C++ Bitmap::GetWidth方法代码示例

void DrawBitmap(Bitmap &b, Rect& rect, int x, int y)
{
	glPushMatrix();
	glTranslatef((float)x,(float)y,0);
	////enable textures and set up automatic texture coordinate generation
	glBindTexture(GL_TEXTURE_2D, b.GetTexture());  
	glEnable(GL_TEXTURE_2D);

	glColor4f(1.0f,1.0f,1.0f,1.0f);

	//Define how alpha blending will work and enable alpha blending.
	glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
	glEnable(GL_BLEND);

	float tx1 = min(1.0f, (float)rect.X / (float)b.GetWidth());
	float ty1 = min(1.0f, (float)rect.Y / (float)b.GetHeight());

	float q = ((float)(rect.Width)/((float)b.GetWidth()));
	float tx2 = min(1.0f, tx1 + q);

	float f = (float)(rect.Height)/((float)b.GetHeight());
	float ty2 = min(1.0f, (ty1 + f) );



	glPolygonMode(GL_FRONT_AND_BACK, GL_POLYGON);
	glBegin(GL_QUADS);
            glTexCoord2f(tx1, 1-ty1); glVertex2f(0.0f, 0.0f);
			glTexCoord2f(tx1, 1-ty2); glVertex2f(0.0f, (float)rect.Height);
            glTexCoord2f(tx2, 1-ty2); glVertex2f((float)rect.Width, (float)rect.Height);
            glTexCoord2f(tx2, 1-ty1); glVertex2f((float)rect.Width, 0.0f);
	glEnd();
	glDisable(GL_TEXTURE_2D);
	glPopMatrix();
}

static RenderedBitmap *ThumbFromCoverPage(Doc doc, SizeI size)
{
    ImageData *coverImage = doc.GetCoverImage();
    if (!coverImage)
        return nullptr;
    Bitmap *coverBmp = BitmapFromData(coverImage->data, coverImage->len);
    if (!coverBmp)
        return nullptr;

    Bitmap res(size.dx, size.dy, PixelFormat24bppRGB);
    float scale = (float)size.dx / (float)coverBmp->GetWidth();
    int fromDy = size.dy;
    if (scale < 1.f)
        fromDy = (int)((float)coverBmp->GetHeight() * scale);
    Graphics g(&res);
    g.SetInterpolationMode(InterpolationModeHighQualityBicubic);
    Status ok = g.DrawImage(coverBmp, Rect(0, 0, size.dx, size.dy),
                            0, 0, coverBmp->GetWidth(), fromDy, UnitPixel);
    if (ok != Ok) {
        delete coverBmp;
        return nullptr;
    }
    HBITMAP hbmp;
    ok = res.GetHBITMAP((ARGB)Color::White, &hbmp);
    delete coverBmp;
    if (ok == Ok)
        return new RenderedBitmap(hbmp, SizeI(size.dx, size.dy));
    return nullptr;
}

// ***************************************************************
//		DrawOverlays()
// ***************************************************************
void TilesDrawer::DrawOverlays(TileCore* tile, RectF screenBounds, ImageAttributes& attr)
{
	for (size_t i = 0; i < tile->Overlays.size(); i++)
	{
		Bitmap* bmp = tile->get_Bitmap(i)->m_bitmap;
		if (bmp)
		{
			// to debug the issue with occasional seams
			// DumpTile

			Status status;

			double ROUNDING_TOLERANCE = 0.1;
			
			double dx = abs(screenBounds.Width - bmp->GetWidth());
			double dy = abs(screenBounds.Height - bmp->GetHeight());

			if (dx < ROUNDING_TOLERANCE && dy < ROUNDING_TOLERANCE)
			{
				// TODO: better to check that all tiles have the same size and apply this rendering only then
				status = _graphics->DrawImage(bmp, Utility::Rint(screenBounds.X), Utility::Rint(screenBounds.Y));
			}
			else
			{
				status = _graphics->DrawImage(bmp, screenBounds, 0.0f, 0.0f, (REAL)bmp->GetWidth(), (REAL)bmp->GetHeight(), UnitPixel, &attr);
			}

			if (status != Gdiplus::Status::Ok)
			{
				Debug::WriteLine("Failed to draw tile.");
			}
		}
	}
}

