Tutorial Part II

This tutorial will show you three basic ways to grow some cells into a particular shape using Fields. We call these basic collections of cells scrums.

FileName: tutorial_13.cyr

Field FileName: tutorial_13_field.png

A Field lets our cells know where they are so that they know when to stop growing. In this way, we can have them grow into specific forms.

It isn't as complicated as it looks. The video shows three different ways to create a form. (There are many others you can come up with.)

Each version -- specifically, cell states Scrum_A, Scrum_B, and Scrum_C -- is discussed below.

A few things to notice before we proceed. As in the video, you can check Draw Fields to see each cell's field. The more cells, the more fields. In the video, it may look like there is one red field... in reality, each cell's individual field is being drawn and overlaid with the other. If you wish to see a single cell's field, uncheck Draw Fields and use your spacebar to select a single cell to monitor.

You'll also notice the fields jostling a bit... this is because each cell is varying its Presumed Position (PP) orientation and location components to try to get in synch with its neighbors.

Go to the Field Editor tab and load tutorial_13_field.png. (Also, ensure that Use Field is checked in the Console. Ditto for all the tutorials that follow.)

The first three lines should be old hat. Notice, though, the FIELD_ACTIVE command; this must be set to 1 in order for our cells to sense their Fields.

The last line is where all the magic happens.

The last two conditions are straightforward: the second condition (ACTUAL_AREA[TYPICAL_AREA,INF]) ensures the cell is big enough to undergo mitosis. The third condition (ADJ_MEMBRANES_PERCENT{MEDIUM}[30,INF]) limits mitosis to the cells which have 30% or more of their membranes not touching neighbors; this is to keep the inner cells from splitting.

The first condition (FIELD[1]) is new. The condition means that the cell must think it's center node is in zone 1 of the Field in order to undergo mitosis.

As the cells split and jostle about, and as they adjust their Presumed Positions, eventually, the cells on the periphery will realize they must be outside zone 1. They consquently quit splitting.

Using just this simple condition, the cells will more or less make the desired form. But, as shown in the video, it will be a bit 'blobby' and not very precise.

In any case, the take-away from Scrum_A is that this technique, although quick and easy, sort of sucks with the finer details of a shape. Let's try something else.

One of the things you can try to make Scrum_A less blobby and more precise is to add this line:
FIELD[0] :: DIE
The gist is to have a cell die if its outsize of zone 1. We've also added FIELD_EDGES{0}[0] as a condition to mitosis; a cell won't undergo mitosis if part of it is hanging outside zone 1.

The problem, you'll find, is that the cells constantly die, and then new ones are formed, and the periphery of your creature is in a constant cycle of flux. Seems a bit sloppy.

The last two examples could be improved. For instance, with Scrum_B you could use a U_VAR to have cells that are about to die exude a chemical into their neighbors to inhibit mitosis for a bit. That way, you could slow down the churning on the periphery. There are innumerable other techniques.

But, by far, the best technique is to do what real cells do; namely, move.

In Scrum_C we have more or less the same first few lines. But, then we have four sentences that involve the MIGRATE command. Let's look at each in turn.

If the cell is in zone 1, but some of its edges are hanging outside zone 1, we want the cell to move back in torwards zone 1. So, we set a V_VAR pointing towards zone 1, and have the cell migrate in that direction.

In the alternative, if the cell is in zone 1, and none of its edges are hanging outside zone 1, we check to see if it has any empty space on its membrane. If so, we tell the cell to move towards that empty space a bit. Why? Well, just to make the cells spread out as they're growing and fill in the zone 1.

In the alternative, if the cell's center is outside of zone 1, but some of its edges are still in zone 1, then clearly we want to make the cell move back to zone 1.

Finally, if the cell is entirely outside zone 1, he's basically screwed. At the very least, lets have him move in towards his neighbors; with any luck, he will worm his way back to zone 1.

The last three lines take care of cells that stay outside of zone 1 too long... each cycle they are in zone 0, a counter increases, and when it reaches 100, the cell will die.

As you'll see in the video, this technique leads to a nice precise fit. You can check Draw Vectors to see which way the cells wish to move.

Regenerating a missing body part is easy when all the cells are capable of dividing... the organism just grows back what it needs. But, what if the cells can't divide? This tutorial will demonstrate how an organism, which has had something amputated, can reconfigure its remaining cells to form a smaller version of itself by adjusting the scale component of each cell's Presumed Position.

FileName: tutorial_14.cyr

Field FileName: tutorial_14_field.png

This tutorial is all about doing expirements on a little lobster-looking thing, the cells of which can't undergo mitosis.

This raises the question of how our little lobster is going to grow in the first place to its normal size and shape if its cells can't undergo mitosis! We'll show you a quick hack that we at CYCELL use when we want to get a basic body-plan on the screen.

Specifially, place a Quickstart cell... it will quickly grow into a lobster. Once its done growing -- should just take a second or two -- we can magically turn all the cells into State_A or State_B by 'touching' the lobster with a Default_Blue or Default_Yellow. There's nothing 'biological' about this; like we said, its just a hack to quickly get what we want in the Petri Dish: a fully-grown lobster composed entirely of State_A or State_B cells.

