Tutorial Art Design: python

SVERCHOK / Case of Matryoshka Dolls

Happy Feet Two of Matryoshka Dolls

The other day, I was laying on bed and imagining: I think Matryoshka Dolls can be made procedurally in Sverchok using just 2 Grease Pencil strokes. And that happens!

There is a bit of research going on regarding the techniques and concepts to create the mesh for the dolls. It is really super simple, however if you actually try to make such setup, you still will learn some interesting things in this simple exercise.

01 GOOGLE SEARCH RESEARCH

There is one Matryoshka Dolls shop in Sydney, located at Darling Harbour Shopping Center. I might go there to have a look and study some of the design.

For our convenience, we can always start by looking at some images on the Internet, I use Google Search for that. Overall, we understand the shape it is really simple.

I also found this Nested Pigs made of glass the other day, very cool:

Nested Pigs,

As a side reference, you might also want to see this Gordian Anime Robot:

02 THE TECHNIQUES

Like I said, it is actually a very simple procedure to create this. When I mean 2 Grease Strokes, I really mean it. One stroke for the smallest doll and another stroke for the biggest doll. That is it.

We can then do some kind of:
- Resampling
- Interpolation
- Lathe
- Distribution
- Alignment

What interesting is the simplicity of the whole setup.

Let's create the dolls!

03 PREPARE THE DATA

Our Data is a 2 x Grease Pencil (GP) Strokes.

GP strokes is always a heavy type of data, even 2 strokes can give back around 2000 points. Just to let you know. Unless you have "Simplify" turned on in GP Preferences.

In our case, it does not really matter much, 2000 points data is still pretty light to handle in Sverchok.

From our research, we know that the smallest doll is more like an egg or baby wrapped and the tallest doll has a bit of double curve for the head and body.

NOTE:
- Grease Pencil Strokes often are connected stroke when converted into Curve, you want to F6 and get rid of the ugly connected curve.
- Careful when drawing GP strokes with nothing in 3D scene (if you happened to delete everything, including Active Camera). GP needs to always be linked to an object, at least an empty or a camera. Otherwise you may not be able to get Curve that you expected.

04. ENTER THE MATRYOSKA

(Pardon my reference to The Matrix, I just need to do it.)

After converting the GP into Curves, simply brought the curve into Sverchok environment via the node-tree. We can manipulate, edit as we need to.

05. SEPARATE AND RESAMPLE

We know that we made 2 strokes as a single Curve object, we need to separate them first using SV Separate Loose.Once we have 2 data now, we simply use SV Vector Interpolation to "resample" each of the curve.

I just use 10 points sample for now. You can use different Count.

You should see something like below.

At the moment, you only see Vertices. You cannot bake the Vertices points. If you want to bake it, you can do that after you use UV Connection and connect the edges. But save that for later.

06. More Interpolation

Using SV Evaluate Line we can further "interpolate" between the 2 curves. Before that we need to specifically filter the 2 Curves using 2 x SV List Item nodes, one for each curve.

We know that with node that has "Factor" we can actually do some "in betweener" magic.

07. SPIDER WEB SITUATION

You are starting to see where this one is going. The next step is probably the trickiest bit, but you need to take a leap of faith.

The SV Evaluate Line actually convert all the data back into 1 array of data. Just points, but still has a nice arrangements or sortings.

[ SV List Split + SV UV Connect ] combo will split those "Points Data" every-N points. By doing so, we have Points data once again ready to be converted into Points and Edge, aka Lines. This will become something that you may encounter in the future. I am not the Oracle, but you can trust me on that.

08. CLONES

We are nearly there in our journey to make the M Dolls.

What I often did not show you in my blog writing when explaining about Sverchok is that I actually check the data a lot of time using SV Viewer Text. Especially important when we are dealing Array of Data or Vectorized Input.

Matryoshka Dolls case is a perfect example to explain this. It is very Pythonic too.

We are slicing Lines into parts. We connect them again using UV Connect node, with that node we can again take advantage of SV Separate Loose, this time, it checks if Points are connected by Edge and then it can "group" or "nest" the data back.

