source: cpp/frams/model/geometry/meshbuilder.h @ 1321

// This file is a part of Framsticks SDK.  http://www.framsticks.com/
// Copyright (C) 1999-2015  Maciej Komosinski and Szymon Ulatowski.
// See LICENSE.txt for details.

#ifndef _MESHBUILDER_H_
#define _MESHBUILDER_H_

#include <frams/model/model.h>
#include <frams/model/modelparts.h>
#include <frams/util/3d.h>
#include <frams/util/list.h>
#include "geometryutils.h"

namespace MeshBuilder
{
        class Callback
        {
                public:
                        virtual void operator()(const Pt3D &point) = 0;
        };
        
        class Iterator
        {
                protected:
                        double density;
                public:
                        Iterator(const double _density);
                        double getDensity() const;
                        void setDensity(const double _density);
                        virtual bool tryGetNext(Pt3D &point) = 0;
                        void forEach(Callback &callback);
                        void addAllPointsToList(SListTempl<Pt3D> &list);
        };

        class Segment: public Iterator
        {
                private:
                        Pt3D point1, point2;
                        int i, I, numberOfPoints;
                public:
                        Segment(const double _density);
                        void initialize(const Pt3D &point1, const Pt3D &point2, const bool skipFirst = false, const bool skipLast = false, const bool forceOddNumberOfPoints = false);
                        bool tryGetNext(Pt3D &point);
        };

        class RectangleSurface: public Iterator
        {
                private:
                        Segment edge1, edge2, area;
                        bool skipVerticalEdges, forceOddNumberOfPoints;
                public:
                        RectangleSurface(const double _density);
                        void initialize(const Part *part, const CuboidFaces::Face face, const bool skipVerticalEdges = false, const bool skipHorizontalEdges = false, const bool forceOddNumberOfPoints = false);
                        void initialize(const double width, const double height, const Pt3D &position, const Orient &orient, const bool skipVerticalEdges = false, const bool skipHorizontalEdges = false, const bool forceOddNumberOfPoints = false);
                        void initialize(const Pt3D &apex1, const Pt3D &apex2, const Pt3D &apex3, const Pt3D &apex4, const bool skipVerticalEdges = false, const bool skipHorizontalEdges = false, const bool forceOddNumberOfPoints = false);
                        bool tryGetNext(Pt3D &point);
        };

        class CuboidApices: public Iterator
        {
                private:
                        Pt3D scale;
                        Pt3D position;
                        Orient orient;
                        Octants::Octant octant;
                public:
                        CuboidApices();
                        void initialize(const Part *part);
                        void initialize(const Pt3D &scale, const Pt3D &position, const Orient &orient);
                        bool tryGetNext(Pt3D &point);
        };

        class CuboidSurface: public Iterator
        {
                private:
                        CuboidApices apices;
                        RectangleSurface rectangle;
                        Iterator *iterator;
                        const Part *part;
                        CuboidFaces::Face face;
                public:
                        CuboidSurface(const double _density);
                        void initialize(const Part *part);
                        bool tryGetNext(Pt3D &point);
        };

        class EllipseSurface: public Iterator
        {
                private:
                        RectangleSurface rectangle;
                        Pt3D position;
                        Orient orient;
                        double inversedSquaredWidth, inversedSquaredHeight;
                public:
                        EllipseSurface(const double _density);
                        void initialize(const Part *part, const CylinderBases::Base base);
                        void initialize(const double width, const double height, const Pt3D &position, const Orient &orient);
                        bool tryGetNext(Pt3D &point);
        };

