immagine colorata in scala di grigi usando elaborazione parallela CUDA

Question

Sto cercando di risolvere un problema in cui dovrei cambiare un'immagine a colori in un'immagine in scala di grigi. Per questo scopo sto usando un approccio parallelo CUDA.

Il codice kerne che sto invocando sulla GPU è il seguente.

__global__ 
void rgba_to_greyscale(const uchar4* const rgbaImage, 
        unsigned char* const greyImage, 
        int numRows, int numCols) 
{ 
    int absolute_image_position_x = blockIdx.x; 
    int absolute_image_position_y = blockIdx.y; 

    if (absolute_image_position_x >= numCols || 
    absolute_image_position_y >= numRows) 
{ 
    return; 
} 
uchar4 rgba = rgbaImage[absolute_image_position_x + absolute_image_position_y]; 
float channelSum = .299f * rgba.x + .587f * rgba.y + .114f * rgba.z; 
greyImage[absolute_image_position_x + absolute_image_position_y] = channelSum; 

} 

void your_rgba_to_greyscale(const uchar4 * const h_rgbaImage, 
          uchar4 * const d_rgbaImage, 
          unsigned char* const d_greyImage, 
          size_t numRows, 
          size_t numCols) 
{ 
    //You must fill in the correct sizes for the blockSize and gridSize 
    //currently only one block with one thread is being launched 
    const dim3 blockSize(numCols/32, numCols/32 , 1); //TODO 
    const dim3 gridSize(numRows/12, numRows/12 , 1); //TODO 
    rgba_to_greyscale<<<gridSize, blockSize>>>(d_rgbaImage, 
              d_greyImage, 
              numRows, 
              numCols); 

    cudaDeviceSynchronize(); checkCudaErrors(cudaGetLastError()); 
} 

vedo una linea di punti nella prima riga di pixel.

errore sto ottenendo è errore

libdc1394: Impossibile inizializzare libdc1394
di differenza al pos 51 supera tolleranza del 5
Riferimento: 255
GPU: 0
my input/output images Qualcuno mi può aiutare con questo ??? Grazie in anticipo.

Answer 1

Ora, da quando ho postato questa domanda ho lavorato costantemente su questo problema
ci sono un paio di miglioramenti che dovrebbero essere fatti al fine di ottenere questo problema corretto ora mi rendo conto della mia soluzione iniziale era sbagliata .
modifiche da compiere: -

1. absolute_position_x =(blockIdx.x * blockDim.x) + threadIdx.x; 
2. absolute_position_y = (blockIdx.y * blockDim.y) + threadIdx.y; 

secondo luogo,

1. const dim3 blockSize(24, 24, 1); 
2. const dim3 gridSize((numCols/16), (numRows/16) , 1); 

Nella soluzione stiamo usando una griglia di numColonne/16 * numColonne/16
e del blocco di 24 * 24

codice eseguito in 0,040576 ms

@datenwolf: grazie per aver risposto sopra !!!

Answer 2

libdc1394 error: Failed to initialize libdc1394

Non credo che questo sia un problema CUDA. libdc1394 è una libreria utilizzata per accedere ai dispositivi video IEEE1394 aka FireWire o iLink (videocamere DV, fotocamera Apple iSight). Quella libreria non viene inizializzata correttamente, quindi non ottieni risultati utili. Fondamentalmente è NINO: Nonsens In Nonsens Out.

Answer 3

Si esegue seguente numero di blocchi e griglie:

const dim3 blockSize(numCols/32, numCols/32 , 1); //TODO 
    const dim3 gridSize(numRows/12, numRows/12 , 1); //TODO 

ancora non si utilizza qualsiasi thread nel codice del kernel!

int absolute_image_position_x = blockIdx.x; 
int absolute_image_position_y = blockIdx.y; 

pensare questo modo, la larghezza di un'immagine può essere dividere in absolute_image_position_x parti della colonna e l'altezza di un'immagine può essere dividere in absolute_image_position_y parti della fila. Ora il riquadro di ciascuna sezione trasversale che crea è necessario modificare/ridisegnare tutti i pixel in termini di greyImage, in parallelo. Abbastanza spoiler per un incarico :)

Answer 4

il calcolo di x assoluto x & posizioni di immagine è perfetto. ma quando hai bisogno di accedere a quel particolare pixel dell'immagine colorata, non dovresti usare il seguente codice ??

uchar4 rgba = rgbaImage[absolute_image_position_x + (absolute_image_position_y * numCols)]; 

ho pensato così, quando si confrontano a un codice che ci scrive per eseguire lo stesso problema in codice seriale. Per favore fatemi sapere :)

Answer 5

Si dovrebbe ancora avere un problema con il tempo di esecuzione - la conversione non darà un risultato corretto.

Le linee:

1. uchar4 RGBA = rgbaImage [absolute_image_position_x + absolute_image_position_y];
2. greyImmagine [absolute_image_position_x + absolute_image_position_y] = channelSum;

dovrebbe essere cambiata a:

1. uchar4 rgba = rgbaImage [absolute_image_position_x + absolute_image_position_y * numColonne];
2. greyImmagine [absolute_image_position_x + absolute_image_position_y * numCols] = channelSum;

Answer 6