void MarkerTool::createCircle()
{
	using namespace Gdiplus;
	delete[] circleData_;
	circleData_ = 0;
	circleStride_ = 0;
	Bitmap * circle = new Bitmap(penSize_, penSize_, PixelFormat32bppARGB);
	Graphics gr2(circle);
	SolidBrush br(Color(255,255,0));
	gr2.FillEllipse( &br, 0, 0, circle->GetWidth(), circle->GetHeight());

	BitmapData circleData;

	Rect lc(0,0,circle->GetWidth(),circle->GetHeight());
	if ( circle->LockBits(&lc, ImageLockModeRead, PixelFormat32bppARGB, & circleData) == Ok)
	{
		if (circleData.Stride > 0) { 
			circleStride_ = circleData.Stride;
		} else {
			circleStride_ = - circleData.Stride;
		}
		size_t dataSize = circleStride_ * circle->GetHeight();
		circleData_ = new uint8_t[dataSize];
		memcpy(circleData_, circleData.Scan0, dataSize);
		circle->UnlockBits(&circleData);
	}
	
	delete circle;
}

void GPCreateFlashFrame( Bitmap& bmpSrc, CRect& rcBegin, CRect& rcEnd, Bitmap& bmpDes, CRect& rcDes, double dPercent )
{
	int  nWidth = bmpSrc.GetWidth();
	int  nHeight = bmpSrc.GetHeight();
	double dPercent2 = 1.0 - dPercent;
	int  nWidthDes = bmpDes.GetWidth();
	int  nHeightDes = bmpDes.GetHeight();
	CRect rcBmpSrc(0,0, nWidth, nHeight);
	CRect rcBmpDes(0,0, nWidthDes, nHeightDes);

	ASSERT(IsInRect(rcBegin, rcBmpSrc));
	ASSERT(IsInRect(rcEnd, rcBmpSrc));
	ASSERT(IsInRect(rcDes, rcBmpDes));
	ASSERT(rcBegin.Size() == rcEnd.Size());
	ASSERT(rcEnd.Size() == rcDes.Size());
	int nLoopWidth = rcBegin.Width();
	int nLoopHeight = rcBegin.Height();
	for (int i = 0; i <nLoopWidth; i++)
	{
		for (int j = 0; j < nLoopHeight; j++)
		{
			Color clrBegin;
			bmpSrc.GetPixel(i+ rcBegin.left, j+ rcBegin.top, &clrBegin);
			Color clrEnd;
			bmpSrc.GetPixel(i+ rcEnd.left, j+ rcEnd.top, &clrEnd);
			Color clrDes = Color::MakeARGB(clrBegin.GetA()*dPercent + clrEnd.GetA()* dPercent2, 
				clrBegin.GetR()*dPercent + clrEnd.GetR()* dPercent2,
				clrBegin.GetG()*dPercent + clrEnd.GetG()* dPercent2,
				clrBegin.GetB()*dPercent + clrEnd.GetB()* dPercent2);
			bmpDes.SetPixel(rcDes.left + i, rcDes.top+j, clrDes);
		}
	}
	

}

// RawSaveScreen: copy the current screen to a backup bitmap
void RawSaveScreen () {
    if (raw_saved_screen != NULL)
        delete raw_saved_screen;
    Bitmap *source = thisroom.ebscene[play.bg_frame];
    raw_saved_screen = BitmapHelper::CreateBitmap(source->GetWidth(), source->GetHeight());
    raw_saved_screen->Blit(source, 0, 0, 0, 0, source->GetWidth(), source->GetHeight());
}

