/// <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);
}
