sharjeelyunus/github-issues-dataset huggingface dataset:
Repository: opencv
Issue: Errors in SURF/STAR Python Bindings
Labels: bug,auto-transferred,category: python bindings,priority: low

Transferred from http://code.opencv.org/issues/1582

```
|| kscottz - on 2012-02-03 16:41
|| Priority: Low
|| Affected: None
|| Category: python bindings
|| Tracker: Bug
|| Difficulty: None
|| PR: None
|| Platform: None / None
```
## Errors in SURF/STAR Python Bindings

```
I have had significant trouble with the cv2 python bindings for feature extraction. I keep getting <unknown> is not a numpy array  when I try to use the surf/star feature extractors. This may simply be for lack of working example code. Could you please verify that these methods work and perhaps post working examples? My problems are summarized here:

http://stackoverflow.com/questions/9131552/feature-detection-in-opencv-python-bindings

I have tried both the release and the current version in the SVN repo. I am OSX but I believe these errors are also present on Linux and Windows. If you want to point me in the right direction and lend some assistance I am more than willing to help fix these bindings in the source repository.
```
## History
##### Alexander Shishkov on 2012-03-20 13:46

```
-   Target version deleted ()
-   Priority changed from High to Normal
```
##### Alexander Shishkov on 2012-03-25 20:44

```
-   Assignee deleted (Vadim Pisarevsky)
```
##### Vadim Pisarevsky on 2012-04-04 13:44

```
in the sample code you are trying to pass Python-wrapped iplimage to cv2. function. It will not work. Forget iplimage and use numpy arrays, as it's suggested in reply on stackoverflow.

Though, we still need samples for the functionality, so I leave this ticket open, but lower its priority.
-   Priority changed from Normal to Low
-   Assignee set to Vadim Pisarevsky
```
##### Alexander Shishkov on 2012-04-05 12:46

```
-   Target version deleted ()
```
Repository: opencv
Issue: Levenberg-Marquardt in calibrateCamera has a small basin of convergence
Labels: bug,auto-transferred,priority: normal,category: calib3d

Transferred from http://code.opencv.org/issues/1733

```
|| Ilya Lysenkov on 2012-03-30 18:20
|| Priority: Normal
|| Affected: None
|| Category: calibration, 3d
|| Tracker: Bug
|| Difficulty: None
|| PR: None
|| Platform: None / None
```
## Levenberg-Marquardt in calibrateCamera has a small basin of convergence

```
When initial estimation of intrinsic parameters is too bad, the LM algorithm often fails to converge to the correct solution. It is the main reason why the test Calib3d_CalibrateCamera_CPP.accuracy_on_artificial_data fails sometimes.

So either the OpenCV implementation of Levenberg-Marquardt should be improved or an another optimization scheme in cv::calibrateCamera should be used. For example, I was able to get good results with the following EM-style procedure:

<pre>
Do several iterations of two steps:
  1. Optimize all parameters with LM (or may be optimize intrinsic parameters only).
  2. Optimize extrinsic parameters with SolvePnP by using the computed intrinsic parameters on the step 1.
</pre>

The calibration in Calib3d_CalibrateCamera_CPP.accuracy_on_artificial_data was successful in 300 random attempts with this scheme. However, I'm not quite sure that we should use it because the paper "Robust registration of 2D and 3D point sets" by A. Fitzgibbon contains an example when the LM algorithm works better than an EM-style optimization scheme. So may be it is just a problem of the current OpenCV implementation of the LM algorithm.

Anyway, I think the current implementation is good enough and this issue should be resolved after the 2.4 release.
```
## History
##### Ilya Lysenkov on 2012-03-30 18:22

```
-   Subject changed from Levenberg-Marquardt in calibrateCamera has a
    low basin of convergence to Levenberg-Marquardt in calibrateCamera
    has a small basin of convergence
```
Repository: opencv
Issue: Descriptors for Affine invariant regions
Labels: auto-transferred,feature,priority: low,category: features2d

Transferred from http://code.opencv.org/issues/1851

