awknaust's profile - activity

Think about the globe and 2D maps, a perfect projection is not possible

You'd have to do it by hand. You make a 2D filter which you slide across the image so that each pixel becomes 0 if it is not the maximum in the neighborhood and retains its value otherwise.

What is the problem exactly?

It almost certainly does, why not try it out?

It is probably the video encoding that is so expensive, this takes time even for high end PCs. Try using a different codec, or just write raw images and process them later

I would recommend linux just because it tends to be more flexible in what software you can use and how you can configure the OS. Theres probably distros designed to use low resources and low-power, but if you are beginners I would recommend something like debian or ubuntu. Perhaps starting with a headless installation and then adding a lightweight GUI like XFCE.

Train a new classifier to detect closed eyes and then vote between them. Or retrain the classifier to detect open AND closed eyes, and then train another to decide whether the eye is open or closed.

I'm not sure about android, but OpenCV provides a FileStorage class that allows you to write matrices to text files as XML or YAML. That is usually sufficient. If your Mat can reasonably be represented as an image, you can just save them to pngs as well

Yes so if you wanted to create a sub-matrix you would use that, not create(). By saying create() you are telling it that you no longer care about the rest of the data, so why would OpenCV keep it around? When you have a ROI, it doesn't rule out that you might still be interested in the original.

What exactly is the error? did you use the example code they give in the documentation?

That function isn't part of the OpenCV API I don't think. It is only used internally. If you really want to use it, you can just copy it from the source code (imgproc/src/precomp.hpp)and probably rename it/put it in a different namespace

You are mixing the OpenCV C API (CvMat*) and OpenCV C++ (Mat), something you do not really want to do, at least not like this. If you want to create an image with a 1pixel extra border, its easy theres even a function to do it directly

It will reallocate unless the size is identical. It would be hard to keep track of the data otherwise.

Short answer : Matlab probably isn't doing what you want. If you look at the documentation for imfilter, it defaults to using a 0-padded border which is nonsense in most scenarios. You can specify the border type to filter2D in OpenCV by passing the last argument, borderType. BORDER_DEFAULT is BORDER_WRAP_101 (which you can read about in the documentation)

Long answer is you do this:

Point anchor( 0 ,0 );
double delta = 0;

float data[2][5] = {{11,11,11,11,11},{11,11,11,11,11}};
float kernel[2][2] = {{2,2},{2,2}};

Mat src = Mat(2, 5, CV_32FC1, &data);
Mat ker = Mat(2, 2, CV_32FC1, &kernel);
Mat dst = Mat(src.size(), src.type());

Ptr<FilterEngine> fe =  createLinearFilter(src.type(), ker.type(), ker, anchor,
        delta, BORDER_CONSTANT, BORDER_CONSTANT, Scalar(0));
fe->apply(src, dst);
cout << dst << endl;

The problem is you can pass BORDER_CONSTANT to filter2D, but it doesnt take the value the constant should be, So instead you have to create a FilterEngine object. Additionally, Matlab anchors its kernel in the top-left corner, unlike the OpenCV's default, in the center

Download the source, i.e. from http://opencv.org/downloads.html

Are you trying to do a Release build with the debug libraries (they have 'd' at the end of them)?

Have you checked whether /usr/local/lib is under the apache user's PATH?

OpenCV is open source, you could just look at/modify the source code!

According to the documentation, what you should be doing is

Moments m = moments(imgThreshold, true);

In C++ calling new allocates memory for an object and returns a pointer to that object, i.e. the line

m = new Moments();

implies that m's type is "Moments*" not "Moments"

Also to get the moment values, you just get them from the resulting object directly.. m.m00, m.m01 etc.

Probably the right way to do this is to somehow access the cameras internal parameters. Other than that, if you can make all 3 cameras point at the same location you could take several sets of 3 identical images and use that to try to train the contrast/brightness adjustments of each, which you can correct when you take new images. This is assuming that the three cameras always have the same relative brightness offsets from one another.

On the other hand, perhaps decomposing the images into HSV and equalizing the mean Value for each image could be an approach. Although this certainly has some drawbacks.

Looking at research into image stitching might also help, I'm sure you aren't the only one with this problem

Follow the steps described here

Basically the MSVC doesn't like that OpenCV is using fopen, but unless you want to edit OpenCV the only option is to tell MSVC to ignore this problem. The quick fix is to add

#define _CRT_SECURE_NO_WARNINGS

Before you include the opencv header. Alternately you can change this in your project settings.

It would be better if you could run it with a debugger and print the whole traceback of the error. Also indentation would make this much more readable...

You are correct, its because java bytes are thought of as signed, whereas in the image they are unsigned, in [0, 255]

perhaps the best course is to read the research papers on these descriptors or to find a paper that compares the three.

You probably need to add opencv_core249.dll to your system Path. This means locating it in your OpenCV install and adding that entire directory to your PATH variable in Windows->Advanced Settings.

This is the last step in the installation tutorial

setmouseCallback only registers a handler for the window. It doesn't actually call mouse_ev itself. Instead when you click on a point, opencv will call 'mouse_ev' with the event type and the coordinates of the point that was clicked on.

The last argument void* allows you to pass additional arguments to the mouse_ev function when it is called, but it isn't clear from your code how that is happening.

I try the following code in C++ using OpenCV 2.42 and it fails when attempting to copy the svm

include <opencv2/opencv.hpp>
using namespace cv;

int main(int argc, char *argv[]){

    Mat trainData(100, 3, CV_32F);
    randu(trainData, 0.0f, 10.f);

    Mat classes = Mat::zeros(100, 1, CV_32F);
    for(int i = 50; i < classes.rows; i++)
        classes.at<float>(i) = 1.0f;

    Mat sample = Mat::ones(1, 3, CV_32F);

    SVM svm;
    svm.train_auto(trainData, classes, Mat(), Mat(), SVMParams(), 2);

    SVM svm2 = SVM(svm);
}

and gives the message (VS2010 Windows XP)

OpenCV Error: Assertion failed (udata < (uchar*)ptr && ((uchar*)ptr - udata) <=
(ptrdiff_t)(sizeof(void*)+16)) in unknown function, file ..\..\..\src\opencv\mod
ules\core\src\alloc.cpp, line 78

Is this a bug, or is there something I am missing about copying an SVM? I expected it to copy the decision function, support vectors, and other parameters, but something seems to be going wrong. I had a look at the source in ml.hpp and it doesn't seem to define a copy constructor.

You can specify UPDATE_WEIGHTS when training a Neural Network in OpenCV to update them instead of completely recompute them

The Library needs to be somewhere on your system path, or in the path of the program. Putting it in the directory with the OpenCV binaries works because you already added that to your PATH variable. You can either move it to a separate folder and add that to your PATH, add it to a directory already in PATH, or add it to the Project folder itself.

This really sounds like you missed some step of the installation process (the one where you tell your project about *.lib ). Did you read this tutorial? I suggest re-reading it making sure you have followed all steps closely

It looks like you are doing exactly what cv::accumulate does as mentioned in your last question

If you look at the documentation, the Output Array has to be a CV_32F or CV_64F, but the inputs can be 8bit or 16 bit.