---

transfer.h

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

#ifndef transferH
#define transferH

#include <list>
#include <string>
#include <Classes.hpp>
#include <Controls.hpp>
#include <ExtCtrls.hpp>
#include <Types.hpp>
#include <XMLDoc.hpp>
#include <Dialogs.hpp>
#include "histo.h"
#include "data.h"
#include "xmltags.h"

// History range:
#define HSIZE           4096

#define DEF_DIST        5

#define DEF_DIST_SQR    25
#define DEF_POINT_DIST  2*DEF_DIST

#define FABS(a)         ((a)<0.0 ? (a)*-1.0 : (a))

struct TData {
        rgba col;
        int name;
        double alpha;
};

rgba TColor2RGBA(TColor c);

TColor RGBA2TColor(rgba c);

rgb TColor2RGB(TColor c);

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

class TLinePoint
{

        private:

                int _x;
                int _y;
                rgba _c;
                bool _selected;

                TColor _getTColor() { return RGBA2TColor(_c); }
                void _setTColor(TColor c) { _c = TColor2RGBA(c); }


        public:

                TLinePoint(const TLinePoint &p)
                : _x(p._x),
                  _y(p._y),
                  _c(p._c),
                  _selected(false)
                {}

                TLinePoint(int x, int y)
                : _x(x),
                  _y(y),
                  _c(TColor2RGBA(clBlack)),
                  _selected(false)
                {}

                TLinePoint(int x, int y, const TColor &c)
                : _x(x),
                  _y(y),
                  _c(TColor2RGBA(c)),
                  _selected(false)
                {}

                TLinePoint(int x, int y, const rgba &c)
                : _x(x),
                  _y(y),
                  _c(c)
                {}

                const TLinePoint &operator=(const TLinePoint &p);


                __property int X = { read=_x, write=_x };
                __property int Y = { read=_y, write=_y };
                __property rgba C = { read=_c, write=_c };
                __property TColor TC = { read=_getTColor, write=_setTColor };
                __property bool Selected = { read=_selected, write=_selected };

};

class TLine
{

        private:

                TLinePoint _start;
                TLinePoint _end;
                bool _selected;
                int _name;

                THistogram *_histo;
                int _distPoint; // Distance from cursor to a line end point

                void __fastcall _drawMarker(TCanvas *c, TColor col,
                                            int x, int y, int width);
                void __fastcall _drawCross(TCanvas *c, TColor col,
                                           int x, int y);

        public:

                TLine(TLinePoint s, TLinePoint e,
                      THistogram *h, int pd, int name)
                : _start(s),
                  _end(e),
                  _histo(h),
                  _distPoint(pd),
                  _name(name)
                {}

                TLine(TLine &l)
                : _start(l._start),
                  _end(l._end),
                  _histo(l._histo),
                  _distPoint(l._distPoint),
                  _name(l._name)
                {}

                TLine(const TLine &l)
                : _start(l._start),
                  _end(l._end),
                  _histo(l._histo),
                  _distPoint(l._distPoint),
                  _name(l._name)
                {}

                ~TLine()
                {}

                const TLine &operator=(const TLine &l)
                {
                        if (&l != this) {
                                _start = l._start;
                                _end = l._end;
                                _histo = l._histo;
                                _distPoint = l._distPoint;
                                _name = l._name;
                        }
                        return *this;
                }


                __property TLinePoint Start = { read=_start, write=_start };
                __property TLinePoint End = { read=_end, write=_end };
                __property bool Selected = { read=_selected, write=_selected };

                __property int Name = { read=_name, write=_name };

                int __fastcall getStartX(TPaintBox *pb);
                int __fastcall getStartY(TPaintBox *pb);
                int __fastcall getEndX(TPaintBox *pb);
                int __fastcall getEndY(TPaintBox *pb);
                int __fastcall getY(TPaintBox *pb, int x);
                int __fastcall getX(TPaintBox *pb, int y);
                float __fastcall getSlope(TPaintBox *pb);
                bool __fastcall highSlope(TPaintBox *pb); // true if slope > 1;
                bool __fastcall isNear(TPaintBox *pb, int x, int y); // true,
                                // if distance to line is smaler than DEF_DIST

                rgba __fastcall interpolate(float d);

                void __fastcall drawTo(TPaintBox *pb);

}; /* TLine */

#define TTRANS_INIT_SIZE        10

class TTransfer
{

    private:

        int _size;
        int _hsize;
        int _fill;
        TLine **_lines;
        THistogram *_histo;
        TData **_TDataCache;
        TStringList *_areaNames;

        int _distance;  // Distance from cursor to line
        int _distPoint; // Distance from cursor to a line end point
        bool _dirty;    // indicates a change in the function

        void _resize(int s);
        void _addLine(TLine *l);
        void _insertLine(TLine *l, int pos);
        void _cleanTDataCache()
        {
                for(int i=0; i<_hsize; ++i) {
                        if (_TDataCache[i]) delete _TDataCache[i];
                        _TDataCache[i] = 0;
                }
        }

        bool _setupTDataCache(__int16 data)
        {
                if (_dirty) {
                        _cleanTDataCache();
                        _dirty = false;
                }
                if (data <= _histo->size) {
                        if (!_TDataCache[data]) {
                                int i = 0;
                                while(_lines[i]->End.X<=data && i<_fill) i++;
                                if (i>_fill) return false;
                                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;
                                float d = (float)dy/(float)dx;
                                _TDataCache[data] = new TData;
                                _TDataCache[data]->col = _lines[i]->interpolate((float)(data-xs)/(float)dx);
                                _TDataCache[data]->col.a = ys+(int)((float)(data-xs)*d);
                                _TDataCache[data]->name = _lines[i]->Name;
                        }
                        return true;
                }
                // We should not reach this, but if we do ...
                return false;
        }

public:
        TTransfer(THistogram *h)
        : _histo(h),
          _hsize(h->size),
          _distance(DEF_DIST),
          _distPoint(DEF_POINT_DIST),
          _dirty(true)
        {
                _size = 0;
                _fill = 0;
                _lines = 0;
                _addLine(new TLine(TLinePoint(0, 0, clBlack),
                                   TLinePoint(350, 0, clBlack),
                                   h, DEF_POINT_DIST, -1));
                _addLine(new TLine(TLinePoint(350, 0, clBlack),
                                   TLinePoint(350, 10,
                                              (TColor)0xff0000),
                                   h, DEF_POINT_DIST, -1));
                _addLine(new TLine(TLinePoint(350, 10,
                                              (TColor)0xff0000),
                                   TLinePoint(1200, 10,
                                              (TColor)0xff0000),
                                   h, DEF_POINT_DIST, -1));
                _addLine(new TLine(TLinePoint(1200, 10,
                                              (TColor)0xff0000),
                                   TLinePoint(1200, 255,
                                              (TColor)0x0000ff),
                                   h, DEF_POINT_DIST, -1));
                _addLine(new TLine(TLinePoint(1200, 255,
                                              (TColor)0x0000ff),
                                   TLinePoint(4096, 255,
                                              (TColor)0x0000ff),
                                   h, DEF_POINT_DIST, -1));
                _TDataCache = new TData*[h->size];
                for(int i=0; i<_histo->size; ++i) _TDataCache[i] = 0;
                _areaNames = new TStringList();
                _areaNames->Sorted = true;
        }

        ~TTransfer()
        {
                for(int i=0; i<_fill; ++i) delete _lines[i];
                delete [] _lines;
                _cleanTDataCache();
                delete [] _TDataCache;
        }

        __property int Distance = { read=_distance, write=_distance };
        __property int DistPoint = { read=_distance, write=_distance };

        __property int numLines = { read=_fill };
        __property bool Dirty = { write=_dirty };
        __property TStringList* areaNames = { read=_areaNames };

        int split(TPaintBox *pb, int x, int y);
        void clear();
        bool select(TPaintBox *pb, int x, int y);
        void select(int idx);
        void selectStart(int idx);
        void selectEnd(int idx);
        TLine *getSelected();
        int getSelIdx();
        TLine *getLine(int idx);
        void unselect();
        void drawTo(TPaintBox *pb);
        int __fastcall lineNear(TPaintBox *pb, int x, int y);
        bool __fastcall nearStart(int idx, TPaintBox *pb, int x, int y);
        bool __fastcall nearEnd(int idx, TPaintBox *pb, int x, int y);

        int __fastcall getName(double data);

        rgba __fastcall getColor(__int16 data);

        //TData __fastcall getData(__int16 data);

        TData __fastcall getData(double data);


        bool loadFromXLM(_di_IXMLNode doc);

        bool saveToXML(_di_IXMLNode doc);


        int addName(AnsiString &name);

};

#endif

---