Sverchok is very good for this kind of Separating and Combining data. Normally if you were to model this using Blender normal environment, you might go back and forth of Object and Edit mode.

Of course, Blender has Array Modifier, Curve Modifier, Particle Instancing, DupliCloning, however, using Sverchok, we have an additional workflow that we can use to streamline the process.

Next node to use is SV Lathe Node. And we are pretty much done!

All we need to do is to present it better.

09. ARRANGE AND DISTRIBUTE

Nicely arranging the Doll and distribute them from the shortest to tallest is a fun Math task.

In our case, we do not really need to worry about sorting them from shortest to tallest. That could be another tutorial. It would also be fun if we are to "Shuffle" these dolls. That is also another different puzzle. What you may not know is that SV Objects In node has a new feature added "Sort Objects Components By Objects Name". Thanks to Nikita for this.

Even Distribution of Dolls
Originally, I arrange the dolls using evenly spaced distribution:

However, a friend suggested me to distribute it more nicely, which takes consideration of the Dolls Radius and also an option to have "gap" or "spacing" in between the dolls.

Nicely Distribution of Dolls with Extra Gap
For this, you probably remember my previous post on SN Accumulator node? We can use that.

If we measure the Bounding Box of each Dolls, and Accumulate the WIDTH of each doll, we can arrange the dolls side by side in a nice way.

A more sophisticated solution is probably to use Radius of each doll and use Math formula to measure the position of each doll center. However, we probably don't need to go there, but you can certainly do that if you like to.

That is the story how the Matryoshka Dolls was made using 2 Grease Pencil strokes.

The nested dolls.

MATRYOSHKA DOLLS SV NODE TREE

Version 1:

Version 2:

HOUDINI STYLE MATRYOSHKA DOLL

[Add Link Here Later...]

SVERCHOK / Parametric Snippet 6

Inspired by Hand Drawn art of Shigeto Maeda.

Time for more snippets. Small little useful recipes to help you make a more sophisticated dishes.

SMART MASKING

Mask List
Mask Join
SN Mask Set

I learned this from Linus (thanks Linus!). He also made additional node that adds feature to the "masking" in Sverchok. This is the ability to specifically mask editing of some components.

Let see how it works in an example.

Supposed we have a Line made with 10 Vertices like below. I am using Index Viewer Draw so that we can see the actual Vertices Index number. The index started counting from 0, so for 10 vertices, we have index 0-9. Let say I want to specifically edit vertices with index number 2, 3, 6, 7.

I will summon the Mask List and Mask Join node. In the past, we only have the Mask Join node and although it is good for certain tasks, it is also limited. Mask List together with Mask Join can do more.

We know from before that in order to create "mask" we need to supply a True or False list, or a list with 0 and 1 numbers.

List pattern of 1 or 0 (True or False) can be generated using Formula2 node if the number has pattern and that is more procedural too. However, if we want to specifically give some list of index number, we want to use a helper SN script called "mask-set" from Ly.

When you download Sverchok ZIP, inside it you will find some "hidden" folder library of SN (Scripted Node) scripts. They are a collection of additional Python code that you can load into Sverchok Scripted Node and it will function like a real node.

We just want the "mask-set". I usually copy the script from its original folder into the main "node_script_templates" so that it will appear in Sverchok Script Node template library viewer.

Anyway, to cut the story short, just load the script into "Scripted Node" aka "Script Generator" inside Sverchok node-tree. After you "Import Template", just click on "Load".

Now, this little node needs its own setup to work:

In the Formula2 node, I specified the index of vertices that I want to mask. With List Length and List Range, we basically generate a list of all index numbers.

The Mask List itself will do the work and spit out True or False list like below that we can use with Mask List and Mask Join:

So finally we can edit and move those specific vertices:

I move up those vertices specifically.

Seems like a lot of work to do "mask" editing, isn't it? Well only the first setup. Because we can always re-use this "compound setup" for other purpose quite easily.

For example, I want to create a house shape from Box node, I simply move up vertices number 14, 15, 16.

And we can also create Procedural Star from Circle by selecting "every other" vertices and move it in or out. The total number of vertices need to be an even number in this case.

