Working A* with cyhon nodes (i wanted to do the whole pathfinding in Cython (python but compiled to c) however i ran into memory issues i wasn't able to fix in time but oh well)

Author: Daxode

.gitignore

@@ -3,3 +3,8 @@ venv
 logs/
 dist/
 build/
+docs/Concept Art/lina2.png
+docs/Concept Art/lina.png
+docs/Concept Art/lina.kra
+docs/Concept Art/DanielHavingFunWithEyes.kra
+docs/Concept Art/CassandraHavingFunWithBrushes.kra

Blobtory/Scripts/planet_former/AStar.py

@@ -1,22 +1,23 @@
-from copy import deepcopy
+from copy import deepcopy, copy
 from typing import Dict, Set, List, Tuple
-from Blobtory.Scripts.planet_former.NodeRef import NodeRef, NodeKey
+from Blobtory.Scripts.planet_former.Nodes import NodeRef, NodeKey, Node
 from queue import PriorityQueue
 from multipledispatch import dispatch
+import numpy as np
 
 
-def GetDist(pFrom: Tuple[float, float, float, float],
-            pTo: Tuple[float, float, float, float]):
+def GetDist(pFrom: Node,
+            pTo: Node):
     return (abs(pFrom[0] - pTo[0]) +
             abs(pFrom[1] - pTo[1]) +
             abs(pFrom[2] - pTo[2]))
 
 
 def ReconstructPath(cameFrom: Dict[NodeRef, NodeKey], current: NodeKey):
-    totalPath: List[Tuple[float, float, float, float]] = [current.point]
+    totalPath: List[Node] = [current]
     while current in cameFrom.keys():
         current = cameFrom[current]
-        totalPath.insert(0, current.point)
+        totalPath.insert(0, current)
 
     return totalPath
 
@@ -30,18 +31,18 @@ def __init__(self, nodeDict: Dict):
         self.keyList = list(self.nodeDict.keys())
 
     def GetKeyNodeFromRef(self, p: NodeRef) -> NodeKey:
-        return self.keyList[self.keyList.index(p.point)]
+        return self.keyList[self.keyList.index(p)]
 
-    def GetKeyNodeFromPoint(self, p: Tuple[float, float, float, float]) -> NodeKey:
+    def GetKeyNodeFromPoint(self, p: Node) -> NodeKey:
         return self.keyList[self.keyList.index(p)]
 
     def GetH(self, p: NodeKey) -> float:
         return 1/p.weight
 
     def GetPathFromTo(self,
-                      pFrom: Tuple[float, float, float, float],
-                      pTo: Tuple[float, float, float, float]
-                      ) -> List[Tuple[float, float, float, float]]:
+                      pFrom: Node,
+                      pTo: Node
+                      ) -> List[Node]:
         startNode = self.GetKeyNodeFromPoint(pFrom)
         openSet = PriorityQueue()
         openSet.put((0, startNode))
