STLWriter

Introduction

vtkSTLWriter writes stereo lithography (.stl) files in either ASCII or binary
form. Stereo lithography files contain only triangles. Since VTK 8.1, this
writer converts non-triangle polygons into triangles, so there is no longer a
need to use vtkTriangleFilter prior to using this writer if the input
contains polygons with more than three vertices.

Methods

extend

Method used to decorate a given object (publicAPI+model) with vtkSTLWriter characteristics.

Argument Type Required Description
publicAPI Yes object on which methods will be bounds (public)
model Yes object on which data structure will be bounds (protected)
initialValues ISTLWriterInitialValues No (default: {})

getFormat

getTransform

newInstance

Method used to create a new instance of vtkSTLWriter

Argument Type Required Description
initialValues ISTLWriterInitialValues No for pre-setting some of its content

requestData

Argument Type Required Description
inData Yes
outData Yes

setFormat

Argument Type Required Description
format Yes

setTransform

Argument Type Required Description
format Yes

writeSTL

Source

Constants.js
export const FormatTypes = {
ASCII: 'ascii',
BINARY: 'binary',
};

export default {
FormatTypes,
};
index.d.ts
import { mat4 } from "gl-matrix";
import vtkPolyData from "../../../Common/DataModel/PolyData";
import { vtkAlgorithm, vtkObject } from "../../../interfaces";

export enum FormatTypes {
ASCII,
BINARY
}

/**
*
*/
interface ISTLWriterInitialValues { }

type vtkSTLWriterBase = vtkObject & vtkAlgorithm;

export interface vtkSTLWriter extends vtkSTLWriterBase {

/**
*
*/
getFormat(): FormatTypes;

/**
*
*/
getTransform(): mat4;

/**
*
* @param inData
* @param outData
*/
requestData(inData: any, outData: any): void;

/**
*
* @param format
*/
setFormat(format: FormatTypes): boolean;

/**
*
* @param format
*/
setTransform(transform: mat4): boolean;
}

/**
* Method used to decorate a given object (publicAPI+model) with vtkSTLWriter characteristics.
*
* @param publicAPI object on which methods will be bounds (public)
* @param model object on which data structure will be bounds (protected)
* @param {ISTLWriterInitialValues} [initialValues] (default: {})
*/
export function extend(publicAPI: object, model: object, initialValues?: ISTLWriterInitialValues): void;

/**
* Method used to create a new instance of vtkSTLWriter
* @param {ISTLWriterInitialValues} [initialValues] for pre-setting some of its content
*/
export function newInstance(initialValues?: ISTLWriterInitialValues): vtkSTLWriter;

/**
*
*/
export function writeSTL(polyData: vtkPolyData, format?: FormatTypes, transform?: mat4): any;


/**
* vtkSTLWriter writes stereo lithography (.stl) files in either ASCII or binary
* form. Stereo lithography files contain only triangles. Since VTK 8.1, this
* writer converts non-triangle polygons into triangles, so there is no longer a
* need to use vtkTriangleFilter prior to using this writer if the input
* contains polygons with more than three vertices.
*/
export declare const vtkSTLWriter: {
newInstance: typeof newInstance;
extend: typeof extend;
writeSTL: typeof writeSTL;
}
export default vtkSTLWriter;
index.js
// @author: Thomas Beznik <thomas.beznik@relu.eu>, with the help of Julien Finet <julien.finet@kitware.com> (https://github.com/Kitware/vtk-js/issues/1442)
// and inspired from Paul Kaplan (https://gist.github.com/paulkaplan/6d5f0ab2c7e8fdc68a61).

import { vec3 } from 'gl-matrix';
import macro from 'vtk.js/Sources/macros';
import vtkTriangle from 'vtk.js/Sources/Common/DataModel/Triangle';
import { FormatTypes } from 'vtk.js/Sources/IO/Geometry/STLWriter/Constants';

const { vtkErrorMacro } = macro;

// ----------------------------------------------------------------------------
// Global methods
// ----------------------------------------------------------------------------

function writeFloatBinary(dataView, offset, float) {
dataView.setFloat32(offset, float.toPrecision(6), true);
return offset + 4;
}

function writeVectorBinary(dataView, offset, vector) {
let off = writeFloatBinary(dataView, offset, vector[0]);
off = writeFloatBinary(dataView, off, vector[1]);
return writeFloatBinary(dataView, off, vector[2]);
}

// ----------------------------------------------------------------------------
// vtkSTLWriter methods
// ----------------------------------------------------------------------------

