LegacyAsciiParser

Source

index.js
import vtkDataArray from 'vtk.js/Sources/Common/Core/DataArray';
import vtkPolyData from 'vtk.js/Sources/Common/DataModel/PolyData';

const METHOD_MAPPING = {
POINTS: 'getPoints',
VERTICES: 'getVerts',
LINES: 'getLines',
TRIANGLE_STRIPS: 'getStrips',
POLYGONS: 'getPolys',
POINT_DATA: 'getPointData',
CELL_DATA: 'getCellData',
FIELD: 'getFieldData',
};

const DATATYPES = {
bit: Uint8Array,
unsigned_char: Uint8Array,
char: Int8Array,
unsigned_short: Uint16Array,
short: Int16Array,
unsigned_int: Uint32Array,
int: Int32Array,
unsigned_long: Uint32Array,
long: Int32Array,
float: Float32Array,
double: Float64Array,
};

const REGISTER_MAPPING = {
SCALARS: 'addArray',
COLOR_SCALARS: 'addArray',
VECTORS: 'setVectors',
NORMALS: 'setNormals',
TEXTURE_COORDINATES: 'setTCoords',
TENSORS: 'setTensors',
FIELD: 'addArray',
};

function createArrayHandler(array, setData, nbComponents) {
let offset = 0;

function fillWith(line) {
line.split(' ').forEach((token) => {
if (token.length) {
array[offset++] = Number(token);
}
});
if (offset < array.length) {
return true;
}
setData(array, nbComponents);
return false;
}

return fillWith;
}

const GENERIC_CELL_HANDLER = {
init(line, dataModel) {
const [name, nbCells, nbValues] = line.split(' ');
const cellArray = dataModel.dataset[METHOD_MAPPING[name]]();
cellArray.set({ numberOfCells: Number(nbCells) }, true); // Force numberOfCells update
dataModel.arrayHandler = createArrayHandler(
new Uint32Array(Number(nbValues)),
cellArray.setData,
1
);
return true;
},
parse(line, dataModel) {
return dataModel.arrayHandler(line);
},
};

