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 File Path

alignment_shift_file_name

Selected Image Geometry

input_image_geometry_path

Mask Array

mask_array_path

Reference Slice

reference_slice

Cell Data Attribute Matrix

selected_cell_data_path

Use Reference Slice

use_reference_slice

Write Alignment Shift File

write_alignment_shifts

Execute(data_structure, alignment_shift_file_name, input_image_geometry_path, mask_array_path, reference_slice, selected_cell_data_path, use_reference_slice, write_alignment_shifts)
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 (List)

class simplnx.AlignSectionsListFilter

This Filter will apply the cell shifts from a user specified txt file to each section of an Image Geometry. It accepts an alignment .txt file that has full Cells shifts that have already been calculated in it.

Link to the full online documentation for AlignSectionsListFilter

Mapping of UI display to python named argument

UI Display

Python Named Argument

DREAM3D Alignment File Format

dream3d_alignment_file

Input File

input_file

Selected Image Geometry

input_image_geometry_path

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

  • dream3d_alignment_file (nx.BoolParameter) – Turn this ON if the alignment file was generated by another DREAM.3D Alignment filter

  • input_file (nx.FileSystemPathParameter) – The input .txt file path containing the shifts to apply to the sections

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

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 Z Slice (Image Geometry)

class simplnx.AppendImageGeometryZSliceFilter

This filter allows the user to append an Image Geometry onto the “end” of another Image Geometry. The input anddestination ImageGeometry objects must have the same X&Y dimensions. Optional Checks for equal Resolution valuescan also be performed.

Link to the full online documentation for AppendImageGeometryZSliceFilter

Mapping of UI display to python named argument

UI Display

Python Named Argument

Check Spacing

check_resolution

Destination Image Geometry

destination_image_geometry_path

Input Image Geometry

input_image_geometry_path

New Image Geometry

output_image_geometry_path

Save as new geometry

save_as_new_geometry

Execute(data_structure, check_resolution, destination_image_geometry_path, input_image_geometry_path, 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.

  • input_image_geometry_path (nx.GeometrySelectionParameter) – The incoming image geometry (cell data) that is to be appended.

  • 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

Rotation Axis-Angle

rotation

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, rotation, 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

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

  • 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

Calculate Frequency Histogram

class simplnx.CalculateArrayHistogramFilter

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 CalculateArrayHistogramFilter

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 Histograms

histogram_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_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_suffix (nx.StringParameter) – String appended to the end of the histogram array names

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

  • min_range (nx.Float64Parameter) – Specifies the 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

Find Feature Sizes

class simplnx.CalculateFeatureSizesFilter

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 CalculateFeatureSizesFilter

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

Calculate Triangle Areas

class simplnx.CalculateTriangleAreasFilter

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

Link to the full online documentation for CalculateTriangleAreasFilter

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

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 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

Face Attribute Matrix

face_attribute_matrix_name

Created Face Labels

face_label_name

Face Normals

face_normals_array_name

Label Triangles

label_faces

Label Vertices

label_vertices

Triangle Geometry

output_triangle_geometry_path

Path to STL Files

stl_files_path

Vertex Attribute Matrix

vertex_attribute_matrix_name

Created Vertex Labels

vertex_label_name

Execute(data_structure, face_attribute_matrix_name, face_label_name, face_normals_array_name, label_faces, label_vertices, output_triangle_geometry_path, stl_files_path, vertex_attribute_matrix_name, vertex_label_name)
Parameters:
  • data_structure (DataStructure) – The DataStructure object that holds the data to be processed.

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

  • face_label_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_faces (nx.BoolParameter) – When true, each triangle will get an index associated with the index of the STL file

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

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

  • 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 vertex labels 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 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:
  • data_structure (DataStructure) – The DataStructure object that holds the data to be processed.

  • feature_data_attribute_matrix_path (nx.DataGroupSelectionParameter) – The path to the feature data attribute matrix associated with the input feature ids array

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

  • feature_rect_array_name (nx.DataObjectNameParameter) – The feature rect calculated from the feature ids

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

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

Copied Parent Group

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 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 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

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) – Number of components

  • 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

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

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, 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

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 DREAM.3D 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 DREAM.3D 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 DREAM.3D 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

