jAPIbeziers.h

Go to the documentation of this file.

//---------------------------------------------------------------------------
#ifndef jAPIbeziersH
#define jAPIbeziersH
//---------------------------------------------------------------------------

#include <vector.h>
#include <stdio.h>

//----------------------------------------------------------------------------
// CLASS CONROL_POINT
// = segment de courbe de bezier
//----------------------------------------------------------------------------

class jBEZctrlPoint
{
        POINT lppt[4];

        public:

        TPoint point_debut;
        TPoint point_fin;
        TPoint point_ctrl_deb;
        TPoint point_ctrl_fin;

        jBEZctrlPoint()
        {
            TPoint tmp;
            tmp.x = 0;
            tmp.y = 0;
            jBEZctrlPoint(tmp, tmp, tmp, tmp);
        }
        jBEZctrlPoint(TPoint a, TPoint b, TPoint c, TPoint d)
        {
                point_debut     = a;
                point_ctrl_deb  = b;
                point_fin       = c;
                point_ctrl_fin  = d;
        }

        TPoint __fastcall Symetrique_point_ctrl_deb(double rapport=1)
        {
                TPoint tmp;
                tmp.x = point_debut.x-(point_ctrl_deb.x-point_debut.x)*rapport;
                tmp.y = point_debut.y-(point_ctrl_deb.y-point_debut.y)*rapport;
                return tmp;
        }
        TPoint __fastcall Symetrique_point_ctrl_fin(double rapport=1)
        {
                TPoint tmp;
                tmp.x = point_fin.x-(point_ctrl_fin.x-point_fin.x)*rapport;
                tmp.y = point_fin.y-(point_ctrl_fin.y-point_fin.y)*rapport;
                return tmp;
        }

        jBEZctrlPoint * __fastcall  Copy();

        // transformations
        void __fastcall Move(TPoint vect);
        void __fastcall Scale(TPoint origine, float rapportX, float rapportY);
        void __fastcall Rotate(TPoint origine, float angle);
        void __fastcall HorizontalSymetry(double ord);
        void __fastcall VerticalSymetry(double abs);

        void __fastcall Draw(TCanvas * CV, bool tangentes=false, jBEZctrlPoint * suiv=NULL);
        void __fastcall UnDraw(TCanvas * CV, bool tangentes=false, jBEZctrlPoint * suiv=NULL);
        void __fastcall LoadFromFile(FILE * f);
        void __fastcall SaveToFile(FILE * f);
};

//----------------------------------------------------------------------------
// CLASS BEZIER_CRV
// = courbe de bezier (composée de plusieurs segment control_point)
//----------------------------------------------------------------------------

class jBEZcurve
{
        vector<jBEZctrlPoint *> vecteur;
        vector<jBEZctrlPoint *>::iterator it;

        public:
        jBEZcurve()      {vecteur.clear();}

        void __fastcall AddPoint(int X, int Y, int X2=0, int Y2=0);
        void __fastcall AddPoint(const TPoint & A, const TPoint & B=TPoint(0,0))   { AddPoint(A.x, A.y, B.x, B.y); }        
        void __fastcall DelLastPoint();
        void __fastcall DelPoint(int num);
        void __fastcall ChangeVectorOfLastPoint(int X, int Y);
        void __fastcall InsertPoint(int num, int X, int Y, int X2=0, int Y2=0);

        void __fastcall Draw(TCanvas * CV, bool tangentes=false);
        bool __fastcall DrawFetched(TCanvas * CV, const TRect & z_dst, const TRect & z_src, bool tangentes=false);

        void __fastcall RedrawLast(TCanvas * CV, bool tangentes=false);
        void __fastcall RefreshLast(TCanvas * CV, int X, int Y, bool tangentes=false);
        void __fastcall TranslatePoint(TCanvas * CV, int num, int X, int Y, bool tangentes=false);
        void __fastcall TranslateCtrlFinPoint(TCanvas * CV, int num, int X, int Y, bool tangentes=false);
        void __fastcall TranslateCtrlDebPoint(TCanvas * CV, int num, int X, int Y, bool tangentes=false);
        TPoint __fastcall Check4Point(bool tangentes, int X, int Y);
        void __fastcall Smooth(float);
        int  __fastcall Check4MinDistance(int X, int Y);
        void __fastcall LoadFromFile(FILE * f, int max);
        void __fastcall SaveToFile(FILE * f);

        jBEZcurve * __fastcall Copy();

        // transformations
        void __fastcall Move(TPoint vect)
        {
            for (unsigned int i=0; i< vecteur.size(); i++)
                vecteur.at(i)->Move(vect);
        }
        void __fastcall Scale(TPoint origine, float rapportX, float rapportY)
        {
            for (unsigned int i=0; i< vecteur.size(); i++)
                vecteur.at(i)->Scale(origine, rapportX, rapportY);
        }
        void __fastcall Rotate(TPoint origine, float angle)
        {
            for (unsigned int i=0; i< vecteur.size(); i++)
                vecteur.at(i)->Rotate(origine, angle);
        }
        void __fastcall HorizontalSymetry(double ord)
        {
            for (unsigned int i=0; i< vecteur.size(); i++)
                vecteur.at(i)->HorizontalSymetry(ord);
        }
        void __fastcall VerticalSymetry(double abs)
        {
            for (unsigned int i=0; i< vecteur.size(); i++)
                vecteur.at(i)->VerticalSymetry(abs);
        }

