Question

我发现了Halide并且在管道上做了各种各样的事情取得了一些成功转换。其中大部分都基于源中的示例（颜色转换，各种过滤器，hist-eq）。

我的下一步需要以块为单位处理图像。在更一般的形式中， 部分重叠的块。

实施例

输入：

      [  1,  2,  3,  4,  5,  6,  7,  8,
         9, 10, 11, 12, 13, 14, 15, 16,
        17, 18, 19, 20, 21, 22, 23, 24,
        25, 26, 27, 28, 29, 30, 31, 32]

非重叠块：

尺寸：2x4

      [ 1,  2,  3,  4,
        9, 10, 11, 12]

      [  5,  6,  7,  8,
        13, 14, 15, 16]

      [ 17, 18, 19, 20,
        25, 26, 27, 28]

      [ 21, 22, 23, 24,
        29, 30, 31, 32]

重叠块：

尺寸：2x4，重叠50％（两个轴）

      [ 1,  2,  3,  4,
        9, 10, 11, 12]

      [ 3,  4, 5, 6,
        11, 12, 13, 14]

      [ 5,  6, 7, 8,
       13, 14, 15, 16]

       -

      [ 9, 10, 11, 12,
       17, 18, 19, 20]

      [11, 12, 13, 14,
       19, 20, 21, 22]

       ...

我怀疑应该有一种很好的表达方式，因为这些也很常见在许多算法（例如宏块）中。

我检查了什么

我尝试从教程和示例应用程序中收集想法并找到以下内容，这似乎与我想要实现的内容有关：

Halide tutorial lesson 6: Realizing Funcs over arbitrary domains
- // We start by creating an image that represents that rectangle
- Image<int> shifted(5, 7); // In the constructor we tell it the size
- shifted.set_min(100, 50); // Then we tell it the top-left corner
- 我遇到的问题：如何在没有循环的情况下将其推广到多个移位域？
Halide tutorial lesson 9: Multi-pass Funcs, update definitions, and reductions
- 这里介绍了RDom，它看起来很不错，可以创建一个块视图
- 使用RDom的大多数示例似乎都是像滑动窗口一样没有跳转的方法

目标

所以一般来说我都在询问如何实现基于块的视图，然后可以对其进行处理其他步骤。

如果方法足够通用以实现两者，重叠和放大，那将是很好的。没有重叠
- 首先以某种方式生成左上角的索引？
就我而言，图像维度在编译时已知，这简化了这个
- 但是我仍然想要一些从Halide的角度来看很合适的紧凑形式（没有手工编码的东西，比如那些带有小滤盒的例子）
使用的方法可能取决于每个块的输出，在我的情况下是标量

也许有人可以给我一些想法和/或一些例子（这会非常有帮助）。

我很抱歉没有提供代码，因为我认为我无法提供任何有用的信息。

编辑：解决方案

在dsharlet的回答和一些微小的调试/讨论here之后，以下非常简化的自包含代码可以正常工作（假设像this one i created这样的单通道64x128输入。）

#include "Halide.h"
#include "Halide/tools/halide_image_io.h"
#include <iostream>

int main(int argc, char **argv) {
  Halide::Buffer<uint8_t> input = Halide::Tools::load_image("TestImages/block_example.png");

  // This is a simple example assuming an input of 64x128
  std::cout << "dim 0: " << input.width() << std::endl;
  std::cout << "dim 1: " << input.height() << std::endl;

  // The "outer" (block) and "inner" (pixel) indices that describe a pixel in a tile.
  Halide::Var xo, yo, xi, yi, x, y;

  // The distance between the start of each tile in the input.
  int tile_stride_x = 32;
  int tile_stride_y = 64;
  int tile_size_x = 32;
  int tile_size_y = 64;

  Halide::Func tiled_f;
  tiled_f(xi, yi, xo, yo) = input(xo * tile_stride_x + xi, yo * tile_stride_y + yi);

  Halide::RDom tile_dom(0, tile_size_x, 0, tile_size_y);
  Halide::Func tile_means;
  tile_means(xo, yo) = sum(Halide::cast<uint32_t>(tiled_f(tile_dom.x, tile_dom.y, xo, yo))) / (tile_size_x * tile_size_y);

  Halide::Func output;
  output(xo, yo) = Halide::cast<uint8_t>(tile_means(xo, yo));

  Halide::Buffer<uint8_t> output_(2, 2);
  output.realize(output_);

  Halide::Tools::save_image(output_, "block_based_stuff.png");
}

Answer 1

这是一个将Func分解为abitrary步长和大小的例子：

Func f = ... // The thing being blocked

// The "outer" (block) and "inner" (pixel) indices that describe a pixel in a tile.
Var xo, yo, xi, yi;
// The distance between the start of each tile in the input.
int tile_stride_x, tile_stride_y;

Func tiled_f;
tiled_f(xi, yi, xo, yo) = f(xo * tile_stride_x + xi, yo * tile_stride_y + yi);

Func tiled_output;
tiled_output(xi, yi, xo, yo) = ... // Your tiled processing here

要计算每个块的某些减少量（如统计数据），您可以执行以下操作：

RDom tile_dom(0, tile_size_x, 0, tile_size_y);
Func tile_means;
tile_means(xo, yo) = sum(tiled_output(tile_dom.x, tile_dom.y, xo, yo)) / (tile_size_x * tile_size_y);

将瓷砖压平成结果有点棘手。这可能取决于您在重叠区域中组合结果的方法。如果你想加起重叠的瓷砖，最简单的方法就是使用RDom：

RDom tiles_dom(
    0, tile_size_x,
    0, tile_size_y,
    min_tile_xo, extent_tile_xo,
    min_tile_yo, extent_tile_yo);

Func output;
Expr output_x = tiles_dom[2] * tile_stride_x + tiles_dom[0];
Expr output_y = tiles_dom[3] * tile_stride_y + tiles_dom[1];
output(x, y) = 0;
output(output_x, output_y) += tiled_output(tiles_dom[0], tiles_dom[1], tiles_dom[2], tiles_dom[3]);

请注意，在上面两个代码块中，tile_stride_x和tile_size_x是独立参数，允许任何切片大小和重叠。

在您的两个示例中，tile_size_x = 4和tile_size_y = 2。要获得非重叠切片，请将切片大小设置为等于切片大小。要获得50％重叠的切片，请设置tile_stride_x = 2和tile_stride_y = 1。

这样的算法的有用计划是：

// Compute tiles as needed by the output.
tiled_output.compute_at(output, tile_dom[2]);
// or
tiled_output.compute_at(tile_means, xo);

还有其他选项，比如使用纯func（无更新/ RDom），它使用mod运算符来计算tile内部和外部索引。但是，这种方法很难通过重叠切片有效地安排（取决于您在每个切片上执行的处理）。当出现这个问题时，我会使用RDom方法。

请注意，使用RDom方法，您必须提供要计算的平铺索引的边界（min_tile_xo，extent_tile_xo，...），这对于重叠切片可能很棘手。< / p>

Halide：如何在（重叠）块中处理图像？

实施例

我检查了什么

目标

1 个答案: