PostFilter.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.
 */
 
#include <map>
#include <deque>
#include "Ray/Ray.h"
 
#ifndef POST_FILTER_H
    #define POST_FILTER_H
 
typedef std::map<signature, std::deque<Ray*>> families;
typedef std::list<Event*> sequence;
typedef std::map<sequence, std::deque<Ray*>> sequenceMap;
 
class PostFilter : public Base
{
public:
    PostFilter(std::deque<Ray*>* tabRay) : _tabRays(tabRay) {}
    ~PostFilter()
    {
        _tabRays = NULL;
    }
 
    virtual unsigned int Process()
    {
        return 0;
    }
 
    inline virtual unsigned int buildFamilies(families& mapFamilies, typeevent typeEv)
    {
        for (unsigned int i = 0; i < _tabRays->size(); i++)
        {
            mapFamilies[_tabRays->at(i)->getSignature(typeEv)].push_back(_tabRays->at(i));
        }
 
        return mapFamilies.size();
    }
 
    inline virtual void rebuildTabRays(families& mapFamilies)
    {
        _tabRays->clear();
 
        // Relecture des familles
        std::map<signature, std::deque<Ray*>>::iterator it_families;
        for (it_families = mapFamilies.begin(); it_families != mapFamilies.end(); it_families++)
        {
            std::deque<Ray*>& aTabRay = (*it_families).second; // Get list of Rays
            for (unsigned int i = 0; i < aTabRay.size(); i++)
            {
                _tabRays->push_back(aTabRay.at(i));
            }
        }
    }
 
    inline virtual sequenceMap buildSequenceMap(const signature& sig, std::vector<Ray*> tabRay,
                                                const typeevent& evType)
    {
        sequenceMap seqMap;
 
        for (unsigned int i = 0; i < tabRay.size(); i++)
        {
            sequence seq = buildSequence(sig, tabRay.at(i), evType);
            seqMap[seq].push_back(tabRay.at(i));
        }
 
        return seqMap;
    }
 
    inline decimal minimum_distance(const decimal& thickness, const decimal& d_R) const
    {
        return sqrt(thickness * thickness + d_R * d_R);
    }
 
protected:
    inline virtual sequence buildSequence(const signature& sig, Ray* ray, const typeevent& evType)
    {
        sequence res;
 
        for (unsigned int i = 0; i < ray->getNbEvents(); i++)
        {
            if (ray->getEvents()->at(i).get()->getType() == evType)
            {
                res.push_back(ray->getEvents()->at(i).get());
            }
        }
 
        return res;
    }
    inline virtual std::deque<Ray*>::iterator erase_element(std::deque<Ray*>& tabRays,
                                                            std::deque<Ray*>::iterator& iter)
    {
        delete (*iter);
        (*iter) = NULL;
 
        return tabRays.erase(iter);
    }
 
protected:
    std::deque<Ray*>* _tabRays; 
};
 
#endif // POST_FILTER_H