void distort_2d_data_transformer::transform( const float * data, float * data_transformed, const layer_configuration_specific& original_config, unsigned int sample_id) { if (original_config.dimension_sizes.size() < 2) throw neural_network_exception((boost::format("distort_2d_data_transformer is processing at least 2d data, data is passed with number of dimensions %1%") % original_config.dimension_sizes.size()).str()); float rotation_angle = rotate_angle_distribution.min(); float scale = scale_distribution.min(); float shift_x = shift_x_distribution.min(); float shift_y = shift_y_distribution.min(); bool flip_around_x_axis = (flip_around_x_distribution.min() == 1); bool flip_around_y_axis = (flip_around_y_distribution.min() == 1); float stretch = stretch_distribution.min(); float stretch_angle = stretch_angle_distribution.min(); float perspective_reverse_distance = perspective_reverse_distance_distribution.min(); float perspective_distance = std::numeric_limits<float>::max(); float perspective_angle = perspective_angle_distribution.min(); { std::lock_guard<std::mutex> lock(gen_stream_mutex); if (apply_rotate_angle_distribution) rotation_angle = rotate_angle_distribution(generator); if (apply_scale_distribution) scale = scale_distribution(generator); if (apply_shift_x_distribution) shift_x = shift_x_distribution(generator); if (apply_shift_y_distribution) shift_y = shift_y_distribution(generator); if (flip_around_x_distribution.max() > flip_around_x_distribution.min()) flip_around_x_axis = (flip_around_x_distribution(generator) == 1); if (flip_around_y_distribution.max() > flip_around_y_distribution.min()) flip_around_y_axis = (flip_around_y_distribution(generator) == 1); if (apply_stretch_distribution) stretch = stretch_distribution(generator); stretch_angle = stretch_angle_distribution(generator); if (apply_perspective_reverse_distance_distribution) { perspective_reverse_distance = perspective_reverse_distance_distribution(generator); if (perspective_reverse_distance > 0.0F) perspective_distance = 1.0F / perspective_reverse_distance; } perspective_angle = perspective_angle_distribution(generator); } unsigned int neuron_count_per_image = original_config.dimension_sizes[0] * original_config.dimension_sizes[1]; unsigned int image_count = original_config.get_neuron_count() / neuron_count_per_image; for(unsigned int image_id = 0; image_id < image_count; ++image_id) { cv::Mat1f dest_image(static_cast<int>(original_config.dimension_sizes[1]), static_cast<int>(original_config.dimension_sizes[0]), data_transformed + (image_id * neuron_count_per_image)); cv::Mat1f image(static_cast<int>(original_config.dimension_sizes[1]), static_cast<int>(original_config.dimension_sizes[0]), const_cast<float *>(data) + (image_id * neuron_count_per_image)); if ((rotation_angle != 0.0F) || (scale != 1.0F) || (shift_x != 0.0F) || (shift_y != 0.0F) || (stretch != 1.0F) || (perspective_distance != std::numeric_limits<float>::max())) { data_transformer_util::stretch_rotate_scale_shift_perspective( dest_image, image, cv::Point2f(static_cast<float>(image.cols) * 0.5F, static_cast<float>(image.rows) * 0.5F), rotation_angle, scale, shift_x, shift_y, stretch, stretch_angle, perspective_distance, perspective_angle, border_value); data_transformer_util::flip( dest_image, flip_around_x_axis, flip_around_y_axis); } else { data_transformer_util::flip( dest_image, image, flip_around_x_axis, flip_around_y_axis); } } }
void gtsrb_toolset::write_folder( nnforge::supervised_data_stream_writer& writer, const boost::filesystem::path& relative_subfolder_path, const char * annotation_file_name, bool jitter) { boost::filesystem::path subfolder_path = get_input_data_folder() / relative_subfolder_path; boost::filesystem::path annotation_file_path = subfolder_path / annotation_file_name; std::cout << "Reading input data from " << subfolder_path.string() << std::endl; boost::filesystem::ifstream file_input(annotation_file_path, std::ios_base::in); nnforge::random_generator generator = nnforge::rnd::get_random_generator(); std::tr1::uniform_real<float> rotate_angle_distribution(-max_rotation_angle_in_degrees, max_rotation_angle_in_degrees); std::tr1::uniform_real<float> scale_distribution(1.0F / max_scale_factor, max_scale_factor); std::tr1::uniform_real<float> shift_distribution(-max_shift, max_shift); std::tr1::uniform_real<float> contrast_distribution(1.0F / max_contrast_factor, max_contrast_factor); std::tr1::uniform_real<float> brightness_shift_distribution(-max_brightness_shift, max_brightness_shift); std::string str; std::getline(file_input, str); // read the header while (true) { std::getline(file_input, str); std::vector<std::string> strs; boost::split(strs, str, boost::is_any_of(";")); if (strs.size() != 8) break; std::string file_name = strs[0]; boost::filesystem::path absolute_file_path = subfolder_path / file_name; char* end; unsigned int top_left_x = static_cast<unsigned int>(strtol(strs[3].c_str(), &end, 10)); unsigned int top_left_y = static_cast<unsigned int>(strtol(strs[4].c_str(), &end, 10)); unsigned int bottom_right_x = static_cast<unsigned int>(strtol(strs[5].c_str(), &end, 10)); unsigned int bottom_right_y = static_cast<unsigned int>(strtol(strs[6].c_str(), &end, 10)); unsigned int class_id = static_cast<unsigned int>(strtol(strs[7].c_str(), &end, 10)); if (jitter) { for(int i = 0; i < random_sample_count; ++i) { float rotation_angle = rotate_angle_distribution(generator); float scale = scale_distribution(generator); float shift_x = shift_distribution(generator); float shift_y = shift_distribution(generator); float contrast = contrast_distribution(generator); float brightness_shift = brightness_shift_distribution(generator); write_single_entry( writer, absolute_file_path, class_id, top_left_x, top_left_y, bottom_right_x, bottom_right_y, rotation_angle, scale, shift_x, shift_y, contrast, brightness_shift); } } else { write_single_entry( writer, absolute_file_path, class_id, top_left_x, top_left_y, bottom_right_x, bottom_right_y); } } }
void distort_2d_data_transformer::transform( const void * data, void * data_transformed, neuron_data_type::input_type type, const layer_configuration_specific& original_config, unsigned int sample_id) { if (type != neuron_data_type::type_byte) throw neural_network_exception("distort_2d_data_transformer is implemented for data stored as bytes only"); if (original_config.dimension_sizes.size() < 2) throw neural_network_exception((boost::format("distort_2d_data_transformer is processing at least 2d data, data is passed with number of dimensions %1%") % original_config.dimension_sizes.size()).str()); float rotation_angle = rotate_angle_distribution.min(); if (rotate_angle_distribution.max() > rotate_angle_distribution.min()) rotation_angle = rotate_angle_distribution(generator); float scale = scale_distribution.min(); if (scale_distribution.max() > scale_distribution.min()) scale = scale_distribution(generator); float shift_x = shift_x_distribution.min(); if (shift_x_distribution.max() > shift_x_distribution.min()) shift_x = shift_x_distribution(generator); float shift_y = shift_y_distribution.min(); if (shift_y_distribution.max() > shift_y_distribution.min()) shift_y = shift_y_distribution(generator); bool flip_around_x_axis = (flip_around_x_distribution.min() == 1); if (flip_around_x_distribution.max() > flip_around_x_distribution.min()) flip_around_x_axis = (flip_around_x_distribution(generator) == 1); bool flip_around_y_axis = (flip_around_y_distribution.min() == 1); if (flip_around_y_distribution.max() > flip_around_y_distribution.min()) flip_around_y_axis = (flip_around_y_distribution(generator) == 1); float stretch = stretch_distribution.min(); if (stretch_distribution.max() > stretch_distribution.min()) stretch = stretch_distribution(generator); float stretch_angle = stretch_angle_distribution.min(); if (stretch_angle_distribution.max() > stretch_angle_distribution.min()) stretch_angle = stretch_angle_distribution(generator); float perspective_reverse_distance = perspective_reverse_distance_distribution.min(); if (perspective_reverse_distance_distribution.max() > perspective_reverse_distance_distribution.min()) perspective_reverse_distance = perspective_reverse_distance_distribution(generator); float perspective_distance = std::numeric_limits<float>::max(); if (perspective_reverse_distance > 0.0F) perspective_distance = 1.0F / perspective_reverse_distance; float perspective_angle = perspective_angle_distribution.min(); if (perspective_angle_distribution.max() > perspective_angle_distribution.min()) perspective_angle = perspective_angle_distribution(generator); unsigned int neuron_count_per_image = original_config.dimension_sizes[0] * original_config.dimension_sizes[1]; unsigned int image_count = original_config.get_neuron_count() / neuron_count_per_image; for(unsigned int image_id = 0; image_id < image_count; ++image_id) { cv::Mat1b image(static_cast<int>(original_config.dimension_sizes[1]), static_cast<int>(original_config.dimension_sizes[0]), static_cast<unsigned char *>(data_transformed) + (image_id * neuron_count_per_image)); if ((rotation_angle != 0.0F) || (scale != 1.0F) || (shift_x != 0.0F) || (shift_y != 0.0F) || (stretch != 1.0F) || (perspective_distance != std::numeric_limits<float>::max())) { data_transformer_util::stretch_rotate_scale_shift_perspective( image, cv::Point2f(static_cast<float>(image.cols) * 0.5F, static_cast<float>(image.rows) * 0.5F), rotation_angle, scale, shift_x, shift_y, stretch, stretch_angle, perspective_distance, perspective_angle, border_value); } data_transformer_util::flip( image, flip_around_x_axis, flip_around_y_axis); } }