Open CV

import cv2
import matplotlib.pyplot as plt
import numpy as np

def display_images(images, titles=None, fontsize=12):
    images = list(images)[:24]
    if not images:
        return
    columns = min(len(images), 6)
    rows = (len(images) + columns - 1) // columns
    fig, axes = plt.subplots(rows, columns, squeeze=False, figsize=(columns * 2.5, rows * 2.5))
    flat_axes = axes.reshape(-1)
    for index, image in enumerate(images):
        flat_axes[index].imshow(image)
        flat_axes[index].axis("off")
        if titles is not None and index < len(titles):
            flat_axes[index].set_title(titles[index], fontsize=fontsize)
    for axis in flat_axes[len(images):]:
        axis.axis("off")
    plt.tight_layout()
    plt.show()

# Generated dot pattern replaces the excluded braille photograph.
im = np.full((260, 520, 3), 245, dtype=np.uint8)
for row in range(5):
    for column in range(16):
        origin_x = 24 + column * 30
        origin_y = 28 + row * 46
        for dx, dy in ((0, 0), (0, 13), (12, 6), (12, 19)):
            if (row + column + dx + dy) % 3:
                cv2.circle(im, (origin_x + dx, origin_y + dy), 4, (20, 20, 20), -1)
print(im.shape)
plt.imshow(cv2.cvtColor(im, cv2.COLOR_BGR2RGB))

bw_im = cv2.cvtColor(im,cv2.COLOR_BGR2GRAY)
print(bw_im.shape)
plt.imshow(bw_im, cmap='gray')

im = cv2.blur(bw_im,(3,3))
im = cv2.adaptiveThreshold(im, 255, cv2.ADAPTIVE_THRESH_MEAN_C,
                           cv2.THRESH_BINARY_INV, 5, 4)
im = cv2.medianBlur(im, 3)
_,im = cv2.threshold(im, 0, 255, cv2.THRESH_OTSU)
im = cv2.GaussianBlur(im, (3,3), 0)
_,im = cv2.threshold(im, 0, 255, cv2.THRESH_OTSU)
plt.imshow(im)

orb = cv2.ORB_create(5000)
f,d = orb.detectAndCompute(im,None)
print(f"First 5 points: { [f[i].pt for i in range(5)]}")

def plot_dots(dots):
    img = np.zeros((250,500))
    for x in dots:
        cv2.circle(img,(int(x[0]),int(x[1])),3,(255,0,0))
    plt.imshow(img)

pts = [x.pt for x in f]
plot_dots(pts)

min_x, min_y, max_x, max_y = [int(f([z[i] for z in pts])) for f in (min,max) for i in (0,1)]
min_y+=13
plt.imshow(im[min_y:max_y,min_x:max_x])

off = 5
src_pts = np.array([(min_x-off,min_y-off),(min_x-off,max_y+off),
                    (max_x+off,min_y-off),(max_x+off,max_y+off)])
w = int(max_x-min_x+off*2)
h = int(max_y-min_y+off*2)
dst_pts = np.array([(0,0),(0,h),(w,0),(w,h)])
ho,m = cv2.findHomography(src_pts,dst_pts)
trim = cv2.warpPerspective(im,ho,(w,h))
plt.imshow(trim)

char_h = 36
char_w = 24
def slice(img):
    dy,dx = img.shape
    y = 0
    while y+char_h<dy:
        x=0
        while x+char_w<dx:
            # Skip empty lines
            if np.max(img[y:y+char_h,x:x+char_w])>0:
                yield img[y:y+char_h,x:x+char_w]
            x+=char_w
        y+=char_h

sliced = list(slice(trim))
display_images(sliced)

# Generated motion frames replace the excluded third-party video.
frames = []
for frame_index in range(90):
    frame = np.zeros((120, 160, 3), dtype=np.uint8)
    if 15 <= frame_index < 75:
        start = 10 + (frame_index - 15) * 2
        cv2.rectangle(frame, (start, 45), (start + 20, 65), (70, 210, 250), -1)
    frames.append(frame)
c = len(frames)
print(f"Total frames: {c}")
display_images(frames[::45])

bwframes = [cv2.cvtColor(x,cv2.COLOR_BGR2GRAY) for x in frames]
diffs = [(p2-p1) for p1,p2 in zip(bwframes[:-1],bwframes[1:])]
diff_amps = np.array([np.linalg.norm(x) for x in diffs])
plt.plot(diff_amps)
display_images(diffs[::150],titles=diff_amps[::150])

def moving_average(x, w):
    return np.convolve(x, np.ones(w), 'valid') / w

threshold = max(1.0, float(diff_amps.max()) * 0.25)

plt.plot(moving_average(diff_amps,10))
plt.axhline(y=threshold, color='r', linestyle='-')

active_frames = np.where(diff_amps > threshold)[0]

def subsequence(seq, min_length=5):
    current = []
    for frame_index in seq:
        frame_index = int(frame_index)
        if current and frame_index != current[-1] + 1:
            if len(current) > min_length:
                return current
            current = []
        current.append(frame_index)
    return current if len(current) > min_length else []

sub = subsequence(active_frames)
if not sub:
    raise RuntimeError("The generated motion fixture should contain an active sequence")
print(sub)

plt.imshow(frames[(sub[0]+sub[-1])//2])

plt.imshow(cv2.cvtColor(frames[(sub[0]+sub[-1])//2],cv2.COLOR_BGR2RGB))

flows = [cv2.calcOpticalFlowFarneback(f1, f2, None, 0.5, 3, 15, 3, 5, 1.2, 0)
         for f1,f2 in zip(bwframes[:-1],bwframes[1:])]
flows[0].shape

def flow_to_hsv(flow):
    hsvImg = np.zeros((flow.shape[0],flow.shape[1],3),dtype=np.uint8)
    mag, ang = cv2.cartToPolar(flow[..., 0], flow[..., 1])
    hsvImg[..., 0] = 0.5 * ang * 180 / np.pi
    hsvImg[..., 1] = 255
    hsvImg[..., 2] = cv2.normalize(mag, None, 0, 255, cv2.NORM_MINMAX)
    return cv2.cvtColor(hsvImg, cv2.COLOR_HSV2BGR)

start = sub[0]
stop = sub[-1]
print(start,stop)

frms = [flow_to_hsv(x) for x in flows[start:stop]]
display_images(frms[::25])