```
|| kaushik pavani on 2012-04-26 09:05
|| Priority: Low
|| Affected: None
|| Category: features2d
|| Tracker: Feature
|| Difficulty: None
|| PR: None
|| Platform: None / None
```
## Descriptors for Affine invariant regions

```
OpenCV keypoints (for SIFT/SURF) are meant to describe circular ROIs. Affine invariant regions, generally elliptical, cannot be described using OpenCV keypoints. Can keypoints be extended to handle elliptical regions? And, can sift / surf descriptors be extended for elliptical keypoints as well?
```
## History
##### Kirill Kornyakov on 2012-04-28 13:15

```
It is hard to understand what you're talking about... Please answer the following questions:
# Is there any papers or links about elliptical regions in this context?
# What is your application, are you sure that you need elliptical regions?
# Don't you want to implement initial version and send it for peer review?
-   Priority changed from Normal to Low
-   Assignee set to kaushik pavani
-   Category set to features2d
```
Repository: opencv
Issue: Exposing more Keypoint and Feature2d C++ functions to Java API.
Labels: auto-transferred,priority: normal,feature,category: java bindings

Transferred from http://code.opencv.org/issues/1866

```
|| Rui Marques on 2012-04-30 11:16
|| Priority: Normal
|| Affected: None
|| Category: java bindings
|| Tracker: Feature
|| Difficulty: None
|| PR: None
|| Platform: None / None
```
## Exposing more Keypoint and Feature2d C++ functions to Java API.

```
I think it would be helpful to expose more functions, for example:

KeyPointsFilter::retainBest (ok this one can probably be already used indirectly by using ORB's nFeatures parameter)

KeyPoint::overlap (this might help as ORB, for example, returns a lot of keypoints that are close to each other and i think all those extra kpts won't help much to find an homography)
```
## History
##### Alexander Shishkov on 2012-05-02 19:01

```
-   Target version set to 2.4.1
-   Assignee set to Andrey Pavlenko
-   Category set to java bindings
```
##### Alexander Shishkov on 2012-05-02 19:06

```
-   Target version changed from 2.4.1 to 3.0
```
##### Arjan Somers on 2012-05-10 08:48

```
I don´t know if the author also means setting the paramaters to the different keypoint detectors/extractors?

Currently the only way to set parameters (such as number of octaves etc) is only possible by writing a yaml file wich describes these settings and then load them from file. (Examples of this can be seen in the unit tests).

It would be nice to be able to set these parameters in a less hack-isch way.

Is this part of this feature feature request or should i make a new request?
```
##### Rui Marques on 2012-05-10 09:51

```
I was aware of the yaml method to set the parameters.
This particular feature request was about exposing more methods to Java but a better way to set the parameters would also be nice.
```
Repository: opencv
Issue: Allowed Matrix dimension for 'objectPoints':cvFindExtrinsicCameraParams2
Labels: bug,auto-transferred,priority: normal,category: documentation,affected: 2.4

Transferred from http://code.opencv.org/issues/1875

```
|| Pranav Kant  Gaur on 2012-05-02 09:34
|| Priority: Normal
|| Affected: 2.4.0 - 2.4.4
|| Category: documentation
|| Tracker: Bug
|| Difficulty: None
|| PR: 
|| Platform: None / None
```
## Allowed Matrix dimension for 'objectPoints':cvFindExtrinsicCameraParams2

```
Hi,
In cvFindExtrinsicCameraParams2(),
I have tried 'objectPoints' array with dimension NX2 instead of NX3(to imply planer configuration) and I found that it compiles without any error.But documentation asks for NX3,3XN 1-channel or 1XN,NX1 3-channel only.

Link:
http://opencv.willowgarage.com/documentation/camera_calibration_and_3d_reconstruction.html#findextrinsiccameraparams2
```
## History
##### Andrey Pavlenko on 2013-06-11 12:45

```
-   Target version set to Next Hackathon
-   Affected version set to 2.4.0 - 2.4.4
-   Start date deleted (2012-05-02)
```
Repository: opencv
Issue: Testing Python Wrappers doc should mention PATH should be set for Windows install
Labels: bug,auto-transferred,priority: low,category: documentation

Transferred from http://code.opencv.org/issues/1933