@@ -50,7 +51,7 @@ def GetPathFromTo(self,
         gScore = {nodeKey: float("inf") for nodeKey in self.nodeDict.keys()}
         gScore[pFrom] = 0
 
-        fScore = deepcopy(gScore)
+        fScore = copy(gScore)
         fScore[pFrom] = self.GetH(startNode)
 
         openSetTable = {startNode}
@@ -65,7 +66,7 @@ def GetPathFromTo(self,
 
             neighbourPoints: Set[NodeRef] = self.nodeDict[current]
             for neighbourPoint in neighbourPoints:
-                tentativeGScore = gScore[current] + GetDist(current.point, neighbourPoint.point)
+                tentativeGScore = gScore[current] + GetDist(current, neighbourPoint)
 
                 if tentativeGScore < gScore[neighbourPoint]:
                     cameFrom[neighbourPoint] = current

Blobtory/Scripts/planet_former/AStarC.c

@@ -0,0 +1 @@
+#error Do not use this file, it is the result of a failed Cython compilation.

Blobtory/Scripts/planet_former/AStarC.pyx

@@ -0,0 +1,87 @@
+from copy import deepcopy
+from typing import Dict, Set, List, Tuple
+from queue import PriorityQueue
+from Blobtory.Scripts.planet_former.Nodes cimport NodeRef, NodeKey
+cdef extern class Node:
+    cdef extern float* point
+    cdef extern char* hashKey
+
+cdef extern class NodeRef(Node):
+    cdef extern float relativeDist
+
+cdef extern class NodeKey(Node):
+    cdef extern float weight
+
+from libcpp.map cimport map
+from libcpp.string cimport string
+from libcpp.vector cimport vector
+
+def GetDist(pFrom: Tuple[float, float, float, float],
+            pTo: Tuple[float, float, float, float]):
+    return (abs(pFrom[0] - pTo[0]) +
+            abs(pFrom[1] - pTo[1]) +
+            abs(pFrom[2] - pTo[2]))
+
+
+def ReconstructPath(cameFrom: Dict[NodeRef, NodeKey], current: NodeKey):
+    cdef list totalPath = [current.point]
+    while current in cameFrom.keys():
+        current = cameFrom[current]
+        totalPath.insert(0, current.point)
+
+    return totalPath
+
+
+
+class AStar:
+    def __init__(self, nodeDict: Dict):
+        self.nodeDict = nodeDict
+        self.keyList = list(self.nodeDict.keys())
+
+    def GetKeyNodeFromRef(self, p: NodeRef) -> NodeKey:
+        return self.keyList[self.keyList.index(p.point)]
+
+    def GetKeyNodeFromPoint(self, p: Tuple[float, float, float, float]) -> NodeKey:
+        return self.keyList[self.keyList.index(p)]
+
+    def GetH(self, p: NodeKey) -> float:
+        return 1/p.weight
+
+    def GetPathFromTo(self,
+                      pFrom: Tuple[float, float, float, float],
+                      pTo: Tuple[float, float, float, float]
+                      ) -> List[Tuple[float, float, float, float]]:
+        startNode = self.GetKeyNodeFromPoint(pFrom)
+        openSet = PriorityQueue()
+        openSet.put((0, startNode))
+        cdef map[NodeRef, NodeKey] cameFrom = {}
+
+        gScore = {nodeKey: float("inf") for nodeKey in self.nodeDict.keys()}
+        gScore[pFrom] = 0
+
+        fScore = deepcopy(gScore)
+        fScore[pFrom] = self.GetH(startNode)
+
+        openSetTable = {startNode}
+
+        while not openSet.empty():
+            setVal = openSet.get()
+            current = setVal[1]
+            openSetTable.remove(current)
+
+            if current == pTo:
+                return ReconstructPath(cameFrom, current)
+
+            neighbourPoints = self.nodeDict[current]
+            for neighbourPoint in neighbourPoints:
+                tentativeGScore = gScore[current] + GetDist(current.point, neighbourPoint.point)
+
+                if tentativeGScore < gScore[neighbourPoint]:
+                    cameFrom[neighbourPoint] = current
+                    gScore[neighbourPoint] = tentativeGScore
+                    fScore[neighbourPoint] = gScore[neighbourPoint] + self.GetH(self.GetKeyNodeFromRef(neighbourPoint))
+                    if neighbourPoint not in openSetTable:
+                        openSet.put((fScore[neighbourPoint], neighbourPoint))
+                        openSetTable.add(neighbourPoint)
+
+        return []

Blobtory/Scripts/planet_former/MarchingCubes.py

@@ -121,10 +121,10 @@ def GenerateMesh(self):
             self.winCreator.base.render.find("**/node").removeNode()
 
         self.geomPath = self.winCreator.base.render.attach_new_node(node)
-        self.geomPath.setPos(
-            -self.size.getX()*0.5*self.cubeformer.spacing,
-            -self.size.getY()*0.5*self.cubeformer.spacing,
-            -self.size.getZ()*0.5*self.cubeformer.spacing)
+        # self.geomPath.setPos(
+        #     -self.size.getX()*0.5*self.cubeformer.spacing,
+        #     -self.size.getY()*0.5*self.cubeformer.spacing,
+        #     -self.size.getZ()*0.5*self.cubeformer.spacing)
 
         self.winCreator.pipelineSwitcher.AddModelWithShaderGeneralName(self.geomPath, "assets/shaders/planets/planet")
         self.geomPath.set_shader_input('vertexBufferEdge', self.edgeVertexBuffer)