python类resize()的实例源码

def createTrainingData(filename,time_start,time_stop):
    vidcap = cv2.VideoCapture(filename)
    try:
        os.makedirs("trainingdata_"+filename)
    except OSError:
        pass
    os.chdir("trainingdata_"+filename)
    length = int(vidcap.get(cv2.CAP_PROP_FRAME_COUNT))
    fps = int(vidcap.get(cv2.CAP_PROP_FPS))
    for time in range(time_start,time_stop):
        vidcap.set(cv2.CAP_PROP_POS_MSEC,time*1000)
        success,image = vidcap.read()
        image = cv2.medianBlur(image,7)
        resized = imutils.resize(image, width=800)
        p1 = resized[370:430,220:300]
        p2 = resized[370:430,520:600]
        p1 = cv2.Canny(p1, 400, 100, 255)
        p2 = cv2.Canny(p2, 400, 100, 255)
        cv2.imwrite('p1_'+str(time)+".png",p1)
        cv2.imwrite('p2_'+str(time)+".png",p2)
    os.chdir("..")

def find_people(self, img):
        '''
        Detect people in image
        :param img: numpy.ndarray
        :return: count of rectangles after non-maxima suppression, corresponding to number of people detected in picture
        '''
        t = time.time()
        # HOG descriptor/person detector
        hog = cv2.HOGDescriptor()
        hog.setSVMDetector(cv2.HOGDescriptor_getDefaultPeopleDetector())
        # Chooses whichever size is less
        image = imutils.resize(img, width=min(self.MIN_IMAGE_WIDTH, img.shape[1]))
        # detect people in the image
        (rects, wghts) = hog.detectMultiScale(image, winStride=self.WIN_STRIDE,
                                              padding=self.PADDING, scale=self.SCALE)
        # apply non-maxima suppression to the bounding boxes but use a fairly large overlap threshold,
        # to try to maintain overlapping boxes that are separate people
        rects = np.array([[x, y, x + w, y + h] for (x, y, w, h) in rects])
        pick = non_max_suppression(rects, probs=None, overlapThresh=self.OVERLAP_THRESHOLD)

        print("Elapsed time: {} seconds".format(int((time.time() - t) * 100) / 100.0))

        if self.SHOW_IMAGES:
            # draw the final bounding boxes
            for (xA, yA, xB, yB) in pick:
                # Tighten the rectangle around each person by a small margin
                shrinkW, shrinkH = int(0.05 * xB), int(0.15*yB)
                cv2.rectangle(image, (xA+shrinkW, yA+shrinkH), (xB-shrinkW, yB-shrinkH), self.BOX_COLOR, 2)

            cv2.imshow("People detection", image)
            cv2.waitKey(self.IMAGE_WAIT_TIME)
            cv2.destroyAllWindows()

        return len(pick)

def debug_face_classifier(file):
    face_cascade = cv2.CascadeClassifier(xml_face_classifier)
    image = cv2.imread(file)

    image = imutils.resize(image, width=500)
    gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
    faces = face_cascade.detectMultiScale(image, 1.07, 3)
    print faces
    for (x, y, w, h) in faces:
        cv2.rectangle(image, (x, y), (x+w, y+h), (255, 0, 0), 2)
        #roi_gray = gray[y:y+h, x:x+w]
        #roi_color = image[y:y+h, x:x+w]

    cv2.imshow('Image', image)
    cv2.waitKey(0)
    cv2.destroyAllWindows()

def image(self):

        img = cv2.imread(self.image_path)
        img = imutils.resize(img,width=min(800,img.shape[1]))
        gray = cv2.cvtColor(img,cv2.COLOR_BGR2GRAY)
        gray = cv2.GaussianBlur(gray,(21,21),0)
        fullbody = self.HogDescriptor(gray)
        for (x,y,w,h) in fullbody:
            cv2.rectangle(img,(x,y),(x+w,y+h),(0,255,0),2)

        faces = self.haar_facedetection(gray)
        for (x,y,w,h) in faces:
            cv2.rectangle(img,(x,y),(x+w,y+h),(255,0,0),2)
            roi_gray = gray[y:y+h, x:x+w]
            roi_color = img[y:y+h, x:x+w]
            eyes = self.haar_eyedetection(roi_gray)
            for (ex,ey,ew,eh) in eyes:
                cv2.rectangle(roi_color, (ex,ey), (ex+ew,ey+eh), (0,255,0),2) 
            smile = self.haar_smilecascade(roi_gray)
            for (sx,sy,sw,sh) in smile:
                cv2.rectangle(roi_color, (sx,sy), (sx+sw,sy+sh),(0,255,0),2)
        img = self.dlib_function(img)
        cv2.imshow('img',img)
        cv2.waitKey(0) 
        cv2.destroyAllWindows()

def find_people(self, img):
        '''
        Detect people in image
        :param img: numpy.ndarray
        :return: count of rectangles after non-maxima suppression, corresponding to number of people detected in picture
        '''
        t = time.time()
        hog = cv2.HOGDescriptor()
        hog.setSVMDetector(cv2.HOGDescriptor_getDefaultPeopleDetector())
        # Chooses whichever size is less
        image = imutils.resize(img, width=min(self.MIN_IMAGE_WIDTH, img.shape[1]))
        # detect people in the image
        (rects, wghts) = hog.detectMultiScale(image, winStride=self.WIN_STRIDE,
                                              padding=self.PADDING, scale=self.SCALE)
        # apply non-maxima suppression to the bounding boxes using a
        # fairly large overlap threshold to try to maintain overlapping boxes that are still people
        rects = np.array([[x, y, x + w, y + h] for (x, y, w, h) in rects])
        pick = non_max_suppression(rects, probs=None, overlapThresh=self.OVERLAP_THRESHOLD)

        print("Elapsed time of detection: {} seconds".format(int((time.time() - t) * 100) / 100.0))

        if self.SHOW_IMAGES:
            # draw the final bounding boxes
            for (xA, yA, xB, yB) in pick:
                # Tighten the rectangle around each person by a small margin
                cv2.rectangle(image, (xA+5, yA+5), (xB-5, yB-10), self.BOX_COLOR, 2)

            cv2.imshow("People detection", image)
            cv2.waitKey(self.IMAGE_WAIT_TIME)
            cv2.destroyAllWindows()

        return len(pick)

def __init__(self, original, is_cards_screen=False):
    self.original = cv2.cvtColor(original, cv2.COLOR_BGR2GRAY)
    (self.original_h, self.original_w) = self.original.shape[:2]
    self.threshold = 0.8
    self.is_cards_screen = False
    self.resized_w = self.original_w
    self.resized_h = self.original_h

    if self.original_w != TARGET_WIDTH:
      self.original = imutils.resize(self.original, width=TARGET_WIDTH)
      (self.resized_h, self.resized_w) = self.original.shape[:2]

    self.mid_height = int(self.resized_h / 2.0)

    # Now can detect if we're on the game-over screen with voting cards, since
    # we've scaled the image to the same size from which the 'rate match'
    # template was taken.
    self.is_cards_screen = self.detect_if_cards_screen()

  # Returns a unique list of tuples with x,y coordinates for the top left of
  # where the given template appears in the original image. Returns None if the
  # template was not detected.

def addFrame(self, frame, width=300):
        frame = imutils.resize(frame, width)

        # check if the writer is None
        if self.writer is None:
            # store the image dimensions, initialzie the video writer,
            # and construct the zeros array
            (self.h, self.w) = frame.shape[:2]
            self.writer = cv2.VideoWriter(self.output, self.fourcc, self.fps,
                                          (self.w * 2, self.h * 2), True)
            self.zeros = np.zeros((self.h, self.w), dtype="uint8")

        # break the image into its RGB components, then construct the
        # RGB representation of each frame individually
        (B, G, R) = cv2.split(frame)
        R = cv2.merge([self.zeros, self.zeros, R])
        G = cv2.merge([self.zeros, G, self.zeros])
        B = cv2.merge([B, self.zeros, self.zeros])

        # construct the final output frame, storing the original frame
        # at the top-left, the red channel in the top-right, the green
        # channel in the bottom-right, and the blue channel in the
        # bottom-left
        output = np.zeros((self.h * 2, self.w * 2, 3), dtype="uint8")
        output[0:self.h, 0:self.w] = frame
        output[0:self.h, self.w:self.w * 2] = R
        output[self.h:self.h * 2, self.w:self.w * 2] = G
        output[self.h:self.h * 2, 0:self.w] = B

        # write the output frame to file
        self.writer.write(output)

