Contact.h

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

#ifndef _CONTACT_H
#define _CONTACT_H

#include <iostream>
#include <list>
#include <boost/shared_ptr.hpp>
#include <Physsim/Vector3.h>
#include <Physsim/ContactData.h>

class SoNode;

namespace Physsim {

class Polyhedron;
class CollisionGeometry;


class Contact : public Base
{
        public:
                enum ContactPhaseType { eNoContact, eImpacting, eImpactResponse, eRestingStart, eResting };
                enum ContactType { eNone, eVertex, eEdge, ePoints, ePolygon, ePolyhedron };
                Contact() { _contact_type = eNone; }
                Contact(const Contact& c) { *this = c; }
                virtual ~Contact() {}
                void operator=(const Contact& c);               
                virtual bool is_struct_identical(BaseConstPtr object) const;
                virtual void clone(BasePtr& cloned, bimap<BasePtr, BasePtr>* obj_map = NULL) const;
                virtual void load_state(BaseConstPtr object, bimap<BasePtr, BasePtr>* correspondence = NULL);
                virtual void save_state(BasePtr object, bimap<BasePtr, BasePtr>* correspondence = NULL) const;
                boost::shared_ptr<std::list<Vector3> > get_vertices() const;
                void set_contact_data(boost::shared_ptr<ContactData> cdata);
                void apply_contact_forces() const;
                static void det_connected_contacts(const std::list<ContactPtr>& contacts, std::list<std::list<ContactPtr> >& sets);

                boost::shared_ptr<ContactData> get_contact_data() const { return _cdata; }

                template <class ForwardIterator>
                static boost::shared_ptr<std::list<ContactPtr> > form_singletons(ForwardIterator first, ForwardIterator last);
                
                ContactType _contact_type;

                Real _d;
                
                Vector3 _vertex;
                
                std::list<Vector3> _points;

                std::pair<Vector3, Vector3> _edge;
                
                std::list<Vector3> _surface;
                
                PolyhedronPtr _volume;

                Vector3 _normal;        

                Vector3 _normal_dot;

                std::list<std::pair<Vector3, Real> > _normal_forces;

                std::list<std::pair<Vector3, Vector3> > _tangent_forces;

                CollisionGeometryPtr _geom1, _geom2;

                ContactPhaseType _phase;

                boost::shared_ptr<std::list<Vector3> > generate_samples() const;        
                boost::shared_ptr<std::list<Vector3> > generate_samples(unsigned n) const;
                SoNode* to_visualization_data() const;
                void write_vrml(const std::string& filename) const;

        private:
                static std::pair<Real, Real> sample_Halton_2D(unsigned n);
                static Real sample_Halton_1D(unsigned n);       

                boost::shared_ptr<ContactData> _cdata;
}; // end class

std::ostream& operator<<(std::ostream& o, const Contact& c);

template <class ForwardIterator>
boost::shared_ptr<std::list<ContactPtr> > Contact::form_singletons(ForwardIterator first, ForwardIterator last)
{
        boost::shared_ptr<std::list<ContactPtr> > singletons(new std::list<ContactPtr>());

        // iterate over all contacts
        for (ForwardIterator i = first; i != last; i++)
        {
                // if the contact type is a vertex, copy *i to the list of discrete contacts
                if ((*i)->_contact_type == Contact::eVertex)
                        singletons->push_back(*i);
                else if ((*i)->_contact_type == Contact::ePoints)
                {                       
                        // create a contact for every vertex
                        for (std::list<Vector3>::const_iterator j = (*i)->_points.begin(); j != (*i)->_points.end(); j++)
                        {
                                // create a new contacts
                                ContactPtr c(new Contact(**i));
                                c->_contact_type = Contact::eVertex;
                                c->_vertex = *j;
                                singletons->push_back(c);
                        }                               
                }
                else if ((*i)->_contact_type == Contact::eEdge)
                {
                        // create two new contacts
                        ContactPtr c1(new Contact(**i));
                        ContactPtr c2(new Contact(**i));
                        c1->_contact_type = c2->_contact_type = Contact::eVertex;
                        c1->_vertex = (*i)->_edge.first;
                        c2->_vertex = (*i)->_edge.second;
                        singletons->push_back(c1);
                        singletons->push_back(c2);
                }
                else if ((*i)->_contact_type == Contact::ePolygon)
                {
                        // create a contact for every vertex
                        for (std::list<Vector3>::const_iterator j = (*i)->_surface.begin(); j != (*i)->_surface.end(); j++)
                        {
                                // create a new contacts
                                ContactPtr c(new Contact(**i));
                                c->_contact_type = Contact::eVertex;
                                c->_vertex = *j;
                                singletons->push_back(c);
                        }                               
                }
                else
                {
                        // get the vertices for the polyhedron of contact
                        const std::vector<Vector3ConstPtr>& vertices = (*i)->_volume->get_vertices();
                        
                        // turn the list of n contact points into n separate contacts of one point each
                        for (unsigned j=0; j< vertices.size(); j++)
                        {
                                ContactPtr c(new Contact(**i));
                                c->_contact_type = Contact::eVertex;
                                c->_vertex = *vertices[j];
                                singletons->push_back(c);
                        }
                }
        }

        return singletons;                      
}

} // end namespace Physsim

#endif

---