pointFilter.hpp

Go to the documentation of this file.

const bool  PointFilterKey::trueValue_m(1);
const bool  PointFilterKey::falseValue_m(0);

const  CFilterStrategy  CFilterStrategy::FilterRandomStart_Strategy_s( CFilterStrategy::CF_FILTER_RANDOM_START );
const  CFilterStrategy  CFilterStrategy::FilterRandomSync_Strategy_s( CFilterStrategy::CF_FILTER_RANDOM_SYNC );
const  CFilterStrategy  CFilterStrategy::FilterSaveFirst_Strategy_s( CFilterStrategy::CF_FILTER_SAVE_FIRST );


const   std::string     CFilterStrategy::cfRandomStartStr_s( "randomStart" );
const   std::string     CFilterStrategy::cfRandomSyncStr_s ( "randomSync" );
const   std::string     CFilterStrategy::cfSaveFirstStr_s  ( "saveFirst"  );



inline PointFilterKey::PointFilterKey():        exactVanishedFocalValues_m( 0 ),
                                                        jacobianRank_m( 0 ), 
                                                        smooth_m( 0 ), 
                                                        quadricsRank_m( 0 )
{
        initRule();
}

                 
        
inline PointFilterKey::PointFilterKey(  uint16_t exactVanishedFocalValues,      
                                                        uint16_t        jacobianRank,
                                                        bool    smooth,
                                                        uint16_t        quadricsRank
                                                        ):      
                                                                exactVanishedFocalValues_m( exactVanishedFocalValues ),
                                                                jacobianRank_m( jacobianRank ), 
                                                                smooth_m( smooth ), 
                                                                quadricsRank_m( quadricsRank )
{}
        

inline PointFilterKey::PointFilterKey(std::string str) 
{
        initRule();
        //bool parsed=false;
        
        std::cerr << " creating PointFilterKey from  " << str << std::endl;

        smooth_m=-1;
                parse_info<>   pi =  boost::spirit::parse(str.c_str(), *pointFilterKeyRule_m, boost::spirit::space_p);

        if ( ! pi.full )
        {
                std::cerr << " creating PointFilterKey from  " << str << " failed" << std::endl;

                // beib Testen (CF_TEST) sollte kein harter assert stattfinden, sondern vielleicht ein Throw
                // in der scharfen Version sollte dagegen ein assert stattfinden.
                assert(false); 
        }
        assert(smooth_m!=-1);
        assert(smooth_m==falseValue_m ||smooth_m==trueValue_m);
        print( std::cerr );
        std::cerr << std::endl;
};

const rule<> *   PointFilterKey::initRule()
{


        pointFilterKeyRule_m = new rule<> (space_rule_g >> str_p("(") >> space_rule_g >> 
                        int_p[ assign_a( exactVanishedFocalValues_m ) ] >> spacy_colon_g >> 
                        int_p [ assign_a( jacobianRank_m ) ] >> spacy_colon_g  >> 
                        (str_p("false")[ assign_a( smooth_m,falseValue_m )  ] | str_p("true")[ assign_a( smooth_m,trueValue_m ) ] )  >> spacy_colon_g  >>
                        int_p[ assign_a(quadricsRank_m)] >> space_rule_g >>  
        str_p(")") >> space_rule_g);
        
        return pointFilterKeyRule_m;
}


inline void     PointFilterKey::print(std::ostream &os) const
{
        os << "( "<< exactVanishedFocalValues_m<< "," << jacobianRank_m << "," ;
        if (smooth_m)
                os << "true, ";
        else
                os << "false, ";
        os << quadricsRank_m << " )" ;
}
inline bool PointFilterKey::operator<(const PointFilterKey& pfkey)      const
{

        /*std::cerr << "key comparison" << std::endl;
        this->print(std::cerr);
        std::cerr <<   std::endl;
        pfkey.print(std::cerr);
        std::cerr <<   std::endl;*/

        if (exactVanishedFocalValues_m!=pfkey.exactVanishedFocalValues_m)
                return exactVanishedFocalValues_m<pfkey.exactVanishedFocalValues_m;

        if (jacobianRank_m!=pfkey.jacobianRank_m)
                return jacobianRank_m<pfkey.jacobianRank_m;

        if (smooth_m!=pfkey.smooth_m)
                return smooth_m<pfkey.smooth_m;

        return quadricsRank_m<pfkey.quadricsRank_m;
}






