wl2776's profile - activity

I've never used Hu moments in my practice, however, Wikipedia says that they are weighted averages of image pixels. So, for each moment, you supply an image to a function and it returns you a single value, depending on all image pixels. Therefore, probably, they can detect that pictures differ, while you seem to be interested in locations of those differences. Answering this your question - unlikely.

I'd suggest warping images to the common coordinate system and then subtract warped results. You could detect 2D feature points with any 2D feature detector, for example, Harris corners, or BRISK, or SIFT, then calculate a homography matrix and then use it to transform one of images to the coordinate system of another.

Also, it would be useful to apply some filtering and morphology to make robust comparisons.

Upgrade OpenCV? Version 2.4.10 contains another check in solvePnPRansac

CV_Assert(opoints.depth() == CV_32F || opoints.depth() == CV_64F);

So does the latest git snapshot: https://github.com/Itseez/opencv/blob...

You can download FFmpeg binaries from here.

Agree with @StevenPuttemans about licensing.

No.

Cmake is to generate build system and compile OpenCV from sources

There is a commit in the master branch, disposing the whole ocl module to trash.

Am I correct in thinking that version 3.0 will have embedded automatically activating support of OpenCL?

Hi all! Is it possible to run StereoSGBM disparity estimation on the trunk OpenCV (3.0.0) with OpenCL? I am trying to recover depth from the stereocamera.

I am using OpenCV 3.0.0 from the trunk. Currently my application, running StereoSGBM algorithm, processes one video frame 640x480 for about 1-2 seconds.

Version 2.4.8 of the OpenCV has the separate module OCL, which includes this. It could be concluded that the version 3.0 can automatically turn on OpenCL support. Is it the case?

Here is the relevant part of the buildInformation string:

Version control:               721d014-dirty
Platform:
    Host:                        Windows 6.1 AMD64
    CMake:                       2.8.12.2
    CMake generator:             Visual Studio 12
    CMake build tool:            C:/PROGRA~2/MSBuild/12.0/Bin/MSBuild.exe
    MSVC:                        1800 
Other third-party libraries:
    Use IPP:                     NO
    Use Eigen:                   YES (ver 3.2.0)
    Use TBB:                     YES (ver 4.2 interface 7002)
    Use OpenMP:                  NO
    Use GCD                      NO
    Use Concurrency              NO
    Use C=:                      NO
    Use Cuda:                    NO
    Use OpenCL:                  YES

OpenCL:
    Version:                     dynamic
    Include path:                C:/opencv/master/3rdparty/include/opencl/1.2
    Use AMDFFT:                  NO
    Use AMDBLAS:                 NO

Wrong usage of VLD. Include it into your cpp or header file,after stdafx or any other precompiled headers. http://vld.codeplex.com/wikipage?title=Using%20Visual%20Leak%20Detector&referringTitle=Documentation

Your includes look strange to me. Try to remove all C includes (starting with opencv/ ).

