Работа с отдельными пикселями

BITMAPINFO bmi;
  ZeroMemory(&bmi, sizeof(BITMAPINFOHEADER));
 
  bmi.bmiHeader.biSize        = sizeof(BITMAPINFOHEADER);
  bmi.bmiHeader.biWidth       = 620;
  bmi.bmiHeader.biHeight      = 200;
  bmi.bmiHeader.biPlanes      = 1;
  bmi.bmiHeader.biCompression = BI_RGB;
  bmi.bmiHeader.biBitCount    = 32;
 
  DWORD *bitmapBits;
  HBITMAP bitmap = CreateDIBSection(txDC(), &bmi, DIB_RGB_COLORS, (void**)&bitmapBits, 0, 0);
Win32::SelectObject(txDC(), bitmap);
 
for (long int i1 = 0; i1<64000l; i1++){
 bitmapBits[i1] = RGB(140,2,1);
}
 
 
SetDIBitsToDevice(txDC(),0,0,320,200,0,0,  0,0,bitmapBits,&bmi,DIB_RGB_COLORS);

#include<stdio.h>
#include<math.h>
#include<conio.h>
#include <gdiplus.h>
#include<Graphics.h>
 
 
#include<time.h>
int printtime(){int tit=clock () / CLOCKS_PER_SEC;printf("\n t=%d",tit);} /// В общем понятно. Мелкая функция для вывода на экран времени после старта программы
 
int drawBMP_xxx(const int x1,const int y1,const int dx,const int dy,const char* name,const int regim,const int zerkalo,const double arg1,const double arg2,const double arg3,const double arg4,const double arg5,const double arg6,const double arg7,const double arg8,const double arg9){
/// Аргументы функции
//// x1,y1 - начало куда рисовать
/// dx dy - желаемый размер картинки
/// regim режим. Есть 0 - ничего особого, 1 - перекраска пикселя по матрице преобразования цветов при помощи getpixel setpixel (работает но с тормозами) и 2 - попытка сделать тоже самое при помощи DBI (Пока абсолютно не работает)
/// zerkalo если ненулевое, то картинка будет "отражена в зеркале"
/// arg1  и далее - матрица перекодирования цвета. Разумеется в таком виде не очень удобно, но интерфейс позже, пока с Ядром проблемы....
wchar_t buffer4[1000];
double cf[3][3]={{arg1,arg2,arg3},{arg4,arg5,arg6},{arg7,arg8,arg9}}; /// Матрица аргументов для преобразования цветов
static HDC htest=txCreateCompatibleDC(1024,768); /// Один раз за программу статически создаем буферный hdc
 
for(int kk=0;kk<1000;kk++){buffer4[kk]=0;}
for(int i=0;i<1000;i++){
 int v=name[i];buffer4[i]=v;if(v==0){break;}
} /// Криво, но думаю надежно преобразуем простое имя файла в формат, который принимает конструктор объекта Gdiplus::Image
 
txBitBlt(htest,0,0,dx,dy,txDC(),x1,y1); //// Копируем ту область экрана, на которой надо нарисовать, в буфер
 
 
 
Gdiplus::Graphics graphics(htest); /// Создаем "рисовалку" gdi+ чтобы она рисовала в буфер
Gdiplus::Image* m_pImage=NULL;
m_pImage=new Gdiplus::Image(buffer4); /// Загружаем из файла картинку в объект gdi+
 
if(zerkalo){m_pImage->RotateFlip(Gdiplus::Rotate180FlipY );}  /// Если задано зеркало - при помощи собственной функции gdi+ отражаем в зеркале
 
 
Gdiplus::Rect rc(0,0,dx,dy); ///Прямоугольник куда рисовать. Рисуем в начало буфера по выбранным размерам
graphics.DrawImage(                m_pImage,                        // [in] Gdiplus::Image object
     rc                                // [in] Position and dimensions
     );  //////// Рисуем загруженную картинку gdi+ в буферный hdc
if(regim==0){} /// В нулевом режиме ничего не делаем, картинка уже какая надо.
 
 
if(regim==1){
 for(int i=0;i<dx;i++){for(int j=0;j<dy;j++){
  COLORREF c_buf=Win32::GetPixel(htest,i,j);
 int r =(BYTE)(c_buf>>0);
int g = (BYTE)(c_buf>>8);
int    b = (BYTE)(c_buf>>16);
Win32::SetPixel(htest,i,j,RGB(cf[0][0]*r+cf[0][1]*g+cf[0][2]*b,cf[1][0]*r+cf[1][1]*g+cf[1][2]*b,cf[2][0]*r+cf[2][1]*g+cf[2][2]*b));
 
/// При помощи примитивной попиксельной работы с GetPixel получаем цвет каждого пикселя, раскодирывем его , преобразуем по матрице и снова рисуем.
 
}}
}
 
 
if(regim==2){
///// Пробуем работать с DIBSextion  ПОКА НЕ РАБОТАЕТ!!!
BITMAPINFO bmi;
 ZeroMemory(&bmi, sizeof(BITMAPINFOHEADER));
 
  bmi.bmiHeader.biSize        = sizeof(BITMAPINFOHEADER);
  bmi.bmiHeader.biWidth       = dx;
  bmi.bmiHeader.biHeight      = -dy;
  bmi.bmiHeader.biPlanes      = 1;
  bmi.bmiHeader.biCompression = BI_RGB;
  bmi.bmiHeader.biBitCount    = 32;
 
  DWORD *bitmapBits;
  HBITMAP bitmap = CreateDIBSection(htest, &bmi, DIB_RGB_COLORS, (void**)&bitmapBits, 0, 0);
Win32::SelectObject(htest, bitmap);
/* Пока ничего не делаем, по идее должна создаваться секция на основе htest и снова рисоваться на htest , то есть внешне ничего не происходить. Но создается секция заполненная нулями!
for (long int i1 = 0; i1<64000l; i1++){
///// bitmapBits[i1] = RGB(140,2,1);
}*/
 
 
SetDIBitsToDevice(htest,0,0,dx,dy,0,0,  0,0,bitmapBits,&bmi,DIB_RGB_COLORS);
 
 
 
}
 
 
txBitBlt(txDC(),x1,y1,dx,dy,htest,0,0); /// выводим выведенную в буфер и обработанную картинку окончательно на экран
delete(m_pImage); /// не мусорим gdi+ объектами, культурно удаляем
}
 
 
 
 
 
 
 
 
 
 
 
 
int main(){
 
int gd,gm;
initgraph(&gd,&gm,""); /// Извратная инициализация полноэкранной графики
 
{
{
Gdiplus::GdiplusStartupInput gdiplusStartupInput; 
ULONG_PTR gdiplusToken; 
GdiplusStartup(&gdiplusToken, &gdiplusStartupInput, NULL);
} //// Инициализация gdi+
 
 
}
 
cleardevice();
 
for(int k=0;k<50;k++){
 
drawBMP_xxx(100,0,676,600,"Tigre039.jpg",1,0, 0,0,0 ,0.5,0.5,0.5, 0.5,0.5,0.5); /// Красим картинку в циан
drawBMP_xxx(800,0,676,600,"Tigre039.jpg",1,1, 0.33,0.33,0.33, 0.33,0.33,0.33, 0.33,0.33,0.33); //// Просто в черно-белый
printf("\n k=%d",k);printtime(); ////Показываем на экране сколько раз уже вывелось и время прошедшее с начала запуска программы
 
/////Выводим картинки много раз циклом для тестирования времени работы
}
 
getch();
 
 
 
}

