sharjeelyunus/github-issues-dataset huggingface dataset:
Repository: opencv
Issue: stereoRectifyUncalibrated doesn't accept the same type of array as findFundamentalMat
Labels: bug,auto-transferred,priority: normal,category: calib3d

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

```
|| Julien Rebetez on 2012-09-13 21:38
|| Priority: Normal
|| Affected: None
|| Category: calibration, 3d
|| Tracker: Bug
|| Difficulty: None
|| PR: None
|| Platform: None / None
```
## stereoRectifyUncalibrated doesn't accept the same type of array as findFundamentalMat

```
stereoRectifyUncalibrated's documentation states that for the points1 and points2 parameters, the same format as in findFundamentalMat is accepted.
But providing a 2xN or Nx2 array (which are working fine with findFundamentalMat) will trigger the following error :

<pre>
error: /home/julien/tm/libs/OpenCV/modules/calib3d/src/calibration.cpp:2649: error: (-215) CV_IS_MAT(_points1) && CV_IS_MAT(_points2) && (_points1->rows == 1 || _points1->cols == 1) && (_points2->rows == 1 || _points2->cols == 1) && CV_ARE_SIZES_EQ(_points1, _points2) in function cvStereoRectifyUncalibrated
</pre>

By looking at the source code, cvStereoRectifyUncalibrated has the following assert :

    CV_Assert( CV_IS_MAT(_points1) && CV_IS_MAT(_points2) &&
        (_points1->rows == 1 || _points1->cols == 1) &&
        (_points2->rows == 1 || _points2->cols == 1) &&
        CV_ARE_SIZES_EQ(_points1, _points2) );


And cvFindFundamentalMat has the following (which doesn't enforce rows == 1 or cols == 1) :

    CV_Assert( CV_IS_MAT(points1) && CV_IS_MAT(points2) && CV_ARE_SIZES_EQ(points1, points2) );


I also found this discussion which seems to be about this problem :
http://opencv-users.1802565.n2.nabble.com/StereoRectifyUncalibrated-not-accepting-same-array-as-FindFundamentalMat-td5149185.html
```
## History
##### Andrey Pavlenko on 2012-09-18 08:45

```
-   Assignee set to Vadim Pisarevsky
```
##### Andrey Pavlenko on 2012-09-18 08:47

```
-   Assignee changed from Vadim Pisarevsky to Ilya Lysenkov
```
##### Vadim Pisarevsky on 2012-10-04 10:11

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

```
-   Target version set to Next Hackathon
```
Repository: opencv
Issue: FileStorage segfaults parsing singleton tags 
Labels: auto-transferred,feature,priority: low,category: core

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

```
|| Hilton Bristow on 2012-10-10 07:36
|| Priority: Low
|| Affected: None
|| Category: core
|| Tracker: Feature
|| Difficulty: None
|| PR: 
|| Platform: None / None
```
## FileStorage segfaults parsing singleton tags 

```
OpenCV 2.4.2 cv::FileStorage segfaults when parsing singleton tags.

It will happily parse empty tags of the form:
<pre>
<variable></variable>
</pre>

But fails in the case where an empty tag is expressed in the form:
<pre>
<variable />
</pre>

Some libraries such as XML parsers within python automatically condense empty tags into this singleton format, so it would be great to be able to parse them correctly (either simply ignoring the variable or setting it to some default null value)

H
```
## History
##### Daniil Osokin on 2012-10-16 04:27

```
Hi! Please, attach a test to reproduce this bug.
-   Assignee changed from Vadim Pisarevsky to Hilton Bristow
```
##### Daniil Osokin on 2012-10-16 04:36

```
-   Target version deleted (2.4.3)
```
##### Vadim Pisarevsky on 2012-10-16 11:08

```
since OpenCV itself does not produces singleton tags and the XMLs read using OpenCV are also created using OpenCV, priority of the bug is lowered
-   Target version set to 3.0
-   Priority changed from Normal to Low
```
##### Kirill Kornyakov on 2013-04-11 15:10

```
Contributors are welcome!
-   Description changed from OpenCV 2.4.2 cv::FileStorage segfaults when
    parsing singleton tags. It will ... to OpenCV 2.4.2 cv::FileStorage
    segfaults when parsing singleton tags. It will ... More
-   Assignee deleted (Hilton Bristow)
-   Tracker changed from Bug to Feature
```
Repository: opencv
Issue: Multi Otsu Threshold
Labels: auto-transferred,priority: normal,feature,category: imgproc,category: video

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

```
|| Anthony Simpson on 2012-10-18 09:40
|| Priority: Normal
|| Affected: None
|| Category: imgproc, video
|| Tracker: Feature
|| Difficulty: None
|| PR: None
|| Platform: None / None
```
## Multi Otsu Threshold

```
It would be really great, if one of you could implement the Multi Otsu Threashold algorithm, which is discribed in http://www.iis.sinica.edu.tw/page/jise/2001/200109_01.pdf
```
## History
Repository: opencv
Issue: Modulo operation for Mat type
Labels: auto-transferred,feature,priority: low,category: core

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

```
|| nicolas martin on 2012-10-29 06:33
|| Priority: Low
|| Affected: None
|| Category: core
|| Tracker: Feature
|| Difficulty: None
|| PR: 
|| Platform: None / None
```
## Modulo operation for Mat type

```
Every other operations (or so) are implemented ..
Is there a reason this one is not ?

As usual, there could be Mat % Scalar or Mat % Mat.
I suppose it could be done for integer type matrices and floating point as well (the operation is well defined even for negative numbers).
```
## History
##### Vadim Pisarevsky on 2012-11-21 10:07

```
Well, probably because you are the first to submit such feature request (when the divisor is a power of two, it can be done with bitwise_and). Could you say where such operation is used?
-   Priority changed from Normal to Low
-   Assignee set to Vadim Pisarevsky
-   Category set to core
```
##### nicolas martin on 2013-02-12 02:49

```
For example, I had a map of angles and I needed to get values mod 2PI.
A simple (mat % M_2_PI) would have been nice.
```
##### Kirill Kornyakov on 2013-02-12 05:55

```
Actually you can work on implementation and submit it as a pull request on the GitHub. But in order to increase the probability of integration you could provide some more examples where such function is needed. OpenCV API is not going to grow much, because it results in high maintenance cost. So, if some code is not "must have", it should stay outside of the main OpenCV modules.
```
Repository: opencv
Issue: Download only python module
Labels: auto-transferred,priority: normal,feature,category: python bindings,category: build/install,category: infrastructure

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

```
|| abid rahman on 2012-11-04 03:49
|| Priority: Normal
|| Affected: None
|| Category: python bindings
|| Tracker: Feature
|| Difficulty: None
|| PR: None
|| Platform: None / None
```
## Download only python module

```
Hi,

Everytime new OpenCV is released, users have to download full exe file(for windows) which is >200MB size. But this link (http://www.lfd.uci.edu/~gohlke/pythonlibs/#opencv) shows python users need to download just <20MB file to start working with new OpenCV. But that repo is not upgraded yet to 2.4.3. 

So is there any way to download only the required builds of latest OpenCV?

Also is it possible to get daily builds of Python module?
```
## History
Repository: opencv
Issue: Improve readability of InputArray type arg-s in func-s signature
Labels: auto-transferred,feature,priority: low,category: core

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

```
|| Andrey Pavlenko on 2012-11-06 14:32
|| Priority: Normal
|| Affected: None
|| Category: core
|| Tracker: Feature
|| Difficulty: None
|| PR: None
|| Platform: None / None
```
## Improve readability of InputArray type arg-s in func-s signature

