Lab3/Sources/Interface/fSpaceC.cpp - master - arkt1k/TOKM

Lab3/Sources/Interface/fSpaceC.cpp
1 356 строк49 KB
arkt1k
Добавление лаборатораторной работы 3
07 ноя 2024, 14:42
07 ноя 2024, 14:42cc118fa
//---------------------------------------------------------------------------
#define MULTICOEF 1
#include <vcl.h>
#include <cstdlib>
#include <ctime>
#include <typeinfo>
#include <fstream>
#include <string>
#pragma hdrstop

#include "fSpaceC.h"
#include "fTableC.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma link "GLS.BaseClasses"
#pragma link "GLS.Cadencer"
#pragma link "GLS.Coordinates"
#pragma link "GLS.Objects"
#pragma link "GLS.Scene"
#pragma link "GLS.SceneViewer"
#pragma link "GLS.GeomObjects"
#pragma link "GLS.VectorFileObjects"
#pragma link "GLS.Mesh"
#pragma link "GLS.SimpleNavigation"
#pragma resource "*.dfm"
TFormScene* FormScene;

int mx, my; // vars for saving position

DelaunayBase* Points;

// All Delaunay structs
DelaunayBase All_Delaunay;
DelaunayBase O_Delaunay;
DelaunayBase B_Delaunay;
DelaunayBase A_Delaunay;
DelaunayBase F_Delaunay;
DelaunayBase G_Delaunay;
DelaunayBase K_Delaunay;
DelaunayBase M_Delaunay;

// All Voronoi structs
VoronoiBase All_Voronoi;
VoronoiBase O_Voronoi;
VoronoiBase B_Voronoi;
VoronoiBase A_Voronoi;
VoronoiBase F_Voronoi;
VoronoiBase G_Voronoi;
VoronoiBase K_Voronoi;
VoronoiBase M_Voronoi;

// Colors for each star class
float lightblue[3] = { 0, 0.8, 1 };
float skyblue[3] = { 0.803, 1, 1 };
float white[3] = { 1, 1, 1 };
float lightyellow[3] = { 0.996, 1, 0.6 };
float yellow[3] = { 1, 1, 0.003 };
float orange[3] = { 1, 0.4, 0 };
float red[3] = { 0.992, 0, 0.003 };

String datapath;

TStringList* S1 = new TStringList;
TStringList* T1 = new TStringList;

//---------------------------------------------------------------------------

void __fastcall TFormScene::FormCreate(TObject* Sender)
{
	// Указываем путь для файлов
	datapath = ".\\..\\..\\DATA\\";
	// Включаем кнопку загрузки
	clbMethods->Checked[0] = true;
	// Разделитель float . (для CSV)
    FormatSettings.DecimalSeparator = '.';
}

