Merge pull request #3144 from MaaAssistantArknights/dev

Release v4.8.2-beta.1

.clang-format

@@ -0,0 +1,195 @@
+Language: Json
+ColumnLimit: 1000
+IndentWidth: 4
+---
+Language: Cpp
+AccessModifierOffset: -4
+AlignAfterOpenBracket: Align
+AlignArrayOfStructures: None
+AlignConsecutiveMacros: None
+AlignConsecutiveAssignments: None
+AlignConsecutiveBitFields: None
+AlignConsecutiveDeclarations: None
+AlignEscapedNewlines: Left
+AlignOperands: Align
+AlignTrailingComments: true
+AllowAllArgumentsOnNextLine: true
+AllowAllParametersOfDeclarationOnNextLine: true
+AllowShortEnumsOnASingleLine: false
+AllowShortBlocksOnASingleLine: Empty
+AllowShortCaseLabelsOnASingleLine: false
+AllowShortFunctionsOnASingleLine: Inline
+AllowShortLambdasOnASingleLine: All
+AllowShortIfStatementsOnASingleLine: WithoutElse
+AllowShortLoopsOnASingleLine: false
+AlwaysBreakAfterDefinitionReturnType: None
+AlwaysBreakAfterReturnType: None
+AlwaysBreakBeforeMultilineStrings: false
+AlwaysBreakTemplateDeclarations: true
+AttributeMacros:
+  - __capability
+BinPackArguments: true
+BinPackParameters: true
+BraceWrapping:
+  AfterCaseLabel: false
+  AfterClass: true
+  AfterControlStatement: Never
+  AfterEnum: true
+  AfterFunction: true
+  AfterNamespace: true
+  AfterObjCDeclaration: true
+  AfterStruct: true
+  AfterUnion: false
+  AfterExternBlock: true
+  BeforeCatch: true
+  BeforeElse: true
+  BeforeLambdaBody: false
+  BeforeWhile: false
+  IndentBraces: false
+  SplitEmptyFunction: false
+  SplitEmptyRecord: false
+  SplitEmptyNamespace: false
+BreakBeforeBinaryOperators: None
+BreakBeforeConceptDeclarations: true
+BreakBeforeBraces: Custom
+BreakBeforeInheritanceComma: false
+BreakInheritanceList: BeforeColon
+BreakBeforeTernaryOperators: true
+BreakConstructorInitializersBeforeComma: false
+BreakConstructorInitializers: BeforeColon
+BreakAfterJavaFieldAnnotations: false
+BreakStringLiterals: true
+ColumnLimit: 120
+CommentPragmas: '^ IWYU pragma:'
+QualifierAlignment: Leave
+CompactNamespaces: false
+ConstructorInitializerIndentWidth: 4
+ContinuationIndentWidth: 4
+Cpp11BracedListStyle: false
+DeriveLineEnding: true
+DerivePointerAlignment: false
+DisableFormat: false
+EmptyLineAfterAccessModifier: Never
+EmptyLineBeforeAccessModifier: LogicalBlock
+ExperimentalAutoDetectBinPacking: false
+PackConstructorInitializers: BinPack
+BasedOnStyle: ''
+ConstructorInitializerAllOnOneLineOrOnePerLine: false
+AllowAllConstructorInitializersOnNextLine: true
+FixNamespaceComments: true
+ForEachMacros:
+  - foreach
+  - Q_FOREACH
+  - BOOST_FOREACH
+IfMacros:
+  - KJ_IF_MAYBE
+IncludeBlocks: Preserve
+IncludeCategories:
+  - Regex: '^"(llvm|llvm-c|clang|clang-c)/'
+    Priority: 2
+    SortPriority: 0
+    CaseSensitive: false
+  - Regex: '^(<|"(gtest|gmock|isl|json)/)'
+    Priority: 3
+    SortPriority: 0
+    CaseSensitive: false
+  - Regex: '.*'
+    Priority: 1
+    SortPriority: 0
+    CaseSensitive: false
+IncludeIsMainRegex: '(Test)?$'
+IncludeIsMainSourceRegex: ''
+IndentAccessModifiers: false
+IndentCaseLabels: false
+IndentCaseBlocks: false
+IndentGotoLabels: true
+IndentPPDirectives: None
+IndentExternBlock: AfterExternBlock
+IndentRequiresClause: false
+IndentWidth: 4
+IndentWrappedFunctionNames: false
+InsertTrailingCommas: None
+JavaScriptQuotes: Leave
+JavaScriptWrapImports: true
+KeepEmptyLinesAtTheStartOfBlocks: true
+LambdaBodyIndentation: Signature
+MacroBlockBegin: ''
+MacroBlockEnd: ''
+MaxEmptyLinesToKeep: 1
+NamespaceIndentation: All
+ObjCBinPackProtocolList: Auto
+ObjCBlockIndentWidth: 2
+ObjCBreakBeforeNestedBlockParam: true
+ObjCSpaceAfterProperty: false
+ObjCSpaceBeforeProtocolList: true
+PenaltyBreakAssignment: 2
+PenaltyBreakBeforeFirstCallParameter: 19
+PenaltyBreakComment: 300
+PenaltyBreakFirstLessLess: 120
+PenaltyBreakOpenParenthesis: 0
+PenaltyBreakString: 1000
+PenaltyBreakTemplateDeclaration: 10
+PenaltyExcessCharacter: 1000000
+PenaltyReturnTypeOnItsOwnLine: 1000
+PenaltyIndentedWhitespace: 0
+PointerAlignment: Left
+PPIndentWidth: -1
+ReferenceAlignment: Pointer
+ReflowComments: true
+RemoveBracesLLVM: false
+RequiresClausePosition: OwnLine
+SeparateDefinitionBlocks: Leave
+ShortNamespaceLines: 50
+SortIncludes: CaseSensitive
+SortJavaStaticImport: Before
+SortUsingDeclarations: true
+SpaceAfterCStyleCast: false
+SpaceAfterLogicalNot: false
+SpaceAfterTemplateKeyword: true
+SpaceBeforeAssignmentOperators: true
+SpaceBeforeCaseColon: false
+SpaceBeforeCpp11BracedList: true
+SpaceBeforeCtorInitializerColon: true
+SpaceBeforeInheritanceColon: true
+SpaceBeforeParens: ControlStatements
+SpaceBeforeParensOptions:
+  AfterControlStatements: true
+  AfterForeachMacros: true
+  AfterFunctionDefinitionName: false
+  AfterFunctionDeclarationName: false
+  AfterIfMacros: true
+  AfterOverloadedOperator: false
+  AfterRequiresInClause: true
+  AfterRequiresInExpression: true
+  BeforeNonEmptyParentheses: false
+SpaceAroundPointerQualifiers: Default
+SpaceBeforeRangeBasedForLoopColon: true
+SpaceInEmptyBlock: false
+SpaceInEmptyParentheses: false
+SpacesBeforeTrailingComments: 1
+SpacesInAngles: Never
+SpacesInConditionalStatement: false
+SpacesInContainerLiterals: true
+SpacesInCStyleCastParentheses: false
+SpacesInLineCommentPrefix:
+  Minimum: 1
+  Maximum: -1
+SpacesInParentheses: false
+SpacesInSquareBrackets: false
+SpaceBeforeSquareBrackets: false
+BitFieldColonSpacing: Both
+Standard: c++20
+StatementAttributeLikeMacros:
+  - Q_EMIT
+StatementMacros:
+  - Q_UNUSED
+  - QT_REQUIRE_VERSION
+TabWidth: 4
+UseCRLF: false
+UseTab: Never
+WhitespaceSensitiveMacros:
+  - STRINGIZE
+  - PP_STRINGIZE
+  - BOOST_PP_STRINGIZE
+  - NS_SWIFT_NAME
+  - CF_SWIFT_NAME

.git-blame-ignore-revs

@@ -0,0 +1,29 @@
+# Since version 2.23 (released in August 2019), git-blame has a feature
+# to ignore or bypass certain commits.
+#
+# This file contains a list of commits that are not likely what you
+# are looking for in a blame, such as mass reformatting or renaming.
+# You can set this file as a default ignore file for blame by running
+# the following command.
+#
+# $ git config blame.ignoreRevsFile .git-blame-ignore-revs
+
+# style: clang format
+98f949346e93e5a1adaade22cda9841e01b98c0b
+290cc30f153a0206bd870a0a58cb6338aa16ea34
+
+# incorrect format of 3rdparty/resource/Arknights-Tile-Pos/levels.json
+65d654e54b9d04d1902c9ee9f9fb2679520adafd
+81ea2c4d4fce29862f719972ecb32877fc4e654f
+
+# refactor: 为 MaaCore 重新建立文件结构
+206df466fd5e3d8ef80387049b0c5011fb58cada
+c9b5aa638a97397ab8666031ea646904527afc09
+559c913fca0dd0966896396e251be13f76ea3e52
+# Re-structure again.
+4b3b84df8f487be0ac86506c28dbebc4635f1282
+91abbb7f175b93a58368a136acf3799666f770d2
+49b3aba96b2dfe1cb187b193d38c436e96e33901
+bae271c09bb79e5cc2a7f8491ce882d276ac97b4
+3d83b80dd67d996a5f4f1732fe1eb36cacc7605e
+21617270bcef2456cb7f89e54560ca6788450711

.gitattributes

@@ -0,0 +1,11 @@
+*        text=auto
+*.cs     text eol=crlf
+*.xaml   text eol=crlf
+
+*.cpp    text eol=lf
+*.hpp    text eol=lf
+*.h      text eol=lf
+
+*.json   text eol=lf
+*.md     text eol=lf
+*.yaml   text eol=lf

.github/ISSUE_TEMPLATE/-----bug-report-.md

@@ -1,16 +0,0 @@
----
-name: 问题反馈（Bug report）
-about: 识别错误、操作异常、连接错误等
-title: ''
-labels: bug
-assignees: ''
-
----
-
-！！！请尽可能详细的描述你遇到的问题，并附上助手软件目录下的 `asst.log` 日志文件！！！
-
-！！！日志文件是可以直接拖拽进来的，没有日志文件的 bug 反馈我会直接关掉！！！
-
-最好再能说明下使用的模拟器、并附上出错时的游戏和软件的截图（要是没截到就算啦_(:з」∠)_
-
-Thanks♪(･ω･)ﾉ

.github/ISSUE_TEMPLATE/-----feature-request-.md

@@ -1,10 +0,0 @@
----
-name: 需求建议（Feature request）
-about: 新功能、建议等
-title: ''
-labels: enhancement
-assignees: ''
-
----
-
-

.github/ISSUE_TEMPLATE/---others-.md

@@ -1,10 +0,0 @@
----
-name: 其他（Others)
-about: 其他议题
-title: ''
-labels: ''
-assignees: ''
-
----
-
-

.github/ISSUE_TEMPLATE/cn-bug-report.yaml

@@ -0,0 +1,50 @@
+name: Bug 反馈（使用中文）
+description: 识别错误、操作异常、连接错误等
+labels: ['bug']
+body:
+  - type: checkboxes
+    id: checks
+    attributes:
+      label: 在提问之前...
+      options:
+      - label: 我理解 Issue 是用于反馈和解决问题的，而非吐槽评论区，将尽可能提供更多信息帮助问题解决
+        required: true
+      - label: 我填写了简短且清晰明确的标题，以便开发者在翻阅 issue 列表时能快速确定大致问题。而不是“一个建议”、“卡住了”等
+        required: true
+      - label: 我已查看最新测试版本的更新内容，并未提及该 bug 已被修复的情况
+        required: true
+  - type: textarea
+    id: describe
+    attributes:
+      label: 问题描述
+      description: 尽可能详细描述你的问题
+    validations:
+      required: true
+  - type: textarea
+    id: logs
+    attributes:
+      label: 日志文件
+      description: |
+        **上传软件目录下的 `asst.log` 日志文件，并说明问题出现的大致时间点**
+        **请直接将完整的文件拖拽进来，而非自己裁切的片段；若文件体积过大可压缩后再上传**
+    validations:
+      required: true
+  - type: textarea
+    id: screenshots
+    attributes:
+      label: 截图
+      description: |
+        如果有，添加屏幕截图以帮助解释你的问题，包括但不限于 MAA 软件截图、游戏画面截图
+        若是识别相关问题，请帮忙提供模拟器自带的截图工具截取的原图（或通过 adb 截取原图）
+        `debug` 文件夹下有一些自动截图的错误图片，若有相关的，请一并打包上传
+    validations:
+      required: false
+  - type: textarea
+    id: others
+    attributes:
+      label: 还有别的吗？
+      description: |
+        使用的模拟器？操作系统？相关的配置？链接？参考资料？
+        任何能让我们对你所遇到的问题有更多了解的东西
+    validations:
+      required: false

.github/ISSUE_TEMPLATE/cn-feature-request.yaml

@@ -0,0 +1,32 @@
+name: 需求建议（使用中文）
+description: 新功能、建议等
+labels: ['enhancement']
+body:
+  - type: checkboxes
+    id: checks
+    attributes:
+      label: 在提问之前...
+      options:
+      - label: 我填写了简短且清晰明确的标题，以便开发者在翻阅 issue 列表时能快速确定大致问题。而不是“一个建议”、“卡住了”等
+        required: true
+      - label: 我基本确定这是一个新功能/建议，而不是遇到了 bug（不确定的话请附上日志）
+        required: true
+  - type: textarea
+    id: describe
+    attributes:
+      label: 说说你遇到的问题？
+    validations:
+      required: false
+  - type: textarea
+    id: solution
+    attributes:
+      label: 有什么好的想法？
+    validations:
+      required: false
+  - type: textarea
+    id: additional
+    attributes:
+      label: 其他内容
+      description: 关于该需求建议的任何其他背景或屏幕截图。
+    validations:
+      required: false

.github/ISSUE_TEMPLATE/cn-others.yaml

@@ -0,0 +1,10 @@
+name: 其他议题（使用中文）
+description: 提出问题，而不是 bug 反馈或需求建议
+labels: ['question']
+body:
+  - type: textarea
+    id: describe
+    attributes:
+      label: 说说你遇到的问题？
+    validations:
+      required: false

.github/ISSUE_TEMPLATE/en-bug-report.yaml

@@ -0,0 +1,76 @@
+name: Bug Report (in English)
+description: >-
+  Recognition errors, operation abnormalities,
+  connection errors, etc.
+labels: ['bug']
+body:
+  - type: checkboxes
+    id: checks
+    attributes:
+      label: Before raising the issue...
+      options:
+      - label: >-
+          I understand that Issues are for feedback and problem solving,
+          not trolling the comments section, and will provide as
+          much information as possible to help solve the problem.
+        required: true
+      - label: >-
+          I filled in a short, clear title
+          so that developers could quickly identify the general problem
+          when going through the issue list.
+          Instead of "Some suggestions", "Stuck", etc.
+        required: true
+      - label: >-
+          I have checked the latest beta update and there is no mention
+          of the bug being fixed.
+        required: true
+  - type: textarea
+    id: describe
+    attributes:
+      label: Description
+      description: Describe your problem in as much detail as possible.
+    validations:
+      required: true
+  - type: textarea
+    id: logs
+    attributes:
+      label: Log files
+      description: >-
+        **Upload the `asst.log` log file from the software directory and**
+        **indicate the approximate point in time when the problem occurred.**
+
+        **Please drag and drop the full file in, not your own cuttings,**
+        **compress it before uploading if too large.**
+    validations:
+      required: true
+  - type: textarea
+    id: screenshots
+    attributes:
+      label: Screenshots
+      description: >-
+        If available, add screenshots to help explain your problem,
+        including but not limited to screenshots of MAA software,
+        screenshots of game screens.
+
+        If the problem is recognition related, please help by providing
+        the original image taken by the emulator's own screenshot tool
+        (or via adb).
+
+        The `debug` folder has some automatic screenshots of the error images,
+        if you have any,
+        please upload them together.
+
+    validations:
+      required: false
+  - type: textarea
+    id: others
+    attributes:
+      label: Anthing else?
+      description: >-
+        Emulator used, operating system, related configuration, links,
+        reference material, etc.
+
+        Anything that will give us more insight into the problem
+        you are having.
+    validations:
+      required: false

.github/ISSUE_TEMPLATE/en-feature-request.yaml

@@ -0,0 +1,32 @@
+name: Feature Request (in English)
+description: New features, suggestions, etc.
+labels: ['enhancement']
+body:
+  - type: checkboxes
+    id: checks
+    attributes:
+      label: Before raising the issue...
+      options:
+      - label: I filled in a short, clear title so that developers could quickly identify the general problem when going through the issue list. Instead of "Some suggestions", "Stuck", etc.
+        required: true
+      - label: I'm probably sure this is a new feature/suggestion and not a bug encountered (please attach logs if you're not sure)
+        required: true
+  - type: textarea
+    id: describe
+    attributes:
+      label: The problems you have encountered?
+    validations:
+      required: false
+  - type: textarea
+    id: solution
+    attributes:
+      label: Any good ideas?
+    validations:
+      required: false
+  - type: textarea
+    id: additional
+    attributes:
+      label: Additional
+      description: Any other background, screen shots, etc.
+    validations:
+      required: false

.github/ISSUE_TEMPLATE/en-others.yaml

@@ -0,0 +1,10 @@
+name: Others (in English)
+description: Ask a question rather than a bug report or feature request.
+labels: ['question']
+body:
+  - type: textarea
+    id: describe
+    attributes:
+      label: The problems you have encountered?
+    validations:
+      required: false

.github/issue-checker.yml

@@ -0,0 +1,512 @@
+default-mode:
+  add:
+  remove: [pull_request_target, issues]
+labels:
+# <!-- [Ss]kip `LABEL` --> 跳过一个 label
+# <!-- [Rr]emove `LABEL` --> 去掉一个 label
+
+# skip and remove
+- name: skip all
+  content:
+  regexes: '[Ss]kip (?:[Aa]ll |)[Ll]abels?'
+- name: remove all
+  content:
+  regexes: '[Rr]emove (?:[Aa]ll |)[Ll]abels?'
+- name: skip module
+  content:
+  regexes: '[Ss]kip [Mm]odule [Ll]abels?'
+- name: remove module
+  content:
+  regexes: '[Rr]emove [Mm]odule [Ll]abels?'
+- name: skip client
+  content:
+  regexes: '[Ss]kip [Cc]lient [Ll]abels?'
+- name: remove client
+  content:
+  regexes: '[Rr]emove [Cc]lient [Ll]abels?'
+- name: skip copilot
+  content:
+  regexes: '[Ss]kip (?:[Ll]abels? |)(?:`|)(?:module: |)copilot(?:`|)'
+- name: remove copilot
+  content:
+  regexes: '[Rr]emove (?:[Ll]abels? |)(?:`|)(?:module: |)copilot(?:`|)'
+- name: skip core
+  content:
+  regexes: '[Ss]kip (?:[Ll]abels? |)(?:`|)(?:module: |)core(?:`|)'
+- name: remove core
+  content:
+  regexes: '[Rr]emove (?:[Ll]abels? |)(?:`|)(?:module: |)core(?:`|)'
+- name: skip depot
+  content:
+  regexes: '[Ss]kip (?:[Ll]abels? |)(?:`|)(?:module: |)depot(?:`|)'
+- name: remove depot
+  content:
+  regexes: '[Rr]emove (?:[Ll]abels? |)(?:`|)(?:module: |)depot(?:`|)'
+- name: skip drop
+  content:
+  regexes: '[Ss]kip (?:[Ll]abels? |)(?:`|)(?:module: |)drop(?:`|)'
+- name: remove drop
+  content:
+  regexes: '[Rr]emove (?:[Ll]abels? |)(?:`|)(?:module: |)drop(?:`|)'
+- name: skip fight
+  content:
+  regexes: '[Ss]kip (?:[Ll]abels? |)(?:`|)(?:module: |)fight(?:`|)'
+- name: remove fight
+  content:
+  regexes: '[Rr]emove (?:[Ll]abels? |)(?:`|)(?:module: |)fight(?:`|)'
+- name: skip GUI
+  content:
+  regexes: '[Ss]kip (?:[Ll]abels? |)(?:`|)(?:module: |)GUI(?:`|)'
+- name: remove GUI
+  content:
+  regexes: '[Rr]emove (?:[Ll]abels? |)(?:`|)(?:module: |)GUI(?:`|)'
+- name: skip infrast
+  content:
+  regexes: '[Ss]kip (?:[Ll]abels? |)(?:`|)(?:module: |)infrast(?:`|)'
+- name: remove infrast
+  content:
+  regexes: '[Rr]emove (?:[Ll]abels? |)(?:`|)(?:module: |)infrast(?:`|)'
+- name: skip others
+  content:
+  regexes: '[Ss]kip (?:[Ll]abels? |)(?:`|)(?:module: |)others(?:`|)'
+- name: remove others
+  content:
+  regexes: '[Rr]emove (?:[Ll]abels? |)(?:`|)(?:module: |)others(?:`|)'
+- name: skip recruit
+  content:
+  regexes: '[Ss]kip (?:[Ll]abels? |)(?:`|)(?:module: |)recruit(?:`|)'
+- name: remove recruit
+  content:
+  regexes: '[Rr]emove (?:[Ll]abels? |)(?:`|)(?:module: |)recruit(?:`|)'
+- name: skip roguelike
+  content:
+  regexes: '[Ss]kip (?:[Ll]abels? |)(?:`|)(?:module: |)roguelike(?:`|)'
+- name: remove roguelike
+  content:
+  regexes: '[Rr]emove (?:[Ll]abels? |)(?:`|)(?:module: |)roguelike(?:`|)'
+- name: skip ambiguous
+  content:
+  regexes: '[Ss]kip (?:[Ll]abels? |)(?:`|)ambiguous(?:`|)'
+- name: remove ambiguous
+  content:
+  regexes: '[Rr]emove (?:[Ll]abels? |)(?:`|)ambiguous(?:`|)'
+- name: skip release
+  content:
+  regexes: '[Ss]kip (?:[Ll]abels? |)(?:`|)release(?:`|)'
+- name: remove release
+  content:
+  regexes: '[Rr]emove (?:[Ll]abels? |)(?:`|)release(?:`|)'
+- name: skip documentation
+  content:
+  regexes: '[Ss]kip (?:[Ll]abels? |)(?:`|)documentation(?:`|)'
+- name: remove documentation
+  content:
+  regexes: '[Rr]emove (?:[Ll]abels? |)(?:`|)documentation(?:`|)'
+- name: skip translation required
+  content:
+  regexes: '[Ss]kip (?:[Ll]abels? |)(?:`|)translation required(?:`|)'
+- name: remove translation required
+  content:
+  regexes: '[Rr]emove (?:[Ll]abels? |)(?:`|)translation required(?:`|)'
+- name: skip client-JP
+  content:
+  regexes: '[Ss]kip (?:[Ll]abels? |)(?:`|)Client: JP(?:`|)'
+- name: remove client-JP
+  content:
+  regexes: '[Rr]emove (?:[Ll]abels? |)(?:`|)Client: JP(?:`|)'
+- name: skip client-EN
+  content:
+  regexes: '[Ss]kip (?:[Ll]abels? |)(?:`|)Client: EN(?:`|)'
+- name: remove client-EN
+  content:
+  regexes: '[Rr]emove (?:[Ll]abels? |)(?:`|)Client: EN(?:`|)'
+- name: skip client-KR
+  content:
+  regexes: '[Ss]kip (?:[Ll]abels? |)(?:`|)Client: KR(?:`|)'
+- name: remove client-KR
+  content:
+  regexes: '[Rr]emove (?:[Ll]abels? |)(?:`|)Client: KR(?:`|)'
+- name: skip client-ZH_TW
+  content:
+  regexes: '[Ss]kip (?:[Ll]abels? |)(?:`|)Client: ZH_TW(?:`|)'
+- name: remove client-ZH_TW
+  content:
+  regexes: '[Rr]emove (?:[Ll]abels? |)(?:`|)Client: ZH_TW(?:`|)'
+- name: skip macOS
+  content:
+  regexes: '[Ss]kip (?:[Ll]abels? |)(?:`|)macOS(?:`|)'
+- name: remove macOS
+  content:
+  regexes: '[Rr]emove (?:[Ll]abels? |)(?:`|)macOS(?:`|)'
+- name: skip incomplete
+  content:
+  regexes: '[Ss]kip (?:[Ll]abels? |)(?:`|)incomplete(?:`|)'
+- name: remove incomplete
+  content:
+  regexes: '[Rr]emove (?:[Ll]abels? |)(?:`|)incomplete(?:`|)'
+
+# `MAA Team`
+- name: MAA Team
+  mode:
+    add: [pull_request_target, issues]
+  author_association:
+  - "MEMBER"
+
+# `module: infrast`
+- name: infrast
+  content: "module: infrast"
+  regexes:
+    "基建|换班|贸易站|制造站|发电站|加工站|会客室|训练室|办公室|控制中枢|宿舍|基地|[Ii]nfrast|[Dd]orm"
+  skip-if:
+  - skip all
+  - skip module
+  - skip infrast
+  remove-if:
+  - remove all
+  - remove module
+  - remove infrast
+
+# `module: roguelike`
+- name: roguelike
+  content: "module: roguelike"
+  regexes:
+    "肉[鸽鴿]|集成战略|[Rr]ogue|ローグ"
+  skip-if:
+  - skip all
+  - skip module
+  - skip roguelike
+  remove-if:
+  - remove all
+  - remove module
+  - remove roguelike
+
+# `module: copilot`
+- name: copilot1
+  content: "module: copilot"
+  regexes: '自动(?:作战|战斗|编队)|自動[戰戦][鬥闘]|[Cc]opilot'
+  mode: add
+  skip-if:
+  - skip all
+  - skip module
+  - skip copilot
+  - roguelike
+  remove-if:
+  - remove all
+  - remove module    
+  - remove copilot
+- name: copilot2
+  content: "module: copilot"
+  regexes: '作[业業]'
+  skip-if:
+  - skip all
+  - skip module
+  - skip copilot
+  - copilot1
+  - infrast
+  - roguelike
+  remove-if:
+  - remove all
+  - remove module    
+  - remove copilot
+
+# `module: drop`
+- name: drop
+  content: "module: drop"
+  regexes:
+    "掉落物?(?:识别|检测)"
+  skip-if:
+  - skip all
+  - skip module
+  - skip drop
+  remove-if:
+  - remove all
+  - remove module
+  - remove drop
+
+# `module: fight`
+- name: fight
+  content: "module: fight"
+  regexes:
+    "刷图|刷理智|剿灭|刷.{0,6}材料|关卡选择|战斗|作战|[戰戦][鬥闘]|[Ff]ight|[Bb]attle|[Aa]nihilation"
+  skip-if:
+  - skip all
+  - skip module
+  - skip fight
+  - copilot1
+  - copilot2
+  - drop
+  - roguelike
+  remove-if:
+  - remove all
+  - remove module
+  - remove fight
+
+# `module: depot`
+- name: depot
+  content: "module: depot"
+  regexes:
+    "仓库识别|仓库检测|仓检|[Dd]epot"
+  skip-if:
+  - skip all
+  - skip module
+  - skip depot
+  remove-if:
+  - remove all
+  - remove module
+  - remove depot
+
+# `module: others`
+- name: others
+  content: "module: others"
+  regexes:
+    "信用|拜访|登录|开始唤醒|连接模拟器|[Vv]isit|[Ll]ogin|[Ss]tartup"
+  skip-if:
+  - skip all
+  - skip module
+  - skip others
+  remove-if:
+  - remove all
+  - remove module
+  - remove others
+
+# `module: recruit`
+- name: recruit
+  content: "module: recruit"
+  regexes:
+    "公招|(?<!肉鸽)招募|公開(?:募集|求人)|[Rr]ecruit"
+  skip-if:
+  - skip all
+  - skip module
+  - skip recruit
+  - roguelike
+  remove-if:
+  - remove all
+  - remove module
+  - remove recruit
+
+# `module: recruit`
+- name: GUI
+  content: "module: GUI"
+  regexes:
+    '软件更新|自动下载|图形化?界面|gui(?!\.)|GUI|Gui'
+  skip-if:
+  - skip all
+  - skip module
+  - skip GUI
+  remove-if:
+  - remove all
+  - remove module
+  - remove GUI
+
+# `ambiguous`
+- name: pr-ambiguous
+  # 不符合 commitizen 的 PR
+  content: ambiguous
+  regexes: '^(?!(?:build|chore|ci|docs?|feat|fix|perf|refactor|rft|style|test)[\:\.\(\,]|[Mm]erge|[Rr]evert|[Rr]elease)'
+  mode:
+    pull_request_target:
+  skip-if:
+  - skip all
+  - skip ambiguous
+  remove-if:
+  - remove all
+  - remove ambiguous
+- name: ambiguous
+  # 不符合上面任何一个的分类的 issue
+  content: ambiguous
+  mode:
+    issues:
+    issue_comment: remove
+  skip-if:
+  - pr-ambiguous
+  - skip all
+  - skip ambiguous
+  remove-if:
+  - remove all
+  - remove ambiguous
+  - copilot1
+  - copilot2
+  - core
+  - depot
+  - drop
+  - fight
+  - GUI
+  - infrast
+  - others
+  - recruit
+  - roguelike
+
+# `release`
+- name: release
+  content: release
+  regexes: 'Release v(?:\d)+\.(?:\d)+\.(?:\d)+'
+  mode:
+    pull_request_target:
+  skip-if:
+  - skip all
+  - skip release
+  remove-if:
+  - remove all
+  - remove release
+
+# `documentation`
+- name: pr-documentation
+  # 不符合 commitizen 的 PR
+  content: documentation
+  regexes: '^docs?[\:\.\(\,]'
+  mode:
+    pull_request_target:
+  skip-if:
+  - skip all
+  - skip documentation
+  - release
+  remove-if:
+  - remove all
+  - remove documentation
+
+# `translation required`
+- name: translation required
+  content: translation required
+  regexes: '(?:(?:(?:[\u3040-\u30ff]|[㍿㍐])[^`]*){10,})'
+  mode:
+    pull_request_target:
+    issues:
+  skip-if:
+  - skip all
+  - skip translation required
+  remove-if:
+  - remove all
+  - remove translation required
+
+# `Client: JP`
+- name: "Client: JP"
+  regexes: '(?:日[文语本]?服|[Yy]o[Ss]tar\-?(?:JP|jp)|(?:JP|jp)[\- ]*(?:[Yy]o[Ss]tar|服|[Cc]lient))'
+  skip-if:
+  - skip all
+  - skip client
+  - skip client-JP
+  remove-if:
+  - remove all
+  - remove client
+  - remove client-JP
+
+# `Client: EN`
+- name: "Client: EN"
+  regexes: '(?:英[文语]?服|国际服|美服|[Yy]o[Ss]tar\-?(?:EN|en)|(?:EN|en)[\- ]*(?:[Yy]o[Ss]tar|服|[Cc]lient))'
+  skip-if:
+  - skip all
+  - skip client
+  - skip client-EN
+  remove-if:
+  - remove all
+  - remove client
+  - remove client-EN
+
+# `Client: KR`
+- name: "Client: KR"
+  regexes: '(?:韩[文语国]?服|[Yy]o[Ss]tar\-?(?:KR|kr)|(?:KR|kr)[\- ]*(?:[Yy]o[Ss]tar|服|[Cc]lient))'
+  skip-if:
+  - skip all
+  - skip client
+  - skip client-KR
+  remove-if:
+  - remove all
+  - remove client
+  - remove client-KR
+
+# `Client: ZH_TW`
+- name: "Client: ZH_TW"
+  regexes: '(?:繁中服|台(?:湾|灣|)服|繁体中文服|[龙龍]成|天下网游|txwy)'
+  skip-if:
+  - skip all
+  - skip client
+  - skip client-ZH_TW
+  remove-if:
+  - remove all
+  - remove client
+  - remove client-ZH_TW
+
+# `macOS`
+- name: macOS
+  regexes: '[Mm]ac(?:(?:book|os|OS)|\s*(?:(?:操作|)系统|电脑|版))'
+  skip-if:
+  - skip all
+  - skip macOS
+  remove-if:
+  - remove all
+  - remove macOS
+
+# `fixed`
+- name: fixed
+  regexes:
+  - "(?:(?:`v\\d+\\.\\d+\\.\\d+(?:-(?:alpha|beta|rc)\\.\\d+|\\.\\d+|)`|\
+    v\\d+\\.\\d+\\.\\d+(?:-(?:alpha|beta|rc)\\.\\d+|\\.\\d+|)\\s+)|\
+    \\[(?:`v\\d+\\.\\d+\\.\\d+(?:-(?:alpha|beta|rc)\\.\\d+|\\.\\d+|)`|\
+    v\\d+\\.\\d+\\.\\d+(?:-(?:alpha|beta|rc)\\.\\d+|\\.\\d+|))\\]\\(\\S*\\)|\
+    (?:https?\\://(?:[^/\\s]+/){3}commit/|)[0-9a-z]{40})\
+    \\s*fixed|[Ff]ixed (?:in|at|by)\\s*\
+    (?:(?:`v\\d+\\.\\d+\\.\\d+(?:-(?:alpha|beta|rc)\\.\\d+|\\.\\d+|)`|\\s+\
+    v\\d+\\.\\d+\\.\\d+(?:-(?:alpha|beta|rc)\\.\\d+|\\.\\d+|))|\
+    \\[(?:`v\\d+\\.\\d+\\.\\d+(?:-(?:alpha|beta|rc)\\.\\d+|\\.\\d+|)`|\
+    v\\d+\\.\\d+\\.\\d+(?:-(?:alpha|beta|rc)\\.\\d+|\\.\\d+|))\\]\\(\\S*\\)|\
+    (?:https?\\://(?:[^/\\s]+/){3}commit/|)[0-9a-z]{40})"
+  mode:
+    issue_comment: add
+
+# `duplicate`
+- name: duplicate
+  regexes:
+    "[Dd]uplicate of\\s*\\[?`?(?:https?\\://(?:[^/\\s]+/){3}issues/|#)\\d+"
+  mode:
+    issue_comment: add
+
+# `outdated`
+- name: outdated
+  regexes:
+    "[Ss]uperseded by"
+  mode:
+    issue_comment: add
+
+# `incomplete`
+- name: incomplete
+  content: incomplete
+  regexes: '(?:\[Uploading asst(?:.bak|)(?: - 副本|)(?:.log|)(?:.zip|)…\]\(\))'
+  mode: add
+  skip-if:
+  - skip all
+  - skip incomplete
+  remove-if:
+  - remove all
+  - remove incomplete
+- name: complete
+  content:
+  regexes: '(?:\[asst(?:.bak|)(?: - 副本|)(?:.log|)(?:.zip|)\]\([^\)]+\))'
+- name: remove incomplete
+  content: incomplete
+  mode: remove
+  skip-if:
+  - skip all
+  - skip incomplete
+  - incomplete
+  remove-if:
+  - remove all
+  - remove incomplete
+  - complete
+
+comments:
+- name: Log upload failed
+  regexes:
+  - '\[Uploading asst(?:.bak|)(?: - 副本|)(?:.log|)(?:.zip|)…\]\(\)'
+  content:
+    "你的日志没有上传成功，请重新上传。\n\n\
+    Your log did not upload successfully, please re-upload it."
+  mode: add
+- name: Upload failed
+  regexes:
+  - "^[^`]*(`[^`]+`[^`]*)*\\[Uploading[^\\]]*…\\]\\(\\)"
+  content:
+    "你有一些文件没有上传成功，请重新上传。\n\n\
+    You have some files that did not upload successfully, please re-upload them."
+  mode: add
+  skip-if:
+  - "Log upload failed"

