---

transfer.cpp

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


#pragma hdrstop

#include "transfer.h"

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

rgba TColor2RGBA(TColor c)
{
        rgba tmp;
        tmp.r = (unsigned char)(c&0xff);
        tmp.g = (unsigned char)((c&0xff00) >> 8);
        tmp.b = (unsigned char)((c&0xff0000) >> 16);
        return tmp;
}

rgb TColor2RGB(TColor c)
{
        rgb tmp;
        tmp.r = (unsigned char)(c&0xff);
        tmp.g = (unsigned char)((c&0xff00) >> 8);
        tmp.b = (unsigned char)((c&0xff0000) >> 16);
        return tmp;
}

TColor RGBA2TColor(rgba c)
{
        //return (TColor)(0x01000000+c.r+(c.g<<8)+(c.b<<16));
        return (TColor)(c.r+(c.g<<8)+(c.b<<16));
}

//---------------------------------------------------------------------------
// TLinePoint:
//---------------------------------------------------------------------------
const TLinePoint &TLinePoint::operator=(const TLinePoint &p)
{
        if (&p != this) {
                _x = p._x;
                _y = p._y;
                _c = p._c;
        }
        return *this;
}

//---------------------------------------------------------------------------
// TLine:
//---------------------------------------------------------------------------
void __fastcall TLine::_drawMarker(TCanvas *c, TColor col,
                                   int x, int y, int width)
{
        c->Pen->Color = col;
        c->Pen->Width = width;

        // Cross:
        c->MoveTo(x-2*_distPoint, y);
        c->LineTo(x+2*_distPoint, y);
        c->MoveTo(x, y-2*_distPoint);
        c->LineTo(x, y+2*_distPoint);

        // Rect:
        c->MoveTo(x-_distPoint, y-_distPoint);
        c->LineTo(x+_distPoint, y-_distPoint);
        c->LineTo(x+_distPoint, y+_distPoint);
        c->LineTo(x-_distPoint, y+_distPoint);
        c->LineTo(x-_distPoint, y-_distPoint);

        c->Pen->Width = 1;
}

void __fastcall TLine::_drawCross(TCanvas *c, TColor col, int x, int y)
{
        // Cross:
        c->MoveTo(x-(_distPoint>>1), y);
        c->LineTo(x+(_distPoint>>1), y);
        c->MoveTo(x, y-(_distPoint>>1));
        c->LineTo(x, y+(_distPoint>>1));
}

int __fastcall TLine::getStartX(TPaintBox *pb)
{
        return (int)((float)_start.X/_histo->getHPP(pb));
}

int __fastcall TLine::getStartY(TPaintBox *pb)
{
        return pb->Height-(int)((float)_start.Y/(float)0xff*pb->Height);
}

int __fastcall TLine::getEndX(TPaintBox *pb)
{
        return (int)((float)_end.X/_histo->getHPP(pb));
}

int __fastcall TLine::getEndY(TPaintBox *pb)
{
        return pb->Height-(int)((float)_end.Y/(float)0xff*pb->Height);
}

int __fastcall TLine::getY(TPaintBox *pb, int x)
{
        return getStartY(pb)+(int)((float)(x-getStartX(pb))*getSlope(pb));
}

int __fastcall TLine::getX(TPaintBox *pb, int y)
{
        return getStartX(pb)+(int)((float)(y-getStartY(pb))/getSlope(pb));
}

float __fastcall TLine::getSlope(TPaintBox *pb)
{
        return (float)(getEndY(pb)-getStartY(pb))/
               (float)(getEndX(pb)-getStartX(pb));
}

bool __fastcall TLine::highSlope(TPaintBox *pb)
{
        return (fabs(getSlope(pb)) > 1.0);
}

