Cleaning

Scripts/data_preprocessing.py → Old_approach/Scripts/data_preprocessing.py

@@ -1,5 +1,4 @@
-from Scripts.gather_data import Data
-from sklearn.model_selection import train_test_split
+from Old_approach.Scripts.gather_data import Data
 import numpy as np
 import random
 import imgaug.augmenters as iaa

Scripts/model.py → Old_approach/Scripts/model.py

@@ -1,9 +1,7 @@
-from Scripts.data_preprocessing import Preprocessing
-from keras.models import Sequential
-from keras.layers import Dense, Conv2D, MaxPool2D, Flatten
+from Old_approach.Scripts.data_preprocessing import Preprocessing
 
 from keras.models import Sequential
-from keras.layers import Conv2D, MaxPooling2D, BatchNormalization
+from keras.layers import Conv2D, MaxPooling2D
 from keras.layers import Activation, Dropout, Flatten, Dense
 from keras.initializers import RandomNormal
 from keras.regularizers import l2
@@ -12,7 +10,7 @@
 #TODO
 # 1. Make some hyperparameters tuning
 class Model:
-    def __init__(self, prepared_data:Preprocessing):
+    def __init__(self, prepared_data:Preprocessing = 0):
         self.prepared_data = prepared_data
         self.size = list(prepared_data.size)
         self.model = Sequential()

Old_approach/main.py

@@ -0,0 +1,66 @@
+import numpy as np
+
+from Old_approach.Scripts.data_preprocessing import Preprocessing
+from Old_approach.Scripts.gather_data import Data
+from Old_approach.Scripts import Model
+import cv2
+from patchify import patchify
+
+# TODO
+#  1. Pack all into one class to reduce complexity
+#  2. Test model
+if __name__ == "__main__":
+    data = Data()
+    preprocessing = Preprocessing(data)
+    preprocessing.size = (100,100)
+    print(repr(preprocessing))
+    preprocessing.normalize()
+    preprocessing.resize()
+    model = Model(preprocessing)
+    model.build_cnn_model()
+    # model.fit_model()
+    # model.validate_model()
+    # model.save_model()
+    # data = Data()
+    # preprocessing = Preprocessing(data)
+    # model = Model(preprocessing)
+    # preprocessing.size = (100, 100)
+    # model.build_cnn_model()
+    model.model.load_weights('model.keras')
+    videofile = 'test_video.mp4'
+    cap = cv2.VideoCapture(videofile)
+    predicted_frames = []
+    k = 0
+    while cap.isOpened():
+        ret, frame = cap.read()
+        if ret==True:
+            frame = cv2.resize(frame, (640, 360))
+            frame2 = frame.copy()
+            predicted_pathes = []
+            patches = patchify(frame, (100,100,3), step = 100)
+            k = k+1
+            if k == 2:
+                k = 0
+                for i in range(patches.shape[0]):
+                    for j in range(patches.shape[1]):
+                        patch = patches[i,j,:,:]
+                        patch_norm_input = patch/255
+                        # patch_prediction = model.model.predict(patch_norm_input)
+                        frame = cv2.rectangle(frame, (j * 100, i * 100), (j * 100 + 95, i * 100 + 95), (255, 0, 0), 2, )
+                        # if patch_prediction.item() > 0.5:
+                        #     frame2 = cv2.rectangle(frame, (j*50, i*50), (j*50+95, i*50+95), (0, 255, 0), 2)
+                        # predicted_pathes.append(patch_prediction.item())
+                        # cv2.waitKey(1)
+                        # alpha = 0.1
+                        # frame2 = cv2.addWeighted(frame, alpha, frame2, 1 - alpha, 0)
+                        cv2.imshow('frame', frame)
+                        # cv2.waitKey(20)
+                predicted_pathes = np.resize(predicted_pathes, (6,4))
+                predicted_frames.append(predicted_pathes)
+
+            # cv2.imshow('frame', frame)
+            if cv2.waitKey(25) & 0xFF == ord('q'): break
+        else:
+            break
+    cap.release()
+    cv2.destroyAllWindows()

bounding_box.py

@@ -18,101 +18,133 @@
 import matplotlib.pyplot as plt
 import numpy as np
 INIT_LR = 1e-4
