Example #1
0
	bool SmtSmfRasLayer::Fetch(eSmtFetchType type)
	{
		if (!IsOpen())
			return false;

		char szImgUrl[MAX_LAYER_FILE_NAME];

		SmtDataSourceInfo info;
		m_pOwnerDs->GetInfo(info);

		sprintf(szImgUrl,"%s",m_szLayerFileName);

		long lCodeType = GetImageTypeByFileExt(m_szLayerFileName);

		CxImage img;

		if (img.Load(szImgUrl,lCodeType))
		{
			BYTE *pImageBuf = NULL;
			long lImageBufSize = 0;
			fRect fLocRect;

			m_pMemLayer->GetRasterRect(fLocRect);
	
			fLocRect.rt.y  = fLocRect.lb.y + fLocRect.Width()*img.GetHeight()/img.GetWidth();

			if (img.Encode(pImageBuf,lImageBufSize,lCodeType))
			{
				return (SMT_ERR_NONE == m_pMemLayer->CreaterRaster((const char *)pImageBuf,lImageBufSize,fLocRect,lCodeType));
			}
		}

		return false;
	}
Example #2
0
bool IGFrame::Update()
{
	if (!UpdateSize (head.biWidth, head.biHeight))
		return false;
	// update selection rect
	RECT rcSel = {0, 0, -1, -1};
	CxImage *pLayer = GetWorkingLayer();
	if (pLayer->SelectionIsValid())
		pLayer->SelectionGetBox (rcSel);
	if (rcSel.right != -1 && rcSel.bottom != -1){
		long nOffsetX, nOffsetY;
		pLayer->GetOffset (&nOffsetX, &nOffsetY);
		rcSel.left += nOffsetX; rcSel.right += nOffsetX;
		rcSel.top -= nOffsetY; rcSel.bottom -= nOffsetY;
	}
	wchar_t twLeft [32], twRight [32], twTop [32], twBottom [32];
	::_itow (rcSel.left, twLeft, 10);
	::_itow (rcSel.right, twRight, 10);
	::_itow (rcSel.top, twTop, 10);
	::_itow (rcSel.bottom, twBottom, 10);		
	wstring wsSelRect (twLeft);
	wsSelRect += L"#"; wsSelRect+= twRight;
	wsSelRect += L"#"; wsSelRect+= twTop;
	wsSelRect += L"#"; wsSelRect+= twBottom;
	SetProperty (IGFRAMEPROPERTY_SELECTIONRECT, wsSelRect);
	// update current history step id
	SetProperty (IGFRAMEPROPERTY_HISTORYSTEP, GetCurrentStepId());
	return true;
}
Example #3
0
int IGIPDraw::GetSecondParam (IGImageProcMessage& message, CxImage& image) const
{	
	IGIPDrawMessage *pIGThreadMessage = dynamic_cast <IGLibrary::IGIPDrawMessage *> (&message);
	if (!pIGThreadMessage)
		return false;
	RECT *prcSubLayer = (RECT*)IGIPFilter::GetSecondParam (message, image);
	if (!prcSubLayer)
		return false;
	int nLayerWidth = image.GetWorkingLayer()->GetWidth();
	int nLayerHeight = image.GetWorkingLayer()->GetHeight();
	RECT rcDraw = IGConvertible::FromListPtsToRECT (pIGThreadMessage->m_lPts, nLayerWidth, nLayerHeight);
	int nTop = rcDraw.top;
	rcDraw.top = nLayerHeight - 1 - rcDraw.bottom;	// convert to Cx Coords
	rcDraw.bottom = nLayerHeight - 1 - nTop;
	// enlarge the region with the brush size + 1 in every direction
	int nOffsetSize = (int)pIGThreadMessage->m_pBrush->GetSize() + 1;
	rcDraw.left = max (0, rcDraw.left - nOffsetSize);
	rcDraw.right = min (nLayerWidth - 1, rcDraw.right + nOffsetSize);
	rcDraw.top = max (0, rcDraw.top - nOffsetSize);
	rcDraw.bottom = min (nLayerHeight - 1, rcDraw.bottom + nOffsetSize);
	if ((prcSubLayer->bottom != -1) && (prcSubLayer->right != -1))
	{
		prcSubLayer->left = max (prcSubLayer->left, rcDraw.left);
		prcSubLayer->right = min (prcSubLayer->right, rcDraw.right);
		prcSubLayer->top = max (prcSubLayer->top, rcDraw.top);
		prcSubLayer->bottom = min (prcSubLayer->bottom, rcDraw.bottom);
	}
	else
	{
		*prcSubLayer = rcDraw;
	}
	return (int)prcSubLayer;
}
Example #4
0
bool CDemoView::SetImageRectSelection(CDemoDoc *pDoc,CRect *rect)
{
	if (pDoc==0)
		return false;

	CxImage* ima = pDoc->GetImage();

	if (ima==0)
		return false;

	long x,y;
	RECT rect_img;
	x = rect_img.left = rect->left;
	y = rect_img.top = rect->top;
	GetImageXY(pDoc, ima, &x,&y);
	rect_img.top = ima->GetHeight() - 1 - y;
	rect_img.left = x;

	x = rect_img.right = rect->right;
	y = rect_img.bottom = rect->bottom;
	GetImageXY(pDoc, ima, &x,&y);
	rect_img.bottom = ima->GetHeight() - 1 - y;
	rect_img.right = x;

	ima->SelectionClear();
	ima->SelectionAddRect(rect_img);

	return true;
}
Example #5
0
HRESULT IGFrame::Resample (long newx, long newy, IGFRAMEPROPERTY_STRETCHING_ENUM eStretchMode)
{
	// Request thread access
	if (!RequestAccess ())
		return E_ACCESSDENIED;
	HRESULT hRes = E_NOTIMPL;
	CxImage *pCurrentLayer = GetWorkingLayer();
	if (!pCurrentLayer)
		return false;
	pCurrentLayer->SelectionDelete();
	switch (eStretchMode)
	{
	case IGFRAMEPROPERTY_STRETCHING_NO:
		hRes = resampleNoStretch (newx, newy);
		break;
	case IGFRAMEPROPERTY_STRETCHING_BICUBIC:
		hRes = resampleBicubic (newx, newy);
		break;
	case IGFRAMEPROPERTY_STRETCHING_FAST:
		hRes = resampleFast (newx, newy);	
		break;
	}
	if (SUCCEEDED (hRes))
		SetSize (newx, newy);
	return hRes;
}
Example #6
0
void DlgDataExt::UpdatePreview()
{

	if (m_image){
		CxImage tmp;
		tmp.Copy(*m_image,true,false,false);

		if (m_chk_preview.GetCheck()){
			UpdateData(1);
			if (m_btn_graylevel.GetCheck()){
				tmp.Threshold(m_thresh);
			} else {
				tmp.SelectionAddColor(tmp.RGBtoRGBQUAD(m_color));
				tmp.SelectionSplit(&tmp);
				tmp.Negative();
			}
		}

		tmp.IncreaseBpp(24);
		tmp.Resample(150,90,0);

		if (m_bitmap) DeleteObject(m_bitmap);
		m_bitmap = tmp.MakeBitmap(m_picture.GetDC()->m_hDC);
		m_picture.SetBitmap(m_bitmap);
	}

}
Example #7
0
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;
}
Example #8
0
bool CImageSelect::SetImageRectSelection(CRect *rect)
{
    CxImage* ima = &image;

    if (ima==0)
        return false;

    long x,y;
    RECT rect_img;
    x = rect_img.left = rect->left-(500-(int)(image.GetWidth()*ZoomFactor))/2;
    y = rect_img.top = rect->top-(300-(int)(image.GetHeight()*ZoomFactor))/2;
    GetImageXY(ima, &x,&y);
    rect_img.top =  y;
    rect_img.left = x;

    x = rect_img.right = rect->right-(500-(int)(image.GetWidth()*ZoomFactor))/2;
    y = rect_img.bottom = rect->bottom-(300-(int)(image.GetHeight()*ZoomFactor))/2;
    GetImageXY(ima, &x,&y);
    rect_img.bottom = y;
    rect_img.right = x;

    ima->SelectionClear();
    ima->SelectionAddRect(rect_img);
    ima->Crop(rect_img,&NewImage);
    return true;
}
bool IGFrameManager::Cut(LPCWSTR pcwGuid)
{
	IGSmartPtr <IGFrame> spFrame;
	if (!GetFrame(pcwGuid, spFrame))
		return false;
	CxImage *pCxLayer = spFrame->GetWorkingLayer();
	if (!pCxLayer)
		return false;
	RECT rcSel;
	if (pCxLayer->SelectionIsValid())
		pCxLayer->SelectionGetBox (rcSel);
	else{
		rcSel.bottom = 0;
		rcSel.left = 0;
		rcSel.top = pCxLayer->GetHeight();
		rcSel.right = pCxLayer->GetWidth();
	}
	m_spClipboardLayer = new IGLayer(NULL);
	m_spClipboardLayer->Create (rcSel.right - rcSel.left, rcSel.top - rcSel.bottom, 24);
	m_spClipboardLayer->AlphaCreate();
	pCxLayer->AlphaCreate();
	RGBQUAD qGray; qGray.rgbBlue = CXIMAGE_GRAY; qGray.rgbGreen = CXIMAGE_GRAY; qGray.rgbRed = CXIMAGE_GRAY;
	for(long y=rcSel.bottom; y<rcSel.top; y++){
		for(long x=rcSel.left; x<rcSel.right; x++){
			if (pCxLayer->BlindSelectionIsInside(x,y)){
				m_spClipboardLayer->BlindSetPixelColor(x - rcSel.left, y - rcSel.bottom, pCxLayer->BlindGetPixelColor(x,y));
				pCxLayer->BlindSetPixelColor(x, y, qGray);
				pCxLayer->AlphaSet(x, y, 0);
			}
			else
				m_spClipboardLayer->AlphaSet (x - rcSel.left, y - rcSel.bottom, 0);
		}
	}
	return true;
}
Example #10
0
int IGIPFilter::GetFirstParam (IGImageProcMessage& message, CxImage& image) const
{
	IGIPFilterMessage *pIGThreadMessage = dynamic_cast <IGLibrary::IGIPFilterMessage *> (&message);
	if (!pIGThreadMessage)
		return false;
	return (int)image.GetLayerPos (image.GetWorkingLayer());
}
Example #11
0
//鼠标在窗口上移动时需要进行的更新
void CEmotionButton::UpdateSelectedFace(int curPage, int curSel, int curFrame, int pvstatus)
{
	HGDIOBJ hOldBrush = NULL, hOldPen = NULL, hTempPen, hTempBrush;
	HPEN hPen1 = NULL;
	HPEN hPen2 = NULL;
	LPRECT lpRect = NULL;
	RECT rc;
	int index;

	//贴背景
	BitBlt(m_hMemDC, 0, 0, QQFACEDLG_WIDTH, QQFACEDLG_HEIGHT, m_hMemDCBkGnd, 0, 0, SRCCOPY);

	//绘制蓝色选中框
	if(curSel >= 0)
	{
		hPen1 = CreatePen(PS_SOLID, 1, RGB(0, 0, 255));
		hTempPen = SelectObject(m_hMemDC, hPen1);
		hTempBrush = SelectObject(m_hMemDC, GetStockObject(NULL_BRUSH));
		GetBlueRect(curSel, &rc);		
		Rectangle(m_hMemDC, rc.left, rc.top, rc.right, rc.bottom);

		if(hOldPen == NULL) hOldPen = hTempPen;
		if(hOldBrush == NULL) hOldBrush = hTempBrush;
	}

	//绘制左侧或者右侧的预览图
	if(pvstatus == _PVStatus::Left) lpRect = &rcLeft;
	else if(pvstatus == _PVStatus::Right) lpRect = &rcRight;

	if(lpRect != NULL)
	{
		index = curPage * CELLCOUNT_PAGE + curSel; //从页内相对索引计算出绝对索引。		
		hPen2 = CreatePen(PS_SOLID, 1, RGB(0, 138, 255)); //淡蓝色画笔		
		hTempPen = SelectObject(m_hMemDC, hPen2);
		hTempBrush = SelectObject(m_hMemDC, GetStockObject(WHITE_BRUSH)); //白色画刷
		Rectangle(m_hMemDC, lpRect->left, lpRect->top, lpRect->right, lpRect->bottom);
		//居中绘制
		int left = (lpRect->left + lpRect->right - m_CxImages[index].GetWidth())/2;
		int top = (lpRect->top + lpRect->bottom - m_CxImages[index].GetHeight())/2;

		//设置帧
		if(curFrame < m_CxImages[index].GetNumFrames())
		{
			CxImage* pFrame = m_CxImages[index].GetFrame(curFrame);
			if(pFrame) pFrame->Draw(m_hMemDC, left, top);
			//m_CxImages[index].Draw(m_hMemDC, left, top);
		}
		if(hOldBrush == NULL) hOldBrush = hTempBrush;
		if(hOldPen == NULL) hOldPen = hTempPen;
	}
	
	//恢复画刷,画笔
	if(hOldBrush != NULL) SelectObject(m_hMemDC, hOldBrush);
	if(hOldPen != NULL)	SelectObject(m_hMemDC, hOldPen);

	if(hPen1 != NULL) DeleteObject(hPen1);
	if(hPen2 != NULL) DeleteObject(hPen2);
}
Example #12
0
  __declspec(dllexport) bool LoadImage(const char *file, unsigned int maxwidth, unsigned int maxheight, ImageInfo *info)
  {
    if (!file || !info) return false;

	if (IsDir(file))
		return false;

	  // load the image
    DWORD dwImageType = GetImageType(file);
    CxImage *image = new CxImage(dwImageType);
    if (!image) return false;

    int actualwidth = maxwidth;
    int actualheight = maxheight;
    try
    {
      if (!image->Load(file, dwImageType, actualwidth, actualheight) || !image->IsValid())
      {
#if !defined(_LINUX) && !defined(__APPLE__)
	    int nErr = GetLastError();
#else
	    int nErr = errno;
#endif
        printf("PICTURE::LoadImage: Unable to open image: %s Error:%s (%d)\n", file, image->GetLastError(),nErr);
        delete image;
        return false;
      }
    }
    catch (...)
    {
      printf("PICTURE::LoadImage: Unable to open image: %s\n", file);
      delete image;
      return false;
    }
    // ok, now resample the image down if necessary
    if (ResampleKeepAspect(*image, maxwidth, maxheight) < 0)
    {
      printf("PICTURE::LoadImage: Unable to resample picture: %s\n", file);
      delete image;
      return false;
    }

    // make sure our image is 24bit minimum
    image->IncreaseBpp(24);

    // fill in our struct
    info->width = image->GetWidth();
    info->height = image->GetHeight();
    info->originalwidth = actualwidth;
    info->originalheight = actualheight;
    memcpy(&info->exifInfo, image->GetExifInfo(), sizeof(EXIFINFO));

    // create our texture
    info->context = image;
    info->texture = image->GetBits();
    info->alpha = image->AlphaGetBits();
    return (info->texture != NULL);
  };
Example #13
0
int ResampleKeepAspectArea(CxImage &image, unsigned int area)
{
  float fAspect = ((float)image.GetWidth()) / ((float)image.GetHeight());
  unsigned int width = (unsigned int)sqrt(area * fAspect);
  unsigned int height = (unsigned int)sqrt(area / fAspect);
  if (width > MAX_WIDTH) width = MAX_WIDTH;
  if (height > MAX_HEIGHT) height = MAX_HEIGHT;
  return ResampleKeepAspect(image, width, height, true);
}
CxImage* CFeedIcoItemListCtrl::GetPng(LPCTSTR lpszPngResource)
{
	if (NULL == lpszPngResource)
		return NULL;

	CxImage* image = new CxImage(CXIMAGE_FORMAT_PNG);
	image->LoadResource(FindResource(NULL, lpszPngResource, _T("PNG")), CXIMAGE_FORMAT_PNG);
	return image;
}
Example #15
0
CxImage* loadImage(const char* imagePath, DWORD imageType)
{
	CxImage* image = new CxImage;
	if (!image->Load(imagePath, imageType))
	{
		printf("get image error!\n");
		return NULL; 
	}
	return image;
}
Example #16
0
CxImage* IGFrame::GetSelectionLayer()
{
	for (int nIdxItem = 0; nIdxItem < GetNbLayers(); nIdxItem++)
	{
		CxImage *pLayer = GetLayer(nIdxItem);
		if (pLayer->SelectionIsValid())
			return pLayer;
	}
	return NULL;
}
Example #17
0
HBITMAP CSkin::LoadImage(const char *filename)
{
  CxImage image;
  image.Load(filename);
  if(!image.IsValid()) {
    return NULL;
  }
  
  return image.MakeBitmap(NULL);
}
Example #18
0
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;
}
Example #19
0
void CCaptchaGenerator::ReGenerateCaptcha(uint32 nLetterCount)
{
	Clear();
	CxImage* pimgResult = new CxImage(nLetterCount > 1 ? (LETTERSIZE + (nLetterCount-1)*CROWDEDSIZE) : LETTERSIZE, 32, 1, CXIMAGE_FORMAT_BMP);
	pimgResult->SetPaletteColor(0, 255, 255, 255);
	pimgResult->SetPaletteColor(1, 0, 0, 0, 0);
	pimgResult->Clear();
	CxImage imgBlank(LETTERSIZE, LETTERSIZE, 1, CXIMAGE_FORMAT_BMP);	
	imgBlank.SetPaletteColor(0, 255, 255, 255);
	imgBlank.SetPaletteColor(1, 0, 0, 0, 0);
	imgBlank.Clear();
	for (uint32 i = 0; i < nLetterCount; i++) {
		CxImage imgLetter(imgBlank);
		
		CString strLetter(schCaptchaContent[GetRandomUInt16() % ARRSIZE(schCaptchaContent)]);
		m_strCaptchaText += strLetter;
		
		uint16 nRandomSize = GetRandomUInt16() % 10;
		uint16 nRandomOffset = 3 + GetRandomUInt16() % 11;
		imgLetter.DrawString(NULL, nRandomOffset, 32, strLetter, imgLetter.RGBtoRGBQUAD(RGB(0, 0, 0)), _T("Arial"), 40 - nRandomSize, 1000);
		//imgLetter.DrawTextA(NULL, nRandomOffset, 32, strLetter, imgLetter.RGBtoRGBQUAD(RGB(0, 0, 0)), "Arial", 40 - nRandomSize, 1000);
		float fRotate = (float)(35 - (GetRandomUInt16() % 70));
		imgLetter.Rotate2(fRotate, NULL, CxImage::IM_BILINEAR,  CxImage::OM_BACKGROUND, 0, false, true);
		uint32 nOffset = i * CROWDEDSIZE; 
		ASSERT( imgLetter.GetHeight() == pimgResult->GetHeight() && pimgResult->GetWidth() >= nOffset + imgLetter.GetWidth() );
		for (uint32 j = 0; j < imgLetter.GetHeight(); j++)
			for (uint32 k = 0; k < imgLetter.GetWidth(); k++)
				if (pimgResult->GetPixelIndex(nOffset + k, j) != 1)
					pimgResult->SetPixelIndex(nOffset + k, j, imgLetter.GetPixelIndex(k, j));
	}
	pimgResult->Jitter(1);
	//pimgResult->Save("D:\\CaptchaTest.bmp", CXIMAGE_FORMAT_BMP);
	m_pimgCaptcha = pimgResult;
}
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);
			}
		}
	}

}
Example #21
0
bool IGFrame::PickColor (POINT ptCoords, RGBQUAD& rgbColor)
{
	// Request thread access
	if (!RequestAccess ())
		return false;
	CxImage *pCurrentLayer = GetWorkingLayer();
	if (!pCurrentLayer)
		return false;
	// convert IG coordinates to Cx coordinates
	IGConvertible::FromIGtoCxCoords (ptCoords, pCurrentLayer->GetHeight());
	rgbColor = pCurrentLayer->GetPixelColor (ptCoords.x, ptCoords.y);
	return true;
}
Example #22
0
int IGIPFilter::GetSecondParam (IGImageProcMessage& message, CxImage& image) const
{
	IGIPFilterMessage *pIGThreadMessage = dynamic_cast <IGLibrary::IGIPFilterMessage *> (&message);
	if (!pIGThreadMessage)
		return false;	
	ZeroMemory (&pIGThreadMessage->m_rcSubLayer, sizeof (RECT));
	if (image.GetWorkingLayer())
		image.GetWorkingLayer()->SelectionGetBox (pIGThreadMessage->m_rcSubLayer);
	if ((pIGThreadMessage->m_rcSubLayer.right == 0) || (pIGThreadMessage->m_rcSubLayer.bottom == 0))
	{
		pIGThreadMessage->m_rcSubLayer.right = -1;
		pIGThreadMessage->m_rcSubLayer.bottom = -1;
	}
	return (int)&pIGThreadMessage->m_rcSubLayer;
}
Example #23
0
		virtual void LoadGifImage()
		{
			CDuiString sImag = m_pOwer->GetBkImage();
			m_bLoadImg = true;
			m_pGifImage	=	CRenderEngine::LoadGifImageX(STRINGorID(sImag),0, 0);
			if ( NULL == m_pGifImage ) return;
			m_nFrameCount	=	m_pGifImage->GetNumFrames();
			m_nFramePosition = 0;
			m_nDelay = m_pGifImage->GetFrameDelay();
			if (m_nDelay <= 0 ) 
				m_nDelay = 100;
			if(!m_bAutoStart)
				m_bRealStop = true;
			if(m_bAutoStart && m_pOwer->IsVisible())
				StartAnim();
		}
