lp_functiontransfer.hxx

Go to the documentation of this file.

#ifndef OPENGM_LP_FUNCTIONTRANSFER_HXX_
#define OPENGM_LP_FUNCTIONTRANSFER_HXX_

#include <opengm/opengm.hxx>
#include <opengm/datastructures/linear_constraint.hxx>

#include <opengm/functions/soft_constraint_functions/sum_constraint_function.hxx>
#include <opengm/functions/soft_constraint_functions/label_cost_function.hxx>
namespace opengm {

/*********************
 * class definition *
 *********************/
template<class VALUE_TYPE, class INDEX_TYPE = size_t, class LABEL_TYPE = size_t>
class LPFunctionTransfer {
public:
   // typedefs
   typedef VALUE_TYPE                                           ValueType;
   typedef INDEX_TYPE                                           IndexType;
   typedef LABEL_TYPE                                           LabelType;
   typedef LinearConstraint<ValueType, IndexType, LabelType>    LinearConstraintType;
   typedef std::vector<LinearConstraintType>                    LinearConstraintsContainerType;
   typedef typename LinearConstraintType::IndicatorVariableType IndicatorVariableType;
   typedef std::vector<IndicatorVariableType>                   IndicatorVariablesContainerType;
   typedef std::vector<ValueType>                               SlackVariablesObjectiveCoefficientsContainerType;

   // transfer interface
   template<class FUNCTION_TYPE>
   static bool isTransferable();
   template<class FUNCTION_TYPE>
   static IndexType numSlackVariables(const FUNCTION_TYPE& function);
   template<class FUNCTION_TYPE>
   static void getSlackVariablesOrder(const FUNCTION_TYPE& function, IndicatorVariablesContainerType& order);
   template<class FUNCTION_TYPE>
   static void getSlackVariablesObjectiveCoefficients(const FUNCTION_TYPE& function, SlackVariablesObjectiveCoefficientsContainerType& coefficients);
   template<class FUNCTION_TYPE>
   static void getIndicatorVariables(const FUNCTION_TYPE& function, IndicatorVariablesContainerType& variables);
   template<class FUNCTION_TYPE>
   static void getLinearConstraints(const FUNCTION_TYPE& function, LinearConstraintsContainerType& constraints);

   // functors
   struct IsTransferableFunctor {
      bool isTransferable_;
      template<class FUNCTION_TYPE>
      void operator()(const FUNCTION_TYPE& function);
   };
   struct NumSlackVariablesFunctor {
      IndexType numSlackVariables_;
      template<class FUNCTION_TYPE>
      void operator()(const FUNCTION_TYPE& function);
   };
   struct GetSlackVariablesOrderFunctor {
      IndicatorVariablesContainerType* order_;
      template<class FUNCTION_TYPE>
      void operator()(const FUNCTION_TYPE& function);
   };
   struct GetSlackVariablesObjectiveCoefficientsFunctor {
      SlackVariablesObjectiveCoefficientsContainerType* coefficients_;
      template<class FUNCTION_TYPE>
      void operator()(const FUNCTION_TYPE& function);
   };
   struct GetIndicatorVariablesFunctor {
      IndicatorVariablesContainerType* variables_;
      template<class FUNCTION_TYPE>
      void operator()(const FUNCTION_TYPE& function);
   };
   struct GetLinearConstraintsFunctor {
      LinearConstraintsContainerType* constraints_;
      template<class FUNCTION_TYPE>
      void operator()(const FUNCTION_TYPE& function);
   };
};

template<class FUNCTION_TYPE, class VALUE_TYPE, class INDEX_TYPE, class LABEL_TYPE>
class LPFunctionTransfer_impl {
public:
   // typedefs
   typedef VALUE_TYPE                                                                         ValueType;
   typedef INDEX_TYPE                                                                         IndexType;
   typedef LABEL_TYPE                                                                         LabelType;
   typedef FUNCTION_TYPE                                                                      FunctionType;
   typedef LPFunctionTransfer<ValueType, IndexType, LabelType>                                LPFunctionTransferType;
   typedef typename LPFunctionTransferType::LinearConstraintType                              LinearConstraintType;
   typedef typename LPFunctionTransferType::LinearConstraintsContainerType                    LinearConstraintsContainerType;
   typedef typename LPFunctionTransferType::IndicatorVariableType                             IndicatorVariableType;
   typedef typename LPFunctionTransferType::IndicatorVariablesContainerType                   IndicatorVariablesContainerType;
   typedef typename LPFunctionTransferType:: SlackVariablesObjectiveCoefficientsContainerType SlackVariablesObjectiveCoefficientsContainerType;