The first and second commented section keep the cells within the desired field. It's similar to what we did in the previous tutorial. Briefly, let's go through each sentence under the //move away from Field zone 0 comment.

• In plain english, the first sentence says that if our cell is in the body, yet part of it is dangling outside, we want the cell to try to squirm back into the body.
• The next three sentences say that if our cell finds itself mostly outside the body, then move in the direction of the body. As we are using more than one zone, we add up these directional vectors as we go, storing the sum in press_in_vector.
• The next sentence concerns a cell that is outside the body. Part of it may be inside. Or, maybe not. Whichever the case, the cell is clearly not where it needs to be so, as a catch-all, we have it move towards its neighbors. We add this directional vector to our sum.
• Finally, we have the cell move in the direction of press_in_vector.

Regarding the sentences under the //move towards empty space comment, we're just telling cells that are completley within the body yet aren't entirely squished up next to neighbor cells, to move in the direction of the empty space around them. This just makes them fill in the shape more quickly.

Regarding the sentences under the //Color stuff comment, we're just coloring the head, tail, and tips of our lobster's arms to keep track of what's going on.

NOW... on to the IMPORTANT part:

We're interested in cells that are within the body but have 30% or so empty space around them. The percentage is somewhat arbitrary... what we're trying to do is focus on cells that aren't completely surrounded by neighbors. Specifically, we want these cells to wonder why they are not completely surrounded by neighbors.

For instance, if we were to chop off our lobster's arm, the cells at the stump would find temselves inside the body, yet missing some neighbors. If they could undergo mitosis, this might trigger them to start dividing. But, what if they can't undergo mitosis? Being smart little cells, they would begin to assume that they are incorrect about the size of the lobster of which they are part. Maybe, they would think, they're part of a smaller lobster.

Likewise, let's say one of the cells is inside the body, yet has a big portion of itself dangling out into Field zone 0. Well, the cell will try to migrate away from the edge, but eventually, it might start thinking that perhaps the lobster of which he is part is actually larger than he thinks.

In both cases, the ADJUST_PP_SCALE command will adjust the cell's idea of the lobster's size. How much is the adjustment? In this case, it's 0.05. Try different values... there's nothing special about 0.05.

The second sentence covers a special case and isn't entirely necessary. Essentially, if the cell finds itself entirely outside the body, it's reasonable for the cell to think his idea of the lobster must be too small... so he increases the scale components by 5%. Now, merely increasing the scale isn't going to get the cell back into Field zone nos. 1-4. But, remember that each cell's scale components are effected by their neighbors' scale components; so, for a cell stuck outside, this signal that he thinks the lobster needs to be bigger, will trickle through the scrum, and eventually, the cells' idea of the lobster's size will result in our lonely outlier getting pulled back into the body.

