public void PuzzelOne()
{
var data = Day8InputParser.ParseSegments("input_data/day8-1.txt");
var sut = new SignalProcessor(data);
Assert.Equal(470, sut.CountKnownSignalsInOutput());
}
public void PuzzelTwo()
{
var data = Day8InputParser.ParseSegments("input_data/day8-1.txt");
var sut = new SignalProcessor(data);
Assert.Equal(989396, sut.SumOfOutputValues());
}
public void TestInputTwo()
{
var data = Day8InputParser.ParseSegments("input_data/day8-test.txt");
var sut = new SignalProcessor(data);
Assert.Equal(61229, sut.SumOfOutputValues());
}
public void TestInput()
{
var data = Day8InputParser.ParseSegments("input_data/day8-test.txt");
var sut = new SignalProcessor(data);
Assert.Equal(26, sut.CountKnownSignalsInOutput());
}
internal void AddSignalProcessor()
{
var newProcessor = new SignalProcessor(DateTime.Now.Millisecond);
newProcessor.Configure(blackboard);
KnowledgeSources.Add(newProcessor);
OrderKnowledgeBases();
}
private void addNoiseButton_Click(object sender, EventArgs e)
{
noised = SignalProcessor.addNoiseToBipolarizedArray(probe);
visualizeBlackWhite(transformedBM, noised);
destinationPictureBox.Refresh();
}
private void loadImageButton_Click(object sender, EventArgs e)
{
try
{
openImageFileDialog.Title = "Open image...";
openImageFileDialog.CheckFileExists = true;
openImageFileDialog.CheckPathExists = true;
openImageFileDialog.DefaultExt = "jpeg";
openImageFileDialog.Filter = "Image Files(*.jpg; *.jpeg; *.gif; *.bmp)|*.jpg; *.jpeg; *.gif; *.bmp|All Files|*.*";
openImageFileDialog.FilterIndex = 1;
openImageFileDialog.RestoreDirectory = true;
if (openImageFileDialog.ShowDialog() == DialogResult.OK)
{
originalBM = new Bitmap(openImageFileDialog.FileName);
probe = SignalProcessor.bipolarize(originalBM, Color.FromArgb(0, 0, 0));
transformedBM = originalBM.Clone() as Bitmap;
visualizeBlackWhite(transformedBM, probe);
originalPictureBox.Image = originalBM;
destinationPictureBox.Image = transformedBM;
stateLabel.Text = "Image loaded.";
stateLabel.Refresh();
}
}
catch (Exception ex)
{
throw new ApplicationException(string.Format("Failed loading image: {0}", ex.Message));
}
}
// Start is called before the first frame update
void Start()
{
gameData = GameObject.Find("GameManager").GetComponent <GameManager>();
sp = GameObject.Find("GameManager").GetComponent <SignalProcessor>();
lm = GameObject.Find("LoggingManager").GetComponent <LoggingManager>();
dataArray = new List <float>();
sp.onSignalProcessedOnce.AddListener(this.LogTriggers);
}
// normally done in setHeaderAll if not backtesting
public void SetProcessingMarkers(CsvReader csv)
{
int bandPowerStart = csv.HeaderRecord.IndexOf("AF3/theta ");
int bandPowersLength = csv.HeaderRecord.Length - bandPowerStart;
SignalProcessor.CreateElectrodes();
// length of raw eeg section
SignalProcessor.BandPowerNullsOffset = bandPowerStart - 1;
SignalProcessor.EEGNullsOffset = bandPowersLength;
SignalProcessor.FreqBandNames = csv.HeaderRecord.ToList().GetRange(bandPowerStart, bandPowersLength);
SignalProcessor.SetClassificationIndices();
}
public int recallIndex(int sampleIndex)
{
var probe = xs[sampleIndex];
SignalProcessor.addNoiseToBipolarizedArray(probe);
var y = assotiatedMemory.recall(probe);
var ind = getSampleIndex(y);
return(ind);
}
private void InitHopfieldModel(string initDir)
{
var di = new DirectoryInfo(initDir);
var files = di.GetFiles("*.jpg");
size = files.Length;
xs = new List <int[]>(size);
classes = new List <string>(size);
for (var i = 0; i < size; ++i)
{
var b = new Bitmap(Image.FromFile(files[i].FullName));
var bipolarized = SignalProcessor.bipolarize(b, Color.FromArgb(0, 0, 0), 50);
xs.Add(bipolarized);
var className = Path.GetFileNameWithoutExtension(files[i].Name);
classes.Add(className);
}
assotiatedMemory = new HopfieldModel(xs);
}
public void Init(string trainingSetDirectory)
{
rand = new Random();
var di = new DirectoryInfo(trainingSetDirectory);
var files = di.GetFiles("*.jpg");
size = files.Length;
xs = new List <int[]>(size);
classes = new List <string>(size);
for (var i = 0; i < size; ++i)
{
var b = new Bitmap(Image.FromFile(files[i].FullName));
var bip_res = SignalProcessor.bipolarize(b, Color.FromArgb(0, 0, 0));
xs.Add(bip_res.Cast <int>().ToArray());
classes.Add(files[i].Name);
}
assotiatedMemory = new HopfieldModel(xs);
}
public SongMatcher(MainForm main, Database.DatabaseAdapter adapter)
{
InitializeComponent();
tracks = null;
lowGroup = medGroup = highGroup = null;
lowGroupIndices = medGroupIndices = highGroupIndices = null;
historyMap = null;
historyQueue = new Queue <int>();
Matching = false;
this.playerForm = main;
this.dbAdapter = adapter;
this.currTrackIndex = -1;
sp = new SignalProcessor();
kp = new KeyboardProcessor();
kp.onDataReady += onKeyboardDataReady;
mp = new MouseProcessor();
mp.onDataReady += onMouseDataReady;
//to get raw x/y points set mean values to 0
mp.MeanValueX = 0;
mp.MeanValueY = 0;
mouseXRecordings = new Queue <short[]>();
mouseYRecordings = new Queue <short[]>();
keyboardRecordings = new Queue <short[]>();
mkTrackBar.ValueChanged += trackBarValuesChanged;
this.hide();
MatcherVisible = false;
this.TopMost = true;
main.onSongComplete += onSongComplete;
prevAction = "";
rnd = new Random();
actionChangedStopWatch = new Stopwatch();
}
public Grapher(MainForm main)
{
this.mainForm = main;
InitializeComponent();
t = null;
chart1.Series.Add("wave");
chart1.Series["wave"].ChartType = System.Windows.Forms.DataVisualization.Charting.SeriesChartType.FastLine;
chart1.Series["wave"].ChartArea = "ChartArea1";
kp = new KeyboardProcessor();
kp.onDataReady += onKeyboardDataReady;
mp = new MouseProcessor();
mp.onDataReady += onMouseDataReady;
sp = new SignalProcessor();
sp.onBPMReady += onBPMReady;
mouseXYComboBox.Items.Add("X");
mouseXYComboBox.Items.Add("Y");
drawThread = null;
this.hide();
GrapherVisible = false;
}
private void InitializeSignalProcessor()
{
m_calibration = new SignalCalibration(this);
m_signalProcessor = new SignalProcessor(this);
}
public RealityCoprocessor(Nintendo64 nintendo64)
{
this.nintendo64 = nintendo64;
SP = new SignalProcessor(this);
DP = new DisplayProcessor(this);
PI = new ParallelInterface(this);
SI = new SerialInterface(this);
AI = new AudioInterface(this);
VI = new VideoInterface(this);
MI = new MIPSInterface(this);
RI = new RDRAMInterface(this);
MemoryMaps = new[]
{
new MappingEntry(0x00000000, 0x03FFFFFF, false)
{
Read = nintendo64.RAM.MemoryMaps.ReadWord,
Write = nintendo64.RAM.MemoryMaps.WriteWord
},
new MappingEntry(0x04000000, 0x040FFFFF, false)
{
Read = SP.MemoryMaps.ReadWord,
Write = SP.MemoryMaps.WriteWord
},
new MappingEntry(0x04100000, 0x041FFFFF, false)
{
Read = DP.MemoryMaps.ReadWord,
Write = DP.MemoryMaps.WriteWord
},
new MappingEntry(0x04300000, 0x043FFFFF, false)
{
Read = MI.MemoryMaps.ReadWord,
Write = MI.MemoryMaps.WriteWord
},
new MappingEntry(0x04400000, 0x044FFFFF, false)
{
Read = VI.MemoryMaps.ReadWord,
Write = VI.MemoryMaps.WriteWord
},
new MappingEntry(0x04500000, 0x045FFFFF, false)
{
Read = AI.MemoryMaps.ReadWord,
Write = AI.MemoryMaps.WriteWord
},
new MappingEntry(0x04600000, 0x046FFFFF, false)
{
Read = PI.MemoryMaps.ReadWord,
Write = PI.MemoryMaps.WriteWord
},
new MappingEntry(0x04700000, 0x047FFFFF, false)
{
Read = RI.MemoryMaps.ReadWord,
Write = RI.MemoryMaps.WriteWord
},
new MappingEntry(0x04800000, 0x048FFFFF, false)
{
Read = SI.MemoryMaps.ReadWord,
Write = SI.MemoryMaps.WriteWord
},
new MappingEntry(0x10000000, 0x1FBFFFFF, false)
{
Read = PI.MemoryMaps.ReadWord
},
new MappingEntry(0x1FC00000, 0x1FC007FF, false)
{
Read = SI.MemoryMaps.ReadWord,
Write = SI.MemoryMaps.WriteWord
}
};
}
private void MainWindow_Loaded(object sender, RoutedEventArgs e)
{
_reader = new DeviceReader();
_reader.Start("COM3", 9600, BatchSize);
_reader.OnLineRead += (r, ir, g, m, dt) =>
{
if (ChartValuesIR.Count > BatchSize)
{
ChartValuesIR.RemoveAt(0);
ChartValuesRed.RemoveAt(0);
ChartValuesHeart.RemoveAt(0);
}
ChartValuesRed.Add(new MeasureModel
{
Time = dt,
Value = r, //r.Next(-8, 10)
});
ChartValuesIR.Add(new MeasureModel
{
Time = dt,
Value = ir, //r.Next(-8, 10)
});
ChartValuesHeart.Add(new MeasureModel
{
Time = dt,
Value = g,
});
Bpm.Add(new MeasureModel
{
Value = m,
Time = dt,
});
if (Bpm.Count > 500)
{
Bpm.RemoveAt(0);
}
SetAxisLimits(dt);
};
_reader.OnEveryLine += (r, ir, g, m, t) =>
{
};
_reader.OnBatchCompleted += (r, ir, g, m) =>
{
//SignalProcessor.Mean(ref r, ref ir);
//SignalProcessor.LineLeveling(ref ir, ref r);
SignalProcessor.Mean(ref g);
SignalProcessor.LineLeveling(ref g);
List <MeasureModel> smoothed = null;
double myBpm = SignalProcessor.ComputeBpm(g, out smoothed);
double spo2 = 0, bpm = 0, xyRatio = 0;
if (Interop.Compute(ir.Select(n => n.Value).ToArray(), r.Select(n => n.Value).ToArray(), ref spo2, ref bpm, ref xyRatio) && myBpm > 0)
{
Dispatcher.Invoke(() =>
{
SpO2Label.Content = $"SPO2: {(int)Math.Round(spo2)}, BPM: {(int)Math.Round(myBpm)}, Ratio: {xyRatio}";
});
//Spo2.Add(new MeasureModel
//{
// Value = spo2,
// Time = m.Last().Time,
//});
//Bpm.Add(new MeasureModel
//{
// Value = myBpm,
// Time = r.Last().Time,
//});
if (Spo2.Count > 2000)
{
Spo2.RemoveAt(0);
Bpm.RemoveAt(0);
}
}
return;
};
}
public static Blueprint Generate(SpriteShifterConfiguration configuration)
{
var signalCount = configuration.SignalCount ?? ScreenUtil.PixelSignals.Count;
const int maxFilters = 20;
const int shifterCount = 32;
const int inputSignalCount = 32;
var inputSignals = ComputerSignals.OrderedSignals.Take(inputSignalCount).ToList();
var offsetSignal = VirtualSignalNames.Dot;
var entities = new List <Entity>();
var inputMaps = new Entity[inputSignalCount];
var shifters = new Shifter[shifterCount];
// Input maps
for (var processorIndex = 0; processorIndex < inputSignalCount; processorIndex++)
{
var inputSignal = inputSignals[processorIndex];
var y = processorIndex * 4 + 3;
if (y % 18 == 8)
{
y--;
}
else if (y % 18 == 9)
{
y++;
}
var inputMap = new Entity
{
Name = ItemNames.ConstantCombinator,
Position = new Position
{
X = 1,
Y = y
},
Direction = Direction.Right,
Control_behavior = new ControlBehavior
{
Filters = new List <Filter> {
Filter.Create(offsetSignal, processorIndex + 1)
}
}
};
inputMaps[processorIndex] = inputMap;
entities.Add(inputMap);
}
// Shifters
for (var shifterIndex = 0; shifterIndex < shifterCount; shifterIndex++)
{
var shifterX = shifterIndex * 2 + shifterIndex / 8 * 2 + 2;
var outputLink = new Entity
{
Name = ItemNames.BigElectricPole,
Position = new Position
{
X = 0.5 + shifterX,
Y = -1.5
}
};
entities.Add(outputLink);
var inputSquared = new Entity
{
Name = ItemNames.ArithmeticCombinator,
Position = new Position
{
X = shifterX,
Y = 0.5
},
Direction = Direction.Down,
Control_behavior = new ControlBehavior
{
Arithmetic_conditions = new ArithmeticConditions
{
First_signal = SignalID.Create(VirtualSignalNames.Each),
Second_constant = 2,
Operation = ArithmeticOperations.Exponentiation,
Output_signal = SignalID.Create(VirtualSignalNames.Each)
}
}
};
entities.Add(inputSquared);
var bufferedInput = new Entity
{
Name = ItemNames.ArithmeticCombinator,
Position = new Position
{
X = 0.5 + shifterX,
Y = 2
},
Direction = Direction.Right,
Control_behavior = new ControlBehavior
{
Arithmetic_conditions = new ArithmeticConditions
{
First_signal = SignalID.Create(VirtualSignalNames.Each),
Second_constant = 1,
Operation = ArithmeticOperations.Multiplication,
Output_signal = SignalID.Create(VirtualSignalNames.Each)
}
}
};
entities.Add(bufferedInput);
var negativeInputSquared = new Entity
{
Name = ItemNames.ArithmeticCombinator,
Position = new Position
{
X = 1 + shifterX,
Y = 0.5
},
Direction = Direction.Up,
Control_behavior = new ControlBehavior
{
Arithmetic_conditions = new ArithmeticConditions
{
First_signal = SignalID.Create(VirtualSignalNames.Each),
Second_constant = -1,
Operation = ArithmeticOperations.Multiplication,
Output_signal = SignalID.Create(VirtualSignalNames.Each)
}
}
};
entities.Add(negativeInputSquared);
// Input signal processors
var signalProcessors = new SignalProcessor[inputSignalCount];
for (var processorIndex = 0; processorIndex < inputSignalCount; processorIndex++)
{
var inputSignal = inputSignals[processorIndex];
var y = processorIndex * 4 + 3;
var inputChecker = new Entity
{
Name = ItemNames.DeciderCombinator,
Position = new Position
{
X = 0.5 + shifterX,
Y = y
},
Direction = Direction.Right,
Control_behavior = new ControlBehavior
{
Decider_conditions = new DeciderConditions
{
First_signal = SignalID.Create(VirtualSignalNames.Each),
Second_signal = SignalID.Create(offsetSignal),
Comparator = Comparators.IsEqual,
Output_signal = SignalID.Create(VirtualSignalNames.Each),
Copy_count_from_input = false
}
}
};
entities.Add(inputChecker);
var inputBuffer = new Entity
{
Name = ItemNames.ArithmeticCombinator,
Position = new Position
{
X = 0.5 + shifterX,
Y = 1 + y
},
Direction = Direction.Right,
Control_behavior = new ControlBehavior
{
Arithmetic_conditions = new ArithmeticConditions
{
First_signal = SignalID.Create(inputSignal),
Second_constant = 1,
Operation = ArithmeticOperations.Multiplication,
Output_signal = SignalID.Create(inputSignal)
}
}
};
entities.Add(inputBuffer);
var outputGenerator = new Entity
{
Name = ItemNames.ArithmeticCombinator,
Position = new Position
{
X = 0.5 + shifterX,
Y = 2 + y
},
Direction = Direction.Right,
Control_behavior = new ControlBehavior
{
Arithmetic_conditions = new ArithmeticConditions
{
First_signal = SignalID.Create(VirtualSignalNames.Each),
Second_signal = SignalID.Create(inputSignal),
Operation = ArithmeticOperations.Multiplication,
Output_signal = SignalID.Create(VirtualSignalNames.Each)
}
}
};
entities.Add(outputGenerator);
var outputCleaner = new Entity
{
Name = ItemNames.ArithmeticCombinator,
Position = new Position
{
X = 0.5 + shifterX,
Y = 3 + y
},
Direction = Direction.Right,
Control_behavior = new ControlBehavior
{
Arithmetic_conditions = new ArithmeticConditions
{
First_signal = SignalID.Create(inputSignal),
Second_constant = -1,
Operation = ArithmeticOperations.Multiplication,
Output_signal = SignalID.Create(offsetSignal)
}
}
};
entities.Add(outputCleaner);
signalProcessors[processorIndex] = new SignalProcessor
{
InputChecker = inputChecker,
InputBuffer = inputBuffer,
OutputGenerator = outputGenerator,
OutputCleaner = outputCleaner
};
}
// Output signal maps
var outputMaps = new Entity[(signalCount + maxFilters - 1) / maxFilters];
for (var index = 0; index < outputMaps.Length; index++)
{
var outputSignalMap = new Entity
{
Name = ItemNames.ConstantCombinator,
Position = new Position
{
X = index % 2 + shifterX,
Y = index / 2 + inputSignalCount * 4 + 3
},
Direction = Direction.Right,
Control_behavior = new ControlBehavior
{
Filters = ScreenUtil.PixelSignals.Skip(index * maxFilters).Take(Math.Min(maxFilters, signalCount - index * maxFilters)).Select((signal, signalIndex) => new Filter
{
Signal = SignalID.Create(signal),
Count = index * maxFilters + signalIndex + 1
}).ToList()
}
};
outputMaps[index] = outputSignalMap;
entities.Add(outputSignalMap);
}
var offsetBuffer = new Entity
{
Name = ItemNames.ArithmeticCombinator,
Position = new Position
{
X = 0.5 + shifterX,
Y = outputMaps[^ 1].Position.Y + 1
static void Main(string[] args)
{
if (args.Length == 0)
{
string path = "data_" + DateTime.Now.ToString().Replace("/", "_").Replace(":", "_") + ".dat";
//using (StreamWriter sw = new StreamWriter(path))
using (FileStream fs = File.Create(path))
{
using (BinaryWriter bw = new BinaryWriter(fs))
{
Reader.DeviceReader dr = new Reader.DeviceReader();
dr.Start("COM3", 9600, 100);
dr.OnEveryLine += (r, ir, g, m, time) =>
{
//Console.Write(".");
bw.Write(time.ToFileTime());
bw.Write(r.Value);
bw.Write(ir.Value);
bw.Write(g.Value);
bw.Write(m.Value);
bw.Write((byte)0x69);
};
dr.OnBatchCompleted += (r, ir, g, m) =>
{
SignalProcessor.Mean(ref g);
SignalProcessor.LineLeveling(ref g);
List <MeasureModel> smoothed = null;
double myBpm = SignalProcessor.ComputeBpm(g, out smoothed);
double spo2 = 0, bpm = 0, xyRatio = 0;
if (Interop.Compute(ir.Select(n => n.Value).ToArray(), r.Select(n => n.Value).ToArray(), ref spo2, ref bpm, ref xyRatio) && myBpm > 0)
{
Console.Clear();
Console.WriteLine($"SPO2: {spo2}, BPM: {myBpm}, Acc: {m.Max(n=>n.Value)}");
}
//Console.Write("+");
bw.Flush();
};
Console.WriteLine("Press ENTER to quit.");
Console.ReadLine();
}
}
}
else
{
bool record = false;
string inputFile = args[0];
using (FileStream fin = File.OpenRead(inputFile))
{
using (BinaryReader br = new BinaryReader(fin))
{
List <MeasureModel> irs = new List <MeasureModel>();
List <MeasureModel> rs = new List <MeasureModel>();
List <MeasureModel> gs = new List <MeasureModel>();
List <MeasureModel> ms = new List <MeasureModel>();
DateTime start = new DateTime(1, 1, 1);
double lastSpo2 = -1;
while (br.BaseStream.Position < br.BaseStream.Length)
{
long fileTime = br.ReadInt64();
double r = br.ReadDouble();
double ir = br.ReadDouble();
double g = br.ReadDouble();
double m = br.ReadDouble();
byte marker = br.ReadByte();
if (marker == 0x69)
{
DateTime dt = DateTime.FromFileTime(fileTime);
if (start.Year == 1)
{
start = dt;
}
irs.Add(new MeasureModel
{
Time = (dt - start).TotalSeconds,
Value = ir,
});
rs.Add(new MeasureModel
{
Time = (dt - start).TotalSeconds,
Value = r,
});
gs.Add(new MeasureModel
{
Time = (dt - start).TotalSeconds,
Value = g,
});
ms.Add(new MeasureModel
{
Time = (dt - start).TotalSeconds,
Value = m,
});
if (rs.Count == 100)
{
bool doIt = false;
double spo2 = 0, bpm = 0, xyRatio = 0;
if (Robert.Interop.Compute(irs.Select(n => n.Value).ToArray(), rs.Select(n => n.Value).ToArray(), ref spo2, ref bpm, ref xyRatio))
{
SignalProcessor.Mean(ref gs);
SignalProcessor.LineLeveling(ref gs);
List <MeasureModel> smoothed = null;
bpm = SignalProcessor.ComputeBpm(gs, out smoothed);
if (spo2 > 94 && spo2 < 100)// && bpm > 0)
{
// sw.WriteLine($"{dt.ToString("MM/dd/yyyy hh:mm:ss.fff tt")},{spo2}, {bpm}, {ms.Max(n => n.Value)}");
// sw.Flush();
}
}
//accelSw.WriteLine($"{dt.ToString("MM/dd/yyyy hh:mm:ss.fff tt")}, {ms.Max(n => n.Value)}");
rs.Clear();
irs.Clear();
gs.Clear();
ms.Clear();
}
}
else
{
Console.WriteLine("Corrupted file! Ending");
return;
}
}
}
}
Console.WriteLine("Done. Press ENTER to quit.");
Console.ReadLine();
}
}
