treeviewclasses.cpp

著名的基因芯片表达数据聚类软件。esein编写

                *Includes = true;
                Best = this;
            }

        }

        return Best;
}

void __fastcall TGeneTreeNode::SaveData(TStringList *FileList, double LowCut,
     double HighCut, int MinElems, bool SaveChildren, bool SaveList)
{
     if ( (Corr >= LowCut) && (Corr <= HighCut) && (Elements > MinElems) )
     {
        int i,j;
        AnsiString Line =
                Data->ID + "\t" + Data->ID + " " + AnsiString(Corr) + " " + AnsiString(Elements);
                for (j=0;j<Data->Columns;j++)
                {
                    Line += "\t";
                    if (Data->Mask[j])
                    {
                        Line += AnsiString(Data->Data[j]);
                    }
                }
        FileList->Add(Line);

        if (SaveChildren && IsNode)
        {
           Child1->SaveData(FileList,LowCut,HighCut, MinElems,SaveChildren,SaveList);
           Child2->SaveData(FileList,LowCut,HighCut, MinElems,SaveChildren,SaveList);
        }

        if (SaveList)
        {
           TStringList *GeneList = new TStringList();
           GetList(GeneList);
           AnsiString ListFileName = Data->ID + ".lst";
           GeneList->SaveToFile(ListFileName);
           delete GeneList;
        }

     }
     else if (IsNode)
     {
        Child1->SaveData(FileList,LowCut,HighCut,MinElems,SaveChildren,SaveList);
        Child2->SaveData(FileList,LowCut,HighCut,MinElems,SaveChildren,SaveList);
     }
}

void __fastcall TGeneTreeNode::GetList(TStringList *List)
{
     if (IsNode)
     {
        Child1->GetList(List);
        Child2->GetList(List);
     }
     else
     {
        List->Add(Data->ID);
     }
}

__fastcall TGeneCluster::TGeneCluster() : TObject()
{
    Arrays = new TStringList();
    Genes = new TStringList();
    Nodes = new TStringList();
    ArrayNodes = new TStringList();
    GeneNames = new TStringList();
    Loaded = false;

    Columns = 0;
}

__fastcall TGeneCluster::~TGeneCluster()
{
    int i;
    delete Bitmap;
    delete Arrays;
    for (i=0; i<Genes->Count;i++)
    {
        delete (TGeneTreeNode *)Genes->Objects[i];
    }
    delete Genes;

    for (i=0; i<Nodes->Count;i++)
    {
        delete (TGeneTreeNode *)Nodes->Objects[i];
    }
    delete Nodes;

    for (i=0; i<ArrayNodes->Count;i++)
    {
        delete (TArrayTreeNode *)ArrayNodes->Objects[i];
    }
    delete ArrayNodes;
}

void __fastcall TGeneCluster::Dist(int X, int Y)
{
    BestNode = TopNode->Dist(X,Y,&BestDist);
    BestNode->Limits(&MinCoor,&MaxCoor);
}

void __fastcall TGeneCluster::Include(int X, int Y)
{
    bool Includes;
    if (TopNode != NULL)
    {
        BestNode = TopNode->Include(X,Y,&Includes);
        BestNode->Limits(&MinCoor,&MaxCoor);
    }
    else
    {
        MinCoor = X;
        MaxCoor = Y;
    }
}

