pptk-revived 0.1.1__tar.gz

pptk_revived-0.1.1/CMakeLists.txt

@@ -0,0 +1,58 @@
+cmake_minimum_required(VERSION 3.1)
+project(pptk)
+
+set(CMAKE_BUILD_TYPE Release)
+set(CMAKE_MODULE_PATH
+  "${CMAKE_CURRENT_SOURCE_DIR}/cmake" ${CMAKE_CURRENT_SOURCE_DIR})
+
+find_package(Python3 REQUIRED COMPONENTS Interpreter Development)
+set(PYTHON_INCLUDE_DIR ${Python3_INCLUDE_DIRS})
+set(PYTHON_LIBRARY ${Python3_LIBRARIES})
+find_package(OpenGL REQUIRED)
+find_package(Numpy REQUIRED)
+find_package(TBB REQUIRED)
+find_package(Eigen REQUIRED)
+find_package(Qt5 CONFIG REQUIRED COMPONENTS Widgets Network OpenGL Core)
+find_package(OpenMP)
+
+# get root Qt5 folder (i.e. contains bin, lib, plugins, etc.)
+get_target_property(Qt5_DIR Qt5::qmake LOCATION)
+get_filename_component(Qt5_DIR ${Qt5_DIR} DIRECTORY)
+get_filename_component(Qt5_DIR ${Qt5_DIR} DIRECTORY)
+set(Qt5_PLUGINS_DIR ${Qt5_DIR}/plugins)
+
+# localize all dependencies (.dll, .so, or .dylib) in the following folder
+set(PPTK_LIBS_DIR ${PROJECT_BINARY_DIR}/pptk/libs)
+
+# use the following variable to store a list of .dll paths required by targets
+# built in pptk; this is useful only for building on Windows platform
+get_filename_component(TBB_RUNTIME_DIR ${TBB_tbb_RUNTIME} DIRECTORY)
+set(PPTK_DLL_DIRS
+  ${TBB_RUNTIME_DIR}
+  ${Qt5_DIR}/bin
+  CACHE INTERNAL "Additional folder paths for finding .dll's")
+
+# use patchelf to modify binary RPATH when building pptk on Linux
+if(UNIX AND NOT APPLE)
+  find_program(PPTK_PATCHELF patchelf)
+  if (NOT PPTK_PATCHELF)
+    message(FATAL_ERROR
+      "patchelf needed for localizing library dependencies; \
+      please manually set the PPTK_PATCHELF variable.")
+  endif()
+endif()
+
+# adds -std=gnu++11 flag when compiling with gcc
+set(CMAKE_CXX_STANDARD 11)
+
+include(UsefulMacros)
+
+# following lines specifies the CMAKE_INSTALL_SYSTEM_RUNTIME_LIBS variable
+set(CMAKE_INSTALL_SYSTEM_RUNTIME_LIBS_SKIP TRUE)
+set(CMAKE_INSTALL_OPENMP_LIBRARIES TRUE)  # requires cmake 3.1
+include(InstallRequiredSystemLibraries)
+
+copy_file(setup.py)
+copy_file(LICENSE)
+add_subdirectory(pptk)
+add_subdirectory(licenses)

pptk_revived-0.1.1/LICENSE

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (C) 2011-2017 HERE Europe B.V.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+

pptk_revived-0.1.1/MANIFEST.in

@@ -0,0 +1,11 @@
+# Include CMake build system files so that `uv build` / `pip wheel` can
+# compile C++ extensions from the source distribution (sdist).
+
+include CMakeLists.txt
+recursive-include cmake *.cmake
+recursive-include pptk CMakeLists.txt *.cmake *.cpp *.h *.cu
+# Pre-compiled artifacts — included when present so the sdist-to-wheel build
+# can skip cmake.  setuptools silently ignores missing files in MANIFEST.in.
+recursive-include pptk *.so *.so.* *.pyd *.dylib
+include pptk/viewer/viewer
+recursive-include licenses *

pptk_revived-0.1.1/PKG-INFO

@@ -0,0 +1,15 @@
+Metadata-Version: 2.4
+Name: pptk-revived
+Version: 0.1.1
+Summary: A Python package for facilitating point cloud processing.
+Author: Nikolaas Steenbergen
+License-Expression: MIT
+Project-URL: Source, https://github.com/nikste/pptk_revived
+Classifier: Intended Audience :: Science/Research
+Classifier: Topic :: Scientific/Engineering
+Requires-Python: >=3.9
+License-File: LICENSE
+Requires-Dist: numpy<2
+Requires-Dist: pillow
+Requires-Dist: scikit-learn
+Dynamic: license-file

pptk_revived-0.1.1/README.md

@@ -0,0 +1,138 @@
+# pptk-revived - Point Processing Toolkit
+
+This is a fork of [heremaps/pptk](https://github.com/heremaps/pptk) maintained by [Nikolaas Steenbergen](https://github.com/nikste), updated to build and run on modern Python (3.12+) and CMake (3.28+).
+
+Source: https://github.com/nikste/pptk_revived
+
+Copyright (C) 2011-2018 HERE Europe B.V.
+
+The Point Processing Toolkit (pptk) is a Python package for visualizing and processing 2-d/3-d point clouds.
+
+At present, pptk consists of the following features.
+
+* A 3-d point cloud viewer that
+  - accepts any 3-column numpy array as input,
+  - renders tens of millions of points interactively using an octree-based level of detail mechanism,
+  - supports point selection for inspecting and annotating point data.
+* A fully parallelized point k-d tree that supports k-nearest neighbor queries and r-near range queries
+  (both build and queries have been parallelized).
+* A normal estimation routine based on principal component analysis of point cloud neighborhoods.
+
+[Homepage](https://heremaps.github.io/pptk/index.html)
+
+![pptk screenshots](/docs/source/tutorials/viewer/images/tutorial_banner.png)
+
+The screenshots above show various point datasets visualized using pptk.
+The `bildstein1` Lidar point cloud from Semantic3D (left),
+Beijing GPS trajectories from Geolife (middle left),
+`DistrictofColumbia.geojson` 2-d polygons from US building footprints (middle right),
+and a Mobius strip (right).
+For details, see the [tutorials](https://heremaps.github.io/pptk/tutorial.html).
+
+## License
+
+Unless otherwise noted in `LICENSE` files for specific files or directories,
+the [LICENSE](LICENSE) in the root applies to all content in this repository.
+
+## Install
+
+Install from PyPI:
+
+```
+pip install pptk-revived
+```
+
+or from a locally built wheel (see [Build](#build)):
+
+```
+pip install <.whl file>
+```
+
+## Quickstart
+
+Both `import pptk` and `import pptk_revived` work and are identical:
+
+```python
+import numpy as np
+import pptk  # or: import pptk_revived
+
+x = np.random.rand(100, 3)
+v = pptk.viewer(x)
+```
+
+Set point size to 0.01.
+
+```python
+v.set(point_size=0.01)
+```
+
+For more advanced examples, see [tutorials](https://heremaps.github.io/pptk/tutorial.html).
+
+## Build
+
+pptk-revived contains C++ extensions (Qt viewer, k-d tree, normal estimator)
+that must be compiled before packaging. The build process is:
+
+1. Compile C++ extensions with CMake
+2. Package the compiled artifacts into a wheel
+
+### System requirements
+
+* [Python](https://www.python.org/) 3.9+
+* [Qt5](https://www.qt.io/)
+* [TBB](https://github.com/oneapi-src/oneTBB) (libtbb-dev)
+* [Eigen](http://eigen.tuxfamily.org) 3.x (libeigen3-dev)
+* [Numpy](http://www.numpy.org/)
+* CMake 3.5+
+* patchelf (Linux only)
+
+On Ubuntu/Debian:
+
+```bash
+sudo apt install build-essential cmake patchelf libtbb-dev libeigen3-dev qtbase5-dev libqt5opengl5-dev
+```
+
+### Build with uv (recommended)
+
+```bash
+# 1. Compile C++ extensions
+mkdir _cmake_build && cd _cmake_build
+cmake .. -DCMAKE_BUILD_TYPE=Release
+cmake --build . -- -j$(nproc)
+cd ..
+
+# 2. Package into a wheel (uv detects the pre-compiled .so files and skips cmake)
+uv build
+
+# 3. Install the wheel
+uv pip install dist/pptk_revived-*.whl
+```
+
+### Build with pip / venv
+
+```bash
+# 1. Create a venv
+python3 -m venv venv && source venv/bin/activate
+pip install numpy
+
+# 2. Compile C++ extensions
+mkdir _cmake_build && cd _cmake_build
+cmake .. -DCMAKE_BUILD_TYPE=Release -DPython3_EXECUTABLE=$(which python)
+cmake --build . -- -j$(nproc)
+cd ..
+
+# 3. Package and install
+python setup.py bdist_wheel
+pip install dist/pptk_revived-*.whl --force-reinstall
+```
+
+### Windows
+
+```bat
+mkdir _cmake_build && cd _cmake_build
+cmake -G "NMake Makefiles" ..
+nmake
+cd ..
+python setup.py bdist_wheel
+pip install dist\pptk_revived-*.whl
+```

pptk_revived-0.1.1/cmake/CopyAppleDependencies.cmake

@@ -0,0 +1,41 @@
+# usage: cmake -P CopyAppleDependencies.cmake 
+#   <target file path> <copy folder path>
+# paths assumed to be existing full paths
+
+include(BundleUtilities)
+
+find_program(_install_name_tool "install_name_tool")
+set(_target ${CMAKE_ARGV3})
+set(_copy_folder ${CMAKE_ARGV4})
+set(_paths "/usr/bin")
+get_item_rpaths(${_target} _rpaths)
+get_prerequisites(${_target} _prereqs 1 1 "" "${_paths}" "${_rpaths}")
+
+# delete existing rpaths in _target and
+# add relative path to _copy_folder as new rpath
+foreach(p ${_rpaths})
+  execute_process(COMMAND ${_install_name_tool} -delete_rpath ${p} ${_target})
+endforeach()
+get_filename_component(_target_folder ${_target} DIRECTORY)
+file(RELATIVE_PATH _new_rpath ${_target_folder} ${_copy_folder})
+execute_process(COMMAND
+  ${_install_name_tool} -add_rpath "@loader_path/${_new_rpath}" ${_target})
+
+# copy _target's dependencies to _copy_folder
+foreach(p ${_prereqs})
+  get_filename_component(y ${p} NAME)
+  set(dst ${_copy_folder}/${y})
+  gp_resolve_item(${_target} ${p} "" "${_paths}" src "${_rpaths}")
+  execute_process(COMMAND ${CMAKE_COMMAND} -E copy_if_different ${src} ${dst})
+  execute_process(COMMAND ${_install_name_tool} -id @rpath/${y} ${dst})
+  if (IS_ABSOLUTE ${p})
+    execute_process(COMMAND ${_install_name_tool} -change ${p} @rpath/${y} ${_target})
+  endif()
+  get_prerequisites(${dst} _prereqs_of_prereqs 1 0 "" "")
+  foreach (pp ${_prereqs_of_prereqs})
+    get_filename_component(yy ${pp} NAME)
+    if (IS_ABSOLUTE ${pp})
+      execute_process(COMMAND ${_install_name_tool} -change ${pp} @rpath/${yy} ${dst})
+    endif()
+  endforeach()
+endforeach()

pptk_revived-0.1.1/cmake/CopyLinuxDependencies.cmake

@@ -0,0 +1,26 @@
+# usage: cmake -P CopyLinuxDependencies.cmake
+#   <target file (orig)> <target file (copy)> <libs folder> <patchelf path>
+# assumes full existing paths
+
+include(GetPrerequisites)
+
+set(_target_file_orig ${CMAKE_ARGV3})
+set(_target_file_copy ${CMAKE_ARGV4})
+set(_libs_folder ${CMAKE_ARGV5})
+set(_patchelf_cmd ${CMAKE_ARGV6})
+
+get_prerequisites(${_target_file_orig} _prereqs 1 1 "" "")
+foreach(p ${_prereqs})
+  gp_resolve_item("" ${p} "" "" src)
+  get_filename_component(x ${src} NAME)
+  set(dst ${_libs_folder}/${x})
+  execute_process(COMMAND
+    ${CMAKE_COMMAND} -E copy_if_different ${src} ${dst})
+  execute_process(COMMAND
+    ${_patchelf_cmd} --set-rpath \$ORIGIN ${dst})
+endforeach()
+
+get_filename_component(y ${_target_file_copy} DIRECTORY)
+file(RELATIVE_PATH _libs_folder_r ${y} ${_libs_folder})
+execute_process(COMMAND
+  ${_patchelf_cmd} --set-rpath \$ORIGIN/${_libs_folder_r} ${_target_file_copy})

pptk_revived-0.1.1/cmake/CopyWindowsDependencies.cmake

@@ -0,0 +1,19 @@
+# usage: cmake -P CopyWindowsDependencies.cmake
+#   <target file path> <copy folder path> <.dll folder paths>
+# assumes full existing paths
+# .dll folder paths are semicolon-separated
+
+include(GetPrerequisites)
+
+set(_target_file ${CMAKE_ARGV3})
+set(_copy_folder ${CMAKE_ARGV4})
+set(_dll_paths ${CMAKE_ARGV5})
+get_prerequisites(${_target_file} _prereqs 1 1 "" "${_dll_paths}")
+foreach(p ${_prereqs})
+  if(NOT (p MATCHES "python[0-9]*.dll"))
+    gp_resolve_item("" ${p} "" "${_dll_paths}" src)
+    set(dst ${_copy_folder})
+    execute_process(COMMAND
+      ${CMAKE_COMMAND} -E copy_if_different ${src} ${dst})
+  endif()
+endforeach()

pptk_revived-0.1.1/cmake/FindEigen.cmake

@@ -0,0 +1,6 @@
+include(FindPackageHandleStandardArgs)
+
+find_path(Eigen_INCLUDE_DIR Eigen/Core
+  PATHS /usr/include/eigen3 /usr/local/include/eigen3 /usr/include /usr/local/include)
+
+find_package_handle_standard_args(Eigen REQUIRED_VARS Eigen_INCLUDE_DIR)

pptk_revived-0.1.1/cmake/FindNumpy.cmake

@@ -0,0 +1,11 @@
+include(FindPackageHandleStandardArgs)
+
+if(NOT Numpy_INCLUDE_DIR)
+  execute_process(
+    COMMAND ${Python3_EXECUTABLE} -c "import numpy; print(numpy.get_include())"
+    OUTPUT_VARIABLE Numpy_INCLUDE_DIR
+    OUTPUT_STRIP_TRAILING_WHITESPACE
+    ERROR_QUIET)
+endif()
+
+find_package_handle_standard_args(Numpy REQUIRED_VARS Numpy_INCLUDE_DIR)

pptk_revived-0.1.1/cmake/FindTBB.cmake

@@ -0,0 +1,28 @@
+include(FindPackageHandleStandardArgs)
+
+find_path(TBB_INCLUDE_DIR tbb/tbb.h
+  PATHS /usr/include /usr/local/include)
+
+find_library(TBB_tbb_LIBRARY tbb
+  PATHS /usr/lib /usr/local/lib /usr/lib/x86_64-linux-gnu)
+
+find_library(TBB_tbbmalloc_LIBRARY tbbmalloc
+  PATHS /usr/lib /usr/local/lib /usr/lib/x86_64-linux-gnu)
+
+# On Linux/Mac the runtime library is the same as the link library
+if(WIN32)
+  find_file(TBB_tbb_RUNTIME tbb.dll)
+  find_file(TBB_tbbmalloc_RUNTIME tbbmalloc.dll)
+else()
+  set(TBB_tbb_RUNTIME ${TBB_tbb_LIBRARY} CACHE FILEPATH "Path to tbb runtime library")
+  set(TBB_tbbmalloc_RUNTIME ${TBB_tbbmalloc_LIBRARY} CACHE FILEPATH "Path to tbbmalloc runtime library")
+endif()
+
+find_package_handle_standard_args(TBB
+  REQUIRED_VARS
+    TBB_INCLUDE_DIR
+    TBB_tbb_LIBRARY
+    TBB_tbbmalloc_LIBRARY
+    TBB_tbb_RUNTIME
+    TBB_tbbmalloc_RUNTIME
+)

pptk_revived-0.1.1/cmake/UsefulMacros.cmake

@@ -0,0 +1,91 @@
+
+macro(set_target_python_module_name target)
+  set_target_properties(${target} PROPERTIES PREFIX "")
+  if (WIN32)
+    set_target_properties(${target} PROPERTIES SUFFIX ".pyd")
+  elseif(APPLE)
+    set_target_properties(${target} PROPERTIES SUFFIX ".so")
+  endif (WIN32)
+endmacro()
+
+macro(set_target_rpath target path)
+  if (APPLE)
+    set_target_properties(${target} PROPERTIES INSTALL_RPATH "@loader_path/${path}" BUILD_WITH_INSTALL_RPATH TRUE)
+  elseif (UNIX)
+    set_target_properties(${target} PROPERTIES INSTALL_RPATH "$ORIGIN/${path}" BUILD_WITH_INSTALL_RPATH TRUE)
+  endif(APPLE)
+endmacro()
+
+macro(copy_target x)
+  set(src $<TARGET_FILE:${x}>)
+  set(dst ${CMAKE_CURRENT_BINARY_DIR})
+  add_custom_command(
+    TARGET ${x}
+    POST_BUILD
+    COMMAND ${CMAKE_COMMAND} -E copy_if_different ${src} ${dst}
+    COMMENT "Copying ${src} to ${dst}")
+  unset(src)
+  unset(dst)
+endmacro()
+
+function(copy_target_dependencies x)
+  if(ARGC GREATER 1)
+    set(_target_file ${ARGV1})
+    get_filename_component(_target_file_name ${_target_file} NAME)
+  else()
+    set(_target_file $<TARGET_FILE:${x}>)
+    set(_target_file_name $<TARGET_FILE_NAME:${x}>)
+  endif()
+  if(WIN32)
+    add_custom_command(TARGET ${x} POST_BUILD
+      COMMAND ${CMAKE_COMMAND} -P
+        ${PROJECT_SOURCE_DIR}/cmake/CopyWindowsDependencies.cmake
+        ${CMAKE_CURRENT_BINARY_DIR}/${_target_file_name}
+        ${PPTK_LIBS_DIR} "${PPTK_DLL_DIRS}")
+  elseif(APPLE)
+    add_custom_command(TARGET ${x} POST_BUILD
+      COMMAND ${CMAKE_COMMAND} -P
+        ${PROJECT_SOURCE_DIR}/cmake/CopyAppleDependencies.cmake
+        ${CMAKE_CURRENT_BINARY_DIR}/${_target_file_name} ${PPTK_LIBS_DIR})
+  elseif(UNIX)
+    add_custom_command(TARGET ${x} POST_BUILD
+      COMMAND ${CMAKE_COMMAND} -P
+        ${PROJECT_SOURCE_DIR}/cmake/CopyLinuxDependencies.cmake
+        ${_target_file}
+        ${CMAKE_CURRENT_BINARY_DIR}/${_target_file_name}
+        ${PPTK_LIBS_DIR} ${PPTK_PATCHELF})
+  endif()
+endfunction()
+
+macro(current_source_dir x)
+  string(CONCAT ${x} "^" ${PROJECT_SOURCE_DIR} "/?")
+  string(REGEX REPLACE ${${x}} "" ${x} ${CMAKE_CURRENT_SOURCE_DIR})
+endmacro()
+
+function(copy_file x)
+  # x should be a file path, and should not be a variable
+  # i.e. copy_file(${var}), not copy_file(var)
+  get_filename_component(name ${x} NAME)
+  file(RELATIVE_PATH temp ${PROJECT_SOURCE_DIR} ${CMAKE_CURRENT_SOURCE_DIR})
+  if (NOT (temp STREQUAL ""))
+    string(REGEX REPLACE "(/|\\\\)" "." temp "${temp}")
+    string(CONCAT name "${temp}" "." "${name}")
+  endif()
+  if (ARGC EQUAL 2)
+    set(${ARGV1} ${name} PARENT_SCOPE)
+  endif()
+  if (NOT IS_ABSOLUTE ${x})
+    set(src ${CMAKE_CURRENT_SOURCE_DIR}/${x})
+  else()
+    set(src ${x})
+  endif()
+  set(dst ${CMAKE_CURRENT_BINARY_DIR})
+  add_custom_target(${name} ALL
+    COMMAND ${CMAKE_COMMAND} -E copy_if_different ${src} ${dst}
+    COMMENT "Copying ${src} to ${dst}")
+endfunction()
+
+function(copy_file_with_dependencies x)
+  copy_file(${x} _target_name)
+  copy_target_dependencies(${_target_name} ${x})
+endfunction()

pptk_revived-0.1.1/licenses/CMakeLists.txt

@@ -0,0 +1,32 @@
+
+macro(remove_header x)
+  string(REGEX REPLACE "^[^-]+" "" ${x} "${${x}}")
+endmacro(remove_header)
+
+macro(read_text x y)
+  file(READ ${x} ${y})
+  remove_header(${y})
+endmacro(read_text)
+
+macro(append_text x y)
+  # reads text in file specified by x, removes header from text,
+  # and then appends results to y
+  # assumes x is a file
+  read_text(${x} temp)
+  string(CONCAT ${y} "${${y}}" "${temp}")
+endmacro(append_text)
+
+if(WIN32)
+  read_text(LICENSE.win.txt added_text)
+elseif(APPLE)
+  read_text(LICENSE.mac.txt added_text)
+  append_text(COPYING.gcc_rle31.txt added_text)
+elseif(UNIX)
+  read_text(LICENSE.linux.txt added_text)
+endif()
+
+append_text(COPYING.lgpl3.txt added_text)
+append_text(COPYING.gpl3.txt added_text)
+append_text(COPYING.apache2.txt added_text)
+
+file(WRITE ${CMAKE_CURRENT_BINARY_DIR}/LICENSE.append.txt "${added_text}")