__global__ 
void rgba_to_greyscale(const uchar4* const rgbaImage, 
         unsigned char* const greyImage, 
         int numRows, int numCols) 
{ 
    int rgba_x = blockIdx.x * blockDim.x + threadIdx.x; 
    int rgba_y = blockIdx.y * blockDim.y + threadIdx.y; 
    int pixel_pos = rgba_x+rgba_y*numCols; 

    uchar4 rgba = rgbaImage[pixel_pos]; 
    unsigned char gray = (unsigned char)(0.299f * rgba.x + 0.587f * rgba.y + 0.114f * rgba.z); 
    greyImage[pixel_pos] = gray; 
} 

void your_rgba_to_greyscale(const uchar4 * const h_rgbaImage, uchar4 * const d_rgbaImage, 
          unsigned char* const d_greyImage, size_t numRows, size_t numCols) 
{ 
    //You must fill in the correct sizes for the blockSize and gridSize 
    //currently only one block with one thread is being launched 
    const dim3 blockSize(24, 24, 1); //TODO 
    const dim3 gridSize(numCols/24+1, numRows/24+1, 1); //TODO 
    rgba_to_greyscale<<<gridSize, blockSize>>>(d_rgbaImage, d_greyImage, numRows, numCols); 

    cudaDeviceSynchronize(); checkCudaErrors(cudaGetLastError()); 
} 

Answer 7

stesso codice con con la capacità di gestire immagini in formato di input non standard

int idx=blockDim.x*blockIdx.x+threadIdx.x; 
int idy=blockDim.y*blockIdx.y+threadIdx.y; 

uchar4 rgbcell=rgbaImage[idx*numCols+idy]; 

    greyImage[idx*numCols+idy]=0.299*rgbcell.x+0.587*rgbcell.y+0.114*rgbcell.z; 


    } 

    void your_rgba_to_greyscale(const uchar4 * const h_rgbaImage, uchar4 * const d_rgbaImage, 
         unsigned char* const d_greyImage, size_t numRows, size_t numCols) 
{ 
//You must fill in the correct sizes for the blockSize and gridSize 
//currently only one block with one thread is being launched 

int totalpixels=numRows*numCols; 
int factors[]={2,4,8,16,24,32}; 
vector<int> numbers(factors,factors+sizeof(factors)/sizeof(int)); 
int factor=1; 

    while(!numbers.empty()) 
    { 
if(totalpixels%numbers.back()==0) 
{ 
    factor=numbers.back(); 
    break; 
} 
    else 
    { 
    numbers.pop_back(); 
    } 
} 



const dim3 blockSize(factor, factor, 1); //TODO 
const dim3 gridSize(numRows/factor+1, numCols/factor+1,1); //TODO 
rgba_to_greyscale<<<gridSize, blockSize>>>(d_rgbaImage, d_greyImage, numRows, numCols); 

Answer 8

L'errore libdc1394 non è correlato a FireWire, ecc, in questo caso - è la libreria che Udacity sta usando per confrontare l'immagine creata dal programma con l'immagine di riferimento. E quello che sta dicendo è che la differenza tra la tua immagine e l'immagine di riferimento è stata superata da una soglia specifica, per quella posizione cioè. pixel.

Answer 9

Recentemente ho aderito a questo corso e ho provato la soluzione ma non funziona così, ho provato il mio. Sei quasi corretto. La soluzione corretta è questa:

__global__` 
void rgba_to_greyscale(const uchar4* const rgbaImage, 
       unsigned char* const greyImage, 
       int numRows, int numCols) 
{` 

int pos_x = (blockIdx.x * blockDim.x) + threadIdx.x; 
int pos_y = (blockIdx.y * blockDim.y) + threadIdx.y; 
if(pos_x >= numCols || pos_y >= numRows) 
    return; 

uchar4 rgba = rgbaImage[pos_x + pos_y * numCols]; 
greyImage[pos_x + pos_y * numCols] = (.299f * rgba.x + .587f * rgba.y + .114f * rgba.z); 

} 

Il resto è uguale al codice.

Answer 10

Poiché non si è a conoscenza delle dimensioni dell'immagine. È meglio scegliere qualsiasi dimensione ragionevole del blocco bidimensionale dei thread e quindi verificare due condizioni. Il primo è che gli indici pos_x e pos_y nel kernel non superano numRows e numCols. In secondo luogo, la dimensione della griglia dovrebbe essere appena sopra il numero totale di thread in tutti i blocchi.

const dim3 blockSize(16, 16, 1); 
const dim3 gridSize((numCols%16) ? numCols/16+1 : numCols/16, 
(numRows%16) ? numRows/16+1 : numRows/16, 1); 

Answer 11

1- int x =(blockIdx.x * blockDim.x) + threadIdx.x;

2- int y = (blockIdx.y * blockDim.y) + threadIdx.y;

E nella griglia e blocco dimensioni

1- const dim3 blockSize(32, 32, 1);

2- const dim3 gridSize((numCols/32+1), (numRows/32+1) , 1);

codice eseguito in 0. 036992 ms.

Answer 12

const dim3 blockSize(16, 16, 1); //TODO 
const dim3 gridSize((numRows+15)/16, (numCols+15)/16, 1); //TODO 

int x = blockIdx.x * blockDim.x + threadIdx.x; 
int y = blockIdx.y * blockDim.y + threadIdx.y; 

uchar4 rgba = rgbaImage[y*numRows + x]; 
float channelSum = .299f * rgba.x + .587f * rgba.y + .114f * rgba.z; 
greyImage[y*numRows + x] = channelSum;