def addFrame(self, frame, width=600):
        frame = imutils.resize(frame, width)

        # check if the writer is None
        if self.writer is None:
            # store the image dimensions, initialzie the video writer,
            (self.h, self.w) = frame.shape[:2]
            self.writer = cv2.VideoWriter(self.output, self.fourcc, self.fps,
                                          (self.w, self.h), True)
        # write the output frame to file
        self.writer.write(frame)

def debug_face_landmark(file, output=False, output_name='output'):
    detector = dlib.get_frontal_face_detector()
    predictor = dlib.shape_predictor(dat_face_landmark)

    image = cv2.imread(file)
    image = imutils.resize(image, width=500)
    gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
    img_size = gray.shape

    faces = detector(gray, 1)
    for (i, itr_face) in enumerate(faces):
        shape = predictor(gray, itr_face)
        shape = shape_to_np(shape)
        # convert dlib's rectangle to a OpenCV-style bounding box
        # [i.e., (x, y, w, h)], then draw the face bounding box
        (x, y, w, h) = rect_to_bb(itr_face, img_size, file)
        #print "landmark: ({:d}, {:d}) ({:d}, {:d})".format(x, y, w, h)

        cv2.rectangle(image, (x, y), (x + w, y + h), (0, 255, 0), 2)
        # show the face number
        cv2.putText(image, "Face #{}".format(i + 1), (x - 10, y - 10),
            cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 2)

        # loop over the (x, y)-coordinates for the facial landmarks
        # and draw them on the image
        for (x, y) in shape:
            cv2.circle(image, (x, y), 1, (0, 0, 255), -1)

    # show the output image with the face detections + facial landmarks
    cv2.imshow(file, image)
    cv2.waitKey(0)
    if output:
        cv2.imwrite("../" + str(output_name + 1) + '.jpg', image)
    cv2.destroyAllWindows()

def debug_Data_Augmentation(blur=False, sigma=1.0, hflip=False, vflip=False, hvsplit=False, randbright=False):
    image = cv2.imread('Dataset/young/female/180.jpg', 0)
    #image = cv2.imread('Dataset/young/female/285.jpg', 0)
    #image = cv2.resize(image, (100, 100))
    cv2.imshow('Image', image)

    # Data Augmentation:
    # Gaussian Blurred 
    if blur:
        cv2.imshow('Blur', gaussian_filter(input=image, sigma=sigma))
        #cv2.imwrite("Blur_{:1.1f}.jpg".format(sigma), 
        #           gaussian_filter(input=image, sigma=sigma))
        cv2.imwrite("../xBlur_{:1.1f}.jpg".format(sigma), 
                    gaussian_filter(input=image, sigma=sigma))
    # Flip and Rotate
    if (hflip and not vflip) or (hflip and hvsplit):
        cv2.imshow('hflip', np.fliplr(image))
        cv2.imwrite("../hflip.jpg", np.fliplr(image))
    if (vflip and not hflip) or (vflip and hvsplit):
        cv2.imshow('vflip', np.flipud(image))
        cv2.imwrite("../vflip.jpg", np.flipud(image))
    if hflip and vflip and not hvsplit:
        cv2.imshow('rot 180', np.rot90(image, k=2))
        cv2.imwrite("../rot2k.jpg", np.rot90(image, k=2))
    cv2.waitKey(0)
    cv2.destroyAllWindows()

def dlib_function(self,image):

        detector = dlib.get_frontal_face_detector()
        predictor = dlib.shape_predictor(self.shape_predictor)
        image = imutils.resize(image, width=500)
        gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
        rects = detector(image, 1)

        for (i, rect) in enumerate(rects):
            shape = predictor(gray, rect)
            shape = face_utils.shape_to_np(shape)

            for (x, y) in shape:
                cv2.circle(image, (x, y), 1, (0, 0, 255), -1)
        return image

def lipSegment(img):
    img = imutils.resize(img,width=300)
    img_copy = img.copy()

    landmarks = dlib_obj.get_landmarks(img)
    dlib_obj.get_face_mask(img_copy, landmarks)

    output_img = img-img_copy
    output_img = cv2.cvtColor(output_img,cv2.COLOR_BGR2GRAY)

    contours,hierarchy = cv2.findContours(output_img.copy(), cv2.cv.CV_RETR_EXTERNAL, cv2.cv.CV_CHAIN_APPROX_SIMPLE)  #cv2.findContours(image, mode, method
    cv2.drawContours(img, contours, -1, (0,255,0), 2,maxLevel=0)

    cnt = contours[0]
    ellipse = cv2.fitEllipse(cnt)
    (x,y),(MA,ma),angle = cv2.fitEllipse(cnt)


    a = ma/2
    b = MA/2


    eccentricity = sqrt(pow(a,2)-pow(b,2))
    eccentricity = round(eccentricity/a,2)

    font = cv2.FONT_HERSHEY_SIMPLEX

    cv2.putText(img,'Eccentr= '+str(round(eccentricity,3)),(10,350), font, 1,(255,0,0),2,16)

    if(eccentricity < 0.9):
        cv2.putText(img,'Commands = O',(10,300), font, 1,(0,0,255),2,16)
    else:
        cv2.putText(img,'Commands = E',(10,300), font, 1,(0,0,255),2,16)

    return img