double __fastcall TGeneCluster::Load
(AnsiString DataFile)
{
    TStringList *DataFileList = new TStringList();

    char Extension[5];
    char FileName[256];

    fnsplit(DataFile.c_str(),NULL,NULL,FileName,Extension);

    DataFileList->LoadFromFile(DataFile);

    bool LoadGeneTree;

    AnsiString GeneTreeFile  = AnsiString(FileName) + ".gtr";
    AnsiString ArrayTreeFile = AnsiString(FileName) + ".atr";

    AnsiString Line;
    AnsiString Field;

    int i,j;

    TStringList *Headers = new TStringList();
    bool *IsData;

    long double Sum = 0;
    long double Sum2 = 0;
    double DCount = 0;

    // Remove Comment Lines

    for (i=DataFileList->Count-1;i>=0;i--)
    {
        if (DataFileList->Strings[i].SubString(1,6) == "REMARK")
        {
            DataFileList->Delete(i);
        }
        if (DataFileList->Strings[i].Length() < 3)
        {
            DataFileList->Delete(i);
        }
    }

    // Parse First Line

    Line = DataFileList->Strings[0];
    DataFileList->Delete(0);

    while ((Field = NextString(&Line)) != "DONE")
    {
        Headers->Insert(0,Field);
    }

    
    IsData = new bool [Headers->Count];

    for (i=0;i<Headers->Count;i++)
    {
        IsData[i] = true;
    }

    int GIDIndex = Headers->IndexOf("GID");
    int UniqueIDIndex;

    if (GIDIndex > -1)
    {
        LoadGeneTree = true;
        UniqueIDIndex = GIDIndex + 1;
        IsData[GIDIndex] = false;
    }
    else
    {
        LoadGeneTree = false;
        UniqueIDIndex = 0;
    }

    UniqueID = Headers->Strings[UniqueIDIndex];
    IsData[UniqueIDIndex] = false;

    int NameIndex = Headers->IndexOf("NAME");

    if (NameIndex > -1)
    {
        IsData[NameIndex] = false;
    }

    int GeneWeightIndex = Headers->IndexOf("GWEIGHT");

    if (GeneWeightIndex > -1)
    {
        IsData[GeneWeightIndex] = false;
    }

    for (i=0;i<Headers->Count;i++)
    {
        if (IsData[i] == true)
        {
            Columns++;
            Arrays->Add(Headers->Strings[i]);
        }
    }

    ListIndex = new long[DataFileList->Count * 2];
    TGeneTreeNode *GeneTreeNode;
    AnsiString GID, ID, Name;
    int index;
    int nGID;
    bool LoadArrayTree = false;
    AnsiString ArrayHeaderString;
    AnsiString ArrayWeightString;
    double Weight;

    TStringList *LineList = new TStringList();

    i=0;
    Rows = 0;

    while (DataFileList->Count > 0)
    {
        Line = DataFileList->Strings[0];
        LineList->Clear();
        while ((Field = NextString(&Line)) != "DONE")
        {
            LineList->Insert(0,Field);
        }

        if (LineList->Strings[0] == "AID")
        {
            LoadArrayTree = true;
            ArrayHeaderString = DataFileList->Strings[0];
        }
        else if (LineList->Strings[0] == "EWEIGHT")
        {
            ArrayWeightString = DataFileList->Strings[0];
        }
        else
        {
            GID = "";
            if ( (GIDIndex > -1) && (GIDIndex < LineList->Count) )
            {
                GID = LineList->Strings[GIDIndex];
            }

            Name = "";
            if ( (NameIndex > -1) && (NameIndex < LineList->Count) )
            {
                Name = LineList->Strings[NameIndex];
                for (int Pos=Name.Length();Pos>=0;Pos--)
                {
                    if (Name.SubString(Pos,1) == "\"")
                    {
                       Name.Delete(Pos,1);
                    }
                }
            }

            ID = "";
            if ( (UniqueIDIndex > -1) && (UniqueIDIndex < LineList->Count) )
            {
                ID = LineList->Strings[UniqueIDIndex];
            }

            Weight = 1.0;
            if ( (GeneWeightIndex > -1) && (GeneWeightIndex < LineList->Count) )
            {
                try
                {
                    Weight = (LineList->Strings[GeneWeightIndex]).ToDouble();
                }
                catch (EConvertError &E)
                {
                    Weight = 1.0;
                }
            }

            index = Genes->Add(ID);

            if (LoadGeneTree == true)
            {
                try
                {
                    nGID =  (GID.SubString(5,GID.Length()-5)).ToInt();
                    ListIndex[nGID] = index;
                }
                catch (EConvertError &E)
                {
                }
            }

            Genes->Objects[index]    = new TGeneTreeNode();
            GeneNames->Add(Name);
            GeneTreeNode             = (TGeneTreeNode *) Genes->Objects[index];
            GeneTreeNode->Data       = new TGeneData(Columns);
            GeneTreeNode->IsNode     = false;
            GeneTreeNode->Corr       = 1.0;
            GeneTreeNode->Weight     = Weight;
            GeneTreeNode->Data->ID   = ID;
            GeneTreeNode->Data->Name = Name;

            index = 0;

            for (j=0;j<min(LineList->Count,Headers->Count);j++)
            {
                if (IsData[j] == true)
                {
                    try
                    {
                        double Val = LineList->Strings[j].ToDouble();
                        GeneTreeNode->Data->Data[index] = Val;
                        GeneTreeNode->Data->Mask[index] = true;
                        Sum += Val;
                        Sum2 += pow(Val,2.0);
                        DCount += 1.0;
                    }
                    catch (EConvertError &E)
                    {
                        GeneTreeNode->Data->Mask[index] = false;
                    }
                    index++;
                }
            }

            /* Handle case where there are too few lines */
            for (j=index; j<Columns;j++)
            {
                GeneTreeNode->Data->Mask[j] = false;
            }

            i++;
            Rows++;
        }
        DataFileList->Delete(0);
    }


    for (i=0;i<Genes->Count;i++)
    {
        ((TGeneTreeNode *)Genes->Objects[i])->YCoor = i;
    }

    if (LoadGeneTree == true)
    {

        TStringList *TreeFileList = new TStringList();
        TreeFileList->LoadFromFile(GeneTreeFile);

        if (TreeFileList->Count == 0)
        {
            ShowMessage("Could Not Load Gene Tree File");
        }
        else
        {
        AnsiString NodeID, Child1, Child2;
        double Corr;

        int nGID1,nGID2;

        for (i=0;i<TreeFileList->Count;i++)
        {
            Line = TreeFileList->Strings[i];

            LineList->Clear();

            while ((Field = NextString(&Line)) != "DONE")
            {
                LineList->Insert(0,Field);
            }

            NodeID = LineList->Strings[0];
            Child1 = LineList->Strings[1];
            Child2 = LineList->Strings[2];
            Corr   = LineList->Strings[3].ToDouble();

            nGID1 =  (Child1.SubString(5,Child1.Length()-5)).ToInt();
            nGID2 =  (Child2.SubString(5,Child2.Length()-5)).ToInt();

            GeneTreeNode = new TGeneTreeNode();
            GeneTreeNode->IsNode = true;

            if (Child1.SubString(1,4) == "NODE")
            {
                GeneTreeNode->Child1 = (TGeneTreeNode *) Nodes->Objects[nGID1-1];
            }
            else
            {
                GeneTreeNode->Child1 = (TGeneTreeNode *) Genes->Objects[ListIndex[nGID1]];
            }

            if (Child2.SubString(1,4) == "NODE")
            {
                GeneTreeNode->Child2 = (TGeneTreeNode *) Nodes->Objects[nGID2-1];
            }
            else
            {
                GeneTreeNode->Child2 = (TGeneTreeNode *) Genes->Objects[ListIndex[nGID2]];
            }

            if ( (GeneTreeNode->Child1 == NULL) || (GeneTreeNode->Child2 == NULL) )
            {
                GeneTreeNode->IsNode = false;
            }

            GeneTreeNode->Corr = Corr;
            index = Nodes->Add(NodeID);
            Nodes->Objects[index]  = GeneTreeNode;
            GeneTreeNode->Data     = new TGeneData(Columns);
            GeneTreeNode->Data->ID = NodeID;

        }

        TopNode = GeneTreeNode;
        TopNode->SetParent(NULL);
        TopNode->SetData();

        //Nodes->Clear();
        }

        delete TreeFileList;
    }
    else
    {
        TopNode = NULL;
    }

    if (LoadArrayTree == true)
    {

        TStringList *TreeFileList = new TStringList();
        TreeFileList->LoadFromFile(ArrayTreeFile);

        TArrayTreeNode *ArrayTreeNode;
        long *ArrayListIndex = new long[Columns];

        LineList->Clear();

        while ((Field = NextString(&ArrayHeaderString)) != "DONE")
        {
            LineList->Insert(0,Field);
        }

        index = 0;

        for (i=0;i<LineList->Count;i++)
        {
            if (IsData[i] == true)
            {
                ID = LineList->Strings[i];
                Arrays->Objects[index] = new TArrayTreeNode();
                ArrayTreeNode = (TArrayTreeNode *) Arrays->Objects[index];

                nGID =  (ID.SubString(5,ID.Length()-5)).ToInt();
                ArrayListIndex[nGID] = index;

                ArrayTreeNode->Data = new TArrayData();
                ArrayTreeNode->IsNode = false;
                ArrayTreeNode->Corr = 1.0;
                ArrayTreeNode->Weight = 1.0;
                ArrayTreeNode->Data->ID = ID;
                ArrayTreeNode->Data->Name = "";

                index++;
            }
        }

        LineList->Clear();

        while ((Field = NextString(&ArrayWeightString)) != "DONE")