void ModelOpened::ExportPNG(wxString val, wxString suffix)
{
if (val == wxEmptyString)
return;
wxFileName fn = fixMPQPath(val);
if (fn.GetExt().Lower() != wxT("blp"))
return;
TextureID temptex = texturemanager.add(val);
Texture &tex = *((Texture*)texturemanager.items[temptex]);
if (tex.w == 0 || tex.h == 0)
return;
wxString temp;
unsigned char *tempbuf = (unsigned char*)malloc(tex.w*tex.h*4);
tex.getPixels(tempbuf, GL_BGRA_EXT);
CxImage *newImage = new CxImage(0);
newImage->AlphaCreate(); // Create the alpha layer
newImage->IncreaseBpp(32); // set image to 32bit
newImage->CreateFromArray(tempbuf, tex.w, tex.h, 32, (tex.w*4), true);
if (bPathPreserved) {
wxFileName::Mkdir(wxGetCwd()+SLASH+wxT("Export")+SLASH+fn.GetPath(), 0755, wxPATH_MKDIR_FULL);
temp = wxGetCwd()+SLASH+wxT("Export")+SLASH+fn.GetPath()+SLASH+fn.GetName()+wxT(".")+suffix;
} else {
temp = wxGetCwd()+SLASH+wxT("Export")+SLASH+fn.GetName()+wxT(".")+suffix;
}
//wxLogMessage(wxT("Info: Exporting texture to %s..."), temp.c_str());
if (suffix == wxT("tga"))
#ifndef _MINGW
newImage->Save(temp.mb_str(), CXIMAGE_FORMAT_TGA);
#else
newImage->Save(temp.wc_str(), CXIMAGE_FORMAT_TGA);
#endif
else
BOOL ScreenSnapshot::saveRect(__in RECT &rc, __in std::wstring &savePath)
{
snapshotScreen();
CxImage img;
int cx = rc.right - rc.left;
int cy = rc.bottom - rc.top;
HDC hSaveDC = CreateCompatibleDC(m_hMemDC);
HBITMAP hBitmap = CreateCompatibleBitmap(m_hMemDC, cx, cy);
HBITMAP hSaveBitmap = (HBITMAP)SelectObject(hSaveDC, (HGDIOBJ)hBitmap);
BitBlt(hSaveDC, 0, 0, cx, cy, m_hMemDC, rc.left, rc.top, SRCCOPY);
hBitmap = (HBITMAP)SelectObject(hSaveDC, (HBITMAP)hSaveBitmap);
BOOL result = FALSE;
do
{
if (!img.CreateFromHBITMAP(hBitmap))
{
break;
}
if (!img.Save(savePath.c_str(), CXIMAGE_FORMAT_BMP))
{
break;
}
result = TRUE;
} while (FALSE);
DeleteObject((HGDIOBJ)hBitmap);
DeleteDC(hSaveDC);
return result;
}
bool CPicShowCtrl::SaveFile(CString strPath)
{
int width=180;
int height=180;
CPaintDC dc(this);
CxImage img;
img.CreateFromHBITMAP(m_hBmp);
CBitmap bitmapmem;
CBitmap *pOldBit;
CDC m_pMemDC;
m_pMemDC.CreateCompatibleDC(&dc);
bitmapmem.CreateCompatibleBitmap(&dc, width, height);
pOldBit=m_pMemDC.SelectObject(&bitmapmem);
CRect rect(0,0,width,height);
HBRUSH bgBrush = ::CreateSolidBrush(RGB(255,255,255));
FillRect(m_pMemDC,&rect,bgBrush);
DeleteObject(bgBrush);
img.Draw(m_pMemDC,m_iStartx,m_iStarty,img.GetWidth(),img.GetHeight(),&rect);
CBitmap* pBmp=m_pMemDC.SelectObject(pOldBit);
CxImage xImagebmp;
xImagebmp.CreateFromHBITMAP((HBITMAP)bitmapmem.m_hObject);
xImagebmp.Resample(100,100,0);
bitmapmem.DeleteObject();
m_pMemDC.DeleteDC();
if(xImagebmp.Save(common::utility::stringhelper::UnicodeToAscii(strPath.GetBuffer()).c_str(), CXIMAGE_FORMAT_JPG))
{
return true;
}
return false;
}
bool SaveThumb(CxImage &image, const char *file, const char *thumb, int maxWidth, int maxHeight, bool bNeedToConvert = true, bool autoRotate = true)
{
// ok, now resample the image down if necessary
int ret = ResampleKeepAspectArea(image, maxWidth * maxHeight);
if (ret < 0) return false;
if (ret) bNeedToConvert = true;
// if we don't have a png but have a < 24 bit image, then convert to 24bits
if ( image.GetNumColors())
{
if (!image.IncreaseBpp(24) || !image.IsValid())
{
printf("PICTURE::SaveThumb: Unable to convert to 24bpp: Error:%s\n", image.GetLastError());
return false;
}
bNeedToConvert = true;
}
if ( autoRotate && image.GetExifInfo()->Orientation > 1)
{
image.RotateExif(image.GetExifInfo()->Orientation);
bNeedToConvert = true;
}
#ifndef _LINUX
::DeleteFile(thumb);
#else
unlink(thumb);
#endif
// only resave the image if we have to (quality of the JPG saver isn't too hot!)
if (bNeedToConvert)
{
// May as well have decent quality thumbs
image.SetJpegQuality(90);
if (!image.Save(thumb, image.AlphaIsValid() ? CXIMAGE_FORMAT_PNG : CXIMAGE_FORMAT_JPG))
{
printf("PICTURE::SaveThumb: Unable to save image: %s Error:%s\n", thumb, image.GetLastError());
::DeleteFile(thumb);
return false;
}
}
else
{ // Don't need to convert the file - copy it instead
if (!CopyFile(file, thumb))
{
printf("PICTURE::SaveThumb: Unable to copy file %s\n", file);
::DeleteFile(thumb);
return false;
}
}
return true;
}
void CClientMain::OnScreenShot()
{
CxImage ScreenImage = m_ScreenDisplayer.GetDisplayImage();
//if (ScreenImage.CreateFromHBITMAP(m_ScreenDisplayer.GetDisplayImage()))
{
ScreenImage.SetJpegQuality(m_dlgSetup.GetImageQuality());
TCHAR filter[] = _T("(*.bmp)|*.bmp |(*.gif)|*.gif|(*.jpg)|*.jpg|(*.png)|*.png|(*.tif)|*.tif|(*.tga)|*.tga|(*.pcx)|*.pcx|(*.wbmp)|*.wbmp|(*.wmf)|*.wmf|(*.jp2)|*.jp2|(*.jpc)|*.jpc|(*.pgx)|*.pgx|(*.raw)|*.raw||");
CFileDialog SaveDlg(false,NULL,NULL,OFN_HIDEREADONLY|OFN_OVERWRITEPROMPT,filter);
if (IDOK == SaveDlg.DoModal())
{
CString FilePathName = SaveDlg.GetPathName();
std::map<int,const wchar_t* const> mapFileExt;//保存所要用到的文件后缀名
std::map<int,DWORD> mapSaveType;//保存所要的图片保存类型对应的CxImage宏
mapFileExt.insert(std::make_pair(1,_T(".bmp")));
mapFileExt.insert(std::make_pair(2,_T(".gif")));
mapFileExt.insert(std::make_pair(3,_T(".jpg")));
mapFileExt.insert(std::make_pair(4,_T(".png")));
mapFileExt.insert(std::make_pair(5,_T(".tif")));
mapFileExt.insert(std::make_pair(6,_T(".tga")));
mapFileExt.insert(std::make_pair(7,_T(".pcx")));
mapFileExt.insert(std::make_pair(8,_T(".wbmp")));
mapFileExt.insert(std::make_pair(9,_T(".wmf")));
mapFileExt.insert(std::make_pair(10,_T(".jp2")));
mapFileExt.insert(std::make_pair(11,_T(".jpc")));
mapFileExt.insert(std::make_pair(12,_T(".pgx")));
mapFileExt.insert(std::make_pair(13,_T(".raw")));
mapSaveType.insert(std::make_pair(1,CXIMAGE_FORMAT_BMP));
mapSaveType.insert(std::make_pair(2,CXIMAGE_FORMAT_GIF));
mapSaveType.insert(std::make_pair(3,CXIMAGE_FORMAT_JPG));
mapSaveType.insert(std::make_pair(4,CXIMAGE_FORMAT_PNG));
mapSaveType.insert(std::make_pair(5,CXIMAGE_FORMAT_TIF));
mapSaveType.insert(std::make_pair(6,CXIMAGE_FORMAT_TGA));
mapSaveType.insert(std::make_pair(7,CXIMAGE_FORMAT_PCX));
mapSaveType.insert(std::make_pair(8,CXIMAGE_FORMAT_WBMP));
mapSaveType.insert(std::make_pair(9,CXIMAGE_FORMAT_WMF));
mapSaveType.insert(std::make_pair(10,CXIMAGE_FORMAT_JP2));
mapSaveType.insert(std::make_pair(11,CXIMAGE_FORMAT_JPC));
mapSaveType.insert(std::make_pair(12,CXIMAGE_FORMAT_PGX));
mapSaveType.insert(std::make_pair(13,CXIMAGE_FORMAT_RAW));
int nFileExt = SaveDlg.m_ofn.nFilterIndex;
const wchar_t *const tFileExt = mapFileExt[nFileExt];
DWORD dwSaveType = mapSaveType[nFileExt];
if(FilePathName.Right(4) !=tFileExt)
{
FilePathName += tFileExt;
ScreenImage.Save(FilePathName.GetString() ,dwSaveType);
}
}
}
}
int main(int argc, char* argv[])
{
CxImage image;
if (argc<3) {
fprintf(stderr, image.GetVersion());
fprintf(stderr, "\nConsole demo\n");
fprintf(stderr, "usage: %s input-file output-file\n", argv[0]);
return 1;
}
CString filein(argv[1]);
CString extin(FindExtension(filein));
extin.MakeLower();
int typein = FindFormat(extin);
if (typein == CXIMAGE_FORMAT_UNKNOWN) {
fprintf(stderr, "unknown extension for %s\n", argv[1]);
return 1;
}
CString fileout(argv[2]);
CString extout(FindExtension(fileout));
extout.MakeLower();
int typeout = FindFormat(extout);
if (typeout == CXIMAGE_FORMAT_UNKNOWN) {
fprintf(stderr, "unknown extension for %s\n", argv[2]);
return 1;
}
if (!image.Load(argv[1],typein)){
fprintf(stderr, "%s\n", image.GetLastError());
fprintf(stderr, "error loading %s\n", argv[1]);
return 1;
}
if (!image.Save(argv[2],typeout)){
fprintf(stderr, "%s\n", image.GetLastError());
fprintf(stderr, "error saving %s\n", argv[2]);
return 1;
}
printf("Done!\n");
return 0;
}
BOOL UIIMEdit::_SaveFile(IN HBITMAP hbitmap, OUT CString& strFilePath)
{
SYSTEMTIME st = { 0 };
GetLocalTime(&st);
CString strTime;
strTime.Format(_T("%d-%02d-%02d-%02d%02d%02d-%03d"), st.wYear,
st.wMonth,
st.wDay,
st.wHour,
st.wMinute,
st.wSecond,
st.wMilliseconds);
util::createAllDirectories(module::getMiscModule()->getUserTempDir());
CString csDstFileName = module::getMiscModule()->getUserTempDir() + strTime;
CString csExtName = _T(".jpg");
CxImage cximage;
cximage.CreateFromHBITMAP(hbitmap);
if (cximage.Save(csDstFileName + csExtName, CXIMAGE_FORMAT_JPG))
{
strFilePath = csDstFileName + csExtName;
return TRUE;
}
return FALSE;
}
BOOL CSonicImage::Rotate(int nAngle, POINT * pScout /* = NULL */)
{
if(m_Dib.IsValid() == FALSE)
{
return FALSE;
}
nAngle = abs(nAngle) % 360;
int nBitX = nAngle <= 180 ? 1 : 0;
int nBitY = nAngle > 90 && nAngle <= 270 ? 1 : 0;
int nSrcW = m_nWidth;
int nSrcH = m_nHeight;
const int nBytePixel = 4;
BYTE * pSrc = m_Dib.GetBits();
int nNewX = (nSrcW - nBitX) >> 1;
int nNewY = (nSrcH - nBitY) >> 1;
double m1 = -nSrcW / 2.0f;
double m2 = nSrcW / 2.0f;
double n1 = nSrcH / 2.0f;
double n2 = -nSrcH / 2.0f;
POINT pt1 = {(int)(m1 * COS(nAngle) + n1 * SIN(nAngle)) >> 10, (int)(-m1 * SIN(nAngle) + n1 * COS(nAngle)) >> 10};
POINT pt2 = {(int)(m2 * COS(nAngle) + n1 * SIN(nAngle)) >> 10, (int)(-m2 * SIN(nAngle) + n1 * COS(nAngle)) >> 10};
POINT pt3 = {(int)(m2 * COS(nAngle) + n2 * SIN(nAngle)) >> 10, (int)(-m2 * SIN(nAngle) + n2 * COS(nAngle)) >> 10};
POINT pt4 = {(int)(m1 * COS(nAngle) + n2 * SIN(nAngle)) >> 10, (int)(-m1 * SIN(nAngle) + n2 * COS(nAngle)) >> 10};
int i, j, x1, y1, x11, y11;
i = abs(pt3.x - pt1.x);
j = abs(pt4.x - pt2.x);
int nDestW = max(i, j);
i = abs(pt3.y - pt1.y);
j = abs(pt4.y - pt2.y);
int nDestH = max(i, j);
m_nWidth = nDestW;
m_nHeight = nDestH;
HBITMAP hBmp = NULL;
m_Dib.Resize(m_nWidth, m_nHeight, &hBmp);
BYTE * pDest = m_Dib.GetBits();
int temp;
int nOriginX = nDestW >> 1;
int nOriginY = nDestH >> 1;
for(i = 0; i < nDestH; i++)
{
for(j = 0; j < nDestW; j++)
{
x1 = j - nOriginX;
y1 = nOriginY - i;
temp = (x1 * COS(nAngle) + y1 * SIN(nAngle)) >> 10;
x11 = temp + nNewX;
temp = (-x1 * SIN(nAngle) + y1 * COS(nAngle)) >> 10;
y11 = nNewY - temp;
if(x11 >= 0 && x11 < nSrcW && y11 >= 0 && y11 < nSrcH)
{
COLORREF color = *(DWORD *)(pSrc + (nSrcW * nBytePixel * y11) + x11 * nBytePixel);
*(DWORD *)(pDest + i * nBytePixel * nDestW + j * nBytePixel) = color;
}
}
}
if(hBmp)
{
DeleteObject(hBmp);
}
if(pScout)
{
x1 = pScout->x - nNewX;
y1 = nNewY - pScout->y;
nAngle = 360 - nAngle;
x11 = (x1 * COS(nAngle) + y1 * SIN(nAngle)) >> 10;
x11 = x11 + nOriginX;
y11 = (-x1 * SIN(nAngle) + y1 * COS(nAngle)) >> 10;
y11 = nOriginY - y11;
pScout->x = x11;
pScout->y = y11;
}
EnableAlphaChannel(FALSE);
return TRUE;
}
BOOL CSonicImage::SaveAsFile(LPCTSTR lpszFileName, enImageType imgType, int nQuality /* = 0 */)
{
if(m_Dib.IsValid() == FALSE)
{
return FALSE;
}
CxImage img;
if(img.CreateFromHBITMAP(m_Dib.GetHBitmap()) == FALSE)
{
return FALSE;
}
if(IsAlphaChannelValid()
&& (imgType == IMAGE_TYPE_BMP
|| imgType == IMAGE_TYPE_PNG
|| imgType == IMAGE_TYPE_TGA
|| imgType == IMAGE_TYPE_ICO))
{
img.AlphaCreate();
for(int i = 0; i < m_nHeight; i++)
{
for(int j = 0; j < m_nWidth; j++)
{
BYTE bAlpha = *(m_Dib.GetBits() + i * m_nWidth * 4 + j * 4 + 3);
img.AlphaSet(j, i, bAlpha);
}
}
}
DWORD dwType = 0;
switch (imgType)
{
case IMAGE_TYPE_BMP:
dwType = CXIMAGE_FORMAT_BMP;
break;
case IMAGE_TYPE_JPEG:
dwType = CXIMAGE_FORMAT_JPG;
nQuality = nQuality ? nQuality : DEFAULT_JPEG_QULITY;
img.SetJpegQuality(nQuality);
break;
case IMAGE_TYPE_TGA:
dwType = CXIMAGE_FORMAT_TGA;
break;
case IMAGE_TYPE_PNG:
dwType = CXIMAGE_FORMAT_PNG;
break;
case IMAGE_TYPE_ICO:
dwType = CXIMAGE_FORMAT_ICO;
break;
}
CString strPath = lpszFileName;
int nFind1 = strPath.ReverseFind(_T('\\'));
int nFind2 = strPath.ReverseFind(_T('/'));
int nFind = max(nFind1, nFind2);
if(nFind != -1)
{
strPath = strPath.Left(nFind);
if(PathFileExists(strPath) == FALSE)
{
SHCreateDirectoryEx(NULL, strPath, NULL);
}
}
#ifdef _UNICODE
USES_CONVERSION;
if(img.Save(W2A(lpszFileName), dwType) == FALSE)
{
return FALSE;
}
#else
if(img.Save(lpszFileName, dwType) == FALSE)
{
return FALSE;
}
#endif
img.Clear();
return TRUE;
}
BOOL CSonicImage::Gray()
{
if(m_Dib.IsValid() == FALSE)
{
return FALSE;
}
int nSrcSize = m_nWidth * m_nHeight * 4;
CSSE::DoGray(m_Dib.GetBits(), nSrcSize);
return TRUE;
}
HRGN CSonicImage::CreateRgn(DWORD dwColorKey /* = DEFAULT_COLOR_KEY */, int x /* = 0 */, int y /* = 0 */, RECT * pRtSrc /* = NULL */, BOOL bReverse /* = FALSE */)
{
if(m_Dib.IsValid() == FALSE)
{
return FALSE;
}
int nBytePixel = 4;
BYTE * pSrc = m_Dib.GetBits();
CRect rtSrc(0, 0, m_nWidth, m_nHeight);
if(pRtSrc)
{
rtSrc = *pRtSrc;
}
int nLeftx = -1;
HRGN hAll = CreateRectRgn(x, y, x + rtSrc.Width(), y + rtSrc.Height());
for(int i = rtSrc.top; i < rtSrc.bottom; i++)
{
for(int j = rtSrc.left; j < rtSrc.right; j++)
{
DWORD dwColor = *(DWORD *)(pSrc + (i * m_nWidth * nBytePixel) + j * nBytePixel);
if(!bReverse)
{
if(EQUAL_24COLOR(dwColor, dwColorKey) && nLeftx < 0)
{
nLeftx = j;
}
if(nLeftx >= 0 && (!EQUAL_24COLOR(dwColor, dwColorKey) || j + 1 == rtSrc.right))
{
if(EQUAL_24COLOR(dwColor, dwColorKey) && j + 1 == rtSrc.right)j++;
HRGN hTemp = CreateRectRgn(x + nLeftx - rtSrc.left, y + i - rtSrc.top, x + j - rtSrc.left, y + i + 1 - rtSrc.top);
CombineRgn(hAll, hAll, hTemp, RGN_XOR);
DeleteObject(hTemp);
nLeftx = -1;
}
}
else
{
if(!EQUAL_24COLOR(dwColor, dwColorKey) && nLeftx < 0)
{
nLeftx = j;
}
if(nLeftx >= 0 && (EQUAL_24COLOR(dwColor, dwColorKey) || j + 1 == rtSrc.right))
{
if(!EQUAL_24COLOR(dwColor, dwColorKey) && j + 1 == rtSrc.right)j++;
HRGN hTemp = CreateRectRgn(x + nLeftx - rtSrc.left, y + i - rtSrc.top, x + j - rtSrc.left, y + i + 1 - rtSrc.top);
CombineRgn(hAll, hAll, hTemp, RGN_XOR);
DeleteObject(hTemp);
nLeftx = -1;
}
}
}
}
return hAll;
}
BOOL CSonicImage::IsAlphaChannelValid()
{
return m_bAlphaChannel;
}
BOOL CSonicImage::EnableAlphaChannel(BOOL bModifyRgb /* = TRUE */)
{
if(m_bAlphaChannel)
{
return FALSE;
}
if(m_Dib.IsValid() == FALSE)
{
return FALSE;
}
m_bAlphaChannel = TRUE;
if(bModifyRgb)
{
int nSrc = m_nWidth * m_nHeight;
DWORD * pSrc = (DWORD *)m_Dib.GetBits();
for(int i = 0; i < nSrc; i++)
{
CSSE::AdjustAlpha(*pSrc);
pSrc++;
}
}
return TRUE;
}
DWORD CSonicImage::GetPixel(int x, int y)
{
if(m_Dib.IsValid() == FALSE)
{
return 0;
}
if(y < 0 || y >= m_nHeight)
{
return 0;
}
if(x < 0 || x >= m_nWidth)
{
return 0;
}
return *(DWORD *)(m_Dib.GetBits() + (m_nHeight - y - 1) * m_nWidth * 4 + x * 4);
}
BOOL CSonicImage::SetPixel(int x, int y, DWORD dwColor)
{
if(m_Dib.IsValid() == FALSE)
{
return 0;
}
if(IsAlphaChannelValid())
{
CSSE::AdjustAlpha(dwColor);
}
else
{
dwColor |= 0xff000000;
}
if(y < 0 || y >= m_nHeight)
{
return 0;
}
if(x < 0 || x >= m_nWidth)
{
return 0;
}
*(DWORD *)(m_Dib.GetBits() + (m_nHeight - y - 1) * m_nWidth * 4 + x * 4) = dwColor;
return TRUE;
}
BYTE * CSonicImage::GetBits()
{
return m_Dib.GetBits();
}
BOOL CSonicImage::Init()
{
double radiant;
for(int i = 0; i < 361; i++)
{
radiant = (i * PAI) / 180;
double temp = sin(radiant) * 1024;
Trigonometry[i][0] = ROUND(temp);
temp = cos(radiant) * 1024;
Trigonometry[i][1] = ROUND(temp);
}
return TRUE;
}
BOOL CSonicImage::SetBitsToDevice(HDC hdc, int x /* = 0 */, int y /* = 0 */)
{
return SetDIBitsToDevice(hdc, x, y, m_nWidth, m_nHeight, 0, 0, 0, m_nHeight, m_Dib.GetBits(), m_Dib.GetBitmapInfo(), DIB_RGB_COLORS) != 0;
}
RECT CSonicImage::CalculateRectByDrawParam(int x, int y, const DRAW_PARAM * pDp, RECT * pSrc /* = NULL */)
{
CRect rtSrc, rtDest;
int cx = m_nWidth;
int cy = m_nHeight;
if(pDp && (pDp->dwMask & DP_SRC_CLIP))
{
rtSrc = pDp->rtSrc;
}
else
{
rtSrc.SetRect(0, 0, m_nWidth, m_nHeight);
}
cx = rtSrc.Width();
cy = rtSrc.Height();
if(pDp)
{
if(pDp->dwMask & DP_SCALE)
{
cx = (int)(rtSrc.Width() * pDp->fScaleX);
cy = (int)(rtSrc.Height() * pDp->fScaleY);
}
if(pDp->dwMask & DP_DEST_LIMIT)
{
cx = pDp->cx;
cy = pDp->cy;
}
if(pDp->dwMask & DP_TILE)
{
cx = pDp->nTileLength;
}
if(pDp->dwMask & DP_VER_TILE)
{
cy = pDp->nTileLength;
}
}
rtDest.SetRect(x, y, x + cx, y + cy);
if(pSrc)
{
*pSrc = rtSrc;
}
return rtDest;
}
BOOL CSonicImage::SetColorKey(DWORD dwColor)
{
if(IsAlphaChannelValid())
{
return FALSE;
}
CSSE::SetColorKey(m_Dib.GetBits(), m_Dib.GetSize(), dwColor);
EnableAlphaChannel(FALSE);
return TRUE;
}
BOOL CSonicImage::Load(HDC hdc, int x, int y, int cx, int cy, BOOL bAlphaChannel /* = FALSE */)
{
Clear();
BITMAP bmp;
GetObject((HBITMAP)GetCurrentObject(hdc, OBJ_BITMAP), sizeof(bmp), &bmp);
if(bmp.bmType != 0 || bmp.bmPlanes != 1)
{
return FALSE;
}
if(bmp.bmBitsPixel != 32)
{
return FALSE;
}
if(PrepareMemDC(cx, cy) == FALSE)
{
return FALSE;
}
BitBlt(m_Dib.GetSafeHdc(), 0, 0, cx, cy, hdc, x, y, SRCCOPY);
if(bAlphaChannel)
{
EnableAlphaChannel(FALSE);
CSSE::DoOr(0xff000000, m_Dib.GetBits(), m_Dib.GetSize());
}
return TRUE;
}
BOOL CSonicImage::Create(int cx, int cy, DWORD dwColor /* = 0 */, BOOL bWithAlpha /* = FALSE */)
{
if(PrepareMemDC(cx, cy) == FALSE)
{
return FALSE;
}
if(bWithAlpha)
{
CSSE::AdjustAlpha(dwColor);
EnableAlphaChannel(FALSE);
}
if(dwColor)
{
Flush(dwColor);
}
return TRUE;
}
BOOL CSonicImage::Flush(DWORD dwColor)
{
if(m_Dib.IsValid() == FALSE)
{
return FALSE;
}
CSSE::MemSetDWord(m_Dib.GetBits(), dwColor, m_Dib.GetSize());
return TRUE;
}
BOOL CSonicImage::SetHsl(int h /* = -1 */, int s /* = -1 */, int l /* = -1 */)
{
if(IsValid() == FALSE)
{
return FALSE;
}
CSSE::SetHSL(m_Dib.GetBits(), m_Dib.GetSize(), h, s, l);
return TRUE;
}
BOOL CSonicImage::MirrorX()
{
if(IsValid() == FALSE)
{
return FALSE;
}
CSSE::MirrorX(m_Dib.GetBits(), m_nWidth, m_nHeight);
return TRUE;
}
BOOL CSonicImage::MirrorY()
{
if(IsValid() == FALSE)
{
return FALSE;
}
CSSE::MirrorY(m_Dib.GetBits(), m_nWidth, m_nHeight);
return TRUE;
}
BOOL CSonicImage::Stretch(int cx, int cy)
{
if(IsValid() == FALSE)
{
return FALSE;
}
if(cx == m_nWidth && cy == m_nHeight)
{
return TRUE;
}
CSonicImage * pImg = (CSonicImage *)g_UI.CreateImage();
pImg->CloneFrom(this);
PrepareMemDC(cx, cy);
CSSE::Stretch(pImg->m_Dib.GetBits(), pImg->GetWidth(), pImg->GetHeight(), m_Dib.GetBits(), cx, cy);
g_UI.DestroyObject(pImg);
return TRUE;
}
BOOL CSonicImage::Extend(int cx /* = 0 */, int cy /* = 0 */)
{
if(IsValid() == FALSE)
{
return FALSE;
}
cx = (cx == 0 ? m_nWidth : cx);
cy = (cy == 0 ? m_nHeight : cy);
CSonicImage * pImg = (CSonicImage *)g_UI.CreateImage();
pImg->CloneFrom(this);
PrepareMemDC(cx, cy);
for(int i = 0; i < cy; i += pImg->GetHeight())
{
for(int j = 0; j < cx; j += pImg->GetWidth())
{
pImg->SetBitsToDevice(m_Dib.GetSafeHdc(), j, i);
}
}
g_UI.DestroyObject(pImg);
return TRUE;
}
HDC CSonicImage::GetDC()
{
if(IsValid() == FALSE)
{
return NULL;
}
return m_Dib.GetSafeHdc();
}
BOOL CSonicImage::DestroyAlphaChannel()
{
if(IsValid() == FALSE)
{
return FALSE;
}
CSSE::DoAnd(0xffffff, (char *)m_Dib.GetBits(), m_Dib.GetSize());
return TRUE;
}
BOOL CSonicImage::SetAlphaChannel(BYTE bAlpha)
{
if(IsValid() == FALSE)
{
return FALSE;
}
CSSE::DoOr((bAlpha << 24), (char *)m_Dib.GetBits(), m_Dib.GetSize());
EnableAlphaChannel(FALSE);
return TRUE;
}
BOOL CSonicImage::Blur(int nType /* = 0 */)
{
if(IsValid() == FALSE)
{
return FALSE;
}
char * pTemp = new char[m_Dib.GetSize()];
CSSE::MemCopy(pTemp, m_Dib.GetBits(), m_Dib.GetSize());
int i, j;
DWORD * pSrc = (DWORD *)m_Dib.GetBits();
DWORD * pDest = (DWORD *)pTemp;
for(i = 1; i < m_Dib.GetHeight() - 1; i++)
{
for(j = 1; j < m_Dib.GetWidth() - 1; j++)
{
DWORD dw1 = *(pDest + i * m_Dib.GetWidth() + j);
DWORD dw2 = *(pDest + i * m_Dib.GetWidth() + j - 1);
DWORD dw3 = *(pDest + i * m_Dib.GetWidth() + j + 1);
DWORD dw4 = *(pDest + (i - 1) * m_Dib.GetWidth() + j);
DWORD dw5 = *(pDest + (i + 1) * m_Dib.GetWidth() + j);
DWORD dw6 = *(pDest + (i - 1) * m_Dib.GetWidth() + j - 1);
DWORD dw7 = *(pDest + (i - 1) * m_Dib.GetWidth() + j + 1);
DWORD dw8 = *(pDest + (i + 1) * m_Dib.GetWidth() + j - 1);
DWORD dw9 = *(pDest + (i + 1) * m_Dib.GetWidth() + j + 1);
char r, g, b;
r = g = b = 0;
switch (nType)
{
case 0:
{
// gauss blur
r = ((GetRValue(dw1) << 2) +
((GetRValue(dw2) +
GetRValue(dw3) +
GetRValue(dw4) +
GetRValue(dw5)) << 1) +
GetRValue(dw6) +
GetRValue(dw7) +
GetRValue(dw8) +
GetRValue(dw9)) >> 4;
g = ((GetGValue(dw1) << 2) +
((GetGValue(dw2) +
GetGValue(dw3) +
GetGValue(dw4) +
GetGValue(dw5)) << 1) +
GetGValue(dw6) +
GetGValue(dw7) +
GetGValue(dw8) +
GetGValue(dw9)) >> 4;
b = ((GetBValue(dw1) << 2) +
((GetBValue(dw2) +
GetBValue(dw3) +
GetBValue(dw4) +
GetBValue(dw5)) << 1) +
GetBValue(dw6) +
GetBValue(dw7) +
GetBValue(dw8) +
GetBValue(dw9)) >> 4;
}
break;
case 1:
{
// even blur
r = (GetRValue(dw1) +
GetRValue(dw2) +
GetRValue(dw3) +
GetRValue(dw4) +
GetRValue(dw5) +
GetRValue(dw6) +
GetRValue(dw7) +
GetRValue(dw8) +
GetRValue(dw9)) / 9;
g = (GetGValue(dw1) +
GetGValue(dw2) +
GetGValue(dw3) +
GetGValue(dw4) +
GetGValue(dw5) +
GetGValue(dw6) +
GetGValue(dw7) +
GetGValue(dw8) +
GetGValue(dw9)) / 9;
b = (GetBValue(dw1) +
GetBValue(dw2) +
GetBValue(dw3) +
GetBValue(dw4) +
GetBValue(dw5) +
GetBValue(dw6) +
GetBValue(dw7) +
GetBValue(dw8) +
GetBValue(dw9)) / 9;
}
break;
}
*(pSrc + i * m_Dib.GetWidth() + j) = (0xff000000 | RGB(r, g, b));
}
}
delete []pTemp;
return TRUE;
}
BOOL CTWainHelper::SaveAsPdf(const char* pFileName, std::vector< HANDLE > m_pic_handles)
{
PDF *p;
int image;
const char *imagefile = "/pvf/pic.jpg";
/* This is where font/image/PDF input files live. Adjust as necessary. */
const char *searchpath = "./";
/* create a new PDFlib object */
if ((p = PDF_new()) == (PDF *) 0)
{
printf("Couldn't create PDFlib object (out of memory)!\n");
return FALSE;
}
PDF_TRY(p){
/* This means we must check return values of load_font() etc. */
PDF_set_parameter(p, "errorpolicy", "return");
/* This line is required to avoid problems on Japanese systems */
PDF_set_parameter(p, "hypertextencoding", "host");
if (PDF_begin_document(p, pFileName, 0, "") == -1) {
printf("Error: %s\n", PDF_get_errmsg(p));
return FALSE;
}
PDF_set_parameter(p, "SearchPath", searchpath);
PDF_set_info(p, "Creator", "TWainApp");
PDF_set_info(p, "Author", "Snail");
PDF_set_info(p, "Title", "image sample (C)");
std::vector< HANDLE >::iterator it;
for(it = m_pic_handles.begin(); it != m_pic_handles.end(); it++)
{
//将Handle转换为CxImage对象
HANDLE imageHandle = (HANDLE)(*it);
CxImage cxImage;
cxImage.CreateFromHANDLE(imageHandle);
//cxImage.Save("C:\\bmp.bmp", CXIMAGE_FORMAT_BMP);
cxImage.Save(".\\temp\\temp.jpg", CXIMAGE_FORMAT_JPG);
char* imagedata = NULL;
DWORD size = 0;
CFile file(".\\temp\\temp.jpg", CFile::modeRead);
size = file.GetLength();
imagedata = new char[size];
memset(imagedata, 0, size);
file.Read(imagedata, size);
file.Close();
PDF_create_pvf(p, imagefile, 0, (const char*)imagedata, size, "");
image = PDF_load_image(p, "auto", imagefile, 0, "");
if (image == -1) {
char logInfo[LOGSIZE];
sprintf(logInfo, "Error: 加载PVF图像数据失败！错误号：%d, %s:%d\r\n", PDF_get_errmsg(p), __FILE__, __LINE__);
CTWainHelper::LogMessage(logInfo);
if(imagedata)
delete imagedata;
continue;
}
/* dummy page size, will be adjusted by PDF_fit_image() */
PDF_begin_page_ext(p, 10, 10, "");
PDF_fit_image(p, image, 0.0, 0.0, "adjustpage dpi {300 300}");
PDF_end_page_ext(p, "");
/* Delete the virtual file to free the allocated memory */
PDF_delete_pvf(p, imagefile, 0);
if(imagedata)
delete imagedata;
}
PDF_end_document(p, "");
::DeleteFile(".\\temp\\temp.jpg");
}
PDF_CATCH(p) {
char logInfo[LOGSIZE];
sprintf(logInfo, "EXCEPTION: PDFlib接口调用过程发生异常！错误信息：[%d] %s: %s, %s:%d\r\n",
PDF_get_errmsg(p), PDF_get_apiname(p), PDF_get_errmsg(p), __FILE__, __LINE__);
CTWainHelper::LogMessage(logInfo);
PDF_delete(p);
return FALSE;
}
PDF_delete(p);
return TRUE;
}