Cambalinho

em toda a área: eu ainda não entendi como funciona os cálculos para calcular os pontos da recta... mas pode ser por isso mesmo que tenho esses pixels pretos dentro do vermelho e eu não sei como os testar

eis a minha função de http://members.chello.at/easyfilter/bresenham.html struct point { float x,y,z; } ; vector<point> GetLinePoints(point Origin, point Destination) { vector<point> LinePoints; point LinePoint; int dx = abs(Destination.x-Origin.x), sx = Origin.x<Destination.x ? 1 : -1; int dy = abs(Destination.y-Origin.y), sy = Origin.y<Destination.y ? 1 : -1; int dz = abs(Destination.z-Origin.z), sz = Origin.z<Destination.z ? 1 : -1; int dm =std::max( { dx, dy, dz } ), i = dm; /* maximum difference */ Destination.x = Destination.y = Destination.z = dm/2; /* error offset */ do { Destination.x -= dx; if (Destination.x < 0) { Destination.x += dm; Origin.x += sx; } Destination.y -= dy; if (Destination.y < 0) { Destination.y += dm; Origin.y += sy; } Destination.z -= dz; if (Destination.z < 0) { Destination.z += dm; Origin.z += sz; } LinePoint.x=Origin.x; LinePoint.y=Origin.y; LinePoint.z=Origin.z; LinePoints.push_back(LinePoint); i--; }while(i >=0); return LinePoints; } eis o resultado: alguns pixels(sim era para ser vermelho) não são imprimidos ou tem coordenadas erradas

C++: O que é Anti-aliased e para que serve? Eu tenho outra função para desenhar uma linha, mas, dependendo da rotação, posso perder alguns pontos da linha. Eu penso que não é perder, mas pode ir para outro pixel que não é o correcto. Será que fazer o Anti-aliased, é tentar corrigir esse erro?

Tem só HDC. O melhor é fazer um HBITMAP com HDC para fazer o resultado pixel a pixel, como um buffer, e depois usar o BitBlt() para desenhar no HDC da janela.

pergunta chave: a janela tem HBITMAP ou só HDC?

void GetPixelsFromHDC(HDC Destination, int *pixels) { HBITMAP hBitmap = reinterpret_cast<HBITMAP>(GetCurrentObject(Destination, OBJ_BITMAP)); DIBSECTION dibs; ::GetObject(hBitmap, sizeof(DIBSECTION), &dibs); BITMAPINFO bitinfo; ::GetObject(hBitmap, sizeof(BITMAPINFO), &bitinfo); pixels = (unsigned int*)malloc(dibs.dsBmih.biWidth*dibs.dsBmih.biHeight*sizeof(unsigned int)); ::GetDIBits(Destination, hBitmap,0,dibs.dsBmih.biHeight,&pixels,&bitinfo,dibs.dsBmih.biClrUsed); } //Draw image pixel a pixel: void DrawImagePoint(HDC hdcDestination,point TopLeft,point TopRight,point BottomLeft,point BottomRight) { point LeftLineOrigin=TopLeft; point LeftLineDestination=BottomLeft; point RightLineOrigin=TopRight; point RightLineDestination=BottomRight; vector<point> LeftLineDots=GetPointsLine(TopLeft,BottomLeft); vector<point> RightLineDots=GetPointsLine(TopRight, BottomRight); COLORREF color; int pixelposition=0; int *pixelspointer; GetPixelsFromHDC(hdcDestination,pixelspointer); //now we draw the line with a color and convert the 3D to 2D: for (int Y=0; Y<LeftLineDots.size(); Y++) { int X=0; point CenterLineOrigin=LeftLineDots[Y]; point CenterLineDestination=RightLineDots[Y]; vector<point> CenterLine=GetPointsLine(CenterLineOrigin,CenterLineDestination); for(point points:CenterLine) { color =RGB(pixel->blue, pixel->green, pixel->red); int pos=points.x*points.y; pixelspointer[pos]=color; //SetPixelV(hdcDestination,points.x,points.y, color); ++pixelposition; ++pixel; //++pixelspointer; } } //in these case the pixelposition, is the last pixel position: for (int i=pixelposition; i!=0; i--) { --pixel; --pixelspointer; } } na execução tenho 1 erro: "Process returned -1073741819 (0xC0000005) execution time : 0.875 s Press any key to continue." penso que erro vem daqui: pixelspointer[pos]=color; porque já converti em comentário... o que estou a fazer de errado? uma questão: eu não criei 1 HBITMAP para a consola... será que não existe algum?

Mas se eu quiser uma posição, tipo 15, como faço para ver e alterar o valor?

me corrija 1 coisa para testar: normalmente fazemos: ++NomeDoPonteiro; NomeDoPonteiro=valor (penso que deveria ser: *NomeDoPonteiro=Valor ou seja usamos '*' para obter\alterar o valor) mas imagine que quero 1 posição do ponteiro, como o faço?

