Differences

This shows you the differences between two versions of the page.

--- tutorials:architecture-model [2024/11/18 10:17] – [Parameters] tim
+++ tutorials:architecture-model [2024/11/19 13:06] (current) – [Apical growth] tim
@@ Line 45: / Line 45: @@
 Looking at our two organs, we can define our very first rule: //a bud becomes a shoot//, or more precisely //every bud becomes a shoot//.
-Writing this in an XL query is quite straightforward:'' Bud %%==>%% Shoot ''.  But with this rule the fun would soon be over, because we can only apply our rule once, after that there are no more buds in our scene.
+Writing this in an rewriting rule is quite straightforward:'' Bud %%==>%% Shoot ''.  But with this rule the fun would soon be over, because we can only apply our rule once, after that there are no more buds in our scene.
@@ Line 100: / Line 100: @@
 {{ :tutorials:ca_tut_latb.png?direct&200|}}
-Even so our little model improves, it can still only grow in one direction which is quite untypical for a tree. Therefore we will now add new shoots on the side of our main branch (stem). The image on the right shows what we would like to see after two growth steps.
+Although our little model is improving, it can still only grow in one direction, which is not typical for a tree. Therefore, we will now add new shoots to the side of our main branch (trunk). The picture on the right shows what we would like to see after two stages of growth. This branches on the side are called lateral.
 {{:tutorials:ca_tut_latbud.png?direct&120 |}}
-Knowing that our first rule is turning a bud into a shoot and a bud allows us to estimate what the first step to the branched tree would have looked like. This can be seen on the right image.
+Knowing that our first rule is to turn a bud into a shoot and a bud, we can estimate what the first step towards the branched tree would have looked like. This can be seen in the picture on the left.
-This leads us to the task of updating our rule. We now want to //replace a but by a shoot, a but on top and two buds on the side//.
+This brings us to the task of updating our rule. We now want to //replace a bud with a shoot, a bud at the top and two buds at the sides//.
 ==== Turtle Geometry ====
-For this new rule we have to get a little inside on how GroIMP is interpreting the results of our rules.  We already defined above that a shoot is a cylinder and a bud is a sphere and that our rule is defining a chain of cylinders with a bud at the end.
+For this new rule we need to look at how GroIMP interprets the results of our rules.  We have already defined above that a shoot is a cylinder and a bud is a sphere, and that our rule defines a chain of cylinders with a bud at the end.
-This chain of cylinders and the bud is stored in GroIMP in a graph, the project graph. This graph holds almost all information of the project and defines the core of a GroIMP simulation. Moreover this graph is also used as the foundation for the visualization of our model. As we can see in the left image below each shoot in the graph is drawn as a cylinder in the 3d scene. The placement of this objects is based on the concept of turtle geometry. We can imagine that a "turtle" is starting at the position (0,0,0) in the 3d scene and then follows the instruction given by the nodes in the graph. The reading of the graph starts a the top at Node.0 and goes down trough the nodes. The first two nodes (node.0 and RGGRoot) do not have any effect of the turtle, but a shoot tells the turtle to draw a cylinder and move to the end of this cylinder. Therefore the second shoot starts at the end of the first shoot and the bud is placed at the end of the second cylinder.
+This chain of cylinders and bud is stored in GroIMP in a graph, the project graph. This graph contains almost all information about the project and defines the core of a GroIMP simulation. It is also the basis for the visualisation of our model. As we can see in the left image below, each shoot in the graph is drawn as a cylinder in the 3D scene. The placement of these objects is based on the concept of turtle geometry. We can imagine that a "turtle" starts at position (0,0,0) in the 3D scene and then follows the instructions given by the nodes in the graph. Reading the graph starts at the top at Node.0 and goes down through the nodes. The first two nodes (Node.0 and RGGRoot) have no effect on the turtle, but a shoot tells the turtle to draw a cylinder and move to the end of that cylinder. So the second shoot starts at the end of the first shoot and the bud is placed at the end of the second cylinder.
 |{{:tutorials:ca_tut_turtles2.png?direct&400 |}} {{ :tutorials:ca_tut_turtlegrow.png?direct&200|}}|
 | Left: Our apical shoot as a drawn image, a GroIMP 2d Graph and the GroIMP visualization, Right: the changes in the graph when the rule is applied|
