StringArray

Introduction

Points and cells may sometimes have associated data that are stored as
strings, e.g. labels for information visualization projects. This class
provides a clean way to store and access those strings.

Methods

extend

Method used to decorate a given object (publicAPI+model) with vtkStringArray 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 IStringArrayInitialValues Yes (default: {})

getComponent

Get the data component at the location specified by tupleIdx and compIdx.

Argument Type Required Description
tupleIdx Number Yes
compIdx Number No

getData

getDataType

getName

getNumberOfComponents

getNumberOfTuples

getNumberOfValues

getTuple

Argument Type Required Description
idx Number Yes
tupleToFill Array. No

getTupleLocation

Argument Type Required Description
idx Number No

newClone

newInstance

Method used to create a new instance of vtkStringArray

Argument Type Required Description
initialValues IStringArrayInitialValues Yes for pre-setting some of its content

setComponent

Set the data component at the location specified by tupleIdx and compIdx
to value.
Note that i is less than NumberOfTuples and j is less than
NumberOfComponents. Make sure enough memory has been allocated
(use SetNumberOfTuples() and SetNumberOfComponents()).

Argument Type Required Description
tupleIdx Number Yes
compIdx Number Yes
value String Yes

setData

Argument Type Required Description
array Array. Yes
numberOfComponents Number Yes

setName

Source

index.d.ts
import { vtkObject } from '../../../interfaces';

/**
*
*/
export interface IStringArrayInitialValues {
name?: string;
numberOfComponents?: number;
size: number;
dataType?: string;
}

export interface vtkStringArray extends vtkObject {
/**
* Get the data component at the location specified by tupleIdx and compIdx.
* @param {Number} tupleIdx
* @param {Number} [compIdx]
*/
getComponent(tupleIdx: number, compIdx?: number): void;

/**
*
*/
getData(): string[];

/**
*
*/
getDataType(): string;

/**
*
*/
getName(): string;

/**
*
*/
getNumberOfComponents(): number;

/**
*
*/
getNumberOfValues(): number;

/**
*
*/
getNumberOfTuples(): number;

/**
*
* @param {Number} idx
* @param {String[]} [tupleToFill]
*/
getTuple(idx: number, tupleToFill?: string[]): string[];

/**
*
* @param {Number} [idx]
*/
getTupleLocation(idx?: number): number;

/**
*
*/
newClone(): void;

/**
* Set the data component at the location specified by tupleIdx and compIdx
* to value.
* Note that i is less than NumberOfTuples and j is less than
* NumberOfComponents. Make sure enough memory has been allocated
* (use SetNumberOfTuples() and SetNumberOfComponents()).
* @param {Number} tupleIdx
* @param {Number} compIdx
* @param {String} value
*/
setComponent(tupleIdx: number, compIdx: number, value: string): void;

/**
*
* @param {String[]} array
* @param {Number} numberOfComponents
*/
setData(array: string[], numberOfComponents: number): void;

/**
*
*/
setName(name: string): boolean;
}

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

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

/**
* Points and cells may sometimes have associated data that are stored as
* strings, e.g. labels for information visualization projects. This class
* provides a clean way to store and access those strings.
*/
export declare const vtkStringArray: {
newInstance: typeof newInstance;
extend: typeof extend;
};
export default vtkStringArray;
index.js
import macro from 'vtk.js/Sources/macros';

// ----------------------------------------------------------------------------
// vtkStringArray methods
// ----------------------------------------------------------------------------

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

// Description:
// Return the data component at the location specified by tupleIdx and
// compIdx.
publicAPI.getComponent = (tupleIdx, compIdx = 0) =>
model.values[tupleIdx * model.numberOfComponents + compIdx];

// Description:
// Set the data component at the location specified by tupleIdx and compIdx
// to value.
// Note that i is less than NumberOfTuples and j is less than
// NumberOfComponents. Make sure enough memory has been allocated
// (use SetNumberOfTuples() and SetNumberOfComponents()).
publicAPI.setComponent = (tupleIdx, compIdx, value) => {
if (value !== model.values[tupleIdx * model.numberOfComponents + compIdx]) {
model.values[tupleIdx * model.numberOfComponents + compIdx] = value;
publicAPI.modified();
}
};

publicAPI.getData = () => model.values;

publicAPI.getTuple = (idx, tupleToFill = []) => {
const numberOfComponents = model.numberOfComponents || 1;
if (tupleToFill.length) {
tupleToFill.length = numberOfComponents;
}
const offset = idx * numberOfComponents;
for (let i = 0; i < numberOfComponents; i++) {
tupleToFill[i] = model.values[offset + i];
}
return tupleToFill;
};

publicAPI.getTupleLocation = (idx = 1) => idx * model.numberOfComponents;
publicAPI.getNumberOfComponents = () => model.numberOfComponents;
publicAPI.getNumberOfValues = () => model.values.length;
publicAPI.getNumberOfTuples = () =>
model.values.length / model.numberOfComponents;
publicAPI.getDataType = () => model.dataType;
/* eslint-disable no-use-before-define */
publicAPI.newClone = () =>
newInstance({
name: model.name,
numberOfComponents: model.numberOfComponents,
empty: true,
});
/* eslint-enable no-use-before-define */

publicAPI.getName = () => {
if (!model.name) {
publicAPI.setName(`vtkStringArray${publicAPI.getMTime()}`);
}
return model.name;
};

publicAPI.setData = (array, numberOfComponents) => {
model.values = array;
model.size = array.length;
if (numberOfComponents) {
model.numberOfComponents = numberOfComponents;
}
if (model.size % model.numberOfComponents !== 0) {
model.numberOfComponents = 1;
}
publicAPI.modified();
};
}

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

const DEFAULT_VALUES = {
name: '',
numberOfComponents: 1,
size: 0,
// values: null,
dataType: 'string',
};

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

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

if (!model.empty && !model.values && !model.size) {
throw new TypeError(
'Cannot create vtkStringArray object without: size > 0, values'
);
}

if (!model.values) {
model.values = [];
} else if (Array.isArray(model.values)) {
model.values = [...model.values];
}

if (model.values) {
model.size = model.values.length;
}

// Object methods
macro.obj(publicAPI, model);
macro.set(publicAPI, model, ['name']);

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

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

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

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

export default { newInstance, extend };