def predictFacialLandmark(img, detector):
    img = imutils.resize(img, width=500)
    gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
    # detect faces in the grayscale image
    rects = detector(gray, 1)
    return rects

def readImage(img_path):
    image = cv2.imread(img_path)
    image = imutils.resize(image, width=500)
    gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
    return image, gray

def drawEyes(eye, image):
    (x, y, w, h) = cv2.boundingRect(np.array([eye]))
    h = w
    y = y - h / 2
    roi = image[y:y + h, x:x + w]
    roi = imutils.resize(roi, width=24, inter=cv2.INTER_CUBIC)

    return roi

def predictFacialLandmark(img, detector):
    img = imutils.resize(img, width=500)
    gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
    # detect faces in the grayscale image
    rects = detector(gray, 1)
    return rects

def readImage(img_path):
    image = cv2.imread(img_path)
    image = imutils.resize(image, width=500)
    gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
    return image, gray

def getScoreboard(self, img):
        template_width = self.TEMPLATE_SCOREBOARD.shape[1]
        img_width = img.shape[1]
        template = imutils.resize(self.TEMPLATE_SCOREBOARD,
                                  width=int(template_width/1280.0*img_width))
        top_left, bottom_right = self.matchTemplate(img, template)

        return img[top_left[1]:bottom_right[1], top_left[0]:bottom_right[0]]

def getTopBar(self, img):
        template_width = self.TEMPLATE_TOP.shape[1]
        img_width = img.shape[1]
        template = imutils.resize(self.TEMPLATE_TOP,
                                  width=int(template_width/1280.0*img_width))
        top_left, bottom_right = self.matchTemplate(img, template)

        located = img[top_left[1]:bottom_right[1], top_left[0]:bottom_right[0]]
        h, w = located.shape[:2]

        return located[:, int(w*0.125):int(w*0.5)]

def getTimeArea(self, img):
        template_width = self.TEMPLATE_TIME.shape[1]
        img_width = img.shape[1]
        template = imutils.resize(self.TEMPLATE_TIME,
                                  width=int(template_width/1280.0*img_width))
        top_left, bottom_right = self.matchTemplate(img, template)

        located = img[top_left[1]:bottom_right[1], top_left[0]:bottom_right[0]]
        h, w = located.shape[:2]

        return located[int(h*0.16):int(h*0.84), int(w*0.42):int(w*0.58)]

def getScoreArea(self, img):
        template_width = self.TEMPLATE_SCORES.shape[1]
        img_width = img.shape[1]
        template = imutils.resize(self.TEMPLATE_SCORES,
                                  width=int(template_width/1280.0*img_width))
        top_left, bottom_right = self.matchTemplate(img, template)

        return img[top_left[1]:bottom_right[1], top_left[0]:bottom_right[0]]

def videoToImageArray(filename,time_start,time_stop):
    vidcap = cv2.VideoCapture(filename)
    pictures = [[],[]]
    for time in range(time_start,time_stop):
        vidcap.set(cv2.CAP_PROP_POS_MSEC,time*1000)      # just cue to 20 sec. position
        success,image = vidcap.read()
        image = cv2.medianBlur(image,7)
        resized = imutils.resize(image, width=800)
        p1 = resized[370:430,220:300]
        p2 = resized[370:430,520:600]
        p1 = cv2.Canny(p1, 400, 100, 255)
        p2 = cv2.Canny(p2, 400, 100, 255)
        pictures[0].append(p1)
        pictures[1].append(p2)
    return pictures

