treeviewclasses.cpp

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

        {
            LineList->Insert(0,Field);
        }

        index = 0;

        for (i=0;i<LineList->Count;i++)
        {
            if (IsData[i] == true)
            {
                try
                {
                    Weight = (LineList->Strings[i]).ToDouble();
                    ArrayTreeNode = (TArrayTreeNode *) Arrays->Objects[index];
                    ArrayTreeNode->Weight = Weight;
                }
                catch (EConvertError &E)
                {
                }
                index ++;
            }
        }


        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();

            ArrayTreeNode = new TArrayTreeNode();
            ArrayTreeNode->IsNode = true;

            if (Child1.SubString(1,4) == "NODE")
            {
                ArrayTreeNode->Child1 = (TArrayTreeNode *) ArrayNodes->Objects[nGID1-1];
            }
            else
            {
                ArrayTreeNode->Child1 = (TArrayTreeNode *) Arrays->Objects[ArrayListIndex[nGID1]];
            }

            if (Child2.SubString(1,4) == "NODE")
            {
                ArrayTreeNode->Child2 = (TArrayTreeNode *) ArrayNodes->Objects[nGID2-1];
            }
            else
            {
                ArrayTreeNode->Child2 = (TArrayTreeNode *) Arrays->Objects[ArrayListIndex[nGID2]];
            }

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

            ArrayTreeNode->Corr = Corr;

            index = ArrayNodes->Add(NodeID);
            ArrayNodes->Objects[index] = ArrayTreeNode;
            ArrayTreeNode->Data = new TArrayData();
            ArrayTreeNode->Data->ID = NodeID;

        }

        TopArrayNode = ArrayTreeNode;
        TopArrayNode->SetParent(NULL);

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

        //Nodes->Clear();

        delete TreeFileList;
        delete ArrayListIndex;

    }

    
    Loaded = true;

    delete ListIndex;
    delete DataFileList;
    delete LineList;
    delete IsData;

    return (sqrt(Sum2/DCount));
}

__fastcall TGeneData::TGeneData() : TObject()
{
}

__fastcall TGeneData::TGeneData(int nCols) : TObject()
{

    Columns = nCols;

    try
    {
        fMask = new bool[nCols];
        fData = new double[nCols];
    }
    catch (EAccessViolation &E)
    {
    }
}

__fastcall TGeneData::~TGeneData()
{
    delete fMask;
    delete fData;
}

