/// <summary>
/// Returns a preconfigured <see cref="Array2D{TItem}"/> which can be used to make a <see cref="DefinitionNodeGrid"/>
/// </summary>
/// <param name="width"></param>
/// <param name="height"></param>
/// <param name="generateNodeGridConnections"></param>
/// <returns></returns>
public static Array2D <DefinitionNode> GeneratePreFilledArray(GenerateNodeGridConnections generateNodeGridConnections, int width, int height)
{
var array = new Array2D <DefinitionNode>(width, height);
for (var y = 0; y < height; y++)
{
for (var x = 0; x < width; x++)
{
var worldPosition = new Vector2(x, y);
var i = width * y + x;
var node = new DefinitionNode(i, worldPosition, 1);
array[x, y] = node;
}
}
if (generateNodeGridConnections != GenerateNodeGridConnections.None)
{
for (var y = 0; y < height; y++)
{
for (var x = 0; x < width; x++)
{
var node = array[x, y];
var neighbours = GetNeighbours(array, x, y, generateNodeGridConnections);
foreach (var neighbour in neighbours)
{
node.Connections.Add(new NodeConnection(neighbour));
}
}
}
}
return(array);
}
private static float GetDistance(DefinitionNode sourceNodeA, DefinitionNode sourceNodeB)
{
var dstX = Math.Abs(sourceNodeA.Position.X - sourceNodeB.Position.X);
var dstY = Math.Abs(sourceNodeA.Position.Y - sourceNodeB.Position.Y);
return(dstY + dstX);
}
public DefinitionNode AddNode(Vector2 position, float movementPenalty = 1f)
{
var definitionNode = new DefinitionNode(DefinitionNodes.Count, position, movementPenalty);
DefinitionNodes.Add(definitionNode);
return(definitionNode);
}
private static float GetDistance(DefinitionNode dijkstraNodeA, DefinitionNode dijkstraNodeB)
{
var dstX = Math.Abs(dijkstraNodeA.Position.X - dijkstraNodeB.Position.X);
var dstY = Math.Abs(dijkstraNodeA.Position.Y - dijkstraNodeB.Position.Y);
return(dstY + dstX);
}
public int AddNode(Vector2 position, float movementPenalty = 1f)
{
var index = NodeArray.Length;
var definitionNode = new DefinitionNode(position, movementPenalty);
NodeArray = NodeArray.Append(definitionNode);
return(index);
}
private static object[] GeneratePathLengthTestCase(int gridWidth, int gridHeight, int[] path, float expectedPathLength)
{
var nodes = new Array2D <DefinitionNode>(gridWidth, gridHeight);
for (var y = 0; y < gridHeight; y++)
{
for (var x = 0; x < gridWidth; x++)
{
nodes[x, y] = new DefinitionNode(new Vector2(x, y));
}
}
return(new object[] { nodes.Array, path, expectedPathLength });
}
public static string GenerateFullName(DefinitionNode node)
{
var fullName = new System.Text.StringBuilder();
while (node != null)
{
fullName.Insert(0, node.name + '.');
node = node.parent;
}
fullName.Length -= 1;
return(fullName.ToString());
}
private void GetTreeData(MainWinVM mainWinVM)
{
PLMProductService service = (PLMProductService)CatiaService.catia.ActiveEditor.GetService("PLMProductService");
VPMRootOccurrence vpmRootOcc = service.RootOccurrence;
VPMReference vpmRefOnRoot = vpmRootOcc.ReferenceRootOccurrenceOf;
// get all children of the root
VPMInstances vpmInstsL1 = vpmRefOnRoot.Instances;
DefinitionNode rootNode = new DefinitionNode();
rootNode.Name = vpmRefOnRoot.GetAttributeValue("V_Name");
mainWinVM.DefinitionNodes = new ObservableCollection <DefinitionNode>();
mainWinVM.DefinitionNodes.Add(rootNode);
Recursion(vpmInstsL1, rootNode);
}
/// <summary>
/// Calculates the clearances up to a maximum <paramref name="maxClearance"/>
/// </summary>
/// <param name="definitionNode"></param>
/// <param name="collisionCategory"></param>
/// <param name="maxClearance"></param>
/// <returns></returns>
public float CalculateGridNodeClearances(DefinitionNode definitionNode, PathfindaxCollisionCategory collisionCategory, int maxClearance)
{
var fromCoordinates = new Point2((int)definitionNode.Position.X, (int)definitionNode.Position.Y);
for (var checkClearance = 0; checkClearance < maxClearance; checkClearance++)
{
var nextClearanceIsBlocked = false;
for (var x = 0; x < checkClearance + 1; x++)
{
switch (IsBlocked(x + fromCoordinates.X, checkClearance + fromCoordinates.Y, collisionCategory, fromCoordinates))
{
case BlockType.Current:
return(checkClearance);
case BlockType.Next:
nextClearanceIsBlocked = true;
break;
}
}
for (var y = 0; y < checkClearance; y++)
{
switch (IsBlocked(checkClearance + fromCoordinates.X, y + fromCoordinates.Y, collisionCategory, fromCoordinates))
{
case BlockType.Current:
return(checkClearance);
case BlockType.Next:
nextClearanceIsBlocked = true;
break;
}
}
if (nextClearanceIsBlocked)
{
var isBlocked = true;
for (var i = 0; i < definitionNode.Connections.Count; i++)
{
if ((definitionNode.Connections[i].CollisionCategory & collisionCategory) == 0)
{
isBlocked = false;
}
}
return(isBlocked ? checkClearance : checkClearance + 1);
}
}
return(maxClearance);
}
private void Recursion(PLMEntities vpmInsts, DefinitionNode node)
{
ObservableCollection <DefinitionNode> definitionNodes = new ObservableCollection <DefinitionNode>();
for (int i = 1; i < vpmInsts.Count + 1; i++)
{
DefinitionNode definitionNode = new DefinitionNode();
VPMInstance vpmInstL1 = vpmInsts.Item(i) as VPMInstance;
VPMReference vpmRefInstL1 = vpmInstL1.ReferenceInstanceOf;
definitionNode.Name = vpmRefInstL1.GetAttributeValue("V_Name");
definitionNodes.Add(definitionNode);
VPMInstances vpmInstsL2 = vpmRefInstL1.Instances;
if (vpmInstsL2.Count > 0)
{
Recursion(vpmInstsL2, definitionNode);
}
else
{
VPMRepInstances vpmRefInstsL3 = vpmRefInstL1.RepInstances;
ObservableCollection <DefinitionNode> nodes = new ObservableCollection <DefinitionNode>();
for (int k = i; k < vpmRefInstsL3.Count + 1; k++)
{
VPMRepInstance vpmRepInstL3 = vpmRefInstsL3.Item(k) as VPMRepInstance;
VPMRepReference vpmRepRefL3 = vpmRepInstL3.ReferenceInstanceOf;
DefinitionNode oneNode = new DefinitionNode();
oneNode.Name = vpmRepRefL3.GetAttributeValue("V_Name");
nodes.Add(oneNode);
}
definitionNode.Children = nodes;
}
}
node.Children = definitionNodes;
}
public IDefinitionNodeNetwork GenerateGrid2D()
{
const int width = 1000;
const int height = 1000;
var random = new Random();
var dictionary = new Dictionary <DelaunayNode, DefinitionNode>();
var nodeNetwork = new DefinitionNodeNetwork(new Vector2(1, 1));
for (var i = 0; i < 100; i++)
{
var node = new DefinitionNode(i, new Vector2(random.Next(0, width), random.Next(0, height)));
var defaultNode = new DelaunayNode(new Vector2(node.Position.X, node.Position.Y));
dictionary.Add(defaultNode, node);
nodeNetwork.DefinitionNodes.Add(node);
}
var graph = new Graph <DelaunayNode>();
graph.Nodes.AddRange(dictionary.Keys);
graph.Triangulate();
foreach (var graphLink in graph.Links.GroupBy(x => x.From))
{
var from = dictionary[graphLink.Key];
var connections = new List <DefinitionNode>();
foreach (var link in graphLink)
{
var to = dictionary[link.To];
connections.Add(to);
}
for (var i = 0; i < connections.Count; i++)
{
var to = connections[i];
from.Connections.Add(new NodeConnection(to.Index));
to.Connections.Add(new NodeConnection(from.Index));
}
}
return(nodeNetwork);
}
/// <summary>
/// Returns a preconfigured <see cref="Array2D{DefinitionNode}"/> which can be used to make a <see cref="DefinitionNodeGrid"/>
/// </summary>
/// <param name="width"></param>
/// <param name="height"></param>
/// <param name="generateNodeGridConnections"></param>
/// <param name="nodeGridCollisionLayers"></param>
/// <param name="crossCorners"></param>
/// <returns></returns>
public Array2D <DefinitionNode> GeneratePreFilledArray(GenerateNodeGridConnections generateNodeGridConnections, int width, int height, NodeGridCollisionMask nodeGridCollisionLayers = null, bool crossCorners = false)
{
var array = new Array2D <DefinitionNode>(width, height);
for (var y = 0; y < height; y++)
{
for (var x = 0; x < width; x++)
{
var worldPosition = new Vector2(x, y);
if (generateNodeGridConnections == GenerateNodeGridConnections.None)
{
array[x, y] = new DefinitionNode(worldPosition);
}
else
{
var connections = GetNeighbours(width, height, x, y, generateNodeGridConnections, nodeGridCollisionLayers, crossCorners);
array[x, y] = new DefinitionNode(worldPosition, connections: connections);
}
}
}
return(array);
}
public PathRequest <TPath> RequestPath(DefinitionNode start, DefinitionNode end, PathfindaxCollisionCategory collisionLayer = PathfindaxCollisionCategory.None, byte agentSize = 1)
{
return(PathRequest.Create(this, start, end, collisionLayer, agentSize));
}
/// <summary>
/// Calculates the <see cref="NodeConnection"/>s for the <paramref name="definitionNode"/>
/// </summary>
/// <param name="tilemapColliderWithBodies"></param>
/// <param name="definitionNode"></param>
/// <param name="definitionNodeGrid"></param>
public void CalculateGridNodeCollision(TilemapColliderWithBody[] tilemapColliderWithBodies, DefinitionNode definitionNode, DefinitionNodeGrid definitionNodeGrid)
{
var nodeGridCoordinates = new Point2((int)definitionNode.Position.X, (int)definitionNode.Position.Y);
CalculateNodeCollisionCategories(nodeGridCoordinates.X, nodeGridCoordinates.Y, tilemapColliderWithBodies);
if (nodeGridCoordinates.X == 0 || nodeGridCoordinates.Y == 0 ||
nodeGridCoordinates.X == definitionNodeGrid.NodeGrid.Width - 1 ||
nodeGridCoordinates.Y == definitionNodeGrid.NodeGrid.Height - 1)
{
for (var index = 1; index < _nodeCollisions.Length; index++)
{
var collisionCategory = _nodeCollisions[index];
if (collisionCategory.X >= 0 && collisionCategory.Y >= 0 &&
collisionCategory.X < definitionNodeGrid.NodeGrid.Width &&
collisionCategory.Y < definitionNodeGrid.NodeGrid.Height)
{
//TODO provide option to exclude diagonal neighbours.
var toNode = definitionNodeGrid.NodeGrid[collisionCategory.X, collisionCategory.Y];
definitionNode.Connections.Add(new NodeConnection(toNode.Index,
collisionCategory.PathfindaxCollisionCategory | _nodeCollisions[0].PathfindaxCollisionCategory));
}
}
}
else
{
for (var index = 1; index < _nodeCollisions.Length; index++)
{
var collisionCategory = _nodeCollisions[index];
//TODO provide option to exclude diagonal neighbours.
var toNode = definitionNodeGrid.NodeGrid[collisionCategory.X, collisionCategory.Y];
definitionNode.Connections.Add(new NodeConnection(toNode.Index,
collisionCategory.PathfindaxCollisionCategory | _nodeCollisions[0].PathfindaxCollisionCategory));
}
}
}
