**Disparity map** refers to the apparent pixel difference or motion between a pair of stereo images. To experience this, try closing one of your eyes and then rapidly close it while opening the other. Objects that are close to you will appear to jump a significant distance while objects further away will move very little. That motion is the disparity.

In a pair of images derived from stereo cameras, you can measure the apparent motion in pixels for every point and make an intensity image out of the measurements.

See [this][1] for an example. You can see the objects in the foreground are brighter, denoting greater motion and lesser distance.

![Example image here][2]

  [1]: http://www2.dis.ulpgc.es/~lalvarez/research/demos/StereoFlow/synthetic.gif
  [2]: http://i.stack.imgur.com/ktQer.gif

Is `memset()`  more efficient than `for` loop.

Considering this code:

    char x[500];
    memset(x,0,sizeof(x));

And this one:

    char x[500];
    for(int i = 0 ; i &lt; 500 ; i ++) x[i] = 0;

Which one is more efficient and why? Is there any special instruction in hardware to do block level initialization.

Is memset() more efficient than for loop in C?

Is there a way to get AWS pricing programmatically (cost per hour of each instance type, cost per GB/month of storage on S3, and etc)?

Also, are there cost monitoring tools?  For example, is there a tool that can report your EC2 instance usage on an hourly basis (versus a monthly basis, which is what Amazon does)?

Thanks in advance.

get ec2 pricing programmatically?

I&#39;ve been asked to implement an edge-based disparity map, but I fundamentally don&#39;t understand what a disparity map is. What is the definition of a &quot;disparity map&quot;?

What is the definition of a &quot;disparity map&quot;?

<p>I've been asked to implement an edge-based disparity map, but I fundamentally don't understand what a disparity map is. What is the definition of a "disparity map"?</p>


