Function maxflow_inference

maxflow_python/util.cpp:117–186

void maxflow_inference(unsigned char * label, const float* img, const float * prob, const unsigned char * seed,
    int H, int W, int chns, int cls, float lambda, float sigma)
{
    // currently, only cls == 2 is supported
    typedef Graph<float, float, float> GraphType;
    /*estimated # of nodes*/ /*estimated # of edges*/
    GraphType * g = new GraphType(H*W, 2*H*W);
    g->add_node(H*W);
    float max_weight = -100000;
    for(int x=0; x<H;x++)
    {
        for(int y=0; y<W;y++)
        {
            std::vector<float> pValue = get_pixel_vector(img, H, W, chns, x, y);
            std::vector<float> qValue;
            float l2dis, n_weight;
            int pIndex  = x*W + y;
            int qIndex;
            int xn, yn;
            int Xoff[2] = {-1, 0};
            int Yoff[2] = {0, -1};
            for(int i=0; i<2; i++){
                xn = x + Xoff[i];
                yn = y + Yoff[i];
                if(xn < 0 || yn < 0) continue;
                qValue   = get_pixel_vector(img, H, W, chns, xn, yn);
                l2dis    = get_l2_distance(pValue, qValue);
                n_weight = lambda*exp(-l2dis * l2dis/(2*sigma*sigma));
                qIndex   = xn*W + yn;
                g->add_edge(qIndex,pIndex,n_weight,n_weight);
                if(n_weight > max_weight) max_weight = n_weight;
            }
        }
    }

    max_weight =  1000 * max_weight;
    for(int x=0;x<H;x++)
    {
        for(int y=0;y<W;y++)
        {
            bool seed_exist = false;
            float s_weight  = 1e-3;
            float t_weight  = 1e-3;
            if(seed != NULL)
            {
                std::vector<unsigned char> label = get_pixel_vector(seed, H, W, 2, x, y); 
                if(label[0] > 0){
                    t_weight   = max_weight;
                    seed_exist = true; 
                }
                else if(label[1] > 0){
                    s_weight   = max_weight;
                    seed_exist = true;
                }
            }
            if(!seed_exist){
                std::vector<float> probs = get_pixel_vector(prob, H, W, 2, x, y);
                s_weight = -log(probs[0]);