Casting-Problem in C++ Eclipse (Linux-Mint12)

Question

Ich versuche, ein Programm (in sequenziellen Code geschrieben) zu parallelisieren, um seine Leistung (Beschleunigung) zu erhöhen. Insgesamt führt das Programm Bildbearbeitung durch Zoomen in Bilder durch. Um dies zu tun, verwendet es eine bikubische Interpolation (berücksichtigt den Mittelwert der 16 umgebenden Pixel, um einen einzelnen Pixelwert zu berechnen). Der folgende Code führt diese Funktion aus, aber ich versuche, es mit 16 Pixeln gleichzeitig arbeiten zu lassen (es funktioniert mit Matrizen und Vektoren anstelle von Vektoren und unsignierten Zeichen), was es mir später ermöglichen wird, SSE einzuführen.

zurück zu der Frage auf der Hand bekommt, zeigt der Fehler in meinem Code, wenn ich die folgende Operation ausführen:

color[c]=bicubicInterpolate_paralelo(arr, auxx, auxy); 

Der Vorgang ist gleich die Zeile einer 3x16-Matrix (color [c]), um einen 16 Element Vektor (valorPixelCanal -> später in meinem Code) zurückgegeben von der Funktion bicubicInterpolate_paralelo. Er erzeugt den folgenden Fehler:

CImg-1.5.2/CImg.h:27491:46: error: cast from ‘const unsigned char*’ to ‘unsigned char’ loses precision [-fpermissive]

ich versucht habe, auf folgende Weise Gießen:

color[c] = <reinterpret_cast(const char*)>(bicubicInterpolate_paralelo(arr, auxx, auxy)) 

Es ist jedoch nicht mein Problem zu lösen. Wenn einer von euch mir dabei helfen könnte, würde ich es sehr schätzen; Mein Code ist unten angegeben, wenn Sie Fragen dazu haben, wie andere Teile davon funktionieren, werde ich ihnen gerne antworten. Vielen Dank im Voraus!

void cubicInterpolate_paralelo(unsigned char p[64]/*4*/, unsigned char x[16]/*1*/, unsigned char* arr) { 

     for (int ii=0; ii<16; ii++) 
     { 
      arr[ii] = p[1+(4*ii)] + 0.5 * x[ii] *(p[2+(4*ii)] - p[0+(4*ii)] + x[ii]*(2.0*p[0+(4*ii)] - 5.0*p[1+(4*ii)] + 4.0*p[2+(4*ii)] - p[3+(4*ii)] + x[ii]*(3.0*(p[1+(4*ii)] - p[2+(4*ii)]) + p[3+(4*ii)] - p[0+(4*ii)]))); 
     } 
} 

unsigned char* bicubicInterpolate_paralelo (unsigned char p[64][64]/*4,4*/, unsigned char x[16]/*1*/, unsigned char y[16]/*1*/) { 
    unsigned char arr[64][16], valorPixelCanal[16]; 
    int ii, kk, jj, ss; 
    int counter = 0; 
    unsigned char aar[16][64]; 

for(ii=0; ii<64; ii++) { 
    cubicInterpolate_paralelo(p[ii], y, arr[ii]); 
} 

for (jj=0; jj<16; jj++) 
{ 
    for (ss=0; ss<16; ss++) 
    { 
     aar[jj][counter] = arr[0][ss]; 
     aar[jj][counter+1] = arr[1][ss]; 
     aar[jj][counter+2] = arr[2][ss]; 
     aar[jj][counter+3] = arr[3][ss]; 
     counter = counter + 4; 
    } 
} 

for(kk=0; kk<16; kk++) { 
    cubicInterpolate_paralelo(aar[kk], x, valorPixelCanal); 
} 
return valorPixelCanal; 
} 

CImg<unsigned char> zoom_paralelo (CImg<unsigned char> img, int zFactor) { 
int i, j, k, l, c, jj; 
unsigned char arr[64][64]; 
unsigned char color[3][16]; 
unsigned char auxx[16],auxy[16]; 

CImg<unsigned char> z_img(zFactor*(img.width()-2)-zFactor+1, zFactor*(img.height()-1)-zFactor+1, 1, 3, 0); 


#pragma omp parallel for schedule(guided, 4) num_threads(4) private(arr, c, l, k, i, j) lastprivate(color) firstprivate(zFactor) // øNecesita collapse? 

for(i=0; i<z_img.width(); i++) { 


    for(j=0; j<z_img.height(); j++) { 
     //For R,G,B 

     for(c=0; c<3; c++) { 

      for(l=0; l<64 /*4*/; l++){ 

       for(k=0; k<64 /*4*/; k++){ 

        arr[l][k] = img(i/zFactor +l, j/zFactor +k, 0, c); // img (x,y,z,c) 
       } 
      } 

      for(jj=0; jj<16; jj++) 
      { 
      auxx[jj] = (unsigned char)(i%zFactor)/zFactor; 
      auxy[jj] = (unsigned char)(j%zFactor)/zFactor; 
      } 
      color[c]=bicubicInterpolate_paralelo(arr, auxx, auxy); 
     } 
     z_img.draw_point(i,j,color); 
    } 
} 
return z_img; 

} 

Answer 1

In bicubicInterpolate_paralelo Sie einen Zeiger auf eine lokale Datenarray. Dieser Zeiger ist nach der Rückgabe der Funktion ungültig.

Dann versuchen Sie, diesen Zeigerwert (unsigned char*) in unsigned char Array zu speichern.

Beschreiben Sie, wie genau diese Funktion funktionieren soll, damit wir Ihnen die Idee geben können, wie Sie diese Funktion reparieren können.

// BEARBEITEN: OK, ich sehe dein Problem. Sie möchten das Array von 16 chars zurückgeben.

Es wird besser sein, es zurück mit dem Ausgangsparameter:

Statt:

unsigned char* bicubicInterpolate_paralelo (unsigned char p[64][64]/*4,4*/, unsigned char x[16]/*1*/, unsigned char y[16]/*1*/) { 

sollten Sie tun:

void/some_status bicubicInterpolate_paralelo (unsigned char p[64][64]/*4,4*/, unsigned char x[16]/*1*/, unsigned char y[16]/*1*/, unsigned char (*output)[16]) { 

mit Aufruf:

bicubicInterpolate_paralelo(arr, auxx, auxy, color[c]); 

jetzt kannst du di schreiben rectly zu outputvalorPixelCanal