The last two sentences are just caps put on the scale values; there is a lot going on under the hood and some scenarios might make the scale component of a cell get crazy large. No matter what, though, these two sentences will put a limit on the value. (There is a lower limit as well of 0.01. It's built-in to the Program so there's no need to control for minimums unless you find 0.01 isn't cutting it.)

What to look for in the video:

• We'll cut off the left arm. Note how each cell's view of the lobster changes... the cells near the stump quickly reason they must be part of a smaller lobster.
• Unlike regeneration with mitosis, the cells start to move into the missing arm area. It takes some time for the cells to move to where they need to be. This is to be expected. But, the form of the missing appendage is re-established very quickly.
• Towards the end of the video, we've amputated a large portion of the body. Even with just a handful of cells, they will make the form with which they have been programmed.
• Finally, keep in mind that each cell is using only local information gleaned from the membranes of its neighboring cells. Not to beat a dead horse, but we at CYCELL think this emergent ability of our lobster to maintain its form -- no matter how many cells it has to work with -- is pretty darned cool.

Scrum_B is the same in all respects except that we are manually adjusting the scale components instead of using ADJUST_PP_SCALE. ADJUST_PP_SCALE has the ability to change the proportions of the Field. You can see some of this in the video where some cells think they are part of a fat lobster, and others a skinny lobster. Scrum_B's manipulations, on the other hand, keep the proportions the same throughout. This leads to some subtle differences in the morphollaxis. Left running long enough, both techniques will have the same end-result. But, with some forms, ADJUST_PP_SCALE gets you there faster, and with other forms, it takes longer.

We are going to use the MOD_PP_LOCATION command to have our cells respond to obstructions.

FileName: tutorial_15.cyr

Field FileName: tutorial_15_field.png

You may have noticed a default cell state in the Manual Placement widget called OBSTRUCTION. We're going to be using it. While technically a cell, an OBSTRUCTION doesn't move, grow, or do much anything. We're going to use it as a wall.

The code contains the typical stuff to get your initial cell to grow into, and maintain, the long slender rod-like shape contained in the field file.

The only new stuff is the sentence under the //adjust location comment.

The sentence has us focus in on cells that are entirely within the body and which are touching an OBSTRUCTION. If these conditions are met, we set a vector and process the MOD_PP_LOCATION command.

Normally, the location component of a cell's Presumed Position is adjusted as a matter of course, depending on its neighbor's membranes and the like, as described ad nauseum on the Fields page. But, we can also adjust it manually, as we do here. Why would we want to?

Well, to answer that, let us view the world from the cell's point of view...

Let's say a cell is completely within the body. He's not touching any of the emptiness that is zone 0. So, the cell would naturally expect there to be neighboring cells touching him on all sides.

But, alas, to his shock he finds one of his sides -- let's say the right side -- is touching the non-living OBSTRUCTION!

The cell thinks, "If I am where I think I am, there should be a cell on my right side. Instead, there's this OBSTRUCTION thing. I must not be in the correct position."

He might consider that he is too far to the right... but that would make no sense... to his left, afterall, there are a bunch of cells pressed up against him and they all think they are in the correct position.

Instead, the cell concludes he must be too far to the left... it the only alternative.

So, he moves his presumed location a smidgen to the right. On the next cycle, the OBSTRUCTION is still there. Damn. So, he adjusts it again. Eventually, he will move far enough right that the membranes touching the OBSTRUCTION are hanging out in Zone 0. At that point, the problem is solved. For, the cell couldn't care less if the OBSTRUCTION is touching his right side as his right side is in Zone 0 and he doesn't expect any neighbors to be out in Zone 0.

This is precisly what is happening in this sentence: if the conditions are met, the cell sets a vector in the direction of the OBSTRUCTION and adjusts the location component of his Presumed Position in that direction. (Keep in mind, the cell doesn't literally move; rather, his mental picture of where he is moves.)

The upshot of all this is pretty dang neat. When the growing column hits an obstruction, it will bend.

You can see this in the video. We've turned the Draw Field on so you can see how the cells' orientation components are altering. Keep in mind the orientation component is not being changed directly, as perhaps it might be in a kinematic 2d physics engine. Instead, the orientations are changing on their own as a result of the little random fluctuations in the cells' Presumed Position components as they continuously try to get in synch.

This tutorial is more of a demonstration of how one can model neoblasts.

FileName: tutorial_16.cyr

Field FileName: tutorial_16_field.png

In real living systems, cell reproduction is often limited to special cells called neoblasts. Instead of a skin cell dividing, for instance, another type of cell creates a new skin cell.

In this example, our neoblasts will travel throughout our little man, and if they reach an area that is in need of new Body cells, they will create them.

This state has the typical MIGRATE commands that keep everything within the field. This should be old-hat.

You'll note there is no MITOSIS command in this state. They Body cells can't reproduce. But, as they are using fields, they know when they need to reproduce. If they are completely within the field, but over 20% of their membranes are exposed to the MEDIUM, the cell knows it needs a neighbor. When these conditions are met, it starts increasing the wound_signale U_VAR. (Later in the state, you'll see that the cell's amount of wound_signal corresponds to a greenish-tint, so that you can visualize what's happening.)

So, a cell that is need of neighbors will send out wound_signal. At the same time, if a cell has part of its membrane sticking out into zone 0, it knows that it doesn't need any more neighbors. It will set a U_VAR called mitosis_inhibit to 1.

If you look at the GAP_JUNCTIONS, you'll see that wound_signal can spread from cell to cell; not so with mitosis_inhibit. The only external cell that can read its mitosis_inhibit value is a Neoblast. Likewise, there is another 'private' flag-like variable called perimeter which is set to 1 if the cell is at the edge of whatever is being grown. We'll see how these flags are used below.

The Neoblast cells constantly move towards the highest concentration of wound_signal. When they get to a high concentration of same AND they are not touching a Body cell that contains mitosis_inhibit AND they are touching a Body cell that contains perimeter, then they need to undergo MITOSIS.

Instead of just splitting, though, they perform a quick test using the SET_RAND command and a helper variable so that 30% of the time the daughter cell will be another Neoblast and 70% of the time, it will be a new Body cell.

That's about it. Except, with all these Neoblasts squirming around, they may have a tendancy to clumped up. So, we change a Neoblast to a Body cell if it is touching 2 or more other Neoblasts. (We stuck in a POISSON condition as well so that a group of them Neoblasts won't simultaneously change.)

The ADHESIONS settings keep Neoblasts away from each other and bit squirmy. (This is fairly similar to what was discussed in the GAP_JUNCTIONS tutorial above.)

Things to watch for in the video:

• A single Neoblast can create the entire organism.
• When an arm is amputated, the nearby Neoblasts swoop in to re-build.
• When we cut off the legs, we also deliberately kill some nearby Neoblasts to more easily show the Neoblasts' movement.
• There are no Scale or Location adjustments in this simple tutorial. Rest assured, though, that the same phenomona demonstrated in previous tutorials will work with Neoblasts.

ON TO PART III...