// OrGate 메시지 처리기입니다.
void OrGate::Paint(CClientDC* dc) {
	/*
	CBitmap bitmap;
	bitmap.LoadBitmapW(IDB_OR);
	BITMAP bmpinfo;
	bitmap.GetBitmap(&bmpinfo);

	CDC dcmem;
	dcmem.CreateCompatibleDC(dc);
	dcmem.SelectObject(&bitmap);

	dc->BitBlt(point.x, point.y, bmpinfo.bmWidth, bmpinfo.bmHeight, &dcmem, 0, 0, SRCCOPY);
*/

/* GDI+ 구현 */
	Graphics ScreenG(dc->GetSafeHdc());
	Bitmap* pBitmapOR;
	pBitmapOR = Bitmap::FromResource(AfxGetInstanceHandle(), (WCHAR*)MAKEINTRESOURCE(IDB_OR));

	ScreenG.DrawImage(pBitmapOR, Rect(point.x, point.y, pBitmapOR->GetWidth(), pBitmapOR->GetHeight()), 0, 0, pBitmapOR->GetWidth(), pBitmapOR->GetHeight(), UnitPixel);


	Width = pBitmapOR->GetWidth();
	Height = pBitmapOR->GetHeight();

	//연결 구현
	if (UpWire == point.x + 3 && UpWire == point.y + 7 && DownWire == point.x + 3 && DownWire == point.y + 19) { // ORGate와 선 연결 성공
		connect = TRUE;
	}
}

void CBMPView::OnDraw(CDC* pDC)
{
	Graphics graphicsDC(*pDC);					// gdi+ 그리기를 위한 객체
	CRect clientRect;
	GetClientRect(clientRect);
	Bitmap bmpCanvas(clientRect.right, clientRect.bottom);	// 캔버스 비트맵 생성
	Graphics graphicsCanvas(&bmpCanvas);		// 캔버스 그래픽스 생성
	graphicsCanvas.Clear(Color::Azure);			// 캔버스 배경색 지정

	CBMPDoc *pDoc = GetDocument();
	ASSERT_VALID(pDoc);
	if (!pDoc)
		return;

	// TODO: 여기에 그리기 코드를 추가합니다.
	Bitmap* pBitmap = pDoc->m_bitmap;
	UINT gapW = abs(clientRect.Width() - (int)pBitmap->GetWidth());
	UINT gapH = abs(clientRect.Height() - (int)pBitmap->GetHeight());
	UINT gap = gapW > gapH ? gapW : gapH;

	if (pBitmap) {
		graphicsCanvas.DrawImage(pBitmap, 0, 0, pBitmap->GetWidth(), pBitmap->GetHeight());
	}

	graphicsDC.DrawImage(&bmpCanvas, clientRect.left, clientRect.top, clientRect.right, clientRect.bottom);	// 캔버스 그리기
}

void show_preload () {
    // ** Do the preload graphic if available
    color temppal[256];
	Bitmap *splashsc = BitmapHelper::CreateRawObjectOwner( load_pcx("preload.pcx",temppal) );
    if (splashsc != NULL) {
        if (splashsc->GetColorDepth() == 8)
            wsetpalette(0,255,temppal);
		Bitmap *screen_bmp = BitmapHelper::GetScreenBitmap();
        Bitmap *tsc = BitmapHelper::CreateBitmap(splashsc->GetWidth(),splashsc->GetHeight(),screen_bmp->GetColorDepth());
        tsc->Blit(splashsc,0,0,0,0,tsc->GetWidth(),tsc->GetHeight());
		screen_bmp->Clear();
        screen_bmp->StretchBlt(tsc, RectWH(0, 0, scrnwid,scrnhit), Common::kBitmap_Transparency);

        gfxDriver->ClearDrawList();

        if (!gfxDriver->UsesMemoryBackBuffer())
        {
            IDriverDependantBitmap *ddb = gfxDriver->CreateDDBFromBitmap(screen_bmp, false, true);
            gfxDriver->DrawSprite(0, 0, ddb);
            render_to_screen(screen_bmp, 0, 0);
            gfxDriver->DestroyDDB(ddb);
        }
        else
			render_to_screen(screen_bmp, 0, 0);

        delete splashsc;
        delete tsc;
        platform->Delay(500);
    }
}