void __fastcall TGeneCluster::MakeThumbnail(TImage *Image,
            double ScaleX, double ScaleY, double Contrast, double MaskVal,
            TColor PositiveColor, TColor ZeroColor, TColor NegativeColor,
            TColor MissingColor)
{
    int i,j,k;

    TRect Rect;

    if (Bitmap != NULL)
    {
        delete Bitmap;
    }

    Bitmap = new Graphics::TBitmap();

    Bitmap->Height = Rows;
    Bitmap->Width  = Columns;
    Bitmap->PixelFormat = 6;

    unsigned char *ScanLine;

    unsigned char *Color;
    Color = new unsigned char[3];

    DWORD DPositiveColor = ColorToRGB(PositiveColor);
    unsigned char *Positive;
    //Positive = new unsigned char[3];
    Positive = (unsigned char *)&DPositiveColor;

    DWORD DZeroColor = ColorToRGB(ZeroColor);
    unsigned char *Zero;
    //Zero = new unsigned char[3];
    Zero = (unsigned char *)&DZeroColor;

    DWORD DNegativeColor = ColorToRGB(NegativeColor);
    unsigned char *Negative;
    //Negative = new unsigned char[3];
    Negative = (unsigned char *)&DNegativeColor;

    DWORD DMissingColor = ColorToRGB(MissingColor);
    unsigned char *Missing;
    //Missing = new unsigned char[3];
    Missing = (unsigned char *)&DMissingColor;

    double Factor;

    TGeneTreeNode *GeneTreeNode;

    for (i=0;i<Genes->Count;i++)
    {
        ScanLine = (unsigned char *) Bitmap->ScanLine[i];
        GeneTreeNode = (TGeneTreeNode *) Genes->Objects[i];

        if ( (GeneTreeNode->Data->ID == "NULL") || (GeneTreeNode->Data->ID == "NONE") )
        {
           for (j=0;j<Columns;j++)
           {
                ScanLine[3*j]   = 255;      //Blue
                ScanLine[3*j+1] = 255;    //Green
                ScanLine[3*j+2] = 255;  //Red
           }
        }
        else
        {
        for (j=0;j<Columns;j++)
        {
            if (GeneTreeNode->Data->Mask[j] == true)
            {
                if (GeneTreeNode->Data->Data[j] >= MaskVal)
                {
                    Factor =  min(1.0, GeneTreeNode->Data->Data[j] / Contrast);
                    for (k=0;k<3;k++)
                    {
                        Color[k] =  Factor * Positive[k] + (1.0 - Factor) * Zero[k];
                    }
                }
                else if (GeneTreeNode->Data->Data[j] <= -MaskVal)
                {
                    Factor =  min(1.0, -GeneTreeNode->Data->Data[j] / Contrast);
                    for (k=0;k<3;k++)
                    {
                        Color[k] =  Factor * Negative[k] + (1.0 - Factor) * Zero[k];
                    }
                }
                else
                {
                    Color[0] = 0;
                    Color[1] = 0;
                    Color[2] = 0;
                }

                ScanLine[3*j] = Color[2];      //Blue
                ScanLine[3*j+1] = Color[1];    //Green
                ScanLine[3*j+2] = Color[0];  //Red
            }
            else
            {
                ScanLine[3*j] = Missing[2];      //Blue
                ScanLine[3*j+1] = Missing[1];    //Green
                ScanLine[3*j+2] = Missing[0];  //Red
            }
        }
        }
    }

    /*

    unsigned char *ScanLine;

    TGeneTreeNode *GeneTreeNode;

    for (i=0;i<Genes->Count;i++)
    {
        ScanLine = (unsigned char *) Bitmap->ScanLine[i];

        for (j=0;j<Columns;j++)
        {
            Red = 0;
            Green = 0;
            Blue = 0;

            GeneTreeNode = (TGeneTreeNode *) Genes->Objects[i];

            if (GeneTreeNode->Data->Mask[j] == true)
            {
                if (GeneTreeNode->Data->Data[j] > 0)
                {
                    Red = max(0,min(255,(int) (256.0 * GeneTreeNode->Data->Data[j] / Contrast)));
                }
                else
                {
                    Green = max(0,min(255,(int) (-256.0 * GeneTreeNode->Data->Data[j] / Contrast)));
                }
            }
            else
            {
                Red = 100;
                Green = 100;
                Blue = 100;
            }


            ScanLine[3*j] = Blue;      //Blue
            ScanLine[3*j+1] = Green;    //Green
            ScanLine[3*j+2] = Red;  //Red
	    }
    }       */

    Image->Width  = Columns * ScaleX;
    Image->Height = Rows    * ScaleY;
    Image->Picture->Bitmap = Bitmap;

    delete Color;


}
__fastcall TArrayTreeNode::TArrayTreeNode() : TObject()
{
    IsNode = true;
    Color = clBlack;
    Child1 = NULL;
    Child2 = NULL;
}

__fastcall TArrayTreeNode::~TArrayTreeNode()
{
    delete Data;
}

void __fastcall TArrayTreeNode::SetParent(TArrayTreeNode *pParent)
{
    Parent = pParent;
    if (IsNode == true)
    {
        Child1->SetParent(this);
        Child2->SetParent(this);
    }
    else
    {
        Child1 = NULL;
        Child2 = NULL;
    }
}

void __fastcall TArrayTreeNode::SetCoor()
{
    if (IsNode == true)
    {
        Child1->SetCoor();
        Child2->SetCoor();

        YCoor = 1.0 - ((1.0 - Corr)/2);
        YCoor = min(YCoor, Child1->YCoor);
        YCoor = min(YCoor, Child2->YCoor);
        XCoor = (Child1->XCoor + Child2->XCoor)/2;

        MinCoor = min(Child1->MinCoor,Child2->MinCoor);
        MaxCoor = max(Child1->MaxCoor,Child2->MaxCoor);
    }
    else
    {
        YCoor = 1.0;
        MinCoor = XCoor;
        MaxCoor = XCoor;
    }
}

void __fastcall TArrayTreeNode::Draw(TImage *Image, double Scale)
{

    if (IsNode == true)
    {
        Image->Canvas->MoveTo(Scale/2 + Child1->XCoor * Scale, Child1->YCoor*Image->Height);
        Image->Canvas->LineTo(Scale/2 + Child1->XCoor * Scale, YCoor*Image->Height);
        Image->Canvas->LineTo(Scale/2 + Child2->XCoor * Scale, YCoor*Image->Height);
        Image->Canvas->LineTo(Scale/2 + Child2->XCoor * Scale, Child2->YCoor*Image->Height);

        Child1->Draw(Image, Scale);
        Child2->Draw(Image, Scale);

        YPoint = YCoor * Image->Height;
        XPoint = XCoor * Scale;
    }
}

