def Decimation_test(): import numpy as np from ATK.Core import DoubleInPointerFilter, DoubleOutPointerFilter from ATK.Tools import DoubleDecimationFilter from numpy.testing import assert_almost_equal input = np.sin(np.arange(2000, dtype=np.float64)[None,:] * 1000 * 2 * np.pi / 96000) output = np.ascontiguousarray(np.zeros(1000, dtype=np.float64)[None,:]) inputfilter = DoubleInPointerFilter(input, False) decimationfilter = DoubleDecimationFilter(1) outputfilter = DoubleOutPointerFilter(output, False) inputfilter.output_sampling_rate = 96000 decimationfilter.input_sampling_rate = 96000 decimationfilter.output_sampling_rate = 48000 outputfilter.input_sampling_rate = 48000 decimationfilter.set_input_port(0, inputfilter, 0) outputfilter.set_input_port(0, decimationfilter, 0) outputfilter.process(1000) assert_almost_equal(input[:,::2], output)
def Oversampling_16_test(): import numpy as np from ATK.Core import DoubleInPointerFilter, DoubleOutPointerFilter from ATK.Tools import DoubleOversampling6points5order_16Filter from numpy.testing import assert_almost_equal ref = np.sin( np.arange(16000, dtype=np.float64)[None, :] * 1000 * 2 * np.pi / 768000) input = np.ascontiguousarray(ref[:, ::16]) output = np.ascontiguousarray(np.zeros(16000, dtype=np.float64)[None, :]) inputfilter = DoubleInPointerFilter(input, False) oversamplingfilter = DoubleOversampling6points5order_16Filter() outputfilter = DoubleOutPointerFilter(output, False) inputfilter.output_sampling_rate = 48000 oversamplingfilter.input_sampling_rate = 48000 oversamplingfilter.output_sampling_rate = 768000 outputfilter.input_sampling_rate = 768000 oversamplingfilter.set_input_port(0, inputfilter, 0) outputfilter.set_input_port(0, oversamplingfilter, 0) outputfilter.process(16000) assert_almost_equal(ref[:, 952:-48], output[:, 1000:], decimal=1)
def filter(input): infilter = DoubleInPointerFilter(input) infilter.output_sampling_rate = sampling_rate attackreleasefilter = DoubleAttackReleaseFilter(1) attackreleasefilter.input_sampling_rate = sampling_rate attackreleasefilter.set_input_port(0, infilter, 0) attackreleasefilter.attack = np.exp(-1/(sampling_rate*1e-3)) attackreleasefilter.release = np.exp(-1/(sampling_rate*10e-3)) outdata = np.zeros(processsize, dtype=np.float64) outfilter = DoubleOutPointerFilter(outdata) outfilter.input_sampling_rate = sampling_rate outfilter.set_input_port(0, attackreleasefilter, 0) attackreleasefilter2 = DoubleAttackReleaseHysteresisFilter(1) attackreleasefilter2.input_sampling_rate = sampling_rate attackreleasefilter2.set_input_port(0, infilter, 0) attackreleasefilter2.attack = np.exp(-1/(sampling_rate*1e-3)) attackreleasefilter2.release = np.exp(-1/(sampling_rate*10e-3)) attackreleasefilter2.release_hysteresis = .5 attackreleasefilter2.attack_hysteresis = .9 outdata2 = np.zeros(processsize, dtype=np.float64) outfilter_hyst = DoubleOutPointerFilter(outdata2) outfilter_hyst.input_sampling_rate = sampling_rate outfilter_hyst.set_input_port(0, attackreleasefilter2, 0) pipelineend = PipelineGlobalSinkFilter() pipelineend.input_sampling_rate = sampling_rate pipelineend.add_filter(outfilter) pipelineend.add_filter(outfilter_hyst) pipelineend.process(processsize) return outdata, outdata2
def Decimation_test(): import numpy as np from ATK.Core import DoubleInPointerFilter, DoubleOutPointerFilter from ATK.Tools import DoubleDecimationFilter from numpy.testing import assert_almost_equal input = np.sin( np.arange(2000, dtype=np.float64)[None, :] * 1000 * 2 * np.pi / 96000) output = np.ascontiguousarray(np.zeros(1000, dtype=np.float64)[None, :]) inputfilter = DoubleInPointerFilter(input, False) decimationfilter = DoubleDecimationFilter(1) outputfilter = DoubleOutPointerFilter(output, False) inputfilter.output_sampling_rate = 96000 decimationfilter.input_sampling_rate = 96000 decimationfilter.output_sampling_rate = 48000 outputfilter.input_sampling_rate = 48000 decimationfilter.set_input_port(0, inputfilter, 0) outputfilter.set_input_port(0, decimationfilter, 0) outputfilter.process(1000) assert_almost_equal(input[:, ::2], output)
def filter(input): infilter = DoubleInPointerFilter(input) infilter.output_sampling_rate = sampling_rate attackreleasefilter = DoubleAttackReleaseFilter(1) attackreleasefilter.input_sampling_rate = sampling_rate attackreleasefilter.set_input_port(0, infilter, 0) attackreleasefilter.attack = np.exp(-1 / (sampling_rate * 1e-3)) attackreleasefilter.release = np.exp(-1 / (sampling_rate * 10e-3)) outdata = np.zeros(processsize, dtype=np.float64) outfilter = DoubleOutPointerFilter(outdata) outfilter.input_sampling_rate = sampling_rate outfilter.set_input_port(0, attackreleasefilter, 0) attackreleasefilter2 = DoubleAttackReleaseHysteresisFilter(1) attackreleasefilter2.input_sampling_rate = sampling_rate attackreleasefilter2.set_input_port(0, infilter, 0) attackreleasefilter2.attack = np.exp(-1 / (sampling_rate * 1e-3)) attackreleasefilter2.release = np.exp(-1 / (sampling_rate * 10e-3)) attackreleasefilter2.release_hysteresis = .5 attackreleasefilter2.attack_hysteresis = .9 outdata2 = np.zeros(processsize, dtype=np.float64) outfilter_hyst = DoubleOutPointerFilter(outdata2) outfilter_hyst.input_sampling_rate = sampling_rate outfilter_hyst.set_input_port(0, attackreleasefilter2, 0) pipelineend = PipelineGlobalSinkFilter() pipelineend.input_sampling_rate = sampling_rate pipelineend.add_filter(outfilter) pipelineend.add_filter(outfilter_hyst) pipelineend.process(processsize) return outdata, outdata2
def MiddleSide_test(): import numpy as np from ATK.Core import DoubleInPointerFilter, DoubleOutPointerFilter from ATK.Tools import DoubleMiddleSideFilter from numpy.testing import assert_almost_equal t = np.arange(1000, dtype=np.float64) input = np.sin(np.array((t, t)) * 1000 * 2 * np.pi / 48000) output = np.ascontiguousarray(np.zeros(2000, dtype=np.float64).reshape(2, -1)) inputfilter = DoubleInPointerFilter(input, False) msfilter = DoubleMiddleSideFilter() outputfilter = DoubleOutPointerFilter(output, False) inputfilter.output_sampling_rate = 48000 msfilter.input_sampling_rate = 48000 outputfilter.input_sampling_rate = 48000 msfilter.set_input_port(0, inputfilter, 0) msfilter.set_input_port(1, inputfilter, 1) outputfilter.set_input_port(0, msfilter, 0) outputfilter.set_input_port(1, msfilter, 1) outputfilter.process(1000) assert_almost_equal(input[0]*2, output[0]) assert_almost_equal(0, output[1])
def Volume_test(): import numpy as np from ATK.Core import DoubleInPointerFilter, DoubleOutPointerFilter from ATK.Tools import DoubleVolumeFilter from numpy.testing import assert_almost_equal input = np.sin( np.arange(1000, dtype=np.float64)[None, :] * 1000 * 2 * np.pi / 48000) output = np.ascontiguousarray(np.zeros(1000, dtype=np.float64)[None, :]) inputfilter = DoubleInPointerFilter(input, False) volumefilter = DoubleVolumeFilter() outputfilter = DoubleOutPointerFilter(output, False) inputfilter.output_sampling_rate = 48000 volumefilter.input_sampling_rate = 48000 volumefilter.volume = .5 outputfilter.input_sampling_rate = 48000 volumefilter.set_input_port(0, inputfilter, 0) outputfilter.set_input_port(0, volumefilter, 0) outputfilter.process(1000) assert_almost_equal(.5 * input, output)
def MiddleSide_test(): import numpy as np from ATK.Core import DoubleInPointerFilter, DoubleOutPointerFilter from ATK.Tools import DoubleMiddleSideFilter from numpy.testing import assert_almost_equal t = np.arange(1000, dtype=np.float64) input = np.sin(np.array((t, t)) * 1000 * 2 * np.pi / 48000) output = np.ascontiguousarray( np.zeros(2000, dtype=np.float64).reshape(2, -1)) inputfilter = DoubleInPointerFilter(input, False) msfilter = DoubleMiddleSideFilter() outputfilter = DoubleOutPointerFilter(output, False) inputfilter.output_sampling_rate = 48000 msfilter.input_sampling_rate = 48000 outputfilter.input_sampling_rate = 48000 msfilter.set_input_port(0, inputfilter, 0) msfilter.set_input_port(1, inputfilter, 1) outputfilter.set_input_port(0, msfilter, 0) outputfilter.set_input_port(1, msfilter, 1) outputfilter.process(1000) assert_almost_equal(input[0] * 2, output[0]) assert_almost_equal(0, output[1])
def Sum_test(): import numpy as np from ATK.Core import DoubleInPointerFilter, DoubleOutPointerFilter from ATK.Tools import DoubleSumFilter from numpy.testing import assert_almost_equal t = np.arange(1000, dtype=np.float64) input = np.sin(np.array((t, t)) * 1000 * 2 * np.pi / 48000) output = np.ascontiguousarray(np.zeros(1000, dtype=np.float64)[None, :]) inputfilter = DoubleInPointerFilter(input, False) sumfilter = DoubleSumFilter() outputfilter = DoubleOutPointerFilter(output, False) inputfilter.output_sampling_rate = 48000 sumfilter.input_sampling_rate = 48000 outputfilter.input_sampling_rate = 48000 sumfilter.set_input_port(0, inputfilter, 0) sumfilter.set_input_port(1, inputfilter, 1) outputfilter.set_input_port(0, sumfilter, 0) outputfilter.process(1000) assert_almost_equal(2 * input[0], output[0])
def DoubleBandPassCoefficientsIIRFilter_test(): import numpy as np from ATK.Core import DoubleInPointerFilter, DoubleOutPointerFilter from ATK.EQ import DoubleSecondOrderBandPassFilter from numpy.testing import assert_almost_equal input = np.sin(np.arange(1000, dtype=np.float64)[None,:] * 1000 * 2 * np.pi / 48000) output = np.ascontiguousarray(np.zeros(1000, dtype=np.float64)[None,:]) inputfilter = DoubleInPointerFilter(input, False) EQfilter = DoubleSecondOrderBandPassFilter() outputfilter = DoubleOutPointerFilter(output, False) inputfilter.output_sampling_rate = 48000 EQfilter.input_sampling_rate = 48000 EQfilter.Q = 1 EQfilter.cut_frequency = 1000 outputfilter.input_sampling_rate = 48000 EQfilter.set_input_port(0, inputfilter, 0) outputfilter.set_input_port(0, EQfilter, 0) outputfilter.process(1000) assert_almost_equal(input[0,500:], input[0,500] / output[0,500] * output[0,500:])
def filter(input, blend=0, feedback=0, feedforward=1): import numpy as np output = np.zeros(input.shape, dtype=np.float64) infilter = DoubleInPointerFilter(input, False) infilter.output_sampling_rate = sample_rate generator = DoubleSinusGeneratorFilter() generator.output_sampling_rate = sample_rate generator.frequency = 1 generator.volume = 1e-3*sample_rate generator.offset = 1.5e-3*sample_rate delayfilter = DoubleUniversalVariableDelayLineFilter(5000) delayfilter.input_sampling_rate = sample_rate delayfilter.set_input_port(0, infilter, 0) delayfilter.set_input_port(1, generator, 0) delayfilter.blend = blend delayfilter.feedback = feedback delayfilter.feedforward = feedforward outfilter = DoubleOutPointerFilter(output, False) outfilter.input_sampling_rate = sample_rate outfilter.set_input_port(0, delayfilter, 0) outfilter.process(input.shape[1]) return output
def Oversampling_16_test(): import numpy as np from ATK.Core import DoubleInPointerFilter, DoubleOutPointerFilter from ATK.Tools import DoubleOversampling6points5order_16Filter from numpy.testing import assert_almost_equal ref = np.sin(np.arange(16000, dtype=np.float64)[None,:] * 1000 * 2 * np.pi / 768000) input = np.ascontiguousarray(ref[:, ::16]) output = np.ascontiguousarray(np.zeros(16000, dtype=np.float64)[None,:]) inputfilter = DoubleInPointerFilter(input, False) oversamplingfilter = DoubleOversampling6points5order_16Filter() outputfilter = DoubleOutPointerFilter(output, False) inputfilter.output_sampling_rate = 48000 oversamplingfilter.input_sampling_rate = 48000 oversamplingfilter.output_sampling_rate = 768000 outputfilter.input_sampling_rate = 768000 oversamplingfilter.set_input_port(0, inputfilter, 0) outputfilter.set_input_port(0, oversamplingfilter, 0) outputfilter.process(16000) assert_almost_equal(ref[:,952:-48], output[:,1000:], decimal=1)
def Sum_test(): import numpy as np from ATK.Core import DoubleInPointerFilter, DoubleOutPointerFilter from ATK.Tools import DoubleSumFilter from numpy.testing import assert_almost_equal t = np.arange(1000, dtype=np.float64) input = np.sin(np.array((t, t)) * 1000 * 2 * np.pi / 48000) output = np.ascontiguousarray(np.zeros(1000, dtype=np.float64)[None,:]) inputfilter = DoubleInPointerFilter(input, False) sumfilter = DoubleSumFilter() outputfilter = DoubleOutPointerFilter(output, False) inputfilter.output_sampling_rate = 48000 sumfilter.input_sampling_rate = 48000 outputfilter.input_sampling_rate = 48000 sumfilter.set_input_port(0, inputfilter, 0) sumfilter.set_input_port(1, inputfilter, 1) outputfilter.set_input_port(0, sumfilter, 0) outputfilter.process(1000) assert_almost_equal(2*input[0], output[0])
def Volume_test(): import numpy as np from ATK.Core import DoubleInPointerFilter, DoubleOutPointerFilter from ATK.Tools import DoubleVolumeFilter from numpy.testing import assert_almost_equal input = np.sin(np.arange(1000, dtype=np.float64)[None,:] * 1000 * 2 * np.pi / 48000) output = np.ascontiguousarray(np.zeros(1000, dtype=np.float64)[None,:]) inputfilter = DoubleInPointerFilter(input, False) volumefilter = DoubleVolumeFilter() outputfilter = DoubleOutPointerFilter(output, False) inputfilter.output_sampling_rate = 48000 volumefilter.input_sampling_rate = 48000 volumefilter.volume = .5 outputfilter.input_sampling_rate = 48000 volumefilter.set_input_port(0, inputfilter, 0) outputfilter.set_input_port(0, volumefilter, 0) outputfilter.process(1000) assert_almost_equal(.5 * input, output)
def DoublePointerFilter2_new_test(): import numpy as np from ATK.Core import DoubleInPointerFilter, DoubleOutPointerFilter from numpy.testing import assert_equal input = np.arange(1000, dtype=np.float64) output = np.zeros(1000, dtype=np.float64) inputfilter = DoubleInPointerFilter(input) outputfilter = DoubleOutPointerFilter(output) outputfilter.set_input_port(0, inputfilter, 0) inputfilter.output_sampling_rate = 48000 outputfilter.input_sampling_rate = 48000 outputfilter.process(1000) assert_equal(input, output)
def DoublePointerFilter2_new_test(): import numpy as np from ATK.Core import DoubleInPointerFilter, DoubleOutPointerFilter from numpy.testing import assert_equal input = np.arange(1000, dtype=np.float64) output = np.zeros(1000, dtype=np.float64) inputfilter = DoubleInPointerFilter(input) outputfilter = DoubleOutPointerFilter(output) outputfilter.set_input_port(0, inputfilter, 0) inputfilter.output_sampling_rate = 48000 outputfilter.input_sampling_rate = 48000 outputfilter.process(1000) assert_equal(input, output)
def PipelineGlobalSinkFilter_usage_test(): import numpy as np from ATK.Core import DoubleInPointerFilter, DoubleOutPointerFilter, PipelineGlobalSinkFilter from numpy.testing import assert_equal input = np.ascontiguousarray(np.arange(1000, dtype=np.float64)[None,:]) output = np.ascontiguousarray(np.zeros(1000, dtype=np.float64)[None,:]) inputfilter = DoubleInPointerFilter(input, False) outputfilter = DoubleOutPointerFilter(output, False) outputfilter.set_input_port(0, inputfilter, 0) inputfilter.output_sampling_rate = 48000 outputfilter.input_sampling_rate = 48000 sink = PipelineGlobalSinkFilter() sink.add_filter(outputfilter) sink.input_sampling_rate = 48000 sink.process(1000) assert_equal(input, output)
def DoubleConvertFilter_new_test(): import numpy as np from ATK.Core import DoubleRealToComplexFilter from ATK.Core import DoubleInPointerFilter, ComplexDoubleOutPointerFilter from numpy.testing import assert_equal input = np.ascontiguousarray(np.arange(1000, dtype=np.float64)) output = np.ascontiguousarray(np.zeros(1000, dtype=np.complex128)) inputfilter = DoubleInPointerFilter(input) convertFilter = DoubleRealToComplexFilter() outputfilter = ComplexDoubleOutPointerFilter(output) convertFilter.set_input_port(0, inputfilter, 0) convertFilter.set_input_port(1, inputfilter, 0) outputfilter.set_input_port(0, convertFilter, 0) inputfilter.output_sampling_rate = 48000 convertFilter.input_sampling_rate = 48000 outputfilter.input_sampling_rate = 48000 outputfilter.process(1000) assert_equal(input + 1j * input, output)
def DoubleConvertFilter_new_test(): import numpy as np from ATK.Core import DoubleRealToComplexFilter from ATK.Core import DoubleInPointerFilter, ComplexDoubleOutPointerFilter from numpy.testing import assert_equal input = np.ascontiguousarray(np.arange(1000, dtype=np.float64)) output = np.ascontiguousarray(np.zeros(1000, dtype=np.complex128)) inputfilter = DoubleInPointerFilter(input) convertFilter = DoubleRealToComplexFilter() outputfilter = ComplexDoubleOutPointerFilter(output) convertFilter.set_input_port(0, inputfilter, 0) convertFilter.set_input_port(1, inputfilter, 0) outputfilter.set_input_port(0, convertFilter, 0) inputfilter.output_sampling_rate = 48000 convertFilter.input_sampling_rate = 48000 outputfilter.input_sampling_rate = 48000 outputfilter.process(1000) assert_equal(input + 1j * input, output)
pass import numpy as np from matplotlib import pyplot as plt plt.style.use("dark_background") length = 10000 sampling_rate = 100000 t = np.arange(length)[None, :] * (1 / sampling_rate) x = np.sin(2 * np.pi * 50 * t) input = DoubleInPointerFilter(x) input.input_sampling_rate = sampling_rate input.output_sampling_rate = sampling_rate filter = DoubleModellerFilter.create_dynamic_filter(ast) filter.input_sampling_rate = sampling_rate filter.output_sampling_rate = sampling_rate filter.set_input_port(0, input, 0) y = np.zeros((11, length)) output = DoubleOutPointerFilter(y) output.input_sampling_rate = sampling_rate output.output_sampling_rate = sampling_rate output.set_input_port(0, filter, 0) output.set_input_port(1, filter, 1) output.set_input_port(2, filter, 2) output.set_input_port(3, filter, 3) output.set_input_port(4, filter, 4)