// Run()
void Run()
{
	HDC backDC = backBuf.GetDC();
	
	// 塗りつぶし
	RECT rc;
	rc.left = rc.top = 0;
	rc.right = backBuf.GetWidth();
	rc.bottom = backBuf.GetHeight();

	FillRect(backDC, &rc, (HBRUSH)GetStockObject(BLACK_BRUSH));

	// 図形描画
	HPEN hPenOld, hPen;

	hPen = CreatePen(PS_SOLID, 0, RGB(0xff, 0, 0));
	hPenOld = (HPEN)SelectObject(backDC, hPen);
	
	Vector2 r[4];
	Vector2 trans(backBuf.GetWidth()>>1, backBuf.GetHeight()>>1);
	Matrix2 rot, sc;
	static int t = 0;
	t += 5;
	Matrix2Rotation(rot, t/180.0f*3.14);
	Matrix2Scaling(sc, 2, 2);
	for (int i = 0; i < 4; ++i) {
		r[i] = rect[i] * sc * rot;
		r[i] = r[i] + trans;
	}
		/*Vector3 r[4];
		Vector3 trans(backBuf.GetWidth()>>1, backBuf.GetHeight()>>1, 0);
		Matrix3 rot, sc;
		static int t = 0;
		t += 5;
		Matrix3RotationHV(rot, t/180.0f*3.14);
		for (int i = 0; i < 4; ++i) {
			r[i].x = rect[i].x;
			r[i].y = rect[i].y;
			r[i] = r[i] * rot;
			r[i] = r[i] + trans;
		}*/
	for (int i = 0; i < 4; ++i) {
		MoveToEx(backDC, r[i].x, r[i].y, NULL);
		LineTo(backDC, r[(i+1)&3].x, r[(i+1)&3].y);
	}
	SelectObject(backDC, hPenOld);
	DeleteObject(hPen);
	

	// フリップ
	HDC hDC = GetDC(wnd.GetHandle());
	BitBlt(hDC, 0, 0, rc.right, rc.bottom, backDC, 0, 0, SRCCOPY);
	ReleaseDC(wnd.GetHandle(), hDC);

	Sleep(100);
}

Texture::Texture(const Bitmap& bmp){
    glGenTextures(1, &id);
    //glBindTexture(GL_TEXTURE_2D, id);
    Bind();
	glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, bmp.GetWidth(), bmp.GetHeight(), 0, GL_RGBA, GL_UNSIGNED_BYTE, bmp.GetData());
	this->width = bmp.GetWidth();
	this->height = bmp.GetHeight();
    cout << "Texture " << id << endl;
}

static FtkBitmap* load_win32 (const char *filename)
{
	int x = 0;
	int y = 0;
	int w = 0;
	int h = 0;
	FtkColor bg = {0};
	FtkBitmap* bitmap = NULL;
	WCHAR wfilename[MAX_PATH] = {0};
	mbstowcs(wfilename, filename, MAX_PATH);
	Bitmap* img = Bitmap::FromFile(wfilename);

	return_val_if_fail(img != NULL, NULL);
	if(img->GetWidth() == 0 || img->GetHeight() == 0)
	{
		delete img;

		return NULL;
	}

	w = img->GetWidth();
	h = img->GetHeight();

	bg.a = 0xff;
	bitmap = ftk_bitmap_create(w, h, bg);
	Rect r(0, 0, w, h);
	BitmapData bitmapData;
#ifdef VC6
	img->LockBits(r, ImageLockModeRead, PixelFormat32bppARGB, &bitmapData);
#else
	img->LockBits(&r, ImageLockModeRead, PixelFormat32bppARGB, &bitmapData);
#endif
	FtkColor* src = (FtkColor*)bitmapData.Scan0;
	FtkColor* dst = ftk_bitmap_bits(bitmap);

	for(y = 0; y < h; y++)
	{
		for(x = 0; x < w; x++)
		{
			*dst = *src;
			dst++;
			src++;
		}
	}

	img->UnlockBits(&bitmapData);
	
	delete img;

	return bitmap;
}

