© Vladimir Kovalevsky 2019
Vladimir KovalevskyModern Algorithms for Image Processinghttps://doi.org/10.1007/978-1-4842-4237-7_14

14. A Computer Model of Cell Differentiation

Vladimir Kovalevsky1 
(1)
Berlin, Germany
 

This chapter does not belong to the area of image processing. The reason for including it in this book is the broad and versatile interest circle of the author. The topic of this chapter is related to biology.

One can ask how is it possible that cells of different types are developed during the growth of an organism in spite of the fact that they all have exactly the same deoxyribonucleic acid (DNA) . It can be supposed that each cell must obtain some information indicating its position in the growing organism, perhaps some kind of coordinates. The DNA must then contain different instructions for the development of cells having different coordinates. The coordinates can be produced during the division of cells: A new cell adjacent to an old cell with coordinate set (X, Y, Z) must get the coordinate set in which one of the coordinates of the old cell has been increased or reduced by 1. Which of the three coordinates is changed depends on the direction of the vector from the old cell to the new one. Thus the two main ideas of this chapter are that cells must get some kind of coordinates and that DNA instructions specifying the properties of a cell must depend on its coordinates.

We have developed a project WFcellDivision in which a multicellular organism is modeled by an array Org (organism) of 63 × 63 cells (an odd number is better to exactly define the middle cell).

The process of producing a new cell is simulated by specifying and saving its features. Each cell can possess the coordinates X and Y as its features, a variable Property (which is a color index), and the array DNA[63×63] as its genetic information. A cell is an object of the class CCelln.
int const Cwidth=63, Cheight=63;
class CCelln
{ public:
    int X, Y, Property;
    unsigned char DNA[Cwidth*Cheight];
}

The aim of the project is to simulate the generation of one cell after another and the assignment of a value to the variable Property of each cell. The value depends on the coordinates of this cell and on the contents of DNA saved in this cell. Directly copying the values of DNA to Properties of all cells of Org is supposed to be impossible. It is only possible to copy the DNA from one cell to the neighboring new originating cell and to copy inside the originating cell one certain value from the DNA of the cell to the Property of this cell. The aim of the project is to demonstrate that in spite of these limitations, it is possible to assign correct values of Property to all cells of Org.

Let us describe the functioning of the project. The method Form1 begins by defining and initializing the array Org possessing memory for 63 × 63 cells. Initializing Org consists of setting the Property and the elements of the array DNA[63×63] of each cell of Org to −1, which means that the cell does not exist.

Then one of the cells in the middle of the array Org , namely that with the coordinates (31, 31), becomes “filled”: It obtains the coordinates X = 31 and Y = 31. Its array DNA is filled with the color indexes of a small digital Image of 63 × 63 pixels. The image has been chosen arbitrarily to demonstrate that concrete content can be assigned to the properties of the cells. The content of DNA becomes a copy of a digital image where each element is a color index, a number between 0 and 255 that can be transformed to a color by means of a color table Palette. In Palette a color (RED, GREEN, BLUE) is saved for each color index. All other cells of the array Org initially have at the coordinates equal to −1 and the array DNA is empty (i.e., it is filled with −1).

The method Grow is called next. It simulates the growth of the organism while generating coordinates of cells starting with a cell adjacent to the central cell (31, 31). The coordinates are generated in such a way that all originating cells lie in a spiral turning around the central cell. During the growth process, more and more cells obtain a copy of the array DNA from one of the neighboring cells. They also obtain their coordinates and certain values of Property depending on the content of DNA and of the coordinates of a cell.

The Property of the cell with the coordinates (31, 31) obtains the value of a single element of the array DNA (see Figure 14-1), DNA[31, 31], i.e. the color index of the pixel (31, 31).
../images/474294_1_En_14_Chapter/474294_1_En_14_Fig1_HTML.jpg
Figure 14-1

The image copied to Org[31, 31].DNA

The shape of the growing organism is specified by the boundary of the area with the black color assigned to some elements of DNA around the color area representing the growing organism. This array contains a color index different from (0, 0, 0) in each element corresponding to a cell that should be present in the organism and an index pointing to (0, 0, 0) (black color) for each element corresponding to a cell that should not be present in the organism.

