CVNovice's profile - activity

Thanks for the tip. I didn't realize that. I just thought this forum would be more knowledgeable about opencv specifically while stack would be a good source of broader knowledge and has a larger user base. I'm not quite sure why it would be bad to post on two different forums?? It seems its just a better way to have more people see the question and potential answer.

I've seen different examples where each row of the sample data is either (R,G,B) or (X,Y,R,G,B).

What is the difference of using just color values or color and spatial values? How does this affect the centroids generated from a color image?

My goal is to identify prominent colors of the image, for example, detecting eye color following face detection.

import numpy as np
H = np.array(
    [[ 7, -1,  1, -1],
     [-1, -1,  2,  0],
     [-1, -1,  3,  1],
     [-1, -1,  4,  2],
     [-1, -1,  5,  3],
     [ 6, -1, -1,  4],
     [-1,  5, -1,  4],
     [ 8,  0, -1, -1],
     [-1,  7, -1, -1]])

def T(i):
    children = [(h, j) for j, h in enumerate(H) if h[3] == i]
    children.sort(key = lambda h: h[0][1])
    return {c[1]: T(c[1]) for c in children}

print T(-1)

Thanks to Falko at stack overflow for this answer.

For example if I were to input the hierarchy from 4.RETR_TREE here

hierarchy = 
    array([[[ 7, -1,  1, -1],
            [-1, -1,  2,  0],
            [-1, -1,  3,  1],
            [-1, -1,  4,  2],
            [-1, -1,  5,  3],
            [ 6, -1, -1,  4],
            [-1,  5, -1,  4],
            [ 8,  0, -1, -1],
            [-1,  7, -1, -1]]])

I would like to get this output:

{0:{1:{2:{3:{4:{5:{},6:{}}}}}},
7:{},
8:{}}

I am looking to do this to build a tree model in Qt so I can easily see which contours contain which others. If you have a better idea of how to turn the hierarchy data into a Qt tree model that would also be appreciated.

Thanks in advance!

Not quite. I'm making a GUI that takes a regular cv function and lets you change its attributes and see the results of different parameters in real time.

I have written wrappers for most of the common methods but I thought it would be really cool (if its possible) to have a script make the wrappers automatically for every cv method based on the documentation.

For instance, the threshold function gets passed its source image, then has a slider for changing the threshold value and max threshold value, and a combo box to select what type of threshold to use (binary, binary_inv).

cvtColor just has the combo box to select bgr2gray,bgr2hsv, etc.

Does that make sense? Give me a few mins and Ill post a screen shot.

Ok a slightly bigger issue, I need to get this information into a class method call. But it seems help automatically prints to stdout. I need to figure out how to go about redirecting the output of help() so it can be called and parsed in a script. Any ideas?

Thank you! Now what about getting the type of each argument in the method call?

Note: I'm using python 2.7, ubuntu14.04, and opencv2.4

Is it possible to have python return a list or dictionary of method arguments and their type?

For instance take cv2.threshold function. If I go to the docs webpage I can see all of the info I want, but is it possible to get this information in code? I would like to query the function cv2.threshold and have something tell me it takes the arguments [src,thresh,maxval,type[,dst]). It would be ideal if it also told me what type or class the values are:

e.g. the docs say: Python: cv2.threshold(src, thresh, maxval, type[, dst]) → retval, dst

so I want to be able to do something like:

foo.getMethods(cv2.threshold) -> {src:mat, thresh:int, maxval:int, type:built-in/[cv2. THRESH_BINARY_INV,cv2. THRESH_BINARY)]}

All of this info is in the documentation on the web page, I just want to access it to dynamically setup a codebase I am working on for a GUI.

Can I access this info without having to setup a web-scraper to pull it directly from the website?

Edit: I've uploaded a video to show exactly what I want to do.

Up to now for each function I have to manually enter its parameters which look like this (for cv2.threshold or Binary Threshold in the video):

    def guiParams(self):
    thresh = {'type':'int',
              'name':'threshold value',
              'min':0,
              'max' : 255,
              'default': 127}
    maxval = {'type':'int',
            'name':'max threshold value',
            'min':0,  
            'max' : 255,
          'default': 255}
    threshtype ={'type':'builtin',
            'name':'thresholding type',
            'options':{'THRESH_BINARY':cv2.THRESH_BINARY,
                       'THRESH_BINARY_INV':cv2.THRESH_BINARY_INV,
                       'THRESH_TRUNC':cv2.THRESH_TRUNC,
                       'THRESH_TOZERO':cv2.THRESH_TOZERO,
                       'THRESH_TOZERO_INV':cv2.THRESH_TOZERO_INV},
            'default':'THRESH_BINARY'
            }
    return [thresh,maxval,threshtype]

This question is trying to figure out how I can get the information in these dictionaries (primarily the attribute name and type, default/typical values would be a bonus) grammatically so I can ensure the gui will work with every image processing method in the opencv Library

Thank you for your suggestions! The top hat filter seems to be just what I needed to remove most of the background debris/noise. I'm still working on the code to keep track of all the particles though, I posted my code so far in the edit.

Thanks again!

I took your suggestion of using a top hat filter and implemented it before feeding the sequence to the LK tracker. I posted the code I'm now using in the edit above.

Hello, I am working on a school project where I want to track the number, direction, and velocity of particles moving across a flow chamber. I have a series of timestamped images which were taken under florescent light showing bright particles flowing over a view field.

The particles I'm interested in tracking are the bright round dots (shown in green), while excluding motion blur from other particles that were not in focus.

Here is a series of sample images from the data set: Sample Data

I have started working with both optical flow examples from the docs but they pick up all of the noise as tracks which I need to avoid. What method would you recommend for this application?

Thanks for the response. I've got a working prototype I did with PyQt, I'll post some screen shots soon.

Background: I am working on a project where I am trying to automatically identify an object and perform color calibration and segmentation on a subset of an image. The image can be taken from any camera where it is uploaded to a server. I am trying to normalize and accommodate for issues such as shadows, non-uniform illumination, as well as zoom, pan, and tilt of the camera. The problem I have is my code works well on images that match the test images I used, but subtle variations can throw it off.

GUI Proposal: I am considering making a tool which would allow each step in an image processing algorithms be kept track of and changed on the fly.

For instance, If these are the steps:

1. BGR > Gray

2. Gray >Gaussian Blur

3. Gaussian Blur > Histogram Equalization

4. Histogram Equalization > Adaptive Threshold

5. Adaptive Threshold > Morph Close

6. Morph Close > Morph Open

I would have a single window pop up with prev and next buttons. Each Step would be loaded into an array along with parameters important to each step. The main window will allow you to scroll through the stack of steps for each process. A prev and next button, along with a slider to quickly cycle through all the steps would be present in every window.

For example, all step one would have is the basic gui. Step two however would have a slider to adjust the kernel size of the blurr, in addition to the basic elemnts. Step 4 would have multiple sliders to adjust all of the paremeters involved in an adaptive threshold.

For instance, when you go to step four you can change the threshold value, and the image will automatically update in the window reflecting the updated values. If you hit next, it will use your updated image rather than the originial hard coded value.

I hope my discription made sense, but my thought here is I waste a lot of time with trial and error trying to get parameters right in some of these functions (primarily thresholds where lighting and showdows vary).

Main Question: Would this be a useful tool for anyone (make a valid contribution to the open source project?) or am I just doing CV wrong? Is there some function I can use to calculate optimal parameters for each image without having to manually play with the values?