上传文件至 'src'

src/imageacquisition.cpp

@@ -0,0 +1,117 @@
+   #include "imageacquisition.h"
+
+void ImageAcquisition::initDistortionParams(int cameraCount) {
+    distortionParamsList.resize(cameraCount);
+    
+    // Initialize default stitching parameters
+    stitchParams.try_use_gpu = false;
+    stitchParams.compose_scale = 1.0;
+    stitchParams.blend_strength = 5;
+}
+
+void ImageAcquisition::setDistortionParams(int cameraIndex, const DistortionParams& params) {
+    if (cameraIndex >= 0 && cameraIndex < distortionParamsList.size()) {
+        distortionParamsList[cameraIndex] = params;
+    }
+}
+
+cv::Mat ImageAcquisition::undistortImage(const cv::Mat& image, int cameraIndex) {
+    if (cameraIndex < 0 || cameraIndex >= distortionParamsList.size()) {
+        return image.clone();
+    }
+    
+    const DistortionParams& params = distortionParamsList[cameraIndex];
+    if (params.cameraMatrix.empty() || params.distCoeffs.empty()) {
+        return image.clone();
+    }
+    
+    cv::Mat undistorted;
+    cv::undistort(image, undistorted, params.cameraMatrix, params.distCoeffs);
+    return undistorted;
+}
+
+std::vector<cv::Mat> ImageAcquisition::undistortImages(const std::vector<cv::Mat>& images) {
+    std::vector<cv::Mat> undistortedImages;
+    for (size_t i = 0; i < images.size(); ++i) {
+        undistortedImages.push_back(undistortImage(images[i], i));
+    }
+    return undistortedImages;
+}
+
+cv::Mat ImageAcquisition::stitchImages(const std::vector<cv::Mat>& images) {
+    if (images.empty()) {
+        return cv::Mat();
+    }
+    
+    if (images.size() == 1) {
+        return images[0].clone();
+    }
+    
+    cv::Stitcher::Mode mode = cv::Stitcher::PANORAMA;
+    cv::Ptr<cv::Stitcher> stitcher = cv::Stitcher::create(mode);
+    
+
+    
+    cv::Mat result;
+    cv::Stitcher::Status status = stitcher->stitch(images, result);
+    
+    if (status != cv::Stitcher::OK) {
+        return cv::Mat();
+    }
+    
+    return result;
+}
+
+cv::Mat ImageAcquisition::processFromImageSource(ImageSource& imageSource, bool fromCamera, const std::vector<std::string>& filePaths) {
+
+    if (fromCamera) {
+        captureFromCameras(imageSource);
+    } else if (!filePaths.empty()) {
+        loadFromFiles(imageSource, filePaths);
+    }
+    
+    std::vector<cv::Mat> images = imageSource.getAllImages();
+    
+    std::vector<cv::Mat> undistortedImages = undistortImages(images);
+    
+    cv::Mat result = stitchImages(undistortedImages);
+    
+    return result;
+}
+
+void ImageAcquisition::captureFromCameras(ImageSource& imageSource) {
+    int cameraCount = imageSource.countCamera;
+    
+    if (cameras.empty()) {
+        cameras.resize(cameraCount);
+        for (int i = 0; i < cameraCount; ++i) {
+            cameras[i].open(i);
+            if (!cameras[i].isOpened()) {
+                std::cerr << "Failed to open camera " << i << std::endl;
+            }
+        }
+    }
+    
+    for (int i = 0; i < cameraCount; ++i) {
+        if (cameras[i].isOpened()) {
+            cv::Mat frame;
+            cameras[i] >> frame;
+            if (!frame.empty()) {
+                imageSource.updateImage(i, frame);
+            }
+        }
+    }
+}
+
+void ImageAcquisition::loadFromFiles(ImageSource& imageSource, const std::vector<std::string>& filePaths) {
+    int cameraCount = imageSource.countCamera;
+    size_t fileCount = filePaths.size();
+    
+    // Load images
+    for (int i = 0; i < cameraCount && i < static_cast<int>(fileCount); ++i) {
+        cv::Mat image = cv::imread(filePaths[i]);
+        if (!image.empty()) {
+            imageSource.updateImage(i, image);
+        }
+    }
+}

src/imageacquisition.h

