Example #1
0
double
InvLogitGaussianJointPdf<V,M>::lnValue(
  const V& domainVector,
  const V* domainDirection,
        V* gradVector,
        M* hessianMatrix,
        V* hessianEffect) const
{
  double returnValue;
  double lnDeterminant = 0.0;
  V transformedDomainVector(domainVector);

  V min_domain_bounds(this->m_domainBoxSubset.minValues());
  V max_domain_bounds(this->m_domainBoxSubset.maxValues());

  double lnjacobian = 0.0;
  for (unsigned int i = 0; i < domainVector.sizeLocal(); i++) {
    double min_val = min_domain_bounds[i];
    double max_val = max_domain_bounds[i];

    if (queso_isfinite(min_val) &&
        queso_isfinite(max_val)) {

      if (domainVector[i] == min_val || domainVector[i] == max_val) {
        // Exit early if we can
        return -INFINITY;
      }

        // Left- and right-hand sides are finite.  Do full transform.
        transformedDomainVector[i] = std::log(domainVector[i] - min_val) -
            std::log(max_val - domainVector[i]);

        lnjacobian += std::log(max_val - min_val) -
          std::log(domainVector[i] - min_val) -
          std::log(max_val - domainVector[i]);
    }
    else if (queso_isfinite(min_val) &&
             !queso_isfinite(max_val)) {

      if (domainVector[i] == min_val) {
        // Exit early if we can
        return -INFINITY;
      }

      // Left-hand side finite, but right-hand side is not.
      // Do only left-hand transform.
      transformedDomainVector[i] = std::log(domainVector[i] - min_val);

      lnjacobian += -std::log(domainVector[i] - min_val);
    }
    else if (!queso_isfinite(min_val) &&
             queso_isfinite(max_val)) {

      if (domainVector[i] == max_val) {
        // Exit early if we can
        return -INFINITY;
      }

      // Right-hand side is finite, but left-hand side is not.
      // Do only right-hand transform.
      transformedDomainVector[i] = -std::log(max_val - domainVector[i]);

      lnjacobian += -std::log(max_val - domainVector[i]);
    }
    else {
      // No transform.
      transformedDomainVector[i] = domainVector[i];
    }
  }

  V diffVec(transformedDomainVector - this->lawExpVector());
  if (m_diagonalCovMatrix) {
    returnValue = ((diffVec * diffVec) /
        this->lawVarVector()).sumOfComponents();
    if (m_normalizationStyle == 0) {
      unsigned int iMax = this->lawVarVector().sizeLocal();
      for (unsigned int i = 0; i < iMax; ++i) {
        lnDeterminant += log(this->lawVarVector()[i]);
      }
    }
  }
  else {
    V tmpVec = this->m_lawCovMatrix->invertMultiply(diffVec);
    returnValue = (diffVec * tmpVec).sumOfComponents();
    if (m_normalizationStyle == 0) {
      lnDeterminant = this->m_lawCovMatrix->lnDeterminant();
    }
  }
  if (m_normalizationStyle == 0) {
    returnValue += ((double) this->lawVarVector().sizeLocal()) * log(2 * M_PI);
    returnValue += lnDeterminant;
  }
  returnValue *= -0.5;
  returnValue += m_logOfNormalizationFactor;
  returnValue += lnjacobian;

  return returnValue;
}
Example #2
0
double
GaussianJointPdf<V,M>::lnValue(
  const V& domainVector,
  const V* domainDirection,
        V* gradVector,
        M* hessianMatrix,
        V* hessianEffect) const
{
  if ((m_env.subDisplayFile()) && (m_env.displayVerbosity() >= 55)) {
    *m_env.subDisplayFile() << "Entering GaussianJointPdf<V,M>::lnValue()"
                            << ", meanVector = "   << *m_lawExpVector
                      << ", lawCovMatrix = " << *m_lawCovMatrix
                            << ": domainVector = " << domainVector
                            << std::endl;
  }

  queso_require_msg(!(domainDirection || hessianMatrix || hessianEffect), "incomplete code for gradVector, hessianMatrix and hessianEffect calculations");

  double returnValue = 0.;

  double lnDeterminant = 0.;
  if (this->m_domainSet.contains(domainVector) == false) {
    // What should the gradient be here?
    returnValue = -INFINITY;
  }
  else {
    V diffVec(domainVector - this->lawExpVector());
    if (m_diagonalCovMatrix) {
      returnValue = ((diffVec*diffVec)/this->lawVarVector()).sumOfComponents();

      // Compute the gradient of log of the pdf.
      // The log of a Gaussian pdf is:
      // f(x) = - 1/2 (x - \mu)^T \Sigma^{-1} (x - \mu)
      // Therefore
      // \frac{df}{dx}(x) = - (x - \mu)^T \Sigma^{-1}
      //                  = - (\Sigma^{-1}^T (x - \mu))^T
      //                  = - (\Sigma^{-1} (x - \mu))^T
      //                  = - \Sigma^{-1} (x - \mu)  (row/column vector doesn't matter)
      //
      // So if \Sigma is diagonal we have a component-wise product of two
      // vectors (x - \mu) and the diagonal elements of \Sigma^{-1}
      if (gradVector) {
        (*gradVector) = diffVec;  // Copy
        (*gradVector) /= this->lawVarVector();
        (*gradVector) *= -1.0;
      }

      if (m_normalizationStyle == 0) {
        unsigned int iMax = this->lawVarVector().sizeLocal();
        for (unsigned int i = 0; i < iMax; ++i) {
          lnDeterminant += std::log(this->lawVarVector()[i]);
        }
      }
    }
    else {
      V tmpVec = this->m_lawCovMatrix->invertMultiply(diffVec);
      returnValue = (diffVec*tmpVec).sumOfComponents();

      // Compute the gradient of log of the pdf.
      // The log of a Gaussian pdf is:
      // f(x) = - 1/2 (x - \mu)^T \Sigma^{-1} (x - \mu)
      // Therefore
      // \frac{df}{dx}(x) = - (x - \mu)^T \Sigma^{-1}
      //                  = - (\Sigma^{-1}^T (x - \mu))^T
      //                  = - (\Sigma^{-1} (x - \mu))^T
      //                  = - \Sigma^{-1} (x - \mu)  (row/column vector doesn't matter)
      if (gradVector) {
        (*gradVector) = tmpVec;
        (*gradVector) *= -1.0;
      }

      if (m_normalizationStyle == 0) {
        lnDeterminant = this->m_lawCovMatrix->lnDeterminant();
      }
    }
    if (m_normalizationStyle == 0) {
      returnValue += ((double) this->lawVarVector().sizeLocal()) * std::log(2*M_PI);   // normalization of pdf
      returnValue += lnDeterminant; // normalization of pdf
    }
    returnValue *= -0.5;
  }
  returnValue += m_logOfNormalizationFactor;

  if ((m_env.subDisplayFile()) && (m_env.displayVerbosity() >= 99)) {
    *m_env.subDisplayFile() << "Leaving GaussianJointPdf<V,M>::lnValue()"
                            << ", m_normalizationStyle = " << m_normalizationStyle
                            << ", m_diagonalCovMatrix = " << m_diagonalCovMatrix
                            << ", m_logOfNormalizationFactor = " << m_logOfNormalizationFactor
                            << ", lnDeterminant = " << lnDeterminant
                            << ", meanVector = "           << *m_lawExpVector
                            << ", lawCovMatrix = "         << *m_lawCovMatrix
                            << ": domainVector = "         << domainVector
                            << ", returnValue = "          << returnValue
                            << std::endl;
  }

  return returnValue;
}
Example #3
0
double
LogNormalJointPdf<V,M>::lnValue(
  const V& domainVector,
  const V* domainDirection,
        V* gradVector,
        M* hessianMatrix,
        V* hessianEffect) const
{
  if ((m_env.subDisplayFile()) && (m_env.displayVerbosity() >= 55)) {
    *m_env.subDisplayFile() << "Entering LogNormalJointPdf<V,M>::lnValue()"
                            << ", meanVector = "   << *m_lawExpVector
                            << ": domainVector = " << domainVector
                            << std::endl;
  }

  UQ_FATAL_TEST_MACRO((gradVector || hessianMatrix || hessianEffect),
                      m_env.worldRank(),
                      "LogNormalJointPdf<V,M>::lnValue()",
                      "incomplete code for gradVector, hessianMatrix and hessianEffect calculations");

  if (domainDirection) {}; // just to remove compiler warning

  double returnValue = 0.;

  V zeroVector(domainVector);
  zeroVector.cwSet(0.);
  if (domainVector.atLeastOneComponentSmallerOrEqualThan(zeroVector)) {
    returnValue = -INFINITY;
  }
  else if (this->m_domainSet.contains(domainVector) == false) { // prudenci 2011-Oct-04
    returnValue = -INFINITY;
  }
  else {
    if (m_diagonalCovMatrix) {
      V diffVec(zeroVector);
      for (unsigned int i = 0; i < domainVector.sizeLocal(); ++i) {
        diffVec[i] = std::log(domainVector[i]) - this->lawExpVector()[i];
      }
      returnValue = ((diffVec*diffVec)/this->lawVarVector()).sumOfComponents();
      returnValue *= -0.5;
      if (m_normalizationStyle == 0) {
        for (unsigned int i = 0; i < domainVector.sizeLocal(); ++i) {
          returnValue -= std::log(domainVector[i] * std::sqrt(2. * M_PI * this->lawVarVector()[i])); // Contribution of 1/(x\sqrt{2\pi\sigma^2})
        }
      }
    }
    else {
      UQ_FATAL_TEST_MACRO(true,
                          m_env.worldRank(),
                          "LogNormalJointPdf<V,M>::lnValue()",
                          "situation with a non-diagonal covariance matrix makes no sense");
    }
    returnValue += m_logOfNormalizationFactor; // [PDF-10]
  }

  if ((m_env.subDisplayFile()) && (m_env.displayVerbosity() >= 55)) {
    *m_env.subDisplayFile() << "Leaving LogNormalJointPdf<V,M>::lnValue()"
                            << ", meanVector = "   << *m_lawExpVector
                            << ": domainVector = " << domainVector
                            << ", returnValue = "  << returnValue
                            << std::endl;
  }

  return returnValue;
}
Example #4
0
void MakeGraph( Energy<float,float,float> *e , int *vars , vector< set<int> > &neighbors,      vector<int> &Disparity,
				vector< vector<double> > Colors_L, vector<int> FLabels_L,       vector<int> BLabels_L , 
				vector<double> FDistVec_L ,        vector<double> BDistVec_L , 
				vector< vector<double> > Colors_R, vector<int> FLabels_R,       vector<int> BLabels_R , 
				vector<double> FDistVec_R ,        vector<double> BDistVec_R , 				  
				int numLabels , int num_high , int numRows , int numCols , double lambda_p , double lambda_c )
{
	int i;
	set<int>::iterator pIter;
	const int K = 10000;					
	// Edge weight for infinity -- All other edge weights less than 1 -- so it suffices to have this weight as more than sum of all other edges, i.e. >8

	double beta;

	double countCand = 0;
	double SumColors = 0;

	for( i=0 ; i<numLabels ; i++ )
	{
		for ( pIter = neighbors[i].begin() ; pIter != neighbors[i].end() ; pIter++ )
		{
			SumColors += pow( diffVec(Colors_L[i],Colors_L[*pIter]) , 2 );
			countCand++;
		}
	}
	for( i=numLabels ; i<2*numLabels ; i++ )
	{
		for ( pIter = neighbors[i].begin() ; pIter != neighbors[i].end() ; pIter++ )
		{
			SumColors += pow( diffVec(Colors_R[i-numLabels],Colors_R[*pIter-numLabels]) , 2 );
			countCand++;
		}
	}
	beta = countCand/(2*SumColors);

	///////////////////////////////////////////////////////////////////////////////////////////////////


	//when reducing the order of high-order term, every high-order clique needs 5 new auxiliary variables 


	//calulate the factors for data term
	vector<double> ForeEdges, BackEdges;
	ForeEdges.clear();
	BackEdges.clear();
	
	printf("Graph Making code starts... \n");

	/****** Making Terminal Edge Weights ******/
	int count=0 ;

	for( i=0; i<numLabels; i++)
	{
		if(findValVec(FLabels_L,i))
		{
			count++ ;
			ForeEdges.push_back(K);
			BackEdges.push_back(0);
		}

		else if(findValVec(BLabels_L,i))
		{
			count++ ;
			ForeEdges.push_back(0);
			BackEdges.push_back(K);
		}
			
		else
		{
			double temp;
			temp = BDistVec_L[i]+FDistVec_L[i] ;
			ForeEdges.push_back(FDistVec_L[i]/temp);
			BackEdges.push_back(BDistVec_L[i]/temp);
		}
	}

	for( i=0; i<numLabels; i++)
	{
		if(findValVec(FLabels_R,i))
		{
			count++ ;
			ForeEdges.push_back(K);
			BackEdges.push_back(0);
		}

		else if(findValVec(BLabels_R,i))
		{
			count++ ;
			ForeEdges.push_back(0);
			BackEdges.push_back(K);
		}
			
		else
		{
			double temp;
			temp = BDistVec_R[i]+FDistVec_R[i] ;
			ForeEdges.push_back(FDistVec_R[i]/temp);
			BackEdges.push_back(BDistVec_R[i]/temp);
		}
	}

	printf("count=%d \n Terminal Edge Weights Made... \n",count);

	///////////////////////////////////////////////
	/******* Start making the graph **************/
	///////////////////////////////////////////////	

	// Add Nodes
	for( i=0 ; i<2*numLabels+4*num_high*5 ; i++ )
		vars[i] = e -> add_variable();

	printf("Nodes Added to Graph... \n");

	//data term
	for( i=0 ; i<2*numLabels ; i++ )
	{
		e -> add_term1(vars[i], ForeEdges[i], BackEdges[i]);
	}

	printf("Terminal Edge Weights Set... \n");

	//smooth term
	for( i=0 ; i<numLabels ; i++ )
		for (pIter = neighbors[i].begin(); pIter != neighbors[i].end(); pIter++)
		{
			int tmpN = *pIter;
			double Energ = exp( -beta * pow(diffVec( Colors_L[i], Colors_L[tmpN]) ,2 ) );
			e -> add_term2( vars[i], vars[tmpN] , 0 , lambda_p*Energ, lambda_p*Energ , 0);
		}
	for( i=numLabels ; i<2*numLabels ; i++ )
		for (pIter = neighbors[i].begin(); pIter != neighbors[i].end(); pIter++)
		{
			int tmpN = *pIter;
			double Energ = exp( -beta * pow(diffVec( Colors_R[i-numLabels], Colors_R[tmpN-numLabels]) ,2 ) );
			e -> add_term2( vars[i], vars[tmpN] , 0 , lambda_p*Energ, lambda_p*Energ , 0);
		}

	//correspondence term: the low-order terms decomposed from the high-order term
	int count_high =0 ;
	int loc_y[4] = { -1 , 1,  0,  0 } ;
	int loc_x[4] = { 0 ,  0, -1,  1 } ;  //up down left right

	float f1 , f2 , a ;
	f2 = 2 ;
	float theta1 , theta2 , gamma1, gamma2 ;

	theta1=0.5 ;
	theta2=1.5 ;  ////////////////////////////////
	////////////////////////////////////////
	gamma1 = 200 ;
	gamma2 = 1000 ;

	for( int c=1 ; c<numCols-1 ; c++ )
	    for( int h=1 ; h<numRows-1 ; h++ )
		{
		    int this_ind , this_disp , cr ;
		    this_ind = c*numRows + h ;
			this_disp = Disparity[this_ind] ;
			cr = c- this_disp ;

		    if( cr >= 1 )
		    {
		    	vector<double> Meanwin_l(3) ;
				vector<double> Meanwin_r(3) ;
				get_win_mean( Colors_L , h , c , numRows , numCols , Meanwin_l ) ;
				get_win_mean( Colors_R , h , cr, numRows , numCols , Meanwin_r ) ;

				double C_rl = exp(    -sqrt(  1/(2*16*16) * pow(diffVec( Meanwin_l, Meanwin_r) ,2)  )    );
				C_rl *= lambda_c ; 

				float local_var=0;
				local_var = get_var( Colors_L , Colors_R , h, c, cr , numRows , numCols , Meanwin_l , Meanwin_r);

				if ( local_var<theta1 )
	                f1 = gamma1 ;
				else if ( local_var>theta2 )
					f1 = gamma2 ;
				else
				{
					f1 = -(gamma2-gamma1)/(theta2-theta1)*local_var + gamma2*theta2-gamma1*theta1 ;
				}

				a = f2 - 2*f1 ;

				if(a>0)
				{
					//one order terms transformed from the high-order term
					e -> add_term1(vars[2*numLabels + count_high*5]   , 0, -C_rl*2*a);
					e -> add_term1(vars[2*numLabels + count_high*5 +1], 0, -C_rl*2*a);
					e -> add_term1(vars[2*numLabels + count_high*5 +2], 0, -C_rl*2*a);
					e -> add_term1(vars[2*numLabels + count_high*5 +3], 0, -C_rl*2*a);
					e -> add_term1(vars[2*numLabels + count_high*5 +4], 0, -C_rl*12*a);    // w1 w2 w3 w4 w

					//two order terms transformed from the high-order term
					for( int u=0 ; u<4 ; u++ )
					{
						//find the corresponding pixels and their neighbours
						int  neigh_y , neigh_xl , neigh_xr , ind_l , ind_r , neigh_ind_l , neigh_ind_r ;
						neigh_y   = h  + loc_y[u] ;
						neigh_xl  = c  + loc_x[u] ;
						neigh_xr  = cr + loc_x[u] ;

						ind_l = c  * numRows + h ;
						ind_r = cr * numRows + h ;
						neigh_ind_l = neigh_xl * numRows + neigh_y ;
						neigh_ind_r = neigh_xr * numRows + neigh_y ;
	
						e -> add_term1(vars[ind_l]                 , 0, C_rl*(f1+6*a) );
						e -> add_term1(vars[ind_r+numLabels]       , 0, C_rl*(f1+6*a) );
						e -> add_term1(vars[neigh_ind_l]           , 0, C_rl*(f1+6*a) );
						e -> add_term1(vars[neigh_ind_r+numLabels] , 0, C_rl*(f1+6*a) );         //x0 y0 x1 y1
	
						e -> add_term2( vars[ind_l]          , vars[neigh_ind_l]           , 0 , 0 , 0 , -C_rl*3*a);   //x0x1 y0y1 x0y1 x1y0
						e -> add_term2( vars[ind_r+numLabels], vars[neigh_ind_r+numLabels] , 0 , 0 , 0 , -C_rl*3*a);
						e -> add_term2( vars[ind_l]          , vars[neigh_ind_r+numLabels] , 0 , 0 , 0 , -C_rl*3*a);
						e -> add_term2( vars[neigh_ind_l]    , vars[ind_r+numLabels]       , 0 , 0 , 0 , -C_rl*3*a);

						e -> add_term2( vars[ind_l]      , vars[ind_r+numLabels]       , 0 , 0 , 0 , C_rl*(-2*f1-4*a) );
						e -> add_term2( vars[neigh_ind_l], vars[neigh_ind_r+numLabels] , 0 , 0 , 0 , C_rl*(-2*f1-4*a) );   //x0y0 x1y1

						e -> add_term2( vars[2*numLabels + count_high*5] , vars[ind_l]           , 0 , 0 , 0 , -C_rl*2*a );  //w1 *( x0 + x1 + y0 )
						e -> add_term2( vars[2*numLabels + count_high*5] , vars[neigh_ind_l]     , 0 , 0 , 0 , -C_rl*2*a );
						e -> add_term2( vars[2*numLabels + count_high*5] , vars[ind_r+numLabels] , 0 , 0 , 0 , -C_rl*2*a );

						e -> add_term2( vars[2*numLabels + count_high*5+1] , vars[ind_l]                 , 0 , 0 , 0 , -C_rl*2*a );  //w2 *( x0 + x1 + y1 )
						e -> add_term2( vars[2*numLabels + count_high*5+1] , vars[neigh_ind_l]           , 0 , 0 , 0 , -C_rl*2*a );
						e -> add_term2( vars[2*numLabels + count_high*5+1] , vars[neigh_ind_r+numLabels] , 0 , 0 , 0 , -C_rl*2*a );

						e -> add_term2( vars[2*numLabels + count_high*5+2] , vars[ind_l]                 , 0 , 0 , 0 , -C_rl*2*a );  //w3 *( x0 + y0 + y1 )
						e -> add_term2( vars[2*numLabels + count_high*5+2] , vars[ind_r+numLabels]       , 0 , 0 , 0 , -C_rl*2*a );
						e -> add_term2( vars[2*numLabels + count_high*5+2] , vars[neigh_ind_r+numLabels] , 0 , 0 , 0 , -C_rl*2*a );

						e -> add_term2( vars[2*numLabels + count_high*5+3] , vars[neigh_ind_l]           , 0 , 0 , 0 , -C_rl*2*a );  //w4 *( x1 + y0 + y1 )
						e -> add_term2( vars[2*numLabels + count_high*5+3] , vars[ind_r+numLabels]       , 0 , 0 , 0 , -C_rl*2*a );
						e -> add_term2( vars[2*numLabels + count_high*5+3] , vars[neigh_ind_r+numLabels] , 0 , 0 , 0 , -C_rl*2*a );

						e -> add_term2( vars[2*numLabels + count_high*5+4] , vars[ind_l]                 , 0 , 0 , 0 , C_rl*4*a );  //w*(x0+x1+y0+y1)
						e -> add_term2( vars[2*numLabels + count_high*5+4] , vars[neigh_ind_l]           , 0 , 0 , 0 , C_rl*4*a );
						e -> add_term2( vars[2*numLabels + count_high*5+4] , vars[ind_r+numLabels]       , 0 , 0 , 0 , C_rl*4*a );
						e -> add_term2( vars[2*numLabels + count_high*5+4] , vars[neigh_ind_r+numLabels] , 0 , 0 , 0 , C_rl*4*a );
					}
				}
				else
				{
					e -> add_term1(vars[2*numLabels + count_high*5]   , 0, C_rl*4*a);
					e -> add_term1(vars[2*numLabels + count_high*5 +1], 0, C_rl*4*a);
					e -> add_term1(vars[2*numLabels + count_high*5 +2], 0, C_rl*4*a);
					e -> add_term1(vars[2*numLabels + count_high*5 +3], 0, C_rl*4*a);
					e -> add_term1(vars[2*numLabels + count_high*5 +4], 0, C_rl*12*a);    // w1 w2 w3 w4 w

					for( int u=0 ; u<4 ; u++ )
					{
						int  neigh_y , neigh_xl , neigh_xr , ind_l , ind_r , neigh_ind_l , neigh_ind_r ;
						neigh_y   = h  + loc_y[u] ;
						neigh_xl  = c  + loc_x[u] ;
						neigh_xr  = cr + loc_x[u] ;

						ind_l = c  * numRows + h ;
						ind_r = cr * numRows + h ;
						neigh_ind_l = neigh_xl * numRows + neigh_y ;
						neigh_ind_r = neigh_xr * numRows + neigh_y ;
	
						e -> add_term1(vars[ind_l]                 , 0, C_rl*f1 );
						e -> add_term1(vars[ind_r+numLabels]       , 0, C_rl*f1 );
						e -> add_term1(vars[neigh_ind_l]           , 0, C_rl*f1 );
						e -> add_term1(vars[neigh_ind_r+numLabels] , 0, C_rl*f1 );         //x0 y0 x1 y1
	
						e -> add_term2( vars[ind_l]          , vars[neigh_ind_l]           , 0 , 0 , 0 , C_rl*5*a);   //x0x1 y0y1 x0y1 x1y0
						e -> add_term2( vars[ind_r+numLabels], vars[neigh_ind_r+numLabels] , 0 , 0 , 0 , C_rl*5*a);
						e -> add_term2( vars[ind_l]          , vars[neigh_ind_r+numLabels] , 0 , 0 , 0 , C_rl*5*a);
						e -> add_term2( vars[neigh_ind_l]    , vars[ind_r+numLabels]       , 0 , 0 , 0 , C_rl*5*a);

						e -> add_term2( vars[ind_l]      , vars[ind_r+numLabels]       , 0 , 0 , 0 , C_rl*(-2*f1+4*a) );
						e -> add_term2( vars[neigh_ind_l], vars[neigh_ind_r+numLabels] , 0 , 0 , 0 , C_rl*(-2*f1+4*a) );   //x0y0 x1y1

						e -> add_term2( vars[2*numLabels + count_high*5] , vars[ind_l]           , 0 , 0 , 0 , -C_rl*2*a );  //w1 *( x0 + x1 + y0 )
						e -> add_term2( vars[2*numLabels + count_high*5] , vars[neigh_ind_l]     , 0 , 0 , 0 , -C_rl*2*a );
						e -> add_term2( vars[2*numLabels + count_high*5] , vars[ind_r+numLabels] , 0 , 0 , 0 , -C_rl*2*a );

						e -> add_term2( vars[2*numLabels + count_high*5+1] , vars[ind_l]                 , 0 , 0 , 0 , -C_rl*2*a );  //w2 *( x0 + x1 + y1 )
						e -> add_term2( vars[2*numLabels + count_high*5+1] , vars[neigh_ind_l]           , 0 , 0 , 0 , -C_rl*2*a );
						e -> add_term2( vars[2*numLabels + count_high*5+1] , vars[neigh_ind_r+numLabels] , 0 , 0 , 0 , -C_rl*2*a );

						e -> add_term2( vars[2*numLabels + count_high*5+2] , vars[ind_l]                 , 0 , 0 , 0 , -C_rl*2*a );  //w3 *( x0 + y0 + y1 )
						e -> add_term2( vars[2*numLabels + count_high*5+2] , vars[ind_r+numLabels]       , 0 , 0 , 0 , -C_rl*2*a );
						e -> add_term2( vars[2*numLabels + count_high*5+2] , vars[neigh_ind_r+numLabels] , 0 , 0 , 0 , -C_rl*2*a );

						e -> add_term2( vars[2*numLabels + count_high*5+3] , vars[neigh_ind_l]           , 0 , 0 , 0 , -C_rl*2*a );  //w4 *( x1 + y0 + y1 )
						e -> add_term2( vars[2*numLabels + count_high*5+3] , vars[ind_r+numLabels]       , 0 , 0 , 0 , -C_rl*2*a );
						e -> add_term2( vars[2*numLabels + count_high*5+3] , vars[neigh_ind_r+numLabels] , 0 , 0 , 0 , -C_rl*2*a );

						e -> add_term2( vars[2*numLabels + count_high*5+4] , vars[ind_l]                 , 0 , 0 , 0 , -C_rl*8*a );  //w*(x0+x1+y0+y1)
						e -> add_term2( vars[2*numLabels + count_high*5+4] , vars[neigh_ind_l]           , 0 , 0 , 0 , -C_rl*8*a );
						e -> add_term2( vars[2*numLabels + count_high*5+4] , vars[ind_r+numLabels]       , 0 , 0 , 0 , -C_rl*8*a );
						e -> add_term2( vars[2*numLabels + count_high*5+4] , vars[neigh_ind_r+numLabels] , 0 , 0 , 0 , -C_rl*8*a );
					}

				}

		    	count_high ++ ;

		    }

    	}

	printf("Graph Made... \n");
}