< Summary - ReFlex - Library

Information
Class: PointCloud.Benchmark.Filter.OptimizedBoxFilter
Assembly: ReFlex.PointCloud.Benchmark
File(s): D:\a\reflex\reflex\test\Library\Performance\PointCloud.Benchmark\Filter\OptimizedBoxFilter.cs
Line coverage
0%
Covered lines: 0
Uncovered lines: 492
Coverable lines: 492
Total lines: 657
Line coverage: 0%
Branch coverage
0%
Covered branches: 0
Total branches: 150
Branch coverage: 0%
Method coverage

Feature is only available for sponsors

Upgrade to PRO version

Metrics

MethodBranch coverage Crap Score Cyclomatic complexity Line coverage
.ctor(...)0%620%
get_Radius()100%210%
set_Radius(...)0%620%
get_NumPasses()100%210%
set_NumPasses(...)0%620%
get_DefaultValue()100%210%
FilterWithCopyParallel(...)0%2040%
FilterWithCopyParallelMemory(...)0%2040%
FilterWithCopy(...)0%2040%
FilterWithCopySpan(...)0%2040%
Filter(...)0%620%
UpdateRadius()100%210%
BoxesForGauss(...)0%4260%
BoxBlurArray(...)0%4260%
BoxBlurArraySpan(...)0%4260%
BoxBlurArrayParallelMem(...)0%2040%
BoxBlurArrayParallel(...)0%4260%
BoxBlurPointSpan(...)0%4260%
boxBlurH_Parallel(...)0%7280%
boxBlurH_ParallelMem(...)0%7280%
boxBlurH(...)0%110100%
boxBlurHSpan(...)0%110100%
boxBlurH_Point3(...)0%110100%
boxBlurT_Parallel(...)0%7280%
boxBlurT_ParallelMem(...)0%7280%
boxBlurT(...)0%110100%
boxBlurTSpan(...)0%110100%
boxBlurT_Point3(...)0%110100%

File(s)

D:\a\reflex\reflex\test\Library\Performance\PointCloud.Benchmark\Filter\OptimizedBoxFilter.cs