#include <iostream>
#include <stdio.h>
#include <Windows.h>
#include <d3d9.h>
#include <d3dx9tex.h>
 
#pragma comment(lib,"d3dx9.lib")
#pragma comment(lib,"d3d9.lib")
 
 
int main()
{
    IDirect3D9 *g_pD3D;
    HWND hWnd;
    
    IDirect3DDevice9 *g_pd3dDevice;
    IDirect3DSurface9 *pSurface;
    D3DDISPLAYMODE d3ddm;
    D3DPRESENT_PARAMETERS d3dpp;
    D3DSURFACE_DESC surfaceDesc;
    D3DLOCKED_RECT lockedRect;
 
    hWnd = GetConsoleWindow();
 
    if((g_pD3D = Direct3DCreate9(D3D_SDK_VERSION)) == NULL) {
     printf("fail 1");
    }
    if(FAILED(g_pD3D->GetAdapterDisplayMode(D3DADAPTER_DEFAULT, &d3ddm))) {
    printf("fail 2");
    }
    ZeroMemory(&d3dpp, sizeof(D3DPRESENT_PARAMETERS));
 
    d3dpp.Windowed = TRUE;
    d3dpp.SwapEffect = D3DSWAPEFFECT_DISCARD;
    d3dpp.BackBufferFormat = d3ddm.Format;
    d3dpp.BackBufferHeight = d3ddm.Height;
    d3dpp.BackBufferWidth = d3ddm.Width;
 
 
    if(FAILED(g_pD3D->CreateDevice(D3DADAPTER_DEFAULT,
                               D3DDEVTYPE_HAL, hWnd,
                               D3DCREATE_SOFTWARE_VERTEXPROCESSING,
                               &d3dpp, &g_pd3dDevice))) {
    printf("fail 3");
    }
    
    if(FAILED(g_pd3dDevice->CreateOffscreenPlainSurface(d3ddm.Width, d3ddm.Height,
        D3DFMT_A8R8G8B8, D3DPOOL_SCRATCH, &pSurface, NULL)))
    {
        printf("fail 4");
    }
    ///////////////////////////////////////////////////////////////////////////////////////
    g_pd3dDevice->GetFrontBufferData(0, pSurface);
    pSurface->GetDesc(&surfaceDesc);
    pSurface->LockRect(&lockedRect, 0, 0);
 
    DWORD* imageData = (DWORD*)lockedRect.pBits;
 
    for(int i = 0; i < surfaceDesc.Height; i++)
    {
        for(int j = 0; j < surfaceDesc.Width; j++)
        {
        // индекс в текстуре, обратите внимание, что мы используем шаг и
        // делим его на 4, поскольку шаг задается в байтах,
        // а каждый пиксель занимает 4 байта.
            int index = i * lockedRect.Pitch / 4 + j;
            imageData[index] = 0xffff0000; // красный цвет
        }
    }
 
    pSurface->UnlockRect();
    ///////////////////////////////////////////////////////////////////////////////////////
    D3DXSaveSurfaceToFile(L"Desktop.bmp",D3DXIFF_BMP,pSurface,NULL,NULL);
    pSurface->Release(); 
 
    return 0;
}