TriangleMeshPrimitive.h

/****************************************************************************
 * Copyright 2005 Evan Drumwright
 * This library is distributed under the terms of the Apache V2.0 
 * License (obtainable from http://www.apache.org/licenses/LICENSE-2.0).
 ****************************************************************************/

#ifndef _TRIANGLE_MESH_PRIMITIVE_H
#define _TRIANGLE_MESH_PRIMITIVE_H

#include <queue>
#include <fstream>
#include <iostream>
#include <cmath>
#include <list>
#include <string>
#include <Moby/Types.h>
#include <Moby/Primitive.h>

namespace Moby {

class TriangleMeshPrimitive : public Primitive
{
  public: 
    TriangleMeshPrimitive();
    TriangleMeshPrimitive(const std::string& filename, bool center = true);
    TriangleMeshPrimitive(const std::string& filename, const Ravelin::Pose3d& T, bool center = true);
    void set_edge_sample_length(double len);
    virtual osg::Node* create_visualization();
    virtual double get_bounding_radius() const { return 0.0; }
    double get_edge_sample_length() const { return _edge_sample_length; }

    virtual double calc_signed_dist(const Point3d& p) const;
    virtual void load_from_xml(boost::shared_ptr<const XMLTree> node, std::map<std::string, BasePtr>& id_map);  
    virtual void save_to_xml(XMLTreePtr node, std::list<boost::shared_ptr<const Base> >& shared_objects) const;
    virtual BVPtr get_BVH_root(CollisionGeometryPtr geom);
    virtual void get_vertices(boost::shared_ptr<const Ravelin::Pose3d> P, std::vector<Point3d>& vertices) const;
    virtual double calc_dist_and_normal(const Point3d& point, std::vector<Ravelin::Vector3d>& normals) const;
    virtual boost::shared_ptr<const IndexedTriArray> get_mesh(boost::shared_ptr<const Ravelin::Pose3d> P) { return _mesh; }
    void set_mesh(boost::shared_ptr<const IndexedTriArray> mesh);
    virtual void set_pose(const Ravelin::Pose3d& T);
    virtual double calc_signed_dist(boost::shared_ptr<const Primitive> p, Point3d& pthis, Point3d& pp) const;
    virtual bool is_convex() const;
    

  private:
    void center();
    virtual void calc_mass_properties();

    bool _convexify_inertia;

    std::map<CollisionGeometryPtr, BVPtr> _roots;
    

    boost::shared_ptr<const IndexedTriArray> _mesh;

    double _edge_sample_length;

    class AThickTri : public ThickTriangle
    {
      public:
        AThickTri(const Triangle& tri, double tol) : ThickTriangle(tri, tol) {}
        boost::shared_ptr<const IndexedTriArray> mesh;  // the mesh that this triangle came from
        unsigned tri_idx;             // the index of this triangle
    };

    void construct_mesh_vertices(boost::shared_ptr<const IndexedTriArray> mesh, CollisionGeometryPtr geom);
    void build_BB_tree(CollisionGeometryPtr geom);
    void split_tris(const Point3d& point, const Ravelin::Vector3d& normal, const IndexedTriArray& orig_mesh, const std::list<unsigned>& ofacets, std::list<unsigned>& pfacets, std::list<unsigned>& nfacets);
    bool split(boost::shared_ptr<const IndexedTriArray> mesh, BVPtr source, BVPtr& tgt1, BVPtr& tgt2, const Ravelin::Vector3d& axis);

    template <class InputIterator, class OutputIterator>
    static OutputIterator get_vertices(const IndexedTriArray& tris, InputIterator fselect_begin, InputIterator fselect_end, OutputIterator output, boost::shared_ptr<const Ravelin::Pose3d> P);

    std::map<BVPtr, std::list<unsigned> > _mesh_tris;

    std::vector<Point3d> _vertices;

    std::map<BVPtr, std::list<unsigned> > _mesh_vertices;

    std::map<BVPtr, std::list<boost::shared_ptr<AThickTri> > > _tris;

    std::pair<boost::shared_ptr<const IndexedTriArray>, std::list<unsigned> > _smesh;
}; // end class

#include "TriangleMeshPrimitive.inl"

} // end namespace 

#endif