### Basic JSON Configuration Example

Source: https://github.com/connormanning/entwine/blob/master/doc/source/configuration.md

This JSON configuration specifies input and output paths for an Entwine build. It can be used with the `-c` command-line argument.

```json
{
    "input": "~/data/chicago.laz",
    "output": "~/entwine/chicago"
}
```

--------------------------------

### EPT Core Metadata (ept.json) Example

Source: https://github.com/connormanning/entwine/blob/master/doc/source/entwine-point-tile.md

Provides an example of the ept.json file, which contains the essential metadata for interpreting an EPT dataset. This includes spatial bounds, data type, hierarchy encoding, point count, and schema definitions.

```json
{
    "bounds": [634962.0, 848881.0, -1818.0, 639620.0, 853539.0, 2840.0],
    "boundsConforming": [635577.0, 848882.0, 406.0, 639004.0, 853538.0, 616.0],
    "dataType": "laszip",
    "hierarchyType": "json",
    "points": 10653336,
    "schema": [
        { "name": "X", "type": "signed", "size": 4, "scale": 0.01, "offset": 637291.0 },
        { "name": "Y", "type": "signed", "size": 4, "scale": 0.01, "offset": 851210.0 },
        { "name": "Z", "type": "signed", "size": 4, "scale": 0.01, "offset": 511.0 },
        { "name": "Intensity", "type": "unsigned", "size": 2 },
        { "name": "ReturnNumber", "type": "unsigned", "size": 1 },
        { "name": "NumberOfReturns", "type": "unsigned", "size": 1 },
        { "name": "ScanDirectionFlag", "type": "unsigned", "size": 1 },
        { "name": "EdgeOfFlightLine", "type": "unsigned", "size": 1 },
        { "name": "Classification", "type": "unsigned", "size": 1 },
        { "name": "ScanAngleRank", "type": "float", "size": 4 },
        { "name": "UserData", "type": "unsigned", "size": 1 },
        { "name": "PointSourceId", "type": "unsigned", "size": 2 },
        { "name": "GpsTime", "type": "float", "size": 8 },
        { "name": "Red", "type": "unsigned", "size": 2 },
        { "name": "Green", "type": "unsigned", "size": 2 },
        { "name": "Blue", "type": "unsigned", "size": 2 },
        { "name": "OriginId", "type": "unsigned", "size": 4 }
    ],
    "span" : 256,
    "srs": {
        "authority": "EPSG",
        "horizontal": "3857",
        "vertical": "5703",
        "wkt": "PROJCS[\"WGS 84 ... AUTHORITY[\"EPSG\",\"3857\"]"]"
    },
    "version" : "1.1.0"
}
```

--------------------------------

### Entwine Build Command with JSON Configuration

Source: https://github.com/connormanning/entwine/blob/master/doc/source/configuration.md

Example of invoking the Entwine build command using a configuration file.

```bash
entwine build -c config.json
```

--------------------------------

### Serve Entwine Data with HTTP Server

Source: https://github.com/connormanning/entwine/blob/master/doc/source/quickstart.rst

Installs http-server globally using npm and starts a server in the 'entwine' directory on port 8080 with CORS enabled. The --cors option is necessary for the localhost HTTP server to serve data to remote Potree/Plasio pages.

```bash
conda install nodejs -y
npm install http-server -g
http-server entwine -p 8080 --cors
```

--------------------------------

### Entwine Build Command with Direct Arguments

Source: https://github.com/connormanning/entwine/blob/master/doc/source/configuration.md

Example of invoking the Entwine build command using direct command-line arguments, equivalent to using a JSON configuration file.

```bash
entwine build -i ~/data/chicago.laz -o ~/entwine/chicago
```

--------------------------------

### Install Entwine via Conda

Source: https://context7.com/connormanning/entwine/llms.txt

Installs Entwine from the conda-forge channel into a new environment and activates it. Verifies the installation by checking the version.

```bash
conda create --yes --name entwine --channel conda-forge entwine
conda activate entwine

entwine --version
```

--------------------------------

### Building Entwine from Source

Source: https://context7.com/connormanning/entwine/llms.txt

Steps to clone the Entwine repository, configure with CMake, build, run tests, and install. Requires CMake >= 3.13, C++17 compiler, PDAL, OpenSSL, and libcurl.

```bash
# Prerequisites: CMake >= 3.13, C++17 compiler, PDAL, OpenSSL, libcurl

git clone https://github.com/connormanning/entwine.git
cd entwine
mkdir build && cd build

cmake .. \
    -DCMAKE_BUILD_TYPE=Release \
    -DWITH_TESTS=ON

cmake --build . --parallel 8

# Run unit tests
ctest --output-on-failure

# Install
cmake --install . --prefix /usr/local

```

--------------------------------

### Example Source Metadata File

Source: https://github.com/connormanning/entwine/blob/master/doc/source/entwine-point-tile.md

This JSON object represents a detailed metadata file for a specific source, referenced by metadataPath in manifest.json. It includes source properties like path, bounds, and points, along with SRS information and custom metadata.

```json
{
    "path": "autzen-high.laz",
    "bounds": [635577.0, 848882.0, 511.0, 639004.0, 853538.0, 616.0],
    "points" : 120000,
    "srs" :
    {
        "authority" : "EPSG",
        "horizontal" : "3857",
        "wkt": "PROJCS[\"WGS 84 ... AUTHORITY[\"EPSG\",\"3857\"]"]"
    },
    "metadata" : {
        "key": "value",
        "sofware_id": "PDAL",
        "version": 58,
        "something_else": -1
    },
    "schema": [] // Omitted for brevity.
}
```

