public void ClonePerformanceTest()
{
var colorBlend = new ColorBlend(new[] { Color.Black, Color.White }, new[] { 0.0f, 1.0f });
var gradientTheme = new GradientTheme("aa", 0, 20, new VectorStyle(), new VectorStyle(), colorBlend,
colorBlend, colorBlend, 5) { NoDataValues = new List<double> { -9999 } };
TestHelper.AssertIsFasterThan(30,() => gradientTheme.Clone());
}
public void ToBrushTest()
{
ColorBlend colorBlend = new ColorBlend(new Color[] {Color.Blue, Color.GreenYellow, Color.Red}, new float[] {0f, 500f, 1000f} );
Assert.IsNotNull(colorBlend);
System.Drawing.Drawing2D.LinearGradientBrush lgb = colorBlend.ToBrush(new Rectangle(0, 0, 100, 100), 0.5f);
Assert.IsNotNull(lgb);
Assert.AreEqual(1.0f, lgb.InterpolationColors.Positions[2]);
}
public void CloneGradientThemeWithNoDataValues()
{
var colorBlend = new ColorBlend(new[]{Color.Black, Color.White}, new[]{0.0f,1.0f});
var gradientTheme = new GradientTheme("aa", 0, 20, new VectorStyle(), new VectorStyle(), colorBlend,
colorBlend, colorBlend)
{NoDataValues = new List<double>{-9999}};
var gradientThemeClone = gradientTheme.Clone();
Assert.AreEqual(gradientTheme.NoDataValues, ((GradientTheme)gradientThemeClone).NoDataValues);
}
public static CategorialTheme CreateCategorialTheme(string attribute, VectorStyle defaultStyle, ColorBlend blend,
int numberOfClasses, IList<IComparable> values, List<string> categories)
{
if (defaultStyle == null)
{
defaultStyle = new VectorStyle
{
GeometryType = typeof (IPolygon)
};
}
var categorialTheme = new CategorialTheme(attribute, defaultStyle);
for (int i = 0; i < numberOfClasses; i++)
{
string label = (categories != null)
? categories[i]
: values[i].ToString();
Color color = (numberOfClasses > 1)
? blend.GetColor((float) i/(numberOfClasses - 1))
: ((SolidBrush) defaultStyle.Fill).Color;
var vectorStyle = (VectorStyle) defaultStyle.Clone();
if (defaultStyle.GeometryType == typeof(IPoint))
{
vectorStyle.Fill = new SolidBrush(color);
vectorStyle.Line.Width = 16;
vectorStyle.Shape = defaultStyle.Shape;
}
else if ((defaultStyle.GeometryType == typeof(IPolygon)) || (defaultStyle.GeometryType == typeof(IMultiPolygon)))
{
vectorStyle.Fill = new SolidBrush(color);
}
else if ((defaultStyle.GeometryType == typeof(ILineString)) || (defaultStyle.GeometryType == typeof(IMultiLineString)))
{
vectorStyle.Line = new Pen(color, defaultStyle.Line.Width);
}
else
{
vectorStyle.Fill = new SolidBrush(color);
}
CategorialThemeItem categorialThemeItem = (values[i] != null)
? new CategorialThemeItem(label, vectorStyle, vectorStyle.LegendSymbol, values[i])
: new CategorialThemeItem(label, vectorStyle, vectorStyle.LegendSymbol);
categorialTheme.AddThemeItem(categorialThemeItem);
}
return categorialTheme;
}
public void GenerateThemeItems()
{
var colorBlend = new ColorBlend(new[] { Color.Black, Color.White }, new[] { 0.0f, 1.0f });
var gradientTheme = new GradientTheme("aa", 0, 3, new VectorStyle(), new VectorStyle(), colorBlend,
colorBlend, colorBlend,3) { NoDataValues = new List<double> { -9999 } };
//assert 3 items were generated..at 0,1.5 and 3
Assert.AreEqual(3,gradientTheme.ThemeItems.Count);
Assert.AreEqual("0",gradientTheme.ThemeItems[0].Range);
//use toString to make sure the machines decimal separator is used
Assert.AreEqual(1.5.ToString(), gradientTheme.ThemeItems[1].Range);
Assert.AreEqual("3", gradientTheme.ThemeItems[2].Range);
}
public void CloneGradientThemeWithNoDataValues()
{
var colorBlend = new ColorBlend(new[]{Color.Black, Color.White}, new[]{0.0f,1.0f});
var gradientTheme = new GradientTheme("aa", 0, 20, new VectorStyle(), new VectorStyle(), colorBlend,
colorBlend, colorBlend,5)
{NoDataValues = new List<double>{-9999}};
var gradientThemeClone = (GradientTheme)gradientTheme.Clone();
Assert.AreEqual(gradientTheme.NoDataValues, (gradientThemeClone).NoDataValues);
Assert.AreEqual(5,gradientThemeClone.NumberOfClasses);
Assert.AreEqual(2,gradientThemeClone.FillColorBlend.Colors.Length);
}
public static QuantityTheme CreateQuantityTheme(string attribute, VectorStyle defaultStyle, ColorBlend blend,
int numberOfClasses, IList <Interval> intervals, float minSize, float maxSize, bool skipColors, bool skipSizes)
{
if (defaultStyle == null)
{
defaultStyle = new VectorStyle();
defaultStyle.GeometryType = typeof(IPolygon);
}
var quantityTheme = new QuantityTheme(attribute, defaultStyle);
var totalMinValue = (float)intervals[0].Min;
var totalMaxValue = (float)intervals[intervals.Count - 1].Max;
if (totalMinValue == totalMaxValue)
{
return(null);
}
for (int i = 0; i < numberOfClasses; i++)
{
Color color = numberOfClasses > 1
? blend.GetColor(1 - (float)i / (numberOfClasses - 1))
: ((SolidBrush)defaultStyle.Fill).Color;
float size = defaultStyle.Line.Width;
if (!skipSizes)
{
var minValue = (float)intervals[i].Min;
var maxValue = (float)intervals[i].Max;
float width = maxValue - minValue;
float mean = minValue + 0.5f * width;
float fraction = (mean - totalMinValue) / (totalMaxValue - totalMinValue);
size = minSize + fraction * (maxSize - minSize);
}
var vectorStyle = new VectorStyle
{
GeometryType = defaultStyle.GeometryType
};
if (defaultStyle.GeometryType == typeof(IPoint))
{
if (skipColors)
{
color = ((SolidBrush)defaultStyle.Fill).Color;
}
vectorStyle.Fill = new SolidBrush(color);
vectorStyle.Shape = defaultStyle.Shape;
if (!skipSizes)
{
vectorStyle.ShapeSize = Convert.ToInt32(size);
vectorStyle.Line.Width = size;
}
}
else if ((defaultStyle.GeometryType == typeof(IPolygon)) || (defaultStyle.GeometryType == typeof(IMultiPolygon)))
{
if (skipColors)
{
color = ((SolidBrush)defaultStyle.Fill).Color;
}
vectorStyle.Fill = new SolidBrush(color);
vectorStyle.Line = new Pen(color, size);
vectorStyle.Outline.Width = (defaultStyle.Outline.Width - defaultStyle.Line.Width) + size;
}
else if ((defaultStyle.GeometryType == typeof(ILineString)) || (defaultStyle.GeometryType == typeof(IMultiLineString)))
{
if (skipColors)
{
color = defaultStyle.Line.Color;
}
vectorStyle.Line = new Pen(color, size);
vectorStyle.Outline.Width = (defaultStyle.Outline.Width - defaultStyle.Line.Width) + size;
}
else
{
vectorStyle.Fill = new SolidBrush(color);
}
quantityTheme.AddStyle(vectorStyle, intervals[i]);
}
return(quantityTheme);
}
public static QuantityTheme CreateQuantityTheme(string attribute, VectorStyle defaultStyle, ColorBlend blend,
int numberOfClasses, IList <Interval> intervals)
{
float minSize = defaultStyle.Line.Width;
float maxSize = defaultStyle.Line.Width;
return(CreateQuantityTheme(attribute, defaultStyle, blend, numberOfClasses, intervals, minSize, maxSize, false, false));
}
public static GradientTheme CreateGradientTheme(string attribute, VectorStyle defaultStyle, ColorBlend blend,
float minValue, float maxValue, int sizeMin, int sizeMax, bool skipColors, bool skipSizes)
{
return(CreateGradientTheme(attribute, defaultStyle, blend, minValue, maxValue, sizeMin, sizeMax, skipColors,
skipSizes, 8));
}
public static GradientTheme CreateGradientTheme(string attribute, VectorStyle defaultStyle, ColorBlend blend,
float minValue, float maxValue, int sizeMin, int sizeMax, bool skipColors, bool skipSizes, int numberOfClasses)
{
if(defaultStyle == null)
{
defaultStyle = new VectorStyle();
defaultStyle.GeometryType = typeof(IPolygon);
}
Color minColor = (skipColors)? ((SolidBrush) defaultStyle.Fill).Color : blend.GetColor(0);
Color maxColor = (skipColors) ? ((SolidBrush)defaultStyle.Fill).Color : blend.GetColor(1);
var deltaWith = (defaultStyle.Outline.Width - defaultStyle.Line.Width);
float minOutlineSize = deltaWith + sizeMin;
float maxOutlineSize = deltaWith + sizeMax;
// Use default styles if not working with VectorLayers (i.e. RegularGridCoverageLayers)
var minStyle = (VectorStyle) defaultStyle.Clone();
var maxStyle = (VectorStyle) defaultStyle.Clone();
minStyle.GeometryType = defaultStyle.GeometryType;
maxStyle.GeometryType = defaultStyle.GeometryType;
if (defaultStyle.GeometryType == typeof(IPoint))
{
minStyle.Fill = new SolidBrush(minColor);
maxStyle.Fill = new SolidBrush(maxColor);
minStyle.Shape = defaultStyle.Shape;
maxStyle.Shape = defaultStyle.Shape;
if (!skipSizes)
{
minStyle.Line.Width = sizeMin;
maxStyle.Line.Width = sizeMax;
minStyle.ShapeSize = sizeMin;
maxStyle.ShapeSize = sizeMax;
}
}
else if ((defaultStyle.GeometryType == typeof(IPolygon)) || (defaultStyle.GeometryType == typeof(IMultiPolygon)))
{
minStyle.Fill = new SolidBrush(minColor);
maxStyle.Fill = new SolidBrush(maxColor);
minStyle.Outline = new Pen(defaultStyle.Outline.Color, minOutlineSize);
maxStyle.Outline = new Pen(defaultStyle.Outline.Color, maxOutlineSize);
}
else if ((defaultStyle.GeometryType == typeof(ILineString)) || (defaultStyle.GeometryType == typeof(IMultiLineString)))
{
minStyle.Line = new Pen(minColor, sizeMin);
maxStyle.Line = new Pen(maxColor, sizeMax);
minStyle.Outline = new Pen(defaultStyle.Outline.Color, minOutlineSize);
maxStyle.Outline = new Pen(defaultStyle.Outline.Color, maxOutlineSize);
}
else
{
minStyle.Fill = new SolidBrush(minColor);
maxStyle.Fill = new SolidBrush(maxColor);
minStyle.Outline = new Pen(minColor, minOutlineSize);
maxStyle.Outline = new Pen(maxColor, maxOutlineSize);
}
var gradientTheme = new GradientTheme(attribute, minValue, maxValue, minStyle, maxStyle, blend, blend, null, numberOfClasses);
return gradientTheme;
}
protected virtual void GetPreview(Dataset dataset, Size size, Graphics g,
BoundingBox displayBbox, ProjectionInfo mapProjection, Map map)
#endif
{
double[] geoTrans = new double[6];
_gdalDataset.GetGeoTransform(geoTrans);
// not rotated, use faster display method
if ((!_useRotation ||
(geoTrans[1] == 1 && geoTrans[2] == 0 && geoTrans[4] == 0 && Math.Abs(geoTrans[5]) == 1))
&& !_haveSpot && _transform == null)
{
GetNonRotatedPreview(dataset, size, g, displayBbox, mapProjection);
return;
}
// not rotated, but has spot...need default rotation
else if ((geoTrans[0] == 0 && geoTrans[3] == 0) && _haveSpot)
geoTrans = new[] { 999.5, 1, 0, 1000.5, 0, -1 };
_geoTransform = new GeoTransform(geoTrans);
double DsWidth = _imagesize.Width;
double DsHeight = _imagesize.Height;
double left, top, right, bottom;
double GndX = 0, GndY = 0, ImgX = 0, ImgY = 0, PixX, PixY;
double[] intVal = new double[Bands];
double imageVal = 0, SpotVal = 0;
double bitScalar = 1.0;
Bitmap bitmap = null;
Point bitmapTL = new Point(), bitmapBR = new Point();
Geometries.Point imageTL = new Geometries.Point(), imageBR = new Geometries.Point();
BoundingBox shownImageBbox, trueImageBbox;
int bitmapLength, bitmapHeight;
int displayImageLength, displayImageHeight;
int iPixelSize = 3; //Format24bppRgb = byte[b,g,r]
if (dataset != null)
{
//check if image is in bounding box
if ((displayBbox.Left > _envelope.Right) || (displayBbox.Right < _envelope.Left)
|| (displayBbox.Top < _envelope.Bottom) || (displayBbox.Bottom > _envelope.Top))
return;
// init histo
_histogram = new List<int[]>();
for (int i = 0; i < _lbands + 1; i++)
_histogram.Add(new int[256]);
// bounds of section of image to be displayed
left = Math.Max(displayBbox.Left, _envelope.Left);
top = Math.Min(displayBbox.Top, _envelope.Top);
right = Math.Min(displayBbox.Right, _envelope.Right);
bottom = Math.Max(displayBbox.Bottom, _envelope.Bottom);
trueImageBbox = new BoundingBox(left, bottom, right, top);
// put display bounds into current projection
if (_transform != null)
{
#if !DotSpatialProjections
_transform.MathTransform.Invert();
shownImageBbox = GeometryTransform.TransformBox(trueImageBbox, _transform.MathTransform);
_transform.MathTransform.Invert();
#else
shownImageBbox = GeometryTransform.TransformBox(trueImageBbox, _transform.Source, _transform.Target);
#endif
}
else
shownImageBbox = trueImageBbox;
// find min/max x and y pixels needed from image
imageBR.X =
(int)
(Math.Max(_geoTransform.GroundToImage(shownImageBbox.TopLeft).X,
Math.Max(_geoTransform.GroundToImage(shownImageBbox.TopRight).X,
Math.Max(_geoTransform.GroundToImage(shownImageBbox.BottomLeft).X,
_geoTransform.GroundToImage(shownImageBbox.BottomRight).X))) + 1);
imageBR.Y =
(int)
(Math.Max(_geoTransform.GroundToImage(shownImageBbox.TopLeft).Y,
Math.Max(_geoTransform.GroundToImage(shownImageBbox.TopRight).Y,
Math.Max(_geoTransform.GroundToImage(shownImageBbox.BottomLeft).Y,
_geoTransform.GroundToImage(shownImageBbox.BottomRight).Y))) + 1);
imageTL.X =
(int)
Math.Min(_geoTransform.GroundToImage(shownImageBbox.TopLeft).X,
Math.Min(_geoTransform.GroundToImage(shownImageBbox.TopRight).X,
Math.Min(_geoTransform.GroundToImage(shownImageBbox.BottomLeft).X,
_geoTransform.GroundToImage(shownImageBbox.BottomRight).X)));
imageTL.Y =
(int)
Math.Min(_geoTransform.GroundToImage(shownImageBbox.TopLeft).Y,
Math.Min(_geoTransform.GroundToImage(shownImageBbox.TopRight).Y,
Math.Min(_geoTransform.GroundToImage(shownImageBbox.BottomLeft).Y,
_geoTransform.GroundToImage(shownImageBbox.BottomRight).Y)));
// stay within image
if (imageBR.X > _imagesize.Width)
imageBR.X = _imagesize.Width;
if (imageBR.Y > _imagesize.Height)
imageBR.Y = _imagesize.Height;
if (imageTL.Y < 0)
imageTL.Y = 0;
if (imageTL.X < 0)
imageTL.X = 0;
displayImageLength = (int)(imageBR.X - imageTL.X);
displayImageHeight = (int)(imageBR.Y - imageTL.Y);
// find ground coordinates of image pixels
Geometries.Point groundBR = _geoTransform.ImageToGround(imageBR);
Geometries.Point groundTL = _geoTransform.ImageToGround(imageTL);
// convert ground coordinates to map coordinates to figure out where to place the bitmap
bitmapBR = new Point((int)map.WorldToImage(trueImageBbox.BottomRight).X + 1,
(int)map.WorldToImage(trueImageBbox.BottomRight).Y + 1);
bitmapTL = new Point((int)map.WorldToImage(trueImageBbox.TopLeft).X,
(int)map.WorldToImage(trueImageBbox.TopLeft).Y);
bitmapLength = bitmapBR.X - bitmapTL.X;
bitmapHeight = bitmapBR.Y - bitmapTL.Y;
// check to see if image is on its side
if (bitmapLength > bitmapHeight && displayImageLength < displayImageHeight)
{
displayImageLength = bitmapHeight;
displayImageHeight = bitmapLength;
}
else
{
displayImageLength = bitmapLength;
displayImageHeight = bitmapHeight;
}
// scale
if (_bitDepth == 12)
bitScalar = 16.0;
else if (_bitDepth == 16)
bitScalar = 256.0;
else if (_bitDepth == 32)
bitScalar = 16777216.0;
// 0 pixels in length or height, nothing to display
if (bitmapLength < 1 || bitmapHeight < 1)
return;
//initialize bitmap
bitmap = new Bitmap(bitmapLength, bitmapHeight, PixelFormat.Format24bppRgb);
BitmapData bitmapData = bitmap.LockBits(new Rectangle(0, 0, bitmapLength, bitmapHeight),
ImageLockMode.ReadWrite, bitmap.PixelFormat);
try
{
unsafe
{
// turn everything to _noDataInitColor, so we can make fill transparent
byte cr = _noDataInitColor.R;
byte cg = _noDataInitColor.G;
byte cb = _noDataInitColor.B;
for (int y = 0; y < bitmapHeight; y++)
{
byte* brow = (byte*)bitmapData.Scan0 + (y * bitmapData.Stride);
for (int x = 0; x < bitmapLength; x++)
{
Int32 offsetX = x * 3;
brow[offsetX++] = cb;
brow[offsetX++] = cg;
brow[offsetX] = cr;
}
}
// create 3 dimensional buffer [band][x pixel][y pixel]
double[][] tempBuffer = new double[Bands][];
double[][][] buffer = new double[Bands][][];
for (int i = 0; i < Bands; i++)
{
buffer[i] = new double[displayImageLength][];
for (int j = 0; j < displayImageLength; j++)
buffer[i][j] = new double[displayImageHeight];
}
Band[] band = new Band[Bands];
int[] ch = new int[Bands];
//
Double[] noDataValues = new Double[Bands];
Double[] scales = new Double[Bands];
ColorTable colorTable = null;
// get data from image
for (int i = 0; i < Bands; i++)
{
tempBuffer[i] = new double[displayImageLength * displayImageHeight];
band[i] = dataset.GetRasterBand(i + 1);
//get nodata value if present
Int32 hasVal = 0;
band[i].GetNoDataValue(out noDataValues[i], out hasVal);
if (hasVal == 0) noDataValues[i] = Double.NaN;
band[i].GetScale(out scales[i], out hasVal);
if (hasVal == 0) scales[i] = 1.0;
band[i].ReadRaster(
(int)imageTL.X,
(int)imageTL.Y,
(int)(imageBR.X - imageTL.X),
(int)(imageBR.Y - imageTL.Y),
tempBuffer[i], displayImageLength, displayImageHeight, 0, 0);
// parse temp buffer into the image x y value buffer
long pos = 0;
for (int y = 0; y < displayImageHeight; y++)
{
for (int x = 0; x < displayImageLength; x++, pos++)
buffer[i][x][y] = tempBuffer[i][pos];
}
if (band[i].GetRasterColorInterpretation() == ColorInterp.GCI_BlueBand) ch[i] = 0;
else if (band[i].GetRasterColorInterpretation() == ColorInterp.GCI_GreenBand) ch[i] = 1;
else if (band[i].GetRasterColorInterpretation() == ColorInterp.GCI_RedBand) ch[i] = 2;
else if (band[i].GetRasterColorInterpretation() == ColorInterp.GCI_Undefined)
{
if (Bands > 1)
ch[i] = 3; // infrared
else
{
ch[i] = 4;
if (_colorBlend == null)
{
Double dblMin, dblMax;
band[i].GetMinimum(out dblMin, out hasVal);
if (hasVal == 0) dblMin = Double.NaN;
band[i].GetMaximum(out dblMax, out hasVal);
if (hasVal == 0) dblMax = double.NaN;
if (Double.IsNaN(dblMin) || Double.IsNaN(dblMax))
{
double dblMean, dblStdDev;
band[i].GetStatistics(0, 1, out dblMin, out dblMax, out dblMean, out dblStdDev);
//double dblRange = dblMax - dblMin;
//dblMin -= 0.1*dblRange;
//dblMax += 0.1*dblRange;
}
Single[] minmax = new float[] { Convert.ToSingle(dblMin), 0.5f * Convert.ToSingle(dblMin + dblMax), Convert.ToSingle(dblMax) };
Color[] colors = new Color[] { Color.Blue, Color.Yellow, Color.Red };
_colorBlend = new ColorBlend(colors, minmax);
}
intVal = new Double[3];
}
}
else if (band[i].GetRasterColorInterpretation() == ColorInterp.GCI_GrayIndex) ch[i] = 0;
else if (band[i].GetRasterColorInterpretation() == ColorInterp.GCI_PaletteIndex)
{
colorTable = band[i].GetRasterColorTable();
ch[i] = 5;
intVal = new Double[3];
}
else ch[i] = -1;
}
// store these values to keep from having to make slow method calls
int bitmapTLX = bitmapTL.X;
int bitmapTLY = bitmapTL.Y;
double imageTop = imageTL.Y;
double imageLeft = imageTL.X;
double dblMapPixelWidth = map.PixelWidth;
double dblMapPixelHeight = map.PixelHeight;
double dblMapMinX = map.Envelope.Min.X;
double dblMapMaxY = map.Envelope.Max.Y;
double geoTop, geoLeft, geoHorzPixRes, geoVertPixRes, geoXRot, geoYRot;
// get inverse values
geoTop = _geoTransform.Inverse[3];
geoLeft = _geoTransform.Inverse[0];
geoHorzPixRes = _geoTransform.Inverse[1];
geoVertPixRes = _geoTransform.Inverse[5];
geoXRot = _geoTransform.Inverse[2];
geoYRot = _geoTransform.Inverse[4];
double dblXScale = (imageBR.X - imageTL.X) / (displayImageLength - 1);
double dblYScale = (imageBR.Y - imageTL.Y) / (displayImageHeight - 1);
double[] dblPoint;
// get inverse transform
// NOTE: calling transform.MathTransform.Inverse() once and storing it
// is much faster than having to call every time it is needed
#if !DotSpatialProjections
IMathTransform inverseTransform = null;
if (_transform != null)
inverseTransform = _transform.MathTransform.Inverse();
#endif
for (PixY = 0; PixY < bitmapBR.Y - bitmapTL.Y; PixY++)
{
byte* row = (byte*)bitmapData.Scan0 + ((int)Math.Round(PixY) * bitmapData.Stride);
for (PixX = 0; PixX < bitmapBR.X - bitmapTL.X; PixX++)
{
// same as Map.ImageToGround(), but much faster using stored values...rather than called each time
GndX = dblMapMinX + (PixX + bitmapTLX) * dblMapPixelWidth;
GndY = dblMapMaxY - (PixY + bitmapTLY) * dblMapPixelHeight;
// transform ground point if needed
if (_transform != null)
{
#if !DotSpatialProjections
dblPoint = inverseTransform.Transform(new[] { GndX, GndY });
#else
dblPoint = new double[] { GndX, GndY };
Reproject.ReprojectPoints(dblPoint, null, _transform.Source, _transform.Target, 0, 1);
#endif
GndX = dblPoint[0];
GndY = dblPoint[1];
}
// same as GeoTransform.GroundToImage(), but much faster using stored values...
ImgX = (geoLeft + geoHorzPixRes * GndX + geoXRot * GndY);
ImgY = (geoTop + geoYRot * GndX + geoVertPixRes * GndY);
if (ImgX < imageTL.X || ImgX > imageBR.X || ImgY < imageTL.Y || ImgY > imageBR.Y)
continue;
// color correction
for (int i = 0; i < Bands; i++)
{
intVal[i] =
buffer[i][(int)((ImgX - imageLeft) / dblXScale)][
(int)((ImgY - imageTop) / dblYScale)];
imageVal = SpotVal = intVal[i] = intVal[i] / bitScalar;
if (ch[i] == 4)
{
if (imageVal != noDataValues[i])
{
Color color = _colorBlend.GetColor(Convert.ToSingle(imageVal));
intVal[0] = color.B;
intVal[1] = color.G;
intVal[2] = color.R;
//intVal[3] = ce.c4;
}
else
{
intVal[0] = cb;
intVal[1] = cg;
intVal[2] = cr;
}
}
else if (ch[i] == 5 && colorTable != null)
{
if (imageVal != noDataValues[i])
{
ColorEntry ce = colorTable.GetColorEntry(Convert.ToInt32(imageVal));
intVal[0] = ce.c3;
intVal[1] = ce.c2;
intVal[2] = ce.c1;
//intVal[3] = ce.c4;
}
else
{
intVal[0] = cb;
intVal[1] = cg;
intVal[2] = cr;
}
}
else
{
if (_colorCorrect)
{
intVal[i] = ApplyColorCorrection(imageVal, SpotVal, ch[i], GndX, GndY);
// if pixel is within ground boundary, add its value to the histogram
if (ch[i] != -1 && intVal[i] > 0 && (_histoBounds.Bottom >= (int)GndY) &&
_histoBounds.Top <= (int)GndY &&
_histoBounds.Left <= (int)GndX && _histoBounds.Right >= (int)GndX)
{
_histogram[ch[i]][(int)intVal[i]]++;
}
}
if (intVal[i] > 255)
intVal[i] = 255;
}
}
// luminosity
if (_lbands >= 3)
_histogram[_lbands][(int)(intVal[2] * 0.2126 + intVal[1] * 0.7152 + intVal[0] * 0.0722)]
++;
WritePixel(PixX, intVal, iPixelSize, ch, row);
}
}
}
}
finally
{
bitmap.UnlockBits(bitmapData);
}
}
bitmap.MakeTransparent(_noDataInitColor);
if (_transparentColor != Color.Empty)
bitmap.MakeTransparent(_transparentColor);
g.DrawImage(bitmap, new Point(bitmapTL.X, bitmapTL.Y));
}
/// <summary>
/// Creates a <see cref="GradientTheme"/>
/// </summary>
/// <param name="attribute">Name of the feature attribute</param>
/// <param name="defaultStyle">Default <see cref="VectorStyle"/> to base this theme on</param>
/// <param name="blend"><see cref="ColorBlend"/>
/// defining the min and max colors
/// Note: Silently assumes 2 Colors defined
/// </param>
/// <param name="minValue">Minimum value of the feature attribute values</param>
/// <param name="maxValue">Maximum value of the feature attribute values</param>
/// <param name="sizeMin">Minimum line/point size in pixels</param>
/// <param name="sizeMax">Maximum line/point size in pixels</param>
/// <param name="skipColors">Use the min and max colors (false) or the defaultStyle fill color (true)</param>
/// <param name="skipSizes">Let the size of a point depend on the value (false) or use the defaultStyle size (true)</param>
/// <param name="numberOfClasses">The number of classes (ThemeItems) to generate (default = 8)</param>
/// <returns>A new <see cref="GradientTheme"/></returns>
public static GradientTheme CreateGradientTheme(string attribute, VectorStyle defaultStyle, ColorBlend blend,
double minValue, double maxValue, int sizeMin, int sizeMax, bool skipColors, bool skipSizes, int numberOfClasses = 8)
{
if (defaultStyle == null)
{
defaultStyle = new VectorStyle {
GeometryType = typeof(IPolygon)
};
}
Color minColor = (skipColors) ? ((SolidBrush)defaultStyle.Fill).Color : blend.GetColor(0);
Color maxColor = (skipColors) ? ((SolidBrush)defaultStyle.Fill).Color : blend.GetColor(1);
var deltaWidth = (defaultStyle.Outline.Width - defaultStyle.Line.Width);
float minOutlineSize = deltaWidth + sizeMin;
float maxOutlineSize = deltaWidth + sizeMax;
// Use default styles if not working with VectorLayers (i.e. RegularGridCoverageLayers)
var minStyle = (VectorStyle)defaultStyle.Clone();
var maxStyle = (VectorStyle)defaultStyle.Clone();
minStyle.GeometryType = defaultStyle.GeometryType;
maxStyle.GeometryType = defaultStyle.GeometryType;
if (defaultStyle.GeometryType == typeof(IPoint))
{
UpdateMinMaxForPoints(defaultStyle, sizeMin, sizeMax, minStyle, maxStyle, minColor, maxColor, skipSizes);
}
else if ((defaultStyle.GeometryType == typeof(IPolygon)) || (defaultStyle.GeometryType == typeof(IMultiPolygon)))
{
UpdateMinMaxForPolygons(defaultStyle, minStyle, maxStyle, minColor, maxColor, minOutlineSize, maxOutlineSize);
}
else if ((defaultStyle.GeometryType == typeof(ILineString)) || (defaultStyle.GeometryType == typeof(IMultiLineString)))
{
UpdateMinMaxForLineStrings(defaultStyle, sizeMin, sizeMax, minStyle, maxStyle, minColor, maxColor, minOutlineSize, maxOutlineSize, skipSizes);
}
else
{
//use for unknown geometry..
minStyle.Fill = new SolidBrush(minColor);
maxStyle.Fill = new SolidBrush(maxColor);
minStyle.Outline = CreatePen(minColor, minOutlineSize, defaultStyle.Outline);
maxStyle.Outline = CreatePen(maxColor, maxOutlineSize, defaultStyle.Outline);
}
return(new GradientTheme(attribute, minValue, maxValue, minStyle, maxStyle, blend, blend, null, numberOfClasses));
}
public static QuantityTheme CreateQuantityTheme(string attribute, VectorStyle defaultStyle, ColorBlend blend,
int numberOfClasses, IList <IComparable> values, float minSize, float maxSize, bool skipColors, bool skipSizes, QuantityThemeIntervalType intervalType)
{
var intervals = ThemeFactoryHelper.GetIntervalsForNumberOfClasses(values.Select(i => Convert.ToSingle(i)).ToList(),
intervalType, numberOfClasses);
return(CreateQuantityTheme(attribute, defaultStyle, blend, numberOfClasses, intervals, minSize, maxSize, skipColors, skipSizes));
}
/// <summary>
/// Build a list of CSS/XML-like <see cref="ColorBlend"/> objects from a <see cref="GradientTheme"/> <see cref="ColorBlend"/>
/// </summary>
/// <param name="colorBlend">The original <see cref="ColorBlend"/> with colors and positions</param>
/// <returns>An array of object containing a color and position; to be used to store as XML</returns>
private static colorBlend[] CreateBlendsFromTheme(ColorBlend colorBlend)
{
var fillColorBlends = new List<colorBlend>();
for (int i = 0; i < colorBlend.Positions.Length; i++)
{
var fillBlend = new colorBlend();
fillBlend.color = ColorTranslator.ToHtml(colorBlend.Colors[i]);
fillBlend.position = colorBlend.Positions[i];
fillColorBlends.Add(fillBlend);
}
return fillColorBlends.ToArray();
}
public GradientTheme(string attributeName, double minValue, double maxValue, IStyle minStyle, IStyle maxStyle,
ColorBlend fillColorBlend, ColorBlend lineColorBlend, ColorBlend textColorBlend) : this(attributeName, minValue, maxValue, minStyle, maxStyle,
fillColorBlend, lineColorBlend, textColorBlend, 8)
{
}
public static GradientTheme CreateGradientTheme(string attribute, VectorStyle defaultStyle, ColorBlend blend,
float minValue, float maxValue, int sizeMin, int sizeMax, bool skipColors, bool skipSizes, int numberOfClasses)
{
if (defaultStyle == null)
{
defaultStyle = new VectorStyle();
defaultStyle.GeometryType = typeof(IPolygon);
}
Color minColor = (skipColors)? ((SolidBrush)defaultStyle.Fill).Color : blend.GetColor(0);
Color maxColor = (skipColors) ? ((SolidBrush)defaultStyle.Fill).Color : blend.GetColor(1);
var deltaWith = (defaultStyle.Outline.Width - defaultStyle.Line.Width);
float minOutlineSize = deltaWith + sizeMin;
float maxOutlineSize = deltaWith + sizeMax;
// Use default styles if not working with VectorLayers (i.e. RegularGridCoverageLayers)
var minStyle = (VectorStyle)defaultStyle.Clone();
var maxStyle = (VectorStyle)defaultStyle.Clone();
minStyle.GeometryType = defaultStyle.GeometryType;
maxStyle.GeometryType = defaultStyle.GeometryType;
if (defaultStyle.GeometryType == typeof(IPoint))
{
minStyle.Fill = new SolidBrush(minColor);
maxStyle.Fill = new SolidBrush(maxColor);
minStyle.Shape = defaultStyle.Shape;
maxStyle.Shape = defaultStyle.Shape;
if (!skipSizes)
{
minStyle.Line.Width = sizeMin;
maxStyle.Line.Width = sizeMax;
minStyle.ShapeSize = sizeMin;
maxStyle.ShapeSize = sizeMax;
}
}
else if ((defaultStyle.GeometryType == typeof(IPolygon)) || (defaultStyle.GeometryType == typeof(IMultiPolygon)))
{
minStyle.Fill = new SolidBrush(minColor);
maxStyle.Fill = new SolidBrush(maxColor);
minStyle.Outline = new Pen(defaultStyle.Outline.Color, minOutlineSize);
maxStyle.Outline = new Pen(defaultStyle.Outline.Color, maxOutlineSize);
}
else if ((defaultStyle.GeometryType == typeof(ILineString)) || (defaultStyle.GeometryType == typeof(IMultiLineString)))
{
minStyle.Line = new Pen(minColor, sizeMin);
maxStyle.Line = new Pen(maxColor, sizeMax);
minStyle.Outline = new Pen(defaultStyle.Outline.Color, minOutlineSize);
maxStyle.Outline = new Pen(defaultStyle.Outline.Color, maxOutlineSize);
}
else
{
minStyle.Fill = new SolidBrush(minColor);
maxStyle.Fill = new SolidBrush(maxColor);
minStyle.Outline = new Pen(minColor, minOutlineSize);
maxStyle.Outline = new Pen(maxColor, maxOutlineSize);
}
var gradientTheme = new GradientTheme(attribute, minValue, maxValue, minStyle, maxStyle, blend, blend, null, numberOfClasses);
return(gradientTheme);
}
private ColorBlend GetColorBlend(Band band)
{
if (_colorBlend != null)
return _colorBlend;
int hasVal;
//Get minimum raster value
double dblMin;
band.GetMinimum(out dblMin, out hasVal);
if (hasVal == 0) dblMin = Double.NaN;
//Get maximum raster value
double dblMax;
band.GetMaximum(out dblMax, out hasVal);
if (hasVal == 0) dblMax = double.NaN;
if (double.IsNaN(dblMin) || double.IsNaN(dblMax))
return null;
double dblMean, dblStdDev;
band.GetStatistics(0, 1, out dblMin, out dblMax, out dblMean,
out dblStdDev);
// ToDo: Colorblend positions
var minmax = new[]
{
Convert.ToSingle(dblMin),
0.5f*Convert.ToSingle(dblMin + dblMax),
Convert.ToSingle(dblMax)
};
_colorBlend = new ColorBlend(new[] { Color.Blue, Color.Yellow, Color.Red }, minmax);
return _colorBlend;
}
public static CategorialTheme CreateCategorialTheme(string attribute, VectorStyle defaultStyle, ColorBlend blend,
int numberOfClasses, IList <IComparable> values, List <string> categories)
{
if (defaultStyle == null)
{
defaultStyle = new VectorStyle
{
GeometryType = typeof(IPolygon)
};
}
var categorialTheme = new CategorialTheme(attribute, defaultStyle);
for (int i = 0; i < numberOfClasses; i++)
{
string label = (categories != null)
? categories[i]
: values[i].ToString();
Color color = (numberOfClasses > 1)
? blend.GetColor((float)i / (numberOfClasses - 1))
: ((SolidBrush)defaultStyle.Fill).Color;
var vectorStyle = (VectorStyle)defaultStyle.Clone();
if (defaultStyle.GeometryType == typeof(IPoint))
{
vectorStyle.Fill = new SolidBrush(color);
vectorStyle.Line.Width = 16;
vectorStyle.Shape = defaultStyle.Shape;
}
else if ((defaultStyle.GeometryType == typeof(IPolygon)) || (defaultStyle.GeometryType == typeof(IMultiPolygon)))
{
vectorStyle.Fill = new SolidBrush(color);
}
else if ((defaultStyle.GeometryType == typeof(ILineString)) || (defaultStyle.GeometryType == typeof(IMultiLineString)))
{
vectorStyle.Line = new Pen(color, defaultStyle.Line.Width);
}
else
{
vectorStyle.Fill = new SolidBrush(color);
}
CategorialThemeItem categorialThemeItem = (values[i] != null)
? new CategorialThemeItem(label, vectorStyle, vectorStyle.LegendSymbol, values[i])
: new CategorialThemeItem(label, vectorStyle, vectorStyle.LegendSymbol);
categorialTheme.AddThemeItem(categorialThemeItem);
}
return(categorialTheme);
}
public static QuantityTheme CreateQuantityTheme(string attribute, VectorStyle defaultStyle, ColorBlend blend,
int numberOfClasses, IList<Interval> intervals)
{
float minSize = defaultStyle.Line.Width;
float maxSize = defaultStyle.Line.Width;
return CreateQuantityTheme(attribute, defaultStyle, blend, numberOfClasses, intervals, minSize, maxSize, false, false);
}
public void GradientThemeScaleToWithColorBlends()
{
var blend = new ColorBlend(new[]{Color.Black, Color.White}, new[]{0f, 1f});
var theme = ThemeFactory.CreateGradientTheme("", null, blend, 0.0, 5.0, 3, 3, false, true, 3);
AssertColor(Color.Black, theme.GetFillColor(-1.0));
AssertColor(Color.Black, theme.GetFillColor(0.0));
AssertColor(Color.FromArgb(255, 64, 64, 64), theme.GetFillColor(1.25));
AssertColor(Color.FromArgb(255, 128, 128, 128), theme.GetFillColor(2.5));
AssertColor(Color.FromArgb(255, 191, 191, 191), theme.GetFillColor(3.75));
AssertColor(Color.White, theme.GetFillColor(5.0));
AssertColor(Color.White, theme.GetFillColor(6.0));
theme.ScaleTo(-2.0, 1.0);
AssertColor(Color.Black, theme.GetFillColor(-3.0));
AssertColor(Color.Black, theme.GetFillColor(-2.0));
AssertColor(Color.FromArgb(255, 64, 64, 64), theme.GetFillColor(-1.25));
AssertColor(Color.FromArgb(255, 128, 128, 128), theme.GetFillColor(-0.5));
AssertColor(Color.FromArgb(255, 191, 191, 191), theme.GetFillColor(0.25));
AssertColor(Color.White, theme.GetFillColor(1.0));
AssertColor(Color.White, theme.GetFillColor(2.0));
}
public static QuantityTheme CreateQuantityTheme(string attribute, VectorStyle defaultStyle, ColorBlend blend,
int numberOfClasses, IList<Interval> intervals, float minSize, float maxSize, bool skipColors, bool skipSizes)
{
if (defaultStyle == null)
{
defaultStyle = new VectorStyle();
defaultStyle.GeometryType = typeof(IPolygon);
}
var quantityTheme = new QuantityTheme(attribute, defaultStyle);
var totalMinValue = (float) intervals[0].Min;
var totalMaxValue = (float) intervals[intervals.Count - 1].Max;
if (totalMinValue == totalMaxValue)
{
return null;
}
for (int i = 0; i < numberOfClasses; i++)
{
Color color = numberOfClasses > 1
? blend.GetColor(1 - (float) i/(numberOfClasses - 1))
: ((SolidBrush) defaultStyle.Fill).Color;
float size = defaultStyle.Line.Width;
if (!skipSizes)
{
var minValue = (float) intervals[i].Min;
var maxValue = (float) intervals[i].Max;
float width = maxValue - minValue;
float mean = minValue + 0.5f * width;
float fraction = (mean - totalMinValue) / (totalMaxValue - totalMinValue);
size = minSize + fraction * (maxSize - minSize);
}
var vectorStyle = new VectorStyle
{
GeometryType = defaultStyle.GeometryType
};
if (defaultStyle.GeometryType == typeof(IPoint))
{
if (skipColors)
{
color = ((SolidBrush)defaultStyle.Fill).Color;
}
vectorStyle.Fill = new SolidBrush(color);
vectorStyle.Shape = defaultStyle.Shape;
if (!skipSizes)
{
vectorStyle.ShapeSize = Convert.ToInt32(size);
vectorStyle.Line.Width = size;
}
}
else if ((defaultStyle.GeometryType == typeof(IPolygon)) || (defaultStyle.GeometryType == typeof(IMultiPolygon)))
{
if (skipColors)
{
color = ((SolidBrush)defaultStyle.Fill).Color;
}
vectorStyle.Fill = new SolidBrush(color);
vectorStyle.Line = new Pen(color, size);
vectorStyle.Outline.Width = (defaultStyle.Outline.Width - defaultStyle.Line.Width) + size;
}
else if ((defaultStyle.GeometryType == typeof(ILineString)) || (defaultStyle.GeometryType == typeof(IMultiLineString)))
{
if (skipColors)
{
color = defaultStyle.Line.Color;
}
vectorStyle.Line = new Pen(color, size);
vectorStyle.Outline.Width = (defaultStyle.Outline.Width - defaultStyle.Line.Width) + size;
}
else
{
vectorStyle.Fill = new SolidBrush(color);
}
quantityTheme.AddStyle(vectorStyle, intervals[i]);
}
return quantityTheme;
}
private void GetNonRotatedPreview(Dataset dataset, Size size, Graphics g,
Envelope bbox, ProjectionInfo mapProjection)
#endif
{
double[] geoTrans = new double[6];
dataset.GetGeoTransform(geoTrans);
// default transform
if (!_useRotation && !HaveSpot || (geoTrans[0] == 0 && geoTrans[3] == 0))
geoTrans = new[] { 999.5, 1, 0, 1000.5, 0, -1 };
Bitmap bitmap = null;
var geoTransform = new GeoTransform(geoTrans);
int DsWidth = 0;
int DsHeight = 0;
BitmapData bitmapData = null;
double[] intVal = new double[Bands];
int p_indx;
double bitScalar = 1.0;
double dblImginMapW = 0, dblImginMapH = 0, dblLocX = 0, dblLocY = 0;
int iPixelSize = 3; //Format24bppRgb = byte[b,g,r]
if (dataset != null)
{
//check if image is in bounding box
if ((bbox.MinX > _envelope.MaxX) || (bbox.MaxX < _envelope.MinX)
|| (bbox.MaxY < _envelope.MinY) || (bbox.MinY > _envelope.MaxY))
return;
DsWidth = _imageSize.Width;
DsHeight = _imageSize.Height;
Histogram = new List<int[]>();
for (int i = 0; i < Bands + 1; i++)
Histogram.Add(new int[256]);
double left = Math.Max(bbox.MinX, _envelope.MinX);
double top = Math.Min(bbox.MaxY, _envelope.MaxY);
double right = Math.Min(bbox.MaxX, _envelope.MaxX);
double bottom = Math.Max(bbox.MinY, _envelope.MinY);
double x1 = Math.Abs(geoTransform.PixelX(left));
double y1 = Math.Abs(geoTransform.PixelY(top));
double imgPixWidth = geoTransform.PixelXwidth(right - left);
double imgPixHeight = geoTransform.PixelYwidth(bottom - top);
//get screen pixels image should fill
double dblBBoxW = bbox.Width;
double dblBBoxtoImgPixX = imgPixWidth / dblBBoxW;
dblImginMapW = size.Width * dblBBoxtoImgPixX * geoTransform.HorizontalPixelResolution;
double dblBBoxH = bbox.Height;
double dblBBoxtoImgPixY = imgPixHeight / dblBBoxH;
dblImginMapH = size.Height * dblBBoxtoImgPixY * -geoTransform.VerticalPixelResolution;
if ((dblImginMapH == 0) || (dblImginMapW == 0))
return;
// ratios of bounding box to image ground space
double dblBBoxtoImgX = size.Width / dblBBoxW;
double dblBBoxtoImgY = size.Height / dblBBoxH;
// set where to display bitmap in Map
if (bbox.MinX != left)
{
if (bbox.MaxX != right)
dblLocX = (_envelope.MinX - bbox.MinX) * dblBBoxtoImgX;
else
dblLocX = size.Width - dblImginMapW;
}
if (bbox.MaxY != top)
{
if (bbox.MinY != bottom)
dblLocY = (bbox.MaxY - _envelope.MaxY) * dblBBoxtoImgY;
else
dblLocY = size.Height - dblImginMapH;
}
bitScalar = GetBitScalar();
try
{
bitmap = new Bitmap((int)Math.Round(dblImginMapW), (int)Math.Round(dblImginMapH),
PixelFormat.Format24bppRgb);
bitmapData =
bitmap.LockBits(
new Rectangle(0, 0, (int)Math.Round(dblImginMapW), (int)Math.Round(dblImginMapH)),
ImageLockMode.ReadWrite, bitmap.PixelFormat);
byte cr = _noDataInitColor.R;
byte cg = _noDataInitColor.G;
byte cb = _noDataInitColor.B;
//
Double[] noDataValues = new Double[Bands];
Double[] scales = new Double[Bands];
ColorTable colorTable = null;
unsafe
{
double[][] buffer = new double[Bands][];
Band[] band = new Band[Bands];
int[] ch = new int[Bands];
// get data from image
for (int i = 0; i < Bands; i++)
{
buffer[i] = new double[(int)Math.Round(dblImginMapW) * (int)Math.Round(dblImginMapH)];
band[i] = dataset.GetRasterBand(i + 1);
//get nodata value if present
Int32 hasVal = 0;
band[i].GetNoDataValue(out noDataValues[i], out hasVal);
if (hasVal == 0) noDataValues[i] = Double.NaN;
band[i].GetScale(out scales[i], out hasVal);
if (hasVal == 0) scales[i] = 1.0;
band[i].ReadRaster((int)Math.Round(x1), (int)Math.Round(y1), (int)Math.Round(imgPixWidth),
(int)Math.Round(imgPixHeight),
buffer[i], (int)Math.Round(dblImginMapW), (int)Math.Round(dblImginMapH),
0, 0);
switch (band[i].GetRasterColorInterpretation())
{
case ColorInterp.GCI_BlueBand:
ch[i] = 0;
break;
case ColorInterp.GCI_GreenBand:
ch[i] = 1;
break;
case ColorInterp.GCI_RedBand:
ch[i] = 2;
break;
case ColorInterp.GCI_Undefined:
if (Bands > 1)
ch[i] = 3; // infrared
else
{
ch[i] = 4;
if (_colorBlend == null)
{
Double dblMin, dblMax;
band[i].GetMinimum(out dblMin, out hasVal);
if (hasVal == 0) dblMin = Double.NaN;
band[i].GetMaximum(out dblMax, out hasVal);
if (hasVal == 0) dblMax = double.NaN;
if (Double.IsNaN(dblMin) || Double.IsNaN(dblMax))
{
double dblMean, dblStdDev;
band[i].GetStatistics(0, 1, out dblMin, out dblMax, out dblMean, out dblStdDev);
//double dblRange = dblMax - dblMin;
//dblMin -= 0.1*dblRange;
//dblMax += 0.1*dblRange;
}
Single[] minmax = new float[] { Convert.ToSingle(dblMin), 0.5f * Convert.ToSingle(dblMin + dblMax), Convert.ToSingle(dblMax) };
Color[] colors = new Color[] { Color.Blue, Color.Yellow, Color.Red };
_colorBlend = new ColorBlend(colors, minmax);
}
intVal = new Double[3];
}
break;
case ColorInterp.GCI_GrayIndex:
ch[i] = 0;
break;
case ColorInterp.GCI_PaletteIndex:
colorTable = band[i].GetRasterColorTable();
ch[i] = 5;
intVal = new Double[3];
break;
default:
ch[i] = -1;
break;
}
}
if (BitDepth == 32)
ch = new[] { 0, 1, 2 };
p_indx = 0;
for (int y = 0; y < Math.Round(dblImginMapH); y++)
{
byte* row = (byte*)bitmapData.Scan0 + (y * bitmapData.Stride);
for (int x = 0; x < Math.Round(dblImginMapW); x++, p_indx++)
{
for (int i = 0; i < Bands; i++)
{
intVal[i] = buffer[i][p_indx]/bitScalar;
Double imageVal = intVal[i] = intVal[i]/bitScalar;
if (ch[i] == 4)
{
if (imageVal != noDataValues[i])
{
Color color = _colorBlend.GetColor(Convert.ToSingle(imageVal));
intVal[0] = color.B;
intVal[1] = color.G;
intVal[2] = color.R;
//intVal[3] = ce.c4;
}
else
{
intVal[0] = cb;
intVal[1] = cg;
intVal[2] = cr;
}
}
else if (ch[i] == 5 && colorTable != null)
{
if (imageVal != noDataValues[i])
{
ColorEntry ce = colorTable.GetColorEntry(Convert.ToInt32(imageVal));
intVal[0] = ce.c3;
intVal[1] = ce.c2;
intVal[2] = ce.c1;
//intVal[3] = ce.c4;
}
else
{
intVal[0] = cb;
intVal[1] = cg;
intVal[2] = cr;
}
}
else
{
if (ColorCorrect)
{
intVal[i] = ApplyColorCorrection(intVal[i], 0, ch[i], 0, 0);
if (Bands >= 3)
Histogram[Bands][
(int) (intVal[2]*0.2126 + intVal[1]*0.7152 + intVal[0]*0.0722)]++;
}
}
if (intVal[i] > 255)
intVal[i] = 255;
}
WritePixel(x, intVal, iPixelSize, ch, row);
}
}
}
}
catch
{
return;
}
finally
{
if (bitmapData != null)
bitmap.UnlockBits(bitmapData);
}
}
if (TransparentColor != Color.Empty)
bitmap.MakeTransparent(TransparentColor);
g.DrawImage(bitmap, new Point((int)Math.Round(dblLocX), (int)Math.Round(dblLocY)));
}
public static GradientTheme CreateGradientTheme(string attribute, VectorStyle defaultStyle, ColorBlend blend,
float minValue, float maxValue, int sizeMin, int sizeMax, bool skipColors, bool skipSizes)
{
return CreateGradientTheme(attribute, defaultStyle, blend, minValue, maxValue, sizeMin, sizeMax, skipColors,
skipSizes, 8);
}