test_detector.py

""" This code compares the pre and post prediction value of the objects pre and post of reconstructing a low-resolution image as an input to the detector"""


import numpy as np
from tensorflow.keras.models import Model, load_model, Sequential
from tensorflow.keras.applications.vgg16 import VGG16, preprocess_input, decode_predictions
from tensorflow.keras.applications import VGG16
from tensorflow.keras.preprocessing import image
from keras.layers import Input, Lambda, Activation, Conv2D, MaxPooling2D, ZeroPadding2D, Reshape, Concatenate

import struct
import numpy as np
from keras.layers import Conv2D
from keras.layers import Input
from keras.layers import BatchNormalization
from keras.layers import LeakyReLU
from keras.layers import ZeroPadding2D
from keras.layers import UpSampling2D
from keras.layers.merge import add, concatenate
from keras.models import Model
import tensorflow as tf

from numpy import expand_dims
from keras.models import load_model
from keras.preprocessing.image import load_img
from keras.preprocessing.image import img_to_array
from matplotlib import pyplot
from matplotlib.patches import Rectangle
from keras.preprocessing import image
from tensorflow.keras.applications.vgg16 import preprocess_input




#Labels for COCO that has CAR and Pedestrian as object
labels = ["person", "bicycle", "car", "motorbike", "aeroplane", "bus", "train", "truck",
"boat", "traffic light", "fire hydrant", "stop sign", "parking meter", "bench",
"bird", "cat", "dog", "horse", "sheep", "cow", "elephant", "bear", "zebra", "giraffe",
"backpack", "umbrella", "handbag", "tie", "suitcase", "frisbee", "skis", "snowboard",
"sports ball", "kite", "baseball bat", "baseball glove", "skateboard", "surfboard",
"tennis racket", "bottle", "wine glass", "cup", "fork", "knife", "spoon", "bowl", "banana",
"apple", "sandwich", "orange", "broccoli", "carrot", "hot dog", "pizza", "donut", "cake",
"Chair", "Couch", "pottedplant", "Bed", "diningtable", "toilet", "TV", "laptop", "mouse",
"remote", "keyboard", "cell phone", "microwave", "oven", "toaster", "sink", "refrigerator",
"book", "clock", "vase", "scissors", "teddy bear", "hair drier", "toothbrush"]
# define the expected input shape for the model
input_w, input_h = 416, 416


_MODEL_YOLO = ""
_MODEL_RETINANET = ""



# Functions neccesary to output a bounding box with prediction 
class BoundBox:
        def __init__(self, xmin, ymin, xmax, ymax, objness = None, classes = None):
                self.xmin = xmin
                self.ymin = ymin
                self.xmax = xmax
                self.ymax = ymax
                self.objness = objness
                self.classes = classes
                self.label = -1
                self.score = -1

        def get_label(self):
                if self.label == -1:
                        self.label = np.argmax(self.classes)

                return self.label

        def get_score(self):
                if self.score == -1:
                        self.score = self.classes[self.get_label()]

                return self.score
def _sigmoid(x):
        return 1. / (1. + np.exp(-x))

def decode_netout(netout, anchors, obj_thresh, net_h, net_w):
        grid_h, grid_w = netout.shape[:2]
        nb_box = 3
        netout = netout.reshape((grid_h, grid_w, nb_box, -1))
        nb_class = netout.shape[-1] - 5
        boxes = []
        netout[..., :2]  = _sigmoid(netout[..., :2])
        netout[..., 4:]  = _sigmoid(netout[..., 4:])
        netout[..., 5:]  = netout[..., 4][..., np.newaxis] * netout[..., 5:]
        netout[..., 5:] *= netout[..., 5:] > obj_thresh

        for i in range(grid_h*grid_w):
                row = i / grid_w
                col = i % grid_w
                for b in range(nb_box):
                        # 4th element is objectness score
                        objectness = netout[int(row)][int(col)][b][4]
                        if(objectness.all() <= obj_thresh): continue
                        # first 4 elements are x, y, w, and h
                        x, y, w, h = netout[int(row)][int(col)][b][:4]
                        x = (col + x) / grid_w # center position, unit: image width
                        y = (row + y) / grid_h # center position, unit: image height
                        w = anchors[2 * b + 0] * np.exp(w) / net_w # unit: image width
                        h = anchors[2 * b + 1] * np.exp(h) / net_h # unit: image height
                        # last elements are class probabilities
                        classes = netout[int(row)][col][b][5:]
                        box = BoundBox(x-w/2, y-h/2, x+w/2, y+h/2, objectness, classes)
                        boxes.append(box)
        return boxes
