python.rhino3d.com - Blogs

Python Goodies - the sorted function

Steve Baer — Tue, 18 Oct 2011 17:35:25 GMT

There are so many nice little features of python. Here's a good one to learn; the sorted function.

sorted(iterable[, cmp[, key[, reverse]]]) - http://wiki.python.org/moin/HowTo/Sorting/
This function takes a list and returns a sorted version of the list. That's nice...... but I wouldn't write a blog post about this if that was all this function does. Here's what I really like about the sorted function, the optional key argument. This argument lets you define a function that tells the sorted function what to use to compare different entries in the list.

I recently attended a Rhino python workshop and a student with a background in RhinoScript was putting together a python script that sorted a bunch of curves based on the Z height of each curve's start point. This isn't necessarily hard to do, but it does involve quite a few lines of script to write the sorting routine, and you can potentially write very slow scripts if you aren't careful about your sorting algorithm.

Here's how this script could be written in python using the sorted function along with the key parameter. The function asks you to select a bunch of curves and then adds text dots to the start point of every curve sorted by the curve's start point Z height

Python Code:

import rhinoscriptsyntax as rs

def curvekey(curve):

point = rs.CurveStartPoint(curve)

return point[2]

def SortCurvesByZ():

curves = rs.GetObjects("Select Curves", rs.filter.curve)

if not curves: return

sorted_curves = sorted(curves, key=curvekey)

for i, curve in enumerate(sorted_curves):

point = rs.CurveStartPoint(curve)

rs.AddTextDot(i+1, point)

if __name__=="__main__":

SortCurvesByZ()

Here's a breakdown of what is happening.
GetObjects is called so that the user can select a bunch of curves

Once we a list, we call the sorted function passing the curves and using the named parameter of key=curvekey

sorted() goes about its job of sorting the list, but since the key parameter was set it knows to call the curvekey function to get a value to use for comparison when sorting.

We defined curvekey as a function that takes a single input parameter. This is what the key parameter in sorted is expecting; a function that takes a single parameter and returns some sort of value that it knows how to compare. curvekey is called for every item in the list and we return a floating point number (the z height of the start point). The floating point number returned is what sorted uses to compare each item's "value"

sorted returns a new list of curves that are now in sorted order. We just walk through the new list and add text dots so we can see that things are working.

Pretty darn useful function to keep in your python toolbox!

Kinect2RhinoSkeleton through OpenNI/OSCeleton

bar — Sun, 21 Aug 2011 20:41:42 GMT

After installing OpenNI you need to unzip the donwload file and start osceleton.exe.
Then you start test_rhino.py through EditPythonScript in Rhino5.
Finally OpenNI/Kinect must detect a skeleton. For this reason you have to do the "init-gesture", i.e. spreading your arms and lifting them, while the kinect sees your upper body .
It is also possible to record data and play them back if you are a bit shy or lazy.
Comments:
Besides OpenNI you need OSCeleton and pyOsc which are both OpenSource projects.
For convenience I included them for this project.
the pure Python pyOSC needed minor modification to be Ironpython compatible-> ipyOSC

Attached Files

Is there a way to change the size of the font inside the editing Python editor?

andres — Sun, 24 Jul 2011 02:41:23 GMT

Hi, it is not that I can not read it, but when you teach, the students on the back of the room can not read the lines...

Thanks

Andres

My First RhinoPython Script

Dale Fugier — Wed, 06 Jul 2011 16:14:12 GMT

I know this is kinda cheezy, since I use the RhinoScript syntax. But hey! gotta start somewhere...

Python Code:

###############################################################################

# ArchimedeanSpiral.py -- July 2011

# If this code works, it was written by Dale Fugier.

# If not, I don't know who wrote it.

#

# Change 'a_const' to turn the spiral.

# Change 'b_const' to control the distance between turnings.

import rhinoscriptsyntax as rs

def ArchimedeanSpiral():

print "Archimedean Spiral: Radius = A + B * Theta"

a_const = rs.GetReal("Value of A constant", 1.0, 0.01)

if a_const is None: return

b_const = rs.GetReal("Value of B constant", 1.0, 0.01)

if b_const is None: return

num_points = rs.GetInteger("Number of points to calculate", 10, 1)

if num_points is None: return

step_angle = rs.GetReal("Angle between points", 30.0, 1.0, 45.0)

if step_angle is None: return

curr_angle = 0.0

base_point = [0.0, 0.0, 0.0]

points = []

for i in xrange(0, num_points):

radius = a_const + (b_const * curr_angle)

pt = rs.Polar(base_point, radius, curr_angle)

points.append(pt)

curr_angle = curr_angle + step_angle

