RampantTrackGeneration 0.0.1.0.0__tar.gz

rampanttrackgeneration-0.0.1.0.0/PKG-INFO

@@ -0,0 +1,18 @@
+Metadata-Version: 2.4
+Name: RampantTrackGeneration
+Version: 0.0.1.0.0
+Summary: Rampant on the Tracks's Track generation logic, leveraging Voronout and optimized for a web service.
+Project-URL: Homepage, https://github.com/jpshankar/RampantTrackGeneration
+Project-URL: Issues, https://github.com/jpshankar/RampantTrackGeneration/issues
+Author-email: Javas Shankar <javasshankar@gmail.com>
+License-Expression: MIT
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.13
+Requires-Dist: flask
+Requires-Dist: networkx
+Requires-Dist: numpy
+Requires-Dist: voronout
+Description-Content-Type: text/markdown
+
+RampantTrackGeneration

rampanttrackgeneration-0.0.1.0.0/README.md

@@ -0,0 +1 @@
+RampantTrackGeneration

rampanttrackgeneration-0.0.1.0.0/TrackGenerationDemo.py

@@ -0,0 +1,57 @@
+from math import floor
+
+from matplotlib import pyplot, patches
+
+from RampantTrackGeneration import TrackGenerator
+
+baseWidth = 600
+baseHeight = 600
+
+numWalkers = 3
+numDestinations = 3
+
+numRegions = (numWalkers * numDestinations) * 2
+#numRegions = 10
+
+minWinSteps = floor(numRegions / 4)
+#print(f"minWinSteps {minWinSteps}")
+    
+percentToProcess = 0.50
+
+newConnectionAngleMinQuantile = 0.45
+lonelyConnectionMinLengthQuantile = 0.25
+
+connectionEdgeVertexPadding = 0.20
+connectionEdgeNodeBuffer = 0.10
+
+track = TrackGenerator.generateTrack(
+    diagramWidth = baseWidth, 
+    diagramHeight = baseHeight,
+    numWalkersOnTrack = numWalkers,
+    numDestinationsOnTrack = numDestinations,
+    diagramEdgePercentageToProcess = percentToProcess,
+    newConnectionAngleMinQuantile = newConnectionAngleMinQuantile,
+    lonelyConnectionMinLengthQuantile = lonelyConnectionMinLengthQuantile,
+    connectionLengthVertexPadding = connectionEdgeVertexPadding,
+    connectionLengthNodeBuffer = connectionEdgeNodeBuffer
+)
+
+pyplot.figure(0)
+(_, ax) = pyplot.subplots()
+
+for (edge, nodes) in track.stops.items():
+    node0Id = edge.vertex0Id
+    node1Id = edge.vertex1Id
+
+    node0 = track.nodes[node0Id]
+    node1 = track.nodes[node1Id]
+
+    #print(f"drawing figure {edgesNum} {vertex0Id}, {vertex1Id}: {vertex0}, {vertex1}")
+
+    pyplot.plot([node0.x, node1.x], [node0.y, node1.y])
+
+    for node in nodes:
+        nodeCircle = patches.Circle(xy = (node.x, node.y), radius = 1.5, color = 'black')
+        ax.add_patch(nodeCircle)
+
+pyplot.show()

rampanttrackgeneration-0.0.1.0.0/pyproject.toml

@@ -0,0 +1,29 @@
+[build-system]
+requires = ["hatchling >= 1.26"]
+build-backend = "hatchling.build"
+
+[project]
+name = "RampantTrackGeneration"
+version = "0.0.1.0.0"
+authors = [
+  { name="Javas Shankar", email="javasshankar@gmail.com" },
+]
+description = "Rampant on the Tracks's Track generation logic, leveraging Voronout and optimized for a web service."
+readme = "README.md"
+requires-python = ">=3.13"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Operating System :: OS Independent",
+]
+license = "MIT"
+license-files = ["LICEN[CS]E*"]
+dependencies = [
+  "flask",
+  "networkx",
+  "numpy",
+  "Voronout",
+]
+
+[project.urls]
+Homepage = "https://github.com/jpshankar/RampantTrackGeneration"
+Issues = "https://github.com/jpshankar/RampantTrackGeneration/issues"

rampanttrackgeneration-0.0.1.0.0/src/RampantTrackGeneration/Track.py

@@ -0,0 +1,13 @@
+from dataclasses import dataclass
+
+from .edges.data import EdgeVertexInfo
+
+from uuid import uuid4
+
+from voronout.Point import Point
+
+@dataclass(frozen=True)
+class Track:
+    nodes: dict[uuid4, Point]
+    stops: dict[EdgeVertexInfo, tuple[Point]]
+    edges: tuple[EdgeVertexInfo]

rampanttrackgeneration-0.0.1.0.0/src/RampantTrackGeneration/TrackGenerator.py