--------------------------------

### Install and Activate Entwine Environment

Source: https://github.com/connormanning/entwine/blob/master/readme.md

Use Conda to create and activate a new environment with the Entwine package. This is the first step to using Entwine.

```bash
conda create --yes --name entwine --channel conda-forge entwine
conda activate entwine
```

--------------------------------

### Entwine CLI with S3 Remote Storage

Source: https://context7.com/connormanning/entwine/llms.txt

These commands illustrate using Entwine with S3 for both input and output. The first example shows basic S3 read/write with server-side encryption, while the second demonstrates using Docker with mounted AWS credentials.

```bash
entwine build \
    -i s3://my-bucket/raw-lidar/ \
    -o s3://my-bucket/ept/city \
    --threads 16 \
    --sse
```

```bash
docker run -it \
    -v ~/.aws:/root/.aws \
    -v ~/entwine:/entwine \
    connormanning/entwine build \
    -i s3://lidar-data/usa/ \
    -o /entwine/usa
```

--------------------------------

### Example manifest.json Structure

Source: https://github.com/connormanning/entwine/blob/master/doc/source/entwine-point-tile.md

This JSON structure represents the manifest file found at ept-sources/manifest.json. It contains an array of objects, each detailing an input source for the EPT dataset, including its path, bounds, insertion status, and point count.

```json
[
    {
        "path": "autzen-low.laz",
        "bounds": [635577.0, 848882.0, 406.0, 639004.0, 853538.0, 511.0],
        "inserted": true,
        "points": 6000 ,
        "metadataPath": "autzen-low.json"
    },
    {
        "path": "autzen-high.laz",
        "bounds": [635577.0, 848882.0, 511.0, 639004.0, 853538.0, 616.0],
        "inserted": true,
        "points": 4000,
        "metadataPath": "autzen-high.json"
    }
]
```

--------------------------------

### Create Entwine Conda Environment

Source: https://github.com/connormanning/entwine/blob/master/doc/source/quickstart.rst

Creates a new Conda environment named 'entwine' and installs the Entwine package from the Conda Forge catalog.

```bash
conda create -n entwine -c conda-forge entwine
```

--------------------------------

### Entwine Parallel Subset Builds

Source: https://context7.com/connormanning/entwine/llms.txt

Splits a large build into multiple independent tasks that can be run in parallel. The `of` value must be a power of 4. Examples show 4-way and 16-way parallel builds.

```bash
entwine build -i ~/data/** -o ~/entwine/subsets --subset 1 4
entwine build -i ~/data/** -o ~/entwine/subsets --subset 2 4
entwine build -i ~/data/** -o ~/entwine/subsets --subset 3 4
entwine build -i ~/data/** -o ~/entwine/subsets --subset 4 4
```

```json
{ "subset": { "id": 1, "of": 4 } }
```

```bash
entwine build -c base-config.json -o ~/entwine/subsets16 --subset 1 16
```

--------------------------------

### EPT Hierarchy with Sentinel Value

Source: https://github.com/connormanning/entwine/blob/master/doc/source/entwine-point-tile.md

This example demonstrates the use of the sentinel value -1 in the EPT hierarchy JSON. A value of -1 for a node indicates that its point count is located in a separate file within its subtree.

```json
{
    "0-0-0-0": 65341,
        "1-0-0-0": 438,
            "2-0-1-0": 322,
        "1-0-0-1": 56209,
            "2-0-1-2": 4332,
            "2-1-1-2": 20300,
            "2-1-1-3": 64020,
                "3-2-3-6": -1,
                "3-3-3-7": -1,
        "1-0-1-0": 30390,
            "2-1-2-0": 2300,
        "1-1-1-1": 2303
}
```

--------------------------------

### Entwine Merge Subset Builds

Source: https://context7.com/connormanning/entwine/llms.txt

Merges completed subset builds into a single EPT dataset. Supports forcing an overwrite and specifying the number of threads. A JSON configuration example is also provided.

```bash
entwine merge ~/entwine/subsets --threads 8
```

```bash
entwine merge ~/entwine/subsets --force --threads 8
```

```json
{
    "output": "~/entwine/subsets",
    "threads": 8
}
```

```bash
entwine merge -c merge-config.json
```

--------------------------------

### Entwine Build with Options

Source: https://context7.com/connormanning/entwine/llms.txt

Builds an EPT dataset with reprojection to Web Mercator, specifies the number of threads, and sets the output data type to laszip. Also demonstrates filtering by explicit bounds and setting a voxel span.

```bash
entwine build \
    -i ~/data/autzen.laz \
    -o ~/entwine/autzen \
    --reprojection EPSG:26915 EPSG:3857 \
    --threads 12 \
    --dataType laszip
```

```bash
entwine build \
    -i ~/data/city.laz \
    -o ~/entwine/city \
    --bounds "[634000, 848000, -100, 640000, 854000, 3000]" \
    --span 128
```

--------------------------------

### Statically Serve 3D Tiles Tileset Locally

Source: https://github.com/connormanning/entwine/blob/master/doc/source/configuration.md

Serve the generated 3D Tiles tileset locally using a simple HTTP server in Docker. This allows for local testing and viewing in Cesium.

```bash
docker run -it -v ~/entwine/cesium:/var/www -p 8080:8080 \
    connormanning/http-server
```

--------------------------------

### Configure Subset for Parallel Builds (JSON)

Source: https://github.com/connormanning/entwine/blob/master/doc/source/configuration.md

Configure subset parameters using JSON format, including the task ID and the total number of tasks.

