PairNode.h

Go to the documentation of this file.

#ifndef ATOMPAIR_H_
#define ATOMPAIR_H_

#include "pano_core/ModelFitter.h"
#include <iostream>

namespace pano {

struct PairNodeData {

    float distance;
    int  depth;
    int visited;
    bool mode;

    PairNodeData( float dist, int depth, int vis ) :
            distance(dist), depth(depth), visited(vis),
            mode(true) { }
    PairNodeData( const PairNodeData& node ) :
    distance(node.distance), depth(node.depth), visited(node.visited),
        mode(node.mode) { }
    AtomPairSet neighbors;

    static int max_depth;
    static int min_depth;
};

typedef float (*PairMatchErrFPT)(const AtomPair& pair, const PairNodeData& node_data );

typedef float (*PairBlendConfFPT)(  float err_new, float err_prv );

inline float PairConfExpLaw(  float err_new, float err_prv ) {
 double C_0   = 20.0;
 double C_1   = 0.5;
 double beta0 = 0.5;   // E=beta0 => C=C_0
 double beta1 = 100.0; // E=beta1 => C=C_1
 double alpha = 1e-2;  // lim(C)_{E->infty) = alpha
 double gamma = -1.0/(beta1-beta0) * log( (C_1-alpha) / C_0 );
 double err_net = err_new + err_prv;
 return (float) alpha + C_0 * exp( -(err_net-beta0) * gamma );
}

inline float PairConfInvLaw( float err_new, float err_prv) {
 double C_0   = 1.0;
 double eps0  = 1e-1;
 double alpha = 1e-3;  // lim(C)_{E->infty) = alpha
 double err   = err_new + err_prv; // allow previous weight somewhat
        err   = pow(err,1.5);
 return (float) alpha + C_0 / (err + eps0 );
}

inline float PairErrorInliers(const AtomPair& pair, const PairNodeData& node_data ){
   return 10*pair.result().err()*pair.result().err()   + 10/(float)pair.result().inliers();
}

inline float PairErrorSimple(const AtomPair& pair, const PairNodeData& node_data){
    return  10*pair.result().err()*pair.result().err() ;
}

inline float PairErrorAvoidCompassChain(const AtomPair& pair, const PairNodeData& node_data){ // big penalty to chaining compass atoms together
    float gamma0 = 0.0;
    if( node_data.mode      ==  true )
        gamma0 += 1e2;
    return pair.result().err() + gamma0;
}

struct PairNode{

    PairNode(PairMatchErrFPT error_func = PairErrorInliers,
     PairBlendConfFPT bconf_func = PairConfInvLaw ):
            error_func(error_func), bconf_func(bconf_func),
            node_data(INFINITY,0,false) {  }

    PairNode( const PairNode& node ) : error_func(node.error_func),
     bconf_func(node.bconf_func), node_data(node.node_data) { }

    PairMatchErrFPT     error_func;
    PairBlendConfFPT    bconf_func;
    PairNodeData node_data;

    cv::Ptr<ImageAtom> min_prev; /* The N-1 optimal atom for sub-problem
                                         terminating at 'this' Nth node */
    cv::Ptr<ImageAtom> atom;     /* 'this' Nth node in dynamic-programming-like traversal  */

    bool operator < (const PairNode& rhs){
        return node_data.distance < rhs.node_data.distance;
    }

    void setDist(const AtomPair& pair, const PairNode& prev_node);

    static void graphviz_dump(std::ostream& out, const std::map<cv::Ptr<ImageAtom>,PairNode>&  node_map);

    static void graphviz_dump_all(std::ostream& out, const std::map<cv::Ptr<ImageAtom>,PairNode>&  node_map);

};


std::ostream& operator << (std::ostream& out, const PairNode& node);

std::ostream& operator << (std::ostream& out, const AtomPair& pair);


}

#endif