Geometry.h

Go to the documentation of this file.

#ifndef _Geometry_H
#define _Geometry_H

#include <vrecko/Logger.h>

#include <helpers/XercesXMLUtils.h>
#include <xercesc/parsers/XercesDOMParser.hpp>
#include <xercesc/dom/DOM.hpp>
#include <xercesc/sax/HandlerBase.hpp>
#include <xercesc/util/XMLString.hpp>
#include <xercesc/util/PlatformUtils.hpp>

#include <osg/Geometry>
#include <vector>
#include <cmath>
#include <osg/ref_ptr>
#include <iostream>
#include "RealCmp.h"

#define RE_DEFAULT_HEIGHT 20.0
#define RE_DEFAULT_BOTTOM 0.0
#define RE_DEFAULT_2_WIDTH 0.75
#define RE_MIN_LENGTH 5.0
#define RE_DEFAULT_COLOR osg::Vec3(1.0, 1.0, 1.0)
#define RE_MIN_ANGLE(x,y) ((x)<(y) ? 2*(RE_DEG_2_RAD_RATIO)*asin((RE_DEFAULT_2_WIDTH)/(x)) : 2*(RE_DEG_2_RAD_RATIO)*asin((RE_DEFAULT_2_WIDTH)/(y)))

#define RE_DEG_2_RAD_RATIO (180.0 / 3.141592653589793238)

#define RE_WALL_ANGLES_COMPUTED 1
#define RE_WALL_DRAWN 2

using namespace vrecko;

namespace WGeometry
{
    enum PointType {
        WG_Q_POINT,
        WG_R_POINT
    };

    // class with helpful geometric methods
    class WG_Geometry {
        public:
            WG_Geometry() {}
            ~WG_Geometry() {}

            static bool getCrossingPoint(osg::Vec2& destPoint, osg::Vec2 pPoint, osg::Vec2 pNormal, osg::Vec2 rPoint, osg::Vec2 rNormal, bool justStroke) {
                float d1, d2, div;
                float resultX, resultY;
                float param, tparam;

                d1 = -1*(pPoint.x() * pNormal.x() + pPoint.y() * pNormal.y());
                d2 = -1*(rPoint.x() * rNormal.x() + rPoint.y() * rNormal.y());
                div = (rNormal.x() * pNormal.y() - pNormal.x() * rNormal.y());

                bool result = false;

                if (!RealCmp<float>::compareEQ(div, 0.0f)) { // are not parallel
                    resultX = (d1 * rNormal.y() - d2 * pNormal.y()) / div;
                    if (RealCmp<float>::compareEQ(pNormal.y(), 0.0f)) {
                        resultY = (-d2 - rNormal.x() * resultX) / rNormal.y();
                    }
                    else {
                        resultY = (-d1 - pNormal.x() * resultX) / pNormal.y();
                    }

                    if (RealCmp<float>::compareEQ(pNormal.x(), 0.0f))
                        param = (resultX - pPoint.x()) / pNormal.y();
                    else
                        param = (resultY - pPoint.y()) / (-pNormal.x());

                    if (RealCmp<float>::compareEQ(rNormal.x(), 0.0f))
                        tparam = (resultX - rPoint.x()) / rNormal.y();
                    else
                        tparam = (resultY - rPoint.y()) / (-rNormal.x());

                    destPoint = osg::Vec2(resultX, resultY);
                    if (justStroke)
                        result = ((param > 0.000009) && (param < 0.999999) && (tparam > 0.000009) && (tparam < 0.999999));
                    else
                        result = true;
                }

                return result;
            }

            static bool barycentricTest(osg::Vec2 P, osg::Vec2 A, osg::Vec2 B, osg::Vec2 C) {
                // Compute vectors        
                osg::Vec2 v0 = C - A,
                          v1 = B - A,
                          v2 = P - A;

                // Compute dot products
                float dot00 = v0 * v0,
                      dot01 = v0 * v1,
                      dot02 = v0 * v2,
                      dot11 = v1 * v1,
                      dot12 = v1 * v2;

                // Compute barycentric coordinates
                float invDenom = 1 / (dot00 * dot11 - dot01 * dot01),
                      u = (dot11 * dot02 - dot01 * dot12) * invDenom,
                      v = (dot00 * dot12 - dot01 * dot02) * invDenom;

                // Check if point is in triangle
                return (u >= 0) && (v >= 0) && (u + v <= 1);
            }


            static float getAngle(osg::Vec2& vector) {
                
                float angle, toSum = 0;
                if (RealCmp<float>::compareEQ(vector.x(), 0.0f)) {
                    if (vector.y() >= 0) {
                        angle = 90;
                    }
                    else {
                        angle = 270;
                    }
                }
                else if(RealCmp<float>::compareEQ(vector.y(), 0.0f)) {
                    if (vector.x() >= 0) {
                        angle = 0;
                    }
                    else {
                        angle = 180;
                    }
                }
                else {
                    if ((vector.x() > 0) && (vector.y() > 0)) {
                        toSum = 0;
                    }
                    else if ((vector.x() < 0) && (vector.y() > 0)) {
                        toSum = 180;
                    }
                    else if ((vector.x() < 0) && (vector.y() < 0)) {
                        toSum = 180;
                    }
                    else {
                        toSum = 360;
                    }
                    angle = ((atan(vector.y() / vector.x())*RE_DEG_2_RAD_RATIO) + toSum);
                }
                return angle;
            }
    };

