SolidModel.h

Go to the documentation of this file.

#pragma once

class SolidHandler
    {
    protected:

        int             idxPivotPoint;
        cv::Mat         mtx;
        SolidPoint      pivotPoint;
        void            takePoint               (SolidPoint &pt, SolidPointVector &points);
        void            takePoint               (size_t idx, SolidPointVector &points);
        void            takeZeroPoint           (SolidPoint &pt, SolidPointVector &points);
        void            takeZeroPoint           (size_t idx, SolidPointVector &points);

        double          deg2Rad                 (double deg) const              { return dPi * deg / 180.; }
        void            xAxis                   (double si, double co);
        void            yAxis                   (double si, double co);
        void            zAxis                   (double si, double co);
        void            takePivotPoint          (SolidPointVector &points)      { takePoint (pivotPoint, points); }
        void            takeZeroPoint           (SolidPointVector &points);
        void            doXRotation             (double rAngle, SolidPointVector &points);
        void            doYRotation             (double rAngle, SolidPointVector &points);
        void            doZRotation             (double rAngle, SolidPointVector &points);
        void            rotateXAxis             (double rAngle, SolidPointVector &points);
        void            rotateYAxis             (double rAngle, SolidPointVector &points);
        void            rotateZAxis             (double rAngle, SolidPointVector &points);

                        SolidHandler            (int idxPivot);

    public:
        void            scale                   (double scale, SolidPointVector &points, bool bPivot = true);
        void            scale                   (double horzScale, double vertScale, SolidPointVector &points, bool bPivot = true);
        void            move                    (double dx, double dy, double dz, SolidPointVector &points);
        double          getNorm                 (size_t idxPt1, size_t idxPt2, SolidPointVector &points);
        double          getPlanarNorm           (size_t idxPt1, size_t idxPt2, SolidPointVector &points);
        double          getPlanarNorm           (double x1, double y1, double x2, double y2)    { return sqrt (pow (x1 - x2, 2) + pow (y1 - y2, 2)); }
        double          getPlanarRotation       (size_t idxPt1, size_t idxPt2, SolidPointVector &points);

    };

class SolidModel : public SolidHandler
    {
    protected:
        SolidPointVector    pointVector;

        void            setPointValues          (size_t idx, double x, double y, double z);
        void            setPointValues          (size_t idx, SolidPoint point);

                        SolidModel              (int idxPivot);

    public:
        void            scale                   (double fScale)                     { SolidHandler::scale (fScale, pointVector); }
        void            scale                   (double horzScale, double vertScale){ SolidHandler::scale (horzScale, vertScale, pointVector); }
        void            move                    (double dx, double dy, double dz)   { SolidHandler::move (dx, dy, dz, pointVector); }
        void            movePointTo             (size_t idx, double x, double y, double z);
        void            rotateXAxis             (double rAngle)                     { SolidHandler::rotateXAxis (rAngle, pointVector); }
        void            rotateYAxis             (double rAngle)                     { SolidHandler::rotateYAxis (rAngle, pointVector); }
        void            rotateZAxis             (double rAngle)                     { SolidHandler::rotateZAxis (rAngle, pointVector); }


        void            getPointsRef            (SolidPointVector** pointsRef)      { *pointsRef = &pointVector;
        // dieser Zuweisungsoperator erzeugt eine tiefe kopie .
        }
        void            getPointsCopy           (SolidPointVector &pointsCopy);
        double          getScaledValue          (double value)                  { return value * getScaleFactor (); }
        bool            isValidIndex            (size_t index)                  { return index < pointVector.size (); }
        bool            setHorzValue            (size_t index, double value)    { if (index < pointVector.size ()) { pointVector [index].y = value; return true; } return false; }
        bool            setVertValue            (size_t index, double value)    { if (index < pointVector.size ()) { pointVector [index].x = value; return true; } return false; }
        bool            setPlanarValues         (size_t index, double horz, double vert)    
            { if (index < pointVector.size ()) { pointVector [index].y = horz; pointVector [index].x = vert; return true; } return false; }
        bool            getPlanarValues         (size_t index, double &horz, double &vert)  
            { if (index < pointVector.size ()) { horz = pointVector [index].y; vert = pointVector [index].x; return true; } return false; }
        double          getHorzValue            (size_t index)                  { return index < pointVector.size () ? pointVector [index].y : 0; }
        double          getVertValue            (size_t index)                  { return index < pointVector.size () ? pointVector [index].x : 0; }
        bool            setPoint                (size_t index, SolidPoint &pt)  { if (index < pointVector.size ()) { pointVector.at (index) = pt; return true; } return false; }
        bool            getPoint                (size_t index, SolidPoint &pt)  { if (index < pointVector.size ()) { pt = pointVector.at (index); return true; } return false; }
        double          getNorm                 (size_t idxPt1, size_t idxPt2)  { return SolidHandler::getNorm (idxPt1, idxPt2, pointVector); }
        double          getPlanarNorm           (size_t idxPt1, size_t idxPt2)  { return SolidHandler::getPlanarNorm (idxPt1, idxPt2, pointVector); }
        double          getPlanarRotation       (size_t idxPt1, size_t idxPt2)  { return SolidHandler::getPlanarRotation (idxPt1, idxPt2, pointVector); }
        void            setPlanarPivotValues    (double horz, double vert)      { setPlanarValues (idxPivotPoint, horz, vert); }
        void            minMaxPointValues       (size_t idx, SolidPoint &minPt, SolidPoint &maxPt);
        virtual double  getScaleFactor          () = 0;
        virtual void    resetModel              () = 0;
    };