// Получение данных для Тетраэдров Делоне
DelaunayBase __fastcall TFormScene::InitDelaunay(
    String starClass, float color[])
{
	//========================= ПОЛУЧЕНИЕ NODE.CSV
    DelaunayBase dt_struct;
	String path = "";
	dt_struct.color = color;
    unsigned char FX, FY, FZ;

    path = datapath + "/Delaunay/" + starClass + "/node.csv";
    S1->LoadFromFile(path);
    T1->CommaText = S1->Strings[0];

    for (int i = 0; i < T1->Count; i++) {
        if (T1[0][i] == "X")
            FX = i;
        else if (T1[0][i] == "Y")
            FY = i;
        else if (T1[0][i] == "Z")
            FZ = i;
    }

    dt_struct.nodeCount = S1->Count;

    dt_struct.node = new double*[dt_struct.nodeCount]; // DT_node
    for (int i = 0; i < dt_struct.nodeCount; ++i)
        dt_struct.node[i] = new double[3];

    for (int i = 1; i < dt_struct.nodeCount; i++) {
        try {
            T1->CommaText = S1->Strings[i];
            dt_struct.node[i][0] = StrToFloat(T1[0][FX]) * MULTICOEF;
            dt_struct.node[i][1] = StrToFloat(T1[0][FY]) * MULTICOEF;
            dt_struct.node[i][2] = StrToFloat(T1[0][FZ]) * MULTICOEF;

        } catch (...) {
        }
    }

	//========================= ПОЛУЧЕНИЕ EDGE.CSV
    path = datapath + "/Delaunay/" + starClass + "/edge.csv";
    S1->LoadFromFile(path);
    T1->CommaText = S1->Strings[0];
    unsigned char FNode1, FNode2;

    for (int i = 0; i < T1->Count; i++) {
        if (T1[0][i] == "Node1")
            FNode1 = i;
        else if (T1[0][i] == "Node2")
            FNode2 = i;
    }

    dt_struct.edgeCount = S1->Count;

    dt_struct.edge = new int*[dt_struct.edgeCount]; // DT_edge
    for (int i = 0; i < dt_struct.edgeCount; ++i) {
        dt_struct.edge[i] = new int[2];
    }

    for (int i = 1; i < dt_struct.edgeCount; i++) {
        try {
            T1->CommaText = S1->Strings[i];

            dt_struct.edge[i][0] = StrToFloat(T1[0][FNode1]) * MULTICOEF;
            dt_struct.edge[i][1] = StrToFloat(T1[0][FNode2]) * MULTICOEF;

        } catch (...) {
        }
    }

    return dt_struct;
}
//---------------------------------------------------------------------------
// Получение данных для полиэдров Вороного
VoronoiBase __fastcall TFormScene::InitVoronoi(String starClass, float color[])
{
    VoronoiBase vd_struct;
    String path = "";
    vd_struct.color = color;

	//========================= ПОЛУЧЕНИЕ NODE.CSV
	unsigned char FX, FY, FZ;

    path = datapath + "/Voronoi/" + starClass + "/node.csv";
    S1->LoadFromFile(path);
    T1->CommaText = S1->Strings[0];

    for (int i = 0; i < T1->Count; i++) {
        if (T1[0][i] == "X")
            FX = i;
        else if (T1[0][i] == "Y")
            FY = i;
        else if (T1[0][i] == "Z")
            FZ = i;
    }

    vd_struct.nodeCount = S1->Count;

	vd_struct.node = new double*[vd_struct.nodeCount];
    for (int i = 0; i < vd_struct.nodeCount; ++i)
        vd_struct.node[i] = new double[3];

    for (int i = 1; i < vd_struct.nodeCount; i++) {
        try {
            T1->CommaText = S1->Strings[i];
            vd_struct.node[i][0] = StrToFloat(T1[0][FX]) * MULTICOEF;
            vd_struct.node[i][1] = StrToFloat(T1[0][FY]) * MULTICOEF;
            vd_struct.node[i][2] = StrToFloat(T1[0][FZ]) * MULTICOEF;

        } catch (...) {
        }
    }

	//========================= ПОЛУЧЕНИЕ EDGE.CSV
    path = datapath + "/Voronoi/" + starClass + "/edge.csv";
    S1->LoadFromFile(path);
    T1->CommaText = S1->Strings[0];
    unsigned char FNode1, FNode2;

    for (int i = 0; i < T1->Count; i++) {
        if (T1[0][i] == "X")
            FX = i;
        else if (T1[0][i] == "Y")
            FY = i;
        else if (T1[0][i] == "Z")
            FZ = i;
        else if (T1[0][i] == "Node1")
            FNode1 = i;
        else if (T1[0][i] == "Node2")
            FNode2 = i;
    }

	vd_struct.edgeCount = S1->Count;

    vd_struct.edge = new double*[vd_struct.edgeCount]; // VD_edge
    for (int i = 0; i < vd_struct.edgeCount; ++i) {
        vd_struct.edge[i] = new double[5];
    }

    for (int i = 1; i < vd_struct.edgeCount; i++) {
        try {
            T1->CommaText = S1->Strings[i];

            vd_struct.edge[i][0] = StrToFloat(T1[0][FNode1]) * MULTICOEF;
            vd_struct.edge[i][1] = StrToFloat(T1[0][FNode2]) * MULTICOEF;

            try {
                vd_struct.edge[i][2] = StrToFloat(T1[0][FX]) * MULTICOEF;
                vd_struct.edge[i][3] = StrToFloat(T1[0][FY]) * MULTICOEF;
                vd_struct.edge[i][4] = StrToFloat(T1[0][FZ]) * MULTICOEF;
            } catch (...) {
                vd_struct.edge[i][2] = 0;
                vd_struct.edge[i][3] = 0;
                vd_struct.edge[i][4] = 0;
            }
        } catch (...) {
        }
    }

    return vd_struct;
}
//---------------------------------------------------------------------------
// Отрисовка звёзд
void __fastcall TFormScene::DrawPoints()
{
    // Delete all points from the scene
    GLPoints1->Free();
    GLPoints1 = (TGLPoints*)(GLDummyCube1->AddNewChild(__classid(TGLPoints)));

    GLPoints1->Size = 2;
    GLPoints1->Positions->Clear();

    float X, Y, Z, R, G, B;
    switch (ClassGroup->ItemIndex) {
        case 0:
            for (int i = 0; i < O_Delaunay.nodeCount; i++) {
                try {
                    X = O_Delaunay.node[i][0] * MULTICOEF;
                    Y = O_Delaunay.node[i][1] * MULTICOEF;
                    Z = O_Delaunay.node[i][2] * MULTICOEF;

                    R = O_Delaunay.color[0];
                    G = O_Delaunay.color[1];
                    B = O_Delaunay.color[2];

                    GLPoints1->Positions->Add(X, Y, Z);
                    GLPoints1->Colors->AddPoint(R, G, B);
                } catch (...) {
                }
            }
            for (int i = 0; i < B_Delaunay.nodeCount; i++) {
                try {
                    X = B_Delaunay.node[i][0] * MULTICOEF;
                    Y = B_Delaunay.node[i][1] * MULTICOEF;
                    Z = B_Delaunay.node[i][2] * MULTICOEF;

                    R = B_Delaunay.color[0];
                    G = B_Delaunay.color[1];
                    B = B_Delaunay.color[2];

                    GLPoints1->Positions->Add(X, Y, Z);
                    GLPoints1->Colors->AddPoint(R, G, B);
				} catch (...) {
                }
            }
            for (int i = 0; i < A_Delaunay.nodeCount; i++) {
                try {
                    X = A_Delaunay.node[i][0] * MULTICOEF;
                    Y = A_Delaunay.node[i][1] * MULTICOEF;
                    Z = A_Delaunay.node[i][2] * MULTICOEF;

                    R = A_Delaunay.color[0];
                    G = A_Delaunay.color[1];
                    B = A_Delaunay.color[2];

                    GLPoints1->Positions->Add(X, Y, Z);
                    GLPoints1->Colors->AddPoint(R, G, B);
                } catch (...) {
                }
            }
            for (int i = 0; i < F_Delaunay.nodeCount; i++) {
                try {
                    X = F_Delaunay.node[i][0] * MULTICOEF;
                    Y = F_Delaunay.node[i][1] * MULTICOEF;
                    Z = F_Delaunay.node[i][2] * MULTICOEF;

                    R = F_Delaunay.color[0];
                    G = F_Delaunay.color[1];
                    B = F_Delaunay.color[2];

                    GLPoints1->Positions->Add(X, Y, Z);
                    GLPoints1->Colors->AddPoint(R, G, B);
                } catch (...) {
                }
            }
            for (int i = 0; i < G_Delaunay.nodeCount; i++) {
                try {
                    X = G_Delaunay.node[i][0] * MULTICOEF;
                    Y = G_Delaunay.node[i][1] * MULTICOEF;
                    Z = G_Delaunay.node[i][2] * MULTICOEF;

                    R = G_Delaunay.color[0];
                    G = G_Delaunay.color[1];
                    B = G_Delaunay.color[2];

                    GLPoints1->Positions->Add(X, Y, Z);
                    GLPoints1->Colors->AddPoint(R, G, B);
                } catch (...) {
                }
            }
            for (int i = 0; i < K_Delaunay.nodeCount; i++) {
                try {
                    X = K_Delaunay.node[i][0] * MULTICOEF;
                    Y = K_Delaunay.node[i][1] * MULTICOEF;
                    Z = K_Delaunay.node[i][2] * MULTICOEF;

                    R = K_Delaunay.color[0];
                    G = K_Delaunay.color[1];
                    B = K_Delaunay.color[2];

                    GLPoints1->Positions->Add(X, Y, Z);
                    GLPoints1->Colors->AddPoint(R, G, B);
                } catch (...) {
                }
            }
            for (int i = 0; i < M_Delaunay.nodeCount; i++) {
                try {
                    X = M_Delaunay.node[i][0] * MULTICOEF;
                    Y = M_Delaunay.node[i][1] * MULTICOEF;
                    Z = M_Delaunay.node[i][2] * MULTICOEF;

                    R = M_Delaunay.color[0];
                    G = M_Delaunay.color[1];
                    B = M_Delaunay.color[2];

                    GLPoints1->Positions->Add(X, Y, Z);
                    GLPoints1->Colors->AddPoint(R, G, B);
                } catch (...) {
                }
            }
            break;
        case 1:
            for (int i = 0; i < O_Delaunay.nodeCount; i++) {
                try {
                    X = O_Delaunay.node[i][0] * MULTICOEF;
                    Y = O_Delaunay.node[i][1] * MULTICOEF;
                    Z = O_Delaunay.node[i][2] * MULTICOEF;

                    R = O_Delaunay.color[0];
                    G = O_Delaunay.color[1];
                    B = O_Delaunay.color[2];

                    GLPoints1->Positions->Add(X, Y, Z);
                    GLPoints1->Colors->AddPoint(R, G, B);
                } catch (...) {
                }
            }
            break;
        case 2:
            for (int i = 0; i < B_Delaunay.nodeCount; i++) {
                try {
                    X = B_Delaunay.node[i][0] * MULTICOEF;
                    Y = B_Delaunay.node[i][1] * MULTICOEF;
                    Z = B_Delaunay.node[i][2] * MULTICOEF;

                    R = B_Delaunay.color[0];
                    G = B_Delaunay.color[1];
                    B = B_Delaunay.color[2];

                    GLPoints1->Positions->Add(X, Y, Z);
                    GLPoints1->Colors->AddPoint(R, G, B);
                } catch (...) {
                }
            }
            break;
        case 3:
            for (int i = 0; i < A_Delaunay.nodeCount; i++) {
                try {
                    X = A_Delaunay.node[i][0] * MULTICOEF;
                    Y = A_Delaunay.node[i][1] * MULTICOEF;
                    Z = A_Delaunay.node[i][2] * MULTICOEF;

                    R = A_Delaunay.color[0];
                    G = A_Delaunay.color[1];
                    B = A_Delaunay.color[2];

                    GLPoints1->Positions->Add(X, Y, Z);
                    GLPoints1->Colors->AddPoint(R, G, B);
                } catch (...) {
                }
            }
            break;
        case 4:
            for (int i = 0; i < F_Delaunay.nodeCount; i++) {
                try {
                    X = F_Delaunay.node[i][0] * MULTICOEF;
                    Y = F_Delaunay.node[i][1] * MULTICOEF;
                    Z = F_Delaunay.node[i][2] * MULTICOEF;

                    R = F_Delaunay.color[0];
                    G = F_Delaunay.color[1];
                    B = F_Delaunay.color[2];

                    GLPoints1->Positions->Add(X, Y, Z);
                    GLPoints1->Colors->AddPoint(R, G, B);
                } catch (...) {
                }
            }
            break;
        case 5:
            for (int i = 0; i < G_Delaunay.nodeCount; i++) {
                try {
                    X = G_Delaunay.node[i][0] * MULTICOEF;
                    Y = G_Delaunay.node[i][1] * MULTICOEF;
                    Z = G_Delaunay.node[i][2] * MULTICOEF;

                    R = G_Delaunay.color[0];
                    G = G_Delaunay.color[1];
                    B = G_Delaunay.color[2];

                    GLPoints1->Positions->Add(X, Y, Z);
                    GLPoints1->Colors->AddPoint(R, G, B);
                } catch (...) {
                }
            }
            break;
        case 6:
            for (int i = 0; i < K_Delaunay.nodeCount; i++) {
                try {
                    X = K_Delaunay.node[i][0] * MULTICOEF;
                    Y = K_Delaunay.node[i][1] * MULTICOEF;
                    Z = K_Delaunay.node[i][2] * MULTICOEF;

                    R = K_Delaunay.color[0];
                    G = K_Delaunay.color[1];
                    B = K_Delaunay.color[2];

                    GLPoints1->Positions->Add(X, Y, Z);
                    GLPoints1->Colors->AddPoint(R, G, B);
                } catch (...) {
                }
            }
            break;
        case 7:
            for (int i = 0; i < M_Delaunay.nodeCount; i++) {
                try {
                    X = M_Delaunay.node[i][0] * MULTICOEF;
                    Y = M_Delaunay.node[i][1] * MULTICOEF;
                    Z = M_Delaunay.node[i][2] * MULTICOEF;

                    R = M_Delaunay.color[0];
                    G = M_Delaunay.color[1];
                    B = M_Delaunay.color[2];

                    GLPoints1->Positions->Add(X, Y, Z);
                    GLPoints1->Colors->AddPoint(R, G, B);
                } catch (...) {
                }
            }
            break;
    }
}
//---------------------------------------------------------------------------
// Отрисовка тетраэдров Делоне
void __fastcall TFormScene::DrawDelaunay()
{
	GLLines1->Free();
    GLLines1 = (TGLLines*)(GLDummyCube1->AddNewChild(__classid(TGLLines)));

    float X1, Y1, Z1, X2, Y2, Z2, R, G, B;
    int NodeIndex1, NodeIndex2, NodeIndex3;
    switch (ClassGroup->ItemIndex) {
        case 0:
            R = O_Delaunay.color[0];
            G = O_Delaunay.color[1];
            B = O_Delaunay.color[2];
            // Set edges color
            GLLines1->LineColor->SetColor(R, G, B, 1);
            // Delete axes of points
            GLLines1->NodesAspect = lnaInvisible;

            for (int i = 0; i < O_Delaunay.edgeCount; i++) {
                try {
                    NodeIndex1 = O_Delaunay.edge[i][0];
                    NodeIndex2 = O_Delaunay.edge[i][1];

                    X1 = O_Delaunay.node[NodeIndex1][0] * MULTICOEF;
                    Y1 = O_Delaunay.node[NodeIndex1][1] * MULTICOEF;
                    Z1 = O_Delaunay.node[NodeIndex1][2] * MULTICOEF;

                    X2 = O_Delaunay.node[NodeIndex2][0] * MULTICOEF;
                    Y2 = O_Delaunay.node[NodeIndex2][1] * MULTICOEF;
                    Z2 = O_Delaunay.node[NodeIndex2][2] * MULTICOEF;

                    GLLines1->Nodes->AddNode(X1, Y1, Z1);
                    GLLines1->Nodes->AddNode(X2, Y2, Z2);
                } catch (...) {
                }
            }

            for (int i = 0; i < B_Delaunay.edgeCount; i++) {
                try {
                    NodeIndex1 = B_Delaunay.edge[i][0];
                    NodeIndex2 = B_Delaunay.edge[i][1];

                    X1 = B_Delaunay.node[NodeIndex1][0] * MULTICOEF;
                    Y1 = B_Delaunay.node[NodeIndex1][1] * MULTICOEF;
                    Z1 = B_Delaunay.node[NodeIndex1][2] * MULTICOEF;

                    X2 = B_Delaunay.node[NodeIndex2][0] * MULTICOEF;
                    Y2 = B_Delaunay.node[NodeIndex2][1] * MULTICOEF;
                    Z2 = B_Delaunay.node[NodeIndex2][2] * MULTICOEF;

                    GLLines1->Nodes->AddNode(X1, Y1, Z1);
                    GLLines1->Nodes->AddNode(X2, Y2, Z2);
                } catch (...) {
                }
            }

            for (int i = 0; i < A_Delaunay.edgeCount; i++) {
                try {
                    NodeIndex1 = A_Delaunay.edge[i][0];
                    NodeIndex2 = A_Delaunay.edge[i][1];

                    X1 = A_Delaunay.node[NodeIndex1][0] * MULTICOEF;
                    Y1 = A_Delaunay.node[NodeIndex1][1] * MULTICOEF;
                    Z1 = A_Delaunay.node[NodeIndex1][2] * MULTICOEF;

                    X2 = A_Delaunay.node[NodeIndex2][0] * MULTICOEF;
                    Y2 = A_Delaunay.node[NodeIndex2][1] * MULTICOEF;
                    Z2 = A_Delaunay.node[NodeIndex2][2] * MULTICOEF;

                    GLLines1->Nodes->AddNode(X1, Y1, Z1);
                    GLLines1->Nodes->AddNode(X2, Y2, Z2);
                } catch (...) {
                }
            }

            for (int i = 0; i < F_Delaunay.edgeCount; i++) {
                try {
                    NodeIndex1 = F_Delaunay.edge[i][0];
                    NodeIndex2 = F_Delaunay.edge[i][1];

                    X1 = F_Delaunay.node[NodeIndex1][0] * MULTICOEF;
                    Y1 = F_Delaunay.node[NodeIndex1][1] * MULTICOEF;
                    Z1 = F_Delaunay.node[NodeIndex1][2] * MULTICOEF;

                    X2 = F_Delaunay.node[NodeIndex2][0] * MULTICOEF;
                    Y2 = F_Delaunay.node[NodeIndex2][1] * MULTICOEF;
                    Z2 = F_Delaunay.node[NodeIndex2][2] * MULTICOEF;

                    GLLines1->Nodes->AddNode(X1, Y1, Z1);
                    GLLines1->Nodes->AddNode(X2, Y2, Z2);
                } catch (...) {
                }
            }

            for (int i = 0; i < G_Delaunay.edgeCount; i++) {
                try {
                    NodeIndex1 = G_Delaunay.edge[i][0];
                    NodeIndex2 = G_Delaunay.edge[i][1];

                    X1 = G_Delaunay.node[NodeIndex1][0] * MULTICOEF;
                    Y1 = G_Delaunay.node[NodeIndex1][1] * MULTICOEF;
                    Z1 = G_Delaunay.node[NodeIndex1][2] * MULTICOEF;

                    X2 = G_Delaunay.node[NodeIndex2][0] * MULTICOEF;
                    Y2 = G_Delaunay.node[NodeIndex2][1] * MULTICOEF;
                    Z2 = G_Delaunay.node[NodeIndex2][2] * MULTICOEF;

                    GLLines1->Nodes->AddNode(X1, Y1, Z1);
                    GLLines1->Nodes->AddNode(X2, Y2, Z2);
                } catch (...) {
                }
            }

            for (int i = 0; i < K_Delaunay.edgeCount; i++) {
                try {
                    NodeIndex1 = K_Delaunay.edge[i][0];
                    NodeIndex2 = K_Delaunay.edge[i][1];

                    X1 = K_Delaunay.node[NodeIndex1][0] * MULTICOEF;
                    Y1 = K_Delaunay.node[NodeIndex1][1] * MULTICOEF;
                    Z1 = K_Delaunay.node[NodeIndex1][2] * MULTICOEF;

                    X2 = K_Delaunay.node[NodeIndex2][0] * MULTICOEF;
                    Y2 = K_Delaunay.node[NodeIndex2][1] * MULTICOEF;
                    Z2 = K_Delaunay.node[NodeIndex2][2] * MULTICOEF;

                    GLLines1->Nodes->AddNode(X1, Y1, Z1);
                    GLLines1->Nodes->AddNode(X2, Y2, Z2);
                } catch (...) {
                }
            }

            for (int i = 0; i < M_Delaunay.edgeCount; i++) {
                try {
                    NodeIndex1 = M_Delaunay.edge[i][0];
                    NodeIndex2 = M_Delaunay.edge[i][1];

                    X1 = M_Delaunay.node[NodeIndex1][0] * MULTICOEF;
                    Y1 = M_Delaunay.node[NodeIndex1][1] * MULTICOEF;
                    Z1 = M_Delaunay.node[NodeIndex1][2] * MULTICOEF;

                    X2 = M_Delaunay.node[NodeIndex2][0] * MULTICOEF;
                    Y2 = M_Delaunay.node[NodeIndex2][1] * MULTICOEF;
                    Z2 = M_Delaunay.node[NodeIndex2][2] * MULTICOEF;

                    GLLines1->Nodes->AddNode(X1, Y1, Z1);
                    GLLines1->Nodes->AddNode(X2, Y2, Z2);
                } catch (...) {
                }
            }
            break;
        case 1:
            R = O_Delaunay.color[0];
            G = O_Delaunay.color[1];
            B = O_Delaunay.color[2];

            for (int i = 0; i < O_Delaunay.edgeCount; i++) {
                try {
                    NodeIndex1 = O_Delaunay.edge[i][0];
                    NodeIndex2 = O_Delaunay.edge[i][1];

                    X1 = O_Delaunay.node[NodeIndex1][0] * MULTICOEF;
                    Y1 = O_Delaunay.node[NodeIndex1][1] * MULTICOEF;
                    Z1 = O_Delaunay.node[NodeIndex1][2] * MULTICOEF;

                    X2 = O_Delaunay.node[NodeIndex2][0] * MULTICOEF;
                    Y2 = O_Delaunay.node[NodeIndex2][1] * MULTICOEF;
                    Z2 = O_Delaunay.node[NodeIndex2][2] * MULTICOEF;

                    GLLines1->Nodes->AddNode(X1, Y1, Z1);
                    GLLines1->Nodes->AddNode(X2, Y2, Z2);
                } catch (...) {
                }
            }
            // Set edges color
            GLLines1->LineColor->SetColor(R, G, B, 1);
            // Delete axes of points
            GLLines1->NodesAspect = lnaInvisible;
            break;
        case 2:
            R = B_Delaunay.color[0];
            G = B_Delaunay.color[1];
            B = B_Delaunay.color[2];

            for (int i = 0; i < B_Delaunay.edgeCount; i++) {
                try {
                    NodeIndex1 = B_Delaunay.edge[i][0];
                    NodeIndex2 = B_Delaunay.edge[i][1];

                    X1 = B_Delaunay.node[NodeIndex1][0] * MULTICOEF;
                    Y1 = B_Delaunay.node[NodeIndex1][1] * MULTICOEF;
                    Z1 = B_Delaunay.node[NodeIndex1][2] * MULTICOEF;

                    X2 = B_Delaunay.node[NodeIndex2][0] * MULTICOEF;
                    Y2 = B_Delaunay.node[NodeIndex2][1] * MULTICOEF;
                    Z2 = B_Delaunay.node[NodeIndex2][2] * MULTICOEF;

                    GLLines1->Nodes->AddNode(X1, Y1, Z1);
                    GLLines1->Nodes->AddNode(X2, Y2, Z2);
                } catch (...) {
                }
            }
            // Set edges color
            GLLines1->LineColor->SetColor(R, G, B, 1);
            // Delete axes of points
            GLLines1->NodesAspect = lnaInvisible;
            break;
        case 3:
            R = A_Delaunay.color[0];
            G = A_Delaunay.color[1];
            B = A_Delaunay.color[2];

            for (int i = 0; i < A_Delaunay.edgeCount; i++) {
                try {
                    NodeIndex1 = A_Delaunay.edge[i][0];
                    NodeIndex2 = A_Delaunay.edge[i][1];

                    X1 = A_Delaunay.node[NodeIndex1][0] * MULTICOEF;
                    Y1 = A_Delaunay.node[NodeIndex1][1] * MULTICOEF;
                    Z1 = A_Delaunay.node[NodeIndex1][2] * MULTICOEF;

                    X2 = A_Delaunay.node[NodeIndex2][0] * MULTICOEF;
                    Y2 = A_Delaunay.node[NodeIndex2][1] * MULTICOEF;
                    Z2 = A_Delaunay.node[NodeIndex2][2] * MULTICOEF;

                    GLLines1->Nodes->AddNode(X1, Y1, Z1);
                    GLLines1->Nodes->AddNode(X2, Y2, Z2);

                } catch (...) {
                }
            }
            // Set edges color
            GLLines1->LineColor->SetColor(R, G, B, 1);
            // Delete axes of points
            GLLines1->NodesAspect = lnaInvisible;
            break;
        case 4:
            R = F_Delaunay.color[0];
            G = F_Delaunay.color[1];
            B = F_Delaunay.color[2];

            for (int i = 0; i < F_Delaunay.edgeCount; i++) {
                try {
                    NodeIndex1 = F_Delaunay.edge[i][0];
                    NodeIndex2 = F_Delaunay.edge[i][1];

                    X1 = F_Delaunay.node[NodeIndex1][0] * MULTICOEF;
                    Y1 = F_Delaunay.node[NodeIndex1][1] * MULTICOEF;
                    Z1 = F_Delaunay.node[NodeIndex1][2] * MULTICOEF;

                    X2 = F_Delaunay.node[NodeIndex2][0] * MULTICOEF;
                    Y2 = F_Delaunay.node[NodeIndex2][1] * MULTICOEF;
                    Z2 = F_Delaunay.node[NodeIndex2][2] * MULTICOEF;

                    GLLines1->Nodes->AddNode(X1, Y1, Z1);
                    GLLines1->Nodes->AddNode(X2, Y2, Z2);
                } catch (...) {
                }
            }
            // Set edges color
            GLLines1->LineColor->SetColor(R, G, B, 1);
            // Delete axes of points
            GLLines1->NodesAspect = lnaInvisible;
            break;
        case 5:
            R = G_Delaunay.color[0];
            G = G_Delaunay.color[1];
            B = G_Delaunay.color[2];

            for (int i = 0; i < G_Delaunay.edgeCount; i++) {
                try {
                    NodeIndex1 = G_Delaunay.edge[i][0];
                    NodeIndex2 = G_Delaunay.edge[i][1];

                    X1 = G_Delaunay.node[NodeIndex1][0] * MULTICOEF;
                    Y1 = G_Delaunay.node[NodeIndex1][1] * MULTICOEF;
                    Z1 = G_Delaunay.node[NodeIndex1][2] * MULTICOEF;

                    X2 = G_Delaunay.node[NodeIndex2][0] * MULTICOEF;
                    Y2 = G_Delaunay.node[NodeIndex2][1] * MULTICOEF;
                    Z2 = G_Delaunay.node[NodeIndex2][2] * MULTICOEF;

                    GLLines1->Nodes->AddNode(X1, Y1, Z1);
                    GLLines1->Nodes->AddNode(X2, Y2, Z2);
                } catch (...) {
                }
            }
            // Set edges color
            GLLines1->LineColor->SetColor(R, G, B, 1);
            // Delete axes of points
            GLLines1->NodesAspect = lnaInvisible;
            break;
        case 6:
            R = K_Delaunay.color[0];
            G = K_Delaunay.color[1];
            B = K_Delaunay.color[2];

            for (int i = 0; i < K_Delaunay.edgeCount; i++) {
                try {
                    NodeIndex1 = K_Delaunay.edge[i][0];
                    NodeIndex2 = K_Delaunay.edge[i][1];

                    X1 = K_Delaunay.node[NodeIndex1][0] * MULTICOEF;
                    Y1 = K_Delaunay.node[NodeIndex1][1] * MULTICOEF;
                    Z1 = K_Delaunay.node[NodeIndex1][2] * MULTICOEF;

                    X2 = K_Delaunay.node[NodeIndex2][0] * MULTICOEF;
                    Y2 = K_Delaunay.node[NodeIndex2][1] * MULTICOEF;
                    Z2 = K_Delaunay.node[NodeIndex2][2] * MULTICOEF;

                    GLLines1->Nodes->AddNode(X1, Y1, Z1);
                    GLLines1->Nodes->AddNode(X2, Y2, Z2);
                } catch (...) {
                }
            }
            // Set edges color
            GLLines1->LineColor->SetColor(R, G, B, 1);
            // Delete axes of points
            GLLines1->NodesAspect = lnaInvisible;
            break;
        case 7:
            R = M_Delaunay.color[0];
            G = M_Delaunay.color[1];
            B = M_Delaunay.color[2];

            for (int i = 0; i < M_Delaunay.edgeCount; i++) {
                try {
                    NodeIndex1 = M_Delaunay.edge[i][0];
                    NodeIndex2 = M_Delaunay.edge[i][1];

                    X1 = M_Delaunay.node[NodeIndex1][0] * MULTICOEF;
                    Y1 = M_Delaunay.node[NodeIndex1][1] * MULTICOEF;
                    Z1 = M_Delaunay.node[NodeIndex1][2] * MULTICOEF;

                    X2 = M_Delaunay.node[NodeIndex2][0] * MULTICOEF;
                    Y2 = M_Delaunay.node[NodeIndex2][1] * MULTICOEF;
                    Z2 = M_Delaunay.node[NodeIndex2][2] * MULTICOEF;

					GLLines1->Nodes->AddNode(X1, Y1, Z1);
                    GLLines1->Nodes->AddNode(X2, Y2, Z2);
                } catch (...) {
                }
            }
            // Set edges color
            GLLines1->LineColor->SetColor(R, G, B, 1);
            // Delete axes of stars
            GLLines1->NodesAspect = lnaInvisible;
            break;
    }
}
//---------------------------------------------------------------------------
// Отрисовка полиэдров Вороного
void __fastcall TFormScene::DrawVoronoi()
{
    GLLines2->Free();
	GLLines2 = (TGLLines*)(GLDummyCube1->AddNewChild(__classid(TGLLines)));
    float X, Y, Z, R, G, B;
    float X1, Y1, Z1, X2, Y2, Z2;
    int NodeIndex1, NodeIndex2;

    switch (ClassGroup->ItemIndex) {
        case 0:
            R = 255;
            G = 255;
			B = 255;

            GLLines2->LineColor->SetColor(R * 0.7, G * 0.7, B * 0.7, 1);

            GLLines2->NodesAspect = lnaInvisible;

            for (int i = 0; i < O_Voronoi.edgeCount; i++) {
                try {
                    NodeIndex1 = O_Voronoi.edge[i][0];
                    NodeIndex2 = O_Voronoi.edge[i][1];

                    X1 = O_Voronoi.node[NodeIndex1][0] * MULTICOEF;
                    Y1 = O_Voronoi.node[NodeIndex1][1] * MULTICOEF;
                    Z1 = O_Voronoi.node[NodeIndex1][2] * MULTICOEF;

                    if (NodeIndex2 == -1) {
                        X2 = O_Voronoi.edge[i][2];
                        Y2 = O_Voronoi.edge[i][3];
                        Z2 = O_Voronoi.edge[i][4];
                    } else {
						X2 = O_Voronoi.node[NodeIndex2][0] * MULTICOEF;
                        Y2 = O_Voronoi.node[NodeIndex2][1] * MULTICOEF;
                        Z2 = O_Voronoi.node[NodeIndex2][2] * MULTICOEF;
                    }

                    GLLines2->Nodes->AddNode(X1, Y1, Z1);
                    GLLines2->Nodes->AddNode(X2, Y2, Z2);
                } catch (...) {
                }
            }

            for (int i = 0; i < B_Voronoi.edgeCount; i++) {
                try {
                    NodeIndex1 = B_Voronoi.edge[i][0];
                    NodeIndex2 = B_Voronoi.edge[i][1];

                    X1 = B_Voronoi.node[NodeIndex1][0] * MULTICOEF;
                    Y1 = B_Voronoi.node[NodeIndex1][1] * MULTICOEF;
                    Z1 = B_Voronoi.node[NodeIndex1][2] * MULTICOEF;

                    if (NodeIndex2 == -1) {
                        X2 = B_Voronoi.edge[i][2];
                        Y2 = B_Voronoi.edge[i][3];
                        Z2 = B_Voronoi.edge[i][4];
                    } else {
                        X2 = B_Voronoi.node[NodeIndex2][0] * MULTICOEF;
                        Y2 = B_Voronoi.node[NodeIndex2][1] * MULTICOEF;
                        Z2 = B_Voronoi.node[NodeIndex2][2] * MULTICOEF;
                    }

                    GLLines2->Nodes->AddNode(X1, Y1, Z1);
                    GLLines2->Nodes->AddNode(X2, Y2, Z2);
                } catch (...) {
                }
            }

            for (int i = 0; i < A_Voronoi.edgeCount; i++) {
                try {
                    NodeIndex1 = A_Voronoi.edge[i][0];
                    NodeIndex2 = A_Voronoi.edge[i][1];

                    X1 = A_Voronoi.node[NodeIndex1][0] * MULTICOEF;
                    Y1 = A_Voronoi.node[NodeIndex1][1] * MULTICOEF;
                    Z1 = A_Voronoi.node[NodeIndex1][2] * MULTICOEF;

                    if (NodeIndex2 == -1) {
                        X2 = A_Voronoi.edge[i][2];
                        Y2 = A_Voronoi.edge[i][3];
                        Z2 = A_Voronoi.edge[i][4];
                    } else {
                        X2 = A_Voronoi.node[NodeIndex2][0] * MULTICOEF;
                        Y2 = A_Voronoi.node[NodeIndex2][1] * MULTICOEF;
                        Z2 = A_Voronoi.node[NodeIndex2][2] * MULTICOEF;
                    }

                    GLLines2->Nodes->AddNode(X1, Y1, Z1);
                    GLLines2->Nodes->AddNode(X2, Y2, Z2);
                } catch (...) {
                }
            }

            for (int i = 0; i < F_Voronoi.edgeCount; i++) {
                try {
                    NodeIndex1 = F_Voronoi.edge[i][0];
                    NodeIndex2 = F_Voronoi.edge[i][1];

                    X1 = F_Voronoi.node[NodeIndex1][0] * MULTICOEF;
                    Y1 = F_Voronoi.node[NodeIndex1][1] * MULTICOEF;
                    Z1 = F_Voronoi.node[NodeIndex1][2] * MULTICOEF;

                    if (NodeIndex2 == -1) {
                        X2 = F_Voronoi.edge[i][2];
                        Y2 = F_Voronoi.edge[i][3];
                        Z2 = F_Voronoi.edge[i][4];
                    } else {
                        X2 = F_Voronoi.node[NodeIndex2][0] * MULTICOEF;
                        Y2 = F_Voronoi.node[NodeIndex2][1] * MULTICOEF;
                        Z2 = F_Voronoi.node[NodeIndex2][2] * MULTICOEF;
                    }

                    GLLines2->Nodes->AddNode(X1, Y1, Z1);
                    GLLines2->Nodes->AddNode(X2, Y2, Z2);

                } catch (...) {
                }
            }

            for (int i = 0; i < G_Voronoi.edgeCount; i++) {
                try {
                    NodeIndex1 = G_Voronoi.edge[i][0];
                    NodeIndex2 = G_Voronoi.edge[i][1];

                    X1 = G_Voronoi.node[NodeIndex1][0] * MULTICOEF;
                    Y1 = G_Voronoi.node[NodeIndex1][1] * MULTICOEF;
                    Z1 = G_Voronoi.node[NodeIndex1][2] * MULTICOEF;

                    if (NodeIndex2 == -1) {
                        X2 = G_Voronoi.edge[i][2];
                        Y2 = G_Voronoi.edge[i][3];
                        Z2 = G_Voronoi.edge[i][4];
                    } else {
                        X2 = G_Voronoi.node[NodeIndex2][0] * MULTICOEF;
                        Y2 = G_Voronoi.node[NodeIndex2][1] * MULTICOEF;
                        Z2 = G_Voronoi.node[NodeIndex2][2] * MULTICOEF;
                    }

                    GLLines2->Nodes->AddNode(X1, Y1, Z1);
                    GLLines2->Nodes->AddNode(X2, Y2, Z2);
                } catch (...) {
                }
            }

            for (int i = 0; i < K_Voronoi.edgeCount; i++) {
                try {
                    NodeIndex1 = K_Voronoi.edge[i][0];
                    NodeIndex2 = K_Voronoi.edge[i][1];

					X1 = K_Voronoi.node[NodeIndex1][0] * MULTICOEF;
                    Y1 = K_Voronoi.node[NodeIndex1][1] * MULTICOEF;
                    Z1 = K_Voronoi.node[NodeIndex1][2] * MULTICOEF;

                    if (NodeIndex2 == -1) {
                        X2 = K_Voronoi.edge[i][2];
                        Y2 = K_Voronoi.edge[i][3];
                        Z2 = K_Voronoi.edge[i][4];
                    } else {
                        X2 = K_Voronoi.node[NodeIndex2][0] * MULTICOEF;
                        Y2 = K_Voronoi.node[NodeIndex2][1] * MULTICOEF;
                        Z2 = K_Voronoi.node[NodeIndex2][2] * MULTICOEF;
                    }

                    GLLines2->Nodes->AddNode(X1, Y1, Z1);
                    GLLines2->Nodes->AddNode(X2, Y2, Z2);
                } catch (...) {
                }
            }

            for (int i = 0; i < M_Voronoi.edgeCount; i++) {
                try {
                    NodeIndex1 = M_Voronoi.edge[i][0];
                    NodeIndex2 = M_Voronoi.edge[i][1];

                    X1 = M_Voronoi.node[NodeIndex1][0] * MULTICOEF;
                    Y1 = M_Voronoi.node[NodeIndex1][1] * MULTICOEF;
                    Z1 = M_Voronoi.node[NodeIndex1][2] * MULTICOEF;

                    if (NodeIndex2 == -1) {
                        X2 = M_Voronoi.edge[i][2];
                        Y2 = M_Voronoi.edge[i][3];
                        Z2 = M_Voronoi.edge[i][4];
                    } else {
                        X2 = M_Voronoi.node[NodeIndex2][0] * MULTICOEF;
                        Y2 = M_Voronoi.node[NodeIndex2][1] * MULTICOEF;
                        Z2 = M_Voronoi.node[NodeIndex2][2] * MULTICOEF;
                    }

                    GLLines2->Nodes->AddNode(X1, Y1, Z1);
                    GLLines2->Nodes->AddNode(X2, Y2, Z2);
                } catch (...) {
                }
            }
            break;
        case 1:
            R = O_Voronoi.color[0];
            G = O_Voronoi.color[1];
            B = O_Voronoi.color[2];

            for (int i = 0; i < O_Voronoi.edgeCount; i++) {
                try {
                    NodeIndex1 = O_Voronoi.edge[i][0];
                    NodeIndex2 = O_Voronoi.edge[i][1];

                    X1 = O_Voronoi.node[NodeIndex1][0] * MULTICOEF;
                    Y1 = O_Voronoi.node[NodeIndex1][1] * MULTICOEF;
                    Z1 = O_Voronoi.node[NodeIndex1][2] * MULTICOEF;

                    if (NodeIndex2 == -1) {
                        X2 = O_Voronoi.edge[i][2];
                        Y2 = O_Voronoi.edge[i][3];
                        Z2 = O_Voronoi.edge[i][4];
                    } else {
                        X2 = O_Voronoi.node[NodeIndex2][0] * MULTICOEF;
                        Y2 = O_Voronoi.node[NodeIndex2][1] * MULTICOEF;
                        Z2 = O_Voronoi.node[NodeIndex2][2] * MULTICOEF;
                    }

                    GLLines2->Nodes->AddNode(X1, Y1, Z1);
                    GLLines2->Nodes->AddNode(X2, Y2, Z2);
                } catch (...) {
                }
            }
            // Set edges color
            GLLines2->LineColor->SetColor(R * 0.7, G * 0.7, B * 0.7, 1);
            // Delete axes of points
            GLLines2->NodesAspect = lnaInvisible;
            break;
        case 2:
            R = B_Voronoi.color[0];
            G = B_Voronoi.color[1];
            B = B_Voronoi.color[2];

            for (int i = 0; i < B_Voronoi.edgeCount; i++) {
                try {
                    NodeIndex1 = B_Voronoi.edge[i][0];
                    NodeIndex2 = B_Voronoi.edge[i][1];

                    X1 = B_Voronoi.node[NodeIndex1][0] * MULTICOEF;
                    Y1 = B_Voronoi.node[NodeIndex1][1] * MULTICOEF;
                    Z1 = B_Voronoi.node[NodeIndex1][2] * MULTICOEF;

                    if (NodeIndex2 == -1) {
                        X2 = B_Voronoi.edge[i][2];
                        Y2 = B_Voronoi.edge[i][3];
                        Z2 = B_Voronoi.edge[i][4];
                    } else {
                        X2 = B_Voronoi.node[NodeIndex2][0] * MULTICOEF;
                        Y2 = B_Voronoi.node[NodeIndex2][1] * MULTICOEF;
                        Z2 = B_Voronoi.node[NodeIndex2][2] * MULTICOEF;
                    }

                    GLLines2->Nodes->AddNode(X1, Y1, Z1);
                    GLLines2->Nodes->AddNode(X2, Y2, Z2);
                } catch (...) {
                }
            }
            // Set edges color
            GLLines2->LineColor->SetColor(R * 0.7, G * 0.7, B * 0.7, 1);
            // Delete axes of points
            GLLines2->NodesAspect = lnaInvisible;
            break;
        case 3:
            R = A_Voronoi.color[0];
            G = A_Voronoi.color[1];
            B = A_Voronoi.color[2];

            for (int i = 0; i < A_Voronoi.edgeCount; i++) {
                try {
                    NodeIndex1 = A_Voronoi.edge[i][0];
                    NodeIndex2 = A_Voronoi.edge[i][1];

                    X1 = A_Voronoi.node[NodeIndex1][0] * MULTICOEF;
                    Y1 = A_Voronoi.node[NodeIndex1][1] * MULTICOEF;
                    Z1 = A_Voronoi.node[NodeIndex1][2] * MULTICOEF;

                    if (NodeIndex2 == -1) {
                        X2 = A_Voronoi.edge[i][2];
                        Y2 = A_Voronoi.edge[i][3];
                        Z2 = A_Voronoi.edge[i][4];
                    } else {
						X2 = A_Voronoi.node[NodeIndex2][0] * MULTICOEF;
                        Y2 = A_Voronoi.node[NodeIndex2][1] * MULTICOEF;
                        Z2 = A_Voronoi.node[NodeIndex2][2] * MULTICOEF;
                    }

                    GLLines2->Nodes->AddNode(X1, Y1, Z1);
                    GLLines2->Nodes->AddNode(X2, Y2, Z2);
                } catch (...) {
                }
            }
            // Set edges color
            GLLines2->LineColor->SetColor(R * 0.7, G * 0.7, B * 0.7, 1);
            // Delete axes of points
            GLLines2->NodesAspect = lnaInvisible;
            break;
        case 4:
            R = F_Voronoi.color[0];
            G = F_Voronoi.color[1];
            B = F_Voronoi.color[2];

            for (int i = 0; i < F_Voronoi.edgeCount; i++) {
                try {
                    NodeIndex1 = F_Voronoi.edge[i][0];
                    NodeIndex2 = F_Voronoi.edge[i][1];

                    X1 = G_Voronoi.node[NodeIndex1][0] * MULTICOEF;
                    Y1 = G_Voronoi.node[NodeIndex1][1] * MULTICOEF;
                    Z1 = G_Voronoi.node[NodeIndex1][2] * MULTICOEF;

                    if (NodeIndex2 == -1) {
                        X2 = F_Voronoi.edge[i][2];
                        Y2 = F_Voronoi.edge[i][3];
                        Z2 = F_Voronoi.edge[i][4];
                    } else {
                        X2 = F_Voronoi.node[NodeIndex2][0] * MULTICOEF;
                        Y2 = F_Voronoi.node[NodeIndex2][1] * MULTICOEF;
                        Z2 = F_Voronoi.node[NodeIndex2][2] * MULTICOEF;
                    }

                    GLLines2->Nodes->AddNode(X1, Y1, Z1);
                    GLLines2->Nodes->AddNode(X2, Y2, Z2);
                } catch (...) {
                }
            }
            // Set edges color
            GLLines2->LineColor->SetColor(R * 0.7, G * 0.7, B * 0.7, 1);
            // Delete axes of points
            GLLines2->NodesAspect = lnaInvisible;
            break;
        case 5:
            R = G_Voronoi.color[0];
            G = G_Voronoi.color[1];
            B = G_Voronoi.color[2];

            for (int i = 0; i < G_Voronoi.edgeCount; i++) {
                try {
                    NodeIndex1 = G_Voronoi.edge[i][0];
                    NodeIndex2 = G_Voronoi.edge[i][1];

                    X1 = G_Voronoi.node[NodeIndex1][0] * MULTICOEF;
                    Y1 = G_Voronoi.node[NodeIndex1][1] * MULTICOEF;
                    Z1 = G_Voronoi.node[NodeIndex1][2] * MULTICOEF;

                    if (NodeIndex2 == -1) {
                        X2 = G_Voronoi.edge[i][2];
                        Y2 = G_Voronoi.edge[i][3];
                        Z2 = G_Voronoi.edge[i][4];
                    } else {
                        X2 = G_Voronoi.node[NodeIndex2][0] * MULTICOEF;
                        Y2 = G_Voronoi.node[NodeIndex2][1] * MULTICOEF;
                        Z2 = G_Voronoi.node[NodeIndex2][2] * MULTICOEF;
                    }

                    GLLines2->Nodes->AddNode(X1, Y1, Z1);
                    GLLines2->Nodes->AddNode(X2, Y2, Z2);
                } catch (...) {
                }
            }
            // Set edges color
            GLLines2->LineColor->SetColor(R * 0.7, G * 0.7, B * 0.7, 1);
            // Delete axes of points
            GLLines2->NodesAspect = lnaInvisible;
            break;
        case 6:
            R = K_Voronoi.color[0];
            G = K_Voronoi.color[1];
            B = K_Voronoi.color[2];

            for (int i = 0; i < K_Voronoi.edgeCount; i++) {
                try {
                    NodeIndex1 = K_Voronoi.edge[i][0];
                    NodeIndex2 = K_Voronoi.edge[i][1];

                    X1 = K_Voronoi.node[NodeIndex1][0] * MULTICOEF;
                    Y1 = K_Voronoi.node[NodeIndex1][1] * MULTICOEF;
                    Z1 = K_Voronoi.node[NodeIndex1][2] * MULTICOEF;

                    if (NodeIndex2 == -1) {
                        X2 = K_Voronoi.edge[i][2];
                        Y2 = K_Voronoi.edge[i][3];
                        Z2 = K_Voronoi.edge[i][4];
                    } else {
                        X2 = K_Voronoi.node[NodeIndex2][0] * MULTICOEF;
                        Y2 = K_Voronoi.node[NodeIndex2][1] * MULTICOEF;
                        Z2 = K_Voronoi.node[NodeIndex2][2] * MULTICOEF;
                    }

                    GLLines2->Nodes->AddNode(X1, Y1, Z1);
                    GLLines2->Nodes->AddNode(X2, Y2, Z2);
                } catch (...) {
                }
            }
            // Set edges color
            GLLines2->LineColor->SetColor(R * 0.7, G * 0.7, B * 0.7, 1);
            // Delete axes of points
            GLLines2->NodesAspect = lnaInvisible;
            break;
        case 7:
            R = M_Voronoi.color[0];
            G = M_Voronoi.color[1];
            B = M_Voronoi.color[2];

            for (int i = 0; i < M_Voronoi.edgeCount; i++) {
                try {
                    NodeIndex1 = M_Voronoi.edge[i][0];
                    NodeIndex2 = M_Voronoi.edge[i][1];

                    X1 = M_Voronoi.node[NodeIndex1][0] * MULTICOEF;
                    Y1 = M_Voronoi.node[NodeIndex1][1] * MULTICOEF;
                    Z1 = M_Voronoi.node[NodeIndex1][2] * MULTICOEF;

                    if (NodeIndex2 == -1) {
                        X2 = M_Voronoi.edge[i][2];
                        Y2 = M_Voronoi.edge[i][3];
                        Z2 = M_Voronoi.edge[i][4];
                    } else {
                        X2 = M_Voronoi.node[NodeIndex2][0] * MULTICOEF;
                        Y2 = M_Voronoi.node[NodeIndex2][1] * MULTICOEF;
                        Z2 = M_Voronoi.node[NodeIndex2][2] * MULTICOEF;
                    }

                    GLLines2->Nodes->AddNode(X1, Y1, Z1);
                    GLLines2->Nodes->AddNode(X2, Y2, Z2);
                } catch (...) {
                }
            }
            // Set edges color
            GLLines2->LineColor->SetColor(R * 0.7, G * 0.7, B * 0.7, 1);
            // Delete axes of points
            GLLines2->NodesAspect = lnaInvisible;
            break;
    }
}