Example #24
0
bool IGIPIndex::OnImageProcessing (CxImage& image, IGImageProcMessage& message)
{
	IGIPIndexMessage *pIGThreadMessage = dynamic_cast <IGIPIndexMessage *> (&message);
	_ASSERTE (pIGThreadMessage && L"Wrong IGThread message, image processing aborted");
	if (!pIGThreadMessage || !m_pFrame)
		return false;
	IGLayer *pLayer = m_pFrame->GetLayer (m_pFrame->GetLayerPos (image.GetWorkingLayer()));
	if (!pLayer)
		return false;

	switch (pIGThreadMessage->m_eFilterType)
	{
	case IGIPINDEX_LPE:
		{
			int nNbMarkers = 0;
			if (pIGThreadMessage->m_pMarkerBackground && pIGThreadMessage->m_pMarkerObject) {
				IGMarker* tM [2];
				tM[0] = pIGThreadMessage->m_pMarkerBackground;
				tM[1] = pIGThreadMessage->m_pMarkerObject;
				nNbMarkers = 2;
				return pLayer->IndexLPE (tM, nNbMarkers);
			}
			else
				return pLayer->IndexLPE (NULL, nNbMarkers);
		}
	case IGIPINDEX_FACE:
		return pLayer->IndexFaces();
	case IGIPINDEX_IRIS:
		return pLayer->IndexIris();
	}

	return false;
}
Example #25
0
void CxImage::CreateFromHICON(HICON hico)
{
	Destroy();
	if (hico) { 
		ICONINFO iinfo;
		GetIconInfo(hico,&iinfo);
		CreateFromHBITMAP(iinfo.hbmColor);
#if CXIMAGE_SUPPORT_ALPHA
		CxImage mask;
		mask.CreateFromHBITMAP(iinfo.hbmMask);
		mask.GrayScale();
		mask.Negative();
		AlphaSet(mask);
#endif
    }
}
Example #26
0
/**
 * Creates the selection channel from a gray scale image.
 * black = unselected
 */
