Python Tutorials (back to the list of tutorials)

## Cell Division and Growth Algorithm 1 (requires iGeo version 0.9.1.5)

### Cell Division and Growth by Particle and Repulsion

The tutorial codes in this page explore formation made by the mechanism inspired by cell division and growth process.

In the first code below, it defines an agent class "Cell" inheriting IParticle class to let the cell agents to move around by external or internal forces. This agent implements the following three behaviors.

• Growth : A cell agent grows its size over time. This is implemented by having a circle as the agent body geometry and increasing the radius over time in the update method.
• Repulsion : When a cell agent grows its size and starts touching other cell agents, it pushes others. This is implemented in interact method by applying force to the other cell agent if the distance of center points of two agents is smaller than summation of both radii.
• Division : Cell division is simulated by creating a new child cell by a parent cell agent and making both size half. The center positions of both cell agents are moved by the half radius towards opposite directions each other. This is implemented in update method.

The code below also control the timing of growth and division in update method by growthInterval and divisionInterval and also stop them after growthDuration time frame. The division is also controlled to happen randomly in 50 percent probability.

```add_library('igeo')

def setup() :
size(480,360,IG.GL)
Cell(IVec(0,0,0), 10).clr(1.0,0,0)

class Cell(IParticle) :
growthDuration = 2000 #duration of growth and division
growthInterval = 10
divisionInterval = 100

IParticle.__init__(self, pos, IVec(0,0,0))
self.circle = None
self.fric(0.1)

def interact(self, agents) :
for a in agents :
if isinstance(a, Cell) :
if a is not self :
# push if closer than two radii
dif = a.pos().dif(self.pos())
a.push(dif)

def update(self) :
if IG.time() < Cell.growthDuration :
if self.time() > 0 and self.time()%Cell.divisionInterval==0 :
if IRand.pct(50) :
dir = IRand.dir(IG.zaxis)
self.radius *= 0.5 #make both cell size half
child.hsb(self.hue()+IRand.get(-.1,.1),self.saturation()+IRand.get(-.1,.1),self.brightness()+IRand.get(-.1,.1))
self.pos().sub(dir) # move to the other way
if self.time()%Cell.growthInterval==0 :

# update geometry
if self.circle is None :
else :
```

The code below only reorganize the first code above by extracting part of the code of division growth from update method and putting them into grow method and divide method. The grow method also gets maxRadius parameter not to grow the size too much.

```add_library('igeo')

def setup() :
size(480,360,IG.GL)
Cell(IVec(0,0,0), 10).clr(1.0,0,0)

class Cell(IParticle) :
growthDuration = 2000 #duration of growth and division
growthInterval = 10
divisionInterval = 100
growthSpeed = 0.1

IParticle.__init__(self, pos, IVec(0,0,0))
self.circle = None
self.fric(0.1)

def interact(self, agents) :
for a in agents :
if isinstance(a, Cell) :
if a is not self :
# push if closer than two radii
dif = a.pos().dif(self.pos())
a.push(dif)

def update(self) :
if IG.time() < Cell.growthDuration :
if self.time() > 0 and self.time()%Cell.divisionInterval==0 :
if IRand.pct(50) :
self.divide()
if self.time()%Cell.growthInterval==0 :
self.grow()
# update geometry
if self.circle is None :
else :

def divide(self) : # cell division
dir = IRand.dir(IG.zaxis)
self.radius *= 0.5 #make both cell size half
child.hsb(self.hue()+IRand.get(-.1,.1),self.saturation()+IRand.get(-.1,.1),self.brightness()+IRand.get(-.1,.1))
self.pos().sub(dir) # move to the other way

def grow(self) : # growing cell size
```

### Division Control by Location

The next several codes show variations in controlling when cell division happens. The code below controls division by cell's location. When y coordinates of the center point of a cell is larger, it's more likely to divide because the probability is calculated by the y coordinates.