.github/workflows/dev-build-linux.yml

@@ -0,0 +1,70 @@
+name: dev-build-linux
+
+on:
+  push:
+    branches-ignore:
+      - master
+    paths:
+      - 'src/MaaCore/**'
+      - '3rdparty/**'
+      - 'include/**'
+      - 'resource/**'
+      - 'cmake/**'
+      - CMakeLists.txt
+  pull_request:
+    branches:
+      - dev
+    paths:
+      - 'src/MaaCore/**'
+      - '3rdparty/**'
+      - 'include/**'
+      - 'resource/**'
+      - 'cmake/**'
+      - CMakeLists.txt
+
+jobs:
+  linux-latest:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+        with:
+          submodules: recursive
+
+      - name: Install GCC-12
+        run: |
+          sudo apt update
+          sudo apt upgrade
+          sudo apt install gcc-12 g++-12
+
+      - name: Setup ccache
+        uses: Chocobo1/setup-ccache-action@v1
+        with:
+          remove_stale_cache: false
+
+      - name: Build MAA
+        env:
+          CC: ccache gcc-12
+          CXX: ccache g++-12
+        run: |
+          mkdir -p build
+          cmake -B build \
+            -DINSTALL_THIRD_LIBS=ON \
+            -DINSTALL_RESOURCE=OFF \
+            -DINSTALL_PYTHON=OFF
+          # -DFASTDEPLOY_DIRECTORY=~/fastdeploy \
+          # -DOPENCV_DIRECTORY=~/opencv/lib/cmake/opencv4 \
+          cmake --build build --parallel $(nproc --all)
+          
+          mkdir -p install
+          cmake --install build --prefix install
+
+      - name: tar files
+        run: |
+          mkdir -p release
+          cd install
+          tar czvf $GITHUB_WORKSPACE/release/MaaAssistantArknights.tar.gz .
+
+      - uses: actions/upload-artifact@v3
+        with:
+          name: MAA-linux
+          path: release/*.tar.gz

.github/workflows/dev-build-mac.yml

@@ -0,0 +1,56 @@
+name: dev-build-mac
+
+on:
+  push:
+    branches-ignore:
+      - master
+    paths:
+      - 'src/MaaCore/**'
+      - 'src/MaaMacGui/**'
+      - '3rdparty/**'
+      - 'include/**'
+      - 'resource/**'
+      - 'cmake/**'
+      - CMakeLists.txt
+  pull_request:
+    branches:
+      - dev
+    paths:
+      - 'src/MaaCore/**'
+      - 'src/MaaMacGui/**'
+      - '3rdparty/**'
+      - 'include/**'
+      - 'resource/**'
+      - 'cmake/**'
+      - CMakeLists.txt
+
+jobs:
+  macos-latest:
+    runs-on: macos-12
+    steps:
+      - uses: actions/checkout@v3
+        with:
+          submodules: recursive
+          fetch-depth: 100
+      - name: Cache Homebrew
+        uses: actions/cache@v3
+        with:
+          path: $(brew --prefix)
+          key: ${{ runner.os }}-homebrew-${{ hashFiles('.config/brew/Brewfile') }}
+      - name: Install Dependencies
+        run: |
+          brew update --preinstall
+          brew install ninja range-v3
+      - name: Configure MaaCore
+        run: |
+          mkdir build && cd build
+          cmake .. -GNinja -DBUILD_XCFRAMEWORK=ON
+      - name: Build libMaaCore
+        run: cmake --build build
+      - name: Build MAA
+        working-directory: src/MaaMacGui
+        run: xcodebuild CODE_SIGN_IDENTITY="-" DEVELOPMENT_TEAM="-" -derivedDataPath DerivedData -project MeoAsstMac.xcodeproj -scheme MAA-x86_64
+      - uses: actions/upload-artifact@v3
+        with:
+          name: MAA-macos
+          path: src/MaaMacGui/DerivedData/Build/Products/Debug

.github/workflows/dev-build-win.yml

@@ -0,0 +1,75 @@
+# ------------------------------------------------------------------------------
+# <auto-generated>
+#
+#     This code was generated.
+#
+#     - To turn off auto-generation set:
+#
+#         [GitHubActions (AutoGenerate = false)]
+#
+#     - To trigger manual generation invoke:
+#
+#         nuke --generate-configuration GitHubActions_dev-build-win --host GitHubActions
+#
+# </auto-generated>
+# ------------------------------------------------------------------------------
+
+name: dev-build-win
+
+on:
+  push:
+    branches-ignore:
+      - master
+    paths:
+      - 'src/MaaCore/**'
+      - 'src/MaaWpfGui/**'
+      - '3rdparty/**'
+      - 'tools/MaaBuilder/**'
+      - tools/MaaBuilder.sln
+      - 'include/**'
+      - 'resource/**'
+      - MAA.sln
+  pull_request:
+    branches:
+      - dev
+    paths:
+      - 'src/MaaCore/**'
+      - 'src/MaaWpfGui/**'
+      - '3rdparty/**'
+      - 'tools/MaaBuilder/**'
+      - tools/MaaBuilder.sln
+      - 'include/**'
+      - 'resource/**'
+      - MAA.sln
+  workflow_dispatch:
+    inputs:
+      Reason:
+        description: "Reason"
+        required: true
+      ReleaseSimulation:
+        description: "Release Simulation"
+        required: true
+
+jobs:
+  windows-latest:
+    name: windows-latest
+    runs-on: windows-latest
+    steps:
+      - uses: actions/checkout@v3
+      - name: Cache .nuke/temp, ~/.nuget/packages
+        uses: actions/cache@v3
+        with:
+          path: |
+            .nuke/temp
+            ~/.nuget/packages
+          key: ${{ runner.os }}-${{ hashFiles('**/global.json', '**/*.csproj') }}
+      - name: Run './build.cmd DevBuild'
+        run: ./build.cmd DevBuild
+        env:
+          Reason: ${{ github.event.inputs.Reason }}
+          ReleaseSimulation: ${{ github.event.inputs.ReleaseSimulation }}
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+      - uses: actions/upload-artifact@v3
+        with:
+          name: MAA-win-x64
+          path: artifacts

.github/workflows/issue-checker.yml

@@ -0,0 +1,25 @@
+name: "Issue Checker"
+on:
+  issues:
+    types: [opened, edited]
+  pull_request_target:
+    types: [opened, edited]
+  issue_comment:
+    types: [created, edited]
+  push:
+
+permissions:
+  contents: read
+  issues: write
+  pull-requests: write
+
+jobs:
+  triage:
+    runs-on: ubuntu-latest
+    steps:
+    - uses: zzyyyl/issue-checker@v1.7
+      with:
+        repo-token: "${{ secrets.GITHUB_TOKEN }}"
+        configuration-path: .github/issue-checker.yml
+        not-before: 2022-08-05T00:00:00Z
+        include-title: 1

.github/workflows/release-maa-linux.yml

@@ -0,0 +1,61 @@
+name: dev-build-linux
+
+on:
+  release:
+    types: [published]
+
+jobs:
+  linux-latest:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Setup tag info
+        run: |
+          GIT_TAG=${GITHUB_REF#refs/*/}
+          echo "GIT_TAG=${GIT_TAG}" >> $GITHUB_ENV
+
+      - uses: actions/checkout@v3
+        with:
+          submodules: recursive
+
+      - name: Install GCC-12
+        run: |
+          sudo apt update
+          sudo apt upgrade
+          sudo apt install gcc-12 g++-12
+
+      - name: Setup ccache
+        uses: Chocobo1/setup-ccache-action@v1
+        with:
+          remove_stale_cache: false
+
+      - name: Build MAA
+        env:
+          CC: ccache gcc-12
+          CXX: ccache g++-12
+        run: |
+          mkdir -p build
+          cmake -B build \
+            -DINSTALL_THIRD_LIBS=ON \
+            -DINSTALL_RESOURCE=ON \
+            -DINSTALL_PYTHON=ON
+          # -DFASTDEPLOY_DIRECTORY=~/fastdeploy \
+          # -DOPENCV_DIRECTORY=~/opencv/lib/cmake/opencv4 \
+          cmake --build build --parallel $(nproc --all)
+          
+          mkdir -p install
+          cmake --install build --prefix install
+
+      - name: tar files
+        run: |
+          mkdir -p release
+          cd install
+          tar czvf $GITHUB_WORKSPACE/release/MAA-${{ env.GIT_TAG }}-linux.tar.gz .
+
+      - name: Upload image to release
+        uses: svenstaro/upload-release-action@v2
+        with:
+          repo_token: ${{ secrets.GITHUB_TOKEN }}
+          file: 'release/*.tar.gz'
+          file_glob: true
+          tag: ${{ env.GIT_TAG }}
+          overwrite: true

.github/workflows/release-maa-mac.yml

@@ -0,0 +1,99 @@
+name: release-maa-mac
+
+on:
+  release:
+    types: [published]
+
+jobs:
+  macos-latest:
+    name: macos-latest
+    runs-on: macos-12
+
+    strategy:
+      matrix:
+        arch: [arm64, x86_64]
+
+    steps:
+      - uses: actions/checkout@v3
+        with:
+          submodules: recursive
+      - name: 'Install Developer ID Certificate'
+        uses: apple-actions/import-codesign-certs@v1
+        with:
+          p12-file-base64: ${{ secrets.HGUANDL_SIGN_CERT_P12 }}
+          p12-password: ${{ secrets.HGUANDL_SIGN_CERT_PASSWD }}
+      - name: Cache Homebrew
+        uses: actions/cache@v3
+        with:
+          path: $(brew --prefix)
+          key: ${{ runner.os }}-homebrew-${{ hashFiles('.config/brew/Brewfile') }}
+      - name: Install Dependencies
+        run: |
+            brew update --preinstall
+            brew install ninja range-v3 create-dmg
+      - name: Configure MaaCore
+        run: |
+          mkdir build && cd build
+          cmake .. -GNinja -DCMAKE_BUILD_TYPE=Release -DBUILD_XCFRAMEWORK=ON -DCMAKE_OSX_ARCHITECTURES=${{ matrix.arch }}
+      - name: Build libMaaCore
+        run: cmake --build build
+      - name: Build MAA
+        working-directory: src/MaaMacGui
+        run: xcodebuild -project MeoAsstMac.xcodeproj -scheme MAA-${{ matrix.arch }} archive -archivePath MAA.xcarchive -configuration Release-${{ matrix.arch }}
+      - name: Export MAA
+        working-directory: src/MaaMacGui
+        run: xcodebuild -exportArchive -archivePath MAA.xcarchive -exportOptionsPlist ExportOptions.plist -exportPath Export
+      - name: Create disk image
+        working-directory: src/MaaMacGui
+        run: create-dmg --background dmg-bkg.png --window-size 500 300 --icon-size 128 --icon MAA.app 0 120 --hide-extension MAA.app --app-drop-link 270 120 MAA-${{ matrix.arch }}.dmg Export/MAA.app
+      - name: Archive debug symbols
+        working-directory: src/MaaMacGui/MAA.xcarchive/dSYMs
+        run: ditto -c -k --keepParent MAA.app.dSYM MAA-${{ matrix.arch }}.app.dSYM.zip
+      - name: Place packages
+        run: |
+          GIT_TAG=${GITHUB_REF#refs/*/}
+          APP_DMG=MAA-${GIT_TAG}-macos-${{ matrix.arch }}.dmg
+          APP_SYM=MAAComponent-DebugSymbol-${GIT_TAG}-macos-${{ matrix.arch }}.zip
+          mkdir -p release
+          mv src/MaaMacGui/MAA-${{ matrix.arch }}.dmg release/${APP_DMG}
+          mv src/MaaMacGui/MAA.xcarchive/dSYMs/MAA-${{ matrix.arch }}.app.dSYM.zip release/${APP_SYM}
+      - name: Upload products
+        uses: actions/upload-artifact@v3
+        with:
+          name: MAA-macos
+          path: release
+
+  macos-release:
+    name: macos-release
+    runs-on: macos-12
+    needs: [macos-latest]
+    steps:
+      - name: 'Setup tag information'
+        run: |
+          GIT_TAG=${GITHUB_REF#refs/*/}
+          echo "GIT_TAG=${GIT_TAG}" >> $GITHUB_ENV
+      - name: Download artifacts
+        uses: actions/download-artifact@v3
+        with:
+          name: MAA-macos
+      - name: 'Verify image'
+        run: |
+          find . -name "*.dmg" -exec hdiutil verify {} \;
+      - name: 'Notarize image'
+        env:
+          NOTARY_USER: ${{ secrets.HGUANDL_NOTARY_AAPL_ID }}
+          NOTARY_PASSWD: ${{ secrets.HGUANDL_NOTARY_PASSWD }}
+          NOTARY_TEAM: ${{ secrets.HGUANDL_SIGN_IDENTITY }}
+        run: |
+          find . -name "*.dmg" | while read dmg; do
+            xcrun notarytool submit --apple-id "$NOTARY_USER" --password "$NOTARY_PASSWD" --team-id "$NOTARY_TEAM" --wait ${dmg}
+            xcrun stapler staple ${dmg}
+          done
+      - name: Upload image to release
+        uses: svenstaro/upload-release-action@v2
+        with:
+          repo_token: ${{ secrets.GITHUB_TOKEN }}
+          file: 'MAA*${{ env.GIT_TAG }}-macos*'
+          file_glob: true
+          tag: ${{ env.GIT_TAG }}
+          overwrite: true

.github/workflows/release-maa-win.yml

@@ -0,0 +1,45 @@
+# ------------------------------------------------------------------------------
+# <auto-generated>
+#
+#     This code was generated.
+#
+#     - To turn off auto-generation set:
+#
+#         [GitHubActions (AutoGenerate = false)]
+#
+#     - To trigger manual generation invoke:
+#
+#         nuke --generate-configuration GitHubActions_release-maa-win --host GitHubActions
+#
+# </auto-generated>
+# ------------------------------------------------------------------------------
+
+name: release-maa-win
+
+on:
+  push:
+    tags:
+      - 'v*'
+
+jobs:
+  windows-latest:
+    name: windows-latest
+    runs-on: windows-latest
+    steps:
+      - uses: actions/checkout@v3
+      - name: Cache .nuke/temp, ~/.nuget/packages
+        uses: actions/cache@v3
+        with:
+          path: |
+            .nuke/temp
+            ~/.nuget/packages
+          key: ${{ runner.os }}-${{ hashFiles('**/global.json', '**/*.csproj') }}
+      - name: Run './build.cmd ReleaseMaa'
+        run: ./build.cmd ReleaseMaa
+        env:
+          PUBLISH_GH_PAT: ${{ secrets.PUBLISH_GH_PAT }}
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+      - uses: actions/upload-artifact@v3
+        with:
+          name: MAA-win-x64
+          path: artifacts

.github/workflows/release-nightly-ota.yml

@@ -0,0 +1,161 @@
+name: release-nightly-ota
+
+on:
+  workflow_dispatch:
+    inputs:
+      ref:
+        description: 'Commit to build (git checkout)'
+        type: string
+        required: true
+      limit:
+        description: 'Number of releases to fetch from MaaAssistantArknights'
+        required: false
+        default: 30
+        type: number
+      limit_2:
+        description: 'Number of releases to fetch from MaaRelease'
+        required: false
+        default: 30
+      tag_name:
+        description: 'Tag name to release'
+        required: false
+      release_body:
+        type: string
+        required: false
+
+jobs:
+  build-win-nightly:
+    runs-on: windows-latest
+    outputs:
+      tag: ${{ steps.set_tag.outputs.tag }}
+    steps:
+      - uses: actions/checkout@v3
+        with:
+          # repository: 'MaaAssistantArknights/MaaAssistantArknights'
+          submodules: recursive
+          #ref: ${{ inputs.ref }}
+          fetch-depth: 0
+      - name: Checkout ref
+        run: |
+          git checkout --progress --recurse-submodules ${{ inputs.ref || 'dev' }}
+      - run: |
+          npm install --global --progress semver
+      - name: Set tag
+        id: set_tag
+        run: |
+          if ("${{ inputs.tag_name }}" -ne "") {
+            echo "tag=${{ inputs.tag_name }}" >> $env:GITHUB_OUTPUT
+            exit 0
+          }
+          $described = $(git describe --tags --long --match 'v*')
+          $ids = $($described -split "-")
+          if ($ids.length -eq 3) {
+            $ver = "v$(semver --increment $ids[0].Substring(1))"
+            echo "tag=$ver-alpha.0.$($ids[1]).$($ids[2])" >> $env:GITHUB_OUTPUT
+            exit 0
+          }
+          if ($ids.length -eq 4) {
+            echo "tag=$($ids[0])-$($ids[1]).$($ids[2]).$($ids[3])" >> $env:GITHUB_OUTPUT
+            exit 0
+          }
+          exit 1
+      - name: Cache .nuke/temp, ~/.nuget/packages
+        uses: actions/cache@v3
+        with:
+          path: |
+            .nuke/temp
+            ~/.nuget/packages
+          key: ${{ runner.os }}-${{ hashFiles('**/global.json', '**/*.csproj') }}
+      - name: Run './build.cmd DevBuild'
+        run: |
+          $env:GITHUB_WORKFLOW = 'dev-build-win' # pretend this is a dev-build-win workflow
+          $env:MAA_BUILDER_MAA_VERSION = "${{steps.set_tag.outputs.tag}}"
+          echo "tag: " $env:MAA_BUILDER_MAA_VERSION
+          ./build.cmd DevBuild
+        env:
+          Reason: 'Build nightly version'
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+      - uses: actions/upload-artifact@v3
+        with:
+          name: MAA-win-x64
+          path: artifacts
+
+  make-ota:
+    needs: build-win-nightly
+    runs-on: ubuntu-latest
+    steps:
+      - run: echo ${{ needs.build-win-nightyl.outputs.tag }}
+      - name: "Fetch MaaRelease"
+        uses: actions/checkout@v3
+        with:
+          repository: ${{ format('{0}/{1}', github.repository_owner, 'MaaRelease') }}
+          path: MaaRelease
+          fetch-depth: 0
+          token: ${{ secrets.MAARELEASE_RELEASE }}
+      - uses: actions/checkout@v3
+        with:
+          path: MaaAssistantArknights
+      - uses: actions/download-artifact@v3
+        with:
+          name: MAA-win-x64
+          path: ${{ format('{0}/{1}', 'build-ota', needs.build-win-nightly.outputs.tag) }}
+      - name: "Fetch release info"
+        env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: |
+          mkdir -pv build-ota && cd build-ota
+          cd ${{ needs.build-win-nightly.outputs.tag }}
+          mkdir -pv content
+          unzip -q *.zip -x '*.lib' -x '*.pdb' -x '*.exp' -x '*.config' -x '*.xml' -d content
+          cd ..
+
+          gh release list --repo 'MaaAssistantArknights/MaaAssistantArknights' --limit ${{ inputs.limit || 30 }} | tee ./release_maa.txt
+          gh release list --repo "${{ github.repository_owner }}/MaaRelease" --limit ${{ inputs.limit_2 || 30 }} | tee ./release_mr.txt
+          echo ${{ needs.build-win-nightly.outputs.tag }} > ./config
+
+          cat ./release_maa.txt | awk '{ print $1 }' > ./tags_maa.txt
+          cat ./release_mr.txt | awk '{ print $1 }' > ./tags_mr.txt
+
+          comm <(sort ./tags_maa.txt) <(sort ./tags_mr.txt) | awk '{ print $1 }' >> ./config
+
+          echo "config:"
+          cat ./config
+
+          echo "release_tag=$(head -n 1 ./config)" >> $GITHUB_ENV
+      - name: "Build OTA"
+        env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: |
+          cd build-ota
+          $GITHUB_WORKSPACE/MaaAssistantArknights/tools/OTAPacker/build.sh 'MaaAssistantArknights/MaaAssistantArknights' ./config "${{ github.repository_owner }}/MaaRelease"
+          mv -v ${{ needs.build-win-nightly.outputs.tag }}/*.zip ./MAA-${{ env.release_tag }}-win-x64.zip
+      - name: "Commit and setup tag"
+        run: |
+          cd MaaRelease
+          git config user.name 'github-actions[bot]'
+          git config user.email 'github-actions[bot]@users.noreply.github.com'
+          git checkout --orphan __temp
+          git rm -rf .
+          git commit --allow-empty --message ${{ env.release_tag }}
+          git tag ${{ env.release_tag }} || exit 0 # do nothing if the tag already exists
+          git push --tags
+      - name: "Upload to MaaRelease"
+        uses: svenstaro/upload-release-action@v2
+        with:
+          repo_name: ${{ format('{0}/{1}', github.repository_owner, 'MaaRelease') }}
+          repo_token: ${{ secrets.MAARELEASE_RELEASE }}
+          file_glob: true
+          file: build-ota/*.zip
+          tag: ${{ env.release_tag }}
+          prerelease: true
+          overwrite: true
+          body: ${{ inputs.release_body || '' }}
+      - name: "Upload to server"
+        uses: appleboy/scp-action@master
+        with:
+          host: ${{ secrets.SSH_HOST }}
+          username: ${{ secrets.SSH_USER }}
+          key: ${{ secrets.SSH_ID }}
+          source: "build-ota/*.zip"
+          strip_components: 1
+          target: ${{ format('{0}/{1}', 'OTA/MaaAssistantArknights/MaaRelease/releases/download', env.release_tag) }}

.github/workflows/release-ota.yml

@@ -0,0 +1,97 @@
+name: release-ota
+
+on:
+  release:
+    types: [published]
+  workflow_dispatch:
+    inputs:
+      limit:
+        description: 'Number of releases to fetch from MaaAssistantArknights, 2 at least'
+        required: false
+        default: 31
+        type: number
+      limit_2:
+        description: 'Number of releases to fetch from MaaRelease'
+        required: false
+        default: 30
+
+jobs:
+  make-ota:
+    runs-on: "ubuntu-latest"
+    steps:
+      - name: "Fetch MaaRelease"
+        uses: actions/checkout@v3
+        with:
+          repository: ${{ format('{0}/{1}', github.repository_owner, 'MaaRelease') }}
+          path: MaaRelease
+          fetch-depth: 0
+          token: ${{ secrets.MAARELEASE_RELEASE }}
+      - uses: actions/checkout@v3
+        with:
+          path: MaaAssistantArknights
+      - name: "Fetch release info"
+        env: 
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: |
+          mkdir -pv build-ota && cd build-ota
+          gh release list --repo 'MaaAssistantArknights/MaaAssistantArknights' --limit ${{ inputs.limit || 31 }} | tee ./release_maa.txt
+          gh release list --repo "MaaAssistantArknights/MaaRelease" --limit ${{ inputs.limit_2 || 30 }} | tee ./release_mr.txt
+          head -n 1 ./release_maa.txt | awk '{ print $1 }' > ./config
+
+          tail -n +1 ./release_maa.txt | awk '{ print $1 }' > ./tags_maa.txt
+          cat ./release_mr.txt | awk '{ print $1 }' > ./tags_mr.txt
+
+          comm <(sort ./tags_maa.txt) <(sort ./tags_mr.txt) | awk '{ print $1 }' >> ./config
+
+          echo "config:"
+          cat ./config
+
+          echo "prerelease=$([ $(head -n 1 release_maa.txt | awk '{ print $2}') = 'Pre-release' ] && echo true || echo false)" >> $GITHUB_ENV
+          echo "release_tag=$(head -n 1 ./config)" >> $GITHUB_ENV
+      - name: "Download latest version for server"
+        run: |
+          mkdir -pv build-ota/${{ env.release_tag }}
+          cd build-ota/${{ env.release_tag }}
+          mkdir -pv content
+          gh release download ${{ env.release_tag }} --repo 'MaaAssistantArknights/MaaAssistantArknights' --pattern "MAA-${{ env.release_tag }}-win-x64.zip" --clobber
+          unzip -q -O gbk -o "*.zip" -d 'content'
+          mv *.zip ..
+        env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+      - name: "Build OTA"
+        env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: |
+          cd build-ota
+          $GITHUB_WORKSPACE/MaaAssistantArknights/tools/OTAPacker/build.sh 'MaaAssistantArknights/MaaAssistantArknights' ./config 'MaaAssistantArknights/MaaRelease'
+      - name: "Commit and setup tag"
+        run: |
+          cd MaaRelease
+          git config user.name 'github-actions[bot]'
+          git config user.email 'github-actions[bot]@users.noreply.github.com'
+          git checkout --orphan __temp
+          git rm -rf .
+          git commit --allow-empty --message ${{ env.release_tag }}
+          git tag ${{ env.release_tag }} || exit 0 # do nothing if the tag already exists
+          git push --tags
+        env:
+          PUSH_REMOTE: https://github-actions[bot]:${{ secrets.MAARELEASE_RELEASE }}@github.com/${{ github.repository_owner }}/MaaRelease
+      - name: "Upload to MaaRelease"
+        uses: svenstaro/upload-release-action@v2
+        with:
+          repo_name: ${{ format('{0}/{1}', github.repository_owner, 'MaaRelease') }}
+          repo_token: ${{ secrets.MAARELEASE_RELEASE }}
+          file_glob: true
+          file: build-ota/*.zip
+          tag: ${{ env.release_tag }}
+          prerelease: ${{ env.prerelease }}
+          overwrite: true
+      - name: "Upload to server"
+        uses: appleboy/scp-action@master
+        with:
+          host: ${{ secrets.SSH_HOST }}
+          username: ${{ secrets.SSH_USER }}
+          key: ${{ secrets.SSH_ID }}
+          source: "build-ota/*.zip"
+          strip_components: 1
+          target: ${{ format('{0}/{1}', 'OTA/MaaAssistantArknights/MaaRelease/releases/download', env.release_tag) }}

.gitignore

@@ -1,3 +1,6 @@
+# docs
+docs/node_modules
+docs/.vuepress/.temp
 # Prerequisites
 *.d
 
@@ -20,6 +23,7 @@ build
 # Fortran module files
 *.mod
 *.smod
+!go.mod
 
 # Compiled Static libraries
 *.lai
@@ -71,6 +75,7 @@ bld/
 [Oo]bj/
 [Ll]og/
 [Ll]ogs/
+cmake-build-debug/
 
 # Visual Studio 2015/2017 cache/options directory
 .vs/
@@ -431,5 +436,9 @@ FodyWeavers.xsd
 screen.png
 adb_screen.png
 tools/**/*.png
-resource/infrast
 .vscode
+!3rdparty/tools/*
+enc_temp_folder/*
+
+# Nuke
+.nuke/temp/*

.gitmodules

@@ -0,0 +1,6 @@
+[submodule "test"]
+	path = test
+	url = https://github.com/MaaAssistantArknights/MaaTestSet.git
+[submodule "src/MaaMacGui"]
+	path = src/MaaMacGui
+	url = https://github.com/MaaAssistantArknights/MaaMacGui.git

.nuke/build.schema.json

@@ -0,0 +1,132 @@
+{
+  "$schema": "http://json-schema.org/draft-04/schema#",
+  "title": "Build Schema",
+  "$ref": "#/definitions/build",
+  "definitions": {
+    "build": {
+      "type": "object",
+      "properties": {
+        "Continue": {
+          "type": "boolean",
+          "description": "Indicates to continue a previously failed build attempt"
+        },
+        "Help": {
+          "type": "boolean",
+          "description": "Shows the help text for this build assembly"
+        },
+        "Host": {
+          "type": "string",
+          "description": "Host for execution. Default is 'automatic'",
+          "enum": [
+            "AppVeyor",
+            "AzurePipelines",
+            "Bamboo",
+            "Bitbucket",
+            "Bitrise",
+            "GitHubActions",
+            "GitLab",
+            "Jenkins",
+            "Rider",
+            "SpaceAutomation",
+            "TeamCity",
+            "Terminal",
+            "TravisCI",
+            "VisualStudio",
+            "VSCode"
+          ]
+        },
+        "NoLogo": {
+          "type": "boolean",
+          "description": "Disables displaying the NUKE logo"
+        },
+        "Partition": {
+          "type": "string",
+          "description": "Partition to use on CI"
+        },
+        "Plan": {
+          "type": "boolean",
+          "description": "Shows the execution plan (HTML)"
+        },
+        "Profile": {
+          "type": "array",
+          "description": "Defines the profiles to load",
+          "items": {
+            "type": "string"
+          }
+        },
+        "Root": {
+          "type": "string",
+          "description": "Root directory during build execution"
+        },
+        "Skip": {
+          "type": "array",
+          "description": "List of targets to be skipped. Empty list skips all dependencies",
+          "items": {
+            "type": "string",
+            "enum": [
+              "Default",
+              "DevBuild",
+              "DevBuildDefault",
+              "DevBuildReleaseSimulation",
+              "ReleaseMaa",
+              "SetMaaChangeLog",
+              "SetPackageBundled",
+              "SetVersion",
+              "UseClean",
+              "UseCommitVersion",
+              "UseMaaChangeLog",
+              "UseMaaDevBundle",
+              "UseMaaRelease",
+              "UsePublishArtifact",
+              "UsePublishRelease",
+              "UseRsVersion",
+              "UseTagVersion",
+              "WithCompileCoreRelease",
+              "WithCompileWpfRelease",
+              "WithSyncRes"
+            ]
+          }
+        },
+        "Target": {
+          "type": "array",
+          "description": "List of targets to be invoked. Default is '{default_target}'",
+          "items": {
+            "type": "string",
+            "enum": [
+              "Default",
+              "DevBuild",
+              "DevBuildDefault",
+              "DevBuildReleaseSimulation",
+              "ReleaseMaa",
+              "SetMaaChangeLog",
+              "SetPackageBundled",
+              "SetVersion",
+              "UseClean",
+              "UseCommitVersion",
+              "UseMaaChangeLog",
+              "UseMaaDevBundle",
+              "UseMaaRelease",
+              "UsePublishArtifact",
+              "UsePublishRelease",
+              "UseRsVersion",
+              "UseTagVersion",
+              "WithCompileCoreRelease",
+              "WithCompileWpfRelease",
+              "WithSyncRes"
+            ]
+          }
+        },
+        "Verbosity": {
+          "type": "string",
+          "description": "Logging verbosity during build execution. Default is 'Normal'",
+          "enum": [
+            "Minimal",
+            "Normal",
+            "Quiet",
+            "Verbose"
+          ]
+        }
+      }
+    }
+  }
+}

.nuke/parameters.json

@@ -0,0 +1,4 @@
+{
+  "$schema": "./build.schema.json",
+  "Solution": "tools/MaaBuilder.sln"
+}

.vscode/settings.json

@@ -0,0 +1,10 @@
+{
+    "json.schemas": [
+        {
+            "fileMatch": [
+                "resource/tasks.json"
+            ],
+            "url": "./docs/maa_tasks_schema.json"
+        }
+    ]
+}

3rdparty/include/Arknights-Tile-Pos/TileCalc.hpp

@@ -1,13 +1,15 @@
 #pragma once
 
-#include <string>
-#include <vector>
 #include <cmath>
 #include <fstream>
 #include <iostream>
+#include <string>
+#include <vector>
 
-#include <opencv2/core.hpp>
 #include <meojson/json.hpp>
+#include <opencv2/core.hpp>
+
+#include "TileDef.hpp"
 
 namespace Map
 {
@@ -25,22 +27,33 @@ namespace Map
         int get_width() const { return width; }
         int get_height() const { return height; }
         Tile get_item(int y, int x) const { return tiles[y][x]; }
-        int view = 0;
-        std::string stageId;
-        std::string	code;
-        std::string	levelId;
-        std::string	name;
+        std::vector<cv::Point3d> view;
+        LevelKey key;
+
     private:
         int height = 0;
         int width = 0;
         std::vector<std::vector<Tile>> tiles;
     };
+
     class TileCalc
     {
     public:
-        TileCalc(int width, int height, const std::string& dir);
-        bool run(const std::string& code_or_name, bool side, std::vector<std::vector<cv::Point2d>>& out_pos, std::vector<std::vector<Tile>>& out_tiles) const;
+        TileCalc(int width, int height, const json::array& json);
+
+        bool contains(const std::string& any_key);
+        bool contains(const LevelKey& key);
+
+        bool run(const std::string& any_key, bool side, std::vector<std::vector<cv::Point2d>>& out_pos,
+                 std::vector<std::vector<Tile>>& out_tiles) const;
+        bool run(const LevelKey& key, bool side, std::vector<std::vector<cv::Point2d>>& out_pos,
+                 std::vector<std::vector<Tile>>& out_tiles) const;
+
     private:
+        bool run(const Level& level, bool side, std::vector<std::vector<cv::Point2d>>& out_pos,
+                 std::vector<std::vector<Tile>>& out_tiles) const;
+        bool adapter(double& x, double& y) const;
+
         int width = 0;
         int height = 0;
         const double degree = atan(1.0) * 4 / 180;
@@ -48,10 +61,9 @@ namespace Map
         cv::Mat MatrixP = cv::Mat(4, 4, CV_64F);
         cv::Mat MatrixX = cv::Mat(4, 4, CV_64F);
         cv::Mat MatrixY = cv::Mat(4, 4, CV_64F);
-        bool adapter(double& x, double& y) const;
     };
 
-    inline void InitMat4x4(cv::Mat& m, double(*num)[4])
+    inline void InitMat4x4(cv::Mat& m, double (*num)[4])
     {
         for (int i = 0; i < m.rows; i++)
             for (int j = 0; j < m.cols; j++)
@@ -60,68 +72,54 @@ namespace Map
 
     inline Level::Level(const json::value& data)
     {
-        Level::stageId = data.at("stageId").as_string();
-        Level::code = data.at("code").as_string();
-        Level::levelId = data.at("levelId").as_string();
-        Level::name = data.get("name", "null");
-        Level::height = data.at("height").as_integer();
-        Level::width = data.at("width").as_integer();
-        Level::view = data.at("view").as_integer();
+        key.stageId = data.at("stageId").as_string();
+        key.code = data.at("code").as_string();
+        key.levelId = data.at("levelId").as_string();
+        key.name = data.get("name", "null");
+        this->height = data.at("height").as_integer();
+        this->width = data.at("width").as_integer();
+        for (const json::value& point_data : data.at("view").as_array()) {
+            cv::Point3d tmp;
+            auto point_array = point_data.as_array();
+            tmp.x = point_array[0].as_double();
+            tmp.y = point_array[1].as_double();
+            tmp.z = point_array[2].as_double();
+            this->view.emplace_back(std::move(tmp));
+        }
         for (const json::value& row : data.at("tiles").as_array()) {
             std::vector<Tile> tmp;
-            tmp.reserve(Level::width);
+            tmp.reserve(this->width);
             for (const json::value& tile : row.as_array()) {
-                tmp.emplace_back(Tile{
-                    tile.at("heightType").as_integer(),
-                    tile.at("buildableType").as_integer(),
-                    tile.get("tileKey", std::string()) });
+                tmp.emplace_back(Tile { tile.at("heightType").as_integer(), tile.at("buildableType").as_integer(),
+                                        tile.get("tileKey", std::string()) });
             }
             tiles.emplace_back(std::move(tmp));
         }
     }
 
-    inline TileCalc::TileCalc(int width, int height, const std::string& dir)
+    inline TileCalc::TileCalc(int width, int height, const json::array& json)
     {
-        TileCalc::width = width;
-        TileCalc::height = height;
+        this->width = width;
+        this->height = height;
         double ratio = static_cast<double>(height) / width;
-        double matrixP[4][4]{
-            { ratio / tan(20 * degree), 0, 0, 0},
-            { 0, 1 / tan(20 * degree), 0, 0},
-            { 0, 0, -(1000 + 0.3) / (1000 - 0.3), -(1000 * 0.3 * 2) / (1000 - 0.3)},
-            { 0, 0, -1, 0 }
-        };
-        InitMat4x4(TileCalc::MatrixP, matrixP);
-        double matrixX[4][4]{
-                    { 1, 0, 0, 0},
-                    { 0, cos(30 * degree), -sin(30 * degree), 0},
-                    { 0, -sin(30 * degree), -cos(30 * degree), 0},
-                    { 0, 0, 0, 1}
-        };
-        InitMat4x4(TileCalc::MatrixX, matrixX);
-        double matrixY[4][4]{
-                    { cos(10 * degree), 0, sin(10 * degree), 0},
-                    { 0, 1, 0, 0},
-                    { -sin(10 * degree), 0, cos(10 * degree), 0},
-                    { 0, 0, 0, 1}
-        };
-        InitMat4x4(TileCalc::MatrixY, matrixY);
-        std::ifstream ifs(dir, std::ios::in);
-        if (!ifs.is_open()) {
-            std::cerr << "Read resource failed" << std::endl;
-            throw "Read resource failed";
-        }
-        std::stringstream iss;
-        iss << ifs.rdbuf();
-        ifs.close();
-        std::string content = iss.str();
-        auto ret = json::parse(content);
-        if (!ret) {
-            std::cerr << "Parsing failed" << std::endl;
-            throw "Parsing failed";
-        }
-        for (const json::value& item : ret.value().as_array()) {
-            TileCalc::levels.emplace_back(item);
+        double matrixP[4][4] { { ratio / tan(20 * degree), 0, 0, 0 },
+                               { 0, 1 / tan(20 * degree), 0, 0 },
+                               { 0, 0, -(1000 + 0.3) / (1000 - 0.3), -(1000 * 0.3 * 2) / (1000 - 0.3) },
+                               { 0, 0, -1, 0 } };
+        InitMat4x4(this->MatrixP, matrixP);
+        double matrixX[4][4] { { 1, 0, 0, 0 },
+                               { 0, cos(30 * degree), -sin(30 * degree), 0 },
+                               { 0, -sin(30 * degree), -cos(30 * degree), 0 },
+                               { 0, 0, 0, 1 } };
+        InitMat4x4(this->MatrixX, matrixX);
+        double matrixY[4][4] { { cos(10 * degree), 0, sin(10 * degree), 0 },
+                               { 0, 1, 0, 0 },
+                               { -sin(10 * degree), 0, cos(10 * degree), 0 },
+                               { 0, 0, 0, 1 } };
+        InitMat4x4(this->MatrixY, matrixY);
+
+        for (const json::value& item : json) {
+            this->levels.emplace_back(item);
         }
     }
 
@@ -141,96 +139,81 @@ namespace Map
         return true;
     }
 
-    inline bool TileCalc::run(const std::string& code_or_name, bool side, std::vector<std::vector<cv::Point2d>>& out_pos, std::vector<std::vector<Tile>>& out_tiles) const
+    inline bool TileCalc::contains(const std::string& any_key)
     {
-        bool runned = false;
-        double x = 0, y = 0, z = 0;
-        for (const Map::Level& level : TileCalc::levels) {
-            if (/*level.code == code_or_name || */
-                level.name == code_or_name) {
-                switch (level.view) {
-                case 0:
-                    x = 0;
-                    y = -4.81;
-                    z = -7.76;
-                    if (side) {
-                        x += 0.5975104570388794;
-                        y -= 0.5;
-                        z -= 0.882108688354492;
-                    }
-                    break;
-                case 1:
-                    x = 0;
-                    y = -5.60;
-                    z = -8.92;
-                    if (side) {
-                        x += 0.7989424467086792;
-                        y -= 0.5;
-                        z -= 0.86448486328125;
-                    }
-                    break;
-                case 2:
-                    x = 0;
-                    y = -5.08;
-                    z = -8.04;
-                    if (side) {
-                        x += 0.6461319923400879;
-                        y -= 0.5;
-                        z -= 0.877854309082031;
-                    }
-                    break;
-                default:
-                    x = 0;
-                    y = -6.1;
-                    z = -9.78;
-                    if (side) {
-                        x += 0.948279857635498;
-                        y -= 0.5;
-                        z -= 0.85141918182373;
-                    }
-                    break;
-                }
-                double adapter_y = 0, adapter_z = 0;
-                TileCalc::adapter(adapter_y, adapter_z);
-                double matrix[4][4]{
-                    { 1, 0, 0, -x},
-                    { 0, 1, 0, -y - adapter_y},
-                    { 0, 0, 1, -z - adapter_z},
-                    { 0, 0, 0, 1}
-                };
-                auto raw = cv::Mat(cv::Size(4, 4), CV_64F);
-                auto Finall_Matrix = cv::Mat(cv::Size(4, 4), CV_64F);
-                InitMat4x4(raw, matrix);
-                if (side) {
-                    Finall_Matrix = TileCalc::MatrixP * TileCalc::MatrixX * TileCalc::MatrixY * raw;
-                }
-                else {
-                    Finall_Matrix = TileCalc::MatrixP * TileCalc::MatrixX * raw;
-                }
-                int h = level.get_height();
-                int w = level.get_width();
-                auto map_point = cv::Mat(cv::Size(1, 4), CV_64F);
-                map_point.at<double>(3, 0) = 1;
-                auto tmp_pos = std::vector<cv::Point2d>(w);
-                auto tmp_tiles = std::vector<Tile>(w);
-                for (int i = 0; i < h; i++) {
-                    for (int j = 0; j < w; j++) {
-                        tmp_tiles[j] = level.get_item(i, j);
-                        map_point.at<double>(0, 0) = j - (w - 1) / 2.0;
-                        map_point.at<double>(1, 0) = (h - 1) / 2.0 - i;
-                        map_point.at<double>(2, 0) = tmp_tiles[j].heightType * -0.4;
-                        cv::Mat view_point = Finall_Matrix * map_point;
-                        view_point = view_point / view_point.at<double>(3, 0);
-                        view_point = (view_point + 1) / 2;
-                        tmp_pos[j] = cv::Point2d(view_point.at<double>(0, 0) * TileCalc::width, (1 - view_point.at<double>(1, 0)) * TileCalc::height);
-                    }
-                    out_pos.emplace_back(tmp_pos);
-                    out_tiles.emplace_back(tmp_tiles);
-                }
-                runned = true;
-                break;
-            }
-        }
-        return runned;
+        auto iter = std::find_if(levels.cbegin(), levels.cend(),
+                                 [&any_key](const Level& level) -> bool { return level.key == any_key; });
+        return iter != levels.cend();
     }