def capture_images():
    """
    print "Staring capture thread"
    global frame
    while True:
        print "Attempting capture"
        (grabbed, f) = stream.read()
        if grabbed:
            print "Captured"
            lock.acquire()
            frame = imutils.resize(f, width=resolution[0], height=resolution[1])
            lock.release()
    """
    print "started capturing thread"
    global frame
    with picamera.PiCamera() as camera:
        camera.resolution = resolution
        camera.shutter_speed = 250
        time.sleep(0.5) # Shutter speed is not set instantly. This wait allows time for changes to take effect.
        print "Initialized camera..."
        with picamera.array.PiRGBArray(camera) as stream:
            for foo in camera.capture_continuous(stream, format="bgr", use_video_port=True):
                print "Captured an image"
                stream.seek(0)
                stream.truncate()
                lock.acquire()
                frame = stream.array
                lock.release()
                print "Converted image data to array"

def cnvt_edged_image(img_arr, should_save=False):
  # ratio = img_arr.shape[0] / 300.0
  image = imutils.resize(img_arr,height=300)
  gray_image = cv2.bilateralFilter(cv2.cvtColor(image, cv2.COLOR_BGR2GRAY),11, 17, 17)
  edged_image = cv2.Canny(gray_image, 30, 200)

  if should_save:
    cv2.imwrite('cntr_ocr.jpg')

  return edged_image

def createImagePyramid(im, scale, minHeight, minWidth):
    yield im
    while (True):
        reducedWidth = int(round(im.shape[1] / scale))
        reducedHeight = int(round(im.shape[0] / scale))
        im = imutils.resize(im, width=reducedWidth, height=reducedHeight)
        if ((im.shape[0] >= minHeight) and (im.shape[1] >= minWidth)):
            yield im
        else:
            break

def scale_template_for_cards_screen(self, template):
    (height, width) = template.shape[:2]
    new_width = int(math.ceil(width * 0.78))
    return imutils.resize(template, width=new_width)

  # Returns true if the given y-axis position represents a hero on the red team.

def face_extraction(path):
    path_str = path[:-1] if path.endswith('/') else path
    output_dir = path_str + '_faces'
    if not os.path.isdir(output_dir):
        os.makedirs(output_dir)

    detector = dlib.get_frontal_face_detector()
    predictor = dlib.shape_predictor(dat_face_landmark)
    face_cascade = cv2.CascadeClassifier(xml_face_classifier)
    undetectLst = list()

    numfile = get_dataInfo(path_str)
    not_detected = 0
    itr = 0

    for itr_file in os.listdir(path_str):
        if itr_file.endswith('.jpg'):
            file = "{:s}/{:s}".format(path_str, itr_file)
            image = cv2.imread(file)
            image = imutils.resize(image, width=500)
            bFace, faces = facial_landmark_detection(image, detector, predictor, file)

            if not bFace:
                bFace, faces = face_detect_classifier(image, face_cascade)
                if not bFace:
                    print file
                    undetectLst.append(file)
                    not_detected += 1
                    image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
                    cv2.imwrite("{:s}/{:s}".format(output_dir, itr_file), image)
                    continue
            x, y, w, h = faces
            crop_img = image[y:y + h, x:x + w]
            crop_img = cv2.cvtColor(crop_img, cv2.COLOR_BGR2GRAY)
            cv2.imwrite("{:s}/{:s}".format(output_dir, itr_file), crop_img)
            itr += 1 
        else:
            continue
    total = itr + not_detected
    print "{:s}: {:4d} of {:4d} file missed detected, detect rate {:2.2f}%"\
    .format(path_str, not_detected, total, 100.0 * itr / total)
    return undetectLst, total

