Note / 说明： API 参考文档使用英文撰写，以保持与代码中函数签名、参数名和类型定义的一致性。技术文档保持英文是行业惯例。
ACL Pack API Reference
Version: 1.0.3
Platform: Android arm64-v8a · Linux aarch64
Language: C++17
Delivery: Static library (libacl.a) + Headers
Table of Contents
- Operator Catalog
- Getting Started
- Error Codes
- Type Definitions
- Analysis
- Arithmetic
- Color Conversion
- Filter
- Geometric
- Feature Detection
- Transform
- Math
- Drawing
- Contour Analysis
- Utilities
- 命名空间可用性一览
Operator Catalog
ACL Pack 全部出货算子的一页全景图,按类别分组。Tier 后缀表明哪种 license 解锁该调用:
- 无后缀 — Starter tier
[Pro]— 需 Pro 或 Business license[Business]— 需 Business license
每个算子的签名与支持类型见下方对应类别章节。
| 类别 | 算子 |
|---|---|
| Filter | GaussianBlur、BoxFilter、Filter2D、SepFilter2D、Sobel、Scharr、Laplacian、Canny、MedianFilter、BilateralFilter [Pro]、NLMeansDenoising [Pro]、GuidedFilter [Pro]、UnsharpMask [Pro]、StackBlur、GaborFilter [Pro]、Erode / Dilate、EdgePreservingFilter [Business]、MergeMertens [Business]、Tonemap [Business] |
| Color | RGB2Gray、BGR↔RGB / BGRA / RGBA(10 个交错变体)、RGB↔HSV [Pro]、RGB↔Lab [Pro]、RGB↔YUV(NV21 / YV12 / YUV444、BT601 / 709 / 2020)、Bayer 解马赛克、GammaTransform |
| Geometric | Resize(NEAREST / LINEAR2D / AREA_AVG / CUBIC4x4)、Rotate(0 / 180 / CW90 / CCW90 / FLIP_V / FLIP_H / XPOSE)、PyrDown / PyrUp / buildPyramid、NEON resizeYUV / rotateYUV |
| Arithmetic | AddImg、AbsDiff、AddWeighted、AlphaImgFusion、Multiply、Threshold、AdaptiveThreshold [Pro]、Bitwise AND / NOT / XOR、LUT、ConvertScaleAbs、InRange、Normalize、Phase [Pro]、Magnitude [Pro]、LinearTransform2x2 [Business] |
| Analysis | Integral、Histogram、BlockAverage、EqualizeHist、CopyMakeBorder、CLAHE [Pro]、HistMatch [Pro]、MinMaxLoc、Mean、Count、MatchTemplate [Pro]、Moments [Pro]、FindContours [Pro]、ExtractBlockPixels [Business]、DistanceTransform [Business]、ConnectedComponentLabeling / connectedComponent_8n_dfs [Business] |
| Feature | FAST、Harris、Shi-Tomasi(及 Detect 变体)、ORB(detect + detectAndCompute)、HOG、HoughLines / HoughLinesP / HoughCircles、OpticalFlowLK、bfMatch / bfMatchBinary / bfKnnMatch / bfKnnMatchBinary — 均 [Pro];SIFT、SURF [Business] |
| Transform | WarpAffine、WarpPerspective、Remap(仅 CPP)、GetAffineTransform、GetPerspectiveTransform、GetRotationMatrix2D、FindHomography [Pro]、yuvRemap [Business] |
| Math (NEON) | DFT(dft1d / dft2d / dftReal1d / idftReal1d)、mulSpectrums、getOptimalDFTSize — 均 [Pro] |
| Draw (CPP) | drawLine、drawRect、drawCircle、putText(仅 u8) |
| Contour (CPP) | contourArea、arcLength、boundingRect、convexHull、approxPolyDP、minAreaRect、fitEllipse — 均 [Pro] |
Commercial Tier And Type Policy
当前客户可见的商业 tier 名称是 Starter、Pro 和 Business。Core、Advanced、Full 等旧名称不再出现在商业头文件或 package metadata 中。
| Tier | 算子可用范围 | 商业头文件允许的图像像素类型 |
|---|---|---|
| Starter | Starter 算子 | uint8_t |
| Pro | Starter + Pro 算子 | uint8_t, uint16_t |
| Business | Starter + Pro + Business 算子 | uint8_t, uint16_t, float |
每个算子自己的 类型 表描述的是实现层面的模板支持。商业 package 中实际可调用的类型集合，是该表与上方 tier 类型策略的交集。不支持的组合会在交付的 <acl/api.h> 中以编译期错误拒绝，通常表现为显式 = delete 的模板特化。例如 Starter 删除 blockAverage<uint16_t> 和 blockAverage<float>，Pro 删除 blockAverage<float>，Business 才暴露三种像素类型。
Trial package 与通用 acl::* / acl::neon::* API 表面分离，只暴露 acl::trial 下 2 个固定参数 wrapper：resizeBilinear2xDown_cpp 和 resizeBilinear2xDown_neon。Trial 用户不应调用付费 tier 文档中的通用命名空间入口。
cpp
namespace acl::trial {
int resizeBilinear2xDown_cpp(const uint8_t* srcImage, uint8_t* dstImage);
int resizeBilinear2xDown_neon(const uint8_t* srcImage, uint8_t* dstImage);
}这些 Trial wrapper 使用固定 Trial 输入尺寸 1920x1280；2x 下采样 wrapper 输出 960x640。
Getting Started
Initialization
cpp
#include <acl/acl.h>
// 使用 License 文件初始化
int result = acl::init("/path/to/license.dat");
// 检查结果
if (result == 0) {
// 成功 — 所有算子可用
} else {
// 失败 — 参见下方错误码
}
// 获取库版本
const char* ver = acl::version(); // "1.0.3"License 初始化
cpp
namespace acl {
int init(const char* licensePath, JNIEnv* env = nullptr, jobject context = nullptr);
const char* version(); // 返回 "1.0.3"
}| 参数 | 类型 | 说明 |
|---|---|---|
licensePath | const char* | 设备上 license.dat 的绝对路径 |
env | JNIEnv* | JNI 环境,可选。ABI 保留参数,留作未来扩展;当前实现不读取它。纯 Native 调用传 nullptr 即可 |
context | jobject | Android Context,与 env 同义,行为同上 |
init() 读取 license 文件并校验其完整性与 tier。在购买约定的范围内,你收到的版本可继续使用。每个进程启动时调用一次,在调用任何算子前完成;同一进程内后续再调用会直接返回相同状态码,不会重新读文件。
返回值:
0— 成功-1001— License 无效(文件缺失、签名损坏、被篡改,或init()未调用)-1005— Tier 不匹配(init 阶段)或当前 tier 不含该算子(调用点)-1006— 不符合 Trial 固定尺寸(1920×1280)
Architecture
ACL Pack 提供两套并行实现:
acl::{module}::*— 可移植 C++ scalar 实现。许多算子模板化支持标准图片像素类型(uint8_t/uint16_t/float;具体组合见每个算子说明)。所有 scalar 算子直接位于acl::{module}::下(无cpp::段)。所有声明集中在单一头文件<acl/api.h>中。acl::neon::{module}::*— ARM NEON 手工向量化实现。大多数算子优先针对uint8_t;uint16_t与float支持按算子而定,部分路径会回退到 scalar 实现。相比 scalar 层典型 2-25× 提速,峰值 50×+。
所有声明都集中在一个头文件里 — <acl/api.h>。 客户工程只需 #include <acl/api.h> 即可访问所有算子。
两套 API 签名几乎一致。Android arm64-v8a 上推荐使用 neon:: 版本;若某个入口只在 scalar 下提供(文档中会明确标注),请使用对应的 acl::{module}:: 入口。
short / int16_t、int、int64_t、double 等类型用于梯度输出、标签、积分图累加器、几何矩阵、矩和参数等特定辅助角色,不是通用图片像素输入类型。<acl/typeDef.h> 定义共享 public 结构体和枚举,并不表示每个枚举值或数据类型都被每个算子实现。
Conventions
- 图像数据用原始指针传递(
const T*输入,T*输出) stride单位为字节(不是像素)。传0时自动按width × channels × sizeof(T)计算(要求连续内存)cn指通道数(1 = 灰度,3 = RGB,4 = RGBA)- 返回
0(ACL_OK)成功;负数为错误码 - 内存由调用方分配和释放,库内零隐式分配
- 大多数算子不支持 inplace(
src == dst),需单独分配输出缓冲;个别支持 inplace 的在该算子处单独说明 - 算子调用要求
acl::init()已返回0;否则直接返回-1001,不执行任何计算
Error Codes
cpp
#include <acl/err.h>| Code | Macro | Description |
|---|---|---|
0 | ACL_OK | Operation completed successfully |
-1 | ACL_ERR_GENERIC | Unknown error |
-2 | ACL_ERR_INVAL | Invalid parameter (null ptr, zero size, etc.) |
-3 | ACL_ERR_NOMEM | Memory allocation failed |
-4 | ACL_ERR_NOSUP | Unsupported operation or type combination |
-5 | ACL_ERR_IO | File/port open failed |
-1001 | ACL_ERR_LICENSE_INVALID | License 文件缺失、损坏、被篡改,或 acl::init() 尚未成功 |
-1005 | ACL_ERR_NOT_LICENSED | Tier 不匹配：license.tier 与编译 tier 不符(由 acl::init 检测),或当前算子不在本 tier(调用点检测) |
-1006 | ACL_ERR_RESOLUTION_LIMIT | 不符合 Trial 固定尺寸(1920×1280) |
-1002 / -1003 / -1004 在 ABI 中保留但不会被返回。详见 License Guide。
Type Definitions
cpp
#include <acl/typeDef.h>Enums
RotateOrient
cpp
enum class RotateOrient {
ROT_0, // 不旋转(复制)
ROT_180, // 180 度旋转
ROT_CW_90, // 顺时针 90 度
ROT_CCW_90, // 逆时针 90 度
FLIP_V, // 垂直镜像(上下翻转)
FLIP_H, // 水平镜像(左右翻转)
XPOSE // 矩阵转置
};InterpMode
cpp
enum class InterpMode {
NEAREST, // 最近邻
LINEAR2D, // 双线性插值
AREA_AVG, // 面积平均(用于下采样)
CUBIC4x4 // 双三次(4x4 邻域)
};BorderType
边界处理模式 — 取 kernel 时如果超出图像范围,如何填充越界像素。示例序列 abcdefgh(输入):
cpp
enum class BorderType {
BORDER_CONSTANT, // 'iiiiii|abcdefgh|iiiiii' — 用 constant 参数填充
BORDER_REPLICATE, // 'aaaaaa|abcdefgh|hhhhhh' — 复制边缘像素
BORDER_REFLECT, // 'fedcba|abcdefgh|hgfedc' — 含边界像素的镜像
BORDER_WRAP, // 'cdefgh|abcdefgh|abcdef' — 循环回卷
BORDER_REFLECT_101, // 'gfedcb|abcdefgh|gfedcb' — 不含边界像素的镜像
BORDER_DEFAULT = BORDER_REFLECT_101
};BayerPattern
cpp
enum class BayerPattern { RGGB, GRBG, GBRG, BGGR };ColorCvtGrayMode
cpp
enum class ColorCvtGrayMode {
GRAY_LUMA, // BT.601 luma (0.299R + 0.587G + 0.114B)
GRAY_MAX, // R/G/B 逐像素取 max
GRAY_MIN, // R/G/B 逐像素取 min
GRAY_AVG, // 简单平均 (R + G + B) / 3
GRAY_WEIGHTED // 用户提供的权重 (cR * R + cG * G + cB * B)
};ThreshMode
cpp
enum class ThreshMode {
THRESH_BINARY, // dst = (src > thresh) ? maxVal : 0
THRESH_BINARY_INV, // dst = (src > thresh) ? 0 : maxVal
THRESH_TRUNC, // dst = (src > thresh) ? thresh : src
THRESH_TOZERO, // dst = (src > thresh) ? src : 0
THRESH_TOZERO_INV, // dst = (src > thresh) ? 0 : src
THRESH_OTSU // Automatic threshold (Otsu's method)
};YUVEncodeStandard
cpp
enum class YUVEncodeStandard {
STD_BT601, // ITU-R BT.601 (SDTV)
STD_BT709, // ITU-R BT.709 (HDTV)
STD_BT2020, // ITU-R BT.2020 (UHDTV)
STD_CUSTOM // 调用方提供的 3x3 转换矩阵
};NormType
cpp
enum class NormType { NORM_INF, NORM_L1, NORM_L2, NORM_MINMAX };AdaptiveThreshMethod
cpp
enum class AdaptiveThreshMethod {
ADAPTIVE_THRESH_MEAN_C, // Block 内均值
ADAPTIVE_THRESH_GAUSSIAN_C // Block 内高斯加权均值
};MorphOp
cpp
enum class MorphOp {
ERODE, // 腐蚀(取 kernel 覆盖区最小值)
DILATE // 膨胀(取 kernel 覆盖区最大值)
};ValueRange
用于指定输出值域(如 normalize 算子使用):
cpp
enum class ValueRange {
STD_NEG1_TO_POS1, // 结果落在 [-1, 1]
UNIT_INTERVAL, // 结果落在 [0, 1]
NATIVE_FULL_SCALE // 结果落在输出类型的全正值范围(如 u8 → [0, 255])
};TemplateMatchMethod
cpp
enum class TemplateMatchMethod {
TM_SQDIFF, TM_SQDIFF_NORMED,
TM_CCORR, TM_CCORR_NORMED,
TM_CCOEFF, TM_CCOEFF_NORMED
};DftFlags
cpp
enum DftFlags { DFT_FORWARD = 0, DFT_INVERSE = 1, DFT_SCALE = 2 };数据结构(几何 / Hough / 特征 / 颜色 / 轮廓)
下列结构体作为参数包传入算子,或作为返回值/结果容器使用。按用途分类:
- 几何基本类型 —
Point2f、Point2i、Size2f、RotatedRect(用于minAreaRect/fitEllipse/findContours) - Hough 结果 —
Vec2f、Vec3f、Vec4i(houghLines/houghCircles/houghLinesP的输出格式) - 特征与匹配 —
KeyPoint、KeyPointORB、KeyPointExt、DMatch、HOGParams(Harris / FAST / ORB / SIFT / SURF / HOG /bfMatch/bfKnnMatch) - 颜色转换 —
YUVConvertParams(单一参数包,驱动所有rgb2YUV/yuv2RGB算子) - 轮廓与矩 —
HierarchyEntry、Moments(findContours/moments的输出)
顶层 acl:: 命名空间(<acl/typeDef.h>),YUV ↔ RGB 转换参数包,驱动所有 rgb2YUV / yuv2RGB 算子:
cpp
namespace acl {
struct YUVConvertParams {
YUVEncodeStandard yuv_std = YUVEncodeStandard::STD_BT601;
bool yuv444_fmt = true; // true = 4:4:4 packed, false = 4:4:4 planar (仅 4:4:4 算子使用)
bool nv21_fmt = true; // true = NV21 (V 在前), false = NV12 (U 在前) (仅 NV 系列算子使用)
bool rgb_fmt = true; // true = RGB, false = BGR
int bit_depth = 0; // 0 = 自动从像素类型推断 (u8 = 8, u16 = 16)
int shift_right = 0; // 输出位移(16-bit pipeline 用)
int shift_left = 0; // 输入位移(16-bit pipeline 用)
bool yuv_full_range = true; // true = 全范围 (0–255), false = 限范围 (16–235)
bool rgb_full_range = true; // true = 全范围, false = 限范围
};
}默认值对应常见的 BT.601 8-bit 全范围 RGB pipeline。传 {} 用全部默认值,或仅覆盖你 pipeline 需要不同的字段。具体例子见 Color Conversion 段。
所有公开 struct 和 enum 都在单一顶层 acl:: 命名空间下(没有子命名空间):
cpp
namespace acl {
// ── Geometry ────────────────────────────────────────────
struct Point2i { int x, y; };
// ── Contour / Moments ───────────────────────────────────
struct HierarchyEntry { int next, prev, first_child, parent; }; // 默认 -1
struct Moments { double m00, m10, m01, m20, m11, m02, m30, m21, m12, m03; };
enum DistanceType { DIST_L1 = 1, DIST_L2 = 2, DIST_LINF = 3 };
enum ContourRetrMode {
CONTOUR_RETR_EXTERNAL = 0,
CONTOUR_RETR_LIST = 1,
CONTOUR_RETR_CCOMP = 2,
CONTOUR_RETR_TREE = 3
};
enum ContourApproxMethod {
CONTOUR_CHAIN_APPROX_NONE = 1,
CONTOUR_CHAIN_APPROX_SIMPLE = 2
};
// ── Features ────────────────────────────────────────────
struct KeyPoint { int x, y; float response; };
struct KeyPointORB { float x, y, response, scale, angle; uint8_t descriptor[32]; };
struct KeyPointExt { float x, y, response, scale, angle; float descriptor[128]; };
struct HOGParams {
int cellSize, blockSize, nbins, blockStride;
// 默认: cellSize=8, blockSize=2, nbins=9, blockStride=1
};
// ── Filter mode tags ────────────────────────────────────
enum EdgePreservingType {
EDGE_PRESERVING_RECURSIVE = 1, // 快速版
EDGE_PRESERVING_NORMCONV = 2 // 高质量版
};
}Analysis
Namespace: acl::analysis (CPP) / acl::neon::analysis (NEON)
integral
积分图(Summed Area Table):I(x, y) = ∑ src(i, j), 0 ≤ i ≤ x, 0 ≤ j ≤ y。用于 O(1) 矩形区域求和(boxFilter、Haar 特征等)。
Tier: Starter+
通道: 1ch
Inplace: not supported
类型:
| 模板参数 | 允许类型 | 约束 |
|---|---|---|
SrcType | uint8_t、uint16_t、float | — |
IntegralType | int32_t、int64_t、double | sizeof(IntegralType) ≥ sizeof(SrcType) |
CPP 版
cpp
template<class SrcType, class IntegralType>
int integral(
const SrcType* srcImage, IntegralType* integral,
int width, int height,
int srcStride = 0);| 参数 | 类型 | 含义 | 默认 |
|---|---|---|---|
srcImage | const SrcType* | 输入图(单通道) | 非空 |
integral | IntegralType* | 输出积分图,尺寸 (width+1) × (height+1) | 非空 |
width, height | int | 输入图尺寸 | > 0 |
srcStride | int | 每行字节数 | 0 = 自动 |
integral第 0 行和第 0 列恒为 0(实现哨兵行列,方便边界查询)。
NEON 版
cpp
template<class SrcType, class IntegralType>
int integral(
const SrcType* srcImage, IntegralType* integralImage,
int width, int height,
int srcStride = 0);示例
cpp
uint8_t srcImage[1920*1080];
int32_t integ[(1920+1)*(1080+1)];
acl::neon::analysis::integral<uint8_t, int32_t>(
srcImage, integ, 1920, 1080);
// O(1) 矩形 (x0,y0)-(x1,y1) 求和
auto rectSum = [&](int x0, int y0, int x1, int y1) {
int W = 1921;
return integ[(y1+1)*W + (x1+1)]
- integ[(y1+1)*W + x0]
- integ[y0*W + (x1+1)]
+ integ[y0*W + x0];
};histogram
统计像素值直方图。
Tier: Starter+
通道: 1ch(必要时通过运行时 hcn × vcn 参数打包)
Inplace: 不适用
类型:
| 模板参数 | 允许类型 | 约束 |
|---|---|---|
ST | {uint8_t, uint16_t} | — |
HT | {int, long, …}(直方图 bin 计数类型) | — |
CPP 版
cpp
template<class ST, class HT>
int histogram(
const ST* srcImage, HT* hist,
int width, int height,
int srcStride, int histLen,
int hcn = 1, int vcn = 1);| 参数 | 类型 | 含义 | 默认 |
|---|---|---|---|
srcImage | const ST* | 输入图 | 非空 |
hist | HT* | 输出直方图(长度 histLen,调用方清零) | 非空 |
srcStride | int | 每行字节数 | 0 = 自动 |
histLen | int | 直方图 bin 数(u8 → 256,u16 → 65536) | — |
hcn, vcn | int | 水平/垂直通道打包 | 1, 1 |
NEON 版(仅 uint8_t,固定 histLen = 256)
cpp
int histogram(
const uint8_t* srcImage, int* hist,
int width, int height,
int srcStride = 0);
hist固定长度 256 个intbin;非uint8_t或非 256 bin 请用 CPP 版。
histMatch
直方图匹配(规范化)— 调整 src 的像素分布使其匹配 ref 的直方图。
Tier: Pro+
通道: 1ch
Inplace: not supported
类型:
| 模板参数 | 允许类型 | 约束 |
|---|---|---|
ST | uint8_t, uint16_t | 三参数必须同类型 |
DT | uint8_t, uint16_t | 三参数必须同类型 |
RT | uint8_t, uint16_t | 三参数必须同类型 |
CPP 签名
cpp
template<class ST, class DT, class RT>
int histMatch(
const ST* srcImage, DT* dstImage, const RT* refImage,
int width, int height,
int srcStride, int dstStride, int refStride,
int srcHistLen, int refHistLen,
double MATCH_TH = 0.0,
int hcn = 1, int vcn = 1);| 参数 | 类型 | 含义 | 默认 |
|---|---|---|---|
srcImage, dstImage | const ST* / DT* | 输入 / 输出 | 非空 |
refImage | const RT* | 参考图(用其直方图作为目标分布) | 非空 |
srcHistLen, refHistLen | int | 源 / 参考 bin 数 | u8:256 |
MATCH_TH | double | 匹配容忍度阈值 [0, 1] | 0.0 |
hcn, vcn | int | 水平/垂直通道打包 | 1, 1 |
equalizeHist
直方图均衡化。
Tier: Starter+
通道: 1ch
Inplace: 支持
类型:
| 模板参数 | 允许类型 | 约束 |
|---|---|---|
T (CPP) | uint8_t, uint16_t | — |
T (NEON) | uint8_t | 仅 NEON |
CPP 版
cpp
template<class T>
int equalizeHist(
const T* srcImage, T* dstImage,
int width, int height,
int srcStride = 0, int dstStride = 0);NEON 版(仅 uint8_t)
cpp
int equalizeHist(
const uint8_t* srcImage, uint8_t* dstImage,
int width, int height,
int srcStride = 0, int dstStride = 0);clahe
Contrast Limited Adaptive Histogram Equalization — 把图像分成 tilesX × tilesY 格,每格做直方图均衡化并对对比度上限做截断,最后双线性插值 blend,避免全局 equalization 导致的过度对比。
Tier: Pro+
通道: 1ch
Inplace: 不支持
类型:
| 模板参数 | 允许类型 | 约束 |
|---|---|---|
T | uint8_t | — |
CPP / NEON 签名(一致)
cpp
int clahe(
const uint8_t* srcImage, uint8_t* dstImage,
int width, int height,
int srcStride = 0, int dstStride = 0,
double clipLimit = 40.0,
int tilesX = 8, int tilesY = 8);| 参数 | 类型 | 含义 | 默认 |
|---|---|---|---|
srcImage, dstImage | const uint8_t* / uint8_t* | 输入 / 输出 | 非空 |
width, height | int | 图像尺寸 | 需满足 width ≥ tilesX, height ≥ tilesY |
srcStride, dstStride | int | 每行字节数 | 0 = 自动 |
clipLimit | double | 对比度上限(越大对比越强) | 40.0(OpenCV 默认) |
tilesX, tilesY | int | 水平 / 垂直格子数 | 8 × 8 |
minMaxLoc
找图像中最小 / 最大值及其位置。
Tier: Starter+
通道: 1ch
Inplace: not supported
类型:
| 模板参数 | 允许类型 | 约束 |
|---|---|---|
T | uint8_t, uint16_t, float | — |
CPP / NEON 签名(一致)
cpp
template<class T>
int minMaxLoc(
const T* srcImage, int width, int height, int srcStride,
T* minVal, T* maxVal,
int* minLocX, int* minLocY,
int* maxLocX, int* maxLocY);| 参数 | 类型 | 含义 | 默认 |
|---|---|---|---|
srcImage | const T* | 输入图 | 非空 |
srcStride | int | 每行字节数 | 0 = 自动 |
minVal, maxVal | T* | 输出最小 / 最大值(可为 nullptr) | — |
minLocX, minLocY, maxLocX, maxLocY | int* | 输出对应坐标(可为 nullptr) | — |
任何输出指针为
nullptr时对应结果跳过。
moments
空间矩(0~3 阶)。单通道图像,输出 Moments 结构体含 10 个 double 原始矩:m00, m10, m01, m20, m11, m02, m30, m21, m12, m03。
Tier: Pro+
通道: 1ch
Inplace: not supported
类型:
| 模板参数 | 允许类型 | 约束 |
|---|---|---|
T (CPP) | uint8_t, uint16_t, float | — |
CPP 签名
cpp
struct Moments {
double m00, m10, m01, m20, m11, m02, m30, m21, m12, m03;
};
template<class T>
int moments(
const T* srcImage, int width, int height, int srcStride,
Moments& m,
bool binaryImage = false);| 参数 | 类型 | 含义 | 默认 |
|---|---|---|---|
srcImage | const T* | 输入图 | 非空 |
m | Moments& | 输出矩结构 | 由函数填充 |
binaryImage | bool | true = 所有非零像素按 1 处理(按二值计算) | false |
copyMakeBorder
在图像外围添加边界,支持多种边界模式。典型用途:卷积前填充。
Tier: Starter+
通道: 1ch / 3ch / 4ch
Inplace: not supported
类型:
| 模板参数 | 允许类型 | 约束 |
|---|---|---|
T | uint8_t, uint16_t, float | — |
BorderType: BORDER_REPLICATE / BORDER_REFLECT / BORDER_REFLECT_101 / BORDER_WRAP / BORDER_CONSTANT 等 |
CPP 版
cpp
template<class T>
int copyMakeBorder(
const T* srcImage, T* dstImage,
int srcWidth, int srcHeight, int channelNum,
int srcStride, int dstStride,
int top, int bottom, int left, int right,
const T* constant = nullptr,
acl::BorderType bt = acl::BorderType::BORDER_REFLECT_101);| 参数 | 类型 | 含义 | 默认 |
|---|---|---|---|
srcImage | const T* | 输入图 | 非空 |
dstImage | T* | 输出图(尺寸 (srcWidth + left + right) × (srcHeight + top + bottom)) | 非空 |
channelNum | int | 通道数 | — |
top, bottom, left, right | int | 四个方向的 padding 宽度 | ≥ 0 |
constant | const T* | BORDER_CONSTANT 填充值数组(长度 channelNum) | nullptr |
bt | acl::BorderType | 边界处理模式 | BORDER_REFLECT_101 |
NEON 版
cpp
template<class T>
int copyMakeBorder(
const T* srcImage, T* dstImage,
int srcWidth, int srcHeight, int channelNum,
int srcStride = 0, int dstStride = 0,
int top = 0, int bottom = 0, int left = 0, int right = 0,
const T* constant = nullptr,
acl::BorderType bt = acl::BorderType::BORDER_REFLECT_101);count
统计满足条件的像素个数。
Tier: Starter+
通道: 1ch
Inplace: not supported
类型:
| 模板参数 | 允许类型 | 约束 |
|---|---|---|
T | uint8_t, uint16_t, float | — |
CPP 签名(3 个入口)
cpp
// == threshold
template<class T>
int countEQ(const T* srcImage, int width, int height, int stride, const T& threshold);
// <= threshold
template<class T>
int countLET(const T* srcImage, int width, int height, int stride, const T& threshold);
// < threshold
template<class T>
int countLT(const T* srcImage, int width, int height, int stride, const T& threshold);返回值是计数(非 error code);
srcImage == nullptr返回 0。
mean
两图或 N 图的逐像素平均 dst[i] = (A[i] + B[i] + …) / N。
Tier: Starter+
通道: 1ch / 3ch / 4ch
Inplace: not supported
类型:
| 模板参数 | 允许类型 | 约束 |
|---|---|---|
AT | uint8_t, uint16_t, float | — |
BT | uint8_t, uint16_t, float | — |
DT | uint8_t, uint16_t, float | — |
CPP 签名(2 图 + N 图两个重载)
cpp
// 两图
template<class AT, class BT, class DT>
int mean(
const AT* src1Image, const BT* src2Image, DT* dstImage,
int width, int height, int cn = 1,
int src1Stride = 0, int src2Stride = 0, int dstStride = 0);
// N 图
template<class ST, class DT>
int mean(
const ST* const* srcImages, int srcNum, DT* dstImage,
int width, int height, int cn = 1,
int srcStride = 0, int dstStride = 0);matchTemplate
模板匹配(6 种相似度度量)。FFT 加速,适合大图 × 小模板。
Tier: Pro+
通道: 1ch
Inplace: not supported
类型:
| 模板参数 | 允许类型 | 约束 |
|---|---|---|
T (CPP) | {uint8_t, float} | — |
T (NEON) | uint8_t | 仅 NEON |
TemplateMatchMethod:
TM_SQDIFF— 平方差之和TM_SQDIFF_NORMED— 归一化平方差TM_CCORR— 互相关TM_CCORR_NORMED— 归一化互相关TM_CCOEFF— 相关系数TM_CCOEFF_NORMED— 归一化相关系数
CPP 版
cpp
template<class T>
int matchTemplate(
const T* srcImage, int srcW, int srcH, int srcStride,
const T* templ, int templW, int templH, int templStride,
float* result, int resultStride,
acl::TemplateMatchMethod tm = acl::TemplateMatchMethod::TM_SQDIFF);NEON 版(仅 uint8_t)
cpp
template<class T>
int matchTemplate(
const T* srcImage, int srcW, int srcH, int srcStride,
const T* templ, int templW, int templH, int templStride,
float* result, int resultStride,
acl::TemplateMatchMethod tm = acl::TemplateMatchMethod::TM_SQDIFF);| 参数 | 类型 | 含义 | 默认 |
|---|---|---|---|
srcImage, templ | const T* | 搜索图、模板图 | 非空,templW ≤ srcW, templH ≤ srcH |
result | float* | 输出得分图,尺寸 (srcW - templW + 1) × (srcH - templH + 1) | 非空 |
*Stride | int | 每行字节数(result 按 float 计) | 0 = 自动 |
tm | acl::TemplateMatchMethod | 相似度度量 | TM_SQDIFF |
connectedComponent_8n_dfs
8-连通域标注(DFS)。输入二值图,输出每个连通域的像素坐标列表。
Tier: Business
通道: 1ch
Inplace: not supported
类型:
| 模板参数 | 允许类型 | 约束 |
|---|---|---|
T | uint8_t, uint16_t | — |
LabelType | int | — |
CPP 签名
cpp
template<class T>
int connectedComponent_8n_dfs(
T* binaryImage, int width, int height, int stride,
std::vector<std::vector<std::pair<int, int>>>& regions,
int minArea, int maxArea,
int frontFlag = 255, int backFlag = 0);| 参数 | 类型 | 含义 |
|---|---|---|
binaryImage | T* | 输入二值图(算法可能改写像素用作标记) |
regions | vector<vector<pair<int, int>>>& | 输出每个连通域的像素 (x, y) 坐标列表 |
minArea, maxArea | int | 过滤:只保留 area ∈ [minArea, maxArea] 的域 |
frontFlag, backFlag | int | 前景/背景像素值,DFS 标记用(默认 255 / 0) |
connectedComponentLabeling
带 label 图的连通域标注(union-find)。输出 label 图(每像素标签)+ 按面积排序的 label 列表。
Tier: Business
通道: 1ch
Inplace: not supported
类型:
| 模板参数 | 允许类型 | 约束 |
|---|---|---|
DataInType | uint8_t, uint16_t | — |
LabelType | int | — |
CPP 签名
cpp
template<class DataInType, class LabelType>
int connectedComponentLabeling(
DataInType* dataIn, LabelType* label,
std::vector<std::pair<LabelType, int>>& sortLabelHist,
DataInType threshold,
int topAreaCnt, int minArea,
int width, int height,
int inStride = 0, int labelStride = 0);| 参数 | 类型 | 含义 |
|---|---|---|
dataIn | DataInType* | 输入图(用 threshold 二值化) |
label | LabelType* | 输出 label 图 |
sortLabelHist | vector<pair<LabelType, int>>& | 输出按面积降序的 (label, area) 列表 |
threshold | DataInType | 输入二值化阈值 |
topAreaCnt | int | 只保留面积最大的 topAreaCnt 个域 |
findContours
在二值图中找轮廓(Suzuki-Abe 算法,OpenCV 兼容)。
Tier: Pro+
通道: 1ch
Inplace: not supported
类型:
| 模板参数 | 允许类型 | 约束 |
|---|---|---|
T | uint8_t | — |
CPP 签名
cpp
enum ContourRetrMode {
CONTOUR_RETR_EXTERNAL = 0, // 只保留最外层
CONTOUR_RETR_LIST = 1, // 所有轮廓,无层级
CONTOUR_RETR_CCOMP = 2, // 两层(外 + 内孔)
CONTOUR_RETR_TREE = 3 // 完整层级树
};
enum ContourApproxMethod {
CONTOUR_CHAIN_APPROX_NONE = 1, // 保留所有轮廓点
CONTOUR_CHAIN_APPROX_SIMPLE = 2 // 压缩水平 / 垂直 / 对角线段的中间点
};
struct Point2i { int x, y; };
struct HierarchyEntry { int next, prev, first_child, parent; };
int findContours(
const uint8_t* srcImage, int width, int height, int srcStride,
std::vector<std::vector<Point2i>>& contours,
std::vector<HierarchyEntry>* hierarchy = nullptr,
ContourRetrMode mode = CONTOUR_RETR_LIST,
ContourApproxMethod method = CONTOUR_CHAIN_APPROX_SIMPLE,
int offsetX = 0, int offsetY = 0);| 参数 | 类型 | 含义 |
|---|---|---|
contours | vector<vector<Point2i>>& | 输出轮廓,每条轮廓是 Point2i 数组 |
hierarchy | vector<HierarchyEntry>* | (可选)层级信息 [next, prev, first_child, parent] |
offsetX, offsetY | int | 所有轮廓点坐标加上此偏移 |
distanceTransform
距离变换 — 每个像素输出到最近的 0 像素的距离(L1 / L2 / L∞)。
Tier: Business
通道: 1ch
Inplace: not supported
类型:
| 模板参数 | 允许类型 | 约束 |
|---|---|---|
| 输入 | uint8_t | — |
| 输出 | float | — |
DistanceType: DIST_L1(Manhattan)/ DIST_L2(Euclidean,精确算法)/ DIST_LINF(chessboard)
CPP 签名(2 个入口,float 或 u8 输出)
cpp
// float 输出(精度高)
int distanceTransform(
const uint8_t* srcImage, float* dstImage,
int width, int height,
int srcStride = 0, int dstStride = 0,
DistanceType distType = DIST_L2);
// u8 输出(0-255 归一化,适合可视化)
int distanceTransformU8(
const uint8_t* srcImage, uint8_t* dstImage,
int width, int height,
int srcStride = 0, int dstStride = 0,
DistanceType distType = DIST_L2);
DIST_L2使用 Felzenszwalb-Huttenlocher 精确 Euclidean 算法(不是近似)。
blockAverage
把每个 U × V 块内像素取平均作为输出(图像下采样)。U = V = 2 对应 2×2 平均。
Tier: Starter+
通道: 1ch / 3ch
Inplace: 不支持
类型:
| 模板参数 | 允许类型 | 约束 |
|---|---|---|
T | uint8_t, uint16_t, float | — |
商业 package 类型可用性:
| Tier | 交付 <acl/api.h> 中可调用的 T |
|---|---|
| Starter | uint8_t |
| Pro | uint8_t, uint16_t |
| Business | uint8_t, uint16_t, float |
CPP / NEON 签名(一致)
cpp
template<class T>
int blockAverage(
const T* srcImage, T* dstImage,
int srcWidth, int srcHeight,
int U, int V,
int srcStride = 0, int dstStride = 0,
bool round = true,
int hcn = 1, int vcn = 1);| 参数 | 类型 | 含义 | 默认 |
|---|---|---|---|
U, V | int | 块的水平 / 垂直大小 | — |
round | bool | true = 四舍五入,false = 截断 | true |
hcn, vcn | int | 水平/垂直通道打包 | 1, 1 |
extractBlockPixels
从每个 U × V 块提取位于 (u, v) 的那个像素(即下采样但指定采样点)。
Tier: Business
通道: 1ch
Inplace: not supported
类型:
| 模板参数 | 允许类型 | 约束 |
|---|---|---|
ST | uint8_t, uint16_t, float | — |
DT | uint8_t, uint16_t, float | — |
CPP 签名
cpp
template<class ST, class DT>
int extractBlockPixels(
const ST* srcImage, DT* dstImage,
int srcWidth, int srcHeight,
int srcStride, int dstStride,
int U, int V, int u, int v);| 参数 | 类型 | 含义 |
|---|---|---|
U, V | int | 块大小 |
u, v | int | 每块中采样的像素位置(0 ≤ u < U, 0 ≤ v < V),自动 clamp |
Arithmetic
Namespace: acl::arithmetic (CPP) / acl::neon::arithmetic (NEON)
addImg
两图逐像素相加 dst = src1 + src2,输入操作数类型与输出类型解耦(AT / BT → DT)。
Tier: Starter+
通道: 1ch / 3ch / 4ch
Inplace: 支持(dst == src1 或 dst == src2)
类型:
| 模板参数 | 允许类型 | 约束 |
|---|---|---|
AT, BT, DT (CPP) | {uint8_t, uint16_t, float} | — |
T (NEON) | {uint8_t, uint16_t} | 仅 NEON |
变体入口(CPP):
| 入口 | 作用 |
|---|---|
addImg | 两图相加,无饱和 |
addImgClamp | 两图相加,结果 clamp 到 [minValue, maxValue] |
add_Imgs | N 图累加(srcImages[0] + srcImages[1] + …) |
add_ImgsClamp | N 图累加 + clamp |
add_ImgsManual | N 图累加,手动指定中间累加类型 ACC_T |
add_ImgsManualClamp | N 图累加 + 手动 ACC_T + clamp |
CPP 版
cpp
template<class AT, class BT, class DT>
int addImg(
const AT* src1Image, const BT* src2Image, DT* dstImage,
int width, int height, int cn = 1,
int src1Stride = 0, int src2Stride = 0, int dstStride = 0);
template<class AT, class BT, class DT>
int addImgClamp(
const AT* src1Image, const BT* src2Image, DT* dstImage,
int width, int height, int cn,
int src1Stride, int src2Stride, int dstStride,
DT minValue, DT maxValue);
template<class ST, class DT>
int add_Imgs(
const ST* const* srcImages, int srcNum, DT* dstImage,
int width, int height, int cn = 1,
int srcStride = 0, int dstStride = 0);| 参数 | 类型 | 含义 | 默认 |
|---|---|---|---|
src1Image, src2Image | const AT*, const BT* | 输入 | 非空 |
dstImage | DT* | 输出 | 非空 |
width, height | int | 图像尺寸 | > 0 |
cn | int | 通道数 | 1 |
*Stride | int | 每行字节数 | 0 = 自动 |
minValue, maxValue | DT | (仅 clamp 版)输出上下界 | — |
NEON 版
cpp
template<class T>
int addImg(
const T* src1, const T* src2, T* dstImage,
int width, int height, int cn = 1,
int src1Stride = 0, int src2Stride = 0, int dstStride = 0);NEON 只提供
addImg本体;N 图累加、clamp、跨类型(AT/BT/DT)、手动ACC_T等变体走 CPP 版。
示例
cpp
uint8_t a[1920*1080], b[1920*1080], dstImage[1920*1080];
// 两图相加(u8)
acl::neon::arithmetic::addImg(a, b, dstImage, 1920, 1080);
// 饱和 clamp 到 [0, 200](CPP)
acl::arithmetic::addImgClamp<uint8_t, uint8_t, uint8_t>(
a, b, dstImage, 1920, 1080, 1, 0, 0, 0,
/*minValue=*/0, /*maxValue=*/200);
// 10 张图累加成 u16,避免 u8 溢出
const uint8_t* imgs[10] = { /* ... */ };
uint16_t acc[1920*1080];
acl::arithmetic::add_Imgs<uint8_t, uint16_t>(
imgs, 10, acc, 1920, 1080);absDiff
两图逐像素绝对差 dst = |src1 - src2|。
Tier: Starter+
通道: any
Inplace: 支持
类型:
| 模板参数 | 允许类型 | 约束 |
|---|---|---|
ST1 | uint8_t, uint16_t, float | — |
ST2 | uint8_t, uint16_t, float | — |
DT | uint8_t, uint16_t, float | — |
cpp
template<class T>
int absDiff(
const T* src1, const T* src2, T* dstImage,
int width, int height, int cn,
int src1Stride = 0, int src2Stride = 0, int dstStride = 0);同时提供
acl::arithmetic::absDiff(CPP)和acl::neon::arithmetic::absDiff(NEON),签名一致、命名空间不同。NEON 路径支持uint8_t/float/double(u16 走标量)。
示例
cpp
uint8_t a[1920*1080], b[1920*1080], diff[1920*1080];
// 帧差法(运动检测)
acl::neon::arithmetic::absDiff<uint8_t>(a, b, diff, 1920, 1080, 1);addWeighted
加权和 dst = alpha*src1 + beta*src2 + gamma。典型用途:图像过渡、曝光融合。
Tier: Starter+
通道: 1ch / 3ch / 4ch
Inplace: 支持
类型:
| 模板参数 | 允许类型 | 约束 |
|---|---|---|
T | uint8_t, uint16_t, float | — |
CPP 版
cpp
template<class ST1, class ST2, class DT>
int addWeighted(
const ST1* src1, const ST2* src2, DT* dstImage,
int width, int height, int cn,
int src1Stride, int src2Stride, int dstStride,
double alpha, double beta, double gamma);NEON 版(T ∈ {uint8_t, uint16_t, float},输入/输出同类型)
cpp
template<class T>
int addWeighted(
const T* src1, const T* src2, T* dstImage,
int width, int height,
int cn = 1,
int src1Stride = 0, int src2Stride = 0, int dstStride = 0,
double alpha = 1.0, double beta = 1.0, double gamma = 0.0);示例
cpp
uint8_t a[1920*1080*3], b[1920*1080*3], dstImage[1920*1080*3];
// 50% 混合: dstImage = 0.5 * a + 0.5 * b
acl::neon::arithmetic::addWeighted(
a, b, dstImage, 1920, 1080, 3, 0, 0, 0, 0.5, 0.5, 0.0);alphaImgFusion
Alpha 融合 C = alpha * A + (1 - alpha) * B。
Tier: Starter+
通道: 1ch(入参 width*cn 按字节计)
Inplace: 支持
类型:
| 模板参数 | 允许类型 | 约束 |
|---|---|---|
ST1 | uint8_t, uint16_t, float | — |
ST2 | uint8_t, uint16_t, float | — |
DT | uint8_t, uint16_t, float | — |
CPP / NEON 签名(一致)
cpp
template<class T>
int alphaImgFusion(
const T* A, const T* B, T* C,
int width, int height,
int AStride, int BStride, int CStride,
float alpha);| 参数 | 类型 | 含义 | 默认 |
|---|---|---|---|
A, B | const T* | 输入两张图 | 非空 |
C | T* | 输出融合图 | 非空 |
AStride, BStride, CStride | int | 每行字节数 | 0 = 自动 |
alpha | float | A 的权重,[0, 1] | — |
mul
逐像素乘法 C = A * B。saturateCast = true 时结果按 CT 类型饱和(例如 uint8_t clamp 到 [0, 255])。
Tier: Starter+
通道: 1ch / 3ch / 4ch
Inplace: 支持
类型:
| 模板参数 | 允许类型 | 约束 |
|---|---|---|
AT, BT, CT (CPP) | {uint8_t, uint16_t, float} | — |
T (NEON) | {uint8_t, uint16_t} | 仅 NEON |
CPP 版
cpp
template<class AT, class BT, class CT>
int mul(
const AT* A, const BT* B, CT* C,
int width, int height, int cn,
int AStride, int BStride, int CStride,
bool saturateCast = false);NEON 版(uint8_t / uint16_t / float,同类型输入输出)
cpp
template<class T>
int mul(
const T* A, const T* B, T* C,
int width, int height, int cn,
int AStride, int BStride, int CStride,
bool saturateCast = false);NEON 要求
AT == BT == CT(即T);异类型请用 CPP 版。
threshold
固定阈值二值化 / 截断。
Tier: Starter+
通道: 1ch
Inplace: 支持
类型:
| 模板参数 | 允许类型 | 约束 |
|---|---|---|
T | uint8_t, uint16_t, float | — |
ThreshMode: THRESH_BINARY / THRESH_BINARY_INV / THRESH_TRUNC / THRESH_TOZERO / THRESH_TOZERO_INV / THRESH_OTSU(仅 u8) |
CPP 版
cpp
template<class ST, class DT>
int threshold(
const ST* srcImage, DT* dstImage,
int width, int height,
ST threshold,
DT maxVal = 255, DT minVal = 0,
int srcStride = 0, int dstStride = 0,
acl::ThreshMode tm = acl::ThreshMode::THRESH_BINARY);
THRESH_OTSU模式会自动计算最优阈值(忽略传入的threshold参数),仅uint8_t/uint16_t支持。
NEON 版(仅 uint8_t 输入输出)
cpp
template<class T>
int threshold(
const T* srcImage, T* dstImage,
int width, int height,
T threshold,
T maxVal = 255, T minVal = 0,
int srcStride = 0, int dstStride = 0,
acl::ThreshMode tm = acl::ThreshMode::THRESH_BINARY);示例
cpp
uint8_t gray[1920*1080], bin[1920*1080];
// 固定阈值二值化
acl::neon::arithmetic::threshold<uint8_t>(
gray, bin, 1920, 1080, /*threshold=*/128,
/*maxVal=*/255, /*minVal=*/0, 0, 0,
acl::ThreshMode::THRESH_BINARY);
// Otsu 自动阈值(仅 CPP)
acl::arithmetic::threshold<uint8_t, uint8_t>(
gray, bin, 1920, 1080, /*threshold=*/0,
/*maxVal=*/255, /*minVal=*/0, 0, 0,
acl::ThreshMode::THRESH_OTSU); // threshold 参数被忽略adaptiveThreshold
自适应阈值 — 每个像素的阈值 = local_mean(src, blockSize) - C(或 Gaussian 加权平均)。
Tier: Pro+
通道: 1ch
Inplace: 不支持
类型:
| 模板参数 | 允许类型 | 约束 |
|---|---|---|
T | uint8_t, uint16_t, float | — |
方法: ADAPTIVE_THRESH_MEAN_C / ADAPTIVE_THRESH_GAUSSIAN_C |
CPP 版
cpp
template<class T>
int adaptiveThreshold(
const T* srcImage, T* dstImage,
int width, int height,
int srcStride, int dstStride,
T maxVal,
int blockSize,
double C,
acl::AdaptiveThreshMethod am = acl::AdaptiveThreshMethod::ADAPTIVE_THRESH_MEAN_C);| 参数 | 类型 | 含义 | 默认 |
|---|---|---|---|
srcImage, dstImage | const T* / T* | 输入 / 输出 | 非空 |
width, height | int | 图像尺寸 | > 0 |
srcStride, dstStride | int | 每行字节数 | 0 = 自动 |
maxVal | T | 超过阈值的像素输出值 | 典型 255 |
blockSize | int | 局部窗口大小(必须奇数且 ≥ 3) | 典型 11 / 25 |
C | double | 阈值调整常数 | 典型 2 ~ 10 |
am | acl::AdaptiveThreshMethod | ADAPTIVE_THRESH_MEAN_C / ADAPTIVE_THRESH_GAUSSIAN_C | MEAN_C |
NEON 版(仅 uint8_t)
cpp
template<class T>
int adaptiveThreshold(
const T* srcImage, T* dstImage,
int width, int height,
int srcStride, int dstStride,
T maxVal,
int blockSize,
double C,
acl::AdaptiveThreshMethod am = acl::AdaptiveThreshMethod::ADAPTIVE_THRESH_MEAN_C);bitwise
位运算 AND / NOT / XOR。
Tier: Starter+
通道: 1ch / 3ch / 4ch
Inplace: 支持
类型:
| 模板参数 | 允许类型 | 约束 |
|---|---|---|
T (CPP) | {uint8_t, uint16_t} | — |
T (NEON) | uint8_t | 仅 NEON |
无
bitwiseOr入口(OR 可通过 NOT + AND + NOT 组合,当前版本未单独提供)。
CPP / NEON 签名(一致)
cpp
// AND
template<class T>
int bitwiseAnd(
const T* src1, const T* src2, T* dstImage,
int width, int height, int cn,
int src1Stride = 0, int src2Stride = 0, int dstStride = 0);
// NOT
template<class T>
int bitwiseNot(
const T* srcImage, T* dstImage,
int width, int height, int cn,
int srcStride = 0, int dstStride = 0);
// XOR
template<class T>
int bitwiseXor(
const T* src1, const T* src2, T* dstImage,
int width, int height, int cn,
int src1Stride = 0, int src2Stride = 0, int dstStride = 0);lut
查表变换 dst[i] = table[src[i]]。常用于 gamma 校正、颜色映射、曲线调整。
Tier: Starter+
通道: 1ch / 3ch / 4ch
Inplace: 支持
类型:
| 模板参数 | 允许类型 | 约束 |
|---|---|---|
ST ∈ {uint8_t}、DT ∈ {uint8_t, uint16_t, float} (CPP) | 已测试组合 | — |
T (NEON) | uint8_t | 仅 NEON |
CPP 版:1ch,ST → DT
cpp
template<class ST, class DT>
int lut(
const ST* srcImage, DT* dstImage,
const DT* table,
int width, int height,
int srcStride = 0, int dstStride = 0);
table长度必须覆盖ST所有可能值(uint8_t→ 256 项,uint16_t→ 65536 项)。
NEON 版:1ch / 3ch / 4ch,仅 uint8_t
cpp
int lut(
const uint8_t* srcImage, uint8_t* dstImage,
const uint8_t* table,
int width, int height,
int cn = 1,
int srcStride = 0, int dstStride = 0);NEON 版额外支持多通道(对同一张 256 项表应用到所有通道)。
示例
cpp
uint8_t src[1920*1080*3], dst[1920*1080*3];
// Gamma 2.2 LUT
uint8_t gamma_lut[256];
for (int i = 0; i < 256; ++i)
gamma_lut[i] = (uint8_t)(std::pow(i / 255.0, 1.0 / 2.2) * 255.0);
// 3 通道 gamma 校正(NEON)
acl::neon::arithmetic::lut(src, dst, gamma_lut, 1920, 1080, 3);convertScaleAbs
标量乘法 + 加偏移 + 取绝对值 + 转 u8:dst = saturate_cast<u8>(|alpha*src + beta|)。
Tier: Starter+
通道: 1ch / 3ch / 4ch
Inplace: 支持(需 ST == uint8_t)
类型:
| 模板参数 | 允许类型 | 约束 |
|---|---|---|
ST | uint8_t, int16_t, uint16_t, float | 输出固定为 uint8_t |
CPP / NEON 签名(一致)
cpp
template<class ST>
int convertScaleAbs(
const ST* srcImage, uint8_t* dstImage,
int width, int height, int cn,
int srcStride, int dstStride,
double alpha, double beta);典型搭配:把 Sobel / Scharr 输出的
int16_t梯度可视化时,调用convertScaleAbs<int16_t>。
inRange
范围判定:每个通道同时满足 low[c] ≤ src[c] ≤ high[c] 则输出 255,否则 0。常用于 HSV 颜色分割。
Tier: Starter+
通道: 输入 1ch / 3ch / 4ch(逐通道判定),输出 1ch 二值掩膜
Inplace: 不支持
类型:
| 模板参数 | 允许类型 | 约束 |
|---|---|---|
T | uint8_t, uint16_t, float | — |
CPP / NEON 签名(一致)
cpp
template<class T>
int inRange(
const T* srcImage, uint8_t* dstImage,
int width, int height, int cn,
int srcStride, int dstStride,
const T* low, const T* high);| 参数 | 类型 | 含义 |
|---|---|---|
srcImage | const T* | 输入图(多通道,交织) |
dstImage | uint8_t* | 输出 1ch 二值掩膜 |
low, high | const T* | 长度 cn 的上下界数组 |
示例
cpp
uint8_t hsv[1920*1080*3], mask[1920*1080];
// 提取红色:H∈[0,10] S∈[100,255] V∈[100,255]
uint8_t low[3] = {0, 100, 100};
uint8_t high[3] = {10, 255, 255};
acl::neon::arithmetic::inRange(hsv, mask, 1920, 1080, 3, 0, 0, low, high);normalize
归一化 — 把像素值线性映射到目标范围。
Tier: Starter+
通道: 1ch
Inplace: 支持
类型:
| 模板参数 | 允许类型 | 约束 |
|---|---|---|
T | uint8_t, uint16_t, float | — |
NormType: NORM_MINMAX(映射到 [alpha, beta]) |
CPP / NEON 签名(一致)
cpp
template<class T>
int normalize(
const T* srcImage, T* dstImage,
int width, int height,
int srcStride, int dstStride,
acl::NormType nt = acl::NormType::NORM_MINMAX,
double alpha = 0.0, double beta = 255.0);| 参数 | 类型 | 含义 | 默认 |
|---|---|---|---|
srcImage, dstImage | const T* / T* | 输入 / 输出 | 非空 |
width, height | int | 图像尺寸 | > 0 |
srcStride, dstStride | int | 每行字节数 | 必填(0 = 自动) |
nt | acl::NormType | 归一化模式 | NORM_MINMAX |
alpha | double | 目标下界 | 0.0 |
beta | double | 目标上界(仅 NORM_MINMAX) | 255.0 |
linearTransform2x2
2×2 像素块线性变换:用户给一个 2×2 系数矩阵 [[v00, v01], [v10, v11]],作用到每个 2×2 像素块上,常用于 Bayer 色彩校正等。
Tier: Business
通道: 1ch(输入在 2×2 block 结构里理解)
Inplace: 不支持
类型:
| 模板参数 | 允许类型 | 约束 |
|---|---|---|
T | uint8_t, uint16_t, float | — |
DT | uint8_t, uint16_t, float | — |
CPP 签名
cpp
template<class T, class DT>
int linearTransform2x2(
const T* srcImage, T* dstImage,
int width, int height,
int srcStride, int dstStride,
int minValue, int maxValue,
const DT& v00, const DT& v01, const DT& v10, const DT& v11);| 参数 | 类型 | 含义 |
|---|---|---|
minValue, maxValue | int | 输出 clamp 上下界 |
v00, v01, v10, v11 | DT | 2×2 矩阵系数 |
phaseMagnitude
从 Sobel / Scharr 梯度 (dx, dy) 计算相位角和模长。
Tier: Pro+
通道: 1ch
Inplace: 不支持
类型:
| 模板参数 | 允许类型 | 约束 |
|---|---|---|
GT (CPP) | {int16_t, int32_t}(模板亦接受 float) | — |
T (NEON) | int16_t | 仅 NEON |
CPP 版:两个独立入口
cpp
// 相位角(弧度或度)
template<class GT>
int phase(
const GT* dx, const GT* dy, float* angle,
int width, int height,
int dxStride, int dyStride, int angleStride,
bool angleInDegrees = true);
// 模长(L2 范数)
template<class GT>
int magnitude(
const GT* dx, const GT* dy, float* mag,
int width, int height,
int dxStride, int dyStride, int magStride);
GT∈{short, int, float}。输出固定float。
NEON 版(仅 short 输入,非模板)
cpp
int magnitude(
const short* dx, const short* dy, float* mag,
int width, int height,
int dxStride, int dyStride, int magStride);
int phase(
const short* dx, const short* dy, float* angle,
int width, int height,
int dxStride, int dyStride, int angleStride,
bool angleInDegrees = true);典型搭配:
sobel3x3<short>输出short梯度,直接喂给 NEONmagnitude / phase。
示例
cpp
short dx[1920*1080], dy[1920*1080];
float mag[1920*1080], angle[1920*1080];
// Sobel → 梯度模长 + 相位
acl::neon::filter::sobel3x3<uint8_t, short>(src, dx, dy, 1920, 1080);
acl::neon::arithmetic::magnitude(dx, dy, mag, 1920, 1080, 0, 0, 0);
acl::neon::arithmetic::phase(dx, dy, angle, 1920, 1080, 0, 0, 0, /*degrees=*/true);Color Conversion
Namespace: acl::cvtcolor (CPP) / acl::neon::cvtcolor (NEON)
RGB2Gray / RGBA2Gray
RGB(A) → 灰度图。支持 5 种灰度策略(BT.601 luma、max、min、average、weighted)。
Tier: Starter+
通道: 输入 3ch(RGB)或 4ch(RGBA),输出 1ch
Inplace: 不支持
类型:
| 模板参数 | 允许类型 | 约束 |
|---|---|---|
T | uint8_t, uint16_t, float | — |
CPP 版:acl::cvtcolor::RGB2Gray / RGBA2Gray
cpp
template<class T>
int RGB2Gray(
const T* rgbImage, T* grayImage,
int width, int height,
int rgbStride = 0, int grayStride = 0,
acl::ColorCvtGrayMode mode = acl::ColorCvtGrayMode::GRAY_LUMA,
float cR = 0.299f, float cG = 0.587f, float cB = 0.114f);
template<class T>
int RGBA2Gray(
const T* rgbaImage, T* grayImage,
int width, int height,
int rgbaStride = 0, int grayStride = 0,
acl::ColorCvtGrayMode mode = acl::ColorCvtGrayMode::GRAY_LUMA,
float cR = 0.299f, float cG = 0.587f, float cB = 0.114f);| 参数 | 类型 | 含义 | 默认 |
|---|---|---|---|
rgbImage / rgbaImage | const T* | 输入 RGB / RGBA 图 | 非空 |
grayImage | T* | 输出灰度图 | 非空 |
width, height | int | 图像尺寸 | > 0 |
rgbStride/rgbaStride, grayStride | int | 每行字节数 | 0 = 自动 |
mode | acl::ColorCvtGrayMode | 灰度策略 | GRAY_LUMA |
cR, cG, cB | float | 仅 GRAY_WEIGHTED 模式使用 | BT.601 默认 |
mode 取值(见 acl::ColorCvtGrayMode):
GRAY_LUMA(默认)— BT.601 luma:0.299R + 0.587G + 0.114BGRAY_WEIGHTED— 使用cR/cG/cB自定义权重GRAY_MIN/GRAY_MAX/GRAY_AVG— 通道间取 min / max / 平均
NEON 版:acl::neon::cvtcolor::RGB2Gray / RGBA2Gray(仅 uint8_t)
cpp
int RGB2Gray( // 或 RGBA2Gray
const uint8_t* rgbImage, uint8_t* grayImage,
int width, int height,
int rgbStride = 0, int grayStride = 0,
acl::ColorCvtGrayMode mode = acl::ColorCvtGrayMode::GRAY_LUMA,
float cR = 0.299f, float cG = 0.587f, float cB = 0.114f);元素类型固定
uint8_t,其他参数语义与 CPP 版一致。
示例
cpp
uint8_t rgb[1920*1080*3], gray[1920*1080];
// BT.601 luma 灰度(默认)
acl::neon::cvtcolor::RGB2Gray(rgb, gray, 1920, 1080);
// 通道 max 模式(u16)
acl::cvtcolor::RGB2Gray<uint16_t>(
src16, gray16, 1920, 1080,
/*rgbStride=*/0, /*grayStride=*/0,
acl::ColorCvtGrayMode::GRAY_MAX);Channel Swap(BGR / RGB / RGBA 互换)
通道顺序互换(3ch ↔ 3ch、3ch ↔ 4ch、4ch ↔ 3ch)。统一一个模板入口 channelSwap<Mode>() 覆盖全部方向,只需替换 Mode tag。
Tier: Starter+
通道: 3ch ↔ 3ch / 3ch ↔ 4ch / 4ch ↔ 3ch
Inplace: 不支持(通道数不同时)
类型:
| 模板参数 | 允许类型 | 约束 |
|---|---|---|
T | uint8_t | — |
CPP / NEON 版(签名一致,仅 uint8_t)
所有通道交换方向都通过统一的 channelSwap<Mode>() 模板分派 — Mode 模板参数为空 tag 结构体,用来选择转换方向。共 5 个 tag,覆盖全部 10 个有效方向(每个 tag 同时处理一对等价的交换)。
cpp
template<class Mode>
int channelSwap(
const uint8_t* srcImage, uint8_t* dstImage,
int width, int height, int srcStride = 0, int dstStride = 0);
// Mode tag(声明在 typeDef.h,namespace acl::):
// 3ch ↔ 3ch: BGR2RGB (RGB → BGR 同一字节布局,等价)
// 3ch → 4ch: BGR2BGRA (RGB → RGBA 等价)
// BGR2RGBA (RGB → BGRA 等价 — 交换 R/B + 加 alpha)
// 4ch → 3ch: BGRA2BGR (RGBA → RGB 等价)
// BGRA2RGB (RGBA → BGR 等价 — 交换 R/B + 丢 alpha)CPP 在
acl::cvtcolor::,NEON 在acl::neon::cvtcolor::,签名完全一致。
| 参数 | 类型 | 含义 | 默认 |
|---|---|---|---|
srcImage, dstImage | const uint8_t* / uint8_t* | 输入 / 输出 | 非空 |
width, height | int | 图像尺寸 | > 0 |
srcStride, dstStride | int | 每行字节数 | 0 = 自动 |
示例
cpp
uint8_t bgr[1920*1080*3], rgba[1920*1080*4];
// BGR → RGBA(NEON) — 选择对应方向的 Mode tag
acl::neon::cvtcolor::channelSwap<acl::BGR2RGBA>(bgr, rgba, 1920, 1080);RGB ↔ YUV(fixed-point)
RGB/RGBA 与 YUV(NV21 / YV12 / YUV444)互转,整数定点算法。所有标准/通道顺序/位深/range 组合通过统一的 YUVConvertParams 结构体配置。
Tier: Starter+
通道: 3ch RGB ↔ NV21 / NV12 / YV12 / YUV444
Inplace: 不支持
类型:
| 模板参数 | 允许类型 | 约束 |
|---|---|---|
RGB_T | uint8_t, uint16_t | — |
YUV_T | uint8_t, uint16_t | — |
NV21 与 NV12 共用同一入口,通过
YUVConvertParams::nv21_fmt切换(true = NV21,false = NV12)。
CPP 版:acl::cvtcolor::rgb*2*_fixed(RGB → YUV,6 个入口)
NV21 / NV12(Y 平面 + UV 交织平面)
cpp
template<class RGB_T, class YUV_T>
int rgb2NV21_fixed(
const RGB_T* rgbImage, YUV_T* dstYImage, YUV_T* dstUVImage,
int width, int height,
int rgbStride = 0, int yStride = 0, int uvStride = 0,
const float* cvMatrix = nullptr,
const acl::YUVConvertParams& p = {});
template<class RGB_T, class YUV_T>
int rgba2NV21_fixed(
const RGB_T* rgbaImage, YUV_T* dstYImage, YUV_T* dstUVImage,
int width, int height,
int rgbaStride = 0, int yStride = 0, int uvStride = 0,
const float* cvMatrix = nullptr,
const acl::YUVConvertParams& p = {});YV12(Y / U / V 三个独立平面,U/V 各为 width/2 × height/2)
cpp
template<class RGB_T, class YUV_T>
int rgb2YV12_fixed(
const RGB_T* rgbImage,
YUV_T* dstYImage, YUV_T* dstUImage, YUV_T* dstVImage,
int width, int height,
int rgbStride = 0, int yStride = 0, int uStride = 0, int vStride = 0,
const float* cvMatrix = nullptr,
const acl::YUVConvertParams& p = {});
template<class RGB_T, class YUV_T>
int rgba2YV12_fixed(
const RGB_T* rgbaImage,
YUV_T* dstYImage, YUV_T* dstUImage, YUV_T* dstVImage,
int width, int height,
int rgbaStride = 0, int yStride = 0, int uStride = 0, int vStride = 0,
const float* cvMatrix = nullptr,
const acl::YUVConvertParams& p = {});YUV444(单平面交织)
cpp
template<class RGB_T, class YUV_T>
int rgb2YUV444_fixed(
const RGB_T* rgbImage, YUV_T* dstYUVImage,
int width, int height,
int rgbStride = 0, int yuvStride = 0,
const float* cvMatrix = nullptr,
const acl::YUVConvertParams& p = {});
template<class RGB_T, class YUV_T>
int rgba2YUV444_fixed(
const RGB_T* rgbaImage, YUV_T* dstYUVImage,
int width, int height,
int rgbaStride = 0, int yuvStride = 0,
const float* cvMatrix = nullptr,
const acl::YUVConvertParams& p = {});CPP 版:acl::cvtcolor::*2RGB_fixed(YUV → RGB,6 个入口)
NV21 / NV12 → RGB / RGBA
cpp
template<class YUV_T, class RGB_T>
int nv212RGB_fixed(
const YUV_T* srcYImage, const YUV_T* srcUVImage, RGB_T* rgbImage,
int width, int height,
int yStride = 0, int uvStride = 0, int rgbStride = 0,
const float* cvMatrix = nullptr,
const acl::YUVConvertParams& p = {});
template<class YUV_T, class RGB_T>
int nv212RGBA_fixed(
const YUV_T* srcYImage, const YUV_T* srcUVImage, RGB_T* rgbaImage,
int width, int height,
int yStride = 0, int uvStride = 0, int rgbaStride = 0,
const float* cvMatrix = nullptr,
const acl::YUVConvertParams& p = {});YV12 → RGB / RGBA(三输入平面)
cpp
template<class YUV_T, class RGB_T>
int yv122RGB_fixed(
const YUV_T* srcYImage, const YUV_T* srcUImage, const YUV_T* srcVImage,
RGB_T* rgbImage,
int width, int height,
int yStride = 0, int uStride = 0, int vStride = 0, int rgbStride = 0,
const float* cvMatrix = nullptr,
const acl::YUVConvertParams& p = {});
template<class YUV_T, class RGB_T>
int yv122RGBA_fixed(
const YUV_T* srcYImage, const YUV_T* srcUImage, const YUV_T* srcVImage,
RGB_T* rgbaImage,
int width, int height,
int yStride = 0, int uStride = 0, int vStride = 0, int rgbaStride = 0,
const float* cvMatrix = nullptr,
const acl::YUVConvertParams& p = {});YUV444 → RGB / RGBA(单输入平面)
cpp
template<class YUV_T, class RGB_T>
int yuv4442RGB_fixed(
const YUV_T* srcYUVImage, RGB_T* rgbImage,
int width, int height,
int yuvStride = 0, int rgbStride = 0,
const float* cvMatrix = nullptr,
const acl::YUVConvertParams& p = {});
template<class YUV_T, class RGB_T>
int yuv4442RGBA_fixed(
const YUV_T* srcYUVImage, RGB_T* rgbaImage,
int width, int height,
int yuvStride = 0, int rgbaStride = 0,
const float* cvMatrix = nullptr,
const acl::YUVConvertParams& p = {});| 参数 | 含义 |
|---|---|
rgbImage / rgbaImage | RGB / RGBA 平面,3 或 4 字节/像素 |
dstYImage, dstUVImage / dstUImage, dstVImage / dstYUVImage | YUV 输出平面(NV 合并 UV、YV12 独立 U/V、YUV444 交织) |
width, height | 图像尺寸(NV/YV12 要求 偶数) |
*Stride | 每行字节数,0 = 自动 |
cvMatrix | 自定义 3×3 转换矩阵(仅 p.yuv_std = YUVEncodeStandard::STD_CUSTOM 时使用) |
p | YUVConvertParams — 选择标准、通道顺序、位深、range。默认 BT.601 8-bit full-range RGB。 |
NEON 版:acl::neon::cvtcolor::rgb*2*_fixed(仅 uint8_t)
cpp
template<class RGB_T, class YUV_T>
int rgb2NV21_fixed(
const RGB_T* rgbImage, YUV_T* dstYImage, YUV_T* dstUVImage,
int width, int height,
int rgbStride = 0, int yStride = 0, int uvStride = 0,
const float* cvMatrix = nullptr,
const acl::YUVConvertParams& p = {});
// 对应 12 个 NEON 入口(签名与 CPP 一致):
// rgb2NV21_fixed / rgba2NV21_fixed / rgb2YV12_fixed / rgba2YV12_fixed
// rgb2YUV444_fixed / rgba2YUV444_fixed
// nv212RGB_fixed / nv212RGBA_fixed / yv122RGB_fixed / yv122RGBA_fixed
// yuv4442RGB_fixed / yuv4442RGBA_fixedNEON RGB/YUV 输入/输出类型仅
uint8_t,其余参数(包括YUVConvertParams)与 CPP 版一致。
示例
cpp
uint8_t rgb[1920*1080*3];
uint8_t y[1920*1080], uv[1920*540*2];
// BT.601 full-range RGB → NV21(默认参数)
acl::neon::cvtcolor::rgb2NV21_fixed<uint8_t, uint8_t>(
rgb, y, uv, 1920, 1080);
// BT.709 limited-range NV12(覆盖默认值)
acl::YUVConvertParams p;
p.yuv_std = acl::YUVEncodeStandard::STD_BT709;
p.nv21_fmt = false; // NV12
p.yuv_full_range = false; // limited range [16, 235/240]
acl::cvtcolor::rgb2NV21_fixed<uint8_t, uint8_t>(
rgb, y, uv, 1920, 1080,
/*rgbStride=*/0, /*yStride=*/0, /*uvStride=*/0,
/*cvMatrix=*/nullptr, p);RGB ↔ YUV(float,仅 CPP)
浮点实现(精度更高,速度略慢于 fixed,适合对精度敏感场景)。NEON 无此路径。
Tier: Starter+
通道: 3ch RGB ↔ NV21 / NV12 / YV12 / YUV444
Inplace: 不支持
类型:
| 模板参数 | 允许类型 | 约束 |
|---|---|---|
RGB_T | uint8_t, uint16_t, float | — |
YUV_T | uint8_t, uint16_t, float | — |
CPP 签名(与 _fixed 版一一对应,仅去掉 _fixed 后缀)
签名、参数、尾部 YUVConvertParams& p 与 fixed 版完全一致;_float 变体侧重数值精度,_fixed 变体侧重吞吐性能。12 个入口:
RGB → YUV
cpp
template<class RGB_T, class YUV_T>
int rgb2NV21(const RGB_T* rgbImage, YUV_T* dstYImage, YUV_T* dstUVImage,
int width, int height,
int rgbStride = 0, int yStride = 0, int uvStride = 0,
const float* cvMatrix = nullptr,
const acl::YUVConvertParams& p = {});
template<class RGB_T, class YUV_T> int rgba2NV21(/* 同上,rgba 前缀 */);
template<class RGB_T, class YUV_T>
int rgb2YV12(const RGB_T* rgbImage,
YUV_T* dstYImage, YUV_T* dstUImage, YUV_T* dstVImage,
int width, int height,
int rgbStride = 0, int yStride = 0, int uStride = 0, int vStride = 0,
const float* cvMatrix = nullptr,
const acl::YUVConvertParams& p = {});
template<class RGB_T, class YUV_T> int rgba2YV12(/* 同上 */);
template<class RGB_T, class YUV_T>
int rgb2YUV444(const RGB_T* rgbImage, YUV_T* dstYUVImage,
int width, int height,
int rgbStride = 0, int yuvStride = 0,
const float* cvMatrix = nullptr,
const acl::YUVConvertParams& p = {});
template<class RGB_T, class YUV_T> int rgba2YUV444(/* 同上 */);YUV → RGB
cpp
template<class YUV_T, class RGB_T> int nv212RGB (...); // 签名镜像 nv212RGB_fixed
template<class YUV_T, class RGB_T> int nv212RGBA(...);
template<class YUV_T, class RGB_T> int yv122RGB (...);
template<class YUV_T, class RGB_T> int yv122RGBA(...);
template<class YUV_T, class RGB_T> int yuv4442RGB (...);
template<class YUV_T, class RGB_T> int yuv4442RGBA(...);参数列表、默认值与对应的
_fixed入口 完全相同,仅函数名去掉_fixed。
示例
cpp
// float RGB → NV21(float 精度)
float rgb_f[1920*1080*3];
float y_f[1920*1080], uv_f[1920*540*2];
acl::cvtcolor::rgb2NV21<float, float>(
rgb_f, y_f, uv_f, 1920, 1080);Bayer Demosaic
Bayer 原始图 → RGB / RGBA。支持 4 种 Bayer 模式(RGGB / GRBG / GBRG / BGGR)。
Tier: Starter+
通道: 1ch Bayer → 3ch RGB / 4ch RGBA
Inplace: 不支持
类型:
| 模板参数 | 允许类型 | 约束 |
|---|---|---|
T (CPP) | uint8_t, uint16_t | — |
T (NEON) | uint8_t | 仅 NEON |
CPP 版:acl::cvtcolor::bayer2RGB / bayer2RGBA
cpp
template<class ST, class DT>
int bayer2RGB(
const ST* bayerImage, DT* rgbImage,
int width, int height,
int bayerStride, int rgbStride,
int borderMode = 1,
int bayerDataBit = 8,
int RGBDataBit = 8,
acl::BayerPattern pattern = acl::BayerPattern::GBRG);
// RGBA 输出(4ch):
template<class ST, class DT>
int bayer2RGBA(
const ST* bayerImage, DT* rgbaImage,
int width, int height,
int bayerStride, int rgbaStride,
int borderMode = 1,
int bayerDataBit = 8,
int RGBDataBit = 8,
acl::BayerPattern pattern = acl::BayerPattern::GBRG);| 参数 | 类型 | 含义 | 默认 |
|---|---|---|---|
bayerImage | const ST* | 输入 Bayer 原始图 | 非空 |
rgbImage / rgbaImage | DT* | 输出 RGB / RGBA 图 | 非空 |
width, height | int | 图像尺寸 | > 0,偶数 |
bayerStride, rgbStride / rgbaStride | int | 每行字节数 | 0 = 自动 |
borderMode | int | 0 = 复制内圈;1 = reflect_101 | 1 |
bayerDataBit | int | bayer 数据有效位 | 8 |
RGBDataBit | int | RGB 数据有效位 | 8 |
pattern | acl::BayerPattern | Bayer 排列模式(RGGB / GRBG / GBRG / BGGR) | GBRG |
NEON 版:acl::neon::cvtcolor::bayer2RGB(仅 uint8_t,仅 3ch)
cpp
int bayer2RGB(
const uint8_t* bayerImage, uint8_t* rgbImage,
int width, int height,
acl::BayerPattern pattern,
int bayerStride = 0, int rgbStride = 0);NEON 无
bayer2RGBA入口,且borderMode固定为 reflect_101。
示例
cpp
uint8_t bayer[1920*1080], rgb[1920*1080*3];
// NEON(运行时 pattern)
acl::neon::cvtcolor::bayer2RGB(bayer, rgb, 1920, 1080,
acl::BayerPattern::RGGB);
// CPP(u16 bayer → u8 RGB,RGGB pattern)
uint16_t bayer16[1920*1080];
acl::cvtcolor::bayer2RGB<uint16_t, uint8_t>(
bayer16, rgb, 1920, 1080,
/*bayerStride=*/0, /*rgbStride=*/0,
/*borderMode=*/1, /*bayerDataBit=*/10, /*RGBDataBit=*/8,
acl::BayerPattern::RGGB);RGB ↔ HSV
RGB/BGR 与 HSV 互转。
Tier: Pro+
通道: 3ch ↔ 3ch
Inplace: 不支持
类型:
| 模板参数 | 允许类型 | 约束 |
|---|---|---|
T | uint8_t | — |
CPP / NEON 签名(一致)
cpp
// CPP 和 NEON 同名同签,仅命名空间不同
int bgr2HSV(const uint8_t* bgrImage, uint8_t* hsvImage,
int width, int height, int srcStride = 0, int dstStride = 0);
int rgb2HSV(const uint8_t* rgbImage, uint8_t* hsvImage, ...);
int hsv2BGR(const uint8_t* hsvImage, uint8_t* bgrImage, ...); // 仅 CPP 有NEON 仅提供
bgr2HSV/rgb2HSV两个入口,没有hsv2BGR。如需反向转换请用 CPP 版。
| 参数 | 类型 | 含义 | 默认 |
|---|---|---|---|
bgrImage / rgbImage / hsvImage | const uint8_t* / uint8_t* | 输入 / 输出平面 | 非空 |
width, height | int | 图像尺寸 | > 0 |
srcStride, dstStride | int | 每行字节数 | 0 = 自动 |
HSV 编码:H ∈ [0, 180](OpenCV 兼容),S, V ∈ [0, 255]。
示例
cpp
uint8_t rgb[1920*1080*3], hsv[1920*1080*3];
acl::neon::cvtcolor::rgb2HSV(rgb, hsv, 1920, 1080);RGB ↔ Lab
RGB/BGR 与 CIE Lab 互转。
Tier: Pro+
通道: 3ch ↔ 3ch
Inplace: 不支持
类型:
| 模板参数 | 允许类型 | 约束 |
|---|---|---|
T | uint8_t | — |
CPP / NEON 签名(一致)
cpp
int bgr2Lab(const uint8_t* bgrImage, uint8_t* labImage,
int width, int height, int srcStride = 0, int dstStride = 0);
int rgb2Lab(const uint8_t* rgbImage, uint8_t* labImage, ...);
int lab2BGR(const uint8_t* labImage, uint8_t* bgrImage, ...); // 仅 CPP 有NEON 仅提供
bgr2Lab/rgb2Lab,没有lab2BGR。
Lab 编码:L ∈ [0, 255](对应 L* 0-100 映射)、a, b ∈ [0, 255](中心 128)。
示例
cpp
uint8_t rgb[1920*1080*3], lab[1920*1080*3];
acl::neon::cvtcolor::rgb2Lab(rgb, lab, 1920, 1080);gammaTransform
Gamma 变换:dst = A * base * (src/base)^gamma,用于显示 gamma 校正、曝光压缩等。
Tier: Starter+
通道: 1ch
Inplace: 支持
类型:
| 模板参数 | 允许类型 | 约束 |
|---|---|---|
T | {uint8_t, uint16_t} | — |
GT(计算精度)∈ {float, double} | — | — |
CPP 签名
cpp
template<class T, class GT = float>
int gammaTransform(
const T* srcImage, T* dstImage,
int width, int height,
int srcStride, int dstStride,
const GT& gamma,
int normalizeBase,
bool if_round = false,
const GT& A = GT{1});| 参数 | 类型 | 含义 | 默认 |
|---|---|---|---|
srcImage, dstImage | const T* / T* | 输入 / 输出 | 非空 |
width, height | int | 图像尺寸 | > 0 |
srcStride, dstStride | int | 每行字节数 | 必填(0 = 自动) |
gamma | GT | Gamma 指数 | 2.2(显示)/ 1/2.2(反 gamma) |
normalizeBase | int | 归一化到 [0, 1] 的基值 | u8:255 / u16:1023 等 |
if_round | bool | 结果是否 round(否则 floor) | false |
A | GT | 线性缩放系数 | 1 |
示例
cpp
uint8_t src[1920*1080], dst[1920*1080];
// 显示 gamma 校正(2.2)
acl::cvtcolor::gammaTransform<uint8_t, float>(
src, dst, 1920, 1080, 0, 0, 2.2f, 255);Filter
Namespace: acl::filter (cpp) / acl::neon::filter (NEON)
gaussianBlur
高斯模糊(低通滤波),使用可分离核(行 kernel × 列 kernel)加速。
Tier: Starter+
通道: 1ch / 3ch
Inplace: 不支持
类型:
| 模板参数 | 允许类型 | 约束 |
|---|---|---|
ST | uint8_t, uint16_t, float | — |
DT | uint8_t, uint16_t, float | — |
CPP 版:acl::filter::gaussianBlur
cpp
template<class ST, class DT>
int gaussianBlur(
const ST* srcImage, DT* dstImage,
int width, int height, int cn,
int srcStride, int dstStride,
int kRadiusX, int kRadiusY,
double sigmaX = 0.0, double sigmaY = 0.0,
ST* constant = nullptr,
acl::BorderType bt = acl::BorderType::BORDER_REFLECT_101);| 参数 | 类型 | 含义 | 默认 |
|---|---|---|---|
srcImage, dstImage | const ST* / DT* | 输入 / 输出,dstImage 须预分配 | 非空 |
width, height | int | 图像尺寸(像素) | > 0 |
cn | int | 通道数 | 1 或 3 |
srcStride, dstStride | int | 每行字节数 | 0 = 自动 |
kRadiusX, kRadiusY | int | 核半径;核大小 = 2r+1 | ≥ 1 |
sigmaX, sigmaY | double | 高斯 sigma | 0 = 自动(σ = 0.15·kSize + 0.35) |
constant | ST* | BORDER_CONSTANT 填充值指针 | nullptr |
bt | acl::BorderType | 边界处理 | BORDER_REFLECT_101 |
NEON 版:acl::neon::filter::gaussianBlur*(仅 uint8_t)
NEON 层提供固定核和通用两类入口:
| 入口 | 核 | 通道 | Tier | sigma 可配 |
|---|---|---|---|---|
gaussianBlur3x3 | 3×3 | 1 | Starter+ | — |
gaussianBlur3x3_3ch | 3×3 | 3 | Starter+ | — |
gaussianBlur5x5 | 5×5 | 1 | Starter+ | — |
gaussianBlur11x11 | 11×11 | 1 | Starter+ | — |
gaussianBlur(通用) | 任意 2r+1 | 1 | Starter+ | ✅ |
gaussianBlur5x5_3ch | 5×5 | 3 | Starter+ | — |
Trial package note: Trial 不包含 gaussianBlur。Trial demo surface 请使用 resize wrapper
acl::trial::resizeBilinear2xDown_cpp(const uint8_t*, uint8_t*)或acl::trial::resizeBilinear2xDown_neon(const uint8_t*, uint8_t*)。
固定核签名(3x3 / 5x5 / 11x11 / 3x3_3ch / 5x5_3ch 签名一致):
cpp
int gaussianBlur3x3( // 或 gaussianBlur5x5 / gaussianBlur11x11 / gaussianBlur3x3_3ch / gaussianBlur5x5_3ch
const uint8_t* srcImage, uint8_t* dstImage,
int width, int height,
int srcStride = 0, int dstStride = 0,
uint8_t constant = 0,
acl::BorderType bt = acl::BorderType::BORDER_REFLECT_101);通用签名(支持任意 radius / sigma):
cpp
int gaussianBlur(
const uint8_t* srcImage, uint8_t* dstImage,
int width, int height,
int srcStride, int dstStride,
int kRadiusX, int kRadiusY,
double sigmaX = 0.0, double sigmaY = 0.0,
int constant = 0,
acl::BorderType bt = acl::BorderType::BORDER_REFLECT_101);Smart dispatch:当
kSize ∈ {3, 5, 11}且sigma = 0时,通用版的吞吐与对应固定核变体一致;其他(kSize, sigma)组合的性能特征对齐动态sepFilter2D。
示例
cpp
#include <acl/acl.h>
#include <acl/api.h>
acl::init("license.dat");
uint8_t src[1920*1080], dst[1920*1080];
// 情况 1:3×3 固定核(Starter+ 付费 API)
acl::neon::filter::gaussianBlur3x3(src, dst, 1920, 1080);
// 情况 2:5×5 + 自定义 sigma(Starter+)
acl::neon::filter::gaussianBlur(src, dst, 1920, 1080, 0, 0, 2, 2, 1.5, 1.5);性能(SD8550, 1920×1280, uint8_t, 1ch)
| 变体 | ACL (ms) | OpenCV (ms) | Speedup |
|---|---|---|---|
| 3×3 | 4.07 | 4.20 | 1.03× |
| 5×5 | 0.69 | 11.0 | 15.9× |
boxFilter
盒式(均值)滤波,核内所有像素等权求和。可选归一化(normalize=true 时除以核大小,即标准均值滤波)。
Tier: Starter+
通道: 1ch / 3ch
Inplace: 不支持
类型:
| 模板参数 | 允许类型 | 约束 |
|---|---|---|
ST, DT (CPP) | {uint8_t, uint16_t, float} | — |
DT (NEON) | {uint8_t, int} (src 为 uint8_t) | 仅 NEON |
CPP 版:acl::filter::boxFilter
cpp
template<class ST, class DT>
int boxFilter(
const ST* srcImage, DT* dstImage,
int width, int height, int cn,
int srcStride, int dstStride,
int kRadius,
bool isNormalize = true,
acl::BorderType bt = acl::BorderType::BORDER_REFLECT_101);| 参数 | 类型 | 含义 | 默认 |
|---|---|---|---|
srcImage, dstImage | const ST* / DT* | 输入 / 输出 | 非空 |
width, height | int | 图像尺寸(像素) | > 0 |
cn | int | 通道数 | 1 或 3 |
srcStride, dstStride | int | 每行字节数 | 0 = 自动 |
kRadius | int | 核半径(kSize = 2r+1) | ≥ 1 |
isNormalize | bool | true → 均值(除以 kSize²);false → 求和 | true |
bt | acl::BorderType | 边界处理 | BORDER_REFLECT_101 |
NEON 版:acl::neon::filter::boxFilter*(仅 uint8_t)
| 入口 | 核 | 通道 | Tier |
|---|---|---|---|
boxFilter3x3 | 3×3 | 1 | Starter+ |
boxFilter5x5 | 5×5 | 1 | Starter+ |
boxFilter(通用) | 任意 2r+1 | 1 | Starter+ |
3 通道暂无 NEON 入口,请用 CPP 版
acl::filter::boxFilter<uint8_t,uint8_t>(..., cn=3)。
固定核签名(boxFilter3x3 / boxFilter5x5):
cpp
template<class DT>
int boxFilter3x3( // 或 boxFilter5x5
const uint8_t* srcImage, DT* dstImage,
int width, int height,
int srcStride, int dstStride,
int constant = 0,
bool isNormalize = true,
int cn = 1,
acl::BorderType bt = acl::BorderType::BORDER_REFLECT_101);通用签名:
cpp
template<class DT>
int boxFilter(
const uint8_t* srcImage, DT* dstImage,
int width, int height,
int srcStride, int dstStride,
int kRadius, int constant,
bool isNormalize = true,
int cn = 1,
acl::BorderType bt = acl::BorderType::BORDER_REFLECT_101);DT 支持 uint8_t(normalize)/ uint32_t(不 normalize,防溢出)。cn 为运行时参数(1 或 3)。
示例
cpp
// 3×3 均值滤波
acl::neon::filter::boxFilter3x3<uint8_t>(src, dst, 1920, 1080, 0, 0);
// 5×5 求和(不归一化,输出 u32)
acl::neon::filter::boxFilter5x5<uint32_t>(
src, (uint32_t*)dst_u32, 1920, 1080, 0, 0,
/*constant=*/0, /*isNormalize=*/false, /*cn=*/1,
acl::BorderType::BORDER_REPLICATE);filter2D
通用 2D 卷积(任意核)。内部自动检测可分离核,若可分离自动转为 sepFilter2D 加速。
Tier: Starter+
通道: 1ch / 3ch
Inplace: 不支持
类型:
| 模板参数 | 允许类型 | 约束 |
|---|---|---|
ST | uint8_t, uint16_t, float | — |
DT | uint8_t, uint16_t, float | — |
KT | uint8_t, uint16_t, float | — |
CPP 版:acl::filter::filter2D
cpp
template<class ST, class DT, class KT>
int filter2D(
const ST* srcImage, DT* dstImage,
int width, int height, int cn,
int srcStride, int dstStride,
const KT* kernel, int kRadiusX, int kRadiusY,
const ST* constant = nullptr,
bool isNormalize = true,
acl::BorderType bt = acl::BorderType::BORDER_REFLECT_101);| 参数 | 类型 | 含义 | 默认 |
|---|---|---|---|
srcImage, dstImage | const ST* / DT* | 输入 / 输出 | 非空 |
width, height | int | 图像尺寸 | > 0 |
cn | int | 通道数 | 1 或 3 |
srcStride, dstStride | int | 每行字节数 | 0 = 自动 |
kernel | const KT* | 核数据,行主序,大小 (2rX+1)×(2rY+1) | 非空 |
kRadiusX, kRadiusY | int | 核半径 | ≥ 1 |
constant | const ST* | BORDER_CONSTANT 填充值指针 | nullptr |
isNormalize | bool | 输出除以 kernel 元素和(用于均值类核) | true |
bt | acl::BorderType | 边界处理 | BORDER_REFLECT_101 |
NEON 版:acl::neon::filter::filter2D(仅 uint8_t 输入)
cpp
template<class DT, class KT>
int filter2D(
const uint8_t* srcImage, DT* dstImage,
int width, int height,
int srcStride, int dstStride,
const KT* kernel, int kRadiusX, int kRadiusY,
int constant = 0,
bool isNormalize = true,
int cn = 1,
acl::BorderType bt = acl::BorderType::BORDER_REFLECT_101);DT / KT:常见 (uint8_t, float) 或 (int32_t, int32_t)。
示例
cpp
// 5×5 拉普拉斯核(不归一化,锐化)
int K[25] = { 0, 0,-1, 0, 0,
0,-1,-2,-1, 0,
-1,-2,17,-2,-1,
0,-1,-2,-1, 0,
0, 0,-1, 0, 0 };
acl::filter::filter2D<uint8_t, uint8_t, int>(
src, dst, 1920, 1080, 1, 0, 0, K, 2, 2,
nullptr, /*isNormalize=*/false, acl::BorderType::BORDER_REPLICATE);sepFilter2D
可分离 2D 卷积:先沿行方向卷积 kernelX,再沿列方向卷积 kernelY。比 filter2D 快 O(k) → O(2k)。
Tier: Starter+
通道: 1ch / 3ch
Inplace: 不支持
类型:
| 模板参数 | 允许类型 | 约束 |
|---|---|---|
ST | uint8_t, uint16_t, float | — |
DT | uint8_t, uint16_t, float | — |
KT | uint8_t, uint16_t, float | — |
CPP 版:acl::filter::sepFilter2D
cpp
template<class ST, class DT, class KT>
int sepFilter2D(
const ST* srcImage, DT* dstImage,
int width, int height, int cn,
int srcStride, int dstStride,
const KT* kernelX, const KT* kernelY,
int kRadiusX, int kRadiusY,
const ST* constant = nullptr,
bool isNormalize = true,
acl::BorderType bt = acl::BorderType::BORDER_REFLECT_101);| 参数 | 类型 | 含义 | 默认 |
|---|---|---|---|
srcImage, dstImage | const ST* / DT* | 输入 / 输出 | 非空 |
width, height | int | 图像尺寸 | > 0 |
cn | int | 通道数 | 1 或 3 |
srcStride, dstStride | int | 每行字节数 | 0 = 自动 |
kernelX, kernelY | const KT* | 行 / 列 1D 核,长度分别 2rX+1 / 2rY+1 | 非空 |
kRadiusX, kRadiusY | int | 核半径 | ≥ 1 |
constant | const ST* | BORDER_CONSTANT 填充值指针 | nullptr |
isNormalize | bool | true 表示除以核和 | true |
bt | acl::BorderType | 边界处理模式 | BORDER_REFLECT_101 |
NEON 版:acl::neon::filter::sepFilter2D(仅 uint8_t,1ch / 3ch)
cpp
template<class KT>
int sepFilter2D(
const uint8_t* srcImage, uint8_t* dstImage,
int width, int height,
int srcStride, int dstStride,
const KT* kernelX, const KT* kernelY,
int kRadiusX, int kRadiusY,
int constant = 0,
int cn = 1,
acl::BorderType bt = acl::BorderType::BORDER_REFLECT_101);cn = 1 或 3(运行期选择通道数)。KT:一般 float。
示例
cpp
// 高斯 5×5 分解成 [1,4,6,4,1]/16 × [1,4,6,4,1]/16
float kx[5] = {1,4,6,4,1}, ky[5] = {1,4,6,4,1};
acl::neon::filter::sepFilter2D<float>(
src, dst, 1920, 1080, 0, 0, kx, ky, 2, 2, /*constant=*/0, /*cn=*/1);sobel3x3
3×3 Sobel 边缘检测算子。运行期参数 isGradX 选择计算 Gx(水平梯度)或 Gy(垂直梯度)。
Tier: Starter+
通道: 1ch(多通道分别调用或用 filter2D)
Inplace: 不支持
类型:
| 模板参数 | 允许类型 | 约束 |
|---|---|---|
ST | {uint8_t, uint16_t, float} | — |
DT 通常为 int16_t / int32_t / float | — | — |
输出类型:int16_t(short)(因为梯度值可能为负) |
CPP 版:acl::filter::sobel3x3
cpp
template<class ST, class DT>
int sobel3x3(
const ST* srcImage, DT* dstImage,
int width, int height, int cn,
int srcStride = 0, int dstStride = 0,
const ST* constant = nullptr,
bool isGradX = true,
acl::BorderType bt = acl::BorderType::BORDER_REFLECT_101);| 参数 | 类型 | 含义 | 默认 |
|---|---|---|---|
srcImage, dstImage | const ST* / DT* | 输入 / 输出 | 非空 |
width, height | int | 图像尺寸 | > 0 |
cn | int | 通道数 | 1 或 3 |
srcStride, dstStride | int | 每行字节数 | 0 = 自动 |
constant | const ST* | BORDER_CONSTANT 填充值 | nullptr |
isGradX | bool | true:Gx(水平);false:Gy(垂直) | true |
bt | acl::BorderType | 边界处理模式 | BORDER_REFLECT_101 |
两个方向梯度需分别调用两次。
NEON 版:acl::neon::filter::sobel3x3(仅 uint8_t → int16_t,1ch)
cpp
int sobel3x3(
const uint8_t* srcImage, int16_t* dstImage,
int width, int height,
int srcStride = 0, int dstStride = 0,
int constant = 0,
bool isGradX = true,
acl::BorderType bt = acl::BorderType::BORDER_REFLECT_101);示例
cpp
int16_t gx[1920*1080], gy[1920*1080];
acl::neon::filter::sobel3x3(src_u8, gx, 1920, 1080, 0, 0, 0, /*isGradX=*/true); // Gx
acl::neon::filter::sobel3x3(src_u8, gy, 1920, 1080, 0, 0, 0, /*isGradX=*/false); // Gy
// 梯度幅值可用 acl::arithmetic::phaseMagnitude 合成性能(SD8550, 1920×1280, uint8_t, 1ch)
| 方向 | ACL (ms) | OpenCV (ms) | Speedup |
|---|---|---|---|
| Gx | 0.23 | 5.33 | 23.6× |
scharr
3×3 Scharr 边缘检测算子。比 Sobel 具有更好的旋转对称性,数值精度略高。
Tier: Starter+
通道: 1ch
Inplace: 不支持
类型:
| 模板参数 | 允许类型 | 约束 |
|---|---|---|
ST | {uint8_t, uint16_t, float} | — |
DT 通常为 int16_t / int32_t / float | — | — |
输出类型: int16_t |
CPP 版:acl::filter::scharr
cpp
template<class ST, class DT>
int scharr(
const ST* srcImage, DT* dstImage,
int width, int height,
int srcStride = 0, int dstStride = 0,
const ST* constant = nullptr,
bool isGradX = true,
acl::BorderType bt = acl::BorderType::BORDER_REFLECT_101);参数语义与 sobel3x3 相同(只是内核系数为 Scharr [-3, -10, -3; 0, 0, 0; 3, 10, 3] 而非 Sobel)。
NEON 版:acl::neon::filter::scharr(仅 uint8_t → int16_t)
cpp
int scharr(
const uint8_t* srcImage, int16_t* dstImage,
int width, int height,
int srcStride = 0, int dstStride = 0,
bool isGradX = true,
acl::BorderType bt = acl::BorderType::BORDER_REFLECT_101);示例
cpp
int16_t gx[1920*1080];
acl::neon::filter::scharr(src_u8, gx, 1920, 1080, 0, 0, /*isGradX=*/true); // Gx (Scharr)性能(SD8550, 1920×1280, uint8_t, 1ch)
| 方向 | ACL (ms) | OpenCV (ms) | Speedup |
|---|---|---|---|
| Gx | 0.35 | 10.16 | 28.8× |
laplacian
拉普拉斯算子(二阶梯度),用于边缘检测或锐化。内部通过 3×3 或更大内核做两次卷积。
Tier: Starter+
通道: 1ch
Inplace: 不支持
类型:
| 模板参数 | 允许类型 | 约束 |
|---|---|---|
ST | {uint8_t, uint16_t, float} | — |
DT 通常为 int16_t / int32_t / float | — | — |
输出类型: int16_t(二阶梯度可能为负) |
CPP 版:acl::filter::laplacian
cpp
template<class ST, class DT>
int laplacian(
const ST* srcImage, DT* dstImage,
int width, int height, int cn,
int srcStride = 0, int dstStride = 0,
int ksize = 1, double scale = 1.0, double delta = 0.0,
const ST* constant = nullptr,
acl::BorderType bt = acl::BorderType::BORDER_REFLECT_101);| 参数 | 类型 | 含义 | 默认 |
|---|---|---|---|
srcImage, dstImage | const ST* / DT* | 输入 / 输出 | 非空 |
width, height | int | 图像尺寸 | > 0 |
cn | int | 通道数 | 1 |
srcStride, dstStride | int | 每行字节数 | 0 = 自动 |
ksize | int | 内核孔径大小 | 1(= 3×3 标准拉普拉斯) |
scale | double | 输出缩放因子 | 1.0 |
delta | double | 输出偏移量 | 0.0 |
constant | const ST* | BORDER_CONSTANT 填充值 | nullptr |
bt | acl::BorderType | 边界处理模式 | BORDER_REFLECT_101 |
NEON 版:acl::neon::filter::laplacian(仅 uint8_t → int16_t)
cpp
int laplacian(
const uint8_t* srcImage, int16_t* dstImage,
int width, int height,
int srcStride = 0, int dstStride = 0,
int ksize = 1, int constant = 0,
acl::BorderType bt = acl::BorderType::BORDER_REFLECT_101);NEON 版省略了
scale/delta(固定 1.0 / 0.0)。需要缩放请用 CPP 版。
示例
cpp
int16_t dst[1920*1080];
acl::neon::filter::laplacian(src_u8, dst, 1920, 1080);canny
Canny 边缘检测。典型流程:高斯模糊 → 求梯度 → 非极大值抑制 → 双阈值连接。
Tier: Starter+
通道: 1ch(灰度输入)
Inplace: 不支持
类型:
| 模板参数 | 允许类型 | 约束 |
|---|---|---|
Src_T | uint8_t、uint16_t | CPP 后端 |
Src_T | uint8_t | NEON 后端 |
NEON 版:acl::neon::filter::canny(仅 uint8_t)
cpp
int canny(
const uint8_t* srcImage, uint8_t* dstImage,
int width, int height,
int low_thresh, int high_thresh,
int aperture_size = 3,
int srcStride = 0, int dstStride = 0,
bool l2GradFlag = true);| 参数 | 类型 | 含义 | 默认 |
|---|---|---|---|
srcImage | const uint8_t* | 输入灰度图 | 非空 |
dstImage | uint8_t* | 输出二值边缘图(0 / 255) | 非空 |
width, height | int | 图像尺寸 | > 0 |
low_thresh, high_thresh | int | 双阈值(低 / 高) | low < high |
aperture_size | int | Sobel 核孔径 | 3(仅支持 3) |
srcStride, dstStride | int | 每行字节数 | 0 = 自动 |
l2GradFlag | bool | true:L2 欧氏梯度;false:L1 梯度(更快) | true |
示例
cpp
uint8_t src[1920*1080], dst[1920*1080];
acl::neon::filter::canny(src, dst, 1920, 1080, 50, 150);morphology (erode / dilate)
形态学基础算子:腐蚀(erode,取 kernel 覆盖区最小值)与 膨胀(dilate,取最大值)。使用 O(N) van Herk / Gil-Werman 算法,耗时与核大小无关。
Tier: Starter+
通道: 1ch / 3ch
Inplace: 不支持
类型:
| 模板参数 | 允许类型 | 约束 |
|---|---|---|
T | uint8_t, uint16_t, float | — |
内核形状:方形(由 radius 决定,实际核大小 = 2r+1) |
CPP 版:acl::filter::erode / acl::filter::dilate
cpp
template<class T>
int erode(
const T* srcImage, T* dstImage,
int width, int height, int cn, int radius,
int srcStride = 0, int dstStride = 0);
template<class T>
int dilate(
const T* srcImage, T* dstImage,
int width, int height, int cn, int radius,
int srcStride = 0, int dstStride = 0);| 参数 | 类型 | 含义 | 默认 |
|---|---|---|---|
srcImage, dstImage | const T* / T* | 输入 / 输出 | 非空 |
width, height | int | 图像尺寸 | > 0 |
cn | int | 通道数 | 1 或 3 |
radius | int | 结构元半径(方核,大小 = 2r+1) | ≥ 1 |
srcStride, dstStride | int | 每行字节数 | 0 = 自动 |
NEON 版:acl::neon::filter::erode / acl::neon::filter::dilate(仅 uint8_t)
cpp
int erode( // 或 dilate
const uint8_t* srcImage, uint8_t* dstImage,
int width, int height, int cn, int radius,
int srcStride = 0, int dstStride = 0);参数语义与 CPP 版一致。
示例
cpp
// 3×3 腐蚀(radius=1)
acl::filter::erode<uint8_t>(src, dst, 1920, 1080, 1, 1);
// 11×11 膨胀(radius=5,O(N) 算法不受尺寸影响)
acl::filter::dilate<uint8_t>(src, dst, 1920, 1080, 1, 5);medianFilter
3×3 中值滤波 — 取 kernel 内 9 个像素的中间值作为输出。典型用途:去椒盐噪声。
Tier: Starter+
通道: 1ch / 3ch
Inplace: 支持(src == dst OK)
类型:
| 模板参数 | 允许类型 | 约束 |
|---|---|---|
DT | uint8_t, uint16_t, float | — |
| 核大小:仅 3×3(未实现 5×5 及以上) |
CPP 版:acl::filter::medianFilter3x3
cpp
template<class DT>
int medianFilter3x3(
const DT* srcImage, DT* dstImage,
int width, int height,
int cn = 1,
int srcStride = 0, int dstStride = 0,
DT borderValue = 0,
acl::BorderType bt = acl::BorderType::BORDER_REFLECT_101);| 参数 | 类型 | 含义 | 默认 |
|---|---|---|---|
srcImage, dstImage | const DT* / DT* | 输入 / 输出(支持 inplace) | 非空 |
width, height | int | 图像尺寸 | > 0 |
cn | int | 通道数 | 1 |
srcStride, dstStride | int | 每行字节数 | 0 = 自动 |
borderValue | DT | BORDER_CONSTANT 填充值 | 0 |
bt | acl::BorderType | 边界处理模式 | BORDER_REFLECT_101 |
NEON 版:acl::neon::filter::medianFilter3x3 / medianFilter3x3_3ch(仅 uint8_t)
| 入口 | 通道 | Tier |
|---|---|---|
medianFilter3x3 | 1 | Starter+ |
medianFilter3x3_3ch | 3 | Starter+ |
cpp
int medianFilter3x3( // 或 medianFilter3x3_3ch
const uint8_t* srcImage, uint8_t* dstImage,
int width, int height,
int srcStride = 0, int dstStride = 0,
uint8_t borderValue = 0,
acl::BorderType bt = acl::BorderType::BORDER_REFLECT_101);示例
cpp
// 去椒盐噪声(in-place)
acl::neon::filter::medianFilter3x3(src, src, 1920, 1080);bilateralFilter
保边平滑滤波 — 双边滤波,同时考虑空间距离和像素值差异,能去噪但保留边缘。
Tier: Pro+
通道: 1ch / 3ch
Inplace: 不支持
类型:
| 模板参数 | 允许类型 | 约束 |
|---|---|---|
T (CPP) | uint8_t, uint16_t, float | — |
T (NEON) | uint8_t | 仅 NEON |
CPP 版:acl::filter::bilateralFilter
cpp
template<class T = uint8_t>
int bilateralFilter(
const T* srcImage, T* dstImage,
int width, int height, int cn,
int srcStride, int dstStride,
int d, double sigmaColor, double sigmaSpace,
const T* constant = nullptr,
acl::BorderType bt = acl::BorderType::BORDER_REFLECT_101);| 参数 | 类型 | 含义 | 默认 |
|---|---|---|---|
srcImage, dstImage | const T* / T* | 输入 / 输出 | 非空 |
width, height | int | 图像尺寸 | > 0 |
cn | int | 通道数 | 1 或 3 |
srcStride, dstStride | int | 每行字节数 | 必填 |
d | int | 滤波半径(即 kernel = 2d+1) | ≥ 1 |
sigmaColor | double | 颜色空间标准差 | 典型 10-100 |
sigmaSpace | double | 坐标空间标准差 | 典型 10-100 |
constant | const T* | BORDER_CONSTANT 填充值 | nullptr |
bt | acl::BorderType | 边界处理 | BORDER_REFLECT_101 |
NEON 版:acl::neon::filter::bilateralFilter(仅 uint8_t,1ch / 3ch)
cpp
int bilateralFilter(
const uint8_t* srcImage, uint8_t* dstImage,
int width, int height,
int srcStride, int dstStride,
int d, double sigmaColor, double sigmaSpace,
int constant = 0,
int cn = 1,
acl::BorderType bt = acl::BorderType::BORDER_REFLECT_101);cn = 1 或 3(运行时通道数)。
示例
cpp
// 边缘保持去噪,d=5, sigmaColor=sigmaSpace=30
acl::neon::filter::bilateralFilter(
src, dst, 1920, 1080, 0, 0, 5, 30.0, 30.0);nlMeansDenoising
Non-Local Means 去噪 — 在整个搜索窗内找相似 patch 做加权平均,去噪同时保留细节。
Tier: Pro+
通道: 1ch
Inplace: 不支持
类型:
| 模板参数 | 允许类型 | 约束 |
|---|---|---|
T (CPP) | uint8_t, uint16_t, float | — |
T (NEON) | uint8_t | 仅 NEON |
CPP 版:acl::filter::nlMeansDenoising
cpp
template<class T = uint8_t>
int nlMeansDenoising(
const T* srcImage, T* dstImage,
int width, int height,
int srcStride, int dstStride,
float h,
int patchRadius = 3,
int searchRadius = 10);| 参数 | 类型 | 含义 | 默认 |
|---|---|---|---|
srcImage, dstImage | const T* / T* | 输入 / 输出 | 非空 |
width, height | int | 图像尺寸 | > 0 |
srcStride, dstStride | int | 每行字节数 | 必填 |
h | float | 去噪强度(越大越平滑;典型 5-15) | 必填 |
patchRadius | int | patch 半径(patch = 2r+1) | 3(= 7×7) |
searchRadius | int | 搜索窗半径 | 10(= 21×21) |
NEON 版:acl::neon::filter::nlMeansDenoising(仅 uint8_t)
cpp
int nlMeansDenoising(
const uint8_t* srcImage, uint8_t* dstImage,
int width, int height,
int srcStride, int dstStride,
float h,
int patchRadius = 3,
int searchRadius = 10);非模板,签名与 CPP 版相同(去掉模板
<T>)。
示例
cpp
uint8_t srcImage[1920*1080], dstImage[1920*1080];
// 轻量去噪(h=10, patch 7×7, search 21×21 — 默认)
acl::neon::filter::nlMeansDenoising(srcImage, dstImage, 1920, 1080, 0, 0, 10.0f);
// 更强去噪 + 更大搜索窗
acl::neon::filter::nlMeansDenoising(srcImage, dstImage, 1920, 1080, 0, 0, 15.0f, 3, 15);性能(SD8650, 1920×1280, uint8_t, patch=3, search=5)
| 参数 | ACL (ms) | OpenCV (ms) | Speedup |
|---|---|---|---|
| h=10 | 445 | 12,133 | 27.3× |
guidedFilter
引导滤波 — 基于引导图(guideImage)对输入图像做边缘感知平滑。O(N) 复杂度(不随核大小增长)。
Tier: Pro+
通道: 1ch
Inplace: 不支持
类型:
| 模板参数 | 允许类型 | 约束 |
|---|---|---|
T | uint8_t, uint16_t, float | — |
CPP 版:acl::filter::guidedFilter
cpp
template<class T>
int guidedFilter(
const T* guideImage,
const T* srcImage,
T* dstImage,
int width, int height,
int guideStride, int srcStride, int dstStride,
int radius, double eps);| 参数 | 类型 | 含义 | 默认 |
|---|---|---|---|
guideImage | const T* | 引导图(常与 srcImage 相同,也可用其他图) | 非空 |
srcImage, dstImage | const T* / T* | 输入 / 输出 | 非空 |
width, height | int | 图像尺寸 | > 0 |
guideStride, srcStride, dstStride | int | 各自每行字节数 | 必填 |
radius | int | 窗口半径(窗口大小 = 2r+1) | ≥ 1 |
eps | double | 正则化参数 | 典型 0.01(整数图 1.0-100.0) |
NEON 版:acl::neon::filter::guidedFilter(仅 uint8_t)
cpp
int guidedFilter(
const uint8_t* guideImage,
const uint8_t* srcImage,
uint8_t* dstImage,
int width, int height,
int guideStride, int srcStride, int dstStride,
int radius, double eps);示例
cpp
uint8_t srcImage[1920*1080], dstImage[1920*1080];
// 以原图自身作 guide,radius=8, eps=1000
acl::filter::guidedFilter<uint8_t>(
srcImage, srcImage, dstImage, 1920, 1080, 1920, 1920, 1920, 8, 1000.0);stackBlur
O(1) 近似高斯模糊(复杂度与核大小无关),适合大核场景。效果接近高斯但略有差异,用在不要求精确高斯的场景(如 UI 模糊背景)。
Tier: Starter+
通道: 1ch / 3ch
Inplace: 不支持
类型:
| 模板参数 | 允许类型 | 约束 |
|---|---|---|
T | uint8_t, uint16_t, float | — |
CPP 版:acl::filter::stackBlur
cpp
template<class T>
int stackBlur(
const T* srcImage, T* dstImage,
int width, int height, int cn,
int srcStride = 0, int dstStride = 0,
int kSizeX = 3, int kSizeY = 3);NEON 版:acl::neon::filter::stackBlur(仅 uint8_t)
cpp
int stackBlur(
const uint8_t* srcImage, uint8_t* dstImage,
int width, int height, int cn,
int srcStride = 0, int dstStride = 0,
int kSizeX = 3, int kSizeY = 3);| 参数 | 类型 | 含义 | 默认 |
|---|---|---|---|
srcImage, dstImage | const T* / T* (NEON: uint8_t*) | 输入 / 输出 | 非空 |
width, height | int | 图像尺寸 | > 0 |
cn | int | 通道数 | 1 或 3 |
srcStride, dstStride | int | 每行字节数 | 0 = 自动 |
kSizeX, kSizeY | int | 水平 / 垂直核大小(必须为奇数) | 3 |
示例
cpp
uint8_t srcImage[1920*1080], dstImage[1920*1080];
// 21×21 模糊(远超 Gaussian 11×11 的尺寸,O(1) 算法性能不衰减)
acl::filter::stackBlur<uint8_t>(srcImage, dstImage, 1920, 1080, 1, 0, 0, 21, 21);unsharpMask
反锐化遮罩(Unsharp Mask)— 通过从原图减去模糊图,得到锐化增强。amount 控制锐化强度。
Tier: Pro+
通道: 1ch
Inplace: 不支持
类型:
| 模板参数 | 允许类型 | 约束 |
|---|---|---|
T | uint8_t, uint16_t, float | — |
CPP 版:acl::filter::unsharpMask
cpp
template<class T>
int unsharpMask(
const T* srcImage, T* dstImage,
int width, int height,
int srcStride, int dstStride,
int kRadius, double sigma, float amount);| 参数 | 类型 | 含义 | 默认 |
|---|---|---|---|
srcImage, dstImage | const T* / T* | 输入 / 输出 | 非空 |
width, height | int | 图像尺寸 | > 0 |
srcStride, dstStride | int | 每行字节数 | 必填 |
kRadius | int | 高斯核半径 | ≥ 1 |
sigma | double | 高斯 sigma(控制模糊强度) | 典型 1.0 ~ 2.0 |
amount | float | 锐化强度 | 典型 0.5 ~ 2.0(1.0 = 原强度) |
NEON 版:acl::neon::filter::unsharpMask(仅 uint8_t)
cpp
int unsharpMask(
const uint8_t* srcImage, uint8_t* dstImage,
int width, int height,
int srcStride, int dstStride,
int kRadius, double sigma, float amount);示例
cpp
uint8_t srcImage[1920*1080], dstImage[1920*1080];
// 轻度锐化(radius=2, sigma=1.5, amount=1.2)
acl::filter::unsharpMask<uint8_t>(
srcImage, dstImage, 1920, 1080, 0, 0, 2, 1.5, 1.2f);gaborFilter
Gabor 滤波 — 用于纹理分析和方向敏感边缘检测的正弦 × 高斯调制核。
Tier: Pro+
通道: 1ch
Inplace: 不支持
类型:
| 模板参数 | 允许类型 | 约束 |
|---|---|---|
T | uint8_t, uint16_t, float | — |
CPP 版:acl::filter::gaborFilter
cpp
template<class T>
int gaborFilter(
const T* srcImage, T* dstImage,
int width, int height,
int srcStride, int dstStride,
int ksize, double sigma, double theta,
double lambd, double gamma, double psi);NEON 版:acl::neon::filter::gaborFilter(仅 uint8_t)
cpp
int gaborFilter(
const uint8_t* srcImage, uint8_t* dstImage,
int width, int height,
int srcStride, int dstStride,
int ksize, double sigma, double theta,
double lambd, double gamma, double psi);| 参数 | 类型 | 含义 | 典型值 |
|---|---|---|---|
srcImage, dstImage | const T* / T* (NEON: uint8_t*) | 输入 / 输出 | 非空 |
width, height | int | 图像尺寸 | > 0 |
srcStride, dstStride | int | 每行字节数 | 必填 |
ksize | int | 核大小(通常奇数) | 21 / 31 |
sigma | double | 高斯包络 sigma | 4.0-8.0 |
theta | double | 方向(弧度) | 0(水平)~ π |
lambd | double | 正弦波波长 | 10.0 |
gamma | double | 空间纵横比 | 0.5 |
psi | double | 相位偏移 | 0 |
示例
cpp
uint8_t srcImage[1920*1080], dstImage[1920*1080];
// 水平方向 Gabor 核
acl::neon::filter::gaborFilter(srcImage, dstImage, 1920, 1080, 0, 0,
21, 4.0, 0.0, 10.0, 0.5, 0.0);edgePreservingFilter / detailEnhance
保边滤波 — 基于递归域变换(Gastal & Oliveira, SIGGRAPH 2011)的 O(N) 保边平滑。edgePreservingFilter 保持边缘的同时平滑;detailEnhance 反向使用以增强细节。
Tier: Business
通道: 3ch(RGB)
Inplace: 不支持
类型:
| 模板参数 | 允许类型 | 约束 |
|---|---|---|
T | uint8_t | — |
CPP 签名
cpp
int edgePreservingFilter(
const uint8_t* srcImage, uint8_t* dstImage,
int width, int height,
int srcStride = 0, int dstStride = 0,
float sigmaS = 60.0f, float sigmaR = 0.4f,
int numIter = 3);
int detailEnhance(
const uint8_t* srcImage, uint8_t* dstImage,
int width, int height,
int srcStride = 0, int dstStride = 0,
float sigmaS = 10.0f, float sigmaR = 0.15f);| 参数 | 类型 | 含义 | 默认 |
|---|---|---|---|
sigmaS | float | 空间 sigma(大 → 平滑范围大) | 60.0(保边) / 10.0(细节) |
sigmaR | float | 颜色值 sigma | 0.4 / 0.15 |
numIter | int | 迭代次数(保边) | 3 |
示例
cpp
uint8_t srcImage[1920*1080*3], dstImage[1920*1080*3];
// 卡通化效果
acl::filter::edgePreservingFilter(srcImage, dstImage, 1920, 1080, 0, 0, 60.0f, 0.4f, 3);
// 细节增强
acl::filter::detailEnhance(srcImage, dstImage, 1920, 1080);tonemap
HDR 色调映射 — 把 float HDR 图像压到 uint8_t LDR 显示空间。提供 3 种经典算法。
Tier: Business
通道: 1ch / 3ch
Inplace: 不支持
类型:
| 模板参数 | 允许类型 | 约束 |
|---|---|---|
| 输入 | float | — |
| 输出 | uint8_t | — |
CPP 签名
cpp
// 线性曝光(简单 gamma)
int tonemapLinear(
const float* srcImage, uint8_t* dstImage,
int width, int height,
int srcStride = 0, int dstStride = 0,
float gamma = 2.2f, float exposure = 1.0f);
// Reinhard(全局 key 控制)
int tonemapReinhard(
const float* srcImage, uint8_t* dstImage,
int width, int height,
int srcStride = 0, int dstStride = 0,
float gamma = 2.2f,
float key = 0.18f,
float lWhite = 0.0f);
// Drago(对数映射,适合高动态范围)
int tonemapDrago(
const float* srcImage, uint8_t* dstImage,
int width, int height,
int srcStride = 0, int dstStride = 0,
float gamma = 2.2f,
float saturation = 1.0f,
float bias = 0.85f);| 参数 | 含义 | 典型值 |
|---|---|---|
gamma | 输出 gamma 校正 | 2.2 |
exposure(Linear) | 曝光倍数 | 1.0 |
key(Reinhard) | 平均亮度 key | 0.18 |
lWhite(Reinhard) | 白点(0 = 自动取 max) | 0.0 |
saturation(Drago) | 饱和度 | 1.0 |
bias(Drago) | 偏置 | 0.85 |
示例
cpp
float srcImage[1920*1080];
uint8_t dstImage[1920*1080];
// 最简单:线性 + gamma
acl::filter::tonemapLinear(srcImage, dstImage, 1920, 1080);
// 场景过亮时用 Reinhard
acl::filter::tonemapReinhard(srcImage, dstImage, 1920, 1080, 0, 0, 2.2f, 0.18f);mergeMertens
多曝光图像融合(Mertens et al. 2007)— 把多张不同曝光的图像融合成一张均衡曝光的输出。替代 HDR + tonemap 的更简流程。
Tier: Business
通道: 3ch(RGB)
Inplace: 不支持
类型:
| 模板参数 | 允许类型 | 约束 |
|---|---|---|
T | uint8_t | — |
CPP 签名
cpp
int mergeMertens(
const uint8_t** images, int numImages,
uint8_t* dstImage,
int width, int height,
const int* strides = nullptr,
int dstStride = 0,
float wContrast = 1.0f,
float wSaturation = 1.0f,
float wExposure = 1.0f);| 参数 | 含义 | 典型值 |
|---|---|---|
images | 输入图像指针数组(3ch RGB) | numImages 张 |
numImages | 输入图像数 | 通常 3(欠曝 / 正常 / 过曝) |
strides | 各图像 stride 数组;nullptr 时均按 width*3 | 可选 |
wContrast | 对比度权重 | 1.0 |
wSaturation | 饱和度权重 | 1.0 |
wExposure | 曝光质量权重 | 1.0 |
示例
cpp
uint8_t under[1920*1080*3], normal[1920*1080*3], over[1920*1080*3];
uint8_t dstImage[1920*1080*3];
const uint8_t* imgs[3] = { under, normal, over };
acl::filter::mergeMertens(imgs, 3, dstImage, 1920, 1080);Geometric
Namespace: acl::geometric (CPP) / acl::neon::geometric (NEON)
resize
图像缩放,支持 4 种插值模式(NEAREST / LINEAR2D / CUBIC4x4 / AREA_AVG)。
Tier: Starter+
通道: 1ch / 3ch / 4ch(运行时 hcn / cn 指定)
Inplace: 仅当 srcWidth == dstWidth && srcHeight == dstHeight 时支持(退化为拷贝/裁剪场景)
类型:
| 模板参数 | 允许类型 | 约束 |
|---|---|---|
T | uint8_t, uint16_t, float | — |
CPP 版:acl::geometric::resize
cpp
template<class T, class OT = float>
int resize(
const T* srcImage, T* dstImage,
int srcWidth, int srcHeight,
int dstWidth, int dstHeight,
int srcStride = 0, int dstStride = 0,
int hcn = 1, int vcn = 1,
acl::InterpMode im = acl::InterpMode::LINEAR2D);| 参数 | 类型 | 含义 | 默认 |
|---|---|---|---|
srcImage, dstImage | const T* / T* | 输入 / 输出 | 非空 |
srcWidth, srcHeight | int | 源图尺寸 | > 0 |
dstWidth, dstHeight | int | 目标图尺寸 | > 0 |
srcStride, dstStride | int | 每行字节数 | 0 = 自动 |
hcn | int | 水平通道数(灰度 1 / Bayer 2 / RGB 3 / RGBA 4) | 1 |
vcn | int | 垂直通道数 | 1 |
im | acl::InterpMode | NEAREST / LINEAR2D(默认) / CUBIC4x4 / AREA_AVG | LINEAR2D |
模板参数:
T— 输入 / 输出元素类型OT— 插值中间类型(float默认,double高精度)
NEON 版:acl::neon::geometric::resize(uint8_t / uint16_t)
cpp
template<class T>
int resize(
const T* srcImage, T* dstImage,
int srcWidth, int srcHeight,
int dstWidth, int dstHeight,
int srcStride = 0, int dstStride = 0,
acl::InterpMode im = acl::InterpMode::LINEAR2D,
int cn = 1,
int shiftRight = 0);参数:
T—uint8_t/uint16_tim— 同 CPP 版cn— 通道数(1 / 3 / 4)shiftRight— P010 格式时数据右移位数(10-bit in 16-bit 高位时设置)
示例
cpp
uint8_t srcImage[1920*1080], dstImage[960*540];
// NEON LINEAR2D 1ch 缩小 2 倍
acl::neon::geometric::resize<uint8_t>(
srcImage, dstImage, 1920, 1080, 960, 540);
// CPP LINEAR2D 3ch 放大
uint8_t rgbSrc[640*480*3], rgbDst[1280*960*3];
acl::geometric::resize<uint8_t>(
rgbSrc, rgbDst, 640, 480, 1280, 960,
/*srcStride=*/0, /*dstStride=*/0,
/*hcn=*/3, /*vcn=*/1,
acl::InterpMode::LINEAR2D);
// float CUBIC4x4(仅 CPP)
float fSrc[640*480], fDst[1280*960];
acl::geometric::resize<float>(
fSrc, fDst, 640, 480, 1280, 960,
0, 0, 1, 1, acl::InterpMode::CUBIC4x4);rotate
图像旋转 / 翻转 / 转置。支持 ROT_0 / ROT_180 / ROT_CW_90 / ROT_CCW_90 / FLIP_H / FLIP_V / XPOSE。
Tier: Starter+
通道: 1ch / 3ch / 4ch
Inplace: 支持 ROT_180 / FLIP_H / FLIP_V(srcImage == dstImage)
类型:
| 模板参数 | 允许类型 | 约束 |
|---|---|---|
T (CPP) | {uint8_t, uint16_t, float} | — |
T (NEON) | uint8_t | 仅 NEON |
通道 / 类型支持矩阵
| 入口 | 通道 | 类型 |
|---|---|---|
CPP rotate<T> | 任意(通过 runtime blockW / blockH 打包) | T 任意(uint8_t / uint16_t / float / …) |
NEON rotate<T> | 仅 1ch | 仅 uint8_t |
NEON rotateNV | NV21 / NV12(Y + UV) | uint8_t |
NEON rotateYV12 | YV12 / I420(Y + U + V) | uint8_t |
NEON rotateYUV444 | YUV444(3ch 交织) | uint8_t |
RGB / RGBA 旋转的推荐方案:
- NEON 加速路径:没有直接的 RGB NEON rotate 入口,但纯旋转本质是内存搬运,CPP 版本的
blockW=3/4路径已用 memcpy + 内联读写,对 RGB/RGBA 来说性能等价。- 多通道请用 CPP
rotate<uint8_t>配合blockW=3(RGB)或blockW=4(RGBA);见下方示例。
CPP 版:acl::geometric::rotate
cpp
template<class T>
int rotate(
const T* srcImage, T* dstImage,
int srcWidth, int srcHeight,
int dstWidth, int dstHeight,
int srcStride = 0, int dstStride = 0,
acl::RotateOrient ori = acl::RotateOrient::ROT_CW_90,
int blockW = 1, int blockH = 1);| 参数 | 类型 | 含义 | 默认 |
|---|---|---|---|
srcImage, dstImage | const T* / T* | 输入 / 输出 | 非空 |
srcWidth, srcHeight | int | 源图尺寸,以像素块数(非像素)计 | 必须 blockW/H 整除 |
dstWidth, dstHeight | int | 目标尺寸,同上 | 同上 |
srcStride, dstStride | int | 每行字节数 | 0 = 自动 |
ori | acl::RotateOrient | 旋转方向 | ROT_CW_90 |
blockW, blockH | int | 像素块尺寸(单元)。1,1 处理单通道标量;blockW=3 打包 RGB 一个像素作为一个不可分的单元;blockW=4 打包 RGBA。 | 1, 1 |
注意
srcWidth/dstWidth传的是块数:灰度图 1920 宽 →srcWidth=1920;RGB 1920 宽 →srcWidth=1920(块数仍是 1920,不是 5760)、blockW=3。
NEON 版:acl::neon::geometric::rotate(仅 uint8_t,1ch)
cpp
template<class T>
int rotate(
const T* srcImage, T* dstImage,
int srcW, int srcH,
int srcStride = 0, int dstStride = 0,
acl::RotateOrient ori = acl::RotateOrient::ROT_CW_90);签名略有差异:无
dstWidth/dstHeight,输出尺寸由ori推导(CW/CCW/XPOSE → 宽高互换,其他 → 保持)。
示例
cpp
// 1) 1ch u8 走 NEON
uint8_t srcImage[1920*1080], dstImage[1080*1920];
acl::neon::geometric::rotate<uint8_t>(
srcImage, dstImage, 1920, 1080,
/*srcStride=*/0, /*dstStride=*/0,
acl::RotateOrient::ROT_CW_90);
// 2) RGB(3ch)走 CPP,blockW=3 打包像素
uint8_t srcImageRGB[1920*1080*3], dstImageRGB[1080*1920*3];
acl::geometric::rotate<uint8_t>(
srcImageRGB, dstImageRGB,
/*srcWidth=*/1920, /*srcHeight=*/1080, // 块数,不是 1920*3
/*dstWidth=*/1080, /*dstHeight=*/1920,
/*srcStride=*/1920*3, /*dstStride=*/1080*3,
acl::RotateOrient::ROT_CW_90,
/*blockW=*/3, /*blockH=*/1);
// 3) float 1ch 180° in-place
float img[512*512];
acl::geometric::rotate<float>(
img, img, 512, 512, 512, 512,
0, 0,
acl::RotateOrient::ROT_180);
// 4) YUV NV21 旋转走专用 NEON 入口(见 "YUV rotate" 节)pyrDown
2 倍下采样(高斯金字塔向下):先 5×5 高斯平滑再 2×2 下采样。
Tier: Starter+
通道: 1ch / 3ch
Inplace: 不支持
类型:
| 模板参数 | 允许类型 | 约束 |
|---|---|---|
T | uint8_t, uint16_t, float | — |
CPP 版:acl::geometric::pyrDown
cpp
template<class T>
int pyrDown(
const T* srcImage, T* dstImage,
int srcWidth, int srcHeight, int cn,
int srcStride = 0, int dstStride = 0,
int dstWidth = 0, int dstHeight = 0,
const T* constant = nullptr,
acl::BorderType bt = acl::BorderType::BORDER_REFLECT_101);| 参数 | 类型 | 含义 | 默认 |
|---|---|---|---|
srcImage, dstImage | const T* / T* | 输入 / 输出 | 非空 |
srcWidth, srcHeight | int | 源图尺寸 | ≥ 2 |
cn | int | 通道数 | 1 或 3 |
srcStride, dstStride | int | 每行字节数 | 0 = 自动 |
dstWidth, dstHeight | int | 目标尺寸(0 时取 (src+1)/2) | OpenCV 兼容:|dstW*2 - srcW| ≤ 2 |
constant | const T* | BORDER_CONSTANT 填充值 | nullptr |
bt | acl::BorderType | 边界处理模式 | BORDER_REFLECT_101 |
NEON 版:acl::neon::geometric::pyrDown(仅 uint8_t)
cpp
template<class T>
int pyrDown(...) // 签名与 CPP 版完全一致类型固定
uint8_t,参数语义与 CPP 版相同。
pyrUp
2 倍上采样(高斯金字塔向上):插值放大后 5×5 高斯平滑。
Tier: Starter+
通道: 1ch / 3ch
Inplace: 不支持
类型:
| 模板参数 | 允许类型 | 约束 |
|---|---|---|
T (CPP) | uint8_t(目前仅支持 uint8_t) | — |
T (NEON) | uint8_t | 仅 NEON |
CPP / NEON 签名(一致)
cpp
template<class T>
int pyrUp(
const T* srcImage, T* dstImage,
int srcWidth, int srcHeight, int cn,
int srcStride = 0, int dstStride = 0,
int dstWidth = 0, int dstHeight = 0,
const T* constant = nullptr,
acl::BorderType bt = acl::BorderType::BORDER_REFLECT_101);参数语义与 pyrDown 相同,默认输出 srcWidth*2 × srcHeight*2。
buildPyramid
构建多层高斯金字塔(连续 pyrDown 累积)。pyramid[0] = pyrDown(srcImage),pyramid[1] = pyrDown(pyramid[0]),……
Tier: Starter+
通道: 1ch / 3ch
Inplace: 不支持
类型:
| 模板参数 | 允许类型 | 约束 |
|---|---|---|
T (CPP) | uint8_t(目前仅支持 uint8_t) | — |
T (NEON) | uint8_t | 仅 NEON |
CPP / NEON 签名(一致)
cpp
template<class T>
int buildPyramid(
const T* srcImage,
T** pyramid,
int* widths, int* heights,
int srcWidth, int srcHeight,
int cn, int numLevels,
int srcStride = 0,
acl::BorderType bt = acl::BorderType::BORDER_REFLECT_101);| 参数 | 类型 | 含义 | 默认 |
|---|---|---|---|
srcImage | const T* | 输入图(level 0) | 非空 |
pyramid | T** | 输出指针数组(numLevels 个,调用方预分配) | 非空 |
widths, heights | int* | 输出各层尺寸 | 非空 |
srcWidth, srcHeight | int | 源图尺寸 | ≥ 2 |
cn | int | 通道数 | 1 或 3 |
numLevels | int | 层数 | ≥ 1 |
srcStride | int | 源图每行字节数 | 0 = 自动 |
bt | acl::BorderType | 边界处理模式 | BORDER_REFLECT_101 |
示例
cpp
uint8_t srcImage[1920*1080];
uint8_t l0[960*540], l1[480*270], l2[240*135];
uint8_t* pyr[3] = { l0, l1, l2 };
int widths[3], heights[3];
acl::neon::geometric::buildPyramid<uint8_t>(
srcImage, pyr, widths, heights, 1920, 1080, 1, 3);YUV resize(NV21 / NV12 / YV12 / YUV444)
YUV 原生缩放,避免 YUV ↔ RGB 转换。每个通道独立缩放(NV 平面 split → resize → merge 避免 U/V 混色)。
Tier: Starter+
通道: Y 平面(1ch)+ UV 平面(交错或分平面)
Inplace: 不支持
类型:
| 模板参数 | 允许类型 | 约束 |
|---|---|---|
T | uint8_t | — |
NEON 签名
cpp
// NV21 / NV12 — Y 全分辨率,UV 平面 1/4 分辨率
int resizeNV(
const uint8_t* srcYImage, const uint8_t* srcUVImage,
uint8_t* dstYImage, uint8_t* dstUVImage,
int srcW, int srcH, int dstW, int dstH,
int srcYStride = 0, int srcUVStride = 0,
int dstYStride = 0, int dstUVStride = 0,
bool nv21Fmt = true);
// YV12 / I420 — Y 全分辨率,U / V 各自 1/4 分辨率
int resizeYV12(
const uint8_t* srcYImage, const uint8_t* srcUImage, const uint8_t* srcVImage,
uint8_t* dstYImage, uint8_t* dstUImage, uint8_t* dstVImage,
int srcW, int srcH, int dstW, int dstH,
int srcYStride = 0, int srcUVStride = 0,
int dstYStride = 0, int dstUVStride = 0);
// YUV444 — 3 通道交织,无子采样
int resizeYUV444(
const uint8_t* srcImage, uint8_t* dstImage,
int srcW, int srcH, int dstW, int dstH,
int srcStride = 0, int dstStride = 0);
nv21Fmt = true→ NV21(V/U 顺序);false→ NV12(U/V 顺序)。
NV / YV12 要求输入尺寸偶数。
YUV rotate(NV21 / NV12 / YV12 / YUV444)
YUV 原生旋转,避免 YUV ↔ RGB 转换。
Tier: Starter+
通道: Y 平面(1ch)+ UV 平面(交错或分平面)
Inplace: 支持 ROT_180 / FLIP_H / FLIP_V
类型:
| 模板参数 | 允许类型 | 约束 |
|---|---|---|
T | uint8_t | — |
NEON 签名
cpp
// NV21 / NV12
int rotateNV(
const uint8_t* srcYImage, const uint8_t* srcUVImage,
uint8_t* dstYImage, uint8_t* dstUVImage,
int srcW, int srcH,
int* dstW = nullptr, int* dstH = nullptr,
acl::RotateOrient ori = acl::RotateOrient::ROT_CW_90,
bool nv21Fmt = true);
// YV12
int rotateYV12(
const uint8_t* srcYImage, const uint8_t* srcUImage, const uint8_t* srcVImage,
uint8_t* dstYImage, uint8_t* dstUImage, uint8_t* dstVImage,
int srcW, int srcH,
int* dstW = nullptr, int* dstH = nullptr,
acl::RotateOrient ori = acl::RotateOrient::ROT_CW_90);
// YUV444(单平面交织)
int rotateYUV444(
const uint8_t* srcImage, uint8_t* dstImage,
int srcW, int srcH,
int* dstW = nullptr, int* dstH = nullptr,
acl::RotateOrient ori = acl::RotateOrient::ROT_CW_90);
dstW/dstH是可选的输出参数 — 调用方传入指针,函数填入旋转后目标尺寸(ROT_CW_90/ROT_CCW_90/XPOSE时为宽高互换)。不需要可传nullptr。
示例
cpp
uint8_t srcY[1920*1280], srcUV[1920*640*2];
uint8_t dstY[1280*1920], dstUV[1280*640*2];
// NV21 顺时针 90°
int dstW = 0, dstH = 0;
acl::neon::geometric::rotateNV(
srcY, srcUV, dstY, dstUV, 1920, 1280,
&dstW, &dstH,
acl::RotateOrient::ROT_CW_90,
/*nv21Fmt=*/true);
// dstW == 1280, dstH == 1920Feature Detection
Namespace: acl::feature (CPP) / acl::neon::feature (NEON)
通用数据结构(acl:: 命名空间下):
cpp
struct KeyPoint { int x, y; float response; };
struct KeyPointORB { float x, y, response, scale, angle; uint8_t descriptor[32]; };
struct KeyPointExt { float x, y, response, scale, angle; float descriptor[128]; };
struct Point2f { float x, y; };
struct DMatch { int queryIdx, trainIdx; float distance; };
struct Vec2f { float val[2]; }; // (rho, theta)
struct Vec3f { float val[3]; }; // (cx, cy, radius)
struct Vec4i { int val[4]; }; // (x1, y1, x2, y2)FAST Corner Detection
FAST 角点检测(Bresenham 16 像素圆圈比较)。
Tier: Pro+
通道: 1ch
Inplace: not supported
类型:
| 模板参数 | 允许类型 | 约束 |
|---|---|---|
T | uint8_t | — |
CPP / NEON 签名(一致)
cpp
int fastCornerDetect(
const uint8_t* srcImage, int width, int height, int srcStride,
std::vector<KeyPoint>& keypoints,
int threshold = 20,
bool nonmaxSuppress = true,
int type = 9);| 参数 | 类型 | 含义 | 默认 |
|---|---|---|---|
srcImage | const uint8_t* | 输入灰度图 | 非空 |
srcStride | int | 每行字节数 | 0 = width |
keypoints | vector<KeyPoint>& | 输出角点 | — |
threshold | int | 灰度差阈值 | 20 |
nonmaxSuppress | bool | 是否做 NMS | true |
type | int | FAST-N(9 或 12,N 为连续像素数) | 9 |
Harris Corner Detection
Harris 角点检测。响应 R = det(M) - k * trace(M)^2,其中 M 为结构张量。
Tier: Pro+
通道: 1ch
Inplace: not supported
类型:
| 模板参数 | 允许类型 | 约束 |
|---|---|---|
T | uint8_t | — |
CPP / NEON 签名(一致)
cpp
// 检测角点(含 NMS)
int harrisCornerDetect(
const uint8_t* srcImage, int width, int height, int srcStride,
std::vector<KeyPoint>& keypoints,
int blockSize = 2,
float k = 0.04f,
float threshold = 1e6f);
// 仅输出 Harris 响应图(用户自己做阈值 / NMS)— CPP only
int harrisResponse(
const uint8_t* srcImage, float* dstImage,
int width, int height, int srcStride,
int blockSize = 2, float k = 0.04f);| 参数 | 类型 | 含义 | 默认 |
|---|---|---|---|
blockSize | int | 结构张量邻域半径 | 2 |
k | float | Harris 自由参数 | 0.04 |
threshold | float | 最小响应阈值 | 1e6 |
Shi-Tomasi Corner Detection
Shi-Tomasi 角点(Good Features to Track):响应 = min(λ1, λ2)(结构张量特征值)。
Tier: Pro+
通道: 1ch
Inplace: not supported
类型:
| 模板参数 | 允许类型 | 约束 |
|---|---|---|
T | uint8_t | — |
CPP / NEON 签名(一致)
cpp
int shiTomasiCornerDetect(
const uint8_t* srcImage, int width, int height, int srcStride,
std::vector<KeyPoint>& keypoints,
int maxCorners = 500,
float qualityLevel = 0.01f,
float minDistance = 10.0f,
int blockSize = 2);
// 别名(语义同 shiTomasiCornerDetect)
int shiTomasiDetect(
const uint8_t* srcImage, int width, int height, int srcStride,
std::vector<KeyPoint>& corners,
int maxCorners = 500,
float qualityLevel = 0.01f,
float minDistance = 10.0f,
int blockSize = 2);
// 仅输出最小特征值响应图 — CPP only
int minEigenValResponse(
const uint8_t* srcImage, float* dstImage,
int width, int height, int srcStride,
int blockSize = 2);| 参数 | 类型 | 含义 | 默认 |
|---|---|---|---|
maxCorners | int | 返回角点数量上限(0 = 无限制) | 500 |
qualityLevel | float | 相对最强响应的最低质量比 | 0.01 |
minDistance | float | 相邻角点最小 Euclidean 距离 | 10.0 |
blockSize | int | 结构张量邻域半径 | 2 |
ORB(Oriented FAST and Rotated BRIEF)
ORB 检测 + 256-bit rBRIEF 描述子。
Tier: Pro+
通道: 1ch
Inplace: not supported
类型:
| 模板参数 | 允许类型 | 约束 |
|---|---|---|
T | uint8_t | — |
CPP / NEON 签名(一致)
cpp
// 检测 + 计算描述子
int orbDetectAndCompute(
const uint8_t* srcImage, int width, int height, int srcStride,
std::vector<KeyPointORB>& keypoints,
int maxKeypoints = 500,
float scaleFactor = 1.2f,
int nLevels = 8,
int fastThreshold = 20);
// 仅检测(丢弃描述子,输出 KeyPoint)
int orbDetect(
const uint8_t* srcImage, int width, int height, int srcStride,
std::vector<KeyPoint>& keypoints,
int maxKeypoints = 500,
float scaleFactor = 1.2f,
int nLevels = 8,
int fastThreshold = 20);
// 两个 256-bit 描述子之间的 Hamming 距离(0-256)
int orbHammingDistance(const uint8_t desc1[32], const uint8_t desc2[32]);| 参数 | 类型 | 含义 | 默认 |
|---|---|---|---|
maxKeypoints | int | 目标关键点数量 | 500 |
scaleFactor | float | 金字塔层间缩放比(> 1.0) | 1.2 |
nLevels | int | 金字塔层数 | 8 |
fastThreshold | int | FAST 内部阈值 | 20 |
srcWidth / srcHeight需 ≥32。
SIFT(Scale-Invariant Feature Transform)
SIFT 尺度不变特征 + 128-D 描述子。
Tier: Business
通道: 1ch
Inplace: not supported
类型:
| 模板参数 | 允许类型 | 约束 |
|---|---|---|
T | uint8_t | — |
CPP / NEON 签名(一致)
cpp
int siftDetectAndCompute(
const uint8_t* srcImage, int width, int height, int srcStride,
std::vector<KeyPointExt>& keypoints,
int nOctaves = 0,
int nScalesPerOctave = 3,
float contrastThresh = 0.04f,
float edgeThresh = 10.0f,
float sigma = 1.6f);
// 仅检测
int siftDetect(
const uint8_t* srcImage, int width, int height, int srcStride,
std::vector<KeyPoint>& keypoints,
int nOctaves = 0, int nScalesPerOctave = 3,
float contrastThresh = 0.04f, float edgeThresh = 10.0f,
float sigma = 1.6f);| 参数 | 类型 | 含义 | 默认 |
|---|---|---|---|
nOctaves | int | 金字塔 octave 数(0 = 自动 log2(min(w,h)) - 2) | 0 |
nScalesPerOctave | int | 每 octave 的尺度数 | 3 |
contrastThresh | float | DoG 极值对比度阈值 | 0.04 |
edgeThresh | float | 边缘响应剔除阈值 | 10.0 |
sigma | float | 初始高斯 sigma | 1.6 |
srcWidth / srcHeight需 ≥16。
SURF(Speeded-Up Robust Features)
SURF 加速特征。积分图 + Hessian 行列式,输出 128-D 描述子(keypoints.descriptor 的前 64 维被使用)。
Tier: Business
通道: 1ch
Inplace: not supported
类型:
| 模板参数 | 允许类型 | 约束 |
|---|---|---|
T | uint8_t | — |
CPP / NEON 签名(一致)
cpp
int surfDetectAndCompute(
const uint8_t* srcImage, int width, int height, int srcStride,
std::vector<KeyPointExt>& keypoints,
float hessianThresh = 100.0f,
int nOctaves = 4,
int nOctaveLayers = 3);
// 仅检测
int surfDetect(
const uint8_t* srcImage, int width, int height, int srcStride,
std::vector<KeyPoint>& keypoints,
float hessianThresh = 100.0f,
int nOctaves = 4, int nOctaveLayers = 3);
srcWidth / srcHeight需 ≥24。
HOG(Histogram of Oriented Gradients)
HOG 描述子 — 梯度方向直方图,常用于行人检测、分类特征。
Tier: Pro+
通道: 1ch
Inplace: not supported
类型:
| 模板参数 | 允许类型 | 约束 |
|---|---|---|
T | uint8_t | — |
CPP / NEON 签名(一致)
cpp
struct HOGParams {
int cellSize; // 默认 8
int blockSize; // 默认 2(block = blockSize × blockSize cells)
int nbins; // 默认 9
int blockStride; // 默认 1(以 cell 为单位)
};
int computeHOG(
const uint8_t* srcImage, int width, int height, int srcStride,
float* descriptors, int& descriptorSize,
const HOGParams& params = HOGParams());| 参数 | 类型 | 含义 | 默认 |
|---|---|---|---|
descriptors | float* | 输出描述子数组(调用方预分配) | 非空 |
descriptorSize | int& | 返回实际写入的 float 数 | — |
params | const HOGParams& | HOG 参数 | 默认构造 |
输出尺寸 =
blocksX * blocksY * (blockSize * blockSize * nbins)。调用前可用默认参数先估算或调用一次读取descriptorSize。
houghLines / houghLinesP
标准 Hough 直线检测(houghLines 输出 (rho, theta))与概率 Hough(houghLinesP 输出线段端点)。
Tier: Pro+
通道: 1ch 二值边缘图(通常由 canny 输出)
Inplace: not supported
类型:
| 模板参数 | 允许类型 | 约束 |
|---|---|---|
T | uint8_t | — |
CPP / NEON 签名(一致)
cpp
// 标准 Hough
int houghLines(
const uint8_t* edgeImage, int width, int height, int stride,
std::vector<acl::Vec2f>& lines,
float rho,
float theta,
int threshold);
// 概率 Hough(返回线段)
int houghLinesP(
const uint8_t* edgeImage, int width, int height, int stride,
std::vector<acl::Vec4i>& lines,
float rho,
float theta,
int threshold,
double minLineLength,
double maxLineGap);| 参数 | 类型 | 含义 | 推荐值 |
|---|---|---|---|
edgeImage | const uint8_t* | 输入二值边缘图(非零视为边缘) | 非空 |
rho | float | 距离分辨率(像素) | 1.0 |
theta | float | 角度分辨率(弧度) | M_PI/180 |
threshold | int | 累加器投票数阈值 | 标准 100 / 概率 50 |
minLineLength | double | (仅概率版)最短线段长度 | 0 |
maxLineGap | double | (仅概率版)同一直线上两点最大间隔 | 10 |
输出:
houghLines→Vec2f(rho, theta)houghLinesP→Vec4i(x1, y1, x2, y2)
houghCircles
Hough 圆形检测(21HT 梯度法)。
Tier: Pro+
通道: 1ch 灰度图(内部自动做 Canny + 梯度,无需预先二值化)
Inplace: not supported
类型:
| 模板参数 | 允许类型 | 约束 |
|---|---|---|
T | uint8_t | — |
CPP / NEON 签名(一致)
cpp
int houghCircles(
const uint8_t* grayImage, int width, int height, int stride,
std::vector<acl::Vec3f>& circles,
float dp = 1.0f,
float minDist = 20.0f,
float param1 = 100.0f,
float param2 = 100.0f,
int minRadius = 0,
int maxRadius = 0);| 参数 | 类型 | 含义 | 默认 |
|---|---|---|---|
grayImage | const uint8_t* | 输入灰度图 | 非空 |
circles | vector<Vec3f>& | 输出圆 (cx, cy, radius) | — |
dp | float | 累加器 / 图像分辨率比 | 1.0 |
minDist | float | 相邻圆心最小距离 | 20.0 |
param1 | float | Canny 上阈值(下阈值自动 = param1 / 2) | 100.0 |
param2 | float | 圆心检测累加器阈值 | 100.0 |
minRadius | int | 最小半径 | 0 |
maxRadius | int | 最大半径(0 = max(width, height)) | 0 |
opticalFlowLK
稀疏金字塔 Lucas-Kanade 光流。
Tier: Pro+
通道: 1ch
Inplace: not supported
类型:
| 模板参数 | 允许类型 | 约束 |
|---|---|---|
T | uint8_t | — |
CPP / NEON 签名(一致)
cpp
int opticalFlowLK(
const uint8_t* prevImg, const uint8_t* nextImg,
int width, int height, int stride,
const acl::Point2f* prevPts, acl::Point2f* nextPts,
uint8_t* status, float* error,
int numPoints,
int winSize = 21,
int maxLevel = 3,
int maxIter = 30,
float epsilon = 0.01f);| 参数 | 类型 | 含义 | 默认 |
|---|---|---|---|
prevImg, nextImg | const uint8_t* | 前 / 后帧 | 非空 |
prevPts | const Point2f* | 前帧待跟踪的点 | 非空 |
nextPts | Point2f* | 后帧跟踪到的点(调用方预分配 numPoints) | 非空 |
status | uint8_t* | 每点状态(1 = 跟踪成功,0 = 丢失;预分配 numPoints) | 非空 |
error | float* | 每点跟踪误差(可 nullptr;非 null 时预分配 numPoints) | 可空 |
numPoints | int | 跟踪点数 | — |
winSize | int | 搜索窗口大小 | 21 |
maxLevel | int | 最大金字塔层级 | 3 |
maxIter | int | 每层最大迭代数 | 30 |
epsilon | float | 收敛阈值 | 0.01 |
descriptorMatch(bfMatch / bfMatchBinary / bfKnnMatch / bfKnnMatchBinary)
暴力描述子匹配:bfMatch* 每个 query 返回 1 个最近邻;bfKnn* 返回 K 个最近邻。float 版用 L2 距离,Binary 版用 Hamming 距离。
Tier: Pro+
通道: N/A(描述子向量)
Inplace: not supported
类型:
| 模板参数 | 允许类型 | 约束 |
|---|---|---|
T | uint8_t | 二进制描述子(如 ORB) |
T | float | 浮点描述子(如 SIFT/SURF) |
CPP / NEON 签名(一致)
cpp
// float 描述子,L2 距离,1-NN
int bfMatch(
const float* queryDescs, int queryCount, int descDim,
const float* trainDescs, int trainCount,
std::vector<acl::DMatch>& matches);
// 二进制描述子(如 ORB),Hamming 距离,1-NN
int bfMatchBinary(
const uint8_t* queryDescs, int queryCount, int descBytes,
const uint8_t* trainDescs, int trainCount,
std::vector<acl::DMatch>& matches);
// float 描述子,L2,K-NN
int bfKnnMatch(
const float* queryDescs, int queryCount, int descDim,
const float* trainDescs, int trainCount,
std::vector<std::vector<acl::DMatch>>& matches,
int k = 2);
// 二进制描述子,Hamming,K-NN
int bfKnnMatchBinary(
const uint8_t* queryDescs, int queryCount, int descBytes,
const uint8_t* trainDescs, int trainCount,
std::vector<std::vector<acl::DMatch>>& matches,
int k = 2);| 参数 | 类型 | 含义 |
|---|---|---|
queryDescs, trainDescs | const float* / const uint8_t* | 行主序描述子,长度 Count × (descDim 或 descBytes) |
descDim | int | float 描述子维度(SIFT 128, SURF 实现使用 64) |
descBytes | int | 二进制描述子字节数(ORB 32) |
matches | vector<DMatch>& 或 vector<vector<DMatch>>& | 输出匹配,每个 DMatch 含 queryIdx, trainIdx, distance |
k | int | K-NN 的 K(实际返回 min(k, trainCount) 个) |
示例
cpp
uint8_t srcImage[1920*1080];
std::vector<acl::KeyPointORB> kps;
// 1) ORB 检测 + 描述
acl::neon::feature::orbDetectAndCompute(
srcImage, 1920, 1080, 0, kps);
// 2) 两张图的 ORB 匹配(Binary + Hamming)
std::vector<uint8_t> qDescs(kps.size() * 32), tDescs(/*...*/);
for (size_t i = 0; i < kps.size(); ++i)
memcpy(qDescs.data() + i*32, kps[i].descriptor, 32);
std::vector<acl::DMatch> matches;
acl::neon::feature::bfMatchBinary(
qDescs.data(), (int)kps.size(), 32,
tDescs.data(), /*trainCount=*/200,
matches);Transform
Namespace: acl::transform (CPP) / acl::neon::transform (NEON)
Transform 分两类:
- 矩阵计算(给定点对求变换矩阵):
getRotationMatrix2D/getAffineTransform/getPerspectiveTransform/findHomography - 应用变换(按矩阵重采样图像):
warpAffine/warpPerspective/remap/yuvRemap
getRotationMatrix2D
由绕 (cx, cy) 旋转 + 缩放构造 2×3 仿射矩阵。
Tier: Starter+
通道: N/A(矩阵构造器)
Inplace: not supported
类型:
| 模板参数 | 允许类型 | 约束 |
|---|---|---|
T | double | — |
CPP 签名
cpp
int getRotationMatrix2D(
double cx, double cy,
double angle, double scale,
double* M);| 参数 | 类型 | 含义 | 默认 |
|---|---|---|---|
cx, cy | double | 旋转中心坐标 | — |
angle | double | 旋转角度(度数,逆时针为正) | — |
scale | double | 缩放因子 | — |
M | double* | 输出 2×3 矩阵,行主序,6 个 double | 非空 |
getAffineTransform
由 3 组点对求 2×3 仿射变换矩阵。
Tier: Starter+
通道: N/A(矩阵构造器)
Inplace: not supported
类型:
| 模板参数 | 允许类型 | 约束 |
|---|---|---|
T | double | — |
CPP 签名
cpp
int getAffineTransform(
const double* srcImage, const double* dstImage,
double* M);| 参数 | 类型 | 含义 |
|---|---|---|
srcImage | const double* | 3 个源点 (x0,y0, x1,y1, x2,y2),共 6 个 double(注:此处复用图像入参名,实为点对数组) |
dstImage | const double* | 3 个目标点(同上格式) |
M | double* | 输出 2×3 矩阵,行主序 |
getPerspectiveTransform
由 4 组点对求 3×3 透视变换矩阵。
Tier: Starter+
通道: N/A(矩阵构造器)
Inplace: not supported
类型:
| 模板参数 | 允许类型 | 约束 |
|---|---|---|
T | double | — |
CPP / NEON 签名(一致)
cpp
int getPerspectiveTransform(
const double* srcImage, const double* dstImage,
double* M);| 参数 | 类型 | 含义 |
|---|---|---|
srcImage | const double* | 4 个源点,共 8 个 double(注:此处复用图像入参名,实为点对数组) |
dstImage | const double* | 4 个目标点 |
M | double* | 输出 3×3 矩阵,行主序,9 个 double(最后归一化使 M[8] = 1) |
findHomography
由 N ≥ 4 组点对求 3×3 单应矩阵,支持最小二乘或 RANSAC。
Tier: Pro+
通道: N/A(点集)
Inplace: not supported
类型:
| 模板参数 | 允许类型 | 约束 |
|---|---|---|
T | double | — |
CPP / NEON 签名(一致)
cpp
int findHomography(
const double* srcPts, const double* dstPts,
int numPts, double* H,
int method = 0,
double ransacThreshold = 3.0);| 参数 | 类型 | 含义 | 默认 |
|---|---|---|---|
srcPts | const double* | N 个源点 (x0,y0, x1,y1, …),共 2*N 个 double | 非空 |
dstPts | const double* | N 个目标点 | 非空 |
numPts | int | 点对数量,必须 ≥ 4 | — |
H | double* | 输出 3×3 单应矩阵,行主序,归一化 H[8] = 1 | 非空 |
method | int | 0 = 最小二乘 DLT;1 = RANSAC | 0 |
ransacThreshold | double | RANSAC 内点距离阈值 | 3.0 |
numPts == 4时自动走getPerspectiveTransform(精确解)。
dltHomography
底层 / 算法定制 API。 大多数用户应直接使用
findHomography；只有当你需要直接操作线性 DLT 求解器、并自行处理外点剔除时才用这个。
由 numPts ≥ 4 组点对，通过一次归一化 Direct Linear Transform (DLT) 最小二乘求解 3×3 单应矩阵 — 不带 RANSAC、不做鲁棒过滤。
Tier: Pro+
通道: N/A(点集)
Inplace: not supported
CPP 签名(仅 acl::transform)
该 helper 不声明在 acl::neon::transform 下；NEON package 暴露 findHomography、getPerspectiveTransform、warpAffine 和 warpPerspective，但不暴露 DLT helper。
cpp
int dltHomography(
const double* srcPts, const double* dstPts,
int numPts, double* H);| 参数 | 类型 | 含义 |
|---|---|---|
srcPts | const double* | N 个源点 (x0,y0, x1,y1, …),共 2*N 个 double |
dstPts | const double* | N 个目标点,布局相同 |
numPts | int | 点对数量,必须 ≥ 4 |
H | double* | 输出 3×3 单应矩阵,行主序,归一化 H[8] = 1 |
返回值:成功返回 0,失败(点配置退化、numPts < 4)返回非零。
homographyError
底层 / 算法定制 API。 主要用于在
dltHomography之上自行实现外点剔除或评分循环。
将一个点经单应矩阵投影,返回它与观测对应点的欧氏距离平方 — 即 RANSAC 评分中常用的"单点重投影误差"。
Tier: Pro+
通道: N/A(标量运算)
Inplace: N/A
CPP 签名(仅 acl::transform)
该 helper 不声明在 acl::neon::transform 下；付费 package 中请调用 acl::transform::homographyError。
cpp
double homographyError(
const double* H,
double sx, double sy,
double dx, double dy);| 参数 | 类型 | 含义 |
|---|---|---|
H | const double* | 行主序 3×3 单应矩阵 |
sx, sy | double | 源点坐标 |
dx, dy | double | 观测目标点坐标 |
返回值:H · (sx, sy, 1)(归一到 z=1)与 (dx, dy) 的欧氏距离平方。
warpAffine
对图像应用 2×3 仿射变换。使用逆映射:目标像素 (x', y') 查找源坐标 (x, y) = M * (x', y', 1)^T。
Tier: Starter+
通道: 1ch / 3ch / 4ch(通过运行时 cn 参数指定)
Inplace: 不支持
类型:
| 模板参数 | 允许类型 | 约束 |
|---|---|---|
IMG_T | {uint8_t, uint16_t, float} | — |
MAT_T | {float, double} | — |
CPP / NEON 签名(一致)
cpp
template<class IMG_T, class MAT_T = double>
int warpAffine(
const IMG_T* srcImage, IMG_T* dstImage,
const MAT_T* M,
int srcWidth, int srcHeight,
int dstWidth, int dstHeight,
int srcStride = 0, int dstStride = 0,
acl::InterpMode interpMode = acl::InterpMode::LINEAR2D,
int cn = 1);| 参数 | 类型 | 含义 | 默认 |
|---|---|---|---|
srcImage, dstImage | const IMG_T* / IMG_T* | 输入 / 输出 | 非空 |
M | const MAT_T* | 2×3 仿射矩阵,行主序 | 非空 |
srcWidth, srcHeight | int | 源图尺寸 | > 0 |
dstWidth, dstHeight | int | 目标图尺寸 | > 0 |
srcStride, dstStride | int | 每行字节数 | 0 = 自动 |
interpMode | acl::InterpMode | NEAREST / LINEAR2D | LINEAR2D |
cn | int | 通道数(1 / 3 / 4) | 1 |
warpPerspective
对图像应用 3×3 透视变换。逆映射,齐次坐标除以 w。
Tier: Starter+
通道: 1ch / 3ch / 4ch(通过运行时 cn 参数)
Inplace: 不支持
类型:
| 模板参数 | 允许类型 | 约束 |
|---|---|---|
IMG_T | {uint8_t, uint16_t, float} | — |
MAT_T | {float, double} | — |
CPP / NEON 签名(一致)
cpp
template<class IMG_T, class MAT_T = double>
int warpPerspective(
const IMG_T* srcImage, IMG_T* dstImage,
const MAT_T* M,
int srcWidth, int srcHeight,
int dstWidth, int dstHeight,
int srcStride = 0, int dstStride = 0,
acl::InterpMode interpMode = acl::InterpMode::LINEAR2D,
int cn = 1);运行时参数与 warpAffine 相同,M 是 3×3 矩阵(9 个 MAT_T)。
示例(warpAffine + warpPerspective 链式)
cpp
uint8_t srcImage[1920*1080], dstImage[1920*1080];
// 1) 构造绕图像中心 30° 旋转矩阵
double M_affine[6];
acl::transform::getRotationMatrix2D(960.0, 540.0, 30.0, 1.0, M_affine);
// 2) 应用仿射(NEON 加速,LINEAR2D)
acl::neon::transform::warpAffine<uint8_t, double>(
srcImage, dstImage, M_affine, 1920, 1080, 1920, 1080,
0, 0, acl::InterpMode::LINEAR2D, 1);
// 3) 4 点透视矩阵
double srcPts[8] = { 0,0, 1920,0, 1920,1080, 0,1080 };
double dstPts[8] = { 100,50, 1820,0, 1920,1080, 50,1050 };
double H[9];
acl::transform::getPerspectiveTransform(srcPts, dstPts, H);
acl::neon::transform::warpPerspective<uint8_t, double>(
srcImage, dstImage, H, 1920, 1080, 1920, 1080,
0, 0, acl::InterpMode::LINEAR2D, 1);remap
通用像素重映射:dst(x, y) = src(mapX(x, y), mapY(x, y))。可用于实现鱼眼校正、任意畸变矫正等。
Tier: Starter+
通道: 1ch / 3ch / 4ch(通过运行时 cn 参数)
Inplace: 不支持
类型:
| 模板参数 | 允许类型 | 约束 |
|---|---|---|
IMG_T | {uint8_t, uint16_t, float} | — |
MAP_T | {float, double} | — |
CPP 签名
cpp
template<class IMG_T, class MAP_T>
int remap(
const IMG_T* srcImage, IMG_T* dstImage,
const MAP_T* mapX, const MAP_T* mapY,
int srcWidth, int srcHeight,
int dstWidth, int dstHeight,
int srcStride = 0, int dstStride = 0,
int mapStride = 0,
acl::InterpMode interpMode = acl::InterpMode::LINEAR2D,
int cn = 1);| 参数 | 类型 | 含义 | 默认 |
|---|---|---|---|
mapX, mapY | const MAP_T* | 源坐标映射图,尺寸 dstWidth × dstHeight(每个像素一对 (x, y)) | 非空 |
mapStride | int | 映射图行字节数(mapX 和 mapY 共用) | 0 = 自动 |
interpMode | acl::InterpMode | 插值模式 | LINEAR2D |
cn | int | 通道数 | 1 |
yuvRemap
对 NV21 / NV12 图像直接做 remap,保持 Y / UV 平面结构(相当于 remap 后还原 YUV 采样关系)。
Tier: Business
通道: NV21 / NV12(Y 平面 + UV 交织平面)
Inplace: 不支持
类型:
| 模板参数 | 允许类型 | 约束 |
|---|---|---|
IMG_T | uint8_t | — |
MAP_T | {float, double} | — |
CPP 签名
cpp
template<class IMG_T, class MAP_T>
int yuvRemap(
const IMG_T* srcYImage, const IMG_T* srcUVImage,
IMG_T* dstYImage, IMG_T* dstUVImage,
const MAP_T* mapX, const MAP_T* mapY,
int srcWidth, int srcHeight,
int dstWidth, int dstHeight,
int srcStride = 0, int dstStride = 0, int mapStride = 0,
acl::InterpMode interpMode = acl::InterpMode::LINEAR2D);| 参数 | 类型 | 含义 |
|---|---|---|
srcYImage, srcUVImage | const IMG_T* | 源 NV21 / NV12 平面 |
dstYImage, dstUVImage | IMG_T* | 目标 NV21 / NV12 平面 |
mapX, mapY | const MAP_T* | 基于 Y 平面尺寸的源坐标映射图(UV 自动按半分辨率采样) |
Math
Namespace: acl::neon::math
离散傅里叶变换(DFT / IDFT / 复数频谱乘法)。matchTemplate 内部也用到这套 API。
Tier: Pro+
NEON only(CPP 无对应独立 API)
DftFlags(见 acl::DftFlags):
| 标志 | 值 | 含义 |
|---|---|---|
DFT_FORWARD | 0 | 正向变换(默认) |
DFT_INVERSE | 1 | 逆向变换 |
DFT_SCALE | 2 | 结果除以 N 归一化 |
标志可按位或组合,例如
DFT_INVERSE \| DFT_SCALE。
dft1d
1D 复数 → 复数 DFT。 Tier: Pro+
通道: N/A(一维信号)
Inplace: not supported
类型:
| 模板参数 | 允许类型 | 约束 |
|---|---|---|
T | float | — |
cpp
int dft1d(
const float* srcRe, const float* srcIm,
float* dstRe, float* dstIm,
int n,
int flags = acl::DFT_FORWARD);| 参数 | 类型 | 含义 | 默认 |
|---|---|---|---|
srcRe | const float* | 输入实部(n 元素) | 非空 |
srcIm | const float* | 输入虚部(n 元素;对实数输入可传 nullptr) | 可空 |
dstRe, dstIm | float* | 输出实部 / 虚部(各 n 元素) | 非空 |
n | int | 变换长度 | > 0 |
flags | int | DFT_FORWARD / DFT_INVERSE,可或上 DFT_SCALE | DFT_FORWARD |
dftReal1d
1D 实数 → 复数正向 DFT(输出为半谱,n/2 + 1 个复系数,利用共轭对称)。 Tier: Pro+
通道: N/A(一维信号)
Inplace: not supported
类型:
| 模板参数 | 允许类型 | 约束 |
|---|---|---|
T | float | — |
cpp
int dftReal1d(
const float* srcImage,
float* dstRe, float* dstIm,
int n);| 参数 | 类型 | 含义 | 默认 |
|---|---|---|---|
srcImage | const float* | 输入实数数组(n 元素;此处复用图像入参名,实为 1D 信号) | 非空 |
dstRe, dstIm | float* | 输出实部 / 虚部(各 n/2 + 1 元素) | 非空 |
n | int | 输入长度 | 偶数且为 2 的幂 |
idftReal1d
1D 复数(CCS 半谱)→ 实数逆向 DFT。与 dftReal1d 对称,输入为 n/2 + 1 个复系数,输出 n 个实数。 Tier: Pro+
通道: N/A(一维信号)
Inplace: not supported
类型:
| 模板参数 | 允许类型 | 约束 |
|---|---|---|
T | float | — |
cpp
int idftReal1d(
const float* srcRe, const float* srcIm,
float* dstImage,
int n);| 参数 | 类型 | 含义 | 默认 |
|---|---|---|---|
srcRe, srcIm | const float* | 输入实部 / 虚部(各 n/2 + 1 元素,CCS 格式) | 非空 |
dstImage | float* | 输出实数数组(n 元素;此处复用图像入参名,实为 1D 信号) | 非空 |
n | int | 输出长度 | 偶数且为 2 的幂 |
dft2d
2D 复数 → 复数 DFT(逐行 + 逐列两次 1D FFT)。 Tier: Pro+
通道: 1ch
Inplace: not supported
类型:
| 模板参数 | 允许类型 | 约束 |
|---|---|---|
T | float | — |
cpp
int dft2d(
const float* srcRe, const float* srcIm,
float* dstRe, float* dstIm,
int width, int height,
int flags = acl::DFT_FORWARD);| 参数 | 类型 | 含义 | 默认 |
|---|---|---|---|
srcRe | const float* | 输入实部(width * height,行主序) | 非空 |
srcIm | const float* | 输入虚部(同上;实数输入可传 nullptr) | 可空 |
dstRe, dstIm | float* | 输出实部 / 虚部(同尺寸) | 非空 |
width, height | int | 列数 / 行数 | > 0 |
flags | int | 同 dft1d | DFT_FORWARD |
mulSpectrums
逐点复数乘法:C = A * B 或 C = A * conj(B)。常用于频域互相关 / 卷积。 Tier: Pro+
通道: N/A(复频谱)
Inplace: supported (aRe / aIm may equal dstRe / dstIm)
类型:
| 模板参数 | 允许类型 | 约束 |
|---|---|---|
T | float | — |
cpp
int mulSpectrums(
const float* aRe, const float* aIm,
const float* bRe, const float* bIm,
float* cRe, float* cIm,
int n,
bool conjB = false);| 参数 | 类型 | 含义 | 默认 |
|---|---|---|---|
aRe, aIm | const float* | 复数数组 A 的实部 / 虚部 | 非空 |
bRe, bIm | const float* | 复数数组 B 的实部 / 虚部 | 非空 |
cRe, cIm | float* | 输出乘积 C 的实部 / 虚部 | 非空 |
n | int | 复数元素个数 | > 0 |
conjB | bool | true = 对 B 取共轭后再相乘 | false |
示例
cpp
int n = 1024; // 必须为偶数且 2 的幂
std::vector<float> srcImage(n, 0.0f), re(n), im(n);
std::vector<float> dstImage(n);
// 1) 实数 → 半谱
acl::neon::math::dftReal1d(srcImage.data(), re.data(), im.data(), n);
// 2) 频域加工(示例:pass-through)
// 3) 半谱 → 实数还原
acl::neon::math::idftReal1d(re.data(), im.data(), dstImage.data(), n);Drawing
Namespace: acl::draw
在图像上画线 / 矩形 / 圆 / 文字。所有入口非模板,仅 uint8_t,支持 1ch / 3ch / 4ch。
Tier: Starter+
通道:1 / 3 / 4
Inplace:在原图上直接绘制(img 既是输入也是输出)
drawLine
Bresenham 直线算法绘制线段。 Tier: Starter+
通道: 1ch / 3ch / 4ch
Inplace: supported (writes onto the provided image buffer)
类型:
| 模板参数 | 允许类型 | 约束 |
|---|---|---|
T | uint8_t | — |
cpp
int drawLine(
uint8_t* img,
int width, int height, int cn, int stride,
int x0, int y0, int x1, int y1,
const uint8_t* color,
int thickness = 1);| 参数 | 类型 | 含义 | 默认 |
|---|---|---|---|
img | uint8_t* | 目标图(原位绘制) | 非空 |
width, height | int | 图像尺寸 | > 0 |
cn | int | 通道数 | 1 / 3 / 4 |
stride | int | 每行字节数 | 0 = width * cn |
x0, y0, x1, y1 | int | 线段起 / 止点 | — |
color | const uint8_t* | 颜色值数组,长度 cn | 非空 |
thickness | int | 线宽(像素) | 1 |
drawRect
绘制矩形(空心或填充)。 Tier: Starter+
通道: 1ch / 3ch / 4ch
Inplace: supported (writes onto the provided image buffer)
类型:
| 模板参数 | 允许类型 | 约束 |
|---|---|---|
T | uint8_t | — |
cpp
int drawRect(
uint8_t* img,
int imgW, int imgH, int cn, int stride,
int x, int y, int w, int h,
const uint8_t* color,
int thickness = 1);| 参数 | 类型 | 含义 | 默认 |
|---|---|---|---|
x, y | int | 矩形左上角 | — |
w, h | int | 矩形宽 / 高 | — |
thickness | int | 线宽;-1 = 填充矩形 | 1 |
其他参数与 drawLine 相同。
drawCircle
中点圆算法绘制圆(空心或填充)。 Tier: Starter+
通道: 1ch / 3ch / 4ch
Inplace: supported (writes onto the provided image buffer)
类型:
| 模板参数 | 允许类型 | 约束 |
|---|---|---|
T | uint8_t | — |
cpp
int drawCircle(
uint8_t* img,
int width, int height, int cn, int stride,
int cx, int cy, int radius,
const uint8_t* color,
int thickness = 1);| 参数 | 类型 | 含义 | 默认 |
|---|---|---|---|
cx, cy | int | 圆心 | — |
radius | int | 半径 | ≥ 0 |
thickness | int | 线宽;-1 = 填充圆 | 1 |
putText
用内置 8×16 位图字体渲染 ASCII 文字。支持换行 \n,字号由 scale 线性放大。 Tier: Starter+
通道: 1ch / 3ch / 4ch
Inplace: supported (writes onto the provided image buffer)
类型:
| 模板参数 | 允许类型 | 约束 |
|---|---|---|
T | uint8_t | — |
cpp
int putText(
uint8_t* img,
int width, int height, int cn, int stride,
const char* text,
int x, int y,
const uint8_t* color,
int scale = 1);| 参数 | 类型 | 含义 | 默认 |
|---|---|---|---|
text | const char* | 以 \0 结尾的 ASCII 字符串 | 非空 |
x, y | int | 文字左上角坐标 | — |
scale | int | 字号倍数(1 = 8×16,2 = 16×32 …) | 1 |
示例
cpp
uint8_t img[1920*1080*3] = {};
uint8_t red[3] = { 255, 0, 0 };
uint8_t blue[3] = { 0, 0, 255 };
acl::draw::drawLine(img, 1920, 1080, 3, 0, 100, 100, 500, 500, red, 2);
acl::draw::drawRect(img, 1920, 1080, 3, 0, 200, 200, 300, 150, blue, -1);
acl::draw::drawCircle(img, 1920, 1080, 3, 0, 960, 540, 80, red, 3);
acl::draw::putText(img, 1920, 1080, 3, 0, "Hello\nWorld", 50, 50, blue, 2);Contour Analysis
Namespace: acl::contour
轮廓几何分析。输入是 std::vector<acl::Point2i>(通常来自 findContours 输出)。
Tier: Pro+
NEON:无(几何计算,纯 CPP)
相关结构体
cpp
struct acl::Point2i { int x, y; }; // 输入点类型
struct acl::Rect { int x, y, width, height; };
struct acl::Point2f { float x, y; };
struct acl::Size2f { float width, height; };
struct acl::RotatedRect { Point2f center; Size2f size; float angle; };contourArea
Shoelace 公式计算多边形面积。 Tier: Pro+
通道: N/A(点集)
Inplace: not supported
类型:
| 模板参数 | 允许类型 | 约束 |
|---|---|---|
| 输入 | std::vector<acl::Point2i> | — |
| 输出 | double | — |
cpp
double contourArea(
const std::vector<acl::Point2i>& contour,
bool oriented = false);| 参数 | 类型 | 含义 | 默认 |
|---|---|---|---|
contour | 点数组 | 轮廓(至少 3 个点,否则返回 0) | — |
oriented | bool | true = 带符号面积(正 = 逆时针,负 = 顺时针);false = 绝对值 | false |
返回值是面积(非 error code)。
arcLength
轮廓周长(相邻点欧氏距离之和)。 Tier: Pro+
通道: N/A(点集)
Inplace: not supported
类型:
| 模板参数 | 允许类型 | 约束 |
|---|---|---|
| 输入 | std::vector<acl::Point2i> | — |
| 输出 | double | — |
cpp
double arcLength(
const std::vector<acl::Point2i>& contour,
bool closed = true);| 参数 | 类型 | 含义 | 默认 |
|---|---|---|---|
closed | bool | true = 闭合(包含最后一点 → 首点);false = 开放 | true |
返回值是长度(非 error code)。
boundingRect
计算轮廓的轴对齐外接矩形。 Tier: Pro+
通道: N/A(点集)
Inplace: not supported
类型:
| 模板参数 | 允许类型 | 约束 |
|---|---|---|
| 输入 | std::vector<acl::Point2i> | — |
| 输出 | acl::Rect | — |
cpp
acl::Rect boundingRect(
const std::vector<acl::Point2i>& contour);返回
Rect(非 error code)。空轮廓返回Rect(0, 0, 0, 0)。
convexHull
Andrew's monotone chain 算法计算凸包。 Tier: Pro+
通道: N/A(点集)
Inplace: not supported
类型:
| 模板参数 | 允许类型 | 约束 |
|---|---|---|
| 输入/输出 | std::vector<acl::Point2i> | — |
cpp
int convexHull(
const std::vector<acl::Point2i>& points,
std::vector<acl::Point2i>& hull);输出
hull按逆时针顺序排列。
approxPolyDP
Douglas-Peucker 算法化简多边形(减少顶点数)。 Tier: Pro+
通道: N/A(点集)
Inplace: not supported
类型:
| 模板参数 | 允许类型 | 约束 |
|---|---|---|
| 输入/输出 | std::vector<acl::Point2i> | — |
cpp
int approxPolyDP(
const std::vector<acl::Point2i>& curve,
std::vector<acl::Point2i>& approx,
double epsilon,
bool closed = true);| 参数 | 类型 | 含义 | 默认 |
|---|---|---|---|
epsilon | double | 原始曲线与化简曲线的最大距离 | — |
closed | bool | 视为闭合轮廓 | true |
minAreaRect
旋转卡尺法计算最小外接旋转矩形。 Tier: Pro+
通道: N/A(点集)
Inplace: not supported
类型:
| 模板参数 | 允许类型 | 约束 |
|---|---|---|
| 输入 | std::vector<acl::Point2i> | — |
| 输出 | acl::RotatedRect | — |
cpp
int minAreaRect(
const std::vector<acl::Point2i>& points,
acl::RotatedRect& result);输入需至少 3 个点(0 点返回错误,1-2 点返回退化 Rect)。
fitEllipse
Direct Least Squares 拟合椭圆,输出椭圆的旋转矩形描述。 Tier: Pro+
通道: N/A(点集)
Inplace: not supported
类型:
| 模板参数 | 允许类型 | 约束 |
|---|---|---|
| 输入 | std::vector<acl::Point2i> | ≥5 |
| 输出 | acl::RotatedRect | — |
cpp
int fitEllipse(
const std::vector<acl::Point2i>& points,
acl::RotatedRect& result);输入需至少 5 个点。
Utilities
cropRect
在两个 buffer 之间拷贝矩形区域,支持 inplace 缩减 stride。
Namespace: acl::memory
cpp
template<class T>
int cropRect(
const T* srcBuffer, T* dstBuffer,
int copyWidth, int copyHeight,
int srcStride = 0, int dstStride = 0,
int srcLeft = 0, int srcTop = 0,
int dstLeft = 0, int dstTop = 0);| 参数 | 类型 | 含义 | 默认 |
|---|---|---|---|
copyWidth, copyHeight | int | 拷贝区域尺寸 | — |
srcLeft, srcTop | int | 在源 buffer 的起始位置 | 0 |
dstLeft, dstTop | int | 在目标 buffer 的起始位置 | 0 |
srcStride, dstStride | int | 每行字节数 | 0 = 自动 |
支持
srcBuffer == dstBuffer的 inplace stride 缩减(srcStride ≥ dstStride时原地压缩)。
命名空间可用性一览
每类算子在 acl::neon::* 与 acl::*(CPP only)下的分布。凡两边都有的算子,签名一致(除非对应算子章节明确说明差异)。
| 类别 | neon:: + CPP 都有 | 仅 CPP |
|---|---|---|
| Analysis | integral, histogram, equalizeHist, clahe, minMaxLoc, copyMakeBorder, matchTemplate, blockAverage | histMatch, moments, count, mean, connectedComponent_8n_dfs, connectedComponentLabeling, findContours, distanceTransform, extractBlockPixels |
| Arithmetic | addImg, absDiff, addWeighted, alphaImgFusion, mul, threshold, adaptiveThreshold, bitwise (And/Not/Xor), lut, convertScaleAbs, inRange, normalize, phaseMagnitude | linearTransform2x2 |
| Color Conversion | RGB2Gray / RGBA2Gray, channelSwap (5 Mode tags), bayer2RGB, rgb2YUV_fixed 系列, yuv2RGB_fixed 系列, rgb2HSV / bgr2HSV, rgb2Lab / bgr2Lab | hsv2BGR, lab2BGR, rgb2YUV_float 系列, yuv2RGB_float 系列, bayer2RGBA, gammaTransform |
| Filter | gaussianBlur, boxFilter, filter2D, sepFilter2D, sobel3x3, scharr, laplacian, morphology(erode/dilate), canny, medianFilter3x3, bilateralFilter, nlMeansDenoising, guidedFilter, unsharpMask, stackBlur, gaborFilter | edgePreservingFilter, detailEnhance, tonemap(Linear/Reinhard/Drago), mergeMertens |
| Geometric | resize, rotate(NEON 仅 1ch u8), pyrDown, pyrUp, buildPyramid | — |
| Geometric(仅 NEON) | resizeNV, resizeYV12, resizeYUV444, rotateNV, rotateYV12, rotateYUV444 | — |
| Feature Detection | FAST, Harris(检测), Shi-Tomasi(检测)/ shiTomasiDetect, ORB(检测 + 描述), SIFT, SURF, HOG, houghLines / houghLinesP, houghCircles, opticalFlowLK, descriptorMatch(bfMatch / bfMatchBinary 及 K-NN 变体) | harrisResponse, minEigenValResponse |
| Transform | getPerspectiveTransform, findHomography, warpAffine, warpPerspective | getRotationMatrix2D, getAffineTransform, remap, yuvRemap |
| Math | — | — |
| Math(仅 NEON) | dft1d / dft2d / dftReal1d / idftReal1d / mulSpectrums | — |
| Drawing | — | drawLine, drawRect, drawCircle, putText |
| Contour Analysis | — | contourArea, arcLength, boundingRect, convexHull, approxPolyDP, minAreaRect, fitEllipse |
| Utilities | — | cropRect |
Android arm64-v8a 上,凡算子在
acl::neon::下存在就优先调 NEON 版。具体 vs OpenCV 的加速比因算子和图像尺寸而异,详见性能白皮书。