A cell of the array Org is filled if it has nonzero coordinates, a value of Property pointing to a color different from (0, 0, 0), and contents of DNA different from -1.

When the growth process is started, each cell in the array Org that is adjacent to a filled cell obtains an exact copy of the array DNA that is the same for all cells. The coordinates of this cell obtain values differing by 1 from the coordinates of the filled neighbor cell. For example, if the new cell lies to the right of a filled cell with coordinates (X, Y) then its X coordinate obtains the value X1 = X + 1 and its Y coordinate Y1 the value Y. The new cell obtains the standard copy of the DNA and its Property becomes equal to DNA[X1, Y1] where X1 and Y1 are the coordinates of the new cell.

Here is the code for Grow .
int Grow(CCelln[] Org, int width, int height)
{ int cnt=0, i, k, x=(width-1)/2, y=(height-1)/2, nCount=1, X, Y;
  do
  { for (i=0; i<nCount && x<width-1; i++)
    { x++;
      X=Org[x+width*y].X=Org[x-1+width*y].X+1;
      Y=Org[x+width*y].Y=Org[x-1+width*y].Y;
      for (k=0; k<width*height; k++) Org[x+width*y].DNA[k] =
                                                   Org[x-1+width*y].DNA[k];
      Org[x+width*y].Property=Org[x+width*y].DNA[X+width*Y];
    }
    cnt+=nCount;
    if (cnt==width*height) break;
    for (i=0; i<nCount && y<height-1; i++)
    {  y++;
      X=Org[x+width*y].X=Org[x+width*(y-1)].X;
      Y=Org[x+width*y].Y=Org[x+width*(y-1)].Y+1;
      for (k=0; k<width*height; k++) Org[x+width*y].DNA[k] =
                                                 Org[x+width*(y-1)].DNA[k];
      Org[x+width*y].Property=Org[x+width*y].DNA[X+width*Y];
    }
    cnt+=nCount;
    if (cnt==width*height) break;
    nCount++;
    for (i=0; i<nCount && x>0; i++)
    {  x--;
      X=Org[x+width*y].X=Org[x+1+width*y].X-1;
      Y=Org[x+width*y].Y=Org[x+1+width*y].Y;
      for (k=0; k<width*height; k++)
                             Org[x+width*y].DNA[k]=Org[x+1+width*y].DNA[k];
      Org[x+width*y].Property=Org[x+width*y].DNA[X+width*Y];
    }
    cnt+=nCount;
    if (cnt==width*height) break;
    for (i=0; i<nCount && y>0; i++)
    { y--;
      X=Org[x+width*y].X=Org[x+width*(y+1)].X;
      Y=Org[x+width*y].Y=Org[x+width*(y+1)].Y-1;
      for (k=0; k<width*height; k++)
                           Org[x+width*y].DNA[k]=Org[x+width*(y+1)].DNA[k];
      Org[x+width*y].Property=Org[x+width*y].DNA[X+width*Y];
    }
    cnt+=nCount;
    if (cnt==width*height) break;
    nCount++;
  } while(1);
  return 1;
}
The process finishes when all cells of the array Org are filled. Then the values of Property of all cells are copied into a new array (image) of 63 × 63 pixels with the aim of making the results visible. This image is displayed with the color table Palette, and the user can see that the image is identical to the original Image copied to DNA[31, 31] except the pixels where the array DNA has indexes pointing to the black color. These pixels are shown as black (see Figure 14-2).
../images/474294_1_En_14_Chapter/474294_1_En_14_Fig2_HTML.jpg
Figure 14-2

The resulting image copied from Org[*].Property

Thus all cells of the array Org are different: They contain different values of Property despite all of them having exactly the same copy of the array DNA .

Conclusion

We have demonstrated that it is possible to generate an organism with different cells in spite of the fact that all cells of the organism have exactly the same copy of genetic information and in spite of the fact that directly copying the array DNA to the array Org[x, y].Property was prohibited.

..................Content has been hidden....................

You can't read the all page of ebook, please click here login for view all page.
Reset
3.140.198.43