gcoptimization.cpp

markov random field in matlab code

    Neighbor *tmp;
    

    for ( i = 0; i < size; i++ )
    {
        pix = pixels[i];
        if ( !m_neighbors[pix].isEmpty() )
        {
            m_neighbors[pix].setCursorFront();
            
            while ( m_neighbors[pix].hasNext() )
            {
                tmp = (Neighbor *) (m_neighbors[pix].next());
                nPix   = tmp->to_node;
                
                if ( m_labeling[nPix] == alpha_label || m_labeling[nPix] == beta_label)
                {
                    if ( pix < nPix )
                        e ->add_term2(variables[i],variables[m_lookupPixVar[nPix]],
                                      m_smoothFnPix(pix,nPix,alpha_label,alpha_label),
                                      m_smoothFnPix(pix,nPix,alpha_label,beta_label),
                                      m_smoothFnPix(pix,nPix,beta_label,alpha_label),
                                      m_smoothFnPix(pix,nPix,beta_label,beta_label) );
                }
                else
                    e ->add_term1(variables[i],m_smoothFnPix(pix,nPix,alpha_label,m_labeling[nPix]),
                                               m_smoothFnPix(pix,nPix,beta_label,m_labeling[nPix]));
            }
        }
    }
}

/**************************************************************************************/

void Swap::set_up_swap_energy_G_FnPix(int size,LabelType alpha_label,LabelType beta_label,
                                                PixelType *pixels,Energy* e, Energy::Var *variables)
{
    PixelType nPix,pix,i,x,y;

    
    for ( i = 0; i < size; i++ )
    {
        pix = pixels[i];
        y = pix/m_width;
        x = pix - y*m_width;

        if ( x > 0 )
        {
            nPix = pix - 1;
    
            if ( m_labeling[nPix] == alpha_label || m_labeling[nPix] == beta_label)
                e ->add_term2(variables[i],variables[m_lookupPixVar[nPix]],
                              m_smoothFnPix(pix,nPix,alpha_label,alpha_label),
                              m_smoothFnPix(pix,nPix,alpha_label,beta_label),
                              m_smoothFnPix(pix,nPix,beta_label,alpha_label),
                              m_smoothFnPix(pix,nPix,beta_label,beta_label) );
    
                else
                    e ->add_term1(variables[i],m_smoothFnPix(pix,nPix,alpha_label,m_labeling[nPix]),
                                           m_smoothFnPix(pix,nPix,beta_label,m_labeling[nPix]));
    
        }   
        if ( y > 0 )
        {
            nPix = pix - m_width;
            if ( m_labeling[nPix] == alpha_label || m_labeling[nPix] == beta_label)
                e ->add_term2(variables[i],variables[m_lookupPixVar[nPix]],
                              m_smoothFnPix(pix,nPix,alpha_label,alpha_label),
                              m_smoothFnPix(pix,nPix,alpha_label,beta_label),
                              m_smoothFnPix(pix,nPix,beta_label,alpha_label),
                              m_smoothFnPix(pix,nPix,beta_label,beta_label) );
    
                else
                    e ->add_term1(variables[i],m_smoothFnPix(pix,nPix,alpha_label,m_labeling[nPix]),
                                           m_smoothFnPix(pix,nPix,beta_label,m_labeling[nPix]));
        }   

        if ( x < m_width - 1 )
        {
            nPix = pix + 1;
    
            if ( !(m_labeling[nPix] == alpha_label || m_labeling[nPix] == beta_label) )
                    e ->add_term1(variables[i],m_smoothFnPix(pix,nPix,alpha_label,m_labeling[nPix]),
                                               m_smoothFnPix(pix,nPix,beta_label,m_labeling[nPix]));
        }   

        if ( y < m_height - 1 )
        {
            nPix = pix + m_width;
    
            if ( !(m_labeling[nPix] == alpha_label || m_labeling[nPix] == beta_label) )
                e ->add_term1(variables[i],m_smoothFnPix(pix,nPix,alpha_label,m_labeling[nPix]),
                                           m_smoothFnPix(pix,nPix,beta_label,m_labeling[nPix]));

        }
    }
}


