ImagePatchRepresentation FeatureExtractor::extractPatches(const std::string& file, double yaw, double pitch)
{
const cv::Mat input = cv::imread(file, 0);
return extractPatches(input, yaw, pitch);
}
void Foam::CV2D::calcDual
(
point2DField& dualPoints,
faceList& dualFaces,
wordList& patchNames,
labelList& patchSizes,
EdgeMap<label>& mapEdgesRegion,
EdgeMap<label>& indirectPatchEdge
) const
{
// Dual points stored in triangle order.
dualPoints.setSize(number_of_faces());
label dualVerti = 0;
for
(
Triangulation::Finite_faces_iterator fit = finite_faces_begin();
fit != finite_faces_end();
++fit
)
{
if
(
fit->vertex(0)->internalOrBoundaryPoint()
|| fit->vertex(1)->internalOrBoundaryPoint()
|| fit->vertex(2)->internalOrBoundaryPoint()
)
{
fit->faceIndex() = dualVerti;
dualPoints[dualVerti++] = toPoint2D(circumcenter(fit));
}
else
{
fit->faceIndex() = -1;
}
}
dualPoints.setSize(dualVerti);
extractPatches(patchNames, patchSizes, mapEdgesRegion, indirectPatchEdge);
forAll(patchNames, patchi)
{
Info<< "Patch " << patchNames[patchi]
<< " has size " << patchSizes[patchi] << endl;
}
// Create dual faces
// ~~~~~~~~~~~~~~~~~
dualFaces.setSize(number_of_vertices());
label dualFacei = 0;
labelList faceVerts(maxNvert);
for
(
Triangulation::Finite_vertices_iterator vit = finite_vertices_begin();
vit != finite_vertices_end();
++vit
)
{
if (vit->internalOrBoundaryPoint())
{
Face_circulator fcStart = incident_faces(vit);
Face_circulator fc = fcStart;
label verti = 0;
do
{
if (!is_infinite(fc))
{
if (fc->faceIndex() < 0)
{
FatalErrorInFunction
<< "Dual face uses vertex defined by a triangle"
" defined by an external point"
<< exit(FatalError);
}
// Look up the index of the triangle
faceVerts[verti++] = fc->faceIndex();
}
} while (++fc != fcStart);
if (faceVerts.size() > 2)
{
dualFaces[dualFacei++] =
face(labelList::subList(faceVerts, verti));
}
else
{
Info<< "From triangle point:" << vit->index()
<< " coord:" << toPoint2D(vit->point())
<< " generated illegal dualFace:" << faceVerts
<< endl;
}
}
}
dualFaces.setSize(dualFacei);
}
int main(int argc, char** argv)
{
THCState *state = (THCState*)malloc(sizeof(THCState));
THCudaInit(state);
if(argc < 3)
{
std::cout << "arguments: [network] [image1] [image2]\n";
return 1;
}
const char *network_path = argv[1];
auto net = loadNetwork(state, network_path);
// load the images
cv::Mat ima = cv::imread(argv[2]);
cv::Mat imb = cv::imread(argv[3]);
if(ima.empty() || imb.empty())
{
std::cout << "images not found\n";
return 1;
}
cv::Mat ima_gray, imb_gray;
cv::cvtColor(ima, ima_gray, cv::COLOR_BGR2GRAY);
cv::cvtColor(imb, imb_gray, cv::COLOR_BGR2GRAY);
// Here we set min_area parameter to a bigger value, like that minimal size
// of a patch will be around 11x11, because the network was trained on bigger patches
// this parameter is important in practice
cv::Ptr<cv::MSER> detector = cv::MSER::create(5, 620);
std::vector<cv::KeyPoint> kpa, kpb;
detector->detect(ima_gray, kpa);
detector->detect(imb_gray, kpb);
std::cout << "image A MSER points detected: " << kpa.size() << std::endl;
std::cout << "image B MSER points detected: " << kpb.size() << std::endl;
std::vector<cv::Mat> patches_a, patches_b;
extractPatches(ima_gray, kpa, patches_a);
extractPatches(imb_gray, kpb, patches_b);
cv::Mat descriptors_a, descriptors_b;
extractDescriptors(state, net, patches_a, descriptors_a);
extractDescriptors(state, net, patches_b, descriptors_b);
cv::FlannBasedMatcher matcher;
std::vector<cv::DMatch> matches;
matcher.match( descriptors_a, descriptors_b, matches );
double max_dist = 0; double min_dist = 100;
//-- Quick calculation of max and min distances between keypoints
for( int i = 0; i < descriptors_a.rows; i++ )
{ double dist = matches[i].distance;
if( dist < min_dist ) min_dist = dist;
if( dist > max_dist ) max_dist = dist;
}
printf("-- Max dist : %f \n", max_dist );
printf("-- Min dist : %f \n", min_dist );
std::vector<cv::DMatch> good_matches;
for( int i = 0; i < descriptors_a.rows; i++ )
{ if( matches[i].distance <= std::max(4*min_dist, 0.02) )
{ good_matches.push_back( matches[i]); }
}
//-- Draw only "good" matches
float f = 0.25;
cv::resize(ima, ima, cv::Size(), f, f);
cv::resize(imb, imb, cv::Size(), f, f);
for(auto &it: kpa) { it.pt *= f; it.size *= f; }
for(auto &it: kpb) { it.pt *= f; it.size *= f; }
cv::Mat img_matches;
cv::drawMatches( ima, kpa, imb, kpb,
good_matches, img_matches, cv::Scalar::all(-1), cv::Scalar::all(-1),
std::vector<char>(), cv::DrawMatchesFlags::NOT_DRAW_SINGLE_POINTS );
for(auto &it : kpa)
cv::circle(ima, cv::Point(it.pt.x, it.pt.y), it.size, cv::Scalar(255,255,0));
for(auto &it : kpb)
cv::circle(imb, cv::Point(it.pt.x, it.pt.y), it.size, cv::Scalar(255,255,0));
cv::imshow("matches", img_matches);
//cv::imshow("keypoints image 1", ima);
//cv::imshow("keypoints image 2", imb);
cv::waitKey();
THCudaShutdown(state);
return 0;
}
