private void RenderCollision2D <T>(Type type) where T : Collider2D
{
T[] colliders = UnityEngine.Object.FindObjectsOfType <T>();
Color color = ColliderColor(type);
AddToRenderList2D(colliders);
switch (type)
{
case Type.Boxes:
Box2D.Render(colliderList2D, color, EdgeAlpha, color, FaceAlpha, IsSet(Flags.NoDepth));
Box2D.Render(triggerList2D, triggerColor, EdgeAlpha, triggerColor, FaceAlpha, IsSet(Flags.NoDepth));
break;
case Type.Spheres:
Circle2D.Render(colliderList2D, color, EdgeAlpha, color, FaceAlpha, IsSet(Flags.NoDepth));
Circle2D.Render(triggerList2D, triggerColor, EdgeAlpha, triggerColor, FaceAlpha, IsSet(Flags.NoDepth));
break;
case Type.Meshes:
if (typeof(T) == typeof(EdgeCollider2D))
{
Edge2D.Render(colliderList2D, color, EdgeAlpha, color, FaceAlpha, IsSet(Flags.NoDepth));
Edge2D.Render(triggerList2D, triggerColor, EdgeAlpha, triggerColor, FaceAlpha, IsSet(Flags.NoDepth));
}
else
{
Mesh2D.Render(colliderList2D, color, EdgeAlpha, color, FaceAlpha, IsSet(Flags.NoDepth));
Mesh2D.Render(triggerList2D, triggerColor, EdgeAlpha, triggerColor, FaceAlpha, IsSet(Flags.NoDepth));
}
break;
}
guiColliderCount[(int)type] += colliderList2D.Count + triggerList2D.Count;
}
public override bool Equals(object obj)
{
if (!(obj is Edge2D))
{
return(false);
}
Edge2D other = (Edge2D)obj;
return(a.Equals(other.a) && b.Equals(other.b));
}
Dictionary <Edge2D, int> BuildEdgesFromMesh()
{
var mesh = filter.sharedMesh;
if (mesh == null)
{
return(null);
}
var verts = mesh.vertices;
var tris = mesh.triangles;
var edges = new Dictionary <Edge2D, int>();
for (int i = 0; i < tris.Length - 2; i += 3)
{
var faceVert1 = verts[tris[i]];
var faceVert2 = verts[tris[i + 1]];
var faceVert3 = verts[tris[i + 2]];
if (Math.Round(faceVert1.z, 3) != 0 || Math.Round(faceVert2.z, 3) != 0 || Math.Round(faceVert3.z, 3) != 0)
{
continue;
}
Edge2D[] faceEdges;
faceEdges = new Edge2D[] {
new Edge2D {
a = faceVert1, b = faceVert2
},
new Edge2D {
a = faceVert2, b = faceVert3
},
new Edge2D {
a = faceVert3, b = faceVert1
},
};
foreach (var edge in faceEdges)
{
if (edges.ContainsKey(edge))
{
edges[edge]++;
}
else
{
edges[edge] = 1;
}
}
}
return(edges);
}
private void AddEdge(Edge2D e)
{
if (e != null)
{
_edge.Add(e);
IPrimitive prim = new Tube();
(prim as Tube).StartVector = e.V1.q;
(prim as Tube).EndVector = e.V2.q;
AddPrimitive(prim);
}
}
public double LinearCut(Edge2D e)
{
double x0 = e.V1.X;
double y0 = e.V1.Y;
double x1 = e.V2.X;
double y1 = e.V2.Y;
Func <double, double> Lin = (t) =>
{
Vertex2D v = e.Verteces2LinCut(t);
return(Calc(v.X, v.Y));
};
return(Dihotomy(Lin, 0.0, 1.0, 1e-3));
}
/// <summary>
/// 通过SpriteRenderer去找所有的边，存到一个字典里
/// 如果 int = 1 则证明是边缘的边，如果 int = 2 则证明则是公用的（不是边缘）
/// </summary>
/// <returns>返回存Edge2D的字典</returns>
private static Dictionary <Edge2D, int> BuildEdgesFromSprite(SpriteRenderer spriteRenderer)
{
if (spriteRenderer == null)
{
return(null);
}
var verts = spriteRenderer.sprite.vertices;
var tris = spriteRenderer.sprite.triangles;
var edges = new Dictionary <Edge2D, int>();
for (int i = 0; i < tris.Length - 2; i += 3)
{
var faceVert1 = verts[tris[i]];
var faceVert2 = verts[tris[i + 1]];
var faceVert3 = verts[tris[i + 2]];
Edge2D[] faceEdges;
faceEdges = new Edge2D[] {
new Edge2D {
a = faceVert1, b = faceVert2
},
new Edge2D {
a = faceVert2, b = faceVert3
},
new Edge2D {
a = faceVert3, b = faceVert1
},
};
foreach (var edge in faceEdges)
{
if (edges.ContainsKey(edge))
{
edges[edge]++;
}
else
{
edges[edge] = 1;
}
}
}
return(edges);
}
private Edge2D AddEdgeIfNotExist(Vertex2D v1, Vertex2D v2)
{
Edge2D e1 = _edge.Find(item => (item.V1.ID == v1.ID) & (item.V2.ID == v2.ID));
Edge2D e2 = _edge.Find(item => (item.V1.ID == v2.ID) & (item.V2.ID == v1.ID));
if (e1 != null)
{
return(e1);
}
if (e2 != null)
{
return(e2);
}
Edge2D e = new Edge2D(v1, v2);
AddEdge(e);
return(e);
}
public void InsertPointAt(_Block block, Vector3 position)
{
//_Block block = blockObj.GetComponent<_Block>();
Edge2D edge = block.Edge;
block.Recycle();
blocks.Remove(block);
_Vertex vertex = vertexPrefab.Spawn();
vertex.transform.SetParent(transform);
vertex.transform.position = position;
vertex.Border = this;
edge.MiddlePoint = vertex.Point;
Edge2D e0 = new Edge2D(edge.Points[0], vertex.Point);
Edge2D e1 = new Edge2D(vertex.Point, edge.Points[1]);
_Block b0 = blockPrefab.Spawn();
_Block b1 = blockPrefab.Spawn();
b0.transform.SetParent(transform);
b1.transform.SetParent(transform);
b0.Border = this;
b1.Border = this;
b0.Edge = e0;
b1.Edge = e1;
blocks.Add(b0);
blocks.Add(b1);
vertexs.Add(vertex);
_lazyAllVertices.isValeChanged = true;
//Debug.Log("Border Vertices Count : " + Vertices.Count);
}
private static EdgeIntersection[] MergeIslandSprtSegmentsSprtIntersections(int polygonIndex, Edge2D edge, EdgeIntersection[] intersections)
{
List<EdgeIntersection> retVal = new List<EdgeIntersection>();
foreach (EdgeIntersection intersection in intersections)
{
if (intersection.Poly1Index == polygonIndex) // polygon match (1)
{
if (MergeIslandSprtSegmentsSprtIntersectionsSprtIsSame(edge.Index0, edge.Index1.Value, intersection.Poly1Edge.Index0, intersection.Poly1Edge.Index1.Value)) // edge match (1)
{
retVal.Add(intersection);
}
}
else if (intersection.Poly2Index == polygonIndex) // polygon match (2)
{
if (MergeIslandSprtSegmentsSprtIntersectionsSprtIsSame(edge.Index0, edge.Index1.Value, intersection.Poly2Edge.Index0, intersection.Poly2Edge.Index1.Value)) // edge match (2)
{
retVal.Add(intersection);
}
}
}
return retVal.ToArray();
}
private static Canvas DrawVoronoi_Tiled(VoronoiResult2D voronoi, SOMNode[] nodes, ISOMInput[][] images, int imageWidth, int imageHeight, int tileWidth, int tileHeight, Action <DrawTileArgs> drawTile, BlobEvents events)
{
#region transform
var aabb = Math2D.GetAABB(voronoi.EdgePoints);
TransformGroup transform = new TransformGroup();
transform.Children.Add(new TranslateTransform(-aabb.Item1.X, -aabb.Item1.Y));
transform.Children.Add(new ScaleTransform(imageWidth / (aabb.Item2.X - aabb.Item1.X), imageHeight / (aabb.Item2.Y - aabb.Item1.Y)));
#endregion
Canvas retVal = new Canvas();
for (int cntr = 0; cntr < voronoi.ControlPoints.Length; cntr++)
{
#region polygon
Polygon polygon = new Polygon();
if (voronoi.EdgesByControlPoint[cntr].Length < 3)
{
throw new ApplicationException("Expected at least three edge points");
}
Edge2D[] edges = voronoi.EdgesByControlPoint[cntr].Select(o => voronoi.Edges[o]).ToArray();
Point[] edgePoints = Edge2D.GetPolygon(edges, 1d);
edgePoints = edgePoints.
Select(o => transform.Transform(o)).
ToArray();
foreach (Point point in edgePoints)
{
polygon.Points.Add(point);
}
polygon.Fill = GetTiledSamples(edgePoints, images[cntr], nodes[cntr], tileWidth, tileHeight, drawTile);
polygon.Stroke = new SolidColorBrush(UtilityWPF.GetRandomColor(64, 192));
polygon.StrokeThickness = 2;
polygon.Tag = Tuple.Create(nodes[cntr], images[cntr]);
if (events != null)
{
if (events.MouseMove != null && events.MouseLeave != null)
{
polygon.MouseMove += Polygon2D_MouseMove;
polygon.MouseLeave += Polygon2D_MouseLeave;
}
if (events.Click != null)
{
polygon.MouseUp += Polygon_MouseUp;
}
}
retVal.Children.Add(polygon);
#endregion
}
return(retVal);
}
private static Canvas DrawVoronoi_Blobs(VoronoiResult2D voronoi, Color[] colors, SOMNode[] nodes, ISOMInput[][] inputsByNode, int imageWidth, int imageHeight, BlobEvents events)
{
const double MARGINPERCENT = 1.05;
// Analyze size ratios
double[] areas = AnalyzeVoronoiCellSizes(voronoi, inputsByNode);
#region transform
var aabb = Math2D.GetAABB(voronoi.EdgePoints);
aabb = Tuple.Create((aabb.Item1.ToVector() * MARGINPERCENT).ToPoint(), (aabb.Item2.ToVector() * MARGINPERCENT).ToPoint());
TransformGroup transform = new TransformGroup();
transform.Children.Add(new TranslateTransform(-aabb.Item1.X, -aabb.Item1.Y));
transform.Children.Add(new ScaleTransform(imageWidth / (aabb.Item2.X - aabb.Item1.X), imageHeight / (aabb.Item2.Y - aabb.Item1.Y)));
#endregion
Canvas retVal = new Canvas();
retVal.Effect = new DropShadowEffect()
{
Color = Colors.Gray,
Opacity = .2,
BlurRadius = 5,
Direction = 0,
ShadowDepth = 0,
};
for (int cntr = 0; cntr < voronoi.ControlPoints.Length; cntr++)
{
#region polygon
Polygon polygon = new Polygon();
if (voronoi.EdgesByControlPoint[cntr].Length < 3)
{
throw new ApplicationException("Expected at least three edge points");
}
Edge2D[] edges = voronoi.EdgesByControlPoint[cntr].Select(o => voronoi.Edges[o]).ToArray();
Point[] edgePoints = Edge2D.GetPolygon(edges, 1d);
// Resize to match the desired area
edgePoints = ResizeConvexPolygon(edgePoints, areas[cntr]);
// Convert into a smooth blob
BezierSegment3D[] bezier = BezierUtil.GetBezierSegments(edgePoints.Select(o => o.ToPoint3D()).ToArray(), .25, true);
edgePoints = BezierUtil.GetPath(75, bezier).
Select(o => o.ToPoint2D()).
ToArray();
// Transform to canvas coords
edgePoints = edgePoints.
Select(o => transform.Transform(o)).
ToArray();
foreach (Point point in edgePoints)
{
polygon.Points.Add(point);
}
polygon.Fill = new SolidColorBrush(colors[cntr]);
polygon.Stroke = null; // new SolidColorBrush(UtilityWPF.OppositeColor(colors[cntr], false));
polygon.StrokeThickness = 1;
polygon.Tag = Tuple.Create(events, nodes[cntr], inputsByNode[cntr]);
if (events != null)
{
if (events.MouseMove != null && events.MouseLeave != null)
{
polygon.MouseMove += Polygon2D_MouseMove;
polygon.MouseLeave += Polygon2D_MouseLeave;
}
if (events.Click != null)
{
polygon.MouseUp += Polygon_MouseUp;
}
}
retVal.Children.Add(polygon);
#endregion
}
return(retVal);
}
public bool UpdateCadTopologyGeometry(CadObject2D cad2D)
{
SutableRotMode = RotMode.RotMode2D;
IList <CadObject2DDrawPart> oldDrawParts = new List <CadObject2DDrawPart>();
for (int i = 0; i < DrawParts.Count; i++)
{
oldDrawParts.Add(new CadObject2DDrawPart(DrawParts[i]));
}
for (int idp = 0; idp < oldDrawParts.Count; idp++)
{
oldDrawParts[idp].MeshId = 0;
oldDrawParts[idp].ShowMode = 0;
}
DrawParts.Clear();
int minLayer;
int maxLayer;
cad2D.GetLayerMinMax(out minLayer, out maxLayer);
double layerHeight = 1.0 / (maxLayer - minLayer + 1);
{
// 面をセット
IList <uint> lIds = cad2D.GetElementIds(CadElementType.Loop);
for (int iLId = 0; iLId < lIds.Count; iLId++)
{
uint lId = lIds[iLId];
double height = 0;
{
int layer = cad2D.GetLayer(CadElementType.Loop, lId);
height = (layer - minLayer) * layerHeight;
}
int idp0 = 0;
for (; idp0 < oldDrawParts.Count; idp0++)
{
CadObject2DDrawPart olddp = oldDrawParts[idp0];
if (olddp.Type == CadElementType.Loop && olddp.CadId == lId)
{
olddp.MeshId = 1;
olddp.Height = height;
double[] color = cad2D.GetLoopColor(lId);
for (int iTmp = 0; iTmp < 3; iTmp++)
{
olddp.Color[iTmp] = (float)color[iTmp];
}
DrawParts.Add(oldDrawParts[idp0]);
break;
}
}
if (idp0 == oldDrawParts.Count)
{
CadObject2DDrawPart dp = new CadObject2DDrawPart();
dp.CadId = lId;
dp.Type = CadElementType.Loop;
dp.Height = height;
double[] color = cad2D.GetLoopColor(lId);
for (int iTmp = 0; iTmp < 3; iTmp++)
{
dp.Color[iTmp] = (float)color[iTmp];
}
DrawParts.Add(dp);
}
}
}
{
// set edge
IList <uint> eIds = cad2D.GetElementIds(CadElementType.Edge);
for (int iEId = 0; iEId < eIds.Count; iEId++)
{
uint eId = eIds[iEId];
double height = 0;
{
int layer = cad2D.GetLayer(CadElementType.Edge, eId);
height += (layer - minLayer + 0.01) * layerHeight;
}
int idp0 = 0;
for (; idp0 < oldDrawParts.Count; idp0++)
{
CadObject2DDrawPart olddp = oldDrawParts[idp0];
if (olddp.Type == CadElementType.Edge && olddp.CadId == eId)
{
olddp.MeshId = 1;
olddp.Height = height;
DrawParts.Add(olddp);
break;
}
}
if (idp0 == oldDrawParts.Count)
{
CadObject2DDrawPart dp = new CadObject2DDrawPart();
dp.CadId = eId;
dp.Type = CadElementType.Edge;
dp.Height = height;
DrawParts.Add(dp);
}
{
CadObject2DDrawPart dp = DrawParts[DrawParts.Count - 1];
Edge2D edge = cad2D.GetEdge(eId);
dp.CtrlPoints.Clear();
dp.CurveType = edge.CurveType;
if (edge.CurveType == CurveType.CurveArc)
{
OpenTK.Vector2d cPt;
double radius;
edge.GetCenterRadius(out cPt, out radius);
dp.CtrlPoints.Add(cPt);
}
else if (edge.CurveType == CurveType.CurveBezier)
{
IList <OpenTK.Vector2d> cos = edge.GetCurvePoint();
dp.CtrlPoints.Add(cos[0]);
dp.CtrlPoints.Add(cos[1]);
}
}
}
}
{
// set vertex
IList <uint> vIds = cad2D.GetElementIds(CadElementType.Vertex);
for (int iVId = 0; iVId < vIds.Count; iVId++)
{
uint vCadId = vIds[iVId];
int layer = cad2D.GetLayer(CadElementType.Vertex, vCadId);
double height = (layer - minLayer + 0.1) * layerHeight;
int idp0 = 0;
for (; idp0 < oldDrawParts.Count; idp0++)
{
CadObject2DDrawPart olddp = oldDrawParts[idp0];
if (olddp.Type == CadElementType.Vertex && olddp.CadId == vCadId)
{
olddp.MeshId = 1;
olddp.Height = height;
DrawParts.Add(olddp);
break;
}
}
if (idp0 == oldDrawParts.Count)
{
CadObject2DDrawPart dp = new CadObject2DDrawPart();
dp.CadId = vCadId;
dp.Type = CadElementType.Vertex;
dp.Height = height;
DrawParts.Add(dp);
}
}
}
oldDrawParts.Clear();
UpdateCadGeometry(cad2D);
return(true);
}
public void UpdateCadGeometry(CadObject2D cad2D)
{
Mesher2D mesh = new Mesher2D(cad2D);
for (int idp = 0; idp < DrawParts.Count; idp++)
{
CadObject2DDrawPart dp = DrawParts[idp];
dp.Clear();
uint cadId = dp.CadId;
CadElementType cadType = dp.Type;
if (!cad2D.IsElementId(cadType, cadId))
{
continue;
}
uint meshId = mesh.GetIdFromCadId(cadId, cadType);
if (meshId == 0)
{
continue;
}
MeshType meshType;
uint elemCnt;
int loc;
uint cadId0;
mesh.GetMeshInfo(meshId, out elemCnt, out meshType, out loc, out cadId0);
System.Diagnostics.Debug.Assert(cadId0 == cadId);
if (meshType == MeshType.Tri)
{
dp.SetTriArray(mesh.GetTriArrays()[loc]);
double[] color = cad2D.GetLoopColor(cadId0);
for (int iTmp = 0; iTmp < 3; iTmp++)
{
dp.Color[iTmp] = (float)color[iTmp];
}
}
else if (meshType == MeshType.Bar)
{
dp.SetBarArray(mesh.GetBarArrays()[loc]);
System.Diagnostics.Debug.Assert(cadType == CadElementType.Edge);
Edge2D edge = cad2D.GetEdge(cadId);
dp.CurveType = edge.CurveType;
dp.CtrlPoints.Clear();
// 2019-03-11 エッジの色 FIX
double[] color = edge.Color;
for (int iTmp = 0; iTmp < 3; iTmp++)
{
dp.Color[iTmp] = (float)color[iTmp];
}
if (edge.CurveType == CurveType.CurveArc)
{
OpenTK.Vector2d cPt;
double radius;
edge.GetCenterRadius(out cPt, out radius);
dp.CtrlPoints.Add(cPt);
}
else if (edge.CurveType == CurveType.CurveBezier)
{
IList <OpenTK.Vector2d> cos = edge.GetCurvePoint();
dp.CtrlPoints.Add(cos[0]);
dp.CtrlPoints.Add(cos[1]);
}
}
else if (meshType == MeshType.Vertex)
{
dp.SetVertex(mesh.GetVertexs()[loc]);
}
}
{
// 座標をセット
IList <OpenTK.Vector2d> vec2Ds = mesh.GetVectors();
uint ptCnt = (uint)vec2Ds.Count;
uint ndim = 2;
VertexArray.SetSize(ptCnt, ndim);
for (int iPt = 0; iPt < ptCnt; iPt++)
{
VertexArray.VertexCoordArray[iPt * ndim] = vec2Ds[iPt].X;
VertexArray.VertexCoordArray[iPt * ndim + 1] = vec2Ds[iPt].Y;
}
if (VertexArray.UVCoordArray != null)
{
for (int iPt = 0; iPt < ptCnt; iPt++)
{
VertexArray.UVCoordArray[iPt * ndim] = vec2Ds[iPt].X * TexScale;
VertexArray.UVCoordArray[iPt * ndim + 1] = vec2Ds[iPt].Y * TexScale;
}
}
}
}
public PolygonOverlay(Edge2D[] polygonEdges, Point[] polygonPoints, Tuple<int, int, double>[] pixels)
{
this.PolygonEdges = polygonEdges;
this.PolygonPoints = polygonPoints;
this.Pixels = pixels;
}
public EdgeIntersection(int poly1Index, Edge2D poly1Edge, int poly2Index, Edge2D poly2Edge, Point intersectionPoint)
{
this.Poly1Index = poly1Index;
this.Poly1Edge = poly1Edge;
this.Poly2Index = poly2Index;
this.Poly2Edge = poly2Edge;
this.IntersectionPoint = intersectionPoint;
}
public bool SmoothingPolylineEdge(uint eId, uint nIter, OpenTK.Vector2d pos, double radius)
{
if (!this.IsElementId(CadElementType.Edge, eId))
{
return(false);
}
if (GetEdgeCurveType(eId) != CurveType.CurvePolyline)
{
return(true);
}
if (nIter == 0)
{
return(true);
}
Edge2D edge = GetEdge(eId);
IList <double> axys = edge.GetCurveRelPoint();
System.Diagnostics.Debug.Assert(axys.Count % 2 == 0);
uint nno = (uint)axys.Count / 2;
IList <uint> aIndNo = new List <uint>();
if (radius > 0)
{
uint[] tmp = new uint[nno];
for (int i = 0; i < nno; i++)
{
if (i < aIndNo.Count)
{
tmp[i] = aIndNo[i];
}
else
{
tmp[i] = 0;
}
}
aIndNo.Clear();
aIndNo = tmp.ToList();
OpenTK.Vector2d sPt = edge.GetVertex(true);
OpenTK.Vector2d ePt = edge.GetVertex(false);
var v0 = ePt - sPt;
OpenTK.Vector2d v1 = new OpenTK.Vector2d(-v0.Y, v0.X);
for (int ino = 0; ino < nno; ino++)
{
var p = sPt + v0 * axys[ino * 2 + 0] + v1 * axys[ino * 2 + 1];
if (CadUtils.SquareLength(p - pos) < radius * radius)
{
aIndNo.Add((uint)ino);
}
}
}
else
{
aIndNo = new List <uint>();
for (int ino = 0; ino < nno; ino++)
{
aIndNo[ino] = (uint)ino;
}
}
// strength of smoothing(0から1)
double w = 0.8;
for (uint iiter = 0; iiter < nIter; iiter++)
{
for (int iIndNo = 0; iIndNo < aIndNo.Count; iIndNo++)
{
int ino = (int)aIndNo[iIndNo];
double[] po0 = new double[2];
double[] po1 = new double[2];
double[] po2 = new double[2];
if (ino == 0)
{
po0[0] = 0;
po0[1] = 0;
}
else
{
po0[0] = axys[ino * 2 - 2];
po0[1] = axys[ino * 2 - 1];
}
po1[0] = axys[ino * 2 + 0];
po1[1] = axys[ino * 2 + 1];
if (ino == nno - 1)
{
po2[0] = 1; po2[1] = 0;
}
else
{
po2[0] = axys[ino * 2 + 2];
po2[1] = axys[ino * 2 + 3];
}
////////////////
double[] mPt = { (po0[0] + po2[0]) * 0.5, (po0[1] + po2[1]) * 0.5 };
double[] dPt = { (1.0 - w) * po1[0] + w * mPt[0], (1.0 - w) * po1[1] + w * mPt[1] };
axys[ino * 2 + 0] = dPt[0];
axys[ino * 2 + 1] = dPt[1];
}
}
edge.SetCurveRelPoint(axys);
return(true);
}
/// <summary>
/// 骨骼动画直接是找最大的区域
/// </summary>
/// <returns>返回存Edge2D的字典</returns>
private static Dictionary <Edge2D, int> BuildEdgesFromSkeletonAnim(MeshFilter filter)
{
var mesh = filter.sharedMesh;
if (mesh == null)
{
return(null);
}
var verts = mesh.vertices;
var tris = mesh.triangles;
var edges = new Dictionary <Edge2D, int>();
Vector3 vert = verts[0];
float minXPos = vert.x;
float maxXPos = vert.x;
float minYPos = vert.y;
float maxYPos = vert.y;
for (int i = 1; i < verts.Length; i++)
{
Vector3 checkVert = verts[i];
if (checkVert.x < minXPos)
{
minXPos = checkVert.x;
}
if (checkVert.x > maxXPos)
{
maxXPos = checkVert.x;
}
if (checkVert.y < minYPos)
{
minYPos = checkVert.y;
}
if (checkVert.y > maxYPos)
{
maxYPos = checkVert.y;
}
}
//修复偏移
minYPos = 0;
Edge2D[] faceEdges;
faceEdges = new Edge2D[] {
new Edge2D {
a = new Vector2(minXPos, minYPos), b = new Vector2(minXPos, maxYPos)
},
new Edge2D {
a = new Vector2(minXPos, maxYPos), b = new Vector2(maxXPos, maxYPos)
},
new Edge2D {
a = new Vector2(maxXPos, maxYPos), b = new Vector2(maxXPos, minYPos)
},
new Edge2D {
a = new Vector2(maxXPos, minYPos), b = new Vector2(minXPos, minYPos)
},
};
foreach (var edge in faceEdges)
{
if (edges.ContainsKey(edge))
{
edges[edge]++;
}
else
{
edges[edge] = 1;
}
}
return(edges);
}
public static int CheckEdgeIntersection(IList <Edge2D> edges)
{
uint edgeCnt = (uint)edges.Count;
for (int iedge = 0; iedge < edgeCnt; iedge++)
{
Edge2D iE = edges[iedge];
if (iE.IsCrossEdgeSelf())
{
return(1);
}
uint iPt0 = iE.GetVertexId(true);
uint iPt1 = iE.GetVertexId(false);
BoundingBox2D iBB = iE.GetBoundingBox();
for (int jedge = iedge + 1; jedge < edgeCnt; jedge++)
{
Edge2D jE = edges[jedge];
uint jPt0 = jE.GetVertexId(true);
uint jPt1 = jE.GetVertexId(false);
if ((iPt0 - jPt0) * (iPt0 - jPt1) * (iPt1 - jPt0) * (iPt1 - jPt1) != 0)
{
BoundingBox2D jBB = jE.GetBoundingBox();
if (jBB.MinX > iBB.MaxX || jBB.MaxX < iBB.MinX)
{
continue;
}
if (jBB.MinY > iBB.MaxY || jBB.MaxY < iBB.MinY)
{
continue;
}
if (!iE.IsCrossEdge(jE))
{
continue;
}
return(1);
}
if (iPt0 == jPt0 && iPt1 == jPt1)
{
if (iE.IsCrossEdgeShareBothPoints(jE, true))
{
return(1);
}
}
else if (iPt0 == jPt1 && iPt1 == jPt0)
{
if (iE.IsCrossEdgeShareBothPoints(jE, false))
{
return(1);
}
}
else if (iPt0 == jPt0)
{
if (iE.IsCrossEdgeShareOnePoint(jE, true, true))
{
return(1);
}
}
else if (iPt0 == jPt1)
{
if (iE.IsCrossEdgeShareOnePoint(jE, true, false))
{
return(1);
}
}
else if (iPt1 == jPt0)
{
if (iE.IsCrossEdgeShareOnePoint(jE, false, true))
{
return(1);
}
}
else if (iPt1 == jPt1)
{
if (iE.IsCrossEdgeShareOnePoint(jE, false, false))
{
return(1);
}
}
continue;
}
}
return(0);
}
public void SetCadEdge(CadObject2D cad2D, uint eId, OpenTK.Vector2d pickPos)
{
this.PickPos = pickPos;
this.ECadId = eId;
ClearMemory();
IList <double> relCoPolys = new List <double>();
{
System.Diagnostics.Debug.Assert(cad2D.IsElementId(CadElementType.Edge, eId));
Edge2D e = cad2D.GetEdge(eId);
relCoPolys = e.GetCurveRelPoint();
}
IList <double> xys = new List <double>();
uint ndiv = (uint)(relCoPolys.Count / 2 + 1);
No = ndiv + 1;
for (int i = 0; i < No * 2; i++)
{
xys.Add(0);
}
uint sVId = cad2D.GetEdgeVertexId(eId, true);
uint eVId = cad2D.GetEdgeVertexId(eId, false);
OpenTK.Vector2d sV = cad2D.GetVertexCoord(sVId);
OpenTK.Vector2d eV = cad2D.GetVertexCoord(eVId);
OpenTK.Vector2d hse = eV - sV;
OpenTK.Vector2d vse = new OpenTK.Vector2d(-hse.Y, hse.X);
xys.Add(sV.X);
xys.Add(sV.Y);
for (int i = 0; i < ndiv - 1; i++)
{
OpenTK.Vector2d v = sV + relCoPolys[i * 2 + 0] * hse + relCoPolys[i * 2 + 1] * vse;
xys.Add(v.X);
xys.Add(v.Y);
}
xys.Add(eV.X);
xys.Add(eV.Y);
//////////////////////////////////////
Mat = new TriDiaMat3(No);
IniX = new double[No * 2];
Ut = new double[No * 3];
Res = new double[No * 3];
Dut = new double[No * 3];
BCFlag = new int[No * 3];
////
for (int i = 0; i < No * 2; i++)
{
IniX[i] = xys[i];
}
for (int i = 0; i < No * 3; i++)
{
Ut[i] = 0;
}
for (int i = 0; i < No * 3; i++)
{
BCFlag[i] = 0;
}
//////////////////////////////////////
SetFixedBoundaryFlag(0, 0);
SetFixedBoundaryFlag(0, 1);
SetFixedBoundaryFlag(No - 1, 0);
SetFixedBoundaryFlag(No - 1, 1);
double alpha;
double ndist;
double normX;
double normY;
ProjectPoint(pickPos.X, pickPos.Y, ref PickedDivIndex,
out alpha, out ndist, out normX, out normY);
if (PickedDivIndex == -1)
{
return;
}
SetFixedBoundaryFlag((uint)PickedDivIndex, 0);
SetFixedBoundaryFlag((uint)PickedDivIndex, 1);
SetFixedBoundaryFlag((uint)PickedDivIndex + 1, 0);
SetFixedBoundaryFlag((uint)PickedDivIndex + 1, 1);
}
public bool MoveEdgeCtrl(uint eId, uint iCtrl, OpenTK.Vector2d deltaVec)
{
if (!IsElementId(CadElementType.Edge, eId))
{
return(false);
}
IList <double> oldRelCos = null;
{
Edge2D e = GetEdge(eId);
oldRelCos = e.GetCurveRelPoint();
}
Edge2D edge = GetEdge(eId);
if (iCtrl >= edge.GetCurvePoint().Count)
{
return(true);
}
{
OpenTK.Vector2d sPt = edge.GetVertex(true);
OpenTK.Vector2d ePt = edge.GetVertex(false);
double sqLen = CadUtils.SquareLength(ePt - sPt);
var eh = (ePt - sPt) * (1 / sqLen);
OpenTK.Vector2d ev = new OpenTK.Vector2d(-eh.Y, eh.X);
var p0 = edge.GetCurvePoint()[(int)iCtrl] + deltaVec;
IList <double> aRelCo = edge.GetCurveRelPoint();
aRelCo[(int)(iCtrl * 2 + 0)] = OpenTK.Vector2d.Dot(p0 - sPt, eh);
aRelCo[(int)(iCtrl * 2 + 1)] = OpenTK.Vector2d.Dot(p0 - sPt, ev);
edge.SetCurveRelPoint(aRelCo);
}
HashSet <uint> setLId = new HashSet <uint>();
for (VertexEdgeItr vItr = this.BRep.GetVertexEdgeItr(edge.GetVertexId(true)); !vItr.IsEnd(); vItr++)
{
uint tmpLId = vItr.GetLoopId();
if (!setLId.Contains(tmpLId))
{
setLId.Add(tmpLId);
}
}
for (VertexEdgeItr vItr = this.BRep.GetVertexEdgeItr(edge.GetVertexId(false)); !vItr.IsEnd(); vItr++)
{
uint tmpLId = vItr.GetLoopId();
if (!setLId.Contains(tmpLId))
{
setLId.Add(tmpLId);
}
}
foreach (uint lId in setLId)
{
if (!this.BRep.IsElementId(CadElementType.Loop, lId))
{
continue;
}
if (CheckLoop(lId) != 0)
{
// fail
edge.SetCurveRelPoint(oldRelCos);
return(true);
}
}
return(true);
}
private void processPoint(Point2D point)
{
badTriangles.Clear();
foreach (Triangle2D tri in triangles)
{
if (tri.HasPoint(point))
{
// Don't need to process this triangle further
return;
}
if (tri.CircumcircleContains(point))
{
badTriangles.Add(tri);
}
}
polygon.Clear();
foreach (Triangle2D tri in badTriangles)
{
if (!triangles.Remove(tri))
{
Debug.Log("Didn't remove triangle!: " + tri);
}
Edge2D ab = new Edge2D(tri.a, tri.b);
if (polygon.ContainsKey(ab))
{
polygon[ab] = 2;
}
else
{
polygon[ab] = 1;
}
Edge2D bc = new Edge2D(tri.b, tri.c);
if (polygon.ContainsKey(bc))
{
polygon[bc] = 2;
}
else
{
polygon[bc] = 1;
}
Edge2D ca = new Edge2D(tri.c, tri.a);
if (polygon.ContainsKey(ca))
{
polygon[ca] = 2;
}
else
{
polygon[ca] = 1;
}
}
foreach (KeyValuePair <Edge2D, int> edge in polygon)
{
if (edge.Value == 1)
{
Triangle2D tri = new Triangle2D(edge.Key.a, edge.Key.b, point);
triangles.Add(tri);
}
}
}
private static IEnumerable<Tuple<Point, Point>> MergeIslandSprtSegmentsSprtDivide_OLD(int polyCntr, Edge2D edge, EdgeIntersection[] intersections)
{
// Build vectors from edge.p0 to each intersection, sort by length
var distances = Enumerable.Range(0, intersections.Length).
Select(o => new { Index = o, Distance = (intersections[o].IntersectionPoint - edge.Point0).LengthSquared }).
OrderBy(o => o.Distance).
ToArray();
List<Tuple<Point, Point>> retVal = new List<Tuple<Point, Point>>();
// Point0 to first intersect
retVal.Add(Tuple.Create(
edge.Point0,
intersections[distances[0].Index].IntersectionPoint));
// Intersect to Intersect
for (int cntr = 0; cntr < distances.Length - 1; cntr++)
{
retVal.Add(Tuple.Create(
intersections[distances[cntr].Index].IntersectionPoint,
intersections[distances[cntr + 1].Index].IntersectionPoint));
}
// Last intersect to Point1
retVal.Add(Tuple.Create(
intersections[distances[distances.Length - 1].Index].IntersectionPoint,
edge.Point1Ext));
return retVal;
}
public bool DragArc(uint eId, OpenTK.Vector2d vec)
{
if (!IsElementId(CadElementType.Edge, eId))
{
return(false);
}
if (GetEdgeCurveType(eId) != CurveType.CurveArc)
{
return(true);
}
bool oldIsLeftSide;
double oldDist;
{
Edge2D e = GetEdge(eId);
e.GetCurveArc(out oldIsLeftSide, out oldDist);
}
Edge2D edge = GetEdge(eId);
System.Diagnostics.Debug.Assert(edge.CurveType == CurveType.CurveArc);
{
OpenTK.Vector2d sPt = edge.GetVertex(true);
OpenTK.Vector2d ePt = edge.GetVertex(false);
double edgeLen = Math.Sqrt(CadUtils.SquareLength(sPt, ePt));
if (Math.Abs(CadUtils.TriHeight(vec, sPt, ePt)) > edgeLen * 0.02)
{
OpenTK.Vector2d cPt;
bool ret = CadUtils.CenterCircumcircle(sPt, ePt, vec, out cPt);
System.Diagnostics.Debug.Assert(ret);
double dist = CadUtils.TriHeight(cPt, sPt, ePt);
double distRatio = dist / edgeLen;
edge.SetCurveArc(CadUtils.TriArea(sPt, ePt, vec) > 0, distRatio);
}
else
{
return(true);
}
}
HashSet <uint> setLId = new HashSet <uint>();
for (VertexEdgeItr vItr = this.BRep.GetVertexEdgeItr(edge.GetVertexId(true)); !vItr.IsEnd(); vItr++)
{
uint tmpLId = vItr.GetLoopId();
if (!setLId.Contains(tmpLId))
{
setLId.Add(tmpLId);
}
}
for (VertexEdgeItr vItr = this.BRep.GetVertexEdgeItr(edge.GetVertexId(false)); !vItr.IsEnd(); vItr++)
{
uint tmpLId = vItr.GetLoopId();
if (!setLId.Contains(tmpLId))
{
setLId.Add(tmpLId);
}
}
foreach (uint lId in setLId)
{
if (!this.BRep.IsElementId(CadElementType.Loop, lId))
{
continue;
}
if (CheckLoop(lId) != 0)
{
// fail
edge.SetCurveArc(oldIsLeftSide, oldDist);
return(true);
}
}
return(true);
}
