Upload 17 files

.gitattributes

@@ -33,3 +33,7 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+lib/aarch64/libdet.so filter=lfs diff=lfs merge=lfs -text
+lib/result_11pose.jpg filter=lfs diff=lfs merge=lfs -text
+lib/result_v8.jpg filter=lfs diff=lfs merge=lfs -text
+lib/x86_64/libdet.so filter=lfs diff=lfs merge=lfs -text

examples/cmdline.hpp

@@ -0,0 +1,732 @@
+/*
+  Copyright (c) 2009, Hideyuki Tanaka
+  All rights reserved.
+
+  Redistribution and use in source and binary forms, with or without
+  modification, are permitted provided that the following conditions are met:
+  * Redistributions of source code must retain the above copyright
+  notice, this list of conditions and the following disclaimer.
+  * Redistributions in binary form must reproduce the above copyright
+  notice, this list of conditions and the following disclaimer in the
+  documentation and/or other materials provided with the distribution.
+  * Neither the name of the <organization> nor the
+  names of its contributors may be used to endorse or promote products
+  derived from this software without specific prior written permission.
+
+  THIS SOFTWARE IS PROVIDED BY <copyright holder> ''AS IS'' AND ANY
+  EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+  DISCLAIMED. IN NO EVENT SHALL <copyright holder> BE LIABLE FOR ANY
+  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+#pragma once
+
+#include <cxxabi.h>
+
+#include <algorithm>
+#include <cstdlib>
+#include <cstring>
+#include <iostream>
+#include <map>
+#include <sstream>
+#include <stdexcept>
+#include <string>
+#include <typeinfo>
+#include <vector>
+
+namespace cmdline {
+
+namespace detail {
+
+template <typename Target, typename Source, bool Same>
+class lexical_cast_t {
+ public:
+  static Target cast(const Source &arg) {
+    Target ret;
+    std::stringstream ss;
+    if (!(ss << arg && ss >> ret && ss.eof())) throw std::bad_cast();
+
+    return ret;
+  }
+};
+
+template <typename Target, typename Source>
+class lexical_cast_t<Target, Source, true> {
+ public:
+  static Target cast(const Source &arg) { return arg; }
+};
+
+template <typename Source>
+class lexical_cast_t<std::string, Source, false> {
+ public:
+  static std::string cast(const Source &arg) {
+    std::ostringstream ss;
+    ss << arg;
+    return ss.str();
+  }
+};
+
+template <typename Target>
+class lexical_cast_t<Target, std::string, false> {
+ public:
+  static Target cast(const std::string &arg) {
+    Target ret;
+    std::istringstream ss(arg);
+    if (!(ss >> ret && ss.eof())) throw std::bad_cast();
+    return ret;
+  }
+};
+
+template <typename T1, typename T2>
+struct is_same {
+  static const bool value = false;
+};
+
+template <typename T>
+struct is_same<T, T> {
+  static const bool value = true;
+};
+
+template <typename Target, typename Source>
+Target lexical_cast(const Source &arg) {
+  return lexical_cast_t<Target, Source,
+                        detail::is_same<Target, Source>::value>::cast(arg);
+}
+
+static inline std::string demangle(const std::string &name) {
+  int status = 0;
+  char *p = abi::__cxa_demangle(name.c_str(), 0, 0, &status);
+  std::string ret(p);
+  free(p);
+  return ret;
+}
+
+template <class T>
+std::string readable_typename() {
+  return demangle(typeid(T).name());
+}
+
+template <class T>
+std::string default_value(T def) {
+  return detail::lexical_cast<std::string>(def);
+}
+
+template <>
+inline std::string readable_typename<std::string>() {
+  return "string";
+}
+
+}  // namespace detail
+
+//-----
+
+class cmdline_error : public std::exception {
+ public:
+  cmdline_error(const std::string &msg) : msg(msg) {}
+  ~cmdline_error() throw() {}
+  const char *what() const throw() { return msg.c_str(); }
+
+ private:
+  std::string msg;
+};
+
+template <class T>
+struct default_reader {
+  T operator()(const std::string &str) { return detail::lexical_cast<T>(str); }
+};
+
+template <class T>
+struct range_reader {
+  range_reader(const T &low, const T &high) : low(low), high(high) {}
+  T operator()(const std::string &s) const {
+    T ret = default_reader<T>()(s);
+    if (!(ret >= low && ret <= high))
+      throw cmdline::cmdline_error("range_error");
+    return ret;
+  }
+
+ private:
+  T low, high;
+};
+
+template <class T>
+range_reader<T> range(const T &low, const T &high) {
+  return range_reader<T>(low, high);
+}
+
+template <class T>
+struct oneof_reader {
+  T operator()(const std::string &s) {
+    T ret = default_reader<T>()(s);
+    if (std::find(alt.begin(), alt.end(), ret) == alt.end())
+      throw cmdline_error("");
+    return ret;
+  }
+  void add(const T &v) { alt.push_back(v); }
+
+ private:
+  std::vector<T> alt;
+};
+
+template <class T>
+oneof_reader<T> oneof(T a1) {
+  oneof_reader<T> ret;
+  ret.add(a1);
+  return ret;
+}
+
+template <class T>
+oneof_reader<T> oneof(T a1, T a2) {
+  oneof_reader<T> ret;
+  ret.add(a1);
+  ret.add(a2);
+  return ret;
+}
+
+template <class T>
+oneof_reader<T> oneof(T a1, T a2, T a3) {
+  oneof_reader<T> ret;
+  ret.add(a1);
+  ret.add(a2);
+  ret.add(a3);
+  return ret;
+}
+
+template <class T>
+oneof_reader<T> oneof(T a1, T a2, T a3, T a4) {
+  oneof_reader<T> ret;
+  ret.add(a1);
+  ret.add(a2);
+  ret.add(a3);
+  ret.add(a4);
+  return ret;
+}
+
+template <class T>
+oneof_reader<T> oneof(T a1, T a2, T a3, T a4, T a5) {
+  oneof_reader<T> ret;
+  ret.add(a1);
+  ret.add(a2);
+  ret.add(a3);
+  ret.add(a4);
+  ret.add(a5);
+  return ret;
+}
+
+template <class T>
+oneof_reader<T> oneof(T a1, T a2, T a3, T a4, T a5, T a6) {
+  oneof_reader<T> ret;
+  ret.add(a1);
+  ret.add(a2);
+  ret.add(a3);
+  ret.add(a4);
+  ret.add(a5);
+  ret.add(a6);
+  return ret;
+}
+
+template <class T>
+oneof_reader<T> oneof(T a1, T a2, T a3, T a4, T a5, T a6, T a7) {
+  oneof_reader<T> ret;
+  ret.add(a1);
+  ret.add(a2);
+  ret.add(a3);
+  ret.add(a4);
+  ret.add(a5);
+  ret.add(a6);
+  ret.add(a7);
+  return ret;
+}
+
+template <class T>
+oneof_reader<T> oneof(T a1, T a2, T a3, T a4, T a5, T a6, T a7, T a8) {
+  oneof_reader<T> ret;
+  ret.add(a1);
+  ret.add(a2);
+  ret.add(a3);
+  ret.add(a4);
+  ret.add(a5);
+  ret.add(a6);
+  ret.add(a7);
+  ret.add(a8);
+  return ret;
+}
+
+template <class T>
+oneof_reader<T> oneof(T a1, T a2, T a3, T a4, T a5, T a6, T a7, T a8, T a9) {
+  oneof_reader<T> ret;
+  ret.add(a1);
+  ret.add(a2);
+  ret.add(a3);
+  ret.add(a4);
+  ret.add(a5);
+  ret.add(a6);
+  ret.add(a7);
+  ret.add(a8);
+  ret.add(a9);
+  return ret;
+}
+
+template <class T>
+oneof_reader<T> oneof(T a1, T a2, T a3, T a4, T a5, T a6, T a7, T a8, T a9,
+                      T a10) {
+  oneof_reader<T> ret;
+  ret.add(a1);
+  ret.add(a2);
+  ret.add(a3);
+  ret.add(a4);
+  ret.add(a5);
+  ret.add(a6);
+  ret.add(a7);
+  ret.add(a8);
+  ret.add(a9);
+  ret.add(a10);
+  return ret;
+}
+
+//-----
+
+class parser {
+ public:
+  parser() {}
+  ~parser() {
+    for (std::map<std::string, option_base *>::iterator p = options.begin();
+         p != options.end(); p++)
+      delete p->second;
+  }
+
+  void add(const std::string &name, char short_name = 0,
+           const std::string &desc = "") {
+    if (options.count(name))
+      throw cmdline_error("multiple definition: " + name);
+    options[name] = new option_without_value(name, short_name, desc);
+    ordered.push_back(options[name]);
+  }
+
+  template <class T>
+  void add(const std::string &name, char short_name = 0,
+           const std::string &desc = "", bool need = true, const T def = T()) {
+    add(name, short_name, desc, need, def, default_reader<T>());
+  }
+
+  template <class T, class F>
+  void add(const std::string &name, char short_name = 0,
+           const std::string &desc = "", bool need = true, const T def = T(),
+           F reader = F()) {
+    if (options.count(name))
+      throw cmdline_error("multiple definition: " + name);
+    options[name] = new option_with_value_with_reader<T, F>(
+        name, short_name, need, def, desc, reader);
+    ordered.push_back(options[name]);
+  }
+
+  void footer(const std::string &f) { ftr = f; }
+
+  void set_program_name(const std::string &name) { prog_name = name; }
+
+  bool exist(const std::string &name) const {
+    if (options.count(name) == 0)
+      throw cmdline_error("there is no flag: --" + name);
+    return options.find(name)->second->has_set();
+  }
+
+  template <class T>
+  const T &get(const std::string &name) const {
+    if (options.count(name) == 0)
+      throw cmdline_error("there is no flag: --" + name);
+    const option_with_value<T> *p =
+        dynamic_cast<const option_with_value<T> *>(options.find(name)->second);
+    if (p == NULL) throw cmdline_error("type mismatch flag '" + name + "'");
+    return p->get();
+  }
+
+  const std::vector<std::string> &rest() const { return others; }
+
+  bool parse(const std::string &arg) {
+    std::vector<std::string> args;
+
+    std::string buf;
+    bool in_quote = false;
+    for (std::string::size_type i = 0; i < arg.length(); i++) {
+      if (arg[i] == '\"') {
+        in_quote = !in_quote;
+        continue;
+      }
+
+      if (arg[i] == ' ' && !in_quote) {
+        args.push_back(buf);
+        buf = "";
+        continue;
+      }
+
+      if (arg[i] == '\\') {
+        i++;
+        if (i >= arg.length()) {
+          errors.push_back("unexpected occurrence of '\\' at end of string");
+          return false;
+        }
+      }
+
+      buf += arg[i];
+    }
+
+    if (in_quote) {
+      errors.push_back("quote is not closed");
+      return false;
+    }
+
+    if (buf.length() > 0) args.push_back(buf);
+
+    for (size_t i = 0; i < args.size(); i++)
+      std::cout << "\"" << args[i] << "\"" << std::endl;
+
+    return parse(args);
+  }
+
+  bool parse(const std::vector<std::string> &args) {
+    int argc = static_cast<int>(args.size());
+    std::vector<const char *> argv(argc);
+
+    for (int i = 0; i < argc; i++) argv[i] = args[i].c_str();
+
+    return parse(argc, &argv[0]);
+  }
+
+  bool parse(int argc, const char *const argv[]) {
+    errors.clear();
+    others.clear();
+
+    if (argc < 1) {
+      errors.push_back("argument number must be longer than 0");
+      return false;
+    }
+    if (prog_name == "") prog_name = argv[0];
+
+    std::map<char, std::string> lookup;
+    for (std::map<std::string, option_base *>::iterator p = options.begin();
+         p != options.end(); p++) {
+      if (p->first.length() == 0) continue;
+      char initial = p->second->short_name();
+      if (initial) {
+        if (lookup.count(initial) > 0) {
+          lookup[initial] = "";
+          errors.push_back(std::string("short option '") + initial +
+                           "' is ambiguous");
+          return false;
+        } else
+          lookup[initial] = p->first;
+      }
+    }
+
+    for (int i = 1; i < argc; i++) {
+      if (strncmp(argv[i], "--", 2) == 0) {
+        const char *p = strchr(argv[i] + 2, '=');
+        if (p) {
+          std::string name(argv[i] + 2, p);
+          std::string val(p + 1);
+          set_option(name, val);
+        } else {
+          std::string name(argv[i] + 2);
+          if (options.count(name) == 0) {
+            errors.push_back("undefined option: --" + name);
+            continue;
+          }
+          if (options[name]->has_value()) {
+            if (i + 1 >= argc) {
+              errors.push_back("option needs value: --" + name);
+              continue;
+            } else {
+              i++;
+              set_option(name, argv[i]);
+            }
+          } else {
+            set_option(name);
+          }
+        }
+      } else if (strncmp(argv[i], "-", 1) == 0) {
+        if (!argv[i][1]) continue;
+        char last = argv[i][1];
+        for (int j = 2; argv[i][j]; j++) {
+          last = argv[i][j];
+          if (lookup.count(argv[i][j - 1]) == 0) {
+            errors.push_back(std::string("undefined short option: -") +
+                             argv[i][j - 1]);
+            continue;
+          }
+          if (lookup[argv[i][j - 1]] == "") {
+            errors.push_back(std::string("ambiguous short option: -") +
+                             argv[i][j - 1]);
+            continue;
+          }
+          set_option(lookup[argv[i][j - 1]]);
+        }
+
+        if (lookup.count(last) == 0) {
+          errors.push_back(std::string("undefined short option: -") + last);
+          continue;
+        }
+        if (lookup[last] == "") {
+          errors.push_back(std::string("ambiguous short option: -") + last);
+          continue;
+        }
+
+        if (i + 1 < argc && options[lookup[last]]->has_value()) {
+          set_option(lookup[last], argv[i + 1]);
+          i++;
+        } else {
+          set_option(lookup[last]);
+        }
+      } else {
+        others.push_back(argv[i]);
+      }
+    }
+
+    for (std::map<std::string, option_base *>::iterator p = options.begin();
+         p != options.end(); p++)
+      if (!p->second->valid())
+        errors.push_back("need option: --" + std::string(p->first));
+
+    return errors.size() == 0;
+  }
+
+  void parse_check(const std::string &arg) {
+    if (!options.count("help")) add("help", '?', "print this message");
+    check(0, parse(arg));
+  }
+
+  void parse_check(const std::vector<std::string> &args) {
+    if (!options.count("help")) add("help", '?', "print this message");
+    check(args.size(), parse(args));
+  }
+
+  void parse_check(int argc, char *argv[]) {
+    if (!options.count("help")) add("help", '?', "print this message");
+    check(argc, parse(argc, argv));
+  }
+
+  std::string error() const { return errors.size() > 0 ? errors[0] : ""; }
+
+  std::string error_full() const {
+    std::ostringstream oss;
+    for (size_t i = 0; i < errors.size(); i++) oss << errors[i] << std::endl;
+    return oss.str();
+  }
+
+  std::string usage() const {
+    std::ostringstream oss;
+    oss << "usage: " << prog_name << " ";
+    for (size_t i = 0; i < ordered.size(); i++) {
+      if (ordered[i]->must()) oss << ordered[i]->short_description() << " ";
+    }
+
+    oss << "[options] ... " << ftr << std::endl;
+    oss << "options:" << std::endl;
+
+    size_t max_width = 0;
+    for (size_t i = 0; i < ordered.size(); i++) {
+      max_width = std::max(max_width, ordered[i]->name().length());
+    }
+    for (size_t i = 0; i < ordered.size(); i++) {
+      if (ordered[i]->short_name()) {
+        oss << "  -" << ordered[i]->short_name() << ", ";
+      } else {
+        oss << "      ";
+      }
+
+      oss << "--" << ordered[i]->name();
+      for (size_t j = ordered[i]->name().length(); j < max_width + 4; j++)
+        oss << ' ';
+      oss << ordered[i]->description() << std::endl;
+    }
+    return oss.str();
+  }
+
+ private:
+  void check(int argc, bool ok) {
+    if ((argc == 1 && !ok) || exist("help")) {
+      std::cerr << usage();
+      exit(0);
+    }
+
+    if (!ok) {
+      std::cerr << error() << std::endl << usage();
+      exit(1);
+    }
+  }
+
+  void set_option(const std::string &name) {
+    if (options.count(name) == 0) {
+      errors.push_back("undefined option: --" + name);
+      return;
+    }
+    if (!options[name]->set()) {
+      errors.push_back("option needs value: --" + name);
+      return;
+    }
+  }
+
+  void set_option(const std::string &name, const std::string &value) {
+    if (options.count(name) == 0) {
+      errors.push_back("undefined option: --" + name);
+      return;
+    }
+    if (!options[name]->set(value)) {
+      errors.push_back("option value is invalid: --" + name + "=" + value);
+      return;
+    }
+  }
+
+  class option_base {
+   public:
+    virtual ~option_base() {}
+
+    virtual bool has_value() const = 0;
+    virtual bool set() = 0;
+    virtual bool set(const std::string &value) = 0;
+    virtual bool has_set() const = 0;
+    virtual bool valid() const = 0;
+    virtual bool must() const = 0;
+
+    virtual const std::string &name() const = 0;
+    virtual char short_name() const = 0;
+    virtual const std::string &description() const = 0;
+    virtual std::string short_description() const = 0;
+  };
+
+  class option_without_value : public option_base {
+   public:
+    option_without_value(const std::string &name, char short_name,
+                         const std::string &desc)
+        : nam(name), snam(short_name), desc(desc), has(false) {}
+    ~option_without_value() {}
+
+    bool has_value() const { return false; }
+
+    bool set() {
+      has = true;
+      return true;
+    }
+
+    bool set(const std::string &) { return false; }
+
+    bool has_set() const { return has; }
+
+    bool valid() const { return true; }
+
+    bool must() const { return false; }
+
+    const std::string &name() const { return nam; }
+
+    char short_name() const { return snam; }
+
+    const std::string &description() const { return desc; }
+
+    std::string short_description() const { return "--" + nam; }
+
+   private:
+    std::string nam;
+    char snam;
+    std::string desc;
+    bool has;
+  };
+
+  template <class T>
+  class option_with_value : public option_base {
+   public:
+    option_with_value(const std::string &name, char short_name, bool need,
+                      const T &def, const std::string &desc)
+        : nam(name),
+          snam(short_name),
+          need(need),
+          has(false),
+          def(def),
+          actual(def) {
+      this->desc = full_description(desc);
+    }
+    ~option_with_value() {}
+
+    const T &get() const { return actual; }
+
+    bool has_value() const { return true; }
+
+    bool set() { return false; }
+
+    bool set(const std::string &value) {
+      try {
+        actual = read(value);
+        has = true;
+      } catch (const std::exception &e) {
+        return false;
+      }
+      return true;
+    }
+
+    bool has_set() const { return has; }
+
+    bool valid() const {
+      if (need && !has) return false;
+      return true;
+    }
+
+    bool must() const { return need; }
+
+    const std::string &name() const { return nam; }
+
+    char short_name() const { return snam; }
+
+    const std::string &description() const { return desc; }
+
+    std::string short_description() const {
+      return "--" + nam + "=" + detail::readable_typename<T>();
+    }
+
+   protected:
+    std::string full_description(const std::string &desc) {
+      return desc + " (" + detail::readable_typename<T>() +
+             (need ? "" : " [=" + detail::default_value<T>(def) + "]") + ")";
+    }
+
+    virtual T read(const std::string &s) = 0;
+
+    std::string nam;
+    char snam;
+    bool need;
+    std::string desc;
+
+    bool has;
+    T def;
+    T actual;
+  };
+
+  template <class T, class F>
+  class option_with_value_with_reader : public option_with_value<T> {
+   public:
+    option_with_value_with_reader(const std::string &name, char short_name,
+                                  bool need, const T def,
+                                  const std::string &desc, F reader)
+        : option_with_value<T>(name, short_name, need, def, desc),
+          reader(reader) {}
+
+   private:
+    T read(const std::string &s) { return reader(s); }
+
+    F reader;
+  };
+
+  std::map<std::string, option_base *> options;
+  std::vector<option_base *> ordered;
+  std::string ftr;
+
+  std::string prog_name;
+  std::vector<std::string> others;
+
+  std::vector<std::string> errors;
+};
+
+}  // namespace cmdline

examples/test_ax_api.cpp

@@ -0,0 +1,42 @@
+#include "runner/ax650/ax_api_loader.h"
+#include "runner/ax650/ax_model_runner_ax650.hpp"
+#include "cmdline.hpp"
+
+#include <fstream>
+#include <vector>
+#include <cstring>
+
+AxSysApiLoader &get_ax_sys_loader();
+
+AxEngineApiLoader &get_ax_engine_loader();
+
+int main(int argc, char *argv[])
+{
+    cmdline::parser parser;
+    parser.add<std::string>("model", 'm', "model", true);
+    parser.parse_check(argc, argv);
+
+    AxSysApiLoader &ax_sys_loader = get_ax_sys_loader();
+
+    AxEngineApiLoader &ax_engine_loader = get_ax_engine_loader();
+
+    ax_sys_loader.AX_SYS_Init();
+    AX_ENGINE_NPU_ATTR_T npu_attr;
+    memset(&npu_attr, 0, sizeof(AX_ENGINE_NPU_ATTR_T));
+    npu_attr.eHardMode = AX_ENGINE_VIRTUAL_NPU_DISABLE;
+    ax_engine_loader.AX_ENGINE_Init(&npu_attr);
+
+    ax_runner_ax650 runner;
+    std::ifstream file(parser.get<std::string>("model"), std::ios::binary);
+    if (!file.is_open())
+    {
+        printf("open file failed\n");
+        return -1;
+    }
+    std::vector<uint8_t> model_data((std::istreambuf_iterator<char>(file)), std::istreambuf_iterator<char>());
+    runner.init(model_data.data(), model_data.size(), 0);
+
+    ax_engine_loader.AX_ENGINE_Deinit();
+    ax_sys_loader.AX_SYS_Deinit();
+    return 0;
+}

examples/test_axcl_api.cpp

@@ -0,0 +1,35 @@
+#include "runner/axcl/axcl_manager.h"
+#include "runner/axcl/ax_model_runner_axcl.hpp"
+#include "cmdline.hpp"
+#include <fstream>
+
+int main(int argc, char *argv[])
+{
+    auto ret = axclInit();
+    if (ret != 0)
+    {
+        printf("axclInit failed\n");
+        return -1;
+    }
+
+    axcl_Dev_Init(0);
+    cmdline::parser parser;
+    parser.add<std::string>("model", 'm', "model", true);
+    parser.parse_check(argc, argv);
+
+    ax_runner_axcl runner;
+    std::ifstream file(parser.get<std::string>("model"), std::ios::binary);
+    if (!file.is_open())
+    {
+        printf("open file failed\n");
+        return -1;
+    }
+    std::vector<uint8_t> model_data((std::istreambuf_iterator<char>(file)), std::istreambuf_iterator<char>());
+    runner.init(model_data.data(), model_data.size(), 0);
+
+    runner.deinit();
+
+    axcl_Dev_Exit(0);
+    axclFinalize();
+    return 0;
+}

examples/test_det.cpp

@@ -0,0 +1,128 @@
+#include "libdet.h"
+#include "cmdline.hpp"
+#include "timer.hpp"
+#include <fstream>
+#include <cstring>
+#include <opencv2/opencv.hpp>
+
+int main(int argc, char *argv[])
+{
+    ax_devices_t ax_devices;
+    memset(&ax_devices, 0, sizeof(ax_devices_t));
+    if (ax_dev_enum_devices(&ax_devices) != 0)
+    {
+        printf("enum devices failed\n");
+        return -1;
+    }
+
+    if (ax_devices.host.available)
+    {
+        ax_dev_sys_init(host_device, -1);
+    }
+
+    if (ax_devices.devices.count > 0)
+    {
+        ax_dev_sys_init(axcl_device, 0);
+    }
+
+    if (!ax_devices.host.available && ax_devices.devices.count == 0)
+    {
+        printf("no device available\n");
+        return -1;
+    }
+
+    ax_det_init_t init_info;
+    memset(&init_info, 0, sizeof(init_info));
+
+    cmdline::parser parser;
+    parser.add<std::string>("model", 'm', "model", true);
+    parser.add<int>("model_type", 't', "model type", true);
+    parser.add<std::string>("image", 'i', "image folder(jpg png etc....)", true);
+    parser.add<float>("threshold", 0, "threshold", false, 0.25);
+    parser.add<int>("num_classes", 'c', "num classes", false, 80);
+    parser.add<int>("num_kpt", 0, "num kpt", false, 0);
+    parser.add<std::string>("output", 'o', "output", false, "results.jpg");
+    parser.parse_check(argc, argv);
+
+    if (ax_devices.host.available)
+    {
+        init_info.dev_type = host_device;
+    }
+    else if (ax_devices.devices.count > 0)
+    {
+        init_info.dev_type = axcl_device;
+        init_info.devid = 0;
+    }
+
+    init_info.num_classes = parser.get<int>("num_classes");
+    init_info.num_kpt = parser.get<int>("num_kpt");
+
+    init_info.model_type = ax_det_model_type_e(parser.get<int>("model_type"));
+
+    sprintf(init_info.model_path, "%s", parser.get<std::string>("model").c_str());
+    init_info.threshold = parser.get<float>("threshold");
+
+    ax_det_handle_t handle;
+    int ret = ax_det_init(&init_info, &handle);
+    if (ret != ax_det_errcode_success)
+    {
+        printf("ax_det_init failed\n");
+        return -1;
+    }
+
+    std::string image_src = parser.get<std::string>("image");
+    cv::Mat src = cv::imread(image_src);
+    if (src.empty())
+    {
+        printf("imread %s failed\n", image_src.c_str());
+        return -1;
+    }
+    cv::cvtColor(src, src, cv::COLOR_BGR2RGB);
+    ax_det_img_t img;
+    img.data = src.data;
+    img.width = src.cols;
+    img.height = src.rows;
+    img.channels = src.channels();
+    img.stride = src.step;
+    ax_det_result_t result;
+    memset(&result, 0, sizeof(result));
+    ret = ax_det(handle, &img, &result);
+    if (ret != ax_det_errcode_success)
+    {
+        printf("ax_det failed\n");
+        return -1;
+    }
+    printf("num_objs: %d\n", result.num_objs);
+
+    cv::cvtColor(src, src, cv::COLOR_RGB2BGR);
+
+    for (int i = 0; i < result.num_objs; i++)
+    {
+        ax_det_obj_t &obj = result.objects[i];
+        cv::Rect rect(obj.box.x, obj.box.y, obj.box.w, obj.box.h);
+        cv::rectangle(src, rect, cv::Scalar(0, 255, 0), 2);
+        char label_info[128];
+        sprintf(label_info, "%d %5.2f", obj.label, obj.score);
+        cv::putText(src, label_info, cv::Point(obj.box.x, obj.box.y + 25), cv::FONT_HERSHEY_SIMPLEX, 1.5, cv::Scalar(0, 255, 0), 2);
+
+        for (int j = 0; j < obj.num_kpt; j++)
+        {
+            cv::circle(src, cv::Point(obj.kpts[j].x, obj.kpts[j].y), 10, cv::Scalar(0, 255, 0), -1);
+        }
+    }
+
+    cv::imwrite(parser.get<std::string>("output"), src);
+
+    ax_det_deinit(handle);
+
+    if (ax_devices.host.available)
+    {
+        ax_dev_sys_deinit(host_device, -1);
+    }
+    else if (ax_devices.devices.count > 0)
+    {
+        ax_dev_sys_deinit(axcl_device, 0);
+    }
+
+    return 0;
+}

examples/test_enum_devices.cpp

@@ -0,0 +1,59 @@
+#include "ax_devices.h"
+#include <iostream>
+#include <cstring>
+
+int main()
+{
+    ax_devices_t ax_devices;
+    memset(&ax_devices, 0, sizeof(ax_devices_t));
+    if (ax_dev_enum_devices(&ax_devices) != 0)
+    {
+        printf("enum devices failed\n");
+        return -1;
+    }
+
+    std::cout << "host npu avaiable:" << static_cast<int>(ax_devices.host.available) << " version:" << ax_devices.host.version << std::endl;
+    std::cout << "host mem total:" << ax_devices.host.mem_info.total << " MiB remain:" << ax_devices.host.mem_info.remain << " MiB" << std::endl;
+
+    std::cout << "Host Version: " << ax_devices.devices.host_version << std::endl;
+    std::cout << "Dev Version: " << ax_devices.devices.dev_version << std::endl;
+    std::cout << "Detected Devices Count: " << static_cast<int>(ax_devices.devices.count) << std::endl;
+
+    for (unsigned char i = 0; i < ax_devices.devices.count; ++i)
+    {
+        std::cout << "  Device " << static_cast<int>(i) << ":" << std::endl;
+        std::cout << "    Temperature: " << ax_devices.devices.devices_info[i].temp << "C" << std::endl;
+        std::cout << "    CPU Usage: " << ax_devices.devices.devices_info[i].cpu_usage << "%" << std::endl;
+        std::cout << "    NPU Usage: " << ax_devices.devices.devices_info[i].npu_usage << "%" << std::endl;
+        std::cout << "    Memory Remaining: " << ax_devices.devices.devices_info[i].mem_info.remain << " MiB" << std::endl;
+        std::cout << "    Memory Total: " << ax_devices.devices.devices_info[i].mem_info.total << " MiB" << std::endl;
+    }
+
+    if (ax_devices.host.available)
+    {
+        ax_dev_sys_init(host_device, -1);
+    }
+
+    if (ax_devices.devices.count > 0)
+    {
+        for (unsigned char i = 0; i < ax_devices.devices.count; ++i)
+        {
+            ax_dev_sys_init(axcl_device, i);
+        }
+    }
+
+    if (ax_devices.host.available)
+    {
+        ax_dev_sys_deinit(host_device, -1);
+    }
+
+    if (ax_devices.devices.count > 0)
+    {
+        for (unsigned char i = 0; i < ax_devices.devices.count; ++i)
+        {
+            ax_dev_sys_deinit(axcl_device, i);
+        }
+    }
+
+    return 0;
+}

examples/timer.hpp

@@ -0,0 +1,61 @@
+/*
+ * AXERA is pleased to support the open source community by making ax-samples available.
+ * 
+ * Copyright (c) 2022, AXERA Semiconductor (Shanghai) Co., Ltd. All rights reserved.
+ * 
+ * Licensed under the BSD 3-Clause License (the "License"); you may not use this file except
+ * in compliance with the License. You may obtain a copy of the License at
+ * 
+ * https://opensource.org/licenses/BSD-3-Clause
+ * 
+ * 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.
+ */
+
+/*
+ * Author: ls.wang
+ */
+
+#pragma once
+
+#include <chrono>
+
+class timer
+{
+private:
+    std::chrono::system_clock::time_point start_time, end_time;
+
+public:
+    timer()
+    {
+        start();
+    }
+
+    void start()
+    {
+        stop();
+        this->start_time = this->end_time;
+    }
+
+    void stop()
+    {
+#ifdef _MSC_VER
+        this->end_time = std::chrono::system_clock::now();
+#else
+        this->end_time = std::chrono::high_resolution_clock::now();
+#endif
+    }
+
+    float cost()
+    {
+        if (this->end_time <= this->start_time)
+        {
+            this->stop();
+        }
+
+        auto ms = std::chrono::duration_cast<std::chrono::microseconds>(this->end_time - this->start_time).count();
+        return static_cast<float>(ms) / 1000.f;
+    }
+};

include/ax_devices.h

@@ -0,0 +1,70 @@
+#ifndef __AX_DEVICES_H__
+#define __AX_DEVICES_H__
+
+#if defined(__cplusplus)
+extern "C"
+{
+#endif
+#define AX_DEVICES_COUNT 16
+#define AX_VERSION_LEN 32
+
+    typedef enum
+    {
+        ax_dev_errcode_failed = -1,
+        ax_dev_errcode_success = 0,
+
+        ax_dev_errcode_sysinit_failed,
+        ax_dev_errcode_sysdeinit_failed,
+        ax_dev_errcode_axcl_sysinit_failed,
+        ax_dev_errcode_axcl_sysdeinit_failed,
+    } ax_dev_errcode_e;
+
+    typedef enum
+    {
+        unknown_device = 0,
+        host_device = 1,
+        axcl_device = 2
+    } ax_devive_e;
+
+    typedef struct
+    {
+        struct
+        {
+            char available;
+            char version[AX_VERSION_LEN];
+            struct
+            {
+                int remain;
+                int total;
+            } mem_info;
+        } host;
+
+        struct
+        {
+            char host_version[AX_VERSION_LEN];
+            char dev_version[AX_VERSION_LEN];
+            unsigned char count;
+            struct
+            {
+                int temp;
+                int cpu_usage;
+                int npu_usage;
+                struct
+                {
+                    int remain;
+                    int total;
+                } mem_info;
+            } devices_info[AX_DEVICES_COUNT];
+
+        } devices;
+    } ax_devices_t;
+
+    int ax_dev_enum_devices(ax_devices_t *devices);
+    int ax_dev_sys_init(ax_devive_e dev_type, char devid);
+    int ax_dev_sys_deinit(ax_devive_e dev_type, char devid);
+
+#if defined(__cplusplus)
+}
+#endif
+
+#endif // __AX_DEVICES_H__

