/// <summary> /// Initializes a new instance of the <see cref="InRamImageData"/> class. /// Creates the bitmap from the raw image specified. The bounds should be set on this later. /// </summary> /// <param name="rawImage"> /// The raw image. /// </param> public InRamImageData(Image rawImage) { _myImage = new Bitmap(rawImage.Width, rawImage.Height); Width = rawImage.Width; Height = rawImage.Height; Graphics g = Graphics.FromImage(_myImage); g.DrawImageUnscaled(rawImage, 0, 0); g.Dispose(); WorldFile = new WorldFile(); double[] aff = new[] { .5, 1.0, 0, _myImage.Height - .5, 0, -1.0 }; Bounds = new RasterBounds(_myImage.Height, _myImage.Width, aff); MemorySetup(); }
public void TestMethod1() { double[] affine = new double[6]; affine[0] = 10; affine[1] = 1; affine[2] = .2; affine[3] = 100; affine[4] = .2; affine[5] = -1.2; RasterBounds rb = new RasterBounds(100, 100, affine); int row = 40; int col = 30; Coordinate c = rb.CellCenter_ToProj(row, col); RcIndex rc = rb.ProjToCell(c); Assert.AreEqual(rc.Row, row); Assert.AreEqual(rc.Column, col); }
/// <summary> /// Initializes a new instance of the <see cref="InRamImageData"/> class. /// Constructs a new ImageData of the specified width and height. /// </summary> /// <param name="width"> /// The integer width in pixels. /// </param> /// <param name="height"> /// The integer height in pixels. /// </param> public InRamImageData(int width, int height) { WorldFile = new WorldFile(); double[] aff = new[] { .5, 1.0, 0, _myImage.Height - .5, 0, -1.0 }; Bounds = new RasterBounds(height, width, aff); _myImage = new Bitmap(width, height); Width = width; Height = height; MemorySetup(); }
public bool RasterMath(IRaster input1, IRaster input2, IRaster output, ICancelProgressHandler cancelProgressHandler) { // Validates the input and output data if (input1 == null || input2 == null || output == null) { return false; } Extent envelope = UnionEnvelope(input1, input2); // Figures out which raster has smaller cells IRaster smallestCellRaster = input1.CellWidth < input2.CellWidth ? input1 : input2; // Given the envelope of the two rasters we calculate the number of columns / rows int noOfCol = Convert.ToInt32(Math.Abs(envelope.Width / smallestCellRaster.CellWidth)); int noOfRow = Convert.ToInt32(Math.Abs(envelope.Height / smallestCellRaster.CellHeight)); // create output raster output = Raster.CreateRaster( output.Filename, string.Empty, noOfCol, noOfRow, 1, typeof(int), new[] { string.Empty }); RasterBounds bound = new RasterBounds(noOfRow, noOfCol, envelope); output.Bounds = bound; output.NoDataValue = input1.NoDataValue; RcIndex v1; RcIndex v2; int previous = 0; int max = output.Bounds.NumRows + 1; for (int i = 0; i < output.Bounds.NumRows; i++) { for (int j = 0; j < output.Bounds.NumColumns; j++) { Coordinate cellCenter = output.CellToProj(i, j); v1 = input1.ProjToCell(cellCenter); double val1; if (v1.Row <= input1.EndRow && v1.Column <= input1.EndColumn && v1.Row > -1 && v1.Column > -1) { val1 = input1.Value[v1.Row, v1.Column]; } else { val1 = input1.NoDataValue; } v2 = input2.ProjToCell(cellCenter); double val2; if (v2.Row <= input2.EndRow && v2.Column <= input2.EndColumn && v2.Row > -1 && v2.Column > -1) { val2 = input2.Value[v2.Row, v2.Column]; } else { val2 = input2.NoDataValue; } if (val1 == input1.NoDataValue && val2 == input2.NoDataValue) { output.Value[i, j] = output.NoDataValue; } else if (val1 != input1.NoDataValue && val2 == input2.NoDataValue) { output.Value[i, j] = output.NoDataValue; } else if (val1 == input1.NoDataValue && val2 != input2.NoDataValue) { output.Value[i, j] = output.NoDataValue; } else { output.Value[i, j] = Operation(val1, val2); } if (cancelProgressHandler.Cancel) { return false; } } int current = Convert.ToInt32(Math.Round(i * 100D / max)); // only update when increment in persentage if (current > previous) { cancelProgressHandler.Progress(string.Empty, current, current + TextStrings.progresscompleted); } previous = current; } // output = Temp; output.Save(); return true; }
/// <summary> /// Executes the RasterFromLAS tool. /// </summary> /// <param name="filenameLAS">The string filename of the LAS file to convert.</param> /// <param name="outputExtent">The extent of the output raster.</param> /// <param name="numRows">The integer number of rows of the output raster.</param> /// <param name="numColumns">The integer number of columns.</param> /// <param name="output">The output raster.</param> /// <param name="cancelProgressHandler">The progress handler.</param> /// <returns>Boolean, true if the method was successful.</returns> public bool Execute( string filenameLAS, Extent outputExtent, int numRows, int numColumns, IRaster output, ICancelProgressHandler cancelProgressHandler) { // create output raster output = Raster.CreateRaster( output.Filename, string.Empty, numColumns, numRows, 1, typeof(int), new[] { string.Empty }); RasterBounds bound = new RasterBounds(numRows, numColumns, outputExtent); output.Bounds = bound; output.NoDataValue = int.MinValue; ProgressMeter pm = new ProgressMeter( cancelProgressHandler, TextStrings.ConvertingLAS + filenameLAS + TextStrings.Progresstoraster + "...", numRows); for (int row = 0; row < numRows; row++) { for (int j = 0; j < output.Bounds.NumColumns; j++) { // TO DO: PING CAN ADD LAS READING AND CELL ASSIGNMENT HERE if (cancelProgressHandler.Cancel) { return false; } } pm.CurrentValue = row; } // output = Temp; output.Save(); return true; }
/// <summary> /// Reads the header only from the specified mwi file. The header is in xml format. /// This is a test. We may have to jurry rig the thing to ensure it ignores the actual /// image content. /// </summary> /// <param name="fileName">Whether this is the mwi or mwh file, this reads the mwh file for the fileName.</param> public void ReadHeader(string fileName) { string header = Path.ChangeExtension(fileName, "mwh"); XmlSerializer s = new XmlSerializer(typeof(PyramidHeader)); TextReader r = new StreamReader(header); _header = (PyramidHeader)s.Deserialize(r); PyramidImageHeader ph = _header.ImageHeaders[0]; Bounds = new RasterBounds(ph.NumRows, ph.NumColumns, ph.Affine); Width = _header.ImageHeaders[0].NumColumns; Height = _header.ImageHeaders[0].NumRows; r.Close(); }
/// <summary> /// This will resample the cells. /// If the cell size is zero, this will default to the shorter of the width or height /// divided by 256. /// </summary> /// <param name="input1">the input raster.</param> /// <param name="cellHeight">The new cell height or null.</param> /// <param name="cellWidth">The new cell width or null.</param> /// <param name="outputFileName">The string name of the output raster.</param> /// <param name="progressHandler">An interface for handling the progress messages.</param> /// <returns>The resampled raster.</returns> public static IRaster Resample(IRaster input1, double cellHeight, double cellWidth, string outputFileName, IProgressHandler progressHandler) { if (input1 == null) { return null; } Extent envelope = input1.Bounds.Extent; if (cellHeight == 0) { cellHeight = envelope.Height / 256; } if (cellWidth == 0) { cellWidth = envelope.Width / 256; } //Calculate new number of columns and rows int noOfCol = Convert.ToInt32(Math.Abs(envelope.Width / cellWidth)); int noOfRow = Convert.ToInt32(Math.Abs(envelope.Height / cellHeight)); IRaster output = Raster.CreateRaster(outputFileName, string.Empty, noOfCol, noOfRow, 1, input1.DataType, new[] { string.Empty }); RasterBounds bound = new RasterBounds(noOfRow, noOfCol, envelope); output.Bounds = bound; output.NoDataValue = input1.NoDataValue; RcIndex index1; int max = (output.Bounds.NumRows); ProgressMeter pm = new ProgressMeter(progressHandler, "ReSize Cells", max); //Loop through every cell for new value for (int i = 0; i < max; i++) { for (int j = 0; j < output.Bounds.NumColumns; j++) { //Project the cell position to Map Coordinate cellCenter = output.CellToProj(i, j); index1 = input1.ProjToCell(cellCenter); double val; if (index1.Row <= input1.EndRow && index1.Column <= input1.EndColumn && index1.Row > -1 && index1.Column > -1) { val = input1.Value[index1.Row, index1.Column] == input1.NoDataValue ? output.NoDataValue : input1.Value[index1.Row, index1.Column]; } else { val = output.NoDataValue; } output.Value[i, j] = val; } pm.CurrentValue = i; } output.Save(); pm.Reset(); return output; }
/// <summary> /// Initializes a new instance of an InRamImage class. This class supports a basic .Net Image /// plus a geographic extent as a RasterBounds. This class does not feature any byte level /// data access or built in file access. The expectation is that this will only be used in memory. /// </summary> /// <param name="image">THe Bitmap image to use to create this image.</param> public InRamImage(Bitmap image) { _myImage = image; Bounds = new RasterBounds(image.Height, image.Width, new double[] { 0, 1, 0, image.Height, 0, -1 }); }
/// <summary> /// Executes the Erase Opaeration tool programaticaly /// Ping Yang deleted static for external testing 01/2010 /// </summary> /// <param name="input">The input raster</param> /// <param name="oldValue">The original double value representing no-data</param> /// <param name="newValue">The new double value representing no-data</param> /// <param name="output">The output raster</param> /// <param name="cancelProgressHandler">The progress handler</param> /// <returns></returns> public bool Execute( IRaster input, double oldValue, double newValue, IRaster output, ICancelProgressHandler cancelProgressHandler) { // Validates the input and output data if (input == null || newValue == 0 || output == null) { return false; } Extent envelope = input.Bounds.Extent; int noOfCol = input.NumColumns; int noOfRow = input.NumRows; int previous = 0; Type dataType = input.DataType; // create output raster output = Raster.CreateRaster( output.Filename, string.Empty, noOfCol, noOfRow, 1, dataType, new[] { string.Empty }); RasterBounds bound = new RasterBounds(noOfRow, noOfCol, envelope); output.Bounds = bound; output.NoDataValue = newValue; // Loop throug every cell int max = output.Bounds.NumRows + 1; for (int i = 0; i < output.Bounds.NumRows; i++) { for (int j = 0; j < output.Bounds.NumColumns; j++) { if (input.Value[i, j] == oldValue) { output.Value[i, j] = newValue; } else { output.Value[i, j] = input.Value[i, j]; } if (cancelProgressHandler.Cancel) { return false; } } int current = Convert.ToInt32(Math.Round(i * 100D / max)); // only update when increment in persentage if (current > previous) { cancelProgressHandler.Progress(string.Empty, current, current + TextStrings.progresscompleted); } previous = current; } // output = Temp; output.Save(); return true; }
/// <summary> /// For big images the scale that is just one step larger than the specified window will be used. /// </summary> /// <param name="envelope">The envelope containing the geographic extent.</param> /// <param name="window">The rectangle containing the window extent.</param> /// <returns>The bitmap.</returns> public override Bitmap GetBitmap(Extent envelope, Rectangle window) { if (window.Width == 0 || window.Height == 0) { return(null); } if (Header?.ImageHeaders?[0] == null) { return(null); } Rectangle expWindow = window.ExpandBy(1); Envelope expEnvelope = envelope.ToEnvelope().Reproportion(window, expWindow); Envelope env = expEnvelope.Intersection(Bounds.Extent.ToEnvelope()); if (env == null || env.IsNull || env.Height == 0 || env.Width == 0) { return(null); } PyramidImageHeader he = Header.ImageHeaders[0]; int scale; double cwa = expWindow.Width / expEnvelope.Width; double cha = expWindow.Height / expEnvelope.Height; for (scale = 0; scale < Header.ImageHeaders.Length; scale++) { PyramidImageHeader ph = Header.ImageHeaders[scale]; if (cwa > ph.NumColumns / Bounds.Width || cha > ph.NumRows / Bounds.Height) { if (scale > 0) { scale -= 1; } break; } he = ph; } RasterBounds overviewBounds = new RasterBounds(he.NumRows, he.NumColumns, he.Affine); Rectangle r = overviewBounds.CellsContainingExtent(envelope); if (r.Width == 0 || r.Height == 0) { return(null); } byte[] vals = ReadWindow(r.Y, r.X, r.Height, r.Width, scale); Bitmap bmp = new Bitmap(r.Width, r.Height); BitmapData bData = bmp.LockBits(new Rectangle(0, 0, r.Width, r.Height), ImageLockMode.ReadWrite, PixelFormat.Format32bppArgb); Marshal.Copy(vals, 0, bData.Scan0, vals.Length); bmp.UnlockBits(bData); // Use the cell coordinates to determine the affine coefficients for the cells retrieved. double[] affine = new double[6]; Array.Copy(he.Affine, affine, 6); affine[0] = affine[0] + (r.X * affine[1]) + (r.Y * affine[2]); affine[3] = affine[3] + (r.X * affine[4]) + (r.Y * affine[5]); if (window.Width == 0 || window.Height == 0) { return(null); } Bitmap result = new Bitmap(window.Width, window.Height); Graphics g = Graphics.FromImage(result); // Gets the scaling factor for converting from geographic to pixel coordinates double dx = window.Width / envelope.Width; double dy = window.Height / envelope.Height; double[] a = affine; // gets the affine scaling factors. float m11 = Convert.ToSingle(a[1] * dx); float m22 = Convert.ToSingle(a[5] * -dy); float m21 = Convert.ToSingle(a[2] * dx); float m12 = Convert.ToSingle(a[4] * -dy); double l = a[0] - (.5 * (a[1] + a[2])); // Left of top left pixel double t = a[3] - (.5 * (a[4] + a[5])); // top of top left pixel float xShift = (float)((l - envelope.MinX) * dx); float yShift = (float)((envelope.MaxY - t) * dy); g.Transform = new Matrix(m11, m12, m21, m22, xShift, yShift); g.PixelOffsetMode = PixelOffsetMode.Half; if (m11 > 1 || m22 > 1) { g.InterpolationMode = InterpolationMode.NearestNeighbor; } g.DrawImage(bmp, new PointF(0, 0)); bmp.Dispose(); g.Dispose(); return(result); }
/// <summary> /// This takes an original image and calculates the header content for all the lower resolution tiles. /// This does not actually write the bytes for those images. /// </summary> /// <param name="originalImage">The raster bounds for the original image.</param> public void CreateHeaders(RasterBounds originalImage) { Bounds = originalImage; CreateHeaders(originalImage.NumRows, originalImage.NumColumns, originalImage.AffineCoefficients); }
/// <summary> /// Initializes a new instance of the <see cref="InRamImage"/> class. This class supports a basic .Net Image /// plus a geographic extent as a RasterBounds. This class does not feature any byte level /// data access or built in file access. The expectation is that this will only be used in memory. /// </summary> /// <param name="image">THe Bitmap image to use to create this image.</param> public InRamImage(Bitmap image) { _myImage = image; Bounds = new RasterBounds(image.Height, image.Width, new double[] { 0, 1, 0, image.Height, 0, -1 }); }
/// <summary> /// Creates a new image and world file, placing the default bounds at the origin, with one pixel per unit. /// </summary> /// <param name="fileName">The string fileName.</param> /// <param name="width">The integer width.</param> /// <param name="height">The integer height.</param> /// <param name="bandType">The ImageBandType that clarifies how the separate bands are layered in the image.</param> /// <returns>The create image.</returns> public override IImageData Create(string fileName, int width, int height, ImageBandType bandType) { Filename = fileName; WorldFile = new WorldFile(); double[] aff = { 1.0, 0, 0, -1.0, 0, height }; Bounds = new RasterBounds(height, width, aff); WorldFile.Filename = WorldFile.GenerateFilename(fileName); Width = width; Height = height; _myImage = new Bitmap(width, height); string ext = Path.GetExtension(fileName); ImageFormat imageFormat; switch (ext) { case ".bmp": imageFormat = ImageFormat.Bmp; break; case ".emf": imageFormat = ImageFormat.Emf; break; case ".exf": imageFormat = ImageFormat.Exif; break; case ".gif": imageFormat = ImageFormat.Gif; break; case ".ico": imageFormat = ImageFormat.Icon; break; case ".jpg": imageFormat = ImageFormat.Jpeg; break; case ".mbp": imageFormat = ImageFormat.MemoryBmp; break; case ".png": imageFormat = ImageFormat.Png; break; case ".tif": imageFormat = ImageFormat.Tiff; break; case ".wmf": imageFormat = ImageFormat.Wmf; break; default: throw new ArgumentOutOfRangeException(nameof(fileName), DataStrings.FileTypeNotSupported); } _myImage.Save(fileName, imageFormat); NumBands = 4; BytesPerPixel = 4; CopyBitmapToValues(); return(this); }
/// <summary> /// Executes the ReSample Opaeration tool programaticaly /// Ping deleted the static property for external testing. /// </summary> /// <param name="input1">The input raster.</param> /// <param name="newCellHeight">The size of the cell's hight.</param> /// <param name="newCellWidth">The size of the cell's width.</param> /// <param name="output">The output raster.</param> /// <param name="cancelProgressHandler">The progress handler.</param> /// <returns>Boolean, true if the method was successful.</returns> public bool Execute( IRaster input1, double newCellHeight, double newCellWidth, IRaster output, ICancelProgressHandler cancelProgressHandler) { // Validates the input and output data if (input1 == null || newCellWidth == 0 || output == null) { return false; } Extent envelope = input1.Bounds.Extent; // Calculate new number of columns and rows int noOfCol = Convert.ToInt32(Math.Abs(envelope.Width / newCellWidth)); int noOfRow = Convert.ToInt32(Math.Abs(envelope.Height / newCellHeight)); int previous = 0; // ************OLD Method ////Create the new raster with the appropriate dimensions // Raster Temp = new Raster(); ////Temp.CreateNew(output.Filename, noOfRow, noOfCol, input1.DataType); // Temp.CreateNew(output.Filename, "", noOfCol, noOfRow, 1, input1.DataType, new string[] { "" }); // Temp.CellWidth = newCellSize; // Temp.CellHeight = oldCellSize; // Temp.Xllcenter = input1.Bounds.Envelope.Minimum.X + (Temp.CellWidth / 2); // Temp.Yllcenter = input1.Bounds.Envelope.Minimum.Y + (Temp.CellHeight / 2); // *************** // create output raster output = Raster.CreateRaster( output.Filename, string.Empty, noOfCol, noOfRow, 1, input1.DataType, new[] { string.Empty }); RasterBounds bound = new RasterBounds(noOfRow, noOfCol, envelope); output.Bounds = bound; output.NoDataValue = input1.NoDataValue; RcIndex index1; // Loop throug every cell for new value int max = output.Bounds.NumRows + 1; for (int i = 0; i < output.Bounds.NumRows; i++) { for (int j = 0; j < output.Bounds.NumColumns; j++) { // Projet the cell position to Map Coordinate cellCenter = output.CellToProj(i, j); index1 = input1.ProjToCell(cellCenter); double val; if (index1.Row <= input1.EndRow && index1.Column <= input1.EndColumn && index1.Row > -1 && index1.Column > -1) { val = input1.Value[index1.Row, index1.Column] == input1.NoDataValue ? output.NoDataValue : input1.Value[index1.Row, index1.Column]; } else { val = output.NoDataValue; } output.Value[i, j] = val; if (cancelProgressHandler.Cancel) { return false; } } int current = Convert.ToInt32(Math.Round(i * 100D / max)); // only update when increment in persentage if (current > previous) { cancelProgressHandler.Progress(string.Empty, current, current + TextStrings.progresscompleted); } previous = current; } // output = Temp; output.Save(); return true; }
/// <summary> /// Creates a new image and world file, placing the default bounds at the origin, with one pixel per unit. /// </summary> /// <param name="fileName"> /// The string fileName /// </param> /// <param name="width"> /// The integer width /// </param> /// <param name="height"> /// The integer height /// </param> /// <param name="bandType">The ImageBandType that clarifies how the separate bands are layered in the image.</param> public override IImageData Create(string fileName, int width, int height, ImageBandType bandType) { Filename = fileName; WorldFile = new WorldFile(); double[] aff = new[] { 1.0, 0, 0, -1.0, 0, height }; Bounds = new RasterBounds(height, width, aff); WorldFile.Filename = WorldFile.GenerateFilename(fileName); Width = width; Height = height; _myImage = new Bitmap(width, height); string ext = Path.GetExtension(fileName); switch (ext) { case ".bmp": _myImage.Save(fileName, ImageFormat.Bmp); break; case ".emf": _myImage.Save(fileName, ImageFormat.Emf); break; case ".exf": _myImage.Save(fileName, ImageFormat.Exif); break; case ".gif": _myImage.Save(fileName, ImageFormat.Gif); break; case ".ico": _myImage.Save(fileName, ImageFormat.Icon); break; case ".jpg": _myImage.Save(fileName, ImageFormat.Jpeg); break; case ".mbp": _myImage.Save(fileName, ImageFormat.MemoryBmp); break; case ".png": _myImage.Save(fileName, ImageFormat.Png); break; case ".tif": _myImage.Save(fileName, ImageFormat.Tiff); break; case ".wmf": _myImage.Save(fileName, ImageFormat.Wmf); break; } NumBands = 4; BytesPerPixel = 4; CopyBitmapToValues(); return this; }
/// <summary> /// For big images the scale that is just one step larger than the specified window will be used. /// </summary> /// <param name="envelope"></param> /// <param name="window"></param> /// <returns></returns> public override Bitmap GetBitmap(Extent envelope, Rectangle window) { if (window.Width == 0 || window.Height == 0) return null; if (_header == null) return null; if (_header.ImageHeaders == null) return null; if (_header.ImageHeaders[0] == null) return null; Rectangle expWindow = window.ExpandBy(1); IEnvelope expEnvelope = envelope.ToEnvelope().Reproportion(window, expWindow); IEnvelope env = expEnvelope.Intersection(Bounds.Extent.ToEnvelope()); if (env == null || env.IsNull || env.Height == 0 || env.Width == 0) return null; PyramidImageHeader he = _header.ImageHeaders[0]; int scale; double cwa = expWindow.Width / expEnvelope.Width; double cha = expWindow.Height / expEnvelope.Height; for (scale = 0; scale < _header.ImageHeaders.Length; scale++) { PyramidImageHeader ph = _header.ImageHeaders[scale]; if (cwa > ph.NumColumns / Bounds.Width || cha > ph.NumRows / Bounds.Height) { if (scale > 0) scale -= 1; break; } he = ph; } RasterBounds overviewBounds = new RasterBounds(he.NumRows, he.NumColumns, he.Affine); Rectangle r = overviewBounds.CellsContainingExtent(envelope); if (r.Width == 0 || r.Height == 0) return null; byte[] vals = ReadWindow(r.Y, r.X, r.Height, r.Width, scale); Bitmap bmp = new Bitmap(r.Width, r.Height); BitmapData bData = bmp.LockBits(new Rectangle(0, 0, r.Width, r.Height), ImageLockMode.ReadWrite, PixelFormat.Format32bppArgb); Marshal.Copy(vals, 0, bData.Scan0, vals.Length); bmp.UnlockBits(bData); // Use the cell coordinates to determine the affine coefficients for the cells retrieved. double[] affine = new double[6]; Array.Copy(he.Affine, affine, 6); affine[0] = affine[0] + r.X * affine[1] + r.Y * affine[2]; affine[3] = affine[3] + r.X * affine[4] + r.Y * affine[5]; if (window.Width == 0 || window.Height == 0) { return null; } Bitmap result = new Bitmap(window.Width, window.Height); Graphics g = Graphics.FromImage(result); // // Gets the scaling factor for converting from geographic to pixel coordinates double dx = (window.Width / envelope.Width); double dy = (window.Height / envelope.Height); double[] a = affine; // gets the affine scaling factors. float m11 = Convert.ToSingle(a[1] * dx); float m22 = Convert.ToSingle(a[5] * -dy); float m21 = Convert.ToSingle(a[2] * dx); float m12 = Convert.ToSingle(a[4] * -dy); float l = (float)(a[0] - .5 * (a[1] + a[2])); // Left of top left pixel float t = (float)(a[3] - .5 * (a[4] + a[5])); // top of top left pixel float xShift = (float)((l - envelope.MinX) * dx); float yShift = (float)((envelope.MaxY - t) * dy); g.Transform = new Matrix(m11, m12, m21, m22, xShift, yShift); g.PixelOffsetMode = PixelOffsetMode.Half; if (m11 > 1 || m22 > 1) { g.InterpolationMode = InterpolationMode.NearestNeighbor; } g.DrawImage(bmp, new PointF(0, 0)); bmp.Dispose(); g.Dispose(); return result; }
/// <summary> /// Opens the file, assuming that the fileName has already been specified using a Dot Net Image object /// </summary> public override void Open() { if (_myImage != null) { _myImage.Dispose(); } using (FileStream stream = new FileStream(Filename, FileMode.Open)) { using (Image temp = Image.FromStream(stream)) { _myImage = new Bitmap(temp.Width, temp.Height, PixelFormat.Format32bppArgb); Width = temp.Width; Height = temp.Height; using (Graphics g = Graphics.FromImage(_myImage)) { g.DrawImage(temp, new Rectangle(0, 0, temp.Width, temp.Height)); } } } WorldFile = new WorldFile(Filename); if (WorldFile.Affine == null) WorldFile.Affine = new[] { .5, 1.0, 0, _myImage.Height - .5, 0, -1.0 }; Bounds = new RasterBounds(_myImage.Height, _myImage.Width, WorldFile.Affine); NumBands = 4; BytesPerPixel = 4; CopyBitmapToValues(); }
/// <summary> /// Initializes a new instance of the <see cref="InRamImageData"/> class. /// Uses a bitmap and a geographic envelope in order to define a new imageData object. /// </summary> /// <param name="rawImage"> /// The raw image. /// </param> /// <param name="bounds"> /// The envelope bounds. /// </param> public InRamImageData(Bitmap rawImage, Extent bounds) { _myImage = rawImage; Width = _myImage.Width; Height = _myImage.Height; Bounds = new RasterBounds(_myImage.Height, _myImage.Width, bounds); MemorySetup(); }
/// <summary> /// Creates a new image and world file, placing the default bounds at the origin, with one pixel per unit. /// </summary> /// <param name="fileName"> /// The string fileName /// </param> /// <param name="width"> /// The integer width /// </param> /// <param name="height"> /// The integer height /// </param> /// <param name="bandType">The ImageBandType that clarifies how the separate bands are layered in the image.</param> public override IImageData Create(string fileName, int width, int height, ImageBandType bandType) { Filename = fileName; WorldFile = new WorldFile(); double[] aff = new[] { 1.0, 0, 0, -1.0, 0, height }; Bounds = new RasterBounds(height, width, aff); WorldFile.Filename = WorldFile.GenerateFilename(fileName); Width = width; Height = height; _myImage = new Bitmap(width, height); string ext = Path.GetExtension(fileName); switch (ext) { case ".bmp": _myImage.Save(fileName, ImageFormat.Bmp); break; case ".emf": _myImage.Save(fileName, ImageFormat.Emf); break; case ".exf": _myImage.Save(fileName, ImageFormat.Exif); break; case ".gif": _myImage.Save(fileName, ImageFormat.Gif); break; case ".ico": _myImage.Save(fileName, ImageFormat.Icon); break; case ".jpg": _myImage.Save(fileName, ImageFormat.Jpeg); break; case ".mbp": _myImage.Save(fileName, ImageFormat.MemoryBmp); break; case ".png": _myImage.Save(fileName, ImageFormat.Png); break; case ".tif": _myImage.Save(fileName, ImageFormat.Tiff); break; case ".wmf": _myImage.Save(fileName, ImageFormat.Wmf); break; } NumBands = 4; BytesPerPixel = 4; CopyBitmapToValues(); return(this); }