        class Ellipse: public Iterator
        {
                private:
                        enum Phase { yToZ, zToY, Done };
                        Phase phase;
                        Pt3D position;
                        Orient orient;
                        double width, height, d, p, q, P, Q, D, a, b;
                        QuadrantsYZ::QuadrantYZ quadrant;
                public:
                        Ellipse(const double _density);
                        void initialize(const Part *part, const CylinderBases::Base base);
                        void initialize(const double width, const double height, const Pt3D &position, const Orient &orient);
                        bool tryGetNext(Pt3D &point);
                private:
                        void calculateAndSetSegmentationDistance();
                        void initializePhase(Phase ph);
                        void setPoint(Pt3D &point);
                        void findNextPQAndPhase();
                        int findLastPQOfPhase(Phase ph, double &lp, double &lq);
        };

        class CylinderEdges: public Iterator
        {
                private:
                        Ellipse ellipse;
                        Pt3D edge, length;
                        CylinderBases::Base base;
                public:
                        CylinderEdges(const double _density);
                        void initialize(const Part *part);
                        void initialize(const Pt3D &scale, const Pt3D &position, const Orient &orient);
                        void initialize(const double length, const double width, const double height, const Pt3D &position, const Orient &orient);
                        bool tryGetNext(Pt3D &point);
        };

        class CylinderWallSurface: public Iterator
        {
                private:
                        Ellipse edge;
                        Pt3D length;
                        Segment area;
                public:
                        CylinderWallSurface(const double _density);
                        void initialize(const Part *part);
                        void initialize(const Pt3D &scale, const Pt3D &position, const Orient &orient);
                        void initialize(const double length, const double width, const double height, const Pt3D &position, const Orient &orient);
                        bool tryGetNext(Pt3D &point);
        };

        class CylinderSurface: public Iterator
        {
                private:
                        CylinderWallSurface wall;
                        EllipseSurface ellipse;
                        Iterator *iterator;
                        const Part *part;
                        CylinderBases::Base base;
                public:
                        CylinderSurface(const double _density);
                        void initialize(const Part *part);
                        bool tryGetNext(Pt3D &point);
        };

        class EllipsoidSurface: public Iterator
        {
                private:
                        enum Phase { X, Y, Z, Done };
                        Phase phase;
                        Pt3D edge, area, scale, limit;
                        double d;
                        const Part *part;
                        Octants::Octant octant;
                public:
                        EllipsoidSurface(const double _density);
                        void initialize(const Part *part);
                        bool tryGetNext(Pt3D &point);
                private:
                        void initializePhase(Phase ph);
                        void setPoint(Pt3D &point);
                        void proceedToNextOctant();
                        void findNextAreaEdgeAndPhase();
        };

        class PartSurface: public Iterator
        {
                private:
                        CuboidSurface cuboid;
                        CylinderSurface cylinder;
                        EllipsoidSurface ellipsoid;
                        Iterator *iterator;
                public:
                        PartSurface(const double _density);
                        void initialize(const Part *part);
                        bool tryGetNext(Pt3D &point);
        };

        class ModelSurface: public Iterator
        {
                private:
                        PartSurface surface;
                        const Model *model;
                        int index;
                public:
                        ModelSurface(const double _density);
                        void initialize(const Model *model);
                        bool tryGetNext(Pt3D &point);
        };

        class PartApices: public Iterator
        {
                private:
                        CuboidApices cuboid;
                        CylinderEdges cylinder;
                        EllipsoidSurface ellipsoid;
                        Iterator *iterator;
                public:
                        PartApices(const double _density);
                        void initialize(const Part *part);
                        bool tryGetNext(Pt3D &point);
        };

        class ModelApices: public Iterator
        {
                private:
                        PartApices surface;
                        const Model *model;
                        int index;
                public:
                        ModelApices(const double _density);
                        void initialize(const Model *model);
                        bool tryGetNext(Pt3D &point);
        };

        class BoundingBoxVolume: Iterator
        {
                private:
                        Segment edge, area, volume;
                        Pt3D length, width, height;
                public:
                        BoundingBoxVolume(const double _density);
                        void initialize(const Model &model);
                        void initialize(const Pt3D &lowerBoundary, const Pt3D &upperBoundary);
                        bool tryGetNext(Pt3D &point);
        };
};

#endif