//create diamond with dist from center point 1 to each direction
private static int[,] DiamondProcess(int dist)
{
int[,] result = new int[(dist * 2) + 1, (dist * 2) + 1];
//int[] resVect = result.Cast<int>().ToArray();
ArrGen <int> d = new ArrGen <int>();
if (HelpMe(dist, dist))
{
result = d.ArrOfSingle(result.GetLength(0), result.GetLength(0), 1);
for (int i = 0; i < result.GetLength(0); i++)
{
for (int j = 0; j < result.GetLength(0); j++)
{
if (i < dist && j < dist - i || i < dist && j > i + dist)
{
result[i, j] = 0;
}
else if (i > dist && j < i - dist || i > dist && j > result.GetLength(0) - (i - dist + 1))
{
result[i, j] = 0;
}
}
}
}
return(result);
}
//create octagon with dist from center point 1 to each direction
private static int[,] OctagonProcess(int dist)
{
ArrGen <int> d = new ArrGen <int>();
int[,] result = d.ArrOfSingle((dist * 2) + 1, (dist * 2) + 1, 1);
var baka = dist / 3 * 2;
if (HelpMe(dist, dist))
{
for (int i = 0; i < result.GetLength(0); i++)
{
for (int j = 0; j < result.GetLength(0); j++)
{
if (i < baka && j < baka - i || i < baka && j >= result.GetLength(0) - baka + i)
{
result[i, j] = 0;
}
else if (i >= result.GetLength(0) - baka && j <= baka - (result.GetLength(0) - i) ||
i >= result.GetLength(0) - baka && j >= result.GetLength(0) - (i - (baka * 2 + 1)) - 1)
{
result[i, j] = 0;
}
}
}
}
return(result);
}
//create rectangle with entred height and width
private static int[,] RectangleProcess(int height, int width)
{
ArrGen <int> d = new ArrGen <int>();
if (HelpMe(height, width))
{
return(d.ArrOfSingle(height, width, 1));
}
return(new int[height, width]);
}
//create disk with radius
private static int[,] DiskProcess(int radius)
{
int[,] result = new int[(radius * 2) + 1, (radius * 2) + 1];
ArrGen <int> d = new ArrGen <int>();
if (HelpMe(radius, radius))
{
//if (radius == 0)
// result = new int[1; 1] { { 1 } };
if (radius == 1)
{
result = new int[3, 3] {
{ 0, 1, 0 }, { 1, 1, 1 }, { 0, 1, 0 }
}
}
;
else if (radius == 3)
{
result = d.ArrOfSingle(5, 5, 1);
}
else
{
if (radius != 2)
{
result = new int[(radius * 2) - 1, (radius * 2) - 1];
}
result = d.ArrOfSingle(result.GetLength(0), result.GetLength(0), 1);
for (int i = 0; i < result.GetLength(0); i++)
{
for (int j = 0; j < result.GetLength(0); j++)
{
if (i == 0 || i == result.GetLength(0) - 1)
{
if (j < 2 || j > result.GetLength(0) - 3)
{
result[i, j] = 0;
}
}
else if (i == 1 || i == result.GetLength(0) - 2)
{
if (j < 1 || j > result.GetLength(0) - 2)
{
result[i, j] = 0;
}
}
}
}
}
}
return(result);
}
//create square with entered square side size
private static int[,] SquareProcess(int size)
{
ArrGen <int> d = new ArrGen <int>();
if (HelpMe(size, size))
{
return(d.ArrOfSingle(size, size, 1));
}
return(new int[size, size]);
}
//create line with lenght and diretion
private static int[,] LineProcess(int size, LineStructElementDegree lineType)
{
int[,] resultH = new int [1, size];
int[,] resultV = new int [size, 1];
int[,] tempRes = new int [size, size];
ArrGen <int> d = new ArrGen <int>();
if (HelpMe(size, size))
{
switch (lineType)
{
case LineStructElementDegree.horizontal:
resultH = d.ArrOfSingle(1, size, 1);
return(resultH);
case LineStructElementDegree.vertical:
resultV = d.ArrOfSingle(size, 1, 1);
return(resultV);
case LineStructElementDegree.plus45:
int m = size - 1;
int n = 0;
for (int i = 0; i < size; i++)
{
for (int j = 0; j < size; j++)
{
if (i == n && j == m)
{
tempRes[i, j] = 1;
}
}
m--;
n++;
}
return(tempRes);
case LineStructElementDegree.minus45:
for (int i = 0; i < size; i++)
{
for (int j = 0; j < size; j++)
{
if (i == j)
{
tempRes[i, j] = 1;
}
}
}
return(tempRes);
}
}
return(tempRes);
}
private static int[,] SaltandPepper(int[,] arr, double[,] noise, double densitySalt, double densityPepper, int white, SaltandPapperNoise noiseType)
{
int[,] result = new int[arr.GetLength(0), arr.GetLength(1)];
ArrGen <int> d = new ArrGen <int>();
var vectorArr = arr.Cast <int>().ToArray();
var vectorNoise = noise.Cast <double>().ToArray();
switch (noiseType)
{
case SaltandPapperNoise.salt:
for (int i = 0; i < noise.Length; i++)
{
if (vectorNoise[i] >= (1 - densitySalt / 2))
{
vectorArr[i] = white;
}
}
result = d.VecorToArrayRowByRow(arr.GetLength(0), arr.GetLength(1), vectorArr);
break;
case SaltandPapperNoise.pepper:
for (int i = 0; i < noise.Length; i++)
{
if (vectorNoise[i] <= densityPepper / 2)
{
vectorArr[i] = 0;
}
}
result = d.VecorToArrayRowByRow(arr.GetLength(0), arr.GetLength(1), vectorArr);
break;
case SaltandPapperNoise.saltandpepper:
for (int i = 0; i < noise.Length; i++)
{
if (vectorNoise[i] >= (1 - densitySalt / 2))
{
vectorArr[i] = white;
}
}
for (int i = 0; i < noise.Length; i++)
{
if (vectorNoise[i] <= densityPepper / 2)
{
vectorArr[i] = 0;
}
}
result = d.VecorToArrayRowByRow(arr.GetLength(0), arr.GetLength(1), vectorArr);
break;
}
return(result);
}
//process histogram by applying lut
private static int[,] HisteqHelper(int[,] cPlane)
{
//gen array of the same values
ArrGen <double> d = new ArrGen <double>();
double eps = 2.2204 * Math.Pow(10, -16);
const int nDef = 64; //default
const int nUint8 = 256; //for uint8 image. At this time operationg only with them
int[,] Result;
//hgram contain integer counts for equally spaced bins with intensity values
//here count it based on input array
//array on ones 1 x nDef mult by input array length dived by nDef
//obtain vector 1 x nDef size
var hgram = (d.ArrOfSingle(1, nDef, 1).Cast <double>().ToArray()).VectorMultByConst((cPlane.ArrayToDouble().Cast <double>().ToArray().Length) / (double)nDef);
//Normalize hgram. hgram = hgram mult by input array dived by hgram elements sum
hgram = hgram.VectorMultByConst((cPlane.ArrayToDouble().Cast <double>().ToArray().Length) / (hgram.Cast <double>().ToArray().Sum()));
var m = hgram.Length;
//compute Cumulative and Histogram
var imhist = ImHist(cPlane); //imhist only for uint8 arrays realization ([0..255])
double[] CumuSum = new double[nUint8];
for (int i = 0; i < nUint8; i++)
{
if (i == 0)
{
CumuSum[i] = imhist[i];
}
else
{
CumuSum[i] = imhist[i] + CumuSum[i - 1];
}
}
//cumulative distribution function
//create Transformation To Intensity Image
var cumdInput = hgram.VectorMultByConst((cPlane.ArrayToDouble().Cast <double>().ToArray().Length) / (hgram.Cast <double>().ToArray().Sum()));
double[] cumd = new double[nDef];
for (int i = 0; i < nDef; i++)
{
if (i == 0)
{
cumd[i] = cumdInput[i];
}
else
{
cumd[i] = cumdInput[i] + cumd[i - 1];
}
}
//Create transformation to an intensity image by minimizing the error
//between desired and actual cumulative histogram.
//tol saturates equal fractions at low and high pixel values
//sory for this wtf code
var z = new double[2 * imhist.Length];
var partOne = imhist.ToList();
partOne[nUint8 - 1] = 0;
partOne.ToArray().CopyTo(z, 0);
var partTwo = imhist.ToList();
partTwo[0] = 0;
partTwo.ToArray().CopyTo(z, imhist.Length);
var tolPart = d.VecorToArrayRowByRow(1, nUint8, (d.VecorToArrayRowByRow(2, nUint8, z)).MinInColumns());
var tol = (d.ArrOfSingle(m, 1, 1)).MultArrays(tolPart.ArrayDivByConst(2));
//Error
var cumdArr = d.TransposeArray(d.VecorToArrayRowByRow(1, nDef, cumd));
var CumuSumArr = d.VecorToArrayRowByRow(1, nUint8, CumuSum);
var errPartOne = cumdArr.MultArrays(d.ArrOfSingle(1, nUint8, 1));
var errPartTwo = (d.ArrOfSingle(m, 1, 1)).MultArrays(CumuSumArr);
var err = errPartOne.SubArrays(errPartTwo).SumArrays(tol);
//Find all places with error. Yep; wtf code continues!
List <double> erroIndexes = new List <double>();
//present array as vector col by col. Coz this is cool. Cast dont need!
//Sorry; stupid copy step by step matlab logic
//var errVector = d.ArrayToVectorColByCol(err);
//with cast faster a little?
var errVector = err.Cast <double>().ToArray();
for (int i = 0; i < errVector.Length; i++)
{
if (errVector[i] < -(cPlane.Length * Math.Sqrt(eps)))
{
erroIndexes.Add(i);
}
}
//f**k the error values
double[,] rest = new double[err.GetLength(0), err.GetLength(1)];
if (erroIndexes.Any())
{
var newErrVector = errVector.ToList();
var newValue = (d.ArrOfSingle(erroIndexes.Count(), 1, 1).Cast <double>().ToArray()).VectorMultByConst(cPlane.Length); //coz erroIndexes - vector
for (int i = 0; i < errVector.Length; i++)
{
for (int j = 0; j < erroIndexes.Count(); j++)
{
if (i == erroIndexes[j])
{
newErrVector[i] = cPlane.Length; //newValue[j];
}
}
}
rest = d.VecorToArrayRowByRow(rest.GetLength(0), rest.GetLength(1), newErrVector.ToArray());
}
else
{
//err vector back to array
rest = err;
}
//find row number of mins in each col rest array
double[] lut = new double[rest.GetLength(1)];
double min;
int index = 0;
for (int i = 0; i < rest.GetLength(1); i++)
{
min = rest[0, i];
index = 0;
for (int j = 0; j < rest.GetLength(0); j++)
{
if (min > rest[j, i])
{
min = rest[j, i];
index = j;
}
}
lut[i] = index;
}
//count lut
for (int i = 0; i < lut.Length; i++)
{
lut[i] = lut[i] / (m - 1);
}
Result = (InlutHisteq(cPlane, lut)).ArrayToUint8();
return(Result);
}
private static Bitmap SaltPepperFilterProcess(Bitmap img, int m, int n, double filterOrder, SaltPepperfilterType spfiltType, bool unsharp)
{
Bitmap image = new Bitmap(img.Width, img.Height, PixelFormat.Format24bppRgb);
List <ArraysListInt> ColorList = Helpers.GetPixels(img);
var Rc = ColorList[0].Color;
var Gc = ColorList[1].Color;
var Bc = ColorList[2].Color;
double[,] filter;
int[,] resultR = new int[img.Height, img.Width];
int[,] resultG = new int[img.Height, img.Width];
int[,] resultB = new int[img.Height, img.Width];
ArrGen <double> arrGen = new ArrGen <double>();
double Depth = System.Drawing.Image.GetPixelFormatSize(img.PixelFormat);
if (m >= 1 && n >= 1)
{
switch (spfiltType)
{
//Arithmetic mean filtering.
//help with salt noize
case SaltPepperfilterType.amean:
filter = ImageFilter.FspecialSize(m, n, "average");
resultR = (ImageFilter.Filter_double(Rc, filter)).ArrayToUint8();
resultG = (ImageFilter.Filter_double(Gc, filter)).ArrayToUint8();
resultB = (ImageFilter.Filter_double(Bc, filter)).ArrayToUint8();
break;
//Geometric mean filtering.
//help with salt noize
case SaltPepperfilterType.gmean:
filter = arrGen.ArrOfSingle(m, n, 1);
resultR = GmeanCount(Rc, filter, m, n);
resultG = GmeanCount(Gc, filter, m, n);
resultB = GmeanCount(Bc, filter, m, n);
break;
//harmonic mean filter
//help with salt noize
case SaltPepperfilterType.hmean:
filter = arrGen.ArrOfSingle(m, n, 1);
resultR = HmeanCount(Rc, filter, m, n);
resultG = HmeanCount(Gc, filter, m, n);
resultB = HmeanCount(Bc, filter, m, n);
break;
//contraharmonic mean filter Q>0 for pepper & <0 for salt
case SaltPepperfilterType.chmean:
filter = arrGen.ArrOfSingle(m, n, 1);
resultR = CharmeanCount(Rc, filter, filterOrder);
resultG = CharmeanCount(Gc, filter, filterOrder);
resultB = CharmeanCount(Bc, filter, filterOrder);
break;
default:
resultR = Rc; resultG = Gc; resultB = Bc;
break;
}
image = Helpers.SetPixels(image, resultR, resultG, resultB);
if (unsharp) //spfiltType == SaltPepperfilterType.chmean & unsharp
{
image = Helpers.FastSharpImage(image);
}
if (Depth == 8)
{
image = PixelFormatWorks.Bpp24Gray2Gray8bppBitMap(image);
}
if (Depth == 1)
{
image = PixelFormatWorks.ImageTo1BppBitmap(image, 0.5);
}
}
else
{
Console.WriteLine("m and n parameters must be positive geater or equal 1. Recommended 2 & 2 and higher. Method >SaltandPapperFilter<");
}
return(image);
}
private static double[,] Conv2Process(double[,] inArray, double[] hrow, double[] hcol, Convback convback)
{
ArrGen <double> d = new ArrGen <double>();
double[,] result = new double[inArray.GetLength(0) + hrow.Length - 1, inArray.GetLength(1) + hcol.Length - 1];
List <double> tempColList = new List <double>();
List <double> tempRowList = new List <double>();
List <double> tempResults = new List <double>();
var arrayCols = d.ReturnListof2DArrayCols(inArray);
//first convolves columns with col vector
for (int i = 0; i < inArray.GetLength(1); i++)
{
tempResults = Convolution.Conv(arrayCols[i].Vect, hrow, Convback.full).ToList();
tempColList.AddRange(tempResults);
}
var colsResult = d.VecorToArrayColbyCol(result.GetLength(0), inArray.GetLength(1), tempColList.ToArray());
var arrayRows = d.ReturnListof2DArrayRows(colsResult);
//convolves rows of the result with row vector
for (int i = 0; i < colsResult.GetLength(0); i++)
{
tempResults = Convolution.Conv(arrayRows[i].Vect, hcol, Convback.full).ToList();
tempRowList.AddRange(tempResults);
}
var convResult = d.VecorToArrayRowByRow(result.GetLength(0), result.GetLength(1), tempRowList.ToArray());
result = convResult;
if (convback == Convback.same)
{
int indexCols = 0;
int indexRows = 0;
if (hcol.Length % 2 != 0)
{
indexCols = (hcol.Length - 1) / 2;
}
else
{
indexCols = hcol.Length / 2;
}
if (hrow.Length % 2 != 0)
{
indexRows = (hrow.Length - 1) / 2;
}
else
{
indexRows = hrow.Length / 2;
}
tempResults = new List <double>();
var RowsCut = d.ArrayToVectorColByCol(convResult).ToList();
for (int i = 0; i < convResult.GetLength(1); i++)
{
int index = convResult.GetLength(0) * i + indexRows;
var rowPal = RowsCut.GetRange(index, inArray.GetLength(0));
tempResults.AddRange(rowPal);
}
var sameRows = d.VecorToArrayColbyCol(inArray.GetLength(0), convResult.GetLength(1), tempResults.ToArray());
tempResults = new List <double>();
var ColsCut = sameRows.Cast <double>().ToList();
for (int i = 0; i < inArray.GetLength(0); i++)
{
int index = convResult.GetLength(1) * i + indexCols;
var colPal = ColsCut.GetRange(index, inArray.GetLength(1));
tempResults.AddRange(colPal);
}
result = new double[inArray.GetLength(0), inArray.GetLength(1)];
result = d.VecorToArrayRowByRow(inArray.GetLength(0), inArray.GetLength(1), tempResults.ToArray());
}
result.DecimalCorrection();
return(result);
}
//forgive for such implementation. Slow and ugly...
private static double[,] Conv2Process(double[,] inArray, double[,] convArray, Convback convback)
{
ArrGen <double> d = new ArrGen <double>();
double[,] result = new double[inArray.GetLength(0) + convArray.GetLength(0) - 1, inArray.GetLength(1) + convArray.GetLength(1) - 1];
List <double> tempResults = new List <double>();
double[] tempResult = new double[result.GetLength(0)];
List <VectorsListDouble> aRListIn = new List <VectorsListDouble>();
List <VectorsListDouble> aRListOut = new List <VectorsListDouble>();
List <VectorsListDouble> temp = new List <VectorsListDouble>();
List <VectorsListDouble> tempRes = new List <VectorsListDouble>();
int sameRow = convArray.GetLength(0); int sameRowPart = inArray.GetLength(0);
int sameCol = convArray.GetLength(1); int sameColPart = inArray.GetLength(1);
//lazy cheat
if (inArray.GetLength(1) < convArray.GetLength(1))
{
var tempIn = inArray;
inArray = new double[convArray.GetLength(0), convArray.GetLength(1)];
inArray = convArray;
convArray = new double[inArray.GetLength(0), inArray.GetLength(1)];
convArray = tempIn;
}
var arrayCols = d.ReturnListof2DArrayCols(inArray);
var convCols = d.ReturnListof2DArrayCols(convArray);
//conv col by col
for (int i = 0; i < convArray.GetLength(1); i++)
{
for (int j = 0; j < inArray.GetLength(1); j++)
{
tempResult = Convolution.Conv(arrayCols[j].Vect, convCols[i].Vect, Convback.full);
aRListIn.Add(new VectorsListDouble()
{
Vect = tempResult
});
}
}
if (convArray.GetLength(1) == 1)
{
aRListOut = aRListIn;
}
else
{
var first = aRListIn[0].Vect;
var last = aRListIn[aRListIn.Count - 1].Vect;
aRListOut.Add(new VectorsListDouble()
{
Vect = first
});
aRListIn.RemoveAt(0); aRListIn.RemoveAt(aRListIn.Count - 1);
int maxAmount = convArray.GetLength(1); //максимальное число суммируемых стобцов в один //max number of cols to one sum
int maxSumCount = 0; //количество maxAmount //count maxAmount
int simpleSumCount = 0; //количество остальных сумм //count another sums
int sumCount = result.GetLength(1) - 2; //кроличество всех сумм //count all sums
int step = 0; //шаг через который суммируются //sum step
if (convArray.GetLength(1) == 2)
{
simpleSumCount = inArray.GetLength(1) - 1;
step = inArray.GetLength(1) - 1;
for (int i = 0; i < sumCount; i++)
{
aRListOut.Add(new VectorsListDouble()
{
Vect = aRListIn[i].Vect.SumVectors(aRListIn[i + step].Vect)
});
}
}
else
{
step = inArray.GetLength(1) - 2 + 1;
maxSumCount = Math.Abs(inArray.GetLength(1) - convArray.GetLength(1)) + 1;
simpleSumCount = result.GetLength(1) - maxSumCount - 2;
tempResult = new double[result.GetLength(0)];
for (int i = 0; i < simpleSumCount / 2; i++)
{
int baka = i + 1;
int c = 0;
for (int j = 0; j <= baka; j++)
{
temp.Add(new VectorsListDouble()
{
Vect = aRListIn[i + c].Vect
});
c = c + step;
}
for (int k = 0; k < temp.Count; k++)
{
tempResult = tempResult.SumVectors(temp[k].Vect);
}
aRListOut.Add(new VectorsListDouble()
{
Vect = tempResult
});
temp = new List <VectorsListDouble>(); tempResult = new double[result.GetLength(0)];
}
for (int i = 0; i < maxSumCount; i++)
{
int maxstep = 0;
int maxFirstIndex = simpleSumCount / 2;
for (int j = 0; j < maxAmount; j++)
{
temp.Add(new VectorsListDouble()
{
Vect = aRListIn[i + maxFirstIndex + maxstep].Vect
});
maxstep = maxstep + step;
}
for (int k = 0; k < temp.Count; k++)
{
tempResult = tempResult.SumVectors(temp[k].Vect);
}
aRListOut.Add(new VectorsListDouble()
{
Vect = tempResult
});
temp = new List <VectorsListDouble>(); tempResult = new double[result.GetLength(0)];
}
for (int i = 0; i < simpleSumCount / 2; i++)
{
int baka = i + 1;
int c = 0;
int kap = aRListIn.Count - 1;
for (int j = 0; j <= baka; j++)
{
temp.Add(new VectorsListDouble()
{
Vect = aRListIn[kap - i - c].Vect
});
c = c + step;
}
for (int k = 0; k < temp.Count; k++)
{
tempResult = tempResult.SumVectors(temp[k].Vect);
}
tempRes.Add(new VectorsListDouble()
{
Vect = tempResult
});
temp = new List <VectorsListDouble>(); tempResult = new double[result.GetLength(0)];
}
for (int i = tempRes.Count - 1; i >= 0; i--)
{
aRListOut.Add(new VectorsListDouble()
{
Vect = tempRes[i].Vect
});
}
}
aRListOut.Add(new VectorsListDouble()
{
Vect = last
});
}
for (int i = 0; i < aRListOut.Count; i++)
{
var getCol = aRListOut[i].Vect;
tempResults.AddRange(getCol);
}
var convResult = d.VecorToArrayColbyCol(result.GetLength(0), result.GetLength(1), tempResults.ToArray());
result = convResult;
if (convback == Convback.same)
{
int indexCols = 0;
int indexRows = 0;
if (sameCol % 2 != 0)
{
indexCols = (sameCol - 1) / 2;
}
else
{
indexCols = sameCol / 2;
}
if (sameRow % 2 != 0)
{
indexRows = (sameRow - 1) / 2;
}
else
{
indexRows = sameRow / 2;
}
tempResults = new List <double>();
var RowsCut = d.ArrayToVectorColByCol(convResult).ToList();
for (int i = 0; i < convResult.GetLength(1); i++)
{
int index = convResult.GetLength(0) * i + indexRows;
var rowPal = RowsCut.GetRange(index, sameRowPart);
tempResults.AddRange(rowPal);
}
var sameRows = d.VecorToArrayColbyCol(sameRowPart, convResult.GetLength(1), tempResults.ToArray());
tempResults = new List <double>();
var ColsCut = sameRows.Cast <double>().ToList();
for (int i = 0; i < sameRowPart; i++)
{
int index = convResult.GetLength(1) * i + indexCols;
var colPal = ColsCut.GetRange(index, sameColPart);
tempResults.AddRange(colPal);
}
result = new double[sameRowPart, sameColPart];
result = d.VecorToArrayRowByRow(sameRowPart, sameColPart, tempResults.ToArray());
}
result.DecimalCorrection();
return(result);
}
//difference shown at original image by using alpha channel
public static void Difference(Bitmap imgOrig, Bitmap imgMod, double coefOne, double coefTwo, double alpha)
{
string defPath = GetImageInfo.MyPath("Rand");
int width = imgOrig.Width;
int height = imgOrig.Height;
Bitmap image = new Bitmap(width, height, PixelFormat.Format24bppRgb);
double DepthOrig = System.Drawing.Image.GetPixelFormatSize(imgOrig.PixelFormat);
double DepthMod = System.Drawing.Image.GetPixelFormatSize(imgMod.PixelFormat);
if (imgOrig.Width != imgMod.Width || imgOrig.Height != imgMod.Height)
{
Console.WriteLine("Origin and modified images dimentions dismatch or them different");
}
else if (alpha < 0 || alpha > 1)
{
Console.WriteLine("Alpha must be in range [0..1]");
}
else if (DepthOrig != DepthMod)
{
Console.WriteLine("Can`t obtain difference between 8bit and 24bit iamge");
}
else
{
List <ArraysListInt> cListOrigin = Helpers.GetPixels(imgOrig);
List <ArraysListInt> cListMod = Helpers.GetPixels(imgMod);
//get difference
var Rdif = (cListOrigin[0].Color).SubArrays(cListMod[0].Color).AbsArrayElements().ArraySubWithConst(coefOne).Uint8Range();
var Gdif = (cListOrigin[1].Color).SubArrays(cListMod[1].Color).AbsArrayElements().ArraySubWithConst(coefOne).Uint8Range();
var Bdif = (cListOrigin[2].Color).SubArrays(cListMod[2].Color).AbsArrayElements().ArraySubWithConst(coefOne).Uint8Range();
Rdif = Rdif.ArrayMultByConst(coefTwo).Uint8Range();
Gdif = Gdif.ArrayMultByConst(coefTwo).Uint8Range();
Bdif = Bdif.ArrayMultByConst(coefTwo).Uint8Range();
var fakeR = (cListOrigin[0].Color).ArrayToDouble().ArrayMultByConst(alpha).ArrayToUint8();
var fakeG = (cListOrigin[1].Color).ArrayToDouble().ArrayMultByConst(alpha).ArrayToUint8();
var fakeB = (cListOrigin[2].Color).ArrayToDouble().ArrayMultByConst(alpha).ArrayToUint8();
//obtain indexes with difference
List <int> rIndexes = new List <int>();
var rVector = Rdif.Cast <int>().ToArray();
for (int i = 0; i < rVector.Length; i++)
{
if (rVector[i] > 0)
{
rIndexes.Add(i);
}
}
var newrVector = fakeR.Cast <int>().ToList();
for (int i = 0; i < rVector.Length; i++)
{
for (int j = 0; j < rIndexes.Count(); j++)
{
if (i == rIndexes[j])
{
newrVector[i] = rVector[i];
}
}
}
//*****************
List <int> gIndexes = new List <int>();
var gVector = Gdif.Cast <int>().ToArray();
for (int i = 0; i < gVector.Length; i++)
{
if (gVector[i] > 0)
{
gIndexes.Add(i);
}
}
var newgVector = fakeG.Cast <int>().ToList();
for (int i = 0; i < gVector.Length; i++)
{
for (int j = 0; j < gIndexes.Count(); j++)
{
if (i == gIndexes[j])
{
newgVector[i] = gVector[i];
}
}
}
//*****************
List <int> bIndexes = new List <int>();
var bVector = Bdif.Cast <int>().ToArray();
for (int i = 0; i < bVector.Length; i++)
{
if (bVector[i] > 0)
{
bIndexes.Add(i);
}
}
var newbVector = fakeB.Cast <int>().ToList();
for (int i = 0; i < bVector.Length; i++)
{
for (int j = 0; j < bIndexes.Count(); j++)
{
if (i == bIndexes[j])
{
newbVector[i] = bVector[i];
}
}
}
ArrGen <int> d = new ArrGen <int>();
var R = d.VecorToArrayRowByRow(fakeR.GetLength(0), fakeR.GetLength(1), newrVector.ToArray());
var G = d.VecorToArrayRowByRow(fakeR.GetLength(0), fakeR.GetLength(1), newgVector.ToArray());
var B = d.VecorToArrayRowByRow(fakeR.GetLength(0), fakeR.GetLength(1), newbVector.ToArray());
//lay difference on alpha image
image = Helpers.SetPixels(image, R, G, B);
string outName = defPath + "Difference.png";
if (DepthOrig == 8)
{
image = PixelFormatWorks.Bpp24Gray2Gray8bppBitMap(image);
}
image.Save(outName);
}
}
//create CheckerBoard process
private static int[,] CheckerBoardHelper(int n, int r, int c)
{
int[] wCell = new int[n];
int[] bCell = new int[n];
int[,] result = new int[n * r, n *c];
for (int i = 0; i < n; i++)
{
wCell[i] = 255;
}
ArrGen <int> d = new ArrGen <int>();
int[] temp1 = new int[n * c];
int[] temp2 = new int[n * c];
var resVect = result.Cast <int>().ToArray();
for (int i = 0; i < temp1.Length / n; i++)
{
if (i % 2 == 0)
{
bCell.CopyTo(temp1, bCell.Length * i);
}
else
{
wCell.CopyTo(temp1, wCell.Length * i);
}
}
for (int i = 0; i < temp2.Length / n; i++)
{
if (i % 2 == 0)
{
wCell.CopyTo(temp2, wCell.Length * i);
}
else
{
bCell.CopyTo(temp2, bCell.Length * i);
}
}
int count = 0;
int countn = 0;
if (r % 2 == 0)
{
for (int i = 0; i < r / 2; i++)
{
for (int j = 0; j < n; j++)
{
temp1.CopyTo(resVect, temp1.Length * (i + countn));
countn++;
}
//count++;
for (int j = 0; j < n; j++)
{
temp2.CopyTo(resVect, temp2.Length * (i + countn));
countn++;
}
countn--;
}
}
else
{
for (int i = 0; i < (r - 1) / 2; i++)
{
for (int j = 0; j < n; j++)
{
temp1.CopyTo(resVect, temp1.Length * (i + count));
count++;
}
//count++;
for (int j = 0; j < n; j++)
{
temp2.CopyTo(resVect, temp2.Length * (i + count));
count++;
}
count--;
}
int baka = n;
for (int j = 0; j < n; j++)
{
temp1.CopyTo(resVect, resVect.Length - (temp2.Length * baka));
baka--;
}
}
return(d.VecorToArrayRowByRow(n * r, n * c, resVect)); //r;c; vector
}
//circular averaging filter
//within the square matrix of side 2*radius+1
//realization at the level "Bratiwka, ya tebe pokywat prines"
private static double[,] DiskProcess(double radius)
{
double[,] result = new double[1, 1];
ArrGen <double> d = new ArrGen <double>();
if (radius > 0)
{
var crad = Math.Ceiling(radius - 0.5);
int rc = 0;
for (int i = (int)(-crad); i <= crad; i++)
{
rc++;
}
double[,] x = new double[rc, rc];
double[,] y = new double[rc, rc];
var trap = -crad;
for (int i = 0; i < rc; i++)
{
for (int j = 0; j < rc; j++)
{
x[i, j] = trap + j;
y[i, j] = trap + i;
}
}
var maxxy = x.AbsArrayElements().MaxTwoArrays(y.AbsArrayElements());
var minxy = x.AbsArrayElements().MinTwoArrays(y.AbsArrayElements());
var maxxyVector = maxxy.Cast <double>().ToArray();
var minxyVector = minxy.Cast <double>().ToArray();
//temp vectors and variables
double[] temp1 = new double[rc * rc];
double[] temp2 = new double[rc * rc];
double temp = 0;
Complex tempComplex;
//m1 count by partial
double[] m1tempCusum = new double[rc * rc];
for (int i = 0; i < m1tempCusum.Length; i++)
{
//a = (rad^2 < (maxxy+0.5).^2 + (minxy-0.5).^2).*(minxy-0.5)
if (Math.Pow(radius, 2) < (Math.Pow(maxxyVector[i] + 0.5, 2) + Math.Pow(minxyVector[i] - 0.5, 2)))
{
temp = 1;
}
temp1[i] = temp * (minxyVector[i] - 0.5); temp = 0;
// b =(rad^2 >= (maxxy+0.5).^2 + (minxy-0.5).^2).* sqrt(rad ^ 2 - (maxxy + 0.5).^ 2)
if (Math.Pow(radius, 2) >= (Math.Pow(maxxyVector[i] + 0.5, 2) + Math.Pow(minxyVector[i] - 0.5, 2)))
{
temp = 1;
}
tempComplex = Complex.Sqrt(Math.Pow(radius, 2) - Math.Pow(maxxyVector[i] + 0.5, 2));
temp2[i] = temp * (tempComplex.Real + tempComplex.Imaginary); temp = 0;
}
//a + b
m1tempCusum = temp1.SumVectors(temp2);
var m1 = d.VecorToArrayRowByRow(rc, rc, m1tempCusum);
temp1 = new double[rc * rc]; temp2 = new double[rc * rc];
//m2 count by partial
double[] m2tempCusum = new double[rc * rc];
for (int i = 0; i < m2tempCusum.Length; i++)
{
//a = (rad^2 > (maxxy-0.5).^2 + (minxy+0.5).^2).*(minxy+0.5)
if (Math.Pow(radius, 2) > (Math.Pow(maxxyVector[i] - 0.5, 2) + Math.Pow(minxyVector[i] + 0.5, 2)))
{
temp = 1;
}
temp1[i] = temp * (minxyVector[i] + 0.5); temp = 0;
// b = (rad^2 <= (maxxy-0.5).^2 + (minxy+0.5).^2).* sqrt(rad ^ 2 - (maxxy - 0.5).^ 2)
if (Math.Pow(radius, 2) <= (Math.Pow(maxxyVector[i] - 0.5, 2) + Math.Pow(minxyVector[i] + 0.5, 2)))
{
temp = 1;
}
temp2[i] = temp * Math.Sqrt(Math.Pow(radius, 2) - Math.Pow(maxxyVector[i] - 0.5, 2)); temp = 0;
}
//a + b
m2tempCusum = temp1.SumVectors(temp2);
var m2 = d.VecorToArrayRowByRow(rc, rc, m2tempCusum);
temp1 = new double[rc * rc]; temp2 = new double[rc * rc];
//sgrid count by partial
double[] sgridVector = new double[rc * rc];
for (int i = 0; i < sgridVector.Length; i++)
{
//rad^2*(0.5*(asin(m2/rad) - asin(m1/rad)) + 0.25 * (sin(2 * asin(m2 / rad)) - sin(2 * asin(m1 / rad)))) - (maxxy - 0.5).* (m2 - m1) + (m1 - minxy + 0.5)
temp1[i] = Math.Pow(radius, 2) * (0.5 * (Math.Asin(m2tempCusum[i] / radius) - Math.Asin(m1tempCusum[i] / radius)) +
0.25 * (Math.Sin(2 * Math.Asin(m2tempCusum[i] / radius)) - Math.Sin(2 * Math.Asin(m1tempCusum[i] / radius)))) -
(maxxyVector[i] - 0.5) * (m2tempCusum[i] - m1tempCusum[i]) +
(m1tempCusum[i] - minxyVector[i] + 0.5);
// ((rad^2 < (maxxy+0.5).^2 + (minxy+0.5).^2) & (rad ^ 2 > (maxxy - 0.5).^ 2 + (minxy - 0.5).^ 2)) | ((minxy == 0) & (maxxy - 0.5 < rad) & (maxxy + 0.5 >= rad))
if (Math.Pow(radius, 2) < (Math.Pow(maxxyVector[i] + 0.5, 2) + Math.Pow(minxyVector[i] + 0.5, 2)))
{
temp = 1;
}
if (Math.Pow(radius, 2) > (Math.Pow(maxxyVector[i] - 0.5, 2) + Math.Pow(minxyVector[i] - 0.5, 2)) && temp == 1)
{
temp = 1;
}
else
{
temp = 0;
}
if (((minxyVector[i] == 0) && (maxxyVector[i] - 0.5 < radius) && (maxxyVector[i] + 0.5 >= radius)) || temp == 1)
{
temp = 1;
}
else
{
temp = 0;
}
temp2[i] = temp; temp = 0;
}
//a * b
sgridVector = temp1.MultVectors(temp2);
for (int i = 0; i < sgridVector.Length; i++)
{
if ((Math.Pow(maxxyVector[i] + 0.5, 2) + Math.Pow(minxyVector[i] + 0.5, 2)) < Math.Pow(radius, 2))
{
temp = 1;
}
sgridVector[i] = sgridVector[i] + temp; temp = 0;
}
var sgrid = d.VecorToArrayRowByRow(rc, rc, sgridVector);
sgrid[(int)crad, (int)crad] = Math.Min(Math.PI * Math.Pow(radius, 2), Math.PI / 2);
if ((crad > 0) && (radius > (crad - 0.5)) && (Math.Pow(radius, 2) < (Math.Pow(crad - 0.5, 2) + 0.25)))
{
var tempm1 = Math.Sqrt(Math.Pow(radius, 2) - Math.Pow(crad - 0.5, 2));
var tempm1n = tempm1 / radius;
var sg0 = 2 * (Math.Pow(radius, 2) * (0.5 * Math.Asin(tempm1n) +
0.25 * Math.Sin(2 * Math.Asin(tempm1n))) - tempm1 * (crad - 0.5));
sgrid[2 * (int)crad, (int)crad] = sg0;
sgrid[(int)crad, 2 * (int)crad] = sg0;
sgrid[(int)crad, 0] = sg0;
sgrid[0, (int)crad] = sg0;
sgrid[2 * (int)crad - 1, (int)crad] = sgrid[(2 * (int)crad - 1), (int)crad] - sg0;
sgrid[(int)crad, 2 * (int)crad - 1] = sgrid[(int)crad, 2 * (int)crad - 1] - sg0;
sgrid[(int)crad, 1] = sgrid[(int)crad, 1] - sg0;
sgrid[1, (int)crad] = sgrid[1, (int)crad] - sg0;
}
sgrid[(int)crad, (int)crad] = Math.Min(sgrid[(int)crad, (int)crad], 1);
result = new double[rc, rc];
result = d.VecorToArrayRowByRow(rc, rc, sgrid.Cast <double>().ToArray().VectorDivByConst(sgrid.Cast <double>().ToArray().Sum()));
}
else
{
Console.WriteLine("Radius must be greater 0. Method: FSpecial.Radius(). Return black point.");
}
return(result);
}
//linear motion of a camera by Len pixels
//with an angle of Theta degrees
//realization at the level "Bratiwka, ya tebe pokywat prines"
private static double[,] MotionProcess(uint len, double theta)
{
double[,] result = new double[1, 1];
ArrGen <double> d = new ArrGen <double>();
if (len > 1)
{
//Floating-point relative accuracy
double eps = 2.2204 * Math.Pow(10, -16);
//rotate half length around center
var half = ((double)len - 1) / 2;
var phi = (theta % 180) / 180 * Math.PI;
var cosPhi = Math.Cos(phi);
var sinPhi = Math.Sin(phi);
var xsign = Math.Sign(cosPhi);
if (xsign == 0 || xsign == -1)
{
Console.WriteLine("Something wrong with input parameters. Return empty."); return(result);
}
double linewdt = 1;
//define mesh for the half matrix, eps takes care of the right size for 0 & 90 rotation
var sx = half * cosPhi + linewdt * xsign - len * eps;
if (sx > 0)
{
sx = Math.Floor(sx);
}
else
{
sx = -(Math.Floor(-sx));
}
var sy = half * sinPhi + linewdt - len * eps;
if (sy > 0)
{
sy = Math.Floor(sy);
}
else
{
sy = -(Math.Floor(-sy));
}
double[,] x = new double[(int)sy + 1, (int)sx + 1];
double[,] y = new double[(int)sy + 1, (int)sx + 1];
for (int i = 0; i <= sy; i++)
{
for (int j = 0; j <= sx; j++)
{
x[i, j] = j;
y[i, j] = i;
}
}
//define shortest distance from a pixel to the rotated line
var dist2line = y.ArrayMultByConst(cosPhi).SubArrays(x.ArrayMultByConst(sinPhi));
var rad = x.PowArrayElements(2).SumArrays(y.PowArrayElements(2)).SqrtArrayElements();
//find points beyond the line's end-point but within the line width
var tempGreater = rad.MarkGreaterEqual(half, BabaYaga.logic);
var tempLess = dist2line.AbsArrayElements().MarkLessEqual(linewdt, BabaYaga.logic);
tempGreater = tempGreater.ArrayMultElements(tempLess);
List <int> lastpix = new List <int>();
var lastPixVector = d.ArrayToVectorColByCol(tempGreater);
for (int i = 0; i < lastPixVector.Count(); i++)
{
if (lastPixVector[i] != 0)
{
lastpix.Add(i);
}
}
//distance to the line's end-point parallel to the line
//transform into vectors, for more convenient process (for me naturally :D)
var xVector = d.ArrayToVectorColByCol(x);
var dist2lineVector = d.ArrayToVectorColByCol(dist2line);
List <double> x2lastpix = new List <double>();
for (int i = 0; i < lastpix.Count; i++)
{
x2lastpix.Add(half - Math.Abs((xVector[lastpix[i]] + dist2lineVector[lastpix[i]] * sinPhi) / cosPhi));
dist2lineVector[lastpix[i]] = Math.Sqrt(Math.Pow(dist2lineVector[lastpix[i]], 2) + Math.Pow(x2lastpix[i], 2));
}
for (int i = 0; i < dist2lineVector.Length; i++)
{
dist2lineVector[i] = linewdt + eps - Math.Abs(dist2lineVector[i]);
if (dist2lineVector[i] < 0)
{
dist2lineVector[i] = 0; //zero out anything beyond line width
}
}
//back to 2D
dist2line = d.VecorToArrayColbyCol(dist2line.GetLength(0), dist2line.GetLength(1), dist2lineVector);
//unfold half - matrix to the full size
result = new double[dist2line.GetLength(0) * 2 - 1, dist2line.GetLength(1) * 2 - 1];
var temp = Rotate90.RotateArray90(dist2line, 2);
var reverse = d.VecorToArrayRowByRow(temp.GetLength(0), temp.GetLength(1), temp.Cast <double>().Reverse().ToArray());
for (int i = 0; i < temp.GetLength(0); i++)
{
for (int j = 0; j < temp.GetLength(1); j++)
{
result[i, j] = temp[i, j];
}
}
for (int i = 0; i < reverse.GetLength(0); i++)
{
for (int j = 0; j < reverse.GetLength(1); j++)
{
result[i + reverse.GetLength(0) - 1, j + reverse.GetLength(1) - 1] = reverse[i, j];
}
}
result = result.ArrayDivByConst(result.Cast <double>().Sum() + eps * len * len);
if (cosPhi > 0)
{
result = d.FlipArray(result);
}
}
else
{
Console.WriteLine("Len must be positive integer value, greater than 1. Method: FSpecial.Motion(). Return black rectangle.");
}
return(result);
}