-}
+
+    bool TileCalc::contains(const LevelKey& key)
+    {
+        auto iter = std::find_if(levels.cbegin(), levels.cend(),
+                                 [&key](const Level& level) -> bool { return level.key == key; });
+        return iter != levels.cend();
+    }
+
+    inline bool TileCalc::run(const std::string& any_key, bool side, std::vector<std::vector<cv::Point2d>>& out_pos,
+                              std::vector<std::vector<Tile>>& out_tiles) const
+    {
+        auto iter = std::find_if(levels.cbegin(), levels.cend(),
+                                 [&any_key](const Level& level) -> bool { return level.key == any_key; });
+        if (iter == levels.cend()) {
+            return false;
+        }
+        return run(*iter, side, out_pos, out_tiles);
+    }
+
+    inline bool TileCalc::run(const LevelKey& key, bool side, std::vector<std::vector<cv::Point2d>>& out_pos,
+                              std::vector<std::vector<Tile>>& out_tiles) const
+    {
+        auto iter = std::find_if(levels.cbegin(), levels.cend(),
+                                 [&key](const Level& level) -> bool { return level.key == key; });
+        if (iter == levels.cend()) {
+            return false;
+        }
+        return run(*iter, side, out_pos, out_tiles);
+    }
+
+    inline bool TileCalc::run(const Level& level, bool side, std::vector<std::vector<cv::Point2d>>& out_pos,
+                              std::vector<std::vector<Tile>>& out_tiles) const
+    {
+        auto [x, y, z] = level.view[side ? 1 : 0];
+        double adapter_y = 0, adapter_z = 0;
+        this->adapter(adapter_y, adapter_z);
+        double matrix[4][4] {
+            { 1, 0, 0, -x }, { 0, 1, 0, -y - adapter_y }, { 0, 0, 1, -z - adapter_z }, { 0, 0, 0, 1 }
+        };
+        auto raw = cv::Mat(cv::Size(4, 4), CV_64F);
+        auto Finall_Matrix = cv::Mat(cv::Size(4, 4), CV_64F);
+        InitMat4x4(raw, matrix);
+        if (side) {
+            Finall_Matrix = this->MatrixP * this->MatrixX * this->MatrixY * raw;
+        }
+        else {
+            Finall_Matrix = this->MatrixP * this->MatrixX * raw;
+        }
+        int h = level.get_height();
+        int w = level.get_width();
+        auto map_point = cv::Mat(cv::Size(1, 4), CV_64F);
+        map_point.at<double>(3, 0) = 1;
+        auto tmp_pos = std::vector<cv::Point2d>(w);
+        auto tmp_tiles = std::vector<Tile>(w);
+        for (int i = 0; i < h; i++) {
+            for (int j = 0; j < w; j++) {
+                tmp_tiles[j] = level.get_item(i, j);
+                map_point.at<double>(0, 0) = j - (w - 1) / 2.0;
+                map_point.at<double>(1, 0) = (h - 1) / 2.0 - i;
+                map_point.at<double>(2, 0) = tmp_tiles[j].heightType * -0.4;
+                cv::Mat view_point = Finall_Matrix * map_point;
+                view_point = view_point / view_point.at<double>(3, 0);
+                view_point = (view_point + 1) / 2;
+                tmp_pos[j] = cv::Point2d(view_point.at<double>(0, 0) * this->width,
+                                         (1 - view_point.at<double>(1, 0)) * this->height);
+            }
+            out_pos.emplace_back(tmp_pos);
+            out_tiles.emplace_back(tmp_tiles);
+        }
+        return true;
+    }
+} // namespace Map

3rdparty/include/Arknights-Tile-Pos/TileDef.hpp

@@ -0,0 +1,32 @@
+#pragma once
+
+#include <string>
+
+namespace Map
+{
+    struct LevelKey
+    {
+        std::string stageId;
+        std::string code;
+        std::string levelId;
+        std::string name;
+
+        bool empty_or_equal(const std::string& lhs, const std::string& rhs) const noexcept
+        {
+            return (lhs.empty() || rhs.empty()) ? true : lhs == rhs;
+        }
+        bool operator==(const LevelKey& other) const noexcept
+        {
+            return empty_or_equal(stageId, other.stageId) && empty_or_equal(code, other.code) &&
+                   empty_or_equal(levelId, other.levelId) && empty_or_equal(name, other.name);
+        }
+        bool operator==(const std::string& any_key) const noexcept
+        {
+            if (any_key.empty()) {
+                return false;
+            }
+            return empty_or_equal(stageId, any_key) || empty_or_equal(code, any_key) ||
+                   empty_or_equal(levelId, any_key) || empty_or_equal(name, any_key);
+        }
+    };
+}

3rdparty/include/PaddleOCR/exports.h

@@ -1,37 +0,0 @@
-#pragma once
-
-// The way how the function is called
-#if !defined(OCR_CALL)
-#if defined(_WIN32)
-#define OCR_CALL __stdcall
-#else
-#define OCR_CALL
-#endif /* _WIN32 */
-#endif /* OCR_CALL */
-
-// The function exported symbols
-#if defined _WIN32 || defined __CYGWIN__
-#define OCR_IMPORT __declspec(dllimport)
-#define OCR_EXPORT __declspec(dllexport)
-#define OCR_LOCAL
-#else
-#if __GNUC__ >= 4
-#define OCR_IMPORT __attribute__ ((visibility ("default")))
-#define OCR_EXPORT __attribute__ ((visibility ("default")))
-#define OCR_LOCAL  __attribute__ ((visibility ("hidden")))
-#else
-#define OCR_IMPORT
-#define OCR_EXPORT
-#define OCR_LOCAL
-#endif
-#endif
-
-#ifdef OCR_EXPORTS // defined if we are building the DLL (instead of using it)
-#define OCRAPI_PORT OCR_EXPORT
-#else
-#define OCRAPI_PORT OCR_IMPORT
-#endif // OCR_EXPORTS
-
-#define OCRAPI OCRAPI_PORT OCR_CALL
-
-#define OCRLOCAL OCR_LOCAL OCR_CALL

3rdparty/include/PaddleOCR/paddle_ocr.h

@@ -1,56 +0,0 @@
-#pragma once
-
-#include "exports.h"
-
-struct paddle_ocr_t;
-typedef int OCR_ERROR;
-typedef unsigned char uint8_t;
-
-#define OCR_SUCCESS 0
-#define OCR_FAILURE 1
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-    OCRAPI_PORT paddle_ocr_t* OCR_CALL PaddleOcrCreate(
-        const char* det_model_dir, const char* rec_model_dir,
-        const char* char_list_file, const char* cls_model_dir);
-
-    void OCRAPI PaddleOcrDestroy(paddle_ocr_t* ocr_ptr);
-
-    OCR_ERROR OCRAPI PaddleOcrDet(
-        paddle_ocr_t* ocr_ptr, const uint8_t* encode_buf, size_t encode_buf_size,
-        int* out_boxes, size_t* out_boxes_size,
-        double* out_times, size_t* out_times_size);
-
-    OCR_ERROR OCRAPI PaddleOcrDetWithData(
-        paddle_ocr_t* ocr_ptr, int rows, int cols, int type, void* data,
-        int* out_boxes, size_t* out_boxes_size,
-        double* out_times, size_t* out_times_size);
-
-    OCR_ERROR OCRAPI PaddleOcrRec(
-        paddle_ocr_t* ocr_ptr, const uint8_t* encode_buf, size_t encode_buf_size,
-        char** out_strs, float* out_scores, size_t* out_size,
-        double* out_times, size_t* out_times_size);
-
-    OCR_ERROR OCRAPI PaddleOcrRecWithData(
-        paddle_ocr_t* ocr_ptr, int rows, int cols, int type, void* data,
-        char** out_strs, float* out_scores, size_t* out_size,
-        double* out_times, size_t* out_times_size);
-
-    OCR_ERROR OCRAPI PaddleOcrSystem(
-        paddle_ocr_t* ocr_ptr, const uint8_t* encode_buf, size_t encode_buf_size,
-        bool with_cls,
-        int* out_boxes, char** out_strs, float* out_scores, size_t* out_size,
-        double* out_times, size_t* out_times_size);
-
-    OCR_ERROR OCRAPI PaddleOcrSystemWithData(
-        paddle_ocr_t* ocr_ptr, int rows, int cols, int type, void* data,
-        bool with_cls,
-        int* out_boxes, char** out_strs, float* out_scores, size_t* out_size,
-        double* out_times, size_t* out_times_size);
-
-#ifdef __cplusplus
-}
-#endif

3rdparty/include/cpp-base64/base64.hpp

@@ -1,310 +0,0 @@
-/*
-   base64.cpp and base64.h
-
-   base64 encoding and decoding with C++.
-   More information at
-     https://renenyffenegger.ch/notes/development/Base64/Encoding-and-decoding-base-64-with-cpp
-
-   Version: 2.rc.08 (release candidate)
-
-   Copyright (C) 2004-2017, 2020, 2021 René Nyffenegger
-
-   This source code is provided 'as-is', without any express or implied
-   warranty. In no event will the author be held liable for any damages
-   arising from the use of this software.
-
-   Permission is granted to anyone to use this software for any purpose,
-   including commercial applications, and to alter it and redistribute it
-   freely, subject to the following restrictions:
-
-   1. The origin of this source code must not be misrepresented; you must not
-      claim that you wrote the original source code. If you use this source code
-      in a product, an acknowledgment in the product documentation would be
-      appreciated but is not required.
-
-   2. Altered source versions must be plainly marked as such, and must not be
-      misrepresented as being the original source code.
-
-   3. This notice may not be removed or altered from any source distribution.
-
-   René Nyffenegger rene.nyffenegger@adp-gmbh.ch
-
-*/
-#ifndef BASE64_H_C0CE2A47_D10E_42C9_A27C_C883944E704A
-#define BASE64_H_C0CE2A47_D10E_42C9_A27C_C883944E704A
-
-#include <string>
-
-#if __cplusplus >= 201703L
-#include <string_view>
-#endif  // __cplusplus >= 201703L
-
-std::string base64_encode     (std::string const& s, bool url = false);
-std::string base64_encode_pem (std::string const& s);
-std::string base64_encode_mime(std::string const& s);
-
-std::string base64_decode(std::string const& s, bool remove_linebreaks = false);
-std::string base64_encode(unsigned char const*, size_t len, bool url = false);
-
-#if __cplusplus >= 201703L
-//
-// Interface with std::string_view rather than const std::string&
-// Requires C++17
-// Provided by Yannic Bonenberger (https://github.com/Yannic)
-//
-std::string base64_encode     (std::string_view s, bool url = false);
-std::string base64_encode_pem (std::string_view s);
-std::string base64_encode_mime(std::string_view s);
-
-std::string base64_decode(std::string_view s, bool remove_linebreaks = false);
-#endif  // __cplusplus >= 201703L
-
-#include <algorithm>
-#include <stdexcept>
-
- //
- // Depending on the url parameter in base64_chars, one of
- // two sets of base64 characters needs to be chosen.
- // They differ in their last two characters.
- //
-static const char* base64_chars[2] = {
-             "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
-             "abcdefghijklmnopqrstuvwxyz"
-             "0123456789"
-             "+/",
-
-             "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
-             "abcdefghijklmnopqrstuvwxyz"
-             "0123456789"
-             "-_"};
-
-static unsigned int pos_of_char(const unsigned char chr) {
- //
- // Return the position of chr within base64_encode()
- //
-
-    if      (chr >= 'A' && chr <= 'Z') return chr - 'A';
-    else if (chr >= 'a' && chr <= 'z') return chr - 'a' + ('Z' - 'A')               + 1;
-    else if (chr >= '0' && chr <= '9') return chr - '0' + ('Z' - 'A') + ('z' - 'a') + 2;
-    else if (chr == '+' || chr == '-') return 62; // Be liberal with input and accept both url ('-') and non-url ('+') base 64 characters (
-    else if (chr == '/' || chr == '_') return 63; // Ditto for '/' and '_'
-    else
- //
- // 2020-10-23: Throw std::exception rather than const char*
- //(Pablo Martin-Gomez, https://github.com/Bouska)
- //
-    throw std::runtime_error("Input is not valid base64-encoded data.");
-}
-
-static std::string insert_linebreaks(std::string str, size_t distance) {
- //
- // Provided by https://github.com/JomaCorpFX, adapted by me.
- //
-    if (!str.length()) {
-        return "";
-    }
-
-    size_t pos = distance;
-
-    while (pos < str.size()) {
-        str.insert(pos, "\n");
-        pos += distance + 1;
-    }
-
-    return str;
-}
-
-template <typename String, unsigned int line_length>
-static std::string encode_with_line_breaks(String s) {
-  return insert_linebreaks(base64_encode(s, false), line_length);
-}
-
-template <typename String>
-static std::string encode_pem(String s) {
-  return encode_with_line_breaks<String, 64>(s);
-}
-
-template <typename String>
-static std::string encode_mime(String s) {
-  return encode_with_line_breaks<String, 76>(s);
-}
-
-template <typename String>
-static std::string encode(String s, bool url) {
-  return base64_encode(reinterpret_cast<const unsigned char*>(s.data()), s.length(), url);
-}
-
-std::string base64_encode(unsigned char const* bytes_to_encode, size_t in_len, bool url) {
-
-    size_t len_encoded = (in_len +2) / 3 * 4;
-
-    unsigned char trailing_char = url ? '.' : '=';
-
- //
- // Choose set of base64 characters. They differ
- // for the last two positions, depending on the url
- // parameter.
- // A bool (as is the parameter url) is guaranteed
- // to evaluate to either 0 or 1 in C++ therefore,
- // the correct character set is chosen by subscripting
- // base64_chars with url.
- //
-    const char* base64_chars_ = base64_chars[url];
-
-    std::string ret;
-    ret.reserve(len_encoded);
-
-    unsigned int pos = 0;
-
-    while (pos < in_len) {
-        ret.push_back(base64_chars_[(bytes_to_encode[pos + 0] & 0xfc) >> 2]);
-
-        if (pos+1 < in_len) {
-           ret.push_back(base64_chars_[((bytes_to_encode[pos + 0] & 0x03) << 4) + ((bytes_to_encode[pos + 1] & 0xf0) >> 4)]);
-
-           if (pos+2 < in_len) {
-              ret.push_back(base64_chars_[((bytes_to_encode[pos + 1] & 0x0f) << 2) + ((bytes_to_encode[pos + 2] & 0xc0) >> 6)]);
-              ret.push_back(base64_chars_[  bytes_to_encode[pos + 2] & 0x3f]);
-           }
-           else {
-              ret.push_back(base64_chars_[(bytes_to_encode[pos + 1] & 0x0f) << 2]);
-              ret.push_back(trailing_char);
-           }
-        }
-        else {
-
-            ret.push_back(base64_chars_[(bytes_to_encode[pos + 0] & 0x03) << 4]);
-            ret.push_back(trailing_char);
-            ret.push_back(trailing_char);
-        }
-
-        pos += 3;
-    }
-
-
-    return ret;
-}
-
-template <typename String>
-static std::string decode(String encoded_string, bool remove_linebreaks) {
- //
- // decode(…) is templated so that it can be used with String = const std::string&
- // or std::string_view (requires at least C++17)
- //
-
-    if (encoded_string.empty()) return std::string();
-
-    if (remove_linebreaks) {
-
-       std::string copy(encoded_string);
-
-       copy.erase(std::remove(copy.begin(), copy.end(), '\n'), copy.end());
-
-       return base64_decode(copy, false);
-    }
-
-    size_t length_of_string = encoded_string.length();
-    size_t pos = 0;
-
- //
- // The approximate length (bytes) of the decoded string might be one or
- // two bytes smaller, depending on the amount of trailing equal signs
- // in the encoded string. This approximation is needed to reserve
- // enough space in the string to be returned.
- //
-    size_t approx_length_of_decoded_string = length_of_string / 4 * 3;
-    std::string ret;
-    ret.reserve(approx_length_of_decoded_string);
-
-    while (pos < length_of_string) {
-    //
-    // Iterate over encoded input string in chunks. The size of all
-    // chunks except the last one is 4 bytes.
-    //
-    // The last chunk might be padded with equal signs or dots
-    // in order to make it 4 bytes in size as well, but this
-    // is not required as per RFC 2045.
-    //
-    // All chunks except the last one produce three output bytes.
-    //
-    // The last chunk produces at least one and up to three bytes.
-    //
-
-       size_t pos_of_char_1 = pos_of_char(encoded_string[pos+1] );
-
-    //
-    // Emit the first output byte that is produced in each chunk:
-    //
-       ret.push_back(static_cast<std::string::value_type>( ( (pos_of_char(encoded_string[pos+0]) ) << 2 ) + ( (pos_of_char_1 & 0x30 ) >> 4)));
-
-       if ( ( pos + 2 < length_of_string  )       &&  // Check for data that is not padded with equal signs (which is allowed by RFC 2045)
-              encoded_string[pos+2] != '='        &&
-              encoded_string[pos+2] != '.'            // accept URL-safe base 64 strings, too, so check for '.' also.
-          )
-       {
-       //
-       // Emit a chunk's second byte (which might not be produced in the last chunk).
-       //
-          unsigned int pos_of_char_2 = pos_of_char(encoded_string[pos+2] );
-          ret.push_back(static_cast<std::string::value_type>( (( pos_of_char_1 & 0x0f) << 4) + (( pos_of_char_2 & 0x3c) >> 2)));
-
-          if ( ( pos + 3 < length_of_string )     &&
-                 encoded_string[pos+3] != '='     &&
-                 encoded_string[pos+3] != '.'
-             )
-          {
-          //
-          // Emit a chunk's third byte (which might not be produced in the last chunk).
-          //
-             ret.push_back(static_cast<std::string::value_type>( ( (pos_of_char_2 & 0x03 ) << 6 ) + pos_of_char(encoded_string[pos+3])   ));
-          }
-       }
-
-       pos += 4;
-    }
-
-    return ret;
-}
-
-std::string base64_decode(std::string const& s, bool remove_linebreaks) {
-   return decode(s, remove_linebreaks);
-}
-
-std::string base64_encode(std::string const& s, bool url) {
-   return encode(s, url);
-}
-
-std::string base64_encode_pem (std::string const& s) {
-   return encode_pem(s);
-}
-
-std::string base64_encode_mime(std::string const& s) {
-   return encode_mime(s);
-}
-
-#if __cplusplus >= 201703L
-//
-// Interface with std::string_view rather than const std::string&
-// Requires C++17
-// Provided by Yannic Bonenberger (https://github.com/Yannic)
-//
-
-std::string base64_encode(std::string_view s, bool url) {
-   return encode(s, url);
-}
-
-std::string base64_encode_pem(std::string_view s) {
-   return encode_pem(s);
-}
-
-std::string base64_encode_mime(std::string_view s) {
-   return encode_mime(s);
-}
-
-std::string base64_decode(std::string_view s, bool remove_linebreaks) {
-   return decode(s, remove_linebreaks);
-}
-
-#endif  // __cplusplus >= 201703L
-
-#endif /* BASE64_H_C0CE2A47_D10E_42C9_A27C_C883944E704A */

