i_shape_3d.h

Go to the documentation of this file.

// \file geomtools/i_shape_3d.h
/* Author(s):     Francois Mauger <mauger@lpccaen.in2p3.fr>
 * Creation date: 2008-05-23
 * Last modified: 2017-02-22
 *
 * Description:
 *
 *  Interface for all 3D shaped volumes
 *
 */

#ifndef GEOMTOOLS_I_SHAPE_3D_H
#define GEOMTOOLS_I_SHAPE_3D_H 1

// Standard library:
#include <string>

// Third party:
// - Boost:
#include <boost/utility.hpp>
#include <boost/optional.hpp>
// - Bayeux/datatools:
#include <datatools/handle.h>
#include <datatools/ocd_macros.h>

// This project:
#include <geomtools/utils.h>
#include <geomtools/i_object_3d.h>
#include <geomtools/i_stackable.h>
#include <geomtools/bounding_data.h>
#include <geomtools/i_find_intercept.h>
#include <geomtools/face_info.h>
#include <geomtools/i_wires_3d_rendering.h>

namespace datatools {
  // Forward class declaration:
  class properties;
}

namespace geomtools {

  // Forward class declaration:
  class i_shape_2d;

  class i_shape_3d
    : public i_object_3d
    , public i_wires_3d_rendering
    , public i_find_intercept
  {
  public:

    static const double DEFAULT_SKIN;
    static const double ZERO_SKIN;
    static const double USING_PROPER_SKIN;

    static double get_default_skin();

    static double get_zero_skin();

    static double get_proper_skin();

    // Return the property key for the volume property
    static const std::string & volume_key();

    // Return the property key for the surface property
    static const std::string & surface_key();

    /* Check if a 3D-shape can be stacked using some
     *  stacking algorithms. There are 2 checks:
     *  check #1: checks if the instance owns a valid
     *  embedded 'stackable_data' instance.
     *  check #2: if check #1 fails, check if the instance inherits
     *  the 'i_stackable' interface.
     */
    // static bool is_stackable(const i_shape_3d &);

    // Check if the shape is natively stackable (i.e. inherits the 'geomtools::i_stackable' interface)
    bool is_native_stackable() const;

    static bool pickup_stackable(const i_shape_3d &, stackable_data &);

    static bool check_stackability(const i_shape_3d &, const stackable::stackability_mode);

    const stackable_data & get_stackable_data() const;

    bool has_stackable_data() const;

    bool owns_stackable_data() const;

    void set_stackable_data(const stackable_data & a_stackable_data);

    void set_stackable_data(const stackable_data * a_stackable_data);

    void reset_stackable_data();

    int get_dimensional() const;

    double get_skin(double a_skin) const;

    double get_skin() const;

    void set_skin(double a_skin);

    i_shape_3d();

    i_shape_3d(double a_skin);

    i_shape_3d(double a_skin_, double angular_tolerance_);

    i_shape_3d(const i_shape_3d &);

    i_shape_3d & operator=(const i_shape_3d &);

    virtual ~i_shape_3d();

    virtual bool is_composite() const;

    virtual bool using_face_id_bits() const;

    virtual bool using_face_id_index() const;

    virtual bool using_face_id_part_index() const;

    virtual void make_any_face(face_identifier &) const;

    virtual bool has_number_of_faces() const;

    virtual unsigned int get_number_of_faces() const;

    virtual bool volume_can_be_forced() const;

    virtual bool has_forced_volume() const;

    void set_forced_volume(double volume_);

    double get_forced_volume() const;

    virtual bool has_volume(uint32_t flags_ = 0) const;

    virtual double get_volume(uint32_t flags_ = 0) const;

    double get_effective_volume() const;

    virtual bool has_surface(uint32_t flags_ = face_identifier::FACE_BITS_ANY) const;

    virtual double get_surface(uint32_t flags_ = face_identifier::FACE_BITS_ANY) const;

    bool check_inside(const vector_3d & position_,
                      double a_skin = GEOMTOOLS_PROPER_TOLERANCE) const;

    bool check_outside(const vector_3d & position_,
                       double a_skin = GEOMTOOLS_PROPER_TOLERANCE) const;

    face_identifier check_surface(const vector_3d & position_,
                                  const face_identifier & a_surface_mask = face_identifier::FACE_BITS_ANY,
                                  double a_skin = GEOMTOOLS_PROPER_TOLERANCE) const;

    bool check_surface(const vector_3d & position_,
                       double a_skin = GEOMTOOLS_PROPER_TOLERANCE) const;

    virtual bool is_inside(const vector_3d & position_,
                           double a_skin = GEOMTOOLS_PROPER_TOLERANCE) const = 0;

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

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

    virtual vector_3d get_normal_on_surface(const vector_3d & a_position,
                                            const face_identifier & a_surface_bit) const = 0;

    bool is_on_surface(const vector_3d & position_,
                       const face_identifier & a_surface_mask = face_identifier::FACE_BITS_ANY,
                       double a_skin = GEOMTOOLS_PROPER_TOLERANCE) const;

    virtual shape_domain_flags_type where_is(const vector_3d & position_, double a_skin) const;

    virtual unsigned int compute_faces(face_info_collection_type & faces_) const;

    bool has_computed_faces() const;

    const face_info_collection_type & get_computed_faces() const;

    void reset_computed_faces();

    bool has_bounding_data() const;

    const bounding_data & get_bounding_data() const;

    void reset_bounding_data();

    void set_bounding_data(const bounding_data &);

    void build_default_bounding_data();

    virtual void tree_dump(std::ostream & a_out         = std::clog,
                           const std::string & a_title  = "",
                           const std::string & a_indent = "",
                           bool a_inherit               = false) const;

    static void init_ocd(datatools::object_configuration_description &);

    bool is_locked() const;

    void lock();

    void unlock();

  protected:

    void _set_defaults();

    virtual void _at_lock();

    virtual void _at_unlock();

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

    void _reset();

    virtual void _build_bounding_data();


    void _initialize_bounding_data(const datatools::properties & config_);


    void _initialize_stackable_data(const datatools::properties & config_);

    void _reset_bounding_data();

    bounding_data & _grab_bounding_data();

  private:

    // Work data:
    bool                   _locked_;              
    bool                   _owns_stackable_data_; 
    const stackable_data * _stackable_data_;      
    bounding_data          _bounding_data_;       
    boost::optional<double> _forced_volume_;      
    datatools::handle<face_info_collection_type> _computed_faces_; 

    // Serialization interface
    DATATOOLS_SERIALIZATION_DECLARATION()

  };

} // end of namespace geomtools

/*
// Class version:
#include <boost/serialization/version.hpp>
BOOST_CLASS_VERSION(geomtools::i_shape_3d, 0)
*/

#endif // GEOMTOOLS_I_SHAPE_3D_H

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