simple_polygon.h

Go to the documentation of this file.

/* Author(s) :    Francois Mauger <mauger@lpccaen.in2p3.fr>
 * Creation date: 2015-07-09
 * Last modified: 2015-07-09
 *
 * License:
 *
 * Description:
 *
 *   A simple polygon in 2D space
 *
 * History:
 *
 */

#ifndef GEOMTOOLS_SIMPLE_POLYGON_H
#define GEOMTOOLS_SIMPLE_POLYGON_H

// Standard library:
#include <vector>
#include <string>

// Third party:
// - Bayeux/mygsl:
#include <mygsl/min_max.h>

// This project:
#include <geomtools/utils.h>
#include <geomtools/i_shape_2d.h>
#include <geomtools/i_polygon.h>

namespace geomtools {

  // Forward declaration:
  class triangle;

  class simple_polygon : public i_shape_2d,
                         public i_polygon
  {

  public:

    enum build_mode_type {
      BUILD_MODE_INVALID     = 0, 
      BUILD_MODE_BY_VERTICES = 1, 
      BUILD_MODE_BY_SEGMENTS = 2  
    };

    static build_mode_type build_mode_from_label(const std::string &);

    static std::string label_from_build_mode(build_mode_type);

    static const std::string & simple_polygon_label();

    bool is_valid() const;

    virtual std::string get_shape_name() const;

    struct wall_segment_type {
      wall_segment_type();
      vector_2d start;
      vector_2d stop;
      double left_thickness;
      double right_thickness;
      double start_angle;
      double stop_angle;
    };

    typedef std::vector<wall_segment_type> wall_segment_col_type;

    void set_build_mode(build_mode_type);

    build_mode_type get_build_mode() const;

    virtual double get_perimeter(uint32_t flags_ = ALL_PIECES) const;

    virtual double get_surface(uint32_t flags_ = ALL_PIECES) const;

    unsigned int get_number_of_vertices() const;

    const vector_2d & get_vertex(int) const;

    bool is_convex() const;

    void add_vertex(double x_, double y_);

    void add_vertex(const vector_2d &);

    void add_wall_segment(const vector_2d & start_,
                          const vector_2d & stop_,
                          double left_thickness_,
                          double right_thickness_,
                          double start_angle_ = 0.0,
                          double stop_angle_ = std::numeric_limits<double>::quiet_NaN());

    void add_wall_segment(const vector_2d & stop_,
                          double left_thickness_,
                          double right_thickness_,
                          double stop_angle_ = std::numeric_limits<double>::quiet_NaN());

    bool walls_are_terminated() const;

    simple_polygon();

    virtual ~simple_polygon();

    virtual bool is_on_surface(const vector_3d &,
                               double tolerance_ = GEOMTOOLS_PROPER_TOLERANCE) const;

    virtual vector_3d get_normal_on_surface(const vector_3d & position_,
                                            bool check_ = false,
                                            double skin_ = GEOMTOOLS_PROPER_TOLERANCE) const;

    bool is_clockwise() const;

    bool is_anticlockwise() const;

    virtual bool find_intercept(const vector_3d & from_,
                                const vector_3d & direction_,
                                face_intercept_info & intercept_,
                                double tolerance_ = GEOMTOOLS_PROPER_TOLERANCE) const;

    virtual void tree_dump(std::ostream & out_ = std::clog,
                           const std::string & title_ = "",
                           const std::string & indent_ = "",
                           bool inherit_= false) const;

    enum simple_polygon_wires_rendering_option_type {
      WR_SP_INTERNAL_EDGES = (WR_BASE_LAST << 1),    
      WR_SP_LAST           = (WR_SP_INTERNAL_EDGES), 
      WR_SP_MASK           = (WR_SP_INTERNAL_EDGES
                              )   
    };

    virtual void generate_wires_self(wires_type & wires_,
                                     uint32_t options_ = 0) const;

    virtual unsigned int compute_vertexes(vertex_col_type & vertexes_) const;

    unsigned int number_of_triangles() const;

    const triangle & get_triangle(int index_) const;

    const mygsl::min_max & get_xrange() const;

    const mygsl::min_max & get_yrange() const;

    bool is_initialized() const;

    void initialize(const datatools::properties &, const handle_dict_type * objects_ = 0);

    void reset();

    static bool find_segment_2d_intersection(const vector_2d & a_,
                                             const vector_2d & b_,
                                             const vector_2d & c_,
                                             const vector_2d & d_,
                                             vector_2d & intersection_);

    static void triangulation(const std::vector<const vector_2d *> & vertices_,
                              const vector_3d & normal_,
                              std::vector<triangle> & triangles_);


  protected:

    void _set_defaults();

    void _build_by_vertices();

    void _build_by_segments();

    bool _check_vertex(const vector_2d & vtx_, bool no_first_check_ = false) const;

    void _compute_normal();

    void _add_vertex(const vector_2d & vtx_);

    void _add_wall_segment(const vector_2d & start_,
                           const vector_2d & stop_,
                           double left_thickness_,
                           double right_thickness_,
                           double start_angle_,
                           double stop_angle_);

    void _at_initialize();

  private:

    build_mode_type _build_mode_; 
    std::vector<vector_2d> _vertices_; 
    wall_segment_col_type _wall_segments_; 

    // Working data:
    bool _convex_;
    mygsl::min_max _xrange_; 
    mygsl::min_max _yrange_; 
    vector_3d _normal_; 
    std::vector<triangle> _triangles_; 

    // Registration interface :
    GEOMTOOLS_OBJECT_3D_REGISTRATION_INTERFACE(simple_polygon)

  };

} // end of namespace geomtools

#endif // GEOMTOOLS_SIMPLE_POLYGON_H

/*
** Local Variables: --
** mode: c++ --
** c-file-style: "gnu" --
** tab-width: 2 --
** End: --
*/