result.h

// Copyright (c) 2022 PaddlePaddle Authors. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
#pragma once
#include "fastdeploy/fastdeploy_model.h"
#include "opencv2/core/core.hpp"
#include <set>

namespace fastdeploy {
namespace vision {
enum FASTDEPLOY_DECL ResultType {
  UNKNOWN_RESULT,
  CLASSIFY,
  DETECTION,
  SEGMENTATION,
  OCR,
  MOT,
  FACE_DETECTION,
  FACE_ALIGNMENT,
  FACE_RECOGNITION,
  MATTING,
  MASK,
  KEYPOINT_DETECTION,
  HEADPOSE,
};

struct FASTDEPLOY_DECL BaseResult {
  ResultType type = ResultType::UNKNOWN_RESULT;
};

struct FASTDEPLOY_DECL ClassifyResult : public BaseResult {
  ClassifyResult() = default;
  std::vector<int32_t> label_ids;
  std::vector<float> scores;
  ResultType type = ResultType::CLASSIFY;

  void Resize(int size);

  void Clear();

  void Free();

  ClassifyResult(const ClassifyResult& other) = default;
  ClassifyResult& operator=(ClassifyResult&& other);

  std::string Str();
};

struct FASTDEPLOY_DECL Mask : public BaseResult {
  std::vector<uint8_t> data;
  std::vector<int64_t> shape;  // (H,W) ...
  ResultType type = ResultType::MASK;

  void Clear();

  void Free();

  void* Data() { return data.data(); }

  const void* Data() const { return data.data(); }

  void Reserve(int size);

  void Resize(int size);

  std::string Str();
};


struct FASTDEPLOY_DECL DetectionResult : public BaseResult {
  DetectionResult() = default;
  std::vector<std::array<float, 4>> boxes;
  std::vector<float> scores;
  std::vector<int32_t> label_ids;
  std::vector<Mask> masks;
  bool contain_masks = false;

  ResultType type = ResultType::DETECTION;

  DetectionResult(const DetectionResult& res);
  DetectionResult& operator=(DetectionResult&& other);

  void Clear();

  void Free();

  void Reserve(int size);

  void Resize(int size);

  std::string Str();
};

struct FASTDEPLOY_DECL KeyPointDetectionResult : public BaseResult {
  std::vector<std::array<float, 2>> keypoints;
  std::vector<float> scores;
  int num_joints = -1;

  ResultType type = ResultType::KEYPOINT_DETECTION;
  void Clear();

  void Free();

  void Reserve(int size);

  void Resize(int size);

  std::string Str();
};

struct FASTDEPLOY_DECL OCRResult : public BaseResult {
  std::vector<std::array<int, 8>> boxes;

  std::vector<std::string> text;
  std::vector<float> rec_scores;

  std::vector<float> cls_scores;
  std::vector<int32_t> cls_labels;

  ResultType type = ResultType::OCR;

  void Clear();

  std::string Str();
};

struct FASTDEPLOY_DECL MOTResult : public BaseResult {
  std::vector<std::array<int, 4>> boxes;
  std::vector<int> ids;
  std::vector<float> scores;
  std::vector<int> class_ids;

  ResultType type = ResultType::MOT;
  void Clear();
  std::string Str();
};



struct FASTDEPLOY_DECL FaceDetectionResult : public BaseResult {
  std::vector<std::array<float, 4>> boxes;
  std::vector<std::array<float, 2>> landmarks;
  std::vector<float> scores;
  ResultType type = ResultType::FACE_DETECTION;
  int landmarks_per_face;

  FaceDetectionResult() { landmarks_per_face = 0; }
  FaceDetectionResult(const FaceDetectionResult& res);
  void Clear();

  void Free();

  void Reserve(int size);

  void Resize(int size);
  std::string Str();
};

struct FASTDEPLOY_DECL FaceAlignmentResult : public BaseResult {
  std::vector<std::array<float, 2>> landmarks;

  ResultType type = ResultType::FACE_ALIGNMENT;
  void Clear();

  void Free();

  void Reserve(int size);

  void Resize(int size);

  std::string Str();
};

struct FASTDEPLOY_DECL SegmentationResult : public BaseResult {
  SegmentationResult() = default;
  std::vector<uint8_t> label_map;
  std::vector<float> score_map;
  std::vector<int64_t> shape;
  bool contain_score_map = false;

  SegmentationResult(const SegmentationResult& other) = default;
  SegmentationResult& operator=(SegmentationResult&& other);

  ResultType type = ResultType::SEGMENTATION;
  void Clear();

  void Free();

  void Reserve(int size);

  void Resize(int size);

  std::string Str();
};

struct FASTDEPLOY_DECL FaceRecognitionResult : public BaseResult {
  std::vector<float> embedding;

  ResultType type = ResultType::FACE_RECOGNITION;

  FaceRecognitionResult() {}
  FaceRecognitionResult(const FaceRecognitionResult& res);
  void Clear();

  void Free();

  void Reserve(int size);

  void Resize(int size);
  std::string Str();
};

struct FASTDEPLOY_DECL MattingResult : public BaseResult {
  std::vector<float> alpha;       // h x w
  std::vector<float> foreground;  // h x w x c (c=3 default)
  std::vector<int64_t> shape;
  bool contain_foreground = false;

  ResultType type = ResultType::MATTING;

  MattingResult() {}
  MattingResult(const MattingResult& res);
  void Clear();

  void Free();

  void Reserve(int size);

  void Resize(int size);
  std::string Str();
};

struct FASTDEPLOY_DECL HeadPoseResult : public BaseResult {
  std::vector<float> euler_angles;

  ResultType type = ResultType::HEADPOSE;
  void Clear();

  void Free();

  void Reserve(int size);

  void Resize(int size);

  std::string Str();
};


}  // namespace vision
}  // namespace fastdeploy