bool CExampleDemoDlg::GetFaceRect(Bitmap* pImageSori)
{
	//_sleep(100);
	Bitmap* pImageS = pImageSori->Clone(0, 0, pImageSori->GetWidth(), pImageSori->GetHeight(), PixelFormat32bppARGB);
	// TODO:  在此添加您专用的创建代码
	float scalew = 1.;
	if (pImageS->GetWidth() > 480 || pImageS->GetHeight() > 640)
	{

		scalew=min(480.f / pImageS->GetWidth(), 640.f / pImageS->GetHeight());

		int width = pImageS->GetWidth()*scalew;
		int height = pImageS->GetHeight()*scalew;
		ResizeBitmap(&pImageS, width, height);
	}


	Gdiplus::BitmapData TempBitmapData;
	Gdiplus::Rect rc(0, 0, pImageS->GetWidth(), pImageS->GetHeight());
	pImageS->LockBits(&rc, Gdiplus::ImageLockModeRead | Gdiplus::ImageLockModeWrite, PixelFormat32bppARGB, &TempBitmapData);


	CPupilGUI cpi = CPupilGUI((BYTE*)TempBitmapData.Scan0, TempBitmapData.Width, TempBitmapData.Height);
	pImageS->UnlockBits(&TempBitmapData);
	SAFE_DELETE(pImageS);
	if (cpi.isface == true)
	{
		int x0=cpi.m_face_detection.rFace.left;
		int y0 = cpi.m_face_detection.rFace.top;
		int width = (cpi.m_face_detection.rFace.right-x0)/scalew;
		int height = (cpi.m_face_detection.rFace.bottom-y0)/scalew;
		if (height+width<700)
		{
			return false;
		}
		else
		{
			return true;
		}
		//return GetRect(CRect(x0/scalew, y0/scalew, width/scalew, height/scalew), pImageSori);

	}
	else
	{
		return false;
	}



}

void DrawingSurface_DrawSurface(ScriptDrawingSurface* target, ScriptDrawingSurface* source, int translev) {
    if ((translev < 0) || (translev > 99))
        quit("!DrawingSurface.DrawSurface: invalid parameter (transparency must be 0-99)");

    Bitmap *ds = target->StartDrawing();
    Bitmap *surfaceToDraw = source->GetBitmapSurface();

    if (surfaceToDraw == target->GetBitmapSurface())
        quit("!DrawingSurface.DrawSurface: cannot draw surface onto itself");

    if (translev == 0) {
        // just draw it over the top, no transparency
        ds->Blit(surfaceToDraw, 0, 0, 0, 0, surfaceToDraw->GetWidth(), surfaceToDraw->GetHeight());
        target->FinishedDrawing();
        return;
    }

    if (surfaceToDraw->GetColorDepth() <= 8)
        quit("!DrawingSurface.DrawSurface: 256-colour surfaces cannot be drawn transparently");

    // Draw it transparently
    GfxUtil::DrawSpriteWithTransparency(ds, surfaceToDraw, 0, 0,
        GfxDef::Trans100ToAlpha255(translev));
    target->FinishedDrawing();
}

/*
** Loads the image from disk
**
*/
void MeterImage::LoadImage(const std::wstring& imageName, bool bLoadAlways)
{
	m_Image.LoadImage(imageName, bLoadAlways);

	if (m_Image.IsLoaded())
	{
		// Calculate size of the meter
		Bitmap* bitmap = m_Image.GetImage();

		int imageW = bitmap->GetWidth();
		int imageH = bitmap->GetHeight();

		if (m_WDefined)
		{
			if (!m_HDefined)
			{
				m_H = (imageW == 0) ? 0 : (m_DrawMode == DRAWMODE_TILE) ? imageH : m_W * imageH / imageW;
			}
		}
		else
		{
			if (m_HDefined)
			{
				m_W = (imageH == 0) ? 0 : (m_DrawMode == DRAWMODE_TILE) ? imageW : m_H * imageW / imageH;
			}
			else
			{
				m_W = imageW;
				m_H = imageH;
			}
		}
	}
}