FaceSelector.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 FACE_SELECTOR
#define FACE_SELECTOR

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


enum TYPEHISTORY
{
    HISTORY_FACE = 0,
    HISTORY_PRIMITIVE,
    HISTORY_BUILDING
};

template<typename T>
class FaceSelector : public Selector<T>
{
public:
    FaceSelector(TYPEHISTORY _modeHistory = HISTORY_FACE) : Selector<T>() { modeHistory = _modeHistory; }
    virtual ~FaceSelector() {}

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

    TYPEHISTORY getModeHistory() { return modeHistory; }

    void setModeHistory(TYPEHISTORY _modeHistory)
    {
        if (modeHistory != _modeHistory)
        {
            modeHistory = _modeHistory;
            selectedPath.clear();
        }
    }

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

        //Get the history according to the TYPEHISTORY selected
        switch (modeHistory)
        {
            case HISTORY_FACE :
                path = r->getFaceHistory();
                break;
            case HISTORY_PRIMITIVE :
                path = r->getPrimitiveHistory();
                break;
            default:
                path = r->getFaceHistory();
                break;
        }

                it = selectedPath.find(path); // search for an equivalent history among the histories of already selected rays

        // if there already is a ray with the same history
                if (it != selectedPath.end())
        {
            r->computeLongueur();
            double currentDistance = r->getLongueur();
            // if current ray has a shorter length than the already selected one
            if (currentDistance < it->second->getLongueur())
            {
                //replace the older ray by the new one
                replace = it->second->getConstructId();
                return SELECTOR_REPLACE;
            }
            else
            {     
                return SELECTOR_REJECT;
            }

        }
        return SELECTOR_ACCEPT;
    }

    virtual void insert(T* r)
    {
        typename std::map<std::vector<unsigned int>, T*, CompareToKey>::iterator it;
        std::vector<unsigned int> path;
        switch (modeHistory)
        {
            case HISTORY_FACE :
                path = r->getFaceHistory();
                break;
            case HISTORY_PRIMITIVE :
                path = r->getPrimitiveHistory();
                break;
            default:
                path = r->getFaceHistory();
                break;
        }

       
        it = selectedPath.find(path); // search for an equivalent history among the histories of already selected rays
        r->computeLongueur();

        // if there already is a ray with the same history
        if (it != selectedPath.end()) 
        {
            it->second = r;

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

                return ;
    }

    virtual bool insertWithTest(T* r)
    {
        typename std::map<std::vector<unsigned int>, T*, CompareToKey>::iterator it;
        std::vector<unsigned int> path;
        switch (modeHistory)
        {
            case HISTORY_FACE :
                path = r->getFaceHistory();
                break;
            case HISTORY_PRIMITIVE :
                path = r->getPrimitiveHistory();
                break;
            default:
                path = r->getFaceHistory();
                break;
        }

                it = selectedPath.find(path); // search for an equivalent history among the histories of already selected rays
        r->computeLongueur();
        double currentDistance = r->getLongueur();

        // if there already is a ray with the same history
        if (it != selectedPath.end())
        {
            if (currentDistance < it->second->getLongueur())
            {
                it->second = r;
                return true;
            }
            else
            {
                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
            selectedPath.insert(std::pair<std::vector<unsigned int>, T*>(path, r));
            return true;
        }
    }

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

protected:
    std::map<std::vector<unsigned int>, T*, CompareToKey> selectedPath; 
    TYPEHISTORY modeHistory;    
};

#endif