TriangleMesh.h

/****************************************************************************
 * Copyright 2005 Evan Drumwright
 * This library is distributed under the terms of the GNU General Public 
 * License (found in COPYING).
 ****************************************************************************/

#ifndef _TRIANGLE_MESH_H
#define _TRIANGLE_MESH_H

#include <iostream>
#include <cmath>
#include <list>
#include <string>
#include <Physsim/Types.h>
#include <Physsim/Triangle.h>
#include <Physsim/Primitive.h>
#include <Physsim/CompGeom.h>

namespace Physsim {

class TriangleMesh : public Primitive
{
        public: 
                TriangleMesh() {}
                TriangleMesh(TriangleArrayConstPtr trimesh, bool center = true);
                TriangleMesh(TriangleArrayConstPtr trimesh,  const Matrix4& T, bool center = true);
                TriangleMesh(const std::string& filename, bool center = true);
                TriangleMesh(const std::string& filename, const Matrix4& T, bool center = true);
                virtual void load_from_xml(XMLTreeConstPtr node, std::map<std::string, BasePtr>& id_map);       
                virtual void save_to_xml(XMLTreePtr node, std::list<BaseConstPtr>& shared_objects) const;
                static void write_to_obj(const std::string& filename, const std::vector<TriangleConstPtr>& mesh);
                static TriangleArrayConstPtr read_from_obj(const std::string& filename);
                static void transform_mesh(const std::vector<TrianglePtr>& mesh, const Matrix4& T);
                static void subdivide(std::vector<TrianglePtr>& mesh, Real max_tri_area);
                static TriangleArrayPtr clone_mesh(const std::vector<TriangleConstPtr>& mesh);


                template <class ForwardIterator>
                static void get_unique_vertices(ForwardIterator first, ForwardIterator last, std::list<Vector3ConstPtr>& result);

                        template <class ForwardIterator>
                static Real calc_signed_distance(ForwardIterator first, ForwardIterator last, const Vector3& point, TriangleConstPtr& closest_tri);

                template <class ForwardIterator>
                static Real calc_signed_distance(ForwardIterator first, ForwardIterator last, const Vector3& point);
}; // end class

/***************************************************************
 * Template methods follow
 **************************************************************/

template <class ForwardIterator>
void TriangleMesh::get_unique_vertices(ForwardIterator first, ForwardIterator last, std::list<Vector3ConstPtr>& result)
{
        // clear result
        result.clear();

        // get the vertices from all triangles
        for (ForwardIterator i = first; i != last; i++)
        {
                result.push_back((*i)->a());
                result.push_back((*i)->b());
                result.push_back((*i)->c());
        }

        // sort the list and make it unique
        result.erase(std::unique(result.begin(), result.end()), result.end());
}


template <class ForwardIterator>
Real TriangleMesh::calc_signed_distance(ForwardIterator first, ForwardIterator last, const Vector3& point, TriangleConstPtr& closest_tri)
{
        // we'll reuse iterators for speed -- we want to pickup where left off
        // if point is outside the mesh
        ForwardIterator i;

        // initialize minimum distance
        Real min_dist = std::numeric_limits<Real>::max();

        // first, determine whether the point is inside or outside
        bool inside = true;
        for (i = first; i != last; i++)
        {
                // compute the projected distance to the i'th face
                Real proj_dist = Vector3::dot((*i)->normal(), point) - (*i)->get_d();

                // if distance is positive, the point is visible from the face
                if (proj_dist > NEAR_ZERO)
                {
                        inside = false;
                        break;
                }
                else if (proj_dist < min_dist)
                {
                        min_dist = proj_dist;
                        closest_tri = *i;
                }
        }

        // if the point is outside, recompute the distance 
        if (!inside)
        {
                // reset the minimum distance
                min_dist = std::numeric_limits<Real>::max();

                // only calculate distance for the faces from which this point is 
                // visible, since distance computation is expensive; note that we pick
                // up where left off 
                for (; i != last; i++)
                {
                        // compute the distance to the i'th face
                        Real proj_dist = Vector3::dot((*i)->normal(), point) - (*i)->get_d();
        
                        // only compute distance for non-visible faces
                        if (proj_dist > NEAR_ZERO)
                        {
                                Vector3 closest_point;
                                Real dist = (*i)->calc_distance(point, closest_point);
                                if (dist < min_dist)
                                {
                                        min_dist = dist;
                                        closest_tri = *i;
                                }
                        }
                }
        }

        // return the distance
        return min_dist;
}

template <class ForwardIterator>
Real TriangleMesh::calc_signed_distance(ForwardIterator first, ForwardIterator last, const Vector3& point)
{
        // init a pointer to the closest triangle that we will not use..
        TriangleConstPtr pointer;
        return calc_signed_distance(first, last, point, pointer);
}

} // end namespace 

#endif

---