📄 decoderquad.cpp
字号:
for (int nShiftY = -MAX_SHIFT; nShiftY <= MAX_SHIFT; nShiftY++) {
for (int nShiftX = -MAX_SHIFT; nShiftX <= MAX_SHIFT; nShiftX++) {
int nShift = (nShiftY+MAX_SHIFT)*NUM_SHIFTS + nShiftX+MAX_SHIFT;
if (dProbabilitySum != 0)
pMotionBlock[nBlock*NUM_SHIFTS_2D + nShift] /= dProbabilitySum;
else
pMotionBlock[nBlock*NUM_SHIFTS_2D + nShift] = EPS;
} // end nShiftX
} // end nShiftY
} // end nBlockCol
} // end nBlockRow
delete [] pThetaNew;
return GOOD_RETURN;
}
int pixelQuads_interpolateMotionQuad(const int nInterpolateMethod, double* pMotionBlock, double* pMotionPixel)
{
bool bSuccess = true;
float* pMotionBlockFPlane = new float[BLOCKS_QUAD];
float* pMotionPixelFPlane = new float[PIXELS_QUAD];
//------------------------------------------------------------
// Normalize coarse disparity
//------------------------------------------------------------
double* pSum = new double[PIXELS_QUAD];
if (nInterpolateMethod == INTERP_NN) {
memset(pSum, 0, PIXELS_QUAD*sizeof(double));
for (int nShiftY = 0; nShiftY < NUM_SHIFTS; nShiftY++)
{
for (int nShiftX = 0; nShiftX < NUM_SHIFTS; nShiftX++)
{
int nShift = nShiftY*NUM_SHIFTS + nShiftX;
for (int k1 = 0; k1 < BLOCK_ROWS_QUAD; k1++)
for (int k2 = 0; k2 < BLOCK_COLS_QUAD; k2++)
{
int k3 = k1*BLOCK_COLS_QUAD + k2;
int k4 = k3*NUM_SHIFTS_2D + nShift;
pSum[k3] += pMotionBlock[k4];
}
} // end nShiftX
} // end nShiftY
for (int nShiftY = 0; nShiftY < NUM_SHIFTS; nShiftY++)
{
for (int nShiftX = 0; nShiftX < NUM_SHIFTS; nShiftX++)
{
int nShift = nShiftY*NUM_SHIFTS + nShiftX;
for (int k1 = 0; k1 < BLOCK_ROWS_QUAD; k1++)
for (int k2 = 0; k2 < BLOCK_COLS_QUAD; k2++)
{
int k3 = k1*BLOCK_COLS_QUAD + k2;
int k4 = k3*NUM_SHIFTS_2D + nShift;
if (pSum[k3] != 0.0)
pMotionBlock[k4] /= pSum[k3];
else
pMotionBlock[k4] = EPS;
}
} // end nShiftX
} // end nShiftY
}
//------------------------------------------------------------
// Perform interpolation from block to pixel
//------------------------------------------------------------
for (int nShiftY = 0; nShiftY < NUM_SHIFTS; nShiftY++) {
for (int nShiftX = 0; nShiftX < NUM_SHIFTS; nShiftX++)
{
int nShift = nShiftY*NUM_SHIFTS + nShiftX;
// Copy pMotionBlock[nShift] into image plane
for (int k1 = 0; k1 < BLOCK_ROWS_QUAD; k1++)
for (int k2 = 0; k2 < BLOCK_COLS_QUAD; k2++)
{
int k3 = k1*BLOCK_COLS_QUAD + k2;
int k4 = k3*NUM_SHIFTS_2D + nShift;
pMotionBlockFPlane[k3] = (float)pMotionBlock[k4];
}
// Interpolate the input motion array
RECORD_SUCCESS( ChenImage_interpolateImage(nInterpolateMethod, BLOCK_COLS_QUAD, BLOCK_ROWS_QUAD, pMotionBlockFPlane, WIDTH_QUAD, HEIGHT_QUAD, pMotionPixelFPlane), bSuccess );
// Copy image plane into pMotionPixel[nShift]
for (int k1 = 0; k1 < HEIGHT_QUAD; k1++)
for (int k2 = 0; k2 < WIDTH_QUAD; k2++)
{
int k3 = k1*WIDTH_QUAD + k2;
int k4 = k3*NUM_SHIFTS_2D + nShift;
pMotionPixel[k4] = MAX(0.0, pMotionPixelFPlane[k3]);
}
} // end nShiftX
} // end nShiftY
//------------------------------------------------------------
// Normalize precise disparity
//------------------------------------------------------------
memset(pSum, 0, PIXELS_QUAD*sizeof(double));
for (int nShiftY = 0; nShiftY < NUM_SHIFTS; nShiftY++)
{
for (int nShiftX = 0; nShiftX < NUM_SHIFTS; nShiftX++)
{
int nShift = nShiftY*NUM_SHIFTS + nShiftX;
for (int k1 = 0; k1 < HEIGHT_QUAD; k1++)
for (int k2 = 0; k2 < WIDTH_QUAD; k2++)
{
int k3 = k1*WIDTH_QUAD + k2;
int k4 = k3*NUM_SHIFTS_2D + nShift;
pSum[k3] += pMotionPixel[k4];
}
} // end nShiftX
} // end nShiftY
for (int nShiftY = 0; nShiftY < NUM_SHIFTS; nShiftY++)
{
for (int nShiftX = 0; nShiftX < NUM_SHIFTS; nShiftX++)
{
int nShift = nShiftY*NUM_SHIFTS + nShiftX;
for (int k1 = 0; k1 < HEIGHT_QUAD; k1++)
for (int k2 = 0; k2 < WIDTH_QUAD; k2++)
{
int k3 = k1*WIDTH_QUAD + k2;
int k4 = k3*NUM_SHIFTS_2D + nShift;
if (pSum[k3] != 0.0)
pMotionPixel[k4] /= pSum[k3];
else
pMotionPixel[k4] = EPS;
}
} // end nShiftX
} // end nShiftY
delete [] pSum;
delete [] pMotionBlockFPlane;
delete [] pMotionPixelFPlane;
return bSuccess ? GOOD_RETURN : BAD_RETURN;
}
int pixelQuads_initializeMotionLearningQuad(double* pMotionBlock)
{
double* pMotionBlockX = new double[NUM_SHIFTS];
double* pMotionBlockY = new double[NUM_SHIFTS];
double dCenterX = 0.8;
double dCenterY = 0.8;
double dSideX = 1.0 - dCenterX;
double dSideY = 1.0 - dCenterY;
for (int nBlockRow = 0; nBlockRow < BLOCK_ROWS_QUAD; nBlockRow++)
{
//------------------------------------------------------------
// Set vertical disparity field
//------------------------------------------------------------
// Top block
if( nBlockRow == 0 )
{
for (int l=0; l<MAX_SHIFT; l++)
pMotionBlockY[l] = 0;
pMotionBlockY[MAX_SHIFT] = dCenterY;
for (int l=0; l<MAX_SHIFT; l++)
pMotionBlockY[(MAX_SHIFT+1)+l] = dSideY/(double)MAX_SHIFT;
}
// Bottom block
else if( nBlockRow == BLOCK_ROWS_QUAD - 1 )
{
for (int l=0; l<MAX_SHIFT; l++)
pMotionBlockY[l] = dSideY/(double)MAX_SHIFT;
pMotionBlockY[MAX_SHIFT] = dCenterY;
for (int l=0; l<MAX_SHIFT; l++)
pMotionBlockY[(MAX_SHIFT+1)+l] = 0;
}
// Middle block
else
{
for (int l=0; l<MAX_SHIFT; l++)
pMotionBlockY[l] = dSideY/(double)(2*MAX_SHIFT);
pMotionBlockY[MAX_SHIFT] = dCenterY;
for (int l=0; l<MAX_SHIFT; l++)
pMotionBlockY[(MAX_SHIFT+1)+l] = dSideY/(double)(2*MAX_SHIFT);
}
for (int nBlockCol = 0; nBlockCol < BLOCK_COLS_QUAD; nBlockCol++)
{
int nBlock = nBlockRow*BLOCK_COLS_QUAD + nBlockCol;
//------------------------------------------------------------
// Set horizontal disparity field
//------------------------------------------------------------
// Left block
if( nBlockCol == 0 )
{
for (int l=0; l<MAX_SHIFT; l++)
pMotionBlockX[l] = 0;
pMotionBlockX[MAX_SHIFT] = dCenterX;
for (int l=0; l<MAX_SHIFT; l++)
pMotionBlockX[(MAX_SHIFT+1)+l] = dSideX/(double)MAX_SHIFT;
}
// Right block
else if( nBlockCol == BLOCK_COLS_QUAD - 1 )
{
for (int l=0; l<MAX_SHIFT; l++)
pMotionBlockX[l] = dSideX/(double)MAX_SHIFT;
pMotionBlockX[MAX_SHIFT] = dCenterX;
for (int l=0; l<MAX_SHIFT; l++)
pMotionBlockX[(MAX_SHIFT+1)+l] = 0;
}
// Middle block
else
{
for (int l=0; l<MAX_SHIFT; l++)
pMotionBlockX[l] = dSideX/(double)(2*MAX_SHIFT);
pMotionBlockX[MAX_SHIFT] = dCenterX;
for (int l=0; l<MAX_SHIFT; l++)
pMotionBlockX[(MAX_SHIFT+1)+l] = dSideX/(double)(2*MAX_SHIFT);
}
//------------------------------------------------------------
// Set 2D disparity field
//------------------------------------------------------------
for (int nShiftY = 0; nShiftY < NUM_SHIFTS; nShiftY++) {
for (int nShiftX = 0; nShiftX < NUM_SHIFTS; nShiftX++) {
int nShift = nShiftY*NUM_SHIFTS + nShiftX;
pMotionBlock[nBlock*NUM_SHIFTS_2D + nShift] = pMotionBlockX[nShiftX] * pMotionBlockY[nShiftY];
}
}
} // end nBlockCol
} // end nBlockRow
delete [] pMotionBlockX;
delete [] pMotionBlockY;
return GOOD_RETURN;
}
int pixelQuads_initializeMotionOracleQuad(const short* pShiftsX, const short* pShiftsY, double* pMotionBlock)
{
memset(pMotionBlock, 0, BLOCKS_QUAD*NUM_SHIFTS_2D*sizeof(double));
for (int nBlock = 0; nBlock < BLOCKS_QUAD; nBlock++) {
int nShiftX = MAX_SHIFT + pShiftsX[nBlock];
int nShiftY = MAX_SHIFT + pShiftsY[nBlock];
int nShift = nShiftY*NUM_SHIFTS + nShiftX;
pMotionBlock[nBlock*NUM_SHIFTS_2D + nShift] = 1.0;
} // end nBlock
return GOOD_RETURN;
}
int pixelQuads_initializeMotionNoCompensationQuad(double* pMotionBlock)
{
memset(pMotionBlock, 0, BLOCKS_QUAD*NUM_SHIFTS_2D*sizeof(double));
for (int nBlock = 0; nBlock < BLOCKS_QUAD; nBlock++) {
int nShiftX = MAX_SHIFT;
int nShiftY = MAX_SHIFT;
int nShift = nShiftY*NUM_SHIFTS + nShiftX;
pMotionBlock[nBlock*NUM_SHIFTS_2D + nShift] = 1.0;
} // end nBlock
return GOOD_RETURN;
}
int pixelQuads_decodeBitsQuad(const CodingOption* pOption, const short* pSideInfo, const uchar* pParity, const float fRateBound, const float* pLaplacian, const short* pQuantCoeffRange, const short* pOracleShiftsX, const short* pOracleShiftsY, double* pDecodedBits, float* pDecodedRate, double* pMotionBlock, double* pMotionPixel)
{
bool bSuccess = true;
time_t nTimeStart, nTimeEnd;
//------------------------------------------------------------
// Initialize
//------------------------------------------------------------
FILE* pLadderFile = fopen(pOption->pLadderFileName, "r");
if (pLadderFile == NULL) return BAD_RETURN;
double* pChannel = new double[(2*LEVELS-1) * NUM_COEFFS];
double* pProbArray = new double[LEVELS];
double* pThetaArray = new double[LEVELS * BLOCK_SIZE * BLOCK_SIZE];
int nNumCodes, nCodeLength, nCodeEdges, nTotalNumInc;
fscanf(pLadderFile, "%d", &nNumCodes);
fscanf(pLadderFile, "%d", &nCodeLength);
fscanf(pLadderFile, "%d", &nCodeEdges);
fscanf(pLadderFile, "%d", &nTotalNumInc);
int* pIR = new int[nCodeEdges];
int* pJC = new int[nCodeLength+1];
int* pTxSeq = new int[nTotalNumInc];
double* pSyndrome = new double[nCodeLength];
double* pLLRMemory = new double[nCodeEdges];
double* pCheckLLR = new double[nCodeEdges];
double* pCheckLLRMag = new double[nCodeEdges];
double* pRowTotal = new double[nCodeLength];
double* pLLROutput = new double[nCodeLength];
double* pLLRSideInfo = new double[nCodeLength];
for (int k = 0; k < nCodeLength+1; k++)
fscanf(pLadderFile, "%d", pJC+k);
int* pNumIncRead = new int[nNumCodes];
int** pTxSeqRead = new int*[nNumCodes];
int** pIrRead = new int*[nNumCodes];
for (int nCode = 0; nCode < nNumCodes; nCode++) {
pTxSeqRead[nCode] = new int[nTotalNumInc];
pIrRead[nCode] = new int[nCodeEdges];
}
int* pNumEdgesRead = new int[nNumCodes];
float* pRateRead = new float[nNumCodes];
for (int nCode = 0; nCode < nNumCodes; nCode++)
{
fscanf(pLadderFile, "%d", pNumIncRead+nCode);
for (int k = 0; k < pNumIncRead[nCode]; k++)
fscanf(pLadderFile, "%d", pTxSeqRead[nCode]+k);
for (int k = 0; k < nCodeEdges; k++)
fscanf(pLadderFile, "%d", pIrRead[nCode]+k);
pNumEdgesRead[nCode] = (nCodeLength/nTotalNumInc)*pNumIncRead[nCode];
pRateRead[nCode] = ((float) pNumEdgesRead[nCode])/((float) nCodeLength);
}
fclose(pLadderFile);
//------------------------------------------------------------
// Set Laplacian channel
//------------------------------------------------------------
for (int l = 0; l < NUM_COEFFS; l++) {
for (int k = 0; k < (2*LEVELS-1); k++) {
pChannel[(2*LEVELS-1)*l + k] = exp(-pLaplacian[l]*fabs( (double) k-(LEVELS-1) )) + 0.0001;
}
}
//------------------------------------------------------------
// Loop over rates
//------------------------------------------------------------
float fLinLow = fRateBound;
int nCodeStart = 0;
while (pRateRead[nCodeStart] < fLinLow) nCodeStart++;
bool bConverged = false;
for (int nCode = nCodeStart; nCode < nNumCodes; nCode++) {
time(&nTimeStart);
//------------------------------------------------------------
// Copy previously read parameters
//------------------------------------------------------------
int nNumInc = pNumIncRead[nCode];
for (int k = 0; k < nNumInc; k++) {
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -