diff --git a/.buildinfo b/.buildinfo index b3aede5..c30db9b 100644 --- a/.buildinfo +++ b/.buildinfo @@ -1,4 +1,4 @@ # Sphinx build info version 1 # This file hashes the configuration used when building these files. When it is not found, a full rebuild will be done. -config: 3c7cbc2567366b70bfa993aea4e8883c +config: f7d25218f9a02756d96ec1b9e14444fd tags: 645f666f9bcd5a90fca523b33c5a78b7 diff --git a/.doctrees/CHANGELOG.doctree b/.doctrees/CHANGELOG.doctree index 724e7a4..90003d0 100644 Binary files a/.doctrees/CHANGELOG.doctree and b/.doctrees/CHANGELOG.doctree differ diff --git a/.doctrees/environment.pickle b/.doctrees/environment.pickle index 3adc3b9..5275de1 100644 Binary files a/.doctrees/environment.pickle and b/.doctrees/environment.pickle differ diff --git a/.doctrees/pathfinding3d.core.diagonal_movement.doctree b/.doctrees/pathfinding3d.core.diagonal_movement.doctree new file mode 100644 index 0000000..2e3f717 Binary files /dev/null and b/.doctrees/pathfinding3d.core.diagonal_movement.doctree differ diff --git a/.doctrees/pathfinding3d.core.doctree b/.doctrees/pathfinding3d.core.doctree index 16be487..aed8fbd 100644 Binary files a/.doctrees/pathfinding3d.core.doctree and b/.doctrees/pathfinding3d.core.doctree differ diff --git a/.doctrees/pathfinding3d.core.grid.doctree b/.doctrees/pathfinding3d.core.grid.doctree new file mode 100644 index 0000000..bfa4731 Binary files /dev/null and b/.doctrees/pathfinding3d.core.grid.doctree differ diff --git a/.doctrees/pathfinding3d.core.heap.doctree b/.doctrees/pathfinding3d.core.heap.doctree new file mode 100644 index 0000000..ec90e45 Binary files /dev/null and b/.doctrees/pathfinding3d.core.heap.doctree differ diff --git a/.doctrees/pathfinding3d.core.heuristic.doctree b/.doctrees/pathfinding3d.core.heuristic.doctree new file mode 100644 index 0000000..0c775af Binary files /dev/null and b/.doctrees/pathfinding3d.core.heuristic.doctree differ diff --git a/.doctrees/pathfinding3d.core.node.doctree b/.doctrees/pathfinding3d.core.node.doctree new file mode 100644 index 0000000..8afb87d Binary files /dev/null and b/.doctrees/pathfinding3d.core.node.doctree differ diff --git a/.doctrees/pathfinding3d.core.util.doctree b/.doctrees/pathfinding3d.core.util.doctree new file mode 100644 index 0000000..282e387 Binary files /dev/null and b/.doctrees/pathfinding3d.core.util.doctree differ diff --git a/.doctrees/pathfinding3d.core.world.doctree b/.doctrees/pathfinding3d.core.world.doctree new file mode 100644 index 0000000..7459c0b Binary files /dev/null and b/.doctrees/pathfinding3d.core.world.doctree differ diff --git a/.doctrees/pathfinding3d.finder.a_star.doctree b/.doctrees/pathfinding3d.finder.a_star.doctree new file mode 100644 index 0000000..3696b2f Binary files /dev/null and b/.doctrees/pathfinding3d.finder.a_star.doctree differ diff --git a/.doctrees/pathfinding3d.finder.best_first.doctree b/.doctrees/pathfinding3d.finder.best_first.doctree new file mode 100644 index 0000000..adcdaee Binary files /dev/null and b/.doctrees/pathfinding3d.finder.best_first.doctree differ diff --git a/.doctrees/pathfinding3d.finder.bi_a_star.doctree b/.doctrees/pathfinding3d.finder.bi_a_star.doctree new file mode 100644 index 0000000..06ce7ca Binary files /dev/null and b/.doctrees/pathfinding3d.finder.bi_a_star.doctree differ diff --git a/.doctrees/pathfinding3d.finder.breadth_first.doctree b/.doctrees/pathfinding3d.finder.breadth_first.doctree new file mode 100644 index 0000000..fc2b8d3 Binary files /dev/null and b/.doctrees/pathfinding3d.finder.breadth_first.doctree differ diff --git a/.doctrees/pathfinding3d.finder.dijkstra.doctree b/.doctrees/pathfinding3d.finder.dijkstra.doctree new file mode 100644 index 0000000..1674018 Binary files /dev/null and b/.doctrees/pathfinding3d.finder.dijkstra.doctree differ diff --git a/.doctrees/pathfinding3d.finder.doctree b/.doctrees/pathfinding3d.finder.doctree index 2361efe..d6a2fe2 100644 Binary files a/.doctrees/pathfinding3d.finder.doctree and b/.doctrees/pathfinding3d.finder.doctree differ diff --git a/.doctrees/pathfinding3d.finder.finder.doctree b/.doctrees/pathfinding3d.finder.finder.doctree new file mode 100644 index 0000000..1304710 Binary files /dev/null and b/.doctrees/pathfinding3d.finder.finder.doctree differ diff --git a/.doctrees/pathfinding3d.finder.ida_star.doctree b/.doctrees/pathfinding3d.finder.ida_star.doctree new file mode 100644 index 0000000..378160e Binary files /dev/null and b/.doctrees/pathfinding3d.finder.ida_star.doctree differ diff --git a/.doctrees/pathfinding3d.finder.msp.doctree b/.doctrees/pathfinding3d.finder.msp.doctree new file mode 100644 index 0000000..3f78404 Binary files /dev/null and b/.doctrees/pathfinding3d.finder.msp.doctree differ diff --git a/.doctrees/pathfinding3d.finder.theta_star.doctree b/.doctrees/pathfinding3d.finder.theta_star.doctree new file mode 100644 index 0000000..05cc3f8 Binary files /dev/null and b/.doctrees/pathfinding3d.finder.theta_star.doctree differ diff --git a/404.html b/404.html index f2e3f42..f3a6830 100644 --- a/404.html +++ b/404.html @@ -3,28 +3,28 @@ - — pathfinding3d 0.6.1 documentation - - - - - + Page Not Found — pathfinding3d 0.6.2 documentation + + + + + - - - - - - - - - - + + + + + + + + + + @@ -35,14 +35,14 @@ - + pathfinding3d
- 0.6.1 + 0.6.2
-
+ @@ -51,48 +51,49 @@
diff --git a/_modules/pathfinding3d/core/diagonal_movement.html b/_modules/pathfinding3d/core/diagonal_movement.html index 61b5e6c..ef7f625 100644 --- a/_modules/pathfinding3d/core/diagonal_movement.html +++ b/_modules/pathfinding3d/core/diagonal_movement.html @@ -3,7 +3,7 @@ - pathfinding3d.core.diagonal_movement — pathfinding3d 0.6.1 documentation + pathfinding3d.core.diagonal_movement — pathfinding3d 0.6.2 documentation @@ -17,7 +17,7 @@ - + @@ -39,7 +39,7 @@ pathfinding3d
- 0.6.1 + 0.6.2
@@ -76,16 +76,17 @@
  • Change Log
  • pathfinding3d
  • Change Log
  • pathfinding3d
  • Change Log
  • pathfinding3d
  • Change Log
  • pathfinding3d
  • Change Log
  • pathfinding3d
  • Change Log
  • pathfinding3d
  • Change Log
  • pathfinding3d
  • Change Log
  • pathfinding3d
  • Change Log
  • pathfinding3d
  • Change Log
  • pathfinding3d
  • Change Log
  • pathfinding3d
  • Change Log
  • pathfinding3d
  • Change Log
  • pathfinding3d
  • Change Log
  • pathfinding3d
  • Change Log
  • pathfinding3d
  • Change Log
  • pathfinding3d
  • Change Log
  • pathfinding3d
    • @@ -1206,7 +265,7 @@

    Submodules - +
    diff --git a/pathfinding3d.core.node.html b/pathfinding3d.core.node.html new file mode 100644 index 0000000..dd0d502 --- /dev/null +++ b/pathfinding3d.core.node.html @@ -0,0 +1,522 @@ + + + + + + + pathfinding3d.core.node module — pathfinding3d 0.6.2 documentation + + + + + + + + + + + + + + + + + + + + + + + + +
    + + +
    + +
    +
    +
    + +
    +
    +
    +
    + +
    +

    pathfinding3d.core.node module

    +
    +
    +class pathfinding3d.core.node.Node[source]
    +

    Bases: object

    +

    Basic node class, saves calculated values for pathfinding

    +
    +
    +h
    +

    The cost from this node to the goal (for A* including the heuristic).

    +
    +
    Type:
    +

    float

    +
    +
    +
    + +
    +
    +g
    +

    The cost from the start node to this node.

    +
    +
    Type:
    +

    float

    +
    +
    +
    + +
    +
    +f
    +

    The overall cost for a path using this node (f = g + h).

    +
    +
    Type:
    +

    float

    +
    +
    +
    + +
    +
    +opened
    +

    The number of times this node has been opened.

    +
    +
    Type:
    +

    int

    +
    +
    +
    + +
    +
    +closed
    +

    Whether this node is closed.

    +
    +
    Type:
    +

    bool

    +
    +
    +
    + +
    +
    +parent
    +

    The parent node of this node.

    +
    +
    Type:
    +

    Optional[Node]

    +
    +
    +
    + +
    +
    +retain_count
    +

    Used for recursion tracking of IDA*.

    +
    +
    Type:
    +

    int

    +
    +
    +
    + +
    +
    +tested
    +

    Used for IDA* and Jump-Point-Search.

    +
    +
    Type:
    +

    bool

    +
    +
    +
    + +
    +
    +__init__()[source]
    +
    + +
    +
    +cleanup()[source]
    +

    Reset all calculated values, fresh start for pathfinding

    +
    + +
    +
    +h
    +
    + +
    +
    +g
    +
    + +
    +
    +f
    +
    + +
    +
    +opened
    +
    + +
    +
    +closed
    +
    + +
    +
    +parent
    +
    + +
    +
    +retain_count
    +
    + +
    +
    +tested
    +
    + +
    + +
    +
    +class pathfinding3d.core.node.GridNode(x=0, y=0, z=0, walkable=True, weight=1.0, grid_id=None, connections=None)[source]
    +

    Bases: Node

    +

    Basic node in a grid.

    +
    +
    Parameters:
    +
      +

    • x (int) –

      • +

    • y (int) –

      • +

    • z (int) –

      • +

    • walkable (bool) –

      • +

    • weight (float) –

      • +

    • grid_id (int | None) –

      • +

    • connections (List | None) –

      • +
    +
    +
    +
    +
    +x
    +

    The x coordinate of the node.

    +
    +
    Type:
    +

    int

    +
    +
    +
    + +
    +
    +y
    +

    The y coordinate of the node.

    +
    +
    Type:
    +

    int

    +
    +
    +
    + +
    +
    +z
    +

    The z coordinate of the node.

    +
    +
    Type:
    +

    int

    +
    +
    +
    + +
    +
    +walkable
    +

    Whether this node can be walked through.

    +
    +
    Type:
    +

    bool

    +
    +
    +
    + +
    +
    +weight
    +

    The weight of the node.

    +
    +
    Type:
    +

    float

    +
    +
    +
    + +
    +
    +grid_id
    +

    The id of the grid this node belongs to.

    +
    +
    Type:
    +

    Optional[int]

    +
    +
    +
    + +
    +
    +connections
    +

    The connections of this node.

    +
    +
    Type:
    +

    Optional[List]

    +
    +
    +
    + +
    +
    +x: int = 0
    +
    + +
    +
    +y: int = 0
    +
    + +
    +
    +z: int = 0
    +
    + +
    +
    +walkable: bool = True
    +
    + +
    +
    +weight: float = 1.0
    +
    + +
    +
    +grid_id: Optional[int] = None
    +
    + +
    +
    +connections: Optional[List] = None
    +
    + +
    +
    +connect(other_node)[source]
    +

    Connect this node to another node.

    +
    +
    Parameters:
    +

    other_node (GridNode) – The node to connect to.

    +
    +
    +
    + +
    +
    +h
    +
    + +
    +
    +g
    +
    + +
    +
    +f
    +
    + +
    +
    +opened
    +
    + +
    +
    +closed
    +
    + +
    +
    +parent
    +
    + +
    +
    +retain_count
    +
    + +
    +
    +tested
    +
    + +
    +
    +__init__(x=0, y=0, z=0, walkable=True, weight=1.0, grid_id=None, connections=None)
    +
    +
    Parameters:
    +
      +

    • x (int) –

      • +

    • y (int) –

      • +

    • z (int) –

      • +

    • walkable (bool) –

      • +

    • weight (float) –

      • +

    • grid_id (int | None) –

      • +

    • connections (List | None) –

      • +
    +
    +
    Return type:
    +

    None

    +
    +
    +
    + +
    +
    +cleanup()
    +

    Reset all calculated values, fresh start for pathfinding

    +
    + +
    + +
    + + +
    +
    +
    + +
    + +
    +

    © Copyright 2024, Harisankar Babu.

    +
    + + + +
    +
    +
    +
    +
    + + + + \ No newline at end of file diff --git a/pathfinding3d.core.util.html b/pathfinding3d.core.util.html new file mode 100644 index 0000000..b75018a --- /dev/null +++ b/pathfinding3d.core.util.html @@ -0,0 +1,308 @@ + + + + + + + pathfinding3d.core.util module — pathfinding3d 0.6.2 documentation + + + + + + + + + + + + + + + + + + + + + + + + +
    + + +
    + +
    +
    +
    + +
    +
    +
    +
    + +
    +

    pathfinding3d.core.util module

    +
    +
    +pathfinding3d.core.util.backtrace(node)[source]
    +

    Backtrace according to the parent records and return the path. +(including both start and end nodes)

    +
    +
    Parameters:
    +

    node (GridNode) – node to backtrace from

    +
    +
    Returns:
    +

    path

    +
    +
    Return type:
    +

    List[GridNode]

    +
    +
    +
    + +
    +
    +pathfinding3d.core.util.bi_backtrace(node_a, node_b)[source]
    +

    Backtrace from start and end node, returns the path for bi-directional A* +(including both start and end nodes)

    +
    +
    Parameters:
    +
    +
    +
    Returns:
    +

    path

    +
    +
    Return type:
    +

    List[GridNode]

    +
    +
    +
    + +
    +
    +pathfinding3d.core.util.raytrace(coords_a, coords_b)[source]
    +

    Given the start and end coordinates, return all the coordinates lying +on the line formed by these coordinates, based on ray tracing.

    +
    +
    Parameters:
    +
      +

    • coords_a (Coords) – start coordinates

      • +

    • coords_b (Coords) – end coordinates

      • +
    +
    +
    Returns:
    +

    list of coordinates

    +
    +
    Return type:
    +

    List[List[float]]

    +
    +
    +
    + +
    +
    +pathfinding3d.core.util.bresenham(coords_a, coords_b)[source]
    +

    Given the start and end coordinates, return all the coordinates lying +on the line formed by these coordinates, based on Bresenham’s algorithm.

    +
    +
    Parameters:
    +
      +

    • coords_a (Coords) – start coordinates

      • +

    • coords_b (Coords) – end coordinates

      • +
    +
    +
    Returns:
    +

    list of coordinates

    +
    +
    Return type:
    +

    List[List[float]]

    +
    +
    +
    + +
    +
    +pathfinding3d.core.util.expand_path(path)[source]
    +

    Given a compressed path, return a new path that has all the segments +in it interpolated.

    +
    +
    Parameters:
    +

    path (List[Coords]) – path to expand

    +
    +
    Returns:
    +

    expanded path

    +
    +
    Return type:
    +

    List[Coords]

    +
    +
    +
    + +
    +
    +pathfinding3d.core.util.smoothen_path(grid, path, use_raytrace=False)[source]
    +

    Given an uncompressed path, return a new path that has less +turnings and looks more natural.

    +
    +
    Parameters:
    +
      +

    • grid (Grid) – grid

      • +

    • path (List[Coords]) – path to smoothen

      • +

    • use_raytrace (bool, optional) – whether to use raytrace, by default False

      • +
    +
    +
    Returns:
    +

    smoothened path

    +
    +
    Return type:
    +

    List[List[float]]

    +
    +
    +
    + +
    +
    +pathfinding3d.core.util.line_of_sight(grid, node1, node2)[source]
    +

    Check if there is a line of sight between two nodes using Bresenham’s algorithm

    +
    +
    Parameters:
    +
      +

    • grid (Grid) – The grid on which the nodes exist

      • +

    • node1 (GridNode) – The first node

      • +

    • node2 (GridNode) – The second node

      • +
    +
    +
    Returns:
    +

    True if there is a line of sight between the two nodes, False otherwise

    +
    +
    Return type:
    +

    bool

    +
    +
    +
    + +
    + + +
    +
    +
    + +
    + +
    +

    © Copyright 2024, Harisankar Babu.

    +
    + + + +
    +
    +
    +
    +
    + + + + \ No newline at end of file diff --git a/pathfinding3d.core.world.html b/pathfinding3d.core.world.html new file mode 100644 index 0000000..1f0cb4c --- /dev/null +++ b/pathfinding3d.core.world.html @@ -0,0 +1,237 @@ + + + + + + + pathfinding3d.core.world module — pathfinding3d 0.6.2 documentation + + + + + + + + + + + + + + + + + + + + + + + + +
    + + +
    + +
    +
    +
    + +
    +
    +
    +
    + +
    +

    pathfinding3d.core.world module

    +
    +
    +class pathfinding3d.core.world.World(grids)[source]
    +

    Bases: object

    +

    A world connects grids but can have multiple grids.

    +
    +
    Parameters:
    +

    grids (Dict[int, Grid]) –

    +
    +
    +
    +
    +__init__(grids)[source]
    +

    Initialize a new world.

    +
    +
    Parameters:
    +

    grids (Dict[int, Grid]) – grids in this world

    +
    +
    +
    + +
    +
    +neighbors(node, diagonal_movement)[source]
    +

    Get neighbors of the given node.

    +
    +
    Parameters:
    +
      +

    • node (GridNode) – node to get neighbors from

      • +

    • diagonal_movement (int) – if diagonal movement is allowed +(see enum in diagonal_movement)

      • +
    +
    +
    Returns:
    +

    neighbors of the given node

    +
    +
    Return type:
    +

    List[GridNode]

    +
    +
    +
    + +
    +
    +calc_cost(node_a, node_b, weighted=False)[source]
    +

    Calculate the cost between two nodes.

    +
    +
    Parameters:
    +
      +

    • node_a (GridNode) – first node

      • +

    • node_b (GridNode) – second node

      • +

    • weighted (bool) – wether to use weights or not

      • +
    +
    +
    Returns:
    +

    cost between the two nodes

    +
    +
    Return type:
    +

    float

    +
    +
    +
    + +
    +
    +cleanup()[source]
    +

    Cleanup all grids in this world.

    +
    + +
    + +
    + + +
    +
    +
    + +
    + +
    +

    © Copyright 2024, Harisankar Babu.

    +
    + + + +
    +
    +
    +
    +
    + + + + \ No newline at end of file diff --git a/pathfinding3d.finder.a_star.html b/pathfinding3d.finder.a_star.html new file mode 100644 index 0000000..351f443 --- /dev/null +++ b/pathfinding3d.finder.a_star.html @@ -0,0 +1,327 @@ + + + + + + + pathfinding3d.finder.a_star module — pathfinding3d 0.6.2 documentation + + + + + + + + + + + + + + + + + + + + + + + + +
    + + +
    + +
    +
    +
    + +
    +
    +
    +
    + +
    +

    pathfinding3d.finder.a_star module

    +
    +
    +class pathfinding3d.finder.a_star.AStarFinder(heuristic=None, weight=1, diagonal_movement=DiagonalMovement.never, time_limit=TIME_LIMIT, max_runs=MAX_RUNS)[source]
    +

    Bases: Finder

    +
    +
    Parameters:
    +
      +

    • heuristic (Callable | None) –

      • +

    • weight (int) –

      • +

    • diagonal_movement (int) –

      • +

    • time_limit (float) –

      • +

    • max_runs (int | float) –

      • +
    +
    +
    +
    +
    +__init__(heuristic=None, weight=1, diagonal_movement=DiagonalMovement.never, time_limit=TIME_LIMIT, max_runs=MAX_RUNS)[source]
    +

    Find shortest path using A* algorithm

    +
    +
    Parameters:
    +
      +

    • heuristic (Callable) – heuristic used to calculate distance of 2 points

      • +

    • weight (int) – weight for the edges

      • +

    • diagonal_movement (int) – if diagonal movement is allowed +(see enum in diagonal_movement)

      • +

    • time_limit (float) – max. runtime in seconds

      • +

    • max_runs (int) – max. amount of tries until we abort the search +(optional, only if we enter huge grids and have time constrains) +<=0 means there are no constrains and the code might run on any +large map.

      • +
    +
    +
    +
    + +
    +
    +check_neighbors(start, end, grid, open_list, open_value=1, backtrace_by=None)[source]
    +

    Find next path segment based on given node +(or return path if we found the end)

    +
    +
    Parameters:
    +
      +

    • start (GridNode) – start node

      • +

    • end (GridNode) – end node

      • +

    • grid (Grid) – grid that stores all possible steps/tiles as 3D-list

      • +

    • open_list (List) – stores nodes that will be processed next

      • +

    • open_value (int) –

      • +
    +
    +
    Returns:
    +

    path

    +
    +
    Return type:
    +

    Optional[List[GridNode]]

    +
    +
    +
    + +
    +
    +apply_heuristic(node_a, node_b, heuristic=None)
    +

    Helper function to apply heuristic

    +
    +
    Parameters:
    +
      +

    • node_a (GridNode) – first node

      • +

    • node_b (GridNode) – second node

      • +

    • heuristic (Callable) – heuristic used to calculate distance of 2 points

      • +
    +
    +
    Returns:
    +

    heuristic value

    +
    +
    Return type:
    +

    float

    +
    +
    +
    + +
    +
    +find_neighbors(grid, node, diagonal_movement=None)
    +

    Find neighbor, same for Djikstra, A*, Bi-A*, IDA*

    +
    +
    Parameters:
    +
      +

    • grid (Grid) – grid that stores all possible steps/tiles as 3D-list

      • +

    • node (GridNode) – node to find neighbors for

      • +

    • diagonal_movement (int) – if diagonal movement is allowed +(see enum in diagonal_movement)

      • +
    +
    +
    Returns:
    +

    list of neighbors

    +
    +
    Return type:
    +

    List[GridNode]

    +
    +
    +
    + +
    +
    +find_path(start, end, grid)[source]
    +

    Find a path from start to end node on grid using the A* algorithm

    +
    +
    Parameters:
    +
      +

    • start (GridNode) – start node

      • +

    • end (GridNode) – end node

      • +

    • grid (Grid) – grid that stores all possible steps/tiles as 3D-list

      • +
    +
    +
    Returns:
    +

    path, number of iterations

    +
    +
    Return type:
    +

    Tuple[List, int]

    +
    +
    +
    + +
    +
    +keep_running()
    +

    Check, if we run into time or iteration constrains.

    +
    +
    Raises:
    +
    +
    +
    +
    + +
    +
    +process_node(grid, node, parent, end, open_list, open_value=1)
    +

    We check if the given node is part of the path by calculating its +cost and add or remove it from our path

    +
    +
    Parameters:
    +
      +

    • grid (Grid) – grid that stores all possible steps/tiles as 3D-list

      • +

    • node (GridNode) – the node we like to test +(the neighbor in A* or jump-node in JumpPointSearch)

      • +

    • parent (GridNode) – the parent node (of the current node we like to test)

      • +

    • end (GridNode) – the end point to calculate the cost of the path

      • +

    • open_list (List) – the list that keeps track of our current path

      • +

    • open_value (bool) – needed if we like to set the open list to something +else than True (used for bi-directional algorithms)

      • +
    +
    +
    +
    + +
    + +
    + + +
    +
    +
    + +
    + +
    +

    © Copyright 2024, Harisankar Babu.

    +
    + + + +
    +
    +
    +
    +
    + + + + \ No newline at end of file diff --git a/pathfinding3d.finder.best_first.html b/pathfinding3d.finder.best_first.html new file mode 100644 index 0000000..e2408a6 --- /dev/null +++ b/pathfinding3d.finder.best_first.html @@ -0,0 +1,328 @@ + + + + + + + pathfinding3d.finder.best_first module — pathfinding3d 0.6.2 documentation + + + + + + + + + + + + + + + + + + + + + + + + +
    + + +
    + +
    +
    +
    + +
    +
    +
    +
    + +
    +

    pathfinding3d.finder.best_first module

    +
    +
    +class pathfinding3d.finder.best_first.BestFirst(heuristic=None, weight=1, diagonal_movement=DiagonalMovement.never, time_limit=TIME_LIMIT, max_runs=MAX_RUNS)[source]
    +

    Bases: AStarFinder

    +

    Similar to the default A* algorithm from a_star.

    +
    +
    Parameters:
    +
      +

    • heuristic (Callable | None) –

      • +

    • weight (int) –

      • +

    • diagonal_movement (int) –

      • +

    • time_limit (float) –

      • +

    • max_runs (int | float) –

      • +
    +
    +
    +
    +
    +__init__(heuristic=None, weight=1, diagonal_movement=DiagonalMovement.never, time_limit=TIME_LIMIT, max_runs=MAX_RUNS)[source]
    +

    Find shortest path using BestFirst algorithm

    +
    +
    Parameters:
    +
      +

    • heuristic (Callable) – heuristic used to calculate distance of 2 points

      • +

    • weight (int) – weight for the edges

      • +

    • diagonal_movement (int) – if diagonal movement is allowed +(see enum in diagonal_movement)

      • +

    • time_limit (float) – max. runtime in seconds

      • +

    • max_runs (int) – max. amount of tries until we abort the search +(optional, only if we enter huge grids and have time constrains) +<=0 means there are no constrains and the code might run on any +large map.

      • +
    +
    +
    +
    + +
    +
    +apply_heuristic(node_a, node_b, heuristic=None)[source]
    +

    Helper function to apply heuristic

    +
    +
    Parameters:
    +
      +

    • node_a (GridNode) – first node

      • +

    • node_b (GridNode) – second node

      • +

    • heuristic (Callable) – heuristic used to calculate distance of 2 points

      • +
    +
    +
    Returns:
    +

    heuristic value

    +
    +
    Return type:
    +

    float

    +
    +
    +
    + +
    +
    +check_neighbors(start, end, grid, open_list, open_value=1, backtrace_by=None)
    +

    Find next path segment based on given node +(or return path if we found the end)

    +
    +
    Parameters:
    +
      +

    • start (GridNode) – start node

      • +

    • end (GridNode) – end node

      • +

    • grid (Grid) – grid that stores all possible steps/tiles as 3D-list

      • +

    • open_list (List) – stores nodes that will be processed next

      • +

    • open_value (int) –

      • +
    +
    +
    Returns:
    +

    path

    +
    +
    Return type:
    +

    Optional[List[GridNode]]

    +
    +
    +
    + +
    +
    +find_neighbors(grid, node, diagonal_movement=None)
    +

    Find neighbor, same for Djikstra, A*, Bi-A*, IDA*

    +
    +
    Parameters:
    +
      +

    • grid (Grid) – grid that stores all possible steps/tiles as 3D-list

      • +

    • node (GridNode) – node to find neighbors for

      • +

    • diagonal_movement (int) – if diagonal movement is allowed +(see enum in diagonal_movement)

      • +
    +
    +
    Returns:
    +

    list of neighbors

    +
    +
    Return type:
    +

    List[GridNode]

    +
    +
    +
    + +
    +
    +find_path(start, end, grid)
    +

    Find a path from start to end node on grid using the A* algorithm

    +
    +
    Parameters:
    +
      +

    • start (GridNode) – start node

      • +

    • end (GridNode) – end node

      • +

    • grid (Grid) – grid that stores all possible steps/tiles as 3D-list

      • +
    +
    +
    Returns:
    +

    path, number of iterations

    +
    +
    Return type:
    +

    Tuple[List, int]

    +
    +
    +
    + +
    +
    +keep_running()
    +

    Check, if we run into time or iteration constrains.

    +
    +
    Raises:
    +
    +
    +
    +
    + +
    +
    +process_node(grid, node, parent, end, open_list, open_value=1)
    +

    We check if the given node is part of the path by calculating its +cost and add or remove it from our path

    +
    +
    Parameters:
    +
      +

    • grid (Grid) – grid that stores all possible steps/tiles as 3D-list

      • +

    • node (GridNode) – the node we like to test +(the neighbor in A* or jump-node in JumpPointSearch)

      • +

    • parent (GridNode) – the parent node (of the current node we like to test)

      • +

    • end (GridNode) – the end point to calculate the cost of the path

      • +

    • open_list (List) – the list that keeps track of our current path

      • +

    • open_value (bool) – needed if we like to set the open list to something +else than True (used for bi-directional algorithms)

      • +
    +
    +
    +
    + +
    + +
    + + +
    +
    +
    + +
    + +
    +

    © Copyright 2024, Harisankar Babu.

    +
    + + + +
    +
    +
    +
    +
    + + + + \ No newline at end of file diff --git a/pathfinding3d.finder.bi_a_star.html b/pathfinding3d.finder.bi_a_star.html new file mode 100644 index 0000000..c819779 --- /dev/null +++ b/pathfinding3d.finder.bi_a_star.html @@ -0,0 +1,329 @@ + + + + + + + pathfinding3d.finder.bi_a_star module — pathfinding3d 0.6.2 documentation + + + + + + + + + + + + + + + + + + + + + + + + +
    + + +
    + +
    +
    +
    + +
    +
    +
    +
    + +
    +

    pathfinding3d.finder.bi_a_star module

    +
    +
    +class pathfinding3d.finder.bi_a_star.BiAStarFinder(heuristic=None, weight=1, diagonal_movement=DiagonalMovement.never, time_limit=TIME_LIMIT, max_runs=MAX_RUNS)[source]
    +

    Bases: AStarFinder

    +

    Similar to the default A* algorithm from a_star.

    +
    +
    Parameters:
    +
      +

    • heuristic (Callable | None) –

      • +

    • weight (int) –

      • +

    • diagonal_movement (int) –

      • +

    • time_limit (float) –

      • +

    • max_runs (int | float) –

      • +
    +
    +
    +
    +
    +__init__(heuristic=None, weight=1, diagonal_movement=DiagonalMovement.never, time_limit=TIME_LIMIT, max_runs=MAX_RUNS)[source]
    +

    Find shortest path using Bi-A* algorithm

    +
    +
    Parameters:
    +
      +

    • heuristic (Callable) – heuristic used to calculate distance of 2 points

      • +

    • weight (int) – weight for the edges

      • +

    • diagonal_movement (int) – if diagonal movement is allowed +(see enum in diagonal_movement)

      • +

    • time_limit (float) – max. runtime in seconds

      • +

    • max_runs (int) – max. amount of tries until we abort the search +(optional, only if we enter huge grids and have time constrains) +<=0 means there are no constrains and the code might run on any +large map.

      • +
    +
    +
    +
    + +
    +
    +find_path(start, end, grid)[source]
    +

    Find a path from start to end node on grid using the A* algorithm

    +
    +
    Parameters:
    +
      +

    • start (GridNode) – start node

      • +

    • end (GridNode) – end node

      • +

    • grid (Grid) – grid that stores all possible steps/tiles as 3D-list +(can be a list of grids)

      • +
    +
    +
    Returns:
    +

    path, number of iterations

    +
    +
    Return type:
    +

    Tuple[List, int]

    +
    +
    +
    + +
    +
    +apply_heuristic(node_a, node_b, heuristic=None)
    +

    Helper function to apply heuristic

    +
    +
    Parameters:
    +
      +

    • node_a (GridNode) – first node

      • +

    • node_b (GridNode) – second node

      • +

    • heuristic (Callable) – heuristic used to calculate distance of 2 points

      • +
    +
    +
    Returns:
    +

    heuristic value

    +
    +
    Return type:
    +

    float

    +
    +
    +
    + +
    +
    +check_neighbors(start, end, grid, open_list, open_value=1, backtrace_by=None)
    +

    Find next path segment based on given node +(or return path if we found the end)

    +
    +
    Parameters:
    +
      +

    • start (GridNode) – start node

      • +

    • end (GridNode) – end node

      • +

    • grid (Grid) – grid that stores all possible steps/tiles as 3D-list

      • +

    • open_list (List) – stores nodes that will be processed next

      • +

    • open_value (int) –

      • +
    +
    +
    Returns:
    +

    path

    +
    +
    Return type:
    +

    Optional[List[GridNode]]

    +
    +
    +
    + +
    +
    +find_neighbors(grid, node, diagonal_movement=None)
    +

    Find neighbor, same for Djikstra, A*, Bi-A*, IDA*

    +
    +
    Parameters:
    +
      +

    • grid (Grid) – grid that stores all possible steps/tiles as 3D-list

      • +

    • node (GridNode) – node to find neighbors for

      • +

    • diagonal_movement (int) – if diagonal movement is allowed +(see enum in diagonal_movement)

      • +
    +
    +
    Returns:
    +

    list of neighbors

    +
    +
    Return type:
    +

    List[GridNode]

    +
    +
    +
    + +
    +
    +keep_running()
    +

    Check, if we run into time or iteration constrains.

    +
    +
    Raises:
    +
    +
    +
    +
    + +
    +
    +process_node(grid, node, parent, end, open_list, open_value=1)
    +

    We check if the given node is part of the path by calculating its +cost and add or remove it from our path

    +
    +
    Parameters:
    +
      +

    • grid (Grid) – grid that stores all possible steps/tiles as 3D-list

      • +

    • node (GridNode) – the node we like to test +(the neighbor in A* or jump-node in JumpPointSearch)

      • +

    • parent (GridNode) – the parent node (of the current node we like to test)

      • +

    • end (GridNode) – the end point to calculate the cost of the path

      • +

    • open_list (List) – the list that keeps track of our current path

      • +

    • open_value (bool) – needed if we like to set the open list to something +else than True (used for bi-directional algorithms)

      • +
    +
    +
    +
    + +
    + +
    + + +
    +
    +
    + +
    + +
    +

    © Copyright 2024, Harisankar Babu.

    +
    + + + +
    +
    +
    +
    +
    + + + + \ No newline at end of file diff --git a/pathfinding3d.finder.breadth_first.html b/pathfinding3d.finder.breadth_first.html new file mode 100644 index 0000000..324fa23 --- /dev/null +++ b/pathfinding3d.finder.breadth_first.html @@ -0,0 +1,328 @@ + + + + + + + pathfinding3d.finder.breadth_first module — pathfinding3d 0.6.2 documentation + + + + + + + + + + + + + + + + + + + + + + + + +
    + + +
    + +
    +
    +
    + +
    +
    +
    +
    + +
    +

    pathfinding3d.finder.breadth_first module

    +
    +
    +class pathfinding3d.finder.breadth_first.BreadthFirstFinder(heuristic=None, weight=1, diagonal_movement=DiagonalMovement.never, time_limit=TIME_LIMIT, max_runs=MAX_RUNS)[source]
    +

    Bases: Finder

    +
    +
    Parameters:
    +
      +

    • heuristic (Callable | None) –

      • +

    • weight (int) –

      • +

    • diagonal_movement (int) –

      • +

    • time_limit (float) –

      • +

    • max_runs (int | float) –

      • +
    +
    +
    +
    +
    +__init__(heuristic=None, weight=1, diagonal_movement=DiagonalMovement.never, time_limit=TIME_LIMIT, max_runs=MAX_RUNS)[source]
    +

    Find shortest path using Breadth First algorithm

    +
    +
    Parameters:
    +
      +

    • heuristic (Callable) – heuristic used to calculate distance of 2 points

      • +

    • weight (int) – weight for the edges

      • +

    • diagonal_movement (int) – if diagonal movement is allowed +(see enum in diagonal_movement)

      • +

    • time_limit (float) – max. runtime in seconds

      • +

    • max_runs (int) – max. amount of tries until we abort the search +(optional, only if we enter huge grids and have time constrains) +<=0 means there are no constrains and the code might run on any +large map.

      • +
    +
    +
    +
    + +
    +
    +check_neighbors(start, end, grid, open_list)[source]
    +

    Find next path segment based on given node +(or return path if we found the end)

    +
    +
    Parameters:
    +
      +

    • start (GridNode) – start node

      • +

    • end (GridNode) – end node

      • +

    • grid (Grid) – grid that stores all possible steps/tiles as 3D-list

      • +

    • open_list (List) – stores nodes that will be processed next

      • +
    +
    +
    Returns:
    +

    path

    +
    +
    Return type:
    +

    List[GridNode]

    +
    +
    +
    + +
    +
    +apply_heuristic(node_a, node_b, heuristic=None)
    +

    Helper function to apply heuristic

    +
    +
    Parameters:
    +
      +

    • node_a (GridNode) – first node

      • +

    • node_b (GridNode) – second node

      • +

    • heuristic (Callable) – heuristic used to calculate distance of 2 points

      • +
    +
    +
    Returns:
    +

    heuristic value

    +
    +
    Return type:
    +

    float

    +
    +
    +
    + +
    +
    +find_neighbors(grid, node, diagonal_movement=None)
    +

    Find neighbor, same for Djikstra, A*, Bi-A*, IDA*

    +
    +
    Parameters:
    +
      +

    • grid (Grid) – grid that stores all possible steps/tiles as 3D-list

      • +

    • node (GridNode) – node to find neighbors for

      • +

    • diagonal_movement (int) – if diagonal movement is allowed +(see enum in diagonal_movement)

      • +
    +
    +
    Returns:
    +

    list of neighbors

    +
    +
    Return type:
    +

    List[GridNode]

    +
    +
    +
    + +
    +
    +find_path(start, end, grid)
    +

    Find a path from start to end node on grid by iterating over +all neighbors of a node (see check_neighbors)

    +
    +
    Parameters:
    +
      +

    • start (GridNode) – start node

      • +

    • end (GridNode) – end node

      • +

    • grid (Grid) – grid that stores all possible steps/tiles as 3D-list +(can be a list of grids)

      • +
    +
    +
    Returns:
    +

    path, number of iterations

    +
    +
    Return type:
    +

    Tuple[List, int]

    +
    +
    +
    + +
    +
    +keep_running()
    +

    Check, if we run into time or iteration constrains.

    +
    +
    Raises:
    +
    +
    +
    +
    + +
    +
    +process_node(grid, node, parent, end, open_list, open_value=1)
    +

    We check if the given node is part of the path by calculating its +cost and add or remove it from our path

    +
    +
    Parameters:
    +
      +

    • grid (Grid) – grid that stores all possible steps/tiles as 3D-list

      • +

    • node (GridNode) – the node we like to test +(the neighbor in A* or jump-node in JumpPointSearch)

      • +

    • parent (GridNode) – the parent node (of the current node we like to test)

      • +

    • end (GridNode) – the end point to calculate the cost of the path

      • +

    • open_list (List) – the list that keeps track of our current path

      • +

    • open_value (bool) – needed if we like to set the open list to something +else than True (used for bi-directional algorithms)

      • +
    +
    +
    +
    + +
    + +
    + + +
    +
    +
    + +
    + +
    +

    © Copyright 2024, Harisankar Babu.

    +
    + + + +
    +
    +
    +
    +
    + + + + \ No newline at end of file diff --git a/pathfinding3d.finder.dijkstra.html b/pathfinding3d.finder.dijkstra.html new file mode 100644 index 0000000..284ec54 --- /dev/null +++ b/pathfinding3d.finder.dijkstra.html @@ -0,0 +1,325 @@ + + + + + + + pathfinding3d.finder.dijkstra module — pathfinding3d 0.6.2 documentation + + + + + + + + + + + + + + + + + + + + + + + + +
    + + +
    + +
    +
    +
    + +
    +
    +
    +
    + +
    +

    pathfinding3d.finder.dijkstra module

    +
    +
    +class pathfinding3d.finder.dijkstra.DijkstraFinder(weight=1, diagonal_movement=DiagonalMovement.never, time_limit=TIME_LIMIT, max_runs=MAX_RUNS)[source]
    +

    Bases: AStarFinder

    +
    +
    Parameters:
    +
      +

    • weight (int) –

      • +

    • diagonal_movement (int) –

      • +

    • time_limit (float) –

      • +

    • max_runs (int | float) –

      • +
    +
    +
    +
    +
    +__init__(weight=1, diagonal_movement=DiagonalMovement.never, time_limit=TIME_LIMIT, max_runs=MAX_RUNS)[source]
    +

    Find shortest path using Dijkstra algorithm

    +
    +
    Parameters:
    +
      +

    • weight (int) – weight for the edges

      • +

    • diagonal_movement (int) – if diagonal movement is allowed +(see enum in diagonal_movement)

      • +

    • time_limit (float) – max. runtime in seconds

      • +

    • max_runs (int) – max. amount of tries until we abort the search +(optional, only if we enter huge grids and have time constrains) +<=0 means there are no constrains and the code might run on any +large map.

      • +
    +
    +
    +
    + +
    +
    +apply_heuristic(node_a, node_b, heuristic=None)[source]
    +

    Helper function to apply heuristic

    +
    +
    Parameters:
    +
      +

    • node_a (Node) – first node

      • +

    • node_b (Node) – second node

      • +

    • heuristic (Callable) – heuristic used to calculate distance of 2 points

      • +
    +
    +
    Returns:
    +

    0.0

    +
    +
    Return type:
    +

    float

    +
    +
    +
    + +
    +
    +check_neighbors(start, end, grid, open_list, open_value=1, backtrace_by=None)
    +

    Find next path segment based on given node +(or return path if we found the end)

    +
    +
    Parameters:
    +
      +

    • start (GridNode) – start node

      • +

    • end (GridNode) – end node

      • +

    • grid (Grid) – grid that stores all possible steps/tiles as 3D-list

      • +

    • open_list (List) – stores nodes that will be processed next

      • +

    • open_value (int) –

      • +
    +
    +
    Returns:
    +

    path

    +
    +
    Return type:
    +

    Optional[List[GridNode]]

    +
    +
    +
    + +
    +
    +find_neighbors(grid, node, diagonal_movement=None)
    +

    Find neighbor, same for Djikstra, A*, Bi-A*, IDA*

    +
    +
    Parameters:
    +
      +

    • grid (Grid) – grid that stores all possible steps/tiles as 3D-list

      • +

    • node (GridNode) – node to find neighbors for

      • +

    • diagonal_movement (int) – if diagonal movement is allowed +(see enum in diagonal_movement)

      • +
    +
    +
    Returns:
    +

    list of neighbors

    +
    +
    Return type:
    +

    List[GridNode]

    +
    +
    +
    + +
    +
    +find_path(start, end, grid)
    +

    Find a path from start to end node on grid using the A* algorithm

    +
    +
    Parameters:
    +
      +

    • start (GridNode) – start node

      • +

    • end (GridNode) – end node

      • +

    • grid (Grid) – grid that stores all possible steps/tiles as 3D-list

      • +
    +
    +
    Returns:
    +

    path, number of iterations

    +
    +
    Return type:
    +

    Tuple[List, int]

    +
    +
    +
    + +
    +
    +keep_running()
    +

    Check, if we run into time or iteration constrains.

    +
    +
    Raises:
    +
    +
    +
    +
    + +
    +
    +process_node(grid, node, parent, end, open_list, open_value=1)
    +

    We check if the given node is part of the path by calculating its +cost and add or remove it from our path

    +
    +
    Parameters:
    +
      +

    • grid (Grid) – grid that stores all possible steps/tiles as 3D-list

      • +

    • node (GridNode) – the node we like to test +(the neighbor in A* or jump-node in JumpPointSearch)

      • +

    • parent (GridNode) – the parent node (of the current node we like to test)

      • +

    • end (GridNode) – the end point to calculate the cost of the path

      • +

    • open_list (List) – the list that keeps track of our current path

      • +

    • open_value (bool) – needed if we like to set the open list to something +else than True (used for bi-directional algorithms)

      • +
    +
    +
    +
    + +
    + +
    + + +
    +
    +
    + +
    + +
    +

    © Copyright 2024, Harisankar Babu.

    +
    + + + +
    +
    +
    +
    +
    + + + + \ No newline at end of file diff --git a/pathfinding3d.finder.finder.html b/pathfinding3d.finder.finder.html new file mode 100644 index 0000000..83b6fbe --- /dev/null +++ b/pathfinding3d.finder.finder.html @@ -0,0 +1,377 @@ + + + + + + + pathfinding3d.finder.finder module — pathfinding3d 0.6.2 documentation + + + + + + + + + + + + + + + + + + + + + + + + +
    + + +
    + +
    +
    +
    + +
    +
    +
    +
    + +
    +

    pathfinding3d.finder.finder module

    +
    +
    +exception pathfinding3d.finder.finder.ExecutionTimeException(message)[source]
    +

    Bases: Exception

    +
    +
    +__init__(message)[source]
    +
    + +
    +
    +args
    +
    + +
    +
    +with_traceback()
    +

    Exception.with_traceback(tb) – +set self.__traceback__ to tb and return self.

    +
    + +
    + +
    +
    +exception pathfinding3d.finder.finder.ExecutionRunsException(message)[source]
    +

    Bases: Exception

    +
    +
    +__init__(message)[source]
    +
    + +
    +
    +args
    +
    + +
    +
    +with_traceback()
    +

    Exception.with_traceback(tb) – +set self.__traceback__ to tb and return self.

    +
    + +
    + +
    +
    +class pathfinding3d.finder.finder.Finder(heuristic=None, weight=1, diagonal_movement=DiagonalMovement.never, weighted=True, time_limit=TIME_LIMIT, max_runs=MAX_RUNS)[source]
    +

    Bases: object

    +
    +
    Parameters:
    +
      +

    • heuristic (Callable | None) –

      • +

    • weight (int) –

      • +

    • diagonal_movement (int) –

      • +

    • weighted (bool) –

      • +

    • time_limit (float) –

      • +

    • max_runs (int | float) –

      • +
    +
    +
    +
    +
    +__init__(heuristic=None, weight=1, diagonal_movement=DiagonalMovement.never, weighted=True, time_limit=TIME_LIMIT, max_runs=MAX_RUNS)[source]
    +

    Find shortest path

    +
    +
    Parameters:
    +
      +

    • heuristic (Callable) – heuristic used to calculate distance of 2 points

      • +

    • weight (int) – weight for the edges

      • +

    • diagonal_movement (int) – if diagonal movement is allowed +(see enum in diagonal_movement)

      • +

    • weighted (the algorithm supports weighted nodes) – (should be True for A* and Dijkstra)

      • +

    • time_limit (float) – max. runtime in seconds

      • +

    • max_runs (int) – max. amount of tries until we abort the search +(optional, only if we enter huge grids and have time constrains) +<=0 means there are no constrains and the code might run on any +large map.

      • +
    +
    +
    +
    + +
    +
    +apply_heuristic(node_a, node_b, heuristic=None)[source]
    +

    Helper function to apply heuristic

    +
    +
    Parameters:
    +
      +

    • node_a (GridNode) – first node

      • +

    • node_b (GridNode) – second node

      • +

    • heuristic (Callable) – heuristic used to calculate distance of 2 points

      • +
    +
    +
    Returns:
    +

    heuristic value

    +
    +
    Return type:
    +

    float

    +
    +
    +
    + +
    +
    +find_neighbors(grid, node, diagonal_movement=None)[source]
    +

    Find neighbor, same for Djikstra, A*, Bi-A*, IDA*

    +
    +
    Parameters:
    +
      +

    • grid (Grid) – grid that stores all possible steps/tiles as 3D-list

      • +

    • node (GridNode) – node to find neighbors for

      • +

    • diagonal_movement (int) – if diagonal movement is allowed +(see enum in diagonal_movement)

      • +
    +
    +
    Returns:
    +

    list of neighbors

    +
    +
    Return type:
    +

    List[GridNode]

    +
    +
    +
    + +
    +
    +keep_running()[source]
    +

    Check, if we run into time or iteration constrains.

    +
    +
    Raises:
    +
    +
    +
    +
    + +
    +
    +process_node(grid, node, parent, end, open_list, open_value=1)[source]
    +

    We check if the given node is part of the path by calculating its +cost and add or remove it from our path

    +
    +
    Parameters:
    +
      +

    • grid (Grid) – grid that stores all possible steps/tiles as 3D-list

      • +

    • node (GridNode) – the node we like to test +(the neighbor in A* or jump-node in JumpPointSearch)

      • +

    • parent (GridNode) – the parent node (of the current node we like to test)

      • +

    • end (GridNode) – the end point to calculate the cost of the path

      • +

    • open_list (List) – the list that keeps track of our current path

      • +

    • open_value (bool) – needed if we like to set the open list to something +else than True (used for bi-directional algorithms)

      • +
    +
    +
    +
    + +
    +
    +check_neighbors(start, end, grid, open_list, open_value=1, backtrace_by=None)[source]
    +

    find next path segment based on given node +(or return path if we found the end)

    +
    +
    Parameters:
    +
      +

    • start (GridNode) – start node

      • +

    • end (GridNode) – end node

      • +

    • grid (Grid) – grid that stores all possible steps/tiles as 3D-list

      • +

    • open_list (List) – stores nodes that will be processed next

      • +

    • open_value (int) –

      • +
    +
    +
    Returns:
    +

    path

    +
    +
    Return type:
    +

    Optional[List[GridNode]]

    +
    +
    +
    + +
    +
    +find_path(start, end, grid)[source]
    +

    Find a path from start to end node on grid by iterating over +all neighbors of a node (see check_neighbors)

    +
    +
    Parameters:
    +
      +

    • start (GridNode) – start node

      • +

    • end (GridNode) – end node

      • +

    • grid (Grid) – grid that stores all possible steps/tiles as 3D-list +(can be a list of grids)

      • +
    +
    +
    Returns:
    +

    path, number of iterations

    +
    +
    Return type:
    +

    Tuple[List, int]

    +
    +
    +
    + +
    + +
    + + +
    +
    +
    + +
    + +
    +

    © Copyright 2024, Harisankar Babu.

    +
    + + + +
    +
    +
    +
    +
    + + + + \ No newline at end of file diff --git a/pathfinding3d.finder.html b/pathfinding3d.finder.html index cc79718..0b8cb74 100644 --- a/pathfinding3d.finder.html +++ b/pathfinding3d.finder.html @@ -4,7 +4,7 @@ - pathfinding3d.finder package — pathfinding3d 0.6.1 documentation + pathfinding3d.finder package — pathfinding3d 0.6.2 documentation @@ -18,7 +18,7 @@ - + @@ -26,7 +26,8 @@ - + + @@ -41,7 +42,7 @@ pathfinding3d
    - 0.6.1 + 0.6.2
    @@ -78,16 +79,17 @@
  • Change Log
  • pathfinding3d
      @@ -132,1435 +134,142 @@

      pathfinding3d.finder package

      Submodules

      -
      -
      -

      pathfinding3d.finder.a_star module

      -
      -
      -class pathfinding3d.finder.a_star.AStarFinder(heuristic=None, weight=1, diagonal_movement=DiagonalMovement.never, time_limit=TIME_LIMIT, max_runs=MAX_RUNS)[source]
      -

      Bases: Finder

      -
      -
      Parameters:
      -
        -

      • heuristic (Callable | None) –

        • -

      • weight (int) –

        • -

      • diagonal_movement (int) –

        • -

      • time_limit (float) –

        • -

      • max_runs (int | float) –

        • -
      -
      -
      -
      -
      -__init__(heuristic=None, weight=1, diagonal_movement=DiagonalMovement.never, time_limit=TIME_LIMIT, max_runs=MAX_RUNS)[source]
      -

      Find shortest path using A* algorithm

      -
      -
      Parameters:
      -
        -

      • heuristic (Callable) – heuristic used to calculate distance of 2 points

        • -

      • weight (int) – weight for the edges

        • -

      • diagonal_movement (int) – if diagonal movement is allowed -(see enum in diagonal_movement)

        • -

      • time_limit (float) – max. runtime in seconds

        • -

      • max_runs (int) – max. amount of tries until we abort the search -(optional, only if we enter huge grids and have time constrains) -<=0 means there are no constrains and the code might run on any -large map.

        • -
      -
      -
      -
      - -
      -
      -check_neighbors(start, end, grid, open_list, open_value=1, backtrace_by=None)[source]
      -

      Find next path segment based on given node -(or return path if we found the end)

      -
      -
      Parameters:
      -
        -

      • start (GridNode) – start node

        • -

      • end (GridNode) – end node

        • -

      • grid (Grid) – grid that stores all possible steps/tiles as 3D-list

        • -

      • open_list (List) – stores nodes that will be processed next

        • -

      • open_value (int) –

        • -
      -
      -
      Returns:
      -

      path

      -
      -
      Return type:
      -

      Optional[List[GridNode]]

      -
      -
      -
      - -
      -
      -apply_heuristic(node_a, node_b, heuristic=None)
      -

      Helper function to apply heuristic

      -
      -
      Parameters:
      -
        -

      • node_a (GridNode) – first node

        • -

      • node_b (GridNode) – second node

        • -

      • heuristic (Callable) – heuristic used to calculate distance of 2 points

        • -
      -
      -
      Returns:
      -

      heuristic value

      -
      -
      Return type:
      -

      float

      -
      -
      -
      - -
      -
      -find_neighbors(grid, node, diagonal_movement=None)
      -

      Find neighbor, same for Djikstra, A*, Bi-A*, IDA*

      -
      -
      Parameters:
      -
        -

      • grid (Grid) – grid that stores all possible steps/tiles as 3D-list

        • -

      • node (GridNode) – node to find neighbors for

        • -

      • diagonal_movement (int) – if diagonal movement is allowed -(see enum in diagonal_movement)

        • -
      -
      -
      Returns:
      -

      list of neighbors

      -
      -
      Return type:
      -

      List[GridNode]

      -
      -
      -
      - -
      -
      -find_path(start, end, grid)[source]
      -

      Find a path from start to end node on grid using the A* algorithm

      -
      -
      Parameters:
      -
        -

      • start (GridNode) – start node

        • -

      • end (GridNode) – end node

        • -

      • grid (Grid) – grid that stores all possible steps/tiles as 3D-list

        • -
      -
      -
      Returns:
      -

      path, number of iterations

      -
      -
      Return type:
      -

      Tuple[List, int]

      -
      -
      -
      - -
      -
      -keep_running()
      -

      Check, if we run into time or iteration constrains.

      -
      -
      Raises:
      -
      -
      -
      -
      - -
      -
      -process_node(grid, node, parent, end, open_list, open_value=1)
      -

      We check if the given node is part of the path by calculating its -cost and add or remove it from our path

      -
      -
      Parameters:
      -
        -

      • grid (Grid) – grid that stores all possible steps/tiles as 3D-list

        • -

      • node (GridNode) – the node we like to test -(the neighbor in A* or jump-node in JumpPointSearch)

        • -

      • parent (GridNode) – the parent node (of the current node we like to test)

        • -

      • end (GridNode) – the end point to calculate the cost of the path

        • -

      • open_list (List) – the list that keeps track of our current path

        • -

      • open_value (bool) – needed if we like to set the open list to something -else than True (used for bi-directional algorithms)

        • -
      -
      -
      -
      - -
      - -
      -
      -

      pathfinding3d.finder.best_first module

      -
      -
      -class pathfinding3d.finder.best_first.BestFirst(heuristic=None, weight=1, diagonal_movement=DiagonalMovement.never, time_limit=TIME_LIMIT, max_runs=MAX_RUNS)[source]
      -

      Bases: AStarFinder

      -

      Similar to the default A* algorithm from a_star.

      -
      -
      Parameters:
      -
        -

      • heuristic (Callable | None) –

        • -

      • weight (int) –

        • -

      • diagonal_movement (int) –

        • -

      • time_limit (float) –

        • -

      • max_runs (int | float) –

        • -
      -
      -
      -
      -
      -__init__(heuristic=None, weight=1, diagonal_movement=DiagonalMovement.never, time_limit=TIME_LIMIT, max_runs=MAX_RUNS)[source]
      -

      Find shortest path using BestFirst algorithm

      -
      -
      Parameters:
      -
        -

      • heuristic (Callable) – heuristic used to calculate distance of 2 points

        • -

      • weight (int) – weight for the edges

        • -

      • diagonal_movement (int) – if diagonal movement is allowed -(see enum in diagonal_movement)

        • -

      • time_limit (float) – max. runtime in seconds

        • -

      • max_runs (int) – max. amount of tries until we abort the search -(optional, only if we enter huge grids and have time constrains) -<=0 means there are no constrains and the code might run on any -large map.

        • -
      -
      -
      -
      - -
      -
      -apply_heuristic(node_a, node_b, heuristic=None)[source]
      -

      Helper function to apply heuristic

      -
      -
      Parameters:
      -
        -

      • node_a (GridNode) – first node

        • -

      • node_b (GridNode) – second node

        • -

      • heuristic (Callable) – heuristic used to calculate distance of 2 points

        • -
      -
      -
      Returns:
      -

      heuristic value

      -
      -
      Return type:
      -

      float

      -
      -
      -
      - -
      -
      -check_neighbors(start, end, grid, open_list, open_value=1, backtrace_by=None)
      -

      Find next path segment based on given node -(or return path if we found the end)

      -
      -
      Parameters:
      -
        -

      • start (GridNode) – start node

        • -

      • end (GridNode) – end node

        • -

      • grid (Grid) – grid that stores all possible steps/tiles as 3D-list

        • -

      • open_list (List) – stores nodes that will be processed next

        • -

      • open_value (int) –

        • -
      -
      -
      Returns:
      -

      path

      -
      -
      Return type:
      -

      Optional[List[GridNode]]

      -
      -
      -
      - -
      -
      -find_neighbors(grid, node, diagonal_movement=None)
      -

      Find neighbor, same for Djikstra, A*, Bi-A*, IDA*

      -
      -
      Parameters:
      -
        -

      • grid (Grid) – grid that stores all possible steps/tiles as 3D-list

        • -

      • node (GridNode) – node to find neighbors for

        • -

      • diagonal_movement (int) – if diagonal movement is allowed -(see enum in diagonal_movement)

        • -
      -
      -
      Returns:
      -

      list of neighbors

      -
      -
      Return type:
      -

      List[GridNode]

      -
      -
      -
      - -
      -
      -find_path(start, end, grid)
      -

      Find a path from start to end node on grid using the A* algorithm

      -
      -
      Parameters:
      -
        -

      • start (GridNode) – start node

        • -

      • end (GridNode) – end node

        • -

      • grid (Grid) – grid that stores all possible steps/tiles as 3D-list

        • -
      -
      -
      Returns:
      -

      path, number of iterations

      -
      -
      Return type:
      -

      Tuple[List, int]

      -
      -
      -
      - -
      -
      -keep_running()
      -

      Check, if we run into time or iteration constrains.

      -
      -
      Raises:
      -
      -
      -
      -
      - -
      -
      -process_node(grid, node, parent, end, open_list, open_value=1)
      -

      We check if the given node is part of the path by calculating its -cost and add or remove it from our path

      -
      -
      Parameters:
      -
        -

      • grid (Grid) – grid that stores all possible steps/tiles as 3D-list

        • -

      • node (GridNode) – the node we like to test -(the neighbor in A* or jump-node in JumpPointSearch)

        • -

      • parent (GridNode) – the parent node (of the current node we like to test)

        • -

      • end (GridNode) – the end point to calculate the cost of the path

        • -

      • open_list (List) – the list that keeps track of our current path

        • -

      • open_value (bool) – needed if we like to set the open list to something -else than True (used for bi-directional algorithms)

        • -
      -
      -
      -
      - -
      - -
      -
      -

      pathfinding3d.finder.bi_a_star module

      -
      -
      -class pathfinding3d.finder.bi_a_star.BiAStarFinder(heuristic=None, weight=1, diagonal_movement=DiagonalMovement.never, time_limit=TIME_LIMIT, max_runs=MAX_RUNS)[source]
      -

      Bases: AStarFinder

      -

      Similar to the default A* algorithm from a_star.

      -
      -
      Parameters:
      -
        -

      • heuristic (Callable | None) –

        • -

      • weight (int) –

        • -

      • diagonal_movement (int) –

        • -

      • time_limit (float) –

        • -

      • max_runs (int | float) –

        • -
      -
      -
      -
      -
      -__init__(heuristic=None, weight=1, diagonal_movement=DiagonalMovement.never, time_limit=TIME_LIMIT, max_runs=MAX_RUNS)[source]
      -

      Find shortest path using Bi-A* algorithm

      -
      -
      Parameters:
      -
        -

      • heuristic (Callable) – heuristic used to calculate distance of 2 points

        • -

      • weight (int) – weight for the edges

        • -

      • diagonal_movement (int) – if diagonal movement is allowed -(see enum in diagonal_movement)

        • -

      • time_limit (float) – max. runtime in seconds

        • -

      • max_runs (int) – max. amount of tries until we abort the search -(optional, only if we enter huge grids and have time constrains) -<=0 means there are no constrains and the code might run on any -large map.

        • -
      -
      -
      -
      - -
      -
      -find_path(start, end, grid)[source]
      -

      Find a path from start to end node on grid using the A* algorithm

      -
      -
      Parameters:
      -
      -
      Returns:
      -

      path, number of iterations

      -
      -
      Return type:
      -

      Tuple[List, int]

      -
      -
      -
      - -
      -
      -apply_heuristic(node_a, node_b, heuristic=None)
      -

      Helper function to apply heuristic

      -
      -
      Parameters:
      -
        -

      • node_a (GridNode) – first node

        • -

      • node_b (GridNode) – second node

        • -

      • heuristic (Callable) – heuristic used to calculate distance of 2 points

        • -
      -
      -
      Returns:
      -

      heuristic value

      -
      -
      Return type:
      -

      float

      -
      -
      -
      - -
      -
      -check_neighbors(start, end, grid, open_list, open_value=1, backtrace_by=None)
      -

      Find next path segment based on given node -(or return path if we found the end)

      -
      -
      Parameters:
      -
        -

      • start (GridNode) – start node

        • -

      • end (GridNode) – end node

        • -

      • grid (Grid) – grid that stores all possible steps/tiles as 3D-list

        • -

      • open_list (List) – stores nodes that will be processed next

        • -

      • open_value (int) –

        • -
      -
      -
      Returns:
      -

      path

      -
      -
      Return type:
      -

      Optional[List[GridNode]]

      -
      -
      -
      - -
      -
      -find_neighbors(grid, node, diagonal_movement=None)
      -

      Find neighbor, same for Djikstra, A*, Bi-A*, IDA*

      -
      -
      Parameters:
      -
        -

      • grid (Grid) – grid that stores all possible steps/tiles as 3D-list

        • -

      • node (GridNode) – node to find neighbors for

        • -

      • diagonal_movement (int) – if diagonal movement is allowed -(see enum in diagonal_movement)

        • -
      -
      -
      Returns:
      -

      list of neighbors

      -
      -
      Return type:
      -

      List[GridNode]

      -
      -
      -
      - -
      -
      -keep_running()
      -

      Check, if we run into time or iteration constrains.

      -
      -
      Raises:
      -
      -
      -
      -
      - -
      -
      -process_node(grid, node, parent, end, open_list, open_value=1)
      -

      We check if the given node is part of the path by calculating its -cost and add or remove it from our path

      -
      -
      Parameters:
      -
        -

      • grid (Grid) – grid that stores all possible steps/tiles as 3D-list

        • -

      • node (GridNode) – the node we like to test -(the neighbor in A* or jump-node in JumpPointSearch)

        • -

      • parent (GridNode) – the parent node (of the current node we like to test)

        • -

      • end (GridNode) – the end point to calculate the cost of the path

        • -

      • open_list (List) – the list that keeps track of our current path

        • -

      • open_value (bool) – needed if we like to set the open list to something -else than True (used for bi-directional algorithms)

        • -
      -
      -
      -
      - -
      - -
      -
      -

      pathfinding3d.finder.breadth_first module

      -
      -
      -class pathfinding3d.finder.breadth_first.BreadthFirstFinder(heuristic=None, weight=1, diagonal_movement=DiagonalMovement.never, time_limit=TIME_LIMIT, max_runs=MAX_RUNS)[source]
      -

      Bases: Finder

      -
      -
      Parameters:
      -
        -

      • heuristic (Callable | None) –

        • -

      • weight (int) –

        • -

      • diagonal_movement (int) –

        • -

      • time_limit (float) –

        • -

      • max_runs (int | float) –

        • -
      -
      -
      -
      -
      -__init__(heuristic=None, weight=1, diagonal_movement=DiagonalMovement.never, time_limit=TIME_LIMIT, max_runs=MAX_RUNS)[source]
      -

      Find shortest path using Breadth First algorithm

      -
      -
      Parameters:
      -
        -

      • heuristic (Callable) – heuristic used to calculate distance of 2 points

        • -

      • weight (int) – weight for the edges

        • -

      • diagonal_movement (int) – if diagonal movement is allowed -(see enum in diagonal_movement)

        • -

      • time_limit (float) – max. runtime in seconds

        • -

      • max_runs (int) – max. amount of tries until we abort the search -(optional, only if we enter huge grids and have time constrains) -<=0 means there are no constrains and the code might run on any -large map.

        • -
      -
      -
      -
      - -
      -
      -check_neighbors(start, end, grid, open_list)[source]
      -

      Find next path segment based on given node -(or return path if we found the end)

      -
      -
      Parameters:
      -
        -

      • start (GridNode) – start node

        • -

      • end (GridNode) – end node

        • -

      • grid (Grid) – grid that stores all possible steps/tiles as 3D-list

        • -

      • open_list (List) – stores nodes that will be processed next

        • -
      -
      -
      Returns:
      -

      path

      -
      -
      Return type:
      -

      List[GridNode]

      -
      -
      -
      - -
      -
      -apply_heuristic(node_a, node_b, heuristic=None)
      -

      Helper function to apply heuristic

      -
      -
      Parameters:
      -
        -

      • node_a (GridNode) – first node

        • -

      • node_b (GridNode) – second node

        • -

      • heuristic (Callable) – heuristic used to calculate distance of 2 points

        • -
      -
      -
      Returns:
      -

      heuristic value

      -
      -
      Return type:
      -

      float

      -
      -
      -
      - -
      -
      -find_neighbors(grid, node, diagonal_movement=None)
      -

      Find neighbor, same for Djikstra, A*, Bi-A*, IDA*

      -
      -
      Parameters:
      -
        -

      • grid (Grid) – grid that stores all possible steps/tiles as 3D-list

        • -

      • node (GridNode) – node to find neighbors for

        • -

      • diagonal_movement (int) – if diagonal movement is allowed -(see enum in diagonal_movement)

        • -
      -
      -
      Returns:
      -

      list of neighbors

      -
      -
      Return type:
      -

      List[GridNode]

      -
      -
      -
      - -
      -
      -find_path(start, end, grid)
      -

      Find a path from start to end node on grid by iterating over -all neighbors of a node (see check_neighbors)

      -
      -
      Parameters:
      -
        -

      • start (GridNode) – start node

        • -

      • end (GridNode) – end node

        • -

      • grid (Grid) – grid that stores all possible steps/tiles as 3D-list -(can be a list of grids)

        • -
      -
      -
      Returns:
      -

      path, number of iterations

      -
      -
      Return type:
      -

      Tuple[List, int]

      -
      -
      -
      - -
      -
      -keep_running()
      -

      Check, if we run into time or iteration constrains.

      -
      -
      Raises:
      -
      -
      -
      -
      - -
      -
      -process_node(grid, node, parent, end, open_list, open_value=1)
      -

      We check if the given node is part of the path by calculating its -cost and add or remove it from our path

      -
      -
      Parameters:
      -
        -

      • grid (Grid) – grid that stores all possible steps/tiles as 3D-list

        • -

      • node (GridNode) – the node we like to test -(the neighbor in A* or jump-node in JumpPointSearch)

        • -

      • parent (GridNode) – the parent node (of the current node we like to test)

        • -

      • end (GridNode) – the end point to calculate the cost of the path

        • -

      • open_list (List) – the list that keeps track of our current path

        • -

      • open_value (bool) – needed if we like to set the open list to something -else than True (used for bi-directional algorithms)

        • -
      -
      -
      -
      - -
      - -
      -
      -

      pathfinding3d.finder.dijkstra module

      -
      -
      -class pathfinding3d.finder.dijkstra.DijkstraFinder(weight=1, diagonal_movement=DiagonalMovement.never, time_limit=TIME_LIMIT, max_runs=MAX_RUNS)[source]
      -

      Bases: AStarFinder

      -
      -
      Parameters:
      -
        -

      • weight (int) –

        • -

      • diagonal_movement (int) –

        • -

      • time_limit (float) –

        • -

      • max_runs (int | float) –

        • -
      -
      -
      -
      -
      -__init__(weight=1, diagonal_movement=DiagonalMovement.never, time_limit=TIME_LIMIT, max_runs=MAX_RUNS)[source]
      -

      Find shortest path using Dijkstra algorithm

      -
      -
      Parameters:
      -
        -

      • weight (int) – weight for the edges

        • -

      • diagonal_movement (int) – if diagonal movement is allowed -(see enum in diagonal_movement)

        • -

      • time_limit (float) – max. runtime in seconds

        • -

      • max_runs (int) – max. amount of tries until we abort the search -(optional, only if we enter huge grids and have time constrains) -<=0 means there are no constrains and the code might run on any -large map.

        • -
      -
      -
      -
      - -
      -
      -apply_heuristic(node_a, node_b, heuristic=None)[source]
      -

      Helper function to apply heuristic

      -
      -
      Parameters:
      -
        -

      • node_a (Node) – first node

        • -

      • node_b (Node) – second node

        • -

      • heuristic (Callable) – heuristic used to calculate distance of 2 points

        • -
      -
      -
      Returns:
      -

      0.0

      -
      -
      Return type:
      -

      float

      -
      -
      -
      - -
      -
      -check_neighbors(start, end, grid, open_list, open_value=1, backtrace_by=None)
      -

      Find next path segment based on given node -(or return path if we found the end)

      -
      -
      Parameters:
      -
        -

      • start (GridNode) – start node

        • -

      • end (GridNode) – end node

        • -

      • grid (Grid) – grid that stores all possible steps/tiles as 3D-list

        • -

      • open_list (List) – stores nodes that will be processed next

        • -

      • open_value (int) –

        • -
      -
      -
      Returns:
      -

      path

      -
      -
      Return type:
      -

      Optional[List[GridNode]]

      -
      -
      -
      - -
      -
      -find_neighbors(grid, node, diagonal_movement=None)
      -

      Find neighbor, same for Djikstra, A*, Bi-A*, IDA*

      -
      -
      Parameters:
      -
        -

      • grid (Grid) – grid that stores all possible steps/tiles as 3D-list

        • -

      • node (GridNode) – node to find neighbors for

        • -

      • diagonal_movement (int) – if diagonal movement is allowed -(see enum in diagonal_movement)

        • -
      -
      -
      Returns:
      -

      list of neighbors

      -
      -
      Return type:
      -

      List[GridNode]

      -
      -
      -
      - -
      -
      -find_path(start, end, grid)
      -

      Find a path from start to end node on grid using the A* algorithm

      -
      -
      Parameters:
      -
        -

      • start (GridNode) – start node

        • -

      • end (GridNode) – end node

        • -

      • grid (Grid) – grid that stores all possible steps/tiles as 3D-list

        • -
      -
      -
      Returns:
      -

      path, number of iterations

      -
      -
      Return type:
      -

      Tuple[List, int]

      -
      -
      -
      - -
      -
      -keep_running()
      -

      Check, if we run into time or iteration constrains.

      -
      -
      Raises:
      -
      -
      -
      -
      - -
      -
      -process_node(grid, node, parent, end, open_list, open_value=1)
      -

      We check if the given node is part of the path by calculating its -cost and add or remove it from our path

      -
      -
      Parameters:
      -
        -

      • grid (Grid) – grid that stores all possible steps/tiles as 3D-list

        • -

      • node (GridNode) – the node we like to test -(the neighbor in A* or jump-node in JumpPointSearch)

        • -

      • parent (GridNode) – the parent node (of the current node we like to test)

        • -

      • end (GridNode) – the end point to calculate the cost of the path

        • -

      • open_list (List) – the list that keeps track of our current path

        • -

      • open_value (bool) – needed if we like to set the open list to something -else than True (used for bi-directional algorithms)

        • -
      -
      -
      -
      - -
      - -
      -
      -

      pathfinding3d.finder.finder module

      -
      -
      -exception pathfinding3d.finder.finder.ExecutionTimeException(message)[source]
      -

      Bases: Exception

      -
      -
      -__init__(message)[source]
      -
      - -
      -
      -args
      -
      - -
      -
      -with_traceback()
      -

      Exception.with_traceback(tb) – -set self.__traceback__ to tb and return self.

      -
      - -
      - -
      -
      -exception pathfinding3d.finder.finder.ExecutionRunsException(message)[source]
      -

      Bases: Exception

      -
      -
      -__init__(message)[source]
      -
      - -
      -
      -args
      -
      - -
      -
      -with_traceback()
      -

      Exception.with_traceback(tb) – -set self.__traceback__ to tb and return self.

      -
      - -
      - -
      -
      -class pathfinding3d.finder.finder.Finder(heuristic=None, weight=1, diagonal_movement=DiagonalMovement.never, weighted=True, time_limit=TIME_LIMIT, max_runs=MAX_RUNS)[source]
      -

      Bases: object

      -
      -
      Parameters:
      -
        -

      • heuristic (Callable | None) –

        • -

      • weight (int) –

        • -

      • diagonal_movement (int) –

        • -

      • weighted (bool) –

        • -

      • time_limit (float) –

        • -

      • max_runs (int | float) –

        • -
      -
      -
      -
      -
      -__init__(heuristic=None, weight=1, diagonal_movement=DiagonalMovement.never, weighted=True, time_limit=TIME_LIMIT, max_runs=MAX_RUNS)[source]
      -

      Find shortest path

      -
      -
      Parameters:
      -
        -

      • heuristic (Callable) – heuristic used to calculate distance of 2 points

        • -

      • weight (int) – weight for the edges

        • -

      • diagonal_movement (int) – if diagonal movement is allowed -(see enum in diagonal_movement)

        • -

      • weighted (the algorithm supports weighted nodes) – (should be True for A* and Dijkstra)

        • -

      • time_limit (float) – max. runtime in seconds

        • -

      • max_runs (int) – max. amount of tries until we abort the search -(optional, only if we enter huge grids and have time constrains) -<=0 means there are no constrains and the code might run on any -large map.

        • -
      -
      -
      -
      - -
      -
      -apply_heuristic(node_a, node_b, heuristic=None)[source]
      -

      Helper function to apply heuristic

      -
      -
      Parameters:
      -
        -

      • node_a (GridNode) – first node

        • -

      • node_b (GridNode) – second node

        • -

      • heuristic (Callable) – heuristic used to calculate distance of 2 points

        • -
      -
      -
      Returns:
      -

      heuristic value

      -
      -
      Return type:
      -

      float

      -
      -
      -
      - -
      -
      -find_neighbors(grid, node, diagonal_movement=None)[source]
      -

      Find neighbor, same for Djikstra, A*, Bi-A*, IDA*

      -
      -
      Parameters:
      -
        -

      • grid (Grid) – grid that stores all possible steps/tiles as 3D-list

        • -

      • node (GridNode) – node to find neighbors for

        • -

      • diagonal_movement (int) – if diagonal movement is allowed -(see enum in diagonal_movement)

        • -
      -
      -
      Returns:
      -

      list of neighbors

      -
      -
      Return type:
      -

      List[GridNode]

      -
      -
      -
      - -
      -
      -keep_running()[source]
      -

      Check, if we run into time or iteration constrains.

      -
      -
      Raises:
      -
      -
      -
      -
      - -
      -
      -process_node(grid, node, parent, end, open_list, open_value=1)[source]
      -

      We check if the given node is part of the path by calculating its -cost and add or remove it from our path

      -
      -
      Parameters:
      -
        -

      • grid (Grid) – grid that stores all possible steps/tiles as 3D-list

        • -

      • node (GridNode) – the node we like to test -(the neighbor in A* or jump-node in JumpPointSearch)

        • -

      • parent (GridNode) – the parent node (of the current node we like to test)

        • -

      • end (GridNode) – the end point to calculate the cost of the path

        • -

      • open_list (List) – the list that keeps track of our current path

        • -

      • open_value (bool) – needed if we like to set the open list to something -else than True (used for bi-directional algorithms)

        • -
      -
      -
      -
      - -
      -
      -check_neighbors(start, end, grid, open_list, open_value=1, backtrace_by=None)[source]
      -

      find next path segment based on given node -(or return path if we found the end)

      -
      -
      Parameters:
      -
        -

      • start (GridNode) – start node

        • -

      • end (GridNode) – end node

        • -

      • grid (Grid) – grid that stores all possible steps/tiles as 3D-list

        • -

      • open_list (List) – stores nodes that will be processed next

        • -

      • open_value (int) –

        • +
      -
      -
      Returns:
      -

      path

      -
      -
      Return type:
      -

      Optional[List[GridNode]]

      -
      -
      -
      - -
      -
      -find_path(start, end, grid)[source]
      -

      Find a path from start to end node on grid by iterating over -all neighbors of a node (see check_neighbors)

      -
      -
      Parameters:
      -
      -
      Returns:
      -

      path, number of iterations

      -
      -
      Return type:
      -

      Tuple[List, int]

      -
      -
      -
      - -
      - -
      -
      -

      pathfinding3d.finder.ida_star module

      -
      -
      -class pathfinding3d.finder.ida_star.IDAStarFinder(heuristic=None, weight=1, diagonal_movement=DiagonalMovement.never, time_limit=TIME_LIMIT, max_runs=MAX_RUNS, track_recursion=True)[source]
      -

      Bases: Finder

      -

      Iterative Deeping A Star (IDA*) path-finder.

      -

      Recursion based on: -http://www.apl.jhu.edu/~hall/AI-Programming/IDA-Star.html

      -

      Path retracing based on: -V. Nageshwara Rao, Vipin Kumar and K. Ramesh -“A Parallel Implementation of Iterative-Deeping-A*”, January 1987. -ftp://ftp.cs.utexas.edu/.snapshot/hourly.1/pub/AI-Lab/tech-reports/ -UT-AI-TR-87-46.pdf

      -

      based on the JavaScript implementation by Gerard Meier -(www.gerardmeier.com)

      -
      -
      Parameters:
      -
        -

      • heuristic (Callable | None) –

        • -

      • weight (int) –

        • -

      • diagonal_movement (int) –

        • -

      • time_limit (float) –

        • -

      • max_runs (int | float) –

        • -

      • track_recursion (bool) –

        • +
      -
      -
      -
      -
      -__init__(heuristic=None, weight=1, diagonal_movement=DiagonalMovement.never, time_limit=TIME_LIMIT, max_runs=MAX_RUNS, track_recursion=True)[source]
      -

      Find shortest path using IDA* algorithm

      -
      -
      Parameters:
      -
      -
      -
      - -
      -
      -search(node, g, cutoff, path, depth, end, grid)[source]
      -

      Recursive IDA* search implementation

      -
      -
      Parameters:
      -
        -

      • node (GridNode) – current node

        • -

      • g (float) – cost from start to current node

        • -

      • cutoff (float) – cutoff cost

        • -

      • path (List[GridNode]) – path

        • -

      • depth (int) – current depth

        • -

      • end (GridNode) – end node

        • -

      • grid (Grid) – grid that stores all possible steps/tiles as 3D-list

        • +
      -
      -
      Returns:
      -

      cutoff cost or end node

      -
      -
      Return type:
      -

      Union[float, GridNode]

      -
      -
      -
      - -
      -
      -apply_heuristic(node_a, node_b, heuristic=None)
      -

      Helper function to apply heuristic

      -
      -
      Parameters:
      -
      -
      Returns:
      -

      heuristic value

      -
      -
      Return type:
      -

      float

      -
      -
      -
      - -
      -
      -check_neighbors(start, end, grid, open_list, open_value=1, backtrace_by=None)
      -

      find next path segment based on given node -(or return path if we found the end)

      -
      -
      Parameters:
      -
        -

      • start (GridNode) – start node

        • -

      • end (GridNode) – end node

        • -

      • grid (Grid) – grid that stores all possible steps/tiles as 3D-list

        • -

      • open_list (List) – stores nodes that will be processed next

        • -

      • open_value (int) –

        • +
      -
      -
      Returns:
      -

      path

      -
      -
      Return type:
      -

      Optional[List[GridNode]]

      -
      -
      -
      - -
      -
      -find_neighbors(grid, node, diagonal_movement=None)
      -

      Find neighbor, same for Djikstra, A*, Bi-A*, IDA*

      -
      -
      Parameters:
      -
      -
      Returns:
      -

      list of neighbors

      -
      -
      Return type:
      -

      List[GridNode]

      -
      -
      -
      - -
      -
      -find_path(start, end, grid)[source]
      -

      Find a path from start to end node on grid using the IDA* algorithm

      -
      -
      Parameters:
      -
        -

      • start (GridNode) – start node

        • -

      • end (GridNode) – end node

        • -

      • grid (Grid) – grid that stores all possible steps/tiles as 3D-list

        • +
      -
      -
      Returns:
      -

      path, number of iterations

      -
      -
      Return type:
      -

      Tuple[List, int]

      -
      -
      -
      - -
      -
      -keep_running()
      -

      Check, if we run into time or iteration constrains.

      -
      -
      Raises:
      -
      -
      -
      - -
      -
      -process_node(grid, node, parent, end, open_list, open_value=1)
      -

      We check if the given node is part of the path by calculating its -cost and add or remove it from our path

      -
      -
      Parameters:
      -
      -
      -
      - -
      - -
      -
      -

      pathfinding3d.finder.msp module

      -
      -
      -class pathfinding3d.finder.msp.MinimumSpanningTree(*args, **kwargs)[source]
      -

      Bases: Finder

      -

      Minimum Spanning Tree implementation by Brad Beattie -(see https://github.com/brean/python-pathfinding/issues/18)

      -

      The wikipedia page has a nice description about MSP: -https://en.wikipedia.org/wiki/Minimum_spanning_tree

      -
      -
      -__init__(*args, **kwargs)[source]
      -

      Find shortest path

      -
      -
      Parameters:
      -
      -
      -
      - -
      -
      -tree(grid, start)[source]
      -

      Returns a list of nodes that are part of the minimum spanning tree -of the grid.

      -
      -
      Parameters:
      -
        -

      • grid (Grid) – grid that stores all possible steps/tiles as 3D-list

        • -

      • start (GridNode) – start node

        • +
      -
      -
      Return type:
      -

      List[GridNode]

      -
      -
      -
      - -
      -
      -itertree(grid, start)[source]
      -

      Returns a generator that yields nodes that are part of the minimum -spanning tree of the grid.

      -
      -
      Parameters:
      -
      -
      -
      - -
      -
      -find_path(start, end, grid)[source]
      -

      Find a path from start to end node on grid using the Minimum Spanning -Tree algorithm

      -
      -
      Parameters:
      -
        -

      • start (GridNode) – start node

        • -

      • end (GridNode) – end node

        • -

      • grid (Grid) – grid that stores all possible steps/tiles as 3D-list

        • +
      -
      -
      Returns:
      -

      path, number of iterations

      -
      -
      Return type:
      -

      Tuple[List, int]

      -
      -
      -
      - -
      -
      -apply_heuristic(node_a, node_b, heuristic=None)
      -

      Helper function to apply heuristic

      -
      -
      Parameters:
      -
      -
      Returns:
      -

      heuristic value

      -
      -
      Return type:
      -

      float

      -
      -
      -
      - -
      -
      -check_neighbors(start, end, grid, open_list, open_value=1, backtrace_by=None)
      -

      find next path segment based on given node -(or return path if we found the end)

      -
      -
      Parameters:
      -
        -

      • start (GridNode) – start node

        • -

      • end (GridNode) – end node

        • -

      • grid (Grid) – grid that stores all possible steps/tiles as 3D-list

        • -

      • open_list (List) – stores nodes that will be processed next

        • -

      • open_value (int) –

        • +
      -
      -
      Returns:
      -

      path

      -
      -
      Return type:
      -

      Optional[List[GridNode]]

      -
      -
      -
      - -
      -
      -find_neighbors(grid, node, diagonal_movement=None)
      -

      Find neighbor, same for Djikstra, A*, Bi-A*, IDA*

      -
      -
      Parameters:
      -
      -
      Returns:
      -

      list of neighbors

      -
      -
      Return type:
      -

      List[GridNode]

      -
      -
      -
      - -
      -
      -keep_running()
      -

      Check, if we run into time or iteration constrains.

      -
      -
      Raises:
      -
      -
      -
      -
      - -
      -
      -process_node(grid, node, parent, end, open_list, open_value=1)
      -

      We check if the given node is part of the path by calculating its -cost and add or remove it from our path

      -
      -
      Parameters:
      -
        -

      • grid (Grid) – grid that stores all possible steps/tiles as 3D-list

        • -

      • node (GridNode) – the node we like to test -(the neighbor in A* or jump-node in JumpPointSearch)

        • -

      • parent (GridNode) – the parent node (of the current node we like to test)

        • -

      • end (GridNode) – the end point to calculate the cost of the path

        • -

      • open_list (List) – the list that keeps track of our current path

        • -

      • open_value (bool) – needed if we like to set the open list to something -else than True (used for bi-directional algorithms)

        • +
      -
      -
      -
      - -
      - +
    • @@ -1568,7 +277,8 @@

    Submodules - + +
    diff --git a/pathfinding3d.finder.ida_star.html b/pathfinding3d.finder.ida_star.html new file mode 100644 index 0000000..c455ea7 --- /dev/null +++ b/pathfinding3d.finder.ida_star.html @@ -0,0 +1,364 @@ + + + + + + + pathfinding3d.finder.ida_star module — pathfinding3d 0.6.2 documentation + + + + + + + + + + + + + + + + + + + + + + + + +
    + + +
    + +
    +
    +
    + +
    +
    +
    +
    + +
    +

    pathfinding3d.finder.ida_star module

    +
    +
    +class pathfinding3d.finder.ida_star.IDAStarFinder(heuristic=None, weight=1, diagonal_movement=DiagonalMovement.never, time_limit=TIME_LIMIT, max_runs=MAX_RUNS, track_recursion=True)[source]
    +

    Bases: Finder

    +

    Iterative Deeping A Star (IDA*) path-finder.

    +

    Recursion based on: +http://www.apl.jhu.edu/~hall/AI-Programming/IDA-Star.html

    +

    Path retracing based on: +V. Nageshwara Rao, Vipin Kumar and K. Ramesh +“A Parallel Implementation of Iterative-Deeping-A*”, January 1987. +ftp://ftp.cs.utexas.edu/.snapshot/hourly.1/pub/AI-Lab/tech-reports/ +UT-AI-TR-87-46.pdf

    +

    based on the JavaScript implementation by Gerard Meier +(www.gerardmeier.com)

    +
    +
    Parameters:
    +
      +

    • heuristic (Callable | None) –

      • +

    • weight (int) –

      • +

    • diagonal_movement (int) –

      • +

    • time_limit (float) –

      • +

    • max_runs (int | float) –

      • +

    • track_recursion (bool) –

      • +
    +
    +
    +
    +
    +__init__(heuristic=None, weight=1, diagonal_movement=DiagonalMovement.never, time_limit=TIME_LIMIT, max_runs=MAX_RUNS, track_recursion=True)[source]
    +

    Find shortest path using IDA* algorithm

    +
    +
    Parameters:
    +
      +

    • heuristic (Callable) – heuristic used to calculate distance of 2 points

      • +

    • weight (int) – weight for the edges

      • +

    • diagonal_movement (int) – if diagonal movement is allowed +(see enum in diagonal_movement)

      • +

    • time_limit (float) – max. runtime in seconds

      • +

    • max_runs (int) – max. amount of tries until we abort the search +(optional, only if we enter huge grids and have time constrains) +<=0 means there are no constrains and the code might run on any +large map.

      • +

    • track_recursion (bool) – if we should track recursion

      • +
    +
    +
    +
    + +
    +
    +search(node, g, cutoff, path, depth, end, grid)[source]
    +

    Recursive IDA* search implementation

    +
    +
    Parameters:
    +
      +

    • node (GridNode) – current node

      • +

    • g (float) – cost from start to current node

      • +

    • cutoff (float) – cutoff cost

      • +

    • path (List[GridNode]) – path

      • +

    • depth (int) – current depth

      • +

    • end (GridNode) – end node

      • +

    • grid (Grid) – grid that stores all possible steps/tiles as 3D-list

      • +
    +
    +
    Returns:
    +

    cutoff cost or end node

    +
    +
    Return type:
    +

    Union[float, GridNode]

    +
    +
    +
    + +
    +
    +apply_heuristic(node_a, node_b, heuristic=None)
    +

    Helper function to apply heuristic

    +
    +
    Parameters:
    +
      +

    • node_a (GridNode) – first node

      • +

    • node_b (GridNode) – second node

      • +

    • heuristic (Callable) – heuristic used to calculate distance of 2 points

      • +
    +
    +
    Returns:
    +

    heuristic value

    +
    +
    Return type:
    +

    float

    +
    +
    +
    + +
    +
    +check_neighbors(start, end, grid, open_list, open_value=1, backtrace_by=None)
    +

    find next path segment based on given node +(or return path if we found the end)

    +
    +
    Parameters:
    +
      +

    • start (GridNode) – start node

      • +

    • end (GridNode) – end node

      • +

    • grid (Grid) – grid that stores all possible steps/tiles as 3D-list

      • +

    • open_list (List) – stores nodes that will be processed next

      • +

    • open_value (int) –

      • +
    +
    +
    Returns:
    +

    path

    +
    +
    Return type:
    +

    Optional[List[GridNode]]

    +
    +
    +
    + +
    +
    +find_neighbors(grid, node, diagonal_movement=None)
    +

    Find neighbor, same for Djikstra, A*, Bi-A*, IDA*

    +
    +
    Parameters:
    +
      +

    • grid (Grid) – grid that stores all possible steps/tiles as 3D-list

      • +

    • node (GridNode) – node to find neighbors for

      • +

    • diagonal_movement (int) – if diagonal movement is allowed +(see enum in diagonal_movement)

      • +
    +
    +
    Returns:
    +

    list of neighbors

    +
    +
    Return type:
    +

    List[GridNode]

    +
    +
    +
    + +
    +
    +find_path(start, end, grid)[source]
    +

    Find a path from start to end node on grid using the IDA* algorithm

    +
    +
    Parameters:
    +
      +

    • start (GridNode) – start node

      • +

    • end (GridNode) – end node

      • +

    • grid (Grid) – grid that stores all possible steps/tiles as 3D-list

      • +
    +
    +
    Returns:
    +

    path, number of iterations

    +
    +
    Return type:
    +

    Tuple[List, int]

    +
    +
    +
    + +
    +
    +keep_running()
    +

    Check, if we run into time or iteration constrains.

    +
    +
    Raises:
    +
    +
    +
    +
    + +
    +
    +process_node(grid, node, parent, end, open_list, open_value=1)
    +

    We check if the given node is part of the path by calculating its +cost and add or remove it from our path

    +
    +
    Parameters:
    +
      +

    • grid (Grid) – grid that stores all possible steps/tiles as 3D-list

      • +

    • node (GridNode) – the node we like to test +(the neighbor in A* or jump-node in JumpPointSearch)

      • +

    • parent (GridNode) – the parent node (of the current node we like to test)

      • +

    • end (GridNode) – the end point to calculate the cost of the path

      • +

    • open_list (List) – the list that keeps track of our current path

      • +

    • open_value (bool) – needed if we like to set the open list to something +else than True (used for bi-directional algorithms)

      • +
    +
    +
    +
    + +
    + +
    + + +
    +
    +
    + +
    + +
    +

    © Copyright 2024, Harisankar Babu.

    +
    + + + +
    +
    +
    +
    +
    + + + + \ No newline at end of file diff --git a/pathfinding3d.finder.msp.html b/pathfinding3d.finder.msp.html new file mode 100644 index 0000000..f8242aa --- /dev/null +++ b/pathfinding3d.finder.msp.html @@ -0,0 +1,355 @@ + + + + + + + pathfinding3d.finder.msp module — pathfinding3d 0.6.2 documentation + + + + + + + + + + + + + + + + + + + + + + + + +
    + + +
    + +
    +
    +
    + +
    +
    +
    +
    + +
    +

    pathfinding3d.finder.msp module

    +
    +
    +class pathfinding3d.finder.msp.MinimumSpanningTree(*args, **kwargs)[source]
    +

    Bases: Finder

    +

    Minimum Spanning Tree implementation by Brad Beattie +(see https://github.com/brean/python-pathfinding/issues/18)

    +

    The wikipedia page has a nice description about MSP: +https://en.wikipedia.org/wiki/Minimum_spanning_tree

    +
    +
    +__init__(*args, **kwargs)[source]
    +

    Find shortest path

    +
    +
    Parameters:
    +
      +

    • heuristic (Callable) – heuristic used to calculate distance of 2 points

      • +

    • weight (int) – weight for the edges

      • +

    • diagonal_movement (int) – if diagonal movement is allowed +(see enum in diagonal_movement)

      • +

    • weighted (the algorithm supports weighted nodes) – (should be True for A* and Dijkstra)

      • +

    • time_limit (float) – max. runtime in seconds

      • +

    • max_runs (int) – max. amount of tries until we abort the search +(optional, only if we enter huge grids and have time constrains) +<=0 means there are no constrains and the code might run on any +large map.

      • +
    +
    +
    +
    + +
    +
    +tree(grid, start)[source]
    +

    Returns a list of nodes that are part of the minimum spanning tree +of the grid.

    +
    +
    Parameters:
    +
      +

    • grid (Grid) – grid that stores all possible steps/tiles as 3D-list

      • +

    • start (GridNode) – start node

      • +
    +
    +
    Return type:
    +

    List[GridNode]

    +
    +
    +
    + +
    +
    +itertree(grid, start)[source]
    +

    Returns a generator that yields nodes that are part of the minimum +spanning tree of the grid.

    +
    +
    Parameters:
    +
      +

    • grid (Grid) – grid that stores all possible steps/tiles as 3D-list

      • +

    • start (GridNode) – start node

      • +
    +
    +
    +
    + +
    +
    +find_path(start, end, grid)[source]
    +

    Find a path from start to end node on grid using the Minimum Spanning +Tree algorithm

    +
    +
    Parameters:
    +
      +

    • start (GridNode) – start node

      • +

    • end (GridNode) – end node

      • +

    • grid (Grid) – grid that stores all possible steps/tiles as 3D-list

      • +
    +
    +
    Returns:
    +

    path, number of iterations

    +
    +
    Return type:
    +

    Tuple[List, int]

    +
    +
    +
    + +
    +
    +apply_heuristic(node_a, node_b, heuristic=None)
    +

    Helper function to apply heuristic

    +
    +
    Parameters:
    +
      +

    • node_a (GridNode) – first node

      • +

    • node_b (GridNode) – second node

      • +

    • heuristic (Callable) – heuristic used to calculate distance of 2 points

      • +
    +
    +
    Returns:
    +

    heuristic value

    +
    +
    Return type:
    +

    float

    +
    +
    +
    + +
    +
    +check_neighbors(start, end, grid, open_list, open_value=1, backtrace_by=None)
    +

    find next path segment based on given node +(or return path if we found the end)

    +
    +
    Parameters:
    +
      +

    • start (GridNode) – start node

      • +

    • end (GridNode) – end node

      • +

    • grid (Grid) – grid that stores all possible steps/tiles as 3D-list

      • +

    • open_list (List) – stores nodes that will be processed next

      • +

    • open_value (int) –

      • +
    +
    +
    Returns:
    +

    path

    +
    +
    Return type:
    +

    Optional[List[GridNode]]

    +
    +
    +
    + +
    +
    +find_neighbors(grid, node, diagonal_movement=None)
    +

    Find neighbor, same for Djikstra, A*, Bi-A*, IDA*

    +
    +
    Parameters:
    +
      +

    • grid (Grid) – grid that stores all possible steps/tiles as 3D-list

      • +

    • node (GridNode) – node to find neighbors for

      • +

    • diagonal_movement (int) – if diagonal movement is allowed +(see enum in diagonal_movement)

      • +
    +
    +
    Returns:
    +

    list of neighbors

    +
    +
    Return type:
    +

    List[GridNode]

    +
    +
    +
    + +
    +
    +keep_running()
    +

    Check, if we run into time or iteration constrains.

    +
    +
    Raises:
    +
    +
    +
    +
    + +
    +
    +process_node(grid, node, parent, end, open_list, open_value=1)
    +

    We check if the given node is part of the path by calculating its +cost and add or remove it from our path

    +
    +
    Parameters:
    +
      +

    • grid (Grid) – grid that stores all possible steps/tiles as 3D-list

      • +

    • node (GridNode) – the node we like to test +(the neighbor in A* or jump-node in JumpPointSearch)

      • +

    • parent (GridNode) – the parent node (of the current node we like to test)

      • +

    • end (GridNode) – the end point to calculate the cost of the path

      • +

    • open_list (List) – the list that keeps track of our current path

      • +

    • open_value (bool) – needed if we like to set the open list to something +else than True (used for bi-directional algorithms)

      • +
    +
    +
    +
    + +
    + +
    + + +
    +
    +
    + +
    + +
    +

    © Copyright 2024, Harisankar Babu.

    +
    + + + +
    +
    +
    +
    +
    + + + + \ No newline at end of file diff --git a/pathfinding3d.finder.theta_star.html b/pathfinding3d.finder.theta_star.html new file mode 100644 index 0000000..9971270 --- /dev/null +++ b/pathfinding3d.finder.theta_star.html @@ -0,0 +1,325 @@ + + + + + + + pathfinding3d.finder.theta_star module — pathfinding3d 0.6.2 documentation + + + + + + + + + + + + + + + + + + + + + + + +
    + + +
    + +
    +
    +
    + +
    +
    +
    +
    + +
    +

    pathfinding3d.finder.theta_star module

    +
    +
    +class pathfinding3d.finder.theta_star.ThetaStarFinder(heuristic=None, weight=1, diagonal_movement=DiagonalMovement.always, time_limit=TIME_LIMIT, max_runs=MAX_RUNS)[source]
    +

    Bases: AStarFinder

    +
    +
    Parameters:
    +
      +

    • heuristic (Callable) –

      • +

    • weight (int) –

      • +

    • diagonal_movement (int) –

      • +

    • time_limit (float) –

      • +

    • max_runs (int | float) –

      • +
    +
    +
    +
    +
    +__init__(heuristic=None, weight=1, diagonal_movement=DiagonalMovement.always, time_limit=TIME_LIMIT, max_runs=MAX_RUNS)[source]
    +

    Find shortest path using Theta* algorithm +Diagonal movement is forced to always. Not weighted.

    +
    +
    Parameters:
    +
      +

    • heuristic (Callable) – heuristic used to calculate distance of 2 points

      • +

    • weight (int) – weight for the edges

      • +

    • diagonal_movement (int) – if diagonal movement is allowed +(see enum in diagonal_movement)

      • +

    • time_limit (float) – max. runtime in seconds

      • +

    • max_runs (int) – max. amount of tries until we abort the search +(optional, only if we enter huge grids and have time constrains) +<=0 means there are no constrains and the code might run on any +large map.

      • +
    +
    +
    +
    + +
    +
    +process_node(grid, node, parent, end, open_list, open_value=1)[source]
    +

    Check if we can reach the grandparent node directly from the current node +and if so, skip the parent.

    +
    +
    Parameters:
    +
      +

    • grid (Grid) – grid that stores all possible steps/tiles as 3D-list

      • +

    • node (GridNode) – the node we like to test

      • +

    • parent (GridNode) – the parent node (of the current node we like to test)

      • +

    • end (GridNode) – the end point to calculate the cost of the path

      • +

    • open_list (List) – the list that keeps track of our current path

      • +

    • open_value (bool) – needed if we like to set the open list to something +else than True (used for bi-directional algorithms)

      • +
    +
    +
    +
    + +
    +
    +apply_heuristic(node_a, node_b, heuristic=None)
    +

    Helper function to apply heuristic

    +
    +
    Parameters:
    +
      +

    • node_a (GridNode) – first node

      • +

    • node_b (GridNode) – second node

      • +

    • heuristic (Callable) – heuristic used to calculate distance of 2 points

      • +
    +
    +
    Returns:
    +

    heuristic value

    +
    +
    Return type:
    +

    float

    +
    +
    +
    + +
    +
    +check_neighbors(start, end, grid, open_list, open_value=1, backtrace_by=None)
    +

    Find next path segment based on given node +(or return path if we found the end)

    +
    +
    Parameters:
    +
      +

    • start (GridNode) – start node

      • +

    • end (GridNode) – end node

      • +

    • grid (Grid) – grid that stores all possible steps/tiles as 3D-list

      • +

    • open_list (List) – stores nodes that will be processed next

      • +

    • open_value (int) –

      • +
    +
    +
    Returns:
    +

    path

    +
    +
    Return type:
    +

    Optional[List[GridNode]]

    +
    +
    +
    + +
    +
    +find_neighbors(grid, node, diagonal_movement=None)
    +

    Find neighbor, same for Djikstra, A*, Bi-A*, IDA*

    +
    +
    Parameters:
    +
      +

    • grid (Grid) – grid that stores all possible steps/tiles as 3D-list

      • +

    • node (GridNode) – node to find neighbors for

      • +

    • diagonal_movement (int) – if diagonal movement is allowed +(see enum in diagonal_movement)

      • +
    +
    +
    Returns:
    +

    list of neighbors

    +
    +
    Return type:
    +

    List[GridNode]

    +
    +
    +
    + +
    +
    +find_path(start, end, grid)
    +

    Find a path from start to end node on grid using the A* algorithm

    +
    +
    Parameters:
    +
      +

    • start (GridNode) – start node

      • +

    • end (GridNode) – end node

      • +

    • grid (Grid) – grid that stores all possible steps/tiles as 3D-list

      • +
    +
    +
    Returns:
    +

    path, number of iterations

    +
    +
    Return type:
    +

    Tuple[List, int]

    +
    +
    +
    + +
    +
    +keep_running()
    +

    Check, if we run into time or iteration constrains.

    +
    +
    Raises:
    +
    +
    +
    +
    + +
    + +
    + + +
    +
    +
    + +
    + +
    +

    © Copyright 2024, Harisankar Babu.

    +
    + + + +
    +
    +
    +
    +
    + + + + \ No newline at end of file diff --git a/pathfinding3d.html b/pathfinding3d.html index 0767ddb..ecee1e1 100644 --- a/pathfinding3d.html +++ b/pathfinding3d.html @@ -4,7 +4,7 @@ - pathfinding3d package — pathfinding3d 0.6.1 documentation + pathfinding3d package — pathfinding3d 0.6.2 documentation @@ -18,7 +18,7 @@ - + @@ -42,7 +42,7 @@ pathfinding3d
    - 0.6.1 + 0.6.2
    @@ -79,16 +79,17 @@
  • Change Log
  • pathfinding3d
      @@ -135,122 +136,45 @@

      Subpackages
      • pathfinding3d.core package
          -
        • Submodules
          • -
        • pathfinding3d.core.diagonal_movement module
            -
          • DiagonalMovement
              -
            • DiagonalMovement.always
              • -
            • DiagonalMovement.never
              • -
            • DiagonalMovement.if_at_most_one_obstacle
              • -
            • DiagonalMovement.only_when_no_obstacle
              • +
            • Submodules
                +
              • pathfinding3d.core.diagonal_movement module
                • +
              • pathfinding3d.core.grid module
                • -
              • pathfinding3d.core.grid module
                  -
                • build_nodes()
                  • -
                • Grid
                    -
                  • Grid.__init__()
                    • -
                  • Grid._validate_dimensions()
                    • -
                  • Grid.is_valid_grid()
                    • -
                  • Grid.node()
                    • -
                  • Grid.inside()
                    • -
                  • Grid.walkable()
                    • -
                  • Grid._calc_cost()
                    • -
                  • Grid.calc_cost()
                    • -
                  • Grid.neighbors()
                    • -
                  • Grid.cleanup()
                    • +
                  • pathfinding3d.core.heap module
                    • +
                  • pathfinding3d.core.heuristic module
                    • -
                  • pathfinding3d.core.heap module
                      -
                    • SimpleHeap
                        -
                      • SimpleHeap.__init__()
                        • -
                      • SimpleHeap._determine_node_retrieval_function()
                        • -
                      • SimpleHeap._determine_node_function()
                        • -
                      • SimpleHeap.pop_node()
                        • -
                      • SimpleHeap.push_node()
                        • -
                      • SimpleHeap.remove_node()
                        • +
                      • pathfinding3d.core.node module
                        • +
                      • pathfinding3d.core.util module
                        • -
                      • pathfinding3d.core.heuristic module -
                        • -
                      • pathfinding3d.core.node module -
                        • -
                      • pathfinding3d.core.util module -
                        • -
                      • pathfinding3d.core.world module
                          -
                        • World @@ -258,122 +182,43 @@

                          Subpackagespathfinding3d.finder package
                            -
                          • Submodules
                            • -
                          • pathfinding3d.finder.a_star module -
                            • -
                          • pathfinding3d.finder.best_first module -
                            • -
                          • pathfinding3d.finder.bi_a_star module -
                            • -
                          • pathfinding3d.finder.breadth_first module -
                            • -
                          • pathfinding3d.finder.dijkstra module
                              -
                            • DijkstraFinder
                                -
                              • DijkstraFinder.__init__()
                                • -
                              • DijkstraFinder.apply_heuristic()
                                • -
                              • DijkstraFinder.check_neighbors()
                                • -
                              • DijkstraFinder.find_neighbors()
                                • -
                              • DijkstraFinder.find_path()
                                • -
                              • DijkstraFinder.keep_running()
                                • -
                              • DijkstraFinder.process_node()
                                • +
                              • Submodules
                                  +
                                • pathfinding3d.finder.a_star module
                                  • +
                                • pathfinding3d.finder.best_first module
                                  • -
                                • pathfinding3d.finder.finder module
                                    -
                                  • ExecutionTimeException
                                      -
                                    • ExecutionTimeException.__init__()
                                      • -
                                    • ExecutionTimeException.args
                                      • -
                                    • ExecutionTimeException.with_traceback()
                                      • +
                                    • pathfinding3d.finder.bi_a_star module
                                      • -
                                    • ExecutionRunsException
                                        -
                                      • ExecutionRunsException.__init__()
                                        • -
                                      • ExecutionRunsException.args
                                        • -
                                      • ExecutionRunsException.with_traceback()
                                        • +
                                      • pathfinding3d.finder.breadth_first module
                                        • -
                                      • Finder
                                          -
                                        • Finder.__init__()
                                          • -
                                        • Finder.apply_heuristic()
                                          • -
                                        • Finder.find_neighbors()
                                          • -
                                        • Finder.keep_running()
                                          • -
                                        • Finder.process_node()
                                          • -
                                        • Finder.check_neighbors()
                                          • -
                                        • Finder.find_path()
                                          • +
                                        • pathfinding3d.finder.dijkstra module
                                          • +
                                        • pathfinding3d.finder.finder module
                                          • -
                                        • pathfinding3d.finder.ida_star module
                                            -
                                          • IDAStarFinder
                                              -
                                            • IDAStarFinder.__init__()
                                              • -
                                            • IDAStarFinder.search()
                                              • -
                                            • IDAStarFinder.apply_heuristic()
                                              • -
                                            • IDAStarFinder.check_neighbors()
                                              • -
                                            • IDAStarFinder.find_neighbors()
                                              • -
                                            • IDAStarFinder.find_path()
                                              • -
                                            • IDAStarFinder.keep_running()
                                              • -
                                            • IDAStarFinder.process_node()
                                              • +
                                            • pathfinding3d.finder.ida_star module
                                              • +
                                            • pathfinding3d.finder.msp module
                                              • -
                                            • pathfinding3d.finder.msp module
                                            • Change Log
                                            • pathfinding3d
                                            • Change Log
                                            • pathfinding3d
                                                diff --git a/searchindex.js b/searchindex.js index e3f5691..465f29c 100644 --- a/searchindex.js +++ b/searchindex.js @@ -1 +1 @@ -Search.setIndex({"docnames": ["CHANGELOG", "INSTALL", "INTRO", "USAGE", "index", "modules", "pathfinding3d", "pathfinding3d.core", "pathfinding3d.finder"], "filenames": ["CHANGELOG.md", "INSTALL.md", "INTRO.md", "USAGE.md", "index.rst", "modules.rst", "pathfinding3d.rst", "pathfinding3d.core.rst", "pathfinding3d.finder.rst"], "titles": ["Version History", "Installation", "Pathfinding3D", "Examples", "Welcome to pathfinding3d\u2019s documentation!", "pathfinding3d", "pathfinding3d package", "pathfinding3d.core package", "pathfinding3d.finder package"], "terms": {"fix": 0, "bug": 0, "thetastarfind": [0, 3], "algorithm": [0, 2, 3, 7, 8], "when": 0, "us": [0, 2, 3, 4, 7, 8], "world": [0, 3, 5, 6], "connect": [0, 4, 6, 7], "grid": [0, 3, 5, 6, 8], "see": [0, 3, 7, 8], "issu": [0, 8], "12": [0, 3], "theta": [0, 2, 3], "ad": [0, 3, 7], "line": [0, 3, 7], "sight": [0, 3, 7], "minor": 0, "improv": 0, "code": [0, 3, 8], "qualiti": 0, "more": [0, 3, 7], "test": [0, 6, 7, 8], "new": [0, 3, 7], "diagon": [0, 3, 7, 8], "movement": [0, 2, 4, 7, 8], "lru": 0, "cach": 0, "heurist": [0, 2, 5, 6, 8], "updat": [0, 3], "document": 0, "exampl": [0, 4], "node": [0, 3, 5, 6, 8], "class": [0, 3, 7, 8], "ha": [0, 3, 7, 8], "addit": 0, "attribut": [0, 3, 7], "heap": [0, 5, 6], "replic": 0, "simpl": [0, 3, 7], "structur": [0, 3, 7], "inspir": [0, 7], "from": [0, 2, 3, 7, 8], "python": [0, 1, 2, 7, 8], "pathfind": [0, 2, 3, 7, 8], "origin": [0, 3, 7], "author": [0, 7], "base": [0, 7, 8], "v1": 0, "7": [0, 2, 3], "initi": [0, 3, 7], "have": [0, 3, 7, 8], "better": [0, 3], "error": 0, "messag": [0, 8], "url": 0, "point": [0, 3, 7, 8], "repositori": 0, "enabl": [0, 3], "weight": [0, 2, 3, 6, 7, 8], "biastarfind": [0, 6, 8], "add": [0, 3, 8], "type": [0, 3, 7, 8], "hint": 0, "sphinx": 0, "minim": 0, "autogener": 0, "codecov": 0, "badg": 0, "workflow": 0, "number": [0, 3, 7, 8], "setup": 0, "py": 0, "minimum": [0, 2, 8], "releas": 0, "3": [1, 3, 4, 7], "8": [1, 3], "higher": [1, 3], "numpi": [1, 3], "The": [1, 3, 7, 8], "packag": [1, 4, 5], "i": [1, 2, 3, 7, 8], "avail": [1, 3], "so": [1, 3, 7], "you": [1, 3], "can": [1, 3, 7, 8], "pip": [1, 3], "pathfinding3d": [1, 3], "git": 1, "clone": 1, "http": [1, 7, 8], "github": [1, 3, 7, 8], "com": [1, 7, 8], "harisankar95": 1, "cd": 1, "e": 1, "dev": 1, "checkout": 1, "b": 1, "branch_nam": 1, "python3": 2, "froke": 2, "brean": [2, 7, 8], "comprehens": 2, "librari": [2, 3], "design": 2, "3d": [2, 3, 7, 8], "applic": [2, 3], "current": [2, 7, 8], "ar": [2, 3, 7, 8], "path": [2, 4, 7, 8], "finder": [2, 3, 5, 6], "bundl": 2, "thi": [2, 3, 7], "name": [2, 3], "A": [2, 3, 7, 8], "versatil": 2, "most": 2, "wide": 2, "dijkstra": [2, 5, 6, 7], "without": 2, "best": 2, "first": [2, 3, 7, 8], "bi": [2, 3, 7, 8], "direct": [2, 3, 7, 8], "effici": [2, 3], "larg": [2, 8], "graph": 2, "known": 2, "goal": [2, 7], "breadth": [2, 8], "search": [2, 4, 6, 7, 8], "bf": 2, "iter": [2, 3, 8], "deep": [2, 8], "ida": [2, 7, 8], "memori": 2, "span": [2, 8], "tree": [2, 6, 8], "msp": [2, 5, 6], "almost": 2, "smooth": [2, 3], "take": [2, 3, 7], "field": [2, 3, 7], "map": [2, 3, 7, 8], "account": 2, "variant": 2, "ani": [2, 4, 8], "angl": [2, 4], "allow": [2, 3, 7, 8], "For": [3, 4], "detail": 3, "descript": [3, 8], "look": [3, 7], "folder": 3, "find": [3, 8], "environ": 3, "import": 3, "requir": [3, 4], "np": 3, "core": [3, 5, 6], "diagonal_mov": [3, 5, 6, 8], "diagonalmov": [3, 6, 7, 8], "a_star": [3, 5, 6], "astarfind": [3, 6, 8], "creat": [3, 7], "defin": 3, "arrai": [3, 7], "valu": [3, 7, 8], "smaller": 3, "equal": 3, "0": [3, 4, 7, 8], "repres": [3, 7], "an": [3, 7], "obstacl": 3, "posit": [3, 7], "walk": [3, 7], "bigger": 3, "cost": [3, 7, 8], "In": 3, "all": [3, 7, 8], "walkabl": [3, 6, 7], "same": [3, 8], "1": [3, 4, 7, 8], "feel": 3, "free": 3, "complex": 3, "some": 3, "sensor": 3, "data": [3, 7], "input": 3, "x": [3, 6, 7], "y": [3, 6, 7], "z": [3, 6, 7], "matrix": [3, 7], "ones": 3, "set": [3, 7, 8], "center": 3, "note": 3, "differ": 3, "vari": 3, "travers": 3, "instanti": 3, "object": [3, 7, 8], "instanc": 3, "everi": 3, "element": 3, "also": 3, "size": [3, 7], "start": [3, 7, 8], "end": [3, 7, 8], "determin": [3, 7], "coordin": [3, 7], "access": 3, "paramet": [3, 7, 8], "second": [3, 7, 8], "third": 3, "top": 3, "left": 3, "corner": 3, "bottom": 3, "right": 3, "2": [3, 4, 7, 8], "here": 3, "we": [3, 7, 8], "which": [3, 7], "default": [3, 7, 8], "find_path": [3, 6, 8], "method": 3, "return": [3, 7, 8], "need": [3, 8], "alwai": [3, 6, 7], "run": [3, 8], "output": 3, "result": 3, "list": [3, 7, 8], "waypoint": 3, "convert": 3, "tupl": [3, 7, 8], "pretti": 3, "print": 3, "part": [3, 8], "p": 3, "identifi": 3, "oper": 3, "length": 3, "len": 3, "whole": 3, "copi": 3, "past": 3, "plai": 3, "With": 3, "seamlessli": 3, "multipl": [3, 7], "featur": 3, "invalu": 3, "simul": 3, "multi": 3, "stori": 3, "staircas": 3, "between": [3, 7], "even": 3, "magic": 3, "link": 3, "dispar": 3, "locat": [3, 7], "let": 3, "": [3, 7], "consid": [3, 7], "where": 3, "want": 3, "adjac": 3, "each": [3, 7], "world0": 3, "world1": 3, "both": [3, 7], "grid0": 3, "grid_id": [3, 6, 7], "grid1": 3, "establish": 3, "wai": 3, "travel": 3, "unidirect": 3, "onli": [3, 7, 8], "one": [3, 7], "manag": 3, "find_neighbor": [3, 6, 8], "them": 3, "dure": 3, "across": 3, "util": [3, 5, 6], "time": [3, 7, 8], "pass": 3, "_": 3, "anoth": [3, 7], "demonstr": 3, "uniqu": 3, "capabl": 3, "space": 3, "id": [3, 7], "separ": 3, "path0": 3, "path1": 3, "through": [3, 7], "should": [3, 7, 8], "like": [3, 8], "put": 3, "togeth": 3, "sometim": 3, "help": 3, "understand": 3, "purpos": [3, 4], "instal": [3, 4], "o": 3, "o3d": 3, "load": 3, "sampl": 3, "sample_map": 3, "npy": 3, "shape": 3, "42": 3, "indic": 3, "file": 3, "download": 3, "provid": 3, "start_pt": 3, "21": 3, "end_pt": 3, "5": [3, 4], "38": 3, "33": 3, "represent": 3, "unpack": 3, "individu": 3, "argument": 3, "our": [3, 8], "specifi": [3, 7], "only_when_no_obstacl": [3, 6, 7], "get": [3, 7], "path_cost": 3, "g": [3, 6, 7, 8], "f": [3, 6, 7], "4f": 3, "28": 3, "6130": 3, "20": 3, "458": 3, "blue": 3, "color": 3, "n": 3, "column": 3, "red": 3, "channel": 3, "green": 3, "xyz_pt": 3, "pointcloud": 3, "draw_geometri": 3, "obstacle_indic": 3, "stack": 3, "axi": 3, "astyp": 3, "float": [3, 7, 8], "zero": 3, "max": [3, 8], "grei": 3, "path_color": 3, "sinc": 3, "alreadi": 3, "subtract": 3, "remain": 3, "prepar": 3, "start_color": 3, "end_color": 3, "full": 3, "now": 3, "along": 3, "similarli": 3, "correspond": [3, 7], "combin": 3, "concaten": 3, "cloud": 3, "pcd": 3, "geometri": 3, "vector3dvector": 3, "voxelgrid": 3, "gener": [3, 8], "voxel": 3, "voxel_s": 3, "voxel_grid": 3, "create_from_point_cloud": 3, "ax": 3, "trianglemesh": 3, "create_coordinate_fram": 3, "15": 3, "refer": 3, "remov": [3, 7, 8], "width": [3, 7], "height": [3, 7], "window": 3, "window_nam": 3, "env": 3, "1024": 3, "768": 3, "rotat": 3, "click": 3, "drag": 3, "mous": 3, "zoom": 3, "out": 3, "wheel": 3, "03": 3, "view": 3, "often": 3, "desir": 3, "rather": 3, "than": [3, 8], "being": 3, "restrict": 3, "26": 3, "discret": 3, "achiev": 3, "subclass": 3, "cut": 3, "chase": 3, "how": [3, 7], "work": 3, "As": 3, "usual": 3, "theta_star": 3, "singl": 3, "middl": 3, "10": 3, "dtype": 3, "int8": 3, "9": 3, "notic": 3, "doe": [3, 7], "other": 3, "becaus": 3, "check": [3, 7, 8], "whether": [3, 7], "If": [3, 7], "intermedi": 3, "vehicl": 3, "move": 3, "follow": 3, "reduc": 3, "quantit": 3, "analysi": 3, "compar": 3, "cleanup": [3, 6, 7], "astar_path": 3, "52": 3, "11": 3, "4": [3, 4, 7], "6": [3, 4], "function": [3, 7, 8], "calcul": [3, 7, 8], "def": 3, "calculate_path_cost": 3, "pt": 3, "pt_next": 3, "zip": 3, "dx": [3, 7], "dy": [3, 7], "dz": [3, 7], "theta_star_cost": 3, "astar_cost": 3, "nastarfind": 3, "871045857174057": 3, "16": 3, "27062002292411": 3, "lower": 3, "thu": 3, "plotli": 3, "graph_object": 3, "go": 3, "figur": 3, "fig": 3, "scatter3d": 3, "mode": [3, 4], "marker": 3, "dict": [3, 7], "hovertext": 3, "black": 3, "orang": 3, "camera": 3, "up": 3, "1479269806756467": 3, "06501594452841505": 3, "0907033779622012": 3, "ey": 3, "3097359159706334": 3, "4710974884501846": 3, "095154166796815": 3, "project": 3, "perspect": 3, "layout": 3, "update_layout": 3, "scene": 3, "xaxi": 3, "titl": 3, "backgroundcolor": 3, "white": 3, "gridcolor": 3, "lightgrei": 3, "showbackground": 3, "true": [3, 7, 8], "zerolinecolor": 3, "rang": 3, "dtick": 3, "yaxi": 3, "zaxi": 3, "legend": 3, "yanchor": 3, "99": 3, "xanchor": 3, "01": 3, "bgcolor": 3, "rgba": 3, "255": 3, "text": 3, "v": [3, 8], "scene_camera": 3, "show": 3, "tab": 3, "open": [3, 6, 7, 8], "your": 3, "browser": 3, "04": 3, "star": [3, 8], "introduct": 4, "pypi": 4, "develop": 4, "pleas": 4, "edit": 4, "usag": 4, "basic": [4, 7], "step": [4, 8], "portal": 4, "bridg": 4, "toi": 4, "two": [4, 7], "build": 4, "storei": 4, "visual": 4, "prerequisit": 4, "open3d": 4, "chang": 4, "log": 4, "subpackag": [4, 5], "index": 4, "modul": [4, 5, 6], "page": [4, 8], "submodul": [5, 6], "best_first": [5, 6], "bi_a_star": [5, 6], "breadth_first": [5, 6], "ida_star": [5, 6], "never": [6, 7, 8], "if_at_most_one_obstacl": [6, 7], "build_nod": [6, 7], "__init__": [6, 7, 8], "_validate_dimens": [6, 7], "is_valid_grid": [6, 7], "insid": [6, 7], "_calc_cost": [6, 7], "calc_cost": [6, 7], "neighbor": [6, 7, 8], "simpleheap": [6, 7], "_determine_node_retrieval_funct": [6, 7], "_determine_node_funct": [6, 7], "pop_nod": [6, 7], "push_nod": [6, 7], "remove_nod": [6, 7], "null": [6, 7], "manhattan": [6, 7], "euclidean": [6, 7], "chebyshev": [6, 7], "octil": [6, 7], "h": [6, 7], "close": [6, 7], "parent": [6, 7, 8], "retain_count": [6, 7], "gridnod": [6, 7, 8], "backtrac": [6, 7], "bi_backtrac": [6, 7], "raytrac": [6, 7], "bresenham": [6, 7], "expand_path": [6, 7], "smoothen_path": [6, 7], "line_of_sight": [6, 7], "check_neighbor": [6, 8], "apply_heurist": [6, 8], "keep_run": [6, 8], "process_nod": [6, 8], "bestfirst": [6, 8], "breadthfirstfind": [6, 8], "dijkstrafind": [6, 8], "executiontimeexcept": [6, 8], "arg": [6, 8], "with_traceback": [6, 8], "executionrunsexcept": [6, 8], "idastarfind": [6, 8], "minimumspanningtre": [6, 8], "itertre": [6, 8], "sourc": [7, 8], "enum": [7, 8], "depth": [7, 8], "none": [7, 8], "invers": 7, "fals": 7, "accord": 7, "given": [7, 8], "what": 7, "int": [7, 8], "matrixtyp": 7, "thei": 7, "bool": [7, 8], "option": [7, 8], "otherwis": 7, "contain": 7, "ndarrai": 7, "valid": 7, "tile": [7, 8], "distanc": [7, 8], "node_a": [7, 8], "node_b": [7, 8], "order": 7, "pull": 7, "54": 7, "peterchenad": 7, "implement": [7, 8], "optim": 7, "It": 7, "maintain": 7, "statu": 7, "retriev": 7, "its": [7, 8], "union": [7, 8], "rais": [7, 8], "valueerror": 7, "pop": 7, "lowest": 7, "push": 7, "old_f": 7, "just": 7, "store": [7, 8], "ignor": 7, "old": 7, "special": 7, "save": 7, "includ": 7, "overal": 7, "been": 7, "recurs": [7, 8], "track": [7, 8], "jump": [7, 8], "reset": 7, "fresh": 7, "belong": 7, "other_nod": 7, "record": 7, "coords_a": 7, "coords_b": 7, "ly": 7, "form": 7, "rai": 7, "trace": 7, "coord": 7, "compress": 7, "segment": [7, 8], "interpol": 7, "expand": 7, "use_raytrac": 7, "uncompress": 7, "less": 7, "turn": 7, "natur": 7, "smoothen": 7, "node1": 7, "node2": 7, "exist": 7, "wether": 7, "time_limit": 8, "max_run": 8, "callabl": 8, "shortest": 8, "edg": 8, "runtim": 8, "amount": 8, "tri": 8, "until": 8, "abort": 8, "enter": 8, "huge": 8, "constrain": 8, "mean": 8, "might": 8, "open_list": 8, "open_valu": 8, "backtrace_bi": 8, "next": 8, "found": 8, "possibl": 8, "process": 8, "helper": 8, "appli": 8, "djikstra": 8, "jumppointsearch": 8, "keep": 8, "someth": 8, "els": 8, "similar": 8, "over": 8, "except": 8, "tb": 8, "self": 8, "__traceback__": 8, "support": 8, "track_recurs": 8, "www": 8, "apl": 8, "jhu": 8, "edu": 8, "hall": 8, "ai": 8, "program": 8, "html": 8, "retrac": 8, "nageshwara": 8, "rao": 8, "vipin": 8, "kumar": 8, "k": 8, "ramesh": 8, "parallel": 8, "januari": 8, "1987": 8, "ftp": 8, "c": 8, "utexa": 8, "snapshot": 8, "hourli": 8, "pub": 8, "lab": 8, "tech": 8, "report": 8, "ut": 8, "tr": 8, "87": 8, "46": 8, "pdf": 8, "javascript": 8, "gerard": 8, "meier": 8, "gerardmei": 8, "cutoff": 8, "kwarg": 8, "brad": 8, "beatti": 8, "18": 8, "wikipedia": 8, "nice": 8, "about": 8, "en": 8, "org": 8, "wiki": 8, "minimum_spanning_tre": 8, "yield": 8}, "objects": {"": [[6, 0, 0, "-", "pathfinding3d"]], "pathfinding3d": [[7, 0, 0, "-", "core"], [8, 0, 0, "-", "finder"]], "pathfinding3d.core": [[7, 0, 0, "-", "diagonal_movement"], [7, 0, 0, "-", "grid"], [7, 0, 0, "-", "heap"], [7, 0, 0, "-", "heuristic"], [7, 0, 0, "-", "node"], [7, 0, 0, "-", "util"], [7, 0, 0, "-", "world"]], "pathfinding3d.core.diagonal_movement": [[7, 1, 1, "", "DiagonalMovement"]], "pathfinding3d.core.diagonal_movement.DiagonalMovement": [[7, 2, 1, "", "always"], [7, 2, 1, "", "if_at_most_one_obstacle"], [7, 2, 1, "", "never"], [7, 2, 1, "", "only_when_no_obstacle"]], "pathfinding3d.core.grid": [[7, 1, 1, "", "Grid"], [7, 4, 1, "", "build_nodes"]], "pathfinding3d.core.grid.Grid": [[7, 3, 1, "", "__init__"], [7, 3, 1, "", "_calc_cost"], [7, 3, 1, "", "_validate_dimensions"], [7, 3, 1, "", "calc_cost"], [7, 3, 1, "", "cleanup"], [7, 3, 1, "", "inside"], [7, 3, 1, "", "is_valid_grid"], [7, 3, 1, "", "neighbors"], [7, 3, 1, "", "node"], [7, 3, 1, "", "walkable"]], "pathfinding3d.core.heap": [[7, 1, 1, "", "SimpleHeap"]], "pathfinding3d.core.heap.SimpleHeap": [[7, 3, 1, "", "__init__"], [7, 3, 1, "", "_determine_node_function"], [7, 3, 1, "", "_determine_node_retrieval_function"], [7, 3, 1, "", "pop_node"], [7, 3, 1, "", "push_node"], [7, 3, 1, "", "remove_node"]], "pathfinding3d.core.heuristic": [[7, 4, 1, "", "chebyshev"], [7, 4, 1, "", "euclidean"], [7, 4, 1, "", "manhattan"], [7, 4, 1, "", "null"], [7, 4, 1, "", "octile"]], "pathfinding3d.core.node": [[7, 1, 1, "", "GridNode"], [7, 1, 1, "", "Node"]], "pathfinding3d.core.node.GridNode": [[7, 3, 1, "", "__init__"], [7, 3, 1, "", "cleanup"], [7, 2, 1, "", "closed"], [7, 3, 1, "", "connect"], [7, 2, 1, "id14", "connections"], [7, 2, 1, "", "f"], [7, 2, 1, "", "g"], [7, 2, 1, "id13", "grid_id"], [7, 2, 1, "", "h"], [7, 2, 1, "", "opened"], [7, 2, 1, "", "parent"], [7, 2, 1, "", "retain_count"], [7, 2, 1, "", "tested"], [7, 2, 1, "id11", "walkable"], [7, 2, 1, "id12", "weight"], [7, 2, 1, "id8", "x"], [7, 2, 1, "id9", "y"], [7, 2, 1, "id10", "z"]], "pathfinding3d.core.node.Node": [[7, 3, 1, "", "__init__"], [7, 3, 1, "", "cleanup"], [7, 2, 1, "id4", "closed"], [7, 2, 1, "id2", "f"], [7, 2, 1, "id1", "g"], [7, 2, 1, "id0", "h"], [7, 2, 1, "id3", "opened"], [7, 2, 1, "id5", "parent"], [7, 2, 1, "id6", "retain_count"], [7, 2, 1, "id7", "tested"]], "pathfinding3d.core.util": [[7, 4, 1, "", "backtrace"], [7, 4, 1, "", "bi_backtrace"], [7, 4, 1, "", "bresenham"], [7, 4, 1, "", "expand_path"], [7, 4, 1, "", "line_of_sight"], [7, 4, 1, "", "raytrace"], [7, 4, 1, "", "smoothen_path"]], "pathfinding3d.core.world": [[7, 1, 1, "", "World"]], "pathfinding3d.core.world.World": [[7, 3, 1, "", "__init__"], [7, 3, 1, "", "calc_cost"], [7, 3, 1, "", "cleanup"], [7, 3, 1, "", "neighbors"]], "pathfinding3d.finder": [[8, 0, 0, "-", "a_star"], [8, 0, 0, "-", "best_first"], [8, 0, 0, "-", "bi_a_star"], [8, 0, 0, "-", "breadth_first"], [8, 0, 0, "-", "dijkstra"], [8, 0, 0, "-", "finder"], [8, 0, 0, "-", "ida_star"], [8, 0, 0, "-", "msp"]], "pathfinding3d.finder.a_star": [[8, 1, 1, "", "AStarFinder"]], "pathfinding3d.finder.a_star.AStarFinder": [[8, 3, 1, "", "__init__"], [8, 3, 1, "", "apply_heuristic"], [8, 3, 1, "", "check_neighbors"], [8, 3, 1, "", "find_neighbors"], [8, 3, 1, "", "find_path"], [8, 3, 1, "", "keep_running"], [8, 3, 1, "", "process_node"]], "pathfinding3d.finder.best_first": [[8, 1, 1, "", "BestFirst"]], "pathfinding3d.finder.best_first.BestFirst": [[8, 3, 1, "", "__init__"], [8, 3, 1, "", "apply_heuristic"], [8, 3, 1, "", "check_neighbors"], [8, 3, 1, "", "find_neighbors"], [8, 3, 1, "", "find_path"], [8, 3, 1, "", "keep_running"], [8, 3, 1, "", "process_node"]], "pathfinding3d.finder.bi_a_star": [[8, 1, 1, "", "BiAStarFinder"]], "pathfinding3d.finder.bi_a_star.BiAStarFinder": [[8, 3, 1, "", "__init__"], [8, 3, 1, "", "apply_heuristic"], [8, 3, 1, "", "check_neighbors"], [8, 3, 1, "", "find_neighbors"], [8, 3, 1, "", "find_path"], [8, 3, 1, "", "keep_running"], [8, 3, 1, "", "process_node"]], "pathfinding3d.finder.breadth_first": [[8, 1, 1, "", "BreadthFirstFinder"]], "pathfinding3d.finder.breadth_first.BreadthFirstFinder": [[8, 3, 1, "", "__init__"], [8, 3, 1, "", "apply_heuristic"], [8, 3, 1, "", "check_neighbors"], [8, 3, 1, "", "find_neighbors"], [8, 3, 1, "", "find_path"], [8, 3, 1, "", "keep_running"], [8, 3, 1, "", "process_node"]], "pathfinding3d.finder.dijkstra": [[8, 1, 1, "", "DijkstraFinder"]], "pathfinding3d.finder.dijkstra.DijkstraFinder": [[8, 3, 1, "", "__init__"], [8, 3, 1, "", "apply_heuristic"], [8, 3, 1, "", "check_neighbors"], [8, 3, 1, "", "find_neighbors"], [8, 3, 1, "", "find_path"], [8, 3, 1, "", "keep_running"], [8, 3, 1, "", "process_node"]], "pathfinding3d.finder.finder": [[8, 5, 1, "", "ExecutionRunsException"], [8, 5, 1, "", "ExecutionTimeException"], [8, 1, 1, "", "Finder"]], "pathfinding3d.finder.finder.ExecutionRunsException": [[8, 3, 1, "", "__init__"], [8, 2, 1, "", "args"], [8, 3, 1, "", "with_traceback"]], "pathfinding3d.finder.finder.ExecutionTimeException": [[8, 3, 1, "", "__init__"], [8, 2, 1, "", "args"], [8, 3, 1, "", "with_traceback"]], "pathfinding3d.finder.finder.Finder": [[8, 3, 1, "", "__init__"], [8, 3, 1, "", "apply_heuristic"], [8, 3, 1, "", "check_neighbors"], [8, 3, 1, "", "find_neighbors"], [8, 3, 1, "", "find_path"], [8, 3, 1, "", "keep_running"], [8, 3, 1, "", "process_node"]], "pathfinding3d.finder.ida_star": [[8, 1, 1, "", "IDAStarFinder"]], "pathfinding3d.finder.ida_star.IDAStarFinder": [[8, 3, 1, "", "__init__"], [8, 3, 1, "", "apply_heuristic"], [8, 3, 1, "", "check_neighbors"], [8, 3, 1, "", "find_neighbors"], [8, 3, 1, "", "find_path"], [8, 3, 1, "", "keep_running"], [8, 3, 1, "", "process_node"], [8, 3, 1, "", "search"]], "pathfinding3d.finder.msp": [[8, 1, 1, "", "MinimumSpanningTree"]], "pathfinding3d.finder.msp.MinimumSpanningTree": [[8, 3, 1, "", "__init__"], [8, 3, 1, "", "apply_heuristic"], [8, 3, 1, "", "check_neighbors"], [8, 3, 1, "", "find_neighbors"], [8, 3, 1, "", "find_path"], [8, 3, 1, "", "itertree"], [8, 3, 1, "", "keep_running"], [8, 3, 1, "", "process_node"], [8, 3, 1, "", "tree"]]}, "objtypes": {"0": "py:module", "1": "py:class", "2": "py:attribute", "3": "py:method", "4": "py:function", "5": "py:exception"}, "objnames": {"0": ["py", "module", "Python module"], "1": ["py", "class", "Python class"], "2": ["py", "attribute", "Python attribute"], "3": ["py", "method", "Python method"], "4": ["py", "function", "Python function"], "5": ["py", "exception", "Python exception"]}, "titleterms": {"version": 0, "histori": 0, "0": 0, "6": 0, "1": 0, "5": 0, "4": 0, "3": 0, "2": 0, "instal": 1, "requir": 1, "pypi": 1, "For": 1, "develop": 1, "purpos": 1, "pleas": 1, "us": 1, "edit": 1, "mode": 1, "pathfinding3d": [2, 4, 5, 6, 7, 8], "introduct": 2, "exampl": 3, "basic": 3, "usag": 3, "step": 3, "portal": 3, "bridg": 3, "toi": 3, "connect": 3, "two": 3, "build": 3, "storei": 3, "visual": 3, "path": 3, "prerequisit": 3, "open3d": 3, "ani": 3, "angl": 3, "movement": 3, "welcom": 4, "": 4, "document": 4, "content": 4, "indic": 4, "tabl": 4, "packag": [6, 7, 8], "subpackag": 6, "core": 7, "submodul": [7, 8], "diagonal_mov": 7, "modul": [7, 8], "grid": 7, "heap": 7, "heurist": 7, "node": 7, "util": 7, "world": 7, "finder": 8, "a_star": 8, "best_first": 8, "bi_a_star": 8, "breadth_first": 8, "dijkstra": 8, "ida_star": 8, "msp": 8}, "envversion": {"sphinx.domains.c": 3, "sphinx.domains.changeset": 1, "sphinx.domains.citation": 1, "sphinx.domains.cpp": 9, "sphinx.domains.index": 1, "sphinx.domains.javascript": 3, "sphinx.domains.math": 2, "sphinx.domains.python": 4, "sphinx.domains.rst": 2, "sphinx.domains.std": 2, "sphinx.ext.todo": 2, "sphinx.ext.viewcode": 1, "sphinx": 58}, "alltitles": {"Version History": [[0, "version-history"]], "0.6.1": [[0, "id1"]], "0.6.0": [[0, "id2"]], "0.5.1": [[0, "id3"]], "0.5.0": [[0, "id4"]], "0.4.1": [[0, "id5"]], "0.4.0": [[0, "id6"]], "0.3.1": [[0, "id7"]], "0.3": [[0, "id8"]], "0.2": [[0, "id9"]], "0.1": [[0, "id10"]], "Installation": [[1, "installation"]], "Requirements": [[1, "requirements"]], "PyPI": [[1, "pypi"]], "For development purposes please use editable mode": [[1, "for-development-purposes-please-use-editable-mode"]], "Pathfinding3D": [[2, "pathfinding3d"]], "Introduction": [[2, "introduction"]], "Examples": [[3, "examples"]], "Basic usage": [[3, "basic-usage"]], "Steps/Portals/Bridges": [[3, "steps-portals-bridges"]], "Toy Example: Connecting Two Building Storeys with a Bridge": [[3, "toy-example-connecting-two-building-storeys-with-a-bridge"]], "Visualizing the Path": [[3, "visualizing-the-path"]], "Prerequisites": [[3, "prerequisites"]], "Example with Open3D": [[3, "example-with-open3d"]], "Example with any angle of movement": [[3, "example-with-any-angle-of-movement"]], "Welcome to pathfinding3d\u2019s documentation!": [[4, "welcome-to-pathfinding3d-s-documentation"]], "Contents:": [[4, null]], "Indices and tables": [[4, "indices-and-tables"]], "pathfinding3d": [[5, "pathfinding3d"]], "pathfinding3d package": [[6, "module-pathfinding3d"]], "Subpackages": [[6, "subpackages"]], "pathfinding3d.core package": [[7, "module-pathfinding3d.core"]], "Submodules": [[7, "submodules"], [8, "submodules"]], "pathfinding3d.core.diagonal_movement module": [[7, "module-pathfinding3d.core.diagonal_movement"]], "pathfinding3d.core.grid module": [[7, "module-pathfinding3d.core.grid"]], "pathfinding3d.core.heap module": [[7, "module-pathfinding3d.core.heap"]], "pathfinding3d.core.heuristic module": [[7, "module-pathfinding3d.core.heuristic"]], "pathfinding3d.core.node module": [[7, "module-pathfinding3d.core.node"]], "pathfinding3d.core.util module": [[7, "module-pathfinding3d.core.util"]], "pathfinding3d.core.world module": [[7, "module-pathfinding3d.core.world"]], "pathfinding3d.finder package": [[8, "module-pathfinding3d.finder"]], "pathfinding3d.finder.a_star module": [[8, "module-pathfinding3d.finder.a_star"]], "pathfinding3d.finder.best_first module": [[8, "module-pathfinding3d.finder.best_first"]], "pathfinding3d.finder.bi_a_star module": [[8, "module-pathfinding3d.finder.bi_a_star"]], "pathfinding3d.finder.breadth_first module": [[8, "module-pathfinding3d.finder.breadth_first"]], "pathfinding3d.finder.dijkstra module": [[8, "module-pathfinding3d.finder.dijkstra"]], "pathfinding3d.finder.finder module": [[8, "module-pathfinding3d.finder.finder"]], "pathfinding3d.finder.ida_star module": [[8, "module-pathfinding3d.finder.ida_star"]], "pathfinding3d.finder.msp module": [[8, "module-pathfinding3d.finder.msp"]]}, "indexentries": {"module": [[6, "module-pathfinding3d"], [7, "module-pathfinding3d.core"], [7, "module-pathfinding3d.core.diagonal_movement"], [7, "module-pathfinding3d.core.grid"], [7, "module-pathfinding3d.core.heap"], [7, "module-pathfinding3d.core.heuristic"], [7, "module-pathfinding3d.core.node"], [7, "module-pathfinding3d.core.util"], [7, "module-pathfinding3d.core.world"], [8, "module-pathfinding3d.finder"], [8, "module-pathfinding3d.finder.a_star"], [8, "module-pathfinding3d.finder.best_first"], [8, "module-pathfinding3d.finder.bi_a_star"], [8, "module-pathfinding3d.finder.breadth_first"], [8, "module-pathfinding3d.finder.dijkstra"], [8, "module-pathfinding3d.finder.finder"], [8, "module-pathfinding3d.finder.ida_star"], [8, "module-pathfinding3d.finder.msp"]], "pathfinding3d": [[6, "module-pathfinding3d"]], "diagonalmovement (class in pathfinding3d.core.diagonal_movement)": [[7, "pathfinding3d.core.diagonal_movement.DiagonalMovement"]], "grid (class in pathfinding3d.core.grid)": [[7, "pathfinding3d.core.grid.Grid"]], "gridnode (class in pathfinding3d.core.node)": [[7, "pathfinding3d.core.node.GridNode"]], "node (class in pathfinding3d.core.node)": [[7, "pathfinding3d.core.node.Node"]], "simpleheap (class in pathfinding3d.core.heap)": [[7, "pathfinding3d.core.heap.SimpleHeap"]], "world (class in pathfinding3d.core.world)": [[7, "pathfinding3d.core.world.World"]], "__init__() (pathfinding3d.core.grid.grid method)": [[7, "pathfinding3d.core.grid.Grid.__init__"]], "__init__() (pathfinding3d.core.heap.simpleheap method)": [[7, "pathfinding3d.core.heap.SimpleHeap.__init__"]], "__init__() (pathfinding3d.core.node.gridnode method)": [[7, "pathfinding3d.core.node.GridNode.__init__"]], "__init__() (pathfinding3d.core.node.node method)": [[7, "pathfinding3d.core.node.Node.__init__"]], "__init__() (pathfinding3d.core.world.world method)": [[7, "pathfinding3d.core.world.World.__init__"]], "_calc_cost() (pathfinding3d.core.grid.grid method)": [[7, "pathfinding3d.core.grid.Grid._calc_cost"]], "_determine_node_function() (pathfinding3d.core.heap.simpleheap method)": [[7, "pathfinding3d.core.heap.SimpleHeap._determine_node_function"]], "_determine_node_retrieval_function() (pathfinding3d.core.heap.simpleheap method)": [[7, "pathfinding3d.core.heap.SimpleHeap._determine_node_retrieval_function"]], "_validate_dimensions() (pathfinding3d.core.grid.grid method)": [[7, "pathfinding3d.core.grid.Grid._validate_dimensions"]], "always (pathfinding3d.core.diagonal_movement.diagonalmovement attribute)": [[7, "pathfinding3d.core.diagonal_movement.DiagonalMovement.always"]], "backtrace() (in module pathfinding3d.core.util)": [[7, "pathfinding3d.core.util.backtrace"]], "bi_backtrace() (in module pathfinding3d.core.util)": [[7, "pathfinding3d.core.util.bi_backtrace"]], "bresenham() (in module pathfinding3d.core.util)": [[7, "pathfinding3d.core.util.bresenham"]], "build_nodes() (in module pathfinding3d.core.grid)": [[7, "pathfinding3d.core.grid.build_nodes"]], "calc_cost() (pathfinding3d.core.grid.grid method)": [[7, "pathfinding3d.core.grid.Grid.calc_cost"]], "calc_cost() (pathfinding3d.core.world.world method)": [[7, "pathfinding3d.core.world.World.calc_cost"]], "chebyshev() (in module pathfinding3d.core.heuristic)": [[7, "pathfinding3d.core.heuristic.chebyshev"]], "cleanup() (pathfinding3d.core.grid.grid method)": [[7, "pathfinding3d.core.grid.Grid.cleanup"]], "cleanup() (pathfinding3d.core.node.gridnode method)": [[7, "pathfinding3d.core.node.GridNode.cleanup"]], "cleanup() (pathfinding3d.core.node.node method)": [[7, "pathfinding3d.core.node.Node.cleanup"]], "cleanup() (pathfinding3d.core.world.world method)": [[7, "pathfinding3d.core.world.World.cleanup"]], "closed (pathfinding3d.core.node.gridnode attribute)": [[7, "pathfinding3d.core.node.GridNode.closed"]], "closed (pathfinding3d.core.node.node attribute)": [[7, "id4"], [7, "pathfinding3d.core.node.Node.closed"]], "connect() (pathfinding3d.core.node.gridnode method)": [[7, "pathfinding3d.core.node.GridNode.connect"]], "connections (pathfinding3d.core.node.gridnode attribute)": [[7, "id14"], [7, "pathfinding3d.core.node.GridNode.connections"]], "euclidean() (in module pathfinding3d.core.heuristic)": [[7, "pathfinding3d.core.heuristic.euclidean"]], "expand_path() (in module pathfinding3d.core.util)": [[7, "pathfinding3d.core.util.expand_path"]], "f (pathfinding3d.core.node.gridnode attribute)": [[7, "pathfinding3d.core.node.GridNode.f"]], "f (pathfinding3d.core.node.node attribute)": [[7, "id2"], [7, "pathfinding3d.core.node.Node.f"]], "g (pathfinding3d.core.node.gridnode attribute)": [[7, "pathfinding3d.core.node.GridNode.g"]], "g (pathfinding3d.core.node.node attribute)": [[7, "id1"], [7, "pathfinding3d.core.node.Node.g"]], "grid_id (pathfinding3d.core.node.gridnode attribute)": [[7, "id13"], [7, "pathfinding3d.core.node.GridNode.grid_id"]], "h (pathfinding3d.core.node.gridnode attribute)": [[7, "pathfinding3d.core.node.GridNode.h"]], "h (pathfinding3d.core.node.node attribute)": [[7, "id0"], [7, "pathfinding3d.core.node.Node.h"]], "if_at_most_one_obstacle (pathfinding3d.core.diagonal_movement.diagonalmovement attribute)": [[7, "pathfinding3d.core.diagonal_movement.DiagonalMovement.if_at_most_one_obstacle"]], "inside() (pathfinding3d.core.grid.grid method)": [[7, "pathfinding3d.core.grid.Grid.inside"]], "is_valid_grid() (pathfinding3d.core.grid.grid method)": [[7, "pathfinding3d.core.grid.Grid.is_valid_grid"]], "line_of_sight() (in module pathfinding3d.core.util)": [[7, "pathfinding3d.core.util.line_of_sight"]], "manhattan() (in module pathfinding3d.core.heuristic)": [[7, "pathfinding3d.core.heuristic.manhattan"]], "neighbors() (pathfinding3d.core.grid.grid method)": [[7, "pathfinding3d.core.grid.Grid.neighbors"]], "neighbors() (pathfinding3d.core.world.world method)": [[7, "pathfinding3d.core.world.World.neighbors"]], "never (pathfinding3d.core.diagonal_movement.diagonalmovement attribute)": [[7, "pathfinding3d.core.diagonal_movement.DiagonalMovement.never"]], "node() (pathfinding3d.core.grid.grid method)": [[7, "pathfinding3d.core.grid.Grid.node"]], "null() (in module pathfinding3d.core.heuristic)": [[7, "pathfinding3d.core.heuristic.null"]], "octile() (in module pathfinding3d.core.heuristic)": [[7, "pathfinding3d.core.heuristic.octile"]], "only_when_no_obstacle (pathfinding3d.core.diagonal_movement.diagonalmovement attribute)": [[7, "pathfinding3d.core.diagonal_movement.DiagonalMovement.only_when_no_obstacle"]], "opened (pathfinding3d.core.node.gridnode attribute)": [[7, "pathfinding3d.core.node.GridNode.opened"]], "opened (pathfinding3d.core.node.node attribute)": [[7, "id3"], [7, "pathfinding3d.core.node.Node.opened"]], "parent (pathfinding3d.core.node.gridnode attribute)": [[7, "pathfinding3d.core.node.GridNode.parent"]], "parent (pathfinding3d.core.node.node attribute)": [[7, "id5"], [7, "pathfinding3d.core.node.Node.parent"]], "pathfinding3d.core": [[7, "module-pathfinding3d.core"]], "pathfinding3d.core.diagonal_movement": [[7, "module-pathfinding3d.core.diagonal_movement"]], "pathfinding3d.core.grid": [[7, "module-pathfinding3d.core.grid"]], "pathfinding3d.core.heap": [[7, "module-pathfinding3d.core.heap"]], "pathfinding3d.core.heuristic": [[7, "module-pathfinding3d.core.heuristic"]], "pathfinding3d.core.node": [[7, "module-pathfinding3d.core.node"]], "pathfinding3d.core.util": [[7, "module-pathfinding3d.core.util"]], "pathfinding3d.core.world": [[7, "module-pathfinding3d.core.world"]], "pop_node() (pathfinding3d.core.heap.simpleheap method)": [[7, "pathfinding3d.core.heap.SimpleHeap.pop_node"]], "push_node() (pathfinding3d.core.heap.simpleheap method)": [[7, "pathfinding3d.core.heap.SimpleHeap.push_node"]], "raytrace() (in module pathfinding3d.core.util)": [[7, "pathfinding3d.core.util.raytrace"]], "remove_node() (pathfinding3d.core.heap.simpleheap method)": [[7, "pathfinding3d.core.heap.SimpleHeap.remove_node"]], "retain_count (pathfinding3d.core.node.gridnode attribute)": [[7, "pathfinding3d.core.node.GridNode.retain_count"]], "retain_count (pathfinding3d.core.node.node attribute)": [[7, "id6"], [7, "pathfinding3d.core.node.Node.retain_count"]], "smoothen_path() (in module pathfinding3d.core.util)": [[7, "pathfinding3d.core.util.smoothen_path"]], "tested (pathfinding3d.core.node.gridnode attribute)": [[7, "pathfinding3d.core.node.GridNode.tested"]], "tested (pathfinding3d.core.node.node attribute)": [[7, "id7"], [7, "pathfinding3d.core.node.Node.tested"]], "walkable (pathfinding3d.core.node.gridnode attribute)": [[7, "id11"], [7, "pathfinding3d.core.node.GridNode.walkable"]], "walkable() (pathfinding3d.core.grid.grid method)": [[7, "pathfinding3d.core.grid.Grid.walkable"]], "weight (pathfinding3d.core.node.gridnode attribute)": [[7, "id12"], [7, "pathfinding3d.core.node.GridNode.weight"]], "x (pathfinding3d.core.node.gridnode attribute)": [[7, "id8"], [7, "pathfinding3d.core.node.GridNode.x"]], "y (pathfinding3d.core.node.gridnode attribute)": [[7, "id9"], [7, "pathfinding3d.core.node.GridNode.y"]], "z (pathfinding3d.core.node.gridnode attribute)": [[7, "id10"], [7, "pathfinding3d.core.node.GridNode.z"]], "astarfinder (class in pathfinding3d.finder.a_star)": [[8, "pathfinding3d.finder.a_star.AStarFinder"]], "bestfirst (class in pathfinding3d.finder.best_first)": [[8, "pathfinding3d.finder.best_first.BestFirst"]], "biastarfinder (class in pathfinding3d.finder.bi_a_star)": [[8, "pathfinding3d.finder.bi_a_star.BiAStarFinder"]], "breadthfirstfinder (class in pathfinding3d.finder.breadth_first)": [[8, "pathfinding3d.finder.breadth_first.BreadthFirstFinder"]], "dijkstrafinder (class in pathfinding3d.finder.dijkstra)": [[8, "pathfinding3d.finder.dijkstra.DijkstraFinder"]], "executionrunsexception": [[8, "pathfinding3d.finder.finder.ExecutionRunsException"]], "executiontimeexception": [[8, "pathfinding3d.finder.finder.ExecutionTimeException"]], "finder (class in pathfinding3d.finder.finder)": [[8, "pathfinding3d.finder.finder.Finder"]], "idastarfinder (class in pathfinding3d.finder.ida_star)": [[8, "pathfinding3d.finder.ida_star.IDAStarFinder"]], "minimumspanningtree (class in pathfinding3d.finder.msp)": [[8, "pathfinding3d.finder.msp.MinimumSpanningTree"]], "__init__() (pathfinding3d.finder.a_star.astarfinder method)": [[8, "pathfinding3d.finder.a_star.AStarFinder.__init__"]], "__init__() (pathfinding3d.finder.best_first.bestfirst method)": [[8, "pathfinding3d.finder.best_first.BestFirst.__init__"]], "__init__() (pathfinding3d.finder.bi_a_star.biastarfinder method)": [[8, "pathfinding3d.finder.bi_a_star.BiAStarFinder.__init__"]], "__init__() (pathfinding3d.finder.breadth_first.breadthfirstfinder method)": [[8, "pathfinding3d.finder.breadth_first.BreadthFirstFinder.__init__"]], "__init__() (pathfinding3d.finder.dijkstra.dijkstrafinder method)": [[8, "pathfinding3d.finder.dijkstra.DijkstraFinder.__init__"]], "__init__() (pathfinding3d.finder.finder.executionrunsexception method)": [[8, "pathfinding3d.finder.finder.ExecutionRunsException.__init__"]], "__init__() (pathfinding3d.finder.finder.executiontimeexception method)": [[8, "pathfinding3d.finder.finder.ExecutionTimeException.__init__"]], "__init__() (pathfinding3d.finder.finder.finder method)": [[8, "pathfinding3d.finder.finder.Finder.__init__"]], "__init__() (pathfinding3d.finder.ida_star.idastarfinder method)": [[8, "pathfinding3d.finder.ida_star.IDAStarFinder.__init__"]], "__init__() (pathfinding3d.finder.msp.minimumspanningtree method)": [[8, "pathfinding3d.finder.msp.MinimumSpanningTree.__init__"]], "apply_heuristic() (pathfinding3d.finder.a_star.astarfinder method)": [[8, "pathfinding3d.finder.a_star.AStarFinder.apply_heuristic"]], "apply_heuristic() (pathfinding3d.finder.best_first.bestfirst method)": [[8, "pathfinding3d.finder.best_first.BestFirst.apply_heuristic"]], "apply_heuristic() (pathfinding3d.finder.bi_a_star.biastarfinder method)": [[8, "pathfinding3d.finder.bi_a_star.BiAStarFinder.apply_heuristic"]], "apply_heuristic() (pathfinding3d.finder.breadth_first.breadthfirstfinder method)": [[8, "pathfinding3d.finder.breadth_first.BreadthFirstFinder.apply_heuristic"]], "apply_heuristic() (pathfinding3d.finder.dijkstra.dijkstrafinder method)": [[8, "pathfinding3d.finder.dijkstra.DijkstraFinder.apply_heuristic"]], "apply_heuristic() (pathfinding3d.finder.finder.finder method)": [[8, "pathfinding3d.finder.finder.Finder.apply_heuristic"]], "apply_heuristic() (pathfinding3d.finder.ida_star.idastarfinder method)": [[8, "pathfinding3d.finder.ida_star.IDAStarFinder.apply_heuristic"]], "apply_heuristic() (pathfinding3d.finder.msp.minimumspanningtree method)": [[8, "pathfinding3d.finder.msp.MinimumSpanningTree.apply_heuristic"]], "args (pathfinding3d.finder.finder.executionrunsexception attribute)": [[8, "pathfinding3d.finder.finder.ExecutionRunsException.args"]], "args (pathfinding3d.finder.finder.executiontimeexception attribute)": [[8, "pathfinding3d.finder.finder.ExecutionTimeException.args"]], "check_neighbors() (pathfinding3d.finder.a_star.astarfinder method)": [[8, "pathfinding3d.finder.a_star.AStarFinder.check_neighbors"]], "check_neighbors() (pathfinding3d.finder.best_first.bestfirst method)": [[8, "pathfinding3d.finder.best_first.BestFirst.check_neighbors"]], "check_neighbors() (pathfinding3d.finder.bi_a_star.biastarfinder method)": [[8, "pathfinding3d.finder.bi_a_star.BiAStarFinder.check_neighbors"]], "check_neighbors() (pathfinding3d.finder.breadth_first.breadthfirstfinder method)": [[8, "pathfinding3d.finder.breadth_first.BreadthFirstFinder.check_neighbors"]], "check_neighbors() (pathfinding3d.finder.dijkstra.dijkstrafinder method)": [[8, "pathfinding3d.finder.dijkstra.DijkstraFinder.check_neighbors"]], "check_neighbors() (pathfinding3d.finder.finder.finder method)": [[8, "pathfinding3d.finder.finder.Finder.check_neighbors"]], "check_neighbors() (pathfinding3d.finder.ida_star.idastarfinder method)": [[8, "pathfinding3d.finder.ida_star.IDAStarFinder.check_neighbors"]], "check_neighbors() (pathfinding3d.finder.msp.minimumspanningtree method)": [[8, "pathfinding3d.finder.msp.MinimumSpanningTree.check_neighbors"]], "find_neighbors() (pathfinding3d.finder.a_star.astarfinder method)": [[8, "pathfinding3d.finder.a_star.AStarFinder.find_neighbors"]], "find_neighbors() (pathfinding3d.finder.best_first.bestfirst method)": [[8, "pathfinding3d.finder.best_first.BestFirst.find_neighbors"]], "find_neighbors() (pathfinding3d.finder.bi_a_star.biastarfinder method)": [[8, "pathfinding3d.finder.bi_a_star.BiAStarFinder.find_neighbors"]], "find_neighbors() (pathfinding3d.finder.breadth_first.breadthfirstfinder method)": [[8, "pathfinding3d.finder.breadth_first.BreadthFirstFinder.find_neighbors"]], "find_neighbors() (pathfinding3d.finder.dijkstra.dijkstrafinder method)": [[8, "pathfinding3d.finder.dijkstra.DijkstraFinder.find_neighbors"]], "find_neighbors() (pathfinding3d.finder.finder.finder method)": [[8, "pathfinding3d.finder.finder.Finder.find_neighbors"]], "find_neighbors() (pathfinding3d.finder.ida_star.idastarfinder method)": [[8, "pathfinding3d.finder.ida_star.IDAStarFinder.find_neighbors"]], "find_neighbors() (pathfinding3d.finder.msp.minimumspanningtree method)": [[8, "pathfinding3d.finder.msp.MinimumSpanningTree.find_neighbors"]], "find_path() (pathfinding3d.finder.a_star.astarfinder method)": [[8, "pathfinding3d.finder.a_star.AStarFinder.find_path"]], "find_path() (pathfinding3d.finder.best_first.bestfirst method)": [[8, "pathfinding3d.finder.best_first.BestFirst.find_path"]], "find_path() (pathfinding3d.finder.bi_a_star.biastarfinder method)": [[8, "pathfinding3d.finder.bi_a_star.BiAStarFinder.find_path"]], "find_path() (pathfinding3d.finder.breadth_first.breadthfirstfinder method)": [[8, "pathfinding3d.finder.breadth_first.BreadthFirstFinder.find_path"]], "find_path() (pathfinding3d.finder.dijkstra.dijkstrafinder method)": [[8, "pathfinding3d.finder.dijkstra.DijkstraFinder.find_path"]], "find_path() (pathfinding3d.finder.finder.finder method)": [[8, "pathfinding3d.finder.finder.Finder.find_path"]], "find_path() (pathfinding3d.finder.ida_star.idastarfinder method)": [[8, "pathfinding3d.finder.ida_star.IDAStarFinder.find_path"]], "find_path() (pathfinding3d.finder.msp.minimumspanningtree method)": [[8, "pathfinding3d.finder.msp.MinimumSpanningTree.find_path"]], "itertree() (pathfinding3d.finder.msp.minimumspanningtree method)": [[8, "pathfinding3d.finder.msp.MinimumSpanningTree.itertree"]], "keep_running() (pathfinding3d.finder.a_star.astarfinder method)": [[8, "pathfinding3d.finder.a_star.AStarFinder.keep_running"]], "keep_running() (pathfinding3d.finder.best_first.bestfirst method)": [[8, "pathfinding3d.finder.best_first.BestFirst.keep_running"]], "keep_running() (pathfinding3d.finder.bi_a_star.biastarfinder method)": [[8, "pathfinding3d.finder.bi_a_star.BiAStarFinder.keep_running"]], "keep_running() (pathfinding3d.finder.breadth_first.breadthfirstfinder method)": [[8, "pathfinding3d.finder.breadth_first.BreadthFirstFinder.keep_running"]], "keep_running() (pathfinding3d.finder.dijkstra.dijkstrafinder method)": [[8, "pathfinding3d.finder.dijkstra.DijkstraFinder.keep_running"]], "keep_running() (pathfinding3d.finder.finder.finder method)": [[8, "pathfinding3d.finder.finder.Finder.keep_running"]], "keep_running() (pathfinding3d.finder.ida_star.idastarfinder method)": [[8, "pathfinding3d.finder.ida_star.IDAStarFinder.keep_running"]], "keep_running() (pathfinding3d.finder.msp.minimumspanningtree method)": [[8, "pathfinding3d.finder.msp.MinimumSpanningTree.keep_running"]], "pathfinding3d.finder": [[8, "module-pathfinding3d.finder"]], "pathfinding3d.finder.a_star": [[8, "module-pathfinding3d.finder.a_star"]], "pathfinding3d.finder.best_first": [[8, "module-pathfinding3d.finder.best_first"]], "pathfinding3d.finder.bi_a_star": [[8, "module-pathfinding3d.finder.bi_a_star"]], "pathfinding3d.finder.breadth_first": [[8, "module-pathfinding3d.finder.breadth_first"]], "pathfinding3d.finder.dijkstra": [[8, "module-pathfinding3d.finder.dijkstra"]], "pathfinding3d.finder.finder": [[8, "module-pathfinding3d.finder.finder"]], "pathfinding3d.finder.ida_star": [[8, "module-pathfinding3d.finder.ida_star"]], "pathfinding3d.finder.msp": [[8, "module-pathfinding3d.finder.msp"]], "process_node() (pathfinding3d.finder.a_star.astarfinder method)": [[8, "pathfinding3d.finder.a_star.AStarFinder.process_node"]], "process_node() (pathfinding3d.finder.best_first.bestfirst method)": [[8, "pathfinding3d.finder.best_first.BestFirst.process_node"]], "process_node() (pathfinding3d.finder.bi_a_star.biastarfinder method)": [[8, "pathfinding3d.finder.bi_a_star.BiAStarFinder.process_node"]], "process_node() (pathfinding3d.finder.breadth_first.breadthfirstfinder method)": [[8, "pathfinding3d.finder.breadth_first.BreadthFirstFinder.process_node"]], "process_node() (pathfinding3d.finder.dijkstra.dijkstrafinder method)": [[8, "pathfinding3d.finder.dijkstra.DijkstraFinder.process_node"]], "process_node() (pathfinding3d.finder.finder.finder method)": [[8, "pathfinding3d.finder.finder.Finder.process_node"]], "process_node() (pathfinding3d.finder.ida_star.idastarfinder method)": [[8, "pathfinding3d.finder.ida_star.IDAStarFinder.process_node"]], "process_node() (pathfinding3d.finder.msp.minimumspanningtree method)": [[8, "pathfinding3d.finder.msp.MinimumSpanningTree.process_node"]], "search() (pathfinding3d.finder.ida_star.idastarfinder method)": [[8, "pathfinding3d.finder.ida_star.IDAStarFinder.search"]], "tree() (pathfinding3d.finder.msp.minimumspanningtree method)": [[8, "pathfinding3d.finder.msp.MinimumSpanningTree.tree"]], "with_traceback() (pathfinding3d.finder.finder.executionrunsexception method)": [[8, "pathfinding3d.finder.finder.ExecutionRunsException.with_traceback"]], "with_traceback() (pathfinding3d.finder.finder.executiontimeexception method)": [[8, "pathfinding3d.finder.finder.ExecutionTimeException.with_traceback"]]}}) \ No newline at end of file +Search.setIndex({"docnames": ["CHANGELOG", "INSTALL", "INTRO", "USAGE", "index", "modules", "pathfinding3d", "pathfinding3d.core", "pathfinding3d.core.diagonal_movement", "pathfinding3d.core.grid", "pathfinding3d.core.heap", "pathfinding3d.core.heuristic", "pathfinding3d.core.node", "pathfinding3d.core.util", "pathfinding3d.core.world", "pathfinding3d.finder", "pathfinding3d.finder.a_star", "pathfinding3d.finder.best_first", "pathfinding3d.finder.bi_a_star", "pathfinding3d.finder.breadth_first", "pathfinding3d.finder.dijkstra", "pathfinding3d.finder.finder", "pathfinding3d.finder.ida_star", "pathfinding3d.finder.msp", "pathfinding3d.finder.theta_star"], "filenames": ["CHANGELOG.md", "INSTALL.md", "INTRO.md", "USAGE.md", "index.rst", "modules.rst", "pathfinding3d.rst", "pathfinding3d.core.rst", "pathfinding3d.core.diagonal_movement.rst", "pathfinding3d.core.grid.rst", "pathfinding3d.core.heap.rst", "pathfinding3d.core.heuristic.rst", "pathfinding3d.core.node.rst", "pathfinding3d.core.util.rst", "pathfinding3d.core.world.rst", "pathfinding3d.finder.rst", "pathfinding3d.finder.a_star.rst", "pathfinding3d.finder.best_first.rst", "pathfinding3d.finder.bi_a_star.rst", "pathfinding3d.finder.breadth_first.rst", "pathfinding3d.finder.dijkstra.rst", "pathfinding3d.finder.finder.rst", "pathfinding3d.finder.ida_star.rst", "pathfinding3d.finder.msp.rst", "pathfinding3d.finder.theta_star.rst"], "titles": ["Version History", "Installation", "Pathfinding3D", "Examples", "Welcome to pathfinding3d\u2019s documentation!", "pathfinding3d", "pathfinding3d package", "pathfinding3d.core package", "pathfinding3d.core.diagonal_movement module", "pathfinding3d.core.grid module", "pathfinding3d.core.heap module", "pathfinding3d.core.heuristic module", "pathfinding3d.core.node module", "pathfinding3d.core.util module", "pathfinding3d.core.world module", "pathfinding3d.finder package", "pathfinding3d.finder.a_star module", "pathfinding3d.finder.best_first module", "pathfinding3d.finder.bi_a_star module", "pathfinding3d.finder.breadth_first module", "pathfinding3d.finder.dijkstra module", "pathfinding3d.finder.finder module", "pathfinding3d.finder.ida_star module", "pathfinding3d.finder.msp module", "pathfinding3d.finder.theta_star module"], "terms": {"sphinx": 0, "document": 0, "updat": [0, 3], "fix": 0, "bug": 0, "thetastarfind": [0, 3, 6, 15, 24], "algorithm": [0, 2, 3, 9, 13, 16, 17, 18, 19, 20, 21, 22, 23, 24], "when": 0, "us": [0, 2, 3, 4, 9, 12, 13, 14, 16, 17, 18, 19, 20, 21, 22, 23, 24], "world": [0, 3, 6, 7, 10], "connect": [0, 4, 7, 9, 12, 14], "grid": [0, 3, 6, 7, 10, 12, 13, 14, 16, 17, 18, 19, 20, 21, 22, 23, 24], "see": [0, 3, 9, 14, 16, 17, 18, 19, 20, 21, 22, 23, 24], "issu": [0, 23], "12": [0, 3], "theta": [0, 2, 3, 24], "ad": [0, 3, 10], "line": [0, 3, 13], "sight": [0, 3, 13], "minor": 0, "improv": 0, "code": [0, 3, 16, 17, 18, 19, 20, 21, 22, 23, 24], "qualiti": 0, "more": [0, 3, 13], "test": [0, 7, 12, 16, 17, 18, 19, 20, 21, 22, 23, 24], "new": [0, 3, 9, 13, 14], "diagon": [0, 3, 8, 9, 14, 16, 17, 18, 19, 20, 21, 22, 23, 24], "movement": [0, 2, 4, 8, 9, 14, 16, 17, 18, 19, 20, 21, 22, 23, 24], "lru": 0, "cach": 0, "heurist": [0, 2, 6, 7, 12, 16, 17, 18, 19, 20, 21, 22, 23, 24], "exampl": [0, 4], "node": [0, 3, 6, 7, 9, 10, 11, 13, 14, 16, 17, 18, 19, 20, 21, 22, 23, 24], "class": [0, 3, 8, 9, 10, 12, 14, 16, 17, 18, 19, 20, 21, 22, 23, 24], "ha": [0, 3, 12, 13, 23], "addit": 0, "attribut": [0, 3, 10], "heap": [0, 6, 7], "replic": 0, "simpl": [0, 3, 10], "structur": [0, 3, 10], "inspir": [0, 10], "from": [0, 2, 3, 9, 10, 11, 12, 13, 14, 16, 17, 18, 19, 20, 21, 22, 23, 24], "python": [0, 1, 2, 10, 23], "pathfind": [0, 2, 3, 10, 12, 23], "origin": [0, 3, 10], "author": [0, 10], "base": [0, 8, 9, 10, 12, 13, 14, 16, 17, 18, 19, 20, 21, 22, 23, 24], "v1": 0, "7": [0, 2, 3], "initi": [0, 3, 10, 14], "have": [0, 3, 10, 14, 16, 17, 18, 19, 20, 21, 22, 23, 24], "better": [0, 3], "error": 0, "messag": [0, 21], "url": 0, "point": [0, 3, 11, 12, 16, 17, 18, 19, 20, 21, 22, 23, 24], "repositori": 0, "enabl": [0, 3], "weight": [0, 2, 3, 7, 9, 12, 14, 16, 17, 18, 19, 20, 21, 22, 23, 24], "biastarfind": [0, 6, 15, 18], "add": [0, 3, 16, 17, 18, 19, 20, 21, 22, 23], "type": [0, 3, 9, 10, 11, 12, 13, 14, 16, 17, 18, 19, 20, 21, 22, 23, 24], "hint": 0, "minim": 0, "autogener": 0, "codecov": 0, "badg": 0, "workflow": 0, "number": [0, 3, 9, 12, 16, 17, 18, 19, 20, 21, 22, 23, 24], "setup": 0, "py": 0, "minimum": [0, 2, 23], "releas": 0, "3": [1, 3, 4, 8], "8": [1, 3], "higher": [1, 3], "numpi": [1, 3], "The": [1, 3, 9, 10, 12, 13, 23], "packag": [1, 4, 5], "i": [1, 2, 3, 9, 10, 11, 12, 13, 14, 16, 17, 18, 19, 20, 21, 22, 23, 24], "avail": [1, 3], "so": [1, 3, 11, 24], "you": [1, 3], "can": [1, 3, 12, 14, 18, 19, 21, 24], "pip": [1, 3], "pathfinding3d": [1, 3], "git": 1, "clone": 1, "http": [1, 10, 22, 23], "github": [1, 3, 10, 23], "com": [1, 10, 22, 23], "harisankar95": 1, "cd": 1, "e": 1, "dev": 1, "checkout": 1, "b": 1, "branch_nam": 1, "python3": 2, "froke": 2, "brean": [2, 10, 23], "comprehens": 2, "librari": [2, 3], "design": 2, "3d": [2, 3, 9, 16, 17, 18, 19, 20, 21, 22, 23, 24], "applic": [2, 3], "current": [2, 9, 11, 16, 17, 18, 19, 20, 21, 22, 23, 24], "ar": [2, 3, 9, 10, 16, 17, 18, 19, 20, 21, 22, 23, 24], "path": [2, 4, 12, 13, 16, 17, 18, 19, 20, 21, 22, 23, 24], "finder": [2, 3, 5, 6], "bundl": 2, "thi": [2, 3, 10, 12, 14], "name": [2, 3], "A": [2, 3, 9, 10, 12, 13, 14, 16, 17, 18, 19, 20, 21, 22, 23, 24], "versatil": 2, "most": 2, "wide": 2, "dijkstra": [2, 6, 11, 15, 21, 23], "without": 2, "best": 2, "first": [2, 3, 13, 14, 16, 17, 18, 19, 20, 21, 22, 23, 24], "bi": [2, 3, 13, 16, 17, 18, 19, 20, 21, 22, 23, 24], "direct": [2, 3, 13, 16, 17, 18, 19, 20, 21, 22, 23, 24], "effici": [2, 3], "larg": [2, 16, 17, 18, 19, 20, 21, 22, 23, 24], "graph": 2, "known": 2, "goal": [2, 12], "breadth": [2, 19], "search": [2, 4, 12, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24], "bf": 2, "iter": [2, 3, 16, 17, 18, 19, 20, 21, 22, 23, 24], "deep": [2, 22], "ida": [2, 12, 16, 17, 18, 19, 20, 21, 22, 23, 24], "memori": 2, "span": [2, 23], "tree": [2, 15, 23], "msp": [2, 6, 15], "almost": 2, "smooth": [2, 3], "take": [2, 3, 10], "field": [2, 3, 9], "map": [2, 3, 9, 16, 17, 18, 19, 20, 21, 22, 23, 24], "account": 2, "variant": 2, "ani": [2, 4, 16, 17, 18, 19, 20, 21, 22, 23, 24], "angl": [2, 4], "allow": [2, 3, 9, 14, 16, 17, 18, 19, 20, 21, 22, 23, 24], "For": [3, 4], "detail": 3, "descript": [3, 23], "look": [3, 13], "folder": 3, "find": [3, 16, 17, 18, 19, 20, 21, 22, 23, 24], "environ": 3, "import": 3, "requir": [3, 4], "np": 3, "core": [3, 5, 6], "diagonal_mov": [3, 6, 7, 9, 14, 16, 17, 18, 19, 20, 21, 22, 23, 24], "diagonalmov": [3, 6, 7, 8, 9, 16, 17, 18, 19, 20, 21, 22, 24], "a_star": [3, 6, 15, 17, 18], "astarfind": [3, 6, 15, 16, 17, 18, 20, 24], "creat": [3, 9], "defin": 3, "arrai": [3, 9], "valu": [3, 9, 12, 16, 17, 18, 19, 21, 22, 23, 24], "smaller": 3, "equal": 3, "0": [3, 4, 9, 11, 12, 16, 17, 18, 19, 20, 21, 22, 23, 24], "repres": [3, 9, 10], "an": [3, 10, 13], "obstacl": 3, "posit": [3, 9], "walk": [3, 12], "bigger": 3, "cost": [3, 9, 10, 11, 12, 14, 16, 17, 18, 19, 20, 21, 22, 23, 24], "In": 3, "all": [3, 9, 12, 13, 14, 16, 17, 18, 19, 20, 21, 22, 23, 24], "walkabl": [3, 7, 9, 12], "same": [3, 16, 17, 18, 19, 20, 21, 22, 23, 24], "1": [3, 4, 8, 12, 16, 17, 18, 19, 20, 21, 22, 23, 24], "feel": 3, "free": 3, "complex": 3, "some": 3, "sensor": 3, "data": [3, 10], "input": 3, "x": [3, 7, 9, 11, 12], "y": [3, 7, 9, 11, 12], "z": [3, 7, 9, 11, 12], "matrix": [3, 9], "ones": 3, "set": [3, 9, 10, 16, 17, 18, 19, 20, 21, 22, 23, 24], "center": 3, "note": 3, "differ": 3, "vari": 3, "travers": 3, "instanti": 3, "object": [3, 8, 9, 10, 12, 14, 21], "instanc": 3, "everi": 3, "element": 3, "also": 3, "size": [3, 9], "start": [3, 11, 12, 13, 16, 17, 18, 19, 20, 21, 22, 23, 24], "end": [3, 13, 16, 17, 18, 19, 20, 21, 22, 23, 24], "determin": [3, 9, 10], "coordin": [3, 12, 13], "access": 3, "paramet": [3, 9, 10, 11, 12, 13, 14, 16, 17, 18, 19, 20, 21, 22, 23, 24], "second": [3, 13, 14, 16, 17, 18, 19, 20, 21, 22, 23, 24], "third": 3, "top": 3, "left": 3, "corner": 3, "bottom": 3, "right": 3, "2": [3, 4, 8, 16, 17, 18, 19, 20, 21, 22, 23, 24], "here": 3, "we": [3, 10, 16, 17, 18, 19, 20, 21, 22, 23, 24], "which": [3, 10, 13], "default": [3, 9, 13, 17, 18], "find_path": [3, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24], "method": 3, "return": [3, 9, 10, 11, 12, 13, 14, 16, 17, 18, 19, 20, 21, 22, 23, 24], "need": [3, 16, 17, 18, 19, 20, 21, 22, 23, 24], "alwai": [3, 7, 8, 11, 24], "run": [3, 16, 17, 18, 19, 20, 21, 22, 23, 24], "output": 3, "result": 3, "list": [3, 9, 10, 12, 13, 14, 16, 17, 18, 19, 20, 21, 22, 23, 24], "waypoint": 3, "convert": 3, "tupl": [3, 9, 10, 16, 17, 18, 19, 20, 21, 22, 23, 24], "pretti": 3, "print": 3, "part": [3, 16, 17, 18, 19, 20, 21, 22, 23], "p": 3, "identifi": 3, "oper": 3, "length": 3, "len": 3, "whole": 3, "copi": 3, "past": 3, "plai": 3, "With": 3, "seamlessli": 3, "multipl": [3, 14], "featur": 3, "invalu": 3, "simul": 3, "multi": 3, "stori": 3, "staircas": 3, "between": [3, 9, 13, 14], "even": 3, "magic": 3, "link": 3, "dispar": 3, "locat": [3, 10], "let": 3, "": [3, 13], "consid": [3, 9], "where": 3, "want": 3, "adjac": 3, "each": [3, 10], "world0": 3, "world1": 3, "both": [3, 13], "grid0": 3, "grid_id": [3, 7, 9, 12], "grid1": 3, "establish": 3, "wai": 3, "travel": 3, "unidirect": 3, "onli": [3, 11, 16, 17, 18, 19, 20, 21, 22, 23, 24], "one": [3, 9], "manag": 3, "find_neighbor": [3, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24], "them": 3, "dure": 3, "across": 3, "util": [3, 6, 7], "time": [3, 12, 16, 17, 18, 19, 20, 21, 22, 23, 24], "pass": 3, "_": 3, "anoth": [3, 12], "demonstr": 3, "uniqu": 3, "capabl": 3, "space": 3, "id": [3, 9, 12], "separ": 3, "path0": 3, "path1": 3, "through": [3, 12], "should": [3, 10, 21, 22, 23], "like": [3, 16, 17, 18, 19, 20, 21, 22, 23, 24], "put": 3, "togeth": 3, "sometim": 3, "help": 3, "understand": 3, "purpos": [3, 4], "instal": [3, 4], "o": 3, "o3d": 3, "load": 3, "sampl": 3, "sample_map": 3, "npy": 3, "shape": 3, "42": 3, "indic": 3, "file": 3, "download": 3, "provid": 3, "start_pt": 3, "21": 3, "end_pt": 3, "5": [3, 4], "38": 3, "33": 3, "represent": 3, "unpack": 3, "individu": 3, "argument": 3, "our": [3, 16, 17, 18, 19, 20, 21, 22, 23, 24], "specifi": [3, 9], "only_when_no_obstacl": [3, 7, 8], "get": [3, 9, 10, 14], "path_cost": 3, "g": [3, 7, 11, 12, 22], "f": [3, 7, 10, 11, 12], "4f": 3, "28": 3, "6130": 3, "20": 3, "458": 3, "blue": 3, "color": 3, "n": 3, "column": 3, "red": 3, "channel": 3, "green": 3, "xyz_pt": 3, "pointcloud": 3, "draw_geometri": 3, "obstacle_indic": 3, "stack": 3, "axi": 3, "astyp": 3, "float": [3, 9, 10, 11, 12, 13, 14, 16, 17, 18, 19, 20, 21, 22, 23, 24], "zero": 3, "max": [3, 16, 17, 18, 19, 20, 21, 22, 23, 24], "grei": 3, "path_color": 3, "sinc": 3, "alreadi": 3, "subtract": 3, "remain": 3, "prepar": 3, "start_color": 3, "end_color": 3, "full": 3, "now": 3, "along": 3, "similarli": 3, "correspond": [3, 10], "combin": 3, "concaten": 3, "cloud": 3, "pcd": 3, "geometri": 3, "vector3dvector": 3, "voxelgrid": 3, "gener": [3, 23], "voxel": 3, "voxel_s": 3, "voxel_grid": 3, "create_from_point_cloud": 3, "ax": 3, "trianglemesh": 3, "create_coordinate_fram": 3, "15": 3, "refer": 3, "remov": [3, 10, 16, 17, 18, 19, 20, 21, 22, 23], "width": [3, 9], "height": [3, 9], "window": 3, "window_nam": 3, "env": 3, "1024": 3, "768": 3, "rotat": 3, "click": 3, "drag": 3, "mous": 3, "zoom": 3, "out": 3, "wheel": 3, "03": 3, "view": 3, "often": 3, "desir": 3, "rather": 3, "than": [3, 16, 17, 18, 19, 20, 21, 22, 23, 24], "being": 3, "restrict": 3, "26": 3, "discret": 3, "achiev": 3, "subclass": 3, "cut": 3, "chase": 3, "how": [3, 9], "work": 3, "As": 3, "usual": 3, "theta_star": [3, 6, 15], "singl": 3, "middl": 3, "10": 3, "dtype": 3, "int8": 3, "9": 3, "notic": 3, "doe": [3, 10], "other": 3, "becaus": 3, "check": [3, 9, 13, 16, 17, 18, 19, 20, 21, 22, 23, 24], "whether": [3, 12, 13], "If": [3, 9, 10], "intermedi": 3, "vehicl": 3, "move": 3, "follow": 3, "reduc": 3, "quantit": 3, "analysi": 3, "compar": 3, "cleanup": [3, 7, 9, 12, 14], "astar_path": 3, "52": 3, "11": 3, "4": [3, 4, 8], "6": [3, 4], "function": [3, 10, 16, 17, 18, 19, 20, 21, 22, 23, 24], "calcul": [3, 11, 12, 14, 16, 17, 18, 19, 20, 21, 22, 23, 24], "def": 3, "calculate_path_cost": 3, "pt": 3, "pt_next": 3, "zip": 3, "dx": [3, 9, 11], "dy": [3, 9, 11], "dz": [3, 9, 11], "theta_star_cost": 3, "astar_cost": 3, "nastarfind": 3, "871045857174057": 3, "16": 3, "27062002292411": 3, "lower": 3, "thu": 3, "plotli": 3, "graph_object": 3, "go": 3, "figur": 3, "fig": 3, "scatter3d": 3, "mode": [3, 4], "marker": 3, "dict": [3, 14], "hovertext": 3, "black": 3, "orang": 3, "camera": 3, "up": 3, "1479269806756467": 3, "06501594452841505": 3, "0907033779622012": 3, "ey": 3, "3097359159706334": 3, "4710974884501846": 3, "095154166796815": 3, "project": 3, "perspect": 3, "layout": 3, "update_layout": 3, "scene": 3, "xaxi": 3, "titl": 3, "backgroundcolor": 3, "white": 3, "gridcolor": 3, "lightgrei": 3, "showbackground": 3, "true": [3, 9, 12, 13, 16, 17, 18, 19, 20, 21, 22, 23, 24], "zerolinecolor": 3, "rang": 3, "dtick": 3, "yaxi": 3, "zaxi": 3, "legend": 3, "yanchor": 3, "99": 3, "xanchor": 3, "01": 3, "bgcolor": 3, "rgba": 3, "255": 3, "text": 3, "v": [3, 22], "scene_camera": 3, "show": 3, "tab": 3, "open": [3, 7, 10, 12, 16, 17, 18, 19, 20, 21, 22, 23, 24], "your": 3, "browser": 3, "04": 3, "star": [3, 22], "introduct": 4, "pypi": 4, "develop": 4, "pleas": 4, "edit": 4, "usag": 4, "basic": [4, 12], "step": [4, 16, 17, 18, 19, 20, 21, 22, 23, 24], "portal": 4, "bridg": 4, "toi": 4, "two": [4, 13, 14], "build": 4, "storei": 4, "visual": 4, "prerequisit": 4, "open3d": 4, "chang": 4, "log": 4, "subpackag": [4, 5], "index": 4, "modul": [4, 6, 7, 15], "page": [4, 23], "submodul": [5, 6], "build_nod": [6, 7, 9], "simpleheap": [6, 7, 10], "null": [6, 7, 11], "manhattan": [6, 7, 11], "euclidean": [6, 7, 11], "chebyshev": [6, 7, 11], "octil": [6, 7, 11], "gridnod": [6, 7, 9, 10, 12, 13, 14, 16, 17, 18, 19, 20, 21, 22, 23, 24], "backtrac": [6, 7, 13], "bi_backtrac": [6, 7, 13], "raytrac": [6, 7, 13], "bresenham": [6, 7, 13], "expand_path": [6, 7, 13], "smoothen_path": [6, 7, 13], "line_of_sight": [6, 7, 13], "best_first": [6, 15], "bestfirst": [6, 15, 17], "bi_a_star": [6, 15], "breadth_first": [6, 15], "breadthfirstfind": [6, 15, 19], "dijkstrafind": [6, 15, 20], "executiontimeexcept": [6, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24], "executionrunsexcept": [6, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24], "ida_star": [6, 15], "idastarfind": [6, 15, 22], "minimumspanningtre": [6, 15, 23], "never": [7, 8, 9, 16, 17, 18, 19, 20, 21, 22], "if_at_most_one_obstacl": [7, 8], "__init__": [7, 9, 10, 12, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24], "_validate_dimens": [7, 9], "is_valid_grid": [7, 9], "insid": [7, 9], "_calc_cost": [7, 9], "calc_cost": [7, 9, 14], "neighbor": [7, 9, 14, 16, 17, 18, 19, 20, 21, 22, 23, 24], "_determine_node_retrieval_funct": [7, 10], "_determine_node_funct": [7, 10], "pop_nod": [7, 10], "push_nod": [7, 10], "remove_nod": [7, 10], "h": [7, 11, 12], "close": [7, 12], "parent": [7, 12, 13, 16, 17, 18, 19, 20, 21, 22, 23, 24], "retain_count": [7, 12], "sourc": [8, 9, 10, 11, 12, 13, 14, 16, 17, 18, 19, 20, 21, 22, 23, 24], "enum": [8, 9, 14, 16, 17, 18, 19, 20, 21, 22, 23, 24], "depth": [9, 22], "none": [9, 12, 16, 17, 18, 19, 20, 21, 22, 23, 24], "invers": 9, "fals": [9, 13, 14], "accord": [9, 13], "given": [9, 10, 13, 14, 16, 17, 18, 19, 20, 21, 22, 23, 24], "what": 9, "int": [9, 11, 12, 14, 16, 17, 18, 19, 20, 21, 22, 23, 24], "matrixtyp": 9, "thei": 9, "bool": [9, 12, 13, 14, 16, 17, 18, 19, 20, 21, 22, 23, 24], "option": [9, 12, 13, 16, 17, 18, 19, 20, 21, 22, 23, 24], "otherwis": [9, 13], "contain": 9, "ndarrai": 9, "valid": 9, "tile": [9, 16, 17, 18, 19, 20, 21, 22, 23, 24], "distanc": [9, 11, 16, 17, 18, 19, 20, 21, 22, 23, 24], "node_a": [9, 13, 14, 16, 17, 18, 19, 20, 21, 22, 23, 24], "node_b": [9, 13, 14, 16, 17, 18, 19, 20, 21, 22, 23, 24], "order": 10, "pull": 10, "54": 10, "peterchenad": 10, "implement": [10, 22, 23], "optim": 10, "It": 10, "maintain": 10, "statu": 10, "retriev": 10, "its": [10, 16, 17, 18, 19, 20, 21, 22, 23], "union": [10, 11, 22], "rais": [10, 16, 17, 18, 19, 20, 21, 22, 23, 24], "valueerror": 10, "pop": 10, "lowest": 10, "push": 10, "old_f": 10, "just": 10, "store": [10, 16, 17, 18, 19, 20, 21, 22, 23, 24], "ignor": 10, "old": 10, "special": 11, "save": 12, "includ": [12, 13], "overal": 12, "been": 12, "recurs": [12, 22], "track": [12, 16, 17, 18, 19, 20, 21, 22, 23, 24], "jump": [12, 16, 17, 18, 19, 20, 21, 22, 23], "reset": 12, "fresh": 12, "belong": 12, "other_nod": 12, "record": 13, "coords_a": 13, "coords_b": 13, "ly": 13, "form": 13, "rai": 13, "trace": 13, "coord": 13, "compress": 13, "segment": [13, 16, 17, 18, 19, 20, 21, 22, 23, 24], "interpol": 13, "expand": 13, "use_raytrac": 13, "uncompress": 13, "less": 13, "turn": 13, "natur": 13, "smoothen": 13, "node1": 13, "node2": 13, "exist": 13, "wether": 14, "check_neighbor": [15, 16, 17, 18, 19, 20, 21, 22, 23, 24], "apply_heurist": [15, 16, 17, 18, 19, 20, 21, 22, 23, 24], "keep_run": [15, 16, 17, 18, 19, 20, 21, 22, 23, 24], "process_nod": [15, 16, 17, 18, 19, 20, 21, 22, 23, 24], "arg": [15, 21, 23], "with_traceback": [15, 21], "itertre": [15, 23], "time_limit": [16, 17, 18, 19, 20, 21, 22, 23, 24], "max_run": [16, 17, 18, 19, 20, 21, 22, 23, 24], "callabl": [16, 17, 18, 19, 20, 21, 22, 23, 24], "shortest": [16, 17, 18, 19, 20, 21, 22, 23, 24], "edg": [16, 17, 18, 19, 20, 21, 22, 23, 24], "runtim": [16, 17, 18, 19, 20, 21, 22, 23, 24], "amount": [16, 17, 18, 19, 20, 21, 22, 23, 24], "tri": [16, 17, 18, 19, 20, 21, 22, 23, 24], "until": [16, 17, 18, 19, 20, 21, 22, 23, 24], "abort": [16, 17, 18, 19, 20, 21, 22, 23, 24], "enter": [16, 17, 18, 19, 20, 21, 22, 23, 24], "huge": [16, 17, 18, 19, 20, 21, 22, 23, 24], "constrain": [16, 17, 18, 19, 20, 21, 22, 23, 24], "mean": [16, 17, 18, 19, 20, 21, 22, 23, 24], "might": [16, 17, 18, 19, 20, 21, 22, 23, 24], "open_list": [16, 17, 18, 19, 20, 21, 22, 23, 24], "open_valu": [16, 17, 18, 19, 20, 21, 22, 23, 24], "backtrace_bi": [16, 17, 18, 20, 21, 22, 23, 24], "next": [16, 17, 18, 19, 20, 21, 22, 23, 24], "found": [16, 17, 18, 19, 20, 21, 22, 23, 24], "possibl": [16, 17, 18, 19, 20, 21, 22, 23, 24], "process": [16, 17, 18, 19, 20, 21, 22, 23, 24], "helper": [16, 17, 18, 19, 20, 21, 22, 23, 24], "appli": [16, 17, 18, 19, 20, 21, 22, 23, 24], "djikstra": [16, 17, 18, 19, 20, 21, 22, 23, 24], "jumppointsearch": [16, 17, 18, 19, 20, 21, 22, 23], "keep": [16, 17, 18, 19, 20, 21, 22, 23, 24], "someth": [16, 17, 18, 19, 20, 21, 22, 23, 24], "els": [16, 17, 18, 19, 20, 21, 22, 23, 24], "similar": [17, 18], "over": [19, 21], "except": 21, "tb": 21, "self": 21, "__traceback__": 21, "support": [21, 23], "track_recurs": 22, "www": 22, "apl": 22, "jhu": 22, "edu": 22, "hall": 22, "ai": 22, "program": 22, "html": 22, "retrac": 22, "nageshwara": 22, "rao": 22, "vipin": 22, "kumar": 22, "k": 22, "ramesh": 22, "parallel": 22, "januari": 22, "1987": 22, "ftp": 22, "c": 22, "utexa": 22, "snapshot": 22, "hourli": 22, "pub": 22, "lab": 22, "tech": 22, "report": 22, "ut": 22, "tr": 22, "87": 22, "46": 22, "pdf": 22, "javascript": 22, "gerard": 22, "meier": 22, "gerardmei": 22, "cutoff": 22, "kwarg": 23, "brad": 23, "beatti": 23, "18": 23, "wikipedia": 23, "nice": 23, "about": 23, "en": 23, "org": 23, "wiki": 23, "minimum_spanning_tre": 23, "yield": 23, "forc": 24, "Not": 24, "reach": 24, "grandpar": 24, "directli": 24, "skip": 24}, "objects": {"": [[6, 0, 0, "-", "pathfinding3d"]], "pathfinding3d": [[7, 0, 0, "-", "core"], [15, 0, 0, "-", "finder"]], "pathfinding3d.core": [[8, 0, 0, "-", "diagonal_movement"], [9, 0, 0, "-", "grid"], [10, 0, 0, "-", "heap"], [11, 0, 0, "-", "heuristic"], [12, 0, 0, "-", "node"], [13, 0, 0, "-", "util"], [14, 0, 0, "-", "world"]], "pathfinding3d.core.diagonal_movement": [[8, 1, 1, "", "DiagonalMovement"]], "pathfinding3d.core.diagonal_movement.DiagonalMovement": [[8, 2, 1, "", "always"], [8, 2, 1, "", "if_at_most_one_obstacle"], [8, 2, 1, "", "never"], [8, 2, 1, "", "only_when_no_obstacle"]], "pathfinding3d.core.grid": [[9, 1, 1, "", "Grid"], [9, 4, 1, "", "build_nodes"]], "pathfinding3d.core.grid.Grid": [[9, 3, 1, "", "__init__"], [9, 3, 1, "", "_calc_cost"], [9, 3, 1, "", "_validate_dimensions"], [9, 3, 1, "", "calc_cost"], [9, 3, 1, "", "cleanup"], [9, 3, 1, "", "inside"], [9, 3, 1, "", "is_valid_grid"], [9, 3, 1, "", "neighbors"], [9, 3, 1, "", "node"], [9, 3, 1, "", "walkable"]], "pathfinding3d.core.heap": [[10, 1, 1, "", "SimpleHeap"]], "pathfinding3d.core.heap.SimpleHeap": [[10, 3, 1, "", "__init__"], [10, 3, 1, "", "_determine_node_function"], [10, 3, 1, "", "_determine_node_retrieval_function"], [10, 3, 1, "", "pop_node"], [10, 3, 1, "", "push_node"], [10, 3, 1, "", "remove_node"]], "pathfinding3d.core.heuristic": [[11, 4, 1, "", "chebyshev"], [11, 4, 1, "", "euclidean"], [11, 4, 1, "", "manhattan"], [11, 4, 1, "", "null"], [11, 4, 1, "", "octile"]], "pathfinding3d.core.node": [[12, 1, 1, "", "GridNode"], [12, 1, 1, "", "Node"]], "pathfinding3d.core.node.GridNode": [[12, 3, 1, "", "__init__"], [12, 3, 1, "", "cleanup"], [12, 2, 1, "", "closed"], [12, 3, 1, "", "connect"], [12, 2, 1, "id14", "connections"], [12, 2, 1, "", "f"], [12, 2, 1, "", "g"], [12, 2, 1, "id13", "grid_id"], [12, 2, 1, "", "h"], [12, 2, 1, "", "opened"], [12, 2, 1, "", "parent"], [12, 2, 1, "", "retain_count"], [12, 2, 1, "", "tested"], [12, 2, 1, "id11", "walkable"], [12, 2, 1, "id12", "weight"], [12, 2, 1, "id8", "x"], [12, 2, 1, "id9", "y"], [12, 2, 1, "id10", "z"]], "pathfinding3d.core.node.Node": [[12, 3, 1, "", "__init__"], [12, 3, 1, "", "cleanup"], [12, 2, 1, "id4", "closed"], [12, 2, 1, "id2", "f"], [12, 2, 1, "id1", "g"], [12, 2, 1, "id0", "h"], [12, 2, 1, "id3", "opened"], [12, 2, 1, "id5", "parent"], [12, 2, 1, "id6", "retain_count"], [12, 2, 1, "id7", "tested"]], "pathfinding3d.core.util": [[13, 4, 1, "", "backtrace"], [13, 4, 1, "", "bi_backtrace"], [13, 4, 1, "", "bresenham"], [13, 4, 1, "", "expand_path"], [13, 4, 1, "", "line_of_sight"], [13, 4, 1, "", "raytrace"], [13, 4, 1, "", "smoothen_path"]], "pathfinding3d.core.world": [[14, 1, 1, "", "World"]], "pathfinding3d.core.world.World": [[14, 3, 1, "", "__init__"], [14, 3, 1, "", "calc_cost"], [14, 3, 1, "", "cleanup"], [14, 3, 1, "", "neighbors"]], "pathfinding3d.finder": [[16, 0, 0, "-", "a_star"], [17, 0, 0, "-", "best_first"], [18, 0, 0, "-", "bi_a_star"], [19, 0, 0, "-", "breadth_first"], [20, 0, 0, "-", "dijkstra"], [21, 0, 0, "-", "finder"], [22, 0, 0, "-", "ida_star"], [23, 0, 0, "-", "msp"], [24, 0, 0, "-", "theta_star"]], "pathfinding3d.finder.a_star": [[16, 1, 1, "", "AStarFinder"]], "pathfinding3d.finder.a_star.AStarFinder": [[16, 3, 1, "", "__init__"], [16, 3, 1, "", "apply_heuristic"], [16, 3, 1, "", "check_neighbors"], [16, 3, 1, "", "find_neighbors"], [16, 3, 1, "", "find_path"], [16, 3, 1, "", "keep_running"], [16, 3, 1, "", "process_node"]], "pathfinding3d.finder.best_first": [[17, 1, 1, "", "BestFirst"]], "pathfinding3d.finder.best_first.BestFirst": [[17, 3, 1, "", "__init__"], [17, 3, 1, "", "apply_heuristic"], [17, 3, 1, "", "check_neighbors"], [17, 3, 1, "", "find_neighbors"], [17, 3, 1, "", "find_path"], [17, 3, 1, "", "keep_running"], [17, 3, 1, "", "process_node"]], "pathfinding3d.finder.bi_a_star": [[18, 1, 1, "", "BiAStarFinder"]], "pathfinding3d.finder.bi_a_star.BiAStarFinder": [[18, 3, 1, "", "__init__"], [18, 3, 1, "", "apply_heuristic"], [18, 3, 1, "", "check_neighbors"], [18, 3, 1, "", "find_neighbors"], [18, 3, 1, "", "find_path"], [18, 3, 1, "", "keep_running"], [18, 3, 1, "", "process_node"]], "pathfinding3d.finder.breadth_first": [[19, 1, 1, "", "BreadthFirstFinder"]], "pathfinding3d.finder.breadth_first.BreadthFirstFinder": [[19, 3, 1, "", "__init__"], [19, 3, 1, "", "apply_heuristic"], [19, 3, 1, "", "check_neighbors"], [19, 3, 1, "", "find_neighbors"], [19, 3, 1, "", "find_path"], [19, 3, 1, "", "keep_running"], [19, 3, 1, "", "process_node"]], "pathfinding3d.finder.dijkstra": [[20, 1, 1, "", "DijkstraFinder"]], "pathfinding3d.finder.dijkstra.DijkstraFinder": [[20, 3, 1, "", "__init__"], [20, 3, 1, "", "apply_heuristic"], [20, 3, 1, "", "check_neighbors"], [20, 3, 1, "", "find_neighbors"], [20, 3, 1, "", "find_path"], [20, 3, 1, "", "keep_running"], [20, 3, 1, "", "process_node"]], "pathfinding3d.finder.finder": [[21, 5, 1, "", "ExecutionRunsException"], [21, 5, 1, "", "ExecutionTimeException"], [21, 1, 1, "", "Finder"]], "pathfinding3d.finder.finder.ExecutionRunsException": [[21, 3, 1, "", "__init__"], [21, 2, 1, "", "args"], [21, 3, 1, "", "with_traceback"]], "pathfinding3d.finder.finder.ExecutionTimeException": [[21, 3, 1, "", "__init__"], [21, 2, 1, "", "args"], [21, 3, 1, "", "with_traceback"]], "pathfinding3d.finder.finder.Finder": [[21, 3, 1, "", "__init__"], [21, 3, 1, "", "apply_heuristic"], [21, 3, 1, "", "check_neighbors"], [21, 3, 1, "", "find_neighbors"], [21, 3, 1, "", "find_path"], [21, 3, 1, "", "keep_running"], [21, 3, 1, "", "process_node"]], "pathfinding3d.finder.ida_star": [[22, 1, 1, "", "IDAStarFinder"]], "pathfinding3d.finder.ida_star.IDAStarFinder": [[22, 3, 1, "", "__init__"], [22, 3, 1, "", "apply_heuristic"], [22, 3, 1, "", "check_neighbors"], [22, 3, 1, "", "find_neighbors"], [22, 3, 1, "", "find_path"], [22, 3, 1, "", "keep_running"], [22, 3, 1, "", "process_node"], [22, 3, 1, "", "search"]], "pathfinding3d.finder.msp": [[23, 1, 1, "", "MinimumSpanningTree"]], "pathfinding3d.finder.msp.MinimumSpanningTree": [[23, 3, 1, "", "__init__"], [23, 3, 1, "", "apply_heuristic"], [23, 3, 1, "", "check_neighbors"], [23, 3, 1, "", "find_neighbors"], [23, 3, 1, "", "find_path"], [23, 3, 1, "", "itertree"], [23, 3, 1, "", "keep_running"], [23, 3, 1, "", "process_node"], [23, 3, 1, "", "tree"]], "pathfinding3d.finder.theta_star": [[24, 1, 1, "", "ThetaStarFinder"]], "pathfinding3d.finder.theta_star.ThetaStarFinder": [[24, 3, 1, "", "__init__"], [24, 3, 1, "", "apply_heuristic"], [24, 3, 1, "", "check_neighbors"], [24, 3, 1, "", "find_neighbors"], [24, 3, 1, "", "find_path"], [24, 3, 1, "", "keep_running"], [24, 3, 1, "", "process_node"]]}, "objtypes": {"0": "py:module", "1": "py:class", "2": "py:attribute", "3": "py:method", "4": "py:function", "5": "py:exception"}, "objnames": {"0": ["py", "module", "Python module"], "1": ["py", "class", "Python class"], "2": ["py", "attribute", "Python attribute"], "3": ["py", "method", "Python method"], "4": ["py", "function", "Python function"], "5": ["py", "exception", "Python exception"]}, "titleterms": {"version": 0, "histori": 0, "0": 0, "6": 0, "2": 0, "1": 0, "5": 0, "4": 0, "3": 0, "instal": 1, "requir": 1, "pypi": 1, "For": 1, "develop": 1, "purpos": 1, "pleas": 1, "us": 1, "edit": 1, "mode": 1, "pathfinding3d": [2, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24], "introduct": 2, "exampl": 3, "basic": 3, "usag": 3, "step": 3, "portal": 3, "bridg": 3, "toi": 3, "connect": 3, "two": 3, "build": 3, "storei": 3, "visual": 3, "path": 3, "prerequisit": 3, "open3d": 3, "ani": 3, "angl": 3, "movement": 3, "welcom": 4, "": 4, "document": 4, "content": 4, "indic": 4, "tabl": 4, "packag": [6, 7, 15], "subpackag": 6, "core": [7, 8, 9, 10, 11, 12, 13, 14], "submodul": [7, 15], "diagonal_mov": 8, "modul": [8, 9, 10, 11, 12, 13, 14, 16, 17, 18, 19, 20, 21, 22, 23, 24], "grid": 9, "heap": 10, "heurist": 11, "node": 12, "util": 13, "world": 14, "finder": [15, 16, 17, 18, 19, 20, 21, 22, 23, 24], "a_star": 16, "best_first": 17, "bi_a_star": 18, "breadth_first": 19, "dijkstra": 20, "ida_star": 22, "msp": 23, "theta_star": 24}, "envversion": {"sphinx.domains.c": 3, "sphinx.domains.changeset": 1, "sphinx.domains.citation": 1, "sphinx.domains.cpp": 9, "sphinx.domains.index": 1, "sphinx.domains.javascript": 3, "sphinx.domains.math": 2, "sphinx.domains.python": 4, "sphinx.domains.rst": 2, "sphinx.domains.std": 2, "sphinx.ext.todo": 2, "sphinx.ext.viewcode": 1, "sphinx": 58}, "alltitles": {"Version History": [[0, "version-history"]], "0.6.2": [[0, "id1"]], "0.6.1": [[0, "id2"]], "0.6.0": [[0, "id3"]], "0.5.1": [[0, "id4"]], "0.5.0": [[0, "id5"]], "0.4.1": [[0, "id6"]], "0.4.0": [[0, "id7"]], "0.3.1": [[0, "id8"]], "0.3": [[0, "id9"]], "0.2": [[0, "id10"]], "0.1": [[0, "id11"]], "Installation": [[1, "installation"]], "Requirements": [[1, "requirements"]], "PyPI": [[1, "pypi"]], "For development purposes please use editable mode": [[1, "for-development-purposes-please-use-editable-mode"]], "Pathfinding3D": [[2, "pathfinding3d"]], "Introduction": [[2, "introduction"]], "Examples": [[3, "examples"]], "Basic usage": [[3, "basic-usage"]], "Steps/Portals/Bridges": [[3, "steps-portals-bridges"]], "Toy Example: Connecting Two Building Storeys with a Bridge": [[3, "toy-example-connecting-two-building-storeys-with-a-bridge"]], "Visualizing the Path": [[3, "visualizing-the-path"]], "Prerequisites": [[3, "prerequisites"]], "Example with Open3D": [[3, "example-with-open3d"]], "Example with any angle of movement": [[3, "example-with-any-angle-of-movement"]], "Welcome to pathfinding3d\u2019s documentation!": [[4, "welcome-to-pathfinding3d-s-documentation"]], "Contents:": [[4, null]], "Indices and tables": [[4, "indices-and-tables"]], "pathfinding3d": [[5, "pathfinding3d"]], "pathfinding3d package": [[6, "module-pathfinding3d"]], "Subpackages": [[6, "subpackages"]], "pathfinding3d.core package": [[7, "module-pathfinding3d.core"]], "Submodules": [[7, "submodules"], [15, "submodules"]], "pathfinding3d.core.diagonal_movement module": [[8, "module-pathfinding3d.core.diagonal_movement"]], "pathfinding3d.core.grid module": [[9, "module-pathfinding3d.core.grid"]], "pathfinding3d.core.heap module": [[10, "module-pathfinding3d.core.heap"]], "pathfinding3d.core.heuristic module": [[11, "module-pathfinding3d.core.heuristic"]], "pathfinding3d.core.node module": [[12, "module-pathfinding3d.core.node"]], "pathfinding3d.core.util module": [[13, "module-pathfinding3d.core.util"]], "pathfinding3d.core.world module": [[14, "module-pathfinding3d.core.world"]], "pathfinding3d.finder package": [[15, "module-pathfinding3d.finder"]], "pathfinding3d.finder.a_star module": [[16, "module-pathfinding3d.finder.a_star"]], "pathfinding3d.finder.best_first module": [[17, "module-pathfinding3d.finder.best_first"]], "pathfinding3d.finder.bi_a_star module": [[18, "module-pathfinding3d.finder.bi_a_star"]], "pathfinding3d.finder.breadth_first module": [[19, "module-pathfinding3d.finder.breadth_first"]], "pathfinding3d.finder.dijkstra module": [[20, "module-pathfinding3d.finder.dijkstra"]], "pathfinding3d.finder.finder module": [[21, "module-pathfinding3d.finder.finder"]], "pathfinding3d.finder.ida_star module": [[22, "module-pathfinding3d.finder.ida_star"]], "pathfinding3d.finder.msp module": [[23, "module-pathfinding3d.finder.msp"]], "pathfinding3d.finder.theta_star module": [[24, "module-pathfinding3d.finder.theta_star"]]}, "indexentries": {"module": [[6, "module-pathfinding3d"], [7, "module-pathfinding3d.core"], [8, "module-pathfinding3d.core.diagonal_movement"], [9, "module-pathfinding3d.core.grid"], [10, "module-pathfinding3d.core.heap"], [11, "module-pathfinding3d.core.heuristic"], [12, "module-pathfinding3d.core.node"], [13, "module-pathfinding3d.core.util"], [14, "module-pathfinding3d.core.world"], [15, "module-pathfinding3d.finder"], [16, "module-pathfinding3d.finder.a_star"], [17, "module-pathfinding3d.finder.best_first"], [18, "module-pathfinding3d.finder.bi_a_star"], [19, "module-pathfinding3d.finder.breadth_first"], [20, "module-pathfinding3d.finder.dijkstra"], [21, "module-pathfinding3d.finder.finder"], [22, "module-pathfinding3d.finder.ida_star"], [23, "module-pathfinding3d.finder.msp"], [24, "module-pathfinding3d.finder.theta_star"]], "pathfinding3d": [[6, "module-pathfinding3d"]], "pathfinding3d.core": [[7, "module-pathfinding3d.core"]], "diagonalmovement (class in pathfinding3d.core.diagonal_movement)": [[8, "pathfinding3d.core.diagonal_movement.DiagonalMovement"]], "always (pathfinding3d.core.diagonal_movement.diagonalmovement attribute)": [[8, "pathfinding3d.core.diagonal_movement.DiagonalMovement.always"]], "if_at_most_one_obstacle (pathfinding3d.core.diagonal_movement.diagonalmovement attribute)": [[8, "pathfinding3d.core.diagonal_movement.DiagonalMovement.if_at_most_one_obstacle"]], "never (pathfinding3d.core.diagonal_movement.diagonalmovement attribute)": [[8, "pathfinding3d.core.diagonal_movement.DiagonalMovement.never"]], "only_when_no_obstacle (pathfinding3d.core.diagonal_movement.diagonalmovement attribute)": [[8, "pathfinding3d.core.diagonal_movement.DiagonalMovement.only_when_no_obstacle"]], "pathfinding3d.core.diagonal_movement": [[8, "module-pathfinding3d.core.diagonal_movement"]], "grid (class in pathfinding3d.core.grid)": [[9, "pathfinding3d.core.grid.Grid"]], "__init__() (pathfinding3d.core.grid.grid method)": [[9, "pathfinding3d.core.grid.Grid.__init__"]], "_calc_cost() (pathfinding3d.core.grid.grid method)": [[9, "pathfinding3d.core.grid.Grid._calc_cost"]], "_validate_dimensions() (pathfinding3d.core.grid.grid method)": [[9, "pathfinding3d.core.grid.Grid._validate_dimensions"]], "build_nodes() (in module pathfinding3d.core.grid)": [[9, "pathfinding3d.core.grid.build_nodes"]], "calc_cost() (pathfinding3d.core.grid.grid method)": [[9, "pathfinding3d.core.grid.Grid.calc_cost"]], "cleanup() (pathfinding3d.core.grid.grid method)": [[9, "pathfinding3d.core.grid.Grid.cleanup"]], "inside() (pathfinding3d.core.grid.grid method)": [[9, "pathfinding3d.core.grid.Grid.inside"]], "is_valid_grid() (pathfinding3d.core.grid.grid method)": [[9, "pathfinding3d.core.grid.Grid.is_valid_grid"]], "neighbors() (pathfinding3d.core.grid.grid method)": [[9, "pathfinding3d.core.grid.Grid.neighbors"]], "node() (pathfinding3d.core.grid.grid method)": [[9, "pathfinding3d.core.grid.Grid.node"]], "pathfinding3d.core.grid": [[9, "module-pathfinding3d.core.grid"]], "walkable() (pathfinding3d.core.grid.grid method)": [[9, "pathfinding3d.core.grid.Grid.walkable"]], "simpleheap (class in pathfinding3d.core.heap)": [[10, "pathfinding3d.core.heap.SimpleHeap"]], "__init__() (pathfinding3d.core.heap.simpleheap method)": [[10, "pathfinding3d.core.heap.SimpleHeap.__init__"]], "_determine_node_function() (pathfinding3d.core.heap.simpleheap method)": [[10, "pathfinding3d.core.heap.SimpleHeap._determine_node_function"]], "_determine_node_retrieval_function() (pathfinding3d.core.heap.simpleheap method)": [[10, "pathfinding3d.core.heap.SimpleHeap._determine_node_retrieval_function"]], "pathfinding3d.core.heap": [[10, "module-pathfinding3d.core.heap"]], "pop_node() (pathfinding3d.core.heap.simpleheap method)": [[10, "pathfinding3d.core.heap.SimpleHeap.pop_node"]], "push_node() (pathfinding3d.core.heap.simpleheap method)": [[10, "pathfinding3d.core.heap.SimpleHeap.push_node"]], "remove_node() (pathfinding3d.core.heap.simpleheap method)": [[10, "pathfinding3d.core.heap.SimpleHeap.remove_node"]], "chebyshev() (in module pathfinding3d.core.heuristic)": [[11, "pathfinding3d.core.heuristic.chebyshev"]], "euclidean() (in module pathfinding3d.core.heuristic)": [[11, "pathfinding3d.core.heuristic.euclidean"]], "manhattan() (in module pathfinding3d.core.heuristic)": [[11, "pathfinding3d.core.heuristic.manhattan"]], "null() (in module pathfinding3d.core.heuristic)": [[11, "pathfinding3d.core.heuristic.null"]], "octile() (in module pathfinding3d.core.heuristic)": [[11, "pathfinding3d.core.heuristic.octile"]], "pathfinding3d.core.heuristic": [[11, "module-pathfinding3d.core.heuristic"]], "gridnode (class in pathfinding3d.core.node)": [[12, "pathfinding3d.core.node.GridNode"]], "node (class in pathfinding3d.core.node)": [[12, "pathfinding3d.core.node.Node"]], "__init__() (pathfinding3d.core.node.gridnode method)": [[12, "pathfinding3d.core.node.GridNode.__init__"]], "__init__() (pathfinding3d.core.node.node method)": [[12, "pathfinding3d.core.node.Node.__init__"]], "cleanup() (pathfinding3d.core.node.gridnode method)": [[12, "pathfinding3d.core.node.GridNode.cleanup"]], "cleanup() (pathfinding3d.core.node.node method)": [[12, "pathfinding3d.core.node.Node.cleanup"]], "closed (pathfinding3d.core.node.gridnode attribute)": [[12, "pathfinding3d.core.node.GridNode.closed"]], "closed (pathfinding3d.core.node.node attribute)": [[12, "id4"], [12, "pathfinding3d.core.node.Node.closed"]], "connect() (pathfinding3d.core.node.gridnode method)": [[12, "pathfinding3d.core.node.GridNode.connect"]], "connections (pathfinding3d.core.node.gridnode attribute)": [[12, "id14"], [12, "pathfinding3d.core.node.GridNode.connections"]], "f (pathfinding3d.core.node.gridnode attribute)": [[12, "pathfinding3d.core.node.GridNode.f"]], "f (pathfinding3d.core.node.node attribute)": [[12, "id2"], [12, "pathfinding3d.core.node.Node.f"]], "g (pathfinding3d.core.node.gridnode attribute)": [[12, "pathfinding3d.core.node.GridNode.g"]], "g (pathfinding3d.core.node.node attribute)": [[12, "id1"], [12, "pathfinding3d.core.node.Node.g"]], "grid_id (pathfinding3d.core.node.gridnode attribute)": [[12, "id13"], [12, "pathfinding3d.core.node.GridNode.grid_id"]], "h (pathfinding3d.core.node.gridnode attribute)": [[12, "pathfinding3d.core.node.GridNode.h"]], "h (pathfinding3d.core.node.node attribute)": [[12, "id0"], [12, "pathfinding3d.core.node.Node.h"]], "opened (pathfinding3d.core.node.gridnode attribute)": [[12, "pathfinding3d.core.node.GridNode.opened"]], "opened (pathfinding3d.core.node.node attribute)": [[12, "id3"], [12, "pathfinding3d.core.node.Node.opened"]], "parent (pathfinding3d.core.node.gridnode attribute)": [[12, "pathfinding3d.core.node.GridNode.parent"]], "parent (pathfinding3d.core.node.node attribute)": [[12, "id5"], [12, "pathfinding3d.core.node.Node.parent"]], "pathfinding3d.core.node": [[12, "module-pathfinding3d.core.node"]], "retain_count (pathfinding3d.core.node.gridnode attribute)": [[12, "pathfinding3d.core.node.GridNode.retain_count"]], "retain_count (pathfinding3d.core.node.node attribute)": [[12, "id6"], [12, "pathfinding3d.core.node.Node.retain_count"]], "tested (pathfinding3d.core.node.gridnode attribute)": [[12, "pathfinding3d.core.node.GridNode.tested"]], "tested (pathfinding3d.core.node.node attribute)": [[12, "id7"], [12, "pathfinding3d.core.node.Node.tested"]], "walkable (pathfinding3d.core.node.gridnode attribute)": [[12, "id11"], [12, "pathfinding3d.core.node.GridNode.walkable"]], "weight (pathfinding3d.core.node.gridnode attribute)": [[12, "id12"], [12, "pathfinding3d.core.node.GridNode.weight"]], "x (pathfinding3d.core.node.gridnode attribute)": [[12, "id8"], [12, "pathfinding3d.core.node.GridNode.x"]], "y (pathfinding3d.core.node.gridnode attribute)": [[12, "id9"], [12, "pathfinding3d.core.node.GridNode.y"]], "z (pathfinding3d.core.node.gridnode attribute)": [[12, "id10"], [12, "pathfinding3d.core.node.GridNode.z"]], "backtrace() (in module pathfinding3d.core.util)": [[13, "pathfinding3d.core.util.backtrace"]], "bi_backtrace() (in module pathfinding3d.core.util)": [[13, "pathfinding3d.core.util.bi_backtrace"]], "bresenham() (in module pathfinding3d.core.util)": [[13, "pathfinding3d.core.util.bresenham"]], "expand_path() (in module pathfinding3d.core.util)": [[13, "pathfinding3d.core.util.expand_path"]], "line_of_sight() (in module pathfinding3d.core.util)": [[13, "pathfinding3d.core.util.line_of_sight"]], "pathfinding3d.core.util": [[13, "module-pathfinding3d.core.util"]], "raytrace() (in module pathfinding3d.core.util)": [[13, "pathfinding3d.core.util.raytrace"]], "smoothen_path() (in module pathfinding3d.core.util)": [[13, "pathfinding3d.core.util.smoothen_path"]], "world (class in pathfinding3d.core.world)": [[14, "pathfinding3d.core.world.World"]], "__init__() (pathfinding3d.core.world.world method)": [[14, "pathfinding3d.core.world.World.__init__"]], "calc_cost() (pathfinding3d.core.world.world method)": [[14, "pathfinding3d.core.world.World.calc_cost"]], "cleanup() (pathfinding3d.core.world.world method)": [[14, "pathfinding3d.core.world.World.cleanup"]], "neighbors() (pathfinding3d.core.world.world method)": [[14, "pathfinding3d.core.world.World.neighbors"]], "pathfinding3d.core.world": [[14, "module-pathfinding3d.core.world"]], "pathfinding3d.finder": [[15, "module-pathfinding3d.finder"]], "astarfinder (class in pathfinding3d.finder.a_star)": [[16, "pathfinding3d.finder.a_star.AStarFinder"]], "__init__() (pathfinding3d.finder.a_star.astarfinder method)": [[16, "pathfinding3d.finder.a_star.AStarFinder.__init__"]], "apply_heuristic() (pathfinding3d.finder.a_star.astarfinder method)": [[16, "pathfinding3d.finder.a_star.AStarFinder.apply_heuristic"]], "check_neighbors() (pathfinding3d.finder.a_star.astarfinder method)": [[16, "pathfinding3d.finder.a_star.AStarFinder.check_neighbors"]], "find_neighbors() (pathfinding3d.finder.a_star.astarfinder method)": [[16, "pathfinding3d.finder.a_star.AStarFinder.find_neighbors"]], "find_path() (pathfinding3d.finder.a_star.astarfinder method)": [[16, "pathfinding3d.finder.a_star.AStarFinder.find_path"]], "keep_running() (pathfinding3d.finder.a_star.astarfinder method)": [[16, "pathfinding3d.finder.a_star.AStarFinder.keep_running"]], "pathfinding3d.finder.a_star": [[16, "module-pathfinding3d.finder.a_star"]], "process_node() (pathfinding3d.finder.a_star.astarfinder method)": [[16, "pathfinding3d.finder.a_star.AStarFinder.process_node"]], "bestfirst (class in pathfinding3d.finder.best_first)": [[17, "pathfinding3d.finder.best_first.BestFirst"]], "__init__() (pathfinding3d.finder.best_first.bestfirst method)": [[17, "pathfinding3d.finder.best_first.BestFirst.__init__"]], "apply_heuristic() (pathfinding3d.finder.best_first.bestfirst method)": [[17, "pathfinding3d.finder.best_first.BestFirst.apply_heuristic"]], "check_neighbors() (pathfinding3d.finder.best_first.bestfirst method)": [[17, "pathfinding3d.finder.best_first.BestFirst.check_neighbors"]], "find_neighbors() (pathfinding3d.finder.best_first.bestfirst method)": [[17, "pathfinding3d.finder.best_first.BestFirst.find_neighbors"]], "find_path() (pathfinding3d.finder.best_first.bestfirst method)": [[17, "pathfinding3d.finder.best_first.BestFirst.find_path"]], "keep_running() (pathfinding3d.finder.best_first.bestfirst method)": [[17, "pathfinding3d.finder.best_first.BestFirst.keep_running"]], "pathfinding3d.finder.best_first": [[17, "module-pathfinding3d.finder.best_first"]], "process_node() (pathfinding3d.finder.best_first.bestfirst method)": [[17, "pathfinding3d.finder.best_first.BestFirst.process_node"]], "biastarfinder (class in pathfinding3d.finder.bi_a_star)": [[18, "pathfinding3d.finder.bi_a_star.BiAStarFinder"]], "__init__() (pathfinding3d.finder.bi_a_star.biastarfinder method)": [[18, "pathfinding3d.finder.bi_a_star.BiAStarFinder.__init__"]], "apply_heuristic() (pathfinding3d.finder.bi_a_star.biastarfinder method)": [[18, "pathfinding3d.finder.bi_a_star.BiAStarFinder.apply_heuristic"]], "check_neighbors() (pathfinding3d.finder.bi_a_star.biastarfinder method)": [[18, "pathfinding3d.finder.bi_a_star.BiAStarFinder.check_neighbors"]], "find_neighbors() (pathfinding3d.finder.bi_a_star.biastarfinder method)": [[18, "pathfinding3d.finder.bi_a_star.BiAStarFinder.find_neighbors"]], "find_path() (pathfinding3d.finder.bi_a_star.biastarfinder method)": [[18, "pathfinding3d.finder.bi_a_star.BiAStarFinder.find_path"]], "keep_running() (pathfinding3d.finder.bi_a_star.biastarfinder method)": [[18, "pathfinding3d.finder.bi_a_star.BiAStarFinder.keep_running"]], "pathfinding3d.finder.bi_a_star": [[18, "module-pathfinding3d.finder.bi_a_star"]], "process_node() (pathfinding3d.finder.bi_a_star.biastarfinder method)": [[18, "pathfinding3d.finder.bi_a_star.BiAStarFinder.process_node"]], "breadthfirstfinder (class in pathfinding3d.finder.breadth_first)": [[19, "pathfinding3d.finder.breadth_first.BreadthFirstFinder"]], "__init__() (pathfinding3d.finder.breadth_first.breadthfirstfinder method)": [[19, "pathfinding3d.finder.breadth_first.BreadthFirstFinder.__init__"]], "apply_heuristic() (pathfinding3d.finder.breadth_first.breadthfirstfinder method)": [[19, "pathfinding3d.finder.breadth_first.BreadthFirstFinder.apply_heuristic"]], "check_neighbors() (pathfinding3d.finder.breadth_first.breadthfirstfinder method)": [[19, "pathfinding3d.finder.breadth_first.BreadthFirstFinder.check_neighbors"]], "find_neighbors() (pathfinding3d.finder.breadth_first.breadthfirstfinder method)": [[19, "pathfinding3d.finder.breadth_first.BreadthFirstFinder.find_neighbors"]], "find_path() (pathfinding3d.finder.breadth_first.breadthfirstfinder method)": [[19, "pathfinding3d.finder.breadth_first.BreadthFirstFinder.find_path"]], "keep_running() (pathfinding3d.finder.breadth_first.breadthfirstfinder method)": [[19, "pathfinding3d.finder.breadth_first.BreadthFirstFinder.keep_running"]], "pathfinding3d.finder.breadth_first": [[19, "module-pathfinding3d.finder.breadth_first"]], "process_node() (pathfinding3d.finder.breadth_first.breadthfirstfinder method)": [[19, "pathfinding3d.finder.breadth_first.BreadthFirstFinder.process_node"]], "dijkstrafinder (class in pathfinding3d.finder.dijkstra)": [[20, "pathfinding3d.finder.dijkstra.DijkstraFinder"]], "__init__() (pathfinding3d.finder.dijkstra.dijkstrafinder method)": [[20, "pathfinding3d.finder.dijkstra.DijkstraFinder.__init__"]], "apply_heuristic() (pathfinding3d.finder.dijkstra.dijkstrafinder method)": [[20, "pathfinding3d.finder.dijkstra.DijkstraFinder.apply_heuristic"]], "check_neighbors() (pathfinding3d.finder.dijkstra.dijkstrafinder method)": [[20, "pathfinding3d.finder.dijkstra.DijkstraFinder.check_neighbors"]], "find_neighbors() (pathfinding3d.finder.dijkstra.dijkstrafinder method)": [[20, "pathfinding3d.finder.dijkstra.DijkstraFinder.find_neighbors"]], "find_path() (pathfinding3d.finder.dijkstra.dijkstrafinder method)": [[20, "pathfinding3d.finder.dijkstra.DijkstraFinder.find_path"]], "keep_running() (pathfinding3d.finder.dijkstra.dijkstrafinder method)": [[20, "pathfinding3d.finder.dijkstra.DijkstraFinder.keep_running"]], "pathfinding3d.finder.dijkstra": [[20, "module-pathfinding3d.finder.dijkstra"]], "process_node() (pathfinding3d.finder.dijkstra.dijkstrafinder method)": [[20, "pathfinding3d.finder.dijkstra.DijkstraFinder.process_node"]], "executionrunsexception": [[21, "pathfinding3d.finder.finder.ExecutionRunsException"]], "executiontimeexception": [[21, "pathfinding3d.finder.finder.ExecutionTimeException"]], "finder (class in pathfinding3d.finder.finder)": [[21, "pathfinding3d.finder.finder.Finder"]], "__init__() (pathfinding3d.finder.finder.executionrunsexception method)": [[21, "pathfinding3d.finder.finder.ExecutionRunsException.__init__"]], "__init__() (pathfinding3d.finder.finder.executiontimeexception method)": [[21, "pathfinding3d.finder.finder.ExecutionTimeException.__init__"]], "__init__() (pathfinding3d.finder.finder.finder method)": [[21, "pathfinding3d.finder.finder.Finder.__init__"]], "apply_heuristic() (pathfinding3d.finder.finder.finder method)": [[21, "pathfinding3d.finder.finder.Finder.apply_heuristic"]], "args (pathfinding3d.finder.finder.executionrunsexception attribute)": [[21, "pathfinding3d.finder.finder.ExecutionRunsException.args"]], "args (pathfinding3d.finder.finder.executiontimeexception attribute)": [[21, "pathfinding3d.finder.finder.ExecutionTimeException.args"]], "check_neighbors() (pathfinding3d.finder.finder.finder method)": [[21, "pathfinding3d.finder.finder.Finder.check_neighbors"]], "find_neighbors() (pathfinding3d.finder.finder.finder method)": [[21, "pathfinding3d.finder.finder.Finder.find_neighbors"]], "find_path() (pathfinding3d.finder.finder.finder method)": [[21, "pathfinding3d.finder.finder.Finder.find_path"]], "keep_running() (pathfinding3d.finder.finder.finder method)": [[21, "pathfinding3d.finder.finder.Finder.keep_running"]], "pathfinding3d.finder.finder": [[21, "module-pathfinding3d.finder.finder"]], "process_node() (pathfinding3d.finder.finder.finder method)": [[21, "pathfinding3d.finder.finder.Finder.process_node"]], "with_traceback() (pathfinding3d.finder.finder.executionrunsexception method)": [[21, "pathfinding3d.finder.finder.ExecutionRunsException.with_traceback"]], "with_traceback() (pathfinding3d.finder.finder.executiontimeexception method)": [[21, "pathfinding3d.finder.finder.ExecutionTimeException.with_traceback"]], "idastarfinder (class in pathfinding3d.finder.ida_star)": [[22, "pathfinding3d.finder.ida_star.IDAStarFinder"]], "__init__() (pathfinding3d.finder.ida_star.idastarfinder method)": [[22, "pathfinding3d.finder.ida_star.IDAStarFinder.__init__"]], "apply_heuristic() (pathfinding3d.finder.ida_star.idastarfinder method)": [[22, "pathfinding3d.finder.ida_star.IDAStarFinder.apply_heuristic"]], "check_neighbors() (pathfinding3d.finder.ida_star.idastarfinder method)": [[22, "pathfinding3d.finder.ida_star.IDAStarFinder.check_neighbors"]], "find_neighbors() (pathfinding3d.finder.ida_star.idastarfinder method)": [[22, "pathfinding3d.finder.ida_star.IDAStarFinder.find_neighbors"]], "find_path() (pathfinding3d.finder.ida_star.idastarfinder method)": [[22, "pathfinding3d.finder.ida_star.IDAStarFinder.find_path"]], "keep_running() (pathfinding3d.finder.ida_star.idastarfinder method)": [[22, "pathfinding3d.finder.ida_star.IDAStarFinder.keep_running"]], "pathfinding3d.finder.ida_star": [[22, "module-pathfinding3d.finder.ida_star"]], "process_node() (pathfinding3d.finder.ida_star.idastarfinder method)": [[22, "pathfinding3d.finder.ida_star.IDAStarFinder.process_node"]], "search() (pathfinding3d.finder.ida_star.idastarfinder method)": [[22, "pathfinding3d.finder.ida_star.IDAStarFinder.search"]], "minimumspanningtree (class in pathfinding3d.finder.msp)": [[23, "pathfinding3d.finder.msp.MinimumSpanningTree"]], "__init__() (pathfinding3d.finder.msp.minimumspanningtree method)": [[23, "pathfinding3d.finder.msp.MinimumSpanningTree.__init__"]], "apply_heuristic() (pathfinding3d.finder.msp.minimumspanningtree method)": [[23, "pathfinding3d.finder.msp.MinimumSpanningTree.apply_heuristic"]], "check_neighbors() (pathfinding3d.finder.msp.minimumspanningtree method)": [[23, "pathfinding3d.finder.msp.MinimumSpanningTree.check_neighbors"]], "find_neighbors() (pathfinding3d.finder.msp.minimumspanningtree method)": [[23, "pathfinding3d.finder.msp.MinimumSpanningTree.find_neighbors"]], "find_path() (pathfinding3d.finder.msp.minimumspanningtree method)": [[23, "pathfinding3d.finder.msp.MinimumSpanningTree.find_path"]], "itertree() (pathfinding3d.finder.msp.minimumspanningtree method)": [[23, "pathfinding3d.finder.msp.MinimumSpanningTree.itertree"]], "keep_running() (pathfinding3d.finder.msp.minimumspanningtree method)": [[23, "pathfinding3d.finder.msp.MinimumSpanningTree.keep_running"]], "pathfinding3d.finder.msp": [[23, "module-pathfinding3d.finder.msp"]], "process_node() (pathfinding3d.finder.msp.minimumspanningtree method)": [[23, "pathfinding3d.finder.msp.MinimumSpanningTree.process_node"]], "tree() (pathfinding3d.finder.msp.minimumspanningtree method)": [[23, "pathfinding3d.finder.msp.MinimumSpanningTree.tree"]], "thetastarfinder (class in pathfinding3d.finder.theta_star)": [[24, "pathfinding3d.finder.theta_star.ThetaStarFinder"]], "__init__() (pathfinding3d.finder.theta_star.thetastarfinder method)": [[24, "pathfinding3d.finder.theta_star.ThetaStarFinder.__init__"]], "apply_heuristic() (pathfinding3d.finder.theta_star.thetastarfinder method)": [[24, "pathfinding3d.finder.theta_star.ThetaStarFinder.apply_heuristic"]], "check_neighbors() (pathfinding3d.finder.theta_star.thetastarfinder method)": [[24, "pathfinding3d.finder.theta_star.ThetaStarFinder.check_neighbors"]], "find_neighbors() (pathfinding3d.finder.theta_star.thetastarfinder method)": [[24, "pathfinding3d.finder.theta_star.ThetaStarFinder.find_neighbors"]], "find_path() (pathfinding3d.finder.theta_star.thetastarfinder method)": [[24, "pathfinding3d.finder.theta_star.ThetaStarFinder.find_path"]], "keep_running() (pathfinding3d.finder.theta_star.thetastarfinder method)": [[24, "pathfinding3d.finder.theta_star.ThetaStarFinder.keep_running"]], "pathfinding3d.finder.theta_star": [[24, "module-pathfinding3d.finder.theta_star"]], "process_node() (pathfinding3d.finder.theta_star.thetastarfinder method)": [[24, "pathfinding3d.finder.theta_star.ThetaStarFinder.process_node"]]}}) \ No newline at end of file