bool __fastcall TLine::isNear(TPaintBox *pb, int x, int y)
{
        int sx = getStartX(pb);
        int sy = getStartY(pb);
        int ex = getEndX(pb);
        int ey = getEndY(pb);
        int dx = ex - sx;
        int dy = ey - sy;
        if (dx == 0) {  // vertical line
                if ( ((ey>sy) && (y>ey || y<sy)) ||
                     ((ey<sy) && (y<ey || y>sy)) )
                        return false;
                else
                        return (DEF_DIST_SQR >= (sx-x)*(sx-x));
        } else if (dy == 0) {
                if (x<sx || x>ex)
                        return false;
                else
                        return (DEF_DIST_SQR >= ((sy-y)*(sy-y)));
        } else {
                float k = (float)dy/(float)dx;
                float absk = FABS(k);
                if ((absk < 1.0) && (x<sx || x>ex))
                        return false;
                else if ( (k >= 1.0) &&
                          ( ((ey>sy) && (y>ey || y<sy)) ||
                            ((ey<sy) && (y<ey || y<sy)) ) )
                        return false;
                else if (FABS(k) != 1.0) {
                        // TODO: Refine
                        float dg1 = (float)(sy - k*sx);
                        float dg2 = (float)y - (float)x/k;
                        float distx = ((k*dg2 - k*dg1)/(k*k - 1.0)) - (float)x;
                        float disty = ((k*k*dg2 - dg1) / ((k*k) - 1.0)) - (float)y;
                        return ((float)DEF_DIST_SQR >= (distx*distx+disty*disty));
                }
        }
        return false;
}

rgba __fastcall TLine::interpolate(float d)
{
        rgba tmp;
        tmp.r = _start.C.r + (int)((float)(_end.C.r-_start.C.r)*d);
        tmp.g = _start.C.g + (int)((float)(_end.C.g-_start.C.g)*d);
        tmp.b = _start.C.b + (int)((float)(_end.C.b-_start.C.b)*d);
        tmp.a = _start.C.a + (int)((float)(_end.C.a-_start.C.a)*d);
        return tmp;
}

void __fastcall TLine::drawTo(TPaintBox *pb)
{
        TCanvas *c = pb->Canvas;
        c->Pen->Color = _start.TC;
        int xs = getStartX(pb);
        int ys = getStartY(pb);
        int xe = getEndX(pb);
        int ye = getEndY(pb);
        int x = xs, y = ys;
        int dx = xe - xs;
        int dy = ye - ys;
        int sign;
        if (dy >= 0)    sign = 1;
        else            sign = -1;
        dy *= sign;
        int p = 2*dy - dy;
        //c->Pen->Color = _start.TC;
        c->Pixels[x][y] = _start.TC;
        if (dy==0) {                                    // horizontal line
                while(x < xe) {
                        x++;
                        c->Pixels[x][y] =
                                RGBA2TColor(interpolate((float)(x-xs)/
                                                        (float)dx));
                }
        } else if (dx==0) {                             // vertical line
                while(y != ye) {
                        y += sign;
                        c->Pixels[x][y] =
                                RGBA2TColor(interpolate((float)abs(y-ys)/
                                                        (float)abs(dy)));
                }
        } else if (fabs((float)dy/(float)dx) < 1.0) {   // more than 45°
                int twody = 2*dy;
                int twodydx = 2*(dy-dx);
                while(x < xe) {
                        x++;
                        if (p < 0) {
                                p += twody;
                        } else {
                                y += sign;
                                p += twodydx;
                        }
                        /*
                        c->Pen->Color =
                                RGBA2TColor(interpolate((float)(x-xs)/
                                                        (float)dx));
                        c->Pixels[x][y] = c->Pen->Color;
                        */
                        c->Pixels[x][y] = RGBA2TColor(interpolate((float)(x-xs)/
                                                      (float)dx));
                }
        } else {                                        // less than 45°
                int twody = 2*dx;
                int twodydx = 2*(dx-dy);
                while(y != ye) {
                        y += sign;
                        if (p < 0) {
                                p += twody;
                        } else {
                                x++;
                                p += twodydx;
                        }
                        /*
                        c->Pen->Color =
                                RGBA2TColor(interpolate((float)abs(y-ys)/
                                                           (float)abs(dy)));
                        c->Pixels[x][y] = c->Pen->Color;
                        */
                        c->Pixels[x][y] =
                                RGBA2TColor(interpolate((float)abs(y-ys)/
                                                        (float)abs(dy)));
                }
        }
        if (_selected) {
                if (_start.Selected)
                        _drawMarker(c, _start.TC, xs, ys, 2);
                else
                        _drawMarker(c, _start.TC, xs, ys, 1);
                if (_end.Selected)
                        _drawMarker(c, _end.TC, xe, ye, 2);
                else
                        _drawMarker(c, _end.TC, xe, ye, 1);
        } else {
                _drawCross(c, _start.TC, xs, ys);
                _drawCross(c, _end.TC, xe, ye);
        }
}

