pyastar2d 1.0.5__tar.gz → 1.1.0__tar.gz

pyastar2d-1.1.0/MANIFEST.in

@@ -0,0 +1,2 @@
+include requirements.txt
+include src/cpp/experimental_heuristics.h

{pyastar2d-1.0.5 → pyastar2d-1.1.0}/PKG-INFO

@@ -1,18 +1,24 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: pyastar2d
-Version: 1.0.5
+Version: 1.1.0
 Summary: A simple implementation of the A* algorithm for path-finding on a two-dimensional grid.
 Home-page: https://github.com/hjweide/pyastar2d
 Author: Hendrik Weideman
 Author-email: hjweide@gmail.com
-License: UNKNOWN
-Platform: UNKNOWN
-Classifier: Programming Language :: Python :: 3
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Operating System :: OS Independent
-Requires-Python: >=3.7
+Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 License-File: LICENSE
+Requires-Dist: imageio
+Requires-Dist: numpy
+Dynamic: author
+Dynamic: author-email
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
 
 [![Build Status](https://travis-ci.com/hjweide/pyastar2d.svg?branch=master)](https://travis-ci.com/hjweide/pyastar2d)
 [![Coverage Status](https://coveralls.io/repos/github/hjweide/pyastar2d/badge.svg?branch=master)](https://coveralls.io/github/hjweide/pyastar2d?branch=master)
@@ -109,7 +115,7 @@ python examples/maze_solver.py --input mazes/maze_small.png --output solns/maze_
 python examples/maze_solver.py --input mazes/maze_large.png --output solns/maze_large.png
 ```
 
-### Small Maze (1802 x 1802): 
+### Small Maze (1802 x 1802):
 ```bash
 time python examples/maze_solver.py --input mazes/maze_small.png --output solns/maze_small.png
 Loaded maze of shape (1802, 1802) from mazes/maze_small.png
@@ -124,7 +130,7 @@ sys	0m0.606s
 The solution found for the small maze is shown below:
 <img src="https://github.com/hjweide/pyastar2d/raw/master/solns/maze_small_soln.png" alt="Maze Small Solution" style="width: 100%"/>
 
-### Large Maze (4002 x 4002): 
+### Large Maze (4002 x 4002):
 ```bash
 time python examples/maze_solver.py --input mazes/maze_large.png --output solns/maze_large.png
 Loaded maze of shape (4002, 4002) from mazes/maze_large.png
@@ -164,14 +170,34 @@ pip install -r requirements-dev.txt
 ```
 before running
 ```bash
-py.test
+pytest
 ```
 The tests are fairly basic but cover some of the
 more common pitfalls.  Pull requests for more extensive tests are welcome.
 
-## References
-1. [A\* search algorithm on Wikipedia](https://en.wikipedia.org/wiki/A*_search_algorithm#Pseudocode)
-2. [Pathfinding with A* on Red Blob Games](http://www.redblobgames.com/pathfinding/a-star/introduction.html)
+## Code Formatting
 
+It's recommended that you use `pre-commit` to ensure linting procedures are
+run on any code you write.  See [pre-commit.com](https://pre-commit.com/) for
+more information.
 
+Reference [pre-commit's installation instructions](https://pre-commit.com/#install)
+for software installation on your OS/platform. After you have the software
+installed, run `pre-commit install` on the command line. Now every time you commit
+to this project's code base the linter procedures will automatically run over the
+changed files.  To run pre-commit on files preemtively from the command line use:
 
+```bash
+pip install -r requirements-dev.txt
+pre-commit run --all-files
+```
+
+The code base has been formatted by [Black](https://black.readthedocs.io/en/stable/).
+Furthermore, try to conform to `PEP8`.  You should set up your preferred editor to
+use `flake8` as its Python linter, but pre-commit will ensure compliance before a
+git commit is completed.  This will use the `flake8` configuration within
+`.flake8`, which ignores several errors and stylistic considerations.
+
+## References
+1. [A\* search algorithm on Wikipedia](https://en.wikipedia.org/wiki/A*_search_algorithm#Pseudocode)
+2. [Pathfinding with A* on Red Blob Games](http://www.redblobgames.com/pathfinding/a-star/introduction.html)

pyastar2d-1.0.5/src/pyastar2d.egg-info/PKG-INFO → pyastar2d-1.1.0/README.md

@@ -1,19 +1,3 @@
-Metadata-Version: 2.1
-Name: pyastar2d
-Version: 1.0.5
-Summary: A simple implementation of the A* algorithm for path-finding on a two-dimensional grid.
-Home-page: https://github.com/hjweide/pyastar2d
-Author: Hendrik Weideman
-Author-email: hjweide@gmail.com
-License: UNKNOWN
-Platform: UNKNOWN
-Classifier: Programming Language :: Python :: 3
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Operating System :: OS Independent
-Requires-Python: >=3.7
-Description-Content-Type: text/markdown
-License-File: LICENSE
-
 [![Build Status](https://travis-ci.com/hjweide/pyastar2d.svg?branch=master)](https://travis-ci.com/hjweide/pyastar2d)
 [![Coverage Status](https://coveralls.io/repos/github/hjweide/pyastar2d/badge.svg?branch=master)](https://coveralls.io/github/hjweide/pyastar2d?branch=master)
 [![PyPI version](https://badge.fury.io/py/pyastar2d.svg)](https://badge.fury.io/py/pyastar2d)
@@ -109,7 +93,7 @@ python examples/maze_solver.py --input mazes/maze_small.png --output solns/maze_
 python examples/maze_solver.py --input mazes/maze_large.png --output solns/maze_large.png
 ```
 
-### Small Maze (1802 x 1802): 
+### Small Maze (1802 x 1802):
 ```bash
 time python examples/maze_solver.py --input mazes/maze_small.png --output solns/maze_small.png
 Loaded maze of shape (1802, 1802) from mazes/maze_small.png
@@ -124,7 +108,7 @@ sys	0m0.606s
 The solution found for the small maze is shown below:
 <img src="https://github.com/hjweide/pyastar2d/raw/master/solns/maze_small_soln.png" alt="Maze Small Solution" style="width: 100%"/>
 
-### Large Maze (4002 x 4002): 
+### Large Maze (4002 x 4002):
 ```bash
 time python examples/maze_solver.py --input mazes/maze_large.png --output solns/maze_large.png
 Loaded maze of shape (4002, 4002) from mazes/maze_large.png
@@ -164,14 +148,34 @@ pip install -r requirements-dev.txt
 ```
 before running
 ```bash
-py.test
+pytest
 ```
 The tests are fairly basic but cover some of the
 more common pitfalls.  Pull requests for more extensive tests are welcome.
 
-## References
-1. [A\* search algorithm on Wikipedia](https://en.wikipedia.org/wiki/A*_search_algorithm#Pseudocode)
-2. [Pathfinding with A* on Red Blob Games](http://www.redblobgames.com/pathfinding/a-star/introduction.html)
+## Code Formatting
+
+It's recommended that you use `pre-commit` to ensure linting procedures are
+run on any code you write.  See [pre-commit.com](https://pre-commit.com/) for
+more information.
+
+Reference [pre-commit's installation instructions](https://pre-commit.com/#install)
+for software installation on your OS/platform. After you have the software
+installed, run `pre-commit install` on the command line. Now every time you commit
+to this project's code base the linter procedures will automatically run over the
+changed files.  To run pre-commit on files preemtively from the command line use:
 
+```bash
+pip install -r requirements-dev.txt
+pre-commit run --all-files
+```
 
+The code base has been formatted by [Black](https://black.readthedocs.io/en/stable/).
+Furthermore, try to conform to `PEP8`.  You should set up your preferred editor to
+use `flake8` as its Python linter, but pre-commit will ensure compliance before a
+git commit is completed.  This will use the `flake8` configuration within
+`.flake8`, which ignores several errors and stylistic considerations.
 
+## References
+1. [A\* search algorithm on Wikipedia](https://en.wikipedia.org/wiki/A*_search_algorithm#Pseudocode)
+2. [Pathfinding with A* on Red Blob Games](http://www.redblobgames.com/pathfinding/a-star/introduction.html)

pyastar2d-1.1.0/pyproject.toml

@@ -0,0 +1,3 @@
+[build-system]
+requires = ["setuptools>=64", "wheel", "numpy"]
+build-backend = "setuptools.build_meta"

pyastar2d-1.1.0/setup.cfg

@@ -0,0 +1,16 @@
+[flake8]
+exclude = .git
+
+[tool:isort]
+profile = black
+line_length = 90
+multi_line_output = 3
+include_trailing_comma = true
+force_grid_wrap = 0
+use_parentheses = true
+ensure_newline_before_comments = true
+
+[egg_info]
+tag_build = 
+tag_date = 0
+

pyastar2d-1.1.0/setup.py

@@ -0,0 +1,58 @@
+import pathlib
+
+from setuptools import Extension, find_packages, setup
+
+# Use pathlib for paths
+here = pathlib.Path(__file__).parent.resolve()
+
+# Read README and requirements
+long_description = (here / 'README.md').read_text(encoding='utf-8')
+install_requires = (here / 'requirements.txt').read_text().splitlines()
+
+
+class get_numpy_include:
+    """Defer numpy import until it is actually installed."""
+
+    def __str__(self):
+        import numpy
+
+        return numpy.get_include()
+
+
+# Define the C++ extension
+astar_module = Extension(
+    name='pyastar2d.astar',
+    sources=[
+        'src/cpp/astar.cpp',
+        'src/cpp/experimental_heuristics.cpp',
+    ],
+    define_macros=[
+        ('Py_LIMITED_API', '0x03080000'),
+        ('NPY_NO_DEPRECATED_API', 'NPY_1_7_API_VERSION'),
+    ],
+    py_limited_api=True,
+    include_dirs=[
+        'src/cpp',
+        get_numpy_include(),
+    ],
+    extra_compile_args=['-O3', '-fpic', '-Wall'],
+    language='c++',
+)
+
+# Define package metadata
+setup(
+    name='pyastar2d',
+    version='1.1.0',
+    author='Hendrik Weideman',
+    author_email='hjweide@gmail.com',
+    description='A simple implementation of the A* algorithm for path-finding on a two-dimensional grid.',
+    long_description=long_description,
+    long_description_content_type='text/markdown',
+    url='https://github.com/hjweide/pyastar2d',
+    packages=find_packages(where='src', exclude=('tests',)),
+    package_dir={'': 'src'},
+    install_requires=install_requires,
+    python_requires='>=3.8',
+    ext_modules=[astar_module],
+    options={'bdist_wheel': {'py_limited_api': 'cp38'}},
+)

{pyastar2d-1.0.5 → pyastar2d-1.1.0}/src/cpp/astar.cpp

@@ -2,6 +2,7 @@
 #include <limits>
 #include <cmath>
 #include <Python.h>
+#define NPY_NO_DEPRECATED_API NPY_1_7_API_VERSION
 #include <numpy/arrayobject.h>
 #include <iostream>
 #include <experimental_heuristics.h>
@@ -44,7 +45,7 @@ inline float l1_norm(int i0, int j0, int i1, int j1) {
 // diag_ok:        if true, allows diagonal moves (8-conn.)
 // paths (output): for each node, stores previous node in path
 static PyObject *astar(PyObject *self, PyObject *args) {
-  const PyArrayObject* weights_object;
+  PyArrayObject* weights_object;
   int h;
   int w;
   int start;
@@ -61,7 +62,7 @@ static PyObject *astar(PyObject *self, PyObject *args) {
         ))
     return NULL;
 
-  float* weights = (float*) weights_object->data;
+  float* weights = (float*) PyArray_DATA(weights_object);
   int* paths = new int[h * w];
   int path_length = -1;
 
@@ -76,7 +77,7 @@ static PyObject *astar(PyObject *self, PyObject *args) {
   nodes_to_visit.push(start_node);
 
   int* nbrs = new int[8];
-  
+
   int goal_i = goal / w;
   int goal_j = goal % w;
   int start_i = start / w;
@@ -141,11 +142,13 @@ static PyObject *astar(PyObject *self, PyObject *args) {
   if (path_length >= 0) {
     npy_intp dims[2] = {path_length, 2};
     PyArrayObject* path = (PyArrayObject*) PyArray_SimpleNew(2, dims, NPY_INT32);
+    char* data = (char*) PyArray_BYTES(path);
+    npy_intp* strides = PyArray_STRIDES(path);
     npy_int32 *iptr, *jptr;
     int idx = goal;
     for (npy_intp i = dims[0] - 1; i >= 0; --i) {
-        iptr = (npy_int32*) (path->data + i * path->strides[0]);
-        jptr = (npy_int32*) (path->data + i * path->strides[0] + path->strides[1]);
+        iptr = (npy_int32*) (data + i * strides[0]);
+        jptr = (npy_int32*) (data + i * strides[0] + strides[1]);
 
         *iptr = idx / w;
         *jptr = idx % w;

pyastar2d-1.1.0/src/cpp/experimental_heuristics.h

@@ -0,0 +1,20 @@
+// Please note below heuristics are experimental and only for pretty lines.
+// They may not take the shortest path and require additional cpu cycles.
+
+#ifndef EXPERIMENTAL_HEURISTICS_H_
+#define EXPERIMENTAL_HEURISTICS_H_
+
+
+enum Heuristic { DEFAULT, ORTHOGONAL_X, ORTHOGONAL_Y };
+
+typedef float (*heuristic_ptr)(int, int, int, int, int, int);
+
+heuristic_ptr select_heuristic(int);
+
+// Orthogonal x (moves by x first, then half way by y)
+float orthogonal_x(int, int, int, int, int, int);
+
+// Orthogonal y (moves by y first, then half way by x)
+float orthogonal_y(int, int, int, int, int, int);
+
+#endif

pyastar2d-1.1.0/src/pyastar2d/__init__.py

@@ -0,0 +1,3 @@
+from pyastar2d.astar_wrapper import Heuristic, astar_path
+
+__all__ = ['astar_path', 'Heuristic']

pyastar2d-1.1.0/src/pyastar2d/astar_wrapper.py

@@ -0,0 +1,77 @@
+import ctypes
+from enum import IntEnum
+from typing import Optional, Tuple
+
+import numpy as np
+
+import pyastar2d.astar
+
+# Define array types
+ndmat_f_type = np.ctypeslib.ndpointer(dtype=np.float32, ndim=1, flags='C_CONTIGUOUS')
+ndmat_i2_type = np.ctypeslib.ndpointer(dtype=np.int32, ndim=2, flags='C_CONTIGUOUS')
+
+# Define input/output types
+pyastar2d.astar.restype = ndmat_i2_type  # Nx2 (i, j) coordinates or None
+pyastar2d.astar.argtypes = [
+    ndmat_f_type,  # weights
+    ctypes.c_int,  # height
+    ctypes.c_int,  # width
+    ctypes.c_int,  # start index in flattened grid
+    ctypes.c_int,  # goal index in flattened grid
+    ctypes.c_bool,  # allow diagonal
+    ctypes.c_int,  # heuristic_override
+]
+
+
+class Heuristic(IntEnum):
+    """The supported heuristics."""
+
+    DEFAULT = 0
+    ORTHOGONAL_X = 1
+    ORTHOGONAL_Y = 2
+
+
+def astar_path(
+    weights: np.ndarray,
+    start: Tuple[int, int],
+    goal: Tuple[int, int],
+    allow_diagonal: bool = False,
+    heuristic_override: Heuristic = Heuristic.DEFAULT,
+) -> Optional[np.ndarray]:
+    """
+    Run astar algorithm on 2d weights.
+
+    param np.ndarray weights: A grid of weights e.g. np.ones((10, 10), dtype=np.float32)
+    param Tuple[int, int] start: (i, j)
+    param Tuple[int, int] goal: (i, j)
+    param bool allow_diagonal: Whether to allow diagonal moves
+    param Heuristic heuristic_override: Override heuristic, see Heuristic(IntEnum)
+
+    """
+    assert (
+        weights.dtype == np.float32
+    ), f'weights must have np.float32 data type, but has {weights.dtype}'
+    # For the heuristic to be valid, each move must cost at least 1.
+    if weights.min(axis=None) < 1.0:
+        raise ValueError('Minimum cost to move must be 1, but got %f' % (weights.min(axis=None)))
+    # Ensure start is within bounds.
+    if start[0] < 0 or start[0] >= weights.shape[0] or start[1] < 0 or start[1] >= weights.shape[1]:
+        raise ValueError(f'Start of {start} lies outside grid.')
+    # Ensure goal is within bounds.
+    if goal[0] < 0 or goal[0] >= weights.shape[0] or goal[1] < 0 or goal[1] >= weights.shape[1]:
+        raise ValueError(f'Goal of {goal} lies outside grid.')
+
+    height, width = weights.shape
+    start_idx = np.ravel_multi_index(start, (height, width))
+    goal_idx = np.ravel_multi_index(goal, (height, width))
+
+    path = pyastar2d.astar.astar(
+        weights.flatten(),
+        height,
+        width,
+        start_idx,
+        goal_idx,
+        allow_diagonal,
+        int(heuristic_override),
+    )
+    return path

pyastar2d-1.0.5/README.md → pyastar2d-1.1.0/src/pyastar2d.egg-info/PKG-INFO

@@ -1,3 +1,25 @@
+Metadata-Version: 2.4
+Name: pyastar2d
+Version: 1.1.0
+Summary: A simple implementation of the A* algorithm for path-finding on a two-dimensional grid.
+Home-page: https://github.com/hjweide/pyastar2d
+Author: Hendrik Weideman
+Author-email: hjweide@gmail.com
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: imageio
+Requires-Dist: numpy
+Dynamic: author
+Dynamic: author-email
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
 [![Build Status](https://travis-ci.com/hjweide/pyastar2d.svg?branch=master)](https://travis-ci.com/hjweide/pyastar2d)
 [![Coverage Status](https://coveralls.io/repos/github/hjweide/pyastar2d/badge.svg?branch=master)](https://coveralls.io/github/hjweide/pyastar2d?branch=master)
 [![PyPI version](https://badge.fury.io/py/pyastar2d.svg)](https://badge.fury.io/py/pyastar2d)
@@ -93,7 +115,7 @@ python examples/maze_solver.py --input mazes/maze_small.png --output solns/maze_
 python examples/maze_solver.py --input mazes/maze_large.png --output solns/maze_large.png
 ```
 
-### Small Maze (1802 x 1802): 
+### Small Maze (1802 x 1802):
 ```bash
 time python examples/maze_solver.py --input mazes/maze_small.png --output solns/maze_small.png
 Loaded maze of shape (1802, 1802) from mazes/maze_small.png
@@ -108,7 +130,7 @@ sys	0m0.606s
 The solution found for the small maze is shown below:
 <img src="https://github.com/hjweide/pyastar2d/raw/master/solns/maze_small_soln.png" alt="Maze Small Solution" style="width: 100%"/>
 
-### Large Maze (4002 x 4002): 
+### Large Maze (4002 x 4002):
 ```bash
 time python examples/maze_solver.py --input mazes/maze_large.png --output solns/maze_large.png
 Loaded maze of shape (4002, 4002) from mazes/maze_large.png
@@ -148,12 +170,34 @@ pip install -r requirements-dev.txt
 ```
 before running
 ```bash
-py.test
+pytest
 ```
 The tests are fairly basic but cover some of the
 more common pitfalls.  Pull requests for more extensive tests are welcome.
 
+## Code Formatting
+
+It's recommended that you use `pre-commit` to ensure linting procedures are
+run on any code you write.  See [pre-commit.com](https://pre-commit.com/) for
+more information.
+
+Reference [pre-commit's installation instructions](https://pre-commit.com/#install)
+for software installation on your OS/platform. After you have the software
+installed, run `pre-commit install` on the command line. Now every time you commit
+to this project's code base the linter procedures will automatically run over the
+changed files.  To run pre-commit on files preemtively from the command line use:
+
+```bash
+pip install -r requirements-dev.txt
+pre-commit run --all-files
+```
+
+The code base has been formatted by [Black](https://black.readthedocs.io/en/stable/).
+Furthermore, try to conform to `PEP8`.  You should set up your preferred editor to
+use `flake8` as its Python linter, but pre-commit will ensure compliance before a
+git commit is completed.  This will use the `flake8` configuration within
+`.flake8`, which ignores several errors and stylistic considerations.
+
 ## References
 1. [A\* search algorithm on Wikipedia](https://en.wikipedia.org/wiki/A*_search_algorithm#Pseudocode)
 2. [Pathfinding with A* on Red Blob Games](http://www.redblobgames.com/pathfinding/a-star/introduction.html)
-

{pyastar2d-1.0.5 → pyastar2d-1.1.0}/src/pyastar2d.egg-info/SOURCES.txt

@@ -1,14 +1,18 @@
 LICENSE
 MANIFEST.in
 README.md
+pyproject.toml
 requirements.txt
+setup.cfg
 setup.py
 src/cpp/astar.cpp
 src/cpp/experimental_heuristics.cpp
+src/cpp/experimental_heuristics.h
 src/pyastar2d/__init__.py
 src/pyastar2d/astar_wrapper.py
 src/pyastar2d.egg-info/PKG-INFO
 src/pyastar2d.egg-info/SOURCES.txt
 src/pyastar2d.egg-info/dependency_links.txt
 src/pyastar2d.egg-info/requires.txt
-src/pyastar2d.egg-info/top_level.txt
+src/pyastar2d.egg-info/top_level.txt
+tests/test_astar.py

pyastar2d-1.1.0/tests/test_astar.py

@@ -0,0 +1,156 @@
+import numpy as np
+import pytest
+
+import pyastar2d
+from pyastar2d import Heuristic
+
+
+def test_small():
+    weights = np.array(
+        [
+            [1, 3, 3, 3, 3],
+            [2, 1, 3, 3, 3],
+            [2, 2, 1, 3, 3],
+            [2, 2, 2, 1, 3],
+            [2, 2, 2, 2, 1],
+        ],
+        dtype=np.float32,
+    )
+    # Run down the diagonal.
+    path = pyastar2d.astar_path(weights, (0, 0), (4, 4), allow_diagonal=True)
+    expected = np.array([[0, 0], [1, 1], [2, 2], [3, 3], [4, 4]])
+
+    assert np.all(path == expected)
+
+    # Down, right, down, right, etc.
+    path = pyastar2d.astar_path(weights, (0, 0), (4, 4), allow_diagonal=False)
+    expected = np.array([[0, 0], [1, 0], [1, 1], [2, 1], [2, 2], [3, 2], [3, 3], [4, 3], [4, 4]])
+
+    assert np.all(path == expected)
+
+
+def test_no_solution():
+    # Vertical wall.
+    weights = np.ones((5, 5), dtype=np.float32)
+    weights[:, 2] = np.inf
+
+    path = pyastar2d.astar_path(weights, (0, 0), (4, 4), allow_diagonal=True)
+    assert not path
+
+    # Horizontal wall.
+    weights = np.ones((5, 5), dtype=np.float32)
+    weights[2, :] = np.inf
+
+    path = pyastar2d.astar_path(weights, (0, 0), (4, 4), allow_diagonal=True)
+    assert not path
+
+
+def test_match_reverse():
+    # Might fail if there are multiple paths, but this should be rare.
+    h, w = 25, 25
+    weights = (1.0 + 5.0 * np.random.random((h, w))).astype(np.float32)
+
+    fwd = pyastar2d.astar_path(weights, (0, 0), (h - 1, w - 1))
+    rev = pyastar2d.astar_path(weights, (h - 1, w - 1), (0, 0))
+
+    assert np.all(fwd[::-1] == rev)
+
+    fwd = pyastar2d.astar_path(weights, (0, 0), (h - 1, w - 1), allow_diagonal=True)
+    rev = pyastar2d.astar_path(weights, (h - 1, w - 1), (0, 0), allow_diagonal=True)
+
+    assert np.all(fwd[::-1] == rev)
+
+
+def test_narrow():
+    # Column weights.
+    weights = np.ones((5, 1), dtype=np.float32)
+    path = pyastar2d.astar_path(weights, (0, 0), (4, 0))
+
+    expected = np.array([[0, 0], [1, 0], [2, 0], [3, 0], [4, 0]])
+
+    assert np.all(path == expected)
+
+    # Row weights.
+    weights = np.ones((1, 5), dtype=np.float32)
+    path = pyastar2d.astar_path(weights, (0, 0), (0, 4))
+
+    expected = np.array([[0, 0], [0, 1], [0, 2], [0, 3], [0, 4]])
+
+    assert np.all(path == expected)
+
+
+def test_bad_heuristic():
+    # For valid heuristics, the cost to move must be at least 1.
+    weights = (1.0 + 5.0 * np.random.random((10, 10))).astype(np.float32)
+    # An element smaller than 1 should raise a ValueError.
+    bad_cost = np.random.random() / 2.0
+    weights[4, 4] = bad_cost
+
+    with pytest.raises(ValueError) as exc:
+        pyastar2d.astar_path(weights, (0, 0), (9, 9))
+        assert '.f' % bad_cost in exc.value.args[0]
+
+
+def test_invalid_start_and_goal():
+    weights = (1.0 + 5.0 * np.random.random((10, 10))).astype(np.float32)
+    # Test bad start indices.
+    with pytest.raises(ValueError) as exc:
+        pyastar2d.astar_path(weights, (-1, 0), (9, 9))
+        assert '-1' in exc.value.args[0]
+    with pytest.raises(ValueError) as exc:
+        pyastar2d.astar_path(weights, (10, 0), (9, 9))
+        assert '10' in exc.value.args[0]
+    with pytest.raises(ValueError) as exc:
+        pyastar2d.astar_path(weights, (0, -1), (9, 9))
+        assert '-1' in exc.value.args[0]
+    with pytest.raises(ValueError) as exc:
+        pyastar2d.astar_path(weights, (0, 10), (9, 9))
+        assert '10' in exc.value.args[0]
+    # Test bad goal indices.
+    with pytest.raises(ValueError) as exc:
+        pyastar2d.astar_path(weights, (0, 0), (-1, 9))
+        assert '-1' in exc.value.args[0]
+    with pytest.raises(ValueError) as exc:
+        pyastar2d.astar_path(weights, (0, 0), (10, 9))
+        assert '10' in exc.value.args[0]
+    with pytest.raises(ValueError) as exc:
+        pyastar2d.astar_path(weights, (0, 0), (0, -1))
+        assert '-1' in exc.value.args[0]
+    with pytest.raises(ValueError) as exc:
+        pyastar2d.astar_path(weights, (0, 0), (0, 10))
+        assert '10' in exc.value.args[0]
+
+
+def test_bad_weights_dtype():
+    weights = np.array([[1, 2, 3], [1, 2, 3], [1, 2, 3]], dtype=np.float64)
+    with pytest.raises(AssertionError) as exc:
+        pyastar2d.astar_path(weights, (0, 0), (2, 2))
+    assert 'float64' in exc.value.args[0]
+
+
+def test_orthogonal_x():
+    weights = np.ones((5, 5), dtype=np.float32)
+    path = pyastar2d.astar_path(
+        weights,
+        (0, 0),
+        (4, 4),
+        allow_diagonal=False,
+        heuristic_override=Heuristic.ORTHOGONAL_X,
+    )
+    expected = np.array([[0, 0], [1, 0], [2, 0], [2, 1], [2, 2], [2, 3], [2, 4], [3, 4], [4, 4]])
+
+    assert np.all(path == expected)
+
+
+def test_orthogonal_y():
+    weights = np.ones((5, 5), dtype=np.float32)
+    path = pyastar2d.astar_path(
+        weights,
+        (0, 0),
+        (4, 4),
+        allow_diagonal=False,
+        heuristic_override=Heuristic.ORTHOGONAL_Y,
+    )
+    expected = np.array([[0, 0], [0, 1], [0, 2], [1, 2], [2, 2], [3, 2], [4, 2], [4, 3], [4, 4]])
+
+    assert np.all(path == expected)

pyastar2d-1.0.5/MANIFEST.in

@@ -1 +0,0 @@
-include requirements.txt

pyastar2d-1.0.5/setup.cfg

@@ -1,4 +0,0 @@
-[egg_info]
-tag_build = 
-tag_date = 0
-

pyastar2d-1.0.5/setup.py

@@ -1,44 +0,0 @@
-import setuptools
-from distutils.core import Extension
-from setuptools import dist
-dist.Distribution().fetch_build_eggs(["numpy"])
-import numpy
-
-astar_module = Extension(
-    'pyastar2d.astar', sources=['src/cpp/astar.cpp', 'src/cpp/experimental_heuristics.cpp'],
-    include_dirs=[
-                    numpy.get_include(),   # for numpy/arrayobject.h
-                    'src/cpp'    # for experimental_heuristics.h
-                 ],
-    extra_compile_args=["-O3", "-Wall", "-shared", "-fpic"],
-)
-
-
-with open("requirements.txt", "r") as fh:
-    install_requires = fh.readlines()
-
-with open("README.md", "r") as fh:
-    long_description = fh.read()
-
-setuptools.setup(
-    name="pyastar2d",
-    version="1.0.5",
-    author="Hendrik Weideman",
-    author_email="hjweide@gmail.com",
-    description=(
-        "A simple implementation of the A* algorithm for "
-        "path-finding on a two-dimensional grid."),
-    long_description=long_description,
-    long_description_content_type="text/markdown",
-    url="https://github.com/hjweide/pyastar2d",
-    install_requires=install_requires,
-    packages=setuptools.find_packages(where="src", exclude=("tests",)),
-    package_dir={"": "src"},
-    ext_modules=[astar_module],
-    classifiers=[
-        "Programming Language :: Python :: 3",
-        "License :: OSI Approved :: MIT License",
-        "Operating System :: OS Independent",
-    ],
-    python_requires='>=3.7',
-)

pyastar2d-1.0.5/src/pyastar2d/__init__.py

@@ -1,2 +0,0 @@
-from pyastar2d.astar_wrapper import astar_path, Heuristic
-__all__ = ["astar_path", "Heuristic"]

pyastar2d-1.0.5/src/pyastar2d/astar_wrapper.py

@@ -1,73 +0,0 @@
-import ctypes
-import numpy as np
-import pyastar2d.astar
-from enum import IntEnum
-from typing import Optional, Tuple
-
-
-# Define array types
-ndmat_f_type = np.ctypeslib.ndpointer(
-    dtype=np.float32, ndim=1, flags="C_CONTIGUOUS")
-ndmat_i2_type = np.ctypeslib.ndpointer(
-    dtype=np.int32, ndim=2, flags="C_CONTIGUOUS")
-
-# Define input/output types
-pyastar2d.astar.restype = ndmat_i2_type  # Nx2 (i, j) coordinates or None
-pyastar2d.astar.argtypes = [
-    ndmat_f_type,   # weights
-    ctypes.c_int,   # height
-    ctypes.c_int,   # width
-    ctypes.c_int,   # start index in flattened grid
-    ctypes.c_int,   # goal index in flattened grid
-    ctypes.c_bool,  # allow diagonal
-    ctypes.c_int,   # heuristic_override
-]
-
-class Heuristic(IntEnum):
-    """The supported heuristics."""
-
-    DEFAULT = 0
-    ORTHOGONAL_X = 1
-    ORTHOGONAL_Y = 2
-
-def astar_path(
-        weights: np.ndarray,
-        start: Tuple[int, int],
-        goal: Tuple[int, int],
-        allow_diagonal: bool = False,
-        heuristic_override: Heuristic = Heuristic.DEFAULT) -> Optional[np.ndarray]:
-    """
-    Run astar algorithm on 2d weights.
-
-    param np.ndarray weights: A grid of weights e.g. np.ones((10, 10), dtype=np.float32)
-    param Tuple[int, int] start: (i, j)
-    param Tuple[int, int] goal: (i, j)
-    param bool allow_diagonal: Whether to allow diagonal moves
-    param Heuristic heuristic_override: Override heuristic, see Heuristic(IntEnum)
-
-    """
-    assert weights.dtype == np.float32, (
-        f"weights must have np.float32 data type, but has {weights.dtype}"
-    )
-    # For the heuristic to be valid, each move must cost at least 1.
-    if weights.min(axis=None) < 1.:
-        raise ValueError("Minimum cost to move must be 1, but got %f" % (
-            weights.min(axis=None)))
-    # Ensure start is within bounds.
-    if (start[0] < 0 or start[0] >= weights.shape[0] or
-            start[1] < 0 or start[1] >= weights.shape[1]):
-        raise ValueError(f"Start of {start} lies outside grid.")
-    # Ensure goal is within bounds.
-    if (goal[0] < 0 or goal[0] >= weights.shape[0] or
-            goal[1] < 0 or goal[1] >= weights.shape[1]):
-        raise ValueError(f"Goal of {goal} lies outside grid.")
-
-    height, width = weights.shape
-    start_idx = np.ravel_multi_index(start, (height, width))
-    goal_idx = np.ravel_multi_index(goal, (height, width))
-
-    path = pyastar2d.astar.astar(
-        weights.flatten(), height, width, start_idx, goal_idx, allow_diagonal,
-        int(heuristic_override)
-    )
-    return path