public_ops.h

#pragma once
 
#include "blace_index.h"
#include "computation_graph/public_base_op.h"
#include "computation_graph/raw_memory_fetcher.h"
#include "computation_graph/raw_memory_object.h"
#include "ml_core/types.h"
#ifdef BLACE_AI_OPENCV_INTERFACE
#include <opencv2/core/mat.hpp>
#endif
#include <variant>
 
#include "library_defines.h"
 
typedef std::vector<int64_t> SizesVec;
 
namespace blace {
namespace ops {
 
#ifdef BLACE_AI_OPENCV_INTERFACE
class EXPORT_OR_IMPORT FromCVMatOp : public BaseOp {
public:
  FromCVMatOp(cv::Mat cv_mat);
};
 
class EXPORT_OR_IMPORT FromImageFileOp : public BaseOp {
public:
  FromImageFileOp(std::string path);
};
 
#endif
 
class EXPORT_OR_IMPORT Interpolate2DOp : public BaseOp {
public:
  Interpolate2DOp(OpP node, int height, int width,
                  ml_core::Interpolation interpolation, bool align_corners,
                  bool antialias);
};
 
class EXPORT_OR_IMPORT NormalizeImagenetOp : public BaseOp {
public:
  NormalizeImagenetOp(OpP input);
};
 
class EXPORT_OR_IMPORT FromTextOp : public BaseOp {
public:
  FromTextOp(std::string text);
};
 
class EXPORT_OR_IMPORT FromIntOp : public BaseOp {
public:
  FromIntOp(int val);
};
 
class EXPORT_OR_IMPORT FromIntListOp : public BaseOp {
public:
  FromIntListOp(std::vector<int64_t> val);
};
 
class EXPORT_OR_IMPORT FromBoolOp : public BaseOp {
public:
  FromBoolOp(bool val);
};
 
class EXPORT_OR_IMPORT FromFloatOp : public BaseOp {
public:
  FromFloatOp(float val);
};
 
class EXPORT_OR_IMPORT InferenceOp : public BaseOp {
 
public:
  InferenceOp(std::vector<char> model_bytes, std::vector<OpP> inputs,
              ml_core::InferenceArgsCollection inference_args, int return_index,
              std::string payload_folder,
              std::optional<std::string> payload_url = std::nullopt);
 
  InferenceOp(InferenceOp const &e);
  ~InferenceOp();
};
 
class EXPORT_OR_IMPORT MapToRangeOp : public BaseOp {
 
public:
  MapToRangeOp(OpP input, ml_core::ValueRangeEnum range);
};
 
class EXPORT_OR_IMPORT NormalizeToZeroOneOP : public BaseOp {
 
public:
  NormalizeToZeroOneOP(OpP input);
 
  NormalizeToZeroOneOP(OpP input, double min, double max);
 
  NormalizeToZeroOneOP(OpP input, OpP min_in, OpP max_in, double min_out,
                       double max_out);
 
  NormalizeToZeroOneOP(OpP input, double min_in, double max_in, double min_out,
                       double max_out);
 
  NormalizeToZeroOneOP(OpP input, double min_in, double max_in, OpP min_out,
                       OpP max_out);
  NormalizeToZeroOneOP(NormalizeToZeroOneOP const &e);
  ~NormalizeToZeroOneOP();
};
 
class EXPORT_OR_IMPORT ToColorOp : public BaseOp {
 
public:
  ToColorOp(OpP input, ml_core::ColorFormatEnum color_format);
 
  ToColorOp(OpP input, ml_core::ColorFormatEnum color_format,
            ml_core::LAB_NORMS lab_norms);
};
 
class EXPORT_OR_IMPORT FromRawMemoryOp : public BaseOp {
 
public:
  FromRawMemoryOp(std::shared_ptr<blace::RawMemoryObject> mem_object);
};
 
class EXPORT_OR_IMPORT FromRawMemoryFetcherOp : public BaseOp {
 
public:
  FromRawMemoryFetcherOp(std::shared_ptr<blace::RawMemoryFetcher> mem_fetcher,
                         ml_core::DeviceEnum device);
};
 
class EXPORT_OR_IMPORT PrepareForHostCopyOP : public BaseOp {
 
public:
  PrepareForHostCopyOP(OpP input, ml_core::DataTypeEnum data_type,
                       ml_core::ColorFormatEnum color_format,
                       ml_core::OrderEnum tensor_order,
                       ml_core::ValueRangeEnum value_range,
                       ml_core::DeviceEnum device);
};
 
class EXPORT_OR_IMPORT ZerosOp : public BaseOp {
 
public:
  ZerosOp(std::vector<int64_t> sizes, ml_core::OrderEnum order,
          ml_core::DeviceEnum device, ml_core::DataTypeEnum data_type,
          ml_core::ColorFormatEnum color_format);
  ZerosOp(ZerosOp const &e);
  ~ZerosOp();
};
 
class EXPORT_OR_IMPORT OnesOp : public BaseOp {
 
public:
  OnesOp(std::vector<int64_t> sizes, ml_core::OrderEnum order,
         ml_core::DeviceEnum device, ml_core::DataTypeEnum data_type,
         ml_core::ColorFormatEnum color_format);
};
 
class EXPORT_OR_IMPORT IndexPutOp : public BaseOp {
 
public:
  IndexPutOp(blace::ops::OpP input, ml_core::BlaceIndexVec indices,
             blace::ops::OpP val);
  IndexPutOp(blace::ops::OpP input, ml_core::BlaceIndexVec indices, double val);
  IndexPutOp(blace::ops::OpP input, ml_core::BlaceIndexVec indices, float val);
  IndexPutOp(blace::ops::OpP input, ml_core::BlaceIndexVec indices, int val);
};
 
class EXPORT_OR_IMPORT NoneOp : public BaseOp {
 
public:
  NoneOp();
};
 
class EXPORT_OR_IMPORT SaveImageOp : public BaseOp {
 
public:
  SaveImageOp(blace::ops::OpP input, std::string filename);
};
 
class EXPORT_OR_IMPORT SaveAudioFileOp : public BaseOp {
 
public:
  SaveAudioFileOp(blace::ops::OpP input, std::string filename);
};
 
class EXPORT_OR_IMPORT IndexOp : public BaseOp {
public:
  IndexOp(blace::ops::OpP input, ml_core::BlaceIndexVec indices,
          std::optional<ml_core::ColorFormatEnum> color_format = std::nullopt);
};
 
class EXPORT_OR_IMPORT DrawRectangles : public BaseOp {
 
public:
  DrawRectangles(blace::ops::OpP img, blace::ops::OpP bounding_boxes, int r,
                 int g, int b, int thickness);
};
 
class EXPORT_OR_IMPORT AddOp : public BaseOp {
public:
  AddOp(blace::ops::OpP a, blace::ops::OpP b);
  AddOp(blace::ops::OpP a, double b);
  AddOp(blace::ops::OpP a, double b, ml_core::ValueRangeEnum norm);
};
 
class EXPORT_OR_IMPORT SubOp : public BaseOp {
public:
  SubOp(blace::ops::OpP a, blace::ops::OpP b);
};
 
class EXPORT_OR_IMPORT SumOp : public BaseOp {
 
public:
  SumOp(blace::ops::OpP input, std::vector<int64_t> sizes, bool keepdim);
};
 
} // namespace ops
} // namespace blace