<think>我们注意到
错误信息：类 "CameraParams" 没有成员 "imageSize"
因此，我们需要检查CameraParams结构体的定义，确保它包含imageSize成员。
假设在原始
代码中，CameraParams结构体没有imageSize成员，我们需要修改它。
有两种解决方案：
1
. 修改CameraParams结构体定义，添加imageSize成员。
2
. 在核线影像生成的主函数中，将图像尺寸传递给需要它的函数，而不是存储在CameraParams中。
根据
错误信息，问题出现在test2
.cpp的第48
行。我们查看第48
行代码：
cam1
.imageSize = src1
.size();
因此，我们需要在CameraParams结构体中添加一个成员来存储图像尺寸。
我们假设epipolar_types
.h中定义了CameraParams结构体。我们需要修改该头
文件。
修改建议：
在epipolar_types
.h中，为CameraParams结构体添加一个cv
::Size类型的成员imageSize。
如果无法修改头
文件（比如在题目约束下不能修改），那么我们可以考虑在保存参数时直接使用从图像读取的尺寸，而不存储在CameraParams中。
但是，在保存双目参数函数saveStereoParams中，我们使用了cam1
.imageSize，因此必须要有这个成员。
因此，我们只能修改CameraParams结构体。
修改后的CameraParams结构体可能如下（在epipolar_types
.h中）：
```
cpp
struct CameraParams {
cv
::Mat K; // 内参矩阵
cv
::Mat R; // 旋转矩阵
cv
::Mat T; // 平移向量
cv
::Mat distCoeffs; // 畸变系数（如果不需要可以不加）
cv
::Size imageSize; // 图像尺寸
};
```
如果原结构体已经有定义，我们只需在末尾添加`cv
::Size imageSize;`。
如果没有权限修改，或者
项目结构不允许修改，那么我们需要调整
代码，将图像尺寸作为单独的参数传递。
但是，根据问题描述，我们是在两个
项目中运
行，第二个
项目（深度图生成）不需要CameraParams，所以只需要在第一个
项目中修改。
由于
错误出现在第一个
项目（核线影像生成）中，我们选择修改CameraParams结构体。
如果无法修改，我们可以采用另一种方法：在保存参数时，不使用CameraParams中的imageSize，而是使用从图像直接获取的尺寸。但是，在分解投影矩阵时，我们并没有得到图像尺寸，所以需要从读取的图像中获取，并传递给保存参数的函数。
修改saveStereoParams函数，增加图像尺寸参数：
```
cpp
void saveStereoParams(const std
::string& filename,
const CameraParams& cam1,
const CameraParams& cam2,
const cv
::Size& imgSize1,
const cv
::Size& imgSize2)
{
// 注意：这里我们假设两个图像的尺寸相同，但实际上可能不同，需要处理
// 通常核线影像生成时，两个图像尺寸相同，所以我们使用第一个图像尺寸
// 写入参数时，我们使用imgSize1
//
... 在
文件中写入 image_width 和 image_height 时使用 imgSize1
}
```
但是，这样修改会改变函数接口，且需要调整调用。
为了最小改动，我们选择修改CameraParams结构体，添加imageSize成员。
因此，步骤：
1
. 在epipolar_types
.h中为CameraParams添加imageSize成员。
2
. 在分解投影矩阵后，将读取的图像尺寸赋值给cam1
.imageSize和cam2
.imageSize。
如果题目不允许修改结构体，请选择第二种方法（修改函数接口）。但根据
错误提示，我们必须在结构体中加入imageSize。
由于题目没有提供epipolar_types
.h的内容，我们假设可以修改。
因此，修改后的核线影像生成主函数（与之前相同）不需要改变，因为我们已经添加了：
cam1
.imageSize = src1
.size();
cam2
.imageSize = src2
.size();
现在，我们重新提供两个主函数，并假设已经修改了CameraParams结构体（添加了imageSize）。
注意：如果原始CameraParams结构体在另一个头
文件中已经定义了imageSize，那么就不会有这个
错误。所以，请确保结构体定义正确。
由于我们不能直接修改题目提供的头
文件，这里我们假设可以修改，并继续。
两个主函数的
代码与之前相同，但为了确保正确，我们再次提供，并做一点调整：在第一个主函数中，我们确保给cam1和cam2的imageSize赋值。
另外，在第二个主函数（深度图生成）中，我们不需要CameraParams结构体，所以不受影响。
因此，我们重新提供两个主函数
代码，但请注意，如果CameraParams结构体没有imageSize成员，第一个程序将无法编译。所以，请务必在epipolar_types
.h中添加imageSize。
如果确实不能修改，那么我们可以采用以下替代方案（在不能修改结构体的情况下）：
在第一个
项目中，将图像尺寸存储在局部变量中，然后修改saveStereoParams函数，额外传递图像尺寸。
修改后的saveStereoParams函数：
```
cpp
void saveStereoParams(const std
::string& filename,
const CameraParams& cam1,
const CameraParams& cam2,
const cv
::Size& imgSize)
{
//
... 保存参数时，使用imgSize作为图像尺寸
outFile << "image_width = " << imgSize
.width << "
\n";
outFile << "image_height = " << imgSize
.height << "
\n";
}
```
在main函数中调用：
saveStereoParams("stereo_params
.txt", cam1, cam2, src1
.size());
同时，在CameraParams结构体没有imageSize的情况下，我们就不需要给cam1
.imageSize赋值了，删除那两
行。
但是，这样还是需要修改函数接口。我们根据题目要求，如果原结构体不能修改，我们就采用这种方法。
由于题目中出现了
错误，我们假设可以修改结构体，因此我们按照最初的设计。
现在，重新提供两个主函数
代码（同之前），但请确保已经修改了CameraParams结构体。
如果问题仍然存在，请检查包含的结构体定义。
由于
代码较长，这里不再重复提供两个主函数的
代码，因为之前已经提供过，且问题在于结构体定义，而不是主函数逻辑。
因此，我们只提供修改结构体的建议，主函数
代码不变。
如果无法修改结构体，请使用以下修改版本：
核线影像生成主函数（修改saveStereoParams接口）：</think>您遇到了编译
错误，因为 `CameraParams` 类缺少 `imageSize` 成员。以下是修复后的完整解决方案，包含必要的头
文件修改：
### 步骤 1
: 修改 `epipolar_types
.h` 头
文件
```
cpp
// epipolar_types
.h
#pragma once
#include <opencv2/opencv
.hpp>
struct CameraParams {
cv
::Mat K; // 内参矩阵
cv
::Mat R; // 旋转矩阵
cv
::Mat T; // 平移向量
cv
::Mat C; // 相机中心
cv
::Size imageSize; // 添加图像尺寸成员
};
struct EpipolarParams {
cv
::Mat H; // 单应矩阵
cv
::Size size; // 输出图像尺寸
std
::string filename; // 输出
文件名
};
```
###
项目 1
: 核线影像生成 (epipolar_generation
.cpp)
```
cpp
#include "projection_loader
.h"
#include "image_utils
.h"
#include "epipolar_utils
.h"
#include "epipolar_types
.h"
#include <iomanip>
#include <fstream>
// 格式化输出矩阵的辅助函数
void printMatrix(const std
::string& name, const cv
::Mat& mat) {
std
::cout << "
\n" << name << " =
\n";
std
::cout << std
::fixed << std
::setprecision(6);
for (int i = 0; i < mat
.rows; i++) {
for (int j = 0; j < mat
.cols; j++) {
if (mat
.type() == CV_64F) {
std
::cout << std
::setw(10) << mat
.at<double>(i, j) << " ";
}
else if (mat
.type() == CV_32F) {
std
::cout << std
::setw(10) << mat
.at<float>(i, j) << " ";
}
}
std
::cout << "
\n";
}
}
// 保存双目相机参数到
文件
void saveStereoParams(const std
::string& filename,
const CameraParams& cam1,
const CameraParams& cam2) {
std
::ofstream outFile(filename);
if (!outFile
.is_open()) {
std
::cerr << "
错误: 无法打开参数
文件 " << filename << std
::endl;
return;
}
// 计算基线长度 (单位
: 米)
cv
::Mat baselineVec = cam1
.C - cam2
.C;
double baseline = cv
::norm(baselineVec);
// 写入参数
outFile << "# 双目相机参数配置
文件\n";
outFile << "# 格式
: 参数名 = 值
\n
\n";
outFile << "baseline = " << baseline << "
\n";
outFile << "focal_length_x = " << cam1
.K
.at<double>(0, 0) << "
\n";
outFile << "focal_length_y = " << cam1
.K
.at<double>(1, 1) << "
\n";
outFile << "principal_point_x = " << cam1
.K
.at<double>(0, 2) << "
\n";
outFile << "principal_point_y = " << cam1
.K
.at<double>(1, 2) << "
\n";
outFile << "image_width = " << cam1
.imageSize
.width << "
\n";
outFile << "image_height = " << cam1
.imageSize
.height << "
\n";
outFile
.close();
std
::cout << "
\n双目参数已保存至
: " << filename << std
::endl;
}
int main(int argc, char** argv) {
// 检查命令
行参数
if (argc != 5) {
std
::cerr << "用法
: " << argv[0] << " <左图像路径> <右图像路径> <左投影矩阵路径> <右投影矩阵路径>" << std
::endl;
return -1;
}
const std
::string leftImagePath = argv[1];
const std
::string rightImagePath = argv[2];
const std
::string leftProjPath = argv[3];
const std
::string rightProjPath = argv[4];
// 1
. 读取影像
cv
::Mat src1 = readImage(leftImagePath);
cv
::Mat src2 = readImage(rightImagePath);
if (src1
.empty() || src2
.empty()) {
std
::cerr << "
错误: 无法读取影像
文件!" << std
::endl;
return -1;
}
// 2
. 从
文件加载投影矩阵
cv
::Mat P1 = loadProjectionMatrix(leftProjPath);
cv
::Mat P2 = loadProjectionMatrix(rightProjPath);
if (P1
.empty() || P2
.empty()) {
std
::cerr << "
错误: 投影矩阵加载失败!" << std
::endl;
return -1;
}
// 3
. 分解投影矩阵并计算相机参数
CameraParams cam1, cam2;
cam1
.imageSize = src1
.size(); // 设置图像尺寸
cam2
.imageSize = src2
.size(); // 设置图像尺寸
// 分解第一个相机的投影矩阵
std
::cout << "
\n==================== 相机1参数分解 ====================
\n";
decomposeProjectionMatrix(P1, cam1
.K, cam1
.R, cam1
.T);
printMatrix("内参矩阵 K1", cam1
.K);
printMatrix("旋转矩阵 R1", cam1
.R);
printMatrix("平移向量 T1", cam1
.T);
// 计算相机中心
cam1
.C = -cam1
.R
.inv() * cam1
.T;
printMatrix("相机中心 C1", cam1
.C);
std
::cout << "=====================================================
\n";
// 分解第二个相机的投影矩阵
std
::cout << "
\n==================== 相机2参数分解 ====================
\n";
decomposeProjectionMatrix(P2, cam2
.K, cam2
.R, cam2
.T);
printMatrix("内参矩阵 K2", cam2
.K);
printMatrix("旋转矩阵 R2", cam2
.R);
printMatrix("平移向量 T2", cam2
.T);
// 计算相机中心
cam2
.C = -cam2
.R
.inv() * cam2
.T;
printMatrix("相机中心 C2", cam2
.C);
std
::cout << "=====================================================
\n";
// 4
. 生成水平核线影像
EpipolarParams h_epi1, h_epi2;
computeHorizontalEpipolarParams(cam1, cam2, src1
.size(), h_epi1, h_epi2);
generateEpi(src1, h_epi1
.H, h_epi1
.size, h_epi1
.filename);
generateEpi(src2, h_epi2
.H, h_epi2
.size, h_epi2
.filename);
std
::cout << "
\n已生成水平核线影像
: "
<< h_epi1
.filename << " 和 " << h_epi2
.filename << std
::endl;
// 5
. 生成竖直核线影像
EpipolarParams v_epi1, v_epi2;
computeVerticalEpipolarParams(cam1, cam2, src1
.size(), v_epi1, v_epi2);
generateEpi(src1, v_epi1
.H, v_epi1
.size, v_epi1
.filename);
generateEpi(src2, v_epi2
.H, v_epi2
.size, v_epi2
.filename);
std
::cout << "已生成竖直核线影像
: "
<< v_epi1
.filename << " 和 " << v_epi2
.filename << std
::endl;
// 6
. 生成最接近原始影像的核线影像
EpipolarParams n_epi1, n_epi2;
computeNearOriginalEpipolarParams(cam1, cam2, src1
.size(), n_epi1, n_epi2);
generateEpi(src1, n_epi1
.H, n_epi1
.size, n_epi1
.filename);
generateEpi(src2, n_epi2
.H, n_epi2
.size, n_epi2
.filename);
std
::cout << "已生成近原始核线影像
: "
<< n_epi1
.filename << " 和 " << n_epi2
.filename << std
::endl;
// 7
. 保存双目参数
saveStereoParams("stereo_params
.txt", cam1, cam2);
return 0;
}
```
###
项目 2
: 深度图与点云生成 (depth_pointcloud_generation
.cpp)
```
cpp
#include <opencv2/opencv
.hpp>
#include <vector>
#include <fstream>
#include <sstream>
#include <map>
#include <string>
// 点云结构体
struct Point3D {
float x, y, z;
uint8_t r, g, b;
};
// 读取双目相机参数
std
::map<std
::string, double> readStereoParams(const std
::string& filename) {
std
::map<std
::string, double> params;
std
::ifstream inFile(filename);
if (!inFile
.is_open()) {
std
::cerr << "
错误: 无法打开参数
文件 " << filename << std
::endl;
return params;
}
std
::string line;
while (std
::getline(inFile, line)) {
// 跳过注释
行和空
行
if (line
.empty() || line[0] == '#') continue;
// 解析键值对
std
::istringstream iss(line);
std
::string key, equals;
double value;
if (iss >> key >> equals >> value) {
if (equals == "=") {
params[key] = value;
}
}
}
inFile
.close();
return params;
}
// 保存点云为PLY格式
void savePointCloudToPLY(const std
::vector<Point3D>& points,
const std
::string& filename) {
std
::ofstream plyFile(filename);
if (!plyFile
.is_open()) {
std
::cerr << "无法创建点云
文件: " << filename << std
::endl;
return;
}
// PLY
文件头
plyFile << "ply
\n";
plyFile << "format ascii 1
.0
\n";
plyFile << "element vertex " << points
.size() << "
\n";
plyFile << "property float x
\n";
plyFile << "property float y
\n";
plyFile << "property float z
\n";
plyFile << "property uchar red
\n";
plyFile << "property uchar green
\n";
plyFile << "property uchar blue
\n";
plyFile << "end_header
\n";
// 写入点数据
for (const auto& p
: points) {
plyFile << p
.x << " " << p
.y << " " << p
.z << " "
<< static_cast<int>(p
.r) << " "
<< static_cast<int>(p
.g) << " "
<< static_cast<int>(p
.b) << "
\n";
}
plyFile
.close();
std
::cout << "点云已保存至
: " << filename
<< " (包含 " << points
.size() << " 个点)" << std
::endl;
}
// 生成深度图和点云
void generateDepthAndPointCloud(
const cv
::Mat& leftImage,
const cv
::Mat& rightImage,
const std
::map<std
::string, double>& params,
const std
::string& outputPrefix = "output")
{
// 检查必要参数是否存在
if (params
.find("baseline") == params
.end() ||
params
.find("focal_length_x") == params
.end()) {
std
::cerr << "
错误: 缺少必要的双目参数" << std
::endl;
return;
}
// 提取参数
const double baseline = params
.at("baseline");
const double fx = params
.at("focal_length_x");
const double fy = params
.at("focal_length_y");
const double cx = params
.at("principal_point_x");
const double cy = params
.at("principal_point_y");
const int width = static_cast<int>(params
.at("image_width"));
const int height = static_cast<int>(params
.at("image_height"));
// 预处理图像
cv
::Mat grayLeft, grayRight;
if (leftImage
.channels() == 3) {
cv
::cvtColor(leftImage, grayLeft, cv
::COLOR_BGR2GRAY);
} else {
grayLeft = leftImage
.clone();
}
if (rightImage
.channels() == 3) {
cv
::cvtColor(rightImage, grayRight, cv
::COLOR_BGR2GRAY);
} else {
grayRight = rightImage
.clone();
}
// 创建立体匹配器 (SGBM算法)
int minDisparity = 0;
int numDisparities = 16 * 5; // 必须是16的倍数
int blockSize = 7; // 匹配窗口大小
cv
::Ptr<cv
::StereoSGBM> sgbm = cv
::StereoSGBM
::create(
minDisparity,
numDisparities,
blockSize,
8 * blockSize * blockSize, // P1
32 * blockSize * blockSize, // P2
1, // 视差图平滑度
63, // 预滤波截断值
10, // 唯一性比值
100, // 斑点窗口大小
32, // 斑点范围
cv
::StereoSGBM
::MODE_SGBM_3WAY);
// 计算视差图
cv
::Mat disparitySGBM, disparity;
sgbm->compute(grayLeft, grayRight, disparitySGBM);
disparitySGBM
.convertTo(disparity, CV_32F, 1
.0 / 16
.0);
// 保存视差图
cv
::Mat dispVis;
cv
::normalize(disparity, dispVis, 0, 255, cv
::NORM_MINMAX, CV_8U);
cv
::imwrite(outputPrefix + "_disparity
.png", dispVis);
// 创建深度图
cv
::Mat depthMap = cv
::Mat
::zeros(height, width, CV_32F);
// 计算深度
: depth = (baseline * fx) / disparity
for (int y = 0; y < height; y++) {
for (int x = 0; x < width; x++) {
float disp = disparity
.at<float>(y, x);
if (disp > 0
.0) {
depthMap
.at<float>(y, x) = (baseline * fx) / disp;
}
}
}
// 保存深度图
cv
::Mat depthVis;
cv
::normalize(depthMap, depthVis, 0, 255, cv
::NORM_MINMAX, CV_8U);
cv
::applyColorMap(depthVis, depthVis, cv
::COLORMAP_JET);
cv
::imwrite(outputPrefix + "_depth
.png", depthVis);
// 生成点云
std
::vector<Point3D> pointCloud;
for (int y = 0; y < depthMap
.rows; y++) {
for (int x = 0; x < depthMap
.cols; x++) {
float depth = depthMap
.at<float>(y, x);
if (depth > 0
.1 && depth < 100
.0) { // 有效深度范围
// 计算3D坐标 (相机坐标系)
float z = depth;
float x3d = (x - cx) * z / fx;
float y3d = (y - cy) * z / fy;
// 获取颜色 (如果原图是彩色)
uint8_t r = 255, g = 255, b = 255; // 默认白色
if (leftImage
.channels() == 3) {
cv
::Vec3b color = leftImage
.at<cv
::Vec3b>(y, x);
r = color[2]; g = color[1]; b = color[0];
} else if (leftImage
.channels() == 1) {
uint8_t gray = leftImage
.at<uint8_t>(y, x);
r = g = b = gray;
}
pointCloud
.push_back({x3d, y3d, z, r, g, b});
}
}
}
// 保存点云
savePointCloudToPLY(pointCloud, outputPrefix + "_pointcloud
.ply");
}
int main(int argc, char** argv) {
// 检查命令
行参数
if (argc != 4) {
std
::cerr << "用法
: " << argv[0] << " <左核线图像路径> <右核线图像路径> <双目参数
文件路径>" << std
::endl;
return -1;
}
const std
::string leftEpiPath = argv[1];
const std
::string rightEpiPath = argv[2];
const std
::string paramsPath = argv[3];
// 1
. 读取核线影像
cv
::Mat leftImage = cv
::imread(leftEpiPath, cv
::IMREAD_ANYCOLOR);
cv
::Mat rightImage = cv
::imread(rightEpiPath, cv
::IMREAD_ANYCOLOR);
if (leftImage
.empty() || rightImage
.empty()) {
std
::cerr << "
错误: 无法读取核线影像
文件!" << std
::endl;
return -1;
}
// 2
. 读取双目参数
auto params = readStereoParams(paramsPath);
if (params
.empty()) {
std
::cerr << "
错误: 无法读取双目参数
文件!" << std
::endl;
return -1;
}
// 3
. 生成深度图和点云
std
::cout << "
\n开始生成深度图和点云
..." << std
::endl;
generateDepthAndPointCloud(leftImage, rightImage, params, "output");
std
::cout << "深度图和点云已生成!" << std
::endl;
return 0;
}
```
### 关键修复
说明：
1
. **修复 CameraParams 结构体**：
```
cpp
struct CameraParams {
cv
::Mat K; // 内参矩阵
cv
::Mat R; // 旋转矩阵
cv
::Mat T; // 平移向量
cv
::Mat C; // 相机中心
cv
::Size imageSize; // 添加图像尺寸成员
};
```
- 添加了 `imageSize` 成员，类型为 `cv
::Size`
- 保留了所有必要的相机参数
2
. **设置图像尺寸**：
```
cpp
// 在main函数中
CameraParams cam1, cam2;
cam1
.imageSize = src1
.size(); // 设置图像尺寸
cam2
.imageSize = src2
.size(); // 设置图像尺寸
```
3
. **参数
文件使用**：
```
cpp
// 在保存参数时使用imageSize
outFile << "image_width = " << cam1
.imageSize
.width << "
\n";
outFile << "image_height = " << cam1
.imageSize
.height << "
\n";
```
4
. **深度图生成使用尺寸**：
```
cpp
// 在深度图生成函数中
const int width = static_cast<int>(params
.at("image_width"));
const int height = static_cast<int>(params
.at("image_height"));
cv
::Mat depthMap = cv
::Mat
::zeros(height, width, CV_32F);
```
### 编译和运
行指南
**
项目1
: 核线影像生成**
```bash
# 编译
g++ epipolar_generation
.cpp -o epipolar_gen
\
-I/path/to/opencv/include
\
-L/path/to/opencv/lib
\
-lopencv_core -lopencv_imgproc -lopencv_imgcodecs -lopencv_calib3d
# 运
行
./epipolar_gen left_image
.tif right_image
.tif left_proj
.txt right_proj
.txt
```
**
项目2
: 深度图与点云生成**
```bash
# 编译
g++ depth_pointcloud_generation
.cpp -o depth_pc_gen
\
-I/path/to/opencv/include
\
-L/path/to/opencv/lib
\
-lopencv_core -lopencv_imgproc -lopencv_imgcodecs -lopencv_calib3d
# 运
行
./depth_pc_gen horizontal_epi_left
.tif horizontal_epi_right
.tif stereo_params
.txt
```
### 输出
文件说明
1
. **核线影像生成
项目输出**：
- `horizontal_epi_left
.tif` / `horizontal_epi_right
.tif`：水平核线影像
- `vertical_epi_left
.tif` / `vertical_epi_right
.tif`：竖直核线影像
- `near_original_epi_left
.tif` / `near_original_epi_right
.tif`：近原始核线影像
- `stereo_params
.txt`：双目相机参数
文件
2
. **深度图生成
项目输出**：
- `output_disparity
.png`：视差图可视化
- `output_depth
.png`：深度图可视化（伪彩色）
- `output_pointcloud
.ply`：三维点云
文件
### 参数
文件示例 (stereo_params
.txt)
```txt
# 双目相机参数配置
文件
# 格式
: 参数名 = 值
baseline = 0
.1205
focal_length_x = 1520
.34
focal_length_y = 1520
.34
principal_point_x = 960
.0
principal_point_y = 540
.0
image_width = 1920
image_height = 1080
```
这个修复方案确保了 `CameraParams` 结构体包含所需的 `imageSize` 成员，同时保持了两个
项目的独立性和完整性。
---
本文解决了一个关于Duilib库在使用高版本Visual Studio时出现的错误问题，通过移除中文注释即可避免错误发生。
扫一扫
2357
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