@@ -0,0 +1,326 @@
+from .edges.data import EdgesMakingAngle, EdgeVertexInfo
+
+from .edges.Ops import Ops as EdgesOps
+from .graphs.Ops import Ops as GraphOps
+
+from math import floor
+
+from networkx import Graph, all_node_cuts as networkXAllNodeCuts
+
+from voronout.Point import Point
+from voronout.VoronoiDiagram import VoronoiDiagram
+
+from .Track import Track
+
+import numpy
+import random
+
+from uuid import uuid4
+
+class TrackGenerator:
+    @staticmethod
+    def _edgeAngleViability(angle: float, minAcceptableAngle: float) -> bool:
+        # neither angle nor its complement should be < minAcceptableAngle
+        return angle >= minAcceptableAngle and (180 - angle) >= minAcceptableAngle
+    
+    @staticmethod
+    def _calculateEdgeAnglesWithGraphVertexEdges(graph: Graph, edge: EdgeVertexInfo, vertexId: uuid4) -> dict[EdgesMakingAngle, float]:
+        vertexNeighborIds = graph.neighbors(n = vertexId)
+        vertexEdgesMakingAngles = []
+        for vertexNeighborId in vertexNeighborIds:
+            otherEdge = EdgeVertexInfo(vertex0Id = vertexId, vertex1Id = vertexNeighborId)
+            edgesMakingAngle = EdgesMakingAngle(edge0 = edge, edge1 = otherEdge)
+            vertexEdgesMakingAngles.append(edgesMakingAngle)
+
+        return EdgesOps.calculateEdgeAnglesWithExtantVertexEdges(edgeGraph = graph, edgesMakingAngles = tuple(vertexEdgesMakingAngles))
+
+    @staticmethod
+    def _findPossibleViableConnection(graph: Graph, possibleConnections: tuple[EdgeVertexInfo], minAcceptableAngle: float) -> EdgeVertexInfo:
+        possibleViableConnections = []
+        for possibleConnection in possibleConnections:
+            zeroConnections = TrackGenerator._calculateEdgeAnglesWithGraphVertexEdges(graph = graph, edge = possibleConnection, vertexId = possibleConnection.vertex0Id)
+            oneConnections = TrackGenerator._calculateEdgeAnglesWithGraphVertexEdges(graph = graph, edge = possibleConnection, vertexId = possibleConnection.vertex1Id)
+
+            allZeroConnectionsValid = all((TrackGenerator._edgeAngleViability(angle = angle, minAcceptableAngle = minAcceptableAngle) for angle in zeroConnections.values()))
+            allOneConnectionsValid = all((TrackGenerator._edgeAngleViability(angle = angle, minAcceptableAngle = minAcceptableAngle) for angle in oneConnections.values()))
+
+            if allZeroConnectionsValid and allOneConnectionsValid:
+                possibleViableConnections.append(possibleConnection)
+
+        return random.choice(possibleViableConnections) if possibleViableConnections else None
+    
+    @staticmethod
+    def _updateVertexPotentialConnections(existingConnectionsGraph: Graph, potentialConnectionsGraph: Graph, vertexToUpdateId: uuid4): 
+        verticesConnectedTo = existingConnectionsGraph.neighbors(n = vertexToUpdateId)
+        potentialConnectingVertexIds = tuple((potentialConnectingVertexId for potentialConnectingVertexId in existingConnectionsGraph.nodes if potentialConnectingVertexId not in verticesConnectedTo and potentialConnectingVertexId != vertexToUpdateId))
+
+        vertexToUpdate = existingConnectionsGraph.nodes[vertexToUpdateId]
+        GraphOps.addVertexToGraph(graph = potentialConnectionsGraph, vertexId = vertexToUpdateId, vertexX = vertexToUpdate["x"], vertexY = vertexToUpdate["y"])
+        
+        for potentialConnectingVertexId in potentialConnectingVertexIds:
+            potentialConnectionVertex = existingConnectionsGraph.nodes[potentialConnectingVertexId]
+            GraphOps.addVertexToGraph(graph = existingConnectionsGraph, vertexId = potentialConnectingVertexId, vertexX = potentialConnectionVertex["x"], vertexY = potentialConnectionVertex["y"])
+
+            potentialConnection = EdgeVertexInfo(vertex0Id = vertexToUpdateId, vertex1Id = potentialConnectingVertexId)
+            
+            potentialConnectionP1 = Point(x = vertexToUpdate["x"], y = vertexToUpdate["y"])
+            potentialConnectionP2 = Point(x = potentialConnectionVertex["x"], y = potentialConnectionVertex["y"])
+
+            potentialConnectionDistance = GraphOps.scaledGraphPointDistance(graph = potentialConnectionsGraph, p1 = potentialConnectionP1, p2 = potentialConnectionP2)
+
+            GraphOps.addConnectionToGraph(graph = potentialConnectionsGraph, connection = potentialConnection, vertexDistance = potentialConnectionDistance)
+
+    @staticmethod
+    def _pruneIntersectionEdgesFromExistingConnectionsGraph(existingConnectionsGraph: Graph, intersectionEdges: tuple[EdgeVertexInfo]):
+        existingConnectionsNodeCutSets = networkXAllNodeCuts(G = existingConnectionsGraph)
+        nodesThatWouldDisconnect = set()
+
+        for existingConnectionNodeCutSet in existingConnectionsNodeCutSets:
+            for existingConnectionNodeCut in existingConnectionNodeCutSet:
+                nodesThatWouldDisconnect.add(existingConnectionNodeCut)
+
+        safeToRemoveEdges = tuple((intersectionEdge for intersectionEdge in intersectionEdges if intersectionEdge.vertex0Id not in nodesThatWouldDisconnect and intersectionEdge.vertex1Id not in nodesThatWouldDisconnect))
+
+        for safeToRemoveEdge in safeToRemoveEdges:
+            safeToRemoveEdgeLength = GraphOps.graphEdgeLength(graph = existingConnectionsGraph, edge = safeToRemoveEdge)
+            (disconnectedVertex0, disconnectedVertex1) = GraphOps.removeEdgeAndReturnDisconnected(edgeGraph = existingConnectionsGraph, existingEdge = safeToRemoveEdge)
+            if len(disconnectedVertex0) > 0 or len(disconnectedVertex1) > 0:
+                # Need to disconnect/reconnect like this because refreshing existingConnectionsNodeCutSets after every removal is too expensive
+                existingConnectionsGraph.add_edge(u_of_edge = safeToRemoveEdge.vertex0Id, v_of_edge = safeToRemoveEdge.vertex1Id, edgeLength = safeToRemoveEdgeLength)
+
+    @staticmethod
+    def _handleLonelyExistingConnections(existingConnectionsGraph: Graph, lonelyConnectionMinLengthQuantile: float):
+        existingConnectionsEdgeLengthMapping = {}
+        for (ev0Id, ev1Id) in existingConnectionsGraph.edges:
+            existingConnectionEdgeInfo = EdgeVertexInfo(vertex0Id = ev0Id, vertex1Id = ev1Id)
+            existingConnectionsEdgeLengthMapping[existingConnectionEdgeInfo] = GraphOps.graphEdgeLength(graph = existingConnectionsGraph, edge = existingConnectionEdgeInfo)
+
+        existingConnectionEdgeMinQuantile = numpy.quantile(tuple(existingConnectionsEdgeLengthMapping.values()), lonelyConnectionMinLengthQuantile)
+
+        for (existingConnectionEdgeInfo, existingConnectionEdgeLength) in existingConnectionsEdgeLengthMapping.items():
+            existingEdgeVertex0Id = existingConnectionEdgeInfo.vertex0Id
+            existingEdgeVertex1Id = existingConnectionEdgeInfo.vertex1Id
+
+            zeroNeighbors = tuple(existingConnectionsGraph.neighbors(existingEdgeVertex0Id))
+            oneNeighbors = tuple(existingConnectionsGraph.neighbors(existingEdgeVertex1Id))
+
+            if not len(zeroNeighbors) > 1 or not len(oneNeighbors) > 1:
+                if existingConnectionEdgeLength < existingConnectionEdgeMinQuantile:
+                    existingConnectionsGraph.remove_edge(u = existingEdgeVertex0Id, v = existingEdgeVertex1Id)
+
+    # https://math.stackexchange.com/questions/134112/find-a-point-on-a-line-segment-located-at-a-distance-d-from-one-endpoint
+    @staticmethod
+    def _generateStopsOnConnection(connectionGraph: Graph, connection: EdgeVertexInfo, connectionLengthVertexPadding: float, connectionLengthNodeBuffer: float) -> tuple[Point]:
+        connectionVertexZeroId = connection.vertex0Id
+        connectionVertexZero = connectionGraph.nodes[connectionVertexZeroId]
+
+        connectionVertexOneId = connection.vertex1Id
+        connectionVertexOne = connectionGraph.nodes[connectionVertexOneId]
+
+        zeroIsFirstVertex = connectionVertexZero["x"] < connectionVertexOne["x"]
+
+        firstVertex = connectionVertexZero if zeroIsFirstVertex else connectionVertexOne
+        secondVertex = connectionVertexZero if not zeroIsFirstVertex else connectionVertexOne
+
+        connectionLength = GraphOps.graphEdgeLength(graph = connectionGraph, edge = connection)
+
+        connectionXRangeMinInterval = (connectionLengthVertexPadding + connectionLengthNodeBuffer) * connectionLength
+        connectionXRangeMaxInterval = connectionLength - connectionXRangeMinInterval
+
+        connectionNodes = []
+
+        while connectionXRangeMinInterval < connectionXRangeMaxInterval:
+            d = random.uniform(connectionXRangeMinInterval, connectionXRangeMaxInterval)        
+            td = d / connectionLength
+
+            nextX = firstVertex["x"] + ((secondVertex["x"] - firstVertex["x"]) * td)
+            nextY = firstVertex["y"] + ((secondVertex["y"] - firstVertex["y"]) * td)
+            
+            nextPoint = Point(x = nextX, y = nextY)
+            connectionNodes.append(nextPoint)
+
+            connectionXRangeMinInterval = d + (connectionLengthNodeBuffer * connectionLength)
+        
+        return tuple(connectionNodes)
+                
+    @staticmethod
+    def generateTrack(
+        diagramWidth: int,
+        diagramHeight: int,
+        numWalkersOnTrack: int,
+        numDestinationsOnTrack: int,
+        diagramEdgePercentageToProcess: float, 
+        newConnectionAngleMinQuantile: float, 
+        lonelyConnectionMinLengthQuantile: float, 
+        connectionLengthVertexPadding: float, 
+        connectionLengthNodeBuffer: float
+    ) -> Track:
+        numVoronoiDiagramRegions = (numWalkersOnTrack * numDestinationsOnTrack) * 2
+
+        diagramRegionSites = tuple((Point(x = random.random(), y = random.random()) for _ in range(numVoronoiDiagramRegions)))
+
+        voronoiDiagram = VoronoiDiagram(basePoints = diagramRegionSites, planeWidth = diagramWidth, planeHeight = diagramHeight)
+
+        voronoiDiagramEdgesToProcess = []
+        for voronoiDiagramEdge in voronoiDiagram.diagramEdges:
+            edge = EdgeVertexInfo(vertex0Id = voronoiDiagramEdge.vertex0Id, vertex1Id = voronoiDiagramEdge.vertex1Id)
+            if edge not in voronoiDiagramEdgesToProcess:
+                voronoiDiagramEdgesToProcess.append(edge)
+
+        voronoiDiagramEdges = tuple(voronoiDiagramEdgesToProcess)
+
+        voronoiVertices = voronoiDiagram.vertices
+
+        existingConnections = Graph(width = diagramWidth, height = diagramHeight)
+        potentialConnections = Graph(width = diagramWidth, height = diagramHeight)
+
+        for vertexId in voronoiVertices.keys():
+            edgesWithVertex = set((maybeEdgeWithPoint for maybeEdgeWithPoint in voronoiDiagramEdges if maybeEdgeWithPoint.vertex0Id == vertexId or maybeEdgeWithPoint.vertex1Id == vertexId))
+            
+            if not len(edgesWithVertex) > 0:
+                print(f"discarding {vertexId}")
+                pass
+            
+            for edgeWithPoint in edgesWithVertex:
+                pointEdgeVertex0Id = edgeWithPoint.vertex0Id
+                pointEdgeVertex0 = voronoiVertices[pointEdgeVertex0Id]
+
+                pointEdgeVertex1Id = edgeWithPoint.vertex1Id
+                pointEdgeVertex1 = voronoiVertices[pointEdgeVertex1Id]
+
+                GraphOps.addVertexToGraph(graph = existingConnections, vertexId = pointEdgeVertex0Id, vertexX = pointEdgeVertex0.x, vertexY = pointEdgeVertex0.y)
+                GraphOps.addVertexToGraph(graph = existingConnections, vertexId = pointEdgeVertex1Id, vertexX = pointEdgeVertex1.x, vertexY = pointEdgeVertex1.y)
+
+                pointEdgeVertexDistance = GraphOps.scaledGraphPointDistance(graph = existingConnections, p1 = pointEdgeVertex0, p2 = pointEdgeVertex1)
+                GraphOps.addConnectionToGraph(graph = existingConnections, connection = edgeWithPoint, vertexDistance = pointEdgeVertexDistance)
+
+        existingEdgeVertexAngles = {}
+
+        for (vertex0Id, vertex1Id) in existingConnections.edges:
+            existingEdge = EdgeVertexInfo(vertex0Id = vertex0Id, vertex1Id = vertex1Id)
+
+            vertex0EdgeAngles = TrackGenerator._calculateEdgeAnglesWithGraphVertexEdges(graph = existingConnections, edge = existingEdge, vertexId = vertex0Id)
+            for vertex0AngleEdges in vertex0EdgeAngles:
+                if vertex0AngleEdges not in existingEdgeVertexAngles:
+                    existingEdgeVertexAngles[vertex0AngleEdges] = vertex0EdgeAngles[vertex0AngleEdges]
+
+            vertex1EdgeAngles = TrackGenerator._calculateEdgeAnglesWithGraphVertexEdges(graph = existingConnections, edge = existingEdge, vertexId = vertex1Id)
+            for vertex1AngleEdges in vertex1EdgeAngles:
+                if vertex1AngleEdges not in existingEdgeVertexAngles:
+                    existingEdgeVertexAngles[vertex1AngleEdges] = vertex1EdgeAngles[vertex1AngleEdges]
+
+        initialDiagramEdgeAngles = tuple(existingEdgeVertexAngles.values())
+        initialDiagramMinAcceptableAngle = numpy.quantile(a = initialDiagramEdgeAngles, q = newConnectionAngleMinQuantile)
+
+        for vertexId in existingConnections.nodes:
+            TrackGenerator._updateVertexPotentialConnections(existingConnectionsGraph = existingConnections, potentialConnectionsGraph = potentialConnections, vertexToUpdateId = vertexId)
+
+        diagramEdgesSorted = sorted(voronoiDiagramEdges, key = lambda vde: GraphOps.graphEdgeLength(graph = existingConnections, edge = vde))
+        numDiagramEdgesToProcess = floor(len(diagramEdgesSorted) * diagramEdgePercentageToProcess)
+
+        diagramEdgesToProcess = diagramEdgesSorted[:numDiagramEdgesToProcess]
+
+        intersectionEdges = []
+
+        for diagramEdgeToProcess in diagramEdgesToProcess:
+            edgeVertex0Id = diagramEdgeToProcess.vertex0Id
+            edgeVertex1Id = diagramEdgeToProcess.vertex1Id
+
+            if existingConnections.has_edge(u = edgeVertex0Id, v = edgeVertex1Id):
+                edgeToProcessLength = GraphOps.graphEdgeLength(graph = existingConnections, edge = diagramEdgeToProcess)
+
+                (disconnectedByDeletionVertex0, disconnectedByDeletionVertex1) = GraphOps.removeEdgeAndReturnDisconnected(edgeGraph = existingConnections, existingEdge = diagramEdgeToProcess)
+                possibleConnections = []
+
+                for vertexDisconnected0 in disconnectedByDeletionVertex0:
+                    for vertexDisconnected1 in disconnectedByDeletionVertex1:
+                        connectionAlreadyAdded = existingConnections.has_edge(u = vertexDisconnected0, v = vertexDisconnected1)
+
+                        if not connectionAlreadyAdded:
+                            potentialConnection = EdgeVertexInfo(vertex0Id = vertexDisconnected0, vertex1Id = vertexDisconnected1)
+                            
+                            if GraphOps.graphEdgeLength(graph = potentialConnections, edge = potentialConnection) > edgeToProcessLength:
+                                possibleConnections.append(potentialConnection)
+
+                maybeViableConnection = TrackGenerator._findPossibleViableConnection(graph = existingConnections, possibleConnections = tuple(possibleConnections), minAcceptableAngle = initialDiagramMinAcceptableAngle)
+
+                if maybeViableConnection:
+                    print(f"reconnecting to {maybeViableConnection}")
+                    maybeViableVertexLength = GraphOps.graphEdgeLength(graph = potentialConnections, edge = maybeViableConnection) 
+
+                    maybeViableVertex0Id = maybeViableConnection.vertex0Id
+                    maybeViableVertex1Id = maybeViableConnection.vertex1Id
+
+                    potentialConnections.remove_edge(u = maybeViableVertex0Id, v = maybeViableVertex1Id)
+                    
+                    # calculate intersections
+                    potentialIntersections = tuple((EdgeVertexInfo(vertex0Id = vertex0Id, vertex1Id = vertex1Id) for (vertex0Id, vertex1Id) in existingConnections.edges if (vertex0Id != maybeViableVertex0Id and vertex0Id != maybeViableVertex1Id) and (vertex1Id != maybeViableVertex0Id and vertex1Id != maybeViableVertex1Id)))
+                    edgeIntersectionsInfo = EdgesOps.calculateEdgesIntersectionInfo(edgeGraph = existingConnections, intersectingEdge = maybeViableConnection, otherEdges = potentialIntersections)
+                                            
+                    if edgeIntersectionsInfo:
+                        # We expect this to be sorted along the v0 -> v1 path.
+                        precedingVertexId = maybeViableVertex0Id
+                        precedingVertex = GraphOps.graphVertex(graph = existingConnections, vertexId = maybeViableVertex0Id)
+
+                        for edgeIntersectionInfo in edgeIntersectionsInfo:
+                            edgeIntersectionPoint = edgeIntersectionInfo.intersectionPoint
+                            distanceToIntersection = GraphOps.scaledGraphPointDistance(graph = existingConnections, p1 = precedingVertex, p2 = edgeIntersectionPoint)
+
+                            edgeIntersectionPointId = uuid4()
+                            print(f"creating intersection point {edgeIntersectionPointId}")
+
+                            existingConnections.add_node(node_for_adding = edgeIntersectionPointId, x = edgeIntersectionPoint.x, y = edgeIntersectionPoint.y)
+
+                            existingConnections.add_edge(u_of_edge = precedingVertexId, v_of_edge = edgeIntersectionPointId, edgeLength = distanceToIntersection)
+                            intersectionEdges.append(EdgeVertexInfo(vertex0Id = precedingVertexId, vertex1Id = edgeIntersectionPointId))
+
+                            edgeIntersected = edgeIntersectionInfo.intersectedEdge
+
+                            edgeIntersectedVertex0Id = edgeIntersected.vertex0Id
+                            edgeIntersectedVertex1Id = edgeIntersected.vertex1Id
+                            
+                            print(f"handling intersected edge {edgeIntersectedVertex0Id}, {edgeIntersectedVertex1Id}")
+                            
+                            edgeIntersectedVertex0 = GraphOps.graphVertex(graph = existingConnections, vertexId = edgeIntersectedVertex0Id)
+                            edgeIntersectedVertex1 = GraphOps.graphVertex(graph = existingConnections, vertexId = edgeIntersectedVertex1Id)
+
+                            iv0DistanceToIntersection = GraphOps.scaledGraphPointDistance(graph = existingConnections, p1 = edgeIntersectedVertex0, p2 = edgeIntersectionPoint)
+                            iv1DistanceToIntersection = GraphOps.scaledGraphPointDistance(graph = existingConnections, p1 = edgeIntersectionPoint, p2 = edgeIntersectedVertex1)
+
+                            existingConnections.remove_edge(u = edgeIntersectedVertex0Id, v = edgeIntersectedVertex1Id)
+                            if edgeIntersected in intersectionEdges:
+                                intersectionEdges.remove(edgeIntersected)
+
+                            existingConnections.add_edge(u_of_edge = edgeIntersectedVertex0Id, v_of_edge = edgeIntersectionPointId, edgeLength = iv0DistanceToIntersection)
+                            intersectionEdges.append(EdgeVertexInfo(vertex0Id = edgeIntersectedVertex0Id, vertex1Id = edgeIntersectionPointId))
+
+                            existingConnections.add_edge(u_of_edge = edgeIntersectionPointId, v_of_edge = edgeIntersectedVertex1Id, edgeLength = iv1DistanceToIntersection)
+                            intersectionEdges.append(EdgeVertexInfo(vertex0Id = edgeIntersectionPointId, vertex1Id = edgeIntersectedVertex1Id))
+
+                            TrackGenerator._updateVertexPotentialConnections(existingConnectionsGraph = existingConnections, potentialConnectionsGraph = potentialConnections, vertexToUpdateId = edgeIntersectionPointId)
+
+                            precedingVertexId = edgeIntersectionPointId
+                            precedingVertex = edgeIntersectionPoint
+
+                        # finish up with precedingVertex (last intersection point) -> vertex1
+                        maybeViableVertex1 = GraphOps.graphVertex(graph = existingConnections, vertexId = maybeViableVertex1Id)
+
+                        distanceToEnd = GraphOps.scaledGraphPointDistance(graph = existingConnections, p1 = precedingVertex, p2 = maybeViableVertex1)
+
+                        existingConnections.add_edge(u_of_edge = precedingVertexId, v_of_edge = maybeViableVertex1Id, edgeLength = distanceToEnd)
+                        intersectionEdges.append(EdgeVertexInfo(vertex0Id = precedingVertexId, vertex1Id = maybeViableVertex1Id))
+                    else:
+                        existingConnections.add_edge(u_of_edge = maybeViableVertex0Id, v_of_edge = maybeViableVertex1Id, edgeLength = maybeViableVertexLength)
+                else:
+                    print(f"skipping edge {diagramEdgesToProcess}")
+
+        TrackGenerator._pruneIntersectionEdgesFromExistingConnectionsGraph(existingConnectionsGraph = existingConnections, intersectionEdges = intersectionEdges)
+        TrackGenerator._handleLonelyExistingConnections(existingConnectionsGraph = existingConnections, lonelyConnectionMinLengthQuantile = lonelyConnectionMinLengthQuantile)
+
+        edges = tuple((EdgeVertexInfo(vertex0Id = vertex0Id, vertex1Id = vertex1Id) for (vertex0Id, vertex1Id) in existingConnections.edges))
+        
+        stops = { edge: TrackGenerator._generateStopsOnConnection(connectionGraph = existingConnections, connection = edge, connectionLengthVertexPadding = connectionLengthVertexPadding, connectionLengthNodeBuffer = connectionLengthNodeBuffer) for edge in edges}
+        
+        nodes = { nodeId: GraphOps.graphVertex(graph = existingConnections, vertexId = nodeId) for nodeId in existingConnections.nodes}
+
+        return Track(nodes = nodes, stops = stops, edges = edges)