3rdparty/include/fastdeploy/backends/backend.h

@@ -0,0 +1,77 @@
+// 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 <iostream>
+#include <memory>
+#include <string>
+#include <vector>
+
+#include "fastdeploy/backends/common/multiclass_nms.h"
+#include "fastdeploy/core/fd_tensor.h"
+#include "fastdeploy/core/fd_type.h"
+
+namespace fastdeploy {
+
+/*! @brief Information of Tensor
+ */
+struct TensorInfo {
+  std::string name;        ///< Name of tensor
+  std::vector<int> shape;  ///< Shape of tensor
+  FDDataType dtype;        ///< Data type of tensor
+
+  friend std::ostream& operator<<(std::ostream& output,
+                                  const TensorInfo& info) {
+    output << "TensorInfo(name: " << info.name << ", shape: [";
+    for (size_t i = 0; i < info.shape.size(); ++i) {
+      if (i == info.shape.size() - 1) {
+        output << info.shape[i];
+      } else {
+        output << info.shape[i] << ", ";
+      }
+    }
+    output << "], dtype: " << Str(info.dtype) << ")";
+    return output;
+  }
+};
+
+class BaseBackend {
+ public:
+  bool initialized_ = false;
+
+  BaseBackend() {}
+  virtual ~BaseBackend() = default;
+
+  virtual bool Initialized() const { return initialized_; }
+
+  virtual int NumInputs() const = 0;
+  virtual int NumOutputs() const = 0;
+  virtual TensorInfo GetInputInfo(int index) = 0;
+  virtual TensorInfo GetOutputInfo(int index) = 0;
+  virtual std::vector<TensorInfo> GetInputInfos() = 0;
+  virtual std::vector<TensorInfo> GetOutputInfos() = 0;
+  // if copy_to_fd is true, copy memory data to FDTensor
+  // else share memory to FDTensor(only Paddle、ORT、TRT、OpenVINO support it)
+  virtual bool Infer(std::vector<FDTensor>& inputs,
+                     std::vector<FDTensor>* outputs,
+                     bool copy_to_fd = true) = 0;
+  virtual std::unique_ptr<BaseBackend> Clone(void *stream = nullptr,
+                                             int device_id = -1) {
+    FDERROR << "Clone no support" << std::endl;
+    return nullptr;
+  }
+};
+
+}  // namespace fastdeploy

3rdparty/include/fastdeploy/backends/common/multiclass_nms.h

@@ -0,0 +1,45 @@
+// 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 <map>
+#include <string>
+#include <vector>
+
+namespace fastdeploy {
+namespace backend {
+struct MultiClassNMS {
+  int64_t background_label = -1;
+  int64_t keep_top_k = -1;
+  float nms_eta;
+  float nms_threshold = 0.7;
+  int64_t nms_top_k;
+  bool normalized;
+  float score_threshold;
+
+  std::vector<int32_t> out_num_rois_data;
+  std::vector<int32_t> out_index_data;
+  std::vector<float> out_box_data;
+  void FastNMS(const float* boxes, const float* scores, const int& num_boxes,
+               std::vector<int>* keep_indices);
+  int NMSForEachSample(const float* boxes, const float* scores, int num_boxes,
+                       int num_classes,
+                       std::map<int, std::vector<int>>* keep_indices);
+  void Compute(const float* boxes, const float* scores,
+               const std::vector<int64_t>& boxes_dim,
+               const std::vector<int64_t>& scores_dim);
+};
+}  // namespace backend
+
+}  // namespace fastdeploy

3rdparty/include/fastdeploy/backends/ort/ops/adaptive_pool2d.h

@@ -0,0 +1,89 @@
+// 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 <map>
+#include <string>
+#include <algorithm>
+#include <cmath>
+#include "fastdeploy/core/fd_tensor.h"
+#include "fastdeploy/utils/utils.h"
+
+#ifndef NON_64_PLATFORM
+#include "onnxruntime_cxx_api.h"  // NOLINT
+
+#ifdef WITH_GPU
+#include "fastdeploy/backends/op_cuda_kernels/adaptive_pool2d_kernel.h"
+#endif
+
+namespace fastdeploy {
+struct AdaptivePool2dKernel {
+ protected:
+  std::string pooling_type_ = "avg";
+  std::vector<int64_t> output_size_ = {};
+  Ort::CustomOpApi ort_;
+  void* compute_stream_;
+  const char* provider_;
+
+ public:
+  AdaptivePool2dKernel(Ort::CustomOpApi ort,
+                        const OrtKernelInfo* info,
+                        const char* provider)
+      : ort_(ort) {
+    GetAttribute(info);
+    provider_ = provider;
+  }
+
+  void GetAttribute(const OrtKernelInfo* info);
+
+  void Compute(OrtKernelContext* context);
+
+  void CpuAdaptivePool(const std::vector<int64_t>& input_size,
+                        const std::vector<int64_t>& output_size,
+                        const float* input_data,
+                        float* output_data);
+};
+
+struct AdaptivePool2dOp
+    : Ort::CustomOpBase<AdaptivePool2dOp, AdaptivePool2dKernel> {
+  explicit AdaptivePool2dOp(const char* provider) : provider_(provider) {}
+  void* CreateKernel(Ort::CustomOpApi api, const OrtKernelInfo* info) const {
+    return new AdaptivePool2dKernel(api, info, provider_);
+  }
+
+  const char* GetName() const { return "AdaptivePool2d"; }
+
+  size_t GetInputTypeCount() const { return 1; }
+
+  ONNXTensorElementDataType GetInputType(size_t index) const {
+    return ONNX_TENSOR_ELEMENT_DATA_TYPE_FLOAT;
+  }
+
+  size_t GetOutputTypeCount() const { return 1; }
+
+  ONNXTensorElementDataType GetOutputType(size_t index) const {
+    return ONNX_TENSOR_ELEMENT_DATA_TYPE_FLOAT;
+  }
+
+  const char* GetExecutionProviderType() const {
+    return provider_;
+  }
+ private:
+  const char* provider_;
+};
+
+}  // namespace fastdeploy
+
+#endif

3rdparty/include/fastdeploy/backends/ort/ops/multiclass_nms.h

@@ -0,0 +1,81 @@
+// 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 <map>
+
+#ifndef NON_64_PLATFORM
+#include "onnxruntime_cxx_api.h"  // NOLINT
+
+namespace fastdeploy {
+
+struct MultiClassNmsKernel {
+ protected:
+  int64_t background_label = -1;
+  int64_t keep_top_k = -1;
+  float nms_eta;
+  float nms_threshold = 0.7;
+  int64_t nms_top_k;
+  bool normalized;
+  float score_threshold;
+  Ort::CustomOpApi ort_;
+
+ public:
+  MultiClassNmsKernel(Ort::CustomOpApi ort, const OrtKernelInfo* info)
+      : ort_(ort) {
+    GetAttribute(info);
+  }
+
+  void GetAttribute(const OrtKernelInfo* info);
+
+  void Compute(OrtKernelContext* context);
+  void FastNMS(const float* boxes, const float* scores, const int& num_boxes,
+               std::vector<int>* keep_indices);
+  int NMSForEachSample(const float* boxes, const float* scores, int num_boxes,
+                       int num_classes,
+                       std::map<int, std::vector<int>>* keep_indices);
+};
+
+struct MultiClassNmsOp
+    : Ort::CustomOpBase<MultiClassNmsOp, MultiClassNmsKernel> {
+  void* CreateKernel(Ort::CustomOpApi api, const OrtKernelInfo* info) const {
+    return new MultiClassNmsKernel(api, info);
+  }
+
+  const char* GetName() const { return "MultiClassNMS"; }
+
+  size_t GetInputTypeCount() const { return 2; }
+
+  ONNXTensorElementDataType GetInputType(size_t index) const {
+    return ONNX_TENSOR_ELEMENT_DATA_TYPE_FLOAT;
+  }
+
+  size_t GetOutputTypeCount() const { return 3; }
+
+  ONNXTensorElementDataType GetOutputType(size_t index) const {
+    if (index == 0) {
+      return ONNX_TENSOR_ELEMENT_DATA_TYPE_FLOAT;
+    }
+    return ONNX_TENSOR_ELEMENT_DATA_TYPE_INT32;
+  }
+
+  const char* GetExecutionProviderType() const {
+    return "CPUExecutionProvider";
+  }
+};
+
+}  // namespace fastdeploy
+
+#endif

3rdparty/include/fastdeploy/backends/ort/ort_backend.h

@@ -0,0 +1,99 @@
+// 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 <iostream>
+#include <memory>
+#include <string>
+#include <vector>
+
+#include "fastdeploy/backends/backend.h"
+#include "onnxruntime_cxx_api.h"  // NOLINT
+
+namespace fastdeploy {
+
+struct OrtValueInfo {
+  std::string name;
+  std::vector<int64_t> shape;
+  ONNXTensorElementDataType dtype;
+};
+
+struct OrtBackendOption {
+  // -1 means default
+  // 0: ORT_DISABLE_ALL
+  // 1: ORT_ENABLE_BASIC
+  // 2: ORT_ENABLE_EXTENDED
+  // 99: ORT_ENABLE_ALL (enable some custom optimizations e.g bert)
+  int graph_optimization_level = -1;
+  int intra_op_num_threads = -1;
+  int inter_op_num_threads = -1;
+  // 0: ORT_SEQUENTIAL
+  // 1: ORT_PARALLEL
+  int execution_mode = -1;
+  bool use_gpu = false;
+  int gpu_id = 0;
+  void* external_stream_ = nullptr;
+
+  // inside parameter, maybe remove next version
+  bool remove_multiclass_nms_ = false;
+  std::map<std::string, std::string> custom_op_info_;
+};
+
+class OrtBackend : public BaseBackend {
+ public:
+  OrtBackend() {}
+  virtual ~OrtBackend() = default;
+
+  void BuildOption(const OrtBackendOption& option);
+
+  bool InitFromPaddle(const std::string& model_file,
+                      const std::string& params_file,
+                      const OrtBackendOption& option = OrtBackendOption(),
+                      bool verbose = false);
+
+  bool InitFromOnnx(const std::string& model_file,
+                    const OrtBackendOption& option = OrtBackendOption(),
+                    bool from_memory_buffer = false);
+
+  bool Infer(std::vector<FDTensor>& inputs,
+             std::vector<FDTensor>* outputs,
+             bool copy_to_fd = true) override;
+
+  int NumInputs() const override { return inputs_desc_.size(); }
+
+  int NumOutputs() const override { return outputs_desc_.size(); }
+
+  TensorInfo GetInputInfo(int index) override;
+  TensorInfo GetOutputInfo(int index) override;
+  std::vector<TensorInfo> GetInputInfos() override;
+  std::vector<TensorInfo> GetOutputInfos() override;
+  static std::vector<OrtCustomOp*> custom_operators_;
+  void InitCustomOperators();
+
+ private:
+  Ort::Env env_;
+  Ort::Session session_{nullptr};
+  Ort::SessionOptions session_options_;
+  std::shared_ptr<Ort::IoBinding> binding_;
+  std::vector<OrtValueInfo> inputs_desc_;
+  std::vector<OrtValueInfo> outputs_desc_;
+#ifndef NON_64_PLATFORM
+  Ort::CustomOpDomain custom_op_domain_ = Ort::CustomOpDomain("Paddle");
+#endif
+  OrtBackendOption option_;
+  void OrtValueToFDTensor(const Ort::Value& value, FDTensor* tensor,
+                          const std::string& name, bool copy_to_fd);
+};
+}  // namespace fastdeploy

3rdparty/include/fastdeploy/backends/ort/utils.h

@@ -0,0 +1,39 @@
+// 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 <iostream>
+#include <memory>
+#include <string>
+#include <vector>
+
+#include "fastdeploy/backends/backend.h"
+#include "onnxruntime_cxx_api.h"  // NOLINT
+
+namespace fastdeploy {
+
+// Convert FDDataType to OrtDataType
+ONNXTensorElementDataType GetOrtDtype(const FDDataType& fd_dtype);
+
+// Convert OrtDataType to FDDataType
+FDDataType GetFdDtype(const ONNXTensorElementDataType& ort_dtype);
+
+// Create Ort::Value
+// is_backend_cuda specify if the onnxruntime use CUDAExectionProvider
+// While is_backend_cuda = true, and tensor.device = Device::GPU
+// Will directly share the cuda data in tensor to OrtValue
+Ort::Value CreateOrtValue(FDTensor& tensor, bool is_backend_cuda = false);
+
+}  // namespace fastdeploy

3rdparty/include/fastdeploy/backends/rknpu/rknpu2/rknpu2_backend.h

@@ -0,0 +1,104 @@
+// 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/backends/backend.h"
+#include "fastdeploy/core/fd_tensor.h"
+#include "rknn_api.h" // NOLINT
+#include "fastdeploy/backends/rknpu/rknpu2/rknpu2_config.h"
+#include <cstring>
+#include <iostream>
+#include <memory>
+#include <string>
+#include <vector>
+
+namespace fastdeploy {
+struct RKNPU2BackendOption {
+  rknpu2::CpuName cpu_name = rknpu2::CpuName::RK3588;
+
+  // The specification of NPU core setting.It has the following choices :
+  // RKNN_NPU_CORE_AUTO : Referring to automatic mode, meaning that it will
+  // select the idle core inside the NPU.
+  // RKNN_NPU_CORE_0 : Running on the NPU0 core
+  // RKNN_NPU_CORE_1: Runing on the NPU1 core
+  // RKNN_NPU_CORE_2: Runing on the NPU2 core
+  // RKNN_NPU_CORE_0_1: Running on both NPU0 and NPU1 core simultaneously.
+  // RKNN_NPU_CORE_0_1_2: Running on both NPU0, NPU1 and NPU2 simultaneously.
+  rknpu2::CoreMask core_mask = rknpu2::CoreMask::RKNN_NPU_CORE_AUTO;
+};
+
+class RKNPU2Backend : public BaseBackend {
+ public:
+  RKNPU2Backend() = default;
+
+  virtual ~RKNPU2Backend();
+
+  // RKNN API
+  bool LoadModel(void* model);
+
+  bool GetSDKAndDeviceVersion();
+
+  bool SetCoreMask(rknpu2::CoreMask& core_mask) const;
+
+  bool GetModelInputOutputInfos();
+
+  // BaseBackend API
+  void BuildOption(const RKNPU2BackendOption& option);
+
+  bool InitFromRKNN(const std::string& model_file,
+                    const RKNPU2BackendOption& option = RKNPU2BackendOption());
+
+  int NumInputs() const override {
+    return static_cast<int>(inputs_desc_.size());
+  }
+
+  int NumOutputs() const override {
+    return static_cast<int>(outputs_desc_.size());
+  }
+
+  TensorInfo GetInputInfo(int index) override;
+  TensorInfo GetOutputInfo(int index) override;
+  std::vector<TensorInfo> GetInputInfos() override;
+  std::vector<TensorInfo> GetOutputInfos() override;
+  bool Infer(std::vector<FDTensor>& inputs,
+             std::vector<FDTensor>* outputs,
+             bool copy_to_fd = true) override;
+
+ private:
+  // The object of rknn context.
+  rknn_context ctx{};
+  // The structure rknn_sdk_version is used to indicate the version
+  // information of the RKNN SDK.
+  rknn_sdk_version sdk_ver{};
+  // The structure rknn_input_output_num represents the number of
+  // input and output Tensor
+  rknn_input_output_num io_num{};
+  std::vector<TensorInfo> inputs_desc_;
+  std::vector<TensorInfo> outputs_desc_;
+
+  rknn_tensor_attr* input_attrs_ = nullptr;
+  rknn_tensor_attr* output_attrs_ = nullptr;
+
+  rknn_tensor_mem** input_mems_;
+  rknn_tensor_mem** output_mems_;
+
+  bool infer_init = false;
+
+  RKNPU2BackendOption option_;
+
+  static void DumpTensorAttr(rknn_tensor_attr& attr);
+  static FDDataType RknnTensorTypeToFDDataType(rknn_tensor_type type);
+  static rknn_tensor_type FDDataTypeToRknnTensorType(FDDataType type);
+};
+}  // namespace fastdeploy

3rdparty/include/fastdeploy/backends/rknpu/rknpu2/rknpu2_config.h

@@ -0,0 +1,37 @@
+// 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
+
+namespace fastdeploy {
+namespace rknpu2 {
+typedef enum _rknpu2_cpu_name {
+  RK356X = 0, /* run on RK356X. */
+  RK3588 = 1, /* default,run on RK3588. */
+  UNDEFINED,
+} CpuName;
+
+/*! RKNPU2 core mask for mobile device. */
+typedef enum _rknpu2_core_mask {
+  RKNN_NPU_CORE_AUTO = 0,  //< default, run on NPU core randomly.
+  RKNN_NPU_CORE_0 = 1,    //< run on NPU core 0.
+  RKNN_NPU_CORE_1 = 2,    //< run on NPU core 1.
+  RKNN_NPU_CORE_2 = 4,    //< run on NPU core 2.
+  RKNN_NPU_CORE_0_1 =
+      RKNN_NPU_CORE_0 | RKNN_NPU_CORE_1,  //< run on NPU core 1 and core 2.
+  RKNN_NPU_CORE_0_1_2 =
+      RKNN_NPU_CORE_0_1 | RKNN_NPU_CORE_2,  //< run on NPU core 1 and core 2.
+  RKNN_NPU_CORE_UNDEFINED,
+} CoreMask;
+}  // namespace rknpu2
+}  // namespace fastdeploy

3rdparty/include/fastdeploy/core/allocate.h

@@ -0,0 +1,60 @@
+// 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 <memory>
+#include <new>
+#include <numeric>
+#include <string>
+#include <vector>
+
+#include "fastdeploy/utils/utils.h"
+
+namespace fastdeploy {
+
+class FASTDEPLOY_DECL FDHostAllocator {
+ public:
+  bool operator()(void** ptr, size_t size) const;
+};
+
+class FASTDEPLOY_DECL FDHostFree {
+ public:
+  void operator()(void* ptr) const;
+};
+
+#ifdef WITH_GPU
+
+class FASTDEPLOY_DECL FDDeviceAllocator {
+ public:
+  bool operator()(void** ptr, size_t size) const;
+};
+
+class FASTDEPLOY_DECL FDDeviceFree {
+ public:
+  void operator()(void* ptr) const;
+};
+
+class FASTDEPLOY_DECL FDDeviceHostAllocator {
+ public:
+  bool operator()(void** ptr, size_t size) const;
+};
+
+class FASTDEPLOY_DECL FDDeviceHostFree {
+ public:
+  void operator()(void* ptr) const;
+};
+
+#endif
+
+}  // namespace fastdeploy

3rdparty/include/fastdeploy/core/config.h

@@ -0,0 +1,72 @@
+// 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
+
+#ifndef FASTDEPLOY_LIB
+/* #undef FASTDEPLOY_LIB */
+#endif
+
+#ifndef ENABLE_PADDLE_FRONTEND
+/* #undef ENABLE_PADDLE_FRONTEND */
+#endif
+
+#ifndef ENABLE_ORT_BACKEND
+#define ENABLE_ORT_BACKEND
+#endif
+
+#ifndef ENABLE_PADDLE_BACKEND
+/* #undef ENABLE_PADDLE_BACKEND */
+#endif
+
+#ifndef ENABLE_POROS_BACKEND
+/* #undef ENABLE_POROS_BACKEND */
+#endif
+
+#ifndef ENABLE_OPENVINO_BACKEND
+/* #undef ENABLE_OPENVINO_BACKEND */
+#endif
+
+#ifndef WITH_GPU
+/* #undef WITH_GPU */
+#endif
+
+#ifndef ENABLE_TRT_BACKEND
+/* #undef ENABLE_TRT_BACKEND */
+#endif
+
+#ifndef ENABLE_VISION
+#define ENABLE_VISION
+#endif
+
+#ifndef ENABLE_FLYCV
+/* #undef ENABLE_FLYCV */
+#endif
+
+#ifndef ENABLE_TEXT
+/* #undef ENABLE_TEXT */
+#endif
+
+#ifndef ENABLE_OPENCV_CUDA
+/* #undef ENABLE_OPENCV_CUDA */
+#endif
+
+#ifdef ENABLE_VISION
+#ifndef ENABLE_VISION_VISUALIZE
+#define ENABLE_VISION_VISUALIZE
+#endif
+#endif
+
+#ifndef ENABLE_FDTENSOR_FUNC
+/* #undef ENABLE_FDTENSOR_FUNC */
+#endif

3rdparty/include/fastdeploy/core/fd_scalar.h

@@ -0,0 +1,121 @@
+// 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 <cstdint>
+#include <limits>
+
+#include "fastdeploy/core/fd_type.h"
+#include "fastdeploy/core/float16.h"
+
+namespace fastdeploy {
+
+class Scalar {
+ public:
+  // Constructor support implicit
+  Scalar() : Scalar(0) {}
+  Scalar(double val) : dtype_(FDDataType::FP64) {  // NOLINT
+    data_.f64 = val;
+  }
+
+  Scalar(float val) : dtype_(FDDataType::FP32) {  // NOLINT
+    data_.f32 = val;
+  }
+
+  Scalar(float16 val) : dtype_(FDDataType::FP16) {  // NOLINT
+    data_.f16 = val;
+  }
+
+  Scalar(int64_t val) : dtype_(FDDataType::INT64) {  // NOLINT
+    data_.i64 = val;
+  }
+
+  Scalar(int32_t val) : dtype_(FDDataType::INT32) {  // NOLINT
+    data_.i32 = val;
+  }
+
+  Scalar(int16_t val) : dtype_(FDDataType::INT16) {  // NOLINT
+    data_.i16 = val;
+  }
+
+  Scalar(int8_t val) : dtype_(FDDataType::INT8) {  // NOLINT
+    data_.i8 = val;
+  }
+
+  Scalar(uint8_t val) : dtype_(FDDataType::UINT8) {  // NOLINT
+    data_.ui8 = val;
+  }
+
+  Scalar(bool val) : dtype_(FDDataType::BOOL) {  // NOLINT
+    data_.b = val;
+  }
+
+  // The compatible method for fliud operators,
+  // and it will be removed in the future.
+  explicit Scalar(const std::string& str_value) : dtype_(FDDataType::FP64) {
+    if (str_value == "inf") {
+      data_.f64 = std::numeric_limits<double>::infinity();
+    } else if (str_value == "-inf") {
+      data_.f64 = -std::numeric_limits<double>::infinity();
+    } else if (str_value == "nan") {
+      data_.f64 = std::numeric_limits<double>::quiet_NaN();
+    } else {
+      data_.f64 = std::stod(str_value);
+    }
+  }
+
+  template <typename RT> inline RT to() const {
+    switch (dtype_) {
+    case FDDataType::FP32:
+      return static_cast<RT>(data_.f32);
+    case FDDataType::FP64:
+      return static_cast<RT>(data_.f64);
+    case FDDataType::FP16:
+      return static_cast<RT>(data_.f16);
+    case FDDataType::INT32:
+      return static_cast<RT>(data_.i32);
+    case FDDataType::INT64:
+      return static_cast<RT>(data_.i64);
+    case FDDataType::INT16:
+      return static_cast<RT>(data_.i16);
+    case FDDataType::INT8:
+      return static_cast<RT>(data_.i8);
+    case FDDataType::UINT8:
+      return static_cast<RT>(data_.ui8);
+    case FDDataType::BOOL:
+      return static_cast<RT>(data_.b);
+    default:
+      FDASSERT(false, "Invalid enum scalar data type `%s`.",
+               Str(dtype_).c_str());
+    }
+  }
+
+  FDDataType dtype() const { return dtype_; }
+
+ private:
+  FDDataType dtype_;
+  union data {
+    bool b;
+    int8_t i8;
+    int16_t i16;
+    int32_t i32;
+    int64_t i64;
+    uint8_t ui8;
+    float16 f16;
+    float f32;
+    double f64;
+  } data_;
+};
+
+}  // namespace fastdeploy

3rdparty/include/fastdeploy/core/fd_tensor.h

@@ -0,0 +1,153 @@
+// 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 <iostream>
+#include <numeric>
+#include <string>
+#include <vector>
+
+#include "fastdeploy/core/allocate.h"
+#include "fastdeploy/core/fd_scalar.h"
+#include "fastdeploy/core/fd_type.h"
+
+namespace fastdeploy {
+
+struct FASTDEPLOY_DECL FDTensor {
+  // std::vector<int8_t> data;
+  void* buffer_ = nullptr;
+  std::vector<int64_t> shape = {0};
+  std::string name = "";
+  FDDataType dtype = FDDataType::INT8;
+
+  // This use to skip memory copy step
+  // the external_data_ptr will point to the user allocated memory
+  // user has to maintain the memory, allocate and release
+  void* external_data_ptr = nullptr;
+  // The internal data will be on CPU
+  // Some times, the external data is on the GPU, and we are going to use
+  // GPU to inference the model
+  // so we can skip data transfer, which may improve the efficience
+  Device device = Device::CPU;
+  // By default the device id of FDTensor is -1, which means this value is
+  // invalid, and FDTensor is using the same device id as Runtime.
+  int device_id = -1;
+
+  // Whether the data buffer is in pinned memory, which is allocated
+  // with cudaMallocHost()
+  bool is_pinned_memory = false;
+
+  // if the external data is not on CPU, we use this temporary buffer
+  // to transfer data to CPU at some cases we need to visit the
+  // other devices' data
+  std::vector<int8_t> temporary_cpu_buffer;
+
+  // Get data buffer pointer
+  void* MutableData();
+
+  void* Data();
+
+  bool IsShared() { return external_data_ptr != nullptr; }
+
+  void StopSharing();
+
+  const void* Data() const;
+
+  // Use this data to get the tensor data to process
+  // Since the most senario is process data in CPU
+  // this function will return a pointer to cpu memory
+  // buffer.
+  // If the original data is on other device, the data
+  // will copy to cpu store in `temporary_cpu_buffer`
+  const void* CpuData() const;
+
+  // Set user memory buffer for Tensor, the memory is managed by
+  // the user it self, but the Tensor will share the memory with user
+  // So take care with the user buffer
+  void SetExternalData(const std::vector<int64_t>& new_shape,
+                       const FDDataType& data_type, void* data_buffer,
+                       const Device& new_device = Device::CPU,
+                       int new_device_id = -1);
+
+  // Expand the shape of a Tensor. Insert a new axis that will appear
+  // at the `axis` position in the expanded Tensor shape.
+  void ExpandDim(int64_t axis = 0);
+
+  // Squeeze the shape of a Tensor. Erase the axis that will appear
+  // at the `axis` position in the squeezed Tensor shape.
+  void Squeeze(int64_t axis = 0);
+
+  // Initialize Tensor
+  // Include setting attribute for tensor
+  // and allocate cpu memory buffer
+  void Allocate(const std::vector<int64_t>& new_shape,
+                const FDDataType& data_type,
+                const std::string& tensor_name = "",
+                const Device& new_device = Device::CPU);
+
+  // Total size of tensor memory buffer in bytes
+  int Nbytes() const;
+
+  // Total number of elements in this tensor
+  int Numel() const;
+
+  // Get shape of FDTensor
+  std::vector<int64_t> Shape() const { return shape; }
+
+  // Get dtype of FDTensor
+  FDDataType Dtype() const { return dtype; }
+
+  void Resize(size_t nbytes);
+
+  void Resize(const std::vector<int64_t>& new_shape);
+
+  void Resize(const std::vector<int64_t>& new_shape,
+              const FDDataType& data_type, const std::string& tensor_name = "",
+              const Device& new_device = Device::CPU);
+
+  bool Reshape(const std::vector<int64_t>& new_shape);
+  // Debug function
+  // Use this function to print shape, dtype, mean, max, min
+  // prefix will also be printed as tag
+  void PrintInfo(const std::string& prefix = "TensorInfo: ") const;
+
+  bool ReallocFn(size_t nbytes);
+
+  void FreeFn();
+
+  FDTensor() {}
+  explicit FDTensor(const std::string& tensor_name);
+  explicit FDTensor(const char* tensor_name);
+
+  // Deep copy
+  FDTensor(const FDTensor& other);
+  // Move constructor
+  FDTensor(FDTensor&& other);
+
+  // Deep copy assignment
+  FDTensor& operator=(const FDTensor& other);
+  // Move assignment
+  FDTensor& operator=(FDTensor&& other);
+
+  // Scalar to FDTensor
+  explicit FDTensor(const Scalar& scalar);
+
+  ~FDTensor() { FreeFn(); }
+
+  static void CopyBuffer(void* dst, const void* src, size_t nbytes,
+                         const Device& device = Device::CPU,
+                         bool is_pinned_memory = false);
+};
+
+}  // namespace fastdeploy

3rdparty/include/fastdeploy/core/fd_type.h

@@ -0,0 +1,80 @@
+// 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 <ostream>
+#include <sstream>
+#include <string>
+
+#include "fastdeploy/core/config.h"
+#include "fastdeploy/utils/utils.h"
+
+namespace fastdeploy {
+
+enum FASTDEPLOY_DECL Device { CPU, GPU, RKNPU, IPU, TIMVX};
+
+FASTDEPLOY_DECL std::string Str(const Device& d);
+
+enum FASTDEPLOY_DECL FDDataType {
+  BOOL,
+  INT16,
+  INT32,
+  INT64,
+  FP16,
+  FP32,
+  FP64,
+  UNKNOWN1,
+  UNKNOWN2,
+  UNKNOWN3,
+  UNKNOWN4,
+  UNKNOWN5,
+  UNKNOWN6,
+  UNKNOWN7,
+  UNKNOWN8,
+  UNKNOWN9,
+  UNKNOWN10,
+  UNKNOWN11,
+  UNKNOWN12,
+  UNKNOWN13,
+  UINT8,
+  INT8
+};
+
+FASTDEPLOY_DECL std::ostream& operator<<(std::ostream& out, const Device& d);
+
+FASTDEPLOY_DECL std::ostream& operator<<(std::ostream& out,
+                                         const FDDataType& fdt);
+
+FASTDEPLOY_DECL std::string Str(const FDDataType& fdt);
+
+FASTDEPLOY_DECL int32_t FDDataTypeSize(const FDDataType& data_dtype);
+
+template <typename PlainType>
+struct FASTDEPLOY_DECL TypeToDataType {
+  static const FDDataType dtype;
+};
+
+/*! Deep learning model format */
+enum ModelFormat {
+  AUTOREC,      ///< Auto recognize the model format by model file name
+  PADDLE,       ///< Model with paddlepaddle format
+  ONNX,         ///< Model with ONNX format
+  RKNN,         ///< Model with RKNN format
+  TORCHSCRIPT,  ///< Model with TorchScript format
+};
+
+FASTDEPLOY_DECL std::ostream& operator<<(std::ostream& out,
+                                         const ModelFormat& format);
+
+}  // namespace fastdeploy

3rdparty/include/fastdeploy/core/float16.h

