CollisionElement.h

Go to the documentation of this file.

/******************************************************************************
*       SOFA, Simulation Open-Framework Architecture, version 1.0 beta 3      *
*                (c) 2006-2008 MGH, INRIA, USTL, UJF, CNRS                    *
*                                                                             *
* This library is free software; you can redistribute it and/or modify it     *
* under the terms of the GNU Lesser General Public License as published by    *
* the Free Software Foundation; either version 2.1 of the License, or (at     *
* your option) any later version.                                             *
*                                                                             *
* This library is distributed in the hope that it will be useful, but WITHOUT *
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or       *
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License *
* for more details.                                                           *
*                                                                             *
* You should have received a copy of the GNU Lesser General Public License    *
* along with this library; if not, write to the Free Software Foundation,     *
* Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301 USA.          *
*******************************************************************************
*                              SOFA :: Framework                              *
*                                                                             *
* Authors: M. Adam, J. Allard, B. Andre, P-J. Bensoussan, S. Cotin, C. Duriez,*
* H. Delingette, F. Falipou, F. Faure, S. Fonteneau, L. Heigeas, C. Mendoza,  *
* M. Nesme, P. Neumann, J-P. de la Plata Alcade, F. Poyer and F. Roy          *
*                                                                             *
* Contact information: contact@sofa-framework.org                             *
******************************************************************************/
#ifndef SOFA_CORE_COLLISIONELEMENT_H
#define SOFA_CORE_COLLISIONELEMENT_H

#include <vector>

namespace sofa
{

namespace core
{

class CollisionModel;
class CollisionElementIterator;

class BaseCollisionElementIterator
{
public:
    typedef std::vector<int>::const_iterator VIterator;

    BaseCollisionElementIterator(int index=0)
    : index(index), it(emptyVector.begin()), itend(emptyVector.end())
    {
    }

    BaseCollisionElementIterator(int index, VIterator it, VIterator itend)
    : index(index), it(it), itend(itend)
    {
    }

    BaseCollisionElementIterator(VIterator it, VIterator itend)
    : index(-1), it(it), itend(itend)
    {
    if (it != itend) index = *it;
    }


    void next()
    {
    if (it == itend)
        ++index;
    else
    {
        ++it;
        if (it != itend) index = *it;
    }
    }

    void operator++()
    {
    next();
    }

    void operator++(int)
    {
    next();
    }

    int getIndex() const
    {
        return index;
    }

    const VIterator& getVIterator() const
    {
        return it;
    }

    const VIterator& getVIteratorEnd() const
    {
        return itend;
    }


protected:
    int index;      
    VIterator it; 
    VIterator itend; 
    static std::vector<int> emptyVector; 
};

template<class TModel>
class TCollisionElementIterator : public BaseCollisionElementIterator
{
public:
    typedef TModel Model;
    typedef std::vector<int>::const_iterator VIterator;

    TCollisionElementIterator(Model* model=NULL, int index=0)
    : BaseCollisionElementIterator(index), model(model)
    {
    }

    TCollisionElementIterator(Model* model, int index, VIterator it, VIterator itend)
    : BaseCollisionElementIterator(index, it, itend), model(model)
    {
    }

    TCollisionElementIterator(Model* model, VIterator it, VIterator itend)
    : BaseCollisionElementIterator(it, itend), model(model)
    {
    }


    template<class Model2>
    bool operator==(const TCollisionElementIterator<Model2>& i) const
    {
        return this->model == i.getCollisionModel() && this->index == i.getIndex();
    }

    template<class Model2>
    bool operator!=(const TCollisionElementIterator<Model2>& i) const
    {
        return this->model != i.getCollisionModel() || this->index != i.getIndex();
    }

    bool valid() const
    {
        return model!=NULL;
    }

    Model* getCollisionModel() const
    {
        return model;
    }



    std::pair<CollisionElementIterator,CollisionElementIterator> getInternalChildren() const;

    std::pair<CollisionElementIterator,CollisionElementIterator> getExternalChildren() const;

    bool isLeaf ( ) const
    {
        return model->isLeaf(index);
    }

    bool canCollideWith(TCollisionElementIterator<Model>& elem)
    {
        return model->canCollideWithElement(index, elem.model, elem.index);
    }

    double getProximity() { return model->getProximity(); }

    double getContactStiffness() { return model->getContactStiffness(index); }

    double getContactFriction() { return model->getContactFriction(index); }


    void draw()
    {
        model->draw(index);
    }



protected:
    Model* model;   
};

class CollisionElementIterator : public TCollisionElementIterator<CollisionModel>
{
public:
    CollisionElementIterator(CollisionModel* model=NULL, int index=0)
    : TCollisionElementIterator<CollisionModel>(model, index)
    {
    }

    CollisionElementIterator(CollisionModel* model, VIterator it, VIterator itend)
    : TCollisionElementIterator<CollisionModel>(model, it, itend)
    {
    }

    CollisionElementIterator(CollisionModel* model, int index, VIterator it, VIterator itend)
    : TCollisionElementIterator<CollisionModel>(model, index, it, itend)
    {
    }

    template<class DerivedModel>
    CollisionElementIterator(const TCollisionElementIterator<DerivedModel>& i)
    : TCollisionElementIterator<CollisionModel>(i.getCollisionModel(), i.getIndex(), i.getVIterator(), i.getVIteratorEnd())
    {
    }

    template<class DerivedModel>
    void operator=(const TCollisionElementIterator<DerivedModel>& i)
    {
        this->model = i.getCollisionModel();
        this->index = i.getIndex();
    this->it = i.getVIterator();
    this->itend = i.getVIteratorEnd();
    }
};


template<class Model>
std::pair<CollisionElementIterator,CollisionElementIterator> TCollisionElementIterator<Model>::getInternalChildren() const
{
    return model->getInternalChildren(index);
}

template<class Model>
std::pair<CollisionElementIterator,CollisionElementIterator> TCollisionElementIterator<Model>::getExternalChildren() const
{
    return model->getExternalChildren(index);
}

} // namespace core

} // namespace sofa

#endif