OpenCV | The OpenCV Java project for Android | Android library

according to wikipedia it's [[1, 0, -1],[2, 0, -2],[1, 0, 1]] but according to other sources it's [[-1, 0, 1],[-2, 0, 2],[-1, 0, 1]]

Both are used for detecting vertical edges. Difference here is how these kernels mark "left" and "right" edges.

For simplicity sake lets consider 1D example, and let array be

[0, 0, 255, 255, 255]

then if we calculate using padding then

• kernel [2, 0, -2] gives [0, -510, -510, 0, 0]
• kernel [-2, 0, 2] gives [0, 510, 510, 0, 0]

As you can see abrupt increase in value was marked with negative values by first kernel and positive values by second. Note that is is relevant only if you need to discriminate left vs right edges, when you want just to find vertical edges, you might use any of these 2 aboves and then get absolute value.

The issue is due to the intruduction of namespace, indeed you can get a similar issue with this code:

I'm going by what I remember from the last time I investigated this. Grain of salt and all that.

the fixed point format splits the integer and fractional parts of your (x,y)-coordinates into different maps.

it's "compact" in that CV_32FC2 or 2x CV_32FC1 uses 8 bytes per pixel, while CV_16SC2 + CV_16UC1 uses 6 bytes per pixel. also it's integer-only, so using it can free up floating point compute resources for other work.

the integer parts go into the first map, which is 2-channel. no surprises there.

the fractional parts are converted to 5-bit integers, i.e. they're multiplied by 32. then they're packed together, lowest 5 bits from one coordinate, higher next 5 bits from the other one.

the resulting funny number has a range of 0 .. 1023, or 0b00000_00000 .. 0b11111_11111, which encodes fractional parts (0.0, 0.0) and (0.96875, 0.96875) respectively (that's 31/32).

during remap...

the integer map is used to look up, for every resulting pixel, several pixels in the source image required for interpolation.

the fractional map is taken as an index into an "interpolation table", which is internal to OpenCV. it contains whatever factors and shifts required to correctly blend the several sampled pixels into one resulting pixel, all using integer math. I guess there are multiple tables, one for each interpolation method (linear, cubic, ...).

As a first solution I'd recommend maximizing the distance between the image of the line at infinity and the center of your picture.

Identify at least two pairs of lines that are parallel in the original image. Intersect the lines of each pair and connect the resulting points. Best do all of this in homogeneous coordinates so you won't have to worry about lines being still parallel in the transformed version. Compute the distance between the center of the image and that line, possibly taking the resolution of the image into account somehow to make the result invariant to resampling. The result will be infinity for an image obtained from a pure affine transformation. So the larger that value the closer you are to the affine scenario.

As pointed out in the comments, for the code you have shown, you are getting a warning and this warning can be safely ignored.

For usage in CUDA device code:

For a C++ class to be usable in CUDA device code, any relevant member functions that will be used explicitly or implicitly in CUDA device code, must be marked with the __device__ decorator. (There are a few exceptions e.g. for defaulted constructors which don't apply here.)

The OpenCV class you are attempting to use (cv::KeyPoint), doesn't meet these requirements for use in device code. It won't be usable as-is.

There may be a few options:

1. Recast your work using cv::KeyPoint to use some class that provides similar functionality, that you write yourself, in such a way as to be properly designed and decorated.

2. Perhaps see if OpenCV built with CUDA has an alternate version here (properly designed/decorated) (my guess would be it probably doesn't)

3. Rewrite OpenCV itself, taking into account all necessary design changes to allow the cv::KeyPoint class to be usable in device code.

4. As a variant of suggestion 1, copy the relevant data .response to a separate set of classes or just a bare array, and do your selection work based on that. The selection work done there can be used to "filter" the original array.

images in opencv should only have 2 dim if grayscale/single channel or 3 dim if color. you seem to have a gray/single channel image [192,640] thats wrapped in 2 lists [1,1,---]

so to get the image you need to get it from inside those 2 lists.

img = np.load(filepath)[0][0]

or if you are not sure how many lists its wrapped in, you can do

img = np.squeeze(np.load(filepath)

but that will work as long as there is only 1 image in those lists

It is an unwanted and unnecessary dimension, you can eliminate the dimension by using the squeeze function of numpy:

Go to the main section of the GitHub repository: https://github.com/codingforentrepreneurs/OpenCV-Python-Series

1. Press the code button and then download as zip.
2. Unzip the file in your downloads.
3. Navigate to src/recognisers and the file face-trainner.yml should be there.
4. Use that file how you want in your project (discard of the rest if you have no need for it).

Also make sure that you have typed the correct file name in your program with the two 'n's (face-trainner.yml not face-trainer.yml)

matPrevGray is empty. that's what it's saying.