/**************************************************************************************/

void Swap::set_up_swap_energy_G_ARRAY_VW(int size,LabelType alpha_label,LabelType beta_label,
                                                   PixelType *pixels,Energy* e, Energy::Var *variables)
{
    PixelType nPix,pix,i,x,y;
    EnergyTermType weight;  



    for ( i = 0; i < size; i++ )
    {
        pix = pixels[i];
        y = pix/m_width;
        x = pix - y*m_width;

        if ( x > 0 )
        {
            nPix = pix - 1;
            weight = m_horizWeights[nPix];
    
            if ( m_labeling[nPix] == alpha_label || m_labeling[nPix] == beta_label)
                e ->add_term2(variables[i],variables[m_lookupPixVar[nPix]],
                              m_smoothcost(alpha_label,alpha_label)*weight,
                              m_smoothcost(alpha_label,beta_label)*weight,
                              m_smoothcost(beta_label,alpha_label)*weight,
                              m_smoothcost(beta_label,beta_label)*weight );
    
                else
                    e ->add_term1(variables[i],m_smoothcost(alpha_label,m_labeling[nPix])*weight,
                                           m_smoothcost(beta_label,m_labeling[nPix])*weight);
    
        }   
        if ( y > 0 )
        {
            nPix = pix - m_width;
            weight = m_vertWeights[nPix];

            if ( m_labeling[nPix] == alpha_label || m_labeling[nPix] == beta_label)
                e ->add_term2(variables[i],variables[m_lookupPixVar[nPix]],
                              m_smoothcost(alpha_label,alpha_label)*weight,
                              m_smoothcost(alpha_label,beta_label)*weight,
                              m_smoothcost(beta_label,alpha_label)*weight,
                              m_smoothcost(beta_label,beta_label)*weight );
    
                else
                    e ->add_term1(variables[i],m_smoothcost(alpha_label,m_labeling[nPix])*weight,
                                           m_smoothcost(beta_label,m_labeling[nPix])*weight);
        }   

        if ( x < m_width - 1 )
        {
            nPix = pix + 1;
    
            if ( !(m_labeling[nPix] == alpha_label || m_labeling[nPix] == beta_label) )
                    e ->add_term1(variables[i],m_smoothcost(alpha_label,m_labeling[nPix])*m_horizWeights[pix],
                                               m_smoothcost(beta_label,m_labeling[nPix])*m_horizWeights[pix]);
        }   

        if ( y < m_height - 1 )
        {
            nPix = pix + m_width;
    
            if ( !(m_labeling[nPix] == alpha_label || m_labeling[nPix] == beta_label) )
                e ->add_term1(variables[i],m_smoothcost(alpha_label,m_labeling[nPix])*m_vertWeights[pix],
                                           m_smoothcost(beta_label,m_labeling[nPix])*m_vertWeights[pix]);

        }
    }
}

/**************************************************************************************/

void Swap::set_up_swap_energy_G_ARRAY(int size,LabelType alpha_label,LabelType beta_label,
                                               PixelType *pixels,Energy* e, Energy::Var *variables)

