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);
}
}
