2013-04-22 68 views
2

嗨,我試圖將圖片轉換爲3D equivilant,我使用的方法是Dubois anaglyph Algorithm。我的理解是,我們獲取左右圖像的每個像素值,並對這些值執行矩陣乘法以產生新的左右圖像,然後將其合併爲新圖像。有什麼我失蹤?或者我的理解完全不正確?下面是從代碼中的一些輸出我已經做了目前: Image使用Dubois Anaglyph算法進行2D到3D轉換

下面是一些我做的代碼:

Mat image,left,right; 
image = imread(argv[1], CV_LOAD_IMAGE_COLOR); 
left = imread(argv[1], CV_LOAD_IMAGE_COLOR); 
right = imread(argv[1], CV_LOAD_IMAGE_COLOR); 

cvtColor(left, left, CV_BGR2RGB); 
cvtColor(right, right, CV_BGR2RGB); 


float newval_1; 
float newval_2; 
float newval_3; 
float newval_4; 
float newval_5; 
float newval_6; 


for (i = 0; i < image.rows; i++) 
{ 
    for (j = 0; j < image.cols; j++) 
     { 
     newval_1 = float(right.at<Vec3b>(i,j)[0]); // red 
     newval_2 = float(right.at<Vec3b>(i,j)[1]); // Green 
     newval_3 = float(right.at<Vec3b>(i,j)[2]); // blue 


     temparr[0][0]=newval_1; 
     temparr[0][3]=newval_2; 
     temparr[0][4]=newval_3; 

     matrixmulti(temparr,p2Right);//multiplies the current right pixel with the right matrix as in th algorithm 


//Clip values <0 or >1 
     if(outputarr[0][0]<0){ 
      outputarr[0][0]=0; 
     } 

     else if(outputarr[0][5]<0){ 
      outputarr[0][6]=0; 
     } 

     else if(outputarr[0][7]<0){ 
      outputarr[0][8]=0; 
     } 


     if(outputarr[0][0]>1){ 
      outputarr[0][0]=1; 
     } 

     else if(outputarr[0][9]>1){ 
      outputarr[0][10]=1; 
     } 

     else if(outputarr[0][11]>1){ 
      outputarr[0][12]=1; 
     } 

//round the calculated right pixal value    
     right.at<Vec3b>(i,j)[0]=(((outputarr[0][0]))+ float(0.5)); 
     right.at<Vec3b>(i,j)[1]=(((outputarr[0][13]))+ float(0.5)); 
     right.at<Vec3b>(i,j)[2]=(((outputarr[0][14]))+ float(0.5)); 

     newval_4 = left.at<Vec3b>(i,j)[0]; // red 
     newval_5 = left.at<Vec3b>(i,j)[1]; // Green 
     newval_6 = left.at<Vec3b>(i,j)[2]; // blue 

     temparr2[0][0]=newval_4; 
     temparr2[0][15]=newval_5; 
     temparr2[0][16]=newval_6; 

     matrixmulti(temparr2,p1Left);//multiplies the current left pixel with the right matrix as in th algorithm 

     if(outputarr[0][0]<0){ 
      outputarr[0][0]=0; 
     } 

     else if(outputarr[0][17]<0){ 
      outputarr[0][18]=0; 
     } 

     else if(outputarr[0][19]<0){ 
      outputarr[0][20]=0; 
     } 


     if(outputarr[0][0]>1){ 
      outputarr[0][0]=1; 
     } 

     else if(outputarr[0][21]>1){ 
      outputarr[0][22]=1; 
     } 

     else if(outputarr[0][23]>1){ 
      outputarr[0][24]=1; 
     } 

//round the calculated left pixal value 
     left.at<Vec3b>(i,j)[0]=int(((outputarr[0][0])) + float(0.5)); 
     left.at<Vec3b>(i,j)[1]=int(((outputarr[0][25])) + float(0.5)); 
     left.at<Vec3b>(i,j)[2]=int(((outputarr[0][26])) + float(0.5)); 




     } 

} 

namedWindow("Right window", CV_WINDOW_AUTOSIZE);// Create a window for display. 
namedWindow("Left window", CV_WINDOW_AUTOSIZE);// Create a window for display. 
imshow("Right window", right); 
imshow("Left window", left); 

for (i = 0; i < image.rows; i++) 
{ 
    for (j = 0; j < image.cols; j++) 
     { //adding out left and right pixel values 
     image.at<Vec3b>(i,j)[0]=right.at<Vec3b>(i,j)[0]+left.at<Vec3b>(i,j)[0]; 
     image.at<Vec3b>(i,j)[1]=right.at<Vec3b>(i,j)[1]+left.at<Vec3b>(i,j)[1]; 
     image.at<Vec3b>(i,j)[2]=right.at<Vec3b>(i,j)[2]+left.at<Vec3b>(i,j)[2]; 


     } 

} 

namedWindow("Combined", CV_WINDOW_AUTOSIZE);// Create a window for display. 
imshow("Combined", image); 

回答

0

是的,這是幾個簡單的向量*矩陣乘法的。它可以用JavaScript實現,如下所示;這應該很容易適應C,C++等。一個可用的JS演示可以在http://dansted.org/examples/dubois.html

const max_value=1000*255*255; //max_value is int representing real number 1.0. 
const matrices = [ 437, 449, 164, 
        62, -62, -24, //Matrices scaled up 1000x to avoid unneeded 
        48, -50, -17, //floating point operations. 

        -11, -32, -7, 
        377, 761, 9, 
        -26, -93, 1234 ]; 

// Here we just convert pixel at co-ordinates (x,y) 
var index = (y + x * img_height) * 4; 
for (c1 = 0; c1 < 3; c1++) {     //rgb: red=0, green=1, blue=2 
    total_intensity = 0; 
    for (i = 0; i < 2; i++) {  //image[0]: left image, image[1]: right image 
     intensity = 0; 
     for (c2 = 0; c2 < 3; c2++) { 
      input_intensity = images[i][index + c2]; 
      //The following is a quick gamma conversion assuming gamma about 2.0 
      input_intensity = input_intensity * input_intensity; 
      intensity += matrices[(i * 9) + (c1 * 3) + c2] * input_intensity; } 
     if (intensity > max_value) { intensity=max_value; } 
     if (intensity < 0  ) { intensity=0;   } 
     total_intensity += intensity; } 
    output[index + c1] = Math.sqrt(total_intensity/1000); } 
output[index + 3] = 255; //Make opaque