@@ -0,0 +1,665 @@
+// 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 <stdint.h>
+
+#include <cmath>
+#include <iostream>
+#include <limits>
+
+#if !defined(_WIN32)
+#define FD_ALIGN(x) __attribute__((aligned(x)))
+#else
+#define FD_ALIGN(x) __declspec(align(x))
+#endif
+
+namespace fastdeploy {
+
+struct FD_ALIGN(2) float16 {
+ public:
+  uint16_t x;
+
+  // The following defaulted special class member functions
+  // are added to make float16 pass the std::is_trivial test
+  float16() = default;
+  float16(const float16& o) = default;
+  float16& operator=(const float16& o) = default;
+  float16(float16&& o) = default;
+  float16& operator=(float16&& o) = default;
+  ~float16() = default;
+
+// Constructors
+
+#ifdef FD_WITH_NATIVE_FP16
+  // __fp16 is a native half precision data type for arm cpu,
+  // float16_t is an alias for __fp16
+  inline explicit float16(const float16_t& h) {
+    x = *reinterpret_cast<const uint16_t*>(&h);
+  }
+#endif
+
+  inline explicit float16(float val) {
+#if defined(FD_WITH_NATIVE_FP16)
+    float32x4_t tmp = vld1q_dup_f32(&val);
+    float16_t res = vget_lane_f16(vcvt_f16_f32(tmp), 0);
+    x = *reinterpret_cast<uint16_t*>(&res);
+
+#elif defined(__F16C__)
+    x = _cvtss_sh(val, 0);
+
+#else
+    // Conversion routine adapted from
+    // http://stackoverflow.com/questions/1659440/32-bit-to-16-bit-floating-point-conversion
+    Bits v, s;
+    v.f = val;
+    uint32_t sign = v.si & sigN;
+    v.si ^= sign;
+    sign >>= shiftSign;  // logical shift
+    s.si = mulN;
+    s.si = s.f * v.f;  // correct subnormals
+    v.si ^= (s.si ^ v.si) & -(minN > v.si);
+    v.si ^= (infN ^ v.si) & -((infN > v.si) & (v.si > maxN));
+    v.si ^= (nanN ^ v.si) & -((nanN > v.si) & (v.si > infN));
+    v.ui >>= shift;  // logical shift
+    v.si ^= ((v.si - maxD) ^ v.si) & -(v.si > maxC);
+    v.si ^= ((v.si - minD) ^ v.si) & -(v.si > subC);
+    x = v.ui | sign;
+
+#endif
+  }
+
+  inline explicit float16(bool b) : x(b ? 0x3c00 : 0) {}
+
+  template <class T>
+  inline explicit float16(const T& val)
+      : x(float16(static_cast<float>(val)).x) {}
+
+// Assignment operators
+
+#ifdef FD_WITH_NATIVE_FP16
+  inline float16& operator=(const float16_t& rhs) {
+    x = *reinterpret_cast<const uint16_t*>(&rhs);
+    return *this;
+  }
+#endif
+
+  inline float16& operator=(bool b) {
+    x = b ? 0x3c00 : 0;
+    return *this;
+  }
+
+  inline float16& operator=(int8_t val) {
+    x = float16(val).x;
+    return *this;
+  }
+
+  inline float16& operator=(uint8_t val) {
+    x = float16(val).x;
+    return *this;
+  }
+
+  inline float16& operator=(int16_t val) {
+    x = float16(val).x;
+    return *this;
+  }
+
+  inline float16& operator=(uint16_t val) {
+    x = float16(val).x;
+    return *this;
+  }
+
+  inline float16& operator=(int32_t val) {
+    x = float16(val).x;
+    return *this;
+  }
+
+  inline float16& operator=(uint32_t val) {
+    x = float16(val).x;
+    return *this;
+  }
+
+  inline float16& operator=(int64_t val) {
+    x = float16(val).x;
+    return *this;
+  }
+
+  inline float16& operator=(uint64_t val) {
+    x = float16(val).x;
+    return *this;
+  }
+
+  inline float16& operator=(float val) {
+    x = float16(val).x;
+    return *this;
+  }
+
+  inline float16& operator=(double val) {
+    x = float16(val).x;
+    return *this;
+  }
+
+// Conversion opertors
+#ifdef FD_WITH_NATIVE_FP16
+  HOSTDEVICE inline explicit operator float16_t() const {
+    return *reinterpret_cast<const float16_t*>(this);
+  }
+#endif
+
+  inline operator float() const {
+#if defined(FD_WITH_NATIVE_FP16)
+    float16x4_t res = vld1_dup_f16(reinterpret_cast<const float16_t*>(this));
+    return vgetq_lane_f32(vcvt_f32_f16(res), 0);
+
+#elif defined(__F16C__)
+    return _cvtsh_ss(this->x);
+
+#else
+    // Conversion routine adapted from
+    // http://stackoverflow.com/questions/1659440/32-bit-to-16-bit-floating-point-conversion
+    Bits v;
+    v.ui = this->x;
+    int32_t sign = v.si & sigC;
+    v.si ^= sign;
+    sign <<= shiftSign;
+    v.si ^= ((v.si + minD) ^ v.si) & -(v.si > subC);
+    v.si ^= ((v.si + maxD) ^ v.si) & -(v.si > maxC);
+    Bits s;
+    s.si = mulC;
+    s.f *= v.si;
+    int32_t mask = -(norC > v.si);
+    v.si <<= shift;
+    v.si ^= (s.si ^ v.si) & mask;
+    v.si |= sign;
+    return v.f;
+
+#endif
+  }
+
+  inline explicit operator bool() const { return (x & 0x7fff) != 0; }
+
+  inline explicit operator int8_t() const {
+    return static_cast<int8_t>(static_cast<float>(*this));
+  }
+
+  inline explicit operator uint8_t() const {
+    return static_cast<uint8_t>(static_cast<float>(*this));
+  }
+
+  inline explicit operator int16_t() const {
+    return static_cast<int16_t>(static_cast<float>(*this));
+  }
+
+  inline explicit operator uint16_t() const {
+    return static_cast<uint16_t>(static_cast<float>(*this));
+  }
+
+  inline explicit operator int32_t() const {
+    return static_cast<int32_t>(static_cast<float>(*this));
+  }
+
+  inline explicit operator uint32_t() const {
+    return static_cast<uint32_t>(static_cast<float>(*this));
+  }
+
+  inline explicit operator int64_t() const {
+    return static_cast<int64_t>(static_cast<float>(*this));
+  }
+
+  inline explicit operator uint64_t() const {
+    return static_cast<uint64_t>(static_cast<float>(*this));
+  }
+
+  inline operator double() const {
+    return static_cast<double>(static_cast<float>(*this));
+  }
+
+  inline bool operator>(const float& other) const {
+    return this->operator float() > other;
+  }
+
+  inline bool operator>(const double& other) const {
+    return this->operator double() > other;
+  }
+
+  inline bool operator<(const float& other) const {
+    return this->operator float() > other;
+  }
+
+  inline bool operator<(const double& other) const {
+    return this->operator double() > other;
+  }
+
+  template <typename T,
+            typename std::enable_if<!std::is_same<T, float16>::value,
+                                    bool>::type = true>
+  inline float16& operator+=(const T& other) {
+    *this = float16(static_cast<T>(*this) + other);
+    return *this;
+  }
+
+ private:
+  union Bits {
+    float f;
+    int32_t si;
+    uint32_t ui;
+  };
+
+  static const int shift = 13;
+  static const int shiftSign = 16;
+
+  static const int32_t infN = 0x7F800000;
+  static const int32_t maxN = 0x477FE000;  // max flt16 as flt32
+  static const int32_t minN = 0x38800000;  // min flt16 normal as flt32
+  static const int32_t sigN = 0x80000000;  // sign bit
+
+  static constexpr int32_t infC = infN >> shift;
+  static constexpr int32_t nanN = (infC + 1)
+                                  << shift;  // minimum flt16 nan as float32
+  static constexpr int32_t maxC = maxN >> shift;
+  static constexpr int32_t minC = minN >> shift;
+  static constexpr int32_t sigC = sigN >> shiftSign;
+
+  static const int32_t mulN = 0x52000000;  // (1 << 23) / minN
+  static const int32_t mulC = 0x33800000;  // minN / (1 << (23 - shift))
+  static const int32_t subC = 0x003FF;     // max flt32 subnormal downshifted
+  static const int32_t norC = 0x00400;     // min flt32 normal downshifted
+
+  static constexpr int32_t maxD = infC - maxC - 1;
+  static constexpr int32_t minD = minC - subC - 1;
+};
+
+// Arithmetic operators for float16 on ARMv8.2-A CPU
+#if defined(FD_WITH_NATIVE_FP16)
+inline float16 operator+(const float16& a, const float16& b) {
+  float16 res;
+  asm volatile(
+      "ld1 {v0.h}[0], [%[a_ptr]]\n"
+      "ld1 {v1.h}[0], [%[b_ptr]]\n"
+      "fadd h0, h0, h1\n"
+      "st1 {v0.h}[0], [%[res_ptr]]\n"
+      :  // outputs
+      :  // inputs
+      [a_ptr] "r"(&(a.x)), [b_ptr] "r"(&(b.x)),
+      [res_ptr] "r"(&(res.x))
+      :  // clobbers
+      "memory", "v0", "v1");
+  return res;
+}
+
+inline float16 operator-(const float16& a, const float16& b) {
+  float16 res;
+  asm volatile(
+      "ld1 {v0.h}[0], [%[a_ptr]]\n"
+      "ld1 {v1.h}[0], [%[b_ptr]]\n"
+      "fsub h0, h0, h1\n"
+      "st1 {v0.h}[0], [%[res_ptr]]\n"
+      :  // outputs
+      :  // inputs
+      [a_ptr] "r"(&(a.x)), [b_ptr] "r"(&(b.x)),
+      [res_ptr] "r"(&(res.x))
+      :  // clobbers
+      "memory", "v0", "v1");
+  return res;
+}
+
+inline float16 operator*(const float16& a, const float16& b) {
+  float16 res;
+  asm volatile(
+      "ld1 {v0.h}[0], [%[a_ptr]]\n"
+      "ld1 {v1.h}[0], [%[b_ptr]]\n"
+      "fmul h0, h0, h1\n"
+      "st1 {v0.h}[0], [%[res_ptr]]\n"
+      :  // outputs
+      :  // inputs
+      [a_ptr] "r"(&(a.x)), [b_ptr] "r"(&(b.x)),
+      [res_ptr] "r"(&(res.x))
+      :  // clobbers
+      "memory", "v0", "v1");
+  return res;
+}
+
+inline float16 operator/(const float16& a, const float16& b) {
+  float16 res;
+  asm volatile(
+      "ld1 {v0.h}[0], [%[a_ptr]]\n"
+      "ld1 {v1.h}[0], [%[b_ptr]]\n"
+      "fdiv h0, h0, h1\n"
+      "st1 {v0.h}[0], [%[res_ptr]]\n"
+      :  // outputs
+      :  // inputs
+      [a_ptr] "r"(&(a.x)), [b_ptr] "r"(&(b.x)),
+      [res_ptr] "r"(&(res.x))
+      :  // clobbers
+      "memory", "v0", "v1");
+  return res;
+}
+
+inline float16 operator-(const float16& a) {
+  float16 res;
+  asm volatile(
+      "ld1 {v0.h}[0], [%[a_ptr]]\n"
+      "fneg h0, h0\n"
+      "st1 {v0.h}[0], [%[res_ptr]]\n"
+      :  // outputs
+      :  // inputs
+      [a_ptr] "r"(&(a.x)),
+      [res_ptr] "r"(&(res.x))
+      :  // clobbers
+      "memory", "v0");
+  return res;
+}
+
+inline float16& operator+=(float16& a, const float16& b) {  // NOLINT
+  a = a + b;
+  return a;
+}
+
+inline float16& operator-=(float16& a, const float16& b) {  // NOLINT
+  a = a - b;
+  return a;
+}
+
+inline float16& operator*=(float16& a, const float16& b) {  // NOLINT
+  a = a * b;
+  return a;
+}
+
+inline float16& operator/=(float16& a, const float16& b) {  // NOLINT
+  a = a / b;
+  return a;
+}
+
+inline bool operator==(const float16& a, const float16& b) {
+  uint16_t res;
+  asm volatile(
+      "ld1 {v0.h}[0], [%[a_ptr]]\n"
+      "ld1 {v1.h}[0], [%[b_ptr]]\n"
+      "fcmeq h0, h0, h1\n"
+      "st1 {v0.h}[0], [%[res_ptr]]\n"
+      :  // outputs
+      :  // inputs
+      [a_ptr] "r"(&(a.x)), [b_ptr] "r"(&(b.x)),
+      [res_ptr] "r"(&res)
+      :  // clobbers
+      "memory", "v0", "v1");
+  return (res & 0xffff) != 0;
+}
+
+inline bool operator!=(const float16& a, const float16& b) { return !(a == b); }
+
+inline bool operator<(const float16& a, const float16& b) {
+  uint16_t res;
+  asm volatile(
+      "ld1 {v1.h}[0], [%[a_ptr]]\n"
+      "ld1 {v0.h}[0], [%[b_ptr]]\n"
+      "fcmgt h0, h0, h1\n"
+      "st1 {v0.h}[0], [%[res_ptr]]\n"
+      :  // outputs
+      :  // inputs
+      [a_ptr] "r"(&(a.x)), [b_ptr] "r"(&(b.x)),
+      [res_ptr] "r"(&res)
+      :  // clobbers
+      "memory", "v0", "v1");
+  return (res & 0xffff) != 0;
+}
+
+inline bool operator<=(const float16& a, const float16& b) {
+  uint16_t res;
+  asm volatile(
+      "ld1 {v1.h}[0], [%[a_ptr]]\n"
+      "ld1 {v0.h}[0], [%[b_ptr]]\n"
+      "fcmge h0, h0, h1\n"
+      "st1 {v0.h}[0], [%[res_ptr]]\n"
+      :  // outputs
+      :  // inputs
+      [a_ptr] "r"(&(a.x)), [b_ptr] "r"(&(b.x)),
+      [res_ptr] "r"(&res)
+      :  // clobbers
+      "memory", "v0", "v1");
+  return (res & 0xffff) != 0;
+}
+
+inline bool operator>(const float16& a, const float16& b) {
+  uint16_t res;
+  asm volatile(
+      "ld1 {v0.h}[0], [%[a_ptr]]\n"
+      "ld1 {v1.h}[0], [%[b_ptr]]\n"
+      "fcmgt h0, h0, h1\n"
+      "st1 {v0.h}[0], [%[res_ptr]]\n"
+      :  // outputs
+      :  // inputs
+      [a_ptr] "r"(&(a.x)), [b_ptr] "r"(&(b.x)),
+      [res_ptr] "r"(&res)
+      :  // clobbers
+      "memory", "v0", "v1");
+  return (res & 0xffff) != 0;
+}
+
+inline bool operator>=(const float16& a, const float16& b) {
+  uint16_t res;
+  asm volatile(
+      "ld1 {v0.h}[0], [%[a_ptr]]\n"
+      "ld1 {v1.h}[0], [%[b_ptr]]\n"
+      "fcmge h0, h0, h1\n"
+      "st1 {v0.h}[0], [%[res_ptr]]\n"
+      :  // outputs
+      :  // inputs
+      [a_ptr] "r"(&(a.x)), [b_ptr] "r"(&(b.x)),
+      [res_ptr] "r"(&res)
+      :  // clobbers
+      "memory", "v0", "v1");
+  return (res & 0xffff) != 0;
+#else
+inline float16 operator+(const float16& a, const float16& b) {
+  return float16(static_cast<float>(a) + static_cast<float>(b));
+}
+
+inline float16 operator-(const float16& a, const float16& b) {
+  return float16(static_cast<float>(a) - static_cast<float>(b));
+}
+
+inline float16 operator*(const float16& a, const float16& b) {
+  return float16(static_cast<float>(a) * static_cast<float>(b));
+}
+
+inline float16 operator/(const float16& a, const float16& b) {
+  return float16(static_cast<float>(a) / static_cast<float>(b));
+}
+
+inline float16 operator-(const float16& a) {
+  float16 res;
+  res.x = a.x ^ 0x8000;
+  return res;
+}
+
+inline float16& operator+=(float16& a, const float16& b) {  // NOLINT
+  a = float16(static_cast<float>(a) + static_cast<float>(b));
+  return a;
+}
+
+inline float16& operator-=(float16& a, const float16& b) {  // NOLINT
+  a = float16(static_cast<float>(a) - static_cast<float>(b));
+  return a;
+}
+
+inline float16& operator*=(float16& a, const float16& b) {  // NOLINT
+  a = float16(static_cast<float>(a) * static_cast<float>(b));
+  return a;
+}
+
+inline float16& operator/=(float16& a, const float16& b) {  // NOLINT
+  a = float16(static_cast<float>(a) / static_cast<float>(b));
+  return a;
+}
+
+inline bool operator==(const float16& a, const float16& b) {
+  return static_cast<float>(a) == static_cast<float>(b);
+}
+
+inline bool operator!=(const float16& a, const float16& b) {
+  return static_cast<float>(a) != static_cast<float>(b);
+}
+
+inline bool operator<(const float16& a, const float16& b) {
+  return static_cast<float>(a) < static_cast<float>(b);
+}
+
+inline bool operator<=(const float16& a, const float16& b) {
+  return static_cast<float>(a) <= static_cast<float>(b);
+}
+
+inline bool operator>(const float16& a, const float16& b) {
+  return static_cast<float>(a) > static_cast<float>(b);
+}
+
+inline bool operator>=(const float16& a, const float16& b) {
+  return static_cast<float>(a) >= static_cast<float>(b);
+}
+#endif
+
+  template <typename T,
+            typename std::enable_if<std::is_integral<T>::value ||
+                                        std::is_same<T, float>::value,
+                                    bool>::type = true>
+  inline T& operator+=(T& a, const float16& b) {  // NOLINT
+    auto c = static_cast<float>(a) + static_cast<float>(b);
+    a = static_cast<T>(c);
+    return a;
+  }
+
+  inline double& operator+=(double& a, const float16& b) {  // NOLINT
+    a = a + static_cast<double>(b);
+    return a;
+  }
+
+  inline float16 raw_uint16_to_float16(uint16_t a) {
+    float16 res;
+    res.x = a;
+    return res;
+  }
+
+  inline bool(isnan)(const float16& a) { return (a.x & 0x7fff) > 0x7c00; }
+
+  inline bool(isinf)(const float16& a) { return (a.x & 0x7fff) == 0x7c00; }
+
+  inline bool(isfinite)(const float16& a) {
+    return !((isnan)(a)) && !((isinf)(a));
+  }
+
+  inline float16(abs)(const float16& a) {
+    return float16(std::abs(static_cast<float>(a)));
+  }
+
+  inline std::ostream& operator<<(std::ostream& os, const float16& a) {
+    os << static_cast<float>(a);
+    return os;
+  }
+}  // namespace fastdeploy
+
+namespace std {
+
+// Override the std::is_pod::value for float16
+// The reason is that different compilers implemented std::is_pod based on
+// different C++ standards. float16 class is a plain old data in C++11 given
+// that it is both trivial and standard_layout.
+// However, std::is_pod in nvcc 8.0 host c++ compiler follows C++0x and is
+// more restricted in that you cannot provide any customized
+// constructor in float16. Hence, we override is_pod here following C++11
+// so that .cu files can be successfully compiled by nvcc.
+template <>
+struct is_pod<fastdeploy::float16> {
+  static const bool value = is_trivial<fastdeploy::float16>::value &&
+                            is_standard_layout<fastdeploy::float16>::value;
+};
+
+template <>
+struct is_floating_point<fastdeploy::float16>
+    : std::integral_constant<
+          bool, std::is_same<fastdeploy::float16,
+                             typename std::remove_cv<
+                                 fastdeploy::float16>::type>::value> {};
+template <>
+struct is_signed<fastdeploy::float16> {
+  static const bool value = true;
+};
+
+template <>
+struct is_unsigned<fastdeploy::float16> {
+  static const bool value = false;
+};
+
+inline bool isnan(const fastdeploy::float16& a) { return fastdeploy::isnan(a); }
+
+inline bool isinf(const fastdeploy::float16& a) { return fastdeploy::isinf(a); }
+
+template <>
+struct numeric_limits<fastdeploy::float16> {
+  static const bool is_specialized = true;
+  static const bool is_signed = true;
+  static const bool is_integer = false;
+  static const bool is_exact = false;
+  static const bool has_infinity = true;
+  static const bool has_quiet_NaN = true;
+  static const bool has_signaling_NaN = true;
+  static const float_denorm_style has_denorm = denorm_present;
+  static const bool has_denorm_loss = false;
+  static const std::float_round_style round_style = std::round_to_nearest;
+  static const bool is_iec559 = false;
+  static const bool is_bounded = false;
+  static const bool is_modulo = false;
+  static const int digits = 11;
+  static const int digits10 = 3;
+  static const int max_digits10 = 5;
+  static const int radix = 2;
+  static const int min_exponent = -13;
+  static const int min_exponent10 = -4;
+  static const int max_exponent = 16;
+  static const int max_exponent10 = 4;
+  static const bool traps = true;
+  static const bool tinyness_before = false;
+
+  static fastdeploy::float16(min)() {
+    return fastdeploy::raw_uint16_to_float16(0x400);
+  }
+  static fastdeploy::float16 lowest() {
+    return fastdeploy::raw_uint16_to_float16(0xfbff);
+  }
+  static fastdeploy::float16(max)() {
+    return fastdeploy::raw_uint16_to_float16(0x7bff);
+  }
+  static fastdeploy::float16 epsilon() {
+    return fastdeploy::raw_uint16_to_float16(0x0800);
+  }
+  static fastdeploy::float16 round_error() { return fastdeploy::float16(0.5); }
+  static fastdeploy::float16 infinity() {
+    return fastdeploy::raw_uint16_to_float16(0x7c00);
+  }
+  static fastdeploy::float16 quiet_NaN() {
+    return fastdeploy::raw_uint16_to_float16(0x7e00);
+  }
+  static fastdeploy::float16 signaling_NaN() {
+    return fastdeploy::raw_uint16_to_float16(0x7e00);
+  }
+  static fastdeploy::float16 denorm_min() {
+    return fastdeploy::raw_uint16_to_float16(0x1);
+  }
+};
+
+inline fastdeploy::float16 abs(const fastdeploy::float16& a) {
+  return fastdeploy::abs(a);
+}
+
+}  // namespace std

3rdparty/include/fastdeploy/fastdeploy_model.h

@@ -0,0 +1,142 @@
+// 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/runtime.h"
+
+namespace fastdeploy {
+
+/*! @brief Base model object for all the vision models
+ */
+class FASTDEPLOY_DECL FastDeployModel {
+ public:
+  /// Get model's name
+  virtual std::string ModelName() const { return "NameUndefined"; }
+
+  /** \brief Inference the model by the runtime. This interface is included in the `Predict()` function, so we don't call `Infer()` directly in most common situation
+  */
+  virtual bool Infer(std::vector<FDTensor>& input_tensors,
+                     std::vector<FDTensor>* output_tensors);
+
+  /** \brief Inference the model by the runtime. This interface is using class member reused_input_tensors_ to do inference and writing results to reused_output_tensors_
+  */
+  virtual bool Infer();
+
+  RuntimeOption runtime_option;
+  /** \brief Model's valid cpu backends. This member defined all the cpu backends have successfully tested for the model
+   */
+  std::vector<Backend> valid_cpu_backends = {Backend::ORT};
+  /** Model's valid gpu backends. This member defined all the gpu backends have successfully tested for the model
+   */
+  std::vector<Backend> valid_gpu_backends = {Backend::ORT};
+  /** Model's valid ipu backends. This member defined all the ipu backends have successfully tested for the model
+   */
+  std::vector<Backend> valid_ipu_backends = {};
+  /** Model's valid timvx backends. This member defined all the timvx backends have successfully tested for the model
+   */
+  std::vector<Backend> valid_timvx_backends = {};
+  /** Model's valid hardware backends. This member defined all the gpu backends have successfully tested for the model
+   */
+  std::vector<Backend> valid_rknpu_backends = {};
+
+  /// Get number of inputs for this model
+  virtual int NumInputsOfRuntime() { return runtime_->NumInputs(); }
+  /// Get number of outputs for this model
+  virtual int NumOutputsOfRuntime() { return runtime_->NumOutputs(); }
+  /// Get input information for this model
+  virtual TensorInfo InputInfoOfRuntime(int index) {
+    return runtime_->GetInputInfo(index);
+  }
+  /// Get output information for this model
+  virtual TensorInfo OutputInfoOfRuntime(int index) {
+    return runtime_->GetOutputInfo(index);
+  }
+  /// Check if the model is initialized successfully
+  virtual bool Initialized() const {
+    return runtime_initialized_ && initialized;
+  }
+
+  /** \brief This is a debug interface, used to record the time of backend runtime
+   *
+   * example code @code
+   * auto model = fastdeploy::vision::PPYOLOE("model.pdmodel", "model.pdiparams", "infer_cfg.yml");
+   * if (!model.Initialized()) {
+   *   std::cerr << "Failed to initialize." << std::endl;
+   *   return -1;
+   * }
+   * model.EnableRecordTimeOfRuntime();
+   * cv::Mat im = cv::imread("test.jpg");
+   * for (auto i = 0; i < 1000; ++i) {
+   *   fastdeploy::vision::DetectionResult result;
+   *   model.Predict(&im, &result);
+   * }
+   * model.PrintStatisInfoOfRuntime();
+   * @endcode After called the `PrintStatisInfoOfRuntime()`, the statistical information of runtime will be printed in the console
+   */
+  virtual void EnableRecordTimeOfRuntime() {
+    time_of_runtime_.clear();
+    std::vector<double>().swap(time_of_runtime_);
+    enable_record_time_of_runtime_ = true;
+  }
+
+  /** \brief Disable to record the time of backend runtime, see `EnableRecordTimeOfRuntime()` for more detail
+  */
+  virtual void DisableRecordTimeOfRuntime() {
+    enable_record_time_of_runtime_ = false;
+  }
+
+  /** \brief Print the statistic information of runtime in the console, see function `EnableRecordTimeOfRuntime()` for more detail
+  */
+  virtual std::map<std::string, float> PrintStatisInfoOfRuntime();
+
+  /** \brief Check if the `EnableRecordTimeOfRuntime()` method is enabled.
+  */
+  virtual bool EnabledRecordTimeOfRuntime() {
+    return enable_record_time_of_runtime_;
+  }
+
+  /** \brief Release reused input/output buffers
+  */
+  virtual void ReleaseReusedBuffer() {
+    std::vector<FDTensor>().swap(reused_input_tensors_);
+    std::vector<FDTensor>().swap(reused_output_tensors_);
+  }
+
+ protected:
+  virtual bool InitRuntime();
+
+  bool initialized = false;
+  // Reused input tensors
+  std::vector<FDTensor> reused_input_tensors_;
+  // Reused output tensors
+  std::vector<FDTensor> reused_output_tensors_;
+
+ private:
+  bool InitRuntimeWithSpecifiedBackend();
+  bool InitRuntimeWithSpecifiedDevice();
+  bool CreateCpuBackend();
+  bool CreateGpuBackend();
+  bool CreateIpuBackend();
+  bool CreateRKNPUBackend();
+  bool CreateTimVXBackend();
+
+  std::shared_ptr<Runtime> runtime_;
+  bool runtime_initialized_ = false;
+  // whether to record inference time
+  bool enable_record_time_of_runtime_ = false;
+
+  // record inference time for backend
+  std::vector<double> time_of_runtime_;
+};
+
+}  // namespace fastdeploy

3rdparty/include/fastdeploy/function/cast.h

@@ -0,0 +1,31 @@
+// 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/core/fd_tensor.h"
+
+namespace fastdeploy {
+namespace function {
+
+/** Cast x to output data type element-wise. Only for float type FDTensor
+    @param x The input tensor.
+    @param out The output tensor which stores the result.
+    @param output_dtype The type of output tensor.
+*/
+FASTDEPLOY_DECL void Cast(const FDTensor& x, FDTensor* out,
+                          FDDataType output_dtype);
+
+}  // namespace function
+}  // namespace fastdeploy

3rdparty/include/fastdeploy/function/clip.h

@@ -0,0 +1,32 @@
+// 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/core/fd_tensor.h"
+
+namespace fastdeploy {
+namespace function {
+
+/** This operator clip all elements in input into the range [ min, max ]. Support float32, float64, int32, int64
+    @param x The input tensor.
+    @param min The lower bound
+    @param max The uppper bound
+    @param out The output tensor which stores the result.
+*/
+FASTDEPLOY_DECL void Clip(const FDTensor& x, double min, double max,
+                          FDTensor* out);
+
+}  // namespace function
+}  // namespace fastdeploy

3rdparty/include/fastdeploy/function/concat.h

@@ -0,0 +1,32 @@
+// 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/core/fd_tensor.h"
+
+namespace fastdeploy {
+namespace function {
+
+/** Excute the concatenate operation for input FDTensor along given axis.
+    @param x The input tensor.
+    @param out The output tensor which stores the result.
+    @param axis Axis which will be concatenated.
+*/
+
+FASTDEPLOY_DECL void Concat(const std::vector<FDTensor>& x, FDTensor* out,
+                            int axis = 0);
+
+}  // namespace function
+}  // namespace fastdeploy

3rdparty/include/fastdeploy/function/cuda_cast.h

@@ -0,0 +1,29 @@
+// 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/core/fd_tensor.h"
+
+namespace fastdeploy {
+namespace function {
+/** Cast the type of the data in GPU buffer.
+    @param in The input tensor.
+    @param out The output tensor
+    @param stream CUDA stream
+*/
+FASTDEPLOY_DECL void CudaCast(const FDTensor& in, FDTensor* out,
+                              cudaStream_t stream);
+}  // namespace function
+}  // namespace fastdeploy

3rdparty/include/fastdeploy/function/cumprod.h

@@ -0,0 +1,31 @@
+// 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/core/fd_tensor.h"
+
+namespace fastdeploy {
+namespace function {
+
+/** Excute the concatenate operation for input FDTensor along given axis.
+    @param x The input tensor.
+    @param out The output tensor which stores the result.
+    @param axisi Axis which will be concatenated.
+*/
+
+FASTDEPLOY_DECL void Cumprod(const FDTensor& x, FDTensor* out, int axis = 0);
+
+}  // namespace function
+}  // namespace fastdeploy

3rdparty/include/fastdeploy/function/eigen.h

@@ -0,0 +1,140 @@
+// 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 <algorithm>
+#include <memory>
+#include <vector>
+#include "fastdeploy/core/fd_tensor.h"
+#include "fastdeploy/utils/axis_utils.h"
+#include "unsupported/Eigen/CXX11/Tensor"
+
+namespace fastdeploy {
+namespace function {
+// EigenDim converts shape into Eigen::DSizes.
+template <int D>
+struct EigenDim {
+  using Type = Eigen::DSizes<Eigen::DenseIndex, D>;
+
+  static Type From(const std::vector<int64_t>& dims) {
+    Type ret;
+    for (int64_t d = 0; d < dims.size(); d++) {
+      ret[d] = dims[d];
+    }
+    return ret;
+  }
+};
+
+// Interpret FDTensor as EigenTensor and EigenConstTensor.
+template <typename T, size_t D, int MajorType = Eigen::RowMajor,
+          typename IndexType = Eigen::DenseIndex>
+struct EigenTensor {
+  using Type = Eigen::TensorMap<Eigen::Tensor<T, D, MajorType, IndexType>>;
+
+  using ConstType =
+      Eigen::TensorMap<Eigen::Tensor<const T, D, MajorType, IndexType>>;
+
+  static Type From(FDTensor& tensor,
+                   const std::vector<int64_t>& dims) {  // NOLINT
+    return Type(reinterpret_cast<T*>(tensor.Data()), EigenDim<D>::From(dims));
+  }
+
+  static Type From(FDTensor& tensor) {  // NOLINT
+    return From(tensor, tensor.shape);
+  }  // NOLINT
+
+  static ConstType From(const FDTensor& tensor,
+                        const std::vector<int64_t>& dims) {
+    return ConstType(reinterpret_cast<const T*>(tensor.Data()),
+                     EigenDim<D>::From(dims));
+  }
+
+  static ConstType From(const FDTensor& tensor) {
+    return From(tensor, tensor.shape);
+  }
+};
+
+template <typename T, int MajorType = Eigen::RowMajor,
+          typename IndexType = Eigen::DenseIndex>
+struct EigenScalar {
+  // Scalar tensor (implemented as a rank-0 tensor) of scalar type T.
+  using Type = Eigen::TensorMap<
+      Eigen::TensorFixedSize<T, Eigen::Sizes<>, MajorType, IndexType>>;
+  using ConstType = Eigen::TensorMap<
+      Eigen::TensorFixedSize<const T, Eigen::Sizes<>, MajorType, IndexType>>;
+
+  static Type From(FDTensor& tensor) {
+    return Type(reinterpret_cast<T*>(tensor.Data()));
+  }  // NOLINT
+
+  static ConstType From(const FDTensor& tensor) {
+    return ConstType(reinterpret_cast<const T*>(tensor.Data()));
+  }
+};
+
+template <typename T, int MajorType = Eigen::RowMajor,
+          typename IndexType = Eigen::DenseIndex>
+struct EigenVector : public EigenTensor<T, 1, MajorType, IndexType> {
+  // Flatten reshapes a Tensor into an EigenVector.
+  static typename EigenVector::Type Flatten(FDTensor& tensor) {  // NOLINT
+    return EigenVector::From(tensor, {tensor.Numel()});
+  }
+
+  static typename EigenVector::ConstType Flatten(
+      const FDTensor& tensor) {  // NOLINT
+    return EigenVector::From(tensor, {tensor.Numel()});
+  }
+};
+
+template <typename T, int MajorType = Eigen::RowMajor,
+          typename IndexType = Eigen::DenseIndex>
+struct EigenMatrix : public EigenTensor<T, 2, MajorType, IndexType> {
+  static typename EigenMatrix::Type Reshape(FDTensor& tensor,  // NOLINT
+                                            int num_col_dims) {
+    int rank = tensor.shape.size();
+    FDASSERT((num_col_dims > 0 && num_col_dims < rank),
+             "Input dimension number(num_col_dims) must be between 0 and %d, "
+             "but received number is %d.",
+             rank, num_col_dims);
+    const int n = SizeToAxis(num_col_dims, tensor.shape);
+    const int d = SizeFromAxis(num_col_dims, tensor.shape);
+    return EigenMatrix::From(tensor, {n, d});
+  }
+
+  static typename EigenMatrix::ConstType Reshape(const FDTensor& tensor,
+                                                 int num_col_dims) {
+    int rank = tensor.shape.size();
+    FDASSERT((num_col_dims > 0 && num_col_dims < rank),
+             "Input dimension number(num_col_dims) must be between 0 and %d, "
+             "but received number is %d.",
+             rank, num_col_dims);
+    const int n = SizeToAxis(num_col_dims, tensor.shape);
+    const int d = SizeFromAxis(num_col_dims, tensor.shape);
+    return EigenMatrix::From(tensor, {n, d});
+  }
+};
+
+class EigenDeviceWrapper {
+ public:
+  static std::shared_ptr<EigenDeviceWrapper> GetInstance();
+  const Eigen::DefaultDevice* GetDevice() const;
+
+ private:
+  Eigen::DefaultDevice device_;
+  static std::shared_ptr<EigenDeviceWrapper> instance_;
+};
+
+}  // namespace function
+}  // namespace fastdeploy

3rdparty/include/fastdeploy/function/elementwise.h

@@ -0,0 +1,105 @@
+// 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/core/fd_scalar.h"
+#include "fastdeploy/core/fd_tensor.h"
+
+namespace fastdeploy {
+
+namespace function {
+
+/** Excute the add operation for input FDTensors. *out = x + y.
+    @param x The input tensor.
+    @param y The input tensor.
+    @param out The output tensor which stores the result.
+*/
+FASTDEPLOY_DECL void Add(const FDTensor& x, const FDTensor& y, FDTensor* out);
+
+/** Excute the subtract operation for input FDTensors.  *out = x - y.
+    @param x The input tensor.
+    @param y The input tensor.
+    @param out The output tensor which stores the result.
+*/
+FASTDEPLOY_DECL void Subtract(const FDTensor& x, const FDTensor& y,
+                              FDTensor* out);
+
+/** Excute the multiply operation for input FDTensors.  *out = x * y.
+    @param x The input tensor.
+    @param y The input tensor.
+    @param out The output tensor which stores the result.
+*/
+FASTDEPLOY_DECL void Multiply(const FDTensor& x, const FDTensor& y,
+                              FDTensor* out);
+
+/** Excute the divide operation for input FDTensors.  *out = x / y.
+    @param x The input tensor.
+    @param y The input tensor.
+    @param out The output tensor which stores the result.
+*/
+FASTDEPLOY_DECL void Divide(const FDTensor& x, const FDTensor& y,
+                            FDTensor* out);
+
+/** Excute the maximum operation for input FDTensors.  *out = max(x, y).
+    @param x The input tensor.
+    @param y The input tensor.
+    @param out The output tensor which stores the result.
+*/
+FASTDEPLOY_DECL void Maximum(const FDTensor& x, const FDTensor& y,
+                             FDTensor* out);
+
+}  // namespace function
+
+FASTDEPLOY_DECL FDTensor operator+(const FDTensor& x, const FDTensor& y);
+
+template <typename T> FDTensor operator+(const FDTensor& x, T y) {
+  return x + FDTensor(Scalar(y));
+}
+
+template <typename T> FDTensor operator+(T x, const FDTensor& y) {
+  return FDTensor(Scalar(x)) + y;
+}
+
+FASTDEPLOY_DECL FDTensor operator-(const FDTensor& x, const FDTensor& y);
+
+template <typename T> FDTensor operator-(const FDTensor& x, T y) {
+  return x - FDTensor(Scalar(y));
+}
+
+template <typename T> FDTensor operator-(T x, const FDTensor& y) {
+  return FDTensor(Scalar(x)) - y;
+}
+
+FASTDEPLOY_DECL FDTensor operator*(const FDTensor& x, const FDTensor& y);
+
+template <typename T> FDTensor operator*(const FDTensor& x, T y) {
+  return x * FDTensor(Scalar(y));
+}
+
+template <typename T> FDTensor operator*(T x, const FDTensor& y) {
+  return FDTensor(Scalar(x)) * y;
+}
+
+FASTDEPLOY_DECL FDTensor operator/(const FDTensor& x, const FDTensor& y);
+
+template <typename T> FDTensor operator/(const FDTensor& x, T y) {
+  return x / FDTensor(Scalar(y));
+}
+
+template <typename T> FDTensor operator/(T x, const FDTensor& y) {
+  return FDTensor(Scalar(x)) / y;
+}
+
+}  // namespace fastdeploy

3rdparty/include/fastdeploy/function/elementwise_base.h

@@ -0,0 +1,265 @@
+// 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 <algorithm>
+
+#include "fastdeploy/core/fd_tensor.h"
+#include "fastdeploy/function/eigen.h"
+
+namespace fastdeploy {
+namespace function {
+
+#define DEFINE_ELEMENTWISE_OP(name)                                            \
+  template <typename T> struct name##RawKernel {                               \
+    void operator()(const FDTensor& x, const FDTensor& y, int axis,            \
+                    FDTensor* out) {                                           \
+      if (x.Shape() == y.Shape()) {                                            \
+        SameDimsElementwiseCompute<SameDims##name##Functor<T>>()(x, y, out);   \
+      } else {                                                                 \
+        auto x_dims = x.Shape();                                               \
+        auto y_dims = y.Shape();                                               \
+        if (x_dims.size() >= y_dims.size()) {                                  \
+          ElementwiseCompute<name##Functor<T>, T>(x, y, axis,                  \
+                                                  name##Functor<T>(), out);    \
+        } else {                                                               \
+          ElementwiseCompute<Inverse##name##Functor<T>, T>(                    \
+              x, y, axis, Inverse##name##Functor<T>(), out);                   \
+        }                                                                      \
+      }                                                                        \
+    }                                                                          \
+  }
+
+inline void GetMidDims(const std::vector<int64_t>& x_dims,
+                       const std::vector<int64_t>& y_dims, const int axis,
+                       int* pre, int* n, int* post,
+                       int* is_run_common_broadcast) {
+  *pre = 1;
+  *n = 1;
+  *post = 1;
+  *is_run_common_broadcast = 0;
+  for (int i = 0; i < axis; ++i) {
+    (*pre) *= x_dims[i];
+  }
+  for (int i = 0; i < y_dims.size(); ++i) {
+    if (x_dims[i + axis] != y_dims[i]) {
+      FDASSERT(y_dims[i] == 1 || x_dims[i + axis] == 1,
+               "Broadcast dimension mismatch. Operands "
+               "could not be broadcast together with the shape of "
+               "X = [%s] and the shape of Y = [%s]. Received [%d] "
+               "in X is not equal to [%d] in Y.",
+               Str(x_dims).c_str(), Str(y_dims).c_str(), x_dims[i + axis],
+               y_dims[i]);
+      *is_run_common_broadcast = 1;
+      return;
+    }
+    (*n) *= y_dims[i];
+  }
+  for (int i = axis + y_dims.size(); i < x_dims.size(); ++i) {
+    (*post) *= x_dims[i];
+  }
+}
+
+inline std::vector<int64_t>
+TrimTrailingSingularDims(const std::vector<int64_t>& dims) {
+  // Remove trailing dimensions of size 1 for y
+  auto actual_dims_size = dims.size();
+  for (; actual_dims_size != 0; --actual_dims_size) {
+    if (dims[actual_dims_size - 1] != 1)
+      break;
+  }
+  if (actual_dims_size == dims.size())
+    return dims;
+  std::vector<int64_t> trim_dims;
+  trim_dims.resize(actual_dims_size);
+  for (int i = 0; i < actual_dims_size; ++i) {
+    trim_dims[i] = dims[i];
+  }
+  return trim_dims;
+}
+
+inline int GetElementwiseIndex(const int64_t* x_dims_array, const int max_dim,
+                               const int64_t* index_array) {
+  int index_ = 0;
+  for (int i = 0; i < max_dim; i++) {
+    if (x_dims_array[i] > 1) {
+      index_ = index_ * x_dims_array[i] + index_array[i];
+    }
+  }
+  return index_;
+}
+
+inline void UpdateElementwiseIndexArray(const int64_t* out_dims_array,
+                                        const int max_dim,
+                                        int64_t* index_array) {
+  for (int i = max_dim - 1; i >= 0; --i) {
+    ++index_array[i];
+    if (index_array[i] >= out_dims_array[i]) {
+      index_array[i] -= out_dims_array[i];
+    } else {
+      break;
+    }
+  }
+}
+
+inline void GetBroadcastDimsArrays(const std::vector<int64_t>& x_dims,
+                                   const std::vector<int64_t>& y_dims,
+                                   int64_t* x_dims_array, int64_t* y_dims_array,
+                                   int64_t* out_dims_array, const int max_dim,
+                                   const int axis) {
+  FDASSERT(axis >= 0,
+           "Axis should be great than or equal to 0, but received axis is %d.",
+           axis);
+  FDASSERT(axis < max_dim,
+           "Axis should be less than %d, but received axis is %d.", max_dim,
+           axis);
+  if (x_dims.size() > y_dims.size()) {
+    std::fill(y_dims_array, y_dims_array + axis, 1);
+    if (axis + y_dims.size() < max_dim) {
+      std::fill(y_dims_array + axis + y_dims.size(), y_dims_array + max_dim, 1);
+    }
+    std::copy(x_dims.data(), x_dims.data() + x_dims.size(), x_dims_array);
+    std::copy(y_dims.data(), y_dims.data() + y_dims.size(),
+              y_dims_array + axis);
+  } else {
+    std::fill(x_dims_array, x_dims_array + axis, 1);
+    if (axis + x_dims.size() < max_dim) {
+      std::fill(x_dims_array + axis + x_dims.size(), x_dims_array + max_dim, 1);
+    }
+    std::copy(x_dims.data(), x_dims.data() + x_dims.size(),
+              x_dims_array + axis);
+    std::copy(y_dims.data(), y_dims.data() + y_dims.size(), y_dims_array);
+  }
+
+  for (int i = 0; i < max_dim; i++) {
+    FDASSERT(x_dims_array[i] == y_dims_array[i] || x_dims_array[i] <= 1 ||
+                 y_dims_array[i] <= 1,
+             "Broadcast dimension mismatch. Operands "
+             "could not be broadcast together with the shape of "
+             "X = [%s] and the shape of Y = [%s]. Received [%d] "
+             "in X is not equal to [%d] in Y.",
+             Str(x_dims).c_str(), Str(y_dims).c_str(), x_dims[i + axis],
+             y_dims[i]);
+    if ((x_dims_array[i] > 1 || y_dims_array[i] > 1) ||
+        (x_dims_array[i] == 1 && y_dims_array[i] == 1)) {
+      out_dims_array[i] = (std::max)(x_dims_array[i], y_dims_array[i]);
+    } else {
+      out_dims_array[i] = -1;
+    }
+  }
+}
+
+template <typename Functor, typename T, typename OutType = T>
+void CommonForwardBroadcastCPU(const FDTensor& x, const FDTensor& y,
+                               FDTensor* z, int64_t* x_dims_array,
+                               int64_t* y_dims_array, int64_t* out_dims_array,
+                               int max_dim, Functor func,
+                               const bool is_xsize_larger = true) {
+  std::vector<int64_t> index_array(max_dim, 0);
+  const T* x_data = reinterpret_cast<const T*>(x.Data());
+  const T* y_data = reinterpret_cast<const T*>(y.Data());
+  FDASSERT(x_data != nullptr, "The input X should not be empty.");
+  FDASSERT(y_data != nullptr, "The input X should not be empty.");
+  OutType* out_data = reinterpret_cast<OutType*>(z->Data());
+
+  const int out_size = std::accumulate(out_dims_array, out_dims_array + max_dim,
+                                       1, std::multiplies<int64_t>());
+  int x_index, y_index;
+  for (int out_index = 0; out_index < out_size; ++out_index) {
+    x_index = GetElementwiseIndex(x_dims_array, max_dim, index_array.data());
+    y_index = GetElementwiseIndex(y_dims_array, max_dim, index_array.data());
+    if (is_xsize_larger) {
+      out_data[out_index] = func(x_data[x_index], y_data[y_index]);
+    } else {
+      out_data[out_index] = func(y_data[y_index], x_data[x_index]);
+    }
+
+    UpdateElementwiseIndexArray(out_dims_array, max_dim, index_array.data());
+  }
+}
+
+template <typename Functor, typename T, typename OutType = T>
+void CommonElementwiseBroadcastForward(const FDTensor& x, const FDTensor& y,
+                                       FDTensor* z,
+                                       const std::vector<int64_t>& x_dims,
+                                       const std::vector<int64_t>& y_dims,
+                                       Functor func, int axis,
+                                       const bool is_xsize_larger = true) {
+  int x_dims_size = x_dims.size();
+  int y_dims_size = y_dims.size();
+  int max_dim = (std::max)(x_dims_size, y_dims_size);
+  axis = (axis == -1 ? std::abs(x_dims_size - y_dims_size) : axis);
+  FDASSERT(axis >= 0,
+           "Axis should be great than or equal to 0, but received axis is %d.",
+           axis);
+  FDASSERT(axis < max_dim,
+           "Axis should be less than %d, but received axis is %d.", max_dim,
+           axis);
+  std::vector<int64_t> x_dims_array(max_dim);
+  std::vector<int64_t> y_dims_array(max_dim);
+  std::vector<int64_t> out_dims_array(max_dim);
+  GetBroadcastDimsArrays(x_dims, y_dims, x_dims_array.data(),
+                         y_dims_array.data(), out_dims_array.data(), max_dim,
+                         axis);
+  FDTensor tmp;
+  tmp.Allocate(out_dims_array, TypeToDataType<OutType>::dtype);
+  CommonForwardBroadcastCPU<Functor, T, OutType>(
+      x, y, &tmp, x_dims_array.data(), y_dims_array.data(),
+      out_dims_array.data(), max_dim, func, is_xsize_larger);
+  *z = std::move(tmp);
+}
+
+template <typename Functor, typename T, typename OutType = T>
+void ElementwiseCompute(const FDTensor& x, const FDTensor& y, int axis,
+                        Functor func, FDTensor* z) {
+  auto x_dims = x.Shape();
+  auto y_dims = y.Shape();
+  bool is_xsize_larger = true;
+  int max_dim = x_dims.size();
+  if (x_dims.size() < y_dims.size()) {
+    is_xsize_larger = false;
+    max_dim = y_dims.size();
+  }
+
+  int diff_size = x_dims.size() - y_dims.size();
+  axis = (axis == -1 ? std::abs(diff_size) : axis);
+  FDASSERT(axis >= 0,
+           "Axis should be great than or equal to 0, but received axis is %d.",
+           axis);
+  FDASSERT(axis < max_dim,
+           "Axis should be less than %d, but received axis is %d.", max_dim,
+           axis);
+
+  int pre, n, post, is_run_common_broadcast, axis_trim = 0;
+  if (is_xsize_larger) {
+    auto y_dims_trimed = TrimTrailingSingularDims(y_dims);
+    axis_trim = (y_dims_trimed.size() == 0) ? x_dims.size() : axis;
+    GetMidDims(x_dims, y_dims_trimed, axis_trim, &pre, &n, &post,
+               &is_run_common_broadcast);
+  } else {
+    auto x_dims_trimed = TrimTrailingSingularDims(x_dims);
+    axis_trim = (x_dims_trimed.size() == 0) ? y_dims.size() : axis;
+    GetMidDims(y_dims, x_dims_trimed, axis_trim, &pre, &n, &post,
+               &is_run_common_broadcast);
+  }
+  // special case for common implementation.
+  // case 1: x=[2,3,1,5], y=[2,1,4,1]
+  // case 2: x=[2,3,4], y=[1,1,4]
+  CommonElementwiseBroadcastForward<Functor, T, OutType>(
+      x, y, z, x_dims, y_dims, func, axis, is_xsize_larger);
+}
+
+}  // namespace function
+}  // namespace fastdeploy

