public static void Render(string pointFilePath, Size?resolution)
{
using var points = PointStream.Load(pointFilePath);
var viewPort = points.ViewPort;
var actualResolution = resolution ?? points.ViewPort.Resolution;
if (actualResolution != points.ViewPort.Resolution)
{
viewPort = new ViewPort(viewPort.Area, actualResolution);
}
var imageFilePath = pointFilePath + $".{actualResolution.Width}x{actualResolution.Height}.png";
using var timer = TimedOperation.Start("points", totalWork: actualResolution.Area());
var image = new FastImage(actualResolution);
image.Fill(Color.White);
Parallel.ForEach(points, point =>
{
image.SetPixel(viewPort.GetPosition(point), Color.Black);
timer.AddWorkDone(1);
});
image.Save(imageFilePath);
}
protected override void InitializeCell()
{
var width = CellWidth;
var height = CellHeight;
_titleLabel = new Label();
AbsoluteLayout simpleLayout = new AbsoluteLayout {
VerticalOptions = LayoutOptions.FillAndExpand,
WidthRequest = CellWidth,
HeightRequest = CellHeight,
};
_image = new FastImage()
{
Aspect = Aspect.AspectFill,
BackgroundColor = Color.Black,
};
_titleLabel = new Label {
Text = "",
TextColor = Color.White,
FontSize = 14,
XAlign = TextAlignment.Center,
YAlign = TextAlignment.Center,
LineBreakMode = LineBreakMode.TailTruncation,
BackgroundColor = Color.FromHex("#272727"),
};
simpleLayout.Children.Add(_image, new Rectangle(0, 0, width, height - 30));
simpleLayout.Children.Add(_titleLabel, new Rectangle(0, height - 30, width, 30));
View = simpleLayout;
}
public static void RenderAllSpans(string edgeSpansPath, string imageFilePath, bool showDirections)
{
Log.Info($"Output image: {imageFilePath}");
if (showDirections)
{
Log.Info("Displaying span directions as well.");
}
using var spans = EdgeSpanStream.Load(edgeSpansPath);
using var timer = TimedOperation.Start("edge spans", totalWork: showDirections?spans.Count * 2 : spans.Count);
var scale = showDirections ? 3 : 1;
var resolution = spans.ViewPort.Resolution.Scale(scale);
var image = new FastImage(resolution);
image.Fill(Color.White);
Parallel.ForEach(spans, logicalSpan =>
{
if (showDirections)
{
var scaledLocation = logicalSpan.Location.Scale(scale);
for (int yDelta = 0; yDelta < 3; yDelta++)
{
for (int xDelta = 0; xDelta < 3; xDelta++)
{
image.SetPixel(
scaledLocation.OffsetBy(xDelta, yDelta),
(logicalSpan.Location.X + logicalSpan.Location.Y) % 2 == 1 ? Color.Black : Color.Gray);
}
}
}
else
{
image.SetPixel(
logicalSpan.Location,
Color.Black);
}
timer.AddWorkDone(1);
});
if (showDirections)
{
Parallel.ForEach(spans, locatedSpan =>
{
var scaledLocation = locatedSpan.Location.Scale(scale);
var pointingTo = scaledLocation.OffsetBy(1, 1).OffsetIn(locatedSpan.ToOutside);
image.SetPixel(
pointingTo,
Color.Red);
timer.AddWorkDone(1);
});
}
image.Save(imageFilePath);
}
public Segmentare(FastImage image, int panelWidth, int panelHeight)
{
this.image = image;
this.panelWidth = panelWidth;
this.panelHeight = panelHeight;
this.canvas = new FastImage(new Bitmap(image.Width, image.Height));
matriceVizitate = new bool[image.Width + 1, image.Height + 1];
}
public Bitmap Compute(FastImage workImage)
{
image = workImage;
image.Lock();
DoKirsch();
image.Unlock();
return(image.GetBitMap());
}
private static bool SaltPepper(FastImage fastImage, int i, int j)
{
var color = fastImage.GetPixel(i, j);
var isBlack = color.R == 0 && color.G == 0 && color.B == 0;
var isWhite = color.R == 255 && color.G == 255 && color.B == 255;
return(isBlack || isWhite);
}
public Gene(FastImage src, int minx, int miny, int maxx, int maxy, int minsz, int maxsz)
{
x = _rnd.Next(minx, maxx);
y = _rnd.Next(miny, maxy);
sz = _rnd.Next(minsz, maxsz);
//color = new SimpleColor(_rnd.Next(0, 256), _rnd.Next(0, 256), _rnd.Next(0, 256));
SimpleColor sc = src.GetPixel(_rnd.Next(0, src.width), _rnd.Next(0, src.height));
color = new SimpleColor(sc.GetR(), sc.GetG(), sc.GetB());
}
public Candidate(FastImage src, int gCount, int minSqSz, int maxSqSz)
{
f = new FastImage(src.width, src.height);
genes = new List <Gene>();
for (int i = 0; i < gCount; i++)
{
Gene g = new Gene(src, 0, 0, src.width, src.height, minSqSz, maxSqSz);
genes.Add(g);
}
}
public static void Laplace(FastImage fastImage, FastImage originalFastImage)
{
var H1 = new[, ]
{
{ 0, 1, 0 },
{ 1, -4, 1 },
{ 0, 1, 0 }
};
var H2 = new[, ]
{
{ -1, -1, -1 },
{ -1, 8, -1 },
{ -1, -1, -1 }
};
fastImage.Lock();
originalFastImage.Lock();
for (int row = 1; row < originalFastImage.Width - 2; row++)
{
for (int column = 1; column < originalFastImage.Height - 2; column++)
{
GetConvolutionSums(originalFastImage, row, column, H1, out var sumRedH1, out var sumGreenH1, out var sumBlueH1);
GetConvolutionSums(originalFastImage, row, column, H2, out var sumRedH2, out var sumGreenH2, out var sumBlueH2);
var sumsRed = new List <int> {
sumRedH1, sumRedH2
};
var sumsGreen = new List <int> {
sumGreenH1, sumGreenH2
};
var sumsBlue = new List <int> {
sumBlueH1, sumBlueH2
};
var maxRed = sumsRed.Max();
var maxGreen = sumsGreen.Max();
var maxBlue = sumsBlue.Max();
maxRed = Normalizare(maxRed, 0, 255);
maxGreen = Normalizare(maxGreen, 0, 255);
maxBlue = Normalizare(maxBlue, 0, 255);
var newColor = Color.FromArgb(maxRed, maxGreen, maxBlue);
fastImage.SetPixel(row, column, newColor);
}
}
fastImage.Unlock();
originalFastImage.Unlock();
}
// TODO: This code should not be in this class - its too specialized
public IImage <bool> CreateBinaryImage(double threshhold)
{
IImage <bool> binaryImage = new FastImage <bool>(Width, Height);
for (int i = 0; i < Width; ++i)
{
for (int j = 0; j < Height; ++j)
{
binaryImage[i, j] = this[i, j] > threshhold;
}
}
return(binaryImage);
}
public static void Export(MetaMap map, MapPalette palette, string outputFilePath, int scale = 1)
{
using var image = new FastImage(map.Width, map.Height, scale);
for (var tileY = 0; tileY < map.Height; tileY++)
{
for (var tileX = 0; tileX < map.Width; tileX++)
{
var tileColor = palette.PickColor(map[tileX, tileY]);
image.SetPixel(tileX, tileY, tileColor);
}
}
image.Save(outputFilePath);
}
private static string GetNewFolder(string oldPath)
{
string root;
DateTime dateTaken = DateTime.MinValue;
string extension = Path.GetExtension(oldPath).ToUpper();
switch (extension)
{
case ".MP4":
root = Environment.GetFolderPath(Environment.SpecialFolder.MyVideos);
dateTaken = File.GetCreationTime(oldPath);
break;
case ".THM":
case ".LRV":
root = Environment.GetFolderPath(Environment.SpecialFolder.MyVideos);
dateTaken = File.GetLastWriteTime(oldPath);
break;
default:
root = Environment.GetFolderPath(Environment.SpecialFolder.MyPictures);
break;
}
try
{
FastImage img = new FastImage(oldPath);
dateTaken = img.DateTaken;
}
catch
{
// No Date Info use default.
}
if (dateTaken == DateTime.MinValue)
{
return(String.Format("{0}\\No Date", root));
}
else
{
return(String.Format("{0}\\{1:d4}\\{1:d4}-{2:d2}\\{1:d4}-{2:d2}-{3:d2}",
root, dateTaken.Year, dateTaken.Month, dateTaken.Day));
}
}
private static void GetConvolutionSumsForRobert(FastImage fastImage, int x, int y, int[,] matrix, out int sumRed, out int sumGreen, out int sumBlue)
{
sumRed = 0;
sumGreen = 0;
sumBlue = 0;
for (int i = x; i <= x + 1; i++)
{
for (int j = y; j <= y + 1; j++)
{
var pixel = fastImage.GetPixel(i, j);
sumRed += pixel.R * matrix[i - x, j - y];
sumGreen += pixel.G * matrix[i - x, j - y];
sumBlue += pixel.B * matrix[i - x, j - y];
}
}
}
public static IFastImage Render(LightMap lightMap, int scale = 10)
{
var image = new FastImage(lightMap.Size.Width, lightMap.Size.Height, scale);
for (int y = 0; y < lightMap.Size.Height; y++)
{
for (int x = 0; x < lightMap.Size.Width; x++)
{
var light = lightMap[x, y];
byte intensity = (byte)((((double)light + lightMap.Range.DarkLevels) / lightMap.Range.Total) * 256);
image.SetPixel(x, y, new SKColor(intensity, intensity, intensity));
}
}
return(image);
}
private static byte CBP(FastImage fastImage, int x, int y, int contextSize, int searchRadius, int sumLimit)
{
var intensities = new int[256];
for (int i = x - searchRadius; i <= x + searchRadius; i++)
{
if (i < 0 || i >= fastImage.Width)
{
continue;
}
for (int j = y - searchRadius; j < y + searchRadius; j++)
{
if (j < 0 || j >= fastImage.Height)
{
continue;
}
if (i == y && j == x)
{
continue;
}
if (SAD(fastImage, x, y, i, j, contextSize) < sumLimit && !SaltPepper(fastImage, i, j))
{
var color = fastImage.GetPixel(i, j);
intensities[color.R]++;
}
}
}
int indexOfBiggestValue = 0;
var max = 0;
for (int i = 0; i < intensities.Length; i++)
{
if (intensities[i] > max)
{
max = intensities[i];
indexOfBiggestValue = i;
}
}
return((byte)indexOfBiggestValue);
}
public static void LowPassFiler(FastImage fastImage, FastImage originalFastImage, int n)
{
if (n < 1)
{
throw new ArgumentException();
}
var matrix = GetLowPassFilterMatrix(n);
fastImage.Lock();
originalFastImage.Lock();
for (int row = 1; row < originalFastImage.Width - 2; row++)
{
for (int column = 1; column < originalFastImage.Height - 2; column++)
{
var sumRed = 0;
var sumGreen = 0;
var sumBlue = 0;
for (int i = row - 1; i <= row + 1; i++)
{
for (int j = column - 1; j <= column + 1; j++)
{
var pixel = originalFastImage.GetPixel(i, j);
sumRed += pixel.R * matrix[i - row + 1, j - column + 1];
sumGreen += pixel.G * matrix[i - row + 1, j - column + 1];
sumBlue += pixel.B * matrix[i - row + 1, j - column + 1];
}
}
var divide = (n + 2) * (n + 2);
var newRed = sumRed / divide;
var newGreen = sumGreen / divide;
var newBlue = sumBlue / divide;
var newColor = Color.FromArgb(newRed, newGreen, newBlue);
fastImage.SetPixel(row, column, newColor);
}
}
fastImage.Unlock();
originalFastImage.Unlock();
}
public static void GrayScaleFastImage(FastImage fastImage)
{
fastImage.Lock();
for (var i = 0; i < fastImage.Width; i++)
{
for (var j = 0; j < fastImage.Height; j++)
{
var color = fastImage.GetPixel(i, j);
var average = (byte)((color.R + color.G + color.B) / 3);
color = Color.FromArgb(average, average, average);
fastImage.SetPixel(i, j, color);
}
}
fastImage.Unlock();
}
public static void Roberts(FastImage fastImage, FastImage originalFastImage)
{
var P = new[, ]
{
{ -1, 0 },
{ 0, 1 },
};
var Q = new[, ]
{
{ 0, 1 },
{ -1, 0 },
};
fastImage.Lock();
originalFastImage.Lock();
const int k = 7;
for (int row = 1; row < originalFastImage.Width - 2; row++)
{
for (int column = 1; column < originalFastImage.Height - 2; column++)
{
GetConvolutionSumsForRobert(originalFastImage, row, column, P, out var sumRedP, out var sumGreenP, out var sumBlueP);
GetConvolutionSumsForRobert(originalFastImage, row, column, Q, out var sumRedQ, out var sumGreenQ, out var sumBlueQ);
int newRed = k * (int)Math.Sqrt(Math.Pow(sumRedP, 2) + Math.Pow(sumRedQ, 2));
int newGreen = k * (int)Math.Sqrt(Math.Pow(sumGreenP, 2) + Math.Pow(sumGreenQ, 2));
int newBlue = k * (int)Math.Sqrt(Math.Pow(sumBlueP, 2) + Math.Pow(sumBlueQ, 2));
newRed = Normalizare(newRed, 0, 255);
newGreen = Normalizare(newGreen, 0, 255);
newBlue = Normalizare(newBlue, 0, 255);
var newColor = Color.FromArgb(newRed, newGreen, newBlue);
fastImage.SetPixel(row, column, newColor);
}
}
fastImage.Unlock();
originalFastImage.Unlock();
}
public static void Sobel(FastImage fastImage, FastImage originalFastImage)
{
var P = new[, ]
{
{ -1, -2, -1 },
{ 0, 0, 0 },
{ 1, 2, 1 }
};
var Q = new[, ]
{
{ -1, 0, 1 },
{ -2, 0, 2 },
{ -1, 0, 1 }
};
fastImage.Lock();
originalFastImage.Lock();
for (int row = 1; row < originalFastImage.Width - 2; row++)
{
for (int column = 1; column < originalFastImage.Height - 2; column++)
{
GetConvolutionSums(originalFastImage, row, column, P, out var sumRedP, out var sumGreenP, out var sumBlueP);
GetConvolutionSums(originalFastImage, row, column, Q, out var sumRedQ, out var sumGreenQ, out var sumBlueQ);
var maxRed = (int)Math.Sqrt(Math.Pow(sumRedP, 2) + Math.Pow(sumRedQ, 2));
var maxGreen = (int)Math.Sqrt(Math.Pow(sumGreenP, 2) + Math.Pow(sumGreenQ, 2));
var maxBlue = (int)Math.Sqrt(Math.Pow(sumBlueP, 2) + Math.Pow(sumBlueQ, 2));
maxRed = Normalizare(maxRed, 0, 255);
maxGreen = Normalizare(maxGreen, 0, 255);
maxBlue = Normalizare(maxBlue, 0, 255);
var newColor = Color.FromArgb(maxRed, maxGreen, maxBlue);
fastImage.SetPixel(row, column, newColor);
}
}
fastImage.Unlock();
originalFastImage.Unlock();
}
public static void CBPF(FastImage fastImage, FastImage originalFastImage, int contextSize, int searchRadius, int sumLimit)
{
fastImage.Lock();
originalFastImage.Lock();
for (int i = 0; i < originalFastImage.Width; i++)
{
for (int j = 0; j < originalFastImage.Height; j++)
{
if (SaltPepper(originalFastImage, i, j))
{
var newColor = CBP(originalFastImage, i, j, contextSize, searchRadius, sumLimit);
fastImage.SetPixel(i, j, Color.FromArgb(newColor, newColor, newColor));
}
}
}
fastImage.Unlock();
originalFastImage.Unlock();
}
public static long Error(FastImage a, FastImage b)
{
long error = 0;
for (int x = 0; x < a.width; x++)
{
for (int y = 0; y < a.height; y++)
{
SimpleColor old = a.GetPixel(x, y);
SimpleColor srcCol = b.GetPixel(x, y);
error += (long)Math.Sqrt(
Math.Pow(old.GetR() - srcCol.GetR(), 2) +
Math.Pow(old.GetG() - srcCol.GetG(), 2) +
Math.Pow(old.GetB() - srcCol.GetB(), 2));
}
}
return(error);
}
private static int SAD(FastImage fastImage, int x1, int y1, int x2, int y2, int contextSize)
{
int sum = 0;
for (int i = -contextSize / 2; i <= contextSize / 2; i++)
{
if (i + x1 < 0 || i + x1 >= fastImage.Width)
{
continue;
}
if (i + x2 < 0 || i + x2 >= fastImage.Width)
{
continue;
}
for (int j = -contextSize / 2; j < contextSize / 2; j++)
{
if (i + y1 < 0 || i + y1 >= fastImage.Height)
{
continue;
}
if (i + y2 < 0 || i + y2 >= fastImage.Height)
{
continue;
}
if (i == 0 && j == 0)
{
continue;
}
var color1 = fastImage.GetPixel(j + x1, i + y1);
var color2 = fastImage.GetPixel(j + x2, i + y2);
sum += Math.Abs(color1.R - color2.R);
}
}
return(sum);
}
public GeneticAlgorithm(Bitmap sourceImage, int keepEvery, int maxGens, double mutRate,
int topn, int numCands, int numGenes, int min, int max)
{
rnd = new Random();
src = new FastImage(sourceImage);
this.keepEvery = keepEvery;
this.maxGens = maxGens;
this.mutN = (int)(1 / mutRate);
this.topn = topn;
this.numCands = numCands;
this.numGenes = numGenes;
this.min = min;
this.max = max;
candidates = new List <Candidate>();
for (int i = 0; i < numCands; i++)
{
Candidate n = new Candidate(src, numGenes, min, max);
candidates.Add(n);
}
}
public static void NegateFastImage(FastImage fastImage)
{
fastImage.Lock();
for (var i = 0; i < fastImage.Width; i++)
{
for (var j = 0; j < fastImage.Height; j++)
{
var color = fastImage.GetPixel(i, j);
var newRed = (byte)(255 - color.R);
var newGreen = (byte)(255 - color.G);
var newBlue = (byte)(255 - color.B);
color = Color.FromArgb(newRed, newGreen, newBlue);
fastImage.SetPixel(i, j, color);
}
}
fastImage.Unlock();
}
public System.Drawing.Bitmap GetAsBitmap()
{
GR.Image.FastImage fastImage = new FastImage(Width, Height, PixelFormat);
for (int i = 0; i < PaletteEntryCount; ++i)
{
fastImage.SetPaletteColor(i, PaletteRed(i), PaletteGreen(i), PaletteBlue(i));
}
for (int x = 0; x < Width; ++x)
{
for (int y = 0; y < Height; ++y)
{
fastImage.SetPixel(x, y, GetPixel(x, y));
}
}
System.Drawing.Bitmap bitmap = fastImage.GetAsBitmap();
fastImage.Dispose();
return(bitmap);
}
public static void ApplyEqualization(FastImage fastImage, FastImage originalFastImage)
{
var oldGrayScaleHistogram = originalFastImage.GrayScaleHistogram;
var newGrayScaleHistogram = new int[256];
newGrayScaleHistogram[0] = oldGrayScaleHistogram[0];
for (var i = 1; i < oldGrayScaleHistogram.Length; i++)
{
newGrayScaleHistogram[i] = newGrayScaleHistogram[i - 1] + oldGrayScaleHistogram[i];
}
var transf = new int[256];
for (var i = 0; i < transf.Length; i++)
{
transf[i] = (newGrayScaleHistogram[i] * 255) / (originalFastImage.Width * originalFastImage.Height);
}
originalFastImage.Lock();
fastImage.Lock();
for (var i = 0; i < fastImage.Width; i++)
{
for (var j = 0; j < fastImage.Height; j++)
{
var color = originalFastImage.GetPixel(i, j);
var gray = (color.R + color.G + color.B) / 3;
var newColor = Color.FromArgb(transf[gray], transf[gray], transf[gray]);
fastImage.SetPixel(i, j, newColor);
}
}
originalFastImage.Unlock();
fastImage.Unlock();
}
public static void Render(string gridFilePath, string imageFilePath)
{
Log.Info($"Output image: {imageFilePath}");
using var grid = PointGrid.Load(gridFilePath);
using var timer = TimedOperation.Start("points", totalWork: grid.ViewPort.Resolution.Area());
var image = new FastImage(grid.ViewPort.Resolution);
image.Fill(Color.White);
Parallel.ForEach(grid, row =>
{
foreach (var setSegment in row.GetSegmentsInSet())
{
foreach (var x in Enumerable.Range(setSegment.StartCol, setSegment.Length))
{
image.SetPixel(x, row.Y, Color.Black);
}
}
timer.AddWorkDone(grid.ViewPort.Resolution.Width);
});
image.Save(imageFilePath);
}
public void TestFitness(FastImage src)
{
f.Clear();
_error = 0;
foreach (Gene gene in genes)
{
for (int x = gene.x; x < src.width && x < gene.x + gene.sz; x++)
{
for (int y = gene.y; y < src.height && y < gene.y + gene.sz; y++)
{
f.SetPixel(x, y, gene.color);
}
}
}
for (int x = 0; x < src.width; x++)
{
for (int y = 0; y < src.height; y++)
{
_error += src.GetPixel(x, y).Difference(f.GetPixel(x, y));
}
}
}
private static void GetConvolutionSumsForFreiChen(FastImage fastImage, int x, int y, List <double[, ]> matrixes, out int sumRed, out int sumGreen, out int sumBlue)
{
var firstSumR = 0d;
var firstSumG = 0d;
var firstSumB = 0d;
var secondSumR = 0d;
var secondSumG = 0d;
var secondSumB = 0d;
for (var index = 0; index < matrixes.Count; index++)
{
var matrix = matrixes[index];
for (int i = x; i <= x + 1; i++)
{
for (int j = y; j <= y + 1; j++)
{
var pixel = fastImage.GetPixel(i, j);
secondSumR += Math.Pow(pixel.R * matrix[i - x, j - y], 2);
secondSumG += Math.Pow(pixel.G * matrix[i - x, j - y], 2);
secondSumB += Math.Pow(pixel.B * matrix[i - x, j - y], 2);
if (index < 4)
{
firstSumR += Math.Pow(pixel.R * matrix[i - x, j - y], 2);
firstSumG += Math.Pow(pixel.G * matrix[i - x, j - y], 2);
firstSumB += Math.Pow(pixel.B * matrix[i - x, j - y], 2);
}
}
}
}
sumRed = (int)(Math.Sqrt(firstSumR / secondSumR) * 255);
sumGreen = (int)(Math.Sqrt(firstSumG / secondSumG) * 255);
sumBlue = (int)(Math.Sqrt(firstSumB / secondSumB) * 255);
}
static void Main(string[] args)
{
Uri horizonUri = UriFromArg(args, 0);
GeodysseyModel model = new GeodysseyModel();
LoaderController.Instance.Open(horizonUri, model);
IRegularGrid2D horizon = model[0];
//string pathOriginal = horizonUri.LocalPath.Replace(".dat", ".grd");
//horizon.WriteSurfer6BinaryFile(pathOriginal);
// TODO: Make IRegularGrid IEnumerable
var extentMap = new FastImage <bool>(horizon.SizeI, horizon.SizeJ, horizon.Select(item => item.HasValue));
IImage <bool> faultMap = Morphology.Invert(extentMap);
IImage <double> distanceMap = DistanceMap.EuclideanTransform(extentMap);
// Remove anything above a threshold distance from data
const double threshold = 50;
var clippedFaultMap = extentMap.CloneTransform((i, j) => distanceMap[i, j] < threshold &&
faultMap[i, j]);
Trace.WriteLine("Pepper filter");
IImage <bool> filtered = Morphology.PepperFiltering(5, clippedFaultMap);
Trace.WriteLine("Closing gaps");
IImage <bool> closed = Morphology.Closing(filtered);
Trace.WriteLine("Thinning until convergence");
IImage <bool> thinned = Morphology.ThinUntilConvergence(closed);
Trace.WriteLine("Thinning blocks until convergence");
IImage <bool> blockthinned = Morphology.ThinBlockUntilConvergence(thinned);
Trace.WriteLine("Filling");
IImage <bool> filled = Morphology.Fill(blockthinned);
WriteBinaryImageSurfer6Grid(horizon, filled, horizonUri.LocalPath.Replace(".grd", "_filled.grd"));
//// Create a double valued 'binary' image showing the extent of the horizon data
//FastImage<double> extentMap = new FastImage<double>(horizon.SizeI, horizon.SizeJ);
//for (int i = 0; i < horizon.SizeI; ++i)
//{
// for (int j = 0; j < horizon.SizeJ; ++j)
// {
// bool hasValue = horizon[i, j].HasValue;
// extentMap[i, j] = hasValue ? 1.0 : 0.0;
// }
//}
//int extent = extentMap.Where(v => v == 1.0).Count();
//double extentProportion = (double) extent / (extentMap.Width * extentMap.Height);
//IImage<double> scaledExtentMap = Scaler.Downscale(extentMap, 5);
//IImage<double> smoothedExtentMap = scaledExtentMap.CloneSize();
//Convolver.GaussianSmooth(scaledExtentMap, smoothedExtentMap, 3.0);
//IRegularGrid2D smoothedGrid = horizon.CloneSize(smoothedExtentMap.Width, smoothedExtentMap.Height);
//for (int i = 0 ; i < smoothedGrid.SizeI; ++i)
//{
// for (int j = 0 ; j < smoothedGrid.SizeJ; ++j)
// {
// smoothedGrid[i, j] = smoothedExtentMap[i, j];
// }
//}
//PriorityQueue<double> orderedIntensities = PriorityQueue<double>.CreateHighFirstOut(smoothedExtentMap);
//int k = (int) (extentProportion * orderedIntensities.Count);
//Debug.Assert(k >= 0);
//for (int i = 0 ; i < k - 1; ++i)
//{
// orderedIntensities.Dequeue();
//}
//double threshold = orderedIntensities.Dequeue();
//string pathSmoothed = horizonUri.LocalPath.Replace(".grd", "_smoothed.grd");
//smoothedGrid.WriteSurfer6BinaryFile(pathSmoothed);
//IImage<bool> thresholdMap = BitImage.Analysis.Threshold(smoothedExtentMap, threshold * 2.0);
//int actual = thresholdMap.Where(v => v).Count();
//double actualProportion = (double) actual / (thresholdMap.Width * thresholdMap.Height);
//IRegularGrid2D thresholdGrid = horizon.CloneSize(thresholdMap.Width, thresholdMap.Height);
//for (int i = 0; i < smoothedGrid.SizeI; ++i)
//{
// for (int j = 0; j < smoothedGrid.SizeJ; ++j)
// {
// thresholdGrid[i, j] = thresholdMap[i, j] ? 1.0 : 0.0;
// }
//}
//string pathThresholded = horizonUri.LocalPath.Replace(".grd", "_thresholded.grd");
//thresholdGrid.WriteSurfer6BinaryFile(pathThresholded);
//IImage<double> distanceMap = DistanceMap.EuclideanTransform(scaledExtentMap);
// Convert the image back to a grid for convenient output
IRegularGrid2D distanceGrid = horizon.CloneSize(distanceMap.Width, distanceMap.Height);
for (int i = 0; i < distanceMap.Width; ++i)
{
for (int j = 0; j < distanceMap.Height; ++j)
{
distanceGrid[i, j] = distanceMap[i, j];
}
}
string pathDistance = horizonUri.LocalPath.Replace(".grd", "_distance.grd");
distanceGrid.WriteSurfer6BinaryFile(pathDistance);
}