include/libdet.h

@@ -0,0 +1,89 @@
+#ifndef __LIBDET_H__
+#define __LIBDET_H__
+#include "ax_devices.h"
+
+#if defined(__cplusplus)
+extern "C"
+{
+#endif
+#define AX_DET_MAX_OBJ_NUM 64
+#define AX_DET_MAX_KPT_NUM 32
+    typedef enum
+    {
+        ax_det_errcode_failed = -1,
+        ax_det_errcode_success = 0,
+    } ax_det_errcode_e;
+
+    typedef enum
+    {
+        ax_det_model_type_unknown = -1,
+        ax_det_model_type_yolov5,
+        ax_det_model_type_yolov8,
+        ax_det_model_type_yolov8_pose,
+        ax_det_model_type_yolo11,
+        ax_det_model_type_yolo11_pose,
+    } ax_det_model_type_e;
+
+    typedef struct
+    {
+        int width;
+        int height;
+        int channels;
+        int stride;
+        void *data;
+    } ax_det_img_t;
+
+    typedef struct
+    {
+        struct
+        {
+            int x, y, w, h;
+        } box;
+
+        struct
+        {
+            int x, y;
+        } kpts[AX_DET_MAX_KPT_NUM];
+        int num_kpt;
+
+        float score;
+        int label;
+    } ax_det_obj_t;
+
+    typedef struct
+    {
+        ax_det_obj_t objects[AX_DET_MAX_OBJ_NUM];
+        int num_objs;
+    } ax_det_result_t;
+
+    typedef struct
+    {
+        ax_devive_e dev_type; // Device type
+        char devid;           // axcl device ID
+
+        ax_det_model_type_e model_type;
+        char model_path[256];
+
+        int num_classes;
+        int num_kpt; // for face/pose
+
+        float threshold;
+
+        // int anchors[18]; // for yolov5
+        // int strides[3];
+
+        float mean[3]; // for nchw float input model, not suggestion
+        float std[3];  // for nchw float input model, not suggestion
+    } ax_det_init_t;
+
+    typedef void *ax_det_handle_t;
+
+    int ax_det_init(ax_det_init_t *init, ax_det_handle_t *handle);
+    int ax_det_deinit(ax_det_handle_t handle);
+
+    int ax_det(ax_det_handle_t handle, ax_det_img_t *img, ax_det_result_t *result);
+
+#if defined(__cplusplus)
+}
+#endif
+#endif