-NUM_EPOCHS = 25
-BATCH_SIZE = 32
+NUM_EPOCHS = 10
+BATCH_SIZE = 16
+
+
+def get_iou(bb1, bb2):
+    assert bb1['x1'] < bb1['x2']
+    assert bb1['y1'] < bb1['y2']
+    assert bb2['x1'] < bb2['x2']
+    assert bb2['y1'] < bb2['y2']
+    x_left = max(bb1['x1'], bb2['x1'])
+    y_top = max(bb1['y1'], bb2['y1'])
+    x_right = min(bb1['x2'], bb2['x2'])
+    y_bottom = min(bb1['y2'], bb2['y2'])
+    if x_right < x_left or y_bottom < y_top:
+        return 0.0
+    intersection_area = (x_right - x_left) * (y_bottom - y_top)
+    bb1_area = (bb1['x2'] - bb1['x1']) * (bb1['y2'] - bb1['y1'])
+    bb2_area = (bb2['x2'] - bb2['x1']) * (bb2['y2'] - bb2['y1'])
+    iou = intersection_area / float(bb1_area + bb2_area - intersection_area)
+    assert iou >= 0.0
+    assert iou <= 1.0
+    return iou
+
 
 if __name__ == "__main__":
+    ss = cv2.ximgproc.segmentation.createSelectiveSearchSegmentation()
+
+
     # for image in os.listdir('dron'):
     #     img = cv2.imread(f"dron/{image}")
     #     print(img.shape)
-    img = cv2.imread("dron/5.PNG")
-    w1, h1 = img.shape[:2]
-    img = cv2.resize(img,(1000, 500))
+    img = cv2.imread(f'Old_approach/dron/6.PNG')
+    img = cv2.resize(img, (500, 250))
     w2, h2 = img.shape[:2]
     target_coor = []
     target_coor_temp = []
     data_image = []
     pic = {}
     car_in_pic = {}
     # x = tqdm()
-    dir_list = os.listdir('dron/default')
+    dir_list = os.listdir('Old_approach/dron/default')
     dir_txt = []
     for dir in dir_list:
         if dir.endswith(".txt"):
             dir_txt.append(dir)
-    image_list = os.listdir('dron')
+    image_list = os.listdir('Old_approach/dron')
     for dir, image in zip(dir_txt, image_list):
+        img = cv2.imread(f'Old_approach/dron/{image}')
+        w1, h1 = img.shape[:2]
         if dir.endswith(".txt") and image.endswith(".PNG"):
-            with open(f"dron/default/{dir}", "r") as file:
+            with open(f"Old_approach/dron/default/{dir}", "r") as file:
                 lines = file.readlines()
                 for line in tqdm(lines):
                     var1, var2, var3, var4 = line.split()
                     target_coor_temp.append([float(var1)/h1, float(var2)/w1, float(var3)/h1, float(var4)/w1])
-                    # imgg = cv2.imread(f'dron/{image}')
-                    imgg = load_img(f'dron/{image}', target_size=(1000, 500))
+                    imgg = load_img(f'Old_approach/dron/{image}', target_size=(500, 250))
                     imgg = img_to_array(imgg)
                     data_image.append(imgg)
             num = re.findall(r'\d+', dir)
 
             pic[f"{num[0]}"] = target_coor_temp
             target_coor = target_coor + target_coor_temp
             target_coor_temp=[]
-    for car in pic["5"]:
-        xy, hw = (int(car[0]*h2),int(car[1]*w2)), (int(car[2]*h2), int(car[3]*w2))
-        # xy, hw = (int(float(car[0])),int(float(car[1]))), (int(float(car[2])),int(float(car[3])))
-        cv2.rectangle(img, xy, hw, color = (0,255,0), thickness=1)
-    cv2.imshow('image', img)
-    cv2.waitKey(0)
-    #
-    # data_image = np.array(data_image, dtype="float32")/255.0
-    # target_coor = np.array(target_coor, dtype="float32")
-    #
-    # data_image_train, data_image_test, target_coor_train, target_coor_test = train_test_split(data_image, target_coor, test_size=0.10,
-    #                          random_state=42)
-    #
-    # ...
-    # # load the VGG16 network, ensuring the head FC layers are left off
-    # vgg = VGG16(weights="imagenet", include_top=False,
-    #             input_tensor=Input(shape=(1000, 500, 3)))
-    # # freeze all VGG layers so they will *not* be updated during the
-    # # training process
-    # vgg.trainable = False
-    # # flatten the max-pooling output of VGG
-    # flatten = vgg.output
-    # flatten = Flatten()(flatten)
-    # # construct a fully-connected layer header to output the predicted
-    # # bounding box coordinates
-    # bboxHead = Dense(128, activation="relu")(flatten)
-    # bboxHead = Dense(64, activation="relu")(bboxHead)
-    # bboxHead = Dense(32, activation="relu")(bboxHead)
-    # bboxHead = Dense(4, activation="sigmoid")(bboxHead)
-    # # construct the model we will fine-tune for bounding box regression
-    # model = Model(inputs=vgg.input, outputs=bboxHead)
-    #
-    # opt = Adam(lr=INIT_LR)
-    # model.compile(loss="mse", optimizer=opt)
-    # print(model.summary())
-    # # train the network for bounding box regression
-    # print("[INFO] training bounding box regressor...")
-    # H = model.fit(
-    #     data_image_train, target_coor_train,
-    #     validation_data=(data_image_test, target_coor_test),
-    #     batch_size=BATCH_SIZE,
-    #     epochs=NUM_EPOCHS,
-    #     verbose=1)
+
+    # for photo in pic.items():
+    #     im, cars = photo
+    #     imgggg = cv2.imread(f'dron/{im}.PNG')
+    #     imgggg = cv2.resize(imgggg, (1000, 500))
+    #     for car in cars:
     #