void __fastcall TArrayTreeNode::DrawPS(TStringList *PSFile, int XScale, int YScale, int XOrigin, int YOrigin)
{
    if (IsNode == true)
    {
        AnsiString TempString;
        int X1,Y1,X2,Y2;

        X1 = XOrigin + (XScale/2) + Child1->XCoor*XScale;
        Y1 = YOrigin + (1.0 - Child1->YCoor) * YScale;
        X2 = XOrigin + (XScale/2) + Child1->XCoor*XScale;
        Y2 = YOrigin + (1.0 - YCoor) * YScale;

        TempString = AnsiString(X1) + " " + AnsiString(Y1) + " " +
            AnsiString(X2) + " " + AnsiString(Y2) + " ln";

        PSFile->Add(TempString);

        X1 = XOrigin + (XScale/2) + Child2->XCoor*XScale;
        Y1 = YOrigin + (1.0 - Child2->YCoor) * YScale;
        X2 = XOrigin + (XScale/2) + Child2->XCoor*XScale;
        Y2 = YOrigin + (1.0 - YCoor) * YScale;

        TempString = AnsiString(X1) + " " + AnsiString(Y1) + " " +
            AnsiString(X2) + " " + AnsiString(Y2) + " ln";

        PSFile->Add(TempString);

        X1 = XOrigin + (XScale/2) + Child1->XCoor*XScale;
        Y1 = YOrigin + (1.0 - YCoor) * YScale;
        X2 = XOrigin + (XScale/2) + Child2->XCoor*XScale;
        Y2 = YOrigin + (1.0 - YCoor) * YScale;

        TempString = AnsiString(X1) + " " + AnsiString(Y1) + " " +
            AnsiString(X2) + " " + AnsiString(Y2) + " ln";

        PSFile->Add(TempString);

        Child1->DrawPS(PSFile, XScale, YScale, XOrigin, YOrigin);
        Child2->DrawPS(PSFile, XScale, YScale, XOrigin, YOrigin);
    }
}

__fastcall TArrayData::TArrayData() : TObject()
{
}

__fastcall TArrayData::~TArrayData()
{
}

void __fastcall TGeneTreeNode::MakeBarcode(TImage *Image, int ScaleX, int ScaleY,
            double Contrast, TColor PositiveColor, TColor ZeroColor, TColor NegativeColor,
            TColor MissingColor)
{

    int i,j,k;
    unsigned char *Color;
    Color = new unsigned char[3];

    DWORD DPositiveColor = ColorToRGB(PositiveColor);
    unsigned char *Positive;
    //Positive = new unsigned char[3];
    Positive = (unsigned char *)&DPositiveColor;

    DWORD DZeroColor = ColorToRGB(ZeroColor);
    unsigned char *Zero;
    //Zero = new unsigned char[3];
    Zero = (unsigned char *)&DZeroColor;

    DWORD DNegativeColor = ColorToRGB(NegativeColor);
    unsigned char *Negative;
    //Negative = new unsigned char[3];
    Negative = (unsigned char *)&DNegativeColor;

    DWORD DMissingColor = ColorToRGB(MissingColor);
    unsigned char *Missing;
    //Missing = new unsigned char[3];
    Missing = (unsigned char *)&DMissingColor;

    double Factor;

    TRect Rect;
    Rect.Top = 0;
    Rect.Bottom = ScaleY;

    Image->Canvas->Pen->Style = psClear;
    Image->Canvas->Brush->Style = bsSolid;

    for (j=0;j<Data->Columns;j++)
    {
        Color[0] = Missing[0];
        Color[1] = Missing[1];
        Color[2] = Missing[2];

        if (Data->Mask[j] == true)
        {
            if (Data->Data[j] > 0)
            {
                Factor =  min(1.0, Data->Data[j] / Contrast);
                for (k=0;k<3;k++)
                {
                    Color[k] =  Factor * Positive[k] + (1.0 - Factor) * Zero[k];
                }
            }
            else
            {
                Factor =  min(1.0, -Data->Data[j] / Contrast);
                for (k=0;k<3;k++)
                {
                    Color[k] =  Factor * Negative[k] + (1.0 - Factor) * Zero[k];
                }
            }
        }

        Image->Canvas->Brush->Color = RGB(Color[0],Color[1],Color[2]);

        Rect.Left = j * ScaleX;
        Rect.Right = (j + 1) * ScaleX;

        Image->Canvas->FillRect(Rect);
    }

    delete Color;
}