Also, try using Visual Leak Detector (http://vld.codeplex.com/) to get more sensible information about memory leaks.

Hi all. Do prebuilt binaries of the version 2.4.3 for windows use TBB and Eigen?

I've searched for TBB and parallel_for through files. Search for "parallel_for" has revealed several entries.

Search for TBB has brought to me files C:\opencv\build\x64\vc10\bin\opencv_core243.dll and C:\opencv\build\x64\vc10\bin\opencv_core243d.dll

These binary files contain the following text:

....
Use TBB:            NO
Use Eigen:          NO
....

Overall, this part of the hexdump looks like a compiled in CMake configuration. However, I didn't find a function which would print it.

So, 2 questions.

1. Is the TBB and Eigen support switched on by default?

2. Is there any function, which can print building parameters?

Thanks

Hi all.

I have two matrices of the same size (1 x ncols, vectors actually) and I need

• one of them sorted in descending order
• another one reordered according to the first one.

What is the most optimal method to do that?

cv::sortIdx() function gives me correct ordering, but I cannot figure out, how to use it for this task.

After some experiments, I've found that C++ API can also do this. I've corrected my answer

I've found the solution. Old C functions cvStartWriteStruct and cvEndWriteStruct can do the job.

#include <opencv2/core/core_c.h>
...
Mat matrix;
FeatureDetector detector;
DescriptorExtractor extractor;

/* fill matrix, detector and extractor*/

FileStorage fs(file_name, FileStorage::WRITE);
cvStartWriteStruct(*fs, "detector", CV_NODE_MAP);
detector.write(fs);
cvEndWriteStruct(*fs);
fs << "matrix" << matrix;

This produces the following.

<opencv_storage>
<detector>
<name>Feature2D.ORB</name>
<WTA_K>2</WTA_K>
....
<scoreType>0</scoreType></detector>
<matrix type_id="opencv-matrix">
<rows>500</rows>
<cols>64</cols>
<dt>u</dt>
<data>
  1 96 0 0 140 191 127 60 28 0 0 0 72 240 249 79 55 8 32 128 99 28 199
  ...

The reading code then would become

FileNode fn = fs["detector"];
if (!fn.empty()) {
    string name = fn["name"];
    ORB det;
    det.read(fn);
}

UPDATE. C++ API can also do this. Same result can be achieved with

fs << "detector" << "{";
detector.write(fs);
fs << "}";

Hi all. I've got a matrix cv::Mat, keypoint detector and descriptor extractor objects. And I want to save all of them to the single file using cv::FileStorage. Is it possible?

I tried

Mat matrix;
FeatureDetector detector;
DescriptorExtractor extractor;

/* fill matrix, detector and extractor*/

FileStorage fs(file_name, FileStorage::WRITE);
fs << "matrix" << matrix;
detector.write(fs);
extractor.write(fs);

This code writes everything to the file.

But the resulting file is invalid, since it contains two pairs of <name> </name> tags, and the code, reading data from disk, throws the exception "Duplicated key".

Here is the example of what I've got

<opencv_storage>
<name>Feature2D.ORB</name>
<WTA_K>2</WTA_K>
....  (other saved ORB parameters are skipped for brevity)
<name>Feature2D.BRISK</name>
<octaves>3</octaves>
<thres>30</thres>
<matrix type_id="opencv-matrix">
   <rows>500</rows>
   <cols>64</cols>
   <dt>u</dt>
   <data>
1 96 0 0 140 191 127 60 28 0 0 0 72 240 249 79 55 8 32 128 99 28 199
48 28 31 12 24 192 128 0 102 24 115 254 255 255 157 113 134 25 34 0
0 0 24 134 96 182 255 255 255 163 64 254 255 219 4 2 0 0 0 96 196 3
...

One possible solution could be wrapping the detector and extractor with custom tags, like

<opencv_storage>
<detector>
<name>Feature2D.ORB</name>
<WTA_K>2</WTA_K>
....
</detector>
<extractor>
<name>Feature2D.BRISK</name>
<octaves>3</octaves>
<thres>30</thres>
</extractor>
... (the rest of file)

Is it possible with FileStorage? I tried

fs << "detector";
detector.write(fs);

However, this code throws the exception "no element was given".

I don't have OpenCV libraries in PATH. Instead I add needed path in the project settings (Debugging -> Environment), and have menu items in Far Manager, which add needed path to the current session.

What for your case, the DLL name immediately suggests that we have DLL hell curse. Numbers 90 in the name define MSVC version (9.0 is Visual Studio 2008, 10.0 is VS 2010). I recommend you to carefully inspect your PATH variable and clean everything unneeded.

That's a pity that there is no such thing as modules (http://modules.sourceforge.net) in windows.

Looks like a bug. Report, of course.

According to reference manual (opencv2refman.pdf, page 35), values like CV_8U or CV_8S, or CV_16U, etc, are returned from Mat::depth().

Mat::type() returns a constant, having number of channels, like CV_8UC3

Suppose I create EM object, train it and then change its "nclusters" property. In my understanding, this should reset it to the untrained state, since the sizes of means and covs do not longer correspond to the number of clusters.

However, isTrained() returns true.

Is is a bug or feature?

Yes, this looks like a bug. isTrained is implemented as

return !means.empty();

So, the application should itself keep track on what is trained and what is not.

Also, cv::Algorithm's implementation of property storage lists and getters/setters doesn't have any means for object invalidation. The AlgorithmInfo::set() methods simply change values, but do not track the object logical consistency.