```json
{ "subset": { "id": 1, "of": 16 } }
```

--------------------------------

### Basic Entwine CLI Commands

Source: https://context7.com/connormanning/entwine/llms.txt

These commands demonstrate basic usage of the Entwine CLI for building and gathering information about point cloud data. The 'build' command can use info output to avoid re-scanning, and the 'info' command can save a summary JSON.

```bash
entwine build -i ~/entwine/info/autzen-files/ -o ~/entwine/autzen
```

```bash
entwine info -i ~/data/** --summary ~/entwine/analysis-summary.json
```

```bash
entwine info -i ~/data/ --reprojection EPSG:26915 EPSG:3857 --threads 4
```

--------------------------------

### Serving EPT Data with HTTP Servers

Source: https://context7.com/connormanning/entwine/llms.txt

Commands to serve EPT directories using Node.js http-server or Docker. Assumes EPT data is located in ~/entwine.

```bash
# Option 1: Node.js http-server (via Conda)
conda install nodejs -y
npm install http-server -g
http-server ~/entwine -p 8080 --cors

# Option 2: Docker HTTP server
docker run -it -v ~/entwine:/var/www -p 8080:8080 connormanning/http-server
```

--------------------------------

### C++ Builder API - `builder::create` and `builder::run`

Source: https://context7.com/connormanning/entwine/llms.txt

Programmatically build EPT datasets using the C++ API. Initialize a `Builder` with `builder::create` using a JSON configuration, then execute the build process with `builder::run`.

```cpp
## C++ Builder API — `builder::create` / `builder::run`

Programmatic interface for building EPT datasets from C++. Use `builder::create` to initialize a `Builder` from a JSON config, then call `builder::run` to execute the build.

```cpp
#include <entwine/builder/builder.hpp>
#include <entwine/util/json.hpp>

using namespace entwine;

int main()
{
    // Create builder from JSON configuration
    json config = {
        { "input",   "~/data/autzen.laz" },
        { "output",  "~/entwine/autzen" },
        { "threads", 8 },
        { "dataType", "laszip" },
        { "span",    256 },
        { "reprojection", {
            { "in",  "EPSG:26915" },
            { "out", "EPSG:3857" }
        }}
    };

    try
    {
        Builder builder = builder::create(config);

        // Print metadata summary
        std::cout << "Points to index: "
                  << builder.manifest.size() << " files\n";

        // Run the indexing — returns number of points actually written
        const uint64_t pointsWritten = builder::run(builder, config);

        std::cout << "Wrote " << pointsWritten << " points.\n";
        // Output: "Wrote 10653336 points."
    }
    catch (const std::exception& e)
    {
        std::cerr << "Build failed: " << e.what() << "\n";
        return 1;
    }

    return 0;
}
```
```

--------------------------------

### Define Executable and Link Libraries

Source: https://github.com/connormanning/entwine/blob/master/app/CMakeLists.txt

Configures the main executable 'app' by specifying source files and linking necessary libraries including Entwine, PDAL, OpenSSL, and optionally cURL and Backtrace.

```cmake
set(BASE "${CMAKE_CURRENT_SOURCE_DIR}")

set(
    SOURCES
    "${BASE}/build.cpp"
    "${BASE}/entwine.cpp"
    "${BASE}/info.cpp"
    "${BASE}/merge.cpp"
    # "${BASE}/scan.cpp"
)

set(CMAKE_THREAD_PREFER_PTHREAD TRUE)
find_package(Threads REQUIRED)

add_executable(app ${SOURCES})
compiler_options(app)
add_dependencies(app entwine)

target_link_libraries(app
    PRIVATE
        entwine
        ${PDAL_LIBRARIES}
        ${CMAKE_DL_LIBS}
        ${CMAKE_THREAD_LIBS_INIT}
        pdalcpp
        OpenSSL::applink
        OpenSSL::Crypto
)
if (CURL_FOUND)
    target_link_libraries(app
        PRIVATE
            CURL::libcurl
    )
endif()



if (DEFINED BACKTRACE_DEFS)
  target_link_libraries(app PRIVATE ${Backtrace_LIBRARIES})
endif (DEFINED BACKTRACE_DEFS)

set_target_properties(app PROPERTIES OUTPUT_NAME entwine)

install(TARGETS app DESTINATION bin)
```

--------------------------------

### Using JSON Config with CLI Override

Source: https://context7.com/connormanning/entwine/llms.txt

This command demonstrates how to use a JSON configuration file for the Entwine build process, while overriding the output path at runtime.

```bash
entwine build -c build-template.json -o ~/entwine/output-v2
```

--------------------------------

### Entwine Build from Local Directory

Source: https://context7.com/connormanning/entwine/llms.txt

Builds an EPT dataset from a local directory. Supports non-recursive and recursive scans using glob patterns.

```bash
entwine build -i ~/county-data/ -o ~/entwine/county
```

```bash
entwine build -i "~/lidar/**" -o ~/entwine/lidar-full
```

--------------------------------

### Serve Entwine Data with Docker

Source: https://github.com/connormanning/entwine/blob/master/readme.md

Serve the generated Entwine data statically using a Docker container. Mount the Entwine output directory to /var/www and map the port to access the data via HTTP.

```bash
docker run -it -v ~/entwine:/var/www -p 8080:8080 connormanning/http-server
```

--------------------------------

### C++ Builder API: Create and Run EPT Build

Source: https://context7.com/connormanning/entwine/llms.txt

Programmatically initialize a Builder from a JSON config and execute the EPT dataset build process. Requires Entwine C++ headers and a C++17 compiler.

