public void AddCube(Cube c)
        {
            if ((selectedSide.Parent != null) && (selectedSide.Parent.Origin != null))
            {
                Cube copyC = new Cube();
                copyC.Initialize(c);

                Cube newCube = new Cube();

                newCube.Initialize(selectedSide.Parent.Origin);
                newCube.TransCube = new Cube();
                newCube.TransCube.Initialize(selectedSide.Parent.TransCube);
                double org = 0, now = 0;
                switch (selectedSide.maxState)
                {
                case "minY":
                    org = newCube.faces[0].MaxY();
                    now = selectedSide.Parent.faces[0].MaxY();

                    newCube.TransCube.Translate(0, -2, 0);
                    //copyC.TransCube.Translate(0, -2, 0);

                    if (org > now)
                    {
                        newCube.Translate(0, -2 - (org - now), 0);

                        //copyC.Translate(0, -2 - (org - now), 0);
                    }
                    else
                    {
                        newCube.Translate(0, -2 + (now - org), 0);
                        //copyC.Translate(0, -2 + (now - org), 0);
                    }


                    newCube.Origin = new Cube();
                    newCube.Origin.Initialize(newCube);

                    //newCube.Initialize(copyC);

                    //find center

                    Vertex center = new Vertex();
                    center.x = 0; center.y = 0; center.z = 0;

                    //serendyp approxymations
                    double sumX = 0, sumY = 0, sumZ = 0;
                    for (int j = 0; j < 20; j++)
                    {
                        double fi = F_i(center, j);
                        sumX += newCube.vertices[j].x * fi;
                        sumY += newCube.vertices[j].y * fi;
                        sumZ += newCube.vertices[j].z * fi;
                    }
                    double x0 = sumX;
                    double y0 = sumY;
                    double z0 = sumZ;

                    MessageBox.Show("MinY (" + x0 + ", " + y0 + ", " + z0 + ")");

                    copyC.Translate(x0, y0, z0);
                    newCube.Initialize(copyC);

                    InitializeFace(ref newCube, ref selectedSide.Parent, "minY");


                    CheckAllFaces(0, 0, 0, 0, 0, 0, ref newCube);


                    Model.Add(newCube);
                    break;

                case "maxY":
                    org = newCube.faces[1].MinY();
                    now = selectedSide.Parent.faces[1].MinY();

                    newCube.TransCube.Translate(0, 2, 0);
                    //copyC.TransCube.Translate(0, 2, 0);

                    if (org < now)
                    {
                        newCube.Translate(0, 2 + (org - now), 0);
                        //copyC.Translate(0, 2 + (org - now), 0);
                    }
                    else
                    {
                        newCube.Translate(0, 2 - (org - now), 0);
                        //copyC.Translate(0, 2 - (org - now), 0);
                    }

                    newCube.Origin = new Cube();
                    newCube.Origin.Initialize(newCube);

                    center   = new Vertex();
                    center.x = 0; center.y = 0; center.z = 0;
                    sumX     = 0; sumY = 0; sumZ = 0;
                    for (int j = 0; j < 20; j++)
                    {
                        double fi = F_i(center, j);
                        sumX += newCube.vertices[j].x * fi;
                        sumY += newCube.vertices[j].y * fi;
                        sumZ += newCube.vertices[j].z * fi;
                    }
                    x0 = sumX;
                    y0 = sumY;
                    z0 = sumZ;

                    MessageBox.Show("MaxY (" + x0 + ", " + y0 + ", " + z0 + ")");

                    copyC.Translate(x0, y0, z0);
                    newCube.Initialize(copyC);

                    InitializeFace(ref newCube, ref selectedSide.Parent, "maxY");


                    CheckAllFaces(0, 0, 0, 0, 0, 0, ref newCube);



                    Model.Add(newCube);



                    break;

                case "minX":
                    org = newCube.faces[5].MaxX();
                    now = selectedSide.Parent.faces[5].MaxX();

                    newCube.TransCube.Translate(-2, 0, 0);
                    // copyC.TransCube.Translate(-2, 0, 0);

                    if (org > now)
                    {
                        newCube.Translate(-2 - (org - now), 0, 0);
                        //copyC.Translate(-2 - (org - now), 0, 0);
                    }
                    else
                    {
                        newCube.Translate(-2 + (now - org), 0, 0);
                        //copyC.Translate(-2 + (now - org), 0, 0);
                    }

                    newCube.Origin = new Cube();
                    newCube.Origin.Initialize(newCube);

                    center   = new Vertex();
                    center.x = 0; center.y = 0; center.z = 0;
                    sumX     = 0; sumY = 0; sumZ = 0;
                    for (int j = 0; j < 20; j++)
                    {
                        double fi = F_i(center, j);
                        sumX += newCube.vertices[j].x * fi;
                        sumY += newCube.vertices[j].y * fi;
                        sumZ += newCube.vertices[j].z * fi;
                    }
                    x0 = sumX;
                    y0 = sumY;
                    z0 = sumZ;

                    MessageBox.Show("MinX (" + x0 + ", " + y0 + ", " + z0 + ")");

                    copyC.Translate(x0, y0, z0);
                    newCube.Initialize(copyC);

                    InitializeFace(ref newCube, ref selectedSide.Parent, "minX");
                    CheckAllFaces(1, 0, 0, 0, 0, 0, ref newCube);



                    Model.Add(newCube);
                    break;

                case "maxX":
                    org = newCube.faces[3].MinX();
                    now = selectedSide.Parent.faces[3].MinX();

                    newCube.TransCube.Translate(2, 0, 0);
                    //copyC.TransCube.Translate(2, 0, 0);

                    if (org < now)
                    {
                        newCube.Translate(2 + (org - now), 0, 0);
                        //copyC.Translate(2 + (org - now), 0, 0);
                    }
                    else
                    {
                        newCube.Translate(2 - (org - now), 0, 0);
                        //copyC.Translate(2 - (org - now), 0, 0);
                    }

                    newCube.Origin = new Cube();
                    newCube.Origin.Initialize(newCube);

                    center   = new Vertex();
                    center.x = 0; center.y = 0; center.z = 0;
                    sumX     = 0; sumY = 0; sumZ = 0;
                    for (int j = 0; j < 20; j++)
                    {
                        double fi = F_i(center, j);
                        sumX += newCube.vertices[j].x * fi;
                        sumY += newCube.vertices[j].y * fi;
                        sumZ += newCube.vertices[j].z * fi;
                    }
                    x0 = sumX;
                    y0 = sumY;
                    z0 = sumZ;

                    MessageBox.Show("MaxX (" + x0 + ", " + y0 + ", " + z0 + ")");

                    copyC.Translate(x0, y0, z0);
                    newCube.Initialize(copyC);

                    InitializeFace(ref newCube, ref selectedSide.Parent, "maxX");
                    CheckAllFaces(0, 0, 0, 0, 0, 0, ref newCube);



                    Model.Add(newCube);
                    break;

                case "minZ":
                    org = newCube.faces[4].MaxZ();
                    now = selectedSide.Parent.faces[4].MaxZ();

                    newCube.TransCube.Translate(0, 0, -2);
                    //copyC.TransCube.Translate(0, 0, -2);

                    if (org > now)
                    {
                        newCube.Translate(0, 0, -2 - (org - now));
                        //copyC.Translate(0, 0, -2 - (org - now));
                    }
                    else
                    {
                        newCube.Translate(0, 0, -2 + (now - org));
                        //copyC.Translate(0, 0, -2 + (now - org));
                    }


                    newCube.Origin = new Cube();
                    newCube.Origin.Initialize(newCube);

                    center   = new Vertex();
                    center.x = 0; center.y = 0; center.z = 0;
                    sumX     = 0; sumY = 0; sumZ = 0;
                    for (int j = 0; j < 20; j++)
                    {
                        double fi = F_i(center, j);
                        sumX += newCube.vertices[j].x * fi;
                        sumY += newCube.vertices[j].y * fi;
                        sumZ += newCube.vertices[j].z * fi;
                    }
                    x0 = sumX;
                    y0 = sumY;
                    z0 = sumZ;

                    MessageBox.Show("MinZ (" + x0 + ", " + y0 + ", " + z0 + ")");

                    copyC.Translate(x0, y0, z0);
                    newCube.Initialize(copyC);

                    InitializeFace(ref newCube, ref selectedSide.Parent, "minZ");
                    CheckAllFaces(0, 0, 0, 0, 0, 0, ref newCube);



                    Model.Add(newCube);
                    break;

                case "maxZ":
                    org = newCube.faces[2].MinZ();
                    now = selectedSide.Parent.faces[2].MinZ();

                    newCube.TransCube.Translate(0, 0, 2);
                    //copyC.TransCube.Translate(0, 0, 2);

                    if (org < now)
                    {
                        newCube.Translate(0, 0, 2 + (org - now));
                        //copyC.Translate(0, 0, 2 + (org - now));
                    }
                    else
                    {
                        newCube.Translate(0, 0, 2 - (org - now));
                        //copyC.Translate(0, 0, 2 - (org - now));
                    }

                    newCube.Origin = new Cube();
                    newCube.Origin.Initialize(newCube);

                    center   = new Vertex();
                    center.x = 0; center.y = 0; center.z = 0;
                    sumX     = 0; sumY = 0; sumZ = 0;
                    for (int j = 0; j < 20; j++)
                    {
                        double fi = F_i(center, j);
                        sumX += newCube.vertices[j].x * fi;
                        sumY += newCube.vertices[j].y * fi;
                        sumZ += newCube.vertices[j].z * fi;
                    }
                    x0 = sumX;
                    y0 = sumY;
                    z0 = sumZ;

                    MessageBox.Show("MaxZ (" + x0 + ", " + y0 + ", " + z0 + ")");

                    copyC.Translate(x0, y0, z0);
                    newCube.Initialize(copyC);

                    InitializeFace(ref newCube, ref selectedSide.Parent, "maxZ");
                    CheckAllFaces(0, 0, 0, 0, 0, 0, ref newCube);



                    Model.Add(newCube);
                    break;
                }


                DevideCurveCube(Model.Count - 1, ref newCube);
            }
            else
            {
                IsAddingCube = false;
            }
            IsAddingCube           = false;
            selectedSide.IsPointed = false;
        }
        void AddCube1(Cube newCube)
        {
            if ((selectedSide.Parent != null) && (selectedSide.Parent.Origin != null))
            {
                //Cube newCube = new Cube();

                //newCube.Initialize(selectedSide.Parent.Origin);
                newCube.Origin = new Cube();
                newCube.Origin.Initialize(selectedSide.Parent.Origin);
                newCube.TransCube = new Cube();
                newCube.TransCube.Initialize(selectedSide.Parent.TransCube);
                double org = 0, now = 0;
                switch (selectedSide.maxState)
                {
                case "minY":
                    org = newCube.faces[0].MaxY();
                    now = selectedSide.Parent.faces[0].MaxY();

                    newCube.TransCube.Translate(0, -2, 0);

                    if (org > now)
                    {
                        newCube.Translate(0, -2 - (org - now), 0);
                    }
                    else
                    {
                        newCube.Translate(0, -2 + (now - org), 0);
                    }


                    newCube.Origin = new Cube();
                    newCube.Origin.Initialize(newCube);

                    InitializeFace(ref newCube, ref selectedSide.Parent, "minY");


                    CheckAllFaces(0, 0, 0, 0, 0, 0, ref newCube);


                    Model.Add(newCube);
                    break;

                case "maxY":
                    org = newCube.faces[1].MinY();
                    now = selectedSide.Parent.faces[1].MinY();

                    newCube.TransCube.Translate(0, 2, 0);

                    if (org < now)
                    {
                        newCube.Translate(0, 2 + (org - now), 0);
                    }
                    else
                    {
                        newCube.Translate(0, 2 - (org - now), 0);
                    }

                    newCube.Origin = new Cube();
                    newCube.Origin.Initialize(newCube);

                    InitializeFace(ref newCube, ref selectedSide.Parent, "maxY");
                    CheckAllFaces(0, 0, 0, 0, 0, 0, ref newCube);

                    Model.Add(newCube);

                    break;

                case "minX":
                    org = newCube.faces[5].MaxX();
                    now = selectedSide.Parent.faces[5].MaxX();

                    newCube.TransCube.Translate(-2, 0, 0);

                    if (org > now)
                    {
                        newCube.Translate(-2 - (org - now), 0, 0);
                    }
                    else
                    {
                        newCube.Translate(-2 + (now - org), 0, 0);
                    }

                    newCube.Origin = new Cube();
                    newCube.Origin.Initialize(newCube);

                    InitializeFace(ref newCube, ref selectedSide.Parent, "minX");
                    CheckAllFaces(1, 0, 0, 0, 0, 0, ref newCube);


                    Model.Add(newCube);
                    break;

                case "maxX":
                    org = newCube.faces[3].MinX();
                    now = selectedSide.Parent.faces[3].MinX();

                    newCube.TransCube.Translate(2, 0, 0);

                    if (org < now)
                    {
                        newCube.Translate(2 + (org - now), 0, 0);
                    }
                    else
                    {
                        newCube.Translate(2 - (org - now), 0, 0);
                    }

                    newCube.Origin = new Cube();
                    newCube.Origin.Initialize(newCube);

                    InitializeFace(ref newCube, ref selectedSide.Parent, "maxX");
                    CheckAllFaces(0, 0, 0, 0, 0, 0, ref newCube);

                    Model.Add(newCube);
                    break;

                case "minZ":
                    org = newCube.faces[4].MaxZ();
                    now = selectedSide.Parent.faces[4].MaxZ();

                    newCube.TransCube.Translate(0, 0, -2);

                    if (org > now)
                    {
                        newCube.Translate(0, 0, -2 - (org - now));
                    }
                    else
                    {
                        newCube.Translate(0, 0, -2 + (now - org));
                    }

                    newCube.Origin = new Cube();
                    newCube.Origin.Initialize(newCube);

                    InitializeFace(ref newCube, ref selectedSide.Parent, "minZ");
                    CheckAllFaces(0, 0, 0, 0, 0, 0, ref newCube);

                    Model.Add(newCube);
                    break;

                case "maxZ":
                    org = newCube.faces[2].MinZ();
                    now = selectedSide.Parent.faces[2].MinZ();

                    newCube.TransCube.Translate(0, 0, 2);

                    if (org < now)
                    {
                        newCube.Translate(0, 0, 2 + (org - now));
                    }
                    else
                    {
                        newCube.Translate(0, 0, 2 - (org - now));
                    }

                    newCube.Origin = new Cube();
                    newCube.Origin.Initialize(newCube);

                    InitializeFace(ref newCube, ref selectedSide.Parent, "maxZ");
                    CheckAllFaces(0, 0, 0, 0, 0, 0, ref newCube);

                    Model.Add(newCube);
                    break;
                }
                DevideCurveCube(Model.Count - 1, ref newCube);
            }
            else
            {
                IsAddingCube = false;
            }
            IsAddingCube           = false;
            selectedSide.IsPointed = false;
        }