```
|| Steve Eight on 2012-05-14 18:30
|| Priority: Low
|| Affected: None
|| Category: documentation
|| Tracker: Bug
|| Difficulty: None
|| PR: None
|| Platform: None / None
```
## Testing Python Wrappers doc should mention PATH should be set for Windows install

```
In the Install Guide for OpenCV, in the section "Testing Python wrappers", it says "If you want to try Python samples without installing OpenCV, put cv.so and cv2.so (called cv.pyd and cv2.pyd on Windows) to opencv/samples/python directory, or rather add the directory containing cv.so/cv.pyd to PYTHONPATH".  

However, this is not sufficient on Windows.  On Windows, you must also set the PATH to point to the directory that includes the various OpenCV DLLs, otherwise it will give the message:

Traceback (most recent call last):
  File "delaunay.py", line 9, in <module>
    import cv2.cv as cv
ImportError: DLL load failed: The specified module could not be found.

The error is vague, and it sounds like there is something wrong with the cv2.pyd, when in fact it was simply unable to load the OpenCV dlls.

A sentence should be added that states that in addition to the PYTHONPATH, the PATH should be set to the directory that contains the OpenCV dlls.
```
## History
##### Kirill Kornyakov on 2012-05-16 06:56

```
-   Category set to documentation
```
Repository: opencv
Issue: LINE-MOD docs missing
Labels: auto-transferred,priority: normal,feature,category: documentation

Transferred from http://code.opencv.org/issues/1950

```
|| Vincent Rabaud on 2012-05-16 16:42
|| Priority: Normal
|| Affected: None
|| Category: documentation
|| Tracker: Feature
|| Difficulty: None
|| PR: None
|| Platform: None / None
```
## LINE-MOD docs missing

```
in the official OpenCV 2.4 pdf, there are no docs about LINE-MOD and how to use it.
```
## History
##### Andrey Kamaev on 2012-05-17 12:31

```
-   Category set to documentation
```
Repository: opencv
Issue: Change the name of the library folder in win-superpack to enable specifying the path using Visual C++ macro
Labels: auto-transferred,priority: normal,feature,category: build/install

Transferred from http://code.opencv.org/issues/2002

```
|| Tsukasa Sugiura on 2012-05-31 05:51
|| Priority: Normal
|| Affected: None
|| Category: build/install
|| Tracker: Feature
|| Difficulty: None
|| PR: None
|| Platform: None / None
```
## Change the name of the library folder in win-superpack to enable specifying the path using Visual C++ macro

```
Currently, The name of the library folder in win-superpack is as follows.

・for 32bit application "x86"
・for 64bit application "x64"

I propose the improvement plan.

Visual C++ macros are $(PlatformName).
This macro shows the "Win32" when project is Win32, shows the "x64" when project is x64.
If changed "x86, x64" to "Win32, x64" the name of the library folder in win-superpack, will be very useful it can be use to specify the path.
(Similar macro $(PlatformShortName) show the "x86" when project is Win32, shows the "amd64" when project is x64.)

Also, can use the $(PlatformToolset) to specify the path if you change "vc9, vc10" to "vc90, vc100".
$(PlatformToolset) shows the "vc100" when compiler is Visual C++ 2010, shows the "vc90" compiler is Visual C++ 2008.

*\opencv\build\(x86|x64)\(vc9|vc10)\* -> *\opencv\build\(Win32|x64)\(vc90|vc100)\*

Please consider changing the name of the folder.
```
## History
##### Andrey Kamaev on 2012-05-31 06:24

```
-   Assignee set to Alexander Shishkov
-   Category set to build/install
```
Repository: opencv
Issue: FLANN documentation only lists deprecated class
Labels: bug,auto-transferred,priority: normal,category: documentation,affected: 2.4

Transferred from http://code.opencv.org/issues/2008

```
|| Nick Kitten on 2012-06-01 17:38
|| Priority: Normal
|| Affected: branch '2.4'
|| Category: documentation
|| Tracker: Bug
|| Difficulty: None
|| PR: 
|| Platform: None / None
```
## FLANN documentation only lists deprecated class

