public void TestAABB()
{
Vector[] vecs = new Vector[] { Vector.Create(-1.0, -1.0), Vector.Create(1.0, 1.0), Vector.Create(2.0, 2.0), Vector.Create(3.0, 3.0) };
KdTree <Vector> tree = new KdTree <Vector>(vecs, new Accelerators.Subdivision.SubdivisionPolicyConnector(1));
BoundingVolumeSearch <Vector> s = new BoundingVolumeSearch <Vector>(tree.Root);
List <Vector> found =
new List <Vector>(s.FindInsideBoundingVolume(new AABB(Vector.Create(0.5, 0.5), Vector.Create(2.5, 2.5))));
Assert.AreEqual(found.Count, 2);
Assert.IsTrue(VectorComparison.Equal(vecs[1], found[0]));
Assert.IsTrue(VectorComparison.Equal(vecs[2], found[1]));
found = new List <Vector>(
s.FindInsideBoundingVolume(
new AABB(Vector.Create(0.0, 0.0), Vector.Create(0.5, 0.5))
)
);
Assert.IsEmpty(found);
found = new List <Vector>(
s.FindInsideBoundingVolume(
new AABB(Vector.Create(-2.0, -2.0), Vector.Create(4.5, 4.5))
)
);
Assert.AreEqual(4, found.Count);
Assert.IsTrue(VectorComparison.Equal(vecs[0], found[0]));
Assert.IsTrue(VectorComparison.Equal(vecs[1], found[1]));
Assert.IsTrue(VectorComparison.Equal(vecs[2], found[2]));
Assert.IsTrue(VectorComparison.Equal(vecs[3], found[3]));
}
public void TestCopyTo()
{
IVector[] dest = new IVector[10];
Vector[] vecs = new Vector[] { Vector.Create(-1.0, -1.0), Vector.Create(0.0, 0.0), Vector.Create(1.0, 1.0), Vector.Create(2.0, 2.0) };
KdTree <IVector> tree = new KdTree <IVector>(2, new Accelerators.Subdivision.SubdivisionPolicyConnector(1));
tree.CopyTo(dest, 0);
Assert.IsNull(dest[0]); // nothing copied
tree.Add(vecs[0]);
tree.Add(vecs[1]);
tree.Add(vecs[2]);
tree.CopyTo(dest, 0);
for (int i = 0; i < 3; ++i)
{
Assert.IsTrue(VectorComparison.Equal(vecs[i], dest[i]));
}
tree.CopyTo(dest, 3);
for (int i = 0; i < 3; ++i)
{
Assert.IsTrue(VectorComparison.Equal(vecs[i], dest[i + 3]));
}
tree = new KdTree <IVector>(2, new Accelerators.Subdivision.SubdivisionPolicyConnector(2));
tree.Add(vecs[0]);
tree.Add(vecs[1]);
tree.Add(vecs[2]);
tree.CopyTo(dest, 6);
for (int i = 0; i < 3; ++i)
{
Assert.IsTrue(VectorComparison.Equal(vecs[i], dest[i + 6]));
}
}
public void TestScalarMul()
{
Vector a = Vector.Create(1.0, 2.0);
VectorOperations.ScalarMul(a, 0.5, ref a);
Assert.IsTrue(VectorComparison.Close(a, Vector.Create(0.5, 1.0), FloatComparison.DefaultEps));
}
/// <summary>
/// Specialized exact search for the first matching item. This method
/// does not carry the overhead of creating IEnumerables for its result set.
/// </summary>
public bool TryFindExactFirst(IVector x, out T first)
{
// If point is not within root-bounds we can exit early
if (!this.Tree.InternalBounds.Inside(x))
{
first = default(T);
return(false);
}
// Else we fetch the leaf x possibly resides in
KdNode <T> leaf = _cls.FindClosestLeaf(x);
// And test for containment
int index = leaf.Vectors.FindIndex(delegate(T obj) { return(VectorComparison.Equal(x, obj)); });
if (index < 0)
{
first = default(T);
return(false);
}
else
{
first = leaf.Vectors[index];
return(true);
}
}
public void TestConstructorSet()
{
// Construct from dimensionality
Vector v1 = new Vector(3);
Assert.AreEqual(3, v1.Dimensions);
v1[0] = 1.0; v1[1] = 2.0;
// Construct from other vector
Vector reference = Vector.Create(1.0, 2.0, 3.0);
Vector v2 = new Accelerators.Vector(reference);
Assert.IsTrue(VectorComparison.Close(reference, v2, FloatComparison.DefaultEps));
Vector v3 = new Accelerators.Vector((IVector)reference);
Assert.IsTrue(VectorComparison.Close(reference, v3, FloatComparison.DefaultEps));
Vector v5 = Vector.Create(1.0, 2.0);
Assert.AreEqual(1.0, v5[0], FloatComparison.DefaultEps);
Assert.AreEqual(2.0, v5[1], FloatComparison.DefaultEps);
Vector v6 = Vector.Create(1.0, 2.0, 3.0);
Assert.AreEqual(1.0, v6[0], FloatComparison.DefaultEps);
Assert.AreEqual(2.0, v6[1], FloatComparison.DefaultEps);
Assert.AreEqual(3.0, v6[2], FloatComparison.DefaultEps);
}
public void TestCopy()
{
Vector a = Vector.Create(3.0, 4.0);
Vector b = new Vector(2);
VectorOperations.Copy(a, ref b);
Assert.IsTrue(VectorComparison.Close(a, b, FloatComparison.DefaultEps));
}
public void TestSub()
{
Vector a = Vector.Create(1.0, 2.0);
Vector b = Vector.Create(-1.0, 3.0);
VectorOperations.Sub(a, b, ref a);
Assert.IsTrue(VectorComparison.Close(a, Vector.Create(2.0, -1.0), FloatComparison.DefaultEps));
}
public void TestExistingDuplicates()
{
ExactSearch <Vector> es = new ExactSearch <Vector>(_tree.Root);
IEnumerable <Vector> en = es.FindExact(Vector.Create(1.0, 5.0));
Assert.IsTrue(VectorComparison.Equal(Numbered.First(en), Vector.Create(1.0, 5.0)));
Assert.IsTrue(VectorComparison.Equal(Numbered.Second(en), Vector.Create(1.0, 5.0)));
Assert.IsTrue(VectorComparison.Equal(Numbered.Third(en), Vector.Create(1.0, 5.0)));
}
public void TestOperatorOverloadingSub()
{
Vector a = Vector.Create(4.0, 5.0, 6.0);
Vector b = Vector.Create(1.0, 2.0, 3.0);
Vector c = a - b;
Assert.IsTrue(VectorComparison.Close(c, Vector.Create(3.0, 3.0, 3.0), FloatComparison.DefaultEps));
a -= b;
Assert.IsTrue(VectorComparison.Close(a, Vector.Create(3.0, 3.0, 3.0), FloatComparison.DefaultEps));
}
public void TestBallContainsSome()
{
Ball b = new Ball(Vector.Create(1.0, 4.0), 1.0);
BoundingVolumeSearch <Vector> s = new BoundingVolumeSearch <Vector>(_tree.Root);
List <Vector> result = new List <Vector>(s.FindInsideBoundingVolume(b));
Assert.AreEqual(3, result.Count);
Assert.IsTrue(VectorComparison.Equal(result[0], _vecs[4]));
Assert.IsTrue(VectorComparison.Equal(result[1], _vecs[5]));
Assert.IsTrue(VectorComparison.Equal(result[2], _vecs[6]));
}
public void TestLimitDistance()
{
IncrementalDistanceSearch <Vector> ids = new IncrementalDistanceSearch <Vector>(_tree.Root);
ids.DistanceLimit = 0.1;
ids.CountLimit = 2;
List <Vector> ordered = new List <Vector>(ids.Find(Vector.Create(-1.0, -1.0)));
Assert.AreEqual(1, ordered.Count);
Assert.IsTrue(VectorComparison.Equal(ordered[0], _vecs[0]));
ordered = new List <Vector>(ids.Find(Vector.Create(5.0, 5.0)));
Assert.AreEqual(0, ordered.Count);
}
/// <summary>
/// A function to compare the current VectorClock to another and
/// determine which came first, or if the events happened simultaneously.
/// </summary>
/// <param name="clock2">The VectorClock to compare.</param>
/// <returns>A ComparisonResult enum with the result of the comparison.</returns>
public ComparisonResult CompareVectors(VectorClock clock2)
{
/* We check every readOnlyDeviceId that is a key in this vector clock against every readOnlyDeviceId in clock2.
* If all readOnlyDeviceId values in both clocks are equal they are the same clock(equal). This result should never happen in BudgetFirst since we always increment the clock for each event.
* If every readOnlyDeviceId value in this clock is less than the readOnlyDeviceId in clock2 then this VectorClock came before clock2. Some of the deviceIds can be equal but at least one must be less for this case.
* If every readOnlyDeviceId value in this clock is greater than the readOnlyDeviceId in clock2 then this VectorClock came after clock2. Some of the deviceIds can be equal but at least one must be greater for this case.
* If at least one readOnlyDeviceId is greater, and at least one other readOnlyDeviceId is less between the two clocks, the events happened simultaneously.
*/
var comparison = new VectorComparison();
foreach (var deviceId in this.Keys)
{
if (clock2.ContainsKey(deviceId))
{
if (this[deviceId] < clock2[deviceId])
{
// other clock is ahead for this device, so we're most likely earlier or simultaneous
comparison.SetSmallerOrSimultaneous();
}
if (this[deviceId] > clock2[deviceId])
{
// other clock is behind for this device, so we're most likely later or simultaneous
comparison.SetGreaterOrSimultaneous();
}
}
else if (this[deviceId] != 0)
{
// other clock doesn't know about a device in my vector, so we assume to be later or simultaneous
comparison.SetGreaterOrSimultaneous();
}
}
// Check if clock2 has any deviceIds that are not present in this VectorClock
foreach (var deviceId in clock2.Keys)
{
if (!this.ContainsKey(deviceId) && clock2[deviceId] != 0)
{
// We cannot be later because we don't know about those other devices?
// So we can only be earlier, or simultaneous
comparison.SetSmallerOrSimultaneous();
}
}
return(comparison.GetComparisonResult());
}
public void TestNoLimits()
{
IncrementalDistanceSearch <Vector> ids = new IncrementalDistanceSearch <Vector>(_tree.Root);
List <Vector> ordered = new List <Vector>(ids.Find(Vector.Create(-1.0, -1.0)));
Assert.AreEqual(ordered.Count, 4);
Assert.IsTrue(VectorComparison.Equal(ordered[0], _vecs[0]));
Assert.IsTrue(VectorComparison.Equal(ordered[1], _vecs[1]));
Assert.IsTrue(VectorComparison.Equal(ordered[2], _vecs[2]));
Assert.IsTrue(VectorComparison.Equal(ordered[3], _vecs[3]));
ordered = new List <Vector>(ids.Find(Vector.Create(5.0, 5.0)));
Assert.IsTrue(VectorComparison.Equal(ordered[0], _vecs[3]));
Assert.IsTrue(VectorComparison.Equal(ordered[1], _vecs[2]));
Assert.IsTrue(VectorComparison.Equal(ordered[2], _vecs[1]));
Assert.IsTrue(VectorComparison.Equal(ordered[3], _vecs[0]));
}
public void TestEnlargeSingle()
{
AABB box = new AABB(2);
Vector a = Vector.Create(1.0, 2.0);
box.Enlarge(a);
Assert.IsFalse(box.Empty);
Assert.IsTrue(VectorComparison.Close(a, box.Lower, FloatComparison.DefaultEps));
Assert.IsTrue(VectorComparison.Close(a, box.Upper, FloatComparison.DefaultEps));
Vector b = Vector.Create(-1.0, 4.0);
box.Enlarge(b);
Assert.AreEqual(box.Lower[0], -1.0, FloatComparison.DefaultEps);
Assert.AreEqual(box.Lower[1], 2.0, FloatComparison.DefaultEps);
Assert.AreEqual(box.Upper[0], 1.0, FloatComparison.DefaultEps);
Assert.AreEqual(box.Upper[1], 4.0, FloatComparison.DefaultEps);
}
public bool Test(T obj)
{
return(VectorComparison.Equal(_reference, obj));
}
