I haven´t written about Py4D for quite a while now…

In the meantime, Maxon has first announced a cooperation with – and now the acquisition of Sebastian Rath´s praised python implementation for Cinema4D.

So finally – Cinema4D meets Python!

Let´s celebrate with some cool experiments!

If you are new to this blog or Py4D – a short introduction:

Py4D enhances C4D with a standard Python interpreter that provides access to the C4D SDK and allows to easily code platform indepentent scripts and plugins that control or extend C4D.

Basicly the same as COFFEE, C4D´s own scripting language, but Py4D has two major advantages:

• It follows the C++ SDK more closely and implements it further than COFFEE does.
• It is a easy to pickup, widely known language with a huge community and tons of existing code and librarys.

While C4D is a mighty tool in itself, this powerful scripting interface enables the user to work with external data, automate processes or build his own tools.

Being more the C++ type when it comes to plugin development and C4D, I enjoy being able to solve small problems just by hacking a few lines of code into the script manager.
I also prototype most of my plugins in Py4D before I start developing in C++ – it´s just more convenient.
The step of compiling for every test takes much more time in the long run.

So here´s the meat:

Four simple examples how to have a good time with Py4D and some particles…

Everyone requires C4D R11.5, the Thinking Particles module and the actual version of Py4D.

Update: All files have been updated to work with the R12 version of Cinema 4D.

Py4D has been through some changes since the open beta started, so I took the time to update the scripts I published in the boids, and strange attractor posts and included them here.

Click the images for a preview.

1. Stars4Py4D

This is a Py4D port of the Sagan experiment I did in flash <- check out this link, it´s fun

A good and simple first step with particles - position vectors get parsed from a CVS database and from a galaxy of suns… “My God. It’s full of stars!”

Hint: this example might be the best to start with, as it includes comments – the others don´t, because they use pretty much the same pattern.

Just download the package, load the scene and change the path to the CSV file within the “file” user data field of the Py4D Tag.

2. Phy4D

A very simple adaptation of a 2D “physic engine” – works only with spheres.
The direction of gravitation is animated to make this a little more interesting.

Have a look at the preview video and scene file.

3. Boids

This is simply a revival of the Py4D Boids post – same beast, but updated to the Py4D release version.
The script creates a flocking boids swarm, that behaves according to the rules outlined by Craig Reynolds.

Checkout this video from Sebastian and get the scenefile.

4. Strange Attractor

Again just the script from the original strange attractor post, but ported to the final SDK.
View the final rendering and the original post – you can use the Strange Attractor Finder to locate your very own, chaotic attractor!

Here´s the scene file.

Conclusion

Python and Cinema4D are a great team and Py4D is THE alternative to COFFEE.

I hope this gives everybody who is interested in Py4D and controlling particles, a small head start, some inspiration or at least something fun to play with


Thanks to Sebastian for suggestions, support – and of course Py4D.

Cheers!

In his TV series “Cosmos”, Carl Sagan travels the universe in a “ship of the imagination”.

Uninfluenced by the laws of physics, “perfect as a snowflake, organic as a dandelion seed”, this vessel carries him between galaxies, stars, and planets.

And now you can cruise the cosmos too!



Recently I watched cosmos again and remembered how that sequence fascinated me as kid.
The sheer scale of the distances involved blew my mind. It still does today.

The concept has been revisited by many popular movies and media (Man in Black, The Simpsons…) and is always the same – the camera enters the universe, our galaxy, solar system and finally stops on earth – sometimes entering the microcosm, like the DNA of a cell.

Years ago I experimented with something like a pyramidial image to archive this effect in flash, unfortunately the result didn´t create the feeling of depth that I had hoped for.

But flash has advanced in those years… as I wrote before, in the strange attractor post, Ralph Hauwert and Joa Ebert have published some astonishing code that renders nearly half a million particles in real-time!

First I decided that I would work with real data – otherwise this would become just another “random stars / noise flying at you” screensaver.

But after some research I learned that the actual distance of nearby stars (called “stellar parallax”) is not always known, so that most models and databases project stars onto the inside of a virtual sphere.

Finally I found the HYG database – “a subset of the data in three major catalogs: the Hipparcos Catalog,the Yale Bright Star Catalog (5th Edition), and the Gliese Catalog of Nearby Stars (3rd Edition)”.
It contains about 120.000 stars, many including their parallaxes and conveniently cartesian coordinates, so I saved the step of calculating xyz from right ascension, declination and distance – like I had to with other databases I tested.

The CSV file got stripped of all additional data aside from the positions with a simple parser – that got it down from 20 to 4MB – still too big for my taste.

So I added the Fzip library to Joa´s AS3 only version of Ralph´s experiment, parsed the position vectors, scaled them and got my first view on our galaxy – breathtaking.

Scaling, controls and a simple clipping where swiftly implemented and everything was set for the voyage to the stars…

Tribute – “A Glorious Dawn” displaced

While watching the result, an idea struck my mind:
As the z-axis movement of the camera or the zooming into the szene is done by simply scaling the particle positions, its obviously possible to change their parameters in realtime…

I remembered my displacement experiment with papervision and quickly added a color parameter to the particle class, loaded an flv video and compiled this:

“A Glorious Dawn” live rendered to a displaced point cloud

Conclusion

It´s possible to handle an awful lot of particles with flash, even more if haxe/alchemy – inlining gets involved.
As the displacement experiment shows, the dataset can even be dynamic!

And hey – these are real stars, so this is science!

Hint: turn up your gamma adjustment.

Strange attractors are fractals that emerge at certain, sensitive parameters within the three-or more dimensional phase space.

They are are researched since the early 70s and strongly related to the chaos theory as they allow to watch the transition from chaos to order/geometry.

Good things first: see the result and try the chaotic attractor finder!

The 3D visualization of a strange attractor is quite resource intensive as points race around the attractors on chaotic trajectories – so it needs many iterations or particles to see a shape emerge from that chaos.

There are already some great flash experiments so I turned to Cinema 4D and PY4D as an advanced renderer would easily allow to raytrace and shadow the results – and to calculate even more particles of course.

This small PY4D script creates a strange attractor that Dr. Clifford Pickover had published 1990.

I managed to render a maximum of 50.000 particles with the R11 on my machine.

But with the new R11.5 release Maxon introduced render instances to C4D allowing now to calculate up to millions of particles – depending on the system.

I went with a number of 300.000 points, seeded the attractor parameters and rendered four transparent animations that could be combined to a 1.2 million particle video.

The preparation time for each frame was ~1min while PY4D took less than a second of that duration to perform five sinus/cosinus operations for each point.
Rendering itself took about five seconds per frame (CPU:Q6600).

If you are interested you can download the szenefile here.
(Remember to activate render instances in the PShape node of the XPresso tag).

Update:
The scene file has been updated to the R12.

When I learned that you can actually identify strange attractors using the Lyapunov exponent and found John Holder´s programm ‘lyapdemo.c’, I took a few minutes to port it to AS3.

You can use it to generate parameters for the PY4D script.