//---------------------------------------------------------------------------
// TTransfer:
//---------------------------------------------------------------------------
void TTransfer::_resize(int s)
{
        int newsize = _size+s;
        TLine **tmp = new TLine*[newsize];
        for(int i=0; i<newsize; ++i) tmp[i] = 0;
        if (_lines) {
                for(int i=0; i<_size; ++i) tmp[i] = _lines[i];
                delete [] _lines;
        }
        _lines = tmp;
        _size = newsize;
}

void TTransfer::_addLine(TLine *l)
{
        if (_fill >= _size) _resize(10);
        _lines[_fill] = l;
        _fill++;
}

void TTransfer::_insertLine(TLine *l, int pos)
{
        if (pos >= _fill) {
                _addLine(l);
        } else {
                if (_fill >= _size) _resize(10);
                // move the rest one back:
                for(int i=_fill; i>pos; --i)
                        _lines[i] = _lines[i-1];
                _lines[pos] = l;
                _fill++;
        }
}

int TTransfer::split(TPaintBox *pb, int x, int y)
{
        int idx = lineNear(pb, x, y);
        if (idx == -1) return -1;
        if (nearStart(idx, pb, x, y)) return -1;
        if (nearEnd(idx, pb, x, y)) return -1;
        int thex = (int)((float)x*_histo->getHPP(pb));
        int they = (int)((float)(pb->Height-y)/(float)pb->Height*(float)0xff);
        if (thex > _lines[idx]->End.X) thex = _lines[idx]->End.X; // Startpoint
                // x can not be bigger than endpoint x!
        TLinePoint n(thex, they, _lines[idx]->End.C);
        _insertLine(new TLine(n, _lines[idx]->End, _histo, _distPoint, _lines[idx]->Name), idx+1);
        _lines[idx]->End = n;
        select(idx);
        return idx;
}

void TTransfer::clear()
{
        for(int i=0; i<_fill; ++i) {
                delete _lines[i];
                _lines[i] = 0;
        }
        _fill = 0;
}

bool TTransfer::select(TPaintBox *pb, int x, int y)
{
        int idx = lineNear(pb, x, y);
        if (idx == -1) return false;
        else {
                unselect();
                _lines[idx]->Selected = true;
                return true;
        }
}

void TTransfer::select(int idx)
{
        unselect();
        if ((idx>-1) && (idx<_fill)) _lines[idx]->Selected = true;
}

void TTransfer::selectStart(int idx)
{
        unselect();
        if ((idx>-1) && (idx<_fill)) {
                _lines[idx]->Selected = true;
                _lines[idx]->Start.Selected = true;
        }
}

void TTransfer::selectEnd(int idx)
{
        unselect();
        if ((idx>-1) && (idx<_fill)) {
                _lines[idx]->Selected = true;
                _lines[idx]->End.Selected = true;
        }
}

void TTransfer::unselect()
{
        for(int i=0; i<_fill; ++i) {
                _lines[i]->Start.Selected = false;
                _lines[i]->End.Selected = false;
                _lines[i]->Selected = false;
        }
}

TLine *TTransfer::getSelected()
{
        int i = 0;
        bool found = false;
        while(i<_fill && !found) {
                found = _lines[i]->Selected;
                i++;
        }
        if (found)      return _lines[i-1];
        else            return 0;
}

int TTransfer::getSelIdx()
{
        int i = 0;
        bool found = false;
        while(i<_fill && !found) {
                found = _lines[i]->Selected;
                i++;
        }
        if (found) return i-1;
        else       return -1;
}

TLine *TTransfer::getLine(int idx)
{
        if (idx<0 || idx>_fill) return 0;
        return _lines[idx];
}

void TTransfer::drawTo(TPaintBox *pb)
{
        for(int i=0; i<_fill; ++i)
        {
                _lines[i]->drawTo(pb);
        }
}

int __fastcall TTransfer::lineNear(TPaintBox *pb, int x, int y)
{
        // TODO: Should find all lines!
        int i=0;
        //int xx = (int)((float)x * _histo->getHPP(pb));
        //int yy = (int)((pb->Height-y)/(float)pb->Height*(float)0xff);
        bool found = false;
        while (!found && i<_fill) {
                found = _lines[i++]->isNear(pb, x, y);
        }
        return found ? (i-1) : -1;
}

