void flip_2d_data_sampler_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("flip_2d_data_sampler_transformer is implemented for data stored as bytes only");
if (original_config.dimension_sizes.size() != 2)
throw neural_network_exception((boost::format("flip_2d_data_sampler_transformer is processing 2d data only, data is passed with number of dimensions %1%") % original_config.dimension_sizes.size()).str());
unsigned int neuron_count_per_feature_map = 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::Mat1b src_image(static_cast<int>(original_config.dimension_sizes[1]), static_cast<int>(original_config.dimension_sizes[0]), const_cast<unsigned char *>(static_cast<const unsigned char *>(data)) + (neuron_count_per_feature_map * feature_map_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) + (neuron_count_per_feature_map * feature_map_id));
memcpy(
((unsigned char *)data_transformed) + neuron_count_per_feature_map * feature_map_id,
((unsigned char *)data) + neuron_count_per_feature_map * feature_map_id,
neuron_count_per_feature_map * neuron_data_type::get_input_size(type));
if (sample_id == 1)
{
data_transformer_util::flip(
image,
(flip_around_dimension_id == 0),
(flip_around_dimension_id == 1));
}
}
}
static bool ExportAllVisibleLayersAsImage(const char* filename, sTileset& tileset, std::vector<sLayer> layers)
{
if (!(layers.size() >= 1))
return false;
int tile_width = tileset.GetTileWidth();
int tile_height = tileset.GetTileHeight();
int dest_image_width = 0;
int dest_image_height = 0;
unsigned int i;
// find the size of the image we're going to create
for (i = 0; i < layers.size(); i++) {
if (layers[i].GetWidth() * tile_width > dest_image_width) {
dest_image_width = layers[i].GetWidth() * tile_width;
}
if (layers[i].GetHeight() * tile_height > dest_image_height) {
dest_image_height = layers[i].GetHeight() * tile_height;
}
}
if (dest_image_width <= 0 || dest_image_height <= 0)
return false;
// create destination/output image
CImage32 dest_image(dest_image_width, dest_image_height);
if (layers.size() > 0) { // start from the bottom and work our way to the top ;)
if (!LayerToImage(&dest_image, layers[0], tileset)) {
return false;
}
}
else // nothing to export
return false;
// we already have the first layer, now we do the rest
for (i = 1; i < layers.size(); i++) {
int image_width = layers[i].GetWidth() * tile_width;
int image_height = layers[i].GetHeight() * tile_height;
CImage32 src_image(image_width, image_height);
if ( !LayerToImage(&src_image, layers[i], tileset) ) {
return false;
}
else {
// blend (dest_image, src_image)
BlendImage(dest_image_width, dest_image_height, image_width, image_height, dest_image.GetPixels(), src_image.GetPixels());
}
}
return dest_image.Save(filename);
}
int resize_with_halide()
{
Halide::ImageParam input {Halide::type_of<uint8_t>(), 3};
//_/_/_/ load a source image and repeat its edges
Halide::Func src_image {};
src_image = Halide::BoundaryConditions::repeat_edge(input);
//_/_/_/ describe algorithm
Halide::Param<float> src_rows {};
Halide::Param<float> src_cols {};
Halide::Param<float> dst_rows {};
Halide::Param<float> dst_cols {};
// const float sc = 500.0f/4999;//static_cast<float>(src_cols.get()) / dst_cols.get();
// const float sr = 350.0f/3499;//static_cast<float>(src_rows.get()) / dst_rows.get();
const auto sc = src_cols / dst_cols;
const auto sr = src_rows / dst_rows;
Halide::Var i {};
Halide::Var j {};
Halide::Var c {};
auto fj = j * sr;
auto cj0 = Halide::cast<int>(fj);
auto cj1 = cj0 + 1;
auto dj = fj - cj0;
auto fi = i * sc;
auto ci0 = Halide::cast<int>(fi);
auto ci1 = ci0 + 1;
auto di = fi - ci0;
const auto c0 = (1.0f - dj) * (1.0f - di);
const auto c1 = (1.0f - dj) * di;
const auto c2 = dj * (1.0f - di);
const auto c3 = dj * di;
const auto& src_pixel0 = src_image(ci0, cj0, c);
const auto& src_pixel1 = src_image(ci1, cj0, c);
const auto& src_pixel2 = src_image(ci0, cj1, c);
const auto& src_pixel3 = src_image(ci1, cj1, c);
Halide::Func resize {};
resize(i, j, c) = Halide::saturating_cast<uint8_t>(c0 * src_pixel0 + c1 * src_pixel1 + c2 * src_pixel2 + c3 * src_pixel3);
//_/_/_/ describe scheduling
Halide::Var i_inner, j_inner;
auto x_vector_size = 64;
resize.compute_root();
resize.tile(i, j, i_inner, j_inner, x_vector_size, 4).vectorize(i_inner, 16).parallel(j);
//_/_/_/ save a static library
const auto path = "/Users/kumada/Projects/cct_blog/halide/sample_4/sample_4/resize";
resize.compile_to_static_library(
path,
{input, src_rows, src_cols, dst_rows, dst_cols},
"resize");
return 1;
}
