alias (str): Name of new command alias. Cannot match command names or existing
        aliases.
macro (str): The macro to run when the alias is executed.

bool: True or False indicating success or failure.

import rhinoscriptsyntax as  rs
rs.AddAlias("OriginLine",  "!_Line 0,0,0")

folder (str): A valid folder, or path, to add.
index (number, optional): Zero-based position in the search path list to insert.
                       If omitted, path will be appended to the end of the
                       search path list.

number: The index where the item was inserted if success.
     -1 on failure.

import rhinoscriptsyntax as rs
rs.AddSearchPath("C:\\My Python Scripts")

number: the number of command aliases in Rhino.

import rhinoscriptsyntax as rs
print("alias count = {}".format(rs.AliasCount()))

alias (str): The name of an existing command alias.
macro (str, optional): The new macro to run when the alias is executed. If omitted, the current alias macro is returned.

str:  If a new macro is not specified, the existing macro if successful.
str:  If a new macro is specified, the previous macro if successful.
null:  None on error

import rhinoscriptsyntax as rs
aliases = rs.AliasNames()
for alias in aliases:
    print("{} -> {}".format(alias, rs.AliasMacro(alias)))

str: a list of command alias names.

import rhinoscriptsyntax as rs
aliases = rs.AliasNames()
for alias in aliases: print(alias)

item (number): Item number to either query or modify
       0  = View background
       1  = Major grid line
       2  = Minor grid line
       3  = X-Axis line
       4  = Y-Axis line
       5  = Selected Objects
       6  = Locked Objects
       7  = New layers
       8  = Feedback
       9  = Tracking
       10 = Crosshair
       11 = Text
       12 = Text Background
       13 = Text hover
color ([r255,g255,b255], optional): The new color value in (r255,g255,b255). If omitted, the current item color is returned.

tuple (r255,g255,b255): if color is not specified, the current item color.
tuple (r255,g255,b255): if color is specified, the previous item color.

import rhinoscriptsyntax as rs
oldColor = rs.AppearanceColor(0)
newColor = rs.GetColor(oldColor)
if newColor is not None:
    rs.AppearanceColor(0, newColor)
    rs.Redraw()

filename (str, optional): Name of the new autosave file

str: if filename is not specified, the name of the current autosave file
str: if filename is specified, the name of the previous autosave file

import rhinoscriptsyntax as rs
file = rs.AutosaveFile()
print("The current autosave file is {}".format(file))

minutes (number, optional): The number of minutes between saves

number: if minutes is not specified, the current interval in minutes
number: if minutes is specified, the previous interval in minutes

import rhinoscriptsyntax as rs
minutes = rs.AutosaveInterval()
if minutes>20: rs.AutosaveInterval(20)

Datetime.date: the build date of Rhino. Will be converted to a string by most functions.

import rhinoscriptsyntax as rs
build = rs.BuildDate()
print("Rhino Build:{}".format(build)

none

import rhinoscriptsyntax as rs
rs.ClearCommandHistory()

commandString (str): A Rhino command including any arguments
echo (bool, optional): The command echo mode True will display the commands on the commandline. If omitted, command prompts are echoed (True)

bool: True or False indicating success or failure

Write command scripts just as you would type the command sequence at the
command line. A space or a new line acts like pressing <Enter> at the
command line. For more information, see "Scripting" in Rhino help.

Note, this function is designed to run one command and one command only.
Do not combine multiple Rhino commands into a single call to this method.
  WRONG:
    rs.Command("_Line _SelLast _Invert")
  CORRECT:
    rs.Command("_Line")
    rs.Command("_SelLast")
    rs.Command("_Invert")

Also, the exclamation point and space character ( ! ) combination used by
button macros and batch-driven scripts to cancel the previous command is
not valid.
  WRONG:
    rs.Command("! _Line _Pause _Pause")
  CORRECT:
    rs.Command("_Line _Pause _Pause")
After the command script has run, you can obtain the identifiers of most
recently created or changed object by calling LastCreatedObjects.

import rhinoscriptsyntax as rs
rs.Command("_Line 0,0,0 2,2,2")
rs.Command("_Line _Pause _Pause")

str: the contents of Rhino's command history window

import rhinoscriptsyntax as rs
print(rs.CommandHistory())

renderer (str, optional): The name of the renderer to set as default renderer.  If omitted the Guid of the current renderer is returned.

guid: Unique identifier of default renderer

import rhinoscriptsyntax as rs
rs.DefaultRenderer("MyRenderPlugIn")

alias (str): The name of an existing alias.

bool: True or False indicating success

import rhinoscriptsyntax as rs
print(rs.DeleteAlias("Hello"))

folder (str): A folder to remove

bool: True or False indicating success

import rhinoscriptsyntax as rs
rs.DeleteSearchPath("C:\\My RhinoScripts")

enable (bool): Whether alerts should be visible (True or False)

none

import System
import rhinoscriptsyntax as rs
rs.DisplayOleAlerts( False )
t = System.Type.GetTypeFromProgID("Excel.Application")
objExcel = System.Activator.CreateObject(t)
...

color (tuple (r255,g255,b255), optional): The new color for the analysis.

tuple (r255,g255,b255): if color is not specified, the current edge analysis color
tuple (r255,g255,b255): if color is specified, the previous edge analysis color

import rhinoscriptsyntax as rs
oldcolor = rs.EdgeAnalysisColor()
newcolor = rs.GetColor(oldcolor)
if newcolor is not None:
    rs.EdgeAnalysisColor(newcolor)

mode (number, optional): The new display mode. The available modes are
             0 - display all edges
             1 - display naked edges

number: if mode is not specified, the current edge analysis mode
number: if mode is specified, the previous edge analysis mode

import rhinoscriptsyntax as rs
previous_mode = rs.EdgeAnalysisMode(1)

enable (bool, optional): The autosave state. If omitted automatic saving is enabled (True)

bool: the previous autosave state

import rhinoscriptsyntax as rs
prevstate = rs.EnableAutosave()

plugin (guid): The unique Guid id of the plugin.
enable (bool, optional): Load silently if True. If omitted Load silently is False.

bool: True if set to load silently otherwise False

import rhinoscriptsyntax as rs
print(rs.EnablePlugIn("RhinoCrasher", False))

str: the full path to Rhino's executable folder.

import rhinoscriptsyntax as rs
folder = rs.ExeFolder()
print(folder)

str: the platform of the Rhino executable

import rhinoscriptsyntax as rs
if rs.ExePlatform() == 1:
    print("You are using a 64-bit version of Rhino.")
else:
    print("You are using a 32-bit version of Rhino.")

str: the service release number of the Rhino executable

import rhinoscriptsyntax as rs
print("Build date:{}".format(rs.BuildDate())
print("SDK Version:{}".format(rs.SdkVersion())
print("SDK Service Release:{}".format(rs.SdkServiceRelease())
print("Executable Version:{}".format(rs.ExeVersion())
print("Executable Service Release:{}".format(rs.ExeServiceRelease())
print("Serial Number:{}".format(rs.SerialNumber())
print("Node Type:{}".format(rs.NodeType())
print("Install Type:{}".format(rs.InstallType())

str: the major version number of the Rhino executable

import rhinoscriptsyntax as rs
print("Build date:{}".format(rs.BuildDate()))
print("SDK Version:{}".format(rs.SdkVersion()))
print("SDK Service Release:{}".format(rs.SdkServiceRelease()))
print("Executable Version:{}".format(rs.ExeVersion()))
print("Executable Service Release:{}".format(rs.ExeServiceRelease()))
print("Serial Number:{}".format(rs.SerialNumber()))
print("Node Type:{}".format(rs.NodeType()))
print("Install Type:{}".format(rs.InstallType()))

none

import rhinoscriptsyntax as rs
rs.Exit()

filename (str): A short file name to search for

str: full path on success

import rhinoscriptsyntax as rs
path = rs.FindFile("Rhino.exe")
print(path)

plug_in (str or guid): The name or Id of a registered plug-in that supports scripting.
                       If the plug-in is registered but not loaded, it will be loaded

guid: scriptable object if successful
null: None on error

import rhinoscriptsyntax as rs
objPlugIn = rs.GetPlugInObject("SomePlugIn")
if objPlugIn is not None:
    print(objPlugIn.About())

ignore_runners (bool, optional): If True, script running commands, such as
                                 LoadScript, RunScript, and ReadCommandFile will not counted.
                                 If omitted the default is not to count script running command (True).

number: the number of active commands

import rhinoscriptsyntax as rs
commands = rs.InCommand()
if commands > 0:
    print("Rhino is running", commands, "command(s).")
else:
    print("Rhino is not running any command(s).")

str: the full path to Rhino's installation folder

import rhinoscriptsyntax as rs
print(rs.InstallFolder())

alias (str): The name of an existing command alias

bool: True if exists or False if the alias does not exist.

import rhinoscriptsyntax as rs
print(rs.IsAlias("Hello"))

command_name (str): The command name to test

bool: True if the string is a command or False if it is not a command.

import rhinoscriptsyntax as rs
cmdname = rs.GetString("Command name to test")
if cmdname is not None:
    iscmd = rs.IsCommand(cmdname)
    if iscmd:
        print("The", cmdname, "command exists.")
    else:
        print("The", cmdname, "command does not exist.")

plugin (guid): The unique id of the plug-in

bool: True if the Guid is registered or False if it is not.

import rhinoscriptsyntax as rs
plugin = rs.GetString("Plug-in name")
if rs.IsPlugIn(plugin): print("The  plug-in is registered.")
else: print("The  plug-in is not registered.")

bool: True if currently running on the Widows platform. False if it is not Windows.

import rhinoscriptsyntax as rs
if rs.IsRunngingOnWindows():
    print("Running on Windows")
else:
    print("Running on Mac")

str: the name of the last executed command

import rhinoscriptsyntax as rs
rs.Command( "Line" )
print("The last command was the {} {}".format(rs.LastCommandName(), "command."))

number: the result code for the last executed command.
          0 = success (command successfully completed)
          1 = cancel (command was cancelled by the user)
          2 = nothing (command did nothing, but was not cancelled)
          3 = failure (command failed due to bad input, computational problem...)
          4 = unknown command (the command was not found)

import rhinoscriptsyntax as rs
rs.Command( "Line" )
result = rs.LastCommandResult()
if result==0:
    print("The command completed.")
else:
    print("The command did not complete.")

number: the current language used for the Rhino interface as a locale ID, or LCID.
          1029  Czech
          1031  German-Germany
          1033  English-United States
          1034  Spanish-Spain
          1036  French-France
          1040  Italian-Italy
          1041  Japanese
          1042  Korean
          1045  Polish

import rhinoscriptsyntax as rs
lcid = rs.LocaleID()
if lcid==1029:
    print("message in Czech")
elif lcid==1031:
    print("message in German")
elif lcid==1033:
    print("message in English")
elif lcid==1034:
    print("message in Spanish")
elif lcid==1036:
    print("message in Italian")
elif lcid==1040:
    print("message in Japanese")
elif lcid==1042:
    print("message in Korean")
elif lcid==1045:
    print("message in Polish")

enable (bool, optional): The new enabled status (True or False). If omitted the current state is returned.

bool: if enable is not specified, then the current ortho status
bool: if enable is specified, then the previous ortho status

import rhinoscriptsyntax as rs
if not rs.Ortho(): rs.Ortho(True)

enable (bool, optional): The new enabled status.

bool: if enable is not specified, then the current osnap status
bool: if enable is specified, then the previous osnap status

import rhinoscriptsyntax as rs
if not rs.Osnap(): rs.Osnap(True)

visible (bool, optional): The new visibility state. If omitted then the current state is returned.

bool: if visible is not specified, then the current visible state
bool: if visible is specified, then the previous visible state

import rhinoscriptsyntax as rs
if not rs.OsnapDialog(): rs.OsnapDialog(True)

mode (number, optional): The object snap mode or modes to set. Object snap modes
               can be added together to set multiple modes
               0          None
               2          Near
               8          Focus
               32         Center
               64         Vertex
               128        Knot
               512        Quadrant
               2048       Midpoint
               8192       Intersection
               131072     End
               524288     Perpendicular
               2097152    Tangent
               134217728  Point

number: if mode is not specified, then the current object snap mode(s)
number: if mode is specified, then the previous object snap mode(s)

import rhinoscriptsyntax as rs
rhOsnapModeEnd = 131072
#add 'End' mode while keeping the ones that are already set
mode = rs.OsnapMode()
rs.OsnapMode(mode + rhOsnapModeEnd)
#add 'End' mode while clearing the others
rs.OsnapMode(rhOsnapModeEnd)

enable (bool, optional): The new enable status.  If omitted the current state is returned.

bool: if enable is not specified, then the current planar status
bool: if enable is secified, then the previous planar status

import rhinoscriptsyntax as rs
if not rs.Planar(): rs.Planar(True)

plugin (guid): Unique id of the plug-in

guid: the id of the plug-in
None: None if the plug-in isn't valid

import rhinoscriptsyntax as rs
plugins = rs.PlugIns(0, 1)
if plugins:
    for plugin in plugins: print(rs.PlugInId(plugin))

types (number, optional): The type of plug-ins to return.
                          0=all
                          1=render
                          2=file export
                          4=file import
                          8=digitizer
                          16=utility.
                          If omitted, all are returned.
status (number, optional): 0=both loaded and unloaded, 1=loaded, 2=unloaded.  If omitted both status is returned.

list of str: list of registered Rhino plug-ins

import rhinoscriptsyntax as rs
plugins = rs.PlugIns(0, 1)
for plugin in plugins: print(plugin)

enable (bool, optional): The new enabled status.  If omitted the current status is returned.

bool: the current object snap projection status

import rhinoscriptsyntax as rs
if not rs.ProjectOsnaps(): rs.ProjectOsnaps(True)

message (str, optional): The new prompt on the commandline.  If omitted the prompt will be blank.

none

import rhinoscriptsyntax as rs
rs.Prompt("Hello Rhino!")

tuple (width, height): containing two numbers identifying the width and height in pixels

import rhinoscriptsyntax as rs
size = rs.ScreenSize()
print("Screen Width: {} pixels".format(size[0]))
print("Screen Height: {} pixels".format(size[1]))

str: the version of the Rhino SDK supported by the executing Rhino. Rhino SDK versions are 9 digit numbers in the form of YYYYMMDDn.

import rhinoscriptsyntax as rs
print("Required SDK Version: {}".format(rs.SdkVersion()))

number: the number of path items in Rhino's search path list

import rhinoscriptsyntax as rs
count = rs.SearchPathCount()
if count>0:
    paths = rs.SearchPathList()
    for path in paths: print(path)

list of str: list of search paths

import rhinoscriptsyntax as rs
count = rs.SearchPathCount()
if count>0:
    paths = rs.SearchPathList()
    for path in paths: print(path)

keys (str, optional): A string of characters to send to the command line.
add_return (bool, optional): Append a return character to the end of the string. If omitted an return character will be added (True)

none

import rhinoscriptsyntax as rs
rs.SendKeystroke( "Hello Rhino!" )
rs.SendKeystrokes( 25/4 )

enable (bool, optional): The new enabled status. If omitted the current status is returned.

bool: the current grid snap status

import rhinoscriptsyntax as rs
if not rs.Snap(): rs.Snap(True)

distance (number, optional): The distance to set the status bar.  If omitted the distance will be set to 0.

none

import rhinoscriptsyntax as rs
rs.StatusBarDistance(3.14159)

message (str, optional): The message to display.

none

import rhinoscriptsyntax as rs
rs.StatusBarMessage("Hello Rhino!")

point (point3d, optional): The 3d coordinates of the status bar.  If omitted the current poition is set to (0,0,0).

none

import rhinoscriptsyntax as rs
pt = (1.1, 2.2, 3.3)
rs.StatusBarPoint(pt)

label (str): Short description of the progesss
lower (str): Lower limit of the progress meter's range
upper (str): Upper limit of the progress meter's range
embed_label (bool, optional): If True, the label will show inside the meter.
                              If false, the label will show to the left of the meter.
                              If omitted the label will show inside the meter (True)
show_percent (bool): Show the percent complete if True. If omitted the percnetage will be shown (True)

bool: True or False indicating success or failure

position (number): The new position in the progress meter
absolute (bool, optional): The position is set absolute (True) or relative (False) to its current position. If omitted the absolute (True) is used.

number: previous position setting.

none

filename (str, optional): The name of the new default template file. If omitted the current default template name is returned.

str: if filename is not specified, then the current default template file
str: if filename is specified, then the previous default template file

import rhinoscriptsyntax as rs
folder = rs.TemplateFolder()
filename = folder + "\\Millimeters.3dm"
rs.TemplateFile(filename)

folder (str, optional): The location of Rhino's template files. Note, the location must exist.

str: if folder is not specified, then the current template file folder
str: if folder is specified, then the previous template file folder

import rhinoscriptsyntax as rs
folder = rs.TemplateFolder()
filename = folder + "\\Millimeters.3dm"
rs.TemplateFile(filename)

IntPt: the Window's handle of Rhino's main window. IntPtr is a platform-specific type that is used to represent a pointer or a handle.

import rhinoscriptsyntax as rs
handle = rs.WindowHandle()
print(handle)

folder (str, optional): The new working folder for the current Rhino session.

str: if folder is not specified, then the current working folder
str: if folder is specified, then the previous working folder

import rhinoscriptsyntax as  rs
folder = rs.WorkingFolder()
folder = rs.BrowseForFolder(folder,  "Directory", "Select Directory")
if folder is not None:
    rs.WorkingFolder(folder)

object_ids ([guid, ....]) objects that will be included in the block
base_point (point): 3D base point for the block definition
name (str, optional): name of the block definition. If omitted a name will be
  automatically generated
delete_input (bool): if True, the object_ids will be deleted

str: name of new block definition on success

import rhinoscriptsyntax as rs
objs = rs.GetObjects("Select objects to define block")
if objs:
    point = rs.GetPoint("Block base point")
    if point:
        block = rs.AddBlock(objs, point, None, True)
        rs.InsertBlock(block, point)

block_name (str): the name of an existing block definition

number: the number of block definitions that contain a specified block definition

import rhinoscriptscriptsyntax as rs
block = rs.GetString("Block name to query")
if rs.IsBlock(block):
    count = rs.BlockContainerCount(block)
    print("This block is nested in {} block(s).".format(count))

block_name (str): the name of an existing block definition

list(str, ...): A list of block definition names

import rhinoscriptsyntax as rs
blockname = rs.GetString("Block name to query")
if rs.IsBlock(blockname):
    blocks = rs.BlockContainers(blockname)
    for block in blocks: print(block)

number: the number of block definitions in the document

import rhinoscriptsyntax as rs
count = rs.BlockCount()
print("There are {} blocks".format(count)

block_name (str): the name of an existing block definition
description (str, optional): The new description.

str: if description is not specified, the current description
str: if description is specified, the previous description

import rhinoscriptsyntax as rs
blockname = rs.GetString("Block name to list description")
if rs.IsBlock(blockname):
    desc = rs.BlockDescription(blockname)
    if desc is None: print("No description")
    else: print(desc)

block_name (str): the name of an existing block definition
where_to_look (number, optional):
  0 = get top level references in active document.
  1 = get top level and nested references in active document.
  2 = check for references from other instance definitions

number: the number of instances of the block in the document

import rhinoscriptsyntax as rs
blockname = rs.GetString("Block to count")
if rs.IsBlock(blockname):
    count = rs.BlockInstanceCount(blockname)
    print("{} block(s) found.".format(count))

object_id (guid): The identifier of an existing block insertion object

point: The insertion 3D point if successful

import rhinoscriptsyntax as rs
strObject = rs.GetObject("Select block")
if rs.IsBlockInstance(strObject):
    rs.AddPoint( rs.BlockInstanceInsertPoint(strObject) )

object_id (guid): The identifier of an existing block insertion object

str: the block name of a block instance

import rhinoscriptsyntax as rs
strObject = rs.GetObject("Select block")
if rs.IsBlockInstance(strObject):
    print(rs.BlockInstanceName(strObject))

block_name (str): the name of an existing block definition
where_to_look (number, optional):
  0 = get top level references in active document.
  1 = get top level and nested references in active document.
  2 = check for references from other instance definitions

list(guid, ...): Ids identifying the instances of a block in the model.

import rhinoscriptsyntax as rs
strBlock = rs.GetString("Block to select")
if rs.IsBlock(strBlock):
    arrObjects = rs.BlockInstances(strBlock)
    if arrobjects:
        rs.SelectObjects(arrObjects)

object_id (guid): The identifier of an existing block insertion object

transform: the location, as a transform matrix, of a block instance relative to the world coordinate
system origin

import rhinoscriptsyntax as rs
obj = rs.GetObject("Select block to query")
if rs.IsBlockInstance(obj):
    arrMatrix = rs.BlockInstanceXform(obj)
    if arrMatrix is not None:
        pointId = rs.AddPoint([0,0,0])
        rs.TransformObject( pointId, arrMatrix)

sort (bool): True to return a sorted list

list(str, ...): the names of all block definitions in the document

import rhinoscriptsyntax as rs
names = rs.BlockNames(True)
if names:
    for name in names: print(name)

block_name (str): name of an existing block definition

number: the number of objects that make up a block definition

import rhinoscriptsyntax as rs
count = rs.BlockObjectCount()
print("There are {} blocks".format(count))

block_name (str): name of an existing block definition

list(guid, ...): list of identifiers on success

import rhinoscriptsyntax as rs
strBlock = rs.GetString("Block name to list identifiers")
if rs.IsBlock(strBlock):
    objects = rs.BlockObjects(strBlock)
    if objects:
        for item in objects: print(item)

block_name (str): name of an existing block definition

str: path to the linked block on success

import rhinoscriptsyntax as rs
strBlock = rs.GetString("Block name to list path")
if rs.IsBlockEmbedded(strBlock):
    print(rs.BlockPath(strBlock))

block_name (str): Name of an existing block

number: the status of a linked block
  Value Description
  -3    Not a linked block definition.
  -2    The linked block definition's file could not be opened or could not be read.
  -1    The linked block definition's file could not be found.
   0    The linked block definition is up-to-date.
   1    The linked block definition's file is newer than definition.
   2    The linked block definition's file is older than definition.
   3    The linked block definition's file is different than definition.

import rhinoscriptsyntax as rs
block = rs.GetString("Block name to list description")
if rs.IsBlock(block):
    status = rs.BlockStatus(block)
    print("block status for {} is {}".format(block, status))

block_name (str): name of an existing block definition

bool: True or False indicating success or failure

import rhinoscriptsyntax as rs
strBlock = rs.GetString("Block name to delete")
if rs.IsBlock(strBlock):
    rs.DeleteBlock(strBlock)

object_id (guid): The identifier of an existing block insertion object
explode_nested_instances (bool, optional): By default nested blocks are not exploded.

list(guid, ...): identifiers for the newly exploded objects on success

import rhinoscriptsyntax as rs
strObject = rs.GetObject("Select block instance to explode")
if rs.IsBlockInstance(strObject):
    rs.ExplodeBlockInstance(strObject)

block_name (str): name of an existing block definition
insertion_point (point): insertion point for the block
scale ({number, number, number]): x,y,z scale factors
angle_degrees (number, optional): rotation angle in degrees
rotation_normal (vector, optional): the axis of rotation.

guid: id for the block that was added to the doc

block_name (str): name of an existing block definition
xform (transform): 4x4 transformation matrix to apply

guid: id for the block that was added to the doc on success

block_name (str): name of an existing block definition

bool: True or False

import rhinoscriptsyntax as rs
strBlock = rs.GetString("Block name")
if rs.IsBlock(strBlock):
    print("The block definition exists.")
else:
    print("The block definition does not exist.")

block_name (str): name of an existing block definition

bool: True or False

import rhinoscriptsyntax as rs
strBlock = rs.GetString("Block name")
if rs.IsBlock(strBlock):
    if rs.IsBlockEmbedded(strBlock):
        print("The block definition is embedded.")
    else:
        print("The block definition is not embedded.")
else:
    print("The block definition does not exist.")

object_id (guid): The identifier of an existing block insertion object

bool: True or False

import rhinoscriptsyntax as rs
obj = rs.GetObject("Select block instance")
if rs.IsBlockInstance(obj):
    print("The object is a block instance.")
else:
    print("The object is not a block instance.")

block_name (str): name of an existing block definition
where_to_look (number, optional): One of the following values
     0 = Check for top level references in active document
     1 = Check for top level and nested references in active document
     2 = Check for references in other instance definitions

bool: True or False

import rhinoscriptsyntax as rs
strBlock = rs.GetString("Block name")
if rs.IsBlock(strBlock):
    if rs.IsBlockInUse(strBlock):
        print("The block definition is in use.")
    else:
        print("The block definition is not in use.")
else:
    print("The block definition does not exist.")

block_name (str): name of an existing block definition

bool: True or False

import rhinoscriptsyntax as rs
strBlock = rs.GetString("Block name")
if rs.IsBlock(strBlock):
    if rs.IsBlockReference(strBlock):
        print("The block definition is a reference definition.")
    else:
        print("The block definition is not a reference definition.")
else:
    print("The block definition does not exist.")

block_name (str): name of an existing block definition
new_name (str): name to change to

bool: True or False indicating success or failure

import rhinoscriptsyntax as rs
strOldBlock = rs.GetString("Old block name")
if strOldBlock:
    strNewBlock = rs.GetString("New block name")
    if strNewBlock:
        rs.RenameBlock (strOldBlock, strNewBlock)

plane (str): plane on which the arc will lie. The origin of the plane will be
  the center point of the arc. x-axis of the plane defines the 0 angle
  direction.
radius(number): radius of the arc
angle_degrees (number): interval of arc in degrees

guid: id of the new curve object

import rhinoscriptsyntax as  rs
plane = rs.WorldXYPlane()
plane = rs.RotatePlane(plane,  45.0, [0,0,1])
rs.AddArc( plane, 5.0, 45.0  )

start, end (point|guid): endpoints of the arc
point_on_arc (point|guid): a point on the arc

guid: id of the new curve object

import rhinoscriptsyntax as rs
start = rs.GetPoint("Start of arc")
if start is not None:
    end = rs.GetPoint("End of arc")
    if end is not None:
        pton = rs.GetPoint("Point on arc")
        if pton is not None:
            rs.AddArc3Pt(start, end, pton)

start (point): the starting point of the arc
direction (vector): the arc direction at start
end (point): the ending point of the arc

guid: id of the new curve object

import rhinoscriptsyntax as rs
pick = rs.GetCurveObject("Select curve to extend")
point = rs.GetPoint("End of extension")
domain = rs.CurveDomain(pick[0])
if abs(pick[4]-domain[0]) < abs(pick[4]-domain[1]):
    origin = rs.CurveStartPoint(pick[0])
    tangent = rs.VectorReverse(rs.CurveTangent(pick[0], domain[0]))
else:
    origin = rs.CurveEndPoint(pick[0])
    tangent = rs.CurveTangent(pick[0], domain[1])
rs.AddArcPtTanPt(origin, tangent, point)

curves ([guid|curve, guid|curve]): list of two curves
parameters ([number, number]): list of two curve parameters defining the blend end points
reverses ([bool, bool]): list of two boolean values specifying to use the natural or opposite direction of the curve
continuities ([number, number]): list of two numbers specifying continuity at end points
                                      0 = position
                                      1 = tangency
                                      2 = curvature

guid: identifier of new curve on success

import rhinoscriptsyntax as rs
curve0 = rs.AddLine((0,0,0), (0,9,0))
curve1 = rs.AddLine((1,10,0), (10,10,0))
curves = curve0, curve1
domain_crv0 = rs.CurveDomain(curve0)
domain_crv1 = rs.CurveDomain(curve1)
params = domain_crv0[1], domain_crv1[0]
revs = False, True
cont = 2,2
rs.AddBlendCurve( curves, params, revs, cont )

plane_or_center (point|plane): plane on which the circle will lie. If a point is
  passed, this will be the center of the circle on the active
  construction plane
radius (number): the radius of the circle

guid: id of the new curve object

import rhinoscriptsyntax as rs
plane = rs.WorldXYPlane()
rs.AddCircle( plane, 5.0 )

first, second, third (point|guid): points on the circle

guid: id of the new curve object

import rhinoscriptsyntax as rs
point1 = rs.GetPoint("First point on circle")
if point1:
    point2 = rs.GetPoint("Second point on circle")
    if point2:
        point3 = rs.GetPoint("Third point on circle")
        if point3:
            rs.AddCircle3Pt(point1, point2, point3)

points ([point|guid, ...]) a list of points
degree (number): degree of the curve

guid: id of the new curve object

import rhinoscriptsyntax as rs
points = rs.GetPoints(True, message1="Pick curve point")
if points: rs.AddCurve(points)

plane (plane) the plane on which the ellipse will lie. The origin of
        the plane will be the center of the ellipse
radiusX, radiusY (number): radius in the X and Y axis directions

guid: id of the new curve object if successful

import rhinoscriptsyntax as rs
plane = rs.WorldXYPlane()
rs.AddEllipse( plane, 5.0, 10.0 )

center (point|guid): center point of the ellipse
second (point|guid): end point of the x axis
third  (point|guid): end point of the y axis

guid: id of the new curve object if successful

import rhinoscriptsyntax as rs
center = (0,0,0)
second = (5,0,0)
third = (0,10,0)
rs.AddEllipse3Pt( center, second, third )

curve0id (guid): identifier of the first curve object
curve1id (guid): identifier of the second curve object
radius (number, optional): fillet radius
base_point0 (point|guid, optional): base point of the first curve. If omitted,
                    starting point of the curve is used
base_point1 (point|guid, optional): base point of the second curve. If omitted,
                    starting point of the curve is used

guid: id of the new curve object if successful

import rhinoscriptsyntax as rs
curve0 = rs.AddLine([0,0,0], [5,1,0])
curve1 = rs.AddLine([0,0,0], [1,5,0])
rs.AddFilletCurve( curve0, curve1 )

surface_id (guid): identifier of the surface to create the curve on
points ([point|guid, point|guid, ...])list of 3D points that lie on the specified surface.
         The list must contain at least 2 points

guid: id of the new curve object if successful

import rhinoscriptsyntax as rs
surface_id = rs.GetObject("Select surface to draw curve on", rs.filter.surface)
if surface_id:
    point1 = rs.GetPointOnSurface( surface_id, "First point on surface")
    if point1:
        point2 = rs.GetPointOnSurface( surface_id, "Second point on surface")
        if point2:
            rs.AddInterpCrvOnSrf( surface_id, [point1, point2])

surface_id (guid): identifier of the surface to create the curve on
points ([[number, number}, [number,number], ...]): a list of 2D surface parameters. The list must contain
                                                   at least 2 sets of parameters

guid: id of the new curve object if successful

import rhinoscriptsyntax as rs
surface_id = rs.GetObject("Select surface to draw curve on", rs.filter.surface)
if surface_id:
    domainU = rs.SurfaceDomain( surface_id, 0)
    u0 = domainU[0]/2
    u1 = domainU[1]/2
    domainV = rs.SurfaceDomain( surface_id, 1)
    v0 = domainV[0]/2
    v1 = domainV[1]/2
    rs.AddInterpCrvOnSrfUV( surface_id, [[u0,v0],[u1,v1]])

points (point|guid, point|guid, ...]): a list containing 3D points to interpolate. For periodic curves,
    if the final point is a duplicate of the initial point, it is
    ignored. The number of control points must be >= (degree+1).
degree (number, optional): The degree of the curve (must be >=1).
    Periodic curves must have a degree >= 2. For knotstyle = 1 or 2,
    the degree must be 3. For knotstyle = 4 or 5, the degree must be odd
knotstyle(opt):
    0 Uniform knots.  Parameter spacing between consecutive knots is 1.0.
    1 Chord length spacing.  Requires degree = 3 with arrCV1 and arrCVn1 specified.
    2 Sqrt (chord length).  Requires degree = 3 with arrCV1 and arrCVn1 specified.
    3 Periodic with uniform spacing.
    4 Periodic with chord length spacing.  Requires an odd degree value.
    5 Periodic with sqrt (chord length) spacing.  Requires an odd degree value.
start_tangent (vector, optional): a vector that specifies a tangency condition at the
    beginning of the curve. If the curve is periodic, this argument must be omitted.
end_tangent (vector, optional): 3d vector that specifies a tangency condition at the
    end of the curve. If the curve is periodic, this argument must be omitted.

guid: id of the new curve object if successful

import rhinoscriptsyntax as rs
points = (0,0,0), (1,1,0), (2,0,0), (3,1,0), (4,0,0), (5,1,0)
rs.AddInterpCurve(points)

start, end (point|guid) end points of the line

guid: id of the new curve object

import rhinoscriptsyntax as rs
start = rs.GetPoint("Start of line")
if start:
    end = rs.GetPoint("End of line")
    if end: rs.AddLine(start, end)

points ([guid|point, guid|point, ...]): a list containing 3D control points
knots ([number, number, ...]): Knot values for the curve. The number of elements in knots must
    equal the number of elements in points plus degree minus 1
degree (number): degree of the curve. must be greater than of equal to 1
weights([number, number, ...], optional) weight values for the curve. Number of elements should
    equal the number of elements in points. Values must be greater than 0

guid: the identifier of the new object if successful, otherwise None

import rhinoscriptsyntax as rs
curve_id = rs.GetObject("Pick a curve", rs.filter.curve)
if curve_id:
    points = rs.CurvePoints(curve_id)
    knots = rs.CurveKnots(curve_id)
    degree = rs.CurveDegree(curve_id)
    newcurve = rs.AddNurbsCurve( points, knots, degree)
    if newcurve: rs.SelectObject(newcurve)

points ([guid|point, guid|point, ...]): list of 3D points. Duplicate, consecutive points will be
         removed. The list must contain at least two points. If the
         list contains less than four points, then the first point and
         last point must be different.
replace_id (guid, optional): If set to the id of an existing object, the object
         will be replaced by this polyline

guid: id of the new curve object if successful

import rhinoscriptsyntax as rs
points = rs.GetPoints(True)
if points: rs.AddPolyline(points)

plane (plane) plane on which the rectangle will lie
width, height (number): width and height of rectangle as measured along the plane's
  x and y axes

guid: id of new rectangle

import rhinoscriptsyntax as rs
plane = rs.WorldXYPlane()
plane = rs.RotatePlane(plane, 45.0, [0,0,1])
rs.AddRectangle( plane, 5.0, 15.0 )

point0 (point|guid): helix axis start point or center of spiral
point1 (point|guid): helix axis end point or point normal on spiral plane
pitch (number): distance between turns. If 0, then a spiral. If > 0 then the
        distance between helix "threads"
turns (number): number of turns
radius0 (number): starting radius of spiral
radius1 (number, optional): ending radius of spiral. If omitted, the starting radius is used for the complete spiral.

guid: id of new curve on success

import rhinoscriptsyntax as rs
point0 = (0,0,0)
point1 = (0,0,10)
pitch = 1
turns = 10
radius0 = 5.0
radius1 = 8.0
rs.AddSpiral(point0, point1, pitch, turns, radius0, radius1)

curve_id (guid): identifier of a closed planar curve object
param0, param1 (number): first and second parameters on the source curve

guid: id of the new curve object if successful

import rhinoscriptsyntax as rs
getresult = rs.GetCurveObject()
if getresult:
    curve_id = getresult[0]
    point0 = rs.GetPointOnCurve( curve_id )
    if point0:
        point1 = rs.GetPointOnCurve( curve_id )
        if point1:
            t0 = rs.CurveClosestPoint( curve_id, point0)
            t1 = rs.CurveClosestPoint( curve_id, point1)
            rs.AddSubCrv( curve_id, t0, t1 )

curve_id (guid): identifier of a curve object
segment_index (number, optional): identifies the curve segment if
curve_id (guid): identifies a polycurve

number: The angle in degrees if successful.

import rhinoscriptsyntax as rs
id = rs.GetObject("Select arc")
if rs.IsArc(id):
    angle = rs.ArcAngle(id)
    print("Arc angle: {}".format(angle))

curve_id (guid): identifier of a curve object
segment_index (number, optional): the curve segment index if `curve_id` identifies a polycurve

point: The 3D center point of the arc if successful.

import rhinoscriptsyntax as rs
id = rs.GetObject("Select arc")
if rs.IsArc(id):
point = rs.ArcCenterPoint(id)
rs.AddPoint(point)

curve_id (guid): identifier of a curve object
segment_index (number, optional): the curve segment index if `curve_id` identifies a polycurve

point: The 3D mid point of the arc if successful.

import rhinoscriptsyntax as rs
id = rs.GetObject("Select arc")
if rs.IsArc(id):
    point = rs.ArcMidPoint(id)
    rs.AddPoint(point)

curve_id (guid): identifier of a curve object
segment_index (number, optional): the curve segment index if `curve_id` identifies a polycurve

number: The radius of the arc if successful.

import rhinoscriptsyntax as rs
id = rs.GetObject("Select arc")
if rs.IsArc(id):
    radius = rs.ArcRadius(id)
    print("Arc radius: {}".format(radius))

curve_id (guid): identifier of a curve object
segment_index (number, optional): the curve segment index if `curve_id` identifies a polycurve
return_plane (bool, optional): if True, the circle's plane is returned. If omitted the plane is not returned.

point: The 3D center point of the circle if successful.
plane: The plane of the circle if return_plane is True

import rhinoscriptsyntax as rs
id = rs.GetObject("Select circle")
if rs.IsCircle(id):
    point = rs.CircleCenterPoint(id)
    rs.AddPoint( point )

curve_id (guid): identifier of a curve object
segment_index (number, optional): the curve segment index if `curve_id` identifies a polycurve

number: The circumference of the circle if successful.

import rhinoscriptsyntax as rs
id = rs.GetObject("Select circle")
if rs.IsCircle(id):
    circumference = rs.CircleCircumference(id)
    print("Circle circumference: {}".format(circumference))

curve_id (guid): identifier of a curve object
segment_index (number, optional): the curve segment index if `curve_id` identifies a polycurve

number: The radius of the circle if successful.

import rhinoscriptsyntax as rs
id = rs.GetObject("Select circle")
if rs.IsCircle(id):
    radius = rs.CircleRadius(id)
    print("Circle radius: {}".format(radius))

curve_id (guid): identifier of a curve object
tolerance (number, optional): maximum allowable distance between start and end
                              point. If omitted, the current absolute tolerance is used

guid: id of the new curve object if successful

import rhinoscriptsyntax as rs
obj = rs.GetObject("Select curve", rs.filter.curve)
if not rs.IsCurveClosed(obj) and rs.IsCurveClosable(obj):
    rs.CloseCurve( obj )

curve_id (guid): identifier of a curve object
direction (vector, optional): 3d vector that identifies up, or Z axs, direction of
                              the plane to test against

number: 1 if the curve's orientation is clockwise
       -1 if the curve's orientation is counter-clockwise
        0 if unable to compute the curve's orientation

curve_id (guid): identifier of a curve object
angle_tolerance (number, optional): The maximum angle between curve tangents at line endpoints.
                                    If omitted, the angle tolerance is set to 5.0.
tolerance(number, optional): The distance tolerance at segment midpoints. If omitted, the tolerance is set to 0.01.
delete_input(bool, optional): Delete the curve object specified by curve_id. If omitted, curve_id will not be deleted.
min_edge_length (number, optional): Minimum segment length
max_edge_length (number, optonal): Maximum segment length

guid: The new curve if successful.

import rhinoscriptsyntax as rs
obj = rs.GetObject("Select a curve")
if rs.IsCurve(obj):
    polyline = rs.ConvertCurveToPolyline(obj)
    if polyline: rs.SelectObject(polyline)

curve_id (guid): identifier of a curve object
length (number): The arc length from the start of the curve to evaluate.
from_start (bool, optional): If not specified or True, then the arc length point is
    calculated from the start of the curve. If False, the arc length
    point is calculated from the end of the curve.

point: on curve if successful

import rhinoscriptsyntax as rs
obj = rs.GetObject("Select a curve")
if rs.IsCurve(obj):
    length = rs.CurveLength(obj)
    point = rs.CurveArcLengthPoint(obj, length/3.0)
    rs.AddPoint( point )

curve_id (guid): The identifier of a closed, planar curve object.

list[number, number]: List of area information. The list will contain the following information:
  Element  Description
  [0]      The area. If more than one curve was specified, the
             value will be the cumulative area.
  [1]      The absolute (+/-) error bound for the area.

import rhinoscriptsyntax as rs
id = rs.GetObject("Select a curve", rs.filter.curve)
if id:
    props = rs.CurveArea(id)
    if props:
        print("The curve area is: {}".format(props[0]))

curve_id (guid)The identifier of a closed, planar curve object.

tuple(point, vector): of area centroid information containing the following information:
  Element  Description
  [0]        The 3d centroid point. If more than one curve was specified,
           the value will be the cumulative area.
  [1]        A 3d vector with the absolute (+/-) error bound for the area
           centroid.

import rhinoscriptsyntax as rs
id = rs.GetObject("Select a curve", rs.filter.curve)
if id:
    props = rs.CurveAreaCentroid(id)
    if props:
        print("The curve area centroid is: {}".format(props[0]))

curve_id (guid): identifier of a curve
arrow_style (number, optional): the style of annotation arrow to be displayed. If omitted the current type is returned.
  0 = no arrows
  1 = display arrow at start of curve
  2 = display arrow at end of curve
  3 = display arrow at both start and end of curve

number: if arrow_style is not specified, the current annotation arrow style
number: if arrow_style is specified, the previous arrow style

import rhinoscriptsyntax as rs
obj = rs.GetObject("Select a curve", rs.filter.curve)
if rs.CurveArrows(obj)!=3: rs.CurveArrows(obj, 3)

curve_id_0 (guid): identifier of the first curve object.
curve_id_1 (guid): identifier of the second curve object.
tolerance (float, optional): a positive tolerance value, or None for the doc default.

list(guid, ...): The identifiers of the new objects if successful, None on error.

import rhinoscriptsyntax as rs
curveA = rs.GetObject("Select first curve", rs.filter.curve)
curveB = rs.GetObject("Select second curve", rs.filter.curve)
arrResult = rs.CurveBooleanDifference(curveA, curveB)
if arrResult:
    rs.DeleteObject( curveA )
    rs.DeleteObject( curveB )

curve_id_0 (guid): identifier of the first curve object.
curve_id_1 (guid): identifier of the second curve object.
tolerance (float, optional): a positive tolerance value, or None for the doc default.

list(guid, ...): The identifiers of the new objects.

import rhinoscriptsyntax as rs
curveA = rs.GetObject("Select first curve", rs.filter.curve)
curveB = rs.GetObject("Select second curve", rs.filter.curve)
result = rs.CurveBooleanIntersection(curveA, curveB)
if result:
    rs.DeleteObject( curveA )
    rs.DeleteObject( curveB )

curve_id ([guid, guid, ...])list of two or more close planar curves identifiers
tolerance (float, optional): a positive tolerance value, or None for the doc default.

list(guid, ...): The identifiers of the new objects.

import rhinoscriptsyntax as rs
curve_ids = rs.GetObjects("Select curves to union", rs.filter.curve)
if curve_ids and len(curve_ids)>1:
    result = rs.CurveBooleanUnion(curve_ids)
    if result: rs.DeleteObjects(curve_ids)

curve_id (guid): identifier of a curve object
brep_id (guid): identifier of a brep object
tolerance (number, optional): distance tolerance at segment midpoints.
                  If omitted, the current absolute tolerance is used.

list(guid, ...): identifiers for the newly created intersection objects if successful.
None: on error.

import rhinoscriptsyntax as rs
curve = rs.GetObject("Select a curve", rs.filter.curve)
if curve:
    brep = rs.GetObject("Select a brep", rs.filter.surface + rs.filter.polysurface)
    if brep: rs.CurveBrepIntersect( curve, brep )

curve_id (guid):identifier of the curve object to test
object_ids ([guid, ...]) list of identifiers of point cloud, curve, surface, or
  polysurface to test against

tuple[guid, point, point]: containing the results of the closest point calculation.
The elements are as follows:
  [0]    The identifier of the closest object.
  [1]    The 3-D point that is closest to the closest object.
  [2]    The 3-D point that is closest to the test curve.

import rhinoscriptsyntax as rs
filter = rs.filter.curve | rs.filter.pointcloud | rs.filter.surface | rs.filter.polysurface
objects = rs.GetObjects("Select target objects for closest point", filter)
if objects:
    curve = rs.GetObject("Select curve")
    if curve:
        results = rs.CurveClosestObject(curve, objects)
        if results:
            print("Curve id: {}".format(results[0]))
            rs.AddPoint( results[1] )
            rs.AddPoint( results[2] )

curve_id (guid): identifier of a curve object
point (point): sampling point
segment_index (number, optional): curve segment index if `curve_id` identifies a polycurve

number: The parameter of the closest point on the curve

import rhinoscriptsyntax as rs
id = rs.GetObject("Select a curve")
if id:
    point = rs.GetPointOnCurve(id, "Pick a test point")
    if point:
        param = rs.CurveClosestPoint(id, point)
        print("Curve parameter: {}".format(param))

curve_id (guid): identifier of a curve object.
start_point (point): 3D starting point of a center line.
end_point (point): 3D ending point of a center line.
interval (number, optional): The distance between contour curves. If omitted,
the interval will be equal to the diagonal distance of the object's
bounding box divided by 50.

list(point, ....): A list of 3D points, one for each contour

import rhinoscriptsyntax as rs
obj = rs.GetObject("Select curve", rs.filter.curve)
start_point = rs.GetPoint("Base point of center line")
end_point = rs.GetPoint("Endpoint of center line", start_point)
contour = rs.CurveContourPoints(obj, start_point, end_point)
if contour: rs.AddPoints(contour)

curve_id (guid): identifier of the curve
parameter (number): parameter to evaluate

tuple[point, vector, point, number, vector]: of curvature information on success
  [0] = point at specified parameter
  [1] = tangent vector
  [2] = center of radius of curvature
  [3] = radius of curvature
  [4] = curvature vector
None: on failure

import rhinoscriptsyntax as rs
obj = rs.GetObject("Select a curve")
if rs.IsCurve(obj):
    point = rs.GetPointOnCurve(obj, "Pick a test point")
    if point:
        param = rs.CurveClosestPoint(obj, point)
        if param:
            data = rs.CurveCurvature(obj, param)
            if data:
                print("Curve curvature evaluation at parameter {}".format(param, ":"))
                print(" 3-D Point: {}".format(data[0]))
                print(" 3-D Tangent: {}".format(data[1]))
                print(" Center of radius of curvature: {}".format(data[2]))
                print(" Radius of curvature: {}".format(data[3]))
                print(" 3-D Curvature: {}".format(data[4]))

curveA (guid): identifier of the first curve object.
curveB  (guid, optional): identifier of the second curve object. If omitted, then a
         self-intersection test will be performed on curveA.
tolerance (number, optional): absolute tolerance in drawing units. If omitted,
                  the document's current absolute tolerance is used.

list of tuples: containing intersection information if successful.
The list will contain one or more of the following elements:
  Element Type     Description
  [n][0]  Number   The intersection event type, either Point (1) or Overlap (2).
  [n][1]  Point3d  If the event type is Point (1), then the intersection point 
                   on the first curve. If the event type is Overlap (2), then
                   intersection start point on the first curve.
  [n][2]  Point3d  If the event type is Point (1), then the intersection point
                   on the first curve. If the event type is Overlap (2), then
                   intersection end point on the first curve.
  [n][3]  Point3d  If the event type is Point (1), then the intersection point 
                   on the second curve. If the event type is Overlap (2), then
                   intersection start point on the second curve.
  [n][4]  Point3d  If the event type is Point (1), then the intersection point
                   on the second curve. If the event type is Overlap (2), then
                   intersection end point on the second curve.
  [n][5]  Number   If the event type is Point (1), then the first curve parameter.
                   If the event type is Overlap (2), then the start value of the
                   first curve parameter range.
  [n][6]  Number   If the event type is Point (1), then the first curve parameter.
                   If the event type is Overlap (2), then the end value of the
                   first curve parameter range.
  [n][7]  Number   If the event type is Point (1), then the second curve parameter.
                   If the event type is Overlap (2), then the start value of the
                   second curve parameter range.
  [n][8]  Number   If the event type is Point (1), then the second curve parameter.
                   If the event type is Overlap (2), then the end value of the 
                   second curve parameter range.

import rhinoscriptsyntax as rs
def ccx():
    curve1 = rs.GetObject("Select first curve", rs.filter.curve)
    if curve1 is None: return
    curve2 = rs.GetObject("Select second curve", rs.filter.curve)
    if curve2 is None: return
    intersection_list = rs.CurveCurveIntersection(curve1, curve2)
    if intersection_list is None:
        print("Selected curves do not intersect.")
        return
    for intersection in intersection_list:
        if intersection[0] == 1:
            print("Point")
            print("Intersection point on first curve:  {}".format(intersection[1]))
            print("Intersection point on second curve:  {}".format(intersection[3]))
            print("First curve parameter:  {}".format(intersection[5]))
            print("Second curve parameter:  {}".format(intersection[7]))
        else:
            print("Overlap")
            print("Intersection start point on first curve: {}".format(intersection[1]))
            print("Intersection end point on first curve: {}".format(intersection[2]))
            print("Intersection start point on second curve: {}".format(intersection[3]))
            print("Intersection end point on second curve: {}".format(intersection[4]))
            print("First curve parameter range: {} to {}".format(intersection[5], intersection[6]))
            print("Second curve parameter range: {} to {}".format(intersection[7], intersection[8]))
ccx()

curve_id (guid): identifier of a curve object.
segment_index (number, optional): the curve segment index if `curve_id` identifies a polycurve.

number: The degree of the curve if successful.
None: on error.

import rhinoscriptsyntax as rs
obj = rs.GetObject("Select a curve")
if rs.IsCurve(obj):
    degree = rs.CurveDegree(obj)
    print("Curve degree:{}".format(degree))

curve_a, curve_b (guid): identifiers of two curves

tuple[number, number, number, number, number, number]: of deviation information on success
  [0] = curve_a parameter at maximum overlap distance point
  [1] = curve_b parameter at maximum overlap distance point
  [2] = maximum overlap distance
  [3] = curve_a parameter at minimum overlap distance point
  [4] = curve_b parameter at minimum overlap distance point
  [5] = minimum distance between curves
None on error

import rhinoscriptsyntax as rs
curveA = rs.GetObject("Select first curve to test", rs.filter.curve)
curveB = rs.GetObject("Select second curve to test", rs.filter.curve)
deviation = rs.CurveDeviation(curveA, curveB)
if deviation:
    print("Minimum deviation = {}".format(deviation[5]))
    print("Maximum deviation = {}".format(deviation[2]))

curve_id (guid): identifier of a curve object.
segment_index (number, optional): the curve segment if `curve_id` identifies a polycurve.

number: The dimension of the curve if successful. None on error.

import rhinoscriptsyntax as rs
curve = rs.GetObject("Select a curve")
if rs.IsCurve(curve):
    print("Curve dimension = {}".format(rs.CurveDim(curve)))

curve_id_0 (guid): identifier of first curve object
curve_id_1 (guid): identifier of second curve object

bool: True if the curve directions match, otherwise False.

import rhinoscriptsyntax as rs
curve1 = rs.GetObject("Select first curve to compare", rs.filter.curve)
curve2 = rs.GetObject("Select second curve to compare", rs.filter.curve)
if rs.CurveDirectionsMatch(curve1, curve2):
    print("Curves are in the same direction")
else:
    print("Curve are not in the same direction")

curve_id (guid): identifier of curve object
style (number): The type of continuity to test for. The types of
    continuity are as follows:
    Value    Description
    1        C0 - Continuous function
    2        C1 - Continuous first derivative
    3        C2 - Continuous first and second derivative
    4        G1 - Continuous unit tangent
    5        G2 - Continuous unit tangent and curvature

list(point, ...): 3D points where the curve is discontinuous

import rhinoscriptsyntax as rs
curve = rs.GetObject("Select a curve", rs.filter.curve)
if rs.IsCurve(curve):
    points = rs.CurveDiscontinuity(curve, 2)
    if points: rs.AddPoints( points )

curve_id (guid): identifier of the curve object
segment_index (number, optional): the curve segment index if `curve_id` identifies a polycurve.

list(number, number): the domain of the curve if successful.
   [0] Domain minimum
   [1] Domain maximum
None: on error

import rhinoscriptsyntax as rs
obj = rs.GetObject("Select a curve")
if rs.IsCurve(obj):
    domain = rs.CurveDomain(obj)
    print("Curve domain: {} to {}".format(domain[0], domain[1]))

curve_id (guid): identifier of the curve object
return_parameters (bool, optional): if True, return as a list of curve parameters.
                                    If False, return as a list of 3d points
segment_index (number, optional): the curve segment index is `curve_id` identifies a polycurve

list(point, ....): curve edit points on success
None on error

import rhinoscriptsyntax as rs
obj = rs.GetObject("Select a curve")
if rs.IsCurve(obj):
    points = rs.CurveEditPoints(obj)
    if points: rs.AddPointCloud( points )

curve_id (guid): identifier of the curve object
segment_index (number, optional): the curve segment index if `curve_id` identifies a polycurve

point: The 3d endpoint of the curve if successful.
None: on error

import rhinoscriptsyntax as rs
object = rs.GetObject("Select a curve")
if rs.IsCurve(object):
    point = rs.CurveEndPoint(object)
    rs.AddPoint(point)

curve_id_0 (guid): identifier of the first curve object.
curve_id_1 (guid): identifier of the second curve object.
radius (number, optional): The fillet radius. If omitted, a radius
               of 1.0 is specified.
base_point_0 (point, optional): The base point on the first curve.
               If omitted, the starting point of the curve is used.
base_point_1 (point, optional): The base point on the second curve. If omitted,
               the starting point of the curve is used.
return_points (bool, optional): If True (Default), then fillet points are
               returned. Otherwise, a fillet curve is created and
               it's identifier is returned.

list(point, point, point, vector, vector, vector): If return_points is True, then a list of point and vector values
if successful. The list elements are as follows:
    [0]    A point on the first curve at which to cut (point).
    [1]    A point on the second curve at which to cut (point).
    [2]    The fillet plane's origin (point). This point is also
             the center point of the fillet
    [3]    The fillet plane's X axis (vector).
    [4]    The fillet plane's Y axis (vector).
    [5]    The fillet plane's Z axis (vector).
      
guid: If return_points is False, then the identifier of the fillet curve
      if successful.
None: if not successful, or on error.

import rhinoscriptsyntax as rs
curve0 = rs.AddLine([0,0,0], [5,1,0])
curve1 = rs.AddLine([0,0,0], [1,5,0])
fillet = rs.CurveFilletPoints(curve0, curve1)
if fillet:
    rs.AddPoint( fillet[0] )
    rs.AddPoint( fillet[1] )
    rs.AddPoint( fillet[2] )

curve_id (guid): identifier of the curve object.
parameter (number): parameter to evaluate.
segment_index (number, optional): the curve segment index if `curve_id` identifies a polycurve

plane: The plane at the specified parameter if successful.
None: if not successful, or on error.

import rhinoscriptsyntax as rs
curve = rs.GetCurveObject("Select a curve")
if curve:
    plane = rs.CurveFrame(curve[0], curve[4])
    rs.AddPlaneSurface(plane, 5.0, 3.0)

curve_id (guid): identifier of the curve object.
segment_index (number, optional): the curve segment if `curve_id` identifies a polycurve.

number: The number of knots if successful.
None: if not successful or on error.

import rhinoscriptsyntax as rs
obj = rs.GetObject("Select a curve")
if rs.IsCurve(obj):
    count = rs.CurveKnotCount(obj)
    print("Curve knot count:{}".format(count))

curve_id (guid): identifier of the curve object.
segment_index (number, optional): the curve segment index if `curve_id` identifies a polycurve.

list(number, ....): knot values if successful.
None: if not successful or on error.

import rhinoscriptsyntax as rs
obj = rs.GetObject("Select a curve")
if rs.IsCurve(obj):
    knots = rs.CurveKnots(obj)
    if knots:
        for knot in knots: print("Curve knot value:{}".format(knot))

curve_id (guid): identifier of the curve object
segment_index (number, optional): the curve segment index if `curve_id` identifies a polycurve
sub_domain ([number, number], optional): list of two numbers identifying the sub-domain of the
    curve on which the calculation will be performed. The two parameters
    (sub-domain) must be non-decreasing. If omitted, the length of the
    entire curve is returned.

number: The length of the curve if successful.
None: if not successful, or on error.

import rhinoscriptsyntax as rs
object = rs.GetObject("Select a curve")
if rs.IsCurve(object):
    length = rs.CurveLength(object)
    print("Curve length:{}".format(length))

curve_id (guid): identifier of the curve object
segment_index (number, optional): the curve segment index if `curve_id` identifies a polycurve

point: The 3D midpoint of the curve if successful.
None: if not successful, or on error.

import rhinoscriptsyntax as rs
object = rs.GetObject("Select a curve")
if rs.IsCurve(object):
    point = rs.CurveMidPoint(pbject)
    rs.AddPoint( point )

curve_id (guid): identifier of the curve object
segment_index (number, optional): the curve segment if curve_id identifies a polycurve

vector: The 3D normal vector if successful.
None: if not successful, or on error.

import rhinoscriptsyntax as rs
object = rs.GetObject("Select a planar curve")
if rs.IsCurve(object) and rs.IsCurvePlanar(object):
    normal = rs.CurveNormal(object)
    if normal: print("Curve Normal:{}".format(normal))

curve_id (guid): identifier of the curve object
parameter (number): the curve parameter to convert

number: normalized curve parameter

import rhinoscriptsyntax as rs
obj = rs.GetObject("Select curve")
if rs.IsCurve(obj):
    domain = rs.CurveDomain(obj)
    parameter = (domain[0]+domain[1])/2.0
    print("Curve parameter:{}".format(parameter))
    normalized = rs.CurveNormalizedParameter(obj, parameter)
    print("Normalized parameter:{}".format(normalized))

curve_id (guid): identifier of the curve object
parameter (number): the normalized curve parameter to convert

number: curve parameter

import rhinoscriptsyntax as rs
obj = rs.GetObject("Select curve")
if rs.IsCurve(obj):
    normalized = 0.5
    print("Normalized parameter:{}".format(normalized))
    parameter = rs.CurveParameter(obj, normalized)
    print("Curve parameter:{}".format(parameter))

curve_id (guid): identifier of the curve object
parameter (number): parameter to evaluate

plane: Plane on success
None: on error

import rhinoscriptsyntax as rs
crv = rs.GetCurveObject("Select a curve")
if crv:
    plane = rs.CurvePerpFrame(crv[0], crv[4])
    rs.AddPlaneSurface( plane, 1, 1 )

curve_id (guid): identifier of the curve object
segment_index (number, optional): the curve segment index if `curve_id` identifies a polycurve

plane: The plane in which the curve lies if successful.
None: if not successful, or on error.

import rhinoscriptsyntax as rs
curve = rs.GetObject("Select a curve", rs.filter.curve)
if rs.IsCurvePlanar(curve):
    plane = rs.CurvePlane(curve)
    rs.ViewCPlane(None, plane)

curve_id (guid) identifier of the curve object
segment_index (number, optional): the curve segment if `curve_id` identifies a polycurve

number: Number of control points if successful.
None: if not successful

import rhinoscriptsyntax as rs
obj = rs.GetObject("Select a curve")
if rs.IsCurve(obj):
    count = rs.CurvePointCount(obj)
    print("Curve point count:{}".format(count))

curve_id (guid): the object's identifier
segment_index (number, optional): the curve segment if `curve_id` identifies a polycurve

list(point, ...): the control points, or control vertices, of a curve object

import rhinoscriptsyntax as rs
obj = rs.GetObject("Select a curve")
if rs.IsCurve(obj):
    points = rs.CurvePoints(obj)
    if points: [rs.AddPoint(pt) for pt in points]

curve_id (guid): identifier of the curve object
test_point (point): sampling point
segment_index (number, optional): the curve segment if curve_id identifies a polycurve

number: The radius of curvature at the point on the curve if successful.
None: if not successful, or on error.

import rhinoscriptsyntax as rs
obj = rs.GetObject("Select a curve")
if rs.IsCurve(obj):
    point = rs.GetPointOnCurve(obj, "Pick a test point")
    if point:
        radius = rs.CurveRadius(obj, point)
        print("Radius of curvature:{}".format(radius))

curve_id (guid): identifier of the curve object
parameter (number): The parameter of the new start/end point.
            Note, if successful, the resulting curve's
            domain will start at `parameter`.

bool: True or False indicating success or failure.

import rhinoscriptsyntax as rs
obj = rs.GetObject("Select closed curve", rs.filter.curve)
if rs.IsCurveClosed(obj):
    domain = rs.CurveDomain(obj)
    parameter = (domain[0] + domain[1])/2.0
    rs.CurveSeam( obj, parameter )

curve_id (guid): identifier of the curve object
segment_index (number, optional): the curve segment index if `curve_id` identifies a polycurve
point (point, optional): new start point

point: The 3D starting point of the curve if successful.

import rhinoscriptsyntax as rs
object = rs.GetObject("Select a curve")
if rs.IsCurve(object):
    point = rs.CurveStartPoint(object)
    rs.AddPoint(point)

curve_id (guid): The identifier of the first curve object.
surface_id (guid): The identifier of the second curve object. If omitted,
    the a self-intersection test will be performed on curve.
tolerance (number, optional): The absolute tolerance in drawing units. If omitted,
    the document's current absolute tolerance is used.
angle_tolerance (number, optional) angle tolerance in degrees. The angle
    tolerance is used to determine when the curve is tangent to the
    surface. If omitted, the document's current angle tolerance is used.

list(list(point, point, point, point, number, number, number, number, number, number), ...): of intersection information if successful.
The list will contain one or more of the following elements:
  Element Type     Description
  [n][0]  Number   The intersection event type, either Point(1) or Overlap(2).
  [n][1]  Point3d  If the event type is Point(1), then the intersection point
                   on the first curve. If the event type is Overlap(2), then
                   intersection start point on the first curve.
  [n][2]  Point3d  If the event type is Point(1), then the intersection point
                   on the first curve. If the event type is Overlap(2), then
                   intersection end point on the first curve.
  [n][3]  Point3d  If the event type is Point(1), then the intersection point
                   on the second curve. If the event type is Overlap(2), then
                   intersection start point on the surface.
  [n][4]  Point3d  If the event type is Point(1), then the intersection point
                   on the second curve. If the event type is Overlap(2), then
                   intersection end point on the surface.
  [n][5]  Number   If the event type is Point(1), then the first curve parameter.
                   If the event type is Overlap(2), then the start value of the
                   first curve parameter range.
  [n][6]  Number   If the event type is Point(1), then the first curve parameter.
                   If the event type is Overlap(2), then the end value of the
                   curve parameter range.
  [n][7]  Number   If the event type is Point(1), then the U surface parameter.
                   If the event type is Overlap(2), then the U surface parameter
                   for curve at (n, 5).
  [n][8]  Number   If the event type is Point(1), then the V surface parameter.
                   If the event type is Overlap(2), then the V surface parameter
                   for curve at (n, 5).
  [n][9]  Number   If the event type is Point(1), then the U surface parameter.
                   If the event type is Overlap(2), then the U surface parameter
                   for curve at (n, 6).
  [n][10] Number   If the event type is Point(1), then the V surface parameter.
                   If the event type is Overlap(2), then the V surface parameter
                   for curve at (n, 6).

import rhinoscriptsyntax as rs
def csx():
    curve = rs.GetObject("Select curve", rs.filter.curve)
    if curve is None: return
    surface = rs.GetObject("Select surface", rs.filter.surface)
    if surface is None: return
    intersection_list = rs.CurveSurfaceIntersection(curve, surface)
    if intersection_list is None:
        print("Curve and surface do not intersect.")
        return
    for intersection in intersection_list:
        if intersection[0]==1:
            print("Point")
            print("Intersection point on curve:{}".format(intersection[1]))
            print("Intersection point on surface:{}".format(intersection[3]))
            print("Curve parameter:{}".format(intersection[5]))
            print("Surface parameter: {}, {}".format(intersection[7], intersection[8]))
        else:
            print("Overlap")
            print("Intersection start point on curve:{}".format(intersection[1]))
            print("Intersection end point on curve:{}".format(intersection[2]))
            print("Intersection start point on surface:{}".format(intersection[3]))
            print("Intersection end point on surface:{}".format(intersection[4]))
            print("Curve parameter range: {} to {}".format(intersection[5], intersection[6]))
            print("Surface parameter range: {}, {} to {}, {}".format(intersection[7] intersection[8], intersection[9], intersection[10]))
csx()

curve_id (guid): identifier of the curve object
parameter (number) parameter to evaluate
segment_index (number, optional) the curve segment index if `curve_id` identifies a polycurve

vector: A 3D vector if successful.
None: on error.

import rhinoscriptsyntax as rs
obj = rs.GetObject("Select a curve", rs.filter.curve)
if obj:
    point = rs.GetPointOnCurve(obj)
    if point:
        param = rs.CurveClosestPoint(obj, point)
        normal = rs.CurveTangent(obj, param)
        print(normal)

curve_id (guid): identifier of the curve object
segment_index (number, optional): the curve segment index if `curve_id` identifies a polycurve

number: The weight values of the curve if successful.
None: if not successful, or on error.

import rhinoscriptsyntax as rs
obj = rs.GetObject("Select a curve")
if rs.IsCurve(obj):
    weights = rs.CurveWeights(obj)
    if weights:
        for weight in weights:
            print("Curve control point weight value:{}".format(weight))

curve_id (guid):identifier of the curve object
segments (number): The number of segments.
create_points (bool, optional): Create the division points. If omitted or False,
    points are not created.
return_points (bool, optional): If omitted or True, points are returned.
    If False, then a list of curve parameters are returned.

list(point|number, ...): If `return_points` is not specified or True, then a list containing 3D division points.
list(point|number, ...): If `return_points` is False, then an array containing division curve parameters.
None: if not successful, or on error.

import rhinoscriptsyntax as rs
obj = rs.GetObject("Select a curve")
if obj:
    points = rs.DivideCurve(obj, 4)
    for point in points: rs.AddPoint(point)

curve_id (guid): the object's identifier
distance (number): linear distance between division points
create_points (bool, optional): create the division points if True.
return_points (bool, optional): If True, return a list of points.
                                If False, return a list of curve parameters

list(point|number, ...): points or curve parameters based on the value of return_points
none on error

import rhinoscriptsyntax as rs
obj = rs.GetObject("Select a curve", rs.filter.curve)
if obj:
    points = rs.DivideCurveEquidistant(obj, 4, True)

curve_id (guid): identifier of the curve object
length (number): The length of each segment.
create_points (bool, optional): Create the division points. If omitted or False,
    points are not created.
return_points (bool, optional): If omitted or True, points are returned.
    If False, then a list of curve parameters are returned.

list(point, ...): If return_points is not specified or True, then a list containing division points.
list(number, ...): If return_points is False, then an array containing division curve parameters.
None: if not successful, or on error.

import rhinoscriptsyntax as rs
obj = rs.GetObject("Select a curve")
if rs.IsCurve(obj):
    length = rs.CurveLength(obj) / 4
    points = rs.DivideCurveLength(obj, length)
    for point in points: rs.AddPoint(point)

curve_id (guid): identifier of the curve object.

point: The 3D center point of the ellipse if successful.

import rhinoscriptsyntax as rs
obj = rs.GetObject("Select ellipse")
if rs.IsEllipse(obj):
    point = rs.EllipseCenterPoint(obj)
    rs.AddPoint( point )

curve_id (guid): identifier of the curve object.

list(point, point, point, point): Four points identifying the quadrants of the ellipse

import rhinoscriptsyntax as rs
obj = rs.GetObject("Select ellipse")
if rs.IsEllipse(obj):
    rs.AddPoints( rs.EllipseQuadPoints(obj) )

curve_id (guid): identifier of the curve object
t (number): the parameter to evaluate
segment_index (number, optional): the curve segment index if `curve_id` identifies a polycurve

point: a 3-D point if successful
None: if not successful

import rhinoscriptsyntax as rs
obj = rs.GetObject("Select a curve")
if rs.IsCurve(obj):
    domain = rs.CurveDomain(obj)
    t = domain[1]/2.0
    point = rs.EvaluateCurve(obj, t)
    rs.AddPoint( point )

curve_ids (guid): the curve object(s) to explode.
delete_input (bool, optional): Delete input objects after exploding if True.

list(guid, ...): identifying the newly created curve objects

import rhinoscriptsyntax as rs
crv = rs.GetObject("Select curve to explode", rs.filter.curve)
if rs.IsCurve(crv): rs.ExplodeCurves(crv)

curve_id (guid): identifier of curve to extend
extension_type (number):
  0 = line
  1 = arc
  2 = smooth
side (number):
  0=extend from the start of the curve
  1=extend from the end of the curve
  2=extend from both the start and the end of the curve
boundary_object_ids (guid): curve, surface, and polysurface objects to extend to

guid: The identifier of the new object if successful.
None: if not successful

import rhinoscriptsyntax as rs
filter = rs.filter.curve | rs.filter.surface | rs.filter.polysurface
objects = rs.GetObjects("Select boundary objects", filter)
if objects:
    curve = rs.GetObject("Select curve to extend", rs.filter.curve)
    if curve: rs.ExtendCurve( curve, 2, 1, objects )

curve_id (guid): curve to extend
extension_type (number):
  0 = line
  1 = arc
  2 = smooth
side (number):
  0=extend from start of the curve
  1=extend from end of the curve
  2=Extend from both ends
length (number): distance to extend

guid: The identifier of the new object
None: if not successful

import rhinoscriptsyntax as rs
curve = rs.GetObject("Select curve to extend", rs.filter.curve)
if curve:
    length = rs.GetReal("Length to extend", 3.0)
    if length: rs.ExtendCurveLength( curve, 2, 2, length )

curve_id (guid): curve to extend
side (number):
  0=extend from start of the curve
  1=extend from end of the curve
point (guid|point): point to extend to
extension_type (number, optional): type of extension
  0 = Line
  1 = Arc
  2 = Smooth

guid: The identifier of the new object if successful.
None: if not successful, or on error.

import rhinoscriptsyntax as rs
curve = rs.GetObject("Select curve to extend", rs.filter.curve)
if curve:
    point = rs.GetPoint("Point to extend to")
    if point: rs.ExtendCurvePoint(curve, 1, point)

curve_id (guid): curve to fair
tolerance (number, optional): fairing tolerance

bool: True or False indicating success or failure

import rhinoscriptsyntax as rs
curves = rs.GetObjects("Select curves to fair", rs.filter.curve)
if curves:
    [rs.FairCurve(curve) for curve in curves]

curve_id (guid): Identifier of the curve object
degree (number, optional): The curve degree, which must be greater than 1.
               The default is 3.
distance_tolerance (number, optional): The fitting tolerance. If distance_tolerance
    is not specified or <= 0.0, the document absolute tolerance is used.
angle_tolerance (number, optional): The kink smoothing tolerance in degrees. If
    angle_tolerance is 0.0, all kinks are smoothed. If angle_tolerance
    is > 0.0, kinks smaller than angle_tolerance are smoothed. If
    angle_tolerance is not specified or < 0.0, the document angle
    tolerance is used for the kink smoothing.

guid: The identifier of the new object
None: if not successful, or on error.

import rhinoscriptsyntax as rs
oldCurve = rs.GetObject("Select curve to fit", rs.filter.curve)
if oldCurve:
    newCurve = rs.FitCurve(oldCurve)
    if newCurve: rs.DeleteObject(oldCurve)

curve_id (guid): identifier of the curve object
parameter (number): parameter on the curve
symmetrical (bool, optional): if True, then knots are added on both sides of
    the center of the curve

bool: True or False indicating success or failure

import rhinoscriptsyntax as rs
obj = rs.GetObject("Select curve for knot insertion", rs.filter.curve)
if obj:
    point = rs.GetPointOnCurve(obj, "Point on curve to add knot")
    if point:
        parameter = rs.CurveClosestPoint(obj, point)
        rs.InsertCurveKnot( obj, parameter )

curve_id (guid): Identifier of the curve object
segment_index (number): the curve segment index if `curve_id` identifies a polycurve

bool: True or False

import rhinoscriptsyntax as rs
obj = rs.GetObject("Select an arc")
if rs.IsArc(obj):
    print("The object is an arc.")
else:
    print("The object is not an arc.")

curve_id (guid): Identifier of the curve object
tolerance (number, optional) If the curve is not a circle, then the tolerance used
  to determine whether or not the NURBS form of the curve has the
  properties of a circle. If omitted, Rhino's internal zero tolerance is used

bool: True or False

import rhinoscriptsyntax as rs
obj = rs.GetObject("Select a circle")
if rs.IsCircle(obj):
    print("The object is a circle.")
else:
    print("The object is not a circle.")

object_id (guid): the object's identifier

bool: True or False

import rhinoscriptsyntax as rs
object = rs.GetObject("Select a curve")
if rs.IsCurve(object):
    print("The object is a curve.")
else:
    print("The object is not a curve.")

curve_id (guid): identifier of the curve object
tolerance[opt] = maximum allowable distance between start point and end
  point. If omitted, the document's current absolute tolerance is used

bool: True or False

import rhinoscriptsyntax as rs
crv = rs.GetObject("Select curve", rs.filter.curve)
if not rs.IsCurveClosed(crv) and rs.IsCurveClosable(crv):
    rs.CloseCurve( crv, 0.1 )

object_id (guid): the object's identifier

bool: True if successful otherwise False.  None on error

import rhinoscriptsyntax as rs
object = rs.GetObject("Select a curve")
if rs.IsCurve(object):
    if rs.IsCurveClosed(oObject):
        print("The object is a closed curve.")
    else:
        print("The object is not a closed curve.")
else:
    print("The object is not a curve.")

object_id (guid): the object's identifier
plane (plane, optional): plane to test. If omitted, the active construction plane is used

bool: True or False

import rhinoscriptsyntax as rs
obj = rs.GetObject("Select a curve")
if rs.IsCurve(obj) and rs.IsCurvePlanar(obj):
    if rs.IsCurveInPlane(obj):
        print("The curve lies in the current cplane.")
    else:
        print("The curve does not lie in the current cplane.")
else:
    print("The object is not a planar curve.")

curve_id (guid):identifier of the curve object
segment_index (number): the curve segment index if `curve_id` identifies a polycurve

bool: True or False indicating success or failure

import rhinoscriptsyntax as rs
id = rs.GetObject("Select a curve")
if rs.IsCurve(id):
    if rs.IsCurveLinear(id):
        print("The object is a linear curve.")
    else:
        print("The object is not a linear curve.")
else:
    print("The object is not a curve.")

curve_id (guid): identifier of the curve object
segment_index (number, optional): the curve segment index if `curve_id` identifies a polycurve

bool: True or False

import rhinoscriptsyntax as rs
obj = rs.GetObject("Select a curve")
if rs.IsCurve(obj):
    if rs.IsCurvePeriodic(obj):
        print("The object is a periodic curve.")
    else:
        print("The object is not a periodic curve.")
else:
    print("The object is not a curve.")

curve_id (guid): identifier of the curve object
segment_index (number, optional): the curve segment index if `curve_id` identifies a polycurve

bool: True or False indicating success or failure

import rhinoscriptsyntax as rs
obj = rs.GetObject("Select a curve")
if rs.IsCurve(obj):
    if rs.IsCurvePlanar(obj):
        print("The object is a planar curve.")
    else:
        print("The object is not a planar curve.")
else:
    print("The object is not a curve.")

curve_id (guid): identifier of the curve object
segment_index (number, optional): the curve segment index if `curve_id` identifies a polycurve

bool: True or False indicating success or failure

import rhinoscriptsyntax as rs
obj = rs.GetObject("Select a curve")
if rs.IsCurve(obj):
    if rs.IsCurveRational(obj):
        print("The object is a rational NURBS curve.")
    else:
        print("The object is not a rational NURBS curve.")
else:
    print("The object is not a curve.")

curve_id (guid): identifier of the curve object
segment_index (number, optional): the curve segment index if `curve_id` identifies a polycurve

bool: True or False indicating success or failure

import rhinoscriptsyntax as rs
obj = rs.GetObject("Select an ellipse")
if rs.IsEllipse(obj):
    print("The object is an ellipse.")
else:
    print("The object is not an ellipse.")

curve_id (guid): identifier of the curve object
segment_index (number, optional): the curve segment index if `curve_id` identifies a polycurve

bool: True or False indicating success or failure

import rhinoscriptsyntax as rs
obj = rs.GetObject("Select a line")
if rs.IsLine(obj):
    print("The object is a line.")
else:
    print("The object is not a line.")

curve_id (guid): identifier of the curve object
point (point): the test point
segment_index (number, optional): the curve segment index if `curve_id` identifies a polycurve

bool: True or False indicating success or failure

import rhinoscriptsyntax as rs
obj = rs.GetObject("Select a curve")
if rs.IsCurve(obj):
    point = rs.GetPoint("Pick a test point")
    if point:
        if rs.IsPointOnCurve(obj, point):
            print("The point is on the curve")
        else:
            print("The point is not on the curve")

curve_id (guid): identifier of the curve object
segment_index (number, optional) the curve segment index if `curve_id` identifies a polycurve

bool: True or False

import rhinoscriptsyntax as rs
obj = rs.GetObject("Select a polycurve")
if rs.IsPolyCurve(obj):
    print("The object is a polycurve.")
else:
    print("The object is not a polycurve.")

curve_id (guid): identifier of the curve object
segment_index (number, optional): the curve segment index if `curve_id` identifies a polycurve

bool: True or False

import rhinoscriptsyntax as rs
obj = rs.GetObject("Select a polyline")
if rs.IsPolyline(obj):
    print("The object is a polyline.")
else:
    print("The object is not a polyline.")

object_ids (guid): list of multiple curves
delete_input (bool, optional): delete input objects after joining
tolerance (number, optional): join tolerance. If omitted, 2.1 * document absolute
    tolerance is used

list(guid, ...): Object id representing the new curves

import rhinoscriptsyntax as rs
objs = rs.GetObjects("Select curves to join", rs.filter.curve)
if objs: rs.JoinCurves(objs)

points ([point, point, ...]): a list of at least two 3D points

line: line on success

import rhinoscriptsyntax as rs
points = rs.GetPoints()
if points and len(points)>1:
    line=rs.LineFitFromPoints(points)
    if line: rs.AddLine(line.From, line.To)

curve_id (guid): identifier of the curve object
delete_input (bool): delete the input curve. If omitted, the input curve will not be deleted.

guid: id of the new or modified curve if successful
None: on error

import rhinoscriptsyntax as rs
curve = rs.GetObject("Select a curve", rs.filter.curve)
if rs.IsCurvePeriodic(curve): rs.MakeCurveNonPeriodic( curve )

curve0, curve1 (guid): identifiers of two curves
tolerance (number, optional): angle tolerance used to match kinks between curves

guid: id of the new or modified curve if successful
None: on error

import rhinoscriptsyntax as rs
curve0 = rs.GetObject("Select the first curve", rs.filter.curve)
curve1 = rs.GetObject("Select the second curve", rs.filter.curve)
rs.MeanCurve( curve0, curve1 )

polyline_id (guid): identifier of the polyline curve object

guid: identifier of the new mesh object
None: on error

import rhinoscriptsyntax as rs
polyline = rs.GetObject("Select a polyline", rs.filter.curve)
if polyline:
    if rs.IsPolyline(polyline) and rs.IsCurveClosed(polyline):
        rs.MeshPolyline( polyline )

object_id (guid): identifier of a curve object
direction (point): point describing direction of the offset
distance (number): distance of the offset
normal (vector, optional): normal of the plane in which the offset will occur.
    If omitted, the normal of the active construction plane will be used
style (number, optional): the corner style. If omitted, the style is sharp.
                          0 = None
                          1 = Sharp
                          2 = Round
                          3 = Smooth
                          4 = Chamfer

list(guid, ...): list of ids for the new curves on success
None: on error

import rhinoscriptsyntax as rs
obj = rs.GetObject("Select a curve", rs.filter.curve)
if rs.IsCurve(obj):
    rs.OffsetCurve( obj, [0,0,0], 1.0 )

curve_id, surface_id (guid): curve and surface identifiers
distance_or_parameter (number|tuple(number, number)): If a single number is passed, then this is the
  distance of the offset. Based on the curve's direction, a positive value
  will offset to the left and a negative value will offset to the right.
  If a tuple of two values is passed, this is interpreted as the surface
  U,V parameter that the curve will be offset through

list(guid, ...): identifiers of the new curves if successful
None: on error

import rhinoscriptsyntax as rs
def TestOffset():
    curve = rs.GetObject("Select curve on a surface", rs.filter.curve)
    if curve is None: return False
    surface = rs.GetObject("Select base surface", rs.filter.surface)
    if surface is None: return False
    point = rs.GetPointOnSurface( surface, "Through point" )
    if point is None: return False
    parameter = rs.SurfaceClosestPoint(surface, point)
    rc = rs.OffsetCurveOnSurface( curve, surface, parameter )
    return rc is not None
       
TestOffset()

curve_a, curve_b (guid): identifiers of two planar, closed curves
plane (plane, optional): test plane. If omitted, the currently active construction
  plane is used
tolerance (number, optional): if omitted, the document absolute tolerance is used

number: a number identifying the relationship if successful
  0 = the regions bounded by the curves are disjoint
  1 = the two curves intersect
  2 = the region bounded by curve_a is inside of curve_b
  3 = the region bounded by curve_b is inside of curve_a
None: if not successful

import rhinoscriptsyntax as rs
curve1 = rs.GetObject("Select first curve", rs.filter.curve )
curve2 = rs.GetObject("Select second curve", rs.filter.curve )
if rs.IsCurvePlanar(curve1) and rs.IsCurvePlanar(curve2):
    if rs.IsCurveClosed(curve1) and rs.IsCurveClosed(curve2):
        if rs.IsCurveInPlane(curve1) and rs.IsCurveInPlane(curve2):
            result = rs.PlanarClosedCurveContainment(curve1, curve2)
            if result==0: print("The regions bounded by the curves are disjoint.")
            elif result==1: print("The two curves intersect..")
            elif result==2: print("The region bounded by Curve1 is inside of Curve2.")
            else: print("The region bounded by Curve2 is inside of Curve1.")

curve_a, curve_b (guid): identifiers of two planar curves
plane (plane, optional): test plane. If omitted, the currently active construction
  plane is used
tolerance (number, optional): if omitted, the document absolute tolerance is used

bool: True if the curves intersect; otherwise False

import rhinoscriptsyntax as rs
curve1 = rs.GetObject("Select first curve")
curve2 = rs.GetObject("Select second curve")
if( rs.IsCurvePlanar(curve1) and rs.IsCurvePlanar(curve2) and rs.IsCurveInPlane(curve1) and rs.IsCurveInPlane(curve2) ):
    if rs.PlanarCurveCollision(curve1, curve2):
        print("The coplanar curves intersect.")
    else:
        print("The coplanar curves do not intersect.")

point (point|guid): text point
curve (guid): identifier of a curve object
plane (plane, optional): plane containing the closed curve and point. If omitted,
    the currently active construction plane is used
tolerance (number, optional) it omitted, the document abosulte tolerance is used

number: number identifying the result if successful
        0 = point is outside of the curve
        1 = point is inside of the curve
        2 = point in on the curve

import rhinoscriptsyntax as rs
curve = rs.GetObject("Select a planar, closed curve", rs.filter.curve)
if rs.IsCurveClosed(curve) and rs.IsCurvePlanar(curve):
    point = rs.GetPoint("Pick a point")
    if point:
        result = rs.PointInPlanarClosedCurve(point, curve)
        if result==0: print("The point is outside of the closed curve.")
        elif result==1: print("The point is inside of the closed curve.")
        else: print("The point is on the closed curve.")

curve_id (guid): the object's identifier
segment_index (number, optional): if `curve_id` identifies a polycurve object, then `segment_index` identifies the curve segment of the polycurve to query.

number: the number of curve segments in a polycurve if successful
None: if not successful

import rhinoscriptsyntax as rs
obj = rs.GetObject("Select a polycurve")
if rs.IsPolyCurve(obj):
    count = rs.PolyCurveCount(obj)
    if count: print("The polycurve contains {} curves".format(count))

curve_id (guid): the object's identifier
segment_index (number, optional): if curve_id identifies a polycurve object, then segment_index identifies the curve segment of the polycurve to query.

list(point, ...): an list of Point3d vertex points if successful
None: if not successful

import rhinoscriptsyntax as rs
obj = rs.GetObject("Select a polyline")
if rs.IsPolyline(obj):
    points = rs.PolylineVertices(obj)
    if points:
        for point in points: rs.AddPoint(point)

curve_ids ([guid, ...]): identifiers of curves to project
mesh_ids ([guid, ...]): identifiers of meshes to project onto
direction (vector): projection direction

list(guid, ...): list of identifiers for the resulting curves.

import rhinoscriptsyntax as rs
mesh = rs.GetObject("Select mesh to project onto", rs.filter.mesh)
curve= rs.GetObject("Select curve to project", rs.filter.curve)
#Project down...
results = rs.ProjectCurveToMesh(curve, mesh, (0,0,-1))

curve_ids ([guid, ...]): identifiers of curves to project
surface_ids ([guid, ...]): identifiers of surfaces to project onto
direction (vector): projection direction

list(guid, ...): list of identifiers

import rhinoscriptsyntax as rs
surface = rs.GetObject("Select surface to project onto", rs.filter.surface)
curve = rs.GetObject("Select curve to project", rs.filter.curve)
# Project down...
results = rs.ProjectCurveToSurface(curve, surface, (0,0,-1))

curve_id (guid): identifier of the curve object
degree (number, optional): new degree (must be greater than 0)
point_count (number, optional) new point count, which must be bigger than degree.

bool: True of False indicating success or failure

import rhinoscriptsyntax as rs
curve = rs.GetObject("Select curve to rebuild", rs.filter.curve)
if curve: rs.RebuildCurve(curve, 3, 10)

curve (guid): The reference of the source object
parameter (number): The parameter on the curve. Note, if the parameter is not equal to one
                of the existing knots, then the knot closest to the specified parameter
                will be removed.

bool: True of False indicating success or failure

import rhinoscriptsyntax as rs

crv_info = rs.GetCurveObject("Select curve near knot to be removed")
if crv_info:
    crv_id = crv_info[0]
    crv_param = crv_info[4]
    rs.RemoveCurveKnot(crv_id, crv_param)

curve_id (guid): identifier of the curve object

bool: True or False indicating success or failure

import rhinoscriptsyntax as rs
curve = rs.GetObject("Select a curve to reverse")
if rs.IsCurve(curve): rs.ReverseCurve(curve)

curve_id (guid): the object's identifier
flags (number, optional): the simplification methods to use. By default, all methods are used (flags = 0)
  Value Description
  0     Use all methods.
  1     Do not split NURBS curves at fully multiple knots.
  2     Do not replace segments with IsCurveLinear = True with line curves.
  4     Do not replace segments with IsArc = True with arc curves.
  8     Do not replace rational NURBS curves with constant denominator with an equivalent non-rational NURBS curve.
  16    Do not adjust curves at G1-joins.
  32    Do not merge adjacent co-linear lines or co-circular arcs or combine consecutive line segments into a polyline.

bool: True or False

import rhinoscriptsyntax as rs
curve = rs.GetObject("Select a curve to simplify", rs.filter.curve)
if curve: rs.SimplifyCurve(curve)

curve_id (guid): the curve to split
parameter ({number, ...]) one or more parameters to split the curve at
delete_input (bool, optional): delete the input curve

list(guid, ....): list of new curves on success
None: on error

import rhinoscriptsyntax as rs
curve = rs.GetObject("Select a curve to split", rs.filter.curve)
if rs.IsCurve(curve):
    domain = rs.CurveDomain(curve)
    parameter = domain[1] / 2.0
    rs.SplitCurve( curve, parameter )

curve_id (guid):the curve to trim
interval ([number, number]): two numbers identifying the interval to keep. Portions of
  the curve before domain[0] and after domain[1] will be removed. If the
  input curve is open, the interval must be increasing. If the input
  curve is closed and the interval is decreasing, then the portion of
  the curve across the start and end of the curve is returned
delete_input (bool): delete the input curve. If omitted the input curve is deleted.

list(guid, ...): identifier of the new curve on success
None: on failure

import rhinoscriptsyntax as rs
curve = rs.GetObject("Select a curve to trim", rs.filter.curve)
if rs.IsCurve(curve):
    domain = rs.CurveDomain(curve)
    domain[1] /= 2.0
    rs.TrimCurve( curve, domain )

object_id (guid): the object's identifier.
degree (number): the new degree.

bool: True of False indicating success or failure.
None: on failure

from_curve_id (guid): identifier of the first curve object.
to_curve_id (guid): identifier of the second curve object.
number_of_curves (number): The number of curves to create. The default is 1.
method (number): The method for refining the output curves, where:
  0: (Default) Uses the control points of the curves for matching. So the first control point of first curve is matched to first control point of the second curve.
  1: Refits the output curves like using the FitCurve method.  Both the input curve and the output curve will have the same structure. The resulting curves are usually more complex than input unless input curves are compatible.
  2: Input curves are divided to the specified number of points on the curve, corresponding points define new points that output curves go through. If you are making one tween curve, the method essentially does the following: divides the two curves into an equal number of points, finds the midpoint between the corresponding points on the curves, and interpolates the tween curve through those points.
sample_number (number): The number of samples points to use if method is 2. The default is 10.

list(guid, ...): The identifiers of the new tween objects if successful, None on error.

import rhinoscriptsyntax as rs
curveA = rs.GetObject("Select first curve", rs.filter.curve)
curveB = rs.GetObject("Select second curve", rs.filter.curve)
arrResult = rs.AddTweenCurves(curveA, curveB, 6, 2, 30)

start_point (point): first point of dimension
end_point (point): second point of dimension
point_on_dimension_line (point): location point of dimension line
style (str, optional): name of dimension style

guid: identifier of new dimension on success
None: on error

import rhinoscriptsyntax as rs
origin = 1, 1, 0
offset = 11, 5, 0
point = 1, 3, 0
rs.AddAlignedDimension( origin, offset, point )

dimstyle_name (str, optional): name of the new dimension style. If omitted, Rhino automatically generates the dimension style name

str: name of the new dimension style on success
None: on error

import rhinoscriptsyntax as rs
print("New dimension style: {}".format(rs.AddDimStyle()))
print("New dimension style: {}".format(rs.AddDimStyle("MyDimStyle")))

points ([point, point, ....])list of (at least 2) 3D points
view_or_plane (str, optional): If a view name is specified, points will be constrained
  to the view's construction plane. If a view is not specified, points
  will be constrained to a plane fit through the list of points
text (str, optional): leader's text string

guid: identifier of the new leader on success
None: on error

import rhinoscriptsyntax as rs
points = rs.GetPoints(True, False, "Select leader points")
if points: rs.AddLeader( points )

plane (plane): The plane on which the dimension will lie.
start_point (point): The origin, or first point of the dimension.
end_point (point): The offset, or second point of the dimension.
point_on_dimension_line (point): A point that lies on the dimension line.

guid: identifier of the new object on success
None: on error

import rhinoscriptsyntax as  rs
points = rs.GetPoints(True,  False, "Select 3 dimension points")
if points and len(points)>2:
    rs.AddLinearDimension(rs.WorldXYPlane(),  points[0], points[1], points[2] )

dimstyle_name (str, optional): name of an existing dimension style to make current

str: if dimstyle_name is not specified, name of the current dimension style
str: if dimstyle_name is specified, name of the previous dimension style
None: on error

import rhinoscriptsyntax as rs
rs.AddDimStyle("MyDimStyle")
rs.CurrentDimStyle("MyDimStyle")

dimstyle_name (str): the name of an unreferenced dimension style

str: The name of the deleted dimension style if successful
None: on error

import rhinoscriptsyntax as rs
dimstyle = rs.GetString("Dimension style to remove")
if dimstyle: rs.DeleteDimStyle(dimstyle)

object_id (guid): identifier of the object
dimstyle_name (str, optional): the name of an existing dimension style

str: if dimstyle_name is not specified, the object's current dimension style name
str: if dimstyle_name is specified, the object's previous dimension style name
None: on error

import rhinoscriptsyntax as rs
obj = rs.GetObject("Select a dimension")
if rs.IsDimension(obj): rs.DimensionStyle(obj, "Default")

object_id (guid): identifier of the object

str: the text displayed by a dimension object

import rhinoscriptsyntax as rs
obj = rs.GetObject("Select a dimension")
if rs.IsDimension(obj):
    print(rs.DimensionText(obj))

object_id (guid): identifier of the object
usertext (str, optional): the new user text string value

str: if usertext is not specified, the current usertext string
str: if usertext is specified, the previous usertext string

import rhinoscriptsyntax as rs
obj = rs.GetObject("Select a dimension")
if rs.IsDimension(obj):
    usertext = "!= " + chr(177) + str(rs.UnitAbsoluteTolerance())
    rs.DimensionUserText( obj, usertext )

object_id (guid): identifier of the object

number: numeric value of the dimension if successful

import rhinoscriptsyntax as rs
obj = rs.GetObject("Select a dimension")
if rs.IsDimension(obj):
    print(rs.DimensionValue(obj))

dimstyle (str): the name of an existing dimension style
precision (number, optional): the new angle precision value. If omitted, the current angle
  precision is returned

number: If a precision is not specified, the current angle precision
number: If a precision is specified, the previous angle precision

import rhinoscriptsyntax as rs
dimstyle = rs.CurrentDimStyle()
precision = rs.DimStyleAnglePrecision(dimstyle)
if precision>2:
    rs.DimStyleAnglePrecision( dimstyle, 2 )

dimstyle (str): the name of an existing dimension style
size (number, optional): the new arrow size. If omitted, the current arrow size is returned

number: If size is not specified, the current arrow size
number: If size is specified, the previous arrow size
None: on error

import rhinoscriptsyntax as rs
dimstyle = rs.CurrentDimStyle()
size = rs.DimStyleArrowSize(dimstyle)
if size>1.0: rs.DimStyleArrowSize( dimstyle, 1.0 )

number: the number of dimension styles in the document

import rhinoscriptsyntax as rs
count = rs.DimStyleCount()
print("There are", count, "dimension styles.")

dimstyle (str): the name of an existing dimension style
extension (number, optional): the new extension line extension

number: if extension is not specified, the current extension line extension
number: if extension is specified, the previous extension line extension
None: on error

import rhinoscriptsyntax as rs
dimstyle = rs.CurrentDimStyle()
extension = rs.DimStyleExtension(dimstyle)
if extension>0.5: rs.DimStyleExtension( dimstyle, 0.5 )

dimstyle (str): the name of an existing dimension style
font (str, optional): the new font face name

str: if font is not specified, the current font if successful
str: if font is specified, the previous font if successful
None: on error

import rhinoscriptsyntax as rs
dimstyle = rs.CurrentDimStyle()
font = rs.DimStyleFont(dimstyle)
if font!="Arial": rs.DimStyleFont( dimstyle, "Arial" )

dimstyle (str): the name of an existing dimension style
size (number, optional) the new leader arrow size

number: if size is not specified, the current leader arrow size
number: if size is specified, the previous leader arrow size
None: on error

import rhinoscriptsyntax as rs
dimstyle = rs.CurrentDimStyle()
size = rs.DimStyleLeaderArrowSize(dimstyle)
if size>1.0: rs.DimStyleLeaderArrowSize( dimstyle, 1.0 )

dimstyle (str): the name of an existing dimension style
factor (number, optional): the new length factor

number: if factor is not defined, the current length factor
number: if factor is defined, the previous length factor
None: on error

import rhinoscriptsyntax as rs
dimstyle = rs.CurrentDimStyle()
factor = rs.DimStyleLengthFactor(dimstyle)
if factor>1.0: rs.DimStyleLengthFactor( dimstyle, 1.0 )

dimstyle (str): the name of an existing dimension style
precision (number, optional): the new linear precision value

number: if precision is not specified, the current linear precision value
number: if precision is specified, the previous linear precision value
None: on error

import rhinoscriptsyntax as rs
dimstyle = rs.CurrentDimStyle()
precision = rs.DimStyleLinearPrecision(dimstyle)
if precision>2: rs.DimStyleLinearPrecision( dimstyle, 2 )

sort (bool): sort the list if True, not sorting is the default (False)

list(str, ...): the names of all dimension styles in the document

import rhinoscriptsyntax as rs
dimstyles = rs.DimStyleNames()
if dimstyles:
    for dimstyle in dimstyles: print(dimstyle)

dimstyle (str): the name of an existing dimension style
format (number, optional) the new number format
   0 = Decimal
   1 = Fractional
   2 = Feet and inches

number: if format is not specified, the current display format
number: if format is specified, the previous display format
None: on error

import rhinoscriptsyntax as rs
dimstyle = rs.CurrentDimStyle()
format = rs.DimStyleNumberFormat(dimstyle)
if format>0: rs.DimStyleNumberFormat( dimstyle, 0 )

dimstyle (str): the name of an existing dimension style
offset (number, optional): the new extension line offset

number: if offset is not specified, the current extension line offset
number: if offset is specified, the previous extension line offset
None: on error

import rhinoscriptsyntax as rs
dimstyle = rs.CurrentDimStyle()
offset = rs.DimStyleOffset(dimstyle)
if offset>0.5: rs.DimStyleOffset( dimstyle, 0.5 )

dimstyle (str): the name of an existing dimstyle
prefix (str, optional): the new prefix

str: if prefix is not specified, the current prefix
str: if prefix is specified, the previous prefix
None: on error

import rhinoscriptsyntax as rs
dimstyle = rs.CurrentDimStyle()
rs.DimStylePrefix( dimstyle, "[" )

dimstyle (str): the name of an existing dimstyle
scale (number, optional): the new scale value

number: if scale is not specified, the current scale
number: if scale is specified, the previous scale
None: on error

import rhinoscriptsyntax as rs
from scriptcontext import doc
dimstyle = doc.DimStyles.Current
scale = rs.DimStyleScale(dimstyle)
rs.DimStyleScale(dimstyle, scale*2.0)

dimstyle (str): the name of an existing dimstyle
suffix (str, optional): the new suffix

str: if suffix is not specified, the current suffix
str: if suffix is specified, the previous suffix
None: on error

import rhinoscriptsyntax as rs
dimstyle = rs.CurrentDimStyle()
rs.DimStyleSuffix( dimstyle, "}" )

dimstyle (str): the name of an existing dimension style
alignment (number, optional): the new text alignment
    0 = Normal (same as 2)
    1 = Horizontal to view
    2 = Above the dimension line
    3 = In the dimension line

number: if alignment is not specified, the current text alignment
number: if alignment is specified, the previous text alignment
None: on error

import rhinoscriptsyntax as rs
dimstyle = rs.CurrentDimStyle()
alignment = rs.DimStyleTextAlignment(dimstyle)
if alignment!=2: rs.DimStyleTextAlignment( dimstyle, 2 )

dimstyle (str): the name of an existing dimension style
gap (number, optional): the new text gap

number: if gap is not specified, the current text gap
number: if gap is specified, the previous text gap
None: on error

import rhinoscriptsyntax as rs
dimstyle = rs.CurrentDimStyle()
gap = rs.DimStyleTextGap(dimstyle)
if gap>0.25: rs.DimStyleTextGap( dimstyle, 0.25 )

dimstyle (str): the name of an existing dimension style
height (number, optional): the new text height

number: if height is not specified, the current text height
number: if height is specified, the previous text height
None: on error

import rhinoscriptsyntax as rs
dimstyle = rs.CurrentDimStyle()
height = rs.DimStyleTextHeight(dimstyle)
if offset>1.0: rs.DimStyleTextHeight( dimstyle, 1.0 )

object_id (guid): the object's identifier

bool: True or False.  None on error

import rhinoscriptsyntax as rs
obj = rs.GetObject("Select a dimension")
if rs.IsAlignedDimension(obj):
    print("The object is an aligned dimension.")
else:
    print("The object is not an aligned dimension.")

object_id (guid): the object's identifier

bool: True or False.
None: on error

import rhinoscriptsyntax as rs
obj = rs.GetObject("Select a dimension")
if rs.IsAngularDimension(obj):
    print("The object is an angular dimension.")
else:
    print("The object is not an angular dimension.")

object_id (guid): the object's identifier

bool: True or False.
None: on error

import rhinoscriptsyntax as rs
obj = rs.GetObject("Select a dimension")
if rs.IsDiameterDimension(obj):
    print("The object is a diameter dimension.")
else:
    print("The object is not a diameter dimension.")

object_id (guid): the object's identifier

bool: True or False.
None: on error

import rhinoscriptsyntax as rs
obj = rs.GetObject("Select a dimension")
if rs.IsDimension(obj):
    print("The object is a dimension.")
else:
    print("The object is not a dimension.")

dimstyle (str): the name of a dimstyle to test for

bool: True or False.
None: on error

import rhinoscriptsyntax as rs
dimstyle = rs.GetString("Dimension style to test")
if rs.IsDimStyle(dimstyle):
    if rs.IsDimStyleReference(dimstyle):
        print("The dimension style is from a reference file.")
    else:
        print("The dimension style is not from a reference file.")
else:
    print("The dimension style does not exist.")

dimstyle (str): the name of an existing dimension style

bool: True or False.
None: on error

import rhinoscriptsyntax as rs
dimstyle = rs.GetString("Dimension style to test")
if rs.IsDimStyle(dimstyle):
    if rs.IsDimStyleReference(dimstyle):
        print("The dimension style is from a reference file.")
    else:
        print("The dimension style is not from a reference file.")
else:
    print("The dimension style does not exist.")

object_id (guid): the object's identifier

bool: True or False.
None: on error

import rhinoscriptsyntax as rs
obj = rs.GetObject("Select a leader")
if rs.IsLeader(obj):
    print("The object is a leader.")
else:
    print("The object is not a leader.")

object_id (guid): the object's identifier

bool: True or False.
None: on error

import rhinoscriptsyntax as rs
obj = rs.GetObject("Select a dimension")
if rs.IsLinearDimension(obj):
    print("The object is a linear dimension.")
else:
    print("The object is not a linear dimension.")

object_id (guid): the object's identifier

bool: True or False.
None: on error

import rhinoscriptsyntax as rs
obj = rs.GetObject("Select a dimension")
if rs.IsOrdinateDimension(obj):
    print("The object is an ordinate dimension.")
else:
    print("The object is not an ordinate dimension.")

object_id (guid): the object's identifier

bool: True or False.
None: on error

import rhinoscriptsyntax as rs
obj = rs.GetObject("Select a dimension")
if rs.IsRadialDimension(obj):
    print("The object is a radial dimension.")
else:
    print("The object is not a radial dimension.")

object_id (guid): the object's identifier
text (string, optional): the new text string

str: if text is not specified, the current text string
str: if text is specified, the previous text string
None on error

import rhinoscriptsyntax as rs
obj = rs.GetObject("Select a leader")
if rs.IsLeader(obj): print(rs.LeaderText(obj))

oldstyle (str): the name of an existing dimension style
newstyle (str): the new dimension style name

str: the new dimension style name if successful
None: on error

import rhinoscriptsyntax as rs
oldstyle = rs.GetString("Old dimension style name")
if oldstyle:
    newstyle = rs.GetString("New dimension style name")
    if newstyle: rs.RenameDimStyle( oldstyle, newstyle )

filename (str): name of the bitmap file to create
view (str, optional): title of the view. If omitted, the active view is used
size (number, optional): two integers that specify width and height of the bitmap
flags (number, optional): Bitmap creation flags. Can be the combination of:
    1 = honor object highlighting
    2 = draw construction plane
    4 = use ghosted shading
wireframe (bool, optional): If True then a wireframe preview image. If False,
    a rendered image will be created

bool: True or False indicating success or failure

import rhinoscriptsyntax as  rs
result = rs.CreatePreviewImage("test.jpg")
if result:
    print( "test.jpg created successfully.")
else:
    print( "Unable to create preview image.")

modified (bool): the modified state, either True or False

bool: if no modified state is specified, the current modified state
bool: if a modified state is specified, the previous modified state

import rhinoscriptsyntax as rs
modified = rs.IsDocumentModified()
if not modified: rs.DocumentModified(True)

str: the name of the currently loaded Rhino document (3DM file)

import rhinoscriptsyntax as rs
name = rs.DocumentName()
print(name)

str: the path of the currently loaded Rhino document (3DM file)

import rhinoscriptsyntax as rs
path = rs.DocumentPath()
print(path)

enable (bool, optional): True to enable, False to disable

bool: previous screen redrawing state

import rhinoscriptsyntax as rs
redraw = rs.EnableRedraw(True)

filename (str): name of the bitmap file to create. The extension of
   the filename controls the format of the bitmap file created.
   (.bmp, .tga, .jpg, .jpeg, .pcx, .png, .tif, .tiff)
modelname (str, optional): The model (.3dm) from which to extract the
   preview image. If omitted, the currently loaded model is used.

bool: True or False indicating success or failure

import rhinoscriptsyntax as rs
result = rs.ExtractPreviewImage("test.jpg")
if result:
    print("Test.jpg created successfully.")
else:
    print("Unable to extract preview image.")

bool: True or False. None on error

import rhinoscriptsyntax as rs
modified = rs.IsDocumentModified()
if not modified: rs.DocumentModified(True)

newnotes (str): new notes to set

str: if `newnotes` is omitted, the current notes if successful
str: if `newnotes` is specified, the previous notes if successful

import rhinoscriptsyntax as rs
notes = rs.Notes()
if notes: rs.MessageBox(notes)

str: the file version of the current document

import rhinoscriptsyntax as rs
print("ReadFileVersion = {}".format(rs.ReadFileVersion()))

None

import rhinoscriptsyntax as rs
rs.Redraw()

style (number, optional): level of antialiasing (0=none, 1=normal, 2=best)

number: if style is not specified, the current antialiasing style
number: if style is specified, the previous antialiasing style

import rhinoscriptsyntax as rs
rs.RenderAntialias(1)

item (number): 0=ambient light color, 1=background color
color (color, optional): the new color value. If omitted, the current item color is returned

color: if color is not specified, the current item color
color: if color is specified, the previous item color

import rhinoscriptsyntax as rs
render_background_color = 1
rs.RenderColor( render_background_color, (0,0,255) )

resolution ([number, number], optional): width and height of render

tuple(number, number): if resolution is not specified, the current resolution width,height
tuple(number, number): if resolution is specified, the previous resolution width, height

import rhinoscriptsyntax as rs
sizex, sizey = rs.Viewsize()
resolution = sizex/2 , sizey/2
rs.RenderResolution( resolution )

density (number, optional): the new render mesh density, which is a number between 0.0 and 1.0.

number: if density is not specified, the current render mesh density if successful.
number: if density is specified, the previous render mesh density if successful.

import rhinoscriptsyntax as  rs
print("Quality: %s" % rs.RenderMeshQuality())
print("Mesh density: %s" % rs.RenderMeshDensity())
print("Maximum angle: %s" % rs.RenderMeshMaxAngle())
print("Maximum aspect ratio: %s" % rs.RenderMeshMaxAspectRatio())
print("Minimun edge length: %s" % rs.RenderMeshMinEdgeLength())
print("Maximum edge length: %s" % rs.RenderMeshMaxEdgeLength())
print("Maximum distance, edge to surface: %s" % rs.RenderMeshMaxDistEdgeToSrf())
print("Minumum initial grid quads: %s" % rs.RenderMeshMinInitialGridQuads())
print("Other settings: %s" % rs.RenderMeshSettings())

angle_degrees (number, optional): the new maximum angle, which is a positive number in degrees.

number: if angle_degrees is not specified, the current maximum angle if successful.
number: if angle_degrees is specified, the previous maximum angle if successful.
None: if not successful, or on error.

import rhinoscriptsyntax as  rs
print("Quality: %s" % rs.RenderMeshQuality())
print("Mesh density: %s" % rs.RenderMeshDensity())
print("Maximum angle: %s" % rs.RenderMeshMaxAngle())
print("Maximum aspect ratio: %s" % rs.RenderMeshMaxAspectRatio())
print("Minimun edge length: %s" % rs.RenderMeshMinEdgeLength())
print("Maximum edge length: %s" % rs.RenderMeshMaxEdgeLength())
print("Maximum distance, edge to surface: %s" % rs.RenderMeshMaxDistEdgeToSrf())
print("Minumum initial grid quads: %s" % rs.RenderMeshMinInitialGridQuads())
print("Other settings: %s" % rs.RenderMeshSettings())

ratio (number, optional): the render mesh maximum aspect ratio.  The suggested range, when not zero, is from 1 to 100.

number: if ratio is not specified, the current render mesh maximum aspect ratio if successful.
number: if ratio is specified, the previous render mesh maximum aspect ratio if successful.
None: if not successful, or on error.

import rhinoscriptsyntax as  rs
print("Quality: %s" % rs.RenderMeshQuality())
print("Mesh density: %s" % rs.RenderMeshDensity())
print("Maximum angle: %s" % rs.RenderMeshMaxAngle())
print("Maximum aspect ratio: %s" % rs.RenderMeshMaxAspectRatio())
print("Minimun edge length: %s" % rs.RenderMeshMinEdgeLength())
print("Maximum edge length: %s" % rs.RenderMeshMaxEdgeLength())
print("Maximum distance, edge to surface: %s" % rs.RenderMeshMaxDistEdgeToSrf())
print("Minumum initial grid quads: %s" % rs.RenderMeshMinInitialGridQuads())
print("Other settings: %s" % rs.RenderMeshSettings())

distance (number, optional): the render mesh maximum distance, edge to surface.

number: if distance is not specified, the current render mesh maximum distance, edge to surface if successful.
number: if distance is specified, the previous render mesh maximum distance, edge to surface if successful.
None: if not successful, or on error.

import rhinoscriptsyntax as  rs
print("Quality: %s" % rs.RenderMeshQuality())
print("Mesh density: %s" % rs.RenderMeshDensity())
print("Maximum angle: %s" % rs.RenderMeshMaxAngle())
print("Maximum aspect ratio: %s" % rs.RenderMeshMaxAspectRatio())
print("Minimun edge length: %s" % rs.RenderMeshMinEdgeLength())
print("Maximum edge length: %s" % rs.RenderMeshMaxEdgeLength())
print("Maximum distance, edge to surface: %s" % rs.RenderMeshMaxDistEdgeToSrf())
print("Minumum initial grid quads: %s" % rs.RenderMeshMinInitialGridQuads())
print("Other settings: %s" % rs.RenderMeshSettings())

distance (number, optional): the render mesh maximum edge length.

number: if distance is not specified, the current render mesh maximum edge length if successful.
number: if distance is specified, the previous render mesh maximum edge length if successful.
None: if not successful, or on error.

import rhinoscriptsyntax as  rs
print("Quality: %s" % rs.RenderMeshQuality())
print("Mesh density: %s" % rs.RenderMeshDensity())
print("Maximum angle: %s" % rs.RenderMeshMaxAngle())
print("Maximum aspect ratio: %s" % rs.RenderMeshMaxAspectRatio())
print("Minimun edge length: %s" % rs.RenderMeshMinEdgeLength())
print("Maximum edge length: %s" % rs.RenderMeshMaxEdgeLength())
print("Maximum distance, edge to surface: %s" % rs.RenderMeshMaxDistEdgeToSrf())
print("Minumum initial grid quads: %s" % rs.RenderMeshMinInitialGridQuads())
print("Other settings: %s" % rs.RenderMeshSettings())

distance (number, optional): the render mesh minimum edge length.

number: if distance is not specified, the current render mesh minimum edge length if successful.
number: if distance is specified, the previous render mesh minimum edge length if successful.
None: if not successful, or on error.

import rhinoscriptsyntax as  rs
print("Quality: %s" % rs.RenderMeshQuality())
print("Mesh density: %s" % rs.RenderMeshDensity())
print("Maximum angle: %s" % rs.RenderMeshMaxAngle())
print("Maximum aspect ratio: %s" % rs.RenderMeshMaxAspectRatio())
print("Minimun edge length: %s" % rs.RenderMeshMinEdgeLength())
print("Maximum edge length: %s" % rs.RenderMeshMaxEdgeLength())
print("Maximum distance, edge to surface: %s" % rs.RenderMeshMaxDistEdgeToSrf())
print("Minumum initial grid quads: %s" % rs.RenderMeshMinInitialGridQuads())
print("Other settings: %s" % rs.RenderMeshSettings())

quads (number, optional): the render mesh minimum initial grid quads. The suggested range is from 0 to 10000.

number: if quads is not specified, the current render mesh minimum initial grid quads if successful.
number: if quads is specified, the previous render mesh minimum initial grid quads if successful.
None: if not successful, or on error.

import rhinoscriptsyntax as  rs
print("Quality: %s" % rs.RenderMeshQuality())
print("Mesh density: %s" % rs.RenderMeshDensity())
print("Maximum angle: %s" % rs.RenderMeshMaxAngle())
print("Maximum aspect ratio: %s" % rs.RenderMeshMaxAspectRatio())
print("Minimun edge length: %s" % rs.RenderMeshMinEdgeLength())
print("Maximum edge length: %s" % rs.RenderMeshMaxEdgeLength())
print("Maximum distance, edge to surface: %s" % rs.RenderMeshMaxDistEdgeToSrf())
print("Minumum initial grid quads: %s" % rs.RenderMeshMinInitialGridQuads())
print("Other settings: %s" % rs.RenderMeshSettings())

quality (number, optional): the render mesh quality, either:
  0: Jagged and faster.  Objects may look jagged, but they should shade and render relatively quickly.
  1: Smooth and slower.  Objects should look smooth, but they may take a very long time to shade and render.
  2: Custom.

number: if quality is not specified, the current render mesh quality if successful.
number: if quality is specified, the previous render mesh quality if successful.
None: if not successful, or on error.

import rhinoscriptsyntax as  rs
print("Quality: %s" % rs.RenderMeshQuality())
print("Mesh density: %s" % rs.RenderMeshDensity())
print("Maximum angle: %s" % rs.RenderMeshMaxAngle())
print("Maximum aspect ratio: %s" % rs.RenderMeshMaxAspectRatio())
print("Minimun edge length: %s" % rs.RenderMeshMinEdgeLength())
print("Maximum edge length: %s" % rs.RenderMeshMaxEdgeLength())
print("Maximum distance, edge to surface: %s" % rs.RenderMeshMaxDistEdgeToSrf())
print("Minumum initial grid quads: %s" % rs.RenderMeshMinInitialGridQuads())
print("Other settings: %s" % rs.RenderMeshSettings())

settings (number, optional): the render mesh settings, which is a bit-coded number that allows or disallows certain features.
The bits can be added together in any combination to form a value between 0 and 7.  The bit values are as follows:
  0: No settings enabled.
  1: Refine mesh enabled.
  2: Jagged seams enabled.
  4: Simple planes enabled.
  8: Texture is packed, scaled and normalized; otherwise unpacked, unscaled and normalized.

number: if settings is not specified, the current render mesh settings if successful.
number: if settings is specified, the previous render mesh settings if successful.
None: if not successful, or on error.

import rhinoscriptsyntax as  rs
print("Quality: %s" % rs.RenderMeshQuality())
print("Mesh density: %s" % rs.RenderMeshDensity())
print("Maximum angle: %s" % rs.RenderMeshMaxAngle())
print("Maximum aspect ratio: %s" % rs.RenderMeshMaxAspectRatio())
print("Minimun edge length: %s" % rs.RenderMeshMinEdgeLength())
print("Maximum edge length: %s" % rs.RenderMeshMaxEdgeLength())
print("Maximum distance, edge to surface: %s" % rs.RenderMeshMaxDistEdgeToSrf())
print("Minumum initial grid quads: %s" % rs.RenderMeshMinInitialGridQuads())
print("Other settings: %s" % rs.RenderMeshSettings())

settings (number, optional): bit-coded flags of render settings to modify.
  0=none,
  1=create shadows,
  2=use lights on layers that are off,
  4=render curves and isocurves,
  8=render dimensions and text

number: if settings are not specified, the current render settings in bit-coded flags
number: if settings are specified, the previous render settings in bit-coded flags

import rhinoscriptsyntax as rs
render_annotations = 8
settings = rs.RenderSettings()
if settings & render_annotations:
    settings = settings - render_annotations
    rs.RenderSettings( settings )

tolerance (number, optional): the absolute tolerance to set
in_model_units (bool, optional): Return or modify the document's model units (True)
                      or the document's page units (False)

number: if tolerance is not specified, the current absolute tolerance
number: if tolerance is specified, the previous absolute tolerance

import rhinoscriptsyntax as rs
tol = rs.UnitAbsoluteTolerance()
if tol<0.01:
    rs.UnitAbsoluteTolerance( 0.01 )

angle_tolerance_degrees (number, optional): the angle tolerance to set
in_model_units (number, optional): Return or modify the document's model units (True)
                       or the document's page units (False)

number: if angle_tolerance_degrees is not specified, the current angle tolerance
number: if angle_tolerance_degrees is specified, the previous angle tolerance

import rhinoscriptsyntax as rs
tol = rs.UnitAngleTolerance()
if tol<3.0:
    rs.UnitAngleTolerance(3.0)

precision (number, optional): The distance display precision.  If the current distance display mode is Decimal, then precision is the number of decimal places.
                              If the current distance display mode is Fractional (including Feet and Inches), then the denominator = (1/2)^precision.
                              Use UnitDistanceDisplayMode to get the current distance display mode.
model_units (bool, optional): Return or modify the document's model units (True) or the document's page units (False). The default is True.

number: If precision is not specified, the current distance display precision if successful. If precision is specified, the previous distance display precision if successful. If not successful, or on error.

import rhinoscriptsyntax as rs
precision = 3
rs.UnitDistanceDisplayPrecision( precision )

relative_tolerance (number, optional) the relative tolerance in percent
in_model_units (bool, optional): Return or modify the document's model units (True)
                       or the document's page units (False)

number: if relative_tolerance is not specified, the current tolerance in percent
number: if relative_tolerance is specified, the previous tolerance in percent

import rhinoscriptsyntax as rs
tol = rs.UnitRelativeTolerance()
if tol<1.0:
    rs.UnitRelativeTolerance(1.0)

to_system (number): The unit system to convert to. The unit systems are are:
   0 - No unit system
   1 - Microns (1.0e-6 meters)
   2 - Millimeters (1.0e-3 meters)
   3 - Centimeters (1.0e-2 meters)
   4 - Meters
   5 - Kilometers (1.0e+3 meters)
   6 - Microinches (2.54e-8 meters, 1.0e-6 inches)
   7 - Mils (2.54e-5 meters, 0.001 inches)
   8 - Inches (0.0254 meters)
   9 - Feet (0.3408 meters, 12 inches)
  10 - Miles (1609.344 meters, 5280 feet)
  11 - *Reserved for custom Unit System*
  12 - Angstroms (1.0e-10 meters)
  13 - Nanometers (1.0e-9 meters)
  14 - Decimeters (1.0e-1 meters)
  15 - Dekameters (1.0e+1 meters)
  16 - Hectometers (1.0e+2 meters)
  17 - Megameters (1.0e+6 meters)
  18 - Gigameters (1.0e+9 meters)
  19 - Yards (0.9144  meters, 36 inches)
  20 - Printer point (1/72 inches, computer points)
  21 - Printer pica (1/6 inches, (computer picas)
  22 - Nautical mile (1852 meters)
  23 - Astronomical (1.4959787e+11)
  24 - Lightyears (9.46073e+15 meters)
  25 - Parsecs (3.08567758e+16)
from_system (number, optional): the unit system to convert from (see above). If omitted,
    the document's current unit system is used

number: scale factor for changing between unit systems

import rhinoscriptsyntax as rs
print(rs.UnitScale(3, 4)) # 100.0
print(rs.UnitScale(3, 8)) # 2.54
print(rs.UnitScale(8, 9)) # 12.0

unit_system (number, optional): The unit system to set the document to. The unit systems are:
   0 - No unit system
   1 - Microns (1.0e-6 meters)
   2 - Millimeters (1.0e-3 meters)
   3 - Centimeters (1.0e-2 meters)
   4 - Meters
   5 - Kilometers (1.0e+3 meters)
   6 - Microinches (2.54e-8 meters, 1.0e-6 inches)
   7 - Mils (2.54e-5 meters, 0.001 inches)
   8 - Inches (0.0254 meters)
   9 - Feet (0.3048 meters, 12 inches)
  10 - Miles (1609.344 meters, 5280 feet)
  11 - *Reserved for custom Unit System*
  12 - Angstroms (1.0e-10 meters)
  13 - Nanometers (1.0e-9 meters)
  14 - Decimeters (1.0e-1 meters)
  15 - Dekameters (1.0e+1 meters)
  16 - Hectometers (1.0e+2 meters)
  17 - Megameters (1.0e+6 meters)
  18 - Gigameters (1.0e+9 meters)
  19 - Yards (0.9144  meters, 36 inches)
  20 - Printer point (1/72 inches, computer points)
  21 - Printer pica (1/6 inches, (computer picas)
  22 - Nautical mile (1852 meters)
  23 - Astronomical (1.4959787e+11)
  24 - Lightyears (9.46073e+15 meters)
  25 - Parsecs (3.08567758e+16)
scale (bool, optional): Scale existing geometry based on the new unit system.
    If not specified, any existing geometry is not scaled (False)
in_model_units (number, optional): Return or modify the document's model units (True)
    or the document's page units (False). The default is True.

number: if unit_system is not specified, the current unit system
number: if unit_system is specified, the previous unit system
None: on error

import rhinoscriptsyntax as rs
rhUnitMillimeters = 2
rhUnitInches = 8
current_system = rs.UnitSystem()
if current_system==rhUnitMillimeters:
    rs.UnitSystem(rhUnitInches, True)

capitalize (bool, optional): Capitalize the first character of the units system name (e.g. return "Millimeter" instead of "millimeter"). The default is not to capitalize the first character (false).
singular (bool, optional): Return the singular form of the units system name (e.g. "millimeter" instead of "millimeters"). The default is to return the singular form of the name (true).
abbreviate (bool, optional): Abbreviate the name of the units system (e.g. return "mm" instead of "millimeter"). The default is not to abbreviate the name (false).
model_units (bool, optional): Return the document's model units (True) or the document's page units (False). The default is True.

str: The name of the current units system if successful.

import rhinoscriptsyntax as rs
system = rs.UnitSystemName(False, False, False)
print("The units system is set to{}".format(system))

plane (plane): the plane
u_magnitude, v_magnitude (number): size of the plane
views ([str|guid, ...]): Titles or ids the the view(s) to clip. If omitted, the active
  view is used.

guid: object identifier on success
None: on failure

import rhinoscriptsyntax as rs
rs.AddClippingPlane( rs.WorldXYPlane(), 5.0, 3.0 )

plane (plane): The plane in which the PictureFrame will be created.  The bottom-left corner of picture will be at plane's origin. The width will be in the plane's X axis direction, and the height will be in the plane's Y axis direction.
filename (str): The path to a bitmap or image file.
width (number, optional): If both dblWidth and dblHeight = 0, then the width and height of the PictureFrame will be the width and height of the image. If dblWidth = 0 and dblHeight is > 0, or if dblWidth > 0 and dblHeight = 0, then the non-zero value is assumed to be an aspect ratio of the image's width or height, which ever one is = 0. If both dblWidth and dblHeight are > 0, then these are assumed to be the width and height of in the current unit system.
height (number, optional):  If both dblWidth and dblHeight = 0, then the width and height of the PictureFrame will be the width and height of the image. If dblWidth = 0 and dblHeight is > 0, or if dblWidth > 0 and dblHeight = 0, then the non-zero value is assumed to be an aspect ratio of the image's width or height, which ever one is = 0. If both dblWidth and dblHeight are > 0, then these are assumed to be the width and height of in the current unit system.
self_illumination (bool, optional): If True, then the image mapped to the picture frame plane always displays at full intensity and is not affected by light or shadow.
embed (bool, optional): If True, then the function adds the image to Rhino's internal bitmap table, thus making the document self-contained.
use_alpha (bool, optional): If False, the picture frame is created without any transparency texture.  If True, a transparency texture is created with a "mask texture" set to alpha, and an instance of the diffuse texture in the source texture slot.
make_mesh (bool, optional): If True, the function will make a PictureFrame object from a mesh rather than a plane surface.

guid: object identifier on success
None: on failure

point (point): a point3d or list(x,y,z) location of point to add

guid: identifier for the object that was added to the doc

import rhinoscriptsyntax as rs
rs.AddPoint( (1,2,3) )

points ([point, ....]): list of values where every multiple of three represents a point
colors ([color, ...]): list of colors to apply to each point

guid: identifier of point cloud on success

import rhinoscriptsyntax as rs
points = (0,0,0), (1,1,1), (2,2,2), (3,3,3)
rs.AddPointCloud(points)

points ([point, ...]): list of points

list(guid, ...): identifiers of the new objects on success

import rhinoscriptsyntax as rs
points = rs.GetPoints(True, True, "Select points")
if points: rs.AddPoints(points)

text (str): the text to display
point_or_plane (point|plane): a 3-D point or the plane on which the text will lie.
    The origin of the plane will be the origin point of the text
height (number, optional): the text height
font (str, optional): the text font
font_style (number, optional): any of the following flags
   0 = normal
   1 = bold
   2 = italic
   3 = bold and italic
justification (number, optional): text justification. Values may be added to create combinations.
   1 = Left
   2 = Center (horizontal)
   4 = Right
   65536 = Bottom
   131072 = Middle (vertical)
   262144 = Top

guid: identifier for the object that was added to the doc on success
None: on failure

import rhinoscriptsyntax as rs
point = rs.GetPoint("Pick point")
if point: rs.AddText("Hello Rhino!", point)

text (str): string in dot
point (point): A 3D point identifying the origin point.

guid: The identifier of the new object if successful

import rhinoscriptsyntax as rs
rs.AddTextDot("howdy",(1,2,3))

object_id (guid): the object's identifier

number: area if successful
None: on error

import rhinoscriptsyntax as  rs
a = rs.Area('a9e34aa8-226c-4e17-9e11-b74bf2cf581b')

objects ([guid, ...]): The identifiers of the objects
view_or_plane (str|guid): Title or id of the view that contains the
    construction plane to which the bounding box should be aligned -or-
    user defined plane. If omitted, a world axis-aligned bounding box
    will be calculated
in_world_coords (bool, optional): return the bounding box as world coordinates or
    construction plane coordinates. Note, this option does not apply to
    world axis-aligned bounding boxes.

list(point, point, point, point, point, point, point, point): Eight 3D points that define the bounding box.
     Points returned in counter-clockwise order starting with the bottom rectangle of the box.
None: on error

import rhinoscriptsyntax as rs
object = rs.GetObject("Select object")
if object:
    box = rs.BoundingBox(object)
    if box:
        for i, point in enumerate(box):
            rs.AddTextDot( i, point )

first (guid|geometry): The identifier of the first object to compare.
second (guid|geometry): The identifier of the second object to compare.

True if the objects are geometrically identical, otherwise False.

import rhinoscriptsyntax as rs
object1 = rs.GetObject("Select first object")
object2 = rs.GetObject("Select second object")
if object:
print("Objects are identical" if rs.CompareGeometry(object1, object2) else "Objects differ")

text_id (guid): identifier of Text object to explode
delete (bool, optional): delete the text object after the curves have been created

list(guid): of outline curves

import rhinoscriptsyntax as rs
text = rs.AddText("abcd", rs.WorldXYPlane())
rs.ExplodeText(text, True)

object_id (guid): the object's identifier

bool: True if the object with a given id is a clipping plane

import rhinoscriptsyntax as rs
id = rs.GetObject("Select a clipping plane")
if rs.IsClippingPlane(id):
    print("The object is a clipping plane.")
else:
    print("The object is not a clipping plane.")

object_id (guid): the object's identifier

bool: True if the object with a given id is a point

import rhinoscriptsyntax as rs
id = rs.GetObject("Select a point")
if rs.IsPoint(id):
    print("The object is a point.")
else:
    print("The object is not a point.")

object_id (guid): the object's identifier

bool: True if the object with a given id is a point cloud

import rhinoscriptsyntax as rs
id = rs.GetObject("Select a point cloud")
if rs.IsPointCloud(id):
    print("The object is a point cloud.")
else:
    print("The object is not a point cloud.")

object_id (guid): the object's identifier

bool: True if the object with a given id is a text object

import rhinoscriptsyntax as rs
id = rs.GetObject("Select a text object")
if rs.IsText(id):
    print("The object is a text object.")
else:
    print("The object is not a text object.")

object_id (guid): the object's identifier

bool: True if the object with a given id is a text dot object

import rhinoscriptsyntax as rs
id = rs.GetObject("Select a text dot object")
if rs.IsTextDot(id):
    print("The object is a text dot object.")
else:
    print("The object is not a text dot object.")

object_id (guid): the point cloud object's identifier

number: number of points if successful

import rhinoscriptsyntax as rs
id = rs.GetObject("Select point cloud", rs.filter.pointcloud)
print("Point count:{}".format(rs.PointCloudCount(id)))

object_id (guid): the point cloud object's identifier

bool: True if cloud has hidden points, otherwise False

import rhinoscriptsyntax as rs
obj = rs.GetObject("Select a point cloud", rs.filter.pointcloud)
if rs.PointCloudHasHiddenPoints(obj):
    print("The point cloud has hidden points.")
else:
    print("The point cloud has no hidden points.")

object_id (guid): the point cloud object's identifier

bool: True if cloud has point colors, otherwise False

import rhinoscriptsyntax as rs
obj = rs.GetObject("Select a point cloud", rs.filter.pointcloud)
if rs.PointCloudHasPointColors(obj):
    print("The point cloud has point colors.")
else:
    print("The point cloud has no point colors.")

object_id (guid): the point cloud object's identifier
hidden ([bool, ....]): list of booleans matched to the index of points to be hidden

list(bool, ....): List of point cloud hidden states

import rhinoscriptsyntax as rs
obj = rs.GetObject("Select point cloud", rs.filter.pointcloud)
if obj:
    hidden = [True] * rs.PointCloudCount(obj)
    for i in range(len(hidden)):
        hidden[i] = (i%2==0)
    rs.PointCloudHidePoints(obj, hidden)

object_id (guid): the point cloud object's identifier
colors ([color, ...]) list of color values if you want to adjust colors

list(color, ...): List of point cloud colors

import rhinoscriptsyntax as rs
import random
       
def RandomColor():
    red = random.randint(0,255)
    green = random.randint(0,255)
    blue = random.randint(0,255)
    return rs.coercecolor((red,green,blue))
       
obj = rs.GetObject("Select point cloud", rs.filter.pointcloud)
if obj:
    colors = [RandomColor() for i in range(rs.PointCloudCount(obj))]
    rs.PointCloudColors(obj, colors)

object_id (guid): the point cloud object's identifier

list(guid, ...): list of points if successful

import rhinoscriptsyntax as rs
id = rs.GetObject("Select point cloud", rs.filter.pointcloud)
points = rs.PointCloudPoints(id)
if points: for point in points: print(point)

pt_cloud (guid|[point, ...]): the point cloud to be searched, or the "hay stack". This can also be a list of points.
needle_points (guid|[point, ...]): a list of points to search in the point_cloud. This can also be specified as a point cloud.
amount (int, optional): the amount of required closest points. Defaults to 1.

[int, int,...]: a list of indices of the found points, if amount equals 1.
[[int, ...], ...]: nested lists with amount items within a list, with the indices of the found points.

import rhinoscriptsyntax as rs
id = rs.GetObject("Select point cloud", rs.filter.pointcloud)
if id:
    result = rs.PointCloudKNeighbors(id, [(0,0,0)])
    if result:
        print("The closest point to origin has index : %s." % result[0])

pt_cloud (guid|[point, ...]): the point cloud to be searched, or the "hay stack". This can also be a list of points.
needle_points (guid|[point, ...]): a list of points to search in the point_cloud. This can also be specified as a point cloud.
distance (float): the included limit for listing points.

[[int, ...], ...]: a list of lists with the indices of the found points.

import rhinoscriptsyntax as rs
id = rs.GetObject("Select point cloud", rs.filter.pointcloud)
if id:
    result = rs.PointCloudClosestPoints(id, [[0,0,0]], 1.0)
    if result and result[0]:
        print("The first point next to origin within a 1.0 unit radius is: %s." % result[0][0])
    else:
        print("There is no point in the point cloud within a 1.0 unit radius sphere from origin.")

object_id (guid): The identifier of a point object
point (point, optional): A new 3D point location.

point: If point is not specified, the current 3-D point location
point: If point is specified, the previous 3-D point location

import rhinoscriptsyntax as rs
id = rs.GetObject("Select point", rs.filter.point)
point = rs.PointCoordinates(id)
if point: print(point)

object_id (guid): identifier of a text dot object
fontface (str, optional): new font face name

str: If font is not specified, the current text dot font
str: If font is specified, the previous text dot font
None: on error

import rhinoscriptsyntax as rs
obj = rs.GetObject("Select text dot")
if rs.IsTextDot(obj): rs.TextDotFont( obj, "Arial" )

object_id (guid): identifier of a text dot object
height (number, optional) new font height

number: If height is not specified, the current text dot height
number: If height is specified, the previous text dot height
None: on error

import rhinoscriptsyntax as rs
obj = rs.GetObject("Select text dot")
if rs.IsTextDot(obj): rs.TextDotHeight(obj, 10.0)

object_id (guid): identifier of a text dot object
point (point, optional): A new 3D point location.

point: If point is not specified, the current 3-D text dot location
point: If point is specified, the previous 3-D text dot location
None: if not successful, or on error

import rhinoscriptsyntax as rs
id = rs.GetObject("Select text dot")
if rs.IsTextDot(id):
    point = rs.TestDotPoint(id)
    rs.AddPoint( point )
    rs.TextDotPoint(id, [0,0,0])

object_id (guid): The identifier of a text dot object
text (str, optional): a new string for the dot

str: If text is not specified, the current text dot text
str: If text is specified, the previous text dot text
None: if not successful, or on error

import rhinoscriptsyntax as rs
id = rs.GetObject("Select text dot")
if rs.IsTextDot(id):
    rs.TextDotText( id, "Rhino")

object_id (guid): the identifier of a text object
font (str): the new font face name

str: if a font is not specified, the current font face name
str: if a font is specified, the previous font face name
None: if not successful, or on error

import rhinoscriptsyntax as rs
obj = rs.GetObject("Select text")
if rs.IsText(obj): rs.TextObjectFont(obj, "Arial")

object_id (guid): the identifier of a text object
height (number, optional): the new text height.

number: if height is not specified, the current text height
number: if height is specified, the previous text height
None: if not successful, or on error

import rhinoscriptsyntax as rs
obj = rs.GetObject("Select text")
if rs.IsText(obj):
    rs.TextObjectHeight( obj, 1.0 )

object_id (guid): the identifier of a text object
plane (plane): the new text object plane

plane: if a plane is not specified, the current plane if successful
plane: if a plane is specified, the previous plane if successful
None: if not successful, or on Error

import rhinoscriptsyntax as rs
obj = rs.GetObject("Select text")
if rs.IsText(obj):
    plane = rs.ViewCPlane("Top")
    rs.TextObjectPlane( obj, plane )

object_id (guid): the identifier of a text object
point (point, optional) the new text object location

point: if point is not specified, the 3D point identifying the current location
point: if point is specified, the 3D point identifying the previous location
None: if not successful, or on Error

import rhinoscriptsyntax as rs
obj = rs.GetObject("Select text")
if rs.IsText(obj):
    rs.TextObjectPoint( obj, [0,0,0] )

object_id (guid) the identifier of a text object
style (number, optional) the font style. Can be any of the following flags
   0 = Normal
   1 = Bold
   2 = Italic

number: if style is not specified, the current font style
number: if style is specified, the previous font style
None: if not successful, or on Error

import rhinoscriptsyntax as rs
obj = rs.GetObject("Select text")
if rs.IsText(obj):
    rs.TextObjectStyle( obj, 3 )

object_id (guid): the identifier of a text object
text (str, optional): a new text string

str: if text is not specified, the current string value if successful
str: if text is specified, the previous string value if successful
None: if not successful, or on error

import rhinoscriptsyntax as rs
obj = rs.GetObject("Select text")
if rs.IsText(obj): rs.TextObjectText(obj, "Rhino")

object_id (guid): identifier of the object
enable (bool, optional): if True, the specified object's grips will be turned on.
  Otherwise, they will be turned off

bool: True on success, False on failure

import rhinoscriptsyntax as  rs
objects = rs.GetObjects("Select  objects")
if objects: [rs.EnableObjectGrips(obj)  for obj in objs]

message (str, optional): prompt for picking
preselect (bool, optional): allow for selection of pre-selected object grip.
select (bool, optional): select the picked object grip.

tuple(guid, number, point): defining a grip record.
   [0] = identifier of the object that owns the grip
   [1] = index value of the grip
   [2] = location of the grip
None: on error

import rhinoscriptsyntax as rs
curve = rs.GetObject("Select a curve", rs.filter.curve)
if curve:
    rs.EnableObjectGrips( curve )
    grip = rs.GetObjectGrip("Select a curve grip")
    if grip: print(grip[2])

message (str, optional): prompt for picking
preselect (bool, optional): allow for selection of pre-selected object grips
select (bool, optional) select the picked object grips

list((guid, number, point), ...): containing one or more grip records. Each grip record is a tuple
  [n][0] = identifier of the object that owns the grip
  [n][1] = index value of the grip
  [n][2] = location of the grip
None: on error

import rhinoscriptsyntax as rs
curves = rs.GetObjects("Select curves", rs.filter.curves)
if curves:
    for curve in curves: rs.EnableObjectGrips(curve)
    grips = rs.GetObjectGrips("Select curve grips")
    if grips: for grip in grips: print(grip[0])

object_id (guid): identifier of the object
index (number): zero based grip index from which to get the next grip index
direction ([number, number], optional): direction to get the next grip index (0=U, 1=V)
enable (bool, optional): if True, the next grip index found will be selected

number: index of the next grip on success
None: on failure

import rhinoscriptsyntax as rs
object_id = rs.GetObject("Select curve", rs.filter.curve)
if object_id:
    rs.EnableObjectGrips( object_id )
    count = rs.ObjectGripCount( object_id )
    for i in range(0,count,2):
        rs.NextObjectGrip(object_id, i, 0, True)

object_id (guid): identifier of the object

number: number of grips if successful
None: on error

import rhinoscriptsyntax as rs
obj = rs.GetObject("Select object")
if rs.ObjectGripsOn(obj):
    print("Grip count ={}".format(rs.ObjectGripCount(obj)))

object_id (guid) identifier of the object
index (number): index of the grip to either query or modify
point (point, optional): 3D point defining new location of the grip

point: if point is not specified, the current location of the grip referenced by index
point: if point is specified, the previous location of the grip referenced by index
None: on error

import rhinoscriptsyntax as rs
obj = rs.GetObject("Select curve", rs.filter.curve)
if obj:
    rs.EnableObjectGrips(obj)
    point = rs.ObjectGripLocation(obj, 0)
    point[0] = point[0] + 1.0
    point[1] = point[1] + 1.0
    point[2] = point[2] + 1.0
    rs.ObjectGripLocation(obj, 0, point)
    rs.EnableObjectGrips(obj, False)

object_id (guid): identifier of the object
points ([point, ...], optional) list of 3D points identifying the new grip locations

list(point, ...): if points is not specified, the current location of all grips
list(point, ...): if points is specified, the previous location of all grips
None: if not successful

import rhinoscriptsyntax as rs
obj = rs.GetObject("Select curve", rs.filter.curve)
if obj:
    rs.EnableObjectGrips( obj )
    points = rs.ObjectGripLocations(obj)
    for point in points:  print(point)

object_id (guid): identifier of the object

bool: True or False indicating Grips state
None: on error

import rhinoscriptsyntax as rs
obj = rs.GetObject("Select object")
if rs.ObjectGripsOn(obj):
    print("Grip count = {}".format(rs.ObjectGripCount(obj)))

object_id (guid): identifier of the object

bool: True or False indicating success or failure

import rhinoscriptsyntax as rs
obj = rs.GetObject("Select object")
if rs.ObjectGripsSelected(obj):
    rs.UnselectObjectGrips( obj )

object_id (guid): identifier of the object
index (number): zero based grip index from which to get the previous grip index
direction ([number, number], optional): direction to get the next grip index (0=U, 1=V)
enable (bool, optional): if True, the next grip index found will be selected

number: index of the next grip on success
None: on failure

import rhinoscriptsyntax as rs
object_id = rs.GetObject("Select curve", rs.filter.curve)
if object_id:
    rs.EnableObjectGrips(object_id)
    count = rs.ObjectGripCount(object_id)
    for i in range(count-1, 0, -2):
        rs.PrevObjectGrip(object_id, i, 0, True)

object_id (guid): identifier of the object

list(number): list of indices on success
None: on failure or if no grips are selected

import rhinoscriptsyntax as rs
obj = rs.GetObject("Select curve", rs.filter.curve)
if obj:
    rs.EnableObjectGrips( obj )
    count = rs.ObjectGripCount( obj )
    for i in range(0,count,2):
        rs.SelectObjectGrip( obj, i )
    grips = rs.SelectedObjectGrips(obj)
    if grips: print(len(grips{}).format("grips selected"))

object_id (guid) identifier of the object
index (number): index of the grip to select

bool: True or False indicating success or failure

import rhinoscriptsyntax as rs
obj = rs.GetObject("Select curve", rs.filter.curve)
if obj:
    rs.EnableObjectGrips( obj )
    count = rs.ObjectGripCount( obj )
    for i in range(0,count,2): rs.SelectObjectGrip(obj,i)

object_id (guid): identifier of the object

number: Number of grips selected on success
None: on failure

import rhinoscriptsyntax as rs
obj = rs.GetObject("Select object")
if rs.ObjectGripsSelected(obj)==False:
    rs.SelectObjectGrips( obj )

object_id (guid): identifier of the object
index (number): index of the grip to unselect

bool: True or False indicating success or failure

import rhinoscriptsyntax as rs
obj = rs.GetObject("Select curve", rs.filter.curve)
if obj:
    rs.EnableObjectGrips( obj )
    count = rs.ObjectGripCount(obj)
    for i in range(0,count,2):
        rs.UnselectObjectGrip( obj, i )

object_id (guid): identifier of the object

number: Number of grips unselected on success
None: on failure

import rhinoscriptsyntax as rs
obj = rs.GetObject("Select object")
if rs.ObjectGripsSelected(obj): rs.UnselectObjectGrips(obj)

group_name (str, optional): name of the new group. If omitted, rhino automatically
    generates the group name

str: name of the new group if successful
None: is not successful or on error

import rhinoscriptsyntax as rs
name = rs.AddGroup("NewGroup")

object_ids ([guid, ...]) list of Strings or Guids representing the object identifiers
group_name (str): the name of an existing group

number: number of objects added to the group

import rhinoscriptsyntax as rs
name = "NewGroup"
object_ids = rs.GetObjects("Select objects to add to group")
if object_ids: rs.AddObjectsToGroup(object_ids, name)

object_id (guid): String or Guid representing the object identifier
group_name (str): the name of an existing group

True or False representing success or failure

import rhinoscriptsyntax as rs
name = "NewGroup"
id = rs.GetObject("Select object to add to group")
if id: rs.AddObjectToGroup(id,name)

group_name (str): the name of an existing group

bool: True or False representing success or failure

import rhinoscriptsyntax as rs
groups = rs.GroupNames()
if groups:
    for group in groups: rs.DeleteGroup(group)