simplnx Filter API

This is the documentation for all filters included in the simplnx module. These filters can be used by importing the appropriate module. Each filter is contained in the module:

import simplnx
# Instantiate and execute a filter from the module
result = simplnx.SomeFilterName.execute(...)

Add Bad Data

class simplnx.AddBadDataFilter

This Filter adds “bad” data to an Image Geometry. This Filter is intended to add “realism” (i.e., more representative of an experimental dataset) to synthetic structures that don not have any “bad” Cells. The user can choose to add “random noise” and/or “noise” along Feature boundaries. For a given type of noise, the user must then set the volume fraction of Cells to set as “bad”. The volume fractions entered apply to only the set of Cells that the noise would affect. For example, if the user chose 0.2 for the volume fraction of boundary “noise”, then each boundary Cell would have a 20% chance of being changed to a “bad” Cell and all other Cells would have a 0% chance of being changed. In order to compute noise over the Feature boundaries, the Filter needs the Manhattan distances for each Cell from the Feature boundaries. Note that the computed Manhattan distances are floating point values, but this Filter requires an integer array. To create the necessary integer array, use the Convert Attributer Data Type Filter to cast the Manhattan distance array to an integer array.

Link to the full online documentation for AddBadDataFilter

Mapping of UI display to python named argument

UI Display

Python Named Argument

Add Boundary Noise

boundary_noise

Volume Fraction of Boundary Noise

boundary_vol_fraction

Boundary Euclidean Distances

gb_euclidean_distances_array_path

Image Geometry

input_image_geometry_path

Add Random Noise

poisson_noise

Volume Fraction of Random Noise

poisson_vol_fraction

Stored Seed Value Array Name

seed_array_name

Seed Value

seed_value

Use Seed for Random Generation

use_seed

Execute(data_structure, boundary_noise, boundary_vol_fraction, gb_euclidean_distances_array_path, input_image_geometry_path, poisson_noise, poisson_vol_fraction, seed_array_name, seed_value, use_seed)
Parameters:
  • data_structure (DataStructure) – The DataStructure object that holds the data to be processed.

  • boundary_noise (nx.BoolParameter) – If true the user may set the boundary volume fraction

  • boundary_vol_fraction (nx.Float32Parameter) – A value between 0 and 1 inclusive that is compared against random generation

  • gb_euclidean_distances_array_path (nx.ArraySelectionParameter) – This is the GB Manhattan Distances array

  • input_image_geometry_path (nx.GeometrySelectionParameter) – The selected image geometry

  • poisson_noise (nx.BoolParameter) – If true the user may set the poisson volume fraction

  • poisson_vol_fraction (nx.Float32Parameter) – A value between 0 and 1 inclusive that is compared against random generation

  • seed_array_name (nx.DataObjectNameParameter) – Name of array holding the seed value

  • seed_value (nx.UInt64Parameter) – The seed fed into the random generator

  • use_seed (nx.BoolParameter) – When true the user will be able to put in a seed for random generation

Returns:

Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.

Return type:

nx.IFilter.ExecuteResult

Align Geometries

class simplnx.AlignGeometriesFilter

This Filter will align 2 Geometry objects using 1 of several alignment methods:

Link to the full online documentation for AlignGeometriesFilter

Mapping of UI display to python named argument

UI Display

Python Named Argument

Alignment Type

alignment_type_index

Moving Geometry

input_moving_geometry_path

Fixed Geometry

input_target_geometry_path

Execute(data_structure, alignment_type_index, input_moving_geometry_path, input_target_geometry_path)
Parameters:
Returns:

Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.

Return type:

nx.IFilter.ExecuteResult

Align Sections (Feature Centroid)

class simplnx.AlignSectionsFeatureCentroidFilter

This Filter attempts to align ‘sections’ of the sample perpendicular to the Z-direction by determining the position that closest aligns the centroid(s) of previously defined “regions”. The “regions” are defined by a boolean array where the Cells have been flagged by another Filter. Typically, during reading/processing of the data, each Cell is subject to a “quality metric” (or threshold) that defines if the Cell is good. This threshold can be used to define areas of each slice that are bad, either due to actual features in the microstructure or external references inserted by the user/experimentalist. If these “regions” of bad Cells are believed to be consistent through sections, then this Filter will preserve that by aligning those “regions” on top of one another on consecutive sections. The algorithm of this Filter is as follows:

Link to the full online documentation for AlignSectionsFeatureCentroidFilter

Mapping of UI display to python named argument

UI Display

Python Named Argument

Alignment Attribute Matrix Name

alignment_attribute_matrix_name

Alignment Centroids Data Array Name

centroids_array_name

Alignment Cumulative Shifts Data Array Name

cumulative_shifts_array_name

Selected Image Geometry

input_image_geometry_path

Mask Array

mask_array_path

Reference Slice

reference_slice

Alignment Relative Shifts Data Array Name

relative_shifts_array_name

Alignment Slices Data Array Name

slices_array_name

Store Alignment Shifts

store_alignment_shifts

Use Reference Slice

use_reference_slice

Execute(data_structure, alignment_attribute_matrix_name, centroids_array_name, cumulative_shifts_array_name, input_image_geometry_path, mask_array_path, reference_slice, relative_shifts_array_name, slices_array_name, store_alignment_shifts, use_reference_slice)
Parameters:
  • data_structure (DataStructure) – The DataStructure object that holds the data to be processed.

  • alignment_attribute_matrix_name (nx.DataObjectNameParameter) – The output attribute matrix where the shifts applied to the section to be stored as DataArrays.

  • centroids_array_name (nx.DataObjectNameParameter) – The output array name where the centroid information will be stored.

  • cumulative_shifts_array_name (nx.DataObjectNameParameter) – The output array name where the accumulated shift information will be stored.

  • input_image_geometry_path (nx.GeometrySelectionParameter) – The target geometry on which to perform the alignment

  • mask_array_path (nx.ArraySelectionParameter) – Specifies if the Cell is to be counted in the algorithm.

  • reference_slice (nx.Int32Parameter) – Slice number to use as reference

  • relative_shifts_array_name (nx.DataObjectNameParameter) – The output array name where the new shifts relative to previous slice information will be stored.

  • slices_array_name (nx.DataObjectNameParameter) – The output array name where the slice information related to shifts will be stored.

  • store_alignment_shifts (nx.BoolParameter) – Whether to store the shifts applied to each section to a collection of Arrays in a new Attribute Matrix

  • use_reference_slice (nx.BoolParameter) – Whether the centroids of each section should be compared to a reference slice instead of their neighboring section

Returns:

Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.

Return type:

nx.IFilter.ExecuteResult

Align Sections (List)

class simplnx.AlignSectionsListFilter

This Filter will apply the precalculated cell shifts to each section of an Image Geometry. It allows for both relative or cumulative cell shifts. The difference between the two being the former is dependent on the previous slice’s position. Under the covers, relative is translated to cumulative before applying shifts to the cells themselves. Previously, the only accepted input was utilizing relative shifts, so use those for backwards compatibility. See the Handling User Created Shifts File and Example Pipelines sections of this documentation for further hints.

Link to the full online documentation for AlignSectionsListFilter

Mapping of UI display to python named argument

UI Display

Python Named Argument

Input Array Type

input_array_type_index

Selected Image Geometry

input_image_geometry_path

Shifts Array

shifts_array_path

Execute(data_structure, input_array_type_index, input_image_geometry_path, shifts_array_path)
Parameters:
  • data_structure (DataStructure) – The DataStructure object that holds the data to be processed.

  • input_array_type_index (nx.ChoicesParameter) – This selection determines how the input array was produced, Relative refers to the case where the shifts were calculated relative to the previous slice’s new position, Cumulative refers to the case where the shifts are the direct change in position

  • input_image_geometry_path (nx.GeometrySelectionParameter) – The target geometry on which to perform the alignment

  • shifts_array_path (nx.ArraySelectionParameter) – The array containing the relative or cumulative shifts for each slice

Returns:

Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.

Return type:

nx.IFilter.ExecuteResult

Append Image Geometry

class simplnx.AppendImageGeometryFilter

This filter allows the user to append one or multiple image geometries to a given image geometry, in any direction (X,Y,Z). The input anddestination ImageGeometry objects must have the same dimensions in the directions that are NOT chosen. If the X direction is chosen, the geometries must match in Y & Z. If the Y direction is chosen, the geometries must match in X & Z. If the Z direction is chosen, the geometries must match in X & Y. Optional checks for equal Resolution values can also be performed.

Link to the full online documentation for AppendImageGeometryFilter

Mapping of UI display to python named argument

UI Display

Python Named Argument

Check Spacing

check_resolution

Destination Image Geometry

destination_image_geometry_path

Direction

direction_index

Input Image Geometries

input_image_geometries_paths

Mirror Geometry In Direction

mirror_geometry

New Image Geometry

output_image_geometry_path

Save as new geometry

save_as_new_geometry

Execute(data_structure, check_resolution, destination_image_geometry_path, direction_index, input_image_geometries_paths, mirror_geometry, output_image_geometry_path, save_as_new_geometry)
Parameters:
  • data_structure (DataStructure) – The DataStructure object that holds the data to be processed.

  • check_resolution (nx.BoolParameter) – Checks to make sure the spacing for the input geometry and destination geometry match

  • destination_image_geometry_path (nx.GeometrySelectionParameter) – The destination image geometry (cell data) that is the final location for the appended data.

  • direction_index (nx.ChoicesParameter) – The direction that will be used to append the geometries.

  • input_image_geometries_paths (nx.MultiPathSelectionParameter) – The incoming image geometries (cell data) that will be appended to the destination image geometry.

  • mirror_geometry (nx.BoolParameter) – Mirrors the resulting geometry in the chosen direction.

  • output_image_geometry_path (nx.DataGroupCreationParameter) – The path to the new geometry with the combined data from the input & destination geometry

  • save_as_new_geometry (nx.BoolParameter) – Save the combined data as a new geometry instead of appending the input data to the destination geometry

Returns:

Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.

Return type:

nx.IFilter.ExecuteResult

Apply Transformation to Geometry

class simplnx.ApplyTransformationToGeometryFilter

Link to the full online documentation for ApplyTransformationToGeometryFilter

Mapping of UI display to python named argument

UI Display

Python Named Argument

Cell Attribute Matrix (Image Geometry Only)

cell_attribute_matrix_path

Precomputed Transformation Matrix Path

computed_transformation_matrix_path

Selected Geometry

input_image_geometry_path

Resampling or Interpolation (Image Geometry Only)

interpolation_type_index

Transformation Matrix

manual_transformation_matrix

Transform Matrix Output Path

output_transform_matrix_path

Rotation Axis-Angle

rotation

Save Transformation Matrix

save_transform_matrix

Scale

scale

Transformation Type

transformation_type_index

Translate Geometry To Global Origin Before Transformation

translate_geometry_to_global_origin

Translation

translation

Execute(data_structure, cell_attribute_matrix_path, computed_transformation_matrix_path, input_image_geometry_path, interpolation_type_index, manual_transformation_matrix, output_transform_matrix_path, rotation, save_transform_matrix, scale, transformation_type_index, translate_geometry_to_global_origin, translation)
Parameters:
  • data_structure (DataStructure) – The DataStructure object that holds the data to be processed.

  • cell_attribute_matrix_path (nx.AttributeMatrixSelectionParameter) – The path to the Cell level data that should be interpolated. Only applies when selecting an Image Geometry.

  • computed_transformation_matrix_path (nx.ArraySelectionParameter) – A precomputed 4x4 transformation matrix

  • input_image_geometry_path (nx.GeometrySelectionParameter) – The target geometry on which to perform the transformation

  • interpolation_type_index (nx.ChoicesParameter) – Select the type of interpolation algorithm. (0)Nearest Neighbor, (1)Linear Interpolation, (3)No Interpolation

  • manual_transformation_matrix (nx.DynamicTableParameter) – The 4x4 Transformation Matrix

  • output_transform_matrix_path (nx.ArrayCreationParameter) – The output array that contains the transformation Matrix.

  • rotation (nx.VectorFloat32Parameter) – <xyz> w (w in degrees)

  • save_transform_matrix (nx.BoolParameter) – Save the generated transform matrix as a Data Array

  • scale (nx.VectorFloat32Parameter) – 0>= value < 1: Shrink, value = 1: No transform, value > 1.0 enlarge

  • transformation_type_index (nx.ChoicesParameter) – The type of transformation to perform.

  • translate_geometry_to_global_origin (nx.BoolParameter) – Specifies whether to translate the geometry to (0, 0, 0), apply the transformation, and then translate the geometry back to its original origin.

  • translation (nx.VectorFloat32Parameter) – A pure translation vector

Returns:

Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.

Return type:

nx.IFilter.ExecuteResult

Approximate Point Cloud Hull

class simplnx.ApproximatePointCloudHullFilter

This Filter determines a set of points that approximates the surface (or hull) or a 3D point cloud represented by a Vertex Geometry. The hull is approximate in that the surface points are not guaranteed to hve belonged to the original point cloud; instead, the determined set of points is meant to represent a sampling of where the 3D point cloud surface occurs. To following steps are used to approximate the hull:

Link to the full online documentation for ApproximatePointCloudHullFilter

Mapping of UI display to python named argument

UI Display

Python Named Argument

Grid Resolution

grid_resolution

Vertex Geometry

input_vertex_geometry_path

Minimum Number of Empty Neighbors

min_empty_neighbors

Hull Vertex Geometry

output_vertex_geometry_path

Execute(data_structure, grid_resolution, input_vertex_geometry_path, min_empty_neighbors, output_vertex_geometry_path)
Parameters:
Returns:

Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.

Return type:

nx.IFilter.ExecuteResult

Attribute Array Calculator

class simplnx.ArrayCalculatorFilter

This Filter performs calculations on Attribute Arrays using the mathematical expression entered by the user, referred to as the infix expression. Calculations follow standard mathematical order of operations rules. Parentheses may be used to influence priority. The output of the entered equation is stored as a new Attribute Array of type double in an Attribute Matrix chosen by the user.

Link to the full online documentation for ArrayCalculatorFilter

Mapping of UI display to python named argument

UI Display

Python Named Argument

Output Calculated Array

calculated_array_path

Infix Expression

calculator_parameter

Output Numeric Type

scalar_type_index

Execute(data_structure, calculated_array_path, calculator_parameter, scalar_type_index)
Parameters:
Returns:

Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.

Return type:

nx.IFilter.ExecuteResult

Convert Angles to Degrees or Radians

class simplnx.ChangeAngleRepresentationFilter

This Filter will multiply the values of every Element by a factor to convert degrees to radians or radians to degrees. The user needs to know the units of their data in order to use this Filter properly.

Link to the full online documentation for ChangeAngleRepresentationFilter

Mapping of UI display to python named argument

UI Display

Python Named Argument

Angles

angles_array_path

Conversion Type

conversion_type_index

Execute(data_structure, angles_array_path, conversion_type_index)
Parameters:
  • data_structure (DataStructure) – The DataStructure object that holds the data to be processed.

  • angles_array_path (nx.ArraySelectionParameter) – The DataArray containing the angles to be converted.

  • conversion_type_index (nx.ChoicesParameter) – Tells the Filter which conversion is being made

Returns:

Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.

Return type:

nx.IFilter.ExecuteResult

Combine Attribute Arrays

class simplnx.CombineAttributeArraysFilter

This Filter will “stack” any number of user-chosen Attribute Arrays into a single attribute array and allows the option to remove the original Attribute Arrays once this operation is completed. The arrays must all share the same primitive type and number of tuples, but may have differing component dimensions. The resulting combined array will have a total number of components equal to the sum of the number of components for each stacked array. The order in which the components are placed in the combined array is the same as the ordering chosen by the user when selecting the arrays. For example, consider two arrays, one that is a 3-vector and one that is a scalar. The values in memory appear as follows:

Link to the full online documentation for CombineAttributeArraysFilter

Mapping of UI display to python named argument

UI Display

Python Named Argument

Attribute Arrays to Combine

input_data_array_paths

Move Data

move_values

Normalize Data

normalize_data

Created Data Array

output_data_array_name

Execute(data_structure, input_data_array_paths, move_values, normalize_data, output_data_array_name)
Parameters:
  • data_structure (DataStructure) – The DataStructure object that holds the data to be processed.

  • input_data_array_paths (nx.MultiArraySelectionParameter) – The complete path to each of the Attribute Arrays to combine

  • move_values (nx.BoolParameter) – Whether to remove the original arrays after combining the data

  • normalize_data (nx.BoolParameter) – Whether to normalize the combine data on the interval [0, 1]

  • output_data_array_name (nx.DataObjectNameParameter) – This is the name of the created output array of the combined attribute arrays.

Returns:

Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.

Return type:

nx.IFilter.ExecuteResult

Combine Node Based Geometries

class simplnx.CombineNodeBasedGeometriesFilter

This Filter will combine any node-based geometries together into one node-based geometry. The algorithm is governed by several rules:

Link to the full online documentation for CombineNodeBasedGeometriesFilter

Mapping of UI display to python named argument

UI Display

Python Named Argument

Input Geometries

input_geometry_paths

Combined Geometry

output_geometry_path

Execute(data_structure, input_geometry_paths, output_geometry_path)
Parameters:
  • data_structure (DataStructure) – The DataStructure object that holds the data to be processed.

  • input_geometry_paths (nx.MultiPathSelectionParameter) – The incoming geometries that will be combined together into the destination geometry. All geometries must be of the same geometry type.

  • output_geometry_path (nx.DataGroupCreationParameter) – The path to the combined geometry

Returns:

Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.

Return type:

nx.IFilter.ExecuteResult

Combine STL Files

class simplnx.CombineStlFilesFilter

This Filter combines all of the STL files from a given directory into a single triangle geometry. This filter will make use of the Import STL File Filter to read in each stl file in the given directory and then will proceed to combine each of the imported files into a single triangle geometry.

Link to the full online documentation for CombineStlFilesFilter

Mapping of UI display to python named argument

UI Display

Python Named Argument

Active

active_array_name

Feature Attribute Matrix

cell_feature_attribute_matrix_name

Generate Triangle Face Labels

create_face_labels

Generate Triangle Part Numbers

create_part_numbers

Face Attribute Matrix

face_attribute_matrix_name

Created Face Labels Array

face_labels_name

Face Normals

face_normals_array_name

Generate Vertex Part Numbers

label_vertices

File List Array

output_file_list_name

Triangle Geometry

output_triangle_geometry_path

Created Part Number Array

part_numbers_name

Path to STL Files

stl_files_path

Vertex Attribute Matrix

vertex_attribute_matrix_name

Created Part Number Labels

vertex_label_name

Execute(data_structure, active_array_name, cell_feature_attribute_matrix_name, create_face_labels, create_part_numbers, face_attribute_matrix_name, face_labels_name, face_normals_array_name, label_vertices, output_file_list_name, output_triangle_geometry_path, part_numbers_name, stl_files_path, vertex_attribute_matrix_name, vertex_label_name)
Parameters:
  • data_structure (DataStructure) – The DataStructure object that holds the data to be processed.

  • active_array_name (nx.DataObjectNameParameter) – Specifies if the Feature is still in the sample (true if the Feature is in the sample and false if it is not). At the end of the Filter, all Features will be Active

  • cell_feature_attribute_matrix_name (nx.DataObjectNameParameter) – The name of the created feature attribute matrix

  • create_face_labels (nx.BoolParameter) – When true, the ‘Face Labels’ array will be created.

  • create_part_numbers (nx.BoolParameter) – When true, each triangle will get an index associated with the index of the STL file

  • face_attribute_matrix_name (nx.DataObjectNameParameter) – The name of the face level attribute matrix to be created with the geometry

  • face_labels_name (nx.DataObjectNameParameter) – The name of the ‘Face Labels’ data array

  • face_normals_array_name (nx.DataObjectNameParameter) – The name of the data array in which to store the face normals for the created triangle geometry

  • label_vertices (nx.BoolParameter) – When true, each vertex will get an index associated with the index of the STL file

  • output_file_list_name (nx.DataObjectNameParameter) – The path to a String array that will store the input paths of each file that was read.

  • output_triangle_geometry_path (nx.DataGroupCreationParameter) – The path to the triangle geometry to be created from the combined STL files

  • part_numbers_name (nx.DataObjectNameParameter) – The name of the part numbers data array

  • stl_files_path (nx.FileSystemPathParameter) – The path to the folder containing all the STL files to be combined

  • vertex_attribute_matrix_name (nx.DataObjectNameParameter) – The name of the vertex level attribute matrix to be created with the geometry

  • vertex_label_name (nx.DataObjectNameParameter) – The name of the part numbers data array

Returns:

Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.

Return type:

nx.IFilter.ExecuteResult

Compute Attribute Array Frequency Histogram

class simplnx.ComputeArrayHistogramFilter

This Filter accepts DataArray(s) as input, creates histogram DataArray(s) in specified DataGroup from input DataArray(s), then calculates histogram values according to user parameters and stores values in created histogram DataArray(s).

Link to the full online documentation for ComputeArrayHistogramFilter

Mapping of UI display to python named argument

UI Display

Python Named Argument

Create New DataGroup for Histograms

create_new_data_group

Suffix for created Histogram Bin Counts

histogram_bin_count_suffix

Suffix for created Histogram Bin Ranges

histogram_bin_range_suffix

Max Value

max_range

Min Value

min_range

New DataGroup Path

new_data_group_path

Number of Bins

number_of_bins

Output DataGroup Path

output_data_group_path

Input Data Arrays

selected_array_paths

Use Custom Min & Max Range

user_defined_range

Execute(data_structure, create_new_data_group, histogram_bin_count_suffix, histogram_bin_range_suffix, max_range, min_range, new_data_group_path, number_of_bins, output_data_group_path, selected_array_paths, user_defined_range)
Parameters:
  • data_structure (DataStructure) – The DataStructure object that holds the data to be processed.

  • create_new_data_group (nx.BoolParameter) – Whether or not to store the calculated histogram(s) in a new DataGroup

  • histogram_bin_count_suffix (nx.StringParameter) – String appended to the end of the histogram array names

  • histogram_bin_range_suffix (nx.StringParameter) – String appended to the end of the histogram array names

  • max_range (nx.Float64Parameter) – Specifies the exclusive upper bound of the histogram.

  • min_range (nx.Float64Parameter) – Specifies the inclusive lower bound of the histogram.

  • new_data_group_path (nx.DataGroupCreationParameter) – The path to the new DataGroup in which to store the calculated histogram(s)

  • number_of_bins (nx.Int32Parameter) – Specifies number of histogram bins (greater than zero)

  • output_data_group_path (nx.DataGroupSelectionParameter) – The complete path to the DataGroup in which to store the calculated histogram(s)

  • selected_array_paths (nx.MultiArraySelectionParameter) – The list of arrays to calculate histogram(s) for

  • user_defined_range (nx.BoolParameter) – Whether the user can set the min and max values to consider for the histogram

Returns:

Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.

Return type:

nx.IFilter.ExecuteResult

Compute Attribute Array Statistics

class simplnx.ComputeArrayStatisticsFilter

This Filter computes a variety of statistics for a given scalar array. The currently available statistics are array length, minimum, maximum, (arithmetic) mean, median, mode, standard deviation, and summation; any combination of these statistics may be computed by this Filter. Any scalar array, of any primitive type, may be used as input. The type of the output arrays depends on the kind of statistic computed:

Link to the full online documentation for ComputeArrayStatisticsFilter

Mapping of UI display to python named argument

UI Display

Python Named Argument

Compute Statistics Per Feature/Ensemble

compute_by_index

Destination Attribute Matrix

destination_attribute_matrix_path

Feature-Has-Data Array Name

