First complete version

Author: abey79

.github/workflows/python-lint-tests.yml

@@ -0,0 +1,75 @@
+name: Lint and Tests
+
+on:
+  push:
+    branches:
+      - master
+      - release/*
+  pull_request:
+    branches:
+      - master
+      - release/*
+
+jobs:
+
+  ###########
+  # LINTING #
+  ###########
+  linting:
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v2
+    - name: Set up Python
+      uses: actions/setup-python@v2
+      with:
+        python-version: 3.9
+    # Cache pip
+    - uses: actions/cache@v2
+      with:
+        path: ~/.cache/pip
+        key: ${{ runner.os }}-pip
+        restore-keys: ${{ runner.os }}-pip
+    - name: Install dependencies
+      run: |
+        python -m pip install --upgrade pip
+        python -m pip install mypy black isort
+    - name: Python Code Quality and Lint
+      uses: abey79/python-lint@master
+      with:
+        python-root-list: "vnoise tests"
+        use-pylint: false
+        use-pycodestyle: false
+        use-flake8: false
+        use-black: true
+        extra-black-options: --diff
+        use-mypy: true
+        use-isort: true
+
+  #########
+  # TESTS #
+  #########
+  tests:
+    needs: linting
+    strategy:
+      fail-fast: true
+      matrix:
+        python-version: [3.7, 3.8, 3.9]
+        os: [ubuntu-latest, macos-latest, windows-latest]
+    defaults:
+      run:
+        shell: bash
+    runs-on: ${{ matrix.os }}
+
+    steps:
+    - uses: actions/checkout@v2
+    - name: Set up Python ${{ matrix.python-version }}
+      uses: actions/setup-python@v2
+      with:
+        python-version: ${{ matrix.python-version }}
+    - name: Install dependencies
+      run: |
+        pip install .
+        pip install -r dev-requirements.txt
+    - name: Pytest
+      run: |
+        pytest

LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2021 Antoine Beyeler, David Olsen
+Copyright (c) 2021 Antoine Beyeler, Tatarize
 Copyright (c) 2008 Casey Duncan
 
 Permission is hereby granted, free of charge, to any person obtaining a copy

README.md

@@ -1,3 +1,84 @@
-# vnoise
+# *vnoise*
 
-Vectorized, pure-Python Perlin noise library.
+*vnoise* is a pure-Python, Numpy-based, vectorized port of the [*noise*](https://github.com/caseman/noise) library. It
+currently implements the Perlin noise functions in 1D, 2D and 3D version (*noise* also implements simplex noise).
+
+## Why?
+
+*vnoise* was started because the original *noise* library is no longer supported and binaries for recent versions of
+Python are unavailable, making it hard to install for non-technical users. *vnoise* does not suffer from the same issue
+since it is written in pure Python.
+
+## Is *vnoise* slow?
+
+For scalar input (e.g. when computing noise values one at a time), yes (~300-2000x slower depending on the conditions).
+
+*vnoise* deals with this by offering a vectorized API to compute large numbers of noise values in a single call. Since is
+uses Numpy internally, its performance can match or exceed the original library (0.3-4x faster depending on the conditions).
+
+## Installing
+
+```
+$ pip install vnoise
+```
+
+## Using *vnoise*
+
+Basic example:
+
+```python
+>>> import vnoise
+>>> noise = vnoise.Noise()
+>>> noise.noise1(0.5)
+0.0
+>>> noise.noise1(0.1)
+0.09144000000000001
+>>> noise.noise2(0.1, 0.3)
+0.09046282464000001
+>>> noise.noise3(0.1, 0.3, 0.7)
+0.27788822071249925
+```
+
+The `noiseX()` functions also accept sequences as arguments:
+
+```python
+>>> import numpy as np
+>>> noise.noise2([0.1, 0.2, 0.3], np.linspace(0.5, 0.8, 10), grid_mode=True)
+array([[0.0893    , 0.08919374, 0.08912713, 0.08910291, 0.08912241,
+        0.08918551, 0.08929079, 0.08943552, 0.08961588, 0.08982716],
+       [0.1276    , 0.126881  , 0.12643032, 0.12626645, 0.12639833,
+        0.12682535, 0.12753768, 0.12851697, 0.12973738, 0.13116695],
+       [0.09615   , 0.09412557, 0.09285663, 0.09239525, 0.09276657,
+        0.09396889, 0.09597453, 0.09873182, 0.10216802, 0.10619312]])
+```
+
+With `grid_mode=True` (default value), a noise value is computed for every combination of the input value. In this case, the length of 
+the first input is 3, and the length of the second input is 10. The result is an array with shape `(3, 10)`.
+
+If `grid_mode=False`, all the input must have the same length, and the result has the same shape: 
+
+```python
+>>> noise.noise2(np.linspace(0.1, 0.3, 30), np.linspace(10, 10.5, 30), grid_mode=False)
+array([0.099144  , 0.12303124, 0.14685425, 0.17057388, 0.194133  ,
+       0.21745892, 0.24046583, 0.26305716, 0.28512793, 0.30656706,
+       0.32725957, 0.34708877, 0.36593838, 0.38369451, 0.40024759,
+       0.41549419, 0.42933872, 0.44169499, 0.45248762, 0.46165335,
+       0.46914216, 0.4749182 , 0.47896062, 0.48126415, 0.48183955,
+       0.4807138 , 0.47793023, 0.47354831, 0.46764335, 0.460306  ])
+```
+
+A seed value can be specified when creating the `Noise` class or afterward using the `seed()` function:
+
+```python
+>>> noise = vnoise.Noise(4)
+>>> noise.seed(5)
+```
+
+## License
+
+This code is available under the MIT license, see [LICENSE](LICENSE).
+
+
+## Acknowledgments
+
+This code is based on Casey Duncan's [noise](https://github.com/caseman/noise) library. The port was done with the help of [@tatarize](https://github.com/tatarize)

mypy.ini

@@ -0,0 +1,6 @@
+[mypy]
+ignore_missing_imports = True
+allow_redefinition = True
+disallow_incomplete_defs = True
+files = vnoise,tests
+

setup.py

@@ -8,7 +8,7 @@
 
 setup(
     name="vnoise",
-    version="0.1.0",
+    version="0.1.0a0",
     description="Vectorized, pure-Python Perlin noise library",
     long_description=readme,
     long_description_content_type="text/markdown",
@@ -17,7 +17,9 @@
     url="https://github.com/vpype/vnoise",
     license=license_file,
     packages=["vnoise"],
+    python_requires=">=3.6",
     install_requires=[
-        "numpy>=1.20.0",
+        "numpy>=1.19",
+        "setuptools",
     ],
 )

tests/conftest.py

@@ -0,0 +1,7 @@
+import pytest
+from vnoise import Noise
+
+
+@pytest.fixture(scope="module")
+def noise():
+    return Noise()

tests/test_noise.py

@@ -0,0 +1,83 @@
+from numbers import Number
+
+import numpy as np
+import pytest
+from vnoise import Noise
+
+
+def test_noise1_dimensions(noise):
+    assert isinstance(noise.noise1(1.5), float)
+    assert noise.noise1([1]).shape == (1,)
+    assert noise.noise1([1, 3, 4]).shape == (3,)
+
+
+def test_noise2_dimensions(noise):
+    # scalar
+    assert isinstance(noise.noise2(1.5, 1.0, grid_mode=True), float)
+    assert isinstance(noise.noise2(1.5, 1.0, grid_mode=False), float)
+
+    # grid mode on
+    assert noise.noise2([0, 1], [2, 3, 4]).shape == (2, 3)
+    assert noise.noise2([1], [2, 3, 4]).shape == (1, 3)
+    assert noise.noise2([0, 1], 4).shape == (2,)
+    assert noise.noise2(4, [0, 1]).shape == (2,)
+
+    # grid mode off
+    assert noise.noise2([0, 1, 2], [3, 4, 5], grid_mode=False).shape == (3,)
+    assert noise.noise2([0], [3], grid_mode=False).shape == (1,)
+
+    with pytest.raises(ValueError):
+        noise.noise2([0, 1, 2], [3, 4, 5, 6], grid_mode=False)
+
+
+def test_noise3_dimensions(noise):
+    # scalar
+    assert isinstance(noise.noise3(1.5, 1.0, 1.5, grid_mode=True), float)
+    assert isinstance(noise.noise3(1.5, 1.0, 1.5, grid_mode=False), float)
+
+    # grid mode on
+    assert noise.noise3([0, 1], [2, 3, 4], 4).shape == (2, 3)
+    assert noise.noise3([0, 1], [2, 3, 4], [5, 6, 7, 8]).shape == (2, 3, 4)
+    assert noise.noise3([1], [2, 3, 4], [5, 6, 7, 8]).shape == (1, 3, 4)
+    assert noise.noise3([0, 1], 4, [5, 6, 7, 8]).shape == (2, 4)
+    assert noise.noise3(4, 4, [5, 6, 7, 8]).shape == (4,)
+    assert noise.noise3(4, [0, 1], [5, 6, 7, 8]).shape == (2, 4)
+
+    # grid mode off
+    assert noise.noise3([0, 1, 2], [3, 4, 5], [5, 6, 7], grid_mode=False).shape == (3,)
+    assert noise.noise3([0], [3], [5], grid_mode=False).shape == (1,)
+
+    with pytest.raises(ValueError):
+        noise.noise3([0, 1, 2], [3, 4, 5, 6], [5, 6, 7], grid_mode=False)
+
+
+@pytest.mark.parametrize("seed", [None, 0, 1])
+@pytest.mark.parametrize("octaves", list(range(1, 9)))
+@pytest.mark.parametrize("x", [10, [1], 0.5, range(5), np.linspace(0, 10, 100)])
+def test_noise1_noise2(seed, x, octaves):
+    noise = Noise(seed)
+    y = 0 if isinstance(x, Number) else np.zeros_like(x)
+
+    n2 = noise.noise2(x, y, octaves=octaves, grid_mode=False)
+    n1 = noise.noise1(x, octaves=octaves)
+    assert np.all(n1 == n2)
+
+
+@pytest.mark.parametrize("seed", [None, 0, 1])
+@pytest.mark.parametrize("octaves", list(range(1, 9)))
+@pytest.mark.parametrize(
+    ["x", "y", "grid_mode"],
+    [
+        (0, 10, False),
+        (0.0, 15.0, False),
+        (range(5), 0, True),
+        (np.linspace(0, 10, 100), np.linspace(10, 20, 100), False),
+    ],
+)
+def test_noise2_noise3(seed, x, y, grid_mode, octaves):
+    noise = Noise(seed)
+    z = 0 if grid_mode else np.zeros_like(x)
+    assert np.all(
+        noise.noise2(x, y, octaves=octaves, grid_mode=grid_mode)
+        == noise.noise3(x, y, z, octaves=octaves, grid_mode=grid_mode)
+    )

tests/test_ported.py

@@ -0,0 +1,73 @@
+"""This test suite is a port of Casey Duncan original test suite
+"""
+
+
+def test_perlin_1d_range(noise):
+    for i in range(-10000, 10000):
+        x = i * 0.49
+        n = noise.noise1(x)
+        assert -1.0 <= n <= 1.0
+
+
+def test_perlin_1d_octaves_range(noise):
+    for i in range(-1000, 1000):
+        for o in range(10):
+            x = i * 0.49
+            n = noise.noise1(x, octaves=o + 1)
+            assert -1.0 <= n <= 1.0
+
+
+def test_perlin_1d_base(noise):
+    assert noise.noise1(0.5) == noise.noise1(0.5, base=0)
+    assert noise.noise1(0.5) != noise.noise1(0.5, base=5)
+    assert noise.noise1(0.5, base=5) != noise.noise1(0.5, base=1)
+
+
+def test_perlin_2d_range(noise):
+    for i in range(-10000, 10000):
+        x = i * 0.49
+        y = -i * 0.67
+        n = noise.noise2(x, y)
+        assert -1.0 <= n <= 1.0
+
+
+def test_perlin_2d_octaves_range(noise):
+    for i in range(-1000, 1000):
+        for o in range(10):
+            x = -i * 0.49
+            y = i * 0.67
+            n = noise.noise2(x, y, octaves=o + 1)
+            assert -1.0 <= n <= 1.0
+
+
+def test_perlin_2d_base(noise):
+    x, y = 0.73, 0.27
+    assert noise.noise2(x, y) == noise.noise2(x, y, base=0)
+    assert noise.noise2(x, y) != noise.noise2(x, y, base=5)
+    assert noise.noise2(x, y, base=5) != noise.noise2(x, y, base=1)
+
+
+def test_perlin_3d_range(noise):
+    for i in range(-10000, 10000):
+        x = -i * 0.49
+        y = i * 0.67
+        z = -i * 0.727
+        n = noise.noise3(x, y, z)
+        assert -1.0 <= n <= 1.0
+
+
+def test_perlin_3d_octaves_range(noise):
+    for i in range(-1000, 1000):
+        x = i * 0.22
+        y = -i * 0.77
+        z = -i * 0.17
+        for o in range(10):
+            n = noise.noise3(x, y, z, octaves=o + 1)
+            assert -1.0 <= n <= 1.0
+
+
+def test_perlin_3d_base(noise):
+    x, y, z = 0.1, 0.7, 0.33
+    assert noise.noise3(x, y, z) == noise.noise3(x, y, z, base=0)
+    assert noise.noise3(x, y, z) != noise.noise3(x, y, z, base=5)
+    assert noise.noise3(x, y, z, base=5) != noise.noise3(x, y, z, base=1)

vnoise/__init__.py

@@ -0,0 +1,10 @@
+from .vnoise import Noise
+
+
+def _get_version() -> str:
+    import pkg_resources
+
+    return pkg_resources.get_distribution("vnoise").version
+
+
+__version__ = _get_version()