rs.AddInterpCurve(points)

##########################################################################

# Check to see if this file is being executed as the "main" python

# script instead of being used as a module by some other python script

# This allows us to use the module which ever way we want.

if( __name__ == "__main__" ):

ArchimedeanSpiral()

Enjoy!

Numpy and Scipy in RhinoPython

Steve Baer — Mon, 27 Jun 2011 21:14:25 GMT

Disclaimer: I have very little experience with numpy and scipy so you are going to do better by searching google for support with these libraries. This blog is about getting these libraries to run in Rhino.

Yes it is possible now!!!
Okay, here's what I did to get numpy/scipy running in Rhino

1 - Install Rhino 5 (32bit version)
numpy/scipy uses C++ DLLs which need to be compiled for a specific platform. Currently numpy/scipy for IronPython will only run in 32bit applications on Windows. I contacted the guys at Enthought and they do plan on releasing a 64bit version for Windows, but they want to make sure everything is working on 32bit first. They have some doubts about being able to release a mono version for you Mac guys out there.

2 - Install numpy/scipy for IronPython
Follow the instructions on this site http://www.enthought.com/repo/.iron/

3 - Modify settings in RhinoPython
Start Rhino 5 - 32bit version and run "EditPythonScript" to bring up the editor. Go to the options dialog by selecting Tools->Options from the menu

Add site-packages and DLLs to the search paths (see image). This helps RhinoPython find the numpy/scipy packages and associated DLLs.

Check the "Frames Enabled" option since numpy/scipy requires this to be turned on.

I decided to make the "Frames Enabled" an optional engine feature since it does have a performance impact on scripts. Numpy/scipy requires this feature to be turned on.

4 - Run a test

Python Code:

# For now, we need to manually load mtrand before using numpy or scipy

# I'm still trying to figure out why mtrand is not automatically getting

# loaded when numpy/scipy imports it. If I can fix this, we won't need

# the following two lines

import clr

clr.AddReference("mtrand")

import numpy

import rhinoscriptsyntax as rs

x_coord = [ 0, 1, 2, 3, 4, 5, 6]

y_coord = [0.0,0.1,0.5,2.5,2.5,2.5,4.0]

xyz = zip(x_coord,y_coord,[0]*len(x_coord))

rs.AddPoints(xyz)

degree = 5

eq = numpy.polyfit(x_coord, y_coord, degree)

fitfunc = numpy.poly1d(eq)

fit_points = []

for i in range(61):

x = i/10.0

y = fitfunc(x)

fit_points.append((x, y, 0))

rs.AddPolyline(fit_points)

If you get a polyline in rhino fit through a series of point then you are all all set; if not go back to step 1 and repeat.

This looks like a good place to start if you want to learn more about numpy/scipy
http://docs.scipy.org/doc/

Kinect SDK

Steve Baer — Fri, 17 Jun 2011 16:31:46 GMT

YES!!! This could lead to some incredible applications.

http://research.microsoft.com/en-us/...cts/kinectsdk/

Now if they only had a version that clipped to your monitor and tracked your fingers...

Outside the Box 2 - Calling the Shapeways API from Python

Steve Baer — Thu, 02 Jun 2011 19:48:24 GMT

