color_tracking_draft.py

# coding: utf-8

# In[1]:


# adapted from https://www.pyimagesearch.com/2015/09/14/ball-tracking-with-opencv/
# Kalman filter from https://github.com/Myzhar/simple-opencv-kalman-tracker/blob/master/source/opencv-kalman.cpp
from collections import deque
import numpy as np
import argparse
import imutils
import cv2


# In[2]:


thresLower = (25, 50, 50)
thresUpper = (35, 255, 255)
pts = deque(maxlen=64)

camera = cv2.VideoCapture(0)


# In[3]:


stateSize = 5 # [x, y, v_x, v_y, r]'
measSize = 3 # [x, y, r]

kf = cv2.KalmanFilter(stateSize, measSize)

cv2.setIdentity(kf.transitionMatrix, 1.)

kf.measurementMatrix = np.array([
    [1., 0., 0., 0., 0.],
    [0., 1., 0., 0., 0.],
    [0., 0., 0., 0., 1.]
],np.float32)

kf.processNoiseCov = np.array([
    [1e-3, 0, 0, 0, 0],
    [0, 1e-3, 0, 0, 0],
    [0, 0, 5., 0, 0],
    [0, 0, 0, 5., 0],
    [0, 0, 0, 0, 1e-1]
],np.float32)

cv2.setIdentity(kf.measurementNoiseCov, 1e-1)

ticks = cv2.getTickCount()


# In[4]:


while True:
    # grab the current frame
    (grabbed, frame) = camera.read()
 
    precTick = ticks
    ticks = cv2.getTickCount()
    
    dT = (ticks - precTick) / cv2.getTickFrequency()
    
    # resize the frame, blur it, and convert it to the HSV
    # color space
    # frame = imutils.resize(frame, width=600)
    # blurred = cv2.GaussianBlur(frame, (11, 11), 0)
    hsv = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV)
 
    # construct a mask for the color "yellow", then perform
    # a series of dilations and erosions to remove any small
    # blobs left in the mask
    mask = cv2.inRange(hsv, thresLower, thresUpper)
    mask = cv2.erode(mask, None, iterations=2)
    mask = cv2.dilate(mask, None, iterations=2)
    
    # find contours in the mask and initialize the current
    # (x, y) center of the ball
    cnts = cv2.findContours(mask.copy(), cv2.RETR_EXTERNAL,
        cv2.CHAIN_APPROX_SIMPLE)[-2]
    center = None

    
    # only proceed if at least one contour was found
    if len(cnts) > 0:
        # find the largest contour in the mask, then use
        # it to compute the minimum enclosing circle and
        # centroid
        c = max(cnts, key=cv2.contourArea)
        ((x, y), radius) = cv2.minEnclosingCircle(c)
        M = cv2.moments(c)
        center = (int(M["m10"] / M["m00"]), int(M["m01"] / M["m00"]))
 
        # only proceed if the radius meets a minimum size
        if radius > 10:
            mp = np.array([[x], [y], [radius]],np.float32)
            kf.transitionMatrix = np.array([
                [1., 0, dT, 0, 0],
                [0, 1., 0, dT, 0],
                [0, 0, 1., 0, 0],
                [0, 0, 0, 1., 0],
                [0, 0, 0, 0, 1.]
            ],np.float32)
            
            kf.correct(mp)
 
    # update the points queue
    state = kf.predict()
            
    x = state[0]
    y = state[1]
    radius = state[4]
    # draw the circle and centroid on the frame,
    # then update the list of tracked points
    cv2.circle(frame, (int(x), int(y)), int(radius),
        (0, 255, 255), 2)
    cv2.circle(frame, center, 5, (0, 0, 255), -1)
        
    pts.appendleft(center)
    
        # loop over the set of tracked points
    for i in xrange(1, len(pts)):
        # if either of the tracked points are None, ignore
        # them
        if pts[i - 1] is None or pts[i] is None:
            continue
 
        # otherwise, compute the thickness of the line and
        # draw the connecting lines
        thickness = int(np.sqrt(64 / float(i + 1)) * 2.5)
        cv2.line(frame, pts[i - 1], pts[i], (0, 0, 255), thickness)
 
    # show the frame to our screen
    cv2.imshow("Frame", cv2.flip(frame,1))
#     cv2.imshow("HSV", cv2.flip(hsv,1))
    cv2.imshow("Mask", cv2.flip(mask,1))
    key = cv2.waitKey(1) & 0xFF

    # if the 'q' key is pressed, stop the loop
    if key == ord("q"):
        break


# In[5]:


camera.release()
cv2.destroyAllWindows()


# In[ ]:


green = np.uint8([[[0,111,255 ]]])
cv2.cvtColor(green,cv2.COLOR_BGR2HSV)


# In[ ]:


green = np.uint8([[[29, 86, 6]]])
cv2.cvtColor(green,cv2.COLOR_HSV2RGB)