Codacus's profile - activity

blur = cv2.GaussianBlur(img,(5,5),0)
smooth = cv2.addWeighted(blur,1.5,img,-0.5,0)

this will do the work, you can adjust the kernel size for the blur according to your requirement..

    tp=[]
    qp=[]
    for m in goodMatch:
        tp.append(trainKP[m.trainIdx].pt)
        qp.append(queryKP[m.queryIdx].pt)
    tp,qp=np.float32((tp,qp))
    H,mask=cv2.findHomography(tp,qp,cv2.RANSAC,3.0)

I think this will work, source

try using cv2.waitKey(10) instead of cv2.waitKey(1)

I was having a doubt that you are pasting cv2.pyd in one version of the python and when using python you are running the other version..

As already mentioned in the code you can use model->predict(testSample, predictedLabel, confidence); to get the predictedLabel and confidence, the confidence variable will give you the estimate of how accurate the prediction is. the lesser the value to more accurate the prediction is.

So you can use it like this way

if(confidence<50){
    // put the predictedLebel as a detected face
}
else{
    // put the Unknown as a detected face
}

Now you can play with this value 50 to work best for you.

Here is a series of articles in python if you are interested for face recognition for known and unknown faces

OpenCV has many face recognizer built-in like LBPHFaceRecognizer or EigenFaceRecognizer,

for your project you will need a cascade classifier to first detect the face regions and the use those recognizer to recognize the person, here is a series of article you can follow to make your recognizer,

Hope this will help

This is an implementation that I used once

python has a thread safe queue which can be used for this purpose

hope this will help

import threading
import time
import Queue
import cv2
frames = Queue(10)

class ImageGrabber(threading.Thread):
    def __init__(self, ID):
        threading.Thread.__init__(self)
        self.ID=ID
        self.cam=cv2.VideoCapture(ID)

    def Run(self):
        global frames
        while True:
            ret,frame=self.cam.read()
            frames.put(frame)
            time.sleep(0.1)


class Main(threading.Thread):
    def __init__(self):
        threading.Thread.__init__(self)

    def run(self):
        global frames
        while True:
            if(not frames.empty()):
                self.Currframe=frames.get()
            ##------------------------##
            ## your opencv logic here ##
            ## -----------------------##


grabber = ImageGrabber(0)
main = Main()

grabber.start()
main.start()
main.join()
grabber.join()

(rect[0], rect[1]) yes those are exactly upper left and,.. , (rect[2], rect[3]) are the lower left corners..

you can just do the following

xFaceCenter=(rect[2]-rect[0])/2
yFaceCenter=(rect[3]-rect[1])/2

and now you have the height and width of the image frame lets say h,w then you can easily use

dy=(h/2)-yFaceCenter
dx=(w/2)-xFaceCenter

So you now just have to make these dy and dx values to be zero by changing the horizontal and vertical servo angle accordingly

you might be having two python installation.. try to remove all python from control panel as well as from the folder where you are pasting cv2.pyd and then create a clean python installation.. try after that

Well if you are using python, you can use "cv2.resize()"

subA = cv2.resize(A, (128,128), interpolation = cv2.INTER_AREA)

subA' = cv2.resize(A', (128,128), interpolation = cv2.INTER_AREA)

if both A,A' are same in dimension then both sub-sampled image will have same pixel operation on it

I also did the same, lower resolution images around 600x400 (approx cont remember) also posted https://www.youtube.com/watch?v=T77i_P-7otM (Vlog) its not very clear map but works for realtime

You can use, "cv2.resize(image, (height, width))" this function to resize the training images just before you feed it to the recognizer

recognizer.save("filename.yml"), file name is in quote and to load the trained recognizer you will need recognizer.load("filename.yml")..