├── .clang-format
├── .clang-tidy
├── .gitignore
├── 3rdparty
└── 3es-core
│ └── 3esservermacros.h
├── CMakeLists.txt
├── LICENSE
├── OpenCL.md
├── clearance-performance-notes.md
├── clu
├── 3rdparty
│ └── CL
│ │ └── opencl.hpp
├── CMakeLists.txt
├── clu.cpp
├── clu.h
├── cluBuffer.h
├── cluConfig.in.h
├── cluConstraint.cpp
├── cluConstraint.h
├── cluKernel.cpp
├── cluKernel.h
├── cluProgram.cpp
└── cluProgram.h
├── cmake
├── ClangTidy.cmake
├── FindLASZIP.cmake
├── FindLIBLAS.cmake
├── FindOctomap.cmake
├── FindTBB.cmake
├── Findglm.cmake
├── LeakTrack.cmake
├── OhmCuda.cmake
├── OhmGTest.cmake
├── TextFileResource.cmake
├── TextFileResource.py
├── compilerSetup.cmake
├── doxyfile.in
├── doxygen.cmake
├── ohm-config.cmake
├── ohm-packages.cmake
├── tidy
│ ├── clang-tidy-names.yaml
│ └── wrap-clang-tidy.py
└── utils.cmake
├── docs
├── docglossary.md
├── docmain.h
├── docusage.md
├── docutils.md
├── docvoxellayers.md
└── gpu
│ ├── docgpualgorithm.md
│ └── docgpudetail.md
├── gputil
├── CMakeLists.txt
├── cl
│ ├── gpuApiExceptionCode.cpp
│ ├── gpuBuffer.cpp
│ ├── gpuBufferDetail.h
│ ├── gpuDevice.cpp
│ ├── gpuDeviceDetail.h
│ ├── gpuEvent.cpp
│ ├── gpuEventDetail.h
│ ├── gpuKernel.cpp
│ ├── gpuKernel2.h
│ ├── gpuKernelDetail.h
│ ├── gpuPinnedBuffer.cpp
│ ├── gpuPlatform2.h
│ ├── gpuProgram.cpp
│ ├── gpuProgramDetail.h
│ ├── gpuQueue.cpp
│ └── gpuQueueDetail.h
├── cuda
│ ├── cutil_atomic.h
│ ├── cutil_decl.h
│ ├── cutil_importcl.h
│ ├── cutil_math.h
│ ├── gpuApiExceptionCode.cpp
│ ├── gpuBuffer.cpp
│ ├── gpuBufferDetail.h
│ ├── gpuDevice.cpp
│ ├── gpuDeviceDetail.h
│ ├── gpuDirtyRegion
│ ├── gpuEvent.cpp
│ ├── gpuEventDetail.h
│ ├── gpuKernel.cpp
│ ├── gpuKernel2.h
│ ├── gpuKernelDetail.h
│ ├── gpuMemRegion.cpp
│ ├── gpuMemRegion.h
│ ├── gpuPinnedBuffer.cpp
│ ├── gpuPlatform2.h
│ ├── gpuProgram.cpp
│ ├── gpuProgramDetail.h
│ ├── gpuQueue.cpp
│ ├── gpuQueueDetail.h
│ └── ref.h
├── gpuApiException.cpp
├── gpuApiException.h
├── gpuBuffer.h
├── gpuConfig.in.h
├── gpuDevice.h
├── gpuDeviceInfo.h
├── gpuEvent.h
├── gpuEventList.cpp
├── gpuEventList.h
├── gpuException.cpp
├── gpuException.h
├── gpuKernel.h
├── gpuPinMode.h
├── gpuPinnedBuffer.h
├── gpuPlatform.h
├── gpuProgram.h
├── gpuQueue.h
├── gpuThrow.cpp
├── gpuThrow.h
├── gpuVersion.h
└── gpu_ext.h
├── logutil
├── CMakeLists.txt
├── LogUtil.cpp
├── LogUtil.h
├── LogUtilConfig.in.h
├── Logger.cpp
├── Logger.h
└── LoggerDetail.h
├── ohm.natvis
├── ohm
├── Aabb.h
├── CMakeLists.txt
├── CalculateSegmentKeys.cpp
├── CalculateSegmentKeys.h
├── ClearingPattern.cpp
├── ClearingPattern.h
├── CompareMaps.cpp
├── CompareMaps.h
├── CopyUtil.cpp
├── CopyUtil.h
├── CovarianceVoxel.cpp
├── CovarianceVoxel.h
├── CovarianceVoxelCompute.h
├── DataType.cpp
├── DataType.h
├── DebugDraw.cpp
├── DebugDraw.h
├── DebugIDs.h
├── DefaultLayer.cpp
├── DefaultLayer.h
├── Density.cpp
├── Density.h
├── Key.cpp
├── Key.h
├── KeyHash.cpp
├── KeyHash.h
├── KeyList.cpp
├── KeyList.h
├── KeyRange.cpp
├── KeyRange.h
├── KeyStream.h
├── LineKeysQuery.cpp
├── LineKeysQuery.h
├── LineQuery.cpp
├── LineQuery.h
├── LineWalk.h
├── LineWalkCompute.h
├── MapChunk.cpp
├── MapChunk.h
├── MapChunkFlag.h
├── MapCoord.h
├── MapFlag.cpp
├── MapFlag.h
├── MapInfo.cpp
├── MapInfo.h
├── MapLayer.cpp
├── MapLayer.h
├── MapLayout.cpp
├── MapLayout.h
├── MapLayoutMatch.h
├── MapProbability.h
├── MapRegion.cpp
├── MapRegion.h
├── MapRegionCache.cpp
├── MapRegionCache.h
├── MapSerialise.cpp
├── MapSerialise.h
├── Mapper.cpp
├── Mapper.h
├── MappingProcess.cpp
├── MappingProcess.h
├── Mutex.cpp
├── Mutex.h
├── NdtMap.cpp
├── NdtMap.h
├── NdtMode.cpp
├── NdtMode.h
├── NearestNeighbours.cpp
├── NearestNeighbours.h
├── OccupancyMap.cpp
├── OccupancyMap.h
├── OccupancyType.cpp
├── OccupancyType.h
├── OccupancyUtil.cpp
├── OccupancyUtil.h
├── OhmConfig.in.h
├── Query.cpp
├── Query.h
├── QueryFlag.h
├── RayFilter.cpp
├── RayFilter.h
├── RayFlag.h
├── RayMapper.cpp
├── RayMapper.h
├── RayMapperNdt.cpp
├── RayMapperNdt.h
├── RayMapperOccupancy.cpp
├── RayMapperOccupancy.h
├── RayMapperSecondarySample.cpp
├── RayMapperSecondarySample.h
├── RayMapperTrace.cpp
├── RayMapperTrace.h
├── RayMapperTsdf.cpp
├── RayMapperTsdf.h
├── RayPattern.cpp
├── RayPattern.h
├── RayPatternConical.cpp
├── RayPatternConical.h
├── RaysQuery.cpp
├── RaysQuery.h
├── Stream.cpp
├── Stream.h
├── Trace.cpp
├── Trace.h
├── Voxel.cpp
├── Voxel.h
├── VoxelBlock.cpp
├── VoxelBlock.h
├── VoxelBlockCompressionQueue.cpp
├── VoxelBlockCompressionQueue.h
├── VoxelBuffer.cpp
├── VoxelBuffer.h
├── VoxelData.h
├── VoxelIncident.h
├── VoxelIncidentCompute.h
├── VoxelLayout.cpp
├── VoxelLayout.h
├── VoxelMean.h
├── VoxelMeanCompute.h
├── VoxelOccupancy.h
├── VoxelOccupancyCompute.h
├── VoxelSecondarySample.h
├── VoxelTouchTime.h
├── VoxelTouchTimeCompute.h
├── VoxelTsdf.cpp
├── VoxelTsdf.h
├── VoxelTsdfCompute.h
├── private
│ ├── ClearingPatternDetail.h
│ ├── LineKeysQueryDetail.h
│ ├── LineQueryDetail.h
│ ├── MapLayerDetail.h
│ ├── MapLayoutDetail.h
│ ├── MapperDetail.h
│ ├── NdtMapDetail.h
│ ├── NearestNeighboursDetail.h
│ ├── OccupancyMapDetail.cpp
│ ├── OccupancyMapDetail.h
│ ├── OccupancyQueryAlg.h
│ ├── QueryDetail.h
│ ├── RayPatternDetail.h
│ ├── RaysQueryDetail.h
│ ├── SerialiseUtil.h
│ ├── VoxelAlgorithms.cpp
│ ├── VoxelAlgorithms.h
│ ├── VoxelBlockCompressionQueueDetail.h
│ └── VoxelLayoutDetail.h
└── serialise
│ ├── MapSerialiseV0.1.cpp
│ ├── MapSerialiseV0.1.h
│ ├── MapSerialiseV0.2.cpp
│ ├── MapSerialiseV0.2.h
│ ├── MapSerialiseV0.4.cpp
│ ├── MapSerialiseV0.4.h
│ ├── MapSerialiseV0.5.cpp
│ ├── MapSerialiseV0.5.h
│ ├── MapSerialiseV0.cpp
│ └── MapSerialiseV0.h
├── ohmapp
├── CMakeLists.txt
├── DataSource.cpp
├── DataSource.h
├── MapHarness.cpp
├── MapHarness.h
├── OhmAppConfig.in.h
├── OhmAppCpu.cpp
├── OhmAppCpu.h
├── OhmAppGpu.cpp
├── OhmAppGpu.h
├── OhmAppGpuConfig.in.h
├── SlamIOSource.cpp
├── SlamIOSource.h
└── ohmappmain.inl
├── ohmgpu
├── CMakeLists.txt
├── ClearanceProcess.cpp
├── ClearanceProcess.h
├── GpuCache.cpp
├── GpuCache.h
├── GpuCachePostSyncHandler.h
├── GpuCacheStats.h
├── GpuKey.h
├── GpuLayerCache.cpp
├── GpuLayerCache.h
├── GpuLayerCacheParams.cpp
├── GpuLayerCacheParams.h
├── GpuMap.cpp
├── GpuMap.h
├── GpuNdtMap.cpp
├── GpuNdtMap.h
├── GpuTransformSamples.cpp
├── GpuTransformSamples.h
├── GpuTsdfMap.cpp
├── GpuTsdfMap.h
├── LineKeysQueryGpu.cpp
├── LineKeysQueryGpu.h
├── LineQueryGpu.cpp
├── LineQueryGpu.h
├── OhmGpu.cpp
├── OhmGpu.h
├── OhmGpuConfig.in.h
├── RayItem.h
├── RaysQueryGpu.cpp
├── RaysQueryGpu.h
├── gpu
│ ├── AdjustNdt.cl
│ ├── AdjustOccupancy.cl
│ ├── CovarianceHitNdt.cl
│ ├── CovarianceHitNdt.cu
│ ├── CovarianceHitNdt_h.cl
│ ├── LineKeys.cl
│ ├── LineKeys.cu
│ ├── LineWalk.cl
│ ├── LineWalkMarkers.cl
│ ├── RaysQuery.cl
│ ├── RaysQuery.cu
│ ├── RaysQueryResult.h
│ ├── RegionUpdate.cl
│ ├── RegionUpdate.cu
│ ├── RegionUpdateNdt.cu
│ ├── Regions.cl
│ ├── RoiRangeFill.cl
│ ├── RoiRangeFill.cu
│ ├── TransformSamples.cl
│ ├── TransformSamples.cu
│ ├── Traversal.cl
│ ├── TsdfUpdate.cl
│ ├── TsdfUpdate.cu
│ ├── VoxelIncident.cl
│ └── VoxelMean.cl
└── private
│ ├── ClearanceProcessDetail.cpp
│ ├── ClearanceProcessDetail.h
│ ├── GpuMapDetail.cpp
│ ├── GpuMapDetail.h
│ ├── GpuNdtMapDetail.h
│ ├── GpuProgramRef.cpp
│ ├── GpuProgramRef.h
│ ├── GpuTransformSamplesDetail.h
│ ├── GpuTsdfMapDetail.h
│ ├── LineKeysQueryDetailGpu.h
│ ├── LineQueryDetailGpu.h
│ ├── RaysQueryDetailGpu.cpp
│ ├── RaysQueryDetailGpu.h
│ ├── RoiRangeFill.cpp
│ └── RoiRangeFill.h
├── ohmheightmap
├── 3rdparty
│ └── delaunator.hpp
├── CMakeLists.txt
├── Heightmap.cpp
├── Heightmap.h
├── HeightmapMesh.cpp
├── HeightmapMesh.h
├── HeightmapMode.cpp
├── HeightmapMode.h
├── HeightmapSerialise.cpp
├── HeightmapSerialise.h
├── HeightmapUtil.cpp
├── HeightmapUtil.h
├── HeightmapVoxel.cpp
├── HeightmapVoxel.h
├── HeightmapVoxelType.h
├── OhmHeightmapConfig.in.h
├── PlaneFillLayeredWalker.cpp
├── PlaneFillLayeredWalker.h
├── PlaneFillWalker.cpp
├── PlaneFillWalker.h
├── PlaneWalkVisitMode.h
├── PlaneWalker.cpp
├── PlaneWalker.h
├── TriangleEdge.h
├── TriangleNeighbours.h
├── UpAxis.h
└── private
│ ├── HeightmapDetail.cpp
│ ├── HeightmapDetail.h
│ ├── HeightmapOperations.cpp
│ └── HeightmapOperations.h
├── ohmheightmapimage
├── CMakeLists.txt
├── HeightmapImage.cpp
├── HeightmapImage.h
└── OhmHeightmapImageConfig.in.h
├── ohmtools
├── CMakeLists.txt
├── OhmCloud.cpp
├── OhmCloud.h
├── OhmGen.cpp
├── OhmGen.h
└── OhmToolsConfig.in.h
├── ohmutil
├── 3rdparty
│ ├── cxxopts
│ │ └── cxxopts.hpp
│ └── ska
│ │ ├── bytell_hash_map.hpp
│ │ ├── flat_hash_map.hpp
│ │ ├── ska_sort.hpp
│ │ └── unordered_map.hpp
├── CMakeLists.txt
├── Colour.cpp
├── Colour.h
├── GlmStream.h
├── OhmUtilConfig.in.h
├── Options.h
├── PlyMesh.cpp
├── PlyMesh.h
├── PlyPointStream.cpp
├── PlyPointStream.h
├── Profile.cpp
├── Profile.h
├── ProfileMarker.cpp
├── ProfileMarker.h
├── ProgressMonitor.cpp
├── ProgressMonitor.h
├── SafeIO.cpp
├── SafeIO.h
├── ScopedTimeDisplay.cpp
├── ScopedTimeDisplay.h
├── VectorHash.h
└── p2p.h
├── package.xml
├── readme.md
├── scripts
├── ohm-parse-timing.py
├── ohm-timing-run.py
└── setup.cfg
├── slamio
├── CMakeLists.txt
├── DataChannel.h
├── PointCloudReader.cpp
├── PointCloudReader.h
├── PointCloudReaderPdal.cpp
├── PointCloudReaderPdal.h
├── PointCloudReaderPly.cpp
├── PointCloudReaderPly.h
├── PointCloudReaderTraj.cpp
├── PointCloudReaderTraj.h
├── PointCloudReaderXyz.cpp
├── PointCloudReaderXyz.h
├── Points.cpp
├── Points.h
├── SlamCloudLoader.cpp
├── SlamCloudLoader.h
├── SlamIO.cpp
├── SlamIO.h
├── SlamIOConfig.in.h
├── pdal
│ ├── PointStream.cpp
│ └── PointStream.h
└── rply
│ ├── LICENSE
│ ├── rply.c
│ ├── rply.h
│ └── rplyfile.h
├── tests
├── CMakeLists.txt
├── data
│ ├── CMakeLists.txt
│ ├── readme.md
│ ├── test-map.0.1.0.ohm
│ ├── test-map.0.2.0.ohm
│ ├── test-map.0.3.0.ohm
│ ├── test-map.0.4.0.ohm
│ └── test-map.0.ohm
├── gputiltest
│ ├── CMakeLists.txt
│ ├── GpuBufferTest.cpp
│ ├── GpuDeviceTest.cpp
│ ├── KernelTest.cpp
│ ├── TestMain.cpp
│ ├── cuda
│ │ └── matrix_kernel.cu
│ └── matrix.cl
├── ohmtest
│ ├── CMakeLists.txt
│ ├── CompressionTests.cpp
│ ├── CopyTests.cpp
│ ├── IncidentsTests.cpp
│ ├── KeyTests.cpp
│ ├── LayoutTests.cpp
│ ├── LineQueryTests.cpp
│ ├── LineWalkTests.cpp
│ ├── MapTests.cpp
│ ├── MathsTests.cpp
│ ├── NdtTests.cpp
│ ├── OhmConfig.in.h
│ ├── OhmTestConfig.in.h
│ ├── RayPatternTests.cpp
│ ├── RayValidation.cpp
│ ├── RayValidation.h
│ ├── RaysQueryTests.cpp
│ ├── SecondarySampleTests.cpp
│ ├── SerialisationTests.cpp
│ ├── TestMain.cpp
│ ├── TouchTimeTests.cpp
│ ├── TraversalTests.cpp
│ ├── TsdfTests.cpp
│ └── VoxelMeanTests.cpp
├── ohmtestcommon
│ ├── CMakeLists.txt
│ ├── CovarianceTestUtil.cpp
│ ├── CovarianceTestUtil.h
│ ├── OhmTestUtil.cpp
│ ├── OhmTestUtil.h
│ ├── RayPatternTestUtil.h
│ ├── TraversalTest.cpp
│ ├── TraversalTest.h
│ ├── WalkSegmentKeysLegacy.cpp
│ └── WalkSegmentKeysLegacy.h
├── ohmtestgpu
│ ├── CMakeLists.txt
│ ├── GpuCopyTests.cpp
│ ├── GpuIncidentsTests.cpp
│ ├── GpuLineKeysTests.cpp
│ ├── GpuLineQueryTests.cpp
│ ├── GpuMapTest.cpp
│ ├── GpuMapperTests.cpp
│ ├── GpuNdtTests.cpp
│ ├── GpuRangesTests.cpp
│ ├── GpuRayPatternTests.cpp
│ ├── GpuRaysQueryTests.cpp
│ ├── GpuSerialisationTests.cpp
│ ├── GpuTestMain.cpp
│ ├── GpuTests.cpp
│ ├── GpuTouchTimeTests.cpp
│ ├── GpuTraversalTests.cpp
│ ├── GpuTsdfTests.cpp
│ └── GpuVoxelMeanTests.cpp
├── ohmtestheightmap
│ ├── CMakeLists.txt
│ └── HeightmapTests.cpp
└── slamiotest
│ ├── CMakeLists.txt
│ ├── Loader.cpp
│ └── SlamCloudLoader.cpp
├── todo.md
├── utils
├── CMakeLists.txt
├── ohm2ply
│ ├── CMakeLists.txt
│ └── ohm2ply.cpp
├── ohmcmp
│ ├── CMakeLists.txt
│ └── ohmcmp.cpp
├── ohmfilter
│ ├── CMakeLists.txt
│ └── ohmfilter.cpp
├── ohmheightmap
│ ├── CMakeLists.txt
│ └── ohmheightmap.cpp
├── ohmhm2img
│ ├── CMakeLists.txt
│ └── ohmhm2img.cpp
├── ohminfo
│ ├── CMakeLists.txt
│ └── ohminfo.cpp
├── ohmpop
│ ├── CMakeLists.txt
│ ├── OhmPopConfig.in.h
│ ├── ohmpopmaincpu.cpp
│ └── ohmpopmaingpu.cpp
├── ohmprob
│ ├── CMakeLists.txt
│ └── ohmprob.cpp
├── ohmquery
│ ├── CMakeLists.txt
│ ├── OhmQueryConfig.in.h
│ └── ohmquery.cpp
└── ohmsubmap
│ ├── CMakeLists.txt
│ └── ohmsubmap.cpp
└── vcpkg.json
/.gitignore:
--------------------------------------------------------------------------------
1 | .vscode/
2 | .vs/
3 | build*/
4 | # Visual Studio output directory for CMake projects.
5 | out/
6 | vcpkg_installed/
7 |
--------------------------------------------------------------------------------
/clu/cluConfig.in.h:
--------------------------------------------------------------------------------
1 | //
2 | // Project configuration header. This is a generated header; do not modify
3 | // it directly. Instead, modify the config.h.in version and run CMake again.
4 | //
5 | #ifndef CLUCONFIG_H
6 | #define CLUCONFIG_H
7 |
8 | #ifndef _USE_MATH_DEFINES
9 | #define _USE_MATH_DEFINES
10 | #endif // _USE_MATH_DEFINES
11 | #ifndef NOMINMAX
12 | #define NOMINMAX
13 | #endif // NOMINMAX
14 |
15 | #ifdef _MSC_VER
16 | // Avoid dubious security warnings for plenty of legitimate code
17 | #ifndef _SCL_SECURE_NO_WARNINGS
18 | #define _SCL_SECURE_NO_WARNINGS
19 | #endif // _SCL_SECURE_NO_WARNINGS
20 | #ifndef _CRT_SECURE_NO_WARNINGS
21 | #define _CRT_SECURE_NO_WARNINGS
22 | #endif // _CRT_SECURE_NO_WARNINGS
23 | //#define _CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES 1
24 | #endif // _MSC_VER
25 |
26 | // clang-format off
27 | #define CL_HPP_MINIMUM_OPENCL_VERSION 120
28 | #define CL_HPP_TARGET_OPENCL_VERSION @CLU_TARGET_OPENCL_VERSION@
29 | // clang-format on
30 |
31 | #endif // CLUCONFIG_H
32 |
--------------------------------------------------------------------------------
/cmake/FindLASZIP.cmake:
--------------------------------------------------------------------------------
1 | # This module searches LASzip and defines
2 | # LASZIP_LIBRARIES - link libraries
3 | # LASZIP_FOUND, if false, do not try to link
4 | # LASZIP_INCLUDE_DIR, where to find the headers
5 | #
6 | # $LASZIP_DIR is an environment variable that would
7 | # correspond to the ./configure --prefix=$LASZIP_DIR
8 |
9 | find_path(LASZIP_INCLUDE_DIR laszip.hpp HINTS ENV LASZIP_DIR PATH_SUFFIXES include/laszip)
10 |
11 | find_library(LASZIP_LIBRARY_DEBUG NAMES laszipd HINTS ENV LASZIP_DIR PATH_SUFFIXES lib)
12 | find_library(LASZIP_LIBRARY_RELEASE NAMES laszip HINTS ENV LASZIP_DIR PATH_SUFFIXES lib)
13 |
14 | find_file(LASZIP_RUNTIME_DEBUG NAMES laszipd${CMAKE_SHARED_LIBRARY_SUFFIX} HINTS ENV LASZIP_DIR PATH_SUFFIXES lib bin)
15 | find_file(LASZIP_RUNTIME_RELEASE NAMES laszip${CMAKE_SHARED_LIBRARY_SUFFIX} HINTS ENV LASZIP_DIR PATH_SUFFIXES lib bin)
16 |
17 | set(LASZIP_RUNTIME_DIRS)
18 | if(LASZIP_RUNTIME_DEBUG)
19 | get_filename_component(RUNTIME_DIR "${LASZIP_RUNTIME_DEBUG}" DIRECTORY)
20 | list(APPEND LASZIP_RUNTIME_DIRS "${RUNTIME_DIR}")
21 | endif(LASZIP_RUNTIME_DEBUG)
22 | if(LASZIP_RUNTIME_RELEASE)
23 | get_filename_component(RUNTIME_DIR "${LASZIP_RUNTIME_RELEASE}" DIRECTORY)
24 | list(APPEND LASZIP_RUNTIME_DIRS "${RUNTIME_DIR}")
25 | endif(LASZIP_RUNTIME_RELEASE)
26 | if(LASZIP_RUNTIME_DIRS)
27 | list(REMOVE_DUPLICATES LASZIP_RUNTIME_DIRS)
28 | endif(LASZIP_RUNTIME_DIRS)
29 | set(LASZIP_RUNTIME_DIRS "${LASZIP_RUNTIME_DIRS}" CACHE PATH "LASZIP runtime directories")
30 |
31 | if(LASZIP_LIBRARY_DEBUG)
32 | list(APPEND LASZIP_LIBRARIES debug ${LASZIP_LIBRARY_DEBUG})
33 | if(LASZIP_LIBRARY_RELEASE)
34 | list(APPEND LASZIP_LIBRARIES optimized ${LASZIP_LIBRARY_RELEASE})
35 | endif(LASZIP_LIBRARY_RELEASE)
36 | else(LASZIP_LIBRARY_DEBUG)
37 | list(APPEND LASZIP_LIBRARIES ${LASZIP_LIBRARY_RELEASE})
38 | endif(LASZIP_LIBRARY_DEBUG)
39 |
40 | # handle the QUIETLY and REQUIRED arguments and set LASZIP_FOUND to TRUE if
41 | # all listed variables are TRUE
42 | include(FindPackageHandleStandardArgs)
43 | FIND_PACKAGE_HANDLE_STANDARD_ARGS(LASZIP REQUIRED_VARS LASZIP_LIBRARIES LASZIP_INCLUDE_DIR)
44 |
45 | if(LASZIP_FOUND)
46 | mark_as_advanced(LASZIP_INCLUDE_DIR LASZIP_LIBRARIES LASZIP_RUNTIME_DIRS LASZIP_RUNTIME_DEBUG LASZIP_RUNTIME_RELEASE)
47 | endif(LASZIP_FOUND)
48 |
--------------------------------------------------------------------------------
/cmake/Findglm.cmake:
--------------------------------------------------------------------------------
1 |
2 | # FindGLM (OpenGL Mathematics library)
3 | # --------
4 | #
5 | # try to find include files.
6 | #
7 | # IMPORTED Targets
8 | # ^^^^^^^^^^^^^^^^
9 | #
10 | # This module defines the :prop_tgt:`IMPORTED` targets:
11 | #
12 | # ``glm::glm``
13 | # Defined if the system has OpenGL Mathematics headers.
14 | #
15 | # Result Variables
16 | # ^^^^^^^^^^^^^^^^
17 | #
18 | # This module sets the following variables:
19 | #
20 | # ::
21 | #
22 | # GLM_INCLUDE_DIRS, where to find glm/glm.hpp, etc.
23 | # glm_FOUND, If false, do not try to use GLM.
24 | # glm::glm, import target
25 |
26 | # Try config file first. This particular file is really only for supporting older GLM such as found on Ubuntu 18.04.
27 | # Newer GLM with config.cmake files is strongly recommended.
28 | find_package(glm QUIET CONFIG)
29 | if(NOT glm_FOUND)
30 | find_path(GLM_INCLUDE_DIRS NAMES glm/glm.hpp
31 | PATHS $ENV{GLM_ROOT_PATH}/include ${GLM_ROOT_PATH}/include
32 | /usr/local/include
33 | )
34 |
35 | mark_as_advanced(
36 | GLM_INCLUDE_DIRS
37 | )
38 | endif()
39 |
40 | # Note: glmConfig.cmake on Ubuntu 18.04 does not provide a target glm::glm.
41 | # 20.04 does.
42 | if(NOT TARGET glm::glm)
43 | add_library(glm::glm INTERFACE IMPORTED)
44 | set_target_properties(glm::glm PROPERTIES
45 | INTERFACE_INCLUDE_DIRECTORIES "${GLM_INCLUDE_DIRS}"
46 | )
47 | else()
48 | get_target_property(GLM_INCLUDE_DIRS glm::glm INTERFACE_INCLUDE_DIRECTORIES)
49 | endif()
50 |
51 | include(FindPackageHandleStandardArgs)
52 | FIND_PACKAGE_HANDLE_STANDARD_ARGS(glm REQUIRED_VARS GLM_INCLUDE_DIRS)
53 |
--------------------------------------------------------------------------------
/cmake/ohm-packages.cmake:
--------------------------------------------------------------------------------
1 | # Copyright (c) 2017
2 | # Commonwealth Scientific and Industrial Research Organisation (CSIRO)
3 | # ABN 41 687 119 230
4 | #
5 | # Author: Kazys Stepanas
6 |
7 | # Configure variables and include packages.
8 |
9 | # Find packages
10 | find_package(Threads)
11 | find_package(glm REQUIRED)
12 |
13 | if(OHM_FEATURE_THREADS)
14 | find_package(TBB CONFIG)
15 | endif(OHM_FEATURE_THREADS)
16 |
17 | if(NOT OHM_BUILD_SHARED)
18 | # We only need to propagate these packages for static ohm builds.
19 | if(OHM_TES_DEBUG)
20 | find_package(3es)
21 | endif(OHM_TES_DEBUG)
22 |
23 | if(OHM_FEATURE_PDAL)
24 | find_package(PDAL REQUIRED)
25 | endif(OHM_FEATURE_PDAL)
26 |
27 | find_package(ZLIB)
28 | endif(NOT OHM_BUILD_SHARED)
29 |
--------------------------------------------------------------------------------
/docs/docglossary.md:
--------------------------------------------------------------------------------
1 |
9 |
10 |
11 |
12 | @page docglossary OHM Glossary
13 | (val2);
43 | return true;
44 | }
45 |
46 |
47 | /// Explicitly typed stream reading.
48 | template
49 | inline bool read(InputStream &stream, S &val)
50 | {
51 | T val2{ 0 };
52 | if (stream.read(&val2, unsigned(sizeof(val2))) != sizeof(val2))
53 | {
54 | return false;
55 | }
56 | val = static_cast(val2);
57 | return true;
58 | }
59 | } // namespace ohm
60 |
61 | #endif // SERIALISEUTIL_H
62 |
--------------------------------------------------------------------------------
/ohm/private/VoxelLayoutDetail.h:
--------------------------------------------------------------------------------
1 | // Copyright (c) 2018
2 | // Commonwealth Scientific and Industrial Research Organisation (CSIRO)
3 | // ABN 41 687 119 230
4 | //
5 | // Author: Kazys Stepanas
6 | #ifndef OHM_VOXELLAYOUTDETAIL_H
7 | #define OHM_VOXELLAYOUTDETAIL_H
8 |
9 | #include "OhmConfig.h"
10 |
11 | #include
12 | #include
13 |
14 | namespace ohm
15 | {
16 | struct ohm_API VoxelMember
17 | {
18 | /// Voxel member name field. Sized to set the overall structure size to 64 bytes.
19 | std::array name; // NOLINT(readability-magic-numbers)
20 | uint64_t clear_value;
21 | uint16_t type;
22 | uint16_t offset;
23 | };
24 |
25 | struct ohm_API VoxelLayoutDetail
26 | {
27 | std::vector members;
28 | uint16_t next_offset = 0u;
29 | uint16_t voxel_byte_size = 0u;
30 | };
31 | } // namespace ohm
32 |
33 | #endif // OHM_VOXELLAYOUTDETAIL_H
34 |
--------------------------------------------------------------------------------
/ohm/serialise/MapSerialiseV0.1.h:
--------------------------------------------------------------------------------
1 | // Copyright (c) 2019
2 | // Commonwealth Scientific and Industrial Research Organisation (CSIRO)
3 | // ABN 41 687 119 230
4 | //
5 | // Author: Kazys Stepanas
6 | #ifndef MAPSERIALISEV0_1_H
7 | #define MAPSERIALISEV0_1_H
8 |
9 | #include "OhmConfig.h"
10 |
11 | #include
12 |
13 | namespace ohm
14 | {
15 | class InputStream;
16 | struct MapChunk;
17 | struct MapVersion;
18 | struct OccupancyMapDetail;
19 | class SerialiseProgress;
20 |
21 | using ChunkFunc = std::function;
22 |
23 | namespace v0_1
24 | {
25 | int load(InputStream &stream, OccupancyMapDetail &detail, SerialiseProgress *progress, const MapVersion &version,
26 | size_t region_count);
27 | int load(InputStream &stream, OccupancyMapDetail &detail, SerialiseProgress *progress, const MapVersion &version,
28 | size_t region_count, const ChunkFunc &load_chunk);
29 | int loadLayout(InputStream &stream, OccupancyMapDetail &map);
30 | int loadChunk(InputStream &stream, MapChunk &chunk, const OccupancyMapDetail &detail);
31 | } // namespace v0_1
32 | } // namespace ohm
33 |
34 | #endif // MAPSERIALISEV0_1_H
35 |
--------------------------------------------------------------------------------
/ohm/serialise/MapSerialiseV0.2.h:
--------------------------------------------------------------------------------
1 | // Copyright (c) 2019
2 | // Commonwealth Scientific and Industrial Research Organisation (CSIRO)
3 | // ABN 41 687 119 230
4 | //
5 | // Author: Kazys Stepanas
6 | #ifndef MAPSERIALISEV0_2_H
7 | #define MAPSERIALISEV0_2_H
8 |
9 | #include "OhmConfig.h"
10 |
11 | #include "MapSerialiseV0.1.h"
12 |
13 | namespace ohm
14 | {
15 | class InputStream;
16 | struct MapChunk;
17 | class MapInfo;
18 | class MapValue;
19 | struct MapVersion;
20 | struct OccupancyMapDetail;
21 | class SerialiseProgress;
22 |
23 | namespace v0_2
24 | {
25 | int load(InputStream &stream, OccupancyMapDetail &detail, SerialiseProgress *progress, const MapVersion &version,
26 | size_t region_count);
27 | int load(InputStream &stream, OccupancyMapDetail &detail, SerialiseProgress *progress, const MapVersion &version,
28 | size_t region_count, const ChunkFunc &load_chunk);
29 |
30 | int loadMapInfo(InputStream &in, MapInfo &info);
31 | int loadItem(InputStream &in, MapValue &value);
32 | } // namespace v0_2
33 | } // namespace ohm
34 |
35 | #endif // MAPSERIALISEV0_2_H
36 |
--------------------------------------------------------------------------------
/ohm/serialise/MapSerialiseV0.4.h:
--------------------------------------------------------------------------------
1 | // Copyright (c) 2019
2 | // Commonwealth Scientific and Industrial Research Organisation (CSIRO)
3 | // ABN 41 687 119 230
4 | //
5 | // Author: Kazys Stepanas
6 | #ifndef MAPSERIALISEV0_4_H
7 | #define MAPSERIALISEV0_4_H
8 |
9 | #include "OhmConfig.h"
10 |
11 | #include "MapSerialiseV0.1.h"
12 |
13 | namespace ohm
14 | {
15 | class InputStream;
16 | struct MapChunk;
17 | struct MapVersion;
18 | struct OccupancyMapDetail;
19 | class SerialiseProgress;
20 |
21 | namespace v0_4
22 | {
23 | int load(InputStream &stream, OccupancyMapDetail &detail, SerialiseProgress *progress, const MapVersion &version,
24 | size_t region_count);
25 |
26 | int load(InputStream &stream, OccupancyMapDetail &detail, SerialiseProgress *progress, const MapVersion &version,
27 | size_t region_count, const ChunkFunc &load_chunk);
28 |
29 | int loadChunk(InputStream &stream, MapChunk &chunk, const OccupancyMapDetail &detail);
30 | } // namespace v0_4
31 | } // namespace ohm
32 |
33 | #endif // MAPSERIALISEV0_3_H
34 |
--------------------------------------------------------------------------------
/ohm/serialise/MapSerialiseV0.5.cpp:
--------------------------------------------------------------------------------
1 | // Copyright (c) 2021
2 | // Commonwealth Scientific and Industrial Research Organisation (CSIRO)
3 | // ABN 41 687 119 230
4 | //
5 | // Author: Kazys Stepanas
6 | #include "MapSerialiseV0.5.h"
7 |
--------------------------------------------------------------------------------
/ohm/serialise/MapSerialiseV0.5.h:
--------------------------------------------------------------------------------
1 | // Copyright (c) 2021
2 | // Commonwealth Scientific and Industrial Research Organisation (CSIRO)
3 | // ABN 41 687 119 230
4 | //
5 | // Author: Kazys Stepanas
6 | #ifndef MAPSERIALISEV0_5_H
7 | #define MAPSERIALISEV0_5_H
8 |
9 | #include "OhmConfig.h"
10 |
11 | #include "MapSerialiseV0.4.h"
12 |
13 | namespace ohm
14 | {
15 | namespace v0_5
16 | {
17 | inline int load(InputStream &stream, OccupancyMapDetail &detail, SerialiseProgress *progress, const MapVersion &version,
18 | size_t region_count)
19 | {
20 | return v0_4::load(stream, detail, progress, version, region_count);
21 | }
22 | } // namespace v0_5
23 | } // namespace ohm
24 |
25 | #endif // MAPSERIALISEV0_3_H
26 |
--------------------------------------------------------------------------------
/ohm/serialise/MapSerialiseV0.h:
--------------------------------------------------------------------------------
1 | // Copyright (c) 2019
2 | // Commonwealth Scientific and Industrial Research Organisation (CSIRO)
3 | // ABN 41 687 119 230
4 | //
5 | // Author: Kazys Stepanas
6 | #ifndef MAPSERIALISEV0_H
7 | #define MAPSERIALISEV0_H
8 |
9 | #include "OhmConfig.h"
10 |
11 | namespace ohm
12 | {
13 | class InputStream;
14 | struct MapChunk;
15 | struct MapVersion;
16 | struct OccupancyMapDetail;
17 | class SerialiseProgress;
18 |
19 | namespace v0
20 | {
21 | int load(InputStream &stream, OccupancyMapDetail &detail, SerialiseProgress *progress, const MapVersion &version,
22 | size_t region_count);
23 | int loadChunk(InputStream &stream, MapChunk &chunk, const OccupancyMapDetail &detail);
24 | } // namespace v0
25 | } // namespace ohm
26 |
27 | #endif // MAPSERIALISEV0_H
28 |
--------------------------------------------------------------------------------
/ohmapp/OhmAppConfig.in.h:
--------------------------------------------------------------------------------
1 | //
2 | // Project configuration header. This is a generated header; do not modify
3 | // it directly. Instead, modify the config.h.in version and run CMake again.
4 | //
5 | #ifndef OHMAPPCONFIG_H
6 | #define OHMAPPCONFIG_H
7 |
8 | #include "OhmAppExport.h"
9 |
10 | #include
11 |
12 | #endif // OHMAPPCONFIG_H
13 |
--------------------------------------------------------------------------------
/ohmapp/OhmAppGpuConfig.in.h:
--------------------------------------------------------------------------------
1 | //
2 | // Project configuration header. This is a generated header; do not modify
3 | // it directly. Instead, modify the config.h.in version and run CMake again.
4 | //
5 | #ifndef OHMAPPGPUCONFIG_H
6 | #define OHMAPPGPUCONFIG_H
7 |
8 | #include "OhmAppGpuExport.h"
9 |
10 | #include
11 |
12 | #endif // OHMAPPGPUCONFIG_H
13 |
--------------------------------------------------------------------------------
/ohmapp/ohmappmain.inl:
--------------------------------------------------------------------------------
1 | // Copyright (c) 2021
2 | // Commonwealth Scientific and Industrial Research Organisation (CSIRO)
3 | // ABN 41 687 119 230
4 | //
5 | // Author: Kazys Stepanas
6 | //
7 | // Provdes a structure for an application which populates a map using MapHarness
8 | #include "MapHarness.h"
9 |
10 | #include
11 | #include
12 | #include
13 | #include
14 |
15 | namespace
16 | {
17 | /// Global cache of @c ohmapp::MapHarness::quitLevelPtr() updated in @c onSignal()
18 | unsigned *g_quit = nullptr;
19 |
20 | /// Handle @c SIGINT and @c SIGTERM by incrementing @c g_quit
21 | void onSignal(int arg)
22 | {
23 | if (arg == SIGINT || arg == SIGTERM)
24 | {
25 | if (g_quit)
26 | {
27 | ++(*g_quit);
28 | }
29 | }
30 | }
31 | } // namespace
32 |
33 | /// Main program implementation.
34 | ///
35 | /// @param argc Command line argument count.
36 | /// @param argv Command line arguments.
37 | /// @param populator Map generation option.
38 | int ohmappMain(int argc, const char *const *argv, ohmapp::MapHarness &populator)
39 | {
40 | g_quit = populator.quitLevelPtr();
41 | signal(SIGINT, onSignal);
42 | signal(SIGTERM, onSignal);
43 |
44 | std::cout.imbue(std::locale(""));
45 |
46 | int exit_code = populator.parseCommandLineOptions(argc, argv);
47 | if (exit_code)
48 | {
49 | return exit_code;
50 | }
51 |
52 | exit_code = populator.run();
53 | return exit_code;
54 | }
55 |
56 | /// Overload using the template type as a @c ohmapp::MapHarness .
57 | /// @param argc Command line argument count.
58 | /// @param argv Command line arguments.
59 | /// @param data_source Data source object.
60 | template
61 | int ohmappMain(int argc, const char *const *argv, std::shared_ptr data_source)
62 | {
63 | OhmPop populator(data_source);
64 | return ohmappMain(argc, argv, populator);
65 | }
66 |
67 | /// Overload using the template types as a @c ohmapp::MapHarness and @c ohmapp::DataSource .
68 | /// @param argc Command line argument count.
69 | /// @param argv Command line arguments.
70 | template
71 | int ohmappMain(int argc, const char *const *argv)
72 | {
73 | return ohmappMain(argc, argv, std::make_shared());
74 | }
75 |
--------------------------------------------------------------------------------
/ohmgpu/GpuCachePostSyncHandler.h:
--------------------------------------------------------------------------------
1 | // Copyright (c) 2019
2 | // Commonwealth Scientific and Industrial Research Organisation (CSIRO)
3 | // ABN 41 687 119 230
4 | //
5 | // Author: Kazys Stepanas
6 | #ifndef GPUCACHEPOSTSYNCHANDLER_H
7 | #define GPUCACHEPOSTSYNCHANDLER_H
8 |
9 | #include
10 |
11 | #include
12 |
13 | #include
14 |
15 | namespace ohm
16 | {
17 | struct MapChunk;
18 |
19 | using GpuCachePostSyncHandler = std::function;
20 | } // namespace ohm
21 |
22 | #endif // GPUCACHEPOSTSYNCHANDLER_H
23 |
--------------------------------------------------------------------------------
/ohmgpu/GpuCacheStats.h:
--------------------------------------------------------------------------------
1 | // Copyright (c) 2020
2 | // Commonwealth Scientific and Industrial Research Organisation (CSIRO)
3 | // ABN 41 687 119 230
4 | //
5 | // Author: Kazys Stepanas
6 | #ifndef OHMGPU_GPUCACHESTATS_H
7 | #define OHMGPU_GPUCACHESTATS_H
8 |
9 | #include "OhmGpuConfig.h"
10 |
11 | #include
12 |
13 | namespace ohm
14 | {
15 | /// Running stats on a @c GpuLayerCache .
16 | struct ohmgpu_API GpuCacheStats
17 | {
18 | uint32_t hits = 0; ///< Number of cache hits
19 | uint32_t misses = 0; ///< Number of cache misses.
20 | uint32_t full = 0; ///< Number of misses where the cache was full and something had to be dropped.
21 | };
22 | } // namespace ohm
23 |
24 | #endif // OHMGPU_GPUCACHESTATS_H
25 |
--------------------------------------------------------------------------------
/ohmgpu/GpuLayerCacheParams.cpp:
--------------------------------------------------------------------------------
1 | // Copyright (c) 2021
2 | // Commonwealth Scientific and Industrial Research Organisation (CSIRO)
3 | // ABN 41 687 119 230
4 | //
5 | // Author: Kazys Stepanas
6 | #include "GpuLayerCacheParams.h"
7 |
--------------------------------------------------------------------------------
/ohmgpu/GpuLayerCacheParams.h:
--------------------------------------------------------------------------------
1 | // Copyright (c) 2018
2 | // Commonwealth Scientific and Industrial Research Organisation (CSIRO)
3 | // ABN 41 687 119 230
4 | //
5 | // Author: Kazys Stepanas
6 | #ifndef GPULAYERCACHEPARAMS_H
7 | #define GPULAYERCACHEPARAMS_H
8 |
9 | #include "OhmGpuConfig.h"
10 |
11 | #include "GpuCachePostSyncHandler.h"
12 |
13 | #include
14 |
15 | namespace ohm
16 | {
17 | /// Flags used to create a @c GpuLayerCache.
18 | enum GpuLayerCacheFlag : unsigned
19 | {
20 | /// Will read voxel data from host to GPU memory.
21 | kGcfRead = (1u << 0u),
22 | /// Will write voxel data from GPU to host memory.
23 | kGcfWrite = (1u << 1u),
24 | /// Using buffers mappable to host memory? Can result in faster data transfer.
25 | kGcfMappable = (1u << 2u),
26 |
27 | /// Default creation flags.
28 | kGcfDefaultFlags = kGcfRead | kGcfMappable
29 | };
30 |
31 | /// Parameters used in creating a @c GpuCacheLayer in @c GpuCache::createCache().
32 | struct ohmgpu_API GpuLayerCacheParams
33 | {
34 | /// The size (bytes) of the GPU cache buffer. Use zero to choose the default size specified by the @c GpuCache.
35 | size_t gpu_mem_size = 0;
36 | /// The @c MapLayer index the cache pulls data from.
37 | int map_layer = 0;
38 | /// @c GpuLayerCacheFlag cache creation flags.
39 | unsigned flags = kGcfDefaultFlags;
40 | /// Callback invoked on synchronising memory back to CPU.
41 | /// The calling thread may not be the main thread, so the function must be threadsafe.
42 | GpuCachePostSyncHandler on_sync;
43 |
44 | /// Default constructor.
45 | inline GpuLayerCacheParams() = default;
46 | /// Construct with the given member values.
47 | /// @param mem_size Target GPU cache size.
48 | /// @param layer The @c MapLayer index which the GPU layer cache synchronised with.
49 | /// @param flags @c GpuLayerCacheFlag cache creation flags.
50 | /// @param on_sync Callback to invoke on synchronising back to CPU.
51 | inline GpuLayerCacheParams(size_t mem_size, int layer, unsigned flags,
52 | GpuCachePostSyncHandler on_sync = GpuCachePostSyncHandler())
53 | : gpu_mem_size(mem_size)
54 | , map_layer(layer)
55 | , flags(flags)
56 | , on_sync(std::move(on_sync))
57 | {}
58 | };
59 | } // namespace ohm
60 |
61 | #endif // GPULAYERCACHEPARAMS_H
62 |
--------------------------------------------------------------------------------
/ohmgpu/OhmGpuConfig.in.h:
--------------------------------------------------------------------------------
1 | //
2 | // Project configuration header. This is a generated header; do not modify
3 | // it directly. Instead, modify the config.h.in version and run CMake again.
4 | //
5 | #ifndef OHMGPUCONFIG_H
6 | #define OHMGPUCONFIG_H
7 |
8 | #include "OhmGpuExport.h"
9 |
10 | #include
11 |
12 | // clang-format off
13 |
14 | #define OHM_GPU_NONE 0
15 | #define OHM_GPU_OPENCL 1
16 | #define OHM_GPU_CUDA 2
17 |
18 | /// Target OpenCL standard. 'max' => maximum device version (min 1.2)
19 | #define OHM_OPENCL_STD "@OHM_OPENCL_STD@"
20 | /// OpenCL required features to enable OpenCL 2.0 code.
21 | #define OHM_OPENCL_2_FEATURES "@OHM_OPENCL_2_FEATURES@"
22 |
23 | // clang-format on
24 |
25 | #endif // OHMGPUCONFIG_H
26 |
--------------------------------------------------------------------------------
/ohmgpu/RaysQueryGpu.h:
--------------------------------------------------------------------------------
1 | // Copyright (c) 2021
2 | // Commonwealth Scientific and Industrial Research Organisation (CSIRO)
3 | // ABN 41 687 119 230
4 | //
5 | // Author: Kazys Stepanas
6 | #include "OhmGpuConfig.h"
7 |
8 | #include "GpuMap.h"
9 |
10 | #include
11 |
12 | namespace ohm
13 | {
14 | struct RaysQueryDetailGpu;
15 |
16 | /// A GPU implementation of the @c RaysQuery .
17 | ///
18 | /// The GPU overheads mean that this will be slower than the CPU implementation for low counts. GPU begins to outperform
19 | /// CPU when querying rays on the order of 2000 or more with significant benefits starting at 5000-10000 rays with ray
20 | /// lengths approximately 100 times the voxel resolution. Doubling the ray length may require an order of magnitude
21 | /// more sample rays to maintain GPU timing benefits.
22 | ///
23 | /// The actual timing results will vary depending on GPU API, GPU architecture, voxel size, query ray lengths and map
24 | /// environment.
25 | class ohmgpu_API RaysQueryGpu : public RaysQuery
26 | {
27 | protected:
28 | /// Constructor used for inherited objects. This supports deriving @p RaysQueryDetail into
29 | /// more specialised forms.
30 | /// @param detail pimple style data structure. When null, a @c RaysQueryDetail is allocated by
31 | /// this method.
32 | explicit RaysQueryGpu(RaysQueryDetailGpu *detail);
33 |
34 | public:
35 | /// Constructor. The map and rays must be set before using.
36 | RaysQueryGpu();
37 |
38 | /// Destructor.
39 | ~RaysQueryGpu() override;
40 |
41 | protected:
42 | void onSetMap() override;
43 | bool onExecute() override;
44 | bool onExecuteAsync() override;
45 | void onReset(bool hard_reset) override;
46 |
47 | /// Synchronise GPU results
48 | void sync();
49 |
50 | /// Internal pimpl data access.
51 | /// @return Pimpl data pointer.
52 | RaysQueryDetailGpu *imp();
53 | /// Internal pimpl data access.
54 | /// @return Pimpl data pointer.
55 | const RaysQueryDetailGpu *imp() const;
56 | };
57 | } // namespace ohm
58 |
--------------------------------------------------------------------------------
/ohmgpu/gpu/AdjustOccupancy.cl:
--------------------------------------------------------------------------------
1 | // Copyright (c) 2020
2 | // Commonwealth Scientific and Industrial Research Organisation (CSIRO)
3 | // ABN 41 687 119 230
4 | //
5 | // Author: Kazys Stepanas
6 | #ifndef ADJUSTOCCUPANCY_CL
7 | #define ADJUSTOCCUPANCY_CL
8 |
9 | inline __device__ float calculateOccupancyAdjustment(const GpuKey *voxel_key, const GpuKey *end_key, bool is_end_voxel,
10 | bool is_sample_voxel, float voxel_resolution,
11 | LineWalkData *line_data)
12 | {
13 | // We need to handle broken ray segments. They will come through with is_end_voxel true, but is_sample_voxel false.
14 | // We need to make a zero adjustment in that case.
15 | const float adjustment = (!is_sample_voxel || line_data->region_update_flags & kRfEndPointAsFree) ?
16 | line_data->ray_adjustment :
17 | line_data->sample_adjustment;
18 | return (is_end_voxel && !is_sample_voxel) ? 0 : adjustment;
19 | }
20 |
21 | #endif // ADJUSTOCCUPANCY_CL
22 |
--------------------------------------------------------------------------------
/ohmgpu/gpu/CovarianceHitNdt.cu:
--------------------------------------------------------------------------------
1 | // Copyright (c) 2017
2 | // Commonwealth Scientific and Industrial Research Organisation (CSIRO)
3 | // ABN 41 687 119 230
4 | //
5 | // Author: Kazys Stepanas
6 |
7 | #include
8 | #include
9 |
10 | #include "CovarianceHitNdt.cl"
11 |
12 | GPUTIL_CUDA_DEFINE_KERNEL(covarianceHitNdt);
13 |
--------------------------------------------------------------------------------
/ohmgpu/gpu/CovarianceHitNdt_h.cl:
--------------------------------------------------------------------------------
1 | // Copyright (c) 2021
2 | // Commonwealth Scientific and Industrial Research Organisation (CSIRO)
3 | // ABN 41 687 119 230
4 | //
5 | // Author: Kazys Stepanas
6 |
7 | #ifndef OHMGPU_COVARIANCE_HIT_HDT_H_
8 | #define OHMGPU_COVARIANCE_HIT_HDT_H_
9 |
10 | #include "CovarianceVoxelCompute.h"
11 | // #include "VoxelMeanCompute.h"
12 |
13 | // #include "Regions.cl"
14 |
15 | typedef struct WorkItem_t
16 | {
17 | CovarianceVoxel cov;
18 | // Voxel mean relative to the voxel centre.
19 | float3 mean;
20 | uint sample_count;
21 | float occupancy;
22 | } WorkItem;
23 |
24 | // forward declarations
25 |
26 | void __device__ collateSample(WorkItem *work_item, float3 sensor, float3 sample, int3 region_dimensions,
27 | float voxel_resolution, float sample_adjustment, float occupied_threshold,
28 | float sensor_noise, float reinitialise_cov_threshold,
29 | unsigned reinitialise_cov_sample_count);
30 |
31 |
32 | void __device__ collateSample(WorkItem *work_item, float3 sensor, float3 sample, int3 region_dimensions,
33 | float voxel_resolution, float sample_adjustment, float occupied_threshold,
34 | float sensor_noise, float reinitialise_cov_threshold,
35 | unsigned reinitialise_cov_sample_count)
36 | {
37 | // The sample is currently relative to the voxel centre of the end voxel. This is the same reference frame we need
38 | // to calculate the quantised mean, so no change is required.
39 | if (calculateHitWithCovariance(&work_item->cov, &work_item->occupancy, sample, work_item->mean,
40 | work_item->sample_count, sample_adjustment, INFINITY, voxel_resolution,
41 | reinitialise_cov_threshold, reinitialise_cov_sample_count))
42 | {
43 | // Covariance matrix has reset. Reset the point count to clear the mean value.
44 | work_item->sample_count = 0;
45 | }
46 |
47 | const float one_on_count_plus_one = 1.0f / (float)(work_item->sample_count + 1);
48 | work_item->mean = (work_item->sample_count * work_item->mean + sample) * one_on_count_plus_one;
49 | ++work_item->sample_count;
50 | }
51 |
52 | #endif // OHMGPU_COVARIANCE_HIT_HDT_H_
53 |
--------------------------------------------------------------------------------
/ohmgpu/gpu/LineKeys.cu:
--------------------------------------------------------------------------------
1 | // Copyright (c) 2017
2 | // Commonwealth Scientific and Industrial Research Organisation (CSIRO)
3 | // ABN 41 687 119 230
4 | //
5 | // Author: Kazys Stepanas
6 | #include
7 | #include
8 |
9 | #include "LineKeys.cl"
10 |
11 | GPUTIL_CUDA_DEFINE_KERNEL(calculateLines);
12 |
--------------------------------------------------------------------------------
/ohmgpu/gpu/LineWalkMarkers.cl:
--------------------------------------------------------------------------------
1 | // Copyright (c) 2022
2 | // Commonwealth Scientific and Industrial Research Organisation (CSIRO)
3 | // ABN 41 687 119 230
4 | //
5 | // Author: Kazys Stepanas
6 | #ifndef LINE_WALK_MARKERS_CL
7 | #define LINE_WALK_MARKERS_CL
8 |
9 | /// Flags affecting line walking
10 | typedef enum LineWalkFlag
11 | {
12 | /// No options set: default behaviour.
13 | kLineWalkFlagNone = 0u,
14 | /// Skip reporting the voxel containing the start point if different from the end point?
15 | kExcludeStartVoxel = (1u << 0u),
16 | /// Skip reporting the voxel containing the end point if different from the start point.
17 | kExcludeEndVoxel = (1u << 1u),
18 | /// Option for reverse line walking. The line walks the segment in reverse.
19 | kLineWalkFlagReverse = (1u << 2u),
20 | /// Option to force reporting the end voxel last in a reverse walk. This occurs normally when @p kLineWalkFlagReverse
21 | /// is not set.
22 | kLineWalkFlagForReportEndLast = (1u << 3u)
23 | } LineWalkFlag;
24 |
25 | #endif // LINE_WALK_MARKERS_CL
26 |
--------------------------------------------------------------------------------
/ohmgpu/gpu/RaysQuery.cu:
--------------------------------------------------------------------------------
1 | // Copyright (c) 2017
2 | // Commonwealth Scientific and Industrial Research Organisation (CSIRO)
3 | // ABN 41 687 119 230
4 | //
5 | // Author: Kazys Stepanas
6 |
7 | #include
8 | #include
9 |
10 | // Build base without voxel means
11 | #include "RaysQuery.cl"
12 |
13 | GPUTIL_CUDA_DEFINE_KERNEL(raysQuery);
14 |
--------------------------------------------------------------------------------
/ohmgpu/gpu/RaysQueryResult.h:
--------------------------------------------------------------------------------
1 | // Copyright (c) 2021
2 | // Commonwealth Scientific and Industrial Research Organisation (CSIRO)
3 | // ABN 41 687 119 230
4 | //
5 | // Author: Kazys Stepanas
6 | #ifndef OHMGPU_GPU_RAYQUERY_RESULT_H
7 | #define OHMGPU_GPU_RAYQUERY_RESULT_H
8 |
9 | #ifndef RQ_OccNull
10 | // TODO(KS): include OccupancyType.h or formalise the types.
11 | /// Invalid/null voxel.
12 | #define RQ_OccNull (-2)
13 | /// Unobserved: no data recorded or available for the voxel.
14 | #define RQ_OccUnobserved (-1)
15 | /// Know to be empty or free (traversable).
16 | #define RQ_OccFree (0)
17 | /// Occupied voxel.
18 | #define RQ_OccOccupied (1)
19 | #endif // RQ_OccNull
20 |
21 | /// Structure used to write results for a GpuRayQuery.
22 | typedef struct RaysQueryResult_t // NOLINT(readability-identifier-naming, modernize-use-using)
23 | {
24 | /// Range the ray successfully traverses.
25 | float range;
26 | /// Unobserved volume metric.
27 | float unobserved_volume;
28 | /// Occupancy type of the final voxel.
29 | int voxel_type;
30 | } RaysQueryResult;
31 |
32 | #endif // OHMGPU_GPU_RAYQUERY_RESULT_H
33 |
--------------------------------------------------------------------------------
/ohmgpu/gpu/RegionUpdate.cu:
--------------------------------------------------------------------------------
1 | // Copyright (c) 2017
2 | // Commonwealth Scientific and Industrial Research Organisation (CSIRO)
3 | // ABN 41 687 119 230
4 | //
5 | // Author: Kazys Stepanas
6 |
7 | #include
8 | #include
9 |
10 | // Build base without voxel means
11 | #include "RegionUpdate.cl"
12 |
13 | GPUTIL_CUDA_DEFINE_KERNEL(regionRayUpdateOccupancy);
14 |
--------------------------------------------------------------------------------
/ohmgpu/gpu/RegionUpdateNdt.cu:
--------------------------------------------------------------------------------
1 | // Copyright (c) 2020
2 | // Commonwealth Scientific and Industrial Research Organisation (CSIRO)
3 | // ABN 41 687 119 230
4 | //
5 | // Author: Kazys Stepanas
6 |
7 | #include
8 | #include
9 |
10 | // Build base with voxel means and NDT
11 | #define NDT
12 | #include "RegionUpdate.cl"
13 |
14 | GPUTIL_CUDA_DEFINE_KERNEL(regionRayUpdateNdt);
15 |
--------------------------------------------------------------------------------
/ohmgpu/gpu/RoiRangeFill.cu:
--------------------------------------------------------------------------------
1 | // Copyright (c) 2017
2 | // Commonwealth Scientific and Industrial Research Organisation (CSIRO)
3 | // ABN 41 687 119 230
4 | //
5 | // Author: Kazys Stepanas
6 |
7 | #include
8 | #include
9 |
10 | // Build base without voxel means
11 | #include "RoiRangeFill.cl"
12 |
13 | GPUTIL_CUDA_DEFINE_KERNEL(seedRegionVoxels);
14 | GPUTIL_CUDA_DEFINE_KERNEL(seedFromOuterRegions);
15 | GPUTIL_CUDA_DEFINE_KERNEL(propagateObstacles);
16 | GPUTIL_CUDA_DEFINE_KERNEL(migrateResults);
17 |
--------------------------------------------------------------------------------
/ohmgpu/gpu/TransformSamples.cu:
--------------------------------------------------------------------------------
1 | // Copyright (c) 2017
2 | // Commonwealth Scientific and Industrial Research Organisation (CSIRO)
3 | // ABN 41 687 119 230
4 | //
5 | // Author: Kazys Stepanas
6 |
7 | #include
8 | #include
9 |
10 | #include "TransformSamples.cl"
11 |
12 | GPUTIL_CUDA_DEFINE_KERNEL(transformTimestampedPoints);
13 |
--------------------------------------------------------------------------------
/ohmgpu/gpu/TsdfUpdate.cu:
--------------------------------------------------------------------------------
1 | // Copyright (c) 2021
2 | // Commonwealth Scientific and Industrial Research Organisation (CSIRO)
3 | // ABN 41 687 119 230
4 | //
5 | // Author: Kazys Stepanas
6 |
7 | #include
8 | #include
9 |
10 | // Build base without voxel means
11 | #include "TsdfUpdate.cl"
12 |
13 | GPUTIL_CUDA_DEFINE_KERNEL(tsdfRayUpdate);
14 |
--------------------------------------------------------------------------------
/ohmgpu/gpu/VoxelIncident.cl:
--------------------------------------------------------------------------------
1 | // Copyright (c) 2020
2 | // Commonwealth Scientific and Industrial Research Organisation (CSIRO)
3 | // ABN 41 687 119 230
4 | //
5 | // Author: Kazys Stepanas
6 |
7 | #include "VoxelIncidentCompute.h"
8 |
9 | /// Update the voxel mean pattern at @p target_address by including the bit(s) from @p pattern_to_add.
10 | /// This is done using atomic operations.
11 | ///
12 | /// Each bit in the pattern indicates occupancy at a particular voxel mean location.
13 | /// @param voxel The @c VoxelMean to update.
14 | /// @param incident_ray The incident ray from sensor to sample (un-normalised).
15 | /// @param sample_count How many samples in the voxel *before* adding the current one.
16 | __device__ void updateVoxelIncident(__global atomic_uint *voxel, float3 incident_ray, uint sample_count);
17 |
18 | #ifndef VOXEL_INCIDENT_CL
19 | #define VOXEL_INCIDENT_CL
20 |
21 | //------------------------------------------------------------------------------
22 | // Functions
23 | //------------------------------------------------------------------------------
24 |
25 | // Psuedo header guard to prevent function implementation duplication.
26 | inline __device__ void updateVoxelIncident(__global atomic_uint *voxel, float3 incident_ray, uint sample_count)
27 | {
28 | uint old_value;
29 | uint new_value;
30 |
31 | // Few iterations as it's less important to get this right.
32 | const int iteration_limit = 10;
33 | int iteration_count = 0;
34 |
35 | // First update the mean position, then the point count. There is a level of contension here, and the results may be
36 | // somewhat out.
37 | do
38 | {
39 | old_value = gputilAtomicLoadU32(voxel);
40 | new_value = updateIncidentNormal(old_value, incident_ray, sample_count);
41 | ++iteration_count;
42 | } while (!gputilAtomicCasU32(voxel, old_value, new_value) && iteration_limit < iteration_count);
43 | }
44 |
45 | #endif // VOXEL_INCIDENT_CL
46 |
--------------------------------------------------------------------------------
/ohmgpu/gpu/VoxelMean.cl:
--------------------------------------------------------------------------------
1 | // Copyright (c) 2020
2 | // Commonwealth Scientific and Industrial Research Organisation (CSIRO)
3 | // ABN 41 687 119 230
4 | //
5 | // Author: Kazys Stepanas
6 |
7 | /// Update the voxel mean pattern at @p target_address by including the bit(s) from @p pattern_to_add.
8 | /// This is done using atomic operations.
9 | ///
10 | /// Each bit in the pattern indicates occupancy at a particular voxel mean location.
11 | /// @param voxel The @c VoxelMean to update.
12 | /// @param sample_pos The sample position local to the centre of the voxel in falls in.
13 | /// @param voxel_resolution Voxel size.
14 | __device__ uint updateVoxelMeanPosition(__global VoxelMean *voxel, float3 sample_pos, float voxel_resolution);
15 |
16 | #ifndef VOXEL_MEAN_CL
17 | #define VOXEL_MEAN_CL
18 |
19 | //------------------------------------------------------------------------------
20 | // Functions
21 | //------------------------------------------------------------------------------
22 |
23 | // Psuedo header guard to prevent function implementation duplication.
24 | inline __device__ uint updateVoxelMeanPosition(__global VoxelMean *voxel, float3 sample_pos, float voxel_resolution)
25 | {
26 | uint point_count;
27 | uint old_value;
28 | uint new_value;
29 |
30 | // Few iterations as it's less important to get this right.
31 | const int iteration_limit = 10;
32 | int iteration_count = 0;
33 |
34 | // First update the mean position, then the point count. There is a level of contension here, and the results may be
35 | // somewhat out.
36 | do
37 | {
38 | // point_count = gputilAtomicLoadU32(&voxel->count);
39 | point_count = gputilAtomicLoadU32(&voxel->count);
40 | old_value = gputilAtomicLoadU32(&voxel->coord);
41 | new_value = subVoxelUpdate(old_value, point_count, sample_pos, voxel_resolution);
42 | ++iteration_count;
43 | } while (!gputilAtomicCasU32(&voxel->coord, old_value, new_value) && iteration_limit < iteration_count);
44 |
45 | // Atomic increment for the point count.
46 | return gputilAtomicInc(&voxel->count);
47 | }
48 |
49 | #endif // VOXEL_MEAN_CL
50 |
--------------------------------------------------------------------------------
/ohmgpu/private/ClearanceProcessDetail.cpp:
--------------------------------------------------------------------------------
1 | // Copyright (c) 2018
2 | // Commonwealth Scientific and Industrial Research Organisation (CSIRO)
3 | // ABN 41 687 119 230
4 | //
5 | // Author: Kazys Stepanas
6 | #include "ClearanceProcessDetail.h"
7 |
8 | #include
9 |
10 | #include
11 |
12 | namespace ohm
13 | {
14 | void ClearanceProcessDetail::getWork(OccupancyMap &map)
15 | {
16 | map.calculateDirtyClearanceExtents(&min_dirty_region, &max_dirty_region, 1);
17 | current_dirty_cursor = min_dirty_region;
18 | }
19 |
20 |
21 | void ClearanceProcessDetail::stepCursor(const glm::i16vec3 &step)
22 | {
23 | if (current_dirty_cursor.x < max_dirty_region.x)
24 | {
25 | current_dirty_cursor.x = std::min(current_dirty_cursor.x + step.x, max_dirty_region.x);
26 | }
27 | else
28 | {
29 | current_dirty_cursor.x = min_dirty_region.x;
30 | if (current_dirty_cursor.y < max_dirty_region.y)
31 | {
32 | current_dirty_cursor.y = std::min(current_dirty_cursor.y + step.y, max_dirty_region.y);
33 | }
34 | else
35 | {
36 | current_dirty_cursor.y = min_dirty_region.y;
37 | if (current_dirty_cursor.z < max_dirty_region.z)
38 | {
39 | current_dirty_cursor.z = std::min(current_dirty_cursor.z + step.z, max_dirty_region.z);
40 | }
41 | else
42 | {
43 | current_dirty_cursor = max_dirty_region + glm::i16vec3(1);
44 | }
45 | }
46 | }
47 | }
48 | } // namespace ohm
49 |
--------------------------------------------------------------------------------
/ohmgpu/private/ClearanceProcessDetail.h:
--------------------------------------------------------------------------------
1 | // Copyright (c) 2017
2 | // Commonwealth Scientific and Industrial Research Organisation (CSIRO)
3 | // ABN 41 687 119 230
4 | //
5 | // Author: Kazys Stepanas
6 | #ifndef OHMGPU_CLEARANCEPROCESSEDETAIL_H
7 | #define OHMGPU_CLEARANCEPROCESSEDETAIL_H
8 |
9 | #include "OhmGpuConfig.h"
10 |
11 | #include
12 |
13 | #include "RoiRangeFill.h"
14 |
15 | #include
16 |
17 | // #define CACHE_LOCAL_RESULTS
18 | // #define VALIDATE_KEYS
19 |
20 | namespace ohm
21 | {
22 | class OccupancyMap;
23 | struct MapChunk;
24 |
25 | struct ClearanceProcessDetail
26 | {
27 | unsigned query_flags = 0;
28 | glm::vec3 axis_scaling = glm::vec3(1);
29 | glm::i16vec3 min_dirty_region = glm::i16vec3(1);
30 | glm::i16vec3 max_dirty_region = glm::i16vec3(0);
31 | glm::i16vec3 current_dirty_cursor = glm::i16vec3(0);
32 | /// Last value of the @c OccupancyMap::stamp(). Used to see if the cache needs to be cleared.
33 | uint64_t map_stamp = 0;
34 | float search_radius = 0;
35 |
36 | std::unique_ptr gpu_query;
37 |
38 | inline bool haveWork() const
39 | {
40 | return glm::all(glm::lessThanEqual(min_dirty_region, max_dirty_region)) &&
41 | glm::all(glm::lessThanEqual(current_dirty_cursor, max_dirty_region));
42 | }
43 |
44 | inline void resetWorking()
45 | {
46 | min_dirty_region = glm::i16vec3(1);
47 | max_dirty_region = current_dirty_cursor = glm::i16vec3(0);
48 | map_stamp = 0;
49 | }
50 |
51 | void stepCursor(const glm::i16vec3 &step = glm::i16vec3(1));
52 |
53 | void getWork(OccupancyMap &map);
54 | };
55 | } // namespace ohm
56 |
57 | #endif // OHMGPU_CLEARANCEPROCESSEDETAIL_H
58 |
--------------------------------------------------------------------------------
/ohmgpu/private/GpuNdtMapDetail.h:
--------------------------------------------------------------------------------
1 | // Copyright (c) 2020
2 | // Commonwealth Scientific and Industrial Research Organisation (CSIRO)
3 | // ABN 41 687 119 230
4 | //
5 | // Author: Kazys Stepanas
6 | #ifndef GPUNDTMAPDETAIL_H
7 | #define GPUNDTMAPDETAIL_H
8 |
9 | #include "OhmGpuConfig.h"
10 |
11 | #include "private/GpuMapDetail.h"
12 |
13 | #include
14 | #include
15 |
16 | namespace ohm
17 | {
18 | struct GpuNdtMapDetail : public GpuMapDetail
19 | {
20 | GpuProgramRef *cov_hit_program_ref = nullptr;
21 | gputil::Kernel cov_hit_kernel;
22 | NdtMap ndt_map;
23 |
24 | /// Index into @c voxel_upload_info buffers at which we have the @c VoxelUploadInfo for the covariance layer.
25 | int cov_uidx = -1;
26 | /// Index into @c voxel_upload_info buffers at which we have the @c VoxelUploadInfo for the intensity layer.
27 | int intensity_uidx = -1;
28 | /// Index into @c voxel_upload_info buffers at which we have the @c VoxelUploadInfo for the hit/hiss layer.
29 | int hit_miss_uidx = -1;
30 |
31 | GpuNdtMapDetail(OccupancyMap *map, bool borrowed_map, NdtMode mode)
32 | : GpuMapDetail(map, borrowed_map)
33 | , ndt_map(map, true, mode) // Ensures correct initialisation for NDT operations.
34 | {}
35 | };
36 | } // namespace ohm
37 |
38 | #endif // GPUNDTMAPDETAIL_H
39 |
--------------------------------------------------------------------------------
/ohmgpu/private/GpuTransformSamplesDetail.h:
--------------------------------------------------------------------------------
1 | // Copyright (c) 2018
2 | // Commonwealth Scientific and Industrial Research Organisation (CSIRO)
3 | // ABN 41 687 119 230
4 | //
5 | // Author: Kazys Stepanas
6 | #include "OhmGpuConfig.h"
7 |
8 | #include
9 | #include
10 | #include
11 | #include
12 |
13 | #include
14 |
15 | namespace ohm
16 | {
17 | struct GpuTransformSamplesDetail
18 | {
19 | static const unsigned kUploadEventCount = 4;
20 |
21 | gputil::Buffer transform_positions_buffer;
22 | gputil::Buffer transform_rotations_buffer;
23 | gputil::Buffer transform_times_buffer;
24 | std::array upload_events;
25 | gputil::Device gpu;
26 | gputil::Kernel kernel;
27 | };
28 | } // namespace ohm
29 |
--------------------------------------------------------------------------------
/ohmgpu/private/GpuTsdfMapDetail.h:
--------------------------------------------------------------------------------
1 | // Copyright (c) 2021
2 | // Commonwealth Scientific and Industrial Research Organisation (CSIRO)
3 | // ABN 41 687 119 230
4 | //
5 | // Author: Kazys Stepanas
6 | #ifndef GPUTSDFMAPDETAIL_H
7 | #define GPUTSDFMAPDETAIL_H
8 |
9 | #include "OhmGpuConfig.h"
10 |
11 | #include "private/GpuMapDetail.h"
12 |
13 | #include
14 |
15 | namespace ohm
16 | {
17 | struct GpuTsdfMapDetail : public GpuMapDetail
18 | {
19 | /// Index into @c voxel_upload_info buffers at which we have the @c VoxelUploadInfo for the tsdf layer.
20 | int tsdf_uidx = -1;
21 | /// Tsdf mapping options.
22 | TsdfOptions tsdf_options;
23 |
24 | GpuTsdfMapDetail(OccupancyMap *map, bool borrowed_map)
25 | : GpuMapDetail(map, borrowed_map)
26 | {
27 | // Require original samples for TSDF for the distance calculations.
28 | use_original_ray_buffers = true;
29 | }
30 | };
31 | } // namespace ohm
32 |
33 | #endif // GPUTSDFMAPDETAIL_H
34 |
--------------------------------------------------------------------------------
/ohmgpu/private/LineKeysQueryDetailGpu.h:
--------------------------------------------------------------------------------
1 |
2 | // Copyright (c) 2017
3 | // Commonwealth Scientific and Industrial Research Organisation (CSIRO)
4 | // ABN 41 687 119 230
5 | //
6 | // Author: Kazys Stepanas
7 | #ifndef OHMGPU_LINEKEYSQUERYDETAILGPU_H_
8 | #define OHMGPU_LINEKEYSQUERYDETAILGPU_H_OHMGPU_LINEKEYSQUERYDETAILGPU_HOHMGPU_LINEKEYSQUERYDETAILGPU_H_
9 |
10 | #include "OhmGpuConfig.h"
11 |
12 | #include
13 |
14 | // Include GPU structure definition.
15 | #include "GpuKey.h"
16 |
17 | #include
18 | #include
19 | #include
20 | #include
21 |
22 | #include
23 |
24 | namespace ohm
25 | {
26 | struct LineKeysQueryDetailGpu : public LineKeysQueryDetail
27 | {
28 | gputil::Kernel line_keys_kernel;
29 | gputil::Device gpu;
30 |
31 | gputil::Queue queue;
32 |
33 | gputil::Buffer lines_out;
34 | gputil::Buffer line_points;
35 | unsigned max_keys_per_line = 0;
36 | std::atomic_bool inflight{ false };
37 |
38 | bool gpu_ok = false;
39 | };
40 | } // namespace ohm
41 |
42 | #endif // OHMGPU_LINEKEYSQUERYDETAILGPU_H_
43 |
--------------------------------------------------------------------------------
/ohmgpu/private/LineQueryDetailGpu.h:
--------------------------------------------------------------------------------
1 | // Copyright (c) 2017
2 | // Commonwealth Scientific and Industrial Research Organisation (CSIRO)
3 | // ABN 41 687 119 230
4 | //
5 | // Author: Kazys Stepanas
6 | #ifndef OHMGPU_LINEQUERYDETAILGPU_H
7 | #define OHMGPU_LINEQUERYDETAILGPU_H
8 |
9 | #include "OhmGpuConfig.h"
10 |
11 | #include
12 |
13 | #include
14 |
15 | namespace ohm
16 | {
17 | class ClearanceProcess;
18 |
19 | struct LineQueryDetailGpu : LineQueryDetail
20 | {
21 | ClearanceProcess *clearance_calculator = nullptr;
22 | };
23 | } // namespace ohm
24 |
25 | #endif // OHMGPU_LINEQUERYDETAILGPU_H
26 |
--------------------------------------------------------------------------------
/ohmheightmap/HeightmapMode.cpp:
--------------------------------------------------------------------------------
1 | // Copyright (c) 2021
2 | // Commonwealth Scientific and Industrial Research Organisation (CSIRO)
3 | // ABN 41 687 119 230
4 | //
5 | // Author: Kazys Stepanas
6 | #include "HeightmapMode.h"
7 |
8 | #include
9 |
10 | namespace ohm
11 | {
12 | namespace
13 | {
14 | static const std::array mode_names = //
15 | {
16 | //
17 | "planar", //
18 | "fill", //
19 | "layered-unordered", //
20 | "layered", //
21 | };
22 | }
23 |
24 | std::string heightmapModeToString(HeightmapMode mode)
25 | {
26 | if (size_t(mode) < mode_names.size())
27 | {
28 | return mode_names[int(mode)];
29 | }
30 |
31 | return "";
32 | }
33 | HeightmapMode heightmapModeFromString(const std::string &str, bool *valid_string)
34 | {
35 | int mode_index = 0;
36 | for (const auto &name : mode_names)
37 | {
38 | if (str == name)
39 | {
40 | if (valid_string)
41 | {
42 | *valid_string = true;
43 | }
44 | return HeightmapMode(mode_index);
45 | }
46 | ++mode_index;
47 | }
48 |
49 | if (valid_string)
50 | {
51 | *valid_string = false;
52 | }
53 | return HeightmapMode::kPlanar;
54 | }
55 | } // namespace ohm
56 |
--------------------------------------------------------------------------------
/ohmheightmap/HeightmapMode.h:
--------------------------------------------------------------------------------
1 | // Copyright (c) 2020
2 | // Commonwealth Scientific and Industrial Research Organisation (CSIRO)
3 | // ABN 41 687 119 230
4 | //
5 | // Author: Kazys Stepanas
6 |
7 | #ifndef OHMHEIGHTMAP_HEIGHTMAPMODE_H
8 | #define OHMHEIGHTMAP_HEIGHTMAPMODE_H
9 |
10 | #include "OhmHeightmapConfig.h"
11 |
12 | #include
13 |
14 | namespace ohm
15 | {
16 | /// Enumeration of the available heightmap generation modes.
17 | enum class HeightmapMode
18 | {
19 | /// Simple planar traversal from the reference position. Heightmap grid cells are only visited once each.
20 | kPlanar,
21 | /// Use a simple flood fill out from the reference position. The resulting heightmap may have better continuity than
22 | /// @c kPlanar. Voxels may be revisited when a lower candidate voxel is found.
23 | kSimpleFill,
24 | /// Use a flood fill which supports layering. The fill attempts to expand on all available surfaces and can generate
25 | /// a multi layer heightmap. The resulting heightmap is 2.5D and each column can contain multiple entries. The height
26 | /// values of entries in each column are unsorted with undefined height ordering.
27 | kLayeredFillUnordered,
28 | /// Same as @c kLayeredFillUnordered except that the resulting heightmap ensures each column of voxels in the
29 | /// generated heightmap are in ascending height order.
30 | kLayeredFill,
31 |
32 | /// First mode value
33 | kFirst = kPlanar,
34 | /// Last mode value.
35 | kLast = kLayeredFill
36 | };
37 |
38 | /// Convert a @c HeightmapMode to a string.
39 | /// @param mode The mode value to convert.
40 | /// @return The string name for @p mode or `""` if @p mode is out of range.
41 | std::string ohmheightmap_API heightmapModeToString(HeightmapMode mode);
42 | /// Convert a string to a @c HeightampMode - reverse of @c heightmapModeToString().
43 | /// @param str The string to convert.
44 | /// @param valid_string Optional - set to true if @p str is a valid mode name, false otherwise.
45 | /// @return The mode matching @p str or @c HeightmapMode::kPlanar when @p str is not a valid mode name.
46 | HeightmapMode ohmheightmap_API heightmapModeFromString(const std::string &str, bool *valid_string = nullptr);
47 | } // namespace ohm
48 |
49 | #endif // OHMHEIGHTMAP_HEIGHTMAPMODE_H
50 |
--------------------------------------------------------------------------------
/ohmheightmap/HeightmapSerialise.cpp:
--------------------------------------------------------------------------------
1 | // Copyright (c) 2021
2 | // Commonwealth Scientific and Industrial Research Organisation (CSIRO)
3 | // ABN 41 687 119 230
4 | //
5 | // Author: Kazys Stepanas
6 | #include "HeightmapSerialise.h"
7 |
8 | #include "Heightmap.h"
9 |
10 | #include "private/HeightmapDetail.h"
11 |
12 | #include
13 | #include
14 |
15 | namespace
16 | {
17 | struct RegisterExtensionCodes
18 | {
19 | RegisterExtensionCodes()
20 | {
21 | ohm::registerSerialiseExtensionErrorCodeString(int(ohm::kSeHeightmapInfoMismatch), "heightmap info mismatch");
22 | }
23 | };
24 |
25 | const RegisterExtensionCodes s_register_heightmap_errors;
26 | } // namespace
27 |
28 | namespace ohm
29 | {
30 | int load(const std::string &filename, Heightmap &heightmap, SerialiseProgress *progress, MapVersion *version_out)
31 | {
32 | HeightmapDetail &detail = *heightmap.detail();
33 |
34 | int err = load(filename, *detail.heightmap, progress, version_out);
35 | if (err)
36 | {
37 | return err;
38 | }
39 |
40 | // TODO(KS): Set axis from map info.
41 | const MapInfo &info = detail.heightmap->mapInfo();
42 | if (!bool(info.get("heightmap")))
43 | {
44 | return kSeHeightmapInfoMismatch;
45 | }
46 |
47 | detail.fromMapInfo(info);
48 |
49 | return err;
50 | }
51 | } // namespace ohm
52 |
--------------------------------------------------------------------------------
/ohmheightmap/HeightmapSerialise.h:
--------------------------------------------------------------------------------
1 | // Copyright (c) 2021
2 | // Commonwealth Scientific and Industrial Research Organisation (CSIRO)
3 | // ABN 41 687 119 230
4 | //
5 | // Author: Kazys Stepanas
6 | #ifndef OHMHEIGHTMAP_HEIGHTMAPMAPSERIALISE_H
7 | #define OHMHEIGHTMAP_HEIGHTMAPMAPSERIALISE_H
8 |
9 | #include "OhmHeightmapConfig.h"
10 |
11 | #include
12 |
13 | #include
14 |
15 | #include
16 | #include
17 |
18 | namespace ohm
19 | {
20 | class Heightmap;
21 |
22 | /// An enumeration of potential serialisation errors.
23 | enum HeightmapSerialisationError
24 | {
25 | /// @c MapInfo does not represent a heightmap.
26 | kSeHeightmapInfoMismatch = kSeExtensionCode + 1,
27 | };
28 |
29 | /// Load a save heightmap into a @c Heightmap object. Saving can be done directly on the @c Occupancy map stored in
30 | /// @c Heightmap::heightmap() .
31 | /// @param filename The heightmap file path to load.
32 | /// @param heightmap The heightmap object to load into.
33 | /// @param progress Optional progress reporting interface.
34 | /// @param[out] version_out Set to the map file version number if provided.
35 | int ohmheightmap_API load(const std::string &filename, Heightmap &heightmap, SerialiseProgress *progress = nullptr,
36 | MapVersion *version_out = nullptr);
37 | } // namespace ohm
38 |
39 | #endif // OHMHEIGHTMAP_HEIGHTMAPMAPSERIALISE_H
40 |
--------------------------------------------------------------------------------
/ohmheightmap/HeightmapVoxel.cpp:
--------------------------------------------------------------------------------
1 | // Copyright (c) 2018
2 | // Commonwealth Scientific and Industrial Research Organisation (CSIRO)
3 | // ABN 41 687 119 230
4 | //
5 | // Author: Kazys Stepanas
6 | #include "HeightmapVoxel.h"
7 |
8 | namespace ohm
9 | {
10 | const char *const HeightmapVoxel::kHeightmapLayer = "heightmap";
11 | const char *const HeightmapVoxel::kHeightmapBuildLayer = "heightmap_build";
12 | } // namespace ohm
13 |
--------------------------------------------------------------------------------
/ohmheightmap/HeightmapVoxelType.h:
--------------------------------------------------------------------------------
1 | // Copyright (c) 2020
2 | // Commonwealth Scientific and Industrial Research Organisation (CSIRO)
3 | // ABN 41 687 119 230
4 | //
5 | // Author: Kazys Stepanas
6 | #ifndef OHMHEIGHTMAP_HEIGHTMAP_VOXEL_TYPE_H_
7 | #define OHMHEIGHTMAP_HEIGHTMAP_VOXEL_TYPE_H_
8 |
9 | #include "OhmHeightmapConfig.h"
10 |
11 | namespace ohm
12 | {
13 | /// Type enumeration for voxels in a heightmap.
14 | enum class HeightmapVoxelType : uint8_t
15 | {
16 | /// Unkown or unobserved voxel.
17 | kUnknown = 0,
18 | /// A voxel which is being kept forcibly vacant. Normally this represents voxels which have yet to be able to
19 | /// observed at the startup location.
20 | kVacant,
21 | /// Represents a real surface voxel in the heightmap.
22 | kSurface,
23 | /// Represents a virtual surface voxel in the heightmap. Virtual surfaces are created at the interface between
24 | /// free and unknown voxels (free supported by unknown).
25 | kVirtualSurface,
26 | /// A voxel which has been inferred as fatal. This occurs where virtual surfaces appear near the reference point.
27 | kInferredFatal,
28 | /// An otherwise forcibly fatal cost voxel.
29 | kFatal
30 | };
31 | } // namespace ohm
32 |
33 | #endif // OHMHEIGHTMAP_HEIGHTMAP_VOXEL_TYPE_H_
34 |
--------------------------------------------------------------------------------
/ohmheightmap/OhmHeightmapConfig.in.h:
--------------------------------------------------------------------------------
1 | //
2 | // Project configuration header. This is a generated header; do not modify
3 | // it directly. Instead, modify the config.h.in version and run CMake again.
4 | //
5 | #ifndef OHMHEIGHTMAPCONFIG_H
6 | #define OHMHEIGHTMAPCONFIG_H
7 |
8 | #include "OhmHeightmapExport.h"
9 |
10 | #ifndef _USE_MATH_DEFINES
11 | #define _USE_MATH_DEFINES
12 | #endif // _USE_MATH_DEFINES
13 | #ifndef NOMINMAX
14 | #define NOMINMAX
15 | #endif // NOMINMAX
16 |
17 | #ifdef _MSC_VER
18 | // Avoid dubious security warnings for plenty of legitimate code
19 | #ifndef _SCL_SECURE_NO_WARNINGS
20 | #define _SCL_SECURE_NO_WARNINGS
21 | #endif // _SCL_SECURE_NO_WARNINGS
22 | #ifndef _CRT_SECURE_NO_WARNINGS
23 | #define _CRT_SECURE_NO_WARNINGS
24 | #endif // _CRT_SECURE_NO_WARNINGS
25 | //#define _CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES 1
26 | #endif // _MSC_VER
27 |
28 | #include
29 |
30 | #include
31 |
32 | #endif // OHMHEIGHTMAPCONFIG_H
33 |
--------------------------------------------------------------------------------
/ohmheightmap/PlaneWalkVisitMode.h:
--------------------------------------------------------------------------------
1 | // Copyright (c) 2020
2 | // Commonwealth Scientific and Industrial Research Organisation (CSIRO)
3 | // ABN 41 687 119 230
4 | //
5 | // Author: Kazys Stepanas
6 | #ifndef OHMHEIGHTMAP_PLANEWALKVISITMODE_H
7 | #define OHMHEIGHTMAP_PLANEWALKVISITMODE_H
8 |
9 | #include "OhmHeightmapConfig.h"
10 |
11 | namespace ohm
12 | {
13 | /// Mode selection for handling neighbours in various @c PlaneWalker implementations used by @c Heightmap .
14 | /// Determines now neighbours are handled when visiting a node.
15 | enum class PlaneWalkVisitMode
16 | {
17 | /// Do nothing with neighbours. Not added.
18 | kIgnoreNeighbours,
19 | /// Add (planar) neighbours for processing.
20 | kAddUnvisitedNeighbours,
21 | /// Add (planar) neighbours for processing as long as they have not yet been visited in a 2D sense.
22 | ///
23 | /// This option should be used with @c PlaneFillLayeredWalk when a column cannot find a valid ground candidate. The
24 | /// layered fill can then traverse unobserved space.
25 | kAddUnvisitedColumnNeighbours
26 | };
27 | } // namespace ohm
28 |
29 | #endif // OHMHEIGHTMAP_PLANEWALKVISITMODE_H
30 |
--------------------------------------------------------------------------------
/ohmheightmap/PlaneWalker.cpp:
--------------------------------------------------------------------------------
1 | // Copyright (c) 2019
2 | // Commonwealth Scientific and Industrial Research Organisation (CSIRO)
3 | // ABN 41 687 119 230
4 | //
5 | // Author: Kazys Stepanas
6 | #include "PlaneWalker.h"
7 |
8 | #include "HeightmapUtil.h"
9 |
10 | #include
11 |
12 | namespace ohm
13 | {
14 | PlaneWalker::PlaneWalker(const OccupancyMap &map, const Key &min_ext_key, const Key &max_ext_key, UpAxis up_axis,
15 | const Key *plane_key_ptr)
16 | : map(map)
17 | , min_ext_key(min_ext_key)
18 | , max_ext_key(max_ext_key)
19 | , plane_key(plane_key_ptr ? *plane_key_ptr : min_ext_key)
20 | , axis_indices(ohm::heightmap::heightmapAxisIndices(up_axis))
21 | {}
22 |
23 |
24 | bool PlaneWalker::begin(Key &key) const
25 | {
26 | key = min_ext_key;
27 | // Flatten the key onto the plane.
28 | key.setRegionAxis(axis_indices[2], plane_key.regionKey()[axis_indices[2]]);
29 | key.setLocalAxis(axis_indices[2], plane_key.localKey()[axis_indices[2]]);
30 | key.clampToAxis(axis_indices[2], min_ext_key, max_ext_key);
31 | return true;
32 | }
33 |
34 |
35 | bool PlaneWalker::walkNext(Key &key) const
36 | {
37 | map.stepKey(key, axis_indices[0], 1);
38 | if (!key.isBounded(axis_indices[0], min_ext_key, max_ext_key))
39 | {
40 | // Finished walking this axis. Reset and walk outer axis.
41 | key.setLocalAxis(axis_indices[0], min_ext_key.localKey()[axis_indices[0]]);
42 | key.setRegionAxis(axis_indices[0], min_ext_key.regionKey()[axis_indices[0]]);
43 |
44 | map.stepKey(key, axis_indices[1], 1);
45 | if (!key.isBounded(axis_indices[1], min_ext_key, max_ext_key))
46 | {
47 | return false;
48 | }
49 | }
50 |
51 | return true;
52 | }
53 | } // namespace ohm
54 |
--------------------------------------------------------------------------------
/ohmheightmap/TriangleEdge.h:
--------------------------------------------------------------------------------
1 | // Copyright (c) 2019
2 | // Commonwealth Scientific and Industrial Research Organisation (CSIRO)
3 | // ABN 41 687 119 230
4 | //
5 | // Author: Kazys Stepanas
6 | #ifndef OHMHEIGHTMAP_TRIANGLEEDGE_H
7 | #define OHMHEIGHTMAP_TRIANGLEEDGE_H
8 |
9 | #include "OhmHeightmapConfig.h"
10 |
11 | #include
12 |
13 | namespace ohm
14 | {
15 | /// A helper for tracking edges in mesh generation. Stores edge vertices such that v0 < v1 regardless of the input
16 | /// ordering. This allows the edge array to be sorted to clump the edge pairings where two triangles share an edge.
17 | /// Only two triangles can share one edge because we build the mesh without T intersections.
18 | struct ohmheightmap_API TriangleEdge
19 | {
20 | unsigned v0; ///< The lower magnitude vertex index.
21 | unsigned v1; ///< The higher magnitude vertex index.
22 | unsigned triangle; ///< The index of the triangle which generated this edge.
23 | unsigned triangle_edge_index; ///< The index of this edge in @p triangle.
24 |
25 | /// Constructor; v0 and v1 will be reordered such that v0 < v1.
26 | /// @param v0 First vertex index.
27 | /// @param v1 Second vertex index.
28 | /// @param triangle Triangle index.
29 | /// @param edge_index The index of the edge in @p triangle [0, 2].
30 | inline TriangleEdge(unsigned v0, unsigned v1, unsigned triangle, unsigned edge_index)
31 | : triangle(triangle)
32 | , triangle_edge_index(edge_index)
33 | {
34 | this->v0 = std::min(v0, v1);
35 | this->v1 = std::max(v0, v1);
36 | }
37 |
38 | /// Comparison operator for sorting.
39 | inline bool operator<(const TriangleEdge &other) const { return v0 < other.v0 || v0 == other.v0 && v1 < other.v1; }
40 | };
41 | } // namespace ohm
42 |
43 | #endif // OHMHEIGHTMAP_TRIANGLEEDGE_H
44 |
--------------------------------------------------------------------------------
/ohmheightmap/TriangleNeighbours.h:
--------------------------------------------------------------------------------
1 | // Copyright (c) 2019
2 | // Commonwealth Scientific and Industrial Research Organisation (CSIRO)
3 | // ABN 41 687 119 230
4 | //
5 | // Author: Kazys Stepanas
6 | #ifndef OHMHEIGHTMAP_TRIANGLENEIGHBOURS_H
7 | #define OHMHEIGHTMAP_TRIANGLENEIGHBOURS_H
8 |
9 | #include "OhmHeightmapConfig.h"
10 |
11 | #include
12 | #include
13 |
14 | namespace ohm
15 | {
16 | /// Stores the neighbours information for a triangle.
17 | ///
18 | /// Identifies the @p neighbour triangle indices (multiply by 3 when indexing HeightmapMesh::triangles()) and the
19 | /// edge ID of the shared edge in the neighbour. The index into @c neighbours [0, 2] identifies the edge ID in the
20 | /// current triangle.
21 | struct ohmheightmap_API TriangleNeighbours
22 | {
23 | /// Indices to the neighbouring triangles.
24 | /// ~0u for each open edge (-1).
25 | ///
26 | /// Ordered by the shared edge as {v[0], v[1]}, {v[1], v[2]}, {v[2], v[0]}.
27 | std::array neighbours;
28 | /// Identifies the shared edge indices in each neighbour triangle. For example, @c neighbour_edge_indices[0]
29 | /// contains edge information for neighbour[0]. The value of [0, 2] indicates which vertex pairing in neighbour[0]
30 | /// identifies the shared edge. -1 is used for empty edges.
31 | std::array neighbour_edge_indices;
32 | };
33 | } // namespace ohm
34 |
35 | #endif // OHMHEIGHTMAP_TRIANGLENEIGHBOURS_H
36 |
--------------------------------------------------------------------------------
/ohmheightmap/UpAxis.h:
--------------------------------------------------------------------------------
1 | // Copyright (c) 2019
2 | // Commonwealth Scientific and Industrial Research Organisation (CSIRO)
3 | // ABN 41 687 119 230
4 | //
5 | // Author: Kazys Stepanas
6 | #ifndef UPAXIS_H
7 | #define UPAXIS_H
8 |
9 | #include "OhmConfig.h"
10 |
11 | namespace ohm
12 | {
13 | /// Up axis identification values. Used for @c Heightmap generation.
14 | ///
15 | /// Documentation for each ID identifies the up axis.
16 | enum class UpAxis : int
17 | {
18 | /// (0, 0, -1)
19 | kNegZ = -3,
20 | /// (0, -1, 0)
21 | kNegY = -2,
22 | /// (-1, 0, 0)
23 | kNegX = -1,
24 | /// (1, 0, 0)
25 | kX,
26 | /// (0, 1, 0)
27 | kY,
28 | /// (0, 0, 1)
29 | kZ,
30 | };
31 | } // namespace ohm
32 |
33 | #endif // UPAXIS_H
34 |
--------------------------------------------------------------------------------
/ohmheightmapimage/OhmHeightmapImageConfig.in.h:
--------------------------------------------------------------------------------
1 | //
2 | // Project configuration header. This is a generated header; do not modify
3 | // it directly. Instead, modify the config.h.in version and run CMake again.
4 | //
5 | #ifndef OHMHEIGHTMAPIMAGECONFIG_H
6 | #define OHMHEIGHTMAPIMAGECONFIG_H
7 |
8 | #include "OhmHeightmapUtilExport.h"
9 |
10 | #ifndef _USE_MATH_DEFINES
11 | #define _USE_MATH_DEFINES
12 | #endif // _USE_MATH_DEFINES
13 | #ifndef NOMINMAX
14 | #define NOMINMAX
15 | #endif // NOMINMAX
16 | #include
17 |
18 | #ifdef _MSC_VER
19 | // Avoid dubious security warnings for plenty of legitimate code
20 | #ifndef _SCL_SECURE_NO_WARNINGS
21 | #define _SCL_SECURE_NO_WARNINGS
22 | #endif // _SCL_SECURE_NO_WARNINGS
23 | #ifndef _CRT_SECURE_NO_WARNINGS
24 | #define _CRT_SECURE_NO_WARNINGS
25 | #endif // _CRT_SECURE_NO_WARNINGS
26 | //#define _CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES 1
27 | #endif // _MSC_VER
28 |
29 | // Enable various validation tests throughout this library.
30 | //#cmakedefine OHM_FEATURE_THREADS
31 |
32 | #include "OhmConfig.h"
33 |
34 | #endif // OHMHEIGHTMAPIMAGECONFIG_H
35 |
--------------------------------------------------------------------------------
/ohmtools/CMakeLists.txt:
--------------------------------------------------------------------------------
1 |
2 | include(GenerateExportHeader)
3 |
4 |
5 |
6 | configure_file(OhmToolsConfig.in.h "${CMAKE_CURRENT_BINARY_DIR}/ohmtools/OhmToolsConfig.h")
7 |
8 | set(SOURCES
9 | OhmCloud.cpp
10 | OhmCloud.h
11 | OhmGen.cpp
12 | OhmGen.h
13 | OhmToolsConfig.in.h
14 | )
15 |
16 | set(PUBLIC_HEADERS
17 | OhmCloud.h
18 | OhmGen.h
19 | "${CMAKE_CURRENT_BINARY_DIR}/ohmtools/OhmToolsConfig.h"
20 | "${CMAKE_CURRENT_BINARY_DIR}/ohmtools/OhmToolsExport.h"
21 | )
22 |
23 | add_library(ohmtools ${SOURCES})
24 | clang_tidy_target(ohmtools)
25 |
26 | generate_export_header(ohmtools
27 | EXPORT_MACRO_NAME ohmtools_API
28 | EXPORT_FILE_NAME ohmtools/OhmToolsExport.h
29 | STATIC_DEFINE OHMTOOLS_STATIC)
30 |
31 | target_link_libraries(ohmtools
32 | PUBLIC
33 | ohm
34 | ohmheightmap
35 | ohmutil
36 | glm::glm
37 | )
38 |
39 | target_include_directories(ohmtools
40 | PUBLIC
41 | $
42 | $
43 | $
44 | $
45 | )
46 |
47 | install(TARGETS ohmtools EXPORT ${CMAKE_PROJECT_NAME}-config-targets
48 | LIBRARY DESTINATION lib
49 | ARCHIVE DESTINATION lib
50 | RUNTIME DESTINATION bin
51 | INCLUDES DESTINATION ${OHM_PREFIX_INCLUDE}/ohmtools
52 | )
53 |
54 | install(FILES ${PUBLIC_HEADERS} DESTINATION ${OHM_PREFIX_INCLUDE}/ohmtools)
55 |
56 | source_group("source" REGULAR_EXPRESSION ".*$")
57 | # Needs CMake 3.8+:
58 | # source_group(TREE "${CMAKE_CURRENT_LIST_DIR}" PREFIX source FILES ${SOURCES})
59 |
--------------------------------------------------------------------------------
/ohmtools/OhmToolsConfig.in.h:
--------------------------------------------------------------------------------
1 | //
2 | // Project configuration header. This is a generated header; do not modify
3 | // it directly. Instead, modify the config.h.in version and run CMake again.
4 | //
5 | #ifndef OHMTOOLSCONFIG_H
6 | #define OHMTOOLSCONFIG_H
7 |
8 | #include "OhmToolsExport.h"
9 |
10 | #ifndef _USE_MATH_DEFINES
11 | #define _USE_MATH_DEFINES
12 | #endif // _USE_MATH_DEFINES
13 | #ifndef NOMINMAX
14 | #define NOMINMAX
15 | #endif // NOMINMAX
16 | #include
17 |
18 | #ifdef _MSC_VER
19 | // Avoid dubious security warnings for plenty of legitimate code
20 | #ifndef _SCL_SECURE_NO_WARNINGS
21 | #define _SCL_SECURE_NO_WARNINGS
22 | #endif // _SCL_SECURE_NO_WARNINGS
23 | #ifndef _CRT_SECURE_NO_WARNINGS
24 | #define _CRT_SECURE_NO_WARNINGS
25 | #endif // _CRT_SECURE_NO_WARNINGS
26 | //#define _CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES 1
27 | #endif // _MSC_VER
28 |
29 | // Enable various validation tests throughout this library.
30 | //#cmakedefine OHM_FEATURE_THREADS
31 |
32 | #include "OhmConfig.h"
33 |
34 | #endif // OHMTOOLSCONFIG_H
35 |
--------------------------------------------------------------------------------
/ohmutil/OhmUtilConfig.in.h:
--------------------------------------------------------------------------------
1 | //
2 | // Project configuration header. This is a generated header; do not modify
3 | // it directly. Instead, modify the config.h.in version and run CMake again.
4 | //
5 | #ifndef OHMUTILCONFIG_H
6 | #define OHMUTILCONFIG_H
7 |
8 | #include "OhmUtilExport.h"
9 |
10 | #ifndef _USE_MATH_DEFINES
11 | #define _USE_MATH_DEFINES
12 | #endif // _USE_MATH_DEFINES
13 | #ifndef NOMINMAX
14 | #define NOMINMAX
15 | #endif // NOMINMAX
16 |
17 | #ifdef _MSC_VER
18 | // Avoid dubious security warnings for plenty of legitimate code
19 | #ifndef _SCL_SECURE_NO_WARNINGS
20 | #define _SCL_SECURE_NO_WARNINGS
21 | #endif // _SCL_SECURE_NO_WARNINGS
22 | #ifndef _CRT_SECURE_NO_WARNINGS
23 | #define _CRT_SECURE_NO_WARNINGS
24 | #endif // _CRT_SECURE_NO_WARNINGS
25 | //#define _CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES 1
26 | #endif // _MSC_VER
27 |
28 | #include
29 |
30 | /// Enable experimental parts of GLM, like `glm::length2()` (length squared)
31 | #define GLM_ENABLE_EXPERIMENTAL
32 |
33 | #endif // OHMUTILCONFIG_H
34 |
--------------------------------------------------------------------------------
/ohmutil/Options.h:
--------------------------------------------------------------------------------
1 | // Copyright (c) 2018
2 | // Commonwealth Scientific and Industrial Research Organisation (CSIRO)
3 | // ABN 41 687 119 230
4 | //
5 | // Author: Kazys Stepanas
6 | #ifndef OHMUTIL_OPTIONS_H
7 | #define OHMUTIL_OPTIONS_H
8 |
9 | #ifdef _MSC_VER
10 | #pragma warning(push)
11 | #pragma warning(disable : 4267)
12 | #endif // _MSC_VER
13 |
14 | #include "GlmStream.h"
15 |
16 | #include
17 |
18 | template
19 | inline std::string optStr(const T &value)
20 | {
21 | std::ostringstream str;
22 | str << value;
23 | return str.str();
24 | }
25 |
26 | template
27 | inline std::shared_ptr optVal(T &val)
28 | {
29 | return cxxopts::value(val)->default_value(optStr(val));
30 | }
31 |
32 | inline std::shared_ptr optVal(bool &val)
33 | {
34 | return cxxopts::value(val)->implicit_value("true")->default_value(val ? "true" : "false");
35 | }
36 |
37 | #pragma warning(pop)
38 |
39 | #endif // OHMUTIL_OPTIONS_H
40 |
--------------------------------------------------------------------------------
/ohmutil/ProfileMarker.cpp:
--------------------------------------------------------------------------------
1 | // Copyright (c) 2018
2 | // Commonwealth Scientific and Industrial Research Organisation (CSIRO)
3 | // ABN 41 687 119 230
4 | //
5 | // Author: Kazys Stepanas
6 | #include "ProfileMarker.h"
7 |
8 | #include "Profile.h"
9 |
10 | namespace ohm
11 | {
12 | ProfileMarker::ProfileMarker(const char *name, bool activate)
13 | : ProfileMarker(name, nullptr, activate)
14 | {}
15 |
16 |
17 | ProfileMarker::ProfileMarker(const char *name, Profile *profile, bool activate)
18 | : name_(name)
19 | , profile_(profile)
20 | , active_(false)
21 | {
22 | restart(activate);
23 | }
24 |
25 |
26 | ProfileMarker::~ProfileMarker()
27 | {
28 | end();
29 | }
30 |
31 |
32 | void ProfileMarker::end()
33 | {
34 | if (active_)
35 | {
36 | // Pop first so this marker isn't a parent of itself.
37 | Profile *profile = (profile_ == nullptr) ? &Profile::instance() : profile_;
38 | profile->pop();
39 | active_ = false;
40 | }
41 | }
42 |
43 |
44 | void ProfileMarker::restart(bool activate)
45 | {
46 | if (!active_ && activate)
47 | {
48 | Profile *profile = (profile_ == nullptr) ? &Profile::instance() : profile_;
49 | active_ = profile->push(name_);
50 | }
51 | }
52 | } // namespace ohm
53 |
--------------------------------------------------------------------------------
/ohmutil/SafeIO.cpp:
--------------------------------------------------------------------------------
1 | // Copyright (c) 2018
2 | // Commonwealth Scientific and Industrial Research Organisation (CSIRO)
3 | // ABN 41 687 119 230
4 | //
5 | // Author: Kazys Stepanas
6 | #include "SafeIO.h"
7 |
8 | #include
9 |
10 | #if !defined(_MSC_VER)
11 |
12 | int fopen_s(FILE **file, const char *name, const char *mode) // NOLINT
13 | {
14 | *file = fopen(name, mode);
15 | if (*file)
16 | {
17 | return 0;
18 | }
19 | return 1;
20 | }
21 |
22 | #else // !defined(_MSC_VER)
23 |
24 | namespace
25 | {
26 | int avoid_no_symbols_link_warning = 0;
27 | }
28 |
29 | #endif // !defined(_MSC_VER)
30 |
--------------------------------------------------------------------------------
/ohmutil/SafeIO.h:
--------------------------------------------------------------------------------
1 | // Copyright (c) 2018
2 | // Commonwealth Scientific and Industrial Research Organisation (CSIRO)
3 | // ABN 41 687 119 230
4 | //
5 | // Author: Kazys Stepanas
6 | #ifndef OHMUTIL_SAFEIO_H
7 | #define OHMUTIL_SAFEIO_H
8 |
9 | #include "OhmUtilExport.h"
10 |
11 | #include
12 |
13 | #if !defined(_MSC_VER)
14 |
15 | #define sprintf_s snprintf
16 | #define sscanf_s sscanf
17 |
18 | int ohmutil_API fopen_s(FILE **file, const char *name, const char *mode); // NOLINT
19 |
20 | #endif // !defined(_MSC_VER)
21 |
22 | #endif // OHMUTIL_SAFEIO_H
23 |
--------------------------------------------------------------------------------
/ohmutil/p2p.h:
--------------------------------------------------------------------------------
1 | //
2 | // author Kazys Stepanas
3 | //
4 | #ifndef OHMUTIL_P2P_H
5 | #define OHMUTIL_P2P_H
6 |
7 | #include
8 |
9 | #ifdef TES_ENABLE
10 | #include "3esvector3.h"
11 |
12 | #include
13 |
14 | inline tes::Vector3f p2p(const glm::vec3 &p)
15 | {
16 | return tes::Vector3f(p.x, p.y, p.z);
17 | }
18 |
19 | inline glm::vec3 p2p(const tes::Vector3f &p)
20 | {
21 | return glm::vec3(p.x, p.y, p.z);
22 | }
23 |
24 | inline const tes::Vector3f *p2pArray(const glm::vec3 *points)
25 | {
26 | static_assert(sizeof(tes::Vector3f) == sizeof(glm::vec3), "tes::Vector3f size does not match glm::vec3 size.");
27 | // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
28 | return reinterpret_cast(points);
29 | }
30 |
31 | inline const glm::vec3 *p2pArray(const tes::Vector3f *points)
32 | {
33 | static_assert(sizeof(tes::Vector3f) == sizeof(glm::vec3), "tes::Vector3f size does not match glm::vec3 size.");
34 | // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
35 | return reinterpret_cast(points);
36 | }
37 |
38 | #endif // TES_ENABLE
39 |
40 | #endif // OHMUTIL_P2P_H
41 |
--------------------------------------------------------------------------------
/package.xml:
--------------------------------------------------------------------------------
1 |
2 |
3 | ohm
4 | 0.5.0
5 | Occupancy Homogeneous Map libraries
6 | Kazys Stepanas
7 | Modified MIT
8 |
9 | libglew-dev
10 | libglfw3-dev
11 | libglm-dev
12 | ocl-icd-opencl-dev
13 |
14 |
15 | cmake
16 |
17 |
18 |
19 |
--------------------------------------------------------------------------------
/scripts/setup.cfg:
--------------------------------------------------------------------------------
1 | [pep8]
2 | max-line-length = 120
3 |
4 | [flake8]
5 | max-line-length = 120
6 |
--------------------------------------------------------------------------------
/slamio/DataChannel.h:
--------------------------------------------------------------------------------
1 | // Copyright (c) 2021
2 | // Commonwealth Scientific and Industrial Research Organisation (CSIRO)
3 | // ABN 41 687 119 230
4 | //
5 | // Author: Kazys Stepanas
6 | #ifndef SLAMIO_DATACHANNEL_H_
7 | #define SLAMIO_DATACHANNEL_H_
8 |
9 | #include "SlamIOConfig.h"
10 |
11 | namespace slamio
12 | {
13 | enum class DataChannel : unsigned;
14 | }
15 |
16 | slamio::DataChannel operator~(slamio::DataChannel a);
17 | slamio::DataChannel operator|(slamio::DataChannel a, slamio::DataChannel b);
18 | slamio::DataChannel operator|=(slamio::DataChannel &a, slamio::DataChannel b);
19 | slamio::DataChannel operator&(slamio::DataChannel a, slamio::DataChannel b);
20 | slamio::DataChannel operator&=(slamio::DataChannel &a, slamio::DataChannel b);
21 |
22 | namespace slamio
23 | {
24 | enum class DataChannel : unsigned
25 | {
26 | None = 0u,
27 | Time = (1u << 0u),
28 | Position = (1u << 1u),
29 | Normal = (1u << 2u),
30 | ColourRgb = (1u << 3u),
31 | ColourAlpha = (1u << 4u),
32 | Intensity = (1u << 5u),
33 | ReturnNumber = (1u << 6u),
34 |
35 | Colour = ColourRgb | ColourAlpha
36 | };
37 | }
38 |
39 | inline slamio::DataChannel operator~(slamio::DataChannel a)
40 | {
41 | return slamio::DataChannel(~unsigned(a));
42 | }
43 |
44 | inline slamio::DataChannel operator|(slamio::DataChannel a, slamio::DataChannel b)
45 | {
46 | return slamio::DataChannel(unsigned(a) | unsigned(b));
47 | }
48 |
49 | inline slamio::DataChannel operator|=(slamio::DataChannel &a, slamio::DataChannel b)
50 | {
51 | a = a | b;
52 | return a;
53 | }
54 |
55 | inline slamio::DataChannel operator&(slamio::DataChannel a, slamio::DataChannel b)
56 | {
57 | return slamio::DataChannel(unsigned(a) & unsigned(b));
58 | }
59 |
60 | inline slamio::DataChannel operator&=(slamio::DataChannel &a, slamio::DataChannel b)
61 | {
62 | a = a & b;
63 | return a;
64 | }
65 |
66 | #endif // SLAMIO_DATACHANNEL_H_
67 |
--------------------------------------------------------------------------------
/slamio/PointCloudReader.cpp:
--------------------------------------------------------------------------------
1 | // Copyright (c) 2021
2 | // Commonwealth Scientific and Industrial Research Organisation (CSIRO)
3 | // ABN 41 687 119 230
4 | //
5 | // Author: Kazys Stepanas
6 | #include "PointCloudReader.h"
7 |
8 | #include
9 |
10 | namespace slamio
11 | {
12 | const char *const *timeFieldNames(size_t &count)
13 | {
14 | static const std::array names = //
15 | {
16 | //
17 | "gps_time", //
18 | "gpstime", //
19 | "internal_time", //
20 | "internaltime", //
21 | "offset_time", //
22 | "offsettime", //
23 | "timestamp", //
24 | "time" //
25 | };
26 | count = names.size();
27 | return names.data();
28 | }
29 |
30 | const char *const *returnNumberFieldNames(size_t &count)
31 | {
32 | {
33 | static const std::array names = //
34 | {
35 | //
36 | "returnnumber", //
37 | "return_number", //
38 | "returnnum", //
39 | "return_num", //
40 | };
41 | count = names.size();
42 | return names.data();
43 | }
44 | }
45 |
46 | PointCloudReader::~PointCloudReader() = default;
47 | } // namespace slamio
48 |
--------------------------------------------------------------------------------
/slamio/PointCloudReaderTraj.h:
--------------------------------------------------------------------------------
1 | // Copyright (c) 2021
2 | // Commonwealth Scientific and Industrial Research Organisation (CSIRO)
3 | // ABN 41 687 119 230
4 | //
5 | // Author: Kazys Stepanas
6 | #ifndef SLAMIO_POINTCLOUDREADERTRAJ_H_
7 | #define SLAMIO_POINTCLOUDREADERTRAJ_H_
8 |
9 | #include "SlamIOConfig.h"
10 |
11 | #include "PointCloudReader.h"
12 |
13 | #include
14 | #include