+++ /dev/null
-
-/*
- * 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 <francois.fleuret@idiap.ch>
- *
- * 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 <http://www.gnu.org/licenses/>.
- *
- */
-
-#include <iostream>
-#include <fstream>
-#include <cmath>
-#include <stdio.h>
-#include <stdlib.h>
-#include <stdint.h>
-#include <errno.h>
-#include <string.h>
-#include <sys/stat.h>
-#include <sys/time.h>
-
-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;
- }
-}
projects / flatland.git / blobdiff