const binaryWriter = () => {
let offset = 0;
let dataView = null;
return {
init: (polyData) => {
const polys = polyData.getPolys().getData();
const buffer = new ArrayBuffer(80 + 4 + (50 * polys.length) / 4); // buffer for the full file; size = header (80) + num cells (4) + 50 bytes per poly
dataView = new DataView(buffer);
},
writeHeader: (polyData) => {
offset += 80; // Header is empty // TODO: could add date, version, package

// First need to write the number of cells
dataView.setUint32(offset, polyData.getNumberOfCells(), true);
offset += 4;
},
writeTriangle: (v1, v2, v3, dn) => {
offset = writeVectorBinary(dataView, offset, dn);
offset = writeVectorBinary(dataView, offset, v1);
offset = writeVectorBinary(dataView, offset, v2);
offset = writeVectorBinary(dataView, offset, v3);
offset += 2; // unused 'attribute byte count' is a Uint16
},
writeFooter: (polyData) => {},
getOutputData: () => dataView,
};
};

const asciiWriter = () => {
let file = '';
return {
init: (polyData) => {},
writeHeader: (polyData) => {
file += 'solid ascii\n';
},
writeTriangle: (v1, v2, v3, dn) => {
file += ` facet normal ${dn[0].toPrecision(6)} ${dn[1].toPrecision(
6
)} ${dn[2].toPrecision(6)}\n`;
file += ' outer loop\n';
file += ` vertex ${v1[0].toPrecision(6)} ${v1[1].toPrecision(
6
)} ${v1[2].toPrecision(6)}\n`;
file += ` vertex ${v2[0].toPrecision(6)} ${v2[1].toPrecision(
6
)} ${v2[2].toPrecision(6)}\n`;
file += ` vertex ${v3[0].toPrecision(6)} ${v3[1].toPrecision(
6
)} ${v3[2].toPrecision(6)}\n`;
file += ' endloop\n';
file += ' endfacet\n';
},
writeFooter: (polyData) => {
file += 'endsolid\n';
},
getOutputData: () => file,
};
};

function writeSTL(polyData, format = FormatTypes.BINARY, transform = null) {
let writer = null;
if (format === FormatTypes.BINARY) {
writer = binaryWriter();
} else if (format === FormatTypes.ASCII) {
writer = asciiWriter();
} else {
vtkErrorMacro('Invalid format type');
}

writer.init(polyData);
writer.writeHeader(polyData);

const polys = polyData.getPolys().getData();
const points = polyData.getPoints().getData();
const strips = polyData.getStrips() ? polyData.getStrips().getData() : null;

const n = [];
let v1 = [];
let v2 = [];
let v3 = [];

// Strips
if (strips && strips.length > 0) {
throw new Error('Unsupported strips');
}

// Polys
for (let i = 0; i < polys.length; ) {
const pointNumber = polys[i++];

if (pointNumber) {
v1 = [
points[polys[i] * 3],
points[polys[i] * 3 + 1],
points[polys[i++] * 3 + 2],
];
v2 = [
points[polys[i] * 3],
points[polys[i] * 3 + 1],
points[polys[i++] * 3 + 2],
];
v3 = [
points[polys[i] * 3],
points[polys[i] * 3 + 1],
points[polys[i++] * 3 + 2],
];
if (transform) {
vec3.transformMat4(v1, v1, transform);
vec3.transformMat4(v2, v2, transform);
vec3.transformMat4(v3, v3, transform);
}

vtkTriangle.computeNormal(v1, v2, v3, n);

writer.writeTriangle(v1, v2, v3, n);
}
}
writer.writeFooter(polyData);
return writer.getOutputData();
}

// ----------------------------------------------------------------------------
// Static API
// ----------------------------------------------------------------------------

export const STATIC = {
writeSTL,
};

// ----------------------------------------------------------------------------
// vtkSTLWriter methods
// ----------------------------------------------------------------------------

function vtkSTLWriter(publicAPI, model) {
// Set our className
model.classHierarchy.push('vtkSTLWriter');

publicAPI.requestData = (inData, outData) => {
const input = inData[0];
if (!input || input.getClassName() !== 'vtkPolyData') {
vtkErrorMacro('Invalid or missing input');
return;
}
outData[0] = writeSTL(input, model.format, model.transform);
};
}

// ----------------------------------------------------------------------------
// Object factory
// ----------------------------------------------------------------------------

const DEFAULT_VALUES = {
format: FormatTypes.BINARY,
transform: null,
};

// ----------------------------------------------------------------------------

export function extend(publicAPI, model, initialValues = {}) {
Object.assign(model, DEFAULT_VALUES, initialValues);

// Make this a VTK object
macro.obj(publicAPI, model);

// Also make it an algorithm with one input and one output
macro.algo(publicAPI, model, 1, 1);

macro.setGet(publicAPI, model, ['format', 'transform']);

// Object specific methods
vtkSTLWriter(publicAPI, model);
}

// ----------------------------------------------------------------------------

export const newInstance = macro.newInstance(extend, 'vtkSTLWriter');

// ----------------------------------------------------------------------------

export default { newInstance, extend, ...STATIC };