Merge pull request #2 from kylebarron/pybind11

Author: kylebarron

pydelatin/__init__.py

@@ -1,7 +1,2 @@
-"""Top-level package for pydelatin."""
 
-__author__ = """Kyle Barron"""
-__email__ = 'kylebarron2@gmail.com'
-__version__ = '0.1.0'
-
-from .delatin import Delatin
+from .wrapper import Pydelatin

pydelatin/wrapper.py

@@ -0,0 +1,57 @@
+from typing import Optional
+import numpy as np
+from _pydelatin import PydelatinTriangulator
+
+
+class Pydelatin:
+    def __init__(
+            self,
+            arr: np.ndarray,
+            z_scale,
+            z_exag: float = 1,
+            max_error: float = 0.001,
+            max_triangles: Optional[int] = None,
+            max_points: Optional[int] = None,
+            base_height: float = 0,
+            level: bool = False,
+            invert: bool = False,
+            blur: int = 0,
+            gamma: float = 0,
+            border_size: int = 0,
+            border_height: float = 1):
+        """
+
+        Args:
+            - arr: data array
+            - z_scale: z scale relative to x & y
+            - z_exag: z exaggeration
+            - max_error: maximum triangulation error
+            - max_triangles: maximum number of triangles
+            - max_points: maximum number of vertices
+            - base_height: solid base height
+            - level: auto level input to full grayscale range
+            - invert: invert heightmap
+            - blur: gaussian blur sigma
+            - gamma: gamma curve exponent
+            - border_size: border size in pixels
+            - border_height: border z height
+        """
+        super(Pydelatin, self).__init__()
+
+        max_triangles = max_triangles if max_triangles is not None else 0
+        max_points = max_points if max_points is not None else 0
+
+        height, width = arr.shape
+        self.tri = PydelatinTriangulator(
+            arr.flatten(), width, height, max_error, z_scale, z_exag,
+            max_triangles, max_points, level, invert, blur, gamma, border_size,
+            border_height, base_height)
+        self.tri.run()
+
+    @property
+    def vertices(self):
+        return self.tri.getPoints()
+
+    @property
+    def triangles(self):
+        return self.tri.getTriangles()

setup.py

@@ -1,51 +1,124 @@
-"""Setup for pydelatin."""
-from pathlib import Path
+from setuptools import find_packages, setup, Extension
+from setuptools.command.build_ext import build_ext
+import sys
+import setuptools
 
-import numpy as np
-# setuptools must be before Cython
-from setuptools import find_packages, setup
-from Cython.Build import cythonize
+__version__ = '0.1.0'
 
-with open("README.md") as f:
-    readme = f.read()
 
-# Runtime requirements.
-inst_reqs = ["numpy"]
+class get_pybind_include(object):
+    """Helper class to determine the pybind11 include path
 
-extra_reqs = {
-    "test": ["pytest", "pytest-benchmark", "imageio"], }
+    The purpose of this class is to postpone importing pybind11
+    until it is actually installed, so that the ``get_include()``
+    method can be invoked. """
 
+    def __str__(self):
+        import pybind11
+        return pybind11.get_include()
 
-# Ref https://suzyahyah.github.io/cython/programming/2018/12/01/Gotchas-in-Cython.html
-def find_pyx(path='.'):
-    return list(map(str, Path(path).glob('**/*.pyx')))
+
+ext_modules = [
+    Extension(
+        '_pydelatin',
+        # Sort input source files to ensure bit-for-bit reproducible builds
+        # (https://github.com/pybind/python_example/pull/53)
+        sorted([
+            'src/base.cpp',
+            'src/blur.cpp',
+            'src/heightmap.cpp',
+            'src/main.cpp',
+            'src/triangulator.cpp',
+        ]),
+        include_dirs=[
+            # Path to pybind11 headers
+            get_pybind_include(),
+        ],
+        language='c++'
+    ),
+]
+
+
+# cf http://bugs.python.org/issue26689
+def has_flag(compiler, flagname):
+    """Return a boolean indicating whether a flag name is supported on
+    the specified compiler.
+    """
+    import tempfile
+    import os
+    with tempfile.NamedTemporaryFile('w', suffix='.cpp', delete=False) as f:
+        f.write('int main (int argc, char **argv) { return 0; }')
+        fname = f.name
+    try:
+        compiler.compile([fname], extra_postargs=[flagname])
+    except setuptools.distutils.errors.CompileError:
+        return False
+    finally:
+        try:
+            os.remove(fname)
+        except OSError:
+            pass
+    return True
+
+
+def cpp_flag(compiler):
+    """Return the -std=c++[11/14/17] compiler flag.
+
+    The newer version is prefered over c++11 (when it is available).
+    """
+    flags = ['-std=c++17', '-std=c++14', '-std=c++11']
+
+    for flag in flags:
+        if has_flag(compiler, flag):
+            return flag
+
+    raise RuntimeError('Unsupported compiler -- at least C++11 support '
+                       'is needed!')
+
+
+class BuildExt(build_ext):
+    """A custom build extension for adding compiler-specific options."""
+    c_opts = {
+        'msvc': ['/EHsc'],
+        'unix': [],
+    }
+    l_opts = {
+        'msvc': [],
+        'unix': [],
+    }
+
+    if sys.platform == 'darwin':
+        darwin_opts = ['-stdlib=libc++', '-mmacosx-version-min=10.7']
+        c_opts['unix'] += darwin_opts
+        l_opts['unix'] += darwin_opts
+
+    def build_extensions(self):
+        ct = self.compiler.compiler_type
+        opts = self.c_opts.get(ct, [])
+        link_opts = self.l_opts.get(ct, [])
+        if ct == 'unix':
+            opts.append(cpp_flag(self.compiler))
+            if has_flag(self.compiler, '-fvisibility=hidden'):
+                opts.append('-fvisibility=hidden')
+
+        for ext in self.extensions:
+            ext.define_macros = [('VERSION_INFO', '"{}"'.format(self.distribution.get_version()))]
+            ext.extra_compile_args = opts
+            ext.extra_link_args = link_opts
+        build_ext.build_extensions(self)
 
 
 setup(
-    name="pydelatin",
-    version="0.1.0",
-    description="A Python port of Martini for fast terrain mesh generation",
-    long_description=readme,
-    long_description_content_type="text/markdown",
-    classifiers=[
-        "Intended Audience :: Information Technology",
-        "Intended Audience :: Science/Research",
-        "License :: OSI Approved :: MIT License",
-        "Programming Language :: Python :: 3.6",
-        "Programming Language :: Python :: 3.7",
-        "Programming Language :: Python :: 3.8",
-        "Topic :: Scientific/Engineering :: GIS"],
-    keywords="mesh heightmap elevation terrain numpy",
-    author="Kyle Barron",
-    author_email="kylebarron2@gmail.com",
-    url="https://github.com/kylebarron/pydelatin",
-    license="MIT",
-    packages=find_packages(exclude=["ez_setup", "scripts", "examples", "test"]),
-    include_package_data=True,
+    name='pydelatin',
+    version=__version__,
+    author='Kyle Barron',
+    author_email='kylebarron2@gmail.com',
+    url='https://github.com/kylebarron/pydelatin',
+    description='A wrapper for hmm',
+    long_description='',
+    packages=find_packages(include=['pydelatin', 'pydelatin.*']),
+    ext_modules=ext_modules,
+    setup_requires=['pybind11>=2.5.0'],
+    cmdclass={'build_ext': BuildExt},
     zip_safe=False,
-    install_requires=inst_reqs,
-    extras_require=extra_reqs,
-    ext_modules=cythonize(find_pyx(), language_level=3),
-    # Include Numpy headers
-    include_dirs=[np.get_include()],
 )

src/__init__.py.bak

@@ -0,0 +1,7 @@
+"""Top-level package for pydelatin."""
+
+__author__ = """Kyle Barron"""
+__email__ = 'kylebarron2@gmail.com'
+__version__ = '0.1.0'
+
+from .main import pydelatin

src/base.cpp

