OpenCV Operator Factory 🔧 图像处理算子工厂系统

📖 系统概述

OpenCV Operator Factory 是一个用C++17实现的图像处理算子框架，基于OpenCV库构建。它通过工厂模式统一管理多种图像处理算子，支持算子的动态创建、权重持久化、进化算法优化和混合算子组合。系统特别适用于需要自适应调整图像处理参数的场景，如自动图像增强、边缘检测参数优化等。

✨ 核心特性

• 工厂模式设计 — 统一的算子创建接口，支持运行时动态创建算子实例
• 权重管理系统 — 算子权重持久化(YAML格式)，支持加载、保存、历史记录
• 进化算法优化 — 遗传算法优化算子参数，支持种群进化、交叉、变异、创新
• 混合算子 — 多个算子加权组合，动态调整子算子权重
• 自定义卷积核学习 — 通过梯度下降优化卷积核参数
• 配置系统 — YAML配置文件管理算子参数、进化参数、权重路径
• 历史权重记忆 — 保存最佳权重历史，支持历史交叉和创新
• 适应度评估 — 基于目标图像的MSE计算适应度分数

🏗️ 架构设计

⚡ 快速开始

编译与安装

# 安装依赖
sudo apt update
sudo apt install build-essential cmake libopencv-dev

# 克隆仓库
git clone https://github.com/example/opencv-operator-factory.git
cd opencv-operator-factory

# 创建构建目录
mkdir build && cd build

# CMake配置
cmake .. -DCMAKE_BUILD_TYPE=Release

# 编译
make -j4

# 运行演示程序
./bin/OperatorFactoryDemo

基本使用示例

#include "OperatorFactory.h"

using namespace OperatorFactory;

int main() {
    // 获取工厂实例
    auto& factory = OperatorFactory::getInstance();
    
    // 创建高斯模糊算子
    auto gaussianOp = factory.createOperator(
        OperatorBase::OP_GAUSSIAN_BLUR, "MyGaussian");
    
    // 加载图像
    cv::Mat image = cv::imread("input.jpg", cv::IMREAD_GRAYSCALE);
    
    // 应用算子
    cv::Mat result = gaussianOp->apply(image);
    
    // 保存结果
    cv::imwrite("output.jpg", result);
    
    // 保存权重
    gaussianOp->saveWeights("weights/gaussian.yaml");
    
    return 0;
}

🎯 内置算子详解

1. 高斯模糊算子 (GaussianBlurOperator)

对图像进行高斯平滑处理，减少噪声和细节。

参数:
- sigma: 高斯核标准差 (0.5-5.0)
- kernelSize: 核大小 (3,5,7,...,31) 必须为奇数

2. Sobel边缘检测算子 (SobelOperator)

计算图像梯度，检测边缘。

参数:
- dx: x方向导数阶数 (0-2)
- dy: y方向导数阶数 (0-2)
- ksize: Sobel核大小 (1,3,5,7)
- scale: 缩放因子 (0.5-3.0)

3. Canny边缘检测算子 (CannyOperator)

多级边缘检测算法。

参数:
- threshold1: 低阈值 (10-100)
- threshold2: 高阈值 (100-300)
- apertureSize: Sobel算子大小 (3,5,7)
- L2gradient: 是否使用L2范数

4. Laplacian算子 (LaplacianOperator)

二阶导数边缘检测。

参数:
- ksize: 核大小 (1,3,5,...,31)
- scale: 缩放因子 (0.1-3.0)

5. 自定义卷积算子 (CustomConvolutionOperator)

可学习的卷积核，支持梯度下降优化。

特性:
- 可学习卷积核 (3x3, 5x5, 7x7等)
- 基于梯度的参数更新
- 核归一化约束

⚖️ 权重管理系统

每个算子都关联一个OperatorWeight对象，存储可学习参数和进化信息。

权重数据结构

struct WeightData {
    cv::Mat weightMatrix;           // 权重矩阵
    std::vector<float> parameters;  // 算子参数
    std::map<string, cv::Mat> featureMaps; // 特征图
    float fitnessScore;             // 适应度分数
    int generation;                 // 进化代数
    std::string metadata;           // 元数据
    std::vector<float> mutationHistory; // 变异历史
};

权重操作

// 保存权重
operator->saveWeights("weights/my_operator.yaml");

// 加载权重
operator->loadWeights("weights/my_operator.yaml");

// 变异
weight->mutate(0.1f, rng);

// 交叉
OperatorWeight child = parent1.crossover(parent2, 0.7f, rng);

// 创新
weight->innovate(0.15f, rng);

🧬 进化算法系统

WeightEvolution类实现了完整的遗传算法，用于优化算子参数。

进化流程

