m1-ENSL/seam-carving
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

adds remove_seam function

Browse Source
This commit is contained in:
François Colin de Verdière 2025-04-01 11:51:56 +02:00
parent 964d597bdd
commit f15b4c471b
1 changed files with 184 additions and 127 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

197
src/seam-carving.cpp
View File

@ -1,6 +1,6 @@
#include <iostream>
#include <string>
#include <random>
#include <string>
#include <vector>
// Command-line parsing
#include <CLI11.hpp>
@ -9,62 +9,73 @@
#define STB_IMAGE_IMPLEMENTATION
#include <stb_image.h>
#define STB_IMAGE_WRITE_IMPLEMENTATION
#include <stb_image_write.h>
#include <SimpleProgressBar.hpp>
#include <stb_image_write.h>
// Global flag to silent verbose messages
bool silent;
bool test_energy;
#define min(a, b) { (a < b ? a : b) }
// Get index for any table indexed by [width*(i : height) + (j : width)], but a : dim_long, b : dim_large
#define im_index(a, b) \
(vertical ? (width*a + b) : (width*b + a))
#define min(a, b) \
{ (a < b ? a : b) }
// Get index for any table indexed by [width*(i : height) + (j : width)], but a
// : dim_long, b : dim_large
#define im_index(a, b) (vertical ? (width * a + b) : (width * b + a))
bool nearly_equal(float a, float b) {
return std::nextafter(a, std::numeric_limits<float>::lowest()) <= b
&& std::nextafter(a, std::numeric_limits<float>::max()) >= b;
return std::nextafter(a, std::numeric_limits<float>::lowest()) <= b &&
std::nextafter(a, std::numeric_limits<float>::max()) >= b;
}
void export_image(const char* filename, const void* data, int width, int height, int nbChannels) {
if (!silent) std::cout << "Exporting to \"" << filename << "\".." << std::endl;
int errcode = stbi_write_png(filename, width, height, nbChannels, data, nbChannels*width);
void export_image(const char *filename, const void *data, int width, int height,
int nbChannels) {
if (!silent)
std::cout << "Exporting to \"" << filename << "\".." << std::endl;
int errcode = stbi_write_png(filename, width, height, nbChannels, data,
nbChannels * width);
if (!errcode) {
std::cerr << "Error while exporting the resulting image." << std::endl;
exit(errcode);
}
}
/** e_1 energy, energy is always normalized between 0 and 1 */
std::vector<float> energy_e1(std::vector<unsigned char> source, int width, int height, int nbChannels) {
int nbColorChannels = nbChannels > 3 ? 3 : nbChannels; // nombre de canaux, excepté le alpha
std::vector<float> energy_e1(std::vector<unsigned char> source, int width,
int height, int nbChannels) {
int nbColorChannels =
nbChannels > 3 ? 3 : nbChannels; // nombre de canaux, excepté le alpha
std::vector<float> energy(width * height);
float max_energy = 0;
for (auto i = 0; i < width; ++i) {
for (auto j = 0; j < height; ++j) {
auto indexPixel = nbChannels * (width * j + i);
auto indexPixel_up = (j-1 > 0) ? nbChannels*(width*(j-1)+i) : indexPixel;
auto indexPixel_down = (j+1 < height) ? nbChannels*(width*(j+1)+i) : indexPixel;
auto indexPixel_left = (i-1 > 0) ? nbChannels*(width*j+(i-1)) : indexPixel;
auto indexPixel_right = (i+1 < width) ? nbChannels*(width*j+(i+1)) : indexPixel;
auto indexPixel_up =
(j - 1 > 0) ? nbChannels * (width * (j - 1) + i) : indexPixel;
auto indexPixel_down =
(j + 1 < height) ? nbChannels * (width * (j + 1) + i) : indexPixel;
auto indexPixel_left =
(i - 1 > 0) ? nbChannels * (width * j + (i - 1)) : indexPixel;
auto indexPixel_right =
(i + 1 < width) ? nbChannels * (width * j + (i + 1)) : indexPixel;
energy[width * j + i] = 0;
for (auto ch=0; ch < nbColorChannels; ch++) { // Le alpha n'est pas pris en compte dans l'énergie
energy[width*j+i] += (
fabs((float)source[indexPixel_up+ch] - source[indexPixel+ch])
+fabs((float)source[indexPixel_down+ch] - source[indexPixel+ch])
+fabs((float)source[indexPixel_left+ch] - source[indexPixel+ch])
+fabs((float)source[indexPixel_right+ch] - source[indexPixel+ch])
);
for (auto ch = 0; ch < nbColorChannels;
ch++) { // Le alpha n'est pas pris en compte dans l'énergie
energy[width * j + i] +=
(fabs((float)source[indexPixel_up + ch] - source[indexPixel + ch]) +
fabs((float)source[indexPixel_down + ch] -
source[indexPixel + ch]) +
fabs((float)source[indexPixel_left + ch] -
source[indexPixel + ch]) +
fabs((float)source[indexPixel_right + ch] -
source[indexPixel + ch]));
}
max_energy = fmax(max_energy, energy[width * j + i]);
}
}
if (max_energy == 0) { return energy; }
if (max_energy == 0) {
return energy;
}
for (auto k = 0; k < width * height; k++) {
energy[k] = energy[k] / max_energy;
}
@ -72,8 +83,9 @@ std::vector<float> energy_e1(std::vector<unsigned char> source, int width, int h
return energy;
}
std::vector<int> optimal_seam(std::vector<float> energy, int width, int height,
bool vertical) {
/** Given the energy value, returns the optimal seam */
std::vector<int> optimal_seam(std::vector<float> energy, int width, int height, bool vertical) {
// dyn_energy is indexed by [dim_large*(i : dim_long) + (j : dim_large)]
std::vector<float> dyn_energy(width * height);
@ -88,16 +100,14 @@ std::vector<int> optimal_seam(std::vector<float> energy, int width, int height,
for (auto i = 1; i < dim_long; i++) { // Propagate dyn_energy
for (auto j = 0; j < dim_large; j++) {
float bot_center = dyn_energy[dim_large * (i - 1) + j];
float bot_left = (j > 0) ? dyn_energy[dim_large*(i-1) + (j-1)] : __FLT_MAX__;
float bot_right = (j+1 < dim_large) ? dyn_energy[dim_large*(i-1) + (j+1)] : __FLT_MAX__;
float bot_left =
(j > 0) ? dyn_energy[dim_large * (i - 1) + (j - 1)] : __FLT_MAX__;
float bot_right = (j + 1 < dim_large)
? dyn_energy[dim_large * (i - 1) + (j + 1)]
: __FLT_MAX__;
dyn_energy[dim_large*i+j] = fmin(
bot_center,
fmin(
bot_left,
bot_right
)
) + energy[im_index(i, j)];
dyn_energy[dim_large * i + j] =
fmin(bot_center, fmin(bot_left, bot_right)) + energy[im_index(i, j)];
}
}
@ -115,13 +125,15 @@ std::vector<int> optimal_seam(std::vector<float> energy, int width, int height,
//* Backtracking to find the path
for (auto i = dim_long - 1; i > 0; i--) {
// We want to find either (bot_l, bot_c, bot_r) with dyn_energy[.] = min_val - energy[cur]
// We want to find either (bot_l, bot_c, bot_r) with dyn_energy[.] = min_val -
// energy[cur]
// Idea : float next_energy = min_val - energy[width*i + min_idx];
//! With floats, we don't always have x + y - y == x, so we check is x+y == x+y
// This define is a bit ugly but 200x faster than using a lambda function
#define is_next_idx(idx) \
(dyn_energy[(i-1)*dim_large + idx]+energy[im_index(i, min_idx)] == min_val)
(dyn_energy[(i - 1) * dim_large + idx] + energy[im_index(i, min_idx)] == \
min_val)
if (is_next_idx(min_idx)) {
// min_idx does not change
@ -142,18 +154,22 @@ std::vector<int> optimal_seam(std::vector<float> energy, int width, int height,
return result;
}
/** Carves an image by one seam. Returns the optimal seam used */
std::vector<int> carving_step(const std::vector<unsigned char> source, std::vector<unsigned char> &output, int width, int height, int nbChannels, bool vertical) {
std::vector<float> energy = energy_e1(source, width, height, nbChannels);
std::vector<int> opt_seam = optimal_seam(energy, width, height, vertical);
void remove_seam(const std::vector<unsigned char> source,
std::vector<unsigned char> &output, int width, int height,
int nbChannels, bool vertical, const std::vector<int> seam)
{
/* remove the given seam from the image, the result is in output*/
std::vector<bool> blacklist(width * height);
int dim_large = vertical ? width : height;
int dim_long = vertical ? height : width;
for (auto k=0; k < width*height; k++) { blacklist[k] = false; }
for (auto k = 0; k < width * height; k++) {
blacklist[k] = false;
}
for (auto i = 0; i < dim_long; i++) {
int index = vertical ? opt_seam[i]+i*width : i+width*opt_seam[i];
int index = vertical ? seam[i] + i * width : i + width * seam[i];
blacklist[index] = true;
}
@ -161,7 +177,8 @@ std::vector<int> carving_step(const std::vector<unsigned char> source, std::vect
int cur_j = 0;
for (auto j = 0; cur_j < dim_large - 1 && j < dim_large; j++) {
if (!blacklist[im_index(i, j)]) {
int out_pixelIndex = nbChannels*(vertical ? ((width-1)*i + cur_j) : (width*cur_j + i));
int out_pixelIndex = nbChannels * (vertical ? ((width - 1) * i + cur_j)
: (width * cur_j + i));
int src_pixelIndex = nbChannels * im_index(i, j);
for (auto ch = 0; ch < nbChannels; ch++)
@ -170,11 +187,28 @@ std::vector<int> carving_step(const std::vector<unsigned char> source, std::vect
}
}
}
}
std::vector<int> carving_step(const std::vector<unsigned char> source,
std::vector<unsigned char> &output, int width,
int height, int nbChannels, bool vertical) {
/** Carves an image by one seam. Returns the optimal seam used */
std::vector<float> energy = energy_e1(source, width, height, nbChannels);
std::vector<int> opt_seam = optimal_seam(energy, width, height, vertical);
remove_seam(source, output, width, height, nbChannels, vertical, opt_seam);
return opt_seam;
}
void seam_carving(unsigned char* source, int width, int height, int nbChannels, const char* out_filename, int nbSeams, bool vertical, bool test_energy=false) {
void seam_carving(unsigned char *source, int width, int height, int nbChannels,
const char *out_filename, int nbSeams, bool vertical,
bool test_energy = false) {
int nbColorChannels = nbChannels > 3 ? 3 : nbChannels;
int curWidth = width;
int curHeight = height;
@ -182,22 +216,32 @@ void seam_carving(unsigned char* source, int width, int height, int nbChannels,
int dim_large = vertical ? width : height;
int dim_long = vertical ? height : width;
std::vector<unsigned char> carve_output(width*height*nbChannels); // Receives at each step the newly carved image
std::vector<unsigned char> source_img(width*height*nbChannels); // Contains at each step the carved image
std::vector<bool> complete_blacklist(width*height); // Contains all removed pixels, for "test_energy"
std::vector<float> ini_energy; // Contains the initial energy, only for "test_energy"
std::vector<unsigned char> test_energy_output(width*height*nbChannels); // Final output for "test_energy"
std::vector<unsigned char> carve_output(
width * height *
nbChannels); // Receives at each step the newly carved image
std::vector<unsigned char> source_img(
width * height * nbChannels); // Contains at each step the carved image
std::vector<bool> complete_blacklist(
width * height); // Contains all removed pixels, for "test_energy"
std::vector<float>
ini_energy; // Contains the initial energy, only for "test_energy"
std::vector<unsigned char> test_energy_output(
width * height * nbChannels); // Final output for "test_energy"
for (auto i=0; i < width*height*nbChannels; i++) { source_img[i] = source[i]; }
for (auto i = 0; i < width * height * nbChannels; i++) {
source_img[i] = source[i];
}
if (test_energy) {
ini_energy = energy_e1(source_img, width, height, nbChannels);
for (auto k=0; k < width*height; k++) { complete_blacklist[k] = false; }
for (auto k = 0; k < width * height; k++) {
complete_blacklist[k] = false;
}
//* Prepare final output
for (auto k = 0; k < width * height; k++) {
//for (auto i=0; i < nbColorChannels; i++) //* Uncomment if you prefer to see darkened source image
// for (auto i=0; i < nbColorChannels; i++) //* Uncomment if you prefer to
// see darkened source image
// output[nbChannels*k+i] = source_img[nbChannels*k+i]/nbChannels;
for (auto i = 0; i < nbColorChannels; i++)
test_energy_output[nbChannels * k + i] = ini_energy[k] * 255;
@ -209,7 +253,8 @@ void seam_carving(unsigned char* source, int width, int height, int nbChannels,
SimpleProgressBar::ProgressBar bar(nbSeams);
for (auto seam = 0; seam < nbSeams; seam++) {
std::vector<int> opt_seam = carving_step(source_img, carve_output, curWidth, curHeight, nbChannels, vertical);
std::vector<int> opt_seam = carving_step(source_img, carve_output, curWidth,
curHeight, nbChannels, vertical);
std::copy(carve_output.begin(), carve_output.end(), source_img.begin());
if (vertical) // We just reduced the dimension
@ -219,14 +264,19 @@ void seam_carving(unsigned char* source, int width, int height, int nbChannels,
if (test_energy) { // Update blacklist
for (auto i = 0; i < dim_long; i++) {
int j, cur_j = 0; // cur_j is the index relative to the current carved image. j is absolute in the source image
int j, cur_j = 0; // cur_j is the index relative to the current carved
// image. j is absolute in the source image
for (j = 0; j < dim_large && cur_j < opt_seam[i]; j++) {
if (!complete_blacklist[im_index(i, j)]) { cur_j++; }
if (!complete_blacklist[im_index(i, j)]) {
cur_j++;
}
assert(cur_j == opt_seam[i]); // Else, j == width and cur_j is not in the source image..
}
assert(cur_j == opt_seam[i]); // Else, j == width and cur_j is not in
// the source image..
complete_blacklist[im_index(i, j)] = true;
test_energy_output[nbChannels*im_index(i, j)] = 255; // Set carved pixel to red
test_energy_output[nbChannels * im_index(i, j)] =
255; // Set carved pixel to red
}
}
bar.increment();
@ -235,17 +285,21 @@ void seam_carving(unsigned char* source, int width, int height, int nbChannels,
std::cout << std::endl;
if (test_energy) {
export_image(out_filename, test_energy_output.data(), width, height, nbChannels);
export_image(out_filename, test_energy_output.data(), width, height,
nbChannels);
} else {
export_image(out_filename, source_img.data(), curWidth, curHeight, nbChannels);
export_image(out_filename, source_img.data(), curWidth, curHeight,
nbChannels);
}
}
int main(int argc, char **argv) {
CLI::App app{"seam-carving"};
std::string sourceImage;
app.add_option("-s,--source", sourceImage, "Source image")->required()->check(CLI::ExistingFile);;
app.add_option("-s,--source", sourceImage, "Source image")
->required()
->check(CLI::ExistingFile);
;
std::string outputImage = "output.png";
app.add_option("-o,--output", outputImage, "Output image")->required();
int nbSeams = 1;
@ -255,17 +309,20 @@ int main(int argc, char **argv) {
silent = false;
app.add_flag("--silent", silent, "No verbose messages");
test_energy = false;
app.add_flag("--test-energy", test_energy, "Don't resize image, just try the specified energy function");
app.add_flag("--test-energy", test_energy,
"Don't resize image, just try the specified energy function");
CLI11_PARSE(app, argc, argv);
// Image loading
int width, height, nbChannels;
unsigned char *source = stbi_load(sourceImage.c_str(), &width, &height, &nbChannels, 0);
unsigned char *source =
stbi_load(sourceImage.c_str(), &width, &height, &nbChannels, 0);
nbSeams = min(nbSeams, width);
// std::cout << "channels: " << nbChannels << std::endl;
seam_carving(source, width, height, nbChannels, outputImage.c_str(), nbSeams, vertical, test_energy=test_energy);
seam_carving(source, width, height, nbChannels, outputImage.c_str(), nbSeams,
vertical, test_energy = test_energy);
stbi_image_free(source);
exit(0);