dtype compute_graph(int num_parts_y,int num_parts_x,dtype *costs,int num_lab_y,int num_lab_x,dtype *data,int *laborder,int *reslab)
{
MRF* mrf;
//Expansion* mrf;
//EnergyFunction *energy;
MRF::EnergyVal E;
double lowerBound;
float t,tot_t;
int iter;
int seed = 1124285485;
srand(seed);
dtype scr;
//copy costs in local memory
//dtype V[maxlab*maxlab];
st_cost_v_y=costs;
st_cost_v_x=costs+num_parts_x*num_parts_y;
st_cost_h_y=costs+2*num_parts_x*num_parts_y;
st_cost_h_x=costs+3*num_parts_x*num_parts_y;
st_parts_x=num_parts_x;
st_parts_y=num_parts_y;
st_num_lab_x=num_lab_x;
st_num_lab_y=num_lab_y;
st_numlab=num_lab_y*num_lab_x;//num_parts_x*num_parts_y;//num_labels;
//dtype* V=(dtype*)malloc(st_numlab*st_numlab*sizeof(dtype));
clock_t t0,t1;
t0 = clock ();
int l1,l2;
//printf("At least here!!!\n");
/*for (l1=0;l1<st_numlab;l1++)
{
for (l2=0;l2<st_numlab;l2++)
{
int x1=l1%num_lab_x;
int y1=l1/num_lab_x;
int x2=l2%num_lab_x;
int y2=l2/num_lab_x;
V[l1*st_numlab+l2]=abs(x1-x2)+abs(y1-y2);
}
}*/
t1 = clock ();
//printf("t0=%d t1=%d Diff %f",t0,t1,float(t1-t0)/CLOCKS_PER_SEC);
//try{
DataCost *dt = new DataCost(data);
//SmoothnessCost *sm = new SmoothnessCost(smoothApp2);
//SmoothnessCost *sm = new SmoothnessCost(smoothApp3);
//SmoothnessCost *sm = new SmoothnessCost(smoothApp4);
SmoothnessCost *sm = new SmoothnessCost(smoothApp5);
//SmoothnessCost *sm = new SmoothnessCost(V, st_cost_x, st_cost_y);
//SmoothnessCost *sm = new SmoothnessCost(1, 100, 1, st_cost_v_x, st_cost_v_y);
EnergyFunction *energy = new EnergyFunction(dt,sm);
// GCoptimizationGeneralGraph *gc = new GCoptimizationGeneralGraph(num_parts,num_labels);
// // set up the needed data to pass to function for the data costs
// //ForDataFn toFn;
// //toFn.data = data;
// //toFn.numLab = num_labels;
// //gc->setDataCost(&dataFn,&toFn);
// gc->setDataCost(data);
//
// // smoothness comes from function pointer
// gc->setSmoothCost(&smoothApp);
// // now set up a graph neighborhood system
// // use only the upper part of the matrix
// for (int py=0; py<num_parts; py++ )
// for (int px=py+1; px<num_parts; px++)
// if (connect[py*num_parts+px]>0)
// {
// //gc->setNeighbors(px,py);
// gc->setNeighbors(py,px);
// }
//
// //printf("\nBefore optimization energy is %f",gc->compute_energy());
// gc->expansion(10);// run expansion for 2 iterations. For swap use gc->swap(num_iterations);
// scr=gc->compute_energy();
// //printf("\nAfter optimization energy is %f \n",scr);
///new way
//printf("%d,%d\n",num_parts_x,num_parts_y);
//mrf = new MaxProdBP(num_parts_x,num_parts_y,num_parts_x*num_parts_y,energy);
//mrf = new BPS(num_parts_x,num_parts_y,num_parts_x*num_parts_y,energy);
//mrf = new Swap(num_parts_x,num_parts_y,num_lab_y*num_lab_x,energy);
mrf = new Expansion(num_parts_x,num_parts_y,num_lab_y*num_lab_x,energy);
//((Expansion*)mrf)->setLabelOrder(0);
if (laborder!=NULL)
((Expansion*)mrf)->setMyLabelOrder(laborder);
Energy* trees=NULL;
//((Expansion*)mrf)->setEnergies(trees);
int* sol=NULL;
//((Expansion*)mrf)->setSolutions(sol);
#include<time.h>
//clock_t t0,t1;
//mrf = new TRWS(num_parts_x,num_parts_y,num_lab_y*num_lab_x,energy);
//mrf = new ICM(num_parts_x,num_parts_y,st_numlab,energy);
// can disable caching of values of general smoothness function:
//mrf->dontCacheSmoothnessCosts();
t0 = clock ();
mrf->initialize();
t1 = clock ();
//mrf->setCues(st_cost_x,st_cost_y);
//mrf->clearAnswer();
// for ( int i = 0; i < num_parts_y*num_parts_x; i++ )
// {
// mrf->setLabel(i,reslab[i]);
// reslab[i] = mrf->getLabel(i);//gc->whatLabel(i);
// printf("%d ",reslab[i]);
// }
//printf("+++++\n");
// E = mrf->totalEnergy();
//printf("Energy at the Start= %g (%g,%g)\n", (float)E,
// (float)mrf->smoothnessEnergy(), (float)mrf->dataEnergy());
//printf("t0=%d t1=%d Diff %f",t0,t1,float(t1-t0)/CLOCKS_PER_SEC);
tot_t = 0;
//printf("Before C\n");
for (iter=0; iter<1; iter++)
{
mrf->optimize(1, t);
//printf("After C\n");
E = mrf->totalEnergy();
lowerBound = mrf->lowerBound();
tot_t = tot_t + t ;
//printf("Energy= %g (%g,%g)\n", (float)E,
//(float)mrf->smoothnessEnergy(), (float)mrf->dataEnergy());
//printf("energy = %g, lower bound = %f (%f secs)\n", (float)E, lowerBound, tot_t);
}
for ( int i = 0; i < num_parts_y*num_parts_x; i++ )
{
reslab[i] = mrf->getLabel(i);//gc->whatLabel(i);
//printf("%d ",reslab[i]);
}
trees=((Expansion*)mrf)->getEnergies();
sol=((Expansion*)mrf)->getSolutions();
delete mrf;
//}
//catch (GCException e){
// e.Report();
//}
//delete [] result;
//delete [] data;
//free(V);
return -E;
}
dtype compute_graph2(int num_parts_y,int num_parts_x,dtype *costs,int num_lab_y,int num_lab_x,dtype *data,int numhyp,dtype* lscr,int *reslab)
{
MRF* mrf;
//Expansion* mrf;
//EnergyFunction *energy;
MRF::EnergyVal E;
double lowerBound;
float t,tot_t;
int iter;
int seed = 1124285485;
srand(seed);
dtype scr;
//copy costs in local memory
//dtype V[maxlab*maxlab];
st_cost_v_y=costs;
st_cost_v_x=costs+num_parts_x*num_parts_y;
st_cost_h_y=costs+2*num_parts_x*num_parts_y;
st_cost_h_x=costs+3*num_parts_x*num_parts_y;
st_parts_x=num_parts_x;
st_parts_y=num_parts_y;
st_num_lab_x=num_lab_x;
st_num_lab_y=num_lab_y;
st_numlab=num_lab_y*num_lab_x;//num_parts_x*num_parts_y;//num_labels;
//dtype* V=(dtype*)malloc(st_numlab*st_numlab*sizeof(dtype));
clock_t t0,t1;
t0 = clock ();
int l1,l2;
DataCost *dt = new DataCost(data);
//SmoothnessCost *sm = new SmoothnessCost(smoothApp2);
//SmoothnessCost *sm = new SmoothnessCost(smoothApp3);
//SmoothnessCost *sm = new SmoothnessCost(smoothApp4);
SmoothnessCost *sm = new SmoothnessCost(smoothApp5);
//SmoothnessCost *sm = new SmoothnessCost(V, st_cost_x, st_cost_y);
//SmoothnessCost *sm = new SmoothnessCost(1, 100, 1, st_cost_v_x, st_cost_v_y);
EnergyFunction *energy = new EnergyFunction(dt,sm);
//int *ilaborder = new int[st_numlab];
//int *sumpart = new int[st_numlab];
///new way
//printf("%d,%d\n",num_parts_x,num_parts_y);
//mrf = new MaxProdBP(num_parts_x,num_parts_y,num_parts_x*num_parts_y,energy);
//mrf = new BPS(num_parts_x,num_parts_y,num_parts_x*num_parts_y,energy);
//mrf = new Swap(num_parts_x,num_parts_y,num_lab_y*num_lab_x,energy);
mrf = new Expansion(num_parts_x,num_parts_y,num_lab_y*num_lab_x,energy);
//((Expansion*)mrf)->setLabelOrder(0);
//if (laborder!=NULL)
// ((Expansion*)mrf)->setMyLabelOrder(laborder);
Energy* trees=NULL;
//((Expansion*)mrf)->setEnergies(trees);
int* sol=NULL;
//((Expansion*)mrf)->setSolutions(sol);
#include<time.h>
//clock_t t0,t1;
//mrf = new TRWS(num_parts_x,num_parts_y,num_lab_y*num_lab_x,energy);
//mrf = new ICM(num_parts_x,num_parts_y,st_numlab,energy);
// can disable caching of values of general smoothness function:
//mrf->dontCacheSmoothnessCosts();
//t0 = clock ();
mrf->initialize();
tot_t = 0;
//printf("Before C\n");
for (iter=0; iter<numhyp; iter++)
{
//((Expansion*)mrf)->setLabelOrder(0);
/*for (int lab=0;lab<st_numlab;lab++)
for (int part=0;part<num_parts_y*num_parts_x;part++)
sumpart[lab]+=data[part*st_numlab+lab];
argsort(sumpart,ilaborder,st_numlab);*/
/*for (int i = 0; i < st_numlab; i++)
ilaborder[i]=i;*/
//((Expansion*)mrf)->setMyLabelOrder(ilaborder);
mrf->optimize(3, t);
//printf("After C\n");
E = mrf->totalEnergy();
lowerBound = mrf->lowerBound();
tot_t = tot_t + t ;
*lscr=-E;
lscr++;
//t0 = clock ();
for ( int i = 0; i < num_parts_y*num_parts_x; i++ )
{
int aux=mrf->getLabel(i);
reslab[iter*num_parts_y*num_parts_x+i] = aux;//gc->whatLabel(i);
//data[i*st_numlab+aux]=1;//delete solution
for (int rx=-1;rx<2;rx++)
{
for (int ry=-1;ry<2;ry++)
{
int pp=aux+rx+ry*st_num_lab_x;
pp=maxi(pp,0);
pp=mini(pp,st_numlab);
data[pp+i*st_numlab]=1;//delete solution
}
}
//printf("%d ",reslab[i]);
}
//t1 = clock ();
//printf("t0=%d t1=%d Diff %f \n",t0,t1,float(t1-t0)/CLOCKS_PER_SEC);
//trees=((Expansion*)mrf)->getEnergies();
//sol=((Expansion*)mrf)->getSolutions();
}
delete mrf;
t1 = clock ();
//printf("t0=%d t1=%d Diff %f \n",t0,t1,float(t1-t0)/CLOCKS_PER_SEC);
return -E;
}
int main(int argc, char **argv)
{
MRF* mrf;
EnergyFunction *energy;
MRF::EnergyVal E;
double lowerBound;
float t,tot_t;
int iter;
int seed = 1124285485;
srand(seed);
int Etype = 0;
if (argc != 2) {
fprintf(stderr, usage, argv[0]);
exit(1);
}
if (argc > 1)
Etype = atoi(argv[1]);
try {
switch(Etype) {
// Here are 4 sample energies to play with.
case 0:
energy = generate_DataARRAY_SmoothFIXED_FUNCTION();
fprintf(stderr, "using fixed (array) smoothness cost\n");
break;
case 1:
energy = generate_DataARRAY_SmoothTRUNCATED_LINEAR();
fprintf(stderr, "using truncated linear smoothness cost\n");
break;
case 2:
energy = generate_DataARRAY_SmoothTRUNCATED_QUADRATIC();
fprintf(stderr, "using truncated quadratic smoothness cost\n");
break;
case 3:
energy = generate_DataFUNCTION_SmoothGENERAL_FUNCTION();
fprintf(stderr, "using general smoothness functions\n");
break;
default:
fprintf(stderr, usage, argv[0]);
exit(1);
}
bool runICM = true;
bool runExpansion = true;
bool runSwap = true;
bool runMaxProdBP = true;
bool runTRWS = true;
bool runBPS = true;
////////////////////////////////////////////////
// ICM //
////////////////////////////////////////////////
if (runICM) {
printf("\n*******Started ICM *****\n");
mrf = new ICM(sizeX,sizeY,numLabels,energy);
mrf->initialize();
mrf->clearAnswer();
E = mrf->totalEnergy();
printf("Energy at the Start= %g (%g,%g)\n", (float)E,
(float)mrf->smoothnessEnergy(), (float)mrf->dataEnergy());
tot_t = 0;
for (iter=0; iter<6; iter++) {
mrf->optimize(10, t);
E = mrf->totalEnergy();
tot_t = tot_t + t ;
printf("energy = %g (%f secs)\n", (float)E, tot_t);
}
delete mrf;
}
////////////////////////////////////////////////
// Graph-cuts expansion //
////////////////////////////////////////////////
if (runExpansion) {
printf("\n*******Started graph-cuts expansion *****\n");
mrf = new Expansion(sizeX,sizeY,numLabels,energy);
mrf->initialize();
mrf->clearAnswer();
E = mrf->totalEnergy();
printf("Energy at the Start= %g (%g,%g)\n", (float)E,
(float)mrf->smoothnessEnergy(), (float)mrf->dataEnergy());
#ifdef COUNT_TRUNCATIONS
truncCnt = totalCnt = 0;
#endif
tot_t = 0;
for (iter=0; iter<6; iter++) {
mrf->optimize(1, t);
E = mrf->totalEnergy();
tot_t = tot_t + t ;
printf("energy = %g (%f secs)\n", (float)E, tot_t);
}
#ifdef COUNT_TRUNCATIONS
if (truncCnt > 0)
printf("***WARNING: %d terms (%.2f%%) were truncated to ensure regularity\n",
truncCnt, (float)(100.0 * truncCnt / totalCnt));
#endif
delete mrf;
}
////////////////////////////////////////////////
// Graph-cuts swap //
////////////////////////////////////////////////
if (runSwap) {
printf("\n*******Started graph-cuts swap *****\n");
mrf = new Swap(sizeX,sizeY,numLabels,energy);
mrf->initialize();
mrf->clearAnswer();
E = mrf->totalEnergy();
printf("Energy at the Start= %g (%g,%g)\n", (float)E,
(float)mrf->smoothnessEnergy(), (float)mrf->dataEnergy());
#ifdef COUNT_TRUNCATIONS
truncCnt = totalCnt = 0;
#endif
tot_t = 0;
for (iter=0; iter<8; iter++) {
mrf->optimize(1, t);
E = mrf->totalEnergy();
tot_t = tot_t + t ;
printf("energy = %g (%f secs)\n", (float)E, tot_t);
}
#ifdef COUNT_TRUNCATIONS
if (truncCnt > 0)
printf("***WARNING: %d terms (%.2f%%) were truncated to ensure regularity\n",
truncCnt, (float)(100.0 * truncCnt / totalCnt));
#endif
delete mrf;
}
////////////////////////////////////////////////
// Belief Propagation //
////////////////////////////////////////////////
if (runMaxProdBP) {
printf("\n******* Started MaxProd Belief Propagation *****\n");
mrf = new MaxProdBP(sizeX,sizeY,numLabels,energy);
mrf->initialize();
mrf->clearAnswer();
E = mrf->totalEnergy();
printf("Energy at the Start= %g (%g,%g)\n", (float)E,
(float)mrf->smoothnessEnergy(), (float)mrf->dataEnergy());
tot_t = 0;
for (iter=0; iter < 10; iter++) {
mrf->optimize(1, t);
E = mrf->totalEnergy();
tot_t = tot_t + t ;
printf("energy = %g (%f secs)\n", (float)E, tot_t);
}
delete mrf;
}
////////////////////////////////////////////////
// TRW-S //
////////////////////////////////////////////////
if (runTRWS) {
printf("\n*******Started TRW-S *****\n");
mrf = new TRWS(sizeX,sizeY,numLabels,energy);
// can disable caching of values of general smoothness function:
//mrf->dontCacheSmoothnessCosts();
mrf->initialize();
mrf->clearAnswer();
E = mrf->totalEnergy();
printf("Energy at the Start= %g (%g,%g)\n", (float)E,
(float)mrf->smoothnessEnergy(), (float)mrf->dataEnergy());
tot_t = 0;
for (iter=0; iter<10; iter++) {
mrf->optimize(10, t);
E = mrf->totalEnergy();
lowerBound = mrf->lowerBound();
tot_t = tot_t + t ;
printf("energy = %g, lower bound = %f (%f secs)\n", (float)E, lowerBound, tot_t);
}
delete mrf;
}
////////////////////////////////////////////////
// BP-S //
////////////////////////////////////////////////
if (runBPS) {
printf("\n*******Started BP-S *****\n");
mrf = new BPS(sizeX,sizeY,numLabels,energy);
// can disable caching of values of general smoothness function:
//mrf->dontCacheSmoothnessCosts();
mrf->initialize();
mrf->clearAnswer();
E = mrf->totalEnergy();
printf("Energy at the Start= %g (%g,%g)\n", (float)E,
(float)mrf->smoothnessEnergy(), (float)mrf->dataEnergy());
tot_t = 0;
for (iter=0; iter<10; iter++) {
mrf->optimize(10, t);
E = mrf->totalEnergy();
tot_t = tot_t + t ;
printf("energy = %g (%f secs)\n", (float)E, tot_t);
}
delete mrf;
}
}
catch (std::bad_alloc) {
fprintf(stderr, "*** Error: not enough memory\n");
exit(1);
}
return 0;
}
