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); }