rampanttrackgeneration-0.0.1.0.0/src/RampantTrackGeneration/__init__.py

@@ -0,0 +1,2 @@
+from .Track import Track
+from .TrackGenerator import TrackGenerator

rampanttrackgeneration-0.0.1.0.0/src/RampantTrackGeneration/edges/Ops.py

@@ -0,0 +1,87 @@
+from .data import EdgesMakingAngle, EdgeIntersectionInfo, EdgeVertexInfo
+
+from ..graphs.Ops import Ops as GraphOps
+
+from math import atan, degrees
+
+from networkx import Graph
+
+from voronout.Point import Point
+
+class Ops:
+    @staticmethod
+    def _edgeSlope(edgePoint1: Point, edgePoint2: Point) -> float:
+        if edgePoint2.x == edgePoint1.x:
+            return 0.0
+        else:
+            return (edgePoint2.y - edgePoint1.y)/(edgePoint2.x - edgePoint1.x)
+        
+    @staticmethod
+    def _angleBetweenEdges(edgeGraph: Graph, edge0: EdgeVertexInfo, edge1: EdgeVertexInfo) -> float:
+        edge0Slope = Ops._edgeSlope(edgePoint1 = GraphOps.graphVertex(graph = edgeGraph, vertexId = edge0.vertex0Id), edgePoint2 = GraphOps.graphVertex(graph = edgeGraph, vertexId = edge0.vertex1Id))
+        edge1Slope = Ops._edgeSlope(edgePoint1 = GraphOps.graphVertex(graph = edgeGraph, vertexId = edge1.vertex0Id), edgePoint2 = GraphOps.graphVertex(graph = edgeGraph, vertexId = edge1.vertex1Id))
+
+        slopeNumerator = edge0Slope - edge1Slope
+        slopeDenominator = 1 + (edge0Slope * edge1Slope)
+
+        return degrees(atan(abs(slopeNumerator / slopeDenominator)))
+    
+    @staticmethod
+    def _calculateEdgeAngles(edgeGraph: Graph, angleEdges: EdgesMakingAngle) -> float:
+        return Ops._angleBetweenEdges(edgeGraph = edgeGraph, edge0 = angleEdges.edge0, edge1 = angleEdges.edge1)
+
+    def calculateEdgeAnglesWithExtantVertexEdges(edgeGraph: Graph, edgesMakingAngles: tuple[EdgesMakingAngle]) -> dict[EdgesMakingAngle, float]:
+        return { edgesMakingAngle: Ops._calculateEdgeAngles(edgeGraph = edgeGraph, angleEdges = edgesMakingAngle) for edgesMakingAngle in edgesMakingAngles }
+    
+    # https://en.wikipedia.org/wiki/Line%E2%80%93line_intersection#Given_two_points_on_each_line
+    @staticmethod
+    def _calculateEdgeIntersectionInfo(edgeGraph: Graph, intersectingEdge: EdgeVertexInfo, intersectedEdge: EdgeVertexInfo) -> EdgeIntersectionInfo:
+        intersectingVertex0 = GraphOps.graphVertex(graph = edgeGraph, vertexId = intersectingEdge.vertex0Id)
+        intersectingVertex1 = GraphOps.graphVertex(graph = edgeGraph, vertexId = intersectingEdge.vertex1Id)
+
+        intersectedVertex0 = GraphOps.graphVertex(graph = edgeGraph, vertexId = intersectedEdge.vertex0Id)
+        intersectedVertex1 = GraphOps.graphVertex(graph = edgeGraph, vertexId = intersectedEdge.vertex1Id)
+
+        x1dx3 = intersectingVertex0.x - intersectedVertex0.x
+        y3dy4 = intersectedVertex0.y - intersectedVertex1.y
+
+        y1dy3 = intersectingVertex0.y - intersectedVertex0.y
+        x3dx4 = intersectedVertex0.x - intersectedVertex1.x
+
+        x1dx2 = intersectingVertex0.x - intersectingVertex1.x
+        y1dy2 = intersectingVertex0.y - intersectingVertex1.y
+
+        denominator = (x1dx2 * y3dy4) - (y1dy2 * x3dx4)
+
+        if denominator != 0.0:
+            tNumerator = (x1dx3 * y3dy4) - (y1dy3 * x3dx4)
+            t = tNumerator / denominator
+
+            uNumerator = (x1dx2 * y1dy3) - (y1dy2 * x1dx3)
+            u = -(uNumerator / denominator)
+
+            if 0 <= t <= 1 and 0 <= u <= 1:
+                intersectionX = intersectingVertex0.x + (t * -x1dx2)
+                intersectionY = intersectingVertex0.y + (t * -y1dy2)
+
+                intersectionPoint = Point(x = intersectionX, y = intersectionY)
+                return EdgeIntersectionInfo(intersectionPoint = intersectionPoint, intersectedEdge = intersectedEdge)
+            else:
+                return None
+        else:
+            return None
+    
+    @staticmethod
+    def calculateEdgesIntersectionInfo(edgeGraph: Graph, intersectingEdge: EdgeVertexInfo, otherEdges: tuple[EdgeVertexInfo]) -> tuple[EdgeIntersectionInfo]:
+        edgeIntersectionData = []
+        for otherEdge in otherEdges:
+            edgeIntersectionInfo = Ops._calculateEdgeIntersectionInfo(edgeGraph = edgeGraph, intersectingEdge = intersectingEdge, intersectedEdge = otherEdge)
+            if edgeIntersectionInfo:
+                edgeIntersectionData.append(edgeIntersectionInfo)
+
+        intersectingVertex0Id = intersectingEdge.vertex0Id
+        intersectingVertex0 = GraphOps.graphVertex(graph = edgeGraph, vertexId = intersectingVertex0Id)
+
+        edgeIntersectionData.sort(key = lambda eii: GraphOps.scaledGraphPointDistance(graph = edgeGraph, p1 = intersectingVertex0, p2 = eii.intersectionPoint))
+
+        return edgeIntersectionData

