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