Function ComputeConvSizes

tensorflow/lite/kernels/internal/test_util.cc:23–65

this is a copied from an internal function in propagate_fixed_sizes.cc

// this is a copied from an internal function in propagate_fixed_sizes.cc
bool ComputeConvSizes(const RuntimeShape& input_shape, int output_depth,
                      int filter_width, int filter_height, int stride,
                      int dilation_width_factor, int dilation_height_factor,
                      PaddingType padding_type, RuntimeShape* output_shape,
                      int* pad_width, int* pad_height) {
  const int input_width = input_shape.Dims(2);
  const int input_height = input_shape.Dims(1);
  const int batch = input_shape.Dims(0);

  int dilated_filter_width = dilation_width_factor * (filter_width - 1) + 1;
  int dilated_filter_height = dilation_height_factor * (filter_height - 1) + 1;

  int output_height = 0;
  int output_width = 0;
  if (padding_type == PaddingType::kValid) {
    // Official TF is
    // ceil((input_height - (dilated_filter_height - 1)) / stride),
    // implemented as
    // floor(
    //   (input_height - (dilated_filter_height - 1) + (stride - 1)) / stride).
    output_height = (input_height + stride - dilated_filter_height) / stride;
    output_width = (input_width + stride - dilated_filter_width) / stride;
  } else if (padding_type == PaddingType::kSame) {
    output_height = (input_height + stride - 1) / stride;
    output_width = (input_width + stride - 1) / stride;
  } else {
    return false;
  }

  if (output_width <= 0 || output_height <= 0) {
    return false;
  }

  *pad_height = std::max(
      0, ((output_height - 1) * stride + dilated_filter_height - input_height) /
             2);
  *pad_width = std::max(
      0,
      ((output_width - 1) * stride + dilated_filter_width - input_width) / 2);

  output_shape->BuildFrom({batch, output_height, output_width, output_depth});
  return true;
}

std::mt19937& RandomEngine() {
  static std::mt19937 engine;