Add image and video processing example code

Author: gjbex

source-code/image-processing/.gitignore

@@ -0,0 +1 @@
+bouncing_ball_full_[0-9]*.avi

source-code/image-processing/Data/problem.jpg

@@ -0,0 +1,20 @@
+# ImageProcessing
+Some sample code for image processing using Scikit-Image and video
+processing with OpenCV.
+
+## What is it?
+1. `denoise.py`: sharpen an image using deconvolution.
+1. `segmentation.py`: segmentation using an active cotour model, aka,
+    snake.
+1. `restoration.ipynb`: Jupyter notebook illustrating analysis of a
+    problematic camera image and custum restoration.
+1. `Data`: directory containing image files for illustration purposes.
+1. `caputure.py`: capture video from a webcam using OpenCV.
+1. `analyze.py`: show a plot of the average RGB values for the frames in
+    a movie using OpenCV.
+1. `split_scenes.py`: very naive utility to split a movie into scences,
+    based on rapid changes in RGB intenisty.
+1. `bouncing_ball_full.avi`: movie to test `scene_spliiter.py` with.
+1. `follow_ball.py`: example of using the camshift algorithm to follow
+    a bouncing ball in a scene.
+1. `bouncing_ball.avi`: movie to test `follow_ball.py` with.

source-code/image-processing/Data/restored.jpg

@@ -0,0 +1,45 @@
+#!/usr/bin/env python
+
+from argparse import ArgumentParser
+import cv2
+import matplotlib.pyplot as plt
+import numpy as np
+
+if __name__ == '__main__':
+    arg_parser = ArgumentParser(description='capture video')
+    arg_parser.add_argument('input', help='file to read from')
+    options = arg_parser.parse_args()
+    capture = cv2.VideoCapture(options.input)
+    counter = 0
+    try:
+        densities = []
+        while (True):
+            status, frame = capture.read()
+            if status:
+                counter += 1
+                nr_pixels = frame.shape[0]*frame.shape[1]
+                red_channel = frame[:, :, 0]
+                green_channel = frame[:, :, 1]
+                blue_channel = frame[:, :, 2]
+                densities.append((counter,
+                                  red_channel.sum()/nr_pixels,
+                                  green_channel.sum()/nr_pixels,
+                                  blue_channel.sum()/nr_pixels))
+                cv2.imshow('frame', frame)
+                if cv2.waitKey(1) & 0xFF == ord('q'):
+                    break
+            else:
+                break
+        capture.release()
+        cv2.destroyAllWindows()
+        densities = np.array(densities).T
+        plt.plot(densities[0], densities[1], 'r')
+        plt.plot(densities[0], densities[2], 'g')
+        plt.plot(densities[0], densities[3], 'b')
+        plt.xlabel('frame')
+        plt.ylabel('RGB')
+        plt.ylim((0, 255))
+        plt.show()
+    except KeyboardInterrupt:
+        capture.release()
+        cv2.destroyAllWindows()

source-code/image-processing/README.md

@@ -0,0 +1,49 @@
+#!/usr/bin/env python
+
+from argparse import ArgumentParser
+import cv2
+import numpy as np
+
+if __name__ == '__main__':
+    arg_parser = ArgumentParser(description='capture video')
+    arg_parser.add_argument('--dev', type=int, default=0,
+                            help='device number to capture')
+    arg_parser.add_argument('--input', help='file to read from')
+    arg_parser.add_argument('--output', help='file to write to')
+    arg_parser.add_argument('--fps', type=float, default=10.0,
+                            help='frames per soecond for recording')
+    options = arg_parser.parse_args()
+    if options.input:
+        capture = cv2.VideoCapture(options.input)
+    else:
+        capture = cv2.VideoCapture(options.dev)
+    if options.output:
+        fourcc = cv2.VideoWriter_fourcc(*'XVID')
+        output = cv2.VideoWriter(options.output, fourcc,
+                                 options.fps, (640, 480))
+    counter = 0
+    try:
+        while True:
+            status, frame = capture.read()
+            if status:
+                counter += 1
+                # frame = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
+                if options.output:
+                    output.write(frame)
+                cv2.imshow('frame', frame)
+                if cv2.waitKey(1) & 0xFF == ord('q'):
+                    break
+            else:
+                break
+    except KeyboardInterrupt:
+        capture.release()
+        if options.output:
+            output.release()
+        cv2.destroyAllWindows()
+        print('captured {0:d} frames'.format(counter))
+    else:
+        capture.release()
+        if options.output:
+            output.release()
+        cv2.destroyAllWindows()
+        print('captured {0:d} frames'.format(counter))

