When the `normType` is `NORM_MINMAX`, `cv::normalize` normalizes `_src` in such a way that the min value of `dst` is `alpha` and max value of `dst` is `beta`. `cv::normalize` does its magic using only scales and shifts (i.e. adding constants and multiplying by constants).

`CV_8UC1` says how many channels `dst` has.

The documentation here is pretty clear: http://docs.opencv.org/modules/core/doc/operations_on_arrays.html#normalize

Why using &quot;MapRoute&quot; for &quot;Default&quot; routing, while using &quot;MapHttpRoute&quot; for &quot;DefaultApi&quot; routing?

    routes.MapHttpRoute(
      name: &quot;DefaultApi&quot;,
      routeTemplate: &quot;api/{controller}/{action}&quot;
    );

    routes.MapRoute(
      name: &quot;Default&quot;,
      url: &quot;{controller}/{action}/{id}&quot;,
      defaults: new { controller = &quot;Home&quot;, action = &quot;Index&quot;, id = UrlParameter.Optional }
    );

Difference between &quot;MapHttpRoute&quot; and &quot;MapRoute&quot;?

In cases where I have a key for each element and I don&#39;t know the index of the element into an array, hashtables perform better than arrays (O(1) vs O(n)). 

Why is that? I mean: I have a key, I hash it.. I have the hash.. shouldn&#39;t the algorithm compare this hash against every element&#39;s hash? I think there&#39;s some trick behind the memory disposition, isn&#39;t it?

Hash table - why is it faster than arrays?

What does the `cv::normalize(_src, dst, 0, 255, NORM_MINMAX, CV_8UC1);` do in OpenCV?

I went through  the documentation and was unable to understand what `alpha`, `beta`, `NORM_MINMAX` and `CV_8UC1` actually do. I am aware alpha sets the lower and beta the higher bound. `CV_8UC1` stands for an 8-bit unsigned single channel. But what exactly these arguments do to the picture is what I am unable to comprehend.

What does cv::normalize(_src, dst, 0, 255, NORM_MINMAX, CV_8UC1);

<p>What does the <code>cv::normalize(_src, dst, 0, 255, NORM_MINMAX, CV_8UC1);</code> do in OpenCV?</p>
<p>I went through  the documentation and was unable to understand what <code>alpha</code>, <code>beta</code>, <code>NORM_MINMAX</code> and <code>CV_8UC1</code> actually do. I am aware alpha sets the lower and beta the higher bound. <code>CV_8UC1</code> stands for an 8-bit unsigned single channel. But what exactly these arguments do to the picture is what I am unable to comprehend.</p>


I am developing an Augmented Reality SDK on OpenCV. I had some problems to find tutorials on the topic, which steps to follow, possible algorithms, fast and efficient coding for real-time performance etc.

So far I have gathered the next information and useful links.

# OpenCV installation