```cpp
#include <entwine/builder/builder.hpp>
#include <entwine/util/json.hpp>

using namespace entwine;

int main()
{
    // Create builder from JSON configuration
    json config = {
        { "input",   "~/data/autzen.laz" },
        { "output",  "~/entwine/autzen" },
        { "threads", 8 },
        { "dataType", "laszip" },
        { "span",    256 },
        { "reprojection", {
            { "in",  "EPSG:26915" },
            { "out", "EPSG:3857" }
        }}
    };

    try
    {
        Builder builder = builder::create(config);

        // Print metadata summary
        std::cout << "Points to index: "
                  << builder.manifest.size() << " files\n";

        // Run the indexing — returns number of points actually written
        const uint64_t pointsWritten = builder::run(builder, config);

        std::cout << "Wrote " << pointsWritten << " points.\n";
        // Output: "Wrote 10653336 points."
    }
    catch (const std::exception& e)
    {
        std::cerr << "Build failed: " << e.what() << "\n";
        return 1;
    }

    return 0;
}
```

--------------------------------

### Entwine Build with JSON Configuration

Source: https://context7.com/connormanning/entwine/llms.txt

Builds an EPT dataset using a JSON configuration file. CLI arguments can override values specified in the config file.

```json
{
    "input": "~/data/chicago.laz",
    "output": "~/entwine/chicago",
    "threads": 9,
    "dataType": "laszip",
    "reprojection": { "in": "EPSG:26915", "out": "EPSG:3857" }
}
```

```bash
entwine build -c config.json
```

```bash
entwine build -c config.json -i ~/data/other.laz -o ~/entwine/other
```

--------------------------------

### Configure Header File

Source: https://github.com/connormanning/entwine/blob/master/test/CMakeLists.txt

Configures a header file from a template, typically used for build-time information.

```cmake
configure_file(unit/config.hpp.in "${CMAKE_CURRENT_BINARY_DIR}/unit/config.hpp")
```

--------------------------------

### Enable Verbose Output

Source: https://github.com/connormanning/entwine/blob/master/doc/source/configuration.md

Enable more detailed output to STDOUT. Defaults to false.

```bash
--verbose
```

--------------------------------

### Build Third Party Library

Source: https://github.com/connormanning/entwine/blob/master/entwine/third/CMakeLists.txt

Adds the third-party library as an object library and applies compiler options.

```cmake
add_library(${MODULE} OBJECT ${THIRD_SOURCES})
compiler_options(${MODULE})
```

--------------------------------

### Configure Third Party Module

Source: https://github.com/connormanning/entwine/blob/master/entwine/third/CMakeLists.txt

Sets the module name and base directory for third-party components. Includes subdirectories for additional modules.

```cmake
set(MODULE third)
set(BASE "${CMAKE_CURRENT_SOURCE_DIR}")

add_subdirectory(arbiter)
```

--------------------------------

### Define Subset for Parallel Builds

Source: https://github.com/connormanning/entwine/blob/master/doc/source/configuration.md

Specify a subset configuration for splitting builds into multiple tasks. Requires a 1-based ID and the total number of tasks (a power of 4).

```bash
--subset 1 4
```

--------------------------------

### Viewing EPT Data with Potree and Plasio

Source: https://context7.com/connormanning/entwine/llms.txt

URLs for viewing EPT data in Potree and Plasio viewers, assuming EPT data is served locally on port 8080.

```bash
# View Red Rocks dataset in Potree
# http://potree.entwine.io/data/custom.html?r=http://localhost:8080/red-rocks/ept.json

# View in Plasio
# http://dev.speck.ly/?s=0&r=ept://localhost:8080/red-rocks&c0s=local://color
```

--------------------------------

### Build Entwine Index for Point Cloud Data

Source: https://github.com/connormanning/entwine/blob/master/readme.md

Index a point cloud file (e.g., a .laz file) using the `entwine build` command. Specify the input file with -i and the output directory with -o. This command can also accept directories as input to index multiple files.

```bash
entwine build \
    -i https://data.entwine.io/red-rocks.laz \
    -o ~/entwine/red-rocks
```

--------------------------------

### C++ Builder API - `builder::merge`

Source: https://context7.com/connormanning/entwine/llms.txt

Merge completed parallel subset builds programmatically using the `builder::merge` function with a JSON configuration.

```cpp
## C++ Builder API — `builder::merge`

Merge completed parallel subset builds programmatically.

```cpp
#include <entwine/builder/builder.hpp>
#include <entwine/types/endpoints.hpp>
#include <entwine/util/json.hpp>

using namespace entwine;

int main()
{
    // Merge via JSON config
    json mergeConfig = {
        { "output",  "~/entwine/subsets" },
        { "threads", 8 },
        { "force",   false }
    };

    try
    {
        builder::merge(mergeConfig);
        std::cout << "Merge complete.\n";
    }
    catch (const std::exception& e)
    {
        std::cerr << "Merge failed: " << e.what() << "\n";
        return 1;
    }

    return 0;
}
```
```

--------------------------------

### Cesium 3D Tiles Conversion Workflow

Source: https://context7.com/connormanning/entwine/llms.txt

This multi-step process shows how to convert point cloud data into Cesium 3D Tiles format. It involves building an EPT in ECEF projection, converting it, and then serving it with a simple HTTP server.

```bash
# Step 1: Build EPT with ECEF reprojection
mkdir ~/entwine
docker run -it -v ~/entwine:/entwine connormanning/entwine build \
    -i https://entwine.io/sample-data/autzen.laz \
    -o /entwine/autzen-ecef \
    -r EPSG:4978
```

