ADF.h

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

#ifndef _PHYSSIM_ADF_H_
#define _PHYSSIM_ADF_H_

#include <boost/shared_ptr.hpp>
#include <boost/enable_shared_from_this.hpp>
#include <list>
#include <vector>
#include <Physsim/Types.h>
#include <Physsim/TriangleMesh.h>
#include <Physsim/Vector3.h>

namespace Physsim {

class ADF : public boost::enable_shared_from_this<ADF>
{
        public:
                ADF();
                ADF(boost::shared_ptr<ADF> parent, unsigned recursion_level, const Vector3& lo_bounds, const Vector3& hi_bounds);
                ADF(boost::shared_ptr<ADF> parent, unsigned recursion_level, const std::vector<Vector3ConstPtr>& vertices);
                Real calc_signed_distance(const Vector3& point) const;
                const std::vector<Vector3ConstPtr>& get_vertices() const { return _vertices; }
                void set_distances(const std::vector<Real>& distances);

                template <class ForwardIterator>
                void set_distances(ForwardIterator first, ForwardIterator last);
                void get_samples(std::vector<Vector3>& samples) const;
                void reset();
                void simplify(Real epsilon);
                void get_bounds(Vector3& lo, Vector3& hi) const;
                void set_bounds(const Vector3& lo_bound, const Vector3& hi_bound);
                static boost::shared_ptr<ADF> build_ADF_iso_inside_focus(const std::vector<TriangleConstPtr>& mesh, unsigned max_recursion, Real epsilon);
                const std::vector<Real>& get_distances() const { return _distances; }
                static boost::shared_ptr<ADF> intersect(boost::shared_ptr<ADF> adf1, boost::shared_ptr<ADF> adf2, Real epsilon, unsigned recursion_limit);
                bool contains(const Vector3& point) const;
                unsigned count_cells() const;
                bool generate_iso_sample(Vector3& sample, Real epsilon) const;
                void get_all_leaf_nodes(std::list<boost::shared_ptr<ADF> >& leafs) const;
                void get_all_cells(std::list<boost::shared_ptr<ADF> >& cells) const;
                void determine_normal(const Vector3& point, Vector3& normal) const;
                bool intersect_seg_iso_surface(const std::pair<Vector3, Vector3>& seg, Vector3& isect) const;

                void set_parent(boost::shared_ptr<ADF> parent) { _parent = parent; }

                boost::shared_ptr<ADF> get_parent() const { return (_parent.expired()) ? boost::shared_ptr<ADF>() : boost::shared_ptr<ADF>(_parent); }

                bool is_leaf() const { return _children.empty(); }

                unsigned get_recursion_level() const { return _recursion_level; }

                void set_recursion_level(unsigned level) { _recursion_level = level; }

                void subdivide();

                const std::vector<boost::shared_ptr<ADF> >& get_children() const { return _children; }

        private:
                static Real calc_max_distance(boost::shared_ptr<ADF> adf1, boost::shared_ptr<ADF> adf2, const Vector3& point);
                static Real tri_linear_interp(const std::vector<Vector3ConstPtr>& x, const std::vector<Real>& q, const Vector3& p);
                boost::shared_ptr<ADF> is_cell_occupied(const Vector3& point) const;
                unsigned get_sub_volume_idx(const Vector3& point) const;

                static const unsigned OCT_CHILDREN = 8;
                static const unsigned BOX_VERTICES = 8;
                std::vector<boost::shared_ptr<ADF> > _children;
                boost::weak_ptr<ADF> _parent;
                std::vector<Vector3ConstPtr> _vertices;
                unsigned _recursion_level;
                std::vector<Real> _distances;
                Vector3 _lo_bounds, _hi_bounds;
}; // end class

std::ostream& operator<<(std::ostream& out, const ADF& adf);

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


template <class ForwardIterator>
void ADF::set_distances(ForwardIterator first, ForwardIterator last)
{
        // setup the vector of distances
        _distances = std::vector<Real>(BOX_VERTICES);

        // compute and set the distances
        for (unsigned i=0; i< BOX_VERTICES; i++)
                _distances[i] = TriangleMesh::calc_signed_distance(first, last, *_vertices[i]);
}

} // end namespace

#endif

---