internal static void ConvolutionalLayer2D(Index2 currentInput, ArrayView3D <float> weights, ArrayView2D <float> error, ArrayView2D <float> activatedPreviousLayer, ArrayView2D <float> bias, ArrayView <float> variables)
{
int radius = (int)variables[new Index1(2)];
int diameter = radius * 2 + 1;
var fac = error[currentInput] * variables[new Index1(0)];
float xBounds = error.Extent.X;
float yBounds = error.Extent.Y;
bias[currentInput] -= fac;
var baseIndex = new Index2(currentInput.X - radius, currentInput.Y - radius);
for (int i = 0; i < diameter; i++)
{
for (int j = 0; j < diameter; j++)
{
var asosInput = baseIndex.Add(new Index2(i, j));
if (asosInput.X < xBounds & asosInput.X >= 0 & asosInput.Y >= 0 & asosInput.Y < yBounds)
{
var adjustment = fac * activatedPreviousLayer[asosInput];
var d = activatedPreviousLayer[asosInput];
if (float.IsNaN(adjustment) | float.IsInfinity(adjustment))
{
;
}
weights[new Index3(currentInput, i * diameter + j)] -= adjustment;
}
}
}
}
private static void strategy(Index1 index, ArrayView3D <byte> destBuffer, Index2 offset,
int rWidth, int rHeight, ArrayView <byte> color)
{
if (index <= rWidth)
{
Index2 indw0 = offset + new Index2(index, 0);
Index2 indw1 = indw0 + new Index2(0, rHeight);
for (int i = 0; i < color.Length; i++)
{
destBuffer[new Index3(i, indw0)] = color[i];
destBuffer[new Index3(i, indw1)] = color[i];
}
}
if (index <= rHeight)
{
Index2 indh0 = offset + new Index2(0, index);
Index2 indh1 = indh0 + new Index2(rWidth, 0);
for (int i = 0; i < color.Length; i++)
{
destBuffer[new Index3(i, indh0)] = color[i];
destBuffer[new Index3(i, indh1)] = color[i];
}
}
}
internal static void ConvolutionalLayer2D(Index2 currentInput, ArrayView3D <float> weight, ArrayView2D <float> outputPreviousLayerActivated, ArrayView2D <float> sumInput, ArrayView2D <float> bias, ArrayView <float> variables)
{
int radius = (int)variables[new Index1(1)];
int diameter = radius * 2 + 1;
var baseIndex = new Index2(currentInput.X - radius, currentInput.Y - radius);
var xBounds = outputPreviousLayerActivated.Extent.X;
var yBounds = outputPreviousLayerActivated.Extent.Y;
float sum = bias[currentInput];
for (int i = 0; i < diameter; i++)
{
for (int j = 0; j < diameter; j++)
{
var asosInput = baseIndex.Add(new Index2(i, j));
if (asosInput.X < xBounds & asosInput.X >= 0 & asosInput.Y >= 0 & asosInput.Y < yBounds)
{
sum += weight[new Index3(currentInput, i * diameter + j)] * outputPreviousLayerActivated[asosInput];
var w = weight[new Index3(currentInput, i * diameter + j)]; var oA = outputPreviousLayerActivated[asosInput];
if (float.IsNaN(w * oA) | float.IsInfinity(w * oA))
{
;
}
}
}
}
sumInput[currentInput] = sum;
if (float.IsNaN(sum) | float.IsInfinity(sum))
{
;
}
}
//static readonly float[,] sobelXKern = new float[3, 3]
//{
// { -1,0,1 },
// { -2,0,2 },
// { -1,0,1 }
//};
//static readonly float[,] sobelYKern = new float[3, 3]
//{
// { -1,-2,-1 },
// { 0, 0, 0 },
// { 1, 2, 1 }
//};
#region Sobel
public static void CalculateHorizontalSobel(Index2 index, ArrayView3D <short> result, ArrayView3D <short> image)
{
if (index.X == 0 || index.Y == 0 ||
index.X == image.Width - 1 || index.Y == image.Height - 1)
{
for (int i = 0; i < image.Depth; i++)
{
result[index.X, index.Y, i] = 32000;
}
return;
}
for (int i = 0; i < image.Depth; i++)
{
var kern = image.GetSliceView(i).GetSubView(new Index2(index.X - 1, index.Y - 1), new Index2(3, 3));
short val = 0;
val += (short)(kern[0, 0] * -1);
val += (short)(kern[2, 0] * 1);
val += (short)(kern[0, 1] * -2);
val += (short)(kern[2, 1] * 2);
val += (short)(kern[0, 2] * -1);
val += (short)(kern[2, 2] * 1);
result[index.X, index.Y, i] = val;
}
}
public static void CalculateVerticalSobel(Index2 index, ArrayView3D <short> result, ArrayView3D <short> image)
{
if (index.X == 0 || index.Y == 0 ||
index.X == image.Width - 1 || index.Y == image.Height - 1)
{
for (int i = 0; i < image.Depth; i++)
{
result[index.X, index.Y, i] = 30000;
}
return;
}
//var sobelYKern = new short[3, 3]
//{
// { -1,-2,-1 },
// { 0, 0, 0 },
// { 1, 2, 1 }
//};
for (int i = 0; i < image.Depth; i++)
{
var kern = image.GetSubView(new Index3(index.X - 1, index.Y - 1, i), new Index3(3, 3, 1)).GetSliceView(0);
short val = 0;
val += (short)(kern[0, 0] * -1);
val += (short)(kern[1, 0] * -2);
val += (short)(kern[2, 0] * -1);
val += (short)(kern[0, 2] * 1);
val += (short)(kern[1, 2] * 2);
val += (short)(kern[2, 2] * 1);
result[index.X, index.Y, i] = val;
}
}
public static uint[] AccumulateEdges(ArrayView3D <short> imageShortView, ArrayView3D <byte> imageByteView, byte[] cannyData, byte pearsonThreshold, short maxValue)
{
uint[] result;
var pearsonData = CalculationWrappers.CalculatePearsonCorrelation(imageByteView, 0, pearsonThreshold).rawPicture;
var signLengthByte = CalculateSignatureLengthDerivative(imageByteView, true).rawPicture;
var signLengthShort = CalculateSignatureLengthDerivative(imageShortView, true, maxValue).rawPicture;
var picIndex = imageByteView.GetSliceView(0).Extent;
using (var pearsBuffer = GpuContext.Instance.Accelerator.Allocate <byte>(picIndex))
using (var signLengthByteBuffer = GpuContext.Instance.Accelerator.Allocate <byte>(picIndex))
using (var signLengthShortBuffer = GpuContext.Instance.Accelerator.Allocate <byte>(picIndex))
using (var cannyBuffer = GpuContext.Instance.Accelerator.Allocate <byte>(picIndex))
using (var imgBuffer = GpuContext.Instance.Accelerator.Allocate <uint>(picIndex))
{
pearsBuffer.CopyFrom(pearsonData, 0, Index2.Zero, picIndex.Size);
signLengthByteBuffer.CopyFrom(signLengthByte, 0, Index2.Zero, picIndex.Size);
signLengthShortBuffer.CopyFrom(signLengthShort, 0, Index2.Zero, picIndex.Size);
cannyBuffer.CopyFrom(cannyData, 0, Index2.Zero, picIndex.Size);
_accumulateEdgesKernel(picIndex, imgBuffer.View, pearsBuffer.View, cannyBuffer.View, signLengthByteBuffer.View, signLengthShortBuffer.View);
GpuContext.Instance.Accelerator.Synchronize();
result = imgBuffer.GetAsArray();
}
return(result);
}
public static uint[] GetSobelMap(Index2 index, ArrayView3D <short> imageView)
{
var horizontalSobelKernel = GpuContext.Instance.Accelerator.LoadAutoGroupedStreamKernel <Index2, ArrayView3D <short>, ArrayView3D <short> >(Kernels.CalculateHorizontalSobel);
var verticalSobelKernel = GpuContext.Instance.Accelerator.LoadAutoGroupedStreamKernel <Index2, ArrayView3D <short>, ArrayView3D <short> >(Kernels.CalculateVerticalSobel);
var accumulateSobelKernel = GpuContext.Instance.Accelerator.LoadAutoGroupedStreamKernel <Index3, ArrayView3D <short>, ArrayView3D <short>, ArrayView3D <short> >(Kernels.AccumulateSobelMap);
var calculateSobelKernel = GpuContext.Instance.Accelerator.LoadAutoGroupedStreamKernel <Index2, ArrayView2D <short>, ArrayView3D <short> >(Kernels.CalculateSobel);
uint[] result;
using (var bufHor = GpuContext.Instance.Accelerator.Allocate <short>(imageView.Extent))
using (var bufVer = GpuContext.Instance.Accelerator.Allocate <short>(imageView.Extent))
using (var bufAccum = GpuContext.Instance.Accelerator.Allocate <short>(imageView.Extent))
using (var bufMap = GpuContext.Instance.Accelerator.Allocate <short>(index))
using (var bufOut2 = GpuContext.Instance.Accelerator.Allocate <uint>(index))
{
horizontalSobelKernel(index, bufHor.View, imageView);
GpuContext.Instance.Accelerator.Synchronize();
verticalSobelKernel(index, bufVer.View, imageView);
GpuContext.Instance.Accelerator.Synchronize();
accumulateSobelKernel(bufAccum.Extent, bufAccum.View, bufHor.View, bufVer.View);
GpuContext.Instance.Accelerator.Synchronize();
calculateSobelKernel(index, bufMap.View, bufAccum.View);
GpuContext.Instance.Accelerator.Synchronize();
PiсConvertKernel(index.Size, bufOut2.AsLinearView(), bufMap.AsLinearView(), 1, 0);
GpuContext.Instance.Accelerator.Synchronize();
result = bufOut2.GetAsArray();
}
return(result);
}
private static void strategyBestEach(Index1 index, ArrayView3D <int> palres)
{
int min = palres.Extent.Z;
int ind = 0;
int changed = 0;
for (int i = 0; i < palres.Extent.Y; i++)
{
if (index != i && palres[index, i, 0] < min && palres[index, i, 0] >= 0)
{
min = palres[index, i, 0];
ind = i;
changed = 1;
}
}
if (changed == 1)
{
palres[index, index, 0] = ind;
palres[index, index, 1] = min;
}
else
{
palres[index, index, 0] = -1;
}
}
public static BrightnessCalculationData CalculateBrightnessStats(ArrayView3D <short> imageView, BrightnessCalculationData output)
{
using (var meanBrightnessBuf = GpuContext.Instance.Accelerator.Allocate <double>(imageView.Depth))
using (var maxBrightnessBuf = GpuContext.Instance.Accelerator.Allocate <short>(imageView.Depth))
using (var deviationBuf = GpuContext.Instance.Accelerator.Allocate <double>(imageView.Depth))
{
_calcStatsKernel(imageView.Depth, imageView, meanBrightnessBuf.View, maxBrightnessBuf.View, deviationBuf.View);
GpuContext.Instance.Accelerator.Synchronize();
var max = maxBrightnessBuf.GetAsArray().Max();
var dMax = (int)deviationBuf.GetAsArray().Max();
var height = Math.Max(max, dMax) + 1;
output.imageSize = new Index2(1000, 1000);
double scale = 1000 / (double)height;
using (var imageBuf = GpuContext.Instance.Accelerator.Allocate <int>(output.imageSize))
{
_memSetKernel(output.imageSize.Size, imageBuf.AsLinearView(), ColorConsts.Black);
GpuContext.Instance.Accelerator.Synchronize();
_calcMapKernel(imageView.Depth, meanBrightnessBuf.View, maxBrightnessBuf.View, deviationBuf.View, imageBuf.View, ColorConsts.Red, ColorConsts.Blue, ColorConsts.Green, scale);
GpuContext.Instance.Accelerator.Synchronize();
output.arrImage = imageBuf.GetAsArray();
output.arrMeanBrightness = meanBrightnessBuf.GetAsArray();
output.arrMaxBrightness = maxBrightnessBuf.GetAsArray();
output.arrStandardDeviation = deviationBuf.GetAsArray();
}
}
return(output);
}
public static double PearsonSobelCorrelation(ArrayView3D <byte> bufIn, Index2 pixel1, Index2 pixel2)
{
var minLength = bufIn.Depth;
int sum1 = 0, sum2 = 0;
float mean1 = 0, mean2 = 0;
for (int i = 0; i < minLength; i++)
{
short x = bufIn[pixel1.X, pixel1.Y, i];
short y = bufIn[pixel2.X, pixel2.Y, i];
sum1 += x;
sum2 += y;
}
mean1 = sum1 / minLength;
mean2 = sum2 / minLength;
float covariation = 0;
float xDerSqrSum = 0;
float yDerSqrSum = 0;
for (int i = 0; i < minLength; i++)
{
short x = bufIn[pixel1.X, pixel1.Y, i];
short y = bufIn[pixel2.X, pixel2.Y, i];
float xDer = x - mean1;
float yDer = y - mean2;
covariation += xDer * yDer;
xDerSqrSum += xDer * xDer;
yDerSqrSum += yDer * yDer;
}
return(covariation / XMath.Sqrt(xDerSqrSum * yDerSqrSum));
}
public static void CalculateSignatureLengthDerivative(Index2 index, ArrayView3D <float> output, ArrayView3D <byte> input)
{
var x = index.X;
var y = index.Y;
if (x == 0)
{
x = 1;
}
if (x == input.Width - 1)
{
x = input.Width - 2;
}
if (y == 0)
{
y = 1;
}
if (y == input.Height - 1)
{
y = input.Height - 2;
}
var depth = input.Depth;
float xDiffComponentSum = 0;
float yDiffComponentSum = 0;
for (int i = 0; i < depth; i++)
{
var val1 = input[x - 1, y, i]; if (val1 < 0)
{
val1 = 0;
}
var val2 = input[x + 1, y, i]; if (val2 < 0)
{
val1 = 0;
}
var xDiff = val2 - val1;
xDiffComponentSum += xDiff * xDiff;
val1 = input[x, y - 1, i]; if (val1 < 0)
{
val1 = 0;
}
val2 = input[x, y + 1, i]; if (val2 < 0)
{
val1 = 0;
}
var yDiff = val2 - val1;
yDiffComponentSum += yDiff * yDiff;
}
var xDiffLength = XMath.Sqrt(xDiffComponentSum);
var yDiffLength = XMath.Sqrt(yDiffComponentSum);
output[index.X, index.Y, 0] = xDiffLength;
output[index.X, index.Y, 1] = yDiffLength;
output[index.X, index.Y, 2] = XMath.Max(xDiffLength, yDiffLength);
}
public static PicturesData CalculateSignatureLengthDerivative(ArrayView3D <byte> imageView, bool normalize)
{
PicturesData result = new PicturesData();
var slice = imageView.GetSliceView(0);
var picIndex = new Index3(slice.Extent.X, slice.Extent.Y, 3);
using (var calcBuffer = GpuContext.Instance.Accelerator.Allocate <float>(picIndex))
using (var byteBuf = GpuContext.Instance.Accelerator.Allocate <byte>(picIndex))
using (var imageBuffer = GpuContext.Instance.Accelerator.Allocate <uint>(picIndex))
{
if (normalize)
{
BCalculateSignatureLengthDerivativeWithNormalizationKernel(slice.Extent, calcBuffer.View, imageView);
}
else
{
BCalculateSignatureLengthDerivativeKernel(slice.Extent, calcBuffer.View, imageView);
}
GpuContext.Instance.Accelerator.Synchronize();
var array = calcBuffer.GetAsArray();
var maxBand1 = array.Take(slice.Extent.Size).Max();
var maxBand2 = array.Skip(slice.Extent.Size).Take(slice.Extent.Size).Max();
//var maxBand3 = array.Skip(slice.Extent.Size * 2).Max();
var maxBand3 = XMath.Max(maxBand1, maxBand2);
NormalizeLengthMapKernel(slice.Extent, calcBuffer, 0, maxBand1); GpuContext.Instance.Accelerator.Synchronize();
NormalizeLengthMapKernel(slice.Extent, calcBuffer, 1, maxBand2); GpuContext.Instance.Accelerator.Synchronize();
NormalizeLengthMapKernel(slice.Extent, calcBuffer, 2, maxBand3); GpuContext.Instance.Accelerator.Synchronize();
FloatToByteKernel(calcBuffer.Extent.Size, calcBuffer.AsLinearView(), byteBuf.AsLinearView());
GpuContext.Instance.Accelerator.Synchronize();
result.rawPicture = byteBuf.GetAsArray().Skip(slice.Extent.Size * 2).ToArray();
PinConvertFromByteKernel(slice.Extent.Size, imageBuffer.GetSliceView(0).AsLinearView(), byteBuf.GetSliceView(0).AsLinearView(), 1.0, 0);
PinConvertFromByteKernel(slice.Extent.Size, imageBuffer.GetSliceView(1).AsLinearView(), byteBuf.GetSliceView(1).AsLinearView(), 1.0, 0);
PinConvertFromByteKernel(slice.Extent.Size, imageBuffer.GetSliceView(2).AsLinearView(), byteBuf.GetSliceView(2).AsLinearView(), 1.0, 0);
GpuContext.Instance.Accelerator.Synchronize();
var img = imageBuffer.GetAsArray();
var size = slice.Extent.Size;
var buf = new uint[size];
Array.Copy(img, 0, buf, 0, size);
result.xPicture = buf;
buf = new uint[size];
Array.Copy(img, size, buf, 0, size);
result.yPicture = buf;
buf = new uint[size];
Array.Copy(img, size * 2, buf, 0, size);
result.xyPicture = buf;
}
return(result);
}
public DebugArrayView3D(ArrayView3D <T, TStride> source)
{
Extent = source.Extent;
Stride = source.Stride;
SyncDebuggerState(source.BaseView);
Data = source.AsGeneral().GetAsArray3D();
}
private static void strategy(Index2 index, ArrayView3D <byte> destBuffer, Index2 offset, ArrayView <byte> color)
{
Index2 ind = index + offset;
for (int i = 0; i < color.Length; i++)
{
destBuffer[new Index3(i, ind)] = color[i];
}
}
public static void ConvertToByte(Index3 index, ArrayView3D <byte> output, ArrayView3D <short> input, short maxValue)
{
var val = input[index];
val = XMath.Clamp(val, (short)0, maxValue);
byte result = (byte)((val / (float)maxValue) * 255);
output[index] = result;
}
internal static void ArrayViewMultidimensionalAccessKernel(
Index1D index,
ArrayView3D <int, Stride3D.DenseXY> data,
ArrayView3D <int, Stride3D.DenseXY> source)
{
var reconstructedIndex = data.Extent.ReconstructIndex(index);
data[reconstructedIndex] = source[reconstructedIndex];
}
public static CorrelationData CalculatePearsonCorrelation(ArrayView3D <byte> imageView, byte lowThreshold = 0, byte highThreshold = 0)
{
var result = new CorrelationData();
var slice = imageView.GetSliceView(0);
var comboSlice = new Index3(slice.Width, slice.Height, 3);
using (var calcBuf = GpuContext.Instance.Accelerator.Allocate <float>(comboSlice))
using (var byteBuf = GpuContext.Instance.Accelerator.Allocate <byte>(comboSlice))
using (var imageBuf = GpuContext.Instance.Accelerator.Allocate <uint>(comboSlice))
{
PearsonKernel(slice.Extent, calcBuf.View, imageView);
GpuContext.Instance.Accelerator.Synchronize();
var maxCorrelation = calcBuf.GetAsArray().Max();
NormalizeKernel(calcBuf.Extent.Size, calcBuf.AsLinearView(), maxCorrelation);
GpuContext.Instance.Accelerator.Synchronize();
var maxGradientValue = calcBuf.GetAsArray().Skip(slice.Extent.Size).Take(slice.Extent.Size).Max();
NormalizeKernel(slice.Extent.Size, calcBuf.GetSliceView(1).AsLinearView(), maxGradientValue);
GpuContext.Instance.Accelerator.Synchronize();
FloatToByteKernel(calcBuf.Extent.Size, calcBuf.AsLinearView(), byteBuf.AsLinearView());
GpuContext.Instance.Accelerator.Synchronize();
if (highThreshold != 0 || lowThreshold != 0)
{
ThresholdingKernel(byteBuf.Extent.Size, byteBuf.AsLinearView(), lowThreshold, highThreshold);
GpuContext.Instance.Accelerator.Synchronize();
}
result.rawPicture = byteBuf.GetAsArray().Skip(slice.Extent.Size * 2).ToArray();
PiсConvertFromByteKernel(slice.Extent.Size, imageBuf.GetSliceView(0).AsLinearView(), byteBuf.GetSliceView(0).AsLinearView(), 1.0, 0);
PiсConvertFromByteKernel(slice.Extent.Size, imageBuf.GetSliceView(1).AsLinearView(), byteBuf.GetSliceView(1).AsLinearView(), 1.0, 0);
PiсConvertFromByteKernel(slice.Extent.Size, imageBuf.GetSliceView(2).AsLinearView(), byteBuf.GetSliceView(2).AsLinearView(), 1.0, 0);
GpuContext.Instance.Accelerator.Synchronize();
var img = imageBuf.GetAsArray();
var size = slice.Extent.Size;
var buf = new uint[size];
Array.Copy(img, 0, buf, 0, size);
result.xCorrelation = buf;
buf = new uint[size];
Array.Copy(img, size, buf, 0, size);
result.yCorrelation = buf;
buf = new uint[size];
Array.Copy(img, size * 2, buf, 0, size);
result.xyCorrelation = buf;
}
return(result);
}
public static void CalculateHistogram(Index3 index, ArrayView <int> result, ArrayView3D <short> input)
{
var val = input[index];
if (val < 0)
{
val = 0;
}
Atomic.Add(ref result[(int)val], 1);
}
public static short Magnitude(ArrayView3D <short> a, Index2 index)
{
var extent = a.Depth;
int sum = 0;
for (int i = 0; i < extent; i++)
{
sum = (int)XMath.Pow(a[index.X, index.Y, i], 2);
}
return((short)XMath.Sqrt(sum));
}
internal static void AlternateWeights(Index2 currentInput, ArrayView3D <float> weight, ArrayView3D <float> newWeights)
{
for (int z = 0; z < weight.Extent.Z; z++)
{
var index = new Index3(currentInput, z);
if (newWeights[index] != 0f)
{
weight[index] = newWeights[index];
}
}
}
internal static void AlternateConnections(Index2 currentInput, ArrayView3D <int> connectionInfo, ArrayView3D <int> newConnenctionInfo)
{
for (int z = 0; z < connectionInfo.Extent.Z; z++)
{
var index = new Index3(currentInput, z);
if (newConnenctionInfo[index] != 0f)
{
connectionInfo[index] = newConnenctionInfo[index];
}
}
}
public dVoxelChunk(AABB aabb, Vec3 position, int width, int depth, int height, int maxViewDist, ArrayView3D <int> tiles, ArrayView <int> tileMaterialIDs)
{
this.aabb = aabb;
this.position = position;
this.width = width;
this.depth = depth;
this.height = height;
this.maxViewDist = maxViewDist;
this.tiles = tiles;
this.tileMaterialIDs = tileMaterialIDs;
}
public static uint[] PictureConvertion(ArrayView3D <byte> imageView, int band, double mult, short min)
{
uint[] result;
using (var bufOut = GpuContext.Instance.Accelerator.Allocate <uint>(imageView.Width * imageView.Height))
{
PiсConvertFromByteKernel(bufOut.Length, bufOut.View, imageView.GetSliceView(band - 1).AsLinearView(), mult, min);
GpuContext.Instance.Accelerator.Synchronize();
result = bufOut.GetAsArray();
}
return(result);
}
internal static void Calculate(Index2 currentInput, ArrayView3D <float> weight, ArrayView3D <int> connectionInfo, ArrayView2D <float> outputPreviousLayerActivated, ArrayView2D <float> sumInput, ArrayView2D <float> bias, ArrayView <float> variables)
{
float sum = bias[currentInput];
for (int i = 0; i < connectionInfo.Extent.Z; i += 2)
{
int x = connectionInfo[new Index3(currentInput, i)];
int y = connectionInfo[new Index3(currentInput, i + 1)];
sum += outputPreviousLayerActivated[new Index2(x, y)] * weight[new Index3(currentInput, i / 2)];
}
sumInput[currentInput] = sum;
}
private static void strategy(Index2 index, ArrayView3D <byte> destBuffer, ArrayView3D <byte> srcBuffer,
Index2 dstOffset, Index2 srcOffset, int ColorSize, ArrayView <byte> BitChecker,
int Zoom, ArrayView <byte> BackgroundColor)
{
bool change = true;
byte b = 0;
for (int i = 0; i < ColorSize; i++)
{
b = BitChecker[i];
if (change && BitChecker[i] != 0 &&
(srcBuffer[new Index3(i, index + srcOffset)] & b) != 0)
{
change = false;
}
}
if (!change && BackgroundColor.Length != ColorSize)
{
return;
}
Index2 off = dstOffset + (index * Zoom);
if (change)
{
Index2 srcOff = index + srcOffset;
for (int x = 0; x < Zoom; x++)
{
for (int y = 0; y < Zoom; y++)
{
for (int i = 0; i < ColorSize; i++)
{
destBuffer[new Index3(i, off + new Index2(x, y))] = srcBuffer[new Index3(i, srcOff)];
}
}
}
}
else
{
for (int x = 0; x < Zoom; x++)
{
for (int y = 0; y < Zoom; y++)
{
for (int i = 0; i < ColorSize; i++)
{
destBuffer[new Index3(i, off + new Index2(x, y))] = BackgroundColor[i];
}
}
}
}
}
public static void CalculateSlices(Index index, ArrayView2D <uint> result, ArrayView3D <short> input, int row, int column)
{
for (int i = 0; i < input.Width; i++)
{
uint val = (uint)(input[i, row, index.X] / 9000f * 255);
result[i + 1 /*+ index.X*/, input.Depth /*- index.X*/] = (uint)((val) + (val << 8) + (val << 16) + (255 << 24));
}
for (int i = 0; i < input.Height; i++)
{
uint val = (uint)(input[column, i, index.X] / 9000f * 255);
result[input.Width /*+ index.X*/, input.Depth - 1 /*- index.X*/ + i] = (uint)((val) + (val << 8) + (val << 16) + (255 << 24));
}
}
internal static void FullyConnectedLayer2D(Index2 currentInput, ArrayView3D <float> weights, ArrayView2D <float> outputsPreviousLayerActivated, ArrayView2D <float> sumInput, ArrayView2D <float> bias, ArrayView <float> variables)
{
float sum = bias[currentInput];
for (int x = 0; x < outputsPreviousLayerActivated.Width; x++)
{
for (int y = 0; y < outputsPreviousLayerActivated.Height; y++)
{
sum += weights[new Index3(currentInput, x * y + x)] * outputsPreviousLayerActivated[new Index2(x, y)];
}
}
sumInput[currentInput] = sum;
}
private static void strategyReduceColors(Index1 index, ArrayView3D <int> palres, ArrayView3D <int> palres2, ArrayView2D <int> palsBuff, ArrayView2D <int> indsbuff, ArrayView2D <int> tilesPerPalBuff)
{
int i1 = indsbuff[index, 0];
int i2 = indsbuff[index, 1];
for (int i = 0; i < palsBuff.Extent.Y; i++)
{
palsBuff[i1, i] = palres[i1, i2, i + 1];
}
for (int i = 0; i < tilesPerPalBuff.Extent.Y; i++)
{
tilesPerPalBuff[i1, i] = palres2[i1, i2, i];
}
}
public static void Execute(Index3 index, ArrayView3D <byte> destBuffer, byte[] color)
{
if (color == null)
{
throw new ArgumentNullException(nameof(color));
}
using (MemoryBuffer <byte> c = HardwareAcceleratorManager.GPUAccelerator.Allocate <byte>(color.Length))
{
c.CopyFrom(color, 0, 0, color.Length);
kernel(index, destBuffer, c);
HardwareAcceleratorManager.GPUAccelerator.Synchronize();
}
}
internal static void FullyConnectedLayer2D(Index2 currentInput, ArrayView3D <float> weights, ArrayView2D <float> error, ArrayView2D <float> activatedPreviousLayer, ArrayView2D <float> bias, ArrayView <float> variables)
{
var fac = error[currentInput] * variables[new Index1(0)];
bias[currentInput] -= fac;
for (int x = 0; x < activatedPreviousLayer.Width; x++)
{
for (int y = 0; y < activatedPreviousLayer.Height; y++)
{
Index2 asosIndex = new Index2(x, y);
var adjustment = fac * activatedPreviousLayer[asosIndex];
weights[new Index3(currentInput, x * y + x)] -= adjustment;
}
}
}
