3 * dyncnn is a deep-learning algorithm for the prediction of
4 * interacting object dynamics
6 * Copyright (c) 2016 Idiap Research Institute, http://www.idiap.ch/
7 * Written by Francois Fleuret <francois.fleuret@idiap.ch>
9 * This file is part of dyncnn.
11 * dyncnn is free software: you can redistribute it and/or modify it
12 * under the terms of the GNU General Public License version 3 as
13 * published by the Free Software Foundation.
15 * dyncnn is distributed in the hope that it will be useful, but
16 * WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18 * General Public License for more details.
20 * You should have received a copy of the GNU General Public License
21 * along with dyncnn. If not, see <http://www.gnu.org/licenses/>.
39 #include "canvas_cairo.h"
41 FILE *safe_fopen(const char *name, const char *mode) {
42 FILE *file = fopen(name, mode);
44 cerr << "Cannot open " << name << endl;
50 void print_help(const char *command) {
51 cerr << command << " <nb sequences to generate> [--dir <dir>] [--seed <seed>]]" << endl;
55 //////////////////////////////////////////////////////////////////////
57 void draw_universe_on_canvas(CanvasCairo *canvas, scalar_t scaling,
59 canvas->set_line_width(1.0 / scaling);
60 universe->draw(canvas);
63 void draw_grabbing_point_on_canvas(CanvasCairo *canvas, scalar_t scaling,
64 scalar_t xg, scalar_t yg,
65 scalar_t r, scalar_t g, scalar_t b) {
66 scalar_t radius = 1/scaling;
68 scalar_t xp[n], yp[n];
69 for(int k = 0; k < n; k++) {
70 scalar_t alpha = 2 * M_PI * scalar_t(k) / scalar_t(n);
71 xp[k] = xg + radius * cos(alpha);
72 yp[k] = yg + radius * sin(alpha);
74 canvas->set_drawing_color(r, g, b);
75 canvas->set_line_width(2.0);
76 canvas->draw_polygon(1, n, xp, yp);
79 //////////////////////////////////////////////////////////////////////
81 int main(int argc, char **argv) {
82 const scalar_t world_width = 400;
83 const scalar_t world_height = 400;
84 const scalar_t scaling = 0.16; // So that 400 * 0.16 = 64
86 const scalar_t dt = 0.1;
87 const int nb_iterations_per_steps = 5;
89 //////////////////////////////////////////////////////////////////////
91 // We will generate images { 0, every_nth, 2 * every_nth, ..., k * every_nth < nb_frames }
93 // The framerate every_nth may be set to smaller value to generate
94 // nice materials for presentations or papers.
99 int random_shape_size = 0;
101 char data_dir[1024] = "/tmp/";
102 int multi_images = 0;
103 int show_grabbing_point = 0;
106 //////////////////////////////////////////////////////////////////////
112 int nb_sequences = atoi(argv[1]);
116 if(strcmp(argv[i], "--dir") == 0) {
118 if(i == argc) { print_help(argv[0]);}
119 strncpy(data_dir, argv[i], sizeof(data_dir) / sizeof(char) - 1);
123 else if(strcmp(argv[i], "--seed") == 0) {
125 if(i == argc) { print_help(argv[0]); }
126 srand48(atoi(argv[i]));
130 else if(strcmp(argv[i], "--nb_shapes") == 0) {
132 if(i == argc) { print_help(argv[0]);}
133 nb_shapes = atoi(argv[i]);
137 else if(strcmp(argv[i], "--random_grasp") == 0) {
142 else if(strcmp(argv[i], "--random_shape_size") == 0) {
143 random_shape_size = 1;
147 else if(strcmp(argv[i], "--every_nth") == 0) {
149 if(i == argc) { print_help(argv[0]);}
150 every_nth = atoi(argv[i]);
154 else if(strcmp(argv[i], "--nb_frames") == 0) {
156 if(i == argc) { print_help(argv[0]);}
157 nb_frames = atoi(argv[i]);
161 else if(strcmp(argv[i], "--multi_images") == 0) {
166 else if(strcmp(argv[i], "--show_grabbing_point") == 0) {
167 show_grabbing_point = 1;
171 else if(strcmp(argv[i], "--skip") == 0) {
173 if(i == argc) { print_help(argv[0]);}
174 skip = atoi(argv[i]);
179 cerr << "Unknown option " << argv[i] << "." << endl;
184 if(nb_shapes < 1 || nb_shapes > 10) {
185 cerr << "nb_shapes has to be in {1, ..., 10}" << endl;
189 if(nb_frames < 0 || nb_frames > 50) {
190 cerr << "nb_frames has to be in {0, ..., 50}" << endl;
194 for(int n = 0; n < nb_sequences; n++) {
197 Polygon *grabbed_polygon;
199 universe = new Universe(nb_shapes, world_width, world_height);
201 const int nb_saved_frames = (nb_frames + every_nth - 1) / every_nth;
203 CanvasCairo *canvases[nb_saved_frames * 2];
205 for(int s = 0; s < 2 * nb_saved_frames; s++) {
206 canvases[s] = new CanvasCairo(scaling, universe->width(), universe->height());
209 scalar_t grab_start_x, grab_start_y;
212 grab_start_x = world_width * (0.1 + 0.8 * drand48());
213 grab_start_y = world_height * (0.1 + 0.8 * drand48());
215 grab_start_x = world_width * 0.5;
216 grab_start_y = world_height * 0.75;
221 << n+1 << "/" << nb_sequences << " sequences in "
229 const int nb_attempts_max = 100;
232 for(int u = 0; u < nb_shapes; u++) {
239 if(random_shape_size) {
240 shape_size = 40 + 80 * drand48();
246 scalar_t x[] = { - shape_size * 0.4, + shape_size * 0.4,
247 + shape_size * 0.4, - shape_size * 0.4 };
249 scalar_t y[] = { - shape_size * 0.6, - shape_size * 0.6,
250 + shape_size * 0.6, + shape_size * 0.6 };
252 scalar_t delta = shape_size / sqrt(2.0);
254 scalar_t object_center_x = delta + (world_width - 2 * delta) * drand48();
255 scalar_t object_center_y = delta + (world_height - 2 * delta) * drand48();
258 pol = new Polygon(0.5, 1.0, 1.0, 1.0, x, y, sizeof(x)/sizeof(scalar_t));
259 pol->set_position(object_center_x, object_center_y, M_PI * 2 * drand48());
260 pol->set_speed(0, 0, 0);
262 universe->initialize_polygon(pol);
265 } while(nb_attempts < nb_attempts_max && universe->collide(pol));
267 if(nb_attempts == nb_attempts_max) {
273 universe->add_polygon(pol);
277 grabbed_polygon = universe->pick_polygon(grab_start_x, grab_start_y);
278 } while(!grabbed_polygon);
282 sprintf(buffer, "%s/%03d/", data_dir, n / 1000);
286 if(skip < 0 || n >= skip) {
288 scalar_t grab_relative_x = grabbed_polygon->relative_x(grab_start_x, grab_start_y);
289 scalar_t grab_relative_y = grabbed_polygon->relative_y(grab_start_x, grab_start_y);
291 for(int s = 0; s < nb_frames; s++) {
292 if(s % every_nth == 0) {
293 int t = s / every_nth;
294 scalar_t xf = grabbed_polygon->absolute_x(grab_relative_x, grab_relative_y);
295 scalar_t yf = grabbed_polygon->absolute_y(grab_relative_x, grab_relative_y);
297 canvases[2 * t + 0]->clear();
298 draw_grabbing_point_on_canvas(canvases[2 * t + 0], scaling,
299 xf, yf, 0.0, 0.0, 0.0);
300 canvases[2 * t + 1]->clear();
301 draw_universe_on_canvas(canvases[2 * t + 1], scaling, universe);
303 if(show_grabbing_point) {
304 draw_grabbing_point_on_canvas(canvases[2 * t + 1], scaling,
305 xf, yf, 1.0, 0.0, 0.0);
309 if(s < nb_frames - 1) {
310 // Run the simulation
311 for(int i = 0; i < nb_iterations_per_steps; i++) {
312 scalar_t xf = grabbed_polygon->absolute_x(grab_relative_x, grab_relative_y);
313 scalar_t yf = grabbed_polygon->absolute_y(grab_relative_x, grab_relative_y);
314 grabbed_polygon->apply_force(dt, xf, yf, 0.0, -1.0);
315 universe->update(dt);
323 for(int j = 0; j < nb_saved_frames; j++) {
325 sprintf(buffer, "%s/%03d/dyn_%06d_grab_%02d.png", data_dir, n / 1000, n, j);
326 file = safe_fopen(buffer, "w");
327 canvases[j * 2 + 0]->write_png(file);
329 sprintf(buffer, "%s/%03d/dyn_%06d_state_%02d.png", data_dir, n / 1000, n, j);
330 file = safe_fopen(buffer, "w");
331 canvases[j * 2 + 1]->write_png(file);
335 CanvasCairo main_canvas(scaling, nb_saved_frames, 2, canvases);
336 sprintf(buffer, "%s/%03d/dyn_%06d.png", data_dir, n / 1000, n);
337 FILE *file = safe_fopen(buffer, "w");
338 main_canvas.write_png(file);
343 for(int t = 0; t < 2 * nb_saved_frames; t++) {