```
[from ECCV-2012 / Mobile OpenCV tutorial / wishlist brainstorm]
Some of OpenCV functions ( e.g. @cv::add()@ ) accepts input arg-s of almost any types, so @InputArray@ works like a charm here.
But there are some others that expect @InputArray@-s of particular type(s) only, and use of @InputArray@ type for input arg-s here complicates their usage. Examples:

* @findHomography@: the @InputArray srcPoints, InputArray dstPoints@ are expected to be 2D points vector, i.e. @std::vector<Point2{i,f,d}>, Mat 1xN or Nx1 CV_{32S,32F,64F}C2@
* @convexityDefects@: the @InputArray _points@ is expected to be @std::vector<Point2i>, Mat 1xN or Nx1 CV_32SC2@
* @calcOpticalFlowPyrLK@:
** @InputArray prevImg, InputArray nextImg@ are expected to be gray-scale images (@8UC1@) or pyramid (@std::vector<Mat>@)
** @InputArray prevPts, CV_OUT InputOutputArray nextPts@ are expected to be Point2f vector
and etc.
Even for @cv::add()@ the @InputArray src2@ can be not only image but @cv::Scalar@ as well!

The suggestion is to define a set of @typedef@-s that will help to understand what is expected and use them in signatures.

The potential candidates for the improvement are:
# randu
# randn
# inRange
# goodFeaturesToTrack
# findFundamentalMat
# cornerSubPix
# minEnclosingCircle
# findHomography
# solvePnP
# distCoeffs
# solvePnPRansac
# distCoeffs
# calcOpticalFlowPyrLK
# fitEllipse
# fillPoly
# polylines
# fillConvexPoly
# boundingRect
# approxPolyDP
# arcLength
# pointPolygonTest
# minAreaRect
# getAffineTransform
# hconcat
# vconcat
# undistortPoints
# checkRange
# meanStdDev
# drawContours
# findContours
# convexityDefects
# isContourConvex
# convexHull
# projectPoints
# distCoeffs
# initCameraMatrix2D
# findChessboardCorners
# drawChessboardCorners
```
## History
Repository: opencv
Issue: cvGetWindowHandle with QT windows don't work
Labels: bug,auto-transferred,priority: normal,category: highgui-gui

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

```
|| Thibault Lelore on 2012-11-10 17:21
|| Priority: Normal
|| Affected: None
|| Category: highgui-gui
|| Tracker: Bug
|| Difficulty: None
|| PR: None
|| Platform: None / None
```
## cvGetWindowHandle with QT windows don't work

```
This method should return an HWND in case of Win32 and GtkWidget in case of GTK+.
But when using QT windows, the method return a CvWindow* which is not usefull as this class is not available for end-users...
```
## History
Repository: opencv
Issue: Accepting vector<Point2d> instead of vector<Point> (for consistency and convenience)
Labels: auto-transferred,priority: normal,feature,category: core

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

```
|| Michael Burdinov on 2012-11-27 06:38
|| Priority: Normal
|| Affected: None
|| Category: core
|| Tracker: Feature
|| Difficulty: None
|| PR: None
|| Platform: None / None
```
## Accepting vector<Point2d> instead of vector<Point> (for consistency and convenience)

```
Point can be initialized from Point2d. As a result functions that require Point as input, are also accepting Point2d. But if function requires vector<Point> than vector<Point2d> won't be accepted (in drawContours for example). As a result I need to create and fill vector<Point> before each call to those functions. It would be better if functions that require vector<Point> as input will also accept vector<Point2d>.
```
## History
Repository: opencv
Issue: VideoCapture is retrieving images always with 3 channels
Labels: auto-transferred,priority: normal,feature,category: videoio

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

```
|| Greg Phil on 2012-11-27 15:37
|| Priority: Normal
|| Affected: None
|| Category: highgui-video
|| Tracker: Feature
|| Difficulty: None
|| PR: None
|| Platform: None / None
```
## VideoCapture is retrieving images always with 3 channels

```
Hello guys,

I realized that while retrieving images from an AVI using VideoCapture they have always three channels (while using Mat.type() == 16) even if the AVI file is containing only 8bit GRAYSCALE images. This quite annoying if you have to debayer these images.
```
## History
##### Kirill Kornyakov on 2012-11-28 07:52

```
Greg,

# Could you please attach a small input video for your case? 
# The annoying code sample could be also helpful.
-   Assignee changed from Vadim Pisarevsky to Greg Phil
-   Tracker changed from Bug to Feature
```
Repository: opencv
Issue: BruteForceMatcher : Custom norm types don't work since v2.4
Labels: auto-transferred,feature,priority: low,category: features2d

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

