8位、24位原图数据（RAW）反像、水平镜像、垂直镜像算法实现 .

#define GFP_OPERATORIMAGEDATA_TYPE_INVERSE			1	// 反像图像数据
#define GFP_OPERATORIMAGEDATA_TYPE_HMIRROR			2	// 水平镜像图像数据
#define GFP_OPERATORIMAGEDATA_TYPE_VMIRROR			3	// 垂直镜像图像数据

//24位
int OperatorImageDataEx(UCHAR* pImageData, int nw, int nh, int nBitCnt, UCHAR fOprType)
{
if(nBitCnt == 8)
return Gfp_OperatorImageData(pImageData, nw, nh, fOprType);

if(nBitCnt != 24)
return 0;

UCHAR *pTmpData,  *pRowData, nSwap[3];
int col, row, nMid, nrowLen, nOff;

//	if(nBitCnt == 8)
//		nrowLen = nw;
//	else
nrowLen = nw * 3;

switch(fOprType)
{
case GFP_OPERATORIMAGEDATA_TYPE_INVERSE:
pTmpData = pImageData;
for(row = 0; row < nh; row++)
{
for(col = 0; col < nrowLen; col++, pTmpData++)
{
*pTmpData = ~(*pTmpData);
}
}
return 1;

case GFP_OPERATORIMAGEDATA_TYPE_HMIRROR:
nMid = nw >> 1;
pTmpData = pImageData;
for(row = 0; row < nh; row++, pTmpData += nrowLen)
{
for(col = 0, nOff = 0; col < nMid; col++, nOff += 3)
{
memcpy(nSwap, pTmpData + nOff, 3);
memcpy(pTmpData + nOff, pTmpData + (nw - 1 - col) * 3, 3);
memcpy(pTmpData + (nw - 1 - col) * 3, nSwap, 3);
}
}
return 1;

case GFP_OPERATORIMAGEDATA_TYPE_VMIRROR:
nMid = nh >> 1;
pRowData = (UCHAR*)malloc(sizeof(UCHAR) *  nrowLen);
if(NULL == pRowData)
return 0;
pTmpData = pImageData;
for(row = 0; row < nMid; row++, pTmpData += nrowLen)
{
memcpy(pRowData, pTmpData, nrowLen);
memcpy(pTmpData, pImageData + (nh - 1 - row) * nrowLen, nrowLen);
memcpy(pImageData + (nh - 1 - row) * nrowLen, pRowData, nrowLen);
}
free(pRowData);
pRowData = NULL;
return 1;

case GFP_OPERATORIMAGEDATA_TYPE_RU90IRROR:
{
unsigned char* pData = (unsigned char*)malloc(3*nh*nw);
memset(pData, 0, 3*nw*nh);

int nLineLen = 3*nw;

int nlineLen1 = 3*nh;
//memcpy(pData, pImageData, 3*nh*nw);
for(int i = 0; i < nh; i++)
{
for(int j = 0; j < nw; j++)
{
memcpy(pData + j* nlineLen1 + (nh - i - 1)* 3, /*j*nh + nh -1 -i ,*/ pImageData +i * nLineLen + j* 3, 3 );
//*(pData + j * nh + nh - 1 - i) = *(pImageData + i * nw + j);
}
}
memcpy(pImageData, pData, 3*nh*nw);
free(pData);
pData = NULL;
return 1;
}

case GFP_OPERATORIMAGEDATA_TYPE_LD90IRROR:
{
unsigned char* pData1 = (unsigned char*)malloc(3*nh*nw);
memset(pData1, 0, 3*nw*nh);
int nWLenth = 3*nw;
int nHLenth = 3*nh;

for( int i = 0; i < nh; i++ )
{
for(int j =0; j < nw; j++ )
{
//memcpy(pData1+(nh-1-j)*nWLenth + i*3, pImageData+i*nWLenth+j*3, 3);
memcpy(pData1 + (nw-1-j)*nHLenth + i*3, pImageData + i*nWLenth + j*3, 3);
}
}
memcpy(pImageData,pData1,3*nw*nh);
free(pData1);
pData1 = NULL;
return 1;
}
}

return 0;
}

//8位
int OperatorImageData(UCHAR* pImageData, int nw, int nh, UCHAR fOprType)
{
if(NULL == pImageData)
return 0;

UCHAR *pTmpData,  *pRowData, nSwap;
int col, row, nMid;

switch(fOprType)
{
case GFP_OPERATORIMAGEDATA_TYPE_INVERSE:
pTmpData = pImageData;
for(row = 0; row < nh; row++)
{
for(col = 0; col < nw; col++, pTmpData++)
{
*pTmpData = ~(*pTmpData);
}
}
return 1;

case GFP_OPERATORIMAGEDATA_TYPE_HMIRROR:
nMid = nw >> 1;
pTmpData = pImageData;
for(row = 0; row < nh; row++, pTmpData += nw)
{
for(col = 0; col < nMid; col++)
{
nSwap = pTmpData[col];
pTmpData[col] = pTmpData[nw - 1 - col];
pTmpData[nw - 1 - col] = nSwap;
}
}
return 1;

case GFP_OPERATORIMAGEDATA_TYPE_VMIRROR:
nMid = nh >> 1;
pRowData = (UCHAR*)malloc(sizeof(UCHAR) *  nw);
if(NULL == pRowData)
return 0;
pTmpData = pImageData;
for(row = 0; row < nMid; row++, pTmpData += nw)
{
memcpy(pRowData, pTmpData, nw);
memcpy(pTmpData, pImageData + (nh - 1 - row) * nw, nw);
memcpy(pImageData + (nh - 1 - row) * nw, pRowData, nw);
}
free(pRowData);

return 1;
}

return 0;
}