Gate2D.hpp

Go to the documentation of this file.

 
#ifndef H_GATE2D
#define H_GATE2D
 
#include <vector>
#include <fstream>
#include <cstdio>
#include <iostream>
 
 
namespace pottu {
 
 
    struct Gate2D {
 
    struct point_t {
        double x;
        double y;
    };
 
    // Points of the polygon gate. The very last point is the same
    // as the very first. This is to speed up the test.
    std::vector<point_t>  points;
 
    // One point which is outside the polygon. Needed in the test.
    point_t               pointOutside{0,0};
    // Bounding box low corner
    point_t               c00{0};
    // Bounding box high corner
    point_t               c11{0};
 
    void update() {
        if( points.size() < 4 )
        throw std::runtime_error("Too few points in points");
        c00 = points.front();
        c11 = points.front();
        for( const auto &p : points ) {
        if( p.x < c00.x )
            c00.x = p.x;
        if( p.y < c00.y )
            c00.y = p.y;
        if( p.x > c11.x )
            c11.x = p.x;
        if( p.y > c11.y )
            c11.y = p.y;
        }
        pointOutside.x = c00.x - 0.5*(c11.x-c00.x);
        pointOutside.x = c00.y - (c11.y-c00.y);
    }
    
 
    
    bool operator()( double x, double y ) const noexcept {
        if( points.size()<4 )
        return false;
        
        const point_t p1{x,y};
        int ret{0};
        auto prev = points.begin();
        auto next = prev+1;
        while( next != points.end() ) {
        ret += hasIntersection( p1, pointOutside, *prev, *next );
        prev++;
        next++;
        }
        return ret & 1;
    }
 
 
    static Gate2D createFromAsciiFile( const std::string &filename ) {
        Gate2D gate;
        std::ifstream f( filename );
        if( !f.is_open() )
        throw std::runtime_error( "Gate2D::readFromAsciiFile(): Couldnot open the file." );
            
        unsigned int row = 0;
        double       x, y;
        int          tmp;
    
        std::string  s_line, s_tmp;
        while( !f.eof() ) {
        ++row;
        std::getline( f, s_line );
        
        tmp = sscanf( s_line.c_str(), " %lf %lf", &x, &y );
        if( tmp == 2 ) {
            gate.points.push_back( {x,y} );
        }
        if( tmp != 2 && tmp != 0 && tmp != EOF ) {
            std::cerr << "Gate2D::readFromAsciiFile(): \n"
                  << "  Error on file \'" << filename << "\' on line " << row << "!\n"
                  << "  Line \'" << s_line << "\'\n"
                  << "  tmp = " << tmp << "\n";
            throw std::runtime_error( "Syntax error when reading Gate2D from an ascii file" );
        }
        }
        if( gate.points.size() < 3 )
        throw std::runtime_error( "Gate2D: Too few points in polygon." );
        gate.points.push_back( gate.points.front() );
        gate.update();
        return gate;
    }
    
 
    // Helper function 
    static int hasIntersection( point_t p0, point_t p1, point_t p2, point_t p3 ) noexcept  {
        const point_t s1{ p1.x - p0.x, p1.y - p0.y };
        const point_t s2{ p3.x - p2.x, p3.y - p2.y };
        
        point_t st{
        (-s1.y * (p0.x - p2.x) + s1.x * (p0.y - p2.y)) / (-s2.x * s1.y + s1.x * s2.y),
        ( s2.x * (p0.y - p2.y) - s2.y * (p0.x - p2.x)) / (-s2.x * s1.y + s1.x * s2.y) };
        
        return st.x >= 0 && st.x <= 1 && st.y >=0 && st.y <= 1;
    }
 
    };
 
}
 
#endif