```
The section on nearest-neighbor search refers to the (deprecated) Index_<T> class parameterized on the index type, whereas the current library uses GenericIndex<D> parameterized on the distance type, and is far more flexible.  If the documentation is brought up to date, "non-issues like this one":http://code.opencv.org/issues/1947 may stop appearing.
```
## History
##### Vadim Pisarevsky on 2012-06-06 10:12

```
-   Assignee set to Vadim Pisarevsky
```
##### Vadim Pisarevsky on 2012-10-04 10:43

```
-   Target version deleted ()
-   Assignee deleted (Vadim Pisarevsky)
```
##### Kirill Kornyakov on 2012-10-24 08:38

```
-   Target version set to Next Hackathon
```
##### Vadim Pisarevsky on 2013-01-22 22:23

```
-   Target version deleted (Next Hackathon)
```
##### Kirill Kornyakov on 2013-02-14 08:00

```
-   Target version set to Next Hackathon
```
##### Andrey Pavlenko on 2013-06-11 12:20

```
-   Target version deleted (Next Hackathon)
-   Affected version set to branch '2.4'
-   Start date deleted (2012-06-01)
```
Repository: opencv
Issue: Serializable datatypes in Java API
Labels: auto-transferred,priority: normal,feature,category: java bindings

Transferred from http://code.opencv.org/issues/2015

```
|| Arjan Somers on 2012-06-04 13:47
|| Priority: Normal
|| Affected: None
|| Category: java bindings
|| Tracker: Feature
|| Difficulty: None
|| PR: None
|| Platform: None / None
```
## Serializable datatypes in Java API

```
The 2.4.1 release comes with an option to store and retrieve matrices as noted in the release notes
* Added API for storing OpenCV data structures to text string and reading them back

I think this or similar functionality (maybe by implementing java's Serializable API) might be very useful in the Java API for android.

In my particular case i want to do feature detection on images using SIFT. Now every time i start my application i have to parse all reference images to find keypoints and compute their descriptors. If the keypoints would be serializable this could greatly reduce loading times.

Therefore: Could some persistence functionality, such as serialisation, be implemented for datatypes such as Keypoints or matrices in general?
```
## History
##### Andrey Pavlenko on 2012-06-04 14:48

```
-   Category set to android
```
##### Rui Marques on 2012-06-04 16:00

```
Just as a notice, this is a feature that also interests me for similar reasons. Although it is not critical for me.
```
##### Vadim Pisarevsky on 2012-06-06 10:06

```
well, part of it has been done on C++ side in OpenCV 2.4.1; there is still some work to do both in C++ and Java wrappers.
-   Assignee set to Andrey Pavlenko
```
##### Andrey Pavlenko on 2012-06-28 15:00

```
-   Category changed from android to java bindings
```
Repository: opencv
Issue: solvePnPRansac and the inliers
Labels: auto-transferred,feature,priority: low,category: calib3d

Transferred from http://code.opencv.org/issues/2026

```
|| Simone Gasparini on 2012-06-06 16:35
|| Priority: Low
|| Affected: None
|| Category: calibration, 3d
|| Tracker: Feature
|| Difficulty: None
|| PR: None
|| Platform: None / None
```
## solvePnPRansac and the inliers

```
Normally when dealing with algorithms using Ransac (findHomography/Fundamental and so on), the functions returns a mask (vector or Mat) of uchar containing 0 or 255, and of the same size of the input data. 
On the other hand solvePnPRansac return a vector of int with the indices of the inliers. Why is it so? Wouldn't be better to uniform this and make the function return a vector/matrix of uchar like all the other functions of the same kind?

S.
```
## History
##### Simone Gasparini on 2012-06-08 15:37

```
Also, I see that rvec and tvec are created as 64FC1 matrix. This is a bit not consistent with the fact that as input the function is requiring vectors of Point2f/Point3f or Mat 32FCx containing points. Isn't it better to give as output something with the same depth as the input?

S.
```
Repository: opencv
Issue: SURF feautures doesn't work with DenseGrid when grid sampling is pair
Labels: bug,auto-transferred,priority: normal,category: nonfree

Transferred from http://code.opencv.org/issues/2031

