154 Bbox solely owned area (#155)

* implemented solely owned area computation for bboxes
* unified package versions and upgraded PyO3 to 0.22
* fixed opentelemetry init for null output (was to stdout)
* implemented bbox association function
* implemented ordering and fixed review comments

Cargo.toml

@@ -8,11 +8,25 @@ members = [
 ]
 
 [workspace.dependencies]
+anyhow = "1.0"
+evalexpr = { version = "11", features = ["rand", "regex_support"] }
+geo = "0.28"
+lazy_static = "1.5"
+log = "0.4"
 savant_core = { path = "savant_core" }
 savant_core_py = { path = "savant_core_py" }
+hashbrown = { version = "0.15", features = ["serde"] }
+opentelemetry = "0.24"
+opentelemetry-otlp = { version = "0.17", features = ["http-json", "http-proto", "tls", "reqwest-rustls"] }
+parking_lot = { version = "0.12", features = ["deadlock_detection"] }
+pyo3 = "0.22"
+pyo3-build-config = "0.22"
+serde = { version = "1.0", features = ["derive"] }
+serde_json = "1.0"
+thiserror = "1.0"
 
 [workspace.package]
-version = "0.4.0"
+version = "0.4.1"
 edition = "2021"
 authors = ["Ivan Kudriavtsev <ivan.a.kudryavtsev@gmail.com>"]
 description = "Savant Rust core functions library"

python/frame_pipeline_evolution.py

@@ -4,42 +4,96 @@
 
 set_log_level(LogLevel.Trace)
 
-from savant_rs.pipeline import VideoPipelineStagePayloadType, VideoPipeline, VideoPipelineConfiguration, StageFunction
-from savant_rs.primitives import VideoFrame, VideoFrameContent, VideoFrameTranscodingMethod, VideoFrameTransformation, \
-    Attribute, AttributeValue
+from savant_rs.pipeline import (
+    VideoPipelineStagePayloadType,
+    VideoPipeline,
+    VideoPipelineConfiguration,
+    StageFunction,
+)
+from savant_rs.primitives import (
+    VideoFrame,
+    VideoFrameContent,
+    VideoFrameTranscodingMethod,
+    VideoFrameTransformation,
+    Attribute,
+    AttributeValue,
+)
 from savant_rs.utils import gen_frame, TelemetrySpan, enable_dl_detection
-from savant_rs import init_jaeger_tracer
 
 if __name__ == "__main__":
     savant_rs.version()
     enable_dl_detection()  # enables internal DL detection (checks every 5 secs)
-    log(LogLevel.Info, "root", "Begin operation", dict(savant_rs_version=savant_rs.version()))
-    init_jaeger_tracer("demo-pipeline", "localhost:6831")
+    log(
+        LogLevel.Info,
+        "root",
+        "Begin operation",
+        dict(savant_rs_version=savant_rs.version()),
+    )
 
     conf = VideoPipelineConfiguration()
     conf.append_frame_meta_to_otlp_span = True
 
-    frame = VideoFrame(source_id="test", framerate="30/1", width=1400, height=720,
-                       content=VideoFrameContent.internal(bytes("this is it", 'utf-8')),
-                       transcoding_method=VideoFrameTranscodingMethod.Encoded, codec="h264", keyframe=True,
-                       time_base=(1, 1000000), pts=10000, dts=10000, duration=10)
+    frame = VideoFrame(
+        source_id="test",
+        framerate="30/1",
+        width=1400,
+        height=720,
+        content=VideoFrameContent.internal(bytes("this is it", "utf-8")),
+        transcoding_method=VideoFrameTranscodingMethod.Encoded,
+        codec="h264",
+        keyframe=True,
+        time_base=(1, 1000000),
+        pts=10000,
+        dts=10000,
+        duration=10,
+    )
     frame.add_transformation(VideoFrameTransformation.initial_size(1920, 1080))
     frame.add_transformation(VideoFrameTransformation.scale(1280, 720))
     frame.add_transformation(VideoFrameTransformation.padding(120, 0, 0, 0))
     frame.add_transformation(VideoFrameTransformation.resulting_size(1400, 720))
 
-    frame.set_attribute(Attribute("Configuration", "CamMode",
-                                  [AttributeValue.string("fisheye"), AttributeValue.integers([180, 180])],
-                                  "PlatformConfig", True))
+    frame.set_attribute(
+        Attribute(
+            "Configuration",
+            "CamMode",
+            [AttributeValue.string("fisheye"), AttributeValue.integers([180, 180])],
+            "PlatformConfig",
+            True,
+        )
+    )
 
     print(frame.json_pretty)
 
-    p = VideoPipeline("video-pipeline-root", [
-        ("input", VideoPipelineStagePayloadType.Frame, StageFunction.none(), StageFunction.none()),
-        ("proc1", VideoPipelineStagePayloadType.Batch, StageFunction.none(), StageFunction.none()),
-        ("proc2", VideoPipelineStagePayloadType.Batch, StageFunction.none(), StageFunction.none()),
-        ("output", VideoPipelineStagePayloadType.Frame, StageFunction.none(), StageFunction.none()),
-    ], conf)
+    p = VideoPipeline(
+        "video-pipeline-root",
+        [
+            (
+                "input",
+                VideoPipelineStagePayloadType.Frame,
+                StageFunction.none(),
+                StageFunction.none(),
+            ),
+            (
+                "proc1",
+                VideoPipelineStagePayloadType.Batch,
+                StageFunction.none(),
+                StageFunction.none(),
+            ),
+            (
+                "proc2",
+                VideoPipelineStagePayloadType.Batch,
+                StageFunction.none(),
+                StageFunction.none(),
+            ),
+            (
+                "output",
+                VideoPipelineStagePayloadType.Frame,
+                StageFunction.none(),
+                StageFunction.none(),
+            ),
+        ],
+        conf,
+    )
     p.sampling_period = 10
 
     root_span = TelemetrySpan("new-telemetry")

python/primitives/bbox/utils.py

@@ -0,0 +1,41 @@
+from savant_rs.primitives.geometry import (
+    RBBox,
+    solely_owned_areas,
+    associate_bboxes,
+)
+from savant_rs.utils import BBoxMetricType
+
+red = RBBox.ltrb(0.0, 2.0, 2.0, 4.0)
+green = RBBox.ltrb(1.0, 3.0, 5.0, 5.0)
+yellow = RBBox.ltrb(1.0, 1.0, 3.0, 6.0)
+purple = RBBox.ltrb(4.0, 0.0, 7.0, 2.0)
+
+areas = solely_owned_areas([red, green, yellow, purple], parallel=True)
+
+red = areas[0]
+green = areas[1]
+yellow = areas[2]
+purple = areas[3]
+
+assert red == 2.0
+assert green == 4.0
+assert yellow == 5.0
+assert purple == 6.0
+
+lp1 = RBBox.ltrb(0.0, 1.0, 2.0, 2.0)
+lp2 = RBBox.ltrb(5.0, 2.0, 8.0, 3.0)
+lp3 = RBBox.ltrb(100.0, 0.0, 6.0, 3.0)
+owner1 = RBBox.ltrb(1.0, 0.0, 6.0, 3.0)
+owner2 = RBBox.ltrb(6.0, 1.0, 9.0, 4.0)
+
+associations_iou = associate_bboxes(
+    [lp1, lp2, lp3], [owner1, owner2], BBoxMetricType.IoU, 0.01
+)
+
+lp1_associations = associations_iou[0]
+lp2_associations = associations_iou[1]
+lp3_associations = associations_iou[2]
+
+assert list(map(lambda t: t[0], lp1_associations)) == [0]
+assert list(map(lambda t: t[0], lp2_associations)) == [1, 0]
+assert lp3_associations == []