Skip to content

Commit

Permalink
Merge pull request opencv#16695 from SimpleVlad:intelligent_scissors
Browse files Browse the repository at this point in the history 
Intelligent scissors

* Start

* Remove whitespace

* Re onMouse

* replased double to float

* Draw contours

* CV_FILLED -> FILLED

* Remove line 210

* Change 'about'

* Remove M_PI

* Remove warning

* CP_PI

* double to float

* CV_PI to Float

* Add struct for data

* line 172, 191 whitespace

* Change name

* Fix Warnings

* Set const

* line 180

* rewrite keys

* &img = param->img
  • Loading branch information
@SimpleVlad
SimpleVlad authored Mar 16, 2020
1 parent 71ec112 commit 1c2ed28
Showing 1 changed file with 232 additions and 0 deletions.
232 changes: 232 additions & 0 deletions samples/cpp/intelligent_scissors.cpp
View file
Original file line number Diff line number Diff line change
@@ -0,0 +1,232 @@
#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\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, &param);
imshow("lasso", param.img);
waitKey(0);
}

0 comments on commit 1c2ed28

Please sign in to comment.