I&#39;m trying to use OpenCV 2.1 to combine two images into one, with the two images placed adjacent to each other. In Python, I&#39;m doing:

    import numpy as np, cv

    img1 = cv.LoadImage(fn1, 0)
    img2 = cv.LoadImage(fn2, 0)

    h1, w1 = img1.height,img1.width
    h2, w2 = img2.height,img2.width
    
    # Create an array big enough to hold both images next to each other.
    vis = np.zeros((max(h1, h2), w1+w2), np.float32)
    
    mat1 = cv.CreateMat(img1.height,img1.width, cv.CV_32FC1)
    cv.Convert( img1, mat1 )
    
    mat2 = cv.CreateMat(img2.height, img2.width, cv.CV_32FC1)
    cv.Convert( img2, mat2 )
    
    # Copy both images into the composite image.
    vis[:h1, :w1] = mat1
    vis[:h2, w1:w1+w2] = mat2
    
    h,w = vis.shape
    vis2 = cv.CreateMat(h, w, cv.CV_32FC3)
    vis0 = cv.fromarray(vis)
    cv.CvtColor(vis0, vis2, cv.CV_GRAY2BGR)
    cv.ShowImage(&#39;test&#39;, vis2)
    cv.WaitKey()

The two input images are:

https://code.ros.org/trac/opencv/browser/trunk/opencv/samples/c/box.png?rev=2270

https://code.ros.org/trac/opencv/browser/trunk/opencv/samples/c/box_in_scene.png?rev=2270

The resulting image is:

![enter image description here][1]

It may be hard to distinguish from the rest of the site, but most of the image is white, corresponding to where the individual images should be. The black area is where no image data was written.

Why is all my image data being converted to white?

  [1]: http://i.stack.imgur.com/3yzIv.png

Combining Two Images with OpenCV

How do you convert a grayscale OpenCV image to black and white? I see a [similar question][1] has already been asked, but I&#39;m using OpenCV 2.3, and the proposed solution no longer seems to work.

I&#39;m trying to convert a greyscale image to black and white, so that anything not absolutely black is white, and use this as a mask for [surf.detect()][2], in order to ignore keypoints found on the edge of the black mask area.

The following Python gets me almost there, but the threshold value sent to Threshold() doesn&#39;t appear to have any effect. If I set it to 0 or 16 or 128 or 255, the result is the same, with all pixels with a value &gt; 128 becoming white, and everything else becoming black.

What am I doing wrong?

    import cv, cv2
    fn = &#39;myfile.jpg&#39;
    im_gray = cv2.imread(fn, cv.CV_LOAD_IMAGE_GRAYSCALE)
    im_gray_mat = cv.fromarray(im_gray)
    im_bw = cv.CreateImage(cv.GetSize(im_gray_mat), cv.IPL_DEPTH_8U, 1);
    im_bw_mat = cv.GetMat(im_bw)
    threshold = 0 # 128#255# HAS NO EFFECT!?!?
    cv.Threshold(im_gray_mat, im_bw_mat, threshold, 255, cv.CV_THRESH_BINARY | cv.CV_THRESH_OTSU);
    cv2.imshow(&#39;&#39;, np.asarray(im_bw_mat))
    cv2.waitKey()


  [1]: https://stackoverflow.com/questions/1585535/convert-rgb-to-black-white-in-opencv
  [2]: http://opencv.itseez.com/modules/features2d/doc/feature_detection_and_description.html?highlight=surf#cv2.SURF

Converting an OpenCV Image to Black and White

I was wondering if there is a way to determine if an image is blurry or not by analyzing the image data.

Is there a way to detect if an image is blurry?

I&#39;m trying to do a [perspective transformation][1] of a set of points in order to achieve a [deskewing][2] effect:

&lt;img src=&quot;http://nuigroup.com/?ACT=28&amp;fid=27&amp;aid=1892_H6eNAaign4Mrnn30Au8d&quot; width=&quot;300&quot; height=&quot;100&quot;&gt;

I&#39;m using the image below for tests, and the **green** rectangle display the area of interest.

&lt;img src=&quot;http://i.stack.imgur.com/r8fmh.jpg&quot; width=&quot;300&quot; height=&quot;350&quot;&gt;

I was wondering if it&#39;s possible to achieve the effect I&#39;m hoping for using a simple combination of `cv::getPerspectiveTransform` and `cv::warpPerspective`. I&#39;m sharing the source code I&#39;ve written so far, but it doesn&#39;t work. This is the resulting image:

&lt;img src=&quot;http://i.stack.imgur.com/206aG.jpg&quot; width=&quot;100&quot; height=&quot;130&quot;&gt;

So there is a `vector&lt;cv::Point&gt;` that **defines the region of interest**, but the points are **not stored in any particular order** inside the vector, and that&#39;s something I can&#39;t change in the detection procedure. Anyway, **later**, the points in the vector are used to define a `RotatedRect`, which in turn is used to assemble `cv::Point2f src_vertices[4];`, one of the variables required by `cv::getPerspectiveTransform()`.

My understanding about **vertices** and how they are organized **might be one of the issues**. I also think that using a **`RotatedRect` is not the best idea** to store the original points of the ROI, since the **coordinates will change** a little bit to fit into the rotated rectangle, and **that&#39;s not very cool**.

    #include &lt;cv.h&gt;
    #include &lt;highgui.h&gt;
    #include &lt;iostream&gt;
    
    using namespace std;
    using namespace cv;
    
    int main(int argc, char* argv[])
    {
    	cv::Mat src = cv::imread(argv[1], 1);
    
        // After some magical procedure, these are points detect that represent 
        // the corners of the paper in the picture: 
        // [408, 69] [72, 2186] [1584, 2426] [1912, 291]
        vector&lt;Point&gt; not_a_rect_shape;
        not_a_rect_shape.push_back(Point(408, 69));
        not_a_rect_shape.push_back(Point(72, 2186));
        not_a_rect_shape.push_back(Point(1584, 2426));
        not_a_rect_shape.push_back(Point(1912, 291));
    
        // For debugging purposes, draw green lines connecting those points 
        // and save it on disk
        const Point* point = &amp;not_a_rect_shape[0];
        int n = (int)not_a_rect_shape.size();
        Mat draw = src.clone();
        polylines(draw, &amp;point, &amp;n, 1, true, Scalar(0, 255, 0), 3, CV_AA);
        imwrite(&quot;draw.jpg&quot;, draw);
    
        // Assemble a rotated rectangle out of that info
        RotatedRect box = minAreaRect(cv::Mat(not_a_rect_shape));
        std::cout &lt;&lt; &quot;Rotated box set to (&quot; &lt;&lt; box.boundingRect().x &lt;&lt; &quot;,&quot; &lt;&lt; box.boundingRect().y &lt;&lt; &quot;) &quot; &lt;&lt; box.size.width &lt;&lt; &quot;x&quot; &lt;&lt; box.size.height &lt;&lt; std::endl;
    
        // Does the order of the points matter? I assume they do NOT.
        // But if it does, is there an easy way to identify and order 
        // them as topLeft, topRight, bottomRight, bottomLeft?
        cv::Point2f src_vertices[4];
        src_vertices[0] = not_a_rect_shape[0];
        src_vertices[1] = not_a_rect_shape[1];
        src_vertices[2] = not_a_rect_shape[2];
        src_vertices[3] = not_a_rect_shape[3];
    
        Point2f dst_vertices[4];
        dst_vertices[0] = Point(0, 0);
        dst_vertices[1] = Point(0, box.boundingRect().width-1);
        dst_vertices[2] = Point(0, box.boundingRect().height-1);
        dst_vertices[3] = Point(box.boundingRect().width-1, box.boundingRect().height-1);
    
        Mat warpMatrix = getPerspectiveTransform(src_vertices, dst_vertices);
    
        cv::Mat rotated;
        warpPerspective(src, rotated, warpMatrix, rotated.size(), INTER_LINEAR, BORDER_CONSTANT);
    
        imwrite(&quot;rotated.jpg&quot;, rotated);
    
        return 0;
    }

Can someone help me fix this problem?


  [1]: http://nuigroup.com/forums/viewthread/3414/
  [2]: http://felix.abecassis.me/2011/10/opencv-rotation-deskewing/


Executing cv::warpPerspective for a fake deskewing on a set of cv::Point

We&#39;re trying to do the following in Mathematica - https://stackoverflow.com/questions/7738437.

But with actual photos it ends up looking lousy (like having a halo around the image).

Here&#39;s what we&#39;ve tried so far:

    unground0[img_] := With[{mask = ChanVeseBinarize[img, TargetColor-&gt;{1.,1.,1.}]},
      Rasterize[SetAlphaChannel[img, ImageApply[1-#&amp;, mask]], Background-&gt;None]]]

Here&#39;s an example of what that does.

Original image:

![original image][1]

Image with the white background replaced with no background (or, for demonstration purposes here, a pink background):

![image with transparent background -- actually a pink background here, to make the halo problem obvious][2]

Any ideas for getting rid of that halo? Tweaking things like LevelPenalty, I can only get the halo to go away at the expense of losing some of the image.

EDIT: So I can compare solutions for the bounty, please structure your solution like above, namely a self-contained function named unground-something that takes an image and returns an image with transparent background.

  [1]: http://i.stack.imgur.com/k7E1F.png
  [2]: http://i.stack.imgur.com/lbVKT.png

Remove White Background from an Image and Make It Transparent

I successfully implemented the OpenCV square-detection example in my test application, but now need to filter the output, because it&#39;s quite messy - or is my code wrong?

I&#39;m interested in the four corner points of the paper for skew reduction (like [that][1]) and further processing&#160;…


**Input &amp; Output:**
[![Input &amp; Output][2]][2]

**Original image:**

[click][3]

**Code:**

    double angle( cv::Point pt1, cv::Point pt2, cv::Point pt0 ) {
        double dx1 = pt1.x - pt0.x;
        double dy1 = pt1.y - pt0.y;
        double dx2 = pt2.x - pt0.x;
        double dy2 = pt2.y - pt0.y;
        return (dx1*dx2 + dy1*dy2)/sqrt((dx1*dx1 + dy1*dy1)*(dx2*dx2 + dy2*dy2) + 1e-10);
    }
    
    - (std::vector&lt;std::vector&lt;cv::Point&gt; &gt;)findSquaresInImage:(cv::Mat)_image
    {
        std::vector&lt;std::vector&lt;cv::Point&gt; &gt; squares;
        cv::Mat pyr, timg, gray0(_image.size(), CV_8U), gray;
        int thresh = 50, N = 11;
        cv::pyrDown(_image, pyr, cv::Size(_image.cols/2, _image.rows/2));
        cv::pyrUp(pyr, timg, _image.size());
        std::vector&lt;std::vector&lt;cv::Point&gt; &gt; contours;
        for( int c = 0; c &lt; 3; c++ ) {
            int ch[] = {c, 0};
            mixChannels(&amp;timg, 1, &amp;gray0, 1, ch, 1);
            for( int l = 0; l &lt; N; l++ ) {
                if( l == 0 ) {
                    cv::Canny(gray0, gray, 0, thresh, 5);
                    cv::dilate(gray, gray, cv::Mat(), cv::Point(-1,-1));
                }
                else {
                    gray = gray0 &gt;= (l+1)*255/N;
                }
                cv::findContours(gray, contours, CV_RETR_LIST, CV_CHAIN_APPROX_SIMPLE);
                std::vector&lt;cv::Point&gt; approx;
                for( size_t i = 0; i &lt; contours.size(); i++ )
                {
                    cv::approxPolyDP(cv::Mat(contours[i]), approx, arcLength(cv::Mat(contours[i]), true)*0.02, true);
                    if( approx.size() == 4 &amp;&amp; fabs(contourArea(cv::Mat(approx))) &gt; 1000 &amp;&amp; cv::isContourConvex(cv::Mat(approx))) {
                        double maxCosine = 0;
                        
                        for( int j = 2; j &lt; 5; j++ )
                        {
                            double cosine = fabs(angle(approx[j%4], approx[j-2], approx[j-1]));
                            maxCosine = MAX(maxCosine, cosine);
                        }
                        
                        if( maxCosine &lt; 0.3 ) {
                            squares.push_back(approx);
                        }
                    }
                }
            }
        }
        return squares;
    }

***EDIT 17/08/2012:***

To draw the detected squares on the image use this code:

    cv::Mat debugSquares( std::vector&lt;std::vector&lt;cv::Point&gt; &gt; squares, cv::Mat image )
    {
        for ( int i = 0; i&lt; squares.size(); i++ ) {
            // draw contour
            cv::drawContours(image, squares, i, cv::Scalar(255,0,0), 1, 8, std::vector&lt;cv::Vec4i&gt;(), 0, cv::Point());
            
            // draw bounding rect
            cv::Rect rect = boundingRect(cv::Mat(squares[i]));
            cv::rectangle(image, rect.tl(), rect.br(), cv::Scalar(0,255,0), 2, 8, 0);
            
            // draw rotated rect
            cv::RotatedRect minRect = minAreaRect(cv::Mat(squares[i]));
            cv::Point2f rect_points[4];
            minRect.points( rect_points );
            for ( int j = 0; j &lt; 4; j++ ) {
                cv::line( image, rect_points[j], rect_points[(j+1)%4], cv::Scalar(0,0,255), 1, 8 ); // blue
            }
        }
        
        return image;
    }



  [1]: https://stackoverflow.com/questions/7838487/executing-cvwarpperspective-for-a-fake-deskewing-on-a-set-of-cvpoint
  [2]: http://i.stack.imgur.com/5e2Mv.jpg
  [3]: http://i.stack.imgur.com/MIm24.jpg

OpenCV C++/Obj-C: Detecting a sheet of paper / Square Detection

Shamelessly jumping on the bandwagon :-)

Inspired by [How do I find Waldo with Mathematica](https://stackoverflow.com/questions/8479058/how-do-i-find-waldo-with-mathematica) and the followup [How to find Waldo with R](https://stackoverflow.com/questions/8563604/how-to-find-waldo-with-r), as a new python user I&#39;d love to see how this could be done. It seems that python would be better suited to this than R, and we don&#39;t have to worry about licenses as we would with Mathematica or Matlab.

In an example like the one below obviously simply using stripes wouldn&#39;t work. It would be interesting if a simple rule based approach could be made to work for difficult examples such as this.

![At the beach][2]

I&#39;ve added the [machine-learning] tag as I believe the correct answer will have to use ML techniques, such as the Restricted Boltzmann Machine (RBM) approach advocated by Gregory Klopper in the original thread. There is some [RBM code available in python](http://imonad.com/rbm/restricted-boltzmann-machine/) which might be a good place to start, but obviously training data is needed for that approach. 

At the [2009 IEEE International Workshop on MACHINE LEARNING FOR SIGNAL PROCESSING (MLSP 2009)](http://mlsp2009.conwiz.dk/) they ran a [Data Analysis Competition: Where&#39;s Wally?](http://mlsp2009.conwiz.dk/index.php?id=43). Training data is provided in matlab format. Note that the links on that website are dead, but the data (along with the source of an approach taken by [Sean McLoone](http://www.eeng.nuim.ie/~semcloone/homepage.html) and colleagues can be found [here](https://labanquise.insa-rouen.fr/projects/l1pca/) (see SCM link). Seems like one place to start.


  [1]: http://i.stack.imgur.com/OyOqc.jpg
  [2]: http://i.stack.imgur.com/WEGrv.jpg

How do I find Wally with Python?

I am trying to implement a &quot;Digit Recognition OCR&quot; in OpenCV-Python (cv2). It is just for learning purposes. I would like to learn both KNearest and SVM features in OpenCV. 

I have 100 samples (i.e. images) of each digit. I would like to train with them.

There is a sample `letter_recog.py` that comes with OpenCV sample. But I still couldn&#39;t figure out on how to use it. I don&#39;t understand what are the samples, responses etc. Also, it loads a txt file at first, which I didn&#39;t understand first.

Later on searching a little bit, I could find a letter_recognition.data in cpp samples. I used it and made a code for cv2.KNearest in the model of letter_recog.py (just for testing):

    import numpy as np
    import cv2
    
    fn = &#39;letter-recognition.data&#39;
    a = np.loadtxt(fn, np.float32, delimiter=&#39;,&#39;, converters={ 0 : lambda ch : ord(ch)-ord(&#39;A&#39;) })
    samples, responses = a[:,1:], a[:,0]
    
    model = cv2.KNearest()
    retval = model.train(samples,responses)
    retval, results, neigh_resp, dists = model.find_nearest(samples, k = 10)
    print results.ravel()

It gave me an array of size 20000, I don&#39;t understand what it is.

**Questions:**

1) What is letter_recognition.data file? How to build that file from my own data set?

2) What does `results.reval()` denote? 

3) How we can write a simple digit recognition tool using letter_recognition.data file (either KNearest or SVM)?


Simple Digit Recognition OCR in OpenCV-Python

I want to scale a `System.Drawing.Bitmap` to at least less than some fixed width and height. This is to generate thumbnails for an image gallery on a website, so I want to keep the aspect ratio the same.

I have some across quite a few solutions but none seem to really do what I need; they revolve around scaling based on keeping the width or the height the same but not changing both.

An example:

If I have a 4272 by 2848 image and I want to scale it to a size of 1024 by 768, then the resulting image should be 1024 by 683 and padded (with a black border) to 1024 by 768.

How can I do this with images larger than the required size and smaller than the require sized and also pad images which don&#39;t come out to the exact size I need once scaled?

Scaling a System.Drawing.Bitmap to a given size while maintaining aspect ratio

I installed `Pillow`, and after I want to do:

    from PIL import Image

I get the following error:

    Traceback (most recent call last):
      File &quot;&lt;console&gt;&quot;, line 1, in &lt;module&gt;
      File &quot;/usr/local/lib/python2.7/dist-packages/PIL/Image.py&quot;, line 61, in &lt;module&gt;
    ImportError: cannot import name _imaging

However, if I import these separately, everything is fine, ie:

    import _imaging
    import Image

Do you know what the problem might be?


ImportError: cannot import name _imaging

I am new to stereo matching. I couldn&#39;t understand the concept of disparity. What are a disparity map and disparity image, and what is the difference between them?

What is the difference between a disparity map and a disparity image in stereo matching?

I&#39;m trying to get a depth map with an uncalibrated method.
I can obtain the fundamental matrix by finding correspondent points with SIFT and then using `cv2.findFundamentalMat`. I then use `cv2.stereoRectifyUncalibrated` to get the homography matrices for each image. Finally I use `cv2.warpPerspective` to rectify and compute the disparity, but this doesn&#39;t create a good depth map. The values are very high so I&#39;m wondering if I have to use `warpPerspective` or if I have to calculate a rotation matrix from the homography matrices I got with `stereoRectifyUncalibrated`.

I&#39;m not sure of the projective matrix with the case of homography matrix obtained with the `stereoRectifyUncalibrated` to rectify.

A part of the code:

    #Obtainment of the correspondent point with SIFT
    sift = cv2.SIFT()
    
    ###find the keypoints and descriptors with SIFT
    kp1, des1 = sift.detectAndCompute(dst1,None)
    kp2, des2 = sift.detectAndCompute(dst2,None)
    
    ###FLANN parameters
    FLANN_INDEX_KDTREE = 0
    index_params = dict(algorithm = FLANN_INDEX_KDTREE, trees = 5)
    search_params = dict(checks=50)
    
    flann = cv2.FlannBasedMatcher(index_params,search_params)
    matches = flann.knnMatch(des1,des2,k=2)
    
    good = []
    pts1 = []
    pts2 = []
    
    ###ratio test as per Lowe&#39;s paper
    for i,(m,n) in enumerate(matches):
        if m.distance &lt; 0.8*n.distance:
            good.append(m)
            pts2.append(kp2[m.trainIdx].pt)
            pts1.append(kp1[m.queryIdx].pt)
    	
    	
    pts1 = np.array(pts1)
    pts2 = np.array(pts2)
    
    #Computation of the fundamental matrix
    F,mask= cv2.findFundamentalMat(pts1,pts2,cv2.FM_LMEDS)
    
    
    # Obtainment of the rectification matrix and use of the warpPerspective to transform them...
    pts1 = pts1[:,:][mask.ravel()==1]
    pts2 = pts2[:,:][mask.ravel()==1]
    
    pts1 = np.int32(pts1)
    pts2 = np.int32(pts2)
    
    p1fNew = pts1.reshape((pts1.shape[0] * 2, 1))
    p2fNew = pts2.reshape((pts2.shape[0] * 2, 1))
    	
    retBool ,rectmat1, rectmat2 = cv2.stereoRectifyUncalibrated(p1fNew,p2fNew,F,(2048,2048))
    
    dst11 = cv2.warpPerspective(dst1,rectmat1,(2048,2048))
    dst22 = cv2.warpPerspective(dst2,rectmat2,(2048,2048))

    #calculation of the disparity
    stereo = cv2.StereoBM(cv2.STEREO_BM_BASIC_PRESET,ndisparities=16*10, SADWindowSize=9)
    disp = stereo.compute(dst22.astype(uint8), dst11.astype(uint8)).astype(np.float32)
    plt.imshow(disp);plt.colorbar();plt.clim(0,400)#;plt.show()
    plt.savefig(&quot;0gauche.png&quot;)
    
    #plot depth by using disparity focal length `C1[0,0]` from stereo calibration and `T[0]` the distance between cameras

    plt.imshow(C1[0,0]*T[0]/(disp),cmap=&#39;hot&#39;);plt.clim(-0,500);plt.colorbar();plt.show()


Here are the rectified pictures with the uncalibrated method (and `warpPerspective`):

![enter image description here][2]

Here are the rectified pictures with the calibrated method:

![enter image description here][4]

I don&#39;t know how the difference is so important between the two kind of pictures. And for the calibrated method, it doesn&#39;t seem aligned. 

The disparity map using the uncalibrated method:
 
![enter image description here][5]  

The depths are calculated with : `C1[0,0]*T[0]/(disp)`
with T from the `stereoCalibrate`. The values are very high.


------------ EDIT LATER ------------

I tried to &quot;mount&quot; the reconstruction matrix (**[Devernay97]**, **[Garcia01]**) with the homography matrix obtained with &quot;stereoRectifyUncalibrated&quot;, but the result is still not good. Am I doing this correctly? 


    Y=np.arange(0,2048)
    X=np.arange(0,2048)
    (XX_field,YY_field)=np.meshgrid(X,Y)
    
    #I mount the X, Y and disparity in a same 3D array 
    stock = np.concatenate((np.expand_dims(XX_field,2),np.expand_dims(YY_field,2)),axis=2)
    XY_disp = np.concatenate((stock,np.expand_dims(disp,2)),axis=2)
    
    XY_disp_reshape = XY_disp.reshape(XY_disp.shape[0]*XY_disp.shape[1],3)
    
    Ts = np.hstack((np.zeros((3,3)),T_0)) #i use only the translations obtained with the rectified calibration...Is it correct?

    
    # I establish the projective matrix with the homography matrix
    P11 = np.dot(rectmat1,C1)
    P1 = np.vstack((np.hstack((P11,np.zeros((3,1)))),np.zeros((1,4))))
    P1[3,3] = 1
    
    # P1 = np.dot(C1,np.hstack((np.identity(3),np.zeros((3,1)))))
    
    P22 = np.dot(np.dot(rectmat2,C2),Ts)
    P2 = np.vstack((P22,np.zeros((1,4))))
    P2[3,3] = 1
    
    lambda_t = cv2.norm(P1[0,:].T)/cv2.norm(P2[0,:].T)
    

    #I define the reconstruction matrix
    Q = np.zeros((4,4))
    
    Q[0,:] = P1[0,:].T
    Q[1,:] = P1[1,:].T
    Q[2,:] = lambda_t*P2[1,:].T - P1[1,:].T
    Q[3,:] = P1[2,:].T
    
    #I do the calculation to get my 3D coordinates
    test = []
    for i in range(0,XY_disp_reshape.shape[0]):
    	a = np.dot(inv(Q),np.expand_dims(np.concatenate((XY_disp_reshape[i,:],np.ones((1))),axis=0),axis=1))
    	test.append(a)
    
    test = np.asarray(test)
    
    XYZ = test[:,:,0].reshape(XY_disp.shape[0],XY_disp.shape[1],4)


  [1]: http://i.stack.imgur.com/Gn8Xd.png
  [2]: http://i.stack.imgur.com/Ybj5o.png
  [3]: http://i.stack.imgur.com/TmhBP.png
  [4]: http://i.stack.imgur.com/bygjx.png
  [5]: http://i.stack.imgur.com/mYbS8.png

Content Type	Original Author	Original Content on Stackoverflow
Question	jmnwong	View Question on Stackoverflow
Solution 1 - Image Processing	peakxu	View Answer on Stackoverflow

What is the definition of a "disparity map"?

Image Processing Problem Overview

Image Processing Solutions

Solution 1 - Image Processing

get ec2 pricing programmatically?

Is memset() more efficient than for loop in C?

Attributions