```
|| Alexandre Benoit on 2012-06-08 11:29
|| Priority: Normal
|| Affected: None
|| Category: nonfree
|| Tracker: Bug
|| Difficulty: None
|| PR: None
|| Platform: None / None
```
## SURF feautures doesn't work with DenseGrid when grid sampling is pair

```
Hi everyone,
I observe that on the current svn trunk and OpenCV2.4 release, the SURF descriptor returns only zeros when used with a Dense grid configured with a pair pixel sampling.
The problem seems to not appear when using SIFT

Code samples are below
```
## History
##### Alexandre Benoit on 2012-06-08 11:45

```
Hi again, oops, my explanation was a bit wrong at the end, sorry for that, here are the good code samples :

I observe that on the current svn trunk and OpenCV2.4 release, the SURF descriptor returns only zeros when used with a Dense grid configured with a pair pixel sampling.
The problem seems to not appear when using SIFT

Typically when the dense grid is such like this :
<pre>
cv::Ptr<cv::FeatureDetector> _featureDetector = new cv::DenseFeatureDetector(1.f, 1, 2.5f, 6);)// descritor returns zeros when sampling is 6,8,10,12, however, it "works" with sampling like 5,7,9, etc.
</pre>

and the descriptor being like this :
<pre>
_descExtractor = cv::DescriptorExtractor::create("SURF" ); or "OppenentSURF"
</pre>

Then, running the descriptor like this :
<pre>
_featureDetector->detect(colorImage, imageKeypoints, mask);
_descExtractor->compute( colorImage, imageKeypoints, currentImageDescriptors);
</pre>
==> here currentImageDescriptors is the right length but it contains only zeros is dense features sampling is a mutiple of 2
```
##### Kirill Kornyakov on 2012-06-15 06:47

```
Alexandre, thank you for report, but please use wiki "syntax":http://code.opencv.org/help/wiki_syntax.html, and do not use High priority by default. All bugs are triaged, and the team will decide about the priority and Target version.
-   Target version deleted (3.0)
-   Priority changed from High to Normal
-   Description changed from Hi everyone, I observe that on the current
    svn trunk and OpenCV2.4 release, t... to Hi everyone, I observe that
    on the current svn trunk and OpenCV2.4 release, t... More
-   Category changed from features2d to nonfree
```
Repository: opencv
Issue: Empty imshow window when OpenGL enabled
Labels: bug,auto-transferred,priority: normal,category: highgui-gui

Transferred from http://code.opencv.org/issues/2039

```
|| Alexander Mordvintsev on 2012-06-12 06:39
|| Priority: Normal
|| Affected: None
|| Category: highgui-gui
|| Tracker: Bug
|| Difficulty: None
|| PR: None
|| Platform: None / None
```
## Empty imshow window when OpenGL enabled

```
Built with OpenGL, no QT. OS win7 64 (but OpenCV is 32bit)
Code to reproduce:

<pre><code class="python">
import numpy as np
import cv2

img = np.zeros((200, 200), np.uint8)
cv2.circle(img, (100, 100), 90, 255)
cv2.imshow('img', img)  // image blinks for a moment and then the window goes gray
cv2.waitKey()                
cv2.imshow('img', img)  // second attempt AFTER key press works fine
cv2.waitKey()
</code></pre>
```
## History
##### Andrey Kamaev on 2012-06-18 08:50

```
-   Description changed from Built with OpenGL, no QT. OS win7 64 (but
    OpenCV is 32bit) Code to reproduce:... to Built with OpenGL, no QT.
    OS win7 64 (but OpenCV is 32bit) Code to reproduce:... More
```
##### Eric Hartmann on 2012-07-15 05:19

```
have the same problem...

Also, I tested point_cloud.cpp with opengl enabled and it also doesn't work. Only a black empty screen is showed but with visible updating FPS texts.

OS win7 64bit, VS2010, Cmake 2.8.8, OpenCV 32bit

=========================
Alexander Mordvintsev wrote:
> Built with OpenGL, no QT. OS win7 64 (but OpenCV is 32bit)
> Code to reproduce:
>
> [...]
-   File Capture.PNG added
```
##### Andrey Kamaev on 2012-08-16 15:38