That's how really the basic idea to create procedural hairy creature the Susuwatari below.

Susuwatari (c) Studio Ghibli

Below we have Smart Masking setup example from the genius Nikita aka Nikitron:

LIST INPUT NODES AT WORK

Often time we are in situation where we need to have a single node that can output multiple values, that is when List Input Nodes can come in handy.

It seems really obvious that List Input can do this, however, sometimes I forgot.

The above setup is certainly better than below (not quite as elegant):

With List Input, we can take advantage of quick edit.

I use this actually for lofting each leg of Spider Limb.

BMESH BAKE OUTPUT MESH WITH MATERIAL

In recent version of Sverchok, we have now the ability to specify Material for our mesh. This is pretty self explanatory, but anyway below is such example.

PYTHON FOR SVERCHOK NODE TREE

This almost escapes my mind, but that is because I am still familiarizing to work inside the Node Editor. We can make use Python scripting handy when working inside the Node Editor. Just like when we are doing Compositing or creating Material in nodes, we can use Python scripting.

Sometimes all we need to do is to peek into the History and then reuse the script to modify the nodes.

Multiple Mesh Baking

Let say, we end up with node setup that require multiple mesh baking like below. We have many mesh that needed "Bake" button to be pressed.

If I manually click on the "Bake" button anyway and peek into the History, I will get the Python script that reflects what I just did.

It is pretty clear what is happening. We just click some nodes with certain ID Name (node name) from certain IDTREE NodeTree. More correctly, clicking the button actually runs those Operators to bake the mesh out.

You can copy and paste those code into Text Editor. Remember to do "import bpy" before running the code. The code can simply be like below:

You can tidy up the nodes even further, make the code more elegant, let say to take nodes with list of names you specified. No worries, you will learn about this eventually.

Next time you want to bake those nodes, you just simply run the script from Text Editor.

Resetting Values
Similar to above, you can also watch the History panel and see what Python script is executed when you change the parameters.

Eventually you will need to care more about Node Name + Label. Node Name is more important because it is what the script will be referring to. You definitely cannot have Node with the same name. But you can Label them with a same name.

I need to look around to find out how to do this below:
- Arranging nodes layout using Python
- Connecting/Disconnecting node using Python
- Creating and deleting node using Python

QUICK SNIPPET LINKING AND CREATING NODES

Found this. But was a bit outdated and actually for Node Compositing.
http://blenderartists.org/forum/showthread.php?271813-Connect-nodes-in-python

Then I figure out we can do this:

import bpy

tree = bpy.context.scene.node_tree
comp = tree.nodes.new('CompositorNodeImage')
RL = tree.nodes.new('CompositorNodeRLayers')
comp = tree.nodes.new('CompositorNodeComposite')
link = tree.links.new(RL.outputs[0], comp.inputs[0])

However the layout then need to be arranged somewhat. So that is something to keep in mind.

Anyways, after a bit of trial and error, for Sverchok Node Tree, we apparently can find the node tree data inside the Node Groups:

import bpy

NG = bpy.data.node_groups['NodeTree']

OI = NG.nodes['Objects_in']
VD = NG.nodes['Viewer Draw']

# print out all the nodes name
for node in NG.nodes:
print(node.name)

# link the two
link = NG.links.new(OI.outputs['Vertices'], VD.inputs['vertices'])

# create a new node of certain type
VN = NG.nodes.new('ViewerNode')

Ugly code but seems to work. Just make sure we keep track of every node created.

And... this is if you want to change some node stuff for Materials.
http://blenderartists.org/forum/showthread.php?321177-How-can-I-add-material-Diffuse-BSDF-to-object-using-python-script

Have to do this:
bpy.data.materials['Material'].node_tree.nodes['Material'].inputs['Color'].default_value = 1,0,0,1

Instead of this:
bpy.data.node_groups["Shader Nodetree"].nodes["Material"].inputs[0].default_value = (1, 0, 0, 1)

Data digging in Blender is both fun and frustrating. At one point, I shall be more familiar with all this and hopefully all questions answered! :)

