virtual public bool EqualTo(ISpatialContainer container)
{
if (container is APointContainer)
{
var currentPoint = ((APointContainer)container).Coordinates;
for (int i = 0; i < Coordinates.Length; i++)
{
if (Coordinates[i] != currentPoint[i])
return false;
}
return true;
}
var currentLower = ((ASpatialContainer)container).Lower;
var currentUpper = ((ASpatialContainer)container).Upper;
for (int i = 0; i < Coordinates.Length; i++)
{
if (currentLower[i] != Coordinates[i] || currentUpper[i] != Coordinates[i])
return false;
}
return true;
}
//
//You can use the following additional attributes as you write your tests:
//
//Use ClassInitialize to run code before running the first test in the class
//[ClassInitialize()]
//public static void MyClassInitialize(TestContext testContext)
//{
//}
//
//Use ClassCleanup to run code after all tests in a class have run
//[ClassCleanup()]
//public static void MyClassCleanup()
//{
//}
//
//Use TestInitialize to run code before running each test
//[TestInitialize()]
//public void MyTestInitialize()
//{
//}
//
//Use TestCleanup to run code after each test has run
//[TestCleanup()]
//public void MyTestCleanup()
//{
//}
//
#endregion
internal virtual ISpatialContainer CreateISpatialContainer()
{
// TODO: Instantiate an appropriate concrete class.
ISpatialContainer target = null;
return(target);
}
virtual public bool Adjacency(ISpatialContainer container)
{
if (container is APointContainer)
{
var currentPointContainer = (APointContainer)container;
for (int i = 0; i < Lower.Length; i++)
{
if (Lower[i] != currentPointContainer.Coordinates[i] ||
Upper[i] != currentPointContainer.Coordinates[i])
{
return(false);
}
}
return(true);
}
if (Intersection(container) && !InternalIntersection((ASpatialContainer)container))
{
return(true);
}
return(false);
}
virtual public bool EqualTo(ISpatialContainer myContainer)
{
if (myContainer is APointContainer)
{
var currentPoint = ((APointContainer)myContainer).Coordinates;
for (int i = 0; i < Lower.Length; i++)
{
if (Lower[i] != currentPoint[i] || Upper[i] != currentPoint[i])
{
return(false);
}
}
return(true);
}
var currentLower = ((ASpatialContainer)myContainer).Lower;
var currentUpper = ((ASpatialContainer)myContainer).Upper;
for (int i = 0; i < Lower.Length; i++)
{
if (currentLower[i] != Lower[i] || currentUpper[i] != Upper[i])
{
return(false);
}
}
return(true);
}
public void ContainerUnitTest()
{
Assert.Inconclusive("TODO");
ISpatialContainer target = CreateISpatialContainer(); // TODO: Initialize to an appropriate value
TypeOfContainer actual;
actual = target.Container;
}
public void UpperPointUnitTest()
{
Assert.Inconclusive("TODO");
ISpatialContainer target = CreateISpatialContainer(); // TODO: Initialize to an appropriate value
float[] actual;
actual = target.UpperPoint;
}
public void EqualToUnitTest()
{
Assert.Inconclusive("TODO");
ISpatialContainer target = CreateISpatialContainer(); // TODO: Initialize to an appropriate value
ISpatialContainer container = null; // TODO: Initialize to an appropriate value
bool expected = false; // TODO: Initialize to an appropriate value
bool actual;
actual = target.EqualTo(container);
Assert.AreEqual(expected, actual);
}
virtual public bool Intersection(ISpatialContainer container)
{
if (container is ASpatialContainer)
{
var currentLower = ((ASpatialContainer)container).Lower;
var currentUpper = ((ASpatialContainer)container).Upper;
for (int i = 0; i < Lower.Length; i++)
{
if (Lower[i] > currentUpper[i] || Upper[i] < currentLower[i])
{
return(false);
}
}
return(true);
}
return(Inclusion(container));
}
public virtual bool Adjacency(ISpatialContainer container)
{
if (container is APointContainer)
{
var currentPointContainer = (APointContainer)container;
for (int i = 0; i < Lower.Length; i++)
{
if (Lower[i] != currentPointContainer.Coordinates[i]
|| Upper[i] != currentPointContainer.Coordinates[i])
return false;
}
return true;
}
if (Intersection(container) && !InternalIntersection((ASpatialContainer)container))
return true;
return false;
}
virtual public bool Intersection(ISpatialContainer container)
{
#region MBR
if (container is ASpatialContainer)
{
var currentContainer = (ASpatialContainer)container;
for (var i = 0; i < Coordinates.Length; i++)
{
if (currentContainer.Lower[i] > Coordinates[i] || currentContainer.Upper[i] < Coordinates[i])
return false;
}
return true;
}
#endregion
#region Point
return EqualTo(container);
#endregion
}
virtual public bool Adjacency(ISpatialContainer container)
{
#region Point
if (container is APointContainer)
{
return(EqualTo(container));
}
#endregion
#region MBR
var currentLower = ((ASpatialContainer)container).Lower;
var currentUpper = ((ASpatialContainer)container).Upper;
for (int i = 0; i < Coordinates.Length; i++)
{
if (currentLower[i] != Coordinates[i] || currentUpper[i] != Coordinates[i])
{
return(false);
}
}
return(true);
}
virtual public bool Intersection(ISpatialContainer container)
{
#region MBR
if (container is ASpatialContainer)
{
var currentContainer = (ASpatialContainer)container;
for (var i = 0; i < Coordinates.Length; i++)
{
if (currentContainer.Lower[i] > Coordinates[i] || currentContainer.Upper[i] < Coordinates[i])
{
return(false);
}
}
return(true);
}
#endregion
#region Point
return(EqualTo(container));
#endregion
}
private float Distance(ISpatialContainer container1, ISpatialContainer container2)
{
if (container1 is APointContainer && container2 is APointContainer)
{
return Metric.Distance((APointContainer)container1, (APointContainer)container2);
}
var points = FindNeighborPoints(container1.LowerPoint, container1.UpperPoint, container2.LowerPoint, container2.UpperPoint);
return Metric.Distance(points.Item1, points.Item2);
}
private static bool Adjacency(ISpatialContainer x, ISpatialContainer y)
{
return x.Adjacency(y);
}
private static bool Inclusion(ISpatialContainer x, ISpatialContainer y)
{
return x.Inclusion(y);
}
private static bool Intersection(ISpatialContainer x, ISpatialContainer y)
{
return x.Intersection(y);
}
public virtual bool EqualTo(ISpatialContainer myContainer)
{
if (myContainer is APointContainer)
{
var currentPoint = ((APointContainer)myContainer).Coordinates;
for (int i = 0; i < Lower.Length; i++)
{
if (Lower[i] != currentPoint[i] || Upper[i] != currentPoint[i])
return false;
}
return true;
}
var currentLower = ((ASpatialContainer)myContainer).Lower;
var currentUpper = ((ASpatialContainer)myContainer).Upper;
for (int i = 0; i < Lower.Length; i++)
{
if (currentLower[i] != Lower[i] || currentUpper[i] != Upper[i])
return false;
}
return true;
}
public virtual bool Intersection(ISpatialContainer container)
{
if (container is ASpatialContainer)
{
var currentLower = ((ASpatialContainer) container).Lower;
var currentUpper = ((ASpatialContainer) container).Upper;
for (int i = 0; i < Lower.Length; i++)
{
if (Lower[i] > currentUpper[i] || Upper[i] < currentLower[i])
return false;
}
return true;
}
return Inclusion(container);
}
virtual public bool Adjacency(ISpatialContainer container)
{
#region Point
if (container is APointContainer)
{
return EqualTo(container);
}
#endregion
#region MBR
var currentLower = ((ASpatialContainer)container).Lower;
var currentUpper = ((ASpatialContainer)container).Upper;
for (int i = 0; i < Coordinates.Length; i++)
{
if (currentLower[i] != Coordinates[i] || currentUpper[i] != Coordinates[i])
return false;
}
return true;
}
private static bool ReInclusion(ISpatialContainer x, ISpatialContainer y)
{
return y.Inclusion(x);
}
virtual public bool Inclusion(ISpatialContainer container)
{
return EqualTo(container);
}
private IMBR FindMBR(ISpatialContainer container1, ISpatialContainer container2)
{
var lower = new float[_countOfR];
var upper = new float[_countOfR];
for (int dimension = 0; dimension < _countOfR; dimension++)
{
lower[dimension] = Math.Min(container1.LowerPoint[dimension], container2.LowerPoint[dimension]);
upper[dimension] = Math.Max(container1.UpperPoint[dimension], container2.UpperPoint[dimension]);
}
return new MBR(lower, upper);
}
virtual public bool Inclusion(ISpatialContainer container)
{
return(EqualTo(container));
}