```bash
# Step 2: Convert EPT to Cesium 3D Tiles
docker run -it -v ~/entwine:/entwine connormanning/entwine convert \
    -i /entwine/autzen-ecef \
    -o /entwine/cesium/autzen
```

```bash
# Step 3: Serve and view in Cesium
docker run -it -v ~/entwine/cesium:/var/www -p 8080:8080 \
    connormanning/http-server

# Open: http://cesium.entwine.io/?url=http://localhost:8080/autzen/tileset.json
```

--------------------------------

### Allow EC2 Instance Profile Credentials for S3

Source: https://github.com/connormanning/entwine/blob/master/doc/source/configuration.md

Permit the use of EC2 instance profile credentials for authentication when accessing S3.

```bash
--allow-instance-profile
```

--------------------------------

### Add Initialize Test

Source: https://github.com/connormanning/entwine/blob/master/test/CMakeLists.txt

Uses the ENTWINE_ADD_TEST macro to add a test executable for initialization.

```cmake
ENTWINE_ADD_TEST(initialize FILES unit/init.cpp)
```

--------------------------------

### Configure Spatial Scale Factor (JSON)

Source: https://github.com/connormanning/entwine/blob/master/doc/source/configuration.md

Configure the spatial scale factor using JSON format. Supports uniform or non-uniform scaling.

```json
{ "scale": 0.01 }
```

```json
{ "scale": [0.01, 0.01, 0.025] }
```

--------------------------------

### Enable S3 Requester-Pays Mode

Source: https://github.com/connormanning/entwine/blob/master/doc/source/configuration.md

Activate S3 requester-pays mode, where the requester incurs the data access costs.

```bash
--requester-pays
```

--------------------------------

### Force New Index Creation via JSON

Source: https://github.com/connormanning/entwine/blob/master/doc/source/configuration.md

Configure forcing a new index creation using a JSON object. Setting 'force' to true will overwrite an existing index.

```json
{ "force": true }
```

--------------------------------

### Build Entwine Point Tile Dataset for Cesium

Source: https://github.com/connormanning/entwine/blob/master/doc/source/configuration.md

Create an Entwine Point Tile dataset with an Earth-Centered Earth-Fixed (ECEF) projection using Docker. This is the first step in preparing data for Cesium.

```bash
mkdir ~/entwine
docker run -it -v ~/entwine:/entwine connormanning/entwine build \
    -i https://entwine.io/sample-data/autzen.laz \
    -o /entwine/autzen-ecef \
    -r EPSG:4978
```

--------------------------------

### EPT Dataset Directory Structure

Source: https://github.com/connormanning/entwine/blob/master/doc/source/entwine-point-tile.md

Illustrates the typical organization of files and directories within an Entwine Point Tile (EPT) dataset.

```text
├── ept.json
├── ept-data
│   └── 0-0-0-0.laz
├── ept-hierarchy
│   └── 0-0-0-0.json
└── ept-sources
    ├── list.json
    └── 0.json
```

--------------------------------

### Specify Total Bounds via JSON

Source: https://github.com/connormanning/entwine/blob/master/doc/source/configuration.md

Configure the total bounds for all indexed points using a JSON array. The format is [xmin, ymin, zmin, xmax, ymax, zmax].

```json
{ "bounds": [0, 500, 30, 800, 1300, 50] }
```

--------------------------------

### Limit Number of Files Processed

Source: https://github.com/connormanning/entwine/blob/master/doc/source/configuration.md

Specify a maximum number of files to process for a build. Useful for partial builds that can be continued later.

```bash
--limit 20
```

--------------------------------

### Enable Deep Scan for Point Data

Source: https://github.com/connormanning/entwine/blob/master/doc/source/configuration.md

Set to 'true' to require a deep scan of all points in each file. This is useful if file headers are known to be incorrect regarding point counts or bounds.

```bash
--deep
```

--------------------------------

### Build Entwine EPT Dataset

Source: https://github.com/connormanning/entwine/blob/master/doc/source/quickstart.rst

Fetches the Red Rocks Amphitheatre dataset and builds an EPT dataset in the specified output directory. Supports indexing multiple files by passing a directory to the -i flag.

```bash
entwine build -i https://data.entwine.io/red-rocks.laz -o ~/entwine/red-rocks
```

--------------------------------

### Specify Input Point Cloud Data Path

Source: https://github.com/connormanning/entwine/blob/master/doc/source/configuration.md

Define the path to the point cloud data to be indexed. This can be a single file, a directory (recursive or non-recursive), or an info directory/file.

```json
{ "input": "~/data/autzen.laz" }
```

```json
{ "input": ["autzen.laz", "~/data/"] }
```

--------------------------------

### Entwine Build Configuration via JSON

Source: https://context7.com/connormanning/entwine/llms.txt

This JSON object defines configuration options for the Entwine build process. CLI arguments can override these settings, enabling reusable build templates.

```json
{
    "input": ["~/data/tiles/", "s3://my-bucket/lidar/"],
    "output": "~/entwine/combined",
    "threads": [4, 8],
    "dataType": "laszip",
    "span": 256,
    "scale": 0.01,
    "reprojection": {
        "in": "EPSG:26915",
        "out": "EPSG:3857",
        "hammer": true
    },
    "force": false,
    "verbose": true,
    "progress": 10,
    "maxNodeSize": 262144,
    "minNodeSize": 50,
    "cacheSize": 64,
    "allowOriginId": true
}
```

--------------------------------

### Specify Output Data Type

Source: https://github.com/connormanning/entwine/blob/master/doc/source/configuration.md

