/// <summary> /// Creates a screen handler to get the changed parts of the screen since the last check. /// </summary> /// <param name="screen">A rectangle that represents which part of the screen will be handled.</param> /// <param name="hashOnlyCompare"> /// If true, pixel data will be checked only by its HashCode, otherwise it will be checked /// with the implemented Equals method /// </param> public ScreenHandler(Rectangle screen, bool hashOnlyCompare) { if (hashOnlyCompare) { Comparator = new HashComparer(); } else { Comparator = new FullComparer(); } var rect = new Rectangle2(screen); Bounds = rect; //One of the most expensive operations, getting the screen capture. Should be used as less as possible var pixels = PixelGrabber.GrabPixels(PixelGrabber.CreateScreenCapture(screen)); LastPixels = pixels; var minTHeight = Bounds.Height / 6; var minTWidth = Bounds.Width / 8; current = new QuadTree(rect, pixels /*, minTHeight, minTWidth*/); previous = current; firstScreen = true; }
public List <WriterDescription> GetDestination(InnerData ev) { _lock.EnterReadLock(); var ret = new List <WriterDescription>(); if (_servers.Count(x => x.IsAvailable) >= _configuration.CountReplics) { string current = ev.Transaction.EventHash; for (int i = 0; i < _configuration.CountReplics; i++) { var find = _map.AvailableMap.FirstOrDefault( x => HashComparer.Compare(current, x.End) <= 0 && !ret.Contains(x.ServerId)); if (find == null && _map.AvailableMap.Count > 0) { current = Consts.StartHashInRing; find = _map.AvailableMap.FirstOrDefault( x => HashComparer.Compare(current, x.End) <= 0 && !ret.Contains(x.ServerId)); } if (find == null) { Logger.Logger.Instance.Error(Errors.NotEnoughServers); ret.Clear(); break; } current = find.End; ret.Add(find.ServerId); } } _lock.ExitReadLock(); return(ret); }
public void ComparisonIsConstantTime() { var runTimes = new List <RunTime>(); var a = new byte[128]; var b = new byte[128]; for (var i = 0; i < 100000; i++) { var differencePosition = i % a.Length; b[differencePosition] = 0x01; var stopwatch = Stopwatch.StartNew(); HashComparer.Compare(a, b); stopwatch.Stop(); if (i > 10) // Exclude first runs to exclude startup effects { runTimes.Add(new RunTime(differencePosition, stopwatch.ElapsedTicks)); } b[differencePosition] = 0x00; } var correlation = StatisticalOperations.Correlation( runTimes.Select(x => (double)x.DifferencePosition).ToArray(), runTimes.Select(x => (double)x.ElapsedTicks).ToArray()); Console.WriteLine($"Correlation: {correlation}"); Assert.That(correlation, Is.EqualTo(0).Within(0.01), "Correlation"); }
public void EqualArraysReturnTrue() { var a = new byte[] { 0x41, 0x42, 0x43 }; var b = new byte[] { 0x41, 0x42, 0x43 }; Assert.That(HashComparer.Compare(a, b), Is.True); }
public void DifferentArraysReturnFalse() { var a = new byte[] { 0x41, 0x42, 0x43 }; var b = new byte[] { 0x01, 0x02, 0x03 }; Assert.That(HashComparer.Compare(a, b), Is.False); }
public void ArraysOfDifferentLengthReturnFalse() { var a = new byte[3]; var b = new byte[4]; Assert.That(HashComparer.Compare(a, b), Is.False); }
public bool IsMine(MetaData data) { return (_hash.Exists( x => HashComparer.Compare(x.Key, data.Hash) <= 0 && HashComparer.Compare(data.Hash, x.Value) <= 0)); }
/// <summary> /// Takes two hashes, sorts them, and concatenates them. /// </summary> private static byte[] JoinHashesPairwise(byte[] h1, byte[] h2) { if (h1.Length == 0) { return(h2); } if (h2.Length == 0) { return(h1); } HashComparer comparer = new HashComparer(); if (comparer.Compare(h1, h2) < 0) { return(h1.Concat(h2).ToArray()); } else { return(h2.Concat(h1).ToArray()); } }
private static bool CompareEquality(object value, object refValue, object tolerance) { var cc = tolerance as ComparisonConfig; if (cc != null) { //Compare by hash HashComparer <object> hc = new HashComparer <object>(cc); return(hc.Equals(value, refValue)); } // Try checking name compatibility. Useful for materials. string valueString = BH.Engine.CIH.Query.ValueFromSource(value, "Name") as string; string referenceValue = BH.Engine.CIH.Query.ValueFromSource(refValue, "Name") as string; if (string.IsNullOrWhiteSpace(referenceValue)) { referenceValue = refValue as string; } if (valueString == referenceValue) { return(true); } if (value.ToString().Contains("BH.oM") && (refValue is Type)) { return(value.ToString() == refValue.ToString()); } if (value is string && refValue is string) { return(value.ToString() == refValue.ToString()); // this workaround is required. Not even Convert.ChangeType and dynamic type worked. } return(value == refValue); }
public bool IsMine(string hash) { return(HashComparer.Compare(Begin, hash) <= 0 && HashComparer.Compare(hash, End) <= 0); }