mtourne's profile - activity

I feel like you're not really answering the question.

Hello,

I'm using the sample code for latentsvm detector [1]. It's from opencv 2.4, this sample code actually seems to be gone in the master branch (?)

I'm using what seems to a be a pretrained model on VOC2007 [2], I'm only using the cars.xml model not all of them.

Here is the output of running the car detector on a picture of a cat : https://i.imgur.com/IltJIsC.png

It did an ok job at finding cars : https://i.imgur.com/5dbUTxf.png

But then again, everything appears to be a car ..

[1] https://github.com/Itseez/opencv/blob...

[2] https://github.com/Itseez/opencv_extr...

added a code snippet, not sure it conveys more than the text though

Hi,

I've created a class Image which is a wrapper over a Mat (the actual data), plus some keypoints, descriptors, camera intrinsic matrix, etc .. I have an Image::ptr which is a shared_ptr<image>

I have vectors of Image::ptr, pairs of Image::ptr. Everybody is sharing, everything is great!

Up until I serialize // deserialize them using FileStorage.

Not surprisingly the serialized file contains a copy of the data, in every place I've used an Image::ptr. The more problematic thing, is that if I de-serialize I now have a copy of my Image everytime it appeared in a vector. (I don't serialize the actual pixels, just descriptors but still).

The question is, Is there a way to deal with smart / auto ptr to avoid redundancy when serializing ?

Otherwise, I'm considering using a global variable holding a map<index,image::ptr> and then replace Image::ptr with index everywhere. Or is there a simpler cleaner way that I haven't seen ?

Thank you!

EDIT: adding code snippet

class Image {
  typedef shared_ptr<Image> ptr;

  Mat data;
  vector<Keypoint> Keypoints;
  Mat descriptors;
}

Image::ptr img1 (new Image());
Image::ptr img2 (new Image());

pair<Image::ptr, Image::ptr>> image_matches1;
pair<Image::ptr, Image::ptr>> image_matches2;

// note that it's the same pair
image_matches1 = make_pair(img1, im2);
image_matches2 = make_pair(img2, im1);

// prints out the same pointer, which makes sense
cout << image_matches1.first() << endl;
cout << image_matches2.second() << endl;

// serialization
FileStorage fsb("filestorage_pairs.txt", FileStorage::WRITE);
 fsb << "pair1" << img_matches1;
 fsb << "pair2" << img_matches2;
 fsb.release();

// de-serialization
fsb.open("filestorage_pairs.txt", FileStorage::READ);

ImagePair pair1_loaded;
ImagePair pair2_loaded;

 fsb["pair1"] >> pair1_loaded;
 fsb["pair2"] >> pair2_loaded;

// now the pointers are different, through serializaion / deserialization the resource has been copied
cout << pair1_loaded.first() << end;
cout << pair2_loaded.second() << end;

My next idea was to apply a distance transform on the masked version, then threshold to get a local max. This should get me a patch towards the center of the texture. I imagine the distance transform is more expensive ?

Hi,

I'm processing a still image in order to find where the water is. (see my other question here)

Now, I can find all the rather large polygons in the image, using approxPolyDP. But there is no guarantee that the water is the dominant part of the image.

In case I have a few large-ish polygons (> 5%) of the image), I'd like to find a small patch that fits in my polygon and test its texture using one of the classic statistical texture methods (local binary pattern, laws, gabor filters).

But I'm not sure how to find a small square that fits inside the polygon. The only thing I can think of is to use the center of gravity, and create a small box around it. But in the case of a complicated shape, the center of gravity might not be in the shape itself.

Here is an example where finding a small square patch in the polygon that I have outlined seems potentially tricky:

Original image:

Outline of the water (one of the large polygons), where I'd like to define a square patch :

I finally ended up inverting the edges found with the canny procedure and applying findContours on that, to cut on the number of steps. It roughly looks like that :

edge = cv2.Canny(img_gray, CANNY_THRSH_LOW, CANNY_THRSH_HIGH, apertureSize=5)
kern = np.ones((5, 5))
# dilatation connects most of the disparate edges
edge = cv2.dilate(edge, kern)
# invert edges to create one big water blob
edge_inv = np.zeros((img_gray.shape), np.uint8)
edge_inv.fill(255)
edge_inv = edge_inv - edge
contours0, hierarchy0 = cv2.findContours(edge_inv.copy(), cv2.RETR_EXTERNAL,
                                         cv2.CHAIN_APPROX_SIMPLE)

That makes sense, thank you!

Did you use a trackbar to change the value for the threshold in practice ? I can't seem to replicate your result using the value "10" for the threshold

Hi,

In the context of flying over water, I'm trying to segment the coastline out of the water.

To do that I've been using a Canny edge detection, which I'm hoping to use to create several large polygons : Each polygon should be contain either: the coastline, the body of water, or some other occlusion

My problem is that I can't find a way to connect a line to the "borders of the image" and make a polygon that way.

What I currently have produces this image : On the top left, and the right is a coastline (flying over a bay), and the bottom part is the UAV itself with the antenna.

This is almost what I need, but I need to create a polygon that extends all the way to the borders.

This is the code :

def find_coastline(img_gray, img_rgb):
    CANNY_THRSH_LOW = 1000
    CANNY_THRSH_HIGH = 2000
    # add borders for polygons
    edge = cv2.Canny(img_gray, CANNY_THRSH_LOW, CANNY_THRSH_HIGH, apertureSize=5)
    kern = np.ones((5, 5))
    # dilatation connects most of the disparate edges
    edge = cv2.dilate(edge, kern)
    vis = cv2.cvtColor(img_gray, cv2.COLOR_GRAY2BGR)
    vis[edge != 0] = (0, 255, 0)
    cv2.imwrite('boats_canny.jpg', vis)
    # only external contours
    contours, hierarchy = cv2.findContours(edge.copy(), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
    vis = np.zeros((img_rgb.shape), np.uint8)
    i = 0
    for cnt in contours:
        color = np.random.random_integers(255, size=(3))
        cv2.drawContours( vis, contours0, i, color,
                          3, cv2.CV_AA, hierarchy, 0)
        i += 1
    cv2.imwrite('boats_contours.jpg', vis)

This is the original image :