void BPFlow::AllocateMessage()
{
// delete the buffers for the messages
_Release1DBuffer(pSpatialMessage);
_Release1DBuffer(ptrSpatialMessage);
_Release1DBuffer(pBelief);
_Release1DBuffer(ptrBelief);
// allocate the buffers for the messages
nTotalSpatialElements = AllocateBuffer(pSpatialMessage, nNeighbors, ptrSpatialMessage, WinSize);
nTotalBeliefElements = AllocateBuffer(pBelief, 1, ptrBelief, WinSize);
}
//------------------------------------------------------------------------------------------------
// function for belief propagation
//------------------------------------------------------------------------------------------------
double BPFlow::MessagePassing(int nIterations,int nHierarchy,double* pEnergyList)
{
AllocateMessage();
if(nHierarchy>0)
{
BPFlow bp;
generateCoarserLevel(bp);
bp.MessagePassing(20,nHierarchy-1);
bp.propagateFinerLevel(*this);
}
if(pX!=NULL)
_Release1DBuffer(pX);
pX=new int[Area*2];
double energy;
for(int count=0;count<nIterations;count++)
{
//Bipartite(count);
BP_S(count);
//TRW_S(count);
//FindOptimalSolutionSequential();
ComputeBelief();
FindOptimalSolution();
energy=GetEnergy();
if(IsDisplay)
printf("No. %d energy: %f...\n",count,energy);
if(pEnergyList!=NULL)
pEnergyList[count]=energy;
}
return energy;
}
void BPFlow::LoadMasks(int _width, int _height, const bool *mask1, const bool *mask2)
{
int area = _width * _height;
_Release1DBuffer(pMask1);
_Release1DBuffer(pMask2);
pMask1 = new bool[area];
pMask2 = new bool[area];
if (mask1 == NULL) memset(pMask1, true, sizeof(bool) * area);
else memcpy(pMask1, mask1, sizeof(bool) * area);
if (mask2 == NULL) memset(pMask2, true, sizeof(bool) * area);
else memcpy(pMask2, mask2, sizeof(bool) * area);
}
//----------------------------------------------------------------------
// function to load images
//----------------------------------------------------------------------
void BPFlow::LoadImages(int _width, int _height, int _nchannels, const T_input *pImage1, const T_input *pImage2)
{
Width=_width;
Height=_height;
Area=Width*Height;
nChannels=_nchannels;
_Release1DBuffer(pIm1);
_Release1DBuffer(pIm2);
pIm1=new T_input[Width*Height*nChannels];
pIm2=new T_input[Width*Height*nChannels];
memcpy(pIm1,pImage1,sizeof(T_input)*Width*Height*nChannels);
memcpy(pIm2,pImage2,sizeof(T_input)*Width*Height*nChannels);
Width2=Width;
Height2=Height;
}
//------------------------------------------------------------------------------------------------
// function to set the homogeneous MRF parameters
// There is no offset, and the window size is identical for each pixel (winSize)
//------------------------------------------------------------------------------------------------
void BPFlow::setHomogeneousMRF(int winSize)
{
for(int i=0;i<2;i++)
{
_Release1DBuffer(pOffset[i]); // release the buffer of the offset
_Release1DBuffer(pWinSize[i]); // release the buffer of the size
pOffset[i]=new T_state[Area];
memset(pOffset[i],0,sizeof(T_state)*Area);
pWinSize[i]=new T_state[Area];
for(size_t j=0;j<Area;j++)
pWinSize[i][j]=winSize;//+CStochastic::UniformSampling(3)-1;
}
// add some disturbance
for(int i=0;i<2;i++)
for(int j=0;j<Area;j++)
pOffset[i][j]=CStochastic::UniformSampling(5)-2;
}
//------------------------------------------------------------------------------------------------
// function to compute range term
//------------------------------------------------------------------------------------------------
void BPFlow::ComputeRangeTerm(double _gamma)
{
gamma=_gamma;
for(int i=0;i<2;i++)
{
_Release1DBuffer(pRangeTerm[i]);
_Release1DBuffer(ptrRangeTerm[i]);
AllocateBuffer(pRangeTerm[i],1,ptrRangeTerm[i],pWinSize[i]);
}
for(ptrdiff_t offset=0;offset<Area;offset++)
{
for(ptrdiff_t plane=0;plane<2;plane++)
{
int winsize=pWinSize[plane][offset];
for(ptrdiff_t j=-winsize;j<=winsize;j++)
pRangeTerm[plane][offset].data()[j+winsize]=gamma*fabs((double)j+pOffset[plane][offset]);
}
}
}
//------------------------------------------------------------------------------------------------
// function to compute range term
//------------------------------------------------------------------------------------------------
void BPFlow::ComputeRangeTerm(double _gamma)
{
gamma = _gamma;
_Release1DBuffer(pRangeTerm);
_Release1DBuffer(ptrRangeTerm);
AllocateBuffer(pRangeTerm, 1, ptrRangeTerm, WinSize);
int xWinLen = WinSize * 2 + 1;
for(int offset = 0; offset < Area; offset++)
{
for (int i = -WinSize; i <= WinSize; i++)
{
for(int j = -WinSize; j <= WinSize; j++)
{
int index = i + WinSize + (j + WinSize) * xWinLen;
pRangeTerm[offset].data()[index] = gamma * (fabs(i + pOffset[0][offset]) + fabs(j + pOffset[1][offset]));
}
}
}
}
//------------------------------------------------------------------------------------------------
// function to set the homogeneous MRF parameters
// There is no offset, and the window size is identical for each pixel (winSize)
//------------------------------------------------------------------------------------------------
void BPFlow::setHomogeneousMRF(int winSize)
{
WinSize = winSize;
for(int i = 0; i < 2; i++)
{
_Release1DBuffer(pOffset[i]); // release the buffer of the offset
pOffset[i] = new T_state[Area];
memset(pOffset[i], 0, sizeof(T_state) * Area);
}
// add gaussian disturbance here
}
void BPFlow::AllocateMessage()
{
// delete the buffers for the messages
for(int i=0;i<2;i++)
{
_Release1DBuffer(pSpatialMessage[i]);
_Release1DBuffer(ptrSpatialMessage[i]);
_Release1DBuffer(pDualMessage[i]);
_Release1DBuffer(ptrDualMessage[i]);
_Release1DBuffer(pBelief[i]);
_Release1DBuffer(ptrBelief[i]);
}
// allocate the buffers for the messages
for(int i=0;i<2;i++)
{
nTotalSpatialElements[i]=AllocateBuffer(pSpatialMessage[i],nNeighbors,ptrSpatialMessage[i],pWinSize[i]);
nTotalDualElements[i]=AllocateBuffer(pDualMessage[i],1,ptrDualMessage[i],pWinSize[i]);
nTotalBelifElements[i]=AllocateBuffer(pBelief[i],1,ptrBelief[i],pWinSize[i]);
}
}
void BPFlow::ReleaseBuffer()
{
_Release1DBuffer(pIm1);
_Release1DBuffer(pIm2);
for(int i=0;i<2;i++)
{
_Release1DBuffer(pOffset[i]); // release the buffer of the offset
_Release1DBuffer(pWinSize[i]); // release the buffer of the size
}
_Release1DBuffer(pDataTerm);
_Release1DBuffer(ptrDataTerm);
for(int i=0;i<2;i++)
{
_Release1DBuffer(pRangeTerm[i]);
_Release1DBuffer(ptrRangeTerm[i]);
_Release1DBuffer(pSpatialMessage[i]);
_Release1DBuffer(ptrSpatialMessage[i]);
_Release1DBuffer(pDualMessage[i]);
_Release1DBuffer(ptrDualMessage[i]);
_Release1DBuffer(pBelief[i]);
_Release1DBuffer(ptrBelief[i]);
}
_Release1DBuffer(pX);
}
void BPFlow::ReleaseBuffer()
{
_Release1DBuffer(pIm1);
_Release1DBuffer(pIm2);
_Release1DBuffer(pMask1);
_Release1DBuffer(pMask2);
// release the buffer of the offset
for(int i = 0; i < 2; i++)
_Release1DBuffer(pOffset[i]);
_Release1DBuffer(pDataTerm);
_Release1DBuffer(ptrDataTerm);
_Release1DBuffer(pRangeTerm);
_Release1DBuffer(ptrRangeTerm);
_Release1DBuffer(pSpatialMessage);
_Release1DBuffer(ptrSpatialMessage);
_Release1DBuffer(pBelief);
_Release1DBuffer(ptrBelief);
_Release1DBuffer(pX);
}
