ITEP-69567: Update openvino version (#221)

Update the openvino and model-api versions to latest.
Add changes to get BAT to pass.

Author: saratpoluri

percebro/requirements-runtime.txt

@@ -14,8 +14,8 @@ ntplib
 numpy>=1.16.6,<=1.26.4
 onvif-zeep
 open3d-cpu
-openvino-model-api==0.2.5
-openvino==2024.6.0
+openvino-model-api==0.3.0.3
+openvino==2025.2.0
 ovmsclient
 paho-mqtt
 pillow

percebro/src/detector.py

@@ -9,7 +9,6 @@
 import uuid
 
 import cv2
-from model_api.models.open_pose import OpenPoseDecoder
 import numpy as np
 from openvino.runtime import Core
 from ovmsclient import make_grpc_client
@@ -365,8 +364,7 @@ def modelPreconfigure(self):
     if self.device == "CPU":
       self.config = {'NUM_STREAMS': self.ov_cores,
                      'INFERENCE_NUM_THREADS': str(self.ov_cores),
-                     'PERFORMANCE_HINT': 'THROUGHPUT',
-                     'AFFINITY': 'CORE'}
+                     'PERFORMANCE_HINT': 'THROUGHPUT'}
       self.core.set_property(device_name=self.device, properties=self.config)
 
       if self.plugin:
@@ -770,150 +768,6 @@ def deserializeOutput(self, data):
     dec_data = json.loads(data)
     return dec_data
 
