int main(){
unsigned char *ro_ch,*ve_ch,*az_ch;
float *red_input,*red_output,*blue_input,*blue_output,*green_input,*green_output,lambda;
char fentrada[200];
int i,niter,tam,h,w;
float dt;
printf("---------------MENU-----------------.\n");
printf("Introduzca la direccion del archivo\n");
scanf("%s",fentrada);
printf("introduzca dt \n");
scanf("%f",&dt);
printf("Introduzca numero de iteraciones\n");
scanf("%d",&niter);
printf("Introduzca valor para el parámetro lambda\n");
scanf("%f",&lambda);
ami_read_bmp(fentrada,&ro_ch,&ve_ch,&az_ch, &w,&h);
tam=w*h;
red_input=(float*)malloc(tam*sizeof(float));
blue_input=(float*)malloc(tam*sizeof(float));
green_input=(float*)malloc(tam*sizeof(float));
red_output=(float*)malloc(tam*sizeof(float));
blue_output=(float*)malloc(tam*sizeof(float));
green_output=(float*)malloc(tam*sizeof(float));
for(i=0;i<tam;i++){
red_input[i]=ro_ch[i];
blue_input[i]=az_ch[i];
green_input[i]=ve_ch[i];
}
perona_malik(red_input,green_input,blue_input,w,h,dt,niter,lambda);
free(red_input);
free(blue_input);
free(green_input);
free(red_output);
free(blue_output);
free(green_output);
free(ro_ch);
free(az_ch);
free(ve_ch);
printf("FINISH");
return 0;
}
int
main(int argc,
char ** argv)
{
/// @section csv_segmentation Chan-Sandberg-Vese segmentation
///
/// @subsection csv_theory Theory
/// Since the routine contains too many free parameters which makes it unreasonable to place it into a separate
/// function, all the code is kept in main(). Here's a rough explanation of what's Chan-Sandberg-Vese all about,
/// which is based on paper @cite Getreuer2012.
///
/// The Chan-Vese method seeks a contour @f$\mathcal{C}@f$ which minimizes the functional
/// @f[
/// \mathcal{F}[I;\,\mathcal{C},\,c_{1},\,c_{2}]=
/// \mu\mathrm{Length}(\mathcal{C})+
/// \nu\mathrm{Area}(\mathcal{C})+
/// \lambda_{1}\int_{\mathcal{C}}|I-c_{1}|^{2}\,\mathrm{d}x\mathrm{d}y+
/// \lambda_{2}\int_{\Omega\setminus\mathcal{C}}|I-c_{2}|^{2}\,\mathrm{d}x\mathrm{d}y\,,
/// @f]
/// where
/// - the single-channel image @f$I=I(x,\,y)@f$ is defined on the region @f$\Omega=[0,\,a]\times[0,\,b]@f$;
/// - regions in the integral limits, @f$\mathcal{C}@f$ and @f$\Omega\setminus\mathcal{C}@f$,
/// denote the region enclosed by the contour and the region outside the contour, respectively;
/// - @f$\mu(=0.5)@f$, @f$\nu(=0)@f$, @f$\lambda_{1}(=1)@f$ and @f$\lambda_{2}(=1)@f$ are free parameters,
/// whereby only @f$\nu@f$ can be negative (default values in parentheses);
/// - @f$c_{1}@f$ and @f$c_{2}@f$ are constants that depend on the information of the regions enclosed by and
/// outside of the contour.
///
/// Instead of dealing with @f$\mathcal{C}@f$ explicitly, it's custom to define a level set function @f$u(x,\,y;\,t)@f$
/// so that its zero-level iso-surface (also: zero level set) coincides with the contour:
/// @f$\mathcal{C}=\{\Omega\ni(x,\,y)\,:\,u(x,\,y;\,t)=0\forall t\}@f$. This in turn leads us to a new definition
/// of the functional:
/// @f[
/// \mathcal{F}[I;\,u,\,c_{1},\,c_{2}] =
/// \mu\left(\int_{\Omega}|\nabla H(u)|\,\mathrm{d}x\mathrm{d}y\right)^{p}+
/// \nu\int_{\Omega}H(u)\,\mathrm{d}x\mathrm{d}y+
/// \lambda_{1}\int_{\Omega}|I-c_{1}|^{2}H(u)\,\mathrm{d}x\mathrm{d}y+
/// \lambda_{2}\int_{\Omega}|I-c_{2}|^{2}(1-H(u))\,\mathrm{d}x\mathrm{d}y\,.
/// @f]
/// In our implementation we've picked @f$p=1@f$, so that the first integral reduces to
/// @f[
/// \left.\mu\left(\int_{\Omega}|\nabla H(u)|\,\mathrm{d}x\mathrm{d}y\right)^{p}\right|_{p=1}=
/// \mu\int_{\Omega}\delta(u)|\nabla u|\,\mathrm{d}x\mathrm{d}y\,,
/// @f]
/// where @f$H(x)@f$ and @f$\delta(x)=H'(x)@f$ are Heaviside's step and Dirac's delta functions.
/// In this prescription @f$c_{1}@f$ and @f$c_{2}@f$ are now region averages and take the following form:
/// @f[
/// c_{1}=\frac{\int_{\Omega}IH(u)\mathrm{d}x\mathrm{d}y}{\int_{\Omega}H(u)\,\mathrm{d}x\mathrm{d}y}\,,\quad
/// c_{2}=\frac{\int_{\Omega}I(1-H(u))\mathrm{d}x\mathrm{d}y}{\int_{\Omega}(1 - H(u))\,\mathrm{d}x\mathrm{d}y}\,.
/// @f]
/// For practical reasons the functions are replaced by smooth/regularized versions (see regularized_heaviside() and
/// regularized_delta()):
/// @f[
/// H_{\epsilon}(x)=\frac{1}{2}\left[1+\frac{2}{\pi}\arctan\left(\frac{x}{\epsilon}\right)\right]\,,\quad
/// \delta_{\epsilon}(x)=\frac{\epsilon}{\pi\left(\epsilon^{2}+x^{2}\right)}\,,
/// @f]
/// with @f$\epsilon=1@f$ by default.
/// The interpretation of the functional @f$\mathcal{F}@f$ is the following:
/// - the first term penalizes the length of @f$\mathcal{C}@f$;
/// - the second term penalizes the area enclosed by the curve;
/// - the 3rd and 4th term penalize region averages inside and outside of the contour; in other words
/// it keeps track of the discrepancy between the two regions.
///
/// A stationary solution to @f$\mathcal{F}@f$, or equivalently the equation of motion (e.o.m) for the contour,
/// can be found by solving it with Euler-Lagrange equation, which results in
/// @f[
/// u_{t} = \delta_{\epsilon}(u)\left[\mu\kappa-\nu-\lambda_{1}(I-c_{1})^{2}+\lambda_{2}(I-c_{2})^{2}\right]\,,
/// @f]
/// where @f$\kappa=\nabla\cdot\left(\frac{\nabla u}{|\nabla u|}\right)@f$ is curvature of @f$u@f$.
///
/// If the (still 2D) image has @f$I@f$ has @f$N@f$ channels @f$\{I_{i}(x,\,y)\}_{i=1}^{N}@f$, there should still
/// be a single level set @f$u@f$, which leads us the following functional:
/// @f[
/// \mathcal{F}[I;\,u,\,\mathbf{c_{1}},\,\mathbf{c}_{2}]=
/// \mu\int_{\Omega}|\nabla H(u)|\mathrm{d}x\mathrm{d}y+
/// \nu\int_{\Omega}H(u)\mathrm{d}x\mathrm{d}y+
/// \int_{\Omega}\frac{1}{N}\sum_{i=1}^{N}\lambda_{1}^{(i)}|I_{i}-c_{1}^{(i)}|^{2}H(u)\mathrm{d}x\mathrm{d}y+
/// \int_{\Omega}\frac{1}{N}\sum_{i=1}^{N}\lambda_{2}^{(i)}|I_{i}-c_{2}^{(i)}|^{2}(1-H(u))\mathrm{d}x\mathrm{d}y\,.
/// @f]
/// Variables @f$\{c_{1}^{(i)},\,c_{2}^{(i)}\}_{i=1}^{N}@f$ retain their original meaning,
/// @f[
/// c_{1}^{(i)}=\frac{\int_{\Omega}I_{i}H(u)\mathrm{d}x\mathrm{d}y}{\int_{\Omega}H(u)\mathrm{d}x\mathrm{d}y}\,,\quad
/// c_{2}^{(i)}=\frac{\int_{\Omega}I_{i}(1-H(u))\mathrm{d}x\mathrm{d}y}{\int_{\Omega}(1-H(u))\mathrm{d}x\mathrm{d}y}
/// \quad\forall i=\{1,\,\ldots,\,N\}\,;
/// @f]
/// the constants @f$\{\lambda_{1}^{(i)},\,\lambda_{2}^{(i)}\}_{i=1}^{N}@f$ are defined for each channel separately.
/// This implementation consider only grayscale (@f$N=1@f$) and RGB (@f$N=3@f$) images, for which @f$\lambda_{i}=1@f$
/// by default for any @f$i@f$-th channel.
/// The corresponding e.o.m reads
/// @f[
/// u_{t}=\delta_{\epsilon}(u)\left[\mu\kappa-\nu-
/// \frac{1}{N}\sum_{i=1}^{N}\lambda_{1}^{(i)}\left(I_{i}-c_{1}^{(i)}\right)^{2}+
/// \frac{1}{N}\sum_{i=1}^{N}\lambda_{2}^{(i)}\left(I_{i}-c_{2}^{(i)}\right)^{2}\right]\,.
/// @f]
///
/// @subsection csv_numsch Numerical scheme
///
/// Finite difference expression for the curvature @f$\kappa@f$ is explained in curvature(). The advantage of this scheme
/// is that we only need nearest neighbouring points at current point while keeping the derivative centered at current point,
/// whereas naive implementation would use more distant points. Since we're dealing with a finite domain and therefore
/// boundaries, we don't have to "extend" the region by two pixels each direction. Instead, we just duplicate border pixels.
///
/// Rest of the calculation is actually quite straightforward -- the zero level set is iteratively updated with
/// @f[
/// u_{i,j}^{n+1}=u_{i,j}^{n}+\mathrm{d}t\;\delta_{\epsilon}(u_{i,j}^{n})\left[\kappa_{i,j}^{n}-\nu-
/// \frac{1}{N}\sum_{k=1}^N\lambda_{1}^{(k)}\left(I_{i,j}-c_{1}^{n,(k)}\right)+
/// \frac{1}{N}\sum_{k=1}^N\lambda_{2}^{(k)}\left(I_{i,j}-c_{2}^{n,(k)}\right)\right]\,.
/// @f]
/// The method is inherently implicit and is implemented with ordinary matrix operations. The first term in the brackets
/// has already been discussed; the second term is trivial; the final two terms are explained in region_variance() and
/// variance_penalty().
///
/// There are various ways to initialize the level set, and since we're solving a differential equation, different initial
/// conditions lead to different outcome. The simplest way is to let the user draw either rectangular or circular contour.
/// The level set will be evaluated with @f$+1@f$'s inside the contour and with @f$-1@f$'s outside of it.
/// A more optimal (here the default) contour would be checkerboard
/// @f[
/// u(i,\,j;\,0)=\sin\left(\frac{\pi}{5}i\right)\sin\left(\frac{\pi}{5}j\right)\,,
/// @f]
/// because it converges faster to a solution (see levelset_checkerboard()). The solution is reached when the maximum number
/// of iterations, @f$T_\max@f$, is reached or when @f$||u_{i,j}^{n+1}-u_{i,j}^{n}||_{2}\leqslant\delta ||\bar{I}||_{2}@f$,
/// where the subscript denotes @f$L_{2}@f$-norm, @f$\delta=(10^{-3})@f$ is tolerance parameter and @f$\bar{I}@f$ is
/// the intensity average in the image (averaged across the channels).
///
/// @subsection csv_summary Summary
///
/// The main logic described above starts with a timestep loop (look for the comment below); everything else preciding
/// that is actually sugar coating just to make the program usable for anyone.
///
/// If it isn't clear from above text or the code below, here is the list of variables which the user can pass as an argument
/// (the default values in the parentheses): @f$\mu(=0.5)@f$, @f$\nu(=0)@f$, @f$\mathrm{d}t(=1)@f$,
/// @f$\lambda_{1}^{(i)}(=1)@f$ and @f$\lambda_{1}^{(i)}(=1)@f$ @f$\forall i=1\ldots N@f$, @f$\epsilon(=1)@f$,
/// @f$\delta(=10^{-3})@f$, @f$T_\max@f$(=INT_MAX), @f$N(=1\;\mbox{or}\;3)@f$ (number of channels).
///
/// Other general options include:
/// - object selection (-s) -- the region enclosed by the contour will be cut out and placed onto white canvas and saved;
/// - region inversion (-I) -- sometimes the ROI is inverted; there's an option to circumvent that (goes with -s option);
/// - video output (-V) -- see contour evolution in a video (*.avi, the same filename as the image; see VideoWriterManager);
/// - overlay text (-O) -- puts overlay text (timesteps) on the video (goes with the previous option);
/// - frame rate (-f) -- frame rate of the video;
/// - line color (-l) -- color of the contour line (see Colors);
/// - rectangular (-R) or circular (-C) contour -- lets the user draw it on the image (see InteractiveData and its subclasses);
/// - grayscale image (-g) -- sometimes we just want do perform it on a black-white image, but the original source is RGB.
///
/// For Perona-Malik-specific parameters @f$K@f$, @f$L@f$, @f$T@f$, see perona_malik().
///
/// @sa curvature, region_variance, variance_penalty, levelset_checkerboard, VideoWriterManager, InteractiveData, Colors, perona_malik
double mu, nu, eps, tol, dt, fps, K, L, T;
int max_steps;
std::vector<double> lambda1,
lambda2;
std::string input_filename,
text_position,
line_color_str;
bool grayscale = false,
write_video = false,
overlay_text = false,
object_selection = false,
invert = false,
segment = false,
rectangle_contour = false,
circle_contour = false;
ChanVese::TextPosition pos = ChanVese::TextPosition::TopLeft;
cv::Scalar contour_color = ChanVese::Colors::blue;
//-- Parse command line arguments
// Negative values in multitoken are not an issue, b/c it doesn't make much sense
// to use negative values for lambda1 and lambda2
try
{
namespace po = boost::program_options;
po::options_description desc("Allowed options", get_terminal_width());
desc.add_options()
("help,h", "this message")
("input,i", po::value<std::string>(&input_filename), "input image")
("mu", po::value<double>(&mu) -> default_value(0.5), "length penalty parameter (must be positive or zero)")
("nu", po::value<double>(&nu) -> default_value(0), "area penalty parameter")
("dt", po::value<double>(&dt) -> default_value(1), "timestep")
("lambda1", po::value<std::vector<double>>(&lambda1) -> multitoken(), "penalty of variance inside the contour (default: 1's)")
("lambda2", po::value<std::vector<double>>(&lambda2) -> multitoken(), "penalty of variance outside the contour (default: 1's)")
("epsilon,e", po::value<double>(&eps) -> default_value(1), "smoothing parameter in Heaviside/delta")
("tolerance,t", po::value<double>(&tol) -> default_value(0.001), "tolerance in stopping condition")
("max-steps,N", po::value<int>(&max_steps) -> default_value(-1), "maximum nof iterations (negative means unlimited)")
("fps,f", po::value<double>(&fps) -> default_value(10), "video fps")
("overlay-pos,P", po::value<std::string>(&text_position) -> default_value("TL"), "overlay tex position; allowed only: TL, BL, TR, BR")
("line-color,l", po::value<std::string>(&line_color_str) -> default_value("blue"), "contour color (allowed only: black, white, R, G, B, Y, M, C")
("edge-coef,K", po::value<double>(&K) -> default_value(10), "coefficient for enhancing edge detection in Perona-Malik")
("laplacian-coef,L", po::value<double>(&L) -> default_value(0.25), "coefficient in the gradient FD scheme of Perona-Malik (must be [0, 1/4])")
("segment-time,T", po::value<double>(&T) -> default_value(20), "number of smoothing steps in Perona-Malik")
("segment,S", po::bool_switch(&segment), "segment the image with Perona-Malik beforehand")
("grayscale,g", po::bool_switch(&grayscale), "read in as grayscale")
("video,V", po::bool_switch(&write_video), "enable video output (changes the extension to '.avi')")
("overlay-text,O", po::bool_switch(&overlay_text), "add overlay text")
("invert-selection,I", po::bool_switch(&invert), "invert selected region (see: select)")
("select,s", po::bool_switch(&object_selection), "separate the region encolosed by the contour (adds suffix '_selection')")
("rectangle,R", po::bool_switch(&rectangle_contour), "select rectangular contour interactively")
("circle,C", po::bool_switch(&circle_contour), "select circular contour interactively")
;
po::variables_map vm;
po::store(po::command_line_parser(argc, argv).options(desc).run(), vm);
po::notify(vm);
if(vm.count("help"))
{
std::cout << desc << "\n";
return EXIT_SUCCESS;
}
if(! vm.count("input"))
msg_exit("Error: you have to specify input file name!");
else if(vm.count("input") && ! boost::filesystem::exists(input_filename))
msg_exit("Error: file \"" + input_filename + "\" does not exists!");
if(vm.count("dt") && dt <= 0)
msg_exit("Cannot have negative or zero timestep: " + std::to_string(dt) + ".");
if(vm.count("mu") && mu < 0)
msg_exit("Length penalty parameter cannot be negative: " + std::to_string(mu) + ".");
if(vm.count("lambda1"))
{
if(grayscale && lambda1.size() != 1)
msg_exit("Too many lambda1 values for a grayscale image.");
else if(! grayscale && lambda1.size() != 3)
msg_exit("Number of lambda1 values must be 3 for a colored input image.");
else if(grayscale && lambda1[0] < 0)
msg_exit("The value of lambda1 cannot be negative.");
else if(! grayscale && (lambda1[0] < 0 || lambda1[1] < 0 || lambda1[2] < 0))
msg_exit("Any value of lambda1 cannot be negative.");
}
else if(! vm.count("lambda1"))
{
if(grayscale) lambda1 = {1};
else lambda1 = {1, 1, 1};
}
if(vm.count("lambda2"))
{
if(grayscale && lambda2.size() != 1)
msg_exit("Too many lambda2 values for a grayscale image.");
else if(! grayscale && lambda2.size() != 3)
msg_exit("Number of lambda2 values must be 3 for a colored input image.");
else if(grayscale && lambda2[0] < 0)
msg_exit("The value of lambda2 cannot be negative.");
else if(! grayscale && (lambda2[0] < 0 || lambda2[1] < 0 || lambda2[2] < 0))
msg_exit("Any value of lambda2 cannot be negative.");
}
else if(! vm.count("lambda2"))
{
if(grayscale) lambda2 = {1};
else lambda2 = {1, 1, 1};
}
if(vm.count("eps") && eps < 0)
msg_exit("Cannot have negative smoothing parameter: " + std::to_string(eps) + ".");
if(vm.count("tol") && tol < 0)
msg_exit("Cannot have negative tolerance: " + std::to_string(tol) + ".");
if(vm.count("overlay-pos"))
{
if (boost::iequals(text_position, "TL")) pos = ChanVese::TextPosition::TopLeft;
else if(boost::iequals(text_position, "BL")) pos = ChanVese::TextPosition::BottomLeft;
else if(boost::iequals(text_position, "TR")) pos = ChanVese::TextPosition::TopRight;
else if(boost::iequals(text_position, "BR")) pos = ChanVese::TextPosition::BottomRight;
else
msg_exit("Invalid text position requested.\n"\
"Correct values are: TL -- top left\n"\
" BL -- bottom left\n"\
" TR -- top right\n"\
" BR -- bottom right"\
);
}
if(vm.count("line-color"))
{
if (boost::iequals(line_color_str, "red")) contour_color = ChanVese::Colors::red;
else if(boost::iequals(line_color_str, "green")) contour_color = ChanVese::Colors::green;
else if(boost::iequals(line_color_str, "blue")) contour_color = ChanVese::Colors::blue;
else if(boost::iequals(line_color_str, "black")) contour_color = ChanVese::Colors::black;
else if(boost::iequals(line_color_str, "white")) contour_color = ChanVese::Colors::white;
else if(boost::iequals(line_color_str, "magenta")) contour_color = ChanVese::Colors::magenta;
else if(boost::iequals(line_color_str, "yellow")) contour_color = ChanVese::Colors::yellow;
else if(boost::iequals(line_color_str, "cyan")) contour_color = ChanVese::Colors::cyan;
else
msg_exit("Invalid contour color requested.\n"\
"Correct values are: red, green, blue, black, white, magenta, yellow, cyan.");
}
if(vm.count("laplacian-coef") && (L > 0.25 || L < 0))
msg_exit("The Laplacian coefficient in Perona-Malik segmentation must be between 0 and 0.25.");
if(vm.count("segment-time") && (T < L))
msg_exit("The segmentation duration must exceed the value of Laplacian coefficient, " +
std::to_string(L) + ".");
if(rectangle_contour && circle_contour)
msg_exit("Cannot initialize with both rectangular and circular contour");
}
catch(std::exception & e)
{
msg_exit("error: " + std::string(e.what()));
}
//-- Read the image (grayscale or BGR? RGB? BGR? help)
cv::Mat _img;
if(grayscale) _img = cv::imread(input_filename, CV_LOAD_IMAGE_GRAYSCALE);
else _img = cv::imread(input_filename, CV_LOAD_IMAGE_COLOR);
if(! _img.data)
msg_exit("Error on opening \"" + input_filename + "\" (probably not an image)!");
//-- Second conversion needed since we want to display a colored contour on a grayscale image
cv::Mat img;
if(grayscale) cv::cvtColor(_img, img, CV_GRAY2RGB);
else img = _img;
_img.release();
//-- Determine the constants and define functionals
max_steps = max_steps < 0 ? std::numeric_limits<int>::max() : max_steps;
const int h = img.rows;
const int w = img.cols;
const int nof_channels = grayscale ? 1 : img.channels();
const auto heaviside = std::bind(regularized_heaviside, std::placeholders::_1, eps);
const auto delta = std::bind(regularized_delta, std::placeholders::_1, eps);
//-- Construct the level set
cv::Mat u;
if(rectangle_contour || circle_contour)
{
std::unique_ptr<InteractiveData> id;
cv::startWindowThread();
cv::namedWindow(WINDOW_TITLE, cv::WINDOW_NORMAL);
if (rectangle_contour)
id = std::unique_ptr<InteractiveDataRect>(new InteractiveDataRect(&img, contour_color));
else if(circle_contour)
id = std::unique_ptr<InteractiveDataCirc>(new InteractiveDataCirc(&img, contour_color));
if(id) cv::setMouseCallback(WINDOW_TITLE, on_mouse, id.get());
cv::imshow(WINDOW_TITLE, img);
cv::waitKey();
cv::destroyWindow(WINDOW_TITLE);
if(id)
{
if(! id -> is_ok())
msg_exit("You must specify the contour with non-zero dimensions");
u = id -> get_levelset(h, w);
}
}
else
u = levelset_checkerboard(h, w);
//-- Set up the video writer (and save the first frame)
VideoWriterManager vwm;
if(write_video)
{
vwm = VideoWriterManager(input_filename, img, contour_color, fps, pos, overlay_text);
vwm.write_frame(u, overlay_text ? "t = 0" : "");
}
//-- Split the channels
std::vector<cv::Mat> channels;
channels.reserve(nof_channels);
cv::split(img, channels);
if(grayscale) channels.erase(channels.begin() + 1, channels.end());
//-- Smooth the image with Perona-Malik
cv::Mat smoothed_img;
if(segment)
{
smoothed_img = perona_malik(channels, h, w, K, L, T);
channels.clear();
cv::split(smoothed_img, channels);
cv::imwrite(add_suffix(input_filename, "pm"), smoothed_img);
}
//-- Find intensity sum and derive the stopping condition
cv::Mat intensity_avg = cv::Mat(h, w, CV_64FC1);
#pragma omp parallel for num_threads(nof_channels)
for(int k = 0; k < nof_channels; ++k)
{
cv::Mat channel(h, w, intensity_avg.type());
channels[k].convertTo(channel, channel.type());
intensity_avg += channel;
}
intensity_avg /= nof_channels;
double stop_cond = tol * cv::norm(intensity_avg, cv::NORM_L2);
intensity_avg.release();
//-- Timestep loop
for(int t = 1; t <= max_steps; ++t)
{
cv::Mat u_diff(cv::Mat::zeros(h, w, CV_64FC1));
//-- Channel loop
#pragma omp parallel for num_threads(nof_channels)
for(int k = 0; k < nof_channels; ++k)
{
cv::Mat channel = channels[k];
//-- Find the average regional variances
const double c1 = region_variance(channel, u, h, w, ChanVese::Region::Inside, heaviside);
const double c2 = region_variance(channel, u, h, w, ChanVese::Region::Outside, heaviside);
//-- Calculate the contribution of one channel to the level set
const cv::Mat variance_inside = variance_penalty(channel, h, w, c1, lambda1[k]);
const cv::Mat variance_outside = variance_penalty(channel, h, w, c2, lambda2[k]);
u_diff += -variance_inside + variance_outside;
}
//-- Calculate the curvature (divergence of normalized gradient)
const cv::Mat kappa = curvature(u, h, w);
//-- Mash the terms together
u_diff = dt * (mu * kappa - nu + u_diff / nof_channels);
//-- Run delta function on the level set
cv::Mat u_cp = u.clone();
cv::parallel_for_(cv::Range(0, h * w), ParallelPixelFunction(u_cp, w, delta));
//-- Shift the level set
cv::multiply(u_diff, u_cp, u_diff);
const double u_diff_norm = cv::norm(u_diff, cv::NORM_L2);
u += u_diff;
//-- Save the frame
if(write_video) vwm.write_frame(u, overlay_text ? "t = " + std::to_string(t) : "");
//-- Check if we have achieved the desired precision
if(u_diff_norm <= stop_cond) break;
}
//-- Select the region enclosed by the contour and save it to the disk
if(object_selection)
cv::imwrite(add_suffix(input_filename, "selection"), separate(img, u, h, w, invert));
return EXIT_SUCCESS;
}
