tensor.h

Go to the documentation of this file.

/*******************************************************************************
 * Copyright (C) 2018-2020 Intel Corporation
 *
 * SPDX-License-Identifier: MIT
 ******************************************************************************/
 
#ifndef __TENSOR_H__
#define __TENSOR_H__
 
#include "metadata/gva_tensor_meta.h"
 
#include <gst/gst.h>
#include <gst/video/gstvideometa.h>
 
#include <stdexcept>
#include <string>
#include <vector>
 
namespace GVA {
 
class Tensor {
    friend class VideoFrame;
#ifdef AUDIO
    friend class AudioFrame;
#endif
 
  public:
    enum class Precision {
        UNSPECIFIED = GVA_PRECISION_UNSPECIFIED, 
        FP32 = GVA_PRECISION_FP32,               
        U8 = GVA_PRECISION_U8                    
    };
 
    enum class Layout {
        ANY = GVA_LAYOUT_ANY,   
        NCHW = GVA_LAYOUT_NCHW, 
        NHWC = GVA_LAYOUT_NHWC, 
        NC = GVA_LAYOUT_NC      
    };
 
    template <class T>
    const std::vector<T> data() const {
        gsize size = 0;
        const void *data = gva_get_tensor_data(_structure, &size);
        if (!data || !size)
            return std::vector<T>();
        return std::vector<T>((T *)data, (T *)((char *)data + size));
    }
 
    std::vector<guint> dims() const {
        GValueArray *arr = NULL;
        gst_structure_get_array(_structure, "dims", &arr);
        std::vector<guint> dims;
        if (arr) {
            for (guint i = 0; i < arr->n_values; ++i)
                dims.push_back(g_value_get_uint(g_value_array_get_nth(arr, i)));
            g_value_array_free(arr);
        }
        return dims;
    }
 
    Precision precision() const {
        if (has_field("precision"))
            return (Precision)get_int("precision");
        else
            return Precision::UNSPECIFIED;
    }
 
    Layout layout() const {
        if (has_field("layout"))
            return (Layout)get_int("layout");
        else
            return Layout::ANY;
    }
 
    std::string layer_name() const {
        return get_string("layer_name");
    }
 
    std::string model_name() const {
        return get_string("model_name");
    }
 
    std::string format() const {
        return get_string("format");
    }
 
    std::string name() const {
        const gchar *name = gst_structure_get_name(_structure);
        if (name)
            return std::string(name);
        return std::string{};
    }
 
    double confidence() const {
        return get_double("confidence");
    }
 
    std::string label() const {
        if (!this->is_detection())
            return get_string("label");
        else
            throw std::runtime_error("Detection GVA::Tensor can't have label.");
    }
 
    std::vector<std::string> fields() const {
        std::vector<std::string> fields;
        int fields_count = gst_structure_n_fields(_structure);
        if (fields_count <= 0)
            return fields;
 
        fields.reserve(fields_count);
        for (int i = 0; i < fields_count; ++i)
            fields.emplace_back(gst_structure_nth_field_name(_structure, i));
        return fields;
    }
 
    bool has_field(const std::string &field_name) const {
        return gst_structure_has_field(_structure, field_name.c_str());
    }
 
    std::string get_string(const std::string &field_name, const std::string &default_value = std::string()) const {
        const gchar *val = gst_structure_get_string(_structure, field_name.c_str());
        return (val) ? std::string(val) : default_value;
    }
 
    int get_int(const std::string &field_name, int32_t default_value = 0) const {
        gint val = default_value;
        gst_structure_get_int(_structure, field_name.c_str(), &val);
        return val;
    }
 
    double get_double(const std::string &field_name, double default_value = 0) const {
        double val = default_value;
        gst_structure_get_double(_structure, field_name.c_str(), &val);
        return val;
    }
 
    void set_string(const std::string &field_name, const std::string &value) {
        gst_structure_set(_structure, field_name.c_str(), G_TYPE_STRING, value.c_str(), NULL);
    }
 
    void set_int(const std::string &field_name, int value) {
        gst_structure_set(_structure, field_name.c_str(), G_TYPE_INT, value, NULL);
    }
 
    void set_double(const std::string &field_name, double value) {
        gst_structure_set(_structure, field_name.c_str(), G_TYPE_DOUBLE, value, NULL);
    }
 
    void set_name(const std::string &name) {
        gst_structure_set_name(_structure, name.c_str());
    }
 
    void set_label(const std::string &label) {
        if (!this->is_detection())
            set_string("label", label);
        else
            throw std::runtime_error("Detection GVA::Tensor can't have label.");
    }
 
    std::string precision_as_string() const {
        Precision precision_value = precision();
        switch (precision_value) {
        case Precision::U8:
            return "U8";
        case Precision::FP32:
            return "FP32";
        default:
            return "UNSPECIFIED";
        }
    }
 
    std::string layout_as_string() const {
        Layout layout_value = layout();
        switch (layout_value) {
        case Layout::NCHW:
            return "NCHW";
        case Layout::NHWC:
            return "NHWC";
        case Layout::NC:
            return "NC";
        default:
            return "ANY";
        }
    }
 
    std::string element_id() const {
        return get_string("element_id");
    }
 
    int label_id() const {
        return get_int("label_id");
    }
 
    bool is_detection() const {
        return name() == "detection";
    }
 
    Tensor(GstStructure *structure) : _structure(structure) {
        if (not _structure)
            throw std::invalid_argument("GVA::Tensor: structure is nullptr");
    }
 
    GstStructure *gst_structure() const {
        return _structure;
    }
 
  protected:
    GstStructure *_structure;
};
 
} // namespace GVA
 
#endif // __TENSOR_H__