# Wheelbase points

I divide the diagonal of the roof: 70 cm wheelbase
this does not happen … the division is wrong, not the same … why do you think ??

Hey Alex,

Mapping multiple parameters on multiple curves can be a bit tricky. My suggestion is the following:

-use one of the lit combining nodes

-very important: on the “Curve.PointAtParameter”, right click the “param” input and turn off “Use Default Value”

Thank Dimitar
takes only one point for a straight
What is wrong?

Count = 1, not 11?

Alex, you will need to flatten your list of curves. Right now they are nested in a sub list.

Thank Dimitar
now it works, I do not understand “flatten” what does
Thanks again … Regards

The “Flatten” node roughly said moves all your sub-lists up into the main list. You could also use the “List.Flatten” node to specify exactly how many ranks you want to move the sub-lists up.

Dimitar,

Can you please explain what does the “Use Default Value” do, and why do you need to turn it off?

thanks!

Sure Aseem,

Compare the image below - the above node has default values enabled (which are 0 for both u and v) and the one below does not. The output of the first is a point while the second returns a function. List combinators require a function to work and to make sure we feed it one, we have to turn of the PointAtParameter’s default value to make it act as a function and accept our lists of parameters.

That’s nifty Dimitar, many thanks for the tip!

Dimitar,

Once again, thank you so very much. Very clear explanation that helps make sense of the node’s behavior. Your help is much appreciated.

If you don’t mind, I’ll like to go back to your initial example that uses the List.Combine. I am trying to understand what this node actually does. I have experimented with different kinds of list using various kind of combinators. Sometimes the output makes sense, sometimes it doesn’t. So I have not been able to pin down this node. Can you please help understand this node?

This will be a long post, so get your self some coffee/tea. Have a look at the following image:

You may already be aware that nodes have lacing options(those little lines in the bottom right corner). In the above image we have two lists - one contains five items and the other 10. If we feed those into a function, the output of the function will depend on how we tell the function to handle the lists. You have three options - shortest, longest and cross. Shortest will end the function, once the shorter list runs out of indices, while Longest will continue it until the longer one runs out of indices, matching its extra indices with the last index from the short list. Cross will simply take each index and combine it with every other index from the corresponding list, returning all possible combinations. Once you understand this principle, the list combinators make a lot more sense.

Most of the times, the basic node lacing has you covered. However sometimes you need finer control and you want to perform a specific function on a list of items and treat each item differently. Take for example Alex’s case - he wanted to take each curve and create different and unique parameters for each based on the curve’s length. If he had to use only the standard “Curve.PointAtParameter” to accomplish this, he would need to split his list of curves into individual curves and feed only the specific parameters for that curve. That would take a lot of extra wiring and and the next time he uses his workflow on a different number of curves, he would have to rework it for that particular case. Now imagine you have to perform individually on 100 curves - Yikes!

Luckily for us Dynamo is a (visual) programming language and like other programing languages, is built smart and can iterate through lists of items and perform actions on them procedurally. This is where List combinators come in play.

Not coincidentally you have three main list combinators - “List.LaceShortest”, “List.LaceLongest” and “List.CartesianProduct”. If you’re on the daily builds of Dynamo, the little icons next to the node inside the library really help drive the message home on what each of those does.

The combinators act just like the basic node lacing, but instead of a flat list of items, you can input nested lists into them and perform any number of complicated functions on varying numbers of elements with varying numbers of arguments.

There’s also a special fourth combinateor simply called “List.Combine”. It is “special” in the sense that it expects to be fed lists that match in length, otherwise it will fail to perform and return a null answer. Now you might think that this doesn’t make a whole lot of sense - List.LaceLongest/Shortest sound much smarter because they can use a previous value or terminate on mismatch. However there are some cases where your workflow may specifically demand matching values and that “null” option will be very helpful revealing a problem, or feeding a specific information on null, etc.

This is my own personal overview on lacing and list products. Please if anyone sees anything wrong with the above information, do not hesitate to correct me.

Dimitar,

Very rational and clear to understand write up. Can’t thank you enough for being so generous in helping out the less informed.

Thanks!