   // transfer interface
   static bool isTransferable();
   static IndexType numSlackVariables(const FunctionType& function);
   static void getSlackVariablesOrder(const FunctionType& function, IndicatorVariablesContainerType& order);
   static void getSlackVariablesObjectiveCoefficients(const FunctionType& function, SlackVariablesObjectiveCoefficientsContainerType& coefficients);
   static void getIndicatorVariables(const FunctionType& function, IndicatorVariablesContainerType& variables);
   static void getLinearConstraints(const FunctionType& function, LinearConstraintsContainerType& constraints);
};

template<class VALUE_TYPE, class INDEX_TYPE, class LABEL_TYPE>
class LPFunctionTransfer_impl<SumConstraintFunction<VALUE_TYPE, INDEX_TYPE, LABEL_TYPE>, VALUE_TYPE, INDEX_TYPE, LABEL_TYPE> {
public:
   // typedefs
   typedef VALUE_TYPE                                                                         ValueType;
   typedef INDEX_TYPE                                                                         IndexType;
   typedef LABEL_TYPE                                                                         LabelType;
   typedef SumConstraintFunction<VALUE_TYPE, INDEX_TYPE, LABEL_TYPE>                          FunctionType;
   typedef LPFunctionTransfer<ValueType, IndexType, LabelType>                                LPFunctionTransferType;
   typedef typename LPFunctionTransferType::LinearConstraintType                              LinearConstraintType;
   typedef typename LPFunctionTransferType::LinearConstraintsContainerType                    LinearConstraintsContainerType;
   typedef typename LPFunctionTransferType::IndicatorVariableType                             IndicatorVariableType;
   typedef typename LPFunctionTransferType::IndicatorVariablesContainerType                   IndicatorVariablesContainerType;
   typedef typename LPFunctionTransferType:: SlackVariablesObjectiveCoefficientsContainerType SlackVariablesObjectiveCoefficientsContainerType;

   // transfer interface
   static bool isTransferable();
   static IndexType numSlackVariables(const FunctionType& function);
   static void getSlackVariablesOrder(const FunctionType& function, IndicatorVariablesContainerType& order);
   static void getSlackVariablesObjectiveCoefficients(const FunctionType& function, SlackVariablesObjectiveCoefficientsContainerType& coefficients);
   static void getIndicatorVariables(const FunctionType& function, IndicatorVariablesContainerType& variables);
   static void getLinearConstraints(const FunctionType& function, LinearConstraintsContainerType& constraints);
};

template<class VALUE_TYPE, class INDEX_TYPE, class LABEL_TYPE>
class LPFunctionTransfer_impl<LabelCostFunction<VALUE_TYPE, INDEX_TYPE, LABEL_TYPE>, VALUE_TYPE, INDEX_TYPE, LABEL_TYPE> {
public:
   // typedefs
   typedef VALUE_TYPE                                                                         ValueType;
   typedef INDEX_TYPE                                                                         IndexType;
   typedef LABEL_TYPE                                                                         LabelType;
   typedef LabelCostFunction<VALUE_TYPE, INDEX_TYPE, LABEL_TYPE>                              FunctionType;
   typedef LPFunctionTransfer<ValueType, IndexType, LabelType>                                LPFunctionTransferType;
   typedef typename LPFunctionTransferType::LinearConstraintType                              LinearConstraintType;
   typedef typename LPFunctionTransferType::LinearConstraintsContainerType                    LinearConstraintsContainerType;
   typedef typename LPFunctionTransferType::IndicatorVariableType                             IndicatorVariableType;
   typedef typename LPFunctionTransferType::IndicatorVariablesContainerType                   IndicatorVariablesContainerType;
   typedef typename LPFunctionTransferType:: SlackVariablesObjectiveCoefficientsContainerType SlackVariablesObjectiveCoefficientsContainerType;