rampanttrackgeneration-0.0.1.0.0/src/RampantTrackGeneration/edges/__init__.py

@@ -0,0 +1 @@
+from .Ops import Ops

rampanttrackgeneration-0.0.1.0.0/src/RampantTrackGeneration/edges/data/EdgeIntersectionInfo.py

@@ -0,0 +1,10 @@
+from dataclasses import dataclass
+
+from .EdgeVertexInfo import EdgeVertexInfo
+
+from voronout.Point import Point
+
+@dataclass(frozen=True)
+class EdgeIntersectionInfo:
+    intersectionPoint: Point
+    intersectedEdge: EdgeVertexInfo

rampanttrackgeneration-0.0.1.0.0/src/RampantTrackGeneration/edges/data/EdgeVertexInfo.py

@@ -0,0 +1,10 @@
+from dataclasses import dataclass
+from uuid import uuid4
+
+@dataclass(frozen=True)
+class EdgeVertexInfo:
+    vertex0Id: uuid4
+    vertex1Id: uuid4
+
+    def __eq__(self, other) -> bool:
+        return (self.vertex0Id == other.vertex0Id and self.vertex1Id == other.vertex1Id) or (self.vertex0Id == other.vertex1Id and self.vertex1Id == other.vertex0Id)

rampanttrackgeneration-0.0.1.0.0/src/RampantTrackGeneration/edges/data/EdgesMakingAngle.py