como prometido e sim mudei algumas coisas, mas teste alguns erros do meu codigo: #include <iostream> #include <string> #include <string.h> #include <windows.h> #include <math.h> #include <vector> #include <gdiplus.h> #include <stdlib.h> #include <algorithm> #include <thread> #include <future> //#include "image.h" using namespace Gdiplus; using namespace std; const double PI = 3.14159265358979; class GDI_Plus { public: GDI_Plus() { Gdiplus::GdiplusStartup(&m_gdiplusToken, &gdiplusStartupInput, nullptr); } ~GDI_Plus() { Gdiplus::GdiplusShutdown(m_gdiplusToken); } private: ULONG_PTR m_gdiplusToken = 0; Gdiplus::GdiplusStartupInput gdiplusStartupInput = {0}; }; struct Pixel { BYTE red, green, blue, alpha; }; struct { BITMAPINFOHEADER bmiHeader; RGBQUAD bmiColors[256]; } bmi; struct point { float x,y,z; } ; struct angle { float x,y,z; } ; point perspective(const point &p,const point &eyepoint) { float w=1+(p.z/eyepoint.z); return {(p.x-eyepoint.x)/w+eyepoint.x, (p.y-eyepoint.y)/w+eyepoint.y, (p.z-eyepoint.z)/w+eyepoint.z}; } float GetLineLength(point p1,point p2) { return sqrt( (p1.x-p2.x)* (p1.x-p2.x) + (p1.y-p2.y)* (p1.y-p2.y) + (p1.z-p2.z)* (p1.z-p2.z)); } //Get Points Line: point lineto(point fp,point p,float length) { point res; float L=GetLineLength(fp,p); res.x=fp.x+length*(p.x-fp.x)/L; res.y=fp.y+length*(p.y-fp.y)/L; res.z=fp.z+length*(p.z-fp.z)/L; return res; } vector<point> GetPointsLine(point origin,point destination) { point t=origin; vector<point> coordenates; float dst=GetLineLength(origin,destination); point eyepoint={250,150,300}; for (int i=0;i<=dst;i++) { t=lineto(t,destination,1); //t = perspective(t,eyepoint); coordenates.push_back(t); } return coordenates; } //Convert the std::string to std::wstring: std::wstring towstring(const std::string& v) { std::wstring out(v.size()+1,L'\0'); int size = MultiByteToWideChar(CP_UTF8, 0, v.c_str(), -1, &out[0], out.size()); out.resize(size-1); return out; } POINT Convert3DTo2D(point Dot, int FocalDistance=100) { POINT ptDot; ptDot.x=Dot.x/Dot.z * FocalDistance; ptDot.y=Dot.y/Dot.z * FocalDistance; return ptDot; } void GetPixelsFromHDC(HDC Destination, int *pixels) { HBITMAP hBitmap = reinterpret_cast<HBITMAP>(GetCurrentObject(Destination, OBJ_BITMAP)); DIBSECTION dibs; ::GetObject(hBitmap, sizeof(DIBSECTION), &dibs); BITMAPINFO bitinfo; ::GetObject(hBitmap, sizeof(BITMAPINFO), &bitinfo); pixels = (unsigned int*)malloc(dibs.dsBmih.biWidth*dibs.dsBmih.biHeight*sizeof(unsigned int)); ::GetDIBits(Destination, hBitmap,0,0,&pixels,&bitinfo,dibs.dsBmih.biClrUsed); } point Convert3DTO2D(point Position, float FocalDistance=0.05) { point Point2D; Point2D.x=Position.x * FocalDistance/Position.z; Point2D.y=Position.y*FocalDistance/Position.z; return Point2D; } angle ConvertDegreesToRadians(angle Rotation) { double deg2Rad; deg2Rad = PI / 180; angle ConvertDegrees; ConvertDegrees.x = Rotation.x * deg2Rad; ConvertDegrees.y = Rotation.y * deg2Rad; ConvertDegrees.z = Rotation.z * deg2Rad; return ConvertDegrees; } point RotationPoints2(point Coordenate, const angle AngleCoordenate, const point pivot={0,0,0}) { angle radians= ConvertDegreesToRadians(AngleCoordenate); point RotatedPoint; RotatedPoint=Coordenate; Coordenate.x-=pivot.x; Coordenate.y-=pivot.y; Coordenate.z-=pivot.z; //First we rotate the Z: RotatedPoint.x=Coordenate.x * cos(AngleCoordenate.z)-Coordenate.y*sin(AngleCoordenate.z); RotatedPoint.y=Coordenate.x * sin(AngleCoordenate.z)+Coordenate.y*cos(AngleCoordenate.z); //RotatedPoint.z=Coordenate.z; //Second we rotate the Y: RotatedPoint.x=RotatedPoint.x * cos(AngleCoordenate.y)+RotatedPoint.z*sin(AngleCoordenate.y); //RotatedPoint.y=RotatedPoint.y; // pointless self assignemnt RotatedPoint.z=-RotatedPoint.x * sin(AngleCoordenate.y)+RotatedPoint.z*cos(AngleCoordenate.y); //Third we rotate the X: //RotatedPoint.x=RotatedPoint.x; // pointless self assignemnt RotatedPoint.y=RotatedPoint.y * cos(AngleCoordenate.x)-RotatedPoint.z*sin(AngleCoordenate.x); RotatedPoint.z=RotatedPoint.y * sin(AngleCoordenate.x)+RotatedPoint.z*cos(AngleCoordenate.x); RotatedPoint.x+=pivot.x; RotatedPoint.y+=pivot.y; RotatedPoint.z+=pivot.z; return RotatedPoint; } point RotationPoints(point pt, angle Angle, point pivot={0,0,0},point scale={1,1,1}) { angle radians= ConvertDegreesToRadians(Angle); Angle.x =radians.x; Angle.y =radians.y; Angle.z =radians.z; point p={pt.x-pivot.x,pt.y-pivot.y,pt.z-pivot.z}; point rot,temp; temp={(p.y)*cos(Angle.x)+(-p.z)*sin(Angle.x),(p.z)*cos(Angle.x)+(p.y)*sin(Angle.x)}; rot.y=temp.x;rot.z=temp.y; p.y = rot.y;p.z = rot.z; temp={(p.z)*cos(Angle.y)+(-p.x)*sin(Angle.y),(p.x)*cos(Angle.y)+(p.z)*sin(Angle.y)}; rot.z=temp.x;rot.x=temp.y; p.x=rot.x; temp={(p.x)*cos(Angle.z)+(-p.y)*sin(Angle.z),(p.y)*cos(Angle.z)+(p.x)*sin(Angle.z)}; rot.x=temp.x;rot.y=temp.y; return {(scale.x*rot.x+pivot.x),(scale.y*rot.y+pivot.y),(scale.z*rot.z+pivot.z)}; } //Draw a Line: void DrawLine(HDC WindowHDC,point origin,point destination,COLORREF color=RGB(0,0,255) ) { //for convert 3D to 2D we must: //have Focal Distance, in these case is 100 //float FocalDistance =100; //2D.X = 3D.X * FocalDistance / 3D.Z //2D.Y = 3D.Y * FocalDistance / 3D.Z //Getting the Points of a line: vector<point> coordenates; //origin.z=-origin.z; //destination.z=-destination.z; coordenates = GetPointsLine(origin,destination); point eyepoint={250,150,300}; //now we draw the line with a color and convert the 3D to 2D: for (point LinePoints:coordenates) { point p=perspective(LinePoints,eyepoint); //SetPixel(WindowHDC,p.x,p.y,color); std::thread thread_obj(SetPixel, WindowHDC,p.x,p.y,color); thread_obj.join(); } } void DrawRectangle(HDC WindowHDC,point Top, point Left, point Right, point Bottom,COLORREF color=RGB(255,0,0) ) { //for convert 3D to 2D we must: //have Focal Distance, in these case is 100 //2D.X = 3D.X * FocalDistance / 3D.Z //2D.Y = 3D.Y * FocalDistance / 3D.Z float FocalDistance =100; //Getting the Points of a line: vector<point> coordenates; /* coordenates = GetPointsLine(origin,destination); point eyepoint={250,150,300}; //now we draw the line with a color and convert the 3D to 2D: for (point LinePoints:coordenates) { point p=Convert3DTO2D(LinePoints); //perspective(LinePoints,eyepoint); SetPixel(WindowHDC,p.x,p.y,color); }*/ } //Draw an Image: void DrawImage(HDC HDCWindow,point corners[4], HDC HDCOrigin, int PosX, int PosY, int Width, int Height) { POINT ImageCordeners[3]; //Move Top-Left Corner: ImageCordeners[0].x=corners[0].x; ImageCordeners[0].y=corners[0].y; //Move Top-Right Corner: ImageCordeners[1].x=corners[1].x; ImageCordeners[1].y=corners[1].y; ////Move the Bottom-Right Corner: ImageCordeners[2].x=corners[2].x; ImageCordeners[2].y=corners[2].y; PlgBlt(HDCWindow,ImageCordeners,HDCOrigin,PosX,PosY,Width,Height,NULL,0,0); } //Draw image pixel a pixel: void DrawImagePoint(HDC HDCDestination,HDC HDCOrigin, point TopLeft,point TopRight,point BottomLeft,point BottomRight) { //Getting the Points of a line: vector<point> LeftLine; LeftLine = GetPointsLine(TopLeft,BottomLeft); vector<point> RgihtLine; RgihtLine = GetPointsLine(TopRight,BottomRight); for(int PosX=0; PosX<LeftLine.size(); PosX++) { vector<point> PixelLine; PixelLine=GetPointsLine(LeftLine[PosX], RgihtLine[PosX]); for (int PosY=0; PosY<PixelLine.size(); PosY++) { point Point=PixelLine[PosY]; COLORREF color; color=::GetPixel(HDCOrigin,PosY+800,PosX); ::SetPixel( HDCDestination,PosY,PosX,color); } } } class image { public: ULONG_PTR m_gdiplusToken=NULL; Gdiplus::GdiplusStartupInput gdiplusStartupInput; Graphics *graphic=nullptr; Gdiplus::Bitmap *img; Pixel *pixel; HDC ImageHDC=NULL; int Width=0; int Height=0; HBITMAP hBitmap; void GetHDC(HDC &imgHDC) { imgHDC=graphic->GetHDC(); } void ReleaseHDC(HDC &imgHDC) { graphic->ReleaseHDC(imgHDC); } image() { GDI_Plus _ ; //nothing: } image(int SizeWidth, int SizeHeight) { GDI_Plus _ ; //New(SizeWidth, SizeHeight); } image(string strFile) { GDI_Plus _ ; FromFile(strFile); } void Clear(Color BackColor=Color::White) { SolidBrush *Fill=new SolidBrush(BackColor); graphic->FillRectangle(Fill,0,0,Width,Height); } void New(int Width, int Height,Color BackColor=Color::White) { Dispose(); img=new Gdiplus::Bitmap(Width, Height); graphic=new Gdiplus::Graphics(img); SolidBrush *Fill=new SolidBrush(BackColor); graphic->FillRectangle(Fill,0,0,Width,Height); //getting the hbitmap, hbitmapinfo and dibs\pixels: // pixels = (unsigned int*)malloc(Width*Height*sizeof(unsigned int)); Color clr(0x00,0x00,0x00); HBITMAP *hBitmap; //Gdiplus::Bitmap *img; img->GetHBITMAP(clr,hBitmap); DIBSECTION dibs; ::GetObject(hBitmap, sizeof(DIBSECTION), &dibs); BITMAPINFO bitinfo; ::GetObject(hBitmap, sizeof(BITMAPINFO), &bitinfo); // ::GetDIBits(graphic->GetHDC(), *hBitmap,0,0,&pixels,&bitinfo,dibs.dsBmih.biClrUsed); delete Fill; } void Dispose() { //clear all objects for avoid memory leaks: //by some reason, i can't delete the 'new' values: 'img' and 'graphic' //the program terminates with an exit error } ~image() { Dispose(); } void FromFile(string strFile) { //clean all objects.. here i must update it, but i need test an object before delete it: Dispose(); //Create a GDIPlus image: img =new Bitmap(towstring(strFile).c_str()); Width=img->GetWidth(); Height=img->GetHeight(); //Get Graphics from image: graphic= Graphics::FromImage(img); Gdiplus::Rect rect(0,0, img->GetWidth(), img->GetHeight()); Gdiplus::BitmapData data; auto status = img->LockBits(&rect, Gdiplus::ImageLockModeWrite, PixelFormat32bppARGB, &data); // 24 bit jpeg pixel = static_cast<Pixel*>(data.Scan0); img->UnlockBits(&data); int numPixels = img->GetWidth() * img->GetHeight(); //Create the HDC for draw the image: ImageHDC = CreateCompatibleDC(GetDC(NULL)); //Create the HBITMAP using the image size and pixels pointer: hBitmap=CreateBitmap(Width,Height,1,32,NULL); //Combine the HBITMAP the HDC: SelectObject(ImageHDC, hBitmap); //Get the Graphics from HDC and draw the image on HDC: Graphics *g; g=Graphics::FromHDC(ImageHDC); g->DrawImage(img,0,0); } void DrawImage(HDC DestinationHDC, int PosX=0, int PosY=0, COLORREF TransparentColor=RGB(0,0,0)) { TransparentBlt(DestinationHDC,0,0,Width,Height,ImageHDC,0,0,Width,Height,TransparentColor); } //Draw image pixel a pixel: void DrawImagePoint(HDC hdcDestination,point TopLeft,point TopRight,point BottomLeft,point BottomRight, angle angles={0,0,0}) { //Obter os pontos das 2 linhas verticais: //Getting the Points of a line: vector<point> LeftLine; LeftLine = GetPointsLine(TopLeft,BottomLeft); vector<point> RgihtLine; RgihtLine = GetPointsLine(TopRight,BottomRight); int pixelposition=0; int PosX=0; int PosY=0; int *DestinationPixels; GetPixelsFromHDC(hdcDestination, DestinationPixels); for( PosX=0; PosX<LeftLine.size()-1; PosX++) { //Calcular os pontos da linha horizontal usando os pontos das linha verticais vector<point> PixelLine; PixelLine=GetPointsLine(LeftLine[PosX], RgihtLine[PosX]); for ( PosY=0; PosY<PixelLine.size()-1; PosY++) { //Obter o ponto da recto Horizontal: point Point=PixelLine[PosY]; //Obter a cor do pixel: COLORREF clr; byte r =pixel->red; byte g = pixel->green; byte b=pixel->blue; byte a=pixel->alpha; clr=RGB(b,g,r) ; //se os pontos são 3D, temos de usar a perspectiva point eyepoint={250,150,300}; Point = perspective(Point,eyepoint); //Imprimir o pixel no Destino do HDC: DestinationPixels=clr; //::SetPixel(hdcDestination,PosY,PosX,clr); ++pixel; ++pixelposition; ++DestinationPixels; } } //in these case the pixelposition, is the last pixel position: for (int i=pixelposition; i!=0; i--) { --pixel; --DestinationPixels; } } }; int main() { //getting the HDC Console Window: HDC WindowHDC=GetDC(GetConsoleWindow()); image img("c:\\1595973613452.bmp"); point TopLeft={0, 0,0}; point TopRight={img.Width,0,0}; point BottomLeft={0,img.Height,0}; point BottomRight={img.Width,img.Height,0}; point RotationPoint={img.Width/2,img.Height/2,0}; angle d; do { d.y+=1; //TopLeft: point TopLeftRotated=RotationPoints2(TopLeft,d,RotationPoint); //TopRight: point TopRightRotated=RotationPoints2(TopRight,d,RotationPoint); //BottomLeft: point BottomLeftRotated=RotationPoints2(BottomLeft,d,RotationPoint); //BottomRight: point BottomRightRotated=RotationPoints2(BottomRight,d,RotationPoint); RECT f={0,0,1000,1000}; FillRect(WindowHDC,&f,(HBRUSH)(RGB(255,255,255))); img.DrawImagePoint(WindowHDC,TopLeftRotated,TopRightRotated,BottomLeftRotated,BottomRightRotated); Sleep(100); }while(!(GetKeyState(VK_ESCAPE) & 0x8000));//press escape for exit*/ cout<<"Press return to end . . ."<<endl; cin.get(); } está tudo num ficheiro. agora estou a testar para evitar o 'SetPixel()', mas estou sem resultados. talvez o erro seja na função 'GetPixelsFromHDC()', mas não sei. aceito mais dicas

