c++ opencv 复现 halcon算子 derivate_gauss

终于搞懂了halcon的derivate_gauss 里面的卷积核的生成逻辑了
测试 halcon算子 derivate_gauss 高斯一阶导数卷积

之前的逻辑使用的是生成高斯导数核(标准公式)

换成生成高斯导数核 (area‑integrated) 两者的结果就完全相等了

// 高斯函数 G(x)
inline double gaussian(double x, double sigma) {
	const double sqrt2pi = std::sqrt(2.0 * CV_PI);
	return std::exp(-0.5 * x * x / (sigma * sigma)) / (sigma * sqrt2pi);
}
// 高斯累积分布函数 Φ(x) = 0.5*(1 + erf(x/(σ√2)))
inline double gaussianCDF(double x, double sigma) {
	return 0.5 * (1.0 + std::erf(x / (sigma * std::sqrt(2.0))));
}
// 生成高斯导数核 (area‑integrated)
// (order: 0 -> 平滑, 1 -> 一阶导, 2 -> 二阶导)
cv::Mat getDerivGaussianKernel(int ksize, double sigma, int order) {
	CV_Assert(ksize % 2 == 1 && ksize > 0);
		cv::Mat kernel(ksize, 1, CV_32F);
		float* k = kernel.ptr<float>(0);
		int center = (ksize - 1) / 2;

		for (int i = 0; i < ksize; ++i) {
			double x = i - center;          // 像素中心坐标
			double left = x - 0.5;          // 像素左边界
			double right = x + 0.5;         // 像素右边界

			double val = 0.0;
			switch (order) {
			case 0: // 平滑：∫ G(x) dx
				val = gaussianCDF(right, sigma) - gaussianCDF(left, sigma);
				break;
			case 1: // 一阶导：∫ dG/dx dx = G(right) - G(left)
				val = gaussian(right, sigma) - gaussian(left, sigma);
				break;
			case 2: // 二阶导：∫ d²G/dx² dx = dG/dx(right) - dG/dx(left)
				// dG/dx = -x/σ² * G(x)
			{
				double dG_left = -left / (sigma * sigma) * gaussian(left, sigma);
				double dG_right = -right / (sigma * sigma) * gaussian(right, sigma);
				val = dG_right - dG_left;
			}
			break;
			default:
				CV_Error(cv::Error::StsBadArg, "order must be 0,1,2");
			}
			k[i] = static_cast<float>(val);
		}
		return kernel;
	}
// 生成高斯导数核(标准公式)
// (order: 0->平滑, 1->一阶导, 2->二阶导)
Mat getDerivGaussianKernel_(int ksize, double sigma, int order) {
	CV_Assert(ksize % 2 == 1);
		Mat kernel(ksize, 1, CV_32F);
		float* k = kernel.ptr<float>(0);
		int center = (ksize - 1) / 2;
		double sigma2 = sigma * sigma;
		double sigma4 = sigma2 * sigma2;

		// 先计算标准高斯核 (order=0)
		for (int i = 0; i < ksize; i++) {
			double x = i - center;
			double g = exp(-x * x / (2.0 * sigma2)) / (sqrt(2.0 * CV_PI) * sigma);
			if (order == 0) {
				k[i] = (float)g;
			}
			else if (order == 1) {
				// 一阶导数核: -x / σ² * G
				k[i] = (float)(-x / sigma2 * g);
			}
			else if (order == 2) {
				// 二阶导数核: (x²/σ⁴ - 1/σ²) * G
				k[i] = (float)((x * x / sigma4 - 1.0 / sigma2) * g);
			}
		}
		return kernel;
	}