-class PoseEstimator(Detector):
-  POSE_PAIRS = ((15, 13), (13, 11), (16, 14), (14, 12), (11, 12), (5, 11),
-                (6, 12), (5, 6), (5, 7), (6, 8), (7, 9), (8, 10), (1, 2),
-                (0, 1), (0, 2), (1, 3), (2, 4), (3, 5), (4, 6))
-
-  bodyPartKP = ['Nose', 'Left-Eye', 'Right-Eye', 'Left-Ear', 'Right-Ear',
-                'Left-Shoulder', 'Right-Shoulder', 'Left-Elbow', 'Right-Elbow',
-                'Left-Wrist', 'Right-Wrist', 'Left-Hip', 'Right-Hip',
-                'Left-Knee', 'Right-Knee', 'Left-Ankle', 'Right-Ankle']
-
-  colors = [  (255,0,0),  (255,85,0), (255,170,0), (255,255,0), (170,255,0),  (85,255,0),
-              (0,255,0),  (0,255,85), (0,255,170), (0,255,255), (0,170,255),  (0,85,255),
-              (0,0,255),  (85,0,255), (170,0,255), (255,0,255), (255,0,170)]
-
-  def __init__(self, asynchronous=False, distributed=Distributed.NONE):
-    super().__init__(asynchronous=asynchronous, distributed=distributed)
-    self.decoder = OpenPoseDecoder()
-    self.saveDict = True
-
-    return
-
-  def setParameters(self, model, device, plugin, threshold, ov_cores):
-    super().setParameters(model, device, plugin, threshold, ov_cores)
-
-    if self.distributed == Distributed.OVMS:
-      self.output_keys = list(self.model_metadata["outputs"].keys())
-      self.n, self.c, self.h, self.w = self.model_metadata["inputs"]["data"]["shape"]
-    else:
-      self.output_keys = [out.get_any_name() for out in self.model.outputs]
-      self.n, self.c, self.h, self.w = self.model.inputs[0].shape
-
-    return
-
-  def postprocess(self, result):
-    people = []
-    poses = self.processResults(result)
-
-    for pose in poses:
-      points = pose[:, :2]
-      points_scores = pose[:, 2]
-
-      hpe_bounds = [None] * 4
-      published_pose = []
-      for point, score in zip(points, points_scores):
-        if len(point) == 0 or score == 0:
-          published_pose.append(())
-          continue
-
-        point_x, point_y = point[0], point[1]
-        published_pose.append((point_x, point_y))
-
-        if hpe_bounds[0] is None or point_x < hpe_bounds[0]:
-          hpe_bounds[0] = point_x
-        if hpe_bounds[2] is None or point_x > hpe_bounds[2]:
-          hpe_bounds[2] = point_x
-        if hpe_bounds[1] is None or point_y < hpe_bounds[1]:
-          hpe_bounds[1] = point_y
-        if hpe_bounds[3] is None or point_y > hpe_bounds[3]:
-          hpe_bounds[3] = point_y
-
-      if hpe_bounds[0] == None:
-        continue
-
-      if self.hasKeypoints(published_pose,
-                          ('Right-Hip', 'Right-Knee', 'Right-Ankle',
-                          'Left-Hip', 'Left-Knee', 'Left-Ankle')) \
-          or self.hasKeypoints(published_pose,
-                              ('Right-Shoulder', 'Right-Elbow', 'Right-Wrist',
-                              'Left-Shoulder', 'Left-Elbow', 'Left-Wrist')):
-
-        bounds = Rectangle(origin=Point(hpe_bounds[0], hpe_bounds[1]),
-                           opposite=Point(hpe_bounds[2], hpe_bounds[3]))
-        if bounds.width == 0 or bounds.height == 0:
-          continue
-
-        comw = bounds.width / 3
-        comh = bounds.height / 4
-        center_of_mass = Rectangle(origin=Point(bounds.x + comw, bounds.y + comh),
-                                   size=(comw, comh))
-        person = {'id': len(people) + 1,
-                  'category': 'person',
-                  'bounding_box': bounds.asDict,
-                  'center_of_mass': center_of_mass.asDict,
-                  'pose': published_pose}
-        people.append(person)
-
-    return people
-
-  def hasKeypoints(self, pose, points):
-    for point in points:
-      idx = self.bodyPartKP.index(point)
-      if idx >= len(pose) or not len(pose[idx]):
-        return False
-    return True
-
-  def processResults(self, results):
-
-    pafs = results.data[self.output_keys[0]]
-    heatmaps = results.data[self.output_keys[1]]
-
-    pooled_heatmaps = np.array(
-        [[self.maxpool(h, kernel_size=3, stride=1, padding=1) for h in heatmaps[0]]])
-    nms_heatmaps = self.nonMaxSuppression(heatmaps, pooled_heatmaps)
-
-    image_shape = results.save
-    poses, _ = self.decoder(heatmaps, nms_heatmaps, pafs)
-
-    if self.distributed == Distributed.OVMS:
-      output_shape = self.model_metadata["outputs"][self.output_keys[0]]['shape']
-    else:
-      output_shape = self.model.get_output_shape(0)
-
-    image_width, image_height = image_shape
-    _, _, output_height, output_width = output_shape
-    x_scale, y_scale = image_width / output_width, image_height / output_height
-
-    if self.keep_aspect:
-      height_ratio = self.h / image_height
-      width_ratio = self.w / image_width
-      if height_ratio <= width_ratio:
-        x_scale = x_scale / (height_ratio / width_ratio)
-      else:
-        y_scale = y_scale / (width_ratio / height_ratio)
-
-    poses[:, :, :2] *= (x_scale, y_scale)
-    return poses
-
-  def maxpool(self, matrix, kernel_size, stride, padding):
-    matrix = np.pad(matrix, padding, mode="constant")
-    output_shape = ((matrix.shape[0] - kernel_size) // stride + 1,
-                    (matrix.shape[1] - kernel_size) // stride + 1,)
-
-    kernel_size = (kernel_size, kernel_size)
-
-    matrix_view = np.lib.stride_tricks.as_strided(matrix,
-        shape=output_shape + kernel_size,
-        strides=(stride * matrix.strides[0], stride * matrix.strides[1]) + matrix.strides)
-    matrix_view = matrix_view.reshape(-1, *kernel_size)
-
-    return matrix_view.max(axis=(1, 2)).reshape(output_shape)
-
-  def nonMaxSuppression(self, result, pooled_result):
-    return result * (result == pooled_result)
-
 class REIDDetector(Detector):
 
   def postprocess(self, result):

percebro/src/detector_geti.py

@@ -7,18 +7,12 @@
 import numpy as np
 
 from scene_common import log
-from openvino.runtime import Core
-from model_api.adapters import OpenvinoAdapter, create_core
 from model_api.models import Model
-from model_api.models.utils import Detection
+from model_api.models.result.detection import DetectionResult
 from detector import Detector, Distributed, IAData
-from wrapper_otxssd import OTXSSDModel
 
 from scene_common.geometry import Point, Rectangle
 
-def getDetectionCoords(detection : Detection):
-  return [detection.xmin, detection.ymin, detection.xmax, detection.ymax]
-
 class GetiDetector(Detector):
   def __init__(self, asynchronous=False, distributed=Distributed.NONE):
     super().__init__(asynchronous=asynchronous, distributed=distributed)
@@ -77,54 +71,54 @@ def postprocess(self, result):
     # 'predictions' is now of type DetectionResult
     # which is a tuple of (detections, saliency_map, feature_vector).
     # Therefore just looking at first tuple member.
-    for res in predictions[0]:
+    for idx, res in enumerate(predictions.scores):
       # Leave early when we're done with high confidence detections
-      if res.score < self.threshold:
+      if res < self.threshold:
         continue
 
       # Avoid crash due to out of bounds index
-      if res.id >= len(self.categories):
+      if idx >= len(self.categories):
         log.debug("Skipping out of bounds category index")
         continue
 
-      if self.categories[res.id] in self.blacklist:
-        log.debug(f"Skipping blacklisted category {self.categories[res.id]}")
+      if self.categories[idx] in self.blacklist:
+        log.debug(f"Skipping blacklisted category {self.categories[idx]}")
         continue
 
       bounds = [None] * 4
-      rect = getDetectionCoords(res)
+      rect = predictions.bboxes[idx]
       bounds[0] = rect[0]
       bounds[1] = rect[1]
       bounds[2] = rect[2]
       bounds[3] = rect[3]
       # Avoid reporting invalid detections (0 height or width)
       if bounds[0] == bounds[2] \
-          or bounds[1] == bounds[3]:
+        or bounds[1] == bounds[3]:
         continue
 
       if bounds[2] < bounds[0]:
         tmp = bounds[0]
         bounds[0] = bounds[2]
         bounds[2] = tmp
       if bounds[3] < bounds[1]:
-        tmp = bounds[0]
-        bounds[0] = bounds[3]
+        tmp = bounds[1]
+        bounds[1] = bounds[3]
         bounds[3] = tmp
 
       bound_box = Rectangle(origin=Point(bounds[0], bounds[1]),
-                            opposite=Point(bounds[2], bounds[3]))
+                opposite=Point(bounds[2], bounds[3]))
       comw = bound_box.width / 3
       comh = bound_box.height / 4
       center_of_mass = Rectangle(origin=Point(bound_box.x + comw, bound_box.y + comh),
-                                 size=(comw, comh))
-      object = {
+                   size=(comw, comh))
+      detected_object = {
         'id': len(found) + 1,
-        'category': self.categories[res.id] ,
-        'confidence': float(res.score),
+        'category': self.categories[idx],
+        'confidence': float(res),
         'bounding_box': bound_box.asDict,
         'center_of_mass': center_of_mass.asDict
       }
-      found.append( object )
+      found.append(detected_object)
 
     return found