public List <Data.Point> getSolution() { List <Data.Point> result = new List <Data.Point>(); /* double maxGradient = -255; * double minGradient = 255; * * for (int i = 0; i < swingSharpness.GetLength(0); i++) * for (int j = 0; j < swingSharpness.GetLength(1); j++) * { * if (maxGradient < swingSharpness[i, j]) maxGradient = swingSharpness[i, j]; * if (minGradient > swingSharpness[i, j]) minGradient = swingSharpness[i, j]; * } */ double maxGradient = swingSharpness.Cast <double>().Max(); double minGradient = swingSharpness.Cast <double>().Min(); double delta = matematical.getDeltaThreshold(); double threshold = minGradient + ((maxGradient - minGradient) * delta); for (int x = 0; x < swingSharpness.GetLength(0); x++) { for (int y = 0; y < swingSharpness.GetLength(1); y++) { if (swingSharpness[x, y] >= threshold) { result.Add(new Data.Point(x, y)); } } } return(result); }
public override void SetMatrixForPlotting(double[,] newMat, string[] WontBeUsed = null, string[] WontBeUsed2 = null) { double min = newMat.Cast <double>().Min(); double max = newMat.Cast <double>().Max(); CreateNewMat(min, max); }
public unsafe static Bitmap DensityGraph(double[,] data, int maxCores, ref Bitmap image, bool greyscale = false, double rangeHigh = 0, double rangeLow = 0) { int num = Environment.ProcessorCount; if (maxCores < 1 || maxCores >= num) { num = Environment.ProcessorCount; } else { num = maxCores; } Bitmap imgBuffer = (Bitmap)image.Clone(); BitmapData bitmapData = imgBuffer.LockBits(new Rectangle(0, 0, imgBuffer.Width, imgBuffer.Height), ImageLockMode.ReadWrite, imgBuffer.PixelFormat); int bytesPerPixel = Bitmap.GetPixelFormatSize(imgBuffer.PixelFormat) / 8; int heightInPixels = bitmapData.Height; int widthInBytes = bitmapData.Width * bytesPerPixel; byte * PtrFirstPixel = (byte *)bitmapData.Scan0; bool isAutoscale = rangeHigh - rangeLow == 0; double maxValue = isAutoscale ? data.Cast <double>().Max() : rangeHigh; double minValue = isAutoscale ? data.Cast <double>().Min() : rangeLow; Parallel.For(0, heightInPixels, new ParallelOptions() { MaxDegreeOfParallelism = num }, y => { byte *currentLine = PtrFirstPixel + (y * bitmapData.Stride); int red; int green; int blue; double h, s, v; for (int x = 0; x < bitmapData.Width; x++) { double value = Math.Min(maxValue, data[y, x]); value = Math.Max(minValue, data[y, x]); value = maxValue - minValue == 0 ? 0 : (value - minValue) / (maxValue - minValue); h = greyscale ? 0 : 360.0 * value; s = greyscale ? 0 : 1; v = greyscale ? value : 1; HsvToRgb(h, s, v, out red, out green, out blue); currentLine[x * bytesPerPixel] = (byte)red; currentLine[x * bytesPerPixel + 1] = (byte)green; currentLine[x * bytesPerPixel + 2] = (byte)blue; } }); imgBuffer.UnlockBits(bitmapData); return(imgBuffer); }
private static bool isParametersChanged( double sigma, double T, double kappa, double B, double risk_free, double credit_spread, double stock_growth, double[,] couponInfoMatrix, double[,] callInfoMatrix, double[,] putInfoMatrix) { if (_sigma != sigma || _T != T || _kappa != kappa || _B != B || _risk_free != risk_free || _credit_spread != credit_spread || _stock_growth != stock_growth || _couponInfoMatrix.Length != couponInfoMatrix.Length || _callInfoMatrix.Length != callInfoMatrix.Length || _putInfoMatrix.Length != putInfoMatrix.Length) { return(true); } if (!couponInfoMatrix.Cast <double>().SequenceEqual(_couponInfoMatrix.Cast <double>()) || !callInfoMatrix.Cast <double>().SequenceEqual(_callInfoMatrix.Cast <double>()) || !putInfoMatrix.Cast <double>().SequenceEqual(_putInfoMatrix.Cast <double>())) { return(true); } return(false); }
private void ShowResultText() { //string precision = ""; //string recall = ""; //double acc = ((double)RealNum / (double)TotalNum) * 100; int sum = (int)confusionMatrix.Cast <double>().Sum(); int correctSum = 0; for (int j = 0; j < confusionMatrix.GetLength(1); j++) { for (int i = 0; i < confusionMatrix.GetLength(0); i++) { if (i == j) { correctSum += (int)confusionMatrix[i, j]; } } } double acc = (double)correctSum / (double)sum * 100; ResultText_TB.Text = "Total : " + sum.ToString() + " / Acc : " + string.Format("{0:0.00}", acc); }
public static KMeansClusteringSolution CreateKMeansSolution(IClusteringProblemData problemData, int k, int restarts) { var dataset = problemData.Dataset; IEnumerable <string> allowedInputVariables = problemData.AllowedInputVariables; IEnumerable <int> rows = problemData.TrainingIndices; int info; double[,] centers; int[] xyc; double[,] inputMatrix = AlglibUtil.PrepareInputMatrix(dataset, allowedInputVariables, rows); if (inputMatrix.Cast <double>().Any(x => double.IsNaN(x) || double.IsInfinity(x))) { throw new NotSupportedException("k-Means clustering does not support NaN or infinity values in the input dataset."); } alglib.kmeansgenerate(inputMatrix, inputMatrix.GetLength(0), inputMatrix.GetLength(1), k, restarts + 1, out info, out centers, out xyc); if (info != 1) { throw new ArgumentException("Error in calculation of k-Means clustering solution"); } KMeansClusteringSolution solution = new KMeansClusteringSolution(new KMeansClusteringModel(centers, allowedInputVariables), (IClusteringProblemData)problemData.Clone()); return(solution); }
public Matrix(double[,] matrix, bool rowMajor = true) { // NOTE copies elements if (rowMajor) { rows = matrix.GetLength(0); cols = matrix.GetLength(1); mat = matrix.Cast <double>().ToArray(); } // column-major else { rows = matrix.GetLength(1); cols = matrix.GetLength(0); mat = new double[rows * cols]; for (int row = 0; row < rows; row++) { for (int col = 0; col < cols; col++) { this[row, col] = matrix[matrix.GetLowerBound(0) + col, matrix.GetLowerBound(1) + row]; } } } }
public static double[,] SwapMatrixRows(double[,] source, int row, int size, out int swaps) { var list = new List <List <double> >(); var flatMatrix = source.Cast <double>(); for (var i = 0; i < size; i++) { var matrixRow = flatMatrix.Skip(i * size).Take(size).ToList(); list.Add(matrixRow); } for (var i = 1; i < size - row; i++) { if (list[row + i][row + i] != 0) { swaps = row + i; var listRow = list[row]; list.RemoveAt(row); list.Insert(row + i, listRow); return(list.To2DArray()); } } throw new InfiniteSystemSolutionsException(); }
public static double[,] ThresholdFilter(double[,] original, double threshold) { var width = original.GetLength(0); var height = original.GetLength(1); if (threshold < 0 || threshold > 1) { return(new double[width, height]); } var res = new double[width, height]; var whitePixels = (int)(threshold * original.Length); var tmp = original.Cast <double>().OrderByDescending(x => x).ToList(); var bright = tmp.FirstOrDefault(y => (whitePixels <= tmp.Count(z => z > y))); for (var i = 0; i < width; i++) { for (var j = 0; j < height; j++) { res[i, j] = original[i, j] > bright ? 1 : 0; } } return(res); }
public double[] QueryBack(double[,] xTargets) { //BACK QUERY NEURAL NETWORK double[,] finalOutputs = Transpose(xTargets); double[,] finalInputs = LogitFunction(finalOutputs); //CALCULATE THE SIGNAL OUT OF THE HIDDEN LAYER double[,] hiddenOutputs = Multiply(Transpose(weightOutput), finalInputs); hiddenOutputs = Subtract(hiddenOutputs, MatrixMinimum(hiddenOutputs)); hiddenOutputs = Division(hiddenOutputs, MatrixMaximum(hiddenOutputs)); hiddenOutputs = Multiply(0.98, hiddenOutputs); hiddenOutputs = Addition(0.01, hiddenOutputs); //CALCULATE THE SIGNAL INTO THE HIDEEN LAYER double[,] hiddenInputs = LogitFunction(hiddenOutputs); //CALCULATE THE SIGNAL OUT OF THE INPUT LAYER double[,] inputs = Multiply(Transpose(weightInput), hiddenInputs); inputs = Subtract(inputs, MatrixMinimum(inputs)); inputs = Division(inputs, MatrixMaximum(inputs)); inputs = Multiply(0.98, inputs); inputs = Addition(0.01, inputs); return(inputs.Cast <double>().ToArray()); }
static void LinqLoop() { if (!data.Cast <double>().Any(d => double.IsNaN(d) || double.IsInfinity(d))) { Console.WriteLine("FOUND!"); } }
public static double[,] ThresholdFilter(double[,] original, double whitePixelsFraction) { var n = original.GetLength(0) * original.GetLength(1); var amountOfWhitePixels = (int)(whitePixelsFraction * n); var pixels = original.Cast <double>().ToList(); pixels.Sort(); var newMass = pixels.ToArray(); var middleCell = 1.0; if (amountOfWhitePixels > 0) { middleCell = newMass[n - amountOfWhitePixels]; } for (var i = n - 1 - amountOfWhitePixels; i >= 0; i--) { if (newMass[i] == middleCell && amountOfWhitePixels > 0 && amountOfWhitePixels < n) { amountOfWhitePixels++; } } for (var i = n - 1 - amountOfWhitePixels; i >= 0; i--) { WhiteCicle(original, newMass[i], false); } for (var i = n - 1; i >= n - amountOfWhitePixels; i--) { WhiteCicle(original, newMass[i], true); } return(original); }
private static void AssertInputMatrix(double[,] inputMatrix) { if (inputMatrix.Cast <double>().Any(x => Double.IsNaN(x) || Double.IsInfinity(x))) { throw new NotSupportedException("Random forest modeling does not support NaN or infinity values in the input dataset."); } }
// Determinant of matrixA private void determinantA_Click(object sender, EventArgs e) { res = new Result(); if (combo1[0].Text == combo1[1].Text && combo1[0].Text != "" && combo1[1].Text != "") { matrixA = matrix.FillMatrix(textBoxes1, int.Parse(combo1[0].Text), int.Parse(combo1[1].Text)); double determinant = matrix.Determinant(matrixA, int.Parse(combo1[0].Text), int.Parse(combo1[1].Text)); double[] temp = matrixA.Cast <double>().ToArray(); WriteLabel("Deter:", res); int x = 20, y = 55; int count1 = 0; for (int i = 0; i < int.Parse(combo1[0].Text) * int.Parse(combo1[1].Text); i++) { if (count1 == int.Parse(combo1[1].Text)) { count1 = 0; x = 20; y += 25; } textBoxes1.Add(CreateTextBoxes(x, y, res, temp[i].ToString())); x += 40; count1++; } Label lab = new Label(); lab.Text = "Determinant of matrixA: "; lab.Location = new Point(20, 270); lab.Size = new Size(200, 50); lab.Font = new Font("Tobota", 10, FontStyle.Bold); res.Controls.Add(lab); TextBox tex = new TextBox(); tex.Top = 270; tex.Left = 230; tex.Width = 60; tex.TextAlign = HorizontalAlignment.Center; tex.Text = determinant.ToString(); res.Controls.Add(tex); res.Show(); } else if (combo1[0].Text == "" && combo1[1].Text == "" || combo1[0].Text == "" || combo1[1].Text == "") { MessageBox.Show("The number of rows and columns in matrixA is not specified!"); } else if (combo1[0].Text != combo1[1].Text) { MessageBox.Show("The matrix must be square!"); } }
public Graph(double[,] adjacencyTable, bool isDirected) { adjacencyTable.GetLength(0).Should().Be(adjacencyTable.GetLength(1)); _adjacencyTable = adjacencyTable; IsDirected = isDirected; NumberOfVertices = adjacencyTable.GetLength(0); NumberOfEdges = adjacencyTable.Cast <double>().Count(edgeDistance => !double.IsPositiveInfinity(edgeDistance)); }
public static IClassificationSolution CreateLinearDiscriminantAnalysisSolution(IClassificationProblemData problemData) { var dataset = problemData.Dataset; string targetVariable = problemData.TargetVariable; IEnumerable <string> allowedInputVariables = problemData.AllowedInputVariables; IEnumerable <int> rows = problemData.TrainingIndices; int nClasses = problemData.ClassNames.Count(); double[,] inputMatrix = AlglibUtil.PrepareInputMatrix(dataset, allowedInputVariables.Concat(new string[] { targetVariable }), rows); if (inputMatrix.Cast <double>().Any(x => double.IsNaN(x) || double.IsInfinity(x))) { throw new NotSupportedException("Linear discriminant analysis does not support NaN or infinity values in the input dataset."); } // change class values into class index int targetVariableColumn = inputMatrix.GetLength(1) - 1; List <double> classValues = problemData.ClassValues.OrderBy(x => x).ToList(); for (int row = 0; row < inputMatrix.GetLength(0); row++) { inputMatrix[row, targetVariableColumn] = classValues.IndexOf(inputMatrix[row, targetVariableColumn]); } int info; double[] w; alglib.fisherlda(inputMatrix, inputMatrix.GetLength(0), allowedInputVariables.Count(), nClasses, out info, out w); if (info < 1) { throw new ArgumentException("Error in calculation of linear discriminant analysis solution"); } ISymbolicExpressionTree tree = new SymbolicExpressionTree(new ProgramRootSymbol().CreateTreeNode()); ISymbolicExpressionTreeNode startNode = new StartSymbol().CreateTreeNode(); tree.Root.AddSubtree(startNode); ISymbolicExpressionTreeNode addition = new Addition().CreateTreeNode(); startNode.AddSubtree(addition); int col = 0; foreach (string column in allowedInputVariables) { VariableTreeNode vNode = (VariableTreeNode) new HeuristicLab.Problems.DataAnalysis.Symbolic.Variable().CreateTreeNode(); vNode.VariableName = column; vNode.Weight = w[col]; addition.AddSubtree(vNode); col++; } var model = LinearDiscriminantAnalysis.CreateDiscriminantFunctionModel(tree, new SymbolicDataAnalysisExpressionTreeInterpreter(), problemData, rows); SymbolicDiscriminantFunctionClassificationSolution solution = new SymbolicDiscriminantFunctionClassificationSolution(model, (IClassificationProblemData)problemData.Clone()); return(solution); }
private void calcularValores() { int rows = matrix.GetLength(0); int columns = matrix.GetLength(1); for (int a = 0; a < 100; a++) { for (int i = 0; i < rows; i++) { for (int j = 0; j < columns; j++) { matrix[i, j] = ((((i == 0) ? fN : matrix[i - 1, j]) + ((j == 0) ? fO : matrix[i, j - 1]) + ((i == rows - 1) ? fS : matrix[i + 1, j]) + ((j == columns - 1) ? fE : matrix[i, j + 1])) / 4) + cMatrix[i, j]; } } } mostrarGrid(); min = matrix.Cast <double>().Min(); max = matrix.Cast <double>().Max(); double valor = max / 9; foreach (DataGridViewRow r in grid.Rows) { for (int i = 0; i < r.Cells.Count; i++) { double val = Convert.ToDouble(r.Cells[i].Value); r.Cells[i].Style.BackColor = (val > valor) ? ((val > valor * 2) ? ((val > valor * 3) ? ((val > valor * 4) ? ((val > valor * 5) ? ((val > valor * 6) ? ((val > valor * 7) ? ((val > valor * 8) ? c9 : c8) : c7) : c6) : c5) : c4) : c3) : c2) : c1; r.Cells[i].Style.ForeColor = (r.Cells[i].Style.BackColor == c4) ? Color.Black : Color.White; } } grid.Invalidate(); }
// Get Fractal Data public int[,] GetData() { int[,] map = new int[size, size]; double[,] data = DiamondSquareAlgorithm(); double max = data.Cast <double>().Max(); double min = data.Cast <double>().Min(); for (int x = 0; x < size - 1; x++) { for (int y = 0; y < size - 1; y++) { double n = data[x, y]; n += roughness / 100 - 1 + Math.Abs(min) / 100; map[x, y] = (int)n; } } return(map); }
public void ExponentiateMatrixTest_ReturnMultiplicateMatrix() { double[,] matrix = { { 1, 1, 1 }, { 0, 0, 1 }, { 0, 0, 1 } }; double[,] expectedMatrix = { { 1, 1, 3 }, { 0, 0, 1 }, { 0, 0, 1 } }; var actualMatrix = FoxMath.ExponentiateMatrix(matrix); bool equal = actualMatrix.Rank == expectedMatrix.Rank && Enumerable.Range(0, actualMatrix.Rank).All(dimension => actualMatrix.GetLength(dimension) == expectedMatrix.GetLength(dimension)) && actualMatrix.Cast <double>().SequenceEqual(expectedMatrix.Cast <double>()); Assert.AreEqual(equal, true); }
private static double CalcThresholdValue(double[,] original, double whitePixelsFraction) { var picWidth = original.GetLength(0); var picHeight = original.GetLength(1); var pixelsCount = picWidth * picHeight; var whitePixelsCount = (int)(pixelsCount * whitePixelsFraction); return(whitePixelsCount > 0 ? original.Cast <double>().OrderByDescending(x => x).ElementAt(whitePixelsCount - 1) : Double.MaxValue); }
/// <summary> /// Определение границ сингулярности изображения /// </summary> /// <param name="image">Анализируемое изображение</param> /// <param name="converterType">Тип конвертера</param> /// <returns>Интервал сингулярностей изображения</returns> internal Interval GetSingularityBounds(DirectBitmap image, ConverterType converterType) { Intensivities = new double[image.Width, image.Height]; CalculateIntensivities(image, converterType); CalculateDensity(); var densityValues = Densities.Cast <double>(); return(new Interval(densityValues.Min(), densityValues.Max())); }
private static double FindThresholdValue(double[,] original, double whitePixelsFraction) { var pixelsList = original.Cast <double>().ToList(); pixelsList.Sort(); var whitePixelsCount = (int)(whitePixelsFraction * pixelsList.Count); return(whitePixelsCount == 0 ? pixelsList.Last() + 1: pixelsList[pixelsList.Count - whitePixelsCount]); }
private static void DodecFace(int a, int b, int c, int d, int e, PrimitiveType shadeType) { double[] n0 = new double[3], d1 = new double[3], d2 = new double[3]; Diff3(_dodec.Cast <double>().Skip(19 * a).Take(3).ToArray(), _dodec.Cast <double>().Skip(19 * b).Take(3).ToArray(), ref d1); Diff3(_dodec.Cast <double>().Skip(19 * b).Take(3).ToArray(), _dodec.Cast <double>().Skip(19 * c).Take(3).ToArray(), ref d2); Crossprod(d1, d2, ref n0); Normalize(n0); GL.Begin(shadeType); GL.Normal3(n0[0], n0[1], n0[2]); GL.Vertex3(_dodec[a, 0], _dodec[a, 1], _dodec[a, 2]); GL.Vertex3(_dodec[b, 0], _dodec[b, 1], _dodec[b, 2]); GL.Vertex3(_dodec[c, 0], _dodec[c, 1], _dodec[c, 2]); GL.Vertex3(_dodec[d, 0], _dodec[d, 1], _dodec[d, 2]); GL.Vertex3(_dodec[e, 0], _dodec[e, 1], _dodec[e, 2]); GL.End(); }
public void EstimateGmm() { IDataset dataset = new BasicTextDataset(mz, data, coordinates: null); var result = _gmm.EstimateGmm(dataset); Console.WriteLine(result); // Assert Assert.Multiple(testDelegate: () => { Assert.IsNotNull(result); Assert.True(condition: data.Cast <double>() .Take(count: data.GetLength(dimension: 1)) .SequenceEqual(result.OriginalMeanSpectrum)); Assert.True(condition: mz.SequenceEqual(result.OriginalMz)); Assert.False(result.IsMerged); Assert.False(result.IsNoiseReduced); Assert.Null(result.MzMergingThreshold); }); }
public static IClassificationSolution CreateLogitClassificationSolution(IClassificationProblemData problemData, out double rmsError, out double relClassError) { var dataset = problemData.Dataset; string targetVariable = problemData.TargetVariable; var doubleVariableNames = problemData.AllowedInputVariables.Where(dataset.VariableHasType <double>); var factorVariableNames = problemData.AllowedInputVariables.Where(dataset.VariableHasType <string>); IEnumerable <int> rows = problemData.TrainingIndices; double[,] inputMatrix = dataset.ToArray(doubleVariableNames.Concat(new string[] { targetVariable }), rows); var factorVariableValues = dataset.GetFactorVariableValues(factorVariableNames, rows); var factorMatrix = dataset.ToArray(factorVariableValues, rows); inputMatrix = factorMatrix.HorzCat(inputMatrix); if (inputMatrix.Cast <double>().Any(x => double.IsNaN(x) || double.IsInfinity(x))) { throw new NotSupportedException("Multinomial logit classification does not support NaN or infinity values in the input dataset."); } alglib.logitmodel lm = new alglib.logitmodel(); alglib.mnlreport rep = new alglib.mnlreport(); int nRows = inputMatrix.GetLength(0); int nFeatures = inputMatrix.GetLength(1) - 1; double[] classValues = dataset.GetDoubleValues(targetVariable).Distinct().OrderBy(x => x).ToArray(); int nClasses = classValues.Count(); // map original class values to values [0..nClasses-1] Dictionary <double, double> classIndices = new Dictionary <double, double>(); for (int i = 0; i < nClasses; i++) { classIndices[classValues[i]] = i; } for (int row = 0; row < nRows; row++) { inputMatrix[row, nFeatures] = classIndices[inputMatrix[row, nFeatures]]; } int info; alglib.mnltrainh(inputMatrix, nRows, nFeatures, nClasses, out info, out lm, out rep); if (info != 1) { throw new ArgumentException("Error in calculation of logit classification solution"); } rmsError = alglib.mnlrmserror(lm, inputMatrix, nRows); relClassError = alglib.mnlrelclserror(lm, inputMatrix, nRows); MultinomialLogitClassificationSolution solution = new MultinomialLogitClassificationSolution(new MultinomialLogitModel(lm, targetVariable, doubleVariableNames, factorVariableValues, classValues), (IClassificationProblemData)problemData.Clone()); return(solution); }
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); }
/// <summary> /// Converts double[,] array into 8 bit grayscale image. If <paramref name="image"/> is <see cref="WriteableBitmap"/> values are updated directly in the /// image else values are set in the new image which is then returned (since original cannot be modified) /// </summary> /// <param name="image"></param> /// <param name="data"></param> /// <returns>Either new image (if source is not writable) or source image with updated vales</returns> public static BitmapSource FromDouble2D(this BitmapSource image, double[,] data) { int rows = data.GetLength(0); int cols = data.GetLength(1); WriteableBitmap result = null; if (image is WriteableBitmap) { result = image as WriteableBitmap; } else { result = new WriteableBitmap(cols, rows, 96, 96, PixelFormats.Gray8, BitmapPalettes.Gray256); } // Find min max of source data, used later for scaling double srcMin = data.Cast <double>().Min(); double srcMax = data.Cast <double>().Max(); // Init temp array of pixel values, later to be written into destination image byte[] pixels = new byte[rows * cols]; // Compute pixel values for (int row = 0; row < rows; row++) { for (int col = 0; col < cols; col++) { pixels[row * cols + col] = (byte)Scale(data[row, col], srcMin, srcMax, 0, 255); } } // Copy pixels to image Int32Rect roi = new Int32Rect(0, 0, cols, rows); result.WritePixels(roi, pixels, cols, 0); return(result); }
public void IndexesOfMin(out int i, out int j) { double min = arr.Cast <double>().Min(); int resultI = 0; int resultJ = 0; for (int _i = 0; _i < rows; _i++) { for (int _j = 0; _j < colls; _j++) { if (arr[_i, _j] == min) { resultI = _i; resultJ = _j; } } } i = resultI; j = resultJ; }
public static bool HasInvalidData(this double[,] mat) { //for (int i = 0; i < mat.Count; i++) //{ // for (int j = 0; j < lists[i].Count; j++) // { // exData[j, i] = lists[i][j]; // } //} var flattened = mat.Cast <double>().ToArray(); return(flattened.HasInvalidData()); }
public void DoWork() { _topo = LoadTopoFromFile(_fileName); var a = _topo.SelectMany(x => x).ToList(); _topoMin = a.Min(); _topoMax = a.Max(); _newTopo = NewTopo(_topo); var b = _newTopo.Cast <double>().ToList(); MinValue = b.Min(); MaxValue = b.Max(); }