Microsoft/Windows2003-3790
Microsoft/Windows2003-3790
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
50969b0ea2
Windows2003-3790/windows/advcore/gdiplus/test/drawimage/drawimage.cpp
Microsoft 50969b0ea2 First commit
2020-09-30 16:53:55 +02:00

769 lines
19 KiB
C++
Raw Blame History

/******************************Module*Header*******************************\
* Module Name: drawimage.cpp
*
* Created: 23 December 1999
* Author: Adrian Secchia [asecchia]
*
* Copyright (c) 1999,Microsoft Corporation
*
* This is the DrawImage unit test.
*
\**************************************************************************/
#include <windows.h>
#include <objbase.h>
#include <math.h> // sin & cos
// Define away IStream
#define IStream int
#include <gdiplus.h>
#include <stdlib.h>
#include <stdio.h>
#include <tchar.h>
#include "drawimage.hpp"
#include "wndstuff.h"
using namespace Gdiplus;
#define USE_NEW_APIS 1
#define USE_NEW_APIS2 1
ImageAttributes *Img = NULL;
/***************************************************************************\
* DrawXXXX
*
* These routines are all the individual tests that this test
* suite will use.
\***************************************************************************/
// No fancy stuff - just put the whole image in the window.
// No rotation, stretching, etc.
#if 0
// cached bitmap in animated infinite loop
VOID DrawSimple(Graphics *g)
{
unsigned short filename[1024];
CachedBitmap *frame[32];
Bitmap *temp;
Graphics *gbmp;
Unit u;
RectF r;
for(int i=0; i<32; i++) {
wsprintf(filename, L"T%d.bmp", i);
temp = new Bitmap(filename);
temp->GetBounds(&r, &u);
// r.Width *=2;
// r.Height *=2;
frame[i] = new CachedBitmap(temp, g);
// gbmp = new Graphics(frame[i]);
// gbmp->SetInterpolationMode(InterpolationModeHighQualityBilinear);
/* Matrix *m = new Matrix(1.0f, 0.0f,
0.0f, -1.0f,
0.0f, r.Height);
gbmp->SetTransform(m);
*/
// gbmp->DrawImage(temp, 0, 0, (INT)r.Width, (INT)r.Height);
// delete gbmp;
delete temp;
// delete m;
}
RectF s = r;
i = 0;
int j;
while(++i) {
// for(j=0; j<3; j++)
// g->DrawImage(frame[i % 32], s, r.X, r.Y, r.Width, r.Height, UnitPixel);
g->DrawCachedBitmap(frame[i % 32], 10, 10);
}
}
#endif
VOID DrawSimple(Graphics *g)
{
Bitmap *image = new Bitmap(FileName);
Unit u;
RectF r;
image->GetBounds(&r, &u);
RectF s = r;
s.X = 31;
s.Y = 27;
s.Width *= 0.7f;
s.Height *= 0.7f;
g->DrawImage(image, s, r.X, r.Y, r.Width, r.Height, UnitPixel);
g->SetClip(Rect(50, 70, 100, 10));
ImageAttributes img;
ColorMatrix flipRedBlue = {
0, 1, 0, 0, 0,
0, 0, 1, 0, 0,
1, 0, 0, 0, 0,
0, 0, 0, 1, 0,
0, 0, 0, 0, 1
};
img.SetColorMatrix(&flipRedBlue);
g->DrawImage(image, s, r.X, r.Y, r.Width, r.Height, UnitPixel, &img);
g->ResetClip();
delete image;
}
VOID DrawSpecialRotate(Graphics *g)
{
Bitmap *image = new Bitmap(FileName);
Unit u;
RectF r;
image->GetBounds(&r, &u);
RectF s = r;
ImageAttributes img;
ColorMatrix flipRedBlue = {
0, 1, 0, 0, 0,
1, 0, 0, 0, 0,
0, 0, 1, 0, 0,
0, 0, 0, 1, 0,
0, 0, 0, 0, 1
};
img.SetColorMatrix(&flipRedBlue);
g->SetCompositingQuality(CompositingQualityGammaCorrected);
Rect dstRect(0, 0, 50, 100);
Rect srcRect(12, -14, 50, 100);
g->TranslateTransform(s.Height, 0.0f);
g->RotateTransform(90);
g->DrawImage(image, s, r.X, r.Y, r.Width, r.Height, UnitPixel, Img);
g->ResetTransform();
g->TranslateTransform(s.Height, s.Width);
g->RotateTransform(270);
g->DrawImage(image, s, r.X, r.Y, r.Width, r.Height, UnitPixel, Img);
g->ResetTransform();
g->TranslateTransform(s.Width, s.Height+s.Width);
g->RotateTransform(180);
g->DrawImage(image, s, r.X, r.Y, r.Width, r.Height, UnitPixel, Img);
g->ResetTransform();
g->TranslateTransform(s.Width+2*s.Height, 0.0f);
g->ScaleTransform(-1.0, 1.0);
g->DrawImage(image, s, r.X, r.Y, r.Width, r.Height, UnitPixel, Img);
g->ResetTransform();
g->TranslateTransform(2*s.Height, s.Height*2);
g->ScaleTransform(1.0, -1.0);
g->DrawImage(image, s, r.X, r.Y, r.Width, r.Height, UnitPixel, Img);
g->ResetTransform();
g->TranslateTransform(s.Width+2*s.Height, 0.0f);
g->ScaleTransform(-1.0, 1.0);
g->RotateTransform(90);
g->DrawImage(image, s, r.X, r.Y, r.Width, r.Height, UnitPixel, Img);
g->ResetTransform();
g->TranslateTransform(s.Width+3*s.Height, 2*s.Width);
g->ScaleTransform(-1.0, 1.0);
g->RotateTransform(270);
g->DrawImage(image, s, r.X, r.Y, r.Width, r.Height, UnitPixel, Img);
g->ResetTransform();
//Rot180
g->TranslateTransform(400.0f, 500.0f);
g->RotateTransform(180);
g->DrawImage(image, dstRect,srcRect.X, srcRect.Y, srcRect.Width, srcRect.Height+1, UnitPixel, &img);
g->ResetTransform();
g->TranslateTransform(400.0f, 500.0f);
g->RotateTransform(180);
g->DrawImage(image, dstRect,srcRect.X, srcRect.Y, srcRect.Width, srcRect.Height, UnitPixel);
g->ResetTransform();
//ID
g->TranslateTransform(400.0f, 500.0f);
g->RotateTransform(0);
g->DrawImage(image, dstRect,srcRect.X, srcRect.Y, srcRect.Width, srcRect.Height+1, UnitPixel, &img);
g->ResetTransform();
g->TranslateTransform(400.0f, 500.0f);
g->RotateTransform(0);
g->DrawImage(image, dstRect,srcRect.X, srcRect.Y, srcRect.Width, srcRect.Height, UnitPixel);
g->ResetTransform();
//Rot270FlipX
g->TranslateTransform(600.0f, 500.0f);
g->ScaleTransform(-1.0f, 1.0f);
g->RotateTransform(270);
g->DrawImage(image, dstRect,srcRect.X, srcRect.Y, srcRect.Width, srcRect.Height+1, UnitPixel, &img);
g->ResetTransform();
g->TranslateTransform(600.0f, 500.0f);
g->ScaleTransform(-1.0f, 1.0f);
g->RotateTransform(270);
g->DrawImage(image, dstRect,srcRect.X, srcRect.Y, srcRect.Width, srcRect.Height, UnitPixel);
g->ResetTransform();
//Rot270
g->TranslateTransform(600.0f, 500.0f);
g->RotateTransform(270);
g->DrawImage(image, dstRect,srcRect.X, srcRect.Y, srcRect.Width, srcRect.Height+1, UnitPixel, &img);
g->ResetTransform();
g->TranslateTransform(600.0f, 500.0f);
g->RotateTransform(270);
g->DrawImage(image, dstRect,srcRect.X, srcRect.Y, srcRect.Width, srcRect.Height, UnitPixel);
g->ResetTransform();
//Rot90FlipX
g->TranslateTransform(600.0f, 500.0f);
g->ScaleTransform(-1.0f, 1.0f);
g->RotateTransform(90);
g->DrawImage(image, dstRect,srcRect.X, srcRect.Y, srcRect.Width, srcRect.Height+1, UnitPixel, &img);
g->ResetTransform();
g->TranslateTransform(600.0f, 500.0f);
g->ScaleTransform(-1.0f, 1.0f);
g->RotateTransform(90);
g->DrawImage(image, dstRect,srcRect.X, srcRect.Y, srcRect.Width, srcRect.Height, UnitPixel);
g->ResetTransform();
//Rot90
g->TranslateTransform(600.0f, 500.0f);
g->RotateTransform(90);
g->DrawImage(image, dstRect,srcRect.X, srcRect.Y, srcRect.Width, srcRect.Height+1, UnitPixel, &img);
g->ResetTransform();
g->TranslateTransform(600.0f, 500.0f);
g->RotateTransform(90);
g->DrawImage(image, dstRect,srcRect.X, srcRect.Y, srcRect.Width, srcRect.Height, UnitPixel);
g->ResetTransform();
// FlipX
g->TranslateTransform(600.0f, 300.0f);
g->ScaleTransform(-1.0f, 1.0f);
g->DrawImage(image, dstRect,srcRect.X, srcRect.Y, srcRect.Width, srcRect.Height+1, UnitPixel, &img);
g->ResetTransform();
g->TranslateTransform(600.0f, 300.0f);
g->ScaleTransform(-1.0f, 1.0f);
g->DrawImage(image, dstRect,srcRect.X, srcRect.Y, srcRect.Width, srcRect.Height, UnitPixel);
g->ResetTransform();
// FlipY
g->TranslateTransform(600.0f, 300.0f);
g->ScaleTransform(1.0f, -1.0f);
g->DrawImage(image, dstRect,srcRect.X, srcRect.Y, srcRect.Width, srcRect.Height+1, UnitPixel, &img);
g->ResetTransform();
g->TranslateTransform(600.0f, 300.0f);
g->ScaleTransform(1.0f, -1.0f);
g->DrawImage(image, dstRect,srcRect.X, srcRect.Y, srcRect.Width, srcRect.Height, UnitPixel);
g->ResetTransform();
delete image;
}
VOID DrawCachedBitmap(Graphics *g)
{
Bitmap *image = new Bitmap(FileName);
Bitmap *bmp = new Bitmap(100, 100, PixelFormat32bppPARGB);
Graphics *gfx = new Graphics(bmp);
gfx->DrawImage(image, Rect(0,0,100,100), 0,0,100,100, UnitPixel);
gfx->SetCompositingMode(CompositingModeSourceCopy);
SolidBrush brush(Color(0x7f0000ff));
gfx->FillEllipse(&brush, 0, 0, 100, 100);
brush.SetColor(Color(0x00000000));
gfx->FillEllipse(&brush, 25, 25, 50, 50);
delete image;
delete gfx;
CachedBitmap *cb = new CachedBitmap(bmp, g);
int x;
for(int i=0; i<=40; i++)
{
x = i-20;
g->DrawCachedBitmap(cb, x*x, i*10);
}
delete cb;
delete bmp;
}
// Slightly rotated stretch.
VOID DrawStretchRotation(Graphics *g)
{
Image *image = new Bitmap(FileName);
PointF dst[4];
dst[0].X = 20;
dst[0].Y = 0;
dst[1].X = 900;
dst[1].Y = 20;
dst[2].X = 0;
dst[2].Y = 700;
g->DrawImage(image, dst, 3);
delete image;
}
// Slightly rotated stretch.
VOID DrawShrinkRotation(Graphics *g)
{
Image *image = new Bitmap(FileName);
PointF dst[4];
dst[0].X = 14.1521f;
dst[0].Y = 11.0205f;
dst[1].X = 25.4597f;
dst[1].Y = 10.5023f;
dst[2].X = 14.5403f;
dst[2].Y = 19.4908f;
g->DrawImage(image, dst, 3);
delete image;
}
// Rotated stretch with source cropping.
VOID DrawCropRotation(Graphics *g)
{
Image *image = new Bitmap(FileName);
PointF dst[4];
dst[0].X = 20;
dst[0].Y = 0;
dst[1].X = 180;
dst[1].Y = 20;
dst[2].X = 0;
dst[2].Y = 140;
g->DrawImage(image, dst, 3, 0, 0, 488, 400, UnitPixel);
delete image;
}
// Draw multiple copybits with different source cropping and
// destination positions.
// Little squares are drawn in reverse order from their source position and
// only alternate squares from a checkerboard pattern are drawn.
// Note outcropping can occur along the bottom and right edge of the source -
// which would be the top and left row of squares in the output.
VOID DrawCopyCrop(Graphics *g)
{
Image *image = new Bitmap(FileName);
const INT xs = 10;
const INT ys = 6;
const INT step = 50;
Rect s(0,0,step,step);
for(int i=0; i<xs; i++) for(int j=0; j<ys; j++) {
if(((i+j) & 0x1)==0x1) {
s.X = i*step-15;
s.Y = j*step-15;
g->DrawImage(image, s,
(xs-i-1)*step, (ys-j-1)*step, step, step, UnitPixel);
}
}
delete image;
}
// Pixel centering test. This test should show
// the correct pixel centering. The top left should be green and the bottom
// and right should be blending in the blend color
VOID DrawPixelCenter(Graphics *g)
{
WCHAR *filename = L"../data/3x3.bmp";
Image *image = new Bitmap(filename);
Color black(0xff,0,0,0);
Pen linepen(black, 1);
RectF r(100.0f, 100.0f, 300.0f, 300.0f);
for(int i=0; i<6; i++) {
g->DrawLine(&linepen, 100*i, 0, 100*i, 600);
g->DrawLine(&linepen, 0, 100*i, 600, 100*i);
}
g->DrawImage(image, r, 0.0f, 0.0f, 3.0f, 3.0f, UnitPixel, Img);
delete image;
}
// Draw with palette modification.
VOID DrawPalette(Graphics *g)
{
Image *image = new Bitmap(FileName, uICM==IDM_ICM);
Unit u;
RectF r;
image->GetBounds(&r, &u);
RectF s = r;
s.X = 21;
s.Y = 30;
ColorPalette *palette = NULL;
INT size;
Status status;
// Whack the first entry in the palette.
size = image->GetPaletteSize();
if(size > 0) {
palette = (ColorPalette *)malloc(size);
if(palette) {
status = image->GetPalette(palette, size);
if(status == Ok) {
palette->Entries[0] = 0x7fff0000;
status = image->SetPalette(palette);
}
}
}
g->DrawImage(image, r, r.X, r.Y, r.Width, r.Height, UnitPixel);
free(palette);
delete image;
}
// Specify source rectangle crop area not at the origin.
// Draw off the top of the window (negative destination).
VOID DrawICM(Graphics *g)
{
Bitmap *image = new Bitmap(FileName, uICM==IDM_ICM);
// Our ICM profile is hacked to flip the red and blue color channels
// Apply a recolor matrix to flip them back so that if something breaks
// ICM, the picture will look blue instead of the familiar colors.
ColorMatrix flipRedBlue =
{0, 1, 0, 0, 0,
0, 0, 1, 0, 0,
1, 0, 0, 0, 0,
0, 0, 0, 1, 0,
0, 0, 0, 0, 1};
/*img->SetColorMatrix(&flipRedBlue);*/
Unit u;
RectF r;
image->GetBounds(&r, &u);
RectF s = r;
s.X = 21;
s.Y = 30;
g->DrawImage(image, r, r.X, r.Y, r.Width, r.Height, UnitPixel, Img);
/* CachedBitmap *cb = new CachedBitmap(image, g);
g->DrawCachedBitmap(cb, 100, 100);
delete cb;*/
delete image;
}
// Draw a non rotated outcropped image.
VOID DrawOutCrop(Graphics *g)
{
Image *image = new Bitmap(FileName);
g->DrawImage(image, Rect(0,0,500,500), -500,-500,1500,1500, UnitPixel, Img);
delete image;
}
// Do a non-trivial crop with a world transform applied.
VOID DrawCropWT(Graphics *g)
{
Image *image = new Bitmap(FileName);
g->TranslateTransform(0, 100.0f);
g->DrawImage(image, 0, 0, 100,100,600,400, UnitPixel);
g->ResetTransform();
delete image;
}
// Non-trivial cropping combined with a horizontal flip and a world transform
VOID DrawHFlip(Graphics *g)
{
Image *image = new Bitmap(FileName);
PointF dst[4];
dst[0].X = 400;
dst[0].Y = 200;
dst[1].X = 0;
dst[1].Y = 200;
dst[2].X = 400;
dst[2].Y = 500;
g->TranslateTransform(0, 100.0f);
g->DrawImage(image, dst, 3, 100, 100, 600, 400, UnitPixel);
g->ResetTransform();
delete image;
}
// Non-trivial cropping combined with a vertical flip and a world transform
VOID DrawVFlip(Graphics *g)
{
Image *image = new Bitmap(FileName);
PointF dst[4];
dst[0].X = 0;
dst[0].Y = 500;
dst[1].X = 400;
dst[1].Y = 500;
dst[2].X = 0;
dst[2].Y = 200;
g->TranslateTransform(0, 100.0f);
g->DrawImage(image, dst, 3, 100, 100, 600, 400, UnitPixel);
g->ResetTransform();
delete image;
}
// Draw stretched image.
VOID DrawStretchS(Graphics *g)
{
Image *image = new Bitmap(FileName);
RectF r;
for(int i=6; i<15; i++)
{
g->DrawImage(image, (i+1)*i*10/2-200, 300, i*10, i*10);
}
g->DrawImage(image, 0, 0, 470, 200);
g->DrawImage(image, 500, 100, 300, 300);
g->DrawImage(image, 100, 500, 400, 300);
g->DrawImage(image, 500, 500, 300, 80);
delete image;
}
// Draw stretched image.
VOID DrawStretchB(Graphics *g)
{
Image *image = new Bitmap(FileName);
g->DrawImage(image, 100, 100, 603, 603);
delete image;
}
// Draw a rotated outcropped image.
VOID DrawOutCropR(Graphics *g)
{
Image *image = new Bitmap(FileName);
PointF dst[4];
dst[0].X = 20;
dst[0].Y = 0;
dst[1].X = 180;
dst[1].Y = 20;
dst[2].X = 0;
dst[2].Y = 140;
g->DrawImage(image, dst, 3, -50,-50,600,400, UnitPixel);
delete image;
}
// Simple no rotation, origin based source clip.
VOID DrawTest2(Graphics *g)
{
Image *image = new Bitmap(FileName);
g->DrawImage(image, 0, 0, 0, 0,100,100, UnitPixel);
delete image;
}
/***************************************************************************\
* DoTest
*
* Sets up the graphics according to the selected parameters on the menu
* and then invokes the appropriate test routine from above.
\***************************************************************************/
VOID
DoTest(
HWND hwnd
)
{
// Create a Graphics in the window.
// Graphics *g = Graphics::GetFromHwnd(hwnd, uICMBack==IDM_ICM_BACK);
HDC hdc = GetDC(hwnd);
SetICMMode(hdc, (uICMBack==IDM_ICM_BACK)?ICM_ON:ICM_OFF);
Graphics *g = new Graphics(hdc);
g->SetSmoothingMode(SmoothingModeNone);
// Choose the resampling mode.
switch(uResample) {
case IDM_BILINEAR:
g->SetInterpolationMode(InterpolationModeBilinear);
break;
case IDM_BICUBIC:
g->SetInterpolationMode(InterpolationModeBicubic);
break;
case IDM_NEARESTNEIGHBOR:
g->SetInterpolationMode(InterpolationModeNearestNeighbor);
break;
case IDM_HIGHBILINEAR:
g->SetInterpolationMode(InterpolationModeHighQualityBilinear);
break;
case IDM_HIGHBICUBIC:
g->SetInterpolationMode(InterpolationModeHighQualityBicubic);
break;
default:
break;
}
g->SetPixelOffsetMode(bPixelMode?PixelOffsetModeHalf:PixelOffsetModeNone);
Img = new ImageAttributes();
switch(uWrapMode)
{
case IDM_WRAPMODETILE:
Img->SetWrapMode(WrapModeTile, Color(0), FALSE);
break;
case IDM_WRAPMODEFLIPX:
Img->SetWrapMode(WrapModeTileFlipX, Color(0), FALSE);
break;
case IDM_WRAPMODEFLIPY:
Img->SetWrapMode(WrapModeTileFlipY, Color(0), FALSE);
break;
case IDM_WRAPMODEFLIPXY:
Img->SetWrapMode(WrapModeTileFlipXY, Color(0), FALSE);
break;
case IDM_WRAPMODECLAMP0:
Img->SetWrapMode(WrapModeClamp, Color(0), FALSE);
break;
case IDM_WRAPMODECLAMPFF:
Img->SetWrapMode(WrapModeClamp, Color(0xffff0000), FALSE);
break;
}
// Choose the test to run
switch(uCategory) {
case IDM_ALL:
DrawSimple(g);
DrawStretchRotation(g);
DrawShrinkRotation(g);
DrawCropRotation(g);
DrawCopyCrop(g);
DrawICM(g);
DrawTest2(g);
DrawOutCrop(g);
DrawOutCropR(g);
DrawCropWT(g);
DrawHFlip(g);
DrawVFlip(g);
DrawStretchB(g);
DrawCachedBitmap(g);
DrawStretchS(g);
DrawPalette(g);
DrawPixelCenter(g);
DrawSpecialRotate(g);
break;
case IDM_OUTCROPR:
DrawOutCropR(g);
break;
case IDM_OUTCROP:
DrawOutCrop(g);
break;
case IDM_SIMPLE:
DrawSimple(g);
break;
case IDM_STRETCHROTATION:
DrawStretchRotation(g);
break;
case IDM_SHRINKROTATION:
DrawShrinkRotation(g);
break;
case IDM_CROPROTATION: //who says programmers don't do real work??
DrawCropRotation(g);
break;
case IDM_PIXELCENTER:
DrawPixelCenter(g);
break;
case IDM_COPYCROP:
DrawCopyCrop(g);
break;
case IDM_DRAWPALETTE:
DrawPalette(g);
break;
case IDM_DRAWICM:
DrawICM(g);
break;
case IDM_DRAWIMAGE2:
DrawTest2(g);
break;
case IDM_STRETCHB:
DrawStretchB(g);
break;
case IDM_STRETCHS:
DrawStretchS(g);
break;
case IDM_CACHEDBITMAP:
DrawCachedBitmap(g);
break;
case IDM_CROPWT:
DrawCropWT(g);
break;
case IDM_HFLIP:
DrawHFlip(g);
break;
case IDM_VFLIP:
DrawVFlip(g);
break;
case IDM_SPECIALROTATE:
DrawSpecialRotate(g);
break;
default:
break;
}
delete Img;
Img = NULL;
delete g;
ReleaseDC(hwnd, hdc);
}
Reference in New Issue View Git Blame Copy Permalink