feature_has_data_array_name

Cell Feature Ids

feature_ids_path

Find Histogram

find_histogram

Find Length

find_length

Find Maximum

find_max

Find Mean

find_mean

Find Median

find_median

Find Minimum

find_min

Find Modal Histogram Bin Ranges

find_modal_bin_ranges

Find Mode

find_mode

Find Standard Deviation

find_std_deviation

Find Summation

find_summation

Find Number of Unique Values

find_unique_values

Histogram Bin Counts Array Name

histogram_bin_count_name

Histogram Bin Ranges Array Name

histogram_bin_range_name

Length Array Name

length_array_name

Mask Array

mask_array_path

Custom Histogram Max Value

max_range

Maximum Array Name

maximum_array_name

Mean Array Name

mean_array_name

Median Array Name

median_array_name

Custom Histogram Min Value

min_range

Minimum Array Name

minimum_array_name

Modal Histogram Bin Ranges Array Name

modal_bin_array_name

Mode Array Name

mode_array_name

Most Populated Bin Array Name

most_populated_bin_array_name

Number of Bins

num_bins

Number of Unique Values Array Name

number_unique_values_name

Attribute Array to Compute Statistics

selected_array_path

Standardize Data

standardize_data

Standardized Data Array Name

standardized_array_name

Standard Deviation Array Name

std_deviation_array_name

Summation Array Name

summation_array_name

Use Full Range for Histogram

use_full_range

Use Mask Array

use_mask

Execute(data_structure, compute_by_index, destination_attribute_matrix_path, feature_has_data_array_name, feature_ids_path, find_histogram, find_length, find_max, find_mean, find_median, find_min, find_modal_bin_ranges, find_mode, find_std_deviation, find_summation, find_unique_values, histogram_bin_count_name, histogram_bin_range_name, length_array_name, mask_array_path, max_range, maximum_array_name, mean_array_name, median_array_name, min_range, minimum_array_name, modal_bin_array_name, mode_array_name, most_populated_bin_array_name, num_bins, number_unique_values_name, selected_array_path, standardize_data, standardized_array_name, std_deviation_array_name, summation_array_name, use_full_range, use_mask)
Parameters:
Returns:

Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.

Return type:

nx.IFilter.ExecuteResult

Compute Biased Features (Bounding Box)

class simplnx.ComputeBiasedFeaturesFilter

This Filter determines which Features are biased by the outer surfaces of the sample. Larger Features are more likely to intersect the outer surfaces and thus it is not sufficient to only note which Features touch the outer surfaces of the sample. Denoting which Features are biased is important so that they may be excluded from any statistical analyses. The algorithm for determining whether a Feature is biased is as follows:

Link to the full online documentation for ComputeBiasedFeaturesFilter

Mapping of UI display to python named argument

UI Display

Python Named Argument

Biased Features

biased_features_array_name

Apply Phase by Phase

calc_by_phase

Centroids

centroids_array_path

Image Geometry

input_image_geometry_path

Phases

phases_array_path

Surface Features

surface_features_array_path

Execute(data_structure, biased_features_array_name, calc_by_phase, centroids_array_path, input_image_geometry_path, phases_array_path, surface_features_array_path)
Parameters:
  • data_structure (DataStructure) – The DataStructure object that holds the data to be processed.

  • biased_features_array_name (nx.DataObjectNameParameter) – Flag of 1 if Feature is biased or of 0 if it is not

  • calc_by_phase (nx.BoolParameter) – Whether to apply the biased Features algorithm per Ensemble

  • centroids_array_path (nx.ArraySelectionParameter) – X, Y, Z coordinates of Feature center of mass

  • input_image_geometry_path (nx.GeometrySelectionParameter) – The selected geometry in which to the (biased) features belong

  • phases_array_path (nx.ArraySelectionParameter) – Specifies to which Ensemble each Feature belongs. Only required if Apply Phase by Phase is checked

  • surface_features_array_path (nx.ArraySelectionParameter) – Flag of 1 if Feature touches an outer surface or of 0 if it does not

Returns:

Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.

Return type:

nx.IFilter.ExecuteResult

Compute Boundary Cells (Image)

class simplnx.ComputeBoundaryCellsFilter

This Filter determines, for each Cell, the number of neighboring Cells that are owned by a different Feature. The algorithm for determining this is as follows:

Link to the full online documentation for ComputeBoundaryCellsFilter

Mapping of UI display to python named argument

UI Display

Python Named Argument

Boundary Cells

boundary_cells_array_name

Cell Feature Ids

feature_ids_array_path

Ignore Feature 0

ignore_feature_zero

Include Volume Boundary

include_volume_boundary

Image Geometry

input_image_geometry_path

Execute(data_structure, boundary_cells_array_name, feature_ids_array_path, ignore_feature_zero, include_volume_boundary, input_image_geometry_path)
Parameters:
  • data_structure (DataStructure) – The DataStructure object that holds the data to be processed.

  • boundary_cells_array_name (nx.DataObjectNameParameter) – The number of neighboring Cells of a given Cell that belong to a different Feature than itself. Values will range from 0 to 6

  • feature_ids_array_path (nx.ArraySelectionParameter) – Data Array that specifies to which Feature each Element belongs

  • ignore_feature_zero (nx.BoolParameter) – Do not use feature 0

  • include_volume_boundary (nx.BoolParameter) – Include the Cell boundaries

  • input_image_geometry_path (nx.GeometrySelectionParameter) – The selected geometry to which the cells belong

Returns:

Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.

Return type:

nx.IFilter.ExecuteResult

Compute Feature Boundary Element Fractions

class simplnx.ComputeBoundaryElementFractionsFilter

This Filter calculates the fraction of Elements of each Feature that are on the “surface” of that Feature. The Filter simply iterates through all Elements asking for the Feature that owns them and if the Element is a “surface” Element. Each Feature counts the total number of Elements it owns and the number of those Elements that are “surface” Elements. The fraction is then stored for each Feature.

Link to the full online documentation for ComputeBoundaryElementFractionsFilter

Mapping of UI display to python named argument

UI Display

Python Named Argument

Surface Element Fractions

boundary_cell_fractions_array_name

Surface Elements

boundary_cells_array_path

Feature Data

feature_data_attribute_matrix_path

Cell Feature Ids

feature_ids_array_path

Execute(data_structure, boundary_cell_fractions_array_name, boundary_cells_array_path, feature_data_attribute_matrix_path, feature_ids_array_path)
Parameters:
  • data_structure (DataStructure) – The DataStructure object that holds the data to be processed.

  • boundary_cell_fractions_array_name (nx.DataObjectNameParameter) – Name of created Data Array containing fraction of Elements belonging to the Feature that are “surface” Elements

  • boundary_cells_array_path (nx.ArraySelectionParameter) – DataArray containing the number of neighboring Elements of a given Element that belong to a different Feature than itself

  • feature_data_attribute_matrix_path (nx.AttributeMatrixSelectionParameter) – Parent Attribute Matrix for the Surface Element Fractions Array to be created in

  • feature_ids_array_path (nx.ArraySelectionParameter) – Data Array that specifies to which Feature each Element belongs

Returns:

Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.

Return type:

nx.IFilter.ExecuteResult

Compute Differences Map

class simplnx.ComputeDifferencesMapFilter

This Filter calculates the difference between two Attribute Arrays. The arrays must have the same primitive type (e.g., float), component dimensions and number of tuples. The Filter uses the following pseudocode to calculate the difference map:

Link to the full online documentation for ComputeDifferencesMapFilter

Mapping of UI display to python named argument

UI Display

Python Named Argument

Difference Map

difference_map_array_path

First Input Array

first_input_array_path

Second Input Array

second_input_array_path

Execute(data_structure, difference_map_array_path, first_input_array_path, second_input_array_path)
Parameters:
Returns:

Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.

Return type:

nx.IFilter.ExecuteResult

Compute Euclidean Distance Map

class simplnx.ComputeEuclideanDistMapFilter

This Filter calculates the distance of each Cell from the nearest Feature boundary, triple line and/or quadruple point. The following algorithm explains the process:

Link to the full online documentation for ComputeEuclideanDistMapFilter

Mapping of UI display to python named argument

UI Display

Python Named Argument

Output arrays are Manhattan distance (int32)

calc_manhattan_dist

Calculate Distance to Boundaries

do_boundaries

Calculate Distance to Quadruple Points

do_quad_points

Calculate Distance to Triple Lines

do_triple_lines

Cell Feature Ids

feature_ids_path

Boundary Distances

g_bdistances_array_name

Selected Image Geometry

input_image_geometry_path

Nearest Boundary Cells

nearest_neighbors_array_name

Quadruple Point Distances

q_pdistances_array_name

Store the Nearest Boundary Cells

save_nearest_neighbors

Triple Line Distances

t_jdistances_array_name

Execute(data_structure, calc_manhattan_dist, do_boundaries, do_quad_points, do_triple_lines, feature_ids_path, g_bdistances_array_name, input_image_geometry_path, nearest_neighbors_array_name, q_pdistances_array_name, save_nearest_neighbors, t_jdistances_array_name)
Parameters:
  • data_structure (DataStructure) – The DataStructure object that holds the data to be processed.

  • calc_manhattan_dist (nx.BoolParameter) – If Manhattan distance is used then results are stored as int32 otherwise results are stored as float32

  • do_boundaries (nx.BoolParameter) – Whether the distance of each Cell to a Feature boundary is calculated

  • do_quad_points (nx.BoolParameter) – Whether the distance of each Cell to a quadruple point between Features is calculated

  • do_triple_lines (nx.BoolParameter) – Whether the distance of each Cell to a triple line between Features is calculated

  • feature_ids_path (nx.ArraySelectionParameter) – Specifies to which Feature each cell belongs

  • g_bdistances_array_name (nx.DataObjectNameParameter) – The name of the array with the distance the cells are from the boundary of the Feature they belong to.

  • input_image_geometry_path (nx.GeometrySelectionParameter) – The target geometry

  • nearest_neighbors_array_name (nx.DataObjectNameParameter) – The name of the array with the indices of the closest cell that touches a boundary, triple and quadruple point for each cell.

  • q_pdistances_array_name (nx.DataObjectNameParameter) – The name of the array with the distance the cells are from a quadruple point of Features.

  • save_nearest_neighbors (nx.BoolParameter) – Whether to store the nearest neighbors of Cell

  • t_jdistances_array_name (nx.DataObjectNameParameter) – The name of the array with the distance the cells are from a triple junction of Features.

Returns:

Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.

Return type:

nx.IFilter.ExecuteResult

Compute Feature Centroids

class simplnx.ComputeFeatureCentroidsFilter

This Filter calculates the centroid of each Feature by determining the average X, Y, and Z position of all the Cells belonging to the Feature. Note that Features that intersect the outer surfaces of the sample will still have centroids calculated, but they will be centroids of the truncated part of the Feature that lies inside the sample.

Link to the full online documentation for ComputeFeatureCentroidsFilter

Mapping of UI display to python named argument

UI Display

Python Named Argument

Centroids

centroids_array_name

Feature Attribute Matrix

feature_attribute_matrix_path

Cell Feature Ids

feature_ids_path

Selected Image Geometry

input_image_geometry_path

Execute(data_structure, centroids_array_name, feature_attribute_matrix_path, feature_ids_path, input_image_geometry_path)
Parameters:
Returns:

Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.

Return type:

nx.IFilter.ExecuteResult

Compute Feature Clustering

class simplnx.ComputeFeatureClusteringFilter

This Filter determines the radial distribution function (RDF), as a histogram, of a given set of Features. Currently, the Features need to be of the same Ensemble (specified by the user), and the resulting RDF is stored as Ensemble data. This Filter also returns the clustering list (the list of all the inter-Feature distances) and the minimum and maximum separation distances. The algorithm proceeds as follows:

Link to the full online documentation for ComputeFeatureClusteringFilter

Mapping of UI display to python named argument

UI Display

Python Named Argument

Biased Features

biased_features_array_path

Cell Ensemble Attribute Matrix

cell_ensemble_attribute_matrix_path

Centroids

centroids_array_path

Clustering List

clustering_list_array_name

Phases

feature_phases_array_path

Selected Image Geometry

input_image_geometry_path

Max and Min Separation Distances

max_min_array_name

Number of Bins for RDF

number_of_bins

Phase Index

phase_number

Radial Distribution Function

rdf_array_name

Remove Biased Features

remove_biased_features

Stored Seed Value Array Name

seed_array_name

Seed Value

seed_value

Set Random Seed

set_random_seed

Execute(data_structure, biased_features_array_path, cell_ensemble_attribute_matrix_path, centroids_array_path, clustering_list_array_name, feature_phases_array_path, input_image_geometry_path, max_min_array_name, number_of_bins, phase_number, rdf_array_name, remove_biased_features, seed_array_name, seed_value, set_random_seed)
Parameters:
Returns:

Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.

Return type:

nx.IFilter.ExecuteResult

Compute Feature Neighbors

class simplnx.ComputeFeatureNeighborsFilter

This Filter determines, for each Feature, the number of other Features that are in contact with it. The algorithm for determining the number of “contiguous” neighbors of each Feature is as follows:

Link to the full online documentation for ComputeFeatureNeighborsFilter

Mapping of UI display to python named argument

UI Display

Python Named Argument

Boundary Cells

boundary_cells_name

Feature Attribute Matrix

cell_feature_array_path

Cell Feature Ids

feature_ids_path

Image Geometry

input_image_geometry_path

Neighbor List

neighbor_list_name

Number of Neighbors

number_of_neighbors_name

Shared Surface Area List

shared_surface_area_list_name

Store Boundary Cells Array

store_boundary_cells

Store Surface Features Array

store_surface_features

Surface Features

surface_features_name

Execute(data_structure, boundary_cells_name, cell_feature_array_path, feature_ids_path, input_image_geometry_path, neighbor_list_name, number_of_neighbors_name, shared_surface_area_list_name, store_boundary_cells, store_surface_features, surface_features_name)
Parameters:
  • data_structure (DataStructure) – The DataStructure object that holds the data to be processed.

  • boundary_cells_name (nx.DataObjectNameParameter) – The number of neighboring Cells of a given Cell that belong to a different Feature than itself. Values will range from 0 to 6. Only created if Store Boundary Cells Array is checked

  • cell_feature_array_path (nx.AttributeMatrixSelectionParameter) – Feature Attribute Matrix of the selected Feature Ids

  • feature_ids_path (nx.ArraySelectionParameter) – Specifies to which Feature each cell belongs

  • input_image_geometry_path (nx.GeometrySelectionParameter) – The geometry in which to identify feature neighbors

  • neighbor_list_name (nx.DataObjectNameParameter) – List of the contiguous neighboring Features for a given Feature

  • number_of_neighbors_name (nx.DataObjectNameParameter) – Number of contiguous neighboring Features for a given Feature

  • shared_surface_area_list_name (nx.DataObjectNameParameter) – List of the shared surface area for each of the contiguous neighboring Features for a given Feature

  • store_boundary_cells (nx.BoolParameter) – Whether to store the boundary Cells array

  • store_surface_features (nx.BoolParameter) – Whether to store the surface Features array

  • surface_features_name (nx.DataObjectNameParameter) – The name of the surface features data array. Flag equal to 1 if the Feature touches an outer surface of the sample and equal to 0 if it does not. Only created if Store Surface Features Array is checked

Returns:

Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.

Return type:

nx.IFilter.ExecuteResult

Compute Feature Phases Binary

class simplnx.ComputeFeaturePhasesBinaryFilter

This Filter assigns an Ensemble Id number to binary data. The true Cells will be Ensemble 1, and false Cells will be Ensemble 0. This Filter is generally useful when the Cell Ensembles were not known ahead of time. For example, if an image is segmented into precipitates and non-precipitates, this Filter will assign the precipitates to Ensemble 1, and the non-precipitates to Ensemble 0.

Link to the full online documentation for ComputeFeaturePhasesBinaryFilter

Mapping of UI display to python named argument

UI Display

Python Named Argument

Cell Data Attribute Matrix

cell_data_attribute_matrix_path

Cell Feature Ids

feature_ids_array_path

Binary Feature Phases Array Name

feature_phases_array_name

Mask Array

mask_array_path

Execute(data_structure, cell_data_attribute_matrix_path, feature_ids_array_path, feature_phases_array_name, mask_array_path)
Parameters:
  • data_structure (DataStructure) – The DataStructure object that holds the data to be processed.

  • cell_data_attribute_matrix_path (nx.AttributeMatrixSelectionParameter) – The Cell Data Attribute Matrix within the Image Geometry where the Binary Phases Array will be created

  • feature_ids_array_path (nx.ArraySelectionParameter) – Data Array that specifies to which Feature each Element belongs

  • feature_phases_array_name (nx.DataObjectNameParameter) – Created Data Array name to specify to which Ensemble each Feature belongs

  • mask_array_path (nx.ArraySelectionParameter) – Data Array that specifies if the Cell is to be counted in the algorithm

Returns:

Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.

Return type:

nx.IFilter.ExecuteResult

Compute Feature Phases

class simplnx.ComputeFeaturePhasesFilter

This Filter determines the Ensemble of each Feature by querying the Ensemble of the Elements that belong to the Feature. Note that it is assumed that all Elements belonging to a Feature are of the same Feature, and thus any Element can be used to determine the Ensemble of the Feature that owns that Element.

Link to the full online documentation for ComputeFeaturePhasesFilter

Mapping of UI display to python named argument

UI Display

Python Named Argument

Feature Attribute Matrix

cell_features_attribute_matrix_path

Cell Phases

cell_phases_array_path

Cell Feature Ids

feature_ids_path

Feature Phases

feature_phases_array_name

Execute(data_structure, cell_features_attribute_matrix_path, cell_phases_array_path, feature_ids_path, feature_phases_array_name)
Parameters:
Returns:

Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.

Return type:

nx.IFilter.ExecuteResult

Compute Feature Corners

class simplnx.ComputeFeatureRectFilter

This Filter computes the XYZ minimum and maximum coordinates for each Feature in a segmentation. This data can be important for finding the smallest encompassing volume. This values are given in Pixel coordinates.

Link to the full online documentation for ComputeFeatureRectFilter

Mapping of UI display to python named argument

UI Display

Python Named Argument

Feature Data Attribute Matrix

feature_data_attribute_matrix_path

Cell Feature Ids

feature_ids_array_path

Feature Rect

feature_rect_array_name

Execute(data_structure, feature_data_attribute_matrix_path, feature_ids_array_path, feature_rect_array_name)
Parameters:
Returns:

Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.

Return type:

nx.IFilter.ExecuteResult

Compute Feature Sizes

class simplnx.ComputeFeatureSizesFilter

This Filter calculates the sizes of all Features. The Filter simply iterates through all Elements querying for the Feature that owns them and keeping a tally for each Feature. The tally is then stored as NumElements and the Volume and EquivalentDiameter are also calculated (and stored) by knowing the volume of each Element.

Link to the full online documentation for ComputeFeatureSizesFilter

Mapping of UI display to python named argument

UI Display

Python Named Argument

Equivalent Diameters

equivalent_diameters_name

Feature Attribute Matrix

feature_attribute_matrix_path

Cell Feature Ids

feature_ids_path

Input Image Geometry

input_image_geometry_path

Number of Elements

num_elements_name

Generate Missing Element Sizes

save_element_sizes

Volumes

volumes_name

Execute(data_structure, equivalent_diameters_name, feature_attribute_matrix_path, feature_ids_path, input_image_geometry_path, num_elements_name, save_element_sizes, volumes_name)
Parameters:
Returns:

Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.

Return type:

nx.IFilter.ExecuteResult

Compute K Means

class simplnx.ComputeKMeansFilter

*Warning:* The randomnes in this filter is not currently consistent between operating systems even if the same seed is used. Specifically between Unix and Windows. This does not affect the results, but the IDs will not correspond. For example if the Cluster Identifier at index one on Linux is 1 it could be 2 on Windows, the overarching clusters will be the same, but their IDs will be different.

Link to the full online documentation for ComputeKMeansFilter

Mapping of UI display to python named argument

UI Display

Python Named Argument

Distance Metric

distance_metric_index

Cluster Attribute Matrix

feature_attribute_matrix_path

Cluster Ids Array Name

feature_ids_array_name

Number of Clusters

init_clusters

Cell Mask Array

mask_array_path

Cluster Means Array Name

means_array_name

Stored Seed Value Array Name

seed_array_name

Seed Value

seed_value

Attribute Array to Cluster

selected_array_path

Use Mask Array

use_mask

Use Seed for Random Generation

use_seed

Execute(data_structure, distance_metric_index, feature_attribute_matrix_path, feature_ids_array_name, init_clusters, mask_array_path, means_array_name, seed_array_name, seed_value, selected_array_path, use_mask, use_seed)
Parameters:
Returns:

Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.

Return type:

nx.IFilter.ExecuteResult

Compute K Medoids

class simplnx.ComputeKMedoidsFilter

*Warning:* The randomnes in this filter is not currently consistent between operating systems even if the same seed is used. Specifically between Unix and Windows. This does not affect the results, but the IDs will not correspond. For example if the Cluster Identifier at index one on Linux is 1 it could be 2 on Windows, the overarching clusters will be the same, but their IDs will be different.

Link to the full online documentation for ComputeKMedoidsFilter

Mapping of UI display to python named argument

UI Display

Python Named Argument

Distance Metric

distance_metric_index

Cluster Attribute Matrix

feature_attribute_matrix_path

Cluster Ids Array Name

feature_ids_array_name

Number of Clusters

init_clusters

Mask Array

mask_array_path

Cluster Medoids Array Name

medoids_array_name

Stored Seed Value Array Name

seed_array_name

Seed Value

seed_value

Attribute Array to Cluster

selected_array_path

Use Mask Array

use_mask

Use Seed for Random Generation

use_seed

Execute(data_structure, distance_metric_index, feature_attribute_matrix_path, feature_ids_array_name, init_clusters, mask_array_path, medoids_array_name, seed_array_name, seed_value, selected_array_path, use_mask, use_seed)
Parameters:
Returns:

Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.

Return type:

nx.IFilter.ExecuteResult

Compute Feature Largest Cross-Section Areas

class simplnx.ComputeLargestCrossSectionsFilter

This Filter calculates the largest cross-sectional area on a user-defined plane for all Features. The Filter simply iterates through all Cells (on each section) asking for Feature that owns them. On each section, the count of Cells for each Feature is then converted to an area and stored as the LargestCrossSection if the area for the current section is larger than the existing LargestCrossSection for that Feature.

Link to the full online documentation for ComputeLargestCrossSectionsFilter

Mapping of UI display to python named argument

UI Display

Python Named Argument

Feature Attribute Matrix

cell_feature_attribute_matrix_path

Cell Feature Ids

feature_ids_array_path

Image Geometry

input_image_geometry_path

Largest Cross Sections

largest_cross_sections_array_name

Plane of Interest

plane_index

Execute(data_structure, cell_feature_attribute_matrix_path, feature_ids_array_path, input_image_geometry_path, largest_cross_sections_array_name, plane_index)
Parameters:
Returns:

Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.

Return type:

nx.IFilter.ExecuteResult

Compute Moment Invariants (2D)

class simplnx.ComputeMomentInvariants2DFilter

This Filter computes the 2D Omega-1 and Omega 2 values from the Central Moments matrix and optionally will normalize the values to a unit circle and also optionally save the Central Moments matrix as a DataArray to the Cell Feature Attribute Matrix. Based off the paper by MacSleyne et. al [1], the algorithm will calculate the 2D central moments for each feature starting at feature id = 1. Because feature id 0 is of special significance and typically is a matrix or background it is ignored in this filter. If any feature id has a Z Delta of > 1, the feature will be skipped. This algorithm works strictly in the XY plane and is meant to be applied to a 2D image. Using the research from the cited paper certain shapes can be detected using the Omega-1 and Omega-2 values. An example usage is finding elliptical shapes in an image:

Link to the full online documentation for ComputeMomentInvariants2DFilter

Mapping of UI display to python named argument

UI Display

Python Named Argument

Central Moments

central_moments_array_name

Feature Attribute Matrix

feature_attribute_matrix_path

Cell Feature Ids

feature_ids_array_path

Feature Rect

feature_rect_array_path

2D Image Geometry

input_image_geometry_path

Normalize Moment Invariants

normalize_moment_invariants

Omega 1

omega1_array_name

Omega 2

omega2_array_name

Save Central Moments

save_central_moments

Execute(data_structure, central_moments_array_name, feature_attribute_matrix_path, feature_ids_array_path, feature_rect_array_path, input_image_geometry_path, normalize_moment_invariants, omega1_array_name, omega2_array_name, save_central_moments)
Parameters:
Returns:

Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.

Return type:

nx.IFilter.ExecuteResult

Compute Neighbor List Statistics

class simplnx.ComputeNeighborListStatisticsFilter

This Filter computes the selected statistics for each list contained in a NeighborList container. Each of those statistics are reported back as new Attribute Arrays. The user selectable statistics are:

Link to the full online documentation for ComputeNeighborListStatisticsFilter

Mapping of UI display to python named argument

UI Display

Python Named Argument

Find Length

find_length

Find Maximum

find_maximum

Find Mean

find_mean

Find Median

find_median

Find Minimum

find_minimum

Find Standard Deviation

find_standard_deviation

Find Summation

find_summation

NeighborList to Compute Statistics

input_neighbor_list_path

Length

length_array_name

Maximum

maximum_array_name

Mean

mean_array_name

Median

median_array_name

Minimum

minimum_array_name

Standard Deviation

standard_deviation_array_name

Summation

summation_array_name

Execute(data_structure, find_length, find_maximum, find_mean, find_median, find_minimum, find_standard_deviation, find_summation, input_neighbor_list_path, length_array_name, maximum_array_name, mean_array_name, median_array_name, minimum_array_name, standard_deviation_array_name, summation_array_name)
Parameters:
  • data_structure (DataStructure) – The DataStructure object that holds the data to be processed.

  • find_length (nx.BoolParameter) – Specifies whether or not the filter creates the Length array during calculations

  • find_maximum (nx.BoolParameter) – Specifies whether or not the filter creates the Maximum array during calculations

  • find_mean (nx.BoolParameter) – Specifies whether or not the filter creates the Mean array during calculations

  • find_median (nx.BoolParameter) – Specifies whether or not the filter creates the Median array during calculations

  • find_minimum (nx.BoolParameter) – Specifies whether or not the filter creates the Minimum array during calculations

  • find_standard_deviation (nx.BoolParameter) – Specifies whether or not the filter creates the Standard Deviation array during calculations

  • find_summation (nx.BoolParameter) – Specifies whether or not the filter creates the Summation array during calculations

  • input_neighbor_list_path (nx.NeighborListSelectionParameter) – Input Data Array to compute statistics

  • length_array_name (nx.DataObjectNameParameter) – Path to create the Length array during calculations

  • maximum_array_name (nx.DataObjectNameParameter) – Path to create the Maximum array during calculations

  • mean_array_name (nx.DataObjectNameParameter) – Path to create the Mean array during calculations

  • median_array_name (nx.DataObjectNameParameter) – Path to create the Median array during calculations

  • minimum_array_name (nx.DataObjectNameParameter) – Path to create the Minimum array during calculations

  • standard_deviation_array_name (nx.DataObjectNameParameter) – Path to create the Standard Deviation array during calculations

  • summation_array_name (nx.DataObjectNameParameter) – Path to create the Summation array during calculations

Returns:

Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.

Return type:

nx.IFilter.ExecuteResult

Compute Feature Neighborhoods

class simplnx.ComputeNeighborhoodsFilter

This Filter determines the number of Features, for each Feature, whose centroids lie within a distance equal to a user defined multiple of the average Equivalent Sphere Diameter (average of all **Features*). The algorithm for determining the number of Features is given below:

Link to the full online documentation for ComputeNeighborhoodsFilter

Mapping of UI display to python named argument

UI Display

Python Named Argument

Centroids

centroids_array_path

Equivalent Diameters

equivalent_diameters_array_path

Phases

feature_phases_array_path

Selected Image Geometry

input_image_geometry_path

Multiples of Average Diameter

multiples_of_average

Neighborhood List

neighborhood_list_array_name

Neighborhoods

neighborhoods_array_name

Execute(data_structure, centroids_array_path, equivalent_diameters_array_path, feature_phases_array_path, input_image_geometry_path, multiples_of_average, neighborhood_list_array_name, neighborhoods_array_name)
Parameters:
  • data_structure (DataStructure) – The DataStructure object that holds the data to be processed.

  • centroids_array_path (nx.ArraySelectionParameter) – Path to the array specifying the X, Y, Z coordinates of Feature center of mass

  • equivalent_diameters_array_path (nx.ArraySelectionParameter) – Path to the array specifying the diameter of a sphere with the same volume as the Feature

  • feature_phases_array_path (nx.ArraySelectionParameter) – Path to the array specifying to which Ensemble each Feature belongs

  • input_image_geometry_path (nx.GeometrySelectionParameter) – The target geometry

  • multiples_of_average (nx.Float32Parameter) – Defines the search radius to use when looking for ‘neighboring’ Features

  • neighborhood_list_array_name (nx.DataObjectNameParameter) – List of the Features whose centroids are within the user specified multiple of equivalent sphere diameter from each Feature

  • neighborhoods_array_name (nx.DataObjectNameParameter) – Number of Features that have their centroid within the user specified multiple of equivalent sphere diameters from each Feature

Returns:

Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.

Return type:

nx.IFilter.ExecuteResult

Compute Number of Features

class simplnx.ComputeNumFeaturesFilter

This Filter determines the number of Features in each Ensemble by summing the total number of rows in the feature attribute matrix belonging to each phase.

Link to the full online documentation for ComputeNumFeaturesFilter

Mapping of UI display to python named argument

UI Display

Python Named Argument

Ensemble Attribute Matrix

ensemble_attribute_matrix_path

Feature Phases

feature_phases_array_path

Number of Features

num_features_array_name

Execute(data_structure, ensemble_attribute_matrix_path, feature_phases_array_path, num_features_array_name)
Parameters:
Returns:

Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.

Return type:

nx.IFilter.ExecuteResult

Compute Surface Area to Volume & Sphericity

class simplnx.ComputeSurfaceAreaToVolumeFilter

This Filter calculates the ratio of surface area to volume for each Feature in an Image Geometry.

Link to the full online documentation for ComputeSurfaceAreaToVolumeFilter

Mapping of UI display to python named argument

UI Display

Python Named Argument

Calculate Sphericity

calculate_sphericity

Cell Feature Ids

feature_ids_path

Selected Image Geometry

input_image_geometry_path

Number of Cells

num_cells_array_path

Sphericity Array Name

sphericity_array_name

Surface Area to Volume Ratio

surface_area_volume_ratio_array_name

Execute(data_structure, calculate_sphericity, feature_ids_path, input_image_geometry_path, num_cells_array_path, sphericity_array_name, surface_area_volume_ratio_array_name)
Parameters:
Returns:

Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.

Return type:

nx.IFilter.ExecuteResult

Compute Surface Features

class simplnx.ComputeSurfaceFeaturesFilter

This Filter determines whether a Feature touches an outer surface of the sample. This is accomplished by simply querying the Feature owners of the Cells that sit at either . Any Feature that owns one of those Cells is said to touch an outer surface and all other Features are said to not touch an outer surface of the sample.

Link to the full online documentation for ComputeSurfaceFeaturesFilter

Mapping of UI display to python named argument

UI Display

Python Named Argument

Feature Attribute Matrix

feature_attribute_matrix_path

Cell Feature Ids

feature_ids_path

Feature Geometry

input_image_geometry_path

Mark Feature 0 Neighbors

mark_feature_0_neighbors

Surface Features

surface_features_array_name

Execute(data_structure, feature_attribute_matrix_path, feature_ids_path, input_image_geometry_path, mark_feature_0_neighbors, surface_features_array_name)
Parameters:
  • data_structure (DataStructure) – The DataStructure object that holds the data to be processed.

  • feature_attribute_matrix_path (nx.AttributeMatrixSelectionParameter) – The path to the cell feature attribute matrix associated with the input feature ids array

  • feature_ids_path (nx.ArraySelectionParameter) – Specifies to which Feature each cell belongs

  • input_image_geometry_path (nx.GeometrySelectionParameter) – The geometry in which to find surface features

  • mark_feature_0_neighbors (nx.BoolParameter) – Marks features that are neighbors with feature 0. If this option is off, only features that reside on the edge of the geometry will be marked.

  • surface_features_array_name (nx.DataObjectNameParameter) – The created surface features array. Flag of 1 if Feature touches an outer surface or of 0 if it does not

Returns:

Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.

Return type:

nx.IFilter.ExecuteResult

Compute Triangle Areas

class simplnx.ComputeTriangleAreasFilter

This Filter computes the area of each Triangle in a Triangle Geometry by calculating the following:

Link to the full online documentation for ComputeTriangleAreasFilter

Mapping of UI display to python named argument

UI Display

Python Named Argument

Triangle Geometry

input_triangle_geometry_path

Created Face Areas

triangle_areas_array_name

Execute(data_structure, input_triangle_geometry_path, triangle_areas_array_name)
Parameters:
  • data_structure (DataStructure) – The DataStructure object that holds the data to be processed.

  • input_triangle_geometry_path (nx.GeometrySelectionParameter) – The complete path to the Geometry for which to calculate the face areas

  • triangle_areas_array_name (nx.DataObjectNameParameter) – The complete path to the array storing the calculated face areas

Returns:

Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.

Return type:

nx.IFilter.ExecuteResult

Compute Feature Centroids from Triangle Geometry

class simplnx.ComputeTriangleGeomCentroidsFilter

This Filter determines the centroids of each Feature in a Triangle Geometry. The centroids are determinedusing the following algorithm:

Link to the full online documentation for ComputeTriangleGeomCentroidsFilter

Mapping of UI display to python named argument

UI Display

Python Named Argument

Calculated Centroids

centroids_array_name

Face Labels

face_labels_array_path

Face Feature Attribute Matrix

feature_attribute_matrix_path

Triangle Geometry

input_triangle_geometry_path

Execute(data_structure, centroids_array_name, face_labels_array_path, feature_attribute_matrix_path, input_triangle_geometry_path)
Parameters:
Returns:

Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.

Return type:

nx.IFilter.ExecuteResult

Compute Feature Volumes from Triangle Geometry

class simplnx.ComputeTriangleGeomVolumesFilter

This Filter computes the enclosed volume of each Feature in a Triangle Geometry. The result is the volume ofeach surface meshed Feature, or alternatively the volume of each unique polyhedron defined by the given _FaceLabels_ array. The volume of any generic polyhedron can be computed using the following algorithm:

Link to the full online documentation for ComputeTriangleGeomVolumesFilter

Mapping of UI display to python named argument

UI Display

Python Named Argument

Face Labels

face_labels_array_path

Face Feature Attribute Matrix

feature_attribute_matrix_path

Triangle Geometry

input_triangle_geometry_path

Calculated Volumes

volumes_array_name

Execute(data_structure, face_labels_array_path, feature_attribute_matrix_path, input_triangle_geometry_path, volumes_array_name)
Parameters:
Returns:

Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.

Return type:

nx.IFilter.ExecuteResult

Generate Vector Colors

class simplnx.ComputeVectorColorsFilter

This Filter generates a color for each Element based on the vector assigned to that Element in the input vector data. The color scheme assigns a unique color to all points on the unit hemisphere using a HSV-like scheme. The color space is approximately represented by the following legend.

Link to the full online documentation for ComputeVectorColorsFilter

Mapping of UI display to python named argument

UI Display

Python Named Argument

Vector Colors

cell_vector_colors_array_name

Mask Array

mask_array_path

Apply to Good Voxels Only (Bad Voxels Will Be Black)

use_mask

Vector Attribute Array

vectors_array_path

Execute(data_structure, cell_vector_colors_array_name, mask_array_path, use_mask, vectors_array_path)
Parameters:
Returns:

Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.

Return type:

nx.IFilter.ExecuteResult

Compute Vertex to Triangle Distances

class simplnx.ComputeVertexToTriangleDistancesFilter

This Filter computes distances between points in a Vertex Geoemtry and triangles in a Triangle Geoemtry. Specifically, for each point in the Vertex Geometry, the Euclidean distance to the closest triangle in the Triangle Geoemtry is stored. This distance is signed: if the point lies on the side of the triangle to which the triangle normal points, then the distance is positive; otherwise, the distance is negative. Additionally, the ID the closest triangle is stored for each point.

Link to the full online documentation for ComputeVertexToTriangleDistancesFilter

Mapping of UI display to python named argument

UI Display

Python Named Argument

Closest Triangle Ids Array

closest_triangle_id_array_name

Distances Array

distances_array_name

Target Triangle Geometry

input_triangle_geometry_path

Source Vertex Geometry

input_vertex_geometry_path

Triangle Normals

triangle_normals_array_path

Execute(data_structure, closest_triangle_id_array_name, distances_array_name, input_triangle_geometry_path, input_vertex_geometry_path, triangle_normals_array_path)
Parameters:
Returns:

Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.

Return type:

nx.IFilter.ExecuteResult

Compute Volume Fractions of Ensembles

class simplnx.ComputeVolumeFractionsFilter

This Filter determines the volume fraction of each Ensemble. The Filter counts the number of Cells belonging to each Ensemble and stores the number fraction.

Link to the full online documentation for ComputeVolumeFractionsFilter

Mapping of UI display to python named argument

UI Display

Python Named Argument

Cell Ensemble Attribute Matrix

cell_ensemble_attribute_matrix_path

Cell Phases

cell_phases_array_path

Volume Fractions

vol_fractions_array_name

Execute(data_structure, cell_ensemble_attribute_matrix_path, cell_phases_array_path, vol_fractions_array_name)
Parameters:
Returns:

Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.

Return type:

nx.IFilter.ExecuteResult

Concatenate Data Arrays

class simplnx.ConcatenateDataArraysFilter

This Filter concatenates multiple input arrays by taking a list of input arrays and appending their data sequentially into a single output array. The concatenation process involves combining the arrays such that the order of the input arrays directly affects the structure of the output. For example, if the first input array contains 5 tuples and the second contains 7 tuples, the resulting output array will have 12 tuples, with the tuples from the second array appended directly after those from the first array.

Link to the full online documentation for ConcatenateDataArraysFilter

Mapping of UI display to python named argument

UI Display

Python Named Argument

Arrays To Concatenate

input_arrays

Output Array

output_array_path

Execute(data_structure, input_arrays, output_array_path)
Parameters:
  • data_structure (DataStructure) – The DataStructure object that holds the data to be processed.

  • input_arrays (nx.MultiArraySelectionParameter) – Select the arrays that will be concatenated together. The arrays will be concatenated in the order they are listed here.

  • output_array_path (nx.ArrayCreationParameter) – The output array that contains the concatenated arrays.

Returns:

Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.

Return type:

nx.IFilter.ExecuteResult

Replace Value in Array (Conditional)

class simplnx.ConditionalSetValueFilter

This Filter replaces values in a user specified Attribute Array with a user specified value a second boolean Attribute Array specifies, but only when Use Conditional Mask is true. For example, if the user entered a Replace Value of 5.5, then for every occurence of true in the conditional boolean array, the selected Attribute Array would be changed to 5.5. If Use Conditional Mask is false, then Value to Replace will be searched for in the provided Attribute Array and all instances will be replaced. Below are the ranges for the values that can be entered for the different primitive types of arrays (for user reference). The selected Attribute Array must be a scalar array.

Link to the full online documentation for ConditionalSetValueFilter

Mapping of UI display to python named argument

UI Display

Python Named Argument

Conditional Array

conditional_array_path

Invert Mask

invert_mask

Value To Replace

remove_value

New Value

replace_value

Attribute Array

selected_array_path

Use Conditional Mask

use_conditional

Execute(data_structure, conditional_array_path, invert_mask, remove_value, replace_value, selected_array_path, use_conditional)
Parameters:
  • data_structure (DataStructure) – The DataStructure object that holds the data to be processed.

  • conditional_array_path (nx.ArraySelectionParameter) – The complete path to the conditional array that will determine which values/entries will be replaced if index is TRUE

  • invert_mask (nx.BoolParameter) – This makes the filter replace values that are marked FALSE in the conditional array

  • remove_value (nx.StringParameter) – The numerical value that will be replaced in the array

  • replace_value (nx.StringParameter) – The value that will be used as the replacement value

  • selected_array_path (nx.ArraySelectionParameter) – The complete path to array that will have values replaced

  • use_conditional (nx.BoolParameter) – Whether to use a boolean mask array to replace values marked TRUE

Returns:

Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.

Return type:

nx.IFilter.ExecuteResult

Color to GrayScale

class simplnx.ConvertColorToGrayScaleFilter

This Filter allows the user to select a flattening method for turning an array of RGB or RGBa values into grayscale values.

Link to the full online documentation for ConvertColorToGrayScaleFilter

Mapping of UI display to python named argument

UI Display

Python Named Argument

Color Channel

color_channel

Color Weighting

color_weights

Conversion Algorithm

conversion_algorithm_index

Input Data Arrays

input_data_array_paths

Output Data Array Prefix

output_array_prefix

Execute(data_structure, color_channel, color_weights, conversion_algorithm_index, input_data_array_paths, output_array_prefix)
Parameters:
  • data_structure (DataStructure) – The DataStructure object that holds the data to be processed.

  • color_channel (nx.Int32Parameter) – The specific R|G|B channel to use as the GrayScale values

  • color_weights (nx.VectorFloat32Parameter) – The weightings for each R|G|B component when using the luminosity conversion algorithm

  • conversion_algorithm_index (nx.ChoicesParameter) – Which method to use when flattening the RGB array

  • input_data_array_paths (nx.MultiArraySelectionParameter) – Select all DataArrays that need to be converted to GrayScale

  • output_array_prefix (nx.StringParameter) – This prefix will be added to each array name that is selected for conversion to form the new array name

Returns:

Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.

Return type:

nx.IFilter.ExecuteResult

Convert AttributeArray DataType

class simplnx.ConvertDataFilter

This Filter converts attribute data from one primitive type to another by using the built in translation of the compiler. This Filter can be used if the user needs to convert an array into a type that is accepted by another Filter. For example, a Filter may need an input array to be of type _int32_t_ but the array that the user would like to use is _uint16_t_. The user may use this Filter to create a new array that has the proper target type (_int32_t_).

Link to the full online documentation for ConvertDataFilter

Mapping of UI display to python named argument

UI Display

Python Named Argument

Data Array to Convert

array_to_convert_path

Converted Data Array

converted_array_name

Remove Original Array

delete_original_array

Scalar Type

scalar_type_index

Execute(data_structure, array_to_convert_path, converted_array_name, delete_original_array, scalar_type_index)
Parameters:
Returns:

Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.

Return type:

nx.IFilter.ExecuteResult

Copy Data Object

class simplnx.CopyDataObjectFilter

This Filter deep copies one or more DataObjects.

Link to the full online documentation for CopyDataObjectFilter

Mapping of UI display to python named argument

UI Display

Python Named Argument

Objects to copy

existing_data_path

New Parent Destination

new_data_path

Copied Object(s) Suffix

new_path_suffix

Copy to New Parent

use_new_parent

Execute(data_structure, existing_data_path, new_data_path, new_path_suffix, use_new_parent)
Parameters:
Returns:

Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.

Return type:

nx.IFilter.ExecuteResult

Create Element Array from Feature Array

class simplnx.CopyFeatureArrayToElementArrayFilter

This Filter copies the values associated with a Feature to all the Elements that belong to that Feature. Xmdf visualization files write only the Element attributes, so if the user wants to display a spatial map of a Feature level attribute, this Filter will transfer that information down to the Element level.

Link to the full online documentation for CopyFeatureArrayToElementArrayFilter

Mapping of UI display to python named argument

UI Display

Python Named Argument

Created Array Suffix

created_array_suffix

Cell Feature Ids

feature_ids_path

Feature Data to Copy to Cell Data

selected_feature_array_paths

Execute(data_structure, created_array_suffix, feature_ids_path, selected_feature_array_paths)
Parameters:
  • data_structure (DataStructure) – The DataStructure object that holds the data to be processed.

  • created_array_suffix (nx.StringParameter) – The suffix to add to the input attribute array name when creating the copied array

  • feature_ids_path (nx.ArraySelectionParameter) – Specifies to which Feature each cell belongs

  • selected_feature_array_paths (nx.MultiArraySelectionParameter) – The DataPath to the feature data that should be copied to the cell level

Returns:

Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.

Return type:

nx.IFilter.ExecuteResult

Create AM Scan Paths

class simplnx.CreateAMScanPathsFilter

Given an input Edge Geometry, stripe width, hatch spacing, laser power, and scan speed, this Filter will generate an Edge Geometry representing the additive manufacturing scan paths along with arrays containing times for each scan path node and powers, region ids, and slice ids for each scan path. The “SliceTriangleGeometry” filter is typically used before this filter to generate the proper edge geometry.

Link to the full online documentation for CreateAMScanPathsFilter

Mapping of UI display to python named argument

UI Display

Python Named Argument

Region Ids

cad_region_ids_array_path

Slice Data Container

cad_slice_data_container_path

Slice Ids

cad_slice_ids_array_path

Edge Attribute Matrix

hatch_attribute_matrix_name

Scan Vector Geometry

hatch_data_container_path

Hatch Length

hatch_length

Hatch Spacing

hatch_spacing

Region Ids

region_ids_array_name

Hatch Rotation Angle (Degrees)

rotation_angle

Vertex Attribute Matrix

vertex_attribute_matrix_name

Execute(data_structure, cad_region_ids_array_path, cad_slice_data_container_path, cad_slice_ids_array_path, hatch_attribute_matrix_name, hatch_data_container_path, hatch_length, hatch_spacing, region_ids_array_name, rotation_angle, vertex_attribute_matrix_name)
Parameters:
Returns:

Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.

Return type:

nx.IFilter.ExecuteResult

Create Attribute Matrix

class simplnx.CreateAttributeMatrixFilter

This Filter creates a new Attribute Matrix.

Link to the full online documentation for CreateAttributeMatrixFilter

Mapping of UI display to python named argument

UI Display

Python Named Argument

DataObject Path

data_object_path

Attribute Matrix Dimensions (Slowest to Fastest Dimensions)

tuple_dimensions

Execute(data_structure, data_object_path, tuple_dimensions)
Parameters:
Returns:

Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.

Return type:

nx.IFilter.ExecuteResult

Create Color Map

class simplnx.CreateColorMapFilter

This Filter generates a color table array for a given 1-component input array. Each element of the input arrayis normalized and converted to a color based on where the value falls in the spectrum of the selected color preset.

Link to the full online documentation for CreateColorMapFilter

Mapping of UI display to python named argument

UI Display

Python Named Argument

Data Array

input_data_array_path

Masked Color (RGB)

invalid_color_value

Mask Array

mask_array_path

Output RGB Array

output_rgb_array_name

Select Preset…

selected_preset

Use Mask Array

use_mask

Execute(data_structure, input_data_array_path, invalid_color_value, mask_array_path, output_rgb_array_name, selected_preset, use_mask)
Parameters:
  • data_structure (DataStructure) – The DataStructure object that holds the data to be processed.

  • input_data_array_path (nx.ArraySelectionParameter) – The complete path to the data array from which to create the rgb array by applying the selected preset color scheme

  • invalid_color_value (nx.VectorUInt8Parameter) – The color to assign to voxels that have a mask value of FALSE

  • mask_array_path (nx.ArraySelectionParameter) – Path to the data array used to define Elements as good or bad.

  • output_rgb_array_name (nx.DataObjectNameParameter) – The rgb array created by normalizing each element of the input array and converting to a color based on the selected preset color scheme

  • selected_preset (nx.CreateColorMapParameter) – Select a preset color scheme to apply to the created array

  • use_mask (nx.BoolParameter) – Whether to assign a black color to ‘bad’ Elements

Returns:

Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.

Return type:

nx.IFilter.ExecuteResult

Create Data Array (Advanced)

class simplnx.CreateDataArrayAdvancedFilter

This Filter creates a Data Array of any primitive type with any set of component dimensions. The array is initialized to a user defined value or with random values within a specified range.

Link to the full online documentation for CreateDataArrayAdvancedFilter

Mapping of UI display to python named argument

UI Display

Python Named Argument

Data Array Component Dimensions (Slowest to Fastest Dimensions)

component_dimensions

Data Format

data_format

Initialization End Range [Seperated with ;]

init_end_range

Initialization Start Range [Seperated with ;]

init_start_range

Initialization Type

init_type_index

Fill Values [Seperated with ;]

init_value

Output Numeric Type

numeric_type_index

Created Array

output_array_path

Stored Seed Value Array Name

seed_array_name

Seed Value

seed_value

Set Tuple Dimensions [not required if creating inside an existing Attribute Matrix]

set_tuple_dimensions

Use the Same Seed for Each Component

standardize_seed

Starting Value [Seperated with ;]

starting_fill_value

Step Operation

step_operation_index

Step Value [Seperated with ;]

step_value

Data Array Tuple Dimensions (Slowest to Fastest Dimensions)

tuple_dimensions

Use Seed for Random Generation

use_seed

Execute(data_structure, component_dimensions, data_format, init_end_range, init_start_range, init_type_index, init_value, numeric_type_index, output_array_path, seed_array_name, seed_value, set_tuple_dimensions, standardize_seed, starting_fill_value, step_operation_index, step_value, tuple_dimensions, use_seed)
Parameters:
  • data_structure (DataStructure) – The DataStructure object that holds the data to be processed.

  • component_dimensions (nx.DynamicTableParameter) – Slowest to Fastest Component Dimensions.

  • data_format (nx.DataStoreFormatParameter) – This value will specify which data format is used by the array’s data store. An empty string results in in-memory data store.

  • init_end_range (nx.StringParameter) – [Inclusive] The upper bound initialization range for random values

  • init_start_range (nx.StringParameter) – [Inclusive] The lower bound initialization range for random values

  • init_type_index (nx.ChoicesParameter) – Method for determining the what values of the data in the array should be initialized to

  • init_value (nx.StringParameter) – Specify values for each component. Ex: A 3-component array would be 6;8;12 and every tuple would have these same component values

  • numeric_type_index (nx.NumericTypeParameter) – Numeric Type of data to create

  • output_array_path (nx.ArrayCreationParameter) – Array storing the data

  • seed_array_name (nx.DataObjectNameParameter) – Name of the array holding the seed value

  • seed_value (nx.UInt64Parameter) – The seed fed into the random generator

  • set_tuple_dimensions (nx.BoolParameter) – This allows the user to set the tuple dimensions directly rather than just inheriting them. This option is NOT required if you are creating the Data Array in an Attribute Matrix

  • standardize_seed (nx.BoolParameter) – When true the same seed will be used for each component’s generator in a multi-component array

  • starting_fill_value (nx.StringParameter) – The value to start incrementing from. Ex: 6;8;12 would increment a 3-component array starting at 6 for the first component, 8 for the 2nd, and 12 for the 3rd.

  • step_operation_index (nx.ChoicesParameter) – The type of step operation to perform

  • step_value (nx.StringParameter) – The number to add/subtract the fill value by

  • tuple_dimensions (nx.DynamicTableParameter) – Slowest to Fastest Dimensions. Note this might be opposite displayed by an image geometry.

  • use_seed (nx.BoolParameter) – When true, the Seed Value will be used to seed the generator

Returns:

Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.

Return type:

nx.IFilter.ExecuteResult

Create Data Array

class simplnx.CreateDataArrayFilter

This Filter creates an Data Array of any primitive type with any number of components along a single component dimension. For example, a scalar as (1) or a 3-vector as (3), but not a matrix as (3, 3). The array is initialized to a user define value or with random values within a specified range.

Link to the full online documentation for CreateDataArrayFilter

Mapping of UI display to python named argument

UI Display

Python Named Argument

Total Number of Components

component_count

Data Format

data_format

Initialization Value

initialization_value_str

Output Numeric Type

numeric_type_index

Created Array

output_array_path

Set Tuple Dimensions [not required if creating inside an Attribute Matrix]

set_tuple_dimensions

Data Array Dimensions (Slowest to Fastest Dimensions)

tuple_dimensions

Execute(data_structure, component_count, data_format, initialization_value_str, numeric_type_index, output_array_path, set_tuple_dimensions, tuple_dimensions)
Parameters:
  • data_structure (DataStructure) – The DataStructure object that holds the data to be processed.

  • component_count (nx.UInt64Parameter) – Total number of components. Do not set the component dimensions.

  • data_format (nx.DataStoreFormatParameter) – This value will specify which data format is used by the array’s data store. An empty string results in in-memory data store.

  • initialization_value_str (nx.StringParameter) – This value will be used to fill the new array

  • numeric_type_index (nx.NumericTypeParameter) – Numeric Type of data to create

  • output_array_path (nx.ArrayCreationParameter) – Array storing the data

  • set_tuple_dimensions (nx.BoolParameter) – This allows the user to set the tuple dimensions directly rather than just inheriting them. This option is NOT required if you are creating the Data Array in an Attribute Matrix

  • tuple_dimensions (nx.DynamicTableParameter) – Slowest to Fastest Dimensions. Note this might be opposite displayed by an image geometry.

Returns:

Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.

Return type:

nx.IFilter.ExecuteResult

Create Data Group

class simplnx.CreateDataGroupFilter

This Filter creates a new DataGroup.

Link to the full online documentation for CreateDataGroupFilter

Mapping of UI display to python named argument

UI Display

Python Named Argument

DataObject Path

data_object_path

Execute(data_structure, data_object_path)
Parameters:
Returns:

Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.

Return type:

nx.IFilter.ExecuteResult

Create Feature Array from Element Array

class simplnx.CreateFeatureArrayFromElementArrayFilter

This Filter copies all the associated Element data of a selected Element Array to the Feature to which the Elements belong. The value stored for each Feature will be the value of the last element copied.

Link to the full online documentation for CreateFeatureArrayFromElementArrayFilter

Mapping of UI display to python named argument

UI Display

Python Named Argument

Feature Attribute Matrix

cell_feature_attribute_matrix_path

Created Feature Attribute Array

created_array_name

Cell Feature Ids

feature_ids_path

Data to Copy to Feature Data

selected_cell_array_path

Execute(data_structure, cell_feature_attribute_matrix_path, created_array_name, feature_ids_path, selected_cell_array_path)
Parameters:
Returns:

Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.

Return type:

nx.IFilter.ExecuteResult

Create Geometry

class simplnx.CreateGeometryFilter

This Filter creates a Geometry object and the necessary Element Attribute Matrices on which to store Attribute Arrays and Element Attribute Arrays which define the geometry. The type of Attribute Matrices and Attribute Arrays created depends on the kind of Geometry being created:

Link to the full online documentation for CreateGeometryFilter

Mapping of UI display to python named argument

UI Display

Python Named Argument

Array Handling

array_handling_index

Cell Attribute Matrix

cell_attribute_matrix_name

Dimensions

dimensions

Edge Attribute Matrix

edge_attribute_matrix_name

Edge List

edge_list_path

Face Attribute Matrix

face_attribute_matrix_name

Geometry Type

geometry_type_index

Hexahedral List

hexahedral_list_path

Length Unit

length_unit_index

Origin

origin

Geometry Name

output_geometry_path

Quadrilateral List

quadrilateral_list_path

Spacing

spacing

Tetrahedral List

tetrahedral_list_path

Triangle List

triangle_list_path

Vertex Attribute Matrix

vertex_attribute_matrix_name

Shared Vertex List

vertex_list_path

Treat Geometry Warnings as Errors

warnings_as_errors

X Bounds

x_bounds_path

Y Bounds

y_bounds_path

Z Bounds

z_bounds_path

Execute(data_structure, array_handling_index, cell_attribute_matrix_name, dimensions, edge_attribute_matrix_name, edge_list_path, face_attribute_matrix_name, geometry_type_index, hexahedral_list_path, length_unit_index, origin, output_geometry_path, quadrilateral_list_path, spacing, tetrahedral_list_path, triangle_list_path, vertex_attribute_matrix_name, vertex_list_path, warnings_as_errors, x_bounds_path, y_bounds_path, z_bounds_path)
Parameters:
Returns:

Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.

Return type:

nx.IFilter.ExecuteResult

Create Geometry (Image)

class simplnx.CreateImageGeometryFilter

This Filter creates an Image Geometry specifically for the representation of a 3D rectilinear grid of voxels (3D) or pixels(2D). Each axis can have its starting point (origin), resolution, and length defined for the Geometry. The Data Container in which to place the Image Geometry must be specified.

Link to the full online documentation for CreateImageGeometryFilter

Mapping of UI display to python named argument

UI Display

Python Named Argument

Cell Data Name

cell_data_name

Dimensions

dimensions

Origin

origin

Output Geometry Name

output_image_geometry_path

Spacing

spacing

Execute(data_structure, cell_data_name, dimensions, origin, output_image_geometry_path, spacing)
Parameters:
Returns:

Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.

Return type:

nx.IFilter.ExecuteResult

Create Python Plugin and/or Filters

class simplnx.CreatePythonSkeletonFilter

The Generate Python Plugin and/or Filters is a powerful tool in the DREAM3D-NX environment that allows users to generate or update Python plugins and filter codes. This filter provides an interface for setting up and configuring Python filters within DREAM3D-NX pipelines, either by creating new plugins or by adding to existing ones.

Link to the full online documentation for CreatePythonSkeletonFilter

Mapping of UI display to python named argument

UI Display

Python Named Argument

Filter Names (comma-separated)

filter_names

Human Name of Plugin

plugin_human_name

Existing Plugin Location

plugin_input_directory

Name of Plugin

plugin_name

Plugin Output Directory

plugin_output_directory

Use Existing Plugin

use_existing_plugin

Execute(data_structure, filter_names, plugin_human_name, plugin_input_directory, plugin_name, plugin_output_directory, use_existing_plugin)
Parameters:
  • data_structure (DataStructure) – The DataStructure object that holds the data to be processed.

  • filter_names (nx.StringParameter) – The names of filters that will be created, separated by commas (,).

  • plugin_human_name (nx.StringParameter) – This is the user facing name of the plugin.

  • plugin_input_directory (nx.FileSystemPathParameter) – The location of the existing plugin’s top level directory on the file system.

  • plugin_name (nx.StringParameter) – This is the name of the plugin.

  • plugin_output_directory (nx.FileSystemPathParameter) – The path to the output directory where the new plugin will be generated.

  • use_existing_plugin (nx.BoolParameter) – Generate the list of filters into an existing plugin instead of creating a new plugin.

Returns:

Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.

Return type:

nx.IFilter.ExecuteResult

Crop Geometry (Edge)

class simplnx.CropEdgeGeometryFilter

The Crop Geometry (Edge) Filter allows users to crop a region of interest (ROI) from an Edge Geometry. This filter is essential for isolating specific portions of edge-based data structures.

Link to the full online documentation for CropEdgeGeometryFilter

Mapping of UI display to python named argument

UI Display

Python Named Argument

Boundary Intersection Behavior

boundary_intersection_behavior_index

Crop X Dimension

crop_x_dim

Crop Y Dimension

crop_y_dim

Crop Z Dimension

crop_z_dim

Selected Edge Geometry

input_image_geometry_path

Max Coordinate [Inclusive]

max_coord

Min Coordinate

min_coord

Created Edge Geometry

output_image_geometry_path

Perform In Place

remove_original_geometry

Execute(data_structure, boundary_intersection_behavior_index, crop_x_dim, crop_y_dim, crop_z_dim, input_image_geometry_path, max_coord, min_coord, output_image_geometry_path, remove_original_geometry)
Parameters:
  • data_structure (DataStructure) – The DataStructure object that holds the data to be processed.

  • boundary_intersection_behavior_index (nx.ChoicesParameter) – The behavior to implement if an edge intersects a bound (one vertex is inside, one vertex is outside).

“Interpolate Outside Vertex” will move the outside vertex of a boundary-intersecting edge from its current position to the boundary edge. “Ignore Edge” will ignore any edge that intersects a bound. “Filter Error” will make this filter throw an error when it encounters an edge that intersects a bound.

param nx.BoolParameter crop_x_dim:

Enable cropping in the X dimension.

param nx.BoolParameter crop_y_dim:

Enable cropping in the Y dimension.

param nx.BoolParameter crop_z_dim:

Enable cropping in the Z dimension.

param nx.GeometrySelectionParameter input_image_geometry_path:

DataPath to the source Edge Geometry

param nx.VectorFloat32Parameter max_coord:

Upper bound of the edge geometry to crop.

param nx.VectorFloat32Parameter min_coord:

Lower bound of the edge geometry to crop.

param nx.DataGroupCreationParameter output_image_geometry_path:

The DataPath to store the created Edge Geometry

param nx.BoolParameter remove_original_geometry:

Replaces the original Edge Geometry after filter is completed

return:

Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.

rtype:

nx.IFilter.ExecuteResult

Crop Geometry (Image)

class simplnx.CropImageGeometryFilter

This Filter allows the user to crop a region of interest (ROI) from an Image Geometry. The input parameters are in units of voxels or physical coordinates.

Link to the full online documentation for CropImageGeometryFilter

Mapping of UI display to python named argument

UI Display

Python Named Argument

Feature Attribute Matrix

cell_feature_attribute_matrix_path

Crop X Dimension

crop_x_dim

Crop Y Dimension

crop_y_dim

Crop Z Dimension

crop_z_dim

Feature IDs

feature_ids_path

Selected Image Geometry

input_image_geometry_path

Max Coordinate (Physical Units) [Inclusive]

max_coord

Max Voxel [Inclusive]

max_voxel

Min Coordinate (Physical Units)

min_coord

Min Voxel

min_voxel

Created Image Geometry

output_image_geometry_path

Perform In Place

remove_original_geometry

Renumber Features

renumber_features

Use Physical Units For Bounds

use_physical_bounds

Execute(data_structure, cell_feature_attribute_matrix_path, crop_x_dim, crop_y_dim, crop_z_dim, feature_ids_path, input_image_geometry_path, max_coord, max_voxel, min_coord, min_voxel, output_image_geometry_path, remove_original_geometry, renumber_features, use_physical_bounds)
Parameters:
Returns:

Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.

Return type:

nx.IFilter.ExecuteResult

Crop Geometry (Vertex)

class simplnx.CropVertexGeometryFilter

This Filter crops a Vertex Geometry by the given bounding box. Unlike the cropping of an Image, it is unknown until run time how the Geometry will be changed by the cropping operation. Therefore, this Filter requires that a new Data Container be created to contain the cropped Vertex Geometry. This new Data Container will contain copies of any Feature or Ensemble Attribute Matrices from the original Data Container. Additionally, all Vertex data will be copied, with tuples removed for any Vertices outside the bounding box. The user must supply a name for the cropped Data Container, but all other copied objects (Attribute Matrices and Data Arrays) will retain the same names as the original source.

Link to the full online documentation for CropVertexGeometryFilter

Mapping of UI display to python named argument

UI Display

Python Named Argument

Vertex Geometry to Crop

input_vertex_geometry_path

Max Pos

max_pos

Min Pos

min_pos

Cropped Vertex Geometry

output_vertex_geometry_path

Vertex Data Arrays to crop

target_array_paths

Vertex Data Name

vertex_attribute_matrix_name

Execute(data_structure, input_vertex_geometry_path, max_pos, min_pos, output_vertex_geometry_path, target_array_paths, vertex_attribute_matrix_name)
Parameters:
Returns:

Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.

Return type:

nx.IFilter.ExecuteResult

DBSCAN

class simplnx.DBSCANFilter

This Filter applies the DBSCAN (density-based spatial clustering of applications with noise) algorithm to an Attribute Array. DBSCAN is a clustering algorithm that assigns to each point of the Attribute Array a cluster Id; points that have the same cluster Id are grouped together more densely (in the sense that the _distance_ between them is small) in the data space (i.e., points that have many nearest neighbors will belong to the same cluster). The user may select from a number of options to use as the distance metric. Points that are in sparse regions of the data space are considered “outliers”; these points will belong to cluster Id 0. Additionally, the user may opt to use a mask to ignore certain points; where the mask is false, the points will be categorized as outliers and placed in cluster 0. The algorithm requires two parameters: a neighborbood region, called epsilon; and the minimum number of points needed to form a cluster. The algorithm, in pseudocode, proceeds as follows:

Link to the full online documentation for DBSCANFilter

Mapping of UI display to python named argument

UI Display

Python Named Argument

Distance Metric

distance_metric_index

Epsilon

epsilon

Cluster Attribute Matrix

feature_attribute_matrix_path

Cluster Ids Array Name

feature_ids_array_name

Initialization Type

init_type_index

Cell Mask Array

mask_array_path

Minimum Points

min_points

Stored Seed Value Array Name

seed_array_name

Seed Value

seed_value

Attribute Array to Cluster

selected_array_path

Use Mask Array

use_mask

Use Precaching

use_precaching

Execute(data_structure, distance_metric_index, epsilon, feature_attribute_matrix_path, feature_ids_array_name, init_type_index, mask_array_path, min_points, seed_array_name, seed_value, selected_array_path, use_mask, use_precaching)
Parameters:
  • data_structure (DataStructure) – The DataStructure object that holds the data to be processed.

  • distance_metric_index (nx.ChoicesParameter) – Distance Metric type to be used for calculations

  • epsilon (nx.Float32Parameter) – The epsilon-neighborhood around each point is queried

  • feature_attribute_matrix_path (nx.DataGroupCreationParameter) – The complete path to the attribute matrix in which to store to hold Cluster Data

  • feature_ids_array_name (nx.DataObjectNameParameter) – Name of the ids array to be created in Attribute Array to Cluster’s parent group

  • init_type_index (nx.ChoicesParameter) – Whether to use random or iterative for start state. See Documentation for further detail

  • mask_array_path (nx.ArraySelectionParameter) – DataPath to the boolean or uint8 mask array. Values that are true will mark that cell/point as usable.

  • min_points (nx.Int32Parameter) – The minimum number of points needed to form a ‘dense region’ (i.e., the minimum number of points needed to be called a cluster)

  • seed_array_name (nx.DataObjectNameParameter) – Name of array holding the seed value

  • seed_value (nx.UInt64Parameter) – The seed fed into the random generator

  • selected_array_path (nx.ArraySelectionParameter) – The data array to cluster

  • use_mask (nx.BoolParameter) – Specifies whether or not to use a mask array

  • use_precaching (nx.BoolParameter) – If true the algorithm will be significantly faster, but it requires more memory

Returns:

Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.

Return type:

nx.IFilter.ExecuteResult

Delete Data

class simplnx.DeleteDataFilter

This Filter allows the user to remove specified objects from the existing structure. This can be helpful if the user has operations that need as much memory as possible and there are extra objects that are not needed residing in memory. Alternatively, this Filter allows the user to remove objects that may share a name with another object further in the Pipeline that another Filter tries to create, since DREAM3D-NX generally does not allows objects at the same hierarchy to share the same name.

Link to the full online documentation for DeleteDataFilter

Mapping of UI display to python named argument

UI Display

Python Named Argument

DataPaths to remove

removed_data_path

Execute(data_structure, removed_data_path)
Parameters:
Returns:

Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.

Return type:

nx.IFilter.ExecuteResult

Erode/Dilate Bad Data

class simplnx.ErodeDilateBadDataFilter

Bad data refers to a Cell that has a Feature Id of 0, which means the Cell has failed some sort of test andbeen marked as a bad Cell.

Link to the full online documentation for ErodeDilateBadDataFilter

Mapping of UI display to python named argument

UI Display

Python Named Argument

Cell Feature Ids

feature_ids_path

Attribute Arrays to Ignore

ignored_data_array_paths

Selected Image Geometry

input_image_geometry_path

Number of Iterations

num_iterations

Operation

operation_index

X Direction

x_dir_on

Y Direction

y_dir_on

Z Direction

z_dir_on

Execute(data_structure, feature_ids_path, ignored_data_array_paths, input_image_geometry_path, num_iterations, operation_index, x_dir_on, y_dir_on, z_dir_on)
Parameters:
Returns:

Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.

Return type:

nx.IFilter.ExecuteResult

Erode/Dilate Coordination Number

class simplnx.ErodeDilateCoordinationNumberFilter

This Filter will smooth the interface between good and bad data. The user can specify a coordination number,which is the number of neighboring Cells of opposite type (i.e., good or bad) compared to a given Cell thatis acceptable. For example, a single bad Cell surrounded by good Cells would have a coordination number of*6*. The number entered by the user is actually the maximum tolerated coordination number. If the user entered a valueof 4, then all good Cells with 5 or more bad neighbors and bad Cells with 5 or more good neighborswould be removed. After Cells with unacceptable coordination number are removed, then the neighboring Cells**are *coarsened* to fill the removed **Cells.

Link to the full online documentation for ErodeDilateCoordinationNumberFilter

Mapping of UI display to python named argument

UI Display

Python Named Argument

Coordination Number to Consider

coordination_number

Cell Feature Ids

feature_ids_path

Attribute Arrays to Ignore

ignored_data_array_paths

Selected Image Geometry

input_image_geometry_path

Loop Until Gone

loop

Execute(data_structure, coordination_number, feature_ids_path, ignored_data_array_paths, input_image_geometry_path, loop)
Parameters:
Returns:

Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.

Return type:

nx.IFilter.ExecuteResult

Erode/Dilate Mask

class simplnx.ErodeDilateMaskFilter

If the mask is _dilated_, the Filter grows the _true_ regions by one Cell in an iterative sequence for a userdefined number of iterations. During the _dilate_ process, the classification of any Cell neighboring a _false_ Cell will be changed to _true_. If the mask is _eroded_, the Filter shrinks the _true_ regions by one Cell inan iterative sequence for a user defined number of iterations. During the _erode_ process, the classification of the*false* Cells is changed to _true_ if one of its neighbors is _true_. The Filter also offers the option(s) toturn on/off the erosion or dilation in specific directions (X, Y or Z).

Link to the full online documentation for ErodeDilateMaskFilter

Mapping of UI display to python named argument

UI Display

Python Named Argument

Selected Image Geometry

input_image_geometry_path

Mask Array Path

mask_array_path

Number of Iterations

num_iterations

Operation

operation_index

X Direction

x_dir_on

Y Direction

y_dir_on

Z Direction

z_dir_on

Execute(data_structure, input_image_geometry_path, mask_array_path, num_iterations, operation_index, x_dir_on, y_dir_on, z_dir_on)
Parameters:
Returns:

Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.

Return type:

nx.IFilter.ExecuteResult

Execute Process

class simplnx.ExecuteProcessFilter

