void ProcessCommon(AudioReader reader, ref float[] impulse)
{
int targetLen = QMath.Base2Ceil((int)reader.Length) << 1;
Complex[] commonSpectrum = new Complex[targetLen];
FFTCache cache = new FFTCache(targetLen);
for (int ch = 0; ch < reader.ChannelCount; ++ch)
{
float[] channel = new float[targetLen];
WaveformUtils.ExtractChannel(impulse, channel, ch, reader.ChannelCount);
Complex[] spectrum = Measurements.FFT(channel, cache);
for (int band = 0; band < spectrum.Length; ++band)
{
commonSpectrum[band] += spectrum[band];
}
}
float mul = 1f / reader.ChannelCount;
for (int band = 0; band < commonSpectrum.Length; ++band)
{
commonSpectrum[band] = (commonSpectrum[band] * mul).Invert();
}
Array.Resize(ref impulse, impulse.Length << 1);
for (int ch = 0; ch < reader.ChannelCount; ++ch)
{
Convolver filter = GetFilter(commonSpectrum, 1, reader.SampleRate);
filter.Process(impulse, ch, reader.ChannelCount);
}
}
/// <summary>
/// Main constructor
/// </summary>
/// <param name="samplingRate"></param>
/// <param name="order"></param>
/// <param name="frameDuration"></param>
/// <param name="hopDuration"></param>
/// <param name="preEmphasis"></param>
/// <param name="window"></param>
public LpcExtractor(int samplingRate,
int order,
double frameDuration = 0.0256 /*sec*/,
double hopDuration = 0.010 /*sec*/,
double preEmphasis = 0.0,
WindowTypes window = WindowTypes.Rectangular)
: base(samplingRate, frameDuration, hopDuration)
{
_order = order;
var fftSize = MathUtils.NextPowerOfTwo(2 * FrameSize - 1);
_convolver = new Convolver(fftSize);
_window = window;
if (_window != WindowTypes.Rectangular)
{
_windowSamples = Window.OfType(_window, FrameSize);
}
_preEmphasis = (float)preEmphasis;
_block = new float[FrameSize];
_reversed = new float[FrameSize];
_cc = new float[fftSize];
}
public void ConvolveWithScharr()
{
var matrix = new double[3,3];
var convolver = new Convolver(ScharrKernel.Instance);
matrix[0, 0] = 0; matrix[1, 0] = 1; matrix[2, 0] = 1;
matrix[0, 1] = 0; matrix[1, 1] = 0; matrix[2, 1] = 1;
matrix[0, 2] = 0; matrix[1, 2] = 0; matrix[2, 2] = 0;
var gradient = convolver.Convolve(new IntCoordinate(1,1), matrix, elem => elem);
Assert.AreEqual(gradient.Angle, Math.PI/4);
matrix[0, 0] = 1; matrix[1, 0] = 1; matrix[2, 0] = 0;
matrix[0, 1] = 1; matrix[1, 1] = 0; matrix[2, 1] = 0;
matrix[0, 2] = 0; matrix[1, 2] = 0; matrix[2, 2] = 0;
gradient = convolver.Convolve(new IntCoordinate(1, 1), matrix, elem => elem);
Assert.AreEqual(gradient.Angle, Math.PI * 3/4);
matrix[0, 0] = 1; matrix[1, 0] = 0; matrix[2, 0] = 0;
matrix[0, 1] = 1; matrix[1, 1] = 0; matrix[2, 1] = 0;
matrix[0, 2] = 1; matrix[1, 2] = 0; matrix[2, 2] = 0;
gradient = convolver.Convolve(new IntCoordinate(1, 1), matrix, elem => elem);
Assert.AreEqual(gradient.Angle, -Math.PI);
matrix[0, 0] = 0; matrix[1, 0] = 0; matrix[2, 0] = 0;
matrix[0, 1] = 0; matrix[1, 1] = 0; matrix[2, 1] = 0;
matrix[0, 2] = 1; matrix[1, 2] = 1; matrix[2, 2] = 1;
gradient = convolver.Convolve(new IntCoordinate(1, 1), matrix, elem => elem);
Assert.AreEqual(gradient.Angle, -Math.PI/2);
}
/// <summary>
/// Main constructor
/// </summary>
/// <param name="samplingRate"></param>
/// <param name="featureCount"></param>
/// <param name="frameSize"></param>
/// <param name="hopSize"></param>
/// <param name="lifterSize"></param>
/// <param name="preEmphasis"></param>
/// <param name="window"></param>
public LpccExtractor(int samplingRate,
int featureCount,
double frameDuration = 0.0256 /*sec*/,
double hopDuration = 0.010 /*sec*/,
int lifterSize = 22,
double preEmphasis = 0.0,
WindowTypes window = WindowTypes.Rectangular)
: base(samplingRate, frameDuration, hopDuration)
{
FeatureCount = featureCount;
_order = featureCount;
var fftSize = MathUtils.NextPowerOfTwo(2 * FrameSize - 1);
_convolver = new Convolver(fftSize);
_window = window;
if (_window != WindowTypes.Rectangular)
{
_windowSamples = Window.OfType(_window, FrameSize);
}
_lifterSize = lifterSize;
_lifterCoeffs = _lifterSize > 0 ? Window.Liftering(FeatureCount, _lifterSize) : null;
_preEmphasis = (float)preEmphasis;
_block = new float[FrameSize];
_reversed = new float[FrameSize];
_cc = new float[fftSize];
_lpc = new float[_order + 1];
}
void camera_NewFrame(object sender, EventArgs e)
{
Invalidate();
if (camera != null)
{
try
{
camera.Lock();
filterBmp = new Bitmap(camera.LastFrame);
PCT_CANVAS.Image = Convolver.Execute(filterBmp, SOBEL_Gx);//Sobel.Execute(YUV.Execute(filterBmp));
MyDelegates.SetControlTextValue(LBL_IMAGE_SIZE, camera.LastFrame.Size);
}
catch (Exception ex)
{
MyDelegates.SetControlTextValue(LBL_IMAGE_SIZE, ex);
}
finally
{
camera.Unlock();
}
if (camera.FramesReceived % 12 == 0)
{
thread = new Thread(Clean);
thread.Start();
}
}
}
void OnEnable()
{
float[] impulse = new float[MaxSamples];
impulse[0] = 1;
filter = new Convolver(impulse, 0);
AddFilter(filter);
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="samplingRate"></param>
/// <param name="frameDuration"></param>
/// <param name="hopDuration"></param>
/// <param name="low"></param>
/// <param name="high"></param>
/// <param name="preEmphasis"></param>
/// <param name="window"></param>
public PitchExtractor(int samplingRate,
double frameDuration = 0.0256 /*sec*/,
double hopDuration = 0.010 /*sec*/,
float low = 80,
float high = 400,
double preEmphasis = 0,
WindowTypes window = WindowTypes.Rectangular)
: base(samplingRate, frameDuration, hopDuration, preEmphasis)
{
_low = low;
_high = high;
_window = window;
if (_window != WindowTypes.Rectangular)
{
_windowSamples = Window.OfType(_window, FrameSize);
}
_blockSize = MathUtils.NextPowerOfTwo(2 * FrameSize - 1);
_convolver = new Convolver(_blockSize);
_reversed = new float[FrameSize];
_cc = new float[_blockSize];
FeatureDescriptions = new List <string>()
{
"pitch"
};
}
void ProcessPerChannel(AudioReader reader, ref float[] impulse)
{
int targetLen = QMath.Base2Ceil((int)reader.Length) << 1;
Convolver[] filters = new Convolver[reader.ChannelCount];
FFTCache cache = new FFTCache(targetLen);
for (int ch = 0; ch < reader.ChannelCount; ++ch)
{
float[] channel = new float[targetLen];
WaveformUtils.ExtractChannel(impulse, channel, ch, reader.ChannelCount);
Complex[] spectrum = Measurements.FFT(channel, cache);
for (int band = 0; band < spectrum.Length; ++band)
{
spectrum[band] = spectrum[band].Invert();
}
filters[ch] = GetFilter(spectrum, WaveformUtils.GetRMS(channel), reader.SampleRate);
}
Array.Resize(ref impulse, impulse.Length << 1);
for (int ch = 0; ch < reader.ChannelCount; ++ch)
{
filters[ch].Process(impulse, ch, reader.ChannelCount);
}
}
static void Main(string[] args)
{
var kernel = Enumerable.Range(0, 30).Select(n => n * 0.01).ToArray();
var conv = new Convolver(kernel);
var inData = Enumerable.Range(0, 200).Select(n => 1d).ToArray();
var outData = new double[200 + 128];
int len = conv.Convolve(inData, 0, 100, outData, 0, outData.Length);
int len2 = conv.Convolve(inData, 100, 100, outData, len, outData.Length - len);
int len3 = conv.ConvolveFinal(outData, len + len2, outData.Length - len - len2);
}
/// <summary>
/// For large window sizes prepare the internal convolver
/// </summary>
private void PrepareConvolver()
{
var fftSize = MathUtils.NextPowerOfTwo(_windowSize + _maxDelta - 1);
if (fftSize >= 512)
{
_convolver = new Convolver(fftSize);
_cc = new float[fftSize];
}
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="options">LPC options</param>
public LpcExtractor(LpcOptions options) : base(options)
{
_order = options.LpcOrder;
FeatureCount = _order + 1;
_blockSize = MathUtils.NextPowerOfTwo(2 * FrameSize - 1);
_convolver = new Convolver(_blockSize);
_reversed = new float[FrameSize];
_cc = new float[_blockSize];
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="options">LPCC options</param>
public LpccExtractor(LpccOptions options) : base(options)
{
FeatureCount = options.FeatureCount;
_order = options.LpcOrder > 0 ? options.LpcOrder : FeatureCount - 1;
_blockSize = MathUtils.NextPowerOfTwo(2 * FrameSize - 1);
_convolver = new Convolver(_blockSize);
_lifterSize = options.LifterSize;
_lifterCoeffs = _lifterSize > 0 ? Window.Liftering(FeatureCount, _lifterSize) : null;
_reversed = new float[FrameSize];
_cc = new float[_blockSize];
_lpc = new float[_order + 1];
}
/// <summary>
/// Constructs extractor from configuration <paramref name="options"/>.
/// </summary>
public PitchExtractor(PitchOptions options) : base(options)
{
_low = (float)options.LowFrequency;
_high = (float)options.HighFrequency;
_blockSize = MathUtils.NextPowerOfTwo(2 * FrameSize - 1);
_convolver = new Convolver(_blockSize);
_reversed = new float[FrameSize];
_cc = new float[_blockSize];
FeatureCount = 1;
FeatureDescriptions = new List <string>()
{
"pitch"
};
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="samplingRate"></param>
/// <param name="frameDuration"></param>
/// <param name="hopDuration"></param>
/// <param name="parameters"></param>
public PitchExtractor(int samplingRate,
double frameDuration = 0.0256 /*sec*/,
double hopDuration = 0.010 /*sec*/,
float low = 80,
float high = 400)
: base(samplingRate, frameDuration, hopDuration)
{
_low = low;
_high = high;
var fftSize = MathUtils.NextPowerOfTwo(2 * FrameSize - 1);
_convolver = new Convolver(fftSize);
_block = new float[FrameSize];
_reversed = new float[FrameSize];
_cc = new float[fftSize];
FeatureDescriptions = new List <string>()
{
"pitch"
};
}
static void Main(string[] args)
{
const int FFTSize = 240;
const int FFTComplexSize = FFTSize / 2 + 1;
var fft = new FFT(FFTSize, fftw_direction.Forward);
var input = new Complex[FFTSize];
var input2 = new Complex[FFTSize];
var output = new Complex[FFTSize];
const int RectWaveWidth = 40;
const int RectWaveWidth2 = 30;
var conv = new Convolver(Kernel);
for (int i = 0; i < FFTSize; i++)
{
//input[i] = i / RectWaveWidth % 2 == 0 ? 1 : 0;
//input[i] += i / RectWaveWidth2 % 2 == 0 ? 1 : 0;
input[i] = 1000 + 50000 * Math.Sin(2 * Math.PI / FFTSize * 20.1 * i) + 40000 * Math.Sin(2 * Math.PI / FFTSize * 7 * i) + 9000 * Math.Sin(2 * Math.PI / FFTSize * 119 * i);
// input[i] = 1 * Math.Sin(2 * Math.PI / FFTSize * 7 * i);
// input[i] *= 2 * Math.Cos(2 * Math.PI / FFTSize * 5 * i);
}
var filter = new Complex[FFTSize];
for (int i = 0; i < FFTSize; i++)
{
filter[i] = Filter(i, FFTSize);
}
//fixed (double* kernel = Kernel) {
// int len = conv.Convolve(input, FFTSize, input2, FFTSize);
// len = conv.ConvolveFinal(input2 + len, FFTSize - len);
//}
//input[0] = 1;
//for (int i = 1; i < FFTSize; i++) {
// input[i] = 0;
//}
//for (int i = 0; i < FFTSize; i++) {
// input[i] = i % 2 == 0 ? 1 : 0;
//}
fft.WriteInput(input);
fft.Execute();
fft.ReadOutput(output);
{
var sum = 0d;
for (int i = 0; i < output.Length; i++)
{
var c = output[i] / (i > 0 ? fft.FFTSize / 2 : FFTSize);
var abs = Complex.Abs(c);
sum += abs;
Console.WriteLine($"{i}=abs({c.Real:N6},{c.Imaginary:N6})={abs:N6}");
}
Console.WriteLine($"sum={sum:N6}");
}
//output[0] = 100 * FFTSize;
//for (int i = 1; i < 50; i++) {
// output[i] = output[FFTSize - i] = 100 * FFTSize / 2;
//}
for (int i = 0; i < FFTSize; i++)
{
output[i] *= filter[i];
}
var ifft = new FFT(FFTSize, fftw_direction.Backward);
ifft.WriteInput(output);
ifft.Execute();
ifft.ReadOutput(input2);
for (int i = 0; i < input2.Length; i++)
{
input2[i] /= FFTSize;
}
fft.WriteInput(input2);
fft.Execute();
fft.ReadOutput(output);
{
var sum = 0d;
for (int i = 0; i < output.Length; i++)
{
var c = output[i] / (i > 0 ? fft.FFTSize / 2 : FFTSize);
var abs = Complex.Abs(c);
sum += abs;
Console.WriteLine($"{i}=abs({c.Real:N6},{c.Imaginary:N6})={abs:N6}");
}
Console.WriteLine($"sum={sum:N6}");
}
}
static void Main(string[] args)
{
Uri faultProbabilityUri = UriFromArg(args, 0);
Uri horizonUri = UriFromArg(args, 1);
GeodysseyModel model = new GeodysseyModel();
LoaderController.Instance.Open(faultProbabilityUri, model);
IRegularGrid2D pFaultGrid = model[0]; // The first grid
LoaderController.Instance.Open(horizonUri, model);
IRegularGrid2D horizon = model[1]; // Horizon grid
GridImage pFaultImage = new GridImage(pFaultGrid);
GridImage pFaultImageX = (GridImage)pFaultImage.Clone();
pFaultImageX.Clear();
GridImage pFaultImageY = (GridImage)pFaultImage.Clone();
pFaultImageY.Clear();
Convolver.GaussianGradient(pFaultImage, pFaultImageX, pFaultImageY, 1.0);
GridImage pFaultImageXX = (GridImage)pFaultImage.Clone();
pFaultImageXX.Clear();
GridImage pFaultImageYY = (GridImage)pFaultImage.Clone();
pFaultImageYY.Clear();
GridImage pFaultImageXY = (GridImage)pFaultImage.Clone();
pFaultImageXY.Clear();
Convolver.HessianMatrixOfGaussian(pFaultImage, pFaultImageXX, pFaultImageYY, pFaultImageXY, 1.0);
//GridImage pFaultImageBeta = (GridImage) RidgeDetector.PrincipleCurvatureDirection(pFaultImageXX, pFaultImageYY, pFaultImageXY);
//GridImage pFaultImagePQ = (GridImage) RidgeDetector.LocalLpq(pFaultImageXX, pFaultImageYY, pFaultImageXY, pFaultImageBeta);
//GridImage pFaultImageP = (GridImage) RidgeDetector.LocalLp(pFaultImageX, pFaultImageY, pFaultImageBeta);
//GridImage pFaultImageQ = (GridImage) RidgeDetector.LocalLq(pFaultImageX, pFaultImageY, pFaultImageBeta);
//GridImage pFaultImagePP = (GridImage) RidgeDetector.LocalLpp(pFaultImageXX, pFaultImageYY, pFaultImageXY, pFaultImageBeta);
//GridImage pFaultImageQQ = (GridImage) RidgeDetector.LocalLqq(pFaultImageXX, pFaultImageYY, pFaultImageXY, pFaultImageBeta);
Trace.WriteLine("Ridge detector");
GridImage pFaultImageRidge = (GridImage)RidgeDetector.Detect(pFaultImageX, pFaultImageY, pFaultImageXX, pFaultImageYY, pFaultImageXY);
IImage <bool> ridge = pFaultImageRidge.CreateBinaryImage(0.0);
Trace.WriteLine("Pepper filter");
IImage <bool> filtered = Morphology.PepperFiltering(5, ridge);
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);
Trace.WriteLine("Connectivity");
IImage <int> connectivity = BitImage.Analysis.Connectivity(filled);
Trace.WriteLine("Connected components");
IImage <int> components = BitImage.Analysis.ConnectedComponents(filled);
Trace.WriteLine("Mapping faults");
FaultNetwork network = FaultNetworkMapper.MapFaultNetwork(filled, horizon);
Trace.WriteLine("Mapping displacements");
FaultDisplacementMapper displacementMapper = new FaultDisplacementMapper(network);
var mesh = displacementMapper.GetResult();
// Output files of mesh
Trace.WriteLine("Writing faults");
string faultSegmentsPath = faultProbabilityUri.LocalPath.Replace(".grd", "_faults.poly");
string monoSegmentsPath = faultProbabilityUri.LocalPath.Replace(".grd", "_mono.poly");
using (StreamWriter faultFile = new StreamWriter(faultSegmentsPath))
using (StreamWriter monoFile = new StreamWriter(monoSegmentsPath))
{
foreach (EdgeBase edge in mesh.Edges)
{
StreamWriter file = edge is FaultEdge ? faultFile : monoFile;
Point2D source = ((PositionedVertexBase)edge.Source).Position;
Point2D target = ((PositionedVertexBase)edge.Target).Position;
file.WriteLine("{0}\t{1}", source.X, source.Y);
file.WriteLine("{0}\t{1}", target.X, target.Y);
file.WriteLine("%");
}
}
// Establish order in the mesh
Trace.WriteLine("Build planar subdivision - Ordering mesh and inserting faces");
var orderer = new Orderer2D <PositionedVertexBase, EdgeBase, FaceBase>(mesh);
var orderedMesh = orderer.GetResult();
Debug.Assert(orderedMesh.Euler == 2);
// Triangulate the mesh
// Copy the list of monotone faces, so we can iterate over it it
// whilst modifying the faces in the mesh during triangulation.
Trace.WriteLine("Triangulating");
List <FaceBase> faces = new List <FaceBase>(orderedMesh.Faces);
foreach (FaceBase face in faces)
{
var triangulator = new MonotonePolygonTriangulator <PositionedVertexBase, EdgeBase, FaceBase>(orderedMesh, face);
triangulator.GetResult();
}
// Improve triangulation quality
var improver = new TriangulationQualityImprover <PositionedVertexBase, EdgeBase, FaceBase>(mesh); // TODO: Add a flippable critera
improver.Improve();
Trace.WriteLine("Writing mesh");
// Output the mesh
Random rng = new Random();
string facesPath = faultProbabilityUri.LocalPath.Replace(".grd", "_faces.poly");
using (StreamWriter facesFile = new StreamWriter(facesPath))
{
// All faces except the last one...
foreach (FaceBase face in orderedMesh.Faces.Take(orderedMesh.FaceCount - 1))
{
foreach (VertexBase vertex in face.Vertices)
{
PositionedVertexBase pos = (PositionedVertexBase)vertex;
Point2D point = pos.Position;
facesFile.WriteLine("{0}\t{1}", point.X, point.Y);
}
int red = rng.Next(255);
int green = rng.Next(255);
int blue = rng.Next(255);
facesFile.WriteLine("% -W0/{0}/{1}/{2} -G{0}/{1}/{2}", red, green, blue);
}
}
// Convert images to grids for convenient output
//GridImage filteredGrid = (GridImage) pFaultImageRidge.Clone();
//for (int i = 0; i < filteredGrid.Width; ++i)
//{
// for (int j = 0; j < filteredGrid.Height; ++j)
// {
// filteredGrid[i, j] = filtered[i, j] ? 1.0 : 0.0;
// }
//}
//GridImage closedGrid = (GridImage) pFaultImageRidge.Clone();
//for (int i = 0; i < closedGrid.Width; ++i)
//{
// for (int j = 0; j < closedGrid.Height; ++j)
// {
// closedGrid[i, j] = closed[i, j] ? 1.0 : 0.0;
// }
//}
//GridImage thinnedGrid = (GridImage) pFaultImageRidge.Clone();
//for (int i = 0; i < thinnedGrid.Width; ++i)
//{
// for (int j = 0; j < thinnedGrid.Height; ++j)
// {
// thinnedGrid[i, j] = thinned[i, j] ? 1.0 : 0.0;
// }
//}
//GridImage blockThinnedGrid = (GridImage) pFaultImageRidge.Clone();
//for (int i = 0; i < blockThinnedGrid.Width; ++i)
//{
// for (int j = 0; j < blockThinnedGrid.Height; ++j)
// {
// blockThinnedGrid[i, j] = blockthinned[i, j] ? 1.0 : 0.0;
// }
//}
GridImage filledGrid = (GridImage)pFaultImageRidge.Clone();
for (int i = 0; i < filledGrid.Width; ++i)
{
for (int j = 0; j < filledGrid.Height; ++j)
{
filledGrid[i, j] = filled[i, j] ? 1.0 : 0.0;
}
}
//GridImage connectivityGrid = (GridImage) pFaultImageRidge.Clone();
//for (int i = 0; i < filledGrid.Width; ++i)
//{
// for (int j = 0; j < filledGrid.Height; ++j)
// {
// connectivityGrid[i, j] = connectivity[i, j];
// }
//}
//GridImage componentsGrid = (GridImage) pFaultImageRidge.Clone();
//for (int i = 0; i < componentsGrid.Width; ++i)
//{
// for (int j = 0; j < componentsGrid.Height; ++j)
// {
// componentsGrid[i, j] = components[i, j];
// }
//}
//string pathX = faultProbabilityUri.LocalPath.Replace(".", "_x.");
//string pathY = faultProbabilityUri.LocalPath.Replace(".", "_y.");
//string pathXX = faultProbabilityUri.LocalPath.Replace(".", "_xx.");
//string pathYX = faultProbabilityUri.LocalPath.Replace(".", "_yy.");
//string pathXY = faultProbabilityUri.LocalPath.Replace(".", "_xy.");
//string pathBeta = faultProbabilityUri.LocalPath.Replace(".", "_beta.");
//string pathPQ = faultProbabilityUri.LocalPath.Replace(".", "_pq.");
//string pathP = faultProbabilityUri.LocalPath.Replace(".", "_p.");
//string pathQ = faultProbabilityUri.LocalPath.Replace(".", "_q.");
//string pathPP = faultProbabilityUri.LocalPath.Replace(".", "_pp.");
//string pathQQ = faultProbabilityUri.LocalPath.Replace(".", "_qq.");
//string pathRidge = faultProbabilityUri.LocalPath.Replace(".", "_ridge.");
//string pathFiltered = faultProbabilityUri.LocalPath.Replace(".", "_filtered.");
//string pathClosed = faultProbabilityUri.LocalPath.Replace(".", "_closed.");
//string pathThinned = faultProbabilityUri.LocalPath.Replace(".", "_thinned.");
//string pathBlockThinned = faultProbabilityUri.LocalPath.Replace(".", "_blockthinned.");
string pathFilled = faultProbabilityUri.LocalPath.Replace(".", "_filled.");
//string pathConnectivity = faultProbabilityUri.LocalPath.Replace(".", "_connectivity.");
//string pathComponents = faultProbabilityUri.LocalPath.Replace(".", "_components.");
//string pathFaultLines = faultProbabilityUri.LocalPath.Replace(".grd", "_faults.poly");
string pathBisectors = faultProbabilityUri.LocalPath.Replace(".grd", "_bisectors.poly");
string pathLabels = faultProbabilityUri.LocalPath.Replace(".grd", "_labels.xy");
string pathStrands = faultProbabilityUri.LocalPath.Replace(".grd", "_strands.poly");
//pFaultImageX.Grid.WriteSurfer6BinaryFile(pathX);
//pFaultImageY.Grid.WriteSurfer6BinaryFile(pathY);
//pFaultImageXX.Grid.WriteSurfer6BinaryFile(pathXX);
//pFaultImageYY.Grid.WriteSurfer6BinaryFile(pathXY);
//pFaultImageXY.Grid.WriteSurfer6BinaryFile(pathXY);
//pFaultImageBeta.Grid.WriteSurfer6BinaryFile(pathBeta);
//pFaultImagePQ.Grid.WriteSurfer6BinaryFile(pathPQ);
//pFaultImageP.Grid.WriteSurfer6BinaryFile(pathP);
//pFaultImageQ.Grid.WriteSurfer6BinaryFile(pathQ);
//pFaultImagePP.Grid.WriteSurfer6BinaryFile(pathPP);
//pFaultImageQQ.Grid.WriteSurfer6BinaryFile(pathQQ);
//pFaultImageRidge.Grid.WriteSurfer6BinaryFile(pathRidge);
//filteredGrid.Grid.WriteSurfer6BinaryFile(pathFiltered);
//closedGrid.Grid.WriteSurfer6BinaryFile(pathClosed);
//thinnedGrid.Grid.WriteSurfer6BinaryFile(pathThinned);
//blockThinnedGrid.Grid.WriteSurfer6BinaryFile(pathBlockThinned);
filledGrid.Grid.WriteSurfer6BinaryFile(pathFilled);
//connectivityGrid.Grid.WriteSurfer6BinaryFile(pathConnectivity);
//componentsGrid.Grid.WriteSurfer6BinaryFile(pathComponents);
//mapper.OutputPolygons(pathFaultLines);
//displacementMapper.OutputBisectors(pathBisectors);
//displacementMapper.OutputLabels(pathLabels);
//displacementMapper.OutputStrands(pathStrands);
}
/// <summary>
/// Calculate data terms for specified coordinates
/// </summary>
/// <param name="selectionBorder"></param>
/// <param name="layerPixels"></param>
/// <param name="windowSize"></param>
/// <returns></returns>
private static IEnumerable<ImgGradient> GradientValues(List<IntCoordinate> selectionBorder, Pixel[,] layerPixels, SelectionMask selection, int windowSize)
{
var convolver = new Convolver(ScharrKernel.Instance);
foreach (var coord in selectionBorder)
{
ImgGradient max = null;
foreach (var sourceCoord in
RegionHelper.Grid(coord.PointCenteredRectangle(windowSize))
.Where(neigbour => !selection[neigbour.X, neigbour.Y]))
{
var grad = convolver.Convolve(sourceCoord, layerPixels,
pixel => (pixel.Red + pixel.Green + pixel.Blue)/(1.0*255.0));
if (max == null)
{
max = grad;
}
max = grad.Magnitude > max.Magnitude ? grad : max;
}
yield return max;
}
}
void OnEnable()
{
source = GetComponent <AudioSource3D>();
filter = new Convolver(new float[MaxSamples], 0);
source.AddFilter(filter);
}
