bool ISpaceManager.TryFindSpacePoints <T>(Space <T> space, out HashSet <SpacePoint <T> > points, params float[] dimensionPositions)
{
MustBe.Equal(space.Dimensions.Length, dimensionPositions.Length, () => "space.Dimensions.Length AND dimensionPositions.Length");
points = new HashSet <SpacePoint <T> >();
for (var d = 0; d < space.Dimensions.Length; ++d)
{
DimensionPoint <T> left;
DimensionPoint <T> right;
if (!_spaceManager.TryFindDimensionPoint(space.Dimensions[d], dimensionPositions[d], out left, out right))
{
return(false);
}
if (left != null)
{
foreach (var sp in left.SpaPoints)
{
if (sp.IsLocatedAt(dimensionPositions))
{
points.Add(sp);
}
}
}
}
return(true);
}
IEnumerable <SpacePoint <T> > ISpaceManager.FindSpacePointsWithin <T>(Space <T> space, float within, IDimensionSelector dimSelector, params float[] dimensionPositions)
{
MustBe.Equal(space.Dimensions.Length, dimensionPositions.Length, () => "space.Dimensions.Length AND dimensionPositions.Length");
var spacePoints = new HashSet <SpacePoint <T> >();
var tempDimPoints = new HashSet <DimensionPoint <T> >();
for (var d = 0; d < space.Dimensions.Length; ++d)
{
if (dimSelector != null && !dimSelector.IncludesDimension(d))
{
continue;
}
DimensionPoint <T> left;
DimensionPoint <T> right;
var dCenter = dimensionPositions[d];
_spaceManager.TryFindDimensionPoint(space.Dimensions[d], dCenter, out left, out right);
var curr = left;
if (curr != null && !tempDimPoints.Contains(curr))
{
foreach (var sp in EnumerateSpacePoints(curr, spacePoints, tempDimPoints, within, dimSelector, dimensionPositions))
{
yield return(sp);
}
var prev = curr.HeadLink.Prev;
while (prev != null && !tempDimPoints.Contains(prev.DimPoint) && (prev.Position - dCenter).Abs() <= within)
{
foreach (var sp in EnumerateSpacePoints(prev.DimPoint, spacePoints, tempDimPoints, within, dimSelector, dimensionPositions))
{
yield return(sp);
}
}
}
curr = right;
if (curr != null && !tempDimPoints.Contains(curr))
{
foreach (var sp in EnumerateSpacePoints(curr, spacePoints, tempDimPoints, within, dimSelector, dimensionPositions))
{
yield return(sp);
}
var next = curr.HeadLink.Next;
while (next != null && !tempDimPoints.Contains(next.DimPoint) && (next.Position - dCenter).Abs() <= within)
{
foreach (var sp in EnumerateSpacePoints(next.DimPoint, spacePoints, tempDimPoints, within, dimSelector, dimensionPositions))
{
yield return(sp);
}
}
}
}
}
bool ISpaceManager.Reposition <T>(SpacePoint <T> sp, params float[] dimensionPositions)
{
MustBe.Equal(sp.Dimensions.Length, dimensionPositions.Length, () => "space.Dimensions.Length AND dimensionPositions.Length");
byte r = 0;
for (var d = 0; d < sp.Dimensions.Length; ++d)
{
if (_spaceManager.Reposition(sp.Dimensions[d].Dimension, sp, dimensionPositions[d]))
{
++r;
}
}
return(r > 0);
}
bool ISpaceManager.Reposition <T>(SpacePoint <T> sp, float x, float y, float z)
{
MustBe.Equal(sp.Dimensions.Length, 3, () => "space.Dimensions.Length AND x,y,z");
byte r = 0;
if (_spaceManager.Reposition(sp.Dimensions[0].Dimension, sp, x))
{
++r;
}
if (_spaceManager.Reposition(sp.Dimensions[1].Dimension, sp, y))
{
++r;
}
if (_spaceManager.Reposition(sp.Dimensions[2].Dimension, sp, z))
{
++r;
}
return(r > 0);
}
SpacePoint <T> ISpaceManager.AddPoint <T>(Space <T> space, T data, params float[] dimensionPositions)
{
MustBe.NotNull(space, () => "space");
MustBe.NotNull(dimensionPositions, () => "dimensionPositions");
MustBe.Equal(dimensionPositions.Length, space.Dimensions.Length, () => "number of dimensions does not match the number of dimension positions passed when adding point to space");
var sp = new SpacePoint <T>(space)
{
Value = data
};
if (dimensionPositions == null)
{
throw new ArgumentException("Expected dimension positions");
}
for (var i = 0; i < space.Dimensions.Length; ++i)
{
_spaceManager.AddPoint(space.Dimensions[i], sp, dimensionPositions[i]);
}
return(sp);
}
bool ISpaceManager.AddPoint <T>(Dimension <T> dimension, SpacePoint <T> sp, float position)
{
if (dimension == null || sp == null)
{
return(false);
}
MustBe.Null(sp.Dimensions[dimension.Index], () => "space point already has assigned the dimension with index=" + dimension.Index);
if (dimension.HeadDimPoint == null)
{
var dp = new DimensionPoint <T>(dimension)
{
Position = position
};
dp.HeadLink = dp.TailLink = new DimensionLink <T>(0, dp);
dp.AddPoint(sp);
dimension.HeadDimPoint = dimension.TailDimPoint = dp;
dimension.Count = 1;
return(true);
}
// try to find existing dimension point
DimensionPoint <T> left;
DimensionPoint <T> right;
if (_spaceManager.TryFindDimensionPoint(dimension, position, out left, out right))
{
// if found add the space point to it
return(left.AddPoint(sp));
}
// new head
if (left == null)
{
AppendNewHead(dimension, sp, position);
dimension.Count++;
return(true);
}
// new tail
if (right == null)
{
AppendNewTail(dimension, sp, position);
dimension.Count++;
return(true);
}
// new in between
var newPoint = new DimensionPoint <T>(dimension)
{
Position = position
};
newPoint.AddPoint(sp);
var newLink = new DimensionLink <T>(0, newPoint);
newPoint.HeadLink = newLink;
newPoint.TailLink = newLink;
left.HeadLink.AssignNext(newLink);
newLink.AssignNext(right.HeadLink);
// for fast movers do not normalize the tree
if (!sp.IsFastMover)
{
_spaceManager.TryAddLevel(dimension);
var toExtendUp = newLink.GetSiblingExtensionCandidate();
while (_spaceManager.TryExtendUp(toExtendUp, out toExtendUp))
{
_spaceManager.TryAddLevel(dimension);
}
}
dimension.Count++;
return(true);
}
