CoPlanaritySelector.h

Go to the documentation of this file.

/*
 * Copyright (C) <2012> <EDF-R&D> <FRANCE>
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 * This program 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 General Public License for more details.
 * You should have received a copy of the GNU General Public License along
 * with this program; if not, write to the Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/

#ifndef COPLANARITY_SELECTOR
#define COPLANARITY_SELECTOR

#include "Selector.h"
#include <map>
#include <vector>



template<typename T>
class CoPlanaritySelector : public Selector<T>
{
public:
        CoPlanaritySelector() : Selector<T>(){}
    virtual ~CoPlanaritySelector() {}

    virtual Selector<T>* Copy()
    {
        CoPlanaritySelector* newSelector = new CoPlanaritySelector();
        newSelector->setIsDeletable(this->deletable);
        return newSelector;
    }
    virtual void reset() { selectedRays.clear(); return; }




        bool haveCoPlanarEvents(T* r1,T* r2){

                if(r1->getEvents()->size()==r2->getEvents()->size()){

                        for(unsigned int i=0;i<r1->getEvents()->size();i++){
                                Event* ev1 = r1->getEvents()->at(i).get();
                                Event* ev2 = r2->getEvents()->at(i).get();

                                if(coPlanarityTest(ev1,ev2))
                                        return true;
                        }
                }
                return false;

        }

        bool areBothReflections(Event* ev1,Event* ev2){
                return ev1->getType()==SPECULARREFLEXION && ev2->getType()==SPECULARREFLEXION;
        }

        bool coPlanarityTest(Event* ev1,Event* ev2){

                // If any of the two events is not a reflection, events are not co-planar
                if(areBothReflections(ev1,ev2)){

                        vec3 n1=ev1->getShape()->getNormal();
                        vec3 n2=ev2->getShape()->getNormal();

                        // Check if the normals are equal
                        if( n1.compare(n2)){
                                vec3 v  = ev2->getPosition() - ev1->getPosition();
                                v.normalize();

                                // Check if the faces are in the same plane
                                if(v*n1 < EPSILON_4 && v*n2 < EPSILON_4)
                                        return true;
                        }
                }

                return false;
        }

    virtual SELECTOR_RESPOND canBeInserted(T* r, unsigned long long& replace)
    {
                
        typename std::map<std::vector<unsigned int>, vector<T*>, CompareToKey>::iterator it;

        std::vector<unsigned int> event_signature = r->getEventSignature();

                it = selectedRays.find(event_signature); 

        // if there already is a ray with the same event signatures
                if (it != selectedRays.end())
        {
            r->computeLongueur();
            //double currentDistance = r->getLongueur();

                        vector<T*> rays=it->second;
                        cerr<<"rays : "<<rays.size()<<endl;
                        /*for(unsigned int i=0;i<rays.size();i++){

                                
                                Ray* r2 = rays.at(i);
                                if (currentDistance < r2->getLongueur())
                                {
                                        //replace the older ray by the new one
                                        replace = r2->getConstructId();
                                        return SELECTOR_REPLACE;
                                }
                                else
                                {     
                                        return SELECTOR_REJECT;
                                }

                        } */
                        return SELECTOR_REJECT;
        }
        return SELECTOR_ACCEPT;
    }

    virtual void insert(T* r)
    {
                typename std::map<std::vector<unsigned int>, vector<T*>, CompareToKey>::iterator it;

        std::vector<unsigned int> event_signature = r->getEventSignature();

                it = selectedRays.find(event_signature); 

        // if there already is a ray with the same event signatures
                if (it != selectedRays.end())
        {
            r->computeLongueur();
            //double currentDistance = r->getLongueur();

                        vector<T*> rays=it->second;
                        cerr<<"rays : "<<rays.size()<<endl;

            return;
        }
        else
        {
            // if none of the already selected rays has the same history than r, then add the ray and its hsitory to selectedPath
                        vector<T*> vec;
                        vec.push_back(r);
            selectedRays.insert(std::pair<std::vector<unsigned int>, vector<T*>>(event_signature,vec));
        }
                
                return ;
    }

    virtual bool insertWithTest(T* r)
    {
                typename std::map<std::vector<unsigned int>, vector<T*>, CompareToKey>::iterator it;

        std::vector<unsigned int> event_signature = r->getEventSignature();

                it = selectedRays.find(event_signature); 

        // if there already is a ray with the same event signatures
                if (it != selectedRays.end())
        {
            r->computeLongueur();
            //double currentDistance = r->getLongueur();

                        vector<T*> rays=it->second;
                        cerr<<"rays : "<<rays.size()<<endl;

            return false;
        }
        else
        {
            // if none of the already selected rays has the same history than r, then add the ray and its hsitory to selectedPath
                        vector<T*> vec;
                        vec.push_back(r);
            selectedRays.insert(std::pair<std::vector<unsigned int>, vector<T*>>(event_signature,vec));
                        return true ;
        }
                
                return false;
    }

        virtual const char* getSelectorName(){
                return typeid(this).name();
        }

protected:
     std::map<std::vector<unsigned int>, vector<T*>, CompareToKey> selectedRays; 
};

#endif