Display, edit, filter, render, convert, generate and export colored point cloud files.

Available at Superhive formerly Blender Market

Standard Edition Key Features:

• Display hundreds of millions of colored points in 3d viewport, limited only by system and gpu memory.
• Any Blender object can be used as container for points, points are not part of Blender data (until converted to) for maximal performance.
• Supported file formats - read: PLY, LAS/LAZ, E57, PCD, any text based file format such as PTS, XYZ, TXT, CSV etc., write: PLY, LAS/LAZ, E57 and PTS.
• Custom PLY reader/writer optimized for point data and performance.
• Supports loading/editing/writing of 3D Gaussian Splatting PLY files, can reconstruct points colors from spherical harmonics and convert to Blender mesh that can be rendered in Cycles engine approximating 3DGS effect.
• Display points with many shading options that can be mixed together, display points with analytic shaders, display point normals, use clipping planes, display scalar values (value remapping in range, color schemes).
• Fast Navigation option that draws subsampled points into 3d viewport while is being navigated for smooth working with very large datasets.
• Cleanup points directly with modal selection tools or by using Blender edit mode with temporary mesh linked with points using Blender tools.
• Mesh Retopology tools that utilize vertices snapping to points and mesh drawn with custom shaders over points.
• Clip planes gizmos to interact with clipping planes visually, store/restore clip planes named states.
• Abundance of editing filters: subsample/voxelize/slice points, crop, boolean, join, split, color adjustment, remove by color or value, project on mesh, remove duplicates, estimate normals, point set registration, surface reconstruction and many more.
• Builtin gpu rendering to image or images sequence with viewport or transparent background.
• Convert points to various Blender mesh (and vdb volume) data for use with Geometry Nodes and rendering with any render engine while preserving all loaded scalar fields and normals.
• Generate point clouds from mesh surface, mesh volume, Geometry Nodes vertices with attributes and generate point clouds from whole scene by simulating lidar scanner or photogrametry.
• Working with PLY sequences, playback, batch convert, filter and export. Sequence can also be generated from mesh or scene.
• Can be used as debugging tool to display 3d location/normal/color data with easy to use python api.
• Extension, all libraries bundled, supported platforms Windows (x64), Linux (x64) and macOS (arm64 & x64)

+ Pro Edition Features:

• All Features as Standard edition
• Tiles mode that allows loading of huge datasets stored in multiple files with real LOD and octree
• Measure tools in Tiles mode
• Special shading options in Tiles mode optimized for datasets without colors

Standard Edition

• Display hundreds of millions of colored points in 3d viewport, limited only by system and gpu memory.
• Any Blender object can be used as container for points, points are not part of Blender data (until converted to) for maximal performance.
• Supported file formats - read: PLY, LAS/LAZ, E57, PCD, any text based file format such as PTS, XYZ, TXT, CSV etc., write: PLY, LAS/LAZ, E57 and PTS.
• Custom PLY reader/writer optimized for point data and performance.
• Supports loading/editing/writing of 3D Gaussian Splatting PLY files, can reconstruct points colors from spherical harmonics and convert to Blender mesh that can be rendered in Cycles engine approximating 3DGS effect.
• Display points with many shading options that can be mixed together, display points with analytic shaders, display point normals, use clipping planes, display scalar values (value remapping in range, color schemes).
• Fast Navigation option that draws subsampled points into 3d viewport while is being navigated for smooth working with very large datasets.
• Cleanup points directly with modal selection tools or by using Blender edit mode with temporary mesh linked with points using Blender tools.
• Mesh Retopology tools that utilize vertices snapping to points and mesh drawn with custom shaders over points.
• Clip planes gizmos to interact with clipping planes visually, store/restore clip planes named states.
• Abundance of editing filters: subsample/voxelize/slice points, crop, boolean, join, split, color adjustment, remove by color or value, project on mesh, remove duplicates, estimate normals, point set registration, surface reconstruction and many more.
• Builtin gpu rendering to image or images sequence with viewport or transparent background.
• Convert points to various Blender mesh (and vdb volume) data for use with Geometry Nodes and rendering with any render engine while preserving all loaded scalar fields and normals.
• Generate point clouds from mesh surface, mesh volume, Geometry Nodes vertices with attributes and generate point clouds from whole scene by simulating lidar scanner or photogrametry.
• Working with PLY sequences, playback, batch convert, filter and export. Sequence can also be generated from mesh or scene.
• Can be used as debugging tool to display 3d location/normal/color data with easy to use python api.
• Extension, all libraries bundled, supported platforms Windows (x64), Linux (x64) and macOS (arm64 & x64)

+ Pro Edition

• All Features as Standard edition
• Tiles mode that allows loading of huge datasets stored in multiple files with real LOD and octree
• Measure tools in Tiles mode
• Special shading options in Tiles mode optimized for datasets without colors

Platform Compatibility

• Windows (x64), Linux (x64) and macOS (arm64 & x64)
• macOS x64 (Intel Architecture) version is provided, but not tested

Blender Compatibility

As a general rule, using latest Blender LTS release is the best, at the time of writing it is Blender 4.5 LTS, latest LTS is used for development and will be the most tested Blender version

• Blender 4.2.6 LTS or later (using LTS is always recommended)
• Blender 4.3 may not work because issue with installation that has been fixed after its release
• Blender 4.4 or later will be compatible, up to Blender 5.0
• for Blender 5.1 use distribution zip with -blender-5.1 suffix and see notes on Blender 5.1 bellow

Notes on Blender 5.0

• PCV is fully compatible on macOS with Metal gpu backend and on Windows/Linux with OpenGL gpu backend
• on Windows/Linux with Vulkan gpu backend, there is minor issue that has been fixed in Blender 5.1 (it is not clear if fix will be backported to Blender 4.5 LTS), this issue affects viewport postprocessing, Tiles shading and modal tools that depends on point selecting, if you switch gpu backend to OpenGL and restart Blender, all will be working as intended. Blender 5.1 works fine with Vulkan backend.

Notes on Blender 5.1

• Blender 5.1 comes with major changes relevant to extensions, Python version went from 3.11 to 3.13 and Numpy from 1.x to 2.x and all libraries that use compiled code need to be budled for new Python and all of them need to support new Numpy
• At the moment, only Open3D is not yet officially released for Python 3.13 and it is not bundled in PCV so features that depends on Open3D will not work
• To install PCV in Blender 5.1, you need to download and install distribution zip for Blender 5.1 (-blender-5.1 suffix), regular distribution zip will refuse to install

Notes on Blender 5.2

• When Blender 5.2 LTS will be released, PCV for macOS x64 (Intel Architecture) will no longer be updated and will be available only as legacy version for Blender 4.5 LTS

Installation

• download latest version point_cloud_visualizer-*version*-*platform*-*architecture*.zip for your system
• start Blender, drag and drop zip into it

Update

• download latest version point_cloud_visualizer-*version*-*platform*-*architecture*.zip for your system
• start Blender, go to Preferences > Get Extensions and find PCV in list
• Choose Uninstall from drop down menu
• quit Blender
• start Blender
• install new PCV (drag and drop zip, see Installation)

⚠️ Upgrade from PCV 3.0.x or earlier (Legacy addon)

PCV 3.1+, as extension, bundles all libraries, libraries installed by legacy PCV must be removed. Not doing so may lead to conflicts between bundled and legacy installed libraries, especially when another installed legacy addon still uses user site-packages directory for its dependencies.

There are two ways to do that: Automatic after new PCV installation via Check Environment button or Manual by deleting all libraries (packages) directories and files from inside of user site-packages directory.

If you are sure you didn't previously install any library using legacy PCV Install *library* operators, you can skip all of the following steps. If you are not 100% sure, you can follow Automatic procedure.

Automatic

• Start Blender, go to Preferences > Addons, find legacy PCV, disable and remove. Save Preferences (if automatic saving is disabled) and Quit Blender.
• Start Blender again, install new PCV (drag and drop zip, see Installation).
• Go to Preferences > Addons, find PCV, expand and under Libraries click Check Environment button. Operator popup will show any problems found and list of libraries installed in user site-packages directory if any are found there. If any library is found, now you can uninstall all libraries from shown list by running Uninstall All operator from popup (will run pip uninstall *package* for each library found in list, which should uninstall it only from user site-packages, not anywhere else if you happen to have more copies). Quit Blender when operator finishes.

Manual

Manual option is recommended for advanced users, that way you will be sure nothing is left uninstalled.

• Start Blender, change any region to Python Console and paste following command:

import site; site.getusersitepackages()

• Press Enter. Path to user site-packages directory will be printed out. Open this directory in your OS file browser. Usually the directory is on macOS/Linux at ~/.local/lib/python3.11/site-packages on Windows %APPDATA%/Python/Python311/site-packages. Also usually this directory is hidden, you may need to enable showing of hidden directories in your OS file browser or paste path to File Explorer path bar on Windows or use Go to Folder (Command+Shift+G) on macOS. Leave window with directory opened.
• From Blender Preferences > Addons disable legacy PCV and remove. Save Preferences (if automatic saving is disabled) and Quit Blender.
• Now manually remove libraries installed by legacy PCV (or any other legacy addon that uses the same system):
  • Go to your OS file browser you opened earlier with opened user site-packages directory and remove everything inside (delete or move to another directory as backup, as you wish), doing so will uninstall all Python libraries installed to user site-packages directory.
  • If you are using some other legacy addon that installs libraries and uses user site-packages directory, you will need to let such addon reinstall them, usually disable and enable (if installs automatically) or click button in such addon preferences (if they let user do it manually).
• Start Blender again, install new PCV (drag and drop zip, see Installation).
• To check if everything is OK and no other than bundled libraries are available, open PCV preferences and under Libraries section, click Check Environment button, popup will open with info. If all is OK, All seems to be fine. message will be displayed.
  • Please note, if some other legacy addon uses user site-packages it will be detected and reported, if some other legacy addon installs any library automatically at startup, it will be also found and reported.

About Libraries

• some select PCV functions depends on 3rd party libraries
• all libraries are bundled in extension: Python Wheels
• with two exceptions (see Known Issues) they are included without modification as downloaded from The Python Package Index (PyPI) via pip download command

Some libraries still have conflicts with other libraries (mainly on Windows platform) which may lead to Blender crash. PCV has automatic system to prevent that, PCV Preferences > Libraries > Resolve Library Conflicts Using Python Subprocess, it is enabled by default. This system runs such operation in another python process without Blender. Input data are saved to disk, separate python process is launched, data processed and written back to disk. Results are collected back to Blender and temporary files removed, slightly slower to run, but prevents freezes and crashes.

PCV is tested on macOS 15 Apple Silicon (arm64), Windows 10 (x64) and Ubuntu 24.04 (x64). macOS Intel (x64) is provided, but not tested.

Bundled Libraries

Following libraries are bundled and used by PCV. There are also wheels of their dependencies, for complete list, look into extension wheels directory.

Laspy

Laspy is a python library for reading, modifying and creating LAS LiDAR files.

License: BSD License

• https://github.com/laspy/laspy
• https://pypi.org/project/laspy/

lazrs

Python bindings for the laz-rs crate. Implementation or rather, translation of LAZ (laszip compression) format in Rust.

License: MIT

• https://github.com/laz-rs/laz-rs-python
• https://pypi.org/project/lazrs/

pye57

Python wrapper of LibE57Format to read and write .e57 point cloud files

License: MIT License (MIT)

• https://github.com/davidcaron/pye57
• https://pypi.org/project/pye57/

SciPy

SciPy (pronounced "Sigh Pie") is an open-source software for mathematics, science, and engineering. It includes modules for statistics, optimization, integration, linear algebra, Fourier transforms, signal and image processing, ODE solvers, and more.

License: BSD License

• https://scipy.org/
• https://github.com/scipy/scipy
• https://pypi.org/project/scipy/

Open3D

Open3D: A Modern Library for 3D Data Processing

License: MIT License (MIT)

• https://www.open3d.org/
• https://github.com/isl-org/Open3D
• https://pypi.org/project/open3d/

PyMeshLab

PyMeshLab is a Python library that interfaces to MeshLab, the popular open source application for editing and processing large 3D triangle meshes. Python bindings are generated using pybind11.

License: GPL3

• https://www.meshlab.net/
• https://github.com/cnr-isti-vclab/PyMeshLab
• https://pypi.org/project/pymeshlab/

psutil

Cross-platform lib for process and system monitoring in Python

License: BSD License (BSD-3-Clause)

• https://github.com/giampaolo/psutil
• https://pypi.org/project/psutil/

Known Issues