@@ -0,0 +1,8 @@
+from dataclasses import dataclass
+
+from .EdgeVertexInfo import EdgeVertexInfo
+
+@dataclass(frozen=True)
+class EdgesMakingAngle:
+    edge0: EdgeVertexInfo
+    edge1: EdgeVertexInfo

rampanttrackgeneration-0.0.1.0.0/src/RampantTrackGeneration/edges/data/__init__.py

@@ -0,0 +1,5 @@
+from .EdgeIntersectionInfo import EdgeIntersectionInfo
+
+from .EdgesMakingAngle import EdgesMakingAngle
+
+from .EdgeVertexInfo import EdgeVertexInfo

rampanttrackgeneration-0.0.1.0.0/src/RampantTrackGeneration/graphs/Ops.py

@@ -0,0 +1,63 @@
+from ..edges.data import EdgeVertexInfo
+
+from networkx import Graph
+from networkx.algorithms import approximation as nxApproximation
+
+from uuid import uuid4
+
+from voronout.Point import Point
+
+class Ops:
+    @staticmethod
+    def graphVertex(graph: Graph, vertexId: uuid4) -> Point:
+        if graph.has_node(n = vertexId):
+            vertex = graph.nodes[vertexId]
+            return Point(x = vertex["x"], y = vertex["y"])
+        else:
+            return None
+        
+    @staticmethod
+    def graphEdgeLength(graph: Graph, edge: EdgeVertexInfo) -> float:
+        return graph.edges[edge.vertex0Id, edge.vertex1Id]["edgeLength"]
+        
+    @staticmethod
+    def scaledGraphPointDistance(graph: Graph, p1: Point, p2: Point):
+        graphWidthScalar = 1 / graph.graph["width"]
+        graphHeightScalar = 1 / graph.graph["height"]
+
+        scaledP1 = p1.scale(widthScalar = graphWidthScalar, heightScalar = graphHeightScalar)
+        scaledP2 = p2.scale(widthScalar = graphWidthScalar, heightScalar = graphHeightScalar)
+
+        return Point.distance(p1 = scaledP1, p2 = scaledP2)
+    
+    @staticmethod
+    def addVertexToGraph(graph: Graph, vertexId: uuid4, vertexX: float, vertexY: float):
+        if not graph.has_node(n = vertexId):
+            graph.add_node(node_for_adding = vertexId, x = vertexX, y = vertexY)
+
+    @staticmethod
+    def addConnectionToGraph(graph: Graph, connection: EdgeVertexInfo, vertexDistance: float):
+        vertex0Id = connection.vertex0Id
+        vertex1Id = connection.vertex1Id
+
+        if not graph.has_edge(u = vertex0Id, v = vertex1Id):
+            graph.add_edge(u_of_edge = vertex0Id, v_of_edge = vertex1Id, edgeLength = vertexDistance)
+
+    @staticmethod
+    def removeEdgeAndReturnDisconnected(edgeGraph: Graph, existingEdge: EdgeVertexInfo) -> tuple[tuple[EdgeVertexInfo]]:
+        existingEdgeVertex0Id = existingEdge.vertex0Id
+        existingEdgeVertex1Id = existingEdge.vertex1Id
+
+        beforeExistingConnectivities = nxApproximation.all_pairs_node_connectivity(G = edgeGraph)
+
+        vertex0ConnectivityBeforeDeletion = beforeExistingConnectivities[existingEdgeVertex0Id]
+        vertex1ConnectivityBeforeDeletion = beforeExistingConnectivities[existingEdgeVertex1Id]
+
+        edgeGraph.remove_edge(u = existingEdgeVertex0Id, v = existingEdgeVertex1Id)
+        afterExistingConnectivities = nxApproximation.all_pairs_node_connectivity(G = edgeGraph)
+
+        disconnectedByDeletionVertex0 = tuple((maybeDisconnectedVertex for (maybeDisconnectedVertex, numConnectionsLeft) in afterExistingConnectivities[existingEdgeVertex0Id].items() if numConnectionsLeft == 0 and vertex0ConnectivityBeforeDeletion[maybeDisconnectedVertex] > 0))
+        disconnectedByDeletionVertex1 = tuple((maybeDisconnectedVertex for (maybeDisconnectedVertex, numConnectionsLeft) in afterExistingConnectivities[existingEdgeVertex1Id].items() if numConnectionsLeft == 0 and vertex1ConnectivityBeforeDeletion[maybeDisconnectedVertex] > 0))
+
+        return (disconnectedByDeletionVertex0, disconnectedByDeletionVertex1)
+