```
|| Anne-Marie Tousch on 2012-11-29 08:55
|| Priority: Low
|| Affected: None
|| Category: features2d
|| Tracker: Feature
|| Difficulty: None
|| PR: 
|| Platform: None / None
```
## BruteForceMatcher : Custom norm types don't work since v2.4

```
There's a major difference between 2.3.x and 2.4.x in @BruteForceMatcher@. Since commit 957e80ab, BruteForceMatcher takes an (@int normType@) instead of a Distance. Code using custom norms is now broken, and I don't quite see how to use a custom distance without modifying library code.
I was trying to use FREAKS (https://github.com/kikohs/freak) & BRISK (http://www.asl.ethz.ch/people/lestefan/personal/BRISK) author's code.

PS: I think it is an issue. Feel free to tell me if I should have submitted it somewhere else as a question instead. I was about to comment the change on GitHub, but I don't know what's your practice in this case.
```
## History
##### Kirill Kornyakov on 2012-11-30 06:11

```
Anne-Marie,

If you're not sure if something is issue or not, please post your question to the answers.opencv.org. It is possible that you should another approach, and community may suggest something.

Maria, 

If you can confirm that this is not an issue, let's close this ticket. But please explain how one can use custom norm...
-   Priority changed from Normal to Low
-   Description changed from There's a major difference between 2.3 and
    2.4 in BruteForceMatcher. Since co... to There's a major difference
    between 2.3.x and 2.4.x in @BruteForceMatcher@. Si... More
-   Assignee set to Maria Dimashova
-   Category set to features2d
-   Tracker changed from Bug to Feature
```
##### Anne-Marie Tousch on 2012-12-04 16:06

```
Hi Kirill,

I've asked a question as suggested, you can find it here: http://answers.opencv.org/question/4891/how-can-i-use-a-custom-norm-with-bruteforcematcher/.
I've seen a couple similar questions on how to match Freaks, unanswered. I think i've dug more than they did.

Best regards,
Anne-Marie
```
##### Anna Kogan on 2012-12-06 07:39

```
Hello Anne-Marie,

Thank you! If you can suggest a solution, a patch or pull request there: http://opencv.org/opencv-pull-requests-test-results.html would be highly appreciated!
```
Repository: opencv
Issue: cv::FileStorage does not support serialization of "unsigned int" and "size_t"
Labels: auto-transferred,feature,priority: low,category: core

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

```
|| Stefan R on 2012-11-29 09:55
|| Priority: Low
|| Affected: None
|| Category: core
|| Tracker: Feature
|| Difficulty: None
|| PR: None
|| Platform: None / None
```
## cv::FileStorage does not support serialization of "unsigned int" and "size_t"

```
As the title says: The cv::FileStorage does not support the serialization of the types "unsigned int" and "size_t".

Tested with Win 7, MSVC 9.0 SP1, x64, OpenCV 2.4.3 (builds from websites)

Example:
<pre>
#include <cstdio>
#include <cstdlib>
#include <string>
#include <iostream>
#include <algorithm>
#include <vector>

#include <cxcore.h>

int main(int argc, char* argv[])
{
    int           a = 5;
    unsigned int  b = 5;
    size_t        c = 5;

    cv::FileStorage fs("test.yaml", cv::FileStorage::WRITE);
    CV_Assert( fs.isOpened() );
    fs << "int"           << a; // works
    fs << "unsigned int"  << b; // compile error, see below
    fs << "size_t"        << c; // compile error, see below
    fs.release();
}
</pre>

Compile error:
<pre>
1>F:\dev\toolbox\libs\OpenCV\OpenCV-2.4.3\opencv\build\include\opencv2/core/operations.hpp(2908) : error C2668: 'cv::write' : ambiguous call to overloaded function
1>        F:\dev\toolbox\libs\OpenCV\OpenCV-2.4.3\opencv\build\include\opencv2/core/operations.hpp(2706): could be 'void cv::write(cv::FileStorage &,const std::string &,double)'
1>        F:\dev\toolbox\libs\OpenCV\OpenCV-2.4.3\opencv\build\include\opencv2/core/operations.hpp(2705): or       'void cv::write(cv::FileStorage &,const std::string &,float)'
1>        F:\dev\toolbox\libs\OpenCV\OpenCV-2.4.3\opencv\build\include\opencv2/core/operations.hpp(2704): or       'void cv::write(cv::FileStorage &,const std::string &,int)'
1>        while trying to match the argument list '(cv::FileStorage, std::string, const unsigned int)'
1>        .\src\main.cpp(36) : see reference to function template instantiation 'cv::FileStorage &cv::operator <<<unsigned int>(cv::FileStorage &,const _Tp &)' being compiled
1>        with
1>        [
1>            _Tp=unsigned int
1>        ]
</pre>

It is actually sufficient to cast a size_t value to int before storing. But I guess the error message could be more helpful and many users will be confused.

It would be easy to add the corresponding overloads, at least if YAML/XML support these types. Otherwise an implicit type conversion would have to be done.
This then must be communicated to the user who reads the corresponding storage back into memory.
```
## History
##### Kirill Kornyakov on 2012-11-30 06:18

