Model Converter

Converts model data using registered loaders, exporters, and named pipelines.

Shape

classDiagram
    direction TB
    class ModelConverter {
      +loaders   : Map~id, ModelLoader~
      +exporters : Map~id, ModelExporter~
      +pipelines : Map~id, Pipeline~
      +convert(request) Promise~ModelConverterResult~
    }
    class ModelConverterParams {
      +loaders
      +exporters
      +pipelines
    }
    class ModelConverterRequest {
      +pipeline   : string
      +inputs     : Map
      +outputs    : Map
      +reports?   : Map
    }
    class ModelConverterResult {
      +outputs    : Map
      +inspection? : ModelConverterInspectionReport
      +manifest?   : ModelConverterManifestReport
      +stats?      : ModelConverterStatsReport
    }
    class ModelLoader {
      <<formats>>
    }
    class ModelExporter {
      <<formats>>
    }
    ModelConverter ..> ModelConverterParams : constructor
    ModelConverter ..> ModelConverterRequest : convert
    ModelConverter ..> ModelConverterResult : returns
    ModelConverter "1" *-- "*" ModelLoader
    ModelConverter "1" *-- "*" ModelExporter

Components

• ModelLoaders parse input formats into scene and data models.
• ModelExporters write output formats from those models.
• Pipelines map input ids to loader ids and output ids to exporter ids.
• Optional reports include inspection, manifest, stats, optimization, and conversion details.
• The xeoconvert CLI uses the same converter.

Installation

npm install @xeokit/sdk
Copy

Usage

Configure ModelConverter with ModelConverterParams:

• loaders: a map of loader instances (keyed by id)
• exporters: a map of exporter instances (keyed by id)
• pipelines: a map of pipeline configs (keyed by pipeline id)

outputs and reports in ModelConverterRequest are currently required by the type, but the converter does not write files to disk. Converted data is returned on ModelConverterResult.outputs.

DotBIM to XGF and DataModelParams JSON

Imports

import { readFile, writeFile } from "fs/promises";

import { ModelConverter, type ModelConverterRequest } from "@xeokit/sdk/convert/modelConverter";
import { DotBIMLoader } from "@xeokit/sdk/formats/dotbim";
import { XGFExporter } from "@xeokit/sdk/formats/xgf";
import { DataModelExporter } from "@xeokit/sdk/model/data";
Copy

Converter setup

This pipeline reads a DotBIM input and returns XGF plus DataModelParams JSON outputs.

const modelConverter = new ModelConverter({
  loaders: {
    dotbim: new DotBIMLoader()
  },
  exporters: {
    xgf: new XGFExporter(),
    datamodel: new DataModelExporter()
  },
  pipelines: {
    dotbim2xgf: {
      inputs: {
        dotbim: {
          loader: "dotbim",
          options: {}
        }
      },
      outputs: {
        xgf: {
          exporter: "xgf",
          version: "1.0",
          options: {}
        },
        datamodel: {
          exporter: "datamodel",
          version: "1.0",
          options: {}
        }
      }
    }
  }
});
Copy

Conversion

Inputs can use fileData or filePath. Outputs are returned in result.outputs.

const dotBIMFileData = JSON.parse(await readFile("model.bim", "utf-8"));

const request: ModelConverterRequest = {
  pipeline: "dotbim2xgf",
  inputs: {
    dotbim: { fileData: dotBIMFileData }
    // Alternative:
    // dotbim: { filePath: "model.bim" }
  }
};

const result = await modelConverter.convert(request);

const xgfOutput = result.outputs.xgf;
const datamodelOutput = result.outputs.datamodel;

await writeFile("model.xgf", xgfOutput.fileData);

await writeFile("model.json", JSON.stringify(datamodelOutput.fileData, null, 2), "utf-8");
Copy

XGF and DataModelParams JSON to DotBIM

Imports

import { readFile, writeFile } from "fs/promises";

import { ModelConverter, type ModelConverterRequest } from "@xeokit/sdk/convert/modelConverter";
import { DotBIMExporter } from "@xeokit/sdk/formats/dotbim";
import { XGFLoader } from "@xeokit/sdk/formats/xgf";
import { DataModelImporter } from "@xeokit/sdk/model/data";
Copy

Converter setup

This pipeline reads XGF and DataModelParams inputs, then exports DotBIM.

const modelConverter = new ModelConverter({
  loaders: {
    xgf: new XGFLoader(),
    datamodel: new DataModelImporter()
  },
  exporters: {
    dotbim: new DotBIMExporter()
  },
  pipelines: {
    xgf2dotbim: {
      inputs: {
        xgf: {
          loader: "xgf",
          sceneModel: "mySceneModel",
          options: {}
        },
        datamodel: {
          loader: "datamodel",
          dataModel: "myDataModel",
          options: {}
        }
      },
      outputs: {
        dotbim: {
          exporter: "dotbim",
          sceneModel: "mySceneModel",
          dataModel: "myDataModel",
          version: "1.1",
          options: {}
        }
      }
    }
  }
});
Copy

Conversion

const xgfFileData = await readFile("model.xgf");
const datamodelFileData = JSON.parse(await readFile("model.json", "utf-8"));

const request: ModelConverterRequest = {
  pipeline: "xgf2dotbim",
  inputs: {
    xgf: { fileData: xgfFileData },
    datamodel: { fileData: datamodelFileData }
  }
};

const result = await modelConverter.convert(request);

await writeFile("model.bim", result.outputs.dotbim.fileData, "utf-8");
Copy

Shared Models Across Inputs and Outputs

Use sceneModel / dataModel ids to make multiple inputs populate the same models, and multiple outputs export from those same models.

import type { ModelConverterRequest } from "@xeokit/sdk/convert/modelConverter";

const modelConverter = new ModelConverter({
  loaders: {
    xgf: new XGFLoader(),
    datamodel: new DataModelImporter()
  },
  exporters: {
    xgf: new XGFExporter(),
    datamodel: new DataModelExporter()
  },
  pipelines: {
    roundTripLike: {
      inputs: {
        geom:   { loader: "xgf", sceneModel: "main", dataModel: "main" },
        props:  { loader: "datamodel", dataModel: "main" }
      },
      outputs: {
        outGeom:  { exporter: "xgf", sceneModel: "main", dataModel: "main", version: "1.0" },
        outProps: { exporter: "datamodel", dataModel: "main", version: "1.0" }
      }
    }
  }
});

const request: ModelConverterRequest = {
  pipeline: "roundTripLike",
  inputs: {
    geom:  { filePath: "model.xgf" },
    props: { filePath: "model.json" }
  }
};

const result = await modelConverter.convert(request);

await writeFile("out/model.xgf", result.outputs.outGeom.fileData);
await writeFile("out/model.json", JSON.stringify(result.outputs.outProps.fileData, null, 2), "utf-8");
Copy