X-Git-Url: https://fleuret.org/cgi-bin/gitweb/gitweb.cgi?p=flatland.git;a=blobdiff_plain;f=sequence_generator.cc;fp=sequence_generator.cc;h=6e6b747648d0c624b259b45bc55043a558fd6797;hp=0000000000000000000000000000000000000000;hb=ee0d125312834bf7692df2e9caa1f858780f335c;hpb=85e284b40ef2175f672298b64bf79424da8ebc19 diff --git a/sequence_generator.cc b/sequence_generator.cc new file mode 100644 index 0000000..6e6b747 --- /dev/null +++ b/sequence_generator.cc @@ -0,0 +1,233 @@ + +/* + * dyncnn is a deep-learning algorithm for the prediction of + * interacting object dynamics + * + * Copyright (c) 2016 Idiap Research Institute, http://www.idiap.ch/ + * Written by Francois Fleuret + * + * This file is part of dyncnn. + * + * dyncnn is free software: you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 3 as + * published by the Free Software Foundation. + * + * dyncnn is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with dyncnn. If not, see . + * + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +using namespace std; + +#include "misc.h" +#include "universe.h" +#include "canvas_cairo.h" + +////////////////////////////////////////////////////////////////////// + +void draw_universe_on_canvas(CanvasCairo *canvas, scalar_t scaling, + Universe *universe) { + canvas->set_line_width(1.0 / scaling); + universe->draw(canvas); +} + +void draw_grabbing_point_on_canvas(CanvasCairo *canvas, scalar_t scaling, + scalar_t xg, scalar_t yg, + scalar_t r, scalar_t g, scalar_t b) { + scalar_t radius = 1/scaling; + int n = 36; + scalar_t xp[n], yp[n]; + for(int k = 0; k < n; k++) { + scalar_t alpha = 2 * M_PI * scalar_t(k) / scalar_t(n); + xp[k] = xg + radius * cos(alpha); + yp[k] = yg + radius * sin(alpha); + } + canvas->set_drawing_color(r, g, b); + canvas->set_line_width(2.0); + canvas->draw_polygon(1, n, xp, yp); +} + +////////////////////////////////////////////////////////////////////// + +extern "C" void fl_generate_sequences(int nb_sequences, + int nb_images_per_sequence, + int width, int height, + unsigned char *output) { + + const scalar_t world_width = width * 8; + const scalar_t world_height = height * 8; + const scalar_t scaling = 0.125; + + const scalar_t dt = 0.1; + const int nb_iterations_per_steps = 5; + + ////////////////////////////////////////////////////////////////////// + + // We will generate images { 0, every_nth, 2 * every_nth, ..., k * every_nth < nb_simulated_frames } + + // The framerate every_nth may be set to smaller value to generate + // nice materials for presentations or papers. + + int every_nth = 16; + int nb_simulated_frames = 1 + (nb_images_per_sequence - 1) * every_nth; + int random_grasp = 1; + int random_shape_size = 0; + int nb_shapes = 10; + int skip = -1; + + for(int n = 0; n < nb_sequences; n++) { + + Universe *universe; + Polygon *grabbed_polygon; + + universe = new Universe(nb_shapes, world_width, world_height); + + const int nb_saved_frames = (nb_simulated_frames + every_nth - 1) / every_nth; + if(nb_saved_frames != nb_images_per_sequence) { + cerr << "It makes no sense." << endl; + abort(); + } + + CanvasCairo *canvases[nb_saved_frames * 2]; + + for(int s = 0; s < 2 * nb_saved_frames; s++) { + canvases[s] = new CanvasCairo(scaling, universe->width(), universe->height()); + } + + scalar_t grab_start_x, grab_start_y; + + if(random_grasp) { + grab_start_x = world_width * (0.1 + 0.8 * drand48()); + grab_start_y = world_height * (0.1 + 0.8 * drand48()); + } else { + grab_start_x = world_width * 0.5; + grab_start_y = world_height * 0.75; + } + + do { + universe->clear(); + + const int nb_attempts_max = 100; + int nb_attempts = 0; + + for(int u = 0; u < nb_shapes; u++) { + Polygon *pol = 0; + + nb_attempts = 0; + + scalar_t shape_size; + + if(random_shape_size) { + shape_size = 40 + 80 * drand48(); + } else { + shape_size = 80; + } + + do { + scalar_t x[] = { - shape_size * 0.4, + shape_size * 0.4, + + shape_size * 0.4, - shape_size * 0.4 }; + + scalar_t y[] = { - shape_size * 0.6, - shape_size * 0.6, + + shape_size * 0.6, + shape_size * 0.6 }; + + scalar_t delta = shape_size / sqrt(2.0); + + scalar_t object_center_x = delta + (world_width - 2 * delta) * drand48(); + scalar_t object_center_y = delta + (world_height - 2 * delta) * drand48(); + + delete pol; + pol = new Polygon(0.5, 1.0, 1.0, 1.0, x, y, sizeof(x)/sizeof(scalar_t)); + pol->set_position(object_center_x, object_center_y, M_PI * 2 * drand48()); + pol->set_speed(0, 0, 0); + + universe->initialize_polygon(pol); + + nb_attempts++; + } while(nb_attempts < nb_attempts_max && universe->collide(pol)); + + if(nb_attempts == nb_attempts_max) { + delete pol; + u = -1; + universe->clear(); + nb_attempts = 0; + } else { + universe->add_polygon(pol); + } + } + + grabbed_polygon = universe->pick_polygon(grab_start_x, grab_start_y); + } while(!grabbed_polygon); + + if(skip < 0 || n >= skip) { + + scalar_t grab_relative_x = grabbed_polygon->relative_x(grab_start_x, grab_start_y); + scalar_t grab_relative_y = grabbed_polygon->relative_y(grab_start_x, grab_start_y); + + for(int s = 0; s < nb_simulated_frames; s++) { + if(s % every_nth == 0) { + int t = s / every_nth; + // scalar_t xf = grabbed_polygon->absolute_x(grab_relative_x, grab_relative_y); + // scalar_t yf = grabbed_polygon->absolute_y(grab_relative_x, grab_relative_y); + + // canvases[2 * t + 0]->clear(); + // draw_grabbing_point_on_canvas(canvases[2 * t + 0], scaling, + // xf, yf, 0.0, 0.0, 0.0); + // canvases[2 * t + 1]->clear(); + // draw_universe_on_canvas(canvases[2 * t + 1], scaling, universe); + + canvases[t]->clear(); + draw_universe_on_canvas(canvases[t], scaling, universe); + + // if(show_grabbing_point) { + // draw_grabbing_point_on_canvas(canvases[2 * t + 1], scaling, + // xf, yf, 1.0, 0.0, 0.0); + // } + } + + if(s < nb_simulated_frames - 1) { + // Run the simulation + for(int i = 0; i < nb_iterations_per_steps; i++) { + scalar_t xf = grabbed_polygon->absolute_x(grab_relative_x, grab_relative_y); + scalar_t yf = grabbed_polygon->absolute_y(grab_relative_x, grab_relative_y); + grabbed_polygon->apply_force(dt, xf, yf, 0.0, -1.0); + universe->update(dt, 1.0 / scaling); + } + } + } + + for(int t = 0; t < nb_images_per_sequence; t++) { + unsigned char *src = canvases[t]->_data; + unsigned char *dst = output + (n * nb_images_per_sequence + t) * width * height * 3; + for(int d = 0; d < 3; d++) { + for(int y = 0; y < height; y++) { + for(int x = 0; x < width; x++) { + dst[x + width * (y + height * d)] = src[d + 4 * (x + width * y)]; + } + } + } + } + } + + for(int t = 0; t < 2 * nb_saved_frames; t++) { + delete canvases[t]; + } + + delete universe; + } +}