inline  PointFilterRule::PointFilterRule(): key_m(),
                                                                passFilterRate_m(1) 
{
        initRule();
};
        
inline  PointFilterRule::PointFilterRule(std::string str)  :  key_m(),
                                                                                        passFilterRate_m(1) 
{

        initRule();
        //bool parsed=false;
        

                parse_info<>   pi =  boost::spirit::parse(str.c_str(), *pointFilterRule_m, boost::spirit::space_p);

        if ( ! pi.full )
        {
                std::cerr << " creating PointFilterRule from  " << str << " failed" << std::endl;

                // beib Testen (CF_TEST) sollte kein harter assert stattfinden, sondern vielleicht ein Throw
                // in der scharfen Version sollte dagegen ein assert stattfinden.
                assert(false); 
        }
};


inline  PointFilterRule::PointFilterRule(       const PointFilterKey & key, 
                        uint64_t        filterRate              ) :     key_m(key), 
                                                                        passFilterRate_m(filterRate)
{
        initRule();
}
        
inline  PointFilterRule::PointFilterRule(       uint16_t exactVanishedFocalValues,      
                                                                uint16_t        jacobianRank,
                                                                bool    smooth,
                                                                uint16_t        quadricsRank,
                                                                uint64_t        filterRate
                                                                ):      key_m( exactVanishedFocalValues,
                                                                                 jacobianRank, smooth,  quadricsRank ),
                                                                        passFilterRate_m(filterRate)
{
        initRule();
}

inline  const rule<>*   PointFilterRule::initRule()
{
        const rule<>& keyRuleRef=key_m.getConstRuleRef();

        
        pointFilterRule_m = new rule<>( space_rule_g >> str_p("[") >> space_rule_g >>  
                                                        keyRuleRef>>  spacy_colon_g >>
                                                                int_p [ assign_a( passFilterRate_m ) ] >> space_rule_g  
                                                        >> str_p("]") >> space_rule_g 
                                                );
        return pointFilterRule_m;
}


void            PointFilterRule::print(std::ostream & os)
{
        os << "[ " ;
        key_m.print(os);
        os << ", "<< passFilterRate_m << " ] " ;

}



inline  CFilterStrategy::CFilterStrategy( CFilterStrategy::FilterStrategy strategy ):   strategy_m(strategy)
{ }

inline  CFilterStrategy::CFilterStrategy(std::string strFilterStrategy)
{
                
        strategy_m=CF_FILTER_UNDEFINED;
        const rule<>    filterStrategyRule = ( str_p(cfRandomStartStr_s.c_str())[  assign_a(strategy_m,CF_FILTER_RANDOM_START ) ] |
                                                        str_p(cfRandomSyncStr_s.c_str())[ assign_a(strategy_m,CF_FILTER_RANDOM_SYNC ) ] |
                                                        str_p(cfSaveFirstStr_s.c_str())[ assign_a(strategy_m,CF_FILTER_SAVE_FIRST ) ] 
                                        );




        parse_info<>   pi =  boost::spirit::parse(strFilterStrategy.c_str(), filterStrategyRule, boost::spirit::space_p);

        if ( ! pi.full )
        {
                std::cerr << " creating CFilterStrategy from  " << strFilterStrategy << " failed" << std::endl;

                // beib Testen (CF_TEST) sollte kein harter assert stattfinden, sondern vielleicht ein Throw
                // in der scharfen Version sollte dagegen ein assert stattfinden.
                assert(false); 
        }

        assert( strategy_m==CF_FILTER_RANDOM_START || 
                        strategy_m==CF_FILTER_RANDOM_SYNC || 
                        strategy_m==CF_FILTER_SAVE_FIRST
                );

}

inline std::string      CFilterStrategy::getValueAsString()
{
        switch (strategy_m)
        {
                case CF_FILTER_RANDOM_START:
                        return cfRandomStartStr_s ;
                        break;
                case CF_FILTER_RANDOM_SYNC:
                        return cfRandomStartStr_s ;
                        break;
                case CF_FILTER_SAVE_FIRST:
                        return cfRandomStartStr_s ;
                        break;
                default:
                        assert(false);
        }
        
}


