Replace raw "keypoints"/"classification_result" strings with named constants

Define TENSOR_TYPE_KEYPOINTS and TENSOR_TYPE_CLASSIFICATION constants
in tensor.h (C++) and tensor.py (Python), then replace all raw string
literals across the codebase with references to these constants.

Additionally, simplify the tensor type filter in jsonconverter.cpp:
change the confusing `!has_field("type") || type() == "keypoints"`
condition to a direct `type() != TENSOR_TYPE_CLASSIFICATION` check,
which clearly expresses the intent of excluding classification tensors
from the raw tensors section.

Author: OskarFiedot

include/dlstreamer/gst/videoanalytics/region_of_interest.h

@@ -231,8 +231,9 @@ class RegionOfInterest {
         for (GList *l = meta->params; l; l = g_list_next(l)) {
             GstStructure *s = GST_STRUCTURE(l->data);
             const char *type = gst_structure_get_string(s, "type");
-            if (not gst_structure_has_name(s, "object_id") && (type == nullptr || strcmp(type, "keypoints") != 0) &&
-                (type == nullptr || strcmp(type, "classification_result") != 0)) {
+            if (not gst_structure_has_name(s, "object_id") &&
+                (type == nullptr || strcmp(type, TENSOR_TYPE_KEYPOINTS) != 0) &&
+                (type == nullptr || strcmp(type, TENSOR_TYPE_CLASSIFICATION) != 0)) {
                 _tensors.emplace_back(s);
                 if (_tensors.back().is_detection())
                     _detection = &_tensors.back();

include/dlstreamer/gst/videoanalytics/tensor.h

@@ -27,6 +27,11 @@
 
 namespace GVA {
 
+/// Tensor type string for keypoints data (e.g. human pose estimation results)
+constexpr const char *TENSOR_TYPE_KEYPOINTS = "keypoints";
+/// Tensor type string for classification results
+constexpr const char *TENSOR_TYPE_CLASSIFICATION = "classification_result";
+
 /**
  * @brief This class represents tensor - map-like storage for inference result information, such as output blob
  * description (output layer dims, layout, rank, precision, etc.), inference result in a raw and interpreted forms.
@@ -610,7 +615,7 @@ class Tensor {
      */
     bool convert_to_meta(GstAnalyticsMtd *mtd, GstAnalyticsODMtd *od_mtd, GstAnalyticsRelationMeta *meta) const {
 
-        if (type() == "keypoints") {
+        if (type() == TENSOR_TYPE_KEYPOINTS) {
             GstAnalyticsGroupMtd *group_mtd = reinterpret_cast<GstAnalyticsGroupMtd *>(mtd);
             const std::vector<guint> dimensions = dims();
             const std::vector<float> raw_positions = data<float>();
@@ -657,7 +662,7 @@ class Tensor {
                 throw std::runtime_error("Failed to create keypoints group meta");
 
             return true;
-        } else if (type() == "classification_result") {
+        } else if (type() == TENSOR_TYPE_CLASSIFICATION) {
             GstAnalyticsClsMtd *cls_mtd = mtd;
             gfloat confidence = this->confidence();
             GQuark label = g_quark_from_string(this->label().c_str());
@@ -789,11 +794,11 @@ class Tensor {
             }
 
             // create keypoint tensor
-            GstStructure *gst_structure = gst_structure_new_empty("keypoints");
+            GstStructure *gst_structure = gst_structure_new_empty(TENSOR_TYPE_KEYPOINTS);
             Tensor tensor(gst_structure);
 
             tensor.set_precision(Precision::FP32);
-            tensor.set_type("keypoints");
+            tensor.set_type(TENSOR_TYPE_KEYPOINTS);
             tensor.set_format(format_str);
 
             tensor.set_dims({static_cast<guint>(keypoint_count), static_cast<guint>(keypoint_dimension)});
@@ -813,7 +818,7 @@ class Tensor {
             gsize class_count = gst_analytics_cls_mtd_get_length(cls_mtd);
 
             GstStructure *tensor = gst_structure_new_empty("classification");
-            gst_structure_set(tensor, "type", G_TYPE_STRING, "classification_result", NULL);
+            gst_structure_set(tensor, "type", G_TYPE_STRING, TENSOR_TYPE_CLASSIFICATION, NULL);
 
             gfloat result_confidence = 0;
             std::string result_label;

python/gstgva/__init__.py

@@ -1,9 +1,9 @@
 # ==============================================================================
-# Copyright (C) 2018-2020 Intel Corporation
+# Copyright (C) 2018-2026 Intel Corporation
 #
 # SPDX-License-Identifier: MIT
 # ==============================================================================
 
 from .region_of_interest import RegionOfInterest
 from .video_frame import VideoFrame
-from .tensor import Tensor
+from .tensor import Tensor, TENSOR_TYPE_KEYPOINTS, TENSOR_TYPE_CLASSIFICATION

python/gstgva/region_of_interest.py

@@ -24,7 +24,7 @@
 from gi.repository import GstVideo, GLib, GObject, Gst, GstAnalytics, DLStreamerMeta
 # pylint: enable=no-name-in-module,unused-import
 
-from .tensor import Tensor
+from .tensor import Tensor, TENSOR_TYPE_KEYPOINTS, TENSOR_TYPE_CLASSIFICATION
 from .util import VideoRegionOfInterestMeta, GstStructureHandle
 from .util import libgst, libgstvideo
 from . import meta_registry  # noqa: F401 — registers DLStreamerMeta types with GstAnalytics
@@ -57,8 +57,8 @@ def __init__(
                 tensor = Tensor(tensor_structure)
                 if (
                     tensor.name() != "object_id"
-                    and tensor.type() != "keypoints"
-                    and tensor.type() != "classification_result"
+                    and tensor.type() != TENSOR_TYPE_KEYPOINTS
+                    and tensor.type() != TENSOR_TYPE_CLASSIFICATION
                 ):
                     self._tensors.append(tensor)
                     if tensor.is_detection():

python/gstgva/tensor.py

@@ -28,6 +28,11 @@
 )
 from .util import GVATensorMeta
 
+## Tensor type string for keypoints data (e.g. human pose estimation results)
+TENSOR_TYPE_KEYPOINTS = "keypoints"
+## Tensor type string for classification results
+TENSOR_TYPE_CLASSIFICATION = "classification_result"
+
 
 ## @brief This class represents tensor - map-like storage for inference result information, such as output blob
 # description (output layer dims, layout, rank, precision, etc.), inference result in a raw and interpreted forms.
@@ -495,7 +500,7 @@ def convert_to_meta(
         #  @param od_meta parent object-detection metadata (required for keypoints)
         #  @return GstAnalyticsMtd on success, None if tensor type is not supported
         mtd = None
-        if self.type() == "keypoints":
+        if self.type() == TENSOR_TYPE_KEYPOINTS:
             dimensions = self.dims()
             raw_data = self.data()
             confidence_val = self.confidence()
@@ -551,7 +556,7 @@ def convert_to_meta(
 
             mtd = group_mtd
 
-        elif self.type() == "classification_result":
+        elif self.type() == TENSOR_TYPE_CLASSIFICATION:
             confidence_level = (
                 self.confidence() if self.confidence() is not None else 0.0
             )
@@ -661,11 +666,11 @@ def convert_to_tensor(mtd: GstAnalytics.Mtd) -> ctypes.c_void_p | None:
                             point_connections.append(i)
 
             # create keypoint tensor
-            structure = libgst.gst_structure_new_empty("keypoints".encode("utf-8"))
+            structure = libgst.gst_structure_new_empty(TENSOR_TYPE_KEYPOINTS.encode("utf-8"))
             tensor = Tensor(structure)
 
             tensor.set_precision(Tensor.PRECISION.FP32)
-            tensor.set_type("keypoints")
+            tensor.set_type(TENSOR_TYPE_KEYPOINTS)
             tensor.set_format(semantic_tag)
 
             tensor.set_dims([keypoint_count, keypoint_dimension])
@@ -704,7 +709,7 @@ def convert_to_tensor(mtd: GstAnalytics.Mtd) -> ctypes.c_void_p | None:
                     result_confidence = confidence
 
             tensor.set_name("classification")
-            tensor["type"] = "classification_result"
+            tensor["type"] = TENSOR_TYPE_CLASSIFICATION
             tensor.set_label(result_label)
             tensor["confidence"] = result_confidence
 

src/monolithic/gst/elements/gvametaconvert/jsonconverter.cpp

@@ -289,7 +289,7 @@ json convert_frame_tensors(GstGvaMetaConvert *converter, GstBuffer *buffer) {
     const std::vector<GVA::Tensor> tensors = video_frame.tensors();
     json array = json::array();
     for (auto &tensor : video_frame.tensors()) {
-        if (!tensor.has_field("type") || tensor.type() == "keypoints") {
+        if (tensor.type() != GVA::TENSOR_TYPE_CLASSIFICATION) {
             array.push_back(convert_tensor(tensor));
         }
     }
@@ -606,7 +606,7 @@ json convert_lidar_inference_meta(GstGvaMetaConvert *converter, GstBuffer *buffe
                 objects.push_back(detection);
         }
 
-        if (converter->add_tensor_data && (!tensor.has_field("type") || tensor.type() == "keypoints") &&
+        if (converter->add_tensor_data && tensor.type() != GVA::TENSOR_TYPE_CLASSIFICATION &&
             tensor.has_field("data_buffer")) {
             tensors.push_back(convert_tensor(tensor));
         }

src/monolithic/gst/elements/gvawatermark/gstgvawatermarkimpl.cpp

@@ -1056,7 +1056,7 @@ void Impl::preparePrimsForTensor(const GVA::Tensor &tensor, GVA::Rect<double> re
  */
 void Impl::preparePrimsForKeypoints(const GVA::Tensor &tensor, GVA::Rect<double> rectangle,
                                     std::vector<render::Prim> &prims) const {
-    if (tensor.type() != "keypoints")
+    if (tensor.type() != GVA::TENSOR_TYPE_KEYPOINTS)
         return;
 
     const auto keypoints_data = tensor.data<float>();

src/monolithic/gst/inference_elements/common/post_processor/converters/to_roi/blob_to_roi_converter.h

@@ -9,6 +9,7 @@
 #include "post_processor/blob_to_meta_converter.h"
 #include "post_processor/post_proc_common.h"
 
+#include <dlstreamer/gst/videoanalytics/tensor.h>
 #include <gst/gst.h>
 
 #include <map>
@@ -100,7 +101,7 @@ class BlobToROIConverter : public BlobToMetaConverter {
             for (auto &structure : this->tensors) {
                 GVA::Tensor tensor(structure);
 
-                if (tensor.type() != "keypoints") {
+                if (tensor.type() != GVA::TENSOR_TYPE_KEYPOINTS) {
                     continue;
                 };
 

src/monolithic/gst/inference_elements/common/post_processor/converters/to_roi/centerface.cpp

@@ -12,6 +12,7 @@
 #include "safe_arithmetic.hpp"
 
 #include <dlstreamer/gst/metadata/gstanalyticskeypointdescriptor.h>
+#include <dlstreamer/gst/videoanalytics/tensor.h>
 #include <gst/gst.h>
 #include <opencv2/opencv.hpp>
 
@@ -94,8 +95,8 @@ const float *CenterfaceConverter::parseOutputBlob(const OutputBlobs &output_blob
 void CenterfaceConverter::addLandmarksTensor(DetectedObject &detected_object, const float *landmarks,
                                              int num_of_landmarks) const {
     GstStructure *tensor = gst_structure_copy(getModelProcOutputInfo().get());
-    gst_structure_set_name(tensor, "keypoints");
-    gst_structure_set(tensor, "type", G_TYPE_STRING, "keypoints", NULL);
+    gst_structure_set_name(tensor, GVA::TENSOR_TYPE_KEYPOINTS);
+    gst_structure_set(tensor, "type", G_TYPE_STRING, GVA::TENSOR_TYPE_KEYPOINTS, NULL);
     gst_structure_set(tensor, "precision", G_TYPE_INT, GVA_PRECISION_FP32, NULL);
     gst_structure_set(tensor, "format", G_TYPE_STRING, GST_ANALYTICS_KEYPOINT_FACE_CENTERFACE_5, NULL);
 

src/monolithic/gst/inference_elements/common/post_processor/converters/to_roi/yolo_v26.cpp

@@ -10,6 +10,7 @@
 #include "inference_backend/logger.h"
 
 #include <dlstreamer/gst/metadata/gstanalyticskeypointdescriptor.h>
+#include <dlstreamer/gst/videoanalytics/tensor.h>
 #include <gst/gst.h>
 #include <opencv2/opencv.hpp>
 #include <string>
@@ -121,8 +122,8 @@ void YOLOv26PoseConverter::parseOutputBlob(const float *data, const std::vector<
             GstStructure *gst_structure = gst_structure_copy(getModelProcOutputInfo().get());
             GVA::Tensor tensor(gst_structure);
 
-            tensor.set_name("keypoints");
-            tensor.set_type("keypoints");
+            tensor.set_name(GVA::TENSOR_TYPE_KEYPOINTS);
+            tensor.set_type(GVA::TENSOR_TYPE_KEYPOINTS);
             tensor.set_format(coco17_descriptor->semantic_tag);
 
             // set tensor data (positions)