id
int64 393k
2.82B
| repo
stringclasses 68
values | title
stringlengths 1
936
| body
stringlengths 0
256k
⌀ | labels
stringlengths 2
508
| priority
stringclasses 3
values | severity
stringclasses 3
values |
|---|---|---|---|---|---|---|
97,412,884 | opencv | CascadeClassifier::detectMultiScale() const? | Transferred from http://code.opencv.org/issues/1217
```
|| Josh Klontz on 2011-07-12 13:47
|| Priority: Normal
|| Affected: None
|| Category: objdetect
|| Tracker: Feature
|| Difficulty: None
|| PR: None
|| Platform: None / None
```
## CascadeClassifier::detectMultiScale() const?
```
It would be great to a have a const version of detectMultiScale for multi-threaded use, or alternatively, some way to copy/clone cascades. Currently it appears that the only way to run multiple cascades simultaneously is to construct them repeatedly from disk. This becomes cumbersome when trying to thread at a per image basis which necessitates the construction of a new cascade for each image.
On a related note, it appears that the default copy constructor for CascadeClassifier ought to be disabled as it does not appear to make a deep copy and thus does not provide a solution for thread safety.
```
## History
##### Alexander Shishkov on 2012-02-12 20:56
```
- Description changed from It would be great to a have a const version
of detectMultiScale for multi-thr... to It would be great to a have
a const version of detectMultiScale for multi-thr... More
```
##### Matthew Newman on 2012-03-04 23:42
```
It is possible (with the new format cascades at least) to use cv::FileStorage to avoid reading from disk repeatedly (see http://stackoverflow.com/questions/7285480/opencv-cascadeclassifier-c-interface-in-multiple-threads), but I agree that this is not a great solution.
Given a bit of input from a developer regarding their preferred solution I'd be willing to work on this issue, as thread safety is something my company requires.
```
##### Jose Gómez on 2013-11-29 20:50
```
There is a ticket requesting a clone() for the CascadeClassifier: http://code.opencv.org/issues/2600
Nevertheless, thread safety would probably be a more elegant solution.
```
| auto-transferred,priority: normal,feature,category: objdetect | low | Minor |
97,412,980 | opencv | add scrollbars to highgui windows | Transferred from http://code.opencv.org/issues/1229
```
|| Vadim Pisarevsky on 2011-07-17 10:23
|| Priority: Low
|| Affected: None
|| Category: highgui-gui
|| Tracker: Feature
|| Difficulty: None
|| PR: None
|| Platform: None / None
```
## add scrollbars to highgui windows
```
in the case of large-resolution images the highui windows displaying them are getting big and do not fit the screen. adding scrollbars to solve the problem would be a useful addition.
the original request is here: #1225
```
## History
##### Alexander Shishkov on 2012-03-21 20:25
```
- Priority changed from Normal to Low
```
##### Andrey Kamaev on 2012-04-10 11:17
```
- Description changed from in the case of large-resolution images the
highui windows displaying them are... to in the case of
large-resolution images the highui windows displaying them are...
More
```
##### Xing Chen on 2012-07-06 00:40
```
I've been suffering from the problem for a long time. A scrollbar is really very very important for inspecting large images.
Currently, when I'm looking at a large image, I have to re-scale the image, which means that some details will be changed. If I don't resize the image, I can't even see some part of the image.
I really believe this should be a basic feature for an image viewer for scientific purposes. If somebody would raise it's priority and work on it, I will be very grateful. Thanks.
```
##### Xing Chen on 2012-07-06 03:59
```
Alternatively, if introducing a scrollbar is too hard, maybe we can add an option to show the status bar on the top-left of the window, so that one can at least know the basic information (position and RGB value) of the visible pixels.
```
##### Andrey Kamaev on 2012-08-16 15:36
```
- Category changed from highgui-images to highgui-gui
```
| auto-transferred,feature,priority: low,category: highgui-gui | low | Minor |
97,413,014 | opencv | Cannot change video size in a thread | Transferred from http://code.opencv.org/issues/1241
```
|| Pavel Gurevich on 2011-07-20 16:23
|| Priority: Normal
|| Affected: branch '2.4' (2.4-dev)
|| Category: highgui-camera
|| Tracker: Bug
|| Difficulty:
|| PR:
|| Platform: Any / Any
```
## Cannot change video size in a thread
```
Changing resolution using
videoCapture -> set( CV_CAP_PROP_FRAME_WIDTH, width )
works fine in the main thread but has no effect inside a thread.
```
## History
##### Vadim Pisarevsky on 2011-10-05 01:26
```
which OS do you use and what does CMake report in the summary section about video capturing?
```
##### Alexander Shishkov on 2012-03-21 20:23
```
- Target version deleted ()
- Priority changed from High to Normal
```
##### Andrey Kamaev on 2012-03-24 17:36
```
- Category changed from imgproc, video to highgui-images
```
##### Alexander Shishkov on 2012-03-25 20:31
```
- Priority changed from Normal to Low
```
##### Alexander Shishkov on 2012-03-25 20:46
```
- Assignee deleted (Vadim Pisarevsky)
```
##### Pavel Gurevich on 2012-03-25 23:05
```
I managed to made this work. The problem is that by default (as of 2.3.1) in the file cap_dshow.cpp which has a copy of videoinput library, the following define is commented out:
//if you need VI to use multi threaded com
#define VI_COM_MULTI_THREADED
Setting it will fix the issue. This is obviously a compile-time decision, and there is no build-time option for this. So, the question is if the current default is a good one.
```
##### Alexander Shishkov on 2012-03-25 23:08
```
- Priority changed from Low to Normal
- Tracker changed from Bug to Patch
```
##### Alexander Reshetnikov on 2012-03-30 09:58
```
- Assignee set to Vadim Pisarevsky
```
##### Alexander Shishkov on 2012-04-05 12:44
```
- Target version deleted ()
```
##### Pavel Gurevich on 2012-07-24 16:38
```
As of 2.4.2, even the previous work-around stopped working. I saw much changes in the file cap_dshow.cpp, but meanwhile I cannot isolate the cause problem.
Meanwhile, I've noticed that the whole code section that initialized/deinitialized COM is commented out.
However, when I play with the values of tryWidth and tryHeight I do get the desired capture resolutions.
Currently seems like a degradation from the previous version (and the previous version of the file cannot be just dropped in because of the compilation problems).
```
##### Andrey Kamaev on 2012-08-16 15:39
```
- Category changed from highgui-images to highgui-camera
```
##### Kirill Kornyakov on 2013-02-15 11:40
```
Pavel, could you please attach a repro code sample?
- Affected version set to 2.4.2
- Assignee changed from Vadim Pisarevsky to Pavel Gurevich
```
##### Maksim Shabunin on 2015-07-21 09:10
```
- Affected version changed from 2.4.2 to branch '2.4' (2.4-dev)
- Operating System set to Any
- HW Platform set to Any
```
##### Maksim Shabunin on 2015-07-21 09:10
```
- Tracker changed from Patch to Bug
```
| bug,auto-transferred,priority: normal,affected: 2.4,category: videoio(camera) | low | Critical |
97,413,106 | opencv | negative cursor position overflow in python mouse callbacks | Transferred from http://code.opencv.org/issues/1302
```
|| Alexander Mordvintsev on 2011-08-13 09:04
|| Priority: Low
|| Affected: None
|| Category: python bindings
|| Tracker: Bug
|| Difficulty: None
|| PR: None
|| Platform: None / None
```
## negative cursor position overflow in python mouse callbacks
```
Mouse callback x, y params are unsigned 16-bit, while they may become negative when used holds a mouse button and drugs it behind upped left window corner.
See python2/camshift.py 'onmouse' function work workaround (marked with 'BUG' comment)
```
## History
##### Alexander Shishkov on 2012-03-21 14:08
```
- Target version deleted ()
- Subproject of set to #1437
```
##### Alexander Shishkov on 2012-03-25 20:30
```
- Priority changed from Normal to Low
```
##### Alexander Shishkov on 2012-03-25 20:47
```
- Assignee deleted (Vadim Pisarevsky)
```
##### Alexander Shishkov on 2012-04-05 12:45
```
- Target version deleted ()
```
##### Vadim Pisarevsky on 2012-10-04 14:35
```
- Target version deleted ()
```
##### Kirill Kornyakov on 2012-10-24 08:39
```
- Target version set to Next Hackathon
```
| bug,auto-transferred,category: python bindings,priority: low | low | Critical |
97,413,373 | opencv | copyTo function support to slices of higher-dimensional matrixes. | Transferred from http://code.opencv.org/issues/1403
```
|| Denis Aleshin on 2011-09-30 16:14
|| Priority: High
|| Affected: None
|| Category: core
|| Tracker: Feature
|| Difficulty: None
|| PR: None
|| Platform: None / None
```
## copyTo function support to slices of higher-dimensional matrixes.
```
Currently, copyTo does not recognize when two matrix headers have the same (actual) size and total number of elements, and will allocate a new matrix for the destination.
A clear example is trying to copy an MxN matrix into a 1xMxN matrix.
This is an important case to address, since it often comes up when dealing with video volumes. If I have a [[TxMxN]] frame buffer, I want to construct a 1xMxN time slice header, and then copy my MxN frame into that location.
For instance, this does not work:
// depth_buf is TxMxN
// depth_border is MxN
Range rangesupdate[] = {Range(0,1), Range::all(), Range::all()};
Mat depth_to = depth_buf(rangesupdate);
depth_border.copyTo(depth_to);
// depth_to no longer points inside depth_buf.
```
## History
##### Alexander Shishkov on 2012-02-12 20:26
```
- Description changed from Currently, copyTo does not recognize when
two matrix headers have the same (a... to Currently, copyTo does not
recognize when two matrix headers have the same (a... More
```
| auto-transferred,feature,priority: low,category: core | low | Minor |
97,413,427 | opencv | weighted Hough | Transferred from http://code.opencv.org/issues/1410
```
|| ivansorokin - on 2011-10-07 15:17
|| Priority: Normal
|| Affected: None
|| Category: imgproc, video
|| Tracker: Feature
|| Difficulty: None
|| PR: None
|| Platform: None / None
```
## weighted Hough
```
Currently Hough transform take every point with the same weight: if the point is non zero then it increase every pixel value by one.
<pre><code class="cpp">
if( image[i * step + j] != 0 )
for( n = 0; n < numangle; n++ )
{
r = cvRound( j * tabCos[n] + i * tabSin[n] );
r += (numrho - 1) / 2;
accum[(n+1) * (numrho+2) + r+1]++;
}
</code></pre>
It would be great if it is possible to assign every point in image specific weight. For example, something like this:
<pre><code class="cpp">
if( image[i * step + j] != 0 )
for( n = 0; n < numangle; n++ )
{
r = cvRound( j * tabCos[n] + i * tabSin[n] );
r += (numrho - 1) / 2;
accum[(n+1) * (numrho+2) + r+1] += image[i * step + j];
}
</code></pre>
```
## History
##### Alexander Shishkov on 2012-03-21 12:43
```
- Description changed from Currently Hough transform take every point
with the same weight: if the point... to Currently Hough transform
take every point with the same weight: if the point... More
```
| auto-transferred,priority: normal,feature,category: imgproc,category: video | low | Minor |
97,413,553 | opencv | Problem Accessing Histogram Elements in Android Version of OpenCV | Transferred from http://code.opencv.org/issues/1447
```
|| soriel - on 2011-10-25 21:26
|| Priority: Normal
|| Affected: None
|| Category: java bindings
|| Tracker: Bug
|| Difficulty: None
|| PR: None
|| Platform: None / None
```
## Problem Accessing Histogram Elements in Android Version of OpenCV
```
I need to access the elements of a @Mat@ that is created by @Mat.calcHist@ call. However, it appears that @Mat.get@ does not return the correct set of values. Here is an example:
<pre><code class="java">
public void createHistogram(Bitmap img) {
Mat hist = new Mat();
Mat mat_img = Utils.bitmapToMat(img);
ArrayList<Mat> images = new ArrayList<Mat>();
List<Integer> channels = new ArrayList<Integer>();
List<Integer> histSize = new ArrayList<Integer>();
List<Float> ranges = new ArrayList<Float>();
images.add(mat_img);
channels.add(0);
channels.add(1);
channels.add(2);
// 10x10x10
histSize.add(10);
histSize.add(10);
histSize.add(10);
ranges.add(0.0f);
ranges.add(256.0f);
ranges.add(0.0f);
ranges.add(256.0f);
ranges.add(0.0f);
ranges.add(256.0f);
Imgproc.calcHist(images, channels, new Mat(), hist, histSize, ranges, false);
float[] data = new floatr10;
StringBuffer temp = new StringBuffer();
for (int r = 0; r < 10; r++)
for (int g = 0; g < 10; g++){
hist.get(r, g, data);
for (int b = 0; b < 10; b++)
temp.append(",").append(data[b])
}
Log.i(TAG, Core.sumElems(hist)); // Prints out the number of pixels in the image (correct)
Log.i(TAG, temp.toString()); // Prints out all 0s (Incorrect)
}
</code></pre>
```
## History
##### Kirill Kornyakov on 2012-02-14 15:16
```
Andrey, could you please look into this in the background.
- Target version set to 2.4.0
- Priority changed from High to Normal
- Assignee changed from Kirill Kornyakov to Andrey Pavlenko
```
##### Andrey Kamaev on 2012-02-25 12:23
```
- Description changed from I need to access the elements of a Mat that
is created by Mat.calcHist call. ... to I need to access the
elements of a @Mat@ that is created by @Mat.calcHist@ ca... More
```
##### Alexander Shishkov on 2012-03-21 11:38
```
- Target version deleted (2.4.0)
```
##### Alexander Shishkov on 2012-03-25 20:43
```
- Assignee deleted (Andrey Pavlenko)
```
##### Andrey Pavlenko on 2012-03-26 08:26
```
- Assignee set to Andrey Pavlenko
```
##### Andrey Pavlenko on 2012-04-02 12:32
```
Mat::get() and Mat::put() don't work for Mat-s of more than 2 dimensions.
- Target version set to 2.4.0
```
##### Andrey Pavlenko on 2012-04-26 11:58
```
The support of 3+ dimensional Mat-s in Java API will be done after 2.4 release.
Currently as a workaround I suggest use calcHist() for 1 or 2 channels only, e.g.:
<pre> <code class="java">
public void testCalcHistListOfMatListOfIntegerMatMatListOfIntegerListOfFloat3D() {
List<Mat> images = Arrays.asList(rgbLena);
Mat hist3D = new Mat();
List<Mat> histList = Arrays.asList( new Mat[] {new Mat(), new Mat(), new Mat()} );
MatOfInt histSize = new MatOfInt(10);
MatOfFloat ranges = new MatOfFloat(0f, 256f);
for(int i=0; i<rgbLena.channels(); i++)
{
Imgproc.calcHist(images, new MatOfInt(i), new Mat(), histList.get(i), histSize, ranges);
assertEquals(10, histList.get(i).checkVector(1));
}
Core.merge(histList, hist3D);
assertEquals(CvType.CV_32FC3, hist3D.type());
assertEquals(10, hist3D.checkVector(3));
Mat truth = new Mat(10, 1, CvType.CV_32FC3);
truth.put(0, 0,
0, 24870, 0,
1863, 31926, 1,
56682, 37677, 2260,
77278, 44751, 32436,
69397, 41343, 18526,
27180, 40407, 18658,
21101, 15993, 32042,
8343, 18585, 47786,
300, 6567, 80988,
0, 25, 29447
);
assertMatEqual(truth, hist3D, EPS);
}
</code></pre>
- Target version deleted (2.4.0)
```
##### Andrey Pavlenko on 2012-06-20 08:15
```
- Category changed from android to java bindings
```
| bug,auto-transferred,priority: normal,category: java bindings | low | Critical |
97,413,587 | opencv | Can't use BRIEF descriptor in BOW unless.... | Transferred from http://code.opencv.org/issues/1451
```
|| Bruno Nascimento on 2011-10-27 14:13
|| Priority: Normal
|| Affected: None
|| Category: features2d
|| Tracker: Feature
|| Difficulty: None
|| PR: None
|| Platform: None / None
```
## Can't use BRIEF descriptor in BOW unless....
```
commenting the line 2455 in features2d.hpp CV_Assert( DataType<ValueType>::type == matcher.trainDescCollection[iIdx].type() || matcher.trainDescCollection[iIdx].empty() );
and line 351 in matchers.cpp CV_Assert( queryDescriptors.type() == CV_32FC1 || queryDescriptors.empty() );
This happens because the brief descriptor results in integers, and BOW is expecting to use floats.
```
## History
##### Alexander Shishkov on 2012-02-12 20:19
```
- Description changed from commenting the line 2455 in features2d.hpp
CV_Assert( [[DataType]]<ValueTy... to commenting the line 2455 in
features2d.hpp CV_Assert( DataType<ValueType&g... More
```
##### Alexander Shishkov on 2012-03-21 11:34
```
- Target version deleted ()
```
##### Alexander Shishkov on 2012-03-22 14:33
```
- Target version deleted ()
```
| auto-transferred,priority: normal,feature,category: features2d | low | Minor |
97,413,620 | opencv | header files for python module | Transferred from http://code.opencv.org/issues/1471
```
|| demonstrate - on 2011-11-14 05:59
|| Priority: Normal
|| Affected: None
|| Category: python bindings
|| Tracker: Feature
|| Difficulty: None
|| PR: None
|| Platform: None / None
```
## header files for python module
```
Hi guys,
I am trying to write some functionality for opencv, which is mainly done with C++. But I am also thinking about providing a python module interface so as to carry out some easy experiments in python's code.
The critical thing is that I need interactions between my module and opencv's python module. E.g. I might open an image by calling cv.LoadImageM or cv2.imread and pass then PyObject to my module's function. Most of the functions (maybe some types too?) in the python module are marked as static functions, which forbids linking. And there is no header files provided by the module. Guys like me cannot simply include in my source and link to the module. I tried to copy some parts of the header in the python module but it doesn't work as expected.
Is there any specific development plan for this? I think it encourages people to contribute code in C++ and wrap it for python's friendly usages.
```
## History
##### Alexander Shishkov on 2012-02-12 20:17
```
- Description changed from Hi guys, I am trying to write some
functionality for opencv, which is mainly... to Hi guys, I am trying
to write some functionality for opencv, which is mainly... More
```
| auto-transferred,priority: normal,feature,category: python bindings | low | Minor |
97,413,655 | opencv | CreateVideoWriter does not report error | Transferred from http://code.opencv.org/issues/1476
```
|| ken_seehart - on 2011-11-17 21:46
|| Priority: Normal
|| Affected: None
|| Category: python bindings
|| Tracker: Bug
|| Difficulty: None
|| PR: None
|| Platform: None / None
```
## CreateVideoWriter does not report error
```
CreateVideoWriter should raise an exception when it fails, but does not.
<pre>
>>> import cv
>>> w = cv.CreateVideoWriter('nonexistentdir/foobar/myvid.mpg', cv.CV_FOURCC('Z','Y','X','W'), 5, (354,332), 1)
>>> w
<VideoWriter 02E5EC10>
>>>
>>> im = cv.LoadImage('logo_largel.png')
>>> cv.WriteFrame(w, im)
0
</pre>
Clearly, it should fail to open the output file for writing, and also fail due to the bogus ZYXW codec. Either of these conditions should raise an exception, or at least return something other than a healthy looking VideoWriter instance.
This is an important defect because without any error detection I am unable to troubleshoot my code.
As a side comment, the documentation does not state the meaning of the return value of cv.WriteFrame().
```
## History
##### ken_seehart - on 2011-12-01 00:18
```
Perhaps this should be expanded to a more general defect: The python bindings appear to have essentially no error handling whatsoever. A good start would be to forward cv::Exception into a python exception. Perhaps the C++ code needs more comprehensive error handling as well.
```
##### Alexander Shishkov on 2012-02-12 20:14
```
- Description changed from [[CreateVideoWriter]] should raise an
exception when it fails, but does not. ... to CreateVideoWriter
should raise an exception when it fails, but does not. &l... More
```
| bug,auto-transferred,priority: normal,category: python bindings | low | Critical |
97,413,690 | opencv | In python 'cv2.SURF.detect' is unusable with user-provided keypoints | Transferred from http://code.opencv.org/issues/1495
```
|| alexism - on 2011-11-30 09:51
|| Priority: Normal
|| Affected: None
|| Category: python bindings
|| Tracker: Bug
|| Difficulty: None
|| PR: None
|| Platform: None / None
```
## In python 'cv2.SURF.detect' is unusable with user-provided keypoints
```
In the cv2 python module, there is no way to provide user keypoints.
```
## History
##### Alexander Shishkov on 2012-03-21 10:56
```
- Target version deleted ()
- Priority changed from High to Normal
```
##### Alexander Shishkov on 2012-03-25 20:43
```
- Assignee deleted (Vadim Pisarevsky)
```
##### Alexander Shishkov on 2012-04-05 12:46
```
- Target version deleted ()
```
##### Mr. Luk on 2012-08-30 14:01
```
+1
```
##### Mr. Luk on 2012-08-31 13:11
```
Please find the patch attached. I added CV_IN_OUT to keypoints argument. The keypoints argument is now mandatory, even if useProvidedKeypoints is set to false. In this case, an None can be passed.
- File bug-1495-surf.diff added
```
| bug,auto-transferred,priority: normal,category: python bindings | low | Critical |
97,413,720 | opencv | Signficant slow down of SVD in OpenCV 2.3 | Transferred from http://code.opencv.org/issues/1498
```
|| jcstastny - on 2011-12-01 18:53
|| Priority: Normal
|| Affected: branch 'master' (2.4.9)
|| Category: core
|| Tracker: Bug
|| Difficulty: None
|| PR:
|| Platform: None / None
```
## Signficant slow down of SVD in OpenCV 2.3
```
When using @CvInvert@ with SVD method, OpenCV 2.3 is 3x slower than OpenCV 2.2.
Operating System: Windows
Compiler: MSVC 10
OpenCV Version - All versions of OpenCV 2.3
Same code attached was run using OpenCV 2.2 and OpenCV 2.3.1
Clearly identified @CvInverse@ is slowest component.
Timing tests with 1000 iterations:
OpenCV 2.2 - 9 seconds
OpenCV 2.3.1 - 33 seconds
Test Code below;
<pre><code class="cpp">
/**
* Test speed of linear algebra functions in OpenCV
*
**/
#include <opencv/cv.h>
#include <cstdio>
#include <cstdarg>
#include <cstdlib>
#include <iostream>
#include <fstream>
#include <cmath>
#include <cassert>
#include <ctime>
using namespace std;
void CovarMatrix (CvMat* CovMat, CvMat* FeatureVecs);
int main(int argc, char *argv[])
{
bool debug = false;
int FVLength = 64;
CvMat* avg = cvCreateMat(FVLength, 1, CV_64FC1);
CvMat* FeatVec = cvCreateMat(FVLength, 1, CV_64FC1);
CvMat* Anomaly = cvCreateMat(FVLength, 1, CV_64FC1);
CvMat* Ki = cvCreateMat(FVLength, FVLength, CV_64FC1);
CvMat* CovMat = cvCreateMat(FVLength, FVLength, CV_64FC1);
cvSetZero(CovMat);
CvMat* TotVecs = cvCreateMat(2,FVLength, CV_64FC1);
// Initialize the FeatVec and avg to be random
CvRNG rng_state = cvRNG(0xffffffff);
cvRandArr(&rng_state, FeatVec, CV_RAND_NORMAL, cvRealScalar(100), cvRealScalar(30));
cvRandArr(&rng_state, avg, CV_RAND_NORMAL, cvRealScalar(60), cvRealScalar(25));
// Start time
time_t start,end;
double dif;
time (&start);
unsigned int it = 10000;
for (int p = 0; p < it; p++)
{
cvSub(FeatVec, avg, Anomaly); // Find anomaly vector (feature-average)
//Ki is now going to be inverse covariance matrix
for (int k=0; k < FVLength; k++)
{
cvmSet(TotVecs,0,k,cvmGet(FeatVec,k,0));
cvmSet(TotVecs,1,k,cvmGet(avg,k,0));
}
// Next, find the covariance matrix of this.
CovarMatrix(CovMat, TotVecs);
cvInvert(CovMat, Ki, CV_SVD);
}
time(&end);
dif = difftime(end,start);
cout << "Time Ellapsed : " << dif << endl;
return 0;
}
void CovarMatrix (CvMat* CovMat, CvMat* Vecs)
{
int nums = Vecs->cols;
int Len = Vecs->rows;
int n = Vecs->cols; // step size
double *data = Vecs->data.db; // pointer to float with all values in input
double sum;
for (int j = 0; j < nums ; j++)
{
sum = 0;
for (int i = 0; i < Len; i ++)
sum += data[i * n + j];
sum = sum/Len;
for (int i =0; i < Len; i++)
{
data[i * n + j] -= sum;
}
}
CvMat* VecsT = cvCreateMat(nums, Len, CV_64FC1); // covariance matrix
cvTranspose( Vecs,VecsT );
cvMulTransposed( VecsT, CovMat, 0);
// scale CovMat by m-1
double *CovDat = CovMat->data.db; // pointer to float with all values in input
for (int i = 0; i < CovMat->rows; i++) // for each feature vector, find the mean, and subtract it
{
for (int j = 0; j < CovMat->cols; j ++)
{
CovDat[i * (CovMat->cols) + j] = CovDat[i * (CovMat->cols) + j] / (Len-1);
}
}
cvReleaseMat(&VecsT);
}
</code></pre>
```
## History
##### Vadim Pisarevsky on 2011-12-27 16:13
```
While the problem can not be fixed completely, since we moved to our own SVD implementation, which is much faster on small matrices and generally more accurate on large matrices (at the expense of speed), there is possible workaround -
Since the covariation matrix is symmetrical, you can use cvEigenVV to decompose it to V*E*V' (where V is an orthogonal matrix of eigenvectors and E is a diagonal matrix of eigenvalues) and then pass the matrix V twice to cvSVBkSb (since U=V).
In the latest trunk version (r7098 and higher) you can simply call cvInvert() and pass CV_SVD_SYM flag there.
- Pull request set to fixed
- Status changed from Open to Done
```
##### Andrey Kamaev on 2012-03-19 08:43
```
- Target version set to 2.4.0
- Description changed from When using [[CvInvert]] with SVD method,
[[OpenCV]]2.3 is 3x slower than [[Op... to When using @CvInvert@
with SVD method, OpenCV 2.3 is 3x slower than OpenCV 2.... More
```
##### Ming-Ming Cheng on 2012-05-23 11:15
```
I tested this code in my computer where version 2.4 is about 6 times slower than version 2.2. Is there any possibility to supply user some choice to choose the old lapack package or the newer one. The package is been extensively used in many areas in the past ten years and it’s less likely to have bugs. It’s also less likely to develop a new math package which is significantly more efficient than lapack. Personally, if there is not significant performance gain, I prefer the lapack. If there is, why not suggest these changes to lapack maintainer? As a user, I *strongly recommend return back to lapack version*, considering the performance of current version.
```
##### Vadim Pisarevsky on 2012-05-23 11:54
```
could you, please, replace
cvInvert(CovMat, Ki, CV_SVD);
with
cvInvert(CovMat, Ki, CV_SVD_SYM);
and measure it again?
I believe, the difference in speed should become much smaller.
```
##### Ming-Ming Cheng on 2012-05-23 11:54
```
I noticed many post elsewhere: http://comments.gmane.org/gmane.comp.lib.opencv/50836 . Since there so many users find Lapack version is better, why not change back? I really prefer other new features in later version of opencv, thus I don’t want to change back to version 2.2. Even if I can directly use lapack to solve my own SVD problem, relative slowdown on many other opencv functions relying on this can’t be solved easily.
In the opencv change note: “LAPACK is not used by OpenCV anymore. The change decreased the library footprint and the compile time. We now use our own implementation of Jacobi SVD. SVD performance on small matrices (2x2 to 10x10) has been greatly improved; on larger matrices it is still pretty good. SVD accuracy on poorly-conditioned matrices has also been improved.” However, even for a 64x64 matrix, it’s 6 times much slower; I can imagine the lower performance for even larger matrix.
```
##### Ming-Ming Cheng on 2012-05-23 12:19
```
When people use SVD, they typically don’t have a symmetrical matrix. Even if speed difference of using CV_SVD_SYM is smaller for this special case, it is still slower, and for more general cases, much slower. Performance gain in compile time can is not so important since most users don’t compile it very often. I believe returning this part back to Lapack would make OpenCV much better. I really appreciate your contributions to make opencv better and better in most part. For this specific part, could you please help to return back to Lapack please? Lapack is used in MKL and Matlab, it’s naturally to also use this stable library in OpenCV.
Vadim Pisarevsky wrote:
> could you, please, replace
> cvInvert(CovMat, Ki, CV_SVD);
> with
> cvInvert(CovMat, Ki, CV_SVD_SYM);
> and measure it again?
>
> I believe, the difference in speed should become much smaller.
```
##### Vadim Pisarevsky on 2012-05-23 16:50
```
is it possible to supply the matrix on which the current SVD is 6 times slower? according to my experiments, new SVD is only a bit slower than Lapack on matrices of size <100x100. The specification of OS, compiler and flags you use is also appreciated. Until we have valid proof if the problem, which can not be solved easily, it's not a productive argument. I reopen the ticket for now.
- Target version changed from 2.4.0 to 2.4.2
- Priority changed from Blocker to Normal
- Status changed from Done to Open
```
##### Ming-Ming Cheng on 2012-05-24 14:40
```
Yes of course. I have attached the data file and two versions (2.2 and 2.4) of binary. By just clicking RunTest.bat, you can get the run time used for different versions of opencv.
I run this in more than 10 computers of my friends, and version 2.4 is about 6 times slower. We all use windows 7 and visual studio 2010. Specifically, my computer is ThinkPad T410 with i5 CPU. Here is the source code of this exe:
<pre>
/*** Test speed of linear algebra functions in OpenCV ***/
#include <opencv/cv.h>
#include <cstdio>
#include <cstdarg>
#include <cstdlib>
#include <iostream>
#include <fstream>
#include <cmath>
#include <cassert>
#include <ctime>
#ifdef _DEBUG
#pragma comment(lib, "opencv_core220d.lib")
#pragma comment(lib, "opencv_highgui220d.lib")
#else
#pragma comment(lib, "opencv_core220.lib")
#endif // _DEBUG
using namespace cv;
using namespace std;
void CovarMatrix (CvMat* CovMat, CvMat* FeatureVecs);
int main(int argc, char *argv[])
{
bool debug = false;
int FVLength = 64;
CvMat* avg = cvCreateMat(FVLength, 1, CV_64FC1);
CvMat* FeatVec = cvCreateMat(FVLength, 1, CV_64FC1);
CvMat* Anomaly = cvCreateMat(FVLength, 1, CV_64FC1);
CvMat* Ki = cvCreateMat(FVLength, FVLength, CV_64FC1);
CvMat* CovMat = cvCreateMat(FVLength, FVLength, CV_64FC1);
cvSetZero(CovMat);
CvMat* TotVecs = cvCreateMat(2,FVLength, CV_64FC1);
// Initialize the FeatVec and avg to be random
CvRNG rng_state = cvRNG(0xffffffff);
cvRandArr(&rng_state, FeatVec, CV_RAND_NORMAL, cvRealScalar(100), cvRealScalar(30));
cvRandArr(&rng_state, avg, CV_RAND_NORMAL, cvRealScalar(60), cvRealScalar(25));
// Start time
clock_t start = ::clock();
unsigned int it = 2000;
for (int p = 0; p < it; p++) {
cvSub(FeatVec, avg, Anomaly); // Find anomaly vector (feature-average)
for (int k=0; k < FVLength; k++) //Ki is now going to be inverse covariance matrix
{
cvmSet(TotVecs,0,k,cvmGet(FeatVec,k,0));
cvmSet(TotVecs,1,k,cvmGet(avg,k,0));
}
// Next, find the covariance matrix of this.
CovarMatrix(CovMat, TotVecs);
cvInvert(CovMat, Ki, CV_SVD);
if (p == 0){
CvFileStorage *fs = cvOpenFileStorage("data.xml", NULL, CV_STORAGE_WRITE);
cvWrite(fs, "CovMat", CovMat);
}
}
clock_t endT = clock();
cout<<"Time elapsed : "<< (double(endT - start))/CLOCKS_PER_SEC <<endl;
return 0;
}
void CovarMatrix (CvMat* CovMat, CvMat* Vecs)
{
int nums = Vecs->cols;
int Len = Vecs->rows;
int n = Vecs->cols; // step size
double *data = Vecs->data.db; // pointer to float with all values in input
double sum;
for (int j = 0; j < nums ; j++) {
sum = 0;
for (int i = 0; i < Len; i ++)
sum += data[i * n + j];
sum = sum/Len;
for (int i =0; i < Len; i++)
data[i * n + j] -= sum;
}
CvMat* VecsT = cvCreateMat(nums, Len, CV_64FC1); // covariance matrix
cvTranspose( Vecs,VecsT );
cvMulTransposed( VecsT, CovMat, 0);
// scale CovMat by m-1
double *CovDat = CovMat->data.db; // pointer to float with all values in input
for (int i = 0; i < CovMat->rows; i++) // for each feature vector, find the mean, and subtract it
for (int j = 0; j < CovMat->cols; j ++)
CovDat[i * (CovMat->cols) + j] = CovDat[i * (CovMat->cols) + j] / (Len-1);
cvReleaseMat(&VecsT);
}
</pre>
Vadim Pisarevsky wrote:
> is it possible to supply the matrix on which the current SVD is 6 times slower? according to my experiments, new SVD is only a bit slower than Lapack on matrices of size <100x100. The specification of OS, compiler and flags you use is also appreciated. Until we have valid proof if the problem, which can not be solved easily, it's not a productive argument. I reopen the ticket for now.
- File Test.zip added
- File data.xml added
```
##### Ming-Ming Cheng on 2012-05-24 14:45
```
If you want, I can just start a survey and ask opencv users to give information about their platform and the run-time reported by the exe I just uploaded. Our lab has 40 students using OpenCV. All of them meet this problem. I think I can easily collected more than 100+ from different users, or even 1000+.
```
##### Andrey Kamaev on 2012-06-25 09:17
```
- Target version deleted (2.4.2)
```
##### Vadim Pisarevsky on 2012-06-28 21:17
```
ok; the problem has been reproduced; we will try to solve it soon
- Target version set to 2.4.3
```
##### Vadim Pisarevsky on 2012-10-24 09:56
```
- Target version changed from 2.4.3 to 3.0
```
##### Wolfgang von Hansen on 2013-01-08 14:20
```
I would like to draw the attention to a different and more fundamental aspect of the underlying problem. One of my tasks involves solving large systems of several thousand equations, which -- due to the sparse nature of the problem -- can basically be broken down to compute the inverse of a band matrix. cvInvert from OpenCV 2.2 does the job really fine using the (default) LU-decomposition. The new code in OpenCV 2.3 no longer exploits the sparseness of a matrix. One can easily demonstrate this with a trivial example
@Mat A = Mat::eye(n, n, CV_32F).inv();@
by choosing n large enough. Depending on the speed of your computer some value like 2000 should keep it busy for a minute or so. The times are the same as if it were a random matrix of the same size. If you test different values for n, you will see that the run time is in O(n^3). The reason is most likely, that there are no checks for zero elements during the elimination process, thus blindly computing the inverse by brute force.
For real world problems, the larger a matrix gets, the sparser it is. A good implementation -- like that of LAPACK -- takes the zeros into account, yielding a (linear!) run time in O(n). I sincerely hope that someone can look into this. For me asymptotic behavior for large matrices is much more important than a few saved cycles for small ones (these a fast anyway on modern CPUs).
```
##### Kirill Kornyakov on 2013-04-11 14:53
```
Dear community, could somebody work take this issue? Core OpenCV devs are busy with release preparations, so if we want to see this issue fixed, we need a volunteer!
- Affected version set to branch 'master' (2.4.9)
```
##### Ming-Ming Cheng on 2013-07-03 19:58
```
Will that be easier to simply change back to the original implementation (version 2.2) which calls the well developed LAPACK?
Kirill Kornyakov wrote:
> Dear community, could somebody work take this issue? Core OpenCV devs are busy with release preparations, so if we want to see this issue fixed, we need a volunteer!
```
##### Muhammad Asad on 2014-01-16 17:33
```
I agree with this (and I think most of the developers would think the same). Can we have the LAPACK implementation back.
Ming-Ming Cheng wrote:
> Will that be easier to simply change back to the original implementation (version 2.2) which calls the well developed LAPACK?
>
> Kirill Kornyakov wrote:
> > Dear community, could somebody work take this issue? Core OpenCV devs are busy with release preparations, so if we want to see this issue fixed, we need a volunteer!
```
| bug,auto-transferred,priority: normal,category: core,affected: 2.4 | low | Critical |
97,413,867 | opencv | Feature request: add codec parameters in videoWriter | Transferred from http://code.opencv.org/issues/1506
```
|| sebastien wybo on 2011-12-06 14:30
|| Priority: Normal
|| Affected: None
|| Category: highgui-video
|| Tracker: Feature
|| Difficulty: None
|| PR: None
|| Platform: None / None
```
## Feature request: add codec parameters in videoWriter
```
It would be interesting to be able to control compression, key frames, bit-rate... in encoded videos the same way JPEG and PNG files compression can be controled.
```
## History
##### Andrey Kamaev on 2012-08-16 14:55
```
- Category changed from highgui-images to highgui-video
```
| auto-transferred,priority: normal,feature,category: videoio | low | Minor |
97,413,912 | opencv | Please Implement WarpBilinear | Transferred from http://code.opencv.org/issues/1522
```
|| moellney - on 2011-12-18 11:28
|| Priority: Normal
|| Affected: None
|| Category: imgproc, video
|| Tracker: Feature
|| Difficulty: None
|| PR: None
|| Platform: None / None
```
## Please Implement WarpBilinear
```
You have warpAffine and warpPerspective but both seem not to transform the input image to a bilinear transformation.
Please see the difference between bilinear color interpolation and bilinear position interpolation.
Reasonable links might be:
http://software.intel.com/sites/products/documentation/hpc/composerxe/en-us/ippxe/ipp_manual_win_mac/IPPI/ippi_ch12/functn_WarpBilinear.htm
and
http://developer.qt.nokia.com/forums/viewthread/2007/#11944
```
## History
##### Andrey Kamaev on 2012-04-07 08:18
```
- Category changed from core to imgproc, video
```
| auto-transferred,priority: normal,feature,category: imgproc,category: video | low | Minor |
97,413,976 | opencv | output of GPU detectMultiScale returns multiple of detector size | Transferred from http://code.opencv.org/issues/1525
```
|| brendan ruff on 2011-12-23 13:12
|| Priority: Low
|| Affected: None
|| Category: gpu (cuda)
|| Tracker: Feature
|| Difficulty: None
|| PR:
|| Platform: None / None
```
## output of GPU detectMultiScale returns multiple of detector size
```
Hi
I've started using GPU detectMultiScale on 2.3.1 but the rectangles returned are only multiples of detector size. eg for the face _alt version which is 20x20 then my reported faces are one of 20x20, 40x40, 60x60, etc .
The actual detection seems to be in the right place and reflects the scaling passed in. I checked with scalings from 1.1 through to 2.0 . 1.1 gives good detection at all faces sizes but running up to 2.0 gives holes in the detection as expected, and also the processing time reduces with inreased scaling as expected.
So my question is why does GPU detectMultiScale only return multiple integers of the detector size when clearly it is using the scaling as given ? Is this a bug or a feature of the implementation.
My workaround is to apply the programmatic CPU detectMultiScale in a small ROI around the detected location of each face over the entire scale range bracketing the reported GPU size (ie if 40x40 then detect from 20x20 to 60x60 on a 60x60 pixel ROI. This is relatively low on CPU overhead as the ROI is smallish. Still it all adds up as I'm looking at crowd scenes.
The Graphics card is an older integrated G96M GPU. Querying for the number of multiprocessors (using the device info) returns 1. I think this implies it is one processor cluster as compared to 1 actual core processor unit. Maybe it is only 1 core ? I get 3 frames per second on 800x600 so not too bad for a 3 year old laptop GPU.
```
## History
##### brendan ruff on 2011-12-23 13:30
```
PS I have characterised the bug a bit better. The quantisation of the scale only applies between 20x20 to 40x40 for the 20x20 frontal face model. After 40x40 the face can be any size (eg 41x41), but between 20 and 40 the detector reports only either 20 or 40.
The CPU version reports any size. The workaround stands to redetect faces 40 pixels or below.
```
##### Anatoly Baksheev on 2011-12-23 14:28
```
Anton, what do you think about this?
- Status deleted (Open)
```
##### Anton Obukhov on 2011-12-23 14:38
```
This is on purpose. The integral image is built only once for the input image, and instead of performing downsampling and recalculation of statistics, the decimation approach is used. Thus what happens is that the float scale parameter is rounded to the low integer and that scale is processed.
The code was written at times of Tesla compute architecture (SM 1.0-1.3 capability), but with the modern GPUs one could easily modify the code so that it is more scale-friendly:
- downsample image from previous level
- calculate statistics for the level
- use it in the classifier.
I had a plan to introduce such patch, but this is not a priority for me now, so no estimate provided.
```
##### Alexander Shishkov on 2012-03-22 14:35
```
- Status set to Open
```
##### Marina Kolpakova on 2012-06-28 12:43
```
- Target version set to 3.0
- Assignee changed from Anton Obukhov to Marina Kolpakova
```
##### Marina Kolpakova on 2013-04-05 23:29
```
- Assignee deleted (Marina Kolpakova)
```
| auto-transferred,feature,priority: low,category: gpu/cuda (contrib) | low | Critical |
97,414,221 | opencv | Sometimes focal length is negative during bundle adjustment, it makes crash. | Transferred from http://code.opencv.org/issues/1545
```
|| p x on 2012-01-13 06:14
|| Priority: Normal
|| Affected: branch '2.4'
|| Category: stitching
|| Tracker: Bug
|| Difficulty: None
|| PR:
|| Platform: None / None
```
## Sometimes focal length is negative during bundle adjustment, it makes crash.
```
I detected that, this problem occurs in void BundleAdjusterRay::calcError(Mat &err) in motion_estimators.cpp
After some iterations, f1 or f2 may be negative, so mult = sqrt(f1 * f2) is NaN.
It makes the program crash in a further call of SVD to a NaN matrix.
Please investigate it.
```
## History
##### None on 2012-02-12 18:56
```
- Description changed from I detected that, this problem occurs in
void [[BundleAdjusterRay]]::calcError... to I detected that, this
problem occurs in void BundleAdjusterRay::calcError(Mat... More
```
##### Alexander Shishkov on 2012-02-17 08:59
```
- Category set to stitching
```
##### Andrey Kamaev on 2012-03-24 15:23
```
- Priority changed from Blocker to Normal
- Assignee changed from Vadim Pisarevsky to Alexey Spizhevoy
```
##### Alexey Spizhevoy on 2012-03-26 06:51
```
p x,
Could you attach here the dataset where that error occurs? Provide us, please, all the information to reproduce the bug.
Thanks.
```
##### Anatoly Baksheev on 2012-03-31 23:52
```
I think this reporter doesn't present at this tracker. Try to find his contacts on trac.
```
##### p x on 2012-04-01 00:24
```
I am trying to repro this bug and if it still exists now, some test cases will be given. Thank you for your reply.
```
##### Alexey Spizhevoy on 2013-01-10 06:24
```
no response from the submitter
- Status changed from Open to Cancelled
```
##### Martin Ljungqvist on 2013-04-30 08:51
```
I have happened to reproduce this problem in BundleAdjusterRay::calcError(Mat &err) using the sample code stitching_detailed.cpp.
As described above; after some iterations, if f1 or f2 is negative, then mult = sqrt(f1 * f2) is NaN. This makes the program fail, the output image being just one pixel. If this 'mult' variable is removed then it works and the resulting image looks ok, but the refined focal lengths become quite high. This corresponds to the comments about bundle adjustment and residual weights in "Image alignment and stitching - A tutorial" by Richard Szeliski 2006, page 50, where this weight variable is explained.
This problem happens when running stitching_detailed.cpp with two images being very similar and hardly no movement of the camera but small changes inside the image. All settings default. The iteration in BundleAdjusterRay makes the focal lengths f1 and f2 to approach zero in this case, when one of them might eventually become a small negative value. So either the 'mult' weight variable could perhaps be changed in some way, or e.g the stitching_detailed algorithm could somewhere take precautions if the images are too similar.
Please send me a message if you need images for reproducing the problem.
```
##### Anna Kogan on 2013-05-07 08:20
```
Hello Martin,
Please attach the images for us to reproduce the issue. Thank you!
- Affected version set to branch '2.4'
- Status changed from Cancelled to Open
```
##### Martin Ljungqvist on 2013-05-07 14:08
```
Hello Anna,
Please find the attached files.
- File vid_00001.pgm added
- File vid_00002.pgm added
```
##### Martin Ljungqvist on 2013-05-13 13:41
```
Some speculation if BundleAdjusterRay() would assume not too similar images.. The function leaveBiggestComponent() sorts out images that are not matching at all or are too similar, depending on their confidence. The confidence is calculated in BestOf2NearestMatcher::match(), where there is a threshold for confidence which is set to 3 in the code. The attached images above give 2.66 confidence and fail. But some images can have 2.7 and still be stitched. So confidence alone seems not to discriminate. This is an interesting problem of how and where to handle this.
```
| bug,auto-transferred,priority: normal,affected: 2.4,category: stitching | low | Critical |
97,414,391 | opencv | Flv file writer in Opencv 2.3.1 not working... | Transferred from http://code.opencv.org/issues/1576
```
|| wazzy123 - on 2012-02-01 13:00
|| Priority: Normal
|| Affected: None
|| Category: highgui-video
|| Tracker: Feature
|| Difficulty: None
|| PR: None
|| Platform: None / None
```
## Flv file writer in Opencv 2.3.1 not working...
```
I want to write .flv file from Opencv and spent so much time on it...
OpenCV 2.3 Documentation says we can create flv file with this codec
CV_FOURCC('F','L','V','1')
but I am always getting this error.
[flv @ 0x9bf5000] Tag FLV1/0x31564c46 incompatible with output codec id '22'
Please help.... Currently I am using OpenCV 2.3 on Ubuntu 10.10
Try Pastebin code ( http://pastebin.com/HQEvbDCh ) ....Keep one test.avi file in same folder...Please check whether your OpenCV create new.flv
I tried this to write avi file - THIS WORKS
<pre><code class="c">
CvVideoWriter *vdowriter = cvCreateVideoWriter(
"/path/converted.avi",
CV_FOURCC('M', 'J', 'P', 'G'),
20.0,
cvSize(640,480) );
</code></pre>
Similarly I tried this to write flv file - THIS DOESNT WORKS
<pre><code class="c">
CvVideoWriter *vdowriter = cvCreateVideoWriter(
"/path/converted.flv",
CV_FOURCC('F', 'L', 'V', '1'),
25.0,
cvSize(640,480) );
</code></pre>
```
## History
##### Alexander Shishkov on 2012-02-12 19:54
```
- Description changed from I want to write .flv file from Opencv and
spent so much time on it... [[OpenC... to I want to write .flv file
from Opencv and spent so much time on it... OpenCV ... More
```
##### Andrey Kamaev on 2012-02-17 19:59
```
- Category changed from imgproc, video to highgui-images
```
##### Alexander Shishkov on 2012-03-20 14:52
```
- Target version deleted ()
- Priority changed from High to Normal
- Description changed from I want to write .flv file from Opencv and
spent so much time on it... OpenCV ... to I want to write .flv file
from Opencv and spent so much time on it... OpenCV ... More
```
##### Alexander Shishkov on 2012-03-25 20:44
```
- Assignee deleted (Vadim Pisarevsky)
```
##### Alexander Shishkov on 2012-04-05 12:46
```
- Target version deleted ()
```
##### Andrey Kamaev on 2012-08-16 15:09
```
- Category changed from highgui-images to highgui-video
```
##### Vadim Pisarevsky on 2012-10-05 10:41
```
I do not see where FLV is mentioned in the documentation. I would consider support for FLV as a feature request, not as a bug
- Tracker changed from Bug to Feature
```
##### Alexander Smorkalov on 2012-11-29 11:26
```
It looks like some flv container writer problem. AVI container with flv1 codec works ok.
I add new reproducer with web camera.
<pre>
flv_reproducer test_video.avi #ok
flv_reporducer test_video.flv #invalid file
</pre>
- File flv_reproducer.cpp added
- File flv_mplayer.log added
- File avi_mplayer.log added
```
| auto-transferred,priority: normal,feature,category: videoio | low | Critical |
97,414,482 | opencv | Errors in SURF/STAR Python Bindings | 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 ()
```
| bug,auto-transferred,category: python bindings,priority: low | low | Critical |
97,414,534 | opencv | OpponentSIFT descriptor failure | Transferred from http://code.opencv.org/issues/1588
```
|| Alexandre Benoit on 2012-02-05 19:14
|| Priority: Low
|| Affected: None
|| Category: features2d
|| Tracker: Bug
|| Difficulty: None
|| PR: None
|| Platform: None / None
```
## OpponentSIFT descriptor failure
```
Hi,
I encounter systematic error when using the OpponentSIFT descriptor when using a Dense grid analysis.
Note, it does not fail when using the OpponentSURF descriptor or when using a simple SIFT descriptor
The code and error report are below.
I also have a question regarding SIFT and SURF : how do these implementations differentiate from the official research libraries : are there any difference from precision and/or computation efficiency considerations ?
Once again, thanks a lot for all the contributors of this wonderful library !
From the code side, here is how i setup the dense grid:
// dense grid setup
_featureDetector = new cv::DenseFeatureDetector(cv::DenseFeatureDetector::Params(1.f, 1, 2.5f, 9));
// descriptor setup
_descExtractor = cv::DescriptorExtractor::create( _ddmParams.descriptorType ); // where _ddmParams.descriptorType is the String "OpponentSIFT", "OpponentSURF", "SIFT" or any other compatible
// when running analysis
_descExtractor->compute( colorImage, imageKeypoints, currentImageDescriptors);
Here is the valgrind report at the error place:
==> grabbing from colorImage input (h,w,channels,elemnSize1 => nbKeypoints): 240, 320, 3, 1=> 69
==31790== Invalid read of size 4
==31790== at 0x5D45DE5: cv::OpponentColorDescriptorExtractor::computeImpl(cv::Mat const&, std::vector<cv::KeyPoint, std::allocator<cv::KeyPoint> >&, cv::Mat&) const (in /usr/local/lib/libopencv_features2d.so.2.3.2)
==31790== by 0x5D4008A: cv::DescriptorExtractor::compute(cv::Mat const&, std::vector<cv::KeyPoint, std::allocator<cv::KeyPoint> >&, cv::Mat&) const (in /usr/local/lib/libopencv_features2d.so.2.3.2)
==31790== by 0x4179ED: TrecVidBOWsystem::_grabbDescriptors(cv::Mat const&, std::vector<cv::KeyPoint, std::allocator<cv::KeyPoint> >&, cv::Mat&) (TrecVidBOWsystem.h:484)
==31790== by 0x41BCED: TrecVidBOWtrainer_Experimetal::processSubshotList_SingleFrame(cv::Mat const&, Subshot const&, int const&) (TrecVidBOWtrainer_Experimetal.h:75)
==31790== by 0x40CE50: TrecVidSubshotListProcessor::processSubshotList(TrecVidSubshotListProcessor::SUBSHOTLISTFAILUREPROCESS) (TrecVidSubshotListProcessor.cpp:216)
==31790== by 0x419640: TrecVidBOWtrainer::trainVocabulary(int, char**) (TrecVidBOWtrainer.h:132)
==31790== by 0x410188: main (buildVocabulary.cpp:29)
==31790== Address 0x193ac4f8 is 0 bytes after a block of size 264 alloc'd
==31790== at 0x4C28973: operator new(unsigned long) (vg_replace_malloc.c:261)
==31790== by 0x4EC95DD: std::vector<int, std::allocator<int> >::_M_fill_insert(+gnu_cxx::+normal_iterator<int*, std::vector<int, std::allocator<int> > >, unsigned long, int const&) (in /usr/local/lib/libopencv_core.so.2.3.2)
==31790== by 0x5D4678C: cv::OpponentColorDescriptorExtractor::computeImpl(cv::Mat const&, std::vector<cv::KeyPoint, std::allocator<cv::KeyPoint> >&, cv::Mat&) const (in /usr/local/lib/libopencv_features2d.so.2.3.2)
==31790== by 0x5D4008A: cv::DescriptorExtractor::compute(cv::Mat const&, std::vector<cv::KeyPoint, std::allocator<cv::KeyPoint> >&, cv::Mat&) const (in /usr/local/lib/libopencv_features2d.so.2.3.2)
==31790== by 0x4179ED: TrecVidBOWsystem::_grabbDescriptors(cv::Mat const&, std::vector<cv::KeyPoint, std::allocator<cv::KeyPoint> >&, cv::Mat&) (TrecVidBOWsystem.h:484)
==31790== by 0x41BCED: TrecVidBOWtrainer_Experimetal::processSubshotList_SingleFrame(cv::Mat const&, Subshot const&, int const&) (TrecVidBOWtrainer_Experimetal.h:75)
==31790== by 0x40CE50: TrecVidSubshotListProcessor]]::processSubshotList(TrecVidSubshotListProcessor::SUBSHOTLISTFAILUREPROCESS) (TrecVidSubshotListProcessor.cpp:216)
==31790== by 0x419640: TrecVidBOWtrainer]]::trainVocabulary(int, char**) (TrecVidBOWtrainer.h:132)
==31790== by 0x410188: main (buildVocabulary.cpp:29)
==31790==
==31790== Invalid read of size 4
==31790== at 0x5D45DF8: cv::OpponentColorDescriptorExtractor::computeImpl(cv::Mat const&, std::vector<cv::KeyPoint, std::allocator<cv::KeyPoint> >&, cv::Mat&) const (in /usr/local/lib/libopencv_features2d.so.2.3.2)
==31790== by 0x5D4008A: cv::DescriptorExtractor::compute(cv::Mat const&, std::vector<cv::KeyPoint, std::allocator<cv::KeyPoint> >&, cv::Mat&) const (in /usr/local/lib/libopencv_features2d.so.2.3.2)
==31790== by 0x4179ED: TrecVidBOWsystem::_grabbDescriptors(cv::Mat const&, std::vector<cv::KeyPoint, std::allocator<cv::KeyPoint> >&, cv::Mat&) (TrecVidBOWsystem.h:484)
==31790== by 0x41BCED: TrecVidBOWtrainer_Experimetal::processSubshotList_SingleFrame(cv::Mat const&, Subshot const&, int const&) (TrecVidBOWtrainer_Experimetal.h:75)
==31790== by 0x40CE50: TrecVidSubshotListProcessor::processSubshotList(TrecVidSubshotListProcessor::SUBSHOTLISTFAILUREPROCESS) (TrecVidSubshotListProcessor.cpp:216)
==31790== by 0x419640: TrecVidBOWtrainer::trainVocabulary(int, char**) (TrecVidBOWtrainer.h:132)
==31790== by 0x410188: main (buildVocabulary.cpp:29)
```
## History
##### Alexander Shishkov on 2012-02-12 19:52
```
- Description changed from Hi, I encounter systematic error when using
the [[OpponentSIFT]] descriptor w... to Hi, I encounter systematic
error when using the OpponentSIFT descriptor when ... More
```
##### Alexandre Benoit on 2012-02-20 11:15
```
Here are some more valgrind informations :
When encountering the error, with the current trunk revision:
[swscaler @ 0x14ac97d0]No accelerated colorspace conversion found from yuv420p to bgr24.
VideoProcessor::getFrame: frame acquired, size (h,w,channels,elemSize1) : 240, 320, 3, 1
==8269==
==8269== Process terminating with default action of signal 11 (SIGSEGV)
==8269== Access not within mapped region at address 0x2577635E8
==8269== at 0x5D1FED7: cv::OpponentColorDescriptorExtractor::computeImpl(cv::Mat const&, std::vector<cv::KeyPoint, std::allocator<cv::KeyPoint> >&, cv::Mat&) const (in /usr/local/lib/libopencv_features2d.so.2.3.3)
==8269== by 0x5D1962A: cv::DescriptorExtractor::compute(cv::Mat const&, std::vector<cv::KeyPoint, std::allocator<cv::KeyPoint> >&, cv::Mat&) const (in /usr/local/lib/libopencv_features2d.so.2.3.3)
There are also some warnings :
==8269== Conditional jump or move depends on uninitialised value(s)
==8269== at 0x652A306: __ieee754_atan2 (e_atan2.c:205)
==8269== by 0x65419F4: atan2 (w_atan2.c:36)
==8269== by 0x5D05A61: calc_grad_mag_ori(_IplImage*, int, int, double*, double*) (in /usr/local/lib/libopencv_features2d.so.2.3.3)
==8269== by 0x5D068CC: calc_feature_oris(CvSeq*, _IplImage***) (in /usr/local/lib/libopencv_features2d.so.2.3.3)
==8269== by 0x5D06F94: recalculateAngles(std::vector<cv::KeyPoint, std::allocator<cv::KeyPoint> >&, _IplImage***, int, int) (in /usr/local/lib/libopencv_features2d.so.2.3.3)
==8269== by 0x5D0A44A: cv::SIFT::operator()(cv::Mat const&, cv::Mat const&, std::vector<cv::KeyPoint, std::allocator<cv::KeyPoint> >&, cv::Mat&, bool) const (in /usr/local/lib/libopencv_features2d.so.2.3.3)
==8269== by 0x5D1EB52: cv::SiftDescriptorExtractor::computeImpl(cv::Mat const&, std::vector<cv::KeyPoint, std::allocator<cv::KeyPoint> >&, cv::Mat&) const (in /usr/local/lib/libopencv_features2d.so.2.3.3)
==8269== by 0x5D1962A: cv::DescriptorExtractor::compute(cv::Mat const&, std::vector<cv::KeyPoint, std::allocator<cv::KeyPoint> >&, cv::Mat&) const (in /usr/local/lib/libopencv_features2d.so.2.3.3)
==8269== by 0x5D1F58B: cv::OpponentColorDescriptorExtractor::computeImpl(cv::Mat const&, std::vector<cv::KeyPoint, std::allocator<cv::KeyPoint> >&, cv::Mat&) const (in /usr/local/lib/libopencv_features2d.so.2.3.3)
==8269== by 0x5D1962A: cv::DescriptorExtractor::compute(cv::Mat const&, std::vector<cv::KeyPoint, std::allocator<cv::KeyPoint> >&, cv::Mat&) const (in /usr/local/lib/libopencv_features2d.so.2.3.3)
```
##### Alexandre Benoit on 2012-02-20 15:32
```
When using OpenCV in debug mode, here are more details (with code lines)
==18958== Process terminating with default action of signal 11 (SIGSEGV)
==18958== Access not within mapped region at address 0x2B8A73E28
==18958== at 0x5FF24ED: cv::OpponentColorDescriptorExtractor::computeImpl(cv::Mat const&, std::vector<cv::KeyPoint, std::allocator<cv::KeyPoint> >&, cv::Mat&) const (descriptors.cpp:407)
==18958== by 0x5FEF4C6: cv::DescriptorExtractor::compute(cv::Mat const&, std::vector<cv::KeyPoint, std::allocator<cv::KeyPoint> >&, cv::Mat&) const (descriptors.cpp:69)
==18958== by 0x41C033: MyObject::_grabbDescriptors(cv::Mat const&, std::vector<cv::KeyPoint, std::allocator<cv::KeyPoint> >&, cv::Mat&) (TrecVidBOWsystem.h:491)
```
##### Alexandre Benoit on 2012-02-27 09:26
```
It seems that the bug reported above is related to the length of used vectors in
<pre><code class="cpp">
void OpponentColorDescriptorExtractor::computeImpl( const Mat& bgrImage, vector<KeyPoint>& keypoints, Mat& descriptors ) const:
</code></pre>
When using OpponentSURF, all channels keypoints (coponents of vectorchannelKeypoints in the code) have the same size which is the one provided by the parameter vector "keypoints"... so it works fine in this case.
However, when using OpponentSIFT, the channelKeypoints vector exhibits different vector size for each channel and this leads to a buffer overflow in the following loops:
<pre><code class="cpp" lineNumbers="no">
while( channelKeypoints[2][idxs[2][cp[2]]].class_id < maxInitIdx && cp[2] < channelKeypoints[2].size() ) { cp[2]++; }
</code></pre>
hope it helps
```
##### Alexander Shishkov on 2012-03-20 13:23
```
- Target version deleted ()
```
##### Alexander Shishkov on 2012-03-25 20:48
```
- Assignee deleted (Vadim Pisarevsky)
```
##### Alexander Shishkov on 2012-04-05 12:46
```
- Target version deleted ()
```
##### Vadim Pisarevsky on 2012-10-05 10:12
```
- Target version deleted ()
```
##### Kirill Kornyakov on 2012-10-24 08:38
```
- Target version set to Next Hackathon
```
| bug,auto-transferred,priority: low,category: features2d | low | Critical |
97,415,140 | opencv | Levenberg-Marquardt in calibrateCamera has a small basin of convergence | 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
```
| bug,auto-transferred,priority: normal,category: calib3d | low | Critical |
97,415,565 | opencv | Add a binary FileStorage format | Transferred from http://code.opencv.org/issues/1849
```
|| Josh Klontz on 2012-04-25 18:28
|| Priority: Normal
|| Affected: None
|| Category: core
|| Tracker: Feature
|| Difficulty: None
|| PR: None
|| Platform: None / None
```
## Add a binary FileStorage format
```
It would be wonderful if FileStorage also supported serialization to a binary format when file size is more important than file readability. Furthermore, if implemented, a great extension to this would be to provide a mechanism for representing FileStorage as a buffer in memory. The problem i've run into while writing a gender classification algorithm is one of data persistence for the entire algorithm. Parts of the algorithm, like PCA using the Eigen matrix format are easy to serialize as a binary format. However, other parts, like OpenCV's SVM classifier are difficult to serialize as the only mechanisms for doing so are 1) directly to a file or 2) using the FileStorage class. Thus, with the goal of having one (small) file to represent the result of training all the steps in my algorithm (where some steps require serializing data structures from other libraries), the current approach I take is to save the SVM to its own temporary file, read the file from disk, compress the data, and finally write it to a file stream alongside the other portions of the algorithm. The proposed features or an alternative approach to serializing CvStatModels and the new Algorithm class to a memory buffer would be greatly appreciated! Thanks!
```
## History
##### Joel Mckay on 2012-04-25 20:03
```
The compressed XML files contain marshalled data, and free libs like Xerces can parse it on just about any system (btw a symmetric MatLab xslt based translation routine may be handy for transparency). Additionally, human readable data for analysis is nicer to debug unlike a serialized binary.
A better explanation of why it is important is here:
http://en.wikipedia.org/wiki/Marshalling_%28computer_science%29
If libxerces is missing on your repo:
http://xerces.apache.org/xerces-c/
```
##### Alexander Smorkalov on 2012-10-03 08:38
```
- Target version set to 3.0
- Assignee set to Vadim Pisarevsky
```
##### Peter Minin on 2013-12-15 20:35
```
I miss this feature too, also mainly for saving classifier data. I went another way instead of compressing XML/YAML files: I wrote my own functions for binary storage, and in case of CvSVM I subclassed it and overloaded write() and read() with my ports of the CvFileStorage-based methods. Unfortunately, I couldn't find a way to save/load a Fisherfaces FaceRecognizer like that because it doesn't allow setting some of its variables through set*() and the class isn't even defined in a header file so subclassing won't work either.
I've attached my binary storage functions here and I'd like to ask some experienced OpenCV supporter to check if this approach can find its way to OpenCV and tell me what has to be changed for that.
- File file_storage.cpp added
- File file_storage.h added
```
##### eric king on 2014-01-13 09:24
```
Opencv data serialization and de-serialization .I think it is a very important problema for data storage in opencv data format.So any body can fixed it immediately?
```
| auto-transferred,feature,priority: low,category: core | low | Critical |
97,415,648 | opencv | Descriptors for Affine invariant regions | 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
```
| auto-transferred,feature,priority: low,category: features2d | low | Minor |
97,415,812 | opencv | Exposing more Keypoint and Feature2d C++ functions to Java API. | 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.
```
| auto-transferred,priority: normal,feature,category: java bindings | low | Minor |
97,415,860 | opencv | Allowed Matrix dimension for 'objectPoints':cvFindExtrinsicCameraParams2 | 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)
```
| bug,auto-transferred,priority: normal,category: documentation,affected: 2.4 | low | Critical |
97,416,121 | opencv | OpponentColorDescriptorExtractor::computeImpl vector subscript out of range error | Transferred from http://code.opencv.org/issues/1916
```
|| Elisavet Chatzilari on 2012-05-10 11:51
|| Priority: Normal
|| Affected: None
|| Category: features2d
|| Tracker: Bug
|| Difficulty: None
|| PR: None
|| Platform: None / None
```
## OpponentColorDescriptorExtractor::computeImpl vector subscript out of range error
```
I am trying to extract opponent sift features of images using PyramidDense detectors for keypoints. The code doesnt crash when calculating SIFT but only with opponent SIFT. I have seen that the error happens in one of these two lines:
<pre>
const int maxInitIdx = std::max( channelKeypoints[0][idxs[0][cp[0]]].class_id,
std::max( channelKeypoints[1][idxs[1][cp[1]]].class_id,
channelKeypoints[2][idxs[2][cp[2]]].class_id ) );
while( channelKeypoints[0][idxs[0][cp[0]]].class_id < maxInitIdx && cp[0] < channelKeypoints[0].size() ) { cp[0]++; }.
</pre>
Also it does not crash with all images. There are images that cause this error only in debug mode and other that cause it in both debug and release. The code is quite simple, here is the corresponding part:
<pre>
// load the image
string FullPathName = featureFolder + this->imageName;
this->image=cv::imread(FullPathName);
// find and load segmentation mask
if (this->segmentName=="")
{
int count = this->imageName.find_last_of(".",imageName.size());
this->segmentName = this->imageName.substr(0,count) + ".seg";
}
string FullSegName = featureFolder + this->segmentName;
this->segment = cv::imread(FullSegName,-1);
// Extract keypoints and features
Ptr<FeatureDetector> featureDetector = FeatureDetector::create( "PyramidDense" );
PyramidAdaptedFeatureDetector PyramidDetector(featureDetector,2);
Ptr<DescriptorExtractor> descExtractor = DescriptorExtractor::create(descriptorType);
vector<vector<KeyPoint>> imageKeypoints;
// find the unique segment IDs
this->RegionIDs = this->unique(segment,segment.at<unsigned __int8>(0,0));
for (size_t i=0;i<this->RegionIDs.size();i++)
{
imageKeypoints.push_back( vector<KeyPoint> () );
cv::Mat outMask = this->createMask(segment,this->RegionIDs[i]);
PyramidDetector.detect( image, imageKeypoints[i], outMask );
}
Ptr<DescriptorMatcher> descMatcher = DescriptorMatcher::create( "FlannBased" );
Ptr<BOWImgDescriptorExtractor> bowExtractor = new BOWImgDescriptorExtractor( descExtractor, descMatcher );
bowExtractor->setVocabulary(this->Vocabulary);
Mat temp;
for (size_t i=0;i<this->RegionIDs.size();i++)
{
descriptor.push_back( vector<double> () );
temp.create(imageKeypoints[i].size(),384,CV_32FC1);
cout << i << "\tKeypoints before: " << imageKeypoints.at(i).size() << "\t";
descExtractor->compute(this->image, imageKeypoints[i], temp);
temp.release();
cout << "Keypoints after: " << imageKeypoints.at(i).size() << "\n";
}
</pre>
The code crashes inside the compute only for specific regions.
```
## History
##### Kirill Kornyakov on 2012-05-16 06:58
```
- Description changed from I am trying to extract opponent sift
features of images using PyramidDense de... to I am trying to
extract opponent sift features of images using PyramidDense de...
More
- Category set to features2d
```
| bug,auto-transferred,priority: normal,category: features2d | low | Critical |
97,416,237 | opencv | Testing Python Wrappers doc should mention PATH should be set for Windows install | 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
```
| bug,auto-transferred,priority: low,category: documentation | low | Critical |
97,416,394 | opencv | LINE-MOD docs missing | 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
```
| auto-transferred,priority: normal,feature,category: documentation | low | Minor |
97,416,542 | opencv | Change the name of the library folder in win-superpack to enable specifying the path using Visual C++ macro | 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
```
| auto-transferred,priority: normal,feature,category: build/install | low | Minor |
97,416,593 | opencv | FLANN documentation only lists deprecated class | 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)
```
| bug,auto-transferred,priority: normal,category: documentation,affected: 2.4 | low | Critical |
97,416,633 | opencv | Serializable datatypes in Java API | 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
```
| auto-transferred,priority: normal,feature,category: java bindings | low | Minor |
97,416,703 | opencv | solvePnPRansac and the inliers | 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.
```
| auto-transferred,feature,priority: low,category: calib3d | low | Minor |
97,416,738 | opencv | SURF feautures doesn't work with DenseGrid when grid sampling is pair | 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
```
| bug,auto-transferred,priority: normal,category: nonfree | low | Critical |
97,416,777 | opencv | Empty imshow window when OpenGL enabled | 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
```
| bug,auto-transferred,priority: normal,category: highgui-gui | low | Critical |
97,416,922 | opencv | cv2.HOGDescriptor().compute() crashes python | 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
```
| bug,auto-transferred,priority: normal,category: python bindings | low | Critical |
97,416,948 | opencv | Display special chars using Qt | 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
```
| auto-transferred,priority: normal,feature,category: highgui-gui | low | Critical |
97,416,975 | opencv | No toolbar icon on CV_GUI_EXPANDED, resizeWindow not working when build highgui with QT | Transferred from http://code.opencv.org/issues/2070
```
|| Changlin Hsieh on 2012-06-20 08:16
|| Priority: Normal
|| Affected: None
|| Category: highgui-gui
|| Tracker: Bug
|| Difficulty: None
|| PR: None
|| Platform: None / None
```
## No toolbar icon on CV_GUI_EXPANDED, resizeWindow not working when build highgui with QT
```
There are no toolbar icon when I use CV_GUI_EXPANDED.
And even I use CV_GUI_EXPANDED or CV_GUI_Normal, the function cv::resizeWindow just not working, it always show a window with size about 400x350
I just test using a simple code.
Mat image = imread(filename, 1);
string WinName = "Viewer";
namedWindow(WinName, CV_WINDOW_NORMAL | CV_WINDOW_KEEPRATIO | CV_GUI_EXPANDED);
resizeWindow(WinName, 800, 600);
imshow(WinName, image);
Below is my build Information
General configuration for OpenCV 2.4.1 =====================================
Platform:
Host: Linux 2.6.32-41-generic x86_64
CMake: 2.8.0
CMake generator: Unix Makefiles
CMake build tool: /usr/bin/make
Configuration: Release
C/C++:
Built as dynamic libs?: YES
C++ Compiler: /usr/bin/c++ (ver 4.4.3)
C++ flags (Release): -Wall -Wno-long-long -pthread -fomit-frame-pointer -msse -msse2 -mssse3 -msse4.1 -msse4.2 -ffunction-sections -O3 -DNDEBUG -DNDEBUG
C++ flags (Debug): -Wall -Wno-long-long -pthread -fomit-frame-pointer -msse -msse2 -mssse3 -msse4.1 -msse4.2 -ffunction-sections -g -O0 -DDEBUG -D_DEBUG -ggdb3
C Compiler: /usr/bin/gcc
C flags (Release): -Wall -Wno-long-long -pthread -fomit-frame-pointer -msse -msse2 -mssse3 -msse4.1 -msse4.2 -ffunction-sections -O3 -DNDEBUG -DNDEBUG
C flags (Debug): -Wall -Wno-long-long -pthread -fomit-frame-pointer -msse -msse2 -mssse3 -msse4.1 -msse4.2 -ffunction-sections -g -O0 -DDEBUG -D_DEBUG -ggdb3
Linker flags (Release):
Linker flags (Debug):
OpenCV modules:
To be built: calib3d contrib core features2d flann gpu highgui imgproc legacy ml nonfree objdetect photo stitching ts video videostab
Disabled: -
Disabled by dependency: -
Unavailable: androidcamera java python
GUI:
QT 4.x: YES (ver 4.6.2 EDITION = OpenSource)
QT OpenGL support: NO
OpenGL support: NO
Media I/O:
ZLib: build (ver 1.2.6)
JPEG: build (ver 62)
PNG: build (ver 1.5.9)
TIFF: build (ver 42)
JPEG 2000: build (ver 1.900.1)
OpenEXR: /usr/local/lib/libImath.so /usr/local/lib/libIlmImf.so /usr/local/lib/libIex.so /usr/local/lib/libHalf.so /usr/local/lib/libIlmThread.so (ver 1.6.1)
Video I/O:
DC1394 1.x: NO
DC1394 2.x: NO
FFMPEG: NO
codec: NO
format: NO
util: NO
swscale: NO
gentoo-style: NO
GStreamer: NO
OpenNI: NO
OpenNI PrimeSensor Modules: NO
PvAPI: NO
UniCap: NO
UniCap ucil: NO
V4L/V4L2: YES/YES
Xine: NO
Other third-party libraries:
Use IPP: 7.0 [7.0.205]
at: /opt/intel/ipp
Use TBB: YES (ver 4.0 interface 6003)
Use Eigen: YES (ver 3.0.2)
Python:
Interpreter: /usr/bin/python2.6 (ver 2.6.5)
Tests and samples:
Tests: YES
Performance tests: YES
Examples: YES
Install path: /usr/local
cvconfig.h is in: /home/changlin/OpenCV-2.4.1/build
-----------------------------------------------------------------
```
## History
##### Changlin Hsieh on 2012-06-20 08:25
```
I upload wrong screenshot when crerating issue.
Attach image is correct
- File Screenshot.png added
```
##### Harald Schmidt on 2012-07-18 09:05
```
1. --------------------------------
I use CV_GUI_EXPANDED or CV_GUI_Normal, the function cv::resizeWindow just not working, it always show a window with size about 400x350
Apply resize on parent widget - and it works:
// window_qt.cpp Line: 1855
<pre>
@// window_qt.cpp Line: 1855
void CvWindow::setViewportSize(QSize size)
{
QWidget* view = myView->getWidget();
int dx = size.width();
int dy = size.height();
view->parentWidget()->resize(dx-7, dy);
myView->setSize(size);
}
// that was the bugfix @
</pre>
And now a little improvement:
insert following function e.g. behind cv::moveWindow() in window.cpp :
<pre>
@void cv::adjustWindowPos( const string& winname, int xp, int xwp, int yp, int yhp )
{
// Additional function for % setting of windows:
// all values in % relative to screen resulution:
#ifdef _WIN32
int cx,cy;
cx = GetSystemMetrics(SM_CXSCREEN);
cy = GetSystemMetrics(SM_CYSCREEN);
int x = 0.01 * ( xp * cx );
int y = 0.01 * ( yp * cy );
int neww = 0.01 * (xwp * cx );
int newh = 0.01 * (yhp * cy );
cvMoveWindow( winname.c_str(), x, y );
cvResizeWindow( winname.c_str(),neww, newh );
#else
cvAdjustWindowPosQt( winname.c_str(), xp, xwp, yp, yhp );
#endif
}@
</pre>
additional modify WindowQt.cpp:
in case of Linux we do not have GetSystemMetrics
so let it do by Qt, but one more include is nesseary:
<pre>
@#include <QDesktopWidget>
CV_IMPL void cvAdjustWindowPosQt( const char * name, int xp, int xwp, int yp, int yhp )
{
int cx,cy;
QDesktopWidget* pDeskWid = QApplication::desktop() ;
QRect ScreenGeo = pDeskWid->screenGeometry(); // needs #include <QDesktopWidget>
cx = ScreenGeo.width();
cy = ScreenGeo.height();
int x = 0.01 * ( xp * cx );
int y = 0.01 * ( yp * cy );
int neww = 0.01 * (xwp * cx );
int newh = 0.01 * (yhp * cy );
cvMoveWindow( name, x, y );
cvResizeWindow( name, neww, newh );
}
@
</pre>
2.---------------------------------
There are no toolbar icon when I use CV_GUI_EXPANDED.
it works well with Windows XP + Windows 7
It was possible to reproduce this bug for me using Ubuntu
To avoid this bug I wrote some code to read the whole configuration of a button bar
from a *.cfg
In this way you have a free order of several contol types
( all QT, so only QT New function in the moment)
```
##### Andrey Kamaev on 2012-08-16 15:39
```
- Category changed from highgui-images to highgui-gui
```
| bug,auto-transferred,priority: normal,category: highgui-gui | low | Critical |
97,417,057 | opencv | Restriction on principal point | 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
| auto-transferred,priority: normal,feature,category: calib3d | low | Minor |
97,417,173 | opencv | cv::stereoRectify: add a flag for horizontal/vertical stereo | 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
| auto-transferred,priority: normal,feature,category: calib3d | low | Minor |
97,417,283 | opencv | cvFindExtrinsicCameraParams2 produces inaccurate results when given 2D objectPoints | Transferred from http://code.opencv.org/issues/2143
```
|| dima kogan on 2012-07-04 18:47
|| Priority: Normal
|| Affected: None
|| Category: calibration, 3d
|| Tracker: Bug
|| Difficulty: None
|| PR: None
|| Platform: None / None
```
## cvFindExtrinsicCameraParams2 produces inaccurate results when given 2D objectPoints
```
If I call cvFindExtrinsicCameraParams2() and pass it 2D objectPoints, I
expect the routine to assume a planar object with z==0. Instead, z = 1 is
used; this is done with this line in the implementation of
cvFindExtrinsicCameraParams2():
cvConvertPointsHomogeneous( objectPoints, matM );
It makes no sense to convert the objectPoints matrix to homogeneous
coordinates, as this data lives in a completely different coordinate
system from the camera observing the object.
Looking a bit closer, it appears that the documentation of this function
claims to support ONLY 3D data for this matrix. Thus maybe the fix is to
simply enforce 3D input, which would make this issue moot. This would
handle bug #1875 as well.
Thanks
```
## History
##### Andrey Kamaev on 2012-07-09 11:43
```
- Category set to calibration, 3d
```
| bug,auto-transferred,priority: normal,category: calib3d | low | Critical |
97,417,457 | opencv | Saving and Loading the index starting with a DescriptorMatcher object | Transferred from http://code.opencv.org/issues/2163
```
|| Craig Shaffer on 2012-07-11 20:22
|| Priority: Normal
|| Affected: None
|| Category: flann
|| Tracker: Bug
|| Difficulty: None
|| PR: None
|| Platform: None / None
```
## Saving and Loading the index starting with a DescriptorMatcher object
```
Using the code in "matching_to_many_images.cpp"
descriptorMatcher = DescriptorMatcher::create( matcherType );
//Build the index
descriptorMatcher->add( trainDescriptors );
descriptorMatcher->train();
//Now I want to save the index. Unless I am missing something it cannot be done with this approach.
descriptorMatcher->write(descriptorSettings) would be the obvious choice but it doesn't actually store the index.
Since there is no way to access the flannIndex object (it is protected with no "get" function) I'm stuck.
I believe this is causing about 90% of the confusion posted on various sites under the phrase "opencv flann save index"
I hope you can suggest a change / work around that keeps descriptormatcher as that's a really nice interface.
Also why does "void FlannBasedMatcher::read"
release the index? flannIndex.release() this seems odd.
/Craig
```
## History
##### Maria Dimashova on 2012-07-12 07:20
```
- Priority changed from Blocker to Normal
```
##### Maria Dimashova on 2012-07-12 13:06
```
- Assignee changed from Marius Muja to Maria Dimashova
```
| bug,auto-transferred,priority: normal,category: flann | low | Critical |
97,417,487 | opencv | possible problems of orb and freak | Transferred from http://code.opencv.org/issues/2176
```
|| Maria Dimashova on 2012-07-16 18:27
|| Priority: Normal
|| Affected: None
|| Category: features2d
|| Tracker: Bug
|| Difficulty: None
|| PR: None
|| Platform: None / None
```
## possible problems of orb and freak
```
Please, look at the commented tests in features2d/test/test_rotation_and_scale_invariance.cpp.
ORB shows low scale invariance (especially descriptor), FREAK shows low rotation and scale invariance (maybe I use it wrong).
We have to check that there are no bugs in the algorithms.
```
## History
##### Vadim Pisarevsky on 2012-10-05 10:05
```
- Target version deleted ()
- Assignee deleted (Vadim Pisarevsky)
```
##### Kirill Kornyakov on 2012-10-24 08:38
```
- Target version set to Next Hackathon
```
| bug,auto-transferred,priority: normal,category: features2d | low | Critical |
97,417,522 | opencv | REQUEST: stereosgbm -> change cost array type from short to unsigned short | Transferred from http://code.opencv.org/issues/2180
```
|| Stefan Hahn on 2012-07-18 05:16
|| Priority: Low
|| Affected: None
|| Category: calibration, 3d
|| Tracker: Feature
|| Difficulty: None
|| PR: None
|| Platform: None / None
```
## REQUEST: stereosgbm -> change cost array type from short to unsigned short
```
typedef unsigned short CostType;
On Line 59 in current source would give some more leeway for the accumulator array before clipping.
Tested only with own code.
```
## History
##### Marina Kolpakova on 2012-07-24 17:16
```
- Category set to calibration, 3d
```
| auto-transferred,feature,priority: low,category: calib3d | low | Minor |
97,417,590 | opencv | Add norm type to FlannBasedMatcher constructor | Transferred from http://code.opencv.org/issues/2183
```
|| Maria Dimashova on 2012-07-24 12:57
|| Priority: Normal
|| Affected: None
|| Category: features2d
|| Tracker: Bug
|| Difficulty: None
|| PR: None
|| Platform: None / None
```
## Add norm type to FlannBasedMatcher constructor
```
Add a norm type support to the FlannBasedMatcher. This was not done yet for historical reasons.
```
## History
| bug,auto-transferred,priority: normal,category: features2d | low | Critical |
97,417,835 | opencv | Incorrect window size and drawing functions for small windows. | Transferred from http://code.opencv.org/issues/2200
```
|| Chris Miller on 2012-07-25 18:50
|| Priority: Normal
|| Affected: None
|| Category: highgui-gui
|| Tracker: Bug
|| Difficulty: None
|| PR: None
|| Platform: None / None
```
## Incorrect window size and drawing functions for small windows.
```
Building in Windows x64 VS2010. Issue is possibly related to
http://code.opencv.org/issues/2189
but also affects the perceived cursor position.
<pre><code class="cpp">
void drawCircle( int event, int x, int y, int ignoreMe, void* mat_)
{
if(event == CV_EVENT_LBUTTONDOWN){
Mat img = *((Mat*) mat_);
circle(img, Point(x,y), 3, Scalar(255,255,255), -1);
imshow("Window Test", img);
}
}
int main( int argc, const char** argv )
{
Mat smallImg = Mat::zeros(90,90,CV_32F);
imshow("Window Test", smallImg);
setMouseCallback("Window Test",drawCircle,&smallImg);
while (cvWaitKey(4) == -1) {}
return 0;
}
</code></pre>
As in the OSX bug, this produces a window that is too wide for the image. If you try and draw circles at the cursor position they are placed incorrectly and the error increases as you move to the right.
My screenshooter doesn't capture the cursor but in the attached image I attempted to create 3 circles by clicking on the extreme left, the middle, and the extreme right of the black image.
!bug.png!
```
## History
##### Daniil Osokin on 2012-08-01 06:20
```
Which version of OpenCV do you use?
- Assignee changed from Vadim Pisarevsky to Chris Miller
```
##### Daniil Osokin on 2012-08-06 06:39
```
- Assignee deleted (Chris Miller)
```
##### Andrey Kamaev on 2012-08-15 12:13
```
- Description changed from Building in Windows x64 VS2010. Issue is
possibly related to http://code.o... to Building in Windows x64
VS2010. Issue is possibly related to http://code.o... More
```
##### Andrey Kamaev on 2012-08-16 15:41
```
- Category changed from highgui-images to highgui-gui
```
| bug,auto-transferred,priority: normal,category: highgui-gui | low | Critical |
97,417,910 | opencv | More operations of CCS-packed DFT spectra is advisable | Transferred from http://code.opencv.org/issues/2224
```
|| Alexander Mordvintsev on 2012-08-01 08:45
|| Priority: Low
|| Affected: None
|| Category: core
|| Tracker: Feature
|| Difficulty: None
|| PR: None
|| Platform: None / None
```
## More operations of CCS-packed DFT spectra is advisable
```
Currently we have @mulSpectrums@, which can also take a conjugation of its second argument. Functions for spectrum division and conjugation might be useful for implementing some algorithms. "MOSSE tracker":http://www.cs.colostate.edu/~bolme/publications/Bolme2010Tracking.pdf is an example.
```
## History
##### Will Lucas on 2012-08-11 03:57
```
I created two such methods (division and magnitude) for doing phase correlation a while back. However, as of right now the functions are statically scoped in @phasecorr.cpp@ available "here":http://code.opencv.org/projects/opencv/repository/revisions/master/entry/modules/imgproc/src/phasecorr.cpp.
It may be possible to make these stand alone for more general purpose use.
-Will
```
| auto-transferred,feature,priority: low,category: core | low | Minor |
97,417,977 | opencv | Feature request: max() | Transferred from http://code.opencv.org/issues/2236
```
|| Hilton Bristow on 2012-08-03 23:23
|| Priority: Low
|| Affected: None
|| Category: core
|| Tracker: Feature
|| Difficulty: None
|| PR: None
|| Platform: None / None
```
## Feature request: max()
```
Hello,
I would like to request a new variant of the max() or reduce() feature with the following syntax:
void max(InputArray src, OutputArray vdst, const int dim=-1, OutputArray idst=noArray())
where:
src = the source matrix of dimensionality N
vdst = the destination matrix of dimensionality (N-1)
dim = the dimension over which to perform the max reduction (d < N) (optional)
idst = the index within dimension d which contained the maximum value
I find this operation useful on many occasions and it reflects the Matlab functionality
H
```
## History
| auto-transferred,feature,priority: low,category: core | low | Minor |
97,418,018 | opencv | P algorithm implementation | Transferred from http://code.opencv.org/issues/2239
```
|| Damien DEOM on 2012-08-04 11:51
|| Priority: Low
|| Affected: None
|| Category: imgproc, video
|| Tracker: Feature
|| Difficulty: None
|| PR: None
|| Platform: None / None
```
## P algorithm implementation
```
It would be very nice to have the P algorithm implemented, wich is a huge amelioration of the watershed algotithm
Se documentation here:
http://cmm.ensmp.fr/~beucher/publi/P-Algorithm_SB_BM.pdf
Regards
```
## History
##### Damien DEOM on 2012-08-04 12:10
```
another useful link:
http://cmm.ensmp.fr/~beucher/wtshed.html
```
##### Andrey Kamaev on 2012-08-15 13:01
```
- Category set to imgproc, video
```
##### Vadim Pisarevsky on 2012-10-03 13:17
```
- Priority changed from Normal to Low
```
| auto-transferred,feature,category: imgproc,category: video,priority: low | low | Major |
97,418,152 | opencv | Add inter-camera synchronization | Transferred from http://code.opencv.org/issues/2272
```
|| Pavel Gurevich on 2012-08-15 16:10
|| Priority: Normal
|| Affected: None
|| Category: highgui-camera
|| Tracker: Feature
|| Difficulty: None
|| PR: None
|| Platform: None / None
```
## Add inter-camera synchronization
```
When dealing with stereo vision, inter-camera synchronization is of uttermost importance when objects in the frame move. Currently, OpenCV neglects the ability to synchronize even if underlying system (DirectShow or video4linux) supports it.
Please, add ability to synchronize capturing devices.
Thanks!
```
## History
##### Andrey Kamaev on 2012-08-15 18:45
```
- Category set to highgui-images
```
##### Andrey Kamaev on 2012-08-16 15:43
```
- Category changed from highgui-images to highgui-camera
```
##### Vadim Pisarevsky on 2012-09-24 11:21
```
a patch to do it would be very welcome.
```
| auto-transferred,priority: normal,feature,category: videoio(camera) | low | Minor |
97,418,183 | opencv | Automatic documentation of code samples | Transferred from http://code.opencv.org/issues/2291
```
|| Gary Bradski on 2012-08-22 00:04
|| Priority: Low
|| Affected: None
|| Category: documentation
|| Tracker: Feature
|| Difficulty:
|| PR:
|| Platform: None / None
```
## Automatic documentation of code samples
```
We now have an increasing number of code samples under .../samples in C, C++ and Python
We need to
# come up with a standard information header or "help" out put that can be put into each past sample and all future samples that tells
> * what that sample does
> * how to call that sample
# write a python script that can extract the headers and turn it into a documentation page that users can search through to find out what is in each samples directory
```
## History
##### Andrey Kamaev on 2012-10-31 14:08
```
- Target version changed from 2.4.3 to 3.0
```
##### Maksim Shabunin on 2015-04-27 15:09
```
- Target version changed from 3.0 to 3.1
- Priority changed from Normal to Low
- Assignee changed from Vadim Pisarevsky to Maksim Shabunin
```
| auto-transferred,feature,priority: low,category: documentation | low | Minor |
97,418,277 | opencv | operations on arrays: more cv::Mat return signatures | Transferred from http://code.opencv.org/issues/2305
```
|| Hilton Bristow on 2012-08-25 22:06
|| Priority: Normal
|| Affected: None
|| Category: core
|| Tracker: Feature
|| Difficulty: None
|| PR: None
|| Platform: None / None
```
## operations on arrays: more cv::Mat return signatures
```
I would like to request more Mat/MatExpr return signatures for elementwise operations on arrays, including:
Mat exp(const Mat& src);
Mat pow(const Mat& src, float exp);
Mat sqrt(const Mat& src);
Mat square(const Mat& src);
Mat log(const Mat& src);
That will make for more readable code when doing the following type of operations:
L = I - exp( diag(D) * log(W) );
Obviously this will trigger a lot of unnecessary memory allocations, so non-const (in-place) versions or versions that return MatExpr would be appreciated as well/instead.
```
## History
##### Stefan R on 2012-10-25 15:07
```
I can contribute the following:
<pre>
cv::Mat mul(const cv::Mat& a, const cv::Mat& b)
{
cv::Mat tmp;
cv::multiply(a, b, tmp);
return tmp;
}
cv::Mat pow(const cv::Mat& src, double power)
{
cv::Mat tmp;
if( power == 2.0 ){
cv::multiply(src, src, tmp);
} else {
cv::pow(src, power, tmp);
}
return tmp;
}
cv::Mat sqrt(const cv::Mat& src)
{
cv::Mat tmp;
cv::sqrt(src, tmp);
return tmp;
}
</pre>
```
##### Vadim Pisarevsky on 2012-10-26 18:49
```
let's postpone it; the proposed "naive" implementation is very inefficient. Need to think how to do it properly.
- Target version changed from 2.4.3 to 3.0
```
##### Leszek Swirski on 2013-03-29 11:55
```
Could it be an idea to embrace Eigen for such things? These are exactly the sorts of things that Eigen is good at doing efficiently.
```
| auto-transferred,priority: normal,feature,category: core | low | Minor |
97,418,310 | opencv | dense spectral clustering | Transferred from http://code.opencv.org/issues/2306
```
|| Hilton Bristow on 2012-08-26 05:44
|| Priority: Normal
|| Affected: None
|| Category: core
|| Tracker: Feature
|| Difficulty:
|| PR:
|| Platform: None / None
```
## dense spectral clustering
```
I would like to submit a function for spectral clustering. The function uses dense matrices and dense eigen-decomposition, so it is not suitable for very large clustering problems.
The method is based upon well known works of spectral clustering, and implements two graph laplacian normalization methods:
- Shi and Malik, "Normalized Cuts and Image Segmentation", PAMI 2000
- Ng, Jordan and Weiss, "On Spectral Clustering: Analysis and an Algorithm", NIPS 2002
All functionality is templated, so wrapping it in Input/Output Arrays should be trivial. Please let me know if you need anything further, such as unit tests, etc
```
## History
##### Alexandre Benoit on 2014-01-20 19:52
```
Hi,
i currently take a look at the proposed code.
At this point, it works and this is really interesting to make it available to the community since spectral clustering is a very efficient unsupervised clustering method.
However, the code needs some refactoring that would aim to :
_avoid to force end user to use cv::Mat_<T> objects. It would be easier to use the classical cv::Mat objects.
_enhance the proposed adjacency matrix computation. It currently relies on a the epsilon neighborhood graph. Other methods can be added : fully connected graph (with continuous similarity values) and knn neighbors graph.
I can work on it. However, i wonder where this code should be added ?
opencv_ml ? But the knn neighborhood graph method is very convenient to be used with the cv::DescriptorMatcher object that is in the feature2d module (we can choose the knn matching method, etc.).
Then, what should be done ?
Any recommendation ?
```
| auto-transferred,priority: normal,feature,category: core | low | Minor |
97,418,372 | opencv | standardised Distance interface | Transferred from http://code.opencv.org/issues/2308
```
|| Hilton Bristow on 2012-08-26 06:53
|| Priority: Normal
|| Affected: None
|| Category: core
|| Tracker: Feature
|| Difficulty: None
|| PR: None
|| Platform: None / None
```
## standardised Distance interface
```
I would like to propose a standardized interface for distance functions in OpenCV. I have outlined one such interface in the attached file. I have implemented a simple Euclidean distance function as an example, but if you like the interface I can implement Mahalanobis, Manhattan, Cosine, Correlation, etc.
Aspects of the interface that I deem important:
* standardized. If functions require a DistanceFunction functor, then we can pass any subclass and expect it to work.
* speed. Obvious.
* can maintain state. Say you want a euclidean distance that is only based upon the k-nearest neighbours and zero elsewhere. As long as the distance function is aware of the neighbourliness, this detail can remain transparent to the actual calling function.
* generalize to any dimensionality. Computer vision is no longer about just images. We should not restrict users to find the euclidean distance between 2D points.
For example, finding the pairwise distance between a set of datapoints (pdist() in matlab) is as simple as:
<pre>
int M, K; // M datapoints, K dimensions
Mat_<float> data(M, K);
Mat_<float> pairwise(M, M);
randn(data, 1, 1);
EuclideanDistance<float> distance(K);
for (int i = 0; i < M; ++i) {
for (int j = 0; j < M; ++j) {
pairwise(i,j) = distance(data[i], data[j]);
}
}
</pre>
This would go a long way to producing more general algorithms such as K-dimensional kmeans(), or keypoint matching using complex distance metrics.
```
## History
##### Kirill Kornyakov on 2012-09-24 12:13
```
- Category set to core
```
##### Alexander Smorkalov on 2012-10-03 08:42
```
- Assignee set to Vadim Pisarevsky
```
| auto-transferred,priority: normal,feature,category: core | low | Minor |
97,418,396 | opencv | A big push for sparse support! | Transferred from http://code.opencv.org/issues/2309
```
|| Hilton Bristow on 2012-08-26 07:07
|| Priority: Normal
|| Affected: None
|| Category: core
|| Tracker: Feature
|| Difficulty: None
|| PR: None
|| Platform: None / None
```
## A big push for sparse support!
```
In the lead-up to version 2.5, it would be great to have a big push towards better sparse matrix support in OpenCV. Since sparse matrices are currently not supported at all (no primitive operations +, *, etc) this gives us a great opportunity to talk to the community and ask what they want from sparse matrices, and I'd like to get the conversation started.
Here's what's on the top of my list:
* new optimization module
* make SuiteSparse or Ceres a dependency, and rebuild sparse support around their data structures
* more matlab-esque operations, including accessors [], (), full(), and better sparse support for existing functions, abs(), norm(), inv()
What are the challenges involved in making this happen, and is it possible to absorb libraries like SuiteSparse which already have good sparse support? Can we start a public forum to throw around ideas? Either at ECCV or online?
```
## History
##### Daniel Moodie on 2015-02-03 16:09
```
Hilton Bristow wrote:
> In the lead-up to version 2.5, it would be great to have a big push towards better sparse matrix support in OpenCV. Since sparse matrices are currently not supported at all (no primitive operations +, *, etc) this gives us a great opportunity to talk to the community and ask what they want from sparse matrices, and I'd like to get the conversation started.
>
> Here's what's on the top of my list:
> * new optimization module
> * make SuiteSparse or Ceres a dependency, and rebuild sparse support around their data structures
> * more matlab-esque operations, including accessors [], (), full(), and better sparse support for existing functions, abs(), norm(), inv()
>
> What are the challenges involved in making this happen, and is it possible to absorb libraries like SuiteSparse which already have good sparse support? Can we start a public forum to throw around ideas? Either at ECCV or online?
I would absolutely love SuiteSparse or Ceres integration!
```
##### Alex Susu on 2015-02-12 15:58
```
Hello.
I believe a better format for efficiency for sparse matrix representation should be CSR/CSC, not DOK (Dictionary of Keys), as it is right now. I personally recommend using bebop.cs.berkeley.edu/oski/ since it seems to support more sparse matrix formats.
Also, we need to use in OpenCV operations on sparse matrices such as warpPerspective, etc which boil down to
remap() (http://docs.opencv.org/modules/imgproc/doc/geometric_transformations.html?highlight=remap#remap) .
A trivial implementation would require DOK or LIL sparse matrix format. But, I was able to implement some of the
remap operations using the CSR/CSC format, although it's a bit tricky.
Although this I guess does not encourage highest performance, it would also be nice to derive cv::SparseMat
from cv::Mat and make it's interface compatible with cv::Mat in order to have operations like warpPerspective()
and remap() support directly SparseMat.
Please let me know what are your thoughts on these issues.
Thank you,
Alex
```
| auto-transferred,priority: normal,feature,category: core | low | Major |
97,418,421 | opencv | implicitly casting away cv::Mat constness | Transferred from http://code.opencv.org/issues/2317
```
|| Evan Krause on 2012-08-27 16:53
|| Priority: Low
|| Affected: None
|| Category: core
|| Tracker: Feature
|| Difficulty: None
|| PR:
|| Platform: None / None
```
## implicitly casting away cv::Mat constness
```
While porting some code from using the old IplImage to using cv::Mat, I noticed that it's all too easy to accidentally cast away the constness of cv::Mat. A simple example:
const cv::Mat mat_const(3,1,CV_32FC1,data);
cv::Mat mat_non_const = mat_const;
//modifying mat_non_const also modifies mat_const !!!
It seems that this is a huge problem that opens the door to all kinds of bugs. Is there some alternative way for dealing with and ensuring constness (or at least making it hard and more explicit to cast it away)?
```
## History
##### Vadim Pisarevsky on 2012-09-19 13:05
```
I doubt we can solve it easily. It's not a bug, it's just the way how C++ works. I do not see a solution other than to introduce a separate const_Mat class, but this is big effort to make it properly.
Let's mark it as low-priority feature for 2.5. May be, in a few months from now we will see how to do it or maybe someone proposes a patch.
- Target version set to 3.0
- Priority changed from Normal to Low
- Assignee set to Vadim Pisarevsky
- Category set to core
- Tracker changed from Bug to Feature
```
##### Adi Shavit on 2013-04-25 21:01
```
You could actually define the non-const assignment operator only for non-const cv::Mat, and a const assignment operator for const cv::Mat.
Then when attempting to copy from a const cv::Mat you'd get a compilation error if the target is non-const, at which point you could either define it as const or use clone().
```
| auto-transferred,feature,priority: low,category: core | low | Critical |
97,418,550 | opencv | Add new create() method for Feature2D | Transferred from http://code.opencv.org/issues/2333
```
|| Maria Dimashova on 2012-09-05 09:58
|| Priority: Normal
|| Affected: None
|| Category: features2d
|| Tracker: Feature
|| Difficulty: None
|| PR: None
|| Platform: None / None
```
## Add new create() method for Feature2D
```
with arguments Ptr<FeatureDetector> and Ptr<DescriptorExtractor>.
```
## History
##### Alexander Shishkov on 2012-09-07 13:32
```
- Target version deleted (3.0)
- Assignee deleted (Maria Dimashova)
```
| auto-transferred,priority: normal,feature,category: features2d | low | Minor |
97,418,589 | opencv | Support UnBayer color conversion for Single (float) Images | Transferred from http://code.opencv.org/issues/2346
```
|| Gilad Kapelushnik on 2012-09-10 15:19
|| Priority: Low
|| Affected: None
|| Category: imgproc, video
|| Tracker: Feature
|| Difficulty: None
|| PR: None
|| Platform: None / None
```
## Support UnBayer color conversion for Single (float) Images
```
As of 2.4.2, Unbayer is only supported for 8bit and 16bit integers.
Please add support for Single (float) based images.
```
## History
##### Kirill Kornyakov on 2012-09-24 12:25
```
Could you please explain why do you need this functionality? It would be useful to have:
# Use case description
# Input/output data attached
# Code sample which is supposed to work after this feature is added
Unfortunately I personally don't understand why one may need this function, so please elaborate on your problem. And think about implementing it by yourself :)
- Priority changed from Normal to Low
- Assignee set to Gilad Kapelushnik
- Category set to imgproc, video
```
##### Gilad Kapelushnik on 2012-09-25 17:21
```
I know that in most cases the first operation that is done is unbayer the data that is received from the camera.
In my case I apply two operations before unbayer.
The first is 'Dark Frame' correction - subtracting a dark frame from the image. Lets assume the data received from the camera is 12bit image coded in 16bit data. Subtracting the dark frame from the received image would produce an int16 image, no problem here.
The second is 'Flat field correction' - This is done to remove some unwanted artifacts caused by the lens (and sensor micro-lenses). Since there is a division operation here the output image is float. It is possible to have the flat filed correction produce int16 images but that is in the cost of chopping off some data and converting the data from float to int16 for the whole image. We can argue how much that 'copped' data affects quality but that is another story.
After these 2 procedures I do unbayer. It is better applying these procedures before unbayer as it is faster and the errors or unwanted artifacts aren't smoothed by the unbayer procedure.
I hope I was able to explain this properly.
If you think I would get better results doing things differently I would be happy to know.
Cheers,
Gilad.
```
| auto-transferred,feature,category: imgproc,category: video,priority: low | low | Critical |
97,418,618 | opencv | stereoRectifyUncalibrated doesn't accept the same type of array as findFundamentalMat | 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
```
| bug,auto-transferred,priority: normal,category: calib3d | low | Critical |
97,418,909 | opencv | FileStorage segfaults parsing singleton tags | 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
```
| auto-transferred,feature,priority: low,category: core | low | Critical |
97,418,971 | opencv | Multi Otsu Threshold | 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
| auto-transferred,priority: normal,feature,category: imgproc,category: video | low | Major |
97,419,218 | opencv | Modulo operation for Mat type | 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.
```
| auto-transferred,feature,priority: low,category: core | low | Minor |
97,419,278 | opencv | Download only python module | 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
| auto-transferred,priority: normal,feature,category: python bindings,category: build/install,category: infrastructure | low | Minor |
97,419,427 | opencv | Improve readability of InputArray type arg-s in func-s signature | 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
| auto-transferred,feature,priority: low,category: core | low | Minor |
97,419,457 | opencv | cvGetWindowHandle with QT windows don't work | 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
| bug,auto-transferred,priority: normal,category: highgui-gui | low | Critical |
97,419,706 | opencv | Multiple functions for polygon drawing | Transferred from http://code.opencv.org/issues/2573
```
|| Michael Burdinov on 2012-11-27 06:19
|| Priority: Low
|| Affected: None
|| Category: core
|| Tracker: Feature
|| Difficulty: None
|| PR: None
|| Platform: None / None
```
## Multiple functions for polygon drawing
```
fillPoly, polylines, and drawContours are designed to do the same task: draw set of polygons in image. They have minor differences but it is still unclear why there 3 functions instead of one. There no documentation that compare them, so I don't even know whether each one has its own implementation or they share some code.
Kirill Kornyakov:
Suggestion is to get rid of two of them and to stay with only one.
```
## History
##### Kirill Kornyakov on 2012-11-27 10:34
```
OK, but what exactly is needed here?
If the one is interested in inter-dependency of this functions, he can read the code. If you want to see some explanation in the documentation, then please point which pages should be updated and with which text. It is also possible that you could make a pull request to the documentation, to simplify the whole procedure. OpenCV project doesn't have a dedicated technical writer, so it may take forever...
- Target version set to Next Hackathon
- Assignee changed from Vadim Pisarevsky to Michael Burdinov
- Category changed from core to documentation
```
##### Michael Burdinov on 2012-11-27 14:37
```
This is not issue of documentation (at least not only documentation). Someone has to decide which one of the 3 functions is the most correct / has best interface / fastest / is supported / and so on. Two other functions should be deprecated. Or maybe some new interface should be created that will unify all 3 interfaces, and existing ones will all be depricated. I just pointed out that having 3 different functions with nearly identical functionality is very confusing. At least I don't know the answer to the question: which function should be used.
```
##### Kirill Kornyakov on 2012-11-28 07:47
```
OK, let Vadim decide. Functions are indeed quite similar, so we'll probably get rid of some of them during the next restucturing.
Here are functions' signatures to think about:
* "fillPoly":http://docs.opencv.org/modules/core/doc/drawing_functions.html?highlight=fillpoly#cv.FillPoly
* "polylines":http://docs.opencv.org/modules/core/doc/drawing_functions.html?highlight=polylines#cv2.polylines
* "drawContours":http://docs.opencv.org/modules/imgproc/doc/structural_analysis_and_shape_descriptors.html?highlight=drawcontours#cv.DrawContours
<pre>
void polylines(Mat& img, const Point** pts, const int* npts, int ncontours, bool isClosed, const Scalar& color, int thickness=1, int lineType=8, int shift=0 )
void fillPoly(Mat& img, const Point** pts, const int* npts, int ncontours, const Scalar& color, int lineType=8, int shift=0, Point offset=Point() )
void drawContours(InputOutputArray image, InputArrayOfArrays contours, int contourIdx, const Scalar& color, int thickness=1, int lineType=8, InputArray hierarchy=noArray(), int maxLevel=INT_MAX, Point offset=Point() )
</pre>
- Target version changed from Next Hackathon to 3.0
- Priority changed from Normal to Low
- Description changed from fillPoly, polylines, and drawContours are
designed to do the same task: draw ... to fillPoly, polylines, and
drawContours are designed to do the same task: draw ... More
- Assignee changed from Michael Burdinov to Vadim Pisarevsky
- Category changed from documentation to core
- Tracker changed from Patch to Feature
```
| auto-transferred,feature,priority: low,category: core | low | Minor |
97,419,742 | opencv | Accepting vector<Point2d> instead of vector<Point> (for consistency and convenience) | 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
| auto-transferred,priority: normal,feature,category: core | low | Minor |
97,419,781 | opencv | VideoCapture is retrieving images always with 3 channels | 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
```
| auto-transferred,priority: normal,feature,category: videoio | low | Critical |
97,419,861 | opencv | BruteForceMatcher : Custom norm types don't work since v2.4 | 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!
```
| auto-transferred,feature,priority: low,category: features2d | low | Critical |
97,419,916 | opencv | cv::FileStorage does not support serialization of "unsigned int" and "size_t" | 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...
```
| auto-transferred,feature,priority: low,category: core | low | Critical |
97,420,015 | opencv | cv::CascadeClassifier has no deep copy clone | 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)
```
| auto-transferred,priority: normal,feature,category: objdetect | low | Minor |
97,420,148 | opencv | imshow using cl_khr_gl_sharing extension to show images | 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
```
| auto-transferred,priority: normal,feature,category: ocl | low | Minor |
97,420,353 | opencv | Default behavior of iOS video camera is to not use preview layer | 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)
```
| bug,auto-transferred,priority: normal,platform: ios/osx | low | Critical |
97,420,438 | opencv | filterSpeckles() and fails on large imagery | 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
| bug,auto-transferred,priority: low,category: calib3d | low | Critical |
97,420,602 | opencv | Some basic operations on image are slow | Transferred from http://code.opencv.org/issues/2648
```
|| Michael Burdinov on 2012-12-19 14:04
|| Priority: Low
|| Affected: None
|| Category: core
|| Tracker: Feature
|| Difficulty: None
|| PR:
|| Platform: None / None
```
## Some basic operations on image are slow
```
Basic operations that works with single image are much slower than similar operations that works with multiple images.
For example addWeighted() function is about 3.5 times faster than multiplying image by scalar. This is extremely weird, since addWeighted performs two multiplications of images by scalars.
Adding scalar to image that should be at least as fast as adding two images, is actually 5 times slower.
Applying abs() to image is 2.5 slower than simple loop over pixels that apply abs() to each pixel.
And so on...
Tests were performed with 1000x1000 8-bit image. I used OpenCV 2.4.2. Tested systems: Windows XP service pack 2 Visual Studio 2005 and Windows XP service pack 3 Visual Studio 2010 (results are not the same but similar).
```
## History
##### Vadim Pisarevsky on 2012-12-19 19:02
```
abs() may take allocation of a temporary image when it's used as a part of complex expression. absdiff is more appropriate function if you want better performance. Besides, for 8-bit unsigned image abs(x) == x, right? In general, basic functions are added for completeness; for top performance you can still use manually-written loops.
- Target version set to 3.0
- Priority changed from Normal to Low
- Tracker changed from Bug to Feature
```
##### Michael Burdinov on 2012-12-20 11:50
```
Vadim Pisarevsky wrote:
> abs() may take allocation of a temporary image when it's used as a part of complex expression. absdiff is more appropriate function if you want better performance. Besides, for 8-bit unsigned image abs(x) == x, right? In general, basic functions are added for completeness; for top performance you can still use manually-written loops.
1) When function that performs certain operation twice is few times faster than function that performs the same operation once, something inside definitely went wrong. I don't know whether the problem is some flags, or un-required memory allocations, or anything else.
2) OpenCV is known for highly optimized low level operations with images. I remember that in the past high performance was achieved by use of IPP. Later IPP was replaced with SSE2, TBB and such. But claims that those operations are very efficient remained. Anyway it is weird that simple loop without any optimizations at all is much faster than existing function. This is especially problematic when this happens in most basic functions, that used countless times by any OpenCV user. Improving performance of those function should have high impact on performance of almost any code that uses OpenCV.
3) abs() wasn't used as part of any complex expression so there shouldn't be any temporary images. Also from what I see in online documentation "abs(A) is equivalent to absdiff(A, Scalar::all(0), C)". This means that they are expected to have same time performance. And for 8-bit signed image abs(x) is not always equal to x.
```
##### Michael Burdinov on 2012-12-30 07:49
```
And just for the record: absdiff( image1, Scalar, image1) is 5 times slower than absdiff( image1, image2, image1). So the problem exists in absdiff as well.
```
| auto-transferred,feature,priority: low,category: core | low | Critical |
97,420,675 | opencv | 'solve' fucntion works badly on ill-conditioned matrices (atleast numpy works better) | 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
```
| auto-transferred,feature,priority: low,category: core | low | Critical |
97,420,730 | opencv | KDTree from core.h crashes on simple point configurations | 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
```
| bug,auto-transferred,priority: low,category: core | low | Critical |
97,420,788 | opencv | Allowing double type support if possible | Transferred from http://code.opencv.org/issues/2671
```
|| Ming-Ming Cheng on 2012-12-28 22:41
|| Priority: Normal
|| Affected: None
|| Category: core
|| Tracker: Feature
|| Difficulty: None
|| PR:
|| Platform: None / None
```
## Allowing double type support if possible
```
For 64 bit machine, which is the major type currently, operations on double is faster/equal to operations on float. Since the memory difference between double and float is not important for many people, I tried to use double in my code anywhere where float is used before so that don't care too much about type conversion.
A problem is that, some opencv functions only support float (CV_32F). I feel strange why don't them support for double (CV_64F). One example of this function is cvtColor.
```
## History
##### Alexander Smorkalov on 2012-12-29 08:16
```
It is very rare feature for computer vision algorithm. But if you have any suggestions, you can contribute to OpenCV via Github pull request. See this page for more details: https://help.github.com/articles/using-pull-requests
- Category set to core
```
##### Ming-Ming Cheng on 2013-04-11 11:02
```
Thank you very much for the reply. I agree that most computer vision algorithms needs only float. I just feel that I can consistently use double since I typically don't care about the memory cost introduced by this. Consistently using double, like what was done in Matlab, avoids possible data type conversions when double is required. Modern 64bit computers process double at similar or even more efficiency than float.
Alexander Smorkalov wrote:
> It is very rare feature for computer vision algorithm. But if you have any suggestions, you can contribute to OpenCV via Github pull request. See this page for more details: https://help.github.com/articles/using-pull-requests
```
| auto-transferred,priority: normal,feature,category: core | low | Minor |
97,420,834 | opencv | QueryFrame keeps GIL | Transferred from http://code.opencv.org/issues/2672
```
|| Bouke van der Bijl on 2012-12-29 17:07
|| Priority: Normal
|| Affected: None
|| Category: python bindings
|| Tracker: Bug
|| Difficulty: None
|| PR:
|| Platform: None / None
```
## QueryFrame keeps GIL
```
Hi,
normally when a C extension makes a blocking call it should tell the Python interpeter that it can release the GIL http://docs.python.org/2/c-api/init.html#thread-state-and-the-global-interpreter-lock.
This happens correctly for pycvWaitKey, pycvLoadImage and pycvLoadImageM. QueryFrame completely locks up the interpreter when using threads though, and it should be implemented just like pycvWaitKey, pycvLoadImage and pycvLoadImageM are instead of only being wrapped. I don't have any experience with writing Python C extensions so I am afraid I can't fix this myself.
```
## History
| bug,auto-transferred,priority: normal,category: python bindings | low | Critical |
97,420,869 | opencv | [iOS] Undesired Autorotate behavior | Transferred from http://code.opencv.org/issues/2673
```
|| Diego Araos on 2012-12-30 20:42
|| Priority: Normal
|| Affected: None
|| Category: ios
|| Tracker: Bug
|| Difficulty: None
|| PR:
|| Platform: None / None
```
## [iOS] Undesired Autorotate behavior
```
In iOS, I want my device to have a fixed orientation, but whenever my device orientation changes, CvVideoCamera insist to keep rotating it's orientation and after reviewing the source code, it seems like there is no way to avoid this from outside the framework code.
It would be great if you could add an option so I can use the camera with a fixed orientation and the CvVideoCamera follows this rule too. Maybe adding a boolean ? let's say:
self.videoCamera = [[CvVideoCamera alloc] initWithParentView:self.cameraView];
...
self.cameraView.autorotateCamera = NO;
I offer to code a fix if you let me know how to push it afterwards.
Cheers.
```
## History
##### Andrey Kamaev on 2013-01-08 16:22
```
- Assignee set to Vadim Pisarevsky
- Category set to ios
```
##### Sebastien Thiebaud on 2013-02-03 03:20
```
Hi,
Do you have some news about this bug. I'll release an app and this bug is still persistent.
Thank you!
```
##### Ricardo Ruiz on 2013-04-02 21:41
```
I see a couple of fixes, but don't work for me.
http://stackoverflow.com/questions/14876895/how-do-i-make-cvvideocamera-not-auto-rotate
http://answers.opencv.org/question/8329/opencv-setting-ios-orientation/
Any progress on this issue?
```
| bug,auto-transferred,priority: normal,platform: ios/osx | low | Critical |
97,420,930 | opencv | Link the FaceRecognizer tutorials to the Contribs tutorial page | Transferred from http://code.opencv.org/issues/2687
```
|| Shervin Emami on 2013-01-09 01:36
|| Priority: Low
|| Affected: None
|| Category: documentation
|| Tracker: Feature
|| Difficulty: None
|| PR:
|| Platform: None / None
```
## Link the FaceRecognizer tutorials to the Contribs tutorial page
```
The FaceRecognizer tutorials are in the API Reference section (http://docs.opencv.org/modules/contrib/doc/facerec/index.html) instead of the Contrib tutorials section (http://docs.opencv.org/doc/tutorials/contrib/table_of_content_contrib/table_of_content_contrib.html#table-of-content-contrib). Perhaps it should be moved, or atleast a link put on the Contrib tutorials page showing where the tutorials actually are?
```
## History
| auto-transferred,feature,priority: low,category: documentation | low | Minor |
97,421,009 | opencv | window issues on mac os x mountain lion (10.8) | Transferred from http://code.opencv.org/issues/2694
```
|| Andrei Zaharescu on 2013-01-12 02:40
|| Priority: Normal
|| Affected: 2.4.3
|| Category: highgui-gui
|| Tracker: Bug
|| Difficulty: None
|| PR:
|| Platform: None / None
```
## window issues on mac os x mountain lion (10.8)
```
When running any opencv sample application on Mac OS X (10.8) that uses basic highgui imshow functionality, see the following problems:
* the window does not have the focus by default
* the window position is not remembered between subsequent runs, as it is the case on Windows
* the window flags are not respected. When setting the CV_WINDOW_NORMAL in namedWindow and resizing the window, the content is not auto-resized anymore
* when displaying an image that is too narrow (lets say 400x100), the window is in effect wider than the image, which in practice causes issues when capturing mouse events over the window, since one expects the image to span the whole window.
```
## History
##### Daniil Osokin on 2013-01-14 04:38
```
- Description changed from When running any opencv sample application
on Mac OS X (10.8) that uses basic... to When running any opencv
sample application on Mac OS X (10.8) that uses basic... More
```
##### Daniil Osokin on 2013-01-14 04:40
```
Hi! Please, specify OpenCV version and provide test code sample to reproduce the bug, otherwise the ticket will be closed.
```
##### Daniil Osokin on 2013-01-14 04:40
```
- Assignee changed from Vadim Pisarevsky to Andrei Zaharescu
```
##### Vadim Pisarevsky on 2013-01-22 22:21
```
- Target version deleted (2.4.4)
```
##### Vadim Pisarevsky on 2013-01-24 17:53
```
- Assignee deleted (Andrei Zaharescu)
```
##### Vadim Pisarevsky on 2013-01-31 19:05
```
- Target version set to 3.0
- Affected version set to 2.4.3
- Assignee set to Vadim Pisarevsky
```
| bug,auto-transferred,priority: normal,category: highgui-gui,affected: 2.4 | low | Critical |
97,421,044 | opencv | SURF keypoints' response is inaccurate in Windows x32 Release build | Transferred from http://code.opencv.org/issues/2696
```
|| Andrey Pavlenko on 2013-01-14 09:56
|| Priority: Normal
|| Affected: 2.4.3
|| Category: nonfree
|| Tracker: Bug
|| Difficulty: None
|| PR:
|| Platform: None / None
```
## SURF keypoints' response is inaccurate in Windows x32 Release build
```
I'm adding the following accuracy test to the OpenCV:
<pre>TEST(Features2d_RotationInvariance2_Detector_SURF, regression)
{
Mat cross(100, 100, CV_8UC1, Scalar(255));
line(cross, Point(30, 50), Point(69, 50), Scalar(100), 3);
line(cross, Point(50, 30), Point(50, 69), Scalar(100), 3);
SURF surf(8000., 3, 4, true, false);
vector<KeyPoint> keypoints;
surf(cross, noArray(), keypoints);
ASSERT_EQ(keypoints.size(), 5);
ASSERT_LT( fabs(keypoints[1].response - keypoints[2].response), 1e-6);
ASSERT_LT( fabs(keypoints[1].response - keypoints[3].response), 1e-6);
ASSERT_LT( fabs(keypoints[1].response - keypoints[4].response), 1e-6);
}</pre>
It fails in Windows x32 Release build with @/O2@ compiler option, but doesn't with @/O1@ one.
It also passes on Windows x64 and Linux systems.
```
## History
##### Vadim Pisarevsky on 2013-01-22 16:17
```
- Target version deleted ()
- Affected version set to 2.4.3
```
##### Vadim Pisarevsky on 2013-01-24 17:53
```
- Assignee deleted (Maria Dimashova)
```
##### Vadim Pisarevsky on 2013-01-27 15:00
```
- Category changed from features2d to nonfree
```
##### Vadim Pisarevsky on 2013-01-27 15:02
```
- Assignee set to Vadim Pisarevsky
```
##### Kirill Kornyakov on 2013-02-14 08:11
```
- Target version set to 2.4.4
```
##### Andrey Kamaev on 2013-02-28 14:37
```
- Target version changed from 2.4.4 to 2.4.5
```
##### Andrey Kamaev on 2013-04-03 20:20
```
- Target version changed from 2.4.5 to Next Hackathon
```
| bug,auto-transferred,priority: normal,affected: 2.4,category: nonfree | low | Critical |
97,421,067 | opencv | Algorithm set/info not threadsafe | Transferred from http://code.opencv.org/issues/2697
```
|| daniel oberhoff on 2013-01-14 13:11
|| Priority: Low
|| Affected: 2.4.6 (latest release)
|| Category: core
|| Tracker: Bug
|| Difficulty:
|| PR:
|| Platform: Any / Any
```
## Algorithm set/info not threadsafe
```
Hi,
I make heavy use of threads and lazy initialization in my code. But it seems anything related to the new algorithm info infrastructure is not thread safe. And I mean not when applied on a single instance, but across a whole class. I.e. when I retreive the info simultanously for separate instances of the same class, I get a segfault. same for setting, and again, these are separate instances.
If you wish I can generate stack traces for you.
btw it would be nice, if algorithm parameters where somehow documented somewhere.
Best
```
## History
##### Marina Kolpakova on 2013-01-14 13:31
```
- Assignee set to Vadim Pisarevsky
- Category set to core
```
##### Vadim Pisarevsky on 2013-01-21 14:05
```
without a sample code it's not possible to reproduce the problem. setting Algorithm properties should be thread-safe. info() method is not completely thread-safe, the first invocation may do some initialization, but the problem should not appear in the existing OpenCV classes.
so, please, provide the sample code so that we can reproduce the problem
- Affected version set to 2.4.3
- Priority changed from Normal to Low
- Assignee changed from Vadim Pisarevsky to daniel oberhoff
```
##### Vladislav Vinogradov on 2013-09-30 07:56
```
Hello Vadim,
There is a new report with the same issue : http://code.opencv.org/issues/3292
I attached a sample code that reproduce the issue (tested on Linux with TBB).
@Algorithm::info@ is implemented in the following way:
<pre>
::cv::AlgorithmInfo* classname::info() const
{
static volatile bool initialized = false;
if( !initialized )
{
initialized = true;
memberinit;
}
return &classname##_info();
}
</pre>
There is no synchronization between threads.
So one thread can set @initialized@ variable to @true@ and go to sleep before @memberinit@, while the second thread will read @initialized@ value as @true@ and will use uninitialized struct.
- Affected version changed from 2.4.3 to 2.4.6 (latest release)
- Operating System set to Any
- HW Platform set to Any
- Assignee changed from daniel oberhoff to Vadim Pisarevsky
- File main.cpp added
```
| wontfix,auto-transferred,category: core,affected: 2.4 | low | Critical |
97,421,103 | opencv | cv::GridAdaptedFeatureDetector write of parameters not working | Transferred from http://code.opencv.org/issues/2698
```
|| Erik R on 2013-01-14 15:36
|| Priority: Normal
|| Affected: None
|| Category: features2d
|| Tracker: Bug
|| Difficulty: None
|| PR:
|| Platform: None / None
```
## cv::GridAdaptedFeatureDetector write of parameters not working
```
As the title says, its not possible for a GridAdaptedFeatureDetector to write its parameters to a file.
When using a standard detector (e.g. GFTT) "write(fs)" calls the detector's constructor, but for the gridadapted version it goes into GFTTDetector::detectImpl instead, casting an error when trying to create the grayImage.
Also, pyramid version is not working either.
Example:
<pre>
#include <opencv2\features2d\features2d.hpp>
int main ( int argc, char **argv )
{
cv::initModule_features2d(); // Not needed?
cv::Ptr<cv::FeatureDetector> feature_detector = cv::FeatureDetector::create("GridGFTT"); // goes into GFTTDetector::detectImpl instead of constructor in write method
//cv::Ptr<cv::FeatureDetector> feature_detector = cv::FeatureDetector::create("PyramidGFTT"); // not working either
//cv::Ptr<cv::FeatureDetector> feature_detector = cv::FeatureDetector::create("GFTT"); // goes into constructor in write method (works)
cv::FileStorage fs("grid_params.xml", cv::FileStorage::WRITE);
{
cv::WriteStructContext ws(fs, "params", CV_NODE_MAP);
feature_detector->write(fs);
}
fs.release();
return 0;
}
</pre>
```
## History
| bug,auto-transferred,priority: normal,category: features2d | low | Critical |
97,421,140 | opencv | cap_qtkit.mm: CvCaptureFile::CvCaptureFile does not open URL paths | Transferred from http://code.opencv.org/issues/2705
```
|| Xavier Ho on 2013-01-16 04:00
|| Priority: Low
|| Affected: None
|| Category: highgui-video
|| Tracker: Feature
|| Difficulty:
|| PR:
|| Platform: None / None
```
## cap_qtkit.mm: CvCaptureFile::CvCaptureFile does not open URL paths
```
The minimal case: Load a video stream from an Apexis IP Camera and display it on a Mac.
Example (Python):
<pre>
import cv2
capture = cv2.VideoCapture('http://192.168.1.2/...')
if not capture.isOpened():
print 'Unable to open video.'
success, image = capture.read()
while success:
cv2.imshow('Video', image)
cv.waitKey(2)
success, image = capture.read()
</pre>
We have also tried the RTSP streaming variant from the same camera, but we get the same error.
The problem: Mac's QTKit implementation assumes the filename is always a file:
It uses [QTMovie movieWithFile].
The same code works on Ubuntu 12.10 with gstreamer. It would be sensible for the Mac version to provide the same support for URL paths.
We think an alternative codepath would fix this issue. [QTMovie movieWithURL], for example.
I am happy to do a pull request if this ticket is accepted as important bug fix. Please let us know your thoughts.
```
## History
##### Xavier Ho on 2013-01-16 04:03
```
Possible related: http://code.opencv.org/issues/2474
```
##### Xavier Ho on 2013-01-16 05:35
```
I found a workaround for Macs by compiling WITH_GSTREAMER. You have to unblacklist it first, and then it works fine. See http://stackoverflow.com/questions/14350813/compile-opencv-2-4-3-rc-with-gstreamer-on-mac-os-x-10-8/14351969#14351969.
```
##### Vadim Pisarevsky on 2015-05-22 07:21
```
I would consider it as feature request, especially since you found a workaround.
- Priority changed from Normal to Low
- Tracker changed from Bug to Feature
```
| auto-transferred,feature,priority: low,category: videoio | low | Critical |
97,421,177 | opencv | Segmentation fault inside cvSetTrackbarPos | Transferred from http://code.opencv.org/issues/2706
```
|| Nikita Manovich on 2013-01-16 08:27
|| Priority: Normal
|| Affected: None
|| Category: highgui-gui
|| Tracker: Bug
|| Difficulty: None
|| PR:
|| Platform: None / None
```
## Segmentation fault inside cvSetTrackbarPos
```
I have attached an example from a book. When I tried to close the window using "X" I had segmentation fault inside cvSetTrackbarPos function from highgui module because in this case trackbar variable was NULL.
I didn't investigate the structure of the module in depth but with the attached patch I don't see the crash anymore.
```
## History
##### Marina Kolpakova on 2013-01-16 23:17
```
- Category set to highgui-gui
```
| bug,auto-transferred,priority: normal,category: highgui-gui | low | Critical |
97,421,290 | opencv | adding optional output of cost-array to stereointerfaces StereoBM and StereoSGBM | Transferred from http://code.opencv.org/issues/2708
```
|| Daniel Kapusi on 2013-01-16 11:38
|| Priority: Normal
|| Affected: None
|| Category: calibration, 3d
|| Tracker: Feature
|| Difficulty: None
|| PR:
|| Platform: None / None
```
## adding optional output of cost-array to stereointerfaces StereoBM and StereoSGBM
```
It would be nice, to have optional a quality measure for the disparity values also in the simple interfaces StereoBM and StereoSGBM.
StereoBM::operator()( InputArray _left, InputArray _right, OutputArray _disparity, int disptype )
StereoSGBM::operator ()( InputArray _left, InputArray _right, OutputArray _disp )
maybe in this way ->
StereoBM::operator()( InputArray _left, InputArray _right, OutputArray _disparity, int disptype, OutputArray _costs = noArray())
StereoSGBM::operator ()( InputArray _left, InputArray _right, OutputArray _disp, OutputArray _costs = noArray())
```
## History
| auto-transferred,priority: normal,feature,category: calib3d | low | Minor |
97,421,330 | opencv | A 3D Color Histogram Equalization Methods | Transferred from http://code.opencv.org/issues/2718
```
|| Rel Guzman Apaza on 2013-01-19 00:38
|| Priority: Normal
|| Affected: None
|| Category: imgproc, video
|| Tracker: Feature
|| Difficulty: None
|| PR:
|| Platform: None / None
```
## A 3D Color Histogram Equalization Methods
```
<pre>
It should be some functions on the library for 3D Histogram Eq.
Or is this already exists in the library?
</pre>
```
## History
| auto-transferred,priority: normal,feature,category: imgproc,category: video | low | Minor |
97,421,363 | opencv | Clean up test data | Transferred from http://code.opencv.org/issues/2722
```
|| Kirill Kornyakov on 2013-01-21 13:43
|| Priority: Normal
|| Affected: None
|| Category: infrastructure
|| Tracker: Feature
|| Difficulty: None
|| PR:
|| Platform: None / None
```
## Clean up test data
```
On a weekly OpenCV meeting we decided, that we need to clean & minimize test data. Here are tasks selected for the hackathon:
# Remove unused images and duplicated files (cascades)
# Look at large files and decide if we need the at all
# Make tests to use the same input images, i.e. stitching images can be used by feature2d tests
# Remove auto-generated images, but if only their size is large
```
## History
##### Vadim Pisarevsky on 2013-01-24 17:54
```
- Assignee deleted (Vadim Pisarevsky)
```
##### Kirill Kornyakov on 2013-02-14 08:08
```
- Target version set to 2.4.5
```
##### Andrey Kamaev on 2013-04-01 09:56
```
- Target version changed from 2.4.5 to 3.0
```
| auto-transferred,feature,priority: low,category: infrastructure,Hackathon | low | Major |
97,421,434 | opencv | Integrate gpb-ucm from https://github.com/vrabaud/gPb and add python binding | Transferred from http://code.opencv.org/issues/2728
```
|| David Miller on 2013-01-22 21:37
|| Priority: Normal
|| Affected: None
|| Category: imgproc, video
|| Tracker: Feature
|| Difficulty: None
|| PR:
|| Platform: None / None
```
## Integrate gpb-ucm from https://github.com/vrabaud/gPb and add python binding
```
Integrate gpb-ucm code from https://github.com/vrabaud/gPb and add a python binding.
```
## History
##### Maria Dimashova on 2013-01-23 13:09
```
- Category set to imgproc, video
```
| auto-transferred,feature,category: imgproc,category: video,priority: low | low | Major |
97,421,649 | opencv | Circles grid support should be added into the stereo_calib example | Transferred from http://code.opencv.org/issues/2742
```
|| Ilya Lysenkov on 2013-01-29 07:48
|| Priority: Normal
|| Affected: None
|| Category: calibration, 3d
|| Tracker: Feature
|| Difficulty: None
|| PR:
|| Platform: None / None
```
## Circles grid support should be added into the stereo_calib example
```
@stereo_calib@ example should support different patterns as @calibration@ sample does. In my experiments stereo calibration using circles grid works out of the box just by changing @findChessboardCorners@ with @findCirclesGrid@ and it gives better accuracy.
```
## History
##### Ilya Lysenkov on 2013-01-29 07:49
```
- Assignee deleted (Vadim Pisarevsky)
```
| auto-transferred,priority: normal,feature,category: calib3d | low | Minor |
97,421,708 | opencv | All zeros in SIFT descriptor | Transferred from http://code.opencv.org/issues/2745
```
|| antonio sesto on 2013-01-30 12:20
|| Priority: Low
|| Affected: 2.4.3
|| Category: nonfree
|| Tracker: Bug
|| Difficulty: None
|| PR:
|| Platform: None / None
```
## All zeros in SIFT descriptor
```
Hello,
I am using the latest stable version of OpenCV, but I am having a strange problem while using SIFT.
See attached images. Many points from the query image A are mapped onto the same point of the train image B. If I use B as query and A as train, the same happens, even if the set of keypoints changes.
The problem is due to many SIFT descriptors containing all zeros.
If the SIFT descriptor ends up in being composed by all zero, the keypoint should not be there in the first place.
```
## History
##### Vadim Pisarevsky on 2013-01-30 14:34
```
could you please supply the images and the sample code (desirably, some compact piece of code) in order to reproduce the problem. On the images I tried it don't get this problem.
- Assignee set to Vadim Pisarevsky
- Category set to nonfree
```
##### Vadim Pisarevsky on 2013-01-31 19:16
```
- Assignee changed from Vadim Pisarevsky to antonio sesto
```
##### antonio sesto on 2013-02-01 11:59
```
Hello,
you can see a description of what happens here:
http://stackoverflow.com/questions/14589595/opencv-feature-matching-with-code-from-the-tutorial
I got descriptors with all zero for every image in the folder IRELAND from the INRIA Holidays dataset. I did not try with other folders/images from the same dataset. You may find two images in attachment.
The code is taken from the tutorial:
<pre>
void full_on_line_match(const Mat& img1, const Mat& img2) {
if(! img1.data || ! img2.data) return;
Mat m1, m2;
cvtColor(img1, m1, CV_RGB2GRAY);
cvtColor(img2, m2, CV_RGB2GRAY);
// MATCHER
// FlannBasedMatcher matcher;
BFMatcher matcher(NORM_L2);
// 1 Detect keypoints
vector<KeyPoint> keypoints1_;
vector<KeyPoint> keypoints2_;
detector->detect(m1, keypoints1_);
detector->detect(m2, keypoints2_);
// 2 Compute descriptors
Mat dd1, dd2; // descriptors
extractor->compute(m1, keypoints1_, dd1);
extractor->compute(m2, keypoints2_, dd2);
// 2.1 Cleaning descriptors: remove descr. with all zero
vector<KeyPoint> keypoints1, keypoints2;
Mat d1, d2;
clean_descriptors(keypoints1_, keypoints1, dd1, d1);
clean_descriptors(keypoints2_, keypoints2, dd2, d2);
vector< vector<DMatch> > matches12;
vector< vector<DMatch> > matches21;
matcher.knnMatch( d1, d2, matches12, 2);
matcher.knnMatch( d2, d1, matches21, 2);
[...]
<pre>
- File 17001.jpg added
- File 17000.jpg added
```
##### Kirill Kornyakov on 2013-02-12 06:42
```
Vadim, should we look into it before the final 2.4.4?
```
| bug,auto-transferred,priority: low,affected: 2.4,category: nonfree | low | Critical |
97,421,758 | opencv | cv2.calcHist() not handling non uniform histogramming | Transferred from http://code.opencv.org/issues/2749
```
|| jean-philippe Andreu on 2013-01-31 10:53
|| Priority: Normal
|| Affected: None
|| Category: python bindings
|| Tracker: Feature
|| Difficulty: None
|| PR:
|| Platform: None / None
```
## cv2.calcHist() not handling non uniform histogramming
```
I tried to use cv2.calcHist() for non-uniform histograming but it reports the following error:
"OpenCV Error: Assertion failed (csz == 0 || csz == dims) in unknown function, file D:\OpenCv2.4\opencv\modules\imgproc\src\histogram.cpp, line 841"
"cv2.error: D:\OpenCv2.4\opencv\modules\imgproc\src\histogram.cpp:841: error: (-215) csz == 0 || csz == dims"
Looking at the documentation it doesn't seem to one can set the 'uniform' flag and by peeking at the C++ function (line 841 in histogram.cpp) it looks like the binding is done with the uniform version of cv::calcHist().
Would be nice to have simple feature enabled under python...
```
## History
| auto-transferred,priority: normal,feature,category: python bindings | low | Critical |
97,421,828 | opencv | Stitching module: 8UC1 images support | Transferred from http://code.opencv.org/issues/2752
```
|| Nikolay Rogoshchenkov on 2013-02-02 16:31
|| Priority: Normal
|| Affected: None
|| Category: stitching
|| Tracker: Feature
|| Difficulty: None
|| PR:
|| Platform: None / None
```
## Stitching module: 8UC1 images support
```
Please add support for 8UC1 images into the stitching module.
Now only 8UC3 images are available for stitching.
```
## History
##### Kirill Kornyakov on 2013-02-12 07:03
```
Nikolay, you can work on it by yourself, since OpenCV is open-source and you're the first one who needs such functionality =) And please do not forget to make a GitHub pull request!
Now seriously, currently stithing module is at the "maintenance" stage. That means that nobody is going to further develop it in a short-term. So, if you really need some new functionality, you'd better count on yourself...
```
| auto-transferred,priority: normal,feature,category: stitching | low | Minor |
97,421,889 | opencv | createsamples should be able to create altered sample data from multiple positive images | Transferred from http://code.opencv.org/issues/2758
```
|| Trevor Clarke on 2013-02-04 18:23
|| Priority: Normal
|| Affected: None
|| Category: objdetect
|| Tracker: Feature
|| Difficulty: None
|| PR:
|| Platform: None / None
```
## createsamples should be able to create altered sample data from multiple positive images
```
opencv_createsamples can either create randomized samples from a single positive image or generate a vector file from multiple positive samples. It seems unable to create randomized samples from multiple positive images. For example, I have 500 positive sample images. I would like 6000 positives for training. I would like to be able to create 12 randomized images from each input image by specifying -num 6000 to createsamples. If this is done now, an error will occue on sample 501 as it reads past the end of the info.dat file.
```
## History
##### Kirill Kornyakov on 2013-02-12 06:59
```
+1
Trevor, this is well-known limitiation of OpenCV training utility. And, unfortunately nobody is going to work on it...
```
##### Marina Kolpakova on 2013-04-05 23:27
```
- Assignee deleted (Marina Kolpakova)
```
| auto-transferred,priority: normal,feature,category: objdetect | low | Critical |
97,421,940 | opencv | VideoCapture crashes opening wrong IP address | Transferred from http://code.opencv.org/issues/2785
```
|| Walter Lucetti on 2013-02-08 15:09
|| Priority: Normal
|| Affected: branch 'master' (2.4.9)
|| Category: highgui-camera
|| Tracker: Bug
|| Difficulty: None
|| PR:
|| Platform: None / None
```
## VideoCapture crashes opening wrong IP address
```
Hi,
I found a problem in VideoCapture used with IP Cameras.
When i try to open a "wrong" IP (e.g. the camera is not connected to the network) the "open" function crashes instead of returning "false".
Debugging the application I noticed those fact:
- GStreamer report this error: [tcp @ 0x7a9580] TCP connection to 10.200.0.198:554 failed: No route to host
- the function crashes in file "cap_gstreamer.cpp" calling "gst_caps_unref(caps);" with a SEGMENTATION FAULT
```
## History
##### Kirill Kornyakov on 2013-02-12 06:20
```
Walter, thank you for both reports, but I have to inform you that IP camera support is a low priority for the OpenCV project... At the same time both issues are not looking as difficult ones, so if you're ready to work on a fix, that would help a lot! Please note, that better to target fixes to the '2.4' branch, and patches are accepted as GitHub pull requests.
```
##### Walter Lucetti on 2013-02-13 09:49
```
Kirill, I'm going to work at the patches because I think that it is really important that the functionality are the same for each kind of sensor we can use with OpenCV.
OpenCV is going to gain a lot of importance in videosurveillance applications and I think that a full support to IP Cameras could improve its diffusion in this field.
```
##### Kirill Kornyakov on 2013-02-14 07:48
```
Walter, actually I'm totally agree with you. In one of may past projects we had to "manually" communicate with IP camera, because OpenCV didn't provide support for them. So, this feature would be useful for many projects, and it would be great if you could help with that, while OpenCV team is cooking the next release.
- Assignee changed from Vadim Pisarevsky to Walter Lucetti
```
##### Walter Lucetti on 2013-02-15 16:47
```
Kirill, I'm almost done with the patch. How can I "commit" it when I am ready?
I saw that there are the "pull request", but I did not find instruction about how to do it.
```
##### Anna Kogan on 2013-02-18 10:52
```
Hello Walter,
Our GitHub repo is https://github.com/Itseez/opencv. If you forked you repo from it (see https://help.github.com/articles/fork-a-repo), you just push the branch with the fix in your GitHub fork (when you think it's ready to go in OpenCV). Here you will find "Pull request" button. You can get more information there: https://help.github.com/articles/using-pull-requests. OpenCV has smart pull request system: http://opencv.org/opencv-pull-requests-test-results.html, so you're welcome! =)
```
##### Anna Kogan on 2013-02-20 06:54
```
Here is a full description of contributing process: http://www.code.opencv.org/projects/opencv/wiki/How_to_contribute
```
##### Walter Lucetti on 2013-02-20 15:10
```
Thank you Anna
```
| bug,auto-transferred,priority: normal,affected: 2.4,category: videoio(camera) | low | Critical |
97,422,053 | opencv | Multiple templateMatching | Transferred from http://code.opencv.org/issues/2804
```
|| Baptiste Chinon on 2013-02-15 18:12
|| Priority: Normal
|| Affected: None
|| Category: imgproc, video
|| Tracker: Feature
|| Difficulty:
|| PR:
|| Platform: None / None
```
## Multiple templateMatching
```
The templateMatching can only work with one template to be compared with a main picture ; it would be great to update this function to provide multiple-template support, in order to increase performances in such a case. Instead of giving a single template as an input, it could be possible to provide an array of template, and a trigger in another argument ; the templateMatching function would stop and return a result once a template is found with an accuracy > trigger provided as an argument.
FFT on the main picture would be performed only once, as a matter of fact performances would be increased approximately by a factor of 2.
```
## History
##### Anna Kogan on 2013-02-18 10:43
```
Hello Baptiste,
Thank you for reporting the issue. If you could implement the feature yourself, a patch or pull request in the GitHub repo: http://opencv.org/opencv-pull-requests-test-results.html would be highly appreciated!
- Target version set to 3.0
- Priority changed from High to Normal
- Assignee set to Baptiste Chinon
- Category set to imgproc, video
```
##### Cosmin Boaca on 2014-01-31 14:22
```
Hello,
I would be glad to implement this feature, but i need some help.
1. It's about TemplateMatching from cv::cuda namespace ?
2. if Answer to 1 is Yes, then how should i handle multiple templates using InputArray parameter and how can i check the accuracy of a match ?
```
##### Vladislav Vinogradov on 2014-02-02 12:58
```
Hello Cosmin,
Your help would be highly appreciated!
In current version, @matchTemplate@ (both CPU and CUDA) returns map of comparison results, which should be passed to @minMaxLoc@:
<pre>
matchTemplate(image, templ, result, method);
minMaxLoc(result, &minVal, &maxVal, &minLoc, &maxLoc);
// final location - minLoc or maxLoc (depending on method)
</pre>
But, if I understand correctly, Baptiste suggests adding new method, which will compare input image with several templates and return the first result with an accuracy > threshold. Something like:
<pre>
void matchTemplate(InputArray image, const vector<Mat>& templs, Point& loc, int& templInd, double threshold, int method);
</pre>
```
##### Cosmin Boaca on 2014-02-06 14:35
```
Hello,
Sorry for my delayed answer, i had some exams this week.
I can't figure out how to use the existing functions, and not compute the DFT on the main image for every template. If i us the matchTemplate function with one parameter, this would compute the DFT for every template and that would be no optimization. The only solution i have in mind is like this:
I could add some Mat* imageDFT=0 parameter to the matchTemplate function, and if this parameter is not null and have the proper dimensions i can use it as the dft for the main image, otherwise i would compute it.
If you have any better idea i would like to hear it.
```
| auto-transferred,priority: normal,feature,category: imgproc,category: video | low | Major |
97,422,220 | opencv | Management of native libraries in OpenCV for Desktop Java | Transferred from http://code.opencv.org/issues/2818
```
|| Jose Gómez on 2013-02-20 19:05
|| Priority: Normal
|| Affected: None
|| Category: java bindings
|| Tracker: Feature
|| Difficulty: None
|| PR:
|| Platform: None / None
```
## Management of native libraries in OpenCV for Desktop Java
```
In Android, there is a manager that handles the installation of the native libraries corresponding to the current architecture. Is/will there be something similar in Java-Desktop?
Otherwise, a programmer that wants to support Linux/Mac/Win, will have to compile OpenCV 3 to 5 times, and include all the native libraries. Actually, the Windows distribution provides OpenCV binaries for Win32/64, but there is no repository for binary builds, so Java developers wanting to support multiple platforms have to compile the OpenCV code in all these architectures, which can be a problem if you don't have access to some OS's (like if you don't have a Mac). This is a problem also in the JavaCV wrapper.
Finally, the JavaCV author expressed a concern about the whole OpenCV for Java being exposed in a single library, not allowing the possibility of choosing only the modules that are used in the application. The size of the jars containing the jni interfaces and native libs could be greatly decreased, if only the required modules are included.
```
## History
| auto-transferred,priority: normal,feature,category: java bindings | low | Minor |
97,422,611 | opencv | core/core.hpp is not parse-able by ctags | Transferred from http://code.opencv.org/issues/2838
```
|| Luis Díaz Más on 2013-02-26 19:37
|| Priority: Low
|| Affected: None
|| Category: core
|| Tracker: Feature
|| Difficulty: None
|| PR:
|| Platform: None / None
```
## core/core.hpp is not parse-able by ctags
```
I use to use ctags for creating tags of OpenCV and make my VIM editor able to auto-complete my opencv code. I just noticed that ctags can't parse some of the main classes and structures of OpenCV version 2.4.3 (like the omnipresent cv::Mat). In version 2.4.2 ctags just works fine. I don't know if it is a problem about the OpenCV code or the ctags program
I attach the two ctags files generated by ctags with each of the commented versions.
I also note that ctags in verbose mode prints a failure message at some point of core/core.hpp file in 2.4.3 opencv version, but the description of the message doesn't give me any clue about the problem. The message is:
$PATH_OpenCV/modules/core/include/opencv2/core/core.hpp: failed to find match for '<' at line 4739
After running this command with ctags
ctags -V --totals=yes --language-force=C++ -o tags-opencv243 -R -B -I CVAPI -I CV_EXPORTS -I CV_EXPORTS_W -I CV_IN_OUT -I CV_WRAP --c++-kinds=+p --fields=+iaS --extra=+q $PATH_OpenCV/modules/core/include/opencv2/core/core.hpp
```
## History
##### Andrey Kamaev on 2013-04-03 20:45
```
- Target version changed from 2.4.5 to Next Hackathon
```
| auto-transferred,feature,priority: low,category: core | low | Critical |
97,422,899 | opencv | findCirclesGrid( ..., CALIB_CB_ASYMMETRIC_GRID ) asserts | Transferred from http://code.opencv.org/issues/2852
```
|| Tonu Samuel on 2013-03-02 07:24
|| Priority: Normal
|| Affected: 2.4.3
|| Category: calibration, 3d
|| Tracker: Bug
|| Difficulty: None
|| PR:
|| Platform: None / None
```
## findCirclesGrid( ..., CALIB_CB_ASYMMETRIC_GRID ) asserts
```
I am trying to detect asymmetric grid from image. Current code worked well until I tuned
grid size down to 4x3 and and actually show him 4x11 board. I need to wave board few times to make this happen.
All input looks valid, so I believe rest of the code is not important.
<pre>Starting program: xxx -w 4 -h 3 -i camera_data.yml -s 45
[Thread debugging using libthread_db enabled]
Using host libthread_db library "/lib/x86_64-linux-gnu/libthread_db.so.1".
VIDIOC_QUERYMENU: Invalid argument
VIDIOC_QUERYMENU: Invalid argument
VIDIOC_QUERYMENU: Invalid argument
[New Thread 0x7fffe44f7700 (LWP 2148)]
[New Thread 0x7fffe3cf6700 (LWP 2149)]
OpenCV Error: Assertion failed (h >= 2 && w >= 2) in getCornerSegments, file /tmp/buildd/ros-groovy-opencv2-2.4.3-6quantal-20130125-0325/modules/calib3d/src/circlesgrid.cpp, line 1485
terminate called after throwing an instance of 'cv::Exception'
what(): /tmp/buildd/ros-groovy-opencv2-2.4.3-6quantal-20130125-0325/modules/calib3d/src/circlesgrid.cpp:1485: error: (-215) h >= 2 && w >= 2 in function getCornerSegments
Program received signal SIGABRT, Aborted.
0x00007ffff61aa425 in raise () from /lib/x86_64-linux-gnu/libc.so.6
(gdb) bt
#0 0x00007ffff61aa425 in raise () from /lib/x86_64-linux-gnu/libc.so.6
#1 0x00007ffff61adb8b in abort () from /lib/x86_64-linux-gnu/libc.so.6
#2 0x00007ffff67a9e2d in __gnu_cxx::__verbose_terminate_handler() () from /usr/lib/x86_64-linux-gnu/libstdc++.so.6
#3 0x00007ffff67a7f26 in ?? () from /usr/lib/x86_64-linux-gnu/libstdc++.so.6
#4 0x00007ffff67a7f53 in std::terminate() () from /usr/lib/x86_64-linux-gnu/libstdc++.so.6
#5 0x00007ffff67a817e in __cxa_throw () from /usr/lib/x86_64-linux-gnu/libstdc++.so.6
#6 0x00007ffff780e141 in cv::error(cv::Exception const&) () from /opt/ros/groovy/lib/libopencv_core.so.2.4
#7 0x00007ffff7ba5916 in CirclesGridFinder::getCornerSegments(std::vector<std::vector<unsigned long, std::allocator<unsigned long> >, std::allocator<std::vector<unsigned long, std::allocator<unsigned long> > > > const&, std::vector<std::vector<CirclesGridFinder::Segment, std::allocator<CirclesGridFinder::Segment> >, std::allocator<std::vector<CirclesGridFinder::Segment, std::allocator<CirclesGridFinder::Segment> > > >&, std::vector<cv::Point_<int>, std::allocator<cv::Point_<int> > >&, std::vector<cv::Point_<int>, std::allocator<cv::Point_<int> > >&, std::vector<cv::Point_<int>, std::allocator<cv::Point_<int> > >&) const () from /opt/ros/groovy/lib/libopencv_calib3d.so.2.4
#8 0x00007ffff7ba5dcd in CirclesGridFinder::getFirstCorner(std::vector<cv::Point_<int>, std::allocator<cv::Point_<int> > >&, std::vector<cv::Point_<int>, std::allocator<cv::Point_<int> > >&, std::vector<cv::Point_<int>, std::allocator<cv::Point_<int> > >&, std::vector<cv::Point_<int>, std::allocator<cv::Point_<int> > >&) const () from /opt/ros/groovy/lib/libopencv_calib3d.so.2.4
#9 0x00007ffff7ba616e in CirclesGridFinder::getAsymmetricHoles(std::vector<cv::Point_<float>, std::allocator<cv::Point_<float> > >&) const () from /opt/ros/groovy/lib/libopencv_calib3d.so.2.4
#10 0x00007ffff7bc42d8 in cv::findCirclesGrid(cv::_InputArray const&, cv::Size_<int>, cv::_OutputArray const&, int, cv::Ptr<cv::FeatureDetector> const&) ()
from /opt/ros/groovy/lib/libopencv_calib3d.so.2.4
#11 0x0000000000407fba in main (argc=9, argv=0x7fffffffdc98) at xxx.cpp:176
(gdb) up
#1 0x00007ffff61adb8b in abort () from /lib/x86_64-linux-gnu/libc.so.6
(gdb)
#2 0x00007ffff67a9e2d in __gnu_cxx::__verbose_terminate_handler() () from /usr/lib/x86_64-linux-gnu/libstdc++.so.6
(gdb)
#3 0x00007ffff67a7f26 in ?? () from /usr/lib/x86_64-linux-gnu/libstdc++.so.6
(gdb)
#4 0x00007ffff67a7f53 in std::terminate() () from /usr/lib/x86_64-linux-gnu/libstdc++.so.6
(gdb)
#5 0x00007ffff67a817e in __cxa_throw () from /usr/lib/x86_64-linux-gnu/libstdc++.so.6
(gdb)
#6 0x00007ffff780e141 in cv::error(cv::Exception const&) () from /opt/ros/groovy/lib/libopencv_core.so.2.4
(gdb)
#7 0x00007ffff7ba5916 in CirclesGridFinder::getCornerSegments(std::vector<std::vector<unsigned long, std::allocator<unsigned long> >, std::allocator<std::vector<unsigned long, std::allocator<unsigned long> > > > const&, std::vector<std::vector<CirclesGridFinder::Segment, std::allocator<CirclesGridFinder::Segment> >, std::allocator<std::vector<CirclesGridFinder::Segment, std::allocator<CirclesGridFinder::Segment> > > >&, std::vector<cv::Point_<int>, std::allocator<cv::Point_<int> > >&, std::vector<cv::Point_<int>, std::allocator<cv::Point_<int> > >&, std::vector<cv::Point_<int>, std::allocator<cv::Point_<int> > >&) const () from /opt/ros/groovy/lib/libopencv_calib3d.so.2.4
(gdb)
#8 0x00007ffff7ba5dcd in CirclesGridFinder::getFirstCorner(std::vector<cv::Point_<int>, std::allocator<cv::Point_<int> > >&, std::vector<cv::Point_<int>, std::allocator<cv::Point_<int> > >&, std::vector<cv::Point_<int>, std::allocator<cv::Point_<int> > >&, std::vector<cv::Point_<int>, std::allocator<cv::Point_<int> > >&) const () from /opt/ros/groovy/lib/libopencv_calib3d.so.2.4
(gdb)
#9 0x00007ffff7ba616e in CirclesGridFinder::getAsymmetricHoles(std::vector<cv::Point_<float>, std::allocator<cv::Point_<float> > >&) const () from /opt/ros/groovy/lib/libopencv_calib3d.so.2.4
(gdb)
#10 0x00007ffff7bc42d8 in cv::findCirclesGrid(cv::_InputArray const&, cv::Size_<int>, cv::_OutputArray const&, int, cv::Ptr<cv::FeatureDetector> const&) ()
from /opt/ros/groovy/lib/libopencv_calib3d.so.2.4
(gdb)
#11 0x0000000000407fba in main (argc=9, argv=0x7fffffffdc98) at xxx.cpp:176
176 boardFound = findCirclesGrid( frame, boardSize, foundBoardCorners, CALIB_CB_ASYMMETRIC_GRID );
(gdb) p boardSize
$1 = {width = 4, height = 3}
(gdb) p foundBoardCorners
$2 = {<std::_Vector_base<cv::Point_<float>, std::allocator<cv::Point_<float> > >> = {
_M_impl = {<std::allocator<cv::Point_<float> >> = {<__gnu_cxx::new_allocator<cv::Point_<float> >> = {<No data fields>}, <No data fields>}, _M_start = 0x0, _M_finish = 0x0,
_M_end_of_storage = 0x0}}, <No data fields>}
(gdb) p frame
$3 = {flags = 1124024336, dims = 2, rows = 480, cols = 640,
data = 0x7fffe2fad020 "O_/O_/[LP]NRXZUWYTYUMZVNOSGMQEKQPLRQCJZIP`RTXRTXHfMGeLNhFMgE[c=emGM]SL\\RDiGChFS[SYaY[`\\Z_[WmPNdGF^WC[TA`WDcZ:iL;jMKdYJcXKa_CYWE^SHaVScYScYB^^B^^6_a5^`L^[M_\\/ac0bd<dU>fWF^VG_W<hM:fKCZOF]RE[YF\\Z\\bQZ`OT^"..., refcount = 0x7fffe308e020,
datastart = 0x7fffe2fad020 "O_/O_/[LP]NRXZUWYTYUMZVNOSGMQEKQPLRQCJZIP`RTXRTXHfMGeLNhFMgE[c=emGM]SL\\RDiGChFS[SYaY[`\\Z_[WmPNdGF^WC[TA`WDcZ:iL;jMKdYJcXKa_CYWE^SHaVScYScYB^^B^^6_a5^`L^[M_\\/ac0bd<dU>fWF^VG_W<hM:fKCZOF]RE[YF\\Z\\bQZ`OT^"..., dataend = 0x7fffe308e020 "\002", datalimit = 0x7fffe308e020 "\002", allocator = 0x0, size = {p = 0x7fffffffd5c8}, step = {p = 0x7fffffffd610, buf = {1920, 3}}}
(gdb)
</pre>
```
## History
##### Andrey Pavlenko on 2013-03-06 09:43
```
- Start date deleted (2013-03-02)
- Description changed from I am trying to detect asymmetric grid from
image. Current code worked well un... to I am trying to detect
asymmetric grid from image. Current code worked well un... More
```
##### Andrey Pavlenko on 2013-03-06 09:44
```
- Assignee set to Ilya Lysenkov
```
##### Vadim Pisarevsky on 2013-03-08 20:53
```
- Target version set to Next Hackathon
```
##### Vadim Pisarevsky on 2013-03-08 20:53
```
- Category set to calibration, 3d
```
| bug,auto-transferred,priority: normal,category: calib3d,affected: 2.4 | low | Critical |
97,423,225 | opencv | Memory Leak using BRISK FeatureDetector and DescriptorExtractor in Java | Transferred from http://code.opencv.org/issues/2873
```
|| Guilherme Juraszek on 2013-03-07 20:20
|| Priority: Normal
|| Affected: 2.4.4
|| Category: java bindings
|| Tracker: Bug
|| Difficulty: None
|| PR:
|| Platform: None / None
```
## Memory Leak using BRISK FeatureDetector and DescriptorExtractor in Java
```
Use FeatureDetector and DescriptorExtractor with BRISK implementation causes an huge memory consumption.
for(;;){
FeatureDetector featureDetector = FeatureDetector.create(FeatureDetector.BRISK);
DescriptorExtractor descriptorExtractor = DescriptorExtractor.create(DescriptorExtractor.BRISK);
featureDetector.detect(...);
descriptorExtractor.compute(...);
}
Using Sift and Surf the problem doen't occur.
PS: I'm using this inside Akka actors, so I need to initialise FeatureDetector and DescriptorExtractor multiple times. I can't initialise once and use it for multiple images.
```
## History
##### Vladislav Vinogradov on 2013-04-01 09:13
```
- Assignee set to Andrey Pavlenko
- Category set to java bindings
```
| bug,auto-transferred,priority: normal,affected: 2.4,category: java bindings | low | Critical |
Subsets and Splits