• pye57 wheel for macOS, Intel architecture (x64) is built from source because official wheel is not available at PyPI
• PyMeshLab wheel is not installed properly by Blender (Issue Report), bundled wheels are repacked by me to format Blender expects until Blender is fixed. Contents is the same, only two extra directories pymeshlab-2023.12.post2.data/purelib above actual module are removed and paths updated
• Open3D dependencies has problem installing on Windows because of path length limit (Issue Report), offending wheel is not included in PCV, so Open3D installation is not complete. Its gui functions may be broken, but PCV does not use any of that. Just keep that in mind if you plan to use Open3D in your own custom scripts. macOS and Linux platforms are unaffected by this issue, only Windows.

Integration

• PCV uses any Blender object as a "point in space", that object origin serves as zero point. Point cloud will then draw in object local space. i.e. point cloud will be transformed in the same way as container object. The best is to use Empty object type as containers.
• PCV by default does not store loaded points in blend file because there is no suitable data type available. Only PCV settings and path to data file is stored. when blend file is reopened, points need to loaded from linked file again by clicking Draw button. If you wish to store points in .blend file, see Packer in Preferences for more info.
• Any changes to points made with PCV have to be saved using Export panel before quitting Blender or loading other blend file, otherwise will be lost.

UI Locations

• main PCV panel is located in 3D Viewport Sidebar N under Point Cloud Visualizer tab
• one more extra pop up panel in 3D Viewport header at the top right corner
• helper operator in 3D Viewport > Add menu

General Use

To load and display point cloud from any supported file type, you can add an Empty type object to scene (or use any other Blender object type that exists in scene), then go to 3d Viewport sidebar > PCV tab and click Choose File , file browser will open, select your file and click Load. File will be loaded and contents displayed.

Add Menu Helper Operator

Faster and preferable way of adding PCV instance to scene is to use helper operator from Add menu: 3d Viewport header > Add or Shift+A anywhere in viewport and choose Point Cloud Visualizer menu item. File browser will open where you can choose single or multiple files, click Add PCV Instance(s) and for each selected file, new Empty object will be added, named after file name and file contents will be loaded and drawn.

Any file format that is readable by PCV can be loaded this way, only ASCII file types need to use preset that has been made and saved in advance and multiple files have to have the same format.

File Drag and Drop Support

Files can be loaded by dragging and dropping file to Blender 3D viewport. Upon drag and drop, Add Helper operator is invoked where you can set options. Drag and drop is supported only for .ply, .las, .laz, .e57 and .pcd files. Ascii file types are not supported.

Because Blender has its own .ply importer, if any of dropped files is a .ply file, you need to choose Add PCV Instance(s) option from automatically displayed menu to use PCV.

Large Datasets

• currently, PCV needs to load all points from source file and keep them in system memory
• during loading, system memory usage will peak quite high, 4 (and more in some cases) times the runtime usage
• for display, PCV need to upload all points that are going to be displayed (you can control amount with PCV > Display > Percentage slider) to gpu memory
• to determine approximate maximum number of points your gpu can display at once you can use calculator in PCV preferences (for example 8GB gpu can display ~300M points with default shader and disabled scalars), calculator formula is simple:

ram = 8192  # MB
b = (1024*1024) * ram  # bytes
# default shader uses 3x float32 for point location and 4x float32 for color (rgba)
# float32 takes 4 bytes, hence 3*4 + 4*4 bytes
n = int(b / (12 + 16))
print(n)  # 306783378

• trying to display more points (i.e. uploading more data than gpu memory can contain) will result in Blender crash or freeze
• when extremely big data need to be loaded and is not required to work with exactly all points, alternative loading methods Every Nth or Slice can be used to reduce number of points during loading

Fast Navigation

Draw low resolution point cloud during viewport navigation, it is enabled in PCV Preferences globally and will apply on all PCV instances in scene. During viewport navigation, normals and bounding box drawing is skipped, there rest of shading options is kept, selection is always drawn in full. Each PCV instance can be excluded by unchecking PCV > Display > Options > Use Fast Navigation.

Note: Blender API has no way to tell if user is navigating viewport (well, at least without using modal operator and that is not applicable in this case) so solution involves timers and because of that, when you are still navigating, but pause any movement a bit, high resolution will be drawn after delay and also first redraw when you just started navigating might lag a bit, API does not provide mouse events so i cannot react before view is really changed.

Panels

Main Panel

Main PCV panel is located in 3D Viewport Sidebar N under Point Cloud Visualizer tab. This panel shows active object properties and operators.

Main Controls

• Choose file clicking browse icon and from now on, active object is considered a "PCV Instance".
• and indicates Pack flag status. See Preferences for more info.
• reloads linked file contents.
• Linked file name and number of loaded / displayed points.
• Draw and Erase operators. Draw operator will also load points if they are not loaded. Erase will only stop drawing in viewport, loaded points will remain in system memory.
• Frame Points will center points in viewport camera and adjust its Clip End property if needed to show all points.

3D Viewport Panel

Pop up panel at the top right corner of 3D Viewport header contains actions that can run on multiple PCV instances at the same time, Packer operators that work with current blend file and Postprocess options.

Batch Operators

• Run basic loading, drawing and export operators on every PCV instance that is found in scene and falls under Influence. It is the same like selecting object by object and clicking operator button.
• Synchronize Shader Properties will copy display properties from active to influenced instance.

Packer

• Packer is fully automated storing of loaded points directly in .blend file as hidden mesh datablocks on .blend file save and restoring points from stored meshes on .blend file load. See Preferences for more info.
• Pack and Unpack operators are run automatically on .blend file events or can be run manually from here.
• Optimize will remove stored meshes if PCV instance is no longer present in .blend file, this is also automated during packing or can be run manually from here.
• Clear will remove all stored meshes.
• Mark All Loaded and Unmark All will set Pack flag on all pcv instances in scene.
• Packed Points are will show summary of stored mesh datablocks.

Postprocess

Viewport postprocessing. All draw calls from PCV goes to Offscreen first, then everything is drawn on top of viewport using selected shader. Because of that, points will be always on top above everything else. Currently there is: Quasi EDL, something very similar to Eye-Dome-Lighting. Points are shaded in screen space by their depth. No normals are required. The best use for it is when your points have no other data than point locations. And Image Ouput that will create image datablock with the same content as is drawn on screen, useful for quick screen renders without camera and setting anything.

Display

Points

Colors

Alpha

Depth

Depth Effects

Matcap

Color Adjust

Shade

Illumination

Phong

Fresnel

X-Ray

Effects

Displace

Noise

Position Colors Shader Properties

Height Colors Shader Properties

Scalar Field

Clip

Normals

Bounding Box

Options

Load

General

Reader Options

ASCII Preset Builder

Example of typical PTS file preset

Data

Edit

Edit Mode

Tools

Collection of modal operators for direct editing of points, points container object or mesh. If operator is running all panels but Tools are disabled. To switch tool, click its button on panel.

All Retopology and Transform tools and Place 3D Cursor (GPU) are GPU accelerated. They utilize GPU for point selection. Points are selected in Detection Radius around mouse pointer, point closest to screen space center is selected. Point selection works best if points are that dense so they cover points behind them. If your points are too sparse, there are several options how to prevent selection of points behind those on "surface". Increase point pixel size, or enable Display > Points > Adaptive Size and adjust point size so they cover space between them, or enable Use Depth (D key shortcut) at running tool panel to utilize gpu depth buffer to determine which points are closest in tool Detection Radius.

All tools when running shows help panel in viewport with all modal shortcuts. This help panel can be toggled with H key or disabled in preferences Show Help Panel At Tool Start.

3D Cursor

Place 3D Cursor

Place 3D Cursor on closest point in cloud under mouse cursor. CPU variant, faster on smaller datasets.

• LMB: Place
• Shift+LMB: Place and align with normal
• LMB+drag: Continuous place
• H: Toggle Help panel
• ESC: Exit

Place 3D Cursor (GPU)

Place 3D Cursor on closest point in cloud under mouse cursor. GPU accelerated variant, faster on large datasets.

• LMB: Place
• Shift+LMB: Place and align with normal
• LMB+drag: Continuous place
• D: Toggle using depth buffer for point selection
• H: Toggle Help panel
• ESC: Exit

Transform

Translate

Translate points container so selected point is at chosen location.

• LMB(+drag): Set point
• F: Translate
• D: Toggle using depth buffer for point selection
• RMB: Cancel current transform
• CTRL(+SHIFT)+Z: Undo(Redo)
• H: Toggle Help panel
• ESC: Exit

Rotate XY

Rotate points container to align AB and BC lines between chosen 3 points and world Y and X axes.

• LMB(+drag): Set 3 points
• F: Rotate
• C: Toggle Use Corner
• D: Toggle using depth buffer for point selection
• RMB: Cancel current transform
• CTRL(+SHIFT)+Z: Undo(Redo)
• H: Toggle Help panel
• ESC: Exit

Align Z

Rotate points container to align tow selected points with world Z axis.

• LMB(+drag): Set 2 points
• F: Align
• C: Toggle Use First
• D: Toggle using depth buffer for point selection
• RMB: Cancel current transform
• CTRL(+SHIFT)+Z: Undo(Redo)
• H: Toggle Help panel
• ESC: Exit

Scale

Scale points container to make length between two selected points equal chosen value.

• LMB(+drag): Set points
• F: Scale
• C: Toggle Use Center
• D: Toggle using depth buffer for point selection
• RMB: Cancel current transform
• CTRL(+SHIFT)+Z: Undo(Redo)
• H: Toggle Help panel
• ESC: Exit

Cleanup

Box Select

Select points using box selection.

• LMB+drag: Draw selection
• SHIFT+LMB+drag: Add to selection
• CTRL+LMB+drag: Subtract from selection
• A: (De)Select all
• RMB: Deselect all
• I: Invert selection
• X: Remove selected
• H: Toggle Help panel
• ESC: Exit

Lasso Select

Select points using lasso selection.

• LMB+drag: Draw selection
• SHIFT+LMB+drag: Add to selection
• CTRL+LMB+drag: Subtract from selection
• A: (De)Select all
• RMB: Deselect all
• I: Invert selection
• X: Remove selected
• H: Toggle Help panel
• ESC: Exit

Circle Select

Select points using circle selection.

• LMB+drag: Draw selection
• SHIFT+LMB+drag: Add to selection
• CTRL+LMB+drag: Subtract from selection
• [ and ]: Adjust radius
• A: (De)Select all
• RMB: Deselect all
• I: Invert selection
• X: Remove selected points
• H: Toggle Help panel
• ESC: Exit

Gradient Select

Select points using gradient selection.

• LMB+drag: Draw selection
• SHIFT+LMB+drag: Add to selection
• CTRL+LMB+drag: Subtract from selection
• C: toggle constrain to vertical and horizontal axes
• A: (De)Select all
• RMB: Deselect all
• I: Invert selection
• X: Remove selected points
• H: Toggle Help panel
• ESC: Exit

Retopology

Polygon

Draw polygons while snapping vertices on points or existing vertices in target mesh.

• LMB: Place (on points) / Select (vertex in mesh)
• LMB+drag: Continuous place (on points) / Select more (vertices in mesh)
• CTRL+LMB+drag: Tweak placed point (while snapping on points and vertices) / Tweak mesh vertex (while snapping on points and vertices)
• D: Toggle using depth buffer for point selection
• B: Toggle Ignore Backfacing (for mesh vertices selection)
• M: Toggle Merge Mesh Vertices (disabled if selection exists)
• RMB: Cancel current polygon / Cancel tweak if active
• F: Make polygon from placed and/or selected / Make quad from single selected mesh vertex in corner and mouse location
• X: Delete selected mesh vertices
• TAB: Toggle Mesh Edit mode
• CTRL(+SHIFT)+Z: Undo(Redo) mesh edits only (Toggle Mesh Edit mode resets history)
• CTRL+S: Save the current Blender file
• H: Toggle Help panel
• ESC: Exit

Trace

Trace floor plan while snapping vertices on points and keeping the same height

• LMB(+drag): Place vertex',
• CTRL+LMB: Tweak vertex with snapping',
• CTRL+SHIFT+LMB: Tweak vertex without snapping',
• F: Make line/polygon',
• E: Toggle Fill',
• C: Toggle Cyclic',
• A: Toggle Auto Commit',
• RMB: Cancel current line',
• D: Toggle using depth buffer for point selection',
• TAB: Toggle Mesh Edit mode',
• CTRL(+SHIFT)+Z: Undo(Redo) (Mesh Edit mode resets history)',
• CTRL+S: Save the current Blender file',
• H: Toggle Help panel',
• ESC: Exit',

Plane

Make quad plane rotated to fit selected points.