This filter allows the user to execute any application, program, shell script or any other executable program on the computer system. Any output can be found in the user specified log file.

Link to the full online documentation for ExecuteProcessFilter

Mapping of UI display to python named argument

UI Display

Python Named Argument

Command Line Arguments

arguments

Should Block

blocking

Output Log File

output_log_file

Timeout (ms)

timeout

Execute(data_structure, arguments, blocking, output_log_file, timeout)
Parameters:
  • data_structure (DataStructure) – The DataStructure object that holds the data to be processed.

  • arguments (nx.StringParameter) – The complete command to execute.

  • blocking (nx.BoolParameter) – Whether to block the process while the command executes or not

  • output_log_file (nx.FileSystemPathParameter) – The log file where the output from the process will be stored

  • timeout (nx.Int32Parameter) – The amount of time to wait for the command to start/finish when blocking is selected

Returns:

Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.

Return type:

nx.IFilter.ExecuteResult

Extract/Remove Components

class simplnx.ExtractComponentAsArrayFilter

This Filter will do one of the following to one component of a multicomponent Attribute Array:

Link to the full online documentation for ExtractComponentAsArrayFilter

Mapping of UI display to python named argument

UI Display

Python Named Argument

Component Index to Extract

comp_number

Move Extracted Components to New Array

move_components_to_new_array

Scalar Attribute Array

new_array_name

Remove Extracted Components from Old Array

remove_components_from_array

Multi-Component Attribute Array

selected_array_path

Execute(data_structure, comp_number, move_components_to_new_array, new_array_name, remove_components_from_array, selected_array_path)
Parameters:
  • data_structure (DataStructure) – The DataStructure object that holds the data to be processed.

  • comp_number (nx.Int32Parameter) – The index of the component in each tuple to be removed

  • move_components_to_new_array (nx.BoolParameter) – If true the extracted components will be placed in a new array

  • new_array_name (nx.DataObjectNameParameter) – The DataArray to store the extracted components

  • remove_components_from_array (nx.BoolParameter) – If true the extracted components will be deleted

  • selected_array_path (nx.ArraySelectionParameter) – The array to extract components from

Returns:

Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.

Return type:

nx.IFilter.ExecuteResult

Extract Internal Surfaces From Triangle Geometry

class simplnx.ExtractInternalSurfacesFromTriangleGeometryFilter

This Filter extracts any Triangles from the supplied Triangle Geometry that contain any internal nodes, then uses these extracted Triangles to create a new Data Container with the reduced Triangle Geometry. This operation is the same as removing all Triangles that only lie of the outer surface of the supplied Triangle Geometry. The user must supply a “Node Type” Vertex Attribute Array that defines the type for each node of the Triangle Geometry. Node types may take the following values:

Link to the full online documentation for ExtractInternalSurfacesFromTriangleGeometryFilter

Mapping of UI display to python named argument

UI Display

Python Named Argument

Copy Face Arrays

copy_triangle_array_paths

Copy Vertex Arrays

copy_vertex_array_paths

Triangle Geometry

input_triangle_geometry_path

Internal Surface Node Type Min & Max

node_type_range

Node Types Array

node_types_path

Created Triangle Geometry Path

output_triangle_geometry_path

Face Data Attribute Matrix

triangle_attribute_matrix_name

Vertex Data Attribute Matrix

vertex_attribute_matrix_name

Execute(data_structure, copy_triangle_array_paths, copy_vertex_array_paths, input_triangle_geometry_path, node_type_range, node_types_path, output_triangle_geometry_path, triangle_attribute_matrix_name, vertex_attribute_matrix_name)
Parameters:
Returns:

Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.

Return type:

nx.IFilter.ExecuteResult

Extract DREAM3D-NX Pipeline To File

class simplnx.ExtractPipelineToFileFilter

This Filter reads the pipeline from an hdf5 file with the .dream3d extension and writes it back out to a json formatted pipeline file with the appropriate extension based on whether the pipeline is a DREAM3D-NX version 6 (.json) or DREAM3D-NX version 7 (.d3dpipeline) formatted pipeline.

Link to the full online documentation for ExtractPipelineToFileFilter

Mapping of UI display to python named argument

UI Display

Python Named Argument

Input DREAM3D File Path

input_file_path

Output File Path

output_file_path

Execute(data_structure, input_file_path, output_file_path)
Parameters:
Returns:

Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.

Return type:

nx.IFilter.ExecuteResult

Extract Vertex Geometry

class simplnx.ExtractVertexGeometryFilter

This filter will extract all the voxel centers of an Image Geometry or a RectilinearGrid geometryinto a new Vertex Geometry. The user is given the option to copy or move cell arrays over to thenewly created VertexGeometry. The user can also supply a mask array which has the effect of onlycreating a vertex if the mask value = TRUE.

Link to the full online documentation for ExtractVertexGeometryFilter

Mapping of UI display to python named argument

UI Display

Python Named Argument

Array Handling

array_handling_index

Included Attribute Arrays

included_data_array_paths

Input Geometry

input_grid_geometry_path

Mask Array

mask_array_path

Output Shared Vertex List Name

output_shared_vertex_list_name

Output Vertex Attribute Matrix Name

output_vertex_attr_matrix_name

Output Vertex Geometry

output_vertex_geometry_path

Use Mask Array

use_mask

Execute(data_structure, array_handling_index, included_data_array_paths, input_grid_geometry_path, mask_array_path, output_shared_vertex_list_name, output_vertex_attr_matrix_name, output_vertex_geometry_path, use_mask)
Parameters:
Returns:

Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.

Return type:

nx.IFilter.ExecuteResult

Compute Feature Face Curvature

class simplnx.FeatureFaceCurvatureFilter

This Filter calculates principal direction vectors and the principal curvatures, and optionally the mean and Gaussian curvature, for each Triangle in a Triangle Geometry using the technique in [1]. The groups of Triangles over which to compute the curvatures is determines by the Features they are associated, denoted by their Face Labels. The curvature information will be stored in a Face Attribute Matrix.

Link to the full online documentation for FeatureFaceCurvatureFilter

Mapping of UI display to python named argument

UI Display

Python Named Argument

Compute Gaussian Curvature

compute_gaussian_curvature

Compute Mean Curvature

compute_mean_curvature_path

Compute Principal Direction Vectors

compute_principal_direction

Compute Weingarten Matrix

compute_weingarten_matrix

Face Attribute Matrix

face_attribute_matrix_path

Face Centroids

face_centroids_path

Face Labels

face_labels_path

Face Normals

face_normals_path

Feature Face Ids

feature_face_ids_path

Gaussian Curvature

gaussian_curvature_path

Triangle Geometry

input_triangle_geometry_path

Mean Curvature

mean_curvature_path

Neighborhood Ring Count

neighborhood_ring

Principal Curvature 1

principal_curvature_1_path

Principal Curvature 2

principal_curvature_2_path

Principal Direction 1

principal_direction_1_path

Principal Direction 2

principal_direction_2_path

Use Face Normals for Curve Fitting

use_normals

Weingarten Matrix

weingarten_matrix_path

Execute(data_structure, compute_gaussian_curvature, compute_mean_curvature_path, compute_principal_direction, compute_weingarten_matrix, face_attribute_matrix_path, face_centroids_path, face_labels_path, face_normals_path, feature_face_ids_path, gaussian_curvature_path, input_triangle_geometry_path, mean_curvature_path, neighborhood_ring, principal_curvature_1_path, principal_curvature_2_path, principal_direction_1_path, principal_direction_2_path, use_normals, weingarten_matrix_path)
Parameters:
Returns:

Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.

Return type:

nx.IFilter.ExecuteResult

Fill Bad Data

class simplnx.FillBadDataFilter

This Filter removes small noise in the data, but keeps larger regions that are possibly Features, e.g., pores or defects. This Filter collects the bad Cells (Feature Id = 0) and erodes them until none remain. However, contiguous groups of bad Cells that have at least as many Cells as the minimum allowed defect size entered by the user will not be eroded.

Link to the full online documentation for FillBadDataFilter

Mapping of UI display to python named argument

UI Display

Python Named Argument

Cell Phases

cell_phases_array_path

Cell Feature Ids

feature_ids_path

Attribute Arrays to Ignore

ignored_data_array_paths

Selected Image Geometry

input_image_geometry_path

Minimum Allowed Defect Size

min_allowed_defect_size

Store Defects as New Phase

store_as_new_phase

Execute(data_structure, cell_phases_array_path, feature_ids_path, ignored_data_array_paths, input_image_geometry_path, min_allowed_defect_size, store_as_new_phase)
Parameters:
Returns:

Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.

Return type:

nx.IFilter.ExecuteResult

Surface Contour Filter (Flying Edges 3D)

class simplnx.FlyingEdges3DFilter

This filter will draw a 3 dimensional contouring surface through an Image Geometry based on an input value.

Link to the full online documentation for FlyingEdges3DFilter

Mapping of UI display to python named argument

UI Display

Python Named Argument

Contour Value

contour_value

Data Array to Contour

input_data_array_path

Selected Image Geometry

input_image_geometry_path

Name of Output Triangle Geometry

output_triangle_geometry_path

Execute(data_structure, contour_value, input_data_array_path, input_image_geometry_path, output_triangle_geometry_path)
Parameters:
Returns:

Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.

Return type:

nx.IFilter.ExecuteResult

Isolate Largest Feature (Identify Sample)

class simplnx.IdentifySampleFilter

Often when performing a serial sectioning experiment (especially in the FIB-SEM), the sample is overscanned resulting in a border of bad data around the sample. This Filter attempts to identify the sample within the overscanned volume. The Filter makes the assumption that there is only one contiguous set of Cells that belong to the sample. The Filter requires that the user has already thresheld the data to determine which Cells are good and which are bad. The algorithm for the identification of the sample is then as follows:

Link to the full online documentation for IdentifySampleFilter

Mapping of UI display to python named argument

UI Display

Python Named Argument

Fill Holes in Largest Feature

fill_holes

Image Geometry

input_image_geometry_path

Mask Array

mask_array_path

Process Data Slice-By-Slice

slice_by_slice

Slice-By-Slice Plane

slice_by_slice_plane_index

Execute(data_structure, fill_holes, input_image_geometry_path, mask_array_path, slice_by_slice, slice_by_slice_plane_index)
Parameters:
  • data_structure (DataStructure) – The DataStructure object that holds the data to be processed.

  • fill_holes (nx.BoolParameter) – Whether to fill holes within sample after it is identified

  • input_image_geometry_path (nx.GeometrySelectionParameter) – DataPath to the target ImageGeom

  • mask_array_path (nx.ArraySelectionParameter) – DataPath to the mask array defining what is sample and what is not

  • slice_by_slice (nx.BoolParameter) – Whether to identify the largest sample (and optionally fill holes) slice-by-slice. This option is useful if you have a sample that is not water-tight and the holes open up to the overscan section, or if you have holes that sit on a boundary. The original algorithm will not fill holes that have these characteristics, only holes that are completely enclosed by the sample and water-tight. If you have holes that are not water-tight or sit on a boundary, choose this option and then pick the plane that will allow the holes to be water-tight on each slice of that plane.

  • slice_by_slice_plane_index (nx.ChoicesParameter) – Set the plane that the data will be processed slice-by-slice. For example, if you pick the XY plane, the data will be processed in the Z direction.

Returns:

Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.

Return type:

nx.IFilter.ExecuteResult

Initialize Data

class simplnx.InitializeDataFilter

This Filter allows the user to define the data set in a _DataArray_.

Link to the full online documentation for InitializeDataFilter

Mapping of UI display to python named argument

UI Display

Python Named Argument

Any Component Array

array_path

Initialization End Range [Seperated with ;]

init_end_range

Initialization Start Range [Seperated with ;]

init_start_range

Initialization Type

init_type_index

Fill Values [Seperated with ;]

init_value

Stored Seed Value Array Name

seed_array_name

Seed Value

seed_value

Use the Same Seed for Each Component

standardize_seed

Starting Value [Seperated with ;]

starting_fill_value

Step Operation

step_operation_index

Step Value [Seperated with ;]

step_value

Use Seed for Random Generation

use_seed

Execute(data_structure, array_path, init_end_range, init_start_range, init_type_index, init_value, seed_array_name, seed_value, standardize_seed, starting_fill_value, step_operation_index, step_value, use_seed)
Parameters:
  • data_structure (DataStructure) – The DataStructure object that holds the data to be processed.

  • array_path (nx.ArraySelectionParameter) – The data array in which to initialize the data

  • init_end_range (nx.StringParameter) – [Inclusive] The upper bound initialization range for random values

  • init_start_range (nx.StringParameter) – [Inclusive] The lower bound initialization range for random values

  • init_type_index (nx.ChoicesParameter) – Method for determining the what values of the data in the array should be initialized to

  • init_value (nx.StringParameter) – Specify values for each component. Ex: A 3-component array would be 6;8;12 and every tuple would have these same component values

  • seed_array_name (nx.DataObjectNameParameter) – Name of array holding the seed value

  • seed_value (nx.UInt64Parameter) – The seed fed into the random generator

  • standardize_seed (nx.BoolParameter) – When true the same seed will be used for each component’s generator in a multi-component array

  • starting_fill_value (nx.StringParameter) – The value to start incrementing from

  • step_operation_index (nx.ChoicesParameter) – The type of step operation to preform

  • step_value (nx.StringParameter) – The number to add/subtract the fill value by

  • use_seed (nx.BoolParameter) – When true the Seed Value will be used to seed the generator

Returns:

Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.

Return type:

nx.IFilter.ExecuteResult

Initialize Image Geometry Cell Data

class simplnx.InitializeImageGeomCellDataFilter

This Filter allows the user to define a subvolume of the data set in which the Filter will reset all data by writing zeros (0) into every array for every Cell within the subvolume.

Link to the full online documentation for InitializeImageGeomCellDataFilter

Mapping of UI display to python named argument

UI Display

Python Named Argument

Cell Arrays

cell_arrays

Initialization Range

init_range

Initialization Type

init_type_index

Initialization Value

init_value

Image Geometry

input_image_geometry_path

Max Point

max_point

Min Point

min_point

Stored Seed Value Array Name

seed_array_name

Seed Value

seed_value

Use Seed for Random Generation

use_seed

Execute(data_structure, cell_arrays, init_range, init_type_index, init_value, input_image_geometry_path, max_point, min_point, seed_array_name, seed_value, use_seed)
Parameters:
Returns:

Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.

Return type:

nx.IFilter.ExecuteResult

Interpolate Point Cloud to Regular Grid

class simplnx.InterpolatePointCloudToRegularGridFilter

This Filter interpolates the values of arrays stored in a Vertex Geometry onto a user-selected Image Geometry. The user defines the (x,y,z) radii of a kernel in real space units. This kernel can be intialized to either uniform or Gaussian. The interpolation algorithm proceeds as follows:

Link to the full online documentation for InterpolatePointCloudToRegularGridFilter

Mapping of UI display to python named argument

UI Display

Python Named Argument

Attribute Arrays to Copy

copy_arrays

Gaussian Sigmas

gaussian_sigmas

Interpolated Image Geometry

input_image_geometry_path

Mask

input_mask_path

Vertex Geometry to Interpolate

input_vertex_geometry_path

Attribute Arrays to Interpolate

interpolate_arrays

Interpolated Group

interpolated_group_name

Interpolation Technique

interpolation_index

Kernel Distances Group

kernel_distances_array_name

Kernel Size

kernel_size

Store Kernel Distances

store_kernel_distances

Use Mask Array

use_mask

Voxel Indices

voxel_indices_path

Execute(data_structure, copy_arrays, gaussian_sigmas, input_image_geometry_path, input_mask_path, input_vertex_geometry_path, interpolate_arrays, interpolated_group_name, interpolation_index, kernel_distances_array_name, kernel_size, store_kernel_distances, use_mask, voxel_indices_path)
Parameters:
Returns:

Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.

Return type:

nx.IFilter.ExecuteResult

Iterative Closest Point

class simplnx.IterativeClosestPointFilter

This Filter estimates the rigid body transformation (i.e., rotation and translation) between two sets of points representedby Vertex Geometries using the iterative closest point (ICP) algorithm. The two Vertex Geometries are not requiredto have the same number of points.

Link to the full online documentation for IterativeClosestPointFilter

Mapping of UI display to python named argument

UI Display

Python Named Argument

Apply Transformation to Moving Geometry

apply_transformation

Moving Vertex Geometry

input_moving_vertex_geometry_path

Target Vertex Geometry

input_target_vertex_geometry_path

Number of Iterations

num_iterations

Output Transform Array

transform_array_path

Execute(data_structure, apply_transformation, input_moving_vertex_geometry_path, input_target_vertex_geometry_path, num_iterations, transform_array_path)
Parameters:
Returns:

Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.

Return type:

nx.IFilter.ExecuteResult

Label CAD Geometry

class simplnx.LabelTriangleGeometryFilter

This Filter accepts a Triangle Geometry and checks the connectivity of Triangles and assigns them region ID**s in a mask accordingly as well as providing a count for the number of **Triangles in each Region.

Link to the full online documentation for LabelTriangleGeometryFilter

Mapping of UI display to python named argument

UI Display

Python Named Argument

Region Ids

created_region_ids_path

Triangle Geometry

input_triangle_geometry_path

Number of Triangles Array Name

num_triangles_name

Cell Feature Attribute Matrix Name

triangle_attribute_matrix_name

Execute(data_structure, created_region_ids_path, input_triangle_geometry_path, num_triangles_name, triangle_attribute_matrix_name)
Parameters:
  • data_structure (DataStructure) – The DataStructure object that holds the data to be processed.

  • created_region_ids_path (nx.ArrayCreationParameter) – The triangle id array for indexing into triangle groupings

  • input_triangle_geometry_path (nx.GeometrySelectionParameter) – The CAD Geometry to be labeled (TriangleGeom)

  • num_triangles_name (nx.DataObjectNameParameter) – The name of array created in the new AM that stores the number of triangles per group

  • triangle_attribute_matrix_name (nx.DataObjectNameParameter) – The name of the Cell Feature Attribute Matrix that will hold information arrays about each group; created in the CAD geometry

Returns:

Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.

Return type:

nx.IFilter.ExecuteResult

Laplacian Smoothing

class simplnx.LaplacianSmoothingFilter

This Filter applies Laplacian smoothing to a Triangle Geometry that represents a surface mesh. A. Belyaev [2] has a concise explanation of the Laplacian Smoothing as follows:

Link to the full online documentation for LaplacianSmoothingFilter

Mapping of UI display to python named argument

UI Display

Python Named Argument

Triangle Geometry

input_triangle_geometry_path

Iteration Steps

iteration_steps

Default Lambda

lambda_value

Mu Factor

mu_factor

Quadruple Points Lambda

quad_point_lambda

Node Type

surface_mesh_node_type_array_path

Outer Points Lambda

surface_point_lambda

Outer Quadruple Points Lambda

surface_quad_point_lambda

Outer Triple Line Lambda

surface_triple_line_lambda

Triple Line Lambda

triple_line_lambda

Use Taubin Smoothing

use_taubin_smoothing

Execute(data_structure, input_triangle_geometry_path, iteration_steps, lambda_value, mu_factor, quad_point_lambda, surface_mesh_node_type_array_path, surface_point_lambda, surface_quad_point_lambda, surface_triple_line_lambda, triple_line_lambda, use_taubin_smoothing)
Parameters:
  • data_structure (DataStructure) – The DataStructure object that holds the data to be processed.

  • input_triangle_geometry_path (nx.GeometrySelectionParameter) – The complete path to the surface mesh Geometry for which to apply Laplacian smoothing

  • iteration_steps (nx.Int32Parameter) – Number of iteration steps to perform. More steps causes more smoothing but will also cause the volume to shrink more. Increasing this number too high may cause collapse of points!

  • lambda_value (nx.Float32Parameter) – Value of λ to apply to general internal nodes that are not triple lines, quadruple points or on the surface of the volume

  • mu_factor (nx.Float32Parameter) – A value that is multiplied by Lambda the result of which is the mu in Taubin’s paper. The value should be a negative value.

  • quad_point_lambda (nx.Float32Parameter) – Value of λ to apply to nodes designated as quadruple points.

  • surface_mesh_node_type_array_path (nx.ArraySelectionParameter) – The complete path to the array specifying the type of node in the Geometry

  • surface_point_lambda (nx.Float32Parameter) – The value of λ to apply to nodes that lie on the outer surface of the volume

  • surface_quad_point_lambda (nx.Float32Parameter) – Value of λ for the quadruple Points that lie on the outer surface of the volume.

  • surface_triple_line_lambda (nx.Float32Parameter) – Value of λ for triple lines that lie on the outer surface of the volume

  • triple_line_lambda (nx.Float32Parameter) – Value of λ to apply to nodes designated as triple line nodes.

  • use_taubin_smoothing (nx.BoolParameter) – Use Taubin’s Lambda-Mu algorithm.

Returns:

Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.

Return type:

nx.IFilter.ExecuteResult

Map Point Cloud to Regular Grid

class simplnx.MapPointCloudToRegularGridFilter

This Filter determines, for a user-defined grid, in which voxel each point in a Vertex Geometry lies. The user can either construct a sampling grid by specifying the dimensions, or select a pre-existing Image Geometry to use as the sampling grid. The voxel indices that each point lies in are stored on the vertices.

Link to the full online documentation for MapPointCloudToRegularGridFilter

Mapping of UI display to python named argument

UI Display

Python Named Argument

Created Cell Data Name

cell_data_name

Grid Dimensions

grid_dimensions

Existing Image Geometry

input_image_geometry_path

Vertex Geometry

input_vertex_geometry_path

Mask

mask_path

Out of Bounds Handling

out_of_bounds_handling_index

Out of Bounds Value

out_of_bounds_value

Created Image Geometry

output_image_geometry_path

Sampling Grid Type

sampling_grid_index

Use Mask Array

use_mask

Created Voxel Indices

voxel_indices_name

Execute(data_structure, cell_data_name, grid_dimensions, input_image_geometry_path, input_vertex_geometry_path, mask_path, out_of_bounds_handling_index, out_of_bounds_value, output_image_geometry_path, sampling_grid_index, use_mask, voxel_indices_name)
Parameters:
Returns:

Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.

Return type:

nx.IFilter.ExecuteResult

Move Data

class simplnx.MoveDataFilter

This Filter allows the user to move an Attribute Array from one Attribute Matrix to another compatible Attribute Matrix or to move an Attribute Matrix from one Data Container to another Data Container. Attribute Matrices are compatible if the number of tuples are equal, not the actual tuple dimensions.

Link to the full online documentation for MoveDataFilter

Mapping of UI display to python named argument

UI Display

Python Named Argument

New Parent

destination_parent_path

Data to Move

source_data_paths

Execute(data_structure, destination_parent_path, source_data_paths)
Parameters:
Returns:

Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.

Return type:

nx.IFilter.ExecuteResult

Multi-Threshold Objects

class simplnx.MultiThresholdObjectsFilter

This Filter allows the user to input single or multiple criteria for thresholding Attribute Arrays in an Attribute Matrix. Internally, the algorithm creates the output boolean arrays for each comparison that the user creates. Comparisons can be either a value and boolean operator (Less Than, Greater Than, Equal To, Not Equal To) or a collective set of comparisons. Then all the output arrays are compared with their given comparison operator ( And / Or ) with the value of a set being the result of its own comparisons calculated from top to bottom.

Link to the full online documentation for MultiThresholdObjectsFilter

Mapping of UI display to python named argument

UI Display

Python Named Argument

Data Thresholds

array_thresholds_object

Mask Type

created_mask_type

Custom FALSE Value

custom_false_value

Custom TRUE Value

