IntelliHelper.cpp

Go to the documentation of this file.

#include "IntelliHelper.h"
#include <algorithm>
#include <queue>
#include <cmath>
 
 
std::vector<Triangle> IntelliHelper::calculateTriangles(std::vector<QPoint> polyPoints){
        // helper for managing the triangle vertices and their state
        struct TriangleHelper {
                QPoint vertex;
                float interiorAngle;
                int index;
                bool isTip;
        };
 
        // calculates the inner angle of 'point'
        auto calculateInner = [](QPoint& point, QPoint& prev, QPoint& post){
                                      QPoint AP(point.x()-prev.x(), point.y()-prev.y());
                                      QPoint BP(point.x()-post.x(), point.y()-post.y());
 
                                      float topSclar = AP.x()*BP.x()+AP.y()*BP.y();
                                      float absolute = sqrt(pow(AP.x(),2.)+pow(AP.y(),2.))*sqrt(pow(BP.x(),2.)+pow(BP.y(),2.));
                                      return acos(topSclar/absolute);
                              };
 
        // gets the first element of vec for which element.isTip == true holds
        auto getTip= [](const std::vector<TriangleHelper>& vec){
                             size_t min = 0;
                             for(size_t i=0; i<vec.size(); i++) {
                                     if(vec[i].interiorAngle<vec[min].interiorAngle) {
                                             min = i;
                                     }
                             }
                             return vec[min];
                     };
 
        // get the vertex Index bevor index in relation to the container length
        auto getPrev = [](int index, int length){
                               return (index-1)>=0 ? (index-1) : (length-1);
                       };
 
        // get the vertex Index after index in relation to the container lenght
        auto getPost = [](int index, int length){
                               return (index+1)%length;
                       };
 
        // return if the vertex is a tip
        auto isTip = [](float angle){
                             return static_cast<double>(angle)<(M_PI/2.);
                     };
 
        std::vector<TriangleHelper>  Vertices;
        std::vector<Triangle> Triangles;
 
        // set up all vertices and calculate intirior angle
        for(int i=0; i<static_cast<int>(polyPoints.size()); i++) {
                TriangleHelper helper;
                int prev = getPrev(i, static_cast<int>(polyPoints.size()));
                int post = getPost(i, static_cast<int>(polyPoints.size()));
 
                helper.vertex = polyPoints[static_cast<size_t>(i)];
                helper.index = i;
 
                helper.interiorAngle = calculateInner(polyPoints[static_cast<size_t>(i)],
                                                      polyPoints[static_cast<size_t>(prev)],
                                                      polyPoints[static_cast<size_t>(post)]);
                helper.isTip = isTip(helper.interiorAngle);
                Vertices.push_back(helper);
        }
 
        // search triangles based on the intirior angles of each vertey
        while(Triangles.size() != polyPoints.size()-2) {
                Triangle tri;
                TriangleHelper smallest = getTip(Vertices);
                int prev = getPrev(smallest.index, static_cast<int>(Vertices.size()));
                int post = getPost(smallest.index, static_cast<int>(Vertices.size()));
 
                // set triangle and push it
                tri.A = Vertices[static_cast<size_t>(prev)].vertex;
                tri.B = Vertices[static_cast<size_t>(smallest.index)].vertex;
                tri.C = Vertices[static_cast<size_t>(post)].vertex;
                Triangles.push_back(tri);
 
                // update Vertice array
                Vertices.erase(Vertices.begin()+smallest.index);
                for(size_t i=static_cast<size_t>(smallest.index); i<Vertices.size(); i++) {
                        Vertices[i].index-=1;
                }
 
                // update post und prev index
                post = post-1;
                prev = prev<smallest.index ? prev : (prev-1);
 
                // calcultae neighboors of prev and post to calculate new interior angles
                int prevOfPrev = getPrev(prev, static_cast<int>(Vertices.size()));
                int postOfPrev = getPost(prev, static_cast<int>(Vertices.size()));
 
                int prevOfPost = getPrev(post, static_cast<int>(Vertices.size()));
                int postOfPost = getPost(post, static_cast<int>(Vertices.size()));
 
                // update vertices with interior angles
                // updtae prev
                Vertices[static_cast<size_t>(prev)].interiorAngle = calculateInner(Vertices[static_cast<size_t>(prev)].vertex,
                                                                                   Vertices[static_cast<size_t>(prevOfPrev)].vertex,
                                                                                   Vertices[static_cast<size_t>(postOfPrev)].vertex);
                Vertices[static_cast<size_t>(prev)].isTip = isTip(Vertices[static_cast<size_t>(prev)].interiorAngle);
                // update post
                Vertices[static_cast<size_t>(post)].interiorAngle = calculateInner(Vertices[static_cast<size_t>(post)].vertex,
                                                                                   Vertices[static_cast<size_t>(prevOfPost)].vertex,
                                                                                   Vertices[static_cast<size_t>(postOfPost)].vertex);
                Vertices[static_cast<size_t>(post)].isTip = isTip(Vertices[static_cast<size_t>(post)].interiorAngle);
        }
        return Triangles;
}
 
bool IntelliHelper::isInPolygon(std::vector<Triangle> &triangles, QPoint &point){
        for(auto triangle : triangles) {
                if(IntelliHelper::isInTriangle(triangle, point)) {
                        return true;
                }
        }
        return false;
}