bool __fastcall TTransfer::nearStart(int idx, TPaintBox *pb, int x, int y)
{
        if (idx<0 ||idx>_fill) return false;
        int dx = abs(_lines[idx]->getStartX(pb) - x);
        int dy = abs(_lines[idx]->getStartY(pb) - y);
        return (dx<=_distPoint && dy<=_distPoint);
}

bool __fastcall TTransfer::nearEnd(int idx, TPaintBox *pb, int x, int y)
{
        if (idx<0 ||idx>_fill) return false;
        int dx = abs(_lines[idx]->getEndX(pb) - x);
        int dy = abs(_lines[idx]->getEndY(pb) - y);
        return (dx<=_distPoint && dy<=_distPoint);
}

rgba white = { 0xff, 0xff, 0xff, 0xff };

rgba __fastcall TTransfer::getColor(__int16 data)
{
        if (_setupTDataCache(data)) {
                return _TDataCache[data]->col;
        } else {
                return white;
        }
}

int __fastcall TTransfer::getName(double data)
{
    int i = 0;
    while(_lines[i]->End.X<=data && i<_fill) i++;
    if (i>_fill) return -1;
    return _lines[i]->Name;
}

TData TData_white = { { 0xff, 0xff, 0xff, 0xff }, 0 };

/*
TData __fastcall TTransfer::getData(__int16 data)
{
        if (_setupTDataCache(data)) {
                return *_TDataCache[data];
        } else {
                return TData_white;
        }
}
*/

TData __fastcall TTransfer::getData(double data)
{
    int i = 0;
    while(_lines[i]->End.X<=data && i<_fill) i++;
    if (i>_fill) return TData_white;
    int xs = _lines[i]->Start.X;
    int dx = _lines[i]->End.X - xs;
    int ys = _lines[i]->Start.Y;
    int dy = _lines[i]->End.Y - ys;
    double d = (double)dy/(double)dx;
    TData res;
    res.col = _lines[i]->interpolate((float)(data-xs)/(float)dx);
    res.alpha = ((double)ys+((double)(data-xs)*d))/255.0;
    res.name = _lines[i]->Name;
    return res;
}

bool TTransfer::loadFromXLM(_di_IXMLNode doc)
{
        // Names:
        _di_IXMLNode names = doc->ChildNodes->Nodes[OleVariant(AnsiString(XML_NODE_NAMES))];
        _di_IXMLNodeList nlist = names->ChildNodes;
        WideString wsCount = names->Attributes[XML_ATTRIB_COUNT];
        if (wsCount.IsEmpty()) {
                ShowMessage(AnsiString("No '")
                            + XML_ATTRIB_COUNT
                            + "' attribute in '"
                            + XML_NODE_NAMES
                            + "'!");
                return false;
        }
        int count = AnsiString((BSTR)wsCount).ToInt();
        _areaNames->Clear();
        for(int i = 0; i<count; ++i) {
                _di_IXMLNode n = nlist->GetNode(AnsiString(XML_NODE_NAME)+AnsiString(i));
                // TODO: Make ist robust!
                _areaNames->Add(n->Text);
        }

        // Lines:
        _di_IXMLNode lines = doc->ChildNodes->Nodes[OleVariant(AnsiString(XML_NODE_LINES))];
        _di_IXMLNodeList llist = lines->ChildNodes;
        WideString wsTmp = lines->Attributes[XML_ATTRIB_COUNT];
        if (wsTmp.IsEmpty()) {
                ShowMessage(AnsiString("No '")
                            + XML_ATTRIB_COUNT
                            + "' attribute in the '"
                            + XML_NODE_LINES
                            + "'!");
                return false;
        }
        count = AnsiString((BSTR)wsTmp).ToInt();
        clear();
        _cleanTDataCache();
        for(int i = 0; i<count; ++i) {
                _di_IXMLNode l = llist->Nodes[OleVariant(AnsiString(XML_NODE_LINE)+AnsiString(i))];
                int name = AnsiString(l->Attributes[XML_ATTRIB_LINE_NAME]).ToInt();
                // Getting start point:
                _di_IXMLNode ep = l->ChildNodes->Nodes[OleVariant(AnsiString(XML_NODE_LINE_START))];
                int x = AnsiString(ep->Attributes[XML_ATTRIB_LINE_X]).ToInt();
                int y = AnsiString(ep->Attributes[XML_ATTRIB_LINE_Y]).ToInt();
                rgba col;
                col.r = AnsiString(ep->Attributes[XML_ATTRIB_LINE_R]).ToInt();
                col.g = AnsiString(ep->Attributes[XML_ATTRIB_LINE_G]).ToInt();
                col.b = AnsiString(ep->Attributes[XML_ATTRIB_LINE_B]).ToInt();
                col.a = AnsiString(ep->Attributes[XML_ATTRIB_LINE_A]).ToInt();
                TLinePoint s(x, y, col);
                // Getting end point:
                ep = l->ChildNodes->Nodes[OleVariant(AnsiString(XML_NODE_LINE_END))];
                x = AnsiString(ep->Attributes[XML_ATTRIB_LINE_X]).ToInt();
                y = AnsiString(ep->Attributes[XML_ATTRIB_LINE_Y]).ToInt();
                col.r = AnsiString(ep->Attributes[XML_ATTRIB_LINE_R]).ToInt();
                col.g = AnsiString(ep->Attributes[XML_ATTRIB_LINE_G]).ToInt();
                col.b = AnsiString(ep->Attributes[XML_ATTRIB_LINE_B]).ToInt();
                col.a = AnsiString(ep->Attributes[XML_ATTRIB_LINE_A]).ToInt();
                TLinePoint e(x, y, col);
                _addLine(new TLine(s, e, _histo, DEF_POINT_DIST, name));
        }
        return true;
}