        bool __fastcall Fetch(const TRect & dst, const TRect & src);

        TPoint __fastcall FirstPoint(bool & existe)
        {
                if (vecteur.size() <= 0)       { existe = false; return TPoint(-1, -1); }
                existe = true;
                return vecteur.front()->point_debut;
        }
        ~jBEZcurve()
        {
                for (unsigned int i=0; i<vecteur.size(); i++)
                {
                        if (vecteur.at(i))
                                delete vecteur.at(i);
                }
                vecteur.clear();
        }
};

//----------------------------------------------------------------------------
// CLASS jBEZcurves
// = ensemble de courbes de bezier
//----------------------------------------------------------------------------

class jBEZcurves
{
        vector<jBEZcurve *> vecteur;

        public:

        jBEZcurves()      {vecteur.clear();}

        void __fastcall AddCurve(jBEZcurve * crv) {vecteur.push_back(crv);}
        jBEZcurve * __fastcall CurveAt(unsigned int num)   {return ((num < 0 || num >= vecteur.size()) ? NULL : vecteur.at(num));}

        bool __fastcall LoadFromFile(FILE * f, int max1, int max2);
        bool __fastcall SaveToFile(FILE * f);

        void __fastcall Move(int x, int y)                                   { Move(TPoint(x, y)); }
        // transformations
        void __fastcall Move(TPoint vect)
        {
            for (unsigned int i=0; i< vecteur.size(); i++)
                vecteur.at(i)->Move(vect);
        }

        void __fastcall Scale(TPoint origine, double rapportX, double rapportY)
        {
            for (unsigned int i=0; i< vecteur.size(); i++)
                vecteur.at(i)->Scale(origine, rapportX, rapportY);
        }

        void __fastcall Rotate(TPoint origine, double angle)
        {
            for (unsigned int i=0; i< vecteur.size(); i++)
                vecteur.at(i)->Rotate(origine, angle);
        }
        void __fastcall HorizontalSymetry(double ord)
        {
            for (unsigned int i=0; i< vecteur.size(); i++)
                vecteur.at(i)->HorizontalSymetry(ord);
        }
        void __fastcall VerticalSymetry(double abs)
        {
            for (unsigned int i=0; i< vecteur.size(); i++)
                vecteur.at(i)->VerticalSymetry(abs);
        }

/*      // ne marche pas : copie les adresses au lieu de copier l'objet
        jBEZcurves & operator=(const jBEZcurves & b)
        {
            for (int i=0; i<b.vecteur.size(); i++)
                vecteur.push_back(b.vecteur.at(i)->Copy());
            return *this;
        }*/

        void Copy(const jBEZcurves & b)
        {
            for (unsigned int i=0; i<b.vecteur.size(); i++)
                vecteur.push_back(b.vecteur.at(i)->Copy());
        }

        ~jBEZcurves()   { Empty(); }

        void __fastcall Empty()
        {
                jBEZcurve * l_courbe = NULL;
                for (unsigned int i=0; i<vecteur.size(); i++)
                {
                        l_courbe = vecteur.at(i);
                        if (!l_courbe)  continue;
                        delete l_courbe;
                }
                vecteur.clear();
        }

        bool __fastcall Resize(int nb);        

        void __fastcall Draw(TCanvas * CV, int num=0)
        {
                if (num==0)
                        for (unsigned int i=0; i<vecteur.size(); i++)
                                vecteur.at(i)->Draw(CV, false); // JEG avant (i==num));
                else
                        vecteur.at(num)->Draw(CV, false);
        }

        void __fastcall DrawFetched(TCanvas * CV, const TRect & dst, const TRect & src, int num=0)
        {
                jBEZcurves l_courbes;
                l_courbes.Copy(*this);
                l_courbes.Fetch(dst, src);
                l_courbes.Draw(CV, num);
        }

        void __fastcall Fetch(const TRect & dst, const TRect & src)
        {
                TPoint l_vect    = TPoint(dst.Left - src.Left, dst.Top - src.Top);
                TPoint origine   = TPoint(dst.Left, dst.Top);
                float  l_rapportH= dst.Height() ? dst.Height() / ((float)(src.Height() ? src.Height() : 1)) : 1;
                float  l_rapportW= dst.Height() ? dst.Width()  / ((float)(src.Width()  ? src.Width()  : 1)) : 1;
                Move(l_vect);
                Scale(origine, l_rapportW, l_rapportH);
        }
        int  __fastcall Size()                          { return vecteur.size(); }
        bool __fastcall ContainsCurves()                { return ((bool)vecteur.size()); }
        bool __fastcall IsEmpty()                       { return (!vecteur.size()); }
};
#endif

---