@@ -0,0 +1,57 @@
+#ifndef IMAGEACQUISITION_H
+#define IMAGEACQUISITION_H
+
+#include <opencv2/opencv.hpp>
+#include <vector>
+#include "imagesource.h"
+
+class ImageAcquisition {
+public:
+    ImageAcquisition() {}
+    
+    // 畸变矫正参数
+    struct DistortionParams {
+        cv::Mat cameraMatrix;    // 相机内参矩阵
+        cv::Mat distCoeffs;      // 畸变系数
+        cv::Mat rvecs;           // 旋转向量
+        cv::Mat tvecs;           // 平移向量
+    };
+    
+    // 图像拼接参数
+    struct StitchParams {
+        bool try_use_gpu;         // 是否使用GPU
+        double compose_scale;     // 拼接缩放比例
+        int blend_strength;       // 融合强度
+    };
+    
+    // 初始化畸变矫正参数
+    void initDistortionParams(int cameraCount);
+    
+    // 设置畸变矫正参数
+    void setDistortionParams(int cameraIndex, const DistortionParams& params);
+    
+    // 畸变矫正
+    cv::Mat undistortImage(const cv::Mat& image, int cameraIndex);
+    
+    // 批量畸变矫正
+    std::vector<cv::Mat> undistortImages(const std::vector<cv::Mat>& images);
+    
+    // 图像拼接
+    cv::Mat stitchImages(const std::vector<cv::Mat>& images);
+    
+    // 从图像源获取并处理图像
+    cv::Mat processFromImageSource(ImageSource& imageSource, bool fromCamera = true, const std::vector<std::string>& filePaths = std::vector<std::string>());
+    
+    // 从相机中获取图像
+    void captureFromCameras(ImageSource& imageSource);
+    
+    // 从文件中获取图像
+    void loadFromFiles(ImageSource& imageSource, const std::vector<std::string>& filePaths);
+    
+private:
+    std::vector<DistortionParams> distortionParamsList; // 每个相机的畸变矫正参数
+    StitchParams stitchParams;                          // 图像拼接参数
+    std::vector<cv::VideoCapture> cameras;              // 相机捕获对象
+};
+
+#endif // IMAGEACQUISITION_H

src/imageprocessor.cpp

@@ -0,0 +1,98 @@
+#include "imageprocessor.h"
+
+// Grayscale conversion
+cv::Mat ImageProcessor::grayscale(const cv::Mat& image)
+{
+    cv::Mat grayImage;
+    cv::cvtColor(image, grayImage, cv::COLOR_BGR2GRAY);
+    return grayImage;
+}
+
+// Gaussian blur
+cv::Mat ImageProcessor::gaussianBlur(const cv::Mat& image, const GaussianBlurParams& params)
+{
+    cv::Mat blurredImage;
+    cv::GaussianBlur(image, blurredImage, cv::Size(params.kernelSize, params.kernelSize), params.sigma);
+    return blurredImage;
+}
+
+// Canny edge detection
+cv::Mat ImageProcessor::cannyEdgeDetection(const cv::Mat& image, const CannyEdgeDetectionParams& params)
+{
+    cv::Mat grayImage;
+    cv::cvtColor(image, grayImage, cv::COLOR_BGR2GRAY);
+    
+    cv::Mat edgeImage;
+    cv::Canny(grayImage, edgeImage, params.threshold1, params.threshold2);
+    return edgeImage;
+}
+
+// Thresholding
+cv::Mat ImageProcessor::thresholding(const cv::Mat& image, const ThresholdingParams& params)
+{
+    cv::Mat grayImage;
+    cv::cvtColor(image, grayImage, cv::COLOR_BGR2GRAY);
+    
+    cv::Mat thresholdedImage;
+    cv::threshold(grayImage, thresholdedImage, static_cast<double>(params.threshold), static_cast<double>(params.maxValue), params.thresholdType);
+    return thresholdedImage;
+}
+
+// Histogram equalization
+cv::Mat ImageProcessor::histogramEqualization(const cv::Mat& image)
+{
+    cv::Mat grayImage;
+    cv::cvtColor(image, grayImage, cv::COLOR_BGR2GRAY);
+    
+    cv::Mat equalizedImage;
+    cv::equalizeHist(grayImage, equalizedImage);
+    return equalizedImage;
+}
+
+// Dilate
+cv::Mat ImageProcessor::dilate(const cv::Mat& image, const DilateErodeParams& params)
+{
+    cv::Mat kernel = cv::getStructuringElement(cv::MORPH_RECT, cv::Size(params.kernelSize, params.kernelSize));
+    cv::Mat dilatedImage;
+    cv::dilate(image, dilatedImage, kernel);
+    return dilatedImage;
+}
+
+// Erode
+cv::Mat ImageProcessor::erode(const cv::Mat& image, const DilateErodeParams& params)
+{
+    cv::Mat kernel = cv::getStructuringElement(cv::MORPH_RECT, cv::Size(params.kernelSize, params.kernelSize));
+    cv::Mat erodedImage;
+    cv::erode(image, erodedImage, kernel);
+    return erodedImage;
+}
+
+// Find contours
+cv::Mat ImageProcessor::findContours(const cv::Mat& image, const FindContoursParams& params)
+{
+    // Convert to grayscale if needed
+    cv::Mat grayImage;
+    if (image.channels() > 1)
+    {
+        cv::cvtColor(image, grayImage, cv::COLOR_BGR2GRAY);
+    }
+    else
+    {
+        grayImage = image.clone();
+    }
+    
+    // Apply threshold to get binary image
+    cv::Mat binaryImage;
+    cv::threshold(grayImage, binaryImage, 128, 255, cv::THRESH_BINARY);
+    
+    // Find contours
+    std::vector<std::vector<cv::Point>> contours;
+    std::vector<cv::Vec4i> hierarchy;
+    cv::findContours(binaryImage, contours, hierarchy, params.mode, params.method);
+    
+    // Draw contours on a copy of the original image
+    cv::Mat resultImage = image.clone();
+    cv::drawContours(resultImage, contours, -1, cv::Scalar(0, 255, 0), 2);
+    
+    return resultImage;
+}

