diff --git a/apps/specular_estimation/CMakeFiles/specular_estimation.dir/src/PhotometricStereo.cc.o b/apps/specular_estimation/CMakeFiles/specular_estimation.dir/src/PhotometricStereo.cc.o
index fadb42bda7c2ea136bf434869d06753e8271ca11..540ba83948787cdb8abf565161409a49e31d4306 100644
Binary files a/apps/specular_estimation/CMakeFiles/specular_estimation.dir/src/PhotometricStereo.cc.o and b/apps/specular_estimation/CMakeFiles/specular_estimation.dir/src/PhotometricStereo.cc.o differ
diff --git a/apps/specular_estimation/CMakeFiles/specular_estimation.dir/src/specular_estimation.cc.o b/apps/specular_estimation/CMakeFiles/specular_estimation.dir/src/specular_estimation.cc.o
index dfc38612e7ed82561406f9c68d1a6fa660a8d93b..374201375dab997b7a111a5c3b3e0519d7d34f82 100644
Binary files a/apps/specular_estimation/CMakeFiles/specular_estimation.dir/src/specular_estimation.cc.o and b/apps/specular_estimation/CMakeFiles/specular_estimation.dir/src/specular_estimation.cc.o differ
diff --git a/apps/specular_estimation/src/Charuco.h b/apps/specular_estimation/src/Charuco.h
index 3441706c9694f5257ded48f5554ac9c0b5764b3c..57fbcecb2e4ba244ec9014adc5a1984a8a22cb2b 100644
--- a/apps/specular_estimation/src/Charuco.h
+++ b/apps/specular_estimation/src/Charuco.h
@@ -27,6 +27,7 @@ void detectArucoMarkers(int dictionaryId, bool showRejected, bool estimatePose,
void createArucoDictionary(std::vector< cv::Mat >& arucoMarkers, int dictionaryId);
cv::Mat drawCharuco(cv::Ptr<cv::aruco::CharucoBoard> board, int rows, int cols, bool saveCharuco, bool displayCharuco);
void calibrateCamera(int squaresX, int squaresY, float squareLength, float markerLength, int dictionaryId, std::vector<cv::Mat> charucoImages, cv::Mat& cameraMatrix, cv::Mat& distCoeffs);
+void calibrateCamera(std::string charucoPath, cv::Mat& cameraMatrix, cv::Mat& distortionCoefficients);
void loadCharucoImages(std::vector< cv::Mat >& charucoImages, std::string charucoPath, std::string charucoName);
void undistortCharuco(cv::Ptr<cv::aruco::CharucoBoard> board, cv::Mat inputImage, cv::Mat boardImage, cv::Mat& undistortedCharuco, cv::Mat cameraMatrix, cv::Mat distortionCoefficients, cv::Vec3d& rvec, cv::Vec3d& tvec, cv::Mat& perspectiveTransform, bool displayUndistortedCharuco);
@@ -428,7 +429,7 @@ void estimatePoseFromCharuco(cv::Ptr<cv::aruco::CharucoBoard> board, cv::Mat inp
}
}
-void calibrateCamera(int squaresX, int squaresY, float squareLength, float markerLength, int dictionaryId, std::vector< cv::Mat > charucoImages, cv::Mat& cameraMatrix, cv::Mat& distortionCoefficients) {
+void calibrateCamera(int squaresX, int squaresY, float squareLength, float markerLength, int dictionaryId, std::vector<cv::Mat> charucoImages, cv::Mat& cameraMatrix, cv::Mat& distortionCoefficients) {
std::string outputFile = "cameraCalibration";
@@ -586,6 +587,180 @@ void calibrateCamera(int squaresX, int squaresY, float squareLength, float marke
}
}
+
+void calibrateCamera(std::string charucoPath, cv::Mat& cameraMatrix, cv::Mat& distortionCoefficients) {
+
+ // Load a premade dictionary of ArUco markers
+ int dictionaryId = 0;
+ //cv::Ptr<cv::aruco::Dictionary> dictionary = cv::aruco::getPredefinedDictionary(cv::aruco::PREDEFINED_DICTIONARY_NAME(dictionaryId));
+
+ // Create a ChArUco board
+ int squaresX = 11;
+ int squaresY = 9;
+ float squareLength = 0.04f;
+ float markerLength = 0.02f;
+ //cv::Ptr<cv::aruco::CharucoBoard> charucoBoard = cv::aruco::CharucoBoard::create(squaresX, squaresY, squareLength, markerLength, dictionary);
+
+ std::cout << "Loading ChArUco images.\n";
+ std::vector<cv::Mat> charucoImages = loadImages(charucoPath);
+
+ std::string outputFile = "cameraCalibration";
+
+ bool showChessboardCorners = false;
+
+ int calibrationFlags = 0;
+ float aspectRatio = 1;
+
+ bool zt = true; // Assume zero tangential distortion
+ bool pc = true; // Fix the principal point at the center
+
+ if (zt) calibrationFlags |= cv::CALIB_ZERO_TANGENT_DIST;
+ if (pc) calibrationFlags |= cv::CALIB_FIX_PRINCIPAL_POINT;
+
+ cv::Ptr<cv::aruco::DetectorParameters> detectorParams = cv::aruco::DetectorParameters::create();
+
+ bool refindStrategy = false; // Apply refind strategy
+ int camId = 0; // Camera id if input doesnt come from video (-v)
+ cv::String video;
+
+ cv::VideoCapture inputVideo;
+ int waitTime = 0;
+
+ cv::Ptr<cv::aruco::Dictionary> dictionary = cv::aruco::getPredefinedDictionary(cv::aruco::PREDEFINED_DICTIONARY_NAME(dictionaryId));
+
+ // create charuco board object
+ cv::Ptr<cv::aruco::CharucoBoard> charucoboard = cv::aruco::CharucoBoard::create(squaresX, squaresY, squareLength, markerLength, dictionary);
+ cv::Ptr<cv::aruco::Board> board = charucoboard.staticCast<cv::aruco::Board>();
+
+ // collect data from each frame
+ std::vector< std::vector< std::vector< cv::Point2f > > > allCorners;
+ std::vector< std::vector< int > > allIds;
+ std::vector< cv::Mat > allImgs;
+ cv::Size imgSize;
+
+ for (unsigned int i = 0; i < charucoImages.size(); i++) {
+ cv::Mat imageCopy;
+
+ std::vector< int > ids;
+ std::vector< std::vector< cv::Point2f > > corners, rejected;
+
+ // detect markers
+ cv::aruco::detectMarkers(charucoImages[i], dictionary, corners, ids, detectorParams, rejected);
+
+ // refind strategy to detect more markers
+ if (refindStrategy) cv::aruco::refineDetectedMarkers(charucoImages[i], board, corners, ids, rejected);
+
+ // interpolate charuco corners
+ cv::Mat currentCharucoCorners, currentCharucoIds;
+ if (ids.size() > 0) {
+ cv::aruco::interpolateCornersCharuco(corners, ids, charucoImages[i], charucoboard, currentCharucoCorners, currentCharucoIds);
+ }
+
+ // draw results
+ charucoImages[i].copyTo(imageCopy);
+ if (ids.size() > 0) {
+ cv::aruco::drawDetectedMarkers(imageCopy, corners);
+ }
+
+ if (currentCharucoCorners.total() > 0) {
+ cv::aruco::drawDetectedCornersCharuco(imageCopy, currentCharucoCorners, currentCharucoIds);
+ }
+
+ //cv::putText(charucoImages[i], "Press 'c' to add current frame. 'ESC' to finish and calibrate", cv::Point(10, 20), cv::FONT_HERSHEY_SIMPLEX, 0.5, cv::Scalar(255, 0, 0), 2);
+
+ //cv::namedWindow( "Camera Calibration", cv::WINDOW_NORMAL );
+ //cv::imshow("Camera Calibration", imageCopy);
+
+ if (ids.size() > 0) {
+ allCorners.push_back(corners);
+ allIds.push_back(ids);
+ allImgs.push_back(charucoImages[i]);
+ imgSize = charucoImages[i].size();
+ }
+
+ //cv::waitKey(0);
+ }
+
+ if (allIds.size() < 1) {
+ std::cerr << "Not enough captures for calibration" << std::endl;
+ return;
+ }
+
+ std::vector< cv::Mat > rvecs, tvecs;
+ double repError;
+
+ if (calibrationFlags & cv::CALIB_FIX_ASPECT_RATIO) {
+ cameraMatrix = cv::Mat::eye(3, 3, CV_64F);
+ cameraMatrix.at< double >(0, 0) = aspectRatio;
+ }
+
+ // prepare data for calibration
+ std::vector< std::vector< cv::Point2f > > allCornersConcatenated;
+ std::vector< int > allIdsConcatenated;
+ std::vector< int > markerCounterPerFrame;
+ markerCounterPerFrame.reserve(allCorners.size());
+ for (unsigned int i = 0; i < allCorners.size(); i++) {
+ markerCounterPerFrame.push_back((int)allCorners[i].size());
+ for (unsigned int j = 0; j < allCorners[i].size(); j++) {
+ allCornersConcatenated.push_back(allCorners[i][j]);
+ allIdsConcatenated.push_back(allIds[i][j]);
+ }
+ }
+
+ // calibrate camera using aruco markers
+ double arucoRepErr;
+ arucoRepErr = cv::aruco::calibrateCameraAruco(allCornersConcatenated, allIdsConcatenated, markerCounterPerFrame, board, imgSize, cameraMatrix, distortionCoefficients, cv::noArray(), cv::noArray(), calibrationFlags);
+
+ // prepare data for charuco calibration
+ int nFrames = (int)allCorners.size();
+ std::vector< cv::Mat > allCharucoCorners;
+ std::vector< cv::Mat > allCharucoIds;
+ std::vector< cv::Mat > filteredImages;
+ allCharucoCorners.reserve(nFrames);
+ allCharucoIds.reserve(nFrames);
+
+ for (int i = 0; i < nFrames; i++) {
+ // interpolate using camera parameters
+ cv::Mat currentCharucoCorners, currentCharucoIds;
+ cv::aruco::interpolateCornersCharuco(allCorners[i], allIds[i], allImgs[i], charucoboard, currentCharucoCorners, currentCharucoIds, cameraMatrix, distortionCoefficients);
+
+ allCharucoCorners.push_back(currentCharucoCorners);
+ allCharucoIds.push_back(currentCharucoIds);
+ filteredImages.push_back(allImgs[i]);
+ }
+
+ if (allCharucoCorners.size() < 4) {
+ std::cerr << "Not enough corners for calibration" << std::endl;
+ return;
+ }
+
+ // calibrate camera using charuco
+ repError = cv::aruco::calibrateCameraCharuco(allCharucoCorners, allCharucoIds, charucoboard, imgSize, cameraMatrix, distortionCoefficients, rvecs, tvecs, calibrationFlags);
+
+ //saveCameraParams(outputFile, imgSize, aspectRatio, calibrationFlags, cameraMatrix, distortionCoefficients, repError);
+
+ std::cout << "Rep Error: " << repError << std::endl;
+ std::cout << "Rep Error Aruco: " << arucoRepErr << std::endl;
+ //std::cout << "Calibration saved to " << outputFile << std::endl;
+
+ // show interpolated charuco corners for debugging
+ if (showChessboardCorners) {
+ for (unsigned int frame = 0; frame < filteredImages.size(); frame++) {
+ cv::Mat imageCopy = filteredImages[frame].clone();
+ if (allIds[frame].size() > 0) {
+
+ if (allCharucoCorners[frame].total() > 0) {
+ cv::aruco::drawDetectedCornersCharuco(imageCopy, allCharucoCorners[frame], allCharucoIds[frame]);
+ }
+ }
+
+ cv::namedWindow("Interpolated ChArUco Markers", cv::WINDOW_NORMAL);
+ cv::imshow("Interpolated ChArUco Markers", imageCopy);
+ }
+ }
+}
+
+
void loadCharucoImages(std::vector< cv::Mat >& charucoImages, std::string charucoPath, std::string charucoName) {
bool loadedImages = false;
int imageNumber = 0;
diff --git a/apps/specular_estimation/src/OpenCV.h b/apps/specular_estimation/src/OpenCV.h
index e7db8a89c2322f070ab42d7cc9b123159970a815..2522596a07aca30d73b549ae61e86da8aea2d2df 100644
--- a/apps/specular_estimation/src/OpenCV.h
+++ b/apps/specular_estimation/src/OpenCV.h
@@ -639,14 +639,15 @@ std::vector<cv::Mat> loadMaterialImages(std::string modelPath, int& originalWidt
}
else {
+ originalWidth = materialImage.cols;
+ originalHeight = materialImage.rows;
+
if (imageScale > 1) {
cv::resize(materialImage, materialImage, cv::Size(), 1.0 / imageScale, 1.0 / imageScale, cv::INTER_AREA);
}
materialImages.push_back(materialImage);
-
imageNumber++;
-
std::cout << "Loaded material image " << imageNumber << std::endl;
}
}
diff --git a/apps/specular_estimation/src/PhotometricStereo.cc b/apps/specular_estimation/src/PhotometricStereo.cc
index 5e60d16154bdd8aac5fb128aea30a06f0b632988..2a9c06ea133a4497dfafe05b73acb8d37b12be09 100755
--- a/apps/specular_estimation/src/PhotometricStereo.cc
+++ b/apps/specular_estimation/src/PhotometricStereo.cc
@@ -181,24 +181,38 @@ photometricStereo::photometricStereo(int n, int startI, int endI, std::string pa
}
photometricStereo::photometricStereo(int imageNumber, std::string modelPath, std::string calibrationPath, std::string macbethPath, std::string imageName, std::string calibration, double discardRatio): mDiscardRatio(discardRatio), imageNum(imageNumber) {
-
- mp2Images = readImages(modelPath);
+ int imageScale = 4;
+ mp2Images = readImages(modelPath, imageScale);
std::cout << "Loaded material images.\n";
- mp2CalibrationImages = readImages(calibrationPath);
+ mp2CalibrationImages = readImages(calibrationPath, imageScale);
std::cout << "Loaded calibration images.\n";
- mp2MacbethImages = readImages(macbethPath);
- std::cout << "Loaded macbeth images.\n";
+ //mp2MacbethImages = readImages(macbethPath);
+ //std::cout << "Loaded macbeth images.\n";
+
+ width = mp2Images[0].cols;
+ height = mp2Images[0].rows;
std::string maskName = calibrationPath + "mask.png";
cv::Mat p2Mask = cv::imread(maskName, cv::IMREAD_GRAYSCALE);
+ if (imageScale != 1)
+ cv::resize(p2Mask, p2Mask, cv::Size(), 1.0 / imageScale, 1.0 / imageScale, cv::INTER_AREA);
mp2Mask.push_back(p2Mask);
mMaskNames.push_back(maskName);
+
+
maskName = calibrationPath + "white.png";
p2Mask = cv::imread(maskName, cv::IMREAD_GRAYSCALE);
+ if (imageScale != 1)
+ cv::resize(p2Mask, p2Mask, cv::Size(), 1.0 / imageScale, 1.0 / imageScale, cv::INTER_AREA);
mp2Mask.push_back(p2Mask);
mMaskNames.push_back(maskName);
}
+photometricStereo::photometricStereo(std::vector<cv::Mat> mp2Images, std::vector<cv::Mat> mp2CalibrationImages, std::vector<cv::Mat> mp2Mask, int imageNumber, double discardRatio): mDiscardRatio(discardRatio), imageNum(imageNumber) {
+ width = mp2Images[0].cols;
+ height = mp2Images[0].rows;
+}
+
/*
photometricStereo::photometricStereo(int imageNumber, std::string modelPath, std::string calibrationPath, std::string macbethPath, std::string imageName, std::string calibration, double discardRatio): mDiscardRatio(discardRatio), imageNum(imageNumber) {
bool loadedImages = false;
@@ -334,7 +348,7 @@ bool photometricStereo::readImage() {
return true;
}
-std::vector<cv::Mat> photometricStereo::readImages(std::string path) {
+std::vector<cv::Mat> photometricStereo::readImages(std::string path, int imageScale = 1) {
std::vector<cv::Mat> images;
bool loadedImages = false;
@@ -357,6 +371,9 @@ std::vector<cv::Mat> photometricStereo::readImages(std::string path) {
loadedImages = true;
}
else {
+ if (imageScale != 1) {
+ cv::resize(image, image, cv::Size(), 1.0 / imageScale, 1.0 / imageScale, cv::INTER_AREA);
+ }
images.push_back(image);
imageNumber++;
//std::cout << "Loaded image " << imageNumber << std::endl;
@@ -510,15 +527,16 @@ void photometricStereo::getLightInformation(const int metalIndex) {
double lightIntensity;
//detectMacbeth(mMacbethNames[0]);
- cv::minMaxLoc(mp2MacbethImages[i], NULL, &lightIntensity, NULL, NULL);
+ //cv::minMaxLoc(mp2MacbethImages[i], NULL, &lightIntensity, NULL, NULL);
+ lightIntensity = 1;
m_light[i].mIntensity = lightIntensity;
//m_light[i].mIntensity = macbethIntensity[i];
//std::cout << "Light intensity: " << m_light[i].mIntensity << std::endl;
}
}
-// calculate the norm and albedo for every pixel
-// here, threshold is for the dark discard
+// calculate the normal and albedo for every pixel
+// threshold is for the dark discard
void photometricStereo::getPixelNormAndAlbedo(const int objectIndex, cv::Mat lightDirections) {
// calculate the pixel num
//std::vector<double> pixelThreshold;
@@ -640,21 +658,21 @@ void photometricStereo::getPixelNormAndAlbedo(const int objectIndex, cv::Mat lig
}
}
-// calculate the norm and albedo for every pixel
-// here, threshold is for the dark discard
+// calculate the normal and albedo for every pixel
+// threshold is for the dark discard
void photometricStereo::getPixelNormAndAlbedo(const int objectIndex) {
// calculate the pixel num
//std::vector<double> pixelThreshold;
for(int i = 0; i < mp2Mask[objectIndex].rows; i++) {
for(int j = 0; j < mp2Mask[objectIndex].cols; j++) {
- if(mp2Mask[objectIndex].at<unsigned char>(i, j) >= 255) {
+ //if(mp2Mask[objectIndex].at<unsigned char>(i, j) == 255) {
mObjectX.push_back(j);
mObjectY.push_back(i);
- }
+ //}
}
}
- //std::cout << "Calculated the pixel coordinates within the mask\n";
+ std::cout << "Calculated the pixel coordinates within the mask\n";
std::vector<std::vector<double>> allPixelValue;
allPixelValue.reserve(imageNum);
@@ -668,7 +686,7 @@ void photometricStereo::getPixelNormAndAlbedo(const int objectIndex) {
}
}
- //std::cout << "Store all pixel values in a vector\n";
+ std::cout << "Store all pixel values in a vector\n";
// threshold for every image;
std::vector<double> allThreshold;
@@ -680,7 +698,7 @@ void photometricStereo::getPixelNormAndAlbedo(const int objectIndex) {
quickSelect(tmpPixelValue, 0, objectPixelNum - 1, thresholdIndex));
}
- //std::cout << "Threshold for every image\n";
+ std::cout << "Threshold for every image\n";
mN.create(3, objectPixelNum, CV_64F);
mAlbedo.create(1, objectPixelNum, CV_64F);
diff --git a/apps/specular_estimation/src/PhotometricStereo.h b/apps/specular_estimation/src/PhotometricStereo.h
index b0ae968cbfd8af516bb2a1bcb1b14b931c265767..e759ccaf011c3f7d562fe5d22f2ab1b8020fa281 100755
--- a/apps/specular_estimation/src/PhotometricStereo.h
+++ b/apps/specular_estimation/src/PhotometricStereo.h
@@ -34,12 +34,13 @@ class photometricStereo {
// use image with equal distance
photometricStereo(int n, int startI, int endI, std::string path, std::string metal1Phere1Name, std::string metal2Phere1Name, std::string lambertPhereName, std::string objectName, double discardRatio = 0.1);
photometricStereo(int imageNumber, std::string modelPath, std::string calibrationPath, std::string macbethPath, std::string imageName, std::string calibration, double discardRatio = 0.1);
+ photometricStereo(std::vector<cv::Mat> mp2Images, std::vector<cv::Mat> mp2CalibrationImages, std::vector<cv::Mat> mp2Mask, int imageNumber = 0, double discardRatio = 0.1);
photometricStereo(const photometricStereo&) = delete;
photometricStereo& operator = (const photometricStereo&) = delete;
~photometricStereo();
bool readImage(); // read the images and masks according to the ImageNames
bool readImage(std::string modelPath, std::string calibrationPath, std::string macbethPath);
- std::vector<cv::Mat> readImages(std::string path);
+ std::vector<cv::Mat> readImages(std::string path, int imageScale);
void getLightInformation(const int metalIndex, const int lambIndex);
void getLightInformation(const int metalIndex);
void getPixelNormAndAlbedo(const int objectIndex);
@@ -81,6 +82,8 @@ class photometricStereo {
std::string calibrationPath;
std::string imageName;
std::string calibration;
+ int width;
+ int height;
};
}
diff --git a/apps/specular_estimation/src/specular_estimation.cc b/apps/specular_estimation/src/specular_estimation.cc
index f4153d33f4a40a4f0b57cb45c6c34a22640698a2..d9fc1d6503ee125d256765a7d846c3f19cc703d4 100644
--- a/apps/specular_estimation/src/specular_estimation.cc
+++ b/apps/specular_estimation/src/specular_estimation.cc
@@ -56,7 +56,7 @@ void specularEstimation(std::string imageName, std::string calibration, double R
// Define the paths for the model images, calibration images and the albedo
const std::string imagesPath = "/home/thomas/Documents/";
- const std::string folderPath = "2017-12-04";
+ const std::string folderPath = "2018-04-18";
const std::string materialPath = imagesPath + folderPath + "/" + imageName + "/" + imageName + ".";
const std::string calibrationPath = imagesPath + folderPath + "/" + calibration + "/" + calibration + ".";
const std::string charucoPath = imagesPath + folderPath + "/charuco/charuco.";
@@ -65,23 +65,37 @@ void specularEstimation(std::string imageName, std::string calibration, double R
const std::string normalPath = materialPath + "normal.png";
double LightDistance = 1.0, LightIntensity = 1.0, Gain = 1.0, Bias = 0.0;
- int numberOfLights = 6, width = 1092, height = 728;
+ int numberOfLights = 6, width = 1092, height = 732;
cv::Mat residualImage, albedo, normalMap, heightMap;
- std::vector<cv::Mat> materialImages, charucoImages, calibrationImages;
+ std::vector<cv::Mat> materialImages, charucoImages, calibrationImages, mp2Mask;
cv::Mat lightDirections = (cv::Mat_<float>(6,3) << 0.447712, 0.138562, 0.883377, 0.228758, -0.106536, 0.967636, 0.1, 0.0705882, 0.99248, 0.000653595, -0.0718954, 0.997412, -0.139216, -0.12549, 0.982279, -0.494771, 0.115033, 0.861376);
if (!synthetic) {
- int originalWidth, originalHeight, imageScale = 1;
+ int originalWidth, originalHeight, imageScale = 1;
+ cv::Mat cameraMatrix, distortionCoefficients, lightDirectionsPerspective;
+
+ calibrateCamera(charucoPath, cameraMatrix, distortionCoefficients);
+ std::cout << "Camera parameters obtained.\n";
+
+ /*
//std::cout << "Loading material images.\n";
- //materialImages = loadMaterialImages(materialPath, originalWidth, originalHeight, width, height, imageScale);
+ materialImages = loadMaterialImages(materialPath, originalWidth, originalHeight, width, height, imageScale);
//std::cout << "Loading light source calibration images.\n";
- //calibrationImages = loadImages(calibrationPath);
- //numberOfLights = calibrationImages.size();
+ calibrationImages = loadImages(calibrationPath);
+ numberOfLights = calibrationImages.size();
+
+ std::string maskName = calibrationPath + "mask.png";
+ cv::Mat p2Mask = cv::imread(maskName, cv::IMREAD_GRAYSCALE);
+ mp2Mask.push_back(p2Mask);
+ maskName = calibrationPath + "white.png";
+ p2Mask = cv::imread(maskName, cv::IMREAD_GRAYSCALE);
+ //p2Mask = cv::Mat(p2Mask.size(), CV_8U, cv::Scalar(255));
+ mp2Mask.push_back(p2Mask);*/
//cv::Mat lightDirectionsInverted;
- cv::Mat cameraMatrix, distortionCoefficients, lightDirectionsPerspective;
+ //cv::Mat cameraMatrix, distortionCoefficients, lightDirectionsPerspective;
/*cv::Mat lightDirections = (cv::Mat_<float>(6,3) << -0.57735, -0.57735, 0.57735, 0, 0.7071, 0.7071, 0, -0.7071, 0.7071, 0.7071, 0, 0.7071, -0.7071, 0, 0.7071, 0.57735, 0.57735, 0.57735);*/
//cv::invert(lightDirections, lightDirectionsInverted, cv::DECOMP_SVD);
@@ -89,7 +103,9 @@ void specularEstimation(std::string imageName, std::string calibration, double R
//charucoAlignment(charucoPath, charucoImages, materialImages, numberOfLights, width, height, lightDirections, lightDirectionsPerspective, cameraMatrix, distortionCoefficients);
+ //phoSte::photometricStereo PhotometricStereo(materialImages, calibrationImages, mp2Mask, numberOfLights, 0);
phoSte::photometricStereo PhotometricStereo(numberOfLights, materialPath, calibrationPath, macbethPath, imageName, calibration, 0);
+
//PhotometricStereo.readImage(materialPath, calibrationPath, macbethPath);
//cv::Mat calibrationMask = loadCalibrationMask(calibrationPath, height, width);
//calibrationBoundingBox = getBoundingBox(calibrationMask);
diff --git a/bin/specular_estimation b/bin/specular_estimation
index 820d8011d34964bb0333787b0f6523776886cf3b..05d138dc76b37f7b723a99e82ee3c01b97583c7b 100755
Binary files a/bin/specular_estimation and b/bin/specular_estimation differ