Differences

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

--- tutorials:architecture-model [2024/11/18 10:31] – [Growing in several directions] 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 181: / 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:
+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 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 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 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 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
+  * A bud of order 2 creates a shoot and a new bud of order 2.
+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:
-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:
 <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 208: / 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 224: / 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 248: / 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 254: / 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>