source-code/image-processing/analyze.py

@@ -0,0 +1,25 @@
+#!/usr/bin/env python
+
+import matplotlib.pyplot as plt
+import numpy as np
+from scipy.signal import convolve2d
+from skimage import color, data, restoration
+
+if __name__ == '__main__':
+    image = color.rgb2gray(data.astronaut())
+    point_spread_func = np.ones((5, 5))/25.0
+    image = convolve2d(image, point_spread_func, 'same')
+    image += 0.1*image.std()*np.random.standard_normal(image.shape)
+    denoised, _ = restoration.unsupervised_wiener(image, point_spread_func)
+    figure, axes = plt.subplots(nrows=1, ncols=2, sharex=True, sharey=True,
+                                subplot_kw={'adjustable': 'box-forced'},
+                                figsize=(8,5))
+    plt.gray()
+    axes[0].imshow(image, vmin=denoised.min(), vmax=denoised.max())
+    axes[0].axis('off')
+    axes[0].set_title('original')
+    axes[1].imshow(denoised)
+    axes[1].axis('off')
+    axes[1].set_title('restored')
+    figure.tight_layout()
+    plt.show()

source-code/image-processing/bouncing_ball.avi

@@ -0,0 +1,77 @@
+#!/usr/bin/env python
+
+from argparse import ArgumentParser
+import cv2
+import matplotlib.pyplot as plt
+import numpy as np
+import sys
+import time
+
+if __name__ == '__main__':
+    arg_parser = ArgumentParser(description='follow the yellow ball')
+    arg_parser.add_argument('input', help='AVI file to use')
+    arg_parser.add_argument('--row', type=int, default=340,
+                            help='row for ROI')
+    arg_parser.add_argument('--col', type=int, default=300,
+                            help='dolumn for ROI')
+    arg_parser.add_argument('--height', type=int, default=210,
+                            help='height for ROI')
+    arg_parser.add_argument('--width', type=int, default=230,
+                            help='width for ROI')
+    arg_parser.add_argument('--min-hue', type=int, default=25,
+                            help='minimum hue')
+    arg_parser.add_argument('--max-hue', type=int, default=50,
+                            help='maximum hue')
+    arg_parser.add_argument('--iterations', type=int, default=5,
+                            help='number of iterations for tracking')
+    arg_parser.add_argument('--output', help='output file name')
+    arg_parser.add_argument('--fps', type=float, default=12.0,
+                            help='frames per second for output')
+    options = arg_parser.parse_args()
+    capture = cv2.VideoCapture(options.input)
+    status, frame = capture.read()
+    if not status:
+        capture.release()
+        sys.exit(1)
+    if options.output:
+        fourcc = cv2.VideoWriter_fourcc(*'XVID')
+        output = cv2.VideoWriter(options.output, fourcc, options.fps,
+                                 (frame.shape[1], frame.shape[0]))
+    else:
+        output = None
+                                 
+    track_window = (options.col, options.row, options.width, options.height)
+    hsv_frame = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV)
+    mask = cv2.inRange(hsv_frame,
+                       np.array((options.min_hue, 50, 50)),
+                       np.array((options.max_hue, 255, 255)))
+    roi_hist = cv2.calcHist([hsv_frame], [0], mask, [50], [0, 50])
+    cv2.normalize(roi_hist, roi_hist, 0, 255, cv2.NORM_MINMAX)
+    termination_cond = (cv2.TERM_CRITERIA_EPS | cv2.TERM_CRITERIA_COUNT,
+                        options.iterations, 1)
+    nr_frames = 1
+    while True:
+        status, frame = capture.read()
+        if status == True:
+            nr_frames += 1
+            hsv = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV)
+            dst = cv2.calcBackProject([hsv], [0], roi_hist, [0, 50], 1)
+            status, track_window = cv2.meanShift(dst, track_window,
+                                                 termination_cond)
+            if not status:
+                continue
+            x, y, w, h = track_window
+            img = cv2.rectangle(frame, (x, y), (x + w, y + h), 255, 2)
+            cv2.imshow('image', img)
+            if output:
+                output.write(img)
+            if cv2.waitKey(1) % 0xFF == ord('q'):
+                break
+        else:
+            break
+
+    print(f'{nr_frames} frames processed')
+    cv2.destroyAllWindows()
+    if output:
+        output.release()
+    capture.release()