#LineLine coverage
 1using ReFlex.Core.Common.Components;
 2using Math = System.Math;
 3
 4namespace PointCloud.Benchmark.Filter;
 5
 6public class OptimizedBoxFilter
 7{
 8  #region fields
 9
 10  private int _radius;
 011  private int _numPasses = 3;
 12
 013  private readonly ParallelOptions _pOptions = new() { MaxDegreeOfParallelism = -1 };
 14
 15  private int[]? _boxes;
 16
 17  #endregion
 18
 19  #region properties
 20
 21  /// <summary>
 22  /// Gets or sets the radius.
 23  /// </summary>
 24  /// <value>
 25  /// The radius.
 26  /// </value>
 27  public int Radius
 28  {
 029    get => _radius;
 30    set
 031    {
 032      if (_radius == value)
 033        return;
 034      _radius = value;
 035      UpdateRadius();
 036    }
 37  }
 38
 39  public int NumPasses
 40  {
 041    get => _numPasses;
 42    set
 043    {
 044      if (_numPasses == value)
 045        return;
 046      _numPasses = value;
 047      UpdateRadius();
 048    }
 49  }
 50
 051  public float DefaultValue { get; set; }
 52
 53  #endregion
 54
 55  #region constructor
 56
 57  /// <summary>
 58  /// Initializes a new instance of the <see cref="BoxFilter"/> class.
 59  /// </summary>
 60  /// <param name="radius">The radius.</param>
 61  /// <param name="maxParallelism">max number of parallel threads to use.
 62  /// -1 (default value) for automatic Task generation, best results for matching number with current number of availabl
 063  public OptimizedBoxFilter(int radius, int numPasses = 3, int maxParallelism = -1)
 064  {
 065    if (numPasses > 0)
 066      _numPasses = numPasses;
 67
 068    Radius = radius;
 069    _pOptions.MaxDegreeOfParallelism = maxParallelism;
 070  }
 71
 72  #endregion
 73
 74  #region methods
 75
 76  /// <summary>
 77  /// Filters highly frequented changes in a field of <see cref="Point3"/>.
 78  /// </summary>
 79  public void FilterWithCopyParallel(Common.PointCloud3 target)
 080  {
 081    var values = target.AsSpan();
 82
 083    var source = new float[target.Size].AsSpan();
 084    var dest = new float[target.Size];
 85
 086    for (var i = 0; i < values.Length; i++)
 087    {
 088      source[i] = values[i].Z;
 089    }
 90
 091    BoxBlurArrayParallel(source.ToArray(), dest, target.SizeX, target.SizeY);
 92
 093    for (var i = 0; i < source.Length; i++)
 094    {
 095      target[i].Z = source[i];
 096    }
 097  }
 98
 99  /// <summary>
 100  /// Filters highly frequented changes in a field of <see cref="Point3"/>.
 101  /// </summary>
 102  public void FilterWithCopyParallelMemory(Common.PointCloud3 target)
 0103  {
 0104    var values = target.AsSpan();
 105
 0106    var source = new float[target.Size];
 0107    var dest = new float[target.Size];
 108
 0109    for (var i = 0; i < values.Length; i++)
 0110    {
 0111      source[i] = values[i].Z;
 0112    }
 113
 0114    BoxBlurArrayParallelMem(source.AsMemory(), dest, target.SizeX, target.SizeY);
 115
 0116    for (var i = 0; i < source.Length; i++)
 0117    {
 0118      target[i].Z = source[i];
 0119    }
 0120  }
 121
 122  /// <summary>
 123  /// Filters highly frequented changes in a field of <see cref="Point3"/>.
 124  /// </summary>
 125  public void FilterWithCopy(Common.PointCloud3 target)
 0126  {
 0127    var values = target.AsSpan();
 128
 0129    var source = new float[target.Size].AsSpan();
 0130    var dest = new float[target.Size];
 131
 0132    for (var i = 0; i < values.Length; i++)
 0133    {
 0134      source[i] = values[i].Z;
 0135    }
 136
 0137    BoxBlurArray(source.ToArray(), dest, target.SizeX, target.SizeY);
 138
 0139    for (var i = 0; i < source.Length; i++)
 0140    {
 0141      target[i].Z = source[i];
 0142    }
 0143  }
 144
 145  /// <summary>
 146  /// Filters highly frequented changes in a field of <see cref="Point3"/>.
 147  /// </summary>
 148  public void FilterWithCopySpan(Common.PointCloud3 target)
 0149  {
 0150    var values = target.AsSpan();
 151
 0152    var source = new float[target.Size].AsSpan();
 0153    var dest = new float[target.Size].AsSpan();
 154
 0155    for (var i = 0; i < values.Length; i++)
 0156    {
 0157      source[i] = values[i].Z;
 0158    }
 159
 0160    BoxBlurArraySpan(source, dest, target.SizeX, target.SizeY);
 161
 0162    for (var i = 0; i < source.Length; i++)
 0163    {
 0164      target[i].Z = source[i];
 0165    }
 0166  }
 167
 168  /// <summary>
 169  /// Filters highly frequented changes in a field of <see cref="Point3"/>.
 170  /// </summary>
 171  public void Filter(Common.PointCloud3 target)
 0172  {
 0173    var source = target.AsSpan();
 174
 0175    var dest = new Point3[target.Size].AsSpan();
 176
 0177    BoxBlurPointSpan(source, dest, target.SizeX, target.SizeY);
 178
 0179    for (var i = 0; i < source.Length; i++)
 0180    {
 0181      target[i] = source[i];
 0182    }
 0183  }
 184
 185  /// <summary>
 186  /// Sets the radius and calculates the diameter.
 187  /// </summary>
 188  private void UpdateRadius()
 0189  {
 0190    _boxes = BoxesForGauss(_radius, _numPasses);
 0191  }
 192
 193  #endregion
 194
 195  #region private methods
 196
 197  private int[] BoxesForGauss(int sigma, int n)
 0198  {
 0199    var wIdeal = Math.Sqrt((12 * sigma * sigma / n) + 1);
 0200    var wl = (int)Math.Floor(wIdeal);
 0201    if (wl % 2 == 0)
 0202      wl--;
 0203    var wu = wl + 2;
 204
 0205    var mIdeal = (double)(12 * sigma * sigma - n * wl * wl - 4 * n * wl - 3 * n) / (-4 * wl - 4);
 0206    var m = Math.Round(mIdeal);
 207
 0208    var sizes = new List<int>();
 0209    for (var i = 0; i < n; i++)
 0210      sizes.Add(i < m ? wl : wu);
 0211    return sizes.ToArray();
 0212  }
 213
 214  private void BoxBlurArray(float[] source, float[] dest, int w, int h)
 0215  {
 0216    for (var i = 0; i < source.Length; i++)
 0217      dest[i] = source[i];
 218
 0219    if (_boxes == null)
 0220      return;
 221
 0222    for (var n = 0; n < _numPasses; n++)
 0223    {
 0224      boxBlurH(dest, source, w, h, (_boxes[n] - 1) / 2);
 0225      boxBlurT(source, dest, w, h, (_boxes[n] - 1) / 2);
 0226    }
 0227  }
 228
 229  private void BoxBlurArraySpan(Span<float> source, Span<float> dest, int w, int h)
 0230  {
 231
 0232    for (var i = 0; i < source.Length; i++)
 0233      dest[i] = source[i];
 234
 0235    if (_boxes == null)
 0236      return;
 237
 0238    for (var n = 0; n < _numPasses; n++)
 0239    {
 0240      boxBlurHSpan(dest, source, w, h, (_boxes[n] - 1) / 2);
 0241      boxBlurTSpan(source, dest, w, h, (_boxes[n] - 1) / 2);
 0242    }
 0243  }
 244
 245  private void BoxBlurArrayParallelMem(Memory<float> source, Memory<float> dest, int w, int h)
 0246  {
 0247    source.CopyTo(dest);
 248
 0249    if (_boxes == null)
 0250      return;
 251
 0252    for (var n = 0; n < _numPasses; n++)
 0253    {
 0254      boxBlurH_ParallelMem(dest, source, w, h, (_boxes[n] - 1) / 2);
 0255      boxBlurT_ParallelMem(source, dest, w, h, (_boxes[n] - 1) / 2);
 0256    }
 0257  }
 258
 259  private void BoxBlurArrayParallel(float[] source, float[] dest, int w, int h)
 0260  {
 261
 262
 0263    for (var i = 0; i < source.Length; i++)
 0264      dest[i] = source[i];
 265
 0266    if (_boxes == null)
 0267      return;
 268
 0269    for (var n = 0; n < _numPasses; n++)
 0270    {
 0271      boxBlurH_Parallel(dest, source, w, h, (_boxes[n] - 1) / 2);
 0272      boxBlurT_Parallel(source, dest, w, h, (_boxes[n] - 1) / 2);
 0273    }
 0274  }
 275
 276  private void BoxBlurPointSpan(Span<Point3> source, Span<Point3> dest, int w, int h)
 0277  {
 0278    for (var i = 0; i < source.Length; i++)
 0279      dest[i] = source[i];
 280
 0281    if (_boxes == null)
 0282      return;
 283
 0284    for (var n = 0; n < _numPasses; n++)
 0285    {
 0286      boxBlurH_Point3(dest, source, w, h, (_boxes[n] - 1) / 2);
 0287      boxBlurT_Point3(source, dest, w, h, (_boxes[n] - 1) / 2);
 0288    }
 0289  }
 290
 291  private void boxBlurH_Parallel(float[] source, float[] dest, int w, int h, int r)
 0292  {
 0293    var iar = (float)1 / (r + r + 1);
 0294    Parallel.For(0, h, _pOptions, i =>
 0295    {
 0296      var ti = i * w;
 0297      var li = ti;
 0298      var ri = ti + r;
 0299      var fv = source[ti];
 0300      var lv = source[ti + w - 1];
 0301      var val = (r + 1) * fv;
 0302      for (var j = 0; j < r; j++)
 0303        val += source[ti + j];
 0304      for (var j = 0; j <= r; j++)
 0305      {
 0306        val += source[ri++] - fv;
 0307        dest[ti++] = (float)Math.Round(val * iar);
 0308      }
 0309
 0310      for (var j = r + 1; j < w - r; j++)
 0311      {
 0312        val += source[ri++] - dest[li++];
 0313        dest[ti++] = (float)Math.Round(val * iar);
 0314      }
 0315
 0316      for (var j = w - r; j < w; j++)
 0317      {
 0318        val += lv - source[li++];
 0319        dest[ti++] = (float)Math.Round(val * iar);
 0320      }
 0321    });
 0322  }
 323
 324  private void boxBlurH_ParallelMem(Memory<float> source, Memory<float> dest, int w, int h, int r)
 0325  {
 0326    var iar = (float)1 / (r + r + 1);
 0327    Parallel.For(0, h, _pOptions, i =>
 0328    {
 0329      var ti = i * w;
 0330      var li = ti;
 0331      var ri = ti + r;
 0332      var fv = source.Span[ti];
 0333      var lv = source.Span[ti + w - 1];
 0334      var val = (r + 1) * fv;
 0335      for (var j = 0; j < r; j++)
 0336        val += source.Span[ti + j];
 0337      for (var j = 0; j <= r; j++)
 0338      {
 0339        val += source.Span[ri++] - fv;
 0340        dest.Span[ti++] = (float)Math.Round(val * iar);
 0341      }
 0342
 0343      for (var j = r + 1; j < w - r; j++)
 0344      {
 0345        val += source.Span[ri++] - dest.Span[li++];
 0346        dest.Span[ti++] = (float)Math.Round(val * iar);
 0347      }
 0348
 0349      for (var j = w - r; j < w; j++)
 0350      {
 0351        val += lv - source.Span[li++];
 0352        dest.Span[ti++] = (float)Math.Round(val * iar);
 0353      }
 0354    });
 0355  }
 356
 357  private void boxBlurH(float[] source, float[] dest, int w, int h, int r)
 0358  {
 0359    var iar = (float)1 / (r + r + 1);
 0360    for (var i = 0; i < h; i++)
 0361    {
 0362      var ti = i * w;
 0363      var li = ti;
 0364      var ri = ti + r;
 0365      var fv = source[ti];
 0366      var lv = source[ti + w - 1];
 0367      var val = (r + 1) * fv;
 0368      for (var j = 0; j < r; j++)
 0369        val += source[ti + j];
 0370      for (var j = 0; j <= r; j++)
 0371      {
 0372        val += source[ri++] - fv;
 0373        dest[ti++] = (float)Math.Round(val * iar);
 0374      }
 375
 0376      for (var j = r + 1; j < w - r; j++)
 0377      {
 0378        val += source[ri++] - dest[li++];
 0379        dest[ti++] = (float)Math.Round(val * iar);
 0380      }
 381
 0382      for (var j = w - r; j < w; j++)
 0383      {
 0384        val += lv - source[li++];
 0385        dest[ti++] = (float)Math.Round(val * iar);
 0386      }
 0387    }
 0388  }
 389
 390  private void boxBlurHSpan(Span<float> source, Span<float> dest, int w, int h, int r)
 0391  {
 0392    var iar = (float)1 / (r + r + 1);
 0393    for (var i = 0; i < h; i++)
 0394    {
 0395      var ti = i * w;
 0396      var li = ti;
 0397      var ri = ti + r;
 0398      var fv = source[ti];
 0399      var lv = source[ti + w - 1];
 0400      var val = (r + 1) * fv;
 0401      for (var j = 0; j < r; j++)
 0402        val += source[ti + j];
 0403      for (var j = 0; j <= r; j++)
 0404      {
 0405        val += source[ri++] - fv;
 0406        dest[ti++] = (float)Math.Round(val * iar);
 0407      }
 408
 0409      for (var j = r + 1; j < w - r; j++)
 0410      {
 0411        val += source[ri++] - dest[li++];
 0412        dest[ti++] = (float)Math.Round(val * iar);
 0413      }
 414
 0415      for (var j = w - r; j < w; j++)
 0416      {
 0417        val += lv - source[li++];
 0418        dest[ti++] = (float)Math.Round(val * iar);
 0419      }
 0420    }
 0421  }
 422
 423  private void boxBlurH_Point3(Span<Point3> source, Span<Point3> dest, int w, int h, int r)
 0424  {
 0425    var iar = (float)1 / (r + r + 1);
 0426    for (var i = 0; i < h; i++)
 0427    {
 0428      var ti = i * w;
 0429      var li = ti;
 0430      var ri = ti + r;
 0431      var fv = source[ti].Z;
 0432      var lv = source[ti + w - 1].Z;
 0433      var val = (r + 1) * fv;
 0434      for (var j = 0; j < r; j++)
 0435        val += source[ti + j].Z;
 0436      for (var j = 0; j <= r; j++)
 0437      {
 0438        val += source[ri++].Z - fv;
 0439        dest[ti++].Z = (float)Math.Round(val * iar);
 0440      }
 441
 0442      for (var j = r + 1; j < w - r; j++)
 0443      {
 0444        val += source[ri++].Z - dest[li++].Z;
 0445        dest[ti++].Z = (float)Math.Round(val * iar);
 0446      }
 447
 0448      for (var j = w - r; j < w; j++)
 0449      {
 0450        val += lv - source[li++].Z;
 0451        dest[ti++].Z = (float)Math.Round(val * iar);
 0452      }
 0453    }
 0454  }
 455
 456  private void boxBlurT_Parallel(float[] source, float[] dest, int w, int h, int r)
 0457  {
 0458    var iar = (float)1 / (r + r + 1);
 0459    Parallel.For(0, w, _pOptions, i =>
 0460    {
 0461      var ti = i;
 0462      var li = ti;
 0463      var ri = ti + r * w;
 0464      var fv = source[ti];
 0465      var lv = source[ti + w * (h - 1)];
 0466      var val = (r + 1) * fv;
 0467      for (var j = 0; j < r; j++)
 0468        val += source[ti + j * w];
 0469      for (var j = 0; j <= r; j++)
 0470      {
 0471        val += source[ri] - fv;
 0472        dest[ti] = (float)Math.Round(val * iar);
 0473        ri += w;
 0474        ti += w;
 0475      }
 0476
 0477      for (var j = r + 1; j < h - r; j++)
 0478      {
 0479        val += source[ri] - source[li];
 0480        dest[ti] = (float)Math.Round(val * iar);
 0481        li += w;
 0482        ri += w;
 0483        ti += w;
 0484      }
 0485
 0486      for (var j = h - r; j < h; j++)
 0487      {
 0488        val += lv - source[li];
 0489        dest[ti] = (float)Math.Round(val * iar);
 0490        li += w;
 0491        ti += w;
 0492      }
 0493    });
 0494  }
 495
 496  private void boxBlurT_ParallelMem(Memory<float> source, Memory<float> dest, int w, int h, int r)
 0497  {
 0498    var iar = (float)1 / (r + r + 1);
 0499    Parallel.For(0, w, _pOptions, i =>
 0500    {
 0501      var ti = i;
 0502      var li = ti;
 0503      var ri = ti + r * w;
 0504      var fv = source.Span[ti];
 0505      var lv = source.Span[ti + w * (h - 1)];
 0506      var val = (r + 1) * fv;
 0507      for (var j = 0; j < r; j++)
 0508        val += source.Span[ti + j * w];
 0509      for (var j = 0; j <= r; j++)
 0510      {
 0511        val += source.Span[ri] - fv;
 0512        dest.Span[ti] = (float)Math.Round(val * iar);
 0513        ri += w;
 0514        ti += w;
 0515      }
 0516
 0517      for (var j = r + 1; j < h - r; j++)
 0518      {
 0519        val += source.Span[ri] - source.Span[li];
 0520        dest.Span[ti] = (float)Math.Round(val * iar);
 0521        li += w;
 0522        ri += w;
 0523        ti += w;
 0524      }
 0525
 0526      for (var j = h - r; j < h; j++)
 0527      {
 0528        val += lv - source.Span[li];
 0529        dest.Span[ti] = (float)Math.Round(val * iar);
 0530        li += w;
 0531        ti += w;
 0532      }
 0533    });
 0534  }
 535
 536  private void boxBlurT(float[] source, float[] dest, int w, int h, int r)
 0537  {
 0538    var iar = (float)1 / (r + r + 1);
 0539    for (var i = 0; i < w; i++)
 0540    {
 0541      var ti = i;
 0542      var li = ti;
 0543      var ri = ti + r * w;
 0544      var fv = source[ti];
 0545      var lv = source[ti + w * (h - 1)];
 0546      var val = (r + 1) * fv;
 0547      for (var j = 0; j < r; j++)
 0548        val += source[ti + j * w];
 0549      for (var j = 0; j <= r; j++)
 0550      {
 0551        val += source[ri] - fv;
 0552        dest[ti] = (float)Math.Round(val * iar);
 0553        ri += w;
 0554        ti += w;
 0555      }
 556
 0557      for (var j = r + 1; j < h - r; j++)
 0558      {
 0559        val += source[ri] - source[li];
 0560        dest[ti] = (float)Math.Round(val * iar);
 0561        li += w;
 0562        ri += w;
 0563        ti += w;
 0564      }
 565
 0566      for (var j = h - r; j < h; j++)
 0567      {
 0568        val += lv - source[li];
 0569        dest[ti] = (float)Math.Round(val * iar);
 0570        li += w;
 0571        ti += w;
 0572      }
 0573    }
 0574  }
 575
 576  private void boxBlurTSpan(Span<float> source, Span<float> dest, int w, int h, int r)
 0577  {
 0578    var iar = (float)1 / (r + r + 1);
 0579    for (var i = 0; i < w; i++)
 0580    {
 0581      var ti = i;
 0582      var li = ti;
 0583      var ri = ti + r * w;
 0584      var fv = source[ti];
 0585      var lv = source[ti + w * (h - 1)];
 0586      var val = (r + 1) * fv;
 0587      for (var j = 0; j < r; j++)
 0588        val += source[ti + j * w];
 0589      for (var j = 0; j <= r; j++)
 0590      {
 0591        val += source[ri] - fv;
 0592        dest[ti] = (float)Math.Round(val * iar);
 0593        ri += w;
 0594        ti += w;
 0595      }
 596
 0597      for (var j = r + 1; j < h - r; j++)
 0598      {
 0599        val += source[ri] - source[li];
 0600        dest[ti] = (float)Math.Round(val * iar);
 0601        li += w;
 0602        ri += w;
 0603        ti += w;
 0604      }
 605
 0606      for (var j = h - r; j < h; j++)
 0607      {
 0608        val += lv - source[li];
 0609        dest[ti] = (float)Math.Round(val * iar);
 0610        li += w;
 0611        ti += w;
 0612      }
 0613    }
 0614  }
 615
 616  private void boxBlurT_Point3(Span<Point3> source, Span<Point3> dest, int w, int h, int r)
 0617  {
 0618    var iar = (float)1 / (r + r + 1);
 0619    for (var i = 0; i < w; i++)
 0620    {
 0621      var ti = i;
 0622      var li = ti;
 0623      var ri = ti + r * w;
 0624      var fv = source[ti].Z;
 0625      var lv = source[ti + w * (h - 1)].Z;
 0626      var val = (r + 1) * fv;
 0627      for (var j = 0; j < r; j++)
 0628        val += source[ti + j * w].Z;
 0629      for (var j = 0; j <= r; j++)
 0630      {
 0631        val += source[ri].Z - fv;
 0632        dest[ti].Z = (float)Math.Round(val * iar);
 0633        ri += w;
 0634        ti += w;
 0635      }
 636
 0637      for (var j = r + 1; j < h - r; j++)
 0638      {
 0639        val += source[ri].Z - source[li].Z;
 0640        dest[ti].Z = (float)Math.Round(val * iar);
 0641        li += w;
 0642        ri += w;
 0643        ti += w;
 0644      }
 645
 0646      for (var j = h - r; j < h; j++)
 0647      {
 0648        val += lv - source[li].Z;
 0649        dest[ti].Z = (float)Math.Round(val * iar);
 0650        li += w;
 0651        ti += w;
 0652      }
 0653    }
 0654  }
 655
 656  #endregion
 657}