+GroIMP comes with a set of commands to manipulate this turtle by rotating, scaling, moving or chaining default values for color and size. (The most important ones can be found here: [[groimp-platform:turtle_commands|]])
-GroIMP comes with a howl set of commands that can manipulate this turtle by rotation, scaling, moving or chaining default values for color and sizes. (The most important once can be found here: [[groimp-platform:turtle_commands|]])
@@ Line 124: / Line 123: @@
 {{:tutorials:ca_tut_sidebud.png?direct&100 |}}
-To first get a feeling for this turtle geometry we will create a rule that turns  bud into a shoot with one bud on the side pointing to the right. First we still need the shoot and then we add the lateral bud. Knowing that the turtle will be at the end of the shoot after drawing it, means that we have to move back form that position. Therefore we can use the move command: ''M(distance)''. {{ :tutorials:local_rotation.png?direct&200|}}
+To get a feel for this turtle geometry, we will create a rule that turns the bud into a shoot with a bud on the right side. First we need the shoot and then we add the side bud. Knowing that the turtle will be at the end of the shoot after we draw it means that we have to move back from that position. So we can use the move command: ''M(distance)''. {{ :tutorials:local_rotation.png?direct&200|}}
-Assuming our shoot growth with a length of $l$, the turtle will move l up with ''Shoot(l)'' to get to the middle of the shoot we can just move back halve way with ''M(-0.5*x)''. This brings us already to the right position. Now we need to rotate to our turtle so that the bud will point towards the right.
+Assuming our shoot has a length of $l$, the turtle will move l up with ''Shoot(l)'' to get to the middle of the shoot, we can just move back half the way with ''M(-0.5*l)''. This will bring us to the right position. Now we have to rotate our turtle so that the bud is pointing to the right.
-**Rotating** the turtle is possible along the three axes x, y and z. We can see an example of the rotation tool on the right with the possible rotations in colors: x= red, y=blue and z=green. In the turtle geometry we can rotate this axes with the commands ''RL(angle)'', ''RU(angle)'' and ''RH(angle)''. RL rotates around the local X-Axes (the red circle in the image), RU around the Y-Axes (the blue circle) and RH around the z-Axes. If we imagine the image on the right rotate by 90 degrees, the names make more sense: RL rotate to the __l__eft (with negative values to the right) RU rotate __u__p and RH rotates around the __h__ead axes.
+You can **rotate** the turtle along the three axes x, y and z. We can see an example of the rotation tool on the right with the possible rotations in colors: x=red, y=blue and z=green. In the turtle geometry we can rotate these axes with the commands ''RL(angle)'', ''RU(angle)'' and ''RH(angle)''. RL rotates around the local X-axis (the red circle in the picture), RU around the Y-axis (the blue circle) and RH around the Z-axis. If we imagine to look from the perspective of the turtle, the names make more sense: RL rotates to the __l__left (with negative values to the right), RU rotates __u__p and RH rotates around the __h__head axes.
-For our little shoot with the apical bud, this means we have to rotate it on y axis (up, if the branch would lay on the side). Therefore we need the RU command and come the following rule:
+For our little shoot with the apical bud, this means that we have to rotate it on the y-axis (up, if the branch would lie on the side). Therefore we need the RU command and the following rule:
 '' Bud(x) %%==>%% Shoot(x) M(-0.5*x) RU(30) Bud(x*0.8) ''
-which,after 3 iterations,  produces the "plant" below by drawing a shoot, moving back half the length rotation 30 degrees around the y axis and than starting over again two times.
+which, after 3 iterations, produces the "plant" below by drawing a shoot, moving back half the length rotation 30 degrees around the y-axis, and then starting over twice.
 {{ :tutorials:ca_tut_grow_latonly.png?direct&200 |}}
