Quickstart Guide

VoxelSpace is a volumetric spatial platform that transforms massive terrain, infrastructure, and sensor datasetsinto living 4D environments. Traditional models capture only surfaces—lines, elevations, or textures. Volumetricmodeling uses
voxels-3D pixels that store data about each cubic volume. This unlocks new capabilities forsimulation, change detection, infrastructure planning, and geoscience because the entire volume becomes thedataset.

VoxelSpace Quickstart Guide

VoxelSpace is a volumetric spatial platform that transforms massive terrain, infrastructure, and sensor datasetsinto living 4D environments. Traditional models capture only surfaces—lines, elevations, or textures. Volumetricmodeling uses
voxels-3D pixels that store data about each cubic volume. This unlocks new capabilities forsimulation, change detection, infrastructure planning, and geoscience because the entire volume becomes thedataset.
VoxelSpace centralizes data in a cloud-hosted repository and offers real-time voxel-level modeling and massive-scale processing using serverless spatial functions called
spatial lambdas.

VoxelSpace Quickstart Guide

Prerequisites

Before getting started, ensure you have:

VoxelSpace Quickstart Guide

1. Sign Up & Set Up Your First Project

Follow these steps to create your first project:

1. Navigate to platform.voxelspace.com and log in with your Microsoft, Google identity or your work email.
2. On the catalog page, click New Project
3. Provide a project name and description
4. Select your time zone
5. Accept the default coordinate datums and projections:

6. Set a voxel resolution or leave the default setting
7. Submit the form

Your new project will appear in the project list.

VoxelSpace Quickstart Guide

2. Prepare and Upload Your Data

Inside your project, click Add Object → Raw Data and choose the type of dataset you want to import:

Point Cloud

 Mesh

 Block Model

 Ortho-Imagery

 After choosing the file and completing required fields, click Create. A new row appears in the project list showingthe object type, creation time, size, and status icon. Note that raw objects cannot be visualized until they areprocessed.

VoxelSpace Quickstart Guide

3. Process Data into Indexed Datasets

To make data queryable and visualizable, convert raw objects into indexed datasets or voxel grids:

Indexed Points

Converts a raw point cloud into a queryable point-cloud dataset. Select your source point cloud and click Create.

 Indexed Mesh

Similar to Indexed Points but for meshes. Select the raw mesh as source and create an indexed mesh.

Indexed Imagery

Processes ortho-imagery into an indexed raster dataset. Important: Only one processing job can run at a time onthe free tier, so subsequent jobs remain queued until the current task finishes.

Voxel Block Model

Converts block-model tables into voxel grids. You can specify:

 Launch this process only when no other job is queued.

Additional Processing Options

 Each option is tailored to specific data types. Processing tasks appear on the Pending Tasks page. In the free tier,only one task can run concurrently, so plan your workflow accordingly.

VoxelSpace Quickstart Guide

4. Visualize Your Data

Once you have indexed datasets, explore them in the interactive 3D viewer:

Creating a View

  1. Select New View from the project or choose View from an indexed object
  2. Enter a name and description for your view

Working with the View Editor

  1. Click Add Objects and select your indexed datasets
  2. Datasets appear in the left panel with icons for:Visibility (colored dot)

 Navigation and Controls

 Customizing Appearance

 Toolbar Features

VoxelSpace Quickstart Guide

5. Explore Advanced Features

VoxelSpace offers powerful capabilities beyond basic visualization:

Spatial Calculations

Run serverless spatial lambdas to:

  1. Compute volumes across datasets
  2. Filter data based on specific criteria
  3. Derive metrics across trillions of voxels

 Temporal Tracking

Add time as a dimension to your datasets to observe changes over time, including:

 Multi-Source Data Fusion

Seamlessly integrate multiple data types into a single voxel grid:

 This unified approach enables comprehensive analysis across diverse data types.

Collaboration and Integration

 Conclusion & Next Steps

This quickstart guide has walked you through the core VoxelSpace workflow:

Volumetric modeling with voxels captures the full volume of space, enabling insights that traditional surfacemodels cannot provide.

 For more advanced tutorials and documentation, visit the VoxelSpace knowledge base or contact support throughthe platform.

Spatial Lambdas

VoxelSpace's spatial lambdas are serverless functions that execute custom computations on your volumetricdata.

Spatial Lambdas

Introduction

VoxelSpace's spatial lambdas are serverless functions that execute custom computations on your volumetricdata. They run near your data on highly parallel infrastructure, allowing you to process trillions of voxels inminutes. This guide explains what spatial lambdas are, when to use them, how to write and execute them, and bestpractices for efficient processing.

Spatial Lambdas

What are Spatial Lambdas?

Spatial lambdas are stateless cloud functions written in languages such as Python or .NET. They take voxel gridsas input, perform a computation, and return a result or a modified dataset. Examples include:

Because the lambdas execute server-side, they scale to trillions of voxels through massive parallelization.

Spatial Lambdas

When to Use a Lambda

Use a spatial lambda when you need to:

Spatial Lambdas

Authoring a Lambda

Spatial lambdas are typically composed of three main components:

1. Input Definition

Specify the dataset(s) and region of interest (bounding box or selection) to process.

2. Compute Function

Write code that iterates through voxels and applies your logic. For example, summing the ore_grade property forvoxels above a grade threshold.

3. Output

Return a summary value (e.g., total_volume) or create a new dataset (e.g., filtered voxels). Lambdas can alsoattach files or emit logs during execution.

Sample Python Lambda

Here's a basic example that sums the volume of high-grade voxels:

def lambda_handler (context, voxel_reader, voxel_writer): 
  total_volume = 0.0
  for voxel in voxel_reader:
    if voxel.properties.get('grade',0.0) >= 0.5: 
      total_volume += voxel.size
  return {'total_volume': total_volume}

Code Explanation

voxel_reader: Provides voxel objects with property dictionaries and geometry

voxel.properties.get('grade', 0.0): Safely retrieves the grade property with a default valueof 0.0

voxel.size: Represents the volume of a voxel (e.g., 1 m³)

Return value: Dictionary with the computed total volume that will appear in reports

Spatial Lambdas

Running a Lambda

Follow these steps to execute a spatial lambda:

Step 1:Prepare Your Dataset

Ensure your data is processed into an indexed dataset or voxel grid. Lambdas operate on indexed datasets ratherthan raw uploads.

Step 2:Select or Upload a Lambda

Navigate to your dataset's actions menu

Choose Run Lambda

Select a pre-built lambda (e.g., volume calculation, surface extraction) OR upload your owncode file

_ _ _

 Step 3:Configure Parameters

Define the execution parameters:

Region of interest: Full dataset or specific bounding box

Property filters: Set thresholds (e.g., grade ≥ 0.5)

Output options: Specify whether to generate new datasets

User inputs: Provide any custom parameters your lambda requires

 

Step 4:Launch the Job

Start the lambda execution:

The task appears in Pending Tasks

On the free tier, only one job (processing or lambda) can run at a time

Additional jobs queue until the current job finishes

 

Step 5:Review Results

When complete, results appear in:

Reports section: Summary values and statistics

Outputs section: New datasets generated by the lambda

Spatial Lambdas

Best Practices

Performance Optimization

Limit the region: Restrict the lambda to the smallest area necessary to reduce compute costand time

Efficient algorithms: Use vectorized operations where possible for better performance

Memory management: Be mindful of memory usage when processing large datasets

 

Development Workflow

Test on a sample: Validate your code on a small subset before running it on the full dataset

Incremental development: Start with simple logic and gradually add complexity

Error handling: Include proper error handling for robust execution

 

Resource Management

Reuse templates: Start with VoxelSpace's built-in lambdas for common tasks; modify themrather than writing from scratch

Queue awareness: Plan your processing and lambda jobs to avoid long queues, especially onthe free tier where concurrency is limited

Monitor usage: Track your compute usage to stay within plan limits

 

Debugging and Validation

Use logs: Include log statements in your lambda to help diagnose issues and verifyintermediate results

Validate inputs: Check that your data has the expected properties before processing

Test edge cases: Consider what happens with empty regions, missing properties, or extremevalues

Spatial Lambdas

Advanced Lambda Example

Here's a more sophisticated lambda that performs statistical analysis:

def statistical_analysis_lambda(context, voxel_reader, voxel_writer): 
  grades = [] 
  volumes = []
  for voxel in voxel_reader: 
    grade = voxel.properties.get('grade',0.0)
    if grade > 0: # Only include non-zero grades
      grades.append(grade) 
      volumes.append(voxel.size)
  if not grades:
    return {'error':'No valid grade values found'}

  # Calculate statistics
  total_volume = sum(volumes) 
  weighted_average_grade = sum(g * v for g, v in zip(grades, volumes)) / total_volume

  return {
    'total_volume': total_volume,
    'voxel_count':len(grades),
    'average_grade':sum(grades) / len(grades),
    'weighted_average_grade': weighted_average_grade,
    'min_grade': min(grades),
    'max_grade': max(grades) 
  }

 

Spatial Lambdas

Troubleshooting Common Issues

Performance Problems

  

Data Issues

 

Runtime Errors

 

Conclusion

Spatial lambdas bring high-performance analytics directly to your data, enabling custom computations at massivescale. By understanding how to author, configure, and run these serverless functions, you can:

 

The power of spatial lambdas lies in their ability to execute near your data, eliminating the need to transfermassive datasets and enabling real-time analysis at unprecedented scales.

Next Steps

To advance your spatial lambda expertise:

  1. Explore built-in templates available in the VoxelSpace platform
  2. Experiment with different processing techniques and algorithms
  3. Study advanced examples in the developer documentation
  4. Consider upgrading your plan for increased compute resources and concurrent processing
  5. Join the VoxelSpace community to share techniques and learn from other users

For comprehensive developer documentation and advanced tutorials, consult the full manuals within VoxelSpace once you have platform access.