```add_library('igeo')

def setup() :
size(480,360,IG.GL)
Cell(IVec(0,0,0), 10).clr(1.0,0,0)

class Cell(IParticle) :
growthDuration = 2000 #duration of growth and division
growthInterval = 10
divisionInterval = 100
growthSpeed = 0.1

IParticle.__init__(self, pos, IVec(0,0,0))
self.circle = None
self.fric(0.1)

def interact(self, agents) :
for a in agents :
if isinstance(a, Cell) :
if a is not self :
# push if closer than two radii
dif = a.pos().dif(self.pos())
a.push(dif)

def update(self) :
if IG.time() < Cell.growthDuration :
if self.time() > 0 and self.time()%Cell.divisionInterval==0 :
probability = (self.pos().y()+50)*0.8 # divide when bigger than 5
if IRand.pct(probability) :
self.divide()
if self.time()%Cell.growthInterval==0 :
self.grow()
# update geometry
if self.circle is None :
else :

def divide(self) : # cell division
dir = IRand.dir(IG.zaxis)
self.radius *= 0.5 #make both cell size half
child.hsb(self.hue()+IRand.get(-.1,.1),self.saturation()+IRand.get(-.1,.1),self.brightness()+IRand.get(-.1,.1));
self.pos().sub(dir) # move to the other way

def grow(self) : # growing cell size
```

### Division Control by Size

The next code controls division by the size of a cell agent. When a cell's size (radius) becomes too big (> 5), then it divides and make the size half. It also randomize the speed of growth (growthSpeed) in each instance of cell agent.

```add_library('igeo')

def setup() :
size(480,360,IG.GL)
Cell(IVec(0,0,0), 10)

class Cell(IParticle) :
growthDuration = 2000 #duration of growth and division
growthInterval = 10
divisionInterval = 100

IParticle.__init__(self, pos, IVec(0,0,0))
self.circle = None
self.growthSpeed = IRand.get(0.05, 0.1)
self.hsb(self.growthSpeed*10, 1, 1)
self.fric(0.1)

def interact(self, agents) :
for a in agents :
if isinstance(a, Cell) :
if a is not self :
# push if closer than two radii
dif = a.pos().dif(self.pos())
a.push(dif)

def update(self) :
if IG.time() < Cell.growthDuration :
if self.time() > 0 and self.time()%Cell.divisionInterval==0 :
if self.radius > 5 : # divide when bigger than 5
self.divide()
if self.time()%Cell.growthInterval==0 :
self.grow()
# update geometry
if self.circle is None :
else :

def divide(self) : # cell division
dir = IRand.dir(IG.zaxis)
self.radius *= 0.5 #make both cell size half
self.pos().sub(dir) # move to the other way

def grow(self) : # growing cell size
```

### Division Control by Attractor

