public void NewPolygon()
{
var polygon = new Polygon2D(Rectangle.One, Color.White);
polygon.Points.AddRange(new[] { Vector2D.Zero, Vector2D.One, Vector2D.UnitY });
Assert.AreEqual(Rectangle.One, polygon.DrawArea);
Assert.AreEqual(Color.White, polygon.Color);
}
public void ChangePolygonAfterFirstFrame()
{
var polygon = new Polygon2D(Rectangle.One, Color.White);
polygon.Points.AddRange(new[] { Vector2D.Zero, Vector2D.One, Vector2D.UnitY });
AdvanceTimeAndUpdateEntities();
polygon.Points.Add(Vector2D.Zero);
AdvanceTimeAndUpdateEntities();
}
private static void CreatePolygon(Vector2D position, float radius, Color color)
{
var polygon = new Polygon2D(Rectangle.FromCenter(position, new Size(radius)), color);
var points = new List<Vector2D> { polygon.Center };
for (int num = 0; num <= 500; num++)
points.Add(polygon.Center +
new Vector2D(radius * MathExtensions.Sin(num * 360.0f / 500.0f),
radius * MathExtensions.Cos(num * 360.0f / 500.0f)));
polygon.Points.AddRange(points);
}
public Clipper(int xmin, int xmax, int ymin, int ymax)
{
m_xMin = xmin;
m_xMax = xmax;
m_yMin = ymin;
m_yMax = ymax;
m_clipPoly = new Polygon2D(m_xMin, m_yMin);
//Need to add vertices in clockwise order
m_clipPoly.AddVertex(new Vector3<double>(m_xMax, m_yMin, 1));
m_clipPoly.AddVertex(new Vector3<double>(m_xMax, m_yMax, 1));
m_clipPoly.AddVertex(new Vector3<double>(m_xMin, m_yMax, 1));
}
static void DrawTileOcclussion(Vector2D offset, float z, LightingTilemapCollider2D id)
{
Polygon2D poly = Polygon2DList.CreateFromRect(new Vector2(0.5f, 0.5f));
foreach (DoublePair2D p in DoublePair2D.GetList(poly.pointsList))
{
Vector2D vA = p.A + offset;
Vector2D vB = p.B + offset;
Vector2D vC = p.B + offset;
Vector2D pA = p.A + offset;
Vector2D pB = p.B + offset;
vA.Push(Vector2D.Atan2(p.A, p.B) - Mathf.PI / 2, -1);
vB.Push(Vector2D.Atan2(p.A, p.B) - Mathf.PI / 2, -1);
vC.Push(Vector2D.Atan2(p.B, p.C) - Mathf.PI / 2, -1);
GL.TexCoord2(uv0, uv0);
Max2D.Vertex3(pB, z);
GL.TexCoord2(0.5f - uv0, uv0);
Max2D.Vertex3(pA, z);
GL.TexCoord2(0.5f - uv0, uv1);
Max2D.Vertex3(vA, z);
GL.TexCoord2(uv0, uv1);
Max2D.Vertex3(vA, z);
GL.TexCoord2(0.5f - uv0, uv1);
Max2D.Vertex3(vB, z);
GL.TexCoord2(0.5f - uv0, uv0);
Max2D.Vertex3(pB, z);
GL.TexCoord2(uv1, uv0);
Max2D.Vertex3(vB, z);
GL.TexCoord2(0.5f - uv0, uv0);
Max2D.Vertex3(pB, z);
GL.TexCoord2(0.5f - uv0, uv1);
Max2D.Vertex3(vC, z);
}
}
// Get List Of Polygons from Collider (Usually Used Before Creating Slicer2D Object)
static public List <Polygon2D> CreateFromPolygonColliderToWorldSpace(PolygonCollider2D collider)
{
List <Polygon2D> result = new List <Polygon2D> ();
if (collider != null && collider.pathCount > 0)
{
Polygon2D newPolygon = new Polygon2D();
foreach (Vector2 p in collider.GetPath(0))
{
newPolygon.AddPoint(p + collider.offset);
}
newPolygon = newPolygon.ToWorldSpace(collider.transform);
result.Add(newPolygon);
for (int i = 1; i < collider.pathCount; i++)
{
Polygon2D hole = new Polygon2D();
foreach (Vector2 p in collider.GetPath(i))
{
hole.AddPoint(p + collider.offset);
}
hole = hole.ToWorldSpace(collider.transform);
if (newPolygon.PolyInPoly(hole) == true)
{
newPolygon.AddHole(hole);
}
else
{
result.Add(hole);
}
}
}
return(result);
}
public static Segment2D GetLineSegment2D(Polygon2D polygon, int index)
{
Segment2D lineSegment = null;
Vector2D[] polygonVertices = polygon.GetVertices();
Vector2D startPoint;
Vector2D endPoint;
if (index <= polygonVertices.Length - 2)
{
startPoint = polygonVertices[index];
endPoint = polygonVertices[index + 1];
lineSegment = CreateSegment2D(new Vector2D[] { startPoint, endPoint }, polygon.Name);
}
else
{
lineSegment = null;
}
return(lineSegment);
}
public Slice2D PointSlice(Vector2D point, float rotation)
{
Slice2D slice2D = Slice2D.Create(gameObject, point, rotation);
if (isActiveAndEnabled == false)
{
return(slice2D);
}
Polygon2D colliderPolygon = GetPolygonToSlice();
if (colliderPolygon != null)
{
Slice2D sliceResult = Slicer2D.API.PointSlice(colliderPolygon, point, rotation);
PerformResult(sliceResult.GetPolygons(), sliceResult);
return(sliceResult);
}
return(slice2D);
}
public void VisibleToOtherVerticesTest2()
{
var m_topVertex = new Vector2(1, 1);
var m_botVertex = new Vector2(0, -1);
var m_rightVertex = new Vector2(1, 0);
var m_farRightVertex = new Vector2(2, 0);
var polygon = new Polygon2D(
new List <Vector2>()
{
m_topVertex,
m_farRightVertex,
m_botVertex,
m_rightVertex
});
var vertices = new List <Vector2>()
{
m_farRightVertex,
m_botVertex,
m_rightVertex
};
var visibleVertices = new List <Vector2>()
{
m_farRightVertex,
m_rightVertex
};
var vertex = m_topVertex;
var actual =
m_L2LVisibility.VisibleToOtherVertices(
vertex,
vertices,
polygon);
Assert.AreEqual(visibleVertices.Count, actual.Count);
}
public bool Detach(PolygonCollider2D collider)
{
Polygon2D polygon = Polygon2DList.CreateFromPolygonColliderToWorldSpace(collider)[0];
bool attached = true;
foreach (Collider2D c in anchorColliders)
{
Polygon2D p = anchorPolygons[anchorColliders.IndexOf(c)].ToWorldSpace(c.transform);
// Fix for PolyCollidePoly!!!
bool inHole = false;
foreach (Polygon2D hole in polygon.holesList)
{
if (hole.PolyInPoly(p))
{
inHole = true;
}
}
if (inHole == false)
{
if (Math2D.PolyCollidePoly(p, polygon) == false)
{
attached = false;
}
}
else
{
attached = false;
}
}
if (attached == false)
{
return(true);
}
return(false);
}
// Getting List is Slower
public static List <Vector2D> GetListLineIntersectPoly(Pair2D line, Polygon2D poly)
{
List <Vector2D> result = new List <Vector2D>();
Vector2D intersection;
Pair2D pair = new Pair2D(new Vector2D(poly.pointsList.Last()), null);
for (int i = 0; i < poly.pointsList.Count; i++)
{
pair.B = poly.pointsList[i];
intersection = GetPointLineIntersectLine(line, pair);
if (intersection != null)
{
result.Add(intersection);
}
pair.A = pair.B;
}
return(result);
}
static void InitShape()
{
Coefficients DefaultCoefficients = TimeWarp.Coefficients;
Vector2D[] mainhullvertecies = new Vector2D[]
{
new Vector2D(90, 0),
new Vector2D(70, 15),
new Vector2D(-20, 15),
new Vector2D(-40, 10),
new Vector2D(-40, -10),
new Vector2D(-20, -15),
new Vector2D(70, -15)
};
Vector2D[] leftWingvertecies = new Vector2D[]
{
new Vector2D(10, 10),
new Vector2D(-30, 10),
new Vector2D(-50, -30),
new Vector2D(-20, -30)
};
int length = leftWingvertecies.Length;
Vector2D[] RightWingvertecies = new Vector2D[]
{
new Vector2D(-20, 30),
new Vector2D(-50, 30),
new Vector2D(-30, -10),
new Vector2D(10, -10)
};
IGeometry2D mainhull = new Polygon2D(ALVector2D.Zero, mainhullvertecies);
IGeometry2D leftWing = new Polygon2D(new ALVector2D(0, new Vector2D(10, -20)), leftWingvertecies);
IGeometry2D RightWing = new Polygon2D(new ALVector2D(0, new Vector2D(10, 20)), RightWingvertecies);
DefaultShape = new RigidBodyTemplate(10, 1468.2144894018809f, new IGeometry2D[] { leftWing, RightWing, mainhull }, new Coefficients[] { DefaultCoefficients, DefaultCoefficients, DefaultCoefficients });
DefaultShape.BalanceBody();
////DefaultShape.CalcInertiaMultiplier(.1f);
}
static public void LinearSlice(Slice2D slice, float forceAmount)
{
float sliceRotationA = (float)Vector2D.Atan2(slice.slice[1], slice.slice[0]) - 90f * Mathf.Deg2Rad;
float sliceRotationB = (float)Vector2D.Atan2(slice.slice[1], slice.slice[0]) + 90f * Mathf.Deg2Rad;
float rot = 0;
Rigidbody2D rigidBody2D;
List <Vector2D> collisions = slice.GetCollisions();
Vector2 middleCollision = ((collisions[0] + collisions[1]) / 2f).ToVector2();
foreach (GameObject gameObject in slice.GetGameObjects())
{
rigidBody2D = gameObject.GetComponent <Rigidbody2D> ();
if (rigidBody2D)
{
Polygon2D poly = slice.GetPolygons()[slice.GetGameObjects().IndexOf(gameObject)];
Rect bounds = poly.GetBounds();
Vector2 cpA = middleCollision;
cpA = cpA.Push(sliceRotationA, 1);
Vector2 cpB = middleCollision;
cpB = cpB.Push(sliceRotationB, 1);
if (Vector2.Distance(cpA, bounds.center) < Vector2.Distance(cpB, bounds.center))
{
rot = sliceRotationA;
}
else
{
rot = sliceRotationB;
}
rigidBody2D.AddForce(new Vector2(Mathf.Cos(rot), Mathf.Sin(rot)) * forceAmount);
}
}
}
public void OnRenderObject()
{
if (Camera.current != Camera.main)
{
return;
}
//Max2D.SetLineWidth (0.25f);
//Max2D.SetColor (Color.black);
//Max2D.SetBorder (false);
//Max2D.SetLineMode(Max2D.LineMode.Smooth);
inspectorPosition = Vector3.zero;
Vector2D pos = new Vector2D(Camera.main.ScreenToWorldPoint(Input.mousePosition));
foreach (Slicer2D slicer in Slicer2D.GetList())
{
Polygon2D poly = slicer.shape.GetWorld().ToWorldSpace(slicer.transform);
if (poly.PointInPoly(pos))
{
Rect rect = poly.GetBounds();
//Max2D.lineMaterial = Max2D.lineLegacyMaterial;
//Max2DLegacy.DrawLineRectf(rect.x, rect.y, rect.width, rect.height);
//Max2DLegacy.DrawLinef(rect.center.x, rect.center.y, rect.center.x, rect.center.y + rect.height / 2 + 1);
//Max2D.lineMaterial = Max2D.lineNewMaterial;
inspectorPosition = new Vector2(rect.center.x, rect.center.y + rect.height / 2);
originalSize = slicer.GetComponent <DemoSlicer2DInspectorTracker>().originalSize;
currentSize = poly.GetArea();
sliced = slicer.limit.counter;
}
}
}
internal Class454(IShape2D shape, GraphicsConfig config)
{
IList <Polyline2D> flattened = (IList <Polyline2D>)ShapeTool.GetFlattened(shape, config.ShapeFlattenEpsilon);
if (flattened != null)
{
IList <Polygon2D> input1 = (IList <Polygon2D>) new List <Polygon2D>(flattened.Count);
IList <Polygon2D> polygon2DList = (IList <Polygon2D>) new List <Polygon2D>();
for (int index = 0; index < flattened.Count; ++index)
{
Polygon2D polygon2D = new Polygon2D((IEnumerable <Point2D>)flattened[index]);
if (polygon2D.IsClockwise())
{
polygon2DList.Add(polygon2D);
}
else if (input1.Count == 0)
{
input1.Add(polygon2D);
}
else
{
input1 = (IList <Polygon2D>)Polygon2D.GetUnion(input1, (IList <Polygon2D>) new Polygon2D[1]
{
polygon2D
});
}
}
List <IList <Point2D> > point2DListList = new List <IList <Point2D> >(input1.Count + polygon2DList.Count);
point2DListList.AddRange((IEnumerable <IList <Point2D> >)input1);
point2DListList.AddRange((IEnumerable <IList <Point2D> >)polygon2DList);
Triangulator2D.Triangulate((IList <IList <Point2D> >)point2DListList, (IList <Triangulator2D.Triangle>) this.list_0, (IList <Point2D>) this.list_1);
}
else
{
this.list_0 = (List <Triangulator2D.Triangle>)null;
this.list_1 = (List <Point2D>)null;
}
}
static private Slice2D SingleSlice(Polygon2D polygon, Pair2D slice)
{
Slice2D result = Slice2D.Create(slice);
if ((polygon.PointInPoly(slice.A) == true || polygon.PointInPoly(slice.B) == true)) // && pointsInHoles == 1
{
Slicer2D.Debug.LogError("Incorrect Split 1: When it Happens");
// Slicing through hole cut-out
// return(result);
}
Polygon2D holeA = polygon.PointInHole(slice.A);
Polygon2D holeB = polygon.PointInHole(slice.B);
int pointsInHoles = Convert.ToInt32(holeA != null) + Convert.ToInt32(holeB != null);
if (pointsInHoles == 2 && holeA == holeB)
{
pointsInHoles = 1;
}
switch (pointsInHoles)
{
case 0:
return(SliceWithoutHoles(polygon, slice));
case 1:
return(SliceWithOneHole(polygon, slice, holeA, holeB));
case 2:
return(SliceWithTwoHoles(polygon, slice, holeA, holeB));
default:
break;
}
return(result);
}
public static Mesh TriangulateAdvanced(Polygon2D polygon, Vector2 UVScale, Vector2 UVOffset)
{
TriangulationWrapper.Polygon poly = new TriangulationWrapper.Polygon();
List <Vector2> pointsList = null;
List <Vector2> UVpointsList = null;
Vector3 v = Vector3.zero;
foreach (Vector2D p in polygon.pointsList)
{
v = p.ToVector2();
poly.outside.Add(v);
//poly.outsideUVs.Add (new Vector2(v.x / UVScale.x + .5f + UVOffset.x, v.y / UVScale.y + .5f + UVOffset.y));
poly.outsideUVs.Add(Vector2.zero);
}
foreach (Polygon2D hole in polygon.holesList)
{
pointsList = new List <Vector2> ();
UVpointsList = new List <Vector2> ();
foreach (Vector2D p in hole.pointsList)
{
v = p.ToVector2();
pointsList.Add(v);
//UVpointsList.Add (new Vector2(v.x / UVScale.x + .5f, v.y / UVScale.y + .5f));
UVpointsList.Add(Vector2.zero);
}
poly.holes.Add(pointsList);
poly.holesUVs.Add(UVpointsList);
}
return(TriangulationWrapper.CreateMesh(poly));
}
public VisibilitySimpleTest()
{
var m_topVertex = new Vector2(0, 1);
var m_botVertex = new Vector2(0, -1);
var m_leftVertex = new Vector2(-1, 0);
var m_rightVertex = new Vector2(1, 0);
var m_farRightVertex = new Vector2(2, 0);
arrowPoly = new Polygon2D(new List <Vector2>()
{
m_topVertex, m_farRightVertex, m_botVertex, m_rightVertex
});
diamondPoly = new Polygon2D(new List <Vector2>()
{
m_topVertex, m_rightVertex, m_botVertex, m_leftVertex
});
LShape = new Polygon2D(new List <Vector2>()
{
new Vector2(0, 0), new Vector2(0, 4), new Vector2(4, 4),
new Vector2(4, 2), new Vector2(2, 2), new Vector2(2, 0)
});
}
static public Mesh GeneratePolygonMesh(Vector2D pos, Polygon2D.PolygonType polygonType, float polygonSize, float minVertexDistance, Transform transform, float lineWidth, float zPosition)
{
List <Mesh2DSubmesh> trianglesList = new List <Mesh2DSubmesh>();
Polygon2D slicePolygon = Polygon2D.Create(polygonType, polygonSize);
slicePolygon.ToOffsetItself(pos);
Vector2D vA, vB;
foreach (Pair2D pair in Pair2D.GetList(slicePolygon.pointsList, true))
{
vA = new Vector2D(pair.A);
vB = new Vector2D(pair.B);
vA.Push(Vector2D.Atan2(pair.A, pair.B), -minVertexDistance / 5);
vB.Push(Vector2D.Atan2(pair.A, pair.B), minVertexDistance / 5);
trianglesList.Add(Max2DMesh.CreateLine(new Pair2D(vA, vB), transform, lineWidth, zPosition));
}
return(Max2DMesh.Export(trianglesList));
}
private void Load()
{
if (!_isLoaded)
{
var points = new List <Point2D>();
if (Commands != null && Commands.Any())
{
points.Add(Commands.First().PointFrom);
points.AddRange(Commands.Select(c => new Point2D {
X = c.PointTo.X ?? 0.0, Y = c.PointTo.Y ?? 0.0
}));
}
_polygon = new Polygon2D {
Points = points
};
_maxX = _polygon.MaxX;
_minX = _polygon.MinX;
_maxY = _polygon.MaxY;
_minY = _polygon.MinY;
_isClosed = _polygon.IsClosed;
_isLoaded = true;
}
}
void Start()
{
instance = this;
tempList = new List <Vector2>();
for (int i = 0; i < 10; i++)
{
tempList.Add(RoomGenerationInCircle.getRandomPointInCircle(100, 1));
}
// tempList.Add(new Vector2(-123,73));
// tempList.Add(new Vector2(108,-63));
// tempList.Add(new Vector2(-107,-46));
// tempList.Add(new Vector2(-39,-8));
// tempList.Add(new Vector2(-54,110));
triangles = Polygon2D.DelaunayTriangulation(tempList);
// foreach (var item in triangles)
// {
// Debug.DrawLine(item.pointA, item.pointB);
// Debug.DrawLine(item.pointA, item.pointC);
// Debug.DrawLine(item.pointC, item.pointB);
// }
// StartCoroutine(Draw());
}
private void Update()
{
foreach (var item in tempList)
{
Debug.DrawLine(item + Vector2.up, item + Vector2.down);
Debug.DrawLine(item + Vector2.left, item + Vector2.right);
}
foreach (var item in triangles)
{
Debug.DrawLine(item.pointA, item.pointB);
Debug.DrawLine(item.pointA, item.pointC);
Debug.DrawLine(item.pointC, item.pointB);
}
if (Input.GetKeyDown("space"))
{
tempList.RemoveRange(0, tempList.Count);
for (int i = 0; i < 10; i++)
{
tempList.Add(RoomGenerationInCircle.getRandomPointInCircle(100, 1));
}
triangles = Polygon2D.DelaunayTriangulation(tempList);
}
}
public void GetOutlinePoints_Rectangle()
{
var polygon = new Polygon2D(PolygonGrid2D.GetRectangle(6, 10));
var expectedPoints = new List <Vector2Int>();
// Vertical lines
for (int i = 0; i <= 10; i++)
{
expectedPoints.Add(new Vector2Int(0, i));
expectedPoints.Add(new Vector2Int(6, i));
}
// Horizontal lines
for (int i = 1; i < 6; i++)
{
expectedPoints.Add(new Vector2Int(i, 0));
expectedPoints.Add(new Vector2Int(i, 10));
}
var points = polygon.GetOutlinePoints();
Assert.That(points, Is.EquivalentTo(expectedPoints));
}
public List <Polygon2D> GetPolygon(LightingTilemapCollider2D tilemap)
{
if (world_polygon == null)
{
if (tilemap.colliderType == LightingTilemapCollider2D.ColliderType.SpriteCustomPhysicsShape)
{
if (GetShapePolygons().Count < 1)
{
return(null);
}
world_polygon = GetShapePolygons(); //poly.ToScaleItself(defaultSize); // scale?
}
else
{
Vector2 size = tilemap.cellSize * 0.5f;
world_polygon = new List <Polygon2D>();
world_polygon.Add(Polygon2D.CreateFromRect(size));
}
}
return(world_polygon);
}
static void InitShape()
{
Coefficients DefaultCoefficients = TimeWarp.Coefficients;
List <IGeometry2D> goes = new List <IGeometry2D>();
List <Coefficients> coes = new List <Coefficients>();
Vector2D[] engineconevertecies = new Vector2D[]
{
new Vector2D(20, 10),
new Vector2D(-50, 40),
new Vector2D(-100, 40),
new Vector2D(-100, -40),
new Vector2D(-50, -40),
new Vector2D(20, -10)
};
Vector2D offset = Polygon2D.CalcCentroid(engineconevertecies);
//engineconevertecies = Vector2D.Translate(-offset, engineconevertecies);
OperationHelper.ArrayRefOp <Vector2D, Vector2D, Vector2D>(
engineconevertecies,
ref offset,
engineconevertecies,
Vector2D.Subtract);
goes.Add(new Polygon2D(new ALVector2D(0, offset), engineconevertecies));
coes.Add(DefaultCoefficients);
goes.Add(new Polygon2D(new ALVector2D(0, new Vector2D(10, 0)), Polygon2D.FromNumberofSidesAndRadius(8, 40)));
coes.Add(DefaultCoefficients);
DefaultShape = new RigidBodyTemplate(20, 1995.1433515249612f, goes.ToArray(), coes.ToArray());
DefaultShape.BalanceBody();
////DefaultShape.CalcInertiaMultiplier(.1f);
}
private void BuildSlice()
{
this.Original = SliceModel.GeometrizeModel(this.data.CurrentModel);
var bounds = this.data.CurrentModel.Bounds;
Construct obj = Construct.Create(this.Original, this.data.CurrentModel.Transform);
//Construct box = Construct.Create(this.SlicePlane.Geometry as MeshGeometry3D);
//Construct sli = obj.Intersect(box);
var dense_spacing = this.data.NozzleDiameter * 2.875; // Default == 1.15
// Genarate infills
var infill_struct = Polygon2D.GenerateInfill(
bounds.X, bounds.Y,
bounds.X + bounds.SizeX, bounds.Y + bounds.SizeY,
this.data.NozzleDiameter, this.data.InfillSpacing, this.data.UseInfill
);
// Construct slice
this.Slice = obj.Slice(bounds.Z + data.CurrentSliceIdx * data.NozzleThickness,
data.NozzleThickness);
this.Slice.SetNozzleHeight(data.CurrentSliceIdx * data.NozzleThickness);
this.Slice.Erode(data.NozzleThickness / 2.0);
this.Slice.AddShells(data.NumberOfShells, data.NozzleThickness * dense_spacing);
this.Slice.AddInfill(infill_struct);
this.Slice.SortPolygons();
var min = Math.Min(bounds.X, bounds.Y);
var max = Math.Max(bounds.X + bounds.SizeX, bounds.Y + bounds.SizeY);
var size = Math.Min(this.data.SliceCanvas.ActualWidth, this.data.SliceCanvas.ActualHeight);
var scale = size / (max - min);
this.data.SliceShapes = this.Slice.ToShapes(bounds.X, bounds.Y, scale, this.data.PreviewArrowThickness, this.data.PreviewStrokeThickness);
this.data.SliceCanvas.Children.Clear();
this.data.SliceShapes.ForEach(x => this.data.SliceCanvas.Children.Add(x));
}
static public Slice2D LinearCutSlice(Polygon2D polygon, LinearCut linearCut)
{
List <Vector2D> slice = linearCut.GetPointsList();
Slice2D result = Slice2D.Create(linearCut);
if (slice.Count < 1)
{
return(result);
}
Vector2D startPoint = null;
foreach (Vector2D id in slice)
{
if (polygon.PointInPoly(id) == false)
{
startPoint = id;
break;
}
}
Polygon2D newPolygon = new Polygon2D(slice);
slice = Vector2DList.GetListStartingPoint(slice, startPoint);
slice.Add(startPoint);
if (polygon.PolyInPoly(newPolygon))
{
polygon.AddHole(newPolygon);
result.AddPolygon(polygon);
return(result);
}
result = ComplexSlicer.Slice(polygon, slice);
return(result);
}
static public void DrawPolygon(Polygon2D poly, float z = 0f, bool connect = true)
{
Max2D.Check();
switch (Max2D.lineMode)
{
case Max2D.LineMode.Smooth:
GL.PushMatrix();
Max2D.lineMaterial.SetPass(0);
GL.Begin(GL.QUADS);
Max2DMatrixLegacy.DrawSliceImage(poly.pointsList, z, connect);
GL.End();
GL.PopMatrix();
break;
case Max2D.LineMode.Default:
GL.PushMatrix();
Max2D.defaultMaterial.SetPass(0);
GL.Begin(GL.LINES);
GL.Color(Max2D.setColor);
Max2DMatrixLegacy.DrawSlice(poly.pointsList, z, connect);
GL.End();
GL.PopMatrix();
break;
}
foreach (Polygon2D p in poly.holesList)
{
DrawPolygon(p, z);
}
}
private Polygon2D WorldPolyon()
{
if (worldPolygon != null)
{
return(worldPolygon);
}
float cameraSizeY = camera.orthographicSize;
float cameraSizeX = cameraSizeY * (float)camera.pixelWidth / camera.pixelHeight;
float sizeX = cameraSizeX * 2;
float sizeY = cameraSizeY * 2;
float x = -sizeX / 2;
float y = -sizeY / 2;
worldPolygon = Polygon();
worldPolygon.pointsList[0].x = x;
worldPolygon.pointsList[0].y = y;
worldPolygon.pointsList[1].x = x + sizeX;
worldPolygon.pointsList[1].y = y;
worldPolygon.pointsList[2].x = x + sizeX;
worldPolygon.pointsList[2].y = y + sizeY;
worldPolygon.pointsList[3].x = x;
worldPolygon.pointsList[3].y = y + sizeY;
worldPolygon.ToRotationItself(rotation * Mathf.Deg2Rad);
worldPolygon.ToOffsetItself(position);
worldRect = worldPolygon.GetRect();
return(worldPolygon);
}
/// <summary>
/// Triangulates this polygon using the two ears theorem. This is O(n^2).
/// </summary>
/// <remarks>
/// Currently runs in O(n^2) time.
/// TODO improve this to O(n log n) or O(n log log n).
/// </remarks>
/// <param name="polygon"></param>
/// <param name="setTwinPointers"> whether the triangulation should set twin pointers </param>
/// <returns>A list of clockwise triangles whose disjoint union is this polygon</returns>
public static Triangulation Triangulate(Polygon2D polygon, bool setTwinPointers = true)
{
// cannot yet triangulate non-simple polygons
/* assume it to be, checks takes too long
* if (!polygon.IsSimple())
* {
* throw new ArgumentException("Polygon must be simple: " + polygon);
* }
*/
if (polygon.VertexCount < 3)
{
return(new Triangulation());
}
var T = TriangulateRecursive(polygon.Vertices.ToList());
if (setTwinPointers)
{
T.SetTwinPointers();
}
return(T);
}
private IList <Polyline4D> method_16(
DrawContext.Wireframe context,
out Polyline3DT imageBoundaryPolyline,
out IClippingTransformer transformer)
{
Polygon2D clipBoundary = this.GetClipBoundary((DrawContext)context);
if (clipBoundary != null && clipBoundary.Count != 0)
{
Matrix4D preTransform = this.method_15();
transformer = context.GetTransformer();
transformer = (IClippingTransformer)transformer.Clone();
transformer.SetPreTransform(preTransform);
imageBoundaryPolyline = new Polyline3DT(true);
foreach (WW.Math.Point2D point2D in (List <WW.Math.Point2D>)clipBoundary)
{
imageBoundaryPolyline.Add(new Point3DT((WW.Math.Point3D)point2D, 0U));
}
return((IList <Polyline4D>) new List <Polyline4D>((IEnumerable <Polyline4D>)transformer.Transform(imageBoundaryPolyline.ToPolyline3D(), true)));
}
imageBoundaryPolyline = (Polyline3DT)null;
transformer = (IClippingTransformer)null;
return((IList <Polyline4D>) new Polyline4D[0]);
}
public override void _Ready()
{
lvl = (level)GetNode("/root/level");
if (lvl != null)
{
difficulty_coef = lvl.get_difficulty();
}
polygon = GetNode <Polygon2D>("polygon_2d");
collision_shape_2d = GetNode <CollisionShape2D>("collision_shape_2d");
polygon.Color = new Color(color_name);
//draw square
var vectors = polygon.Polygon;
vectors[0].x = (-(width / 2));
vectors[0].y = (-(height / 2));
vectors[1].x = width / 2;
vectors[1].y = (-(height / 2));
vectors[2].x = width / 2;
vectors[2].y = height / 2;
vectors[3].x = (-(width / 2));
vectors[3].y = height / 2;
//vectors[0].Set(-(width / 2), -(height / 2)); // old api (before 3.2)
//vectors[1].Set((width / 2), -(height / 2));
//vectors[2].Set((width / 2), (height / 2));
//vectors[3].Set(-(width / 2), (height / 2));
polygon.Polygon = vectors;
//set collision shape
RectangleShape2D shape = new RectangleShape2D();
shape.Extents = new Vector2(width / 2, height / 2);
collision_shape_2d.Shape = shape;
}
public void UnionTest3()
{
var polygon0 = new Polygon2D(new List <Vector2>
{
new Vector2(4.00124f, -0.9741771f), new Vector2(1.329107f, 0.0009262562f),
new Vector2(-1.329329f, -0.003419161f), new Vector2(-1.336399f, -2.668384f),
new Vector2(-4.00066f, -2.661608f), new Vector2(-4.00317f, 2.666523f), new Vector2(4.00428f, 2.665259f),
});
var polygon1 = new Polygon2D(new List <Vector2>
{
new Vector2(4.00124f, -2.664724f), new Vector2(1.333887f, -2.663425f),
new Vector2(1.329107f, 0.0009263754f), new Vector2(-1.329329f, -0.003419101f),
new Vector2(-4.00317f, -0.7164398f), new Vector2(-4.00317f, 2.666523f),
new Vector2(4.00428f, 2.665259f),
});
var polygon2Ds = new List <Polygon2D> {
polygon0, polygon1
};
var unionResult = m_union.Union(polygon2Ds);
Assert.AreEqual(35.57237, unionResult.Area, MathUtil.EPS * 100);
}
// Not finished - still has some artifacts
static public List <Vector2D> PreparePolygon(Polygon2D polygon)
{
Polygon2D newPolygon = new Polygon2D();
polygon.Normalize();
foreach (DoublePair2D pair in DoublePair2D.GetList(polygon.pointsList))
{
float rotA = Vector2D.Atan2(pair.B, pair.A);
float rotC = Vector2D.Atan2(pair.B, pair.C);
Vector2D pairA = new Vector2D(pair.A);
pairA.Push(rotA - Mathf.PI / 2, precision);
Vector2D pairC = new Vector2D(pair.C);
pairC.Push(rotC + Mathf.PI / 2, precision);
Vector2D vecA = new Vector2D(pair.B);
vecA.Push(rotA - Mathf.PI / 2, precision);
vecA.Push(rotA, 10f);
Vector2D vecC = new Vector2D(pair.B);
vecC.Push(rotC + Mathf.PI / 2, precision);
vecC.Push(rotC, 10f);
Vector2D result = Math2D.GetPointLineIntersectLine(new Pair2D(pairA, vecA), new Pair2D(pairC, vecC));
if (result != null)
{
newPolygon.AddPoint(result);
// } else {
//Debug.LogError("Null");
}
}
return(newPolygon.pointsList);
}
// Clips a single polygon and returns the clipped polygon as a new instance
private Polygon2D ClipPolygon(Polygon2D polygon)
{
var vertices = polygon.GetVertices();
foreach (var line in m_clipPoly.GetLines())
{
vertices = SutherlandHodgman(vertices, line);
//We clipped all our vertices and got nothing back, meaning nothing will be displayed.
//Just return nothing
if (vertices.Count == 0)
return null;
}
vertices.ForEach(v => v.Round());
return new Polygon2D(vertices);
}
public void ChangeOutlineColor()
{
var polygon = new Polygon2D(Rectangle.One, Color.Red);
polygon.Add(new OutlineColor(Color.Blue));
Assert.AreEqual(Color.Blue, polygon.Get<OutlineColor>().Value);
}
/// <summary>
///
/// </summary>
private void BuildPolygon()
{
Point2D[] points = new Point2D[Walls.Count];
points[0] = (Walls[0] as MazeWall).points[0];
ArrayList wallsCopy = (ArrayList) Walls.Clone();
wallsCopy.RemoveAt(0);
for (int i = 1; i < points.Length; i++)
{
//find adjacent wall... the closest
foreach (MazeWall wall in wallsCopy)
{
if (Point2D.GetDistance(wall.points[0], points[i - 1]) < 0.01)
{
points[i] = wall.points[1];
wallsCopy.Remove(wall);
break;
}
else if (Point2D.GetDistance(wall.points[1], points[i - 1]) < 0.01)
{
points[i] = wall.points[0];
wallsCopy.Remove(wall);
break;
}
}
}
roomPolygon = new Polygon2D(points);
}
private void btnPolyUnion2_Click(object sender, RoutedEventArgs e)
{
try
{
ClearAllVisuals();
// Create some random triangles
Point[][] initialPolys = new Point[5][];
for (int cntr = 0; cntr < initialPolys.Length; cntr++)
{
Point[] triangle = Enumerable.Range(0, 3).
Select(o => Math3D.GetRandomVector_Circular(20d)).
Select(o => new Point(o.X, o.Y)).
ToArray();
initialPolys[cntr] = triangle;
}
// Separate into islands
Polygon2D[] finalPolys = null;
try
{
finalPolys = GetPolyUnion(initialPolys);
}
catch (Exception ex)
{
MessageBox.Show(ex.ToString(), this.Title, MessageBoxButton.OK, MessageBoxImage.Error);
finalPolys = new Polygon2D[0];
}
#region Draw
Visual3D visual;
// Lines
foreach (Point[] polygon in initialPolys)
{
visual = GetVisual_PolygonLines(polygon.Select(o => o.ToPoint3D(-2)).ToArray(), Colors.Gray, 1);
_debugVisuals.Add(visual);
_viewport.Children.Add(visual);
}
foreach (Polygon2D polygon in finalPolys)
{
visual = GetVisual_PolygonLines(polygon.Polygon.Select(o => o.ToPoint3D(2)).ToArray(), Colors.Black, 2);
_debugVisuals.Add(visual);
_viewport.Children.Add(visual);
foreach (Point[] hole in polygon.Holes)
{
visual = GetVisual_PolygonLines(hole.Select(o => o.ToPoint3D(2)).ToArray(), Colors.Red, 2);
_debugVisuals.Add(visual);
_viewport.Children.Add(visual);
}
}
// Polygons
//foreach (Point[] polygon in finalPolys) // can't do these, they are concave
foreach (Point[] polygon in initialPolys)
{
Color color = Color.FromArgb(10, Convert.ToByte(StaticRandom.Next(256)), Convert.ToByte(StaticRandom.Next(256)), Convert.ToByte(StaticRandom.Next(256)));
visual = GetVisual_Polygon_Convex(polygon.Select(o => o.ToPoint3D()).ToArray(), color);
_debugVisuals.Add(visual);
_viewport.Children.Add(visual);
}
#endregion
}
catch (Exception ex)
{
MessageBox.Show(ex.ToString(), this.Title, MessageBoxButton.OK, MessageBoxImage.Error);
}
}
// Calculate the uv points of the polygons.
public Vector2[] renderpoints(Polygon polygon)
{
polygonsinalllayers [numberOfLayers] = maxPolygons;
value = (polygonsinalllayers [1] - polygonsinalllayers [0])/4;
Polygon2D b = new Polygon2D ();
b.vertices.Add (new Vector2 (0, 0));
b.vertices.Add (new Vector2 (0, 1));
b.vertices.Add (new Vector2 (1, 1));
b.vertices.Add (new Vector2 (1, 0));
b.vertices.Add (new Vector2 (0, 0));
if ((done && checkvalue<=value) || (checkvalue>(2*value) && checkvalue<=(3*value))) {
Polygon2D b1 = new Polygon2D ();
b1 = rotate90points (b);
b = b1;
}
if (checkvalue >value && checkvalue <=(2*value)) {
Polygon2D b2 = new Polygon2D ();
b2 = rotate180points (b);
b = b2;
}
if ((checkvalue >= 23 && checkvalue < 27) || (checkvalue >= 30 && checkvalue < 34) || (checkvalue >= 37 && checkvalue < 41)) {
Polygon2D b2 = new Polygon2D ();
b2 = rotate90points (b);
b = b2;
}
if ((checkvalue >= 41 && checkvalue < 47) || (checkvalue >=51 && checkvalue<54) || (checkvalue >=58 && checkvalue<61)) {
Polygon2D b2 = new Polygon2D ();
b2 = rotate90points (b);
b = b2;
}
if ((checkvalue >= 71 && checkvalue < 75) || (checkvalue >=78 && checkvalue<82) || (checkvalue >=85 && checkvalue<89)) {
Polygon2D b2 = new Polygon2D ();
b2 = rotate90points (b);
b = b2;
}
if ((checkvalue >= 89 && checkvalue < 95) || (checkvalue >=99 && checkvalue<102) || (checkvalue >=106 && checkvalue<109)) {
Polygon2D b2 = new Polygon2D ();
b2 = rotate90points (b);
b = b2;
}
checkvalue++;
Polygon2D c = new Polygon2D ();
c = subdivide2D (b, 10);
Polygon2D d = new Polygon2D ();
for(int i=0;i<c.vertices.Count-1;i++)
{
d.vertices.Add (c.vertices [i]);
d.vertices.Add (c.vertices [i+1]);
d.vertices.Add (new Vector2 (0.5f, 0.5f));
}
Vector2[] final = new Vector2[d.vertices.Count];
for (int i = 0; i < final.Length; i++) {
final [i] = d.vertices [i];
}
done = true;
return final;
}
// Rotates the polygon by 180 degrees.
public Polygon2D rotate180points(Polygon2D polygon)
{
Polygon2D rotated180 = new Polygon2D ();
Polygon2D rotated90 = new Polygon2D ();
rotated90 = rotate90points (polygon);
rotated180 = rotate90points (rotated90);
return rotated180;
}
public void ReduceComplexity(string points, string reduced)
{
var testPoints = from x in points.Split(';') select Point2D.Parse(x);
var expectedPoints = from x in reduced.Split(';') select Point2D.Parse(x);
var poly = new Polygon2D(testPoints);
var expected = new Polygon2D(expectedPoints);
var thinned = poly.ReduceComplexity(0.00001);
CollectionAssert.AreEqual(expected, thinned);
}
// This determines the order in which uvs are rendered...
// This has to be modified if some other type of triply periodic polyhedron
// is selected....This can be automatically setup by some GUI mechansim
// which can be added....
public Vector2[] GraphicsOrder()
{
Vector2[] final= new Vector2[5];
final [0] = new Vector2 (1, 1);
final [1] = new Vector2 (1, 0);
final [2] = new Vector2 (0, 0);
final [3] = new Vector2 (0, 1);
final [4] = new Vector2 (1, 1);
Polygon2D c = new Polygon2D ();
for(int i=0;i<final.Length-1;i++)
{
c.vertices.Add (final[i]);
c.vertices.Add (final[i+1]);
c.vertices.Add (new Vector2 (0.5f, 0.5f));
}
Vector2[] finaluvs = new Vector2[vertices.Length];
for (int i = 0; i < finaluvs.Length; i++) {
finaluvs [i] = c.vertices [i];
}
return finaluvs;
}
private void btnPolyUnionTest3b_Click(object sender, RoutedEventArgs e)
{
try
{
ClearAllVisuals();
// Create some random triangles
Point[][] initialPolys = new Point[3][];
initialPolys[0] = new Point[] {
new Point(-8.00822498773053,15.724908636816),
new Point(-10.9888146681928,9.99396633672174),
new Point(-1.35614945481762,1.2745135259889) };
initialPolys[1] = new Point[] {
new Point(17.6394906227247,-1.78969639822036),
new Point(-0.944559908696264,8.15715451007008),
new Point(-16.1622843293672,0.442278789958519) }.Reverse().ToArray();
initialPolys[2] = new Point[] {
new Point(-13.3366344395237,10.1599123251435),
new Point(4.03979352867374,6.13141576520923),
new Point(16.079651596552,9.28399147918985) };
// Separate into islands
Polygon2D[] finalPolys = null;
try
{
finalPolys = GetPolyUnion(initialPolys);
}
catch (Exception ex)
{
//MessageBox.Show(ex.ToString(), this.Title, MessageBoxButton.OK, MessageBoxImage.Error);
finalPolys = new Polygon2D[0];
}
#region Draw
Visual3D visual;
// Lines
foreach (Point[] polygon in initialPolys)
{
visual = GetVisual_PolygonLines(polygon.Select(o => o.ToPoint3D(-2)).ToArray(), Colors.Gray, 1);
_debugVisuals.Add(visual);
_viewport.Children.Add(visual);
}
foreach (Polygon2D polygon in finalPolys)
{
visual = GetVisual_PolygonLines(polygon.Polygon.Select(o => o.ToPoint3D(2)).ToArray(), Colors.Black, 2);
_debugVisuals.Add(visual);
_viewport.Children.Add(visual);
foreach (Point[] hole in polygon.Holes)
{
visual = GetVisual_PolygonLines(hole.Select(o => o.ToPoint3D(2)).ToArray(), Colors.Red, 2);
_debugVisuals.Add(visual);
_viewport.Children.Add(visual);
}
}
// Polygons
//foreach (Point[] polygon in finalPolys) // can't do these, they are concave
//foreach (Point[] polygon in initialPolys)
for (int cntr = 0; cntr < initialPolys.Length; cntr++)
{
Color color = UtilityWPF.GetColorEGA(10, cntr);
//Color color = Color.FromArgb(10, Convert.ToByte(StaticRandom.Next(256)), Convert.ToByte(StaticRandom.Next(256)), Convert.ToByte(StaticRandom.Next(256)));
visual = GetVisual_Polygon_Convex(initialPolys[cntr].Select(o => o.ToPoint3D()).ToArray(), color);
_debugVisuals.Add(visual);
_viewport.Children.Add(visual);
}
#endregion
}
catch (Exception ex)
{
MessageBox.Show(ex.ToString(), this.Title, MessageBoxButton.OK, MessageBoxImage.Error);
}
}
private void btnChainTest8b_Click(object sender, RoutedEventArgs e)
{
try
{
ClearAllVisuals();
List<Tuple<Point, Point>> segments1 = new List<Tuple<Point, Point>>();
segments1.Add(Tuple.Create(new Point(0, -5), new Point(4, -1)));
segments1.Add(Tuple.Create(new Point(4, -1), new Point(5, 0)));
segments1.Add(Tuple.Create(new Point(5, 0), new Point(4, 1)));
segments1.Add(Tuple.Create(new Point(4, 1), new Point(3, 0)));
segments1.Add(Tuple.Create(new Point(3, 0), new Point(4, -1)));
segments1.Add(Tuple.Create(new Point(4, -1), new Point(4, 1)));
segments1.Add(Tuple.Create(new Point(4, 1), new Point(0, 5)));
segments1.Add(Tuple.Create(new Point(0, 5), new Point(-3, 2)));
segments1.Add(Tuple.Create(new Point(-3, 2), new Point(-2, 1)));
segments1.Add(Tuple.Create(new Point(-2, 1), new Point(-1, 0)));
segments1.Add(Tuple.Create(new Point(-1, 0), new Point(-2, -1)));
segments1.Add(Tuple.Create(new Point(-2, -1), new Point(-3, -2)));
segments1.Add(Tuple.Create(new Point(-3, -2), new Point(-4, -1)));
segments1.Add(Tuple.Create(new Point(-4, -1), new Point(-5, 0)));
segments1.Add(Tuple.Create(new Point(-5, 0), new Point(-4, 1)));
segments1.Add(Tuple.Create(new Point(-4, 1), new Point(-3, 2)));
segments1.Add(Tuple.Create(new Point(-3, 2), new Point(-3, 0)));
segments1.Add(Tuple.Create(new Point(-3, 0), new Point(-3, -2)));
segments1.Add(Tuple.Create(new Point(-2, 1), new Point(-2, -1)));
segments1.Add(Tuple.Create(new Point(-4, 1), new Point(-4, -1)));
segments1.Add(Tuple.Create(new Point(-2, 1), new Point(-3, 0)));
segments1.Add(Tuple.Create(new Point(-2, -1), new Point(-3, 0)));
segments1.Add(Tuple.Create(new Point(-4, 1), new Point(-3, 0)));
segments1.Add(Tuple.Create(new Point(-4, -1), new Point(-3, 0)));
segments1.Add(Tuple.Create(new Point(-3, -2), new Point(0, -5)));
//var segments = segments1;
var segments = UtilityCore.RandomRange(0, segments1.Count).Select(o => segments1[o]).ToList();
Polygon2D[] final = null;
try
{
final = PolyUnion2.StitchSegments2.Stitch(segments.ToArray());
}
catch (Exception)
{
final = new Polygon2D[0];
}
#region Draw
Visual3D visual;
// Initial
for (int cntr = 0; cntr < segments.Count; cntr++)
{
double z = -2 - (cntr * .1);
visual = GetVisual_Line(segments[cntr].Item1.ToPoint3D(z), segments[cntr].Item2.ToPoint3D(z), Colors.Gray, 1);
_debugVisuals.Add(visual);
_viewport.Children.Add(visual);
}
// Final
foreach (Polygon2D polygon in final)
{
visual = GetVisual_PolygonLines(polygon.Polygon.Select(o => o.ToPoint3D(0)).ToArray(), Colors.Black, 2);
_debugVisuals.Add(visual);
_viewport.Children.Add(visual);
foreach (Point[] hole in polygon.Holes)
{
visual = GetVisual_PolygonLines(hole.Select(o => o.ToPoint3D(0)).ToArray(), Colors.Red, 2);
_debugVisuals.Add(visual);
_viewport.Children.Add(visual);
}
}
#endregion
}
catch (Exception ex)
{
MessageBox.Show(ex.ToString(), this.Title, MessageBoxButton.OK, MessageBoxImage.Error);
}
}
private void btnPolyUnionTest5_Click(object sender, RoutedEventArgs e)
{
try
{
ClearAllVisuals();
// Create some random triangles
Point[][] initialPolys = new Point[4][];
initialPolys[0] = new Point[] {
new Point(7.63258002821866,-1.71657720938275),
new Point(7.76145635305171,-1.67761318154907),
new Point(9.43425936393152,-1.17186363320799),
new Point(10.5549080800541,-1.71657720938275) };
initialPolys[1] = new Point[] {
new Point(10.3058611604882,-1.59552300547356),
new Point(10.3269392559373,-1.71657720938275),
new Point(9.54274292483309,-1.71657720938275),
new Point(8.87261465785801,-0.898865063733471) };
initialPolys[2] = new Point[] {
new Point(9.43425936393151,-1.17186363320798),
new Point(7.7614563530517,-1.67761318154907),
new Point(7.63258002821865,-1.71657720938275),
new Point(7.00040640990406,-1.71657720938275),
new Point(6.87244607297693,0.029306274277618),
new Point(6.96135493605682,0.0301407014836736) };
initialPolys[3] = new Point[] {
new Point(6.87244607297693,0.0293062742776171),
new Point(6.96135493605682,0.0301407014836719),
new Point(6.86909824100712,0.0749839012871441) };
var intersections = new Tuple<Point, Point, Point, Point, Point>[] {
Tuple.Create(new Point(9.16344177297135,-1.2537416985989), new Point(7.76145635305171,-1.67761318154907), new Point(9.43425936393152,-1.17186363320799), new Point(9.54274292483309,-1.71657720938275), new Point(8.87261465785801,-0.898865063733471)),
Tuple.Create(new Point(10.3058611604882,-1.59552300547359), new Point(9.43425936393152,-1.17186363320799), new Point(10.5549080800541,-1.71657720938275), new Point(10.3058611604882,-1.59552300547356), new Point(10.3269392559373,-1.71657720938275)),
Tuple.Create(new Point(10.3269392559373,-1.71657720938275), new Point(10.5549080800541,-1.71657720938275), new Point(7.63258002821866,-1.71657720938275), new Point(10.3058611604882,-1.59552300547356), new Point(10.3269392559373,-1.71657720938275)),
Tuple.Create(new Point(9.54274292483309,-1.71657720938275), new Point(10.5549080800541,-1.71657720938275), new Point(7.63258002821866,-1.71657720938275), new Point(9.54274292483309,-1.71657720938275), new Point(8.87261465785801,-0.898865063733471)),
Tuple.Create(new Point(9.16344177297134,-1.25374169859889), new Point(9.54274292483309,-1.71657720938275), new Point(8.87261465785801,-0.898865063733471), new Point(9.43425936393151,-1.17186363320798), new Point(7.7614563530517,-1.67761318154907)),
Tuple.Create(new Point(8.87261465785801,-0.898865063733473), new Point(9.54274292483309,-1.71657720938275), new Point(8.87261465785801,-0.898865063733471), new Point(6.96135493605682,0.0301407014836736), new Point(9.43425936393151,-1.17186363320798)),
Tuple.Create(new Point(6.87244607297693,0.0293062742776171), new Point(7.00040640990406,-1.71657720938275), new Point(6.87244607297693,0.029306274277618), new Point(6.87244607297693,0.0293062742776171), new Point(6.96135493605682,0.0301407014836719)),
Tuple.Create(new Point(6.96135493605682,0.0301407014836736), new Point(6.87244607297693,0.029306274277618), new Point(6.96135493605682,0.0301407014836736), new Point(6.96135493605682,0.0301407014836719), new Point(6.86909824100712,0.0749839012871441)) }.
Select(o => new { Intersect = o.Item1, Segment1 = Tuple.Create(o.Item2, o.Item3), Segment2 = Tuple.Create(o.Item4, o.Item5) }).ToArray();
// Separate into islands
Polygon2D[] finalPolys = null;
try
{
finalPolys = GetPolyUnion(initialPolys);
}
catch (Exception ex)
{
//MessageBox.Show(ex.ToString(), this.Title, MessageBoxButton.OK, MessageBoxImage.Error);
finalPolys = new Polygon2D[0];
}
#region Draw
Visual3D visual;
// Lines
for (int cntr = 0; cntr < initialPolys.Length; cntr++)
{
double z = -2 - (cntr * .1);
visual = GetVisual_PolygonLines(initialPolys[cntr].Select(o => o.ToPoint3D(z)).ToArray(), Colors.Gray, 1);
_debugVisuals.Add(visual);
_viewport.Children.Add(visual);
foreach (Point point in initialPolys[cntr])
{
visual = GetVisual_Dot(point.ToPoint3D(z), .01d, Colors.Gray);
_debugVisuals.Add(visual);
_viewport.Children.Add(visual);
}
}
for (int cntr = 0; cntr < intersections.Length; cntr++)
{
double z = cntr * .1d;
visual = GetVisual_Dot(intersections[cntr].Intersect.ToPoint3D(z), .01d, Colors.Gray);
_debugVisuals.Add(visual);
_viewport.Children.Add(visual);
visual = GetVisual_Line(intersections[cntr].Segment1.Item1.ToPoint3D(z), intersections[cntr].Segment1.Item2.ToPoint3D(z), Colors.Gray, 2d);
_debugVisuals.Add(visual);
_viewport.Children.Add(visual);
visual = GetVisual_Line(intersections[cntr].Segment2.Item1.ToPoint3D(z), intersections[cntr].Segment2.Item2.ToPoint3D(z), Colors.Gray, 2d);
_debugVisuals.Add(visual);
_viewport.Children.Add(visual);
}
foreach (Polygon2D polygon in finalPolys)
{
visual = GetVisual_PolygonLines(polygon.Polygon.Select(o => o.ToPoint3D(2)).ToArray(), Colors.Black, 2);
_debugVisuals.Add(visual);
_viewport.Children.Add(visual);
foreach (Point[] hole in polygon.Holes)
{
visual = GetVisual_PolygonLines(hole.Select(o => o.ToPoint3D(2)).ToArray(), Colors.Red, 2);
_debugVisuals.Add(visual);
_viewport.Children.Add(visual);
}
}
// Polygons
//foreach (Point[] polygon in finalPolys) // can't do these, they are concave
//foreach (Point[] polygon in initialPolys)
for (int cntr = 0; cntr < initialPolys.Length; cntr++)
{
Color color = UtilityWPF.GetColorEGA(10, cntr);
//Color color = Color.FromArgb(10, Convert.ToByte(StaticRandom.Next(256)), Convert.ToByte(StaticRandom.Next(256)), Convert.ToByte(StaticRandom.Next(256)));
visual = GetVisual_Polygon_Convex(initialPolys[cntr].Select(o => o.ToPoint3D(-2 - (cntr * .1))).ToArray(), color);
_debugVisuals.Add(visual);
_viewport.Children.Add(visual);
}
#endregion
}
catch (Exception ex)
{
MessageBox.Show(ex.ToString(), this.Title, MessageBoxButton.OK, MessageBoxImage.Error);
}
}
private void btnPolyUnionTest4_Click(object sender, RoutedEventArgs e)
{
// The main problem is that lines are slicing through the entire polygon. Need to detect that, also get rid of colinear points
try
{
ClearAllVisuals();
Point3D[][] initial3D = new Point3D[3][];
initial3D[0] = new Point3D[] {
new Point3D(-16.1947246550931,-0.9149519332283,2.55976103387392),
new Point3D(-17.1107881600685,0.515445435128346,3.40133335668073),
new Point3D(-17.3596515210729,-0.829632679480615,4.42103762371103),
new Point3D(-17.3450427909807,-2.19357445878095,5.01957844043668),
new Point3D(-17.3283385073944,-2.17500700982897,4.98385833288751) };
initial3D[1] = new Point3D[] {
new Point3D(-16.1947246550931,-0.914951933228302,2.55976103387392),
new Point3D(-17.3283385073944,-2.17500700982897,4.9838583328875),
new Point3D(-17.3450427909807,-2.19357445878095,5.01957844043668),
new Point3D(-17.341448388578,-2.52916527179157,5.16684630945675),
new Point3D(-15.3066235822732,-2.3016870563904,1.74387733292857) };
initial3D[2] = new Point3D[] {
new Point3D(-17.3204018787836,-4.49416933689273,6.02915227870288),
new Point3D(-16.4203453178512,-4.5492595275131,4.58613381891047),
new Point3D(-14.928909934653,-2.89147215820253,1.39687808008519),
new Point3D(-15.3066235822732,-2.3016870563904,1.74387733292857),
new Point3D(-17.341448388578,-2.52916527179157,5.16684630945675) };
// Create some random triangles
Point[][] initialPolys = new Point[3][];
initialPolys[0] = new Point[] {
new Point(-1.70753174254516,-10.6978382660948),
new Point(-0.726945738693094,-12.3201526746214),
new Point(-2.36588629353582,-12.7943243278674),
new Point(-3.85545055921974,-12.7943243278674),
new Point(-3.82425967044327,-12.7638803171038) };
initialPolys[1] = new Point[] {
new Point(-1.70753174254517,-10.6978382660948),
new Point(-3.82425967044327,-12.7638803171038),
new Point(-3.85545055921974,-12.7943243278674),
new Point(-4.22195013459667,-12.7943243278674),
new Point(-2.65818579358351,-9.1250442852861) };
initialPolys[2] = new Point[] {
new Point(-6.36793604229414,-12.7943243278674),
new Point(-5.84736974693176,-11.1743089731826),
new Point(-3.06250352298613,-8.45612745855601),
new Point(-2.65818579358351,-9.1250442852861),
new Point(-4.22195013459667,-12.7943243278674) };
var feedsIntermediate = new Tuple<double, double, double, double>[]
{
Tuple.Create(-1.70753174254516, -10.6978382660948, -0.726945738693094, -12.3201526746214), //0
Tuple.Create(-0.726945738693094, -12.3201526746214, -2.36588629353582, -12.7943243278674), //1
Tuple.Create(-2.36588629353582, -12.7943243278674, -3.85545055921974, -12.7943243278674), //2
Tuple.Create(-3.85545055921974, -12.7943243278674, -3.82425967044327, -12.7638803171038), //3
Tuple.Create(-3.82425967044327, -12.7638803171038, -1.70753174254516, -10.6978382660948), //4
Tuple.Create(-1.70753174254517, -10.6978382660948, -3.82425967044327, -12.7638803171038), //5
Tuple.Create(-3.82425967044327, -12.7638803171038, -3.85545055921974, -12.7943243278674), //6
Tuple.Create(-3.85545055921974, -12.7943243278674, -4.22195013459667, -12.7943243278674), //7
Tuple.Create(-4.22195013459667, -12.7943243278674, -2.65818579358351, -9.1250442852861), //8
Tuple.Create(-2.65818579358351, -9.1250442852861, -1.70753174254517, -10.6978382660948), //9
Tuple.Create(-6.36793604229414, -12.7943243278674, -5.84736974693176, -11.1743089731826), //10
Tuple.Create(-5.84736974693176, -11.1743089731826, -3.06250352298613, -8.45612745855601), //11
Tuple.Create(-3.06250352298613, -8.45612745855601, -2.65818579358351, -9.1250442852861), //12
Tuple.Create(-2.65818579358351, -9.1250442852861, -4.22195013459667, -12.7943243278674), //13
Tuple.Create(-4.22195013459667, -12.7943243278674, -6.36793604229414, -12.7943243278674) //14
}.Select(o => Tuple.Create(new Point(o.Item1, o.Item2), new Point(o.Item3, o.Item4))).ToArray();
#region feeds intermediate dupes
// Simplify duplication chains:
// Any point should only have one other match in the list
// If there is more than one match, the list should be able to be simplified
List<Point> uniquePoints = new List<Point>();
foreach (Point point in UtilityCore.Iterate(feedsIntermediate.Select(o => o.Item1), feedsIntermediate.Select(o => o.Item2)))
{
if (!uniquePoints.Any(o => Math2D.IsNearValue(point, o)))
{
uniquePoints.Add(point);
}
}
var matchAttempt = uniquePoints
.Select(o => new { Point = o, Matches = feedsIntermediate.Where(p => Math2D.IsNearValue(o, p.Item1) || Math2D.IsNearValue(o, p.Item2)).ToArray() }).
OrderByDescending(o => o.Matches.Length).
ToArray();
Tuple<Point, Point>[] feeds2 = feedsIntermediate.Select(o => o.Item1.X < o.Item2.X ? o : Tuple.Create(o.Item2, o.Item1)).ToArray();
List<Tuple<Point, Point>> feeds3 = new List<Tuple<Point, Point>>();
foreach (var feed in feeds2)
{
if (!feeds3.Any(o => Math2D.IsNearValue(feed.Item1, o.Item1) && Math2D.IsNearValue(feed.Item2, o.Item2)))
{
feeds3.Add(feed);
}
}
var matchAttempt2 = uniquePoints
.Select(o => new { Point = o, Matches = feeds3.Where(p => Math2D.IsNearValue(o, p.Item1) || Math2D.IsNearValue(o, p.Item2)).ToArray() }).
OrderByDescending(o => o.Matches.Length).
ToArray();
#endregion
// This is what StitchSegments generates (should have just come up with one poly)
Point[][] intermediate = new Point[1][];
intermediate[0] = new Point[] {
new Point(-1.70753174254516,-10.6978382660948), //0
new Point(-0.726945738693094,-12.3201526746214), //1
new Point(-2.36588629353582,-12.7943243278674), //2
new Point(-3.85545055921974,-12.7943243278674), //3
new Point(-3.82425967044327,-12.7638803171038), //4
new Point(-1.70753174254517,-10.6978382660948), //5
new Point(-3.82425967044327,-12.7638803171038), //6
new Point(-3.85545055921974,-12.7943243278674), //7
new Point(-4.22195013459667,-12.7943243278674), //8
new Point(-2.65818579358351,-9.1250442852861) }; //9
//intermediate[1] = new Point[] {
// new Point(-6.36793604229414,-12.7943243278674),
// new Point(-5.84736974693176,-11.1743089731826),
// new Point(-3.06250352298613,-8.45612745855601),
// new Point(-2.65818579358351,-9.1250442852861),
// new Point(-4.22195013459667,-12.7943243278674) };
#region intermediate distances
List<Tuple<int, int, double, bool>> distances = new List<Tuple<int, int, double, bool>>();
for (int outer = 0; outer < intermediate[0].Length - 1; outer++)
{
for (int inner = outer + 1; inner < intermediate[0].Length; inner++)
{
double distance = (intermediate[0][outer] - intermediate[0][inner]).Length;
distances.Add(Tuple.Create(outer, inner, distance, Math1D.IsNearZero(distance)));
}
}
distances = distances.OrderBy(o => o.Item3).ToList();
#endregion
// Separate into islands
Polygon2D[] finalPolys = null;
try
{
finalPolys = GetPolyUnion(initialPolys);
}
catch (Exception ex)
{
//MessageBox.Show(ex.ToString(), this.Title, MessageBoxButton.OK, MessageBoxImage.Error);
finalPolys = new Polygon2D[0];
}
#region Draw
Visual3D visual;
// Lines
foreach (Point[] polygon in initialPolys)
{
visual = GetVisual_PolygonLines(polygon.Select(o => o.ToPoint3D(-2)).ToArray(), Colors.Gray, 1);
_debugVisuals.Add(visual);
_viewport.Children.Add(visual);
}
foreach (Point[] polygon in intermediate)
{
visual = GetVisual_PolygonLines(polygon.Select(o => o.ToPoint3D(0)).ToArray(), Colors.Gray, 2);
_debugVisuals.Add(visual);
_viewport.Children.Add(visual);
}
for (int cntr = 0; cntr < intermediate[0].Length; cntr++)
{
visual = GetVisual_Dot(intermediate[0][cntr].ToPoint3D(2), .02 + (cntr * .01), UtilityWPF.GetColorEGA(64, cntr));
_debugVisuals.Add(visual);
_viewport.Children.Add(visual);
}
//foreach (Point3D[] poly in initial3D)
//{
// visual = GetPolygonLinesVisual(poly, Colors.Black, 1);
// _debugVisuals.Add(visual);
// _viewport.Children.Add(visual);
//}
foreach (Polygon2D polygon in finalPolys)
{
visual = GetVisual_PolygonLines(polygon.Polygon.Select(o => o.ToPoint3D(2)).ToArray(), Colors.Black, 2);
_debugVisuals.Add(visual);
_viewport.Children.Add(visual);
foreach (Point[] hole in polygon.Holes)
{
visual = GetVisual_PolygonLines(hole.Select(o => o.ToPoint3D(2)).ToArray(), Colors.Red, 2);
_debugVisuals.Add(visual);
_viewport.Children.Add(visual);
}
}
// Polygons
//foreach (Point[] polygon in finalPolys) // can't do these, they are concave
//foreach (Point[] polygon in initialPolys)
for (int cntr = 0; cntr < initialPolys.Length; cntr++)
{
Color color = UtilityWPF.GetColorEGA(10, cntr);
//Color color = Color.FromArgb(10, Convert.ToByte(StaticRandom.Next(256)), Convert.ToByte(StaticRandom.Next(256)), Convert.ToByte(StaticRandom.Next(256)));
visual = GetVisual_Polygon_Convex(initialPolys[cntr].Select(o => o.ToPoint3D()).ToArray(), color);
_debugVisuals.Add(visual);
_viewport.Children.Add(visual);
}
#endregion
}
catch (Exception ex)
{
MessageBox.Show(ex.ToString(), this.Title, MessageBoxButton.OK, MessageBoxImage.Error);
}
}
// This block creates the gameobject based on the points obtained by constructcenterpolygon function
// and adds a material to it.
public void RenderSquare(Material mat)
{
tile=new GameObject("1000");
Mesh msh = new Mesh();
tile.AddComponent<MeshFilter> ();
// if else block to render random color if not in modelling mode or render angels and demons pattern
// if in the modelling_mode.
if (twodhyperbolic.modelling_mode)
{
tile.AddComponent<MeshRenderer> ().material = mat;
}
else
{
Color newcolor = new Color (Random.Range(0f,1f), Random.Range(0f,1f), Random.Range(0f,1f));
tile.AddComponent<MeshRenderer> ().material.color = newcolor;
}
tile.AddComponent<MeshCollider> ();
tile.tag="Player";
// generate names for each polygon of the triply periodic polygon starting from 1000.
int name = 1000 + number;
tile.name = name.ToString ();
a = ConstructCenterPolygon (4, 6);
Vector3 center = CenterofPolygon (a);
print ("center " + center);
Polygon b = new Polygon ();
// setting up the vertices
for (int i=0; i<a.vertices.Count-1; i++)
{
print ("i " + i);
b.vertices.Add(ptok(a.vertices[i]));
b.vertices.Add(ptok(a.vertices[i+1]));
b.vertices.Add (ptok(center));
}
print ("final point" + b.vertices [b.vertices.Count-1]);
vertices = new Vector3[b.vertices.Count];
for (int i = 0; i < vertices.Length; i++) {
vertices [i] = b.vertices [i];
print ("b.verties" + b.vertices [i].x);
}
msh.vertices = vertices;
// setting up the traingles
int[] triangles = new int[b.vertices.Count];
for (int i = 0; i < vertices.Length; i++) {
triangles [i] = i;
print ("tri[i]" + triangles [i]);
}
msh.triangles = triangles;
tile.GetComponent<MeshCollider> ().sharedMesh = msh;
// setting up the uvs.
Vector2[] uv = new Vector2[5];
uv [0] = new Vector2 (0, 1);
uv [1] = new Vector2 (1, 1);
uv [2] = new Vector2 (1, 0);
uv [3] = new Vector2 (0, 0);
uv [4] = new Vector2 (0, 1);
Polygon2D c = new Polygon2D ();
for(int i=0;i<uv.Length-1;i++)
{
c.vertices.Add (uv[i]);
c.vertices.Add (uv[i+1]);
c.vertices.Add (new Vector2 (0.5f, 0.5f));
}
Vector2[] finaluvs = new Vector2[vertices.Length];
for (int i = 0; i < finaluvs.Length; i++) {
finaluvs [i] = c.vertices [i];
}
if (twodhyperbolic.modelling_mode)
{
msh.uv = finaluvs;
}
// setting up the normals
Vector3[] normals=new Vector3[vertices.Length];
for (int i = 0; i < normals.Length; i++) {
normals [i] = Vector3.down;
}
msh.normals = normals;
tile.GetComponent<MeshFilter>().mesh = msh;
// move the triply periodic polyhedron away from the hyperbolic tessellation.
tile.transform.position = new Vector3 (0f,0f,9f);
}
// subdivides the points of UV mapping . It takes 2D points of polygons and number of parts it should be divided into.
public Polygon2D subdivide2D(Polygon2D q,int numberofpoints)
{
Polygon2D r = new Polygon2D ();
for (int i=0; i<q.vertices.Count-1; i++)
{
Vector3 end1=q.vertices[i];
Vector3 end2=q.vertices[i+1];
float dx=end2.x-end1.x;
float dy=end2.y-end1.y;
float stepx = dx / numberofpoints;
float stepy = dy / numberofpoints;
float px = end1.x ;
float py = end1.y ;
for (int ix = 0; ix <= numberofpoints; ix++)
{
Vector2 point=new Vector2(px,py);
r.vertices.Add(point);
px = px + stepx;
py = py + stepy;
}
}
return r;
}
public Point3D[] GetPointsWithinRegion(Polygon2D polygon, bool byRatio)
{
return null;
}
// Rotates the polygon by 90 degrees.
public Polygon2D rotate90points(Polygon2D polygon)
{
Polygon2D rotated = new Polygon2D ();
for (int i = 1; i < sides + 1; i++) {
rotated.vertices.Add (polygon.vertices[i]);
}
rotated.vertices.Add (polygon.vertices[1]);
return rotated;
}