Define the storage type for point cloud data in the output EPT. Acceptable values are 'laszip', 'zstandard', and 'binary'.

```bash
--dataType laszip
```

--------------------------------

### C++ Builder API: Merge EPT Subsets

Source: https://context7.com/connormanning/entwine/llms.txt

Programmatically merge completed parallel subset builds using a JSON configuration. Requires Entwine C++ headers and a C++17 compiler.

```cpp
#include <entwine/builder/builder.hpp>
#include <entwine/types/endpoints.hpp>
#include <entwine/util/json.hpp>

using namespace entwine;

int main()
{
    // Merge via JSON config
    json mergeConfig = {
        { "output",  "~/entwine/subsets" },
        { "threads", 8 },
        { "force",   false }
    };

    try
    {
        builder::merge(mergeConfig);
        std::cout << "Merge complete.\n";
    }
    catch (const std::exception& e)
    {
        std::cerr << "Merge failed: " << e.what() << "\n";
        return 1;
    }

    return 0;
}
```

--------------------------------

### Entwine Info - Analyze Point Cloud Metadata

Source: https://context7.com/connormanning/entwine/llms.txt

Analyzes input files to aggregate metadata like bounds, schema, and point counts before building an EPT dataset. Supports quick analysis of single files, directory scans with per-file JSON output, and deep analysis for files with header issues.

```bash
entwine info -i ~/data/autzen.laz
```

```bash
entwine info -i ~/data/ -o ~/entwine/info/autzen-files/
```

```bash
entwine info -i ~/data/bad-headers.laz --deep
```

--------------------------------

### Configure Multiple S3 Profiles with Arbiter

Source: https://github.com/connormanning/entwine/blob/master/doc/source/configuration.md

Set up Entwine to access multiple S3 buckets with different authentication settings using Arbiter. Non-default profiles require prefixed paths.

```json
{ "arbiter": {
    "s3": [
        {
            "profile": "default",
            "access": "<access key here>",
            "secret": "<secret key here>"
        },
        {
            "profile": "second",
            "access": "<access key here>",
            "secret": "<secret key here>",
            "region": "eu-central-1",
            "sse": true
        }
    ]
} }
```

--------------------------------

### Generate Hillshade with GDALDEM

Source: https://github.com/connormanning/entwine/blob/master/doc/source/quickstart.rst

Creates a hillshade visualization from a GeoTIFF elevation model using the gdaldem command-line utility.

```bash
gdaldem hillshade red-rocks-dtm.tif hillshade.png
```

--------------------------------

### Add Info Test

Source: https://github.com/connormanning/entwine/blob/master/test/CMakeLists.txt

Uses the ENTWINE_ADD_TEST macro to add a test executable for info functionality.

```cmake
ENTWINE_ADD_TEST(info FILES unit/info.cpp)
```

--------------------------------

### Generating GeoTIFF and Hillshade from EPT Data

Source: https://context7.com/connormanning/entwine/llms.txt

Commands to use PDAL to create a GeoTIFF elevation model from EPT data and then generate a hillshade from the GeoTIFF.

```bash
# Use PDAL EPT reader to create a GeoTIFF elevation model
pdal translate \
    ept://~/entwine/red-rocks \
    red-rocks-dtm.tif \
    --writers.gdal.resolution=2.0

# Generate a hillshade from the DTM
gdal "hillshade" red-rocks-dtm.tif hillshade.png
```

--------------------------------

### Convert Point Tile Dataset to 3D Tiles for Cesium

Source: https://github.com/connormanning/entwine/blob/master/doc/source/configuration.md

Convert an existing Entwine Point Tile dataset to a 3D Tiles tileset using the `entwine convert` command in Docker. This is the second step for Cesium integration.

```bash
docker run -it -v ~/entwine:/entwine connormanning/entwine convert \
    -i /entwine/autzen-ecef \
    -o /entwine/cesium/autzen
```

--------------------------------

### Force New Index Creation

Source: https://github.com/connormanning/entwine/blob/master/doc/source/configuration.md

Enable forcing a new index creation. If an Entwine index already exists at the output path, this option ensures it is overwritten instead of appended to.

```bash
--force
```

--------------------------------

### Clone Entwine Development Source

Source: https://github.com/connormanning/entwine/blob/master/doc/source/download.rst

Use this command to obtain a copy of the active source code from the main Entwine repository on GitHub.

```bash
git clone https://github.com/connormanning/entwine.git
```

--------------------------------

### Entwine Build with Force Overwrite

Source: https://context7.com/connormanning/entwine/llms.txt

Forces an overwrite of an existing EPT index at the specified output path.

```bash
entwine build -i ~/data/new.laz -o ~/entwine/existing --force
```

--------------------------------

### Specify Output Data Type via JSON

Source: https://github.com/connormanning/entwine/blob/master/doc/source/configuration.md

Configure the output storage type for point cloud data using a JSON object. Supported types include 'laszip', 'zstandard', and 'binary'.

```json
{ "dataType": "laszip" }
```

--------------------------------

### EPT Sources Per-File Metadata JSON

Source: https://context7.com/connormanning/entwine/llms.txt

Per-file metadata for EPT sources, including path, bounds, point count, SRS, and schema.

```json
// ept-sources/autzen-high.json  (per-file metadata)
{
    "path": "autzen-high.laz",
    "bounds": [635577.0, 848882.0, 511.0, 639004.0, 853538.0, 616.0],
    "points": 120000,
    "srs": {
        "authority": "EPSG",
        "horizontal": "3857",
        "wkt": "PROJCS[\"WGS 84 ...\" AUTHORITY[\"EPSG\",\"3857\"]]]"
    },
    "metadata": {
        "software_id": "PDAL",
        "version": 58
    },
    "schema": []
}
```

