6.7.0 - Alpha12 - 剥离 Paddle OCR (PP-OCRv3) 功能; 定义 Paddle OCR 功能的 AIDL 接口约定
This commit is contained in:
SuperMonster003
1
.gitignore
vendored
1
.gitignore
vendored
@@ -29,6 +29,7 @@ sync.ffs_db
|
||||
/build/
|
||||
/libs/**/build/
|
||||
/modules/**/build/
|
||||
/plugin-api/**/build/
|
||||
/captures/
|
||||
/release/
|
||||
/releases/
|
||||
|
||||
@@ -166,9 +166,6 @@ dependencies /* Unclassified */ {
|
||||
// OpenCV
|
||||
implementation(project(":libs:org-opencv-4_8_0"))
|
||||
|
||||
// PaddleOCR
|
||||
implementation(project(":libs:paddleocr"))
|
||||
|
||||
// RapidOCR
|
||||
implementation(project(":libs:rapidocr"))
|
||||
|
||||
@@ -252,6 +249,9 @@ dependencies /* Unclassified */ {
|
||||
|
||||
// ICU4J
|
||||
implementation(libs.icu4j)
|
||||
|
||||
// Plugin API: Paddle OCR
|
||||
implementation(project(":plugin-api:paddle-ocr"))
|
||||
}
|
||||
|
||||
dependencies /* MIME */ {
|
||||
|
||||
@@ -126,6 +126,10 @@
|
||||
android:protectionLevel="signature"
|
||||
tools:ignore="ProtectedPermissions" />
|
||||
|
||||
<uses-permission
|
||||
android:name="org.autojs.permission.PLUGIN"
|
||||
android:protectionLevel="normal" />
|
||||
|
||||
<!-- 非 AutoJs6 运行必需, 不会主动申请, 脚本可自行申请 -->
|
||||
|
||||
<uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION" />
|
||||
|
||||
@@ -0,0 +1,217 @@
|
||||
package org.autojs.autojs.core.plugin.ocr
|
||||
|
||||
import android.content.ComponentName
|
||||
import android.content.Context
|
||||
import android.content.Intent
|
||||
import android.content.ServiceConnection
|
||||
import android.content.pm.PackageManager
|
||||
import android.content.pm.ServiceInfo
|
||||
import android.graphics.Bitmap
|
||||
import android.graphics.Bitmap.CompressFormat
|
||||
import android.os.Build
|
||||
import android.os.Handler
|
||||
import android.os.IBinder
|
||||
import android.os.ParcelFileDescriptor
|
||||
import android.os.SystemClock.uptimeMillis
|
||||
import android.util.Log
|
||||
import kotlinx.coroutines.CoroutineScope
|
||||
import kotlinx.coroutines.Dispatchers
|
||||
import kotlinx.coroutines.Job
|
||||
import kotlinx.coroutines.launch
|
||||
import kotlinx.coroutines.suspendCancellableCoroutine
|
||||
import kotlinx.coroutines.withContext
|
||||
import org.autojs.plugin.paddle.ocr.IOcrPlugin
|
||||
import org.autojs.plugin.paddle.ocr.OcrOptions
|
||||
import org.autojs.plugin.paddle.ocr.OcrResult
|
||||
import org.autojs.plugin.paddle.ocr.PluginInfo
|
||||
import java.io.File
|
||||
import java.io.FileOutputStream
|
||||
|
||||
object PaddleOcrPluginHost {
|
||||
|
||||
private const val TAG = "PaddleOcrPluginHost"
|
||||
|
||||
const val ACTION_OCR = "org.autojs.plugin.PADDLE_OCR"
|
||||
|
||||
private const val DEFAULT_BIND_TIMEOUT_MS = 60_000L
|
||||
private const val DEFAULT_CALL_TIMEOUT_MS = 60_000L
|
||||
|
||||
data class Discovered(
|
||||
val serviceInfo: ServiceInfo,
|
||||
val pluginInfo: PluginInfo?,
|
||||
)
|
||||
|
||||
suspend fun discover(context: Context): List<Discovered> {
|
||||
val pm = context.packageManager
|
||||
val resolveList = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
|
||||
pm.queryIntentServices(Intent(ACTION_OCR), PackageManager.ResolveInfoFlags.of(0))
|
||||
} else {
|
||||
pm.queryIntentServices(Intent(ACTION_OCR), 0)
|
||||
}
|
||||
val services = resolveList.mapNotNull { it.serviceInfo }
|
||||
Log.i(TAG, "discover: services=${services.size}")
|
||||
return services.map { svc ->
|
||||
Log.i(TAG, "discover: ${svc.packageName}/${svc.name}")
|
||||
val info = runCatching { withService(context, svc, DEFAULT_BIND_TIMEOUT_MS) { it.getInfo() } }
|
||||
.onFailure { e -> Log.w(TAG, "getInfo failed: ${e.message}") }
|
||||
.getOrNull()
|
||||
Discovered(svc, info)
|
||||
}
|
||||
}
|
||||
|
||||
suspend fun recognizeText(
|
||||
context: Context,
|
||||
target: Discovered,
|
||||
bitmap: Bitmap,
|
||||
options: OcrOptions = OcrOptions(),
|
||||
callTimeoutMs: Long = DEFAULT_CALL_TIMEOUT_MS,
|
||||
): List<String> {
|
||||
val start = uptimeMillis()
|
||||
return createTempPfd(context, bitmap).use { pfd ->
|
||||
withService(context, target.serviceInfo, DEFAULT_BIND_TIMEOUT_MS) { proxy ->
|
||||
val remain = callTimeoutMs - (uptimeMillis() - start)
|
||||
if (remain <= 0) error("AIDL call timeout in ${callTimeoutMs / 1000} seconds")
|
||||
val lines = proxy.recognizeText(pfd, options)
|
||||
Log.i(TAG, "recognizeTextAidl: got ${lines.size} lines")
|
||||
lines
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
suspend fun detect(
|
||||
context: Context,
|
||||
target: Discovered,
|
||||
bitmap: Bitmap,
|
||||
options: OcrOptions = OcrOptions(),
|
||||
callTimeoutMs: Long = DEFAULT_CALL_TIMEOUT_MS,
|
||||
): List<OcrResult> {
|
||||
val start = uptimeMillis()
|
||||
return createTempPfd(context, bitmap).use { pfd ->
|
||||
withService(context, target.serviceInfo, DEFAULT_BIND_TIMEOUT_MS) { proxy ->
|
||||
val remain = callTimeoutMs - (uptimeMillis() - start)
|
||||
if (remain <= 0) error("AIDL call timeout")
|
||||
val results = proxy.detect(pfd, options)
|
||||
Log.i(TAG, "detectAidl: got ${results.size} items")
|
||||
results
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
suspend fun select(
|
||||
context: Context,
|
||||
// e.g. "paddle-ocr-v5"
|
||||
engineId: String? = null,
|
||||
// e.g. "paddle-ocr"
|
||||
engine: String? = null,
|
||||
// e.g. "v5"
|
||||
variant: String? = null,
|
||||
): Discovered? {
|
||||
val list = discover(context).filter { it.pluginInfo != null }
|
||||
if (list.isEmpty()) return null
|
||||
if (engineId != null) {
|
||||
list.firstOrNull { d -> d.pluginInfo?.id == engineId }?.let { return it }
|
||||
}
|
||||
if (engine != null && variant != null) {
|
||||
list.firstOrNull { d -> d.pluginInfo?.engine == engine && d.pluginInfo.variant == variant }?.let { return it }
|
||||
}
|
||||
if (engine != null) {
|
||||
list.firstOrNull { d -> d.pluginInfo?.engine == engine }?.let { return it }
|
||||
}
|
||||
return list.first()
|
||||
}
|
||||
|
||||
// Convert temporary file to read-only FD.
|
||||
// zh-CN: 临时文件转换为只读 FD.
|
||||
private fun createTempPfd(context: Context, bmp: Bitmap): ParcelFileDescriptor {
|
||||
val dir = File(context.cacheDir, "ocr_ipc").apply { if (!exists()) mkdirs() }
|
||||
val f = File.createTempFile("img_", ".bin", dir)
|
||||
FileOutputStream(f).use { fos ->
|
||||
val format = when {
|
||||
bmp.hasAlpha() -> CompressFormat.PNG
|
||||
else -> CompressFormat.JPEG
|
||||
}
|
||||
require(bmp.compress(format, 100, fos)) { "Failed to encode bitmap" }
|
||||
}
|
||||
return ParcelFileDescriptor.open(f, ParcelFileDescriptor.MODE_READ_ONLY)
|
||||
}
|
||||
|
||||
private suspend fun <T> withService(
|
||||
context: Context,
|
||||
serviceInfo: ServiceInfo,
|
||||
bindTimeoutMs: Long = DEFAULT_BIND_TIMEOUT_MS,
|
||||
block: suspend (IOcrPlugin) -> T,
|
||||
): T = suspendCancellableCoroutine { cont ->
|
||||
val cn = ComponentName(serviceInfo.packageName, serviceInfo.name)
|
||||
val intent = Intent().setComponent(cn)
|
||||
val appCtx = context.applicationContext
|
||||
|
||||
var resolved = false
|
||||
var jobRef: Job? = null
|
||||
|
||||
val conn = object : ServiceConnection {
|
||||
override fun onServiceConnected(name: ComponentName, binder: IBinder) {
|
||||
Log.i(TAG, "onServiceConnected: $name")
|
||||
val proxy = IOcrPlugin.Stub.asInterface(binder)
|
||||
val self = this
|
||||
|
||||
jobRef = CoroutineScope(cont.context + Dispatchers.IO).launch {
|
||||
val result = runCatching { block(proxy) }
|
||||
try {
|
||||
resolved = true
|
||||
if (!cont.isCompleted) cont.resumeWith(result)
|
||||
Log.i(TAG, "resume continuation: success=${result.isSuccess}")
|
||||
} finally {
|
||||
withContext(Dispatchers.Main) {
|
||||
runCatching { appCtx.unbindService(self) }
|
||||
Log.i(TAG, "unbindService: $name")
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
override fun onServiceDisconnected(name: ComponentName) {
|
||||
Log.w(TAG, "onServiceDisconnected: $name")
|
||||
}
|
||||
}
|
||||
|
||||
val ok = try {
|
||||
Log.i(TAG, "bindService: $cn")
|
||||
appCtx.bindService(intent, conn, Context.BIND_AUTO_CREATE)
|
||||
} catch (se: SecurityException) {
|
||||
Log.e(TAG, "bindService SecurityException: $cn | ${se.message}")
|
||||
cont.resumeWith(
|
||||
Result.failure(
|
||||
IllegalStateException(
|
||||
"bindService SecurityException: $cn. Please make sure the plugin declares <permission android:name=\"org.autojs.permission.PLUGIN\"/> and the Service uses this permission.", se
|
||||
)
|
||||
)
|
||||
)
|
||||
return@suspendCancellableCoroutine
|
||||
}
|
||||
if (!ok) {
|
||||
Log.e(TAG, "bindService failed: $cn")
|
||||
cont.resumeWith(Result.failure(IllegalStateException("bindService failed: $cn")))
|
||||
return@suspendCancellableCoroutine
|
||||
}
|
||||
|
||||
val cancel = Runnable {
|
||||
if (!resolved && !cont.isCompleted) {
|
||||
Log.e(TAG, "bindService timeout: $cn")
|
||||
cont.resumeWith(Result.failure(TimeoutException("bindService timeout: $cn")))
|
||||
runCatching { appCtx.unbindService(conn) }
|
||||
}
|
||||
}
|
||||
val h = Handler(appCtx.mainLooper)
|
||||
h.postDelayed(cancel, bindTimeoutMs)
|
||||
|
||||
cont.invokeOnCancellation {
|
||||
Log.w(TAG, "continuation cancelled: $cn")
|
||||
h.removeCallbacks(cancel)
|
||||
jobRef?.cancel()
|
||||
runCatching { appCtx.unbindService(conn) }
|
||||
}
|
||||
}
|
||||
|
||||
private class TimeoutException(msg: String) : RuntimeException(msg)
|
||||
|
||||
}
|
||||
@@ -3,6 +3,9 @@ package org.autojs.autojs.runtime
|
||||
import android.content.Context
|
||||
import android.os.Build
|
||||
import android.util.Log
|
||||
import kotlinx.coroutines.CoroutineScope
|
||||
import kotlinx.coroutines.Dispatchers
|
||||
import kotlinx.coroutines.SupervisorJob
|
||||
import org.autojs.autojs.AutoJs
|
||||
import org.autojs.autojs.annotation.ScriptInterface
|
||||
import org.autojs.autojs.annotation.ScriptVariable
|
||||
@@ -128,6 +131,7 @@ import java.io.PrintWriter
|
||||
import java.io.StringWriter
|
||||
import java.lang.ref.WeakReference
|
||||
import java.util.concurrent.ConcurrentHashMap
|
||||
import kotlin.coroutines.cancellation.CancellationException
|
||||
import org.autojs.autojs.core.accessibility.UiSelector as CoreUiSelector
|
||||
import org.autojs.autojs.core.crypto.Crypto as CoreCrypto
|
||||
import org.autojs.autojs.core.image.Colors as CoreColors
|
||||
@@ -149,7 +153,6 @@ import org.autojs.autojs.runtime.api.Mime as ApiMime
|
||||
import org.autojs.autojs.runtime.api.Notice as ApiNotice
|
||||
import org.autojs.autojs.runtime.api.Ocr as ApiOcr
|
||||
import org.autojs.autojs.runtime.api.OcrMLKit as ApiOcrMLKit
|
||||
import org.autojs.autojs.runtime.api.OcrPaddle as ApiOcrPaddle
|
||||
import org.autojs.autojs.runtime.api.OcrRapid as ApiOcrRapid
|
||||
import org.autojs.autojs.runtime.api.Plugins as ApiPlugins
|
||||
import org.autojs.autojs.runtime.api.Recorder as ApiRecorder
|
||||
@@ -180,6 +183,10 @@ import org.autojs.autojs.runtime.api.augment.util.VersionCodes as UtilVersionCod
|
||||
@Suppress("unused", "PropertyName", "PrivatePropertyName")
|
||||
class ScriptRuntime private constructor(builder: Builder) {
|
||||
|
||||
private val mJob = SupervisorJob()
|
||||
val coroutineScope = CoroutineScope(Dispatchers.Default + mJob)
|
||||
val coroutineContext = coroutineScope.coroutineContext
|
||||
|
||||
private var mUiHandlerAppContext: Context
|
||||
private var mRootShell: AbstractShell? = null
|
||||
private val mProperties = ConcurrentHashMap<String, Any>()
|
||||
@@ -335,10 +342,6 @@ class ScriptRuntime private constructor(builder: Builder) {
|
||||
@ScriptVariable
|
||||
val ocrMLKit: ApiOcrMLKit
|
||||
|
||||
@JvmField
|
||||
@ScriptVariable
|
||||
val ocrPaddle: ApiOcrPaddle
|
||||
|
||||
@JvmField
|
||||
@ScriptVariable
|
||||
val ocrRapid: ApiOcrRapid
|
||||
@@ -474,7 +477,6 @@ class ScriptRuntime private constructor(builder: Builder) {
|
||||
|
||||
http = ApiHttp()
|
||||
ocrMLKit = ApiOcrMLKit()
|
||||
ocrPaddle = ApiOcrPaddle()
|
||||
ocrRapid = ApiOcrRapid()
|
||||
barcode = ApiBarcode()
|
||||
|
||||
@@ -579,6 +581,10 @@ class ScriptRuntime private constructor(builder: Builder) {
|
||||
@Deprecated("ScriptRuntime#stop is deprecated", ReplaceWith("exit()"))
|
||||
fun stop() = exit()
|
||||
|
||||
fun cancelScriptJobs() {
|
||||
mJob.cancel(CancellationException(mUiHandlerAppContext.getString(R.string.error_script_is_on_exiting)))
|
||||
}
|
||||
|
||||
fun onExit() {
|
||||
Log.d(TAG, "on exit")
|
||||
this.isExiting = true
|
||||
@@ -620,7 +626,6 @@ class ScriptRuntime private constructor(builder: Builder) {
|
||||
ignoresException({ images.releaseScreenCapturer() })
|
||||
ignoresException({ images.stopScreenCapturerForegroundService() })
|
||||
ignoresException({ ocrMLKit.release() })
|
||||
ignoresException({ ocrPaddle.release() })
|
||||
ignoresException({ sensors.unregisterAll() })
|
||||
ignoresException({ timers.recycle() })
|
||||
ignoresException({ ui.recycle() })
|
||||
|
||||
@@ -1,87 +0,0 @@
|
||||
package org.autojs.autojs.runtime.api;
|
||||
|
||||
import android.graphics.Bitmap;
|
||||
import android.os.Looper;
|
||||
import android.util.Log;
|
||||
|
||||
import com.baidu.paddle.lite.ocr.OcrResult;
|
||||
import com.baidu.paddle.lite.ocr.Predictor;
|
||||
|
||||
import org.autojs.autojs.app.GlobalAppContext;
|
||||
import org.autojs.autojs.concurrent.VolatileDispose;
|
||||
import org.autojs.autojs.core.image.ImageWrapper;
|
||||
|
||||
import java.util.Arrays;
|
||||
import java.util.Collections;
|
||||
import java.util.List;
|
||||
|
||||
/**
|
||||
* @author TonyJiangWJ
|
||||
* @since 2023-08-06
|
||||
*/
|
||||
public class OcrPaddle {
|
||||
|
||||
private final Predictor mPredictor = new Predictor();
|
||||
|
||||
public synchronized boolean init(boolean useSlim) {
|
||||
if (!mPredictor.isLoaded || useSlim != mPredictor.isUseSlim()) {
|
||||
if (Looper.getMainLooper() == Looper.myLooper()) {
|
||||
VolatileDispose<Boolean> result = new VolatileDispose<>();
|
||||
new Thread(() -> result.setAndNotify(mPredictor.init(GlobalAppContext.get(), useSlim))).start();
|
||||
return Boolean.TRUE.equals(result.blockedGet(60_000));
|
||||
} else {
|
||||
return mPredictor.init(GlobalAppContext.get(), useSlim);
|
||||
}
|
||||
}
|
||||
return mPredictor.isLoaded;
|
||||
}
|
||||
|
||||
public void release() {
|
||||
mPredictor.releaseModel();
|
||||
}
|
||||
|
||||
public List<OcrResult> detect(ImageWrapper image, int cpuThreadNum, boolean useSlim) {
|
||||
if (image == null) {
|
||||
return Collections.emptyList();
|
||||
}
|
||||
Bitmap bitmap = image.getBitmap();
|
||||
if (bitmap.isRecycled()) {
|
||||
return Collections.emptyList();
|
||||
}
|
||||
if (mPredictor.cpuThreadNum != cpuThreadNum) {
|
||||
mPredictor.releaseModel();
|
||||
mPredictor.cpuThreadNum = cpuThreadNum;
|
||||
}
|
||||
init(useSlim);
|
||||
return mPredictor.runOcr(bitmap);
|
||||
}
|
||||
|
||||
public List<OcrResult> detect(ImageWrapper image, int cpuThreadNum) {
|
||||
return detect(image, cpuThreadNum, true);
|
||||
}
|
||||
|
||||
public List<OcrResult> detect(ImageWrapper image) {
|
||||
return detect(image, 4, true);
|
||||
}
|
||||
|
||||
public List<String> recognizeText(ImageWrapper image, int cpuThreadNum, boolean useSlim) {
|
||||
List<OcrResult> words_result = detect(image, cpuThreadNum, useSlim);
|
||||
Collections.sort(words_result);
|
||||
List<String> outputResult = Arrays.asList(new String[words_result.size()]);
|
||||
for (int i = 0; i < words_result.size(); i++) {
|
||||
outputResult.set(i, words_result.get(i).getLabel());
|
||||
// show LOG in Logcat panel
|
||||
Log.i("outputResult", outputResult.get(i));
|
||||
}
|
||||
return outputResult;
|
||||
}
|
||||
|
||||
public List<String> recognizeText(ImageWrapper image, int cpuThreadNum) {
|
||||
return recognizeText(image, cpuThreadNum, true);
|
||||
}
|
||||
|
||||
public List<String> recognizeText(ImageWrapper image) {
|
||||
return recognizeText(image, 4, true);
|
||||
}
|
||||
|
||||
}
|
||||
@@ -4,7 +4,7 @@ import kotlinx.coroutines.runBlocking
|
||||
import org.autojs.autojs.annotation.RhinoRuntimeFunctionInterface
|
||||
import org.autojs.autojs.apkbuilder.ApkBuilder
|
||||
import org.autojs.autojs.core.image.ImageWrapper
|
||||
import org.autojs.autojs.core.plugin.ocr.OcrPluginHost
|
||||
import org.autojs.autojs.core.plugin.ocr.PaddleOcrPluginHost
|
||||
import org.autojs.autojs.extension.ScriptableObjectExtensions.inquire
|
||||
import org.autojs.autojs.runtime.ScriptRuntime
|
||||
import org.autojs.autojs.runtime.api.OcrResult
|
||||
@@ -14,6 +14,7 @@ import org.autojs.autojs.runtime.api.augment.ocr.Ocr.Companion.OcrMode
|
||||
import org.autojs.autojs.runtime.exception.WrappedIllegalArgumentException
|
||||
import org.autojs.autojs.util.RhinoUtils.coerceBoolean
|
||||
import org.autojs.autojs.util.RhinoUtils.coerceIntNumber
|
||||
import org.autojs.plugin.paddle.ocr.OcrOptions
|
||||
import org.mozilla.javascript.NativeArray
|
||||
import org.mozilla.javascript.NativeObject
|
||||
|
||||
@@ -48,32 +49,35 @@ class OcrPaddle(private val scriptRuntime: ScriptRuntime) : Augmentable(scriptRu
|
||||
}
|
||||
|
||||
fun recognizeTextImpl(scriptRuntime: ScriptRuntime, image: ImageWrapper, options: NativeObject): List<String> {
|
||||
return performOcr(scriptRuntime, image, options).map {
|
||||
it.text
|
||||
}
|
||||
}
|
||||
|
||||
fun detectImpl(scriptRuntime: ScriptRuntime, image: ImageWrapper, options: NativeObject): List<OcrResult> {
|
||||
return performOcr(scriptRuntime, image, options).map {
|
||||
OcrResult(it.text, it.confidence, it.bounds)
|
||||
}
|
||||
}
|
||||
|
||||
private fun performOcr(scriptRuntime: ScriptRuntime, image: ImageWrapper, options: NativeObject): List<org.autojs.plugin.ocr.OcrResult> {
|
||||
ApkBuilder.Libs.PADDLE_OCR.ensureLibFiles(OcrMode.PADDLE.value)
|
||||
val (cpuThreadNum, useSlim, useOpenCL) = getOcrOptions(options)
|
||||
val ocrOptions = org.autojs.plugin.ocr.OcrOptions().apply {
|
||||
this.threads = cpuThreadNum
|
||||
val ocrOptions = OcrOptions().apply {
|
||||
this.cpuThreadNum = cpuThreadNum
|
||||
this.useSlim = useSlim
|
||||
this.useOpenCL = useOpenCL
|
||||
}
|
||||
return runBlocking(scriptRuntime.coroutineContext) {
|
||||
val target = OcrPluginHost.select(globalContext)
|
||||
val target = PaddleOcrPluginHost.select(globalContext)
|
||||
?: throw WrappedIllegalArgumentException("No Paddle OCR plugin matched")
|
||||
OcrPluginHost.detect(globalContext, target, image.bitmap, ocrOptions)
|
||||
PaddleOcrPluginHost.recognizeText(globalContext, target, image.bitmap, ocrOptions)
|
||||
}
|
||||
}
|
||||
|
||||
fun detectImpl(scriptRuntime: ScriptRuntime, image: ImageWrapper, options: NativeObject): List<OcrResult> {
|
||||
ApkBuilder.Libs.PADDLE_OCR.ensureLibFiles(OcrMode.PADDLE.value)
|
||||
val (cpuThreadNum, useSlim, useOpenCL) = getOcrOptions(options)
|
||||
val ocrOptions = OcrOptions().apply {
|
||||
this.cpuThreadNum = cpuThreadNum
|
||||
this.useSlim = useSlim
|
||||
this.useOpenCL = useOpenCL
|
||||
}
|
||||
return runBlocking(scriptRuntime.coroutineContext) {
|
||||
val target = PaddleOcrPluginHost.select(globalContext)
|
||||
?: throw WrappedIllegalArgumentException("No Paddle OCR plugin matched")
|
||||
PaddleOcrPluginHost.detect(globalContext, target, image.bitmap, ocrOptions)
|
||||
}.map { OcrResult(it.text, it.confidence, it.bounds) }
|
||||
}
|
||||
|
||||
private fun getOcrOptions(options: NativeObject): OcrOptions {
|
||||
val cpuThreadNum = options.inquire("cpuThreadNum", ::coerceIntNumber, DEFAULT_CPU_THREAD_NUM)
|
||||
val useSlim = options.inquire("useSlim", ::coerceBoolean, DEFAULT_USE_SLIM)
|
||||
|
||||
9
libs/paddleocr/.gitignore
vendored
9
libs/paddleocr/.gitignore
vendored
@@ -1,9 +0,0 @@
|
||||
/build/
|
||||
/.cxx/
|
||||
/.idea/
|
||||
/cache/
|
||||
|
||||
/src/sdk/native/
|
||||
|
||||
*.skip
|
||||
**/temp-extracted/
|
||||
@@ -1,611 +0,0 @@
|
||||
// Copyright (c) 2019 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.
|
||||
|
||||
/*
|
||||
* This file defines PaddlePredictor, the api for lite. It supports multiple
|
||||
* hardware including ARM, X86, OpenCL, CUDA and so on.
|
||||
*/
|
||||
|
||||
#ifndef PADDLE_LITE_API_H_ // NOLINT
|
||||
#define PADDLE_LITE_API_H_
|
||||
#include <functional>
|
||||
#include <map>
|
||||
#include <memory>
|
||||
#include <string>
|
||||
#include <utility>
|
||||
#include <vector>
|
||||
#include "paddle_place.h" // NOLINT
|
||||
|
||||
namespace paddle {
|
||||
namespace lite_api {
|
||||
|
||||
using shape_t = std::vector<int64_t>;
|
||||
using lod_t = std::vector<std::vector<uint64_t>>;
|
||||
|
||||
enum class LiteModelType { kProtobuf = 0, kNaiveBuffer, UNK };
|
||||
// Methods for allocating L3Cache on Arm platform
|
||||
enum class L3CacheSetMethod {
|
||||
kDeviceL3Cache = 0, // Use the system L3 Cache size, best performance.
|
||||
kDeviceL2Cache = 1, // Use the system L2 Cache size, trade off performance
|
||||
// with less memory consumption.
|
||||
kAbsolute = 2, // Use the external setting.
|
||||
// kAutoGrow = 3, // Not supported yet, least memory consumption.
|
||||
};
|
||||
|
||||
// return true if current device supports OpenCL model
|
||||
LITE_API bool IsOpenCLBackendValid(bool check_fp16_valid = false);
|
||||
|
||||
// return current opencl device type,
|
||||
// if opencl not enabled or IsOpenCLBackendValid return false, it will return -1
|
||||
// UNKNOWN:0, QUALCOMM_ADRENO:1, ARM_MALI:2, IMAGINATION_POWERVR:3, OTHERS:4,
|
||||
LITE_API int GetOpenCLDeviceType();
|
||||
|
||||
struct LITE_API Tensor {
|
||||
explicit Tensor(void* raw);
|
||||
explicit Tensor(const void* raw);
|
||||
|
||||
void Resize(const shape_t& shape);
|
||||
|
||||
/// Readonly data.
|
||||
template <typename T>
|
||||
const T* data() const;
|
||||
|
||||
template <typename T>
|
||||
T* mutable_data(TargetType type = TargetType::kHost) const;
|
||||
|
||||
void* mutable_metal_data(void* ptr) const;
|
||||
|
||||
// Share external memory. Note: ensure that the data pointer is in a valid
|
||||
// state
|
||||
// during the prediction process.
|
||||
void ShareExternalMemory(void* data, size_t memory_size, TargetType target);
|
||||
|
||||
template <typename T, TargetType type = TargetType::kHost>
|
||||
void CopyFromCpu(const T* data);
|
||||
|
||||
template <typename T>
|
||||
void CopyToCpu(T* data) const;
|
||||
/// Shape of the tensor.
|
||||
shape_t shape() const;
|
||||
TargetType target() const;
|
||||
PrecisionType precision() const;
|
||||
void SetPrecision(PrecisionType precision);
|
||||
|
||||
// LoD of the tensor
|
||||
lod_t lod() const;
|
||||
|
||||
// Set LoD of the tensor
|
||||
void SetLoD(const lod_t& lod);
|
||||
bool IsInitialized() const;
|
||||
|
||||
private:
|
||||
void* raw_tensor_;
|
||||
};
|
||||
|
||||
/// The PaddlePredictor defines the basic interfaces for different kinds of
|
||||
/// predictors.
|
||||
class LITE_API PaddlePredictor {
|
||||
public:
|
||||
PaddlePredictor() = default;
|
||||
|
||||
/// Get i-th input.
|
||||
virtual std::unique_ptr<Tensor> GetInput(int i) = 0;
|
||||
|
||||
/// Get i-th output.
|
||||
virtual std::unique_ptr<const Tensor> GetOutput(int i) const = 0;
|
||||
|
||||
virtual void Run() = 0;
|
||||
virtual std::shared_ptr<PaddlePredictor> Clone() = 0;
|
||||
virtual std::shared_ptr<PaddlePredictor> Clone(
|
||||
const std::vector<std::string>& var_names) = 0;
|
||||
|
||||
virtual std::string GetVersion() const = 0;
|
||||
|
||||
// Get input names
|
||||
virtual std::vector<std::string> GetInputNames() = 0;
|
||||
// Get output names
|
||||
virtual std::vector<std::string> GetOutputNames() = 0;
|
||||
// Get output names
|
||||
virtual std::vector<std::string> GetParamNames();
|
||||
|
||||
/// Release all tmp tensor to compress the size of the memory pool.
|
||||
virtual bool TryShrinkMemory() = 0;
|
||||
|
||||
// Get Input by name
|
||||
virtual std::unique_ptr<Tensor> GetInputByName(const std::string& name) = 0;
|
||||
|
||||
/// Get a readonly tensor, return null if no one called `name` exists.
|
||||
virtual std::unique_ptr<const Tensor> GetTensor(
|
||||
const std::string& name) const = 0;
|
||||
/// Get a mutable tensor, return null if on one called `name` exists
|
||||
/// internal infereces API, not recommanded.
|
||||
virtual std::unique_ptr<Tensor> GetMutableTensor(const std::string& name);
|
||||
|
||||
/// Persist the optimized model to disk. This API is only supported by
|
||||
/// CxxConfig, and the persisted model can be reused for MobileConfig.
|
||||
virtual void SaveOptimizedModel(
|
||||
const std::string& model_dir,
|
||||
LiteModelType model_type = LiteModelType::kProtobuf,
|
||||
bool record_info = false);
|
||||
|
||||
virtual ~PaddlePredictor() = default;
|
||||
|
||||
protected:
|
||||
int threads_{1};
|
||||
lite_api::PowerMode mode_{lite_api::LITE_POWER_NO_BIND};
|
||||
};
|
||||
|
||||
/// Base class for all the configs.
|
||||
class LITE_API ConfigBase {
|
||||
std::string model_dir_;
|
||||
int threads_{1};
|
||||
PowerMode mode_{LITE_POWER_NO_BIND};
|
||||
// gpu opencl
|
||||
CLTuneMode opencl_tune_mode_{CL_TUNE_NONE};
|
||||
std::string opencl_bin_path_{""};
|
||||
std::string opencl_bin_name_{""};
|
||||
CLPrecisionType opencl_precision_{CL_PRECISION_AUTO};
|
||||
// Where to cache the npu/xpu/rknpu/apu offline model to the binary files
|
||||
std::string subgraph_model_cache_dir_{""};
|
||||
// Set the cached npu/xpu/rknpu/apu offline model from the buffers
|
||||
std::map<std::string, std::pair<std::vector<char>, std::vector<char>>>
|
||||
subgraph_model_cache_buffers_{};
|
||||
// The selected NNAdapter devices to build and run the model.
|
||||
std::vector<std::string> nnadapter_device_names_{};
|
||||
// The NNAdapter context properties for device configuration, model
|
||||
// compilation and execution
|
||||
std::string nnadapter_context_properties_{};
|
||||
int (*nnadapter_context_callback_)(int event_id,
|
||||
void* user_data){nullptr}; // NOLINT
|
||||
// The directory to find and store the compiled NNAdapter models.
|
||||
std::string nnadapter_model_cache_dir_{""};
|
||||
// Dynamic shapes of the NNAdapter model
|
||||
std::map<std::string, std::vector<std::vector<int64_t>>>
|
||||
nnadapter_dynamic_shape_info_;
|
||||
// The buffers for loading the compiled NNAdapter models from memory.
|
||||
std::map<std::string, std::vector<char>> nnadapter_model_cache_buffers_{};
|
||||
int device_id_{0};
|
||||
int x86_math_num_threads_ = 1;
|
||||
|
||||
std::string metal_path_;
|
||||
bool metal_use_mps_{false};
|
||||
bool metal_use_aggressive_{false};
|
||||
void* metal_device_{nullptr};
|
||||
bool metal_use_memory_reuse_{false};
|
||||
|
||||
std::vector<std::string> discarded_passes_{};
|
||||
|
||||
public:
|
||||
explicit ConfigBase(PowerMode mode = LITE_POWER_NO_BIND, int threads = 1);
|
||||
// set Model_dir
|
||||
void set_model_dir(const std::string& x) { model_dir_ = x; }
|
||||
const std::string& model_dir() const { return model_dir_; }
|
||||
// set Thread
|
||||
void set_threads(int threads);
|
||||
int threads() const { return threads_; }
|
||||
// set Power_mode
|
||||
void set_power_mode(PowerMode mode);
|
||||
PowerMode power_mode() const { return mode_; }
|
||||
|
||||
/// \brief Set path and file name of generated OpenCL compiled kernel binary.
|
||||
///
|
||||
/// If you use GPU of specific soc, using OpenCL binary will speed up the
|
||||
/// initialization.
|
||||
///
|
||||
/// \param path Path that OpenCL compiled kernel binay file stores in. Make
|
||||
/// sure the path exist and you have Read&Write permission.
|
||||
/// \param name File name of OpenCL compiled kernel binay.
|
||||
/// \return void
|
||||
void set_opencl_binary_path_name(const std::string& path,
|
||||
const std::string& name);
|
||||
|
||||
/// \brief Set path and file name of generated OpenCL algorithm selecting
|
||||
/// file.
|
||||
///
|
||||
/// If you use GPU of specific soc, using OpenCL binary will speed up the
|
||||
/// running time in most cases. But the first running for algorithm selecting
|
||||
/// is timg-costing.
|
||||
///
|
||||
/// \param tune_mode Set a tune mode:
|
||||
/// CL_TUNE_NONE: turn off
|
||||
/// CL_TUNE_RAPID: find the optimal algorithm in a rapid way(less
|
||||
/// time-cost)
|
||||
/// CL_TUNE_NORMAL: find the optimal algorithm in a noraml
|
||||
/// way(suggestion)
|
||||
/// CL_TUNE_EXHAUSTIVE: find the optimal algorithm in a exhaustive
|
||||
/// way(most time-costing)
|
||||
/// \param path Path that OpenCL algorithm selecting file stores in. Make
|
||||
/// sure the path exist and you have Read&Write permission.
|
||||
/// \param name File name of OpenCL algorithm selecting file.
|
||||
/// \param lws_repeats Repeat number for find the optimal local work size .
|
||||
/// \return void
|
||||
void set_opencl_tune(CLTuneMode tune_mode = CL_TUNE_NONE,
|
||||
const std::string& path = "",
|
||||
const std::string& name = "",
|
||||
size_t lws_repeats = 4);
|
||||
|
||||
/// \brief Set runtime precision on GPU using OpenCL backend.
|
||||
///
|
||||
/// \param p
|
||||
/// CL_PRECISION_AUTO: first fp16 if valid, default
|
||||
/// CL_PRECISION_FP32: force fp32
|
||||
/// CL_PRECISION_FP16: force fp16
|
||||
/// \return void
|
||||
void set_opencl_precision(CLPrecisionType p = CL_PRECISION_AUTO);
|
||||
|
||||
// set subgraph_model_dir
|
||||
void set_subgraph_model_cache_dir(std::string subgraph_model_cache_dir) {
|
||||
subgraph_model_cache_dir_ = subgraph_model_cache_dir;
|
||||
}
|
||||
const std::string& subgraph_model_cache_dir() const {
|
||||
return subgraph_model_cache_dir_;
|
||||
}
|
||||
void set_subgraph_model_cache_buffers(const std::string& key,
|
||||
const std::vector<char>& cfg,
|
||||
const std::vector<char>& bin);
|
||||
const std::map<std::string, std::pair<std::vector<char>, std::vector<char>>>&
|
||||
subgraph_model_cache_buffers() const {
|
||||
return subgraph_model_cache_buffers_;
|
||||
}
|
||||
// Check if the NNAdapter device is valid.
|
||||
bool check_nnadapter_device_name(const std::string& device_name);
|
||||
// Choose the NNAdapter devices to build and run the model.
|
||||
void set_nnadapter_device_names(
|
||||
const std::vector<std::string>& device_names) {
|
||||
nnadapter_device_names_ = device_names;
|
||||
}
|
||||
const std::vector<std::string>& nnadapter_device_names() const {
|
||||
return nnadapter_device_names_;
|
||||
}
|
||||
// Set the context properties by key-value map for NNAdapter device
|
||||
// configuration, model compilation and execution
|
||||
// Such as "HUAWEI_ASCEND_NPU_SELECTED_DEVICE_IDS=0;"
|
||||
void set_nnadapter_context_properties(const std::string& context_properties) {
|
||||
nnadapter_context_properties_ = context_properties;
|
||||
}
|
||||
const std::string& nnadapter_context_properties() const {
|
||||
return nnadapter_context_properties_;
|
||||
}
|
||||
// Set nnadapter_context_callback for NNAdapter device to get runtime
|
||||
// parameters.
|
||||
// For example:
|
||||
// cudaStream_t cuda_stream;
|
||||
// cudaStreamCreate(&cuda_stream);
|
||||
// int nnadapter_context_callback(int event_id, void* user_data) {
|
||||
// if (event_id == 0x0100) {
|
||||
// *(std::reinterpret_cast<cudaStream_t*>(user_data)) = cuda_stream;
|
||||
// }
|
||||
// return 0;
|
||||
// }
|
||||
void set_nnadapter_context_callback(
|
||||
int (*nnadapter_context_callback)(int event_id, void* user_data)) {
|
||||
nnadapter_context_callback_ = nnadapter_context_callback;
|
||||
}
|
||||
int (*nnadapter_context_callback() const)(int event_id, // NOLINT
|
||||
void* user_data) {
|
||||
return nnadapter_context_callback_;
|
||||
}
|
||||
|
||||
// Enable caching and set the directory to search and store the compiled
|
||||
// NNAdapter models in the file system.
|
||||
void set_nnadapter_model_cache_dir(const std::string& model_cache_dir) {
|
||||
nnadapter_model_cache_dir_ = model_cache_dir;
|
||||
}
|
||||
const std::string& nnadapter_model_cache_dir() const {
|
||||
return nnadapter_model_cache_dir_;
|
||||
}
|
||||
// Set dynamic shapes for building models
|
||||
void set_nnadapter_dynamic_shape_info(
|
||||
const std::map<std::string, std::vector<std::vector<int64_t>>>&
|
||||
nnadapter_dynamic_shape_info) {
|
||||
nnadapter_dynamic_shape_info_ = nnadapter_dynamic_shape_info;
|
||||
}
|
||||
const std::map<std::string, std::vector<std::vector<int64_t>>>&
|
||||
nnadapter_dynamic_shape_info() const {
|
||||
return nnadapter_dynamic_shape_info_;
|
||||
}
|
||||
// Set the buffers for loading the compiled NNAdapter models from memory.
|
||||
void set_nnadapter_model_cache_buffers(
|
||||
const std::string& model_cache_token,
|
||||
const std::vector<char>& model_cache_buffer);
|
||||
const std::map<std::string, std::vector<char>>&
|
||||
nnadapter_model_cache_buffers() const {
|
||||
return nnadapter_model_cache_buffers_;
|
||||
}
|
||||
// set Device ID
|
||||
void set_device_id(int device_id) { device_id_ = device_id; }
|
||||
int get_device_id() const { return device_id_; }
|
||||
// set x86_math_num_threads
|
||||
void set_x86_math_num_threads(int threads);
|
||||
int x86_math_num_threads() const;
|
||||
|
||||
void set_metal_lib_path(const std::string& path);
|
||||
void set_metal_use_mps(bool flag);
|
||||
void set_metal_use_aggressive(bool flag);
|
||||
void set_metal_device(void* device);
|
||||
void set_metal_use_memory_reuse(bool flag);
|
||||
|
||||
std::string metal_lib_path() const { return metal_path_; }
|
||||
bool metal_use_mps() const { return metal_use_mps_; }
|
||||
bool metal_use_aggressive() const { return metal_use_aggressive_; }
|
||||
void* metal_device() const { return metal_device_; }
|
||||
bool metal_use_memory_reuse() const { return metal_use_memory_reuse_; }
|
||||
|
||||
void add_discarded_pass(const std::string pass);
|
||||
const std::vector<std::string> get_discarded_passes() const {
|
||||
return discarded_passes_;
|
||||
}
|
||||
};
|
||||
|
||||
class LITE_API CxxModelBuffer {
|
||||
public:
|
||||
CxxModelBuffer(const char* program_buffer,
|
||||
size_t program_buffer_size,
|
||||
const char* params_buffer,
|
||||
size_t params_buffer_size);
|
||||
CxxModelBuffer(std::string&& program_buffer, std::string&& params_buffer);
|
||||
const std::string& get_program() const;
|
||||
const std::string& get_params() const;
|
||||
bool is_empty() const;
|
||||
|
||||
CxxModelBuffer() = default;
|
||||
CxxModelBuffer(const CxxModelBuffer&) = delete;
|
||||
|
||||
private:
|
||||
std::string program_;
|
||||
std::string params_;
|
||||
};
|
||||
|
||||
/// CxxConfig is the config for the Full feature predictor.
|
||||
class LITE_API CxxConfig : public ConfigBase {
|
||||
std::vector<Place> valid_places_;
|
||||
std::string model_file_;
|
||||
std::string param_file_;
|
||||
std::shared_ptr<CxxModelBuffer> model_buffer_{nullptr};
|
||||
std::vector<std::string> passes_internal_{};
|
||||
bool quant_model_{false}; // Enable post_quant_dynamic in opt
|
||||
QuantType quant_type_{QuantType::QUANT_INT16};
|
||||
bool sparse_model_{false}; // Enable sparse_conv_detect_pass in opt
|
||||
float sparse_threshold_{0.6f};
|
||||
std::map<int, std::vector<std::shared_ptr<void>>>
|
||||
preferred_inputs_for_warmup_;
|
||||
#ifdef LITE_WITH_CUDA
|
||||
bool multi_stream_{false};
|
||||
#endif
|
||||
#ifdef LITE_WITH_MLU
|
||||
lite_api::MLUCoreVersion mlu_core_version_{lite_api::MLUCoreVersion::MLU_270};
|
||||
int mlu_core_number_{1};
|
||||
DataLayoutType mlu_input_layout_{DATALAYOUT(kNCHW)};
|
||||
std::vector<float> mlu_first_conv_mean_{};
|
||||
std::vector<float> mlu_first_conv_std_{};
|
||||
#endif
|
||||
// The custom configuration file or buffer for the NNAdapter subgraph
|
||||
// partition, here is an example:
|
||||
// op_type:in_var_name_0,in_var_name1:out_var_name_0,out_var_name1
|
||||
// op_type::out_var_name_0
|
||||
// op_type:in_var_name_0
|
||||
// op_type
|
||||
std::string nnadapter_subgraph_partition_config_path_;
|
||||
std::string nnadapter_subgraph_partition_config_buffer_;
|
||||
std::string mixed_precision_quantization_config_path_;
|
||||
std::string mixed_precision_quantization_config_buffer_;
|
||||
|
||||
public:
|
||||
void set_valid_places(const std::vector<Place>& x) { valid_places_ = x; }
|
||||
void set_model_file(const std::string& path) { model_file_ = path; }
|
||||
void set_param_file(const std::string& path) { param_file_ = path; }
|
||||
void set_model_buffer(const char* model_buffer,
|
||||
size_t model_buffer_size,
|
||||
const char* param_buffer,
|
||||
size_t param_buffer_size) {
|
||||
model_buffer_.reset(new CxxModelBuffer(
|
||||
model_buffer, model_buffer_size, param_buffer, param_buffer_size));
|
||||
}
|
||||
void set_model_buffer(std::shared_ptr<CxxModelBuffer> model_buffer) {
|
||||
model_buffer_ = model_buffer;
|
||||
}
|
||||
const CxxModelBuffer& get_model_buffer() const;
|
||||
// internal inference to choose passes for model optimizing,
|
||||
// it's designed for internal developer and not recommanded
|
||||
// for comman users.
|
||||
void set_passes_internal(
|
||||
const std::vector<std::string>& passes_internal = {}) {
|
||||
passes_internal_ = passes_internal;
|
||||
}
|
||||
const std::vector<std::string>& get_passes_internal() const {
|
||||
return passes_internal_;
|
||||
}
|
||||
const std::vector<Place>& valid_places() const { return valid_places_; }
|
||||
std::string model_file() const { return model_file_; }
|
||||
std::string param_file() const { return param_file_; }
|
||||
bool is_model_from_memory() const { return static_cast<bool>(model_buffer_); }
|
||||
// note: `model_from_memory` has the same effect as `is_model_from_memory`,
|
||||
// but is_model_from_memory is recommended and `model_from_memory` will be
|
||||
// abandoned in v3.0.
|
||||
bool model_from_memory() const { return static_cast<bool>(model_buffer_); }
|
||||
|
||||
#ifdef LITE_WITH_CUDA
|
||||
void set_multi_stream(bool multi_stream) { multi_stream_ = multi_stream; }
|
||||
bool multi_stream() const { return multi_stream_; }
|
||||
#endif
|
||||
|
||||
#ifdef LITE_WITH_MLU
|
||||
// set MLU core version, which is used when compiling MLU kernels
|
||||
void set_mlu_core_version(lite_api::MLUCoreVersion core_version);
|
||||
// set MLU core number, which is used when compiling MLU kernels
|
||||
void set_mlu_core_number(int core_number);
|
||||
// whether use MLU's first conv kernel. First conv is a special kernel
|
||||
// provided by MLU, its input is uint8, and also needs two 3-dimentional
|
||||
// vectors which save all inputs' mean and std values
|
||||
// set the 3-dimentional mean vector and 3-dimentional std vector used by
|
||||
// MLU's first conv
|
||||
void set_mlu_firstconv_param(const std::vector<float>& mean,
|
||||
const std::vector<float>& std);
|
||||
// set MLU input layout. User can specify layout of input data to be NHWC,
|
||||
// default is NCHW
|
||||
void set_mlu_input_layout(DataLayoutType layout);
|
||||
|
||||
lite_api::MLUCoreVersion mlu_core_version() const;
|
||||
int mlu_core_number() const;
|
||||
DataLayoutType mlu_input_layout() const;
|
||||
// std::pair<mean, std>
|
||||
std::pair<std::vector<float>, std::vector<float>> mlu_firstconv_param() const;
|
||||
#endif
|
||||
|
||||
// XPU only, set the size of the workspace memory from L3 cache for the
|
||||
// current thread.
|
||||
// **DEPRECATED**, use set_xpu_l3_cache_method() in the future
|
||||
void set_xpu_workspace_l3_size_per_thread(int l3_size = 0x4000000);
|
||||
void set_xpu_l3_cache_method(size_t l3_size, bool locked = false);
|
||||
|
||||
void set_xpu_gm_workspace_method(size_t gm_size);
|
||||
|
||||
void set_xpu_conv_autotune(bool autotune = true,
|
||||
const std::string& autotune_file = "");
|
||||
|
||||
// XPU only, specify the target device ID for the current thread.
|
||||
// **DEPRECATED**, use xpu_set_device() at the very beginning of each worker
|
||||
// thread
|
||||
void set_xpu_dev_per_thread(int dev_no = 0);
|
||||
|
||||
// XPU set multi_stream
|
||||
void enable_xpu_multi_stream();
|
||||
|
||||
// **DEPRECATED**, use set_xpu_multi_encoder_method() in the future
|
||||
void set_xpu_multi_encoder_precision(const std::string& precision = "int16");
|
||||
void set_xpu_multi_encoder_method(const std::string& precision = "int16",
|
||||
bool adaptive_seqlen = false);
|
||||
|
||||
// set input tensor for warmup.
|
||||
// It is optional. If you set prefered_inputs, model wil run immediately when
|
||||
// predictor is created
|
||||
template <class T>
|
||||
void set_preferred_inputs_for_warmup(const int group_idx,
|
||||
const int tensor_idx,
|
||||
const shape_t& shape,
|
||||
const lod_t& lod = {},
|
||||
const T fill_value = 0,
|
||||
const void* data = nullptr);
|
||||
const std::map<int, std::vector<std::shared_ptr<void>>>&
|
||||
preferred_inputs_for_warmup() const {
|
||||
return preferred_inputs_for_warmup_;
|
||||
}
|
||||
|
||||
void set_quant_model(bool quant_model) { quant_model_ = quant_model; }
|
||||
bool quant_model() const { return quant_model_; }
|
||||
void set_quant_type(QuantType quant_type) { quant_type_ = quant_type; }
|
||||
QuantType quant_type() const { return quant_type_; }
|
||||
|
||||
void set_sparse_model(bool sparse_model) { sparse_model_ = sparse_model; }
|
||||
bool sparse_model() const { return sparse_model_; }
|
||||
void set_sparse_threshold(float sparse_threshold) {
|
||||
sparse_threshold_ = sparse_threshold;
|
||||
}
|
||||
float sparse_threshold() const { return sparse_threshold_; }
|
||||
|
||||
// Enable the custom subgraph partition for NNAdapter by providing the
|
||||
// configuration file or buffer
|
||||
void set_nnadapter_subgraph_partition_config_path(
|
||||
const std::string& subgraph_partition_config_path) {
|
||||
nnadapter_subgraph_partition_config_path_ = subgraph_partition_config_path;
|
||||
}
|
||||
const std::string& nnadapter_subgraph_partition_config_path() const {
|
||||
return nnadapter_subgraph_partition_config_path_;
|
||||
}
|
||||
void set_nnadapter_subgraph_partition_config_buffer(
|
||||
const std::string& subgraph_partition_config_buffer) {
|
||||
nnadapter_subgraph_partition_config_buffer_ =
|
||||
subgraph_partition_config_buffer;
|
||||
}
|
||||
const std::string& nnadapter_subgraph_partition_config_buffer() const {
|
||||
return nnadapter_subgraph_partition_config_buffer_;
|
||||
}
|
||||
// Clear some ops' quant information to support mixed precision compute by
|
||||
// configuration file or buffer
|
||||
void set_nnadapter_mixed_precision_quantization_config_path(
|
||||
const std::string& mixed_precision_quantization_config_path) {
|
||||
mixed_precision_quantization_config_path_ =
|
||||
mixed_precision_quantization_config_path;
|
||||
}
|
||||
const std::string& nnadapter_mixed_precision_quantization_config_path()
|
||||
const {
|
||||
return mixed_precision_quantization_config_path_;
|
||||
}
|
||||
void set_nnadapter_mixed_precision_quantization_config_buffer(
|
||||
const std::string& mixed_precision_quantization_config_buffer) {
|
||||
mixed_precision_quantization_config_buffer_ =
|
||||
mixed_precision_quantization_config_buffer;
|
||||
}
|
||||
const std::string& nnadapter_mixed_precision_quantization_config_buffer()
|
||||
const {
|
||||
return mixed_precision_quantization_config_buffer_;
|
||||
}
|
||||
};
|
||||
|
||||
/// MobileConfig is the config for the light weight predictor, it will skip
|
||||
/// IR optimization or other unnecessary stages.
|
||||
class LITE_API MobileConfig : public ConfigBase {
|
||||
// whether to load data from memory. Model data will be loaded from memory
|
||||
// buffer if model_from_memory_ is true.
|
||||
bool model_from_memory_{false};
|
||||
|
||||
// model data readed from file or memory buffer in combined format.
|
||||
std::string lite_model_file_;
|
||||
|
||||
// NOTE: This is a deprecated variable and will be removed in latter release.
|
||||
std::string model_buffer_;
|
||||
std::string param_buffer_;
|
||||
|
||||
public:
|
||||
// set model data in combined format, `set_model_from_file` refers to loading
|
||||
// model from file, set_model_from_buffer refers to loading model from memory
|
||||
// buffer
|
||||
void set_model_from_file(const std::string& x);
|
||||
void set_model_from_buffer(const std::string& x);
|
||||
// return model data in lite_model_file_, which is in combined format.
|
||||
const std::string& lite_model_file() const { return lite_model_file_; }
|
||||
|
||||
// return model_from_memory_, which indicates whether to load model from
|
||||
// memory buffer.
|
||||
bool is_model_from_memory() const { return model_from_memory_; }
|
||||
// note: `model_from_memory` has the same effect as `is_model_from_memory`,
|
||||
// but is_model_from_memory is recommended and `model_from_memory` will be
|
||||
// abandoned in v3.0.
|
||||
bool model_from_memory() const { return model_from_memory_; }
|
||||
|
||||
// NOTE: This is a deprecated API and will be removed in latter release.
|
||||
void set_model_buffer(const char* model_buffer,
|
||||
size_t model_buffer_size,
|
||||
const char* param_buffer,
|
||||
size_t param_buffer_size);
|
||||
|
||||
// NOTE: This is a deprecated API and will be removed in latter release.
|
||||
const std::string& model_buffer() const { return model_buffer_; }
|
||||
|
||||
// NOTE: This is a deprecated API and will be removed in latter release.
|
||||
const std::string& param_buffer() const { return param_buffer_; }
|
||||
|
||||
// This is the method for allocating workspace_size according to L3Cache size
|
||||
void SetArmL3CacheSize(
|
||||
L3CacheSetMethod method = L3CacheSetMethod::kDeviceL3Cache,
|
||||
int absolute_val = -1);
|
||||
};
|
||||
|
||||
template <typename ConfigT>
|
||||
LITE_API std::shared_ptr<PaddlePredictor> CreatePaddlePredictor(const ConfigT&);
|
||||
|
||||
} // namespace lite_api
|
||||
} // namespace paddle
|
||||
|
||||
#endif // NOLINT
|
||||
@@ -1,274 +0,0 @@
|
||||
// Copyright (c) 2019 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 <stdio.h>
|
||||
#include <vector>
|
||||
#include "lite/api/paddle_api.h"
|
||||
#include "lite/api/paddle_place.h"
|
||||
|
||||
namespace paddle {
|
||||
namespace lite {
|
||||
namespace utils {
|
||||
namespace cv {
|
||||
typedef paddle::lite_api::Tensor Tensor;
|
||||
typedef paddle::lite_api::DataLayoutType LayoutType;
|
||||
// color enum
|
||||
enum ImageFormat {
|
||||
RGBA = 0,
|
||||
BGRA,
|
||||
RGB,
|
||||
BGR,
|
||||
GRAY,
|
||||
NV21 = 11,
|
||||
NV12,
|
||||
YUV420SP,
|
||||
YUV420P,
|
||||
YUV422,
|
||||
YUV444
|
||||
};
|
||||
// flip enum
|
||||
enum FlipParam {
|
||||
XY = -1, // flip along the XY axis
|
||||
X = 0, // flip along the X axis
|
||||
Y // flip along the Y axis
|
||||
};
|
||||
// transform param
|
||||
typedef struct {
|
||||
int ih; // input height
|
||||
int iw; // input width
|
||||
int oh; // outpu theight
|
||||
int ow; // output width
|
||||
FlipParam flip_param; // flip, support x, y, xy
|
||||
float rotate_param; // rotate, support 90, 180, 270
|
||||
} TransParam;
|
||||
|
||||
class ImagePreprocess {
|
||||
public:
|
||||
/*
|
||||
* init
|
||||
* param srcFormat: input image color
|
||||
* param dstFormat: output image color
|
||||
* param param: input image parameter, egs: input size
|
||||
*/
|
||||
ImagePreprocess(ImageFormat srcFormat,
|
||||
ImageFormat dstFormat,
|
||||
TransParam param);
|
||||
|
||||
/*
|
||||
* image color convert
|
||||
* support NV12/NV21_to_BGR(RGB), NV12/NV21_to_BGRA(RGBA),
|
||||
* BGR(RGB)and BGRA(RGBA) transform,
|
||||
* BGR(RGB)and RGB(BGR) transform,
|
||||
* BGR(RGB)and RGBA(BGRA) transform,
|
||||
* BGR(RGB) and GRAY transform,
|
||||
* BGRA(RGBA) and GRAY transform,
|
||||
* param src: input image data
|
||||
* param dst: output image data
|
||||
*/
|
||||
void image_convert(const uint8_t* src, uint8_t* dst);
|
||||
|
||||
/*
|
||||
* image color convert
|
||||
* support NV12/NV21_to_BGR(RGB), NV12/NV21_to_BGRA(RGBA),
|
||||
* BGR(RGB)and BGRA(RGBA) transform,
|
||||
* BGR(RGB)and RGB(BGR) transform,
|
||||
* BGR(RGB)and RGBA(BGRA) transform,
|
||||
* BGR(RGB)and GRAY transform,
|
||||
* BGRA(RGBA) and GRAY transform,
|
||||
* param src: input image data
|
||||
* param dst: output image data
|
||||
* param srcFormat: input image image format support: GRAY, NV12(NV21),
|
||||
* BGR(RGB) and BGRA(RGBA)
|
||||
* param dstFormat: output image image format, support GRAY, BGR(RGB) and
|
||||
* BGRA(RGBA)
|
||||
*/
|
||||
void image_convert(const uint8_t* src,
|
||||
uint8_t* dst,
|
||||
ImageFormat srcFormat,
|
||||
ImageFormat dstFormat);
|
||||
|
||||
/*
|
||||
* image color convert
|
||||
* support NV12/NV21_to_BGR(RGB), NV12/NV21_to_BGRA(RGBA),
|
||||
* BGR(RGB)and BGRA(RGBA) transform,
|
||||
* BGR(RGB)and RGB(BGR) transform,
|
||||
* BGR(RGB)and RGBA(BGRA) transform,
|
||||
* BGR(RGB)and GRAY transform,
|
||||
* BGRA(RGBA) and GRAY transform,
|
||||
* param src: input image data
|
||||
* param dst: output image data
|
||||
* param srcFormat: input image image format support: GRAY, NV12(NV21),
|
||||
* BGR(RGB) and BGRA(RGBA)
|
||||
* param dstFormat: output image image format, support GRAY, BGR(RGB) and
|
||||
* BGRA(RGBA)
|
||||
* param srcw: input image width
|
||||
* param srch: input image height
|
||||
*/
|
||||
void image_convert(const uint8_t* src,
|
||||
uint8_t* dst,
|
||||
ImageFormat srcFormat,
|
||||
ImageFormat dstFormat,
|
||||
int srcw,
|
||||
int srch);
|
||||
|
||||
/*
|
||||
* image resize, use bilinear method
|
||||
* support image format: 1-channel image (egs: GRAY, 2-channel image (egs:
|
||||
* NV12, NV21), 3-channel(egs: BGR), 4-channel(egs: BGRA)
|
||||
* param src: input image data
|
||||
* param dst: output image data
|
||||
*/
|
||||
void image_resize(const uint8_t* src, uint8_t* dst);
|
||||
|
||||
/*
|
||||
image resize, use bilinear method
|
||||
* support image format: 1-channel image (egs: GRAY, 2-channel image (egs:
|
||||
NV12, NV21), 3-channel image(egs: BGR), 4-channel image(egs: BGRA)
|
||||
* param src: input image data
|
||||
* param dst: output image data
|
||||
* param srcw: input image width
|
||||
* param srch: input image height
|
||||
* param dstw: output image width
|
||||
* param dsth: output image height
|
||||
*/
|
||||
void image_resize(const uint8_t* src,
|
||||
uint8_t* dst,
|
||||
ImageFormat srcFormat,
|
||||
int srcw,
|
||||
int srch,
|
||||
int dstw,
|
||||
int dsth);
|
||||
|
||||
/*
|
||||
* image Rotate
|
||||
* support 90, 180 and 270 Rotate process
|
||||
* color format support 1-channel image, 3-channel image and 4-channel image
|
||||
* param src: input image data
|
||||
* param dst: output image data
|
||||
*/
|
||||
void image_rotate(const uint8_t* src, uint8_t* dst);
|
||||
|
||||
/*
|
||||
* image Rotate
|
||||
* support 90, 180 and 270 Rotate process
|
||||
* color format support 1-channel image, 3-channel image and 4-channel image
|
||||
* param src: input image data
|
||||
* param dst: output image data
|
||||
* param srcFormat: input image format, support GRAY, BGR(RGB) and BGRA(RGBA)
|
||||
* param srcw: input image width
|
||||
* param srch: input image height
|
||||
* param degree: Rotate degree, support 90, 180 and 270
|
||||
*/
|
||||
void image_rotate(const uint8_t* src,
|
||||
uint8_t* dst,
|
||||
ImageFormat srcFormat,
|
||||
int srcw,
|
||||
int srch,
|
||||
float degree);
|
||||
|
||||
/*
|
||||
* image Flip
|
||||
* support X, Y and XY flip process
|
||||
* color format support 1-channel image, 3-channel image and 4-channel image
|
||||
* param src: input image data
|
||||
* param dst: output image data
|
||||
*/
|
||||
void image_flip(const uint8_t* src, uint8_t* dst);
|
||||
|
||||
/*
|
||||
* image Flip
|
||||
* support X, Y and XY flip process
|
||||
* color format support 1-channel image, 3-channel image and 4-channel image
|
||||
* param src: input image data
|
||||
* param dst: output image data
|
||||
* param srcFormat: input image format, support GRAY, BGR(RGB) and BGRA(RGBA)
|
||||
* param srcw: input image width
|
||||
* param srch: input image height
|
||||
* param flip_param: flip parameter, support X, Y and XY
|
||||
*/
|
||||
void image_flip(const uint8_t* src,
|
||||
uint8_t* dst,
|
||||
ImageFormat srcFormat,
|
||||
int srcw,
|
||||
int srch,
|
||||
FlipParam flip_param);
|
||||
|
||||
/*
|
||||
* change image data to tensor data
|
||||
* support image format is GRAY, BGR(RGB) and BGRA(RGBA), Data layout is NHWC
|
||||
* and
|
||||
* NCHW
|
||||
* param src: input image data
|
||||
* param dstTensor: output tensor data
|
||||
* param layout: output tensor layout，support NHWC and NCHW
|
||||
* param means: means of image
|
||||
* param scales: scales of image
|
||||
*/
|
||||
void image_to_tensor(const uint8_t* src,
|
||||
Tensor* dstTensor,
|
||||
LayoutType layout,
|
||||
float* means,
|
||||
float* scales);
|
||||
|
||||
/*
|
||||
* change image data to tensor data
|
||||
* support image format is GRAY, BGR(RGB) and BGRA(RGBA), Data layout is NHWC
|
||||
* and
|
||||
* NCHW
|
||||
* param src: input image data
|
||||
* param dstTensor: output tensor data
|
||||
* param srcFormat: input image format, support BGR(RGB) and BGRA(RGBA)
|
||||
* param srcw: input image width
|
||||
* param srch: input image height
|
||||
* param layout: output tensor layout，support NHWC and NCHW
|
||||
* param means: means of image
|
||||
* param scales: scales of image
|
||||
*/
|
||||
void image_to_tensor(const uint8_t* src,
|
||||
Tensor* dstTensor,
|
||||
ImageFormat srcFormat,
|
||||
int srcw,
|
||||
int srch,
|
||||
LayoutType layout,
|
||||
float* means,
|
||||
float* scales);
|
||||
|
||||
/*
|
||||
* image crop process
|
||||
* color format support 1-channel image, 3-channel image and 4-channel image
|
||||
* param src: input image data
|
||||
* param dst: output image data
|
||||
*/
|
||||
void image_crop(const uint8_t* src,
|
||||
uint8_t* dst,
|
||||
ImageFormat srcFormat,
|
||||
int srcw,
|
||||
int srch,
|
||||
int left_x,
|
||||
int left_y,
|
||||
int dstw,
|
||||
int dsth);
|
||||
|
||||
private:
|
||||
ImageFormat srcFormat_;
|
||||
ImageFormat dstFormat_;
|
||||
TransParam transParam_;
|
||||
};
|
||||
} // namespace cv
|
||||
} // namespace utils
|
||||
} // namespace lite
|
||||
} // namespace paddle
|
||||
@@ -1,44 +0,0 @@
|
||||
// Copyright (c) 2019 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.
|
||||
|
||||
/*
|
||||
* This file defines some MACROS that explicitly determine the op, kernel, mir
|
||||
* passes used in the inference lib.
|
||||
*/
|
||||
#pragma once
|
||||
|
||||
// some platform-independent defintion
|
||||
|
||||
#if defined(_WIN32)
|
||||
#define UNUSED
|
||||
#define __builtin_expect(EXP, C) (EXP)
|
||||
#else
|
||||
#define UNUSED __attribute__((unused))
|
||||
#endif
|
||||
|
||||
#define USE_LITE_OP(op_type__) \
|
||||
extern int touch_op_##op_type__(); \
|
||||
int LITE_OP_REGISTER_FAKE(op_type__) UNUSED = touch_op_##op_type__();
|
||||
|
||||
#define USE_LITE_KERNEL(op_type__, target__, precision__, layout__, alias__) \
|
||||
extern int touch_##op_type__##target__##precision__##layout__##alias__(); \
|
||||
int op_type__##target__##precision__##layout__##alias__##__use_lite_kernel \
|
||||
UNUSED = touch_##op_type__##target__##precision__##layout__##alias__();
|
||||
|
||||
#define USE_MIR_PASS(name__) \
|
||||
extern bool mir_pass_registry##name__##_fake(); \
|
||||
static bool mir_pass_usage##name__ UNUSED = \
|
||||
mir_pass_registry##name__##_fake();
|
||||
|
||||
#define LITE_OP_REGISTER_FAKE(op_type__) op_type__##__registry__
|
||||
@@ -1,278 +0,0 @@
|
||||
// Copyright (c) 2019 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 <set>
|
||||
#include <string>
|
||||
|
||||
// Generic helper definitions for shared library support
|
||||
#if defined _WIN32 || defined __CYGWIN__
|
||||
#define PADDLE_LITE_HELPER_DLL_IMPORT __declspec(dllimport)
|
||||
#define PADDLE_LITE_HELPER_DLL_EXPORT __declspec(dllexport)
|
||||
#define PADDLE_LITE_HELPER_DLL_LOCAL
|
||||
#else
|
||||
#if __GNUC__ >= 4
|
||||
#define PADDLE_LITE_HELPER_DLL_IMPORT __attribute__((visibility("default")))
|
||||
#define PADDLE_LITE_HELPER_DLL_EXPORT __attribute__((visibility("default")))
|
||||
#else
|
||||
#define PADDLE_LITE_HELPER_DLL_IMPORT
|
||||
#define PADDLE_LITE_HELPER_DLL_EXPORT
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#ifdef LITE_ON_TINY_PUBLISH
|
||||
#define LITE_API PADDLE_LITE_HELPER_DLL_EXPORT
|
||||
#define LITE_API_IMPORT PADDLE_LITE_HELPER_DLL_IMPORT
|
||||
#else
|
||||
#define LITE_API
|
||||
#define LITE_API_IMPORT
|
||||
#endif
|
||||
|
||||
namespace paddle {
|
||||
namespace lite_api {
|
||||
|
||||
enum class TargetType : int {
|
||||
kUnk = 0,
|
||||
kHost = 1,
|
||||
kX86 = 2,
|
||||
kCUDA = 3,
|
||||
kARM = 4,
|
||||
kOpenCL = 5,
|
||||
kAny = 6, // any target
|
||||
kFPGA = 7,
|
||||
kNPU = 8,
|
||||
kXPU = 9,
|
||||
kBM = 10,
|
||||
kMLU = 11,
|
||||
kRKNPU = 12,
|
||||
kAPU = 13,
|
||||
kHuaweiAscendNPU = 14,
|
||||
kImaginationNNA = 15,
|
||||
kIntelFPGA = 16,
|
||||
kMetal = 17,
|
||||
kNNAdapter = 18,
|
||||
NUM = 19, // number of fields.
|
||||
};
|
||||
enum class PrecisionType : int {
|
||||
kUnk = 0,
|
||||
kFloat = 1,
|
||||
kInt8 = 2,
|
||||
kInt32 = 3,
|
||||
kAny = 4, // any precision
|
||||
kFP16 = 5,
|
||||
kBool = 6,
|
||||
kInt64 = 7,
|
||||
kInt16 = 8,
|
||||
kUInt8 = 9,
|
||||
kFP64 = 10,
|
||||
NUM = 11, // number of fields.
|
||||
};
|
||||
enum class DataLayoutType : int {
|
||||
kUnk = 0,
|
||||
kNCHW = 1,
|
||||
kNHWC = 3,
|
||||
kImageDefault = 4, // for opencl image2d
|
||||
kImageFolder = 5, // for opencl image2d
|
||||
kImageNW = 6, // for opencl image2d
|
||||
kAny = 2, // any data layout
|
||||
kMetalTexture2DArray = 7,
|
||||
kMetalTexture2D = 8,
|
||||
NUM = 9, // number of fields.
|
||||
};
|
||||
|
||||
typedef enum {
|
||||
LITE_POWER_HIGH = 0,
|
||||
LITE_POWER_LOW = 1,
|
||||
LITE_POWER_FULL = 2,
|
||||
LITE_POWER_NO_BIND = 3,
|
||||
LITE_POWER_RAND_HIGH = 4,
|
||||
LITE_POWER_RAND_LOW = 5
|
||||
} PowerMode;
|
||||
|
||||
typedef enum {
|
||||
CL_TUNE_NONE = 0,
|
||||
CL_TUNE_RAPID = 1,
|
||||
CL_TUNE_NORMAL = 2,
|
||||
CL_TUNE_EXHAUSTIVE = 3
|
||||
} CLTuneMode;
|
||||
|
||||
typedef enum {
|
||||
CL_PRECISION_AUTO = 0,
|
||||
CL_PRECISION_FP32 = 1,
|
||||
CL_PRECISION_FP16 = 2
|
||||
} CLPrecisionType;
|
||||
|
||||
typedef enum { MLU_220 = 0, MLU_270 = 1 } MLUCoreVersion;
|
||||
|
||||
enum class ActivationType : int {
|
||||
kIndentity = 0,
|
||||
kRelu = 1,
|
||||
kRelu6 = 2,
|
||||
kPRelu = 3,
|
||||
kLeakyRelu = 4,
|
||||
kSigmoid = 5,
|
||||
kTanh = 6,
|
||||
kSwish = 7,
|
||||
kExp = 8,
|
||||
kAbs = 9,
|
||||
kHardSwish = 10,
|
||||
kReciprocal = 11,
|
||||
kThresholdedRelu = 12,
|
||||
kElu = 13,
|
||||
kHardSigmoid = 14,
|
||||
kLog = 15,
|
||||
kSigmoid_v2 = 16,
|
||||
kTanh_v2 = 17,
|
||||
kGelu = 18,
|
||||
kErf = 19,
|
||||
kSign = 20,
|
||||
kSoftPlus = 21,
|
||||
kMish = 22,
|
||||
NUM = 23,
|
||||
};
|
||||
|
||||
static size_t PrecisionTypeLength(PrecisionType type) {
|
||||
switch (type) {
|
||||
case PrecisionType::kFloat:
|
||||
return 4;
|
||||
case PrecisionType::kFP64:
|
||||
return 8;
|
||||
case PrecisionType::kUInt8:
|
||||
return 1;
|
||||
case PrecisionType::kInt8:
|
||||
return 1;
|
||||
case PrecisionType::kInt32:
|
||||
return 4;
|
||||
case PrecisionType::kInt64:
|
||||
return 8;
|
||||
case PrecisionType::kFP16:
|
||||
return 2;
|
||||
case PrecisionType::kInt16:
|
||||
return 2;
|
||||
default:
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
enum class QuantType : int {
|
||||
QUANT_INT8,
|
||||
QUANT_INT16,
|
||||
};
|
||||
|
||||
template <typename T>
|
||||
struct PrecisionTypeTrait {
|
||||
constexpr static PrecisionType Type() { return PrecisionType::kUnk; }
|
||||
};
|
||||
|
||||
#define _ForEachPrecisionTypeHelper(callback, cpp_type, precision_type) \
|
||||
callback(cpp_type, ::paddle::lite_api::PrecisionType::precision_type);
|
||||
|
||||
#define _ForEachPrecisionType(callback) \
|
||||
_ForEachPrecisionTypeHelper(callback, bool, kBool); \
|
||||
_ForEachPrecisionTypeHelper(callback, float, kFloat); \
|
||||
_ForEachPrecisionTypeHelper(callback, double, kFP64); \
|
||||
_ForEachPrecisionTypeHelper(callback, uint8_t, kUInt8); \
|
||||
_ForEachPrecisionTypeHelper(callback, int8_t, kInt8); \
|
||||
_ForEachPrecisionTypeHelper(callback, int16_t, kInt16); \
|
||||
_ForEachPrecisionTypeHelper(callback, int, kInt32); \
|
||||
_ForEachPrecisionTypeHelper(callback, int64_t, kInt64);
|
||||
|
||||
#define DefinePrecisionTypeTrait(cpp_type, precision_type) \
|
||||
template <> \
|
||||
struct PrecisionTypeTrait<cpp_type> { \
|
||||
constexpr static PrecisionType Type() { return precision_type; } \
|
||||
}
|
||||
|
||||
_ForEachPrecisionType(DefinePrecisionTypeTrait);
|
||||
|
||||
#ifdef ENABLE_ARM_FP16
|
||||
typedef __fp16 float16_t;
|
||||
_ForEachPrecisionTypeHelper(DefinePrecisionTypeTrait, float16_t, kFP16);
|
||||
#endif
|
||||
|
||||
#undef _ForEachPrecisionTypeHelper
|
||||
#undef _ForEachPrecisionType
|
||||
#undef DefinePrecisionTypeTrait
|
||||
|
||||
#define TARGET(item__) paddle::lite_api::TargetType::item__
|
||||
#define PRECISION(item__) paddle::lite_api::PrecisionType::item__
|
||||
#define DATALAYOUT(item__) paddle::lite_api::DataLayoutType::item__
|
||||
|
||||
const std::string& ActivationTypeToStr(ActivationType act);
|
||||
|
||||
const std::string& TargetToStr(TargetType target);
|
||||
|
||||
const std::string& PrecisionToStr(PrecisionType precision);
|
||||
|
||||
const std::string& DataLayoutToStr(DataLayoutType layout);
|
||||
|
||||
const std::string& TargetRepr(TargetType target);
|
||||
|
||||
const std::string& PrecisionRepr(PrecisionType precision);
|
||||
|
||||
const std::string& DataLayoutRepr(DataLayoutType layout);
|
||||
|
||||
const std::string& CLTuneModeToStr(CLTuneMode mode);
|
||||
|
||||
const std::string& CLPrecisionTypeToStr(CLPrecisionType type);
|
||||
|
||||
// Get a set of all the elements represented by the target.
|
||||
std::set<TargetType> ExpandValidTargets(TargetType target = TARGET(kAny));
|
||||
|
||||
// Get a set of all the elements represented by the precision.
|
||||
std::set<PrecisionType> ExpandValidPrecisions(
|
||||
PrecisionType precision = PRECISION(kAny));
|
||||
|
||||
// Get a set of all the elements represented by the layout.
|
||||
std::set<DataLayoutType> ExpandValidLayouts(
|
||||
DataLayoutType layout = DATALAYOUT(kAny));
|
||||
|
||||
/*
|
||||
* Place specifies the execution context of a Kernel or input/output for a
|
||||
* kernel. It is used to make the analysis of the MIR more clear and accurate.
|
||||
*/
|
||||
struct LITE_API Place {
|
||||
TargetType target{TARGET(kUnk)};
|
||||
PrecisionType precision{PRECISION(kUnk)};
|
||||
DataLayoutType layout{DATALAYOUT(kUnk)};
|
||||
int16_t device{0}; // device ID
|
||||
|
||||
Place() = default;
|
||||
Place(TargetType target,
|
||||
PrecisionType precision = PRECISION(kFloat),
|
||||
DataLayoutType layout = DATALAYOUT(kNCHW),
|
||||
int16_t device = 0)
|
||||
: target(target), precision(precision), layout(layout), device(device) {}
|
||||
|
||||
bool is_valid() const {
|
||||
return target != TARGET(kUnk) && precision != PRECISION(kUnk) &&
|
||||
layout != DATALAYOUT(kUnk);
|
||||
}
|
||||
|
||||
size_t hash() const;
|
||||
|
||||
bool operator==(const Place& other) const {
|
||||
return target == other.target && precision == other.precision &&
|
||||
layout == other.layout && device == other.device;
|
||||
}
|
||||
|
||||
bool operator!=(const Place& other) const { return !(*this == other); }
|
||||
|
||||
friend bool operator<(const Place& a, const Place& b);
|
||||
|
||||
std::string DebugString() const;
|
||||
};
|
||||
|
||||
} // namespace lite_api
|
||||
} // namespace paddle
|
||||
@@ -1,408 +0,0 @@
|
||||
#pragma once
|
||||
#include "paddle_lite_factory_helper.h"
|
||||
|
||||
USE_LITE_KERNEL(gather_nd, kHost, kAny, kAny, def);
|
||||
USE_LITE_KERNEL(relu_clipped, kARM, kFloat, kNCHW, def);
|
||||
USE_LITE_KERNEL(swish, kARM, kFloat, kNCHW, def);
|
||||
USE_LITE_KERNEL(log, kARM, kFloat, kNCHW, def);
|
||||
USE_LITE_KERNEL(exp, kARM, kFloat, kNCHW, def);
|
||||
USE_LITE_KERNEL(floor, kARM, kFloat, kNCHW, def);
|
||||
USE_LITE_KERNEL(hard_sigmoid, kARM, kFloat, kNCHW, def);
|
||||
USE_LITE_KERNEL(sqrt, kARM, kFloat, kNCHW, def);
|
||||
USE_LITE_KERNEL(rsqrt, kARM, kFloat, kNCHW, def);
|
||||
USE_LITE_KERNEL(square, kARM, kFloat, kNCHW, def);
|
||||
USE_LITE_KERNEL(hard_swish, kARM, kFloat, kNCHW, def);
|
||||
USE_LITE_KERNEL(reciprocal, kARM, kFloat, kNCHW, def);
|
||||
USE_LITE_KERNEL(abs, kARM, kFloat, kNCHW, def);
|
||||
USE_LITE_KERNEL(gelu, kARM, kFloat, kNCHW, def);
|
||||
USE_LITE_KERNEL(erf, kARM, kFloat, kNCHW, def);
|
||||
USE_LITE_KERNEL(sign, kARM, kFloat, kNCHW, def);
|
||||
USE_LITE_KERNEL(softplus, kARM, kFloat, kNCHW, def);
|
||||
USE_LITE_KERNEL(mish, kARM, kFloat, kNCHW, def);
|
||||
USE_LITE_KERNEL(pow, kARM, kFloat, kNCHW, def);
|
||||
USE_LITE_KERNEL(where, kHost, kAny, kAny, def);
|
||||
USE_LITE_KERNEL(assign_value, kHost, kAny, kNCHW, def);
|
||||
USE_LITE_KERNEL(tril_triu, kHost, kAny, kNCHW, float32);
|
||||
USE_LITE_KERNEL(lstm, kARM, kFloat, kNCHW, def);
|
||||
USE_LITE_KERNEL(lstm, kARM, kInt8, kNCHW, def);
|
||||
USE_LITE_KERNEL(split, kHost, kFloat, kNCHW, def);
|
||||
USE_LITE_KERNEL(split, kHost, kFloat, kNCHW, int32);
|
||||
USE_LITE_KERNEL(split, kHost, kFloat, kNCHW, int64);
|
||||
USE_LITE_KERNEL(split, kHost, kInt64, kNCHW, def);
|
||||
USE_LITE_KERNEL(gaussian_random, kHost, kFloat, kNCHW, def);
|
||||
USE_LITE_KERNEL(feed, kHost, kAny, kAny, def);
|
||||
USE_LITE_KERNEL(cos, kHost, kFloat, kNCHW, def);
|
||||
USE_LITE_KERNEL(conditional_block, kHost, kAny, kAny, def);
|
||||
USE_LITE_KERNEL(read_from_array, kHost, kAny, kAny, def);
|
||||
USE_LITE_KERNEL(deformable_conv, kHost, kFloat, kNCHW, def);
|
||||
USE_LITE_KERNEL(distribute_fpn_proposals, kHost, kFloat, kNCHW, def);
|
||||
USE_LITE_KERNEL(roi_align, kHost, kFloat, kNCHW, def);
|
||||
USE_LITE_KERNEL(one_hot, kHost, kAny, kAny, def);
|
||||
USE_LITE_KERNEL(one_hot_v2, kHost, kAny, kAny, def);
|
||||
USE_LITE_KERNEL(one_hot_v2, kHost, kAny, kAny, one_hot_v2_int32);
|
||||
USE_LITE_KERNEL(unique_with_counts, kHost, kAny, kAny, def);
|
||||
USE_LITE_KERNEL(arg_max, kARM, kAny, kNCHW, fp32);
|
||||
USE_LITE_KERNEL(arg_max, kARM, kAny, kNCHW, int64);
|
||||
USE_LITE_KERNEL(arg_max, kARM, kAny, kNCHW, int32);
|
||||
USE_LITE_KERNEL(arg_max, kARM, kAny, kNCHW, int16);
|
||||
USE_LITE_KERNEL(arg_max, kARM, kAny, kNCHW, uint8);
|
||||
USE_LITE_KERNEL(lod_array_length, kHost, kAny, kAny, def);
|
||||
USE_LITE_KERNEL(flip, kHost, kAny, kNCHW, flip_fp32);
|
||||
USE_LITE_KERNEL(flip, kHost, kAny, kNCHW, flip_i64);
|
||||
USE_LITE_KERNEL(reduce_all, kHost, kFloat, kNCHW, def);
|
||||
USE_LITE_KERNEL(reduce_any, kHost, kFloat, kNCHW, def);
|
||||
USE_LITE_KERNEL(stack, kHost, kFloat, kAny, def);
|
||||
USE_LITE_KERNEL(stack, kHost, kFloat, kAny, int32_def);
|
||||
USE_LITE_KERNEL(stack, kHost, kFloat, kAny, int64_def);
|
||||
USE_LITE_KERNEL(elementwise_add, kARM, kFloat, kNCHW, def);
|
||||
USE_LITE_KERNEL(elementwise_add, kARM, kInt32, kNCHW, def);
|
||||
USE_LITE_KERNEL(elementwise_add, kARM, kInt64, kNCHW, def);
|
||||
USE_LITE_KERNEL(elementwise_add, kARM, kFloat, kNCHW, int32);
|
||||
USE_LITE_KERNEL(elementwise_add, kARM, kFloat, kNCHW, int64);
|
||||
USE_LITE_KERNEL(fusion_elementwise_add_activation, kARM, kFloat, kNCHW, def);
|
||||
USE_LITE_KERNEL(elementwise_sub, kARM, kFloat, kNCHW, def);
|
||||
USE_LITE_KERNEL(elementwise_sub, kARM, kInt32, kNCHW, def);
|
||||
USE_LITE_KERNEL(elementwise_sub, kARM, kFloat, kNCHW, int32);
|
||||
USE_LITE_KERNEL(elementwise_sub, kARM, kFloat, kNCHW, int64);
|
||||
USE_LITE_KERNEL(fusion_elementwise_sub_activation, kARM, kFloat, kNCHW, def);
|
||||
USE_LITE_KERNEL(elementwise_mul, kARM, kFloat, kNCHW, def);
|
||||
USE_LITE_KERNEL(elementwise_mul, kARM, kInt32, kNCHW, def);
|
||||
USE_LITE_KERNEL(elementwise_mul, kARM, kInt64, kNCHW, def);
|
||||
USE_LITE_KERNEL(elementwise_mul, kARM, kFloat, kNCHW, int32);
|
||||
USE_LITE_KERNEL(elementwise_mul, kARM, kFloat, kNCHW, int64);
|
||||
USE_LITE_KERNEL(fusion_elementwise_mul_activation, kARM, kFloat, kNCHW, def);
|
||||
USE_LITE_KERNEL(fusion_elementwise_mul_activation, kARM, kInt64, kNCHW, def);
|
||||
USE_LITE_KERNEL(elementwise_max, kARM, kFloat, kNCHW, def);
|
||||
USE_LITE_KERNEL(fusion_elementwise_max_activation, kARM, kFloat, kNCHW, def);
|
||||
USE_LITE_KERNEL(elementwise_min, kARM, kFloat, kNCHW, def);
|
||||
USE_LITE_KERNEL(fusion_elementwise_min_activation, kARM, kFloat, kNCHW, def);
|
||||
USE_LITE_KERNEL(elementwise_div, kARM, kFloat, kNCHW, def);
|
||||
USE_LITE_KERNEL(elementwise_div, kARM, kInt32, kNCHW, def);
|
||||
USE_LITE_KERNEL(elementwise_div, kARM, kInt64, kNCHW, def);
|
||||
USE_LITE_KERNEL(fusion_elementwise_div_activation, kARM, kFloat, kNCHW, def);
|
||||
USE_LITE_KERNEL(elementwise_mod, kARM, kInt64, kNCHW, def);
|
||||
USE_LITE_KERNEL(elementwise_mod, kARM, kFloat, kNCHW, int64);
|
||||
USE_LITE_KERNEL(elementwise_mod, kARM, kFloat, kNCHW, int32_mod);
|
||||
USE_LITE_KERNEL(elementwise_pow, kARM, kFloat, kNCHW, def);
|
||||
USE_LITE_KERNEL(elementwise_pow, kARM, kInt32, kNCHW, def);
|
||||
USE_LITE_KERNEL(elementwise_floordiv, kARM, kInt32, kNCHW, def);
|
||||
USE_LITE_KERNEL(elementwise_floordiv, kARM, kInt64, kNCHW, def);
|
||||
USE_LITE_KERNEL(elementwise_floordiv, kARM, kFloat, kNCHW, def);
|
||||
USE_LITE_KERNEL(elementwise_floordiv, kARM, kFloat, kNCHW, int64);
|
||||
USE_LITE_KERNEL(softmax, kARM, kFloat, kNCHW, def);
|
||||
USE_LITE_KERNEL(prior_box, kHost, kFloat, kNCHW, def);
|
||||
USE_LITE_KERNEL(gru, kARM, kFloat, kNCHW, def);
|
||||
USE_LITE_KERNEL(gru, kARM, kInt8, kNCHW, def);
|
||||
USE_LITE_KERNEL(is_empty, kHost, kAny, kAny, def);
|
||||
USE_LITE_KERNEL(unsqueeze, kHost, kAny, kAny, def);
|
||||
USE_LITE_KERNEL(unsqueeze2, kHost, kAny, kAny, def);
|
||||
USE_LITE_KERNEL(sequence_expand_as, kARM, kFloat, kNCHW, def);
|
||||
USE_LITE_KERNEL(sequence_expand_as, kARM, kFloat, kNCHW, int32);
|
||||
USE_LITE_KERNEL(sequence_expand_as, kARM, kFloat, kNCHW, int64);
|
||||
USE_LITE_KERNEL(fill_constant_batch_size_like, kHost, kAny, kNCHW, def);
|
||||
USE_LITE_KERNEL(fill_zeros_like, kHost, kFloat, kNCHW, float32);
|
||||
USE_LITE_KERNEL(fill_zeros_like, kHost, kFloat, kNCHW, int32);
|
||||
USE_LITE_KERNEL(fill_zeros_like, kHost, kFloat, kNCHW, int64);
|
||||
USE_LITE_KERNEL(sum, kARM, kFloat, kNCHW, sum_i32);
|
||||
USE_LITE_KERNEL(sum, kARM, kFloat, kNCHW, sum_i64);
|
||||
USE_LITE_KERNEL(sum, kARM, kFloat, kNCHW, sum_fp32);
|
||||
USE_LITE_KERNEL(relu, kHost, kFloat, kNCHW, def);
|
||||
USE_LITE_KERNEL(leaky_relu, kHost, kFloat, kNCHW, def);
|
||||
USE_LITE_KERNEL(relu_clipped, kHost, kFloat, kNCHW, def);
|
||||
USE_LITE_KERNEL(prelu, kHost, kFloat, kNCHW, def);
|
||||
USE_LITE_KERNEL(sigmoid, kHost, kFloat, kNCHW, def);
|
||||
USE_LITE_KERNEL(tanh, kHost, kFloat, kNCHW, def);
|
||||
USE_LITE_KERNEL(swish, kHost, kFloat, kNCHW, def);
|
||||
USE_LITE_KERNEL(relu6, kHost, kFloat, kNCHW, def);
|
||||
USE_LITE_KERNEL(log, kHost, kFloat, kNCHW, def);
|
||||
USE_LITE_KERNEL(exp, kHost, kFloat, kNCHW, def);
|
||||
USE_LITE_KERNEL(floor, kHost, kFloat, kNCHW, def);
|
||||
USE_LITE_KERNEL(hard_sigmoid, kHost, kFloat, kNCHW, def);
|
||||
USE_LITE_KERNEL(rsqrt, kHost, kFloat, kNCHW, def);
|
||||
USE_LITE_KERNEL(square, kHost, kFloat, kNCHW, def);
|
||||
USE_LITE_KERNEL(hard_swish, kHost, kFloat, kNCHW, def);
|
||||
USE_LITE_KERNEL(reciprocal, kHost, kFloat, kNCHW, def);
|
||||
USE_LITE_KERNEL(abs, kHost, kFloat, kNCHW, def);
|
||||
USE_LITE_KERNEL(thresholded_relu, kHost, kFloat, kNCHW, def);
|
||||
USE_LITE_KERNEL(elu, kHost, kFloat, kNCHW, def);
|
||||
USE_LITE_KERNEL(softplus, kHost, kFloat, kNCHW, def);
|
||||
USE_LITE_KERNEL(reduce_mean, kARM, kFloat, kNCHW, def);
|
||||
USE_LITE_KERNEL(range, kHost, kFloat, kAny, def);
|
||||
USE_LITE_KERNEL(range, kHost, kInt64, kAny, def);
|
||||
USE_LITE_KERNEL(range, kHost, kInt32, kAny, def);
|
||||
USE_LITE_KERNEL(range, kHost, kFloat, kAny, int32);
|
||||
USE_LITE_KERNEL(range, kHost, kFloat, kAny, int64);
|
||||
USE_LITE_KERNEL(beam_search_decode, kHost, kFloat, kNCHW, def);
|
||||
USE_LITE_KERNEL(squeeze, kHost, kAny, kAny, def);
|
||||
USE_LITE_KERNEL(squeeze2, kHost, kAny, kAny, def);
|
||||
USE_LITE_KERNEL(group_norm, kARM, kFloat, kNCHW, def);
|
||||
USE_LITE_KERNEL(sequence_conv, kARM, kFloat, kNCHW, def);
|
||||
USE_LITE_KERNEL(write_to_array, kHost, kAny, kAny, def);
|
||||
USE_LITE_KERNEL(unstack, kHost, kFloat, kAny, def);
|
||||
USE_LITE_KERNEL(unstack, kHost, kFloat, kAny, unstack_int32);
|
||||
USE_LITE_KERNEL(generate_proposals_v2, kHost, kFloat, kNCHW, def);
|
||||
USE_LITE_KERNEL(layer_norm, kARM, kFloat, kNCHW, def);
|
||||
USE_LITE_KERNEL(crop_tensor, kHost, kFloat, kAny, def);
|
||||
USE_LITE_KERNEL(crop_tensor, kHost, kFloat, kAny, int32_precision);
|
||||
USE_LITE_KERNEL(sequence_mask, kHost, kFloat, kNCHW, def);
|
||||
USE_LITE_KERNEL(sequence_mask, kHost, kFloat, kNCHW, int32);
|
||||
USE_LITE_KERNEL(sequence_mask, kHost, kFloat, kNCHW, int64);
|
||||
USE_LITE_KERNEL(matrix_nms, kHost, kFloat, kNCHW, def);
|
||||
USE_LITE_KERNEL(reverse, kHost, kAny, kNCHW, fp32);
|
||||
USE_LITE_KERNEL(sequence_expand, kHost, kFloat, kNCHW, def);
|
||||
USE_LITE_KERNEL(sequence_expand, kHost, kFloat, kNCHW, int32);
|
||||
USE_LITE_KERNEL(sequence_expand, kHost, kFloat, kNCHW, int64);
|
||||
USE_LITE_KERNEL(reduce_prod, kARM, kInt32, kNCHW, def);
|
||||
USE_LITE_KERNEL(reduce_prod, kARM, kFloat, kNCHW, def);
|
||||
USE_LITE_KERNEL(reduce_prod, kARM, kFloat, kNCHW, reduce_prod_i64);
|
||||
USE_LITE_KERNEL(reduce_prod, kARM, kFloat, kNCHW, int32);
|
||||
USE_LITE_KERNEL(pad3d, kHost, kFloat, kNCHW, def);
|
||||
USE_LITE_KERNEL(cos_sim, kHost, kFloat, kNCHW, def);
|
||||
USE_LITE_KERNEL(relu, kARM, kFloat, kNCHW, def);
|
||||
USE_LITE_KERNEL(leaky_relu, kARM, kFloat, kNCHW, def);
|
||||
USE_LITE_KERNEL(prelu, kARM, kFloat, kNCHW, def);
|
||||
USE_LITE_KERNEL(sigmoid, kARM, kFloat, kNCHW, def);
|
||||
USE_LITE_KERNEL(tanh, kARM, kFloat, kNCHW, def);
|
||||
USE_LITE_KERNEL(relu6, kARM, kFloat, kNCHW, def);
|
||||
USE_LITE_KERNEL(thresholded_relu, kARM, kFloat, kNCHW, def);
|
||||
USE_LITE_KERNEL(elu, kARM, kFloat, kNCHW, def);
|
||||
USE_LITE_KERNEL(polygon_box_transform, kHost, kFloat, kNCHW, def);
|
||||
USE_LITE_KERNEL(unfold, kHost, kFloat, kNCHW, def);
|
||||
USE_LITE_KERNEL(unfold, kHost, kFloat, kNCHW, def_int32);
|
||||
USE_LITE_KERNEL(unfold, kHost, kFloat, kNCHW, def_int64);
|
||||
USE_LITE_KERNEL(unfold, kHost, kInt8, kNCHW, def_int8);
|
||||
USE_LITE_KERNEL(pixel_shuffle, kHost, kFloat, kNCHW, def);
|
||||
USE_LITE_KERNEL(increment, kHost, kAny, kNCHW, def);
|
||||
USE_LITE_KERNEL(ctc_align, kHost, kInt64, kNCHW, def);
|
||||
USE_LITE_KERNEL(ctc_align, kHost, kInt32, kNCHW, def);
|
||||
USE_LITE_KERNEL(instance_norm, kARM, kFloat, kNCHW, def);
|
||||
USE_LITE_KERNEL(linspace, kHost, kFloat, kAny, float32);
|
||||
USE_LITE_KERNEL(linspace, kHost, kInt32, kAny, int32);
|
||||
USE_LITE_KERNEL(print, kHost, kAny, kAny, def);
|
||||
USE_LITE_KERNEL(expand, kHost, kAny, kAny, def);
|
||||
USE_LITE_KERNEL(assign, kHost, kAny, kAny, def);
|
||||
USE_LITE_KERNEL(assign, kHost, kAny, kAny, def_tensor_array);
|
||||
USE_LITE_KERNEL(generate_proposals, kHost, kFloat, kNCHW, def);
|
||||
USE_LITE_KERNEL(lrn, kARM, kFloat, kNCHW, def);
|
||||
USE_LITE_KERNEL(cast, kHost, kAny, kNCHW, def);
|
||||
USE_LITE_KERNEL(log_softmax, kHost, kFloat, kNCHW, def);
|
||||
USE_LITE_KERNEL(beam_search, kHost, kFloat, kNCHW, def);
|
||||
USE_LITE_KERNEL(concat, kARM, kAny, kNCHW, def);
|
||||
USE_LITE_KERNEL(scatter, kARM, kFloat, kNCHW, ids_int64);
|
||||
USE_LITE_KERNEL(scatter, kARM, kFloat, kNCHW, ids_int32);
|
||||
USE_LITE_KERNEL(shuffle_channel, kHost, kFloat, kNCHW, def);
|
||||
USE_LITE_KERNEL(meshgrid, kHost, kFloat, kAny, float32);
|
||||
USE_LITE_KERNEL(meshgrid, kHost, kFloat, kAny, int32);
|
||||
USE_LITE_KERNEL(split_lod_tensor, kARM, kFloat, kNCHW, def);
|
||||
USE_LITE_KERNEL(pool2d, kARM, kFloat, kNCHW, def);
|
||||
USE_LITE_KERNEL(scale, kARM, kFloat, kNCHW, int32);
|
||||
USE_LITE_KERNEL(scale, kARM, kFloat, kNCHW, int64);
|
||||
USE_LITE_KERNEL(scale, kARM, kFloat, kNCHW, def);
|
||||
USE_LITE_KERNEL(scale, kARM, kInt32, kNCHW, def);
|
||||
USE_LITE_KERNEL(scale, kARM, kInt64, kNCHW, def);
|
||||
USE_LITE_KERNEL(transpose, kARM, kAny, kNCHW, def);
|
||||
USE_LITE_KERNEL(transpose2, kARM, kAny, kNCHW, def);
|
||||
USE_LITE_KERNEL(depthwise_conv2d_transpose, kARM, kFloat, kNCHW, def);
|
||||
USE_LITE_KERNEL(depthwise_conv2d_transpose, kARM, kInt8, kNCHW, fp32_out);
|
||||
USE_LITE_KERNEL(depthwise_conv2d_transpose, kARM, kInt8, kNCHW, int8_out);
|
||||
USE_LITE_KERNEL(grid_sampler, kARM, kFloat, kNCHW, def);
|
||||
USE_LITE_KERNEL(axpy, kARM, kFloat, kNCHW, def);
|
||||
USE_LITE_KERNEL(tensor_array_to_tensor, kHost, kAny, kNCHW, def);
|
||||
USE_LITE_KERNEL(merge_lod_tensor, kHost, kFloat, kNCHW, def);
|
||||
USE_LITE_KERNEL(reshape, kHost, kAny, kAny, def);
|
||||
USE_LITE_KERNEL(reshape2, kHost, kAny, kAny, def);
|
||||
USE_LITE_KERNEL(flatten, kHost, kAny, kAny, def);
|
||||
USE_LITE_KERNEL(flatten2, kHost, kAny, kAny, def);
|
||||
USE_LITE_KERNEL(sparse_conv2d, kARM, kFloat, kNCHW, def);
|
||||
USE_LITE_KERNEL(sparse_conv2d, kARM, kInt8, kNCHW, int8_fp32_out);
|
||||
USE_LITE_KERNEL(sparse_conv2d, kARM, kInt8, kNCHW, int8_int8_out);
|
||||
USE_LITE_KERNEL(lod_reset, kHost, kAny, kNCHW, def);
|
||||
USE_LITE_KERNEL(expand_as, kHost, kFloat, kAny, def);
|
||||
USE_LITE_KERNEL(expand_as, kHost, kFloat, kAny, int64);
|
||||
USE_LITE_KERNEL(calib, kARM, kInt8, kNCHW, fp32_to_int8);
|
||||
USE_LITE_KERNEL(calib, kARM, kInt32, kNCHW, int32_to_fp32);
|
||||
USE_LITE_KERNEL(calib, kARM, kInt32, kNCHW, int32_to_int64);
|
||||
USE_LITE_KERNEL(calib, kARM, kInt32, kNCHW, fp32_to_int32);
|
||||
USE_LITE_KERNEL(calib, kARM, kInt64, kNCHW, int64_to_fp32);
|
||||
USE_LITE_KERNEL(calib, kARM, kInt64, kNCHW, fp32_to_int64);
|
||||
USE_LITE_KERNEL(calib, kARM, kInt8, kNCHW, int8_to_fp32);
|
||||
USE_LITE_KERNEL(calib, kARM, kInt64, kNCHW, int64_to_int32);
|
||||
USE_LITE_KERNEL(calib_once, kARM, kInt8, kNCHW, fp32_to_int8);
|
||||
USE_LITE_KERNEL(calib_once, kARM, kInt8, kNCHW, int8_to_fp32);
|
||||
USE_LITE_KERNEL(calib_once, kARM, kInt64, kNCHW, int64_to_int32);
|
||||
USE_LITE_KERNEL(clip, kARM, kFloat, kNCHW, def);
|
||||
USE_LITE_KERNEL(select_input, kHost, kAny, kNCHW, def);
|
||||
USE_LITE_KERNEL(reduce_min, kARM, kFloat, kNCHW, def);
|
||||
USE_LITE_KERNEL(reduce_min, kARM, kFloat, kNCHW, def_int64);
|
||||
USE_LITE_KERNEL(sequence_pad, kHost, kFloat, kNCHW, def);
|
||||
USE_LITE_KERNEL(sequence_pad, kHost, kFloat, kNCHW, int32);
|
||||
USE_LITE_KERNEL(sequence_pad, kHost, kFloat, kNCHW, int64);
|
||||
USE_LITE_KERNEL(logical_xor, kHost, kAny, kAny, def);
|
||||
USE_LITE_KERNEL(logical_and, kHost, kAny, kAny, def);
|
||||
USE_LITE_KERNEL(logical_or, kHost, kAny, kAny, def);
|
||||
USE_LITE_KERNEL(logical_not, kHost, kAny, kAny, def);
|
||||
USE_LITE_KERNEL(fill_constant, kHost, kAny, kNCHW, def);
|
||||
USE_LITE_KERNEL(yolo_box, kHost, kFloat, kNCHW, def);
|
||||
USE_LITE_KERNEL(mean, kARM, kFloat, kNCHW, def);
|
||||
USE_LITE_KERNEL(collect_fpn_proposals, kHost, kFloat, kNCHW, def);
|
||||
USE_LITE_KERNEL(matmul_v2, kARM, kFloat, kNCHW, def);
|
||||
USE_LITE_KERNEL(matmul_v2, kARM, kInt8, kNCHW, def);
|
||||
USE_LITE_KERNEL(inverse, kHost, kFloat, kNCHW, fp32);
|
||||
USE_LITE_KERNEL(top_k, kHost, kFloat, kNCHW, def);
|
||||
USE_LITE_KERNEL(uniform_random, kHost, kAny, kAny, def);
|
||||
USE_LITE_KERNEL(matmul, kARM, kFloat, kNCHW, def);
|
||||
USE_LITE_KERNEL(matmul, kARM, kInt8, kNCHW, def);
|
||||
USE_LITE_KERNEL(norm, kHost, kFloat, kNCHW, def);
|
||||
USE_LITE_KERNEL(p_norm, kHost, kFloat, kNCHW, def);
|
||||
USE_LITE_KERNEL(sequence_unpad, kHost, kFloat, kAny, float32);
|
||||
USE_LITE_KERNEL(sequence_unpad, kHost, kFloat, kAny, int64);
|
||||
USE_LITE_KERNEL(where_index, kHost, kAny, kAny, def);
|
||||
USE_LITE_KERNEL(layout, kARM, kFloat, kNCHW, nchw2nhwc);
|
||||
USE_LITE_KERNEL(layout, kARM, kFloat, kNCHW, nhwc2nchw);
|
||||
USE_LITE_KERNEL(layout, kARM, kInt8, kNCHW, int8_nchw2nhwc);
|
||||
USE_LITE_KERNEL(layout, kARM, kInt8, kNCHW, int8_nhwc2nchw);
|
||||
USE_LITE_KERNEL(layout_once, kARM, kFloat, kNCHW, nchw2nhwc);
|
||||
USE_LITE_KERNEL(layout_once, kARM, kFloat, kNCHW, nhwc2nchw);
|
||||
USE_LITE_KERNEL(layout_once, kARM, kInt8, kNCHW, int8_nchw2nhwc);
|
||||
USE_LITE_KERNEL(layout_once, kARM, kInt8, kNCHW, int8_nhwc2nchw);
|
||||
USE_LITE_KERNEL(crop, kHost, kFloat, kAny, def);
|
||||
USE_LITE_KERNEL(crop, kHost, kInt32, kAny, def);
|
||||
USE_LITE_KERNEL(pad2d, kARM, kFloat, kNCHW, def);
|
||||
USE_LITE_KERNEL(argsort, kHost, kFloat, kAny, argsort_fp32);
|
||||
USE_LITE_KERNEL(argsort, kHost, kFloat, kAny, argsort_int32);
|
||||
USE_LITE_KERNEL(argsort, kHost, kFloat, kAny, argsort_int64);
|
||||
USE_LITE_KERNEL(equal, kHost, kFloat, kAny, def);
|
||||
USE_LITE_KERNEL(equal, kHost, kInt64, kAny, def);
|
||||
USE_LITE_KERNEL(equal, kHost, kFloat, kAny, int64);
|
||||
USE_LITE_KERNEL(equal, kHost, kInt32, kAny, def);
|
||||
USE_LITE_KERNEL(equal, kHost, kFloat, kAny, int32);
|
||||
USE_LITE_KERNEL(not_equal, kHost, kFloat, kAny, def);
|
||||
USE_LITE_KERNEL(not_equal, kHost, kFloat, kAny, int32);
|
||||
USE_LITE_KERNEL(not_equal, kHost, kFloat, kAny, int64);
|
||||
USE_LITE_KERNEL(less_than, kHost, kFloat, kAny, def);
|
||||
USE_LITE_KERNEL(less_than, kHost, kInt32, kAny, def);
|
||||
USE_LITE_KERNEL(less_than, kHost, kFloat, kAny, int32);
|
||||
USE_LITE_KERNEL(less_than, kHost, kInt64, kAny, def);
|
||||
USE_LITE_KERNEL(less_than, kHost, kFloat, kAny, int64);
|
||||
USE_LITE_KERNEL(less_equal, kHost, kFloat, kAny, def);
|
||||
USE_LITE_KERNEL(less_equal, kHost, kInt64, kAny, def);
|
||||
USE_LITE_KERNEL(less_equal, kHost, kFloat, kAny, int64);
|
||||
USE_LITE_KERNEL(less_equal, kHost, kFloat, kAny, int32);
|
||||
USE_LITE_KERNEL(greater_than, kHost, kFloat, kAny, def);
|
||||
USE_LITE_KERNEL(greater_than, kHost, kFloat, kAny, def_bool);
|
||||
USE_LITE_KERNEL(greater_than, kHost, kFloat, kAny, def_int32);
|
||||
USE_LITE_KERNEL(greater_than, kHost, kInt64, kAny, def);
|
||||
USE_LITE_KERNEL(greater_than, kHost, kFloat, kAny, def_int64);
|
||||
USE_LITE_KERNEL(greater_equal, kHost, kFloat, kAny, def);
|
||||
USE_LITE_KERNEL(greater_equal, kHost, kFloat, kAny, def_int64);
|
||||
USE_LITE_KERNEL(greater_equal, kHost, kFloat, kAny, def_int32);
|
||||
USE_LITE_KERNEL(sampling_id, kHost, kAny, kAny, float32);
|
||||
USE_LITE_KERNEL(pixel_shuffle, kARM, kFloat, kNCHW, def);
|
||||
USE_LITE_KERNEL(arg_max, kHost, kAny, kNCHW, fp32);
|
||||
USE_LITE_KERNEL(arg_max, kHost, kAny, kNCHW, int64);
|
||||
USE_LITE_KERNEL(arg_max, kHost, kAny, kNCHW, int32);
|
||||
USE_LITE_KERNEL(arg_max, kHost, kAny, kNCHW, int16);
|
||||
USE_LITE_KERNEL(arg_max, kHost, kAny, kNCHW, uint8);
|
||||
USE_LITE_KERNEL(anchor_generator, kHost, kFloat, kNCHW, def);
|
||||
USE_LITE_KERNEL(write_back, kHost, kAny, kAny, write_back);
|
||||
USE_LITE_KERNEL(correlation, kHost, kFloat, kNCHW, def);
|
||||
USE_LITE_KERNEL(im2sequence, kHost, kFloat, kNCHW, def);
|
||||
USE_LITE_KERNEL(batch_norm, kARM, kFloat, kNCHW, def);
|
||||
USE_LITE_KERNEL(sync_batch_norm, kARM, kFloat, kNCHW, def);
|
||||
USE_LITE_KERNEL(gather_tree, kHost, kFloat, kAny, int32);
|
||||
USE_LITE_KERNEL(gather_tree, kHost, kFloat, kAny, int64);
|
||||
USE_LITE_KERNEL(flatten_contiguous_range, kHost, kAny, kAny, def);
|
||||
USE_LITE_KERNEL(lookup_table, kARM, kAny, kNCHW, def);
|
||||
USE_LITE_KERNEL(lookup_table_v2, kARM, kAny, kNCHW, def);
|
||||
USE_LITE_KERNEL(top_k_v2, kHost, kFloat, kNCHW, def);
|
||||
USE_LITE_KERNEL(box_clip, kHost, kFloat, kNCHW, def);
|
||||
USE_LITE_KERNEL(box_coder, kHost, kFloat, kNCHW, def);
|
||||
USE_LITE_KERNEL(conv2d_transpose, kARM, kFloat, kNCHW, def);
|
||||
USE_LITE_KERNEL(conv2d_transpose, kARM, kInt8, kNCHW, fp32_out);
|
||||
USE_LITE_KERNEL(conv2d_transpose, kARM, kInt8, kNCHW, int8_out);
|
||||
USE_LITE_KERNEL(unbind, kHost, kFloat, kNCHW, def);
|
||||
USE_LITE_KERNEL(unbind, kHost, kFloat, kNCHW, def_int64);
|
||||
USE_LITE_KERNEL(shape, kHost, kAny, kAny, def);
|
||||
USE_LITE_KERNEL(bilinear_interp, kARM, kFloat, kNCHW, def);
|
||||
USE_LITE_KERNEL(nearest_interp, kARM, kFloat, kNCHW, def);
|
||||
USE_LITE_KERNEL(bilinear_interp_v2, kARM, kFloat, kNCHW, def);
|
||||
USE_LITE_KERNEL(nearest_interp_v2, kARM, kFloat, kNCHW, def);
|
||||
USE_LITE_KERNEL(conv2d, kARM, kFloat, kNCHW, def);
|
||||
USE_LITE_KERNEL(depthwise_conv2d, kARM, kFloat, kNCHW, def);
|
||||
USE_LITE_KERNEL(conv2d, kARM, kInt8, kNCHW, int8_out);
|
||||
USE_LITE_KERNEL(conv2d, kARM, kInt8, kNCHW, fp32_out);
|
||||
USE_LITE_KERNEL(depthwise_conv2d, kARM, kInt8, kNCHW, int8_out);
|
||||
USE_LITE_KERNEL(depthwise_conv2d, kARM, kInt8, kNCHW, fp32_out);
|
||||
USE_LITE_KERNEL(reduce_max, kARM, kFloat, kNCHW, def);
|
||||
USE_LITE_KERNEL(reduce_max, kARM, kFloat, kNCHW, i64);
|
||||
USE_LITE_KERNEL(index_select, kHost, kAny, kNCHW, fp32);
|
||||
USE_LITE_KERNEL(index_select, kHost, kAny, kNCHW, int32);
|
||||
USE_LITE_KERNEL(index_select, kHost, kAny, kNCHW, int16);
|
||||
USE_LITE_KERNEL(index_select, kHost, kAny, kNCHW, int8);
|
||||
USE_LITE_KERNEL(affine_grid, kARM, kFloat, kNCHW, def);
|
||||
USE_LITE_KERNEL(sequence_pool, kARM, kFloat, kNCHW, def);
|
||||
USE_LITE_KERNEL(rnn, kARM, kFloat, kNCHW, def);
|
||||
USE_LITE_KERNEL(negative, kARM, kFloat, kNCHW, def);
|
||||
USE_LITE_KERNEL(gru_unit, kARM, kFloat, kNCHW, def);
|
||||
USE_LITE_KERNEL(fetch, kHost, kAny, kAny, def);
|
||||
USE_LITE_KERNEL(density_prior_box, kHost, kFloat, kNCHW, def);
|
||||
USE_LITE_KERNEL(scatter_nd_add, kHost, kFloat, kNCHW, def);
|
||||
USE_LITE_KERNEL(scatter_nd_add, kHost, kFloat, kNCHW, float32_int64);
|
||||
USE_LITE_KERNEL(scatter_nd_add, kHost, kFloat, kNCHW, int32_int32);
|
||||
USE_LITE_KERNEL(scatter_nd_add, kHost, kFloat, kNCHW, int32_int64);
|
||||
USE_LITE_KERNEL(scatter_nd_add, kHost, kFloat, kNCHW, int64_int32);
|
||||
USE_LITE_KERNEL(scatter_nd_add, kHost, kFloat, kNCHW, int64_int64);
|
||||
USE_LITE_KERNEL(roi_perspective_transform, kHost, kFloat, kNCHW, def);
|
||||
USE_LITE_KERNEL(while, kHost, kAny, kAny, def);
|
||||
USE_LITE_KERNEL(strided_slice, kHost, kFloat, kNCHW, def);
|
||||
USE_LITE_KERNEL(strided_slice, kHost, kFloat, kNCHW, def_int32);
|
||||
USE_LITE_KERNEL(strided_slice, kHost, kFloat, kNCHW, def_int64);
|
||||
USE_LITE_KERNEL(multiclass_nms, kHost, kFloat, kNCHW, def);
|
||||
USE_LITE_KERNEL(multiclass_nms2, kHost, kFloat, kNCHW, def);
|
||||
USE_LITE_KERNEL(multiclass_nms3, kHost, kFloat, kNCHW, def);
|
||||
USE_LITE_KERNEL(mul, kARM, kFloat, kNCHW, def);
|
||||
USE_LITE_KERNEL(mul, kARM, kInt8, kNCHW, def);
|
||||
USE_LITE_KERNEL(gather, kHost, kFloat, kNCHW, int32int32);
|
||||
USE_LITE_KERNEL(gather, kHost, kFloat, kNCHW, int64int64);
|
||||
USE_LITE_KERNEL(gather, kHost, kFloat, kNCHW, int64int32);
|
||||
USE_LITE_KERNEL(gather, kHost, kFloat, kNCHW, int32int64);
|
||||
USE_LITE_KERNEL(sequence_softmax, kHost, kFloat, kNCHW, def);
|
||||
USE_LITE_KERNEL(tile, kHost, kFloat, kNCHW, def_float);
|
||||
USE_LITE_KERNEL(tile, kHost, kFloat, kNCHW, def_int32);
|
||||
USE_LITE_KERNEL(tile, kHost, kFloat, kNCHW, def_int64);
|
||||
USE_LITE_KERNEL(tile, kHost, kFloat, kNCHW, def_int8);
|
||||
USE_LITE_KERNEL(tile, kHost, kFloat, kNCHW, def_bool);
|
||||
USE_LITE_KERNEL(decode_bboxes, kARM, kFloat, kNCHW, def);
|
||||
USE_LITE_KERNEL(slice, kARM, kFloat, kNCHW, def);
|
||||
USE_LITE_KERNEL(slice, kARM, kFloat, kNCHW, array_def);
|
||||
USE_LITE_KERNEL(slice, kARM, kFloat, kNCHW, float_i64_starts_ends);
|
||||
USE_LITE_KERNEL(slice, kARM, kFloat, kNCHW, array_float_i64_starts_ends);
|
||||
USE_LITE_KERNEL(slice, kARM, kFloat, kNCHW, bool_slice);
|
||||
USE_LITE_KERNEL(slice, kARM, kFloat, kNCHW, array_bool_slice);
|
||||
USE_LITE_KERNEL(slice, kARM, kFloat, kNCHW, int32_slice);
|
||||
USE_LITE_KERNEL(slice, kARM, kFloat, kNCHW, array_int32_slice);
|
||||
USE_LITE_KERNEL(slice, kARM, kFloat, kNCHW, def_int64);
|
||||
USE_LITE_KERNEL(slice, kARM, kFloat, kNCHW, array_def_int64);
|
||||
USE_LITE_KERNEL(dropout, kARM, kFloat, kNCHW, def);
|
||||
USE_LITE_KERNEL(fill_any_like, kHost, kAny, kNCHW, def);
|
||||
USE_LITE_KERNEL(fill_zeros_like, kHost, kAny, kNCHW, def);
|
||||
USE_LITE_KERNEL(max_pool2d_with_index, kHost, kFloat, kNCHW, fp32);
|
||||
USE_LITE_KERNEL(pad2d, kHost, kFloat, kNCHW, def);
|
||||
USE_LITE_KERNEL(deformable_conv, kARM, kFloat, kNCHW, def);
|
||||
USE_LITE_KERNEL(reduce_sum, kARM, kFloat, kNCHW, def_int32);
|
||||
USE_LITE_KERNEL(reduce_sum, kARM, kFloat, kNCHW, def);
|
||||
USE_LITE_KERNEL(expand_v2, kHost, kFloat, kAny, def);
|
||||
USE_LITE_KERNEL(expand_v2, kHost, kFloat, kAny, def_int32);
|
||||
USE_LITE_KERNEL(expand_v2, kHost, kFloat, kAny, def_int64);
|
||||
USE_LITE_KERNEL(affine_channel, kARM, kFloat, kNCHW, def);
|
||||
USE_LITE_KERNEL(crf_decoding, kHost, kFloat, kNCHW, def);
|
||||
USE_LITE_KERNEL(cumsum, kHost, kFloat, kAny, float32);
|
||||
USE_LITE_KERNEL(cumsum, kHost, kFloat, kAny, int32);
|
||||
USE_LITE_KERNEL(cumsum, kHost, kFloat, kAny, int64);
|
||||
USE_LITE_KERNEL(lookup_table_dequant, kARM, kAny, kNCHW, def);
|
||||
USE_LITE_KERNEL(box_coder, kARM, kFloat, kNCHW, def);
|
||||
USE_LITE_KERNEL(sin, kHost, kFloat, kNCHW, def);
|
||||
USE_LITE_KERNEL(fc, kARM, kFloat, kNCHW, def);
|
||||
USE_LITE_KERNEL(fc, kARM, kInt8, kNCHW, int8out);
|
||||
USE_LITE_KERNEL(fc, kARM, kInt8, kNCHW, fp32out);
|
||||
USE_LITE_KERNEL(retinanet_detection_output, kHost, kFloat, kNCHW, def);
|
||||
@@ -1,284 +0,0 @@
|
||||
#pragma once
|
||||
#include "paddle_lite_factory_helper.h"
|
||||
|
||||
USE_LITE_OP(__xpu__logit);
|
||||
USE_LITE_OP(mean);
|
||||
USE_LITE_OP(uniform_random);
|
||||
USE_LITE_OP(equal);
|
||||
USE_LITE_OP(not_equal);
|
||||
USE_LITE_OP(less_than);
|
||||
USE_LITE_OP(less_equal);
|
||||
USE_LITE_OP(greater_than);
|
||||
USE_LITE_OP(greater_equal);
|
||||
USE_LITE_OP(fake_quantize_moving_average_abs_max);
|
||||
USE_LITE_OP(matrix_nms);
|
||||
USE_LITE_OP(lrn);
|
||||
USE_LITE_OP(axpy);
|
||||
USE_LITE_OP(inverse);
|
||||
USE_LITE_OP(scatter);
|
||||
USE_LITE_OP(__xpu__multi_encoder);
|
||||
USE_LITE_OP(gaussian_random);
|
||||
USE_LITE_OP(affine_grid);
|
||||
USE_LITE_OP(roi_align);
|
||||
USE_LITE_OP(range);
|
||||
USE_LITE_OP(sequence_topk_avg_pooling);
|
||||
USE_LITE_OP(search_group_padding);
|
||||
USE_LITE_OP(__xpu__embedding_with_eltwise_add);
|
||||
USE_LITE_OP(fake_dequantize_max_abs);
|
||||
USE_LITE_OP(strided_slice);
|
||||
USE_LITE_OP(lookup_table_dequant);
|
||||
USE_LITE_OP(sum);
|
||||
USE_LITE_OP(tile);
|
||||
USE_LITE_OP(fake_quantize_dequantize_moving_average_abs_max);
|
||||
USE_LITE_OP(search_grnn);
|
||||
USE_LITE_OP(density_prior_box);
|
||||
USE_LITE_OP(atan);
|
||||
USE_LITE_OP(lstm);
|
||||
USE_LITE_OP(fc);
|
||||
USE_LITE_OP(im2sequence);
|
||||
USE_LITE_OP(__xpu__softmax_topk);
|
||||
USE_LITE_OP(multiclass_nms);
|
||||
USE_LITE_OP(multiclass_nms2);
|
||||
USE_LITE_OP(multiclass_nms3);
|
||||
USE_LITE_OP(box_coder);
|
||||
USE_LITE_OP(sequence_reshape);
|
||||
USE_LITE_OP(sequence_conv);
|
||||
USE_LITE_OP(deformable_conv);
|
||||
USE_LITE_OP(search_aligned_mat_mul);
|
||||
USE_LITE_OP(search_fc);
|
||||
USE_LITE_OP(pad3d);
|
||||
USE_LITE_OP(dropout);
|
||||
USE_LITE_OP(calib);
|
||||
USE_LITE_OP(instance_norm);
|
||||
USE_LITE_OP(nearest_interp);
|
||||
USE_LITE_OP(bilinear_interp);
|
||||
USE_LITE_OP(stack);
|
||||
USE_LITE_OP(search_seq_depadding);
|
||||
USE_LITE_OP(cumsum);
|
||||
USE_LITE_OP(gather);
|
||||
USE_LITE_OP(sequence_unpad);
|
||||
USE_LITE_OP(pool2d);
|
||||
USE_LITE_OP(search_seq_softmax);
|
||||
USE_LITE_OP(feed);
|
||||
USE_LITE_OP(generate_proposals_v2);
|
||||
USE_LITE_OP(calib_once);
|
||||
USE_LITE_OP(pow);
|
||||
USE_LITE_OP(unstack);
|
||||
USE_LITE_OP(flip);
|
||||
USE_LITE_OP(lod_reset);
|
||||
USE_LITE_OP(beam_search_decode);
|
||||
USE_LITE_OP(io_copy_once);
|
||||
USE_LITE_OP(negative);
|
||||
USE_LITE_OP(tan);
|
||||
USE_LITE_OP(beam_search);
|
||||
USE_LITE_OP(scatter_nd_add);
|
||||
USE_LITE_OP(expand);
|
||||
USE_LITE_OP(affine_channel);
|
||||
USE_LITE_OP(sequence_mask);
|
||||
USE_LITE_OP(argsort);
|
||||
USE_LITE_OP(top_k);
|
||||
USE_LITE_OP(__xpu__fc);
|
||||
USE_LITE_OP(fill_constant_batch_size_like);
|
||||
USE_LITE_OP(unsqueeze);
|
||||
USE_LITE_OP(unsqueeze2);
|
||||
USE_LITE_OP(split);
|
||||
USE_LITE_OP(attention_padding_mask);
|
||||
USE_LITE_OP(search_attention_padding_mask);
|
||||
USE_LITE_OP(fake_quantize_range_abs_max);
|
||||
USE_LITE_OP(fake_quantize_abs_max);
|
||||
USE_LITE_OP(__xpu__multi_softmax);
|
||||
USE_LITE_OP(one_hot);
|
||||
USE_LITE_OP(max_pool2d_with_index);
|
||||
USE_LITE_OP(sin);
|
||||
USE_LITE_OP(while);
|
||||
USE_LITE_OP(ctc_align);
|
||||
USE_LITE_OP(reshape);
|
||||
USE_LITE_OP(reshape2);
|
||||
USE_LITE_OP(sequence_concat);
|
||||
USE_LITE_OP(fill_constant);
|
||||
USE_LITE_OP(flatten);
|
||||
USE_LITE_OP(flatten2);
|
||||
USE_LITE_OP(flatten_contiguous_range);
|
||||
USE_LITE_OP(is_empty);
|
||||
USE_LITE_OP(retinanet_detection_output);
|
||||
USE_LITE_OP(elementwise_sub);
|
||||
USE_LITE_OP(elementwise_add);
|
||||
USE_LITE_OP(elementwise_mul);
|
||||
USE_LITE_OP(elementwise_max);
|
||||
USE_LITE_OP(elementwise_min);
|
||||
USE_LITE_OP(elementwise_div);
|
||||
USE_LITE_OP(elementwise_floordiv);
|
||||
USE_LITE_OP(elementwise_mod);
|
||||
USE_LITE_OP(elementwise_pow);
|
||||
USE_LITE_OP(sequence_softmax);
|
||||
USE_LITE_OP(reduce_sum);
|
||||
USE_LITE_OP(reduce_prod);
|
||||
USE_LITE_OP(reduce_max);
|
||||
USE_LITE_OP(reduce_min);
|
||||
USE_LITE_OP(reduce_all);
|
||||
USE_LITE_OP(reduce_any);
|
||||
USE_LITE_OP(reduce_mean);
|
||||
USE_LITE_OP(__xpu__conv2d);
|
||||
USE_LITE_OP(lod_array_length);
|
||||
USE_LITE_OP(var_conv_2d);
|
||||
USE_LITE_OP(print);
|
||||
USE_LITE_OP(shuffle_channel);
|
||||
USE_LITE_OP(square);
|
||||
USE_LITE_OP(relu_clipped);
|
||||
USE_LITE_OP(swish);
|
||||
USE_LITE_OP(log);
|
||||
USE_LITE_OP(exp);
|
||||
USE_LITE_OP(abs);
|
||||
USE_LITE_OP(floor);
|
||||
USE_LITE_OP(hard_sigmoid);
|
||||
USE_LITE_OP(sqrt);
|
||||
USE_LITE_OP(rsqrt);
|
||||
USE_LITE_OP(softsign);
|
||||
USE_LITE_OP(gelu);
|
||||
USE_LITE_OP(hard_swish);
|
||||
USE_LITE_OP(reciprocal);
|
||||
USE_LITE_OP(mish);
|
||||
USE_LITE_OP(sigmoid);
|
||||
USE_LITE_OP(tanh);
|
||||
USE_LITE_OP(relu);
|
||||
USE_LITE_OP(leaky_relu);
|
||||
USE_LITE_OP(relu6);
|
||||
USE_LITE_OP(prelu);
|
||||
USE_LITE_OP(thresholded_relu);
|
||||
USE_LITE_OP(elu);
|
||||
USE_LITE_OP(erf);
|
||||
USE_LITE_OP(softplus);
|
||||
USE_LITE_OP(fusion_elementwise_sub_activation);
|
||||
USE_LITE_OP(fusion_elementwise_add_activation);
|
||||
USE_LITE_OP(fusion_elementwise_mul_activation);
|
||||
USE_LITE_OP(fusion_elementwise_max_activation);
|
||||
USE_LITE_OP(fusion_elementwise_min_activation);
|
||||
USE_LITE_OP(fusion_elementwise_div_activation);
|
||||
USE_LITE_OP(assign);
|
||||
USE_LITE_OP(correlation);
|
||||
USE_LITE_OP(arg_max);
|
||||
USE_LITE_OP(sign);
|
||||
USE_LITE_OP(read_from_array);
|
||||
USE_LITE_OP(logical_xor);
|
||||
USE_LITE_OP(logical_and);
|
||||
USE_LITE_OP(logical_or);
|
||||
USE_LITE_OP(logical_not);
|
||||
USE_LITE_OP(box_clip);
|
||||
USE_LITE_OP(dequantize_linear);
|
||||
USE_LITE_OP(softmax);
|
||||
USE_LITE_OP(__xpu__resnet50);
|
||||
USE_LITE_OP(transpose);
|
||||
USE_LITE_OP(transpose2);
|
||||
USE_LITE_OP(tensor_array_to_tensor);
|
||||
USE_LITE_OP(io_copy);
|
||||
USE_LITE_OP(sparse_conv2d);
|
||||
USE_LITE_OP(gather_tree);
|
||||
USE_LITE_OP(fake_channel_wise_quantize_dequantize_abs_max);
|
||||
USE_LITE_OP(increment);
|
||||
USE_LITE_OP(batch_norm);
|
||||
USE_LITE_OP(sync_batch_norm);
|
||||
USE_LITE_OP(pad2d);
|
||||
USE_LITE_OP(lookup_table_v2);
|
||||
USE_LITE_OP(unbind);
|
||||
USE_LITE_OP(distribute_fpn_proposals);
|
||||
USE_LITE_OP(fake_quantize_dequantize_abs_max);
|
||||
USE_LITE_OP(sampling_id);
|
||||
USE_LITE_OP(fpga_conv2d);
|
||||
USE_LITE_OP(index_select);
|
||||
USE_LITE_OP(match_matrix_tensor);
|
||||
USE_LITE_OP(where_index);
|
||||
USE_LITE_OP(sequence_expand_as);
|
||||
USE_LITE_OP(acos);
|
||||
USE_LITE_OP(one_hot_v2);
|
||||
USE_LITE_OP(search_seq_fc);
|
||||
USE_LITE_OP(expand_v2);
|
||||
USE_LITE_OP(topk_pooling);
|
||||
USE_LITE_OP(squeeze);
|
||||
USE_LITE_OP(squeeze2);
|
||||
USE_LITE_OP(sequence_reverse_embedding);
|
||||
USE_LITE_OP(assign_value);
|
||||
USE_LITE_OP(log_softmax);
|
||||
USE_LITE_OP(reverse);
|
||||
USE_LITE_OP(grid_sampler);
|
||||
USE_LITE_OP(bilinear_interp_v2);
|
||||
USE_LITE_OP(nearest_interp_v2);
|
||||
USE_LITE_OP(fill_zeros_like);
|
||||
USE_LITE_OP(sequence_pad);
|
||||
USE_LITE_OP(cos_sim);
|
||||
USE_LITE_OP(layout_once);
|
||||
USE_LITE_OP(subgraph);
|
||||
USE_LITE_OP(gru_unit);
|
||||
USE_LITE_OP(unfold);
|
||||
USE_LITE_OP(slice);
|
||||
USE_LITE_OP(split_lod_tensor);
|
||||
USE_LITE_OP(concat);
|
||||
USE_LITE_OP(anchor_generator);
|
||||
USE_LITE_OP(tril_triu);
|
||||
USE_LITE_OP(conditional_block);
|
||||
USE_LITE_OP(sequence_arithmetic);
|
||||
USE_LITE_OP(search_seq_arithmetic);
|
||||
USE_LITE_OP(unique_with_counts);
|
||||
USE_LITE_OP(group_norm);
|
||||
USE_LITE_OP(yolo_box);
|
||||
USE_LITE_OP(shape);
|
||||
USE_LITE_OP(matmul_v2);
|
||||
USE_LITE_OP(sequence_expand);
|
||||
USE_LITE_OP(cos);
|
||||
USE_LITE_OP(crop);
|
||||
USE_LITE_OP(layer_norm);
|
||||
USE_LITE_OP(asin);
|
||||
USE_LITE_OP(sequence_reverse);
|
||||
USE_LITE_OP(fetch);
|
||||
USE_LITE_OP(linspace);
|
||||
USE_LITE_OP(fake_channel_wise_dequantize_max_abs);
|
||||
USE_LITE_OP(rnn);
|
||||
USE_LITE_OP(__xpu__mmdnn_bid_emb_grnn_att);
|
||||
USE_LITE_OP(__xpu__mmdnn_bid_emb_grnn_att2);
|
||||
USE_LITE_OP(__xpu__mmdnn_bid_emb_att);
|
||||
USE_LITE_OP(__xpu__mmdnn_match_conv_topk);
|
||||
USE_LITE_OP(__xpu__mmdnn_merge_all);
|
||||
USE_LITE_OP(write_to_array);
|
||||
USE_LITE_OP(write_back);
|
||||
USE_LITE_OP(__xpu__sfa_head);
|
||||
USE_LITE_OP(collect_fpn_proposals);
|
||||
USE_LITE_OP(pixel_shuffle);
|
||||
USE_LITE_OP(generate_proposals);
|
||||
USE_LITE_OP(where);
|
||||
USE_LITE_OP(lookup_table);
|
||||
USE_LITE_OP(prior_box);
|
||||
USE_LITE_OP(sequence_pool_concat);
|
||||
USE_LITE_OP(conv2d);
|
||||
USE_LITE_OP(conv3d);
|
||||
USE_LITE_OP(depthwise_conv2d);
|
||||
USE_LITE_OP(polygon_box_transform);
|
||||
USE_LITE_OP(scale);
|
||||
USE_LITE_OP(roi_perspective_transform);
|
||||
USE_LITE_OP(crop_tensor);
|
||||
USE_LITE_OP(gather_nd);
|
||||
USE_LITE_OP(fill_any_like);
|
||||
USE_LITE_OP(cast);
|
||||
USE_LITE_OP(mul);
|
||||
USE_LITE_OP(quantize_linear);
|
||||
USE_LITE_OP(gru);
|
||||
USE_LITE_OP(meshgrid);
|
||||
USE_LITE_OP(__xpu__mmdnn_search_attention);
|
||||
USE_LITE_OP(__xpu__mmdnn_search_attention2);
|
||||
USE_LITE_OP(__xpu__generate_sequence);
|
||||
USE_LITE_OP(__xpu__squeeze_excitation_block);
|
||||
USE_LITE_OP(decode_bboxes);
|
||||
USE_LITE_OP(matmul);
|
||||
USE_LITE_OP(__xpu__resnet_cbam);
|
||||
USE_LITE_OP(clip);
|
||||
USE_LITE_OP(top_k_v2);
|
||||
USE_LITE_OP(__xpu__dynamic_lstm_fuse_op);
|
||||
USE_LITE_OP(norm);
|
||||
USE_LITE_OP(p_norm);
|
||||
USE_LITE_OP(crf_decoding);
|
||||
USE_LITE_OP(layout);
|
||||
USE_LITE_OP(sequence_pool);
|
||||
USE_LITE_OP(__xpu__bigru);
|
||||
USE_LITE_OP(select_input);
|
||||
USE_LITE_OP(conv2d_transpose);
|
||||
USE_LITE_OP(depthwise_conv2d_transpose);
|
||||
USE_LITE_OP(merge_lod_tensor);
|
||||
USE_LITE_OP(expand_as);
|
||||
@@ -1,120 +0,0 @@
|
||||
// Copyright (c) 2019 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 "paddle_lite_factory_helper.h" // NOLINT
|
||||
|
||||
USE_MIR_PASS(demo);
|
||||
USE_MIR_PASS(static_kernel_pick_pass);
|
||||
USE_MIR_PASS(lite_unsqueeze2_pad3d_squeeze2_fuse_pass);
|
||||
USE_MIR_PASS(op_transformation_pass);
|
||||
USE_MIR_PASS(variable_place_inference_pass);
|
||||
USE_MIR_PASS(type_target_cast_pass);
|
||||
USE_MIR_PASS(__fpga_kernel_place_correct_pass);
|
||||
USE_MIR_PASS(opencl_kernel_place_correct_pass);
|
||||
USE_MIR_PASS(generate_program_pass);
|
||||
|
||||
USE_MIR_PASS(io_copy_kernel_pick_pass);
|
||||
USE_MIR_PASS(argument_type_display_pass);
|
||||
USE_MIR_PASS(runtime_context_assign_pass);
|
||||
USE_MIR_PASS(graph_visualize_pass);
|
||||
|
||||
USE_MIR_PASS(sparse_conv_detect_pass);
|
||||
USE_MIR_PASS(adaptive_1x1_pool2d_convert_global_pass);
|
||||
USE_MIR_PASS(remove_scale1_pass);
|
||||
USE_MIR_PASS(remove_tf_redundant_ops_pass);
|
||||
USE_MIR_PASS(lite_conv_bn_fuse_pass);
|
||||
USE_MIR_PASS(lite_conv_conv_fuse_pass);
|
||||
USE_MIR_PASS(lite_squeeze2_matmul_fuse_pass);
|
||||
USE_MIR_PASS(lite_reshape2_matmul_fuse_pass);
|
||||
USE_MIR_PASS(lite_matmul_fuse_pass);
|
||||
USE_MIR_PASS(lite_fc_fuse_pass);
|
||||
USE_MIR_PASS(lite_matmul_element_add_fuse_pass);
|
||||
USE_MIR_PASS(lite_shuffle_channel_fuse_pass);
|
||||
USE_MIR_PASS(lite_transpose_softmax_transpose_fuse_pass);
|
||||
USE_MIR_PASS(lite_interpolate_fuse_pass);
|
||||
USE_MIR_PASS(lite_sequence_pool_concat_fuse_pass);
|
||||
USE_MIR_PASS(identity_scale_eliminate_pass);
|
||||
USE_MIR_PASS(identity_dropout_eliminate_pass);
|
||||
USE_MIR_PASS(lite_conv_elementwise_fuse_pass);
|
||||
USE_MIR_PASS(lite_conv_activation_fuse_pass);
|
||||
USE_MIR_PASS(lite_var_conv_2d_activation_fuse_pass);
|
||||
USE_MIR_PASS(lite_match_matrix_activation_fuse_pass);
|
||||
USE_MIR_PASS(lite_scales_fuse_pass);
|
||||
USE_MIR_PASS(lite_scaleacts_fuse_pass);
|
||||
USE_MIR_PASS(lite_sequence_reverse_embedding_fuse_pass);
|
||||
USE_MIR_PASS(lite_elementwise_activation_fuse_pass);
|
||||
USE_MIR_PASS(lite_elementwise_scale_fuse_pass);
|
||||
USE_MIR_PASS(lite_conv_scale_fuse_pass);
|
||||
USE_MIR_PASS(lite_conv_elementwise_tree_fuse_pass);
|
||||
USE_MIR_PASS(lite_quant_dequant_fuse_pass);
|
||||
USE_MIR_PASS(type_precision_cast_pass);
|
||||
USE_MIR_PASS(type_layout_cast_pass);
|
||||
USE_MIR_PASS(type_layout_cast_preprocess_pass);
|
||||
USE_MIR_PASS(memory_optimize_pass);
|
||||
USE_MIR_PASS(xpu_memory_optimize_pass);
|
||||
USE_MIR_PASS(lite_inplace_fuse_pass);
|
||||
USE_MIR_PASS(multi_stream_analysis_pass);
|
||||
USE_MIR_PASS(elementwise_mul_constant_eliminate_pass);
|
||||
USE_MIR_PASS(npu_subgraph_pass);
|
||||
USE_MIR_PASS(nnadapter_subgraph_pass);
|
||||
USE_MIR_PASS(mlu_subgraph_pass);
|
||||
USE_MIR_PASS(mlu_postprocess_pass);
|
||||
USE_MIR_PASS(weight_quantization_preprocess_pass);
|
||||
USE_MIR_PASS(post_quant_dynamic_pass);
|
||||
USE_MIR_PASS(fp16_attribute_pass);
|
||||
USE_MIR_PASS(fpga_concat_fuse_pass);
|
||||
USE_MIR_PASS(quantization_parameters_propagation_pass);
|
||||
USE_MIR_PASS(quantization_parameters_removal_pass);
|
||||
USE_MIR_PASS(restrict_quantized_op_with_same_input_output_scale_pass);
|
||||
USE_MIR_PASS(control_flow_op_unused_inputs_and_outputs_eliminate_pass);
|
||||
USE_MIR_PASS(control_flow_op_shared_inputs_and_outputs_place_sync_pass);
|
||||
USE_MIR_PASS(lite_scale_activation_fuse_pass);
|
||||
USE_MIR_PASS(lite_instance_norm_activation_fuse_pass);
|
||||
USE_MIR_PASS(ssd_boxes_calc_offline_pass);
|
||||
USE_MIR_PASS(fix_mismatched_precision_pass);
|
||||
USE_MIR_PASS(lite_flatten_fc_fuse_pass);
|
||||
USE_MIR_PASS(lite_fc_prelu_fuse_pass);
|
||||
USE_MIR_PASS(lite_greater_than_cast_fuse_pass);
|
||||
USE_MIR_PASS(assign_value_calc_offline_pass);
|
||||
USE_MIR_PASS(__xpu__graph_dedup_pass);
|
||||
USE_MIR_PASS(__xpu__resnet_fuse_pass);
|
||||
USE_MIR_PASS(__xpu__resnet_cbam_fuse_pass);
|
||||
USE_MIR_PASS(__xpu__multi_encoder_fuse_pass);
|
||||
USE_MIR_PASS(__xpu__embedding_with_eltwise_add_fuse_pass);
|
||||
USE_MIR_PASS(__xpu__fc_fuse_pass);
|
||||
USE_MIR_PASS(__xpu__mmdnn_fuse_pass);
|
||||
USE_MIR_PASS(__xpu__conv2d_affine_channel_fuse_pass);
|
||||
USE_MIR_PASS(__xpu__conv2d_fuse_pass);
|
||||
USE_MIR_PASS(__xpu__sfa_head_meanstd_fuse_pass);
|
||||
USE_MIR_PASS(__xpu__sfa_head_moment_fuse_pass);
|
||||
USE_MIR_PASS(__xpu__softmax_topk_fuse_pass);
|
||||
USE_MIR_PASS(__xpu__multi_encoder_adaptive_seqlen_fuse_pass);
|
||||
USE_MIR_PASS(__xpu__multi_encoder_slice_link_fuse_pass);
|
||||
USE_MIR_PASS(__xpu__generate_sequence_fuse_pass);
|
||||
USE_MIR_PASS(__xpu__logit_fuse_pass);
|
||||
USE_MIR_PASS(__xpu__link_previous_out_max_pass);
|
||||
USE_MIR_PASS(__xpu__squeeze_excitation_fuse_pass);
|
||||
USE_MIR_PASS(__xpu__bigru_fuse_pass);
|
||||
USE_MIR_PASS(__xpu__dynamic_lstm_fuse_pass);
|
||||
USE_MIR_PASS(__xpu__multi_softmax_fuse_pass);
|
||||
USE_MIR_PASS(__xpu__max_pooling_pad_zero_detect_fuse_pass);
|
||||
USE_MIR_PASS(x86_int8_attribute_pass);
|
||||
USE_MIR_PASS(fill_range_fuse_pass);
|
||||
USE_MIR_PASS(range_calc_offline_pass);
|
||||
USE_MIR_PASS(p_norm_fill_constant_max_div_fuse_pass);
|
||||
USE_MIR_PASS(fill_constant_calc_offline_pass);
|
||||
USE_MIR_PASS(unsqueeze_calc_offline_pass);
|
||||
USE_MIR_PASS(scale_calc_offline_pass);
|
||||
USE_MIR_PASS(keepdims_convert_pass);
|
||||
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
@@ -1,169 +0,0 @@
|
||||
/**
|
||||
* Paddle OCR (https://github.com/PaddlePaddle/PaddleOCR) build script (Kotlin DSL).
|
||||
*
|
||||
* Created by TonyJiangWJ (https://github.com/TonyJiangWJ) on Aug 7, 2023.
|
||||
* Modified by TonyJiangWJ (https://github.com/TonyJiangWJ) as of Aug 11, 2023.
|
||||
* Modified by SuperMonster003 as of Sep 4, 2023.
|
||||
* Transformed by SuperMonster003 on Sep 30, 2025.
|
||||
*/
|
||||
|
||||
plugins {
|
||||
id("org.autojs.build.utils")
|
||||
id("org.autojs.build.properties")
|
||||
id("org.autojs.build.jvm-convention")
|
||||
id("com.android.library")
|
||||
id("org.jetbrains.kotlin.android")
|
||||
}
|
||||
|
||||
ext {
|
||||
set("projectName", "Paddle OCR")
|
||||
}
|
||||
|
||||
val versionMap = mapOf(
|
||||
"MIN_SDK" to props["MIN_SDK"].toInt(),
|
||||
"COMPILE_SDK" to props["COMPILE_SDK"].toInt(),
|
||||
"TARGET_SDK" to props["TARGET_SDK"].toInt(),
|
||||
"NDK" to props["PADDLE_OCR/NDK"],
|
||||
"CMAKE" to props["PADDLE_OCR/CMAKE"],
|
||||
"OPENCV" to props["PADDLE_OCR/OPENCV"],
|
||||
)
|
||||
|
||||
val nameMap = mapOf(
|
||||
"PROJECT" to extensions.extraProperties.get("projectName") as String,
|
||||
"OPENCV" to "OpenCV",
|
||||
"NDK" to "NDK",
|
||||
"CMAKE" to "Cmake",
|
||||
)
|
||||
|
||||
val libsToDeploy = listOf(
|
||||
// @Hint by TonyJiangWJ (https://github.com/TonyJiangWJ) on Aug 7, 2023.
|
||||
// ! 下载 OpenCV 源码包 (默认为 4.2.0).
|
||||
// ! 和 Auto.js 中的版本 (如 4.8.0) 不匹配会产生冲突,
|
||||
// ! 可按需修改 version.properties 中对应内容.
|
||||
// ! en-US (translated by SuperMonster003 on Oct 22, 2024):
|
||||
// ! Download the archive for source code of OpenCV (defaults to 4.2.0).
|
||||
// ! Not matching the version in Auto.js (e.g., 4.8.0) will cause conflicts.
|
||||
// ! Adjust the corresponding content in version.properties as needed.
|
||||
utils.newLibDeployer(
|
||||
project,
|
||||
nameMap["OPENCV"] as String,
|
||||
"https://github.com/opencv/opencv/releases/download/${versionMap["OPENCV"]}/opencv-${versionMap["OPENCV"]}-android-sdk.zip",
|
||||
).apply {
|
||||
setSourceDir("/OpenCV-android-sdk/sdk/native/")
|
||||
setDestDir("/src/sdk/native/")
|
||||
}
|
||||
)
|
||||
|
||||
val argsMap = mapOf(
|
||||
// @Hint by LZX284 (https://github.com/LZX284) on Sep 30, 2023.
|
||||
// ! "ANDROID_PLATFORM" 默认为 "android-23", 这里修改为与 AutoJs6 最低 SDK 版本一致的 `versionMap.MIN_SDK`.
|
||||
// ! en-US (translated by SuperMonster003 on Oct 22, 2024):
|
||||
// ! "ANDROID_PLATFORM" with default value "android-23" was changed to `versionMap.MIN_SDK`
|
||||
// ! to align with the min SDK version of AutoJs6.
|
||||
"ANDROID_PLATFORM" to "android-${versionMap["MIN_SDK"]}",
|
||||
"ANDROID_STL" to "c++_shared",
|
||||
"ANDROID_ARM_NEON" to "TRUE",
|
||||
)
|
||||
|
||||
// @Hint by SuperMonster003 on Nov 12, 2023.
|
||||
// ! Do not add a space (nbsp) after "-D".
|
||||
// ! Reference: https://stackoverflow.com/questions/14887438/spacing-in-d-option-in-cmake
|
||||
// ! zh-CN:
|
||||
// ! 在 "-D" 后不要添加空格 (不间断空格).
|
||||
// ! 参阅: https://stackoverflow.com/questions/14887438/spacing-in-d-option-in-cmake
|
||||
val args = argsMap.entries.map { (k, v) -> "-D$k=$v" }
|
||||
|
||||
utils.configureLibraryLifecycleHooks(
|
||||
project,
|
||||
nameMap["PROJECT"] as String,
|
||||
listOf("OPENCV", "NDK", "CMAKE").map { "${nameMap[it]}: ${versionMap[it]}" },
|
||||
libsToDeploy,
|
||||
"isCleanupPaddleOcr",
|
||||
listOf(".cxx")
|
||||
)
|
||||
|
||||
android {
|
||||
namespace = "com.baidu.paddle.lite.ocr"
|
||||
|
||||
ndkVersion = versionMap["NDK"] as String
|
||||
compileSdk = versionMap["COMPILE_SDK"] as Int
|
||||
|
||||
defaultConfig {
|
||||
minSdk = versionMap["MIN_SDK"] as Int
|
||||
|
||||
externalNativeBuild {
|
||||
cmake {
|
||||
val cppFlagsMap = mapOf(
|
||||
"-std" to "c++11"
|
||||
)
|
||||
val cppListFlags = mapOf(
|
||||
"-f" to listOf("rtti", "exceptions"),
|
||||
"-W" to "no-format"
|
||||
)
|
||||
|
||||
// 组装等价于 Groovy 脚本中的拼接逻辑
|
||||
val cppFlagsJoined = buildString {
|
||||
append(
|
||||
cppFlagsMap.entries.joinToString(" ") { (k, v) -> "$k=$v" }
|
||||
)
|
||||
append(" ")
|
||||
append(
|
||||
cppListFlags.entries.joinToString(" ") { (k, v) ->
|
||||
when (v) {
|
||||
is List<*> -> v.joinToString(" ") { opt -> k + opt }
|
||||
else -> "$k$v"
|
||||
}
|
||||
}
|
||||
)
|
||||
}.trim()
|
||||
|
||||
cppFlags += cppFlagsJoined
|
||||
arguments += args
|
||||
}
|
||||
}
|
||||
|
||||
ndk {
|
||||
// @Hint by SuperMonster003 on Jan 2, 2024.
|
||||
// ! Supported architectures: arm-v7, arm-v8.
|
||||
// ! References:
|
||||
// ! https://github.com/PaddlePaddle/Paddle-Lite/blob/develop/lite/tools/build_android.sh#L7
|
||||
// ! https://github.com/PaddlePaddle/Paddle-Lite/issues/80
|
||||
// ! zh-CN:
|
||||
// ! 支持的架构: arm-v7, arm-v8.
|
||||
// ! 参阅:
|
||||
// ! https://github.com/PaddlePaddle/Paddle-Lite/blob/develop/lite/tools/build_android.sh#L7
|
||||
// ! https://github.com/PaddlePaddle/Paddle-Lite/issues/80
|
||||
// noinspection ChromeOsAbiSupport
|
||||
abiFilters += listOf("arm64-v8a", "armeabi-v7a")
|
||||
@Suppress("DEPRECATION")
|
||||
ldLibs?.add("jnigraphics")
|
||||
}
|
||||
}
|
||||
|
||||
buildTypes {
|
||||
release {
|
||||
isMinifyEnabled = false
|
||||
}
|
||||
debug {
|
||||
isMinifyEnabled = false
|
||||
}
|
||||
}
|
||||
|
||||
externalNativeBuild {
|
||||
cmake {
|
||||
path = file("src/main/cpp/CMakeLists.txt")
|
||||
version = versionMap["CMAKE"] as String
|
||||
}
|
||||
}
|
||||
|
||||
lint {
|
||||
targetSdk = versionMap["TARGET_SDK"] as Int
|
||||
}
|
||||
}
|
||||
|
||||
dependencies {
|
||||
implementation(fileTree(mapOf("include" to listOf("*.jar"), "dir" to "libs")))
|
||||
implementation(project(mapOf("path" to ":libs:org-opencv-${versionMap["OPENCV"]}".replace(".", "_"))))
|
||||
implementation(libs.core.ktx)
|
||||
implementation(libs.preference.ktx)
|
||||
}
|
||||
21
libs/paddleocr/proguard-rules.pro
vendored
21
libs/paddleocr/proguard-rules.pro
vendored
@@ -1,21 +0,0 @@
|
||||
# Add project specific ProGuard rules here.
|
||||
# You can control the set of applied configuration files using the
|
||||
# proguardFiles setting in build.gradle.kts.
|
||||
#
|
||||
# For more details, see
|
||||
# http://developer.android.com/guide/developing/tools/proguard.html
|
||||
|
||||
# If your project uses WebView with JS, uncomment the following
|
||||
# and specify the fully qualified class name to the JavaScript interface
|
||||
# class:
|
||||
#-keepclassmembers class fqcn.of.javascript.interface.for.webview {
|
||||
# public *;
|
||||
#}
|
||||
|
||||
# Uncomment this to preserve the line number information for
|
||||
# debugging stack traces.
|
||||
#-keepattributes SourceFile,LineNumberTable
|
||||
|
||||
# If you keep the line number information, uncomment this to
|
||||
# hide the original source file name.
|
||||
#-renamesourcefileattribute SourceFile
|
||||
@@ -1,2 +0,0 @@
|
||||
<?xml version="1.0" encoding="utf-8"?>
|
||||
<manifest />
|
||||
File diff suppressed because it is too large
Load Diff
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
@@ -1,94 +0,0 @@
|
||||
# For more information about using CMake with Android Studio, read the
|
||||
# documentation: https://d.android.com/studio/projects/add-native-code.html
|
||||
|
||||
# Sets the minimum version of CMake required to build the native library.
|
||||
|
||||
cmake_minimum_required(VERSION 3.4.1)
|
||||
|
||||
# Creates and names a library, sets it as either STATIC or SHARED, and provides
|
||||
# the relative paths to its source code. You can define multiple libraries, and
|
||||
# CMake builds them for you. Gradle automatically packages shared libraries with
|
||||
# your APK.
|
||||
|
||||
get_filename_component(MODULE_DIR "${CMAKE_CURRENT_LIST_DIR}/../../.." ABSOLUTE)
|
||||
set(PaddleLite_DIR "${MODULE_DIR}/PaddleLite")
|
||||
include_directories(${PaddleLite_DIR}/cxx/include)
|
||||
|
||||
set(OpenCV_DIR "${MODULE_DIR}/src/sdk/native/jni")
|
||||
message(STATUS "opencv dir: ${OpenCV_DIR}")
|
||||
find_package(OpenCV REQUIRED)
|
||||
message(STATUS "OpenCV libraries: ${OpenCV_LIBS}")
|
||||
include_directories(${OpenCV_INCLUDE_DIRS})
|
||||
aux_source_directory(. SOURCES)
|
||||
set(CMAKE_CXX_FLAGS
|
||||
"${CMAKE_CXX_FLAGS} -ffast-math -Ofast -Os"
|
||||
)
|
||||
set(CMAKE_CXX_FLAGS
|
||||
"${CMAKE_CXX_FLAGS} -fvisibility=hidden -fvisibility-inlines-hidden -fdata-sections -ffunction-sections"
|
||||
)
|
||||
set(CMAKE_SHARED_LINKER_FLAGS
|
||||
"${CMAKE_SHARED_LINKER_FLAGS} -Wl,--gc-sections -Wl,-z,nocopyreloc")
|
||||
|
||||
add_library(
|
||||
# Sets the name of the library.
|
||||
Native
|
||||
# Sets the library as a shared library.
|
||||
SHARED
|
||||
# Provides a relative path to your source file(s).
|
||||
${SOURCES})
|
||||
|
||||
find_library(
|
||||
# Sets the name of the path variable.
|
||||
log-lib
|
||||
# Specifies the name of the NDK library that you want CMake to locate.
|
||||
log)
|
||||
|
||||
add_library(
|
||||
# Sets the name of the library.
|
||||
paddle_light_api_shared
|
||||
# Sets the library as a shared library.
|
||||
SHARED
|
||||
# Provides a relative path to your source file(s).
|
||||
IMPORTED)
|
||||
|
||||
set_target_properties(
|
||||
# Specifies the target library.
|
||||
paddle_light_api_shared
|
||||
# Specifies the parameter you want to define.
|
||||
PROPERTIES
|
||||
IMPORTED_LOCATION
|
||||
${PaddleLite_DIR}/cxx/libs/${ANDROID_ABI}/libpaddle_light_api_shared.so
|
||||
# Provides the path to the library you want to import.
|
||||
)
|
||||
|
||||
|
||||
# Specifies libraries CMake should link to your target library. You can link
|
||||
# multiple libraries, such as libraries you define in this build script,
|
||||
# prebuilt third-party libraries, or system libraries.
|
||||
|
||||
target_link_libraries(
|
||||
# Specifies the target library.
|
||||
Native
|
||||
paddle_light_api_shared
|
||||
${OpenCV_LIBS}
|
||||
GLESv2
|
||||
EGL
|
||||
jnigraphics
|
||||
${log-lib}
|
||||
)
|
||||
|
||||
add_custom_command(
|
||||
TARGET Native
|
||||
POST_BUILD
|
||||
COMMAND
|
||||
${CMAKE_COMMAND} -E copy
|
||||
${PaddleLite_DIR}/cxx/libs/${ANDROID_ABI}/libc++_shared.so
|
||||
${CMAKE_LIBRARY_OUTPUT_DIRECTORY}/libc++_shared.so)
|
||||
|
||||
add_custom_command(
|
||||
TARGET Native
|
||||
POST_BUILD
|
||||
COMMAND
|
||||
${CMAKE_COMMAND} -E copy
|
||||
${PaddleLite_DIR}/cxx/libs/${ANDROID_ABI}/libpaddle_light_api_shared.so
|
||||
${CMAKE_LIBRARY_OUTPUT_DIRECTORY}/libpaddle_light_api_shared.so)
|
||||
@@ -1,37 +0,0 @@
|
||||
//
|
||||
// Created by fu on 4/25/18.
|
||||
//
|
||||
|
||||
#pragma once
|
||||
#import <numeric>
|
||||
#import <vector>
|
||||
|
||||
#ifdef __ANDROID__
|
||||
|
||||
#include <android/log.h>
|
||||
|
||||
#define LOG_TAG "OCR_NDK"
|
||||
|
||||
#define LOGI(...) __android_log_print(ANDROID_LOG_INFO, LOG_TAG, __VA_ARGS__)
|
||||
#define LOGW(...) __android_log_print(ANDROID_LOG_WARN, LOG_TAG, __VA_ARGS__)
|
||||
#define LOGE(...) __android_log_print(ANDROID_LOG_ERROR, LOG_TAG, __VA_ARGS__)
|
||||
#else
|
||||
#include <stdio.h>
|
||||
#define LOGI(format, ...) \
|
||||
fprintf(stdout, "[" LOG_TAG "]" format "\n", ##__VA_ARGS__)
|
||||
#define LOGW(format, ...) \
|
||||
fprintf(stdout, "[" LOG_TAG "]" format "\n", ##__VA_ARGS__)
|
||||
#define LOGE(format, ...) \
|
||||
fprintf(stderr, "[" LOG_TAG "]Error: " format "\n", ##__VA_ARGS__)
|
||||
#endif
|
||||
|
||||
enum RETURN_CODE { RETURN_OK = 0 };
|
||||
|
||||
enum NET_TYPE { NET_OCR = 900100, NET_OCR_INTERNAL = 991008 };
|
||||
|
||||
template <typename T> inline T product(const std::vector<T> &vec) {
|
||||
if (vec.empty()) {
|
||||
return 0;
|
||||
}
|
||||
return std::accumulate(vec.begin(), vec.end(), 1, std::multiplies<T>());
|
||||
}
|
||||
@@ -1,127 +0,0 @@
|
||||
//
|
||||
// Created by fujiayi on 2020/7/5.
|
||||
//
|
||||
|
||||
#include "native.h"
|
||||
#include "ocr_ppredictor.h"
|
||||
#include <algorithm>
|
||||
#include <paddle_api.h>
|
||||
#include <string>
|
||||
|
||||
static paddle::lite_api::PowerMode str_to_cpu_mode(const std::string &cpu_mode);
|
||||
|
||||
extern "C" JNIEXPORT jlong JNICALL
|
||||
Java_com_baidu_paddle_lite_ocr_OCRPredictorNative_init(
|
||||
JNIEnv *env, jobject thiz, jstring j_det_model_path,
|
||||
jstring j_rec_model_path, jstring j_cls_model_path, jint j_use_opencl, jint j_thread_num,
|
||||
jstring j_cpu_mode) {
|
||||
std::string det_model_path = jstring_to_cpp_string(env, j_det_model_path);
|
||||
std::string rec_model_path = jstring_to_cpp_string(env, j_rec_model_path);
|
||||
std::string cls_model_path = jstring_to_cpp_string(env, j_cls_model_path);
|
||||
int thread_num = j_thread_num;
|
||||
std::string cpu_mode = jstring_to_cpp_string(env, j_cpu_mode);
|
||||
ppredictor::OCR_Config conf;
|
||||
conf.use_opencl = j_use_opencl;
|
||||
conf.thread_num = thread_num;
|
||||
conf.mode = str_to_cpu_mode(cpu_mode);
|
||||
ppredictor::OCR_PPredictor *orc_predictor =
|
||||
new ppredictor::OCR_PPredictor{conf};
|
||||
orc_predictor->init_from_file(det_model_path, rec_model_path, cls_model_path);
|
||||
return reinterpret_cast<jlong>(orc_predictor);
|
||||
}
|
||||
|
||||
/**
|
||||
* "LITE_POWER_HIGH" convert to paddle::lite_api::LITE_POWER_HIGH
|
||||
* @param cpu_mode
|
||||
* @return
|
||||
*/
|
||||
static paddle::lite_api::PowerMode
|
||||
str_to_cpu_mode(const std::string &cpu_mode) {
|
||||
static std::map<std::string, paddle::lite_api::PowerMode> cpu_mode_map{
|
||||
{"LITE_POWER_HIGH", paddle::lite_api::LITE_POWER_HIGH},
|
||||
{"LITE_POWER_LOW", paddle::lite_api::LITE_POWER_HIGH},
|
||||
{"LITE_POWER_FULL", paddle::lite_api::LITE_POWER_FULL},
|
||||
{"LITE_POWER_NO_BIND", paddle::lite_api::LITE_POWER_NO_BIND},
|
||||
{"LITE_POWER_RAND_HIGH", paddle::lite_api::LITE_POWER_RAND_HIGH},
|
||||
{"LITE_POWER_RAND_LOW", paddle::lite_api::LITE_POWER_RAND_LOW}};
|
||||
std::string upper_key;
|
||||
std::transform(cpu_mode.cbegin(), cpu_mode.cend(), upper_key.begin(),
|
||||
::toupper);
|
||||
auto index = cpu_mode_map.find(upper_key.c_str());
|
||||
if (index == cpu_mode_map.end()) {
|
||||
// 可能因为大小写转换后找不到 直接通过入参查找
|
||||
index = cpu_mode_map.find(cpu_mode);
|
||||
if (index != cpu_mode_map.end()) {
|
||||
LOGI("find cpu_mode by &cpu_mode %s", cpu_mode.c_str());
|
||||
return index->second;
|
||||
}
|
||||
LOGE("cpu_mode not found %s", upper_key.c_str());
|
||||
return paddle::lite_api::LITE_POWER_HIGH;
|
||||
} else {
|
||||
return index->second;
|
||||
}
|
||||
}
|
||||
|
||||
extern "C" JNIEXPORT jfloatArray JNICALL
|
||||
Java_com_baidu_paddle_lite_ocr_OCRPredictorNative_forward(
|
||||
JNIEnv *env, jobject thiz, jlong java_pointer,
|
||||
jobject original_image,jint j_max_size_len, jint j_run_det, jint j_run_cls,
|
||||
jint j_run_rec) {
|
||||
LOGI("begin to run native forward");
|
||||
if (java_pointer == 0) {
|
||||
LOGE("JAVA pointer is NULL");
|
||||
return cpp_array_to_jfloatarray(env, nullptr, 0);
|
||||
}
|
||||
|
||||
cv::Mat origin = bitmap_to_cv_mat(env, original_image);
|
||||
if (origin.size == nullptr) {
|
||||
LOGE("origin bitmap cannot convert to CV Mat");
|
||||
return cpp_array_to_jfloatarray(env, nullptr, 0);
|
||||
}
|
||||
|
||||
int max_size_len = j_max_size_len;
|
||||
int run_det = j_run_det;
|
||||
int run_cls = j_run_cls;
|
||||
int run_rec = j_run_rec;
|
||||
|
||||
ppredictor::OCR_PPredictor *ppredictor =
|
||||
(ppredictor::OCR_PPredictor *)java_pointer;
|
||||
std::vector<int64_t> dims_arr;
|
||||
std::vector<ppredictor::OCRPredictResult> results =
|
||||
ppredictor->infer_ocr(origin, max_size_len, run_det, run_cls, run_rec);
|
||||
LOGI("infer_ocr finished with boxes %ld", results.size());
|
||||
|
||||
// 这里将std::vector<ppredictor::OCRPredictResult> 序列化成
|
||||
// float数组，传输到java层再反序列化
|
||||
std::vector<float> float_arr;
|
||||
for (const ppredictor::OCRPredictResult &r : results) {
|
||||
float_arr.push_back(r.points.size());
|
||||
float_arr.push_back(r.word_index.size());
|
||||
float_arr.push_back(r.score);
|
||||
// add det point
|
||||
for (const std::vector<int> &point : r.points) {
|
||||
float_arr.push_back(point.at(0));
|
||||
float_arr.push_back(point.at(1));
|
||||
}
|
||||
// add rec word idx
|
||||
for (int index : r.word_index) {
|
||||
float_arr.push_back(index);
|
||||
}
|
||||
// add cls result
|
||||
float_arr.push_back(r.cls_label);
|
||||
float_arr.push_back(r.cls_score);
|
||||
}
|
||||
return cpp_array_to_jfloatarray(env, float_arr.data(), float_arr.size());
|
||||
}
|
||||
|
||||
extern "C" JNIEXPORT void JNICALL
|
||||
Java_com_baidu_paddle_lite_ocr_OCRPredictorNative_release(
|
||||
JNIEnv *env, jobject thiz, jlong java_pointer) {
|
||||
if (java_pointer == 0) {
|
||||
LOGE("JAVA pointer is NULL");
|
||||
return;
|
||||
}
|
||||
ppredictor::OCR_PPredictor *ppredictor =
|
||||
(ppredictor::OCR_PPredictor *)java_pointer;
|
||||
delete ppredictor;
|
||||
}
|
||||
@@ -1,137 +0,0 @@
|
||||
//
|
||||
// Created by fujiayi on 2020/7/5.
|
||||
//
|
||||
|
||||
#pragma once
|
||||
|
||||
#include "common.h"
|
||||
#include <android/bitmap.h>
|
||||
#include <jni.h>
|
||||
#include <opencv2/opencv.hpp>
|
||||
#include <string>
|
||||
#include <vector>
|
||||
|
||||
inline std::string jstring_to_cpp_string(JNIEnv *env, jstring jstr) {
|
||||
// In java, a unicode char will be encoded using 2 bytes (utf16).
|
||||
// so jstring will contain characters utf16. std::string in c++ is
|
||||
// essentially a string of bytes, not characters, so if we want to
|
||||
// pass jstring from JNI to c++, we have convert utf16 to bytes.
|
||||
if (!jstr) {
|
||||
return "";
|
||||
}
|
||||
const jclass stringClass = env->GetObjectClass(jstr);
|
||||
const jmethodID getBytes =
|
||||
env->GetMethodID(stringClass, "getBytes", "(Ljava/lang/String;)[B");
|
||||
const jbyteArray stringJbytes = (jbyteArray)env->CallObjectMethod(
|
||||
jstr, getBytes, env->NewStringUTF("UTF-8"));
|
||||
|
||||
size_t length = (size_t)env->GetArrayLength(stringJbytes);
|
||||
jbyte *pBytes = env->GetByteArrayElements(stringJbytes, NULL);
|
||||
|
||||
std::string ret = std::string(reinterpret_cast<char *>(pBytes), length);
|
||||
env->ReleaseByteArrayElements(stringJbytes, pBytes, JNI_ABORT);
|
||||
|
||||
env->DeleteLocalRef(stringJbytes);
|
||||
env->DeleteLocalRef(stringClass);
|
||||
return ret;
|
||||
}
|
||||
|
||||
inline jstring cpp_string_to_jstring(JNIEnv *env, std::string str) {
|
||||
auto *data = str.c_str();
|
||||
jclass strClass = env->FindClass("java/lang/String");
|
||||
jmethodID strClassInitMethodID =
|
||||
env->GetMethodID(strClass, "<init>", "([BLjava/lang/String;)V");
|
||||
|
||||
jbyteArray bytes = env->NewByteArray(strlen(data));
|
||||
env->SetByteArrayRegion(bytes, 0, strlen(data),
|
||||
reinterpret_cast<const jbyte *>(data));
|
||||
|
||||
jstring encoding = env->NewStringUTF("UTF-8");
|
||||
jstring res = (jstring)(
|
||||
env->NewObject(strClass, strClassInitMethodID, bytes, encoding));
|
||||
|
||||
env->DeleteLocalRef(strClass);
|
||||
env->DeleteLocalRef(encoding);
|
||||
env->DeleteLocalRef(bytes);
|
||||
|
||||
return res;
|
||||
}
|
||||
|
||||
inline jfloatArray cpp_array_to_jfloatarray(JNIEnv *env, const float *buf,
|
||||
int64_t len) {
|
||||
if (len == 0) {
|
||||
return env->NewFloatArray(0);
|
||||
}
|
||||
jfloatArray result = env->NewFloatArray(len);
|
||||
env->SetFloatArrayRegion(result, 0, len, buf);
|
||||
return result;
|
||||
}
|
||||
|
||||
inline jintArray cpp_array_to_jintarray(JNIEnv *env, const int *buf,
|
||||
int64_t len) {
|
||||
jintArray result = env->NewIntArray(len);
|
||||
env->SetIntArrayRegion(result, 0, len, buf);
|
||||
return result;
|
||||
}
|
||||
|
||||
inline jbyteArray cpp_array_to_jbytearray(JNIEnv *env, const int8_t *buf,
|
||||
int64_t len) {
|
||||
jbyteArray result = env->NewByteArray(len);
|
||||
env->SetByteArrayRegion(result, 0, len, buf);
|
||||
return result;
|
||||
}
|
||||
|
||||
inline jlongArray int64_vector_to_jlongarray(JNIEnv *env,
|
||||
const std::vector<int64_t> &vec) {
|
||||
jlongArray result = env->NewLongArray(vec.size());
|
||||
jlong *buf = new jlong[vec.size()];
|
||||
for (size_t i = 0; i < vec.size(); ++i) {
|
||||
buf[i] = (jlong)vec[i];
|
||||
}
|
||||
env->SetLongArrayRegion(result, 0, vec.size(), buf);
|
||||
delete[] buf;
|
||||
return result;
|
||||
}
|
||||
|
||||
inline std::vector<int64_t> jlongarray_to_int64_vector(JNIEnv *env,
|
||||
jlongArray data) {
|
||||
int data_size = env->GetArrayLength(data);
|
||||
jlong *data_ptr = env->GetLongArrayElements(data, nullptr);
|
||||
std::vector<int64_t> data_vec(data_ptr, data_ptr + data_size);
|
||||
env->ReleaseLongArrayElements(data, data_ptr, 0);
|
||||
return data_vec;
|
||||
}
|
||||
|
||||
inline std::vector<float> jfloatarray_to_float_vector(JNIEnv *env,
|
||||
jfloatArray data) {
|
||||
int data_size = env->GetArrayLength(data);
|
||||
jfloat *data_ptr = env->GetFloatArrayElements(data, nullptr);
|
||||
std::vector<float> data_vec(data_ptr, data_ptr + data_size);
|
||||
env->ReleaseFloatArrayElements(data, data_ptr, 0);
|
||||
return data_vec;
|
||||
}
|
||||
|
||||
inline cv::Mat bitmap_to_cv_mat(JNIEnv *env, jobject bitmap) {
|
||||
AndroidBitmapInfo info;
|
||||
int result = AndroidBitmap_getInfo(env, bitmap, &info);
|
||||
if (result != ANDROID_BITMAP_RESULT_SUCCESS) {
|
||||
LOGE("AndroidBitmap_getInfo failed, result: %d", result);
|
||||
return cv::Mat{};
|
||||
}
|
||||
if (info.format != ANDROID_BITMAP_FORMAT_RGBA_8888) {
|
||||
LOGE("Bitmap format is not RGBA_8888 !");
|
||||
return cv::Mat{};
|
||||
}
|
||||
unsigned char *srcData = NULL;
|
||||
AndroidBitmap_lockPixels(env, bitmap, (void **)&srcData);
|
||||
cv::Mat mat = cv::Mat::zeros(info.height, info.width, CV_8UC4);
|
||||
memcpy(mat.data, srcData, info.height * info.width * 4);
|
||||
AndroidBitmap_unlockPixels(env, bitmap);
|
||||
cv::cvtColor(mat, mat, cv::COLOR_RGBA2BGR);
|
||||
/**
|
||||
if (!cv::imwrite("/sdcard/1/copy.jpg", mat)){
|
||||
LOGE("Write image failed " );
|
||||
}
|
||||
*/
|
||||
return mat;
|
||||
}
|
||||
File diff suppressed because it is too large
Load Diff
@@ -1,544 +0,0 @@
|
||||
/*******************************************************************************
|
||||
* *
|
||||
* Author : Angus Johnson *
|
||||
* Version : 6.4.2 *
|
||||
* Date : 27 February 2017 *
|
||||
* Website : http://www.angusj.com *
|
||||
* Copyright : Angus Johnson 2010-2017 *
|
||||
* *
|
||||
* License: *
|
||||
* Use, modification & distribution is subject to Boost Software License Ver 1. *
|
||||
* http://www.boost.org/LICENSE_1_0.txt *
|
||||
* *
|
||||
* Attributions: *
|
||||
* The code in this library is an extension of Bala Vatti's clipping algorithm: *
|
||||
* "A generic solution to polygon clipping" *
|
||||
* Communications of the ACM, Vol 35, Issue 7 (July 1992) pp 56-63. *
|
||||
* http://portal.acm.org/citation.cfm?id=129906 *
|
||||
* *
|
||||
* Computer graphics and geometric modeling: implementation and algorithms *
|
||||
* By Max K. Agoston *
|
||||
* Springer; 1 edition (January 4, 2005) *
|
||||
* http://books.google.com/books?q=vatti+clipping+agoston *
|
||||
* *
|
||||
* See also: *
|
||||
* "Polygon Offsetting by Computing Winding Numbers" *
|
||||
* Paper no. DETC2005-85513 pp. 565-575 *
|
||||
* ASME 2005 International Design Engineering Technical Conferences *
|
||||
* and Computers and Information in Engineering Conference (IDETC/CIE2005) *
|
||||
* September 24-28, 2005 , Long Beach, California, USA *
|
||||
* http://www.me.berkeley.edu/~mcmains/pubs/DAC05OffsetPolygon.pdf *
|
||||
* *
|
||||
*******************************************************************************/
|
||||
|
||||
#ifndef clipper_hpp
|
||||
#define clipper_hpp
|
||||
|
||||
#define CLIPPER_VERSION "6.4.2"
|
||||
|
||||
// use_int32: When enabled 32bit ints are used instead of 64bit ints. This
|
||||
// improve performance but coordinate values are limited to the range +/- 46340
|
||||
//#define use_int32
|
||||
|
||||
// use_xyz: adds a Z member to IntPoint. Adds a minor cost to perfomance.
|
||||
//#define use_xyz
|
||||
|
||||
// use_lines: Enables line clipping. Adds a very minor cost to performance.
|
||||
#define use_lines
|
||||
|
||||
// use_deprecated: Enables temporary support for the obsolete functions
|
||||
//#define use_deprecated
|
||||
|
||||
#include <cstdlib>
|
||||
#include <cstring>
|
||||
#include <functional>
|
||||
#include <list>
|
||||
#include <ostream>
|
||||
#include <queue>
|
||||
#include <set>
|
||||
#include <stdexcept>
|
||||
#include <vector>
|
||||
|
||||
namespace ClipperLib {
|
||||
|
||||
enum ClipType { ctIntersection, ctUnion, ctDifference, ctXor };
|
||||
enum PolyType { ptSubject, ptClip };
|
||||
// By far the most widely used winding rules for polygon filling are
|
||||
// EvenOdd & NonZero (GDI, GDI+, XLib, OpenGL, Cairo, AGG, Quartz, SVG, Gr32)
|
||||
// Others rules include Positive, Negative and ABS_GTR_EQ_TWO (only in OpenGL)
|
||||
// see http://glprogramming.com/red/chapter11.html
|
||||
enum PolyFillType { pftEvenOdd, pftNonZero, pftPositive, pftNegative };
|
||||
|
||||
#ifdef use_int32
|
||||
typedef int cInt;
|
||||
static cInt const loRange = 0x7FFF;
|
||||
static cInt const hiRange = 0x7FFF;
|
||||
#else
|
||||
typedef signed long long cInt;
|
||||
static cInt const loRange = 0x3FFFFFFF;
|
||||
static cInt const hiRange = 0x3FFFFFFFFFFFFFFFLL;
|
||||
typedef signed long long long64; // used by Int128 class
|
||||
typedef unsigned long long ulong64;
|
||||
|
||||
#endif
|
||||
|
||||
struct IntPoint {
|
||||
cInt X;
|
||||
cInt Y;
|
||||
#ifdef use_xyz
|
||||
cInt Z;
|
||||
IntPoint(cInt x = 0, cInt y = 0, cInt z = 0) : X(x), Y(y), Z(z){};
|
||||
#else
|
||||
|
||||
IntPoint(cInt x = 0, cInt y = 0) : X(x), Y(y){};
|
||||
#endif
|
||||
|
||||
friend inline bool operator==(const IntPoint &a, const IntPoint &b) {
|
||||
return a.X == b.X && a.Y == b.Y;
|
||||
}
|
||||
|
||||
friend inline bool operator!=(const IntPoint &a, const IntPoint &b) {
|
||||
return a.X != b.X || a.Y != b.Y;
|
||||
}
|
||||
};
|
||||
//------------------------------------------------------------------------------
|
||||
|
||||
typedef std::vector<IntPoint> Path;
|
||||
typedef std::vector<Path> Paths;
|
||||
|
||||
inline Path &operator<<(Path &poly, const IntPoint &p) {
|
||||
poly.push_back(p);
|
||||
return poly;
|
||||
}
|
||||
|
||||
inline Paths &operator<<(Paths &polys, const Path &p) {
|
||||
polys.push_back(p);
|
||||
return polys;
|
||||
}
|
||||
|
||||
std::ostream &operator<<(std::ostream &s, const IntPoint &p);
|
||||
|
||||
std::ostream &operator<<(std::ostream &s, const Path &p);
|
||||
|
||||
std::ostream &operator<<(std::ostream &s, const Paths &p);
|
||||
|
||||
struct DoublePoint {
|
||||
double X;
|
||||
double Y;
|
||||
|
||||
DoublePoint(double x = 0, double y = 0) : X(x), Y(y) {}
|
||||
|
||||
DoublePoint(IntPoint ip) : X((double)ip.X), Y((double)ip.Y) {}
|
||||
};
|
||||
//------------------------------------------------------------------------------
|
||||
|
||||
#ifdef use_xyz
|
||||
typedef void (*ZFillCallback)(IntPoint &e1bot, IntPoint &e1top, IntPoint &e2bot,
|
||||
IntPoint &e2top, IntPoint &pt);
|
||||
#endif
|
||||
|
||||
enum InitOptions {
|
||||
ioReverseSolution = 1,
|
||||
ioStrictlySimple = 2,
|
||||
ioPreserveCollinear = 4
|
||||
};
|
||||
enum JoinType { jtSquare, jtRound, jtMiter };
|
||||
enum EndType {
|
||||
etClosedPolygon,
|
||||
etClosedLine,
|
||||
etOpenButt,
|
||||
etOpenSquare,
|
||||
etOpenRound
|
||||
};
|
||||
|
||||
class PolyNode;
|
||||
|
||||
typedef std::vector<PolyNode *> PolyNodes;
|
||||
|
||||
class PolyNode {
|
||||
public:
|
||||
PolyNode();
|
||||
|
||||
virtual ~PolyNode(){};
|
||||
Path Contour;
|
||||
PolyNodes Childs;
|
||||
PolyNode *Parent;
|
||||
|
||||
PolyNode *GetNext() const;
|
||||
|
||||
bool IsHole() const;
|
||||
|
||||
bool IsOpen() const;
|
||||
|
||||
int ChildCount() const;
|
||||
|
||||
private:
|
||||
// PolyNode& operator =(PolyNode& other);
|
||||
unsigned Index; // node index in Parent.Childs
|
||||
bool m_IsOpen;
|
||||
JoinType m_jointype;
|
||||
EndType m_endtype;
|
||||
|
||||
PolyNode *GetNextSiblingUp() const;
|
||||
|
||||
void AddChild(PolyNode &child);
|
||||
|
||||
friend class Clipper; // to access Index
|
||||
friend class ClipperOffset;
|
||||
};
|
||||
|
||||
class PolyTree : public PolyNode {
|
||||
public:
|
||||
~PolyTree() { Clear(); };
|
||||
|
||||
PolyNode *GetFirst() const;
|
||||
|
||||
void Clear();
|
||||
|
||||
int Total() const;
|
||||
|
||||
private:
|
||||
// PolyTree& operator =(PolyTree& other);
|
||||
PolyNodes AllNodes;
|
||||
|
||||
friend class Clipper; // to access AllNodes
|
||||
};
|
||||
|
||||
bool Orientation(const Path &poly);
|
||||
|
||||
double Area(const Path &poly);
|
||||
|
||||
int PointInPolygon(const IntPoint &pt, const Path &path);
|
||||
|
||||
void SimplifyPolygon(const Path &in_poly, Paths &out_polys,
|
||||
PolyFillType fillType = pftEvenOdd);
|
||||
|
||||
void SimplifyPolygons(const Paths &in_polys, Paths &out_polys,
|
||||
PolyFillType fillType = pftEvenOdd);
|
||||
|
||||
void SimplifyPolygons(Paths &polys, PolyFillType fillType = pftEvenOdd);
|
||||
|
||||
void CleanPolygon(const Path &in_poly, Path &out_poly, double distance = 1.415);
|
||||
|
||||
void CleanPolygon(Path &poly, double distance = 1.415);
|
||||
|
||||
void CleanPolygons(const Paths &in_polys, Paths &out_polys,
|
||||
double distance = 1.415);
|
||||
|
||||
void CleanPolygons(Paths &polys, double distance = 1.415);
|
||||
|
||||
void MinkowskiSum(const Path &pattern, const Path &path, Paths &solution,
|
||||
bool pathIsClosed);
|
||||
|
||||
void MinkowskiSum(const Path &pattern, const Paths &paths, Paths &solution,
|
||||
bool pathIsClosed);
|
||||
|
||||
void MinkowskiDiff(const Path &poly1, const Path &poly2, Paths &solution);
|
||||
|
||||
void PolyTreeToPaths(const PolyTree &polytree, Paths &paths);
|
||||
|
||||
void ClosedPathsFromPolyTree(const PolyTree &polytree, Paths &paths);
|
||||
|
||||
void OpenPathsFromPolyTree(PolyTree &polytree, Paths &paths);
|
||||
|
||||
void ReversePath(Path &p);
|
||||
|
||||
void ReversePaths(Paths &p);
|
||||
|
||||
struct IntRect {
|
||||
cInt left;
|
||||
cInt top;
|
||||
cInt right;
|
||||
cInt bottom;
|
||||
};
|
||||
|
||||
// enums that are used internally ...
|
||||
enum EdgeSide { esLeft = 1, esRight = 2 };
|
||||
|
||||
// forward declarations (for stuff used internally) ...
|
||||
struct TEdge;
|
||||
struct IntersectNode;
|
||||
struct LocalMinimum;
|
||||
struct OutPt;
|
||||
struct OutRec;
|
||||
struct Join;
|
||||
|
||||
typedef std::vector<OutRec *> PolyOutList;
|
||||
typedef std::vector<TEdge *> EdgeList;
|
||||
typedef std::vector<Join *> JoinList;
|
||||
typedef std::vector<IntersectNode *> IntersectList;
|
||||
|
||||
//------------------------------------------------------------------------------
|
||||
|
||||
// ClipperBase is the ancestor to the Clipper class. It should not be
|
||||
// instantiated directly. This class simply abstracts the conversion of sets of
|
||||
// polygon coordinates into edge objects that are stored in a LocalMinima list.
|
||||
class ClipperBase {
|
||||
public:
|
||||
ClipperBase();
|
||||
|
||||
virtual ~ClipperBase();
|
||||
|
||||
virtual bool AddPath(const Path &pg, PolyType PolyTyp, bool Closed);
|
||||
|
||||
bool AddPaths(const Paths &ppg, PolyType PolyTyp, bool Closed);
|
||||
|
||||
virtual void Clear();
|
||||
|
||||
IntRect GetBounds();
|
||||
|
||||
bool PreserveCollinear() { return m_PreserveCollinear; };
|
||||
|
||||
void PreserveCollinear(bool value) { m_PreserveCollinear = value; };
|
||||
|
||||
protected:
|
||||
void DisposeLocalMinimaList();
|
||||
|
||||
TEdge *AddBoundsToLML(TEdge *e, bool IsClosed);
|
||||
|
||||
virtual void Reset();
|
||||
|
||||
TEdge *ProcessBound(TEdge *E, bool IsClockwise);
|
||||
|
||||
void InsertScanbeam(const cInt Y);
|
||||
|
||||
bool PopScanbeam(cInt &Y);
|
||||
|
||||
bool LocalMinimaPending();
|
||||
|
||||
bool PopLocalMinima(cInt Y, const LocalMinimum *&locMin);
|
||||
|
||||
OutRec *CreateOutRec();
|
||||
|
||||
void DisposeAllOutRecs();
|
||||
|
||||
void DisposeOutRec(PolyOutList::size_type index);
|
||||
|
||||
void SwapPositionsInAEL(TEdge *edge1, TEdge *edge2);
|
||||
|
||||
void DeleteFromAEL(TEdge *e);
|
||||
|
||||
void UpdateEdgeIntoAEL(TEdge *&e);
|
||||
|
||||
typedef std::vector<LocalMinimum> MinimaList;
|
||||
MinimaList::iterator m_CurrentLM;
|
||||
MinimaList m_MinimaList;
|
||||
|
||||
bool m_UseFullRange;
|
||||
EdgeList m_edges;
|
||||
bool m_PreserveCollinear;
|
||||
bool m_HasOpenPaths;
|
||||
PolyOutList m_PolyOuts;
|
||||
TEdge *m_ActiveEdges;
|
||||
|
||||
typedef std::priority_queue<cInt> ScanbeamList;
|
||||
ScanbeamList m_Scanbeam;
|
||||
};
|
||||
//------------------------------------------------------------------------------
|
||||
|
||||
class Clipper : public virtual ClipperBase {
|
||||
public:
|
||||
Clipper(int initOptions = 0);
|
||||
|
||||
bool Execute(ClipType clipType, Paths &solution,
|
||||
PolyFillType fillType = pftEvenOdd);
|
||||
|
||||
bool Execute(ClipType clipType, Paths &solution, PolyFillType subjFillType,
|
||||
PolyFillType clipFillType);
|
||||
|
||||
bool Execute(ClipType clipType, PolyTree &polytree,
|
||||
PolyFillType fillType = pftEvenOdd);
|
||||
|
||||
bool Execute(ClipType clipType, PolyTree &polytree, PolyFillType subjFillType,
|
||||
PolyFillType clipFillType);
|
||||
|
||||
bool ReverseSolution() { return m_ReverseOutput; };
|
||||
|
||||
void ReverseSolution(bool value) { m_ReverseOutput = value; };
|
||||
|
||||
bool StrictlySimple() { return m_StrictSimple; };
|
||||
|
||||
void StrictlySimple(bool value) { m_StrictSimple = value; };
|
||||
// set the callback function for z value filling on intersections (otherwise Z
|
||||
// is 0)
|
||||
#ifdef use_xyz
|
||||
void ZFillFunction(ZFillCallback zFillFunc);
|
||||
#endif
|
||||
protected:
|
||||
virtual bool ExecuteInternal();
|
||||
|
||||
private:
|
||||
JoinList m_Joins;
|
||||
JoinList m_GhostJoins;
|
||||
IntersectList m_IntersectList;
|
||||
ClipType m_ClipType;
|
||||
typedef std::list<cInt> MaximaList;
|
||||
MaximaList m_Maxima;
|
||||
TEdge *m_SortedEdges;
|
||||
bool m_ExecuteLocked;
|
||||
PolyFillType m_ClipFillType;
|
||||
PolyFillType m_SubjFillType;
|
||||
bool m_ReverseOutput;
|
||||
bool m_UsingPolyTree;
|
||||
bool m_StrictSimple;
|
||||
#ifdef use_xyz
|
||||
ZFillCallback m_ZFill; // custom callback
|
||||
#endif
|
||||
|
||||
void SetWindingCount(TEdge &edge);
|
||||
|
||||
bool IsEvenOddFillType(const TEdge &edge) const;
|
||||
|
||||
bool IsEvenOddAltFillType(const TEdge &edge) const;
|
||||
|
||||
void InsertLocalMinimaIntoAEL(const cInt botY);
|
||||
|
||||
void InsertEdgeIntoAEL(TEdge *edge, TEdge *startEdge);
|
||||
|
||||
void AddEdgeToSEL(TEdge *edge);
|
||||
|
||||
bool PopEdgeFromSEL(TEdge *&edge);
|
||||
|
||||
void CopyAELToSEL();
|
||||
|
||||
void DeleteFromSEL(TEdge *e);
|
||||
|
||||
void SwapPositionsInSEL(TEdge *edge1, TEdge *edge2);
|
||||
|
||||
bool IsContributing(const TEdge &edge) const;
|
||||
|
||||
bool IsTopHorz(const cInt XPos);
|
||||
|
||||
void DoMaxima(TEdge *e);
|
||||
|
||||
void ProcessHorizontals();
|
||||
|
||||
void ProcessHorizontal(TEdge *horzEdge);
|
||||
|
||||
void AddLocalMaxPoly(TEdge *e1, TEdge *e2, const IntPoint &pt);
|
||||
|
||||
OutPt *AddLocalMinPoly(TEdge *e1, TEdge *e2, const IntPoint &pt);
|
||||
|
||||
OutRec *GetOutRec(int idx);
|
||||
|
||||
void AppendPolygon(TEdge *e1, TEdge *e2);
|
||||
|
||||
void IntersectEdges(TEdge *e1, TEdge *e2, IntPoint &pt);
|
||||
|
||||
OutPt *AddOutPt(TEdge *e, const IntPoint &pt);
|
||||
|
||||
OutPt *GetLastOutPt(TEdge *e);
|
||||
|
||||
bool ProcessIntersections(const cInt topY);
|
||||
|
||||
void BuildIntersectList(const cInt topY);
|
||||
|
||||
void ProcessIntersectList();
|
||||
|
||||
void ProcessEdgesAtTopOfScanbeam(const cInt topY);
|
||||
|
||||
void BuildResult(Paths &polys);
|
||||
|
||||
void BuildResult2(PolyTree &polytree);
|
||||
|
||||
void SetHoleState(TEdge *e, OutRec *outrec);
|
||||
|
||||
void DisposeIntersectNodes();
|
||||
|
||||
bool FixupIntersectionOrder();
|
||||
|
||||
void FixupOutPolygon(OutRec &outrec);
|
||||
|
||||
void FixupOutPolyline(OutRec &outrec);
|
||||
|
||||
bool IsHole(TEdge *e);
|
||||
|
||||
bool FindOwnerFromSplitRecs(OutRec &outRec, OutRec *&currOrfl);
|
||||
|
||||
void FixHoleLinkage(OutRec &outrec);
|
||||
|
||||
void AddJoin(OutPt *op1, OutPt *op2, const IntPoint offPt);
|
||||
|
||||
void ClearJoins();
|
||||
|
||||
void ClearGhostJoins();
|
||||
|
||||
void AddGhostJoin(OutPt *op, const IntPoint offPt);
|
||||
|
||||
bool JoinPoints(Join *j, OutRec *outRec1, OutRec *outRec2);
|
||||
|
||||
void JoinCommonEdges();
|
||||
|
||||
void DoSimplePolygons();
|
||||
|
||||
void FixupFirstLefts1(OutRec *OldOutRec, OutRec *NewOutRec);
|
||||
|
||||
void FixupFirstLefts2(OutRec *InnerOutRec, OutRec *OuterOutRec);
|
||||
|
||||
void FixupFirstLefts3(OutRec *OldOutRec, OutRec *NewOutRec);
|
||||
|
||||
#ifdef use_xyz
|
||||
void SetZ(IntPoint &pt, TEdge &e1, TEdge &e2);
|
||||
#endif
|
||||
};
|
||||
//------------------------------------------------------------------------------
|
||||
|
||||
class ClipperOffset {
|
||||
public:
|
||||
ClipperOffset(double miterLimit = 2.0, double roundPrecision = 0.25);
|
||||
|
||||
~ClipperOffset();
|
||||
|
||||
void AddPath(const Path &path, JoinType joinType, EndType endType);
|
||||
|
||||
void AddPaths(const Paths &paths, JoinType joinType, EndType endType);
|
||||
|
||||
void Execute(Paths &solution, double delta);
|
||||
|
||||
void Execute(PolyTree &solution, double delta);
|
||||
|
||||
void Clear();
|
||||
|
||||
double MiterLimit;
|
||||
double ArcTolerance;
|
||||
|
||||
private:
|
||||
Paths m_destPolys;
|
||||
Path m_srcPoly;
|
||||
Path m_destPoly;
|
||||
std::vector<DoublePoint> m_normals;
|
||||
double m_delta, m_sinA, m_sin, m_cos;
|
||||
double m_miterLim, m_StepsPerRad;
|
||||
IntPoint m_lowest;
|
||||
PolyNode m_polyNodes;
|
||||
|
||||
void FixOrientations();
|
||||
|
||||
void DoOffset(double delta);
|
||||
|
||||
void OffsetPoint(int j, int &k, JoinType jointype);
|
||||
|
||||
void DoSquare(int j, int k);
|
||||
|
||||
void DoMiter(int j, int k, double r);
|
||||
|
||||
void DoRound(int j, int k);
|
||||
};
|
||||
//------------------------------------------------------------------------------
|
||||
|
||||
class clipperException : public std::exception {
|
||||
public:
|
||||
clipperException(const char *description) : m_descr(description) {}
|
||||
|
||||
virtual ~clipperException() throw() {}
|
||||
|
||||
virtual const char *what() const throw() { return m_descr.c_str(); }
|
||||
|
||||
private:
|
||||
std::string m_descr;
|
||||
};
|
||||
//------------------------------------------------------------------------------
|
||||
|
||||
} // ClipperLib namespace
|
||||
|
||||
#endif // clipper_hpp
|
||||
@@ -1,46 +0,0 @@
|
||||
// Copyright (c) 2020 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.
|
||||
|
||||
#include "ocr_cls_process.h"
|
||||
#include <cmath>
|
||||
#include <cstring>
|
||||
#include <fstream>
|
||||
#include <iostream>
|
||||
#include <iostream>
|
||||
#include <vector>
|
||||
|
||||
const std::vector<int> CLS_IMAGE_SHAPE = {3, 48, 192};
|
||||
|
||||
cv::Mat cls_resize_img(const cv::Mat &img) {
|
||||
int imgC = CLS_IMAGE_SHAPE[0];
|
||||
int imgW = CLS_IMAGE_SHAPE[2];
|
||||
int imgH = CLS_IMAGE_SHAPE[1];
|
||||
|
||||
float ratio = float(img.cols) / float(img.rows);
|
||||
int resize_w = 0;
|
||||
if (ceilf(imgH * ratio) > imgW)
|
||||
resize_w = imgW;
|
||||
else
|
||||
resize_w = int(ceilf(imgH * ratio));
|
||||
|
||||
cv::Mat resize_img;
|
||||
cv::resize(img, resize_img, cv::Size(resize_w, imgH), 0.f, 0.f,
|
||||
cv::INTER_CUBIC);
|
||||
|
||||
if (resize_w < imgW) {
|
||||
cv::copyMakeBorder(resize_img, resize_img, 0, 0, 0, int(imgW - resize_w),
|
||||
cv::BORDER_CONSTANT, {0, 0, 0});
|
||||
}
|
||||
return resize_img;
|
||||
}
|
||||
@@ -1,23 +0,0 @@
|
||||
// Copyright (c) 2020 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 "common.h"
|
||||
#include <opencv2/opencv.hpp>
|
||||
#include <vector>
|
||||
|
||||
extern const std::vector<int> CLS_IMAGE_SHAPE;
|
||||
|
||||
cv::Mat cls_resize_img(const cv::Mat &img);
|
||||
@@ -1,144 +0,0 @@
|
||||
// Copyright (c) 2020 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.
|
||||
|
||||
#include "ocr_crnn_process.h"
|
||||
#include <cmath>
|
||||
#include <cstring>
|
||||
#include <fstream>
|
||||
#include <iostream>
|
||||
#include <iostream>
|
||||
#include <vector>
|
||||
|
||||
const std::string CHARACTER_TYPE = "ch";
|
||||
const int MAX_DICT_LENGTH = 6624;
|
||||
const std::vector<int> REC_IMAGE_SHAPE = {3, 48, 320};
|
||||
|
||||
static cv::Mat crnn_resize_norm_img(cv::Mat img, float wh_ratio) {
|
||||
int imgC = REC_IMAGE_SHAPE[0];
|
||||
int imgH = REC_IMAGE_SHAPE[1];
|
||||
int imgW = REC_IMAGE_SHAPE[2];
|
||||
|
||||
if (CHARACTER_TYPE == "ch")
|
||||
imgW = int(32 * wh_ratio);
|
||||
|
||||
float ratio = float(img.cols) / float(img.rows);
|
||||
int resize_w = 0;
|
||||
if (ceilf(imgH * ratio) > imgW)
|
||||
resize_w = imgW;
|
||||
else
|
||||
resize_w = int(ceilf(imgH * ratio));
|
||||
cv::Mat resize_img;
|
||||
cv::resize(img, resize_img, cv::Size(resize_w, imgH), 0.f, 0.f,
|
||||
cv::INTER_CUBIC);
|
||||
|
||||
resize_img.convertTo(resize_img, CV_32FC3, 1 / 255.f);
|
||||
|
||||
for (int h = 0; h < resize_img.rows; h++) {
|
||||
for (int w = 0; w < resize_img.cols; w++) {
|
||||
resize_img.at<cv::Vec3f>(h, w)[0] =
|
||||
(resize_img.at<cv::Vec3f>(h, w)[0] - 0.5) * 2;
|
||||
resize_img.at<cv::Vec3f>(h, w)[1] =
|
||||
(resize_img.at<cv::Vec3f>(h, w)[1] - 0.5) * 2;
|
||||
resize_img.at<cv::Vec3f>(h, w)[2] =
|
||||
(resize_img.at<cv::Vec3f>(h, w)[2] - 0.5) * 2;
|
||||
}
|
||||
}
|
||||
|
||||
cv::Mat dist;
|
||||
cv::copyMakeBorder(resize_img, dist, 0, 0, 0, int(imgW - resize_w),
|
||||
cv::BORDER_CONSTANT, {0, 0, 0});
|
||||
|
||||
return dist;
|
||||
}
|
||||
|
||||
cv::Mat crnn_resize_img(const cv::Mat &img, float wh_ratio) {
|
||||
int imgC = REC_IMAGE_SHAPE[0];
|
||||
int imgH = REC_IMAGE_SHAPE[1];
|
||||
int imgW = REC_IMAGE_SHAPE[2];
|
||||
|
||||
imgW = int(imgH * wh_ratio);
|
||||
|
||||
float ratio = float(img.cols) / float(img.rows);
|
||||
int resize_w = 0;
|
||||
if (ceilf(imgH * ratio) > imgW)
|
||||
resize_w = imgW;
|
||||
else
|
||||
resize_w = int(ceilf(imgH * ratio));
|
||||
cv::Mat resize_img;
|
||||
cv::resize(img, resize_img, cv::Size(resize_w, imgH), 0.f, 0.f,
|
||||
cv::INTER_LINEAR);
|
||||
cv::copyMakeBorder(resize_img, resize_img, 0, 0, 0,
|
||||
int(imgW - resize_img.cols), cv::BORDER_CONSTANT,
|
||||
{127, 127, 127});
|
||||
return resize_img;
|
||||
}
|
||||
|
||||
cv::Mat get_rotate_crop_image(const cv::Mat &srcimage,
|
||||
const std::vector<std::vector<int>> &box) {
|
||||
|
||||
std::vector<std::vector<int>> points = box;
|
||||
|
||||
int x_collect[4] = {box[0][0], box[1][0], box[2][0], box[3][0]};
|
||||
int y_collect[4] = {box[0][1], box[1][1], box[2][1], box[3][1]};
|
||||
int left = int(*std::min_element(x_collect, x_collect + 4));
|
||||
int right = int(*std::max_element(x_collect, x_collect + 4));
|
||||
int top = int(*std::min_element(y_collect, y_collect + 4));
|
||||
int bottom = int(*std::max_element(y_collect, y_collect + 4));
|
||||
|
||||
cv::Mat img_crop;
|
||||
srcimage(cv::Rect(left, top, right - left, bottom - top)).copyTo(img_crop);
|
||||
|
||||
for (int i = 0; i < points.size(); i++) {
|
||||
points[i][0] -= left;
|
||||
points[i][1] -= top;
|
||||
}
|
||||
|
||||
int img_crop_width = int(sqrt(pow(points[0][0] - points[1][0], 2) +
|
||||
pow(points[0][1] - points[1][1], 2)));
|
||||
int img_crop_height = int(sqrt(pow(points[0][0] - points[3][0], 2) +
|
||||
pow(points[0][1] - points[3][1], 2)));
|
||||
|
||||
cv::Point2f pts_std[4];
|
||||
pts_std[0] = cv::Point2f(0., 0.);
|
||||
pts_std[1] = cv::Point2f(img_crop_width, 0.);
|
||||
pts_std[2] = cv::Point2f(img_crop_width, img_crop_height);
|
||||
pts_std[3] = cv::Point2f(0.f, img_crop_height);
|
||||
|
||||
cv::Point2f pointsf[4];
|
||||
pointsf[0] = cv::Point2f(points[0][0], points[0][1]);
|
||||
pointsf[1] = cv::Point2f(points[1][0], points[1][1]);
|
||||
pointsf[2] = cv::Point2f(points[2][0], points[2][1]);
|
||||
pointsf[3] = cv::Point2f(points[3][0], points[3][1]);
|
||||
|
||||
cv::Mat M = cv::getPerspectiveTransform(pointsf, pts_std);
|
||||
|
||||
cv::Mat dst_img;
|
||||
cv::warpPerspective(img_crop, dst_img, M,
|
||||
cv::Size(img_crop_width, img_crop_height),
|
||||
cv::BORDER_REPLICATE);
|
||||
|
||||
if (float(dst_img.rows) >= float(dst_img.cols) * 1.5) {
|
||||
/*
|
||||
cv::Mat srcCopy = cv::Mat(dst_img.rows, dst_img.cols, dst_img.depth());
|
||||
cv::transpose(dst_img, srcCopy);
|
||||
cv::flip(srcCopy, srcCopy, 0);
|
||||
return srcCopy;
|
||||
*/
|
||||
cv::transpose(dst_img, dst_img);
|
||||
cv::flip(dst_img, dst_img, 0);
|
||||
return dst_img;
|
||||
} else {
|
||||
return dst_img;
|
||||
}
|
||||
}
|
||||
@@ -1,20 +0,0 @@
|
||||
//
|
||||
// Created by fujiayi on 2020/7/3.
|
||||
//
|
||||
#pragma once
|
||||
|
||||
#include "common.h"
|
||||
#include <opencv2/opencv.hpp>
|
||||
#include <vector>
|
||||
|
||||
extern const std::vector<int> REC_IMAGE_SHAPE;
|
||||
|
||||
cv::Mat get_rotate_crop_image(const cv::Mat &srcimage,
|
||||
const std::vector<std::vector<int>> &box);
|
||||
|
||||
cv::Mat crnn_resize_img(const cv::Mat &img, float wh_ratio);
|
||||
|
||||
template <class ForwardIterator>
|
||||
inline size_t argmax(ForwardIterator first, ForwardIterator last) {
|
||||
return std::distance(first, std::max_element(first, last));
|
||||
}
|
||||
@@ -1,342 +0,0 @@
|
||||
// Copyright (c) 2020 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.
|
||||
|
||||
#include "ocr_clipper.hpp"
|
||||
#include "opencv2/core.hpp"
|
||||
#include "opencv2/imgcodecs.hpp"
|
||||
#include "opencv2/imgproc.hpp"
|
||||
#include <iostream>
|
||||
#include <math.h>
|
||||
#include <vector>
|
||||
|
||||
static void getcontourarea(float **box, float unclip_ratio, float &distance) {
|
||||
int pts_num = 4;
|
||||
float area = 0.0f;
|
||||
float dist = 0.0f;
|
||||
for (int i = 0; i < pts_num; i++) {
|
||||
area += box[i][0] * box[(i + 1) % pts_num][1] -
|
||||
box[i][1] * box[(i + 1) % pts_num][0];
|
||||
dist += sqrtf((box[i][0] - box[(i + 1) % pts_num][0]) *
|
||||
(box[i][0] - box[(i + 1) % pts_num][0]) +
|
||||
(box[i][1] - box[(i + 1) % pts_num][1]) *
|
||||
(box[i][1] - box[(i + 1) % pts_num][1]));
|
||||
}
|
||||
area = fabs(float(area / 2.0));
|
||||
|
||||
distance = area * unclip_ratio / dist;
|
||||
}
|
||||
|
||||
static cv::RotatedRect unclip(float **box) {
|
||||
float unclip_ratio = 2.0;
|
||||
float distance = 1.0;
|
||||
|
||||
getcontourarea(box, unclip_ratio, distance);
|
||||
|
||||
ClipperLib::ClipperOffset offset;
|
||||
ClipperLib::Path p;
|
||||
p << ClipperLib::IntPoint(int(box[0][0]), int(box[0][1]))
|
||||
<< ClipperLib::IntPoint(int(box[1][0]), int(box[1][1]))
|
||||
<< ClipperLib::IntPoint(int(box[2][0]), int(box[2][1]))
|
||||
<< ClipperLib::IntPoint(int(box[3][0]), int(box[3][1]));
|
||||
offset.AddPath(p, ClipperLib::jtRound, ClipperLib::etClosedPolygon);
|
||||
|
||||
ClipperLib::Paths soln;
|
||||
offset.Execute(soln, distance);
|
||||
std::vector<cv::Point2f> points;
|
||||
|
||||
for (int j = 0; j < soln.size(); j++) {
|
||||
for (int i = 0; i < soln[soln.size() - 1].size(); i++) {
|
||||
points.emplace_back(soln[j][i].X, soln[j][i].Y);
|
||||
}
|
||||
}
|
||||
cv::RotatedRect res = cv::minAreaRect(points);
|
||||
|
||||
return res;
|
||||
}
|
||||
|
||||
static float **Mat2Vec(cv::Mat mat) {
|
||||
auto **array = new float *[mat.rows];
|
||||
for (int i = 0; i < mat.rows; ++i) {
|
||||
array[i] = new float[mat.cols];
|
||||
}
|
||||
for (int i = 0; i < mat.rows; ++i) {
|
||||
for (int j = 0; j < mat.cols; ++j) {
|
||||
array[i][j] = mat.at<float>(i, j);
|
||||
}
|
||||
}
|
||||
|
||||
return array;
|
||||
}
|
||||
|
||||
static void quickSort(float **s, int l, int r) {
|
||||
if (l < r) {
|
||||
int i = l, j = r;
|
||||
float x = s[l][0];
|
||||
float *xp = s[l];
|
||||
while (i < j) {
|
||||
while (i < j && s[j][0] >= x) {
|
||||
j--;
|
||||
}
|
||||
if (i < j) {
|
||||
std::swap(s[i++], s[j]);
|
||||
}
|
||||
while (i < j && s[i][0] < x) {
|
||||
i++;
|
||||
}
|
||||
if (i < j) {
|
||||
std::swap(s[j--], s[i]);
|
||||
}
|
||||
}
|
||||
s[i] = xp;
|
||||
quickSort(s, l, i - 1);
|
||||
quickSort(s, i + 1, r);
|
||||
}
|
||||
}
|
||||
|
||||
static void quickSort_vector(std::vector<std::vector<int>> &box, int l, int r,
|
||||
int axis) {
|
||||
if (l < r) {
|
||||
int i = l, j = r;
|
||||
int x = box[l][axis];
|
||||
std::vector<int> xp(box[l]);
|
||||
while (i < j) {
|
||||
while (i < j && box[j][axis] >= x) {
|
||||
j--;
|
||||
}
|
||||
if (i < j) {
|
||||
std::swap(box[i++], box[j]);
|
||||
}
|
||||
while (i < j && box[i][axis] < x) {
|
||||
i++;
|
||||
}
|
||||
if (i < j) {
|
||||
std::swap(box[j--], box[i]);
|
||||
}
|
||||
}
|
||||
box[i] = xp;
|
||||
quickSort_vector(box, l, i - 1, axis);
|
||||
quickSort_vector(box, i + 1, r, axis);
|
||||
}
|
||||
}
|
||||
|
||||
static std::vector<std::vector<int>>
|
||||
order_points_clockwise(std::vector<std::vector<int>> pts) {
|
||||
std::vector<std::vector<int>> box = pts;
|
||||
quickSort_vector(box, 0, int(box.size() - 1), 0);
|
||||
std::vector<std::vector<int>> leftmost = {box[0], box[1]};
|
||||
std::vector<std::vector<int>> rightmost = {box[2], box[3]};
|
||||
|
||||
if (leftmost[0][1] > leftmost[1][1]) {
|
||||
std::swap(leftmost[0], leftmost[1]);
|
||||
}
|
||||
|
||||
if (rightmost[0][1] > rightmost[1][1]) {
|
||||
std::swap(rightmost[0], rightmost[1]);
|
||||
}
|
||||
|
||||
std::vector<std::vector<int>> rect = {leftmost[0], rightmost[0], rightmost[1],
|
||||
leftmost[1]};
|
||||
return rect;
|
||||
}
|
||||
|
||||
static float **get_mini_boxes(cv::RotatedRect box, float &ssid) {
|
||||
ssid = box.size.width >= box.size.height ? box.size.height : box.size.width;
|
||||
|
||||
cv::Mat points;
|
||||
cv::boxPoints(box, points);
|
||||
// sorted box points
|
||||
auto array = Mat2Vec(points);
|
||||
quickSort(array, 0, 3);
|
||||
|
||||
float *idx1 = array[0], *idx2 = array[1], *idx3 = array[2], *idx4 = array[3];
|
||||
if (array[3][1] <= array[2][1]) {
|
||||
idx2 = array[3];
|
||||
idx3 = array[2];
|
||||
} else {
|
||||
idx2 = array[2];
|
||||
idx3 = array[3];
|
||||
}
|
||||
if (array[1][1] <= array[0][1]) {
|
||||
idx1 = array[1];
|
||||
idx4 = array[0];
|
||||
} else {
|
||||
idx1 = array[0];
|
||||
idx4 = array[1];
|
||||
}
|
||||
|
||||
array[0] = idx1;
|
||||
array[1] = idx2;
|
||||
array[2] = idx3;
|
||||
array[3] = idx4;
|
||||
|
||||
return array;
|
||||
}
|
||||
|
||||
template <class T> T clamp(T x, T min, T max) {
|
||||
if (x > max) {
|
||||
return max;
|
||||
}
|
||||
if (x < min) {
|
||||
return min;
|
||||
}
|
||||
return x;
|
||||
}
|
||||
|
||||
static float clampf(float x, float min, float max) {
|
||||
if (x > max)
|
||||
return max;
|
||||
if (x < min)
|
||||
return min;
|
||||
return x;
|
||||
}
|
||||
|
||||
float box_score_fast(float **box_array, cv::Mat pred) {
|
||||
auto array = box_array;
|
||||
int width = pred.cols;
|
||||
int height = pred.rows;
|
||||
|
||||
float box_x[4] = {array[0][0], array[1][0], array[2][0], array[3][0]};
|
||||
float box_y[4] = {array[0][1], array[1][1], array[2][1], array[3][1]};
|
||||
|
||||
int xmin = clamp(int(std::floorf(*(std::min_element(box_x, box_x + 4)))), 0,
|
||||
width - 1);
|
||||
int xmax = clamp(int(std::ceilf(*(std::max_element(box_x, box_x + 4)))), 0,
|
||||
width - 1);
|
||||
int ymin = clamp(int(std::floorf(*(std::min_element(box_y, box_y + 4)))), 0,
|
||||
height - 1);
|
||||
int ymax = clamp(int(std::ceilf(*(std::max_element(box_y, box_y + 4)))), 0,
|
||||
height - 1);
|
||||
|
||||
cv::Mat mask;
|
||||
mask = cv::Mat::zeros(ymax - ymin + 1, xmax - xmin + 1, CV_8UC1);
|
||||
|
||||
cv::Point root_point[4];
|
||||
root_point[0] = cv::Point(int(array[0][0]) - xmin, int(array[0][1]) - ymin);
|
||||
root_point[1] = cv::Point(int(array[1][0]) - xmin, int(array[1][1]) - ymin);
|
||||
root_point[2] = cv::Point(int(array[2][0]) - xmin, int(array[2][1]) - ymin);
|
||||
root_point[3] = cv::Point(int(array[3][0]) - xmin, int(array[3][1]) - ymin);
|
||||
const cv::Point *ppt[1] = {root_point};
|
||||
int npt[] = {4};
|
||||
cv::fillPoly(mask, ppt, npt, 1, cv::Scalar(1));
|
||||
|
||||
cv::Mat croppedImg;
|
||||
pred(cv::Rect(xmin, ymin, xmax - xmin + 1, ymax - ymin + 1))
|
||||
.copyTo(croppedImg);
|
||||
|
||||
auto score = cv::mean(croppedImg, mask)[0];
|
||||
return score;
|
||||
}
|
||||
|
||||
std::vector<std::vector<std::vector<int>>>
|
||||
boxes_from_bitmap(const cv::Mat &pred, const cv::Mat &bitmap) {
|
||||
const int min_size = 3;
|
||||
const int max_candidates = 1000;
|
||||
const float box_thresh = 0.5;
|
||||
|
||||
int width = bitmap.cols;
|
||||
int height = bitmap.rows;
|
||||
|
||||
std::vector<std::vector<cv::Point>> contours;
|
||||
std::vector<cv::Vec4i> hierarchy;
|
||||
|
||||
cv::findContours(bitmap, contours, hierarchy, cv::RETR_LIST,
|
||||
cv::CHAIN_APPROX_SIMPLE);
|
||||
|
||||
int num_contours =
|
||||
contours.size() >= max_candidates ? max_candidates : contours.size();
|
||||
|
||||
std::vector<std::vector<std::vector<int>>> boxes;
|
||||
|
||||
for (int _i = 0; _i < num_contours; _i++) {
|
||||
float ssid;
|
||||
cv::RotatedRect box = cv::minAreaRect(contours[_i]);
|
||||
auto array = get_mini_boxes(box, ssid);
|
||||
|
||||
auto box_for_unclip = array;
|
||||
// end get_mini_box
|
||||
|
||||
if (ssid < min_size) {
|
||||
continue;
|
||||
}
|
||||
|
||||
float score;
|
||||
score = box_score_fast(array, pred);
|
||||
// end box_score_fast
|
||||
if (score < box_thresh) {
|
||||
continue;
|
||||
}
|
||||
|
||||
// start for unclip
|
||||
cv::RotatedRect points = unclip(box_for_unclip);
|
||||
// end for unclip
|
||||
|
||||
cv::RotatedRect clipbox = points;
|
||||
auto cliparray = get_mini_boxes(clipbox, ssid);
|
||||
|
||||
if (ssid < min_size + 2)
|
||||
continue;
|
||||
|
||||
int dest_width = pred.cols;
|
||||
int dest_height = pred.rows;
|
||||
std::vector<std::vector<int>> intcliparray;
|
||||
|
||||
for (int num_pt = 0; num_pt < 4; num_pt++) {
|
||||
std::vector<int> a{int(clampf(roundf(cliparray[num_pt][0] / float(width) *
|
||||
float(dest_width)),
|
||||
0, float(dest_width))),
|
||||
int(clampf(roundf(cliparray[num_pt][1] /
|
||||
float(height) * float(dest_height)),
|
||||
0, float(dest_height)))};
|
||||
intcliparray.emplace_back(std::move(a));
|
||||
}
|
||||
boxes.emplace_back(std::move(intcliparray));
|
||||
|
||||
} // end for
|
||||
return boxes;
|
||||
}
|
||||
|
||||
int _max(int a, int b) { return a >= b ? a : b; }
|
||||
|
||||
int _min(int a, int b) { return a >= b ? b : a; }
|
||||
|
||||
std::vector<std::vector<std::vector<int>>>
|
||||
filter_tag_det_res(const std::vector<std::vector<std::vector<int>>> &o_boxes,
|
||||
float ratio_h, float ratio_w, const cv::Mat &srcimg) {
|
||||
int oriimg_h = srcimg.rows;
|
||||
int oriimg_w = srcimg.cols;
|
||||
std::vector<std::vector<std::vector<int>>> boxes{o_boxes};
|
||||
std::vector<std::vector<std::vector<int>>> root_points;
|
||||
for (int n = 0; n < boxes.size(); n++) {
|
||||
boxes[n] = order_points_clockwise(boxes[n]);
|
||||
for (int m = 0; m < boxes[0].size(); m++) {
|
||||
boxes[n][m][0] /= ratio_w;
|
||||
boxes[n][m][1] /= ratio_h;
|
||||
|
||||
boxes[n][m][0] = int(_min(_max(boxes[n][m][0], 0), oriimg_w - 1));
|
||||
boxes[n][m][1] = int(_min(_max(boxes[n][m][1], 0), oriimg_h - 1));
|
||||
}
|
||||
}
|
||||
|
||||
for (int n = 0; n < boxes.size(); n++) {
|
||||
int rect_width, rect_height;
|
||||
rect_width = int(sqrt(pow(boxes[n][0][0] - boxes[n][1][0], 2) +
|
||||
pow(boxes[n][0][1] - boxes[n][1][1], 2)));
|
||||
rect_height = int(sqrt(pow(boxes[n][0][0] - boxes[n][3][0], 2) +
|
||||
pow(boxes[n][0][1] - boxes[n][3][1], 2)));
|
||||
if (rect_width <= 10 || rect_height <= 10)
|
||||
continue;
|
||||
root_points.push_back(boxes[n]);
|
||||
}
|
||||
return root_points;
|
||||
}
|
||||
@@ -1,13 +0,0 @@
|
||||
//
|
||||
// Created by fujiayi on 2020/7/2.
|
||||
//
|
||||
#pragma once
|
||||
#include <opencv2/opencv.hpp>
|
||||
#include <vector>
|
||||
|
||||
std::vector<std::vector<std::vector<int>>>
|
||||
boxes_from_bitmap(const cv::Mat &pred, const cv::Mat &bitmap);
|
||||
|
||||
std::vector<std::vector<std::vector<int>>>
|
||||
filter_tag_det_res(const std::vector<std::vector<std::vector<int>>> &o_boxes,
|
||||
float ratio_h, float ratio_w, const cv::Mat &srcimg);
|
||||
@@ -1,349 +0,0 @@
|
||||
//
|
||||
// Created by fujiayi on 2020/7/1.
|
||||
//
|
||||
|
||||
#include "ocr_ppredictor.h"
|
||||
#include "common.h"
|
||||
#include "ocr_cls_process.h"
|
||||
#include "ocr_crnn_process.h"
|
||||
#include "ocr_db_post_process.h"
|
||||
#include "preprocess.h"
|
||||
|
||||
namespace ppredictor {
|
||||
|
||||
OCR_PPredictor::OCR_PPredictor(const OCR_Config &config) : _config(config) {}
|
||||
|
||||
int OCR_PPredictor::init(const std::string &det_model_content,
|
||||
const std::string &rec_model_content,
|
||||
const std::string &cls_model_content) {
|
||||
_det_predictor = std::unique_ptr<PPredictor>(
|
||||
new PPredictor{_config.use_opencl,_config.thread_num, NET_OCR, _config.mode});
|
||||
_det_predictor->init_nb(det_model_content);
|
||||
|
||||
_rec_predictor = std::unique_ptr<PPredictor>(
|
||||
new PPredictor{_config.use_opencl,_config.thread_num, NET_OCR_INTERNAL, _config.mode});
|
||||
_rec_predictor->init_nb(rec_model_content);
|
||||
|
||||
_cls_predictor = std::unique_ptr<PPredictor>(
|
||||
new PPredictor{_config.use_opencl,_config.thread_num, NET_OCR_INTERNAL, _config.mode});
|
||||
_cls_predictor->init_nb(cls_model_content);
|
||||
return RETURN_OK;
|
||||
}
|
||||
|
||||
int OCR_PPredictor::init_from_file(const std::string &det_model_path,
|
||||
const std::string &rec_model_path,
|
||||
const std::string &cls_model_path) {
|
||||
_det_predictor = std::unique_ptr<PPredictor>(
|
||||
new PPredictor{_config.use_opencl, _config.thread_num, NET_OCR, _config.mode});
|
||||
_det_predictor->init_from_file(det_model_path);
|
||||
|
||||
_rec_predictor = std::unique_ptr<PPredictor>(
|
||||
new PPredictor{_config.use_opencl,_config.thread_num, NET_OCR_INTERNAL, _config.mode});
|
||||
_rec_predictor->init_from_file(rec_model_path);
|
||||
|
||||
_cls_predictor = std::unique_ptr<PPredictor>(
|
||||
new PPredictor{_config.use_opencl,_config.thread_num, NET_OCR_INTERNAL, _config.mode});
|
||||
_cls_predictor->init_from_file(cls_model_path);
|
||||
return RETURN_OK;
|
||||
}
|
||||
/**
|
||||
* for debug use, show result of First Step
|
||||
* @param filter_boxes
|
||||
* @param boxes
|
||||
* @param srcimg
|
||||
*/
|
||||
static void
|
||||
visual_img(const std::vector<std::vector<std::vector<int>>> &filter_boxes,
|
||||
const std::vector<std::vector<std::vector<int>>> &boxes,
|
||||
const cv::Mat &srcimg) {
|
||||
// visualization
|
||||
cv::Point rook_points[filter_boxes.size()][4];
|
||||
for (int n = 0; n < filter_boxes.size(); n++) {
|
||||
for (int m = 0; m < filter_boxes[0].size(); m++) {
|
||||
rook_points[n][m] =
|
||||
cv::Point(int(filter_boxes[n][m][0]), int(filter_boxes[n][m][1]));
|
||||
}
|
||||
}
|
||||
|
||||
cv::Mat img_vis;
|
||||
srcimg.copyTo(img_vis);
|
||||
for (int n = 0; n < boxes.size(); n++) {
|
||||
const cv::Point *ppt[1] = {rook_points[n]};
|
||||
int npt[] = {4};
|
||||
cv::polylines(img_vis, ppt, npt, 1, 1, CV_RGB(0, 255, 0), 2, 8, 0);
|
||||
}
|
||||
// 调试用，自行替换需要修改的路径
|
||||
cv::imwrite("/sdcard/1/vis.png", img_vis);
|
||||
}
|
||||
|
||||
std::vector<OCRPredictResult>
|
||||
OCR_PPredictor::infer_ocr(cv::Mat &origin,int max_size_len, int run_det, int run_cls, int run_rec) {
|
||||
LOGI("ocr cpp start *****************");
|
||||
LOGI("ocr cpp det: %d, cls: %d, rec: %d", run_det, run_cls, run_rec);
|
||||
std::vector<OCRPredictResult> ocr_results;
|
||||
if (run_det || run_rec) {
|
||||
infer_det(origin, max_size_len, ocr_results);
|
||||
}
|
||||
if (run_rec) {
|
||||
if (ocr_results.empty()) {
|
||||
OCRPredictResult res;
|
||||
ocr_results.emplace_back(std::move(res));
|
||||
}
|
||||
for (auto & ocr_result : ocr_results) {
|
||||
infer_rec(origin, run_cls, ocr_result);
|
||||
}
|
||||
}
|
||||
if (run_cls) {
|
||||
ClsPredictResult cls_res = infer_cls(origin);
|
||||
OCRPredictResult res;
|
||||
res.cls_score = cls_res.cls_score;
|
||||
res.cls_label = cls_res.cls_label;
|
||||
ocr_results.push_back(res);
|
||||
}
|
||||
|
||||
LOGI("ocr cpp end *****************");
|
||||
return ocr_results;
|
||||
}
|
||||
|
||||
cv::Mat DetResizeImg(const cv::Mat img, int max_size_len,
|
||||
std::vector<float> &ratio_hw) {
|
||||
int w = img.cols;
|
||||
int h = img.rows;
|
||||
|
||||
float ratio = 1.f;
|
||||
int max_wh = w >= h ? w : h;
|
||||
if (max_wh > max_size_len) {
|
||||
if (h > w) {
|
||||
ratio = static_cast<float>(max_size_len) / static_cast<float>(h);
|
||||
} else {
|
||||
ratio = static_cast<float>(max_size_len) / static_cast<float>(w);
|
||||
}
|
||||
}
|
||||
|
||||
int resize_h = static_cast<int>(float(h) * ratio);
|
||||
int resize_w = static_cast<int>(float(w) * ratio);
|
||||
int shapeSize = 32;
|
||||
if (resize_h % shapeSize == 0)
|
||||
resize_h = resize_h;
|
||||
else if (resize_h / shapeSize < 1 + 1e-5)
|
||||
resize_h = shapeSize;
|
||||
else
|
||||
resize_h = (resize_h / shapeSize - 1) * shapeSize;
|
||||
|
||||
if (resize_w % shapeSize == 0)
|
||||
resize_w = resize_w;
|
||||
else if (resize_w / shapeSize < 1 + 1e-5)
|
||||
resize_w = shapeSize;
|
||||
else
|
||||
resize_w = (resize_w / shapeSize - 1) * shapeSize;
|
||||
|
||||
cv::Mat resize_img;
|
||||
cv::resize(img, resize_img, cv::Size(resize_w, resize_h));
|
||||
|
||||
ratio_hw.push_back(static_cast<float>(resize_h) / static_cast<float>(h));
|
||||
ratio_hw.push_back(static_cast<float>(resize_w) / static_cast<float>(w));
|
||||
return resize_img;
|
||||
}
|
||||
|
||||
void OCR_PPredictor::infer_det(cv::Mat &origin, int max_size_len, std::vector<OCRPredictResult> &ocr_results) {
|
||||
std::vector<float> mean = {0.485f, 0.456f, 0.406f};
|
||||
std::vector<float> scale = {1 / 0.229f, 1 / 0.224f, 1 / 0.225f};
|
||||
|
||||
PredictorInput input = _det_predictor->get_first_input();
|
||||
|
||||
std::vector<float> ratio_hw;
|
||||
cv::Mat input_image = DetResizeImg(origin, max_size_len, ratio_hw);
|
||||
input_image.convertTo(input_image, CV_32FC3, 1 / 255.0f);
|
||||
const float *dimg = reinterpret_cast<const float *>(input_image.data);
|
||||
int input_size = input_image.rows * input_image.cols;
|
||||
|
||||
input.set_dims({1, 3, input_image.rows, input_image.cols});
|
||||
|
||||
neon_mean_scale(dimg, input.get_mutable_float_data(), input_size, mean,
|
||||
scale);
|
||||
LOGI("ocr cpp det shape %d,%d", input_image.rows,input_image.cols);
|
||||
std::vector<PredictorOutput> results = _det_predictor->infer();
|
||||
PredictorOutput &res = results.at(0);
|
||||
std::vector<std::vector<std::vector<int>>> filtered_box = calc_filtered_boxes(
|
||||
res.get_float_data(), res.get_size(), input_image.rows, input_image.cols, origin);
|
||||
LOGI("ocr cpp det Filter_box size %ld", filtered_box.size());
|
||||
|
||||
for(auto & i : filtered_box){
|
||||
LOGI("ocr cpp box %d,%d,%d,%d,%d,%d,%d,%d", i[0][0],i[0][1], i[1][0],i[1][1], i[2][0],i[2][1], i[3][0],i[3][1]);
|
||||
OCRPredictResult res;
|
||||
res.points = i;
|
||||
ocr_results.push_back(res);
|
||||
}
|
||||
}
|
||||
|
||||
void OCR_PPredictor::infer_rec(const cv::Mat &origin_img, int run_cls, OCRPredictResult& ocr_result) {
|
||||
std::vector<float> mean = {0.5f, 0.5f, 0.5f};
|
||||
std::vector<float> scale = {1 / 0.5f, 1 / 0.5f, 1 / 0.5f};
|
||||
std::vector<int64_t> dims = {1, 3, 0, 0};
|
||||
|
||||
PredictorInput input = _rec_predictor->get_first_input();
|
||||
|
||||
const std::vector<std::vector<int>> &box = ocr_result.points;
|
||||
cv::Mat crop_img;
|
||||
if (!box.empty()) {
|
||||
crop_img = get_rotate_crop_image(origin_img, box);
|
||||
} else {
|
||||
crop_img = origin_img;
|
||||
}
|
||||
|
||||
if (run_cls) {
|
||||
ClsPredictResult cls_res = infer_cls(crop_img);
|
||||
crop_img = cls_res.img;
|
||||
ocr_result.cls_score = cls_res.cls_score;
|
||||
ocr_result.cls_label = cls_res.cls_label;
|
||||
}
|
||||
|
||||
float wh_ratio = float(crop_img.cols) / float(crop_img.rows);
|
||||
cv::Mat input_image = crnn_resize_img(crop_img, wh_ratio);
|
||||
input_image.convertTo(input_image, CV_32FC3, 1 / 255.0f);
|
||||
const float *dimg = reinterpret_cast<const float *>(input_image.data);
|
||||
int input_size = input_image.rows * input_image.cols;
|
||||
|
||||
dims[2] = input_image.rows;
|
||||
dims[3] = input_image.cols;
|
||||
input.set_dims(dims);
|
||||
|
||||
neon_mean_scale(dimg, input.get_mutable_float_data(), input_size, mean,
|
||||
scale);
|
||||
|
||||
std::vector<PredictorOutput> results = _rec_predictor->infer();
|
||||
const float *predict_batch = results.at(0).get_float_data();
|
||||
const std::vector<int64_t> predict_shape = results.at(0).get_shape();
|
||||
|
||||
// ctc decode
|
||||
int argmax_idx;
|
||||
int last_index = 0;
|
||||
float score = 0.f;
|
||||
int count = 0;
|
||||
float max_value = 0.0f;
|
||||
|
||||
for (int n = 0; n < predict_shape[1]; n++) {
|
||||
argmax_idx = int(argmax(&predict_batch[n * predict_shape[2]],
|
||||
&predict_batch[(n + 1) * predict_shape[2]]));
|
||||
max_value =
|
||||
float(*std::max_element(&predict_batch[n * predict_shape[2]],
|
||||
&predict_batch[(n + 1) * predict_shape[2]]));
|
||||
if (argmax_idx > 0 && (!(n > 0 && argmax_idx == last_index))) {
|
||||
score += max_value;
|
||||
count += 1;
|
||||
ocr_result.word_index.push_back(argmax_idx);
|
||||
}
|
||||
last_index = argmax_idx;
|
||||
}
|
||||
score /= count;
|
||||
ocr_result.score = score;
|
||||
LOGI("ocr cpp rec word size %ld", count);
|
||||
}
|
||||
|
||||
ClsPredictResult OCR_PPredictor::infer_cls(const cv::Mat &img, float thresh) {
|
||||
std::vector<float> mean = {0.5f, 0.5f, 0.5f};
|
||||
std::vector<float> scale = {1 / 0.5f, 1 / 0.5f, 1 / 0.5f};
|
||||
std::vector<int64_t> dims = {1, 3, 0, 0};
|
||||
|
||||
PredictorInput input = _cls_predictor->get_first_input();
|
||||
|
||||
cv::Mat input_image = cls_resize_img(img);
|
||||
input_image.convertTo(input_image, CV_32FC3, 1 / 255.0f);
|
||||
const float *dimg = reinterpret_cast<const float *>(input_image.data);
|
||||
int input_size = input_image.rows * input_image.cols;
|
||||
|
||||
dims[2] = input_image.rows;
|
||||
dims[3] = input_image.cols;
|
||||
input.set_dims(dims);
|
||||
|
||||
neon_mean_scale(dimg, input.get_mutable_float_data(), input_size, mean,
|
||||
scale);
|
||||
|
||||
std::vector<PredictorOutput> results = _cls_predictor->infer();
|
||||
|
||||
const float *scores = results.at(0).get_float_data();
|
||||
float score = 0;
|
||||
int label = 0;
|
||||
for (int64_t i = 0; i < results.at(0).get_size(); i++) {
|
||||
LOGI("ocr cpp cls output scores [%f]", scores[i]);
|
||||
if (scores[i] > score) {
|
||||
score = scores[i];
|
||||
label = i;
|
||||
}
|
||||
}
|
||||
cv::Mat srcimg;
|
||||
img.copyTo(srcimg);
|
||||
if (label % 2 == 1 && score > thresh) {
|
||||
cv::rotate(srcimg, srcimg, 1);
|
||||
}
|
||||
ClsPredictResult res;
|
||||
res.cls_label = label;
|
||||
res.cls_score = score;
|
||||
res.img = srcimg;
|
||||
LOGI("ocr cpp cls word cls %ld, %f", label, score);
|
||||
return res;
|
||||
}
|
||||
|
||||
std::vector<std::vector<std::vector<int>>>
|
||||
OCR_PPredictor::calc_filtered_boxes(const float *pred, int pred_size,
|
||||
int output_height, int output_width,
|
||||
const cv::Mat &origin) {
|
||||
const double threshold = 0.3;
|
||||
const double maxvalue = 1;
|
||||
|
||||
cv::Mat pred_map = cv::Mat::zeros(output_height, output_width, CV_32F);
|
||||
memcpy(pred_map.data, pred, pred_size * sizeof(float));
|
||||
cv::Mat cbuf_map;
|
||||
pred_map.convertTo(cbuf_map, CV_8UC1);
|
||||
|
||||
cv::Mat bit_map;
|
||||
cv::threshold(cbuf_map, bit_map, threshold, maxvalue, cv::THRESH_BINARY);
|
||||
|
||||
std::vector<std::vector<std::vector<int>>> boxes =
|
||||
boxes_from_bitmap(pred_map, bit_map);
|
||||
float ratio_h = output_height * 1.0f / origin.rows;
|
||||
float ratio_w = output_width * 1.0f / origin.cols;
|
||||
std::vector<std::vector<std::vector<int>>> filter_boxes =
|
||||
filter_tag_det_res(boxes, ratio_h, ratio_w, origin);
|
||||
return filter_boxes;
|
||||
}
|
||||
|
||||
std::vector<int>
|
||||
OCR_PPredictor::postprocess_rec_word_index(const PredictorOutput &res) {
|
||||
const int *rec_idx = res.get_int_data();
|
||||
const std::vector<std::vector<uint64_t>> rec_idx_lod = res.get_lod();
|
||||
|
||||
std::vector<int> pred_idx;
|
||||
for (int n = int(rec_idx_lod[0][0]); n < int(rec_idx_lod[0][1] * 2); n += 2) {
|
||||
pred_idx.emplace_back(rec_idx[n]);
|
||||
}
|
||||
return pred_idx;
|
||||
}
|
||||
|
||||
float OCR_PPredictor::postprocess_rec_score(const PredictorOutput &res) {
|
||||
const float *predict_batch = res.get_float_data();
|
||||
const std::vector<int64_t> predict_shape = res.get_shape();
|
||||
const std::vector<std::vector<uint64_t>> predict_lod = res.get_lod();
|
||||
int blank = predict_shape[1];
|
||||
float score = 0.f;
|
||||
int count = 0;
|
||||
for (int n = predict_lod[0][0]; n < predict_lod[0][1] - 1; n++) {
|
||||
int argmax_idx = argmax(predict_batch + n * predict_shape[1],
|
||||
predict_batch + (n + 1) * predict_shape[1]);
|
||||
float max_value = predict_batch[n * predict_shape[1] + argmax_idx];
|
||||
if (blank - 1 - argmax_idx > 1e-5) {
|
||||
score += max_value;
|
||||
count += 1;
|
||||
}
|
||||
}
|
||||
if (count == 0) {
|
||||
LOGE("calc score count 0");
|
||||
} else {
|
||||
score /= count;
|
||||
}
|
||||
LOGI("calc score: %f", score);
|
||||
return score;
|
||||
}
|
||||
|
||||
NET_TYPE OCR_PPredictor::get_net_flag() const { return NET_OCR; }
|
||||
}
|
||||
@@ -1,130 +0,0 @@
|
||||
//
|
||||
// Created by fujiayi on 2020/7/1.
|
||||
//
|
||||
|
||||
#pragma once
|
||||
|
||||
#include "ppredictor.h"
|
||||
#include <opencv2/opencv.hpp>
|
||||
#include <paddle_api.h>
|
||||
#include <string>
|
||||
|
||||
namespace ppredictor {
|
||||
|
||||
/**
|
||||
* Config
|
||||
*/
|
||||
struct OCR_Config {
|
||||
int use_opencl = 0;
|
||||
int thread_num = 4; // Thread num
|
||||
paddle::lite_api::PowerMode mode =
|
||||
paddle::lite_api::LITE_POWER_HIGH; // PaddleLite Mode
|
||||
};
|
||||
|
||||
/**
|
||||
* PolyGone Result
|
||||
*/
|
||||
struct OCRPredictResult {
|
||||
std::vector<int> word_index;
|
||||
std::vector<std::vector<int>> points;
|
||||
float score;
|
||||
float cls_score;
|
||||
int cls_label=-1;
|
||||
};
|
||||
|
||||
struct ClsPredictResult {
|
||||
float cls_score;
|
||||
int cls_label=-1;
|
||||
cv::Mat img;
|
||||
};
|
||||
/**
|
||||
* OCR there are 2 models
|
||||
* 1. First model（det），select polygones to show where are the texts
|
||||
* 2. crop from the origin images, use these polygones to infer
|
||||
*/
|
||||
class OCR_PPredictor : public PPredictor_Interface {
|
||||
public:
|
||||
OCR_PPredictor(const OCR_Config &config);
|
||||
|
||||
virtual ~OCR_PPredictor() {}
|
||||
|
||||
/**
|
||||
* 初始化二个模型的Predictor
|
||||
* @param det_model_content
|
||||
* @param rec_model_content
|
||||
* @return
|
||||
*/
|
||||
int init(const std::string &det_model_content,
|
||||
const std::string &rec_model_content,
|
||||
const std::string &cls_model_content);
|
||||
int init_from_file(const std::string &det_model_path,
|
||||
const std::string &rec_model_path,
|
||||
const std::string &cls_model_path);
|
||||
/**
|
||||
* Return OCR result
|
||||
* @param dims
|
||||
* @param input_data
|
||||
* @param input_len
|
||||
* @param net_flag
|
||||
* @param origin
|
||||
* @return
|
||||
*/
|
||||
virtual std::vector<OCRPredictResult>
|
||||
infer_ocr(cv::Mat &origin, int max_size_len, int run_det, int run_cls, int run_rec);
|
||||
|
||||
virtual NET_TYPE get_net_flag() const;
|
||||
|
||||
private:
|
||||
/**
|
||||
* calcul Polygone from the result image of first model
|
||||
* @param pred
|
||||
* @param output_height
|
||||
* @param output_width
|
||||
* @param origin
|
||||
* @return
|
||||
*/
|
||||
std::vector<std::vector<std::vector<int>>>
|
||||
calc_filtered_boxes(const float *pred, int pred_size, int output_height,
|
||||
int output_width, const cv::Mat &origin);
|
||||
|
||||
void
|
||||
infer_det(cv::Mat &origin, int max_side_len, std::vector<OCRPredictResult>& ocr_results);
|
||||
/**
|
||||
* infer for rec model
|
||||
*
|
||||
* @param boxes
|
||||
* @param origin
|
||||
* @return
|
||||
*/
|
||||
void
|
||||
infer_rec(const cv::Mat &origin, int run_cls, OCRPredictResult& ocr_result);
|
||||
|
||||
/**
|
||||
* infer for cls model
|
||||
*
|
||||
* @param boxes
|
||||
* @param origin
|
||||
* @return
|
||||
*/
|
||||
ClsPredictResult infer_cls(const cv::Mat &origin, float thresh = 0.9);
|
||||
|
||||
/**
|
||||
* Postprocess or sencod model to extract text
|
||||
* @param res
|
||||
* @return
|
||||
*/
|
||||
std::vector<int> postprocess_rec_word_index(const PredictorOutput &res);
|
||||
|
||||
/**
|
||||
* calculate confidence of second model text result
|
||||
* @param res
|
||||
* @return
|
||||
*/
|
||||
float postprocess_rec_score(const PredictorOutput &res);
|
||||
|
||||
std::unique_ptr<PPredictor> _det_predictor;
|
||||
std::unique_ptr<PPredictor> _rec_predictor;
|
||||
std::unique_ptr<PPredictor> _cls_predictor;
|
||||
OCR_Config _config;
|
||||
};
|
||||
}
|
||||
@@ -1,95 +0,0 @@
|
||||
#include "ppredictor.h"
|
||||
#include "common.h"
|
||||
|
||||
namespace ppredictor {
|
||||
PPredictor::PPredictor(int use_opencl, int thread_num, int net_flag,
|
||||
paddle::lite_api::PowerMode mode)
|
||||
: _use_opencl(use_opencl), _thread_num(thread_num), _net_flag(net_flag), _mode(mode) {}
|
||||
|
||||
int PPredictor::init_nb(const std::string &model_content) {
|
||||
paddle::lite_api::MobileConfig config;
|
||||
config.set_model_from_buffer(model_content);
|
||||
return _init(config);
|
||||
}
|
||||
|
||||
int PPredictor::init_from_file(const std::string &model_content) {
|
||||
paddle::lite_api::MobileConfig config;
|
||||
config.set_model_from_file(model_content);
|
||||
return _init(config);
|
||||
}
|
||||
|
||||
template <typename ConfigT> int PPredictor::_init(ConfigT &config) {
|
||||
bool is_opencl_backend_valid = paddle::lite_api::IsOpenCLBackendValid(/*check_fp16_valid = false*/);
|
||||
if (is_opencl_backend_valid) {
|
||||
if (_use_opencl != 0) {
|
||||
// Make sure you have write permission of the binary path.
|
||||
// We strongly recommend each model has a unique binary name.
|
||||
const std::string bin_path = "/data/local/tmp/";
|
||||
const std::string bin_name = "lite_opencl_kernel.bin";
|
||||
config.set_opencl_binary_path_name(bin_path, bin_name);
|
||||
|
||||
// opencl tune option
|
||||
// CL_TUNE_NONE: 0
|
||||
// CL_TUNE_RAPID: 1
|
||||
// CL_TUNE_NORMAL: 2
|
||||
// CL_TUNE_EXHAUSTIVE: 3
|
||||
const std::string tuned_path = "/data/local/tmp/";
|
||||
const std::string tuned_name = "lite_opencl_tuned.bin";
|
||||
config.set_opencl_tune(paddle::lite_api::CL_TUNE_NORMAL, tuned_path, tuned_name);
|
||||
|
||||
// opencl precision option
|
||||
// CL_PRECISION_AUTO: 0, first fp16 if valid, default
|
||||
// CL_PRECISION_FP32: 1, force fp32
|
||||
// CL_PRECISION_FP16: 2, force fp16
|
||||
config.set_opencl_precision(paddle::lite_api::CL_PRECISION_FP32);
|
||||
LOGI("ocr cpp device: running on gpu.");
|
||||
}
|
||||
} else {
|
||||
LOGI("ocr cpp device: running on cpu.");
|
||||
// you can give backup cpu nb model instead
|
||||
// config.set_model_from_file(cpu_nb_model_dir);
|
||||
}
|
||||
config.set_threads(_thread_num);
|
||||
config.set_power_mode(_mode);
|
||||
_predictor = paddle::lite_api::CreatePaddlePredictor(config);
|
||||
LOGI("ocr cpp paddle instance created");
|
||||
return RETURN_OK;
|
||||
}
|
||||
|
||||
PredictorInput PPredictor::get_input(int index) {
|
||||
PredictorInput input{_predictor->GetInput(index), index, _net_flag};
|
||||
_is_input_get = true;
|
||||
return input;
|
||||
}
|
||||
|
||||
std::vector<PredictorInput> PPredictor::get_inputs(int num) {
|
||||
std::vector<PredictorInput> results;
|
||||
for (int i = 0; i < num; i++) {
|
||||
results.emplace_back(get_input(i));
|
||||
}
|
||||
return results;
|
||||
}
|
||||
|
||||
PredictorInput PPredictor::get_first_input() { return get_input(0); }
|
||||
|
||||
std::vector<PredictorOutput> PPredictor::infer() {
|
||||
LOGI("ocr cpp infer Run start %d", _net_flag);
|
||||
std::vector<PredictorOutput> results;
|
||||
if (!_is_input_get) {
|
||||
return results;
|
||||
}
|
||||
_predictor->Run();
|
||||
LOGI("ocr cpp infer Run end");
|
||||
|
||||
for (int i = 0; i < _predictor->GetOutputNames().size(); i++) {
|
||||
std::unique_ptr<const paddle::lite_api::Tensor> output_tensor =
|
||||
_predictor->GetOutput(i);
|
||||
LOGI("ocr cpp output tensor[%d] size %ld", i, product(output_tensor->shape()));
|
||||
PredictorOutput result{std::move(output_tensor), i, _net_flag};
|
||||
results.emplace_back(std::move(result));
|
||||
}
|
||||
return results;
|
||||
}
|
||||
|
||||
NET_TYPE PPredictor::get_net_flag() const { return (NET_TYPE)_net_flag; }
|
||||
}
|
||||
@@ -1,64 +0,0 @@
|
||||
#pragma once
|
||||
|
||||
#include "paddle_api.h"
|
||||
#include "predictor_input.h"
|
||||
#include "predictor_output.h"
|
||||
|
||||
namespace ppredictor {
|
||||
|
||||
/**
|
||||
* PaddleLite Preditor Common Interface
|
||||
*/
|
||||
class PPredictor_Interface {
|
||||
public:
|
||||
virtual ~PPredictor_Interface() {}
|
||||
|
||||
virtual NET_TYPE get_net_flag() const = 0;
|
||||
};
|
||||
|
||||
/**
|
||||
* Common Predictor
|
||||
*/
|
||||
class PPredictor : public PPredictor_Interface {
|
||||
public:
|
||||
PPredictor(
|
||||
int use_opencl, int thread_num, int net_flag = 0,
|
||||
paddle::lite_api::PowerMode mode = paddle::lite_api::LITE_POWER_HIGH);
|
||||
|
||||
virtual ~PPredictor() {}
|
||||
|
||||
/**
|
||||
* init paddlitelite opt model，nb format ，or use ini_paddle
|
||||
* @param model_content
|
||||
* @return 0
|
||||
*/
|
||||
virtual int init_nb(const std::string &model_content);
|
||||
|
||||
virtual int init_from_file(const std::string &model_content);
|
||||
|
||||
std::vector<PredictorOutput> infer();
|
||||
|
||||
std::shared_ptr<paddle::lite_api::PaddlePredictor> get_predictor() {
|
||||
return _predictor;
|
||||
}
|
||||
|
||||
virtual std::vector<PredictorInput> get_inputs(int num);
|
||||
|
||||
virtual PredictorInput get_input(int index);
|
||||
|
||||
virtual PredictorInput get_first_input();
|
||||
|
||||
virtual NET_TYPE get_net_flag() const;
|
||||
|
||||
protected:
|
||||
template <typename ConfigT> int _init(ConfigT &config);
|
||||
|
||||
private:
|
||||
int _use_opencl;
|
||||
int _thread_num;
|
||||
paddle::lite_api::PowerMode _mode;
|
||||
std::shared_ptr<paddle::lite_api::PaddlePredictor> _predictor;
|
||||
bool _is_input_get = false;
|
||||
int _net_flag;
|
||||
};
|
||||
}
|
||||
@@ -1,28 +0,0 @@
|
||||
#include "predictor_input.h"
|
||||
|
||||
namespace ppredictor {
|
||||
|
||||
void PredictorInput::set_dims(std::vector<int64_t> dims) {
|
||||
// yolov3
|
||||
if (_net_flag == 101 && _index == 1) {
|
||||
_tensor->Resize({1, 2});
|
||||
_tensor->mutable_data<int>()[0] = (int)dims.at(2);
|
||||
_tensor->mutable_data<int>()[1] = (int)dims.at(3);
|
||||
} else {
|
||||
_tensor->Resize(dims);
|
||||
}
|
||||
_is_dims_set = true;
|
||||
}
|
||||
|
||||
float *PredictorInput::get_mutable_float_data() {
|
||||
if (!_is_dims_set) {
|
||||
LOGE("PredictorInput::set_dims is not called");
|
||||
}
|
||||
return _tensor->mutable_data<float>();
|
||||
}
|
||||
|
||||
void PredictorInput::set_data(const float *input_data, int input_float_len) {
|
||||
float *input_raw_data = get_mutable_float_data();
|
||||
memcpy(input_raw_data, input_data, input_float_len * sizeof(float));
|
||||
}
|
||||
}
|
||||
@@ -1,26 +0,0 @@
|
||||
#pragma once
|
||||
|
||||
#include "common.h"
|
||||
#include <paddle_api.h>
|
||||
#include <vector>
|
||||
|
||||
namespace ppredictor {
|
||||
class PredictorInput {
|
||||
public:
|
||||
PredictorInput(std::unique_ptr<paddle::lite_api::Tensor> &&tensor, int index,
|
||||
int net_flag)
|
||||
: _tensor(std::move(tensor)), _index(index), _net_flag(net_flag) {}
|
||||
|
||||
void set_dims(std::vector<int64_t> dims);
|
||||
|
||||
float *get_mutable_float_data();
|
||||
|
||||
void set_data(const float *input_data, int input_float_len);
|
||||
|
||||
private:
|
||||
std::unique_ptr<paddle::lite_api::Tensor> _tensor;
|
||||
bool _is_dims_set = false;
|
||||
int _index;
|
||||
int _net_flag;
|
||||
};
|
||||
}
|
||||
@@ -1,26 +0,0 @@
|
||||
#include "predictor_output.h"
|
||||
namespace ppredictor {
|
||||
const float *PredictorOutput::get_float_data() const {
|
||||
return _tensor->data<float>();
|
||||
}
|
||||
|
||||
const int *PredictorOutput::get_int_data() const {
|
||||
return _tensor->data<int>();
|
||||
}
|
||||
|
||||
const std::vector<std::vector<uint64_t>> PredictorOutput::get_lod() const {
|
||||
return _tensor->lod();
|
||||
}
|
||||
|
||||
int64_t PredictorOutput::get_size() const {
|
||||
if (_net_flag == NET_OCR) {
|
||||
return _tensor->shape().at(2) * _tensor->shape().at(3);
|
||||
} else {
|
||||
return product(_tensor->shape());
|
||||
}
|
||||
}
|
||||
|
||||
const std::vector<int64_t> PredictorOutput::get_shape() const {
|
||||
return _tensor->shape();
|
||||
}
|
||||
}
|
||||
@@ -1,31 +0,0 @@
|
||||
#pragma once
|
||||
|
||||
#include "common.h"
|
||||
#include <paddle_api.h>
|
||||
#include <vector>
|
||||
|
||||
namespace ppredictor {
|
||||
class PredictorOutput {
|
||||
public:
|
||||
PredictorOutput() {}
|
||||
PredictorOutput(std::unique_ptr<const paddle::lite_api::Tensor> &&tensor,
|
||||
int index, int net_flag)
|
||||
: _tensor(std::move(tensor)), _index(index), _net_flag(net_flag) {}
|
||||
|
||||
const float *get_float_data() const;
|
||||
const int *get_int_data() const;
|
||||
int64_t get_size() const;
|
||||
const std::vector<std::vector<uint64_t>> get_lod() const;
|
||||
const std::vector<int64_t> get_shape() const;
|
||||
|
||||
std::vector<float> data; // return float, or use data_int
|
||||
std::vector<int> data_int; // several layers return int ，or use data
|
||||
std::vector<int64_t> shape; // PaddleLite output shape
|
||||
std::vector<std::vector<uint64_t>> lod; // PaddleLite output lod
|
||||
|
||||
private:
|
||||
std::unique_ptr<const paddle::lite_api::Tensor> _tensor;
|
||||
int _index;
|
||||
int _net_flag;
|
||||
};
|
||||
}
|
||||
@@ -1,82 +0,0 @@
|
||||
#include "preprocess.h"
|
||||
#include <android/bitmap.h>
|
||||
|
||||
cv::Mat bitmap_to_cv_mat(JNIEnv *env, jobject bitmap) {
|
||||
AndroidBitmapInfo info;
|
||||
int result = AndroidBitmap_getInfo(env, bitmap, &info);
|
||||
if (result != ANDROID_BITMAP_RESULT_SUCCESS) {
|
||||
LOGE("AndroidBitmap_getInfo failed, result: %d", result);
|
||||
return cv::Mat{};
|
||||
}
|
||||
if (info.format != ANDROID_BITMAP_FORMAT_RGBA_8888) {
|
||||
LOGE("Bitmap format is not RGBA_8888 !");
|
||||
return cv::Mat{};
|
||||
}
|
||||
unsigned char *srcData = NULL;
|
||||
AndroidBitmap_lockPixels(env, bitmap, (void **)&srcData);
|
||||
cv::Mat mat = cv::Mat::zeros(info.height, info.width, CV_8UC4);
|
||||
memcpy(mat.data, srcData, info.height * info.width * 4);
|
||||
AndroidBitmap_unlockPixels(env, bitmap);
|
||||
cv::cvtColor(mat, mat, cv::COLOR_RGBA2BGR);
|
||||
/**
|
||||
if (!cv::imwrite("/sdcard/1/copy.jpg", mat)){
|
||||
LOGE("Write image failed " );
|
||||
}
|
||||
*/
|
||||
|
||||
return mat;
|
||||
}
|
||||
|
||||
cv::Mat resize_img(const cv::Mat &img, int height, int width) {
|
||||
if (img.rows == height && img.cols == width) {
|
||||
return img;
|
||||
}
|
||||
cv::Mat new_img;
|
||||
cv::resize(img, new_img, cv::Size(height, width));
|
||||
return new_img;
|
||||
}
|
||||
|
||||
// fill tensor with mean and scale and trans layout: nhwc -> nchw, neon speed up
|
||||
void neon_mean_scale(const float *din, float *dout, int size,
|
||||
const std::vector<float> &mean,
|
||||
const std::vector<float> &scale) {
|
||||
if (mean.size() != 3 || scale.size() != 3) {
|
||||
LOGE("[ERROR] mean or scale size must equal to 3");
|
||||
return;
|
||||
}
|
||||
|
||||
float32x4_t vmean0 = vdupq_n_f32(mean[0]);
|
||||
float32x4_t vmean1 = vdupq_n_f32(mean[1]);
|
||||
float32x4_t vmean2 = vdupq_n_f32(mean[2]);
|
||||
float32x4_t vscale0 = vdupq_n_f32(scale[0]);
|
||||
float32x4_t vscale1 = vdupq_n_f32(scale[1]);
|
||||
float32x4_t vscale2 = vdupq_n_f32(scale[2]);
|
||||
|
||||
float *dout_c0 = dout;
|
||||
float *dout_c1 = dout + size;
|
||||
float *dout_c2 = dout + size * 2;
|
||||
|
||||
int i = 0;
|
||||
for (; i < size - 3; i += 4) {
|
||||
float32x4x3_t vin3 = vld3q_f32(din);
|
||||
float32x4_t vsub0 = vsubq_f32(vin3.val[0], vmean0);
|
||||
float32x4_t vsub1 = vsubq_f32(vin3.val[1], vmean1);
|
||||
float32x4_t vsub2 = vsubq_f32(vin3.val[2], vmean2);
|
||||
float32x4_t vs0 = vmulq_f32(vsub0, vscale0);
|
||||
float32x4_t vs1 = vmulq_f32(vsub1, vscale1);
|
||||
float32x4_t vs2 = vmulq_f32(vsub2, vscale2);
|
||||
vst1q_f32(dout_c0, vs0);
|
||||
vst1q_f32(dout_c1, vs1);
|
||||
vst1q_f32(dout_c2, vs2);
|
||||
|
||||
din += 12;
|
||||
dout_c0 += 4;
|
||||
dout_c1 += 4;
|
||||
dout_c2 += 4;
|
||||
}
|
||||
for (; i < size; i++) {
|
||||
*(dout_c0++) = (*(din++) - mean[0]) * scale[0];
|
||||
*(dout_c1++) = (*(din++) - mean[1]) * scale[1];
|
||||
*(dout_c2++) = (*(din++) - mean[2]) * scale[2];
|
||||
}
|
||||
}
|
||||
@@ -1,12 +0,0 @@
|
||||
#pragma once
|
||||
|
||||
#include "common.h"
|
||||
#include <jni.h>
|
||||
#include <opencv2/opencv.hpp>
|
||||
cv::Mat bitmap_to_cv_mat(JNIEnv *env, jobject bitmap);
|
||||
|
||||
cv::Mat resize_img(const cv::Mat &img, int height, int width);
|
||||
|
||||
void neon_mean_scale(const float *din, float *dout, int size,
|
||||
const std::vector<float> &mean,
|
||||
const std::vector<float> &scale);
|
||||
@@ -1,126 +0,0 @@
|
||||
package com.baidu.paddle.lite.ocr;
|
||||
|
||||
import android.graphics.Bitmap;
|
||||
import android.util.Log;
|
||||
|
||||
import org.opencv.android.OpenCVLoader;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.concurrent.atomic.AtomicBoolean;
|
||||
import java.util.concurrent.locks.ReentrantLock;
|
||||
|
||||
/**
|
||||
* @author PaddleOCR
|
||||
* Modified by TonyJiangWJ
|
||||
* @since 2023-08-06
|
||||
*/
|
||||
public class OCRPredictorNative {
|
||||
|
||||
private static final AtomicBoolean isSOLoaded = new AtomicBoolean();
|
||||
private static final ReentrantLock lock = new ReentrantLock();
|
||||
|
||||
public static void loadLibrary() throws RuntimeException {
|
||||
if (!isSOLoaded.get() && isSOLoaded.compareAndSet(false, true)) {
|
||||
try {
|
||||
// 可能和 AJ 中的 OpenCV 冲突, 直接初始化一遍
|
||||
OpenCVLoader.initDebug();
|
||||
System.loadLibrary("Native");
|
||||
} catch (Throwable e) {
|
||||
throw new RuntimeException(
|
||||
"Load libNative.so failed, please check it exists in apk file.", e);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private Config config;
|
||||
|
||||
private long nativePointer = 0;
|
||||
|
||||
public OCRPredictorNative(Config config) {
|
||||
lock.lock();
|
||||
try {
|
||||
this.config = config;
|
||||
loadLibrary();
|
||||
nativePointer = init(config.detModelFilename, config.recModelFilename, config.clsModelFilename, config.useOpencl,
|
||||
config.cpuThreadNum, config.cpuPower);
|
||||
Log.i("OCRPredictorNative", "load success " + nativePointer);
|
||||
} finally {
|
||||
lock.unlock();
|
||||
}
|
||||
}
|
||||
|
||||
public ArrayList<OcrResultModel> runImage(Bitmap originalImage, int max_size_len, int run_det, int run_cls, int run_rec) {
|
||||
lock.lock();
|
||||
try {
|
||||
Log.i("OCRPredictorNative", "begin to run image");
|
||||
float[] rawResults = forward(nativePointer, originalImage, max_size_len, run_det, run_cls, run_rec);
|
||||
return postprocess(rawResults);
|
||||
} finally {
|
||||
lock.unlock();
|
||||
}
|
||||
}
|
||||
|
||||
public static class Config {
|
||||
public int useOpencl;
|
||||
public int cpuThreadNum;
|
||||
public String cpuPower;
|
||||
public String detModelFilename;
|
||||
public String recModelFilename;
|
||||
public String clsModelFilename;
|
||||
|
||||
}
|
||||
|
||||
public void destroy() {
|
||||
if (nativePointer != 0) {
|
||||
release(nativePointer);
|
||||
nativePointer = 0;
|
||||
}
|
||||
}
|
||||
|
||||
protected native long init(String detModelPath, String recModelPath, String clsModelPath, int useOpencl, int threadNum, String cpuMode);
|
||||
|
||||
protected native float[] forward(long pointer, Bitmap originalImage, int max_size_len, int run_det, int run_cls, int run_rec);
|
||||
|
||||
protected native void release(long pointer);
|
||||
|
||||
private ArrayList<OcrResultModel> postprocess(float[] raw) {
|
||||
ArrayList<OcrResultModel> results = new ArrayList<OcrResultModel>();
|
||||
int begin = 0;
|
||||
|
||||
while (begin < raw.length) {
|
||||
int point_num = Math.round(raw[begin]);
|
||||
int word_num = Math.round(raw[begin + 1]);
|
||||
OcrResultModel model = parse(raw, begin + 2, point_num, word_num);
|
||||
begin += 2 + 1 + point_num * 2 + word_num + 2;
|
||||
results.add(model);
|
||||
}
|
||||
|
||||
return results;
|
||||
}
|
||||
|
||||
private OcrResultModel parse(float[] raw, int begin, int pointNum, int wordNum) {
|
||||
int current = begin;
|
||||
OcrResultModel model = new OcrResultModel();
|
||||
model.setConfidence(raw[current]);
|
||||
current++;
|
||||
for (int i = 0; i < pointNum; i++) {
|
||||
model.addPoints(Math.round(raw[current + i * 2]), Math.round(raw[current + i * 2 + 1]));
|
||||
}
|
||||
current += (pointNum * 2);
|
||||
for (int i = 0; i < wordNum; i++) {
|
||||
int index = Math.round(raw[current + i]);
|
||||
model.addWordIndex(index);
|
||||
}
|
||||
current += wordNum;
|
||||
model.setClsIdx(raw[current]);
|
||||
model.setClsConfidence(raw[current + 1]);
|
||||
Log.i("OCRPredictorNative", "word finished " + wordNum);
|
||||
return model;
|
||||
}
|
||||
|
||||
@Override
|
||||
protected void finalize() throws Throwable {
|
||||
super.finalize();
|
||||
destroy();
|
||||
}
|
||||
}
|
||||
@@ -1,134 +0,0 @@
|
||||
package com.baidu.paddle.lite.ocr;
|
||||
|
||||
import android.graphics.Point;
|
||||
import android.graphics.Rect;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.List;
|
||||
|
||||
/**
|
||||
* @author PaddleOCR
|
||||
* Modified by TonyJiangWJ
|
||||
* @since 2023-08-06
|
||||
*/
|
||||
public class OcrResult implements Comparable<OcrResult> {
|
||||
private String label;
|
||||
private float confidence;
|
||||
private Rect bounds;
|
||||
private final List<OcrResult> elements = new ArrayList<>();
|
||||
|
||||
public OcrResult() {
|
||||
}
|
||||
|
||||
public OcrResult(OcrResultModel resultModel) {
|
||||
this.label = resultModel.getLabel();
|
||||
this.confidence = resultModel.getConfidence();
|
||||
int left = -1, right = -1, top = -1, bottom = -1;
|
||||
for (Point point : resultModel.getPoints()) {
|
||||
if (point.x < left || left == -1) {
|
||||
left = point.x;
|
||||
}
|
||||
if (point.x > right || right == -1) {
|
||||
right = point.x;
|
||||
}
|
||||
if (point.y < top || top == -1) {
|
||||
top = point.y;
|
||||
}
|
||||
if (point.y > bottom || bottom == -1) {
|
||||
bottom = point.y;
|
||||
}
|
||||
}
|
||||
this.bounds = new Rect(left, top, right, bottom);
|
||||
}
|
||||
|
||||
public OcrResult(String label, float confidence, Rect bounds) {
|
||||
this.label = label;
|
||||
this.confidence = confidence;
|
||||
this.bounds = bounds;
|
||||
}
|
||||
|
||||
public String getLabel() {
|
||||
return label;
|
||||
}
|
||||
|
||||
public void setLabel(String label) {
|
||||
this.label = label;
|
||||
}
|
||||
|
||||
public float getConfidence() {
|
||||
return confidence;
|
||||
}
|
||||
|
||||
public void setConfidence(float confidence) {
|
||||
this.confidence = confidence;
|
||||
}
|
||||
|
||||
public Rect getBounds() {
|
||||
return bounds;
|
||||
}
|
||||
|
||||
public void setBounds(Rect bounds) {
|
||||
this.bounds = bounds;
|
||||
}
|
||||
|
||||
public RectLocation getLocation() {
|
||||
return new RectLocation(bounds);
|
||||
}
|
||||
|
||||
public String getWords() {
|
||||
return label.trim().replace("\r", "");
|
||||
}
|
||||
|
||||
public List<OcrResult> getElements() {
|
||||
return this.elements;
|
||||
}
|
||||
|
||||
public void addElements(OcrResult element) {
|
||||
this.elements.add(element);
|
||||
}
|
||||
|
||||
@Override
|
||||
public int compareTo(OcrResult o) {
|
||||
// 上下差距小于二分之一的高度 判定为同一行
|
||||
int deviation = Math.max(this.bounds.height(), o.bounds.height()) / 2;
|
||||
// 通过垂直中心点的距离判定
|
||||
if (Math.abs((this.bounds.top + this.bounds.bottom) / 2 - (o.bounds.top + o.bounds.bottom) / 2) < deviation) {
|
||||
return this.bounds.left - o.bounds.left;
|
||||
} else {
|
||||
return this.bounds.bottom - o.bounds.bottom;
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public String toString() {
|
||||
return "OcrResult{" + "label='" + label + '\'' +
|
||||
", confidence=" + confidence +
|
||||
", bounds=" + bounds +
|
||||
", elements=" + elements +
|
||||
'}';
|
||||
}
|
||||
|
||||
public static class RectLocation {
|
||||
public int left;
|
||||
public int top;
|
||||
public int width;
|
||||
public int height;
|
||||
|
||||
public RectLocation() {
|
||||
}
|
||||
|
||||
public RectLocation(int left, int top, int width, int height) {
|
||||
this.left = left;
|
||||
this.top = top;
|
||||
this.width = width;
|
||||
this.height = height;
|
||||
}
|
||||
|
||||
public RectLocation(Rect rect) {
|
||||
left = rect.left;
|
||||
top = rect.top;
|
||||
width = rect.right - rect.left;
|
||||
height = rect.bottom - rect.top;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,97 +0,0 @@
|
||||
package com.baidu.paddle.lite.ocr;
|
||||
|
||||
import android.graphics.Point;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.List;
|
||||
|
||||
/**
|
||||
* @author PaddleOCR
|
||||
* Modified by TonyJiangWJ
|
||||
* @since 2023-08-06
|
||||
*/
|
||||
public class OcrResultModel {
|
||||
private final List<Point> points;
|
||||
private final List<Integer> wordIndex;
|
||||
private String label;
|
||||
private float confidence;
|
||||
private float clsIdx;
|
||||
private String clsLabel;
|
||||
private float clsConfidence;
|
||||
|
||||
public OcrResultModel() {
|
||||
super();
|
||||
points = new ArrayList<>();
|
||||
wordIndex = new ArrayList<>();
|
||||
}
|
||||
|
||||
public void addPoints(int x, int y) {
|
||||
Point point = new Point(x, y);
|
||||
points.add(point);
|
||||
}
|
||||
|
||||
public void addWordIndex(int index) {
|
||||
wordIndex.add(index);
|
||||
}
|
||||
|
||||
public List<Point> getPoints() {
|
||||
return points;
|
||||
}
|
||||
|
||||
public List<Integer> getWordIndex() {
|
||||
return wordIndex;
|
||||
}
|
||||
|
||||
public String getLabel() {
|
||||
return label;
|
||||
}
|
||||
|
||||
public void setLabel(String label) {
|
||||
this.label = label;
|
||||
}
|
||||
|
||||
public float getConfidence() {
|
||||
return confidence;
|
||||
}
|
||||
|
||||
public void setConfidence(float confidence) {
|
||||
this.confidence = confidence;
|
||||
}
|
||||
|
||||
public float getClsIdx() {
|
||||
return clsIdx;
|
||||
}
|
||||
|
||||
public void setClsIdx(float idx) {
|
||||
this.clsIdx = idx;
|
||||
}
|
||||
|
||||
public String getClsLabel() {
|
||||
return clsLabel;
|
||||
}
|
||||
|
||||
public void setClsLabel(String label) {
|
||||
this.clsLabel = label;
|
||||
}
|
||||
|
||||
public float getClsConfidence() {
|
||||
return clsConfidence;
|
||||
}
|
||||
|
||||
public void setClsConfidence(float confidence) {
|
||||
this.clsConfidence = confidence;
|
||||
}
|
||||
|
||||
@Override
|
||||
public String toString() {
|
||||
return "OcrResultModel{" +
|
||||
"points=" + points +
|
||||
", wordIndex=" + wordIndex +
|
||||
", label='" + label + '\'' +
|
||||
", confidence=" + confidence +
|
||||
", clsIdx=" + clsIdx +
|
||||
", clsLabel='" + clsLabel + '\'' +
|
||||
", clsConfidence=" + clsConfidence +
|
||||
'}';
|
||||
}
|
||||
}
|
||||
@@ -1,377 +0,0 @@
|
||||
package com.baidu.paddle.lite.ocr;
|
||||
|
||||
import android.content.Context;
|
||||
import android.graphics.Bitmap;
|
||||
import android.graphics.BitmapFactory;
|
||||
import android.os.Build;
|
||||
import android.util.Base64;
|
||||
import android.util.Log;
|
||||
|
||||
import androidx.preference.PreferenceManager;
|
||||
|
||||
import java.io.File;
|
||||
import java.io.FileInputStream;
|
||||
import java.io.InputStream;
|
||||
import java.nio.file.Files;
|
||||
import java.nio.file.Paths;
|
||||
import java.security.MessageDigest;
|
||||
import java.security.NoSuchAlgorithmException;
|
||||
import java.util.ArrayList;
|
||||
import java.util.Arrays;
|
||||
import java.util.Collections;
|
||||
import java.util.Date;
|
||||
import java.util.List;
|
||||
|
||||
/**
|
||||
* @author PaddleOCR
|
||||
* @since 2023-08-06
|
||||
* @noinspection unused
|
||||
* Modified by TonyJiangWJ as of Aug 7, 2023.
|
||||
* Modified by SuperMonster003 as of Oct 27, 2023.
|
||||
*/
|
||||
public class Predictor {
|
||||
private static final String TAG = Predictor.class.getSimpleName();
|
||||
public boolean isLoaded = false;
|
||||
public int warmupIterNum = 1;
|
||||
public int inferIterNum = 1;
|
||||
public int cpuThreadNum = 4;
|
||||
public String cpuPowerMode = "LITE_POWER_HIGH";
|
||||
public String modelPath = "";
|
||||
public String modelName = "";
|
||||
protected OCRPredictorNative paddlePredictor = null;
|
||||
protected float inferenceTime = 0;
|
||||
// Only for object detection
|
||||
protected List<String> wordLabels = new ArrayList<>();
|
||||
protected int detLongSize = 960;
|
||||
public float scoreThreshold = 0.1f;
|
||||
protected Bitmap inputImage = null;
|
||||
protected float preprocessTime = 0;
|
||||
/**
|
||||
* 自定义开关
|
||||
*/
|
||||
public boolean useSlim = true;
|
||||
public boolean useOpencl = false;
|
||||
public boolean checkModelLoaded = true;
|
||||
public boolean runCls = false;
|
||||
public boolean runDet = false;
|
||||
public boolean runRec = true;
|
||||
|
||||
/** @noinspection SpellCheckingInspection*/
|
||||
private static final String CHECK_IMG_BASE64 = "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";
|
||||
private static final Bitmap checkingBitmap = BitmapFactory.decodeByteArray(Base64.decode(CHECK_IMG_BASE64, Base64.DEFAULT), 0, Base64.decode(CHECK_IMG_BASE64, Base64.DEFAULT).length);
|
||||
/**
|
||||
* 检测模型
|
||||
*/
|
||||
public String detModelFilename = "det_opt.nb";
|
||||
/**
|
||||
* 识别模型
|
||||
*/
|
||||
public String recModelFilename = "rec_opt.nb";
|
||||
/**
|
||||
* 文本方向检测模型
|
||||
*/
|
||||
public String clsModelFilename = "cls_opt.nb";
|
||||
|
||||
private final String defaultLabelPath = "labels/ppocr_keys_v1.txt";
|
||||
private final String defaultModelPath = "models/ocr_v3_for_cpu";
|
||||
/**
|
||||
* slim模型 目前使用的是2.10版的opt工具转换的2.11版本不能正常使用
|
||||
*/
|
||||
private final String defaultModelPathSlim = "models/ocr_v3_for_cpu(slim)";
|
||||
|
||||
/**
|
||||
* 初始化时校验模型是否加载正确
|
||||
*/
|
||||
private int retryTime = 1;
|
||||
/**
|
||||
* 初始化尝试次数
|
||||
*/
|
||||
private int initRetryTime = 1;
|
||||
|
||||
public Predictor() {
|
||||
}
|
||||
|
||||
public boolean init(Context appCtx) {
|
||||
return this.init(appCtx, defaultModelPath, defaultLabelPath);
|
||||
}
|
||||
|
||||
public boolean init(Context appCtx, boolean useSlim) {
|
||||
if (this.isLoaded && this.useSlim == useSlim) {
|
||||
return true;
|
||||
}
|
||||
this.useSlim = useSlim;
|
||||
if (useSlim) {
|
||||
return this.init(appCtx, defaultModelPathSlim, defaultLabelPath);
|
||||
} else {
|
||||
return this.init(appCtx, defaultModelPath, defaultLabelPath);
|
||||
}
|
||||
}
|
||||
|
||||
public boolean init(Context appCtx, String modelPath, String labelPath) {
|
||||
Log.d(TAG, "init whit model: " + modelPath + " label: " + labelPath);
|
||||
isLoaded = loadModel(appCtx, modelPath, cpuThreadNum, cpuPowerMode);
|
||||
if (!isLoaded) {
|
||||
return false;
|
||||
}
|
||||
isLoaded = loadLabel(appCtx, labelPath);
|
||||
if (!checkModelLoadedSuccess()) {
|
||||
if (initRetryTime++ < 3) {
|
||||
return init(appCtx, modelPath, labelPath);
|
||||
} else {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
return isLoaded;
|
||||
}
|
||||
|
||||
/**
|
||||
* 初始化模型后通过识别预设图片校验是否初始化成功
|
||||
* 曲线救国 深层的失败原因需要后续排查
|
||||
*/
|
||||
private boolean checkModelLoadedSuccess() {
|
||||
if (!checkModelLoaded) {
|
||||
return true;
|
||||
}
|
||||
if (!isLoaded) {
|
||||
return false;
|
||||
}
|
||||
List<OcrResult> results = runOcr(checkingBitmap);
|
||||
StringBuilder sb = new StringBuilder();
|
||||
for (OcrResult result : results) {
|
||||
sb.append(result.getLabel());
|
||||
}
|
||||
boolean check = sb.toString().contains("测试");
|
||||
Log.d(TAG, "第" + retryTime + "次 校验是否初始化成功: " + check + " 识别结果：" + sb);
|
||||
boolean result = check || retryTime++ >= 5;
|
||||
if (!check && retryTime >= 5) {
|
||||
Log.e(TAG, "初始化模型失败");
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
public boolean init(Context appCtx, String modelPath, String labelPath, int cpuThreadNum, String cpuPowerMode) {
|
||||
isLoaded = loadModel(appCtx, modelPath, cpuThreadNum, cpuPowerMode);
|
||||
if (!isLoaded) {
|
||||
return false;
|
||||
}
|
||||
isLoaded = loadLabel(appCtx, labelPath);
|
||||
return isLoaded;
|
||||
}
|
||||
|
||||
public boolean init(Context appCtx, String modelPath, String labelPath, int cpuThreadNum, String cpuPowerMode,
|
||||
int detLongSize, float scoreThreshold) {
|
||||
boolean isLoaded = init(appCtx, modelPath, labelPath, cpuThreadNum, cpuPowerMode);
|
||||
if (!isLoaded) {
|
||||
return false;
|
||||
}
|
||||
this.detLongSize = detLongSize;
|
||||
this.scoreThreshold = scoreThreshold;
|
||||
return true;
|
||||
}
|
||||
|
||||
protected boolean loadModel(Context appCtx, String modelPath, int cpuThreadNum, String cpuPowerMode) {
|
||||
// Release model if exists
|
||||
releaseModel();
|
||||
|
||||
// Load model
|
||||
if (modelPath.isEmpty()) {
|
||||
return false;
|
||||
}
|
||||
String realPath = modelPath;
|
||||
if (modelPath.charAt(0) != '/') {
|
||||
// Read model files from custom path if the first character of mode path is '/'
|
||||
// otherwise copy model to cache from assets
|
||||
realPath = appCtx.getCacheDir() + File.separator + modelPath;
|
||||
// region add by TonyJiangWJ
|
||||
String key = "PADDLE_MODEL_LOADED" + md5(modelPath);
|
||||
// 进行了模型更新 需要强制覆盖旧模型
|
||||
boolean loaded = PreferenceManager.getDefaultSharedPreferences(appCtx).getBoolean(key, false);
|
||||
if (loaded) {
|
||||
// 没有必要每次都复制
|
||||
Utils.copyDirectoryFromAssetsIfNeeded(appCtx, modelPath, realPath);
|
||||
} else {
|
||||
Utils.copyDirectoryFromAssets(appCtx, modelPath, realPath);
|
||||
PreferenceManager.getDefaultSharedPreferences(appCtx).edit().putBoolean(key, true).apply();
|
||||
}
|
||||
// endregion
|
||||
}
|
||||
|
||||
OCRPredictorNative.Config config = new OCRPredictorNative.Config();
|
||||
// 是否使用GPU
|
||||
config.useOpencl = useOpencl ? 1 : 0;
|
||||
config.cpuThreadNum = cpuThreadNum;
|
||||
config.detModelFilename = realPath + File.separator + detModelFilename;
|
||||
config.recModelFilename = realPath + File.separator + recModelFilename;
|
||||
config.clsModelFilename = realPath + File.separator + clsModelFilename;
|
||||
Log.i("Predictor", "model path" + config.detModelFilename + " ; " + config.recModelFilename + ";" + config.clsModelFilename);
|
||||
config.cpuPower = cpuPowerMode;
|
||||
paddlePredictor = new OCRPredictorNative(config);
|
||||
|
||||
this.cpuThreadNum = cpuThreadNum;
|
||||
this.cpuPowerMode = cpuPowerMode;
|
||||
this.modelPath = realPath;
|
||||
this.modelName = realPath.substring(realPath.lastIndexOf(File.separator) + 1);
|
||||
return true;
|
||||
}
|
||||
|
||||
public static String md5(String text) {
|
||||
MessageDigest md;
|
||||
byte[] bytesOfMessage = text.getBytes();
|
||||
try {
|
||||
md = MessageDigest.getInstance("MD5");
|
||||
} catch (NoSuchAlgorithmException e) {
|
||||
throw new RuntimeException(e);
|
||||
}
|
||||
byte[] thedigest = md.digest(bytesOfMessage);
|
||||
return Base64.encodeToString(thedigest, Base64.DEFAULT);
|
||||
}
|
||||
|
||||
public void releaseModel() {
|
||||
if (paddlePredictor != null) {
|
||||
paddlePredictor.destroy();
|
||||
paddlePredictor = null;
|
||||
}
|
||||
isLoaded = false;
|
||||
modelPath = "";
|
||||
modelName = "";
|
||||
}
|
||||
|
||||
protected boolean loadLabel(Context appCtx, String labelPath) {
|
||||
wordLabels.clear();
|
||||
wordLabels.add("black");
|
||||
// Load word labels from file
|
||||
try {
|
||||
InputStream labelInputStream;
|
||||
if (labelPath.startsWith(File.separator)) {
|
||||
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
|
||||
labelInputStream = Files.newInputStream(Paths.get(labelPath));
|
||||
} else {
|
||||
// noinspection IOStreamConstructor
|
||||
labelInputStream = new FileInputStream(labelPath);
|
||||
}
|
||||
} else {
|
||||
labelInputStream = appCtx.getAssets().open(labelPath);
|
||||
}
|
||||
int available = labelInputStream.available();
|
||||
byte[] lines = new byte[available];
|
||||
if (labelInputStream.read(lines) <= 0) {
|
||||
Log.e(TAG, "读取label失败");
|
||||
return false;
|
||||
}
|
||||
labelInputStream.close();
|
||||
String words = new String(lines);
|
||||
// Windows下换行为\r\n 进行兼容
|
||||
String[] contents = words.split("(\r)?\n");
|
||||
wordLabels.addAll(Arrays.asList(contents));
|
||||
wordLabels.add(" ");
|
||||
Log.i(TAG, "Word label size: " + wordLabels.size());
|
||||
} catch (Exception e) {
|
||||
Log.e(TAG, e.getMessage(), e);
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
public List<OcrResult> runOcr(Bitmap inputImage) {
|
||||
if (inputImage == null || !isLoaded()) {
|
||||
return Collections.emptyList();
|
||||
}
|
||||
// 检测、分类、识别
|
||||
int run_det = runDet ? 1 : 0, run_cls = runCls ? 1 : 0, run_rec = runRec ? 1 : 0;
|
||||
// Warm up
|
||||
for (int i = 0; i < warmupIterNum; i++) {
|
||||
paddlePredictor.runImage(inputImage, detLongSize, run_det, run_cls, run_rec);
|
||||
}
|
||||
warmupIterNum = 0; // do not need warm
|
||||
// Run inference
|
||||
Date start = new Date();
|
||||
ArrayList<OcrResultModel> results = paddlePredictor.runImage(inputImage, detLongSize, run_det, run_cls, run_rec);
|
||||
Date end = new Date();
|
||||
inferenceTime = (end.getTime() - start.getTime()) / (float) inferIterNum;
|
||||
|
||||
postProcess(results);
|
||||
Log.i(TAG, "[stat] Preprocess Time: " + preprocessTime
|
||||
+ " ; Inference Time: " + inferenceTime + " ;Box Size " + results.size());
|
||||
List<OcrResult> ocrResults = new ArrayList<>();
|
||||
for (OcrResultModel resultModel : results) {
|
||||
Log.d(TAG, "recognize: " + resultModel.toString());
|
||||
if (resultModel.getConfidence() >= scoreThreshold) {
|
||||
ocrResults.add(new OcrResult(resultModel));
|
||||
}
|
||||
}
|
||||
Collections.sort(ocrResults);
|
||||
return ocrResults;
|
||||
}
|
||||
|
||||
public boolean isLoaded() {
|
||||
return paddlePredictor != null && isLoaded;
|
||||
}
|
||||
|
||||
public String modelPath() {
|
||||
return modelPath;
|
||||
}
|
||||
|
||||
public String modelName() {
|
||||
return modelName;
|
||||
}
|
||||
|
||||
public int cpuThreadNum() {
|
||||
return cpuThreadNum;
|
||||
}
|
||||
|
||||
public String cpuPowerMode() {
|
||||
return cpuPowerMode;
|
||||
}
|
||||
|
||||
public float inferenceTime() {
|
||||
return inferenceTime;
|
||||
}
|
||||
|
||||
public Bitmap inputImage() {
|
||||
return inputImage;
|
||||
}
|
||||
|
||||
public float preprocessTime() {
|
||||
return preprocessTime;
|
||||
}
|
||||
|
||||
public String getDefaultLabelPath() {
|
||||
return defaultLabelPath;
|
||||
}
|
||||
|
||||
public String getDefaultModelPath() {
|
||||
return defaultModelPath;
|
||||
}
|
||||
|
||||
public String getDefaultModelPathSlim() {
|
||||
return defaultModelPathSlim;
|
||||
}
|
||||
|
||||
public boolean isUseSlim() {
|
||||
return useSlim;
|
||||
}
|
||||
|
||||
public void setInputImage(Bitmap image) {
|
||||
if (image == null) {
|
||||
return;
|
||||
}
|
||||
this.inputImage = image.copy(Bitmap.Config.ARGB_8888, true);
|
||||
}
|
||||
|
||||
private void postProcess(ArrayList<OcrResultModel> results) {
|
||||
for (OcrResultModel r : results) {
|
||||
StringBuilder word = new StringBuilder();
|
||||
for (int index : r.getWordIndex()) {
|
||||
if (index >= 0 && index < wordLabels.size()) {
|
||||
word.append(wordLabels.get(index));
|
||||
} else {
|
||||
Log.e(TAG, "Word index is not in label list:" + index);
|
||||
word.append(" ");
|
||||
}
|
||||
}
|
||||
r.setLabel(word.toString());
|
||||
r.setClsLabel(r.getClsIdx() == 1 ? "180" : "0");
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
@@ -1,198 +0,0 @@
|
||||
package com.baidu.paddle.lite.ocr;
|
||||
|
||||
import android.content.Context;
|
||||
import android.graphics.Bitmap;
|
||||
import android.graphics.Matrix;
|
||||
import android.media.ExifInterface;
|
||||
import android.os.Environment;
|
||||
import android.util.Log;
|
||||
|
||||
import java.io.BufferedInputStream;
|
||||
import java.io.BufferedOutputStream;
|
||||
import java.io.File;
|
||||
import java.io.FileNotFoundException;
|
||||
import java.io.FileOutputStream;
|
||||
import java.io.IOException;
|
||||
import java.io.InputStream;
|
||||
import java.io.OutputStream;
|
||||
|
||||
/**
|
||||
* @author PaddleOCR
|
||||
* Modified by TonyJiangWJ
|
||||
* @since 2023-08-06
|
||||
*/
|
||||
public class Utils {
|
||||
private static final String TAG = Utils.class.getSimpleName();
|
||||
|
||||
public static void copyFileFromAssets(Context appCtx, String srcPath, String dstPath) {
|
||||
if (srcPath.isEmpty() || dstPath.isEmpty()) {
|
||||
return;
|
||||
}
|
||||
InputStream is = null;
|
||||
OutputStream os = null;
|
||||
try {
|
||||
is = new BufferedInputStream(appCtx.getAssets().open(srcPath));
|
||||
os = new BufferedOutputStream(new FileOutputStream(new File(dstPath)));
|
||||
byte[] buffer = new byte[1024];
|
||||
int length = 0;
|
||||
while ((length = is.read(buffer)) != -1) {
|
||||
os.write(buffer, 0, length);
|
||||
}
|
||||
} catch (FileNotFoundException e) {
|
||||
e.printStackTrace();
|
||||
} catch (IOException e) {
|
||||
e.printStackTrace();
|
||||
} finally {
|
||||
try {
|
||||
os.close();
|
||||
is.close();
|
||||
} catch (IOException e) {
|
||||
e.printStackTrace();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public static void copyDirectoryFromAssets(Context appCtx, String srcDir, String dstDir) {
|
||||
if (srcDir.isEmpty() || dstDir.isEmpty()) {
|
||||
return;
|
||||
}
|
||||
try {
|
||||
if (!new File(dstDir).exists()) {
|
||||
new File(dstDir).mkdirs();
|
||||
}
|
||||
for (String fileName : appCtx.getAssets().list(srcDir)) {
|
||||
String srcSubPath = srcDir + File.separator + fileName;
|
||||
String dstSubPath = dstDir + File.separator + fileName;
|
||||
if (new File(srcSubPath).isDirectory()) {
|
||||
copyDirectoryFromAssets(appCtx, srcSubPath, dstSubPath);
|
||||
} else {
|
||||
Log.d(TAG, "复制资源文件: " + srcSubPath + " => " + dstSubPath);
|
||||
copyFileFromAssets(appCtx, srcSubPath, dstSubPath);
|
||||
}
|
||||
}
|
||||
} catch (Exception e) {
|
||||
e.printStackTrace();
|
||||
}
|
||||
}
|
||||
|
||||
public static void copyDirectoryFromAssetsIfNeeded(Context appCtx, String srcDir, String dstDir) {
|
||||
if (srcDir.isEmpty() || dstDir.isEmpty()) {
|
||||
return;
|
||||
}
|
||||
try {
|
||||
if (!new File(dstDir).exists()) {
|
||||
new File(dstDir).mkdirs();
|
||||
}
|
||||
for (String fileName : appCtx.getAssets().list(srcDir)) {
|
||||
String srcSubPath = srcDir + File.separator + fileName;
|
||||
String dstSubPath = dstDir + File.separator + fileName;
|
||||
if (new File(srcSubPath).isDirectory()) {
|
||||
copyDirectoryFromAssetsIfNeeded(appCtx, srcSubPath, dstSubPath);
|
||||
} else {
|
||||
if (new File(dstSubPath).exists()) {
|
||||
return;
|
||||
}
|
||||
Log.d(TAG, "复制资源文件: " + srcSubPath + " => " + dstSubPath);
|
||||
copyFileFromAssets(appCtx, srcSubPath, dstSubPath);
|
||||
}
|
||||
}
|
||||
} catch (Exception e) {
|
||||
e.printStackTrace();
|
||||
}
|
||||
}
|
||||
|
||||
public static float[] parseFloatsFromString(String string, String delimiter) {
|
||||
String[] pieces = string.trim().toLowerCase().split(delimiter);
|
||||
float[] floats = new float[pieces.length];
|
||||
for (int i = 0; i < pieces.length; i++) {
|
||||
floats[i] = Float.parseFloat(pieces[i].trim());
|
||||
}
|
||||
return floats;
|
||||
}
|
||||
|
||||
public static long[] parseLongsFromString(String string, String delimiter) {
|
||||
String[] pieces = string.trim().toLowerCase().split(delimiter);
|
||||
long[] longs = new long[pieces.length];
|
||||
for (int i = 0; i < pieces.length; i++) {
|
||||
longs[i] = Long.parseLong(pieces[i].trim());
|
||||
}
|
||||
return longs;
|
||||
}
|
||||
|
||||
public static String getSDCardDirectory() {
|
||||
return Environment.getExternalStorageDirectory().getAbsolutePath();
|
||||
}
|
||||
|
||||
public static boolean isSupportedNPU() {
|
||||
return false;
|
||||
// String hardware = android.os.Build.HARDWARE;
|
||||
// return hardware.equalsIgnoreCase("kirin810") || hardware.equalsIgnoreCase("kirin990");
|
||||
}
|
||||
|
||||
public static Bitmap resizeWithStep(Bitmap bitmap, int maxLength, int step) {
|
||||
int width = bitmap.getWidth();
|
||||
int height = bitmap.getHeight();
|
||||
int maxWH = Math.max(width, height);
|
||||
float ratio = 1;
|
||||
int newWidth = width;
|
||||
int newHeight = height;
|
||||
if (maxWH > maxLength) {
|
||||
ratio = maxLength * 1.0f / maxWH;
|
||||
newWidth = (int) Math.floor(ratio * width);
|
||||
newHeight = (int) Math.floor(ratio * height);
|
||||
}
|
||||
|
||||
newWidth = newWidth - newWidth % step;
|
||||
if (newWidth == 0) {
|
||||
newWidth = step;
|
||||
}
|
||||
newHeight = newHeight - newHeight % step;
|
||||
if (newHeight == 0) {
|
||||
newHeight = step;
|
||||
}
|
||||
return Bitmap.createScaledBitmap(bitmap, newWidth, newHeight, true);
|
||||
}
|
||||
|
||||
public static Bitmap rotateBitmap(Bitmap bitmap, int orientation) {
|
||||
|
||||
Matrix matrix = new Matrix();
|
||||
switch (orientation) {
|
||||
case ExifInterface.ORIENTATION_NORMAL:
|
||||
return bitmap;
|
||||
case ExifInterface.ORIENTATION_FLIP_HORIZONTAL:
|
||||
matrix.setScale(-1, 1);
|
||||
break;
|
||||
case ExifInterface.ORIENTATION_ROTATE_180:
|
||||
matrix.setRotate(180);
|
||||
break;
|
||||
case ExifInterface.ORIENTATION_FLIP_VERTICAL:
|
||||
matrix.setRotate(180);
|
||||
matrix.postScale(-1, 1);
|
||||
break;
|
||||
case ExifInterface.ORIENTATION_TRANSPOSE:
|
||||
matrix.setRotate(90);
|
||||
matrix.postScale(-1, 1);
|
||||
break;
|
||||
case ExifInterface.ORIENTATION_ROTATE_90:
|
||||
matrix.setRotate(90);
|
||||
break;
|
||||
case ExifInterface.ORIENTATION_TRANSVERSE:
|
||||
matrix.setRotate(-90);
|
||||
matrix.postScale(-1, 1);
|
||||
break;
|
||||
case ExifInterface.ORIENTATION_ROTATE_270:
|
||||
matrix.setRotate(-90);
|
||||
break;
|
||||
default:
|
||||
return bitmap;
|
||||
}
|
||||
try {
|
||||
Bitmap bmRotated = Bitmap.createBitmap(bitmap, 0, 0, bitmap.getWidth(), bitmap.getHeight(), matrix, true);
|
||||
bitmap.recycle();
|
||||
return bmRotated;
|
||||
} catch (OutOfMemoryError e) {
|
||||
e.printStackTrace();
|
||||
return null;
|
||||
}
|
||||
}
|
||||
}
|
||||
28
plugin-api/paddle-ocr/build.gradle.kts
Normal file
28
plugin-api/paddle-ocr/build.gradle.kts
Normal file
@@ -0,0 +1,28 @@
|
||||
plugins {
|
||||
id("org.autojs.build.versions")
|
||||
id("org.autojs.build.jvm-convention")
|
||||
id("com.android.library")
|
||||
id("org.jetbrains.kotlin.android")
|
||||
kotlin("plugin.parcelize")
|
||||
}
|
||||
|
||||
android {
|
||||
namespace = "org.autojs.plugin.paddle.ocr"
|
||||
|
||||
compileSdk = versions.sdkVersionCompile
|
||||
|
||||
defaultConfig {
|
||||
minSdk = versions.sdkVersionMin
|
||||
consumerProguardFiles("consumer-rules.pro")
|
||||
}
|
||||
|
||||
lint {
|
||||
targetSdk = versions.sdkVersionTarget
|
||||
abortOnError = false
|
||||
}
|
||||
|
||||
buildFeatures {
|
||||
aidl = true
|
||||
buildConfig = false
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,16 @@
|
||||
package org.autojs.plugin.paddle.ocr;
|
||||
|
||||
import org.autojs.plugin.paddle.ocr.PluginInfo;
|
||||
import org.autojs.plugin.paddle.ocr.OcrOptions;
|
||||
import org.autojs.plugin.paddle.ocr.OcrResult;
|
||||
import android.os.ParcelFileDescriptor;
|
||||
|
||||
interface IOcrPlugin {
|
||||
|
||||
PluginInfo getInfo();
|
||||
|
||||
List<String> recognizeText(in ParcelFileDescriptor imageFd, in OcrOptions options);
|
||||
|
||||
List<OcrResult> detect(in ParcelFileDescriptor imageFd, in OcrOptions options);
|
||||
|
||||
}
|
||||
@@ -0,0 +1,10 @@
|
||||
package org.autojs.plugin.paddle.ocr;
|
||||
|
||||
parcelable OcrOptions {
|
||||
int cpuThreadNum;
|
||||
boolean useSlim;
|
||||
boolean useOpenCL;
|
||||
int detLongSize;
|
||||
float scoreThreshold;
|
||||
android.os.Bundle extras;
|
||||
}
|
||||
@@ -0,0 +1,8 @@
|
||||
package org.autojs.plugin.paddle.ocr;
|
||||
|
||||
parcelable OcrResult {
|
||||
String text;
|
||||
float confidence;
|
||||
android.graphics.Rect bounds;
|
||||
android.os.Bundle extras;
|
||||
}
|
||||
@@ -0,0 +1,24 @@
|
||||
package org.autojs.plugin.paddle.ocr;
|
||||
|
||||
parcelable PluginInfo {
|
||||
|
||||
String name;
|
||||
@nullable String description;
|
||||
|
||||
String author;
|
||||
@nullable String[] collaborators;
|
||||
|
||||
String versionName;
|
||||
long versionCode;
|
||||
@nullable String versionDate;
|
||||
|
||||
/** @example "paddle-ocr-v5" */
|
||||
@nullable String id;
|
||||
/** @sample "paddle-ocr" */
|
||||
@nullable String engine;
|
||||
/** @sample "v5" */
|
||||
@nullable String variant;
|
||||
|
||||
@nullable android.os.Bundle capabilities;
|
||||
|
||||
}
|
||||
@@ -20,7 +20,6 @@ private val libs = listOf(
|
||||
"androidx-appcompat-1_0_2",
|
||||
"apk-parser-1_0_2",
|
||||
"org-opencv-4_8_0",
|
||||
"paddleocr",
|
||||
"rapidocr",
|
||||
"imagequant",
|
||||
|
||||
@@ -40,16 +39,25 @@ private val libs = listOf(
|
||||
"recyclerview-flexibledivider-1_4_0"
|
||||
)
|
||||
|
||||
private val pluginApi = listOf(
|
||||
"paddle-ocr",
|
||||
)
|
||||
|
||||
include(
|
||||
":app",
|
||||
*modules.map { ":modules:$it" }.toTypedArray(),
|
||||
*libs.map { ":libs:$it" }.toTypedArray(),
|
||||
*pluginApi.map { ":plugin-api:$it" }.toTypedArray(),
|
||||
)
|
||||
|
||||
modules.forEach {
|
||||
project(":modules:$it").projectDir = File("modules", it)
|
||||
}
|
||||
|
||||
pluginApi.forEach {
|
||||
project(":plugin-api:$it").projectDir = File("plugin-api", it)
|
||||
}
|
||||
|
||||
pluginManagement {
|
||||
|
||||
@Suppress("UNCHECKED_CAST")
|
||||
|
||||
@@ -1,5 +1,5 @@
|
||||
#Thu Nov 20 16:13:13 CST 2025
|
||||
BUILD_TIME=1763626393791
|
||||
#Fri Nov 28 14:10:00 CST 2025
|
||||
BUILD_TIME=1764310200816
|
||||
COMPILE_SDK_VERSION=36
|
||||
IMAGE_QUANT_CMAKE_VERSION=3.22.1
|
||||
IMAGE_QUANT_NDK_VERSION=26.1.10909125
|
||||
@@ -27,6 +27,6 @@ RAPID_OCR_OPENCV_MOBILE_LABEL_VERSION=13
|
||||
RAPID_OCR_OPENCV_MOBILE_VERSION=4.5.3
|
||||
TARGET_SDK_VERSION=36
|
||||
TARGET_SDK_VERSION_INRT=29
|
||||
VERSION_BUILD=3502
|
||||
VERSION_NAME=6.7.0 Alpha11
|
||||
VERSION_BUILD=3516
|
||||
VERSION_NAME=6.7.0 Alpha12
|
||||
VSCODE_EXT_REQUIRED_VERSION=1.0.8
|
||||
|
||||
Reference in New Issue
Block a user