Generated by: ReportGenerator 5.4.5.0
4/15/2025 - 11:07:03 AM
GitHub | reportgenerator.io

Methods/Properties

.ctor(System.Int32,System.Int32,System.Int32)
get_Radius()
set_Radius(System.Int32)
get_NumPasses()
set_NumPasses(System.Int32)
get_DefaultValue()
FilterWithCopyParallel(PointCloud.Benchmark.Common.PointCloud3)
FilterWithCopyParallelMemory(PointCloud.Benchmark.Common.PointCloud3)
FilterWithCopy(PointCloud.Benchmark.Common.PointCloud3)
FilterWithCopySpan(PointCloud.Benchmark.Common.PointCloud3)
Filter(PointCloud.Benchmark.Common.PointCloud3)
UpdateRadius()
BoxesForGauss(System.Int32,System.Int32)
BoxBlurArray(System.Single[],System.Single[],System.Int32,System.Int32)
BoxBlurArraySpan(System.Span`1<System.Single>,System.Span`1<System.Single>,System.Int32,System.Int32)
BoxBlurArrayParallelMem(System.Memory`1<System.Single>,System.Memory`1<System.Single>,System.Int32,System.Int32)
BoxBlurArrayParallel(System.Single[],System.Single[],System.Int32,System.Int32)
BoxBlurPointSpan(System.Span`1<ReFlex.Core.Common.Components.Point3>,System.Span`1<ReFlex.Core.Common.Components.Point3>,System.Int32,System.Int32)
boxBlurH_Parallel(System.Single[],System.Single[],System.Int32,System.Int32,System.Int32)
boxBlurH_ParallelMem(System.Memory`1<System.Single>,System.Memory`1<System.Single>,System.Int32,System.Int32,System.Int32)
boxBlurH(System.Single[],System.Single[],System.Int32,System.Int32,System.Int32)
boxBlurHSpan(System.Span`1<System.Single>,System.Span`1<System.Single>,System.Int32,System.Int32,System.Int32)
boxBlurH_Point3(System.Span`1<ReFlex.Core.Common.Components.Point3>,System.Span`1<ReFlex.Core.Common.Components.Point3>,System.Int32,System.Int32,System.Int32)
boxBlurT_Parallel(System.Single[],System.Single[],System.Int32,System.Int32,System.Int32)
boxBlurT_ParallelMem(System.Memory`1<System.Single>,System.Memory`1<System.Single>,System.Int32,System.Int32,System.Int32)
boxBlurT(System.Single[],System.Single[],System.Int32,System.Int32,System.Int32)
boxBlurTSpan(System.Span`1<System.Single>,System.Span`1<System.Single>,System.Int32,System.Int32,System.Int32)
boxBlurT_Point3(System.Span`1<ReFlex.Core.Common.Components.Point3>,System.Span`1<ReFlex.Core.Common.Components.Point3>,System.Int32,System.Int32,System.Int32)