--------------------------------

### JSON Reprojection Configuration

Source: https://github.com/connormanning/entwine/blob/master/doc/source/configuration.md

Configure coordinate system reprojection using a JSON object. Specify input ('in') and output ('out') SRS, and optionally 'hammer' to force input SRS.

```json
{ "reprojection": { "in": "EPSG:26915", "out": "EPSG:3857" } }
```

```json
{ "reprojection": { "in": "EPSG:26915", "out": "EPSG:3857" } }
```

```json
{ "reprojection": { "in": "EPSG:26915", "out": "EPSG:3857" , "hammer": true } }
```

--------------------------------

### EPT Sources Manifest

Source: https://context7.com/connormanning/entwine/llms.txt

The `manifest.json` file within `ept-sources/` tracks the provenance of each source file used in the EPT dataset. It maps `OriginId` to file details like path, bounds, and point count.

```APIDOC
## EPT Sources — `ept-sources/`

Tracks the provenance of each source file inserted into the EPT dataset. The `OriginId` dimension in every point maps back to the index in `manifest.json`.

```json
// ept-sources/manifest.json
[
    {
        "path": "autzen-low.laz",
        "bounds": [635577.0, 848882.0, 406.0, 639004.0, 853538.0, 511.0],
        "inserted": true,
        "points": 6000,
        "metadataPath": "autzen-low.json"
    },
    {
        "path": "autzen-high.laz",
        "bounds": [635577.0, 848882.0, 511.0, 639004.0, 853538.0, 616.0],
        "inserted": true,
        "points": 4000,
        "metadataPath": "autzen-high.json"
    }
]

// ept-sources/autzen-high.json  (per-file metadata)
{
    "path": "autzen-high.laz",
    "bounds": [635577.0, 848882.0, 511.0, 639004.0, 853538.0, 616.0],
    "points": 120000,
    "srs": {
        "authority": "EPSG",
        "horizontal": "3857",
        "wkt": "PROJCS[\"WGS 84 ...\" AUTHORITY[\"EPSG\",\"3857\"]]"
    },
    "metadata": {
        "software_id": "PDAL",
        "version": 58
    },
    "schema": []
}
```
```

--------------------------------

### Translate EPT Data to GeoTIFF with PDAL

Source: https://github.com/connormanning/entwine/blob/master/doc/source/quickstart.rst

Uses PDAL to translate the Entwine EPT dataset to a GeoTIFF file, specifying a resolution of 2.0. This process can be done over HTTP or the local filesystem.

```bash
pdal translate ept://entwine/red-rocks red-rocks-dtm.tif --writers.gdal.resolution=2.0
```

--------------------------------

### Specify Octree Span (Voxel Resolution)

Source: https://github.com/connormanning/entwine/blob/master/doc/source/configuration.md

Set the number of voxels in each spatial dimension, defining the octree's grid size. A span of 256 results in a 256x256x256 cubic resolution.

```bash
--span 128
```

--------------------------------

### Specify Temporary Data Directory

Source: https://github.com/connormanning/entwine/blob/master/doc/source/configuration.md

Define a local directory for Entwine to store temporary data during processing.

```bash
--tmp /tmp/entwine
```

--------------------------------

### Set File Processing Limit (JSON)

Source: https://github.com/connormanning/entwine/blob/master/doc/source/configuration.md

Configure the maximum number of files to process using JSON format.

```json
{ "limit": 25 }
```

--------------------------------

### Specify Output Directory for EPT Data

Source: https://github.com/connormanning/entwine/blob/master/doc/source/configuration.md

Set the directory where Entwine will write the generated EPT (Entwine Point Tile) output. This can be a local or remote path.

```bash
--config template.json -i in.laz -o out
```

--------------------------------

### Enable AWS Server-Side Encryption for S3

Source: https://github.com/connormanning/entwine/blob/master/doc/source/configuration.md

Activate AWS Server-Side Encryption (SSE) for data written to S3 buckets.

```bash
--sse
```

--------------------------------

### Specify Output Coordinate System (SRS)

Source: https://github.com/connormanning/entwine/blob/master/doc/source/configuration.md

Set the coordinate system for the output EPT metadata. This option does not trigger reprojection but updates the 'srs' field in the metadata.

```bash
--srs EPSG:3857
```

--------------------------------

### Add Build Test

Source: https://github.com/connormanning/entwine/blob/master/test/CMakeLists.txt

Uses the ENTWINE_ADD_TEST macro to add a test executable for build functionality.

```cmake
ENTWINE_ADD_TEST(build FILES unit/build.cpp)
```

--------------------------------

### EPT Sources Manifest JSON

Source: https://context7.com/connormanning/entwine/llms.txt

Manifest file tracking the provenance of source files inserted into an EPT dataset. The OriginId maps to the index in this manifest.

```json
// ept-sources/manifest.json
[
    {
        "path": "autzen-low.laz",
        "bounds": [635577.0, 848882.0, 406.0, 639004.0, 853538.0, 511.0],
        "inserted": true,
        "points": 6000,
        "metadataPath": "autzen-low.json"
    },
    {
        "path": "autzen-high.laz",
        "bounds": [635577.0, 848882.0, 511.0, 639004.0, 853538.0, 616.0],
        "inserted": true,
        "points": 4000,
        "metadataPath": "autzen-high.json"
    }
]
```

--------------------------------

### Add Version Test

Source: https://github.com/connormanning/entwine/blob/master/test/CMakeLists.txt