-=== Growing in several directions ===
+==== Growing in several directions ====
-We have already two possible rules to create our little plant, we either grow to the top or to the right. In the next step we want to do both in one rule.  Doing this with one turtle traveling forwards and backwards  would be very hard (sooner or later impossible).
+We already have two possible rules to create our little plant, we can either grow upwards or to the right. In the next step we want to do both in one rule.  Doing this with a turtle moving back and forth would be very hard (sooner or later impossible).
-In L-Systems, and also in GroIMP, this is solved by using a stack of turtle states (the current position, rotation, scale color etc.).  This stack can be controlled by using square brackets ''[ ]''.
+In most L-Systems, and also in GroIMP, this is solved by using a stack of turtle states (the current position, rotation, scale color, etc.).  This stack can be controlled by using square brackets ''[ ]''.
-"[" mans add the current state to the stack of remembered states and "]" means go back to the last remembered state. This concept allows us to let our turtle do little detours that combine our rules to one rule of // relpace a bud by a shoot, remember this state, move back half the length rotate 30 degres up add a new bud go back to the last state and add the apical bud//. Or in XL:
+"[" means to add the current state to the stack of remembered states and "]" means to go back to the last remembered state. This concept allows us to let our turtle do little detours that combine our rules into one rule of // replace a bud by a shoot, remember this state, move back half the length, rotate 30 degrees up, add a new bud, go back to the last state and add the apical bud//. Or in XL:
 ''Bud(x) %%==>%% Shoot(x) [M(-0.5*x)RU(30) Bud(x*0.8)] Bud(x*0.8)''
+The order of the elements (why we go back before adding the apical bud) becomes clear if we imagine that we apply the rule a second time. In this case, we want the second shoot to be added after the detour and not before (see the graphic below), otherwise the lateral shoot would be moved up with the new shoot.
-The order of the elements (why we move back before we add the apical bud) becomes clear if we imagine we apply the rule a second time. In that case we want the second shoot be added after the detour and not before (see in the graph representation below), otherwise the lateral shoot would be moved up with the new shoot.
+In GroIMP's project graph, the "detour" part is added to the same node (in our case the shoot), but with a different edge (the connection between the nodes). The two different types of edges are called successors (the "main edges") and branches (for the "detours"), in the 2D graph (see image below) these two edges are visualized by either solid or dashed arrows. GroIMP supports more and also custom types of edges, but these two are the main ones.
-In GroIMP's project graph, the "detour" part is added to the same node (in our case the shoot) but with a another edge (the connection between the nodes). The two different types of edges are called successors (the "main edges") and branches (for the "detours"), in the 2d graph (see image below) this two edges are visualized by either full or dashed arrows. GroIMP supports more and also custom types of edges but these two are the main once.
@@ Line 158: / Line 156: @@
-As said above, the turtle state is stored in a stack, therefore we can push several turtle stacks in there.
+As mentioned above, the turtle state is stored in a stack, so we can move multiple turtle stacks into it.
-In our case this allows us to add some more lateral buds around (rotate by the head axes) the shoot:
+In our case, this allows us to add some more lateral buds around the shoot (rotated around the head axes):
 <code>
@@ Line 173: / Line 171: @@
 </code>
-Which gives us an already quite nice little plant like structure:
+This gives us a nice little plant-like structure:
 {{ :tutorials:ca_tut_lattree01.png?direct&400 |}}
-You can now already play around with the values to change the shape of the tree, by for instance making the lateral branches shorter (x*0.5 in stead of x*.0.8) or change the rotation angels etc.
+You can now play around with the values to change the shape of the tree, e.g. make the side branches shorter (x*0.5 instead of x*.0.8) or change the rotation angels etc.
 ===== Branching orders =====
@@ Line 184: / Line 181: @@
 {{ :tutorials:order.png?direct&200|}}
-Looking at trees we can see that most of them have different growth-behavior on the trunk and on the branches. To simulate this, we will use the concept of branching orders. In this concept the branches of a tree are separated in orders based on their parent. We define the trunk as order 0 and then every lateral branch on the stem is of the order 1 and every lateral branch on the order 1 is of the order 2 and so on. This can be seen in the image on the right.
+If we look at trees, we can see that most of them have different growth behavior on the trunk and on the branches. To simulate this, we will use the concept of branching order. In this concept, the branches of a tree are separated into orders based on their parent. We define the trunk as order 0, and then each side branch on the trunk is order 1, and each side branch on order 1 is order 2, and so on. This can be seen in the image to the right.
-We, as many other modelers before us, will use this concept to give our tree more structure by defining different growth rules for the different orders.  Lets define just three for now:
-  * A bud on the stem (of order 0) creates a shoot, a new apical bud with the order 0 and three lateral buds around it with the order 1
-  * A bud of the order 1 will create a shoot a new apical bud with the order 1 and two lateral buds of order 2 to the left and the right
-  * A bud of order 2 creates a shoot and a new bud of order 2
+We, like many other modelers before us, will use this concept to give our tree more structure by defining different growth rules for the different orders.  Let us define just three for now:
+  * A bud on the trunk (of order 0) creates a shoot, a new apical bud of order 0, and three lateral buds of order 1 around it.
+  * A bud of order 1 creates a shoot, a new apical bud of order 1, and two lateral buds of order 2 to the left and right.
+  * A bud of order 2 creates a shoot and a new bud of order 2.
-To use this rules, we first need the knowledge of the branching order for each bud. Therefore we can extend the module bud again with one additional parameter as following:
+To use these rules, we first need to know the branching order for each bud. To do this, we need to add an additional parameter to the bud module, as shown below:
 <code java>
  module Bud(int order, float len) extends Sphere(0.1);
 </code>
-And now we learn a new trick, because on the left side of a XL rule it is also possible to specify which value the selected node should have: ''Bud(0,x)'' will only rewrite the buds of the order 0. This allows us to specify our rule from above for the order 0:
+And now we learn a new trick, because on the left side of an XL rule you can also specify which value a parameter of the selected node should have: ''Bud(0,x)'' will only rewrite buds of order 0. This allows us to specify our rule from above for order 0:
 <code java>
@@ Line 211: / Line 207: @@
 </code>
+We now replace only the buds of order 0 (the stem) and give the new buds the correct orders, the lateral buds get order 1 and the apical bud gets 0.
-I now only replaces the buds of order 0 (the stem) and gives the new buds the right orders, the lateral buds get order 1 and the apical bud get 0.
+For the first-order branches, the new rule is as follows, with two buds rotated to the left and right.
-For the branches of the first order the new rule is as following, using the rotation to the left.
 <code java>
 Bud(1,x)==> Shoot(x)[
@@ Line 227: / Line 222: @@
 </code>
-finally the one for the second order is just as we know it from the very beginning.
+Finally, the second order is just as we have known it from the beginning.
 <code java>
  Bud(2,x) ==> Shoot(x)Bud(2,x*0.6);
 </code>
-This three rules result in a already quite nice looking structure. (Don't be confused, I resized the radius of the buds a bit)
+These three rules result in a pretty nice looking structure. (Don't be confused, I resized the radius of the buds a bit)
 {{ :tutorials:ca_tut_orderd_tree.png?direct&400 |}}
 ===== Diameter =====
-Now in the last real step of this tutorial we want to look at the diameters of our little tree.
+Now, in the last real step of this tutorial, we want to look at the diameters of our little tree.
-In the F class that our shoot extends the diameter can be given as an second parameter: ''F(length,diameter)''. So we can just do the same thing as we did with the length and have a parameter d in our shoot hat is then forwarded to the F:
+In the F class that our shoot extends, the diameter can be given as a second parameter: ''F(length,diameter)''. So we can just do the same as we did with the length and have a parameter d in our shoot that will be passed to the F:
 <code java>
  module Shoot(float l,float d) extends F(l,d);
 </code>
-Now for defining this value in our rules we will use a very simple estimation. Lets assume that the ratio between the length of a shoot and its diameter is 10:1. This means in all our rules we can just change the Shoots to ''Shoot(x,x/10)''.
+To define this value in our rules, we will use a very simple estimation. Let us assume that the ratio between the length of a shoot and its diameter is 10:1. This means that in all our rules we can simply change the Shoots to ''Shoot(x,x/10)''.
-Even so this gives our tree already a nicer first shape, there is another thing we want to do with the diameter: secondary thickness growth.  Therefore we add a new rule that states that every Shoot will be replaced by a new Shoot of the same length but a slightly larger diameter.
+Even though this gives our tree a nicer initial shape, there is something else we want to do with the diameter: secondary thickness growth.  So we add a new rule which says that each shoot will be replaced by a new shoot of the same length but with a slightly larger diameter.
 <code java>
@@ Line 251: / Line 246: @@
-With the diameter our tree now looks like this:
+With the diameter, our tree now looks like this:
 {{ :tutorials:ca_tut_diameter.png?direct&400 |}}
@@ Line 257: / Line 252: @@
 ===== Final =====
-This is basically it for this tutorial. Below you can get the code of this small tree. Now you can start playing around fitting it to your needs adding more parameters and rotations.
+That is basically it for this tutorial. Below you will find the code for this little tree. Now you can start playing around with it, adding more parameters and rotations to suit your needs.
 <code java>