fast-crossing 0.0.3__tar.gz

fast_crossing-0.0.3/CMakeLists.txt

@@ -0,0 +1,33 @@
+cmake_minimum_required(VERSION 3.4...3.18)
+project(fast_crossing)
+
+set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
+set(CMAKE_POSITION_INDEPENDENT_CODE ON)
+
+if(NOT CMAKE_BUILD_TYPE OR CMAKE_BUILD_TYPE STREQUAL "")
+  set(CMAKE_BUILD_TYPE
+      "Release"
+      CACHE STRING "" FORCE)
+  message(STATUS "Set build type to default: ${CMAKE_BUILD_TYPE}")
+else()
+  message(STATUS "Your build type: ${CMAKE_BUILD_TYPE}")
+endif()
+if(CMAKE_BUILD_TYPE STREQUAL "Debug")
+  set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -O0 -ggdb")
+  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -O0 -ggdb")
+elseif(CMAKE_BUILD_TYPE STREQUAL "Release")
+  set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -O3")
+  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -O3")
+endif()
+
+include_directories(${PROJECT_SOURCE_DIR}/headers/include
+                    ${PROJECT_SOURCE_DIR}/headers/include/cubao)
+
+set(CMAKE_CXX_STANDARD 17)
+set(PYBIND11_CPP_STANDARD -std=c++17)
+
+add_subdirectory(pybind11)
+pybind11_add_module(fast_crossing src/main.cpp)
+
+target_compile_definitions(fast_crossing
+                           PRIVATE VERSION_INFO=${FAST_CROSSING_VERSION_INFO})

fast_crossing-0.0.3/LICENSE

@@ -0,0 +1,36 @@
+Copyright (c) 2016 The Pybind Development Team, All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its contributors
+   may be used to endorse or promote products derived from this software
+   without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+You are under no obligation whatsoever to provide any bug fixes, patches, or
+upgrades to the features, functionality or performance of the source code
+("Enhancements") to anyone; however, if you choose to make your Enhancements
+available either publicly, or directly to the author of this software, without
+imposing a separate written license agreement for such Enhancements, then you
+hereby grant the following license: a non-exclusive, royalty-free perpetual
+license to install, use, modify, prepare derivative works, incorporate into
+other computer software, distribute, and sublicense such enhancements or
+derivative works thereof, in binary and source code form.

fast_crossing-0.0.3/MANIFEST.in

@@ -0,0 +1,7 @@
+include README.md LICENSE pybind11/LICENSE
+graft headers
+graft pybind11/include
+graft pybind11/tools
+graft src
+graft tests
+global-include CMakeLists.txt *.cmake

fast_crossing-0.0.3/PKG-INFO

@@ -0,0 +1,223 @@
+Metadata-Version: 2.1
+Name: fast_crossing
+Version: 0.0.3
+Summary: fast crossing
+Home-page: https://github.com/cubao/fast-crossing
+Author: tzx
+Author-email: dvorak4tzx@gmail.com
+Description-Content-Type: text/markdown
+Provides-Extra: test
+License-File: LICENSE
+
+# fast crossing
+
+<!--intro-start-->
+
+## Installation
+
+### via pip
+
+```bash
+pip install -U fast-crossing
+```
+
+### from source
+
+```bash
+git clone --recursive https://github.com/cubao/fast-crossing
+pip install ./fast-crossing
+```
+
+Or
+
+```bash
+pip install git+https://github.com/cubao/fast-crossing.git
+```
+
+(you can build wheels for later reuse by ` pip wheel git+https://github.com/cubao/fast-crossing.git`)
+
+<!--intro-end-->
+
+## Usage & Tests
+
+See [`tests/test_basic.py`](tests/test_basic.py):
+
+```python
+import numpy as np
+import pytest
+from fast_crossing import FastCrossing
+
+
+def test_fast_crossing():
+    fc = FastCrossing()
+
+    # add your polylines
+    """
+                    2 C
+                    |
+                    1 D
+    0               |                  5
+    A---------------o------------------B
+                    |
+                    |
+                    -2 E
+    """
+    fc.add_polyline(np.array([[0.0, 0.0], [5.0, 0.0]]))  # AB
+    fc.add_polyline(np.array([[2.5, 2.0], [2.5, 1.0], [2.5, -2.0]]))  # CDE
+
+    # build index
+    fc.finish()
+
+    # num_poylines
+    assert 2 == fc.num_poylines()
+    rulers = fc.polyline_rulers()
+    assert len(rulers) == 2
+    ruler0 = fc.polyline_ruler(0)
+    ruler1 = fc.polyline_ruler(1)
+    assert not ruler0.is_wgs84()
+    assert not ruler1.is_wgs84()
+    assert ruler0.length() == 5
+    assert ruler1.length() == 4
+    assert fc.polyline_ruler(10) is None
+
+    # intersections
+    ret = fc.intersections([1.5, 0], [3.5, 2])
+    assert len(ret) == 2
+    assert np.linalg.norm(fc.coordinates(ret[0]) - [1.5, 0, 0]) < 1e-15
+    assert np.linalg.norm(fc.coordinates(ret[1]) - [2.5, 1, 0]) < 1e-15
+    xyz = fc.coordinates(0, 0, 0.2)
+    assert np.linalg.norm(xyz - [1.0, 0, 0]) < 1e-15
+    with pytest.raises(IndexError) as excinfo:
+        xyz = fc.coordinates(2, 0, 0.5)
+    assert "map::at" in str(excinfo)
+
+    # query all line segment intersections
+    # [
+    #    (array([2.5, 0. ]),
+    #     array([0.5       , 0.33333333]),
+    #     array([0, 0], dtype=int32),
+    #     array([1, 1], dtype=int32))
+    # ]
+    ret = fc.intersections()
+    # print(ret)
+    assert len(ret) == 1
+    for xy, ts, label1, label2 in ret:
+        # xy 是交点，即图中的 o 点坐标
+        # t,s 是分位点，(0.5, 0.33)
+        #        0.5  ->   o 在 AB 1/2 处
+        #        0.33 ->   o 在 DE 1/3 处
+        # label1 是 line segment 索引，(polyline_index, point_index)
+        #        e.g. (0, 0)，polyline AB 的第一段
+        # label2 是另一个条 line seg 的索引
+        #        e.g. (1, 1)，polyline CDE 的第二段（DE 段）
+        # print(xy)
+        # print(ts)
+        # print(label1)
+        # print(label2)
+        assert np.all(xy == [2.5, 0])
+        assert np.all(ts == [0.5, 1 / 3.0])
+        assert np.all(label1 == [0, 0])
+        assert np.all(label2 == [1, 1])
+
+    # query intersections against provided polyline
+    polyline = np.array([[-6.0, -1.0], [-5.0, 1.0], [5.0, -1.0]])
+    ret = fc.intersections(polyline)
+    ret = np.array(ret)  # 还是转化成 numpy 比较好用
+    xy = ret[:, 0]  # 直接取出所有交点
+    ts = ret[:, 1]  # 所有分位点
+    label1 = ret[:, 2]  # 所有 label1（当前 polyline 的 label）
+    label2 = ret[:, 3]  # tree 中 line segs 的 label
+    # print(ret, xy, ts, label1, label2)
+    assert np.all(xy[0] == [0, 0])
+    assert np.all(xy[1] == [2.5, -0.5])
+    assert np.all(ts[0] == [0.5, 0])
+    assert np.all(ts[1] == [0.75, 0.5])
+    assert np.all(label1 == [[0, 1], [0, 1]])
+    assert np.all(label2 == [[0, 0], [1, 1]])
+
+    polyline2 = np.column_stack((polyline, np.zeros(len(polyline))))
+    ret2 = np.array(fc.intersections(polyline2[:, :2]))
+    assert str(ret) == str(ret2)
+
+
+def test_fast_crossing_intersection3d():
+    fc = FastCrossing()
+    """
+                    2 C
+                    |
+                    1 D
+    0               |                  5
+    A---------------o------------------B
+                    |
+                    |
+                    -2 E
+    """
+    fc.add_polyline(np.array([[0.0, 0.0, 0.0], [5.0, 0.0, 100]]))  # AB
+    fc.add_polyline(np.array([[2.5, 2.0, 0.0], [2.5, 1.0, 100], [2.5, -2.0, 0]]))  # CDE
+    fc.finish()
+    ret = fc.intersections()
+    assert len(ret) == 1
+    ret = ret[0]
+    xyz1 = fc.coordinates(ret, second=False)
+    xyz2 = fc.coordinates(ret)
+    assert np.linalg.norm(xyz1 - [2.5, 0, 50]) < 1e-10
+    assert np.linalg.norm(xyz2 - [2.5, 0, 2 / 3 * 100.0]) < 1e-10
+
+
+def test_fast_crossing_auto_rebuild_flatbush():
+    fc = FastCrossing()
+    fc.add_polyline(np.array([[0.0, 0.0, 0.0], [5.0, 0.0, 100]]))  # AB
+    fc.add_polyline(np.array([[2.5, 2.0, 0.0], [2.5, 1.0, 100], [2.5, -2.0, 0]]))  # CDE
+    ret = fc.intersections()
+    assert len(ret) == 1
+
+    fc.add_polyline([[1.5, 0], [3.5, 2]])
+    ret = fc.intersections()
+    assert len(ret) == 4  # should dedup to 3?
+
+
+def test_fast_crossing_filter_by_z():
+    fc = FastCrossing()
+    fc.add_polyline([[0, 0, 0], [1, 0, 0]])
+    fc.add_polyline([[0, 0, 10], [1, 0, 10]])
+    fc.add_polyline([[0, 0, 20], [1, 0, 20]])
+    ret = fc.intersections([[0.5, -1], [0.5, 1]])
+    assert len(ret) == 3
+
+    ret = fc.intersections([[0.5, -1], [0.5, 1]], z_min=-1, z_max=1)
+    assert len(ret) == 1
+    assert fc.coordinates(ret[0])[2] == 0
+
+    ret = fc.intersections([[0.5, -1, 10], [0.5, 1, 10]], z_min=-1, z_max=1)
+    assert len(ret) == 1
+    assert fc.coordinates(ret[0])[2] == 10
+
+    ret = fc.intersections([[0.5, -1, 20], [0.5, 1, 20]], z_min=-1, z_max=1)
+    assert len(ret) == 1
+    assert fc.coordinates(ret[0])[2] == 20
+
+    ret = fc.intersections([[0.5, -1, 15], [0.5, 1, 15]], z_min=-6, z_max=6)
+    assert len(ret) == 2
+    assert fc.coordinates(ret[0])[2] == 10
+    assert fc.coordinates(ret[1])[2] == 20
+
+
+def test_fast_crossing_dedup():
+    # should be stable
+    for _ in range(100):
+        fc = FastCrossing()
+        fc.add_polyline([[0, 0, 0], [1, 0, 0], [2, 0, 0]])
+        fc.add_polyline([[0, 1, 0], [1, 1, 0], [2, 1, 0]])
+
+        ret = fc.intersections([[1, -1], [1, 1]])
+        assert len(ret) == 2
+        assert np.all(ret[0][-1] == [0, 0]), ret
+        assert np.all(ret[1][-1] == [1, 0]), ret
+        assert ret[0][1][1] == 1.0, ret
+        assert ret[1][1][1] == 1.0, ret
+
+        ret = fc.intersections([[1, -1], [1, 1]], dedup=False)
+        # for idx, row in enumerate(ret):
+        #     print(idx, row)
+        assert len(ret) == 4
+```

fast_crossing-0.0.3/README.md

@@ -0,0 +1,212 @@
+# fast crossing
+
+<!--intro-start-->
+
+## Installation
+
+### via pip
+
+```bash
+pip install -U fast-crossing
+```
+
+### from source
+
+```bash
+git clone --recursive https://github.com/cubao/fast-crossing
+pip install ./fast-crossing
+```
+
+Or
+
+```bash
+pip install git+https://github.com/cubao/fast-crossing.git
+```
+
+(you can build wheels for later reuse by ` pip wheel git+https://github.com/cubao/fast-crossing.git`)
+
+<!--intro-end-->
+
+## Usage & Tests
+
+See [`tests/test_basic.py`](tests/test_basic.py):
+
+```python
+import numpy as np
+import pytest
+from fast_crossing import FastCrossing
+
+
+def test_fast_crossing():
+    fc = FastCrossing()
+
+    # add your polylines
+    """
+                    2 C
+                    |
+                    1 D
+    0               |                  5
+    A---------------o------------------B
+                    |
+                    |
+                    -2 E
+    """
+    fc.add_polyline(np.array([[0.0, 0.0], [5.0, 0.0]]))  # AB
+    fc.add_polyline(np.array([[2.5, 2.0], [2.5, 1.0], [2.5, -2.0]]))  # CDE
+
+    # build index
+    fc.finish()
+
+    # num_poylines
+    assert 2 == fc.num_poylines()
+    rulers = fc.polyline_rulers()
+    assert len(rulers) == 2
+    ruler0 = fc.polyline_ruler(0)
+    ruler1 = fc.polyline_ruler(1)
+    assert not ruler0.is_wgs84()
+    assert not ruler1.is_wgs84()
+    assert ruler0.length() == 5
+    assert ruler1.length() == 4
+    assert fc.polyline_ruler(10) is None
+
+    # intersections
+    ret = fc.intersections([1.5, 0], [3.5, 2])
+    assert len(ret) == 2
+    assert np.linalg.norm(fc.coordinates(ret[0]) - [1.5, 0, 0]) < 1e-15
+    assert np.linalg.norm(fc.coordinates(ret[1]) - [2.5, 1, 0]) < 1e-15
+    xyz = fc.coordinates(0, 0, 0.2)
+    assert np.linalg.norm(xyz - [1.0, 0, 0]) < 1e-15
+    with pytest.raises(IndexError) as excinfo:
+        xyz = fc.coordinates(2, 0, 0.5)
+    assert "map::at" in str(excinfo)
+
+    # query all line segment intersections
+    # [
+    #    (array([2.5, 0. ]),
+    #     array([0.5       , 0.33333333]),
+    #     array([0, 0], dtype=int32),
+    #     array([1, 1], dtype=int32))
+    # ]
+    ret = fc.intersections()
+    # print(ret)
+    assert len(ret) == 1
+    for xy, ts, label1, label2 in ret:
+        # xy 是交点，即图中的 o 点坐标
+        # t,s 是分位点，(0.5, 0.33)
+        #        0.5  ->   o 在 AB 1/2 处
+        #        0.33 ->   o 在 DE 1/3 处
+        # label1 是 line segment 索引，(polyline_index, point_index)
+        #        e.g. (0, 0)，polyline AB 的第一段
+        # label2 是另一个条 line seg 的索引
+        #        e.g. (1, 1)，polyline CDE 的第二段（DE 段）
+        # print(xy)
+        # print(ts)
+        # print(label1)
+        # print(label2)
+        assert np.all(xy == [2.5, 0])
+        assert np.all(ts == [0.5, 1 / 3.0])
+        assert np.all(label1 == [0, 0])
+        assert np.all(label2 == [1, 1])
+
+    # query intersections against provided polyline
+    polyline = np.array([[-6.0, -1.0], [-5.0, 1.0], [5.0, -1.0]])
+    ret = fc.intersections(polyline)
+    ret = np.array(ret)  # 还是转化成 numpy 比较好用
+    xy = ret[:, 0]  # 直接取出所有交点
+    ts = ret[:, 1]  # 所有分位点
+    label1 = ret[:, 2]  # 所有 label1（当前 polyline 的 label）
+    label2 = ret[:, 3]  # tree 中 line segs 的 label
+    # print(ret, xy, ts, label1, label2)
+    assert np.all(xy[0] == [0, 0])
+    assert np.all(xy[1] == [2.5, -0.5])
+    assert np.all(ts[0] == [0.5, 0])
+    assert np.all(ts[1] == [0.75, 0.5])
+    assert np.all(label1 == [[0, 1], [0, 1]])
+    assert np.all(label2 == [[0, 0], [1, 1]])
+
+    polyline2 = np.column_stack((polyline, np.zeros(len(polyline))))
+    ret2 = np.array(fc.intersections(polyline2[:, :2]))
+    assert str(ret) == str(ret2)
+
+
+def test_fast_crossing_intersection3d():
+    fc = FastCrossing()
+    """
+                    2 C
+                    |
+                    1 D
+    0               |                  5
+    A---------------o------------------B
+                    |
+                    |
+                    -2 E
+    """
+    fc.add_polyline(np.array([[0.0, 0.0, 0.0], [5.0, 0.0, 100]]))  # AB
+    fc.add_polyline(np.array([[2.5, 2.0, 0.0], [2.5, 1.0, 100], [2.5, -2.0, 0]]))  # CDE
+    fc.finish()
+    ret = fc.intersections()
+    assert len(ret) == 1
+    ret = ret[0]
+    xyz1 = fc.coordinates(ret, second=False)
+    xyz2 = fc.coordinates(ret)
+    assert np.linalg.norm(xyz1 - [2.5, 0, 50]) < 1e-10
+    assert np.linalg.norm(xyz2 - [2.5, 0, 2 / 3 * 100.0]) < 1e-10
+
+
+def test_fast_crossing_auto_rebuild_flatbush():
+    fc = FastCrossing()
+    fc.add_polyline(np.array([[0.0, 0.0, 0.0], [5.0, 0.0, 100]]))  # AB
+    fc.add_polyline(np.array([[2.5, 2.0, 0.0], [2.5, 1.0, 100], [2.5, -2.0, 0]]))  # CDE
+    ret = fc.intersections()
+    assert len(ret) == 1
+
+    fc.add_polyline([[1.5, 0], [3.5, 2]])
+    ret = fc.intersections()
+    assert len(ret) == 4  # should dedup to 3?
+
+
+def test_fast_crossing_filter_by_z():
+    fc = FastCrossing()
+    fc.add_polyline([[0, 0, 0], [1, 0, 0]])
+    fc.add_polyline([[0, 0, 10], [1, 0, 10]])
+    fc.add_polyline([[0, 0, 20], [1, 0, 20]])
+    ret = fc.intersections([[0.5, -1], [0.5, 1]])
+    assert len(ret) == 3
+
+    ret = fc.intersections([[0.5, -1], [0.5, 1]], z_min=-1, z_max=1)
+    assert len(ret) == 1
+    assert fc.coordinates(ret[0])[2] == 0
+
+    ret = fc.intersections([[0.5, -1, 10], [0.5, 1, 10]], z_min=-1, z_max=1)
+    assert len(ret) == 1
+    assert fc.coordinates(ret[0])[2] == 10
+
+    ret = fc.intersections([[0.5, -1, 20], [0.5, 1, 20]], z_min=-1, z_max=1)
+    assert len(ret) == 1
+    assert fc.coordinates(ret[0])[2] == 20
+
+    ret = fc.intersections([[0.5, -1, 15], [0.5, 1, 15]], z_min=-6, z_max=6)
+    assert len(ret) == 2
+    assert fc.coordinates(ret[0])[2] == 10
+    assert fc.coordinates(ret[1])[2] == 20
+
+
+def test_fast_crossing_dedup():
+    # should be stable
+    for _ in range(100):
+        fc = FastCrossing()
+        fc.add_polyline([[0, 0, 0], [1, 0, 0], [2, 0, 0]])
+        fc.add_polyline([[0, 1, 0], [1, 1, 0], [2, 1, 0]])
+
+        ret = fc.intersections([[1, -1], [1, 1]])
+        assert len(ret) == 2
+        assert np.all(ret[0][-1] == [0, 0]), ret
+        assert np.all(ret[1][-1] == [1, 0]), ret
+        assert ret[0][1][1] == 1.0, ret
+        assert ret[1][1][1] == 1.0, ret
+
+        ret = fc.intersections([[1, -1], [1, 1]], dedup=False)
+        # for idx, row in enumerate(ret):
+        #     print(idx, row)
+        assert len(ret) == 4
+```