src/imageprocessor.h

@@ -0,0 +1,60 @@
+#ifndef IMAGEPROCESSOR_H
+#define IMAGEPROCESSOR_H
+
+#include <opencv2/opencv.hpp>
+
+class ImageProcessor
+{
+public:
+    // Parameter structures for each algorithm
+    struct GaussianBlurParams {
+        int kernelSize = 5;
+        double sigma = 0;
+    };
+    
+    struct CannyEdgeDetectionParams {
+        int threshold1 = 50;
+        int threshold2 = 150;
+    };
+    
+    struct ThresholdingParams {
+        int threshold = 128;
+        int maxValue = 255;
+        int thresholdType = cv::THRESH_BINARY;
+    };
+    
+    struct DilateErodeParams {
+        int kernelSize = 3;
+    };
+    
+    struct FindContoursParams {
+        int mode = cv::RETR_TREE;
+        int method = cv::CHAIN_APPROX_SIMPLE;
+    };
+    
+    // Grayscale conversion
+    static cv::Mat grayscale(const cv::Mat& image);
+    
+    // Gaussian blur
+    static cv::Mat gaussianBlur(const cv::Mat& image, const GaussianBlurParams& params);
+    
+    // Canny edge detection
+    static cv::Mat cannyEdgeDetection(const cv::Mat& image, const CannyEdgeDetectionParams& params);
+    
+    // Thresholding
+    static cv::Mat thresholding(const cv::Mat& image, const ThresholdingParams& params);
+    
+    // Histogram equalization
+    static cv::Mat histogramEqualization(const cv::Mat& image);
+    
+    // Dilate
+    static cv::Mat dilate(const cv::Mat& image, const DilateErodeParams& params);
+    
+    // Erode
+    static cv::Mat erode(const cv::Mat& image, const DilateErodeParams& params);
+    
+    // Find contours
+    static cv::Mat findContours(const cv::Mat& image, const FindContoursParams& params);
+};
+
+#endif // IMAGEPROCESSOR_H

src/imagesource.cpp

@@ -0,0 +1,43 @@
+#include "imagesource.h"
+
+void ImageSource::initCameraParams(int xCount, int yCount) {
+    XCount = xCount;
+    YCount = yCount;
+    countCamera = xCount * yCount;
+    cameraParams.resize(countCamera);
+    srcArr.resize(countCamera);
+}
+
+void ImageSource::addCameraParam(int index, const std::string& sn, int width, int height, int type) {
+    if (index >= 0 && index < countCamera) {
+        cameraParams[index].index = index;
+        cameraParams[index].SN = sn;
+        cameraParams[index].width = width;
+        cameraParams[index].height = height;
+        cameraParams[index].type = type;
+    }
+}
+
+CamerPara ImageSource::getCameraParam(int index) const {
+    if (index >= 0 && index < countCamera) {
+        return cameraParams[index];
+    }
+    return CamerPara();
+}
+
+void ImageSource::updateImage(int index, const cv::Mat& image) {
+    if (index >= 0 && index < countCamera) {
+        srcArr[index] = image.clone();
+    }
+}
+
+cv::Mat ImageSource::getImage(int index) const {
+    if (index >= 0 && index < countCamera) {
+        return srcArr[index].clone();
+    }
+    return cv::Mat();
+}
+
+std::vector<cv::Mat> ImageSource::getAllImages() const {
+    return srcArr;
+}