lib/aarch64/libdet.so

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2d4c794896dee3be2c0291a0119e5dd3dcf2fc5459a750f3148ae2473f8b5d7d
+size 4361264

lib/example.py

@@ -0,0 +1,74 @@
+import os
+from pydet import AXDet, ModelType
+from pyaxdev import enum_devices, sys_init, sys_deinit, AxDeviceType
+import cv2
+import glob
+import argparse
+import tqdm
+
+if __name__ == '__main__':
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--model', type=str)
+    parser.add_argument('--model_type', type=int)
+    parser.add_argument('--image', type=str)
+    parser.add_argument('--threshold', type=float, default=0.25)
+    parser.add_argument('--num_classes', type=int, default=80)
+    parser.add_argument('--num_kpt', type=int, default=0)
+    parser.add_argument('--output', type=str, default='results.jpg')
+    
+    args = parser.parse_args()
+
+
+    # 枚举设备
+    dev_type = AxDeviceType.unknown_device
+    dev_id = -1
+    devices_info = enum_devices()
+    print("可用设备:", devices_info)
+    if devices_info['host']['available']:
+        print("host device available")
+        sys_init(AxDeviceType.host_device, -1)
+        dev_type = AxDeviceType.host_device
+        dev_id = -1
+    elif devices_info['devices']['count'] > 0:
+        print("axcl device available, use device-0")
+        sys_init(AxDeviceType.axcl_device, 0)
+        dev_type = AxDeviceType.axcl_device
+        dev_id = 0
+    else:
+        raise Exception("No available device")
+
+ 
+    det = AXDet(
+        model_path=args.model,
+        model_type=args.model_type,
+        threshold=args.threshold,
+        num_classes=args.num_classes,
+        num_kpt=args.num_kpt,
+        dev_type=dev_type,
+        devid=dev_id,
+    )
+    
+     # 加载图像
+    img = cv2.imread(args.image)
+    img_infer = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
+    
+     # 推理
+    results = det.detect(img_infer)
+    for obj in results:
+        box = obj.box
+        score = obj.score
+        label = obj.label
+        kpts = obj.kpts
+        
+        cv2.rectangle(img, box, (0, 255, 0), 2)
+        cv2.putText(img, f"{label}: {score:.2f}", (int(box[0]), int(box[1])-5), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 2)
+        if args.num_kpt > 0:
+            for i in range(args.num_kpt):
+                cv2.circle(img, kpts[i], 5, (0, 0, 255), -1)
+    cv2.imwrite(args.output, img)
+    del det
+
+    if devices_info['host']['available']:
+        sys_deinit(AxDeviceType.host_device, -1)
+    elif devices_info['devices']['count'] > 0:
+        sys_deinit(AxDeviceType.axcl_device, 0)

