mirror of
https://github.com/opencv/opencv.git
synced 2024-12-13 16:09:23 +08:00
8ac333697d
Add link to article for sample "Intelligent scissors" * Add link to article * Add autors name * Fix whitespace
236 lines
7.7 KiB
C++
236 lines
7.7 KiB
C++
#include <iostream>
|
|
#include <cmath>
|
|
#include <string>
|
|
#include <vector>
|
|
#include <queue>
|
|
#include <opencv2/core/core.hpp>
|
|
#include <opencv2/highgui/highgui.hpp>
|
|
#include <opencv2/imgproc/imgproc.hpp>
|
|
|
|
using namespace cv;
|
|
struct Pix
|
|
{
|
|
Point next_point;
|
|
double cost;
|
|
|
|
bool operator > (const Pix &b) const
|
|
{
|
|
return cost > b.cost;
|
|
}
|
|
};
|
|
|
|
struct Parameters
|
|
{
|
|
Mat img, img_pre_render, img_render;
|
|
Point end;
|
|
std::vector<std::vector<Point> > contours;
|
|
std::vector<Point> tmp_contour;
|
|
Mat zero_crossing, gradient_magnitude, Ix, Iy, hit_map_x, hit_map_y;
|
|
};
|
|
|
|
|
|
static float local_cost(const Point& p, const Point& q, const Mat& gradient_magnitude, const Mat& Iy, const Mat& Ix, const Mat& zero_crossing)
|
|
{
|
|
float fG = gradient_magnitude.at<float>(q.y, q.x);
|
|
float dp;
|
|
float dq;
|
|
const float WEIGHT_LAP_ZERO_CROSS = 0.43f;
|
|
const float WEIGHT_GRADIENT_MAGNITUDE = 0.14f;
|
|
const float WEIGHT_GRADIENT_DIRECTION = 0.43f;
|
|
bool isDiag = (p.x != q.x) && (p.y != q.y);
|
|
|
|
if ((Iy.at<float>(p) * (q.x - p.x) - Ix.at<float>(p) * (q.y - p.y)) >= 0)
|
|
{
|
|
dp = Iy.at<float>(p) * (q.x - p.x) - Ix.at<float>(p) * (q.y - p.y);
|
|
dq = Iy.at<float>(q) * (q.x - p.x) - Ix.at<float>(q) * (q.y - p.y);
|
|
}
|
|
else
|
|
{
|
|
dp = Iy.at<float>(p) * (p.x - q.x) + (-Ix.at<float>(p)) * (p.y - q.y);
|
|
dq = Iy.at<float>(q) * (p.x - q.x) + (-Ix.at<float>(q)) * (p.y - q.y);
|
|
}
|
|
if (isDiag)
|
|
{
|
|
dp /= sqrtf(2);
|
|
dq /= sqrtf(2);
|
|
}
|
|
else
|
|
{
|
|
fG /= sqrtf(2);
|
|
}
|
|
return WEIGHT_LAP_ZERO_CROSS * zero_crossing.at<uchar>(q) +
|
|
WEIGHT_GRADIENT_DIRECTION * (acosf(dp) + acosf(dq)) / static_cast<float>(CV_PI) +
|
|
WEIGHT_GRADIENT_MAGNITUDE * fG;
|
|
}
|
|
|
|
static void find_min_path(const Point& start, Parameters* param)
|
|
{
|
|
Pix begin;
|
|
Mat &img = param->img;
|
|
Mat cost_map(img.size(), CV_32F, Scalar(FLT_MAX));
|
|
Mat expand(img.size(), CV_8UC1, Scalar(0));
|
|
Mat processed(img.size(), CV_8UC1, Scalar(0));
|
|
Mat removed(img.size(), CV_8UC1, Scalar(0));
|
|
std::priority_queue < Pix, std::vector<Pix>, std::greater<Pix> > L;
|
|
|
|
cost_map.at<float>(start) = 0;
|
|
processed.at<uchar>(start) = 1;
|
|
begin.cost = 0;
|
|
begin.next_point = start;
|
|
|
|
L.push(begin);
|
|
while (!L.empty())
|
|
{
|
|
Pix P = L.top();
|
|
L.pop();
|
|
Point p = P.next_point;
|
|
processed.at<uchar>(p) = 0;
|
|
if (removed.at<uchar>(p) == 0)
|
|
{
|
|
expand.at<uchar>(p) = 1;
|
|
for (int i = -1; i <= 1; i++)
|
|
{
|
|
for(int j = -1; j <= 1; j++)
|
|
{
|
|
int tx = p.x + i;
|
|
int ty = p.y + j;
|
|
if (tx < 0 || tx >= img.cols || ty < 0 || ty >= img.rows)
|
|
continue;
|
|
if (expand.at<uchar>(ty, tx) == 0)
|
|
{
|
|
Point q = Point(tx, ty);
|
|
float cost = cost_map.at<float>(p) + local_cost(p, q, param->gradient_magnitude, param->Iy, param->Ix, param->zero_crossing);
|
|
if (processed.at<uchar>(q) == 1 && cost < cost_map.at<float>(q))
|
|
{
|
|
removed.at<uchar>(q) = 1;
|
|
}
|
|
if (processed.at<uchar>(q) == 0)
|
|
{
|
|
cost_map.at<float>(q) = cost;
|
|
param->hit_map_x.at<int>(q)= p.x;
|
|
param->hit_map_y.at<int>(q) = p.y;
|
|
processed.at<uchar>(q) = 1;
|
|
Pix val;
|
|
val.cost = cost_map.at<float>(q);
|
|
val.next_point = q;
|
|
L.push(val);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
static void onMouse(int event, int x, int y, int , void* userdata)
|
|
{
|
|
Parameters* param = reinterpret_cast<Parameters*>(userdata);
|
|
Point &end = param->end;
|
|
std::vector<std::vector<Point> > &contours = param->contours;
|
|
std::vector<Point> &tmp_contour = param->tmp_contour;
|
|
Mat &img_render = param->img_render;
|
|
Mat &img_pre_render = param->img_pre_render;
|
|
|
|
if (event == EVENT_LBUTTONDOWN)
|
|
{
|
|
end = Point(x, y);
|
|
if (!contours.back().empty())
|
|
{
|
|
for (int i = static_cast<int>(tmp_contour.size()) - 1; i >= 0; i--)
|
|
{
|
|
contours.back().push_back(tmp_contour[i]);
|
|
}
|
|
tmp_contour.clear();
|
|
}
|
|
else
|
|
{
|
|
contours.back().push_back(end);
|
|
}
|
|
find_min_path(end, param);
|
|
|
|
img_render.copyTo(img_pre_render);
|
|
imshow("lasso", img_render);
|
|
}
|
|
else if (event == EVENT_RBUTTONDOWN)
|
|
{
|
|
img_pre_render.copyTo(img_render);
|
|
drawContours(img_pre_render, contours, static_cast<int>(contours.size()) - 1, Scalar(0,255,0), FILLED);
|
|
addWeighted(img_pre_render, 0.3, img_render, 0.7, 0, img_render);
|
|
contours.resize(contours.size() + 1);
|
|
imshow("lasso", img_render);
|
|
}
|
|
else if (event == EVENT_MOUSEMOVE && !contours.back().empty())
|
|
{
|
|
tmp_contour.clear();
|
|
img_pre_render.copyTo(img_render);
|
|
Point val_point = Point(x, y);
|
|
while (val_point != end)
|
|
{
|
|
tmp_contour.push_back(val_point);
|
|
Point cur = Point(param->hit_map_x.at<int>(val_point), param->hit_map_y.at<int>(val_point));
|
|
line(img_render, val_point, cur, Scalar(255, 0, 0), 2);
|
|
val_point = cur;
|
|
}
|
|
imshow("lasso", img_render);
|
|
}
|
|
}
|
|
|
|
const char* keys =
|
|
{
|
|
"{help h | |}"
|
|
"{@image | fruits.jpg| Path to image to process}"
|
|
};
|
|
|
|
|
|
int main( int argc, const char** argv )
|
|
{
|
|
Parameters param;
|
|
const int EDGE_THRESHOLD_LOW = 50;
|
|
const int EDGE_THRESHOLD_HIGH = 100;
|
|
CommandLineParser parser(argc, argv, keys);
|
|
parser.about("\nThis program demonstrates implementation of 'Intelligent Scissors' algorithm designed\n"
|
|
"by Eric N. Mortensen and William A. Barrett, and described in article\n"
|
|
"'Intelligent Scissors for Image Composition':\n"
|
|
"http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.138.3811&rep=rep1&type=pdf\n"
|
|
"To start drawing a new contour select a pixel, click LEFT mouse button.\n"
|
|
"To fix a path click LEFT mouse button again.\n"
|
|
"To finish drawing a contour click RIGHT mouse button.\n");
|
|
if (parser.has("help"))
|
|
{
|
|
parser.printMessage();
|
|
return 1;
|
|
}
|
|
std::vector<std::vector<Point> > c(1);
|
|
param.contours = c;
|
|
std::string filename = parser.get<std::string>(0);
|
|
|
|
Mat grayscale, img_canny;
|
|
param.img = imread(samples::findFile(filename));
|
|
param.hit_map_x.create(param.img.rows, param.img.cols, CV_32SC1);
|
|
param.hit_map_y.create(param.img.rows, param.img.cols, CV_32SC1);
|
|
|
|
cvtColor(param.img, grayscale, COLOR_BGR2GRAY);
|
|
Canny(grayscale, img_canny, EDGE_THRESHOLD_LOW, EDGE_THRESHOLD_HIGH);
|
|
|
|
threshold(img_canny, param.zero_crossing, 254, 1, THRESH_BINARY_INV);
|
|
Sobel(grayscale, param.Ix, CV_32FC1, 1, 0, 1);
|
|
Sobel(grayscale, param.Iy, CV_32FC1, 0, 1, 1);
|
|
param.Ix.convertTo(param.Ix, CV_32F, 1.0/255);
|
|
param.Iy.convertTo(param.Iy, CV_32F, 1.0/255);
|
|
|
|
// Compute gradients magnitude.
|
|
double max_val = 0.0;
|
|
magnitude(param.Iy, param.Ix, param.gradient_magnitude);
|
|
minMaxLoc(param.gradient_magnitude, 0, &max_val);
|
|
param.gradient_magnitude.convertTo(param.gradient_magnitude, CV_32F, -1/max_val, 1.0);
|
|
|
|
param.img.copyTo(param.img_pre_render);
|
|
param.img.copyTo(param.img_render);
|
|
|
|
namedWindow("lasso");
|
|
setMouseCallback("lasso", onMouse, ¶m);
|
|
imshow("lasso", param.img);
|
|
waitKey(0);
|
|
}
|