STP_BV.h

Go to the documentation of this file.

#ifndef __STP_BV_H
#  define __STP_BV_H
 
#  pragma once
#  include <list>
#  include <map>
#  include <sch/STP-BV/STP_Feature.h>
#  include <sch/S_Object/S_ObjectNormalized.h>
#  include <sch/sch_api.h>
#  include <vector>
 
#  ifdef WITH_BOOST_1_36
#    include <sch/boost/archive/detail/oserializer.hpp>
#  endif
#  include <boost/serialization/split_member.hpp>
 
namespace sch
{
 
enum ArchiveType
{
  BINARY_ARCHIVE,
  TEXT_ARCHIVE
};
 
struct Geometry
{
  enum GeometryType
  {
    LINE,
    TRIANGLE,
    SPHERE
  };
 
  GeometryType type;
  Point3 color;
  Scalar radius; // for spheres only
  Point3 center;
  Matrix3x3 rotation;
  std::vector<Vector3> vertex;
  std::vector<Vector3> normal;
 
  Geometry(GeometryType t) : type(t), color(0, 0, 0), radius(0), center(0, 0, 0), rotation(1, 0, 0, 0, 1, 0, 0, 0, 1) {}
};
 
typedef struct s_toruslinkedBV
{
  int buffer[4];
  template<class Archive>
  void serialize(Archive & ar, const unsigned int /*version*/)
  {
    ar & buffer;
  }
} toruslinkedBV;
 
typedef struct s_Triangle
{
  s_Triangle() {}
  s_Triangle(const Point3 & vertex1, const Point3 & vertex2, const Point3 & vertex3);
 
  template<class Archive>
  void serialize(Archive & ar, const unsigned int /*version*/)
  {
    ar & m_vertex1 & m_vertex2 & m_vertex3;
  }
 
  Point3 m_vertex1;
  Point3 m_vertex2;
  Point3 m_vertex3;
} Triangle;
 
typedef struct s_SphereApproxim
{
  s_SphereApproxim(std::vector<Point3> & vertices, int step, const Point3 & sphereCenter, double sphereRadius);
 
  void operator()(const Triangle & vertices, const int & currentStep) const;
 
  template<class Archive>
  void serialize(Archive & ar, const unsigned int /*version*/)
  {
    ar & m_vertices & m_step & m_sphereCenter & m_sphereRadius;
  }
 
  std::vector<Point3> & m_vertices;
  int m_step;
  Point3 m_sphereCenter;
  Scalar m_sphereRadius;
} SphereApproxim;
 
typedef struct s_PointsComparator
{
  s_PointsComparator();
 
  void setData(const Point3 & axis, const std::vector<Point3> & points);
 
  bool operator()(unsigned int id1, unsigned int id2) const;
 
  template<class Archive>
  void serialize(Archive & ar, const unsigned int /*version*/)
  {
    ar & m_axis & m_points;
  }
 
  Point3 m_axis;
  std::vector<Point3> m_points;
} PointsComparator;
 
class STP_BV : public S_ObjectNormalized
{
public:
  SCH_API STP_BV(void);
  SCH_API STP_BV(const STP_BV &);
 
  SCH_API virtual ~STP_BV(void);
 
  SCH_API virtual STP_BV & operator=(const STP_BV &);
 
  SCH_API virtual STP_BV * clone() const;
 
  SCH_API virtual Point3 l_Support(const Vector3 & v, int & lastFeature) const;
 
  SCH_API virtual S_ObjectType getType() const;
 
  SCH_API virtual void constructFromFile(const std::string & filename);
  SCH_API virtual void constructFromFileWithGL(const std::string & filename)
  {
    constructFromFile(filename);
  }
 
  SCH_API virtual void loadFromBinary(const std::string & filename);
 
  SCH_API virtual void saveToBinary(const std::string & filename);
 
  SCH_API void saveTreeInFile(const std::string & treefilename, ArchiveType type = TEXT_ARCHIVE);
 
  SCH_API void addPatch(STP_Feature * patch);
 
  SCH_API void printSupportTree(std::string filename) const;
 
  SCH_API virtual Scalar supportH(const Vector3 & v) const;
 
  SCH_API virtual Point3 supportNaive(const Vector3 & v) const;
  SCH_API virtual Point3 supportFarthestNeighbour(const Vector3 & v, int & lastFeature) const;
  SCH_API virtual Point3 supportFarthestNeighbourPrime(const Vector3 & v, int & lastFeature) const;
  SCH_API virtual Point3 supportHybrid(const Vector3 & v, int & lastFeature) const;
  SCH_API virtual Point3 supportFirstNeighbour(const Vector3 & v, int & lastFeature) const;
  SCH_API virtual Point3 supportFirstNeighbourPrime(const Vector3 & v, int & lastFeature) const;
 
  SCH_API virtual bool ray_cast(const Point3 & source, const Point3 & target, Scalar & param, Vector3 & normal) const;
 
  SCH_API int getFeaturesNumber() const;
 
  const std::vector<sch::Geometry> & getGeometries() const;
 
  template<class Archive>
  void load(Archive & ar, const unsigned int /*version*/)
  {
    ar & boost::serialization::base_object<S_ObjectNormalized>(*this);
    ar & m_patches;
    ar & m_patchesSize;
    updateFastPatches();
  }
 
  template<class Archive>
  void save(Archive & ar, const unsigned int /*version*/) const
  {
    ar & boost::serialization::base_object<S_ObjectNormalized>(*this);
    ar & m_patches;
    ar & m_patchesSize;
  }
 
  Scalar getBigRadius() const
  {
    return _R;
  }
 
  Scalar getSmallRadius() const
  {
    return _r;
  }
 
  BOOST_SERIALIZATION_SPLIT_MEMBER()
 
protected:
  SCH_API void loadTreeFromFile(const std::string & treefilename, ArchiveType type = TEXT_ARCHIVE);
 
  SCH_API void computeArcPointsBetween(const Point3 & p1,
                                       const Point3 & p2,
                                       const Point3 & center,
                                       int step,
                                       std::vector<Point3> & res) const;
 
  SCH_API void computeConePointsBetween(const Point3 & p1,
                                        const Point3 & p2,
                                        Vector3 axis,
                                        int step,
                                        std::vector<Point3> & res,
                                        Matrix3x3 & homo);
 
  SCH_API Point3 computeLinesCommonPoint(const Point3 & l1p1,
                                         const Point3 & l1p2,
                                         const Point3 & l2p1,
                                         const Point3 & l2p2) const;
 
  SCH_API Point3 computeCenter(const std::vector<Point3> & points);
 
  SCH_API void updateFastPatches();
 
  std::vector<STP_Feature *> m_patches;
 
  STP_Feature ** m_fastPatches;
  STP_Feature ** m_lastPatches;
  int m_patchesSize;
  Scalar _r, _R;
 
  std::vector<Geometry> geometries_;
};
} // namespace sch
 
#endif