• LMB(+drag): Select points
• CTRL+LMB(+drag): Deselect points
• CTRL+SHIFT+LMB(+drag): Rotate plane
• RMB: Cancel current plane
• F: Make plane
• N: Make plane as new mesh object
• D: Toggle using depth buffer for point selection
• TAB: Toggle Mesh Edit mode
• CTRL(+SHIFT)+Z: Undo(Redo) (Mesh Edit mode resets history)
• CTRL+S: Save the current Blender file
• H: Toggle Help panel
• ESC: Exit

Cube

Draw Cube alias Rectangular Cuboid snapped to points by setting three initial corners and arbitrary height.

• 3x LMB(+drag): Place Cube Corners (drag moves last placed)
• After 3rd corner, set cube height
• 4th LMB: Make cube
• CTRL+LMB: Tweak last cube vertices freely
• CTRL+SHIFT+LMB: Tweak last cube vertices and snap to points
• RMB: Cancel current cube
• D: Toggle using depth buffer for point selection
• TAB: Toggle Mesh Edit mode
• CTRL(+SHIFT)+Z: Undo(Redo) (Mesh Edit mode resets history)
• CTRL+S: Save the current Blender file
• H: Toggle Help panel
• ESC: Exit

Filter

Points

Simplify

Remove Duplicates

Poisson Disk Elimination

Voxel Downsample

Crop

Boolean

Outlier Removal

Hidden Point Removal

Project

Split

Split By Scalar Value

Point Set Registration

Join

Apply Shader Effects

Transfer Data

Add Noise

Histogram 3D

DBSCAN Clustering

Normals

Estimate Normals

Smooth Normals

Add Normals

Colors

Remove Color

Color Adjustment

Clip Colors

Add Colors

Add Alphas

Add Colors From Spherical Harmonics

Transfer Colors

Project Image From Camera

Scalars

Remove Value

Blur Scalar

Posterize Scalar

Convert Scalar

Distance To Mesh

Colorize Scalar

Scalar From Mesh Vertex Group

Scalars From Mesh UV Map

Density

Curvature

Add Scalar

Mesh

Surface Reconstruction

Screened Poisson

Find Contours

Render

Output

Images are rendered in Properties > Output Properties > Format Resolution X,Y and % dimensions and saved as set in Properties > Output Properties > Output (image file formats only) at path at the same panel. If Save As Render is enabled, Properties > Output Properties > Output > Color Management is used. Rendered images are directly saved to output directory, they are not opened in image editor area as regular Blender renders, unless Create Image Datablock is enabled, then will render to image datablock (single render, animation is always saved to disk), consecutive renders will create new image datablock each, images have to be saved manualy or packed to blend file.

Performance

Cache Buffers speeds up animation rendering by creating buffers once and reusing for the rest of frames. Works only on static point data (no sequences) and Display properties cannot be animated, Depth Sorting and HPR cannot be used. Only container transformation can be animated.

Anti-aliasing

For anti-aliased images, use Supersampling 2 or larger. At value 2 renders image at 200% size (3 at 300% etc.) and then downsamples to output resolution. This is limited by maximal gpu image (texture) resolution so be careful with value, use the smallest acceptable, usually at 2, amount of anti-aliasing is sufficient.

Look

• If you render points with alpha per point and Alpha shader, or if you use other Global Alpha then 1.0, for best result enable Depth Sort Points Each Frame for correct alpha blending. On the other hand, rendering will be slower because sorting is performed in python and not in gpu.
• Hidden Point Removal runs Hidden Point Removal filter on points on each frame using render camera location.
• Postprocess applies postprocesing on renders as in viewport, but adjust setting first for rendering in Render panel. Because of different resolution, result may look different then in viewport.

Other Notes

• Mask Pass and Depth Pass saves separate files with mask and depth buffer.
• If you start Blender from command line you can observe animation rendering progress in terminal.
• If you want to render points with Blender render engine (Cycles, Eevee or any other), points need to be converted to regular Blender object, see Convert section.

Convert

Conversion Blender object/data type is set at panel top with Target enum.

Preset menu in panel header will save all panel settings into a preset.

Mesh

Volume

3D Gaussian Splatting

Pointcloud

Generate

Generation source Blender object/data type is set at panel top with Source enum.

Preset menu in panel header will save all panel settings into a preset.

Remove Generated operator will remove generated points and Move Points operator will move generated points from source object to a new Empty object.

Colors

Generation methods that use single object as source can generate point colors from various source found on mesh set with Colors enum.

• Constant Color - Use constant color value
• Color Attribute - Use active color attribute
• UV Texture - Generate colors from active image texture node in active material using active UV layout
• Vertex Group Monochromatic - Use active vertex group, result will be shades of grey
• Vertex Group Colorized - Use active vertex group, result will be colored from red (1.0) to blue (0.0) like in weight paint viewport

Other methods that use whole scene use rendered image that is rendered automatically in background. Generation from rendered image uses image itself.

Mesh Vertices

Mesh Surface > Random

Mesh Surface > Poisson

Mesh Surface > Project

Mesh Volume

Native Point Cloud

Geometry Nodes Vertices

Scene > Lidar Simulation

Scene > Project

Render

Export

File type is set at panel top with Type enum.

Preset menu in panel header will save all panel settings into a preset.

PLY

LAS/LAZ

E57

PTS

Sequence

Batch Filter

Batch Operations

Batch Convert

Batch Generate

Batch Export

Preferences

Tab Name

• Tab Name - if Point Cloud Visualizer is too long for your tabs, you can change to shorter PCV.
• Custom Tab Name - if set to existing tan name, PCV panel is moved there.

GPU Memory To Max. Points Calculator

Calculate theoretical maximum of displayable points for given gpu memory, floored to nearest tens of millions. Result is valid only when Default shader is used and nothing else displayed, i.e. location and color per point only. See Large Datasets for more info.

Libraries

• Check Environment - Helper operator that checks for legacy PCV libraries that must be uninstalled
• Resolve Library Conflicts Using Python Subprocess - If library conflict is detected, execute operation in separate python subprocess, operation will take more time because input/output data will be written/read to/from disk in temporary directory bpy.app.tempdir

Defaults when using "PCV > Load" operator

Default options for load operator: 3d Viewport sidebar > PCV tab and click Choose File .

Defaults when using "Add > Point Cloud Visualizer" helper operator

Default options for helper operator (adds empty object to scene and loads points for each selected file): 3D Viewport > Add > Point Cloud Visualizer Shift+A

Fast Navigation

Draw low resolution point cloud during viewport navigation. See Fast Navigation for more info.

• Delay - Delay drawing of high resolution point cloud to viewport after navigation ended
• Percentage - Low resolution point cloud percentage, used until point count exceeds Maximum
• Maximum (Millions) - Low resolution point cloud maximum number of points, used when point count exceeds Percentage
• Auto Exclude (Millions) - Skip Fast Navigation if instance point count is lower, set to zero to disable and use on all instances, will not apply on points if low resolution is already generated in current session, reload files to update

Viewport

• Fancy Selection Shader - Use nicer shader for selected points, uses more gpu memory - disable if that is an issue
• X-Ray Draw On Top - Draw points on top of everything else while 3D Viewport X-Ray is enabled
• Solid Alpha - Adjust alpha of X-Ray points at Solid shading
• Wireframe Alpha - Adjust alpha of X-Ray points at Wireframe shading

Tools

• Show Help Panel At Tool Start - Disable to hide help panel for each tool.
• Show Tools Color Theme - Edit color theme of Tools to fit your Blender theme.

Packer

Store loaded points as hidden mesh datablock with attributes in blend file. Automatically restore and draw points from datablock at blend file load, save points to datablock on blend file save.

This operation is meant to be fully automatic (if Auto Pack and Auto Optimize options in preferences are enabled, they are by default) once loaded point data are marked for packing clicking Pack icon next to file path on main PCV panel (this will work for any file formats, even those loaded using Import panel).

If Packer is enabled, main operators (Draw, Erase, Reload etc.) will prioritize packed data (if available) over loading from ply file.

Packer adds utility operators to 3D Viewport Panel as well as list of packed datablocks in blend file. See Packer for more info.

• Auto Pack: pack all points that are loaded and/or displayed when blend file is being saved
• Auto Optimize: remove packed datablocks on blend file save if container object is not found in scene

Utilities

• Reset PCV On Active Object - Reset all PCV properties stored on active object
• Reset PCV Preferences - Reset all PCV Preferences

Experimental > Patch 'pye57' library

Patch pye57 reader class at runtime to read files with scans without translation and rotation elements in its header.

Helps when reading e57 file ends in error E57 element path well formed but not defined (E57_ERROR_PATH_UNDEFINED) and in console with lines similar to this:

  File "/Users/redacted/.local/lib/python3.10/site-packages/pye57/e57.py", line 214, in read_scan
    xyz = self.to_global(xyz, header.rotation, header.translation)
  File "/Users/redacted/.local/lib/python3.10/site-packages/pye57/scan_header.py", line 32, in rotation
    q = Quaternion([e.value() for e in self.node["pose"]["rotation"]])
pye57.libe57.E57Exception: E57 element path well formed but not defined (E57_ERROR_PATH_UNDEFINED)

Installation

Installation is the same as Standard edition only download latest point_cloud_visualizer-pro-*version*-*platform*-*architecture*.zip (note the pro in zip name).

Platform compatibility and Blender compatibility is also the same and included libraries as well.

Upgrade

Please don't try and install both Standard and Pro editions at the same time. Pro edition include full Standard edition anyway, so you only need to install Pro distribution zip to have both.

If you are upgrading from Standard to Pro, it is the same procedure as updating, i.e. uninstall previous, restart Blender, install new, this time latest version of point_cloud_visualizer-pro-*version*-*platform*-*architecture*.zip (note the pro in zip name).

PCV Pro: Tiles mode

Dataset on video above:

• Over one billion five hundred million points, precisely 1 505 076 907 points in 395 LAZ files
• Tile dimensions 1000x1250m, average number of points per tile 4.4 million, total size on disk 4.55 GB
• Blender 4.5 running on Mac mini Apple M4 Pro 64gb
• Tileset fully loaded with default settings except Optimize Data enabled to remove colors and scalars that are all zeros to save memory and LOD distance set slightly shorter than default
• Default Display settings, only Height shader is used (dataset has no colors) and Shade enabled
• Video is screen capture in real time

Overview

Prerequisites and Preparation

First you need a dataset that is split to individual files in a single directory. If your dataset is one single big file, you need to split it first with PCV (Tiles mode) → Tools → Split - add an empty object to scene, then go to 3d Viewport sidebar N, go to Point Cloud Visualizer tab, on top switch Mode to Tiles, Tools panel becomes accessible. See Split for more details how to use Split tools. By default the empty object will become container for Tiles instance after splitting.

If dataset is already split to multiple files you can use it as it is, or split it even further to smaller parts if overall performance is not smooth enough. Large tiles in terms of total number of points in file are slower to work with. By large is meant ~20 million points and more per file. In this case same splitting tools can be used and run in batch on whole directory of files, see Batch Split for details.

General Use

Add an Empty type object to scene (or use any other Blender object type that exists in scene), then go to 3d Viewport sidebar N, go to Point Cloud Visualizer tab, on top switch Mode to Tiles and click Select Directory , file browser will open, navigate to directory with tiles (dataset split to a grid of LAS/LAZ/E57 files) and click Select Directory button. Directory contents will be read, correct file types selected and list of tiles will be populated. Then click Draw button.

Add Menu Helper Operator

Main Panel and Tile List

Pointer Select

Box Select

Tile List Menu

TileSet

TileSet → Optimize Data

TileSet → States

TileSet → Advanced

TileSet Type: Sequential

• Load Queue - Controls how many tiles at most are loaded at the same time, if set to zero, all tiles are loaded without a break, but interface will be locked until everything is loaded

TileSet Type: Parallel

• CPU Count - Controls how many CPU cores are utilized during loading, leave at zero for maxmimum, set to lower value to leave some cores for other tasks (not exactly per core). If set to higher value than system offers, maximum is used
• Load Everything On Draw - Load all enabled tiles even those not in view, disabled when Unload Hidden is enabled

TileSet Type: Threaded

• Use Multithreading - Start multiple background threads to load files concurrently, disable to use one background thread to load one file at a time. While you will get tiles loaded faster, Blender interface will be less responsive because more work need to be done in Main thread where Blender runs (e.g. passing data to gpu). It has positive effect only when individual tiles have mostly higher point count, 500k and more. Please note, this is not multithreading as in multiprocessing, multiple threads are started, but python is processing only one thread at a time, some operations will happen concurrently, like disk I/O, but point processing will not. Some deeper changes need to be made to Blender first to support multiprocessing so even data can be processed in parallel.
• Threads - How many threads will be running when Multithreading is enabled, value 0 will use number of logical CPUs

TileSet Type: Any

