[C++] Rilevare colore di pixel attraverso DirectX o con interfacciamento diretto

[MItaly]

Puoi riportare di preciso il testo dell'esercizio?

[kirakira93]

OK
Questo è quanto:
"Nella cartella Vacanze2009" che troverete nel disco che vi ho consegnato troverete il file "Esercizio8.exe". Avviate tale file e comparirà una finestra dove vedrete dei pixel di vario colore in movimento seguendo coordinate casuali. Mediante un'applicazione di windows utilizzando dev-c++ scrivete un codice sorgente che analizza tutti i pixel dello schermo mediante un ciclo che viene richiamato più volte al secondo e che dura complessivamente 15 secondi.
Inoltre a seconda che il numero del colore sia:
- <10 000 000: fate in modo che il mouse clicchi sul pixel 800-790;
- >=10 000 000 e: <=16777216 fate in modo che il mouse clicchi su un pixel random (=rand()%x) dell'aplicazione Esercizio8.exe;

Utilizzare risoluzione 1280x800 e modalità 16 milioni di colori.

Punteggio totale della prova se corretta: 56.

Per chi on possedesse un pc di queste potenzialità è pregato di......"

Ecco il testo sulla scheda che mi ha consegnato.
In 3 giorni ho scritto tutto il codice sorgente, l'unico problema è appunto che la funzione getpixel è troppo lenta, mi basta solo cambiarla e tutto va a meraviglia.

E visto che il prof assegna 56 punti a chi riesce a svolgere la prova (gli altri es. ne dannno al massimo 16) diciamo che ci tengo molto a portarla a termine e poi visto che mi manka così poco...

Mi potresti postare il codice sorgente della funzione per analizzare i pixel per piacere.
Sono disperato



P.S. a chi ha inventato la funzione getpixel.....

[MItaly]

Guarda che secondo me anche solo semplicemente facendo così (come spiegato nel primo post)

HDC hdcScreen = GetDC(0);
for(int t=0;t<40000;t++)
{
    for(int X=0;X<1280;X++)
    {
        /* ... */
        for(int Y=0;Y<800;Y++)
        {
            COLORREF colore = GetPixel(hdcScreen, X, Y);
            /* ... */
        }
    }
    /* ... */
}
ReleaseDC(0, hdcScreen);

miglioreresti le prestazioni in maniera notevolissima, dal momento che in quel ciclo l'operazione di gran lunga più lenta è l'acquisizione e il rilascio del DC.

P.S. a chi ha inventato la funzione getpixel.....

Credo che questo risponderebbe

a chi non sa usare le funzioni GDI e acquisisce e rilascia 40000*1280*800=40960000000 (40 miliardi e 960 milioni) di volte un device context quando basterebbe acquisirlo all'inizio di tutto e rilasciarlo alla fine...

Tra l'altro comunque è più che normale che la GetPixel sia lenta... hai idea della complicazione che ci sta dietro alla GDI? Ogni singola chiamata a GetPixel deve passare da user mode a kernel mode (e solo il trapping nel kernel consuma centinaia di migliaia di cicli di CPU), e la GetPixel in questione deve essere in grado di darti il colore RGB di un pixel del dispositivo collegato a qualunque DC, che internamente potrebbe memorizzare il colore nella maniera più astrusa (tripletta RGB, COLORREF, indice in una tabella di colori RGB o in modi ancora più esotici).
La morale è: se ti sembra che il codice di libreria sia troppo lento, probabilmente lo stai usando in modo sbagliato.

[kirakira93]

Grazie per la risposta. Ho provato a fare come hai detto te ma purtroppo non va.
In un post precedente hai detto:

sarebbe copiare con una BitBlt il contenuto del buffer dello schermo in una dibsection creata all'avvio del programma, e quindi controllare il contenuto della dibsection accedendo ai pixel direttamente

ce l'avresti 1 sorgente che utilizza questo?


E inoltre in 1 forum inglese ho postato il sorgente che ho postato anke a te e mi ha risp:

It's a wrong method.
You must use DIBs (see win32 ng http://tinyurl.com/cmhb5g for classic C code (MS))

Traduzione:
E' 1 metodo sbagliato
Devi usare DIBs (Guarda win32 ng http://tinyurl.com/cmhb5g per il classico sorgente per il C (MS))

Ho provato a guardare ma ho capito meno di niente.


Ti prego aiutami.......

[MItaly]

Originariamente inviato da kirakira93
Grazie per la risposta. Ho provato a fare come hai detto te ma purtroppo non va.

Non va in che senso?

sarebbe copiare con una BitBlt il contenuto del buffer dello schermo in una dibsection creata all'avvio del programma, e quindi controllare il contenuto della dibsection accedendo ai pixel direttamente

ce l'avresti 1 sorgente che utilizza questo?

Ho lì un'intera classe DibSection che ho scritto per altri motivi con diversi metodi per ottenere i valori dei pixel in maniera molto efficiente, ma se è per scuola mi pare che così sarebbe barare...

E inoltre in 1 forum inglese ho postato il sorgente che ho postato anke a te e mi ha risp:

It's a wrong method.
You must use DIBs (see win32 ng http://tinyurl.com/cmhb5g for classic C code (MS))

La traduzione corretta è
[quote]
Devi usare le DIB (dai un'occhiata al newsgroup win32 http://tinyurl.com/cmhb5g per (=se ti serve?) codice in C classico (MS).

Comunque è esttamente quello che ti ho detto io; devi:

1. crearti una DibSection (CreateDIBSection) delle dimensioni dello schermo;
2. creare un DC in memoria (CreateCompatibleDC) e selezionarci dentro la DibSection (SelectObject);
3. copiare nel DC il contenuto dello schermo (BitBlt);
4. esaminare il contenuto della DibSection direttamente (CreateDIBSection fornisce un puntatore ai dati della DibSection al momento della creazione)
5. alla fine di tutto elimini il DC (DeleteDC) e la DibSection (DeleteObject).

[kirakira93]

Grazie però non è che potresti rifilarmi il sorgente perchè così non è che capisco moltissimo....

[MItaly]

Senti, ti ho detto esattamente tutti i passaggi che devi fare, citandoti addirittura le funzioni che devi impiegare; ora, il fatto che tu abbia risposto circa un minuto dopo che ho postato io mi fa pensare che tu non abbia nemmeno guardato la documentazione delle funzioni in questione.
Ti invito quindi nuovamente - e questa volta esplicitamente - a guardare la documentazione delle funzioni citate e le specifiche delle DIB, dove puoi vedere come sono memorizzati i dati nel blocco di memoria che ti indica CreateDIBSection.

[kirakira93]

Provo a fare come dici te

[kirakira93]

Ecco quello che sono riuscito a fare.
Da ieri sera ad ora ho provato a fare quello che mi hai detto tu e visto che non sono molto pratico di funzioni ho modificato ile esistenti e dopo 3 ore di lavoro ho concluso questo sorgente(k viene compilato ma non si esegue)



#include <stdio.h>
#include <windows.h>

DWORD error=0;

BOOL main( )
{
int nWidth=2;

int nHeight=2;


HDC memDC = CreateCompatibleDC(NULL);

BITMAPINFO i;
ZeroMemory(&i.bmiHeader, sizeof(BITMAPINFOHEADER) );

//--------------------------------------------------------------------

RGBTRIPLE *lprgbSrc1, *lprgbSrc2, *lprgbDst;
DWORD dwWidthBytes, dwWeight2;
int x, y;

int dwSourceWeight;

/* // Only values between 0 and 255 are valid.
if (dwWeight1 > 255) return FALSE;

// Get weighting value for second source image.
dwWeight2 = 255-dwWeight1;
*/
lprgbSrc1 = (RGBTRIPLE *)memDC/* .bmBits */;
lprgbSrc2 = (RGBTRIPLE *)memDC;
lprgbDst = (RGBTRIPLE *)memDC/* bmDst.bmBits */;

int a,b,c;

lprgbSrc1 = (RGBTRIPLE *)((LPBYTE)lprgbSrc1 + dwWidthBytes);

for ( y=1; y<80; y++) {MessageBox(NULL, "a", "GREEN", 0);
for ( x=1; x<128; x++) {MessageBox(NULL, "b", "GREEN", 0);
lprgbDst[x].rgbtRed = MessageBox(NULL, "c1", "GREEN", 0);


a=/*((*/((BYTE) lprgbSrc1[x].rgbtRed )/** dwWeight1*/ /*+
((DWORD)lprgbSrc2[x].rgbtRed * dwWeight2)) >> 8)*/;


lprgbDst[x].rgbtGreen = MessageBox(NULL, "c2", "GREEN", 0);
b=(/*((*/(BYTE)lprgbSrc1[x].rgbtGreen /** dwWeight1*/) /*+
((DWORD)lprgbSrc2[x].rgbtGreen * dwWeight2)) >> 8)*/;
lprgbDst[x].rgbtBlue =
c=(/*((*/(BYTE)lprgbSrc1[x].rgbtBlue /** dwWeight1*/)/* +
((DWORD)lprgbSrc2[x].rgbtBlue * dwWeight2)) >> 8)*/;

MessageBox(NULL, "c", "GREEN", 0);
}

MessageBox(NULL, "d", "GREEN", 0);
lprgbSrc1 = (RGBTRIPLE *)((LPBYTE)lprgbSrc1 + dwWidthBytes);
lprgbSrc2 = (RGBTRIPLE *)((LPBYTE)lprgbSrc2 + dwWidthBytes);
lprgbDst = (RGBTRIPLE *)((LPBYTE)lprgbDst + dwWidthBytes);


//--------------------------------------------------------------------
VOID *pvBits;
MessageBox(NULL, "e", "GREEN", 0);
error=0;
HBITMAP h = CreateDIBSection(memDC, &i, DIB_RGB_COLORS, &pvBits, NULL, 0);
error=GetLastError();
if (h==NULL)
{
DeleteDC(memDC);
return 1;
}
DeleteObject(h);
DeleteDC(memDC);
return 0;
}
}


Cos'è che non va??????

E' giusto quello che ho fatto.
Non sono riuscito a creare bitblt quindi visto k tu sei più bravo mi potrsti aiutare te che tutta oggi e ieri che fallisco???

[MItaly]

Tutta la parte centrale non ha senso: che senso ha cercare di esaminare i pixel prima ancora che la DibSection sia creata, prima ancora che contenga qualcosa e soprattutto cercando di convertire un DC (che dovresti sapere che è una struttura dati opaca) in un array di byte?
Lo scheletro di codice da cui devi partire è qualcosa del genere:

// Rappresenta un pixel in una DIB a 24 bpp
struct DIB24BPPPixel
{
    BYTE Blue;
    BYTE Green;
    BYTE Red;
};
try
{
    // I device context
    HDC dibDC=NULL, screenDC=NULL;
    // Larghezza e altezza dello schermo (e di conseguenza della DIB)
    LONG width, height;
    // Bitmap selezionata all'inizio in dibDC, DIB Section
    HBITMAP oldBmp=NULL, dibSection=NULL;
    // Puntatore ai dati della DIB
    LPBYTE dibBits=NULL;
    // Struttura utilizzata per inizializzare la DIB
    BITMAPINFO bi={0};
    // Lunghezza di una riga della DIB in byte;  ci torna utile averlo pronto visto che le righe devono essere allineate a 32 bit
    size_t bytesPerLine=0;
    // Ottiene le dimensioni dello schermo
    width = (LONG) GetSystemMetrics(SM_CXFULLSCREEN);
    height = (LONG) GetSystemMetrics(SM_CYFULLSCREEN);
    // Calcola la lunghezza di una riga della DIB
    bytesPerLine = ((width * 24 + 31) & (~31)) / 8;
    // Ottiene l'handle al DC dello schermo
    screenDC = GetDC(0)
    if(screenDC == NULL)
        throw std::runtime_error("Impossibile ottenere il DC dello schermo; GetDC ha restituito NULL.");
    // Inizializza i dati della DIB
    bi.bmiHeader.biSize=sizeof(bi.bmiHeader);
    bi.bmiHeader.biWidth=width;
    bi.bmiHeader.biHeight=height;
    bi.bmiHeader.biPlanes=1;
    bi.bmiHeader.biBitCount=24; /* per semplicità usiamo una DIB a 24 bpp qualunque sia la profondità di colore dello schermo */
    bi.bmiHeader.biCompression=BI_RGB;
    // Crea la DIB section
    dibSection=CreateDIBSection(NULL, &bi, DIB_RGB_COLORS, (LPVOID *)&dibBits, NULL, 0);
    if(dibSection == NULL)
        throw std::runtime_error("Impossibile creare la DibSection; CreateDIBSection ha restituito NULL.");
    // Crea il DC
    dibDC = CreateCompatibleDC(NULL);
    if(dibDC == NULL)
        throw std::runtime_error("Impossibile creare il device context; CreateCompatibleDC ha restituito NULL.");
    // Seleziona la DIB section nel DC e salva la bitmap di default attualmente contenuta nel DC
    oldBmp = SelectObject(dibDC, dibSection);
    for(/* bla bla bla */)
    {
        // Ciclo da ripetere per ogni controllo dello schermo
        // Copia il contenuto dello schermo nella DIB section
        BitBlt(dibDC, 0,0, width, height, screenDC, 0, 0, SRCCOPY);
        // Qui controlla i pixel della DIB
        for(int y=0; y<height; y++)
        {
            // Ottiene un puntatore al primo pixel della riga
            DIB24BPPPixel * rowPtr = (DIB24BPPPixel *) (dibBits+(height-1-y)*bytesPerLine);
            for(int x=0; x<width; x++)
            {
                // Verifica il colore del pixel
                // Esempio:
                if(rowPtr[x].Red==255 && rowPtr[x].Green==0 && rowPtr[x].Blue==0)
                {
                    //Il pixel è rosso
                }
            }
        }
        Sleep(/* valore che ritieni più opportuno */);
        /* bla bla bla */
    }
    // Cleanup
    ReleaseDC(screenDC);
    SelectObject(dibDC, oldBmp);
    DeleteDC(dibDC);
    DeleteObject(dibSection);
}
catch(...)
{
    // Cleanup in caso di errore
    if(screenDC != NULL)
        ReleaseDC(screenDC);
    if(dibDC != NULL)
    {
        SelectObject(dibDC, oldBmp);
        DeleteDC(dibDC);
    }
    if(dibSection != NULL)
        DeleteObject(dibSection);
    // Propaga l'eccezione
    throw;
}

Attenzione, codice non collaudato. Se esplode tutto non mi ritengo responsabile.