rampanttrackgeneration-0.0.1.0.0/src/RampantTrackGeneration/graphs/__init__.py

@@ -0,0 +1 @@
+from .Ops import Ops

rampanttrackgeneration-0.0.1.0.0/src/RampantTrackGeneration/json/flask/JSON.py

@@ -0,0 +1,24 @@
+from flask.json.provider import DefaultJSONProvider
+
+from ... import Track
+
+from uuid import UUID
+
+from voronout.Point import Point
+
+class FlaskRampantTrackGenerationJSONProvider(DefaultJSONProvider):
+    def _handlePointDict(self, pointDict: dict[UUID, Point]) -> dict[str, dict[str, float]]:
+        return {str(key): self.loads(repr(value)) for (key, value) in pointDict.items()}
+        
+
+    def dumps(self, obj, **kw):
+        if isinstance(obj, Track):
+            stopObj = {self.loads(repr(stopLine)): list((self.loads(repr(lineStop)) for lineStop in lineStops)) for (stopLine, lineStops) in obj.stops.items()}
+            
+            return {
+                'nodes': self._handlePointDict(obj.nodes),
+                'stops': stopObj,
+                'edges': list(stopObj.values())
+            }
+        else:
+            return super().dumps(obj, **kw)

rampanttrackgeneration-0.0.1.0.0/src/RampantTrackGeneration/json/flask/__init__.py

@@ -0,0 +1 @@
+from .JSON import FlaskRampantTrackGenerationJSONProvider