Uses the ENTWINE_ADD_TEST macro to add a test executable for version information.

```cmake
ENTWINE_ADD_TEST(version FILES unit/version.cpp)
```

--------------------------------

### Specify Thread Allocation for Parallelization

Source: https://github.com/connormanning/entwine/blob/master/doc/source/configuration.md

Configure the number of threads for parallelization using a JSON object. This can be a single value for total threads or an array specifying worker and serialization threads.

```json
{ "threads": 9 }
```

```json
{ "threads": [2, 7] }
```

--------------------------------

### Activate Entwine Conda Environment

Source: https://github.com/connormanning/entwine/blob/master/doc/source/quickstart.rst

Activates the 'entwine' Conda environment for use.

```bash
conda activate entwine
```

--------------------------------

### Specify Total Bounds for Indexing

Source: https://github.com/connormanning/entwine/blob/master/doc/source/configuration.md

Define the final bounds for all indexed points. These bounds cannot be expanded after indexing begins. Specified as [xmin, ymin, zmin, xmax, ymax, zmax].

```bash
--bounds 0 0 0 100 100 100
```

```bash
--bounds "[0,0,0,100,100,100]"
```

--------------------------------

### Entwine Remote Storage Configuration (S3)

Source: https://context7.com/connormanning/entwine/llms.txt

This JSON configuration shows how to set up Entwine for remote filesystem access using AWS S3. It includes options for multiple S3 profiles, server-side encryption, and specific regions.

```json
{
    "input": "s3://my-bucket/raw/",
    "output": "s3://my-bucket/ept/",
    "arbiter": {
        "s3": [
            {
                "profile": "default",
                "access": "<access-key>",
                "secret": "<secret-key>",
                "region": "us-east-1",
                "sse": true
            },
            {
                "profile": "eu-reader",
                "access": "<access-key>",
                "secret": "<secret-key>",
                "region": "eu-central-1"
            }
        ]
    }
}
```

--------------------------------

### Specify Coordinate System Reprojection

Source: https://github.com/connormanning/entwine/blob/master/doc/source/configuration.md

Define reprojection specifications using a JSON object. This can include input and output coordinate systems, and an option to force input SRS.

```bash
--reprojection EPSG:3857
```

```bash
--reprojection EPSG:26915 EPSG:3857
```

--------------------------------

### Build Entwine Without Tests

Source: https://context7.com/connormanning/entwine/llms.txt

Use these CMake commands to build Entwine, disabling test compilation for a faster build process. The `--parallel` flag utilizes multiple cores for compilation.

```bash
cmake .. -DWITH_TESTS=OFF
```

```bash
cmake --build . --parallel 8
```

--------------------------------

### Specify Number of Threads for Parallelization

Source: https://github.com/connormanning/entwine/blob/master/doc/source/configuration.md

Set the total number of threads for parallel processing. By default, a portion is allocated for point insertion and the rest for serialization.

```bash
--threads 12
```

--------------------------------

### Add Pipeline Utils Test

Source: https://github.com/connormanning/entwine/blob/master/test/CMakeLists.txt

Uses the ENTWINE_ADD_TEST macro to add a test executable for pipeline utility functions.

```cmake
ENTWINE_ADD_TEST(pipeline FILES unit/pipeline-utils.cpp)
```

--------------------------------

### Enable S3 Server-Side Encryption

Source: https://github.com/connormanning/entwine/blob/master/doc/source/configuration.md

Configure Entwine to use server-side encryption for the default S3 profile via Arbiter.

```json
{ "arbiter": {
    "s3": {
        "sse": true
    }
} }
```

--------------------------------

### EPT Subtree Hierarchy File

Source: https://github.com/connormanning/entwine/blob/master/doc/source/entwine-point-tile.md

This JSON file represents a subtree within the EPT hierarchy. It contains the point count for the parent node and its direct children, which may also include sentinel values.

```json
{
    "3-2-3-6": 32004,
        "4-4-6-12": 1500,
        "4-5-6-13": 2400
}
```

--------------------------------

### EPT Hierarchy

Source: https://context7.com/connormanning/entwine/llms.txt

JSON files describing the octree node structure and point counts within an EPT dataset. The `ept-hierarchy/` directory contains these files, with keys in `Depth-X-Y-Z` format. A value of -1 indicates a subtree is in its own child file.

```APIDOC
## EPT Hierarchy — `ept-hierarchy/`

JSON files that describe which octree nodes exist and how many points they contain, using `Depth-X-Y-Z` keys. A value of `-1` means the subtree is in its own child file.

```json
// ept-hierarchy/0-0-0-0.json
{
    "0-0-0-0": 65341,
    "1-0-0-0": 438,
        "2-0-1-0": 322,
    "1-0-0-1": 56209,
        "2-0-1-2": 4332,
        "2-1-1-2": 20300,
        "2-1-1-3": 64020,
            "3-2-3-6": -1,
    "1-0-1-0": 30390,
    "1-1-1-1": 2303
}

// ept-hierarchy/3-2-3-6.json  (subtree, linked via -1 sentinel)
{
    "3-2-3-6": 32004,
        "4-4-6-12": 1500,
        "4-5-6-13": 2400
}
```
```

--------------------------------

### Set Spatial Scale Factor for Output

Source: https://github.com/connormanning/entwine/blob/master/doc/source/configuration.md

Specify a scale factor for the output's spatial coordinates. Can be a single number for uniform scaling or a 3-length array for non-uniform scaling.

```bash
--scale 0.1
```

```bash
--scale "[0.1, 0.1, 0.025]"
```