@@ -0,0 +1,124 @@
+#include "base.h"
+
+#define GLM_ENABLE_EXPERIMENTAL
+
+#include <glm/gtx/hash.hpp>
+#include <map>
+#include <unordered_map>
+
+void AddBase(
+    std::vector<glm::vec3> &points,
+    std::vector<glm::ivec3> &triangles,
+    const int w, const int h, const float z)
+{
+    const int w1 = w - 1;
+    const int h1 = h - 1;
+
+    std::map<int, float> x0s;
+    std::map<int, float> x1s;
+    std::map<int, float> y0s;
+    std::map<int, float> y1s;
+    std::unordered_map<glm::vec3, int> lookup;
+
+    // find points along each edge
+    for (int i = 0; i < points.size(); i++) {
+        const auto &p = points[i];
+        bool edge = false;
+        if (p.x == 0) {
+            x0s[p.y] = p.z;
+            edge = true;
+        } else if (p.x == w1) {
+            x1s[p.y] = p.z;
+            edge = true;
+        }
+        if (p.y == 0) {
+            y0s[p.x] = p.z;
+            edge = true;
+        } else if (p.y == h1) {
+            y1s[p.x] = p.z;
+            edge = true;
+        }
+        if (edge) {
+            lookup[p] = i;
+        }
+    }
+
+    std::vector<std::pair<int, float>> sx0s(x0s.begin(), x0s.end());
+    std::vector<std::pair<int, float>> sx1s(x1s.begin(), x1s.end());
+    std::vector<std::pair<int, float>> sy0s(y0s.begin(), y0s.end());
+    std::vector<std::pair<int, float>> sy1s(y1s.begin(), y1s.end());
+
+    const auto pointIndex = [&lookup, &points](
+        const float x, const float y, const float z)
+    {
+        const glm::vec3 point(x, y, z);
+        if (lookup.find(point) == lookup.end()) {
+            lookup[point] = points.size();
+            points.push_back(point);
+        }
+        return lookup[point];
+    };
+
+    // compute base center point
+    const int center = pointIndex(w * 0.5f, h * 0.5f, z);
+
+    // edge x = 0
+    for (int i = 1; i < sx0s.size(); i++) {
+        const int y0 = sx0s[i-1].first;
+        const int y1 = sx0s[i].first;
+        const float z0 = sx0s[i-1].second;
+        const float z1 = sx0s[i].second;
+        const int p00 = pointIndex(0, y0, z);
+        const int p01 = pointIndex(0, y0, z0);
+        const int p10 = pointIndex(0, y1, z);
+        const int p11 = pointIndex(0, y1, z1);
+        triangles.emplace_back(p01, p10, p00);
+        triangles.emplace_back(p01, p11, p10);
+        triangles.emplace_back(center, p00, p10);
+    }
+
+    // edge x = w1
+    for (int i = 1; i < sx1s.size(); i++) {
+        const int y0 = sx1s[i-1].first;
+        const int y1 = sx1s[i].first;
+        const float z0 = sx1s[i-1].second;
+        const float z1 = sx1s[i].second;
+        const int p00 = pointIndex(w1, y0, z);
+        const int p01 = pointIndex(w1, y0, z0);
+        const int p10 = pointIndex(w1, y1, z);
+        const int p11 = pointIndex(w1, y1, z1);
+        triangles.emplace_back(p00, p10, p01);
+        triangles.emplace_back(p10, p11, p01);
+        triangles.emplace_back(center, p10, p00);
+    }
+
+    // edge y = 0
+    for (int i = 1; i < sy0s.size(); i++) {
+        const int x0 = sy0s[i-1].first;
+        const int x1 = sy0s[i].first;
+        const float z0 = sy0s[i-1].second;
+        const float z1 = sy0s[i].second;
+        const int p00 = pointIndex(x0, 0, z);
+        const int p01 = pointIndex(x0, 0, z0);
+        const int p10 = pointIndex(x1, 0, z);
+        const int p11 = pointIndex(x1, 0, z1);
+        triangles.emplace_back(p00, p10, p01);
+        triangles.emplace_back(p10, p11, p01);
+        triangles.emplace_back(center, p10, p00);
+    }
+
+    // edge y = h1
+    for (int i = 1; i < sy1s.size(); i++) {
+        const int x0 = sy1s[i-1].first;
+        const int x1 = sy1s[i].first;
+        const float z0 = sy1s[i-1].second;
+        const float z1 = sy1s[i].second;
+        const int p00 = pointIndex(x0, h1, z);
+        const int p01 = pointIndex(x0, h1, z0);
+        const int p10 = pointIndex(x1, h1, z);
+        const int p11 = pointIndex(x1, h1, z1);
+        triangles.emplace_back(p01, p10, p00);
+        triangles.emplace_back(p01, p11, p10);
+        triangles.emplace_back(center, p00, p10);
+    }
+}

src/base.h

@@ -0,0 +1,9 @@
+#pragma once
+
+#include <glm/glm.hpp>
+#include <vector>
+
+void AddBase(
+    std::vector<glm::vec3> &points,
+    std::vector<glm::ivec3> &triangles,
+    const int w, const int h, const float z);