custom_true_value

Mask Array

output_data_array_name

Use Custom FALSE Value

use_custom_false_value

Use Custom TRUE Value

use_custom_true_value

Execute(data_structure, array_thresholds_object, created_mask_type, custom_false_value, custom_true_value, output_data_array_name, use_custom_false_value, use_custom_true_value)
Parameters:
  • data_structure (DataStructure) – The DataStructure object that holds the data to be processed.

  • array_thresholds_object (nx.ArrayThresholdsParameter) – DataArray thresholds to mask

  • created_mask_type (nx.DataTypeParameter) – DataType used for the created Mask Array

  • custom_false_value (nx.Float64Parameter) – This is the custom FALSE value that will be output to the mask array

  • custom_true_value (nx.Float64Parameter) – This is the custom TRUE value that will be output to the mask array

  • output_data_array_name (nx.DataObjectNameParameter) – DataPath to the created Mask Array

  • use_custom_false_value (nx.BoolParameter) – Specifies whether to output a custom FALSE value (the default value is 0)

  • use_custom_true_value (nx.BoolParameter) – Specifies whether to output a custom TRUE value (the default value is 1)

Returns:

Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.

Return type:

nx.IFilter.ExecuteResult

Fuse Regular Grids (Nearest Point)

class simplnx.NearestPointFuseRegularGridsFilter

This Filter fuses two Image Geometry data sets together. The grid of Cells in the Reference Data Container is overlaid on the grid of Cells in the Sampling Data Container. Each Cell in the Reference Data Container is associated with the nearest point in the Sampling Data Container (i.e., no interpolation is performed). All the attributes of the Cell in the Sampling Data Container are then assigned to the Cell in the Reference Data Container. Additional to the Cell attributes being copied, all Feature and Ensemble Attribute Matrices from the Sampling Data Container are copied to the Reference Data Container.

Link to the full online documentation for NearestPointFuseRegularGridsFilter

Mapping of UI display to python named argument

UI Display

Python Named Argument

Fill Value

fill_value

Reference Image Geometry

input_reference_image_geometry__path

Sampling Image Geometry

input_sampling_image_geometry_path

Reference Cell Attribute Matrix

reference_cell_attribute_matrix_path

Sampling Cell Attribute Matrix

sampling_cell_attribute_matrix_path

Use Custom Fill Value

use_fill

Execute(data_structure, fill_value, input_reference_image_geometry__path, input_sampling_image_geometry_path, reference_cell_attribute_matrix_path, sampling_cell_attribute_matrix_path, use_fill)
Parameters:
Returns:

Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.

Return type:

nx.IFilter.ExecuteResult

Partition Geometry

class simplnx.PartitionGeometryFilter

This Filter generates a partition grid and assigns partition IDs for every voxel/node of a given geometry.

Link to the full online documentation for PartitionGeometryFilter

Mapping of UI display to python named argument

UI Display

Python Named Argument

Cell Attribute Matrix

created_attribute_matrix_name

Cell Feature Ids

created_feature_ids_name

Existing Partition Grid

existing_partitioning_scheme_path

Feature Attribute Matrix

feature_attr_matrix_name

Input Geometry Cell Attribute Matrix

input_geometry_attribute_matrix_path

Input Geometry to Partition

input_geometry_path

Cell Length (Physical Units)

length_per_partition

Minimum Grid Coordinate

lower_left_coord

Number Of Cells Per Axis

number_of_partitions_per_axis

Out-Of-Bounds Feature ID

out_of_bounds_value

Partition Grid Geometry

output_image_geometry_path

Partition Ids

partition_ids_array_name

Select the partitioning mode

partitioning_mode_index

Partition Grid Origin

partitioning_scheme_origin

Starting Feature ID

starting_partition_id

Maximum Grid Coordinate

upper_right_coord

Use Vertex Mask (Node Geometries Only)

use_vertex_mask

Vertex Mask

vertex_mask_path

Execute(data_structure, created_attribute_matrix_name, created_feature_ids_name, existing_partitioning_scheme_path, feature_attr_matrix_name, input_geometry_attribute_matrix_path, input_geometry_path, length_per_partition, lower_left_coord, number_of_partitions_per_axis, out_of_bounds_value, output_image_geometry_path, partition_ids_array_name, partitioning_mode_index, partitioning_scheme_origin, starting_partition_id, upper_right_coord, use_vertex_mask, vertex_mask_path)
Parameters:
  • data_structure (DataStructure) – The DataStructure object that holds the data to be processed.

  • created_attribute_matrix_name (nx.DataObjectNameParameter) – The name of the cell attribute matrix that will contain the partition grid’s cell data arrays.

  • created_feature_ids_name (nx.DataObjectNameParameter) – The name of the feature ids array that will contain the feature ids of the generated partition grid.

  • existing_partitioning_scheme_path (nx.GeometrySelectionParameter) – This is an existing Image Geometry that defines the partition grid that will be used.

  • feature_attr_matrix_name (nx.DataObjectNameParameter) – The name of the feature attribute matrix that will be created as a child of the input geometry.

  • input_geometry_attribute_matrix_path (nx.AttributeMatrixSelectionParameter) – The attribute matrix that represents the cell data for the geometry.(Vertex=>Node Geometry, Cell=>Image/Rectilinear)

  • input_geometry_path (nx.GeometrySelectionParameter) – The input geometry that will be partitioned

  • length_per_partition (nx.VectorFloat32Parameter) – The length in physical units for each cell in the partition grid. The physical units are automatically set by the input geometry.

  • lower_left_coord (nx.VectorFloat32Parameter) – Minimum grid coordinate used to create the partition grid

  • number_of_partitions_per_axis (nx.VectorInt32Parameter) – The number of cells along each axis of the partition grid

  • out_of_bounds_value (nx.Int32Parameter) – The value used as the feature id for voxels/nodes that are outside the bounds of the partition grid.

  • output_image_geometry_path (nx.DataGroupCreationParameter) – The complete path to the created partition grid geometry

  • partition_ids_array_name (nx.DataObjectNameParameter) – The name of the partition ids output array stored in the input cell attribute matrix

  • partitioning_mode_index (nx.ChoicesParameter) – Mode can be ‘Basic (0)’, ‘Advanced (1)’, ‘Bounding Box (2)’, ‘Existing Partition Grid (3)’

  • partitioning_scheme_origin (nx.VectorFloat32Parameter) – The origin of the generated partition geometry

  • starting_partition_id (nx.Int32Parameter) – The value to start the partition grid’s feature ids at.

  • upper_right_coord (nx.VectorFloat32Parameter) – Maximum grid coordinate used to create the partition grid

  • use_vertex_mask (nx.BoolParameter) – Feature ID values will only be placed on vertices that have a ‘true’ mask value. All others will have the Out-Of-Bounds Feature ID value used instead

  • vertex_mask_path (nx.ArraySelectionParameter) – The complete path to the vertex mask array.

Returns:

Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.

Return type:

nx.IFilter.ExecuteResult

Point Sample Triangle Geometry

class simplnx.PointSampleTriangleGeometryFilter

This Filter randomly samples point locations on Triangles in a Triangle Geometry. The sampled point locations are then used to construct a Vertex Geometry. The number of point samples may either be specified manually or by inferring from another Geometry:

Link to the full online documentation for PointSampleTriangleGeometryFilter

Mapping of UI display to python named argument

UI Display

Python Named Argument

Face Attribute Arrays to Transfer

input_data_array_paths

Triangle Geometry to Sample

input_triangle_geometry_path

Mask Array

mask_array_path

Number of Sample Points

number_of_samples

Vertex Geometry Name

output_vertex_geometry_path

Stored Seed Value Array Name

seed_array_name

Seed Value

seed_value

Face Areas

triangle_areas_array_path

Use Mask Array

use_mask

Use Seed for Random Generation

use_seed

Vertex Data

vertex_data_group_name

Execute(data_structure, input_data_array_paths, input_triangle_geometry_path, mask_array_path, number_of_samples, output_vertex_geometry_path, seed_array_name, seed_value, triangle_areas_array_path, use_mask, use_seed, vertex_data_group_name)
Parameters:
  • data_structure (DataStructure) – The DataStructure object that holds the data to be processed.

  • input_data_array_paths (nx.MultiArraySelectionParameter) – The paths to the Face Attribute Arrays to transfer to the created Vertex Geometry where the mask is false, if Use Mask is checked

  • input_triangle_geometry_path (nx.GeometrySelectionParameter) – The complete path to the triangle Geometry from which to sample

  • mask_array_path (nx.ArraySelectionParameter) – DataPath to the boolean mask array. Values that are true will mark that cell/point as usable.

  • number_of_samples (nx.Int32Parameter) – The number of sample points to use

  • output_vertex_geometry_path (nx.DataGroupCreationParameter) – The complete path to the DataGroup holding the Vertex Geometry that represents the sampling points

  • seed_array_name (nx.DataObjectNameParameter) – Name of array holding the seed value

  • seed_value (nx.UInt64Parameter) – The seed fed into the random generator

  • triangle_areas_array_path (nx.ArraySelectionParameter) – The complete path to the array specifying the area of each Face

  • use_mask (nx.BoolParameter) – Specifies whether or not to use a mask array

  • use_seed (nx.BoolParameter) – When true the user will be able to put in a seed for random generation

  • vertex_data_group_name (nx.DataObjectNameParameter) – The complete path to the vertex data arrays for the Vertex Geometry

Returns:

Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.

Return type:

nx.IFilter.ExecuteResult

Create Surface Mesh (QuickMesh)

class simplnx.QuickSurfaceMeshFilter

This Filter generates a Triangle Geometry from a grid Geometry (either an Image Geometry or a RectGrid Geometry) that represents a surface mesh of the present Features. The algorithm proceeds by creating a pair of Triangles for each face of the Cell where the neighboring Cells have a different Feature Id value. The meshing operation is extremely quick but can result in a surface mesh that is very “stair stepped”. The user is encouraged to use a smoothing operation to reduce this “blockiness”.

Link to the full online documentation for QuickSurfaceMeshFilter

Mapping of UI display to python named argument

UI Display

Python Named Argument

Face Data [AttributeMatrix]

face_data_group_name

Face Feature Data [AttributeMatrix]

face_feature_attribute_matrix_name

Face Labels

face_labels_array_name

Cell Feature Ids

feature_ids_path

Attempt to Fix Problem Voxels

fix_problem_voxels

Generate Triple Lines

generate_triple_lines

Attribute Arrays to Transfer

input_data_array_paths

Grid Geometry

input_grid_geometry_path

Node Type

node_types_array_name

Created Triangle Geometry

output_triangle_geometry_path

Vertex Data [AttributeMatrix]

vertex_data_group_name

Execute(data_structure, face_data_group_name, face_feature_attribute_matrix_name, face_labels_array_name, feature_ids_path, fix_problem_voxels, generate_triple_lines, input_data_array_paths, input_grid_geometry_path, node_types_array_name, output_triangle_geometry_path, vertex_data_group_name)
Parameters:
  • data_structure (DataStructure) – The DataStructure object that holds the data to be processed.

  • face_data_group_name (nx.DataObjectNameParameter) – The complete path to the DataGroup where the Face Data of the Triangle Geometry will be created

  • face_feature_attribute_matrix_name (nx.DataObjectNameParameter) – The complete path to the DataGroup where the Feature Data will be stored.

  • face_labels_array_name (nx.DataObjectNameParameter) – The name of the Array specifying which Features are on either side of each Face in the Triangle Geometry

  • feature_ids_path (nx.ArraySelectionParameter) – The complete path to the Array specifying which Feature each Cell belongs to

  • fix_problem_voxels (nx.BoolParameter) – See help page.

  • generate_triple_lines (nx.BoolParameter) – Experimental feature. May not work.

  • input_data_array_paths (nx.MultiArraySelectionParameter) – The paths to the Arrays specifying which Cell Attribute Arrays to transfer to the created Triangle Geometry

  • input_grid_geometry_path (nx.GeometrySelectionParameter) – The complete path to the Grid Geometry from which to create a Triangle Geometry

  • node_types_array_name (nx.DataObjectNameParameter) – The name of the Array specifying the type of node in the Triangle Geometry

  • output_triangle_geometry_path (nx.DataGroupCreationParameter) – The name of the created Triangle Geometry

  • vertex_data_group_name (nx.DataObjectNameParameter) – The complete path to the DataGroup where the Vertex Data of the Triangle Geometry will be created

Returns:

Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.

Return type:

nx.IFilter.ExecuteResult

Read North Star Imaging CT (.nsihdr/.nsidat)

class simplnx.ReadBinaryCTNorthstarFilter

This Filter will import a NorthStar Imaging data set consisting of a single .nsihdr and one or more .nsidat files. The data is read into an Image Geometry. The user can import a subvolume instead of reading the entire data set into memory.

Link to the full online documentation for ReadBinaryCTNorthstarFilter

Mapping of UI display to python named argument

UI Display

Python Named Argument

Cell Attribute Matrix Name

cell_attribute_matrix_name

Density Array

density_array_name

Ending XYZ Voxel for Subvolume

end_voxel_coord

Import Subvolume

import_subvolume

Input Header File

input_header_file

Image Geometry Path

input_image_geometry_path

Length Unit

length_unit_index

Starting XYZ Voxel for Subvolume

start_voxel_coord

Execute(data_structure, cell_attribute_matrix_name, density_array_name, end_voxel_coord, import_subvolume, input_header_file, input_image_geometry_path, length_unit_index, start_voxel_coord)
Parameters:
Returns:

Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.

Return type:

nx.IFilter.ExecuteResult

Read CSV File

class simplnx.ReadCSVFileFilter

This Filter reads text data from any text-based file and imports the data into DREAM3D-NX-style arrays. The user specifies which file to import, how the data is formatted, what to call each array, and what type each array should be.

Link to the full online documentation for ReadCSVFileFilter

Mapping of UI display to python named argument

UI Display

Python Named Argument

New Attribute Matrix

created_data_group_path

CSV Importer Data

read_csv_data_object

Existing Data Group or Attribute Matrix

selected_attribute_matrix_path

Use Existing Data Group or Attribute Matrix

use_existing_group

Execute(data_structure, created_data_group_path, read_csv_data_object, selected_attribute_matrix_path, use_existing_group)
Parameters:
  • data_structure (DataStructure) – The DataStructure object that holds the data to be processed.

  • created_data_group_path (nx.DataGroupCreationParameter) – Store the imported CSV data arrays in a newly created attribute matrix.

  • read_csv_data_object (nx.ReadCSVFileParameter) – Holds all relevant csv file data collected from the custom interface

  • selected_attribute_matrix_path (nx.DataGroupSelectionParameter) – Store the imported CSV data arrays in an existing data group or attribute matrix.

  • use_existing_group (nx.BoolParameter) – Store the imported CSV data arrays in an existing data group or attribute matrix.

Returns:

Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.

Return type:

nx.IFilter.ExecuteResult

Read DREAM3D-NX File

class simplnx.ReadDREAM3DFilter

This Filter reads the data structure from an hdf5 file with the .dream3d extension. This filter is capable of reading from legacy .dream3d files also.

Link to the full online documentation for ReadDREAM3DFilter

Mapping of UI display to python named argument

UI Display

Python Named Argument

Import File Path

import_data_object

Execute(data_structure, import_data_object)
Parameters:
  • data_structure (DataStructure) – The DataStructure object that holds the data to be processed.

  • import_data_object (nx.Dream3dImportParameter) – The HDF5 file path the DataStructure should be imported from.

Returns:

Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.

Return type:

nx.IFilter.ExecuteResult

Read Deform Key File (v12)

class simplnx.ReadDeformKeyFileV12Filter

This Filter reads DEFORM v12 key files and saves the data in a newly created Data Container.

Link to the full online documentation for ReadDeformKeyFileV12Filter

Mapping of UI display to python named argument

UI Display

Python Named Argument

Cell Data Name

cell_attribute_matrix_name

Input File

input_file_path

Quad Geometry

output_quad_geometry_path

Vertex Data Name

vertex_attribute_matrix_name

Execute(data_structure, cell_attribute_matrix_name, input_file_path, output_quad_geometry_path, vertex_attribute_matrix_name)
Parameters:
Returns:

Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.

Return type:

nx.IFilter.ExecuteResult

Read HDF5 Dataset

class simplnx.ReadHDF5DatasetFilter

This Filter allows the user to import datasets from an HDF5 file and store them as attribute arrays in DREAM3D-NX. This filter supports importing datasets with any number of dimensions, as long as the created attribute array’s total number of components and the tuple count of the destination attribute matrix multiply together to match the HDF5 dataset’s total number of elements.

Link to the full online documentation for ReadHDF5DatasetFilter

Mapping of UI display to python named argument

UI Display

Python Named Argument

Select HDF5 File

import_hdf5_object

Execute(data_structure, import_hdf5_object)
Parameters:
Returns:

Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.

Return type:

nx.IFilter.ExecuteResult

Read Raw Binary

class simplnx.ReadRawBinaryFilter

This Filter is designed to read data stored in files on the users system in binary form. The data file should not have any type of header before the data in the file. The user should know exactly how the data is stored in the file and properly define this in the user interface. Not correctly identifying the type of data can cause serious issues since this Filter is simply reading the data into a pre-allocated array interpreted as the user defines.

Link to the full online documentation for ReadRawBinaryFilter

Mapping of UI display to python named argument

UI Display

Python Named Argument

Output Attribute Array

created_attribute_array_path

Endian

endian_index

Input File

input_file

Number of Components

number_of_components

Input Numeric Type

scalar_type_index

Skip Header Bytes

skip_header_bytes

Data Array Dimensions

tuple_dimensions

Execute(data_structure, created_attribute_array_path, endian_index, input_file, number_of_components, scalar_type_index, skip_header_bytes, tuple_dimensions)
Parameters:
Returns:

Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.

Return type:

nx.IFilter.ExecuteResult

Read STL File

class simplnx.ReadStlFileFilter

This Filter will read a binary STL File and create a Triangle Geometry object in memory. The STL reader is very strict to the STL specification. An explanation of the STL file format can be found on Wikipedia. The structure of the file is as follows:

Link to the full online documentation for ReadStlFileFilter

Mapping of UI display to python named argument

UI Display

Python Named Argument

Generate Triangle Face Labels

create_face_labels

Face Data [AttributeMatrix]

face_attribute_matrix_name

Created Face Labels Array

face_labels_name

Face Normals

face_normals_name

Created Triangle Geometry

output_triangle_geometry_path

Scale Factor

scale_factor

Scale Output Geometry

scale_output

STL File

stl_file_path

Vertex Data [AttributeMatrix]

vertex_attribute_matrix_name

Execute(data_structure, create_face_labels, face_attribute_matrix_name, face_labels_name, face_normals_name, output_triangle_geometry_path, scale_factor, scale_output, stl_file_path, vertex_attribute_matrix_name)
Parameters:
Returns:

Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.

Return type:

nx.IFilter.ExecuteResult

Read String Data Array

class simplnx.ReadStringDataArrayFilter

This Filter allows the user to import a plain text file containing the contents of a single Attribute Array. The delimeters can be one of the following:

Link to the full online documentation for ReadStringDataArrayFilter

Mapping of UI display to python named argument

UI Display

Python Named Argument

Data Format

data_format

Delimiter

delimiter_index

Input File

input_file

Data Array Dimensions (Slowest to Fastest Dimensions)

number_tuples

Created Array Path

output_data_array_path

Set Tuple Dimensions [not required if creating inside an Attribute Matrix]

set_tuple_dimensions

Skip Header Lines

skip_line_count

Execute(data_structure, data_format, delimiter_index, input_file, number_tuples, output_data_array_path, set_tuple_dimensions, skip_line_count)
Parameters:
  • data_structure (DataStructure) – The DataStructure object that holds the data to be processed.

  • data_format (nx.DataStoreFormatParameter) – This value will specify which data format is used by the array’s data store. An empty string results in in-memory data store.

  • delimiter_index (nx.ChoicesParameter) – Delimiter for values on a line

  • input_file (nx.FileSystemPathParameter) – File path that points to the imported file

  • number_tuples (nx.DynamicTableParameter) – Slowest to Fastest Dimensions. Note this might be opposite displayed by an image geometry.

  • output_data_array_path (nx.ArrayCreationParameter) – DataPath or Name for the underlying Data Array

  • set_tuple_dimensions (nx.BoolParameter) – This allows the user to set the tuple dimensions directly rather than just inheriting them. This option is NOT required if you are creating the Data Array in an Attribute Matrix

  • skip_line_count (nx.UInt64Parameter) – Number of lines at the start of the file to skip

Returns:

Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.

Return type:

nx.IFilter.ExecuteResult

Read Text Data Array

class simplnx.ReadTextDataArrayFilter

This Filter allows the user to import a plain text file containing the contents of a single Attribute Array. The delimeters can be one of the following:

Link to the full online documentation for ReadTextDataArrayFilter

Mapping of UI display to python named argument

UI Display

Python Named Argument

Data Format

data_format

Delimiter

delimiter_index

Input File

input_file

Number of Components

number_comp

Data Array Dimensions (Slowest to Fastest Dimensions)

number_tuples

Created Array Path

output_data_array_path

Input Numeric Type

scalar_type_index

Set Tuple Dimensions [not required if creating inside an Attribute Matrix]

set_tuple_dimensions

Skip Header Lines

skip_line_count

Execute(data_structure, data_format, delimiter_index, input_file, number_comp, number_tuples, output_data_array_path, scalar_type_index, set_tuple_dimensions, skip_line_count)
Parameters:
  • data_structure (DataStructure) – The DataStructure object that holds the data to be processed.

  • data_format (nx.DataStoreFormatParameter) – This value will specify which data format is used by the array’s data store. An empty string results in in-memory data store.

  • delimiter_index (nx.ChoicesParameter) – Delimiter for values on a line

  • input_file (nx.FileSystemPathParameter) – File path that points to the imported file

  • number_comp (nx.UInt64Parameter) – Number of columns

  • number_tuples (nx.DynamicTableParameter) – Slowest to Fastest Dimensions. Note this might be opposite displayed by an image geometry.

  • output_data_array_path (nx.ArrayCreationParameter) – DataPath or Name for the underlying Data Array

  • scalar_type_index (nx.NumericTypeParameter) – Data Type to interpret and store data into.

  • set_tuple_dimensions (nx.BoolParameter) – This allows the user to set the tuple dimensions directly rather than just inheriting them. This option is NOT required if you are creating the Data Array in an Attribute Matrix

  • skip_line_count (nx.UInt64Parameter) – Number of lines at the start of the file to skip

Returns:

Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.

Return type:

nx.IFilter.ExecuteResult

Read Volume Graphics File (.vgi/.vol)

class simplnx.ReadVolumeGraphicsFileFilter

This Filter will import Volume Graphics data files in the form of .vgi/.vol pairs. Both files must exist and be in the same directory for the filter to work. The .vgi file is read to find out the dimensions, spacing and units of the data. The name of the .vol file is also contained in the .vgi file.

Link to the full online documentation for ReadVolumeGraphicsFileFilter

Mapping of UI display to python named argument

UI Display

Python Named Argument

Cell Attribute Matrix

cell_attribute_matrix_name

Density

density_array_name

Image Geometry

output_image_geometry_path

Volume Graphics .vgi File

vg_header_file

Execute(data_structure, cell_attribute_matrix_name, density_array_name, output_image_geometry_path, vg_header_file)
Parameters:
Returns:

Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.

Return type:

nx.IFilter.ExecuteResult

Read Vtk Structured Points File

class simplnx.ReadVtkStructuredPointsFilter

