算子 API

内置算子的完整参考文档。

IOperator 接口

class IOperator {
public:
    virtual ~IOperator() = default;

    virtual cudaError_t initialize() { return cudaSuccess; }
    virtual void shutdown() {}

    // 在 GPU 上执行算子
    virtual cudaError_t execute(const void* input, void* output,
                                int width, int height, int channels,
                                cudaStream_t stream) = 0;

    // 获取工作区需求（多输入 / 批处理路径）
    virtual WorkspaceRequirements getWorkspaceRequirements(
        const std::vector<ImageBuffer>& inputs) const {
        return {};
    }

    // 是否接受指定数量的输入
    virtual bool supportsInputCount(size_t count) const { return count == 1; }

    // 多输入 / 批处理执行路径
    virtual cudaError_t executeBuffers(const std::vector<ImageBuffer>& inputs,
                                         ImageBuffer& output,
                                         const OperatorExecutionContext& context);

    // 获取输出尺寸
    virtual void getOutputDimensions(int inputWidth, int inputHeight, int inputChannels,
                                     int& outputWidth, int& outputHeight,
                                     int& outputChannels) const = 0;

    // 获取算子名称
    virtual const char* getName() const = 0;
};

---

GaussianBlurOperator

使用可分离滤波器优化的高斯模糊。

class GaussianBlurOperator : public IOperator {
public:
    explicit GaussianBlurOperator(GaussianKernelSize size, float sigma = 0.0f);
    
    void setKernelSize(GaussianKernelSize size);
    void setSigma(float sigma);
    
    GaussianKernelSize getKernelSize() const;
    float getSigma() const;
};

enum class GaussianKernelSize { 
    KERNEL_3x3 = 3, 
    KERNEL_5x5 = 5, 
    KERNEL_7x7 = 7 
};

参数

参数	类型	描述
size	GaussianKernelSize	内核尺寸 (3×3, 5×5 或 7×7)
sigma	float	高斯 sigma 值 (0 = 自动计算)

示例

auto blur = std::make_shared<GaussianBlurOperator>(GaussianKernelSize::KERNEL_5x5, 1.5f);

实现细节

• 使用可分离滤波器：将 2D 内核分解为两次 1D 处理
• 复杂度：$O(n^2)\to O(2n)$ 每像素
• 使用带边界处理的共享内存和边缘区域

---

SobelOperator

应用 3×3 Sobel 边缘检测。

class SobelOperator : public IOperator {
public:
    SobelOperator();
    // 输出：单通道梯度幅值
};

输出

• 单通道灰度图
• 每个像素表示梯度幅值：$\sqrt{G_x^2+G_y^2}$

Sobel 内核

$$G_x=\left[\begin{array}{ccc}-1& 0& 1\\ -2& 0& 2\\ -1& 0& 1\end{array}\right]$$$$G_y=\left[\begin{array}{ccc}-1& -2& -1\\ 0& 0& 0\\ 1& 2& 1\end{array}\right]$$

示例

auto sobel = std::make_shared<SobelOperator>();

---

ResizeOperator

使用插值调整图像尺寸。

class ResizeOperator : public IOperator {
public:
    ResizeOperator(int targetWidth, int targetHeight, 
                   InterpolationMode mode = InterpolationMode::BILINEAR);
    
    void setTargetSize(int width, int height);
    void setInterpolationMode(InterpolationMode mode);
    
    int getTargetWidth() const;
    int getTargetHeight() const;
};

enum class InterpolationMode { NEAREST, BILINEAR };

参数

参数	类型	描述
targetWidth	int	输出宽度（像素）
targetHeight	int	输出高度（像素）
mode	InterpolationMode	最近邻或双线性插值

坐标映射

$$sr{c}_x=ds{t}_x\times \frac{src\mathrm{\_}width}{dst\mathrm{\_}width}$$$$sr{c}_y=ds{t}_y\times \frac{src\mathrm{\_}height}{dst\mathrm{\_}height}$$

示例

auto resize = std::make_shared<ResizeOperator>(320, 240, InterpolationMode::BILINEAR);

---

ColorConvertOperator

色彩空间转换。

class ColorConvertOperator : public IOperator {
public:
    explicit ColorConvertOperator(ColorConversionType type);
};

enum class ColorConversionType { 
    RGB_TO_GRAY, 
    BGR_TO_RGB, 
    RGBA_TO_RGB, 
    GRAY_TO_RGB 
};

转换类型

类型	输入	输出	描述
RGB_TO_GRAY	3 通道	1 通道	亮度转换
BGR_TO_RGB	3 通道	3 通道	通道重排序
RGBA_TO_RGB	4 通道	3 通道	丢弃 Alpha 通道
GRAY_TO_RGB	1 通道	3 通道	复制到 3 个通道

亮度公式

$$Y=0.299R+0.587G+0.114B$$

(ITU-R BT.601 标准)

示例

auto gray = std::make_shared<ColorConvertOperator>(ColorConversionType::RGB_TO_GRAY);

---

创建自定义算子

实现 IOperator 接口：

class MyCustomOperator : public IOperator {
public:
    cudaError_t execute(const void* input, void* output,
                        int width, int height, int channels,
                        cudaStream_t stream) override {
        // 启动 CUDA 内核
        myKernel<<<grid, block, 0, stream>>>(input, output, width, height, channels);
        return cudaGetLastError();
    }
    
    void getOutputSize(int inputWidth, int inputHeight,
                       int& outputWidth, int& outputHeight) override {
        outputWidth = inputWidth;
        outputHeight = inputHeight;
    }
    
    int getOutputChannels(int inputChannels) override {
        return inputChannels;
    }
};

工作空间需求

WorkspaceRequirements getWorkspaceRequirements(
    const std::vector<ImageBuffer>& inputs) const override {
    if (inputs.empty()) return {};
    return {
        .deviceBytes = static_cast<size_t>(inputs.front().width) *
                       inputs.front().height * inputs.front().channels * sizeof(float)
    };
}

---

MergeAverageOperator

对 2 个及以上同尺寸输入进行逐像素平均。

class MergeAverageOperator : public IOperator {
public:
    MergeAverageOperator();

    bool supportsInputCount(size_t count) const override { return count >= 2; }

    void getOutputDimensions(int inputWidth, int inputHeight, int inputChannels,
                             int& outputWidth, int& outputHeight,
                             int& outputChannels) const override;
};

行为

• 所有输入 必须 具有相同的 width、height 和 channels。
• 维度不匹配将返回 cudaErrorInvalidValue。
• 输出形状与第一个输入一致。

示例

auto merge = std::make_shared<MergeAverageOperator>();
int mergeId = pipeline.addOperator("Merge", merge);
pipeline.connect(leftId, mergeId);
pipeline.connect(rightId, mergeId);