def _interval_overlap(interval_a, interval_b):
        x1, x2 = interval_a
        x3, x4 = interval_b
        if x3 < x1:
                if x4 < x1:
                        return 0
                else:
                     	return min(x2,x4) - x1
        else:
             	if x2 < x3:
                         return 0
                else:
                     	return min(x2,x4) - x3

def bbox_iou(box1, box2):
        intersect_w = _interval_overlap([box1.xmin, box1.xmax], [box2.xmin, box2.xmax])
        intersect_h = _interval_overlap([box1.ymin, box1.ymax], [box2.ymin, box2.ymax])
        intersect = intersect_w * intersect_h
        w1, h1 = box1.xmax-box1.xmin, box1.ymax-box1.ymin
        w2, h2 = box2.xmax-box2.xmin, box2.ymax-box2.ymin
        union = w1*h1 + w2*h2 - intersect
        return intersect/(union+0.00000001)
def do_nms(boxes, nms_thresh):
        if len(boxes) > 0:
                nb_class = len(boxes[0].classes)
        else:
             	return
        for c in range(nb_class):
                sorted_indices = np.argsort([-box.classes[c] for box in boxes])
                for i in range(len(sorted_indices)):
                        index_i = sorted_indices[i]
                        if boxes[index_i].classes[c] == 0: continue
                        for j in range(i+1, len(sorted_indices)):
                                index_j = sorted_indices[j]
                                if bbox_iou(boxes[index_i], boxes[index_j]) >= nms_thresh:
                                        boxes[index_j].classes[c] = 0
                                        
def load_image_pixels(filename, shape):
        # load the image to get its shape
        image = load_img(filename)
        width, height = image.size
        # load the image with the required size
        image = load_img(filename, target_size=shape)
        # convert to numpy array
        image = img_to_array(image)
        # scale pixel values to [0, 1]
        image = image.astype('float32')
        image /= 255.0
        # add a dimension so that we have one sample
        image = expand_dims(image, 0)
        return image, width, height
    
    
# draw all results
def draw_boxes(filename, v_boxes, v_labels, v_scores):
        # load the image
        data = pyplot.imread(filename)
        # plot the image
        pyplot.imshow(data)
        # get the context for drawing boxes
        ax = pyplot.gca()
        # plot each box
        for i in range(len(v_boxes)):
                box = v_boxes[i]
                # get coordinates
                y1, x1, y2, x2 = box.ymin, box.xmin, box.ymax, box.xmax
                # calculate width and height of the box
                width, height = x2 - x1, y2 - y1
                # create the shape
                rect = Rectangle((x1, y1), width, height, fill=False, color='white')
                # draw the box
                ax.add_patch(rect)
                # draw text and score in top left corner
                label = "%s (%.3f)" % (v_labels[i], v_scores[i])
                pyplot.text(x1, y1, label, color='white')
        # show the plot
        pyplot.show()
    


def main():
    img = 
    model = load_model('/home/tug87582/work/project_src/Detectors/YOLOV3/model_coco.h5')
    image = load_image_array("")
    yhat = model_boost.predict(image)

    for th in all_threshold:
        thres = th
        fp = open(os.path.join(_OBJECT_RESULTS,str(th),str(temp_item[0])+"_"+str(probs[0][related_objects[objectIndex][1]])+".txt"),'w')
        # summarize the shape of the list of arrays
        # define the anchors
        boxes = list()
        temp_meta_label = []
        for i in range(len(yhat)):
        # decode the output of the network
            boxes += decode_netout(yhat[i][0], anchors[i], class_threshold, input_w, input_h)
            # correct the sizes of the bounding boxes for the shape of the image
            correct_yolo_boxes(boxes, image_h, image_w, input_h, input_w)
            # suppress non-maximal boxes
            do_nms(boxes, 0.5)
            # define the labels
            # get the details of the detected objects
            v_boxes, v_labels, v_scores = get_boxes(boxes, labels, class_threshold)
            # summarize what we found
            print(v_labels)
            print("")
        draw_boxes(path1, v_boxes, v_labels, v_scores)

main()