1. 初始化种群 (历史权重 + 随机权重)
2. 评估适应度 (基于目标图像的MSE)
3. 选择父代 (锦标赛选择)
4. 交叉操作 (参数和权重矩阵交叉)
5. 变异操作 (高斯噪声扰动)
6. 创新操作 (增强变异)
7. 精英保留 (保留最佳个体)
8. 更新记忆库 (保存最佳权重)

进化参数配置

🔀 混合算子 (HybridOperator)

混合算子将多个子算子加权组合，动态调整各算子的权重。

创建混合算子

std::vector<OperatorBase::OperatorType> types = {
    OperatorBase::OP_GAUSSIAN_BLUR,
    OperatorBase::OP_SOBEL,
    OperatorBase::OP_CUSTOM_CONV
};

auto hybrid = factory.createHybridOperator(types, "MyHybrid");

动态权重更新

// 基于结果更新权重
hybrid->updateWeightsFromResult(input, target, learningRate);

⚙️ 配置系统

YAML格式配置文件，支持运行时加载和保存。

配置文件示例 (config.yaml)

%YAML:1.0
WeightConfig:
  weightPath: "weights/"
  mutationRate: 0.1
  crossoverRate: 0.7
  populationSize: 50
  maxGenerations: 100
  innovationRate: 0.15
  useHistoricalLearning: 1

EvolutionParams:
  explorationFactor: 0.3
  exploitationFactor: 0.5
  diversityWeight: 0.2
  innovationBoost: 1.5
  memorySize: 10

Operators:
  - name: "GaussianBlur"
    type: 0
    params:
      sigma: 1.0
      kernelSize: 3
    kernelSize: [3, 3]
    enabled: 1
  - name: "Sobel"
    type: 1
    params:
      dx: 1.0
      dy: 0.0
      ksize: 3
    kernelSize: [3, 3]
    enabled: 1

📚 API 参考

OperatorFactory

class OperatorFactory {
public:
    static OperatorFactory& getInstance();
    
    // 创建算子
    std::shared_ptr<OperatorBase> createOperator(
        OperatorType type, const std::string& name = "");
    
    // 带权重的算子
    std::shared_ptr<OperatorBase> createOperatorWithWeights(
        OperatorType type, const std::string& weightName = "");
    
    // 创新算子
    std::shared_ptr<OperatorBase> createInnovativeOperator(
        OperatorType type, const cv::Mat& input, const cv::Mat& target);
    
    // 混合算子
    std::shared_ptr<OperatorBase> createHybridOperator(
        const std::vector<OperatorType>& types, const std::string& name = "");
    
    // 注册自定义算子
    void registerOperator(OperatorType type,
        std::function<std::shared_ptr<OperatorBase>()> creator,
        const std::string& name);
};

OperatorBase

class OperatorBase {
public:
    // 核心方法
    virtual cv::Mat apply(const cv::Mat& input) = 0;
    
    // 权重管理
    virtual void setWeights(const std::shared_ptr<OperatorWeight>& weights);
    virtual std::shared_ptr<OperatorWeight> getWeights() const;
    
    // 学习更新
    virtual void updateWeightsFromResult(const cv::Mat& input, 
                                        const cv::Mat& result, 
                                        float learningRate);
    
    // 持久化
    virtual bool loadWeights(const std::string& filePath);
    virtual bool saveWeights(const std::string& filePath) const;
    
    // 克隆
    virtual OperatorBase* clone() const = 0;
};

💡 完整示例程序

#include "OperatorFactory.h"
#include "Config.h"
#include <opencv2/opencv.hpp>

using namespace OperatorFactory;

int main() {
    // 加载配置
    Config::getInstance().load("config/config.yaml");
    
    // 获取工厂
    auto& factory = OperatorFactory::getInstance();
    
    // 加载测试图像
    cv::Mat input = cv::imread("test.jpg", cv::IMREAD_GRAYSCALE);
    cv::Mat target = cv::imread("target.jpg", cv::IMREAD_GRAYSCALE);
    
    // 创建并优化自定义卷积算子
    auto customOp = factory.createOperator(OperatorBase::OP_CUSTOM_CONV);
    
    // 进化优化
    auto weightManager = factory.getWeightManager();
    auto evolvedWeight = weightManager->generateWeight(
        OperatorBase::OP_CUSTOM_CONV, input, target, "evolution");
    
    if (evolvedWeight) {
        customOp->setWeights(evolvedWeight);
        std::cout << "进化完成，适应度: " 
                  << evolvedWeight->getData().fitnessScore << std::endl;
    }
    
    // 应用优化后的算子
    cv::Mat result = customOp->apply(input);
    cv::imwrite("result.jpg", result);
    
    // 保存最佳权重
    customOp->saveWeights("weights/best_operator.yaml");
    
    return 0;
}

⚡ 性能测试结果

测试环境：Intel i7-12700H, 16GB RAM, Ubuntu 22.04, OpenCV 4.8

⚖️ 许可证