int zipfile_delete_files (const char *targ, const char **filenames,
ZipOption opt, GError **gerr)
{
zfile zf;
gchar *matches = NULL;
int err;
g_return_val_if_fail(targ != NULL, 1);
g_return_val_if_fail(filenames != NULL, 1);
trace(1, "zipfile_delete_files: targ = '%s'\n", targ);
matches = make_match_array(filenames);
zfile_init(&zf, 0, opt);
if (matches == NULL) {
err = ZE_MEM;
if (gerr != NULL) {
make_gerr(err, gerr);
}
return err;
}
zf.wanted = filenames;
zf.matches = matches;
err = process_zipfile(&zf, targ, ZIP_DO_DELETE);
trace(2, "zipfile_delete_files: process_zipfile returned %d\n", err);
if (!err) {
err = check_matches(filenames, matches);
}
if (!err) {
err = real_delete_files(&zf);
}
free(matches);
if (err && gerr != NULL) {
make_gerr(err, gerr);
}
zip_finish(&zf);
return err;
}
int zipfile_extract_files (const char *targ,
const char **filenames,
const char *eprefix,
ZipOption opt,
GError **gerr)
{
zfile zf;
gchar *matches = NULL;
int err;
g_return_val_if_fail(targ != NULL, 1);
if (filenames != NULL) {
matches = make_match_array(filenames);
}
zfile_init(&zf, 0, opt);
zf.wanted = filenames;
zf.eprefix = eprefix;
zf.matches = matches;
err = process_zipfile(&zf, targ, ZIP_DO_UNZIP);
trace(2, "zipfile_extract_files: process_zipfile returned %d\n", err);
if (!err && matches != NULL) {
err = check_matches(filenames, matches);
}
free(matches);
if (err && gerr != NULL) {
make_gerr(err, gerr);
}
zip_finish(&zf);
return err;
}
bool CustomPattern::findPatternPass(const Mat& image, vector<Point2f>& matched_features, vector<Point3f>& pattern_points,
Mat& H, vector<Point2f>& scene_corners, const double pratio, const double proj_error,
const bool refine_position, const Mat& mask, OutputArray output)
{
if (!initialized) {return false; }
matched_features.clear();
pattern_points.clear();
vector<vector<DMatch> > matches;
vector<KeyPoint> f_keypoints;
Mat f_descriptor;
detector->detect(image, f_keypoints, mask);
if (refine_position) refineKeypointsPos(image, f_keypoints);
descriptorExtractor->compute(image, f_keypoints, f_descriptor);
descriptorMatcher->knnMatch(f_descriptor, descriptor, matches, 2); // k = 2;
vector<DMatch> good_matches;
vector<Point2f> obj_points;
for(int i = 0; i < f_descriptor.rows; ++i)
{
if(matches[i][0].distance < pratio * matches[i][1].distance)
{
const DMatch& dm = matches[i][0];
good_matches.push_back(dm);
// "keypoints1[matches[i].queryIdx] has a corresponding point in keypoints2[matches[i].trainIdx]"
matched_features.push_back(f_keypoints[dm.queryIdx].pt);
pattern_points.push_back(points3d[dm.trainIdx]);
obj_points.push_back(keypoints[dm.trainIdx].pt);
}
}
if (good_matches.size() < MIN_POINTS_FOR_H) return false;
Mat h_mask;
H = findHomography(obj_points, matched_features, RANSAC, proj_error, h_mask);
if (H.empty())
{
// cout << "findHomography() returned empty Mat." << endl;
return false;
}
for(unsigned int i = 0; i < good_matches.size(); ++i)
{
if(!h_mask.data[i])
{
deleteStdVecElem(good_matches, i);
deleteStdVecElem(matched_features, i);
deleteStdVecElem(pattern_points, i);
}
}
if (good_matches.empty()) return false;
uint numb_elem = good_matches.size();
check_matches(matched_features, obj_points, good_matches, pattern_points, H);
if (good_matches.empty() || numb_elem < good_matches.size()) return false;
// Get the corners from the image
scene_corners = vector<Point2f>(4);
perspectiveTransform(obj_corners, scene_corners, H);
// Check correctnes of H
// Is it a convex hull?
bool cConvex = isContourConvex(scene_corners);
if (!cConvex) return false;
// Is the hull too large or small?
double scene_area = contourArea(scene_corners);
if (scene_area < MIN_CONTOUR_AREA_PX) return false;
double ratio = scene_area/img_roi.size().area();
if ((ratio < MIN_CONTOUR_AREA_RATIO) ||
(ratio > MAX_CONTOUR_AREA_RATIO)) return false;
// Is any of the projected points outside the hull?
for(unsigned int i = 0; i < good_matches.size(); ++i)
{
if(pointPolygonTest(scene_corners, f_keypoints[good_matches[i].queryIdx].pt, false) < 0)
{
deleteStdVecElem(good_matches, i);
deleteStdVecElem(matched_features, i);
deleteStdVecElem(pattern_points, i);
}
}
if (output.needed())
{
Mat out;
drawMatches(image, f_keypoints, img_roi, keypoints, good_matches, out);
// Draw lines between the corners (the mapped object in the scene - image_2 )
line(out, scene_corners[0], scene_corners[1], Scalar(0, 255, 0), 2);
line(out, scene_corners[1], scene_corners[2], Scalar(0, 255, 0), 2);
line(out, scene_corners[2], scene_corners[3], Scalar(0, 255, 0), 2);
line(out, scene_corners[3], scene_corners[0], Scalar(0, 255, 0), 2);
out.copyTo(output);
}
return (!good_matches.empty()); // return true if there are enough good matches
}