```
Stefan, your suggestion is nice, thanks! But again, since you've already thought about the implementation, the best you can do is to implement the feature on your side and submit a pull request. None of OpenCV devs is going to work with the FileStorage class in the observable future...
```
Repository: opencv
Issue: cv::CascadeClassifier has no deep copy clone
Labels: auto-transferred,priority: normal,feature,category: objdetect

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

```
|| Alexander Haase on 2012-12-05 17:11
|| Priority: Normal
|| Affected: None
|| Category: objdetect
|| Tracker: Feature
|| Difficulty: None
|| PR: 
|| Platform: None / None
```
## cv::CascadeClassifier has no deep copy clone

```
I'm currently using a CascadeClassifier per thread. Currently the only way to propagate changes to the classifier is to   write to a file, then reload the classifier in each thread from the file path. It would be nice if there was a cv::CascadeClassifier::clone() method for deep copying.
```
## History
##### Anna Kogan on 2012-12-06 07:10

```
-   Target version set to 3.0
-   Assignee set to Maria Dimashova
-   Category set to ml
```
##### Anna Kogan on 2012-12-06 10:45

```
-   Assignee changed from Maria Dimashova to Marina Kolpakova
```
##### Marina Kolpakova on 2012-12-06 10:46

```
-   Category changed from ml to objdetect
```
##### Marina Kolpakova on 2013-04-05 23:28

```
-   Assignee deleted (Marina Kolpakova)
```
Repository: opencv
Issue: imshow using cl_khr_gl_sharing extension to show images
Labels: auto-transferred,priority: normal,feature,category: ocl

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

```
|| KOLANICH KOLANICH on 2012-12-09 10:41
|| Priority: Normal
|| Affected: None
|| Category: ocl
|| Tracker: Feature
|| Difficulty: None
|| PR: 
|| Platform: None / None
```
## imshow using cl_khr_gl_sharing extension to show images

```
It is possible to render image to screen without converting into cv::Mat (and without transfering into RAM if it was placed into the memory of the same GPU which will render it) using cl_khr_gl_sharing extension.
```
## History
##### Vadim Pisarevsky on 2012-12-16 17:38

```
-   Assignee set to yao wang
-   Category set to ocl
```
Repository: opencv
Issue: Default behavior of iOS video camera is to not use preview layer
Labels: bug,auto-transferred,priority: normal,platform: ios/osx

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

```
|| Aditya Sankar on 2012-12-12 00:12
|| Priority: Normal
|| Affected: None
|| Category: ios
|| Tracker: Bug
|| Difficulty: None
|| PR: 
|| Platform: None / None
```
## Default behavior of iOS video camera is to not use preview layer

```
This conflicts with the tutorial posted here: http://docs.opencv.org/doc/tutorials/ios/video_processing/video_processing.html

To resolve, users must manually enable preview layer use with: 

@self.videoCamera.useAVCaptureVideoPreviewLayer = YES;@

Proposed fix in root/modules/highgui/src/cap_ios_video_camera.mm Line 87:
@self.useAVCaptureVideoPreviewLayer = YES;@
```
## History
##### Alexander Shishkov on 2012-12-12 09:52

```
-   Target version deleted (2.4.4)
```
Repository: opencv
Issue: filterSpeckles() and fails on large imagery
Labels: bug,auto-transferred,priority: low,category: calib3d

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

