/// <summary>
/// Creates a new raster with the specified cell size. If the cell size
/// is zero, this will default to the shorter of the width or height
/// divided by 256. If the cell size produces a raster that is greater
/// than 8,000 pixels in either dimension, it will be re-sized to
/// create an 8,000 length or width raster.
/// </summary>
/// <param name="fs">The featureset to convert to a raster</param>
/// <param name="cellSize">The double extent of the cell.</param>
/// <param name="fieldName">The integer field index of the file.</param>
/// <param name="destFilename">The filename of the raster to create</param>
/// <param name="driverCode">The optional GDAL driver code to use if using GDAL
/// for a format that is not discernable from the file extension. An empty string
/// is usually perfectly acceptable here.</param>
/// <param name="options">For GDAL rasters, they can be created with optional parameters
/// passed in as a string array. In most cases an empty string is perfectly acceptable.</param>
/// <param name="progressHandler">An interface for handling the progress messages.</param>
/// <returns>Generates a raster from the vectors.</returns>
public static IRaster ToRaster(IFeatureSet fs, ref double cellSize, string fieldName, string destFilename, string driverCode, string[] options, IProgressHandler progressHandler)
{
IEnvelope env = fs.Envelope;
if(cellSize == 0)
{
if(fs.Envelope.Width < fs.Envelope.Height)
{
cellSize = env.Width/256;
}
else
{
cellSize = env.Height/256;
}
}
int w = (int)Math.Ceiling(env.Width/cellSize);
if (w > 8000)
{
w = 8000;
cellSize = env.Width/8000;
}
int h = (int) Math.Ceiling(env.Height/cellSize);
if (h > 8000)
{
cellSize = env.Height/8000;
h = 8000;
}
Bitmap bmp = new Bitmap(w, h);
Graphics g = Graphics.FromImage(bmp);
g.Clear(Color.Transparent);
g.SmoothingMode = SmoothingMode.None;
g.TextRenderingHint = TextRenderingHint.SingleBitPerPixel;
g.InterpolationMode = InterpolationMode.NearestNeighbor;
Hashtable colorTable;
MapArgs args = new MapArgs(new Rectangle(0, 0, w, h), env, g);
switch (fs.FeatureType)
{
case FeatureTypes.Polygon:
{
MapPolygonLayer mpl = new MapPolygonLayer(fs);
PolygonScheme ps = new PolygonScheme();
colorTable = ps.GenerateUniqueColors(fs, fieldName);
mpl.Symbology = ps;
mpl.DrawRegions(args, new List<IEnvelope> {env});
}
break;
case FeatureTypes.Line:
{
MapLineLayer mpl = new MapLineLayer(fs);
LineScheme ps = new LineScheme();
colorTable = ps.GenerateUniqueColors(fs, fieldName);
mpl.Symbology = ps;
mpl.DrawRegions(args, new List<IEnvelope> { env });
}
break;
default:
{
MapPointLayer mpl = new MapPointLayer(fs);
PointScheme ps = new PointScheme();
colorTable = ps.GenerateUniqueColors(fs, fieldName);
mpl.Symbology = ps;
mpl.DrawRegions(args, new List<IEnvelope> { env });
}
break;
}
Type tp = fieldName == "FID" ? typeof(int) : fs.DataTable.Columns[fieldName].DataType;
if (tp == typeof(string)) tp = typeof (double); // We will try to convert to double if it is a string
Raster output = new Raster();
MWImageData image = new MWImageData(bmp, env);
ProgressMeter pm = new ProgressMeter(progressHandler, "Converting To Raster Cells", h);
output.CreateNew(destFilename, driverCode, w, h, 1, tp, options);
output.Bounds = new RasterBounds(h, w, env);
List<RcIndex> locations = new List<RcIndex>();
List<string> failureList = new List<string>();
for (int row = 0; row < h; row++)
{
for (int col = 0; col < w; col++)
{
Color c = image.GetColor(row, col);
if (c.A == 0)
{
output.Value[row, col] = output.NoDataValue;
}
else
{
if (colorTable.ContainsKey(c) == false)
{
if (c.A < 125)
{
output.Value[row, col] = output.NoDataValue;
continue;
}
// Use a color matching distance to pick the closest member
object val = GetCellValue(w, h, row, col, image, c, colorTable, locations);
output.Value[row, col] = GetDouble(val, failureList);
}
else
{
output.Value[row, col] = GetDouble(colorTable[c], failureList);
}
}
}
pm.CurrentValue = row;
}
const int maxIterations = 5;
int iteration = 0;
while(locations.Count > 0)
{
List<RcIndex> newLocations = new List<RcIndex>();
foreach (RcIndex location in locations)
{
object val = GetCellValue(w, h, location.Row, location.Column, image, image.GetColor(location.Row, location.Column), colorTable, newLocations);
output.Value[location.Row, location.Column] = GetDouble(val, failureList);
}
locations = newLocations;
iteration++;
if(iteration > maxIterations) break;
}
pm.Reset();
return output;
}
/// <summary>
/// Executes the Erase Opaeration tool programaticaly
/// </summary>
/// <param name="input1">The input raster</param>
/// <param name="input2">The input raster</param>
/// <param name="output">The output raster</param>
/// <param name="cancelProgressHandler">The progress handler</param>
/// <returns></returns>
public bool Execute(IRaster input1, IRaster input2, IRaster output, MapWindow.Tools.ICancelProgressHandler cancelProgressHandler)
{
//Validates the input and output data
if (input1 == null || input2 == null || output == null)
{
return false;
}
IEnvelope envelope = new Envelope() as IEnvelope;
envelope = UnionEnvelope(input1, input2);
int noOfCol;
int noOfRow;
//Figures out which raster has smaller cells
IRaster smallestCellRaster;
if (input1.CellWidth < input2.CellWidth) smallestCellRaster = input1;
else smallestCellRaster = input2;
//Given the envelope of the two rasters we calculate the number of columns / rows
noOfCol = Convert.ToInt32(Math.Abs(envelope.Width / smallestCellRaster.CellWidth));
noOfRow = Convert.ToInt32(Math.Abs(envelope.Height / smallestCellRaster.CellHeight));
//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 = smallestCellRaster.CellWidth;
Temp.CellHeight = smallestCellRaster.CellHeight;
Temp.Xllcenter = envelope.Minimum.X + (Temp.CellWidth / 2);
Temp.Yllcenter = envelope.Minimum.Y + (Temp.CellHeight / 2);
MapWindow.Geometries.ICoordinate I1 = new MapWindow.Geometries.Coordinate() as MapWindow.Geometries.ICoordinate;
RcIndex v1 = new RcIndex();
RcIndex v2 = new RcIndex();
double val1;
double val2;
int previous=0;
int current=0;
int max = (Temp.Bounds.NumRows + 1);
for (int i = 0; i < Temp.Bounds.NumRows; i++)
{
for (int j = 0; j < Temp.Bounds.NumColumns; j++)
{
I1 = Temp.CellToProj(i, j);
v1 = input1.ProjToCell(I1);
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(I1);
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)
{
Temp.Value[i, j] = Temp.NoDataValue;
}
else if (val1 != input1.NoDataValue && val2 == input2.NoDataValue)
{
Temp.Value[i, j] = val1;
}
else if (val1 == input1.NoDataValue && val2 != input2.NoDataValue)
{
Temp.Value[i, j] = val2;
}
else
{
Temp.Value[i, j] = val1;
}
if (cancelProgressHandler.Cancel == true)
return false;
}
current = Convert.ToInt32(Math.Round(i * 100D / max));
//only update when increment in persentage
if(current>previous)
cancelProgressHandler.Progress("", current, current.ToString() + "% progress completed");
previous = current;
}
output = Temp;
output.Save();
return true;
}