```
-   Category changed from highgui-images to highgui-gui
```
Repository: opencv
Issue: cv2.HOGDescriptor().compute() crashes python
Labels: bug,auto-transferred,priority: normal,category: python bindings

Transferred from http://code.opencv.org/issues/2052

```
|| Kalyf Abdalla Buzar Lima on 2012-06-14 22:33
|| Priority: Normal
|| Affected: None
|| Category: python bindings
|| Tracker: Bug
|| Difficulty: None
|| PR: None
|| Platform: None / None
```
## cv2.HOGDescriptor().compute() crashes python

```
With a subimage saved in file, the method crashes the python. The message is "This application has requested the Runtime to terminate it in an unusual way. Please contact the application's support team for more information"

The code:

<pre><code class="python">
import cv2
import numpy as np

moto = cv2.imread('I:\\BOUNDREC\\0.jpg',0)
hog =  cv2.HOGDescriptor()
desc = hog.compute(moto)
</code></pre>
```
## History
##### Andrey Kamaev on 2012-06-15 06:37

```
Could you attach the image?
-   Description changed from With a subimage saved in file, the method
    crashes the python. The message is ... to With a subimage saved in
    file, the method crashes the python. The message is ... More
-   Assignee set to Kalyf Abdalla Buzar Lima
```
##### Kirill Kornyakov on 2012-06-15 07:36

```
I've set python category, but we should test it with C++. May be this problem comes from the native ode.
-   Category set to python bindings
```
Repository: opencv
Issue: Display special chars using Qt
Labels: auto-transferred,priority: normal,feature,category: highgui-gui

Transferred from http://code.opencv.org/issues/2061

```
|| Caius Suliman on 2012-06-18 12:20
|| Priority: Normal
|| Affected: None
|| Category: highgui-gui
|| Tracker: Feature
|| Difficulty: None
|| PR: None
|| Platform: None / None
```
## Display special chars using Qt

```
Are you going to implement a method for getting the text size in pixels for Qt? One that will do the same job as getTextSize()?
```
## History
##### Caius Suliman on 2012-06-18 13:14

```
Can you add other font sets that support output for special characters using putText() and not addText()?
```
##### Andrey Kamaev on 2012-06-25 09:27

```
We are not going to implement such methods in upcoming releases but your patch is welcomed.
-   Category set to highgui-images
-   Tracker changed from Bug to Feature
```
##### Andrey Kamaev on 2012-08-16 15:34

```
-   Category changed from highgui-images to highgui-gui
```
Repository: opencv
Issue: Restriction on principal point
Labels: auto-transferred,priority: normal,feature,category: calib3d

Transferred from http://code.opencv.org/issues/2109

```
|| Pranav Kant  Gaur on 2012-06-28 09:26
|| Priority: Normal
|| Affected: None
|| Category: calibration, 3d
|| Tracker: Feature
|| Difficulty: None
|| PR: None
|| Platform: None / None
```
## Restriction on principal point

```
Hi,
If we want to calibrate a projector,for that principal point can be beyond image dimensions but a check here:
http://code.opencv.org/projects/opencv/repository/entry/tags/2.4.1/opencv/modules/calib3d/src/calibration.cpp#L1564

forces to provide principal point within image dimensions.I know it is meant for camera but now it is common to calibrate projector also using *cvcalibratecamera2()* since projector is modeled as an inverse camera.
```
## History
Repository: opencv
Issue: cv::stereoRectify: add a flag for horizontal/vertical stereo
Labels: auto-transferred,priority: normal,feature,category: calib3d

Transferred from http://code.opencv.org/issues/2133

```
|| Tobias Langner on 2012-07-02 18:17
|| Priority: Normal
|| Affected: None
|| Category: calibration, 3d
|| Tracker: Feature
|| Difficulty: None
|| PR: None
|| Platform: None / None
```
## cv::stereoRectify: add a flag for horizontal/vertical stereo

```
Allow the user to choose whether to use the horizontal or the vertical stereo. The default should be the automatic choice (as it is now).
```
## History