Download [latest release version](http://opencv.org/downloads.html).

You can find installation guides [here](http://docs.opencv.org/doc/tutorials/introduction/table_of_content_introduction/table_of_content_introduction.html) (platforms: linux, mac, windows, java, android, iOS).

Online [documentation](http://opencv.org/documentation.html).

# Augmented Reality

For begginers [here][8] is a simple augmented reality code in OpenCV. It is a good start.

For anyone searching for a well designed state-of-the-art SDK I found some general steps that every augmented-reality based on marker tracking should have, considering OpenCV functions.

1. Main program: creates all classes, initialization, [capture][9] frames from video.

2. AR_Engine class: Controls the parts of an augmented reality application. There should be 2 main states:

   - **detection**: tries to detect the marker in the scene
   - **tracking**: once it is detected, uses lower computational techniques for traking the marker in upcoming frames.

Also there should be some algorithms for finding the position and orientation of the camera in every frame. This is achieve by detecting the homography transformation between the marker detected in the scene, and a 2D image of the marker we have processed offline. The explanation of this method [here][10] (page 18). The main steps for Pose Estimations are:

1. **Load camera Intrinsic Parameters**. Previously extracted offline through calibration.
   ![intrinsic parameters][11]

2. **Load the pattern** (marker) to track: It is an image of the planar marker we are going to track. It is necessary to extract features and generate descriptors ([keypoints][12]) for this pattern so later we can compare with features from the scene. Algorithms for this task:
   - [SIFT][13]
   - [FAST][14]
   - [SURF][15]

3. For every frame update, run a detection algorithm for **extracting features from the scene** and generate descriptors. Again we have several options.
   - SIFT
   - FAST
   - SURF
   - [FREAK][16]: A new method (2012) supossed to be the fastest.
   - [ORB][17]
 

4. Find **matches** between pattern and the scene descriptors.

   - [FLANN matcher][18]

5. Find [Homography][19] matrix from those matches. RANSAC can be used before to find inliers/outliers in the set of matches.

6. Extract **Camera Pose** from homography.

   - Sample code on [Pose from Homography][20].
   - Sample code on [Homography from Pose][21].

# Complete examples:

* [aruco](http://sourceforge.net/projects/aruco/)
* [Mastering OpenCV samples](https://github.com/MasteringOpenCV/code)

  [8]: http://dsynflo.blogspot.com.es/2010/06/simplar-augmented-reality-for-opencv.html
  [9]: https://stackoverflow.com/a/10697379/744859
  [10]: http://cvlab.epfl.ch/~lepetit/papers/lepetit_ftcgv05.pdf
  [11]: http://i.stack.imgur.com/7GcP6.gif
  [12]: http://docs.opencv.org/modules/features2d/doc/feature_detection_and_description.html#keypoint
  [13]: http://docs.opencv.org/modules/nonfree/doc/feature_detection.html#sift
  [14]: http://docs.opencv.org/modules/features2d/doc/feature_detection_and_description.html#fast
  [15]: http://docs.opencv.org/modules/nonfree/doc/feature_detection.html#surf
  [16]: http://docs.opencv.org/modules/features2d/doc/feature_detection_and_description.html#freak
  [17]: http://docs.opencv.org/modules/features2d/doc/feature_detection_and_description.html#orb
  [18]: http://docs.opencv.org/modules/flann/doc/flann_fast_approximate_nearest_neighbor_search.html#flann-index
  [19]: http://docs.opencv.org/modules/calib3d/doc/camera_calibration_and_3d_reconstruction.html#findhomography
  [20]: https://stackoverflow.com/a/10781165/744859
  [21]: https://stackoverflow.com/a/10750648/744859

Augmented Reality SDK with OpenCV

I have a task to locate an object in 3D coordinate system. Since I have to get almost exact X and Y coordinate, I decided to track one color marker with known Z coordinate that will be placed on the top of the moving object, like the orange ball in this picture:
![undistored][1]

First, I have done the camera calibration to get intrinsic parameters and after that I used cv::solvePnP to get rotation and translation vector like in this following code:

    std::vector&lt;cv::Point2f&gt; imagePoints;
    std::vector&lt;cv::Point3f&gt; objectPoints;
    //img points are green dots in the picture
    imagePoints.push_back(cv::Point2f(271.,109.));
    imagePoints.push_back(cv::Point2f(65.,208.));
    imagePoints.push_back(cv::Point2f(334.,459.));
    imagePoints.push_back(cv::Point2f(600.,225.));

    //object points are measured in millimeters because calibration is done in mm also
    objectPoints.push_back(cv::Point3f(0., 0., 0.));
    objectPoints.push_back(cv::Point3f(-511.,2181.,0.));
    objectPoints.push_back(cv::Point3f(-3574.,2354.,0.));
    objectPoints.push_back(cv::Point3f(-3400.,0.,0.));

    cv::Mat rvec(1,3,cv::DataType&lt;double&gt;::type);
    cv::Mat tvec(1,3,cv::DataType&lt;double&gt;::type);
    cv::Mat rotationMatrix(3,3,cv::DataType&lt;double&gt;::type);

    cv::solvePnP(objectPoints, imagePoints, cameraMatrix, distCoeffs, rvec, tvec);
    cv::Rodrigues(rvec,rotationMatrix);

After having all matrices, this equation that can help me with transforming image point to wolrd coordinates:

![transform_equation][2]

where M is cameraMatrix, R - rotationMatrix, t - tvec, and s is an unknown. Zconst represents the height where the orange ball is, in this example it is 285 mm.
So, first I need to solve previous equation, to get &quot;s&quot;, and after I can find out X and Y coordinate by selecting image point:
![equation2][3]

Solving this I can find out variable &quot;s&quot;, using the last row in matrices, because Zconst is known, so here is the following code for that:

    cv::Mat uvPoint = (cv::Mat_&lt;double&gt;(3,1) &lt;&lt; 363, 222, 1); // u = 363, v = 222, got this point using mouse callback
   
    cv::Mat leftSideMat  = rotationMatrix.inv() * cameraMatrix.inv() * uvPoint;
    cv::Mat rightSideMat = rotationMatrix.inv() * tvec;

    double s = (285 + rightSideMat.at&lt;double&gt;(2,0))/leftSideMat.at&lt;double&gt;(2,0)); 
    //285 represents the height Zconst

    std::cout &lt;&lt; &quot;P = &quot; &lt;&lt; rotationMatrix.inv() * (s * cameraMatrix.inv() * uvPoint - tvec) &lt;&lt; std::endl;

After this, I got result: P = [-2629.5, 1272.6, 285.]

and when I compare it to measuring, which is: Preal = [-2629.6, 1269.5, 285.]

the error is very small which is very good, but when I move this box to the edges of this room, errors are maybe 20-40mm and I would like to improve that. Can anyone help me with that, do you have any suggestions?
    
    



  [1]: http://i.stack.imgur.com/RnqDj.jpg
  [2]: http://i.stack.imgur.com/2fTRs.jpg
  [3]: http://i.stack.imgur.com/KUCg3.jpg

Computing x,y coordinate (3D) from image point

I compiled and installed openCV 2.4.2 in ubuntu 12.04. Under `/usr/local/include` I can see the directories `/usr/local/opencv` and `/usr/local/opencv2`.

Here is the code I wrote:


    #include &lt;cv.h&gt;
    #include &lt;highgui.h&gt;
    #include &lt;iostream&gt;
    using namespace cv;
    using namespace std;
    int main(int argc,char **argv)
    {
       Mat image;
       image = imread(argv[1],1);

       if(argc != 2 || !image.data)
       {
           cout &lt;&lt; &quot;No image data\n&quot;;
           return -1;
       }

       namedWindow(&quot;Display Image&quot;,CV_WINDOW_AUTOSIZE);
       imshow(&quot;Display Image&quot;,image);
       waitKey(0);
       return 0;
    }

I compiled it using this command line:

    g++ DisplayImage.cpp -o DisplayImage `pkg-config opencv --cflags --libs` 

There were no compile time errors, however when I try to run the resulting binary with `/DisplayImage code.png` I get the following error message:

    ./DisplayImage: error while loading shared libraries: libopencv_core.so.2.4: cannot open shared object file: No such file or directory


openCV program compile error &quot;libopencv_core.so.2.4: cannot open shared object file: No such file or directory&quot; in ubuntu 12.04

I am totally new to camera calibration techniques... I am using OpenCV chessboard technique... I am using a webcam from Quantum...

Here are my observations and steps..

 1. I have kept each chess square side = 3.5 cm. It is a 7 x 5 chessboard with **6 x 4** internal corners. I am taking total of 10 images in different views/poses at a distance of 1 to 1.5 m from the webcam.
 2. I am following the C code in **Learning OpenCV** by **Bradski** for the calibration.
my code for calibration is 

        cvCalibrateCamera2(object_points,image_points,point_counts,cvSize(640,480),intrinsic_matrix,distortion_coeffs,NULL,NULL,CV_CALIB_FIX_ASPECT_RATIO);

 3. Before calling this function I am making the first and 2nd element along the diagonal of the intrinsic matrix as one to keep the ratio of focal lengths constant and using `CV_CALIB_FIX_ASPECT_RATIO`

 4. With the change in distance of the chess board the `fx` and `fy` are changing with `fx:fy` almost equal to 1. there are `cx` and `cy` values in order of 200 to 400.  the `fx` and `fy` are in the order of 300 - 700 when I change the distance.

 5. Presently I have put all the distortion coefficients to zero because I did not get good result including distortion coefficients. My original image looked handsome than the undistorted one!!

Am I doing the calibration correctly?. Should I use any other option than `CV_CALIB_FIX_ASPECT_RATIO`?. If yes, which one?



How to verify the correctness of calibration of a webcam?

&gt; **Possible Duplicate:**  
&gt; [OpenCv CreateImage Function isn’t working](https://stackoverflow.com/questions/9710520/opencv-createimage-function-isnt-working)  

&lt;!-- End of automatically inserted text --&gt;

I wish to create a new RGB image in OpenCV using Python. I don&#39;t want to load the image from a file, just create an empty image ready to do operations on.

Content Type	Original Author	Original Content on Stackoverflow
Question	user1179510	View Question on Stackoverflow
Solution 1 - Opencv	carlosdc	View Answer on Stackoverflow

What does cv::normalize(_src, dst, 0, 255, NORM_MINMAX, CV_8UC1);

Opencv Problem Overview

Opencv Solutions

Solution 1 - Opencv

Hash table - why is it faster than arrays?

Difference between "MapHttpRoute" and "MapRoute"?

Attributions