Missing's profile - activity

I think you can't do that just with approxPolyDP(). Instead you could use some circularity attributes (inertia ratio), take a look at this article. Another option would be to use scikit-image, which provides an elliptical hough transform, see here.

You should be more specific with your question, how should anyone know what exactly you are trying to do? Nevertheless this often happens because of incompatibilities between 32 bit and 64 bit. So you could check if all your DLL's are either 32 or 64 bit.

What do you mean by "in case there is no signal"? The hough transform already provides you with the radii of the circles.

To my knowledge you can't. You have to recompile opencv with the contrib_modules.

That is not really a problem for a SVM. To train a SVM you need features. This means you need to extract some information about the image. In your scenario such a feature would be the color of the car. And since you need to get the color of the car you don't need a SVM anymore. What is your solution to find the car in the image?

You can use the numpy.where() method to do that. Here is a minimal example:

import numpy as np

zeros = np.zeros((100, 100), dtype=np.uint8)
zeros[:5,:5] = 255

indices = np.where(zeros == [255])
print indices
coordinates = zip(indices[0], indices[1])
print coordinates

So here you see a 100x100 pixel black image where a little square in the upper left is set to white. By using the numpy.where() method I retrieved a tuple of two array (indices) where the first array contains the x-coordinates of the white points and the second array contains the y-coordinates of the white pixels. By using the zip() method you can get a list of tuples containing the points. You can convert this list to a numpy array by calling the numpy.asarray() function.

Best Regards

Where exactly is your problem in getting the convex hull points? The OpenCV function convexHull() will give you an array of the points. Have a look at the documentation: Documentation

The channels of your two images do not match. So you are trying to copy a bgr image to a grayscale image or something like that. Check the types of your images.

BFMatcher needs keypoint descriptors to work. The goodFeaturesToTrack function only gives you strong corners, but no descriptors.

I dont't think that this is an OpenCV problem. It is more likely a hardware problem. USB webcams tend to use as much usb bandwidth as possible. So if your two cameras are connected to the same usb bus, the first webcam will take all the bandwidth and there is no space left for the second webcam. Maybe you could use two different usb hosts to connect both webcams.

OpenCV is released under a BSD licence. This means that it is free to use for academical and commercial use. The modules in the opencv_contrib package are not free for commercial use (algorithms like SIFT, SURF).

Best Regards Missing

I don't know how to check if your contour is a rectangle since the contour is not good. What are these noisy lines at the top left corner? You have to get a clean contour of the paper sheet to determine the shape of it.

Hmm for me your code works fine. Maybe your cap.read() returns False for ret . This would break your while-loop and end the program. You could try to change the break in your else-path to pass

You can check the shape by using approxPolyDP(). This functions approximates a polygonal curve of the contour. This meens you get four points if the contour is a rectangle, three points if it is a triangle and so on. But this will not work for your image, because your contour does not fit the paper sheet correctly. You need to get the contour right like in my example above.

So i wrote some Python code to get the contour of the paper sheet.

import numpy as np
import cv2

# Original image
image = cv2.imread('images/sheet.jpg')
# Resize
image = cv2.resize(image, (500,500))
draw = np.zeros_like(image)
# Convert to grayscale
gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
# Get black and white image
ret, thresh = cv2.threshold(gray, 127, 255, cv2.THRESH_BINARY)
kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (3,3))

# Some erosions and dilations to remove noise.
thresh = cv2.erode(thresh, kernel, iterations=4)
thresh = cv2.dilate(thresh, kernel, iterations=4)

# Get Contours of binary image
im, cnts, hier = cv2.findContours(thresh, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)

# Find the biggest contour
max_area = -1
max_c = 0
for i in range(len(cnts)):
    contour = cnts[i]
    area = cv2.contourArea(contour)
    if (area > max_area):
        max_area = area
        max_c = i
contour = cnts[max_c]

# Get minAreaRect
rect = cv2.minAreaRect(contour)
box = cv2.boxPoints(rect)
box = np.int0(box)


# Draw contour and minAreaRect
cv2.drawContours(image, [box],-1, (0, 255, 0), 2)
cv2.drawContours(image, [contour], -1, (255,0,0), 2)
cv2.imshow('Sheet', image)

cv2.waitKey(0)
cv2.destroyAllWindows()