3rdparty/include/fastdeploy/function/elementwise_functor.h

@@ -0,0 +1,131 @@
+// 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/function/eigen.h"
+#include "fastdeploy/function/elementwise.h"
+#include "fastdeploy/function/elementwise_base.h"
+#include <algorithm>
+
+namespace fastdeploy {
+namespace function {
+
+template <typename Functor> struct SameDimsElementwiseCompute {
+  void operator()(const FDTensor& x, const FDTensor& y, FDTensor* z) {
+    z->Allocate(x.Shape(), x.Dtype());
+    Functor()(x, y, z);
+  }
+};
+
+template <typename T> struct SameDimsAddFunctor {
+  void operator()(const FDTensor& x, const FDTensor& y, FDTensor* z) {
+    const auto& dev = *EigenDeviceWrapper::GetInstance()->GetDevice();
+    auto eigen_x = EigenVector<T>::Flatten(x);
+    auto eigen_y = EigenVector<T>::Flatten(y);
+    auto eigen_z = EigenVector<T>::Flatten(*z);
+    eigen_z.device(dev) = eigen_x + eigen_y;
+  }
+};
+
+template <typename T> struct SameDimsSubtractFunctor {
+  void operator()(const FDTensor& x, const FDTensor& y, FDTensor* z) {
+    const auto& dev = *EigenDeviceWrapper::GetInstance()->GetDevice();
+    auto eigen_x = EigenVector<T>::Flatten(x);
+    auto eigen_y = EigenVector<T>::Flatten(y);
+    auto eigen_z = EigenVector<T>::Flatten(*z);
+    eigen_z.device(dev) = eigen_x - eigen_y;
+  }
+};
+
+template <typename T> struct SameDimsMultiplyFunctor {
+  void operator()(const FDTensor& x, const FDTensor& y, FDTensor* z) {
+    const auto& dev = *EigenDeviceWrapper::GetInstance()->GetDevice();
+    auto eigen_x = EigenVector<T>::Flatten(x);
+    auto eigen_y = EigenVector<T>::Flatten(y);
+    auto eigen_z = EigenVector<T>::Flatten(*z);
+    eigen_z.device(dev) = eigen_x * eigen_y;
+  }
+};
+
+template <typename T> struct SameDimsDivideFunctor {
+  void operator()(const FDTensor& x, const FDTensor& y, FDTensor* z) {
+    const auto& dev = *EigenDeviceWrapper::GetInstance()->GetDevice();
+    auto eigen_x = EigenVector<T>::Flatten(x);
+    auto eigen_y = EigenVector<T>::Flatten(y);
+    auto eigen_z = EigenVector<T>::Flatten(*z);
+    eigen_z.device(dev) = eigen_x / eigen_y;
+  }
+};
+
+// Add
+template <typename T> struct AddFunctor {
+  inline T operator()(const T a, const T b) const { return a + b; }
+};
+template <typename T> struct InverseAddFunctor {
+  inline T operator()(const T a, const T b) const { return b + a; }
+};
+
+// Subtract
+template <typename T> struct SubtractFunctor {
+  inline T operator()(const T a, const T b) const { return a - b; }
+};
+template <typename T> struct InverseSubtractFunctor {
+  inline T operator()(const T a, const T b) const { return b - a; }
+};
+
+// Multiply
+template <typename T> struct MultiplyFunctor {
+  inline T operator()(const T a, const T b) const { return a * b; }
+};
+template <> struct MultiplyFunctor<bool> {
+  inline bool operator()(const bool a, const bool b) const { return a && b; }
+};
+template <typename T> struct InverseMultiplyFunctor {
+  inline T operator()(const T a, const T b) const { return b * a; }
+};
+template <> struct InverseMultiplyFunctor<bool> {
+  inline bool operator()(const bool a, const bool b) const { return b && a; }
+};
+
+// Divide
+#define DIV_ERROR_INFO                                                         \
+  "InvalidArgumentError: Integer division by zero encountered in "             \
+  "(floor) divide. Please check the input value."
+
+template <typename T, typename Enable = void> struct DivideFunctor {
+  inline T operator()(const T a, const T b) const { return a / b; }
+};
+
+template <typename T>
+struct DivideFunctor<
+    T, typename std::enable_if<std::is_integral<T>::value>::type> {
+  inline T operator()(const T a, const T b) const {
+    // For int32/int64, need to check whether the divison is zero.
+    FDASSERT(b != 0, DIV_ERROR_INFO);
+    return a / b;
+  }
+};
+
+template <typename T, typename Enable = void> struct InverseDivideFunctor {
+  inline T operator()(const T a, const T b) const { return b / a; }
+};
+
+// Maximum
+template <typename T> struct MaximumFunctor {
+  inline T operator()(const T a, const T b) const { return a > b ? a : b; }
+};
+
+}  // namespace function
+}  // namespace fastdeploy

3rdparty/include/fastdeploy/function/full.h

@@ -0,0 +1,44 @@
+// 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/core/fd_scalar.h"
+#include "fastdeploy/core/fd_tensor.h"
+
+namespace fastdeploy {
+namespace function {
+
+/** Fill the value to tensor
+    @param value The value to be filled in tensor
+    @param shape The shape of output tensor.
+    @param out The output tensor which stores the result.
+    @param dtype The data type of output tensor. Default to float32
+*/
+FASTDEPLOY_DECL void Full(const Scalar& value,
+                          const std::vector<int64_t>& shape, FDTensor* out,
+                          FDDataType dtype = FDDataType::FP32);
+
+/** Fill the value to tensor
+    @param x The input tensor.
+    @param value The value to be filled in tensor
+    @param out The output tensor which stores the result.
+    @param dtype The data type of output tensor. Default to float32
+*/
+FASTDEPLOY_DECL void FullLike(const FDTensor& x, const Scalar& value,
+                              FDTensor* out,
+                              FDDataType dtype = FDDataType::FP32);
+
+}  // namespace function
+}  // namespace fastdeploy

3rdparty/include/fastdeploy/function/functions.h

@@ -0,0 +1,36 @@
+// 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/function/cast.h"
+#include "fastdeploy/function/clip.h"
+#include "fastdeploy/function/concat.h"
+#include "fastdeploy/function/cumprod.h"
+#include "fastdeploy/function/elementwise.h"
+#include "fastdeploy/function/full.h"
+#include "fastdeploy/function/gather_scatter_along_axis.h"
+#include "fastdeploy/function/gaussian_random.h"
+#include "fastdeploy/function/isfinite.h"
+#include "fastdeploy/function/linspace.h"
+#include "fastdeploy/function/math.h"
+#include "fastdeploy/function/pad.h"
+#include "fastdeploy/function/quantile.h"
+#include "fastdeploy/function/reduce.h"
+#include "fastdeploy/function/slice.h"
+#include "fastdeploy/function/softmax.h"
+#include "fastdeploy/function/sort.h"
+#include "fastdeploy/function/split.h"
+#include "fastdeploy/function/tile.h"
+#include "fastdeploy/function/transpose.h"

3rdparty/include/fastdeploy/function/gather_scatter_along_axis.h

@@ -0,0 +1,33 @@
+// 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/core/fd_tensor.h"
+
+namespace fastdeploy {
+namespace function {
+
+/** Output is obtained by gathering entries of axis of x indexed by index and
+ *  concatenate them together.
+    @param x The input tensor.
+    @param index The index of a tensor to gather.
+    @param out The output tensor which stores the result.
+    @param axis Axis which will be gathered.
+*/
+void GatherAlongAxis(const FDTensor& x, const FDTensor& index, FDTensor* result,
+                     int axis);
+
+}  // namespace function
+}  // namespace fastdeploy

3rdparty/include/fastdeploy/function/gaussian_random.h

@@ -0,0 +1,36 @@
+// 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/core/fd_tensor.h"
+
+namespace fastdeploy {
+namespace function {
+
+/** Output is obtained by gathering entries of axis of x indexed by index and
+ *  concatenate them together.
+    @param shape The output tensor shape.
+    @param out the output tensor.
+    @param mean mean value of gaussian random
+    @param std standard value of gaussian random
+    @param seed The seed of random generator.
+    @param dtype The data type of the output Tensor.
+*/
+void GaussianRandom(const std::vector<int64_t>& shape, FDTensor* out,
+                    FDDataType dtype = FDDataType::FP32, float mean = 0.0f,
+                    float std = 1.0f, int seed = 0);
+
+}  // namespace function
+}  // namespace fastdeploy

3rdparty/include/fastdeploy/function/isfinite.h

@@ -0,0 +1,47 @@
+// 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/core/fd_tensor.h"
+
+namespace fastdeploy {
+namespace function {
+
+/** Return whether every element of input tensor is NaN or not.
+    @param x The input tensor.
+    @param out The output tensor which stores the result.
+    @param dtype The output data type
+*/
+FASTDEPLOY_DECL void IsNan(const FDTensor& x, FDTensor* out,
+                           FDDataType dtype = FDDataType::BOOL);
+
+/** Return whether every element of input tensor is Inf or not.
+    @param x The input tensor.
+    @param out The output tensor which stores the result.
+    @param dtype The output data type
+*/
+FASTDEPLOY_DECL void IsInf(const FDTensor& x, FDTensor* out,
+                           FDDataType dtype = FDDataType::BOOL);
+
+/** Return whether every element of input tensor is finite or not.
+    @param x The input tensor.
+    @param out The output tensor which stores the result.
+    @param dtype The output data type
+*/
+FASTDEPLOY_DECL void IsFinite(const FDTensor& x, FDTensor* out,
+                              FDDataType dtype = FDDataType::BOOL);
+
+}  // namespace function
+}  // namespace fastdeploy

3rdparty/include/fastdeploy/function/linspace.h

@@ -0,0 +1,33 @@
+// 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/core/fd_tensor.h"
+
+namespace fastdeploy {
+namespace function {
+
+/** Return fixed number of evenly spaced values within a given interval.
+    @param start The input start is start variable of range.
+    @param end The input stop is start variable of range.
+    @param num The input num is given num of the sequence.
+    @param out The output tensor which stores the result.
+    @param dtype The data type of output tensor, default to float32.
+*/
+FASTDEPLOY_DECL void Linspace(double start, double end, int num, FDTensor* out,
+                              FDDataType dtype = FDDataType::FP32);
+
+}  // namespace function
+}  // namespace fastdeploy

3rdparty/include/fastdeploy/function/math.h

@@ -0,0 +1,65 @@
+// 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/core/fd_tensor.h"
+
+namespace fastdeploy {
+namespace function {
+
+/** Calculates the sqrt of the given input Tensor, element-wise. Only for float type FDTensor
+    @param x The input tensor.
+    @param out The output tensor which stores the result.
+*/
+FASTDEPLOY_DECL void Sqrt(const FDTensor& x, FDTensor* out);
+
+/** Calculates the natural log of the given input Tensor, element-wise. Only for float type FDTensor
+    @param x The input tensor.
+    @param out The output tensor which stores the result.
+*/
+FASTDEPLOY_DECL void Log(const FDTensor& x, FDTensor* out);
+
+/** Rounds the values in the input to the nearest integer value, element-wise. Only for float type FDTensor
+    @param x The input tensor.
+    @param out The output tensor which stores the result.
+*/
+FASTDEPLOY_DECL void Round(const FDTensor& x, FDTensor* out);
+
+/** Computes exp of x element-wise with a natural number e as the base, element-wise. Only for float type FDTensor
+    @param x The input tensor.
+    @param out The output tensor which stores the result.
+*/
+FASTDEPLOY_DECL void Exp(const FDTensor& x, FDTensor* out);
+
+/** This operator is used to perform elementwise abs for input X. Only for float type FDTensor
+    @param x The input tensor.
+    @param out The output tensor which stores the result.
+*/
+FASTDEPLOY_DECL void Abs(const FDTensor& x, FDTensor* out);
+
+/** Computes ceil of x element-wise. Only for float type FDTensor
+    @param x The input tensor.
+    @param out The output tensor which stores the result.
+*/
+FASTDEPLOY_DECL void Ceil(const FDTensor& x, FDTensor* out);
+
+/** Computes floor of x element-wise. Only for float type FDTensor
+    @param x The input tensor.
+    @param out The output tensor which stores the result.
+*/
+FASTDEPLOY_DECL void Floor(const FDTensor& x, FDTensor* out);
+
+}  // namespace function
+}  // namespace fastdeploy

3rdparty/include/fastdeploy/function/math_functor.h

@@ -0,0 +1,81 @@
+// 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/function/eigen.h"
+
+namespace fastdeploy {
+namespace function {
+
+// log(x) = natural logarithm of x
+template <typename T> struct LogFunctor {
+  template <typename Device, typename X, typename Out>
+  void operator()(Device d, X x, Out out) const {
+    out.device(d) = x.log();
+  }
+};
+
+// exp functor
+// exp(x) = e^x
+template <typename T> struct ExpFunctor {
+  template <typename Device, typename X, typename Out>
+  void operator()(Device d, X x, Out out) const {
+    out.device(d) = x.exp();
+  }
+};
+
+// round(x) = [x]
+template <typename T> struct RoundFunctor {
+  template <typename Device, typename X, typename Out>
+  void operator()(Device d, X x, Out out) const {
+    out.device(d) = x.round();
+  }
+};
+
+// sqrt(x) = x^(1/2)
+template <typename T> struct SqrtFunctor {
+  template <typename Device, typename X, typename Out>
+  void operator()(Device d, X x, Out out) const {
+    out.device(d) = x.sqrt();
+  }
+};
+
+// abs(x) = x if x > 0 else -x
+template <typename T> struct AbsFunctor {
+  template <typename Device, typename X, typename Out>
+  void operator()(Device d, X x, Out out) const {
+    out.device(d) =
+        x.unaryExpr([](T v) { return v > static_cast<T>(0) ? v : -v; });
+  }
+};
+
+// ceil(x) = ceiling(x)
+template <typename T> struct CeilFunctor {
+  template <typename Device, typename X, typename Out>
+  void operator()(Device d, X x, Out out) const {
+    out.device(d) = x.ceil();
+  }
+};
+
+// floor(x) = flooring(x)
+template <typename T> struct FloorFunctor {
+  template <typename Device, typename X, typename Out>
+  void operator()(Device d, X x, Out out) const {
+    out.device(d) = x.floor();
+  }
+};
+
+}  // namespace function
+}  // namespace fastdeploy

