public PolygonAreaMock CreateRegularStarInnerOneHalfOriginal()
{
return(PolygonAreaMock.RegularStar(Center, NumberOfSidesOrCorners,
ParameterizedRadius, (int)(ParameterizedRadius / 2.0),
DrawFromCornersMethods.OriginalDefault, InnerPointsMethods.ScanlineOddEvenDefault,
LineAlgorithm));
}
public PolygonAreaMock CreateRegularStarInnerThreeFourthsKnownSizeHash()
{
return(PolygonAreaMock.RegularStar(Center, NumberOfSidesOrCorners,
ParameterizedRadius, (int)(ParameterizedRadius * 0.75),
DrawFromCornersMethods.OriginalKnownSizeHash, InnerPointsMethods.ScanlineOddEvenKnownSizeHash,
LineAlgorithm));
}
public PolygonAreaMock CreateRegularStarInnerThreeFourthsCacheOuterPointsOtherHasher()
{
return(PolygonAreaMock.RegularStar(Center, NumberOfSidesOrCorners,
ParameterizedRadius, (int)(ParameterizedRadius * 0.75),
DrawFromCornersMethods.OriginalDefault, InnerPointsMethods.ScanlineOddEvenCacheOuterPointsOtherHasher,
LineAlgorithm));
}
public PolygonAreaMock CreateRegularStarInnerOneFourthOmitRedundantCheck()
{
return(PolygonAreaMock.RegularStar(Center, NumberOfSidesOrCorners,
ParameterizedRadius, (int)(ParameterizedRadius / 4.0),
DrawFromCornersMethods.OriginalDefault, InnerPointsMethods.ScanlineOddEvenOmitRedundantCheck,
LineAlgorithm));
}
// Original method implemented in GoRogue that just draws lines using default hashing algorithms
#region Original GoRogue Method
public static void OriginalDefault(PolygonAreaMock polygon)
{
for (int i = 0; i < polygon.Corners.Count - 1; i++)
{
polygon.OuterPoints.Add(new Area(Lines.Get(polygon.Corners[i], polygon.Corners[i + 1], polygon.LineAlgorithm)));
}
polygon.OuterPoints.Add(new Area(Lines.Get(polygon.Corners[^ 1], polygon.Corners[0], polygon.LineAlgorithm)));
// Variation of ScanlineOddEvenDefault that omits the usage of LINQ and a foreach loop
#region ScanlinesNoLinq
public static void ScanlineOddEvenNoLinq(PolygonAreaMock polygon)
{
polygon.InnerPoints = new Area();
var bounds = polygon.OuterPoints.Bounds;
// The top and bottom rows can never contain an inner point, so skip them.
for (int y = bounds.MinExtentY + 1; y < bounds.MaxExtentY; y++)
{
var linesEncountered = new List <IReadOnlyArea>();
// Must include MinExtentX so that it can accurately count lines encountered.
// Doesn't need MaxExtentX since no inner point can be equal to or greater than that.
for (int x = bounds.MinExtentX; x < bounds.MaxExtentX; x++)
{
if (polygon.OuterPoints.Contains(x, y))
{
for (int sIdx = 0; sIdx < polygon.OuterPoints.SubAreas.Count; sIdx++)
{
var boundary = polygon.OuterPoints.SubAreas[sIdx];
if (!boundary.Contains(x, y))
{
continue;
}
if (HasLessY(boundary, y))
{
if (!linesEncountered.Contains(boundary))
{
linesEncountered.Add(boundary);
}
}
}
}
else
{
if (linesEncountered.Count % 2 == 1)
{
polygon.InnerPoints.Add(x, y);
}
}
}
}
}
// Original scan-lines implementation, but avoids iterating over OuterPoints' SubAreas in cases where the point
// being processed is not an outer point, at the cost of caching the entire set of outer points in a hash set.
#region Scanlines Cache Outer Points Other Hasher
public static void ScanlineOddEvenCacheOuterPointsOtherHasher(PolygonAreaMock polygon)
{
var bounds = polygon.OuterPoints.Bounds;
polygon.InnerPoints = new Area(new KnownRangeHasher(bounds.MinExtent, bounds.MaxExtent));
// Cache outer points in a hash set so that we cut down on iteration proportional to number of sides
// per point when checking if a point is an outer point or not.
var outerPointsSet = new HashSet <Point>(polygon.OuterPoints, new KnownRangeHasher(bounds.MinExtent, bounds.MaxExtent));
// The top and bottom rows can never contain an inner point, so skip them.
for (int y = bounds.MinExtentY + 1; y < bounds.MaxExtentY; y++)
{
var linesEncountered = new List <IReadOnlyArea>();
// Must include MinExtentX so that it can accurately count lines encountered.
// Doesn't need MaxExtentX since no inner point can be equal to or greater than that.
for (int x = bounds.MinExtentX; x < bounds.MaxExtentX; x++)
{
if (outerPointsSet.Contains(new Point(x, y)))
{
foreach (var boundary in GetBoundariesContaining(polygon, x, y))
{
if (boundary.Any(p => p.Y < y))
{
if (!linesEncountered.Contains(boundary))
{
linesEncountered.Add(boundary);
}
}
}
}
else
{
if (linesEncountered.Count % 2 == 1)
{
polygon.InnerPoints.Add(x, y);
}
}
}
}
}
// Variation of ScanlineOddEvenDefault that changes the `Any` call to a more refined approach for checking
// for lesser y-values in a boundary line
#region Scanlines FasterYValueCheck
public static void ScanlineOddEvenFasterYCheck(PolygonAreaMock polygon)
{
polygon.InnerPoints = new Area();
var bounds = polygon.OuterPoints.Bounds;
// The top and bottom rows can never contain an inner point, so skip them.
for (int y = bounds.MinExtentY + 1; y < bounds.MaxExtentY; y++)
{
var linesEncountered = new List <IReadOnlyArea>();
// Must include MinExtentX so that it can accurately count lines encountered.
// Doesn't need MaxExtentX since no inner point can be equal to or greater than that.
for (int x = bounds.MinExtentX; x < bounds.MaxExtentX; x++)
{
if (polygon.OuterPoints.Contains(x, y))
{
foreach (var boundary in GetBoundariesContaining(polygon, x, y))
{
// Since these areas are 2D (ordered) lines, if there exists any point that is a lesser
// y-value than the current, it must be one of the ends
if (boundary[0].Y < y || boundary[^ 1].Y < y)
{
if (!linesEncountered.Contains(boundary))
{
linesEncountered.Add(boundary);
}
}
}
}
else
{
if (linesEncountered.Count % 2 == 1)
{
polygon.InnerPoints.Add(x, y);
}
}
}
}
}
// Variation of ScanlineOddEvenDefault that uses the known-size hasher for inner points
#region Scanlines KnownSize Hash
public static void ScanlineOddEvenKnownSizeHash(PolygonAreaMock polygon)
{
var bounds = polygon.OuterPoints.Bounds;
polygon.InnerPoints = new Area(new KnownSizeHasher(bounds.MaxExtentX));
// The top and bottom rows can never contain an inner point, so skip them.
for (int y = bounds.MinExtentY + 1; y < bounds.MaxExtentY; y++)
{
var linesEncountered = new List <IReadOnlyArea>();
// Must include MinExtentX so that it can accurately count lines encountered.
// Doesn't need MaxExtentX since no inner point can be equal to or greater than that.
for (int x = bounds.MinExtentX; x < bounds.MaxExtentX; x++)
{
if (polygon.OuterPoints.Contains(x, y))
{
foreach (var boundary in GetBoundariesContaining(polygon, x, y))
{
if (boundary.Any(p => p.Y < y))
{
if (!linesEncountered.Contains(boundary))
{
linesEncountered.Add(boundary);
}
}
}
}
else
{
if (linesEncountered.Count % 2 == 1)
{
polygon.InnerPoints.Add(x, y);
}
}
}
}
}
public PolygonAreaMock CreateParallelogramTopCornerOmitRedundantCheck()
{
return(PolygonAreaMock.Parallelogram(Origin, Size, Size, DrawFromCornersMethods.OriginalDefault, InnerPointsMethods.ScanlineOddEvenOmitRedundantCheck, true, LineAlgorithm));
}
public PolygonAreaMock CreateParallelogramTopCornerKnownSizeHash()
{
return(PolygonAreaMock.Parallelogram(Origin, Size, Size, DrawFromCornersMethods.OriginalKnownSizeHash, InnerPointsMethods.ScanlineOddEvenKnownSizeHash, true, LineAlgorithm));
}
public PolygonAreaMock CreateRectangleKnownSizeHash()
{
return(PolygonAreaMock.Rectangle(new Rectangle(Origin.X, Origin.Y, Size, Size), DrawFromCornersMethods.OriginalKnownSizeHash, InnerPointsMethods.ScanlineOddEvenKnownSizeHash, LineAlgorithm));
}
public PolygonAreaMock CreateParallelogramBottomCornerOriginal()
{
return(PolygonAreaMock.Parallelogram(Origin, Size, Size, DrawFromCornersMethods.OriginalDefault, InnerPointsMethods.ScanlineOddEvenDefault, false, LineAlgorithm));
}
public PolygonAreaMock CreateRectangleOriginal()
{
return(PolygonAreaMock.Rectangle(new Rectangle(Origin.X, Origin.Y, Size, Size), DrawFromCornersMethods.OriginalDefault, InnerPointsMethods.ScanlineOddEvenDefault, LineAlgorithm));
}
public PolygonAreaMock CreateParallelogramTopCornerCacheOuterPointsOtherHasher()
{
return(PolygonAreaMock.Parallelogram(Origin, Size, Size, DrawFromCornersMethods.OriginalDefault, InnerPointsMethods.ScanlineOddEvenCacheOuterPointsOtherHasher, true, LineAlgorithm));
}
private static IEnumerable <IReadOnlyArea> GetBoundariesContaining(PolygonAreaMock polygon, int x, int y) => polygon.OuterPoints.SubAreas.Where(sa => sa.Contains(x, y));
public PolygonAreaMock CreateRegularPolygonCacheOuterPoints()
{
return(PolygonAreaMock.RegularPolygon(Center, NumberOfSidesOrCorners, ParameterizedRadius,
DrawFromCornersMethods.OriginalDefault, InnerPointsMethods.ScanlineOddEvenCacheOuterPoints, LineAlgorithm));
}
public PolygonAreaMock CreateParallelogramTopCornerHashSetEncountered()
{
return(PolygonAreaMock.Parallelogram(Origin, Size, Size, DrawFromCornersMethods.OriginalDefault, InnerPointsMethods.ScanlineOddEvenHashSetEncountered, true, LineAlgorithm));
}
