lmh188
/
code_app
mirror of http://192.168.10.5:8099/sane/code_app.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
code_app/modules/base/HGImage.cpp

3293 lines
80 KiB
C++
Raw Blame History

#include "HGImage.h"
#include "HGInc.h"
#if defined(HG_CMP_MSC)
#include <combaseapi.h>
#include <atlstr.h>
#include <gdiplus.h>
#endif
struct HGImageImpl
{
HGImageImpl()
{
#if defined(HG_CMP_MSC)
m_hBmp = NULL;
#endif
m_data = NULL;
m_size = 0;
m_alloc = HGFALSE;
m_width = 0;
m_height = 0;
m_type = 0;
m_widthStep = 0;
m_origin = 0;
m_left = 0;
m_top = 0;
m_right = 0;
m_bottom = 0;
m_xDpi = 0;
m_yDpi = 0;
}
~HGImageImpl()
{
if (m_alloc)
{
free(m_data);
m_data = NULL;
}
#if defined(HG_CMP_MSC)
if (NULL != m_hBmp)
{
DeleteObject(m_hBmp);
m_hBmp = NULL;
}
#endif
}
#if defined(HG_CMP_MSC)
HBITMAP m_hBmp;
#endif
HGByte* m_data;
HGUSize m_size;
HGBool m_alloc;
HGUInt m_width;
HGUInt m_height;
HGUInt m_type;
HGUInt m_widthStep;
HGUInt m_origin;
HGUInt m_left;
HGUInt m_top;
HGUInt m_right;
HGUInt m_bottom;
HGUInt m_xDpi;
HGUInt m_yDpi;
};
#if defined(HG_CMP_MSC)
static HBITMAP CreateHBITMAP(HGUInt width, HGUInt height, HGUInt type, HGUInt origin,
HGUInt xDpi, HGUInt yDpi, HGByte** data)
{
BYTE bmi[sizeof(BITMAPINFOHEADER) + 256 * sizeof(RGBQUAD)] = { 0 };
BITMAPINFOHEADER* pbmihdr = (BITMAPINFOHEADER*)bmi;
pbmihdr->biSize = sizeof(BITMAPINFOHEADER);
pbmihdr->biWidth = (LONG)width;
pbmihdr->biHeight = (HGBASE_IMGORIGIN_BOTTOM == origin) ? (LONG)height : -(LONG)height;
pbmihdr->biPlanes = 1;
pbmihdr->biCompression = BI_RGB;
pbmihdr->biXPelsPerMeter = (LONG)(xDpi * 39.37);
pbmihdr->biYPelsPerMeter = (LONG)(yDpi * 39.37);
if (HGBASE_IMGTYPE_BGR == type)
{
pbmihdr->biBitCount = 24;
}
else if (HGBASE_IMGTYPE_BGRA == type)
{
pbmihdr->biBitCount = 32;
}
else if (HGBASE_IMGTYPE_GRAY == type)
{
pbmihdr->biBitCount = 8;
RGBQUAD* clr = (RGBQUAD*)(pbmihdr + 1);
for (int i = 0; i < 256; ++i)
{
clr[i].rgbRed = i;
clr[i].rgbGreen = i;
clr[i].rgbBlue = i;
}
}
else if (HGBASE_IMGTYPE_BINARY == type)
{
pbmihdr->biBitCount = 1;
RGBQUAD* clr = (RGBQUAD*)(pbmihdr + 1);
for (int i = 0; i < 2; ++i)
{
clr[i].rgbRed = i * 255;
clr[i].rgbGreen = i * 255;
clr[i].rgbBlue = i * 255;
}
}
else
{
return NULL;
}
void* pBits = NULL;
HBITMAP hBmp = CreateDIBSection(NULL, (BITMAPINFO*)bmi, DIB_RGB_COLORS, &pBits, NULL, 0);
if (NULL == hBmp)
{
return NULL;
}
*data = (HGByte*)pBits;
return hBmp;
}
#endif
HGResult HGAPI HGBase_CreateImage(HGUInt width, HGUInt height, HGUInt type, HGUInt origin, HGImage* image)
{
if (NULL == image)
{
return HGBASE_ERR_INVALIDARG;
}
if (0 == width || 0 == height || origin < HGBASE_IMGORIGIN_TOP || origin > HGBASE_IMGORIGIN_BOTTOM)
{
return HGBASE_ERR_INVALIDARG;
}
HGUInt bpp = 0;
if (HGBASE_IMGTYPE_BINARY == type)
bpp = 1;
else if (HGBASE_IMGTYPE_GRAY == type)
bpp = 8;
else if (HGBASE_IMGTYPE_BGR == type || HGBASE_IMGTYPE_RGB == type)
bpp = 24;
else if (HGBASE_IMGTYPE_BGRA == type || HGBASE_IMGTYPE_RGBA == type)
bpp = 32;
if (0 == bpp)
{
return HGBASE_ERR_INVALIDARG;
}
// 每行4字节对齐
HGUInt widthStep = ((width * bpp + 31) & ~31) >> 3;
HGUSize size = (HGUSize)widthStep * (HGUSize)height;
HGByte* data = NULL;
HGBool alloc = HGFALSE;
#if defined(HG_CMP_MSC)
HBITMAP hBmp = NULL;
if (HGBASE_IMGTYPE_RGB == type || HGBASE_IMGTYPE_RGBA == type)
{
data = (HGByte*)malloc(size);
if (NULL == data)
return HGBASE_ERR_OUTOFMEMORY;
else
alloc = HGTRUE;
}
else
{
hBmp = CreateHBITMAP(width, height, type, origin, 0, 0, &data);
if (NULL == hBmp)
return HGBASE_ERR_OUTOFMEMORY;
else
assert(NULL != data);
}
#else
data = (HGByte*)malloc(size);
if (NULL == data)
return HGBASE_ERR_OUTOFMEMORY;
else
alloc = HGTRUE;
#endif
HGImageImpl* imageImpl = new HGImageImpl;
#if defined(HG_CMP_MSC)
imageImpl->m_hBmp = hBmp;
#endif
imageImpl->m_data = data;
imageImpl->m_size = size;
imageImpl->m_alloc = alloc;
imageImpl->m_width = width;
imageImpl->m_height = height;
imageImpl->m_type = type;
imageImpl->m_widthStep = widthStep;
imageImpl->m_origin = origin;
imageImpl->m_left = 0;
imageImpl->m_top = 0;
imageImpl->m_right = imageImpl->m_width;
imageImpl->m_bottom = imageImpl->m_height;
imageImpl->m_xDpi = 0;
imageImpl->m_yDpi = 0;
*image = (HGImage)imageImpl;
return HGBASE_ERR_OK;
}
HGResult HGAPI HGBase_CreateImageWithData(HGByte* data, const HGImageInfo* info, HGImage* image)
{
if (NULL == data || NULL == info || NULL == image)
{
return HGBASE_ERR_INVALIDARG;
}
if (0 == info->width || 0 == info->height || info->origin < HGBASE_IMGORIGIN_TOP
|| info->origin > HGBASE_IMGORIGIN_BOTTOM)
{
return HGBASE_ERR_INVALIDARG;
}
HGUInt bpp = 0;
if (HGBASE_IMGTYPE_BINARY == info->type)
bpp = 1;
else if (HGBASE_IMGTYPE_GRAY == info->type)
bpp = 8;
else if (HGBASE_IMGTYPE_BGR == info->type || HGBASE_IMGTYPE_RGB == info->type)
bpp = 24;
else if (HGBASE_IMGTYPE_BGRA == info->type || HGBASE_IMGTYPE_RGBA == info->type)
bpp = 32;
if (0 == bpp)
{
return HGBASE_ERR_INVALIDARG;
}
// info->widthStep必须合法
HGUInt lineSize = ((info->width * bpp + 7) & ~7) >> 3;
if (info->widthStep < lineSize)
{
return HGBASE_ERR_INVALIDARG;
}
HGImageImpl* imageImpl = new HGImageImpl;
#if defined(HG_CMP_MSC)
imageImpl->m_hBmp = NULL;
#endif
imageImpl->m_data = data;
imageImpl->m_size = (HGUSize)info->widthStep * (HGUSize)info->height;
imageImpl->m_alloc = HGFALSE;
imageImpl->m_width = info->width;
imageImpl->m_height = info->height;
imageImpl->m_type = info->type;
imageImpl->m_widthStep = info->widthStep;
imageImpl->m_origin = info->origin;
imageImpl->m_left = 0;
imageImpl->m_top = 0;
imageImpl->m_right = imageImpl->m_width;
imageImpl->m_bottom = imageImpl->m_height;
imageImpl->m_xDpi = 0;
imageImpl->m_yDpi = 0;
*image = (HGImage)imageImpl;
return HGBASE_ERR_OK;
}
HGResult HGAPI HGBase_CreateImageFromData(HGByte* data, const HGImageInfo* info, const HGImageRoi* roi,
HGUInt type, HGUInt origin, HGImage* image)
{
HGImage srcImage = NULL;
HGResult ret = HGBase_CreateImageWithData(data, info, &srcImage);
if (HGBASE_ERR_OK != ret)
return ret;
if (NULL != roi)
{
ret = HGBase_SetImageROI(srcImage, roi);
if (HGBASE_ERR_OK != ret)
{
HGBase_DestroyImage(srcImage);
return ret;
}
}
ret = HGBase_CloneImage(srcImage, type, origin, image);
HGBase_DestroyImage(srcImage);
return ret;
}
#if defined(HG_CMP_MSC)
static HGUInt GetType(HBITMAP hBmp)
{
assert(NULL != hBmp);
HGUInt type = HGBASE_IMGTYPE_BGR;
DIBSECTION dib;
int ret = GetObject(hBmp, sizeof(DIBSECTION), &dib);
assert(sizeof(DIBSECTION) == ret);
RGBQUAD colorTable[256];
HDC hMem = CreateCompatibleDC(NULL);
HBITMAP hOldBmp = (HBITMAP)SelectObject(hMem, hBmp);
UINT colorCount = GetDIBColorTable(hMem, 0, 256, colorTable);
SelectObject(hMem, hOldBmp);
DeleteDC(hMem);
if (1 == dib.dsBmih.biBitCount || 4 == dib.dsBmih.biBitCount
|| 8 == dib.dsBmih.biBitCount)
{
assert(colorCount > 0);
BOOL bGray = TRUE;
BOOL bBinary = TRUE;
for (UINT i = 0; i < colorCount; ++i)
{
BYTE red = colorTable[i].rgbRed;
BYTE green = colorTable[i].rgbGreen;
BYTE blue = colorTable[i].rgbBlue;
if (red != green || red != blue || green != blue)
{
bGray = FALSE;
bBinary = FALSE;
break;
}
if (red != 0 && red != 255)
{
bBinary = FALSE;
}
}
if (bBinary)
type = HGBASE_IMGTYPE_BINARY;
else if (bGray)
type = HGBASE_IMGTYPE_GRAY;
}
else if (32 == dib.dsBmih.biBitCount)
{
type = HGBASE_IMGTYPE_BGRA;
}
return type;
}
HGResult HGAPI HGBase_CreateImageFromHBITMAP(HBITMAP hBmp, const HGImageRoi* roi,
HGUInt type, HGUInt origin, HGImage* image)
{
if (NULL == hBmp || NULL == image)
{
return HGBASE_ERR_INVALIDARG;
}
DIBSECTION dib;
if (sizeof(DIBSECTION) != GetObject(hBmp, sizeof(DIBSECTION), &dib))
{
return HGBASE_ERR_INVALIDDATA;
}
HGImageRoi roi2 = { 0, 0, (HGUInt)dib.dsBm.bmWidth, (HGUInt)dib.dsBm.bmHeight };
if (NULL != roi)
{
if (roi->left >= roi->right || roi->top >= roi->bottom
|| roi->right > (HGUInt)dib.dsBm.bmWidth || roi->bottom > (HGUInt)dib.dsBm.bmHeight)
{
return HGBASE_ERR_INVALIDARG;
}
memcpy(&roi2, roi, sizeof(HGImageRoi));
}
if (0 == type)
{
type = GetType(hBmp);
}
HGResult ret = HGBase_CreateImage(roi2.right - roi2.left, roi2.bottom - roi2.top, type, origin, image);
if (HGBASE_ERR_OK != ret)
{
return ret;
}
HBITMAP hBmp2 = NULL;
HGBase_GetHBITMAPOfImage(*image, &hBmp2);
if (NULL != hBmp2)
{
HDC hMem = CreateCompatibleDC(NULL);
HBITMAP hOldBmp = (HBITMAP)SelectObject(hMem, hBmp);
HDC hMem2 = CreateCompatibleDC(hMem);
HBITMAP hOldBmp2 = (HBITMAP)SelectObject(hMem2, hBmp2);
BitBlt(hMem2, 0, 0, roi2.right - roi2.left, roi2.bottom - roi2.top, hMem, roi2.left, roi2.top, SRCCOPY);
SelectObject(hMem2, hOldBmp2);
DeleteDC(hMem2);
SelectObject(hMem, hOldBmp);
DeleteDC(hMem);
ret = HGBASE_ERR_OK;
}
else
{
HGUInt type2 = type;
if (HGBASE_IMGTYPE_RGB == type)
type2 = HGBASE_IMGTYPE_BGR;
else if (HGBASE_IMGTYPE_RGBA == type)
type2 = HGBASE_IMGTYPE_BGRA;
HGImage image2 = NULL;
ret = HGBase_CreateImageFromHBITMAP(hBmp, roi, type2, origin, &image2);
if (HGBASE_ERR_OK == ret)
{
ret = HGBase_CopyImage(image2, *image);
HGBase_DestroyImage(image2);
}
if (HGBASE_ERR_OK != ret)
HGBase_DestroyImage(*image);
}
if (HGBASE_ERR_OK == ret)
{
HGUInt xDpi = (HGUInt)(dib.dsBmih.biXPelsPerMeter / 39.37);
HGUInt yDpi = (HGUInt)(dib.dsBmih.biYPelsPerMeter / 39.37);
HGBase_SetImageDpi(*image, xDpi, yDpi);
}
return ret;
}
static HGUInt GetType(Gdiplus::Image* pImage)
{
assert(NULL != pImage);
HGUInt type = HGBASE_IMGTYPE_BGR;
Gdiplus::PixelFormat pixFmt = pImage->GetPixelFormat();
if (PixelFormat16bppGrayScale == pixFmt)
{
type = HGBASE_IMGTYPE_GRAY;
}
else if (Gdiplus::IsIndexedPixelFormat(pixFmt))
{
UINT nPaletteSize = pImage->GetPaletteSize();
Gdiplus::ColorPalette* pPalette = (Gdiplus::ColorPalette*)malloc(nPaletteSize);
if (NULL != pPalette)
{
pImage->GetPalette(pPalette, nPaletteSize);
BOOL bGray = TRUE;
BOOL bBinary = TRUE;
for (UINT i = 0; i < pPalette->Count; ++i)
{
Gdiplus::ARGB color = pPalette->Entries[i];
BYTE red = (BYTE)((color >> RED_SHIFT) & 0xFF);
BYTE green = (BYTE)((color >> GREEN_SHIFT) & 0xFF);
BYTE blue = (BYTE)((color >> BLUE_SHIFT) & 0xFF);
if (red != green || red != blue || green != blue)
{
bGray = FALSE;
bBinary = FALSE;
break;
}
if (red != 0 && red != 255)
{
bBinary = FALSE;
}
}
if (bBinary)
type = HGBASE_IMGTYPE_BINARY;
else if (bGray)
type = HGBASE_IMGTYPE_GRAY;
free(pPalette);
}
}
else if (Gdiplus::IsAlphaPixelFormat(pixFmt))
{
type = HGBASE_IMGTYPE_BGRA;
}
return type;
}
static HGResult LoadGdiImage(Gdiplus::Image* pImage, const HGImageRoi* roi, HGUInt type, HGUInt origin, HGImage* image)
{
assert(NULL != pImage && NULL != image);
HGImageRoi roi2 = { 0, 0, pImage->GetWidth(), pImage->GetHeight() };
if (NULL != roi)
{
if (roi->left >= roi->right || roi->top >= roi->bottom
|| roi->right > pImage->GetWidth() || roi->bottom > pImage->GetHeight())
{
return HGBASE_ERR_INVALIDARG;
}
memcpy(&roi2, roi, sizeof(HGImageRoi));
}
if (0 == type)
{
type = GetType(pImage);
}
if (0 == origin)
{
origin = HGBASE_IMGORIGIN_TOP;
}
HGResult ret = HGBase_CreateImage(roi2.right - roi2.left, roi2.bottom - roi2.top, type, origin, image);
if (HGBASE_ERR_OK != ret)
{
return ret;
}
HBITMAP hBmp = NULL;
HGBase_GetHBITMAPOfImage(*image, &hBmp);
if (NULL != hBmp)
{
HDC hMem = CreateCompatibleDC(NULL);
HBITMAP hOldBmp = (HBITMAP)SelectObject(hMem, hBmp);
Gdiplus::Graphics graphics(hMem);
graphics.DrawImage(pImage, (INT)roi2.left, (INT)roi2.top,
(INT)(roi2.right - roi2.left), (INT)(roi2.bottom - roi2.top));
SelectObject(hMem, hOldBmp);
DeleteDC(hMem);
ret = HGBASE_ERR_OK;
}
else
{
HGUInt type2 = type;
if (HGBASE_IMGTYPE_RGB == type)
type2 = HGBASE_IMGTYPE_BGR;
else if (HGBASE_IMGTYPE_RGBA == type)
type2 = HGBASE_IMGTYPE_BGRA;
HGImage image2 = NULL;
ret = LoadGdiImage(pImage, roi, type2, origin, &image2);
if (HGBASE_ERR_OK == ret)
{
ret = HGBase_CopyImage(image2, *image);
HGBase_DestroyImage(image2);
}
if (HGBASE_ERR_OK != ret)
HGBase_DestroyImage(*image);
}
if (HGBASE_ERR_OK == ret)
{
HGUInt xDpi = (HGUInt)((double)pImage->GetHorizontalResolution() + 0.5);
HGUInt yDpi = (HGUInt)((double)pImage->GetVerticalResolution() + 0.5);
HGBase_SetImageDpi(*image, xDpi, yDpi);
}
return ret;
}
HGResult HGAPI HGBase_CreateDIBFile(HGLOBAL hMem, const HGChar *fileName)
{
if (NULL == hMem || NULL == fileName)
{
return HGBASE_ERR_INVALIDARG;
}
HGResult ret = HGBASE_ERR_FAIL;
ULONG size = (ULONG)GlobalSize(hMem);
void* pMem = GlobalLock(hMem);
if (NULL != pMem)
{
FILE *file = fopen(fileName, "wb");
if (NULL != file)
{
BITMAPINFOHEADER* infoHeader = (BITMAPINFOHEADER*)pMem;
DWORD bfOffBits = sizeof(BITMAPFILEHEADER) + sizeof(BITMAPINFOHEADER);
if (infoHeader->biBitCount <= 8)
bfOffBits += ((HGUInt)(1 << infoHeader->biBitCount) * sizeof(RGBQUAD));
BITMAPFILEHEADER fileHeader = { 0 };
fileHeader.bfType = 0x4D42;
fileHeader.bfSize = sizeof(BITMAPFILEHEADER) + size;
fileHeader.bfOffBits = bfOffBits;
fwrite(&fileHeader, 1, sizeof(BITMAPFILEHEADER), file);
fwrite(pMem, 1, size, file);
fclose(file);
ret = HGBASE_ERR_OK;
}
GlobalUnlock(hMem);
}
return ret;
}
HGResult HGAPI HGBase_CreateImageFromFile(const HGChar *fileName, const HGImageRoi* roi,
HGUInt type, HGUInt origin, HGImage* image)
{
if (NULL == fileName || NULL == image)
{
return HGBASE_ERR_INVALIDARG;
}
HGResult ret = HGBASE_ERR_FAIL;
ULONG_PTR nToken = 0;
Gdiplus::GdiplusStartupInput input;
Gdiplus::GdiplusStartupOutput output;
Gdiplus::GdiplusStartup(&nToken, &input, &output);
assert(0 != nToken);
CStringW fileName2(fileName);
Gdiplus::Image *img = new Gdiplus::Image(fileName2);
Gdiplus::Status status = img->GetLastStatus();
if (Gdiplus::Ok == status)
{
ret = LoadGdiImage(img, roi, type, origin, image);
}
delete img;
Gdiplus::GdiplusShutdown(nToken);
nToken = 0;
return ret;
}
HGResult HGAPI HGBase_CreateDIBStream(HGLOBAL hMem, HGStream *stream)
{
if (NULL == hMem || NULL == stream)
{
return HGBASE_ERR_INVALIDARG;
}
HGResult ret = HGBASE_ERR_FAIL;
ULONG size = (ULONG)GlobalSize(hMem);
void* pMem = GlobalLock(hMem);
if (NULL != pMem)
{
IStream* pStream = NULL;
HRESULT hr = CreateStreamOnHGlobal(NULL, TRUE, &pStream);
if (SUCCEEDED(hr))
{
ULONG writeSize = 0;
BITMAPINFOHEADER* infoHeader = (BITMAPINFOHEADER*)pMem;
DWORD bfOffBits = sizeof(BITMAPFILEHEADER) + sizeof(BITMAPINFOHEADER);
if (infoHeader->biBitCount <= 8)
bfOffBits += ((HGUInt)(1 << infoHeader->biBitCount) * sizeof(RGBQUAD));
BITMAPFILEHEADER fileHeader = { 0 };
fileHeader.bfType = 0x4D42;
fileHeader.bfSize = sizeof(BITMAPFILEHEADER) + size;
fileHeader.bfOffBits = bfOffBits;
pStream->Write(&fileHeader, sizeof(BITMAPFILEHEADER), &writeSize);
pStream->Write(pMem, size, &writeSize);
*stream = (HGStream)pStream;
ret = HGBASE_ERR_OK;
}
GlobalUnlock(hMem);
}
return ret;
}
HGResult HGAPI HGBase_DestroyStream(HGStream stream)
{
if (NULL == stream)
{
return HGBASE_ERR_INVALIDARG;
}
IStream* pStream = (IStream*)stream;
pStream->Release();
return HGBASE_ERR_OK;
}
HGResult HGAPI HGBase_CreateImageFromStream(HGStream stream, const HGImageRoi* roi,
HGUInt type, HGUInt origin, HGImage* image)
{
if (NULL == stream || NULL == image)
{
return HGBASE_ERR_INVALIDARG;
}
HGResult ret = HGBASE_ERR_FAIL;
ULONG_PTR nToken = 0;
Gdiplus::GdiplusStartupInput input;
Gdiplus::GdiplusStartupOutput output;
Gdiplus::GdiplusStartup(&nToken, &input, &output);
assert(0 != nToken);
IStream* pStream = (IStream*)stream;
Gdiplus::Image *img = new Gdiplus::Image(pStream);
Gdiplus::Status status = img->GetLastStatus();
if (Gdiplus::Ok == status)
{
ret = LoadGdiImage(img, roi, type, origin, image);
}
delete img;
Gdiplus::GdiplusShutdown(nToken);
nToken = 0;
return ret;
}
#endif /* HG_CMP_MSC */
HGResult HGAPI HGBase_CloneImage(HGImage srcImage, HGUInt type, HGUInt origin, HGImage* image)
{
if (NULL == srcImage || NULL == image)
{
return HGBASE_ERR_INVALIDARG;
}
HGImageImpl* srcImageImpl = (HGImageImpl*)srcImage;
if (0 == type)
{
type = srcImageImpl->m_type;
}
if (0 == origin)
{
origin = srcImageImpl->m_origin;
}
HGResult ret = HGBase_CreateImage(srcImageImpl->m_right - srcImageImpl->m_left,
srcImageImpl->m_bottom - srcImageImpl->m_top, type, origin, image);
if (HGBASE_ERR_OK != ret)
{
return ret;
}
ret = HGBase_CopyImage(srcImage, *image);
if (HGBASE_ERR_OK != ret)
{
HGBase_DestroyImage(*image);
return ret;
}
HGBase_SetImageDpi(*image, srcImageImpl->m_xDpi, srcImageImpl->m_yDpi);
return HGBASE_ERR_OK;
}
HGResult HGAPI HGBase_DestroyImage(HGImage image)
{
if (NULL == image)
{
return HGBASE_ERR_INVALIDARG;
}
HGImageImpl* imageImpl = (HGImageImpl*)image;
delete imageImpl;
return HGBASE_ERR_OK;
}
HGResult HGAPI HGBase_GetImageData(HGImage image, HGByte** data)
{
if (NULL == image || NULL == data)
{
return HGBASE_ERR_INVALIDARG;
}
HGImageImpl* imageImpl = (HGImageImpl*)image;
*data = imageImpl->m_data;
return HGBASE_ERR_OK;
}
HGResult HGAPI HGBase_GetImageInfo(HGImage image, HGImageInfo* info)
{
if (NULL == image || NULL == info)
{
return HGBASE_ERR_INVALIDARG;
}
HGImageImpl* imageImpl = (HGImageImpl*)image;
info->width = imageImpl->m_width;
info->height = imageImpl->m_height;
info->type = imageImpl->m_type;
info->widthStep = imageImpl->m_widthStep;
info->origin = imageImpl->m_origin;
return HGBASE_ERR_OK;
}
HGResult HGAPI HGBase_GetImageROI(HGImage image, HGImageRoi* roi)
{
if (NULL == image || NULL == roi)
{
return HGBASE_ERR_INVALIDARG;
}
HGImageImpl* imageImpl = (HGImageImpl*)image;
roi->left = imageImpl->m_left;
roi->top = imageImpl->m_top;
roi->right = imageImpl->m_right;
roi->bottom = imageImpl->m_bottom;
return HGBASE_ERR_OK;
}
HGResult HGAPI HGBase_SetImageROI(HGImage image, const HGImageRoi* roi)
{
if (NULL == image || NULL == roi)
{
return HGBASE_ERR_INVALIDARG;
}
HGImageImpl* imageImpl = (HGImageImpl*)image;
if (roi->right <= roi->left || roi->bottom <= roi->top
|| roi->right > imageImpl->m_width || roi->bottom > imageImpl->m_height)
{
return HGBASE_ERR_INVALIDARG;
}
imageImpl->m_left = roi->left;
imageImpl->m_top = roi->top;
imageImpl->m_right = roi->right;
imageImpl->m_bottom = roi->bottom;
return HGBASE_ERR_OK;
}
HGResult HGAPI HGBase_ResetImageROI(HGImage image)
{
if (NULL == image)
{
return HGBASE_ERR_INVALIDARG;
}
HGImageImpl* imageImpl = (HGImageImpl*)image;
imageImpl->m_left = 0;
imageImpl->m_top = 0;
imageImpl->m_right = imageImpl->m_width;
imageImpl->m_bottom = imageImpl->m_height;
return HGBASE_ERR_OK;
}
HGResult HGAPI HGBase_GetImageDpi(HGImage image, HGUInt* xDpi, HGUInt* yDpi)
{
if (NULL == image || NULL == xDpi || NULL == yDpi)
{
return HGBASE_ERR_INVALIDARG;
}
HGImageImpl* imageImpl = (HGImageImpl*)image;
*xDpi = imageImpl->m_xDpi;
*yDpi = imageImpl->m_yDpi;
return HGBASE_ERR_OK;
}
HGResult HGAPI HGBase_SetImageDpi(HGImage image, HGUInt xDpi, HGUInt yDpi)
{
if (NULL == image)
{
return HGBASE_ERR_INVALIDARG;
}
HGImageImpl* imageImpl = (HGImageImpl*)image;
imageImpl->m_xDpi = xDpi;
imageImpl->m_yDpi = yDpi;
return HGBASE_ERR_OK;
}
#if defined(HG_CMP_MSC)
HGResult HGAPI HGBase_GetHBITMAPOfImage(HGImage image, HBITMAP* hBmp)
{
if (NULL == image || NULL == hBmp)
{
return HGBASE_ERR_INVALIDARG;
}
HGImageImpl* imageImpl = (HGImageImpl*)image;
*hBmp = imageImpl->m_hBmp;
return HGBASE_ERR_OK;
}
HGResult HGAPI HGBase_CreateHBITMAPFromImage(HGImage image, HBITMAP* hBmp)
{
return HGBASE_ERR_NOTIMPL;
}
HGResult HGAPI HGBase_CreateDIBFromImage(HGImage image, HGLOBAL* hMem)
{
return HGBASE_ERR_NOTIMPL;
}
#endif /* HG_CMP_MSC */
HGResult HGAPI HGBase_ImageMirror(HGImage image, HGImage destImage)
{
if (NULL == image)
{
return HGBASE_ERR_INVALIDARG;
}
HGImageImpl* imageImpl = (HGImageImpl*)image;
HGUInt width = imageImpl->m_width;
HGUInt height = imageImpl->m_height;
HGUInt type = imageImpl->m_type;
HGUInt widthStep = imageImpl->m_widthStep;
HGUInt origin = imageImpl->m_origin;
HGUInt left = imageImpl->m_left;
HGUInt top = imageImpl->m_top;
HGUInt right = imageImpl->m_right;
HGUInt bottom = imageImpl->m_bottom;
HGByte* data = imageImpl->m_data;
HGUInt roiWidth = right - left;
HGUInt roiHeight = bottom - top;
uint32_t channels = 1;
if (HGBASE_IMGTYPE_BGR == type || HGBASE_IMGTYPE_RGB == type)
channels = 3;
else if (HGBASE_IMGTYPE_BGRA == type || HGBASE_IMGTYPE_RGBA == type)
channels = 4;
uint32_t dataSize = roiWidth * channels;
if (NULL == destImage || image == destImage)
{
if (HGBASE_IMGTYPE_BINARY == type)
{
HGImage imageTmp = NULL;
HGResult ret = HGBase_CloneImage(image, HGBASE_IMGTYPE_GRAY, 0, &imageTmp);
if (HGBASE_ERR_OK == ret)
{
ret = HGBase_ImageMirror(imageTmp, imageTmp);
if (HGBASE_ERR_OK == ret)
{
ret = HGBase_CopyImage(imageTmp, image);
}
HGBase_DestroyImage(imageTmp);
}
return ret;
}
HGByte* p = data + (HGUSize)top * (HGUSize)widthStep + left * channels;
HGInt step = (HGInt)widthStep;
if (HGBASE_IMGORIGIN_BOTTOM == origin)
{
p = data + (HGUSize)(height - top - 1) * (HGUSize)widthStep + left * channels;
step = -(HGInt)widthStep;
}
if (3 == channels)
{
//#pragma omp parallel for
for (int32_t i = 0; i < (int32_t)roiHeight; ++i)
{
HGByte* pEx = p + (HGSize)i * (HGSize)step;
HGByte* pEx2 = pEx + dataSize - channels;
while (pEx < pEx2)
{
HGByte temp0 = pEx[0];
pEx[0] = pEx2[0];
pEx2[0] = temp0;
HGByte temp1 = pEx[1];
pEx[1] = pEx2[1];
pEx2[1] = temp1;
HGByte temp2 = pEx[2];
pEx[2] = pEx2[2];
pEx2[2] = temp2;
pEx += 3;
pEx2 -= 3;
}
}
}
else if (4 == channels)
{
//#pragma omp parallel for
for (int32_t i = 0; i < (int32_t)roiHeight; ++i)
{
HGByte* pEx = p + (HGSize)i * (HGSize)step;
HGByte* pEx2 = pEx + dataSize - channels;
while (pEx < pEx2)
{
HGUInt tmp = *(HGUInt*)pEx;
*(HGUInt*)pEx = *(HGUInt*)pEx2;
*(HGUInt*)pEx2 = tmp;
pEx += 4;
pEx2 -= 4;
}
}
}
else
{
assert(1 == channels);
//#pragma omp parallel for
for (int32_t i = 0; i < (int32_t)roiHeight; ++i)
{
HGByte* pEx = p + (HGSize)i * (HGSize)step;
HGByte* pEx2 = pEx + dataSize - channels;
while (pEx < pEx2)
{
HGByte tmp = *pEx;
*pEx = *pEx2;
*pEx2 = tmp;
++pEx;
--pEx2;
}
}
}
}
else
{
HGImageImpl* destImageImpl = (HGImageImpl*)destImage;
HGUInt destWidth = destImageImpl->m_width;
HGUInt destHeight = destImageImpl->m_height;
HGUInt destType = destImageImpl->m_type;
HGUInt destWidthStep = destImageImpl->m_widthStep;
HGUInt destOrigin = destImageImpl->m_origin;
HGUInt destLeft = destImageImpl->m_left;
HGUInt destTop = destImageImpl->m_top;
HGUInt destRight = destImageImpl->m_right;
HGUInt destBottom = destImageImpl->m_bottom;
uint8_t* destData = destImageImpl->m_data;
if (type != destType)
{
return HGBASE_ERR_INVALIDDATA;
}
if (roiWidth != (destRight - destLeft) || roiHeight != (destBottom - destTop))
{
return HGBASE_ERR_INVALIDDATA;
}
if (HGBASE_IMGTYPE_BINARY == type)
{
HGImage imageTmp = NULL;
HGResult ret = HGBase_CloneImage(image, HGBASE_IMGTYPE_GRAY, 0, &imageTmp);
if (HGBASE_ERR_OK == ret)
{
ret = HGBase_ImageMirror(imageTmp, imageTmp);
if (HGBASE_ERR_OK == ret)
{
ret = HGBase_CopyImage(imageTmp, destImage);
}
HGBase_DestroyImage(imageTmp);
}
return ret;
}
HGByte* src = data + (HGUSize)top * (HGUSize)widthStep + left * channels;
HGInt srcStep = (HGInt)widthStep;
if (HGBASE_IMGORIGIN_BOTTOM == origin)
{
src = data + (HGUSize)(height - top - 1) * (HGUSize)widthStep + left * channels;
srcStep = -(HGInt)widthStep;
}
HGByte* dest = destData + (HGUSize)destTop * (HGUSize)destWidthStep + destLeft * channels;
HGInt destStep = (HGInt)destWidthStep;
if (HGBASE_IMGORIGIN_BOTTOM == destOrigin)
{
dest = destData + (HGUSize)(destHeight - destTop - 1) * (HGUSize)destWidthStep + destLeft * channels;
destStep = -(HGInt)destWidthStep;
}
if (3 == channels)
{
//#pragma omp parallel for
for (int32_t i = 0; i < (int32_t)roiHeight; ++i)
{
HGByte* pEx = src + (HGSize)i * (HGSize)srcStep;
HGByte* pExEnd = pEx + dataSize;
HGByte* pDestEx = dest + (HGSize)i * (HGSize)destStep + dataSize - channels;
while (pEx < pExEnd)
{
pDestEx[0] = pEx[0];
pDestEx[1] = pEx[1];
pDestEx[2] = pEx[2];
pEx += 3;
pDestEx -= 3;
}
}
}
else if (4 == channels)
{
//#pragma omp parallel for
for (int32_t i = 0; i < (int32_t)roiHeight; ++i)
{
HGByte* pEx = src + (HGSize)i * (HGSize)srcStep;
HGByte* pExEnd = pEx + dataSize;
HGByte* pDestEx = dest + (HGSize)i * (HGSize)destStep + dataSize - channels;
while (pEx < pExEnd)
{
*(HGUInt*)pDestEx = *(HGUInt*)pEx;
pEx += 4;
pDestEx -= 4;
}
}
}
else
{
assert(1 == channels);
//#pragma omp parallel for
for (int32_t i = 0; i < (int32_t)roiHeight; ++i)
{
HGByte* pEx = src + (HGSize)i * (HGSize)srcStep;
HGByte* pExEnd = pEx + dataSize;
HGByte* pDestEx = dest + (HGSize)i * (HGSize)destStep + dataSize - channels;
while (pEx < pExEnd)
{
*pDestEx = *pEx;
++pEx;
--pDestEx;
}
}
}
}
return HGBASE_ERR_OK;
}
HGResult HGAPI HGBase_ImageFlip(HGImage image, HGImage destImage)
{
if (NULL == image)
{
return HGBASE_ERR_INVALIDARG;
}
HGImageImpl* imageImpl = (HGImageImpl*)image;
HGUInt width = imageImpl->m_width;
HGUInt height = imageImpl->m_height;
HGUInt type = imageImpl->m_type;
HGUInt widthStep = imageImpl->m_widthStep;
HGUInt origin = imageImpl->m_origin;
HGUInt left = imageImpl->m_left;
HGUInt top = imageImpl->m_top;
HGUInt right = imageImpl->m_right;
HGUInt bottom = imageImpl->m_bottom;
HGByte* data = imageImpl->m_data;
HGUInt roiWidth = right - left;
HGUInt roiHeight = bottom - top;
uint32_t channels = 1;
if (HGBASE_IMGTYPE_BGR == type || HGBASE_IMGTYPE_RGB == type)
channels = 3;
else if (HGBASE_IMGTYPE_BGRA == type || HGBASE_IMGTYPE_RGBA == type)
channels = 4;
uint32_t dataSize = roiWidth * channels;
if (NULL == destImage || image == destImage)
{
if (HGBASE_IMGTYPE_BINARY == type)
{
HGImage imageTmp = NULL;
HGResult ret = HGBase_CloneImage(image, HGBASE_IMGTYPE_GRAY, 0, &imageTmp);
if (HGBASE_ERR_OK == ret)
{
ret = HGBase_ImageFlip(imageTmp, imageTmp);
if (HGBASE_ERR_OK == ret)
{
ret = HGBase_CopyImage(imageTmp, image);
}
HGBase_DestroyImage(imageTmp);
}
return ret;
}
HGByte* p1 = data + (HGUSize)top * (HGUSize)widthStep + left * channels;
HGInt step1 = (HGInt)widthStep;
HGByte* p2 = data + (HGUSize)(bottom - 1) * (HGUSize)widthStep + left * channels;
HGInt step2 = -(HGInt)widthStep;
if (HGBASE_IMGORIGIN_BOTTOM == origin)
{
p1 = data + (HGUSize)(height - top - 1) * (HGUSize)widthStep + left * channels;
step1 = -(HGInt)widthStep;
p2 = data + (HGUSize)(height - bottom) * (HGUSize)widthStep + left * channels;
step2 = (HGInt)widthStep;
}
uint32_t loop = roiHeight / 2;
if (4 == channels)
{
//#pragma omp parallel for
for (int32_t i = 0; i < (int32_t)loop; ++i)
{
uint8_t* p1Ex = p1 + (HGSize)i * (HGSize)step1;
uint8_t* p1ExEnd = p1Ex + dataSize;
uint8_t* p2Ex = p2 + (HGSize)i * (HGSize)step2;
while (p1Ex < p1ExEnd)
{
HGUInt tmp = *(HGUInt*)p1Ex;
*(HGUInt*)p1Ex = *(HGUInt*)p2Ex;
*(HGUInt*)p2Ex = tmp;
p1Ex += 4;
p2Ex += 4;
}
}
}
else
{
//#pragma omp parallel for
for (int32_t i = 0; i < (int32_t)loop; ++i)
{
uint8_t* p1Ex = p1 + (HGSize)i * (HGSize)step1;
uint8_t* p1ExEnd = p1Ex + dataSize;
uint8_t* p2Ex = p2 + (HGSize)i * (HGSize)step2;
while (p1Ex < p1ExEnd)
{
uint8_t temp = *p1Ex;
*p1Ex = *p2Ex;
*p2Ex = temp;
++p1Ex;
++p2Ex;
}
}
}
}
else
{
HGImageImpl* destImageImpl = (HGImageImpl*)destImage;
HGUInt destWidth = destImageImpl->m_width;
HGUInt destHeight = destImageImpl->m_height;
HGUInt destType = destImageImpl->m_type;
HGUInt destWidthStep = destImageImpl->m_widthStep;
HGUInt destOrigin = destImageImpl->m_origin;
HGUInt destLeft = destImageImpl->m_left;
HGUInt destTop = destImageImpl->m_top;
HGUInt destRight = destImageImpl->m_right;
HGUInt destBottom = destImageImpl->m_bottom;
uint8_t* destData = destImageImpl->m_data;
if (type != destType)
{
return HGBASE_ERR_INVALIDDATA;
}
if (roiWidth != (destRight - destLeft) || roiHeight != (destBottom - destTop))
{
return HGBASE_ERR_INVALIDDATA;
}
if (HGBASE_IMGTYPE_BINARY == type)
{
HGImage imageTmp = NULL;
HGResult ret = HGBase_CloneImage(image, HGBASE_IMGTYPE_GRAY, 0, &imageTmp);
if (HGBASE_ERR_OK == ret)
{
ret = HGBase_ImageFlip(imageTmp, imageTmp);
if (HGBASE_ERR_OK == ret)
{
ret = HGBase_CopyImage(imageTmp, destImage);
}
HGBase_DestroyImage(imageTmp);
}
return ret;
}
HGByte* src = data + (HGUSize)top * (HGUSize)widthStep + left * channels;
HGInt srcStep = (HGInt)widthStep;
if (HGBASE_IMGORIGIN_BOTTOM == origin)
{
src = data + (HGUSize)(height - top - 1) * (HGUSize)widthStep + left * channels;
srcStep = -(HGInt)widthStep;
}
HGByte* dest = destData + (HGUSize)(destBottom - 1) * (HGUSize)destWidthStep + destLeft * channels;
HGInt destStep = -(HGInt)destWidthStep;
if (HGBASE_IMGORIGIN_BOTTOM == destOrigin)
{
dest = destData + (HGUSize)(destHeight - destBottom) * (HGUSize)destWidthStep + destLeft * channels;
destStep = (HGInt)destWidthStep;
}
//#pragma omp parallel for
for (int32_t i = 0; i < (int32_t)roiHeight; ++i)
{
HGByte* pEx = src + (HGSize)i * (HGSize)srcStep;
HGByte* pDestEx = dest + (HGSize)i * (HGSize)destStep;
memcpy(pDestEx, pEx, dataSize);
}
}
return HGBASE_ERR_OK;
}
HGResult HGAPI HGBase_ImageRotateLeft(HGImage image, HGImage destImage)
{
if (NULL == image || NULL == destImage || image == destImage)
{
return HGBASE_ERR_INVALIDARG;
}
HGImageImpl* imageImpl = (HGImageImpl*)image;
HGUInt width = imageImpl->m_width;
HGUInt height = imageImpl->m_height;
HGUInt type = imageImpl->m_type;
HGUInt widthStep = imageImpl->m_widthStep;
HGUInt origin = imageImpl->m_origin;
HGUInt left = imageImpl->m_left;
HGUInt top = imageImpl->m_top;
HGUInt right = imageImpl->m_right;
HGUInt bottom = imageImpl->m_bottom;
HGByte* data = imageImpl->m_data;
HGUInt roiWidth = right - left;
HGUInt roiHeight = bottom - top;
HGImageImpl* destImageImpl = (HGImageImpl*)destImage;
HGUInt destWidth = destImageImpl->m_width;
HGUInt destHeight = destImageImpl->m_height;
HGUInt destType = destImageImpl->m_type;
HGUInt destWidthStep = destImageImpl->m_widthStep;
HGUInt destOrigin = destImageImpl->m_origin;
HGUInt destLeft = destImageImpl->m_left;
HGUInt destTop = destImageImpl->m_top;
HGUInt destRight = destImageImpl->m_right;
HGUInt destBottom = destImageImpl->m_bottom;
uint8_t* destData = destImageImpl->m_data;
if (type != destType)
{
return HGBASE_ERR_INVALIDDATA;
}
if (roiWidth != (destBottom - destTop) || roiHeight != (destRight - destLeft))
{
return HGBASE_ERR_INVALIDDATA;
}
if (HGBASE_IMGTYPE_BINARY == type)
{
HGImage imageTmp1 = NULL;
HGResult ret = HGBase_CloneImage(image, HGBASE_IMGTYPE_GRAY, 0, &imageTmp1);
if (HGBASE_ERR_OK == ret)
{
HGImageInfo imgInfo;
HGBase_GetImageInfo(imageTmp1, &imgInfo);
HGImage imageTmp2 = NULL;
ret = HGBase_CreateImage(imgInfo.height, imgInfo.width, imgInfo.type, imgInfo.origin, &imageTmp2);
if (HGBASE_ERR_OK == ret)
{
ret = HGBase_ImageRotateLeft(imageTmp1, imageTmp2);
if (HGBASE_ERR_OK == ret)
{
ret = HGBase_CopyImage(imageTmp2, destImage);
}
HGBase_DestroyImage(imageTmp2);
}
HGBase_DestroyImage(imageTmp1);
}
return ret;
}
uint32_t channels = 1;
if (HGBASE_IMGTYPE_BGR == type || HGBASE_IMGTYPE_RGB == type)
channels = 3;
else if (HGBASE_IMGTYPE_BGRA == type || HGBASE_IMGTYPE_RGBA == type)
channels = 4;
uint32_t dataSize = roiWidth * channels;
HGInt span = (HGInt)channels * 32;
HGInt destSpan = (HGInt)destWidthStep * 32;
uint8_t* p = data + (HGUSize)top * (HGUSize)widthStep + left * channels;
HGInt step = (HGInt)widthStep;
if (HGBASE_IMGORIGIN_BOTTOM == origin)
{
p = data + (HGUSize)(height - top - 1) * (HGUSize)widthStep + left * channels;
step = -(HGInt)widthStep;
}
uint8_t* pEnd = p + dataSize;
uint8_t* pDest = destData + (HGUSize)destTop * (HGUSize)destWidthStep + destLeft * channels;
HGInt destStep = (HGInt)destWidthStep;
if (HGBASE_IMGORIGIN_BOTTOM == destOrigin)
{
pDest = destData + (HGUSize)(destHeight - destTop - 1) * (HGUSize)destWidthStep + destLeft * channels;
destStep = -(HGInt)destWidthStep;
destSpan = -(HGInt)destWidthStep * 32;
}
pDest += (HGSize)(roiWidth - 1) * (HGSize)destStep;
if (3 == channels)
{
while (p + span <= pEnd)
{
//#pragma omp parallel for
for (int32_t i = 0; i < (int32_t)roiHeight; ++i)
{
uint8_t* pEx = p + (HGSize)i * (HGSize)step;
uint8_t* pExEnd = pEx + span;
uint8_t* pDestEx = pDest + i * 3;
while (pEx < pExEnd)
{
pDestEx[0] = pEx[0];
pDestEx[1] = pEx[1];
pDestEx[2] = pEx[2];
pEx += 3;
pDestEx -= destStep;
}
}
p += span;
pDest -= destSpan;
}
while (p < pEnd)
{
//#pragma omp parallel for
for (int32_t i = 0; i < (int32_t)roiHeight; ++i)
{
uint8_t* pEx = p + (HGSize)i * (HGSize)step;
uint8_t* pDestEx = pDest + i * 3;
pDestEx[0] = pEx[0];
pDestEx[1] = pEx[1];
pDestEx[2] = pEx[2];
}
p += 3;
pDest -= destStep;
}
}
else if (4 == channels)
{
while (p + span <= pEnd)
{
//#pragma omp parallel for
for (int32_t i = 0; i < (int32_t)roiHeight; ++i)
{
uint8_t* pEx = p + (HGSize)i * (HGSize)step;
uint8_t* pExEnd = pEx + span;
uint8_t* pDestEx = pDest + i * 4;
while (pEx < pExEnd)
{
*(HGUInt*)pDestEx = *(HGUInt*)pEx;
pEx += 4;
pDestEx -= destStep;
}
}
p += span;
pDest -= destSpan;
}
while (p < pEnd)
{
//#pragma omp parallel for
for (int32_t i = 0; i < (int32_t)roiHeight; ++i)
{
uint8_t* pEx = p + (HGSize)i * (HGSize)step;
uint8_t* pDestEx = pDest + i * 4;
*(HGUInt*)pDestEx = *(HGUInt*)pEx;
}
p += 4;
pDest -= destStep;
}
}
else
{
assert(1 == channels);
while (p + span <= pEnd)
{
//#pragma omp parallel for
for (int32_t i = 0; i < (int32_t)roiHeight; ++i)
{
uint8_t* pEx = p + (HGSize)i * (HGSize)step;
uint8_t* pExEnd = pEx + span;
uint8_t* pDestEx = pDest + i;
while (pEx < pExEnd)
{
*pDestEx = *pEx;
++pEx;
pDestEx -= destStep;
}
}
p += span;
pDest -= destSpan;
}
while (p < pEnd)
{
//#pragma omp parallel for
for (int32_t i = 0; i < (int32_t)roiHeight; ++i)
{
uint8_t* pEx = p + (HGSize)i * (HGSize)step;
uint8_t* pDestEx = pDest + i;
*pDestEx = *pEx;
}
++p;
pDest -= destStep;
}
}
return HGBASE_ERR_OK;
}
HGResult HGAPI HGBase_ImageRotateRight(HGImage image, HGImage destImage)
{
if (NULL == image || NULL == destImage || image == destImage)
{
return HGBASE_ERR_INVALIDARG;
}
HGImageImpl* imageImpl = (HGImageImpl*)image;
HGUInt width = imageImpl->m_width;
HGUInt height = imageImpl->m_height;
HGUInt type = imageImpl->m_type;
HGUInt widthStep = imageImpl->m_widthStep;
HGUInt origin = imageImpl->m_origin;
HGUInt left = imageImpl->m_left;
HGUInt top = imageImpl->m_top;
HGUInt right = imageImpl->m_right;
HGUInt bottom = imageImpl->m_bottom;
HGByte* data = imageImpl->m_data;
HGUInt roiWidth = right - left;
HGUInt roiHeight = bottom - top;
HGImageImpl* destImageImpl = (HGImageImpl*)destImage;
HGUInt destWidth = destImageImpl->m_width;
HGUInt destHeight = destImageImpl->m_height;
HGUInt destType = destImageImpl->m_type;
HGUInt destWidthStep = destImageImpl->m_widthStep;
HGUInt destOrigin = destImageImpl->m_origin;
HGUInt destLeft = destImageImpl->m_left;
HGUInt destTop = destImageImpl->m_top;
HGUInt destRight = destImageImpl->m_right;
HGUInt destBottom = destImageImpl->m_bottom;
uint8_t* destData = destImageImpl->m_data;
if (type != destType)
{
return HGBASE_ERR_INVALIDDATA;
}
if (roiWidth != (destBottom - destTop) || roiHeight != (destRight - destLeft))
{
return HGBASE_ERR_INVALIDDATA;
}
if (HGBASE_IMGTYPE_BINARY == type)
{
HGImage imageTmp1 = NULL;
HGResult ret = HGBase_CloneImage(image, HGBASE_IMGTYPE_GRAY, 0, &imageTmp1);
if (HGBASE_ERR_OK == ret)
{
HGImageInfo imgInfo;
HGBase_GetImageInfo(imageTmp1, &imgInfo);
HGImage imageTmp2 = NULL;
ret = HGBase_CreateImage(imgInfo.height, imgInfo.width, imgInfo.type, imgInfo.origin, &imageTmp2);
if (HGBASE_ERR_OK == ret)
{
ret = HGBase_ImageRotateRight(imageTmp1, imageTmp2);
if (HGBASE_ERR_OK == ret)
{
ret = HGBase_CopyImage(imageTmp2, destImage);
}
HGBase_DestroyImage(imageTmp2);
}
HGBase_DestroyImage(imageTmp1);
}
return ret;
}
uint32_t channels = 1;
if (HGBASE_IMGTYPE_BGR == type || HGBASE_IMGTYPE_RGB == type)
channels = 3;
else if (HGBASE_IMGTYPE_BGRA == type || HGBASE_IMGTYPE_RGBA == type)
channels = 4;
uint32_t dataSize = roiWidth * channels;
HGInt span = (HGInt)channels * 32;
HGInt destSpan = (HGInt)destWidthStep * 32;
uint8_t* p = data + (HGUSize)top * (HGUSize)widthStep + left * channels;
HGInt step = (HGInt)widthStep;
if (HGBASE_IMGORIGIN_BOTTOM == origin)
{
p = data + (HGUSize)(height - top - 1) * (HGUSize)widthStep + left * channels;
step = -(HGInt)widthStep;
}
uint8_t* pEnd = p + dataSize;
uint8_t* pDest = destData + (HGUSize)destTop * (HGUSize)destWidthStep + destLeft * channels;
HGInt destStep = (HGInt)destWidthStep;
if (HGBASE_IMGORIGIN_BOTTOM == destOrigin)
{
pDest = destData + (HGUSize)(destHeight - destTop - 1) * (HGUSize)destWidthStep + destLeft * channels;
destStep = -(HGInt)destWidthStep;
destSpan = -(HGInt)destWidthStep * 32;
}
pDest += (roiHeight - 1) * channels;
if (3 == channels)
{
while (p + span <= pEnd)
{
//#pragma omp parallel for
for (int32_t i = 0; i < (int32_t)roiHeight; ++i)
{
uint8_t* pEx = p + (HGSize)i * (HGSize)step;
uint8_t* pExEnd = pEx + span;
uint8_t* pDestEx = pDest - i * 3;
while (pEx < pExEnd)
{
pDestEx[0] = pEx[0];
pDestEx[1] = pEx[1];
pDestEx[2] = pEx[2];
pEx += 3;
pDestEx += destStep;
}
}
p += span;
pDest += destSpan;
}
while (p < pEnd)
{
//#pragma omp parallel for
for (int32_t i = 0; i < (int32_t)roiHeight; ++i)
{
uint8_t* pEx = p + (HGSize)i * (HGSize)step;
uint8_t* pDestEx = pDest - i * 3;
pDestEx[0] = pEx[0];
pDestEx[1] = pEx[1];
pDestEx[2] = pEx[2];
}
p += 3;
pDest += destStep;
}
}
else if (4 == channels)
{
while (p + span <= pEnd)
{
//#pragma omp parallel for
for (int32_t i = 0; i < (int32_t)roiHeight; ++i)
{
uint8_t* pEx = p + (HGSize)i * (HGSize)step;
uint8_t* pExEnd = pEx + span;
uint8_t* pDestEx = pDest - i * 4;
while (pEx < pExEnd)
{
*(HGUInt*)pDestEx = *(HGUInt*)pEx;
pEx += 4;
pDestEx += destStep;
}
}
p += span;
pDest += destSpan;
}
while (p < pEnd)
{
//#pragma omp parallel for
for (int32_t i = 0; i < (int32_t)roiHeight; ++i)
{
uint8_t* pEx = p + (HGSize)i * (HGSize)step;
uint8_t* pDestEx = pDest - i * 4;
*(HGUInt*)pDestEx = *(HGUInt*)pEx;
}
p += 4;
pDest += destStep;
}
}
else
{
assert(1 == channels);
while (p + span <= pEnd)
{
//#pragma omp parallel for
for (int32_t i = 0; i < (int32_t)roiHeight; ++i)
{
uint8_t* pEx = p + (HGSize)i * (HGSize)step;
uint8_t* pExEnd = pEx + span;
uint8_t* pDestEx = pDest - i;
while (pEx < pExEnd)
{
*pDestEx = *pEx;
++pEx;
pDestEx += destStep;
}
}
p += span;
pDest += destSpan;
}
while (p < pEnd)
{
//#pragma omp parallel for
for (int32_t i = 0; i < (int32_t)roiHeight; ++i)
{
uint8_t* pEx = p + (HGSize)i * (HGSize)step;
uint8_t* pDestEx = pDest - i;
*pDestEx = *pEx;
}
++p;
pDest += destStep;
}
}
return HGBASE_ERR_OK;
}
HGResult HGAPI HGBase_ImageRotateLeftMirror(HGImage image, HGImage destImage)
{
if (NULL == image || NULL == destImage || image == destImage)
{
return HGBASE_ERR_INVALIDARG;
}
HGImageImpl* imageImpl = (HGImageImpl*)image;
HGUInt width = imageImpl->m_width;
HGUInt height = imageImpl->m_height;
HGUInt type = imageImpl->m_type;
HGUInt widthStep = imageImpl->m_widthStep;
HGUInt origin = imageImpl->m_origin;
HGUInt left = imageImpl->m_left;
HGUInt top = imageImpl->m_top;
HGUInt right = imageImpl->m_right;
HGUInt bottom = imageImpl->m_bottom;
HGByte* data = imageImpl->m_data;
HGUInt roiWidth = right - left;
HGUInt roiHeight = bottom - top;
HGImageImpl* destImageImpl = (HGImageImpl*)destImage;
HGUInt destWidth = destImageImpl->m_width;
HGUInt destHeight = destImageImpl->m_height;
HGUInt destType = destImageImpl->m_type;
HGUInt destWidthStep = destImageImpl->m_widthStep;
HGUInt destOrigin = destImageImpl->m_origin;
HGUInt destLeft = destImageImpl->m_left;
HGUInt destTop = destImageImpl->m_top;
HGUInt destRight = destImageImpl->m_right;
HGUInt destBottom = destImageImpl->m_bottom;
uint8_t* destData = destImageImpl->m_data;
if (type != destType)
{
return HGBASE_ERR_INVALIDDATA;
}
if (roiWidth != (destBottom - destTop) || roiHeight != (destRight - destLeft))
{
return HGBASE_ERR_INVALIDDATA;
}
if (HGBASE_IMGTYPE_BINARY == type)
{
HGImage imageTmp1 = NULL;
HGResult ret = HGBase_CloneImage(image, HGBASE_IMGTYPE_GRAY, 0, &imageTmp1);
if (HGBASE_ERR_OK == ret)
{
HGImageInfo imgInfo;
HGBase_GetImageInfo(imageTmp1, &imgInfo);
HGImage imageTmp2 = NULL;
ret = HGBase_CreateImage(imgInfo.height, imgInfo.width, imgInfo.type, imgInfo.origin, &imageTmp2);
if (HGBASE_ERR_OK == ret)
{
ret = HGBase_ImageRotateLeftMirror(imageTmp1, imageTmp2);
if (HGBASE_ERR_OK == ret)
{
ret = HGBase_CopyImage(imageTmp2, destImage);
}
HGBase_DestroyImage(imageTmp2);
}
HGBase_DestroyImage(imageTmp1);
}
return ret;
}
uint32_t channels = 1;
if (HGBASE_IMGTYPE_BGR == type || HGBASE_IMGTYPE_RGB == type)
channels = 3;
else if (HGBASE_IMGTYPE_BGRA == type || HGBASE_IMGTYPE_RGBA == type)
channels = 4;
uint32_t dataSize = roiWidth * channels;
HGInt span = (HGInt)channels * 32;
HGInt destSpan = (HGInt)destWidthStep * 32;
uint8_t* p = data + (HGUSize)top * (HGUSize)widthStep + left * channels;
HGInt step = (HGInt)widthStep;
if (HGBASE_IMGORIGIN_BOTTOM == origin)
{
p = data + (HGUSize)(height - top - 1) * (HGUSize)widthStep + left * channels;
step = -(HGInt)widthStep;
}
uint8_t* pEnd = p + dataSize;
uint8_t* pDest = destData + (HGUSize)destTop * (HGUSize)destWidthStep + destLeft * channels;
HGInt destStep = (HGInt)destWidthStep;
if (HGBASE_IMGORIGIN_BOTTOM == destOrigin)
{
pDest = destData + (HGUSize)(destHeight - destTop - 1) * (HGUSize)destWidthStep + destLeft * channels;
destStep = -(HGInt)destWidthStep;
destSpan = -(HGInt)destWidthStep * 32;
}
pDest += (HGSize)(roiWidth - 1) * (HGSize)destStep;
pDest += (roiHeight - 1) * channels;
if (3 == channels)
{
while (p + span <= pEnd)
{
//#pragma omp parallel for
for (int32_t i = 0; i < (int32_t)roiHeight; ++i)
{
uint8_t* pEx = p + (HGSize)i * (HGSize)step;
uint8_t* pExEnd = pEx + span;
uint8_t* pDestEx = pDest - i * 3;
while (pEx < pExEnd)
{
pDestEx[0] = pEx[0];
pDestEx[1] = pEx[1];
pDestEx[2] = pEx[2];
pEx += 3;
pDestEx -= destStep;
}
}
p += span;
pDest -= destSpan;
}
while (p < pEnd)
{
//#pragma omp parallel for
for (int32_t i = 0; i < (int32_t)roiHeight; ++i)
{
uint8_t* pEx = p + (HGSize)i * (HGSize)step;
uint8_t* pDestEx = pDest - i * 3;
pDestEx[0] = pEx[0];
pDestEx[1] = pEx[1];
pDestEx[2] = pEx[2];
}
p += 3;
pDest -= destStep;
}
}
else if (4 == channels)
{
while (p + span <= pEnd)
{
//#pragma omp parallel for
for (int32_t i = 0; i < (int32_t)roiHeight; ++i)
{
uint8_t* pEx = p + (HGSize)i * (HGSize)step;
uint8_t* pExEnd = pEx + span;
uint8_t* pDestEx = pDest - i * 4;
while (pEx < pExEnd)
{
*(HGUInt*)pDestEx = *(HGUInt*)pEx;
pEx += 4;
pDestEx -= destStep;
}
}
p += span;
pDest -= destSpan;
}
while (p < pEnd)
{
//#pragma omp parallel for
for (int32_t i = 0; i < (int32_t)roiHeight; ++i)
{
uint8_t* pEx = p + (HGSize)i * (HGSize)step;
uint8_t* pDestEx = pDest - i * 4;
*(HGUInt*)pDestEx = *(HGUInt*)pEx;
}
p += 4;
pDest -= destStep;
}
}
else
{
assert(1 == channels);
while (p + span <= pEnd)
{
//#pragma omp parallel for
for (int32_t i = 0; i < (int32_t)roiHeight; ++i)
{
uint8_t* pEx = p + (HGSize)i * (HGSize)step;
uint8_t* pExEnd = pEx + span;
uint8_t* pDestEx = pDest - i;
while (pEx < pExEnd)
{
*pDestEx = *pEx;
++pEx;
pDestEx -= destStep;
}
}
p += span;
pDest -= destSpan;
}
while (p < pEnd)
{
//#pragma omp parallel for
for (int32_t i = 0; i < (int32_t)roiHeight; ++i)
{
uint8_t* pEx = p + (HGSize)i * (HGSize)step;
uint8_t* pDestEx = pDest - i;
*pDestEx = *pEx;
}
++p;
pDest -= destStep;
}
}
return HGBASE_ERR_OK;
}
HGResult HGAPI HGBase_ImageRotateRightMirror(HGImage image, HGImage destImage)
{
if (NULL == image || NULL == destImage || image == destImage)
{
return HGBASE_ERR_INVALIDARG;
}
HGImageImpl* imageImpl = (HGImageImpl*)image;
HGUInt width = imageImpl->m_width;
HGUInt height = imageImpl->m_height;
HGUInt type = imageImpl->m_type;
HGUInt widthStep = imageImpl->m_widthStep;
HGUInt origin = imageImpl->m_origin;
HGUInt left = imageImpl->m_left;
HGUInt top = imageImpl->m_top;
HGUInt right = imageImpl->m_right;
HGUInt bottom = imageImpl->m_bottom;
HGByte* data = imageImpl->m_data;
HGUInt roiWidth = right - left;
HGUInt roiHeight = bottom - top;
HGImageImpl* destImageImpl = (HGImageImpl*)destImage;
HGUInt destWidth = destImageImpl->m_width;
HGUInt destHeight = destImageImpl->m_height;
HGUInt destType = destImageImpl->m_type;
HGUInt destWidthStep = destImageImpl->m_widthStep;
HGUInt destOrigin = destImageImpl->m_origin;
HGUInt destLeft = destImageImpl->m_left;
HGUInt destTop = destImageImpl->m_top;
HGUInt destRight = destImageImpl->m_right;
HGUInt destBottom = destImageImpl->m_bottom;
uint8_t* destData = destImageImpl->m_data;
if (type != destType)
{
return HGBASE_ERR_INVALIDDATA;
}
if (roiWidth != (destBottom - destTop) || roiHeight != (destRight - destLeft))
{
return HGBASE_ERR_INVALIDDATA;
}
if (HGBASE_IMGTYPE_BINARY == type)
{
HGImage imageTmp1 = NULL;
HGResult ret = HGBase_CloneImage(image, HGBASE_IMGTYPE_GRAY, 0, &imageTmp1);
if (HGBASE_ERR_OK == ret)
{
HGImageInfo imgInfo;
HGBase_GetImageInfo(imageTmp1, &imgInfo);
HGImage imageTmp2 = NULL;
ret = HGBase_CreateImage(imgInfo.height, imgInfo.width, imgInfo.type, imgInfo.origin, &imageTmp2);
if (HGBASE_ERR_OK == ret)
{
ret = HGBase_ImageRotateRightMirror(imageTmp1, imageTmp2);
if (HGBASE_ERR_OK == ret)
{
ret = HGBase_CopyImage(imageTmp2, destImage);
}
HGBase_DestroyImage(imageTmp2);
}
HGBase_DestroyImage(imageTmp1);
}
return ret;
}
uint32_t channels = 1;
if (HGBASE_IMGTYPE_BGR == type || HGBASE_IMGTYPE_RGB == type)
channels = 3;
else if (HGBASE_IMGTYPE_BGRA == type || HGBASE_IMGTYPE_RGBA == type)
channels = 4;
uint32_t dataSize = roiWidth * channels;
HGInt span = (HGInt)channels * 32;
HGInt destSpan = (HGInt)destWidthStep * 32;
uint8_t* p = data + (HGUSize)top * (HGUSize)widthStep + left * channels;
HGInt step = (HGInt)widthStep;
if (HGBASE_IMGORIGIN_BOTTOM == origin)
{
p = data + (HGUSize)(height - top - 1) * (HGUSize)widthStep + left * channels;
step = -(HGInt)widthStep;
}
uint8_t* pEnd = p + dataSize;
uint8_t* pDest = destData + (HGUSize)destTop * (HGUSize)destWidthStep + destLeft * channels;
HGInt destStep = (HGInt)destWidthStep;
if (HGBASE_IMGORIGIN_BOTTOM == destOrigin)
{
pDest = destData + (HGUSize)(destHeight - destTop - 1) * (HGUSize)destWidthStep + destLeft * channels;
destStep = -(HGInt)destWidthStep;
destSpan = -(HGInt)destWidthStep * 32;
}
if (3 == channels)
{
while (p + span <= pEnd)
{
//#pragma omp parallel for
for (int32_t i = 0; i < (int32_t)roiHeight; ++i)
{
uint8_t* pEx = p + (HGSize)i * (HGSize)step;
uint8_t* pExEnd = pEx + span;
uint8_t* pDestEx = pDest + i * 3;
while (pEx < pExEnd)
{
pDestEx[0] = pEx[0];
pDestEx[1] = pEx[1];
pDestEx[2] = pEx[2];
pEx += 3;
pDestEx += destStep;
}
}
p += span;
pDest += destSpan;
}
while (p < pEnd)
{
//#pragma omp parallel for
for (int32_t i = 0; i < (int32_t)roiHeight; ++i)
{
uint8_t* pEx = p + (HGSize)i * (HGSize)step;
uint8_t* pDestEx = pDest + i * 3;
pDestEx[0] = pEx[0];
pDestEx[1] = pEx[1];
pDestEx[2] = pEx[2];
}
p += 3;
pDest += destStep;
}
}
else if (4 == channels)
{
while (p + span <= pEnd)
{
//#pragma omp parallel for
for (int32_t i = 0; i < (int32_t)roiHeight; ++i)
{
uint8_t* pEx = p + (HGSize)i * (HGSize)step;
uint8_t* pExEnd = pEx + span;
uint8_t* pDestEx = pDest + i * 4;
while (pEx < pExEnd)
{
*(HGUInt*)pDestEx = *(HGUInt*)pEx;
pEx += 4;
pDestEx += destStep;
}
}
p += span;
pDest += destSpan;
}
while (p < pEnd)
{
//#pragma omp parallel for
for (int32_t i = 0; i < (int32_t)roiHeight; ++i)
{
uint8_t* pEx = p + (HGSize)i * (HGSize)step;
uint8_t* pDestEx = pDest + i * 4;
*(HGUInt*)pDestEx = *(HGUInt*)pEx;
}
p += 4;
pDest += destStep;
}
}
else
{
assert(1 == channels);
while (p + span <= pEnd)
{
//#pragma omp parallel for
for (int32_t i = 0; i < (int32_t)roiHeight; ++i)
{
uint8_t* pEx = p + (HGSize)i * (HGSize)step;
uint8_t* pExEnd = pEx + span;
uint8_t* pDestEx = pDest + i;
while (pEx < pExEnd)
{
*pDestEx = *pEx;
++pEx;
pDestEx += destStep;
}
}
p += span;
pDest += destSpan;
}
while (p < pEnd)
{
//#pragma omp parallel for
for (int32_t i = 0; i < (int32_t)roiHeight; ++i)
{
uint8_t* pEx = p + (HGSize)i * (HGSize)step;
uint8_t* pDestEx = pDest + i;
*pDestEx = *pEx;
}
++p;
pDest += destStep;
}
}
return HGBASE_ERR_OK;
}
HGResult HGAPI HGBase_ImageRotate180(HGImage image, HGImage destImage)
{
if (NULL == image)
{
return HGBASE_ERR_INVALIDARG;
}
HGImageImpl* imageImpl = (HGImageImpl*)image;
HGUInt width = imageImpl->m_width;
HGUInt height = imageImpl->m_height;
HGUInt type = imageImpl->m_type;
HGUInt widthStep = imageImpl->m_widthStep;
HGUInt origin = imageImpl->m_origin;
HGUInt left = imageImpl->m_left;
HGUInt top = imageImpl->m_top;
HGUInt right = imageImpl->m_right;
HGUInt bottom = imageImpl->m_bottom;
HGByte* data = imageImpl->m_data;
HGUInt roiWidth = right - left;
HGUInt roiHeight = bottom - top;
uint32_t channels = 1;
if (HGBASE_IMGTYPE_BGR == type || HGBASE_IMGTYPE_RGB == type)
channels = 3;
else if (HGBASE_IMGTYPE_BGRA == type || HGBASE_IMGTYPE_RGBA == type)
channels = 4;
uint32_t dataSize = roiWidth * channels;
if (NULL == destImage || image == destImage)
{
if (HGBASE_IMGTYPE_BINARY == type)
{
HGImage imageTmp = NULL;
HGResult ret = HGBase_CloneImage(image, HGBASE_IMGTYPE_GRAY, 0, &imageTmp);
if (HGBASE_ERR_OK == ret)
{
ret = HGBase_ImageRotate180(imageTmp, imageTmp);
if (HGBASE_ERR_OK == ret)
{
ret = HGBase_CopyImage(imageTmp, image);
}
HGBase_DestroyImage(imageTmp);
}
return ret;
}
HGByte* p1 = data + (HGUSize)top * (HGUSize)widthStep + left * channels;
HGInt step1 = (HGInt)widthStep;
HGByte* p2 = data + (HGUSize)(bottom - 1) * (HGUSize)widthStep + left * channels;
HGInt step2 = -(HGInt)widthStep;
if (HGBASE_IMGORIGIN_BOTTOM == origin)
{
p1 = data + (HGUSize)(height - top - 1) * (HGUSize)widthStep + left * channels;
step1 = -(HGInt)widthStep;
p2 = data + (HGUSize)(height - bottom) * (HGUSize)widthStep + left * channels;
step2 = (HGInt)widthStep;
}
if (3 == channels)
{
HGUInt loop = roiHeight / 2;
//#pragma omp parallel for
for (int32_t i = 0; i < (int32_t)loop; ++i)
{
HGByte* p1Ex = p1 + (HGSize)i * (HGSize)step1;
HGByte* p1ExEnd = p1Ex + dataSize;
HGByte* p2Ex = p2 + (HGSize)i * (HGSize)step2 + dataSize - channels;
while (p1Ex < p1ExEnd)
{
HGByte temp0 = p1Ex[0];
p1Ex[0] = p2Ex[0];
p2Ex[0] = temp0;
HGByte temp1 = p1Ex[1];
p1Ex[1] = p2Ex[1];
p2Ex[1] = temp1;
HGByte temp2 = p1Ex[2];
p1Ex[2] = p2Ex[2];
p2Ex[2] = temp2;
p1Ex += 3;
p2Ex -= 3;
}
}
if (0 != roiHeight % 2)
{
HGByte* p1Ex = p1 + (HGSize)loop * (HGSize)step1;
HGByte* p2Ex = p2 + (HGSize)loop * (HGSize)step2 + dataSize - channels;
while (p1Ex < p2Ex)
{
HGByte temp0 = p1Ex[0];
p1Ex[0] = p2Ex[0];
p2Ex[0] = temp0;
HGByte temp1 = p1Ex[1];
p1Ex[1] = p2Ex[1];
p2Ex[1] = temp1;
HGByte temp2 = p1Ex[2];
p1Ex[2] = p2Ex[2];
p2Ex[2] = temp2;
p1Ex += 3;
p2Ex -= 3;
}
}
}
else if (4 == channels)
{
HGUInt loop = roiHeight / 2;
//#pragma omp parallel for
for (int32_t i = 0; i < (int32_t)loop; ++i)
{
HGByte* p1Ex = p1 + (HGSize)i * (HGSize)step1;
HGByte* p1ExEnd = p1Ex + dataSize;
HGByte* p2Ex = p2 + (HGSize)i * (HGSize)step2 + dataSize - channels;
while (p1Ex < p1ExEnd)
{
HGUInt tmp = *(HGUInt*)p1Ex;
*(HGUInt*)p1Ex = *(HGUInt*)p2Ex;
*(HGUInt*)p2Ex = tmp;
p1Ex += 4;
p2Ex -= 4;
}
}
if (0 != roiHeight % 2)
{
HGByte* p1Ex = p1 + (HGSize)loop * (HGSize)step1;
HGByte* p2Ex = p2 + (HGSize)loop * (HGSize)step2 + dataSize - channels;
while (p1Ex < p2Ex)
{
HGUInt tmp = *(HGUInt*)p1Ex;
*(HGUInt*)p1Ex = *(HGUInt*)p2Ex;
*(HGUInt*)p2Ex = tmp;
p1Ex += 4;
p2Ex -= 4;
}
}
}
else
{
assert(1 == channels);
HGUInt loop = roiHeight / 2;
//#pragma omp parallel for
for (int32_t i = 0; i < (int32_t)loop; ++i)
{
HGByte* p1Ex = p1 + (HGSize)i * (HGSize)step1;
HGByte* p1ExEnd = p1Ex + dataSize;
HGByte* p2Ex = p2 + (HGSize)i * (HGSize)step2 + dataSize - channels;
while (p1Ex < p1ExEnd)
{
HGByte tmp = *p1Ex;
*p1Ex = *p2Ex;
*p2Ex = tmp;
++p1Ex;
--p2Ex;
}
}
if (0 != roiHeight % 2)
{
HGByte* p1Ex = p1 + (HGSize)loop * (HGSize)step1;
HGByte* p2Ex = p2 + (HGSize)loop * (HGSize)step2 + dataSize - channels;
while (p1Ex < p2Ex)
{
HGByte tmp = *p1Ex;
*p1Ex = *p2Ex;
*p2Ex = tmp;
++p1Ex;
--p2Ex;
}
}
}
}
else
{
HGImageImpl* destImageImpl = (HGImageImpl*)destImage;
HGUInt destWidth = destImageImpl->m_width;
HGUInt destHeight = destImageImpl->m_height;
HGUInt destType = destImageImpl->m_type;
HGUInt destWidthStep = destImageImpl->m_widthStep;
HGUInt destOrigin = destImageImpl->m_origin;
HGUInt destLeft = destImageImpl->m_left;
HGUInt destTop = destImageImpl->m_top;
HGUInt destRight = destImageImpl->m_right;
HGUInt destBottom = destImageImpl->m_bottom;
uint8_t* destData = destImageImpl->m_data;
if (type != destType)
{
return HGBASE_ERR_INVALIDDATA;
}
if (roiWidth != (destRight - destLeft) || roiHeight != (destBottom - destTop))
{
return HGBASE_ERR_INVALIDDATA;
}
if (HGBASE_IMGTYPE_BINARY == type)
{
HGImage imageTmp = NULL;
HGResult ret = HGBase_CloneImage(image, HGBASE_IMGTYPE_GRAY, 0, &imageTmp);
if (HGBASE_ERR_OK == ret)
{
ret = HGBase_ImageRotate180(imageTmp, imageTmp);
if (HGBASE_ERR_OK == ret)
{
ret = HGBase_CopyImage(imageTmp, destImage);
}
HGBase_DestroyImage(imageTmp);
}
return ret;
}
HGByte* src = data + (HGUSize)top * (HGUSize)widthStep + left * channels;
HGInt srcStep = (HGInt)widthStep;
if (HGBASE_IMGORIGIN_BOTTOM == origin)
{
src = data + (HGUSize)(height - top - 1) * (HGUSize)widthStep + left * channels;
srcStep = -(HGInt)widthStep;
}
HGByte* dest = destData + (HGUSize)(destBottom - 1) * (HGUSize)destWidthStep + destLeft * channels;
HGInt destStep = -(HGInt)destWidthStep;
if (HGBASE_IMGORIGIN_BOTTOM == destOrigin)
{
dest = destData + (HGUSize)(destHeight - destBottom) * (HGUSize)destWidthStep + destLeft * channels;
destStep = (HGInt)destWidthStep;
}
if (3 == channels)
{
//#pragma omp parallel for
for (int32_t i = 0; i < (int32_t)roiHeight; ++i)
{
HGByte* p1Ex = src + (HGSize)i * (HGSize)srcStep;
HGByte* p1ExEnd = p1Ex + dataSize;
HGByte* p2Ex = dest + (HGSize)i * (HGSize)destStep + dataSize - channels;
while (p1Ex < p1ExEnd)
{
p2Ex[0] = p1Ex[0];
p2Ex[1] = p1Ex[1];
p2Ex[2] = p1Ex[2];
p1Ex += 3;
p2Ex -= 3;
}
}
}
else if (4 == channels)
{
//#pragma omp parallel for
for (int32_t i = 0; i < (int32_t)roiHeight; ++i)
{
HGByte* p1Ex = src + (HGSize)i * (HGSize)srcStep;
HGByte* p1ExEnd = p1Ex + dataSize;
HGByte* p2Ex = dest + (HGSize)i * (HGSize)destStep + dataSize - channels;
while (p1Ex < p1ExEnd)
{
*(HGUInt*)p2Ex = *(HGUInt*)p1Ex;
p1Ex += 4;
p2Ex -= 4;
}
}
}
else
{
assert(1 == channels);
//#pragma omp parallel for
for (int32_t i = 0; i < (int32_t)roiHeight; ++i)
{
HGByte* p1Ex = src + (HGSize)i * (HGSize)srcStep;
HGByte* p1ExEnd = p1Ex + dataSize;
HGByte* p2Ex = dest + (HGSize)i * (HGSize)destStep + dataSize - channels;
while (p1Ex < p1ExEnd)
{
*p2Ex = *p1Ex;
++p1Ex;
--p2Ex;
}
}
}
}
return HGBASE_ERR_OK;
}
HGResult HGAPI HGBase_ImageGrayscale(HGImage image, HGImage destImage)
{
if (NULL == image)
{
return HGBASE_ERR_INVALIDARG;
}
HGImageImpl* imageImpl = (HGImageImpl*)image;
HGUInt width = imageImpl->m_width;
HGUInt height = imageImpl->m_height;
HGUInt type = imageImpl->m_type;
HGUInt widthStep = imageImpl->m_widthStep;
HGUInt origin = imageImpl->m_origin;
HGUInt left = imageImpl->m_left;
HGUInt top = imageImpl->m_top;
HGUInt right = imageImpl->m_right;
HGUInt bottom = imageImpl->m_bottom;
HGByte* data = imageImpl->m_data;
HGUInt roiWidth = right - left;
HGUInt roiHeight = bottom - top;
uint32_t channels = 1;
if (HGBASE_IMGTYPE_BGR == type || HGBASE_IMGTYPE_RGB == type)
channels = 3;
else if (HGBASE_IMGTYPE_BGRA == type || HGBASE_IMGTYPE_RGBA == type)
channels = 4;
uint32_t dataSize = roiWidth * channels;
if (NULL == destImage || image == destImage)
{
if (HGBASE_IMGTYPE_BINARY == type)
{
return HGBASE_ERR_OK;
}
HGByte* p = data + (HGUSize)top * (HGUSize)widthStep + left * channels;
HGInt step = (HGInt)widthStep;
if (HGBASE_IMGORIGIN_BOTTOM == origin)
{
p = data + (HGUSize)(height - top - 1) * (HGUSize)widthStep + left * channels;
step = -(HGInt)widthStep;
}
if (HGBASE_IMGTYPE_RGB == type || HGBASE_IMGTYPE_RGBA == type)
{
//#pragma omp parallel for
for (int32_t i = 0; i < (int32_t)roiHeight; ++i)
{
uint8_t* pEx = p + (HGSize)i * (HGSize)step;
uint8_t* pExEnd = pEx + dataSize;
while (pEx < pExEnd)
{
uint8_t value = (pEx[0] * 76 + pEx[1] * 150 + pEx[2] * 30) >> 8;
pEx[0] = pEx[1] = pEx[2] = value;
pEx += channels;
}
}
}
else if (HGBASE_IMGTYPE_BGR == type || HGBASE_IMGTYPE_BGRA == type)
{
//#pragma omp parallel for
for (int32_t i = 0; i < (int32_t)roiHeight; ++i)
{
uint8_t* pEx = p + (HGSize)i * (HGSize)step;
uint8_t* pExEnd = pEx + dataSize;
while (pEx < pExEnd)
{
uint8_t value = (pEx[2] * 76 + pEx[1] * 150 + pEx[0] * 30) >> 8;
pEx[0] = pEx[1] = pEx[2] = value;
pEx += channels;
}
}
}
else
{
assert(HGBASE_IMGTYPE_GRAY == type);
}
}
else
{
HGImageImpl* destImageImpl = (HGImageImpl*)destImage;
HGUInt destWidth = destImageImpl->m_width;
HGUInt destHeight = destImageImpl->m_height;
HGUInt destType = destImageImpl->m_type;
HGUInt destWidthStep = destImageImpl->m_widthStep;
HGUInt destOrigin = destImageImpl->m_origin;
HGUInt destLeft = destImageImpl->m_left;
HGUInt destTop = destImageImpl->m_top;
HGUInt destRight = destImageImpl->m_right;
HGUInt destBottom = destImageImpl->m_bottom;
uint8_t* destData = destImageImpl->m_data;
if (type != destType)
{
return HGBASE_ERR_INVALIDDATA;
}
if (roiWidth != (destRight - destLeft) || roiHeight != (destBottom - destTop))
{
return HGBASE_ERR_INVALIDDATA;
}
if (HGBASE_IMGTYPE_BINARY == type)
{
return HGBase_CopyImage(image, destImage);
}
HGByte* src = data + (HGUSize)top * (HGUSize)widthStep + left * channels;
HGInt srcStep = (HGInt)widthStep;
if (HGBASE_IMGORIGIN_BOTTOM == origin)
{
src = data + (HGUSize)(height - top - 1) * (HGUSize)widthStep + left * channels;
srcStep = -(HGInt)widthStep;
}
HGByte* dest = destData + (HGUSize)destTop * (HGUSize)destWidthStep + destLeft * channels;
HGInt destStep = (HGInt)destWidthStep;
if (HGBASE_IMGORIGIN_BOTTOM == destOrigin)
{
dest = destData + (HGUSize)(destHeight - destTop - 1) * (HGUSize)destWidthStep + destLeft * channels;
destStep = -(HGInt)destWidthStep;
}
if (HGBASE_IMGTYPE_RGB == type || HGBASE_IMGTYPE_RGBA == type)
{
//#pragma omp parallel for
for (int32_t i = 0; i < (int32_t)roiHeight; ++i)
{
HGByte* pEx = src + (HGSize)i * (HGSize)srcStep;
HGByte* pExEnd = pEx + dataSize;
HGByte* pDestEx = dest + (HGSize)i * (HGSize)destStep;
while (pEx < pExEnd)
{
uint8_t value = (pEx[0] * 76 + pEx[1] * 150 + pEx[2] * 30) >> 8;
pDestEx[0] = pDestEx[1] = pDestEx[2] = value;
pEx += channels;
pDestEx += channels;
}
}
}
else if (HGBASE_IMGTYPE_BGR == type || HGBASE_IMGTYPE_BGRA == type)
{
//#pragma omp parallel for
for (int32_t i = 0; i < (int32_t)roiHeight; ++i)
{
HGByte* pEx = src + (HGSize)i * (HGSize)srcStep;
HGByte* pExEnd = pEx + dataSize;
HGByte* pDestEx = dest + (HGSize)i * (HGSize)destStep;
while (pEx < pExEnd)
{
uint8_t value = (pEx[2] * 76 + pEx[1] * 150 + pEx[0] * 30) >> 8;
pDestEx[0] = pDestEx[1] = pDestEx[2] = value;
pEx += channels;
pDestEx += channels;
}
}
}
else
{
assert(HGBASE_IMGTYPE_GRAY == type);
//#pragma omp parallel for
for (int32_t i = 0; i < (int32_t)roiHeight; ++i)
{
HGByte* pEx = src + (HGSize)i * (HGSize)srcStep;
HGByte* pDestEx = dest + (HGSize)i * (HGSize)destStep;
memcpy(pDestEx, pEx, dataSize);
}
}
}
return HGBASE_ERR_OK;
}
HGResult HGAPI HGBase_ReverseImage(HGImage image, HGImage destImage)
{
if (NULL == image)
{
return HGBASE_ERR_INVALIDARG;
}
HGImageImpl* imageImpl = (HGImageImpl*)image;
HGUInt width = imageImpl->m_width;
HGUInt height = imageImpl->m_height;
HGUInt type = imageImpl->m_type;
HGUInt widthStep = imageImpl->m_widthStep;
HGUInt origin = imageImpl->m_origin;
HGUInt left = imageImpl->m_left;
HGUInt top = imageImpl->m_top;
HGUInt right = imageImpl->m_right;
HGUInt bottom = imageImpl->m_bottom;
HGByte* data = imageImpl->m_data;
HGUInt roiWidth = right - left;
HGUInt roiHeight = bottom - top;
uint32_t channels = 1;
if (HGBASE_IMGTYPE_BGR == type || HGBASE_IMGTYPE_RGB == type)
channels = 3;
else if (HGBASE_IMGTYPE_BGRA == type || HGBASE_IMGTYPE_RGBA == type)
channels = 4;
uint32_t dataSize = roiWidth * channels;
if (NULL == destImage || image == destImage)
{
if (HGBASE_IMGTYPE_BINARY == type)
{
HGImage imageTmp = NULL;
HGResult ret = HGBase_CloneImage(image, HGBASE_IMGTYPE_GRAY, 0, &imageTmp);
if (HGBASE_ERR_OK == ret)
{
ret = HGBase_ReverseImage(imageTmp, imageTmp);
if (HGBASE_ERR_OK == ret)
{
ret = HGBase_CopyImage(imageTmp, image);
}
HGBase_DestroyImage(imageTmp);
}
return ret;
}
HGByte* p = data + (HGUSize)top * (HGUSize)widthStep + left * channels;
HGInt step = (HGInt)widthStep;
if (HGBASE_IMGORIGIN_BOTTOM == origin)
{
p = data + (HGUSize)(height - top - 1) * (HGUSize)widthStep + left * channels;
step = -(HGInt)widthStep;
}
if (4 == channels)
{
//#pragma omp parallel for
for (int32_t i = 0; i < (int32_t)roiHeight; ++i)
{
uint8_t* pEx = p + (HGSize)i * (HGSize)step;
uint8_t* pExEnd = pEx + dataSize;
while (pEx < pExEnd)
{
HGUInt temp = *(HGUInt*)pEx;
temp = ~temp;
*(HGUInt*)pEx = temp;
pEx += 4;
}
}
}
else
{
//#pragma omp parallel for
for (int32_t i = 0; i < (int32_t)roiHeight; ++i)
{
uint8_t* pEx = p + (HGSize)i * (HGSize)step;
uint8_t* pExEnd = pEx + dataSize;
while (pEx < pExEnd)
{
uint8_t temp = *pEx;
temp = ~temp;
*pEx = temp;
++pEx;
}
}
}
}
else
{
HGImageImpl* destImageImpl = (HGImageImpl*)destImage;
HGUInt destWidth = destImageImpl->m_width;
HGUInt destHeight = destImageImpl->m_height;
HGUInt destType = destImageImpl->m_type;
HGUInt destWidthStep = destImageImpl->m_widthStep;
HGUInt destOrigin = destImageImpl->m_origin;
HGUInt destLeft = destImageImpl->m_left;
HGUInt destTop = destImageImpl->m_top;
HGUInt destRight = destImageImpl->m_right;
HGUInt destBottom = destImageImpl->m_bottom;
uint8_t* destData = destImageImpl->m_data;
if (type != destType)
{
return HGBASE_ERR_INVALIDDATA;
}
if (roiWidth != (destRight - destLeft) || roiHeight != (destBottom - destTop))
{
return HGBASE_ERR_INVALIDDATA;
}
if (HGBASE_IMGTYPE_BINARY == type)
{
HGImage imageTmp = NULL;
HGResult ret = HGBase_CloneImage(image, HGBASE_IMGTYPE_GRAY, 0, &imageTmp);
if (HGBASE_ERR_OK == ret)
{
ret = HGBase_ReverseImage(imageTmp, imageTmp);
if (HGBASE_ERR_OK == ret)
{
ret = HGBase_CopyImage(imageTmp, destImage);
}
HGBase_DestroyImage(imageTmp);
}
return ret;
}
HGByte* src = data + (HGUSize)top * (HGUSize)widthStep + left * channels;
HGInt srcStep = (HGInt)widthStep;
if (HGBASE_IMGORIGIN_BOTTOM == origin)
{
src = data + (HGUSize)(height - top - 1) * (HGUSize)widthStep + left * channels;
srcStep = -(HGInt)widthStep;
}
HGByte* dest = destData + (HGUSize)destTop * (HGUSize)destWidthStep + destLeft * channels;
HGInt destStep = (HGInt)destWidthStep;
if (HGBASE_IMGORIGIN_BOTTOM == destOrigin)
{
dest = destData + (HGUSize)(destHeight - destTop - 1) * (HGUSize)destWidthStep + destLeft * channels;
destStep = -(HGInt)destWidthStep;
}
if (4 == channels)
{
//#pragma omp parallel for
for (int32_t i = 0; i < (int32_t)roiHeight; ++i)
{
HGByte* pEx = src + (HGSize)i * (HGSize)srcStep;
HGByte* pExEnd = pEx + dataSize;
HGByte* pDestEx = dest + (HGSize)i * (HGSize)destStep;
while (pEx < pExEnd)
{
HGUInt temp = *(HGUInt*)pEx;
temp = ~temp;
*(HGUInt*)pDestEx = temp;
pEx += 4;
pDestEx += 4;
}
}
}
else
{
//#pragma omp parallel for
for (int32_t i = 0; i < (int32_t)roiHeight; ++i)
{
HGByte* pEx = src + (HGSize)i * (HGSize)srcStep;
HGByte* pExEnd = pEx + dataSize;
HGByte* pDestEx = dest + (HGSize)i * (HGSize)destStep;
while (pEx < pExEnd)
{
uint8_t temp = *pEx;
temp = ~temp;
*pDestEx = temp;
++pEx;
++pDestEx;
}
}
}
}
return HGBASE_ERR_OK;
}
static inline HGByte GetBit(const HGByte* data, HGUInt index)
{
HGUInt byteIndex = index / 8;
HGUInt bitIndex = index % 8;
return (data[byteIndex] >> (7 - bitIndex)) & 0x01;
}
static inline void SetBit(HGByte* data, HGUInt index, HGByte value)
{
assert(0 == value || 1 == value);
HGUInt byteIndex = index / 8;
HGUInt bitIndex = index % 8;
if (1 == value)
data[byteIndex] |= (1 << (7 - bitIndex));
else
data[byteIndex] &= ~(1 << (7 - bitIndex));
}
static HGResult CopyImageWithBinary(HGImageImpl *srcImageImpl, HGImageImpl *destImageImpl)
{
assert(HGBASE_IMGTYPE_BINARY == srcImageImpl->m_type
|| HGBASE_IMGTYPE_BINARY == destImageImpl->m_type);
HGByte* src = srcImageImpl->m_data + (HGUSize)srcImageImpl->m_top * (HGUSize)srcImageImpl->m_widthStep;
HGInt srcStep = (HGInt)srcImageImpl->m_widthStep;
if (HGBASE_IMGORIGIN_BOTTOM == srcImageImpl->m_origin)
{
src = srcImageImpl->m_data + (HGUSize)(srcImageImpl->m_height - srcImageImpl->m_top - 1) * (HGUSize)srcImageImpl->m_widthStep;
srcStep = -(HGInt)srcImageImpl->m_widthStep;
}
HGByte* dest = destImageImpl->m_data + (HGUSize)destImageImpl->m_top * (HGUSize)destImageImpl->m_widthStep;
HGInt destStep = (HGInt)destImageImpl->m_widthStep;
if (HGBASE_IMGORIGIN_BOTTOM == destImageImpl->m_origin)
{
dest = destImageImpl->m_data + (HGUSize)(destImageImpl->m_height - destImageImpl->m_top - 1) * (HGUSize)destImageImpl->m_widthStep;
destStep = -(HGInt)destImageImpl->m_widthStep;
}
if (HGBASE_IMGTYPE_BINARY == srcImageImpl->m_type)
{
if (HGBASE_IMGTYPE_BINARY == destImageImpl->m_type)
{
for (int32_t i = 0; i < (int32_t)(srcImageImpl->m_bottom - srcImageImpl->m_top); ++i)
{
HGByte* pSrcEx = src + (HGSize)i * (HGSize)srcStep;
HGByte* pDestEx = dest + (HGSize)i * (HGSize)destStep;
for (int32_t j = 0; j < (int32_t)(srcImageImpl->m_right - srcImageImpl->m_left); ++j)
{
HGByte value = GetBit(pSrcEx, srcImageImpl->m_left + j);
SetBit(pDestEx, destImageImpl->m_left + j, value);
}
}
}
else if (HGBASE_IMGTYPE_GRAY == destImageImpl->m_type)
{
for (int32_t i = 0; i < (int32_t)(srcImageImpl->m_bottom - srcImageImpl->m_top); ++i)
{
HGByte* pSrcEx = src + (HGSize)i * (HGSize)srcStep;
HGByte* pDestEx = dest + (HGSize)i * (HGSize)destStep;
for (int32_t j = 0; j < (int32_t)(srcImageImpl->m_right - srcImageImpl->m_left); ++j)
{
HGByte value = GetBit(pSrcEx, srcImageImpl->m_left + j);
pDestEx[destImageImpl->m_left + j] = (0 == value) ? 0 : 255;
}
}
}
else if (HGBASE_IMGTYPE_BGR == destImageImpl->m_type || HGBASE_IMGTYPE_RGB == destImageImpl->m_type)
{
for (int32_t i = 0; i < (int32_t)(srcImageImpl->m_bottom - srcImageImpl->m_top); ++i)
{
HGByte* pSrcEx = src + (HGSize)i * (HGSize)srcStep;
HGByte* pDestEx = dest + (HGSize)i * (HGSize)destStep;
for (int32_t j = 0; j < (int32_t)(srcImageImpl->m_right - srcImageImpl->m_left); ++j)
{
HGByte value = GetBit(pSrcEx, srcImageImpl->m_left + j);
pDestEx[(destImageImpl->m_left + j) * 3] = (0 == value) ? 0 : 255;
pDestEx[(destImageImpl->m_left + j) * 3 + 1] = (0 == value) ? 0 : 255;
pDestEx[(destImageImpl->m_left + j) * 3 + 2] = (0 == value) ? 0 : 255;
}
}
}
else
{
assert(HGBASE_IMGTYPE_BGRA == destImageImpl->m_type || HGBASE_IMGTYPE_RGBA == destImageImpl->m_type);
for (int32_t i = 0; i < (int32_t)(srcImageImpl->m_bottom - srcImageImpl->m_top); ++i)
{
HGByte* pSrcEx = src + (HGSize)i * (HGSize)srcStep;
HGByte* pDestEx = dest + (HGSize)i * (HGSize)destStep;
for (int32_t j = 0; j < (int32_t)(srcImageImpl->m_right - srcImageImpl->m_left); ++j)
{
HGByte value = GetBit(pSrcEx, srcImageImpl->m_left + j);
pDestEx[(destImageImpl->m_left + j) * 4] = (0 == value) ? 0 : 255;
pDestEx[(destImageImpl->m_left + j) * 4 + 1] = (0 == value) ? 0 : 255;
pDestEx[(destImageImpl->m_left + j) * 4 + 2] = (0 == value) ? 0 : 255;
}
}
}
}
else
{
assert(HGBASE_IMGTYPE_BINARY == destImageImpl->m_type);
if (HGBASE_IMGTYPE_GRAY == srcImageImpl->m_type)
{
for (int32_t i = 0; i < (int32_t)(srcImageImpl->m_bottom - srcImageImpl->m_top); ++i)
{
HGByte* pSrcEx = src + (HGSize)i * (HGSize)srcStep;
HGByte* pDestEx = dest + (HGSize)i * (HGSize)destStep;
for (int32_t j = 0; j < (int32_t)(srcImageImpl->m_right - srcImageImpl->m_left); ++j)
{
HGByte v = pSrcEx[srcImageImpl->m_left + j];
SetBit(pDestEx, destImageImpl->m_left + j, (v >= 128 ? 1 : 0));
}
}
}
else if (HGBASE_IMGTYPE_BGR == srcImageImpl->m_type)
{
for (int32_t i = 0; i < (int32_t)(srcImageImpl->m_bottom - srcImageImpl->m_top); ++i)
{
HGByte* pSrcEx = src + (HGSize)i * (HGSize)srcStep;
HGByte* pDestEx = dest + (HGSize)i * (HGSize)destStep;
for (int32_t j = 0; j < (int32_t)(srcImageImpl->m_right - srcImageImpl->m_left); ++j)
{
HGInt b = pSrcEx[(srcImageImpl->m_left + j) * 3];
HGInt g = pSrcEx[(srcImageImpl->m_left + j) * 3 + 1];
HGInt r = pSrcEx[(srcImageImpl->m_left + j) * 3 + 2];
HGByte v = (r * 76 + g * 150 + b * 30) >> 8;
SetBit(pDestEx, destImageImpl->m_left + j, (v >= 128 ? 1 : 0));
}
}
}
else if (HGBASE_IMGTYPE_RGB == srcImageImpl->m_type)
{
for (int32_t i = 0; i < (int32_t)(srcImageImpl->m_bottom - srcImageImpl->m_top); ++i)
{
HGByte* pSrcEx = src + (HGSize)i * (HGSize)srcStep;
HGByte* pDestEx = dest + (HGSize)i * (HGSize)destStep;
for (int32_t j = 0; j < (int32_t)(srcImageImpl->m_right - srcImageImpl->m_left); ++j)
{
HGInt r = pSrcEx[(srcImageImpl->m_left + j) * 3];
HGInt g = pSrcEx[(srcImageImpl->m_left + j) * 3 + 1];
HGInt b = pSrcEx[(srcImageImpl->m_left + j) * 3 + 2];
HGByte v = (r * 76 + g * 150 + b * 30) >> 8;
SetBit(pDestEx, destImageImpl->m_left + j, (v >= 128 ? 1 : 0));
}
}
}
else if (HGBASE_IMGTYPE_BGRA == srcImageImpl->m_type)
{
for (int32_t i = 0; i < (int32_t)(srcImageImpl->m_bottom - srcImageImpl->m_top); ++i)
{
HGByte* pSrcEx = src + (HGSize)i * (HGSize)srcStep;
HGByte* pDestEx = dest + (HGSize)i * (HGSize)destStep;
for (int32_t j = 0; j < (int32_t)(srcImageImpl->m_right - srcImageImpl->m_left); ++j)
{
HGInt b = pSrcEx[(srcImageImpl->m_left + j) * 4];
HGInt g = pSrcEx[(srcImageImpl->m_left + j) * 4 + 1];
HGInt r = pSrcEx[(srcImageImpl->m_left + j) * 4 + 2];
HGByte v = (r * 76 + g * 150 + b * 30) >> 8;
SetBit(pDestEx, destImageImpl->m_left + j, (v >= 128 ? 1 : 0));
}
}
}
else if (HGBASE_IMGTYPE_RGBA == srcImageImpl->m_type)
{
for (int32_t i = 0; i < (int32_t)(srcImageImpl->m_bottom - srcImageImpl->m_top); ++i)
{
HGByte* pSrcEx = src + (HGSize)i * (HGSize)srcStep;
HGByte* pDestEx = dest + (HGSize)i * (HGSize)destStep;
for (int32_t j = 0; j < (int32_t)(srcImageImpl->m_right - srcImageImpl->m_left); ++j)
{
HGInt r = pSrcEx[(srcImageImpl->m_left + j) * 4];
HGInt g = pSrcEx[(srcImageImpl->m_left + j) * 4 + 1];
HGInt b = pSrcEx[(srcImageImpl->m_left + j) * 4 + 2];
HGByte v = (r * 76 + g * 150 + b * 30) >> 8;
SetBit(pDestEx, destImageImpl->m_left + j, (v >= 128 ? 1 : 0));
}
}
}
}
return HGBASE_ERR_OK;
}
HGResult HGAPI HGBase_CopyImage(HGImage image, HGImage destImage)
{
if (NULL == image || NULL == destImage || image == destImage)
{
return HGBASE_ERR_INVALIDARG;
}
HGImageImpl* imageImpl = (HGImageImpl*)image;
HGUInt width = imageImpl->m_width;
HGUInt height = imageImpl->m_height;
HGUInt type = imageImpl->m_type;
HGUInt widthStep = imageImpl->m_widthStep;
HGUInt origin = imageImpl->m_origin;
HGUInt left = imageImpl->m_left;
HGUInt top = imageImpl->m_top;
HGUInt right = imageImpl->m_right;
HGUInt bottom = imageImpl->m_bottom;
HGByte* data = imageImpl->m_data;
HGUInt roiWidth = right - left;
HGUInt roiHeight = bottom - top;
HGImageImpl* destImageImpl = (HGImageImpl*)destImage;
HGUInt destWidth = destImageImpl->m_width;
HGUInt destHeight = destImageImpl->m_height;
HGUInt destType = destImageImpl->m_type;
HGUInt destWidthStep = destImageImpl->m_widthStep;
HGUInt destOrigin = destImageImpl->m_origin;
HGUInt destLeft = destImageImpl->m_left;
HGUInt destTop = destImageImpl->m_top;
HGUInt destRight = destImageImpl->m_right;
HGUInt destBottom = destImageImpl->m_bottom;
uint8_t* destData = destImageImpl->m_data;
if (roiWidth != (destRight - destLeft) || roiHeight != (destBottom - destTop))
{
return HGBASE_ERR_INVALIDDATA;
}
if (HGBASE_IMGTYPE_BINARY == type || HGBASE_IMGTYPE_BINARY == destType)
{
return CopyImageWithBinary(imageImpl, destImageImpl);
}
uint32_t channels = 1;
if (HGBASE_IMGTYPE_BGR == type || HGBASE_IMGTYPE_RGB == type)
channels = 3;
else if (HGBASE_IMGTYPE_BGRA == type || HGBASE_IMGTYPE_RGBA == type)
channels = 4;
uint32_t dataSize = roiWidth * channels;
uint32_t destChannels = 1;
if (HGBASE_IMGTYPE_BGR == destType || HGBASE_IMGTYPE_RGB == destType)
destChannels = 3;
else if (HGBASE_IMGTYPE_BGRA == destType || HGBASE_IMGTYPE_RGBA == destType)
destChannels = 4;
HGByte* src = data + (HGUSize)top * (HGUSize)widthStep + left * channels;
HGInt srcStep = (HGInt)widthStep;
if (HGBASE_IMGORIGIN_BOTTOM == origin)
{
src = data + (HGUSize)(height - top - 1) * (HGUSize)widthStep + left * channels;
srcStep = -(HGInt)widthStep;
}
HGByte* dest = destData + (HGUSize)destTop * (HGUSize)destWidthStep + destLeft * destChannels;
HGInt destStep = (HGInt)destWidthStep;
if (HGBASE_IMGORIGIN_BOTTOM == destOrigin)
{
dest = destData + (HGUSize)(destHeight - destTop - 1) * (HGUSize)destWidthStep + destLeft * destChannels;
destStep = -(HGInt)destWidthStep;
}
if (type == destType)
{
//#pragma omp parallel for
for (int32_t i = 0; i < (int32_t)roiHeight; ++i)
{
HGByte* pEx = src + (HGSize)i * (HGSize)srcStep;
HGByte* pDestEx = dest + (HGSize)i * (HGSize)destStep;
memcpy(pDestEx, pEx, dataSize);
}
}
else
{
if (HGBASE_IMGTYPE_GRAY == type)
{
//#pragma omp parallel for
for (int32_t i = 0; i < (int32_t)roiHeight; ++i)
{
HGByte* pEx = src + (HGSize)i * (HGSize)srcStep;
HGByte* pExEnd = pEx + dataSize;
HGByte* pDestEx = dest + (HGSize)i * (HGSize)destStep;
while (pEx < pExEnd)
{
pDestEx[0] = pDestEx[1] = pDestEx[2] = *pEx;
++pEx;
pDestEx += destChannels;
}
}
}
else if (HGBASE_IMGTYPE_GRAY == destType)
{
if (HGBASE_IMGTYPE_RGB == type || HGBASE_IMGTYPE_RGBA == type)
{
//#pragma omp parallel for
for (int32_t i = 0; i < (int32_t)roiHeight; ++i)
{
HGByte* pEx = src + (HGSize)i * (HGSize)srcStep;
HGByte* pExEnd = pEx + dataSize;
HGByte* pDestEx = dest + (HGSize)i * (HGSize)destStep;
while (pEx < pExEnd)
{
uint8_t value = (pEx[0] * 76 + pEx[1] * 150 + pEx[2] * 30) >> 8;
*pDestEx = value;
pEx += channels;
++pDestEx;
}
}
}
else
{
assert(HGBASE_IMGTYPE_BGR == type || HGBASE_IMGTYPE_BGRA == type);
//#pragma omp parallel for
for (int32_t i = 0; i < (int32_t)roiHeight; ++i)
{
HGByte* pEx = src + (HGSize)i * (HGSize)srcStep;
HGByte* pExEnd = pEx + dataSize;
HGByte* pDestEx = dest + (HGSize)i * (HGSize)destStep;
while (pEx < pExEnd)
{
uint8_t value = (pEx[2] * 76 + pEx[1] * 150 + pEx[0] * 30) >> 8;
*pDestEx = value;
pEx += channels;
++pDestEx;
}
}
}
}
else if ((HGBASE_IMGTYPE_RGB == type && HGBASE_IMGTYPE_RGBA == destType)
|| (HGBASE_IMGTYPE_BGR == type && HGBASE_IMGTYPE_BGRA == destType)
|| (HGBASE_IMGTYPE_RGBA == type && HGBASE_IMGTYPE_RGB == destType)
|| (HGBASE_IMGTYPE_BGRA == type && HGBASE_IMGTYPE_BGR == destType))
{
//#pragma omp parallel for
for (int32_t i = 0; i < (int32_t)roiHeight; ++i)
{
HGByte* pEx = src + (HGSize)i * (HGSize)srcStep;
HGByte* pExEnd = pEx + dataSize;
HGByte* pDestEx = dest + (HGSize)i * (HGSize)destStep;
while (pEx < pExEnd)
{
pDestEx[0] = pEx[0];
pDestEx[1] = pEx[1];
pDestEx[2] = pEx[2];
pEx += channels;
pDestEx += destChannels;
}
}
}
else
{
assert((HGBASE_IMGTYPE_RGB == type && HGBASE_IMGTYPE_BGRA == destType)
|| (HGBASE_IMGTYPE_BGR == type && HGBASE_IMGTYPE_RGBA == destType)
|| (HGBASE_IMGTYPE_RGBA == type && HGBASE_IMGTYPE_BGRA == destType)
|| (HGBASE_IMGTYPE_BGRA == type && HGBASE_IMGTYPE_RGBA == destType)
|| (HGBASE_IMGTYPE_RGBA == type && HGBASE_IMGTYPE_BGR == destType)
|| (HGBASE_IMGTYPE_BGRA == type && HGBASE_IMGTYPE_RGB == destType)
|| (HGBASE_IMGTYPE_BGR == type && HGBASE_IMGTYPE_RGB == destType)
|| (HGBASE_IMGTYPE_RGB == type && HGBASE_IMGTYPE_BGR == destType));
//#pragma omp parallel for
for (int32_t i = 0; i < (int32_t)roiHeight; ++i)
{
HGByte* pEx = src + (HGSize)i * (HGSize)srcStep;
HGByte* pExEnd = pEx + dataSize;
HGByte* pDestEx = dest + (HGSize)i * (HGSize)destStep;
while (pEx < pExEnd)
{
pDestEx[2] = pEx[0];
pDestEx[1] = pEx[1];
pDestEx[0] = pEx[2];
pEx += channels;
pDestEx += destChannels;
}
}
}
}
return HGBASE_ERR_OK;
}
Reference in New Issue View Git Blame Copy Permalink