//----------------------------------------------------------------------------------------------- //Приведение значений матрицы к интервалу public static IntegerMatrix TransformMatrixValuesToFinishIntervalValues( IntegerMatrix matrix, Interval <double> finishInterval ) { double minValue = matrix.GetMinValue(); double maxValue = matrix.GetMaxValue(); Interval <double> startInterval = new Interval <double>(minValue, maxValue); RealIntervalTransform intervalTransform = new RealIntervalTransform(startInterval, finishInterval); int rowCount = matrix.RowCount; int columnCount = matrix.ColumnCount; IntegerMatrix transformedMatrix = new IntegerMatrix(rowCount, columnCount); for (int row = 0; row < rowCount; row++) { for (int column = 0; column < columnCount; column++) { double value = matrix[row, column]; double transformedValue = intervalTransform.TransformToFinishIntervalValue(value); transformedMatrix[row, column] = Convert.ToInt32(transformedValue); } } return(transformedMatrix); }
public static IntegerMatrix CreateIntegerMatrix(this REngine engine, Raster raster) { if (engine == null) { throw new ArgumentNullException("engine"); } if (!engine.IsRunning) { throw new InvalidOperationException(); } if (raster == null) { throw new ArgumentNullException("raster"); } var width = raster.Width; var height = raster.Height; var matrix = new IntegerMatrix(engine, height, width); for (var x = 0; x < width; x++) { for (var y = 0; y < height; y++) { matrix[x, y] = ToInteger(raster[x, y]); } } return(matrix); }
public static IntegerMatrix CreateIntegerMatrix(this REngine engine, Raster raster) { if (engine == null) { throw new ArgumentNullException("engine"); } if (!engine.IsRunning) { throw new InvalidOperationException(); } if (raster == null) { throw new ArgumentNullException("raster"); } var width = raster.Width; var height = raster.Height; var matrix = new IntegerMatrix(engine, height, width); for (var x = 0; x < width; x++) { for (var y = 0; y < height; y++) { matrix[x, y] = ToInteger(raster[x, y]); } } return matrix; }
//------------------------------------------------------------------------------------------------- //Ортогональный вектор public IntegerVector GetOrthogonalVector() { IntegerMatrix transformatingMatrix = this.CreateOrthogonalVectorTransformingMatrix(this.Size); IntegerVector orthogonalVector = transformatingMatrix * this; return(orthogonalVector); }
//----------------------------------------------------------------------------------------------- //Преобразование значений матрицы по шаблону public static IntegerMatrix TransformMatrixValues( IntegerMatrix matrix, BitMask2D stencilMatrix, RealIntervalTransform intervalTransform, int prickedValue ) { int rowCount = matrix.RowCount; int columnCount = matrix.ColumnCount; IntegerMatrix transformedMatrix = new IntegerMatrix(rowCount, columnCount); for (int row = 0; row < rowCount; row++) { for (int column = 0; column < columnCount; column++) { if (stencilMatrix[row, column] == true) { double value = matrix[row, column]; double transformedValue = intervalTransform.TransformToFinishIntervalValue(value); transformedMatrix[row, column] = Convert.ToInt32(transformedValue); } else { transformedMatrix[row, column] = prickedValue; } } } return(transformedMatrix); }
//------------------------------------------------------------------------------------------------ //Создание изображения из матриц R G B public static WriteableBitmap CreateWriteableBitmapFromMatricesRGB( IntegerMatrix redMatrix, IntegerMatrix greenMatrix, IntegerMatrix blueMatrix, int dpiX, int dpiY ) { int width = redMatrix.ColumnCount; int height = redMatrix.RowCount; PixelFormat pixelFormat = PixelFormats.Bgra32; WriteableBitmap newImage = WriteableBitmapCreator.CreateWriteableBitmap (width, height, dpiX, dpiY, pixelFormat); WriteableBitmapWrapper wrapper = WriteableBitmapWrapper.Create(newImage); byte[] pixelBytes = new byte[4 * width * height]; //BGRA int pixelByteIndex = 0; for (int y = 0; y < newImage.PixelHeight; y++) { for (int x = 0; x < newImage.PixelWidth; x++) { pixelBytes[pixelByteIndex++] = Convert.ToByte(blueMatrix[y, x]); pixelBytes[pixelByteIndex++] = Convert.ToByte(greenMatrix[y, x]); pixelBytes[pixelByteIndex++] = Convert.ToByte(redMatrix[y, x]); pixelBytes[pixelByteIndex++] = byte.MaxValue; } } wrapper.WritePixels(pixelBytes); return(newImage); }
public static void CreateFromFile(string expr, List <Exception> exceptionsList, SortedList <string, Graph> graphsList, RichTextBox output) { try { int startIndex = expr.IndexOf("\"") + 1; int endIndex = expr.IndexOf("\")"); string path = expr.Substring(startIndex, endIndex - startIndex); string name = expr.Contains(":=") ? expr.Substring(0, expr.IndexOf(":=")) : ""; var graphMatrix = new IntegerSquareMatrix(IntegerMatrix.GetFromFile(path)); if (graphMatrix.Columns == 0) { exceptionsList.Add(new FormatException("Incorrect matrix size in file")); } var graph = new Graph(graphMatrix, name); graphsList.Add(name, graph); output.Text = graph.ToString(); } catch (Exception e) { exceptionsList.Add(e); output.Text += e.Message; } }
public void Integer_Matrix_Construction_Size_Test() { //Arrange int row = rand.Next(1, 10); int col = rand.Next(1, 10); IntegerMatrix m1 = new IntegerMatrix(row, col); //Act //Assert Assert.AreEqual(m1.RowSize, row); Assert.AreEqual(m1.ColumnSize, col); }
public void Integer_Matrix_Value_Change_Test() { //Arrange int row = rand.Next(1, 10); int col = rand.Next(1, 10); int rowIndex = rand.Next(1, row - 1); int colIndex = rand.Next(1, col - 1); IntegerMatrix m1 = new IntegerMatrix(row, col); //Act m1.Replace(rowIndex, colIndex, 5); //value doesnt matter just cant be zero //Assert Assert.AreEqual(m1.Get(rowIndex, colIndex), 5); }
//--------------------------------------------------------------------------------------- //Преобразвание значений матрицы public static IntegerMatrix TransformMatrixValues(IntegerMatrix matrix, LogTransform logTransform) { IntegerMatrix newMatrix = new IntegerMatrix(matrix.RowCount, matrix.ColumnCount); for (int row = 0; row < matrix.RowCount; row++) { for (int column = 0; column < matrix.ColumnCount; column++) { double newValue = logTransform.GetLogTransform(matrix[row, column]); newMatrix[row, column] = Convert.ToInt32(newValue); } } return(newMatrix); }
public void Matrix_Transpose_Test() { //Arrange IntegerMatrix m1 = GenerateRandomIntegerMatrix(); IntegerMatrix m2 = (IntegerMatrix)m1.GetTranspose(); for (int i = 0; i < m1.RowSize; i++) { for (int j = 0; j < m1.ColumnSize; j++) { Assert.AreEqual(m1.Get(i, j), m2.Get(j, i)); } } }
private Random rand = new Random(); //TODO: Figure out whether to keep the same seed every time or not. public IntegerMatrix GenerateRandomIntegerMatrix() { int row = rand.Next(1, 10); int col = rand.Next(1, 10); IntegerMatrix ret = new IntegerMatrix(row, col); for (int i = 0; i < row; i++) { for (int j = 0; j < col; j++) { ret.Replace(i, j, rand.Next(9, 255)); } } return(ret); }
public static IntegerMatrix GetRedMatrix(IntegerMatrix scanDataMatrix) { IntegerMatrix resMatrix = new IntegerMatrix(scanDataMatrix.RowCount, scanDataMatrix.ColumnCount); for (int row = 0; row < scanDataMatrix.RowCount; row++) { for (int column = 0; column < scanDataMatrix.ColumnCount; column++) { ComponentEnum component = BayerMatrixHelper.GetComponent(row, column); if (component == ComponentEnum.Red) { resMatrix[row, column] = scanDataMatrix[row, column]; } if (component == ComponentEnum.Green1) { ComponentLocationEnum[] locations = new ComponentLocationEnum[] { ComponentLocationEnum.West, ComponentLocationEnum.East }; resMatrix[row, column] = InterpolateValue(scanDataMatrix, row, column, locations); } if (component == ComponentEnum.Green2) { ComponentLocationEnum[] locations = new ComponentLocationEnum[] { ComponentLocationEnum.Nord, ComponentLocationEnum.South }; resMatrix[row, column] = InterpolateValue(scanDataMatrix, row, column, locations); } if (component == ComponentEnum.Blue) { ComponentLocationEnum[] locations = new ComponentLocationEnum[] { ComponentLocationEnum.NordWest, ComponentLocationEnum.NordEast, ComponentLocationEnum.SouthWest, ComponentLocationEnum.SouthEast }; resMatrix[row, column] = InterpolateValue(scanDataMatrix, row, column, locations); } } } return(resMatrix); }
public void Row_Append_Test() { //Arrange IntegerMatrix m1 = GenerateRandomIntegerMatrix(); int col = rand.Next(1, 10); IntegerMatrix m2 = new IntegerMatrix(m1.RowSize, col); //Act IntegerMatrix m3 = (IntegerMatrix)m1.AppendByRow(m2); //Assert for (int i = 0; i < m1.RowSize; i++) { for (int j = m1.ColumnSize; j < m3.ColumnSize; j++) { Assert.AreEqual(m3.Get(i, j), 0); } } }
public void Column_Append_Test() { //Arrange IntegerMatrix m1 = GenerateRandomIntegerMatrix(); int row = rand.Next(1, 10); IntegerMatrix m2 = new IntegerMatrix(row, m1.ColumnSize); //Act IntegerMatrix m3 = (IntegerMatrix)m1.AppendByColumn(m2); //Assert for (int i = m1.RowSize; i < m3.RowSize; i++) { for (int j = 0; j < m1.ColumnSize; j++) { Assert.AreEqual(m3.Get(i, j), 0); } } }
public IntegerMatrix Power(IntegerMatrix value, int n) { if (n == 0) { return(value); } if (n % 2 == 0) { var halfValue = Power(value, n / 2); return(halfValue * halfValue); } else { var halfValue = Power(value, n / 2); return(halfValue * halfValue * value); } }
private static int InterpolateValue(IntegerMatrix matrix, int row, int column, ComponentLocationEnum[] locationsArray) { int count = 0; int resValue = 0; double sum = 0; for (int k = 0; k < locationsArray.Length; k++) { int?value = BayerMatrixHelper.GetComponentValue(matrix, row, column, locationsArray[k]); if (value.HasValue) { sum += value.Value; count++; } } resValue = Convert.ToInt32(sum / count); return(resValue); }
//------------------------------------------------------------------------------------- //------------------------------------------------------------------------------------- //Матрица преобразования для вычисления ортогонального вектора private IntegerMatrix CreateOrthogonalVectorTransformingMatrix(int size) { IntegerMatrix transformingMatrix = new IntegerMatrix(size, size); for (int column = 1, row = 0; column < size; column++, row++) { transformingMatrix[row, column] = 1; } for (int row = 1, column = 0; row < size; row++, column++) { transformingMatrix[row, column] = -1; } transformingMatrix[size - 1, 0] = 1; transformingMatrix[0, size - 1] = -1; return(transformingMatrix); }
public static void Main(string[] args) { Random rand = new Random(); IntegerMatrix m1 = new IntegerMatrix(2, 3); m1.Replace(1, 1, 5); Console.WriteLine(m1.ToString()); IntegerMatrix m2 = new IntegerMatrix(2, 3); m2.Replace(0, 2, 15); IntegerMatrix m3 = (IntegerMatrix)m1.AppendByRow(m2); IntegerMatrix m4 = (IntegerMatrix)m1.AppendByColumn(m2); Console.WriteLine(m3.ToString()); Console.WriteLine(m4.ToString()); SquareIntegerMatrix sq1 = new SquareIntegerMatrix(3); SquareIntegerMatrix sq2 = new SquareIntegerMatrix(3); for (int i = 0; i < 3; i++) { for (int j = 0; j < 3; j++) { sq1.Replace(i, j, rand.Next(0, 10)); sq2.Replace(i, j, rand.Next(0, 10)); } } Console.WriteLine(sq1.ToString()); Console.WriteLine(sq2.ToString()); SquareIntegerMatrix prod1 = sq1.Multiply(sq2); Console.WriteLine(prod1.ToString()); IntegerMatrix minor1 = prod1.GetMinor(0); IntegerMatrix minor2 = prod1.GetMinor(1); IntegerMatrix minor3 = prod1.GetMinor(2); Console.WriteLine(minor1); Console.WriteLine(minor2); Console.WriteLine(minor3); TestAlgebra(); Console.Read(); }
private void button1_Click(object sender, EventArgs e) { REngine.SetEnvironmentVariables(); REngine cluster = REngine.GetInstance(); cluster.Initialize(); //try //{ cluster.Evaluate("cluster = read.table(file.choose())"); cluster.Evaluate("cluster <- as.matrix(cluster)"); IntegerMatrix clusterinfo = cluster.GetSymbol("cluster").AsIntegerMatrix(); app.cluster = new int[clusterinfo.AsNumericMatrix().ToArray().GetLength(1)]; for (int i = 0; i < app.cluster.Length; i++) { app.cluster[i] = clusterinfo[0, i]; } //foreach (var item in Enumerable.Range(0, clusterinfo.AsNumericMatrix().ToArray().GetLength(0) * clusterinfo.AsNumericMatrix().ToArray().GetLength(1)).Select(i => new { x = i / clusterinfo.AsNumericMatrix().ToArray().GetLength(1), y = i % clusterinfo.AsNumericMatrix().ToArray().GetLength(1) })) //{ // app.cluster[item.x, item.y] = (int)clusterinfo.AsNumericMatrix().ToArray()[item.x, item.y]; //} //} //try //{ // StatConnector factor = new STATCONNECTORSRVLib.StatConnectorClass(); // factor.Init("R"); // factor.EvaluateNoReturn("cluster = read.table(file.choose())"); // factor.Evaluate("cluster <- as.matrix(cluster)"); // object temp = factor.GetSymbol("cluster"); // app.cluster = (int[,])temp; //} //catch { } }
//------------------------------------------------------------------------------------------------ //Создание изображения из матрицы интенсивностей серого public static WriteableBitmap CreateGrayScaleWriteableBitmapFromMatrix( IntegerMatrix grayScaleMatrix, int dpiX, int dpiY ) { int pixelWidth = grayScaleMatrix.ColumnCount; int pixelHeight = grayScaleMatrix.RowCount; WriteableBitmap writeableBitmap = WriteableBitmapCreator.CreateWriteableBitmap (pixelWidth, pixelHeight, dpiX, dpiY, PixelFormats.Bgra32); WriteableBitmapWrapper bitmapWrapper = WriteableBitmapWrapper.Create(writeableBitmap); for (int x = 0; x < pixelWidth; x++) { for (int y = 0; y < pixelHeight; y++) { int grayIntensity = grayScaleMatrix[y, x]; byte red, green, blue; red = green = blue = Convert.ToByte(grayIntensity); Color color = Color.FromRgb(red, green, blue); bitmapWrapper.SetPixelColor(x, y, color); } } return(writeableBitmap); }
/// <summary> /// Аналог GetFromFile в <see cref="IntegerMatrix"/> /// </summary> /// <param name="path"></param> /// <returns></returns> public static Graph GetFromFile(string path) { Arithmetics.Matrix.IntegerSquareMatrix graphMatrix = (IntegerSquareMatrix)IntegerMatrix.GetFromFile(path); if (graphMatrix.Columns == 0) { return(null); } return(new Graph(graphMatrix)); }
private void CreateClick() { OpenFileDialog dialog = new OpenFileDialog(); if (dialog.ShowDialog() == DialogResult.OK) { string path = dialog.FileName; Arithmetics.Matrix.IntegerSquareMatrix graphMatrix = (IntegerSquareMatrix)IntegerMatrix.GetFromFile(path); if (graphMatrix.Columns == 0) { return; } string name = Interaction.InputBox("Введите имя графа", "", ""); if (graphs.ContainsKey(name) == false) { Graph NewGraph = new Graph(graphMatrix); graphs.Add(name, NewGraph); activeGraph = name; richTextBox1.Text = ""; richTextBox1.Text = graphs[activeGraph].ToString(); graphsToolStripMenuItem.DropDownItems.Add(name); DialogResult result = MessageBox.Show("Граф " + name + " успешно добавлен"); } else { DialogResult result = MessageBox.Show("Граф c таким именем уже существует"); } } }
public static int?GetComponentValue( IntegerMatrix matrix, int rowIndex, int columnIndex, ComponentLocationEnum componentLocation ) { int targetRow = 0; int targetColumn = 0; int? resValue = null; bool isCorrect = true; switch (componentLocation) { case ComponentLocationEnum.Nord: { targetRow = rowIndex - 1; targetColumn = columnIndex; isCorrect = targetRow >= 0; break; } case ComponentLocationEnum.East: { targetRow = rowIndex; targetColumn = columnIndex + 1; isCorrect = targetColumn < matrix.ColumnCount; break; } case ComponentLocationEnum.South: { targetRow = rowIndex + 1; targetColumn = columnIndex; isCorrect = targetRow < matrix.RowCount; break; } case ComponentLocationEnum.West: { targetRow = rowIndex; targetColumn = columnIndex - 1; isCorrect = targetColumn >= 0; break; } case ComponentLocationEnum.NordWest: { targetRow = rowIndex - 1; targetColumn = columnIndex - 1; isCorrect = targetRow >= 0 && targetColumn >= 0; break; } case ComponentLocationEnum.NordEast: { targetRow = rowIndex - 1; targetColumn = columnIndex + 1; isCorrect = targetRow >= 0 && targetColumn < matrix.ColumnCount; break; } case ComponentLocationEnum.SouthEast: { targetRow = rowIndex + 1; targetColumn = columnIndex + 1; isCorrect = targetRow < matrix.RowCount && targetColumn < matrix.ColumnCount; break; } case ComponentLocationEnum.SouthWest: { targetRow = rowIndex + 1; targetColumn = columnIndex - 1; isCorrect = targetRow < matrix.RowCount && targetColumn >= 0; break; } } if (isCorrect) { resValue = matrix[targetRow, targetColumn]; } else { resValue = null; } return(resValue); }
//------------------------------------------------------------------------------------------------ //------------------------------------------------------------------------------------------------ /* * //Создание изображения из файла * public static WriteableBitmap CreateWriteableBitmapFromFile( string fileName, double dpiX, double dpiY ) { * System.Drawing.Bitmap bitmap = new System.Drawing.Bitmap( fileName ); * * //System.Windows.Media.PixelFormat targetPixelFormat = PixelFormats.Rgba64; * System.Windows.Media.PixelFormat targetPixelFormat = PixelFormats.Pbgra32; * * WriteableBitmap writeableBitmap = * new WriteableBitmap( bitmap.Width, bitmap.Height, dpiX, dpiY, targetPixelFormat, null ); * * //WriteableBitmap writeableBitmap = * // new WriteableBitmap( bitmap.Width, bitmap.Height, dpiX, dpiY, PixelFormats.Rgba64, null ); * * System.Drawing.Rectangle rect = new System.Drawing.Rectangle( 0, 0, bitmap.Width, bitmap.Height ); * System.Drawing.Imaging.ImageLockMode lockMode = System.Drawing.Imaging.ImageLockMode.ReadOnly; * * System.Drawing.Imaging.PixelFormat pixelFormat = System.Drawing.Imaging.PixelFormat.Format32bppArgb; * //System.Drawing.Imaging.PixelFormat pixelFormat = System.Drawing.Imaging.PixelFormat.Format64bppArgb; * //System.Drawing.Imaging.PixelFormat pixelFormat = System.Drawing.Imaging.PixelFormat.Format16bppGrayScale; * * System.Drawing.Imaging.BitmapData bitmapData = bitmap.LockBits( rect, lockMode, pixelFormat ); * Int32Rect int32Rect = new System.Windows.Int32Rect( 0, 0, bitmapData.Width, bitmapData.Height ); * * writeableBitmap.WritePixels * ( int32Rect, bitmapData.Scan0, bitmapData.Stride * bitmapData.Height, bitmapData.Stride ); * bitmap.UnlockBits( bitmapData ); * bitmap.Dispose(); * * return writeableBitmap; * } */ //------------------------------------------------------------------------------------------------ public static ExtraImageInfo CreateWriteableBitmapFromFile(string fileName, double dpiX, double dpiY) { //public static WriteableBitmap CreateWriteableBitmapFromFile( string fileName, double dpiX, double dpiY ) { /* * if ( fileName.ToUpper().EndsWith( "CR2" ) ) { * * MagickImage magicImage = new MagickImage( fileName ); * * int width = magicImage.Width; * int height = magicImage.Height; * PixelFormat pixelFormat = PixelFormats.Bgra32; * * WriteableBitmap resultWriteableBitmap = * WriteableBitmapCreator.CreateWriteableBitmap( width, height, (int)dpiX, (int)dpiY, pixelFormat ); * WriteableBitmapWrapper imageWrapper = WriteableBitmapWrapper.Create( resultWriteableBitmap ); * * PixelCollection pixelCollection = magicImage.GetPixels(); * * Interval<double> interval1 = new Interval<double>( 0, ushort.MaxValue ); * Interval<double> interval2 = new Interval<double>( 0, byte.MaxValue ); * RealIntervalTransform intervalTransform = new RealIntervalTransform( interval1, interval2 ); * * RealMatrix redMatrix = new RealMatrix( height, width ); * * for ( int x = 0; x < width; x++ ) { * for ( int y = 0; y < height; y++ ) { * Pixel pixel = pixelCollection.GetPixel(x, y); * MagickColor magicColor = pixel.ToColor(); * * redMatrix[ y, x ] = intervalTransform.TransformToFinishIntervalValue(magicColor.R); * * byte a = Convert.ToByte( intervalTransform.TransformToFinishIntervalValue( magicColor.A ) ); * byte r = Convert.ToByte( intervalTransform.TransformToFinishIntervalValue( magicColor.R ) ); * byte g = Convert.ToByte( intervalTransform.TransformToFinishIntervalValue( magicColor.G ) ); * byte b = Convert.ToByte( intervalTransform.TransformToFinishIntervalValue( magicColor.B ) ); * * Color color = Color.FromArgb( a, r, g, b ); * * imageWrapper.SetPixelColor( x, y, color ); * } * } * * ExtraImageInfo extraImageInfo = new ExtraImageInfo(); * extraImageInfo.RedMatrix = redMatrix; * extraImageInfo.Image = resultWriteableBitmap; * * //return resultWriteableBitmap; * return extraImageInfo; * * } */ /* * if ( fileName.ToUpper().EndsWith( "CR2" ) ) { * * * //System.GC.Collect(); * * //BitmapDecoder bitmapDecoder = * // BitmapDecoder.Create( new Uri( fileName ), * // BitmapCreateOptions.PreservePixelFormat, BitmapCacheOption.None ); * * //BitmapFrame frame = bitmapDecoder.Frames[ 0 ]; * * //WriteableBitmap bitmap = new WriteableBitmap( frame ); * //WriteableBitmapWrapper wrapper = WriteableBitmapWrapper.Create( bitmap ); * * //Color c = wrapper.GetPixelColor( 300, 300 ); * * * System.GC.Collect(); * * uint error; * * IntPtr imgRef; * //Open image * IntPtr inStream; * error = EDSDK.EdsCreateFileStream(fileName, EDSDK.EdsFileCreateDisposition.OpenExisting, EDSDK.EdsAccess.Read, out inStream); * EDSDK.EdsCreateImageRef(inStream, out imgRef); * EDSDK.EdsRelease(inStream); * * string convertedFileName = Path.ChangeExtension(fileName, "TIFF"); * * //Save image * IntPtr outStream; * var settings = new EDSDK.EdsSaveImageSetting(); * error = EDSDK.EdsCreateFileStream(convertedFileName, EDSDK.EdsFileCreateDisposition.CreateAlways, EDSDK.EdsAccess.Write, out outStream); * error = EDSDK.EdsSaveImage(imgRef, EDSDK.EdsTargetImageType.TIFF16, settings, outStream); * EDSDK.EdsRelease(outStream); * * ExtraImageInfo extraImageInfo = new ExtraImageInfo(); * return extraImageInfo; * * } */ if (fileName.ToUpper().EndsWith("CR2")) { Interval <double> finishInterval = new Interval <double>(0, 255); IntegerMatrix matrix = RawReader.ReadImageFromFile(fileName); //matrix = matrix.GetSubMatrix(0, 2640 - 1, matrix.RowCount - 1, matrix.ColumnCount - 1); int min = matrix.GetMinValue(); int max = matrix.GetMaxValue(); IntegerMatrix redMatrix = InterpolationHelper.GetRedMatrix(matrix); int minRed = redMatrix.GetMinValue(); int maxRed = redMatrix.GetMaxValue(); IntegerMatrix greenMatrix = InterpolationHelper.GetGreenMatrix(matrix); int minGreen = greenMatrix.GetMinValue(); int maxGreen = greenMatrix.GetMaxValue(); IntegerMatrix blueMatrix = InterpolationHelper.GetBlueMatrix(matrix); int minBlue = blueMatrix.GetMinValue(); int maxBlue = blueMatrix.GetMaxValue(); int minValue = (new int[] { minRed, minGreen, minBlue }).Min(); int maxValue = (new int[] { maxRed, maxGreen, maxBlue }).Max(); RealIntervalTransform redIntervalTransform = new RealIntervalTransform(new Interval <double>(minValue, maxValue), finishInterval); IntegerMatrix resRedMatrix = IntegerMatrixValuesTransform.TransformMatrixValues(redMatrix, redIntervalTransform); RealIntervalTransform greenIntervalTransform = new RealIntervalTransform(new Interval <double>(minValue, maxValue), finishInterval); IntegerMatrix resGreenMatrix = IntegerMatrixValuesTransform.TransformMatrixValues(greenMatrix, greenIntervalTransform); RealIntervalTransform blueIntervalTransform = new RealIntervalTransform(new Interval <double>(minValue, maxValue), finishInterval); IntegerMatrix resBlueMatrix = IntegerMatrixValuesTransform.TransformMatrixValues(blueMatrix, blueIntervalTransform); WriteableBitmap resImage = WriteableBitmapCreator.CreateWriteableBitmapFromMatricesRGB (resRedMatrix, resGreenMatrix, resBlueMatrix, OS.OS.IntegerSystemDpiX, OS.OS.IntegerSystemDpiY); /* * IntegerMatrix resMatrix = * IntegerMatrixValuesTransform.TransformMatrixValuesToFinishIntervalValues(matrix, finishInterval); * * WriteableBitmap resImage = * WriteableBitmapCreator.CreateGrayScaleWriteableBitmapFromMatrix * (resMatrix, OS.OS.IntegerSystemDpiX, OS.OS.IntegerSystemDpiY); */ ExtraImageInfo extraImageInfo = new ExtraImageInfo(); extraImageInfo.Image = resImage; return(extraImageInfo); } else { Stream imageStreamSource = new FileStream(fileName, FileMode.Open, FileAccess.Read, FileShare.Read); BitmapDecoder decoder = BitmapDecoder.Create(imageStreamSource, BitmapCreateOptions.PreservePixelFormat, BitmapCacheOption.Default); BitmapSource bitmapSource = decoder.Frames[0]; WriteableBitmap resultWriteableBitmap = new WriteableBitmap(bitmapSource); ExtraImageInfo extraImageInfo = new ExtraImageInfo(); extraImageInfo.Image = resultWriteableBitmap; return(extraImageInfo); } }
public static IntegerMatrix ReadScanData(byte[] scanDataBytes, DhtHeader dhtHeader, Sof3Header sof3Header, SosHeader sosHeader, UInt16[] slices) { int columnsCount = GetImageWidth(slices); int rowsCount = sof3Header.LinesNumber; int rowIndex = 0, columnIndex = 0; IntegerMatrix resMatrix = new IntegerMatrix(rowsCount, columnsCount); ushort normalSliceWidth = slices[1]; List <int> decompressionValueList = new List <int>(); Dictionary <string, byte>[] huffmanCodeValueMapsArray = RawReader.GetHuffmanCodeValueMapsArray(dhtHeader); BitArray scanDataBitArray = RawReader.GetScanDataBitArray(scanDataBytes); int index = 0, huffmanCodeIndex = 0; BitArray huffmanCodeBitArray = new BitArray(1); string huffmanCodeString = null; byte huffmanValue = 0; int componentIndex = 0; int componentValueIndex = 0, componentValue = 0; int[] previousComponentValues = RawReader.GetInitialComponentValues(sof3Header); int lastIndex = GetLastDecompressionValueIndex(sof3Header, slices); int lastSliceFirstDecompressionValueIndex = GetLastSliceFirstDecompressionValueIndex(sof3Header, slices); int sliceSize = slices[1] * sof3Header.LinesNumber; Dictionary <string, byte> huffmanCodeValueMap = huffmanCodeValueMapsArray[GetHuffmanTableIndex(rowIndex, columnIndex, sosHeader)]; while (componentValueIndex <= lastIndex && index < scanDataBitArray.Length) { huffmanCodeBitArray[huffmanCodeIndex] = scanDataBitArray[index]; huffmanCodeString = huffmanCodeBitArray.ToBitString(); if (huffmanCodeValueMap.TryGetValue(huffmanCodeString, out huffmanValue)) { int differenceCodeValue = 0; index++; if (huffmanValue > 0) { //Read difference code int finalIndex = index + huffmanValue - 1; differenceCodeValue = GetDifferenceCodeValue(scanDataBitArray, index, finalIndex, huffmanValue); index = finalIndex + 1; } else { differenceCodeValue = 0; } componentValue = previousComponentValues[componentIndex] + differenceCodeValue; previousComponentValues[componentIndex] = componentValue; decompressionValueList.Add(componentValue); resMatrix[rowIndex, columnIndex] = componentValue; componentValueIndex++; huffmanCodeBitArray = new BitArray(1); huffmanCodeIndex = 0; rowIndex = GetNextRowIndex(componentValueIndex, lastSliceFirstDecompressionValueIndex, sliceSize, slices); columnIndex = GetNextColumnIndex(componentValueIndex, lastSliceFirstDecompressionValueIndex, sliceSize, slices); huffmanCodeValueMap = huffmanCodeValueMapsArray[GetHuffmanTableIndex(rowIndex, columnIndex, sosHeader)]; bool initComponentValuesRequired = (columnIndex == 0) || ((columnIndex > 0) && (columnIndex % normalSliceWidth == 0)); if (initComponentValuesRequired) { previousComponentValues = GetInitialComponentValues(sof3Header); } componentIndex = GetComponentIndex(rowIndex, columnIndex); } else { //Read huffman code index++; huffmanCodeIndex++; huffmanCodeBitArray.Length++; } } return(resMatrix); }
/// <summary> /// Converts the specified expression to an IntegerMatrix. /// </summary> /// <param name="expression">The expression.</param> /// <returns>The IntegerMatrix. Returns <c>null</c> if the specified expression is not vector.</returns> public static IntegerMatrix AsIntegerMatrix(this SymbolicExpression expression) { if (!expression.IsVector()) { return null; } int rowCount = 0; int columnCount = 0; if (expression.IsMatrix()) { if (expression.Type == SymbolicExpressionType.IntegerVector) { return new IntegerMatrix(expression.Engine, expression.DangerousGetHandle()); } else { rowCount = expression.GetFunction<Rf_nrows>()(expression.DangerousGetHandle()); columnCount = expression.GetFunction<Rf_ncols>()(expression.DangerousGetHandle()); } } if (columnCount == 0) { rowCount = expression.GetFunction<Rf_length>()(expression.DangerousGetHandle()); columnCount = 1; } IntPtr coerced = expression.GetFunction<Rf_coerceVector>()(expression.DangerousGetHandle(), SymbolicExpressionType.IntegerVector); var dim = new IntegerVector(expression.Engine, new[] { rowCount, columnCount }); SymbolicExpression dimSymbol = expression.Engine.GetPredefinedSymbol("R_DimSymbol"); var matrix = new IntegerMatrix(expression.Engine, coerced); matrix.SetAttribute(dimSymbol, dim); return matrix; }