I received a question on accessing the ShapeWays API from my last "Outside the Box" blog and figured I should dig in and figure out what is going on. Shapeways has a web service API that uses SOAP and a WSDL page (http://en.wikipedia.org/wiki/Web_Ser...ption_Language) as described here
http://www.shapeways.com/api

This API is a bit different than the REST API which I wrote a script to access in my previous blog post. In order to use this API, I ended up modifying a script originally put together by Michael Foord (author of "IronPython in Action") that creates a .NET assembly on the fly for a given WSDL url.

Here are the two scripts:
useshapeways.py
wsdlprovider.py

Place both of these scripts in the same directory and open the "useshapeways.py" script. Here's the script itself

Python Code:

"""Sample script that accesses the shapeways API

[url]http://www.shapeways.com/api[/url]

"""

import wsdlprovider

wsdl_url = "http://api.shapeways.com/v1/wsdl.php"

username = "username"

password = "password"

application_id = "rhinotest"

assembly = wsdlprovider.GetWebservice(wsdl_url)

shapeways = assembly.SWwsdlService()

session_id = shapeways.login(username, password, application_id)

if session_id:

#get list of printers available

printers = shapeways.getPrinters(session_id, "", application_id)

if printers:

for printer in printers:

print "printer:", printer.title

for material in printer.materials:

print " - material ", material.title

The script uses the wsdlprovider script to generate a .NET assembly from the shapeways wsdl url. This assembly has a class in it called SWwsdlService which we create an instance of and call functions on. It looks like a normal class to python, but all of the function calls are sent to ShapeWays over the internet and response are turned into classes that you can use. This sample simply logs into shapeways to get a "session id" and then asks Shapeways for a list of it's available printers along with what materials each printer supports.

At the time of this blog post, the printed output from this script is
Code:
printer: Somatech FDM
 - material  Grey Robust
printer: Somatech Objet 720
 - material  Black Detail
 - material  White Detail
 - material  Transparent Detail
printer: SLS Printer
 - material  White Strong & Flexible
printer: Metal Printer matt
 - material  Gold Plated Glossy
 - material  Antique Bronze Glossy
 - material  Antique Bronze Matte
 - material  Stainless Steel
printer: SLS Color Printer
 - material  Black Strong & Flexible
printer: Silver Printer
 - material  Silver Glossy
 - material  Silver
printer: ZPrinter 650
 - material  Sandstone
 - material  Full Color Sandstone
printer: SLS Alumide
 - material  Alumide
printer: Glass Printer
 - material  High Gloss Black Glass
 - material  High Gloss White Glass
 - material  Milky White Matte Glass
printer: Metal printer Gold
 - material  Gold Plated Matte
printer: SLS Color Printer New
 - material  Dark Grey Strong and Flexible
 - material  Indigo Strong and Flexible
 - material  Winter Red Strong and Flexible
printer: HD printer
 - material  Frosted Detail
printer: UHD printer
 - material  Frosted Ultra Detail
printer: SLS Printer polished
 - material  White Strong & Flexible Polished
printer: Ceramics printer
 - material  Glazed Ceramics
Pretty neat!

Multithreaded Python

Steve Baer — Wed, 01 Jun 2011 19:52:35 GMT

One of the nice bits that we have access to in Rhino python is the Task Parallel Library that is built into .NET 4
http://msdn.microsoft.com/en-us/libr...ing.tasks.aspx

This set of classes and functions makes it relatively easy to write things like parallel for loops in which every iteration of the loop may be processed on different threads. This nice thing about parallel for loops is that they make coding with multiple threads much simpler since the "multi-threading" only occurs inside the for loop and once the loop is finished you know that the all of the threads have completed and you are back on the main execution thread.

Here's a sample python script (standalone and in a grasshopper definition) which runs many Plane-Brep intersections either on a single thread or using multiple threads.
radial_contour.py
radial_contour.ghx

Outside the Box - Using Web Services from Python

Steve Baer — Fri, 27 May 2011 18:14:17 GMT

I've been trying to learn more about things like web services and APIs provided by internet companies (gotta figure out what all of these buzzwords are.) One thing I've noticed is that many companies now provide a REST API which return JSON objects. There are enough resources on the web that describe REST and JSON that I don't need to repeat it here; I'm just going to get to my python experiments on this technology.

Attached are a python script and a grasshopper definition containing a python component.
googletranslate.ghx
googletranslate.py

So what does it do?
The python script uses the Google Translate API to translate text from one language to another. Maybe not the most useful new tool for Rhino, but it shows how simple it is to format a request to a web service and get at the results.

Some important things to note:
The scripts in both attachments are exactly the same. There is code in the script to figure out if it is running as a normal Rhino python script or inside of Grasshopper.

The script does different things when it is running in Rhino versus when running in Grasshopper. In Rhino, the script converts text dot text which in Grasshopper the script uses input and output variables.

I'm using the sticky variable to cache results. This way we don't have to keep going out to Google if we are translating the same text over and over again

Search around on the internet for REST apis that return JSON data. Your python scripts that use these other services will end up looking pretty similar to the samples I posted (unless you don't like my scripting style;)) Here are some interesting APIs to look at:
http://code.google.com/more/
http://friendfeed.com/api/documentation
http://www.flickr.com/services/api/
http://developer.ning.com/docs/ningapi/1.0/index.html
http://develop.github.com/
http://api.pachube.com/

Python component for Grasshopper

Steve Baer — Mon, 02 May 2011 23:56:37 GMT

Giulio Piacentino and I have been working on an update to the grasshopper/python component and finally have something to show off!!!

http://www.food4rhino.com/project/ghpython - NOTE: Will only work in Rhino 5

This component is a scripting component similar to the VB.NET and C# components that ship with Grasshopper. You get a component where you can define as many input and output variables as you want and then reference these variables in the python script.

If you double click on the component, you get a light version of the python script editor which you are used to in the EditPythonScript command (keywords are colorized and functions autocomplete when possible)

But there is a cool twist... this component supports the rhinoscriptsyntax functions. The rhinoscriptsyntax functions can be set to generate geometry inside of Grasshopper that does not live in the Rhino document. We are using a concept called "duck typing" to swap the document that the rhinoscriptsyntax functions use from the rhino document to a grasshopper document. This means that the following script

Python Code:

import rhinoscriptsyntax as rs

for x in range(10):

rs.AddPoint((x,0,0)

will add 10 points to the Rhino document when run from Rhino's "RunPythonScript" or "EditPythonScript" functions. The same script will add 10 points to a grasshopper document that can be passed on to other grasshopper components when run inside the syntax of grasshopper.

We are writing this as an open source project which is hosted at
https://github.com/mcneel/ghpython
Developers are welcome to download, compile, and tinker with the component source code. If you find bugs or want to add features, let us know and we'll figure out how to get you more involved in the development process.

You can also log bugs and wishlist items at
https://github.com/mcneel/ghpython/issues

Use your python scripting skills in Rhino 5 for Windows, Rhino 5 for Mac, and in Grasshopper for Rhino 5;)
Thanks,
-Steve

Running scripts from Toolbar buttons

Steve Baer — Mon, 11 Apr 2011 17:47:53 GMT

This is only for Windows Rhino right now since you can't customize toolbar buttons on Mac yet, but once that feature becomes available I'm pretty sure the technique will be the same.

In Rhino, create a new toolbar button and edit it. Consult the Rhino help for for adding and editing toolbar buttons. Now you have three options (that I can think of at the moment) for adding a python script to a toolbar button. All of these involve executing the RunPythonScript command

Directly embed the script
Make sure the first line reads -_RunPythonScript (. Note that there needs to be a space between RunPythonScript and the parentheses.
Make sure the last line is just a closing parentheses. The lines in between are interpreted as your python script.

Python Code:

-_RunPythonScript (

import rhinoscriptsyntax as rs

point0 = rs.GetPoint("start")

point1 = rs.GetPoint("end")

rs.AddLine(point0,point1)

)

Absolute path to the script
-_RunPythonScript (C:\Users\a-steve\Desktop\CurveLength.py)

Path to script on search path
If the script is on python's search path, you can use the following form to let python find the script (use period separate subdirectories.)
-_RunPythonScript (Samples.CurveLength.py)

Komodo Edit on Mac and RhinoPython

Steve Baer — Tue, 15 Mar 2011 16:45:07 GMT

Komodo Edit can be configured to recognize the rhinoscriptsyntax module which provides for editor features like autocomplete and function tooltips.

Download and start Komodo Edit - http://www.activestate.com/komodo-edit

On the menu, select Komodo->Preferences...

Expand "Languages" and select "Python"

In the Additional Python Import Directories click on the "add" button and navigate to
/Users//Application Support/McNeel/Rhinoceros/MacPlugIns/IronPython/settings/lib

Click OK, it may take a minute for Komodo Edit to parse all of the files and generate autocomplete information, but once that is done you should be able to type your Mac Rhino python scripts with a little help from Komodo!!

ACADIA and MIT wrap up

Steve Baer — Tue, 26 Oct 2010 17:10:03 GMT

Just got back from a trip to New York and Boston for the ACADIA conference (http://www.acadia.org/acadia2010/). I want to thank everyone that spent the time to meet with me and talk python. In particular, it was great getting together with
Marc Fornes - http://theverymany.com/
Skylar Tibbits - http://www.sjet.us/

who from what I can tell are doing most of their Rhino oriented scripting in python now. Nice!

-Steve

StarMaker - An advanced sample

Steve Baer — Thu, 22 Jul 2010 20:33:40 GMT

Here's a sample that demonstrates quite a few of the advanced features in Rhino.python. This sample was written and tested on Windows (I doubt it is going to work very well on OSX given that Windows.Forms are being used.) You are going to need to be running at least the July 20th build of Rhino 5 to test this.

StarMaker is composed of two script files; starmaker.py and sliderform.py. Save these files to the same directory.

What does it do? StarMaker just creates a new curve based on points from a closed planar polyline and some input from a form. Run the Polygon command and create a polygon with something like 30 edges. Then run starmaker.py

Some python features demonstrated:
Multiple Script Files - the python script is broken into two files. sliderform.py doesn't do anything on it's own and is imported into starmaker.py

Direct use of RhinoCommon - the script uses some of the functionality provided by the rhinoscript python functions, but it really makes heavy use of .NET classes defined in RhinoCommon

Custom Windows Form - This is pretty cool!!! sliderform.py is a custom Wnidows Form user interface. This file was actually created in SharpDevelop (http://www.icsharpcode.net/opensource/sd/). SharpDevelop has a nice user interface editor for creating custom forms which are written as python files. Try opening sliderform.py in SharpDevelop and click on the design button. (See the attached SharpDev image)

Custom Display for Preview Geometry - The red curve, dotted lines, and points in the screenshot are not actual geometry in the rhino document but are drawn using display callbacks (also know as conduits)

Calling RhinoCommon from python hasn't been covered too much on this site so much of the script may look foreign.

I want to thank Marc Fornes of www.theverymany.com for inspiring this sample.

Attached Thumbnails

Attached Files

Configuring Pydev for Rhino.Python

Steve Baer — Sat, 12 Jun 2010 23:40:31 GMT

NOTE: This article is specific to getting Pydev to work on Windows. I've had problems getting the ironpython interpreter to work inside Pydev on Mac. Hopefully this will inspire someone to hack away at the Mac version of Pydev and figure out what it takes to make it work for Rhino.Python.

What's Pydev?
The folks at Pydev can probably do a much better job of explaining their product (http://pydev.org/index.html). In short, Pydev is a popular Python script editor (and debugger). Several python scripters who are familiar with Pydev have asked about how to configure it for editing Rhino.Python scripts.

Rhino for windows already comes with a built-in python editor, but I can understand that people will want to use a different editor for many reasons (they're familiar with it or it has features that are missing in the Rhino editor.) Here's the steps I took to get this to work on my Windows 7 computer.

A. Install Pydev - Here's a page I used to get everything set up for Pydev http://pydev.org/manual_101_root.html
If you've already installed Pydev on your computer, you can skip this section.
Download eclipse (http://www.eclipse.org/downloads/).
I downloaded Eclipse Classic 3.6.1 (~170MB) 32bit version for windows.
I downloaded the 32 bit version because I haven't installed the 64 bit version of java on my computer and eclipse requires java to run.
File name is eclipse-SDK-3.6.1-win32.zip

Unzip file and double click on the eclipse.exe to start eclipse

go to help->Install Software and type the following URL into the Work with text box
http://pydev.org/updates

You should get checkboxes for available pydev plug-ins. Check the Pydev item and click next, then finish

This installs the pydev plug-in for eclipse

B. Install IronPython Executables
Rhino.Python uses Microsoft's IronPython engine to process python scripts. Pydev is going to need to use this same engine in order to get things like auto-complete to work.
Go to codeplex and Install "IronPython 2.6.2 for .NET 4.0" http://ironpython.codeplex.com/releases/view/41236
The download link is in the upper right corner of the web page

This installs the command IronPython command line interpreter which is needed by PyDev

C. Configure Pydev
Start eclipse.exe

Select Preferences from the Window menu

Expand the Pydev node in the preferences tree and select "Interpreter - Iron Python"

Click the "New..." button which brings up a "Select Interpreter" dialog

Click the "Browse..." button and select ipy.exe which on my computer happens to be located at
C:\Program Files (x86)\IronPython 2.6\ipy.exe

Click OK and then another OK to accept the default folders added to the SYSTEM pythonpath

Add the lib folder that contains the rhinoscript package to the system python path in order for Pydev to recognize any of the rhinoscript functions
On the Libraries tab click click the "New Folder" button and pick the directory where the rhinoscript package is located. You can find this folder location by looking at the Paths in the built-in Rhino.Python editor. On my computer this directory is located at
C:\Users\a-steve\AppData\Roaming\McNeel\Rhinoceros\5.0\Plug-ins\IronPython (814d908a-e25c-493d-97e9-ee3861957f49)\settings\lib

Add RhinoCommon as a "Forced Builtin". In order to do this we need to create a directory that will be on the python path. I created a new folder in the eclipse directory called pydevrhino and added it to the python path by clicking the "New Folder" button on the Libraries tab and selecting this new folder. On my computer, this folder is located at
C:\Users\a-steve\Desktop\eclipse-SDK-3.5.2-win32\pydevrhino

Pydev has a limitation where it can only read .NET assemblies with a root namespace the same as the dll. We want to get at all of the classes inside of RhinoCommon.DLL, but the root namespace in this DLL is Rhino. Go to the Rhino5 system folder (where the main executable is located) and copy RhinoCommon.dll (and RhinoCommon.xml) to the new folder that you created in the previous step. In the new folder, rename these files to Rhino.dll and Rhino.xml (DON'T CHANGE THE FILES IN THE RHINO SYSTEM DIRECTORY).

Go to the "Forced Builtins" tab, click New... button and type in "Rhino".

D. Start Using Pydev
Good luck! Here's what I get for autocomplete on Rhino and rhinoscript classes/functions