Binocular-vision/getImages.py at main · pranubs/Binocular-vision · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
import cv2
import numpy as np
from scipy.spatial.distance import cdist

cap = cv2.VideoCapture(4)
cap2 = cv2.VideoCapture(2)
def overlay_images(background_img, overlay_img, blend_percentage):
    blended_img = cv2.addWeighted(background_img, 1 - blend_percentage, overlay_img, blend_percentage, 0)
    return blended_img
f = open('output.txt','w')
while cap.isOpened():
    vergence_metric_left_2_right = []
    vergence_metric_right_2_left = []

    succes, rimg = cap.read()
    succes1, limg = cap2.read()
    cv2.imshow('right Img',rimg)
    cv2.imshow('left Img',limg)

    #cv2.imshow('Img diff',rimg - limg)
    img_size = rimg.shape
    #print("Original image size = ",img_size)

    img_gray_right = cv2.cvtColor(rimg, cv2.COLOR_BGR2GRAY)
    img_blur_right = cv2.GaussianBlur(img_gray_right, (3,3), 0)
    #cv2.imshow('blur', img_blurr)
    img_gray_left = cv2.cvtColor(limg, cv2.COLOR_BGR2GRAY)
    img_blur_left = cv2.GaussianBlur(img_gray_left, (3,3), 0)
    blend_percentage = 0.5
    blended_img = overlay_images(rimg, limg, blend_percentage)
    cv2.imshow("Blended Image", blended_img)
    edges_right = cv2.Canny(image=img_blur_right, threshold1=50, threshold2=200)
    edges_left = cv2.Canny(image=img_blur_left, threshold1=50, threshold2=200)
    cv2.imshow('canny right', edges_right)
    cv2.imshow('canny left', edges_left)
    sobel_final = edges_right+edges_left
    cv2.imshow('Sobel add', sobel_final)
    key = cv2.waitKey(5)

    if key == 27:
        cap.release()
        cap2.release()
        cv2.destroyAllWindows()
        f.close()
        break
    elif key == ord('s'):
        center_img_sizes_array = [25,50,75,100,125,150]
        print("Original image shape = ",img_size)
        f.write("Original image size = {}\n".format(img_size))
        for k in center_img_sizes_array:
            slice_right = edges_right[img_size[0]//2-k:img_size[0]//2+k,img_size[1]//2-k:img_size[1]//2+k]
            slice_left = edges_left[img_size[0]//2-k:img_size[0]//2+k,img_size[1]//2-k:img_size[1]//2+k]
            #cv2.imshow('slice_right',slice_right)
            #cv2.imshow('slice_left',slice_left)
            print("Right sliced image shape = ",slice_right.shape)
            print("Left sliced image shape = ",slice_left.shape)
            f.write("Right sliced image shape = {}\n".format(slice_right.shape))
            f.write("Left sliced image shape = {}\n".format(slice_left.shape))
            indices_r = np.where(slice_right != [0])
            coordinates_r = list(zip(indices_r[0], indices_r[1]))
            indices_l = np.where(slice_left != [0])
            coordinates_l = list(zip(indices_l[0], indices_l[1]))
            len_l = len(coordinates_l)
            len_r = len(coordinates_r)
            #print("len l, len r = ",len_l,len_r)
            coordinates_l = np.array(coordinates_l)
            coordinates_r = np.array(coordinates_r)
            d_left2right = cdist(coordinates_l,coordinates_r)
            min_d_left2right = np.min(d_left2right,axis=1)
            vleft = np.sum(min_d_left2right)/len_l
            #print("len vergence metric left to right = ",len(vleft))
            f.write("Number of edge/white pixels in the left image = {}\n".format(len_l))
            vergence_metric_left_2_right.append(vleft)
            d_right2left = cdist(coordinates_r,coordinates_l)
            min_d_right2left = np.min(d_right2left,axis=1)
            vright = np.sum(min_d_right2left)/len_r
            vergence_metric_right_2_left.append(vright)
            #print("len vergence metric right to left = ",len(vright))
            f.write("Number of edge/white pixels in the right image = {}\n".format(len_r))
            f.write("Vergence metric from left image to right image for center image size {}\n = {}\n".format(slice_left.shape,vleft))
            f.write("Vergence metric from right image to left image for center image size {}\n = {}\n".format(slice_left.shape,vright))
            print("Vergence metric left to right = ",vleft)
            print("Vergence metric right to left = ",vright)

        cv2.imwrite('data/final/final_left_img.png', limg)
        cv2.imwrite('data/final/final_right_img.png', rimg)
        cv2.imwrite('data/final/final_edge_left.png', edges_left)
        cv2.imwrite('data/final/final_edge_right.png', edges_right)
        cv2.imwrite('data/final/blended_image.png',blended_img)
        cv2.imwrite('data/final/final_edge_add.png', sobel_final)
        print("Vergence left to right for image sizes ",center_img_sizes_array,"is = ",vergence_metric_left_2_right)
        print("Vergence right to left for image sizes ",center_img_sizes_array,"is = ",vergence_metric_right_2_left)
        #print("len of ver big array = ",len(vergence_metric_left_2_right),len(vergence_metric_right_2_left))
        f.write("Vergence metric from left image to right image for all image sizes = {}\n".format(vergence_metric_left_2_right))
        f.write("Vergence metric from right image to left image for center image size = {}\n".format(vergence_metric_right_2_left))
        print("images saved")