// Общая функция выбора отрисовки
void __fastcall TFormScene::InitDraw()
{
    // Draw 3D model based on selected mode
    if (clbMethods->Checked[0]) {
        DrawPoints();
    }
    if (clbMethods->Checked[1]) {
		DrawDelaunay();
    }
    if (clbMethods->Checked[2]) {
        DrawVoronoi();
	}
}
//---------------------------------------------------------------------------
__fastcall TFormScene::TFormScene(TComponent* Owner) : TForm(Owner) {}
//---------------------------------------------------------------------------
void __fastcall TFormScene::GLCadencer1Progress(
    TObject* Sender, const double deltaTime, const double newTime)
{
    GLSceneViewer1->Invalidate();
}
//---------------------------------------------------------------------------
// Старт загрузки файлов
void __fastcall TFormScene::Start1Click(TObject* Sender)
{
	Start1->Caption = "Загрузка...";
	A_Delaunay = InitDelaunay("A", white);
    B_Delaunay = InitDelaunay("B", skyblue);
    F_Delaunay = InitDelaunay("F", lightyellow);
    G_Delaunay = InitDelaunay("G", yellow);
    K_Delaunay = InitDelaunay("K", orange);
    M_Delaunay = InitDelaunay("M", red);
    O_Delaunay = InitDelaunay("O", lightblue);

    A_Voronoi = InitVoronoi("A", white);
    B_Voronoi = InitVoronoi("B", skyblue);
    F_Voronoi = InitVoronoi("F", lightyellow);
    G_Voronoi = InitVoronoi("G", yellow);
    K_Voronoi = InitVoronoi("K", orange);
    M_Voronoi = InitVoronoi("M", red);
	O_Voronoi = InitVoronoi("O", lightblue);

	Start1->Caption = "Файлы загружены";
	Start1->Enabled = False;

    // Visualization
    InitDraw();
}
//---------------------------------------------------------------------------
void __fastcall TFormScene::clbSpectrasClickCheck(TObject* Sender)
{
    // Init draw method on each checkbox selecting
    InitDraw();
}
//---------------------------------------------------------------------------
void __fastcall TFormScene::Data1Click(TObject* Sender)
{
    FormTable->Show();
}
//---------------------------------------------------------------------------

void __fastcall TFormScene::ClassGroupClick(TObject* Sender)
{
    InitDraw();
}
//---------------------------------------------------------------------------

void __fastcall TFormScene::Panel2Click(TObject* Sender)
{
	ClassGroup->ItemIndex = ((TPanel*)(Sender))->Tag;
}
//---------------------------------------------------------------------------

void __fastcall TFormScene::clbMethodsClickCheck(TObject* Sender)
{
    GLPoints1->Free();
    GLPoints1 = (TGLPoints*)(GLDummyCube1->AddNewChild(__classid(TGLPoints)));
    GLLines1->Free();
    GLLines1 = (TGLLines*)(GLDummyCube1->AddNewChild(__classid(TGLLines)));
    GLLines2->Free();
    GLLines2 = (TGLLines*)(GLDummyCube1->AddNewChild(__classid(TGLLines)));
    VoxelDummy->Free();
    VoxelDummy =
        (TGLDummyCube*)(GLDummyCube1->AddNewChild(__classid(TGLDummyCube)));
    InitDraw();
}
//---------------------------------------------------------------------------