├── .azure-pipelines.yml ├── .circleci └── config.yml ├── .flake8.cython ├── .github └── issue_template.md ├── .gitignore ├── .pep8 ├── .travis.yml ├── LICENSE ├── Makefile ├── _msvccompiler.py ├── appveyor.yml ├── appveyor ├── OpenNI │ ├── Win32 │ │ └── Bin │ │ │ ├── OpenNI.Net.dll │ │ │ ├── OpenNI.dll │ │ │ ├── OpenNI.jni.dll │ │ │ ├── OpenNIFilter.dll │ │ │ ├── Policy.1.1.OpenNI.Net.dll │ │ │ ├── Policy.1.2.OpenNI.Net.dll │ │ │ ├── Policy.1.3.OpenNI.Net.dll │ │ │ ├── Policy.1.4.OpenNI.Net.dll │ │ │ ├── Policy.1.5.OpenNI.Net.dll │ │ │ ├── PublisherPolicy1.1.config │ │ │ ├── PublisherPolicy1.2.config │ │ │ ├── PublisherPolicy1.3.config │ │ │ ├── PublisherPolicy1.4.config │ │ │ ├── PublisherPolicy1.5.config │ │ │ ├── niLicense.exe │ │ │ ├── niReg.exe │ │ │ ├── nimCodecs.dll │ │ │ ├── nimMockNodes.dll │ │ │ ├── nimRecorder.dll │ │ │ └── org.OpenNI.jar │ └── x64 │ │ └── Bin64 │ │ ├── OpenNI.Net.dll │ │ ├── OpenNI.jni64.dll │ │ ├── OpenNI64.dll │ │ ├── Policy.1.1.OpenNI.Net.dll │ │ ├── Policy.1.2.OpenNI.Net.dll │ │ ├── Policy.1.3.OpenNI.Net.dll │ │ ├── PublisherPolicy1.1.config │ │ ├── PublisherPolicy1.2.config │ │ ├── PublisherPolicy1.3.config │ │ ├── niLicense64.exe │ │ ├── niReg64.exe │ │ ├── nimCodecs64.dll │ │ ├── nimMockNodes64.dll │ │ ├── nimRecorder64.dll │ │ └── org.OpenNI.jar ├── OpenNI2 │ ├── Win32 │ │ └── Redist │ │ │ ├── OpenNI.ini │ │ │ ├── OpenNI2.dll │ │ │ ├── OpenNI2.pdb │ │ │ ├── OpenNI2 │ │ │ └── Drivers │ │ │ │ ├── Kinect.dll │ │ │ │ ├── Kinect.pdb │ │ │ │ ├── OniFile.dll │ │ │ │ ├── OniFile.pdb │ │ │ │ ├── PS1080.dll │ │ │ │ └── PS1080.pdb │ │ │ └── PS1080.ini │ └── x64 │ │ └── Redist │ │ ├── OpenNI.ini │ │ ├── OpenNI2.dll │ │ ├── OpenNI2.pdb │ │ ├── OpenNI2 │ │ └── Drivers │ │ │ ├── Kinect.dll │ │ │ ├── Kinect.pdb │ │ │ ├── OniFile.dll │ │ │ ├── OniFile.pdb │ │ │ ├── PS1080.dll │ │ │ └── PS1080.pdb │ │ └── PS1080.ini ├── bfgs.h ├── eigen.h ├── install.ps1 ├── run_with_env.cmd └── shared_ptr.hpp ├── bld.bat ├── build.sh ├── check.bat ├── clean.bat ├── clean.sh ├── conf.py ├── dev-requirements.txt ├── docker ├── Dockerfile └── Dockerfile2 ├── docs ├── Makefile ├── build.bat ├── image │ └── pcl_logo_958x309.png ├── make.bat ├── requirements.txt ├── source │ ├── _static │ │ └── css │ │ │ └── modified_theme.css │ ├── _templates │ │ └── autosummary │ │ │ └── class.rst │ ├── compatibility.rst │ ├── conf.py │ ├── contribution.rst │ ├── developers.rst │ ├── index.rst │ ├── install.rst │ ├── license.rst │ ├── locale │ │ └── ja │ │ │ └── LC_MESSAGES │ │ │ ├── compatibility.po │ │ │ ├── contribution.po │ │ │ ├── developers.po │ │ │ ├── index.po │ │ │ ├── install.po │ │ │ ├── license.po │ │ │ ├── overview.po │ │ │ ├── reference.po │ │ │ └── tutorial.po │ ├── overview.rst │ ├── reference │ │ ├── index.rst │ │ └── pcl.rst │ ├── spelling_wordlist.txt │ └── tutorial │ │ ├── GPU.rst │ │ ├── application.rst │ │ ├── features.rst │ │ ├── filtering.rst │ │ ├── index.rst │ │ ├── io.rst │ │ ├── kdtree.rst │ │ ├── keypoint.rst │ │ ├── octree.rst │ │ ├── pcl.rst │ │ ├── rangeImage.rst │ │ ├── recognition.rst │ │ ├── registration.rst │ │ ├── sampleconsensus.rst │ │ ├── segmentation.rst │ │ ├── surface.rst │ │ ├── tracking.rst │ │ └── visualization.rst └── translate.bat ├── environment.yml ├── environment_minimum.yml ├── examples ├── 3dharris.py ├── GrabberCallbackTest.py ├── HarrisKeypoint3D.py ├── cropbox.py ├── crophull.py ├── example.py ├── external │ ├── laspy │ │ ├── ReadMe.md │ │ ├── visualization_test.py │ │ └── visualization_test_rgb.py │ ├── libfreenect2 │ │ ├── ReadMe.md │ │ ├── example.py │ │ ├── example2.py │ │ └── test.txt │ ├── matlabplot │ │ ├── bunny.pcd │ │ ├── test.ipynb │ │ └── test.py │ ├── opencv │ │ ├── grabber_sequences │ │ │ ├── pclzf │ │ │ │ ├── frame_20121214T142255.814212.xml │ │ │ │ ├── frame_20121214T142256.068683.xml │ │ │ │ └── frame_20121214T142256.332395.xml │ │ │ └── tiff │ │ │ │ ├── frame_20121214T142255.814212_depth.tiff │ │ │ │ ├── frame_20121214T142255.814212_rgb.tiff │ │ │ │ ├── frame_20121214T142256.068683_depth.tiff │ │ │ │ ├── frame_20121214T142256.068683_rgb.tiff │ │ │ │ ├── frame_20121214T142256.332395_depth.tiff │ │ │ │ └── frame_20121214T142256.332395_rgb.tiff │ │ ├── opencv_depth_sample.py │ │ └── opencv_depth_sample2.py │ └── ros │ │ ├── ReadMe.md │ │ ├── memo.txt │ │ ├── ros_utils.py │ │ └── ros_utils.py.txt ├── kdtree.py ├── official │ ├── Applications │ │ ├── ground_based_rgbd_people_detector.txt │ │ ├── template_alignment.txt │ │ └── vfh_cluster_classifier.txt │ ├── Features │ │ ├── NormalEstimationUsingIntegralImages.py │ │ ├── moment_of_inertia.py │ │ └── rops_feature.py │ ├── Filtering │ │ ├── PassThroughFilter.py │ │ ├── VoxelGrid_160.py │ │ ├── VoxelGrid_172.txt │ │ ├── extract_indices.py │ │ ├── project_inliers.py │ │ ├── remove_outliers.py │ │ └── statistical_removal.py │ ├── GPU │ │ └── people_detect_172.txt │ ├── IO │ │ ├── pcd_read.py │ │ └── test_pcd.pcd │ ├── RangeImage │ │ ├── range_image_border_extraction.py │ │ └── range_image_visualize.py │ ├── Recognition │ │ ├── correspondence_grouping.py │ │ ├── global_hypothesis_verification.py │ │ └── implicit_shape_model.py │ ├── Registration │ │ ├── alignment_prerejective.py │ │ ├── iterative_closest_point.py │ │ ├── normal_distributions_transform.py │ │ ├── pairwise_incremental_registration.txt │ │ └── pcl-interactive_icp.txt │ ├── SampleConsensus │ │ └── random_sample_consensus.py │ ├── Segmentation │ │ ├── MinCutSegmentation_172.txt │ │ ├── Plane_model_segmentation.py │ │ ├── bare_earth_172.txt │ │ ├── cluster_extraction.py │ │ ├── conditional_euclidean_clustering_172.txt │ │ ├── cylinder_segmentation.py │ │ ├── don_segmentation_172.txt │ │ ├── region_growing_rgb_segmentation_172.txt │ │ ├── region_growing_segmentation_172.txt │ │ └── supervoxel_clustering_172.txt │ ├── Surface │ │ ├── bun0.pcd │ │ ├── concave_hull_2d.py │ │ ├── greedy_projection_172.txt │ │ └── resampling.py │ ├── Visualization │ │ ├── PCLPlotter.txt │ │ ├── cloud_viewer.txt │ │ ├── pcl_visualizer_viewports.txt │ │ └── range_image_visualization.txt │ ├── grabber │ │ └── openni_grabber.py │ ├── kdtree │ │ └── kdtree_search.py │ ├── keypoints │ │ └── narf_keypoint_extraction.py │ ├── matrix_transform matrix_transform.txt │ └── octree │ │ ├── octree_change_detection.py │ │ └── octree_search.py ├── pcldata │ └── tutorials │ │ ├── correspondence_grouping │ │ ├── milk.pcd │ │ └── milk_cartoon_all_small_clorox.pcd │ │ ├── lamppost.pcd │ │ ├── table_scene_lms400.pcd │ │ └── table_scene_mug_stereo_textured.pcd ├── segment_cyl_plane.py ├── sift.py ├── simple_visualize.py ├── statistical_outlier_fiter.py └── visualization.py ├── examples_command_160.txt ├── examples_command_172.txt ├── pcl ├── ProjectInliers.cpp ├── ProjectInliers.h ├── __init__.py ├── _bind_defs.pxd ├── _pcl.pxd ├── _pcl.pyx ├── _pcl_170.pyx ├── _pcl_172.pyx ├── _pcl_180.pyx ├── _pcl_181.pyx ├── _pcl_190.pyx ├── _pcl_191.pyx ├── bind.h ├── boost_function.pxd ├── boost_shared_ptr.pxd ├── boost_shared_ptr_assign.h ├── boost_signal2_connection.pxd ├── eigen.pxd ├── grabber_callback.cpp ├── grabber_callback.h ├── grabber_callback.pxd ├── indexing.hpp ├── indexing.pxd ├── minipcl.cpp ├── minipcl.h ├── pcl_PCLPointCloud2_172.pxd ├── pcl_PCLPointCloud2_180.pxd ├── pcl_People_172.pxd ├── pcl_People_180.pxd ├── pcl_PointCloud2_160.pxd ├── pcl_Recognition_172.pxd ├── pcl_Recognition_180.pxd ├── pcl_base_172.txt ├── pcl_common.pxd ├── pcl_common_172.pxd ├── pcl_compression_172.txt ├── pcl_defs.pxd ├── pcl_features.pxd ├── pcl_features_170.pxd ├── pcl_features_172.pxd ├── pcl_features_180.pxd ├── pcl_filters.pxd ├── pcl_filters_172.pxd ├── pcl_filters_180.pxd ├── pcl_grabber.pxd ├── pcl_grabber.pyx ├── pcl_grabber_172.pyx ├── pcl_grabber_180.pyx ├── pcl_grabber_defs.pxd ├── pcl_grabber_defs_172.pxd ├── pcl_grabber_defs_180.pxd ├── pcl_io.pxd ├── pcl_io_172.pxd ├── pcl_io_180.pxd ├── pcl_kdtree.pxd ├── pcl_kdtree_172.pxd ├── pcl_kdtree_180.pxd ├── pcl_keypoints.pxd ├── pcl_keypoints_172.pxd ├── pcl_keypoints_180.pxd ├── pcl_octree.pxd ├── pcl_octree_172.pxd ├── pcl_octree_180.pxd ├── pcl_outofcore_172.pxd ├── pcl_outofcore_180.pxd ├── pcl_range_image.pxd ├── pcl_range_image_172.pxd ├── pcl_range_image_180.pxd ├── pcl_registration_160.pxd ├── pcl_registration_172.pxd ├── pcl_registration_180.pxd ├── pcl_ros.pxd ├── pcl_ros_172.pxd ├── pcl_ros_180.pxd ├── pcl_sample_consensus.pxd ├── pcl_sample_consensus_172.pxd ├── pcl_sample_consensus_180.pxd ├── pcl_search.pxd ├── pcl_search_172.pxd ├── pcl_search_180.pxd ├── pcl_segmentation.pxd ├── pcl_segmentation_172.pxd ├── pcl_segmentation_180.pxd ├── pcl_surface.pxd ├── pcl_surface_172.pxd ├── pcl_surface_180.pxd ├── pcl_tracking_172.pxd ├── pcl_tracking_180.pxd ├── pcl_visualization.pxd ├── pcl_visualization.pyx ├── pcl_visualization_160.pyx ├── pcl_visualization_160_defs.pxd ├── pcl_visualization_172.pxd ├── pcl_visualization_180.pxd ├── pcl_visualization_180_defs.pxd ├── pcl_visualization_181_defs.pxd ├── pcl_visualization_191.pyx ├── pcl_visualization_191_defs.pxd ├── pcl_visualization_defs.pxd ├── pxi │ ├── Common │ │ ├── Common.txt │ │ └── RangeImage │ │ │ ├── RangeImagePlanar.pxi │ │ │ ├── RangeImagePlanar_172.pxi │ │ │ ├── RangeImages.pxi │ │ │ ├── RangeImages_172.pxi │ │ │ └── RangeImages_180.pxi │ ├── Features │ │ ├── AddList.txt │ │ ├── DifferenceOfNormalsEstimation_172.pxi │ │ ├── DifferenceOfNormalsEstimation_180.pxi │ │ ├── IntegralImageNormalEstimation.pxi │ │ ├── IntegralImageNormalEstimation_172.pxi │ │ ├── IntegralImageNormalEstimation_180.pxi │ │ ├── MomentOfInertiaEstimation_172.pxi │ │ ├── MomentOfInertiaEstimation_180.pxi │ │ ├── NormalEstimation.pxi │ │ ├── NormalEstimation_172.pxi │ │ ├── NormalEstimation_180.pxi │ │ ├── RangeImageBorderExtractor.pxi │ │ ├── RangeImageBorderExtractor_172.pxi │ │ ├── RangeImageBorderExtractor_180.pxi │ │ ├── VFHEstimation.pxi │ │ ├── VFHEstimation_172.pxi │ │ └── VFHEstimation_180.pxi │ ├── Filters │ │ ├── AddList.txt │ │ ├── ApproximateVoxelGrid.pxi │ │ ├── ApproximateVoxelGrid_172.pxi │ │ ├── ApproximateVoxelGrid_180.pxi │ │ ├── ConditionAnd.pxi │ │ ├── ConditionAnd_172.pxi │ │ ├── ConditionAnd_180.pxi │ │ ├── ConditionalRemoval.pxi │ │ ├── ConditionalRemoval_172.pxi │ │ ├── ConditionalRemoval_180.pxi │ │ ├── CropBox.pxi │ │ ├── CropBox_172.pxi │ │ ├── CropBox_180.pxi │ │ ├── CropHull.pxi │ │ ├── CropHull_172.pxi │ │ ├── CropHull_180.pxi │ │ ├── FieldComparison.pxi │ │ ├── PassThroughFilter.pxi │ │ ├── PassThroughFilter_172.pxi │ │ ├── PassThroughFilter_180.pxi │ │ ├── ProjectInliers.pxi │ │ ├── ProjectInliers_172.pxi │ │ ├── ProjectInliers_180.pxi │ │ ├── RadiusOutlierRemoval.pxi │ │ ├── RadiusOutlierRemoval_172.pxi │ │ ├── RadiusOutlierRemoval_180.pxi │ │ ├── StatisticalOutlierRemovalFilter.pxi │ │ ├── StatisticalOutlierRemovalFilter_172.pxi │ │ ├── StatisticalOutlierRemovalFilter_180.pxi │ │ ├── VoxelGridFilter.pxi │ │ ├── VoxelGridFilter_172.pxi │ │ └── VoxelGridFilter_180.pxi │ ├── Grabber │ │ ├── AddList.txt │ │ ├── ONIGrabber.pxi │ │ ├── OpenNIGrabber.pxi │ │ ├── PyGrabberCallback.pxi │ │ ├── PyGrabberNode.pxi │ │ └── SimpleNIGrabber.pxi │ ├── IO │ │ └── AddList.txt │ ├── KdTree │ │ ├── AddList.txt │ │ ├── KdTree.pxi │ │ └── KdTree_FLANN.pxi │ ├── KeyPoint │ │ ├── AddList.txt │ │ ├── HarrisKeypoint3D.pxi │ │ ├── HarrisKeypoint3D_172.pxi │ │ ├── HarrisKeypoint3D_180.pxi │ │ ├── NarfKeypoint.pxi │ │ ├── NarfKeypoint_172.pxi │ │ ├── NarfKeypoint_180.pxi │ │ ├── UniformSampling.pxi │ │ ├── UniformSampling_172.pxi │ │ └── UniformSampling_180.pxi │ ├── Octree │ │ ├── AddList.txt │ │ ├── Octree2BufBase.pxi │ │ ├── OctreePointCloud.pxi │ │ ├── OctreePointCloud2Buf.pxi │ │ ├── OctreePointCloud2Buf_172.pxi │ │ ├── OctreePointCloud2Buf_180.pxi │ │ ├── OctreePointCloudChangeDetector.pxi │ │ ├── OctreePointCloudChangeDetector_172.pxi │ │ ├── OctreePointCloudChangeDetector_180.pxi │ │ ├── OctreePointCloudSearch.pxi │ │ ├── OctreePointCloudSearch_172.pxi │ │ ├── OctreePointCloudSearch_180.pxi │ │ ├── OctreePointCloud_172.pxi │ │ └── OctreePointCloud_180.pxi │ ├── PointCloud_FPFHSignature33.pxi │ ├── PointCloud_Normal.pxi │ ├── PointCloud_PCLPointCloud2.pxi │ ├── PointCloud_PCLPointCloud2_180.pxi │ ├── PointCloud_PointCloud2.pxi │ ├── PointCloud_PointNormal.pxi │ ├── PointCloud_PointWithViewpoint.pxi │ ├── PointCloud_PointXYZ.pxi │ ├── PointCloud_PointXYZI.pxi │ ├── PointCloud_PointXYZI_172.pxi │ ├── PointCloud_PointXYZI_180.pxi │ ├── PointCloud_PointXYZRGB.pxi │ ├── PointCloud_PointXYZRGBA.pxi │ ├── PointCloud_PointXYZRGBA_172.pxi │ ├── PointCloud_PointXYZRGBA_180.pxi │ ├── PointCloud_PointXYZRGB_172.pxi │ ├── PointCloud_PointXYZRGB_180.pxi │ ├── PointCloud_PointXYZ_172.pxi │ ├── PointCloud_PointXYZ_180.pxi │ ├── PointCloud_PointXYZ_190.pxi │ ├── PointCloud_ReferenceFrame.pxi │ ├── PointCloud_SHOT352.pxi │ ├── PointCloud_SensorPoint.pxi │ ├── PointCloud_VFHSignature308.pxi │ ├── PointXYZtoPointXYZ.pxi │ ├── PolygonMesh.pxi │ ├── Recognition │ │ └── AddList.txt │ ├── SampleConsensus │ │ ├── RandomSampleConsensus.pxi │ │ ├── SampleConsensusModel.pxi │ │ ├── SampleConsensusModelCylinder.pxi │ │ ├── SampleConsensusModelLine.pxi │ │ ├── SampleConsensusModelPlane.pxi │ │ ├── SampleConsensusModelRegistration.pxi │ │ ├── SampleConsensusModelSphere.pxi │ │ └── SampleConsensusModelStick.pxi │ ├── Segmentation │ │ ├── AddList.txt │ │ ├── ConditionalEuclideanClustering_172.pxi │ │ ├── ConditionalEuclideanClustering_180.pxi │ │ ├── EuclideanClusterExtraction.pxi │ │ ├── EuclideanClusterExtraction_172.pxi │ │ ├── EuclideanClusterExtraction_180.pxi │ │ ├── MinCutSegmentation_172.pxi │ │ ├── MinCutSegmentation_180.pxi │ │ ├── ProgressiveMorphologicalFilter_172.pxi │ │ ├── ProgressiveMorphologicalFilter_180.pxi │ │ ├── RegionGrowing_172.pxi │ │ ├── RegionGrowing_180.pxi │ │ ├── Segmentation.pxi │ │ ├── SegmentationNormal.pxi │ │ ├── SegmentationNormal_172.pxi │ │ ├── SegmentationNormal_180.pxi │ │ ├── Segmentation_172.pxi │ │ └── Segmentation_180.pxi │ ├── Surface │ │ ├── AddList.txt │ │ ├── ConcaveHull.pxi │ │ ├── ConcaveHull_172.pxi │ │ ├── ConcaveHull_180.pxi │ │ ├── MovingLeastSquares.pxi │ │ ├── MovingLeastSquares_172.pxi │ │ └── MovingLeastSquares_180.pxi │ ├── Tracking │ │ └── AddList.txt │ ├── Vertices.pxi │ ├── Visualization │ │ ├── AddList.txt │ │ ├── CloudViewing.pxi │ │ ├── Handler │ │ │ ├── PointCloudColorHandleringCustom.pxi │ │ │ ├── PointCloudColorHandleringGenericField.pxi │ │ │ ├── PointCloudColorHandleringHSVField.pxi │ │ │ ├── PointCloudColorHandleringRGBField.pxi │ │ │ ├── PointCloudColorHandleringRandom.pxi │ │ │ ├── PointCloudGeometryHandleringCustom.pxi │ │ │ ├── PointCloudGeometryHandleringSurfaceNormal.pxi │ │ │ └── PointCloudGeometryHandleringXYZ.pxi │ │ ├── PCLHistogramViewing.pxi │ │ ├── PCLVisualizering.pxi │ │ ├── PCLVisualizering_191.pxi │ │ ├── RangeImageVisualization.pxi │ │ └── vtkSmartPointerRenderWindow.pxi │ ├── pxd_cimport.pxi │ ├── pxd_cimport_172.pxi │ ├── pxd_cimport_180.pxi │ ├── pxiInclude.pxi │ ├── pxiInclude_172.pxi │ ├── pxiInclude_180.pxi │ ├── pxiInclude_181.pxi │ ├── pxiInclude_190.pxi │ ├── pxiInclude_191.pxi │ ├── pyx_cimport.pxi │ ├── pyx_cimport_172.pxi │ ├── pyx_cimport_180.pxi │ ├── pyx_cimport_181.pxi │ ├── pyx_cimport_190.pxi │ ├── pyx_cimport_191.pxi │ └── registration │ │ ├── AddList.txt │ │ ├── GeneralizedIterativeClosestPoint.pxi │ │ ├── GeneralizedIterativeClosestPoint_172.pxi │ │ ├── GeneralizedIterativeClosestPoint_180.pxi │ │ ├── IterativeClosestPoint.pxi │ │ ├── IterativeClosestPointNonLinear.pxi │ │ ├── IterativeClosestPointNonLinear_172.pxi │ │ ├── IterativeClosestPointNonLinear_180.pxi │ │ ├── IterativeClosestPoint_172.pxi │ │ ├── IterativeClosestPoint_180.pxi │ │ ├── NormalDistributionsTransform_172.pxi │ │ └── NormalDistributionsTransform_180.pxi ├── registration.pyx ├── shared_ptr.pxd ├── shared_ptr_assign.h ├── vector.pxd ├── vtkInteracterWrapper.cpp ├── vtkInteracterWrapper.h └── vtk_defs.pxd ├── pcl_logo.png ├── pkg-config ├── Install-GTKPlus.ps1 ├── InstallWindowsGTKPlus.bat ├── PS-Zip.psm1 └── pkg-config_setting.txt ├── python-pcl └── pcl │ ├── _pcl.pxd │ └── pcl_defs.pxd ├── readme.rst ├── readthedocs.yml ├── requirements-docs.txt ├── requirements-test.txt ├── requirements.txt ├── setup.py ├── sys_path_check.py ├── test_example_command.txt ├── tests ├── flydracyl.pcd ├── table_scene_mug_stereo_textured_noplane.pcd ├── test_features.py ├── test_filters.py ├── test_io.py ├── test_kdtree.py ├── test_keypoints.py ├── test_octree.py ├── test_recognition.py ├── test_registration.py ├── test_sampleconsensus.py ├── test_segmentation.py ├── test_surface.py └── tutorials │ ├── bunny.pcd │ ├── lamppost.pcd │ ├── table_scene_lms400.pcd │ ├── table_scene_mug_stereo_textured.pcd │ └── table_scene_mug_stereo_textured_noplane.pcd └── travisCI ├── pcl_2d-1.8.pc └── temporary solution.txt /.flake8.cython: -------------------------------------------------------------------------------- 1 | [flake8] 2 | filename = *.pyx,*.px* 3 | exclude = .eggs,*.egg,build 4 | ignore = E901,E225,E226,E227,E999 5 | -------------------------------------------------------------------------------- /.github/issue_template.md: -------------------------------------------------------------------------------- 1 | 2 | 3 | ## Your Environment 4 | 5 | * Operating System and version: 6 | * Compiler: 7 | * PCL Version: 8 | * Cython Version: 9 | 10 | ## Context 11 | 12 | 13 | 14 | ## Expected Behavior 15 | 16 | 17 | 18 | ## Current Behavior 19 | 20 | 21 | 22 | ## Code to Reproduce 23 | 24 | 25 | 26 | ## Possible Solution 27 | 28 | -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | *.pcd 2 | 3 | pcl/_pcl*.cpp 4 | pcl/_pcl.html 5 | pcl/registration.cpp 6 | 7 | *.py[co] 8 | *.so 9 | 10 | # Packages 11 | *.egg 12 | *.egg-info 13 | dist 14 | build 15 | eggs 16 | parts 17 | bin 18 | var 19 | sdist 20 | develop-eggs 21 | .installed.cfg 22 | 23 | # Installer logs 24 | pip-log.txt 25 | 26 | # Unit test / coverage reports 27 | .coverage 28 | .tox 29 | 30 | #Translations 31 | *.mo 32 | 33 | #Mr Developer 34 | .mr.developer.cfg 35 | 36 | # Vim 37 | *.sw[op] 38 | -------------------------------------------------------------------------------- /.pep8: -------------------------------------------------------------------------------- 1 | [pep8] 2 | exclude=.eggs,*.egg,build,pkg-config 3 | diff=True 4 | -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | Copyright 2013 John Stowers, Strawlab 2 | Copyright 2015 Netherlands eScience Center 3 | All rights reserved. 4 | 5 | Redistribution and use in source and binary forms, with or without 6 | modification, are permitted provided that the following conditions are met: 7 | 8 | * Redistributions of source code must retain the above copyright notice, this 9 | list of conditions and the following disclaimer. 10 | 11 | * Redistributions in binary form must reproduce the above copyright notice, 12 | this list of conditions and the following disclaimer in the documentation 13 | and/or other materials provided with the distribution. 14 | 15 | * The names of the authors and contributors may be not used to endorse or 16 | promote products derived from this software without specific prior written 17 | permission. 18 | 19 | THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 20 | AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 21 | IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 22 | DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE 23 | FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 24 | DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR 25 | SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER 26 | CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, 27 | OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 28 | OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 29 | -------------------------------------------------------------------------------- /Makefile: -------------------------------------------------------------------------------- 1 | all: pcl/_pcl.so pcl/registration.so 2 | 3 | pcl/_pcl.so: pcl/_pcl.pxd pcl/_pcl.pyx setup.py pcl/pcl_defs.pxd \ 4 | pcl/minipcl.cpp pcl/indexing.hpp 5 | python setup.py build_ext --inplace 6 | 7 | pcl/registration.so: setup.py pcl/_pcl.pxd pcl/pcl_defs.pxd \ 8 | pcl/registration.pyx 9 | python setup.py build_ext --inplace 10 | 11 | test: pcl/_pcl.so tests/test.py 12 | nosetests -s 13 | 14 | clean: 15 | rm -rf build 16 | rm -f pcl/_pcl.cpp pcl/_pcl.so pcl/registration.so 17 | 18 | doc: pcl.so conf.py readme.rst 19 | sphinx-build -b singlehtml -d build/doctrees . build/html 20 | 21 | showdoc: doc 22 | gvfs-open build/html/readme.html 23 | -------------------------------------------------------------------------------- /appveyor/OpenNI/Win32/Bin/OpenNI.Net.dll: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/strawlab/python-pcl/809199a3a62e8d98f8b8286db3051b6aee0b295b/appveyor/OpenNI/Win32/Bin/OpenNI.Net.dll -------------------------------------------------------------------------------- /appveyor/OpenNI/Win32/Bin/OpenNI.dll: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/strawlab/python-pcl/809199a3a62e8d98f8b8286db3051b6aee0b295b/appveyor/OpenNI/Win32/Bin/OpenNI.dll -------------------------------------------------------------------------------- /appveyor/OpenNI/Win32/Bin/OpenNI.jni.dll: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/strawlab/python-pcl/809199a3a62e8d98f8b8286db3051b6aee0b295b/appveyor/OpenNI/Win32/Bin/OpenNI.jni.dll -------------------------------------------------------------------------------- /appveyor/OpenNI/Win32/Bin/OpenNIFilter.dll: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/strawlab/python-pcl/809199a3a62e8d98f8b8286db3051b6aee0b295b/appveyor/OpenNI/Win32/Bin/OpenNIFilter.dll -------------------------------------------------------------------------------- /appveyor/OpenNI/Win32/Bin/Policy.1.1.OpenNI.Net.dll: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/strawlab/python-pcl/809199a3a62e8d98f8b8286db3051b6aee0b295b/appveyor/OpenNI/Win32/Bin/Policy.1.1.OpenNI.Net.dll -------------------------------------------------------------------------------- /appveyor/OpenNI/Win32/Bin/Policy.1.2.OpenNI.Net.dll: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/strawlab/python-pcl/809199a3a62e8d98f8b8286db3051b6aee0b295b/appveyor/OpenNI/Win32/Bin/Policy.1.2.OpenNI.Net.dll -------------------------------------------------------------------------------- /appveyor/OpenNI/Win32/Bin/Policy.1.3.OpenNI.Net.dll: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/strawlab/python-pcl/809199a3a62e8d98f8b8286db3051b6aee0b295b/appveyor/OpenNI/Win32/Bin/Policy.1.3.OpenNI.Net.dll -------------------------------------------------------------------------------- /appveyor/OpenNI/Win32/Bin/Policy.1.4.OpenNI.Net.dll: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/strawlab/python-pcl/809199a3a62e8d98f8b8286db3051b6aee0b295b/appveyor/OpenNI/Win32/Bin/Policy.1.4.OpenNI.Net.dll -------------------------------------------------------------------------------- /appveyor/OpenNI/Win32/Bin/Policy.1.5.OpenNI.Net.dll: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/strawlab/python-pcl/809199a3a62e8d98f8b8286db3051b6aee0b295b/appveyor/OpenNI/Win32/Bin/Policy.1.5.OpenNI.Net.dll -------------------------------------------------------------------------------- /appveyor/OpenNI/Win32/Bin/PublisherPolicy1.1.config: -------------------------------------------------------------------------------- 1 |  2 | 3 | 4 | 5 | 6 | 7 | 8 | 10 | 11 | 12 | 13 | -------------------------------------------------------------------------------- /appveyor/OpenNI/Win32/Bin/PublisherPolicy1.2.config: -------------------------------------------------------------------------------- 1 |  2 | 3 | 4 | 5 | 6 | 7 | 8 | 10 | 11 | 12 | 13 | -------------------------------------------------------------------------------- /appveyor/OpenNI/Win32/Bin/PublisherPolicy1.3.config: -------------------------------------------------------------------------------- 1 |  2 | 3 | 4 | 5 | 6 | 7 | 8 | 10 | 11 | 12 | 13 | -------------------------------------------------------------------------------- /appveyor/OpenNI/Win32/Bin/PublisherPolicy1.4.config: -------------------------------------------------------------------------------- 1 |  2 | 3 | 4 | 5 | 6 | 7 | 8 | 10 | 11 | 12 | 13 | -------------------------------------------------------------------------------- /appveyor/OpenNI/Win32/Bin/PublisherPolicy1.5.config: -------------------------------------------------------------------------------- 1 |  2 | 3 | 4 | 5 | 6 | 7 | 8 | 10 | 11 | 12 | 13 | -------------------------------------------------------------------------------- /appveyor/OpenNI/Win32/Bin/niLicense.exe: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/strawlab/python-pcl/809199a3a62e8d98f8b8286db3051b6aee0b295b/appveyor/OpenNI/Win32/Bin/niLicense.exe -------------------------------------------------------------------------------- /appveyor/OpenNI/Win32/Bin/niReg.exe: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/strawlab/python-pcl/809199a3a62e8d98f8b8286db3051b6aee0b295b/appveyor/OpenNI/Win32/Bin/niReg.exe -------------------------------------------------------------------------------- /appveyor/OpenNI/Win32/Bin/nimCodecs.dll: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/strawlab/python-pcl/809199a3a62e8d98f8b8286db3051b6aee0b295b/appveyor/OpenNI/Win32/Bin/nimCodecs.dll -------------------------------------------------------------------------------- /appveyor/OpenNI/Win32/Bin/nimMockNodes.dll: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/strawlab/python-pcl/809199a3a62e8d98f8b8286db3051b6aee0b295b/appveyor/OpenNI/Win32/Bin/nimMockNodes.dll -------------------------------------------------------------------------------- /appveyor/OpenNI/Win32/Bin/nimRecorder.dll: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/strawlab/python-pcl/809199a3a62e8d98f8b8286db3051b6aee0b295b/appveyor/OpenNI/Win32/Bin/nimRecorder.dll -------------------------------------------------------------------------------- /appveyor/OpenNI/Win32/Bin/org.OpenNI.jar: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/strawlab/python-pcl/809199a3a62e8d98f8b8286db3051b6aee0b295b/appveyor/OpenNI/Win32/Bin/org.OpenNI.jar -------------------------------------------------------------------------------- /appveyor/OpenNI/x64/Bin64/OpenNI.Net.dll: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/strawlab/python-pcl/809199a3a62e8d98f8b8286db3051b6aee0b295b/appveyor/OpenNI/x64/Bin64/OpenNI.Net.dll -------------------------------------------------------------------------------- /appveyor/OpenNI/x64/Bin64/OpenNI.jni64.dll: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/strawlab/python-pcl/809199a3a62e8d98f8b8286db3051b6aee0b295b/appveyor/OpenNI/x64/Bin64/OpenNI.jni64.dll -------------------------------------------------------------------------------- /appveyor/OpenNI/x64/Bin64/OpenNI64.dll: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/strawlab/python-pcl/809199a3a62e8d98f8b8286db3051b6aee0b295b/appveyor/OpenNI/x64/Bin64/OpenNI64.dll -------------------------------------------------------------------------------- /appveyor/OpenNI/x64/Bin64/Policy.1.1.OpenNI.Net.dll: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/strawlab/python-pcl/809199a3a62e8d98f8b8286db3051b6aee0b295b/appveyor/OpenNI/x64/Bin64/Policy.1.1.OpenNI.Net.dll -------------------------------------------------------------------------------- /appveyor/OpenNI/x64/Bin64/Policy.1.2.OpenNI.Net.dll: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/strawlab/python-pcl/809199a3a62e8d98f8b8286db3051b6aee0b295b/appveyor/OpenNI/x64/Bin64/Policy.1.2.OpenNI.Net.dll -------------------------------------------------------------------------------- /appveyor/OpenNI/x64/Bin64/Policy.1.3.OpenNI.Net.dll: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/strawlab/python-pcl/809199a3a62e8d98f8b8286db3051b6aee0b295b/appveyor/OpenNI/x64/Bin64/Policy.1.3.OpenNI.Net.dll -------------------------------------------------------------------------------- /appveyor/OpenNI/x64/Bin64/PublisherPolicy1.1.config: -------------------------------------------------------------------------------- 1 |  2 | 3 | 4 | 5 | 6 | 7 | 8 | 10 | 11 | 12 | 13 | -------------------------------------------------------------------------------- /appveyor/OpenNI/x64/Bin64/PublisherPolicy1.2.config: -------------------------------------------------------------------------------- 1 |  2 | 3 | 4 | 5 | 6 | 7 | 8 | 10 | 11 | 12 | 13 | -------------------------------------------------------------------------------- /appveyor/OpenNI/x64/Bin64/PublisherPolicy1.3.config: -------------------------------------------------------------------------------- 1 |  2 | 3 | 4 | 5 | 6 | 7 | 8 | 10 | 11 | 12 | 13 | -------------------------------------------------------------------------------- /appveyor/OpenNI/x64/Bin64/niLicense64.exe: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/strawlab/python-pcl/809199a3a62e8d98f8b8286db3051b6aee0b295b/appveyor/OpenNI/x64/Bin64/niLicense64.exe -------------------------------------------------------------------------------- /appveyor/OpenNI/x64/Bin64/niReg64.exe: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/strawlab/python-pcl/809199a3a62e8d98f8b8286db3051b6aee0b295b/appveyor/OpenNI/x64/Bin64/niReg64.exe -------------------------------------------------------------------------------- /appveyor/OpenNI/x64/Bin64/nimCodecs64.dll: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/strawlab/python-pcl/809199a3a62e8d98f8b8286db3051b6aee0b295b/appveyor/OpenNI/x64/Bin64/nimCodecs64.dll -------------------------------------------------------------------------------- /appveyor/OpenNI/x64/Bin64/nimMockNodes64.dll: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/strawlab/python-pcl/809199a3a62e8d98f8b8286db3051b6aee0b295b/appveyor/OpenNI/x64/Bin64/nimMockNodes64.dll -------------------------------------------------------------------------------- /appveyor/OpenNI/x64/Bin64/nimRecorder64.dll: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/strawlab/python-pcl/809199a3a62e8d98f8b8286db3051b6aee0b295b/appveyor/OpenNI/x64/Bin64/nimRecorder64.dll -------------------------------------------------------------------------------- /appveyor/OpenNI/x64/Bin64/org.OpenNI.jar: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/strawlab/python-pcl/809199a3a62e8d98f8b8286db3051b6aee0b295b/appveyor/OpenNI/x64/Bin64/org.OpenNI.jar -------------------------------------------------------------------------------- /appveyor/OpenNI2/Win32/Redist/OpenNI.ini: -------------------------------------------------------------------------------- 1 | [Log] 2 | ; 0 - Verbose; 1 - Info; 2 - Warning; 3 - Error. Default - None 3 | Verbosity=3 4 | LogToConsole=0 5 | LogToFile=0 6 | 7 | [Device] 8 | ;Override="" 9 | -------------------------------------------------------------------------------- /appveyor/OpenNI2/Win32/Redist/OpenNI2.dll: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/strawlab/python-pcl/809199a3a62e8d98f8b8286db3051b6aee0b295b/appveyor/OpenNI2/Win32/Redist/OpenNI2.dll -------------------------------------------------------------------------------- /appveyor/OpenNI2/Win32/Redist/OpenNI2.pdb: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/strawlab/python-pcl/809199a3a62e8d98f8b8286db3051b6aee0b295b/appveyor/OpenNI2/Win32/Redist/OpenNI2.pdb -------------------------------------------------------------------------------- /appveyor/OpenNI2/Win32/Redist/OpenNI2/Drivers/Kinect.dll: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/strawlab/python-pcl/809199a3a62e8d98f8b8286db3051b6aee0b295b/appveyor/OpenNI2/Win32/Redist/OpenNI2/Drivers/Kinect.dll -------------------------------------------------------------------------------- /appveyor/OpenNI2/Win32/Redist/OpenNI2/Drivers/Kinect.pdb: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/strawlab/python-pcl/809199a3a62e8d98f8b8286db3051b6aee0b295b/appveyor/OpenNI2/Win32/Redist/OpenNI2/Drivers/Kinect.pdb -------------------------------------------------------------------------------- /appveyor/OpenNI2/Win32/Redist/OpenNI2/Drivers/OniFile.dll: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/strawlab/python-pcl/809199a3a62e8d98f8b8286db3051b6aee0b295b/appveyor/OpenNI2/Win32/Redist/OpenNI2/Drivers/OniFile.dll -------------------------------------------------------------------------------- /appveyor/OpenNI2/Win32/Redist/OpenNI2/Drivers/OniFile.pdb: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/strawlab/python-pcl/809199a3a62e8d98f8b8286db3051b6aee0b295b/appveyor/OpenNI2/Win32/Redist/OpenNI2/Drivers/OniFile.pdb -------------------------------------------------------------------------------- /appveyor/OpenNI2/Win32/Redist/OpenNI2/Drivers/PS1080.dll: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/strawlab/python-pcl/809199a3a62e8d98f8b8286db3051b6aee0b295b/appveyor/OpenNI2/Win32/Redist/OpenNI2/Drivers/PS1080.dll -------------------------------------------------------------------------------- /appveyor/OpenNI2/Win32/Redist/OpenNI2/Drivers/PS1080.pdb: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/strawlab/python-pcl/809199a3a62e8d98f8b8286db3051b6aee0b295b/appveyor/OpenNI2/Win32/Redist/OpenNI2/Drivers/PS1080.pdb -------------------------------------------------------------------------------- /appveyor/OpenNI2/x64/Redist/OpenNI.ini: -------------------------------------------------------------------------------- 1 | [Log] 2 | ; 0 - Verbose; 1 - Info; 2 - Warning; 3 - Error. Default - None 3 | Verbosity=3 4 | LogToConsole=0 5 | LogToFile=0 6 | 7 | [Device] 8 | ;Override="" 9 | -------------------------------------------------------------------------------- /appveyor/OpenNI2/x64/Redist/OpenNI2.dll: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/strawlab/python-pcl/809199a3a62e8d98f8b8286db3051b6aee0b295b/appveyor/OpenNI2/x64/Redist/OpenNI2.dll -------------------------------------------------------------------------------- /appveyor/OpenNI2/x64/Redist/OpenNI2.pdb: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/strawlab/python-pcl/809199a3a62e8d98f8b8286db3051b6aee0b295b/appveyor/OpenNI2/x64/Redist/OpenNI2.pdb -------------------------------------------------------------------------------- /appveyor/OpenNI2/x64/Redist/OpenNI2/Drivers/Kinect.dll: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/strawlab/python-pcl/809199a3a62e8d98f8b8286db3051b6aee0b295b/appveyor/OpenNI2/x64/Redist/OpenNI2/Drivers/Kinect.dll -------------------------------------------------------------------------------- /appveyor/OpenNI2/x64/Redist/OpenNI2/Drivers/Kinect.pdb: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/strawlab/python-pcl/809199a3a62e8d98f8b8286db3051b6aee0b295b/appveyor/OpenNI2/x64/Redist/OpenNI2/Drivers/Kinect.pdb -------------------------------------------------------------------------------- /appveyor/OpenNI2/x64/Redist/OpenNI2/Drivers/OniFile.dll: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/strawlab/python-pcl/809199a3a62e8d98f8b8286db3051b6aee0b295b/appveyor/OpenNI2/x64/Redist/OpenNI2/Drivers/OniFile.dll -------------------------------------------------------------------------------- /appveyor/OpenNI2/x64/Redist/OpenNI2/Drivers/OniFile.pdb: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/strawlab/python-pcl/809199a3a62e8d98f8b8286db3051b6aee0b295b/appveyor/OpenNI2/x64/Redist/OpenNI2/Drivers/OniFile.pdb -------------------------------------------------------------------------------- /appveyor/OpenNI2/x64/Redist/OpenNI2/Drivers/PS1080.dll: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/strawlab/python-pcl/809199a3a62e8d98f8b8286db3051b6aee0b295b/appveyor/OpenNI2/x64/Redist/OpenNI2/Drivers/PS1080.dll -------------------------------------------------------------------------------- /appveyor/OpenNI2/x64/Redist/OpenNI2/Drivers/PS1080.pdb: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/strawlab/python-pcl/809199a3a62e8d98f8b8286db3051b6aee0b295b/appveyor/OpenNI2/x64/Redist/OpenNI2/Drivers/PS1080.pdb -------------------------------------------------------------------------------- /appveyor/eigen.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Software License Agreement (BSD License) 3 | * 4 | * Point Cloud Library (PCL) - www.pointclouds.org 5 | * Copyright (c) 2012-, Open Perception, Inc. 6 | * 7 | * All rights reserved. 8 | * 9 | * Redistribution and use in source and binary forms, with or without 10 | * modification, are permitted provided that the following conditions 11 | * are met: 12 | * 13 | * * Redistributions of source code must retain the above copyright 14 | * notice, this list of conditions and the following disclaimer. 15 | * * Redistributions in binary form must reproduce the above 16 | * copyright notice, this list of conditions and the following 17 | * disclaimer in the documentation and/or other materials provided 18 | * with the distribution. 19 | * * Neither the name of the copyright holder(s) nor the names of its 20 | * contributors may be used to endorse or promote products derived 21 | * from this software without specific prior written permission. 22 | * 23 | * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 24 | * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 25 | * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS 26 | * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE 27 | * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, 28 | * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, 29 | * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 30 | * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER 31 | * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 32 | * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN 33 | * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 34 | * POSSIBILITY OF SUCH DAMAGE. 35 | * 36 | * $Id: lmeds.h 1370 2011-06-19 01:06:01Z jspricke $ 37 | * 38 | */ 39 | 40 | #ifndef PCL_REGISTRATION_EIGEN_H_ 41 | #define PCL_REGISTRATION_EIGEN_H_ 42 | 43 | #if defined __GNUC__ 44 | # pragma GCC system_header 45 | #endif 46 | 47 | #include 48 | #include 49 | #include 50 | #include 51 | 52 | #endif // PCL_REGISTRATION_EIGEN_H_ 53 | -------------------------------------------------------------------------------- /appveyor/shared_ptr.hpp: -------------------------------------------------------------------------------- 1 | #ifndef BOOST_SHARED_PTR_HPP_INCLUDED 2 | #define BOOST_SHARED_PTR_HPP_INCLUDED 3 | 4 | // 5 | // shared_ptr.hpp 6 | // 7 | // (C) Copyright Greg Colvin and Beman Dawes 1998, 1999. 8 | // Copyright (c) 2001-2008 Peter Dimov 9 | // 10 | // Distributed under the Boost Software License, Version 1.0. (See 11 | // accompanying file LICENSE_1_0.txt or copy at 12 | // http://www.boost.org/LICENSE_1_0.txt) 13 | // 14 | // See http://www.boost.org/libs/smart_ptr/shared_ptr.htm for documentation. 15 | // 16 | 17 | #include 18 | 19 | #endif // #ifndef BOOST_SHARED_PTR_HPP_INCLUDED 20 | -------------------------------------------------------------------------------- /bld.bat: -------------------------------------------------------------------------------- 1 | pip install -r requirements.txt 2 | rem pip install -e . 3 | python setup.py build_ext -i 4 | python setup.py install 5 | rem python setup.py bdist_wheel 6 | nosetests -A "not pcl_ver_0_4" 7 | -------------------------------------------------------------------------------- /build.sh: -------------------------------------------------------------------------------- 1 | python setup.py build_ext -i 2 | python setup.py install 3 | nosetests -A "not pcl_ver_0_4" 4 | -------------------------------------------------------------------------------- /check.bat: -------------------------------------------------------------------------------- 1 | python setup.py build_ext -i > log.txt 2 | -------------------------------------------------------------------------------- /clean.bat: -------------------------------------------------------------------------------- 1 | del pcl\_pcl*.cpp 2 | del pcl\_pcl*.pyd 3 | del pcl\pcl_registration_*.cpp 4 | del pcl\pcl_registration_*.pyd 5 | del pcl\pcl_visualization*.cpp 6 | del pcl\pcl_visualization*.pyd 7 | del pcl\pcl_grabber*.cpp 8 | del pcl\pcl_grabber*.pyd 9 | rd /s /q build 10 | rd /s /q python_pcl.egg-info 11 | pip uninstall python-pcl -y -------------------------------------------------------------------------------- /clean.sh: -------------------------------------------------------------------------------- 1 | sudo rm pcl/_pcl*.cpp 2 | sudo rm pcl/_pcl*.pyd 3 | sudo rm pcl/pcl_registration_*.cpp 4 | sudo rm pcl/pcl_registration_*.pyd 5 | sudo rm pcl/pcl_visualization*.cpp 6 | sudo rm pcl/pcl_visualization*.pyd 7 | sudo rm pcl/pcl_grabber*.cpp 8 | sudo rm pcl/pcl_grabber*.pyd 9 | sudo rm -rf build 10 | sudo rm -rf python_pcl.egg-info 11 | pip uninstall python-pcl -y -------------------------------------------------------------------------------- /conf.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | 3 | # ensure that we use the local pcl (and not the system copy) to document 4 | import sys 5 | import os 6 | sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) 7 | import pcl 8 | assert pcl.PointCloud.__doc__ is not None 9 | 10 | extensions = ['sphinx.ext.autodoc', 'sphinx.ext.autosummary'] 11 | 12 | needs_sphinx = '1.1' 13 | autodoc_docstring_signature = True 14 | 15 | # dont create empty templates and static dirs 16 | templates_path = ['.'] 17 | html_static_path = ['.'] 18 | 19 | source_suffix = '.rst' 20 | master_doc = 'readme' 21 | 22 | # General information about the project. 23 | project = u'python-pcl' 24 | copyright = u'2013, John Stowers' 25 | version = '1.0' 26 | release = '1.0' 27 | 28 | exclude_patterns = ['build'] 29 | pygments_style = 'sphinx' 30 | 31 | html_theme = 'haiku' 32 | htmlhelp_basename = 'python-pcldoc' 33 | html_logo = 'pcl_logo.png' 34 | html_title = 'Python Bindings to the Point Cloud Library' 35 | html_short_title = '%s v%s' % (project, version) 36 | -------------------------------------------------------------------------------- /dev-requirements.txt: -------------------------------------------------------------------------------- 1 | nose 2 | wheel 3 | -------------------------------------------------------------------------------- /docker/Dockerfile: -------------------------------------------------------------------------------- 1 | # docker build -t ubuntu1604py36 . 2 | FROM ubuntu:16.04 3 | 4 | RUN apt-get update && \ 5 | apt-get install -y software-properties-common vim && \ 6 | add-apt-repository ppa:jonathonf/python-3.6 7 | 8 | RUN apt-get update -y 9 | 10 | RUN apt-get install cmake -y && \ 11 | apt-get install -y build-essential python3.6 python3.6-dev python3-pip python3.6-venv && \ 12 | apt-get install -y git && \ 13 | apt-get install openni2-utils -y && \ 14 | apt-get install libpcl-dev -y 15 | 16 | # fork module 17 | RUN git clone -b rc_patches4 https://github.com/Sirokujira/python-pcl.git 18 | # main 19 | # RUN git clone -b master https://github.com/strawlab/python-pcl.git 20 | 21 | WORKDIR /python-pcl 22 | 23 | # update pip 24 | RUN python3.6 -m pip install pip --upgrade && \ 25 | python3.6 -m pip install wheel 26 | 27 | RUN pip install -r requirements.txt && \ 28 | python3.6 setup.py build_ext -i && \ 29 | python3.6 setup.py install 30 | 31 | -------------------------------------------------------------------------------- /docker/Dockerfile2: -------------------------------------------------------------------------------- 1 | # docker build -t ubuntu1804py36 2 | FROM ubuntu:18.04 3 | 4 | RUN apt-get update && \ 5 | apt-get install -y software-properties-common vim && \ 6 | add-apt-repository ppa:jonathonf/python-3.6 7 | 8 | RUN apt-get update -y 9 | 10 | RUN apt-get install cmake -y && \ 11 | apt-get install -y build-essential python3.6 python3.6-dev python3-pip python3.6-venv && \ 12 | apt-get install -y git && \ 13 | apt-get install openni2-utils -y && \ 14 | apt-get install libpcl-dev -y 15 | 16 | # fork module 17 | RUN git clone -b rc_patches4 https://github.com/Sirokujira/python-pcl.git 18 | # main 19 | # RUN git clone -b master https://github.com/strawlab/python-pcl.git 20 | 21 | WORKDIR /python-pcl 22 | 23 | # update pip 24 | RUN python3.6 -m pip install pip --upgrade && \ 25 | python3.6 -m pip install wheel 26 | 27 | RUN pip install -r requirements.txt && \ 28 | python3.6 setup.py build_ext -i && \ 29 | python3.6 setup.py install 30 | 31 | -------------------------------------------------------------------------------- /docs/build.bat: -------------------------------------------------------------------------------- 1 | @ECHO OFF 2 | 3 | rem generate from '.po' to '.mo' files. 4 | sphinx-intl build 5 | rem generate html files. 6 | make html 7 | rem translation jp 8 | rem https://potranslator.readthedocs.io/ja/latest/readme.html#supported-languages 9 | rem Unix 10 | rem make -e SPHINXOPTS="-D language='ja'" html 11 | rem Windows 12 | rem set SPHINXOPTS=-D language=ja 13 | rem make html -------------------------------------------------------------------------------- /docs/image/pcl_logo_958x309.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/strawlab/python-pcl/809199a3a62e8d98f8b8286db3051b6aee0b295b/docs/image/pcl_logo_958x309.png -------------------------------------------------------------------------------- /docs/requirements.txt: -------------------------------------------------------------------------------- 1 | Cython==0.28.5 2 | numpy -------------------------------------------------------------------------------- /docs/source/_static/css/modified_theme.css: -------------------------------------------------------------------------------- 1 | @import url('theme.css'); 2 | 3 | /* Main background color modification */ 4 | .btn-info, .wy-menu-vertical a:active, .wy-side-nav-search, .wy-side-nav-search img, .wy-nav .wy-menu-vertical a:hover, .wy-nav-top img, .wy-tray-item-info, .wy-side-nav-search, .wy-dropdown-menu > dd > a:hover, .wy-dropdown-menu a:hover, .wy-nav-top { 5 | background-color: #70c162 !important; 6 | } 7 | 8 | .wy-side-nav-search input[type=text] { 9 | border-color: #72a424 !important; 10 | } 11 | 12 | .rst-content .note .admonition-title { 13 | background-color: #c9c9c9 !important; 14 | } 15 | 16 | .rst-content .note { 17 | background-color: #e3e3e3 !important; 18 | } 19 | 20 | 21 | /* code style */ 22 | .rst-content table.longtable.docutils code { 23 | font-size: 100% !important; 24 | background-color: transparent !important; 25 | border: none !important; 26 | } 27 | 28 | .rst-content a.reference code { 29 | color: #3399cc !important; 30 | } 31 | 32 | .rst-content a.reference code:hover { 33 | text-decoration: underline !important; 34 | color: #3366cc !important; 35 | } 36 | 37 | 38 | /* rubric */ 39 | .rst-content .class .rubric { 40 | color: #333333; 41 | background-color: #aaeeaa; 42 | padding: 0.2em 0 0.2em 1em; 43 | border-top: solid 0.3em #66cc66; 44 | } 45 | -------------------------------------------------------------------------------- /docs/source/_templates/autosummary/class.rst: -------------------------------------------------------------------------------- 1 | {{ fullname }} 2 | {{ underline }} 3 | 4 | .. currentmodule:: {{ module }} 5 | 6 | .. autoclass:: {{ objname }} 7 | 8 | .. 9 | Methods 10 | 11 | {% block methods %} 12 | 13 | .. rubric:: Methods 14 | 15 | .. 16 | Special methods 17 | 18 | {% for item in ('__call__', '__enter__', '__exit__', '__getitem__', '__setitem__', '__len__', '__next__', '__iter__', '__copy__') %} 19 | {% if item in all_methods %} 20 | .. automethod:: {{ item }} 21 | {% endif %} 22 | {%- endfor %} 23 | 24 | .. 25 | Ordinary methods 26 | 27 | {% for item in methods %} 28 | {% if item not in ('__init__',) %} 29 | .. automethod:: {{ item }} 30 | {% endif %} 31 | {%- endfor %} 32 | 33 | .. 34 | Special methods 35 | 36 | {% for item in ('__eq__', '__ne__', '__lt__', '__le__', '__gt__', '__ge__', '__nonzero__', '__bool__') %} 37 | {% if item in all_methods %} 38 | .. automethod:: {{ item }} 39 | {% endif %} 40 | {%- endfor %} 41 | {% endblock %} 42 | 43 | .. 44 | Atributes 45 | 46 | {% block attributes %} {% if attributes %} 47 | 48 | .. rubric:: Attributes 49 | 50 | {% for item in attributes %} 51 | .. autoattribute:: {{ item }} 52 | {%- endfor %} 53 | {% endif %} {% endblock %} 54 | -------------------------------------------------------------------------------- /docs/source/developers.rst: -------------------------------------------------------------------------------- 1 | ========================= 2 | For python-pcl Developers 3 | ========================= 4 | 5 | .. toctree:: 6 | 7 | contribution 8 | compatibility 9 | -------------------------------------------------------------------------------- /docs/source/index.rst: -------------------------------------------------------------------------------- 1 | ============================================ 2 | python-pcl -- PointCloudLibrary-like API 3 | ============================================ 4 | 5 | This is the `python-pcl `_ documentation. 6 | 7 | .. module:: python-pcl 8 | 9 | .. toctree:: 10 | :maxdepth: 1 11 | 12 | overview 13 | install 14 | tutorial/index 15 | reference/index 16 | developers 17 | license 18 | -------------------------------------------------------------------------------- /docs/source/locale/ja/LC_MESSAGES/developers.po: -------------------------------------------------------------------------------- 1 | # SOME DESCRIPTIVE TITLE. 2 | # Copyright (C) 2017, Tooru Oonuma. 3 | # This file is distributed under the same license as the python-pcl package. 4 | # FIRST AUTHOR , 2018. 5 | # 6 | #, fuzzy 7 | msgid "" 8 | msgstr "" 9 | "Project-Id-Version: python-pcl 0.3\n" 10 | "Report-Msgid-Bugs-To: \n" 11 | "POT-Creation-Date: 2018-10-15 16:12+0900\n" 12 | "PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n" 13 | "Last-Translator: FULL NAME \n" 14 | "Language-Team: LANGUAGE \n" 15 | "MIME-Version: 1.0\n" 16 | "Content-Type: text/plain; charset=utf-8\n" 17 | "Content-Transfer-Encoding: 8bit\n" 18 | "Generated-By: Babel 2.6.0\n" 19 | 20 | #: ../../source/developers.rst:3 21 | msgid "For python-pcl Developers" 22 | msgstr "" 23 | 24 | -------------------------------------------------------------------------------- /docs/source/locale/ja/LC_MESSAGES/index.po: -------------------------------------------------------------------------------- 1 | # SOME DESCRIPTIVE TITLE. 2 | # Copyright (C) 2017, Tooru Oonuma. 3 | # This file is distributed under the same license as the python-pcl package. 4 | # FIRST AUTHOR , 2018. 5 | # 6 | #, fuzzy 7 | msgid "" 8 | msgstr "" 9 | "Project-Id-Version: python-pcl 0.3\n" 10 | "Report-Msgid-Bugs-To: \n" 11 | "POT-Creation-Date: 2018-10-15 16:12+0900\n" 12 | "PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n" 13 | "Last-Translator: FULL NAME \n" 14 | "Language-Team: LANGUAGE \n" 15 | "MIME-Version: 1.0\n" 16 | "Content-Type: text/plain; charset=utf-8\n" 17 | "Content-Transfer-Encoding: 8bit\n" 18 | "Generated-By: Babel 2.6.0\n" 19 | 20 | #: ../../source/index.rst:3 21 | msgid "python-pcl -- PointCloudLibrary-like API" 22 | msgstr "" 23 | 24 | #: ../../source/index.rst:5 25 | msgid "" 26 | "This is the `python-pcl `_ " 27 | "documentation." 28 | msgstr "これは `python-pcl `_ の日本語ドキュメントです" 29 | 30 | -------------------------------------------------------------------------------- /docs/source/overview.rst: -------------------------------------------------------------------------------- 1 | .. _overview: 2 | 3 | python-pcl Overview 4 | ============= 5 | 6 | .. module:: python-pcl 7 | 8 | `python-pcl `_ is an implementation of PointCloudLibrary-compatible. 9 | interface. 10 | 11 | The following is a brief overview of supported subset of PointCloudLibrary interface: 12 | 13 | - `filters `_ 14 | - `features `_ 15 | - `keypoints `_ 16 | - `registration `_ 17 | - `kdtree `_ 18 | - `octree `_ 19 | - `segmentation `_ 20 | - `sample_consensus `_ 21 | - `surface `_ 22 | - `recognition `_ 23 | - `io `_ 24 | - `visualization `_ 25 | 26 | 27 | -------------------------------------------------------------------------------- /docs/source/reference/index.rst: -------------------------------------------------------------------------------- 1 | .. _python-pcl_reference: 2 | 3 | *************************** 4 | python-pcl Reference Manual 5 | *************************** 6 | 7 | This is the official reference of python-pcl, PointCloudLibrary-like API interface. 8 | 9 | 10 | Indices and tables 11 | ================== 12 | 13 | * :ref:`genindex` 14 | * :ref:`modindex` 15 | 16 | Reference 17 | ========= 18 | 19 | .. module:: python-pcl 20 | 21 | .. toctree:: 22 | :maxdepth: 1 23 | 24 | pcl 25 | -------------------------------------------------------------------------------- /docs/source/reference/pcl.rst: -------------------------------------------------------------------------------- 1 | pcl package 2 | =========== 3 | 4 | Submodules 5 | ---------- 6 | 7 | 8 | pcl.pcl\_visualization module 9 | ----------------------------- 10 | 11 | .. automodule:: pcl.pcl_visualization 12 | :members: 13 | :undoc-members: 14 | :show-inheritance: 15 | 16 | 17 | Module contents 18 | --------------- 19 | 20 | .. automodule:: pcl 21 | :members: 22 | :undoc-members: 23 | :show-inheritance: 24 | -------------------------------------------------------------------------------- /docs/source/tutorial/GPU.rst: -------------------------------------------------------------------------------- 1 | GPU Tutorials 2 | ============= 3 | 4 | 5 | Configuring your PC to use your Nvidia GPU with PCL 6 | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7 | This tutorial explains how to configure PCL to use with a Nvidia GPU 8 | 9 | * `Original `_ \ 10 | * TestCode : None 11 | 12 | 13 | Using Kinfu Large Scale to generate a textured mesh 14 | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 15 | This tutorial demonstrates how to use KinFu Large Scale to produce a mesh from a room, and apply texture information in post-processing for a more appealing visual result. 16 | 17 | * `Original `_ \ 18 | * TestCode : None 19 | 20 | 21 | Detecting people and their poses using PointCloud Library 22 | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 23 | This tutorial presents a method for people and pose detection. 24 | 25 | * `Original `_ \ 26 | * TestCode : None 27 | 28 | 29 | -------------------------------------------------------------------------------- /docs/source/tutorial/application.rst: -------------------------------------------------------------------------------- 1 | Applications Tutorials 2 | ====================== 3 | 4 | 5 | Aligning object templates to a point cloud 6 | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7 | This tutorial gives an example of how some of the tools covered in the previous tutorials can be combined to solve a higher level problem - aligning a previously captured model of an object to some newly captured data. 8 | 9 | * `Original `_ \ 10 | * TestCode : None 11 | 12 | 13 | Cluster Recognition and 6DOF Pose Estimation using VFH descriptors 14 | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 15 | In this tutorial we show how the Viewpoint Feature Histogram (VFH) descriptor can be used to recognize similar clusters in terms of their geometry. 16 | 17 | * `Original `_ \ 18 | * TestCode : None 19 | 20 | 21 | Point Cloud Streaming to Mobile Devices with Real-time Visualization 22 | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 23 | This tutorial describes how to send point cloud data over the network from a desktop server to a client running on a mobile device. 24 | 25 | * `Original `_ \ 26 | * TestCode : None 27 | 28 | 29 | Detecting people on a ground plane with RGB-D data 30 | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 31 | This tutorial presents a method for detecting people on a ground plane with RGB-D data. 32 | 33 | * `Original `_ \ 34 | * TestCode : None 35 | 36 | 37 | -------------------------------------------------------------------------------- /docs/source/tutorial/features.rst: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/strawlab/python-pcl/809199a3a62e8d98f8b8286db3051b6aee0b295b/docs/source/tutorial/features.rst -------------------------------------------------------------------------------- /docs/source/tutorial/index.rst: -------------------------------------------------------------------------------- 1 | python-pcl Tutorial 2 | =================== 3 | 4 | .. toctree:: 5 | :maxdepth: 1 6 | 7 | application 8 | features 9 | filtering 10 | GPU 11 | io 12 | keypoint 13 | kdtree 14 | octree 15 | rangeImage 16 | recognition 17 | registration 18 | sampleconsensus 19 | segmentation 20 | surface 21 | tracking 22 | visualization 23 | -------------------------------------------------------------------------------- /docs/source/tutorial/kdtree.rst: -------------------------------------------------------------------------------- 1 | KdTree Tutorials 2 | ================ 3 | 4 | How to use a KdTree to search 5 | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 6 | 7 | In this tutorial, we will learn how to search using the nearest neighbor method for k-d trees 8 | 9 | * `Original `_ \ 10 | * TestCode : examples/official/kdtree/kdtree_search.py 11 | -------------------------------------------------------------------------------- /docs/source/tutorial/keypoint.rst: -------------------------------------------------------------------------------- 1 | KeyPoint Tutorials 2 | ================== 3 | 4 | How to extract NARF keypoint from a range image 5 | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 6 | In this tutorial, we will learn how to extract NARF keypoints from a range image. 7 | 8 | * `Original `_ \ 9 | * TestCode : examples/official/keypoints/narf_keypoint_extraction.py 10 | 11 | 12 | -------------------------------------------------------------------------------- /docs/source/tutorial/octree.rst: -------------------------------------------------------------------------------- 1 | Octree Tutorials 2 | ================ 3 | 4 | Point Cloud Compression 5 | ~~~~~~~~~~~~~~~~~~~~~~~ 6 | In this tutorial, we will learn how to compress a single point cloud and streams of point clouds. 7 | 8 | * `Original `_ \ 9 | * TestCode : None 10 | 11 | 12 | Spatial Partitioning and Search Operations with Octrees 13 | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 14 | In this tutorial, we will learn how to use octrees for spatial partitioning and nearest neighbor search. 15 | 16 | * `Original `_ \ 17 | * TestCode : examples/official/octree/octree_search.py 18 | 19 | 20 | Spatial change detection on unorganized point cloud data 21 | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 22 | In this tutorial, we will learn how to use octrees for detecting spatial changes within point clouds. 23 | 24 | * `Original `_ \ 25 | * TestCode : examples/official/octree/octree_change_detection.py 26 | 27 | 28 | -------------------------------------------------------------------------------- /docs/source/tutorial/rangeImage.rst: -------------------------------------------------------------------------------- 1 | RangeImage Tutorials 2 | ==================== 3 | 4 | How to create a range image from a point cloud 5 | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 6 | This tutorial demonstrates how to create a range image from a point cloud and a given sensor position. 7 | 8 | * `Original `_ \ 9 | * TestCode : None 10 | 11 | 12 | How to extract borders from range images 13 | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 14 | This tutorial demonstrates how to extract borders (traversals from foreground to background) from a range image. 15 | 16 | * `Original `_ \ 17 | * TestCode : examples/official/RangeImage/range_image_border_extraction.py 18 | 19 | 20 | -------------------------------------------------------------------------------- /docs/source/tutorial/recognition.rst: -------------------------------------------------------------------------------- 1 | Recognition Tutorials 2 | ===================== 3 | 4 | 5 | 3D Object Recognition based on Correspondence Grouping 6 | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7 | This tutorial aims at explaining how to perform 3D Object Recognition based on the pcl_recognition module. 8 | 9 | * `Original `_ \ 10 | * TestCode : None 11 | 12 | 13 | Implicit Shape Model 14 | ~~~~~~~~~~~~~~~~~~~~ 15 | In this tutorial we will learn how the Implicit Shape Model algorithm works and how to use it for finding objects centers. 16 | 17 | * `Original `_ \ 18 | * TestCode : None 19 | 20 | 21 | Tutorial: Hypothesis Verification for 3D Object Recognition 22 | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 23 | This tutorial aims at explaining how to do 3D object recognition in clutter by verifying model hypotheses in cluttered and heavily occluded 3D scenes. 24 | 25 | * `Original `_ \ 26 | * TestCode : None 27 | 28 | 29 | -------------------------------------------------------------------------------- /docs/source/tutorial/sampleconsensus.rst: -------------------------------------------------------------------------------- 1 | Sampleconsensus Tutorials 2 | ========================= 3 | 4 | 5 | How to use Random Sample Consensus model 6 | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7 | In this tutorial we learn how to use a RandomSampleConsensus with a plane model to obtain the cloud fitting to this model. 8 | 9 | * `Original `_ \ 10 | * TestCode : examples/official/SampleConsensus/random_sample_consensus.py 11 | 12 | 13 | -------------------------------------------------------------------------------- /docs/source/tutorial/surface.rst: -------------------------------------------------------------------------------- 1 | surface Tutorials 2 | ================= 3 | 4 | 5 | Smoothing and normal estimation based on polynomial reconstruction 6 | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7 | In this tutorial, we will learn how to construct and run a Moving Least Squares (MLS) algorithm to obtain smoothed XYZ coordinates and normals. 8 | 9 | * `Original `_ \ 10 | * TestCode : None 11 | 12 | 13 | Construct a concave or convex hull polygon for a plane model 14 | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 15 | In this tutorial we will learn how to calculate a simple 2D concave or convex hull polygon for a set of points supported by a plane. 16 | 17 | * `Original `_ \ 18 | * TestCode : examples/official/Surface/concave_hull_2d.py 19 | 20 | 21 | Fast triangulation of unordered point clouds 22 | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 23 | In this tutorial we will learn how to run a greedy triangulation algorithm on a PointCloud with normals to obtain a triangle mesh based on projections of the local neighborhood. 24 | 25 | * `Original `_ \ 26 | * TestCode : None 27 | 28 | 29 | Fitting trimmed B-splines to unordered point clouds 30 | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 31 | In this tutorial we will learn how to reconstruct a smooth surface from an unordered point-cloud by fitting trimmed B-splines. 32 | 33 | * `Original `_ \ 34 | * TestCode : None 35 | 36 | 37 | -------------------------------------------------------------------------------- /docs/source/tutorial/tracking.rst: -------------------------------------------------------------------------------- 1 | Tracking Tutorials 2 | ================== 3 | 4 | Tracking Example 5 | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 6 | In this tutorial, we will learn how to construct and run a Moving Least Squares (MLS) algorithm to obtain smoothed XYZ coordinates and normals. 7 | 8 | * Original Page : None (tutorials/sources/tracking/tracking_sample.cpp) 9 | * TestCode : None -------------------------------------------------------------------------------- /docs/source/tutorial/visualization.rst: -------------------------------------------------------------------------------- 1 | Visualization Tutorials 2 | ======================= 3 | 4 | 5 | The CloudViewer 6 | ~~~~~~~~~~~~~~~ 7 | This tutorial demonstrates how to use the pcl visualization tools. 8 | 9 | * `Original `_ \ 10 | * TestCode : None 11 | 12 | 13 | How to visualize a range image 14 | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 15 | This tutorial demonstrates how to use the pcl visualization tools for range images. 16 | 17 | * `Original `_ \ 18 | * TestCode : None 19 | 20 | 21 | PCLVisualizer 22 | ~~~~~~~~~~~~~ 23 | This tutorial demonstrates how to use the PCLVisualizer class for powerful visualisation of point clouds and related data. 24 | 25 | * `Original `_ \ 26 | * TestCode : None 27 | 28 | 29 | PCLPlotter 30 | ~~~~~~~~~~ 31 | This tutorial demonstrates how to use the PCLPlotter class for powerful visualisation of plots, charts and histograms of raw data and explicit functions. 32 | 33 | * `Original `_ \ 34 | * TestCode : None 35 | 36 | 37 | Visualization 38 | ~~~~~~~~~~~~~ 39 | This tutorial will give an overview on the usage of the PCL visualization tools. 40 | 41 | * `Original `_ \ 42 | * TestCode : None 43 | 44 | 45 | Create a PCL visualizer in Qt with cmake 46 | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 47 | This tutorial shows you how to create a PCL visualizer within a Qt application. 48 | 49 | * `Original `_ \ 50 | * TestCode : None 51 | 52 | 53 | Create a PCL visualizer in Qt to colorize clouds 54 | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 55 | This tutorial shows you how to color point clouds within a Qt application. 56 | 57 | * `Original `_ \ 58 | * TestCode : None 59 | 60 | 61 | -------------------------------------------------------------------------------- /docs/translate.bat: -------------------------------------------------------------------------------- 1 | @ECHO OFF 2 | 3 | rem generate and update translation files. 4 | rem generate(update) from '.rst' to '.pot' files.[build/locale] 5 | make gettext 6 | rem generate(update) from '.pot' to '.po' files.[move source/locale] 7 | rem ex. ja 8 | sphinx-intl update -p build/locale -l ja 9 | rem : before settings(set API token) 10 | rem tx init 11 | rem : using transifex(official : https://docs.transifex.com/integrations/sphinx-doc) 12 | rem : # 'sphinx.ext.pngmath', 13 | rem sphinx-intl update-txconfig-resources --pot-dir build/locale --transifex-project-name="" 14 | rem : [transifex] start define. 15 | rem : regist po files. 16 | rem tx push -s 17 | rem : upload pot files. 18 | rem : language transifer. 19 | rem : downloads po files. 20 | rem : tx pull -l ja 21 | rem : [transifex] end define 22 | rem : sphinx-intl build 23 | rem : make -e SPHINXOPTS="-Dlanguage='ja'" html 24 | -------------------------------------------------------------------------------- /environment.yml: -------------------------------------------------------------------------------- 1 | name: python-pcl 2 | channels: 3 | - !!python/unicode 4 | 'conda-forge' 5 | - !!python/unicode 6 | 'menpo' 7 | - !!python/unicode 8 | 'sirokujira' 9 | - !!python/unicode 10 | 'defaults' 11 | dependencies: 12 | - Cython=0.28.5 13 | - pcl=1.8.1 14 | - vtk=8.0.1 15 | - matplotlib 16 | - numpy 17 | -------------------------------------------------------------------------------- /environment_minimum.yml: -------------------------------------------------------------------------------- 1 | name: python-pcl 2 | channels: 3 | - !!python/unicode 4 | 'defaults' 5 | dependencies: 6 | - Cython=0.28.5 7 | - numpy 8 | -------------------------------------------------------------------------------- /examples/GrabberCallbackTest.py: -------------------------------------------------------------------------------- 1 | import pcl.pcl_grabber 2 | 3 | 4 | def func(obj): 5 | print(obj) 6 | obj.Test() # Call to a specific method from class 'PyGrabberNode' 7 | return obj.d_prop 8 | 9 | 10 | def main(): 11 | n = pcl.pcl_grabber.PyGrabberNode() # Custom class of my own 12 | cb = pcl.pcl_grabber.PyGrabberCallback(func) 13 | print(cb.execute(n)) 14 | 15 | 16 | if __name__ == "__main__": 17 | # import cProfile 18 | # cProfile.run('main()', sort='time') 19 | main() 20 | -------------------------------------------------------------------------------- /examples/cropbox.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | from __future__ import print_function 3 | 4 | import numpy as np 5 | import pcl 6 | 7 | 8 | def main(): 9 | cloud = pcl.load( 10 | './examples/pcldata/tutorials/table_scene_mug_stereo_textured.pcd') 11 | 12 | # pcl::CropBox clipper; 13 | # clipper.setInputCloud(cloud); 14 | clipper = cloud.make_cropbox() 15 | 16 | # pcl::PCDWriter writer; 17 | # pcl::PointCloud::Ptr outcloud; 18 | outcloud = pcl.PointCloud() 19 | 20 | # clipper.setTranslation(Eigen::Vector3f(pose->tx, pose->ty, pose->tz)); 21 | # clipper.setRotation(Eigen::Vector3f(pose->rx, pose->ry, pose->rz)); 22 | # clipper.setMin(-Eigen::Vector4f(tracklet->l/2, tracklet->w/2, 0, 0)); 23 | # clipper.setMax(Eigen::Vector4f(tracklet->l/2, tracklet->w/2, tracklet->h, 0)); 24 | # clipper.filter(*outcloud); 25 | tx = 0 26 | ty = 0 27 | tz = 0 28 | clipper.set_Translation(tx, ty, tz) 29 | rx = 0 30 | ry = 0 31 | rz = 0 32 | clipper.set_Rotation(rx, ry, rz) 33 | minx = -1.5 34 | miny = -1.5 35 | minz = 2 36 | mins = 0 37 | maxx = 3.5 38 | maxy = 3.5 39 | maxz = 3 40 | maxs = 0 41 | clipper.set_MinMax(minx, miny, minz, mins, maxx, maxy, maxz, maxs) 42 | clipper.Filtering(outcloud) 43 | 44 | pcl.save(outcloud, "test.pcd") 45 | 46 | # stringstream outfilename; 47 | # outfilename << outfile << tracklet->objectType << i << ".pcd"; 48 | # if(!outcloud->empty()){ 49 | # cout << "Found "<size() << " points, writing to " << outfilename.str() << endl; 50 | # writer.write (outfilename.str(), *outcloud, false); 51 | # }else{ 52 | # cerr << "Couldn't find points for tracklet" << tracklet->objectType << i << endl; 53 | # } 54 | 55 | 56 | if __name__ == "__main__": 57 | # import cProfile 58 | # cProfile.run('main()', sort='time') 59 | main() 60 | -------------------------------------------------------------------------------- /examples/external/laspy/ReadMe.md: -------------------------------------------------------------------------------- 1 | 2 | 1. Install module 3 | pip install laspy 4 | 5 | Use Data : ShizuokaDB las files. 6 | https://pointcloud.pref.shizuoka.jp/ 7 | 8 | XYZTestData : 9 | https://pointcloud.pref.shizuoka.jp/lasmap/ankendetail?ankenno=28XXX10000075 10 | 11 | XYZRGBTestData : 12 | https://pointcloud.pref.shizuoka.jp/lasmap/ankendetail?ankenno=28W0608011101 13 | 14 | -------------------------------------------------------------------------------- /examples/external/laspy/visualization_test.py: -------------------------------------------------------------------------------- 1 | import numpy as np 2 | import random 3 | import scipy as sc 4 | from laspy import file 5 | from pcl import pcl_visualization 6 | 7 | 8 | def main(): 9 | import pcl 10 | # laspy librairy, read las file 11 | f = file.File('28XXX10000075-18.las', mode='r') 12 | # Store pointcloud in array 13 | ptcloud = np.vstack((f.x, f.y, f.z)).transpose() 14 | f.close() 15 | 16 | # cloud = pcl.load('./examples/pcldata/tutorials/table_scene_mug_stereo_textured.pcd') 17 | # ptcloud = cloud.to_list() 18 | 19 | # Centred the data 20 | ptcloud_centred = ptcloud - np.mean(ptcloud, 0) 21 | 22 | # Simulate an intensity information between 0 and 1 23 | ptcloud_centred = sc.append( 24 | ptcloud_centred, np.zeros((ptcloud.shape[0], 1)), axis=1) 25 | for i in range(ptcloud_centred.shape[0] - 1): 26 | ptcloud_centred[i, 3] = random.random() 27 | 28 | p = pcl.PointCloud_PointXYZI() 29 | p.from_array(np.array(ptcloud_centred, dtype=np.float32)) 30 | 31 | # Visualization 32 | visual = pcl_visualization.CloudViewing() 33 | visual.ShowGrayCloud(p, b'cloud') 34 | 35 | v = True 36 | while v: 37 | v = not(visual.WasStopped()) 38 | 39 | 40 | if __name__ == "__main__": 41 | # import cProfile 42 | # cProfile.run('main()', sort='time') 43 | main() 44 | -------------------------------------------------------------------------------- /examples/external/libfreenect2/ReadMe.md: -------------------------------------------------------------------------------- 1 | 2 | 0. libfreenect2 install 3 | https://github.com/OpenKinect/libfreenect2 4 | 5 | 1. pylibfreenect2 install 6 | 7 | 1-a. pip install 8 | ```cmd 9 | pip install pylibfreenect2 10 | ``` 11 | 12 | 1-b. Source Code 13 | ```cmd 14 | git clone https://github.com/r9y9/pylibfreenect2.git 15 | python setup.py install 16 | ``` 17 | 18 | Reference : 19 | http://r9y9.github.io/pylibfreenect2/stable/installation.html 20 | 21 | 2. execute example 22 | 23 | * before Kinect2 device connected 24 | 25 | python examples.py 26 | 27 | 28 | -------------------------------------------------------------------------------- /examples/external/libfreenect2/test.txt: -------------------------------------------------------------------------------- 1 | # https://github.com/r9y9/pylibfreenect2 2 | 3 | 1. install 4 | git clone https://github.com/r9y9/pylibfreenect2.git 5 | python setup.py install 6 | 7 | 2. 8 | 9 | 10 | 11 | -------------------------------------------------------------------------------- /examples/external/matlabplot/test.py: -------------------------------------------------------------------------------- 1 | import pcl 2 | import numpy as np 3 | from mpl_toolkits.mplot3d import Axes3D 4 | import matplotlib.pyplot as plt 5 | 6 | def main(): 7 | pt = pcl.load('bunny.pcd') 8 | 9 | shape = pt.to_array().transpose() 10 | 11 | fig = plt.figure() 12 | ax = fig.add_subplot(111, projection='3d') 13 | 14 | x = shape[0] 15 | y = shape[1] 16 | z = shape[2] 17 | 18 | ax.scatter(x, y, z, c='r', marker='o') 19 | 20 | ax.set_xlabel('X Label') 21 | ax.set_ylabel('Y Label') 22 | ax.set_zlabel('Z Label') 23 | 24 | plt.show() 25 | 26 | 27 | if __name__ == "__main__": 28 | # import cProfile 29 | # cProfile.run('main()', sort='time') 30 | main() -------------------------------------------------------------------------------- /examples/external/opencv/grabber_sequences/pclzf/frame_20121214T142255.814212.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 525 4 | 525 5 | 320 6 | 240 7 | 8 | 9 | 525 10 | 525 11 | 320 12 | 240 13 | 0.001 14 | 15 | -------------------------------------------------------------------------------- /examples/external/opencv/grabber_sequences/pclzf/frame_20121214T142256.068683.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 525 4 | 525 5 | 320 6 | 240 7 | 8 | 9 | 525 10 | 525 11 | 320 12 | 240 13 | 0.001 14 | 15 | -------------------------------------------------------------------------------- /examples/external/opencv/grabber_sequences/pclzf/frame_20121214T142256.332395.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 525 4 | 525 5 | 320 6 | 240 7 | 8 | 9 | 525 10 | 525 11 | 320 12 | 240 13 | 0.001 14 | 15 | -------------------------------------------------------------------------------- /examples/external/opencv/grabber_sequences/tiff/frame_20121214T142255.814212_depth.tiff: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/strawlab/python-pcl/809199a3a62e8d98f8b8286db3051b6aee0b295b/examples/external/opencv/grabber_sequences/tiff/frame_20121214T142255.814212_depth.tiff -------------------------------------------------------------------------------- /examples/external/opencv/grabber_sequences/tiff/frame_20121214T142255.814212_rgb.tiff: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/strawlab/python-pcl/809199a3a62e8d98f8b8286db3051b6aee0b295b/examples/external/opencv/grabber_sequences/tiff/frame_20121214T142255.814212_rgb.tiff -------------------------------------------------------------------------------- /examples/external/opencv/grabber_sequences/tiff/frame_20121214T142256.068683_depth.tiff: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/strawlab/python-pcl/809199a3a62e8d98f8b8286db3051b6aee0b295b/examples/external/opencv/grabber_sequences/tiff/frame_20121214T142256.068683_depth.tiff -------------------------------------------------------------------------------- /examples/external/opencv/grabber_sequences/tiff/frame_20121214T142256.068683_rgb.tiff: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/strawlab/python-pcl/809199a3a62e8d98f8b8286db3051b6aee0b295b/examples/external/opencv/grabber_sequences/tiff/frame_20121214T142256.068683_rgb.tiff -------------------------------------------------------------------------------- /examples/external/opencv/grabber_sequences/tiff/frame_20121214T142256.332395_depth.tiff: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/strawlab/python-pcl/809199a3a62e8d98f8b8286db3051b6aee0b295b/examples/external/opencv/grabber_sequences/tiff/frame_20121214T142256.332395_depth.tiff -------------------------------------------------------------------------------- /examples/external/opencv/grabber_sequences/tiff/frame_20121214T142256.332395_rgb.tiff: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/strawlab/python-pcl/809199a3a62e8d98f8b8286db3051b6aee0b295b/examples/external/opencv/grabber_sequences/tiff/frame_20121214T142256.332395_rgb.tiff -------------------------------------------------------------------------------- /examples/external/ros/ReadMe.md: -------------------------------------------------------------------------------- 1 | 2 | ## Table of Contents 3 | - [Dependencies](#dependencies) 4 | - [ROS](#ros) 5 | - [ros-utils](#ros-utils) 6 | - [Installation](#installation) 7 | - [ROS Package](#ros-package) 8 | - [ROS Compilation](#ros-compilation) 9 | - [Tutorials](#tutorials) 10 | - [CMAKE flags](#cmake-flags) 11 | - [Standalone](#standalone) 12 | - [Compilation](#compilation) 13 | - [Run](#run) 14 | 15 | # License 16 | 17 | # Dependencies 18 | 19 | ## ROS 20 | 21 | We have tested ???? in Ubuntu 16.04 with ROS Kinetic. 22 | To install ROS (Kinetic) use the following command: 23 | `sudo apt-get install ros-kinetic-desktop` 24 | 25 | We have tested ???? in Ubuntu 18.04 with ROS Melodic. 26 | To install ROS (Melodic) use the following command: 27 | `sudo apt-get install ros-Melodic-desktop` 28 | 29 | ## SuiteSparse 30 | 31 | Suitespare is a dependency, so it needs to be installed 32 | 33 | `sudo apt-get install libsuitesparse-dev` 34 | 35 | ## ros-utils 36 | 37 | Install our [ros-utils](https://github.com/lrse/ros-utils) library from the source code provided in 38 | 39 | `git clone git@github.com:lrse/ros-utils.git` 40 | 41 | # ROS Package 42 | 43 | ## ROS Compilation 44 | 45 | `catkin_make --pkg sptam -DCMAKE_BUILD_TYPE=RelWithDebInfo -DSINGLE_THREAD=OFF -DSHOW_TRACKED_FRAMES=ON -DSHOW_PROFILING=ON -DPARALLELIZE=ON` 46 | 47 | To activate Loop Closing capabilities (requires DBoW2 and OpenGV dependencies). 48 | 49 | `catkin_make --pkg sptam -DCMAKE_BUILD_TYPE=RelWithDebInfo -DUSE_LOOPCLOSURE=ON -DSINGLE_THREAD=OFF -DSHOW_TRACKED_FRAMES=ON -DSHOW_PROFILING=ON -DPARALLELIZE=ON` 50 | 51 | For more information about compilation flags see [CMAKE flags](#cmakeFlags) section. 52 | 53 | 54 | 1-b. Source Code 55 | ```cmd 56 | git clone https://github.com/r9y9/pylibfreenect2.git 57 | python setup.py install 58 | ``` 59 | 60 | Reference : 61 | http://wiki.ros.org/rospy/Tutorials 62 | 63 | How to use a PCL tutorial in ROS 64 | http://wiki.ros.org/pcl/Overview 65 | http://wiki.ros.org/perception_pcl/Tutorials 66 | 67 | Japanese : 68 | http://ros-recognition-tutorial.readthedocs.io/ja/latest/pcl/ 69 | 70 | 71 | 2. execute example 72 | 73 | * before Kinect2 device connected 74 | 75 | python ros_utils.py 76 | 77 | -------------------------------------------------------------------------------- /examples/external/ros/memo.txt: -------------------------------------------------------------------------------- 1 | https://stackoverflow.com/questions/39772424/how-to-effeciently-convert-ros-pointcloud2-to-pcl-point-cloud-and-visualize-it-i 2 | 3 | 1. ros install 4 | 5 | ```cmd 6 | git clone https://github.com/karaage0703/ubuntu-setup 7 | cp ~/ubuntu-setup/.bashrc ~/.bashrc 8 | cd ubuntu-setup 9 | ./install-ros-kinetic.sh 10 | ./install-tools.sh 11 | ``` 12 | 13 | reference : 14 | http://karaage.hatenadiary.jp/entry/2016/06/29/073000 (Japanese) 15 | 16 | 2. ros - pcl execute. 17 | 18 | [terminal1] 19 | 20 | ```cmd 21 | git clone https://github.com/karaage0703/pcl_ros_processing 22 | cd pcl_ros_processing 23 | catkin bt 24 | roscore 25 | ``` 26 | 27 | [terminal2] 28 | 29 | cd pcl_ros_processing 30 | 31 | sensor use: 32 | ```cmd 33 | ``` 34 | not sensor case: 35 | ```cmd 36 | rosbag play -l rosbag_data/pcl_test.bag 37 | ``` 38 | 39 | [terminal3] 40 | 41 | ```cmd 42 | cd pcl_ros_processing 43 | rosrun pcl_ros_processing planar_segmentation input:=/camera/depth_registered/ 44 | ``` 45 | 46 | --- 47 | 48 | reference : 49 | http://wiki.ros.org/perception_pcl/Tutorials 50 | 51 | not sensor 52 | http://karaage.hatenadiary.jp/entry/2017/09/11/073000 (Japanese) 53 | 54 | -------------------------------------------------------------------------------- /examples/external/ros/ros_utils.py: -------------------------------------------------------------------------------- 1 | import roslib 2 | import rospy 3 | from sensor_msgs.msg import PointCloud2 4 | import sensor_msgs.point_cloud2 as pc2 5 | 6 | import numpy 7 | import pcl 8 | 9 | 10 | def on_new_point_cloud(data): 11 | pc = pc2.read_points(data, skip_nans=True, field_names=("x", "y", "z")) 12 | pc_list = [] 13 | for p in pc: 14 | pc_list.append([p[0], p[1], p[2]]) 15 | 16 | p = pcl.PointCloud() 17 | p.from_list(pc_list) 18 | seg = p.make_segmenter() 19 | seg.set_model_type(pcl.SACMODEL_PLANE) 20 | seg.set_method_type(pcl.SAC_RANSAC) 21 | indices, model = seg.segment() 22 | 23 | 24 | # reference : http://robonchu.hatenablog.com/entry/2017/09/20/234640 25 | def main(): 26 | rospy.init_node('listener', anonymous=True) 27 | # rospy.Subscriber("/kinect2/sd/points", PointCloud2, on_new_point_cloud) 28 | rospy.Subscriber("/kinect2/hd/points", PointCloud2, on_new_point_cloud) 29 | rospy.spin() 30 | 31 | 32 | if __name__ == "__main__": 33 | # import cProfile 34 | # cProfile.run('main()', sort='time') 35 | main() 36 | -------------------------------------------------------------------------------- /examples/external/ros/ros_utils.py.txt: -------------------------------------------------------------------------------- 1 | import rospy 2 | import pcl 3 | from sensor_msgs.msg import PointCloud2 4 | import sensor_msgs.point_cloud2 as pc2 5 | def on_new_point_cloud(data): 6 | pc = pc2.read_points(data, skip_nans=True, field_names=("x", "y", "z")) 7 | pc_list = [] 8 | for p in pc: 9 | pc_list.append( [p[0],p[1],p[2]] ) 10 | 11 | p = pcl.PointCloud() 12 | p.from_list(pc_list) 13 | seg = p.make_segmenter() 14 | seg.set_model_type(pcl.SACMODEL_PLANE) 15 | seg.set_method_type(pcl.SAC_RANSAC) 16 | indices, model = seg.segment() 17 | 18 | rospy.init_node('listener', anonymous=True) 19 | rospy.Subscriber("/kinect2/hd/points", PointCloud2, on_new_point_cloud) 20 | rospy.spin() -------------------------------------------------------------------------------- /examples/kdtree.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | from __future__ import print_function 3 | 4 | import numpy as np 5 | import pcl 6 | 7 | 8 | def main(): 9 | points_1 = np.array([[0, 0, 0], 10 | [1, 0, 0], 11 | [0, 1, 0], 12 | [1, 1, 0]], dtype=np.float32) 13 | points_2 = np.array([[0, 0, 0.2], 14 | [1, 0, 0], 15 | [0, 1, 0], 16 | [1.1, 1, 0.5]], dtype=np.float32) 17 | 18 | pc_1 = pcl.PointCloud() 19 | pc_1.from_array(points_1) 20 | pc_2 = pcl.PointCloud() 21 | pc_2.from_array(points_2) 22 | kd = pcl.KdTreeFLANN(pc_1) 23 | 24 | print('pc_1:') 25 | print(points_1) 26 | print('\npc_2:') 27 | print(points_2) 28 | print('\n') 29 | 30 | pc_1 = pcl.PointCloud(points_1) 31 | pc_2 = pcl.PointCloud(points_2) 32 | kd = pc_1.make_kdtree_flann() 33 | 34 | # find the single closest points to each point in point cloud 2 35 | # (and the sqr distances) 36 | indices, sqr_distances = kd.nearest_k_search_for_cloud(pc_2, 1) 37 | for i in range(pc_1.size): 38 | print('index of the closest point in pc_1 to point %d in pc_2 is %d' 39 | % (i, indices[i, 0])) 40 | print('the squared distance between these two points is %f' 41 | % sqr_distances[i, 0]) 42 | 43 | 44 | if __name__ == "__main__": 45 | # import cProfile 46 | # cProfile.run('main()', sort='time') 47 | main() 48 | -------------------------------------------------------------------------------- /examples/official/Features/NormalEstimationUsingIntegralImages.py: -------------------------------------------------------------------------------- 1 | # Normal Estimation Using Integral Images 2 | # http://pointclouds.org/documentation/tutorials/normal_estimation_using_integral_images.php#normal-estimation-using-integral-images 3 | 4 | import pcl 5 | import pcl.pcl_visualization 6 | 7 | 8 | def main(): 9 | # cloud = pcl.load('table_scene_mug_stereo_textured.pcd') 10 | cloud = pcl.load( 11 | './examples/pcldata/tutorials/table_scene_mug_stereo_textured.pcd') 12 | 13 | print('load table_scene_mug_stereo_textured.pcd') 14 | 15 | # estimate normals 16 | # pcl::PointCloud::Ptr normals (new pcl::PointCloud); 17 | # pcl::IntegralImageNormalEstimation ne; 18 | print('make_IntegralImageNormalEstimation: ') 19 | ne = cloud.make_IntegralImageNormalEstimation() 20 | 21 | print('set_NormalEstimation_Method_AVERAGE_3D_GRADIENT: ') 22 | ne.set_NormalEstimation_Method_AVERAGE_3D_GRADIENT() 23 | print('set_MaxDepthChange_Factor: ') 24 | ne.set_MaxDepthChange_Factor(0.02) 25 | print('set_NormalSmoothingSize: ') 26 | ne.set_NormalSmoothingSize(10.0) 27 | print('set OK') 28 | print('compute - start') 29 | normals = ne.compute() 30 | print('compute - end') 31 | print(str(normals.size)) 32 | print(normals.to_array()) 33 | 34 | # visualize normals 35 | viewer = pcl.pcl_visualization.PCLVisualizering() 36 | viewer.SetBackgroundColor(0.0, 0.0, 0.5) 37 | # viewer.addPointCloudNormals(cloud, normals, b'normals'); 38 | viewer.AddPointCloud(cloud) 39 | viewer.AddPointCloudNormals(cloud, normals, 10, 0.05, b'normals') 40 | 41 | flag = True 42 | while (flag): 43 | flag = not(viewer.WasStopped()) 44 | viewer.SpinOnce() 45 | 46 | 47 | if __name__ == "__main__": 48 | # import cProfile 49 | # cProfile.run('main()', sort='time') 50 | main() 51 | -------------------------------------------------------------------------------- /examples/official/Features/rops_feature.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/strawlab/python-pcl/809199a3a62e8d98f8b8286db3051b6aee0b295b/examples/official/Features/rops_feature.py -------------------------------------------------------------------------------- /examples/official/Filtering/VoxelGrid_160.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | # http://pointclouds.org/documentation/tutorials/voxel_grid.php#voxelgrid 3 | # http://derivecv.tumblr.com/post/13631147204 4 | # http://nisot0710.blogspot.jp/2014/09/pclvoxelgridpclpointcloud2.html 5 | # PCLPointCloud2 is 1.7.2 6 | 7 | import pcl 8 | 9 | 10 | def main(): 11 | # pcl::PointCloud::Ptr cloud (new pcl::PointCloud ()); 12 | # pcl::PointCloud::Ptr cloud_filtered (new pcl::PointCloud ()); 13 | # 14 | # pcl::PCDReader reader; 15 | # reader.read("pcdfilename", *cloud); 16 | cloud = pcl.load('./examples/pcldata/tutorials/table_scene_lms400.pcd') 17 | 18 | # std::cerr<<"PointCloud befor filtering: " << cloud->width * cloud->height << "data points ( " << pcl::getFieldsList (*cloud) << ")."; 19 | # print('PointCloud befor filtering: ' + str(cloud.width * cloud.height) + 'data points ( ' + pcl.getFieldsList (cloud) + ').') 20 | 21 | # pcl::VoxelGrid sor; 22 | # sor.setInputCloud(cloud); 23 | # sor.setLeafSize(0.1f, 0.1f, 0.1f); 24 | # sor.filter(*cloud_filtered); 25 | sor = cloud.make_voxel_grid_filter() 26 | sor.set_leaf_size(0.01, 0.01, 0.01) 27 | cloud_filtered = sor.filter() 28 | 29 | # std::cerr<<"PointCloud after filtering: " << cloud_filtered->width * cloud_filtered->height << "data points (" << pcl::getFieldsList(*cloud_filtered) <<")."; 30 | # print('PointCloud after filtering: ' + str(cloud_filtered.width * cloud_filtered.height) + 'data points ( ' + pcl.getFieldsList (cloud) + ').') 31 | 32 | # pcl::PCDWriter writer; 33 | # writer.write("savefilename", *cloud_filtered, false); 34 | pcl.save(cloud_filtered, 'table_scene_lms400_voxelfilter.pcd') 35 | 36 | 37 | if __name__ == "__main__": 38 | # import cProfile 39 | # cProfile.run('main()', sort='time') 40 | main() 41 | -------------------------------------------------------------------------------- /examples/official/Filtering/VoxelGrid_172.txt: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | # http://pointclouds.org/documentation/tutorials/voxel_grid.php#voxelgrid 3 | # http://derivecv.tumblr.com/post/13631147204 4 | # http://nisot0710.blogspot.jp/2014/09/pclvoxelgridpclpointcloud2.html 5 | # PCLPointCloud2 is 1.7.2 6 | 7 | import pcl 8 | 9 | def main(): 10 | pcl::PCLPointCloud2::Ptr cloud (new pcl::PCLPointCloud2 ()); 11 | pcl::PCLPointCloud2::Ptr cloud_filtered (new pcl::PCLPointCloud2 ()); 12 | 13 | // Fill in the cloud data 14 | pcl::PCDReader reader; 15 | // Replace the path below with the path where you saved your file 16 | reader.read ("./examples/pcldata/tutorials/table_scene_lms400.pcd", *cloud); // Remember to download the file first! 17 | 18 | std::cerr << "PointCloud before filtering: " << cloud->width * cloud->height 19 | << " data points (" << pcl::getFieldsList (*cloud) << ")."; 20 | 21 | // Create the filtering object 22 | pcl::VoxelGrid sor; 23 | sor.setInputCloud (cloud); 24 | sor.setLeafSize (0.01f, 0.01f, 0.01f); 25 | sor.filter (*cloud_filtered); 26 | 27 | std::cerr << "PointCloud after filtering: " << cloud_filtered->width * cloud_filtered->height 28 | << " data points (" << pcl::getFieldsList (*cloud_filtered) << ")."; 29 | 30 | pcl::PCDWriter writer; 31 | writer.write ("table_scene_lms400_downsampled.pcd", *cloud_filtered, 32 | Eigen::Vector4f::Zero (), Eigen::Quaternionf::Identity (), false); 33 | 34 | 35 | if __name__ == "__main__": 36 | # import cProfile 37 | # cProfile.run('main()', sort='time') 38 | main() -------------------------------------------------------------------------------- /examples/official/Filtering/statistical_removal.py: -------------------------------------------------------------------------------- 1 | # Removing outliers using a StatisticalOutlierRemoval filter 2 | # http://pointclouds.org/documentation/tutorials/statistical_outlier.php#statistical-outlier-removal 3 | 4 | import pcl 5 | 6 | 7 | def main(): 8 | p = pcl.load('./examples/pcldata/tutorials/table_scene_lms400.pcd') 9 | 10 | fil = p.make_statistical_outlier_filter() 11 | fil.set_mean_k(50) 12 | fil.set_std_dev_mul_thresh(1.0) 13 | 14 | pcl.save(fil.filter(), "table_scene_lms400_inliers.pcd") 15 | 16 | fil.set_negative(True) 17 | pcl.save(fil.filter(), "table_scene_lms400_outliers.pcd") 18 | 19 | 20 | if __name__ == "__main__": 21 | # import cProfile 22 | # cProfile.run('main()', sort='time') 23 | main() 24 | -------------------------------------------------------------------------------- /examples/official/GPU/people_detect_172.txt: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | # Detecting people and their poses using PointCloud Library 3 | # http://pointclouds.org/documentation/tutorials/gpu_people.php#gpu-people 4 | 5 | # int main(int argc, char** argv) 6 | # selecting GPU and prining info 7 | # int device = 0; 8 | # pc::parse_argument (argc, argv, "-gpu", device); 9 | # pcl::gpu::setDevice (device); 10 | # pcl::gpu::printShortCudaDeviceInfo (device); 11 | device = 0 12 | pcl::gpu::setDevice (device) 13 | pcl::gpu::printShortCudaDeviceInfo (device) 14 | 15 | # // selecting data source 16 | # boost::shared_ptr capture; 17 | # capture.reset( new pcl::OpenNIGrabber() ); 18 | ## Python 19 | # capture = pcl.??? 20 | ## 21 | 22 | # //selecting tree files 23 | # vector tree_files; 24 | # tree_files.push_back("Data/forest1/tree_20.txt"); 25 | # tree_files.push_back("Data/forest2/tree_20.txt"); 26 | # tree_files.push_back("Data/forest3/tree_20.txt"); 27 | # tree_files.push_back("Data/forest4/tree_20.txt"); 28 | 29 | # pc::parse_argument (argc, argv, "-tree0", tree_files[0]); 30 | # pc::parse_argument (argc, argv, "-tree1", tree_files[1]); 31 | # pc::parse_argument (argc, argv, "-tree2", tree_files[2]); 32 | # pc::parse_argument (argc, argv, "-tree3", tree_files[3]); 33 | 34 | # int num_trees = (int)tree_files.size(); 35 | # pc::parse_argument (argc, argv, "-numTrees", num_trees); 36 | 37 | # tree_files.resize(num_trees); 38 | # if (num_trees == 0 || num_trees > 4) return cout << "Invalid number of trees" << endl, -1; 39 | 40 | # try 41 | # { 42 | # // loading trees 43 | # typedef pcl::gpu::people::RDFBodyPartsDetector RDFBodyPartsDetector; 44 | # RDFBodyPartsDetector::Ptr rdf(new RDFBodyPartsDetector(tree_files)); 45 | # PCL_INFO("Loaded files into rdf"); 46 | # 47 | # // Create the app 48 | # PeoplePCDApp app(*capture); 49 | # app.people_detector_.rdf_detector_ = rdf; 50 | # 51 | # // executing 52 | # app.startMainLoop (); 53 | # } 54 | # catch (const pcl::PCLException& e) { cout << "PCLException: " << e.detailedMessage() << endl; } 55 | # catch (const std::runtime_error& e) { cout << e.what() << endl; } 56 | # catch (const std::bad_alloc& /*e*/) { cout << "Bad alloc" << endl; } 57 | # catch (const std::exception& /*e*/) { cout << "Exception" << endl; } 58 | ### 59 | 60 | 61 | -------------------------------------------------------------------------------- /examples/official/IO/pcd_read.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | # 3 | # #include 4 | # #include 5 | # #include 6 | # 7 | # int main (int argc, char** argv) 8 | # { 9 | # pcl::PointCloud::Ptr cloud (new pcl::PointCloud); 10 | # 11 | # if (pcl::io::loadPCDFile ("test_pcd.pcd", *cloud) == -1) //* load the file 12 | # { 13 | # PCL_ERROR ("Couldn't read file test_pcd.pcd \n"); 14 | # return (-1); 15 | # } 16 | # std::cout << "Loaded " 17 | # << cloud->width * cloud->height 18 | # << " data points from test_pcd.pcd with the following fields: " 19 | # << std::endl; 20 | # for (size_t i = 0; i < cloud->points.size (); ++i) 21 | # std::cout << " " << cloud->points[i].x 22 | # << " " << cloud->points[i].y 23 | # << " " << cloud->points[i].z << std::endl; 24 | # 25 | # return (0); 26 | # } 27 | 28 | import pcl 29 | 30 | 31 | def main(): 32 | cloud = pcl.load('./examples/official/IO/test_pcd.pcd') 33 | 34 | print('Loaded ' + str(cloud.width * cloud.height) + 35 | ' data points from test_pcd.pcd with the following fields: ') 36 | for i in range(0, cloud.size): 37 | print('x: ' + str(cloud[i][0]) + ', y : ' + 38 | str(cloud[i][1]) + ', z : ' + str(cloud[i][2])) 39 | 40 | 41 | if __name__ == "__main__": 42 | # import cProfile 43 | # cProfile.run('main()', sort='time') 44 | main() 45 | -------------------------------------------------------------------------------- /examples/official/Recognition/correspondence_grouping.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/strawlab/python-pcl/809199a3a62e8d98f8b8286db3051b6aee0b295b/examples/official/Recognition/correspondence_grouping.py -------------------------------------------------------------------------------- /examples/official/Segmentation/MinCutSegmentation_172.txt: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | # http://pointclouds.org/documentation/tutorials/min_cut_segmentation.php 3 | 4 | #pcl::PointCloud ::Ptr cloud (new pcl::PointCloud ); 5 | # if ( pcl::io::loadPCDFile ("min_cut_segmentation_tutorial.pcd", *cloud) == -1 ) 6 | # { 7 | # std::cout << "Cloud reading failed." << std::endl; 8 | # return (-1); 9 | # } 10 | cloud = pcl.load('./examples/pcldata/tutorials/min_cut_segmentation_tutorial.pcd') 11 | 12 | # pcl::IndicesPtr indices (new std::vector ); 13 | # pcl::PassThrough pass; 14 | # pass.setInputCloud (cloud); 15 | # pass.setFilterFieldName ("z"); 16 | # pass.setFilterLimits (0.0, 1.0); 17 | # pass.filter (*indices); 18 | pass = cloud.make_passthrough_filter() 19 | pass.set_filter_field_name('z') 20 | pass.set_filter_limits(0.0, 1.0) 21 | indices = pass.filter() 22 | 23 | # pcl::MinCutSegmentation seg; 24 | # seg.setInputCloud (cloud); 25 | # seg.setIndices (indices); 26 | seg = cloud.make_MinCutSegmentation() 27 | 28 | # pcl::PointCloud::Ptr foreground_points(new pcl::PointCloud ()); 29 | foreground_points = pcl.PointCloud() 30 | 31 | # pcl::PointXYZ point; 32 | # point.x = 68.97; 33 | # point.y = -18.55; 34 | # point.z = 0.57; 35 | # foreground_points->points.push_back(point) 36 | 37 | 38 | # seg.setForegroundPoints (foreground_points); 39 | # seg.setSigma (0.25); 40 | # seg.setRadius (3.0433856); 41 | # seg.setNumberOfNeighbours (14); 42 | # seg.setSourceWeight (0.8); 43 | 44 | # std::vector clusters; 45 | # seg.extract (clusters); 46 | # std::cout << "Maximum flow is " << seg.getMaxFlow () << std::endl; 47 | 48 | pcl::PointCloud ::Ptr colored_cloud = seg.getColoredCloud (); 49 | 50 | # pcl::visualization::CloudViewer viewer ("Cluster viewer"); 51 | # viewer.showCloud(colored_cloud); 52 | # while (!viewer.wasStopped ()) 53 | # { 54 | # } 55 | 56 | return (0); -------------------------------------------------------------------------------- /examples/official/Segmentation/region_growing_rgb_segmentation_172.txt: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | # Color-based region growing segmentation 3 | # http://pointclouds.org/documentation/tutorials/region_growing_rgb_segmentation.php#region-growing-rgb-segmentation 4 | 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | 15 | int 16 | main (int argc, char** argv) 17 | { 18 | pcl::search::Search ::Ptr tree = boost::shared_ptr > (new pcl::search::KdTree); 19 | 20 | pcl::PointCloud ::Ptr cloud (new pcl::PointCloud ); 21 | if ( pcl::io::loadPCDFile ("./examples/pcldata/tutorials/region_growing_rgb_tutorial.pcd", *cloud) == -1 ) 22 | { 23 | std::cout << "Cloud reading failed." << std::endl; 24 | return (-1); 25 | } 26 | 27 | pcl::IndicesPtr indices (new std::vector ); 28 | pcl::PassThrough pass; 29 | pass.setInputCloud (cloud); 30 | pass.setFilterFieldName ("z"); 31 | pass.setFilterLimits (0.0, 1.0); 32 | pass.filter (*indices); 33 | 34 | pcl::RegionGrowingRGB reg; 35 | reg.setInputCloud (cloud); 36 | reg.setIndices (indices); 37 | reg.setSearchMethod (tree); 38 | reg.setDistanceThreshold (10); 39 | reg.setPointColorThreshold (6); 40 | reg.setRegionColorThreshold (5); 41 | reg.setMinClusterSize (600); 42 | 43 | std::vector clusters; 44 | reg.extract (clusters); 45 | 46 | pcl::PointCloud ::Ptr colored_cloud = reg.getColoredCloud (); 47 | pcl::visualization::CloudViewer viewer ("Cluster viewer"); 48 | viewer.showCloud (colored_cloud); 49 | while (!viewer.wasStopped ()) 50 | { 51 | boost::this_thread::sleep (boost::posix_time::microseconds (100)); 52 | } 53 | 54 | return (0); 55 | } 56 | -------------------------------------------------------------------------------- /examples/official/Surface/bun0.pcd: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/strawlab/python-pcl/809199a3a62e8d98f8b8286db3051b6aee0b295b/examples/official/Surface/bun0.pcd -------------------------------------------------------------------------------- /examples/official/Surface/resampling.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | # Smoothing and normal estimation based on polynomial reconstruction 3 | # http://pointclouds.org/documentation/tutorials/resampling.php#moving-least-squares 4 | 5 | import numpy as np 6 | import pcl 7 | import random 8 | 9 | 10 | def main(): 11 | # // Load input file into a PointCloud with an appropriate type 12 | # pcl::PointCloud::Ptr cloud (new pcl::PointCloud ()); 13 | # // Load bun0.pcd -- should be available with the PCL archive in test 14 | # pcl::io::loadPCDFile ("bun0.pcd", *cloud); 15 | cloud = pcl.load('./examples/official/Surface/bun0.pcd') 16 | print('cloud(size) = ' + str(cloud.size)) 17 | 18 | # // Create a KD-Tree 19 | # pcl::search::KdTree::Ptr tree (new pcl::search::KdTree); 20 | tree = cloud.make_kdtree() 21 | # tree = cloud.make_kdtree_flann() 22 | # blankCloud = pcl.PointCloud() 23 | # tree = blankCloud.make_kdtree() 24 | 25 | # // Output has the PointNormal type in order to store the normals calculated by MLS 26 | # pcl::PointCloud mls_points; 27 | # mls_points = pcl.PointCloudNormal() 28 | # // Init object (second point type is for the normals, even if unused) 29 | # pcl::MovingLeastSquares mls; 30 | # mls.setComputeNormals (true); 31 | # 32 | # // Set parameters 33 | # mls.setInputCloud (cloud); 34 | # mls.setPolynomialFit (true); 35 | # mls.setSearchMethod (tree); 36 | # mls.setSearchRadius (0.03); 37 | # 38 | # // Reconstruct 39 | # mls.process (mls_points); 40 | mls = cloud.make_moving_least_squares() 41 | # print('make_moving_least_squares') 42 | mls.set_Compute_Normals(True) 43 | mls.set_polynomial_fit(True) 44 | mls.set_Search_Method(tree) 45 | mls.set_search_radius(0.03) 46 | print('set parameters') 47 | mls_points = mls.process() 48 | 49 | # Save output 50 | # pcl::io::savePCDFile ("bun0-mls.pcd", mls_points); 51 | pcl.save_PointNormal(mls_points, 'bun0-mls.pcd') 52 | 53 | 54 | if __name__ == "__main__": 55 | # import cProfile 56 | # cProfile.run('main()', sort='time') 57 | main() 58 | -------------------------------------------------------------------------------- /examples/official/Visualization/PCLPlotter.txt: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | # PCLPlotter 3 | # http://pointclouds.org/documentation/tutorials/pcl_plotter.php#pcl-plotter 4 | 5 | import pcl 6 | 7 | # //defining a plotter 8 | # pcl::visualization::PCLPlotter * plotter = new PCLPlotter (); 9 | # 10 | # //defining the polynomial function, y = x^2. Index of x^2 is 1, rest is 0 11 | # vector func1 (3,0); 12 | # func1[2] = 1; 13 | # 14 | # //adding the polynomial func1 to the plotter with [-10, 10] as the range in X axis and "y = x^2" as title 15 | # plotter->addPlotData (func1, -10, 10, "y = x^2"); 16 | # 17 | # //display the plot, DONE! 18 | # plotter->plot (); 19 | 20 | -------------------------------------------------------------------------------- /examples/official/Visualization/cloud_viewer.txt: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | # The CloudViewer 3 | # http://pointclouds.org/documentation/tutorials/cloud_viewer.php#cloud-viewer 4 | 5 | #include 6 | #include 7 | #include 8 | #include 9 | 10 | import pcl 11 | 12 | # int user_data; 13 | user_data = 0 14 | 15 | cdef viewerOneOff (pcl.visualization.PCLVisualizer viewer) 16 | viewer.set_BackgroundColor (1.0, 0.5, 1.0) 17 | o = pcl.PointCloud() 18 | o.x = 1.0; 19 | o.y = 0; 20 | o.z = 0; 21 | viewer.addSphere (o, 0.25, "sphere", 0); 22 | print('i only run once') 23 | 24 | 25 | cdef viewerPsycho (pcl::visualization::PCLVisualizer& viewer) 26 | # static unsigned count = 0; 27 | count = 0 28 | print('Once per viewer loop: ' + str(count++)) 29 | viewer.removeShape ('text', 0) 30 | viewer.addText (ss.str(), 200, 300, 'text', 0) 31 | user_data++; 32 | 33 | 34 | # pcl::PointCloud::Ptr cloud (new pcl::PointCloud); 35 | # pcl::io::loadPCDFile ("my_point_cloud.pcd", *cloud); 36 | cloud = pcl.load('./examples/pcldata/tutorials/my_point_cloud.pcd') 37 | 38 | # pcl::visualization::CloudViewer viewer("Cloud Viewer"); 39 | # //blocks until the cloud is actually rendered 40 | # viewer.showCloud(cloud); 41 | viewer = pcl.visualization.CloudViewing('Cloud Viewer') 42 | 43 | # //use the following functions to get access to the underlying more advanced/powerful 44 | # //PCLVisualizer 45 | # //This will only get called once 46 | # viewer.runOnVisualizationThreadOnce (viewerOneOff); 47 | # //This will get called once per visualization iteration 48 | # viewer.runOnVisualizationThread (viewerPsycho); 49 | viewer.runOnVisualizationThreadOnce(viewerOneOff) 50 | viewer.runOnVisualizationThreadOnce(viewerPsycho) 51 | 52 | # while (!viewer.wasStopped ()) 53 | # { 54 | # //you can also do cool processing here 55 | # //FIXME: Note that this is running in a separate thread from viewerPsycho 56 | # //and you should guard against race conditions yourself... 57 | # user_data++; 58 | # } 59 | 60 | flag = True 61 | flag != viewer.wasStopped() 62 | while flag: 63 | user_data = user_data + 1 64 | end 65 | 66 | 67 | -------------------------------------------------------------------------------- /examples/official/grabber/openni_grabber.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | # The OpenNI Grabber Framework in PCL 3 | # http://pointclouds.org/documentation/tutorials/openni_grabber.php 4 | 5 | import pcl 6 | import pcl.pcl_grabber 7 | import pcl.pcl_visualization 8 | 9 | 10 | def class SimpleOpenNIViewer: 11 | SimpleOpenNIViewer() 12 | viewer = pcl.pcl_visualization.CloudViewer(b'PCL OpenNI Viewer') 13 | 14 | def void cloud_cb_(pcl.PointCloud_Ptr_t cloud): 15 | if !viewer.wasStopped() == True: 16 | viewer.showCloud(cloud) 17 | 18 | def void run(): 19 | interface = new pcl.OpenNIGrabber() 20 | 21 | interface.RegisterCallback(cloud_cb_) 22 | interface.Start() 23 | 24 | while !viewer.wasStopped() == True: 25 | # boost::this_thread::sleep (boost::posix_time::seconds (1)); 26 | time.sleep(1) 27 | 28 | interface.Stop() 29 | 30 | 31 | if __name__ == '__main__': 32 | v = SimpleOpenNIViewer() 33 | v.run() 34 | -------------------------------------------------------------------------------- /examples/pcldata/tutorials/correspondence_grouping/milk.pcd: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/strawlab/python-pcl/809199a3a62e8d98f8b8286db3051b6aee0b295b/examples/pcldata/tutorials/correspondence_grouping/milk.pcd -------------------------------------------------------------------------------- /examples/pcldata/tutorials/correspondence_grouping/milk_cartoon_all_small_clorox.pcd: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/strawlab/python-pcl/809199a3a62e8d98f8b8286db3051b6aee0b295b/examples/pcldata/tutorials/correspondence_grouping/milk_cartoon_all_small_clorox.pcd -------------------------------------------------------------------------------- /examples/pcldata/tutorials/table_scene_lms400.pcd: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/strawlab/python-pcl/809199a3a62e8d98f8b8286db3051b6aee0b295b/examples/pcldata/tutorials/table_scene_lms400.pcd -------------------------------------------------------------------------------- /examples/pcldata/tutorials/table_scene_mug_stereo_textured.pcd: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/strawlab/python-pcl/809199a3a62e8d98f8b8286db3051b6aee0b295b/examples/pcldata/tutorials/table_scene_mug_stereo_textured.pcd -------------------------------------------------------------------------------- /examples/segment_cyl_plane.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | # port of 3 | # http://pointclouds.org/documentation/tutorials/cylinder_segmentation.php 4 | # you need to download 5 | # http://svn.pointclouds.org/data/tutorials/table_scene_mug_stereo_textured.pcd 6 | 7 | import pcl 8 | 9 | 10 | def main(): 11 | cloud = pcl.load( 12 | './examples/pcldata/tutorials/table_scene_mug_stereo_textured.pcd') 13 | 14 | print(cloud.size) 15 | 16 | fil = cloud.make_passthrough_filter() 17 | fil.set_filter_field_name("z") 18 | fil.set_filter_limits(0, 1.5) 19 | cloud_filtered = fil.filter() 20 | 21 | print(cloud_filtered.size) 22 | 23 | seg = cloud_filtered.make_segmenter_normals(ksearch=50) 24 | seg.set_optimize_coefficients(True) 25 | seg.set_model_type(pcl.SACMODEL_NORMAL_PLANE) 26 | seg.set_normal_distance_weight(0.1) 27 | seg.set_method_type(pcl.SAC_RANSAC) 28 | seg.set_max_iterations(100) 29 | seg.set_distance_threshold(0.03) 30 | indices, model = seg.segment() 31 | 32 | print(model) 33 | 34 | cloud_plane = cloud_filtered.extract(indices, negative=False) 35 | # NG : const char* not str 36 | # cloud_plane.to_file('table_scene_mug_stereo_textured_plane.pcd') 37 | pcl.save(cloud_plane, 'table_scene_mug_stereo_textured_plane.pcd') 38 | 39 | cloud_cyl = cloud_filtered.extract(indices, negative=True) 40 | 41 | seg = cloud_cyl.make_segmenter_normals(ksearch=50) 42 | seg.set_optimize_coefficients(True) 43 | seg.set_model_type(pcl.SACMODEL_CYLINDER) 44 | seg.set_normal_distance_weight(0.1) 45 | seg.set_method_type(pcl.SAC_RANSAC) 46 | seg.set_max_iterations(10000) 47 | seg.set_distance_threshold(0.05) 48 | seg.set_radius_limits(0, 0.1) 49 | indices, model = seg.segment() 50 | 51 | print(model) 52 | 53 | cloud_cylinder = cloud_cyl.extract(indices, negative=False) 54 | # NG : const char* not str 55 | # cloud_cylinder.to_file("table_scene_mug_stereo_textured_cylinder.pcd") 56 | pcl.save(cloud_cylinder, 'table_scene_mug_stereo_textured_cylinder.pcd') 57 | 58 | 59 | if __name__ == "__main__": 60 | # import cProfile 61 | # cProfile.run('main()', sort='time') 62 | main() 63 | -------------------------------------------------------------------------------- /examples/sift.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/strawlab/python-pcl/809199a3a62e8d98f8b8286db3051b6aee0b295b/examples/sift.py -------------------------------------------------------------------------------- /examples/statistical_outlier_fiter.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | # port of 3 | # http://pointclouds.org/documentation/tutorials/statistical_outlier.php 4 | # you need to download 5 | # http://svn.pointclouds.org/data/tutorials/table_scene_lms400.pcd 6 | 7 | import pcl 8 | 9 | 10 | def main(): 11 | p = pcl.load("./examples/pcldata/tutorials/table_scene_lms400.pcd") 12 | 13 | fil = p.make_statistical_outlier_filter() 14 | fil.set_mean_k(50) 15 | fil.set_std_dev_mul_thresh(1.0) 16 | 17 | pcl.save(fil.filter(), 18 | "./examples/pcldata/tutorials/table_scene_lms400_inliers.pcd") 19 | 20 | fil.set_negative(True) 21 | pcl.save(fil.filter(), 22 | "./examples/pcldata/tutorials/table_scene_lms400_outliers.pcd") 23 | 24 | 25 | if __name__ == "__main__": 26 | # import cProfile 27 | # cProfile.run('main()', sort='time') 28 | main() 29 | -------------------------------------------------------------------------------- /examples/visualization.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | from __future__ import print_function 3 | 4 | import numpy as np 5 | import pcl 6 | 7 | import pcl.pcl_visualization 8 | # from pcl.pcl_registration import icp, gicp, icp_nl 9 | 10 | 11 | def main(): 12 | # cloud = pcl.load_XYZRGB( 13 | # './examples/pcldata/tutorials/table_scene_mug_stereo_textured.pcd') 14 | cloud = pcl.load("Tile_173078_LD_010_017_L22.obj") 15 | # Centred the data 16 | centred = cloud - np.mean(cloud, 0) 17 | # print(centred) 18 | ptcloud_centred = pcl.PointCloud() 19 | ptcloud_centred.from_array(centred) 20 | # ptcloud_centred = pcl.load("Tile_173078_LD_010_017_L22.obj") 21 | 22 | visual = pcl.pcl_visualization.CloudViewing() 23 | 24 | # PointXYZ 25 | visual.ShowMonochromeCloud(ptcloud_centred, b'cloud') 26 | # visual.ShowGrayCloud(ptcloud_centred, b'cloud') 27 | # visual.ShowColorCloud(ptcloud_centred, b'cloud') 28 | # visual.ShowColorACloud(ptcloud_centred, b'cloud') 29 | 30 | v = True 31 | while v: 32 | v = not(visual.WasStopped()) 33 | 34 | 35 | if __name__ == "__main__": 36 | # import cProfile 37 | # cProfile.run('main()', sort='time') 38 | main() 39 | -------------------------------------------------------------------------------- /pcl/ProjectInliers.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | #include "ProjectInliers.h" 4 | 5 | // set ksearch and radius to < 0 to disable 6 | void mpcl_ProjectInliers_setModelCoefficients(pcl::ProjectInliers &inliers) 7 | { 8 | pcl::ModelCoefficients::Ptr coefficients (new pcl::ModelCoefficients ()); 9 | coefficients->values.resize (4); 10 | coefficients->values[0] = coefficients->values[1] = 0; 11 | coefficients->values[2] = 1.0; 12 | coefficients->values[3] = 0; 13 | 14 | inliers.setModelCoefficients (coefficients); 15 | } -------------------------------------------------------------------------------- /pcl/ProjectInliers.h: -------------------------------------------------------------------------------- 1 | #ifndef _ProjectInliers_H_ 2 | #define _ProjectInliers_H_ 3 | 4 | #include 5 | #include 6 | #include 7 | 8 | // 9 | void mpcl_ProjectInliers_setModelCoefficients(pcl::ProjectInliers &inliers); 10 | 11 | #endif 12 | -------------------------------------------------------------------------------- /pcl/_bind_defs.pxd: -------------------------------------------------------------------------------- 1 | #-*- coding: utf-8 -*- 2 | # cimport pcl_defs as cpp 3 | 4 | cdef extern from "boost/function.hpp" namespace "boost": 5 | cdef cppclass function[T]: 6 | pass 7 | 8 | cdef extern from "boost/bind.hpp" namespace "boost": 9 | cdef struct arg: 10 | pass 11 | cdef function[T] bind[T](T callback, arg _1) 12 | 13 | cdef extern from "boost/signals2.hpp" namespace "boost::signals2": 14 | cdef cppclass connection: 15 | pass 16 | 17 | # 18 | ctypedef void callback_t(void*) 19 | # ctypedef void callback2_t(cpp.PointCloud_Ptr_t) 20 | 21 | cdef extern from "bind.h": 22 | cdef connection register_callback(function[callback_t] callback) 23 | -------------------------------------------------------------------------------- /pcl/bind.h: -------------------------------------------------------------------------------- 1 | #ifndef __BIND_CPP__ 2 | #define __BIND_CPP__ 3 | 4 | #include 5 | #include 6 | #include 7 | #include 8 | 9 | // void some_callback(void* some_ptr); 10 | boost::signals2::connection register_callback(boost::function callback); 11 | 12 | #endif 13 | -------------------------------------------------------------------------------- /pcl/boost_function.pxd: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | cimport pcl_defs as cpp 3 | from libcpp cimport bool 4 | 5 | ############################################################################### 6 | # Types 7 | ############################################################################### 8 | 9 | # cdef extern from "boost/function/function.hpp" namespace "boost" nogil: 10 | cdef extern from "boost/function.hpp" namespace "boost" nogil: 11 | cdef cppclass function[T]: 12 | function() 13 | function(T*) 14 | 15 | T* get() 16 | bool unique() 17 | long use_count() 18 | void swap(shared_ptr[T]) 19 | void reset(T*) 20 | 21 | ############################################################################### 22 | # Enum 23 | ############################################################################### 24 | 25 | ############################################################################### 26 | # Activation 27 | ############################################################################### 28 | -------------------------------------------------------------------------------- /pcl/boost_shared_ptr.pxd: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | cimport pcl_defs as cpp 3 | from libcpp cimport bool 4 | 5 | ############################################################################### 6 | # Types 7 | ############################################################################### 8 | 9 | # cdef extern from "boost/smart_ptr/shared_ptr.hpp" namespace "boost" nogil: 10 | cdef extern from "boost/shared_ptr.hpp" namespace "boost" nogil: 11 | cdef cppclass shared_ptr[T]: 12 | shared_ptr() 13 | shared_ptr(T*) 14 | # shared_ptr(T*, T*) 15 | # shared_ptr(T*, T*, T*) 16 | # shared_ptr(weak_ptr[T]) 17 | # shared_ptr(weak_ptr[T], boost::detail::sp_nothrow_tag) 18 | 19 | T* get() 20 | bool unique() 21 | long use_count() 22 | void swap(shared_ptr[T]) 23 | void reset(T*) 24 | 25 | cdef extern from "boost_shared_ptr_assign.h" nogil: 26 | # void sp_assign(shared_ptr[cpp.PointCloud[cpp.PointXYZ]] &t, cpp.PointCloud[cpp.PointXYZ] *value) 27 | void sp_assign[T](shared_ptr[T] &p, T *value) 28 | 29 | ############################################################################### 30 | # Enum 31 | ############################################################################### 32 | 33 | ############################################################################### 34 | # Activation 35 | ############################################################################### 36 | -------------------------------------------------------------------------------- /pcl/boost_shared_ptr_assign.h: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | namespace { 5 | // Workaround for lack of operator= support in Cython. 6 | template 7 | void sp_assign(boost::shared_ptr &p, T *v) 8 | { 9 | p = boost::shared_ptr(v); 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /pcl/grabber_callback.cpp: -------------------------------------------------------------------------------- 1 | #include "grabber_callback.h" 2 | 3 | namespace grabber_callback { 4 | 5 | PyLibCallBack::PyLibCallBack() 6 | { 7 | is_cy_call = true; 8 | }; 9 | 10 | PyLibCallBack::PyLibCallBack(Method method, void *user_data) 11 | { 12 | is_cy_call = true; 13 | _method = method; 14 | _user_data = user_data; 15 | }; 16 | 17 | PyLibCallBack::~PyLibCallBack() 18 | { 19 | }; 20 | 21 | double PyLibCallBack::cy_execute (void *parameter) 22 | { 23 | return this->_method(parameter, _user_data); 24 | }; 25 | 26 | } // namespace grabber_callback -------------------------------------------------------------------------------- /pcl/grabber_callback.h: -------------------------------------------------------------------------------- 1 | #ifndef GRABBER_CALLBACK_H_ 2 | #define GRABBER_CALLBACK_H_ 3 | 4 | namespace grabber_callback 5 | { 6 | class PyLibCallBack 7 | { 8 | public: 9 | // This is wrapper of Python fuction. 10 | typedef double (*Method)(void *param, void *user_data); 11 | 12 | // Constructor 13 | PyLibCallBack(); 14 | PyLibCallBack(Method method, void *user_data); 15 | // Destructor 16 | virtual ~PyLibCallBack(); 17 | 18 | double cy_execute(void *parameter); 19 | 20 | bool IsCythonCall() 21 | { 22 | return is_cy_call; 23 | } 24 | 25 | protected: 26 | bool is_cy_call; 27 | 28 | private: 29 | Method _method; 30 | void *_user_data; 31 | }; 32 | } 33 | #endif -------------------------------------------------------------------------------- /pcl/grabber_callback.pxd: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | # cimport pcl_defs as cpp 3 | from libcpp cimport bool 4 | 5 | ctypedef double (*Method)(void *param, void *user_data) 6 | 7 | cdef extern from "grabber_callback.h" namespace "grabber_callback": 8 | cdef cppclass PyLibCallBack: 9 | PyLibCallBack(Method method, void *user_data) 10 | double cy_execute(void *parameter) 11 | 12 | # The pattern/converter method to be used for translating C typed prototype to a Python object call 13 | cdef inline double callback(void *parameter, void *method): 14 | return (method)(parameter) 15 | -------------------------------------------------------------------------------- /pcl/indexing.hpp: -------------------------------------------------------------------------------- 1 | namespace { 2 | // Workaround for a Cython bug in operator[] with templated types and 3 | // references. Let's hope the compiler optimizes these functions away. 4 | template 5 | T *getptr(pcl::PointCloud *pc, size_t i) 6 | { 7 | return &(*pc)[i]; 8 | } 9 | 10 | template 11 | T *getptr_at(pcl::PointCloud *pc, size_t i) 12 | { 13 | return &(pc->at(i)); 14 | } 15 | 16 | template 17 | T *getptr_at2(pcl::PointCloud *pc, int i, int j) 18 | { 19 | return &(pc->at(i, j)); 20 | } 21 | } 22 | -------------------------------------------------------------------------------- /pcl/indexing.pxd: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | from libc.stddef cimport size_t 3 | cimport pcl_defs as cpp 4 | # cimport pcl_PointCloud2_160 as cpp2 5 | 6 | ############################################################################### 7 | # Types 8 | ############################################################################### 9 | 10 | cdef extern from "indexing.hpp" nogil: 11 | # cdef extern from "indexing.hpp": 12 | # Use these instead of operator[] or at. 13 | PointCloudType *getptr [PointCloudType](cpp.PointCloud[PointCloudType] *, size_t) 14 | PointCloudType *getptr_at [PointCloudType](cpp.PointCloud[PointCloudType] *, size_t) except + 15 | PointCloudType *getptr_at2 [PointCloudType](cpp.PointCloud[PointCloudType] *, int, int) except + 16 | 17 | 18 | #cdef extern from "indexing_assign.h" nogil: 19 | # #void sp_assign(shared_ptr[cpp.PointCloud[cpp.PointXYZ]] &t, cpp.PointCloud[cpp.PointXYZ] *value) 20 | # #void sp_assign[T](shared_ptr[T] &p, T *value) 21 | 22 | 23 | ############################################################################### 24 | # Enum 25 | ############################################################################### 26 | 27 | ############################################################################### 28 | # Activation 29 | ############################################################################### 30 | 31 | -------------------------------------------------------------------------------- /pcl/pcl_grabber.pxd: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | # Header for pcl_grabber.pyx functionality that needs sharing with other modules. 3 | 4 | cimport pcl_grabber as cpp 5 | 6 | # # class override(PointCloud) 7 | # cdef class PointCloud: 8 | # cdef cpp.PointCloudPtr_t thisptr_shared # XYZ 9 | # 10 | # # Buffer protocol support. 11 | # cdef Py_ssize_t _shape[2] 12 | # cdef Py_ssize_t _view_count 13 | # 14 | # cdef inline cpp.PointCloud[cpp.PointXYZ] *thisptr(self) nogil: 15 | # # Shortcut to get raw pointer to underlying PointCloud. 16 | # return self.thisptr_shared.get() 17 | # 18 | # 19 | # # class override(PointCloud_PointXYZI) 20 | # cdef class PointCloud_PointXYZI: 21 | # cdef cpp.PointCloud_PointXYZI_Ptr_t thisptr_shared # XYZI 22 | # 23 | # # Buffer protocol support. 24 | # cdef Py_ssize_t _shape[2] 25 | # cdef Py_ssize_t _view_count 26 | # 27 | # cdef inline cpp.PointCloud[cpp.PointXYZI] *thisptr(self) nogil: 28 | # # Shortcut to get raw pointer to underlying PointCloud. 29 | # return self.thisptr_shared.get() 30 | # 31 | # 32 | # # class override(PointCloud_PointXYZRGB) 33 | # cdef class PointCloud_PointXYZRGB: 34 | # cdef cpp.PointCloud_PointXYZRGB_Ptr_t thisptr_shared 35 | # 36 | # # Buffer protocol support. 37 | # cdef Py_ssize_t _shape[2] 38 | # cdef Py_ssize_t _view_count 39 | # 40 | # cdef inline cpp.PointCloud[cpp.PointXYZRGB] *thisptr(self) nogil: 41 | # # Shortcut to get raw pointer to underlying PointCloud. 42 | # return self.thisptr_shared.get() 43 | # 44 | # 45 | # # class override(PointCloud_PointXYZRGBA) 46 | # cdef class PointCloud_PointXYZRGBA: 47 | # cdef cpp.PointCloud_PointXYZRGBA_Ptr_t thisptr_shared # XYZRGBA 48 | # 49 | # # Buffer protocol support. 50 | # cdef Py_ssize_t _shape[2] 51 | # cdef Py_ssize_t _view_count 52 | # 53 | # cdef inline cpp.PointCloud[cpp.PointXYZRGBA] *thisptr(self) nogil: 54 | # # Shortcut to get raw pointer to underlying PointCloud. 55 | # return self.thisptr_shared.get() 56 | # 57 | -------------------------------------------------------------------------------- /pcl/pcl_grabber_172.pyx: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | # cython: embedsignature=True 3 | # 4 | # Copyright 2014 Netherlands eScience Center 5 | 6 | from libcpp cimport bool 7 | 8 | cimport numpy as np 9 | 10 | cimport _pcl 11 | cimport pcl_defs as cpp 12 | cimport pcl_grabber_defs_172 as pcl_grb 13 | from boost_shared_ptr cimport shared_ptr 14 | 15 | 16 | ### Enum Setting ### 17 | # pcl_visualization_defs.pxd 18 | # cdef enum RenderingProperties: 19 | # Re: [Cython] resolving name conflict -- does not work for enums !? 20 | # https://www.mail-archive.com/cython-dev@codespeak.net/msg02494.html 21 | # PCLVISUALIZER_POINT_SIZE = pcl_grb.PCL_VISUALIZER_POINT_SIZE 22 | # PCLVISUALIZER_OPACITY = pcl_grb.PCL_VISUALIZER_OPACITY 23 | # PCLVISUALIZER_LINE_WIDTH = pcl_grb.PCL_VISUALIZER_LINE_WIDTH 24 | # PCLVISUALIZER_FONT_SIZE = pcl_grb.PCL_VISUALIZER_FONT_SIZE 25 | # PCLVISUALIZER_COLOR = pcl_grb.PCL_VISUALIZER_COLOR 26 | # PCLVISUALIZER_REPRESENTATION = pcl_grb.PCL_VISUALIZER_REPRESENTATION 27 | # PCLVISUALIZER_IMMEDIATE_RENDERING = pcl_grb.PCL_VISUALIZER_IMMEDIATE_RENDERING 28 | ### Enum Setting(define Class InternalType) ### 29 | 30 | # Grabber Callback 31 | # include "pxi/Grabber/PyGrabberCallback.pxi" 32 | 33 | # Grabber 34 | # include "pxi/Grabber/ONIGrabber.pxi" 35 | # include "pxi/Grabber/OpenNIGrabber.pxi" 36 | 37 | -------------------------------------------------------------------------------- /pcl/pcl_grabber_180.pyx: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | # cython: embedsignature=True 3 | # 4 | # Copyright 2014 Netherlands eScience Center 5 | 6 | from libcpp cimport bool 7 | 8 | cimport numpy as np 9 | 10 | cimport _pcl 11 | cimport pcl_defs as cpp 12 | cimport pcl_grabber_defs_180 as pcl_grb 13 | from boost_shared_ptr cimport shared_ptr 14 | 15 | 16 | ### Enum Setting ### 17 | # pcl_visualization_defs.pxd 18 | # cdef enum RenderingProperties: 19 | # Re: [Cython] resolving name conflict -- does not work for enums !? 20 | # https://www.mail-archive.com/cython-dev@codespeak.net/msg02494.html 21 | # PCLVISUALIZER_POINT_SIZE = pcl_grb.PCL_VISUALIZER_POINT_SIZE 22 | # PCLVISUALIZER_OPACITY = pcl_grb.PCL_VISUALIZER_OPACITY 23 | # PCLVISUALIZER_LINE_WIDTH = pcl_grb.PCL_VISUALIZER_LINE_WIDTH 24 | # PCLVISUALIZER_FONT_SIZE = pcl_grb.PCL_VISUALIZER_FONT_SIZE 25 | # PCLVISUALIZER_COLOR = pcl_grb.PCL_VISUALIZER_COLOR 26 | # PCLVISUALIZER_REPRESENTATION = pcl_grb.PCL_VISUALIZER_REPRESENTATION 27 | # PCLVISUALIZER_IMMEDIATE_RENDERING = pcl_grb.PCL_VISUALIZER_IMMEDIATE_RENDERING 28 | ### Enum Setting(define Class InternalType) ### 29 | 30 | # Grabber 31 | # include "pxi/Grabber/ONIGrabber.pxi" 32 | # include "pxi/Grabber/OpenNIGrabber.pxi" 33 | 34 | -------------------------------------------------------------------------------- /pcl/pcl_visualization.pxd: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | # Header for pcl_visualization.pyx functionality that needs sharing with other modules. 3 | 4 | cimport pcl_visualization_defs as pcl_vis 5 | cimport vtk_defs as vtk 6 | 7 | from libc.stddef cimport size_t 8 | 9 | from libcpp.vector cimport vector 10 | from libcpp.string cimport string 11 | from libcpp cimport bool 12 | 13 | # main 14 | cimport pcl_defs as cpp 15 | 16 | # class override(PointCloud) 17 | cdef class PointCloudColorHandleringCustom: 18 | cdef pcl_vis.PointCloudColorHandlerCustom_Ptr_t thisptr_shared # PointCloudColorHandlerCustom[PointXYZ] 19 | 20 | # cdef inline PointCloudColorHandlerCustom[cpp.PointXYZ] *thisptr(self) nogil: 21 | # pcl_visualization_defs 22 | cdef inline pcl_vis.PointCloudColorHandlerCustom[cpp.PointXYZ] *thisptr(self) nogil: 23 | # Shortcut to get raw pointer to underlying PointCloudColorHandlerCustom. 24 | return self.thisptr_shared.get() 25 | 26 | 27 | 28 | cdef class PointCloudGeometryHandleringCustom: 29 | cdef pcl_vis.PointCloudGeometryHandlerCustom_Ptr_t thisptr_shared # PointCloudGeometryHandlerCustom[PointXYZ] 30 | 31 | # cdef inline PointCloudGeometryHandlerCustom[cpp.PointXYZ] *thisptr(self) nogil: 32 | # pcl_visualization_defs 33 | cdef inline pcl_vis.PointCloudGeometryHandlerCustom[cpp.PointXYZ] *thisptr(self) nogil: 34 | # Shortcut to get raw pointer to underlying PointCloudGeometryHandlerCustom. 35 | return self.thisptr_shared.get() 36 | 37 | 38 | cdef class vtkSmartPointerRenderWindow: 39 | # cdef vtk.vtkRenderWindow_Ptr_t thisptr_shared # vtkRenderWindow 40 | cdef vtk.vtkSmartPointer[vtk.vtkRenderWindow] thisptr_shared 41 | 42 | # cdef inline vtk.vtkRenderWindow *thisptr(self) nogil: 43 | cdef inline vtk.vtkSmartPointer[vtk.vtkRenderWindow] thisptr(self) nogil: 44 | # Shortcut to get raw pointer to underlying vtkRenderWindow. 45 | return self.thisptr_shared 46 | 47 | -------------------------------------------------------------------------------- /pcl/pxi/Features/AddList.txt: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/strawlab/python-pcl/809199a3a62e8d98f8b8286db3051b6aee0b295b/pcl/pxi/Features/AddList.txt -------------------------------------------------------------------------------- /pcl/pxi/Features/DifferenceOfNormalsEstimation_172.pxi: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | from libcpp.vector cimport vector 3 | from libcpp cimport bool 4 | 5 | cimport pcl_defs as cpp 6 | cimport pcl_features_172 as pcl_ftr 7 | 8 | from boost_shared_ptr cimport sp_assign 9 | 10 | cdef class DifferenceOfNormalsEstimation: 11 | """ 12 | DifferenceOfNormalsEstimation class for 13 | """ 14 | cdef pcl_ftr.DifferenceOfNormalsEstimation_t *me 15 | 16 | def __cinit__(self, PointCloud pc not None): 17 | self.me = new pcl_ftr.DifferenceOfNormalsEstimation_t() 18 | self.me.setInputCloud(pc.thisptr_shared) 19 | 20 | 21 | -------------------------------------------------------------------------------- /pcl/pxi/Features/DifferenceOfNormalsEstimation_180.pxi: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | from libcpp.vector cimport vector 3 | from libcpp cimport bool 4 | 5 | cimport pcl_defs as cpp 6 | cimport pcl_features_180 as pcl_ftr 7 | 8 | from boost_shared_ptr cimport sp_assign 9 | 10 | cdef class DifferenceOfNormalsEstimation: 11 | """ 12 | DifferenceOfNormalsEstimation class for 13 | """ 14 | cdef pcl_ftr.DifferenceOfNormalsEstimation_t *me 15 | 16 | def __cinit__(self, PointCloud pc not None): 17 | self.me = new pcl_ftr.DifferenceOfNormalsEstimation_t() 18 | self.me.setInputCloud(pc.thisptr_shared) 19 | 20 | 21 | -------------------------------------------------------------------------------- /pcl/pxi/Features/NormalEstimation.pxi: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | cimport _pcl 3 | from libcpp.vector cimport vector 4 | from libcpp cimport bool 5 | 6 | cimport pcl_defs as cpp 7 | cimport pcl_features as pcl_ftr 8 | 9 | 10 | cdef class NormalEstimation: 11 | """ 12 | NormalEstimation class for 13 | """ 14 | cdef pcl_ftr.NormalEstimation_t *me 15 | 16 | def __cinit__(self): 17 | self.me = new pcl_ftr.NormalEstimation_t() 18 | # sp_assign(self.thisptr_shared, new pcl_ftr.NormalEstimation[cpp.PointXYZ, cpp.Normal]()) 19 | 20 | def __dealloc__(self): 21 | del self.me 22 | 23 | def set_SearchMethod(self, _pcl.KdTree kdtree): 24 | self.me.setSearchMethod(kdtree.thisptr_shared) 25 | 26 | def set_RadiusSearch(self, double param): 27 | self.me.setRadiusSearch(param) 28 | 29 | def set_KSearch (self, int param): 30 | self.me.setKSearch (param) 31 | 32 | def compute(self): 33 | normal = PointCloud_Normal() 34 | sp_assign(normal.thisptr_shared, new cpp.PointCloud[cpp.Normal]()) 35 | cdef cpp.PointCloud_Normal_t *cNormal = normal.thisptr() 36 | (self.me).compute(deref(cNormal)) 37 | return normal 38 | 39 | -------------------------------------------------------------------------------- /pcl/pxi/Features/NormalEstimation_172.pxi: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | cimport _pcl 3 | from libcpp.vector cimport vector 4 | from libcpp cimport bool 5 | 6 | cimport pcl_defs as cpp 7 | cimport pcl_features_172 as pcl_ftr 8 | 9 | cdef class NormalEstimation: 10 | """ 11 | NormalEstimation class for 12 | """ 13 | cdef pcl_ftr.NormalEstimation_t *me 14 | 15 | def __cinit__(self): 16 | self.me = new pcl_ftr.NormalEstimation_t() 17 | # sp_assign(self.thisptr_shared, new pcl_ftr.NormalEstimation[cpp.PointXYZ, cpp.Normal]()) 18 | 19 | def __dealloc__(self): 20 | del self.me 21 | 22 | def set_SearchMethod(self, _pcl.KdTree kdtree): 23 | self.me.setSearchMethod(kdtree.thisptr_shared) 24 | 25 | def set_RadiusSearch(self, double param): 26 | self.me.setRadiusSearch(param) 27 | 28 | def set_KSearch (self, int param): 29 | self.me.setKSearch (param) 30 | 31 | def compute(self): 32 | normal = PointCloud_Normal() 33 | sp_assign(normal.thisptr_shared, new cpp.PointCloud[cpp.Normal]()) 34 | cdef cpp.PointCloud_Normal_t *cNormal = normal.thisptr() 35 | (self.me).compute(deref(cNormal)) 36 | return normal 37 | 38 | -------------------------------------------------------------------------------- /pcl/pxi/Features/NormalEstimation_180.pxi: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | cimport _pcl 3 | from libcpp.vector cimport vector 4 | from libcpp cimport bool 5 | 6 | cimport pcl_defs as cpp 7 | cimport pcl_features_180 as pcl_ftr 8 | 9 | 10 | cdef class NormalEstimation: 11 | """ 12 | NormalEstimation class for 13 | """ 14 | cdef pcl_ftr.NormalEstimation_t *me 15 | 16 | def __cinit__(self): 17 | self.me = new pcl_ftr.NormalEstimation_t() 18 | # sp_assign(self.thisptr_shared, new pcl_ftr.NormalEstimation[cpp.PointXYZ, cpp.Normal]()) 19 | 20 | def __dealloc__(self): 21 | del self.me 22 | 23 | def set_SearchMethod(self, _pcl.KdTree kdtree): 24 | self.me.setSearchMethod(kdtree.thisptr_shared) 25 | 26 | def set_RadiusSearch(self, double param): 27 | self.me.setRadiusSearch(param) 28 | 29 | def set_KSearch (self, int param): 30 | self.me.setKSearch (param) 31 | 32 | def compute(self): 33 | normals = PointCloud_Normal() 34 | sp_assign(normals.thisptr_shared, new cpp.PointCloud[cpp.Normal]()) 35 | cdef cpp.PointCloud_Normal_t *cNormal = normals.thisptr() 36 | (self.me).compute(deref(cNormal)) 37 | return normals 38 | 39 | -------------------------------------------------------------------------------- /pcl/pxi/Features/RangeImageBorderExtractor.pxi: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | from libcpp.vector cimport vector 3 | from libcpp cimport bool 4 | 5 | cimport pcl_defs as cpp 6 | cimport pcl_features as pcl_ftr 7 | 8 | 9 | cdef class RangeImageBorderExtractor: 10 | """ 11 | RangeImageBorderExtractor class for 12 | """ 13 | cdef pcl_ftr.RangeImageBorderExtractor_t *me 14 | 15 | def __cinit__(self): 16 | self.me = new pcl_ftr.RangeImageBorderExtractor_t() 17 | 18 | def __dealloc__(self): 19 | del self.me 20 | 21 | def set_RangeImage(self, RangeImage rangeImage): 22 | self.me.setRangeImage(range_image) 23 | 24 | def ClearData (self): 25 | clearData () 26 | 27 | # def GetAnglesImageForBorderDirections () 28 | # data = self.me.getAnglesImageForBorderDirections() 29 | # return data 30 | 31 | # def GetAnglesImageForSurfaceChangeDirections () 32 | # data = self.me.getAnglesImageForSurfaceChangeDirections () 33 | # return data 34 | 35 | # def Compute () 36 | # output = pcl.PointCloudOut() 37 | # self.me.compute (output) 38 | # return output 39 | 40 | 41 | # Parameters& getParameters () 42 | # def GetParameters () 43 | # return self.me.getParameters () 44 | 45 | # 46 | # def HasRangeImage () 47 | # # cdef param = self.me.hasRangeImage () 48 | # return self.me.hasRangeImage () 49 | # 50 | # # 51 | # def GetRangeImage() 52 | # const pcl_rim.RangeImage 53 | # self.me.getRangeImage () 54 | # 55 | # def GetBorderScoresLeft () 56 | # float[] data = self.me.getBorderScoresLeft () 57 | # return data 58 | # 59 | # def GetBorderScoresRight () 60 | # float[] data = self.me.getBorderScoresRight () 61 | # return data 62 | # 63 | # def GetBorderScoresTop () 64 | # float[] data = self.me.getBorderScoresTop () 65 | # return data 66 | # 67 | # def GetBorderScoresBottom () 68 | # float[] data = self.me.getBorderScoresBottom () 69 | # return data 70 | 71 | 72 | 73 | ### 74 | 75 | -------------------------------------------------------------------------------- /pcl/pxi/Features/RangeImageBorderExtractor_172.pxi: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | from libcpp.vector cimport vector 3 | from libcpp cimport bool 4 | 5 | cimport pcl_defs as cpp 6 | cimport pcl_features_172 as pcl_ftr 7 | 8 | 9 | cdef class RangeImageBorderExtractor: 10 | """ 11 | RangeImageBorderExtractor class for 12 | """ 13 | cdef pcl_ftr.RangeImageBorderExtractor_t *me 14 | 15 | def __cinit__(self): 16 | self.me = new pcl_ftr.RangeImageBorderExtractor_t() 17 | 18 | def __dealloc__(self): 19 | del self.me 20 | 21 | def set_RangeImage(self, RangeImage rangeImage): 22 | self.me.setRangeImage(range_image) 23 | 24 | def ClearData (self): 25 | clearData () 26 | 27 | # def GetAnglesImageForBorderDirections () 28 | # data = self.me.getAnglesImageForBorderDirections() 29 | # return data 30 | 31 | # def GetAnglesImageForSurfaceChangeDirections () 32 | # data = self.me.getAnglesImageForSurfaceChangeDirections () 33 | # return data 34 | 35 | # def Compute () 36 | # output = pcl.PointCloudOut() 37 | # self.me.compute (output) 38 | # return output 39 | 40 | 41 | # Parameters& getParameters () 42 | # def GetParameters () 43 | # return self.me.getParameters () 44 | 45 | # 46 | # def HasRangeImage () 47 | # # cdef param = self.me.hasRangeImage () 48 | # return self.me.hasRangeImage () 49 | # 50 | # # 51 | # def GetRangeImage() 52 | # const pcl_rim.RangeImage 53 | # self.me.getRangeImage () 54 | # 55 | # def GetBorderScoresLeft () 56 | # float[] data = self.me.getBorderScoresLeft () 57 | # return data 58 | # 59 | # def GetBorderScoresRight () 60 | # float[] data = self.me.getBorderScoresRight () 61 | # return data 62 | # 63 | # def GetBorderScoresTop () 64 | # float[] data = self.me.getBorderScoresTop () 65 | # return data 66 | # 67 | # def GetBorderScoresBottom () 68 | # float[] data = self.me.getBorderScoresBottom () 69 | # return data 70 | 71 | 72 | 73 | ### 74 | 75 | -------------------------------------------------------------------------------- /pcl/pxi/Features/RangeImageBorderExtractor_180.pxi: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | from libcpp.vector cimport vector 3 | from libcpp cimport bool 4 | 5 | cimport pcl_defs as cpp 6 | cimport pcl_features_180 as pcl_ftr 7 | 8 | 9 | cdef class RangeImageBorderExtractor: 10 | """ 11 | RangeImageBorderExtractor class for 12 | """ 13 | cdef pcl_ftr.RangeImageBorderExtractor_t *me 14 | 15 | def __cinit__(self): 16 | self.me = new pcl_ftr.RangeImageBorderExtractor_t() 17 | 18 | def __dealloc__(self): 19 | del self.me 20 | 21 | def set_RangeImage(self, RangeImage rangeImage): 22 | self.me.setRangeImage(range_image) 23 | 24 | def ClearData (self): 25 | clearData () 26 | 27 | # def GetAnglesImageForBorderDirections () 28 | # data = self.me.getAnglesImageForBorderDirections() 29 | # return data 30 | 31 | # def GetAnglesImageForSurfaceChangeDirections () 32 | # data = self.me.getAnglesImageForSurfaceChangeDirections () 33 | # return data 34 | 35 | # def Compute () 36 | # output = pcl.PointCloudOut() 37 | # self.me.compute (output) 38 | # return output 39 | 40 | 41 | # Parameters& getParameters () 42 | # def GetParameters () 43 | # return self.me.getParameters () 44 | 45 | # 46 | # def HasRangeImage () 47 | # # cdef param = self.me.hasRangeImage () 48 | # return self.me.hasRangeImage () 49 | # 50 | # # 51 | # def GetRangeImage() 52 | # const pcl_rim.RangeImage 53 | # self.me.getRangeImage () 54 | # 55 | # def GetBorderScoresLeft () 56 | # float[] data = self.me.getBorderScoresLeft () 57 | # return data 58 | # 59 | # def GetBorderScoresRight () 60 | # float[] data = self.me.getBorderScoresRight () 61 | # return data 62 | # 63 | # def GetBorderScoresTop () 64 | # float[] data = self.me.getBorderScoresTop () 65 | # return data 66 | # 67 | # def GetBorderScoresBottom () 68 | # float[] data = self.me.getBorderScoresBottom () 69 | # return data 70 | 71 | 72 | 73 | ### 74 | 75 | -------------------------------------------------------------------------------- /pcl/pxi/Features/VFHEstimation.pxi: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | cimport _pcl 3 | from libcpp.vector cimport vector 4 | from libcpp cimport bool 5 | 6 | cimport pcl_defs as cpp 7 | cimport pcl_features as pcl_ftr 8 | 9 | 10 | cdef class VFHEstimation: 11 | """ 12 | VFHEstimation class for 13 | """ 14 | cdef pcl_ftr.VFHEstimation_t *me 15 | 16 | def __cinit__(self): 17 | self.me = new pcl_ftr.VFHEstimation_t() 18 | 19 | def __dealloc__(self): 20 | del self.me 21 | 22 | def set_SearchMethod(self, _pcl.KdTree kdtree): 23 | self.me.setSearchMethod(kdtree.thisptr_shared) 24 | 25 | def set_KSearch (self, int param): 26 | self.me.setKSearch (param) 27 | 28 | # use PointCloud[VFHSignature308] 29 | # def compute(self): 30 | # normal = PointCloud_Normal() 31 | # cdef cpp.PointCloud_Normal_t *cNormal = normal.thisptr() 32 | # self.me.compute (deref(cNormal)) 33 | # return normal 34 | 35 | -------------------------------------------------------------------------------- /pcl/pxi/Features/VFHEstimation_172.pxi: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | cimport _pcl 3 | from libcpp.vector cimport vector 4 | from libcpp cimport bool 5 | 6 | cimport pcl_defs as cpp 7 | cimport pcl_features_172 as pcl_ftr 8 | 9 | 10 | cdef class VFHEstimation: 11 | """ 12 | VFHEstimation class for 13 | """ 14 | cdef pcl_ftr.VFHEstimation_t *me 15 | 16 | def __cinit__(self): 17 | self.me = new pcl_ftr.VFHEstimation_t() 18 | 19 | def __dealloc__(self): 20 | del self.me 21 | 22 | def set_SearchMethod(self, _pcl.KdTree kdtree): 23 | self.me.setSearchMethod(kdtree.thisptr_shared) 24 | 25 | def set_KSearch (self, int param): 26 | self.me.setKSearch (param) 27 | 28 | # use PointCloud[VFHSignature308] 29 | # def compute(self): 30 | # normal = PointCloud_Normal() 31 | # cdef cpp.PointCloud_Normal_t *cNormal = normal.thisptr() 32 | # self.me.compute (deref(cNormal)) 33 | # return normal 34 | 35 | -------------------------------------------------------------------------------- /pcl/pxi/Features/VFHEstimation_180.pxi: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | cimport _pcl 3 | from libcpp.vector cimport vector 4 | from libcpp cimport bool 5 | 6 | cimport pcl_defs as cpp 7 | cimport pcl_features_180 as pcl_ftr 8 | 9 | 10 | cdef class VFHEstimation: 11 | """ 12 | VFHEstimation class for 13 | """ 14 | cdef pcl_ftr.VFHEstimation_t *me 15 | 16 | def __cinit__(self): 17 | self.me = new pcl_ftr.VFHEstimation_t() 18 | 19 | def __dealloc__(self): 20 | del self.me 21 | 22 | def set_SearchMethod(self, _pcl.KdTree kdtree): 23 | self.me.setSearchMethod(kdtree.thisptr_shared) 24 | 25 | def set_KSearch (self, int param): 26 | self.me.setKSearch (param) 27 | 28 | # use PointCloud[VFHSignature308] 29 | # def compute(self): 30 | # normal = PointCloud_Normal() 31 | # cdef cpp.PointCloud_Normal_t *cNormal = normal.thisptr() 32 | # self.me.compute (deref(cNormal)) 33 | # return normal 34 | 35 | -------------------------------------------------------------------------------- /pcl/pxi/Filters/AddList.txt: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/strawlab/python-pcl/809199a3a62e8d98f8b8286db3051b6aee0b295b/pcl/pxi/Filters/AddList.txt -------------------------------------------------------------------------------- /pcl/pxi/Filters/ConditionAnd.pxi: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | from libcpp.vector cimport vector 3 | from libcpp cimport bool 4 | # from libcpp.string cimport string 5 | 6 | cimport pcl_defs as cpp 7 | cimport pcl_filters as pcl_fil 8 | 9 | from pcl_filters cimport CompareOp2 10 | from boost_shared_ptr cimport shared_ptr 11 | from boost_shared_ptr cimport sp_assign 12 | 13 | # cdef class ConditionAnd(ConditionBase): 14 | cdef class ConditionAnd: 15 | """ 16 | Must be constructed from the reference point cloud, which is copied, so 17 | changed to pc are not reflected in ConditionAnd(pc). 18 | """ 19 | cdef pcl_fil.ConditionAnd_t *me 20 | 21 | def __cinit__(self): 22 | self.me = new pcl_fil.ConditionAnd_t() 23 | 24 | def __dealloc__(self): 25 | del self.me 26 | 27 | # def add_Comparison(self, comparison): 28 | # self.me.addComparison(comparison.this_ptr()) 29 | 30 | def add_Comparison2(self, field_name, CompareOp2 compOp, double thresh): 31 | cdef bytes fname_ascii 32 | if isinstance(field_name, unicode): 33 | fname_ascii = field_name.encode("ascii") 34 | elif not isinstance(field_name, bytes): 35 | raise TypeError("field_name should be a string, got %r" % field_name) 36 | else: 37 | fname_ascii = field_name 38 | 39 | cdef pcl_fil.FieldComparisonConstPtr_t fieldComp = new pcl_fil.FieldComparison_t(string(fname_ascii), compOp, thresh) 40 | 41 | # Cython 0.25.2 NG 42 | # self.me.addComparison( fieldComp) 43 | self.me.addComparison( fieldComp) 44 | 45 | # NG 46 | # sp_assign( self.fieldCompPtr, new pcl_fil.FieldComparison_t(string(fname_ascii), compOp, thresh) ) 47 | # self.me.addComparison( self.fieldCompPtr) 48 | 49 | -------------------------------------------------------------------------------- /pcl/pxi/Filters/ConditionAnd_172.pxi: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | from libcpp.vector cimport vector 3 | from libcpp cimport bool 4 | # from libcpp.string cimport string 5 | 6 | cimport pcl_defs as cpp 7 | cimport pcl_filters_172 as pcl_fil 8 | 9 | from pcl_filters cimport CompareOp2 10 | from boost_shared_ptr cimport shared_ptr 11 | from boost_shared_ptr cimport sp_assign 12 | 13 | # cdef class ConditionAnd(ConditionBase): 14 | cdef class ConditionAnd: 15 | """ 16 | Must be constructed from the reference point cloud, which is copied, so 17 | changed to pc are not reflected in ConditionAnd(pc). 18 | """ 19 | cdef pcl_fil.ConditionAnd_t *me 20 | 21 | def __cinit__(self): 22 | self.me = new pcl_fil.ConditionAnd_t() 23 | 24 | def __dealloc__(self): 25 | del self.me 26 | 27 | # def add_Comparison(self, comparison): 28 | # self.me.addComparison(comparison.this_ptr()) 29 | 30 | def add_Comparison2(self, field_name, CompareOp2 compOp, double thresh): 31 | cdef bytes fname_ascii 32 | if isinstance(field_name, unicode): 33 | fname_ascii = field_name.encode("ascii") 34 | elif not isinstance(field_name, bytes): 35 | raise TypeError("field_name should be a string, got %r" % field_name) 36 | else: 37 | fname_ascii = field_name 38 | 39 | cdef pcl_fil.FieldComparisonConstPtr_t fieldComp = new pcl_fil.FieldComparison_t(string(fname_ascii), compOp, thresh) 40 | 41 | # Cython 0.25.2 NG 42 | # self.me.addComparison( fieldComp) 43 | self.me.addComparison( fieldComp) 44 | 45 | # NG 46 | # sp_assign( self.fieldCompPtr, new pcl_fil.FieldComparison_t(string(fname_ascii), compOp, thresh) ) 47 | # self.me.addComparison( self.fieldCompPtr) 48 | 49 | -------------------------------------------------------------------------------- /pcl/pxi/Filters/ConditionAnd_180.pxi: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | from libcpp.vector cimport vector 3 | from libcpp cimport bool 4 | # from libcpp.string cimport string 5 | 6 | cimport pcl_defs as cpp 7 | cimport pcl_filters_180 as pcl_fil 8 | 9 | from pcl_filters cimport CompareOp2 10 | from boost_shared_ptr cimport shared_ptr 11 | from boost_shared_ptr cimport sp_assign 12 | 13 | # cdef class ConditionAnd(ConditionBase): 14 | cdef class ConditionAnd: 15 | """ 16 | Must be constructed from the reference point cloud, which is copied, so 17 | changed to pc are not reflected in ConditionAnd(pc). 18 | """ 19 | cdef pcl_fil.ConditionAnd_t *me 20 | 21 | def __cinit__(self): 22 | self.me = new pcl_fil.ConditionAnd_t() 23 | 24 | def __dealloc__(self): 25 | del self.me 26 | 27 | # def add_Comparison(self, comparison): 28 | # self.me.addComparison(comparison.this_ptr()) 29 | 30 | def add_Comparison2(self, field_name, CompareOp2 compOp, double thresh): 31 | cdef bytes fname_ascii 32 | if isinstance(field_name, unicode): 33 | fname_ascii = field_name.encode("ascii") 34 | elif not isinstance(field_name, bytes): 35 | raise TypeError("field_name should be a string, got %r" % field_name) 36 | else: 37 | fname_ascii = field_name 38 | 39 | cdef pcl_fil.FieldComparisonConstPtr_t fieldComp = new pcl_fil.FieldComparison_t(string(fname_ascii), compOp, thresh) 40 | 41 | # Cython 0.25.2 NG 42 | # self.me.addComparison( fieldComp) 43 | self.me.addComparison( fieldComp) 44 | 45 | # NG 46 | # sp_assign( self.fieldCompPtr, new pcl_fil.FieldComparison_t(string(fname_ascii), compOp, thresh) ) 47 | # self.me.addComparison( self.fieldCompPtr) 48 | 49 | -------------------------------------------------------------------------------- /pcl/pxi/Filters/ConditionalRemoval.pxi: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | from libcpp.vector cimport vector 3 | from libcpp cimport bool 4 | 5 | cimport pcl_defs as cpp 6 | cimport pcl_filters as pcl_fil 7 | 8 | cimport eigen as eigen3 9 | 10 | from boost_shared_ptr cimport shared_ptr 11 | 12 | cdef class ConditionalRemoval: 13 | """ 14 | Must be constructed from the reference point cloud, which is copied, so 15 | changed to pc are not reflected in ConditionalRemoval(pc). 16 | """ 17 | cdef pcl_fil.ConditionalRemoval_t *me 18 | 19 | def __cinit__(self, ConditionAnd cond): 20 | # self.me = new pcl_fil.ConditionalRemoval_t(cond.me) 21 | # direct - NG 22 | self.me = new pcl_fil.ConditionalRemoval_t(cond.me) 23 | 24 | # def __dealloc__(self): 25 | # # MemoryAccessError 26 | # # del self.me 27 | # self.me 28 | 29 | def set_KeepOrganized(self, flag): 30 | self.me.setKeepOrganized(flag) 31 | 32 | def filter(self): 33 | """ 34 | Apply the filter according to the previously set parameters and return 35 | a new pointcloud 36 | """ 37 | cdef PointCloud pc = PointCloud() 38 | self.me.filter(pc.thisptr()[0]) 39 | return pc 40 | -------------------------------------------------------------------------------- /pcl/pxi/Filters/ConditionalRemoval_172.pxi: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | from libcpp.vector cimport vector 3 | from libcpp cimport bool 4 | 5 | cimport pcl_defs as cpp 6 | cimport pcl_filters_172 as pcl_fil 7 | 8 | cimport eigen as eigen3 9 | 10 | from boost_shared_ptr cimport shared_ptr 11 | 12 | cdef class ConditionalRemoval: 13 | """ 14 | Must be constructed from the reference point cloud, which is copied, so 15 | changed to pc are not reflected in ConditionalRemoval(pc). 16 | """ 17 | cdef pcl_fil.ConditionalRemoval_t *me 18 | 19 | def __cinit__(self, ConditionAnd cond): 20 | # self.me = new pcl_fil.ConditionalRemoval_t(cond.me) 21 | # direct - NG 22 | self.me = new pcl_fil.ConditionalRemoval_t(cond.me) 23 | 24 | # def __dealloc__(self): 25 | # # MemoryAccessError 26 | # # del self.me 27 | # self.me 28 | 29 | def set_KeepOrganized(self, flag): 30 | self.me.setKeepOrganized(flag) 31 | 32 | def filter(self): 33 | """ 34 | Apply the filter according to the previously set parameters and return 35 | a new pointcloud 36 | """ 37 | cdef PointCloud pc = PointCloud() 38 | self.me.filter(pc.thisptr()[0]) 39 | return pc 40 | -------------------------------------------------------------------------------- /pcl/pxi/Filters/ConditionalRemoval_180.pxi: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | from libcpp.vector cimport vector 3 | from libcpp cimport bool 4 | 5 | cimport pcl_defs as cpp 6 | cimport pcl_filters_180 as pcl_fil 7 | 8 | cimport eigen as eigen3 9 | 10 | from boost_shared_ptr cimport shared_ptr 11 | 12 | cdef class ConditionalRemoval: 13 | """ 14 | Must be constructed from the reference point cloud, which is copied, so 15 | changed to pc are not reflected in ConditionalRemoval(pc). 16 | """ 17 | cdef pcl_fil.ConditionalRemoval_t *me 18 | 19 | def __cinit__(self, ConditionAnd cond): 20 | # self.me = new pcl_fil.ConditionalRemoval_t(cond.me) 21 | # direct - NG 22 | self.me = new pcl_fil.ConditionalRemoval_t(cond.me) 23 | 24 | # def __dealloc__(self): 25 | # # MemoryAccessError 26 | # # del self.me 27 | # self.me 28 | 29 | def set_KeepOrganized(self, flag): 30 | self.me.setKeepOrganized(flag) 31 | 32 | def filter(self): 33 | """ 34 | Apply the filter according to the previously set parameters and return 35 | a new pointcloud 36 | """ 37 | cdef PointCloud pc = PointCloud() 38 | self.me.filter(pc.thisptr()[0]) 39 | return pc 40 | -------------------------------------------------------------------------------- /pcl/pxi/Filters/FieldComparison.pxi: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | from libcpp.vector cimport vector 3 | from libcpp cimport bool 4 | from libcpp.string cimport string 5 | 6 | cimport pcl_defs as cpp 7 | cimport pcl_filters as pcl_fil 8 | 9 | from pcl_filters cimport CompareOp2 10 | from boost_shared_ptr cimport shared_ptr 11 | 12 | cdef class FieldComparison: 13 | """ 14 | Must be constructed from the reference point cloud, which is copied, so 15 | changed to pc are not reflected in ConditionAnd(pc). 16 | """ 17 | cdef pcl_fil.FieldComparison_t *me 18 | 19 | def __cinit__(self, field_name, CompareOp2 op, double thresh): 20 | cdef bytes fname_ascii 21 | if isinstance(field_name, unicode): 22 | fname_ascii = field_name.encode("ascii") 23 | elif not isinstance(field_name, bytes): 24 | raise TypeError("field_name should be a string, got %r" 25 | % field_name) 26 | else: 27 | fname_ascii = field_name 28 | 29 | self.me = new pcl_fil.FieldComparison_t(field_name, op, thresh) 30 | 31 | def __dealloc__(self): 32 | del self.me 33 | 34 | 35 | 36 | -------------------------------------------------------------------------------- /pcl/pxi/Filters/ProjectInliers.pxi: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | cimport pcl_filters as pcl_fil 3 | cimport pcl_segmentation as pcl_seg 4 | cimport pcl_defs as cpp 5 | 6 | cdef class ProjectInliers: 7 | """ 8 | ProjectInliers class for ... 9 | """ 10 | cdef pcl_fil.ProjectInliers_t *me 11 | def __cinit__(self): 12 | self.me = new pcl_fil.ProjectInliers_t() 13 | def __dealloc__(self): 14 | del self.me 15 | 16 | def filter(self): 17 | """ 18 | Apply the filter according to the previously set parameters and return 19 | a new pointcloud 20 | """ 21 | cdef PointCloud pc = PointCloud() 22 | self.me.filter(pc.thisptr()[0]) 23 | return pc 24 | 25 | # def set_Model_Coefficients(self): 26 | # cdef cpp.ModelCoefficients *coeffs 27 | # coeffs.values.resize(4) 28 | # coeffs.values[0] = 0 29 | # coeffs.values[1] = 0 30 | # coeffs.values[2] = 1.0 31 | # coeffs.values[3] = 0 32 | # self.me.setModelCoefficients(coeffs) 33 | # 34 | # def get_Model_Coefficients(self): 35 | # self.me.getModelCoefficients() 36 | def set_model_type(self, pcl_seg.SacModel m): 37 | self.me.setModelType(m) 38 | def get_model_type(self): 39 | return self.me.getModelType() 40 | def set_copy_all_data(self, bool m): 41 | self.me.setCopyAllData (m) 42 | def get_copy_all_data(self): 43 | return self.me.getCopyAllData () 44 | 45 | -------------------------------------------------------------------------------- /pcl/pxi/Filters/ProjectInliers_172.pxi: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | cimport pcl_filters_172 as pcl_fil 3 | cimport pcl_segmentation_172 as pcl_seg 4 | cimport pcl_defs as cpp 5 | 6 | cdef class ProjectInliers: 7 | """ 8 | ProjectInliers class for ... 9 | """ 10 | cdef pcl_fil.ProjectInliers_t *me 11 | def __cinit__(self): 12 | self.me = new pcl_fil.ProjectInliers_t() 13 | def __dealloc__(self): 14 | del self.me 15 | 16 | def filter(self): 17 | """ 18 | Apply the filter according to the previously set parameters and return 19 | a new pointcloud 20 | """ 21 | cdef PointCloud pc = PointCloud() 22 | self.me.filter(pc.thisptr()[0]) 23 | return pc 24 | 25 | # def set_Model_Coefficients(self): 26 | # cdef cpp.ModelCoefficients *coeffs 27 | # coeffs.values.resize(4) 28 | # coeffs.values[0] = 0 29 | # coeffs.values[1] = 0 30 | # coeffs.values[2] = 1.0 31 | # coeffs.values[3] = 0 32 | # self.me.setModelCoefficients(coeffs) 33 | # 34 | # def get_Model_Coefficients(self): 35 | # self.me.getModelCoefficients() 36 | def set_model_type(self, pcl_seg.SacModel m): 37 | self.me.setModelType(m) 38 | def get_model_type(self): 39 | return self.me.getModelType() 40 | def set_copy_all_data(self, bool m): 41 | self.me.setCopyAllData (m) 42 | def get_copy_all_data(self): 43 | return self.me.getCopyAllData () 44 | 45 | -------------------------------------------------------------------------------- /pcl/pxi/Filters/ProjectInliers_180.pxi: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | cimport pcl_filters_180 as pcl_fil 3 | cimport pcl_segmentation_180 as pcl_seg 4 | cimport pcl_defs as cpp 5 | 6 | cdef class ProjectInliers: 7 | """ 8 | ProjectInliers class for ... 9 | """ 10 | cdef pcl_fil.ProjectInliers_t *me 11 | def __cinit__(self): 12 | self.me = new pcl_fil.ProjectInliers_t() 13 | def __dealloc__(self): 14 | del self.me 15 | 16 | def filter(self): 17 | """ 18 | Apply the filter according to the previously set parameters and return 19 | a new pointcloud 20 | """ 21 | cdef PointCloud pc = PointCloud() 22 | self.me.filter(pc.thisptr()[0]) 23 | return pc 24 | 25 | # def set_Model_Coefficients(self): 26 | # cdef cpp.ModelCoefficients *coeffs 27 | # coeffs.values.resize(4) 28 | # coeffs.values[0] = 0 29 | # coeffs.values[1] = 0 30 | # coeffs.values[2] = 1.0 31 | # coeffs.values[3] = 0 32 | # self.me.setModelCoefficients(coeffs) 33 | # 34 | # def get_Model_Coefficients(self): 35 | # self.me.getModelCoefficients() 36 | def set_model_type(self, pcl_seg.SacModel m): 37 | self.me.setModelType(m) 38 | def get_model_type(self): 39 | return self.me.getModelType() 40 | def set_copy_all_data(self, bool m): 41 | self.me.setCopyAllData (m) 42 | def get_copy_all_data(self): 43 | return self.me.getCopyAllData () 44 | 45 | -------------------------------------------------------------------------------- /pcl/pxi/Filters/RadiusOutlierRemoval.pxi: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | from libcpp.vector cimport vector 3 | from libcpp cimport bool 4 | 5 | cimport pcl_filters as pcl_fil 6 | cimport pcl_segmentation as pcl_seg 7 | cimport pcl_defs as cpp 8 | 9 | cdef class RadiusOutlierRemoval: 10 | """ 11 | RadiusOutlierRemoval class for ... 12 | """ 13 | cdef pcl_fil.RadiusOutlierRemoval_t *me 14 | def __cinit__(self): 15 | self.me = new pcl_fil.RadiusOutlierRemoval_t() 16 | def __dealloc__(self): 17 | del self.me 18 | 19 | def filter(self): 20 | """ 21 | Apply the filter according to the previously set parameters and return 22 | a new pointcloud 23 | """ 24 | cdef PointCloud pc = PointCloud() 25 | # Cython 0.25.2 NG(0.24.1 OK) 26 | # self.me.filter(pc.thisptr()[0]) 27 | # self.me.filter( pc.thisptr()[0]) 28 | # Cython 0.24.1 NG(0.25.2 NG) 29 | # self.me.filter( pc) 30 | # pcl 1.7.2 31 | self.me.filter( pc) 32 | return pc 33 | 34 | def set_radius_search(self, double radius): 35 | self.me.setRadiusSearch(radius) 36 | def get_radius_search(self): 37 | return self.me.getRadiusSearch() 38 | def set_MinNeighborsInRadius(self, int min_pts): 39 | self.me.setMinNeighborsInRadius (min_pts) 40 | def get_MinNeighborsInRadius(self): 41 | return self.me.getMinNeighborsInRadius () 42 | 43 | -------------------------------------------------------------------------------- /pcl/pxi/Filters/RadiusOutlierRemoval_172.pxi: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | from libcpp.vector cimport vector 3 | from libcpp cimport bool 4 | 5 | cimport pcl_defs as cpp 6 | cimport pcl_filters_172 as pcl_fil 7 | cimport pcl_segmentation_172 as pcl_seg 8 | 9 | cdef class RadiusOutlierRemoval: 10 | """ 11 | RadiusOutlierRemoval class for ... 12 | """ 13 | cdef pcl_fil.RadiusOutlierRemoval_t *me 14 | def __cinit__(self): 15 | self.me = new pcl_fil.RadiusOutlierRemoval_t() 16 | def __dealloc__(self): 17 | del self.me 18 | 19 | def filter(self): 20 | """ 21 | Apply the filter according to the previously set parameters and return 22 | a new pointcloud 23 | """ 24 | cdef PointCloud pc = PointCloud() 25 | # Cython 0.25.2 NG(0.24.1 OK) 26 | # self.me.filter(pc.thisptr()[0]) 27 | # self.me.filter( pc.thisptr()[0]) 28 | # Cython 0.24.1 NG(0.25.2 NG) 29 | # self.me.filter( pc) 30 | # pcl 1.7.2 31 | self.me.filter( pc) 32 | return pc 33 | 34 | def set_radius_search(self, double radius): 35 | self.me.setRadiusSearch(radius) 36 | def get_radius_search(self): 37 | return self.me.getRadiusSearch() 38 | def set_MinNeighborsInRadius(self, int min_pts): 39 | self.me.setMinNeighborsInRadius (min_pts) 40 | def get_MinNeighborsInRadius(self): 41 | return self.me.getMinNeighborsInRadius () 42 | 43 | -------------------------------------------------------------------------------- /pcl/pxi/Filters/RadiusOutlierRemoval_180.pxi: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | from libcpp.vector cimport vector 3 | from libcpp cimport bool 4 | 5 | cimport pcl_defs as cpp 6 | cimport pcl_filters_180 as pcl_fil 7 | cimport pcl_segmentation_180 as pcl_seg 8 | 9 | cdef class RadiusOutlierRemoval: 10 | """ 11 | RadiusOutlierRemoval class for ... 12 | """ 13 | cdef pcl_fil.RadiusOutlierRemoval_t *me 14 | def __cinit__(self): 15 | self.me = new pcl_fil.RadiusOutlierRemoval_t() 16 | def __dealloc__(self): 17 | del self.me 18 | 19 | def filter(self): 20 | """ 21 | Apply the filter according to the previously set parameters and return 22 | a new pointcloud 23 | """ 24 | cdef PointCloud pc = PointCloud() 25 | # Cython 0.25.2 NG(0.24.1 OK) 26 | # self.me.filter(pc.thisptr()[0]) 27 | # self.me.filter( pc.thisptr()[0]) 28 | # Cython 0.24.1 NG(0.25.2 NG) 29 | # self.me.filter( pc) 30 | # pcl 1.7.2 31 | self.me.filter( pc) 32 | return pc 33 | 34 | def set_radius_search(self, double radius): 35 | self.me.setRadiusSearch(radius) 36 | def get_radius_search(self): 37 | return self.me.getRadiusSearch() 38 | def set_MinNeighborsInRadius(self, int min_pts): 39 | self.me.setMinNeighborsInRadius (min_pts) 40 | def get_MinNeighborsInRadius(self): 41 | return self.me.getMinNeighborsInRadius () 42 | 43 | -------------------------------------------------------------------------------- /pcl/pxi/Grabber/ONIGrabber.pxi: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | # http://ros-robot.blogspot.jp/2011/08/point-cloud-librarykinect.html 3 | from libcpp.vector cimport vector 4 | from libcpp cimport bool 5 | 6 | cimport pcl_defs as cpp 7 | cimport pcl_grabber as pcl_grb 8 | 9 | cimport eigen as eigen3 10 | cimport _bind_defs as _bind 11 | 12 | from boost_shared_ptr cimport shared_ptr 13 | 14 | 15 | cdef class ONIGrabber_: 16 | """ 17 | Must be constructed from the reference point cloud, which is copied, so 18 | changed to pc are not reflected in ONIGrabber(pc). 19 | """ 20 | cdef pcl_grb.ONIGrabber *me 21 | 22 | def __cinit__(self, string file_name, bool repeat, bool stream): 23 | self.me = new pcl_grb.ONIGrabber(file_name, repeat, stream) 24 | 25 | def __dealloc__(self): 26 | del self.me 27 | 28 | # def RegisterCallback (self, func): 29 | # cdef _bind.arg _1 30 | # cdef _bind.function[_bind.callback_t] callback = _bind.bind[_bind.callback_t](<_bind.callback_t> func, _1) 31 | # self.me.register_callback(<_bind.function[callback_t]> callback) 32 | 33 | def Start(self): 34 | self.me.start () 35 | 36 | def Stop(self): 37 | self.me.stop () 38 | 39 | # string 40 | # def getName (): 41 | # return self.me.getName () 42 | 43 | # bool 44 | # def isRunning (): 45 | # return self.me.isRunning () 46 | 47 | # return float 48 | # def getFramesPerSecond (): 49 | # return self.me.getFramesPerSecond () 50 | 51 | -------------------------------------------------------------------------------- /pcl/pxi/Grabber/OpenNIGrabber.pxi: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | # http://ros-robot.blogspot.jp/2011/08/point-cloud-librarykinect.html 3 | from libcpp.vector cimport vector 4 | from libcpp cimport bool 5 | 6 | cimport pcl_defs as cpp 7 | cimport pcl_grabber as pcl_grb 8 | 9 | cimport eigen as eigen3 10 | cimport _bind_defs as _bind 11 | 12 | from boost_shared_ptr cimport shared_ptr 13 | 14 | cdef void some_callback(void* some_ptr): 15 | print('Hello from some_callback (Cython) !') 16 | # print 'some_ptr: ' + some_ptr 17 | 18 | cdef class OpenNIGrabber_: 19 | """ 20 | Must be constructed from the reference point cloud, which is copied, so 21 | changed to pc are not reflected in OpenNIGrabber(). 22 | """ 23 | cdef pcl_grb.OpenNIGrabber *me 24 | 25 | # cdef void some_callback(self, void* some_ptr): 26 | # print('Hello from some_callback (Cython) !') 27 | # # print 'some_ptr: ' + some_ptr 28 | 29 | def __cinit__(self, device_id, depth_mode, image_mode): 30 | self.me = new pcl_grb.OpenNIGrabber(device_id, depth_mode, image_mode) 31 | 32 | def __dealloc__(self): 33 | del self.me 34 | 35 | def RegisterCallback (self, func): 36 | cdef _bind.arg _1 37 | # cdef _bind.function[_bind.callback_t] callback = _bind.bind[_bind.callback_t](<_bind.callback_t> func, _1) 38 | # NG(Cannot assign type 'void (OpenNIGrabber_, void *)' to 'callback_t') 39 | # cdef _bind.function[_bind.callback_t] callback = _bind.bind[_bind.callback_t](self.some_callback, _1) 40 | cdef _bind.function[_bind.callback_t] callback = _bind.bind[_bind.callback_t](some_callback, _1) 41 | # self.me.register_callback(callback) 42 | self.me.registerCallback[_bind.callback_t](callback) 43 | # (self.me).registerCallback[_bind.callback_t](callback) 44 | 45 | def Start(self): 46 | self.me.start () 47 | 48 | def Stop(self): 49 | self.me.stop () 50 | 51 | # string 52 | # def getName (): 53 | # return self.me.getName () 54 | 55 | # bool 56 | # def isRunning (): 57 | # return self.me.isRunning () 58 | 59 | # return float 60 | # def getFramesPerSecond (): 61 | # return self.me.getFramesPerSecond () 62 | 63 | -------------------------------------------------------------------------------- /pcl/pxi/Grabber/PyGrabberCallback.pxi: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | cimport pcl_grabber as pcl_grb 3 | from ../../grabber_callback cimport PyLibCallBack 4 | from ../../grabber_callback cimport callback 5 | 6 | cdef class PyGrabberCallback: 7 | cdef PyLibCallBack* thisptr 8 | 9 | def __cinit__(self, method): 10 | # 'callback' :: The pattern/converter method to fire a Python 11 | # object method from C typed infos 12 | # 'method' :: The effective method passed by the Python user 13 | self.thisptr = new PyLibCallBack(callback, method) 14 | 15 | def __dealloc__(self): 16 | if self.thisptr: 17 | del self.thisptr 18 | 19 | cpdef double execute(self, parameter): 20 | # 'parameter' :: The parameter to be passed to the 'method' 21 | return self.thisptr.cy_execute(parameter) -------------------------------------------------------------------------------- /pcl/pxi/Grabber/PyGrabberNode.pxi: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | cimport pcl_defs as cpp 3 | cimport pcl_grabber as pcl_grb 4 | 5 | cdef class PyGrabberNode: 6 | cdef double d_prop 7 | 8 | # def __cinit__(self): 9 | # self.thisptr = new PyLibCallBack(callback, method) 10 | 11 | # def __dealloc__(self): 12 | # if self.thisptr: 13 | # del self.thisptr 14 | 15 | def Test(self): 16 | print('PyGrabberNode - Test') 17 | d_prop = 10.0 18 | 19 | 20 | -------------------------------------------------------------------------------- /pcl/pxi/Grabber/SimpleNIGrabber.pxi: -------------------------------------------------------------------------------- 1 | 2 | # -*- coding: utf-8 -*- 3 | # 4 | # http://ros-robot.blogspot.jp/2011/08/point-cloud-librarykinect.html 5 | from libcpp.vector cimport vector 6 | from libcpp cimport bool 7 | 8 | cimport pcl_defs as cpp 9 | cimport pcl_grabber as pclgrb 10 | 11 | cimport eigen as eigen3 12 | 13 | from boost_shared_ptr cimport shared_ptr 14 | 15 | # callback 16 | from cython.operator cimport dereference as deref 17 | import sys 18 | # referenced from 19 | # http://stackoverflow.com/questions/5242051/cython-implementing-callbacks 20 | 21 | ctypedef double (*method_type)(void *param, void *user_data) 22 | 23 | cdef extern from "grabber_callback.hpp": 24 | cdef cppclass cpp_backend: 25 | cpp_backend(method_type method, void *callback_func) 26 | double callback_python(void *parameter) 27 | 28 | cdef double scaffold(void *parameter, void *callback_func): 29 | return (callback_func)(parameter) 30 | 31 | 32 | cdef class SimpleNIGrabber: 33 | """ 34 | Must be constructed from the reference point cloud, which is copied, so 35 | changed to pc are not reflected in SimpleNIGrabber(pc). 36 | """ 37 | cdef cpp_backend *thisptr 38 | 39 | def __cinit__(self, pycallback_func): 40 | self.thisptr = new cpp_backend(scaffold, pycallback_func) 41 | 42 | def __dealloc__(self): 43 | if self.thisptr: 44 | del self.thisptr 45 | 46 | cpdef double callback(self, parameter): 47 | return self.thisptr.callback_python(parameter) 48 | 49 | def run(): 50 | cdef pclgrb.Grabber interface = pclgrb.OpenNIGrabber() 51 | # boost::function f = 52 | # boost::bind (&SimpleOpenNIViewer::cloud_cb_, this, _1) 53 | # interface.registerCallback (f) 54 | interface.start () 55 | 56 | while (!viewer.wasStopped()) 57 | sleep (1) 58 | end 59 | interface.stop () 60 | 61 | -------------------------------------------------------------------------------- /pcl/pxi/IO/AddList.txt: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/strawlab/python-pcl/809199a3a62e8d98f8b8286db3051b6aee0b295b/pcl/pxi/IO/AddList.txt -------------------------------------------------------------------------------- /pcl/pxi/KdTree/AddList.txt: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/strawlab/python-pcl/809199a3a62e8d98f8b8286db3051b6aee0b295b/pcl/pxi/KdTree/AddList.txt -------------------------------------------------------------------------------- /pcl/pxi/KeyPoint/AddList.txt: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/strawlab/python-pcl/809199a3a62e8d98f8b8286db3051b6aee0b295b/pcl/pxi/KeyPoint/AddList.txt -------------------------------------------------------------------------------- /pcl/pxi/KeyPoint/HarrisKeypoint3D.pxi: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | from libc.stddef cimport size_t 3 | 4 | from libcpp.vector cimport vector 5 | from libcpp.string cimport string 6 | from libcpp cimport bool 7 | 8 | # main 9 | cimport pcl_defs as cpp 10 | cimport pcl_keypoints as pcl_kp 11 | 12 | # boost 13 | from boost_shared_ptr cimport shared_ptr 14 | 15 | 16 | ############################################################################### 17 | # Types 18 | ############################################################################### 19 | 20 | ### base class ### 21 | 22 | cdef class HarrisKeypoint3D: 23 | """ 24 | HarrisKeypoint3D class for 25 | """ 26 | cdef pcl_kp.HarrisKeypoint3D_t *me 27 | 28 | def __cinit__(self, PointCloud pc not None): 29 | self.me = new pcl_kp.HarrisKeypoint3D_t() 30 | self.me.setInputCloud(pc.thisptr_shared) 31 | # pass 32 | 33 | def __dealloc__(self): 34 | del self.me 35 | 36 | def set_NonMaxSupression(self, bool param): 37 | self.me.setNonMaxSupression (param) 38 | 39 | def set_Radius(self, float param): 40 | self.me.setRadius (param) 41 | 42 | def set_RadiusSearch(self, double param): 43 | self.me.setRadiusSearch (param) 44 | 45 | def compute(self): 46 | keypoints = PointCloud_PointXYZI() 47 | sp_assign(keypoints.thisptr_shared, new cpp.PointCloud[cpp.PointXYZI]()) 48 | cdef cpp.PointCloud_PointXYZI_t *ckeypoints = keypoints.thisptr() 49 | self.me.compute ( deref(ckeypoints)) 50 | return keypoints 51 | 52 | -------------------------------------------------------------------------------- /pcl/pxi/KeyPoint/HarrisKeypoint3D_172.pxi: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | from libc.stddef cimport size_t 3 | 4 | from libcpp.vector cimport vector 5 | from libcpp.string cimport string 6 | from libcpp cimport bool 7 | 8 | # main 9 | cimport pcl_defs as cpp 10 | cimport pcl_keypoints_172 as pcl_kp 11 | 12 | # boost 13 | from boost_shared_ptr cimport shared_ptr 14 | 15 | 16 | ############################################################################### 17 | # Types 18 | ############################################################################### 19 | 20 | ### base class ### 21 | 22 | cdef class HarrisKeypoint3D: 23 | """ 24 | HarrisKeypoint3D class for 25 | """ 26 | cdef pcl_kp.HarrisKeypoint3D_t *me 27 | 28 | def __cinit__(self, PointCloud pc not None): 29 | self.me = new pcl_kp.HarrisKeypoint3D_t() 30 | self.me.setInputCloud(pc.thisptr_shared) 31 | # pass 32 | 33 | def __dealloc__(self): 34 | del self.me 35 | 36 | def set_NonMaxSupression(self, bool param): 37 | self.me.setNonMaxSupression (param) 38 | 39 | def set_Radius(self, float param): 40 | self.me.setRadius (param) 41 | 42 | def set_RadiusSearch(self, double param): 43 | self.me.setRadiusSearch (param) 44 | 45 | def compute(self): 46 | keypoints = PointCloud_PointXYZI() 47 | sp_assign(keypoints.thisptr_shared, new cpp.PointCloud[cpp.PointXYZI]()) 48 | cdef cpp.PointCloud_PointXYZI_t *ckeypoints = keypoints.thisptr() 49 | self.me.compute ( deref(ckeypoints)) 50 | return keypoints 51 | 52 | -------------------------------------------------------------------------------- /pcl/pxi/KeyPoint/HarrisKeypoint3D_180.pxi: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | from libc.stddef cimport size_t 3 | 4 | from libcpp.vector cimport vector 5 | from libcpp.string cimport string 6 | from libcpp cimport bool 7 | 8 | # main 9 | cimport pcl_defs as cpp 10 | cimport pcl_keypoints_180 as pcl_kp 11 | 12 | # boost 13 | from boost_shared_ptr cimport shared_ptr 14 | 15 | 16 | ############################################################################### 17 | # Types 18 | ############################################################################### 19 | 20 | ### base class ### 21 | 22 | cdef class HarrisKeypoint3D: 23 | """ 24 | HarrisKeypoint3D class for 25 | """ 26 | cdef pcl_kp.HarrisKeypoint3D_t *me 27 | 28 | def __cinit__(self, PointCloud pc not None): 29 | self.me = new pcl_kp.HarrisKeypoint3D_t() 30 | self.me.setInputCloud(pc.thisptr_shared) 31 | # pass 32 | 33 | def __dealloc__(self): 34 | del self.me 35 | 36 | def set_NonMaxSupression(self, bool param): 37 | self.me.setNonMaxSupression (param) 38 | 39 | def set_Radius(self, float param): 40 | self.me.setRadius (param) 41 | 42 | def set_RadiusSearch(self, double param): 43 | self.me.setRadiusSearch (param) 44 | 45 | def compute(self): 46 | keypoints = PointCloud_PointXYZI() 47 | sp_assign(keypoints.thisptr_shared, new cpp.PointCloud[cpp.PointXYZI]()) 48 | cdef cpp.PointCloud_PointXYZI_t *ckeypoints = keypoints.thisptr() 49 | self.me.compute ( deref(ckeypoints)) 50 | return keypoints 51 | 52 | -------------------------------------------------------------------------------- /pcl/pxi/KeyPoint/NarfKeypoint.pxi: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | cimport pcl_defs as cpp 3 | cimport pcl_keypoints as pcl_kp 4 | 5 | cdef class NarfKeypoint: 6 | """ 7 | """ 8 | cdef pcl_kp.NarfKeypoint_t *me 9 | 10 | def __cinit__(self, RangeImageBorderExtractor pc not None): 11 | self.me = new pcl_kp.NarfKeypoint(pc, -1.0) 12 | 13 | def __dealloc__(self): 14 | del self.me 15 | 16 | -------------------------------------------------------------------------------- /pcl/pxi/KeyPoint/NarfKeypoint_172.pxi: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | cimport pcl_defs as cpp 3 | cimport pcl_keypoints_172 as pcl_kp 4 | 5 | cdef class NarfKeypoint: 6 | """ 7 | """ 8 | cdef pcl_kp.NarfKeypoint_t *me 9 | 10 | def __cinit__(self, RangeImageBorderExtractor pc not None): 11 | self.me = new pcl_kp.NarfKeypoint(pc, -1.0) 12 | 13 | def __dealloc__(self): 14 | del self.me 15 | 16 | -------------------------------------------------------------------------------- /pcl/pxi/KeyPoint/NarfKeypoint_180.pxi: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | cimport pcl_defs as cpp 3 | cimport pcl_keypoints_180 as pcl_kp 4 | 5 | cdef class NarfKeypoint: 6 | """ 7 | """ 8 | cdef pcl_kp.NarfKeypoint_t *me 9 | 10 | def __cinit__(self, RangeImageBorderExtractor pc not None): 11 | self.me = new pcl_kp.NarfKeypoint(pc, -1.0) 12 | 13 | def __dealloc__(self): 14 | del self.me 15 | 16 | -------------------------------------------------------------------------------- /pcl/pxi/KeyPoint/UniformSampling.pxi: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | cimport pcl_defs as cpp 3 | cimport pcl_keypoints as pcl_kp 4 | 5 | cdef class UniformSampling: 6 | """ 7 | """ 8 | cdef pcl_kp.UniformSampling_t *me 9 | 10 | def __cinit__(self, PointCloud pc not None): 11 | self.me = new pcl_kp.UniformSampling_t() 12 | self.me.setInputCloud(pc.thisptr_shared) 13 | 14 | def __dealloc__(self): 15 | del self.me 16 | 17 | 18 | # cdef class UniformSampling_PointXYZI: 19 | # """ 20 | # """ 21 | # cdef pcl_kp.UniformSampling_PointXYZI_t *me 22 | # 23 | # def __cinit__(self, PointCloud_PointXYZI pc not None): 24 | # self.me = new pcl_kp.UniformSampling_PointXYZI_t() 25 | # # self.me.setInputCloud( pc.thisptr_shared) 26 | # self.me.setInputCloud(pc.thisptr_shared) 27 | # 28 | # def __dealloc__(self): 29 | # del self.me 30 | ### 31 | 32 | # cdef class UniformSampling_PointXYZRGB: 33 | # """ 34 | # """ 35 | # cdef pcl_kp.UniformSampling_PointXYZRGB_t *me 36 | # 37 | # def __cinit__(self, PointCloud_PointXYZRGB pc not None): 38 | # self.me = new pcl_kp.UniformSampling_PointXYZRGB_t() 39 | # # self.me.setInputCloud( pc.thisptr_shared) 40 | # self.me.setInputCloud(pc.thisptr_shared) 41 | # 42 | # def __dealloc__(self): 43 | # del self.me 44 | ### 45 | 46 | # cdef class UniformSampling_PointXYZRGBA: 47 | # """ 48 | # """ 49 | # cdef pcl_kp.UniformSampling_PointXYZRGBA_t *me 50 | # 51 | # def __cinit__(self, PointCloud_PointXYZRGBA pc not None): 52 | # self.me = new pcl_kp.UniformSampling_PointXYZRGBA_t() 53 | # # self.me.setInputCloud( pc.thisptr_shared) 54 | # self.me.setInputCloud(pc.thisptr_shared) 55 | # 56 | # def __dealloc__(self): 57 | # del self.me 58 | ### 59 | -------------------------------------------------------------------------------- /pcl/pxi/KeyPoint/UniformSampling_172.pxi: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | cimport pcl_defs as cpp 3 | cimport pcl_keypoints_172 as pcl_kp 4 | 5 | cdef class UniformSampling: 6 | """ 7 | """ 8 | cdef pcl_kp.UniformSampling_t *me 9 | 10 | def __cinit__(self, PointCloud pc not None): 11 | self.me = new pcl_kp.UniformSampling_t() 12 | self.me.setInputCloud(pc.thisptr_shared) 13 | 14 | def __dealloc__(self): 15 | del self.me 16 | 17 | 18 | # cdef class UniformSampling_PointXYZI: 19 | # """ 20 | # """ 21 | # cdef pcl_kp.UniformSampling_PointXYZI_t *me 22 | # 23 | # def __cinit__(self, PointCloud_PointXYZI pc not None): 24 | # self.me = new pcl_kp.UniformSampling_PointXYZI_t() 25 | # # self.me.setInputCloud( pc.thisptr_shared) 26 | # self.me.setInputCloud(pc.thisptr_shared) 27 | # 28 | # def __dealloc__(self): 29 | # del self.me 30 | ### 31 | 32 | # cdef class UniformSampling_PointXYZRGB: 33 | # """ 34 | # """ 35 | # cdef pcl_kp.UniformSampling_PointXYZRGB_t *me 36 | # 37 | # def __cinit__(self, PointCloud_PointXYZRGB pc not None): 38 | # self.me = new pcl_kp.UniformSampling_PointXYZRGB_t() 39 | # # self.me.setInputCloud( pc.thisptr_shared) 40 | # self.me.setInputCloud(pc.thisptr_shared) 41 | # 42 | # def __dealloc__(self): 43 | # del self.me 44 | ### 45 | 46 | # cdef class UniformSampling_PointXYZRGBA: 47 | # """ 48 | # """ 49 | # cdef pcl_kp.UniformSampling_PointXYZRGBA_t *me 50 | # 51 | # def __cinit__(self, PointCloud_PointXYZRGBA pc not None): 52 | # self.me = new pcl_kp.UniformSampling_PointXYZRGBA_t() 53 | # # self.me.setInputCloud( pc.thisptr_shared) 54 | # self.me.setInputCloud(pc.thisptr_shared) 55 | # 56 | # def __dealloc__(self): 57 | # del self.me 58 | ### 59 | -------------------------------------------------------------------------------- /pcl/pxi/KeyPoint/UniformSampling_180.pxi: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | cimport pcl_defs as cpp 3 | cimport pcl_keypoints_180 as pcl_kp 4 | 5 | cdef class UniformSampling: 6 | """ 7 | """ 8 | cdef pcl_kp.UniformSampling_t *me 9 | 10 | def __cinit__(self, PointCloud pc not None): 11 | self.me = new pcl_kp.UniformSampling_t() 12 | self.me.setInputCloud(pc.thisptr_shared) 13 | 14 | def __dealloc__(self): 15 | del self.me 16 | 17 | 18 | # cdef class UniformSampling_PointXYZI: 19 | # """ 20 | # """ 21 | # cdef pcl_kp.UniformSampling_PointXYZI_t *me 22 | # 23 | # def __cinit__(self, PointCloud_PointXYZI pc not None): 24 | # self.me = new pcl_kp.UniformSampling_PointXYZI_t() 25 | # # self.me.setInputCloud( pc.thisptr_shared) 26 | # self.me.setInputCloud(pc.thisptr_shared) 27 | # 28 | # def __dealloc__(self): 29 | # del self.me 30 | ### 31 | 32 | # cdef class UniformSampling_PointXYZRGB: 33 | # """ 34 | # """ 35 | # cdef pcl_kp.UniformSampling_PointXYZRGB_t *me 36 | # 37 | # def __cinit__(self, PointCloud_PointXYZRGB pc not None): 38 | # self.me = new pcl_kp.UniformSampling_PointXYZRGB_t() 39 | # # self.me.setInputCloud( pc.thisptr_shared) 40 | # self.me.setInputCloud(pc.thisptr_shared) 41 | # 42 | # def __dealloc__(self): 43 | # del self.me 44 | ### 45 | 46 | # cdef class UniformSampling_PointXYZRGBA: 47 | # """ 48 | # """ 49 | # cdef pcl_kp.UniformSampling_PointXYZRGBA_t *me 50 | # 51 | # def __cinit__(self, PointCloud_PointXYZRGBA pc not None): 52 | # self.me = new pcl_kp.UniformSampling_PointXYZRGBA_t() 53 | # # self.me.setInputCloud( pc.thisptr_shared) 54 | # self.me.setInputCloud(pc.thisptr_shared) 55 | # 56 | # def __dealloc__(self): 57 | # del self.me 58 | ### 59 | -------------------------------------------------------------------------------- /pcl/pxi/Octree/AddList.txt: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/strawlab/python-pcl/809199a3a62e8d98f8b8286db3051b6aee0b295b/pcl/pxi/Octree/AddList.txt -------------------------------------------------------------------------------- /pcl/pxi/PointXYZtoPointXYZ.pxi: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | cimport pcl_defs as cpp 3 | cimport numpy as np 4 | 5 | cdef cpp.PointXYZ to_point_t(point): 6 | cdef cpp.PointXYZ p 7 | # check point datasize 8 | # TypeError: a float is required 9 | # http://stackoverflow.com/questions/15003403/typeerror-a-float-is-required 10 | # TypeError: float() argument must be a string or a number, not 'tuple' 11 | p.x = np.float(point[0]) 12 | p.y = np.float(point[1]) 13 | p.z = np.float(point[2]) 14 | return p 15 | 16 | 17 | cdef cpp.PointXYZI to_point2_t(point): 18 | cdef cpp.PointXYZI p 19 | # check point datasize 20 | p.x = point[0] 21 | p.y = point[1] 22 | p.z = point[2] 23 | p.intensity = point[3] 24 | return p 25 | 26 | 27 | cdef cpp.PointXYZRGB to_point3_t(point): 28 | cdef cpp.PointXYZRGB p 29 | 30 | # check point datasize 31 | p.x = point[0] 32 | p.y = point[1] 33 | p.z = point[2] 34 | p.rgb = point[3] 35 | return p 36 | 37 | 38 | cdef cpp.PointXYZRGBA to_point4_t(point): 39 | cdef cpp.PointXYZRGBA p 40 | 41 | # check point datasize 42 | p.x = point[0] 43 | p.y = point[1] 44 | p.z = point[2] 45 | p.rgba = point[3] 46 | return p 47 | -------------------------------------------------------------------------------- /pcl/pxi/Recognition/AddList.txt: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/strawlab/python-pcl/809199a3a62e8d98f8b8286db3051b6aee0b295b/pcl/pxi/Recognition/AddList.txt -------------------------------------------------------------------------------- /pcl/pxi/SampleConsensus/SampleConsensusModel.pxi: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | cimport pcl_defs as cpp 3 | cimport pcl_sample_consensus as pcl_sac 4 | 5 | from boost_shared_ptr cimport sp_assign 6 | 7 | cdef class SampleConsensusModel: 8 | """ 9 | represents the base model class. 10 | """ 11 | # cdef pcl_sac.SampleConsensusModel_t *me 12 | 13 | def __cinit__(self, PointCloud pc not None): 14 | # NG 15 | # self.me = new pcl_sac.SampleConsensusModel_t() 16 | # self.me = new pcl_sac.SampleConsensusModel_t(pc.thisptr_shared) 17 | # shared_ptr 18 | # sp_assign(self.thisptr_shared, pc.thisptr_shared) 19 | sp_assign(self.thisptr_shared, new pcl_sac.SampleConsensusModel_t(pc.thisptr_shared)) 20 | pass 21 | 22 | # def __dealloc__(self): 23 | # del self.me 24 | 25 | -------------------------------------------------------------------------------- /pcl/pxi/SampleConsensus/SampleConsensusModelCylinder.pxi: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | cimport pcl_defs as cpp 3 | cimport pcl_sample_consensus as pcl_sac 4 | 5 | cdef class SampleConsensusModelCylinder: 6 | """ 7 | defines a model for 3D cylinder segmentation class. 8 | """ 9 | 10 | def __cinit__(self, PointCloud pc not None): 11 | # shared_ptr 12 | sp_assign(self.thisptr_shared, new pcl_sac.SampleConsensusModelCylinder[cpp.PointXYZ, cpp.Normal](pc.thisptr_shared)) 13 | pass 14 | 15 | -------------------------------------------------------------------------------- /pcl/pxi/SampleConsensus/SampleConsensusModelLine.pxi: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | cimport pcl_defs as cpp 3 | cimport pcl_sample_consensus as pcl_sac 4 | 5 | cdef class SampleConsensusModelLine: 6 | """ 7 | defines a model for 3D line segmentation class. 8 | """ 9 | 10 | def __cinit__(self, PointCloud pc not None): 11 | # shared_ptr 12 | sp_assign(self.thisptr_shared, new pcl_sac.SampleConsensusModelLine[cpp.PointXYZ](pc.thisptr_shared)) 13 | pass 14 | 15 | -------------------------------------------------------------------------------- /pcl/pxi/SampleConsensus/SampleConsensusModelPlane.pxi: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | cimport pcl_defs as cpp 3 | cimport pcl_sample_consensus as pcl_sac 4 | 5 | cdef class SampleConsensusModelPlane: 6 | """ 7 | defines a model for 3D plane segmentation class. 8 | """ 9 | # cdef pcl_sac.SampleConsensusModelPlane_t *me 10 | 11 | def __cinit__(self, PointCloud pc not None): 12 | # NG 13 | # self.me = new pcl_sac.SampleConsensusModelPlane_t() 14 | # self.me = new pcl_sac.SampleConsensusModelPlane_t(pc.thisptr_shared) 15 | # shared_ptr 16 | sp_assign(self.thisptr_shared, new pcl_sac.SampleConsensusModelPlane[cpp.PointXYZ](pc.thisptr_shared)) 17 | pass 18 | 19 | # def __dealloc__(self): 20 | # del self.me 21 | 22 | -------------------------------------------------------------------------------- /pcl/pxi/SampleConsensus/SampleConsensusModelRegistration.pxi: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | cimport pcl_defs as cpp 3 | cimport pcl_sample_consensus as pcl_sac 4 | 5 | cdef class SampleConsensusModelRegistration: 6 | """ 7 | defines a model for Point-To-Point registration outlier rejection class. 8 | """ 9 | 10 | def __cinit__(self, PointCloud pc not None): 11 | # shared_ptr 12 | sp_assign(self.thisptr_shared, new pcl_sac.SampleConsensusModelRegistration[cpp.PointXYZ](pc.thisptr_shared)) 13 | pass 14 | 15 | -------------------------------------------------------------------------------- /pcl/pxi/SampleConsensus/SampleConsensusModelSphere.pxi: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | cimport pcl_defs as cpp 3 | cimport pcl_sample_consensus as pcl_sac 4 | 5 | from boost_shared_ptr cimport sp_assign 6 | 7 | cdef class SampleConsensusModelSphere: 8 | """ 9 | define a model for 3D sphere segmentation class. 10 | """ 11 | # cdef pcl_sac.SampleConsensusModelSphere_t *me 12 | 13 | def __cinit__(self, PointCloud pc not None): 14 | # NG 15 | # sp_assign(self.thisptr_shared, new pcl_sac.SampleConsensusModelSphere_t(pc.thisptr_shared)) 16 | sp_assign(self.thisptr_shared, new pcl_sac.SampleConsensusModelSphere[cpp.PointXYZ](pc.thisptr_shared)) 17 | pass 18 | 19 | # def __dealloc__(self): 20 | # del self.me 21 | 22 | -------------------------------------------------------------------------------- /pcl/pxi/SampleConsensus/SampleConsensusModelStick.pxi: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | cimport pcl_defs as cpp 3 | cimport pcl_sample_consensus as pcl_sac 4 | 5 | cdef class SampleConsensusModelStick: 6 | """ 7 | define a model for 3D stick segmentation class. 8 | """ 9 | 10 | def __cinit__(self, PointCloud pc not None): 11 | # shared_ptr 12 | sp_assign(self.thisptr_shared, new pcl_sac.SampleConsensusModelStick[cpp.PointXYZ](pc.thisptr_shared)) 13 | pass 14 | 15 | -------------------------------------------------------------------------------- /pcl/pxi/Segmentation/AddList.txt: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/strawlab/python-pcl/809199a3a62e8d98f8b8286db3051b6aee0b295b/pcl/pxi/Segmentation/AddList.txt -------------------------------------------------------------------------------- /pcl/pxi/Segmentation/ConditionalEuclideanClustering_172.pxi: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | cimport pcl_segmentation_172 as pcl_seg 3 | cimport pcl_defs as cpp 4 | 5 | cdef class ConditionalEuclideanClustering: 6 | """ 7 | ConditionalEuclideanClustering class for Sample Consensus methods and models 8 | """ 9 | cdef pcl_seg.ConditionalEuclideanClustering_t *me 10 | def __cinit__(self): 11 | self.me = new pcl_seg.ConditionalEuclideanClustering_t() 12 | 13 | def __dealloc__(self): 14 | del self.me 15 | 16 | -------------------------------------------------------------------------------- /pcl/pxi/Segmentation/ConditionalEuclideanClustering_180.pxi: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | cimport pcl_segmentation_172 as pcl_seg 3 | cimport pcl_defs as cpp 4 | 5 | cdef class ConditionalEuclideanClustering: 6 | """ 7 | ConditionalEuclideanClustering class for Sample Consensus methods and models 8 | """ 9 | cdef pcl_seg.ConditionalEuclideanClustering_t *me 10 | def __cinit__(self): 11 | self.me = new pcl_seg.ConditionalEuclideanClustering_t() 12 | 13 | def __dealloc__(self): 14 | del self.me 15 | 16 | -------------------------------------------------------------------------------- /pcl/pxi/Segmentation/ProgressiveMorphologicalFilter_172.pxi: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | cimport pcl_segmentation_172 as pcl_seg 3 | cimport pcl_defs as cpp 4 | 5 | cdef class ProgressiveMorphologicalFilter: 6 | """ 7 | ProgressiveMorphologicalFilter class for Sample Consensus methods and models 8 | """ 9 | cdef pcl_seg.ProgressiveMorphologicalFilter_t *me 10 | def __cinit__(self): 11 | self.me = new pcl_seg.ProgressiveMorphologicalFilter_t() 12 | 13 | def __dealloc__(self): 14 | del self.me 15 | 16 | def segment(self): 17 | cdef cpp.PointIndices ind 18 | cdef cpp.ModelCoefficients coeffs 19 | 20 | self.me.segment (ind, coeffs) 21 | return [ind.indices[i] for i in range(ind.indices.size())], \ 22 | [coeffs.values[i] for i in range(coeffs.values.size())] 23 | 24 | def set_InputCloud(self, PointCloud cloud): 25 | self.me.setInputCloud(b) 26 | 27 | def set_MaxWindowSize(self, size): 28 | self.me.setMaxWindowSize(m) 29 | 30 | def set_Slope(self, float param): 31 | self.me.setSlope (param) 32 | 33 | def set_InitialDistance(self, float d): 34 | self.me.setInitialDistance (d) 35 | 36 | def set_MaxDistance(self, float d): 37 | self.me.setMaxDistance (d) 38 | 39 | def extract(self): 40 | self.me.extract () 41 | 42 | 43 | 44 | 45 | -------------------------------------------------------------------------------- /pcl/pxi/Segmentation/ProgressiveMorphologicalFilter_180.pxi: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | cimport pcl_segmentation_172 as pcl_seg 3 | cimport pcl_defs as cpp 4 | 5 | cdef class ProgressiveMorphologicalFilter: 6 | """ 7 | ProgressiveMorphologicalFilter class for Sample Consensus methods and models 8 | """ 9 | cdef pcl_seg.ProgressiveMorphologicalFilter_t *me 10 | def __cinit__(self): 11 | self.me = new pcl_seg.ProgressiveMorphologicalFilter_t() 12 | 13 | def __dealloc__(self): 14 | del self.me 15 | 16 | def segment(self): 17 | cdef cpp.PointIndices ind 18 | cdef cpp.ModelCoefficients coeffs 19 | 20 | self.me.segment (ind, coeffs) 21 | return [ind.indices[i] for i in range(ind.indices.size())], \ 22 | [coeffs.values[i] for i in range(coeffs.values.size())] 23 | 24 | def set_InputCloud(self, PointCloud cloud): 25 | self.me.setInputCloud(b) 26 | 27 | def set_MaxWindowSize(self, size): 28 | self.me.setMaxWindowSize(m) 29 | 30 | def set_Slope(self, float param): 31 | self.me.setSlope (param) 32 | 33 | def set_InitialDistance(self, float d): 34 | self.me.setInitialDistance (d) 35 | 36 | def set_MaxDistance(self, float d): 37 | self.me.setMaxDistance (d) 38 | 39 | def extract(self): 40 | self.me.extract () 41 | 42 | 43 | 44 | 45 | -------------------------------------------------------------------------------- /pcl/pxi/Surface/AddList.txt: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/strawlab/python-pcl/809199a3a62e8d98f8b8286db3051b6aee0b295b/pcl/pxi/Surface/AddList.txt -------------------------------------------------------------------------------- /pcl/pxi/Tracking/AddList.txt: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/strawlab/python-pcl/809199a3a62e8d98f8b8286db3051b6aee0b295b/pcl/pxi/Tracking/AddList.txt -------------------------------------------------------------------------------- /pcl/pxi/Visualization/AddList.txt: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/strawlab/python-pcl/809199a3a62e8d98f8b8286db3051b6aee0b295b/pcl/pxi/Visualization/AddList.txt -------------------------------------------------------------------------------- /pcl/pxi/Visualization/CloudViewing.pxi: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | cimport _pcl 3 | cimport pcl_defs as cpp 4 | cimport numpy as cnp 5 | 6 | cimport pcl_visualization_defs as pcl_vis 7 | from boost_shared_ptr cimport sp_assign 8 | 9 | cdef class CloudViewing: 10 | """ 11 | """ 12 | # cdef pcl_vis.CloudViewer *me 13 | cdef pcl_vis.CloudViewerPtr_t thisptr_shared 14 | 15 | def __cinit__(self): 16 | # self.me = new pcl_vis.CloudViewer() 17 | # sp_assign( self.thisptr_shared, new pcl_vis.CloudViewer('cloud')) 18 | sp_assign(self.thisptr_shared, new pcl_vis.CloudViewer('cloud')) 19 | 20 | cdef inline pcl_vis.CloudViewer *thisptr(self) nogil: 21 | # Shortcut to get raw pointer to underlying CloudViewer 22 | return self.thisptr_shared.get() 23 | 24 | def ShowMonochromeCloud(self, _pcl.PointCloud pc, cloudname=b'cloud'): 25 | self.thisptr().showCloud(pc.thisptr_shared, cloudname) 26 | 27 | def ShowGrayCloud(self, _pcl.PointCloud_PointXYZI pc, cloudname=b'cloud'): 28 | self.thisptr().showCloud(pc.thisptr_shared, cloudname) 29 | 30 | def ShowColorCloud(self, _pcl.PointCloud_PointXYZRGB pc, cloudname=b'cloud'): 31 | self.thisptr().showCloud(pc.thisptr_shared, cloudname) 32 | 33 | def ShowColorACloud(self, _pcl.PointCloud_PointXYZRGBA pc, cloudname=b'cloud'): 34 | self.thisptr().showCloud(pc.thisptr_shared, cloudname) 35 | 36 | def WasStopped(self, int millis_to_wait = 1): 37 | return self.thisptr().wasStopped(millis_to_wait) 38 | 39 | # def SpinOnce(self, int millis_to_wait = 1): 40 | # self.thisptr().spinOnce (millis_to_wait) 41 | 42 | # def OffScreenRendering(bool flag) 43 | # self.thisptr().offScreenRendering (flag) 44 | -------------------------------------------------------------------------------- /pcl/pxi/Visualization/Handler/PointCloudColorHandleringCustom.pxi: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | cimport _pcl 3 | cimport pcl_visualization 4 | from _pcl cimport PointCloud_PointWithViewpoint 5 | from _pcl cimport RangeImages 6 | cimport pcl_defs as cpp 7 | cimport numpy as cnp 8 | 9 | 10 | cimport pcl_visualization_defs as pcl_vis 11 | from boost_shared_ptr cimport sp_assign 12 | 13 | cdef class PointCloudColorHandleringCustom: 14 | """ 15 | """ 16 | # cdef pcl_vis.PointCloudColorHandlerCustom_t *me 17 | 18 | def __cinit__(self): 19 | pass 20 | 21 | # void sp_assign[T](shared_ptr[T] &p, T *value) 22 | def __cinit__(self, _pcl.PointCloud pc, int r, int g, int b): 23 | sp_assign(self.thisptr_shared, new pcl_vis.PointCloudColorHandlerCustom[cpp.PointXYZ](pc.thisptr_shared, r, g, b)) 24 | pass 25 | 26 | # def __cinit__(self, _pcl.RangeImages rangeImage, int r, int g, int b): 27 | # sp_assign(self.thisptr_shared, new pcl_vis.PointCloudColorHandlerCustom[cpp.PointWithViewpoint](rangeImage.thisptr_shared, r, g, b)) 28 | # pass 29 | 30 | def __dealloc__(self): 31 | # del self.me 32 | pass 33 | 34 | 35 | 36 | -------------------------------------------------------------------------------- /pcl/pxi/Visualization/Handler/PointCloudColorHandleringGenericField.pxi: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | cimport _pcl 3 | cimport pcl_defs as cpp 4 | cimport numpy as cnp 5 | 6 | cimport pcl_visualization_defs as pcl_vis 7 | from boost_shared_ptr cimport sp_assign 8 | 9 | cdef class PointCloudColorHandleringGenericField: 10 | """ 11 | """ 12 | cdef pcl_vis.PointCloudColorHandlerGenericField_t *me 13 | 14 | def __cinit__(self): 15 | print('__cinit__') 16 | pass 17 | 18 | def __dealloc__(self): 19 | print('__dealloc__') 20 | # del self.me 21 | pass 22 | 23 | 24 | 25 | -------------------------------------------------------------------------------- /pcl/pxi/Visualization/Handler/PointCloudColorHandleringHSVField.pxi: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | cimport _pcl 3 | cimport pcl_defs as cpp 4 | cimport numpy as cnp 5 | 6 | cimport pcl_visualization_defs as pcl_vis 7 | from boost_shared_ptr cimport sp_assign 8 | 9 | cdef class PointCloudColorHandleringHSVField: 10 | """ 11 | """ 12 | cdef pcl_vis.PointCloudColorHandlerHSVField_t *me 13 | 14 | def __cinit__(self): 15 | print('__cinit__') 16 | pass 17 | 18 | def __dealloc__(self): 19 | print('__dealloc__') 20 | # del self.me 21 | pass 22 | 23 | 24 | 25 | -------------------------------------------------------------------------------- /pcl/pxi/Visualization/Handler/PointCloudColorHandleringRGBField.pxi: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | cimport _pcl 3 | cimport pcl_defs as cpp 4 | cimport numpy as cnp 5 | 6 | cimport pcl_visualization_defs as pcl_vis 7 | from boost_shared_ptr cimport sp_assign 8 | 9 | cdef class PointCloudColorHandleringRGBField: 10 | """ 11 | """ 12 | cdef pcl_vis.PointCloudColorHandlerRGBField_t *me 13 | 14 | def __cinit__(self): 15 | print('__cinit__') 16 | pass 17 | 18 | def __dealloc__(self): 19 | print('__dealloc__') 20 | # del self.me 21 | pass 22 | 23 | 24 | 25 | -------------------------------------------------------------------------------- /pcl/pxi/Visualization/Handler/PointCloudColorHandleringRandom.pxi: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | cimport _pcl 3 | cimport pcl_defs as cpp 4 | cimport numpy as cnp 5 | 6 | cimport pcl_visualization_defs as pcl_vis 7 | from boost_shared_ptr cimport sp_assign 8 | 9 | cdef class PointCloudColorHandleringRandom: 10 | """ 11 | """ 12 | cdef pcl_vis.PointCloudColorHandlerRandom_t *me 13 | 14 | def __cinit__(self): 15 | print('__cinit__') 16 | pass 17 | 18 | def __dealloc__(self): 19 | print('__dealloc__') 20 | # del self.me 21 | pass 22 | 23 | 24 | 25 | -------------------------------------------------------------------------------- /pcl/pxi/Visualization/Handler/PointCloudGeometryHandleringCustom.pxi: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | cimport _pcl 3 | cimport pcl_defs as cpp 4 | cimport numpy as cnp 5 | 6 | cimport pcl_visualization_defs as pcl_vis 7 | from boost_shared_ptr cimport sp_assign 8 | 9 | cdef class PointCloudGeometryHandlerCustom: 10 | """ 11 | """ 12 | cdef pcl_vis.PointCloudGeometryHandlerCustom_t *me 13 | 14 | def __cinit__(self): 15 | print('__cinit__') 16 | pass 17 | 18 | def __dealloc__(self): 19 | print('__dealloc__') 20 | # del self.me 21 | pass 22 | 23 | 24 | 25 | -------------------------------------------------------------------------------- /pcl/pxi/Visualization/Handler/PointCloudGeometryHandleringSurfaceNormal.pxi: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | cimport _pcl 3 | cimport pcl_defs as cpp 4 | cimport numpy as cnp 5 | 6 | cimport pcl_visualization_defs as pcl_vis 7 | from boost_shared_ptr cimport sp_assign 8 | 9 | cdef class PointCloudGeometryHandleringSurfaceNormal: 10 | """ 11 | """ 12 | cdef pcl_vis.PointCloudGeometryHandlerSurfaceNormal_t *me 13 | 14 | def __cinit__(self): 15 | print('__cinit__') 16 | pass 17 | 18 | def __dealloc__(self): 19 | print('__dealloc__') 20 | # del self.me 21 | pass 22 | 23 | 24 | 25 | -------------------------------------------------------------------------------- /pcl/pxi/Visualization/Handler/PointCloudGeometryHandleringXYZ.pxi: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | cimport _pcl 3 | cimport pcl_defs as cpp 4 | cimport numpy as cnp 5 | 6 | cimport pcl_visualization_defs as pcl_vis 7 | from boost_shared_ptr cimport sp_assign 8 | 9 | cdef class PointCloudGeometryHandleringXYZ: 10 | """ 11 | """ 12 | cdef pcl_vis.PointCloudGeometryHandlerXYZ_t *me 13 | 14 | def __cinit__(self): 15 | print('__cinit__') 16 | pass 17 | 18 | def __dealloc__(self): 19 | print('__dealloc__') 20 | # del self.me 21 | pass 22 | 23 | 24 | 25 | -------------------------------------------------------------------------------- /pcl/pxi/Visualization/PCLHistogramViewing.pxi: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | # main 3 | cimport _pcl 4 | cimport pcl_defs as cpp 5 | cimport numpy as cnp 6 | 7 | cimport pcl_visualization_defs as pcl_vis 8 | from boost_shared_ptr cimport sp_assign 9 | 10 | cdef class PCLHistogramViewing: 11 | """ 12 | """ 13 | cdef pcl_vis.PCLHistogramVisualizerPtr_t thisptr_shared 14 | 15 | def __cinit__(self): 16 | sp_assign(self.thisptr_shared, new pcl_vis.PCLHistogramVisualizer()) 17 | 18 | cdef inline pcl_vis.PCLHistogramVisualizer *thisptr(self) nogil: 19 | # Shortcut to get raw pointer to underlying PCLHistogramVisualizer 20 | return self.thisptr_shared.get() 21 | 22 | def SpinOnce(self, int time = 1, bool force_redraw = False): 23 | self.thisptr().spinOnce() 24 | 25 | # self.thisptr().addFeatureHistogram[PointT](shared_ptr[cpp.PointCloud[PointT]] &cloud, int hsize, string cloudname, int win_width, int win_height) 26 | def AddFeatureHistogram(self, _pcl.PointCloud cloud, int hsize, cloudname, int win_width = 640, int win_height = 200): 27 | # self.thisptr().addFeatureHistogram[cpp.PointXYZ]( cloud.thisptr_shared, hsize, cloudname, win_width, win_height); 28 | # self.thisptr().addFeatureHistogram[cpp.PointXYZ]( cloud.thisptr_shared, cloudname, 0, "test", win_width, win_height) 29 | # NG(build ok use NG) 30 | # visualization/impl/histogram_visualizer.hpp 31 | # xy[1] = cloud.points[0].histogram[d] 32 | # 33 | # self.thisptr().addFeatureHistogram[cpp.PointXYZ]( cloud.thisptr_shared, hsize, cloudname, win_width, win_height) 34 | pass 35 | 36 | # def AddFeatureHistogram(self, _pcl.PointCloud_PointXYZRGB cloud, int hsize, cloudname): 37 | # # self.thisptr().addFeatureHistogram[PointT](shared_ptr[cpp.PointCloud[PointT]] &cloud, int hsize, cloudname, int win_width, int win_height) 38 | # self.thisptr().addFeatureHistogram( cloud.thisptr_shared, hsize, cloudname, 640, 200) 39 | 40 | def Spin (self): 41 | self.thisptr().spin() 42 | 43 | -------------------------------------------------------------------------------- /pcl/pxi/Visualization/RangeImageVisualization.pxi: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | cimport _pcl 3 | cimport pcl_defs as cpp 4 | cimport numpy as cnp 5 | 6 | cimport pcl_visualization_defs as pcl_vis 7 | cimport pcl_range_image as pcl_rim 8 | 9 | from boost_shared_ptr cimport sp_assign 10 | 11 | cdef class RangeImageVisualization: 12 | """ 13 | RangeImageVisualization 14 | """ 15 | cdef pcl_vis.RangeImageVisualizer *me 16 | def __cinit__(self): 17 | self.me = new pcl_vis.RangeImageVisualizer() 18 | pass 19 | 20 | def __cinit__(self, string name): 21 | self.me = new pcl_vis.RangeImageVisualizer(name) 22 | pass 23 | 24 | def __dealloc__(self): 25 | # print('__dealloc__') 26 | del self.me 27 | pass 28 | 29 | 30 | # -std::numeric_limits::infinity () 31 | # std::numeric_limits::infinity () 32 | def ShowRangeImage (self, _pcl.RangeImages range_image, float min_value = -99999.0, float max_value = 99999.0, bool grayscale = False): 33 | # self.me.showRangeImage(range_image.thisptr(), min_value, max_value, grayscale) 34 | cdef pcl_rim.RangeImage_t user 35 | user = range_image.thisptr()[0] 36 | self.me.showRangeImage(user, min_value, max_value, grayscale) 37 | 38 | # def MarkPoint(self, int ind_width, int point, int width): 39 | # self.me.markPoint(ind_width, point, width) 40 | 41 | def SpinOnce (self, int time = 1, bool force_redraw = True): 42 | self.me.spinOnce(time, force_redraw) 43 | 44 | 45 | -------------------------------------------------------------------------------- /pcl/pxi/Visualization/vtkSmartPointerRenderWindow.pxi: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | cimport _pcl 3 | cimport pcl_defs as cpp 4 | cimport numpy as cnp 5 | 6 | cimport cython 7 | cimport pcl_visualization 8 | from pcl_visualization import vtkSmartPointerRenderWindow 9 | cimport pcl_visualization_defs as pcl_vis 10 | # cimport vtk_defs as vtk 11 | 12 | from libcpp.string cimport string 13 | 14 | from boost_shared_ptr cimport shared_ptr 15 | from boost_shared_ptr cimport sp_assign 16 | 17 | 18 | cdef class vtkSmartPointerRenderWindow: 19 | """ 20 | """ 21 | def __cinit__(self): 22 | pass 23 | 24 | def GetPointer(self): 25 | # import ctypes 26 | # build ok./not convert vtk objects 27 | # return id(self.thisptr().GetPointer()) 28 | # return ctypes.addressof(id(self.thisptr().GetPointer())) 29 | # build ok./not convert vtk objects 30 | # import vtk 31 | # return vtk.vtkRenderWindow(self.thisptr().GetPointer()) 32 | pass 33 | 34 | 35 | -------------------------------------------------------------------------------- /pcl/pxi/pxd_cimport.pxi: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | 3 | cimport pcl_kdtree as pcl_kdt 4 | cimport pcl_range_image as pcl_rim 5 | # cimport pcl_features as pcl_ftr 6 | cimport pcl_sample_consensus as pcl_sac -------------------------------------------------------------------------------- /pcl/pxi/pxd_cimport_172.pxi: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | 3 | cimport pcl_kdtree_172 as pcl_kdt 4 | cimport pcl_range_image_172 as pcl_rim 5 | # cimport pcl_features_172 as pcl_ftr 6 | cimport pcl_sample_consensus_172 as pcl_sac -------------------------------------------------------------------------------- /pcl/pxi/pxd_cimport_180.pxi: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | cimport pcl_kdtree_180 as pcl_kdt 3 | cimport pcl_range_image_180 as pcl_rim 4 | # cimport pcl_features_180 as pcl_ftr 5 | cimport pcl_sample_consensus_180 as pcl_sac 6 | 7 | -------------------------------------------------------------------------------- /pcl/pxi/pxiInclude.pxi: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | 3 | ### include ### 4 | # common? 5 | include "Vertices.pxi" 6 | include "PointXYZtoPointXYZ.pxi" 7 | # Segmentation 8 | include "Segmentation/Segmentation.pxi" 9 | include "Segmentation/SegmentationNormal.pxi" 10 | include "Segmentation/EuclideanClusterExtraction.pxi" 11 | # Filters 12 | include "Filters/StatisticalOutlierRemovalFilter.pxi" 13 | include "Filters/VoxelGridFilter.pxi" 14 | include "Filters/PassThroughFilter.pxi" 15 | include "Filters/ApproximateVoxelGrid.pxi" 16 | # Kdtree 17 | # same 1.6 ～ 1.8 18 | # include "KdTree/KdTree.pxi" 19 | include "KdTree/KdTree_FLANN.pxi" 20 | # Octree 21 | include "Octree/OctreePointCloud.pxi" 22 | include "Octree/OctreePointCloud2Buf.pxi" 23 | include "Octree/OctreePointCloudSearch.pxi" 24 | include "Octree/OctreePointCloudChangeDetector.pxi" 25 | # Filters 26 | include "Filters/CropHull.pxi" 27 | include "Filters/CropBox.pxi" 28 | include "Filters/ProjectInliers.pxi" 29 | include "Filters/RadiusOutlierRemoval.pxi" 30 | include "Filters/ConditionAnd.pxi" 31 | include "Filters/ConditionalRemoval.pxi" 32 | # Surface 33 | include "Surface/ConcaveHull.pxi" 34 | include "Surface/MovingLeastSquares.pxi" 35 | # RangeImage 36 | include "Common/RangeImage/RangeImages.pxi" 37 | 38 | # Registration 39 | include "registration/GeneralizedIterativeClosestPoint.pxi" 40 | include "registration/IterativeClosestPoint.pxi" 41 | include "registration/IterativeClosestPointNonLinear.pxi" 42 | # SampleConsensus 43 | # same 1.6 ～ 1.8 44 | include "SampleConsensus/RandomSampleConsensus.pxi" 45 | include "SampleConsensus/SampleConsensusModelPlane.pxi" 46 | include "SampleConsensus/SampleConsensusModelSphere.pxi" 47 | include "SampleConsensus/SampleConsensusModelCylinder.pxi" 48 | include "SampleConsensus/SampleConsensusModelLine.pxi" 49 | include "SampleConsensus/SampleConsensusModelRegistration.pxi" 50 | include "SampleConsensus/SampleConsensusModelStick.pxi" 51 | # Features 52 | include "Features/NormalEstimation.pxi" 53 | include "Features/VFHEstimation.pxi" 54 | include "Features/IntegralImageNormalEstimation.pxi" 55 | 56 | # keyPoint 57 | include "KeyPoint/HarrisKeypoint3D.pxi" 58 | include "KeyPoint/UniformSampling.pxi" 59 | # pcl 1.7.2? 60 | # include "registration/NormalDistributionsTransform.pxi" 61 | # visual 62 | # include "Visualization/PointCloudColorHandlerCustoms.pxi" 63 | ### 64 | 65 | 66 | -------------------------------------------------------------------------------- /pcl/pxi/pyx_cimport.pxi: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | cimport pcl_sample_consensus as pcl_sac 3 | cimport pcl_features as pcl_ftr 4 | cimport pcl_filters as pcl_fil 5 | cimport pcl_range_image as pcl_rim 6 | cimport pcl_segmentation as pcl_seg -------------------------------------------------------------------------------- /pcl/pxi/pyx_cimport_172.pxi: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | cimport pcl_sample_consensus_172 as pcl_sac 3 | cimport pcl_features_172 as pcl_ftr 4 | cimport pcl_filters_172 as pcl_fil 5 | cimport pcl_range_image_172 as pcl_rim 6 | cimport pcl_segmentation_172 as pcl_seg -------------------------------------------------------------------------------- /pcl/pxi/pyx_cimport_180.pxi: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | cimport pcl_sample_consensus_180 as pcl_sac 3 | cimport pcl_features_180 as pcl_ftr 4 | cimport pcl_filters_180 as pcl_fil 5 | cimport pcl_range_image_180 as pcl_rim 6 | cimport pcl_segmentation_180 as pcl_seg 7 | 8 | -------------------------------------------------------------------------------- /pcl/pxi/pyx_cimport_181.pxi: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | cimport pcl_sample_consensus_180 as pcl_sac 3 | cimport pcl_features_180 as pcl_ftr 4 | cimport pcl_filters_180 as pcl_fil 5 | cimport pcl_range_image_180 as pcl_rim 6 | cimport pcl_segmentation_180 as pcl_seg 7 | 8 | -------------------------------------------------------------------------------- /pcl/pxi/pyx_cimport_190.pxi: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | cimport pcl_sample_consensus_190 as pcl_sac 3 | cimport pcl_features_190 as pcl_ftr 4 | cimport pcl_filters_190 as pcl_fil 5 | cimport pcl_range_image_190 as pcl_rim 6 | cimport pcl_segmentation_190 as pcl_seg 7 | 8 | -------------------------------------------------------------------------------- /pcl/pxi/pyx_cimport_191.pxi: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | cimport pcl_sample_consensus_190 as pcl_sac 3 | cimport pcl_features_190 as pcl_ftr 4 | cimport pcl_filters_190 as pcl_fil 5 | cimport pcl_range_image_190 as pcl_rim 6 | cimport pcl_segmentation_190 as pcl_seg 7 | 8 | -------------------------------------------------------------------------------- /pcl/pxi/registration/AddList.txt: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/strawlab/python-pcl/809199a3a62e8d98f8b8286db3051b6aee0b295b/pcl/pxi/registration/AddList.txt -------------------------------------------------------------------------------- /pcl/pxi/registration/NormalDistributionsTransform_172.pxi: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | # pcl version 1.7.2 3 | cimport pcl_defs as cpp 4 | cimport pcl_registration_172 as pclreg 5 | 6 | cdef class NormalDistributionsTransform: 7 | """ 8 | Registration class for NormalDistributionsTransform 9 | """ 10 | cdef pcl_reg.NormalDistributionsTransform_t *me 11 | 12 | def __cinit__(self): 13 | self.me = new pcl_reg.NormalDistributionsTransform_t() 14 | 15 | def __dealloc__(self): 16 | del self.me 17 | 18 | # def set_InputTarget(self, pcl_reg.RegistrationPtr_t cloud): 19 | def set_InputTarget(self): 20 | # self.me.setInputTarget (cloud.this_ptr()) 21 | pass 22 | 23 | def set_Resolution(self, float resolution): 24 | self.me.setResolution(resolution) 25 | pass 26 | 27 | def get_Resolution(self): 28 | return self.me.getResolution() 29 | 30 | def get_StepSize(self): 31 | return self.me.getStepSize() 32 | 33 | def set_StepSize(self, double step_size): 34 | self.me.setStepSize(step_size) 35 | 36 | def get_OulierRatio(self): 37 | return self.me.getOulierRatio() 38 | 39 | def set_OulierRatio(self, double outlier_ratio): 40 | self.me.setOulierRatio(outlier_ratio) 41 | 42 | def get_TransformationProbability(self): 43 | return self.me.getTransformationProbability() 44 | 45 | def get_FinalNumIteration(self): 46 | return self.me.getFinalNumIteration() 47 | 48 | -------------------------------------------------------------------------------- /pcl/pxi/registration/NormalDistributionsTransform_180.pxi: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | # pcl version 1.8.0 3 | cimport pcl_defs as cpp 4 | cimport pcl_registration_180 as pclreg 5 | 6 | cdef class NormalDistributionsTransform: 7 | """ 8 | Registration class for NormalDistributionsTransform 9 | """ 10 | cdef pcl_reg.NormalDistributionsTransform_t *me 11 | 12 | def __cinit__(self): 13 | self.me = new pcl_reg.NormalDistributionsTransform_t() 14 | 15 | def __dealloc__(self): 16 | del self.me 17 | 18 | # def set_InputTarget(self, pcl_reg.RegistrationPtr_t cloud): 19 | def set_InputTarget(self): 20 | # self.me.setInputTarget (cloud.this_ptr()) 21 | pass 22 | 23 | def set_Resolution(self, float resolution): 24 | self.me.setResolution(resolution) 25 | pass 26 | 27 | def get_Resolution(self): 28 | return self.me.getResolution() 29 | 30 | def get_StepSize(self): 31 | return self.me.getStepSize() 32 | 33 | def set_StepSize(self, double step_size): 34 | self.me.setStepSize(step_size) 35 | 36 | def get_OulierRatio(self): 37 | return self.me.getOulierRatio() 38 | 39 | def set_OulierRatio(self, double outlier_ratio): 40 | self.me.setOulierRatio(outlier_ratio) 41 | 42 | def get_TransformationProbability(self): 43 | return self.me.getTransformationProbability() 44 | 45 | def get_FinalNumIteration(self): 46 | return self.me.getFinalNumIteration() 47 | 48 | -------------------------------------------------------------------------------- /pcl/shared_ptr.pxd: -------------------------------------------------------------------------------- 1 | cimport pcl_defs as cpp 2 | from libcpp cimport bool 3 | 4 | cdef extern from "boost/smart_ptr/shared_ptr.hpp" namespace "boost" nogil: 5 | cdef cppclass shared_ptr[T]: 6 | shared_ptr() 7 | shared_ptr(T*) 8 | T* get() 9 | bool unique() 10 | long use_count() 11 | void swap(shared_ptr[T]) 12 | void reset(T*) 13 | 14 | cdef extern from "shared_ptr_assign.h" nogil: 15 | #void sp_assign(shared_ptr[cpp.PointCloud[cpp.PointXYZ]] &t, cpp.PointCloud[cpp.PointXYZ] *value) 16 | void sp_assign[T](shared_ptr[T] &p, T *value) 17 | 18 | 19 | -------------------------------------------------------------------------------- /pcl/shared_ptr_assign.h: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | namespace { 5 | // Workaround for lack of operator= support in Cython. 6 | template 7 | void sp_assign(boost::shared_ptr &p, T *v) 8 | { 9 | p = boost::shared_ptr(v); 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /pcl/vtkInteracterWrapper.h: -------------------------------------------------------------------------------- 1 | #ifndef _VTKINTERACTERWRAPPER_H_ 2 | #define _VTKINTERACTERWRAPPER_H_ 3 | 4 | // Point Cloud Library visualization 5 | #include 6 | 7 | // Visualization Toolkit (VTK) 8 | #include 9 | #include 10 | #include 11 | #include 12 | // vtk+qt 13 | // #include 14 | 15 | // VTK + PythonCore 16 | // conda vtk only? 17 | #include "PyVTKObject.h" 18 | 19 | // CPython(PyObject*) 20 | #include "Python.h" 21 | 22 | // void wrapped_from_pclvis_to_vtk(boost::shared_ptr viewer, QVTKRenderWindowInteractor& qvtkWidget, const std::string& id = "PCL Viewer", bool isVisible=false); 23 | void wrapped_from_pclvis_to_vtk(pcl::visualization::PCLVisualizer* viewer, vtkSmartPointer& qvtkWidget, const std::string& id = "PCL Viewer", bool isVisible=false); 24 | // void wrapped_from_pclvis_to_vtk2(PyObject* viewer, PyObject* qvtkWidget, const std::string& id = "PCL Viewer", bool isVisible=false); 25 | // void wrapped_from_pclvis_to_vtk2(pcl::visualization::PCLVisualizer* viewer, PyObject* qvtkWidget, const std::string& id = "PCL Viewer", bool isVisible=false); 26 | void wrapped_from_pclvis_to_vtk2(pcl::visualization::PCLVisualizer* viewer, PyObject* qvtkWidget); 27 | PyObject* wrapped_from_pclvis_to_vtk3(pcl::visualization::PCLVisualizer* viewer); 28 | 29 | #endif // _VTKINTERACTERWRAPPER_H_ 30 | 31 | -------------------------------------------------------------------------------- /pcl_logo.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/strawlab/python-pcl/809199a3a62e8d98f8b8286db3051b6aee0b295b/pcl_logo.png -------------------------------------------------------------------------------- /pkg-config/InstallWindowsGTKPlus.bat: -------------------------------------------------------------------------------- 1 | @echo off 2 | 3 | REM HINT=http://qiita.com/usagi/items/2623145f22faf54b99e0 4 | 5 | cd /d%~dp0 6 | :checkMandatoryLevel 7 | for /f "tokens=1 delims=," %%i in ('whoami /groups /FO CSV /NH') do ( 8 | if "%%~i"=="BUILTIN\Administrators" set ADMIN=yes 9 | if "%%~i"=="Mandatory Label\High Mandatory Level" set ELEVATED=yes 10 | ) 11 | 12 | if "%ADMIN%" neq "yes" ( 13 | echo This file needs to be executed with administrator authority{not Administrators Group} 14 | if "%1" neq "/R" goto runas 15 | goto exit1 16 | ) 17 | if "%ELEVATED%" neq "yes" ( 18 | echo This file needs to be executed with administrator authority{The process has not been promoted} 19 | if "%1" neq "/R" goto runas 20 | goto exit1 21 | ) 22 | 23 | 24 | :admins 25 | REM Install GTK+ 26 | REM powershell -NoProfile -ExecutionPolicy Unrestricted .\Install-GTKPlus.ps1 27 | REM powershell -v 2 -NoProfile -ExecutionPolicy Unrestricted .\Install-GTKPlus.ps1 28 | REM powershell -v 3 -NoProfile -ExecutionPolicy Unrestricted .\Install-GTKPlus.ps1 29 | REM default use upper ver 5(use zip archive package) 30 | powershell -v 5 -NoProfile -ExecutionPolicy Unrestricted .\Install-GTKPlus.ps1 31 | 32 | goto exit1 33 | 34 | :runas 35 | REM Re-run as administrator 36 | powershell -Command Start-Process -Verb runas "%0" -ArgumentList "/R" 37 | 38 | :exit1 -------------------------------------------------------------------------------- /pkg-config/pkg-config_setting.txt: -------------------------------------------------------------------------------- 1 | Windows Only 2 | 3 | 1. Download Gtk+ libraries 4 | http://win32builder.gnome.org/ 5 | 6 | Windows OS 7 | 64 bit 8 | http://win32builder.gnome.org/gtk+-bundle_3.10.4-20131202_win64.zip 9 | 32 bit 10 | http://win32builder.gnome.org/gtk+-bundle_3.10.4-20131202_win32.zip 11 | 12 | 2. Unzip the downloaded zip archive file. 13 | 3. Move the expanded bin folder to the pkg-config folder. 14 | 15 | --- 16 | 17 | Distribution file: "Install-GTKPlus.ps1" 18 | 1. Start powershell with administrator privileges 19 | 2. ps1 placement place (Set-Location) 20 | 3. Change the execution policy 21 | Set-ExecutionPolicy RemoteSigned 22 | 4. Execute 23 | .\Install-GTKPlus.ps1 24 | 5. Return execution policy 25 | Set-ExecutionPolicy Restricted 26 | 27 | * 4, when specifying the absolute path of Install-GTKPlus.ps1, 2 is unnecessary. 28 | -------------------------------------------------------------------------------- /readthedocs.yml: -------------------------------------------------------------------------------- 1 | # .readthedocs.yml 2 | name: python-pcl 3 | type: sphinx 4 | base: docs/source 5 | requirements_file: docs/requirements.txt 6 | 7 | build: 8 | image: latest 9 | 10 | conda: 11 | file: environment.yml 12 | 13 | python: 14 | setup_py_install: false 15 | -------------------------------------------------------------------------------- /requirements-docs.txt: -------------------------------------------------------------------------------- 1 | docutils 2 | pygments 3 | sphinx 4 | sphinx-issues 5 | sphinx_rtd_theme 6 | recommonmark 7 | transifex-client -------------------------------------------------------------------------------- /requirements-test.txt: -------------------------------------------------------------------------------- 1 | nose 2 | coverage 3 | coveralls 4 | codecov 5 | mock 6 | pytest 7 | pytest-cov 8 | -------------------------------------------------------------------------------- /requirements.txt: -------------------------------------------------------------------------------- 1 | numpy>=1.16.1,!=1.16.2 2 | Cython>=0.26.0 3 | -------------------------------------------------------------------------------- /sys_path_check.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | import sys 3 | 4 | print(sys.path) -------------------------------------------------------------------------------- /test_example_command.txt: -------------------------------------------------------------------------------- 1 | # Filtering 2 | python examples\official\Filtering\PassThroughFilter.py 3 | python examples\official\Filtering\statistical_removal.py 4 | 5 | # KdTree 6 | 7 | -------------------------------------------------------------------------------- /tests/test_recognition.py: -------------------------------------------------------------------------------- 1 | import os.path 2 | import pickle 3 | import shutil 4 | import tempfile 5 | import unittest 6 | 7 | import pcl 8 | import numpy as np 9 | 10 | _data = [(i, 2 * i, 3 * i + 0.2) for i in range(5)] 11 | _DATA = """0.0, 0.0, 0.2; 12 | 1.0, 2.0, 3.2; 13 | 2.0, 4.0, 6.2; 14 | 3.0, 6.0, 9.2; 15 | 4.0, 8.0, 12.2""" 16 | 17 | # recognition 18 | 19 | 20 | def suite(): 21 | suite = unittest.TestSuite() 22 | # recognition 23 | # suite.addTests(unittest.makeSuite(...)) 24 | return suite 25 | 26 | 27 | if __name__ == '__main__': 28 | testSuite = suite() 29 | unittest.TextTestRunner().run(testSuite) 30 | -------------------------------------------------------------------------------- /tests/test_surface.py: -------------------------------------------------------------------------------- 1 | import os.path 2 | import pickle 3 | import shutil 4 | import tempfile 5 | import unittest 6 | 7 | import pcl 8 | import numpy as np 9 | 10 | 11 | from nose.plugins.attrib import attr 12 | 13 | 14 | # surface 15 | ### ConcaveHull ### 16 | class TestConcaveHull(unittest.TestCase): 17 | 18 | def setUp(self): 19 | self.p = pcl.load("tests" + os.path.sep + "flydracyl.pcd") 20 | self.surf = self.p.make_ConcaveHull() 21 | # self.surf = pcl.ConcaveHull() 22 | # self.surf.setInputCloud() 23 | 24 | def testreconstruct(self): 25 | alpha = 1.0 26 | self.surf.set_Alpha(alpha) 27 | clonepc = self.surf.reconstruct() 28 | # new instance is returned 29 | self.assertNotEqual(self.p, clonepc) 30 | # concavehull retains the same number of points? 31 | self.assertNotEqual(self.p.size, clonepc.size) 32 | 33 | 34 | ### MovingLeastSquares ### 35 | class TestMovingLeastSquares(unittest.TestCase): 36 | 37 | def setUp(self): 38 | self.p = pcl.load("tests" + os.path.sep + "flydracyl.pcd") 39 | self.surf = self.p.make_moving_least_squares() 40 | 41 | def testFilter(self): 42 | self.surf.set_search_radius(0.5) 43 | self.surf.set_polynomial_order(2) 44 | self.surf.set_polynomial_fit(True) 45 | f = self.surf.process() 46 | # new instance is returned 47 | self.assertNotEqual(self.p, f) 48 | # mls filter retains the same number of points 49 | self.assertEqual(self.p.size, f.size) 50 | 51 | 52 | def suite(): 53 | suite = unittest.TestSuite() 54 | 55 | # surface 56 | suite.addTests(unittest.makeSuite(TestConcaveHull)) 57 | suite.addTests(unittest.makeSuite(TestMovingLeastSquares)) 58 | 59 | return suite 60 | 61 | 62 | if __name__ == '__main__': 63 | testSuite = suite() 64 | unittest.TextTestRunner().run(testSuite) 65 | -------------------------------------------------------------------------------- /tests/tutorials/table_scene_lms400.pcd: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/strawlab/python-pcl/809199a3a62e8d98f8b8286db3051b6aee0b295b/tests/tutorials/table_scene_lms400.pcd -------------------------------------------------------------------------------- /tests/tutorials/table_scene_mug_stereo_textured.pcd: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/strawlab/python-pcl/809199a3a62e8d98f8b8286db3051b6aee0b295b/tests/tutorials/table_scene_mug_stereo_textured.pcd -------------------------------------------------------------------------------- /travisCI/pcl_2d-1.8.pc: -------------------------------------------------------------------------------- 1 | # This file was generated by CMake for PCL library pcl_2d 2 | prefix=/usr/local 3 | exec_prefix=${prefix} 4 | libdir=${prefix}/lib 5 | #includedir=${prefix}/include/pcl-1.8/pcl 6 | includedir=${prefix}/include/pcl-1.8 7 | Name: pcl_2d 8 | Description: Point cloud 2d 9 | Version: 1.8.1.99 10 | Requires: pcl_common-1.8 pcl_io-1.8 pcl_filters-1.8 11 | Libs: 12 | Cflags: -I${includedir} 13 | -------------------------------------------------------------------------------- /travisCI/temporary solution.txt: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/strawlab/python-pcl/809199a3a62e8d98f8b8286db3051b6aee0b295b/travisCI/temporary solution.txt --------------------------------------------------------------------------------