3rdparty/include/fastdeploy/function/pad.h

@@ -0,0 +1,31 @@
+// 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/core/fd_tensor.h"
+
+namespace fastdeploy {
+namespace function {
+/** Excute the pad operation for input FDTensor along given dims.
+    @param x The input tensor.
+    @param out The output tensor which stores the result.
+    @param pads The size of padding for each dimension, for 3-D tensor, the pads should be [1d-left, 1d-right, 2d-left, 2d-right, 3d-left, 3d-right]
+    @param pad_value The value which will fill into out tensor
+*/
+FASTDEPLOY_DECL void Pad(const FDTensor& x, FDTensor* out,
+            const std::vector<int>& pads, float pad_value = 0);
+
+}
+}  // namespace fastdeploy

3rdparty/include/fastdeploy/function/quantile.h

@@ -0,0 +1,34 @@
+// 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/core/fd_tensor.h"
+
+namespace fastdeploy {
+namespace function {
+
+/** Compute the quantile of the input along the specified axis. If any values
+ ** in a reduced row are NaN, then the quantiles for that reduction will be NaN.
+    @param x The input tensor.
+    @param q The q for calculate quantile, which should be in range [0, 1].
+    @param axis The axis along which to calculate quantile. axis should be int
+                or list of int.
+    @param out The output tensor which stores the result.
+*/
+FASTDEPLOY_DECL void Quantile(const FDTensor& x, const std::vector<double>& q,
+                              const std::vector<int>& axis, FDTensor* out);
+
+}  // namespace function
+}  // namespace fastdeploy

3rdparty/include/fastdeploy/function/reduce.h

@@ -0,0 +1,127 @@
+// 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/core/fd_tensor.h"
+
+namespace fastdeploy {
+namespace function {
+/** Excute the maximum operation for input FDTensor along given dims.
+    @param x The input tensor.
+    @param out The output tensor which stores the result.
+    @param dims The vector of axis which will be reduced.
+    @param keep_dim Whether to keep the reduced dims, default false.
+    @param reduce_all Whether to reduce all dims, default false.
+*/
+FASTDEPLOY_DECL void Max(const FDTensor& x, FDTensor* out,
+                         const std::vector<int64_t>& dims,
+                         bool keep_dim = false, bool reduce_all = false);
+
+/** Excute the minimum operation for input FDTensor along given dims.
+    @param x The input tensor.
+    @param out The output tensor which stores the result.
+    @param dims The vector of axis which will be reduced.
+    @param keep_dim Whether to keep the reduced dims, default false.
+    @param reduce_all Whether to reduce all dims, default false.
+*/
+FASTDEPLOY_DECL void Min(const FDTensor& x, FDTensor* out,
+                         const std::vector<int64_t>& dims,
+                         bool keep_dim = false, bool reduce_all = false);
+
+/** Excute the sum operation for input FDTensor along given dims.
+    @param x The input tensor.
+    @param out The output tensor which stores the result.
+    @param dims The vector of axis which will be reduced.
+    @param keep_dim Whether to keep the reduced dims, default false.
+    @param reduce_all Whether to reduce all dims, default false.
+*/
+FASTDEPLOY_DECL void Sum(const FDTensor& x, FDTensor* out,
+                         const std::vector<int64_t>& dims,
+                         bool keep_dim = false, bool reduce_all = false);
+
+/** Excute the all operation for input FDTensor along given dims.
+    @param x The input tensor.
+    @param out The output tensor which stores the result.
+    @param dims The vector of axis which will be reduced.
+    @param keep_dim Whether to keep the reduced dims, default false.
+    @param reduce_all Whether to reduce all dims, default false.
+*/
+FASTDEPLOY_DECL void All(const FDTensor& x, FDTensor* out,
+                         const std::vector<int64_t>& dims,
+                         bool keep_dim = false, bool reduce_all = false);
+
+/** Excute the any operation for input FDTensor along given dims.
+    @param x The input tensor.
+    @param out The output tensor which stores the result.
+    @param dims The vector of axis which will be reduced.
+    @param keep_dim Whether to keep the reduced dims, default false.
+    @param reduce_all Whether to reduce all dims, default false.
+*/
+FASTDEPLOY_DECL void Any(const FDTensor& x, FDTensor* out,
+                         const std::vector<int64_t>& dims,
+                         bool keep_dim = false, bool reduce_all = false);
+
+/** Excute the mean operation for input FDTensor along given dims.
+    @param x The input tensor.
+    @param out The output tensor which stores the result.
+    @param dims The vector of axis which will be reduced.
+    @param keep_dim Whether to keep the reduced dims, default false.
+    @param reduce_all Whether to reduce all dims, default false.
+*/
+FASTDEPLOY_DECL void Mean(const FDTensor& x, FDTensor* out,
+                          const std::vector<int64_t>& dims,
+                          bool keep_dim = false, bool reduce_all = false);
+
+/** Excute the product operation for input FDTensor along given dims.
+    @param x The input tensor.
+    @param out The output tensor which stores the result.
+    @param dims The vector of axis which will be reduced.
+    @param keep_dim Whether to keep the reduced dims, default false.
+    @param reduce_all Whether to reduce all dims, default false.
+*/
+FASTDEPLOY_DECL void Prod(const FDTensor& x, FDTensor* out,
+                          const std::vector<int64_t>& dims,
+                          bool keep_dim = false, bool reduce_all = false);
+
+/** Excute the argmax operation for input FDTensor along given dims.
+    @param x The input tensor.
+    @param out The output tensor which stores the result.
+    @param axis The axis which will be reduced.
+    @param output_dtype The data type of output FDTensor, INT64 or INT32,
+   default to INT64.
+    @param keep_dim Whether to keep the reduced dims, default false.
+    @param flatten Whether to flatten FDTensor to get the argmin index, default
+   false.
+*/
+FASTDEPLOY_DECL void ArgMax(const FDTensor& x, FDTensor* out, int64_t axis,
+                            FDDataType output_dtype = FDDataType::INT64,
+                            bool keep_dim = false, bool flatten = false);
+
+/** Excute the argmin operation for input FDTensor along given dims.
+    @param x The input tensor.
+    @param out The output tensor which stores the result.
+    @param axis The axis which will be reduced.
+    @param output_dtype The data type of output FDTensor, INT64 or INT32,
+   default to INT64.
+    @param keep_dim Whether to keep the reduced dims, default false.
+    @param flatten Whether to flatten FDTensor to get the argmin index, default
+   false.
+*/
+FASTDEPLOY_DECL void ArgMin(const FDTensor& x, FDTensor* out, int64_t axis,
+                            FDDataType output_dtype = FDDataType::INT64,
+                            bool keep_dim = false, bool flatten = false);
+
+}  // namespace function
+}  // namespace fastdeploy

3rdparty/include/fastdeploy/function/reduce_functor.h

@@ -0,0 +1,77 @@
+// 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/function/eigen.h"
+namespace fastdeploy {
+namespace function {
+//////// Max Functor ///////
+struct MaxFunctor {
+  template <typename X, typename Y, typename Dim>
+  void operator()(const Eigen::DefaultDevice& dev, X* x, Y* y, const Dim& dim) {
+    y->device(dev) = x->maximum(dim);
+  }
+};
+
+//////// Min Functor ///////
+struct MinFunctor {
+  template <typename X, typename Y, typename Dim>
+  void operator()(const Eigen::DefaultDevice& dev, X* x, Y* y, const Dim& dim) {
+    y->device(dev) = x->minimum(dim);
+  }
+};
+
+//////// Sum Functor ///////
+struct SumFunctor {
+  template <typename X, typename Y, typename Dim>
+  void operator()(const Eigen::DefaultDevice& dev, X* x, Y* y, const Dim& dim) {
+    y->device(dev) = x->sum(dim);
+  }
+};
+
+//////// All Functor ///////
+struct AllFunctor {
+  template <typename X, typename Y, typename Dim>
+  void operator()(const Eigen::DefaultDevice& dev, X* x, Y* y, const Dim& dim) {
+    y->device(dev) = x->all(dim);
+  }
+};
+
+//////// Any Functor ///////
+struct AnyFunctor {
+  template <typename X, typename Y, typename Dim>
+  void operator()(const Eigen::DefaultDevice& dev, X* x, Y* y, const Dim& dim) {
+    y->device(dev) = x->any(dim);
+  }
+};
+
+//////// Mean Functor ///////
+struct MeanFunctor {
+  template <typename X, typename Y, typename Dim>
+  void operator()(const Eigen::DefaultDevice& dev, X* x, Y* y, const Dim& dim) {
+    y->device(dev) = x->mean(dim);
+  }
+};
+
+//////// Prod Functor ///////
+struct ProdFunctor {
+  template <typename X, typename Y, typename Dim>
+  void operator()(const Eigen::DefaultDevice& dev, X* x, Y* y, const Dim& dim) {
+    y->device(dev) = x->prod(dim);
+  }
+};
+
+}  // namespace function
+}  // namespace fastdeploy

3rdparty/include/fastdeploy/function/slice.h

@@ -0,0 +1,44 @@
+// 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/core/fd_tensor.h"
+
+namespace fastdeploy {
+namespace function {
+
+/** This operator produces a slice of input along multiple axes.
+    @param x The input tensor.
+    @param axes Axes that starts and ends apply to.
+    @param starts If starts is a list or tuple, the elements of it should be
+      integers or Tensors with shape [1]. If starts is an Tensor, it should
+      be an 1-D Tensor. It represents starting indices of corresponding axis
+      in axes
+    @param ends If ends is a list or tuple, the elements of it should be
+      integers or Tensors with shape [1]. If ends is an Tensor, it should
+      be an 1-D Tensor . It represents ending indices of corresponding axis
+      in axes.
+    @param out The output tensor which stores the result.
+*/
+
+FASTDEPLOY_DECL void Slice(const FDTensor& x, const std::vector<int64_t>& axes,
+                           const std::vector<int64_t>& starts,
+                           const std::vector<int64_t>& ends, FDTensor* out);
+
+FASTDEPLOY_DECL void Slice(const FDTensor& x, const std::vector<int64_t>& axes,
+                           const std::vector<int64_t>& index, FDTensor* out);
+
+}  // namespace function
+}  // namespace fastdeploy

3rdparty/include/fastdeploy/function/softmax.h

@@ -0,0 +1,29 @@
+// 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/core/fd_tensor.h"
+
+namespace fastdeploy {
+namespace function {
+/** Excute the softmax operation for input FDTensor along given dims.
+    @param x The input tensor.
+    @param out The output tensor which stores the result.
+    @param axis The axis to be computed softmax value.
+*/
+FASTDEPLOY_DECL void Softmax(const FDTensor& x, FDTensor* out, int axis = -1);
+
+}  // namespace function
+}  // namespace fastdeploy

3rdparty/include/fastdeploy/function/sort.h

@@ -0,0 +1,47 @@
+// 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/core/fd_tensor.h"
+
+namespace fastdeploy {
+namespace function {
+
+/**
+ * @brief Performs sorting on the input tensor along the given axis and outputs
+ *        two tensors, Output(Out) and Output(Indices). They reserve the same
+ *        shape with Input(X), and Output(Out) represents the sorted tensor
+ *        while Output(Indices) gives the sorted order along the given axis
+ *        Attr(axis).
+ * @param  x            The input of sort
+ * @param  out          The sorted tensor of sort op, with the same shape as
+ *                      x
+ * @param  indices      The indices of a tensor giving the sorted order, with
+ *                      the same shape as x
+ * @param  axis         The axis along which to sort the tensor.
+ *                      When axis < 0, the actual axis will be the |axis|'th
+ *                      counting backwards
+ * @param  descending   The descending attribute is a flag to tell
+ *                      algorithm how to sort the input data.
+ *                      If descending is true, will sort by descending order,
+ *                      else if false, sort by ascending order
+ * @param  indices_type The data type of indices, default to int64
+ */
+FASTDEPLOY_DECL void Sort(const FDTensor& x, FDTensor* out, FDTensor* indices,
+                          int axis = 0, bool descending = false,
+                          FDDataType indices_type = FDDataType::INT64);
+
+}  // namespace function
+}  // namespace fastdeploy

3rdparty/include/fastdeploy/function/split.h

@@ -0,0 +1,36 @@
+// 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/core/fd_tensor.h"
+
+namespace fastdeploy {
+namespace function {
+
+/** Split the input tensor into multiple sub-Tensors.
+    @param x The input tensor.
+    @param num_or_sections f num_or_sections is an int, then num_or_sections
+           indicates the number of equal sized sub-Tensors that the x will
+           be divided into.
+    @param out The output vector tensor which stores the result.
+    @param axis Axis which will be splitted.
+*/
+
+FASTDEPLOY_DECL void Split(const FDTensor& x,
+                           const std::vector<int>& num_or_sections,
+                           std::vector<FDTensor>* out, int axis = 0);
+
+}  // namespace function
+}  // namespace fastdeploy

3rdparty/include/fastdeploy/function/tile.h

@@ -0,0 +1,36 @@
+// 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/core/fd_tensor.h"
+
+namespace fastdeploy {
+namespace function {
+
+/** Construct a new Tensor by repeating x the number of times given by
+ ** repeat_times. After tiling, the value of the i’th dimension of the
+ ** output is equal to x.shape[i]*repeat_times[i]. Both the number of
+ ** dimensions of x and the number of elements in repeat_times should
+ ** be less than or equal to 6.Support all data types.
+    @param x The input tensor.
+    @param repeat_times The lower bound
+    @param out The output tensor which stores the result.
+*/
+FASTDEPLOY_DECL void Tile(const FDTensor& x,
+                          const std::vector<int64_t>& repeat_times,
+                          FDTensor* out);
+
+}  // namespace function
+}  // namespace fastdeploy

3rdparty/include/fastdeploy/function/transpose.h

@@ -0,0 +1,29 @@
+// 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/core/fd_tensor.h"
+
+namespace fastdeploy {
+namespace function {
+/** Excute the transpose operation for input FDTensor along given dims.
+    @param x The input tensor.
+    @param out The output tensor which stores the result.
+    @param dims The vector of axis which the input tensor will transpose.
+*/
+FASTDEPLOY_DECL void Transpose(const FDTensor& x, FDTensor* out,
+                               const std::vector<int64_t>& dims);
+}  // namespace function
+}  // namespace fastdeploy

3rdparty/include/fastdeploy/pipeline.h

@@ -0,0 +1,21 @@
+// 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/core/config.h"
+#ifdef ENABLE_VISION
+#include "fastdeploy/pipeline/pptinypose/pipeline.h"
+#endif
+
+#include "fastdeploy/vision/visualize/visualize.h"

3rdparty/include/fastdeploy/pipeline/pptinypose/pipeline.h

@@ -0,0 +1,67 @@
+// 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 "fastdeploy/vision/common/result.h"
+#include "fastdeploy/vision/detection/ppdet/model.h"
+#include "fastdeploy/vision/keypointdet/pptinypose/pptinypose.h"
+
+namespace fastdeploy {
+/** \brief All pipeline model APIs are defined inside this namespace
+ *
+ */
+namespace pipeline {
+
+/*! @brief PPTinyPose Pipeline object used when to load a detection model + pptinypose model
+ */
+class FASTDEPLOY_DECL PPTinyPose {
+ public:
+  /** \brief Set initialized detection model object and pptinypose model object
+   *
+   * \param[in] det_model Initialized detection model object
+   * \param[in] pptinypose_model Initialized pptinypose model object
+   */
+  PPTinyPose(
+      fastdeploy::vision::detection::PicoDet* det_model,
+      fastdeploy::vision::keypointdetection::PPTinyPose* pptinypose_model);
+
+  /** \brief Predict the keypoint detection result for an input image
+   *
+   * \param[in] img The input image data, comes from cv::imread()
+   * \param[in] result The output keypoint detection result will be writen to this structure
+   * \return true if the prediction successed, otherwise false
+   */
+  virtual bool Predict(cv::Mat* img,
+                       fastdeploy::vision::KeyPointDetectionResult* result);
+
+  /* \brief The score threshold for detectin model to filter bbox before inputting pptinypose model
+   */
+  float detection_model_score_threshold = 0;
+
+ protected:
+  fastdeploy::vision::detection::PicoDet* detector_ = nullptr;
+  fastdeploy::vision::keypointdetection::PPTinyPose* pptinypose_model_ =
+      nullptr;
+
+  virtual bool Detect(cv::Mat* img,
+                      fastdeploy::vision::DetectionResult* result);
+  virtual bool KeypointDetect(
+      cv::Mat* img, fastdeploy::vision::KeyPointDetectionResult* result,
+      fastdeploy::vision::DetectionResult& detection_result);
+};
+
+}  // namespace pipeline
+}  // namespace fastdeploy

3rdparty/include/fastdeploy/runtime.h

@@ -0,0 +1,471 @@
+// 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.
+
+/*! \file runtime.h
+    \brief A brief file description.
+
+    More details
+ */
+
+#pragma once
+
+#include <algorithm>
+#include <map>
+#include <vector>
+
+#include "backends/rknpu/rknpu2/rknpu2_config.h"
+#include "fastdeploy/backends/backend.h"
+#include "fastdeploy/utils/perf.h"
+
+/** \brief All C++ FastDeploy APIs are defined inside this namespace
+*
+*/
+namespace fastdeploy {
+
+/*! Inference backend supported in FastDeploy */
+enum Backend {
+  UNKNOWN,  ///< Unknown inference backend
+  ORT,  ///< ONNX Runtime, support Paddle/ONNX format model, CPU / Nvidia GPU
+  TRT,  ///< TensorRT, support Paddle/ONNX format model, Nvidia GPU only
+  PDINFER,  ///< Paddle Inference, support Paddle format model, CPU / Nvidia GPU
+  POROS,    ///< Poros, support TorchScript format model, CPU / Nvidia GPU
+  OPENVINO,  ///< Intel OpenVINO, support Paddle/ONNX format, CPU only
+  LITE,      ///< Paddle Lite, support Paddle format model, ARM CPU only
+  RKNPU2,    ///< RKNPU2, support RKNN format model, Rockchip NPU only
+};
+
+FASTDEPLOY_DECL std::ostream& operator<<(std::ostream& out,
+                                         const Backend& backend);
+
+/*! Paddle Lite power mode for mobile device. */
+enum LitePowerMode {
+  LITE_POWER_HIGH = 0,       ///< Use Lite Backend with high power mode
+  LITE_POWER_LOW = 1,        ///< Use Lite Backend with low power mode
+  LITE_POWER_FULL = 2,       ///< Use Lite Backend with full power mode
+  LITE_POWER_NO_BIND = 3,    ///< Use Lite Backend with no bind power mode
+  LITE_POWER_RAND_HIGH = 4,  ///< Use Lite Backend with rand high mode
+  LITE_POWER_RAND_LOW = 5    ///< Use Lite Backend with rand low power mode
+};
+
+FASTDEPLOY_DECL std::string Str(const Backend& b);
+FASTDEPLOY_DECL std::string Str(const ModelFormat& f);
+
+/**
+ * @brief Get all the available inference backend in FastDeploy
+ */
+FASTDEPLOY_DECL std::vector<Backend> GetAvailableBackends();
+
+/**
+ * @brief Check if the inference backend available
+ */
+FASTDEPLOY_DECL bool IsBackendAvailable(const Backend& backend);
+
+bool CheckModelFormat(const std::string& model_file,
+                      const ModelFormat& model_format);
+ModelFormat GuessModelFormat(const std::string& model_file);
+
+/*! @brief Option object used when create a new Runtime object
+ */
+struct FASTDEPLOY_DECL RuntimeOption {
+  /** \brief Set path of model file and parameter file
+   *
+   * \param[in] model_path Path of model file, e.g ResNet50/model.pdmodel for Paddle format model / ResNet50/model.onnx for ONNX format model
+   * \param[in] params_path Path of parameter file, this only used when the model format is Paddle, e.g Resnet50/model.pdiparams
+   * \param[in] format Format of the loaded model
+   */
+  void SetModelPath(const std::string& model_path,
+                    const std::string& params_path = "",
+                    const ModelFormat& format = ModelFormat::PADDLE);
+
+  /// Use cpu to inference, the runtime will inference on CPU by default
+  void UseCpu();
+
+  /// Use Nvidia GPU to inference
+  void UseGpu(int gpu_id = 0);
+
+  void UseRKNPU2(fastdeploy::rknpu2::CpuName rknpu2_name =
+                     fastdeploy::rknpu2::CpuName::RK3588,
+                 fastdeploy::rknpu2::CoreMask rknpu2_core =
+                     fastdeploy::rknpu2::CoreMask::RKNN_NPU_CORE_0);
+
+  /// Use TimVX to inference
+  void UseTimVX();
+
+  void SetExternalStream(void* external_stream);
+
+  /*
+   * @brief Set number of cpu threads while inference on CPU, by default it will decided by the different backends
+   */
+  void SetCpuThreadNum(int thread_num);
+
+  /// Set ORT graph opt level, default is decide by ONNX Runtime itself
+  void SetOrtGraphOptLevel(int level = -1);
+
+  /// Set Paddle Inference as inference backend, support CPU/GPU
+  void UsePaddleBackend();
+
+  /// Wrapper function of UsePaddleBackend()
+  void UsePaddleInferBackend() { return UsePaddleBackend(); }
+
+  /// Set ONNX Runtime as inference backend, support CPU/GPU
+  void UseOrtBackend();
+
+  /// Set TensorRT as inference backend, only support GPU
+  void UseTrtBackend();
+
+  /// Set Poros backend as inference backend, support CPU/GPU
+  void UsePorosBackend();
+
+  /// Set OpenVINO as inference backend, only support CPU
+  void UseOpenVINOBackend();
+
+  /// Set Paddle Lite as inference backend, only support arm cpu
+  void UseLiteBackend();
+
+  /// Wrapper function of UseLiteBackend()
+  void UsePaddleLiteBackend() { return UseLiteBackend(); }
+
+  /// Set mkldnn switch while using Paddle Inference as inference backend
+  void SetPaddleMKLDNN(bool pd_mkldnn = true);
+
+  /*
+   * @brief If TensorRT backend is used, EnablePaddleToTrt will change to use Paddle Inference backend, and use its integrated TensorRT instead.
+   */
+  void EnablePaddleToTrt();
+
+  /**
+   * @brief Delete pass by name while using Paddle Inference as inference backend, this can be called multiple times to delete a set of passes
+   */
+  void DeletePaddleBackendPass(const std::string& delete_pass_name);
+
+  /**
+   * @brief Enable print debug information while using Paddle Inference as inference backend, the backend disable the debug information by default
+   */
+  void EnablePaddleLogInfo();
+
+  /**
+   * @brief Disable print debug information while using Paddle Inference as inference backend
+   */
+  void DisablePaddleLogInfo();
+
+  /**
+   * @brief Set shape cache size while using Paddle Inference with mkldnn, by default it will cache all the difference shape
+   */
+  void SetPaddleMKLDNNCacheSize(int size);
+
+  /**
+   * @brief Set device name for OpenVINO, default 'CPU', can also be 'AUTO', 'GPU', 'GPU.1'....
+   */
+  void SetOpenVINODevice(const std::string& name = "CPU");
+
+  /**
+   * @brief Set shape info for OpenVINO
+   */
+  void SetOpenVINOShapeInfo(
+      const std::map<std::string, std::vector<int64_t>>& shape_info) {
+    ov_shape_infos = shape_info;
+  }
+
+  /**
+   * @brief While use OpenVINO backend with intel GPU, use this interface to specify operators run on CPU
+   */
+  void SetOpenVINOCpuOperators(const std::vector<std::string>& operators) {
+    ov_cpu_operators = operators;
+  }
+
+  /**
+   * @brief Set optimzed model dir for Paddle Lite backend.
+   */
+  void SetLiteOptimizedModelDir(const std::string& optimized_model_dir);
+
+  /**
+   * @brief Set nnadapter subgraph partition path for Paddle Lite backend.
+   */
+  void SetLiteSubgraphPartitionPath(
+      const std::string& nnadapter_subgraph_partition_config_path);
+
+  /**
+   * @brief enable half precision while use paddle lite backend
+   */
+  void EnableLiteFP16();
+
+  /**
+   * @brief disable half precision, change to full precision(float32)
+   */
+  void DisableLiteFP16();
+
+  /**
+    * @brief enable int8 precision while use paddle lite backend
+    */
+  void EnableLiteInt8();
+
+  /**
+    * @brief disable int8 precision, change to full precision(float32)
+    */
+  void DisableLiteInt8();
+
+  /**
+   * @brief Set power mode while using Paddle Lite as inference backend, mode(0: LITE_POWER_HIGH; 1: LITE_POWER_LOW; 2: LITE_POWER_FULL; 3: LITE_POWER_NO_BIND, 4: LITE_POWER_RAND_HIGH; 5: LITE_POWER_RAND_LOW, refer [paddle lite](https://paddle-lite.readthedocs.io/zh/latest/api_reference/cxx_api_doc.html#set-power-mode) for more details)
+   */
+  void SetLitePowerMode(LitePowerMode mode);
+
+  /** \brief Set shape range of input tensor for the model that contain dynamic input shape while using TensorRT backend
+   *
+   * \param[in] input_name The name of input for the model which is dynamic shape
+   * \param[in] min_shape The minimal shape for the input tensor
+   * \param[in] opt_shape The optimized shape for the input tensor, just set the most common shape, if set as default value, it will keep same with min_shape
+   * \param[in] max_shape The maximum shape for the input tensor, if set as default value, it will keep same with min_shape
+   */
+  void SetTrtInputShape(
+      const std::string& input_name, const std::vector<int32_t>& min_shape,
+      const std::vector<int32_t>& opt_shape = std::vector<int32_t>(),
+      const std::vector<int32_t>& max_shape = std::vector<int32_t>());
+
+  /// Set max_workspace_size for TensorRT, default 1<<30
+  void SetTrtMaxWorkspaceSize(size_t trt_max_workspace_size);
+
+  /// Set max_batch_size for TensorRT, default 32
+  void SetTrtMaxBatchSize(size_t max_batch_size);
+
+  /**
+   * @brief Enable FP16 inference while using TensorRT backend. Notice: not all the GPU device support FP16, on those device doesn't support FP16, FastDeploy will fallback to FP32 automaticly
+   */
+  void EnableTrtFP16();
+
+  /// Disable FP16 inference while using TensorRT backend
+  void DisableTrtFP16();
+
+  /**
+   * @brief Set cache file path while use TensorRT backend. Loadding a Paddle/ONNX model and initialize TensorRT will take a long time, by this interface it will save the tensorrt engine to `cache_file_path`, and load it directly while execute the code again
+   */
+  void SetTrtCacheFile(const std::string& cache_file_path);
+
+  /**
+   * @brief Enable pinned memory. Pinned memory can be utilized to speedup the data transfer between CPU and GPU. Currently it's only suppurted in TRT backend and Paddle Inference backend.
+   */
+  void EnablePinnedMemory();
+
+  /**
+   * @brief Disable pinned memory
+   */
+  void DisablePinnedMemory();
+
+  /**
+   * @brief Enable to collect shape in paddle trt backend
+   */
+  void EnablePaddleTrtCollectShape();
+
+  /**
+   * @brief Disable to collect shape in paddle trt backend
+   */
+  void DisablePaddleTrtCollectShape();
+
+  /**
+   * @brief Prevent ops running in paddle trt backend
+   */
+  void DisablePaddleTrtOPs(const std::vector<std::string>& ops);
+
+  /*
+   * @brief Set number of streams by the OpenVINO backends
+   */
+  void SetOpenVINOStreams(int num_streams);
+
+  /** \Use Graphcore IPU to inference.
+   *
+   * \param[in] device_num the number of IPUs.
+   * \param[in] micro_batch_size the batch size in the graph, only work when graph has no batch shape info.
+   * \param[in] enable_pipelining enable pipelining.
+   * \param[in] batches_per_step the number of batches per run in pipelining.
+   */
+  void UseIpu(int device_num = 1, int micro_batch_size = 1,
+              bool enable_pipelining = false, int batches_per_step = 1);
+
+  /** \brief Set IPU config.
+   *
+   * \param[in] enable_fp16 enable fp16.
+   * \param[in] replica_num the number of graph replication.
+   * \param[in] available_memory_proportion the available memory proportion for matmul/conv.
+   * \param[in] enable_half_partial enable fp16 partial for matmul, only work with fp16.
+   */
+  void SetIpuConfig(bool enable_fp16 = false, int replica_num = 1,
+                    float available_memory_proportion = 1.0,
+                    bool enable_half_partial = false);
+
+  Backend backend = Backend::UNKNOWN;
+  // for cpu inference and preprocess
+  // default will let the backend choose their own default value
+  int cpu_thread_num = -1;
+  int device_id = 0;
+
+  Device device = Device::CPU;
+
+  void* external_stream_ = nullptr;
+
+  bool enable_pinned_memory = false;
+
+  // ======Only for ORT Backend========
+  // -1 means use default value by ort
+  // 0: ORT_DISABLE_ALL 1: ORT_ENABLE_BASIC 2: ORT_ENABLE_EXTENDED 3:
+  // ORT_ENABLE_ALL
+  int ort_graph_opt_level = -1;
+  int ort_inter_op_num_threads = -1;
+  // 0: ORT_SEQUENTIAL 1: ORT_PARALLEL
+  int ort_execution_mode = -1;
+
+  // ======Only for Paddle Backend=====
+  bool pd_enable_mkldnn = true;
+  bool pd_enable_log_info = false;
+  bool pd_enable_trt = false;
+  bool pd_collect_shape = false;
+  int pd_mkldnn_cache_size = 1;
+  std::vector<std::string> pd_delete_pass_names;
+
+  // ======Only for Paddle IPU Backend =======
+  int ipu_device_num = 1;
+  int ipu_micro_batch_size = 1;
+  bool ipu_enable_pipelining = false;
+  int ipu_batches_per_step = 1;
+  bool ipu_enable_fp16 = false;
+  int ipu_replica_num = 1;
+  float ipu_available_memory_proportion = 1.0;
+  bool ipu_enable_half_partial = false;
+
+  // ======Only for Paddle-Lite Backend=====
+  // 0: LITE_POWER_HIGH 1: LITE_POWER_LOW 2: LITE_POWER_FULL
+  // 3: LITE_POWER_NO_BIND 4: LITE_POWER_RAND_HIGH
+  // 5: LITE_POWER_RAND_LOW
+  LitePowerMode lite_power_mode = LitePowerMode::LITE_POWER_NO_BIND;
+  // enable int8 or not
+  bool lite_enable_int8 = false;
+  // enable fp16 or not
+  bool lite_enable_fp16 = false;
+  // optimized model dir for CxxConfig
+  std::string lite_optimized_model_dir = "";
+  std::string lite_nnadapter_subgraph_partition_config_path = "";
+  bool enable_timvx = false;
+
+  // ======Only for Trt Backend=======
+  std::map<std::string, std::vector<int32_t>> trt_max_shape;
+  std::map<std::string, std::vector<int32_t>> trt_min_shape;
+  std::map<std::string, std::vector<int32_t>> trt_opt_shape;
+  std::string trt_serialize_file = "";
+  bool trt_enable_fp16 = false;
+  bool trt_enable_int8 = false;
+  size_t trt_max_batch_size = 32;
+  size_t trt_max_workspace_size = 1 << 30;
+  // ======Only for PaddleTrt Backend=======
+  std::vector<std::string> trt_disabled_ops_{};
+
+  // ======Only for Poros Backend=======
+  bool is_dynamic = false;
+  bool long_to_int = true;
+  bool use_nvidia_tf32 = false;
+  int unconst_ops_thres = -1;
+  std::string poros_file = "";
+
+  // ======Only for OpenVINO Backend=======
+  int ov_num_streams = 0;
+  std::string openvino_device = "CPU";
+  std::map<std::string, std::vector<int64_t>> ov_shape_infos;
+  std::vector<std::string> ov_cpu_operators;
+
+  // ======Only for RKNPU2 Backend=======
+  fastdeploy::rknpu2::CpuName rknpu2_cpu_name_ =
+      fastdeploy::rknpu2::CpuName::RK3588;
+  fastdeploy::rknpu2::CoreMask rknpu2_core_mask_ =
+      fastdeploy::rknpu2::CoreMask::RKNN_NPU_CORE_AUTO;
+
+  std::string model_file = "";   // Path of model file
+  std::string params_file = "";  // Path of parameters file, can be empty
+  // format of input model
+  ModelFormat model_format = ModelFormat::AUTOREC;
+};
+
+/*! @brief Runtime object used to inference the loaded model on different devices
+ */
+struct FASTDEPLOY_DECL Runtime {
+ public:
+  /// Intialize a Runtime object with RuntimeOption
+  bool Init(const RuntimeOption& _option);
+
+  /** \brief Inference the model by the input data, and write to the output
+   *
+   * \param[in] input_tensors Notice the FDTensor::name should keep same with the model's input
+   * \param[in] output_tensors Inference results
+   * \return true if the inference successed, otherwise false
+   */
+  bool Infer(std::vector<FDTensor>& input_tensors,
+             std::vector<FDTensor>* output_tensors);
+
+  /** \brief No params inference the model.
+   *
+   *  the input and output data need to pass through the BindInputTensor and GetOutputTensor interfaces.
+   */
+  bool Infer();
+
+  /** \brief Compile TorchScript Module, only for Poros backend
+   *
+   * \param[in] prewarm_tensors Prewarm datas for compile
+   * \param[in] _option Runtime option
+   * \return true if compile successed, otherwise false
+   */
+  bool Compile(std::vector<std::vector<FDTensor>>& prewarm_tensors,
+               const RuntimeOption& _option);
+
+  /** \brief Get number of inputs
+   */
+  int NumInputs() { return backend_->NumInputs(); }
+  /** \brief Get number of outputs
+   */
+  int NumOutputs() { return backend_->NumOutputs(); }
+  /** \brief Get input information by index
+   */
+  TensorInfo GetInputInfo(int index);
+  /** \brief Get output information by index
+   */
+  TensorInfo GetOutputInfo(int index);
+  /** \brief Get all the input information
+   */
+  std::vector<TensorInfo> GetInputInfos();
+  /** \brief Get all the output information
+   */
+  std::vector<TensorInfo> GetOutputInfos();
+  /** \brief Bind FDTensor by name, no copy and share input memory
+   */
+  void BindInputTensor(const std::string& name, FDTensor& input);
+  /** \brief Get output FDTensor by name, no copy and share backend output memory
+   */
+  FDTensor* GetOutputTensor(const std::string& name);
+
+  /** \brief Clone new Runtime when multiple instances of the same model are created
+   *
+   * \param[in] stream CUDA Stream, defualt param is nullptr
+   * \return new Runtime* by this clone
+   */
+  Runtime* Clone(void* stream = nullptr, int device_id = -1);
+
+  RuntimeOption option;
+
+ private:
+  void CreateOrtBackend();
+  void CreatePaddleBackend();
+  void CreateTrtBackend();
+  void CreateOpenVINOBackend();
+  void CreateLiteBackend();
+  void CreateRKNPU2Backend();
+  std::unique_ptr<BaseBackend> backend_;
+  std::vector<FDTensor> input_tensors_;
+  std::vector<FDTensor> output_tensors_;
+};
+}  // namespace fastdeploy