Notei, mas mais tarde, 1 erro: BYTE Red = pixels[(PosX*Width+PosY) + 2]; // obtemos Red; Deveria ser: BYTE Red = * pixels[(PosX*Width+PosY) + 2]; // obtemos Red; O outro problema é que os 4 pontos podem ser uma figura maior ou menor do que a imagem. Logo tenho de actualizar isso e permitir usar uma cor transparente. Muito obrigado

ainda estou a testar e parece que tenho mais erros do que pensava a minha função de obter os pontos de 1 recta 3D(mesmo o Z sendo zero), está me a deixar doido depois voltarei com mais noticias resolvi porque no 'for' deveria ter: PosY<PixelLine.size()-1; agora estou a obter cores aleatorias.. eis como crio o HBITMAP: void FromFile(string strFile) { //Limpar todos os objectos: Dispose(); //Iniciar o GDIPlus: Gdiplus::GdiplusStartup(&m_gdiplusToken, &gdiplusStartupInput, NULL); //Criar 1 imagem GDIPlus: img =new Bitmap(towstring(strFile).c_str()); Width=img->GetWidth(); Height=img->GetHeight(); //Obter o Graphics da imagem: graphic= Graphics::FromImage(this->img); //Alterar o vector dos pixels com o tamanho da imagem: unsigned int* pixels = (unsigned int*)malloc(Width*Height*sizeof(unsigned int)); //Criar 1 HDC para desenhar a imagem: ImageHDC = CreateCompatibleDC(GetDC(NULL)); //Criar o HBITMAP com o tamanho e indicar o ponteiro dos pixels: hBitmap=CreateBitmap(Width,Height,1,32,pixels); //Combinar o HBITMAP com o HDC: SelectObject(ImageHDC, hBitmap); //obter o HDC do HBITMAP para desenhar a imagem do GDIPlus: Graphics *g; g=Graphics::FromHDC(ImageHDC); g->DrawImage(img,0,0); } eis como obtenho as cores: //Draw image pixel a pixel: void DrawImagePoint(HDC hdcDestination,point TopLeft,point TopRight,point BottomLeft,point BottomRight, angle angles={0,0,0}) { //Obter os pontos das 2 linhas verticais: //Getting the Points of a line: vector<point> LeftLine; LeftLine = GetPointsLine(TopLeft,BottomLeft); vector<point> RgihtLine; RgihtLine = GetPointsLine(TopRight,BottomRight); int pixelposition=0; for(int PosX=0; PosX<LeftLine.size()-1; PosX++) { //Calcular os pontos da linha horizontal usando os pontos das linha verticais vector<point> PixelLine; PixelLine=GetPointsLine(LeftLine[PosX], RgihtLine[PosX]); for (int PosY=0; PosY<PixelLine.size()-1; PosY++) { //Obter o ponto da recto Horizontal: point Point=PixelLine[PosY]; //Obter a cor do pixel: COLORREF clr; clr=pixels[pixelposition]; //se os pontos são 3D, temos de usar a perspectiva point eyepoint={250,150,300}; Point = perspective(Point,eyepoint); //Imprimir o pixel no Destino do HDC: ::SetPixel(hdcDestination,PosX,PosY,clr); pixelposition++; } //pixelposition++; } } resultado: o que estou a fazer errado para obter e usar os pixels?

boa noite. aqui está: image.h: #include <iostream> #include <string> #include <string.h> #include <windows.h> #include <math.h> #include <vector> #include <gdiplus.h> #include <stdlib.h> #include <algorithm> #include<thread> /*void foo(param) { // Do something } // The parameters to the function are put after the comma std::thread thread_obj(foo, params);*/ using namespace Gdiplus; using namespace std; const double PI = 3.14159265358979; struct { BITMAPINFOHEADER bmiHeader; RGBQUAD bmiColors[256]; } bmi; struct point { float x,y,z; } ; struct angle { float x,y,z; } ; //Convert the std::string to std::wstring: std::wstring towstring(const std::string& v) { std::wstring out(v.size()+1,L'\0'); int size = MultiByteToWideChar(CP_UTF8, 0, v.c_str(), -1, &out[0], out.size()); out.resize(size-1); return out; } class line { public: point OriginLine; point DestinationLine; line(point origin,point destination) { OriginLine=origin; DestinationLine=destination; } float GetLineLength(point p1,point p2) { return sqrt( (p1.x-p2.x)* (p1.x-p2.x) + (p1.y-p2.y)* (p1.y-p2.y) + (p1.z-p2.z)* (p1.z-p2.z)); } //Get Points Line: point lineto(point fp,point p,float length) { point res; float L=GetLineLength(fp,p); res.x=fp.x+length*(p.x-fp.x)/L; res.y=fp.y+length*(p.y-fp.y)/L; res.z=fp.z+length*(p.z-fp.z)/L; return res; } point perspective(const point &p,const point &eyepoint={250,150,300}) { float w=1+(p.z/eyepoint.z); return {(p.x-eyepoint.x)/w+eyepoint.x, (p.y-eyepoint.y)/w+eyepoint.y, (p.z-eyepoint.z)/w+eyepoint.z}; } vector<point> GetPointsLine() { point t=OriginLine; vector<point> coordenates; float dst=GetLineLength(OriginLine,DestinationLine); for (int i=0;i<=dst;i++) { t=lineto(t,DestinationLine,1); t=perspective(t); coordenates.push_back(t); } return coordenates; } }; POINT Convert3DTo2D(point Dot, int FocalDistance=100) { POINT ptDot; ptDot.x=Dot.x/Dot.z * FocalDistance; ptDot.y=Dot.y/Dot.z * FocalDistance; return ptDot; } class image { public: ULONG_PTR m_gdiplusToken=NULL; Gdiplus::GdiplusStartupInput gdiplusStartupInput; Graphics *graphic=nullptr; Gdiplus::Bitmap *img; unsigned int* pixels; HDC ImageHDC=NULL; int Width=0; int Height=0; HBITMAP hBitmap; void GetHDC(HDC &imgHDC) { imgHDC=graphic->GetHDC(); } void ReleaseHDC(HDC &imgHDC) { graphic->ReleaseHDC(imgHDC); } image() { //nothing: } /*image(int SizeWidth, int SizeHeight) { New(SizeWidth, SizeHeight); }*/ image(string strFile) { FromFile(strFile); } void Clear(Color BackColor=Color::White) { SolidBrush *Fill=new SolidBrush(BackColor); graphic->FillRectangle(Fill,0,0,Width,Height); } void New(int Width, int Height,Color BackColor=Color::White) { Dispose(); Gdiplus::GdiplusStartup(&m_gdiplusToken, &gdiplusStartupInput, NULL); img=new Gdiplus::Bitmap(Width, Height); graphic=new Gdiplus::Graphics(img); SolidBrush *Fill=new SolidBrush(BackColor); graphic->FillRectangle(Fill,0,0,Width,Height); //getting the hbitmap, hbitmapinfo and dibs\pixels: pixels = (unsigned int*)malloc(Width*Height*sizeof(unsigned int)); Color clr(0x00,0x00,0x00); HBITMAP *hBitmap; //Gdiplus::Bitmap *img; img->GetHBITMAP(clr,hBitmap); DIBSECTION dibs; ::GetObject(hBitmap, sizeof(DIBSECTION), &dibs); BITMAPINFO bitinfo; ::GetObject(hBitmap, sizeof(BITMAPINFO), &bitinfo); ::GetDIBits(graphic->GetHDC(), *hBitmap,0,0,&pixels,&bitinfo,dibs.dsBmih.biClrUsed); delete Fill; } void Dispose() { //clear all objects for avoid memory leaks: if(m_gdiplusToken) { Gdiplus::GdiplusShutdown(m_gdiplusToken); } //by some reason, i can't delete the 'new' values: 'img' and 'graphic' //the program terminates with an exit error } ~image() { Dispose(); } void FromFile(string strFile) { Dispose(); Gdiplus::GdiplusStartup(&m_gdiplusToken, &gdiplusStartupInput, NULL); img =new Bitmap(towstring(strFile).c_str()); Width=img->GetWidth(); Height=img->GetHeight(); graphic= Graphics::FromImage(this->img); //getting the hbitmap, hbitmapinfo and dibs\pixels: pixels = (unsigned int*)malloc(Width*Height*sizeof(unsigned int)); hBitmap= CreateBitmap(Width, Height, 1, 32, pixels); ImageHDC = CreateCompatibleDC(GetDC(NULL)); SelectObject(ImageHDC, hBitmap); Graphics *g; g=Graphics::FromHDC(ImageHDC); g->DrawImage(img,0,0); } void DrawImage(HDC DestinationHDC, int PosX=0, int PosY=0, COLORREF TransparentColor=RGB(0,0,0)) { TransparentBlt(DestinationHDC,0,0,Width,Height,ImageHDC,0,0,Width,Height,TransparentColor); } //Draw image pixel a pixel: void DrawImagePoint(HDC hdcDestination,point TopLeft,point TopRight,point BottomLeft,point BottomRight, angle angles={0,0,0}) { //Getting the Points of a line: vector<point> LeftLine; //TopLeft = RotationPoints(TopLeft,angles); //TopRight = RotationPoints(TopRight,angles); //BottomLeft = RotationPoints(BottomLeft,angles); //BottomRight = RotationPoints(BottomRight,angles); line LineLeft(TopLeft,BottomLeft); LeftLine = LineLeft.GetPointsLine(); vector<point> RgihtLine; line LineRight(TopRight,BottomRight); RgihtLine=LineRight.GetPointsLine(); for(int PosX=0; PosX<LeftLine.size(); PosX++) { vector<point> PixelLine; line LinePixel(LeftLine[PosX], RgihtLine[PosX]); PixelLine=LinePixel.GetPointsLine(); for (int PosY=0; PosY<PixelLine.size(); PosY++) { point Point=PixelLine[PosY]; //Get the pixel: COLORREF clr; BYTE Red = pixels[(PosX*Width+PosY) + 2]; // obtemos Red; BYTE Green = pixels[(PosX*Width+PosY) + 1]; // obtemos Green; BYTE Blue = pixels[(PosX*Width+PosY) + 0]; // obtemos Blue; BYTE Alpha = pixels[(PosX*Width+PosY) + 3]; // obtemos Alpha; clr=RGB(Blue, Green,Red); ::SetPixel(hdcDestination,PosY,PosX,clr); } } } }; main.cpp: #include <iostream> #include <string> #include <string.h> #include <windows.h> #include <math.h> #include <vector> #include <gdiplus.h> #include <stdlib.h> #include <algorithm> #include <thread> #include <future> #include "image.h" using namespace Gdiplus; using namespace std; /*const double PI = 3.14159265358979; struct point { float x,y,z; } ; struct angle { float x,y,z; } ;*/ point Convert3DTO2D(point Position, float FocalDistance=0.05) { point Point2D; Point2D.x=Position.x * FocalDistance/Position.z; Point2D.y=Position.y*FocalDistance/Position.z; return Point2D; } angle ConvertDegreesToRadians(angle Rotation) { double deg2Rad; deg2Rad = PI / 180; angle ConvertDegrees; ConvertDegrees.x = Rotation.x * deg2Rad; ConvertDegrees.y = Rotation.y * deg2Rad; ConvertDegrees.z = Rotation.z * deg2Rad; return ConvertDegrees; } point RotationPoints2(point Coordenate, const angle AngleCoordenate, const point pivot={0,0,0}) { angle radians= ConvertDegreesToRadians(AngleCoordenate); point RotatedPoint; RotatedPoint=Coordenate; Coordenate.x-=pivot.x; Coordenate.y-=pivot.y; Coordenate.z-=pivot.z; //First we rotate the Z: RotatedPoint.x=Coordenate.x * cos(AngleCoordenate.z)-Coordenate.y*sin(AngleCoordenate.z); RotatedPoint.y=Coordenate.x * sin(AngleCoordenate.z)+Coordenate.y*cos(AngleCoordenate.z); //RotatedPoint.z=Coordenate.z; //Second we rotate the Y: RotatedPoint.x=RotatedPoint.x * cos(AngleCoordenate.y)+RotatedPoint.z*sin(AngleCoordenate.y); //RotatedPoint.y=RotatedPoint.y; // pointless self assignemnt RotatedPoint.z=-RotatedPoint.x * sin(AngleCoordenate.y)+RotatedPoint.z*cos(AngleCoordenate.y); //Third we rotate the X: //RotatedPoint.x=RotatedPoint.x; // pointless self assignemnt RotatedPoint.y=RotatedPoint.y * cos(AngleCoordenate.x)-RotatedPoint.z*sin(AngleCoordenate.x); RotatedPoint.z=RotatedPoint.y * sin(AngleCoordenate.x)+RotatedPoint.z*cos(AngleCoordenate.x); RotatedPoint.x+=pivot.x; RotatedPoint.y+=pivot.y; RotatedPoint.z+=pivot.z; return RotatedPoint; } point RotationPoints(point pt, angle Angle, point pivot={0,0,0},point scale={1,1,1}) { angle radians= ConvertDegreesToRadians(Angle); Angle.x =radians.x; Angle.y =radians.y; Angle.z =radians.z; point p={pt.x-pivot.x,pt.y-pivot.y,pt.z-pivot.z}; point rot,temp; temp={(p.y)*cos(Angle.x)+(-p.z)*sin(Angle.x),(p.z)*cos(Angle.x)+(p.y)*sin(Angle.x)}; rot.y=temp.x;rot.z=temp.y; p.y = rot.y;p.z = rot.z; temp={(p.z)*cos(Angle.y)+(-p.x)*sin(Angle.y),(p.x)*cos(Angle.y)+(p.z)*sin(Angle.y)}; rot.z=temp.x;rot.x=temp.y; p.x=rot.x; temp={(p.x)*cos(Angle.z)+(-p.y)*sin(Angle.z),(p.y)*cos(Angle.z)+(p.x)*sin(Angle.z)}; rot.x=temp.x;rot.y=temp.y; return {(scale.x*rot.x+pivot.x),(scale.y*rot.y+pivot.y),(scale.z*rot.z+pivot.z)}; } float GetLineLength(point p1,point p2) { return sqrt( (p1.x-p2.x)* (p1.x-p2.x) + (p1.y-p2.y)* (p1.y-p2.y) + (p1.z-p2.z)* (p1.z-p2.z)); } //Get Points Line: point lineto(point fp,point p,float length) { point res; float L=GetLineLength(fp,p); res.x=fp.x+length*(p.x-fp.x)/L; res.y=fp.y+length*(p.y-fp.y)/L; res.z=fp.z+length*(p.z-fp.z)/L; return res; } vector<point> GetPointsLine(point origin,point destination) { point t=origin; vector<point> coordenates; float dst=GetLineLength(origin,destination); for (int i=0;i<=dst;i++) { t=lineto(t,destination,1); coordenates.push_back(t); } return coordenates; } point perspective(const point &p,const point &eyepoint) { float w=1+(p.z/eyepoint.z); return {(p.x-eyepoint.x)/w+eyepoint.x, (p.y-eyepoint.y)/w+eyepoint.y, (p.z-eyepoint.z)/w+eyepoint.z}; } //Draw a Line: void DrawLine(HDC WindowHDC,point origin,point destination,COLORREF color=RGB(0,0,255) ) { //for convert 3D to 2D we must: //have Focal Distance, in these case is 100 //float FocalDistance =100; //2D.X = 3D.X * FocalDistance / 3D.Z //2D.Y = 3D.Y * FocalDistance / 3D.Z //Getting the Points of a line: vector<point> coordenates; //origin.z=-origin.z; //destination.z=-destination.z; coordenates = GetPointsLine(origin,destination); point eyepoint={250,150,300}; //now we draw the line with a color and convert the 3D to 2D: for (point LinePoints:coordenates) { point p=perspective(LinePoints,eyepoint); //SetPixel(WindowHDC,p.x,p.y,color); std::thread thread_obj(SetPixel, WindowHDC,p.x,p.y,color); thread_obj.join(); } } void DrawRectangle(HDC WindowHDC,point Top, point Left, point Right, point Bottom,COLORREF color=RGB(255,0,0) ) { //for convert 3D to 2D we must: //have Focal Distance, in these case is 100 //2D.X = 3D.X * FocalDistance / 3D.Z //2D.Y = 3D.Y * FocalDistance / 3D.Z float FocalDistance =100; //Getting the Points of a line: vector<point> coordenates; /* coordenates = GetPointsLine(origin,destination); point eyepoint={250,150,300}; //now we draw the line with a color and convert the 3D to 2D: for (point LinePoints:coordenates) { point p=Convert3DTO2D(LinePoints); //perspective(LinePoints,eyepoint); SetPixel(WindowHDC,p.x,p.y,color); }*/ } //Draw an Image: void DrawImage(HDC HDCWindow,point corners[4], HDC HDCOrigin, int PosX, int PosY, int Width, int Height) { POINT ImageCordeners[3]; //Move Top-Left Corner: ImageCordeners[0].x=corners[0].x; ImageCordeners[0].y=corners[0].y; //Move Top-Right Corner: ImageCordeners[1].x=corners[1].x; ImageCordeners[1].y=corners[1].y; ////Move the Bottom-Right Corner: ImageCordeners[2].x=corners[2].x; ImageCordeners[2].y=corners[2].y; PlgBlt(HDCWindow,ImageCordeners,HDCOrigin,PosX,PosY,Width,Height,NULL,0,0); } //Draw image pixel a pixel: void DrawImagePoint(HDC HDCDestination,HDC HDCOrigin, point TopLeft,point TopRight,point BottomLeft,point BottomRight) { //Getting the Points of a line: vector<point> LeftLine; LeftLine = GetPointsLine(TopLeft,BottomLeft); vector<point> RgihtLine; RgihtLine = GetPointsLine(TopRight,BottomRight); for(int PosX=0; PosX<LeftLine.size(); PosX++) { vector<point> PixelLine; PixelLine=GetPointsLine(LeftLine[PosX], RgihtLine[PosX]); for (int PosY=0; PosY<PixelLine.size(); PosY++) { point Point=PixelLine[PosY]; COLORREF color; color=::GetPixel(HDCOrigin,PosY+800,PosX); ::SetPixel( HDCDestination,PosY,PosX,color); } } } int main() { //getting the HDC Console Window: HDC WindowHDC=GetDC(GetConsoleWindow()); point TopLeft={100, 200,0}; point TopRight={200,200,0}; point BottomLeft={100,300,0}; point BottomRight={200,300,0}; point RotationPoint={250,150,0};//center of rectangle angle angles; image img("c:\\1595973613452.bmp"); RECT a; a.left=0; a.right=800; a.top=0; a.bottom=800; do { //angles.x+=0.1; //TopLeft: point TopLeftRotated=TopLeft;//RotationPoints(TopLeft,{angles.x,angles.y,angles.z},RotationPoint); //TopRight: point TopRightRotated=TopRight;//RotationPoints(TopRight,{angles.x,angles.y,angles.z},RotationPoint); //BottomLeft: point BottomLeftRotated=BottomLeft;//RotationPoints(BottomLeft,{angles.x,angles.y,angles.z},RotationPoint); //BottomRight: point BottomRightRotated=BottomRight;//RotationPoints(BottomRight,{angles.x,angles.y,angles.z},RotationPoint); img.DrawImagePoint(WindowHDC,TopLeft,TopRight,BottomLeft,BottomRight); Sleep(100); //FillRect(WindowHDC,&a, CreateSolidBrush(RGB(0,0,0))); }while(!(GetKeyState(VK_ESCAPE) & 0x8000));//press escape for exit cout<<"Press return to end . . ."<<endl; cin.get(); } eis as opções\comandos no compilador: -fpermissive -std=c++0x -pthread -Ofast e as librarias adicionadas: \libgdi32.a \libgdiplus.a \libmsimg32.a (a \libmsimg32.a é para usar a função TransparentBlt()) resultado: esse rectangulo é o tamanho da imagem... mas estou a perder as cores? o problema será aqui? hBitmap= CreateBitmap(Width, Height, 1, 32, pixels); ou como obtenho as cores? //Draw image pixel a pixel: void DrawImagePoint(HDC hdcDestination,point TopLeft,point TopRight,point BottomLeft,point BottomRight, angle angles={0,0,0}) { //Getting the Points of a line: vector<point> LeftLine; //TopLeft = RotationPoints(TopLeft,angles); //TopRight = RotationPoints(TopRight,angles); //BottomLeft = RotationPoints(BottomLeft,angles); //BottomRight = RotationPoints(BottomRight,angles); line LineLeft(TopLeft,BottomLeft); LeftLine = LineLeft.GetPointsLine(); vector<point> RgihtLine; line LineRight(TopRight,BottomRight); RgihtLine=LineRight.GetPointsLine(); for(int PosX=0; PosX<LeftLine.size(); PosX++) { vector<point> PixelLine; line LinePixel(LeftLine[PosX], RgihtLine[PosX]); PixelLine=LinePixel.GetPointsLine(); for (int PosY=0; PosY<PixelLine.size(); PosY++) { point Point=PixelLine[PosY]; //Get the pixel: COLORREF clr; BYTE Red = pixels[(PosX*Width+PosY) + 2]; // obtemos Red; BYTE Green = pixels[(PosX*Width+PosY) + 1]; // obtemos Green; BYTE Blue = pixels[(PosX*Width+PosY) + 0]; // obtemos Blue; BYTE Alpha = pixels[(PosX*Width+PosY) + 3]; // obtemos Alpha; clr=RGB(Blue, Green,Red); ::SetPixel(hdcDestination,PosY,PosX,clr); } } }

@devair1010 uso CodeBlocks com GNU/GCC. Mais logo posto o código todinho

olhe uma coisa: eu preciso de evitar os memory leaks.. isso é normal. para evitar isso: tenho de deletar o objecto HBITMAP antes de o criar... como o testo para o deletar? será: if(HBitmap) DeleteObject(HBitmap); ??? o mesmo vai para os outros objectos também prontos actualizei 1 pouco a minha classe image: #include <iostream> #include <string> #include <string.h> #include <windows.h> #include <math.h> #include <vector> #include <gdiplus.h> #include <stdlib.h> #include <algorithm> #include<thread> /*void foo(param) { // Do something } // The parameters to the function are put after the comma std::thread thread_obj(foo, params);*/ using namespace Gdiplus; using namespace std; const double PI = 3.14159265358979; struct point { float x,y,z; } ; struct angle { float x,y,z; } ; //Convert the std::string to std::wstring: std::wstring towstring(const std::string& v) { std::wstring out(v.size()+1,L'\0'); int size = MultiByteToWideChar(CP_UTF8, 0, v.c_str(), -1, &out[0], out.size()); out.resize(size-1); return out; } class line { public: point OriginLine; point DestinationLine; line(point origin,point destination) { OriginLine=origin; DestinationLine=destination; } float GetLineLength(point p1,point p2) { return sqrt( (p1.x-p2.x)* (p1.x-p2.x) + (p1.y-p2.y)* (p1.y-p2.y) + (p1.z-p2.z)* (p1.z-p2.z)); } //Get Points Line: point lineto(point fp,point p,float length) { point res; float L=GetLineLength(fp,p); res.x=fp.x+length*(p.x-fp.x)/L; res.y=fp.y+length*(p.y-fp.y)/L; res.z=fp.z+length*(p.z-fp.z)/L; return res; } point perspective(const point &p,const point &eyepoint={250,150,300}) { float w=1+(p.z/eyepoint.z); return {(p.x-eyepoint.x)/w+eyepoint.x, (p.y-eyepoint.y)/w+eyepoint.y, (p.z-eyepoint.z)/w+eyepoint.z}; } vector<point> GetPointsLine() { point t=OriginLine; vector<point> coordenates; float dst=GetLineLength(OriginLine,DestinationLine); for (int i=0;i<=dst;i++) { t=lineto(t,DestinationLine,1); t=perspective(t); coordenates.push_back(t); } return coordenates; } }; POINT Convert3DTo2D(point Dot, int FocalDistance=100) { POINT ptDot; ptDot.x=Dot.x/Dot.z * FocalDistance; ptDot.y=Dot.y/Dot.z * FocalDistance; return ptDot; } class image { public: ULONG_PTR m_gdiplusToken=NULL; Gdiplus::GdiplusStartupInput gdiplusStartupInput; Graphics *graphic=nullptr; Gdiplus::Bitmap *img; unsigned int* pixels; HDC ImageHDC=NULL; int Width=0; int Height=0; HBITMAP hBitmap; void GetHDC(HDC &imgHDC) { imgHDC=graphic->GetHDC(); } void ReleaseHDC(HDC &imgHDC) { graphic->ReleaseHDC(imgHDC); } image() { //nothing: } /*image(int SizeWidth, int SizeHeight) { New(SizeWidth, SizeHeight); }*/ image(string strFile) { FromFile(strFile); } void Clear(Color BackColor=Color::White) { SolidBrush *Fill=new SolidBrush(BackColor); graphic->FillRectangle(Fill,0,0,Width,Height); } void New(int Width, int Height,Color BackColor=Color::White) { Dispose(); Gdiplus::GdiplusStartup(&m_gdiplusToken, &gdiplusStartupInput, NULL); img=new Gdiplus::Bitmap(Width, Height); graphic=new Gdiplus::Graphics(img); SolidBrush *Fill=new SolidBrush(BackColor); graphic->FillRectangle(Fill,0,0,Width,Height); //getting the hbitmap, hbitmapinfo and dibs\pixels: pixels = (unsigned int*)malloc(Width*Height*sizeof(unsigned int)); Color clr(0x00,0x00,0x00); HBITMAP *hBitmap; //Gdiplus::Bitmap *img; img->GetHBITMAP(clr,hBitmap); DIBSECTION dibs; ::GetObject(hBitmap, sizeof(DIBSECTION), &dibs); BITMAPINFO bitinfo; ::GetObject(hBitmap, sizeof(BITMAPINFO), &bitinfo); ::GetDIBits(graphic->GetHDC(), *hBitmap,0,0,&pixels,&bitinfo,dibs.dsBmih.biClrUsed); delete Fill; } void Dispose() { //clear all objects for avoid memory leaks: if(m_gdiplusToken) { Gdiplus::GdiplusShutdown(m_gdiplusToken); } //by some reason, i can't delete the 'new' values: 'img' and 'graphic' //the program terminates with an exit error } ~image() { Dispose(); } void FromFile(string strFile) { Dispose(); Gdiplus::GdiplusStartup(&m_gdiplusToken, &gdiplusStartupInput, NULL); img =new Bitmap(towstring(strFile).c_str()); Width=img->GetWidth(); Height=img->GetHeight(); graphic= Graphics::FromImage(this->img); //getting the hbitmap, hbitmapinfo and dibs\pixels: pixels = (unsigned int*)malloc(Width*Height*sizeof(unsigned int)); hBitmap= CreateBitmap(Width, Height, 1, 32, pixels); ImageHDC = CreateCompatibleDC(GetDC(NULL)); SelectObject(ImageHDC, hBitmap); Graphics *g; g=Graphics::FromHDC(ImageHDC); g->DrawImage(img,0,0); } void DrawImage(HDC DestinationHDC, int PosX=0, int PosY=0, COLORREF TransparentColor=RGB(0,0,0)) { TransparentBlt(DestinationHDC,0,0,Width,Height,ImageHDC,0,0,Width,Height,TransparentColor); } //Draw image pixel a pixel: void DrawImagePoint(HDC hdcDestination,point TopLeft,point TopRight,point BottomLeft,point BottomRight, angle angles={0,0,0}) { //Getting the Points of a line: vector<point> LeftLine; //TopLeft = RotationPoints(TopLeft,angles); //TopRight = RotationPoints(TopRight,angles); //BottomLeft = RotationPoints(BottomLeft,angles); //BottomRight = RotationPoints(BottomRight,angles); line LineLeft(TopLeft,BottomLeft); LeftLine = LineLeft.GetPointsLine(); vector<point> RgihtLine; line LineRight(TopRight,BottomRight); RgihtLine=LineRight.GetPointsLine(); for(int PosX=0; PosX<LeftLine.size(); PosX++) { vector<point> PixelLine; line LinePixel(LeftLine[PosX], RgihtLine[PosX]); PixelLine=LinePixel.GetPointsLine(); for (int PosY=0; PosY<PixelLine.size(); PosY++) { point Point=PixelLine[PosY]; //Get the pixel: COLORREF clr; BYTE Red = pixels[(PosX*Width+PosY) + 2]; // obtemos Red; BYTE Green = pixels[(PosX*Width+PosY) + 1]; // obtemos Green; BYTE Blue = pixels[(PosX*Width+PosY) + 0]; // obtemos Blue; BYTE Alpha = pixels[(PosX*Width+PosY) + 3]; // obtemos Alpha; clr=RGB(Red, Green,Blue); ::SetPixel(hdcDestination,PosY,PosX,clr); } } } }; como a uso: int main() { //getting the HDC Console Window: HDC WindowHDC=GetDC(GetConsoleWindow()); point TopLeft={100, 200,0}; point TopRight={200,200,0}; point BottomLeft={100,300,0}; point BottomRight={200,300,0}; point RotationPoint={250,150,0};//center of rectangle angle angles; image img("c:\\1595973613452.bmp"); RECT a; a.left=0; a.right=800; a.top=0; a.bottom=800; do { //angles.x+=0.1; //TopLeft: point TopLeftRotated=TopLeft;//RotationPoints(TopLeft,{angles.x,angles.y,angles.z},RotationPoint); //TopRight: point TopRightRotated=TopRight;//RotationPoints(TopRight,{angles.x,angles.y,angles.z},RotationPoint); //BottomLeft: point BottomLeftRotated=BottomLeft;//RotationPoints(BottomLeft,{angles.x,angles.y,angles.z},RotationPoint); //BottomRight: point BottomRightRotated=BottomRight;//RotationPoints(BottomRight,{angles.x,angles.y,angles.z},RotationPoint); img.DrawImage(WindowHDC); Sleep(100); FillRect(WindowHDC,&a, CreateSolidBrush(RGB(0,0,0))); }while(!(GetKeyState(VK_ESCAPE) & 0x8000));//press escape for exit cout<<"Press return to end . . ."<<endl; cin.get(); } a imagem é mostrada... agora estou a ver se o pixels for mesmo criado correctamente: void FromFile(string strFile) { Dispose(); Gdiplus::GdiplusStartup(&m_gdiplusToken, &gdiplusStartupInput, NULL); img =new Bitmap(towstring(strFile).c_str()); Width=img->GetWidth(); Height=img->GetHeight(); graphic= Graphics::FromImage(this->img); //getting the hbitmap, hbitmapinfo and dibs\pixels: pixels = (unsigned int*)malloc(Width*Height*sizeof(unsigned int)); hBitmap= CreateBitmap(Width, Height, 1, 32, pixels); ImageHDC = CreateCompatibleDC(GetDC(NULL)); SelectObject(ImageHDC, hBitmap); Graphics *g; g=Graphics::FromHDC(ImageHDC); g->DrawImage(img,0,0); } aqui mostra normal: void DrawImage(HDC DestinationHDC, int PosX=0, int PosY=0, COLORREF TransparentColor=RGB(0,0,0)) { TransparentBlt(DestinationHDC,0,0,Width,Height,ImageHDC,0,0,Width,Height,TransparentColor); } mas aqui não obtenho as cores mas vou simplificar esta função: //Draw image pixel a pixel: void DrawImagePoint(HDC hdcDestination,point TopLeft,point TopRight,point BottomLeft,point BottomRight, angle angles={0,0,0}) { //Getting the Points of a line: vector<point> LeftLine; //TopLeft = RotationPoints(TopLeft,angles); //TopRight = RotationPoints(TopRight,angles); //BottomLeft = RotationPoints(BottomLeft,angles); //BottomRight = RotationPoints(BottomRight,angles); line LineLeft(TopLeft,BottomLeft); LeftLine = LineLeft.GetPointsLine(); vector<point> RgihtLine; line LineRight(TopRight,BottomRight); RgihtLine=LineRight.GetPointsLine(); for(int PosX=0; PosX<LeftLine.size(); PosX++) { vector<point> PixelLine; line LinePixel(LeftLine[PosX], RgihtLine[PosX]); PixelLine=LinePixel.GetPointsLine(); for (int PosY=0; PosY<PixelLine.size(); PosY++) { point Point=PixelLine[PosY]; //Get the pixel: COLORREF clr; BYTE Red = pixels[(PosX*Width+PosY) + 2]; // obtemos Red; BYTE Green = pixels[(PosX*Width+PosY) + 1]; // obtemos Green; BYTE Blue = pixels[(PosX*Width+PosY) + 0]; // obtemos Blue; BYTE Alpha = pixels[(PosX*Width+PosY) + 3]; // obtemos Alpha; clr=RGB(Red, Green,Blue); ::SetPixel(hdcDestination,PosY,PosX,clr); } } } simplifiquei a função ao máximo para testar: //Draw image pixel a pixel: void DrawImagePoint(HDC hdcDestination) { //Obter o HBITMAP de um HDC: HBITMAP hBmp = reinterpret_cast<HBITMAP>(GetCurrentObject(hdcDestination, OBJ_BITMAP)); //Obter o BITMAPINFOHEADER do HBITMAP e os pixels: memset(&bmi, 0, sizeof(bmi)); bmi.bmiHeader.biSize = sizeof(BITMAPINFOHEADER); unsigned int*pixels2 = (unsigned int*)malloc(Width*Height*sizeof(unsigned int)); GetDIBits(hdcDestination, hBmp, 0, 1, pixels2, (BITMAPINFO *)&bmi, DIB_RGB_COLORS); //obter o tamanho do array: int pixelscount=Width*Height*sizeof(unsigned int); for(int i=0; i<pixelscount; i++) { //copiar a imagem origem para o HDC destino: pixels2[i]=pixels[i]; } } após execução, eu obtenho 1 erro: fiz mais testes e o 'pixelscount' está mal calculado eu meti 300 para testar e não tenho pixels o que estou a fazer errado?

como funciona a minha classe image e desenhar a imagem: 1 - posso criar 1 image usando um tamanho ou 1 ficheiro; 2 - para ler um ficheiro, eu uso as funções GDIPlus; 3 - para criar 1 imagem, posso usar funções GDI; 3 - poder desenhar a imagem em qualquer HDC ou isso usando os 4 cantos; 4 - a rotação não posso usar a mesma função, porque tenho de usar 1 posição 3D(se for 2D, o Z é zero). correcções: 1 - ao usar a 'malloc()', tenho de usar a 'free()'? 2 - ao reutilizar a 'malloc()' tenho de usar o 'new'? tenho de rever a minha função\classe toda para poder fazer a diferença... depois voltarei.. muito obrigado por tudo

por favor verifique o post anterior que fiz\actualizei

estou a tentar a fazer a actualização: void New(int Width, int Height,Color BackColor=Color::White) { Dispose(); Gdiplus::GdiplusStartup(&m_gdiplusToken, &gdiplusStartupInput, NULL); img=new Gdiplus::Bitmap(Width, Height); graphic=new Gdiplus::Graphics(img); SolidBrush *Fill=new SolidBrush(BackColor); graphic->FillRectangle(Fill,0,0,Width,Height); //getting the hbitmap, hbitmapinfo and dibs\pixels: pixels = (unsigned int*)malloc(Width*Height*sizeof(unsigned int)); Color clr(0x00,0x00,0x00); HBITMAP hBitmap; Bitmap->GetHBITMAP(clr,&hBitmap); DIBSECTION dibs; ::GetObject(hBitmap, sizeof(DIBSECTION), &dibs); ::GetDIBits(graphic->GetHDC(), hBitmap,0,0,&pixels,hBitmap,dibs.dsBmih.biClrUsed); delete Fill; } na linha: Bitmap->GetHBITMAP(clr,hBitmap); tenho erros: "error: expected unqualified-id before '->' token" noutra linha tenho: "error: cannot convert 'HBITMAP__**' to 'HBITMAP' {aka 'HBITMAP__*'}" qual é o meu erro? sim não notei 1 erro e ja resolvi: era 'img' e não 'Bitmap'. tinha mais1 erro, mas resolvi. eis com leio 1 ficheiro de imagem: void FromFile(string strFile) { Dispose(); Gdiplus::GdiplusStartup(&m_gdiplusToken, &gdiplusStartupInput, NULL); img =new Bitmap(towstring(strFile).c_str()); Width=img->GetWidth(); Height=img->GetHeight(); graphic= Graphics::FromImage(this->img); //getting the hbitmap, hbitmapinfo and dibs\pixels: pixels = (unsigned int*)malloc(Width*Height*sizeof(unsigned int)); Color clr(0x00,0x00,0x00); HBITMAP *hBitmap; //Gdiplus::Bitmap *img; img->GetHBITMAP(clr,hBitmap); DIBSECTION dibs; ::GetObject(hBitmap, sizeof(DIBSECTION), &dibs); BITMAPINFO bitinfo; ::GetObject(hBitmap, sizeof(BITMAPINFO), &bitinfo); ::GetDIBits(graphic->GetHDC(), *hBitmap,0,0,&pixels,&bitinfo,dibs.dsBmih.biClrUsed); } o compilador não me dá erro... mas mesmo assim ao executar tenho este erro: "Process returned -1073741819 (0xC0000005) execution time : 0.830 s Press any key to continue." o que estou a fazer de errado com o codigo? sim estou a combinar o GDIPLUS(para ler os ficheiros) e GDI para imprimir

@Lucca Rodrigues for(int PixelPosition=0; PixelPosition<PixelsCount; PixelPosition+=4) { byte Red = PixelPosition[(PixelPositionY*ImageWidth+PixelPositionX) + 2]; // obtemos Red; byte Green = PixelPosition[(PixelPositionY*ImageWidth+PixelPositionX) + 1]; // obtemos Green; byte Blue = PixelPosition[(PixelPositionY*ImageWidth+PixelPositionX) + 0]; // obtemos Blue; byte Alpha = PixelPosition[(PixelPositionY*ImageWidth+PixelPositionX) + 3]; // obtemos Alpha; } está correcto?

você utiliza um loop com step de 4 e: (Y*width+X) + 2 : obtemos Red; (Y*width+X) + 1 : obtemos Green; (Y*width+X) + 0 : obtemos Blue; (Y*width+X) + 3 : obtemos Alpha; certo?

@Lucca Rodrigues se eu precisar de um pixel especifico, nesse loop, como posso obter o pixel usando x e y?

1 - você usou o ponteiro 'pixels'... pode mostrar o loop para obter o RGB ou mesmo a cor(COLORREF)? 2 - você acha que o problema está aqui ou tenho de otimizar melhor as outras funções?

voltando um pouco atrás: o problema está mesmo no SetPixel() e GetPixel() ou também na divisão GetPointsLine()? eu sei que o SetPixel() e GetPixel() são lentos... se calhar tenho mesmo de usar DIB's. mas mesmo assim gostava de saber onde está a consumo maximo do tempo

Rodar uma imagem usando X, Y e Z. Mas tenho de usar a perspectiva. Não posso usar o BitBlt() para isso

#include <iostream> #include <string> #include <string.h> #include <windows.h> #include <math.h> #include <vector> #include <gdiplus.h> #include <stdlib.h> #include <algorithm> #include <thread> #include <future> #include "image.h" using namespace Gdiplus; using namespace std; /*const double PI = 3.14159265358979; struct point { float x,y,z; } ; struct angle { float x,y,z; } ;*/ point Convert3DTO2D(point Position, float FocalDistance=0.05) { point Point2D; Point2D.x=Position.x * FocalDistance/Position.z; Point2D.y=Position.y*FocalDistance/Position.z; return Point2D; } angle ConvertDegreesToRadians(angle Rotation) { double deg2Rad; deg2Rad = PI / 180; angle ConvertDegrees; ConvertDegrees.x = Rotation.x * deg2Rad; ConvertDegrees.y = Rotation.y * deg2Rad; ConvertDegrees.z = Rotation.z * deg2Rad; return ConvertDegrees; } point RotationPoints2(point Coordenate, const angle AngleCoordenate, const point pivot={0,0,0}) { angle radians= ConvertDegreesToRadians(AngleCoordenate); point RotatedPoint; RotatedPoint=Coordenate; Coordenate.x-=pivot.x; Coordenate.y-=pivot.y; Coordenate.z-=pivot.z; //First we rotate the Z: RotatedPoint.x=Coordenate.x * cos(AngleCoordenate.z)-Coordenate.y*sin(AngleCoordenate.z); RotatedPoint.y=Coordenate.x * sin(AngleCoordenate.z)+Coordenate.y*cos(AngleCoordenate.z); //RotatedPoint.z=Coordenate.z; //Second we rotate the Y: RotatedPoint.x=RotatedPoint.x * cos(AngleCoordenate.y)+RotatedPoint.z*sin(AngleCoordenate.y); //RotatedPoint.y=RotatedPoint.y; // pointless self assignemnt RotatedPoint.z=-RotatedPoint.x * sin(AngleCoordenate.y)+RotatedPoint.z*cos(AngleCoordenate.y); //Third we rotate the X: //RotatedPoint.x=RotatedPoint.x; // pointless self assignemnt RotatedPoint.y=RotatedPoint.y * cos(AngleCoordenate.x)-RotatedPoint.z*sin(AngleCoordenate.x); RotatedPoint.z=RotatedPoint.y * sin(AngleCoordenate.x)+RotatedPoint.z*cos(AngleCoordenate.x); RotatedPoint.x+=pivot.x; RotatedPoint.y+=pivot.y; RotatedPoint.z+=pivot.z; return RotatedPoint; } point RotationPoints(point pt, angle Angle, point pivot={0,0,0},point scale={1,1,1}) { angle radians= ConvertDegreesToRadians(Angle); Angle.x =radians.x; Angle.y =radians.y; Angle.z =radians.z; point p={pt.x-pivot.x,pt.y-pivot.y,pt.z-pivot.z}; point rot,temp; temp={(p.y)*cos(Angle.x)+(-p.z)*sin(Angle.x),(p.z)*cos(Angle.x)+(p.y)*sin(Angle.x)}; rot.y=temp.x;rot.z=temp.y; p.y = rot.y;p.z = rot.z; temp={(p.z)*cos(Angle.y)+(-p.x)*sin(Angle.y),(p.x)*cos(Angle.y)+(p.z)*sin(Angle.y)}; rot.z=temp.x;rot.x=temp.y; p.x=rot.x; temp={(p.x)*cos(Angle.z)+(-p.y)*sin(Angle.z),(p.y)*cos(Angle.z)+(p.x)*sin(Angle.z)}; rot.x=temp.x;rot.y=temp.y; return {(scale.x*rot.x+pivot.x),(scale.y*rot.y+pivot.y),(scale.z*rot.z+pivot.z)}; } float GetLineLength(point p1,point p2) { return sqrt( (p1.x-p2.x)* (p1.x-p2.x) + (p1.y-p2.y)* (p1.y-p2.y) + (p1.z-p2.z)* (p1.z-p2.z)); } //Get Points Line: point lineto(point fp,point p,float length) { point res; float L=GetLineLength(fp,p); res.x=fp.x+length*(p.x-fp.x)/L; res.y=fp.y+length*(p.y-fp.y)/L; res.z=fp.z+length*(p.z-fp.z)/L; return res; } vector<point> GetPointsLine(point origin,point destination) { point t=origin; vector<point> coordenates; float dst=GetLineLength(origin,destination); for (int i=0;i<=dst;i++) { t=lineto(t,destination,1); coordenates.push_back(t); } return coordenates; } point perspective(const point &p,const point &eyepoint) { float w=1+(p.z/eyepoint.z); return {(p.x-eyepoint.x)/w+eyepoint.x, (p.y-eyepoint.y)/w+eyepoint.y, (p.z-eyepoint.z)/w+eyepoint.z}; } //Draw a Line: void DrawLine(HDC WindowHDC,point origin,point destination,COLORREF color=RGB(0,0,255) ) { //for convert 3D to 2D we must: //have Focal Distance, in these case is 100 //float FocalDistance =100; //2D.X = 3D.X * FocalDistance / 3D.Z //2D.Y = 3D.Y * FocalDistance / 3D.Z //Getting the Points of a line: vector<point> coordenates; //origin.z=-origin.z; //destination.z=-destination.z; coordenates = GetPointsLine(origin,destination); point eyepoint={250,150,300}; //now we draw the line with a color and convert the 3D to 2D: for (point LinePoints:coordenates) { point p=perspective(LinePoints,eyepoint); //SetPixel(WindowHDC,p.x,p.y,color); std::thread thread_obj(SetPixel, WindowHDC,p.x,p.y,color); thread_obj.join(); } } void DrawRectangle(HDC WindowHDC,point Top, point Left, point Right, point Bottom,COLORREF color=RGB(255,0,0) ) { //for convert 3D to 2D we must: //have Focal Distance, in these case is 100 //2D.X = 3D.X * FocalDistance / 3D.Z //2D.Y = 3D.Y * FocalDistance / 3D.Z float FocalDistance =100; //Getting the Points of a line: vector<point> coordenates; /* coordenates = GetPointsLine(origin,destination); point eyepoint={250,150,300}; //now we draw the line with a color and convert the 3D to 2D: for (point LinePoints:coordenates) { point p=Convert3DTO2D(LinePoints); //perspective(LinePoints,eyepoint); SetPixel(WindowHDC,p.x,p.y,color); }*/ } //Draw an Image: void DrawImage(HDC HDCWindow,point corners[4], HDC HDCOrigin, int PosX, int PosY, int Width, int Height) { POINT ImageCordeners[3]; //Move Top-Left Corner: ImageCordeners[0].x=corners[0].x; ImageCordeners[0].y=corners[0].y; //Move Top-Right Corner: ImageCordeners[1].x=corners[1].x; ImageCordeners[1].y=corners[1].y; ////Move the Bottom-Right Corner: ImageCordeners[2].x=corners[2].x; ImageCordeners[2].y=corners[2].y; PlgBlt(HDCWindow,ImageCordeners,HDCOrigin,PosX,PosY,Width,Height,NULL,0,0); } //Draw image pixel a pixel: void DrawImagePoint(HDC HDCDestination,HDC HDCOrigin, point TopLeft,point TopRight,point BottomLeft,point BottomRight) { //Getting the Points of a line: vector<point> LeftLine; LeftLine = GetPointsLine(TopLeft,BottomLeft); vector<point> RgihtLine; RgihtLine = GetPointsLine(TopRight,BottomRight); for(int PosX=0; PosX<LeftLine.size(); PosX++) { vector<point> PixelLine; PixelLine=GetPointsLine(LeftLine[PosX], RgihtLine[PosX]); for (int PosY=0; PosY<PixelLine.size(); PosY++) { point Point=PixelLine[PosY]; COLORREF color; color=::GetPixel(HDCOrigin,PosY+800,PosX); ::SetPixel( HDCDestination,PosY,PosX,color); } } } int main() { //getting the HDC Console Window: HDC WindowHDC=GetDC(GetConsoleWindow()); point TopLeft={100, 200,0}; point TopRight={200,200,0}; point BottomLeft={100,300,0}; point BottomRight={200,300,0}; point RotationPoint={250,150,0};//center of rectangle angle angles; image img("c:\\test.jpg"); img.DrawImage(WindowHDC,800,0); RECT a; a.left=0; a.right=800; a.top=0; a.bottom=800; do { //angles.x+=0.1; //TopLeft: point TopLeftRotated=TopLeft;//RotationPoints(TopLeft,{angles.x,angles.y,angles.z},RotationPoint); //TopRight: point TopRightRotated=TopRight;//RotationPoints(TopRight,{angles.x,angles.y,angles.z},RotationPoint); //BottomLeft: point BottomLeftRotated=BottomLeft;//RotationPoints(BottomLeft,{angles.x,angles.y,angles.z},RotationPoint); //BottomRight: point BottomRightRotated=BottomRight;//RotationPoints(BottomRight,{angles.x,angles.y,angles.z},RotationPoint); DrawImagePoint(WindowHDC,WindowHDC,TopLeftRotated,TopRightRotated,BottomLeftRotated, BottomRightRotated); Sleep(100); FillRect(WindowHDC,&a, CreateSolidBrush(RGB(0,0,0))); }while(!(GetKeyState(VK_ESCAPE) & 0x8000));//press escape for exit cout<<"Press return to end . . ."<<endl; cin.get(); } image.h: #include <iostream> #include <string> #include <string.h> #include <windows.h> #include <math.h> #include <vector> #include <gdiplus.h> #include <stdlib.h> #include <algorithm> #include<thread> /*void foo(param) { // Do something } // The parameters to the function are put after the comma std::thread thread_obj(foo, params);*/ using namespace Gdiplus; using namespace std; const double PI = 3.14159265358979; struct point { float x,y,z; } ; struct angle { float x,y,z; } ; //Convert the std::string to std::wstring: std::wstring towstring(const std::string& v) { std::wstring out(v.size()+1,L'\0'); int size = MultiByteToWideChar(CP_UTF8, 0, v.c_str(), -1, &out[0], out.size()); out.resize(size-1); return out; } class line { public: point OriginLine; point DestinationLine; line(point origin,point destination) { OriginLine=origin; DestinationLine=destination; } float GetLineLength(point p1,point p2) { return sqrt( (p1.x-p2.x)* (p1.x-p2.x) + (p1.y-p2.y)* (p1.y-p2.y) + (p1.z-p2.z)* (p1.z-p2.z)); } //Get Points Line: point lineto(point fp,point p,float length) { point res; float L=GetLineLength(fp,p); res.x=fp.x+length*(p.x-fp.x)/L; res.y=fp.y+length*(p.y-fp.y)/L; res.z=fp.z+length*(p.z-fp.z)/L; return res; } point perspective(const point &p,const point &eyepoint={250,150,300}) { float w=1+(p.z/eyepoint.z); return {(p.x-eyepoint.x)/w+eyepoint.x, (p.y-eyepoint.y)/w+eyepoint.y, (p.z-eyepoint.z)/w+eyepoint.z}; } vector<point> GetPointsLine() { point t=OriginLine; vector<point> coordenates; float dst=GetLineLength(OriginLine,DestinationLine); for (int i=0;i<=dst;i++) { t=lineto(t,DestinationLine,1); t=perspective(t); coordenates.push_back(t); } return coordenates; } }; POINT Convert3DTo2D(point Dot, int FocalDistance=100) { POINT ptDot; ptDot.x=Dot.x/Dot.z * FocalDistance; ptDot.y=Dot.y/Dot.z * FocalDistance; } class image { public: ULONG_PTR m_gdiplusToken=NULL; Gdiplus::GdiplusStartupInput gdiplusStartupInput; Graphics *graphic=nullptr; Gdiplus::Bitmap *img; HDC ImageHDC=NULL; int Width=0; int Height=0; void GetHDC(HDC &imgHDC) { imgHDC=graphic->GetHDC(); } void ReleaseHDC(HDC &imgHDC) { graphic->ReleaseHDC(imgHDC); } COLORREF GetPixel(int PosX, int PosY) { Color clr; img->GetPixel(PosX, PosY, &clr); return clr.ToCOLORREF(); } void SetPixel(int PosX, int PosY, COLORREF color) { Color *clr; clr->SetFromCOLORREF(color); img->SetPixel(PosX, PosY,clr); } image() { //nothing: } image(int SizeWidth, int SizeHeight) { New(SizeWidth, SizeHeight); } image(string strFile) { FromFile(strFile); } void Clear(Color BackColor=Color::White) { SolidBrush *Fill=new SolidBrush(BackColor); graphic->FillRectangle(Fill,0,0,Width,Height); } void New(int Width, int Height,Color BackColor=Color::White) { Dispose(); Gdiplus::GdiplusStartup(&m_gdiplusToken, &gdiplusStartupInput, NULL); img=new Gdiplus::Bitmap(Width, Height); graphic=new Gdiplus::Graphics(img); SolidBrush *Fill=new SolidBrush(BackColor); graphic->FillRectangle(Fill,0,0,Width,Height); delete Fill; } void Dispose() { //clear all objects for avoid memory leaks: if(m_gdiplusToken) { Gdiplus::GdiplusShutdown(m_gdiplusToken); } //by some reason, i can't delete the 'new' values: 'img' and 'graphic' //the program terminates with an exit error } ~image() { Dispose(); } void FromFile(string strFile) { Dispose(); Gdiplus::GdiplusStartup(&m_gdiplusToken, &gdiplusStartupInput, NULL); img =new Bitmap(towstring(strFile).c_str()); Width=img->GetWidth(); Height=img->GetHeight(); graphic= Graphics::FromImage(this->img); } void DrawImage(HDC DestinationHDC, float PosX, float PosY) { if(!img || !m_gdiplusToken) return; Gdiplus::Graphics graphics2(DestinationHDC); graphics2.DrawImage(img , PosX, PosY, img->GetWidth(), img->GetHeight()); } void DrawImage(Graphics *Destination, float PosX, float PosY) { if(!img || !m_gdiplusToken) return; Destination->DrawImage(img, PosX, PosY, img->GetWidth(), img->GetHeight()); } //Draw image pixel a pixel: void DrawImagePoint(HDC hdcDestination,point TopLeft,point TopRight,point BottomLeft,point BottomRight, angle angles={0,0,0}) { //Getting the Points of a line: vector<point> LeftLine; //TopLeft = RotationPoints(TopLeft,angles); //TopRight = RotationPoints(TopRight,angles); //BottomLeft = RotationPoints(BottomLeft,angles); //BottomRight = RotationPoints(BottomRight,angles); line LineLeft(TopLeft,BottomLeft); LeftLine = LineLeft.GetPointsLine(); vector<point> RgihtLine; line LineRight(TopRight,BottomRight); RgihtLine=LineRight.GetPointsLine(); for(int PosX=0; PosX<LeftLine.size(); PosX++) { vector<point> PixelLine; line LinePixel(LeftLine[PosX], RgihtLine[PosX]); PixelLine=LinePixel.GetPointsLine(); for (int PosY=0; PosY<PixelLine.size(); PosY++) { point Point=PixelLine[PosY]; Color color; img->GetPixel(PosY+800,PosX,&color); COLORREF clr =color.ToCOLORREF(); ::SetPixel(hdcDestination,PosY,PosX,clr); } } } }; este codigo faz o que preciso: desenha 1 imagem pixel a pixel... mas preciso de velocidade... então queria ver como posso ganhar mais velocidade... nem 1 frame por segundo consigo e é só 1 imagem... imagine várias

Otimizar, penso, é evitar duplicar o código e tentar evitar muito consumo do CPU. Mas quais são os passos gerais para Otimizar uma função? Eu fiz uma função mas usa muito CPU, está lento.... gostava de entender como aumentar a velocidade da função