def __parseTinyYoloV3Output(self, output_node_results,  # type: numpy.ndarray
                                      filtered_objects,     # type: List
                                      original_image):      # type: OpenCV Mat
        """ Parse tiny yolo v3 inference results by filtering out duplicates via iou
            comparisons, and then filtering out low scoring results. """
            
        source_image_width = float(original_image.shape[1])
        source_image_height = float(original_image.shape[0])
        scaled_w = int(source_image_width * min(self.input_width/source_image_width, self.input_width/source_image_height))
        scaled_h = int(source_image_height * min(self.input_height/source_image_width, self.input_height/source_image_height))

        # transpose the output node results
        output_node_results = output_node_results.transpose(0,2,3,1)
        output_h = output_node_results.shape[1]
        output_w = output_node_results.shape[2]

        # 80 class scores + 4 coordinate values + 1 objectness score = 85 values
        # 85 values * 3 prior box scores per grid cell= 255 values 
        # 255 values * either 26 or 13 grid cells
        num_anchor_boxes_per_cell = 3
        
        # Set the anchor offset depending on the output result shape
        anchor_offset = 0
        if output_w == 13:
            anchor_offset = 2 * 3
        elif output_w == 26:
            anchor_offset = 2 * 0

	    # used to calculate approximate coordinates of bounding box
        x_ratio = float(source_image_width) / scaled_w
        y_ratio = float(source_image_height) / scaled_h

	    # Filter out low scoring results
        output_size = output_w * output_h
        for result_counter in range(output_size): 
            row = int(result_counter / output_w)
            col = int(result_counter % output_h)
            for anchor_boxes in range(num_anchor_boxes_per_cell): 
            	# check the box confidence score of the anchor box. This is how likely the box contains an object
                box_confidence_score = output_node_results[0][row][col][anchor_boxes * self.num_of_classes + 5 + 4]
                if box_confidence_score < self.detection_threshold:
                    continue
                # Calculate the x, y, width, and height of the box
                x_center = (col + output_node_results[0][row][col][anchor_boxes * self.num_of_classes + 5 + 0]) / output_w * scaled_w
                y_center = (row + output_node_results[0][row][col][anchor_boxes * self.num_of_classes + 5 + 1]) / output_h * scaled_h
                width = numpy.exp(output_node_results[0][row][col][anchor_boxes * self.num_of_classes + 5 + 2]) * self.anchors[anchor_offset + 2 * anchor_boxes]
                height = numpy.exp(output_node_results[0][row][col][anchor_boxes * self.num_of_classes + 5 + 3]) * self.anchors[anchor_offset + 2 * anchor_boxes + 1]
                # Now we check for anchor box for the highest class probabilities.
                # If the probability exceeds the threshold, we save the box coordinates, class score and class id
                for class_id in range(self.num_of_classes): 
                    class_probability = output_node_results[0][row][col][anchor_boxes * self.num_of_classes + 5 + 5 + class_id]
                    # Calculate the class's confidence score by multiplying the box_confidence score by the class probabiity
                    class_confidence_score = class_probability * box_confidence_score
                    if class_confidence_score < self.detection_threshold:
                        continue
                    # Calculate the bounding box top left and bottom right vertexes
                    xmin = max(int((x_center - width / 2) * x_ratio), 0)
                    ymin = max(int((y_center - height / 2) * y_ratio), 0)
                    xmax = min(int(xmin + width * x_ratio), source_image_width-1)
                    ymax = min(int(ymin + height * y_ratio), source_image_height-1)
                    filtered_objects.append((xmin, ymin, xmax, ymax, class_confidence_score, class_id))
 Parse tiny yolo v3 inference results by filtering out duplicates via iou
            comparisons, and then filtering out low scoring results. 
networks/tiny_yolo_v3/Tiny_yolo_v3_object_detector.py