void extract_data_transformer::transform(
const float * data,
float * data_transformed,
const layer_configuration_specific& original_config,
unsigned int sample_id)
{
if (input_window_sizes == output_window_sizes)
{
const std::vector<unsigned int>& dimension_sizes = original_config.dimension_sizes;
if (dimension_sizes.size() != input_window_sizes.size())
throw neural_network_exception((boost::format("extract_data_transformer is created with %1%-dimensions, data has %2% dimensions") % input_window_sizes.size() % dimension_sizes.size()).str());
std::vector<unsigned int> src_offset_list;
for(unsigned int i = 0; i < dimension_sizes.size(); ++i)
{
if (dimension_sizes[i] < output_window_sizes[i])
throw neural_network_exception((boost::format("Dimension %1% of original config has %2% size while minimum is %3%") % i % dimension_sizes[i] % output_window_sizes[i]).str());
src_offset_list.push_back((dimension_sizes[i] - output_window_sizes[i]) / 2);
}
std::vector<unsigned int> dst_pos_list(dimension_sizes.size(), 0);
const float * src_begin = data;
float * dst = data_transformed;
for(unsigned int feature_map_id = 0; feature_map_id < original_config.feature_map_count; ++feature_map_id)
{
while (true)
{
unsigned int offset = dst_pos_list.back() + src_offset_list.back();
for(int i = static_cast<int>(dimension_sizes.size()) - 2; i >= 0; --i)
offset = offset * dimension_sizes[i] + dst_pos_list[i] + src_offset_list[i];
memcpy(dst, src_begin + offset, output_window_sizes[0] * sizeof(float));
dst += output_window_sizes[0];
bool inc = false;
for(int i = 1; i < output_window_sizes.size(); ++i)
{
dst_pos_list[i]++;
if (dst_pos_list[i] < output_window_sizes[i])
{
inc = true;
break;
}
else
dst_pos_list[i] = 0;
}
if (!inc)
break;
}
src_begin += original_config.get_neuron_count_per_feature_map();
}
}
else
{
if (original_config.dimension_sizes.size() != 2)
throw neural_network_exception((boost::format("Resizing extract_data_transformer is processing 2D data only, data is passed with number of dimensions %1%") % original_config.dimension_sizes.size()).str());
int window_top_left_x = (original_config.dimension_sizes[0] - input_window_sizes[0]) / 2;
int window_bottom_right_x = window_top_left_x + input_window_sizes[0];
int window_top_left_y = (original_config.dimension_sizes[1] - input_window_sizes[1]) / 2;
int window_bottom_right_y = window_top_left_y + input_window_sizes[1];
unsigned int original_neuron_count_per_feature_map = original_config.get_neuron_count_per_feature_map();
unsigned int transformed_neuron_count_per_feature_map = get_transformed_configuration(original_config).get_neuron_count_per_feature_map();
for(unsigned int feature_map_id = 0; feature_map_id < original_config.feature_map_count; ++feature_map_id)
{
cv::Mat1f original_image(static_cast<int>(original_config.dimension_sizes[1]), static_cast<int>(original_config.dimension_sizes[0]), const_cast<float *>(data) + (original_neuron_count_per_feature_map * feature_map_id));
cv::Mat1f cropped_image = original_image.rowRange(window_top_left_y, window_bottom_right_y).colRange(window_top_left_x, window_bottom_right_x);
cv::Mat1f dest_image(static_cast<int>(output_window_sizes[1]), static_cast<int>(output_window_sizes[0]), data_transformed + (transformed_neuron_count_per_feature_map * feature_map_id));
cv::resize(cropped_image, dest_image, dest_image.size());
}
}
}
void rotate_band_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)
{
const std::vector<unsigned int>& dimension_sizes = original_config.dimension_sizes;
if (dimension_sizes.size() != rotate_band_distributions.size())
throw neural_network_exception((boost::format("rotate_band_data_transformer is created with %1%-dimensional rotations, data has %2% dimensions") % rotate_band_distributions.size() % dimension_sizes.size()).str());
size_t elem_size = neuron_data_type::get_input_size(type);
const unsigned char * src_begin = (const unsigned char *)data;
unsigned char * dst = (unsigned char *)data_transformed;
std::vector<unsigned int> src_pos_list;
std::vector<unsigned int>::const_iterator it2 = dimension_sizes.begin();
for(std::vector<nnforge_uniform_int_distribution<int> >::iterator it = rotate_band_distributions.begin(); it != rotate_band_distributions.end(); ++it, ++it2)
{
nnforge_uniform_int_distribution<int>& rotate_band_distribution = *it;
int rotate_band = rotate_band_distribution.min();
if (rotate_band_distribution.max() > rotate_band_distribution.min())
rotate_band = rotate_band_distribution(generator);
if (rotate_band < 0)
rotate_band += *it2;
src_pos_list.push_back(rotate_band);
}
std::vector<unsigned int> dst_pos_list(dimension_sizes.size(), 0);
unsigned int x_xopy_count1 = dimension_sizes[0] - src_pos_list[0];
for(unsigned int feature_map_id = 0; feature_map_id < original_config.feature_map_count; ++feature_map_id)
{
while (true)
{
unsigned int offset = 0;
for(int i = dimension_sizes.size() - 1; i > 0; --i)
offset = (offset + src_pos_list[i]) * dimension_sizes[i - 1];
const unsigned char * src = src_begin + offset * elem_size;
memcpy(dst, src + src_pos_list[0] * elem_size, x_xopy_count1 * elem_size);
if (src_pos_list[0] > 0)
memcpy(dst + x_xopy_count1 * elem_size, src, src_pos_list[0] * elem_size);
dst += dimension_sizes[0] * elem_size;
bool inc = false;
for(int i = 1; i < dimension_sizes.size(); ++i)
{
dst_pos_list[i]++;
src_pos_list[i]++;
if (src_pos_list[i] == dimension_sizes[i])
src_pos_list[i] = 0;
if (dst_pos_list[i] < dimension_sizes[i])
{
inc = true;
break;
}
else
dst_pos_list[i] = 0;
}
if (!inc)
break;
}
src_begin += original_config.get_neuron_count_per_feature_map() * elem_size;
}
}
