polycone.h

Go to the documentation of this file.

/* Author(s) :    Francois Mauger <mauger@lpccaen.in2p3.fr>
 * Creation date: 2010-03-14
 * Last modified: 2015-03-12
 *
 * License:
 *
 * Description:
 *
 *   Polycone 3D solid shape
 *
 * History:
 *
 */

#ifndef GEOMTOOLS_POLYCONE_H
#define GEOMTOOLS_POLYCONE_H 1

// Standard library:
#include <iostream>
#include <string>
#include <map>
#include <limits>

// This project:
#include <geomtools/i_shape_3d.h>
#include <geomtools/i_stackable.h>
#include <geomtools/right_circular_conical_frustrum.h>

namespace geomtools {

  // Forward class declaration:
  class right_circular_conical_nappe;
  class quadrangle;
  class disk;
  class composite_surface;

  class polycone : public i_shape_3d,
                   public i_stackable
  {
  public:

    static const std::string & polycone_label();

    enum faces_mask_type {
        FACE_NONE         = face_identifier::FACE_BITS_NONE,
        FACE_INNER_SIDE   = datatools::bit_mask::bit00,
        FACE_OUTER_SIDE   = datatools::bit_mask::bit01,
        FACE_BOTTOM       = datatools::bit_mask::bit02,
        FACE_TOP          = datatools::bit_mask::bit03,
        FACE_START_ANGLE  = datatools::bit_mask::bit04,
        FACE_STOP_ANGLE   = datatools::bit_mask::bit05,
        FACE_ALL    = (FACE_INNER_SIDE
                       | FACE_OUTER_SIDE
                       | FACE_BOTTOM
                       | FACE_TOP
                       | FACE_START_ANGLE
                       | FACE_STOP_ANGLE)
      };

    enum datafile_column_mode {
      RMIN_RMAX    = 0, 
      IGNORE_RMIN  = 1, 
      RMIN_AS_RMAX = 2  
    };

    struct r_min_max
    {
      double rmin; 
      double rmax; 
    };

    struct frustrum_data {
      // Bottom parameters:
      double z1, a1, b1;
      // Top parameters:
      double z2, a2, b2;
    };

    // Type alias
    typedef std::map<double, r_min_max> rz_col_type;

    bool is_extruded () const;

    double get_xmin () const;

    double get_xmax () const;

    double get_ymin () const;

    double get_ymax () const;

    double get_zmin () const;

    double get_zmax () const;

    double get_z () const;

    bool has_partial_angle() const;

    bool has_start_angle() const;

    void set_start_angle(double);

    double get_start_angle() const;

    bool has_delta_angle() const;

    void set_delta_angle(double);

    double get_delta_angle() const;

    unsigned int number_of_frustra() const;

    void get_frustrum_data(size_t i_, frustrum_data &) const;

    const rz_col_type & points() const;

    polycone ();

    virtual ~polycone ();

    virtual std::string get_shape_name() const;

    bool is_valid () const;

    void add(double z_, double rmax_, bool compute_ = true);

    void add(double z_, double rmin_, double rmax_, bool compute_ = true);

    void initialize ();

    void initialize (const std::string & filename_);

    void initialize (const std::string & filename_,
                     double zmin_ = std::numeric_limits<double>::quiet_NaN (),
                     double zmax_ = std::numeric_limits<double>::quiet_NaN (),
                     int mode_ = RMIN_RMAX);

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

    virtual void reset ();

    bool has_top_face() const;

    bool has_bottom_face() const;

    bool has_inner_face() const;

    bool has_angle_faces() const;

    void compute_top_face(disk & top_disk_, placement &) const;

    void compute_bottom_face(disk & bottom_disk_, placement &) const;

    void compute_frustrum(right_circular_conical_frustrum & f_, placement &, int index_) const;

    void compute_inner_face(right_circular_conical_nappe & in_, placement &, int index_) const;

    void compute_outer_face(right_circular_conical_nappe & on_, placement &, int index_) const;

    right_circular_conical_frustrum::ssaf_type
    get_start_stop_angle_face_type(int index_) const;

    void compute_start_angle_face(quadrangle & qface_, triangle & tface_, placement &, int index_) const;

    void compute_stop_angle_face(quadrangle & qface_, triangle & tface_, placement &, int index_) const;

    void compute_outer_face(composite_surface & face_, placement &) const;

    void compute_inner_face(composite_surface & face_, placement &) const;

    void compute_start_angle_face(composite_surface & face_, placement &) const;

    void compute_stop_angle_face(composite_surface & face_, placement &) const;

    virtual unsigned int compute_faces(face_info_collection_type &) const;

    void compute_inner_polycone (polycone & ip_);

    void compute_outer_polycone (polycone & op_);

    virtual double get_volume (uint32_t flags_ = 0) const;

    virtual double get_surface (uint32_t mask_ = FACE_ALL) const;

    double get_z_min () const;

    double get_z_max () const;

    double get_r_max () const;

    double get_parameter ( const std::string & flag_ ) const;

    virtual bool is_inside (const vector_3d &,
                            double skin_ = GEOMTOOLS_PROPER_TOLERANCE) const;

    virtual bool is_outside (const vector_3d &,
                             double skin_ = GEOMTOOLS_PROPER_TOLERANCE) const;

    virtual face_identifier on_surface(const vector_3d &,
                                       const face_identifier & a_surface_mask = face_identifier::face_bits_any(),
                                       double a_skin = GEOMTOOLS_PROPER_TOLERANCE) const;

    virtual vector_3d get_normal_on_surface (const vector_3d & position_,
                                             const face_identifier & ) const;

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

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

    friend std::ostream & operator<< (std::ostream &, const polycone &);

    friend std::istream & operator>> (std::istream &, polycone &);

    enum polycone_wires_rendering_option_type {
      WR_POLYCONE_NO_BOTTOM_FACE      = (WR_BASE_LAST << 1),           
      WR_POLYCONE_NO_TOP_FACE         = (WR_BASE_LAST << 2),           
      WR_POLYCONE_NO_INNER_FACE       = (WR_BASE_LAST << 3),           
      WR_POLYCONE_NO_OUTER_FACE       = (WR_BASE_LAST << 4),           
      WR_POLYCONE_NO_START_ANGLE_FACE = (WR_BASE_LAST << 5),           
      WR_POLYCONE_NO_STOP_ANGLE_FACE  = (WR_BASE_LAST << 6),           
      WR_POLYCONE_LAST                = (WR_POLYCONE_NO_STOP_ANGLE_FACE),  
      WR_POLYCONE_MASK                = (WR_POLYCONE_NO_BOTTOM_FACE
                                         | WR_POLYCONE_NO_TOP_FACE
                                         | WR_POLYCONE_NO_INNER_FACE
                                         | WR_POLYCONE_NO_OUTER_FACE
                                         | WR_POLYCONE_NO_START_ANGLE_FACE
                                         | WR_POLYCONE_NO_STOP_ANGLE_FACE) 
    };

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

  protected:

    virtual void _build_bounding_data();

    void _set_defaults();

    virtual void _at_lock();

  private:

    void _compute_surfaces_();

    void _compute_volume_();

    void _compute_limits_();

    void _compute_misc_();

    void _compute_all_();

    // Interpolation:
    void _build_from_envelope_and_skin_ (double thickness_,
                                         double step_,
                                         double zmin_,
                                         double zmax_);

    void _build_from_envelope_and_skin_ (double thickness_, double step_ = 0.0);

  private:

    // Parameters:
    rz_col_type _points_; 
    double _start_angle_; 
    double _delta_angle_; 

    // Working data:
    bool     _computed_; 
    boost::logic::tribool _has_top_face_;
    boost::logic::tribool _has_bottom_face_;
    boost::logic::tribool _has_inner_face_;
    double  _top_surface_;
    double  _bottom_surface_;
    double  _outer_side_surface_;
    double  _inner_side_surface_;
    double  _start_angle_surface_;
    double  _stop_angle_surface_;
    double  _outer_volume_;
    double  _inner_volume_;
    double  _volume_;
    double  _z_min_;
    double  _z_max_;
    double  _r_max_;
    bool    _extruded_;

    // Registration interface :
    GEOMTOOLS_OBJECT_3D_REGISTRATION_INTERFACE(polycone)

  };

} // end of namespace geomtools

#endif // GEOMTOOLS_POLYCONE_H

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