bool CxImage::SelectionSet(CxImage &from)
{
	if (!from.IsGrayScale() || head.biWidth != from.head.biWidth || head.biHeight != from.head.biHeight){
		strcpy(info.szLastError,"CxImage::SelectionSet: wrong width or height, or image is not gray scale");
		return false;
	}

	if (pSelection==NULL) pSelection = (uint8_t*)malloc(head.biWidth * head.biHeight);

	uint8_t* src = from.info.pImage;
	uint8_t* dst = pSelection;
	if (src==NULL || dst==NULL){
		strcpy(info.szLastError,"CxImage::SelectionSet: null pointer");
		return false;
	}

	for (int32_t y=0; y<head.biHeight; y++){
		memcpy(dst,src,head.biWidth);
		dst += head.biWidth;
		src += from.info.dwEffWidth;
	}

	SelectionRebuildBox();

	return true;
}
Example #27
0
void CMainFrame::SetImage(HANDLE hBitmap,TW_IMAGEINFO& /*info*/)
{ //<<<TWAIN>>>
	CDemoDoc *NewDoc=(CDemoDoc*)((CDemoApp*)AfxGetApp())->demoTemplate->OpenDocumentFile(NULL); 
	if (NewDoc)	{
		if (hBitmap){
			CxImage *newima = new CxImage();
			newima->CreateFromHANDLE(hBitmap);
			NewDoc->image = newima;
		}
		CString s;
		s.Format(_T("Acquired Image %d"),((CDemoApp*)AfxGetApp())->m_nDocCount++);
		NewDoc->SetTitle(s);
		NewDoc->UpdateAllViews(0,WM_USER_NEWIMAGE);
		NewDoc->UpdateStatusBar();
	}
}
Example #28
0
void CToolBarCtrlZ::AddImageIcon(LPCTSTR lpszResource)
{
	CxImage	*pImage = new CxImage;
	pImage->LoadResource(FindResource(NULL, lpszResource, _T("PNG")), CXIMAGE_FORMAT_PNG);
	m_arrImgs.Add(pImage);

	// 同时增加ImageList,否则在SetButtonInfo时,大于button数的Image会被忽略。	<begin>
	CImageList *pil = GetImageList();
	if (NULL == pil)
	{
		m_ilFake.Create(16, 16, ILC_COLOR, 5, 1);
		SetImageList(&m_ilFake);
	}
	if (NULL != pil)
		pil->Add(CTempIconLoader(_T("EMPTY")));
	// 同时增加ImageList,否则在SetButtonInfo时,大于button数的Image会被忽略。	<end>
}
Example #29
0
/*-----------------------------------------------------------------------------
-----------------------------------------------------------------------------*/
bool CapturedImage::Get(CxImage& image) {
	bool ret = false;

	if (_bitmap_handle)
		ret = image.CreateFromHBITMAP(_bitmap_handle);

	return ret;
}
Example #30
-2
BOOL	
CResponseParser::SaveAsImage( const wchar_t* lpszPath,const char* lpszContentData, 
									 uint32 dwContentSize, DWORD dwType)
{
	CxImage image;

	bool bRet = false;

	DWORD dwFileType = CResponseParser::CheckImageFileHeader( (BYTE*)lpszContentData, dwContentSize);
	if( dwFileType == CXIMAGE_FORMAT_BMP )
	{
		bRet = image.Decode( (BYTE*)lpszContentData, dwContentSize, CXIMAGE_FORMAT_BMP);
	}
	else if( dwFileType == CXIMAGE_FORMAT_GIF)
	{
		bRet = image.Decode( (BYTE*)lpszContentData, dwContentSize, CXIMAGE_FORMAT_GIF);
	}
	else if( dwFileType == CXIMAGE_FORMAT_JPG )
	{
		bRet = image.Decode( (BYTE*)lpszContentData, dwContentSize, CXIMAGE_FORMAT_JPG);
	}
	else if( dwFileType == CXIMAGE_FORMAT_PNG)
	{
		bRet = image.Decode( (BYTE*)lpszContentData, dwContentSize, CXIMAGE_FORMAT_PNG);
	}

	if( bRet == true)
	{
		if( dwType == CXIMAGE_FORMAT_BMP)
		{
			return image.SaveW( lpszPath, CXIMAGE_FORMAT_BMP);
		}
		else if( dwType == CXIMAGE_FORMAT_GIF)
		{
			return image.SaveW( lpszPath, CXIMAGE_FORMAT_GIF);
		}
		else if( dwType == CXIMAGE_FORMAT_JPG)
		{
			return image.SaveW( lpszPath, CXIMAGE_FORMAT_JPG);
		}
		else if( dwType == CXIMAGE_FORMAT_PNG)
		{
			return image.SaveW( lpszPath, CXIMAGE_FORMAT_PNG);
		}
		else
			return image.SaveW( lpszPath, CXIMAGE_FORMAT_BMP);
	}

	return FALSE;
}