const TYPE_PARSER = {
DATASET: {
init(line, datamodel) {
const type = line.split(' ')[1];
switch (type) {
case 'POLYDATA':
datamodel.dataset = vtkPolyData.newInstance();
break;
default:
console.error(`Dataset of type ${type} not supported`);
}
return false;
},
parse(line, datamodel) {
return false;
},
},
POINTS: {
init(line, dataModel) {
const [name, size, type] = line.split(' ');
const array =
type === 'float'
? new Float32Array(3 * Number(size))
: new Float64Array(3 * Number(size));
const dataArray = dataModel.dataset.getPoints();
dataArray.setName(name);
dataModel.arrayHandler = createArrayHandler(array, dataArray.setData, 3);
return true;
},
parse(line, dataModel) {
return dataModel.arrayHandler(line);
},
},
METADATA: {
init(line, dataModel) {
return true;
},
parse(line, dataModel) {
return !!line.length;
},
},
VERTICES: GENERIC_CELL_HANDLER,
LINES: GENERIC_CELL_HANDLER,
TRIANGLE_STRIPS: GENERIC_CELL_HANDLER,
POLYGONS: GENERIC_CELL_HANDLER,
POINT_DATA: {
init(line, dataModel) {
dataModel.POINT_DATA = Number(line.split(' ')[1]);
dataModel.activeFieldLocation = 'POINT_DATA';
return false;
},
parse(line, dataModel) {
return false;
},
},
CELL_DATA: {
init(line, dataModel) {
dataModel.CELL_DATA = Number(line.split(' ')[1]);
dataModel.activeFieldLocation = 'CELL_DATA';
return false;
},
parse(line, dataModel) {
return false;
},
},
SCALARS: {
init(line, dataModel) {
const [type, name, dataType, numComp] = line.split(' ');
const size = dataModel[dataModel.activeFieldLocation] * Number(numComp);
const array = new DATATYPES[dataType](size);
const dataArray = vtkDataArray.newInstance({ name, empty: true });
dataModel.dataset[METHOD_MAPPING[dataModel.activeFieldLocation]]()[
REGISTER_MAPPING[type]
](dataArray);
dataModel.arrayHandler = createArrayHandler(
array,
dataArray.setData,
Number(numComp)
);
return true;
},
parse(line, dataModel) {
if (line.split(' ')[0] === 'LOOKUP_TABLE') {
return true;
}
return dataModel.arrayHandler(line);
},
},
COLOR_SCALARS: {
init(line, dataModel) {
const [type, name, numComp] = line.split(' ');
const size = dataModel[dataModel.activeFieldLocation] * Number(numComp);
const array = new Uint8Array(size);
const dataArray = vtkDataArray.newInstance({ name, empty: true });
dataModel.dataset[METHOD_MAPPING[dataModel.activeFieldLocation]]()[
REGISTER_MAPPING[type]
](dataArray);
dataModel.arrayHandler = createArrayHandler(
array,
dataArray.setData,
Number(numComp)
);
return true;
},
parse(line, dataModel) {
if (line.split(' ')[0] === 'LOOKUP_TABLE') {
return true;
}
return dataModel.arrayHandler(line);
},
},
VECTORS: {
init(line, dataModel) {
const [type, name, dataType] = line.split(' ');
const size = dataModel[dataModel.activeFieldLocation] * 3;
const array = new DATATYPES[dataType](size);
const dataArray = vtkDataArray.newInstance({ name, empty: true });
dataModel.dataset[METHOD_MAPPING[dataModel.activeFieldLocation]]()[
REGISTER_MAPPING[type]
](dataArray);
dataModel.arrayHandler = createArrayHandler(array, dataArray.setData, 3);
return true;
},
parse(line, dataModel) {
return dataModel.arrayHandler(line);
},
},
NORMALS: {
init(line, dataModel) {
const [type, name] = line.split(' ');
const size = dataModel[dataModel.activeFieldLocation] * 3;
const array = new Float32Array(size);
const dataArray = vtkDataArray.newInstance({ name, empty: true });
dataModel.dataset[METHOD_MAPPING[dataModel.activeFieldLocation]]()[
REGISTER_MAPPING[type]
](dataArray);
dataModel.arrayHandler = createArrayHandler(array, dataArray.setData, 3);
return true;
},
parse(line, dataModel) {
return dataModel.arrayHandler(line);
},
},
TEXTURE_COORDINATES: {
init(line, dataModel) {
const [type, name, numberOfComponents, dataType] = line.split(' ');
const size =
dataModel[dataModel.activeFieldLocation] * Number(numberOfComponents);
const array = new DATATYPES[dataType](size);
const dataArray = vtkDataArray.newInstance({ name, empty: true });
dataModel.dataset[METHOD_MAPPING[dataModel.activeFieldLocation]]()[
REGISTER_MAPPING[type]
](dataArray);
dataModel.arrayHandler = createArrayHandler(array, dataArray.setData, 3);
return true;
},
parse(line, dataModel) {
return dataModel.arrayHandler(line);
},
},
TENSORS: {
init(line, dataModel) {
const [type, name, dataType] = line.split(' ');
const size = dataModel[dataModel.activeFieldLocation] * 9;
const array = new DATATYPES[dataType](size);
const dataArray = vtkDataArray.newInstance({ name, empty: true });
dataModel.dataset[METHOD_MAPPING[dataModel.activeFieldLocation]]()[
REGISTER_MAPPING[type]
](dataArray);
dataModel.arrayHandler = createArrayHandler(array, dataArray.setData, 9);
return true;
},
parse(line, dataModel) {
return dataModel.arrayHandler(line);
},
},
};

function getParser(line, dataModel) {
const tokens = line.split(' ');
return TYPE_PARSER[tokens[0]];
}

function parseLegacyASCII(content, dataModel = {}) {
let parser = null;
const separatorRegExp = /\r?\n/;
const separatorRes = separatorRegExp.exec(content);
const separator = separatorRes !== null ? separatorRes[0] : null;
content.split(separator).forEach((line, index) => {
if (index < 2) {
return;
}
if (!parser) {
parser = getParser(line, dataModel);
if (!parser) {
return;
}
parser = parser.init(line, dataModel) ? parser : null;
return;
}

if (parser && !parser.parse(line, dataModel)) {
parser = null;
}
});
return dataModel;
}

export default {
parseLegacyASCII,
};