-    # print("[INFO] saving object detector model...")
-    # model.save("model_RCNN.keras")
-    # N = NUM_EPOCHS
-    # plt.style.use("ggplot")
-    # plt.figure()
-    # plt.plot(np.arange(0, N), H.history["loss"], label="train_loss")
-    # plt.plot(np.arange(0, N), H.history["val_loss"], label="val_loss")
-    # plt.title("Bounding Box Regression Loss on Training Set")
-    # plt.xlabel("Epoch #")
-    # plt.ylabel("Loss")
-    # plt.legend(loc="lower left")
-    # plt.savefig("wykres.png")
+    #         xy, hw = (int(car[0]*h2),int(car[1]*w2)), (int(car[2]*h2), int(car[3]*w2))
+    #     # xy, hw = (int(float(car[0])),int(float(car[1]))), (int(float(car[2])),int(float(car[3])))
+    #         cv2.rectangle(imgggg, xy, hw, color = (0,255,0), thickness=1)
+    #     cv2.imshow('image', imgggg)
+    #     cv2.waitKey(0)
+
+    a = list(pic.values())
+    data_image = np.array(data_image, dtype="float32")/255.0
+    target_coor = np.array(target_coor, dtype="float32")
+    # target_coor = np.array(a, dtype="float32")
+
+    data_image_train, data_image_test, target_coor_train, target_coor_test = train_test_split(data_image, target_coor, test_size=0.10,
+                             random_state=42)
+
+    ...
+    # load the VGG16 network, ensuring the head FC layers are left off
+    vgg = VGG16(weights="imagenet", include_top=False,
+                input_tensor=Input(shape=(500, 250, 3)))
+    # freeze all VGG layers so they will *not* be updated during the
+    # training process
+    vgg.trainable = False
+    # flatten the max-pooling output of VGG
+    flatten = vgg.output
+    flatten = Flatten()(flatten)
+    # construct a fully-connected layer header to output the predicted
+    # bounding box coordinates
+    bboxHead = Dense(128, activation="relu")(flatten)
+    bboxHead = Dense(64, activation="relu")(bboxHead)
+    bboxHead = Dense(32, activation="relu")(bboxHead)
+    bboxHead = Dense(4, activation="sigmoid")(bboxHead)
+    # construct the model we will fine-tune for bounding box regression
+    model = Model(inputs=vgg.input, outputs=bboxHead)
+
+    opt = Adam(lr=INIT_LR)
+    model.compile(loss="mse", optimizer=opt)
+    print(model.summary())
+    # train the network for bounding box regression
+    print("[INFO] training bounding box regressor...")
+    H = model.fit(
+        data_image_train, target_coor_train,
+        validation_data=(data_image_test, target_coor_test),
+        batch_size=BATCH_SIZE,
+        epochs=NUM_EPOCHS,
+        verbose=1)
+
+    print("[INFO] saving object detector model...")
+    model.save("model_500_250.keras")
+    N = NUM_EPOCHS
+    plt.style.use("ggplot")
+    plt.figure()
+    plt.plot(np.arange(0, N), H.history["loss"], label="train_loss")
+    plt.plot(np.arange(0, N), H.history["val_loss"], label="val_loss")
+    plt.title("Bounding Box Regression Loss on Training Set")
+    plt.xlabel("Epoch #")
+    plt.ylabel("Loss")
+    plt.legend(loc="lower left")
+    plt.savefig("wykres500_250.png")