Custom Shift/Scale lets you set specific values for shift and scale, Reset will remove custom values and will use automatic. If this is used, loaded tileset will be reloaded.

LOD Level Percentages lets you change distribution of points in levels for current LOD Levels number.

• - Set linear distribution
• - Set cubic distribution
• - Set exponential distribution
• - Validate percentages, i.e. make sure they are sorted in correct order, this can shuffle your values
• - Reset to default (cubic)

Preview Count - Force number of points for preview level, lowest LOD level if LOD is enabled, or for preview data

GPU Queue - Because "uploading" of data to GPU can happen only in Blender main thread, to minimize locking of interface, only a portion of tiles are "uploaded" at a time, this controls how many tiles are "uploaded" at once

Preferences

To open Tiles preferences, go to main Blender menu → Edit → Preferences.., choose Add-ons section from left, find Point Cloud Visualizer, expand with and scroll down to Tiles section

Engine

• Budget (GB) - Total budget for all tile sets in scene in GB of gpu memory, different shaders has different requirements for point data that need to be uploaded in gpu memory, thus memory is used instead of point counts. Set it at least 25% less then available on gpu hardware to leave space for other processes, on macOS arm64 architecture with unified memory set it to 25% or less of total ram. Please note, memory is not checked from hardware, but estimated from data sent to gpu
• View Refresh - Tile visibility check rate
• Continuous Checking - Check for tile visibility only when idle (i.e. not navigating) (default, disabled state) or check continuously on every viewport change (enabled state). While continuous check will start tile loading earlier, it may also start tiles that will not be needed in the end and once file loading starts, it must complete, loading cannot be stopped from outside. Also enabling this is not recommended if Fast Navigation is disabled or Sequential or Parallel TileSet type is used
• Use Fast Navigation - Draw preview level resolution while navigating viewport, if disabled, current view is drawn while navigating, will refresh when you stop navigating
• Navigation Delay - Delay drawing of high resolution point cloud to viewport after navigation ended
• Use Unload Timeout - Unload tile point data when tile is not visible (will have effect only if TileSet > Unload Hidden is enabled) after timeout has passed or if timeout is disabled, unload will happen immediately. This affects only automatic processes based on viewport, disabling or hiding tile has immediate effect
• Unload Timeout - Unload timeout
• Unload On Hide - Unload tiles if container object is hidden from viewport (will have effect only if TileSet > Unload Hidden is enabled)
• Monitor System Memory - Monitor system memory while loading new data, pause loading when limit is reached to prevent freeze or crash
• Memory Limit - When memory is filled over limit, loading of new tiles will pause. Checks system total memory, not only portion used by tiles data
• Show Statistics - Show statistics for all tile sets in viewport lower left corner

Memory Limit

Add Helper Defaults

Lets you set defaults for Add Helper Operator, so each time it is run, these will be already set without doing anything

Tiles Theme

Here you can change colors and sizes of ui elements to fit your interface theme

Stats

Statistics for all tile sets in scene in viewport lower left corner. Shows how much of Budget and GPU memory (this is only a estimate based on what Tiles sends there) is used for current view, system memory usage, number of points displayed/loaded/total, tiles loaded/total and length of load queue and gpu queue.

Tips

3D Viewport performance tips

• make sure total point count is somewhere between 5-10 million points per file (this is just an estimate, maybe more or less on your system), if not, split further with Split tools using Batch Split to process all files in directory
• you can manually adjust TileSet → LOD Distance to be shorter, so only closest tiles are drawn with higher LOD level, with that you can disable to prevent it being changed back to automatic if Frame TileSet is used
• disable tiles you don't need to see in tiles list and use States to quickly change between stored states of tiles list
• let all tiles preload to system memory at start and have Unload Hidden disabled, so files are not loaded while navigating viewport, please note that by default files will be loaded until total system memory is 80% full (can be changed in preferences), then loading will pause
• use Optimize Data to limit amount of data loaded, if dataset has colors but they are all zeros, disable colors, if dataset has scalars, but you don't need them, disable all, or keep select scalar fields you need, these options can have huge impact on system memory usage and overall performance
• have and use only one 3D Viewport, while it is possible to use multiple viewports and tiles LOD levels are calculated for all viewports merged, it will lead to more points being displayed then for just one and will slow down overall performance

Other tips

• add Pointer select and Box select operators to Quick Favourites Q menu, right click button and choose Add to Quick Favourites to have quick access to tile selecting tools, both can also enable/disable tiles with a key shortcut while they are running, it is faster than using TileSet menu
• automatic scalar range is set when first tile data is available, it may not be the same in all tiles, best to use selection and fit to selection if dataset is merged from various sources and range differs from tile to tile or fit to all loaded with when more tiles finished loading

Troubleshooting

Notes on "Threaded" TileSet type

If you experience rare random Blender crash while using TileSet → Type: Threaded, it may be caused by another installed and enabled addon that is using gpu module and custom shaders (i.e. addon that draws on screen anything with custom shaders or use shaders for gpu accelerated computing) and it does not clear GPUShader objects from memory properly once finished with them. This happens only if custom shaders are used, builtin shaders that comes with Blender, which are used the most by addon developers, are not affected by this since they are never cleared from memory.

Because Threaded Tiles are using threads to do memory heavy processing, Python may decide to run garbage collecting (clearing out no longer used objects from memory) while running other thread than main thread and when that happens, such shader object is cleared when Blender does not expect that and because shader object is not Python only object but interface to Blender internals, Blender will crash. In that case, disable all addons you don't absolutely need for work. If you want to report that to me, please include list of enabled addons.

PCV itself is immune to this, all its custom shaders are cleared immediately after no longer in use in main thread. TileSet → Type: Sequential is not using threads at all and Parallel is using them in Blender supported way, will not cause any problems of this sort.

Similar kind of a problem may also be with other parts of Blender Python API that are closer to Blender internals, but I don't know about that yet. If you encounter something like this, please let me know here, Message Creator button.

Notes on "E57" files

Some software writes E57 files incorrectly without bounding box (min/max positions) and/or scan pose (translation/rotation) in file header.

If you use E57 files and during loading engine alerts you with E57 element path well formed but not defined (E57_ERROR_PATH_UNDEFINED) library errors, you can try first enable Patch 'pye57' library from PCV preferences, that will fix missing pose information.

Missing bounding box is not yet handled (it would require reading full file and compute min and max instead of just values in header) and your only options are:

• Use LAS/LAZ files exported from source software or somehow force it to write full header info
• Open and save E57 files in software that will write correct header info, e.g. CloudCompare
• Use Tools → Split with settings All At Once, Cuboid, set cuboid dimensions much larger than source file is so file is not split, output format E57 (or LAS/LAZ while at it) and ignore tool warnings that file has not been split

Display

Points

Colors

Colors panel contains settings related to point color or color generation, its content changes according to selected shader.

Colors Shader

Height Shader

Scalar Shader

Shade

Clip

Clip Plane Gizmo

Clip Box Gizmo

Options

Tools

Place 3D Cursor

Measure

Measure Tools

All tools define vertices by selecting points on screen and all have similar controls. Tools have its own undo/redo system that will work only while tool is running, only adding new measurement is written to Blender history.

• LMB - create new vertex on point under mouse cursor, until you release mouse button, vertex can be repositioned
• RMB - move existing under mouse cursor
• CTRL+LMB and CTRL+RMB - will stop snapping to points
• X - remove vertex under mouse cursor if exists
• CTRL+X - will remove all current tool vertices (those not yet stored)
• N - create new "element", in case of Distance, Angle and Area tools, next click will start new line or polygon
• F - frame last "element"
• SPACE - store measurement in list and reset tool
• CTRL(+SHIFT)+Z - undo (redo)
• ESC - exit tool

Distance and Angle tools have one more shortcut:

• C - to toggle cyclic, close line into a loop

Point

Define vertices with XYZ values.

Height

Define vertices with Z value.

Distance

Define line between multiple vertices with total length and lengths for each segment.

Angle

Define line between multiple vertices with angle between each 2 segments.

Area

Define triangulated ngon between multiple vertices with total area of triangles.

Intersect

Convert

Split

Example of split using Chunked Read by Dimensions, Cuboid Size: overall dimensions / 10, result is 95 files each at max 1800x1000m

Example of split using All At Once by Point Count, Count: 3 (×10⁶ = 3 000 000), result is 56 files each with max 3m points, most of the time number of points is slightly less to keep subdivision grid

All At Once

Chunked Read

Batch Split

Advanced

Debug Mode

Is enabled when Blender is started from command line with --debug-value 18077 argument or you can set this at runtime by searching for Debug Menu and setting value 18077 in popup menu.

If Debug Mode is enabled, PCV will log more info to a console (terminal window, not Blender Info panel). In some cases even operation progress. PCV panels will also get several extra buttons to force shader rebuilding, debug options, some more panels with runtime info etc.

API

A few utility functions are re-exported at PCV module level to aid with general script or addon development. If there is problem with function input, error will be logged to console, but all exceptions will be handled to not interrupt main script from running.

Becase of Blender Extension system, importing PCV in user code is:

import bl_ext.user_default.point_cloud_visualizer as pcv

user_default being repository directory name where PCV is installed, user_default is Blender default.

draw(data=None, *, name=None, matrix=None, is_debug=False, )

• Draw data with pcv
  • data: dict with vs, ns, cs and scalars keys (all optional except vs) with numpy arrays as values, all of them must have the same length, shapes of arrays must be: vs and ns (n, 3), cs (n, 4) or (n, 3) and scalars must be a structured array (n, ). if None is passed instead of a dict, empty arrays will be used, nothing will be drawn, but pcv will be initialized
  • name: string, assumes object is in scene, if not raises error, if None is passed, pcv_debug object will be created if needed and drawing mode is set to debug (is_debug=True) (i.e. bigger points, drawn on top, normals visible if exists, fast nav disabled..)
  • matrix: if not None, target object will get assigned this matrix to matrix_world, if not instance of Matrix, it will be converted (if possible, if not, will be ignored)
  • is_debug: if True, some for-better-visibility properties will be adjusted, see source for details, also set to True when no object name is passed (and pcv_debug is used instead)

draw_file(filepath, *, name=None, matrix=None, is_debug=False, )

• Draw point cloud file with pcv
  • filepath: string, absolute path to PLY, LAS, LAZ, E57 or PCD file
  • name: string, assumes object is in scene, if not raises error, if None is passed, pcv_debug object will be created if needed and drawing mode is set to debug (is_debug=True) (i.e. bigger points, drawn on top, normals visible if exists, fast nav disabled..)
  • matrix: if not None, target object will get assigned this matrix to matrix_world, if not instance of Matrix, it will be converted (if possible, if not, will be ignored)
  • is_debug: if True, some for-better-visibility properties will be adjusted, see source for details, also set to True when no object name is passed (and pcv_debug is used instead)

properties(*, name=None, )

• Get property group with pcv properties
  • it is the same as bpy.context.scene.objects[name].point_cloud_visualizer
  • name: string, assumes object is in scene, if not raises error. if None is passed, pcv_debug name will be used

erase(*, name=None, )

• Stop drawing and unload data
  • if name is None, pcv_debug name will be used, if such object is found and is EMPTY type, will be removed
  • name: string, assumes object is in scene, if not raises error. if None is passed, pcv_debug name will be used

Basic Example

import numpy as np
import bl_ext.user_default.point_cloud_visualizer as pcv
# will create `pcv_debug` empty object in scene, to use existing object pass `name="OBJECT_NAME"`
pcv.draw(data={
    'vs': np.array([(0, 0, 0), (0.1, 0, 0), (0.2, 0, 0)], dtype=np.float32, ),
}, )

Full Example

import bpy
import numpy as np
import bl_ext.user_default.point_cloud_visualizer as pcv
from mathutils import Matrix
# add an empty object
o = bpy.data.objects.new("points", None)
bpy.context.view_layer.active_layer_collection.collection.objects.link(o)
# craft some object level transformation
m = Matrix.LocRotScale((0.1, 0.2, 0.3), Matrix.Rotation(np.pi / 4, 3, 'X'), (1, 1, 1))
# scalars got to be a structured array with named fields
sc = np.empty(3, dtype=[('intensity', np.float32, ), ])
sc['intensity'] = np.linspace(0, 1.0, 3)
pcv.draw(name='points', data={
    'vs': np.array([(0, 0, 0), (0.1, 0, 0), (0.2, 0, 0)], dtype=np.float32, ),
    'ns': np.array([(-1, 0, 0), (0, 1, 0), (0, 0, 1)], dtype=np.float32, ),
    'cs': np.array([(1, 0, 0, 1), (0, 1, 0, 1), (0, 0, 1, 1)], dtype=np.float32, ),
    'scalars': sc,
}, matrix=m, is_debug=True, )