The next example shows a control of division by attractor points. With the analogy of food or nutrition gives cells energy to grow and divide, the attractor is implemented as Nutrition class in the code and when cells location is closer than a certain distance (Nutrition's radius), the cells divide themselves. With another analogy of nutrition being consumed, the size of a Nutrition agent decreases when it lets a cell agent divide.

Cell agent class also adds active boolean field to control division any time before update method and Nutrition agent turn cell's active field to true to activate division in its feed method. active field is set to be false in divide method to reset the activation every time.

```add_library('igeo')

def setup() :
size(480,360,IG.GL)
for i in range(8) :
Nutrition(IRand.pt(-100,-100,100,100), 20)
for i in range(20) :
Cell(IRand.pt(-100,-100,100,100), 10)

class Nutrition (IAgent) :

self.pos = p

def feed(self, c) :
c.active = True # activate cell

class Cell(IParticle) :
growthDuration = 1400 #duration of growth and division
growthInterval = 10
divisionInterval = 100
growthSpeed = 0.1

IParticle.__init__(self, pos, IVec(0,0,0))
self.circle = None
self.active = False
self.fric(0.1)

def interact(self, agents) :
for a in agents :
if isinstance(a, Cell) :
if a is not self :
# push if closer than two radii
dif = a.pos().dif(self.pos())
a.push(dif)
if isinstance(a, Nutrition) :
if self.time()%Cell.divisionInterval==0 and IG.time() < Cell.growthDuration :
a.feed(self)

def update(self) :
if IG.time() < Cell.growthDuration :
if self.time() > 0 and self.time()%Cell.divisionInterval==0 :
if self.active : # divide when active flag is on
self.divide()
if self.time()%Cell.growthInterval==0 :
self.grow()
# update geometry
if self.circle is None :
else :

def divide(self) : # cell division
dir = IRand.dir(IG.zaxis)
self.radius *= 0.5 #make both cell size half
self.pos().sub(dir) # move to the other way
self.active = False #reset after division

def grow(self) : # growing cell size
```

### Division Control by Neighboring Cells

The next two codes show an example of division control by measuring how crowded it is around a cell. The cell agent measures how crowded around it by counting number of other cell agents within a certain distance range (neighborDist) in interact method. If the total number of neighbors (neighborCount) within the distance range is not too many (<= 3), the cell activates division by turning active variable true in the code below.

```add_library('igeo')

def setup() :
size(480,360,IG.GL)
Cell(IVec(0,0,0), 10).clr(1.0,0,0)

class Cell(IParticle) :
growthDuration = 1800 #duration of growth and division
growthInterval = 10
divisionInterval = 100
growthSpeed = 0.1

IParticle.__init__(self, pos, IVec(0,0,0))
self.circle = None
self.active = False
self.fric(0.1)

def interact(self, agents) :
neighborCount = 0
neighborDist = 1
for a in agents :
if isinstance(a, Cell) :
if a is not self :
# push if closer than two radii
dif = a.pos().dif(self.pos())
a.push(dif)
neighborCount += 1 # count close neighbors
# activate when not many neighbors
if neighborCount <=3 :
self.active = True
else :
self.active = False

def update(self) :
if IG.time() < Cell.growthDuration :
if self.time() > 0 and self.time()%Cell.divisionInterval==0 :
if self.active : # divide when active flag is on
self.divide()
if self.time()%Cell.growthInterval==0 :
self.grow()
# update geometry
if self.circle is None :
else :

def divide(self) : # cell division
dir = IRand.dir(IG.zaxis)
self.radius *= 0.5 #make both cell size half
child.hsb(self.hue()+IRand.get(-.1,.1),self.saturation()+IRand.get(-.1,.1),self.brightness()+IRand.get(-.1,.1))
self.pos().sub(dir) # move to the other way
self.active = False #reset after division

def grow(self) : # growing cell size
```

The code below has an opposite rule of the previous one in the division control. Instead of activating division when a cell sees small number of neighbors, it activates division when a cell sees many neighbors (> 5). Because it starts with one cell, cells are randomly activated for division in the first 600 time frame, and then after that, it activates only when it finds more than 5 neighbors.

```add_library('igeo')

def setup() :
size(480,360,IG.GL)
Cell(IVec(0,0,0), 10).clr(1.0,0,0)

class Cell(IParticle) :
growthDuration = 1000 #duration of growth and division
growthInterval = 10
divisionInterval = 50
growthSpeed = 0.2

IParticle.__init__(self, pos, IVec(0,0,0))
self.circle = None
self.active = False
self.fric(0.1)

def interact(self, agents) :
neighborCount = 0
neighborDist = 2
for a in agents :
if isinstance(a, Cell) :
if a is not self :
# push if closer than two radii
dif = a.pos().dif(self.pos())
a.push(dif)
neighborCount += 1 # count close neighbors
if IG.time() >= 600 :
# activate when it has too many neighbors
if neighborCount > 5 :
self.active = True
else :
self.active = False

def update(self) :
if IG.time() < Cell.growthDuration :
if self.time() > 0 and self.time()%Cell.divisionInterval==0 :
if IG.time() < 600 : # random division
if IRand.pct(50) :
self.active = True
if self.active : # divide when active flag is on
self.divide()
if self.time()%Cell.growthInterval==0 :
self.grow()
# update geometry
if self.circle is None :
else :

def divide(self) : # cell division
dir = IRand.dir(IG.zaxis)
self.radius *= 0.5 #make both cell size half
child.hsb(self.hue()+IRand.get(-.1,.1),self.saturation()+IRand.get(-.1,.1),self.brightness()+IRand.get(-.1,.1))
self.pos().sub(dir) # move to the other way
self.active = False #reset after division

def grow(self) : # growing cell size
```

### Cell Junction by Tensile Link

Many cells in nature have a mechanism to adhere to other cells. This cell adhesion or cell junction mechanism is simulated by connecting two cells with spring-like tensile force. This connection is created when a cell divides itself into two. The parent cell put a spring link between itself and a new divided child.

The code below introduces a new class CellLink to implement the connection and adhesion. To simulate the adhesion by spring-like force, CellLink has an interact method to calculate a force vector from a difference vector of two positions of the linked cells and pull them if they are farther than the summation of two radii or push them if they are too close. An instance of CellLink is created at Cell class's divide method by passing the cell itself and a new child cell.

```add_library('igeo')

def setup() :
size(480,360,IG.GL)
Cell(IVec(0,0,0), 10).clr(0,0,1.0)

class Cell(IParticle) :
growthDuration = 1800 #duration of growth and division
growthInterval = 10
divisionInterval = 100
growthSpeed = 0.1

IParticle.__init__(self, pos, IVec(0,0,0))
self.circle = None
self.active = False
self.fric(0.1)

def interact(self, agents) :
for a in agents :
if isinstance(a, Cell) :
if a is not self :
# push if closer than two radii
dif = a.pos().dif(self.pos())
a.push(dif)

def update(self) :
if IG.time() < Cell.growthDuration :
if self.time() > 0 and self.time()%Cell.divisionInterval==0 :
if IRand.pct(50) : # random division
self.active = True
if self.active : # divide when active flag is on
self.divide()
if self.time()%Cell.growthInterval==0 :
self.grow()
# update geometry
if self.circle is None :
else :

def divide(self) : # cell division
dir = IRand.dir(IG.zaxis)
self.radius *= 0.5 #make both cell size half
child.hsb(self.hue()+IRand.get(-.1,.1),self.saturation()+IRand.get(-.1,.1),self.brightness()+IRand.get(-.1,.1))
self.pos().sub(dir) # move to the other way
self.active = False #reset after division

def grow(self) : # growing cell size

class CellLink(IAgent) : # a link to connect 2 cells with spring force

def __init__(self, c1, c2) :
IAgent.__init__(self)
self.cell1 = c1
self.cell2 = c2
self.line = ICurve(c1.pos(), c2.pos()).clr(1.0,0,0)

def interact(self, agents) :
# spring force
dif = self.cell1.pos().dif(self.cell2.pos())
dif.len(force)
self.cell1.pull(dif)
self.cell2.push(dif)
```

Just to show the effect of tensile links and the network structure of links clearer, the code below adds another repulsion behavior in interact method to push other cells when they are within a certain distance range (30) in addition to the original repulsion force not to have their body defined by radius overlapped.

```add_library('igeo')

def setup() :
size(480,360,IG.GL)
Cell(IVec(0,0,0), 10).clr(0,0,1.0)

class Cell(IParticle) :
growthDuration = 1800 #duration of growth and division
growthInterval = 10
divisionInterval = 100
growthSpeed = 0.1

IParticle.__init__(self, pos, IVec(0,0,0))
self.circle = None
self.active = False
self.fric(0.1)

def interact(self, agents) :
for a in agents :
if isinstance(a, Cell) :
if a is not self :
# push if closer than two radii
dif = a.pos().dif(self.pos())
a.push(dif)
# additional repulsion for smoother organization
dif = a.pos().dif(self.pos())
dif.len(1) # constant force
a.push(dif)

def update(self) :
if IG.time() < Cell.growthDuration :
if self.time() > 0 and self.time()%Cell.divisionInterval==0 :
if IRand.pct(50) : # random division
self.active = True
if self.active : # divide when active flag is on
self.divide()
if self.time()%Cell.growthInterval==0 :
self.grow()
# update geometry
if self.circle is None :
else :

def divide(self) : # cell division
dir = IRand.dir(IG.zaxis)
self.radius *= 0.5 #make both cell size half
child.hsb(self.hue()+IRand.get(-.1,.1),self.saturation()+IRand.get(-.1,.1),self.brightness()+IRand.get(-.1,.1))
self.pos().sub(dir) # move to the other way
self.active = False #reset after division

def grow(self) : # growing cell size

class CellLink(IAgent) : # a link to connect 2 cells with spring force

def __init__(self, c1, c2) :
IAgent.__init__(self)
self.cell1 = c1
self.cell2 = c2
self.line = ICurve(c1.pos(), c2.pos()).clr(1.0,0,0)

def interact(self, agents) :
# spring force
dif = self.cell1.pos().dif(self.cell2.pos())
dif.len(force)
self.cell1.pull(dif)
self.cell2.push(dif)
```

### Cascading Activation Control on Division

Instead of random activation of division or activation depending on surrounding condition at the moment, the next two codes show a division control depending on the history of parent and child through time. In the cascading activation, a parent cell activates a child cell but the parent cell deactivates itself. When the first cell is activated in setup method, this activation cascades to the youngest child cell and there is always only one active cell at a moment.

```add_library('igeo')

def setup() :
size(480,360,IG.GL)
cell = Cell(IVec(0,0,0), 10)
cell.clr(0,0,1.0)
cell.active = True

class Cell(IParticle) :
growthDuration = 2000 #duration of growth and division
growthInterval = 10
divisionInterval = 50
growthSpeed = 0.1

IParticle.__init__(self, pos, IVec(0,0,0))
self.circle = None
self.active = False
self.fric(0.1)

def interact(self, agents) :
for a in agents :
if isinstance(a, Cell) :
if a is not self :
# push if closer than two radii
dif = a.pos().dif(self.pos())
a.push(dif)
# additional repulsion for smoother organization
dif = a.pos().dif(self.pos())
dif.len(1) # constant force
a.push(dif)

def update(self) :
if IG.time() < Cell.growthDuration :
if self.time() > 0 and self.time()%Cell.divisionInterval==0 :
if self.active : # divide when active flag is on
self.divide()
if self.time()%Cell.growthInterval==0 :
self.grow()
# update geometry
if self.circle is None :
else :

def divide(self) : # cell division
dir = IRand.dir(IG.zaxis)
self.radius *= 0.5 #make both cell size half
child.hsb(self.hue()+IRand.get(-.1,.1),self.saturation()+IRand.get(-.1,.1),self.brightness()+IRand.get(-.1,.1))
self.pos().sub(dir) # move to the other way
child.active = True #activate child
self.active = False #deactivate itself

def grow(self) : # growing cell size

class CellLink(IAgent) : # a link to connect 2 cells with spring force

def __init__(self, c1, c2) :
IAgent.__init__(self)
self.cell1 = c1
self.cell2 = c2
self.line = ICurve(c1.pos(), c2.pos()).clr(1.0,0,0)

def interact(self, agents) :
# spring force
dif = self.cell1.pos().dif(self.cell2.pos())
dif.len(force)
self.cell1.pull(dif)
self.cell2.push(dif)
```

### Branching Activation Control on Division

The code below shows another parent-child history dependent activation control of cell division. Instead of a parent cell deactivate itself, it maintains activation after creating a new child and activating the child. Because the still active parent cell will create another child cell in the next time, the parent cell creates multiple children and branched links. Because if cells create child cells in every cycle, they will produce exponentially large number of cells, the code below limits only 3% of parent cells who have two links (back and front) to maintain the activation.

```add_library('igeo')

def setup() :
size(480,360,IG.GL)
cell = Cell(IVec(0,0,0), 10).clr(0,0,1.0)
cell.clr(0,0,1.0)
cell.active = True

class Cell(IParticle) :
growthDuration = 1000 #duration of growth and division
growthInterval = 10
divisionInterval = 50
growthSpeed = 0.1

IParticle.__init__(self, pos, IVec(0,0,0))
self.circle = None
self.active = False
self.fric(0.1)

def interact(self, agents) :
for a in agents :
if isinstance(a, Cell) :
if a is not self :
# push if closer than two radii
dif = a.pos().dif(self.pos())
a.push(dif)
# additional repulsion for smoother organization
dif = a.pos().dif(self.pos())
dif.len(1) # constant force
a.push(dif)

def update(self) :
if IG.time() < Cell.growthDuration :
if self.time() > 0 and self.time()%Cell.divisionInterval==0 :
if self.active : # divide when active flag is on
self.divide()
if self.time()%Cell.growthInterval==0 :
self.grow()
# update geometry
if self.circle is None :
else :

def divide(self) : # cell division
dir = IRand.dir(IG.zaxis)
self.radius *= 0.5 #make both cell size half
child.hsb(self.hue()+IRand.get(-.1,.1),self.saturation()+IRand.get(-.1,.1),self.brightness()+IRand.get(-.1,.1))
self.pos().sub(dir) # move to the other way
child.active = True #activate child
if IRand.pct(70) : # some deactivated, others stay activated
self.active = False #deactivate itself

def grow(self) : # growing cell size

class CellLink(IAgent) : # a link to connect 2 cells with spring force

def __init__(self, c1, c2) :
IAgent.__init__(self)
self.cell1 = c1
self.cell2 = c2
self.line = ICurve(c1.pos(), c2.pos()).clr(0,0.5,0)

def interact(self, agents) :
# spring force
dif = self.cell1.pos().dif(self.cell2.pos())
dif.len(force)
self.cell1.pull(dif)
self.cell2.push(dif)
```

```add_library('igeo')

def setup() :
size(480,360,IG.GL)
cell = Cell(IVec(0,0,0), 10).clr(0,0,1.0)
cell.clr(0,0,1.0)
cell.active = True

class Cell(IParticle) :
growthDuration = 1800 #duration of growth and division
growthInterval = 10
divisionInterval = 50
growthSpeed = 0.1

IParticle.__init__(self, pos, IVec(0,0,0))
self.circle = None
self.active = False
self.fric(0.1)

def interact(self, agents) :
for a in agents :
if isinstance(a, Cell) :
if a is not self :
# push if closer than two radii
dif = a.pos().dif(self.pos())
a.push(dif)
# additional repulsion for smoother organization
dif = a.pos().dif(self.pos())
dif.len(1) # constant force
a.push(dif)

def update(self) :
if IG.time() < Cell.growthDuration :
if self.time() > 0 and self.time()%Cell.divisionInterval==0 :
if len(self.links)==2 and IRand.pct(3) : # random division
self.active = True
if self.active : # divide when active flag is on
self.divide()
if self.time()%Cell.growthInterval==0 :
self.grow()
# update geometry
if self.circle is None :
else :

def divide(self) : # cell division
dir = IRand.dir(IG.zaxis)
self.radius *= 0.5 #make both cell size half
child.hsb(self.hue()+IRand.get(-.1,.1),self.saturation()+IRand.get(-.1,.1),self.brightness()+IRand.get(-.1,.1))
self.pos().sub(dir) # move to the other way
child.active = True #activate child
self.active = False #deactivate itself

def grow(self) : # growing cell size

class CellLink(IAgent) : # a link to connect 2 cells with spring force

def __init__(self, c1, c2) :
IAgent.__init__(self)
self.cell1 = c1
self.cell2 = c2
self.line = ICurve(c1.pos(), c2.pos()).clr(0,0.5,0)

def interact(self, agents) :
# spring force
dif = self.cell1.pos().dif(self.cell2.pos())
dif.len(force)
self.cell1.pull(dif)
self.cell2.push(dif)
```

The tutorial code shows a different way to add a new link to a child cell and it creates a closed loop of links. So far a parent cell just put one link between a child cell and the parent and the newborn child cell always connected to only one cell. The diagram below shows another way to connect. If a parent cell already has one or more links, a new child cell can be inserted in the middle of one existing link.

The code below also adds another behavior in interact method. It's a type of repulsion behavior which is same with the separation behavior in Boid algorithm. The behavior lets the cell to move away from the center of neighbors.

```add_library('igeo')

def setup() :
size(480,360,IG.GL)
IConfig.syncDrawAndDynamics=True #not to crash when some geometry is deleted while drawing
Cell(IVec(0,0,0), 10).clr(0,0,1.0)

class Cell(IParticle) :
growthDuration = 1000 #duration of growth and division
growthInterval = 10
divisionInterval = 50
growthSpeed = 0.1

IParticle.__init__(self, pos, IVec(0,0,0))
self.circle = None
self.active = False
self.fric(0.1)

def interact(self, agents) :
neighborCenter = IVec(0,0,0)
neighborCount=0
for a in agents :
if isinstance(a, Cell) :
if a is not self :
# push if closer than two radii
dif = a.pos().dif(self.pos())
a.push(dif)
# count neighbors and calculate their center
neighborCount+=1
if neighborCount > 0 : # push from center of neighbors
neighborCenter.div(neighborCount)
dif = self.pos().dif(neighborCenter).len(20) # constant force
self.push(dif)

def update(self) :
if IG.time() < Cell.growthDuration :
if self.time() > 0 and self.time()%Cell.divisionInterval==0 :
if IRand.pct(50) : # random division
self.active = True
if self.active : # divide when active flag is on
self.divide()
if self.time()%Cell.growthInterval==0 :
self.grow()
# update geometry
if self.circle is None :
else :

def divide(self) : # cell division
if len(self.links)==0 :  # dot state
child = self.createChild(IRand.dir(IG.zaxis))
elif len(self.links)==1 :  # line state
child = self.createChild(IRand.dir(IG.zaxis))
elif len(self.links)==2 :  # string state
dir = c.pos().dif(self.pos()) # dividing direction is link direction
child = self.createChild(dir)

def grow(self) : # growing cell size

def createChild(self, dir) :
self.radius *= 0.5 #make both cell size half
child.hsb(self.hue()+IRand.get(-.1,.1),self.saturation()+IRand.get(-.1,.1),self.brightness()+IRand.get(-.1,.1))
self.pos().sub(dir) # move to the other way
self.active = False #reset activation
return child

class CellLink(IAgent) : # a link to connect 2 cells with spring force

def __init__(self, c1, c2) :
IAgent.__init__(self)
self.cell1 = c1
self.cell2 = c2
self.line = ICurve(c1.pos(), c2.pos()).clr(1.0,0,0)

def interact(self, agents) :
# spring force
dif = self.cell1.pos().dif(self.cell2.pos())
dif.len(force)
self.cell1.pull(dif)
self.cell2.push(dif)

def delete(self) :
self.line.del() # delete line geometry
self.del() # stop agent

def oppositeCell(self, c) : # find other cell on the link
if self.cell1 is c :
return self.cell2
if self.cell2 is c :
return self.cell1
print("Link does not contain the input cell")
return None
```

(back to the list of tutorials)