Find 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

Find Attribute Array Statistics

class simplnx.FindArrayStatisticsFilter

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 FindArrayStatisticsFilter

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 Array Name

histogram_array_name

Length Array Name

length_array_name

Mask Array

mask_array_path

Histogram Max Value

max_range

Maximum Array Name

maximum_array_name

Mean Array Name

mean_array_name

Median Array Name

median_array_name

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_array_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

Find Biased Features (Bounding Box)

class simplnx.FindBiasedFeaturesFilter

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 FindBiasedFeaturesFilter

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

Find Boundary Cells (Image)

class simplnx.FindBoundaryCellsFilter

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 FindBoundaryCellsFilter

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

Find Feature Boundary Element Fractions

class simplnx.FindBoundaryElementFractionsFilter

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 FindBoundaryElementFractionsFilter

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

Find Differences Map

class simplnx.FindDifferencesMapFilter

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 FindDifferencesMapFilter

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

Find Euclidean Distance Map

class simplnx.FindEuclideanDistMapFilter

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 FindEuclideanDistMapFilter

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

Find Feature Centroids

class simplnx.FindFeatureCentroidsFilter

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 FindFeatureCentroidsFilter

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

Find Feature Clustering

class simplnx.FindFeatureClusteringFilter

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 FindFeatureClusteringFilter

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

Equivalent Diameters

equivalent_diameters_array_path

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, equivalent_diameters_array_path, 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

Find Feature Neighbors

class simplnx.FindFeatureNeighborsFilter

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 FindFeatureNeighborsFilter

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

Find Feature Phases Binary

class simplnx.FindFeaturePhasesBinaryFilter

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 FindFeaturePhasesBinaryFilter

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

Find Feature Phases

class simplnx.FindFeaturePhasesFilter

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 FindFeaturePhasesFilter

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

Find Feature Largest Cross-Section Areas

class simplnx.FindLargestCrossSectionsFilter

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 FindLargestCrossSectionsFilter

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

Find Neighbor List Statistics

class simplnx.FindNeighborListStatisticsFilter

This Filter finds 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 FindNeighborListStatisticsFilter

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

Find Feature Neighborhoods

class simplnx.FindNeighborhoodsFilter

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 FindNeighborhoodsFilter

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

Find Number of Features

class simplnx.FindNumFeaturesFilter

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 FindNumFeaturesFilter

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:
  • data_structure (DataStructure) – The DataStructure object that holds the data to be processed.

  • ensemble_attribute_matrix_path (nx.DataGroupSelectionParameter) – The path to the ensemble attribute matrix where the number of features array will be stored

  • feature_phases_array_path (nx.ArraySelectionParameter) – Array specifying which Ensemble each Feature belongs

  • num_features_array_name (nx.DataObjectNameParameter) – The number of Features that belong to each Ensemble

Returns:

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

Return type:

nx.IFilter.ExecuteResult

Find Surface Area to Volume & Sphericity

class simplnx.FindSurfaceAreaToVolumeFilter

This Filter calculates the ratio of surface area to volume for each Feature in an Image Geometry. First, all the boundary Cells are found for each Feature. Next, the surface area for each face that is in contact with a different Feature is totalled. This number is divided by the volume of each Feature, calculated by taking the number of Cells of each Feature and multiplying by the volume of a Cell.

Link to the full online documentation for FindSurfaceAreaToVolumeFilter

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

Find Surface Features

class simplnx.FindSurfaceFeaturesFilter

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 FindSurfaceFeaturesFilter

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.DataGroupSelectionParameter) – 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

Find Feature Centroids from Triangle Geometry

class simplnx.FindTriangleGeomCentroidsFilter

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 FindTriangleGeomCentroidsFilter

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

Find Feature Volumes from Triangle Geometry

class simplnx.FindTriangleGeomSizesFilter

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 FindTriangleGeomSizesFilter

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

Find Vertex to Triangle Distances

class simplnx.FindVertexToTriangleDistancesFilter

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 FindVertexToTriangleDistancesFilter

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