{
    PixelType nPix,pix,i,x,y;
    


    for ( i = 0; i < size; i++ )
    {
        pix = pixels[i];
        y = pix/m_width;
        x = pix - y*m_width;

        if ( x > 0 )
        {
            nPix = pix - 1;
    
    
            if ( m_labeling[nPix] == alpha_label || m_labeling[nPix] == beta_label)
                e ->add_term2(variables[i],variables[m_lookupPixVar[nPix]],
                              m_smoothcost(alpha_label,alpha_label),
                              m_smoothcost(alpha_label,beta_label),
                              m_smoothcost(beta_label,alpha_label),
                              m_smoothcost(beta_label,beta_label) );
    
                else
                    e ->add_term1(variables[i],m_smoothcost(alpha_label,m_labeling[nPix]),
                                           m_smoothcost(beta_label,m_labeling[nPix]));
    
        }   
        if ( y > 0 )
        {
            nPix = pix - m_width;

            if ( m_labeling[nPix] == alpha_label || m_labeling[nPix] == beta_label)
                e ->add_term2(variables[i],variables[m_lookupPixVar[nPix]],
                              m_smoothcost(alpha_label,alpha_label),
                              m_smoothcost(alpha_label,beta_label),
                              m_smoothcost(beta_label,alpha_label),
                              m_smoothcost(beta_label,beta_label) );
    
                else
                    e ->add_term1(variables[i],m_smoothcost(alpha_label,m_labeling[nPix]),
                                           m_smoothcost(beta_label,m_labeling[nPix]));
        }   

        if ( x < m_width - 1 )
        {
            nPix = pix + 1;
    
            if ( !(m_labeling[nPix] == alpha_label || m_labeling[nPix] == beta_label) )
                    e ->add_term1(variables[i],m_smoothcost(alpha_label,m_labeling[nPix]),
                                               m_smoothcost(beta_label,m_labeling[nPix]));
        }   

        if ( y < m_height - 1 )
        {
            nPix = pix + m_width;
    
            if ( !(m_labeling[nPix] == alpha_label || m_labeling[nPix] == beta_label))
                e ->add_term1(variables[i],m_smoothcost(alpha_label,m_labeling[nPix]),
                                           m_smoothcost(beta_label,m_labeling[nPix]));

        }
    }
}

/**************************************************************************************/

void Swap::optimizeAlg(int nIterations)
{
    swap(nIterations);
}

/**************************************************************************************/


GCoptimization::EnergyType Expansion::expansion(int max_num_iterations)
{
    return(start_expansion(max_num_iterations)); 
}

/**************************************************************************************/


GCoptimization::EnergyType Expansion::expansion()
{
    return(start_expansion(MAX_INTT));
}

/**************************************************************************************/


GCoptimization::EnergyType Expansion::start_expansion(int max_num_iterations )
{
    
    int curr_cycle = 1;
    EnergyType new_energy,old_energy;
    

    new_energy = dataEnergy()+smoothnessEnergy();

    old_energy = new_energy+1;

    while ( old_energy > new_energy  && curr_cycle <= max_num_iterations)
    {
        old_energy = new_energy;
        new_energy = oneExpansionIteration();
        
        curr_cycle++;   
    }

    //printf(" Exp energy %d",new_energy);
    return(new_energy);
}


/**************************************************************************************/

GCoptimization::EnergyType Expansion::alpha_expansion(LabelType label)
{
    terminateOnError( label < 0 || label >= m_nLabels,"Illegal Label to Expand On");

    perform_alpha_expansion(label);
    return(dataEnergy()+smoothnessEnergy());
}


/**************************************************************************************/

void Expansion::perform_alpha_expansion(LabelType alpha_label)
{
    PixelType i,size = 0; 
    Energy *e = new Energy();
    

    
    for ( i = 0; i < m_nPixels; i++ )
    {
        if ( m_labeling[i] != alpha_label )
        {
            m_lookupPixVar[size] = i;
            size++;
        }
    }

        
    if ( size > 0 ) 
    {
        Energy::Var *variables = (Energy::Var *) new Energy::Var[size];
        if ( !variables) {printf("\nOut of memory, exiting");exit(1);}

        for ( i = 0; i < size; i++ )
            variables[i] = e ->add_variable();

        if ( m_dataType == ARRAY ) add_t_links_ARRAY(e,variables,size,alpha_label);
        else  add_t_links_FnPix(e,variables,size,alpha_label);


        if ( m_grid_graph )
        {
            if ( m_smoothType != FUNCTION )
            {
                if (m_varWeights) set_up_expansion_energy_G_ARRAY_VW(size,alpha_label,e,variables);
                else set_up_expansion_energy_G_ARRAY(size,alpha_label,e,variables);
            }
            else set_up_expansion_energy_G_FnPix(size,alpha_label,e,variables);
            
        }
        else
        {