3rdparty/include/fastdeploy/text.h

@@ -0,0 +1,19 @@
+// 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/core/config.h"
+#ifdef ENABLE_TEXT
+#include "fastdeploy/text/uie/model.h"
+#endif

3rdparty/include/fastdeploy/utils/axis_utils.h

@@ -0,0 +1,52 @@
+// 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
+
+namespace fastdeploy {
+
+static inline int CanonicalAxis(const int axis, const int rank) {
+  if (axis < 0) {
+    return axis + rank;
+  }
+  return axis;
+}
+
+static inline int SizeToAxis(const int axis, const std::vector<int64_t>& dims) {
+  int size = 1;
+  for (int i = 0; i < axis; i++) {
+    size *= dims[i];
+  }
+  return size;
+}
+
+static inline int SizeFromAxis(const int axis,
+                               const std::vector<int64_t>& dims) {
+  int size = 1;
+  for (int i = axis; i < dims.size(); i++) {
+    size *= dims[i];
+  }
+  return size;
+}
+
+static inline int SizeOutAxis(const int axis,
+                              const std::vector<int64_t>& dims) {
+  int size = 1;
+  for (int i = axis + 1; i < dims.size(); i++) {
+    size *= dims[i];
+  }
+  return size;
+}
+
+}  // namespace fastdeploy

3rdparty/include/fastdeploy/utils/path.h

@@ -0,0 +1,74 @@
+// 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 <string>
+#include <vector>
+#include <fstream>
+#ifdef _MSC_VER
+#define PATH_SEP "\\"
+#else
+#define PATH_SEP "/"
+#endif
+
+namespace fastdeploy {
+
+inline std::string PathJoin(const std::vector<std::string>& paths,
+                            const std::string& sep = PATH_SEP) {
+  if (paths.size() == 1) {
+    return paths[0];
+  }
+  std::string filepath = "";
+  for (const auto& path : paths) {
+    if (filepath == "") {
+      filepath += path;
+      continue;
+    }
+    if (path[0] == sep[0] || filepath.back() == sep[0]) {
+      filepath += path;
+    } else {
+      filepath += sep + path;
+    }
+  }
+  return filepath;
+}
+
+inline std::string PathJoin(const std::string& folder,
+                            const std::string& filename,
+                            const std::string& sep = PATH_SEP) {
+  return PathJoin(std::vector<std::string>{folder, filename}, sep);
+}
+
+inline std::string GetDirFromPath(const std::string& path) {
+  auto pos = path.find_last_of(PATH_SEP);
+  if (pos == std::string::npos) {
+    return "";
+  }
+  // The root path in UNIX systems
+  if (pos == 0) {
+    return "/";
+  }
+  return path.substr(0, pos);
+}
+
+inline bool CheckFileExists(const std::string& path) {
+  std::fstream fin(path, std::ios::in);
+  if (!fin) {
+    return false;
+  }
+  return true;
+}
+
+}  // namespace fastdeploy

3rdparty/include/fastdeploy/utils/perf.h

@@ -0,0 +1,49 @@
+// 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/utils/utils.h"
+#include <chrono> // NOLINT
+
+namespace fastdeploy {
+
+class FASTDEPLOY_DECL TimeCounter {
+ public:
+  void Start() { begin_ = std::chrono::system_clock::now(); }
+
+  void End() { end_ = std::chrono::system_clock::now(); }
+
+  double Duration() {
+    auto duration =
+        std::chrono::duration_cast<std::chrono::microseconds>(end_ - begin_);
+    return static_cast<double>(duration.count()) *
+           std::chrono::microseconds::period::num /
+           std::chrono::microseconds::period::den;
+  }
+
+  void PrintInfo(const std::string& prefix = "TimeCounter: ",
+                 bool print_out = true) {
+    if (!print_out) {
+      return;
+    }
+    FDLogger() << prefix << " duration = " << Duration() << "s." << std::endl;
+  }
+
+ private:
+  std::chrono::time_point<std::chrono::system_clock> begin_;
+  std::chrono::time_point<std::chrono::system_clock> end_;
+};
+
+}  // namespace fastdeploy

3rdparty/include/fastdeploy/utils/unique_ptr.h

@@ -0,0 +1,58 @@
+/* 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 <memory>
+
+namespace fastdeploy {
+namespace utils {
+// Trait to select overloads and return types for MakeUnique.
+template <typename T>
+struct MakeUniqueResult {
+  using scalar = std::unique_ptr<T>;
+};
+template <typename T>
+struct MakeUniqueResult<T[]> {
+  using array = std::unique_ptr<T[]>;
+};
+template <typename T, size_t N>
+struct MakeUniqueResult<T[N]> {
+  using invalid = void;
+};
+
+// MakeUnique<T>(...) is an early implementation of C++14 std::make_unique.
+// It is designed to be 100% compatible with std::make_unique so that the
+// eventual switchover will be a simple renaming operation.
+template <typename T, typename... Args>
+typename MakeUniqueResult<T>::scalar make_unique(Args &&... args) {  // NOLINT
+  return std::unique_ptr<T>(
+      new T(std::forward<Args>(args)...));  // NOLINT(build/c++11)
+}
+
+// Overload for array of unknown bound.
+// The allocation of arrays needs to use the array form of new,
+// and cannot take element constructor arguments.
+template <typename T>
+typename MakeUniqueResult<T>::array make_unique(size_t n) {
+  return std::unique_ptr<T>(new typename std::remove_extent<T>::type[n]());
+}
+
+// Reject arrays of known bound.
+template <typename T, typename... Args>
+typename MakeUniqueResult<T>::invalid make_unique(Args &&... /* args */) =
+    delete;  // NOLINT
+
+}  // namespace utils
+}  // namespace fastdeploy

3rdparty/include/fastdeploy/utils/utils.h

@@ -0,0 +1,218 @@
+// 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 <cstdio>
+#include <stdlib.h>
+
+#include <fstream>
+#include <iostream>
+#include <numeric>
+#include <sstream>
+#include <string>
+#include <type_traits>
+#include <vector>
+
+#ifdef __ANDROID__
+#include <android/log.h>  // NOLINT
+#endif
+
+#if defined(_WIN32)
+#ifdef FASTDEPLOY_LIB
+#define FASTDEPLOY_DECL __declspec(dllexport)
+#else
+#define FASTDEPLOY_DECL __declspec(dllimport)
+#endif  // FASTDEPLOY_LIB
+#else
+#define FASTDEPLOY_DECL __attribute__((visibility("default")))
+#endif  // _WIN32
+
+namespace fastdeploy {
+
+class FASTDEPLOY_DECL FDLogger {
+ public:
+  FDLogger() {
+    line_ = "";
+    prefix_ = "[FastDeploy]";
+    verbose_ = true;
+  }
+  explicit FDLogger(bool verbose, const std::string& prefix = "[FastDeploy]");
+
+  template <typename T> FDLogger& operator<<(const T& val) {
+    if (!verbose_) {
+      return *this;
+    }
+    std::stringstream ss;
+    ss << val;
+    line_ += ss.str();
+    return *this;
+  }
+
+  FDLogger& operator<<(std::ostream& (*os)(std::ostream&));
+
+  ~FDLogger() {
+    if (!verbose_ && line_ != "") {
+      std::cout << line_ << std::endl;
+#ifdef __ANDROID__
+      __android_log_print(ANDROID_LOG_INFO, prefix_.c_str(), "%s",
+                          line_.c_str());
+#endif
+    }
+  }
+
+ private:
+  std::string line_;
+  std::string prefix_;
+  bool verbose_ = true;
+};
+
+FASTDEPLOY_DECL bool ReadBinaryFromFile(const std::string& file,
+                                        std::string* contents);
+
+#ifndef __REL_FILE__
+#define __REL_FILE__ __FILE__
+#endif
+
+#define FDERROR                                                                \
+  FDLogger(true, "[ERROR]")                                                    \
+      << __REL_FILE__ << "(" << __LINE__ << ")::" << __FUNCTION__ << "\t"
+
+#define FDWARNING                                                              \
+  FDLogger(true, "[WARNING]")                                                  \
+      << __REL_FILE__ << "(" << __LINE__ << ")::" << __FUNCTION__ << "\t"
+
+#define FDINFO                                                                 \
+  FDLogger(true, "[INFO]") << __REL_FILE__ << "(" << __LINE__                  \
+                           << ")::" << __FUNCTION__ << "\t"
+
+#define FDASSERT(condition, format, ...)                                       \
+  if (!(condition)) {                                                          \
+    int n = std::snprintf(nullptr, 0, format, ##__VA_ARGS__);                  \
+    std::vector<char> buffer(n + 1);                                           \
+    std::snprintf(buffer.data(), n + 1, format, ##__VA_ARGS__);                \
+    FDERROR << buffer.data() << std::endl;                                     \
+    std::abort();                                                              \
+  }
+
+///////// Basic Marco ///////////
+
+#define FD_PRIVATE_CASE_TYPE_USING_HINT(NAME, enum_type, type, HINT, ...)      \
+  case enum_type: {                                                            \
+    using HINT = type;                                                         \
+    __VA_ARGS__();                                                             \
+    break;                                                                     \
+  }
+
+#define FD_PRIVATE_CASE_TYPE(NAME, enum_type, type, ...)                       \
+  FD_PRIVATE_CASE_TYPE_USING_HINT(NAME, enum_type, type, data_t, __VA_ARGS__)
+
+// Visit different data type to match the corresponding function of FDTensor
+#define FD_VISIT_ALL_TYPES(TYPE, NAME, ...)                                    \
+  [&] {                                                                        \
+    const auto& __dtype__ = TYPE;                                              \
+    switch (__dtype__) {                                                       \
+      FD_PRIVATE_CASE_TYPE(NAME, ::fastdeploy::FDDataType::UINT8, uint8_t,     \
+                           __VA_ARGS__)                                        \
+      FD_PRIVATE_CASE_TYPE(NAME, ::fastdeploy::FDDataType::BOOL, bool,         \
+                           __VA_ARGS__)                                        \
+      FD_PRIVATE_CASE_TYPE(NAME, ::fastdeploy::FDDataType::INT32, int32_t,     \
+                           __VA_ARGS__)                                        \
+      FD_PRIVATE_CASE_TYPE(NAME, ::fastdeploy::FDDataType::INT64, int64_t,     \
+                           __VA_ARGS__)                                        \
+      FD_PRIVATE_CASE_TYPE(NAME, ::fastdeploy::FDDataType::FP32, float,        \
+                           __VA_ARGS__)                                        \
+      FD_PRIVATE_CASE_TYPE(NAME, ::fastdeploy::FDDataType::FP64, double,       \
+                           __VA_ARGS__)                                        \
+    default:                                                                   \
+      FDASSERT(false,                                                          \
+               "Invalid enum data type. Expect to accept data "                \
+               "type BOOL, INT32, "                                            \
+               "INT64, FP32, FP64, but receive type %s.",                      \
+               Str(__dtype__).c_str());                                        \
+    }                                                                          \
+  }()
+
+#define FD_VISIT_INT_FLOAT_TYPES(TYPE, NAME, ...)                              \
+  [&] {                                                                        \
+    const auto& __dtype__ = TYPE;                                              \
+    switch (__dtype__) {                                                       \
+      FD_PRIVATE_CASE_TYPE(NAME, ::fastdeploy::FDDataType::INT32, int32_t,     \
+                           __VA_ARGS__)                                        \
+      FD_PRIVATE_CASE_TYPE(NAME, ::fastdeploy::FDDataType::INT64, int64_t,     \
+                           __VA_ARGS__)                                        \
+      FD_PRIVATE_CASE_TYPE(NAME, ::fastdeploy::FDDataType::FP32, float,        \
+                           __VA_ARGS__)                                        \
+      FD_PRIVATE_CASE_TYPE(NAME, ::fastdeploy::FDDataType::FP64, double,       \
+                           __VA_ARGS__)                                        \
+      FD_PRIVATE_CASE_TYPE(NAME, ::fastdeploy::FDDataType::UINT8, uint8_t,     \
+                           __VA_ARGS__)                                        \
+    default:                                                                   \
+      FDASSERT(false,                                                          \
+               "Invalid enum data type. Expect to accept data type INT32, "    \
+               "INT64, FP32, FP64, UINT8 but receive type %s.",                \
+               Str(__dtype__).c_str());                                        \
+    }                                                                          \
+  }()
+
+#define FD_VISIT_FLOAT_TYPES(TYPE, NAME, ...)                                  \
+  [&] {                                                                        \
+    const auto& __dtype__ = TYPE;                                              \
+    switch (__dtype__) {                                                       \
+      FD_PRIVATE_CASE_TYPE(NAME, ::fastdeploy::FDDataType::FP32, float,        \
+                           __VA_ARGS__)                                        \
+      FD_PRIVATE_CASE_TYPE(NAME, ::fastdeploy::FDDataType::FP64, double,       \
+                           __VA_ARGS__)                                        \
+    default:                                                                   \
+      FDASSERT(false,                                                          \
+               "Invalid enum data type. Expect to accept data type FP32, "     \
+               "FP64, but receive type %s.",                                   \
+               Str(__dtype__).c_str());                                        \
+    }                                                                          \
+  }()
+
+#define FD_VISIT_INT_TYPES(TYPE, NAME, ...)                                    \
+  [&] {                                                                        \
+    const auto& __dtype__ = TYPE;                                              \
+    switch (__dtype__) {                                                       \
+      FD_PRIVATE_CASE_TYPE(NAME, ::fastdeploy::FDDataType::INT32, int32_t,     \
+                           __VA_ARGS__)                                        \
+      FD_PRIVATE_CASE_TYPE(NAME, ::fastdeploy::FDDataType::INT64, int64_t,     \
+                           __VA_ARGS__)                                        \
+      FD_PRIVATE_CASE_TYPE(NAME, ::fastdeploy::FDDataType::UINT8, uint8_t,     \
+                           __VA_ARGS__)                                        \
+    default:                                                                   \
+      FDASSERT(false,                                                          \
+               "Invalid enum data type. Expect to accept data type INT32, "    \
+               "INT64, UINT8 but receive type %s.",                            \
+               Str(__dtype__).c_str());                                        \
+    }                                                                          \
+  }()
+
+FASTDEPLOY_DECL std::vector<int64_t>
+GetStride(const std::vector<int64_t>& dims);
+
+template <typename T, typename std::enable_if<std::is_integral<T>::value,
+                                              bool>::type = true>
+std::string Str(const std::vector<T>& shape) {
+  std::ostringstream oss;
+  oss << "[ " << shape[0];
+  for (int i = 1; i < shape.size(); ++i) {
+    oss << " ," << shape[i];
+  }
+  oss << " ]";
+  return oss.str();
+}
+
+}  // namespace fastdeploy

3rdparty/include/fastdeploy/vision.h

@@ -0,0 +1,62 @@
+// 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/core/config.h"
+#ifdef ENABLE_VISION
+#include "fastdeploy/vision/classification/contrib/resnet.h"
+#include "fastdeploy/vision/classification/contrib/yolov5cls.h"
+#include "fastdeploy/vision/classification/ppcls/model.h"
+#include "fastdeploy/vision/detection/contrib/nanodet_plus.h"
+#include "fastdeploy/vision/detection/contrib/scaledyolov4.h"
+#include "fastdeploy/vision/detection/contrib/yolor.h"
+#include "fastdeploy/vision/detection/contrib/yolov5/yolov5.h"
+#include "fastdeploy/vision/detection/contrib/yolov5lite.h"
+#include "fastdeploy/vision/detection/contrib/yolov6.h"
+#include "fastdeploy/vision/detection/contrib/yolov7/yolov7.h"
+#include "fastdeploy/vision/detection/contrib/yolov7end2end_ort.h"
+#include "fastdeploy/vision/detection/contrib/yolov7end2end_trt.h"
+#include "fastdeploy/vision/detection/contrib/yolox.h"
+#include "fastdeploy/vision/detection/ppdet/model.h"
+#include "fastdeploy/vision/facealign/contrib/face_landmark_1000.h"
+#include "fastdeploy/vision/facealign/contrib/pfld.h"
+#include "fastdeploy/vision/facealign/contrib/pipnet.h"
+#include "fastdeploy/vision/facedet/contrib/retinaface.h"
+#include "fastdeploy/vision/facedet/contrib/scrfd.h"
+#include "fastdeploy/vision/facedet/contrib/ultraface.h"
+#include "fastdeploy/vision/facedet/contrib/yolov5face.h"
+#include "fastdeploy/vision/faceid/contrib/adaface.h"
+#include "fastdeploy/vision/faceid/contrib/arcface.h"
+#include "fastdeploy/vision/faceid/contrib/cosface.h"
+#include "fastdeploy/vision/faceid/contrib/insightface_rec.h"
+#include "fastdeploy/vision/faceid/contrib/partial_fc.h"
+#include "fastdeploy/vision/faceid/contrib/vpl.h"
+#include "fastdeploy/vision/headpose/contrib/fsanet.h"
+#include "fastdeploy/vision/keypointdet/pptinypose/pptinypose.h"
+#include "fastdeploy/vision/matting/contrib/modnet.h"
+#include "fastdeploy/vision/matting/contrib/rvm.h"
+#include "fastdeploy/vision/matting/ppmatting/ppmatting.h"
+#include "fastdeploy/vision/ocr/ppocr/classifier.h"
+#include "fastdeploy/vision/ocr/ppocr/dbdetector.h"
+#include "fastdeploy/vision/ocr/ppocr/ppocr_v2.h"
+#include "fastdeploy/vision/ocr/ppocr/ppocr_v3.h"
+#include "fastdeploy/vision/ocr/ppocr/recognizer.h"
+#include "fastdeploy/vision/ocr/ppocr/utils/ocr_utils.h"
+#include "fastdeploy/vision/segmentation/ppseg/model.h"
+#include "fastdeploy/vision/sr/ppsr/model.h"
+#include "fastdeploy/vision/tracking/pptracking/model.h"
+
+#endif
+
+#include "fastdeploy/vision/visualize/visualize.h"

3rdparty/include/fastdeploy/vision/common/processors/base.h

@@ -0,0 +1,75 @@
+// 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/utils/utils.h"
+#include "fastdeploy/vision/common/processors/mat.h"
+#include "opencv2/highgui/highgui.hpp"
+#include "opencv2/imgproc/imgproc.hpp"
+#include <unordered_map>
+
+namespace fastdeploy {
+namespace vision {
+
+/*! @brief Enable using FlyCV to process image while deploy vision models.
+ * Currently, FlyCV in only available on ARM(Linux aarch64/Android), so will
+ * fallback to using OpenCV in other platform
+ */
+FASTDEPLOY_DECL void EnableFlyCV();
+
+/// Disable using FlyCV to process image while deploy vision models.
+FASTDEPLOY_DECL void DisableFlyCV();
+
+/*! @brief Set the cpu num threads of ProcLib.
+ */
+FASTDEPLOY_DECL void SetProcLibCpuNumThreads(int threads);
+
+class FASTDEPLOY_DECL Processor {
+ public:
+  // default_lib has the highest priority
+  // all the function in `processor` will force to use
+  // default_lib if this flag is set.
+  // DEFAULT means this flag is not set
+  // static ProcLib default_lib;
+
+  virtual std::string Name() = 0;
+
+  virtual bool ImplByOpenCV(Mat* mat) {
+    FDERROR << Name() << " Not Implement Yet." << std::endl;
+    return false;
+  }
+
+  virtual bool ImplByFlyCV(Mat* mat) {
+    return ImplByOpenCV(mat);
+  }
+
+  virtual bool ImplByCuda(Mat* mat) {
+    return ImplByOpenCV(mat);
+  }
+
+  virtual bool operator()(Mat* mat, ProcLib lib = ProcLib::DEFAULT);
+
+ protected:
+  FDTensor* UpdateAndGetReusedBuffer(
+      const std::vector<int64_t>& new_shape, const int& opencv_dtype,
+      const std::string& buffer_name, const Device& new_device = Device::CPU,
+      const bool& use_pinned_memory = false);
+
+ private:
+  std::unordered_map<std::string, FDTensor> reused_buffers_;
+};
+
+}  // namespace vision
+}  // namespace fastdeploy

3rdparty/include/fastdeploy/vision/common/processors/cast.h

@@ -0,0 +1,39 @@
+// 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/vision/common/processors/base.h"
+
+namespace fastdeploy {
+namespace vision {
+
+class FASTDEPLOY_DECL Cast : public Processor {
+ public:
+  explicit Cast(const std::string& dtype = "float") : dtype_(dtype) {}
+  bool ImplByOpenCV(Mat* mat);
+#ifdef ENABLE_FLYCV
+  bool ImplByFlyCV(Mat* mat);
+#endif
+  std::string Name() { return "Cast"; }
+  static bool Run(Mat* mat, const std::string& dtype,
+                  ProcLib lib = ProcLib::DEFAULT);
+
+  std::string GetDtype() const { return dtype_; }
+
+ private:
+  std::string dtype_;
+};
+}  // namespace vision
+}  // namespace fastdeploy

3rdparty/include/fastdeploy/vision/common/processors/center_crop.h

@@ -0,0 +1,40 @@
+// 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/vision/common/processors/base.h"
+
+namespace fastdeploy {
+namespace vision {
+
+class FASTDEPLOY_DECL CenterCrop : public Processor {
+ public:
+  CenterCrop(int width, int height) : height_(height), width_(width) {}
+  bool ImplByOpenCV(Mat* mat);
+#ifdef ENABLE_FLYCV
+  bool ImplByFlyCV(Mat* mat);
+#endif
+  std::string Name() { return "CenterCrop"; }
+
+  static bool Run(Mat* mat, const int& width, const int& height,
+                  ProcLib lib = ProcLib::DEFAULT);
+
+ private:
+  int height_;
+  int width_;
+};
+
+}  // namespace vision
+}  // namespace fastdeploy

3rdparty/include/fastdeploy/vision/common/processors/color_space_convert.h

@@ -0,0 +1,68 @@
+// 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/vision/common/processors/base.h"
+
+namespace fastdeploy {
+namespace vision {
+
+class FASTDEPLOY_DECL BGR2RGB : public Processor {
+ public:
+  bool ImplByOpenCV(FDMat* mat);
+#ifdef ENABLE_FLYCV
+  bool ImplByFlyCV(FDMat* mat);
+#endif
+  virtual std::string Name() { return "BGR2RGB"; }
+
+  static bool Run(FDMat* mat, ProcLib lib = ProcLib::DEFAULT);
+};
+
+class FASTDEPLOY_DECL RGB2BGR : public Processor {
+ public:
+  bool ImplByOpenCV(FDMat* mat);
+#ifdef ENABLE_FLYCV
+  bool ImplByFlyCV(FDMat* mat);
+#endif
+  std::string Name() { return "RGB2BGR"; }
+
+  static bool Run(FDMat* mat, ProcLib lib = ProcLib::DEFAULT);
+};
+
+class FASTDEPLOY_DECL BGR2GRAY : public Processor {
+ public:
+  bool ImplByOpenCV(FDMat* mat);
+#ifdef ENABLE_FLYCV
+  bool ImplByFlyCV(FDMat* mat);
+#endif
+  virtual std::string Name() { return "BGR2GRAY"; }
+
+  static bool Run(FDMat* mat, ProcLib lib = ProcLib::DEFAULT);
+};
+
+class FASTDEPLOY_DECL RGB2GRAY : public Processor {
+ public:
+  bool ImplByOpenCV(FDMat* mat);
+#ifdef ENABLE_FLYCV
+  bool ImplByFlyCV(FDMat* mat);
+#endif
+  std::string Name() { return "RGB2GRAY"; }
+
+  static bool Run(FDMat* mat, ProcLib lib = ProcLib::DEFAULT);
+};
+
+
+}  // namespace vision
+}  // namespace fastdeploy

3rdparty/include/fastdeploy/vision/common/processors/convert.h

@@ -0,0 +1,42 @@
+// 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/vision/common/processors/base.h"
+
+namespace fastdeploy {
+namespace vision {
+class FASTDEPLOY_DECL Convert : public Processor {
+ public:
+  Convert(const std::vector<float>& alpha, const std::vector<float>& beta);
+
+  bool ImplByOpenCV(Mat* mat);
+#ifdef ENABLE_FLYCV
+  bool ImplByFlyCV(Mat* mat);
+#endif
+  std::string Name() { return "Convert"; }
+
+  // Compute `result = mat * alpha + beta` directly by channel.
+  // The default behavior is the same as OpenCV's convertTo method.
+  static bool Run(Mat* mat, const std::vector<float>& alpha,
+                  const std::vector<float>& beta,
+                  ProcLib lib = ProcLib::DEFAULT);
+
+ private:
+  std::vector<float> alpha_;
+  std::vector<float> beta_;
+};
+}  // namespace vision
+}  // namespace fastdeploy

3rdparty/include/fastdeploy/vision/common/processors/convert_and_permute.h

@@ -0,0 +1,66 @@
+// 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/vision/common/processors/base.h"
+
+namespace fastdeploy {
+namespace vision {
+class FASTDEPLOY_DECL ConvertAndPermute : public Processor {
+ public:
+  ConvertAndPermute(const std::vector<float>& alpha = std::vector<float>(),
+                    const std::vector<float>& beta = std::vector<float>(),
+                    bool swap_rb = false);
+  bool ImplByOpenCV(FDMat* mat);
+#ifdef ENABLE_FLYCV
+  bool ImplByFlyCV(FDMat* mat);
+#endif
+  std::string Name() { return "ConvertAndPermute"; }
+
+  static bool Run(FDMat* mat, const std::vector<float>& alpha,
+                  const std::vector<float>& beta, bool swap_rb = false,
+                  ProcLib lib = ProcLib::DEFAULT);
+
+  std::vector<float> GetAlpha() const { return alpha_; }
+
+  void SetAlpha(const std::vector<float>& alpha) {
+    alpha_.clear();
+    std::vector<float>().swap(alpha_);
+    alpha_.assign(alpha.begin(), alpha.end());
+  }
+
+  std::vector<float> GetBeta() const { return beta_; }
+
+  void SetBeta(const std::vector<float>& beta) {
+    beta_.clear();
+    std::vector<float>().swap(beta_);
+    beta_.assign(beta.begin(), beta.end());
+  }
+
+  bool GetSwapRB() {
+    return swap_rb_;
+  }
+
+  void SetSwapRB(bool swap_rb) {
+    swap_rb_ = swap_rb;
+  }
+
+ private:
+  std::vector<float> alpha_;
+  std::vector<float> beta_;
+  bool swap_rb_;
+};
+}  // namespace vision
+}  // namespace fastdeploy

3rdparty/include/fastdeploy/vision/common/processors/crop.h

@@ -0,0 +1,49 @@
+// 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/vision/common/processors/base.h"
+
+namespace fastdeploy {
+namespace vision {
+
+class FASTDEPLOY_DECL Crop : public Processor {
+ public:
+  Crop(int offset_w, int offset_h, int width, int height) {
+    offset_w_ = offset_w;
+    offset_h_ = offset_h;
+    width_ = width;
+    height_ = height;
+  }
+
+  bool ImplByOpenCV(Mat* mat);
+
+#ifdef ENABLE_FLYCV
+  bool ImplByFlyCV(Mat* mat);
+#endif
+  std::string Name() { return "Crop"; }
+
+  static bool Run(Mat* mat, int offset_w, int offset_h, int width, int height,
+                  ProcLib lib = ProcLib::DEFAULT);
+
+ private:
+  int offset_w_;
+  int offset_h_;
+  int height_;
+  int width_;
+};
+
+}  // namespace vision
+}  // namespace fastdeploy

3rdparty/include/fastdeploy/vision/common/processors/hwc2chw.h

@@ -0,0 +1,33 @@
+// 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/vision/common/processors/base.h"
+
+namespace fastdeploy {
+namespace vision {
+
+class FASTDEPLOY_DECL HWC2CHW : public Processor {
+ public:
+  bool ImplByOpenCV(Mat* mat);
+#ifdef ENABLE_FLYCV
+  bool ImplByFlyCV(Mat* mat);
+#endif
+  std::string Name() { return "HWC2CHW"; }
+
+  static bool Run(Mat* mat, ProcLib lib = ProcLib::DEFAULT);
+};
+}  // namespace vision
+}  // namespace fastdeploy