    class WG_Wall;

    // class which just stores some vertices (used in WGWall)
    class WG_Vertices {
        public:
            WG_Vertices() { validVertices = false; }
            virtual ~WG_Vertices() {}

            // setters and getters
            void setTopCWVertex(osg::Vec3 P) { topCWVertex = P; }
            osg::Vec3 getTopCWVertex() { return topCWVertex; }

            void setTopCCWVertex(osg::Vec3 P) { topCCWVertex = P; }
            osg::Vec3 getTopCCWVertex() { return topCCWVertex; }

            void setBottomCWVertex(osg::Vec3 P) { bottomCWVertex = P; }
            osg::Vec3 getBottomCWVertex() { return bottomCWVertex; }

            void setBottomCCWVertex(osg::Vec3 P) { bottomCCWVertex = P; }
            osg::Vec3 getBottomCCWVertex() { return bottomCCWVertex; }

            void setNormalCWVertex(osg::Vec2 P) { normalCWVertex = P; }
            osg::Vec2 getNormalCWVertex() { return normalCWVertex; }

            void setNormalCCWVertex(osg::Vec2 P) { normalCCWVertex = P; }
            osg::Vec2 getNormalCCWVertex() { return normalCCWVertex; }

            void setValidVertices(bool valid) { validVertices = valid; }
            bool areValidVertices() { return validVertices; }

        private:
            osg::Vec3 topCWVertex;
            osg::Vec3 topCCWVertex;
            osg::Vec3 bottomCWVertex;
            osg::Vec3 bottomCCWVertex;

            osg::Vec2 normalCWVertex;
            osg::Vec2 normalCCWVertex;

            bool validVertices;
    };


    // class representin a point of a wall
    class WG_Point : public osg::Referenced {
        public:
            WG_Point(osg::Vec2 position, float height = RE_DEFAULT_HEIGHT) { this->position = position; this->height = height; }
            virtual ~WG_Point() { plusVertices.clear(); plusNormals.clear(); plusColors.clear(); }

            // setters and getters
            void setPosition(osg::Vec2 position) {
                this->position = position;
            }
            osg::Vec2 getPosition() { return position; }

            float getHeight() { return height; }

            void addWall(WG_Wall* wall, PointType connectionPointType, bool compute = true);
            void removeWall(WG_Wall* wall);
            std::vector<std::pair<osg::ref_ptr<WG_Wall>, PointType> >* getWalls() { return &walls; }

            void setId(unsigned int i) { id = i; }
            unsigned int getId() { return id; }

            void setIndexTop(unsigned int i) { indexTop = i; }
            unsigned int getIndexTop() { return indexTop; }

            void setIndexBottom(unsigned int i) { indexBottom = i; }
            unsigned int getIndexBottom() { return indexBottom; }

            std::vector<osg::Vec3>* getPlusVertices() { return &plusVertices; }
            std::vector<osg::Vec3>* getPlusNormals() { return &plusNormals; }
            std::vector<osg::Vec3>* getPlusColors() { return &plusColors; }

            // returns wall neighbours from the attribute walls
            bool getWallNeighbours(WG_Wall* wall, std::pair<osg::ref_ptr<WG_Wall>, PointType>& wallCW, std::pair<osg::ref_ptr<WG_Wall>, PointType>& wallCCW);

        private:
            osg::Vec2 position;
            float height;

            unsigned int id; // = index to array of points in WallGeometry Ability

            std::vector<std::pair<osg::ref_ptr<WG_Wall>, PointType> > walls; // walls connected to the point

            unsigned int indexTop;
            unsigned int indexBottom;

            std::vector<osg::Vec3> plusVertices; // used when drawing walls
            std::vector<osg::Vec3> plusNormals;
            std::vector<osg::Vec3> plusColors;
    };

    enum HoleType {
        ht_window,
        ht_door
    };


    // class representin a hole in the wall
    class WG_Hole {
        public:
            WG_Hole(float position, float y, float height, float width, HoleType type) {
                this->position = position;
                this->y = y;
                this->height = height;
                this->width = width;
                this->type = type;
            }
            ~WG_Hole() {}

            // setters and getters
            void setPosition(float position) { this->position = position; }
            float getPosition() { return position; }

            void setY(float y) { this->y = y; }
            float getY() { return y; }

            void setHeight(float height) { this->height = height; }
            float getHeight() { return height; }

            void setWidth(float width) { this->width = width; }
            float getWidth() { return width; }

            void setType(HoleType type) { this->type = type; }
            HoleType getType() { return type; }

            WG_Vertices* getQVertices() { return &qVertices; }
            WG_Vertices* getRVertices() { return &rVertices; }

        private:
            float position; // distance from Q
            float y;

            float height;
            float width;
            HoleType type;
            WG_Vertices qVertices;
            WG_Vertices rVertices;
    };