inline void     CFPointFilter::onRuleScanned(std::string str)
{
        //PointFilterRule*  pfrule = new PointFilterRule(str);
        //addFilterRule(*pfrule);
        std::cerr << "rule "<<  str<< " scanned " << std::endl;
        PointFilterRule  pfrule(str);
        addFilterRule(pfrule);
}

inline  CFPointFilter::CFPointFilter( std::string str ,
                                  CFilterStrategy strategy, std::string name ) :        randomSeed_m( CFPointFilter::seedFromTime() ),
                                                                                                        randomSeedRef_m(randomSeed_m),
                                                                                                        strategy_m(strategy),
                                                                                                        singleRuleScannedTrigger_m( new rule_term_scanned(*this)),
                                                                                                        name_m(name)
{
        
        PointFilterRule tmp;

        const rule<> &  filterRuleRef= tmp.getRuleRef();

        // nicht zutreffenden Regel. 
        rule<> *pointFilterRule=        new rule<>(     space_rule_g  >> (((  filterRuleRef[*singleRuleScannedTrigger_m]   ) >>
                                                                 (  +(  spacy_colon_g >> filterRuleRef[*singleRuleScannedTrigger_m])  | boost::spirit:: eps_p  ) ) | boost::spirit:: eps_p)  >>  
                                                        space_rule_g 
                                                 );
        

        // Achtung: eps_p muss immer ans ende, sonst endlosschleife!
        //rule<> *pointFilterRule=      new rule<>(      space_rule_g  >> (   filterRuleRef[*singleRuleScannedTrigger_m]  | boost::spirit:: eps_p) >> space_rule_g );

        
                parse_info<>   pi =  boost::spirit::parse(str.c_str(), *pointFilterRule, boost::spirit::space_p);

        if ( ! pi.full )
        {
                std::cerr << " creating CFPointFilter from  " << str << " failed" << std::endl;

                // beib Testen (CF_TEST) sollte kein harter assert stattfinden, sondern vielleicht ein Throw
                // in der scharfen Version sollte dagegen ein assert stattfinden.
                assert(false); 
        }
        
}

inline CFPointFilter::CFPointFilter(     CFilterStrategy        strategy,
                                        std::vector<PointFilterRule>    filterRules,
                                         std::string name,
                                        long &  randomSeedRef   )               :randomSeedRef_m(randomSeedRef),
                                                                                                strategy_m(strategy),
                                                                                                singleRuleScannedTrigger_m(NULL),
                                                                                                name_m(name)
{

// fuer alle filterRules einen Eintrag in hierarchicalFilterRules_m erzeugen.
         
        BOOST_FOREACH(const PointFilterRule currentFilterRule, filterRules )
        {
                addFilterRule(currentFilterRule);
        }
}

inline CFPointFilter::CFPointFilter(     CFilterStrategy        strategy, 
                                        std::vector<PointFilterRule>    filterRules,
                                        std::string name
                                                                                )       :       randomSeed_m( CFPointFilter::seedFromTime() ),
                                                                                                randomSeedRef_m(randomSeed_m),
                                                                                                strategy_m(strategy),
                                                                                                singleRuleScannedTrigger_m(NULL),
                                                                                                name_m(name)
{

// fuer alle filterRules einen Eintrag in hierarchicalFilterRules_m erzeugen.
         
                BOOST_FOREACH(const PointFilterRule currentFilterRule, filterRules )
        {
                addFilterRule(currentFilterRule);
        }
}

inline CFPointFilter::CFPointFilter(     CFilterStrategy        strategy,       
                                                std::string     name    ) :   randomSeed_m( CFPointFilter::seedFromTime() ),
                                                                                                randomSeedRef_m(randomSeed_m),
                                                                                                strategy_m(strategy),
                                                                                                singleRuleScannedTrigger_m(NULL),
                                                                                                name_m(name)
{

         
}