lib/gradio_example.py

@@ -0,0 +1,108 @@
+import os
+import gradio as gr
+from pydet import AXDet, ModelType
+from pyaxdev import enum_devices, sys_init, sys_deinit, AxDeviceType
+import cv2
+import glob
+import argparse
+import subprocess
+import re
+
+def get_all_local_ips():
+    result = subprocess.run(['ip', 'a'], capture_output=True, text=True)
+    output = result.stdout
+
+    # 匹配所有IPv4
+    ips = re.findall(r'inet (\d+\.\d+\.\d+\.\d+)', output)
+
+    # 过滤掉回环地址
+    real_ips = [ip for ip in ips if not ip.startswith('127.')]
+
+    return real_ips
+
+
+if __name__ == '__main__':
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--model', type=str)
+    parser.add_argument('--model_type', type=int)
+    parser.add_argument('--image', type=str)
+    parser.add_argument('--threshold', type=float, default=0.25)
+    parser.add_argument('--num_classes', type=int, default=80)
+    parser.add_argument('--num_kpt', type=int, default=0)
+    args = parser.parse_args()
+
+    # 初始化
+    dev_type = AxDeviceType.unknown_device
+    dev_id = -1
+    devices_info = enum_devices()
+    print("可用设备:", devices_info)
+    if devices_info['host']['available']:
+        print("host device available")
+        sys_init(AxDeviceType.host_device, -1)
+        dev_type = AxDeviceType.host_device
+        dev_id = -1
+    elif devices_info['devices']['count'] > 0:
+        print("axcl device available, use device-0")
+        sys_init(AxDeviceType.axcl_device, 0)
+        dev_type = AxDeviceType.axcl_device
+        dev_id = 0
+    else:
+        raise Exception("No available device")
+
+ 
+    det = AXDet(
+        model_path=args.model,
+        model_type=args.model_type,
+        threshold=args.threshold,
+        num_classes=args.num_classes,
+        num_kpt=args.num_kpt,
+        dev_type=dev_type,
+        devid=dev_id,
+    )
+    
+    def detect_image(img):
+        results = det.detect(img)
+        print(results)
+        for obj in results:
+            box = obj.box
+            score = obj.score
+            label = obj.label
+            kpts = obj.kpts
+            
+            cv2.rectangle(img, box, (0, 255, 0), 2)
+            cv2.putText(img, f"{label}: {score:.2f}", (int(box[0]), int(box[1])-5), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 2)
+            if args.num_kpt > 0:
+                for i in range(args.num_kpt):
+                    cv2.circle(img, kpts[i], 15, (0, 0, 255), -1)
+        return img
+
+
+    # Gradio界面
+    with gr.Blocks() as demo:
+        gr.Markdown("# 🔍 Det Demo")
+
+        with gr.Row():
+            input_image = gr.Image(label="输入图像")
+            output_image = gr.Image(label="输出图像")
+        det_btn = gr.Button("Detect")
+
+
+        det_btn.click(fn=detect_image, inputs=[input_image], outputs=[output_image])
+
+    # 启动
+    ips = get_all_local_ips()
+    for ip in ips:
+        print(f"* Running on local URL:  http://{ip}:7860")
+    ip = "0.0.0.0"
+    demo.launch(server_name=ip, server_port=7860)
+    
+    
+    del det
+    
+    import atexit
+    if devices_info['host']['available']:
+        atexit.register(lambda: sys_deinit(AxDeviceType.host_device, -1))
+    elif devices_info['devices']['count'] > 0:
+        atexit.register(lambda: sys_deinit(AxDeviceType.axcl_device, 0))
+    
+    

