text: 
  
  import datetime
  import numpy as np
  import cv2
  
  # -------------------------------------------------------------------
  # Parameters
  # -------------------------------------------------------------------
  
  CONF_THRESHOLD = 0.4
  NMS_THRESHOLD = 0.4
  IMG_WIDTH = 416
  IMG_HEIGHT = 416
  
  # Default colors
  COLOR_BLUE = (255, 0, 0)
  COLOR_GREEN = (0, 255, 0)
  COLOR_RED = (0, 0, 255)
  COLOR_WHITE = (255, 255, 255)
  COLOR_YELLOW = (0, 255, 255)
  
  
  # -------------------------------------------------------------------
  # Help functions
  # -------------------------------------------------------------------
  
  # Get the names of the output layers
  def get_outputs_names(net):
      # Get the names of all the layers in the network
      layers_names = net.getLayerNames()
  
      # Get the names of the output layers, i.e. the layers with unconnected
      # outputs
      return [layers_names[i[0] - 1] for i in net.getUnconnectedOutLayers()]
  
  
  # Draw the predicted bounding box
  def draw_predict(frame, conf, left, top, right, bottom):
      # Draw a bounding box.
      #cv2.rectangle(frame, (left, top), (right, bottom), COLOR_YELLOW, 2)
  
      text = '{:.2f}'.format(conf)
  
      # Display the label at the top of the bounding box
      label_size, base_line = cv2.getTextSize(text, cv2.FONT_HERSHEY_SIMPLEX, 0.5, 1)
  
      top = max(top, label_size[1])
      #cv2.putText(frame, text, (left, top - 4), cv2.FONT_HERSHEY_SIMPLEX, 0.4,
       #           COLOR_WHITE, 1)
  
  
  def post_process(frame, outs, conf_threshold, nms_threshold):
      frame_height = frame.shape[0]
      frame_width = frame.shape[1]
  
      # Scan through all the bounding boxes output from the network and keep only
      # the ones with high confidence scores. Assign the box's class label as the
      # class with the highest score.
      confidences = []
      boxes = []
      final_boxes = []
      for out in outs:
          for detection in out:
              scores = detection[5:]
              class_id = np.argmax(scores)
              confidence = scores[class_id]
              if confidence > conf_threshold:
                  center_x = int(detection[0] * frame_width)
                  center_y = int(detection[1] * frame_height)
                  width = int(detection[2] * frame_width)
                  height = int(detection[3] * frame_height)
                  left = int(center_x - width / 2)
                  top = int(center_y - height / 2)
                  confidences.append(float(confidence))
                  boxes.append([left, top, width, height])
  
      # Perform non maximum suppression to eliminate redundant
      # overlapping boxes with lower confidences.
      indices = cv2.dnn.NMSBoxes(boxes, confidences, conf_threshold,
                                 nms_threshold)
  
      for i in indices:
          i = i[0]
          box = boxes[i]
          left = box[0]
          top = box[1]
          width = box[2]
          height = box[3]
          final_boxes.append(box)
          left, top, right, bottom = refined_box(left, top, width, height)
          # draw_predict(frame, confidences[i], left, top, left + width,
          #              top + height)
          #draw_predict(frame, confidences[i], left, top, right, bottom)
      return final_boxes
  
  
  
  def refined_box(left, top, width, height):
      right = left + width
      bottom = top + height
  
      original_vert_height = bottom - top
      top = int(top + original_vert_height * 0.15)
      bottom = int(bottom - original_vert_height * 0.05)
  
      margin = ((bottom - top) - (right - left)) // 2
      left = left - margin if (bottom - top - right + left) % 2 == 0 else left - margin - 1
  
      right = right + margin
  
      return left, top, right, bottom
  