// A recursive function that accepts an array of integers
// and length and returns the highest common divisor of them.
int hcd(int *vals, int length) {
if (length==2) {
// HCD of two numbers using euclid's algorithm.
int m,n;
m = vals[0];
n = vals[1];
while (m > 0) {
int temp = m;
m = n % m;
n = temp;
}
return n;
}
else if (length > 2) {
// using identity that hcd(a,b,c,..) = hcd(a,hcd(b,c,..))
int vals2[2];
vals2[0]=vals[0];
// hcd of tail of array.
vals2[1]=hcd((vals + 1),length-1);
// finally, hcd of result of hcd and head of array.
return hcd(vals2,2);
}
// There was an error.
else return -1;
}
int main(int argc, char *argv[]) {
// Don't make me laugh.
if (argc<=2) {
return 1;
}
else {
int highest, i;
int *nums;
// nums is an array of the values to process.
nums = (int*)calloc(argc-1,sizeof(int));
// let's populate the nums array.
for (i = 1; i < argc; i++) {
*(nums + i - 1) = atoi(argv[i]);
}
// highest = number of bags.
highest = hcd(nums,argc-1);
// (if we didn't mess up somewhere)
if( highest>0) {
int i, n, sum;
// sum: number of sweets per bag.
sum = 0;
n = argc - 1;
for (i=0; i < n; i++) {
sum += nums[i] / highest;
}
// there you go.
printf("%i %i\n",highest,sum);
}
else return 1;
}
return 0;
}
int main(int argc, char *argv[])
{
std::string img0_str, img1_str;
if(argc == 3) {
img0_str = argv[1];
img1_str = argv[2];
} else {
img0_str = "../data/input/features/balcony_0.png";
img1_str = "../data/input/augmented_reality/desk.png";
}
//computing K matrix from manufacturer data
double fx = pic::getFocalLengthPixels(3.3, 3.8, 2592.0);
double fy = pic::getFocalLengthPixels(3.3, 2.9, 1936.0);
Eigen::Matrix3d K = pic::getIntrinsicsMatrix(fx, fy, 2592.0 / 2.0, 1936.0 / 2.0);
printf("Reading LDR images...");
pic::Image img0, img1;
img0.Read(img0_str, pic::LT_NOR);
img1.Read(img1_str, pic::LT_NOR);
printf("Ok\n");
printf("Are they both valid? ");
if(img0.isValid() && img1.isValid()) {
printf("OK\n");
//output corners
std::vector< Eigen::Vector2f > corners_from_img0;
std::vector< Eigen::Vector2f > corners_from_img1;
//compute the luminance images
pic::Image *L0 = pic::FilterLuminance::Execute(&img0, NULL, pic::LT_CIE_LUMINANCE);
pic::Image *L1 = pic::FilterLuminance::Execute(&img1, NULL, pic::LT_CIE_LUMINANCE);
//get corners
printf("Extracting corners...\n");
pic::HarrisCornerDetector hcd(2.5f, 5);
hcd.execute(L0, &corners_from_img0);
hcd.getCornersImage(&corners_from_img0, NULL, L0->width, L0->height, true)->Write("../test1.bmp");
hcd.execute(L1, &corners_from_img1);
hcd.getCornersImage(&corners_from_img1, NULL, L1->width, L1->height, true)->Write("../test2.bmp");
//compute ORB descriptors for each corner and image
//compute luminance images
pic::Image *L0_flt = pic::FilterGaussian2D::Execute(L0, NULL, 2.5f);
pic::Image *L1_flt = pic::FilterGaussian2D::Execute(L1, NULL, 2.5f);
printf("Computing ORB descriptors...\n");
//pic::PoissonDescriptor b_desc(16);
pic::ORBDescriptor b_desc(31, 512);
std::vector< unsigned int *> descs0;
b_desc.getAll(L0_flt, corners_from_img0 , descs0);
std::vector< unsigned int *> descs1;
b_desc.getAll(L1_flt, corners_from_img1 , descs1);
printf("Matching ORB descriptors...\n");
int n = b_desc.getDescriptorSize();
pic::BinaryFeatureBruteForceMatcher bfm(&descs1, n);
printf("Descriptor size: %d\n", n);
printf("Matching...");
std::vector< Eigen::Vector3i > matches;
bfm.getAllMatches(descs0, matches);
printf(" we found %d matches ", matches.size());
printf("Ok\n");
//filter
std::vector< Eigen::Vector2f > m0, m1;
pic::BinaryFeatureMatcher::filterMatches(corners_from_img0, corners_from_img1, matches, m0, m1);
printf("Estimating a homography matrix H from the matches...");
std::vector< unsigned int > inliers;
Eigen::Matrix3d H = pic::estimateHomographyWithNonLinearRefinement(m0, m1, inliers, 10000, 2.5f, 1, 10000, 1e-5f);
Eigen::Matrix34d cam = pic::getCameraMatrixFromHomography(H, K);
img1 *= 0.25f;
//Augmentation: drawing a 3D grid
int res = 10;
for(int i=1;i<(res + 1);i++) {
float u = float(i) / 50.0f;
for(int j=1;j<(res + 1);j++) {
float v = float(j) / 50.0f;
Eigen::Vector4d point(u, v, 0.0f, 1.0f);
Eigen::Vector2i coord = pic::cameraMatrixProject(cam, point);
float *tmp = img1(coord[0], coord[1]);
tmp[0] = 1.0f;
tmp[1] = 0.25f;
tmp[2] = 0.25f;
}
}
//Augmentation: drawing 3D axis
Eigen::Vector4d p0(0.0, 0.0, 0.0, 1.0);
Eigen::Vector2i coord0 = pic::cameraMatrixProject(cam, p0);
Eigen::Vector4d p1(0.2, 0.0, 0.0, 1.0);
Eigen::Vector2i coord1 = pic::cameraMatrixProject(cam, p1);
Eigen::Vector4d p2(0.0, 0.2, 0.0, 1.0);
Eigen::Vector2i coord2 = pic::cameraMatrixProject(cam, p2);
Eigen::Vector4d p3(0.0, 0.0, 0.2, 1.0);
Eigen::Vector2i coord3 = pic::cameraMatrixProject(cam, p3);
float color[]={0.25f, 1.0f, 0.25f};
pic::drawLine(&img1, pic::convertFromEigenToVec(coord0), pic::convertFromEigenToVec(coord1), color);
pic::drawLine(&img1, pic::convertFromEigenToVec(coord0), pic::convertFromEigenToVec(coord2), color);
pic::drawLine(&img1, pic::convertFromEigenToVec(coord0), pic::convertFromEigenToVec(coord3), color);
img1.Write("../data/output/simple_augmented_reality.png", pic::LT_NOR);
} else {
printf("No, there is at least an invalid file!\n");
}
return 0;
}
