public void ApplyMedianFilterFromFileTest()
{
// preperation
FileStream inputFile = new FileStream("..\\..\\..\\Resources\\OriginalCat.bmp", FileMode.Open, FileAccess.Read);
FileStream expectedOutputFile = new FileStream("..\\..\\..\\Resources\\MedianFilterCat.bmp", FileMode.Open, FileAccess.Read);
byte[] temp = new byte[54];
inputFile.Read(temp, 0, 54);
BMPFileHeader bmpInfo = new BMPFileHeader(temp);
MedianFilter image = new MedianFilter(bmpInfo, inputFile);
// checking
image.ApplyMedianFilter();
byte[] outputFile = new byte[bmpInfo.FileSize];
image.WriteImage(outputFile);
for (uint i = 0; i < bmpInfo.FileSize; i++)
{
Assert.IsTrue(outputFile[i] == (byte)expectedOutputFile.ReadByte());
}
inputFile.Close();
expectedOutputFile.Close();
}
private void Start()
{
sharpness = FindObjectOfType <MatrixFilter>();
linearCorrection = FindObjectOfType <LinearCorrection>();
blackWhite = FindObjectOfType <BlackWhite>();
medianFilter = FindObjectOfType <MedianFilter>();
}
public void CanGetValidMedianFiltration()
{
//Arrange
MedianFilter filter = new MedianFilter();
double[] input1 = { 2, 80, 6, 3 };
int window1 = 3;
double[] reference1 = { 2, 6, 6, 3 };
double[] input2 = { 17, 38, 9, 63, 41, 15 };
int window2 = 4;
double[] reference2 = { 17, 17, 27.5, 39.5, 28, 28 };
double[] input3 = { 7, 100, 1, 33, 12, 1, 56 };
int window3 = 5;
double[] reference3 = { 7, 7, 12, 12, 12, 33, 56 };
//Action
double[] result1 = filter.GetMedianFiltration(input1, window1);
double[] result2 = filter.GetMedianFiltration(input2, window2);
double[] result3 = filter.GetMedianFiltration(input3, window3);
//Assert
CollectionAssert.AreEqual(reference1, result1);
CollectionAssert.AreEqual(reference2, result2);
CollectionAssert.AreEqual(reference3, result3);
}
public MedianFilters()
{
_signal = new WhiteNoiseBuilder().OfLength(N).Build();
_filter = new MedianFilter(15);
_filter2 = new MedianFilter2(15);
}
public static void Run()
{
// ExStart:ApplyingCorrectionFilters
// The path to the documents directory.
string dataDir = RunExamples.GetDataDir_OCR();
// Initialize an instance of OcrEngine
OcrEngine ocrEngine = new OcrEngine();
// Set Image property by loading an image from file path
ocrEngine.Image = ImageStream.FromFile(dataDir + "Sampleocr.bmp");
// Create CorrectionFilters collection
CorrectionFilters filters = new CorrectionFilters();
Filter filter = null;
// Initialize Median filter
filter = new MedianFilter(5);
filters.Add(filter);
// Create Gaussian Blur filter
filter = new GaussBlurFilter();
filters.Add(filter);
// Assign collection to OcrEngine
ocrEngine.Config.CorrectionFilters = filters;
// Run recognition process
if (ocrEngine.Process())
{
// Display results
Console.WriteLine(ocrEngine.Text);
}
// ExEnd:ApplyingCorrectionFilters
}
private void MedianFilter_Click(object sender, EventArgs e)
{
var bitmap = GetPictureBox().Image;
var medianFilter = new MedianFilter();
pictureBox5.Image = medianFilter.Filter((Bitmap)bitmap, trackBar1.Value);
}
public static IFilter Create(string filterKey)
{
IFilter result = null;
switch (filterKey)
{
case "Median":
result = new MedianFilter();
break;
case "Monochrome":
result = new MonochromeFilter();
break;
case "Sharpen":
result = new SharpenFilter();
break;
case "Boundary":
result = new Boundary();
break;
case "Otzu":
result = new Otcu();
break;
}
return result;
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="fftSize"></param>
/// <param name="hopSize"></param>
/// <param name="harmonicWinSize"></param>
/// <param name="percussiveWinSize"></param>
/// <param name="masking"></param>
public HarmonicPercussiveSeparator(int fftSize = 2048,
int hopSize = 512,
int harmonicWinSize = 17,
int percussiveWinSize = 17,
HpsMasking masking = HpsMasking.WienerOrder2)
{
_stft = new Stft(fftSize, hopSize);
_medianHarmonic = new MedianFilter(harmonicWinSize);
_medianPercussive = new MedianFilter(percussiveWinSize);
switch (masking)
{
case HpsMasking.Binary:
_mask = BinaryMask;
break;
case HpsMasking.WienerOrder1:
_mask = WienerMask1;
break;
default:
_mask = WienerMask2;
break;
}
}
private void medianButton_Click(object sender, EventArgs e)
{
var inputBitmap = new Bitmap(otherFiltersInputImgBox.Image);
var medianFilterMaskClient = new MedianFilter(inputBitmap,
Settings.Default.StoreAsColorWherePossible);
otherFiltersOutputImgBox.Image = medianFilterMaskClient.Filter();
}
public void MedianFilter_Defaultvalues_GivesCorrectKernel()
{ /// Test whether Medianfilter class throws correct exceptions
// Filter
MedianFilter medianDef = new MedianFilter();
Assert.Equal(5, medianDef.kernel);
Assert.Equal(2, medianDef.distance);
}
// NET HIKIPURO medexiann
private void button9_Click(object sender, EventArgs e)
{
Bitmap bitmap = new Bitmap(pictureBox1.Image);
bitmap = MedianFilter.Apply(bitmap);
pictureBox2.SizeMode = PictureBoxSizeMode.Zoom;
pictureBox2.Image = bitmap;
}
public void TestMedianFilter32()
{
BMPImage image = new BMPImage("../../../TestFiles/input32.bmp");
MedianFilter.Median(image);
image.WriteToFile("../../../TestFiles/output.bmp");
FileAssert.AreEqual("../../../TestFiles/output.bmp", "../../../TestFiles/Median32.bmp");
Assert.Pass();
}
private void medianToolStripMenuItem_Click(object sender, EventArgs e)
{
if (pictureBox1.Image != null)
{
cashBack.Push(image);
}
Filters filter = new MedianFilter();
backgroundWorker1.RunWorkerAsync(filter);
}
private void МедианныйФильтрToolStripMenuItem_Click(object sender, EventArgs e)
{
var bm = new Bitmap(pictureBox1.Image);
old_image = image;
image = bm;
Filters filter1 = new MedianFilter();
backgroundWorker1.RunWorkerAsync(filter1);
}
public void TestMedianFiltering()
{
var filter = new MedianFilter(5);
var input = new[] { 2, 6, 5, 4, 0, 3, 5, 7, 9, 2, 0, 1f };
var expected = new[] { 2, 4, 4, 4, 4, 4, 5, 5, 5, 2, 1, 0f };
var filtered = filter.ApplyTo(new DiscreteSignal(1, input));
Assert.That(filtered.Samples, Is.EqualTo(expected).Within(1e-10));
}
public void TestMedianFilteringDefault()
{
var filter = new MedianFilter(); // 9-point median filter
var input = new[] { 1, 6, 5, 2, 8, 1, 9, 5, 4, 2, 3, 4, 6, 7, 4f };
var expected = new[] { 1, 1, 2, 5, 5, 5, 4, 4, 4, 4, 4, 4, 4, 3, 3f };
var filtered = filter.ApplyTo(new DiscreteSignal(1, input));
Assert.That(filtered.Samples, Is.EqualTo(expected).Within(1e-10));
}
public static bool ApplyFilter(BitMapReading input, string filterName, string output)
{
uint width = input.Width;
uint height = input.Height;
int channels = input.BitsPerPixel / 8;
byte[][] image = input.Image;
byte[][] filteredImage;
switch (filterName)
{
case "GRAY":
filteredImage = GrayFilter.ApplyFilter(width, height, channels, image);
break;
case "MEDIAN":
filteredImage = MedianFilter.ApplyFilter(width, height, channels, image);
break;
case "GAUSS":
filteredImage = ConvolutionFilters.GaussFilter(width, height, channels, image);
break;
case "SOBELX":
filteredImage = ConvolutionFilters.SobelXFilter(width, height, channels, image);
break;
case "SOBELY":
filteredImage = ConvolutionFilters.SobelYFilter(width, height, channels, image);
break;
case "SOBEL":
case "SOBELXY":
filteredImage = ConvolutionFilters.SobelFilter(width, height, channels, image);
break;
default:
return(false);
}
try
{
new BitMapWriting(output, input.Header, filteredImage);
}
catch (Exception)
{
Console.WriteLine("Could not open\\create output file");
Environment.Exit(3);
}
Console.WriteLine($"{filterName} filter was applied successfully");
return(true);
}
private void btnProcessImage_Click(object sender, EventArgs e)
{
_algoryths["Собеля"] = new Sobel(_parameterSettingForm.SobelLimit);
_algoryths["Гаусса"] = new Gauss(_parameterSettingForm.Sigma);
_algoryths["Медианный"] = new MedianFilter(_parameterSettingForm.WindowSize);
_algoryths["Скользящее окно"] = new SlidingWindow(_parameterSettingForm.WindowSize);
if (_imageIsLoaded)
{
pictureBoxResult.Image = _algoryths[cmbBox.Text].Process(new Bitmap(pictureBoxResult.Image));
return;
}
MessageBox.Show("Load image first!");
}
public async void MedianFilterButton()
{
var metroWindow = Application.Current.MainWindow as MetroWindow;
var controller = await metroWindow.ShowProgressAsync("Proszę czekać...", "Trwa przetwarzanie obrazu");
controller.SetCancelable(false);
controller.SetIndeterminate();
var medianFilter = new MedianFilter();
var newBitmap = medianFilter.ExecuteFilter(this.ConvertFromBitmapImageToBitmap(this.DisplayedImage));
this.DisplayedImage = this.ConvertFromBitmapToBitmapImage(newBitmap);
await controller.CloseAsync();
}
/// <summary>
/// Set value
/// </summary>
private void SetValue()
{
var w = Colors.GetLength(0);
var h = Colors.GetLength(1);
var tempData = new byte[w + 2, h + 2, 1];
Data = new byte[w, h, 1];
Image = new bool[w, h];
for (int i = 0; i < w; i++)
{
for (int j = 0; j < h; j++)
{
var argb = Colors[i, j].ToArgb();
if (argb == Constant.ArgbWhite || argb == Constant.ArgbTunnel || argb == Constant.ArgbYellow)
{
tempData[i + 1, j + 1, 0] = 255;
}
else
{
tempData[i + 1, j + 1, 0] = 0;
}
}
}
MedianFilter.Filter(tempData);
for (int i = 0; i < 5; i++)
{
ZhangSuen.ZhangSuenThinning(tempData);
}
MedianFilter.CorrosiveHit(tempData);
for (int i = 0; i < w; i++)
{
for (int j = 0; j < h; j++)
{
Data[i, j, 0] = tempData[i + 1, j + 1, 0];
Image[i, j] = Data[i, j, 0] == 255 ? true : false;
if (Image[i, j])
{
Colors[i, j] = Color.Black;
}
else
{
Colors[i, j] = Color.White;
}
}
}
}
public void MedianFilter_LargeOrOddkernel_ThrowsCorrectException()
{ /// Test whether Medianfilter class throws correct exceptions
testImg.New("Quarters", new int[] { 6, 6 });
// Filter
MedianFilter medianLarge = new MedianFilter(15);
MedianFilter medianEven = new MedianFilter(4);
Exception ex = Assert.Throws <Exception>(
delegate { medianLarge.Filtering(testImg.Image.ToDouble()); });
Assert.Equal("Kernel radius is larger than input array!", ex.Message);
Exception ex2 = Assert.Throws <Exception>(
delegate { medianEven.Filtering(testImg.Image.ToDouble()); });
Assert.Equal("Kernel width is not odd!", ex2.Message);
}
public void TestMedianFilteringDefault()
{
var filter1 = new MedianFilter(); // 9-point median filter (faster implementation for sizes > 10)
var filter2 = new MedianFilter2(); // 9-point median filter
var input = new[] { 1, 6, 5, 2, 8, 1, 9, 5, 4, 2, 3, 4, 6, 7, 4f };
var expected = new[] { 1, 1, 2, 5, 5, 5, 4, 4, 4, 4, 4, 4, 4, 3, 3f };
var filtered1 = filter1.ApplyTo(new DiscreteSignal(1, input));
var filtered2 = filter2.ApplyTo(new DiscreteSignal(1, input));
Assert.Multiple(() =>
{
Assert.That(filtered1.Samples, Is.EqualTo(expected).Within(1e-10));
Assert.That(filtered2.Samples, Is.EqualTo(expected).Within(1e-10));
});
}
static private int[] PPGremoveOutofRange(float[] signalData, List <int> Idx)
{
List <int> inlier = new List <int>();
NWaves.Filters.MedianFilter mFilter = new MedianFilter();
DiscreteSignal medianSig = mFilter.ApplyTo(new DiscreteSignal(1, signalData));
int i = 0;
for (i = 0; i < Idx.Count(); i++)
{
if (signalData[Idx[i]] < (medianSig[Idx[i]] + SampleStandardDeviation(signalData, signalData[Idx[i]])))
{
inlier.Add(Idx[i]);
}
}
return(inlier.ToArray());
}
static void Main(string[] args)
{
try
{
if (args.Length < 2) throw new Exception("Недостаточно аргументов!");
MedianFilter M = new MedianFilter(windowSize);
M.Load(args[0]);
List<Point> intervals = Helper.getIntervals(ThreadCount, byteOnPixel, M.length, MedianFilter.bmp_info);
M.PFilter(intervals);
M.Save(args[1]);
}
catch (Exception ex)
{
Console.WriteLine("************APP EXCEPTION**********");
Console.WriteLine(ex.Message);
Console.WriteLine(ex.Source);
Console.WriteLine(ex.StackTrace);
}
}
public FilterGenerator(int quadrantSize, LocalTerrain localTerrain)
{
globalFilterMountainC = new GlobalCoordinates(100);
globalFilterAverageC = new GlobalCoordinates(100);
globalFilterMedianC = new GlobalCoordinates(100);
globalFilterSpikeC = new GlobalCoordinates(100);
globalFilterGaussianC = new GlobalCoordinates(100);
globalFilterMinThresholdC = new GlobalCoordinates(100);
globalFilterMaxThresholdC = new GlobalCoordinates(100);
lt = localTerrain;
localCoordinates = lt.localTerrainC;
mf = new MountainFilter(this);
af = new AverageFilter(this);
mdf = new MedianFilter(this);
sf = new SpikeFilter(this);
gf = new GaussianFilter(this);
tf = new ThresholdFilter(this);
}
public void MedianFilter_SmallQuarter_EqualsPythonArray()
{ /// Test whether Medianfilter class equals to scipy.signal.medfilt (default)
testImg.New("Quarters", new int[] { 6, 6 });
// Filter
MedianFilter mc = new MedianFilter(3);
double[,] imageFiltered = mc.Filtering(testImg.Image.ToDouble());
//Console.WriteLine("Median filtered:"); Functions.DisplayArray(imageFiltered);
double[,] refArray = new double[6, 6] // Here, actually columns are written out
{
{ 0, 1, 1, 1, 3, 0 },
{ 1, 1, 1, 3, 3, 3 },
{ 1, 1, 2, 3, 3, 3 },
{ 1, 2, 2, 3, 4, 3 },
{ 2, 2, 2, 4, 4, 4 },
{ 0, 2, 2, 2, 4, 0 }
};
//Console.WriteLine("Reference:"); Functions.DisplayArray(refArray);
Assert.Equal(refArray, imageFiltered);
}
public static void Run()
{
// ExStart:ApplyingCorrectionFilters
// The path to the documents directory.
string dataDir = RunExamples.GetDataDir_OMR();
// Initialize an instance of OcrEngine
OcrEngine ocrEngine = new OcrEngine();
// Set Image property by loading an image from file path
ocrEngine.Image = ImageStream.FromFile(dataDir+ "Sampleocr.bmp");
// Create CorrectionFilters collection
CorrectionFilters filters = new CorrectionFilters();
Filter filter = null;
// Initialize Median filter
filter = new MedianFilter(5);
filters.Add(filter);
// Create Gaussian Blur filter
filter = new GaussBlurFilter();
filters.Add(filter);
// Create Noise Removal filter
filter = new RemoveNoiseFilter();
filters.Add(filter);
// Assign collection to OcrEngine
ocrEngine.Config.CorrectionFilters = filters;
// Run recognition process
if (ocrEngine.Process())
{
// Display results
Console.WriteLine(ocrEngine.Text);
}
// ExEnd:ApplyingCorrectionFilters
}
public static void Main()
{
// The path to the documents directory.
string dataDir = Aspose.OCR.Examples.Utils.GetDataDir(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType);
//Initialize an instance of OcrEngine
OcrEngine ocrEngine = new OcrEngine();
//Set Image property by loading an image from file path
ocrEngine.Image = ImageStream.FromFile(dataDir + "Sampleocr.bmp");
//Create CorrectionFilters collection
CorrectionFilters filters = new CorrectionFilters();
Filter filter = null;
//Initialize Median filter
filter = new MedianFilter(5);
filters.Add(filter);
//Create Gaussian Blur filter
filter = new GaussBlurFilter();
filters.Add(filter);
//Create Noise Removal filter
filter = new RemoveNoiseFilter();
filters.Add(filter);
//Assign collection to OcrEngine
ocrEngine.Config.CorrectionFilters = filters;
//Run recognition process
if (ocrEngine.Process())
{
//Display results
Console.WriteLine(ocrEngine.Text);
}
}
public static void Main()
{
// The path to the documents directory.
string dataDir = Aspose.OCR.Examples.Utils.GetDataDir(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType);
//Initialize an instance of OcrEngine
OcrEngine ocrEngine = new OcrEngine();
//Set Image property by loading an image from file path
ocrEngine.Image = ImageStream.FromFile(dataDir+ "Sampleocr.bmp");
//Create CorrectionFilters collection
CorrectionFilters filters = new CorrectionFilters();
Filter filter = null;
//Initialize Median filter
filter = new MedianFilter(5);
filters.Add(filter);
//Create Gaussian Blur filter
filter = new GaussBlurFilter();
filters.Add(filter);
//Create Noise Removal filter
filter = new RemoveNoiseFilter();
filters.Add(filter);
//Assign collection to OcrEngine
ocrEngine.Config.CorrectionFilters = filters;
//Run recognition process
if (ocrEngine.Process())
{
//Display results
Console.WriteLine(ocrEngine.Text);
}
}
public async Task InitAsync()
{
var i2cDeviceSelector = I2cDevice.GetDeviceSelector();
var devices = await DeviceInformation.FindAllAsync(i2cDeviceSelector);
var hmc5983ConnectionSettings = new I2cConnectionSettings(HMC5983_ADDRESS);
_compassSensor = await I2cDevice.FromIdAsync(devices[0].Id, hmc5983ConnectionSettings);
//Config Register A
// 7 - 7 = 0 Temperature Off
// 6 - 5 = 11 => 8 Samples per reading
// 4 - 2 = 100 => Data Rate 15 Hz
// 1 - 0 = 00 Measurement Config Bits (default)
//Config Register B
//Gain - Use Default
/*
* var setupBuffer = new byte[2];
* setupBuffer[0] = HMC5983_CONF_A;
* setupBuffer[1] = 0b01110000;
* _compassSensor.Write(setupBuffer);*/
_medianFilter = new MedianFilter();
RawX = new Sensor()
{
IsOnline = false
};
RawY = new Sensor()
{
IsOnline = false
};
IsOnline = false;
}
private static async Task TestBrainDeviceManager()
{
var cfg = ClientConfig.GetConfig();
var lowFilter = new LowPassFilter()
{
LowPassRate = 10
};
var highFilter = new HighPassFilter()
{
HighPassRate = 10000
};
var bPassFilter = new BandPassFilter()
{
LowCutoffRate = 20, HighCutoffRate = 30
};
var bStopFilter = new BandStopFilter()
{
LowPassRate = 35, HighPassRate = 38
};
var mFilter = new MedianFilter()
{
HalfMedianWindowSize = 7
};
var bandFilter = new BandPassStopFilter
{
BandFilterList = new List <BandFilter> {
lowFilter, highFilter, bPassFilter, bStopFilter
}
};
bandFilter.Disable = true;
var allFilter = new FilterTypeList()
{
Filters = new List <FilterType> {
bandFilter, mFilter
}
};
var filterParameters = new Dictionary <string, string>
{
{ FilterTypeList.FIRhalfOrderOptionName, 10.ToString() }
};
cfg.FilterLst = allFilter;
IOnlineFilter filter = null;
WaveletReconstruction waveletRec = null;
cfg.WaveletRecCfg = new WaveletReconstructionConfig
{
AvgLevel = 8,
ConvolutionMode = ConvolutionModeEnum.Normal,
ExtensionMode = SignalExtension.ExtensionMode.SymmetricHalfPoint,
Level = 8,
MotherWaveletName = "db5",
WindowSize = 15
};
cfg.WriteToFile(ClientConfig.DefaultConfigFileName);
BrainDeviceManager.Init();
var sender = await BrainDeviceManager.Connnect("127.0.0.1", 9211);
BrainDevState currentState = default(BrainDevState);
//保证设备参数正常才继续跑逻辑
BrainDeviceManager.BrainDeviceState.Subscribe(ss =>
{
currentState = ss;
filterParameters.Update(
FilterTypeList.SampleRateOptionName,
BrainDevState.SampleCountPer1Sec(ss.SampleRate).ToString()
);
//AppLogger.Debug($"Brain Device State Changed Detected: {ss}");
}, () =>
{
AppLogger.Debug("device stop detected");
});
int totalReceived = 0;
var medianFilter = OnlineFirFilter.CreateDenoise(7);
var fastMedianFilter = new OnlineFastMedianFilter(3);
BrainDeviceManager.SampleDataStream.Subscribe(tuple =>
{
var(order, datas, arr) = tuple;
//Console.Write($" {order} ");
var passTimes = BrainDevState.PassTimeMs(currentState.SampleRate, totalReceived) / 1000;
var intArr = datas.CopyToArray();
var val = intArr[0];
var voltage = BitDataConverter.Calculatevoltage(val, 4.5f, currentState.Gain);
totalReceived++;
var m1 = medianFilter.ProcessSample(voltage);
var m2 = fastMedianFilter.ProcessSample(voltage);
AppLogger.Debug($"passTimes:{passTimes},val:{val},voltage:{voltage},median filter:{m1},fast:{m2},{m1==m2}");
if (filter == null)
{
filter = allFilter.CreateFilter(filterParameters);
waveletRec = cfg.WaveletRecCfg.Create(
BrainDevState.SampleCountPer1Sec(currentState.SampleRate));
waveletRec.ReconstructionStream.Subscribe(reconstruct =>
{
var(vol, tim) = reconstruct;
AppLogger.Debug($"wavelet reconstruction:{vol} at {tim}");
});
}
waveletRec?.BufferData((voltage, passTimes));
AppLogger.Debug($"filter processed:{filter.ProcessSample(voltage)}");
//AppLogger.Debug($"order:{order}");
//AppLogger.Debug($"converted values:{datas.Show()}");
//AppLogger.Debug($"original datas:{arr.Show()}");
}, () =>
{
AppLogger.Debug("device sampling stream closed detected");
});
var cmdResult = await sender.QueryParam();
AppLogger.Debug("QueryParam result:" + cmdResult);
if (cmdResult != CommandError.Success)
{
AppLogger.Error("Failed to QueryParam, stop");
BrainDeviceManager.DisConnect();
return;
}
cmdResult = await sender.SetFilter(true);
AppLogger.Debug("SetFilter result:" + cmdResult);
cmdResult = await sender.SetTrap(TrapSettingEnum.Trap_50);
AppLogger.Debug("SetTrap result:" + cmdResult);
cmdResult = await sender.SetSampleRate(SampleRateEnum.SPS_2k);
AppLogger.Debug("SetSampleRate result:" + cmdResult);
cmdResult = await sender.QueryParam();
AppLogger.Debug("QueryParam result:" + cmdResult);
cmdResult = await sender.QueryFaultState();
AppLogger.Debug("QueryFaultState result:" + cmdResult);
cmdResult = await sender.TestSingleImpedance(1);
AppLogger.Debug("TestSingleImpedance result:" + cmdResult);
cmdResult = await sender.TestMultiImpedance(30);
AppLogger.Debug("TestMultiImpedance result:" + cmdResult);
Console.ReadLine();
var fs = new FileResource(currentState, 19801983, 1, BrainDeviceManager.BufMgr);
fs.StartRecord(BrainDeviceManager.SampleDataStream);
cmdResult = await sender.Start();
if (cmdResult != CommandError.Success)
{
AppLogger.Error("Failed to start sampler");
}
else
{
AppLogger.Debug($"start receive sample data");
await Task.Delay(1000 *10);
AppLogger.Debug($"stoping");
await sender.Stop();
AppLogger.Debug($"stop receive sample data");
await Task.Delay(1000);
}
BrainDeviceManager.DisConnect();
fs.Dispose();
var readf = new FileSampleData(fs.ResourceId, BrainDeviceManager.BufMgr);
Console.WriteLine($"expecte to read {totalReceived} blocks");
Console.WriteLine($"start reading saved sampling data");
int readCount = 0;
readf.DataStream.Subscribe(tuple =>
{
var(order, datas, arr) = tuple;
Console.Write($" {order} ");
readCount++;
//AppLogger.Debug($"order:{order}");
//AppLogger.Debug($"converted values:{datas.Show()}");
//AppLogger.Debug($"original datas:{arr.Show()}");
}, () =>
{
AppLogger.Debug($"read sampling data file end,count :{readCount},expected count:{totalReceived}");
});
readf.Start();
await Task.Delay(1000 *10);
Console.Write($"wait complete");
}
static private List <int> PPGfiltering(int[] ppgData)
{
float lowcut = (float)ppg_min_bpm / 60.0f / ppg_frame_rate / 2.0f;
float highcut = (float)ppg_max_bpm / 60.0f / ppg_frame_rate / 2.0f;
var LPfilter = new NWaves.Filters.OnePole.LowPassFilter(highcut);
var HPfilter = new NWaves.Filters.OnePole.HighPassFilter(lowcut);
var filteredPPG = LPfilter.ApplyTo(new DiscreteSignal(1, ppgData));
filteredPPG = HPfilter.ApplyTo(filteredPPG);
/******************** Median Filtering ********************/
NWaves.Filters.MedianFilter mFilter = new MedianFilter(167);
DiscreteSignal mfilteredPPG = mFilter.ApplyTo(filteredPPG);
float[] arrayPPG = SigToArr(mfilteredPPG);
var peakIdx = PPGfindPeaks(arrayPPG);
var inlier = PPGremoveOutofRange(arrayPPG, peakIdx);
List <float> bpm = new List <float>();
for (int i = 0; i < inlier.Count() - 1; i++)
{
float curBPM = ((float)ppg_frame_rate / ((float)inlier[i + 1] - (float)inlier[i])) * 60.0f;
if (curBPM > ppg_max_bpm)
{
bpm.Add(0);
}
else if (curBPM < ppg_min_bpm)
{
bpm.Add(0);
}
else
{
bpm.Add(curBPM);
}
}
List <float> output = new List <float>();
/*output.Add(90);
* for (int i = 1; i < bpm.Count() - 1; i++)
* {
* if (bpm[i] == 0)
* output.Add(output[output.Count() - 1]);
* else if (30 < (bpm[i] - bpm[i - 1]))
* output.Add(output[output.Count() - 1]);
* else
* output.Add(bpm[i]);
* }*/
for (int i = 0; i < bpm.Count() - 1; i++)
{
if (bpm[i] != 0)
{
output.Add(bpm[i]);
}
}
if (output.Count() == 0)
{
output.Add(90);
}
//var outputG = GaussianFiltering(7, output.ToArray());
List <int> toList = new List <int>();
for (int i = 0; i < output.Count(); i++)
{
toList.Add((int)output[i]);
}
return(toList);
}
static public List <GsrPpgPacket> GSRfiltering(List <GsrPpgPacket> GSRdata)
{
var gsrData_int = GSRdata.Select(e => gsr_max - e.Value).ToArray();
var gsrData = Array.ConvertAll(gsrData_int, item => (float)item);
/******************** Gaussian Filtering ********************/
var filtered = GaussianFiltering(gsr_gaussian_kernel, gsrData);
/******************** Median Filtering ********************/
MedianFilter mFilter = new MedianFilter(gsr_subtract_sample);
DiscreteSignal tonic_GSR = mFilter.ApplyTo(filtered);
var phasic_GSR = filtered.Subtract(tonic_GSR);
/******************* 앞/뒤 데이터 자르는 과정인듯 ********************/
if (phasic_GSR.Length > gsr_subtract_sample * 2)
{
for (int i = 0; i < gsr_subtract_sample; i++)
{
phasic_GSR[i] = 0;
}
for (int i = phasic_GSR.Length - 1; i > phasic_GSR.Length - gsr_subtract_sample; i--)
{
phasic_GSR[i] = 0;
}
}
else
{
for (int i = 0; i < phasic_GSR.Length; i++)
{
phasic_GSR[i] = 0;
}
}
/******************** Find peak ********************/
bool checkFlag = false;
float max = 0;
int idx1 = 0;
var findPeak = GSRdata.Select(e => new GsrPpgPacket(0, e.Timestamp)).ToList();
findPeak[0].Value = 0;
for (int i = 1; i < filtered.Length; i++)
{
if (checkFlag)
{
if (phasic_GSR[i] > 0 && phasic_GSR[i - 1] <= 0)
{
for (int j = idx1; j < i; j++)
{
findPeak[j].Value = (int)max;
}
checkFlag = false;
}
if (phasic_GSR[i] > max)
{
max = phasic_GSR[i];
}
}
else
{
if (phasic_GSR[i] > 0 && phasic_GSR[i - 1] > 0)
{
idx1 = i;
max = 0;
checkFlag = true;
}
}
}
/******************** Gaussian Filtering ********************/
//var filteredData = GaussianFiltering(gsr_gaussian_kernel * 10, findPeak.ToArray());
return(findPeak);
}
private void button1_Click(object sender, EventArgs e)
{
Bitmap img = new Bitmap(picBarcode.Image);
picBarcode.Image = MedianFilter.Filter(img, 3, 0, false);
}
static void Main(string[] args)
{
PrintDescription();
if (args.Length != 3)
{
Console.WriteLine(
"Неверное количество аргументов. Формат: <программа> <имя_входного_файла> <название_фильтра> <имя выходного файла>");
return;
}
string currentFilter = args[1];
if (!currentFilter.Equals("median") && !currentFilter.Equals("gauss") && !currentFilter.Equals("sobelx") &&
!currentFilter.Equals("sobely") && !currentFilter.Equals("gray"))
{
Console.WriteLine("Введённый фильтр не относится к списку доступных. Попробуйте ещё раз.");
return;
}
FileStream fileIn;
try
{
fileIn = new FileStream(args[0], FileMode.Open, FileAccess.ReadWrite);
}
catch (FileNotFoundException)
{
Console.WriteLine("Ошибка! Входной файл не был найден! Попробуйте ещё раз.");
return;
}
FileStream fileOut;
try
{
fileOut = new FileStream(args[2], FileMode.Create, FileAccess.ReadWrite);
}
catch (Exception)
{
fileIn.Close();
Console.WriteLine("Ошибка! Не удалось создать/открыть выходной файл. Попробуйте ещё раз.");
return;
}
BitMapFile file = new(fileIn);
fileIn.Close();
if (currentFilter.Equals("gray"))
{
Console.WriteLine("Выбран фильтр серого");
GrayFilter.ApplyFilter(file);
}
else if (currentFilter.Equals("median"))
{
Console.WriteLine("Выбран усредняющий фильтр");
MedianFilter.ApplyFilter(file);
}
else if (currentFilter.Equals("gauss"))
{
Console.WriteLine("Выбран фильтр Гаусса");
GaussFilter.ApplyFilter(file);
}
else if (currentFilter.Equals("sobelx"))
{
Console.WriteLine("Выбран фильтр Собеля по X");
SobelFilter.ApplyFilter(file, SobelFilter.Type.X);
}
else if (currentFilter.Equals("sobely"))
{
Console.WriteLine("Выбран фильтр Собеля по Y");
SobelFilter.ApplyFilter(file, SobelFilter.Type.Y);
}
Console.WriteLine("Фильтр был успешно применён");
file.WriteResult(fileOut);
fileOut.Close();
}