bool TTransfer::saveToXML(_di_IXMLNode doc)
{
        _di_IXMLNode names = doc->AddChild("Names");
        names->SetAttribute("Count", AnsiString(_areaNames->Count));
        for(int i=0; i<_areaNames->Count; ++i) {
                _di_IXMLNode n = names->AddChild("Name"+AnsiString(i));
                n->Text = _areaNames->Strings[i];
        }

        _di_IXMLNode lines = doc->AddChild(XML_NODE_LINES);
        lines->SetAttribute(XML_ATTRIB_COUNT, AnsiString(_fill));
        for(int i=0; i<_fill; ++i) {
                _di_IXMLNode node = lines->AddChild(XML_NODE_LINE+AnsiString(i));
                // Start:
                node->SetAttribute(XML_ATTRIB_LINE_NAME, AnsiString(_lines[i]->Name));
                _di_IXMLNode ep = node->AddChild(XML_NODE_LINE_START);
                ep->SetAttribute(XML_ATTRIB_LINE_X, AnsiString(_lines[i]->Start.X));
                ep->SetAttribute(XML_ATTRIB_LINE_Y, AnsiString(_lines[i]->Start.Y));
                ep->SetAttribute(XML_ATTRIB_LINE_R, AnsiString(_lines[i]->Start.C.r));
                ep->SetAttribute(XML_ATTRIB_LINE_G, AnsiString(_lines[i]->Start.C.g));
                ep->SetAttribute(XML_ATTRIB_LINE_B, AnsiString(_lines[i]->Start.C.b));
                ep->SetAttribute(XML_ATTRIB_LINE_A, AnsiString(_lines[i]->Start.C.a));
                // End:
                ep = node->AddChild(XML_NODE_LINE_END);
                ep->SetAttribute(XML_ATTRIB_LINE_X, AnsiString(_lines[i]->End.X));
                ep->SetAttribute(XML_ATTRIB_LINE_Y, AnsiString(_lines[i]->End.Y));
                ep->SetAttribute(XML_ATTRIB_LINE_R, AnsiString(_lines[i]->End.C.r));
                ep->SetAttribute(XML_ATTRIB_LINE_G, AnsiString(_lines[i]->End.C.g));
                ep->SetAttribute(XML_ATTRIB_LINE_B, AnsiString(_lines[i]->End.C.b));
                ep->SetAttribute(XML_ATTRIB_LINE_A, AnsiString(_lines[i]->End.C.a));
        }
        return true;
}


int TTransfer::addName(AnsiString &name)
{
        _areaNames->Add(name);
        return _areaNames->Count;
}


#pragma package(smart_init)

---