atomorph/demo/main.cpp

301 lines
10 KiB
C++

/*
* See Copyright Notice in main.h
*/
#include <stdio.h>
#include <math.h>
#include <chrono>
#include <thread>
#include "main.h"
#include "lodepng.h"
#include "../src/atomorph.h"
MORPH_OPTIONS options;
int main(int argc, char **argv) {
if (!init(argc, argv)) {
fprintf(stderr, "Failed to initialize!\n");
return -1;
}
if (options.exit_flag) return 0;
std::chrono::steady_clock::time_point program_start;
std::chrono::steady_clock::time_point program_end;
program_start = std::chrono::steady_clock::now();
{
am::morph morph;
// Options should be set before any operations with
// the morph instance. However, they can be changed
// during the run time too.
morph.set_blob_delimiter (options.differ_blobs);
morph.set_blob_max_size (options.blob_max_size);
morph.set_blob_min_size (options.blob_min_size);
morph.set_blob_box_grip (options.blob_box_grip);
morph.set_blob_box_samples(options.blob_box_samples);
morph.set_blob_threshold (options.blob_threshold);
morph.set_blob_number (options.blob_number);
morph.set_seed (options.seed);
morph.set_blob_rgba_weight(options.blob_rgba_weight);
morph.set_blob_size_weight(options.blob_size_weight);
morph.set_blob_xy_weight (options.blob_xy_weight);
morph.set_degeneration (options.degenerate);
morph.set_density (options.density); // Higher than 1 sets fluid to 0.
morph.set_motion (options.motion);
morph.set_fading (options.fading);
morph.set_threads (options.threads);
morph.set_cycle_length (options.cycle_length);
morph.set_feather (options.feather);
morph.set_keep_background (options.keep_background);
morph.set_finite (options.finite);
morph.set_show_blobs (options.show_blobs);
morph.set_fluid (options.fluid); // Higher than 0 sets density to 1.
if (!load_files(&morph)) return -1;
main_loop (&morph);
save_files(&morph);
}
program_end = std::chrono::steady_clock::now();
if (options.verbose) {
size_t duration = std::chrono::duration_cast<std::chrono::microseconds>(program_end - program_start).count();
if (duration < 1000) printf("Process took %lu microseconds to finish.\n", duration);
else if (duration < 1000000) printf("Process took %lu milliseconds to finish.\n", duration/1000);
else printf("Process took %lu seconds to finish.\n", duration/1000000);
}
return 0;
}
bool init(int argc, char **argv) {
if (true == (am::get_warning()&am::WARN_POINTER_SIZE)) {
fprintf(stderr, "Pointer size is insufficiently small.\n");
}
if (true == (am::get_warning()&am::WARN_PIXEL_SIZE)) {
fprintf(stderr, "Pixel size (%lu) is larger than optimal (%lu).\n",
sizeof(am::pixel),
sizeof(void *)
);
}
if (true == (am::get_warning()&am::WARN_POINT_SIZE)) {
fprintf(stderr, "Point size (%lu) is larger than optimal (%lu).\n",
sizeof(am::point),
sizeof(void *)
);
}
if (am::uses_opencv()) {
fprintf(stderr, "Experimental OpenCV optimizations are enabled.\n");
}
if (argc == 1) {
fprintf(stderr, "No arguments specified, try \"\e[1;33m%s --help\e[0m\".\n", argv[0]);
}
return options.parse(argc, argv);
}
bool fill_morph(am::morph *morph, size_t frame, std::vector<unsigned char> *image, unsigned width) {
size_t sz = image->size();
unsigned char r=0,g=0,b=0,a=0;
size_t pixel = 0;
bool empty = true;
if (width > UINT16_MAX) return false;
for (size_t j=0; j<sz; ++j) {
switch (j%4) {
case 0: r=image->at(j); break;
case 1: g=image->at(j); break;
case 2: b=image->at(j); break;
default: {
a=image->at(j);
if (a == 0) {
pixel++;
continue;
}
morph->add_pixel(frame, am::create_pixel(pixel%width, pixel/width, r, g, b, a));
pixel++;
empty = false;
break;
}
}
}
if (empty) morph->add_frame(frame);
return true;
}
void save_files(am::morph *morph) {
for (unsigned f = 0; f<options.frames_out; ++f) {
write_image(morph, f, morph->get_width(), morph->get_height());
}
}
bool load_files(am::morph *morph) {
std::string buf;
std::vector<unsigned char> image;
unsigned width, height, error;
unsigned max_width=0, max_height=0;
image.reserve(262144);
size_t i;
// Load input image files:
for (i=0; i<options.files.size(); ++i) {
buf=options.indir; buf.append("/"); buf.append(options.files[i]);
if (options.verbose) printf("Loading %-30s ... ", buf.c_str());
error = lodepng::decode(image, width, height, buf.c_str());
if (error) {
std::cerr << lodepng_error_text(error) << "." << std::endl;
return false;
}
max_width = std::max(max_width, width);
max_height = std::max(max_height, height);
if (options.verbose) printf("%ux%u image decoded.\n", width, height);
if (!fill_morph(morph, i, &image, width) && options.verbose) {
printf("Unable to fill %lu. frame.\n", i);
}
image.clear();
}
if (morph->get_frame_count()==0) {
fprintf(stderr, "Error. Morph does not contain any key frames.\n");
return false;
}
width = max_width;
height= max_height;
morph->set_resolution(width, height);
return true;
}
void write_image(am::morph *morph, size_t frame_out, unsigned width, unsigned height) {
double t = morph->get_time(frame_out, options.frames_out);
char buf[1024];
sprintf(buf, "%s/%s_%04lu.png", options.outdir.c_str(), options.file.c_str(), frame_out+1);
if (options.verbose) printf("Rendering %4lu. frame ... ", frame_out+1);
std::vector<unsigned char> image;
image.reserve(4*width*height);
image.resize (4*width*height, 0);
std::vector<am::pixel> pixels;
morph->get_pixels(t, &pixels);
while (!pixels.empty()) {
am::pixel px = pixels.back();
pixels.pop_back();
size_t pos = (px.y*width + px.x)*4;
if (pos >= image.size()) continue;
image[pos + 0] = px.c.r;
image[pos + 1] = px.c.g;
image[pos + 2] = px.c.b;
image[pos + 3] = px.c.a;
}
if (options.verbose) printf("writing %s ... ", buf);
unsigned error = lodepng::encode(buf, image, width, height);
if (error) {
if (options.verbose) printf("[\e[1;31mFAIL\e[0m]\n");
std::cerr << "encoder error " << error << ": "<< lodepng_error_text(error) << std::endl;
}
else if (options.verbose) printf("[\e[1;32mDONE\e[0m]\n");
}
void main_loop(am::morph *morph) {
if (options.verbose) {
printf("Blobifying %ux%u morph.\n", morph->get_width(), morph->get_height());
}
std::chrono::steady_clock::time_point start,end;
start = std::chrono::steady_clock::now();
size_t blob_count = 0;
size_t largest_frame = 0;
double last_energy = 0.0;
size_t match_blobs = 0;
size_t morph_atoms = 0;
size_t fs = options.files.size();
while (1) {
morph->suspend();
morph->synchronize();
morph->compute();
blob_count = 0;
for (size_t i=0; i<fs; ++i) {
size_t bc = morph->get_blob_count(i);
if (bc >= blob_count) {
blob_count = bc;
largest_frame = i;
}
}
unsigned morph_state = morph->get_state();
end = std::chrono::steady_clock::now();
if (std::chrono::duration_cast<std::chrono::milliseconds>(end - start).count() > 1000) {
if (morph_state == am::STATE_BLOB_DETECTION
|| morph_state == am::STATE_BLOB_UNIFICATION) {
if (options.verbose) {
printf("%lu/%lu blob%s remaining on frame %lu.\n",
blob_count, morph->get_blob_count(),
blob_count == 1 ? "" : "s", largest_frame
);
}
}
else if (morph_state == am::STATE_BLOB_MATCHING) {
if (options.verbose) {
double e = morph->get_energy();
if (last_energy < e) printf("Matching blobs, absolute energy was %30.10f.\n", e);
else printf("Matching blobs, energy decreased by %30.10f.\n", last_energy - e);
last_energy = e;
}
if (++match_blobs >= options.match_time) {
morph->next_state();
last_energy = 0.0;
}
}
else if (morph_state == am::STATE_ATOM_MORPHING) {
if (options.verbose) {
double e = morph->get_energy();
if (last_energy < e) printf("Matching atoms, absolute energy was %30.2f.\n", e);
else printf("Matching atoms, energy decreased by %30.2f.\n", last_energy - e);
last_energy = e;
}
if (++morph_atoms >= options.morph_time) {
morph->next_state();
}
}
else if (morph_state == am::STATE_DONE) {
if (options.verbose) printf("All done!\n");
break;
}
else {
if (options.verbose) printf("Unknown state!\n");
break;
}
start = std::chrono::steady_clock::now();
}
std::this_thread::sleep_for(std::chrono::milliseconds(100));
}
if (options.verbose) {
printf("Frame %lu had the most blobs (%lu).\n", largest_frame, blob_count);
}
return;
}