jAPIgeometry.h

Go to the documentation of this file.

//---------------------------------------------------------------------------
#ifndef jAPIgeometryH
#define jAPIgeometryH
//---------------------------------------------------------------------------

// constants used for intersection
enum jIntersections {inter_n_existe_pas=0, inter_existe, negatif, positif, posterieur, anterieur, bas, haut, confondues, paralleles_strict, segment_inside, segment_outside };

class jPoint;

class jVecteur
{
        public:
        double  x,y;
        jVecteur(double xx=0, double yy=0)              { x = xx;      y = yy;        }
        jVecteur(const TPoint & a, const TPoint & b)    { x = b.x-a.x; y = b.y-a.y;   }
        jVecteur & operator=(const jVecteur & v)        { x = v.x;     y = v.y;       return *this;}

        friend  jVecteur        operator*(jVecteur v, double f) { return jVecteur(v.x*f, v.y*f); }
        friend  jVecteur        operator*(float f, jVecteur v)  { return jVecteur(v.x*f, v.y*f); }
        void __fastcall         operator*=(double f)            { x*=f; y*=f; }
        jVecteur __fastcall     operator+(jVecteur v)           { return jVecteur(x+v.x, y+v.y); }
        void     __fastcall     Rotation(float);
        float    __fastcall     Norme();
};

class jSegment;

class jDroite
{
        public:

        // coeffs directeurs
        double a, b, c;

        jDroite()       {a=0; b=0; c=0; }
        jDroite(const TPoint & p, const jVecteur & v);
        jDroite(const jVecteur& v, const TPoint& p);
        jDroite(const TPoint & p1, const TPoint & p2);
        jDroite & operator=(const jDroite & D) { a = D.a; b = D.b; c = D.c; return *this;}

        bool __fastcall Rotation(const TPoint & centre, double angleRotDegres);
        jVecteur __fastcall Porteur();
        jVecteur __fastcall Normal();
};

TPoint __fastcall jGEOmilieu(const TPoint & p, const TPoint & q)                        { return TPoint((p.x+q.x)/2.0, (p.y+q.y)/2.0);  }

double jGEOdistance(const jDroite  & d, const jPoint & p);
double jGEOdistance(const jSegment & s, const jPoint & p);

TPoint __fastcall jGEOintersection(const jDroite & d1, const jDroite & d2, jIntersections & _cas);
TPoint __fastcall jGEOintersection(const jDroite & d, const jSegment & s,  jIntersections & _cas);
inline  TPoint __fastcall jGEOintersection(const jSegment & s, const jDroite & d, jIntersections & _cas) { return jGEOintersection(d, s, _cas); }

jDroite __fastcall jGEOperpendiculaire(const jDroite & d, const TPoint & p)             { return jDroite(p, d.Normal()); }
inline jDroite __fastcall jGEOperpendiculaire(const TPoint & p, const jDroite & d)      { return jGEOperpendiculaire(d, p); }

TPoint __fastcall jGEOprojection(const TPoint & p, const jDroite & d)                   { jIntersections existe; return jGEOintersection(d, jGEOperpendiculaire(d, p), existe); }
inline  TPoint __fastcall jGEOprojection(const jDroite & d, const TPoint & p)           { return jGEOprojection(p, d); }

jDroite __fastcall jGEOparallele(const jDroite & d, const TPoint & p)                   { return jDroite(p, d.Porteur()); }
inline  jDroite __fastcall jGEOparallele(const TPoint & p, const jDroite & d)           { return jGEOparallele(d, p); }

jDroite __fastcall jGEOrotation(const jDroite &d, const TPoint &p, float angle);

jDroite __fastcall jGEOparalleleDistante(const jDroite &d, double distance, jIntersections sens);
inline jDroite __fastcall jGEOparalleleDistante(double distance, jDroite d, jIntersections sens)   { return jGEOparalleleDistante(d, distance, sens); }

TPoint __fastcall jGEOpointDistant(const TPoint & p, const jVecteur & v, double distance, jIntersections sens);
inline  TPoint __fastcall jGEOpointDistant(const jVecteur & v, const TPoint & p,  double f, jIntersections sens)  { return jGEOpointDistant(p,v,f,sens);          }
inline  TPoint __fastcall jGEOpointDistant(const TPoint & p,   const jDroite & d, double f, jIntersections sens)  { return jGEOpointDistant(p,d.Porteur(),f,sens);}
inline  TPoint __fastcall jGEOpointDistant(const jDroite & d,  const TPoint & p,  double f, jIntersections sens)  { return jGEOpointDistant(p,d.Porteur(),f,sens);}

class jPoint : public TPoint
{
        public:

        jPoint()                        { x=0; y=0; }
        jPoint(int a, int b)            { x=a; y=b; }
//        jPoint(double a, double b)      { x=a; y=b; }

        jPoint(const TPoint & p)  { x=p.x; y=p.y; }
        jPoint & operator=(const TPoint & P)        { x=P.x; y=P.y; return *this;}
        bool __fastcall     Rotation(const jPoint & centre, double angleRotDegres);
        bool __fastcall     Translation(const jVecteur & v)   { x+=v.x; y+=v.y; return true;}
        void __fastcall     Stretch(const jPoint & origine, double rapX, double rapY)
        {
                x = origine.x + rapX*(x - origine.x);
                y = origine.y + rapY*(y - origine.y);
        }
        bool __fastcall     Symetrie(const jDroite & d);
        // fait passer le point du système de coordonnées OldCadre, au système NewCadre)
        bool __fastcall     Stretch( const TRect & NewCadre, const TRect & OldCadre, bool right=true);
        // fait passer le point du système de coordonnées NewCadre, au système OldCadre)
        bool __fastcall     UnStretch(const TRect & NewCadre, const TRect & OldCadre, bool right=true);
        bool operator==(const jPoint & p)             { return (x==p.x && y==p.y); }
        bool operator!=(const jPoint & p)             { return (x!=p.x || y!=p.y); }
};

class jSegment
{
        public:
        TPoint  p, q;
        jDroite d;

        jSegment()                                      { p=TPoint(0, 0); q=TPoint(0, 0); d=jDroite(p, q); }
        jSegment(TPoint pp, TPoint qq)                  { p=pp; q=qq; d=jDroite(pp, qq);                   }
        jSegment(TPoint pp, TPoint qq, jDroite dd)      { p=pp; q=qq; d=dd;                                }

        jDroite & Porteuse()                            { return d; }
};

#endif

---