void deplace_term(int sigwinch)
{
if (ig_good_size(get_size_x(), get_size_y(), get_long_work(CS), CS->size))
{
tputs(tgoto(tgetstr("cm", NULL), 0, 0), FD, tputs_putchar);
tputs(tgetstr("cd", NULL), FD, tputs_putchar);
print_length(CS, get_size_y());
print_cursor(KEYUP);
print_cursor(KEYDOWN);
}
else
small_size();
(void)sigwinch;
}
bool CartoonEngine::Bilateral2(int iter_num,
int d,
double sigma_color,
double sigma_space) {
if ((image_.empty()) || (CV_8UC3 != image_.type()) || (iter_num < 1))
return false;
// Step 1: convert color, only do filtering on the luminance channel.
cv::Mat bgr_img = image_;
cv::Mat lab_img;
cv::cvtColor(bgr_img, lab_img, CV_BGR2Lab);
std::vector<cv::Mat> lab_channels;
cv::split(lab_img, lab_channels);
cv::Mat temp;
// Step 1: resize the original image to save pprocessing time (if needed).
cv::Size2i small_size(cols_, rows_);
if ((rows_ > 500) || (cols_ > 500)) {
if (rows_ > cols_) {
small_size.height = 500;
small_size.width =
static_cast<int>(500 * (static_cast<float>(cols_) / rows_));
} else {
small_size.width = 500;
small_size.height =
static_cast<int>(500 * (static_cast<float>(rows_) / cols_));
}
cv::resize(lab_channels[0], lab_channels[0], small_size);
temp.create(small_size, CV_8UC1);
} else {
temp.create(rows_, cols_, CV_8UC1);
}
// Step 2: do bilateral filtering for several times for cartoon rendition.
for (int i = 0; i < iter_num; ++i) {
cv::bilateralFilter(lab_channels[0], temp, d, sigma_color, sigma_space);
cv::bilateralFilter(temp, lab_channels[0], d, sigma_color, sigma_space);
}
// Step 3: luminance quantization.
if(!LuminanceQuantization(&lab_channels[0], 8))
return false;
// Step 4: revert the original image size.
if (small_size.width != cols_) {
cv::resize(lab_channels[0], lab_channels[0], cv::Size2i(cols_, rows_));
}
cv::merge(lab_channels, lab_img);
cv::cvtColor(lab_img, bgr_img, CV_Lab2BGR);
bgr_img.copyTo(cartoon_);
return true;
}
bool CartoonEngine::Bilateral(int iter_num,
int d,
double sigma_color,
double sigma_space) {
if ((image_.empty()) || (CV_8UC3 != image_.type()) || (iter_num < 1))
return false;
cv::Mat cartoon_img = image_;
cv::Mat temp;
// Step 1: resize the original image to save pprocessing time (if needed).
cv::Size2i small_size(cols_, rows_);
if ((rows_ > 500) || (cols_ > 500)) {
if (rows_ > cols_) {
small_size.height = 500;
small_size.width =
static_cast<int>(500 * (static_cast<float>(cols_) / rows_));
} else {
small_size.width = 500;
small_size.height =
static_cast<int>(500 * (static_cast<float>(rows_) / cols_));
}
cv::resize(cartoon_img, cartoon_img, small_size);
temp.create(small_size, CV_8UC3);
} else {
temp.create(rows_, cols_, CV_8UC3);
}
// Step 2: do bilateral filtering for several times for cartoon rendition.
for (int i = 0; i < iter_num; ++i) {
cv::bilateralFilter(cartoon_img, temp, d, sigma_color, sigma_space);
cv::bilateralFilter(temp, cartoon_img, d, sigma_color, sigma_space);
}
// Step 3: luminance quantization.
// Step 4: revert the original image size.
if (small_size.width != cols_) {
cv::resize(cartoon_img, cartoon_img, cv::Size2i(cols_, rows_));
}
cartoon_img.copyTo(cartoon_);
return true;
}
void skeletonize(const cv::Mat &input, cv::Mat &output, bool save_images)
{
TS(total);
TS(imwrite_0);
if (save_images) cv::imwrite("0-input.png", input);
TE(imwrite_0);
// Convert to grayscale my
cv::Mat gray_image_my;
ConvertColor_BGR2GRAY_BT709_fpt(input, gray_image_my);
if (save_images) cv::imwrite("1-convertcolor_my.png", gray_image_my);
// Convert to grayscale my
cv::Mat gray_image;
ConvertColor_BGR2GRAY_BT709(input, gray_image);
if (save_images) cv::imwrite("1-convertcolor.png", gray_image);
// Downscale input image
cv::Mat small_image;
cv::Size small_size(input.cols / 1.5, input.rows / 1.5);
ImageResize(gray_image, small_image, small_size);
if (save_images) cv::imwrite("2-resize.png", small_image);
// Binarization and inversion
cv::threshold(small_image, small_image, 128, 255, cv::THRESH_BINARY_INV);
if (save_images) cv::imwrite("3-threshold.png", small_image);
// Thinning
cv::Mat thinned_image;
GuoHallThinning(small_image, thinned_image);
if (save_images) cv::imwrite("4-thinning.png", thinned_image);
// Back inversion
output = 255 - thinned_image;
if (save_images) cv::imwrite("5-output.png", output);
TE(total);
}
bool CartoonEngine::Convert2Painting(int neighbor, int levels) {
if ((image_.empty()) || (CV_8UC3 != image_.type()))
return false;
// Resize image for fast processing.
cv::Size2i small_size(cols_, rows_);
cv::Mat img = image_;
if ((rows_ > 300) || (cols_ > 300)) {
if (rows_ > cols_) {
small_size.height = 300;
small_size.width =
static_cast<int>(300 * (static_cast<float>(cols_) / rows_));
} else {
small_size.width = 300;
small_size.height =
static_cast<int>(300 * (static_cast<float>(rows_) / cols_));
}
cv::resize(img, img, small_size);
}
painting_.create(small_size.height, small_size.width, CV_8UC3);
vector<int> hist(levels, 0);
vector<int> b_sum(levels, 0);
vector<int> g_sum(levels, 0);
vector<int> r_sum(levels, 0);
for (int r = 0; r < small_size.height; ++r) {
for (int c = 0; c < small_size.width; ++c) {
for (int i = 0; i < levels; ++i) {
hist[i] = 0;
b_sum[i] = g_sum[i] = r_sum[i] = 0;
}
int r_start = std::max(0, r - neighbor);
int r_end = std::min(small_size.height, r + neighbor);
int c_start = std::max(0, c - neighbor);
int c_end = std::min(small_size.width, c + neighbor);
for (int rr = r_start; rr < r_end; ++rr) {
for (int cc = c_start; cc < c_end; ++cc) {
cv::Vec3b pixel = img.at<cv::Vec3b>(rr, cc);
int ind = static_cast<int>((pixel[0] + pixel[1] + pixel[2]) / 3) * (levels - 1) / 255;
++hist[ind];
b_sum[ind] += static_cast<int>(pixel[0]);
g_sum[ind] += static_cast<int>(pixel[1]);
r_sum[ind] += static_cast<int>(pixel[2]);
}
}
int new_ind = 0;
int cur_max = hist[0];
for (int l = 1; l < levels; ++l) {
if (hist[l] > hist[new_ind]) {
new_ind = l;
cur_max = hist[l];
}
}
painting_.at<cv::Vec3b>(r, c)[0] =
static_cast<uchar>(b_sum[new_ind] / cur_max);
painting_.at<cv::Vec3b>(r, c)[1] =
static_cast<uchar>(g_sum[new_ind] / cur_max);
painting_.at<cv::Vec3b>(r, c)[2] =
static_cast<uchar>(r_sum[new_ind] / cur_max);
}
}
if (small_size.width != cols_) {
cv::resize(painting_, painting_, cv::Size2i(cols_, rows_));
}
return true;
}
void ClothingSearcher::getTheMaskOfCloth(const Mat &image, Mat &mask,
const std::vector<int> floodfill_thresholds )
{
if( image.channels() == 1 )
return;
//get the mask of cloth region using floodfill algorithm
Mat edges;
computeEdgeMap( image, edges );
//to lower down the complexity, resize the original image to smaller one
Mat small_image;
Size small_size( image.cols, image.rows );
if( image.cols > 320 ){
float scale = image.cols / 320;
small_size.width = image.cols / scale;
small_size.height = image.rows / scale;
cv::resize( image, small_image, small_size );
}
else
small_image = image.clone();
//convert to yuv color space
Mat yuv = Mat( small_size, CV_8UC3 );
cvtColor( small_image, yuv, CV_BGR2RGB );
//the mask used in floodfill should be 2 pixels widther and higher than the image
int sw = small_size.width;
int sh = small_size.height;
Mat mask_plus_border;
mask_plus_border = Mat::zeros( sh + 2, sw + 2, CV_8UC1 );
mask = mask_plus_border( cv::Rect( 1, 1, sw, sh ) );
cv::resize( edges, mask, small_size );
closeOperation( mask );
cv::Rect rect;
prepareSeedsRegionForFloodfill( small_image, rect );
rectangle( small_image, rect, Scalar( 0, 255, 0 ) );
//imshow( "tets", small_image );
waitKey(0);
Scalar lowerDiff = Scalar( floodfill_thresholds[0], floodfill_thresholds[0], floodfill_thresholds[0] );
Scalar upperDiff = Scalar( floodfill_thresholds[0], floodfill_thresholds[0], floodfill_thresholds[0]);
const int CONNECTED_COMPONENTS = 4;
const int flags = CONNECTED_COMPONENTS | FLOODFILL_FIXED_RANGE | FLOODFILL_MASK_ONLY;
Mat edge_mask = mask.clone();
const int X_POINTS = 8;
const int Y_POINTS = 8;
const int X_STEP = rect.width / X_POINTS;
const int Y_STEP = rect.height / Y_POINTS;
for( int i = rect.x + X_STEP; i < (int)(rect.x + rect.width ); i += X_STEP ){
for( int j = rect.y + Y_STEP; j < (int)(rect.y + rect.height ); j += Y_STEP ){
circle( small_image, cv::Point( i, j), 3, Scalar( 0, 0, 255 ) );
floodFill( yuv, mask_plus_border, cv::Point( i, j), Scalar(), NULL,
lowerDiff, upperDiff, flags );
}
}
//imshow( "mask", small_image );
waitKey(0);
mask -= edge_mask;
}
