def from_video_object_scalable(display_image: numpy.ndarray, object_info_list: list, fps: float):
    """Overlays the boxes and labels onto the display image.
    :param display_image: the image on which to overlay the boxes/labels
    :param object_info_list: is a list of lists which have 6 values each
           these are the 6 values:
           [0] string that is network classification ie 'cat', or 'chair' etc
           [1] float value for box upper left X
           [2] float value for box upper left Y
           [3] float value for box lower right X
           [4] float value for box lower right Y
           [5] float value that is the probability 0.0 -1.0 for the network classification.
    :return: None
    """
    source_image_width = display_image.shape[1]
    source_image_height = display_image.shape[0]

    for one_object in object_info_list:
        percentage = int(one_object[5] * 100)

        label_text = one_object[0] + " (" + str(percentage) + "%)"
        box_left = int(one_object[1]) 
        box_top = int(one_object[2])  
        box_right = int(one_object[3])  
        box_bottom = int(one_object[4])  

        box_color = (255, 128, 0)  # box color
        box_thickness = 2
        cv2.rectangle(display_image, (box_left, box_top), (box_right, box_bottom), box_color, box_thickness)

        min_score_percent = 80
        scale_max = (100.0 - min_score_percent)
        scaled_prob = (percentage - min_score_percent)
        scale = scaled_prob / scale_max

        # draw the classification label string just above and to the left of the rectangle
        label_background_color = (0, int(scale * 175), 75)
        label_text_color = (255, 255, 255)  # white text

        label_size = cv2.getTextSize(label_text, cv2.FONT_HERSHEY_SIMPLEX, 0.5, 1)[0]
        label_left = box_left
        label_top = box_top - label_size[1]
        if (label_top < 1):
            label_top = 1
        label_right = label_left + label_size[0]
        label_bottom = label_top + label_size[1]
        cv2.rectangle(display_image, (label_left - 1, label_top - 1), (label_right + 1, label_bottom + 1),
                      label_background_color, -1)

        # label text above the box
        cv2.putText(display_image, label_text, (label_left, label_bottom), cv2.FONT_HERSHEY_SIMPLEX, 0.5,
                    label_text_color, 1)

    if (show_fps):
        fps_text = "FPS: " + "{:.2f}".format(fps)
        fps_thickness = 2
        fps_multiplier = 1.5
        fps_size = cv2.getTextSize(fps_text, cv2.FONT_HERSHEY_SIMPLEX, fps_multiplier, fps_thickness)[0]
        text_pad = 10
        box_coord_left = 0
        box_coord_top = 0
        box_coord_right = box_coord_left + fps_size[0] + text_pad * 2
        box_coord_bottom = box_coord_top + fps_size[1] + text_pad * 2

        fps_left = box_coord_left + text_pad
        fps_bottom = box_coord_bottom - text_pad
        label_background_color = (200, 200, 200)
        label_text_color = (255, 0, 0)

        fps_image = numpy.full((box_coord_bottom - box_coord_top, box_coord_right - box_coord_left, 3),
                               label_background_color, numpy.uint8)
        cv2.putText(fps_image, fps_text, (fps_left, fps_bottom), cv2.FONT_HERSHEY_SIMPLEX, fps_multiplier,
                    label_text_color, fps_thickness)

        fps_transparency = 0.4
        cv2.addWeighted(display_image[box_coord_top:box_coord_bottom, box_coord_left:box_coord_right],
                        1.0 - fps_transparency,
                        fps_image, fps_transparency, 0.0,
                        display_image[box_coord_top:box_coord_bottom, box_coord_left:box_coord_right])

    device_count = 1
    if (show_device_count):
        ncs_count_text = "Devices: " + str(device_count)

        ncs_count_thickness = 2
        ncs_count_multiplier = 1.5
        ncs_count_size = \
        cv2.getTextSize(ncs_count_text, cv2.FONT_HERSHEY_SIMPLEX, ncs_count_multiplier, ncs_count_thickness)[0]
        ncs_count_text_pad = 10
        ncs_count_box_coord_left = display_image.shape[1] - ncs_count_size[0] - + ncs_count_text_pad * 2  # 0
        ncs_count_box_coord_top = 0
        ncs_count_box_coord_right = ncs_count_box_coord_left + ncs_count_size[0] + ncs_count_text_pad * 2
        ncs_count_box_coord_bottom = ncs_count_box_coord_top + ncs_count_size[1] + ncs_count_text_pad * 2

        ncs_count_label_background_color = (200, 200, 200)
        ncs_count_label_text_color = (255, 0, 0)

        ncs_count_image = numpy.full((ncs_count_box_coord_bottom - ncs_count_box_coord_top,
                                      ncs_count_box_coord_right - ncs_count_box_coord_left, 3),
                                     ncs_count_label_background_color, numpy.uint8)
        cv2.putText(ncs_count_image, ncs_count_text, (0 + ncs_count_text_pad, ncs_count_size[1] + ncs_count_text_pad),
                    cv2.FONT_HERSHEY_SIMPLEX, ncs_count_multiplier, ncs_count_label_text_color, ncs_count_thickness)

        ncs_count_transparency = 0.4
        cv2.addWeighted(display_image[ncs_count_box_coord_top:ncs_count_box_coord_bottom,
                        ncs_count_box_coord_left:ncs_count_box_coord_right], 1.0 - ncs_count_transparency,
                        ncs_count_image, ncs_count_transparency, 0.0,
                        display_image[ncs_count_box_coord_top:ncs_count_box_coord_bottom,
                        ncs_count_box_coord_left:ncs_count_box_coord_right])
Overlays the boxes and labels onto the display image.
    :param display_image: the image on which to overlay the boxes/labels
    :param object_info_list: is a list of lists which have 6 values each
           these are the 6 values:
           [0] string that is network classification ie 'cat', or 'chair' etc
           [1] float value for box upper left X
           [2] float value for box upper left Y
           [3] float value for box lower right X
           [4] float value for box lower right Y
           [5] float value that is the probability 0.0 -1.0 for the network classification.
    :return: None
    
apps/classifier_flash/classifier_flash.py