Public imports

  • mir.algorithm.iteration
  • mir.ndslice.allocation
  • mir.ndslice.concatenation
  • mir.ndslice.chunks
  • mir.ndslice.dynamic
  • mir.ndslice.field
  • mir.ndslice.fuse
  • mir.ndslice.iterator
  • mir.ndslice.ndfield
  • mir.ndslice.slice
  • mir.ndslice.topology
  • mir.ndslice.traits

The package provides a multidimensional array implementation. It would be well suited to creating machine learning and image processing algorithms, but should also be general enough for use anywhere with homogeneously-typed multidimensional data. In addition, it includes various functions for iteration, accessing, and manipulation.


is a function designed to create a multidimensional view over a range. Multidimensional view is presented by type.


import mir.ndslice;

auto matrix = slice!double(3, 4); matrix[] = 0; matrix.diagonal[] = 1;

auto row = matrix[2]; row[3] = 6; assert(matrix[2, 3] == 6); // D & C index order

    filter = unary function. Dimension window 2D is the argument.
    image = image dimensions (h, w, c),
        where с is the number of channels in the image
    nr = number of rows in the window
    nс = number of columns in the window

Returns: image dimensions (h - nr + 1, w - nc + 1, c), where с is the number of channels in the image. Dense data layout is guaranteed. +/ Slice!(ubyte, 3) movingWindowByChannel (Slice!(Universal, [3], <font color=blue>ubyte</font>) image, size_t nr, size_t nc, ubyte delegate(Slice!(Universal, [2], ubyte*)) filter) { // 0. 3D // The last dimension represents the color channel. return image // 1. 2D composed of 1D // Packs the last dimension. .pack!1 // 2. 2D composed of 2D composed of 1D // Splits image into overlapping windows. .windows(nr, nc) // 3. 5D // Unpacks the windows. .unpack .transposed!(0, 1, 4) // 4. 5D // Brings the color channel dimension to the third position. .pack!2 // 2D to pixel lazy conversion. .map!filter // Creates the new image. The only memory allocation in this function. .slice; }

A function that calculates the value of iterator median is also necessary.


Params: r = input range buf = buffer with length no less than the number of elements in r Returns: median value over the range r +/ T median(Range, T)(Slice!(Universal, [2], Range) sl, T[] buf) { import std.algorithm.sorting : topN; // copy sl to the buffer auto retPtr = reduce!( (ptr, elem) { *ptr = elem; return ptr + 1;} )(buf.ptr, sl); auto n = retPtr - buf.ptr; buf[0 .. n].topN(n / 2); return buf[n / 2]; }



void main(string[] args)
    import std.conv : to;
    import std.getopt : getopt, defaultGetoptPrinter;
    import std.path : stripExtension;

<font color=blue>uint</font> nr, nc, def = 3;
<font color=blue>auto</font> helpInformation = args.getopt(
    <font color=red>"nr"</font>, <font color=red>"number of rows in window, default value is "</font> ~!string, &nr,
    <font color=red>"nc"</font>, <font color=red>"number of columns in window, default value is equal to nr"</font>, &nc);
<font color=blue>if</font> (helpInformation.helpWanted)
        <font color=red>"Usage: median-filter [<options...>] [<file_names...>]\noptions:"</font>,
    <font color=blue>return</font>;
<font color=blue>if</font> (!nr) nr = def;
<font color=blue>if</font> (!nc) nc = nr;
<font color=blue>auto</font> buf = <font color=blue>new</font> <font color=blue>ubyte</font>[nr * nc];
<font color=blue>foreach</font> (name; args[1 .. $])
    <font color=blue>import</font> imageformats; <font color=green>// can be found at</font>
IFImage image = read_image(name);
<font color=blue>auto</font> ret = image.pixels
    .sliced(<font color=blue>cast</font>(size_t)image.h, <font color=blue>cast</font>(size_t)image.w, <font color=blue>cast</font>(size_t)image.c)
        !(window => median(window, buf))
         (nr, nc);
    name.stripExtension ~ <font color=red>"_filtered.png"</font>,
    (&ret[0, 0, 0])[0 .. ret.elementCount]);

} }

This program works both with color and grayscale images.

$ median-filter --help
Usage: median-filter [] []
     --nr number of rows in window, default value is 3
     --nc number of columns in window default value equals to nr
-h --help This help information.

numpy is undoubtedly one of the most effective software packages that has facilitated the work of many engineers and scientists. However, due to the specifics of implementation of Python, a programmer who wishes to use the functions not represented in numpy may find that the built-in functions implemented specifically for numpy are not enough, and their Python implementations work at a very low speed. Extending numpy can be done, but is somewhat laborious as even the most basic numpy functions that refer directly to

data must be implemented in C for reasonable performance.

At the same time, while working with

, an engineer has access to the whole set of standard D library, so the functions he creates will be as efficient as if they were written in C.


In many examples is used instead of a regular array, which makes it possible to carry out tests without memory allocation.

A median filter is implemented as an example. The function

can also be used with other filters that use a sliding window as the argument, in particular with convolution matrices such as the Sobel operator.

iterates over an image in sliding window mode. Each window is transferred to a
, which calculates the value of the pixel that corresponds to the given window.

This function does not calculate border cases in which a window overlaps the image partially. However, the function can still be used to carry out such calculations. That can be done by creating an amplified image, with the edges reflected from the original image, and then applying the given function to the new file.

You can find the example at GitHub.




Copyright © 2016, Ilya Yaroshenko


Ilya Yaroshenko


John Loughran Colvin