lib/pyaxdev.py

@@ -0,0 +1,148 @@
+import ctypes
+import os
+import platform
+
+def check_error(code: int) -> None:
+    if code != 0:
+        raise Exception(f"API错误: {code}")
+
+base_dir = os.path.dirname(__file__)
+arch = platform.machine()
+
+if arch == 'x86_64':
+    arch_dir = 'x86_64'
+elif arch in ('aarch64', 'arm64'):
+    arch_dir = 'aarch64'
+else:
+    raise RuntimeError(f"Unsupported architecture: {arch}")
+so_name = 'libdet.so'
+lib_paths = [
+    "/home/axera/libdet.axera/build/" + so_name,
+    os.path.join(base_dir, arch_dir, so_name),
+    os.path.join(base_dir, so_name)
+]
+
+last_error = None
+diagnostic_shown = set()
+
+for lib_path in lib_paths:
+    try:
+        print(f"Trying to load: {lib_path}")
+        _lib = ctypes.CDLL(lib_path)
+        print(f"✅ Successfully loaded: {lib_path}")
+        break
+    except OSError as e:
+        last_error = e
+        err_str = str(e)
+        print(f"\n❌ Failed to load: {lib_path}")
+        print(f"   {err_str}")
+
+        # Only show GLIBCXX tip once
+        if "GLIBCXX" in err_str and "not found" in err_str:
+            if "missing_glibcxx" not in diagnostic_shown:
+                diagnostic_shown.add("missing_glibcxx")
+                print("🔍 Detected missing GLIBCXX version in libstdc++.so.6")
+                print("💡 This usually happens when your environment (like Conda) uses an older libstdc++")
+                print(f"👉 Try running with system libstdc++ preloaded:")
+                print(f"   export LD_PRELOAD=/usr/lib/{arch_dir}-linux-gnu/libstdc++.so.6\n")
+        elif "No such file" in err_str:
+            if "file_not_found" not in diagnostic_shown:
+                diagnostic_shown.add("file_not_found")
+                print(f"🔍 File not found. Please verify that {so_name} exists and the path is correct.\n")
+        elif "wrong ELF class" in err_str:
+            if "elf_mismatch" not in diagnostic_shown:
+                diagnostic_shown.add("elf_mismatch")
+                print("🔍 ELF class mismatch — likely due to architecture conflict (e.g., loading x86_64 .so on aarch64).")
+                print(f"👉 Run `file {lib_path}` to verify the binary architecture.\n")
+        else:
+            if "generic_error" not in diagnostic_shown:
+                diagnostic_shown.add("generic_error")
+                print("📎 Tip: Use `ldd` to inspect missing dependencies:")
+                print(f"   ldd {lib_path}\n")
+else:
+    raise RuntimeError(f"\n❗ Failed to load {so_name}.\nLast error:\n{last_error}")
+
+
+# 定义枚举类型
+class AxDeviceType(ctypes.c_int):
+    unknown_device = 0
+    host_device = 1
+    axcl_device = 2
+
+# 定义结构体
+class AxMemInfo(ctypes.Structure):
+    _fields_ = [
+        ('remain', ctypes.c_int),
+        ('total', ctypes.c_int)
+    ]
+
+class AxHostInfo(ctypes.Structure):
+    _fields_ = [
+        ('available', ctypes.c_char),
+        ('version', ctypes.c_char * 32),
+        ('mem_info', AxMemInfo)
+    ]
+
+class AxDeviceInfo(ctypes.Structure):
+    _fields_ = [
+        ('temp', ctypes.c_int),
+        ('cpu_usage', ctypes.c_int),
+        ('npu_usage', ctypes.c_int),
+        ('mem_info', AxMemInfo)
+    ]
+
+class AxDevices(ctypes.Structure):
+    _fields_ = [
+        ('host', AxHostInfo),
+        ('host_version', ctypes.c_char * 32),
+        ('dev_version', ctypes.c_char * 32),
+        ('count', ctypes.c_ubyte),
+        ('devices_info', AxDeviceInfo * 16)
+    ]
+
+
+_lib.ax_dev_enum_devices.argtypes = [ctypes.POINTER(AxDevices)]
+_lib.ax_dev_enum_devices.restype = ctypes.c_int
+
+_lib.ax_dev_sys_init.argtypes = [AxDeviceType, ctypes.c_char]
+_lib.ax_dev_sys_init.restype = ctypes.c_int
+
+_lib.ax_dev_sys_deinit.argtypes = [AxDeviceType, ctypes.c_char]
+_lib.ax_dev_sys_deinit.restype = ctypes.c_int
+
+def enum_devices() -> dict:
+    devices = AxDevices()
+    check_error(_lib.ax_dev_enum_devices(ctypes.byref(devices)))
+    
+    return {
+        'host': {
+            'available': bool(devices.host.available[0]),
+            'version': devices.host.version.decode('utf-8'),
+            'mem_info': {
+                'remain': devices.host.mem_info.remain,
+                'total': devices.host.mem_info.total
+            }
+        },
+        'devices': {
+            'host_version': devices.host_version.decode('utf-8'),
+            'dev_version': devices.dev_version.decode('utf-8'),
+            'count': devices.count,
+            'devices_info': [{
+                'temp': dev.temp,
+                'cpu_usage': dev.cpu_usage,
+                'npu_usage': dev.npu_usage,
+                'mem_info': {
+                    'remain': dev.mem_info.remain,
+                    'total': dev.mem_info.total
+                }
+            } for dev in devices.devices_info[:devices.count]]
+        }
+    }
+
+
+def sys_init(dev_type: AxDeviceType = AxDeviceType.axcl_device, devid: int = 0) -> None:
+    check_error(_lib.ax_dev_sys_init(dev_type, devid))
+
+
+def sys_deinit(dev_type: AxDeviceType = AxDeviceType.axcl_device, devid: int = 0) -> None:
+    check_error(_lib.ax_dev_sys_deinit(dev_type, devid))

lib/pydet.py

@@ -0,0 +1,128 @@
+import ctypes
+import os
+from typing import List, Tuple
+import numpy as np
+import platform
+from pyaxdev import _lib, AxDeviceType, AxDevices, check_error
+
+class ModelType(ctypes.c_int):
+    ax_det_model_type_unknown = -1
+    ax_det_model_type_yolov5 = 0
+    ax_det_model_type_yolov8 = 1
+    ax_det_model_type_yolov8_pose = 2
+    ax_det_model_type_yolo11 = 3
+    ax_det_model_type_yolo11_pose = 4
+
+class DetInit(ctypes.Structure):
+    _fields_ = [
+        ('dev_type', AxDeviceType),
+        ('devid', ctypes.c_char),
+        ('model_type', ModelType),
+        ('model_path', ctypes.c_char * 256),
+        ('num_classes', ctypes.c_int),
+        ('num_kpt', ctypes.c_int),
+        ('threshold', ctypes.c_float),
+        ('mean', ctypes.c_float * 3),
+        ('std', ctypes.c_float * 3),
+    ]
+
+class DetImage(ctypes.Structure):
+    _fields_ = [
+        ('width', ctypes.c_int),
+        ('height', ctypes.c_int),
+        ('channels', ctypes.c_int),
+        ('stride', ctypes.c_int),
+        ('data', ctypes.POINTER(ctypes.c_ubyte)),
+    ]
+
+
+class ObjectItem(ctypes.Structure):
+    _fields_ = [
+        ('box', ctypes.c_int * 4),
+        ('kpts', ctypes.c_int * 2 * 32),
+        ('num_kpt', ctypes.c_int),
+        ('score', ctypes.c_float),
+        ('label', ctypes.c_int),
+    ]
+    
+class ObjectResult(ctypes.Structure):
+    _fields_ = [
+        ('objects', ObjectItem * 64),
+        ('num_objs', ctypes.c_int),
+    ]
+
+_lib.ax_det_init.argtypes = [ctypes.POINTER(DetInit), ctypes.POINTER(ctypes.c_void_p)]
+_lib.ax_det_init.restype = ctypes.c_int
+
+_lib.ax_det_deinit.argtypes = [ctypes.c_void_p]
+_lib.ax_det_deinit.restype = ctypes.c_int
+
+_lib.ax_det.argtypes = [ctypes.c_void_p, ctypes.POINTER(DetImage), ctypes.POINTER(ObjectResult)]
+_lib.ax_det.restype = ctypes.c_int
+
+class Object:
+    def __init__(self, box: List[int], score: float, label: int, kpts: List[int] = []):
+        self.box = box
+        self.score = score
+        self.label = label
+        self.kpts = kpts
+
+    def __repr__(self):
+        return f"Object(box={self.box}, score={self.score:.2f}, label={self.label}, kpts={self.kpts})"
+    
+class AXDet:
+    def __init__(self, model_path: str, model_type: ModelType, num_classes: int, 
+                 num_kpt: int = 0, 
+                 threshold: float= 0.25, 
+                 mean: List[float] = [0,0,0], std: List[float] = [1,1,1],
+                 dev_type: AxDeviceType = AxDeviceType.axcl_device,
+                 devid: int = 0):
+        self.handle = None
+        self.init_info = DetInit()
+        
+        # 设置初始化参数
+        self.init_info.dev_type = dev_type
+        self.init_info.devid = devid
+        
+        # 设置路径
+        self.init_info.model_type = model_type
+        self.init_info.model_path = model_path.encode('utf-8')
+        self.init_info.num_classes = num_classes
+        self.init_info.num_kpt = num_kpt
+        self.init_info.threshold = threshold
+        for i in range(3):
+            self.init_info.mean[i] = mean[i]
+            self.init_info.std[i] = std[i]
+        
+        # 创建CLIP实例
+        handle = ctypes.c_void_p()
+        check_error(_lib.ax_det_init(ctypes.byref(self.init_info), ctypes.byref(handle)))
+        self.handle = handle
+
+    def __del__(self):
+        if self.handle:
+            _lib.ax_det_deinit(self.handle)
+
+    def detect(self, image_data: np.ndarray):
+      
+        image = DetImage()
+        image.data = ctypes.cast(image_data.ctypes.data, ctypes.POINTER(ctypes.c_ubyte))
+        image.width = image_data.shape[1]
+        image.height = image_data.shape[0]
+        image.channels = image_data.shape[2]
+        image.stride = image_data.shape[1] * image_data.shape[2]
+        result = ObjectResult()
+        check_error(_lib.ax_det(self.handle, ctypes.byref(image), ctypes.byref(result)))
+        objects = []
+        for i in range(result.num_objs):
+            _obj = result.objects[i]
+            
+            obj = Object(
+                box=[_obj.box[0], _obj.box[1], _obj.box[2], _obj.box[3]],
+                score=_obj.score,
+                label=_obj.label,
+                kpts=[(_obj.kpts[j][0], _obj.kpts[j][1]) for j in range(_obj.num_kpt)],
+            )
+            objects.append(obj)
+        return objects
+

lib/requirements.txt

@@ -0,0 +1,3 @@
+gradio
+opencv-python
+Pillow

lib/x86_64/libdet.so

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:996c6be093d56653c9a380f53e224a7415f3162bf701ea993c2d6cfc678a8219
+size 5757008