After that the image looks like this (blue is the contour and green is the rectangle around the contour:

No your image named "gray"...This is the black and white image you use to calculate the contours. This image should just contain the white paper sheet.

Could you post your image that you use findContours() on? Your contour follows along the border of the image and not the paper sheet. Seems yout threshold is not good enough.

Simply iterate over your contours and retrieve the contour area by calling contourAea(contour) and store the biggest one. With minAreaRect()you get the rotated rectangle for that contour. If you want to extract that rectangle take a look at that question here: http://answers.opencv.org/question/49...

You already calculated the contours of your image. The paper sheet should be the biggest contour. So find the biggest contour in your image and you get your paper sheet. With minAreaRect() you can calculate a rotated rectangle around that contour.

In OpenCV 2.4 the SURF and SIFT algorithms moved to nonfree folder. Use this instead:

#include <opencv2/nonfree/features2d.hpp>

Since you can't compile the opencv_contrib modules alone, you have to re-compile the opencv core modules with the above mentioned option. You can read about the steps in the README of the repository.

What exactly do you want to compare? The Fourier Transform is used to find the frequency domain of an image and template matching is used to find the location of a template in a larger image, these are different topics.

Okay my fault. The problem here is that the call to numpy.all() tests whether the condition is true for the whole array, meaning it checks if every pixel in an image row is black and that is obviously not true in your case. So try it without the numpy.all() function. Just use

black_mask[np.where(black_mask == [0])] = [255]

Hey, yes because your original image is in RGB color format. The masked image is just black and white, so you just have one color channel. Change your code to:

black_mask[np.where((black_mask == [0]).all(axis = 1))] = [255]

Your first attemp should work correctly. Did you import numpy correctly as np? Do you use your image or the image i created with np.zeros?

import cv2
import numpy as np

    image = np.zeros((400,400,3), dtype="uint8")
    raw = image.copy()
    image[np.where((image==[0,0,0]).all(axis=2))] = [255,255,255]
    cv2.imshow('Test', image)
    cv2.imshow('Test2', raw)
    if cv2.waitKey() == ord('q'):
        cv2.destroyAllWindows()

This is the complete code for the example and it turns a black image into a white one.

You can simply use numpy to do this.

image = np.zeros((400,400,3), dtype="uint8")
image[np.where((image==[0,0,0]).all(axis=2))] = [255,255,255]

This will change all pixels in image that have a value of [0,0,0] to [255,255,255].

After your inRange() operation you get an image in black and white, so you have just one color channel. In that case you have to use:

image[np.where((image==[0]).all(axis=1))] = [255]

This will change all rows in your image that are completely black to white. To change not only the rows that are completely black omit the call to numpy.all(). Use:

image[np.where(image == [0])] = [255]

Best regards

The methods for face recognition were moved to the opencv_contrib repository at https://github.com/Itseez/opencv_contrib

You need to compile OpenCV with

cmake -DOPENCV_EXTRA_MODULES_PATH=<opencv_contrib>/modules <opencv_source_directory>

and then you can use Eigenfaces, Fisherfaces and LBPH.

Best regards

I think the answer to this question will solve your problem: http://answers.opencv.org/question/49...

I just added the two rectangles for demo purposes. If you have the edges in your images it will also work, provided that your input image to findContours() is in grayscale and your rectangles are represented white on black background. The code returns the top left and bottom right coordinates of the rectangle you clicked. You easily can compute the dimension of it from hat.

You could use findContours() to get the contours of your rectangles. If you click somewhere in your image you get the coordinates of the click. With pointPolygonTest() you now can check if you clicked inside one of the contours.

import cv2
import numpy as np

contours = None

def callback(event, x, y, flags, param):
    global contours
    if (event == cv2.EVENT_LBUTTONDOWN):
        for cnt in contours:
            res = cv2.pointPolygonTest(cnt, (x,y), True)
            if (res > 0):
                x,y,w,h = cv2.boundingRect(cnt)
                print (x,y), (x+w-1,y+h-1)


cv2.namedWindow('test')
cv2.setMouseCallback('test', callback)
image = np.zeros((400, 400, 3), np.uint8)
cv2.rectangle(image, (10, 10), (100, 100), (255,255,255), 1)
cv2.rectangle(image, (200, 200), (300, 300), (255,255,255), 1)

gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
cnts, contours, hierarchy = cv2.findContours(gray, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)

cv2.imshow('test', image)
if cv2.waitKey() == ord('1'):
    cv2.destroyAllWindows()

This might be not the best solution, since you check for every contour, but it will work. Best regards

Please make clear what you want to achieve! The dimensions of a box drawn on an image or what?

You could try to set CV_CAP_PROP_CONVERT_RGB property of your camera to false. However this not seems to work everytime, but maybe it will work for you.

Template matching returns a grayscale image where each pixel denotes how much the neighbourhood of that pixel matches with the template. With minMaxLoc() you get the point with the best match. You now could simply check this maximum point and if it is below a certain value (you specif this value) you throw an exception. I never used template matching on my own, so this is just an idea to solve this your issue.

There are some examples for that on the web. I did not try it on my own, but maybe this will work for you: https://gist.github.com/thearn/5562029

Do you use the Template Matching Function in OpenCV or another algorithm? I'm not very familiar with it, but if i'm right you get a matrix back which indicates where the highest matches were detected. So maybe you could use a threshold value for the detected maximum matching value.