    // important class representing a wall
    class WG_Wall : public osg::Referenced {
        public:
            WG_Wall(WG_Point* qPoint, WG_Point* rPoint, bool compute = true) {
                flag = 0; q = qPoint; r = rPoint;
                qAttr.color = RE_DEFAULT_COLOR;
                rAttr.color = RE_DEFAULT_COLOR;
                computeAttrVectorsAndAngles();

                qPoint->addWall(this, WG_Q_POINT, compute);
                rPoint->addWall(this, WG_R_POINT, compute);

                if (compute)
                    computeAttrVertices();
            }
            virtual ~WG_Wall() {}

            // setters and getters
            void setPoints(WG_Point* qPoint, WG_Point* rPoint) {
                q->removeWall(this); r->removeWall(this);
                q = qPoint; r = rPoint;
                computeAttrVectorsAndAngles();
                q->addWall(this, WG_Q_POINT);
                r->addWall(this, WG_R_POINT);
                computeAttrVertices();
            }

            void setPoint(WG_Point* point, PointType type) {
                if (type==WG_Q_POINT) {
                    q->removeWall(this);
                    q = point;
                    computeAttrVectorsAndAngles();
                    q->addWall(this, WG_Q_POINT);
                }
                else {
                    r->removeWall(this);
                    r = point;
                    computeAttrVectorsAndAngles();
                    r->addWall(this, WG_R_POINT);
                }
                computeAttrVertices();
            }

            WG_Point* getPoint(PointType type) { return (type==WG_Q_POINT ? q.get() : r.get()); }
            osg::ref_ptr<WG_Point> getPointRef(PointType type) { return (type==WG_Q_POINT ? q : r); }

            osg::Vec2 getVector(PointType type) { return (type==WG_Q_POINT ? qAttr.vector : rAttr.vector); }
            float getAngle(PointType type) { return (type==WG_Q_POINT ? qAttr.angle : rAttr.angle); }
            WG_Vertices* getVertices(PointType type) { return (type==WG_Q_POINT ? &(qAttr.vertices) : &(rAttr.vertices)); }

            void setColor(osg::Vec3 color, PointType type) { type==WG_Q_POINT ? qAttr.color = color : rAttr.color = color; }
            osg::Vec3 getColor(PointType type) { return (type==WG_Q_POINT ? qAttr.color : rAttr.color); }

            void setId(unsigned int i) { id = i; }
            unsigned int getId() { return id; }

            void setFlag(int flag) { this->flag = flag; }
            int getFlag() { return flag; }

            void setTopNormal(osg::Vec3 n) { topNormal = n; }
            osg::Vec3 getTopNormal() { return topNormal; }

            void setBottomNormal(osg::Vec3 n) { bottomNormal = n; }
            osg::Vec3 getBottomNormal() { return bottomNormal; }

            void setFaceNormal(osg::Vec3 n, PointType type) { (type==WG_Q_POINT ? qrNormal = n : rqNormal = n); }
            osg::Vec3 getFaceNormal(PointType type) { return (type==WG_Q_POINT ? qrNormal : rqNormal); }

            std::vector<WG_Hole>* getHoles() { return &holes; }

            // computes both angles an vectors
            void computeAttrVectorsAndAngles();
            bool areAnglesComputed() { return flag & RE_WALL_ANGLES_COMPUTED; }

            // computes vertices and normals for vertexArray and normalArray
            void computeAttrVertices(PointType type);
            void computeAttrVertices() { computeAttrVertices(WG_Q_POINT); computeAttrVertices(WG_R_POINT); computeAttrNormals(); computeHoleVertices(); }

            bool computeAttrNormals();
            void computeHoleVertices();

        private:
            struct PointRelatedAttr {
                osg::Vec2 vector; // started from the point
                float angle; // CCW angle of the vector

                WG_Vertices vertices;
                osg::Vec3 color; // color of the quad that has front face with vector going left to right
            };

            osg::ref_ptr<WG_Point> q;
            PointRelatedAttr qAttr;

            osg::ref_ptr<WG_Point> r;
            PointRelatedAttr rAttr;

            int flag;
            unsigned int id;

            osg::Vec3 topNormal;
            osg::Vec3 bottomNormal;
            osg::Vec3 qrNormal;
            osg::Vec3 rqNormal;

            std::vector<WG_Hole> holes;

            // sets vector P2 - P1 and angle into corresponding attributes
            void setVectorAndAngle(WG_Point* P1, WG_Point* P2, PointRelatedAttr* attr);

            // computes normal from 3 points that form a triangle (half of a quad)
            osg::Vec3 computeNormal(osg::Vec3 V1, osg::Vec3 V2, osg::Vec3 V3) {
                osg::Vec3 A = V1 - V2;
                osg::Vec3 B = V3 - V2;
                osg::Vec3 normal = osg::Vec3((A.y() * B.z() - A.z() * B.y()), (A.z() * B.x() - A.x() * B.z()), (A.x() * B.y() - A.y() * B.x()));
                normal.normalize();
                return normal;
            }

    };


}

#endif