private bool InitializeBuffers(SharpDX.Direct3D11.Device device)
{
try
{
// Create the vertex array.
var vertices = new DVertex[VertexCount];
// Create the index array.
var indices = new int[IndexCount];
for (var i = 0; i < VertexCount; i++)
{
vertices[i] = new DVertex()
{
position = new Vector3(ModelObject[i].x, ModelObject[i].y, ModelObject[i].z),
texture = new Vector2(ModelObject[i].tu, ModelObject[i].tv),
normal = new Vector3(ModelObject[i].nx, ModelObject[i].ny, ModelObject[i].nz)
};
indices[i] = i;
}
// Create the vertex buffer.
VertexBuffer = SharpDX.Direct3D11.Buffer.Create(device, BindFlags.VertexBuffer, vertices);
// Create the index buffer.
IndexBuffer = SharpDX.Direct3D11.Buffer.Create(device, BindFlags.IndexBuffer, indices);
return(true);
}
catch
{
return(false);
}
}
public void CalcPathLen(DVertex start)
{
// Reinitialize vertices
foreach (var v in Vertices)
{
v._pathLen = int.MaxValue / 2;
v.Viewed = false;
}
heap = new BinaryHeap <DEdge>();
heap.postProcess = (DEdge e, int oldIndex, int newIndex) =>
e._heapIndex = newIndex;
foreach (var e in Edges)
{
heap.Insert(e);
}
var vCount = 1;
ProcessVertex(start, 0);
while (vCount < VerticesCount && !heap.IsEmpty)
{
var e = heap.ExtractMin();
if (!e.Dest.Viewed)
{
ProcessVertex((DVertex)e.Dest, e.PathLen);
vCount++;
}
}
}
public int CompareTo(object obj)
{
DVertex b = ( DVertex )obj;
if (this.x > b.x)
{
return(1);
}
return(-1);
}
private new void ProcessVertex(DVertex v, int pathLen)
{
v.Viewed = true;
v._pathLen = pathLen;
foreach (var e in Outgoing(v.Key))
{
var dedge = (DEdge)e;
heap.RemoveAt(dedge._heapIndex);
heap.Insert(dedge);
}
}
public static List <DTriangle> Triangulate(List <DVertex> vertices)
{
int n = vertices.Count;
/* Bail if there aren't enough vertices to form any triangles. */
if (n < 3)
{
return(new List <DTriangle>());
}
vertices.Sort();
/* Next, find the vertices of the supertriangle (which contains all other
* triangles), and append them onto the end of a (copy of) the vertex
* array. */
float[] st = SuperTriangle(vertices);
vertices.Add(new DVertex(st[0], st[1]));
vertices.Add(new DVertex(st[2], st[3]));
vertices.Add(new DVertex(st[4], st[5]));
/* Initialize the open list (containing the supertriangle and nothing
* else) and the closed list (which is empty since we havn't processed
* any triangles yet). */
List <DTriangle> open = new List <DTriangle> {
Circumcircle(vertices, n + 0, n + 1, n + 2)
};
List <DTriangle> closed = new List <DTriangle>();
List <int> edges = new List <int>();
/* Incrementally add each vertex to the mesh. */
for (int i = 0; i < n; i++)
{
edges.Clear();
/* For each open triangle, check to see if the current point is
* inside it's circumcircle. If it is, remove the triangle and add
* it's edges to an edge list. */
for (int j = open.Count - 1; j >= 0; j--)
{
/* If this point is to the right of this triangle's circumcircle,
* then this triangle should never get checked again. Remove it
* from the open list, add it to the closed list, and skip. */
DTriangle openTri = open[j];
DVertex curVertex = vertices[i];
float dx = curVertex.x - openTri.x;
if (dx > 0.0f && dx * dx > openTri.r)
{
closed.Add(openTri);
open.RemoveAt(j);
continue;
}
/* If we're outside the circumcircle, skip this triangle. */
float dy = curVertex.y - openTri.y;
if (dx * dx + dy * dy - openTri.r > EPSILON)
{
continue;
}
/* Remove the triangle and add it's edges to the edge list. */
edges.Add(openTri.v0);
edges.Add(openTri.v1);
edges.Add(openTri.v1);
edges.Add(openTri.v2);
edges.Add(openTri.v2);
edges.Add(openTri.v0);
open.RemoveAt(j);
}
/* Remove any doubled edges. */
Dedup(edges);
/* Add a new triangle for each edge. */
for (int j = edges.Count; j > 0;)
{
int b = edges[--j];
int a = edges[--j];
open.Add(Circumcircle(vertices, a, b, i));
}
}
/* Copy any remaining open triangles to the closed list, and then
* remove any triangles that share a vertex with the supertriangle,
* building a list of triplets that represent triangles. */
closed.AddRange(open);
open.Clear();
for (int i = closed.Count - 1; i >= 0; i--)
{
DTriangle triangle = closed[i];
if (triangle.v0 < n && triangle.v1 < n && triangle.v2 < n)
{
open.Add(triangle);
}
}
/* Yay, we're done! */
return(open);
}
// Пример отсюда https://ru.wikipedia.org/wiki/%D0%90%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC_%D0%94%D0%B5%D0%B9%D0%BA%D1%81%D1%82%D1%80%D1%8B
public static DGraph GenerateGraph()
{
DVertex one = new DVertex { Name = "1"};
DVertex two = new DVertex {Name = "2"};
DVertex three = new DVertex {Name = "3"};
DVertex four = new DVertex {Name = "4"};
DVertex five = new DVertex {Name = "5"};
DVertex six = new DVertex {Name = "6"};
var edges = new List<Edge<DVertex>>
{
new Edge<DVertex>
{
X = one,
Y = two,
Weight = 7
},
new Edge<DVertex>
{
X = one,
Y = three,
Weight = 9
},
new Edge<DVertex>
{
X = one,
Y = six,
Weight = 14
},
new Edge<DVertex>
{
X = two,
Y = three,
Weight = 10
},
new Edge<DVertex>
{
X = two,
Y = four,
Weight = 15
},
new Edge<DVertex>
{
X = three,
Y = four,
Weight = 11
},
new Edge<DVertex>
{
X = three,
Y = six,
Weight = 2
},
new Edge<DVertex>
{
X = four,
Y = five,
Weight = 6
},
new Edge<DVertex>
{
X = five,
Y = six,
Weight = 9
}
};
var vertices = new List<DVertex>();
vertices.AddRange(new[] { one, two, three, four, five, six });
var graph = new DGraph
{
Edges = edges,
Vertices = vertices
};
return graph;
}