This Filter reads a _STRUCTURED_POINTS_ type of 3D array from a legacy .vtk file. A _STRUCTURED_POINTS_ file is a more general type of Image Geometry where data can be stored at the vertices of each voxel. The currently supported VTK dataset attribute types are SCALARS and VECTORS. Other dataset attributes will not be read correctly and may cause issues when running the Filter. The VTK data must be _POINT_DATA_ and/or _CELL_DATA_ and can be either binary or ASCII. The Filter will create a new Data Container with an Image geometry for each of the types of data (i.e., _POINT_DATA_ and/or _CELL_DATA_) selected to be read, along with a Cell Attribute Matrix to hold the imported data.

Link to the full online documentation for ReadVtkStructuredPointsFilter

Mapping of UI display to python named argument

UI Display

Python Named Argument

Attribute Matrix Name [Cell Data]

cell_attribute_matrix_name

Input VTK File

input_file

Data Container [Cell Data]

output_image_geometry_path

Data Container [Point Data]

output_vertex_geometry_path

Read Cell Data

read_cell_data

Read Point Data

read_point_data

Attribute Matrix Name [Point Data]

vertex_attribute_matrix_name

Execute(data_structure, cell_attribute_matrix_name, input_file, output_image_geometry_path, output_vertex_geometry_path, read_cell_data, read_point_data, vertex_attribute_matrix_name)
Parameters:
Returns:

Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.

Return type:

nx.IFilter.ExecuteResult

Sample Triangle Geometry on Regular Grid

class simplnx.RegularGridSampleSurfaceMeshFilter

This Filter “samples” a triangulated surface mesh on a rectilinear grid. The user can specify the number of Cells along the X, Y, and Z directions in addition to the resolution in each direction and origin to define a rectilinear grid. The sampling is then performed by the following steps:

Link to the full online documentation for RegularGridSampleSurfaceMeshFilter

Mapping of UI display to python named argument

UI Display

Python Named Argument

Cell Attribute Matrix

cell_attribute_matrix_name

Dimensions (Voxels)

dimensions

Feature Ids

feature_ids_array_name

Image Geometry

input_image_geometry_path

Triangle Geometry

input_triangle_geometry_path

Length Units (For Description Only)

length_unit_index

Origin

origin

Spacing

spacing

Face Labels

surface_mesh_face_labels_array_path

Execute(data_structure, cell_attribute_matrix_name, dimensions, feature_ids_array_name, input_image_geometry_path, input_triangle_geometry_path, length_unit_index, origin, spacing, surface_mesh_face_labels_array_path)
Parameters:
Returns:

Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.

Return type:

nx.IFilter.ExecuteResult

Remove Flagged Edges

class simplnx.RemoveFlaggedEdgesFilter

This Filter removes Edges from the supplied Edges Geometry that are flagged by a (boolean|uint8) mask array as true|1. A new reduced Edge Geometry is created that contains all the remaining Edges. It is unknown until run time how many Edges will be removed from the Geometry. Therefore, this Filter requires that a new EdgeGeom be created to contain the reduced Edge Geometry. This new Geometry will NOT contain copies of any Feature Attribute Matrix or Ensemble Attribute Matrix from the original Geometry. The mask is expected to be over the edges themselves so it should be based on something from the Edge Data Attribute Matrix.

Link to the full online documentation for RemoveFlaggedEdgesFilter

Mapping of UI display to python named argument

UI Display

Python Named Argument

Edge Data Handling

edge_data_handling_index

Edge Attribute Arrays to Copy

edge_data_selected_array_paths

Edge Data

edge_data_selected_attribute_matrix_path

Edge Geometry

input_edge_geometry_path

Mask

mask_array_path

Created Geometry

output_edge_geometry_path

Vertex Data Handling

vertex_data_handling_index

Vertex Attribute Arrays to Copy

vertex_data_selected_array_paths

Vertex Data

vertex_data_selected_attribute_matrix_path

Execute(data_structure, edge_data_handling_index, edge_data_selected_array_paths, edge_data_selected_attribute_matrix_path, input_edge_geometry_path, mask_array_path, output_edge_geometry_path, vertex_data_handling_index, vertex_data_selected_array_paths, vertex_data_selected_attribute_matrix_path)
Parameters:
Returns:

Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.

Return type:

nx.IFilter.ExecuteResult

Remove/Extract Flagged Features

class simplnx.RemoveFlaggedFeaturesFilter

This Filter will remove Features that have been flagged by another Filter from the structure. The Filter requires that the user point to a boolean array at the Feature level that tells the Filter whether the Feature should remain in the structure. If the boolean array is false for a Feature, then all Cells that belong to that Feature are temporarily unassigned. Optionally, after all undesired Features are removed, the remaining Features are isotropically coarsened to fill in the gaps left by the removed Features.

Link to the full online documentation for RemoveFlaggedFeaturesFilter

Mapping of UI display to python named argument

UI Display

Python Named Argument

Cell Feature Ids

feature_ids_path

Fill-in Removed Features

fill_removed_features

Flagged Features

flagged_features_array_path

Attribute Arrays to Ignore

ignored_data_array_paths

Selected Image Geometry

input_image_geometry_path

Selected Operation

operation_type_index

Created Image Geometry Prefix

output_image_geometry_prefix

Execute(data_structure, feature_ids_path, fill_removed_features, flagged_features_array_path, ignored_data_array_paths, input_image_geometry_path, operation_type_index, output_image_geometry_prefix)
Parameters:
  • data_structure (DataStructure) – The DataStructure object that holds the data to be processed.

  • feature_ids_path (nx.ArraySelectionParameter) – Specifies to which Feature each cell belongs

  • fill_removed_features (nx.BoolParameter) – Whether or not to fill in the gaps left by the removed Features

  • flagged_features_array_path (nx.ArraySelectionParameter) – Specifies whether the Feature will remain in the structure or not

  • ignored_data_array_paths (nx.MultiArraySelectionParameter) – The list of arrays to ignore when removing flagged features

  • input_image_geometry_path (nx.GeometrySelectionParameter) – The target geometry

  • operation_type_index (nx.ChoicesParameter) – Whether to [0] remove features, [1] extract features into new geometry or [2] extract and then remove

  • output_image_geometry_prefix (nx.StringParameter) – The prefix name for each of new cropped (extracted) geometry

NOTE: a ‘-’ will automatically be added between the prefix and number
return:

Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.

rtype:

nx.IFilter.ExecuteResult

Remove Flagged Triangles

class simplnx.RemoveFlaggedTrianglesFilter

This Filter removes Triangles from the supplied Triangle Geometry that are flagged by a boolean mask array as true. A new reduced Geometry is created that contains all the remaining Triangles. It is unknown until run time how many Triangles will be removed from the Geometry. Therefore, this Filter requires that a new TriangleGeom be created to contain the reduced Triangle Geometry. This new Geometry will NOT contain copies of any Feature Attribute Matrix or Ensemble Attribute Matrix from the original Geometry. The mask is expected to be over the triangles themselves so it should be based on something from the *Face Data* Attribute Matrix.

Link to the full online documentation for RemoveFlaggedTrianglesFilter

Mapping of UI display to python named argument

UI Display

Python Named Argument

Triangle Geometry

input_triangle_geometry_path

Mask

mask_array_path

Created Geometry

output_triangle_geometry_path

Triangle Data Handling

triangle_data_handling_index

Triangle Attribute Arrays to Copy

triangle_data_selected_array_paths

Triangle Data

triangle_data_selected_attribute_matrix_path

Vertex Data Handling

vertex_data_handling_index

Vertex Attribute Arrays to Copy

vertex_data_selected_array_paths

Vertex Data

vertex_data_selected_attribute_matrix_path

Execute(data_structure, input_triangle_geometry_path, mask_array_path, output_triangle_geometry_path, triangle_data_handling_index, triangle_data_selected_array_paths, triangle_data_selected_attribute_matrix_path, vertex_data_handling_index, vertex_data_selected_array_paths, vertex_data_selected_attribute_matrix_path)
Parameters:
Returns:

Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.

Return type:

nx.IFilter.ExecuteResult

Remove Flagged Vertices

class simplnx.RemoveFlaggedVerticesFilter

This Filter removes Vertices from the supplied Vertex Geometry that are flagged as TRUE by a boolean mask array. A new reduced Vertex Geometry is created that contains all the remaining Vertices. It is unknown until run time how many Vertices will be removed from the Geometry. Therefore, this Filter requires that a new Data Container be created to contain the reduced Vertex Geometry. This new Vertex Geometry will contain copies of any Feature or Ensemble Attribute Matrices from the original Data Container. Additionally, all **Vertex* data will be copied*, with tuples removed for any Vertices removed by the Filter. The user must supply a name for the reduced Vertex Geometry, but all other copied objects (Attribute Matrices and Attribute Arrays) will retain the same names as the original source.

Link to the full online documentation for RemoveFlaggedVerticesFilter

Mapping of UI display to python named argument

UI Display

Python Named Argument

Vertex Geometry

input_vertex_geometry_path

Flagged Vertex Array (Mask)

mask_path

Reduced Vertex Geometry

output_vertex_geometry_path

Execute(data_structure, input_vertex_geometry_path, mask_path, output_vertex_geometry_path)
Parameters:
Returns:

Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.

Return type:

nx.IFilter.ExecuteResult

Rename DataObject

class simplnx.RenameDataObjectFilter

This Filter renames a user chosen Data Object of any type.

Link to the full online documentation for RenameDataObjectFilter

Mapping of UI display to python named argument

UI Display

Python Named Argument

Allow Overwrite

allow_overwrite

New Name

new_name

DataObject to Rename

source_data_object_path

Execute(data_structure, allow_overwrite, new_name, source_data_object_path)
Parameters:
  • data_structure (DataStructure) – The DataStructure object that holds the data to be processed.

  • allow_overwrite (nx.BoolParameter) – If true existing object with New Name and all of its nested objects will be removed to free up the name for the target DataObject

  • new_name (nx.StringParameter) – Target DataObject name

  • source_data_object_path (nx.DataPathSelectionParameter) – DataPath pointing to the target DataObject

Returns:

Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.

Return type:

nx.IFilter.ExecuteResult

Replace Element Attributes with Neighbor (Threshold)

class simplnx.ReplaceElementAttributesWithNeighborValuesFilter

This Filter first identifies all Cells that have a value that meets the selected threshold value set by theuser. Then, for each of those Cells, their neighboring Cells are checked to determine the neighbor Cell withmaximum or minimum value. The attributes of the neighbor with the maximum/minimum value are then reassigned to thereference Cell.

Link to the full online documentation for ReplaceElementAttributesWithNeighborValuesFilter

Mapping of UI display to python named argument

UI Display

Python Named Argument

Input Comparison Array

comparison_data_path

Comparison Operator

comparison_index

Selected Image Geometry

input_image_geometry_path

Loop Until Gone

loop

Threshold Value

min_confidence

Execute(data_structure, comparison_data_path, comparison_index, input_image_geometry_path, loop, min_confidence)
Parameters:
Returns:

Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.

Return type:

nx.IFilter.ExecuteResult

Require Minimum Number of Neighbors

class simplnx.RequireMinNumNeighborsFilter

This Filter sets the minimum number of contiguous neighboring Features a Feature must have to remain in the structure. Entering zero results in nothing changing. Entering a number larger than the maximum number of neighbors of any Feature generates an error (since all Features would be removed). The user needs to proceed conservatively here when choosing the value for the minimum to avoid accidentally exceeding the maximum. After Features are removed for not having enough neighbors, the remaining Features are coarsened iteratively, one Cell per iteration, until the gaps left by the removed Features are filled. Effectively, this is an isotropic Feature growth in the regions around removed Features.

Link to the full online documentation for RequireMinNumNeighborsFilter

Mapping of UI display to python named argument

UI Display

Python Named Argument

Apply to Single Phase Only

apply_to_single_phase

Cell Feature Ids

feature_ids_path

Feature Phases

feature_phases_path

Cell Arrays to Ignore

ignored_voxel_arrays

Image Geometry

input_image_geometry_path

Minimum Number Neighbors

min_num_neighbors

Number of Neighbors

num_neighbors_path

Phase Index

phase_number

Execute(data_structure, apply_to_single_phase, feature_ids_path, feature_phases_path, ignored_voxel_arrays, input_image_geometry_path, min_num_neighbors, num_neighbors_path, phase_number)
Parameters:
Returns:

Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.

Return type:

nx.IFilter.ExecuteResult

Remove Minimum Size Features

class simplnx.RequireMinimumSizeFeaturesFilter

This Filter removes Features that have a total number of Cells below the minimum threshold defined by the user. Entering a number larger than the largest Feature generates an error (since all Features would be removed). Hence, a choice of threshold should be carefully be chosen if it is not known how many Cells are in the largest Features. After removing all the small Features, the remaining Features are isotropically coarsened to fill the gaps left by the small Features.

Link to the full online documentation for RequireMinimumSizeFeaturesFilter

Mapping of UI display to python named argument

UI Display

Python Named Argument

Apply to Single Phase

apply_single_phase

Cell Feature Ids

feature_ids_path

Feature Phases

feature_phases_path

Input Image Geometry

input_image_geometry_path

Minimum Allowed Features Size

min_allowed_features_size

Feature Num. Cells Array

num_cells_path

Phase Index

phase_number

Execute(data_structure, apply_single_phase, feature_ids_path, feature_phases_path, input_image_geometry_path, min_allowed_features_size, num_cells_path, phase_number)
Parameters:
Returns:

Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.

Return type:

nx.IFilter.ExecuteResult

Resample Data (Image Geometry)

class simplnx.ResampleImageGeomFilter

This Filter changes the Cell spacing/resolution based on inputs from the user. There are several resampling modes:

Link to the full online documentation for ResampleImageGeomFilter

Mapping of UI display to python named argument

UI Display

Python Named Argument

Feature Attribute Matrix

cell_feature_attribute_matrix_path

Exact Dimensions (pixels)

exact_dimensions

Feature IDs

feature_ids_path

Selected Image Geometry

input_image_geometry_path

Created Image Geometry

new_data_container_path

Perform In Place

remove_original_geometry

Renumber Features

renumber_features

Resampling Mode

resampling_mode_index

Scale Factor (percentages)

scaling

New Spacing

spacing

Execute(data_structure, cell_feature_attribute_matrix_path, exact_dimensions, feature_ids_path, input_image_geometry_path, new_data_container_path, remove_original_geometry, renumber_features, resampling_mode_index, scaling, spacing)
Parameters:
  • data_structure (DataStructure) – The DataStructure object that holds the data to be processed.

  • cell_feature_attribute_matrix_path (nx.AttributeMatrixSelectionParameter) – DataPath to the feature Attribute Matrix

  • exact_dimensions (nx.VectorUInt64Parameter) – The exact dimension size values (dx, dy, dz) to resample the geometry, in pixels.

  • feature_ids_path (nx.ArraySelectionParameter) – DataPath to Cell Feature IDs array

  • input_image_geometry_path (nx.GeometrySelectionParameter) – The target geometry to resample

  • new_data_container_path (nx.DataGroupCreationParameter) – The location of the resampled geometry

  • remove_original_geometry (nx.BoolParameter) – Removes the original Image Geometry after filter is completed

  • renumber_features (nx.BoolParameter) – Specifies if the feature IDs should be renumbered

  • resampling_mode_index (nx.ChoicesParameter) – Mode can be [0] Spacing, [1] Scaling as Percent, [2] Exact Dimensions as voxels

  • scaling (nx.VectorFloat32Parameter) – The scale factor values (dx, dy, dz) to resample the geometry, in percentages. Larger percentages will cause more voxels, smaller percentages will cause less voxels. A percentage of 100 in any dimension will not resample the geometry in that dimension. Percentages must be larger than 0.

  • spacing (nx.VectorFloat32Parameter) – The new spacing values (dx, dy, dz). Larger spacing will cause less voxels, smaller spacing will cause more voxels.

Returns:

Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.

Return type:

nx.IFilter.ExecuteResult

Resample Rectilinear Grid to Image Geom

class simplnx.ResampleRectGridToImageGeomFilter

This Filter will resample an existing RectilinearGrid onto a regular grid (Image Geometry) and copy cell data into the newly created Image Geometry Data Container during the process.

Link to the full online documentation for ResampleRectGridToImageGeomFilter

Mapping of UI display to python named argument

UI Display

Python Named Argument

Dimensions (Voxels)

dimensions

Cell Attribute Matrix

image_geom_cell_attribute_matrix_name

Attribute Arrays to Copy

input_data_array_paths

Created Image Geometry

input_image_geometry_path

Input Rectilinear Grid

rectilinear_grid_path

Execute(data_structure, dimensions, image_geom_cell_attribute_matrix_name, input_data_array_paths, input_image_geometry_path, rectilinear_grid_path)
Parameters:
Returns:

Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.

Return type:

nx.IFilter.ExecuteResult

Reshape Data Array

class simplnx.ReshapeDataArrayFilter

This Filter is used to modify the tuple shape of Data Arrays, Neighbor Lists, and String Arrays within a data structure. It validates the new tuple dimensions to ensure they are positive and differ from the current shape, preventing unnecessary or invalid reshapes.

Link to the full online documentation for ReshapeDataArrayFilter

Mapping of UI display to python named argument

UI Display

Python Named Argument

Input Array

input_array_path

New Tuple Dimensions (Slowest to Fastest Dimensions)

tuple_dims

Execute(data_structure, input_array_path, tuple_dims)
Parameters:
  • data_structure (DataStructure) – The DataStructure object that holds the data to be processed.

  • input_array_path (nx.ArraySelectionParameter) – The input array that will be reshaped.

  • tuple_dims (nx.DynamicTableParameter) – Slowest to Fastest Dimensions. Note this might be opposite displayed by an image geometry.

Returns:

Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.

Return type:

nx.IFilter.ExecuteResult

Reverse Triangle Winding

class simplnx.ReverseTriangleWindingFilter

This Filter reverses the winding for each Triangle in a Triangle Geometry. This will reverse the direction of calculated Triangle normals. Some analysis routines require the normals to be pointing “away” from the center of a Feature. This Filter allows for manipulation of this construct.

Link to the full online documentation for ReverseTriangleWindingFilter

Mapping of UI display to python named argument

UI Display

Python Named Argument

Triangle Geometry

input_triangle_geometry_path

Execute(data_structure, input_triangle_geometry_path)
Parameters:
Returns:

Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.

Return type:

nx.IFilter.ExecuteResult

Robust Automatic Threshold

class simplnx.RobustAutomaticThresholdFilter

This Filter automatically computes a threshold value for a scalar Attribute Array based on the array’s gradient magnitude, producing a boolean array that is false where the input array is less than the threshold value and true otherwise. The threshold value is computed using the following equation:

Link to the full online documentation for RobustAutomaticThresholdFilter

Mapping of UI display to python named argument

UI Display

Python Named Argument

Mask

created_mask_name

Gradient Magnitude Data

gradient_array_path

Input Array

input_array_path

Execute(data_structure, created_mask_name, gradient_array_path, input_array_path)
Parameters:
Returns:

Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.

Return type:

nx.IFilter.ExecuteResult

Rotate Sample Reference Frame

class simplnx.RotateSampleRefFrameFilter

NOTE: As of July 2023, this filter is only verified to work with a rotation angle of 180 degrees, a rotation axis of (010), and a (0, 0, 0) origin.

Link to the full online documentation for RotateSampleRefFrameFilter

Mapping of UI display to python named argument

UI Display

Python Named Argument

Selected Image Geometry

input_image_geometry_path

Created Image Geometry

output_image_geometry_path

Perform In-Place Rotation

remove_original_geometry

Perform Slice By Slice Transform

rotate_slice_by_slice

Rotation Axis-Angle [<ijk>w]

rotation_axis_angle

Transformation Matrix

rotation_matrix

Rotation Representation

rotation_representation_index

Execute(data_structure, input_image_geometry_path, output_image_geometry_path, remove_original_geometry, rotate_slice_by_slice, rotation_axis_angle, rotation_matrix, rotation_representation_index)
Parameters:
Returns:

Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.

Return type:

nx.IFilter.ExecuteResult

Segment Features (Scalar)

class simplnx.ScalarSegmentFeaturesFilter

This Filter segments the Features by grouping neighboring Cells that satisfy the scalar tolerance, i.e., have a scalar difference less than the value set by the user. The process by which the Features are identified is given below and is a standard burn algorithm.

Link to the full online documentation for ScalarSegmentFeaturesFilter

Mapping of UI display to python named argument

UI Display

Python Named Argument

Active

active_array_name

Feature Attribute Matrix

cell_feature_group_name

Cell Feature IDs

feature_ids_name

Scalar Array to Segment

input_array_path

Input Image Geometry

input_image_geometry_path

Cell Mask Array

mask_path

Randomize Feature IDs

randomize_features

Scalar Tolerance

scalar_tolerance

Use Mask Array

use_mask

Execute(data_structure, active_array_name, cell_feature_group_name, feature_ids_name, input_array_path, input_image_geometry_path, mask_path, randomize_features, scalar_tolerance, use_mask)
Parameters:
Returns:

Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.

Return type:

nx.IFilter.ExecuteResult

Set Origin & Spacing (Image Geom)

class simplnx.SetImageGeomOriginScalingFilter

This Filter changes the origin and/or the spacing of an Image Geometry. For example, if the current origin is at (0, 0, 0) and the user would like the origin to be (10, 4, 8), then the user should enter the following input values:

Link to the full online documentation for SetImageGeomOriginScalingFilter

Mapping of UI display to python named argument

UI Display

Python Named Argument

Put Input Origin at the Center of Geometry

center_origin

Set Origin

change_origin

Set Spacing

change_spacing

Image Geometry

input_image_geometry_path

Origin (Physical Units)

origin

Spacing (Physical Units)

spacing

Execute(data_structure, center_origin, change_origin, change_spacing, input_image_geometry_path, origin, spacing)
Parameters:
Returns:

Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.

Return type:

nx.IFilter.ExecuteResult

Compute Triangle Face Ids

class simplnx.SharedFeatureFaceFilter

This Filter assigns a unique Id to each Triangle in a Triangle Geometry that represents the _unique boundary_on which that Triangle resides. For example, if there were only two Features that shared one boundary,then the Triangles on that boundary would be labeled with a single unique Id. This procedure creates _unique groups_of Triangles, which themselves are a set of Features. Thus, this Filter also creates a Feature AttributeMatrix for this new set of Features, and creates Attribute Arrays for their Ids and number of Triangles. Thisprocess can be considered a segmentation where each unique id is the shared boundary between two features.

Link to the full online documentation for SharedFeatureFaceFilter

Mapping of UI display to python named argument

UI Display

Python Named Argument

Face Labels

face_labels_array_path

Feature Face Ids

feature_face_ids_array_name

Feature Face Labels

feature_face_labels_array_name

Feature Number of Triangles

feature_num_triangles_array_name

Face Feature Attribute Matrix

grain_boundary_attribute_matrix_name

Triangle Geometry

input_triangle_geometry_path

Randomize Face IDs

randomize_features

Execute(data_structure, face_labels_array_path, feature_face_ids_array_name, feature_face_labels_array_name, feature_num_triangles_array_name, grain_boundary_attribute_matrix_name, input_triangle_geometry_path, randomize_features)
Parameters:
  • data_structure (DataStructure) – The DataStructure object that holds the data to be processed.

  • face_labels_array_path (nx.ArraySelectionParameter) – The DataPath to the FaceLabels values.

  • feature_face_ids_array_name (nx.DataObjectNameParameter) – The name of the calculated Feature Face Ids DataArray

  • feature_face_labels_array_name (nx.DataObjectNameParameter) – The name of the array that holds the calculated Feature Face Labels

  • feature_num_triangles_array_name (nx.DataObjectNameParameter) – The name of the array that holds the calculated number of triangles for each feature face

  • grain_boundary_attribute_matrix_name (nx.DataObjectNameParameter) – The name of the AttributeMatrix that holds the Feature Face data

  • input_triangle_geometry_path (nx.GeometrySelectionParameter) – The complete path to the Geometry for which to calculate the normals

  • randomize_features (nx.BoolParameter) – Specifies if feature IDs should be randomized. Can be helpful when visualizing the faces.

