public override void Apply(MagickImage image)
{
if (Radius == 0 && Threshold == 0)
{
return;
}
var mask = (MagickImage)image.Clone();
mask.ColorSpace = ColorSpace.Gray;
mask.ReduceNoise(10);
mask.Threshold(new Percentage(Threshold));
// mask.Sharpen();
// mask.Blur(5, 5);
mask.Negate();
mask.Write(Path.Combine(Paths.ResourcesPath(Engine.Engine.project), "Mask.png"));
image.SetWriteMask(mask);
image.Blur(0, Radius);
image.RemoveWriteMask();
// Debug.Log(Path.Combine(Paths.ResourcesPath(Engine.Engine.project)));
image.Write(Path.Combine(Paths.ResourcesPath(Engine.Engine.project), "custom.png"));
// var clone = image.Clone();
// clone.SelectiveBlur(0, Radius, new Percentage(Threshold));
// clone.Write(Path.Combine(Paths.ResourcesPath(Engine.Engine.project), "selective.png"));
}
private void ApplyBlur(MagickImage image)
{
if (Blur != 0)
{
image.Blur(0, Blur);
}
}
public static void TiledText()
{
// Dynamic label height
using (MagickImageCollection images = new MagickImageCollection())
{
// Read the image you want to put a label on.
MagickImage logo = new MagickImage("radial-gradient:green-yellow", 400, 175);
logo.Lower(8);
images.Add(logo);
MagickImage label = new MagickImage();
label.BackgroundColor = new MagickColor();
label.Settings.FontPointsize = 70;
label.Read("caption:Magick.NET is coming for you tinight");
label.Scale(logo.Width, logo.Height);
// Resize the label to the width of the image and place the text in the center
label.Extent(logo.Width, logo.Height, Gravity.Center);
images.Add(label);
// Append the images
using (MagickImage output = images.Flatten())
{
output.Alpha(AlphaOption.Set);
output.Transparent(new MagickColor(System.Drawing.Color.White));
output.Blur(0, 8);
output.Threshold((Percentage)50);
///output.Polaroid("", 2, PixelInterpolateMethod.Bilinear);
output.Write("output-b.png");
}
}
}
public void Process()
{
using (var bg = new MagickImage(MagickColor.FromRgba(255, 255, 255, 255), width, height))
{
using (var image = new MagickImage(input))
{
if (image.HasAlpha == false)
{
image.Alpha(AlphaOption.Opaque);
}
using (var cover = image.Clone())
{
MagickGeometry resize = new MagickGeometry(width + "x" + height + "^");
image.Resize(resize);
image.Extent(width, height, Gravity.Center);
image.Blur(80, 30);
bg.Composite(image, 0, 0, CompositeOperator.Over);
MagickGeometry centerResize = new MagickGeometry(height * 0.7 + "x" + height * 0.7);
cover.Resize(centerResize);
using (var coverShadow = cover.Clone())
{
coverShadow.BackgroundColor = MagickColor.FromRgba(192, 192, 192, 192);
coverShadow.Shadow(50, 50, 10, new Percentage(90));
bg.Composite(coverShadow, Gravity.Center, CompositeOperator.Over);
}
bg.Composite(cover, Gravity.Center, CompositeOperator.Over);
}
}
bg.Write(output);
}
}
public override void Apply(MagickImage image)
{
if (Radius > 0)
{
image.Blur(0, Radius);
}
}
private MagickImage NormalsMap(MagickImage textLayer, string backgroundFile, bool previewMode)
{
var image = LoadImage(backgroundFile).Clone();
if (image.Width != textLayer.Width || image.Height != textLayer.Height)
{
image.Resize(textLayer.Width, textLayer.Height);
}
using (var summaryLayer = GetNormalsMapLayer(textLayer)) {
if (!previewMode)
{
using (var blurredLayer = new MagickImage(summaryLayer)) {
blurredLayer.Blur(12, 6);
image.Composite(blurredLayer, 0, 0, CompositeOperator.Overlay);
}
using (var textFlatten = new MagickImage(textLayer)) {
textFlatten.Colorize(new MagickColor("#8080ff"), new Percentage(100));
image.Composite(textFlatten, 0, 0, CompositeOperator.Over);
}
}
image.Composite(summaryLayer, 0, 0, CompositeOperator.Overlay);
if (!previewMode)
{
NormalizeNormalsMap(image, 1.0);
}
}
return(image);
}
private static void DrawBevel(MagickImage image, MagickImage textLayer, double lightDirection)
{
using (var bevelLayer = new MagickImage(MagickColors.White, textLayer.Width, textLayer.Height)) {
bevelLayer.Composite(textLayer, 0, 0, CompositeOperator.Over);
bevelLayer.Shade(lightDirection, 30);
bevelLayer.Blur(10, 6);
image.Composite(bevelLayer, 0, 0, CompositeOperator.LinearLight);
}
}
public Bitmap EdgeDetect(Bitmap myBitmap, float r, float s)
{
using (MagickImage image = new MagickImage(myBitmap))
{
image.ReduceNoise();
image.Blur(r, s);
image.CannyEdge();
return(image.ToBitmap());
}
}
public override void Apply(MagickImage image)
{
using var noise = new MagickImage(MagickColors.Black, image.Width, image.Height);
noise.AddNoise(NoiseType.Random);
noise.VirtualPixelMethod = VirtualPixelMethod.Tile;
noise.Blur(0, 5);
noise.AutoLevel();
var green = noise.Separate(Channels.Green).First();
image.Composite(green, CompositeOperator.SrcOver);
}
public void ApplyFilter(IFilter filter)
{
ThrowIfDisposed();
switch (filter)
{
case Blur blur:
_native.Blur(0.0, blur.Sigma);
break;
default:
throw new InternalImageException("not_supported_filter", $"Filter {filter} is not supported by imagemagick provider.");
}
}
public void BlurBoxes(BBOXES boxes)
{
foreach (var rect in boxes.ToMagikGeometry())
{
if (rect.X >= 0 && rect.Y >= 0 && rect.Width > 0 && rect.Height > 0)
{
using (var crop_clone = new MagickImage(_current.ToByteArray()))
{
crop_clone.Crop(rect);
crop_clone.Blur();
_current.Composite(crop_clone, rect.X, rect.Y, CompositeOperator.Over);
}
}
}
}
public override void Apply(MagickImage image)
{
var height = image.Height;
var viewPortHeight = Height / 100.0 * height;
var topGradientHeight = (int)((Offset / 100 * height) - (viewPortHeight / 2));
var bottomGradientHeight = (int)(((100 - Offset) / 100 * height) - (viewPortHeight / 2));
var mask = Mask(image.Width, image.Height, topGradientHeight, bottomGradientHeight);
image.BrightnessContrast(new Percentage(0), new Percentage(Contrast));
image.Modulate(new Percentage(100), new Percentage(Saturation), new Percentage(300));
image.Sharpen(Sharpness, Sharpness);
image.SetWriteMask(mask);
image.Blur(0, Blur);
}
private void CopyOpacity(MagickImage image)
{
image.Alpha(AlphaOption.Off);
using (MagickImage gray = image.Clone())
{
gray.ColorSpace = ColorSpace.Gray;
gray.Negate();
gray.AdaptiveThreshold(FilterSize, FilterSize, FilterOffset);
gray.ContrastStretch((Percentage)0);
if (Threshold.HasValue)
{
gray.Blur((double)Threshold.Value / 100.0, Quantum.Max);
gray.Level(Threshold.Value, new Percentage(100));
}
image.Composite(gray, CompositeOperator.CopyAlpha);
image.Opaque(MagickColor.Transparent, BackgroundColor);
image.Alpha(AlphaOption.Off);
}
}
private void RemoveNoise(MagickImage image)
{
using (MagickImage second = image.Clone())
{
second.ColorSpace = ColorSpace.Gray;
second.Negate();
second.AdaptiveThreshold(FilterSize, FilterSize, FilterOffset);
second.ContrastStretch((Percentage)0);
if (SmoothingThreshold != null)
{
second.Blur(SmoothingThreshold.Value.ToDouble() / 100, Quantum.Max);
second.Level(SmoothingThreshold.Value, new Percentage(100));
}
image.Composite(second, CompositeOperator.CopyAlpha);
}
image.Opaque(MagickColor.FromRgba(255, 255, 255, 0), BackgroundColor);
image.Alpha(AlphaOption.Off);
}
public void ShouldBlurTheImage()
{
using (var gaussian = new MagickImage(Files.Builtin.Wizard))
{
gaussian.GaussianBlur(5.5, 10.2);
using (var blur = new MagickImage(Files.Builtin.Wizard))
{
blur.Blur(5.5, 10.2);
double distortion = blur.Compare(gaussian, ErrorMetric.RootMeanSquared);
#if Q8
Assert.InRange(distortion, 0.00066, 0.00067);
#elif Q16
Assert.InRange(distortion, 0.0000033, 0.0000034);
#else
Assert.InRange(distortion, 0.0000011, 0.0000012);
#endif
}
}
}
private void DrawTreeCluster(MagickImage overlay, DrawableFixture fixture)
{
//MainForm.Log(string.Format("Image: {0} ({1}) ...", fixture.Name, fixture.TreeCluster.Tree), MainForm.LogLevel.notice);
string fileName = System.IO.Path.GetFileNameWithoutExtension(fixture.TreeCluster.Tree);
string defaultTree = "elm1";
// Load model image
if (!m_modelImages.ContainsKey(fileName))
{
string treeImageFile = string.Format("{0}\\data\\prerendered\\trees\\{1}.png", System.Windows.Forms.Application.StartupPath, fileName);
if (System.IO.File.Exists(treeImageFile))
{
MagickImage modelImage = new MagickImage(treeImageFile);
modelImage.Blur();
m_modelImages.Add(fileName, modelImage);
}
else
{
MainForm.Log(string.Format("Can not find image for tree {0} ({1}), using default tree", fixture.TreeCluster.Tree, fixture.NifName), MainForm.LogLevel.warning);
m_modelImages.Add(fileName, m_modelImages[defaultTree]);
}
}
if (m_modelImages.ContainsKey(fileName) && m_modelImages[fileName] != null)
{
// Get the width of the orginal tree shape
NifRow tree = FixturesLoader.NifRows.Where(n => n.Filename.ToLower() == fixture.TreeCluster.Tree.ToLower()).FirstOrDefault();
if (tree == null)
{
return;
}
System.Drawing.SizeF treeSize = tree.GetSize(0, 0);
int dimensions = ((fixture.CanvasWidth > fixture.CanvasHeight) ? fixture.CanvasWidth : fixture.CanvasHeight) + 10;
int extendedWidth = dimensions - fixture.CanvasWidth;
int extendedHeight = dimensions - fixture.CanvasHeight;
using (MagickImage treeCluster = new MagickImage(MagickColors.Transparent, dimensions, dimensions))
{
double centerX = treeCluster.Width / 2d;
double centerY = treeCluster.Height / 2d;
foreach (SharpDX.Vector3 treeInstance in fixture.TreeCluster.TreeInstances)
{
using (IMagickImage treeImage = m_modelImages[fileName].Clone())
{
double scaleWidthToTreeImage = treeSize.Width / treeImage.Width;
double scaleHeightToTreeImage = treeSize.Height / treeImage.Height;
int width = Convert.ToInt32(treeImage.Width * scaleWidthToTreeImage * fixture.Scale);
int height = Convert.ToInt32(treeImage.Height * scaleHeightToTreeImage * fixture.Scale);
treeImage.Resize(width, height);
int x = Convert.ToInt32(centerX - width / 2d - zoneConfiguration.ZoneCoordinateToMapCoordinate(treeInstance.X) * (fixture.FixtureRow.Scale / 100));
int y = Convert.ToInt32(centerY - height / 2d - zoneConfiguration.ZoneCoordinateToMapCoordinate(treeInstance.Y) * (fixture.FixtureRow.Scale / 100));
treeCluster.Composite(treeImage, x, y, CompositeOperator.SrcOver);
}
}
treeCluster.Rotate((360d * fixture.FixtureRow.AxisZ3D - fixture.FixtureRow.A) * -1);
using (MagickImage modelCanvas = new MagickImage(MagickColors.Transparent, fixture.CanvasWidth, fixture.CanvasHeight))
{
foreach (DrawableElement drawableElement in fixture.DrawableElements)
{
modelCanvas.Settings.FillColor = new MagickColor(
Convert.ToUInt16(128 * 256 * drawableElement.lightning),
Convert.ToUInt16(128 * 256 * drawableElement.lightning),
Convert.ToUInt16(128 * 256 * drawableElement.lightning)
);
DrawablePolygon polyDraw = new DrawablePolygon(drawableElement.coordinates);
modelCanvas.Draw(polyDraw);
}
modelCanvas.Composite(treeCluster, Gravity.Center, CompositeOperator.DstIn);
treeCluster.Composite(modelCanvas, Gravity.Center, CompositeOperator.Overlay);
//treeCluster.Composite(modelCanvas, Gravity.Center, CompositeOperator.SrcOver);
}
if (fixture.RendererConf.HasShadow)
{
CastShadow(
treeCluster,
fixture.RendererConf.ShadowOffsetX,
fixture.RendererConf.ShadowOffsetY,
fixture.RendererConf.ShadowSize,
new Percentage(100 - fixture.RendererConf.ShadowTransparency),
fixture.RendererConf.ShadowColor,
false
);
}
if (fixture.RendererConf.Transparency != 0)
{
treeCluster.Alpha(AlphaOption.Set);
double divideValue = 100.0 / (100.0 - fixture.RendererConf.Transparency);
treeCluster.Evaluate(Channels.Alpha, EvaluateOperator.Divide, divideValue);
}
overlay.Composite(treeCluster, Convert.ToInt32(fixture.CanvasX - extendedWidth / 2), Convert.ToInt32(fixture.CanvasY - extendedHeight / 2), CompositeOperator.SrcOver);
}
}
}
private void DrawImage(MagickImage overlay, DrawableFixture fixture)
{
//MainForm.Log(string.Format("Image: {0} ({1}) ...", fixture.Name, fixture.NifName), MainForm.LogLevel.notice);
string fileName = System.IO.Path.GetFileNameWithoutExtension(fixture.NifName);
string defaultTree = "elm1";
// Load default tree
if (!m_modelImages.ContainsKey(defaultTree))
{
string defaultTreeImage = string.Format("{0}\\data\\prerendered\\trees\\{1}.png", System.Windows.Forms.Application.StartupPath, defaultTree);
if (System.IO.File.Exists(defaultTreeImage))
{
MagickImage treeImage = new MagickImage(defaultTreeImage);
treeImage.Blur();
m_modelImages.Add(defaultTree, treeImage);
}
else
{
m_modelImages.Add(fileName, null);
}
}
// TreeClusters are sets of trees in a specified arrangement
// They need to be drawe separately
if (fixture.IsTreeCluster)
{
DrawTreeCluster(overlay, fixture);
return;
}
// Load model image
if (!m_modelImages.ContainsKey(fileName))
{
string objectImageFile = string.Format("{0}\\data\\prerendered\\objects\\{1}.png", System.Windows.Forms.Application.StartupPath, fileName);
if (fixture.IsTree)
{
objectImageFile = string.Format("{0}\\data\\prerendered\\trees\\{1}.png", System.Windows.Forms.Application.StartupPath, fileName);
}
if (System.IO.File.Exists(objectImageFile))
{
MagickImage objectImage = new MagickImage(objectImageFile);
if (fixture.IsTree)
{
objectImage.Blur();
}
m_modelImages.Add(fileName, objectImage);
}
else
{
if (fixture.IsTree)
{
MainForm.Log(string.Format("Can not find image for tree {0} ({1}), using default tree", fixture.Name, fixture.NifName), MainForm.LogLevel.warning);
m_modelImages.Add(fileName, m_modelImages[defaultTree]);
}
else
{
m_modelImages.Add(fileName, null);
}
}
}
// Draw the image
if (m_modelImages.ContainsKey(fileName) && m_modelImages[fileName] != null)
{
NifRow orginalNif = FixturesLoader.NifRows.Where(n => n.NifId == fixture.FixtureRow.NifId).FirstOrDefault();
if (orginalNif == null)
{
MainForm.Log(string.Format("Error with imaged nif ({0})!", fixture.FixtureRow.TextualName), MainForm.LogLevel.warning);
}
System.Drawing.SizeF objectSize = orginalNif.GetSize(0, 0);
// The final image
using (MagickImage modelImage = new MagickImage(MagickColors.Transparent, fixture.CanvasWidth, fixture.CanvasHeight))
{
// Place the replacing image
using (IMagickImage newModelImage = m_modelImages[fileName].Clone())
{
newModelImage.BackgroundColor = MagickColors.Transparent;
double scaleWidthToTreeImage = objectSize.Width / newModelImage.Width;
double scaleHeightToTreeImage = objectSize.Height / newModelImage.Height;
int width = Convert.ToInt32(newModelImage.Width * scaleWidthToTreeImage * fixture.Scale);
int height = Convert.ToInt32(newModelImage.Height * scaleHeightToTreeImage * fixture.Scale);
// Resize to new size
newModelImage.FilterType = FilterType.Gaussian;
newModelImage.VirtualPixelMethod = VirtualPixelMethod.Transparent;
newModelImage.Resize(width, height);
// Rotate the image
//newModelImage.Rotate(fixture.FixtureRow.A * -1 * fixture.FixtureRow.AxisZ3D);
newModelImage.Rotate((360d * fixture.FixtureRow.AxisZ3D - fixture.FixtureRow.A) * -1);
// Place in center of modelImage
modelImage.Composite(newModelImage, Gravity.Center, CompositeOperator.SrcOver);
}
// Draw the shaped model if wanted
if (fixture.RendererConf.HasLight)
{
using (MagickImage modelShaped = new MagickImage(MagickColors.Transparent, fixture.CanvasWidth, fixture.CanvasHeight))
{
foreach (DrawableElement drawableElement in fixture.DrawableElements)
{
var light = 1 - drawableElement.lightning;
modelShaped.Settings.FillColor = new MagickColor(
Convert.ToUInt16(ushort.MaxValue * light),
Convert.ToUInt16(ushort.MaxValue * light),
Convert.ToUInt16(ushort.MaxValue * light)
);
DrawablePolygon polyDraw = new DrawablePolygon(drawableElement.coordinates);
modelShaped.Draw(polyDraw);
}
using (MagickImage modelMask = new MagickImage(MagickColors.Transparent, fixture.CanvasWidth, fixture.CanvasHeight))
{
modelShaped.Blur();
modelMask.Composite(modelShaped, 0, 0, CompositeOperator.DstAtop);
modelMask.Composite(modelImage, 0, 0, CompositeOperator.DstIn);
modelMask.Level(new Percentage(20), new Percentage(100), Channels.All);
modelImage.Composite(modelMask, 0, 0, CompositeOperator.ColorDodge);
}
}
}
// Add the shadow if not a tree (tree shadow are substituted by a treeoverlay)
if (fixture.RendererConf.HasShadow && !fixture.IsTree)
{
CastShadow(
modelImage,
fixture.RendererConf.ShadowOffsetX,
fixture.RendererConf.ShadowOffsetY,
fixture.RendererConf.ShadowSize,
new Percentage(100 - fixture.RendererConf.ShadowTransparency),
fixture.RendererConf.ShadowColor
);
// Update the canvas position to match the new border
fixture.CanvasX -= fixture.RendererConf.ShadowSize;
fixture.CanvasY -= fixture.RendererConf.ShadowSize;
}
// Set transprency if not a tree (see shadow)
if (fixture.RendererConf.Transparency != 0 && !fixture.IsTree)
{
double divideValue = 100.0 / (100.0 - fixture.RendererConf.Transparency);
modelImage.Evaluate(Channels.Alpha, EvaluateOperator.Divide, divideValue);
}
// Place the image on the right position
overlay.Composite(modelImage, Convert.ToInt32(fixture.CanvasX), Convert.ToInt32(fixture.CanvasY), CompositeOperator.SrcOver);
}
}
}
public void Draw(MagickImage map)
{
MainForm.ProgressStart("Drawing lightmap ...");
// Get the heightmap
MagickImage heightmap = zoneConfiguration.Heightmap.Heightmap;
using (MagickImage lightmap = new MagickImage(Color.Transparent, 256, 256))
{
using (IPixelCollection heightmapPixels = heightmap.GetPixels())
{
using (IPixelCollection lightmapPixels = lightmap.GetPixels())
{
// z-component of surface normals
double nz = 512d / zScale;
double nz_2 = nz * nz;
double nzlz = nz * lightVector[2];
int y1 = 0, y2 = 0;
for (int y = 0; y < lightmap.Height; y++)
{
if (y == 0)
{
y1 = 0;
}
else
{
y1 = y - 1;
}
if (y == 255)
{
y2 = 255;
}
else
{
y2 = y + 1;
}
int x1 = 0, x2 = 0;
for (int x = 0; x < lightmap.Width; x++)
{
if (x == 0)
{
x1 = 0;
}
else
{
x1 = x - 1;
}
if (x == 255)
{
x2 = 255;
}
else
{
x2 = x + 1;
}
double l = heightmapPixels.GetPixel(x1, y).GetChannel(0);
double r = heightmapPixels.GetPixel(x2, y).GetChannel(0);
double u = heightmapPixels.GetPixel(x, y1).GetChannel(0);
double d = heightmapPixels.GetPixel(x, y2).GetChannel(0);
double nx = l - r;
double ny = u - d;
double m_normal = Math.Sqrt(nx * nx + ny * ny + nz_2);
double ndotl = (nx * lightVector[0] + ny * lightVector[1] + nzlz) / m_normal;
double pixelValue = lightBase - ndotl * lightScale * 256d;
ushort pixelValueDiff = 0;
ushort alphaValue = ushort.MaxValue;
if (pixelValue < 0)
{
pixelValueDiff = 0;
alphaValue = (ushort)pixelValue;
}
else
{
pixelValueDiff = (ushort)pixelValue;
}
// ColorDodge map
// white lightens areas where black does nothing
// alpha darkens areas
lightmapPixels.SetPixel(x, y, new ushort[] { pixelValueDiff, pixelValueDiff, pixelValueDiff, alphaValue });
}
int percent = 100 * y / lightmap.Height;
MainForm.ProgressUpdate(percent);
}
}
}
MainForm.ProgressStartMarquee("Merging...");
lightmap.Blur(0.0, 0.5);
lightmap.VirtualPixelMethod = VirtualPixelMethod.Transparent;
lightmap.FilterType = FilterType.Gaussian;
lightmap.Resize(zoneConfiguration.TargetMapSize, zoneConfiguration.TargetMapSize);
// Apply the bumpmap using ColorDodge
map.Composite(lightmap, 0, 0, CompositeOperator.ColorDodge);
MainForm.ProgressReset();
}
}
public void Draw(MagickImage map)
{
MainForm.ProgressStart("Rendering water ...");
using (IPixelCollection heightmapPixels = zoneConfiguration.Heightmap.HeightmapScaled.GetPixels())
{
using (MagickImage water = new MagickImage(MagickColors.Transparent, zoneConfiguration.TargetMapSize, zoneConfiguration.TargetMapSize))
{
int progressCounter = 0;
foreach (WaterConfiguration river in m_waterAreas)
{
MainForm.Log(river.Name + "...", MainForm.LogLevel.notice);
MagickColor fillColor;
if (m_useClientColors)
{
fillColor = river.Color;
}
else
{
fillColor = m_waterColor;
}
//water.FillColor = fillColor;
// Get the river coordinates and scale them to the targets size
List <PointD> riverCoordinates = river.GetCoordinates().Select(c => new PointD(c.X * zoneConfiguration.MapScale, c.Y * zoneConfiguration.MapScale)).ToList();
// Texture
using (MagickImage texture = new MagickImage((river.Type.ToLower() == "lava") ? GetLavaTexture() : GetWateryTexture()))
{
using (MagickImage pattern = new MagickImage(fillColor, texture.Width, texture.Height))
{
texture.Composite(pattern, 0, 0, CompositeOperator.DstIn);
texture.Composite(pattern, 0, 0, CompositeOperator.ColorDodge);
water.Settings.FillPattern = texture;
DrawablePolygon poly = new DrawablePolygon(riverCoordinates);
water.Draw(poly);
}
}
// get the min/max and just process them
int minX = Convert.ToInt32(riverCoordinates.Min(m => m.X)) - 10;
int maxX = Convert.ToInt32(riverCoordinates.Max(m => m.X)) + 10;
int minY = Convert.ToInt32(riverCoordinates.Min(m => m.Y)) - 10;
int maxY = Convert.ToInt32(riverCoordinates.Max(m => m.Y)) + 10;
using (IPixelCollection riverPixelCollection = water.GetPixels())
{
for (int x = minX; x < maxX; x++)
{
if (x < 0)
{
continue;
}
if (x >= zoneConfiguration.TargetMapSize)
{
continue;
}
for (int y = minY; y < maxY; y++)
{
if (y < 0)
{
continue;
}
if (y >= zoneConfiguration.TargetMapSize)
{
continue;
}
ushort pixelHeight = heightmapPixels.GetPixel(x, y).GetChannel(0);
if (pixelHeight > river.Height)
{
Pixel newPixel = new Pixel(x, y, new ushort[] { 0, 0, 0, ushort.MinValue });
riverPixelCollection.SetPixel(newPixel);
}
}
}
}
if (debug)
{
DebugRiver(progressCounter, river, riverCoordinates);
}
int percent = 100 * progressCounter / m_waterAreas.Count();
MainForm.ProgressUpdate(percent);
progressCounter++;
}
MainForm.ProgressStartMarquee("Merging...");
if (WaterTransparency != 0)
{
water.Alpha(AlphaOption.Set);
double divideValue = 100.0 / (100.0 - WaterTransparency);
water.Evaluate(Channels.Alpha, EvaluateOperator.Divide, divideValue);
}
water.Blur();
map.Composite(water, 0, 0, CompositeOperator.SrcOver);
}
}
MainForm.ProgressReset();
}
public void Apply(MagickImage image)
{
image.Blur(3, 99);
}