def detect():
    move=0
    hog = cv2.HOGDescriptor()
    hog.setSVMDetector(cv2.HOGDescriptor_getDefaultPeopleDetector())
    cap=cv2.VideoCapture(0)
    while(1):
        ret, img=cap.read()
        gray=cv2. cvtColor(img, cv2.COLOR_BGR2GRAY)
        image = imutils.resize(img, width=min(400, img.shape[1]))
        (rects, weights) = hog.detectMultiScale(image, winStride=(4, 4),padding=(8, 8), scale=1.05)
        for (x, y, w, h) in rects:
            cv2.rectangle(image, (x, y), (x + w, y + h), (0, 0, 255), 2)
            rects = np.array([[x, y, x + w, y + h] for (x, y, w, h) in rects])
            pick = non_max_suppression(rects, probs=None, overlapThresh=0.65)
            for (xA, yA, xB, yB) in pick:
                cv2.rectangle(image, (xA, yA), (xB, yB), (0, 255, 0), 2)
            if (xA/480)>0.5 :
                print("move to right")
                move=4

            elif (yA/640)>0.5:
                print('move to down')
                move=3
            elif (xB/480)<0.3:
                print('move to left')
                move=2
            elif (yB/640)<0.3:
                print('move to up')
                move=1
            else:
                print('do nothing')
                move=0
            mqt.pass_message(move)
            #eyes = eye_cascade.detectMultiScale(roi_gray)

            #for (ex,ey,ew,eh) in eyes:
            #   cv2.rectangle(roi_color,(ex,ey),(ex+ew,ey+eh),(0,255,0),2)
        cv2.imshow('img',image)
        k=cv2.waitKey(1)& 0xff
        if k==27:
            break
        elif (k==ord('w')):
            mqt.pass_message(1)
        elif (k==ord('s')):
            mqt.pass_message(3)

    cap.release()
    cv2.destroyAllWindows()

def main():
    print "\t\t########################################"
    print "\t\tOPTIMISED = ",cv2.useOptimized()," !!!!"
    print "\t\t########################################"

    while True:
        ret,img=cap.read()
        #img = cv2.medianBlur(img,3)    # 5 is a fairly small kernel size
        img = cv2.resize(img,None,fx=1.3,fy=1,interpolation = cv2.INTER_LINEAR)

        hand_box = [(0,50),(400,400)]
        head_box = [(500,50),(800,400)]
        cv2.rectangle(img,hand_box[0],hand_box[1],(255,255,255),2)
        cv2.rectangle(img,head_box[0],head_box[1],(50,50,50),2)

        head_frame = img[50:400,500:800]
        try:
            img[50:400,500:800] = lipSegment(head_frame)    
        except ValueError, e:
            #print e
            pass

        hand_frame = img[50:400,0:400]

        try:
            mask,counter,hull,(cx,cy),list_far,list_end = count_fingers(hand_frame)

            if(cv2.contourArea(hull)>3000) and list_far:
                cv2.drawContours(hand_frame,[hull],0,(0,255,0),1)
                [cv2.circle(hand_frame,far,5,[0,0,0],-1) for far in list_far]
                [cv2.circle(hand_frame,end,5,[150,150,150],-1) for end in list_end]
                cv2.putText(hand_frame,"Fingers = "+str(counter+1),(10,250),cv2.FONT_HERSHEY_SIMPLEX, 1,(0,0,255),2,1)

        except ZeroDivisionError, e:
            print "Count_fingers ZeroDivisionError: ",e
        except UnboundLocalError,e:
            print "Count_fingers UnboundLocalError: ",e



        cv2.imshow('Img',img)

        if cv2.waitKey(20)&0xff==ord('q'):
            cv2.imwrite('output.jpg',img)
            cv2.imwrite('Mask.jpg',mask)
            cv2.imwrite('hand_frame.jpg',hand_frame)
            break

    cap.release()
    cv2.destroyAllWindows()

def create_dataset(path, dest, dist, transpose, rgb, resize_factor):
    cap = cv2.VideoCapture(path)
    length = int(cap.get(cv2.cv.CV_CAP_PROP_FRAME_COUNT))
    width  = int(cap.get(cv2.cv.CV_CAP_PROP_FRAME_WIDTH))
    height = int(cap.get(cv2.cv.CV_CAP_PROP_FRAME_HEIGHT))

    fac = 3 if rgb else 1

    rwidth = int(width * resize_factor * fac)
    rheight = int(height * resize_factor * fac)

    frames = 0
    I = np.zeros([rwidth*rheight * fac, length])
    Phi = np.zeros([3, length])

    while True:
        (grabbed, frame) = cap.read()

        if not grabbed: break       

        p, r = detect_ball(frame)

        if p != None:
            Phi[:,frames] = dist(p, r)[0:3]
        else:
            Phi[:,frames] = np.nan

        img = frame

        if not rgb:
            img = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)

        img = imutils.resize(img, width=rwidth, height=rheight, inter=cv2.INTER_AREA)

        I[:,frames] = img.T.ravel() if transpose else img.ravel()

        frames += 1

    print("Got {0} frames".format(frames))

    cap.release()
    cv2.destroyAllWindows()

    data = {'I' : I, 'h' : rheight, 'w' : rwidth, 'Phi' : Phi}
    scipy.io.savemat(dest, data , do_compression=True)