Xeokit Convert

https://github.com/xeokit/xeokit-convert
Admin
Xeokit Convert is a JavaScript toolkit that converts 3D BIM and AEC models (IFC, GLB, LAS, STL,...
Tokens:59,712
Snippets:575
Trust Score:9.6
Update:4 months ago
Show doc for...
Tokens:
Raw
### Install Dependencies and Build

Source: https://github.com/xeokit/xeokit-convert/blob/main/README.md

Install NPM dependencies and run the build script. This is the standard procedure for setting up the project.

```bash
npm install
npm run build
```

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

### Install and Run xeokit-convert Locally

Source: https://github.com/xeokit/xeokit-convert/blob/main/_autodocs/cli-reference.md

Install the xeokit-convert package locally within your project and execute it using npx.

```bash
npm install @xeokit/xeokit-convert

npx xeokit-convert [options]
```

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

### CLI Tool Example

Source: https://github.com/xeokit/xeokit-convert/blob/main/_autodocs/README.md

An example demonstrating how to use the CLI tool to convert an IFC file to XKT format with logging enabled.

```bash
node convert2xkt.js --input model.ifc --output model.xkt --log
```

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

### Run xeokit-convert Help after Global Install

Source: https://github.com/xeokit/xeokit-convert/blob/main/README.md

After installing xeokit-convert globally, you can access its help information by running the command with the -h flag.

```bash
xeokit-convert -h
```

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

### Example: Create and Render a Box

Source: https://github.com/xeokit/xeokit-convert/blob/main/_autodocs/api-reference/geometry-builders.md

Demonstrates creating a box geometry, then creating a geometry, mesh, and entity to render it in a scene.

```javascript
const xktModel = new XKTModel();

const box = buildBoxGeometry({
    center: [-4, 0, 0],
    xSize: 2,
    ySize: 3,
    zSize: 1
});

const geometry = xktModel.createGeometry({
    geometryId: "box1",
    primitiveType: box.primitiveType,
    positions: box.positions,
    normals: box.normals,
    indices: box.indices
});

const mesh = xktModel.createMesh({
    meshId: "boxMesh",
    geometryId: "box1",
    color: [1, 0, 0]
});

const entity = xktModel.createEntity({
    entityId: "redBox",
    meshIds: ["boxMesh"]
});
```

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

### Install and Run xeokit-convert Globally

Source: https://github.com/xeokit/xeokit-convert/blob/main/_autodocs/cli-reference.md

Install the xeokit-convert package globally using npm to run the command directly from your terminal.

```bash
npm install -g @xeokit/xeokit-convert

xeokit-convert [options]
```

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

### Configuration File for Conversion

Source: https://github.com/xeokit/xeokit-convert/blob/main/_autodocs/cli-reference.md

Define conversion parameters in a JSON configuration file for reusability and complex setups. This example shows common settings for IFC to XKT conversion.

```json
{
    "input": "model.ifc",
    "output": "model.xkt",
    "format": "ifc",
    "author": "Design Team",
    "projectId": "proj_123",
    "wasmPath": "./node_modules/web-ifc/dist/",
    "includeTypes": ["IfcWall", "IfcDoor", "IfcWindow"],
    "minTileSize": 500,
    "edgeThreshold": 10,
    "zip": true,
    "log": true
}
```

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

### Install xeokit-convert from Source

Source: https://github.com/xeokit/xeokit-convert/blob/main/README.md

Clone the xeokit-convert repository and install its dependencies locally. This method is useful for development or if you need to modify the source code. Requires git and Node.js v16.10.0 or higher.

```bash
git clone https://github.com/xeokit/xeokit-convert.git
cd xeokit-convert/
npm install
```

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

### Example Logging Output with --log

Source: https://github.com/xeokit/xeokit-convert/blob/main/_autodocs/cli-reference.md

This shows the detailed log messages generated when the --log flag is enabled during conversion.

```text
[xeokit-convert] Parsing IFC file...
[xeokit-convert] Loading web-ifc WASM...
[xeokit-convert] Parsing geometry from IFC model...
[xeokit-convert] Parsed 5,234 objects
[xeokit-convert] Creating 12,456 geometries
[xeokit-convert] Finalizing XKT model...
[xeokit-convert] Compressing textures...
[xeokit-convert] Building spatial tiles...
[xeokit-convert] Serializing XKT file...
[xeokit-convert] XKT written: model.xkt (24.5 MB)
```

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

### Display Installed CLI Version

Source: https://github.com/xeokit/xeokit-convert/blob/main/_autodocs/cli-reference.md

Use this command to check the currently installed version of the xeokit-convert CLI. This is useful for verifying installation and compatibility.

```bash
convert2xkt --version
# @xeokit/xeokit-convert v1.3.2
```

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

### Run xeokit-convert from Source

Source: https://github.com/xeokit/xeokit-convert/blob/main/README.md

After installing xeokit-convert from source, you can run the conversion script directly using Node.js. This is useful for testing local changes.

```bash
node convert2xkt.js -h
```

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

### Check Conversion Exit Code

Source: https://github.com/xeokit/xeokit-convert/blob/main/_autodocs/cli-reference.md

This example demonstrates how to execute the conversion and then check the exit code to verify success or identify errors.

```bash
convert2xkt --input model.ifc --output model.xkt
echo "Exit code: $?"
```

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

### Install Latest CLI Version

Source: https://github.com/xeokit/xeokit-convert/blob/main/_autodocs/cli-reference.md

Use npm to install the latest version of the xeokit-convert package. This ensures you have the most recent features and bug fixes.

```bash
npm install @xeokit/xeokit-convert@latest
```

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

### IFC Include Types Example

Source: https://github.com/xeokit/xeokit-convert/blob/main/_autodocs/configuration.md

Example of a whitelist for IFC types to include in the conversion, focusing on structural and BIM elements.

```javascript
// Structural/BIM elements only
includeTypes: [
    "IfcWall",
    "IfcDoor",
    "IfcWindow",
    "IfcRoof",
    "IfcSlab",
    "IfcColumn",
    "IfcBeam",
    "IfcStair",
    "IfcFurniture"
]
```

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

### Full Model Creation and Export Example

Source: https://github.com/xeokit/xeokit-convert/blob/main/_autodocs/api-reference/xktmodel.md

Demonstrates the complete workflow of creating an XKT model, including geometry, mesh, and entity definitions, followed by finalization and export to an ArrayBuffer.

```javascript
const xktModel = new XKTModel();

// Build model...
xktModel.createGeometry({ /* ... */ });
xktModel.createMesh({ /* ... */ });
xktModel.createEntity({ /* ... */ });

// Finalize and export
await xktModel.finalize();
const arrayBuffer = writeXKTModelToArrayBuffer(xktModel);
```

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

### Complete Geometry Creation Example

Source: https://github.com/xeokit/xeokit-convert/blob/main/_autodocs/api-reference/geometry-builders.md

Demonstrates building and combining box, sphere, and cylinder geometries within an XKT model. Includes finalization and serialization to an ArrayBuffer.

```javascript
import {
    XKTModel,
    buildBoxGeometry,
    buildSphereGeometry,
    buildCylinderGeometry,
    writeXKTModelToArrayBuffer
} from "@xeokit/xeokit-convert";

async function createGeometryDemo() {
    const xktModel = new XKTModel({
        modelId: "geometry_demo",
        author: "Demo Script"
    });

    // Build box
    const boxGeom = buildBoxGeometry({
        center: [-4, 0, 0],
        xSize: 1,
        ySize: 2,
        zSize: 1
    });

    const boxGeometry = xktModel.createGeometry({
        geometryId: "box",
        primitiveType: boxGeom.primitiveType,
        positions: boxGeom.positions,
        normals: boxGeom.normals,
        indices: boxGeom.indices
    });

    const boxMesh = xktModel.createMesh({
        meshId: "boxMesh",
        geometryId: "box",
        color: [1, 0, 0]
    });

    // Build sphere
    const sphereGeom = buildSphereGeometry({
        center: [0, 0, 0],
        radius: 1,
        widthSegments: 32,
        heightSegments: 16
    });

    const sphereGeometry = xktModel.createGeometry({
        geometryId: "sphere",
        primitiveType: sphereGeom.primitiveType,
        positions: sphereGeom.positions,
        normals: sphereGeom.normals,
        indices: sphereGeom.indices
    });

    const sphereMesh = xktModel.createMesh({
        meshId: "sphereMesh",
        geometryId: "sphere",
        color: [0, 1, 0]
    });

    // Build cylinder
    const cylGeom = buildCylinderGeometry({
        center: [4, 0, 0],
        radiusTop: 0.8,
        radiusBottom: 1,
        height: 2,
        radialSegments: 24
    });

    const cylGeometry = xktModel.createGeometry({
        geometryId: "cylinder",
        primitiveType: cylGeom.primitiveType,
        positions: cylGeom.positions,
        normals: cylGeom.normals,
        indices: cylGeom.indices
    });

    const cylMesh = xktModel.createMesh({
        meshId: "cylMesh",
        geometryId: "cylinder",
        color: [0, 0, 1]
    });

    // Create entities
    xktModel.createEntity({
        entityId: "box_entity",
        meshIds: ["boxMesh"]
    });

    xktModel.createEntity({
        entityId: "sphere_entity",
        meshIds: ["sphereMesh"]
    });

    xktModel.createEntity({
        entityId: "cylinder_entity",
        meshIds: ["cylMesh"]
    });

    // Finalize and serialize
    await xktModel.finalize();
    const xktBuffer = writeXKTModelToArrayBuffer(xktModel);

    console.log(`Generated XKT: ${xktBuffer.byteLength} bytes`);
    return xktBuffer;
}
```

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

### Run xeokit-convert from Node Modules

Source: https://github.com/xeokit/xeokit-convert/blob/main/README.md

When installed as a project dependency, you can execute the xeokit-convert script directly from the node_modules directory.

```bash
node node_modules/@xeokit/xeokit-convert/convert2xkt.js -h
```

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

### Install xeokit-convert as NPM Project Dependency

Source: https://github.com/xeokit/xeokit-convert/blob/main/README.md

Install xeokit-convert as a dependency for your current Node.js project. This is the standard way to include libraries in your application.

```bash
npm install @xeokit/xeokit-convert
```

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

### Dockerfile for xeokit-convert

Source: https://github.com/xeokit/xeokit-convert/blob/main/_autodocs/cli-reference.md

A Dockerfile to set up an environment with xeokit-convert installed globally. It uses a Node.js base image and installs the package via npm.

```dockerfile
FROM node:18

RUN npm install -g @xeokit/xeokit-convert

WORKDIR /convert

ENTRYPOINT ["convert2xkt"]
```

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

### Docker Usage for Model Conversion

Source: https://github.com/xeokit/xeokit-convert/blob/main/_autodocs/cli-reference.md

Example of how to run the xeokit-convert Docker container, mounting local directories for input models and output XKT files. This allows conversion within a containerized environment.

```bash
docker run -v $(pwd)/models:/convert/models \
    -v $(pwd)/output:/convert/output \
    xeokit-convert \
    --input /convert/models/model.ifc \
    --output /convert/output/model.xkt
```

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

### Complete Example: Serialize XKTModel with Metadata and Statistics

Source: https://github.com/xeokit/xeokit-convert/blob/main/_autodocs/api-reference/serialization.md

Demonstrates creating an XKTModel with geometries, meshes, and metadata, then serializing it to an ArrayBuffer while capturing detailed statistics. The metamodel JSON is auto-generated.

```javascript
import {
    XKTModel,
    buildBoxGeometry,
    writeXKTModelToArrayBuffer
} from "@xeokit/xeokit-convert";

async function serializeWithMetadata() {
    const xktModel = new XKTModel({
        modelId: "building_123",
        projectId: "proj_001",
        author: "John Doe",
        createdAt: "2024-01-15",
        schema: "IFC4"
    });

    // Create geometry
    const box = buildBoxGeometry({ xSize: 2, ySize: 3, zSize: 1 });
    const geometry = xktModel.createGeometry({
        geometryId: "box_geom",
        primitiveType: box.primitiveType,
        positions: box.positions,
        normals: box.normals,
        indices: box.indices
    });

    // Create mesh
    const mesh = xktModel.createMesh({
        meshId: "box_mesh",
        geometryId: "box_geom",
        color: [0.8, 0.2, 0.2]
    });

    // Create metadata
    const metaObject = xktModel.createMetaObject({
        metaObjectId: "wall_1",
        metaObjectType: "IfcWall",
        metaObjectName: "Exterior Wall"
    });

    const propertySet = xktModel.createPropertySet({
        propertySetId: "wall_props",
        propertySetType: "Pset_WallCommon",
        propertySetName: "Wall Properties",
        properties: [
            { name: "FireRating", value: "1HR" },
            { name: "IsExternal", value: true }
        ]
    });

    // Create entity
    const entity = xktModel.createEntity({
        entityId: "wall_1",
        meshIds: ["box_mesh"]
    });

    // Finalize
    await xktModel.finalize();

    // Serialize with statistics
    const stats = {};
    const xktBuffer = writeXKTModelToArrayBuffer(
        xktModel,
        null,  // Will auto-generate metamodel JSON
        stats,
        { zip: true }
    );

    console.log("Serialization complete:");
    console.log(`  Total size: ${stats.totalSize} bytes`);
    console.log(`  Geometries: ${stats.numGeometries}`);
    console.log(`  Textures: ${stats.numTextures}`);
    console.log(`  Objects: ${stats.numObjects}`);
    console.log(`  Tiles: ${stats.numTiles}`);

    return xktBuffer;
}
```

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

### Basic Texture Creation

Source: https://github.com/xeokit/xeokit-convert/blob/main/_autodocs/configuration.md

Create a texture with specified image data, dimensions, and filtering options. Use this for general texture setup.

```javascript
const texture = xktModel.createTexture({
    textureId: "texture_1",
    imageData: imageBuffer,
    width: 2048,
    height: 2048,
    compressed: true,
    mediaType: PNGMediaType,
    minFilter: LinearMipmapLinearFilter,
    magFilter: LinearFilter,
    wrapS: RepeatWrapping,
    wrapT: RepeatWrapping,
    wrapR: RepeatWrapping
});
```

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

### Load IFC into XKTModel and Viewer

Source: https://github.com/xeokit/xeokit-convert/blob/main/README.md

Parses an IFC file into an XKTModel, serializes it to an ArrayBuffer, and then loads it into a xeokit Viewer. This example demonstrates the full conversion pipeline from IFC.

```javascript
const viewer = new Viewer({
    canvasId: "myCanvas"
});

const xktLoader = new XKTLoaderPlugin(viewer);

utils.loadArraybuffer("./assets/models/ifc/rac_advanced_sample_project.ifc", async (data) => {

        const xktModel = new XKTModel();

        parseIFCIntoXKTModel({data, xktModel, wasmPath: "../dist/"}).then(() => {

            xktModel.finalize().then(() => {

                const xktArrayBuffer = writeXKTModelToArrayBuffer(xktModel);

                xktLoader.load({
                    id: "myModel",
                    xkt: xktArrayBuffer,
                    edges: true
                });

                viewer.cameraFlight.flyTo(viewer.scene);
            });
        });
    },
    (errMsg) => {
    });
```

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

### Troubleshoot Slow Performance

Source: https://github.com/xeokit/xeokit-convert/blob/main/_autodocs/cli-reference.md

Enable logging to identify bottlenecks and then optimize conversion parameters like tile size and edge detection thresholds.

```bash
# Enable logging to identify bottleneck
convert2xkt \
    --input model.ifc \
    --output model.xkt \
    --log

# Optimize parameters
convert2xkt \
    --input model.ifc \
    --output model.xkt \
    --minTileSize 1000 \
    --edgeThreshold 20 \
    --log
```

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

### Load Conversion Configuration from File

Source: https://github.com/xeokit/xeokit-convert/blob/main/_autodocs/cli-reference.md

Execute the xeokit-convert tool using a JSON configuration file. Command-line arguments will override values specified in the configuration file.

```bash
node convert2xkt.js --config convert2xkt.conf.json
```

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

### IFC Exclude Types Example

Source: https://github.com/xeokit/xeokit-convert/blob/main/_autodocs/configuration.md

Example of a blacklist for IFC types to exclude from the conversion, typically used for invisible or utility objects.

```javascript
// Exclude invisible/utility objects
excludeTypes: [
    "IfcSpace",
    "IfcOpeningElement",
    "IfcVirtualElement"
]
```

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

### Build XKT Model Programmatically

Source: https://github.com/xeokit/xeokit-convert/blob/main/_autodocs/api-reference/xktmodel.md

Demonstrates how to create an XKT model from scratch by defining geometries, meshes, and entities. Requires importing necessary components from '@xeokit/xeokit-convert'.

```javascript
import { 
    XKTModel, 
    buildBoxGeometry, 
    writeXKTModelToArrayBuffer 
} from "@xeokit/xeokit-convert";

const xktModel = new XKTModel({
    modelId: "myModel",
    author: "Example"
});

// Create geometry
const boxGeom = buildBoxGeometry({ xSize: 1, ySize: 2, zSize: 1 });
const geometry = xktModel.createGeometry({
    geometryId: "boxGeom",
    primitiveType: "triangles",
    positions: boxGeom.positions,
    normals: boxGeom.normals,
    indices: boxGeom.indices
});

// Create mesh
const mesh = xktModel.createMesh({
    meshId: "boxMesh",
    geometryId: "boxGeom",
    color: [0.8, 0.2, 0.2],
    opacity: 1.0
});

// Create entity
const entity = xktModel.createEntity({
    entityId: "box_1",
    meshIds: ["boxMesh"]
});

// Finalize and serialize
await xktModel.finalize();
const arrayBuffer = writeXKTModelToArrayBuffer(xktModel);
```

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

### Unsupported CommonJS Import (require)

Source: https://github.com/xeokit/xeokit-convert/blob/main/CHANGELOG.md

This import pattern using 'require' is no longer supported starting from version 1.2.0.

```javascript
const { XKT_INFO } = require("./dist/xeokit-convert.cjs.js");
```

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

### CLI Tool Usage

Source: https://github.com/xeokit/xeokit-convert/blob/main/_autodocs/README.md

Shows the basic command structure and available options for the xeokit-convert CLI tool.

```bash
node convert2xkt.js [options]

Options:
  --input <file>              Input model file
  --output <file>             Output XKT file
  --format <format>           Input format (auto-detected if omitted)
  --metaModelJSON <file>      Metamodel JSON file
  --minTileSize <number>      Minimum tile size (default: 500)
  --edgeThreshold <number>    Edge detection threshold (default: 10)
  --log                       Enable logging
```

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

### Troubleshoot 'Input file not found'

Source: https://github.com/xeokit/xeokit-convert/blob/main/_autodocs/cli-reference.md

Verify the file path is correct. Use 'ls -la' to check existence and then provide the correct relative or absolute path.

```bash
convert2xkt --input model.ifc --output model.xkt
# Error: Input file not found

# Solution: Check file path
ls -la model.ifc
convert2xkt --input ./models/model.ifc --output ./output/model.xkt
```

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

### xeokit-convert Project File Structure

Source: https://github.com/xeokit/xeokit-convert/blob/main/_autodocs/README.md

Overview of the key directories within the xeokit-convert project.

```tree
/xeokit-convert
├── /src
│   ├── /XKTModel              # Core model classes
│   ├── /parsers               # Format parsers
│   ├── /geometryBuilders      # Procedural geometry
│   ├── index.js               # Main export
│   └── constants.js           # Constants & enums
├── /types                     # TypeScript definitions
├── convert2xkt.js             # CLI tool
└── README.md                  # Project docs
```

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

### Unsupported CDN Import (import)

Source: https://github.com/xeokit/xeokit-convert/blob/main/CHANGELOG.md

Importing from a CDN using CommonJS module paths is no longer supported starting from version 1.2.0.

```javascript
import { convert2xkt } from 'https://cdn.jsdelivr.net/npm/@xeokit/xeokit-convert/dist/xeokit-convert.cjs.js';
```

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

### Create XKTModel with Constructor Options

Source: https://github.com/xeokit/xeokit-convert/blob/main/_autodocs/configuration.md

Instantiate an XKTModel with various configuration options to control its behavior, optimization, and metadata. Ensure necessary imports are included.

```javascript
import { XKTModel } from "@xeokit/xeokit-convert";

const xktModel = new XKTModel({
    modelId: "my_model",
    projectId: "proj_123",
    revisionId: "rev_1",
    author: "John Doe",
    createdAt: "2024-01-15T10:30:00Z",
    creatingApplication: "xeokit-convert v1.3.2",
    schema: "IFC4",
    edgeThreshold: 10,
    minTileSize: 500,
    maxIndicesForEdge: 10000,
    modelAABB: new Float64Array([0, 0, 0, 100, 100, 100])
});
```

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

### Unsupported CommonJS Import (import)

Source: https://github.com/xeokit/xeokit-convert/blob/main/CHANGELOG.md

This import pattern using 'import' for CommonJS modules is no longer supported starting from version 1.2.0.

```javascript
import { XKT_INFO } from "./dist/xeokit-convert.cjs.js";
```

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

### xeokit-convert Quick Reference Card

Source: https://github.com/xeokit/xeokit-convert/blob/main/_autodocs/INDEX.md

Illustrates the primary workflows for parsing different file formats (glTF/GLB, IFC, LAS/LAZ, STL/PLY/PCD, CityJSON) into XKT models, creating geometries and entities, and exporting the XKT model to an array buffer.

```text
IMPORT          PARSE            CREATE              EXPORT
─────────────────────────────────────────────────────────────
┌─────────────┐
│ glTF/GLB    │ → parseGLTFIntoXKTModel() ──┐
│ IFC         │ → parseIFCIntoXKTModel()    │
│ LAS/LAZ     │ → parseLASIntoXKTModel()    │
│ STL/PLY/PCD │ → parseSTLIntoXKTModel()    │
│ CityJSON    │ → parseCityJSONIntoXKTModel()
└─────────────┘                              │
     OR                                       ├→ XKTModel {
     CREATE                                   │
┌──────────────────┐                          │  createGeometry()
│ buildBoxGeometry │                          │  createMesh()
│ buildSphere...   │                          │  createEntity()
│ buildCylinder... │ → create*() methods ─────┤  createTexture()
│ etc.             │                          │  createMetaObject()
└──────────────────┘                          │  createPropertySet()
                                              │  finalize()
                                              │ }
                                              │
                                              └→ writeXKTModelToArrayBuffer()
                                                 ↓
                                              .xkt file
```

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

### Query XKT Version in Node.js

Source: https://github.com/xeokit/xeokit-convert/blob/main/README.md

Retrieves the current XKT version generated by xeokit-convert within a Node.js script. Requires the xeokit-convert package to be installed.

```javascript
import { XKT_INFO } from '@xeokit/xeokit-convert';

const xktVersion = XKT_INFO.xktVersion; // Unsigned integer
console.log(`XKT version: ${xktVersion}`);
```

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

### Load XKT into xeokit Viewer

Source: https://github.com/xeokit/xeokit-convert/blob/main/_autodocs/api-reference/serialization.md

Demonstrates how to load a serialized XKT file into an xeokit viewer instance in a browser environment. Ensure the viewer is initialized and the XKT file is accessible via its source path.

```javascript
import { Viewer } from "@xeokit/xeokit-sdk";

// In browser after XKT export
const viewer = new Viewer({
    container: "myCanvas"
});

// Load the XKT file
viewer.scene.load({
    src: "model.xkt"
}).then(model => {
    console.log("Model loaded:", model.id);
    viewer.cameraControl.zoomToFit();
});
```

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

### Get XKT Format Version

Source: https://github.com/xeokit/xeokit-convert/blob/main/_autodocs/cli-reference.md

This command retrieves the XKT format version used during conversion. It helps in understanding the compatibility of the output with different viewers or tools.

```bash
convert2xkt --input model.ifc --output model.xkt --log
# [xeokit-convert] XKT version: 12
```

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

### Instantiate XKTModel

Source: https://github.com/xeokit/xeokit-convert/blob/main/_autodocs/api-reference/xktmodel.md

Create a new XKTModel instance with custom configuration options. Useful for programmatically building XKT files or setting specific model properties upon creation.

```javascript
const xktModel = new XKTModel({
    modelId: "my_model",
    projectId: "proj_123",
    author: "John Doe",
    schema: "IFC4",
    edgeThreshold: 10,
    minTileSize: 500
});
```

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

### Convert GLB to XKT with Options using CLI

Source: https://github.com/xeokit/xeokit-convert/blob/main/_autodocs/api-reference/serialization.md

This command converts a GLB file to XKT format and applies specific conversion options like `--minTileSize` and `--edgeThreshold`.

```bash
# Convert with options
node convert2xkt.js \
    --input model.glb \
    --output model.xkt \
    --minTileSize 1000 \
    --edgeThreshold 5
```

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

### Basic IFC Import to XKTModel

Source: https://github.com/xeokit/xeokit-convert/blob/main/_autodocs/README.md

Demonstrates how to import an IFC file into an XKTModel using the xeokit-convert library. Ensure WebIFC is imported and the wasmPath is correctly configured.

```javascript
import * as WebIFC from "web-ifc";
import { XKTModel, parseIFCIntoXKTModel, writeXKTModelToArrayBuffer } from "@xeokit/xeokit-convert";

const xktModel = new XKTModel({ modelId: "rac_advanced" });
const ifcData = await fetch("rac_advanced_sample_project.ifc").then(r => r.arrayBuffer());

await parseIFCIntoXKTModel({
    WebIFC: WebIFC,
    data: ifcData,
    xktModel: xktModel,
    wasmPath: "/wasm/",
    log: msg => console.log(msg)
});

await xktModel.finalize();
const xktBuffer = writeXKTModelToArrayBuffer(xktModel);
```

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

### Define Geometry Positions Portions

Source: https://github.com/xeokit/xeokit-convert/blob/main/specs/xkt_10_generationNotes.md

An array indicating the start index for each XKTGeometry's positions within the main positions array. This defines the boundaries of position data for each geometry.

```plaintext
eachGeometryPositionsPortion = [
   0, // XKTGeometry A has 3 positions, in elements [0-8]
   9, // XKTGeometry B has 5 positions, in elements [9-23]
   23 // XKTGeometry C has 4 positions in elements [23-35] (the rest of the positions array)
]
```

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

### Example XKT Geometry Positions Data

Source: https://github.com/xeokit/xeokit-convert/blob/main/specs/xkt_10_generationNotes.md

Illustrates the structure of the 'positions' array, showing concatenated vertex positions for multiple geometries. Each set of three numbers represents the X, Y, and Z coordinates of a vertex.

```plaintext
positions= [ // Some random positions

   24567, 31234, 17654, // XKTGeometry A
   43210, 19876, 28765,
   15043, 23456, 56789,

   21987, 30567, 12345, // XKTGeometry B
   20876, 29487, 16987,
   45678, 54321, 32109,
   87654, 98765, 65432,
   78901, 87654, 54321,

   98765, 87654, 10987, // XKTGeometry C
   54321, 65432, 23456,
   12345, 23456, 34567,
   65432, 76543, 87654  
]
```

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

### Convert Split GLB/JSON to XKT Files

Source: https://github.com/xeokit/xeokit-convert/blob/main/README.md

Convert the generated GLB and JSON files into XKT format using convert2xkt. Point to the manifest file created by cxconverter with the -a option.

```bash
node convert2xkt.js -a myGLBFiles/model.glb.manifest.json -o myXKTFiles -l
```

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

### Large IFC to XKT with Optimization and Filtering

Source: https://github.com/xeokit/xeokit-convert/blob/main/_autodocs/cli-reference.md

Convert a large IFC model to XKT with advanced optimization techniques, including minimum tile size and edge threshold, along with type filtering and zipping. Logging is enabled for monitoring the process.

```bash
convert2xkt \
    --input large_model.ifc \
    --output large_model.xkt \
    --minTileSize 1000 \
    --edgeThreshold 20 \
    --includeTypes "IfcWall,IfcDoor" \
    --zip true \
    --log
```

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

### Batch Convert IFC to XKT (Node.js Script)

Source: https://github.com/xeokit/xeokit-convert/blob/main/_autodocs/cli-reference.md

A Node.js script to perform batch conversions. It reads IFC files from an 'models' directory, converts them to XKT, and saves them in an 'xkt' directory. Requires `convert2xkt` to be installed and accessible.

```javascript
import { execSync } from "child_process";
import fs from "fs";
import path from "path";

const inputDir = "./models";
const outputDir = "./xkt";

if (!fs.existsSync(outputDir)) {
    fs.mkdirSync(outputDir, { recursive: true });
}

const files = fs.readdirSync(inputDir).filter(f => f.endsWith(".ifc"));

for (const file of files) {
    const inputPath = path.join(inputDir, file);
    const outputPath = path.join(outputDir, file.replace(".ifc", ".xkt"));
    
    console.log(`Converting ${file}...`);
    
    try {
        execSync(`convert2xkt --input "${inputPath}" --output "${outputPath}" --log`, {
            stdio: "inherit"
        });
        console.log(`✓ Success\n`);
    } catch (error) {
        console.error(`✗ Failed\n`);
    }
}
```

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

### Define Geometry Normals Portions

Source: https://github.com/xeokit/xeokit-convert/blob/main/specs/xkt_10_generationNotes.md

An array indicating the start index for each XKTGeometry's normals within the main normals array. This defines the boundaries of normal data for each geometry. A zero-length portion is indicated by consecutive entries having the same value.

```plaintext
eachGeometryNormalsPortion = [
   0, // XKTGeometry A has 3 normals, in elements [0-8]
   9, // XKTGeometry B has 0 normals
   9 // XKTGeometry C has 4 normals in elements [9-20]
]
```

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

### buildGridGeometry(cfg)

Source: https://github.com/xeokit/xeokit-convert/blob/main/_autodocs/api-reference/geometry-builders.md

Creates a 2D grid of lines, useful for reference planes in 3D scenes.

```APIDOC
## buildGridGeometry(cfg)

### Description
Creates a 2D grid of lines (useful for reference planes).

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
- **cfg** (object) - Required - Configuration object
  - **cfg.size** (number) - Optional - Grid size (extends from -size/2 to +size/2). Defaults to `1`.
  - **cfg.divisions** (number) - Optional - Number of grid lines in each direction. Defaults to `1`.

### Request Example
```javascript
const grid = buildGridGeometry({
    size: 10,
    divisions: 10
});
```

### Response
#### Success Response
Grid geometry with line segments (`primitiveType: "lines"`)
```

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

### Import XKTModel

Source: https://github.com/xeokit/xeokit-convert/blob/main/_autodocs/api-reference/xktmodel.md

Import the XKTModel class from the xeokit-convert library. This is the first step to using the class.

```javascript
import { XKTModel } from "@xeokit/xeokit-convert";
```

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

### Import Geometry Builders

Source: https://github.com/xeokit/xeokit-convert/blob/main/_autodocs/api-reference/geometry-builders.md

Import all available geometry builder functions from the xeokit-convert library.

```javascript
import {
    buildBoxGeometry,
    buildBoxLinesGeometry,
    buildSphereGeometry,
    buildCylinderGeometry,
    buildPlaneGeometry,
    buildTorusGeometry,
    buildGridGeometry,
    buildVectorTextGeometry
} from "@xeokit/xeokit-convert";
```

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

### Create Mesh from Grid Geometry

Source: https://github.com/xeokit/xeokit-convert/blob/main/_autodocs/api-reference/geometry-builders.md

Demonstrates how to create a mesh using the geometry generated by buildGridGeometry. This involves creating the geometry object and then the mesh object with specified properties.

```javascript
const grid = buildGridGeometry({ size: 10, divisions: 10 });

const geometry = xktModel.createGeometry({
    geometryId: "grid",
    primitiveType: grid.primitiveType,
    positions: grid.positions,
    indices: grid.indices
});

const mesh = xktModel.createMesh({
    meshId: "gridMesh",
    geometryId: "grid",
    color: [0.5, 0.5, 0.5]
});
```

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

### XKTModel Constructor

Source: https://github.com/xeokit/xeokit-convert/blob/main/_autodocs/api-reference/xktmodel.md

Creates a new XKTModel instance with optional configuration parameters.

```APIDOC
## new XKTModel(cfg)

### Description
Creates a new XKTModel instance.

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
* **cfg** (object) - Optional - Configuration object
    * **modelId** (string) - Optional - Unique identifier for this model. Defaults to "default".
    * **projectId** (string) - Optional - Project identifier if available. Defaults to "".
    * **revisionId** (string) - Optional - Revision identifier if available. Defaults to "".
    * **author** (string) - Optional - Model author name. Defaults to "".
    * **createdAt** (string) - Optional - Creation date/time string. Defaults to "".
    * **creatingApplication** (string) - Optional - Application that created the model. Defaults to "".
    * **schema** (string) - Optional - Model schema version (e.g., "IFC2x3", "IFC4"). Defaults to "".
    * **edgeThreshold** (number) - Optional - Edge triangle count threshold for edge detection. Defaults to 10.
    * **minTileSize** (number) - Optional - Minimum diagonal size of tile boundary. Defaults to 500.
    * **maxIndicesForEdge** (number) - Optional - Maximum triangle indices for edge computation.
    * **modelAABB** (Float64Array) - Optional - Optional overall AABB for split-model alignment.

### Request Example
```javascript
const xktModel = new XKTModel({
    modelId: "my_model",
    projectId: "proj_123",
    author: "John Doe",
    schema: "IFC4",
    edgeThreshold: 10,
    minTileSize: 500
});
```

### Response
#### Success Response (200)
An instance of XKTModel.

#### Response Example
```json
{
  "example": "XKTModel instance"
}
```
```

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

### Basic glTF to XKT Conversion

Source: https://github.com/xeokit/xeokit-convert/blob/main/_autodocs/cli-reference.md

Use this command to perform a basic conversion of a glTF model to XKT format. Ensure the input file is in glTF format.

```bash
convert2xkt --input model.glb --output model.xkt
```

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

### Build Cone Geometry

Source: https://github.com/xeokit/xeokit-convert/blob/main/_autodocs/api-reference/geometry-builders.md

Creates a cone by setting the top radius to zero. Use this to generate a 3D cone mesh.

```javascript
const cone = buildCylinderGeometry({
    radiusTop: 0,
    radiusBottom: 1,
    height: 2,
    radialSegments: 24
});
```

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

### XKTTextureSet Creation

Source: https://github.com/xeokit/xeokit-convert/blob/main/_autodocs/api-reference/model-classes.md

Demonstrates how to create an XKTTextureSet instance using the xktModel.createTextureSet method. This method allows for the association of different texture types with a unique texture set ID.

```APIDOC
## createTextureSet

### Description
Creates a new XKTTextureSet, which is a container for multiple textures defining a PBR material.

### Method
```javascript
xktModel.createTextureSet(cfg)
```

### Parameters
#### Object Parameters
- **cfg** (object) - Configuration object for the texture set.
  - **textureSetId** (string) - Unique identifier for the texture set.
  - **colorTextureId** (string) - ID of the base color/diffuse texture.
  - **metallicRoughnessTextureId** (string) - ID of the metallic/roughness map.
  - **normalsTextureId** (string) - ID of the normal map.
  - **emissiveTextureId** (string) - ID of the emissive/self-illumination texture.
  - **occlusionTextureId** (string) - ID of the ambient occlusion texture.

### Returns
- **XKTTextureSet** - The newly created XKTTextureSet instance.
```

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

### Node.js Conversion with Environment Variables

Source: https://github.com/xeokit/xeokit-convert/blob/main/_autodocs/configuration.md

Configure conversion settings like log level and WASM path using environment variables when running the Node.js script.

```bash
XEOKIT_LOG_LEVEL=debug \
XEOKIT_WASM_PATH=/path/to/wasm/ \
node convert2xkt.js --input model.ifc --output model.xkt
```

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

### Create Default Meta Objects

Source: https://github.com/xeokit/xeokit-convert/blob/main/_autodocs/api-reference/xktmodel.md

Automatically creates default XKTMetaObject entries for any XKTEntity that does not already have one. This method must be called before finalizing the model.

```javascript
xktModel.createDefaultMetaObjects();
```

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

### xeokit-convert Document Relationship Map

Source: https://github.com/xeokit/xeokit-convert/blob/main/_autodocs/INDEX.md

Visualizes the relationship between the main README and other documentation files within the xeokit-convert project.

```markdown
README.md (Overview)
├── xktmodel.md (Main API)
│   ├── model-classes.md (Data structures)
│   ├── serialization.md (Export)
│   └── types.md (Type reference)
├── parsers.md (Import)
├── geometry-builders.md (Procedural generation)
├── configuration.md (Settings & tuning)
└── cli-reference.md (Command-line tool)
└── types.md (Types & constants)
```

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

### Enable Buffer Compression

Source: https://github.com/xeokit/xeokit-convert/blob/main/README.md

Use the -b option with the convert2xkt.js script to maintain the old behavior of compressing buffers. For newer versions, native webserver/browser compression (gzip) is recommended.

```bash
node convert2xkt.js -a manifest.json -o model.xkt -b
```

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

### Basic Node.js Direct Execution

Source: https://github.com/xeokit/xeokit-convert/blob/main/_autodocs/cli-reference.md

Execute the convert2xkt.js script directly using Node.js, specifying the path to the script.

```bash
node /path/to/xeokit-convert/convert2xkt.js [options]
```

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

### XKTModelConfig

Source: https://github.com/xeokit/xeokit-convert/blob/main/_autodocs/types.md

Configuration object for initializing a new XKTModel.

```APIDOC
## XKTModelConfig

### Description
Configuration object for `new XKTModel(cfg)`.

### Parameters
#### Properties
- **modelId** (string) - Optional - Defaults to "default"
- **projectId** (string) - Optional - Defaults to ""
- **revisionId** (string) - Optional - Defaults to ""
- **author** (string) - Optional - Defaults to ""
- **createdAt** (string) - Optional - Defaults to ""
- **creatingApplication** (string) - Optional - Defaults to ""
- **schema** (string) - Optional - Defaults to ""
- **edgeThreshold** (number) - Optional - Defaults to 10
- **minTileSize** (number) - Optional - Defaults to 500
- **maxIndicesForEdge** (number) - Optional
- **modelAABB** (Float64Array) - Optional
```

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

### Main Exports from xeokit-convert

Source: https://github.com/xeokit/xeokit-convert/blob/main/_autodocs/README.md

Lists the primary classes, parsers, builders, serialization functions, and constants exported by the xeokit-convert project.

```javascript
// Classes
export { XKTModel }
export { XKTEntity, XKTMesh, XKTGeometry, XKTTile, XKTMetaObject, XKTPropertySet, XKTTexture, XKTTextureSet }

// Parsers
export { parseGLTFIntoXKTModel, parseIFCIntoXKTModel, parseLASIntoXKTModel, ... }

// Builders
export { buildBoxGeometry, buildSphereGeometry, buildCylinderGeometry, ... }

// Serialization
export { writeXKTModelToArrayBuffer }

// Info & Constants
export { XKT_INFO }
export { RepeatWrapping, ClampToEdgeWrapping, LinearFilter, ... }
```

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

### High-Quality Texture Settings

Source: https://github.com/xeokit/xeokit-convert/blob/main/_autodocs/configuration.md

Configure textures for high quality and memory optimization using KTX2 compression. Recommended for color and normal maps.

```javascript
// Color/diffuse texture
const colorTex = xktModel.createTexture({
    textureId: "color_1",
    imageData: colorData,
    width: 2048,
    height: 2048,
    compressed: true,  // KTX2 compression
    minFilter: LinearMipmapLinearFilter,
    magFilter: LinearFilter
});

// Normal map (no sRGB compression)
const normalTex = xktModel.createTexture({
    textureId: "normal_1",
    imageData: normalData,
    width: 2048,
    height: 2048,
    compressed: true,  // Still compress, but UASTC quality adjusted
    minFilter: LinearMipmapLinearFilter
});

// Metallic/roughness (single channel sufficient)
const mrTex = xktModel.createTexture({
    textureId: "mr_1",
    imageData: mrData,
    width: 1024,  // Can be lower resolution
    height: 1024,
    compressed: true,
    minFilter: LinearMipmapNearestFilter
});
```

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

### Batch Convert IFC to XKT (Linux/macOS Shell Script)

Source: https://github.com/xeokit/xeokit-convert/blob/main/_autodocs/cli-reference.md

Use this shell script to iterate through all .ifc files in the current directory and convert them to .xkt format using the `convert2xkt` command. It includes basic success/failure logging.

```bash
#!/bin/bash

for ifc_file in *.ifc; do
    xkt_file="${ifc_file%.ifc}.xkt"
    echo "Converting $ifc_file → $xkt_file"
    convert2xkt \
        --input "$ifc_file" \
        --output "$xkt_file" \
        --wasmPath ./web-ifc/ \
        --log
    if [ $? -eq 0 ]; then
        echo "✓ Success"
    else
        echo "✗ Failed"
    fi
done
```

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

### Create XKTTextureSet

Source: https://github.com/xeokit/xeokit-convert/blob/main/_autodocs/api-reference/model-classes.md

Creates a new XKTTextureSet to group multiple textures for a PBR material. Requires an XKTModel instance.

```javascript
const textureSet = xktModel.createTextureSet({
    textureSetId: "material_1",
    colorTextureId: "texture_color",
    metallicRoughnessTextureId: "texture_mr",
    normalsTextureId: "texture_normal",
    emissiveTextureId: "texture_emissive",
    occlusionTextureId: "texture_occlusion"
});
```

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

### IFC to XKT with Logging and WASM Path

Source: https://github.com/xeokit/xeokit-convert/blob/main/_autodocs/cli-reference.md

Convert an IFC file to XKT, enabling logging and specifying the path to the WebAssembly module. This is useful for debugging and performance analysis.

```bash
convert2xkt \
    --input rac_advanced_sample_project.ifc \
    --output model.xkt \
    --wasmPath ./node_modules/web-ifc/dist/ \
    --log
```

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

### XKTModel Configuration Object

Source: https://github.com/xeokit/xeokit-convert/blob/main/_autodocs/types.md

Configuration object for initializing a new XKTModel. Defaults are provided for most properties.

```javascript
{
    modelId?: string = "default",
    projectId?: string = "",
    revisionId?: string = "",
    author?: string = "",
    createdAt?: string = "",
    creatingApplication?: string = "",
    schema?: string = "",
    edgeThreshold?: number = 10,
    minTileSize?: number = 500,
    maxIndicesForEdge?: number,
    modelAABB?: Float64Array
}
```
Tokens:
Raw