Creating Interface for Sverchok Setup
Now, what would be nice is to have those script as a Button or some kind of GUI interface. You can use Blender own's interfacing, but since we are doing it inside Sverchok, it would be nice if we can have a node with simple interface (Button, etc) and able to run the script, all from within encapsulated node.

That is when you want to look at Scripted Node (SN).

GETTING INTO SCRIPTED NODES (SN)

I wanted to cover Scripted Nodes (SN) in one big articles or many articles in near future.

I am really still a newbie in term of scripting and coding, slowly getting into it. Eventually there will be time when one need to be comfortable in both Coding and Noding, it will take you far.

You probably already know this fact:

Sverchok inside Blender is actually a perfect Add-On to help you becoming good with both coding and noding, to understand advanced procedural and parametric workflow.

By no means "easy", this is when you are exposed to complexity. Trust me, this used to be a lot harder, all these tools make learning complex things less steep.

Start from here:
ScriptedNode_documentation.md => find it inside Sverchok folder.

For example, below is a SN magic by Ko, generating Text on the fly using Sverchok data. Apparently the Formula2 node is also a single liner Python code executor.

HEAT MAP AND NODE BAKE TIME

When working inside node-tree, especially a complex one, we will start noticing the time it takes to update/refresh per frame update.

Sometimes we want to be able to know how long it takes to bake each node. What node is causing the "slow down". Which node is slowest to calculate.

You can print such data from the Sverchok Add-On Preferences "Print Update Timings" and look at the output on the System Console.

Sneak peek:

USING BOUNDING BOX CORNER AS MATRIX PIVOT

Matrix In
Matrix Apply
Matrix Deform

Spend some time inside Sverchok and sooner or later you want a better understanding of the Matrix for transformation of mesh.

I am also still in the process of having a better understanding of how we could use the Matrix Data. What more importantly is how Matrix is used to generate or modify mesh or to set the pivot point of mesh.

In general 3D, we normally don't care too much about Matrix data, although we are actually using it all the time, especially when we are doing things like: Transforming object (Move, Scale, Rotate from axis), Freeze Transform, Rotate from X pivot.

Try a setup like below, load the Default Cube into Sverchok and we will modify it:

Try changing the value of the Vector In that goes into Location and Scale sockets of Matrix In.

Now, that effect does not always work magically like above. Sometimes we do want that kind of transformation effect to happen. As if we moved the Transformation Pivot into a different point, whether it is an arbitrary point in 3D space, or Empty location, or maybe from Bounding Box corner.

Let's move pivot into Bounding Box corner, it is more fun.

To get the Bounding Box Corner Point, we use SN script below from Linus:

def sv_main(bbox=[[]]):
in_sockets = [
['v', 'BBox', bbox],
]

s_type = ["v" for i in range(8)]
name = ['D','C','H','G','A','B','E','F']

if bbox[0]:# check that we have input
data=[ [[bbox[0][i]]] for i in range(8)]
else:
data = [[] for i in range(8)]

out_sockets = list(map(list,zip(s_type,name,data)))
out_sockets.sort(key=lambda s:s[1])
return in_sockets, out_sockets

The setup above does the procedure below:
1. Get Bounding Box.
2. Get a point from Bounding Box Corner
3. Prepare the Matrix, customize the pivot point for our mesh.
4. Edit and transform the object from the custom pivot.

That makes a point that we need to care about the Transformation Matrix of our Mesh. This is also useful when we are dealing with multiple objects and we are setting up Parent-Child Hierarchy.

If we have a simple head like Pinnochio head like this, we want to pay attention to the Transform Matrix of each parts of the head (hat, left eye, right eye, and nose).

If we set everything correctly, we will be able to have control over the mesh matrix transform while maintaining the structure and relationship.

Simple Procedural Pinnochio

Labels

Movies Post

Sports

Music

Business

Pictures

728x90 AdSpace

Travel

Fashion

Design

Movies

Recent Videos

Labels

Category

Slider

Recent Post

Games

Popular Posts

Pages

Find Us On Facebook

Links

About Me

Technology

Breaking News