Returns:

Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.

Return type:

nx.IFilter.ExecuteResult

Silhouette

class simplnx.SilhouetteFilter

This Filter computes the silhouette for a clustered Attribute Array. The user must select both the original array that has been clustered and the array of cluster Ids. The silhouette represents a measure for the quality of a clustering. Specifically, the silhouette provides a measure for how strongly a given point belongs to its own cluster compared to all other clusters. The silhouette is computed as follows:

Link to the full online documentation for SilhouetteFilter

Mapping of UI display to python named argument

UI Display

Python Named Argument

Distance Metric

distance_metric_index

Cluster Ids

feature_ids_array_path

Mask Array

mask_array_path

Attribute Array to Silhouette

selected_array_path

Silhouette

silhouette_array_path

Use Mask Array

use_mask

Execute(data_structure, distance_metric_index, feature_ids_array_path, mask_array_path, selected_array_path, silhouette_array_path, use_mask)
Parameters:
  • data_structure (DataStructure) – The DataStructure object that holds the data to be processed.

  • distance_metric_index (nx.ChoicesParameter) – Distance Metric type to be used for calculations

  • feature_ids_array_path (nx.ArraySelectionParameter) – The DataPath to the DataArray that specifies which cluster each point belongs

  • mask_array_path (nx.ArraySelectionParameter) – DataPath to the boolean or uint8 mask array. Values that are true will mark that cell/point as usable.

  • selected_array_path (nx.ArraySelectionParameter) – The DataPath to the input DataArray

  • silhouette_array_path (nx.ArrayCreationParameter) – The DataPath to the calculated output Silhouette array values

  • use_mask (nx.BoolParameter) – Specifies whether or not to use a mask array

Returns:

Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.

Return type:

nx.IFilter.ExecuteResult

Slice Triangle Geometry

class simplnx.SliceTriangleGeometryFilter

This Filter slices an input Triangle Geometry, producing an Edge Geometry. The user can control the range over which to slice (either the entire range of the geoemtry or a specified subregion), and the spacing bewteen slices. Currently this filter only supports slicing along the direction of the z axis. The total area and perimieter of each slice is also computed and stored as an attribute on each created slice.

Link to the full online documentation for SliceTriangleGeometryFilter

Mapping of UI display to python named argument

UI Display

Python Named Argument

Edge Attribute Matrix

edge_attribute_matrix_name

Have Region Ids

have_region_ids

Triangle Geometry

input_triangle_geometry_path

Created Edge Geometry

output_edge_geometry_path

Region Ids

region_ids_array_path

Slice Attribute Matrix

slice_attribute_matrix_name

Slice Ids

slice_ids_array_name

Slice Range

slice_range_index

Slice Spacing

slice_spacing_value

Slicing End

z_end_value

Slicing Start

z_start_value

Execute(data_structure, edge_attribute_matrix_name, have_region_ids, input_triangle_geometry_path, output_edge_geometry_path, region_ids_array_path, slice_attribute_matrix_name, slice_ids_array_name, slice_range_index, slice_spacing_value, z_end_value, z_start_value)
Parameters:
Returns:

Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.

Return type:

nx.IFilter.ExecuteResult

Split Multi component Attribute Array

class simplnx.SplitAttributeArrayFilter

This Filter splits an n-component Attribute Array into n scalar arrays, where each array is one of the original components. Any arbitrary component array may be split in this manner, and the output arrays will have the same primitive type as the input array. The original array is not modified (unless the option to remove the original array is selected); instead, n new arrays are created. For example, consider an unsigned 8-bit array with three components:

Link to the full online documentation for SplitAttributeArrayFilter

Mapping of UI display to python named argument

UI Display

Python Named Argument

Components to Extract

components_to_extract

Remove Original Array

delete_original_array

Multi-Component Attribute Array

multicomponent_array_path

Postfix

postfix

Select Specific Components to Extract

select_components_to_extract

Execute(data_structure, components_to_extract, delete_original_array, multicomponent_array_path, postfix, select_components_to_extract)
Parameters:
  • data_structure (DataStructure) – The DataStructure object that holds the data to be processed.

  • components_to_extract (nx.DynamicTableParameter) – The components from the input array to be extracted into separate arrays

  • delete_original_array (nx.BoolParameter) – Whether or not to remove the original multicomponent array after splitting

  • multicomponent_array_path (nx.ArraySelectionParameter) – The multicomponent Attribute Array to split

  • postfix (nx.StringParameter) – Postfix to add to the end of the split Attribute Arrays

  • select_components_to_extract (nx.BoolParameter) – Whether or not to specify only certain components to be extracted

Returns:

Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.

Return type:

nx.IFilter.ExecuteResult

Create Surface Mesh (Surface Nets)

class simplnx.SurfaceNetsFilter

This filter uses the algorithm from {1} to produce a triangle surface mesh. The code is directly based on the sample code from the paper but has been modified towork with the simplnx library classes. This filter uses a different algorithm that aims to produce a mush that keeps sharp edgeswhile still producing a mesh superior to marching cubes or QuickMesh.

Link to the full online documentation for SurfaceNetsFilter

Mapping of UI display to python named argument

UI Display

Python Named Argument

Apply smoothing operations

apply_smoothing

Face Data [AttributeMatrix]

face_data_group_name

Face Feature Data [AttributeMatrix]

face_feature_attribute_matrix_name

Face Labels

face_labels_array_name

Cell Feature Ids

feature_ids_path

Input Image Geometry

input_grid_geometry_path

Max Distance from Voxel Center

max_distance_from_voxel

Node Type

node_types_array_name

Created Triangle Geometry

output_triangle_geometry_path

Relaxation Factor

relaxation_factor

Relaxation Iterations

smoothing_iterations

Vertex Data [AttributeMatrix]

vertex_data_group_name

Execute(data_structure, apply_smoothing, face_data_group_name, face_feature_attribute_matrix_name, face_labels_array_name, feature_ids_path, input_grid_geometry_path, max_distance_from_voxel, node_types_array_name, output_triangle_geometry_path, relaxation_factor, smoothing_iterations, vertex_data_group_name)
Parameters:
  • data_structure (DataStructure) – The DataStructure object that holds the data to be processed.

  • apply_smoothing (nx.BoolParameter) – Use the built in smoothing operation.

  • face_data_group_name (nx.DataObjectNameParameter) – The complete path to the DataGroup where the Face Data of the Triangle Geometry will be created

  • face_feature_attribute_matrix_name (nx.DataObjectNameParameter) – The complete path to the DataGroup where the Feature Data will be stored.

  • face_labels_array_name (nx.DataObjectNameParameter) – The complete path to the Array specifying which Features are on either side of each Face in the Triangle Geometry

  • feature_ids_path (nx.ArraySelectionParameter) – The complete path to the Array specifying which Feature each Cell belongs to

  • input_grid_geometry_path (nx.GeometrySelectionParameter) – DataPath to input Image Geometry

  • max_distance_from_voxel (nx.Float32Parameter) – The maximum allowable distance that a node can move from the voxel center

  • node_types_array_name (nx.DataObjectNameParameter) – The complete path to the Array specifying the type of node in the Triangle Geometry

  • output_triangle_geometry_path (nx.DataGroupCreationParameter) – The name of the created Triangle Geometry

  • relaxation_factor (nx.Float32Parameter) – The factor used to determine how far a node can move in each smoothing iteration

  • smoothing_iterations (nx.Int32Parameter) – Number of relaxation iterations to perform. More iterations causes more smoothing.

  • vertex_data_group_name (nx.DataObjectNameParameter) – The complete path to the DataGroup where the Vertex Data of the Triangle Geometry will be created

Returns:

Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.

Return type:

nx.IFilter.ExecuteResult

Compute Triangle Centroids

class simplnx.TriangleCentroidFilter

This Filter computes the centroid of each Triangle in a Triangle Geometry by calculating the average position of all 3 Vertices that make up the Triangle.

Link to the full online documentation for TriangleCentroidFilter

Mapping of UI display to python named argument

UI Display

Python Named Argument

Created Face Centroids

centroids_array_name

Triangle Geometry

input_triangle_geometry_path

Execute(data_structure, centroids_array_name, input_triangle_geometry_path)
Parameters:
  • data_structure (DataStructure) – The DataStructure object that holds the data to be processed.

  • centroids_array_name (nx.DataObjectNameParameter) – The complete path to the array storing the calculated centroids

  • input_triangle_geometry_path (nx.GeometrySelectionParameter) – The complete path to the Geometry for which to calculate the normals

Returns:

Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.

Return type:

nx.IFilter.ExecuteResult

Calculate Triangle Minimum Dihedral Angle

class simplnx.TriangleDihedralAngleFilter

This Filter computes the minimum dihedral angle of each Triangle in a Triangle Geometry by utilizing matrix mathematics

Link to the full online documentation for TriangleDihedralAngleFilter

Mapping of UI display to python named argument

UI Display

Python Named Argument

Triangle Geometry

input_triangle_geometry_path

Created Dihedral Angles

surface_mesh_triangle_dihedral_angles_array_name

Execute(data_structure, input_triangle_geometry_path, surface_mesh_triangle_dihedral_angles_array_name)
Parameters:
  • data_structure (DataStructure) – The DataStructure object that holds the data to be processed.

  • input_triangle_geometry_path (nx.GeometrySelectionParameter) – The complete path to the Geometry for which to calculate the dihedral angles

  • surface_mesh_triangle_dihedral_angles_array_name (nx.DataObjectNameParameter) – The name of the array storing the calculated dihedral angles

Returns:

Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.

Return type:

nx.IFilter.ExecuteResult

Compute Triangle Normals

class simplnx.TriangleNormalFilter

This Filter computes the normal of each Triangle in a Triangle Geometry by utilizing matrix subtraction, cross product, and normalization to implement the following theory:For a triangle with point1, point2, point3, if the vector U = point2 - point1 and the vector V = point3 - point1

Link to the full online documentation for TriangleNormalFilter

Mapping of UI display to python named argument

UI Display

Python Named Argument

Triangle Geometry

input_triangle_geometry_path

Created Face Normals

output_normals_array_name

Execute(data_structure, input_triangle_geometry_path, output_normals_array_name)
Parameters:
  • data_structure (DataStructure) – The DataStructure object that holds the data to be processed.

  • input_triangle_geometry_path (nx.GeometrySelectionParameter) – The complete path to the Geometry for which to calculate the normals

  • output_normals_array_name (nx.DataObjectNameParameter) – The complete path to the array storing the calculated normals

Returns:

Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.

Return type:

nx.IFilter.ExecuteResult

Sample Triangle Geometry on Uncertain Regular Grid

class simplnx.UncertainRegularGridSampleSurfaceMeshFilter

This Filter “samples” a triangulated surface mesh on a rectilinear grid, but with “uncertainty” in the absolute position of the Cells. The “uncertainty” is meant to simulate the possible positioning error in a sampling probe. The user can specify the number of Cells along the X, Y, and Z directions in addition to the resolution in each direction and origin to define a rectilinear grid. The sampling, with “uncertainty”, is then performed by the following steps:

Link to the full online documentation for UncertainRegularGridSampleSurfaceMeshFilter

Mapping of UI display to python named argument

UI Display

Python Named Argument

Cell Data Name

cell_attribute_matrix_name

Number of Cells per Axis

dimensions

Feature Ids Name

feature_ids_array_name

Image Geometry

input_image_geometry_path

Triangle Geometry

input_triangle_geometry_path

Origin

origin

Stored Seed Value Array Name

seed_array_name

Seed Value

seed_value

Spacing

spacing

Face Labels

surface_mesh_face_labels_array_path

Uncertainty

uncertainty

Use Seed for Random Generation

use_seed

Execute(data_structure, cell_attribute_matrix_name, dimensions, feature_ids_array_name, input_image_geometry_path, input_triangle_geometry_path, origin, seed_array_name, seed_value, spacing, surface_mesh_face_labels_array_path, uncertainty, use_seed)
Parameters:
Returns:

Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.

Return type:

nx.IFilter.ExecuteResult

Write ASCII Data

class simplnx.WriteASCIIDataFilter

This filter will write the selected DataArrays to either individual files or as a single CSV style of file.

Link to the full online documentation for WriteASCIIDataFilter

Mapping of UI display to python named argument

UI Display

Python Named Argument

Delimiter

delimiter_index

File Extension

file_extension

Header and Index Options

header_option_index

Attribute Arrays to Export

input_data_array_paths

Maximum Tuples Per Line

max_val_per_line

Output Directory

output_dir

Output Path

output_path

Output File Generation

output_style_index

Execute(data_structure, delimiter_index, file_extension, header_option_index, input_data_array_paths, max_val_per_line, output_dir, output_path, output_style_index)
Parameters:
Returns:

Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.

Return type:

nx.IFilter.ExecuteResult

Write Abaqus Hexahedron

class simplnx.WriteAbaqusHexahedronFilter

This Filter produces the basic five Abaqus .inp files for input into the Abaqus analysis tool. The files created are: xxx.inp (the master file), xxx_nodes.inp, xxx_elems.inp, xxx_elset.inp and xxx_sects.inp. This Filter is based on a Python script developed by Matthew W. Priddy (Ga. Tech., early 2015).

Link to the full online documentation for WriteAbaqusHexahedronFilter

Mapping of UI display to python named argument

UI Display

Python Named Argument

Cell Feature Ids

feature_ids_array_path

Output File Prefix

file_prefix

Hourglass Stiffness Value

hourglass_stiffness

Selected Image Geometry

input_image_geometry_path

Job Name

job_name

Output Path

output_path

Execute(data_structure, feature_ids_array_path, file_prefix, hourglass_stiffness, input_image_geometry_path, job_name, output_path)
Parameters:
Returns:

Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.

Return type:

nx.IFilter.ExecuteResult

Write Avizo Rectilinear Coordinate

class simplnx.WriteAvizoRectilinearCoordinateFilter

This filter writes out a native Avizo Rectilinear Coordinate data file. Values should be present from segmentation of experimental data or synthetic generation and cannot be determined by this filter. Not having these values will result in the filter to fail/not execute.

Link to the full online documentation for WriteAvizoRectilinearCoordinateFilter

Mapping of UI display to python named argument

UI Display

Python Named Argument

Cell Feature Ids

feature_ids_array_path

Image Geometry

input_image_geometry_path

Output File

output_file

Units

units

Write Binary File

write_binary_file

Execute(data_structure, feature_ids_array_path, input_image_geometry_path, output_file, units, write_binary_file)
Parameters:
Returns:

Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.

Return type:

nx.IFilter.ExecuteResult

Write Avizo Uniform Coordinate

class simplnx.WriteAvizoUniformCoordinateFilter

This filter writes out a native Avizo Uniform Coordinate data file. Values should be present from segmentation of experimental data or synthetic generation and cannot be determined by this filter. Not having these values will result in the filter to fail/not execute.

Link to the full online documentation for WriteAvizoUniformCoordinateFilter

Mapping of UI display to python named argument

UI Display

Python Named Argument

Cell Feature Ids

feature_ids_array_path

Image Geometry

input_image_geometry_path

Output File

output_file

Units

units

Write Binary File

write_binary_file

Execute(data_structure, feature_ids_array_path, input_image_geometry_path, output_file, units, write_binary_file)
Parameters:
Returns:

Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.

Return type:

nx.IFilter.ExecuteResult

Write Binary Data

class simplnx.WriteBinaryDataFilter

This Filter accepts DataArray(s) as input, extracts the data, creates the file(s), and writes it out to a single file in binary

Link to the full online documentation for WriteBinaryDataFilter

Mapping of UI display to python named argument

UI Display

Python Named Argument

Endianess

endian_index

File Extension

file_extension

Attribute Arrays to Export

input_data_array_paths

Output Path

output_path

Execute(data_structure, endian_index, file_extension, input_data_array_paths, output_path)
Parameters:
Returns:

Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.

Return type:

nx.IFilter.ExecuteResult

Write DREAM3D NX File

class simplnx.WriteDREAM3DFilter

This Filter dumps the data structure to an hdf5 file with the .dream3d extension.

Link to the full online documentation for WriteDREAM3DFilter

Mapping of UI display to python named argument

UI Display

Python Named Argument

Output File Path

export_file_path

Write Xdmf File

write_xdmf_file

Execute(data_structure, export_file_path, write_xdmf_file)
Parameters:
  • data_structure (DataStructure) – The DataStructure object that holds the data to be processed.

  • export_file_path (nx.FileSystemPathParameter) – The file path the DataStructure should be written to as an HDF5 file.

  • write_xdmf_file (nx.BoolParameter) – Whether or not to write the data out an XDMF file

Returns:

Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.

Return type:

nx.IFilter.ExecuteResult

Write Feature Data as CSV File

class simplnx.WriteFeatureDataCSVFilter

This Filter writes the data associated with each Feature to a file name specified by the user in CSV format. Every array in the Feature map is written as a column of data in the CSV file. The user can choose to also write the neighbor data. Neighbor data are data arrays that are associated with the neighbors of a Feature, such as: list of neighbors, list of misorientations, list of shared surface areas, etc. These blocks of info are written after the scalar data arrays. Since the number of neighbors is variable for each Feature, the data is written as follows (for each Feature): Id, number of neighbors, value1, value2,…valueN.

Link to the full online documentation for WriteFeatureDataCSVFilter

Mapping of UI display to python named argument

UI Display

Python Named Argument

Feature Attribute Matrix

cell_feature_attribute_matrix_path

Delimiter

delimiter_index

Output File

feature_data_file

Write Neighbor Data

write_neighborlist_data

Write Number of Features Line

write_num_features_line

Execute(data_structure, cell_feature_attribute_matrix_path, delimiter_index, feature_data_file, write_neighborlist_data, write_num_features_line)
Parameters:
Returns:

Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.

Return type:

nx.IFilter.ExecuteResult

Write Los Alamos FFT File

class simplnx.WriteLosAlamosFFTFilter

This Filter will create the directories along the path to the file if possible.

Link to the full online documentation for WriteLosAlamosFFTFilter

Mapping of UI display to python named argument

UI Display

Python Named Argument

Cell Euler Angles

cell_euler_angles_array_path

Cell Phases

cell_phases_array_path

Cell Feature Ids

feature_ids_array_path

Input Image Geometry

input_image_geometry_path

Output File Path

output_file

Execute(data_structure, cell_euler_angles_array_path, cell_phases_array_path, feature_ids_array_path, input_image_geometry_path, output_file)
Parameters:
Returns:

Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.

Return type:

nx.IFilter.ExecuteResult

Write Nodes And Elements File(s)

class simplnx.WriteNodesAndElementsFilesFilter

This Filter exports geometric data into structured text files. It allows users to save the following:

Link to the full online documentation for WriteNodesAndElementsFilesFilter

Mapping of UI display to python named argument

UI Display

Python Named Argument

Output Element/Cell File Path

element_file_path

Include Element/Cell File Header

include_element_file_header

Include Node File Header

include_node_file_header

Output Node File Path

node_file_path

Number Elements/Cells

number_elements

Number Nodes

number_nodes

Geometry To Write

selected_geometry_path

Write Element/Cell File

write_element_file

Write Node File

write_node_file

Execute(data_structure, element_file_path, include_element_file_header, include_node_file_header, node_file_path, number_elements, number_nodes, selected_geometry_path, write_element_file, write_node_file)
Parameters:
  • data_structure (DataStructure) – The DataStructure object that holds the data to be processed.

  • element_file_path (nx.FileSystemPathParameter) – The element/cell information will be written to this file path.

  • include_element_file_header (nx.BoolParameter) – Whether or not to include the element/cell file header in the element/cell output file.

  • include_node_file_header (nx.BoolParameter) – Whether or not to include the node file header in the node output file.

  • node_file_path (nx.FileSystemPathParameter) – The node information will be written to this file path.

  • number_elements (nx.BoolParameter) – Whether or not to number each element/cell in the element information output file.

  • number_nodes (nx.BoolParameter) – Whether or not to number each node in the node information output file.

  • selected_geometry_path (nx.GeometrySelectionParameter) – The Geometry that will be written to the output file(s).

  • write_element_file (nx.BoolParameter) – Whether or not to write the element/cell information out to a file.

  • write_node_file (nx.BoolParameter) – Whether or not to write the node information out to a file.

Returns:

Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.

Return type:

nx.IFilter.ExecuteResult

Write SPParks Sites File

class simplnx.WriteSPParksSitesFilter

This Filter writes to a data file in a format used by SPPARKS Kinetic Monte Carlo Simulator.

Link to the full online documentation for WriteSPParksSitesFilter

Mapping of UI display to python named argument

UI Display

Python Named Argument

Cell Feature Ids

feature_ids_array_path

Input Image Geometry

input_image_geometry_path

Output File Path

output_file

Execute(data_structure, feature_ids_array_path, input_image_geometry_path, output_file)
Parameters:
Returns:

Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.

Return type:

nx.IFilter.ExecuteResult

Write STL Files from Triangle Geometry

class simplnx.WriteStlFileFilter

*WARNING:* The filter now provides implict overflow capabilities for very large datasets, but this will lead to many duplicated vertices being produced. Be sure to run a cleaning algorithm when importing these files into DREAM3DNX or other software. For more info see below.

Link to the full online documentation for WriteStlFileFilter

Mapping of UI display to python named argument

UI Display

Python Named Argument

Face labels

feature_ids_path

Feature Phases

feature_phases_path

File Grouping Type

grouping_type_index

Selected Triangle Geometry

input_triangle_geometry_path

Output STL Directory

output_stl_directory

Output STL File

output_stl_file

Output STL File Prefix

output_stl_prefix

Part Numbers

part_number_path

Execute(data_structure, feature_ids_path, feature_phases_path, grouping_type_index, input_triangle_geometry_path, output_stl_directory, output_stl_file, output_stl_prefix, part_number_path)
Parameters:
Returns:

Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.

Return type:

nx.IFilter.ExecuteResult

Write Vtk Rectilinear Grid

class simplnx.WriteVtkRectilinearGridFilter

This Filter writes a VTK legacy file with a Dataset type of RECTILINEAR_GRID. The user can select which arrays from the Image Geometry will be written to the file.

Link to the full online documentation for WriteVtkRectilinearGridFilter

Mapping of UI display to python named argument

UI Display

Python Named Argument

Cell Data Arrays to Write

input_data_array_paths

Image Geometry

input_image_geometry_path

Output File

output_file

Write Binary File

write_binary_file

Execute(data_structure, input_data_array_paths, input_image_geometry_path, output_file, write_binary_file)
Parameters:
Returns:

Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.

Return type:

nx.IFilter.ExecuteResult

Write Vtk Structured Points

class simplnx.WriteVtkStructuredPointsFilter

This Filter writes a VTK legacy file with a Dataset type of STRUCTURED_POINTS. The user can select which arrays from the Image Geometry will be written to the file.

Link to the full online documentation for WriteVtkStructuredPointsFilter

Mapping of UI display to python named argument

UI Display

Python Named Argument

Cell Data Arrays to Write

input_data_array_paths

Image Geometry

input_image_geometry_path

Output File

output_file

Write Binary File

write_binary_file

Execute(data_structure, input_data_array_paths, input_image_geometry_path, output_file, write_binary_file)
Parameters:
Returns:

Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.

Return type:

nx.IFilter.ExecuteResult