Find Volume Fractions of Ensembles

class simplnx.FindVolFractionsFilter

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 FindVolFractionsFilter

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:
  • data_structure (DataStructure) – The DataStructure object that holds the data to be processed.

  • cell_ensemble_attribute_matrix_path (nx.DataGroupSelectionParameter) – The path to the cell ensemble attribute matrix where the output volume fractions array will be stored

  • cell_phases_array_path (nx.ArraySelectionParameter) – Array specifying which Ensemble each Cell belong

  • vol_fractions_array_name (nx.DataObjectNameParameter) – Fraction of volume that belongs to each Ensemble

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

Generate Color Table

class simplnx.GenerateColorTableFilter

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 GenerateColorTableFilter

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.GenerateColorTableParameter) – 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

Generate Python Plugin and/or Filters

class simplnx.GeneratePythonSkeletonFilter

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 GeneratePythonSkeletonFilter

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

Generate Vector Colors

class simplnx.GenerateVectorColorsFilter

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 GenerateVectorColorsFilter

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

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

Execute(data_structure, fill_holes, input_image_geometry_path, mask_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

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

Increment/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 increment/decrement 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

K Means

class simplnx.KMeansFilter

*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 KMeansFilter

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

K Medoids

class simplnx.KMedoidsFilter

*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 KMedoidsFilter

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

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

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, 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

Minimum Number of Neighbors

class simplnx.MinNeighborsFilter

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 MinNeighborsFilter

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

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:
  • data_structure (DataStructure) – The DataStructure object that holds the data to be processed.

  • fill_value (nx.Float64Parameter) – This is the value that will appear in the arrays outside the overlap

  • input_reference_image_geometry__path (nx.GeometrySelectionParameter) – This is the geometry that will store the values from the overlap

  • input_sampling_image_geometry_path (nx.GeometrySelectionParameter) – This is the geometry that will be copied into the reference geometry at the overlap

  • reference_cell_attribute_matrix_path (nx.DataGroupSelectionParameter) – The attribute matrix for the reference geometry

  • sampling_cell_attribute_matrix_path (nx.DataGroupSelectionParameter) – The attribute matrix for the sampling geometry

  • use_fill (nx.BoolParameter) – If false all copied arrays will be filled with 0 by default

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.DataPathSelectionParameter) – 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

Quick Surface Mesh

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 Attribute Matrix

selected_attribute_matrix_path

Use Existing 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.AttributeMatrixSelectionParameter) – Store the imported CSV data arrays in this existing attribute matrix.

  • use_existing_group (nx.BoolParameter) – Store the imported CSV data arrays in an existing 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 DREAM.3D. 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_hd_f5_file

Execute(data_structure, import_hd_f5_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 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

Face Data [AttributeMatrix]

face_attribute_matrix_name

Face Labels

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, face_attribute_matrix_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 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/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.

Link to the full online documentation for RemoveFlaggedTrianglesFilter

Mapping of UI display to python named argument

UI Display

Python Named Argument

Triangle|Quad Geometry

input_triangle_geometry_path

Mask

mask_array_path

Created Geometry

output_triangle_geometry_path

Execute(data_structure, input_triangle_geometry_path, mask_array_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

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 iscreated that contains all the remaining Vertices. It is unknown until run time how many Vertices will be removedfrom the Geometry. Therefore, this Filter requires that a new Data Container be created to contain thereduced 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, withtuples 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 namesas 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_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

Remove Minimum Size Features

class simplnx.RemoveMinimumSizeFeaturesFilter

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 RemoveMinimumSizeFeaturesFilter

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

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

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

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

Generate 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:
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 Multicomponent 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

SurfaceNets Meshing Filter

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

Attribute Arrays to Transfer

input_data_array_paths

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_data_array_paths, 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 smmothing 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_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) – 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

Calculate 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

Calculate 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 STL Files from Triangle Geometry

class simplnx.WriteStlFileFilter

This Filter will write a binary STL File for each unique Feature Id in the associated Triangle geometry. The STL files will be named with the [Feature_Id].stl. The user can designate an optional prefix for the files.

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

STL File Prefix

output_stl_prefix

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)
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