   // transfer interface
   static bool isTransferable();
   static IndexType numSlackVariables(const FunctionType& function);
   static void getSlackVariablesOrder(const FunctionType& function, IndicatorVariablesContainerType& order);
   static void getSlackVariablesObjectiveCoefficients(const FunctionType& function, SlackVariablesObjectiveCoefficientsContainerType& coefficients);
   static void getIndicatorVariables(const FunctionType& function, IndicatorVariablesContainerType& variables);
   static void getLinearConstraints(const FunctionType& function, LinearConstraintsContainerType& constraints);
};

/***********************
 * class documentation *
 ***********************/
/******************
 * implementation *
 ******************/
template<class VALUE_TYPE, class INDEX_TYPE, class LABEL_TYPE>
template<class FUNCTION_TYPE>
inline bool LPFunctionTransfer<VALUE_TYPE, INDEX_TYPE, LABEL_TYPE>::isTransferable() {
   return LPFunctionTransfer_impl<FUNCTION_TYPE, VALUE_TYPE, INDEX_TYPE, LABEL_TYPE>::isTransferable();
}

template<class VALUE_TYPE, class INDEX_TYPE, class LABEL_TYPE>
template<class FUNCTION_TYPE>
inline typename LPFunctionTransfer<VALUE_TYPE, INDEX_TYPE, LABEL_TYPE>::IndexType LPFunctionTransfer<VALUE_TYPE, INDEX_TYPE, LABEL_TYPE>::numSlackVariables(const FUNCTION_TYPE& function) {
   return LPFunctionTransfer_impl<FUNCTION_TYPE, VALUE_TYPE, INDEX_TYPE, LABEL_TYPE>::numSlackVariables(function);
}

template<class VALUE_TYPE, class INDEX_TYPE, class LABEL_TYPE>
template<class FUNCTION_TYPE>
inline void LPFunctionTransfer<VALUE_TYPE, INDEX_TYPE, LABEL_TYPE>::getSlackVariablesOrder(const FUNCTION_TYPE& function, IndicatorVariablesContainerType& order) {
   LPFunctionTransfer_impl<FUNCTION_TYPE, VALUE_TYPE, INDEX_TYPE, LABEL_TYPE>::getSlackVariablesOrder(function, order);
}

template<class VALUE_TYPE, class INDEX_TYPE, class LABEL_TYPE>
template<class FUNCTION_TYPE>
inline void LPFunctionTransfer<VALUE_TYPE, INDEX_TYPE, LABEL_TYPE>::getSlackVariablesObjectiveCoefficients(const FUNCTION_TYPE& function, SlackVariablesObjectiveCoefficientsContainerType& coefficients) {
   LPFunctionTransfer_impl<FUNCTION_TYPE, VALUE_TYPE, INDEX_TYPE, LABEL_TYPE>::getSlackVariablesObjectiveCoefficients(function, coefficients);
}

template<class VALUE_TYPE, class INDEX_TYPE, class LABEL_TYPE>
template<class FUNCTION_TYPE>
inline void LPFunctionTransfer<VALUE_TYPE, INDEX_TYPE, LABEL_TYPE>::getIndicatorVariables(const FUNCTION_TYPE& function, IndicatorVariablesContainerType& variables) {
   LPFunctionTransfer_impl<FUNCTION_TYPE, VALUE_TYPE, INDEX_TYPE, LABEL_TYPE>::getIndicatorVariables(function, variables);
}

template<class VALUE_TYPE, class INDEX_TYPE, class LABEL_TYPE>
template<class FUNCTION_TYPE>
inline void LPFunctionTransfer<VALUE_TYPE, INDEX_TYPE, LABEL_TYPE>::getLinearConstraints(const FUNCTION_TYPE& function, LinearConstraintsContainerType& constraints) {
   LPFunctionTransfer_impl<FUNCTION_TYPE, VALUE_TYPE, INDEX_TYPE, LABEL_TYPE>::getLinearConstraints(function, constraints);
}

template<class VALUE_TYPE, class INDEX_TYPE, class LABEL_TYPE>
template<class FUNCTION_TYPE>
inline void LPFunctionTransfer<VALUE_TYPE, INDEX_TYPE, LABEL_TYPE>::IsTransferableFunctor::operator()(const FUNCTION_TYPE& function) {
   isTransferable_ = isTransferable<FUNCTION_TYPE>();
}

template<class VALUE_TYPE, class INDEX_TYPE, class LABEL_TYPE>
template<class FUNCTION_TYPE>
inline void LPFunctionTransfer<VALUE_TYPE, INDEX_TYPE, LABEL_TYPE>::NumSlackVariablesFunctor::operator()(const FUNCTION_TYPE& function) {
   numSlackVariables_ = numSlackVariables(function);
}

template<class VALUE_TYPE, class INDEX_TYPE, class LABEL_TYPE>
template<class FUNCTION_TYPE>
inline void LPFunctionTransfer<VALUE_TYPE, INDEX_TYPE, LABEL_TYPE>::GetSlackVariablesOrderFunctor::operator()(const FUNCTION_TYPE& function) {
   getSlackVariablesOrder(function, *order_);
}

template<class VALUE_TYPE, class INDEX_TYPE, class LABEL_TYPE>
template<class FUNCTION_TYPE>
inline void LPFunctionTransfer<VALUE_TYPE, INDEX_TYPE, LABEL_TYPE>::GetSlackVariablesObjectiveCoefficientsFunctor::operator()(const FUNCTION_TYPE& function) {
   getSlackVariablesObjectiveCoefficients(function, *coefficients_);
}

template<class VALUE_TYPE, class INDEX_TYPE, class LABEL_TYPE>
template<class FUNCTION_TYPE>
inline void LPFunctionTransfer<VALUE_TYPE, INDEX_TYPE, LABEL_TYPE>::GetIndicatorVariablesFunctor::operator()(const FUNCTION_TYPE& function) {
   getIndicatorVariables(function, *variables_);
}

template<class VALUE_TYPE, class INDEX_TYPE, class LABEL_TYPE>
template<class FUNCTION_TYPE>
inline void LPFunctionTransfer<VALUE_TYPE, INDEX_TYPE, LABEL_TYPE>::GetLinearConstraintsFunctor::operator()(const FUNCTION_TYPE& function) {
   getLinearConstraints(function, *constraints_);
}

template<class FUNCTION_TYPE, class VALUE_TYPE, class INDEX_TYPE, class LABEL_TYPE>
inline bool LPFunctionTransfer_impl<FUNCTION_TYPE, VALUE_TYPE, INDEX_TYPE, LABEL_TYPE>::isTransferable() {
   // default implementation
   return false;
}

template<class FUNCTION_TYPE, class VALUE_TYPE, class INDEX_TYPE, class LABEL_TYPE>
inline typename LPFunctionTransfer_impl<FUNCTION_TYPE, VALUE_TYPE, INDEX_TYPE, LABEL_TYPE>::IndexType LPFunctionTransfer_impl<FUNCTION_TYPE, VALUE_TYPE, INDEX_TYPE, LABEL_TYPE>::numSlackVariables(const FunctionType& function) {
   // default implementation
   throw opengm::RuntimeError("Unsupported Function Type.");
   return 0;
}

template<class FUNCTION_TYPE, class VALUE_TYPE, class INDEX_TYPE, class LABEL_TYPE>
inline void LPFunctionTransfer_impl<FUNCTION_TYPE, VALUE_TYPE, INDEX_TYPE, LABEL_TYPE>::getSlackVariablesOrder(const FunctionType& function, IndicatorVariablesContainerType& order) {
   // default implementation
   throw opengm::RuntimeError("Unsupported Function Type.");
}

template<class FUNCTION_TYPE, class VALUE_TYPE, class INDEX_TYPE, class LABEL_TYPE>
inline void LPFunctionTransfer_impl<FUNCTION_TYPE, VALUE_TYPE, INDEX_TYPE, LABEL_TYPE>::getSlackVariablesObjectiveCoefficients(const FunctionType& function, SlackVariablesObjectiveCoefficientsContainerType& coefficients) {
   // default implementation
   throw opengm::RuntimeError("Unsupported Function Type.");
}

template<class FUNCTION_TYPE, class VALUE_TYPE, class INDEX_TYPE, class LABEL_TYPE>
inline void LPFunctionTransfer_impl<FUNCTION_TYPE, VALUE_TYPE, INDEX_TYPE, LABEL_TYPE>::getIndicatorVariables(const FunctionType& function, IndicatorVariablesContainerType& variables) {
   // default implementation
   throw opengm::RuntimeError("Unsupported Function Type.");
}

template<class FUNCTION_TYPE, class VALUE_TYPE, class INDEX_TYPE, class LABEL_TYPE>
inline void LPFunctionTransfer_impl<FUNCTION_TYPE, VALUE_TYPE, INDEX_TYPE, LABEL_TYPE>::getLinearConstraints(const FunctionType& function, LinearConstraintsContainerType& constraints) {
   // default implementation
   throw opengm::RuntimeError("Unsupported Function Type.");
}


template<class VALUE_TYPE, class INDEX_TYPE, class LABEL_TYPE>
inline bool LPFunctionTransfer_impl<SumConstraintFunction<VALUE_TYPE, INDEX_TYPE, LABEL_TYPE>, VALUE_TYPE, INDEX_TYPE, LABEL_TYPE>::isTransferable() {
   // implementation for SumConstraintFunction
   return true;
}

template<class VALUE_TYPE, class INDEX_TYPE, class LABEL_TYPE>
inline typename LPFunctionTransfer_impl<SumConstraintFunction<VALUE_TYPE, INDEX_TYPE, LABEL_TYPE>, VALUE_TYPE, INDEX_TYPE, LABEL_TYPE>::IndexType LPFunctionTransfer_impl<SumConstraintFunction<VALUE_TYPE, INDEX_TYPE, LABEL_TYPE>, VALUE_TYPE, INDEX_TYPE, LABEL_TYPE>::numSlackVariables(const FunctionType& function) {
   // implementation for SumConstraintFunction
   return 1;
}

template<class VALUE_TYPE, class INDEX_TYPE, class LABEL_TYPE>
inline void LPFunctionTransfer_impl<SumConstraintFunction<VALUE_TYPE, INDEX_TYPE, LABEL_TYPE>, VALUE_TYPE, INDEX_TYPE, LABEL_TYPE>::getSlackVariablesOrder(const FunctionType& function, IndicatorVariablesContainerType& order) {
   // implementation for SumConstraintFunction
   order.resize(1);
   order[0] = IndicatorVariableType(function.numVariables_, 0);
}

template<class VALUE_TYPE, class INDEX_TYPE, class LABEL_TYPE>
inline void LPFunctionTransfer_impl<SumConstraintFunction<VALUE_TYPE, INDEX_TYPE, LABEL_TYPE>, VALUE_TYPE, INDEX_TYPE, LABEL_TYPE>::getSlackVariablesObjectiveCoefficients(const FunctionType& function, SlackVariablesObjectiveCoefficientsContainerType& coefficients) {
   // implementation for SumConstraintFunction
   coefficients.resize(1);
   coefficients[0] = function.lambda_;
}

template<class VALUE_TYPE, class INDEX_TYPE, class LABEL_TYPE>
inline void LPFunctionTransfer_impl<SumConstraintFunction<VALUE_TYPE, INDEX_TYPE, LABEL_TYPE>, VALUE_TYPE, INDEX_TYPE, LABEL_TYPE>::getIndicatorVariables(const FunctionType& function, IndicatorVariablesContainerType& variables) {
   // implementation for SumConstraintFunction
   variables.clear();
   for(IndexType i = 0; i < function.numVariables_; ++i) {
      for(LabelType j = 0; j < (function.useSameNumLabels_ ? function.maxNumLabels_ : function.shape_[i]); ++j) {
         const IndicatorVariableType indicatorVariable(i, j);
         variables.push_back(indicatorVariable);
      }
   }
   const IndicatorVariableType slackVariable(function.numVariables_, 0);
   variables.push_back(slackVariable);
}

template<class VALUE_TYPE, class INDEX_TYPE, class LABEL_TYPE>
inline void LPFunctionTransfer_impl<SumConstraintFunction<VALUE_TYPE, INDEX_TYPE, LABEL_TYPE>, VALUE_TYPE, INDEX_TYPE, LABEL_TYPE>::getLinearConstraints(const FunctionType& function, LinearConstraintsContainerType& constraints) {
   // implementation for SumConstraintFunction
   constraints.resize(2);
   LinearConstraintType constraint;
   constraint.setConstraintOperator(LinearConstraintType::LinearConstraintOperatorType::LessEqual);
   constraint.setBound(function.bound_);
   for(IndexType i = 0; i < function.numVariables_; ++i) {
      for(LabelType j = 0; j < (function.useSameNumLabels_ ? function.maxNumLabels_ : function.shape_[i]); ++j) {
         const IndicatorVariableType indicatorVariable(i, j);
         constraint.add(indicatorVariable, function.coefficients_[(function.shareCoefficients_ ? j : function.coefficientsOffsets_[i] + j)]);
      }
   }
   const IndicatorVariableType slackVariable(function.numVariables_, 0);
   constraint.add(slackVariable, -1.0);
   constraints[0] = constraint;

   LinearConstraintType constraint2;
   constraint2.setConstraintOperator(LinearConstraintType::LinearConstraintOperatorType::LessEqual);
   constraint2.setBound(-function.bound_);
   for(IndexType i = 0; i < function.numVariables_; ++i) {
      for(LabelType j = 0; j < (function.useSameNumLabels_ ? function.maxNumLabels_ : function.shape_[i]); ++j) {
         const IndicatorVariableType indicatorVariable(i, j);
         constraint2.add(indicatorVariable, -function.coefficients_[(function.shareCoefficients_ ? j : function.coefficientsOffsets_[i] + j)]);
      }
   }
   constraint2.add(slackVariable, -1.0);
   constraints[1] = constraint2;
}

template<class VALUE_TYPE, class INDEX_TYPE, class LABEL_TYPE>
inline bool LPFunctionTransfer_impl<LabelCostFunction<VALUE_TYPE, INDEX_TYPE, LABEL_TYPE>, VALUE_TYPE, INDEX_TYPE, LABEL_TYPE>::isTransferable() {
   // implementation for LabelCostFunction
   return true;
}

template<class VALUE_TYPE, class INDEX_TYPE, class LABEL_TYPE>
inline typename LPFunctionTransfer_impl<LabelCostFunction<VALUE_TYPE, INDEX_TYPE, LABEL_TYPE>, VALUE_TYPE, INDEX_TYPE, LABEL_TYPE>::IndexType LPFunctionTransfer_impl<LabelCostFunction<VALUE_TYPE, INDEX_TYPE, LABEL_TYPE>, VALUE_TYPE, INDEX_TYPE, LABEL_TYPE>::numSlackVariables(const FunctionType& function) {
   // implementation for LabelCostFunction
   // one slack variable for each label cost which is not zero
   if(function.useSingleCost_) {
      return 1;
   } else {
      IndexType numLabelCosts = 0;
      for(LabelType i = 0; i < function.maxNumLabels_; ++i) {
         // sort out unused labels
         if(function.costs_[i] != 0.0) {
            ++numLabelCosts;
         }
      }
      return numLabelCosts;
   }
}

template<class VALUE_TYPE, class INDEX_TYPE, class LABEL_TYPE>
inline void LPFunctionTransfer_impl<LabelCostFunction<VALUE_TYPE, INDEX_TYPE, LABEL_TYPE>, VALUE_TYPE, INDEX_TYPE, LABEL_TYPE>::getSlackVariablesOrder(const FunctionType& function, IndicatorVariablesContainerType& order) {
   // implementation for LabelCostFunction
   const IndexType numLabelCosts = numSlackVariables(function);
   order.resize(numLabelCosts);
   for(IndexType i = 0; i < numLabelCosts; ++i) {
      order[i] = IndicatorVariableType(function.numVariables_ + i, 0);
   }
}

template<class VALUE_TYPE, class INDEX_TYPE, class LABEL_TYPE>
inline void LPFunctionTransfer_impl<LabelCostFunction<VALUE_TYPE, INDEX_TYPE, LABEL_TYPE>, VALUE_TYPE, INDEX_TYPE, LABEL_TYPE>::getSlackVariablesObjectiveCoefficients(const FunctionType& function, SlackVariablesObjectiveCoefficientsContainerType& coefficients) {
   // implementation for LabelCostFunction
   const IndexType numLabelCosts = numSlackVariables(function);
   coefficients.resize(numLabelCosts);
   if(function.useSingleCost_) {
      OPENGM_ASSERT(numLabelCosts == 1);
      coefficients[0] = function.singleCost_;
   } else {
      LabelType currentCostIndex = 0;
      for(LabelType i = 0; i < function.maxNumLabels_; ++i) {
         // sort out unused label costs
         if(function.costs_[i] != 0.0) {
            coefficients[currentCostIndex] = function.costs_[i];
            ++currentCostIndex;
         }
      }
   }
}

template<class VALUE_TYPE, class INDEX_TYPE, class LABEL_TYPE>
inline void LPFunctionTransfer_impl<LabelCostFunction<VALUE_TYPE, INDEX_TYPE, LABEL_TYPE>, VALUE_TYPE, INDEX_TYPE, LABEL_TYPE>::getIndicatorVariables(const FunctionType& function, IndicatorVariablesContainerType& variables) {
   // implementation for LabelCostFunction
   const IndexType numLabelCosts = numSlackVariables(function);
   variables.resize(numLabelCosts * 2);
   if(function.useSingleCost_) {
      OPENGM_ASSERT(variables.size() == 2);
      IndicatorVariableType indicatorVar;
      indicatorVar.setLogicalOperatorType(IndicatorVariableType::Or);
      if(function.useSameNumLabels_) {
         for(IndexType i = 0; i < function.numVariables_; ++i) {
            indicatorVar.add(i, function.singleLabel_);
         }
      } else {
         for(IndexType i = 0; i < function.numVariables_; ++i) {
            if(function.shape_[i] > function.singleLabel_) {
               indicatorVar.add(i, function.singleLabel_);
            }
         }
      }
      variables[0] = indicatorVar;

      variables[1] = IndicatorVariableType(function.numVariables_, 0);
   } else {
      LabelType currentNonZeroLabel = 0;
      for(LabelType currentLabel = 0; currentLabel < function.maxNumLabels_; ++currentLabel) {
         if(function.costs_[currentLabel] != 0) {
            IndicatorVariableType indicatorVar;
            indicatorVar.setLogicalOperatorType(IndicatorVariableType::Or);
            if(function.useSameNumLabels_) {
               for(IndexType i = 0; i < function.numVariables_; ++i) {
                  indicatorVar.add(i, currentLabel);
               }
            } else {
               for(IndexType i = 0; i < function.numVariables_; ++i) {
                  if(function.shape_[i] > currentLabel) {
                     indicatorVar.add(i, currentLabel);
                  }
               }
            }
            variables[currentNonZeroLabel * 2] = indicatorVar;

            variables[(currentNonZeroLabel * 2) + 1] = IndicatorVariableType(function.numVariables_ + currentNonZeroLabel, 0);
            ++currentNonZeroLabel;
         }
      }
   }
}

template<class VALUE_TYPE, class INDEX_TYPE, class LABEL_TYPE>
inline void LPFunctionTransfer_impl<LabelCostFunction<VALUE_TYPE, INDEX_TYPE, LABEL_TYPE>, VALUE_TYPE, INDEX_TYPE, LABEL_TYPE>::getLinearConstraints(const FunctionType& function, LinearConstraintsContainerType& constraints) {
   // implementation for LabelCostFunction
   IndicatorVariablesContainerType variables;
   getIndicatorVariables(function, variables);
   OPENGM_ASSERT(variables.size() % 2 == 0);

   constraints.resize(variables.size() / 2);
   for(size_t i = 0; i < constraints.size(); ++i) {
      LinearConstraintType constraint;
      constraint.setConstraintOperator(LinearConstraintType::LinearConstraintOperatorType::Equal);
      constraint.setBound(0.0);
      constraint.add(variables[i * 2], 1.0); // Or indicator variable
      constraint.add(variables[(i * 2) + 1], -1.0); // slack variable
      constraints[i] = constraint;
   }
}

} // namespace opengm

#endif /* OPENGM_LP_FUNCTIONTRANSFER_HXX_ */