inline bool CFPointFilter::pointPassedFilter(   uint16_t        exactVanishedFocalValues,
                                                uint16_t        jacobianRank,
                                                bool    smooth,
                                                uint16_t        quadricsRank) const
{
        PointFilterKey  key(exactVanishedFocalValues, jacobianRank, smooth, quadricsRank);
        

        hierarchicalFilterRuleMap_Type::const_iterator   it;

        it=hierarchicalFilterRules_m.find(key);
        if ( it==hierarchicalFilterRules_m.end() )
        {
                //std::cerr << "no filter key" << std::endl;
                //key.print(std::cerr);
                //std::cerr <<   std::endl;
                return true ;
        }
        else
        {
                //std::cerr << "found filter key" << std::endl;
                //key.print(std::cerr);
                //std::cerr <<   std::endl;

                switch (strategy_m.integral() )
                {
                        case CFilterStrategy::CF_FILTER_RANDOM_START:
                                it->second.counter_m++;
                                break;
                        case CFilterStrategy::CF_FILTER_RANDOM_SYNC:
                                it->second.counter_m=randomUInt32( &randomSeedRef_m, it->second.getPassFilterRate()-1)+1;
                                //std::cerr << "counter" << it->second.counter_m<< std::endl;
                                break;
                        case CFilterStrategy::CF_FILTER_SAVE_FIRST:
                                //std::cerr << "CF_FILTER_SAVE_FIRST counter" << it->second.counter_m<< std::endl;
                                it->second.counter_m++;
                }
                if ( it->second.getPassFilterRate()==it->second.counter_m )
                {       
                        switch (strategy_m.integral())
                        {
                                case CFilterStrategy::CF_FILTER_RANDOM_START:
                                        it->second.counter_m=0;
                                        break;
                                case CFilterStrategy::CF_FILTER_RANDOM_SYNC:
                                        break;
                                case CFilterStrategy::CF_FILTER_SAVE_FIRST:
                                        it->second.counter_m=0;
                        }
                        return true;
                }
        }
        return false;
}



inline void     CFPointFilter::addFilterRule(const PointFilterRule & rule)      
{
        uint32_t counter=0;
        assert(rule.getPassFilterRate()>=1);
        switch ( strategy_m.integral() )
        {
                case CFilterStrategy::CF_FILTER_RANDOM_START:
                        counter=randomUInt32( &randomSeedRef_m, rule.getPassFilterRate()-1)+1;
                        break;

                case CFilterStrategy::CF_FILTER_RANDOM_SYNC:
                        counter=randomUInt32( &randomSeedRef_m, rule.getPassFilterRate()-1)+1;
                        break;

                case CFilterStrategy::CF_FILTER_SAVE_FIRST:
                        counter=rule.getPassFilterRate()-1;
                        break;
                default:
                        assert(false);
        }
        hierarchicalFilterRuleMap_Type::iterator         it  = hierarchicalFilterRules_m.find(rule.getKeyConstRef() );
        if ( it != hierarchicalFilterRules_m.end() )
        {
                std::cerr << " hierarchicalFilterRules_m  dublicate entry" << std::endl;
                assert(false); 
        }
        else
        {
                hierarchicalFilterRules_m[ rule.getKeyConstRef() ] = CFPointFilter::FilterRateCounterPair(rule.getPassFilterRate(), counter );
        }
}


inline void  CFPointFilter::addFilterRule(      uint16_t        exactVanishedFocalValues,
                                                uint16_t        jacobianRank,
                                                bool    smooth,
                                                uint16_t        quadricsRank,
                                                uint32_t        filterRate )    
{
        PointFilterKey  key(exactVanishedFocalValues, jacobianRank,smooth,quadricsRank);

        PointFilterRule rule(key, filterRate);
        
        addFilterRule(rule);
}


inline void             CFPointFilter::print(std::ostream & os)
{
        hierarchicalFilterRuleMap_Type::iterator         it  = hierarchicalFilterRules_m.begin();
        while( it != hierarchicalFilterRules_m.end() )
        {
                if ( it != hierarchicalFilterRules_m.begin() )
                        os << "\n\t";
                PointFilterRule pfrule( (*it).first,(*it).second.getPassFilterRate() );
                pfrule.print(os);
        
                it++;
        }
}

inline  void            CFPointFilter::printInMacaulayStyle(std::ostream & os)
{
        os << name_m << "  =  ";
        print(os);
        os << " ;";
}