```
|| Mathias Rothermel on 2012-12-14 19:08
|| Priority: Low
|| Affected: None
|| Category: calibration, 3d
|| Tracker: Bug
|| Difficulty: None
|| PR: 
|| Platform: None / None
```
## filterSpeckles() and fails on large imagery

```
Hi guys!

I use your function void *filterSpeckles(...)* for filtering disparity images. Experienced some problems with large imagery. The size of the allocated buffer *_buf* is casted to an int.
@
_buf.create(1, (int)bufSize, CV_8U);
@

As dimensions of rectified images sometimes are rather large (at least in my rectification module) *bufSize* might overflow. Did some dirty workaround by allocating my own buffer
@
unsigned int  npixels = (unsigned int)width * (unsigned int)height;
unsigned char* _buf=new unsigned char [npixels];
@
and deleting it at the end.

Cheers & keep up your great work!
Matze
```
## History
Repository: opencv
Issue: 'solve' fucntion works badly on ill-conditioned matrices (atleast numpy works better)
Labels: auto-transferred,feature,priority: low,category: core

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

```
|| Alexander Mordvintsev on 2012-12-21 10:50
|| Priority: Low
|| Affected: None
|| Category: core
|| Tracker: Feature
|| Difficulty: None
|| PR: 
|| Platform: None / None
```
## 'solve' fucntion works badly on ill-conditioned matrices (atleast numpy works better)

```
Related issue: #2643

<pre>
import numpy as np
import numpy.linalg as la
import cv2

A = np.float64([[8.193152026529024541e+07, 3.256524952090702206e+07, 1.280089998874972807e+05],
                [3.256524952090702206e+07, 1.432970570196110941e+07, 5.087970962876405974e+04],
                [1.280089998874972807e+05, 5.087970962876405974e+04, 2.000000000000000000e+02]])
B = np.float64( [3.543302075289976597e+07, 1.408204120224751532e+07, 5.536028820708069543e+04] )

print la.svd(A)[1]

x = la.solve(A, B)
x1 = cv2.solve(A, B, flags=cv2.DECOMP_QR)[1].ravel()
x2 = cv2.solve(A, B, flags=cv2.DECOMP_LU)[1].ravel()

print la.norm( A.dot(x) - B )  # 0.000149714585044  
print la.norm( A.dot(x1) - B ) # 0.0858401225198    
print la.norm( A.dot(x2) - B ) # 219.692813301      
</pre>
```
## History
##### Alexander Mordvintsev on 2012-12-21 13:19

```
Not sure if this should be fixed at all (see fix to #2643)
-   Priority changed from Normal to Low
```
##### Kirill Kornyakov on 2013-04-11 15:12

```
Looks more like a feature request. Please correct me if I'm wrong.
-   Tracker changed from Bug to Feature
```
Repository: opencv
Issue: KDTree from core.h crashes on simple point configurations
Labels: bug,auto-transferred,priority: low,category: core

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

```
|| Alexander Mordvintsev on 2012-12-24 12:22
|| Priority: Low
|| Affected: None
|| Category: core
|| Tracker: Bug
|| Difficulty: None
|| PR: 
|| Platform: None / None
```
## KDTree from core.h crashes on simple point configurations

```
Code:
<pre>
#include <opencv2/core/core.hpp>

int main()
{
   float data[8] = {926, 693, 931, 817, 926, 651, 1293, 513};
   cv::Mat p(4, 2, CV_32F, data);
   cv::KDTree tree(p);
   return 0;
}
</pre>

gives:

<pre>
OpenCV Error: Assertion failed (std::abs(more - less) <= 1) in unknown function, file
..\..\..\modules\core\src\datastructs.cpp, line 3612
</pre>
```
## History
##### Alexander Mordvintsev on 2012-12-24 15:29

```
It seems that KDTree is superseded by FLANN kd-tree (with checks==FLANN_CHECKS_UNLIMITED). Changing priority to low.
Should KDTree be moved to legacy? Or we may consider switching to flann-based KDTree implementation for simple exact 2d/3d point queries.
-   Priority changed from Normal to Low
```