public void AddHistoryItem(FixedSizeQueue<DiskStatQueue> from, int count, FixedSizeQueue<DiskStatQueue> to, long index)
{
if (from.Count() < count)
return;
double used = 0;
double free = 0;
double size = 0;
for (int i = 1; i <= count; i++)
{
DiskStatQueue sample = from.ElementAt(history.Count() - i);
used += sample.used;
free += sample.free;
size += sample.size;
}
used /= count;
free /= count;
size /= count;
var hourSample = new DiskStatQueue
{
SampleID = index,
used = used,
free = free,
size = size
};
to.Enqueue(hourSample);
}
public StatDiskItem(string n)
{
history = new FixedSizeQueue<DiskStatQueue>{ MaxSize = 602 };
historyDay = new FixedSizeQueue<DiskStatQueue>{ MaxSize = 602 };
name = n;
uuid = n.GetHashCode().ToString();
}
public StatSensorItem(string n, int t)
{
name = n;
type = t;
history = new FixedSizeQueue<SensorStatQueue>{ MaxSize = 602 };
historyHour = new FixedSizeQueue<SensorStatQueue> { MaxSize = 602 };
historyDay = new FixedSizeQueue<SensorStatQueue> { MaxSize = 602 };
}
public void Works()
{
var q = new FixedSizeQueue<int>(2);
q.Enqueue(1);
Assert.AreEqual("(1)", q.Print());
q.Enqueue(2);
Assert.AreEqual("(1,2)", q.Print());
q.Enqueue(3);
Assert.AreEqual("(2,3)", q.Print());
}
public void FixedSizeQueue_CanPeek()
{
FixedSizeQueue<int> queue = new FixedSizeQueue<int>(1);
queue.Enqueue(1);
Assert.AreEqual(1, queue.Count);
int peeked = queue.Peek();
Assert.AreEqual(1, peeked);
Assert.AreEqual(1, queue.Count);
}
public void FixedSizeQueue_CanDequeue()
{
FixedSizeQueue<int> queue = new FixedSizeQueue<int>(1);
queue.Enqueue(1);
Assert.AreEqual(1, queue.Count);
int dequeued = queue.Dequeue();
Assert.AreEqual(1, dequeued);
Assert.AreEqual(0, queue.Count);
}
static GameConsole()
{
_commands = new Dictionary<string, ConsoleCommand>();
_history = new FixedSizeQueue<string>(100);
// Divert Debug Log messages to the GameConsole as well.
Application.logMessageReceived += (log, stackTrace, type) => Log(log);
RegisterCommand("echo", Commands.Echo);
RegisterCommand("clear", Commands.Clear);
}
public void FillEnumerable()
{
var queue = new FixedSizeQueue<int>(Enumerable.Range(0, 64));
Assert.IsFalse(queue.Add(999));
foreach (var item in Enumerable.Range(0, queue.Capacity))
{
int found;
queue.TryTake(out found);
Assert.AreEqual(found, item);
}
}
public Scene(double g, double ballSize, Point ballIinitialLocation, Vector ballIinitialVelocity, int maxAfterimageCount, TimeSpan afterimageInterval)
{
this.g = g;
BallSize = ballSize;
this.ballIinitialLocation = ballIinitialLocation;
this.ballIinitialVelocity = ballIinitialVelocity;
MaxAfterimageCount = maxAfterimageCount;
this.AfterimageInterval = afterimageInterval;
xPositions = new FixedSizeQueue<double>(maxAfterimageCount);
yPositions = new FixedSizeQueue<double>(maxAfterimageCount);
}
public void FixedSizeQueue_CanClear()
{
FixedSizeQueue<int> queue = new FixedSizeQueue<int>(10);
for (int i = 0; i < 10; i++)
{
queue.Enqueue(i);
}
Assert.AreEqual(10, queue.Count);
queue.Clear();
Assert.AreEqual(0, queue.Count);
}
public void FixedSizeQueue_DequeueThrowsWhenEmpty()
{
FixedSizeQueue<int> queue = new FixedSizeQueue<int>(1);
try
{
queue.Dequeue();
Assert.Fail("Dequeueing did not throw an exception when the queue was empty.");
}
catch (InvalidOperationException)
{
// expected
}
}
public void FixedSizeQueue_EnforcesSizeLimit()
{
FixedSizeQueue<int> queue = new FixedSizeQueue<int>(1);
queue.Enqueue(1);
try
{
queue.Enqueue(2);
Assert.Fail("We were able to insert two items into a queue that is of fixed size 1.");
}
catch (InvalidOperationException)
{
// expected
}
}
public StatMemory()
{
history = new FixedSizeQueue<MemStat>{ MaxSize = 602 };
historyHour = new FixedSizeQueue<MemStat>{ MaxSize = 602 };
historyDay = new FixedSizeQueue<MemStat>{ MaxSize = 602 };
sessionID = DateTime.Now.Ticks;
historyIndex = -1;
historyIndexHour = -1;
historyIndexDay = -1;
_pageInSec.NextValue();
_pageOutSec.NextValue();
_timer = new Timer(Update, null, 0, 1000);
Update(null);
}
public StatCPU()
{
history = new FixedSizeQueue<CpuStat>{ MaxSize = 602 };
historyHour = new FixedSizeQueue<CpuStat>{ MaxSize = 602 };
historyDay = new FixedSizeQueue<CpuStat>{ MaxSize = 602 };
sessionID = DateTime.Now.Ticks;
historyIndex = -1;
historyIndexHour = -1;
historyIndexDay = -1;
_cpuPrivCounter.NextValue();
_cpuUserCounter.NextValue();
_timer = new Timer(Update, null, 0, 1000);
Update(null);
}
public void FixedSizeQueueWillDequeuesOldValuesWhenFull()
{
int queueSize = 5;
List<int> dataSet = new List<int> { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
List<int> expected = new List<int> { 5, 6, 7, 8, 9 };
FixedSizeQueue<int> queue = new FixedSizeQueue<int>(queueSize);
foreach (int data in dataSet)
{
queue.Enqueue(data);
}
List<int> actual = queue.ToList<int>();
Assert.Equal(queueSize, queue.Size);
Assert.Equal<int>(expected, actual);
}
public YAMDDetector(IVideoSource source, Magnitude low, Magnitude medium, Magnitude high)
{
detector = new MotionDetector(
new SimpleBackgroundModelingDetector(),
new BlobCountingObjectsProcessing(true));
//async video source processes images in a separate thread and uses the NewFrame event
inputStream = new AsyncVideoSource(source);
inputStream.NewFrame += inputStream_NewFrame;
this.low = low;
this.medium = medium;
this.high = high;
timer = new Stopwatch();
stoptimer = new Stopwatch();
videoRecorder = new VideoFileWriter();
Running = false;
buffer = new FixedSizeQueue<Bitmap>();
buffer.Limit = 50;
magnitudes = new Queue<int>();
}
public void AddHistoryItem(FixedSizeQueue<SensorStatQueue> from, int count, FixedSizeQueue<SensorStatQueue> to, long index)
{
if (from.Count() < count)
return;
float value = 0;
for (int i = 1; i <= count; i++)
{
SensorStatQueue sample = from.ElementAt(history.Count() - i);
value += sample.Value;
}
value /= count;
var hourSample = new SensorStatQueue
{
SampleID = index,
Value = value
};
to.Enqueue(hourSample);
}
/// <summary>
/// Initializes a new instance of the <see cref="Storage"/> class.
/// </summary>
/// <param name="uniqueFolderName">A folder name. Under this folder all the transmissions will be saved.</param>
internal Storage(string uniqueFolderName)
{
this.peekedTransmissions = new SnapshottingDictionary<string, string>();
this.storageFolderName = uniqueFolderName;
this.deletedFilesQueue = new FixedSizeQueue<string>(10);
if (string.IsNullOrEmpty(uniqueFolderName))
{
this.storageFolderName = "ApplicationInsights";
}
this.CapacityInBytes = 10 * 1024 * 1024; // 10 MB
this.MaxFiles = 5000;
Task.Factory.StartNew(this.DeleteObsoleteFiles)
.ContinueWith(
task =>
{
string msg = string.Format(CultureInfo.InvariantCulture, "Storage: Unhandled exception in DeleteObsoleteFiles: {0}", task.Exception);
CoreEventSource.Log.LogVerbose(msg);
},
TaskContinuationOptions.OnlyOnFaulted);
}
public void FixedSizeQueueCorrectlyDequeues()
{
int expected = 3;
FixedSizeQueue<int> queue = new FixedSizeQueue<int>(10);
queue.Enqueue(1);
queue.Enqueue(2);
queue.Enqueue(3);
queue.Enqueue(4);
queue.Enqueue(5);
queue.Enqueue(6);
int overflow;
queue.TryDequeue(out overflow);
queue.TryDequeue(out overflow);
int actual;
queue.TryDequeue(out actual);
Assert.Equal(expected, actual);
}
public static void OpenLog(string id, string filePath = null, bool splunkEnabled = true)
{
Logger.splunkEnabled = splunkEnabled;
lock (Locker)
{
requestLog = new Dictionary <object, RequestLog>();
Queue = new FixedSizeQueue(300);
numBegunRequests = new Dictionary <object, int>();
threadsEnabled = new Dictionary <object, bool>();
restReq = new RestRequest();
// Create new Service object
if (splunkEnabled)
{
splunkClient = new SplunkClient();
splunkClient.SetSource(id);
}
if (filePath == null)
{
return;
}
Logger.filePath = filePath;
file = new System.IO.StreamWriter(filePath + "TripThru-" + id + ".log");
}
}
/// <summary>
/// The abstract method that realizes the logic for learning the parameters and the initial state object from data.
/// </summary>
/// <param name="data">A queue of data points used for training</param>
private protected virtual void LearnStateFromDataCore(FixedSizeQueue <TInput> data)
{
}
private protected override void LearnStateFromDataCore(FixedSizeQueue <Single> data)
{
// This method is empty because there is no need for parameter learning from the initial windowed buffer for this transform.
}
private protected override double ComputeRawAnomalyScore(ref Single input, FixedSizeQueue <Single> windowedBuffer, long iteration)
{
// Get the prediction for the next point opn the series
Single expectedValue = 0;
_model.PredictNext(ref expectedValue);
if (PreviousPosition == -1)
{
// Feed the current point to the model
_model.Consume(ref input, _parentAnomalyDetector.IsAdaptive);
}
// Return the error as the raw anomaly score
return(_parentAnomalyDetector.ErrorFunc(input, expectedValue));
}
private protected override void LearnStateFromDataCore(FixedSizeQueue <float> data)
{
}
public InputReader(string text)
{
Text = text;
CurrentPosition = 0;
LastNchars = new FixedSizeQueue <char>(3);
}
/// <summary> /// The abstract method that realizes the main logic for calculating the raw anomaly score bfor the current input given a windowed buffer /// </summary> /// <param name="input">A reference to the input object.</param> /// <param name="windowedBuffer">A reference to the windowed buffer.</param> /// <param name="iteration">A long number that indicates the number of times ComputeRawAnomalyScore has been called so far (starting value = 0).</param> /// <returns>The raw anomaly score for the input. The Assumption is the higher absolute value of the raw score, the more anomalous the input is. /// The sign of the score determines whether it's a positive anomaly or a negative one.</returns> private protected abstract Double ComputeRawAnomalyScore(ref TInput input, FixedSizeQueue <TInput> windowedBuffer, long iteration);
private void AddHistoryItem(FixedSizeQueue<DiskActivityStatQueue> from, int count, FixedSizeQueue<DiskActivityStatQueue> to, long index)
{
if (from.Count() < count)
return;
double read = 0;
double write = 0;
for (int i = 1; i <= count; i++)
{
DiskActivityStatQueue sample = from.ElementAt(history.Count() - i);
read += sample.read;
write += sample.write;
}
read /= count;
write /= count;
var hourSample = new DiskActivityStatQueue
{
SampleID = index,
read = read,
write = write,
readIOPS = 0,
writeIOPS = 0
};
to.Enqueue(hourSample);
}
protected override double ComputeRawAnomalyScore(ref Single input, FixedSizeQueue <Single> windowedBuffer, long iteration)
{
// This transform treats the input sequenence as the raw anomaly score.
return((double)input);
}
public LastFmScrobblingService(ITrackScrobblingClientFactory <LastfmClient> trackScrobblingClientFactory)
{
_trackScrobblingClientFactory = trackScrobblingClientFactory ?? throw new ArgumentNullException(nameof(trackScrobblingClientFactory));
_lastScrobbledTracks = new FixedSizeQueue <Track>(LastScrobbledTrackCapacity);
}
public void AddHistoryItem(FixedSizeQueue<NetworkStatQueue> from, int count, FixedSizeQueue<NetworkStatQueue> to, long index)
{
if (from.Count() < count)
return;
double down = 0;
double up = 0;
for (int i = 1; i <= count; i++)
{
NetworkStatQueue sample = from.ElementAt(history.Count() - i);
down += sample.Download;
up += sample.Upload;
}
down /= count;
up /= count;
var hourSample = new NetworkStatQueue
{
SampleID = index,
Download = down,
Upload = up
};
to.Enqueue(hourSample);
}
public MovemantCheatDetection(StatController statController)
{
this.statController = statController;
movemantLog = new FixedSizeQueue <MoveCheatDetectionLogItem>();
movemantLog.Limit = 20;
}
private protected virtual void SpectralResidual(TInput input, FixedSizeQueue <TInput> data, ref VBufferEditor <double> result)
{
}
protected SensorProcessorBase(SensorManager manager)
{
ValueHistory = new FixedSizeQueue <T>(10);
AcceptedSensorTypes = new List <SensorType>();
SensorManager = manager;
}
/// <summary> /// The abstract method that realizes the logic for learning the parameters and the initial state object from data. /// </summary> /// <param name="data">A queue of data points used for training</param> private protected abstract void LearnStateFromDataCore(FixedSizeQueue <TInput> data);
public StatDiskActivityItem(string n)
{
history = new FixedSizeQueue<DiskActivityStatQueue>{ MaxSize = 602 };
historyHour = new FixedSizeQueue<DiskActivityStatQueue> { MaxSize = 602 };
historyDay = new FixedSizeQueue<DiskActivityStatQueue> { MaxSize = 602 };
name = n;
uuid = n.GetHashCode().ToString();
diskRead.CategoryName = "PhysicalDisk";
diskRead.CounterName = "Disk Read Bytes/sec";
diskRead.InstanceName = n;
diskWrite.CategoryName = "PhysicalDisk";
diskWrite.CounterName = "Disk Write Bytes/sec";
diskWrite.InstanceName = n;
diskIOPSRead.CategoryName = "PhysicalDisk";
diskIOPSRead.CounterName = "Disk Reads/sec";
diskIOPSRead.InstanceName = n;
diskIOPSWrite.CategoryName = "PhysicalDisk";
diskIOPSWrite.CounterName = "Disk Writes/sec";
diskIOPSWrite.InstanceName = n;
diskRead.NextValue();
diskWrite.NextValue();
diskIOPSRead.NextValue();
diskIOPSWrite.NextValue();
}
public StatNetworkItem(string n)
{
historyTotals = new FixedSizeQueue<NetworkStatQueue> { MaxSize = 602 };
history = new FixedSizeQueue<NetworkStatQueue> { MaxSize = 602 };
historyHour = new FixedSizeQueue<NetworkStatQueue>{ MaxSize = 602 };
historyDay = new FixedSizeQueue<NetworkStatQueue>{ MaxSize = 602 };
name = n;
}
/// <summary>
/// Initializes a new instance of the <see cref="OutputViewModel"/> class.
/// </summary>
/// <param name="queueSize">Size of the queue.</param>
public OutputViewModel(int queueSize = DefaultQueueSize)
{
lines = new FixedSizeQueue<Paragraph>(queueSize);
TimestampEnabled = true;
EnterCommand = new RelayCommand<string>(OnTextEntered);
}
private void AddHistoryItem(FixedSizeQueue<MemStat> from, int count, FixedSizeQueue<MemStat> to, long index)
{
long free = 0;
long total = 0;
long used = 0;
for (int i = 1; i <= count; i++)
{
MemStat sample = from.ElementAt(history.Count() - i);
free += sample.Free;
used += sample.Used;
total += sample.Total;
}
free /= count;
total /= count;
used /= count;
var hourSample = new MemStat
{
SampleID = index,
Free = free,
Total = total,
Used = used,
PageInCount = 0,
PageOutCount = 0,
SwapTotal = 0,
SwapUsed = 0
};
to.Enqueue(hourSample);
}
/// <summary>
/// Tries to decode a QR Code in a given bitmap.
/// </summary>
/// <param name="bm">The bitmap to be parsed.</param>
/// <returns>A string with the contents of the barcode if successful, null otherwise</returns>
public static unsafe string TryDecode(Bitmap bm, bool inverted)
{
_width = bm.Width;
_height = bm.Height;
BitmapData bmData = bm.LockBits(new Rectangle(0, 0, _width, _height), ImageLockMode.ReadOnly, bm.PixelFormat);
int imageBpp = 0;
switch (bm.PixelFormat)
{
case PixelFormat.Format32bppArgb: imageBpp = 4; break;
case PixelFormat.Format24bppRgb: imageBpp = 3; break;
case PixelFormat.Format8bppIndexed: imageBpp = 1; break;
default: break;
}
byte* ptr = (byte*)bmData.Scan0.ToPointer();
int padding = bmData.Stride - _width * imageBpp;
int[] imgArray = new int[_width * _height];
for (int y = 0; y < _height; y++)
{
for (int x = 0; x < (_width * imageBpp); x += imageBpp)
{
if (!inverted)
{
if (ptr[0] < 127)
{
imgArray[y * _width + x / imageBpp] = 1;
}
else if (ptr[0] > 127) imgArray[y * _width + x / imageBpp] = 0;
}
else
{
if (ptr[0] < 127) imgArray[y * _width + x / imageBpp] = 0;
else if (ptr[0] > 127) imgArray[y * _width + x / imageBpp] = 1;
}
ptr += imageBpp;
}
ptr += padding;
}
bm.UnlockBits(bmData);
_imageArray = imgArray;
FixedSizeQueue<int> stateCount = new FixedSizeQueue<int>(5);
FixedSizeQueue<int> pixelColor = new FixedSizeQueue<int>(5);
int[] correctFinderPatternArray = new int[5] { 1, 0, 1, 0, 1 };
List<FinderPattern> finderPatterns = new List<FinderPattern>();
int currentColorCount = 0;
bool correctPixelColor = true;
bool foundStartPixelColor = false;
bool doneSearching = false;
int currentState = 0;
for (int y = 0; y < _height; y++)
{
for (int x = 0; x < _width; x++)
{
int currentPixel = imgArray[y * _width + x];
if (currentPixel == 1) // Current pixel is black
{
currentColorCount++;
if (x == _width - 1 && y == _height - 1)
{
doneSearching = true;
}
if (!doneSearching && imgArray[y * _width + x + 1] == 0)
{
// Next pixel in line is white
stateCount.Enqueue(currentColorCount);
if (!foundStartPixelColor)
{
pixelColor.Enqueue(1);
int[] array = pixelColor.GetArray();
if (correctFinderPatternArray.SequenceEqual(array))
foundStartPixelColor = true;
}
else correctPixelColor = !correctPixelColor;
currentColorCount = 0;
currentState++;
if (currentState >= 5)
{
int[] stateCountArray = stateCount.GetArray();
// We found a black/white/black/white/black pattern, now check its ratios
//if (x > 2009 && y > 880) System.Diagnostics.Debugger.Break();
if (validFinderPattern(stateCountArray) && correctPixelColor)
{
float patternMiddle = verticalFinderPatternCheck(stateCountArray, x, y);
if (!float.IsNaN(patternMiddle))
{
finderPatterns.Add(new FinderPattern(stateCountArray, (int)Math.Round(stateCountCenter(stateCountArray, x)), (int)Math.Round(patternMiddle)));
}
}
}
}
}
else if (currentPixel == 0) // Current pixel is white
{
currentColorCount++;
if (x == _width - 1 && y == _height - 1)
{
doneSearching = true;
}
if (!doneSearching && imgArray[y * _width + x + 1] == 1)
{
stateCount.Enqueue(currentColorCount);
if (!foundStartPixelColor)
{
pixelColor.Enqueue(0);
int[] array = pixelColor.GetArray();
if (correctFinderPatternArray.SequenceEqual(array))
foundStartPixelColor = true;
}
else correctPixelColor = !correctPixelColor;
currentColorCount = 0;
currentState++; // Next pixel in line is black
}
}
}
}
if (doneSearching)
{
List<FinderPattern> uniqueFinderPatterns = new List<FinderPattern>();
foreach (FinderPattern pattern in finderPatterns)
{
int currentX = pattern.X;
int currentY = pattern.Y;
bool listContainsFinderPattern = false;
foreach (FinderPattern uniquePattern in uniqueFinderPatterns)
{
if (Math.Abs(currentX - uniquePattern.X) < (0.05f * currentX) && Math.Abs(currentY - uniquePattern.Y) < (0.05f * currentY)) listContainsFinderPattern = true;
}
if (!listContainsFinderPattern) uniqueFinderPatterns.Add(pattern);
}
if (uniqueFinderPatterns.Count > 3)
{
TryDecode(ImageProcessing.RotateImageByAngle(bm, 45.0f), false);
}
if (uniqueFinderPatterns.Count < 3 && !inverted) // We do not have three finder patterns, repeat the process with an inverted image, as per the spec
{
TryDecode(bm, true);
}
else // We have the necessary number of finder patterns, proceed with decoding
{
float codeAngle;
for (int i = 0; i < uniqueFinderPatterns.Count; i++)
{
}
//uniqueFinderPatterns[2] = uniqueFinderPatterns[3];
bool result = sortUniqueFinderPatterns(ref uniqueFinderPatterns, out codeAngle);
if (result)
{
middleOfFinderPatterns(ref uniqueFinderPatterns);
updateStateCounts(ref uniqueFinderPatterns);
float dx = (float)Math.Cos(codeAngle);
float dy = (float)Math.Sin(codeAngle);
float d = (float)Math.Sqrt(Math.Pow(uniqueFinderPatterns[1].X - uniqueFinderPatterns[0].X, 2) + Math.Pow(uniqueFinderPatterns[1].Y - uniqueFinderPatterns[0].Y, 2));
int[] upperLeftStateCount = uniqueFinderPatterns[0].StateCount;
int[] upperRightStateCount = uniqueFinderPatterns[1].StateCount;
int widthUpperLeft = upperLeftStateCount[0] + upperLeftStateCount[1] + upperLeftStateCount[2] + upperLeftStateCount[3] + upperLeftStateCount[4];
int widthUpperRight = upperRightStateCount[0] + upperRightStateCount[1] + upperRightStateCount[2] + upperRightStateCount[3] + upperRightStateCount[4];
float nominalXDimension = (widthUpperLeft + widthUpperRight) / 14.0f;
int symbolVersion = (int)Math.Round(((d / nominalXDimension) - 10) / 4.0f);
float alpha = (codeAngle / 180.0f) * (float)Math.PI;
if (symbolVersion >= 7)
{
float upperRightModuleSize = widthUpperRight / 7.0f;
string versionInformation1 = "";
float versionInformation1X = uniqueFinderPatterns[1].X - (7.0f * nominalXDimension);
float versionInformation1Y = uniqueFinderPatterns[1].Y - (3.0f * nominalXDimension);
for (int versionY = -3; versionY < 3; versionY++)
{
for (int versionX = -7; versionX < -4; versionX++)
{
float beta = (float)Math.Atan2(versionY, versionX);
float distance = versionX * upperRightModuleSize / (float)Math.Cos(beta);
int xC = (int)Math.Round(distance * Math.Cos(alpha + beta) + uniqueFinderPatterns[1].X);
int yC = (int)Math.Round(distance * Math.Sin(alpha + beta) + uniqueFinderPatterns[1].Y);
if (_imageArray[yC * _width + xC] == 1) versionInformation1 += "1";
else versionInformation1 += "0";
}
}
int? readVersion = qrCodeVersion(versionInformation1);
if (readVersion != null) symbolVersion = (int)readVersion;
else return "";
}
int numberOfModules = 17 + symbolVersion * 4;
int xDifference = Math.Abs(uniqueFinderPatterns[1].X - uniqueFinderPatterns[0].X);
int yDifference = Math.Abs(uniqueFinderPatterns[1].Y - uniqueFinderPatterns[0].Y);
float finderPatternDistance = (float)Math.Sqrt(xDifference * xDifference + yDifference * yDifference);
float moduleSize = finderPatternDistance / (numberOfModules - 7);
bool[,] qrCode = new bool[numberOfModules,numberOfModules];
for (int symbolY = -3; symbolY < numberOfModules - 3; symbolY++)
{
string str = "";
for (int symbolX = -3; symbolX < numberOfModules - 3; symbolX++)
{
float distance;
float beta = (float)Math.Atan2(symbolY, symbolX);
if (beta < 0) beta += 2.0f * (float)Math.PI;
if ((beta > 0.25f * Math.PI && beta < 0.75f * Math.PI) || (beta > 1.25f * Math.PI && beta < 1.75f * Math.PI))
{
distance = symbolY * moduleSize / (float)Math.Sin(beta);
}
else
{
distance = symbolX * moduleSize / (float)Math.Cos(beta);
}
int xC = (int)Math.Round(distance * Math.Cos(alpha + beta) + uniqueFinderPatterns[0].X);
int yC = (int)Math.Round(distance * Math.Sin(alpha + beta) + uniqueFinderPatterns[0].Y);
if (xC < 0) xC = 0;
if (yC < 0) yC = 0;
if (_imageArray[yC * _width + xC] == 1)
{
qrCode[symbolX + 3, symbolY + 3] = true;
str += "1";
}
else
{
qrCode[symbolX + 3, symbolY + 3] = false;
str += "0";
}
}
}
System.Diagnostics.Debug.WriteLine(qrCode[4, 4]);
int ecLevel; // M=0; L=1; H=2; Q=3
int dataMaskingPattern;
formatInformation(qrCode, numberOfModules, out ecLevel, out dataMaskingPattern);
releaseDataMasking(ref qrCode, numberOfModules, dataMaskingPattern);
byte[] rawData = performDecode(qrCode, numberOfModules);
int ordinalECLevel = getOrdinalECLevel(ecLevel);
QRCodeVersion currentVersion = versions[arrayVersionNumber(numberOfModules)];
ECBlocks currentECBlocks = currentVersion.ECBlock(ordinalECLevel);
ECB[] ecBlockArray = currentECBlocks.getECBlocks();
int blockNumber = currentECBlocks.NumBlocks;
int[] dataCodewordsPerBlock = new int[blockNumber];
for (int i = 0; i < ecBlockArray[0].Count; i++)
{
dataCodewordsPerBlock[i] = ecBlockArray[0].DataCodewords;
}
if (ecBlockArray.Length == 2)
{
for (int i = 0; i < ecBlockArray[1].Count; i++)
{
dataCodewordsPerBlock[i] = ecBlockArray[1].DataCodewords;
}
}
int ecCodewordsPerBlock = currentECBlocks.ECCodewordsPerBlock;
int errorCorrectionBoundary = 0;
byte[][] orderedDataCodewords = new byte[blockNumber][];
byte[][] orderedECCodewords = new byte[blockNumber][];
int runCounter = 0;
for (int i = 0; i < ecBlockArray.Length; i++)
{
ECB currentECBlock = ecBlockArray[i];
int count = currentECBlock.Count;
int numberOfDataCodewords = currentECBlock.DataCodewords;
for (int j = 0; j < count; j++)
{
byte[] currentBlockDataCodewords = new byte[numberOfDataCodewords];
for (int k = 0; k < numberOfDataCodewords; k++)
{
int rawDataBytePosition = j + k * count;
currentBlockDataCodewords[k] = rawData[rawDataBytePosition];
errorCorrectionBoundary++;
}
orderedDataCodewords[runCounter++] = currentBlockDataCodewords;
}
}
for (int i = 0; i < blockNumber; i++)
{
byte[] currentBlockECCodewords = new byte[ecCodewordsPerBlock];
for (int j = 0; j < ecCodewordsPerBlock; j++)
{
int rawDataBytePosition = errorCorrectionBoundary + i + j * blockNumber;
currentBlockECCodewords[j] = rawData[rawDataBytePosition];
}
orderedECCodewords[i] = currentBlockECCodewords;
}
byte[][] orderedCodewords = new byte[blockNumber][];
for (int i = 0; i < orderedDataCodewords.GetLength(0); i++)
{
byte[] temp = new byte[orderedDataCodewords[i].Length + orderedECCodewords[i].Length];
orderedDataCodewords[i].CopyTo(temp, 0);
orderedECCodewords[i].CopyTo(temp, orderedDataCodewords[i].Length);
orderedCodewords[i] = temp;
}
int p = currentVersion.getNumberOfMisdecodeProtectionCodewords(ordinalECLevel);
int numberOfSyndromes = ecCodewordsPerBlock - p;
int currentBlock = 0;
List<int> finalDataCodewords = new List<int>();
foreach (byte[] block in orderedCodewords)
{
int[] intBlock = byteArrayToIntArray(block);
int[] corrected = ReedSolomon.CorrectMessage(intBlock, numberOfSyndromes);
if (!corrected.SequenceEqual<int>(new int[] { -1 }))
{
List<int> list = corrected.ToList<int>();
int dataCodewords = dataCodewordsPerBlock[currentBlock];
finalDataCodewords = finalDataCodewords.Concat(list.GetRange(0, dataCodewords)).ToList();
}
else return null;
currentBlock++;
}
System.Diagnostics.Debug.WriteLine(finalDataCodewords);
int fLength = finalDataCodewords.Count;
int[] shiftedFinalDataCodewords = new int[fLength - 2];
int messageLength = ((finalDataCodewords[0] & 0xf) << 4) ^ ((finalDataCodewords[1] & 0xf0) >> 4);
for (int i = 1; i < fLength - 1; i++)
{
int currentCodeword = finalDataCodewords[i];
int nextCodeword = finalDataCodewords[i + 1];
int temp = (int)((currentCodeword & 0xf) << 4);
int temp2 = (int)((nextCodeword & 0xf0) >> 4);
int final = temp ^ temp2;
shiftedFinalDataCodewords[i - 1] = final;
}
return System.Text.Encoding.GetEncoding("iso-8859-1").GetString(intArrayToByteArray(shiftedFinalDataCodewords)).Substring(0, messageLength);
}
}
}
return "";
}
public void FixedSizeQueue_CanEnqueue()
{
FixedSizeQueue<int> queue = new FixedSizeQueue<int>(1);
queue.Enqueue(1);
Assert.AreEqual(1, queue.Count);
}
public void QueueInitializesToEmpty()
{
var queue = new FixedSizeQueue <int>(4);
Assert.AreEqual(queue.Count, 0);
}
private Point2D prevUserCoords; //previous valid user coordinates
//init
public Validator(int theQueueLength)
{
//initialize properties
frameQueue = new FixedSizeQueue <GazeData>(theQueueLength);
prevUserCoords = new Point2D();
}
public FormLoadGraph()
{
if (!HasCounterCategory("Network Interface"))
{
this.Close();
throw new Exception("This computer has no: 'Network Interface' counter");
}//end if
InitializeComponent();
SetStyle(ControlStyles.DoubleBuffer, true);
SetStyle(ControlStyles.AllPaintingInWmPaint, true);
m_Options = new Options();
m_vTrayIcons = new TrayIconList();
string path = Directory.GetParent(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData)).FullName;
string sDirectory = Path.Combine(path, Utils.AppName); //Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
Directory.CreateDirectory(sDirectory);
m_sSettingsFile = Path.Combine(sDirectory, m_sSettingsFile);
string dataBaseFileName = Path.Combine(sDirectory, "log.mdb");
if (!(File.Exists(dataBaseFileName)))
{
Stream s = Assembly.GetExecutingAssembly().GetManifestResourceStream("DUMeterMZ.log.mdb");
Stream r = File.Create(dataBaseFileName);
int len = 8192;
byte[] buffer = new byte[len];
while (len > 0)
{
len = s.Read(buffer, 0, len);
r.Write(buffer, 0, len);
}
r.Close();
s.Close();
} //end if
m_OleDbConnection.ConnectionString =
@"Provider=Microsoft.Jet.OLEDB.4.0;" +
@"Password="""";User ID=Admin;" +
@"Data Source=" + sDirectory + @"\log.mdb;" +
@"Mode=Share Deny None;" +
@"Extended Properties="""";" +
@"Jet OLEDB:System database="""";" +
@"Jet OLEDB:Registry Path="""";" +
@"Jet OLEDB:Database Password="""";" +
@"Jet OLEDB:Engine Type=5;" +
@"Jet OLEDB:Database Locking Mode=1;" +
@"Jet OLEDB:Global Partial Bulk Ops=2;" +
@"Jet OLEDB:Global Bulk Transactions=1;" +
@"Jet OLEDB:New Database Password="""";" +
@"Jet OLEDB:Create System Database=False;" +
@"Jet OLEDB:Encrypt Database=False;" +
@"Jet OLEDB:Don't Copy Locale on Compact=False;" +
@"Jet OLEDB:Compact Without Replica Repair=False;" +
@"Jet OLEDB:SFP=False";
Application.ApplicationExit += new EventHandler(this.AppExit);
MouseWheel += new MouseEventHandler(MyMouseWheel);
m_PictureBoxGraph_Resize(this, null);
m_NotifyIcon.Icon = m_vTrayIcons[3];
//icon = Icon.ToBitmap();
//initialize queue with screen width
m_recv_all_q = new FixedSizeQueue <float>(Screen.PrimaryScreen.Bounds.Width);
m_send_all_q = new FixedSizeQueue <float>(Screen.PrimaryScreen.Bounds.Width);
m_OleDbConnection.Open();
} //end Constructor
private protected sealed override void TransformCore(ref TInput input, FixedSizeQueue <TInput> windowedBuffer, long iteration, ref VBuffer <Double> dst)
{
var outputLength = Parent.OutputLength;
Host.Assert(outputLength >= 2);
var result = VBufferEditor.Create(ref dst, outputLength);
float rawScore = 0;
for (int i = 0; i < outputLength; ++i)
{
result.Values[i] = Double.NaN;
}
// Step 1: Computing the raw anomaly score
result.Values[1] = ComputeRawAnomalyScore(ref input, windowedBuffer, iteration);
if (Double.IsNaN(result.Values[1]))
{
result.Values[0] = 0;
}
else
{
if (WindowSize > 0)
{
// Step 2: Computing the p-value score
rawScore = (float)result.Values[1];
if (Parent.ThresholdScore == AlertingScore.RawScore)
{
switch (Parent.Side)
{
case AnomalySide.Negative:
rawScore = (float)(-result.Values[1]);
break;
case AnomalySide.Positive:
break;
default:
rawScore = (float)Math.Abs(result.Values[1]);
break;
}
}
else
{
result.Values[2] = ComputeKernelPValue(rawScore);
switch (Parent.Side)
{
case AnomalySide.Negative:
result.Values[2] = 1 - result.Values[2];
break;
case AnomalySide.Positive:
break;
default:
result.Values[2] = Math.Min(result.Values[2], 1 - result.Values[2]);
break;
}
// Keeping the p-value in the safe range
if (result.Values[2] < SequentialAnomalyDetectionTransformBase <TInput, TState> .MinPValue)
{
result.Values[2] = SequentialAnomalyDetectionTransformBase <TInput, TState> .MinPValue;
}
else if (result.Values[2] > SequentialAnomalyDetectionTransformBase <TInput, TState> .MaxPValue)
{
result.Values[2] = SequentialAnomalyDetectionTransformBase <TInput, TState> .MaxPValue;
}
RawScoreBuffer.AddLast(rawScore);
// Step 3: Computing the martingale value
if (Parent.Martingale != MartingaleType.None && Parent.ThresholdScore == AlertingScore.MartingaleScore)
{
Double martingaleUpdate = 0;
switch (Parent.Martingale)
{
case MartingaleType.Power:
martingaleUpdate = Parent.LogPowerMartigaleBettingFunc(result.Values[2], Parent.PowerMartingaleEpsilon);
break;
case MartingaleType.Mixture:
martingaleUpdate = Parent.LogMixtureMartigaleBettingFunc(result.Values[2]);
break;
}
if (LogMartingaleUpdateBuffer.Count == 0)
{
for (int i = 0; i < LogMartingaleUpdateBuffer.Capacity; ++i)
{
LogMartingaleUpdateBuffer.AddLast(martingaleUpdate);
}
_logMartingaleValue += LogMartingaleUpdateBuffer.Capacity * martingaleUpdate;
}
else
{
_logMartingaleValue += martingaleUpdate;
_logMartingaleValue -= LogMartingaleUpdateBuffer.PeekFirst();
LogMartingaleUpdateBuffer.AddLast(martingaleUpdate);
}
result.Values[3] = Math.Exp(_logMartingaleValue);
}
}
}
// Generating alert
bool alert = false;
if (RawScoreBuffer.IsFull) // No alert until the buffer is completely full.
{
switch (Parent.ThresholdScore)
{
case AlertingScore.RawScore:
alert = rawScore >= Parent.AlertThreshold;
break;
case AlertingScore.PValueScore:
alert = result.Values[2] <= Parent.AlertThreshold;
break;
case AlertingScore.MartingaleScore:
alert = (Parent.Martingale != MartingaleType.None) && (result.Values[3] >= Parent.AlertThreshold);
if (alert)
{
if (_martingaleAlertCounter > 0)
{
alert = false;
}
else
{
_martingaleAlertCounter = Parent.WindowSize;
}
}
_martingaleAlertCounter--;
_martingaleAlertCounter = _martingaleAlertCounter < 0 ? 0 : _martingaleAlertCounter;
break;
}
}
result.Values[0] = Convert.ToDouble(alert);
}
dst = result.Commit();
}
public bool? Monitor(params object[] data)
{
// TODO: move partially up
byte backgroundCycles = Config.BackgroundCycles;
doBackgroundPremeasure = backgroundCycles != 0;
Graph.MeasureGraph g;
switch (pState) {
case ProgramStates.Ready:
if (SomePointsUsed) {
//Order is important here!!!! Underlying data update before both matrix formation and measure mode init.
g = Graph.MeasureGraph.Instance;
g.ResetForMonitor();
//var peaks = g.PreciseData.GetUsed();
//already filtered in ResetForMonitor()
var peaks = g.PreciseData;
#warning matrix is formed too early
// TODO: move matrix formation to manual operator actions
// TODO: parallelize matrix formation, flag on completion
// TODO: duplicates
peaksForMatrix = peaks.GetWithId();
if (peaksForMatrix.Count > 0) {
// To comply with other processing order (and saved information)
peaksForMatrix.Sort(PreciseEditorData.ComparePreciseEditorDataByPeakValue);
matrix = new Matrix(Config.LoadLibrary(peaksForMatrix));
// What do with empty matrix?
if (matrix != null)
matrix.Init();
else {
OnLog("Error in peak data format or duplicate substance.");
return null;
}
} else
matrix = null;
// TODO: feed measure mode with start shift value (really?)
short? startShiftValue = 0;
{
var co = g.CommonOptions;
var temp = new MeasureMode.Precise.Monitor(Config.MIN_STEP, Config.MAX_STEP,
// TODO: getWithId()
peaks,
co.befTimeReal, co.iTimeReal, co.eTimeReal,
co.ForwardTimeEqualsBeforeTime ? co.befTimeReal : co.fTimeReal, co.bTimeReal,
(p, peak) => g.updateGraphDuringPreciseMeasure(p, peak, Counts),
g.updateGraphAfterPreciseMeasure,
Config.Iterations, Config.TimeLimit,
// TODO: move extra data into checker
Config.CheckerPeak, Config.CheckerPeak == null ? null : startShiftValue, Config.AllowedShift);
temp.SaveResults += (s, e) => {
Config.autoSaveMonitorSpectrumFile(LabelNumber);
if (LabelNumber.HasValue)
LabelNumber = null;
};
temp.Finalize += (s, e) => Config.finalizeMonitorFile();
// how to unsubscribe?
//realizer.MeasureSend += (s, e) => temp.NextMeasure(e.Value);
CurrentMeasureMode = temp;
}
if (doBackgroundPremeasure) {
initMeasure(ProgramStates.WaitBackgroundMeasure);
background = new FixedSizeQueue<List<long>>(backgroundCycles);
// or maybe Enumerator realization: one item, always recounting (accumulate values)..
g.GraphDataModified += NewBackgroundMeasureReady;
} else {
initMeasure(ProgramStates.Measure);
g.GraphDataModified += NewMonitorMeasureReady;
}
return true;
} else {
OnLog("No points for monitor mode measure.");
return null;
}
case ProgramStates.BackgroundMeasureReady:
// set background end label
LabelNumber = 0;
g = Graph.MeasureGraph.Instance;
g.GraphDataModified -= NewBackgroundMeasureReady;
backgroundResult = background.Aggregate(Summarize);
for (int i = 0; i < backgroundResult.Count; ++i) {
// TODO: check integral operation behaviour here
backgroundResult[i] /= backgroundCycles;
}
setProgramStateWithoutUndo(ProgramStates.Measure);
g.GraphDataModified += NewMonitorMeasureReady;
return false;
case ProgramStates.Measure:
// set label
LabelNumber = (int)data[0];
return false;
default:
// wrong state, strange!
return null;
}
}
private protected override void LearnStateFromDataCore(FixedSizeQueue <Single> data)
{
// This method is empty because there is no need to implement a training logic here.
}
private GazeManager()
{
gazeListeners = new List<IGazeListener>();
calibrationStateListeners = new List<ICalibrationResultListener>();
trackerStateListeners = new List<ITrackerStateListener>();
queueGazeData = new FixedSizeQueue<GazeData>(FRAME_QUEUE_SIZE);
}
public void ConvertVideo(Action <string> log, Action <string> setStatus, Action <double> setProgress,
Action <bool> setIsIndeterminate, string sourceFile, string outputFile, CropInfo cropInfo)
{
setStatus("Converting Video");
setIsIndeterminate(true);
CheckOutputDirectory(log, Path.GetDirectoryName(outputFile));
log(Environment.NewLine + Environment.NewLine + "Executing '" + FFMPEGExe + "' on '" + sourceFile + "'...");
ProcessStartInfo psi = new ProcessStartInfo(FFMPEGExe)
{
Arguments = "-y" + (cropInfo.CropStart ? " -ss " + cropInfo.Start.ToString(CultureInfo.InvariantCulture) : null) + " -i \"" + sourceFile + "\" -analyzeduration " + int.MaxValue + " -probesize " + int.MaxValue + " -c:v copy" + (cropInfo.CropEnd ? " -t " + cropInfo.Length.ToString(CultureInfo.InvariantCulture) : null) + " \"" + outputFile + "\"",
RedirectStandardError = true,
RedirectStandardOutput = true,
StandardErrorEncoding = Encoding.UTF8,
StandardOutputEncoding = Encoding.UTF8,
UseShellExecute = false,
CreateNoWindow = true
};
log(Environment.NewLine + "Command line arguments: " + psi.Arguments + Environment.NewLine);
using (Process p = new Process())
{
FixedSizeQueue <string> logQueue = new FixedSizeQueue <string>(200);
TimeSpan duration = TimeSpan.FromSeconds(cropInfo.Length);
DataReceivedEventHandler outputDataReceived = new DataReceivedEventHandler((s, e) =>
{
try
{
if (!string.IsNullOrWhiteSpace(e.Data))
{
string dataTrimmed = e.Data.Trim();
logQueue.Enqueue(dataTrimmed);
if (dataTrimmed.StartsWith("frame", StringComparison.OrdinalIgnoreCase) && duration != TimeSpan.Zero)
{
string timeStr = dataTrimmed.Substring(dataTrimmed.IndexOf("time") + 4).Trim();
timeStr = timeStr.Substring(timeStr.IndexOf("=") + 1).Trim();
timeStr = timeStr.Substring(0, timeStr.IndexOf(" ")).Trim();
if (TimeSpan.TryParse(timeStr, out TimeSpan current))
{
setIsIndeterminate(false);
setProgress(current.TotalMilliseconds / duration.TotalMilliseconds * 100);
}
else
{
setIsIndeterminate(true);
}
}
}
}
catch (Exception ex)
{
log(Environment.NewLine + "An error occured while reading '" + FFMPEGExe + "' output stream!" + Environment.NewLine + Environment.NewLine + ex.ToString());
}
});
p.OutputDataReceived += outputDataReceived;
p.ErrorDataReceived += outputDataReceived;
p.StartInfo = psi;
p.Start();
p.BeginErrorReadLine();
p.BeginOutputReadLine();
p.WaitForExit();
if (p.ExitCode == 0)
{
log(Environment.NewLine + "Video conversion complete!");
}
else
{
if (!logQueue.IsEmpty)
{
foreach (string line in logQueue)
{
log(Environment.NewLine + line);
}
}
throw new ApplicationException("An error occured while converting the video!");
}
}
}
public bool?Monitor(params object[] data)
{
// TODO: move partially up
byte backgroundCycles = Config.BackgroundCycles;
doBackgroundPremeasure = backgroundCycles != 0;
Graph.MeasureGraph g;
switch (pState)
{
case ProgramStates.Ready:
if (SomePointsUsed)
{
//Order is important here!!!! Underlying data update before both matrix formation and measure mode init.
g = Graph.MeasureGraph.Instance;
g.ResetForMonitor();
//var peaks = g.PreciseData.GetUsed();
//already filtered in ResetForMonitor()
var peaks = g.PreciseData;
#warning matrix is formed too early
// TODO: move matrix formation to manual operator actions
// TODO: parallelize matrix formation, flag on completion
// TODO: duplicates
peaksForMatrix = peaks.GetWithId();
if (peaksForMatrix.Count > 0)
{
// To comply with other processing order (and saved information)
peaksForMatrix.Sort(PreciseEditorData.ComparePreciseEditorDataByPeakValue);
matrix = new Matrix(Config.LoadLibrary(peaksForMatrix));
// What do with empty matrix?
if (matrix != null)
{
matrix.Init();
}
else
{
OnLog("Error in peak data format or duplicate substance.");
return(null);
}
}
else
{
matrix = null;
}
// TODO: feed measure mode with start shift value (really?)
short?startShiftValue = 0;
{
var co = g.CommonOptions;
var temp = new MeasureMode.Precise.Monitor(Config.MIN_STEP, Config.MAX_STEP,
// TODO: getWithId()
peaks,
co.befTimeReal, co.iTimeReal, co.eTimeReal,
co.ForwardTimeEqualsBeforeTime ? co.befTimeReal : co.fTimeReal, co.bTimeReal,
(p, peak) => g.updateGraphDuringPreciseMeasure(p, peak, Counts),
g.updateGraphAfterPreciseMeasure,
Config.Iterations, Config.TimeLimit,
// TODO: move extra data into checker
Config.CheckerPeak, Config.CheckerPeak == null ? null : startShiftValue, Config.AllowedShift);
temp.SaveResults += (s, e) => {
Config.autoSaveMonitorSpectrumFile(LabelNumber);
if (LabelNumber.HasValue)
{
LabelNumber = null;
}
};
temp.Finalize += (s, e) => Config.finalizeMonitorFile();
// how to unsubscribe?
//realizer.MeasureSend += (s, e) => temp.NextMeasure(e.Value);
CurrentMeasureMode = temp;
}
if (doBackgroundPremeasure)
{
initMeasure(ProgramStates.WaitBackgroundMeasure);
background = new FixedSizeQueue <List <long> >(backgroundCycles);
// or maybe Enumerator realization: one item, always recounting (accumulate values)..
g.GraphDataModified += NewBackgroundMeasureReady;
}
else
{
initMeasure(ProgramStates.Measure);
g.GraphDataModified += NewMonitorMeasureReady;
}
return(true);
}
else
{
OnLog("No points for monitor mode measure.");
return(null);
}
case ProgramStates.BackgroundMeasureReady:
// set background end label
LabelNumber = 0;
g = Graph.MeasureGraph.Instance;
g.GraphDataModified -= NewBackgroundMeasureReady;
backgroundResult = background.Aggregate(Summarize);
for (int i = 0; i < backgroundResult.Count; ++i)
{
// TODO: check integral operation behaviour here
backgroundResult[i] /= backgroundCycles;
}
setProgramStateWithoutUndo(ProgramStates.Measure);
g.GraphDataModified += NewMonitorMeasureReady;
return(false);
case ProgramStates.Measure:
// set label
LabelNumber = (int)data[0];
return(false);
default:
// wrong state, strange!
return(null);
}
}
private protected override sealed void SpectralResidual(Single input, FixedSizeQueue <Single> data, ref VBufferEditor <double> result)
{
// Step 1: Get backadd wave
List <Single> backAddList = BackAdd(data);
// Step 2: FFT transformation
int length = backAddList.Count;
float[] fftRe = new float[length];
float[] fftIm = new float[length];
FftUtils.ComputeForwardFft(backAddList.ToArray(), Enumerable.Repeat(0.0f, length).ToArray(), fftRe, fftIm, length);
// Step 3: Calculate mags of FFT
List <Single> magList = new List <Single>();
for (int i = 0; i < length; ++i)
{
magList.Add(MathUtils.Sqrt((fftRe[i] * fftRe[i] + fftIm[i] * fftIm[i])));
}
// Step 4: Calculate spectral
List <Single> magLogList = magList.Select(x => x != 0 ? MathUtils.Log(x) : 0).ToList();
List <Single> filteredLogList = AverageFilter(magLogList, Parent.AvergingWindowSize);
List <Single> spectralList = new List <Single>();
for (int i = 0; i < magLogList.Count; ++i)
{
spectralList.Add(MathUtils.ExpSlow(magLogList[i] - filteredLogList[i]));
}
// Step 5: IFFT transformation
float[] transRe = new float[length];
float[] transIm = new float[length];
for (int i = 0; i < length; ++i)
{
if (magLogList[i] != 0)
{
transRe[i] = fftRe[i] * spectralList[i] / magList[i];
transIm[i] = fftIm[i] * spectralList[i] / magList[i];
}
else
{
transRe[i] = 0;
transIm[i] = 0;
}
}
float[] ifftRe = new float[length];
float[] ifftIm = new float[length];
FftUtils.ComputeBackwardFft(transRe, transIm, ifftRe, ifftIm, length);
// Step 6: Calculate mag and ave_mag of IFFT
List <Single> ifftMagList = new List <Single>();
for (int i = 0; i < length; ++i)
{
ifftMagList.Add(MathUtils.Sqrt((ifftRe[i] * ifftRe[i] + ifftIm[i] * ifftIm[i])));
}
List <Single> filteredIfftMagList = AverageFilter(ifftMagList, Parent.JudgementWindowSize);
// Step 7: Calculate score and set result
var score = CalculateSocre(ifftMagList[data.Count - 1], filteredIfftMagList[data.Count - 1]);
score /= 10.0f;
result.Values[1] = score;
score = Math.Min(score, 1);
score = Math.Max(score, 0);
var detres = score > Parent.AlertThreshold ? 1 : 0;
result.Values[0] = detres;
var mag = ifftMagList[data.Count - 1];
result.Values[2] = mag;
}
/// <summary>
/// The abstract method that realizes the main logic for the transform.
/// </summary>
/// <param name="input">A reference to the input object.</param>
/// <param name="dst">A reference to the dst object.</param>
/// <param name="windowedBuffer">A reference to the windowed buffer.</param>
/// <param name="iteration">A long number that indicates the number of times TransformCore has been called so far (starting value = 0).</param>
public virtual void TransformCore(ref TInput input, FixedSizeQueue <TInput> windowedBuffer, long iteration, ref TOutput dst)
{
}
/// <summary>
/// Possible returns:
///
/// Finite Value: no infinite value in the sliding window and at least a non NaN value
/// NaN value: only NaN values in the sliding window or +/- Infinite
/// Inifinite value: one infinite value in the sliding window (sign is no relevant)
/// </summary>
internal static Single ComputeMovingAverageUniform(FixedSizeQueue <Single> others, Single input, int lag,
Single lastDropped, ref Single currentSum,
ref bool initUniformMovingAverage,
ref int nbNanValues)
{
if (initUniformMovingAverage)
{
initUniformMovingAverage = false;
return(ComputeMovingAverageUniformInitialisation(others, input, lag,
lastDropped, ref currentSum, ref nbNanValues));
}
else
{
if (Single.IsNaN(lastDropped))
{
--nbNanValues;
}
else if (!FloatUtils.IsFinite(lastDropped))
{
// One infinite value left,
// we need to recompute everything as we don't know how many infinite values are in the sliding window.
return(ComputeMovingAverageUniformInitialisation(others, input, lag,
lastDropped, ref currentSum, ref nbNanValues));
}
else
{
currentSum -= lastDropped;
}
// lastDropped is finite
Contracts.Assert(FloatUtils.IsFinite(lastDropped) || Single.IsNaN(lastDropped));
var newValue = lag == 0 ? input : others[others.Count - lag];
if (!Single.IsNaN(newValue) && !FloatUtils.IsFinite(newValue))
{
// One infinite value entered,
// we need to recompute everything as we don't know how many infinite values are in the sliding window.
return(ComputeMovingAverageUniformInitialisation(others, input, lag,
lastDropped, ref currentSum, ref nbNanValues));
}
// lastDropped is finite and input is finite or NaN
Contracts.Assert(FloatUtils.IsFinite(newValue) || Single.IsNaN(newValue));
if (!Single.IsNaN(currentSum) && !FloatUtils.IsFinite(currentSum))
{
if (Single.IsNaN(newValue))
{
++nbNanValues;
return(currentSum);
}
else
{
return(FloatUtils.IsFinite(newValue) ? currentSum : (currentSum + newValue));
}
}
// lastDropped is finite, input is finite or NaN, currentSum is finite or NaN
Contracts.Assert(FloatUtils.IsFinite(currentSum) || Single.IsNaN(currentSum));
if (Single.IsNaN(newValue))
{
++nbNanValues;
int nb = (lag == 0 ? others.Count + 1 : others.Count - lag + 1) - nbNanValues;
return(nb == 0 ? Single.NaN : currentSum / nb);
}
else
{
int nb = lag == 0 ? others.Count + 1 - nbNanValues : others.Count + 1 - nbNanValues - lag;
currentSum += input;
return(nb == 0 ? Single.NaN : currentSum / nb);
}
}
}
/// <summary>
/// The abstract method that realizes the main logic for the transform.
/// </summary>
/// <param name="input">A reference to the input object.</param>
/// <param name="dst1">A reference to the dst object.</param>
/// <param name="dst2"></param>
/// <param name="dst3"></param>
/// <param name="windowedBuffer">A reference to the windowed buffer.</param>
/// <param name="iteration">A long number that indicates the number of times TransformCore has been called so far (starting value = 0).</param>
private protected virtual void TransformCore(ref TInput input, FixedSizeQueue <TInput> windowedBuffer, long iteration,
ref TOutput dst1, ref TOutput dst2, ref TOutput dst3)
{
}
/// <summary> /// The abstract method that realizes the main logic for the transform. /// </summary> /// <param name="input">A reference to the input object.</param> /// <param name="dst">A reference to the dst object.</param> /// <param name="windowedBuffer">A reference to the windowed buffer.</param> /// <param name="iteration">A long number that indicates the number of times TransformCore has been called so far (starting value = 0).</param> private protected abstract void TransformCore(ref TInput input, FixedSizeQueue <TInput> windowedBuffer, long iteration, ref TOutput dst);
protected override void LearnStateFromDataCore(FixedSizeQueue <Single> data)
{
// This method is empty because there is no need for initial tuning for this transform.
}
/// <summary> /// Trains the sequence model on a given sequence. /// </summary> /// <param name="data">The input sequence used for training</param> internal abstract void Train(FixedSizeQueue <TInput> data);
public Buffer(int index, string name)
{
this.Index = index;
this.Name = name;
this.Contents = new FixedSizeQueue<BufferEntry>(1024);
}