Context Manager

Context manager for running PCV operators from custom scripts

Will make sure that name object exists, has loaded points in cache and drawn on screen (if not, tries to load linked file if possible), object is selected and active and operators are called with proper context.temp_override (i.e. 3d viewport exists, if not it will swap area, this is especially important when running render operator). On exit it will restore selection and original area (if has been swapped before).

Example (assuming there is an object named points in scene with linked file and (maybe) loaded points):

import bpy
import bl_ext.user_default.point_cloud_visualizer as pcv
with pcv.common.PCVOperatorContextManager('points'):
    bpy.ops.point_cloud_visualizer.render()

FAQ

PCV License

PCV is released under GNU General Public License, version 2 or later. See LICENSE text file in extension zip for full text.

PCV Updates

PCV updates are released on Superhive (Blender Market) for everybody who bought PCV in past since first release of version 1.0 in 2020. Also archive of all past versions is available for download if need to be.

So far I have no plans to change that.

PCV Support

I provide support for everybody who bought PCV on Superhive (Blender Market). To contact me, go to Superhive, log in to your account, go to PCV store page and click Message Creator button.

Platform Compatibility

• Windows (x64), Linux (x64) and macOS (arm64 & x64)
• macOS x64 (Intel Architecture) version is provided, but not tested

Blender Compatibility

As a general rule, using latest Blender LTS release is the best, at the time of writing it is Blender 4.5 LTS, latest LTS is used for development and will be the most tested Blender version

• Blender 4.2.6 LTS or later
• Blender 4.3 may not work because issue with installation that has been fixed after its release
• Blender 4.4 or later will be compatible, up to Blender 5.0
• for Blender 5.1 use distribution zip with -blender-5.1 suffix and see notes on Blender 5.1 bellow

Notes on Blender 5.0

• PCV is fully compatible on macOS with Metal gpu backend and on Windows/Linux with OpenGL gpu backend
• on Windows/Linux with Vulkan gpu backend, there is minor issue that has been fixed in Blender 5.1 (it is not clear if fix will be backported to Blender 4.5 LTS), this issue affects viewport postprocessing, Tiles shading and modal tools that depends on point selecting, if you switch gpu backend to OpenGL and restart Blender, all will be working as intended. Blender 5.1 works fine with Vulkan backend.

Notes on Blender 5.1

• Blender 5.1 comes with major changes relevant to extensions, Python version went from 3.11 to 3.13 and Numpy from 1.x to 2.x and all libraries that use compiled code need to be budled for new Python and all of them need to support new Numpy
• At the moment, only Open3D is not yet officially released for Python 3.13 and it is not bundled in PCV so features that depends on Open3D will not work
• To install PCV in Blender 5.1, you need to download and install distribution zip for Blender 5.1 (-blender-5.1 suffix), regular distribution zip will refuse to install

Notes on Blender 5.2

• When Blender 5.2 LTS will be released, PCV for macOS x64 (Intel Architecture) will no longer be updated and will be available only as legacy version for Blender 4.5 LTS

Are all filters and tools from Standard edition available also in Pro Tiles mode?

No. Tiles mode has its own set of tools. More will come in future updates.

I got warning icons and Missing vertex normals, Missing vertex colors and Missing scalars messages in Display panel

Loaded data does not have normals, colors or scalar fields so affected shading options cannot work properly, missing values are substitued by default normal or colors (exact values are in PCV > Load > General).

My LAS/LAZ file is all black even though i know it has colors

Some software may save colors incorrectly as 8bit values per channel (0-255) in 16bit fields (0-65535). LAS specification uses only 16bit colors and 8bit values are very close to zero when interpreted as 16bit, so colors look almost black in viewport. To fix, go PCV > Load > Reader Options, check Force 8-bit Colors and click Reload in PCV > Load panel. File will be reloaded and colors interpreted as 8bit. This will only happen when all color channels values on all points are between 0 and 255 which indicates incorrectly saved LAS/LAZ.

Points are missing when blend file is saved and reopened?

• PCV does not store loaded points in blend file because there is no suitable data type available. only PCV settings and path to data file is stored. when blend file is reopened, points need to loaded or imported from linked file again by clicking Draw button.
• If you are working with multiple PLY clouds at once, you can use PCV 3d viewport panel (viewport header top right corner: cloud icon) to Draw all PCV instances in scene at once.
• Any changes to points made with PCV have to be saved using Export panel to PLY before quiting Blender or loading blend file otherwise will be lost.
• Other option is to use Pack option that will automatically convert points to hidden mesh datablock on blend file save and restore on blend file load, but since blender uses only single precision floating point numbers for vertex positions, geolocated point data will lost its precision and cannot be moved exactly back. If you don't need to export points back to "world" locations (i.e. LAS/LAZ or E57 files) you can ignore this limitation.

How to render points in Cycles or Eeveee (with colors)?

• Points need to be converted to Blender native data type that can be rendered in engine. Conversion target is mesh vertices with Geometry Nodes to turn them to instances or points, see PCV > Convert panel.
• Converting points will create suitable color data and adds basic material using it so colors are preserved and available for render engine.
• Mesh instances can be rendered in Cycles and Eevee, points are supported only by Cycles, Eevee converts them internally to mesh before rendering so it can be slow.

Large Datasets

• currently, PCV needs to load all points from source file and keep them in system memory
• during loading, system memory usage will peak quite high, 4 (and more in some cases) times the runtime usage
• for display, PCV need to upload all points that are going to be displayed (you can control amount with PCV > Display > Percentage slider) to gpu memory
• to determine approximate maximum number of points your gpu can display at once you can use calculator in PCV preferences (for example 8GB gpu can display ~300M points with default shader and disabled scalars), calculator formula is simple:

ram = 8192  # MB
b = (1024*1024) * ram  # bytes
# default shader uses 3x float32 for point location and 4x float32 for color (rgba)
# float32 takes 4 bytes, hence 3*4 + 4*4 bytes
n = int(b / (12 + 16))
print(n)  # 306783378

• trying to display more points (i.e. uploading more data than gpu memory can contain) will result in Blender crash or freeze
• when extremely big data need to be loaded and is not required to work with exactly all points, alternative loading methods Every Nth or Slice can be used to reduce number of points during loading

Is there a trial version?

No, sorry. it is not possible.

I got an error..

Please let me know "Ask a Question" sidebar button.

Ideal for any bug report would be starting Blender from command line and repeating error situation. Then copy messages from console window, add steps to reproduce it. If it is related to loading a point cloud file include it in report if it is possible.

I'd like to have X feature implemented..

Please let me know "Ask a Question" sidebar button. I am always open to suggestions.

Change Log

3.7.0

• Standard ability to read individual scans from E57 files, thus product of Expand option in Add operator can be reloaded on Blender restart. In order for it to work properly, empties that contain individual scans should not be transformed (they are created with transformation locked), only main, parent, empty object should be transformed.
• Standard E57 scan index can be also set manually in Load > Reader Options panel, but file is not checked in advance for contents, so if scan at index does not exist, you'll get error message.
• Standard fixed pointcloud to volume conversion.
• Pro new Tools > Intersect, gpu accelerated intersection between collection of mesh objects (or to mesh convertible objects) and points in tiles, individual meshes are turned to convex hulls for intersection detection, but each object is tested individually so overall geometry can contain concave shapes. Can be run on current scene state or on animation, then each frame is evaluated and masks are merged. Result is presented in form of point selection (so also new point selection framework for future tooling is now implemented).
• Standard and Pro known issue in Blender 4.5 (possibly earlier as well) to 5.0, Windows and Linux, Vulkan GPU backend, Pro Tiles > Display > Shade does not show shading and Standard 3D Viewport Menu > Postprocess causes all points to disappear, reported, fixed in 5.1 https://projects.blender.org/blender/blender/issues/154184, so far it is unclear if fix will be included in next 4.5 LTS. OpenGL GPU backend is not affected, to fix, switch to OpenGL in Blender > Preferences > System. Blender 5.1 works fine with Vulkan backend.
• Blender 5.1 compatibility: Python version has been updated to 3.13 from 3.11, this requires all new wheels for all libraries, at the moment, all are available except Open3D, hence multiple release zips.

Blender 5.1 PCV variant is without Open3D and following features (all from Standard variant/mode, Pro does not use Open3D for anything) will not work, operators should complain about Open3D not being installed if executed (if not, it is a bug).

3.6.0

• Standard and Pro new Clip Plane and Clip Box gizmos
• Standard and Pro new Clip Planes States UI inside Display > Clip
• removed Tools > Clip Planes (functionality replaced by gizmos)
• Standard new Smooth Normals operator, interpolate existing normals with neighbours within distance and max count
• Pro fixed Tools > Split UI bug that prevented running split e57 to las/laz

3.5.0

• Pro new tileset type Parallel. Tiles are loaded and processed in parallel. UI will not be responsive until loading is fully finished. Fastest, but non-interactive
  • 1.5gp (that's "gigapoint") dataset: Sequential 2:27, Parallel 0:49, (Threaded 1:12)
• Pro Default tileset type renamed to Sequential
• pcv debug mode now requires specific debug value to be set so it does not interfere with blender builtin values

3.4.0

• new PCV Pro with Tiles mode
• new option Luma in Filter > Scalars > Add Scalar

3.3.2

• matcaps - blender 5.0 ships with matcaps as multilayer exr files. there is no reliable python api to load all/specific layers from such exr files as pixel arrays, so rather then remove feature, copy exr files from older blender system directory e.g. 4.5/datafiles/studiolights/matcap/*.exr to user directory 5.0/scripts/presets/point_cloud_visualizer/matcaps/*.exr (more info about blender directory layout) and then they will show in matcap menu as before. if target directory is empty, one matcap (CC0 / public domain as per info here) is bundled in pcv, so menu is not empty and warning is displayed
• more small blender 5.0 fixes here and there
• increased display > points > adaptive point size maximum, handy with very large datasets with relatively sparse points

3.3.1

• fix Trace tool vertex reposition without snapping if points container is transformed

3.3.0

• new Retopology > Trace tool for tracing flooplans, use clip planes to clip points vertically to narrow outline, then you can create lines or polygons with Trace tool while snapping to points (or move freely if points are missing), by default points will be in fixed height along global z axis set by first added point or existing in linked work mesh, lines can be cyclic or open, cyclic can be filled. Until line/polygon is commited, its points can be moved around (with or without snapping to points), once commited, can't be edited, but key shortcut to jump into mesh edit mode exists to enable editing of commited lines.
• new e57 Expand option for Add operator, makes empty for each individual scan in e57 with its associated points (currently, you cannot save that back to e57, and unless you save each scan individually to a file, you won't be able to load points back on Blender restart)
• Blender 4.5 compatibility, initial Blender 5.0 compatibility. but use in 5.0 at your own risk
• convert to native pointcloud object in Blender 4.5 and later (finally python api call is available in Blender release builds)

3.2.2

• LAS/LAZ: Force 8-bit Colors option to load correct colors from LAS/LAZ files that has been saved incorrectly with 8bit values in 16bit fields. Without this enabled, points would appear almost black on screen. Available in Add and Load operators and in Load > Reader Options panel. It is aplied only if enabled and all rgb color fields are uint16 dtype and have all values less or equal 255.

3.2.1

• shader workaround for blender 4.4 and later https://projects.blender.org/blender/blender/issues/138928

3.2.0

• new filter > mesh > Find Contours: Rasterize points along world Z direction, render to a texture using Point Size and Resolution, optionally Interpolate missing pixel values, compute Contours from pixel depth data in Range and Levels and add them as mesh object. So for example, If you need contour at every 10cm in point cloud 1-2m section that has 3m total height from world origin, set Range [1.0, 2.0]m and Levels 11 (1m/0.1m + 1) (+1 to have 10 sections between 11 contours)
• if viewport shading is solid or wireframe and X-Ray is enabled, override drawing for points to be on top with 0.5 alpha to mimic blender viewport drawing. this behavior can be turned off, or alpha can be adjusted in pcv preferences, Viewport section. setting alpha to 1.0 will look like in blender < 4.3, there was a change in blender overlay engine in 4.4, hence this setting
• fix: Render error when supersampling is used together with adaptive point size

3.1.2

• Convert > Gaussian Splatting: added support for Spherical Harmonics levels less than 3, so levels 0, 1, 2 and 3 can be now successfully converted
• fix Convert operator nodetree set boolean error in blender 4.4

3.1.1

• drag and drop for add pcv helper operator, only .ply, .las, .laz, .e57 and .pcd files, ascii types are not supported for drag and drop

3.1.0

• extension, required blender >= 4.2.6
• all libraries bundled, distribution split to platforms (while i provide mac intel package, i cannot test it, my intel mac is too old to run blender 4.0+), libraries wheels (except pye57 for mac intel, that one is built by me, because official is not available) are downloaded from PyPI (except pymeshlab until blender is fixed, see known issues)
• updated libraries to latest (almost)
• added automatic system for handling open3d conflicts on windows, data is saved to disk, separate python process is launched and results are collected back to blender, slower to run, but prevents freezes and crashes, no need to save e57 and laz files to ply and restarting blender anymore
• removed pymeshlab based e57 reader, pye57 is now officially available for mac arm64 and it is now the only way to read e57 files on all platforms
• removed laszip (no mac arm64 wheel, conflict with open3d on windows, laspy prefers lazrs anyway), lazrs is now they only way to read laz files
• fast navigation is now enabled by default, can be disabled in add helper defaults or globally
• both open3d and pymeshlab surface reconstruction freeze on arm64, automatic workaround is available, it is only a bit slower to execute
• removed experimental viewer
• becase of extension system, importing pcv in user code is now: import bl_ext.user_default.point_cloud_visualizer as pcv, user_default being repository directory name where pcv is installed
• updated deprecated nodes in all geometry nodetrees
• fixed filter select points by color not using delta value properly

3.0.2

• various small fixes

3.0.1

• fix: tool help panel visibility is now persistent whole blender session. if you don't need it, H to toggle it off and it will stay off when next tool is run

3.0.0.17 (alpha)

• docs: https://jakubuhlik.com/docs/pcv/
• new: Transfer Data filter - Transfer data from active to (single) selected PCV instance (object) by proximity, there is no interpolation, value is taken from closest point in active instance
• fix: auto radius in scipy based hidden point removal

3.0.0.16 (alpha)

• new Hidden Point Removal alternative implementation using SciPy (instead of Open3D) as filter operator and render function
• faster voxelize option in filter > simplify > type: voxel grid, will sort points to 3d grid and then throw away all, but one point from each cell
• slightly easier on eyes default colors in Height shader
• optional libraries - updated support for their latest versions (that also means Blender 3.6 LTS is minimum now)
  • Open3D 0.18.0 (so it available for python 3.11 that is shipped with blender 4.1+)
  • lazrs 0.6.0
  • pye57 0.4.5
  • PyMeshLab 2023.12.post1 (e57 reader is not backward compatible)
  • to update library, click Install NAME button in pcv preferences, then restart blender

3.0.0.15 (alpha)

• new: Project Image From Camera filter - Create points colors from projected image through camera (only Perspective and Orthographic types are supported), selected image is cloned and resized to render resolution before projection
• new: four color schemes for scalar fields, Viridis is now default
  • http://bids.github.io/colormap/
  • https://github.com/BIDS/colormap/blob/master/colormaps.py
  • original color schemes are released under a CC0 "no rights reserved" license
• new: Custom Colors scheme for scalar fields
  • ui for list of colors, shader will interpolate color between them according to scalar value
  • add template as steps between two colors operator
  • custom colors list is included in Display preset and another preset saving menu is added to Scalar Field subpanel for scalar field display options only
  • cistom colors will also synchronize with Synchronize Shader Properties operator in 3D Viewport Panel
• new: Posterize scalar
  • Display > Scalar Field - in shader posterization, only on screen
  • Filter > Scalars > Posterize Scalar - as a filter that add a new posterized uint8 scalar field
  • if settings are the same, both produce identical result, so shader can be used as preview for filter
• fix: if Add menu operator is used with Sync Shift/Scale option enabled or Sync Shift/Scale operator (PCV > Load > General) is run after on pcv instances, results are now stored as Custom Shift/Scale, that means shift/scale values are stored in container properties and saved to blend. so, on blend file reload (and/or point cloud source reload) custom shift/scale is used and points will appear where they were before and not reset to their individual centers like it was before (and you don't have to run sync again)..

3.0.0.14 (alpha)

• new: Tools > Clip Planes: manipulate clip planes visually with gizmos, store/restore clip planes states (states are saved to blend file and can be restored without tool running)
• new: all Tools now on RMB cancel current action in progress (3d cursor and all selection tools were changed)
• gpu: reduced number of uniform buffers (was running out of available slots (ubuntu + nvidia driver))
• fix: Render operator error on windows platform when Hidden Point Removal option was enabled

3.0.0.13 (alpha)

• updated laspy to latest version (click install button in preferences to update)
• added button in preferences to install lazrs - laz file laspy backend, faster and available also for arm macs
  • if both laszip and lazrs backends are installed, laspy will prefer lazrs, otherwise will use which one is available
• new api for drawing from python
• some small changes and optimizations to internal data storage

3.0.0.12 (alpha)

• new Fast Navigation - Draw low resolution point cloud during viewport navigation
  • to be enabled in pcv preferences, it is off by default for now
  • during viewport navigation, normals and bounding box drawing is skipped, there rest of shading options is kept, selection is always drawn in full
  • a few other options in preferences
    • Delay set to what is comfortable, too short might interfere with overall smoothness of navigation
    • Auto Exclude point clouds with less than set points will not use it
    • Percentage and Maximum controls how large is subset of points, set percentage of points is taken, if it is larger then maximum, maximum is used. please keep it low..
    • each PCV instance can be excluded by unchecking PCV > Display > Options > Use Fast Navigation
  • some implementation notes: Blender API has no way to tell if user is navigating viewport (well, at least without using modal operator and that is not applicable in this case) so solution involves timers and because of that, when you are still navigating, but pause any movement a bit, high resolution will be drawn after delay and also first redraw when you just started navigating might lag a bit, API does not provide mouse events so i cannot react before view is really changed
• new Convert to 3D Gaussian Splatting
  • converts result PLY files from 3D Gaussian Splatting for Real-Time Radiance Field Rendering to something Blender renderable, keep in mind that this training software has its own terms of use. License of the original paper implementation says the official training software for the 3D Gaussian Splatting may be used "non-commercially", i.e., for research and/or evaluation purposes only. Commercial usage requires getting license from INRIA. PCV only reads user supplied 3D Gaussian Splatting PLY files and interpret their data in Blender context. You need to consider how did you get your 3D Gaussian Splatting PLY files.
  • please, take it as a very experimental feature, more like exploring what blender can do or not
  • spherical harmonics formulas used in material nodetree are taken from https://github.com/aras-p/UnityGaussianSplatting/blob/main/package/Shaders/GaussianSplatting.hlsl#L134
  • there are 4 approaches so far: points, octagons, spheres and sphere instances with volume. each have some advantages and each has problems, none is ideal
    • "Point" - Point primitive, splat rotation and scale does not apply
    • "Octagon"- Flat polygon primitive, lighter meshes, texture gradient falloff, lack of third dimension makes result look too sparse, by default has doubled size to counter that
    • "Sphere" - UV sphere primitive, better shape representation, bad gradient falloff due to available surface material possibilities
    • "Volumetric Sphere" - Instanced UV sphere primitive, volumetric material, very slow to render, volume density does not translate that well
  • increasing Properties > Render Properties > Light Paths > Transparent will get rid of weird opaque patches in render
• new Add Colors From Spherical Harmonics in Filter > Colors - Colorize points from 'f_dc_0', 'f_dc_1', 'f_dc_2' and 'opacity' fields that are present in 3D Gaussian Splatting PLY files
  • if you plan to export back to gaussian splatting ply file, you can remove colors in Data panel before exporting. regular gaussian splatting ply files does not contain colors, so they should be ignored even they are there, but that might depend on specific viewer implementation, to be safe, remove them. also exported file will be smaller..
• fix Generate (from Mesh Surface and Mesh Volume sources) colors being black in Blender versions >= 3.5

3.0.0.11 (alpha)

• new Histogram 3D filter
• new Display > Effects
  • Displace - move points along their normals
  • Noise - add "random" noise to positions
• new Apply Shader Effects filter to apply shader effects directly to point data (note: Noise will produce different result then on screen because of random numbers generation, it will look the same in large scale, but individual points will be on different places)
• new option Apply Shader Effects to Sequence > Batch Filter
• refactored Project filter
  • faster: projecting 1.8m points on mesh with 25k faces, color from uv 8k image, smooth normals, discard enabled, old: 5m 22s, refactored: 1m 26s, accelerated: 24s
  • new Use Open3D option to do ray casting with Open3D (faster, no loops) instead of blender BVHTree (slower, no dependencies - is builtin)
  • new option to use closest point on mesh instead of ray casting, does not require normals on points
  • fix of previous fix of color management with uv images
  • fix of getting color attributes
  • fix of getting uv coordinates due to api change (somewhere between blender 3.4 and 3.6)
• Filter panel sorted to categories Points, Colors, Normals, Scalars and Mesh, general rule is: filters removing something are on top, then modifying and lastly adding filters, order from most used to less (well, based on me..)
• Transfer Colors filter, when existing and saved image is used, margin obtained with cycles baking will use saved image pixels instead of just generated (may be a blender bug) so it is no longer possible to select existing image from list, but it is forced to create a new image via button similar to blender new image, new blank images are not affected by this so margin will be created from generated pixels as it should be
• ASCII Preset Builder control number of lines (1-32, default is still 10) shown in preview
• Batch Filter menu sorted to categories mirroring Filter subpanels
• fix Transfer Colors filter color management with float images
• fix Convert and Generate to always use appended copy of material and node tree (was a bug, not feature)
• fix Blur Scalar error when neighbours=1

3.0.0.10 (alpha)

• Tools > Lasso Select and Tools > Circle Select, significantly better performance, drawn area size has no longer impact on performance, only number of points under selection and not that much, from my tests, large selection (relatively large drawn area (~500x500px@72), a lot of points under area (~1m)) from ~1m50s to ~1s, so more than 100x faster. please note, tool is caching points projected to 2d screen space (old versions did the same too), that cache is invalidated when view is moved. so first use of tool is slightly slower then subsequent if view is not moved because points got to be projected to 2d, mentioned test times are including cache creation, point selecting algo is much faster.
• new "Undo/Redo" (a bit exaggerated) system, mainly meant for filters, but working also with tools etc, everything that change loaded point data directly. Store state of point data with a button, then Restore if you want to go back to that stored state at any time, only one state is stored, it is cleared when new point cloud file is loaded, current unloaded, container object is deleted and renamed, when new blend file is loaded or when Clear button is pressed. a bit crude system, but better than nothing.
• new "Fancy" selection shader, looks better, takes more gpu memory (needs points colors), in case memory is a problem, uncheck Fancy Selection Shader in preferences to use old shader
• new Clone Selected operator in Cleanup Tools to copy selected points to a new pcv instance (for example clone can be transformed and joined back)
• new Blur Scalar filter, averages scalar values in radius (better) or by n nearest neighbours (faster)
• new Scalars From Mesh UV filter, adds 2 scalars (u, v) computed from target mesh by proximity (needed that for some custom processing, maybe someone will find that useful as well)
• new Convert Scalar filter, lets you remap values and convert data type of scalar field
• new Standard PTS option for Load and Add operators, will use special PTS reader that expect standard fields format and order (x, y, z, intensity, red, green, blue), this is format used during PTS exporting from pcv. also available as defaults option in pcv preferences, if enabled it will be used for files with .pts extension, if disabled, pts file will be processed with generic ascii reader and requires saved preset (as it was until now)
• new Screened Poisson Surface Reconstruction filter, depends on PyMeshLab, can also transfer point colors and all scalars (as floats, no type checking, also requires scipy installed) to result mesh
• Join filter, new Keep Transformation option to copy transformation from active pcv instance
• support for sequences of other file formats - las, laz, e57, pts (standard flavour, see Standard PTS load option), all formats that can be exported can be loaded back as sequence, both Preloaded and On The Fly sequence types are supported
• Sequence > Batch Export can now export any file format selected in Export panel
• new Sequence > Batch Operations > Batch Apply Transformation to apply container transformation on all sequence frames (export sequence to keep changes)
• fix tool widgets drawing in other viewports then initial
• fix retopology tools save function when blend file has not been saved yet and has no filepath
• KNOWN ISSUE: another incompatibility found: Open3D and laszip, only on Windows. loading LAZ file and then using Open3D filter leads to instant crash (also true when laszip is just installed and LAS file is loaded). workaround is the same as with Open3D and pye57, load LAS/LAZ, export as PLY, restart blender, load PLY and continue with Open3D filter (or pack points and save blend, exporting to PLY can keep shift/scale, packing to blend will remove it). unless library is fixed in future i see no other way around it. the crash is so hard it leaves no log, no message, no clue..
  • this is main cause of new pcv preferences option: Prevent Library Conflicts, it is visible on all platforms, but ONLY on Windows it actually does something (at the time of writing). it is making sure that blender does not crash, for example by preventing you running filter (with message popup) that is using Open3D after conflicting file reading library has been used to load points. turn off to disable checks if you are feeling lucky..

3.0.0.9 (alpha)

• updated compatibility of optional libraries to latest versions (run Install X operators from pcv preferences again to update)
• blender requirement is 3.6 now (because of numpy version required by Open3D, the rest of pcv is stil compatible with 3.4)
• set custom or modify current shift/scale, useful when you need to load separate files that should match. you can also sync shift/scale, but setting values directly allow more control
• disabled auto shuffling, loading is now ~40% faster, added Shuffle Points button next to Display > Percentage slider, added Shuffle option to Convert if Subset of points is requested
• removed Merge With Other PLY filter, use Join filter to merge point clouds from any source files together
• float colors are not clipped (to 0.0-1.0 range) anywhere unless exported to file format that does not support them. colors over 1.0 is very rare scenario, regular scanned data should be in 0.0-1.0 range, but since pcv can generate colors also from exr images, might be useful to leave unclipped values. when points converted to mesh should emit light for example
• new filter Clip Colors, clips color values to 0.0-1.0. that's all it does. just in case unclipped colors are not desirable and float color export is still needed
• new filter Scalar From Mesh Vertex Group, create scalar field from mesh vertex group by point proximity
• new Clone Unclipped Points operator in Display > Clip, copy visible - unclipped points to a new PCV instance
• Project filter, added Smooth Normals option to interpolate smooth normals from projected face vertex normals
• added new filters to Sequence > Batch Filter
• Reset PCV moved from Load to Preferences as Reset PCV On Active Object, also added Reset PCV Preferences button
• fixed color management in Project filter when color is taken from uv image source

3.0.0.8 (alpha)

• redesigned data runtime storage
  • keep double precision positions (if possible, depends on source file format)
  • takes much less system ram when colors/normals are not available in source file (down to 1/3 in best case)
  • system ram does not peak that much during loading (1/3 of total is saved compared to previous version in some scenarios)
  • slightly better performance when creating from raw loaded points (in exchange with slightly slower gpu batches creating when doubles are stored)
  • shift/scale to fit single precision for display is fully automatic and reversible if source file contains positions as double precision floats (if file contains only single precision, it will be executed as well and positions will be converted to doubles, although precision is already lost when source file was created)
  • some operations can remove shift/scale, operator should warn about that, if not it is a bug
  • some filters, especially those which use blender data to set positions may remove double precision positions (this will be addressed)
  • if Packer is used, precision is lost, because blender stores mesh vertices positions in floats, if high precision is required, do not use Packer, always export point cloud file if points are modified. Packer is just workflow convenience if precision higher than 32 floats provide is not needed and it is not required to export points exactly at original locations as in initial file
• export LAS/LAZ (depends on laspy/laszip), las version 1.2, point format 3 and extra dimensions (optional normals and other scalars (other than standard fields) https://laspy.readthedocs.io/en/latest/intro.html#point-records), it is always a new file, original header data (if source is LAS/LAZ) is not copied (as for now)
• export E57 (depends on pye57), only positions, intensity (if exists) and colors (pye57 does not support normals), it is always a new file, original header data (if source is E57) is not copied (as for now)
• E57 and LAS/LAZ are exported unshifted/unscaled because file format allows it, PLY and PTS, unshift/unscale is optional
• export PTS changed floating point numbers handling, if point data has shift/scale and it is requested to be unapplied, 16 decimal places for doubles will be used, else 6 for regular floats
• export PLY
  • ascii PLY uses 16 decimal places for doubles and 6 for floats (applies for point positions, normals, colors and scalars as well)
  • added option for colors data type, now can export uint8 (that is usual format, it is default), uint16 and float32, colors are always in srgb, float32 colors are unclipped, if float32 colors are used, there is also option to convert them to linear color space
• load LAS/LAZ detect normals in file, if there are 3 scalar fields (x, y, z) named in one of these conventions ('nx', 'NormalX', 'normal_x', 'normalx', 'normal x'), those fields will be used together as point normals (and removed from scalars). this is optional, can be set in preferences for add and load operators and can be changed on object as well in Load > Reader Options
• DBSCAN Clustering filter (depends on open3d), result goes to new integer scalar field, can be later split with another filter
• Outlier Removal filter (depends on open3d), select and remove points that are most likely noise or artifacts
• Split Points By Scalar Value filter, integer scalars only, splits points per unique value in scalar (useful after dbscan clustering or E57 import with scan indices to scalar field and files with classification)
• optional render to new image datablock instead of saving directly to disk (single render only, animation is always saved)
• fixed inaccuracy in 16 bit per channel colors handling during loading
• several convert and generate corner cases fixes, fixed color management with generate scene: lidar simulation and scene: project
• load e57 via pye57 library can be monkey patched to read weird files with scans without translation and rotation elements defined in header. option is available in pcv preferences under Experimental Features, library is modified at runtime, its files are not modified. it helps when reading e57 file ends in error E57 element path well formed but not defined (E57_ERROR_PATH_UNDEFINED) and in console with lines like this:

  File "/Users/redacted/.local/lib/python3.10/site-packages/pye57/e57.py", line 214, in read_scan
    xyz = self.to_global(xyz, header.rotation, header.translation)
  File "/Users/redacted/.local/lib/python3.10/site-packages/pye57/scan_header.py", line 32, in rotation
    q = Quaternion([e.value() for e in self.node["pose"]["rotation"]])
pye57.libe57.E57Exception: E57 element path well formed but not defined (E57_ERROR_PATH_UNDEFINED)

3.0.0.7 (alpha)

• fix of Convert fix from previous version
• Packer uses same logic, points are stored in mesh chunks with max 2 ** 26 vertices

3.0.0.6 (alpha)

• new Density filter: make scalar from volume density (in sphere radius around each point), surface (projected to 2d along world z in circle radius) and neighbours (distance to closest neighbour point)
• Convert to mesh/pointcloud operators will detect when more than 2 ** 26 (~67m) points is being converted and will split result meshes, each to fit in 2 ** 26 vertices (https://projects.blender.org/blender/blender/issues/110334)
• disable Display panel ui when no points are loaded

3.0.0.5 (alpha)

• e57 optional scan indices as scalar fields
• e57 optional scan poses as transformed empties parented to container object, available only in Add Helper: Shift+A > PCV
• filter Remove Value can also use integer values
• filter Remove Value no longer requires displayed scalar to edit, uses selection in Data panel
• Generate > Scene > Project can use perspective camera view (in addition to viewport perspective view)
• Generate > Scene better random noise in Project and Lidar Simulation, scaled with distance from “sensor”, creates scalars with xyz offsets and factor
• some blender 4.0 compatibility fixes, but using blender 4.0 is not recommended, don’t know what will break next…
• fix the “if file is missing at absolute path, then same filename is loaded if exists next to blend” when path is windows style, but current platform is posix (blend file has been moved between platforms)

PCV 3.0 (alpha)

• Blender 3.4 and later
• right now available as alpha release

Core

• Metal gpu backend support
• one main shader, recompiled on the fly (instead of single use shaders)
• many shading options can be mixed together (opacity, blending modes)
• several performance improvements, data batches are recreated (and uploaded to gpu) only when needed
• all custom shaders (main shaders, internal utility shaders, tools shaders, render shaders, …) has been updated to be cross compilation ready (OpenGL, Metal and upcoming Vulkan backends)

Data

• new Data panel with overview what has been loaded from file
• filters or other operators that expect scalar field to be selected now will use Data > Scalar Fields list (with some exceptions that require displayed scalar, like remove value filter)
• if linked file is not found, try to recover by loading file with same filename next to blend if exists, path will be updated if blend is saved

File I/O

• any supported format can now be selected as main file, import panel has been removed
• file loading options can be set at file select dialog
• import ascii files has been replaced with ASCII Preset Builder
• new export option: PTS

Packer

• formerly experimental Packer is enabled by default
• loaded point data have to marked for packing (shield icon next to file path on main panel, like with other blender datablocks), the rest is automatic, driven by blend file save and load events
• Packer operators and packed data overview is in 3d viewport popup menu

Filter

• filters working with meshes has been updated to not use any deprecated mesh properties
• new Distance To Mesh to scalar field
• new Reduce method to Simplify filter, remove points so their count is exactly given number
• new Add Noise filter (uses either random sampling in sphere volume to add to current positions, or mathutils.noise.turbulence_vector (quite slow), for more advanced uses, convert data to mesh > point and modify positions with geometry nodes, better performance, undo, etc.)
• removed Discard filters, they are substituted by Data panel, any data except positions can be removed there

Render

• animation buffers caching to speed up rendering (depends, but by a lot in some cases), cannot be used with sequences and in some other cases, see checkbox tooltip

Convert

• complete rewrite (also because of deprecated mesh properties)
• to Mesh - uses geometry nodes to instance mesh primitives or points, geometry nodes modifier is preserved to allow changes after conversion
• to Volume - creates vdb file that is reloaded back to blender
• to Pointcloud - pointcloud object in blender alpha builds
• removed Particles and Instancer types

Generate

• complete rewrite (also because of deprecated mesh properties)
• uses Geometry Nodes as backend where applicable for much better performance
• new Scene > Lidar Simulation generate type, project in spherical coords around origin, colorize with Cycles equirectangular render
• new Scene > Project generate type, project from camera to scene, colorize with Cycles render using same camera
• new Render generate type, generate from multilayer exr, camera and position or depth pass
• active image node, material, uv etc is no longer needed, related datablocks are selected in ui by names
• removed Particles source

Sequence

• new Batch Generate uses options in Generate panel
• Batch Export uses options in Export panel (including PTS export)

Postprocess

• output directly to image datablock for quick renders from viewport view

UI

• many areas reworked to fit new features
• presets for select panels in header
• Preferences - loading defaults for main file select operator

2.2.1

• pcv preferences > install libraries > Check operator to list which library is installed and usable (importable)
• display warning if using Metal gpu backend in blender >= 3.5

2.2.0

Tools

• new ui, sorted to subpanels, options shown when tool is running
• new gpu accelerated Place 3D Cursor tool
• new tools for container transformation:
  • Translate: move container so selected point is at given location
  • Rotate XY: rotate container so 3 selected points at right angle to each otehr are aligned with x and y axes
  • Align Z: shortest rotation around selected point with second point they are aligned with z axis
  • Scale: select two points and scale container so distance between those two points matches given length
• new Gradient Select tool
• new tools for retopology:
  • Polygon: select points or vertices, make polygons from them, tweak while snapping to points, and much more…
  • Plane: select points, single quad plane is fitted between them, scaled to cover points, can be rotated before adding to mesh
  • Cube: quickly draw cuboids by selecting 3 points and cuboid height

Display

• new Cull and Billboard Cull shaders, omit drawing of ‘backfacing’ points (requires correct normals on points to work)

Filters

• new option in Simplify filter: Voxel Grid v2 - faster, more options (also available in Sequence > Batch Filter)

Add Menu Helper

• added support for all readable file formats. defaults can be set in preferences and overrided when helper is being run (ascii file types need format preset saved in advance) and mixed file types can be added at once.
• removed File > Import menu item

Other

• need for Prevent Floating Point Precision Errors enabled is automaticly detected by default, user is notified when this happen (there is option in preferences to disable it)
• fixed detection of shift in negative direction when Prevent Floating Point Precision Errors is used

2.1.0

• filter: Hidden Point Removal (using Open3D), view dependent points removal
• render: Hidden Point Removal option, filter will be run on each frame on points that are send to render
• Height Shader: added global axes and fit to range options

2.0.3

• fix open3d version requirement on other platforms than mac (required open3d 0.16.1 is available only for mac, while other platforms latest version is 0.16.0, haven’t noticed it…)

2.0.2

• fixed error in blender 3.4 on activation, one operator name was too long for blender taste

2.0.1

• new join sequences operator
• sequences can be loaded with gaps in frames, or with gaps merged. default is merge
• fixed playback when multiple sequences are loaded, there was 1 frame offset on second sequence, 2 frames on third and so on
• fixed error in batch filter > simplify
• fixed obscure context errors in batch filter when filter operator poll() fails

2.0.0

• Open3D 0.16.0 support (including python 3.10, so blender 3.1+ is supported)
• renamed addon directory to point_cloud_visualizer, does not matter much for normal use, only if you happen to use pcv in scripts, now it got to be imported with import point_cloud_visualizer as pcv for example
• updated laspy support to latest version

1.999.15

• preferences > calculator: calculate approx. number of points that can fit into given gpu memory while using default shader without scalars
• generate > mesh surface > project from view: basically you can simulate how real scanning is done. it can be run multiple times and new points are appended to existing. you can add some jitter in pixel grid and some displacement noise to look more realistic. want to blend generated points with real? this is tool for you
• fix render > depth and mask pass file format (was always saved as png, instead of what was set in blender properties > output)

1.999.14

• new helper operator Export, export all/selected/active pcv instances to ply files
• new export option Ignore Zero Scalars, do not export scalars that sum to zero
• new filter Poisson Disk Elimination (depends on scipy), even spaced subsampling
• fix incorrect/error default colors in some cases
• ui Convert panel
• ui pye57 is now default option for importing e57 files

1.999.13

• all colors pickers in ui are gamma corrected
• fixed index error (when exact emitter face cannot be found, nearest will be used), color interpolation (was not working properly) and emitter transformation in generate from particle system
• fixed linear to srgb conversion colors in generate from geometry nodes vertices (most of colors in blender are in linear color space, pcv uses gamma corrected as they are in ply, las, etc. files)
• fixed missing alpha blending when selection is displayed
• fixed container transformation in Split Selected operator in Remove Color, Remove Value filters and Tools
• fixed Transfer Colors ui

1.999.12

• generate points from geometry nodes vertices and attributes
• filter > Remove Value and edit > Select Value (both for scalars) can now select single value instead of range only (input value is converted to scalar data type before selecting, e.g. if scalar is unsigned int then ui input float value is converted positive integer, so input 1.789 will select 1 in integer scalar)
• filter > Project new parameter Strength, at 1.0 points land on surface, at 0.5 they will move half way and so on
• filter > Simplify new method option Slice, it does the same as Display > Percentage, but it applies to points directly
• fixed unresponsive blender ui after render is finished on windows ( @Aepi9 )
• removed export > visible only, because of confusion, use filter > simplify > slice to get the same result

1.999.11

• new Convert option: Mesh To Points, creates vertex mesh with attributes from points, adds geometry nodes that converts vertices to points and assigns colors to points and adds material, with this you get cycles point cloud rendering without need for blender alpha build (works in blender 3.1+)
• Start Frame setting for ply sequences
• Split Selected operator for Remove Color and Remove Value filters and selection Tools
• updated optional packages to latest versions (except open3d which is not yet available for python 3.10 included in blender 3.1+), to update package, click its install button from preferences
• fixed scalar soft light blend mode formula
• fixed some primitive drawing types deprecation in blender 3.2
• fixed viewport name label depth in some situations
• fixed point selection drawing in some situations
• fixed center viewport camera view on points operator in some situations and renamed to Frame Points
• fixed sequence playback not restarting after end of sequence is reached while Cycle Forever is turned off

1.999.10

• fixed ply export
• fixed project filter (https://developer.blender.org/T97025)

1.999.9

• new Add Colors and Add Normals filters to create Colors and Normals from scalar values
• new Invert Selection operator in Tools
• new Save As Render option to use view transformation as set in Color Management properties
• render operator is now using properties from: Output Properties > Format, Output Properties > Output and Render Properties > Color Management instead its own, more standard path handling, save any still image format, all color and color depth options, color management looks, etc…
• pye57 support for reading multi scan e57 files
• compatibility with pymeshlab 2022.2.post2
• fixed pip installing latest package instead of specific version
• fixed clip planes in Color Adjustment shader

1.999.8

• All new Tools panel
  • Place 3D Cursor
  • Box Select
  • Lasso Select
  • Circle Select
• X-Ray Shader

1.999.7

• Blending modes for scalars (Normal, Multiply, Screen, Overlay, Soft Light)
• Color adjustment (Exposure, Gamma, Brightness, Contrast) per channel in shader and filter
• Discard filters (Discard Normals/Colors/Scalars)
• Generate from native pointcloud object (Blender 3.1 Alpha or Blender 3.2 Alpha, i.e. build with pointcloud object enabled)
• Viewport postprocessing
• LAZ import: https://github.com/tmontaigu/laszip-python 3
• Alternative E57 reader: https://github.com/davidcaron/pye57 6
• Reading all points from E57 multi scan file when using PyMeshLab for import
• Better ui for packages installation in preferences
• Removed Extras panel and moved contents to filters
• Plugin icon in ui marks functionality depending on 3rd party package

1.999.6

• optional installs (open3d, laspy, etc) are now installed into user python site-packages on all platforms, windows and linux users no longer need to use blender portable/zip distribution
• added sequence batch filter, convert and export to ply. sequence have to be preloaded (not loaded on-the-fly). batch filter and convert uses settings as set in filter/convert panels, batch export uses its own settings in batch export panel. so, for example, if you want apply Remove Duplicates to sequence go Filter > Remove Duplicates, set desired distance, go Sequence > Batch Filter choose Remove Duplicates from list and click Batch Filter. if you start blender from command line, each sequence frame is printed so you can observe some progress

1.999.5

• convert to blender native point cloud object (blender 3.1) - can be rendered in cycles as spheres: https://developer.blender.org/D9887 12
• buttons to uninstall optional libraries

1.999.4

• install Open3d button enabled, Open3d 0.14.1 is already available on PyPI for python 3.9 shipped with blender 3.0
• added “Remove Duplicates” filter for removing points from too dense areas or for very fast subsampling (uses SciPy, need to be installed from preferences, or it comes with Open3d)
• added reload upon export option, so exported points can be reloaded from exported file after export
• added convert to geonodes, number of vertices in instance mesh is calculated from instanced mesh itself
• fixed render when some of points have in front option enabled and rendering of all points in scene is requested
• fixed animation render not updating when some of pcv properties are animated
• fixed sync display settings in 3d view menu

1.999.3

• pcd format import (ascii and binary types), my own custom implementation so i consider it experimental
• e57 format import via pymeshlab (only position, normal and color is imported), experimental as well, if you use older macos than catalina it will crash blender, linux and windows are untested yet
• load default options in preferences for helpers (File > Import > PCV and Add > PCV)
• added normals length in edit mode
• fixed transfer colors to texture exception when uv is from edge to edge
• fixed render all scene points in depth and mask passes

1.999.2

• blender 3.0+ only (bgl module is being deprecated, gpu module only is now used, so “Prepared for the future!”)
• scalar color schemes
• all new edit mode (on the inside - using mesh attributes), works with scalars, can select by scalar value, set scalar value, flip normals
• all filters preserve scalars
• new filters for working with scalars: Remove Value, Colorize, Add Scalar
• render extra mask and depth pass in separate files (there seems to be no way to make multi layer file via python)
• updated Open3D, installation right now need some extra steps, when Open3D 0.14 will be released on PyPI, i enable button in preferences for easy installing

1.999.1

• scalar display is now handled in shaders - faster, can be animated and rendered, added bleeding parameter to mix colors and scalar
• whole internal shader system rewritten, any shader can use clip planes and mixing with scalar
• added sequence “on the fly” frame ply loading - no need to preload all frames, reasonably fast with smaller files, works for render too
• all filters updated to work with new data system and scalars
• fix “in front” display option
• fix export ply with scalars
• and many smaller things…

1.10.0

• convert to geometry nodes with colors (blender 3.0+)
• convert to mesh divided to even chunks
• render points in 3d viewport together with other scene objects

1.9.0

• clipping planes for all shaders (viewport and render)
• auto clipping planes update, linked object can be animated (viewport and render)
• more Split filter options
• shader panel updated

1.8.0

• faster rendering
• render current or all visible point clouds
• optional shuffle when joining points
• optional basic uv layout generation for Convert (mesh based result)
• Convert to vertex mesh with pcv-normal and pcv-color attributes (to be used with Geometry Nodes)

1.7.0

• new in edit mode: Select Color and Set Color
• new filters Split and Join
• Project filter point position change is now optional
• Remove Color both by color and numbers and Color Adjustment Apply speed improvements
• fixed View Points not being correct when container is transformed

1.6.0

• point set registration with several global and local methods (using Open3D)
• normal estimation with normal orientation by direction or camera location (using Open3D)
• new Fast viewport shader
• new File > Import and 3D Viewport > Add helper menu operators
• new center view on points operator
• new edit operators: points to origin, apply transformation
• edit mode enter, update and exit significantly faster
• faster render manual depth sorting
• compatibility with Blender 2.91 viewport drawing and rendering
• compatibility with Open3D 0.10.0
• fixed edit mode ui glitches
• fixed ascii import guess separator

1.5.0

• import points from text file formats

1.4.0

• MatCap and MatCap Billboard shaders
• Fast bounding box Crop points
• Open3D: Voxel Downsample, Estimate Normals and Surface Reconstruction
• fixed render transparency (blender 2.9x)

1.3.0

• Remove Color numeric input with python expression and invert selection operator
• Convert use custom mesh as instance
• Project filter align projected point normal to target mesh surface normal
• fixed point generation on triangles with very small area when using Weighted Random In Triangle
• fixed Sequence not reseting when new blend is loaded

1.2.0

• viewport menu to batch control PCV instances
• Height Colors, Depth Effects and Alpha shaders
• load alpha, export alpha
• render with manual depth sorting
• fixed sequence animation render

1.1.0

• Transfer colors from points to mesh vertex colors or uv texture
• Voxel-like simplification method
• Generate points in mesh volume

1.0.0

• core completely rewritten
• takes less system memory
• better undo / redo handling
• partial ply loading - slice, evenly spaced or random strategies
• out of video memory crash prevention with maximum display points user setting
• more shader types and shader options (Phong, Billboard, Billboard Phong, Fresnel, Bounding Box, Position with scale and offset)
• render to image with any shader
• optional faster triangulated conversion to mesh
• many small fixes and optimizations

• 0.9.30 join filter, ui tweaks, fixes
• 0.9.29 fixes, render logging
• 0.9.28 clipping planes from object bounding box, faster all numpy export, many minor fixes
• 0.9.27 render supersampling and draw smooth circles
• 0.9.26 color adjustment fixes
• 0.9.25 color adjustment, faster boolean
• 0.9.24 project colors
• 0.9.23 fixes
• 0.9.22 extra debug shaders
• 0.9.21 preferences
• 0.9.20 ui changes, poisson disk sampling generation, size and alpha available in edit mode, various fixes, removed manual depth sorting during render
• 0.9.19 point cloud generation from vertices and particles
• 0.9.18 point cloud generation from mesh surface
• 0.9.17 fixes
• 0.9.16 boolean filters
• 0.9.15 selection preview for remove color filter
• 0.9.14 external api improvements
• 0.9.13 faster normals drawing
• 0.9.12 ply sequence, external api
• 0.9.11 merge filter
• 0.9.10 ui
• 0.9.9 point cloud global alpha
• 0.9.8 basic editing
• 0.9.7 project point cloud on mesh surface
• 0.9.6 ply exporting now uses original or viewport data
• 0.9.5 simplify and remove color filters
• 0.9.4 export ply
• 0.9.3 conversion to instancer
• 0.9.2 load ply with 16bit colors
• 0.9.1 all new render settings
• 0.9.0 conversion to particles
• 0.8.14 fixes
• 0.8.13 fixes
• 0.8.12 fixes
• 0.8.11 ui tweaks
• 0.8.10 fixes
• 0.8.9 ui tweaks, code cleanup
• 0.8.8 refactored convert to mesh
• 0.8.7 fixed vcols bug in convert
• 0.8.6 ui tweaks, a few minor optimizations
• 0.8.5 convert to mesh all or subset
• 0.8.4 preferences, ui tweaks
• 0.8.3 display normals
• 0.8.2 fixed shader unknown attribute name
• 0.8.1 fixed ply with alpha, fixed convert to mesh when normals or colors are missing
• 0.8.0 convert to mesh
• 0.7.2 ui tweaks
• 0.7.1 viewport performance fixes
• 0.7.0 ascii ply support
• 0.6.6 fixed drawing after undo/redo
• 0.6.5 point cloud illumination
• 0.6.4 refactored draw handlers, fixed occasional crash on erase
• 0.6.3 added percentage of rendered points, fixed render colors to look the same as in viewport
• 0.6.2 fixed point size display in viewport, separated view and render point size
• 0.6.1 single cloud rendering almost completely rewritten to be better and faster
• 0.6.0 single cloud rendering

• 0.5.2 refactored some logic, removed icons from buttons
• 0.5.1 load ply without vertex colors, uniform grey will be used
• 0.5.0 performance improvements using numpy for loading and processing data
• 0.4.6 fixed crash when parent object is deleted while drawing, fixed removal of loaded data when parent is deleted
• 0.4.5 added 'Display' percentage, better error handling during .ply loading
• 0.4.0 almost complete rewrite for blender 2.80, performance improvements using shaders, simplified ui

• 0.3.0 new ply loader, can be used with any binary ply file with vertex coordinates and colors
• 0.2.0 display percentage
• 0.1.0 first release