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:
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:
data_structure (DataStructure) – The DataStructure object that holds the data to be processed.
alignment_type_index (nx.ChoicesParameter) – The type of alignment to perform (Origin or Centroid.
input_moving_geometry_path (nx.GeometrySelectionParameter) – The geometry that will be moved.
input_target_geometry_path (nx.GeometrySelectionParameter) – The geometry that does not move.
- Returns:
Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.
- Return type:
Align Sections (Feature Centroid)
- class simplnx.AlignSectionsFeatureCentroidFilter
This Filter attempts to align ‘sections’ of the sample perpendicular to the Z-direction by determining the position that closest aligns the centroid(s) of previously defined “regions”. The “regions” are defined by a boolean array where the Cells have been flagged by another Filter. Typically, during reading/processing of the data, each Cell is subject to a “quality metric” (or threshold) that defines if the Cell is good. This threshold can be used to define areas of each slice that are bad, either due to actual features in the microstructure or external references inserted by the user/experimentalist. If these “regions” of bad Cells are believed to be consistent through sections, then this Filter will preserve that by aligning those “regions” on top of one another on consecutive sections. The algorithm of this Filter is as follows:
Link to the full online documentation for AlignSectionsFeatureCentroidFilter
Mapping of UI display to python named argument
UI Display
Python Named Argument
Alignment Attribute Matrix Name
alignment_attribute_matrix_name
Alignment Centroids Data Array Name
centroids_array_name
Alignment Cumulative Shifts Data Array Name
cumulative_shifts_array_name
Selected Image Geometry
input_image_geometry_path
Mask Array
mask_array_path
Reference Slice
reference_slice
Alignment Relative Shifts Data Array Name
relative_shifts_array_name
Alignment Slices Data Array Name
slices_array_name
Store Alignment Shifts
store_alignment_shifts
Use Reference Slice
use_reference_slice
- Execute(data_structure, alignment_attribute_matrix_name, centroids_array_name, cumulative_shifts_array_name, input_image_geometry_path, mask_array_path, reference_slice, relative_shifts_array_name, slices_array_name, store_alignment_shifts, use_reference_slice)
- Parameters:
data_structure (DataStructure) – The DataStructure object that holds the data to be processed.
alignment_attribute_matrix_name (nx.DataObjectNameParameter) – The output attribute matrix where the shifts applied to the section to be stored as DataArrays.
centroids_array_name (nx.DataObjectNameParameter) – The output array name where the centroid information will be stored.
cumulative_shifts_array_name (nx.DataObjectNameParameter) – The output array name where the accumulated shift information will be stored.
input_image_geometry_path (nx.GeometrySelectionParameter) – The target geometry on which to perform the alignment
mask_array_path (nx.ArraySelectionParameter) – Specifies if the Cell is to be counted in the algorithm.
reference_slice (nx.Int32Parameter) – Slice number to use as reference
relative_shifts_array_name (nx.DataObjectNameParameter) – The output array name where the new shifts relative to previous slice information will be stored.
slices_array_name (nx.DataObjectNameParameter) – The output array name where the slice information related to shifts will be stored.
store_alignment_shifts (nx.BoolParameter) – Whether to store the shifts applied to each section to a collection of Arrays in a new Attribute Matrix
use_reference_slice (nx.BoolParameter) – Whether the centroids of each section should be compared to a reference slice instead of their neighboring section
- Returns:
Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.
- Return type:
Align Sections (List)
- class simplnx.AlignSectionsListFilter
This Filter will apply the precalculated cell shifts to each section of an Image Geometry. It allows for both relative or cumulative cell shifts. The difference between the two being the former is dependent on the previous slice’s position. Under the covers, relative is translated to cumulative before applying shifts to the cells themselves. Previously, the only accepted input was utilizing relative shifts, so use those for backwards compatibility. See the Handling User Created Shifts File and Example Pipelines sections of this documentation for further hints.
Link to the full online documentation for AlignSectionsListFilter
Mapping of UI display to python named argument
UI Display
Python Named Argument
Input Array Type
input_array_type_index
Selected Image Geometry
input_image_geometry_path
Shifts Array
shifts_array_path
- Execute(data_structure, input_array_type_index, input_image_geometry_path, shifts_array_path)
- Parameters:
data_structure (DataStructure) – The DataStructure object that holds the data to be processed.
input_array_type_index (nx.ChoicesParameter) – This selection determines how the input array was produced, Relative refers to the case where the shifts were calculated relative to the previous slice’s new position, Cumulative refers to the case where the shifts are the direct change in position
input_image_geometry_path (nx.GeometrySelectionParameter) – The target geometry on which to perform the alignment
shifts_array_path (nx.ArraySelectionParameter) – The array containing the relative or cumulative shifts for each slice
- Returns:
Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.
- Return type:
Append Image Geometry
- class simplnx.AppendImageGeometryFilter
This filter allows the user to append one or multiple image geometries to a given image geometry, in any direction (X,Y,Z). The input anddestination ImageGeometry objects must have the same dimensions in the directions that are NOT chosen. If the X direction is chosen, the geometries must match in Y & Z. If the Y direction is chosen, the geometries must match in X & Z. If the Z direction is chosen, the geometries must match in X & Y. Optional checks for equal Resolution values can also be performed.
Link to the full online documentation for AppendImageGeometryFilter
Mapping of UI display to python named argument
UI Display
Python Named Argument
Check Spacing
check_resolution
Destination Image Geometry
destination_image_geometry_path
Direction
direction_index
Input Image Geometries
input_image_geometries_paths
Mirror Geometry In Direction
mirror_geometry
New Image Geometry
output_image_geometry_path
Save as new geometry
save_as_new_geometry
- Execute(data_structure, check_resolution, destination_image_geometry_path, direction_index, input_image_geometries_paths, mirror_geometry, output_image_geometry_path, save_as_new_geometry)
- Parameters:
data_structure (DataStructure) – The DataStructure object that holds the data to be processed.
check_resolution (nx.BoolParameter) – Checks to make sure the spacing for the input geometry and destination geometry match
destination_image_geometry_path (nx.GeometrySelectionParameter) – The destination image geometry (cell data) that is the final location for the appended data.
direction_index (nx.ChoicesParameter) – The direction that will be used to append the geometries.
input_image_geometries_paths (nx.MultiPathSelectionParameter) – The incoming image geometries (cell data) that will be appended to the destination image geometry.
mirror_geometry (nx.BoolParameter) – Mirrors the resulting geometry in the chosen direction.
output_image_geometry_path (nx.DataGroupCreationParameter) – The path to the new geometry with the combined data from the input & destination geometry
save_as_new_geometry (nx.BoolParameter) – Save the combined data as a new geometry instead of appending the input data to the destination geometry
- Returns:
Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.
- Return type:
Apply Transformation to Geometry
- class simplnx.ApplyTransformationToGeometryFilter
Link to the full online documentation for ApplyTransformationToGeometryFilter
Mapping of UI display to python named argument
UI Display
Python Named Argument
Cell Attribute Matrix (Image Geometry Only)
cell_attribute_matrix_path
Precomputed Transformation Matrix Path
computed_transformation_matrix_path
Selected Geometry
input_image_geometry_path
Resampling or Interpolation (Image Geometry Only)
interpolation_type_index
Transformation Matrix
manual_transformation_matrix
Transform Matrix Output Path
output_transform_matrix_path
Rotation Axis-Angle
rotation
Save Transformation Matrix
save_transform_matrix
Scale
scale
Transformation Type
transformation_type_index
Translate Geometry To Global Origin Before Transformation
translate_geometry_to_global_origin
Translation
translation
- Execute(data_structure, cell_attribute_matrix_path, computed_transformation_matrix_path, input_image_geometry_path, interpolation_type_index, manual_transformation_matrix, output_transform_matrix_path, rotation, save_transform_matrix, scale, transformation_type_index, translate_geometry_to_global_origin, translation)
- Parameters:
data_structure (DataStructure) – The DataStructure object that holds the data to be processed.
cell_attribute_matrix_path (nx.AttributeMatrixSelectionParameter) – The path to the Cell level data that should be interpolated. Only applies when selecting an Image Geometry.
computed_transformation_matrix_path (nx.ArraySelectionParameter) – A precomputed 4x4 transformation matrix
input_image_geometry_path (nx.GeometrySelectionParameter) – The target geometry on which to perform the transformation
interpolation_type_index (nx.ChoicesParameter) – Select the type of interpolation algorithm. (0)Nearest Neighbor, (1)Linear Interpolation, (3)No Interpolation
manual_transformation_matrix (nx.DynamicTableParameter) – The 4x4 Transformation Matrix
output_transform_matrix_path (nx.ArrayCreationParameter) – The output array that contains the transformation Matrix.
rotation (nx.VectorFloat32Parameter) – <xyz> w (w in degrees)
save_transform_matrix (nx.BoolParameter) – Save the generated transform matrix as a Data Array
scale (nx.VectorFloat32Parameter) – 0>= value < 1: Shrink, value = 1: No transform, value > 1.0 enlarge
transformation_type_index (nx.ChoicesParameter) – The type of transformation to perform.
translate_geometry_to_global_origin (nx.BoolParameter) – Specifies whether to translate the geometry to (0, 0, 0), apply the transformation, and then translate the geometry back to its original origin.
translation (nx.VectorFloat32Parameter) – A pure translation vector
- Returns:
Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.
- Return type:
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:
data_structure (DataStructure) – The DataStructure object that holds the data to be processed.
grid_resolution (nx.VectorFloat32Parameter) – Geometry resolution
input_vertex_geometry_path (nx.GeometrySelectionParameter) – Path to the target Vertex geometry
min_empty_neighbors (nx.UInt64Parameter) – Minimum number of empty neighbors
output_vertex_geometry_path (nx.DataGroupCreationParameter) – Path to create the hull Vertex geometry
- Returns:
Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.
- Return type:
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:
data_structure (DataStructure) – The DataStructure object that holds the data to be processed.
calculated_array_path (nx.ArrayCreationParameter) – The path to the calculated array
calculator_parameter (nx.CalculatorParameter) – The mathematical expression used to calculate the output array
scalar_type_index (nx.NumericTypeParameter) – The data type of the calculated array
- Returns:
Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.
- Return type:
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:
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:
Combine Node Based Geometries
- class simplnx.CombineNodeBasedGeometriesFilter
This Filter will combine any node-based geometries together into one node-based geometry. The algorithm is governed by several rules:
Link to the full online documentation for CombineNodeBasedGeometriesFilter
Mapping of UI display to python named argument
UI Display
Python Named Argument
Input Geometries
input_geometry_paths
Combined Geometry
output_geometry_path
- Execute(data_structure, input_geometry_paths, output_geometry_path)
- Parameters:
data_structure (DataStructure) – The DataStructure object that holds the data to be processed.
input_geometry_paths (nx.MultiPathSelectionParameter) – The incoming geometries that will be combined together into the destination geometry. All geometries must be of the same geometry type.
output_geometry_path (nx.DataGroupCreationParameter) – The path to the combined geometry
- Returns:
Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.
- Return type:
Combine STL Files
- class simplnx.CombineStlFilesFilter
This Filter combines all of the STL files from a given directory into a single triangle geometry. This filter will make use of the Import STL File Filter to read in each stl file in the given directory and then will proceed to combine each of the imported files into a single triangle geometry.
Link to the full online documentation for CombineStlFilesFilter
Mapping of UI display to python named argument
UI Display
Python Named Argument
Active
active_array_name
Feature Attribute Matrix
cell_feature_attribute_matrix_name
Generate Triangle Face Labels
create_face_labels
Generate Triangle Part Numbers
create_part_numbers
Face Attribute Matrix
face_attribute_matrix_name
Created Face Labels Array
face_labels_name
Face Normals
face_normals_array_name
Generate Vertex Part Numbers
label_vertices
File List Array
output_file_list_name
Triangle Geometry
output_triangle_geometry_path
Created Part Number Array
part_numbers_name
Path to STL Files
stl_files_path
Vertex Attribute Matrix
vertex_attribute_matrix_name
Created Part Number Labels
vertex_label_name
- Execute(data_structure, active_array_name, cell_feature_attribute_matrix_name, create_face_labels, create_part_numbers, face_attribute_matrix_name, face_labels_name, face_normals_array_name, label_vertices, output_file_list_name, output_triangle_geometry_path, part_numbers_name, stl_files_path, vertex_attribute_matrix_name, vertex_label_name)
- Parameters:
data_structure (DataStructure) – The DataStructure object that holds the data to be processed.
active_array_name (nx.DataObjectNameParameter) – Specifies if the Feature is still in the sample (true if the Feature is in the sample and false if it is not). At the end of the Filter, all Features will be Active
cell_feature_attribute_matrix_name (nx.DataObjectNameParameter) – The name of the created feature attribute matrix
create_face_labels (nx.BoolParameter) – When true, the ‘Face Labels’ array will be created.
create_part_numbers (nx.BoolParameter) – When true, each triangle will get an index associated with the index of the STL file
face_attribute_matrix_name (nx.DataObjectNameParameter) – The name of the face level attribute matrix to be created with the geometry
face_labels_name (nx.DataObjectNameParameter) – The name of the ‘Face Labels’ data array
face_normals_array_name (nx.DataObjectNameParameter) – The name of the data array in which to store the face normals for the created triangle geometry
label_vertices (nx.BoolParameter) – When true, each vertex will get an index associated with the index of the STL file
output_file_list_name (nx.DataObjectNameParameter) – The path to a String array that will store the input paths of each file that was read.
output_triangle_geometry_path (nx.DataGroupCreationParameter) – The path to the triangle geometry to be created from the combined STL files
part_numbers_name (nx.DataObjectNameParameter) – The name of the part numbers data array
stl_files_path (nx.FileSystemPathParameter) – The path to the folder containing all the STL files to be combined
vertex_attribute_matrix_name (nx.DataObjectNameParameter) – The name of the vertex level attribute matrix to be created with the geometry
vertex_label_name (nx.DataObjectNameParameter) – The name of the part numbers data array
- Returns:
Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.
- Return type:
Compute Attribute Array Frequency Histogram
- class simplnx.ComputeArrayHistogramFilter
This Filter accepts DataArray(s) as input, creates histogram DataArray(s) in specified DataGroup from input DataArray(s), then calculates histogram values according to user parameters and stores values in created histogram DataArray(s).
Link to the full online documentation for ComputeArrayHistogramFilter
Mapping of UI display to python named argument
UI Display
Python Named Argument
Create New DataGroup for Histograms
create_new_data_group
Suffix for created Histogram Bin Counts
histogram_bin_count_suffix
Suffix for created Histogram Bin Ranges
histogram_bin_range_suffix
Max Value
max_range
Min Value
min_range
New DataGroup Path
new_data_group_path
Number of Bins
number_of_bins
Output DataGroup Path
output_data_group_path
Input Data Arrays
selected_array_paths
Use Custom Min & Max Range
user_defined_range
- Execute(data_structure, create_new_data_group, histogram_bin_count_suffix, histogram_bin_range_suffix, max_range, min_range, new_data_group_path, number_of_bins, output_data_group_path, selected_array_paths, user_defined_range)
- Parameters:
data_structure (DataStructure) – The DataStructure object that holds the data to be processed.
create_new_data_group (nx.BoolParameter) – Whether or not to store the calculated histogram(s) in a new DataGroup
histogram_bin_count_suffix (nx.StringParameter) – String appended to the end of the histogram array names
histogram_bin_range_suffix (nx.StringParameter) – String appended to the end of the histogram array names
max_range (nx.Float64Parameter) – Specifies the exclusive upper bound of the histogram.
min_range (nx.Float64Parameter) – Specifies the inclusive lower bound of the histogram.
new_data_group_path (nx.DataGroupCreationParameter) – The path to the new DataGroup in which to store the calculated histogram(s)
number_of_bins (nx.Int32Parameter) – Specifies number of histogram bins (greater than zero)
output_data_group_path (nx.DataGroupSelectionParameter) – The complete path to the DataGroup in which to store the calculated histogram(s)
selected_array_paths (nx.MultiArraySelectionParameter) – The list of arrays to calculate histogram(s) for
user_defined_range (nx.BoolParameter) – Whether the user can set the min and max values to consider for the histogram
- Returns:
Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.
- Return type:
Compute Attribute Array Statistics
- class simplnx.ComputeArrayStatisticsFilter
This Filter computes a variety of statistics for a given scalar array. The currently available statistics are array length, minimum, maximum, (arithmetic) mean, median, mode, standard deviation, and summation; any combination of these statistics may be computed by this Filter. Any scalar array, of any primitive type, may be used as input. The type of the output arrays depends on the kind of statistic computed:
Link to the full online documentation for ComputeArrayStatisticsFilter
Mapping of UI display to python named argument
UI Display
Python Named Argument
Compute Statistics Per Feature/Ensemble
compute_by_index
Destination Attribute Matrix
destination_attribute_matrix_path
Feature-Has-Data Array Name
feature_has_data_array_name
Cell Feature Ids
feature_ids_path
Find Histogram
find_histogram
Find Length
find_length
Find Maximum
find_max
Find Mean
find_mean
Find Median
find_median
Find Minimum
find_min
Find Modal Histogram Bin Ranges
find_modal_bin_ranges
Find Mode
find_mode
Find Standard Deviation
find_std_deviation
Find Summation
find_summation
Find Number of Unique Values
find_unique_values
Histogram Bin Counts Array Name
histogram_bin_count_name
Histogram Bin Ranges Array Name
histogram_bin_range_name
Length Array Name
length_array_name
Mask Array
mask_array_path
Custom Histogram Max Value
max_range
Maximum Array Name
maximum_array_name
Mean Array Name
mean_array_name
Median Array Name
median_array_name
Custom Histogram Min Value
min_range
Minimum Array Name
minimum_array_name
Modal Histogram Bin Ranges Array Name
modal_bin_array_name
Mode Array Name
mode_array_name
Most Populated Bin Array Name
most_populated_bin_array_name
Number of Bins
num_bins
Number of Unique Values Array Name
number_unique_values_name
Attribute Array to Compute Statistics
selected_array_path
Standardize Data
standardize_data
Standardized Data Array Name
standardized_array_name
Standard Deviation Array Name
std_deviation_array_name
Summation Array Name
summation_array_name
Use Full Range for Histogram
use_full_range
Use Mask Array
use_mask
- Execute(data_structure, compute_by_index, destination_attribute_matrix_path, feature_has_data_array_name, feature_ids_path, find_histogram, find_length, find_max, find_mean, find_median, find_min, find_modal_bin_ranges, find_mode, find_std_deviation, find_summation, find_unique_values, histogram_bin_count_name, histogram_bin_range_name, length_array_name, mask_array_path, max_range, maximum_array_name, mean_array_name, median_array_name, min_range, minimum_array_name, modal_bin_array_name, mode_array_name, most_populated_bin_array_name, num_bins, number_unique_values_name, selected_array_path, standardize_data, standardized_array_name, std_deviation_array_name, summation_array_name, use_full_range, use_mask)
- Parameters:
data_structure (DataStructure) – The DataStructure object that holds the data to be processed.
compute_by_index (nx.BoolParameter) – Whether the statistics should be computed on a Feature/Ensemble basis
destination_attribute_matrix_path (nx.DataGroupCreationParameter) – Attribute Matrix in which to store the computed statistics
feature_has_data_array_name (nx.DataObjectNameParameter) – The name of the boolean array that indicates whether or not each feature contains any data. This array is especially useful to help determine whether or not the outputted statistics are actually valid or not for a given feature.
feature_ids_path (nx.ArraySelectionParameter) – Specifies to which Feature each Element belongs
find_histogram (nx.BoolParameter) – Whether to compute the histogram of the input array
find_length (nx.BoolParameter) – Whether to compute the length of the input array
find_max (nx.BoolParameter) – Whether to compute the maximum of the input array
find_mean (nx.BoolParameter) – Whether to compute the arithmetic mean of the input array
find_median (nx.BoolParameter) – Whether to compute the median of the input array
find_min (nx.BoolParameter) – Whether to compute the minimum of the input array
find_modal_bin_ranges (nx.BoolParameter) – Whether to compute the histogram bin ranges that contain the mode values. This option requires that “ Find Mode “ is turned on.
find_mode (nx.BoolParameter) – Whether to compute the mode of the input array
find_std_deviation (nx.BoolParameter) – Whether to compute the standard deviation of the input array
find_summation (nx.BoolParameter) – Whether to compute the summation of the input array
find_unique_values (nx.BoolParameter) – Whether to compute the number of unique values in the input array
histogram_bin_count_name (nx.DataObjectNameParameter) – The name of the histogram bin counts array
histogram_bin_range_name (nx.DataObjectNameParameter) – The name of the histogram bin ranges array
length_array_name (nx.DataObjectNameParameter) – The name of the length array
mask_array_path (nx.ArraySelectionParameter) – DataPath to the boolean mask array. Values that are true will mark that cell/point as usable.
max_range (nx.Float64Parameter) – Max cutoff value for histogram
maximum_array_name (nx.DataObjectNameParameter) – The name of the maximum array
mean_array_name (nx.DataObjectNameParameter) – The name of the mean array
median_array_name (nx.DataObjectNameParameter) – The name of the median array
min_range (nx.Float64Parameter) – Min cutoff value for histogram
minimum_array_name (nx.DataObjectNameParameter) – The name of the minimum array
modal_bin_array_name (nx.DataObjectNameParameter) – The name of the array that stores the histogram bin range(s) that contain the mode(s) of the data.
mode_array_name (nx.DataObjectNameParameter) – The name of the mode array
most_populated_bin_array_name (nx.DataObjectNameParameter) – The name of the Most Populated Bin array
num_bins (nx.Int32Parameter) – Number of bins in histogram
number_unique_values_name (nx.DataObjectNameParameter) – The name of the array which stores the calculated number of unique values
selected_array_path (nx.ArraySelectionParameter) – Input Attribute Array for which to compute statistics
standardize_data (nx.BoolParameter) – Should a standardized data array be generated
standardized_array_name (nx.DataObjectNameParameter) – The name of the standardized data array
std_deviation_array_name (nx.DataObjectNameParameter) – The name of the standard deviation array
summation_array_name (nx.DataObjectNameParameter) – The name of the summation array
use_full_range (nx.BoolParameter) – If true, ignore min and max and use min and max from array upon which histogram is computed
use_mask (nx.BoolParameter) – Specifies whether or not to use a mask array
- Returns:
Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.
- Return type:
Compute Biased Features (Bounding Box)
- class simplnx.ComputeBiasedFeaturesFilter
This Filter determines which Features are biased by the outer surfaces of the sample. Larger Features are more likely to intersect the outer surfaces and thus it is not sufficient to only note which Features touch the outer surfaces of the sample. Denoting which Features are biased is important so that they may be excluded from any statistical analyses. The algorithm for determining whether a Feature is biased is as follows:
Link to the full online documentation for ComputeBiasedFeaturesFilter
Mapping of UI display to python named argument
UI Display
Python Named Argument
Biased Features
biased_features_array_name
Apply Phase by Phase
calc_by_phase
Centroids
centroids_array_path
Image Geometry
input_image_geometry_path
Phases
phases_array_path
Surface Features
surface_features_array_path
- Execute(data_structure, biased_features_array_name, calc_by_phase, centroids_array_path, input_image_geometry_path, phases_array_path, surface_features_array_path)
- Parameters:
data_structure (DataStructure) – The DataStructure object that holds the data to be processed.
biased_features_array_name (nx.DataObjectNameParameter) – Flag of 1 if Feature is biased or of 0 if it is not
calc_by_phase (nx.BoolParameter) – Whether to apply the biased Features algorithm per Ensemble
centroids_array_path (nx.ArraySelectionParameter) – X, Y, Z coordinates of Feature center of mass
input_image_geometry_path (nx.GeometrySelectionParameter) – The selected geometry in which to the (biased) features belong
phases_array_path (nx.ArraySelectionParameter) – Specifies to which Ensemble each Feature belongs. Only required if Apply Phase by Phase is checked
surface_features_array_path (nx.ArraySelectionParameter) – Flag of 1 if Feature touches an outer surface or of 0 if it does not
- Returns:
Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.
- Return type:
Compute Boundary Cells (Image)
- class simplnx.ComputeBoundaryCellsFilter
This Filter determines, for each Cell, the number of neighboring Cells that are owned by a different Feature. The algorithm for determining this is as follows:
Link to the full online documentation for ComputeBoundaryCellsFilter
Mapping of UI display to python named argument
UI Display
Python Named Argument
Boundary Cells
boundary_cells_array_name
Cell Feature Ids
feature_ids_array_path
Ignore Feature 0
ignore_feature_zero
Include Volume Boundary
include_volume_boundary
Image Geometry
input_image_geometry_path
- Execute(data_structure, boundary_cells_array_name, feature_ids_array_path, ignore_feature_zero, include_volume_boundary, input_image_geometry_path)
- Parameters:
data_structure (DataStructure) – The DataStructure object that holds the data to be processed.
boundary_cells_array_name (nx.DataObjectNameParameter) – The number of neighboring Cells of a given Cell that belong to a different Feature than itself. Values will range from 0 to 6
feature_ids_array_path (nx.ArraySelectionParameter) – Data Array that specifies to which Feature each Element belongs
ignore_feature_zero (nx.BoolParameter) – Do not use feature 0
include_volume_boundary (nx.BoolParameter) – Include the Cell boundaries
input_image_geometry_path (nx.GeometrySelectionParameter) – The selected geometry to which the cells belong
- Returns:
Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.
- Return type:
Compute Feature Boundary Element Fractions
- class simplnx.ComputeBoundaryElementFractionsFilter
This Filter calculates the fraction of Elements of each Feature that are on the “surface” of that Feature. The Filter simply iterates through all Elements asking for the Feature that owns them and if the Element is a “surface” Element. Each Feature counts the total number of Elements it owns and the number of those Elements that are “surface” Elements. The fraction is then stored for each Feature.
Link to the full online documentation for ComputeBoundaryElementFractionsFilter
Mapping of UI display to python named argument
UI Display
Python Named Argument
Surface Element Fractions
boundary_cell_fractions_array_name
Surface Elements
boundary_cells_array_path
Feature Data
feature_data_attribute_matrix_path
Cell Feature Ids
feature_ids_array_path
- Execute(data_structure, boundary_cell_fractions_array_name, boundary_cells_array_path, feature_data_attribute_matrix_path, feature_ids_array_path)
- Parameters:
data_structure (DataStructure) – The DataStructure object that holds the data to be processed.
boundary_cell_fractions_array_name (nx.DataObjectNameParameter) – Name of created Data Array containing fraction of Elements belonging to the Feature that are “surface” Elements
boundary_cells_array_path (nx.ArraySelectionParameter) – DataArray containing the number of neighboring Elements of a given Element that belong to a different Feature than itself
feature_data_attribute_matrix_path (nx.AttributeMatrixSelectionParameter) – Parent Attribute Matrix for the Surface Element Fractions Array to be created in
feature_ids_array_path (nx.ArraySelectionParameter) – Data Array that specifies to which Feature each Element belongs
- Returns:
Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.
- Return type:
Compute Differences Map
- class simplnx.ComputeDifferencesMapFilter
This Filter calculates the difference between two Attribute Arrays. The arrays must have the same primitive type (e.g., float), component dimensions and number of tuples. The Filter uses the following pseudocode to calculate the difference map:
Link to the full online documentation for ComputeDifferencesMapFilter
Mapping of UI display to python named argument
UI Display
Python Named Argument
Difference Map
difference_map_array_path
First Input Array
first_input_array_path
Second Input Array
second_input_array_path
- Execute(data_structure, difference_map_array_path, first_input_array_path, second_input_array_path)
- Parameters:
data_structure (DataStructure) – The DataStructure object that holds the data to be processed.
difference_map_array_path (nx.ArrayCreationParameter) – DataPath for created Difference Map DataArray
first_input_array_path (nx.ArraySelectionParameter) – DataPath to the first input DataArray
second_input_array_path (nx.ArraySelectionParameter) – DataPath to the second input DataArray
- Returns:
Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.
- Return type:
Compute Euclidean Distance Map
- class simplnx.ComputeEuclideanDistMapFilter
This Filter calculates the distance of each Cell from the nearest Feature boundary, triple line and/or quadruple point. The following algorithm explains the process:
Link to the full online documentation for ComputeEuclideanDistMapFilter
Mapping of UI display to python named argument
UI Display
Python Named Argument
Output arrays are Manhattan distance (int32)
calc_manhattan_dist
Calculate Distance to Boundaries
do_boundaries
Calculate Distance to Quadruple Points
do_quad_points
Calculate Distance to Triple Lines
do_triple_lines
Cell Feature Ids
feature_ids_path
Boundary Distances
g_bdistances_array_name
Selected Image Geometry
input_image_geometry_path
Nearest Boundary Cells
nearest_neighbors_array_name
Quadruple Point Distances
q_pdistances_array_name
Store the Nearest Boundary Cells
save_nearest_neighbors
Triple Line Distances
t_jdistances_array_name
- Execute(data_structure, calc_manhattan_dist, do_boundaries, do_quad_points, do_triple_lines, feature_ids_path, g_bdistances_array_name, input_image_geometry_path, nearest_neighbors_array_name, q_pdistances_array_name, save_nearest_neighbors, t_jdistances_array_name)
- Parameters:
data_structure (DataStructure) – The DataStructure object that holds the data to be processed.
calc_manhattan_dist (nx.BoolParameter) – If Manhattan distance is used then results are stored as int32 otherwise results are stored as float32
do_boundaries (nx.BoolParameter) – Whether the distance of each Cell to a Feature boundary is calculated
do_quad_points (nx.BoolParameter) – Whether the distance of each Cell to a quadruple point between Features is calculated
do_triple_lines (nx.BoolParameter) – Whether the distance of each Cell to a triple line between Features is calculated
feature_ids_path (nx.ArraySelectionParameter) – Specifies to which Feature each cell belongs
g_bdistances_array_name (nx.DataObjectNameParameter) – The name of the array with the distance the cells are from the boundary of the Feature they belong to.
input_image_geometry_path (nx.GeometrySelectionParameter) – The target geometry
nearest_neighbors_array_name (nx.DataObjectNameParameter) – The name of the array with the indices of the closest cell that touches a boundary, triple and quadruple point for each cell.
q_pdistances_array_name (nx.DataObjectNameParameter) – The name of the array with the distance the cells are from a quadruple point of Features.
save_nearest_neighbors (nx.BoolParameter) – Whether to store the nearest neighbors of Cell
t_jdistances_array_name (nx.DataObjectNameParameter) – The name of the array with the distance the cells are from a triple junction of Features.
- Returns:
Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.
- Return type:
Compute Feature Centroids
- class simplnx.ComputeFeatureCentroidsFilter
This Filter calculates the centroid of each Feature by determining the average X, Y, and Z position of all the Cells belonging to the Feature. Note that Features that intersect the outer surfaces of the sample will still have centroids calculated, but they will be centroids of the truncated part of the Feature that lies inside the sample.
Link to the full online documentation for ComputeFeatureCentroidsFilter
Mapping of UI display to python named argument
UI Display
Python Named Argument
Centroids
centroids_array_name
Feature Attribute Matrix
feature_attribute_matrix_path
Cell Feature Ids
feature_ids_path
Selected Image Geometry
input_image_geometry_path
- Execute(data_structure, centroids_array_name, feature_attribute_matrix_path, feature_ids_path, input_image_geometry_path)
- Parameters:
data_structure (DataStructure) – The DataStructure object that holds the data to be processed.
centroids_array_name (nx.DataObjectNameParameter) – DataPath to create the ‘Centroids’ output array
feature_attribute_matrix_path (nx.AttributeMatrixSelectionParameter) – The cell feature attribute matrix
feature_ids_path (nx.ArraySelectionParameter) – Specifies to which Feature each cell belongs
input_image_geometry_path (nx.GeometrySelectionParameter) – The target geometry whose Features’ centroids will be calculated
- Returns:
Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.
- Return type:
Compute Feature Clustering
- class simplnx.ComputeFeatureClusteringFilter
This Filter determines the radial distribution function (RDF), as a histogram, of a given set of Features. Currently, the Features need to be of the same Ensemble (specified by the user), and the resulting RDF is stored as Ensemble data. This Filter also returns the clustering list (the list of all the inter-Feature distances) and the minimum and maximum separation distances. The algorithm proceeds as follows:
Link to the full online documentation for ComputeFeatureClusteringFilter
Mapping of UI display to python named argument
UI Display
Python Named Argument
Biased Features
biased_features_array_path
Cell Ensemble Attribute Matrix
cell_ensemble_attribute_matrix_path
Centroids
centroids_array_path
Clustering List
clustering_list_array_name
Phases
feature_phases_array_path
Selected Image Geometry
input_image_geometry_path
Max and Min Separation Distances
max_min_array_name
Number of Bins for RDF
number_of_bins
Phase Index
phase_number
Radial Distribution Function
rdf_array_name
Remove Biased Features
remove_biased_features
Stored Seed Value Array Name
seed_array_name
Seed Value
seed_value
Set Random Seed
set_random_seed
- Execute(data_structure, biased_features_array_path, cell_ensemble_attribute_matrix_path, centroids_array_path, clustering_list_array_name, feature_phases_array_path, input_image_geometry_path, max_min_array_name, number_of_bins, phase_number, rdf_array_name, remove_biased_features, seed_array_name, seed_value, set_random_seed)
- Parameters:
data_structure (DataStructure) – The DataStructure object that holds the data to be processed.
biased_features_array_path (nx.ArraySelectionParameter) – Specifies which features are biased and therefor should be removed if the Remove Biased Features option is on; True values removed
cell_ensemble_attribute_matrix_path (nx.AttributeMatrixSelectionParameter) – The path to the cell ensemble attribute matrix where the RDF and RDF min and max distance arrays will be stored
centroids_array_path (nx.ArraySelectionParameter) – X, Y, Z coordinates of Feature center of mass
clustering_list_array_name (nx.DataObjectNameParameter) – Distance of each Feature’s centroid to every other Feature’s centroid
feature_phases_array_path (nx.ArraySelectionParameter) – Specifies to which Ensemble each Feature belongs
input_image_geometry_path (nx.GeometrySelectionParameter) – The target geometry
max_min_array_name (nx.DataObjectNameParameter) – The max and min distance found between Features
number_of_bins (nx.Int32Parameter) – Number of bins to split the RDF
phase_number (nx.Int32Parameter) – Ensemble number for which to calculate the RDF and clustering list
rdf_array_name (nx.DataObjectNameParameter) – A histogram of the normalized frequency at each bin
remove_biased_features (nx.BoolParameter) – Remove the biased features
seed_array_name (nx.DataObjectNameParameter) – Name of array holding the seed value
seed_value (nx.UInt64Parameter) – The seed value used to randomly generate the points in the RDF
set_random_seed (nx.BoolParameter) – When checked, allows the user to set the seed value used to randomly generate the points in the RDF
- Returns:
Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.
- Return type:
Compute Feature Neighbors
- class simplnx.ComputeFeatureNeighborsFilter
This Filter determines, for each Feature, the number of other Features that are in contact with it. The algorithm for determining the number of “contiguous” neighbors of each Feature is as follows:
Link to the full online documentation for ComputeFeatureNeighborsFilter
Mapping of UI display to python named argument
UI Display
Python Named Argument
Boundary Cells
boundary_cells_name
Feature Attribute Matrix
cell_feature_array_path
Cell Feature Ids
feature_ids_path
Image Geometry
input_image_geometry_path
Neighbor List
neighbor_list_name
Number of Neighbors
number_of_neighbors_name
Shared Surface Area List
shared_surface_area_list_name
Store Boundary Cells Array
store_boundary_cells
Store Surface Features Array
store_surface_features
Surface Features
surface_features_name
- Execute(data_structure, boundary_cells_name, cell_feature_array_path, feature_ids_path, input_image_geometry_path, neighbor_list_name, number_of_neighbors_name, shared_surface_area_list_name, store_boundary_cells, store_surface_features, surface_features_name)
- Parameters:
data_structure (DataStructure) – The DataStructure object that holds the data to be processed.
boundary_cells_name (nx.DataObjectNameParameter) – The number of neighboring Cells of a given Cell that belong to a different Feature than itself. Values will range from 0 to 6. Only created if Store Boundary Cells Array is checked
cell_feature_array_path (nx.AttributeMatrixSelectionParameter) – Feature Attribute Matrix of the selected Feature Ids
feature_ids_path (nx.ArraySelectionParameter) – Specifies to which Feature each cell belongs
input_image_geometry_path (nx.GeometrySelectionParameter) – The geometry in which to identify feature neighbors
neighbor_list_name (nx.DataObjectNameParameter) – List of the contiguous neighboring Features for a given Feature
number_of_neighbors_name (nx.DataObjectNameParameter) – Number of contiguous neighboring Features for a given Feature
shared_surface_area_list_name (nx.DataObjectNameParameter) – List of the shared surface area for each of the contiguous neighboring Features for a given Feature
store_boundary_cells (nx.BoolParameter) – Whether to store the boundary Cells array
store_surface_features (nx.BoolParameter) – Whether to store the surface Features array
surface_features_name (nx.DataObjectNameParameter) – The name of the surface features data array. Flag equal to 1 if the Feature touches an outer surface of the sample and equal to 0 if it does not. Only created if Store Surface Features Array is checked
- Returns:
Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.
- Return type:
Compute Feature Phases Binary
- class simplnx.ComputeFeaturePhasesBinaryFilter
This Filter assigns an Ensemble Id number to binary data. The true Cells will be Ensemble 1, and false Cells will be Ensemble 0. This Filter is generally useful when the Cell Ensembles were not known ahead of time. For example, if an image is segmented into precipitates and non-precipitates, this Filter will assign the precipitates to Ensemble 1, and the non-precipitates to Ensemble 0.
Link to the full online documentation for ComputeFeaturePhasesBinaryFilter
Mapping of UI display to python named argument
UI Display
Python Named Argument
Cell Data Attribute Matrix
cell_data_attribute_matrix_path
Cell Feature Ids
feature_ids_array_path
Binary Feature Phases Array Name
feature_phases_array_name
Mask Array
mask_array_path
- Execute(data_structure, cell_data_attribute_matrix_path, feature_ids_array_path, feature_phases_array_name, mask_array_path)
- Parameters:
data_structure (DataStructure) – The DataStructure object that holds the data to be processed.
cell_data_attribute_matrix_path (nx.AttributeMatrixSelectionParameter) – The Cell Data Attribute Matrix within the Image Geometry where the Binary Phases Array will be created
feature_ids_array_path (nx.ArraySelectionParameter) – Data Array that specifies to which Feature each Element belongs
feature_phases_array_name (nx.DataObjectNameParameter) – Created Data Array name to specify to which Ensemble each Feature belongs
mask_array_path (nx.ArraySelectionParameter) – Data Array that specifies if the Cell is to be counted in the algorithm
- Returns:
Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.
- Return type:
Compute Feature Phases
- class simplnx.ComputeFeaturePhasesFilter
This Filter determines the Ensemble of each Feature by querying the Ensemble of the Elements that belong to the Feature. Note that it is assumed that all Elements belonging to a Feature are of the same Feature, and thus any Element can be used to determine the Ensemble of the Feature that owns that Element.
Link to the full online documentation for ComputeFeaturePhasesFilter
Mapping of UI display to python named argument
UI Display
Python Named Argument
Feature Attribute Matrix
cell_features_attribute_matrix_path
Cell Phases
cell_phases_array_path
Cell Feature Ids
feature_ids_path
Feature Phases
feature_phases_array_name
- Execute(data_structure, cell_features_attribute_matrix_path, cell_phases_array_path, feature_ids_path, feature_phases_array_name)
- Parameters:
data_structure (DataStructure) – The DataStructure object that holds the data to be processed.
cell_features_attribute_matrix_path (nx.AttributeMatrixSelectionParameter) – The AttributeMatrix that stores the feature data for the input Feature Ids.
cell_phases_array_path (nx.ArraySelectionParameter) – Specifies to which Ensemble each Element belongs
feature_ids_path (nx.ArraySelectionParameter) – Specifies to which Feature each Element belongs
feature_phases_array_name (nx.DataObjectNameParameter) – The name of the feature attribute matrix in which to store the found feature phases array
- Returns:
Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.
- Return type:
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.AttributeMatrixSelectionParameter) – 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:
Compute Feature Sizes
- class simplnx.ComputeFeatureSizesFilter
This Filter calculates the sizes of all Features. The Filter simply iterates through all Elements querying for the Feature that owns them and keeping a tally for each Feature. The tally is then stored as NumElements and the Volume and EquivalentDiameter are also calculated (and stored) by knowing the volume of each Element.
Link to the full online documentation for ComputeFeatureSizesFilter
Mapping of UI display to python named argument
UI Display
Python Named Argument
Equivalent Diameters
equivalent_diameters_name
Feature Attribute Matrix
feature_attribute_matrix_path
Cell Feature Ids
feature_ids_path
Input Image Geometry
input_image_geometry_path
Number of Elements
num_elements_name
Generate Missing Element Sizes
save_element_sizes
Volumes
volumes_name
- Execute(data_structure, equivalent_diameters_name, feature_attribute_matrix_path, feature_ids_path, input_image_geometry_path, num_elements_name, save_element_sizes, volumes_name)
- Parameters:
data_structure (DataStructure) – The DataStructure object that holds the data to be processed.
equivalent_diameters_name (nx.DataObjectNameParameter) – DataPath to equivalent diameters array
feature_attribute_matrix_path (nx.AttributeMatrixSelectionParameter) – Feature Attribute Matrix of the selected Feature Ids
feature_ids_path (nx.ArraySelectionParameter) – Specifies to which Feature each Element belongs
input_image_geometry_path (nx.GeometrySelectionParameter) – DataPath to input Image Geometry
num_elements_name (nx.DataObjectNameParameter) – DataPath to Num Elements array
save_element_sizes (nx.BoolParameter) – If checked this will generate and store the element sizes ONLY if the geometry does not already contain them.
volumes_name (nx.DataObjectNameParameter) – DataPath to volumes array
- Returns:
Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.
- Return type:
Compute K Means
- class simplnx.ComputeKMeansFilter
*Warning:* The randomnes in this filter is not currently consistent between operating systems even if the same seed is used. Specifically between Unix and Windows. This does not affect the results, but the IDs will not correspond. For example if the Cluster Identifier at index one on Linux is 1 it could be 2 on Windows, the overarching clusters will be the same, but their IDs will be different.
Link to the full online documentation for ComputeKMeansFilter
Mapping of UI display to python named argument
UI Display
Python Named Argument
Distance Metric
distance_metric_index
Cluster Attribute Matrix
feature_attribute_matrix_path
Cluster Ids Array Name
feature_ids_array_name
Number of Clusters
init_clusters
Cell Mask Array
mask_array_path
Cluster Means Array Name
means_array_name
Stored Seed Value Array Name
seed_array_name
Seed Value
seed_value
Attribute Array to Cluster
selected_array_path
Use Mask Array
use_mask
Use Seed for Random Generation
use_seed
- Execute(data_structure, distance_metric_index, feature_attribute_matrix_path, feature_ids_array_name, init_clusters, mask_array_path, means_array_name, seed_array_name, seed_value, selected_array_path, use_mask, use_seed)
- Parameters:
data_structure (DataStructure) – The DataStructure object that holds the data to be processed.
distance_metric_index (nx.ChoicesParameter) – Distance Metric type to be used for calculations
feature_attribute_matrix_path (nx.DataGroupCreationParameter) – name and path of Attribute Matrix to hold Cluster Data
feature_ids_array_name (nx.DataObjectNameParameter) – name of the ids array to be created in Attribute Array to Cluster’s parent group
init_clusters (nx.UInt64Parameter) – This will be the tuple size for Cluster Attribute Matrix and the values within
mask_array_path (nx.ArraySelectionParameter) – DataPath to the boolean or uint8 mask array. Values that are true will mark that cell/point as usable.
means_array_name (nx.DataObjectNameParameter) – name of the Means array to be created in Cluster Attribute Matrix
seed_array_name (nx.DataObjectNameParameter) – Name of array holding the seed value
seed_value (nx.UInt64Parameter) – The seed fed into the random generator
selected_array_path (nx.ArraySelectionParameter) – The array to cluster from
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
- Returns:
Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.
- Return type:
Compute K Medoids
- class simplnx.ComputeKMedoidsFilter
*Warning:* The randomnes in this filter is not currently consistent between operating systems even if the same seed is used. Specifically between Unix and Windows. This does not affect the results, but the IDs will not correspond. For example if the Cluster Identifier at index one on Linux is 1 it could be 2 on Windows, the overarching clusters will be the same, but their IDs will be different.
Link to the full online documentation for ComputeKMedoidsFilter
Mapping of UI display to python named argument
UI Display
Python Named Argument
Distance Metric
distance_metric_index
Cluster Attribute Matrix
feature_attribute_matrix_path
Cluster Ids Array Name
feature_ids_array_name
Number of Clusters
init_clusters
Mask Array
mask_array_path
Cluster Medoids Array Name
medoids_array_name
Stored Seed Value Array Name
seed_array_name
Seed Value
seed_value
Attribute Array to Cluster
selected_array_path
Use Mask Array
use_mask
Use Seed for Random Generation
use_seed
- Execute(data_structure, distance_metric_index, feature_attribute_matrix_path, feature_ids_array_name, init_clusters, mask_array_path, medoids_array_name, seed_array_name, seed_value, selected_array_path, use_mask, use_seed)
- Parameters:
data_structure (DataStructure) – The DataStructure object that holds the data to be processed.
distance_metric_index (nx.ChoicesParameter) – Distance Metric type to be used for calculations
feature_attribute_matrix_path (nx.DataGroupCreationParameter) – name and path of Attribute Matrix to hold Cluster Data
feature_ids_array_name (nx.DataObjectNameParameter) – name of the ids array to be created in Attribute Array to Cluster’s parent group
init_clusters (nx.UInt64Parameter) – This will be the tuple size for Cluster Attribute Matrix and the values within
mask_array_path (nx.ArraySelectionParameter) – DataPath to the boolean or uint8 mask array. Values that are true will mark that cell/point as usable.
medoids_array_name (nx.DataObjectNameParameter) – name of the medoids array to be created in Cluster Attribute Matrix
seed_array_name (nx.DataObjectNameParameter) – Name of array holding the seed value
seed_value (nx.UInt64Parameter) – The seed fed into the random generator
selected_array_path (nx.ArraySelectionParameter) – The array to find the medoids for
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
- Returns:
Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.
- Return type:
Compute Feature Largest Cross-Section Areas
- class simplnx.ComputeLargestCrossSectionsFilter
This Filter calculates the largest cross-sectional area on a user-defined plane for all Features. The Filter simply iterates through all Cells (on each section) asking for Feature that owns them. On each section, the count of Cells for each Feature is then converted to an area and stored as the LargestCrossSection if the area for the current section is larger than the existing LargestCrossSection for that Feature.
Link to the full online documentation for ComputeLargestCrossSectionsFilter
Mapping of UI display to python named argument
UI Display
Python Named Argument
Feature Attribute Matrix
cell_feature_attribute_matrix_path
Cell Feature Ids
feature_ids_array_path
Image Geometry
input_image_geometry_path
Largest Cross Sections
largest_cross_sections_array_name
Plane of Interest
plane_index
- Execute(data_structure, cell_feature_attribute_matrix_path, feature_ids_array_path, input_image_geometry_path, largest_cross_sections_array_name, plane_index)
- Parameters:
data_structure (DataStructure) – The DataStructure object that holds the data to be processed.
cell_feature_attribute_matrix_path (nx.AttributeMatrixSelectionParameter) – The path to the cell feature attribute matrix
feature_ids_array_path (nx.ArraySelectionParameter) – Data Array that specifies to which Feature each Element belongs
input_image_geometry_path (nx.GeometrySelectionParameter) – The complete path to the input image geometry
largest_cross_sections_array_name (nx.DataObjectNameParameter) – Area of largest cross-section for Feature perpendicular to the user specified direction
plane_index (nx.ChoicesParameter) – Specifies which plane to consider when determining the maximum cross-section for each Feature
- Returns:
Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.
- Return type:
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:
data_structure (DataStructure) – The DataStructure object that holds the data to be processed.
central_moments_array_name (nx.DataObjectNameParameter) – Central Moments value
feature_attribute_matrix_path (nx.AttributeMatrixSelectionParameter) – The path to the cell feature attribute matrix where the created data arrays will be stored
feature_ids_array_path (nx.ArraySelectionParameter) – Data Array that specifies to which Feature each Element belongs
feature_rect_array_path (nx.ArraySelectionParameter) – Array holding the min xy and max xy pixel coordinates of each feature id
input_image_geometry_path (nx.GeometrySelectionParameter) – The path to the 2D image geometry to be used as input
normalize_moment_invariants (nx.BoolParameter) – Should the algorithm normalize the results to unit circle.
omega1_array_name (nx.DataObjectNameParameter) – Omega1 value
omega2_array_name (nx.DataObjectNameParameter) – Omega2 value
save_central_moments (nx.BoolParameter) – Write the Central Moments to a new Data Array
- Returns:
Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.
- Return type:
Compute Neighbor List Statistics
- class simplnx.ComputeNeighborListStatisticsFilter
This Filter computes the selected statistics for each list contained in a NeighborList container. Each of those statistics are reported back as new Attribute Arrays. The user selectable statistics are:
Link to the full online documentation for ComputeNeighborListStatisticsFilter
Mapping of UI display to python named argument
UI Display
Python Named Argument
Find Length
find_length
Find Maximum
find_maximum
Find Mean
find_mean
Find Median
find_median
Find Minimum
find_minimum
Find Standard Deviation
find_standard_deviation
Find Summation
find_summation
NeighborList to Compute Statistics
input_neighbor_list_path
Length
length_array_name
Maximum
maximum_array_name
Mean
mean_array_name
Median
median_array_name
Minimum
minimum_array_name
Standard Deviation
standard_deviation_array_name
Summation
summation_array_name
- Execute(data_structure, find_length, find_maximum, find_mean, find_median, find_minimum, find_standard_deviation, find_summation, input_neighbor_list_path, length_array_name, maximum_array_name, mean_array_name, median_array_name, minimum_array_name, standard_deviation_array_name, summation_array_name)
- Parameters:
data_structure (DataStructure) – The DataStructure object that holds the data to be processed.
find_length (nx.BoolParameter) – Specifies whether or not the filter creates the Length array during calculations
find_maximum (nx.BoolParameter) – Specifies whether or not the filter creates the Maximum array during calculations
find_mean (nx.BoolParameter) – Specifies whether or not the filter creates the Mean array during calculations
find_median (nx.BoolParameter) – Specifies whether or not the filter creates the Median array during calculations
find_minimum (nx.BoolParameter) – Specifies whether or not the filter creates the Minimum array during calculations
find_standard_deviation (nx.BoolParameter) – Specifies whether or not the filter creates the Standard Deviation array during calculations
find_summation (nx.BoolParameter) – Specifies whether or not the filter creates the Summation array during calculations
input_neighbor_list_path (nx.NeighborListSelectionParameter) – Input Data Array to compute statistics
length_array_name (nx.DataObjectNameParameter) – Path to create the Length array during calculations
maximum_array_name (nx.DataObjectNameParameter) – Path to create the Maximum array during calculations
mean_array_name (nx.DataObjectNameParameter) – Path to create the Mean array during calculations
median_array_name (nx.DataObjectNameParameter) – Path to create the Median array during calculations
minimum_array_name (nx.DataObjectNameParameter) – Path to create the Minimum array during calculations
standard_deviation_array_name (nx.DataObjectNameParameter) – Path to create the Standard Deviation array during calculations
summation_array_name (nx.DataObjectNameParameter) – Path to create the Summation array during calculations
- Returns:
Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.
- Return type:
Compute Feature Neighborhoods
- class simplnx.ComputeNeighborhoodsFilter
This Filter determines the number of Features, for each Feature, whose centroids lie within a distance equal to a user defined multiple of the average Equivalent Sphere Diameter (average of all **Features*). The algorithm for determining the number of Features is given below:
Link to the full online documentation for ComputeNeighborhoodsFilter
Mapping of UI display to python named argument
UI Display
Python Named Argument
Centroids
centroids_array_path
Equivalent Diameters
equivalent_diameters_array_path
Phases
feature_phases_array_path
Selected Image Geometry
input_image_geometry_path
Multiples of Average Diameter
multiples_of_average
Neighborhood List
neighborhood_list_array_name
Neighborhoods
neighborhoods_array_name
- Execute(data_structure, centroids_array_path, equivalent_diameters_array_path, feature_phases_array_path, input_image_geometry_path, multiples_of_average, neighborhood_list_array_name, neighborhoods_array_name)
- Parameters:
data_structure (DataStructure) – The DataStructure object that holds the data to be processed.
centroids_array_path (nx.ArraySelectionParameter) – Path to the array specifying the X, Y, Z coordinates of Feature center of mass
equivalent_diameters_array_path (nx.ArraySelectionParameter) – Path to the array specifying the diameter of a sphere with the same volume as the Feature
feature_phases_array_path (nx.ArraySelectionParameter) – Path to the array specifying to which Ensemble each Feature belongs
input_image_geometry_path (nx.GeometrySelectionParameter) – The target geometry
multiples_of_average (nx.Float32Parameter) – Defines the search radius to use when looking for ‘neighboring’ Features
neighborhood_list_array_name (nx.DataObjectNameParameter) – List of the Features whose centroids are within the user specified multiple of equivalent sphere diameter from each Feature
neighborhoods_array_name (nx.DataObjectNameParameter) – Number of Features that have their centroid within the user specified multiple of equivalent sphere diameters from each Feature
- Returns:
Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.
- Return type:
Compute Number of Features
- class simplnx.ComputeNumFeaturesFilter
This Filter determines the number of Features in each Ensemble by summing the total number of rows in the feature attribute matrix belonging to each phase.
Link to the full online documentation for ComputeNumFeaturesFilter
Mapping of UI display to python named argument
UI Display
Python Named Argument
Ensemble Attribute Matrix
ensemble_attribute_matrix_path
Feature Phases
feature_phases_array_path
Number of Features
num_features_array_name
- Execute(data_structure, ensemble_attribute_matrix_path, feature_phases_array_path, num_features_array_name)
- Parameters:
data_structure (DataStructure) – The DataStructure object that holds the data to be processed.
ensemble_attribute_matrix_path (nx.AttributeMatrixSelectionParameter) – 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:
Compute Surface Area to Volume & Sphericity
- class simplnx.ComputeSurfaceAreaToVolumeFilter
This Filter calculates the ratio of surface area to volume for each Feature in an Image Geometry.
Link to the full online documentation for ComputeSurfaceAreaToVolumeFilter
Mapping of UI display to python named argument
UI Display
Python Named Argument
Calculate Sphericity
calculate_sphericity
Cell Feature Ids
feature_ids_path
Selected Image Geometry
input_image_geometry_path
Number of Cells
num_cells_array_path
Sphericity Array Name
sphericity_array_name
Surface Area to Volume Ratio
surface_area_volume_ratio_array_name
- Execute(data_structure, calculate_sphericity, feature_ids_path, input_image_geometry_path, num_cells_array_path, sphericity_array_name, surface_area_volume_ratio_array_name)
- Parameters:
data_structure (DataStructure) – The DataStructure object that holds the data to be processed.
calculate_sphericity (nx.BoolParameter) – Whether or not to calculate the sphericity of each Feature
feature_ids_path (nx.ArraySelectionParameter) – Specifies to which Feature each cell belongs
input_image_geometry_path (nx.GeometrySelectionParameter) – The target geometry
num_cells_array_path (nx.ArraySelectionParameter) – Number of Cells that are owned by the Feature. This value does not place any distinction between Cells that may be of a different size
sphericity_array_name (nx.DataObjectNameParameter) – The sphericity of each feature
surface_area_volume_ratio_array_name (nx.DataObjectNameParameter) – Ratio of surface area to volume for each Feature. The units are inverse length
- Returns:
Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.
- Return type:
Compute Surface Features
- class simplnx.ComputeSurfaceFeaturesFilter
This Filter determines whether a Feature touches an outer surface of the sample. This is accomplished by simply querying the Feature owners of the Cells that sit at either . Any Feature that owns one of those Cells is said to touch an outer surface and all other Features are said to not touch an outer surface of the sample.
Link to the full online documentation for ComputeSurfaceFeaturesFilter
Mapping of UI display to python named argument
UI Display
Python Named Argument
Feature Attribute Matrix
feature_attribute_matrix_path
Cell Feature Ids
feature_ids_path
Feature Geometry
input_image_geometry_path
Mark Feature 0 Neighbors
mark_feature_0_neighbors
Surface Features
surface_features_array_name
- Execute(data_structure, feature_attribute_matrix_path, feature_ids_path, input_image_geometry_path, mark_feature_0_neighbors, surface_features_array_name)
- Parameters:
data_structure (DataStructure) – The DataStructure object that holds the data to be processed.
feature_attribute_matrix_path (nx.AttributeMatrixSelectionParameter) – The path to the cell feature attribute matrix associated with the input feature ids array
feature_ids_path (nx.ArraySelectionParameter) – Specifies to which Feature each cell belongs
input_image_geometry_path (nx.GeometrySelectionParameter) – The geometry in which to find surface features
mark_feature_0_neighbors (nx.BoolParameter) – Marks features that are neighbors with feature 0. If this option is off, only features that reside on the edge of the geometry will be marked.
surface_features_array_name (nx.DataObjectNameParameter) – The created surface features array. Flag of 1 if Feature touches an outer surface or of 0 if it does not
- Returns:
Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.
- Return type:
Compute Triangle Areas
- class simplnx.ComputeTriangleAreasFilter
This Filter computes the area of each Triangle in a Triangle Geometry by calculating the following:
Link to the full online documentation for ComputeTriangleAreasFilter
Mapping of UI display to python named argument
UI Display
Python Named Argument
Triangle Geometry
input_triangle_geometry_path
Created Face Areas
triangle_areas_array_name
- Execute(data_structure, input_triangle_geometry_path, triangle_areas_array_name)
- Parameters:
data_structure (DataStructure) – The DataStructure object that holds the data to be processed.
input_triangle_geometry_path (nx.GeometrySelectionParameter) – The complete path to the Geometry for which to calculate the face areas
triangle_areas_array_name (nx.DataObjectNameParameter) – The complete path to the array storing the calculated face areas
- Returns:
Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.
- Return type:
Compute Feature Centroids from Triangle Geometry
- class simplnx.ComputeTriangleGeomCentroidsFilter
This Filter determines the centroids of each Feature in a Triangle Geometry. The centroids are determinedusing the following algorithm:
Link to the full online documentation for ComputeTriangleGeomCentroidsFilter
Mapping of UI display to python named argument
UI Display
Python Named Argument
Calculated Centroids
centroids_array_name
Face Labels
face_labels_array_path
Face Feature Attribute Matrix
feature_attribute_matrix_path
Triangle Geometry
input_triangle_geometry_path
- Execute(data_structure, centroids_array_name, face_labels_array_path, feature_attribute_matrix_path, input_triangle_geometry_path)
- Parameters:
data_structure (DataStructure) – The DataStructure object that holds the data to be processed.
centroids_array_name (nx.DataObjectNameParameter) – Centroid values created in the Face Feature Data
face_labels_array_path (nx.ArraySelectionParameter) – The DataPath to the FaceLabels values.
feature_attribute_matrix_path (nx.AttributeMatrixSelectionParameter) – The DataPath to the AttributeMatrix that holds feature data for the faces
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:
Compute Feature Volumes from Triangle Geometry
- class simplnx.ComputeTriangleGeomVolumesFilter
This Filter computes the enclosed volume of each Feature in a Triangle Geometry. The result is the volume ofeach surface meshed Feature, or alternatively the volume of each unique polyhedron defined by the given _FaceLabels_ array. The volume of any generic polyhedron can be computed using the following algorithm:
Link to the full online documentation for ComputeTriangleGeomVolumesFilter
Mapping of UI display to python named argument
UI Display
Python Named Argument
Face Labels
face_labels_array_path
Face Feature Attribute Matrix
feature_attribute_matrix_path
Triangle Geometry
input_triangle_geometry_path
Calculated Volumes
volumes_array_name
- Execute(data_structure, face_labels_array_path, feature_attribute_matrix_path, input_triangle_geometry_path, volumes_array_name)
- Parameters:
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_attribute_matrix_path (nx.AttributeMatrixSelectionParameter) – The DataPath to the AttributeMatrix that holds feature data for the faces
input_triangle_geometry_path (nx.GeometrySelectionParameter) – The complete path to the Geometry for which to calculate the normals
volumes_array_name (nx.DataObjectNameParameter) – Calculated volumes data created in the Face Feature Data Attribute Matrix
- Returns:
Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.
- Return type:
Generate Vector Colors
- class simplnx.ComputeVectorColorsFilter
This Filter generates a color for each Element based on the vector assigned to that Element in the input vector data. The color scheme assigns a unique color to all points on the unit hemisphere using a HSV-like scheme. The color space is approximately represented by the following legend.
Link to the full online documentation for ComputeVectorColorsFilter
Mapping of UI display to python named argument
UI Display
Python Named Argument
Vector Colors
cell_vector_colors_array_name
Mask Array
mask_array_path
Apply to Good Voxels Only (Bad Voxels Will Be Black)
use_mask
Vector Attribute Array
vectors_array_path
- Execute(data_structure, cell_vector_colors_array_name, mask_array_path, use_mask, vectors_array_path)
- Parameters:
data_structure (DataStructure) – The DataStructure object that holds the data to be processed.
cell_vector_colors_array_name (nx.DataObjectNameParameter) – RGB colors
mask_array_path (nx.ArraySelectionParameter) – Used to define Elements as good or bad
use_mask (nx.BoolParameter) – Whether or not to assign colors to bad voxels or leave them black
vectors_array_path (nx.ArraySelectionParameter) – Vectors the colors will represent
- Returns:
Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.
- Return type:
Compute Vertex to Triangle Distances
- class simplnx.ComputeVertexToTriangleDistancesFilter
This Filter computes distances between points in a Vertex Geoemtry and triangles in a Triangle Geoemtry. Specifically, for each point in the Vertex Geometry, the Euclidean distance to the closest triangle in the Triangle Geoemtry is stored. This distance is signed: if the point lies on the side of the triangle to which the triangle normal points, then the distance is positive; otherwise, the distance is negative. Additionally, the ID the closest triangle is stored for each point.
Link to the full online documentation for ComputeVertexToTriangleDistancesFilter
Mapping of UI display to python named argument
UI Display
Python Named Argument
Closest Triangle Ids Array
closest_triangle_id_array_name
Distances Array
distances_array_name
Target Triangle Geometry
input_triangle_geometry_path
Source Vertex Geometry
input_vertex_geometry_path
Triangle Normals
triangle_normals_array_path
- Execute(data_structure, closest_triangle_id_array_name, distances_array_name, input_triangle_geometry_path, input_vertex_geometry_path, triangle_normals_array_path)
- Parameters:
data_structure (DataStructure) – The DataStructure object that holds the data to be processed.
closest_triangle_id_array_name (nx.DataObjectNameParameter) – The array to store the ID of the closest triangle
distances_array_name (nx.DataObjectNameParameter) – The array to store distance between vertex and triangle
input_triangle_geometry_path (nx.GeometrySelectionParameter) – The triangle geometry to compare against
input_vertex_geometry_path (nx.GeometrySelectionParameter) – The Vertex Geometry point cloud to map to triangles
triangle_normals_array_path (nx.ArraySelectionParameter) – The triangle geometry’s normals array
- Returns:
Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.
- Return type:
Compute Volume Fractions of Ensembles
- class simplnx.ComputeVolumeFractionsFilter
This Filter determines the volume fraction of each Ensemble. The Filter counts the number of Cells belonging to each Ensemble and stores the number fraction.
Link to the full online documentation for ComputeVolumeFractionsFilter
Mapping of UI display to python named argument
UI Display
Python Named Argument
Cell Ensemble Attribute Matrix
cell_ensemble_attribute_matrix_path
Cell Phases
cell_phases_array_path
Volume Fractions
vol_fractions_array_name
- Execute(data_structure, cell_ensemble_attribute_matrix_path, cell_phases_array_path, vol_fractions_array_name)
- Parameters:
data_structure (DataStructure) – The DataStructure object that holds the data to be processed.
cell_ensemble_attribute_matrix_path (nx.AttributeMatrixSelectionParameter) – 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:
Concatenate Data Arrays
- class simplnx.ConcatenateDataArraysFilter
This Filter concatenates multiple input arrays by taking a list of input arrays and appending their data sequentially into a single output array. The concatenation process involves combining the arrays such that the order of the input arrays directly affects the structure of the output. For example, if the first input array contains 5 tuples and the second contains 7 tuples, the resulting output array will have 12 tuples, with the tuples from the second array appended directly after those from the first array.
Link to the full online documentation for ConcatenateDataArraysFilter
Mapping of UI display to python named argument
UI Display
Python Named Argument
Arrays To Concatenate
input_arrays
Output Array
output_array_path
- Execute(data_structure, input_arrays, output_array_path)
- Parameters:
data_structure (DataStructure) – The DataStructure object that holds the data to be processed.
input_arrays (nx.MultiArraySelectionParameter) – Select the arrays that will be concatenated together. The arrays will be concatenated in the order they are listed here.
output_array_path (nx.ArrayCreationParameter) – The output array that contains the concatenated arrays.
- Returns:
Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.
- Return type:
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:
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:
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:
data_structure (DataStructure) – The DataStructure object that holds the data to be processed.
array_to_convert_path (nx.ArraySelectionParameter) – The complete path to the Data Array to Convert
converted_array_name (nx.DataObjectNameParameter) – The name of the converted Data Array
delete_original_array (nx.BoolParameter) – Whether or not to remove the original array after conversion
scalar_type_index (nx.ChoicesParameter) – Convert to this data type
- Returns:
Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.
- Return type:
Copy Data Object
- class simplnx.CopyDataObjectFilter
This Filter deep copies one or more DataObjects.
Link to the full online documentation for CopyDataObjectFilter
Mapping of UI display to python named argument
UI Display
Python Named Argument
Objects to copy
existing_data_path
New Parent Destination
new_data_path
Copied Object(s) Suffix
new_path_suffix
Copy to New Parent
use_new_parent
- Execute(data_structure, existing_data_path, new_data_path, new_path_suffix, use_new_parent)
- Parameters:
data_structure (DataStructure) – The DataStructure object that holds the data to be processed.
existing_data_path (nx.MultiPathSelectionParameter) – A list of DataPaths to the DataObjects to be copied
new_data_path (nx.DataGroupSelectionParameter) – DataPath to parent Group in which to store the copied DataObject(s)
new_path_suffix (nx.StringParameter) – Suffix string to be appended to each copied DataObject. Can be blank.
use_new_parent (nx.BoolParameter) – Copy all the DataObjects to a different Group
- Returns:
Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.
- Return type:
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:
Create AM Scan Paths
- class simplnx.CreateAMScanPathsFilter
Given an input Edge Geometry, stripe width, hatch spacing, laser power, and scan speed, this Filter will generate an Edge Geometry representing the additive manufacturing scan paths along with arrays containing times for each scan path node and powers, region ids, and slice ids for each scan path. The “SliceTriangleGeometry” filter is typically used before this filter to generate the proper edge geometry.
Link to the full online documentation for CreateAMScanPathsFilter
Mapping of UI display to python named argument
UI Display
Python Named Argument
Region Ids
cad_region_ids_array_path
Slice Data Container
cad_slice_data_container_path
Slice Ids
cad_slice_ids_array_path
Edge Attribute Matrix
hatch_attribute_matrix_name
Scan Vector Geometry
hatch_data_container_path
Hatch Length
hatch_length
Hatch Spacing
hatch_spacing
Region Ids
region_ids_array_name
Hatch Rotation Angle (Degrees)
rotation_angle
Vertex Attribute Matrix
vertex_attribute_matrix_name
- Execute(data_structure, cad_region_ids_array_path, cad_slice_data_container_path, cad_slice_ids_array_path, hatch_attribute_matrix_name, hatch_data_container_path, hatch_length, hatch_spacing, region_ids_array_name, rotation_angle, vertex_attribute_matrix_name)
- Parameters:
data_structure (DataStructure) – The DataStructure object that holds the data to be processed.
cad_region_ids_array_path (nx.ArraySelectionParameter) – Identifies the region to which each edge belongs
cad_slice_data_container_path (nx.GeometrySelectionParameter) – The input edge geometry from which to create the scan paths
cad_slice_ids_array_path (nx.ArraySelectionParameter) – Identifies the slice to which each edge belongs
hatch_attribute_matrix_name (nx.DataObjectNameParameter) – The name of the attribute matrix containing the scan path’s Edge data
hatch_data_container_path (nx.DataGroupCreationParameter) – The created edge geometry representing the scan paths
hatch_length (nx.Float32Parameter) – The length of each vector that is created.
hatch_spacing (nx.Float32Parameter) – The orthogonal distance between each generated vector.
region_ids_array_name (nx.DataObjectNameParameter) – The name of the array identifying the region to which each scan path belongs
rotation_angle (nx.Float32Parameter) – The angle in degrees by which each slice’s hatches are rotated
vertex_attribute_matrix_name (nx.DataObjectNameParameter) – The name of the attribute matrix containing the scan paths’ vertex data
- Returns:
Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.
- Return type:
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:
data_structure (DataStructure) – The DataStructure object that holds the data to be processed.
data_object_path (nx.DataGroupCreationParameter) – The complete path to the Attribute Matrix being created
tuple_dimensions (nx.DynamicTableParameter) – Slowest to Fastest Dimensions
- Returns:
Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.
- Return type:
Create Color Map
- class simplnx.CreateColorMapFilter
This Filter generates a color table array for a given 1-component input array. Each element of the input arrayis normalized and converted to a color based on where the value falls in the spectrum of the selected color preset.
Link to the full online documentation for CreateColorMapFilter
Mapping of UI display to python named argument
UI Display
Python Named Argument
Data Array
input_data_array_path
Masked Color (RGB)
invalid_color_value
Mask Array
mask_array_path
Output RGB Array
output_rgb_array_name
Select Preset…
selected_preset
Use Mask Array
use_mask
- Execute(data_structure, input_data_array_path, invalid_color_value, mask_array_path, output_rgb_array_name, selected_preset, use_mask)
- Parameters:
data_structure (DataStructure) – The DataStructure object that holds the data to be processed.
input_data_array_path (nx.ArraySelectionParameter) – The complete path to the data array from which to create the rgb array by applying the selected preset color scheme
invalid_color_value (nx.VectorUInt8Parameter) – The color to assign to voxels that have a mask value of FALSE
mask_array_path (nx.ArraySelectionParameter) – Path to the data array used to define Elements as good or bad.
output_rgb_array_name (nx.DataObjectNameParameter) – The rgb array created by normalizing each element of the input array and converting to a color based on the selected preset color scheme
selected_preset (nx.CreateColorMapParameter) – Select a preset color scheme to apply to the created array
use_mask (nx.BoolParameter) – Whether to assign a black color to ‘bad’ Elements
- Returns:
Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.
- Return type:
Create Data Array (Advanced)
- class simplnx.CreateDataArrayAdvancedFilter
This Filter creates a Data Array of any primitive type with any set of component dimensions. The array is initialized to a user defined value or with random values within a specified range.
Link to the full online documentation for CreateDataArrayAdvancedFilter
Mapping of UI display to python named argument
UI Display
Python Named Argument
Data Array Component Dimensions (Slowest to Fastest Dimensions)
component_dimensions
Data Format
data_format
Initialization End Range [Seperated with ;]
init_end_range
Initialization Start Range [Seperated with ;]
init_start_range
Initialization Type
init_type_index
Fill Values [Seperated with ;]
init_value
Output Numeric Type
numeric_type_index
Created Array
output_array_path
Stored Seed Value Array Name
seed_array_name
Seed Value
seed_value
Set Tuple Dimensions [not required if creating inside an existing Attribute Matrix]
set_tuple_dimensions
Use the Same Seed for Each Component
standardize_seed
Starting Value [Seperated with ;]
starting_fill_value
Step Operation
step_operation_index
Step Value [Seperated with ;]
step_value
Data Array Tuple Dimensions (Slowest to Fastest Dimensions)
tuple_dimensions
Use Seed for Random Generation
use_seed
- Execute(data_structure, component_dimensions, data_format, init_end_range, init_start_range, init_type_index, init_value, numeric_type_index, output_array_path, seed_array_name, seed_value, set_tuple_dimensions, standardize_seed, starting_fill_value, step_operation_index, step_value, tuple_dimensions, use_seed)
- Parameters:
data_structure (DataStructure) – The DataStructure object that holds the data to be processed.
component_dimensions (nx.DynamicTableParameter) – Slowest to Fastest Component Dimensions.
data_format (nx.DataStoreFormatParameter) – This value will specify which data format is used by the array’s data store. An empty string results in in-memory data store.
init_end_range (nx.StringParameter) – [Inclusive] The upper bound initialization range for random values
init_start_range (nx.StringParameter) – [Inclusive] The lower bound initialization range for random values
init_type_index (nx.ChoicesParameter) – Method for determining the what values of the data in the array should be initialized to
init_value (nx.StringParameter) – Specify values for each component. Ex: A 3-component array would be 6;8;12 and every tuple would have these same component values
numeric_type_index (nx.NumericTypeParameter) – Numeric Type of data to create
output_array_path (nx.ArrayCreationParameter) – Array storing the data
seed_array_name (nx.DataObjectNameParameter) – Name of the array holding the seed value
seed_value (nx.UInt64Parameter) – The seed fed into the random generator
set_tuple_dimensions (nx.BoolParameter) – This allows the user to set the tuple dimensions directly rather than just inheriting them. This option is NOT required if you are creating the Data Array in an Attribute Matrix
standardize_seed (nx.BoolParameter) – When true the same seed will be used for each component’s generator in a multi-component array
starting_fill_value (nx.StringParameter) – The value to start incrementing from. Ex: 6;8;12 would increment a 3-component array starting at 6 for the first component, 8 for the 2nd, and 12 for the 3rd.
step_operation_index (nx.ChoicesParameter) – The type of step operation to perform
step_value (nx.StringParameter) – The number to add/subtract the fill value by
tuple_dimensions (nx.DynamicTableParameter) – Slowest to Fastest Dimensions. Note this might be opposite displayed by an image geometry.
use_seed (nx.BoolParameter) – When true, the Seed Value will be used to seed the generator
- Returns:
Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.
- Return type:
Create Data Array
- class simplnx.CreateDataArrayFilter
This Filter creates an Data Array of any primitive type with any number of components along a single component dimension. For example, a scalar as (1) or a 3-vector as (3), but not a matrix as (3, 3). The array is initialized to a user define value or with random values within a specified range.
Link to the full online documentation for CreateDataArrayFilter
Mapping of UI display to python named argument
UI Display
Python Named Argument
Total Number of Components
component_count
Data Format
data_format
Initialization Value
initialization_value_str
Output Numeric Type
numeric_type_index
Created Array
output_array_path
Set Tuple Dimensions [not required if creating inside an Attribute Matrix]
set_tuple_dimensions
Data Array Dimensions (Slowest to Fastest Dimensions)
tuple_dimensions
- Execute(data_structure, component_count, data_format, initialization_value_str, numeric_type_index, output_array_path, set_tuple_dimensions, tuple_dimensions)
- Parameters:
data_structure (DataStructure) – The DataStructure object that holds the data to be processed.
component_count (nx.UInt64Parameter) – Total number of components. Do not set the component dimensions.
data_format (nx.DataStoreFormatParameter) – This value will specify which data format is used by the array’s data store. An empty string results in in-memory data store.
initialization_value_str (nx.StringParameter) – This value will be used to fill the new array
numeric_type_index (nx.NumericTypeParameter) – Numeric Type of data to create
output_array_path (nx.ArrayCreationParameter) – Array storing the data
set_tuple_dimensions (nx.BoolParameter) – This allows the user to set the tuple dimensions directly rather than just inheriting them. This option is NOT required if you are creating the Data Array in an Attribute Matrix
tuple_dimensions (nx.DynamicTableParameter) – Slowest to Fastest Dimensions. Note this might be opposite displayed by an image geometry.
- Returns:
Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.
- Return type:
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:
data_structure (DataStructure) – The DataStructure object that holds the data to be processed.
data_object_path (nx.DataGroupCreationParameter) – The complete path to the DataObject being created
- Returns:
Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.
- Return type:
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:
data_structure (DataStructure) – The DataStructure object that holds the data to be processed.
cell_feature_attribute_matrix_path (nx.AttributeMatrixSelectionParameter) – The path to the cell feature attribute matrix where the converted output feature array will be stored
created_array_name (nx.DataObjectNameParameter) – The path to the copied AttributeArray
feature_ids_path (nx.ArraySelectionParameter) – Specifies to which Feature each Element belongs
selected_cell_array_path (nx.ArraySelectionParameter) – Element Data to Copy to Feature Data
- Returns:
Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.
- Return type:
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:
data_structure (DataStructure) – The DataStructure object that holds the data to be processed.
array_handling_index (nx.ChoicesParameter) – Determines if the arrays that make up the geometry primitives should be Moved or Copied to the created Geometry object.
cell_attribute_matrix_name (nx.DataObjectNameParameter) – The name of the cell attribute matrix to be created with the geometry
dimensions (nx.VectorUInt64Parameter) – The number of cells in each of the X, Y, Z directions
edge_attribute_matrix_name (nx.DataObjectNameParameter) – The name of the edge attribute matrix to be created with the geometry
edge_list_path (nx.ArraySelectionParameter) – The complete path to the data array defining the edges for the geometry
face_attribute_matrix_name (nx.DataObjectNameParameter) – The name of the face attribute matrix to be created with the geometry
geometry_type_index (nx.ChoicesParameter) – The type of Geometry to create
hexahedral_list_path (nx.ArraySelectionParameter) – The complete path to the data array defining the hexahedral elements for the geometry
length_unit_index (nx.ChoicesParameter) – The length unit to be used in the geometry
origin (nx.VectorFloat32Parameter) – The origin of each of the axes in X, Y, Z order
output_geometry_path (nx.DataGroupCreationParameter) – The complete path to the geometry to be created
quadrilateral_list_path (nx.ArraySelectionParameter) – The complete path to the data array defining the (quad) faces for the geometry
spacing (nx.VectorFloat32Parameter) – The length scale of each voxel/pixel
tetrahedral_list_path (nx.ArraySelectionParameter) – The complete path to the data array defining the tetrahedral elements for the geometry
triangle_list_path (nx.ArraySelectionParameter) – The complete path to the data array defining the (triangular) faces for the geometry
vertex_attribute_matrix_name (nx.DataObjectNameParameter) – The name of the vertex attribute matrix to be created with the geometry
vertex_list_path (nx.ArraySelectionParameter) – The complete path to the data array defining the point coordinates for the geometry
warnings_as_errors (nx.BoolParameter) – Whether run time warnings for Geometries should be treated as errors
x_bounds_path (nx.ArraySelectionParameter) – The spatial locations of the planes along the x direction
y_bounds_path (nx.ArraySelectionParameter) – The spatial locations of the planes along the y direction
z_bounds_path (nx.ArraySelectionParameter) – The spatial locations of the planes along the z direction
- Returns:
Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.
- Return type:
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:
data_structure (DataStructure) – The DataStructure object that holds the data to be processed.
cell_data_name (nx.DataObjectNameParameter) – The name of the cell Attribute Matrix to be created
dimensions (nx.VectorUInt64Parameter) – The number of cells in each of the X, Y, Z directions
origin (nx.VectorFloat32Parameter) – The origin of each of the axes in X, Y, Z order
output_image_geometry_path (nx.DataGroupCreationParameter) – The complete path to the Geometry being created
spacing (nx.VectorFloat32Parameter) – The length scale of each voxel/pixel
- Returns:
Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.
- Return type:
Create Python Plugin and/or Filters
- class simplnx.CreatePythonSkeletonFilter
The Generate Python Plugin and/or Filters is a powerful tool in the DREAM3D-NX environment that allows users to generate or update Python plugins and filter codes. This filter provides an interface for setting up and configuring Python filters within DREAM3D-NX pipelines, either by creating new plugins or by adding to existing ones.
Link to the full online documentation for CreatePythonSkeletonFilter
Mapping of UI display to python named argument
UI Display
Python Named Argument
Filter Names (comma-separated)
filter_names
Human Name of Plugin
plugin_human_name
Existing Plugin Location
plugin_input_directory
Name of Plugin
plugin_name
Plugin Output Directory
plugin_output_directory
Use Existing Plugin
use_existing_plugin
- Execute(data_structure, filter_names, plugin_human_name, plugin_input_directory, plugin_name, plugin_output_directory, use_existing_plugin)
- Parameters:
data_structure (DataStructure) – The DataStructure object that holds the data to be processed.
filter_names (nx.StringParameter) – The names of filters that will be created, separated by commas (,).
plugin_human_name (nx.StringParameter) – This is the user facing name of the plugin.
plugin_input_directory (nx.FileSystemPathParameter) – The location of the existing plugin’s top level directory on the file system.
plugin_name (nx.StringParameter) – This is the name of the plugin.
plugin_output_directory (nx.FileSystemPathParameter) – The path to the output directory where the new plugin will be generated.
use_existing_plugin (nx.BoolParameter) – Generate the list of filters into an existing plugin instead of creating a new plugin.
- Returns:
Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.
- Return type:
Crop Geometry (Edge)
- class simplnx.CropEdgeGeometryFilter
The Crop Geometry (Edge) Filter allows users to crop a region of interest (ROI) from an Edge Geometry. This filter is essential for isolating specific portions of edge-based data structures.
Link to the full online documentation for CropEdgeGeometryFilter
Mapping of UI display to python named argument
UI Display
Python Named Argument
Boundary Intersection Behavior
boundary_intersection_behavior_index
Crop X Dimension
crop_x_dim
Crop Y Dimension
crop_y_dim
Crop Z Dimension
crop_z_dim
Selected Edge Geometry
input_image_geometry_path
Max Coordinate [Inclusive]
max_coord
Min Coordinate
min_coord
Created Edge Geometry
output_image_geometry_path
Perform In Place
remove_original_geometry
- Execute(data_structure, boundary_intersection_behavior_index, crop_x_dim, crop_y_dim, crop_z_dim, input_image_geometry_path, max_coord, min_coord, output_image_geometry_path, remove_original_geometry)
- Parameters:
data_structure (DataStructure) – The DataStructure object that holds the data to be processed.
boundary_intersection_behavior_index (nx.ChoicesParameter) – The behavior to implement if an edge intersects a bound (one vertex is inside, one vertex is outside).
“Interpolate Outside Vertex” will move the outside vertex of a boundary-intersecting edge from its current position to the boundary edge. “Ignore Edge” will ignore any edge that intersects a bound. “Filter Error” will make this filter throw an error when it encounters an edge that intersects a bound.
- param nx.BoolParameter crop_x_dim:
Enable cropping in the X dimension.
- param nx.BoolParameter crop_y_dim:
Enable cropping in the Y dimension.
- param nx.BoolParameter crop_z_dim:
Enable cropping in the Z dimension.
- param nx.GeometrySelectionParameter input_image_geometry_path:
DataPath to the source Edge Geometry
- param nx.VectorFloat32Parameter max_coord:
Upper bound of the edge geometry to crop.
- param nx.VectorFloat32Parameter min_coord:
Lower bound of the edge geometry to crop.
- param nx.DataGroupCreationParameter output_image_geometry_path:
The DataPath to store the created Edge Geometry
- param nx.BoolParameter remove_original_geometry:
Replaces the original Edge Geometry after filter is completed
- return:
Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.
- rtype:
Crop Geometry (Image)
- class simplnx.CropImageGeometryFilter
This Filter allows the user to crop a region of interest (ROI) from an Image Geometry. The input parameters are in units of voxels or physical coordinates.
Link to the full online documentation for CropImageGeometryFilter
Mapping of UI display to python named argument
UI Display
Python Named Argument
Feature Attribute Matrix
cell_feature_attribute_matrix_path
Crop X Dimension
crop_x_dim
Crop Y Dimension
crop_y_dim
Crop Z Dimension
crop_z_dim
Feature IDs
feature_ids_path
Selected Image Geometry
input_image_geometry_path
Max Coordinate (Physical Units) [Inclusive]
max_coord
Max Voxel [Inclusive]
max_voxel
Min Coordinate (Physical Units)
min_coord
Min Voxel
min_voxel
Created Image Geometry
output_image_geometry_path
Perform In Place
remove_original_geometry
Renumber Features
renumber_features
Use Physical Units For Bounds
use_physical_bounds
- Execute(data_structure, cell_feature_attribute_matrix_path, crop_x_dim, crop_y_dim, crop_z_dim, feature_ids_path, input_image_geometry_path, max_coord, max_voxel, min_coord, min_voxel, output_image_geometry_path, remove_original_geometry, renumber_features, use_physical_bounds)
- Parameters:
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
crop_x_dim (nx.BoolParameter) – Enable cropping in the X dimension.
crop_y_dim (nx.BoolParameter) – Enable cropping in the Y dimension.
crop_z_dim (nx.BoolParameter) – Enable cropping in the Z dimension.
feature_ids_path (nx.ArraySelectionParameter) – DataPath to Cell Feature IDs array
input_image_geometry_path (nx.GeometrySelectionParameter) – DataPath to the source Image Geometry
max_coord (nx.VectorFloat64Parameter) – Upper bound in real units of the volume to crop.
max_voxel (nx.VectorUInt64Parameter) – Upper bound in voxels of the volume to crop out
min_coord (nx.VectorFloat64Parameter) – Lower bound in real units of the volume to crop.
min_voxel (nx.VectorUInt64Parameter) – Lower bound of voxels of the volume to crop out
output_image_geometry_path (nx.DataGroupCreationParameter) – The DataPath to store the created Image 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
use_physical_bounds (nx.BoolParameter) – If true define physical coordinates for bounds, If false define voxel indices for bounds
- Returns:
Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.
- Return type:
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:
data_structure (DataStructure) – The DataStructure object that holds the data to be processed.
input_vertex_geometry_path (nx.GeometrySelectionParameter) – DataPath to target VertexGeom
max_pos (nx.VectorFloat32Parameter) – Maximum vertex position
min_pos (nx.VectorFloat32Parameter) – Minimum vertex position
output_vertex_geometry_path (nx.DataGroupCreationParameter) – Created VertexGeom path
target_array_paths (nx.MultiArraySelectionParameter) – The complete path to all the vertex data arrays to crop
vertex_attribute_matrix_name (nx.DataObjectNameParameter) – Name of the vertex data AttributeMatrix
- Returns:
Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.
- Return type:
DBSCAN
- class simplnx.DBSCANFilter
This Filter applies the DBSCAN (density-based spatial clustering of applications with noise) algorithm to an Attribute Array. DBSCAN is a clustering algorithm that assigns to each point of the Attribute Array a cluster Id; points that have the same cluster Id are grouped together more densely (in the sense that the _distance_ between them is small) in the data space (i.e., points that have many nearest neighbors will belong to the same cluster). The user may select from a number of options to use as the distance metric. Points that are in sparse regions of the data space are considered “outliers”; these points will belong to cluster Id 0. Additionally, the user may opt to use a mask to ignore certain points; where the mask is false, the points will be categorized as outliers and placed in cluster 0. The algorithm requires two parameters: a neighborbood region, called epsilon; and the minimum number of points needed to form a cluster. The algorithm, in pseudocode, proceeds as follows:
Link to the full online documentation for DBSCANFilter
Mapping of UI display to python named argument
UI Display
Python Named Argument
Distance Metric
distance_metric_index
Epsilon
epsilon
Cluster Attribute Matrix
feature_attribute_matrix_path
Cluster Ids Array Name
feature_ids_array_name
Initialization Type
init_type_index
Cell Mask Array
mask_array_path
Minimum Points
min_points
Stored Seed Value Array Name
seed_array_name
Seed Value
seed_value
Attribute Array to Cluster
selected_array_path
Use Mask Array
use_mask
Use Precaching
use_precaching
- Execute(data_structure, distance_metric_index, epsilon, feature_attribute_matrix_path, feature_ids_array_name, init_type_index, mask_array_path, min_points, seed_array_name, seed_value, selected_array_path, use_mask, use_precaching)
- Parameters:
data_structure (DataStructure) – The DataStructure object that holds the data to be processed.
distance_metric_index (nx.ChoicesParameter) – Distance Metric type to be used for calculations
epsilon (nx.Float32Parameter) – The epsilon-neighborhood around each point is queried
feature_attribute_matrix_path (nx.DataGroupCreationParameter) – The complete path to the attribute matrix in which to store to hold Cluster Data
feature_ids_array_name (nx.DataObjectNameParameter) – Name of the ids array to be created in Attribute Array to Cluster’s parent group
init_type_index (nx.ChoicesParameter) – Whether to use random or iterative for start state. See Documentation for further detail
mask_array_path (nx.ArraySelectionParameter) – DataPath to the boolean or uint8 mask array. Values that are true will mark that cell/point as usable.
min_points (nx.Int32Parameter) – The minimum number of points needed to form a ‘dense region’ (i.e., the minimum number of points needed to be called a cluster)
seed_array_name (nx.DataObjectNameParameter) – Name of array holding the seed value
seed_value (nx.UInt64Parameter) – The seed fed into the random generator
selected_array_path (nx.ArraySelectionParameter) – The data array to cluster
use_mask (nx.BoolParameter) – Specifies whether or not to use a mask array
use_precaching (nx.BoolParameter) – If true the algorithm will be significantly faster, but it requires more memory
- Returns:
Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.
- Return type:
Delete Data
- class simplnx.DeleteDataFilter
This Filter allows the user to remove specified objects from the existing structure. This can be helpful if the user has operations that need as much memory as possible and there are extra objects that are not needed residing in memory. Alternatively, this Filter allows the user to remove objects that may share a name with another object further in the Pipeline that another Filter tries to create, since DREAM3D-NX generally does not allows objects at the same hierarchy to share the same name.
Link to the full online documentation for DeleteDataFilter
Mapping of UI display to python named argument
UI Display
Python Named Argument
DataPaths to remove
removed_data_path
- Execute(data_structure, removed_data_path)
- Parameters:
data_structure (DataStructure) – The DataStructure object that holds the data to be processed.
removed_data_path (nx.MultiPathSelectionParameter) – The complete path to the DataObjects to be removed
- Returns:
Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.
- Return type:
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:
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
ignored_data_array_paths (nx.MultiArraySelectionParameter) – The list of arrays to ignore when performing the algorithm
input_image_geometry_path (nx.GeometrySelectionParameter) – The target geometry
num_iterations (nx.Int32Parameter) – The number of iterations to use for erosion/dilation
operation_index (nx.ChoicesParameter) – Whether to dilate or erode
x_dir_on (nx.BoolParameter) – Whether to erode/dilate in the X direction
y_dir_on (nx.BoolParameter) – Whether to erode/dilate in the Y direction
z_dir_on (nx.BoolParameter) – Whether to erode/dilate in the Z direction
- Returns:
Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.
- Return type:
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:
data_structure (DataStructure) – The DataStructure object that holds the data to be processed.
coordination_number (nx.Int32Parameter) – Number of neighboring Cells that can be of opposite classification before a Cell will be removed
feature_ids_path (nx.ArraySelectionParameter) – Specifies to which Feature each Cell belongs
ignored_data_array_paths (nx.MultiArraySelectionParameter) – The list of arrays to ignore when performing the algorithm
input_image_geometry_path (nx.GeometrySelectionParameter) – The target geometry
loop (nx.BoolParameter) – Keep looping until all criteria is met
- Returns:
Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.
- Return type:
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:
data_structure (DataStructure) – The DataStructure object that holds the data to be processed.
input_image_geometry_path (nx.GeometrySelectionParameter) – The target geometry
mask_array_path (nx.ArraySelectionParameter) – Boolean array where true voxels are used. False voxels are ignored.
num_iterations (nx.Int32Parameter) – Number of erode/dilate iterations to perform
operation_index (nx.ChoicesParameter) – Whether to dilate (0) or erode (1)
x_dir_on (nx.BoolParameter) – Whether to erode/dilate in the X direction
y_dir_on (nx.BoolParameter) – Whether to erode/dilate in the Y direction
z_dir_on (nx.BoolParameter) – Whether to erode/dilate in the Z direction
- Returns:
Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.
- Return type:
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:
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:
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:
data_structure (DataStructure) – The DataStructure object that holds the data to be processed.
copy_triangle_array_paths (nx.MultiArraySelectionParameter) – Paths to face-related DataArrays that should be copied to the new geometry
copy_vertex_array_paths (nx.MultiArraySelectionParameter) – Paths to vertex-related DataArrays that should be copied to the new geometry
input_triangle_geometry_path (nx.GeometrySelectionParameter) – Path to the existing Triangle Geometry
node_type_range (nx.VectorInt8Parameter) – The min and max (inclusive) Node Type values that distinguish an internal surface from an external surface
node_types_path (nx.ArraySelectionParameter) – Path to the Node Types array
output_triangle_geometry_path (nx.DataGroupCreationParameter) – Path to create the new Triangle Geometry
triangle_attribute_matrix_name (nx.DataObjectNameParameter) – Created face data AttributeMatrix name
vertex_attribute_matrix_name (nx.DataObjectNameParameter) – Created vertex data AttributeMatrix name
- Returns:
Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.
- Return type:
Extract DREAM3D-NX Pipeline To File
- class simplnx.ExtractPipelineToFileFilter
This Filter reads the pipeline from an hdf5 file with the .dream3d extension and writes it back out to a json formatted pipeline file with the appropriate extension based on whether the pipeline is a DREAM3D-NX version 6 (.json) or DREAM3D-NX version 7 (.d3dpipeline) formatted pipeline.
Link to the full online documentation for ExtractPipelineToFileFilter
Mapping of UI display to python named argument
UI Display
Python Named Argument
Input DREAM3D File Path
input_file_path
Output File Path
output_file_path
- Execute(data_structure, input_file_path, output_file_path)
- Parameters:
data_structure (DataStructure) – The DataStructure object that holds the data to be processed.
input_file_path (nx.FileSystemPathParameter) – The file path to the .dream3d that holds the pipeline to be extracted.
output_file_path (nx.FileSystemPathParameter) – The file path in which to save the extracted pipeline
- Returns:
Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.
- Return type:
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:
data_structure (DataStructure) – The DataStructure object that holds the data to be processed.
array_handling_index (nx.ChoicesParameter) – [0] Move or [1] Copy input data arrays
included_data_array_paths (nx.MultiArraySelectionParameter) – The arrays to copy/move to the vertex array
input_grid_geometry_path (nx.GeometrySelectionParameter) – The input Image/RectilinearGrid Geometry to convert
mask_array_path (nx.ArraySelectionParameter) – DataPath to the boolean mask array. Values that are true will mark that cell/point as usable.
output_shared_vertex_list_name (nx.DataObjectNameParameter) – The name of the shared vertex list that will be created
output_vertex_attr_matrix_name (nx.DataObjectNameParameter) – The name of the vertex attribute matrix that will be created
output_vertex_geometry_path (nx.DataGroupCreationParameter) – The complete path to the vertex geometry that will be created
use_mask (nx.BoolParameter) – Specifies whether or not to use a mask array
- Returns:
Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.
- Return type:
Compute Feature Face Curvature
- class simplnx.FeatureFaceCurvatureFilter
This Filter calculates principal direction vectors and the principal curvatures, and optionally the mean and Gaussian curvature, for each Triangle in a Triangle Geometry using the technique in [1]. The groups of Triangles over which to compute the curvatures is determines by the Features they are associated, denoted by their Face Labels. The curvature information will be stored in a Face Attribute Matrix.
Link to the full online documentation for FeatureFaceCurvatureFilter
Mapping of UI display to python named argument
UI Display
Python Named Argument
Compute Gaussian Curvature
compute_gaussian_curvature
Compute Mean Curvature
compute_mean_curvature_path
Compute Principal Direction Vectors
compute_principal_direction
Compute Weingarten Matrix
compute_weingarten_matrix
Face Attribute Matrix
face_attribute_matrix_path
Face Centroids
face_centroids_path
Face Labels
face_labels_path
Face Normals
face_normals_path
Feature Face Ids
feature_face_ids_path
Gaussian Curvature
gaussian_curvature_path
Triangle Geometry
input_triangle_geometry_path
Mean Curvature
mean_curvature_path
Neighborhood Ring Count
neighborhood_ring
Principal Curvature 1
principal_curvature_1_path
Principal Curvature 2
principal_curvature_2_path
Principal Direction 1
principal_direction_1_path
Principal Direction 2
principal_direction_2_path
Use Face Normals for Curve Fitting
use_normals
Weingarten Matrix
weingarten_matrix_path
- Execute(data_structure, compute_gaussian_curvature, compute_mean_curvature_path, compute_principal_direction, compute_weingarten_matrix, face_attribute_matrix_path, face_centroids_path, face_labels_path, face_normals_path, feature_face_ids_path, gaussian_curvature_path, input_triangle_geometry_path, mean_curvature_path, neighborhood_ring, principal_curvature_1_path, principal_curvature_2_path, principal_direction_1_path, principal_direction_2_path, use_normals, weingarten_matrix_path)
- Parameters:
data_structure (DataStructure) – The DataStructure object that holds the data to be processed.
compute_gaussian_curvature (nx.BoolParameter) – Compute the Gaussian Curvature values
compute_mean_curvature_path (nx.BoolParameter) – Compute the Mean Curvature values
compute_principal_direction (nx.BoolParameter) – Compute the Principal Direction Vectors
compute_weingarten_matrix (nx.BoolParameter) – Compute the Weingarten Matrix values
face_attribute_matrix_path (nx.AttributeMatrixSelectionParameter) – The AttributeMatrix that holds the triangle face data.
face_centroids_path (nx.ArraySelectionParameter) – The DataPath to the ‘Face Centroids’ DataArray
face_labels_path (nx.ArraySelectionParameter) – The DataPath to the ‘Face Labels’ DataArray
face_normals_path (nx.ArraySelectionParameter) – The DataPath to the ‘Feature Normals’ DataArray
feature_face_ids_path (nx.ArraySelectionParameter) – The DataPath to the ‘FeatureIds’ DataArray
gaussian_curvature_path (nx.ArrayCreationParameter) – Output DataPath to hold the ‘Gaussian Curvature’ values
input_triangle_geometry_path (nx.GeometrySelectionParameter) – The input Triangle Geometry to compute the curvature values
mean_curvature_path (nx.ArrayCreationParameter) – Output DataPath to hold the ‘Mean Curvature’ values
neighborhood_ring (nx.Int32Parameter) – The number of ring neighbors to use
principal_curvature_1_path (nx.ArrayCreationParameter) – Output DataPath to hold the ‘Principal Curvature 1’ values
principal_curvature_2_path (nx.ArrayCreationParameter) – Output DataPath to hold the ‘Principal Curvature 2’ values
principal_direction_1_path (nx.ArrayCreationParameter) – Output DataPath to hold the ‘Principal Direction 1’ values
principal_direction_2_path (nx.ArrayCreationParameter) – Output DataPath to hold the ‘Principal Direction 2’ values
use_normals (nx.BoolParameter) – Use the face normals for curve fitting.
weingarten_matrix_path (nx.ArrayCreationParameter) – Output DataPath to hold the ‘Weingarten Matrix’ values
- Returns:
Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.
- Return type:
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:
data_structure (DataStructure) – The DataStructure object that holds the data to be processed.
cell_phases_array_path (nx.ArraySelectionParameter) – Specifies to which Ensemble each Cell belongs.
feature_ids_path (nx.ArraySelectionParameter) – Specifies to which Feature each Element belongs
ignored_data_array_paths (nx.MultiArraySelectionParameter) – The list of arrays to ignore when performing the algorithm
input_image_geometry_path (nx.GeometrySelectionParameter) – The target geometry
min_allowed_defect_size (nx.Int32Parameter) – The size at which a group of bad Cells are left unfilled as a ‘defect’
store_as_new_phase (nx.BoolParameter) – Whether to change the phase of ‘defect’ larger than the minimum allowed size above
- Returns:
Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.
- Return type:
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:
data_structure (DataStructure) – The DataStructure object that holds the data to be processed.
contour_value (nx.Float64Parameter) – The value to contour on
input_data_array_path (nx.ArraySelectionParameter) – This is the data that will be checked for the contouring iso value
input_image_geometry_path (nx.GeometrySelectionParameter) – The target geometry
output_triangle_geometry_path (nx.DataGroupCreationParameter) – This is where the contouring line will be stored
- Returns:
Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.
- Return type:
Isolate Largest Feature (Identify Sample)
- class simplnx.IdentifySampleFilter
Often when performing a serial sectioning experiment (especially in the FIB-SEM), the sample is overscanned resulting in a border of bad data around the sample. This Filter attempts to identify the sample within the overscanned volume. The Filter makes the assumption that there is only one contiguous set of Cells that belong to the sample. The Filter requires that the user has already thresheld the data to determine which Cells are good and which are bad. The algorithm for the identification of the sample is then as follows:
Link to the full online documentation for IdentifySampleFilter
Mapping of UI display to python named argument
UI Display
Python Named Argument
Fill Holes in Largest Feature
fill_holes
Image Geometry
input_image_geometry_path
Mask Array
mask_array_path
Process Data Slice-By-Slice
slice_by_slice
Slice-By-Slice Plane
slice_by_slice_plane_index
- Execute(data_structure, fill_holes, input_image_geometry_path, mask_array_path, slice_by_slice, slice_by_slice_plane_index)
- Parameters:
data_structure (DataStructure) – The DataStructure object that holds the data to be processed.
fill_holes (nx.BoolParameter) – Whether to fill holes within sample after it is identified
input_image_geometry_path (nx.GeometrySelectionParameter) – DataPath to the target ImageGeom
mask_array_path (nx.ArraySelectionParameter) – DataPath to the mask array defining what is sample and what is not
slice_by_slice (nx.BoolParameter) – Whether to identify the largest sample (and optionally fill holes) slice-by-slice. This option is useful if you have a sample that is not water-tight and the holes open up to the overscan section, or if you have holes that sit on a boundary. The original algorithm will not fill holes that have these characteristics, only holes that are completely enclosed by the sample and water-tight. If you have holes that are not water-tight or sit on a boundary, choose this option and then pick the plane that will allow the holes to be water-tight on each slice of that plane.
slice_by_slice_plane_index (nx.ChoicesParameter) – Set the plane that the data will be processed slice-by-slice. For example, if you pick the XY plane, the data will be processed in the Z direction.
- Returns:
Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.
- Return type:
Initialize Data
- class simplnx.InitializeDataFilter
This Filter allows the user to define the data set in a _DataArray_.
Link to the full online documentation for InitializeDataFilter
Mapping of UI display to python named argument
UI Display
Python Named Argument
Any Component Array
array_path
Initialization End Range [Seperated with ;]
init_end_range
Initialization Start Range [Seperated with ;]
init_start_range
Initialization Type
init_type_index
Fill Values [Seperated with ;]
init_value
Stored Seed Value Array Name
seed_array_name
Seed Value
seed_value
Use the Same Seed for Each Component
standardize_seed
Starting Value [Seperated with ;]
starting_fill_value
Step Operation
step_operation_index
Step Value [Seperated with ;]
step_value
Use Seed for Random Generation
use_seed
- Execute(data_structure, array_path, init_end_range, init_start_range, init_type_index, init_value, seed_array_name, seed_value, standardize_seed, starting_fill_value, step_operation_index, step_value, use_seed)
- Parameters:
data_structure (DataStructure) – The DataStructure object that holds the data to be processed.
array_path (nx.ArraySelectionParameter) – The data array in which to initialize the data
init_end_range (nx.StringParameter) – [Inclusive] The upper bound initialization range for random values
init_start_range (nx.StringParameter) – [Inclusive] The lower bound initialization range for random values
init_type_index (nx.ChoicesParameter) – Method for determining the what values of the data in the array should be initialized to
init_value (nx.StringParameter) – Specify values for each component. Ex: A 3-component array would be 6;8;12 and every tuple would have these same component values
seed_array_name (nx.DataObjectNameParameter) – Name of array holding the seed value
seed_value (nx.UInt64Parameter) – The seed fed into the random generator
standardize_seed (nx.BoolParameter) – When true the same seed will be used for each component’s generator in a multi-component array
starting_fill_value (nx.StringParameter) – The value to start incrementing from
step_operation_index (nx.ChoicesParameter) – The type of step operation to preform
step_value (nx.StringParameter) – The number to add/subtract the fill value by
use_seed (nx.BoolParameter) – When true the Seed Value will be used to seed the generator
- Returns:
Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.
- Return type:
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:
data_structure (DataStructure) – The DataStructure object that holds the data to be processed.
cell_arrays (nx.MultiArraySelectionParameter) – The cell data arrays in which to initialize a sub-volume to zeros
init_range (nx.VectorFloat64Parameter) – The initialization range if Random With Range Initialization Type is selected
init_type_index (nx.ChoicesParameter) – Tells how to initialize the data
init_value (nx.Float64Parameter) – The initialization value if Manual Initialization Type is selected
input_image_geometry_path (nx.GeometrySelectionParameter) – The geometry containing the cell data for which to initialize
max_point (nx.VectorUInt64Parameter) – The maximum x, y, z bound in cells
min_point (nx.VectorUInt64Parameter) – The minimum x, y, z bound in cells
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:
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:
data_structure (DataStructure) – The DataStructure object that holds the data to be processed.
copy_arrays (nx.MultiArraySelectionParameter) – DataPaths to copy
gaussian_sigmas (nx.VectorFloat32Parameter) – Specifies the Gaussian sigmas
input_image_geometry_path (nx.GeometrySelectionParameter) – DataPath to interpolated geometry
input_mask_path (nx.ArraySelectionParameter) – DataPath to the boolean mask array. Values that are true will mark that cell/point as usable.
input_vertex_geometry_path (nx.GeometrySelectionParameter) – DataPath to geometry to interpolate
interpolate_arrays (nx.MultiArraySelectionParameter) – DataPaths to interpolate
interpolated_group_name (nx.DataObjectNameParameter) – DataPath to created DataGroup for interpolated data
interpolation_index (nx.ChoicesParameter) – Selected Interpolation Technique
kernel_distances_array_name (nx.DataObjectNameParameter) – DataPath to created DataGroup for kernel distances data
kernel_size (nx.VectorFloat32Parameter) – Specifies the kernel size
store_kernel_distances (nx.BoolParameter) – Specifies whether or not to store kernel distances
use_mask (nx.BoolParameter) – Specifies whether or not to use a mask array
voxel_indices_path (nx.ArraySelectionParameter) – DataPath to voxel indices
- Returns:
Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.
- Return type:
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:
data_structure (DataStructure) – The DataStructure object that holds the data to be processed.
apply_transformation (nx.BoolParameter) – If checked, geometry will be updated implicitly
input_moving_vertex_geometry_path (nx.GeometrySelectionParameter) – The geometry to align [mutable]
input_target_vertex_geometry_path (nx.GeometrySelectionParameter) – The geometry to be matched against [immutable]
num_iterations (nx.UInt64Parameter) – The number of times to run the algorithm [more increases accuracy]
transform_array_path (nx.ArrayCreationParameter) – This is the array to store the transform matrix in
- Returns:
Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.
- Return type:
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:
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:
Map Point Cloud to Regular Grid
- class simplnx.MapPointCloudToRegularGridFilter
This Filter determines, for a user-defined grid, in which voxel each point in a Vertex Geometry lies. The user can either construct a sampling grid by specifying the dimensions, or select a pre-existing Image Geometry to use as the sampling grid. The voxel indices that each point lies in are stored on the vertices.
Link to the full online documentation for MapPointCloudToRegularGridFilter
Mapping of UI display to python named argument
UI Display
Python Named Argument
Created Cell Data Name
cell_data_name
Grid Dimensions
grid_dimensions
Existing Image Geometry
input_image_geometry_path
Vertex Geometry
input_vertex_geometry_path
Mask
mask_path
Out of Bounds Handling
out_of_bounds_handling_index
Out of Bounds Value
out_of_bounds_value
Created Image Geometry
output_image_geometry_path
Sampling Grid Type
sampling_grid_index
Use Mask Array
use_mask
Created Voxel Indices
voxel_indices_name
- Execute(data_structure, cell_data_name, grid_dimensions, input_image_geometry_path, input_vertex_geometry_path, mask_path, out_of_bounds_handling_index, out_of_bounds_value, output_image_geometry_path, sampling_grid_index, use_mask, voxel_indices_name)
- Parameters:
data_structure (DataStructure) – The DataStructure object that holds the data to be processed.
cell_data_name (nx.DataObjectNameParameter) – The name of the cell data attribute matrix to be created within the created Image Geometry
grid_dimensions (nx.VectorInt32Parameter) – Target grid size
input_image_geometry_path (nx.GeometrySelectionParameter) – Path to the existing Image Geometry
input_vertex_geometry_path (nx.GeometrySelectionParameter) – Path to the target Vertex Geometry
mask_path (nx.ArraySelectionParameter) – DataPath to the boolean/uint8 mask array. Values that are true will mark that cell/point as usable.
out_of_bounds_handling_index (nx.ChoicesParameter) – Specifies how data outside the image bounds is handled, see documentation for specification
out_of_bounds_value (nx.UInt64Parameter) – The value to be put in voxel indices slots, occurs when the vertex geometry’s coordinate point falls outside the image geometry’s bounds
output_image_geometry_path (nx.DataGroupCreationParameter) – Path to create the Image Geometry
sampling_grid_index (nx.ChoicesParameter) – Specifies how data is saved or accessed
use_mask (nx.BoolParameter) – Specifies whether or not to use a mask array
voxel_indices_name (nx.DataObjectNameParameter) – Path to the created Voxel Indices array
- Returns:
Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.
- Return type:
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:
data_structure (DataStructure) – The DataStructure object that holds the data to be processed.
destination_parent_path (nx.DataGroupSelectionParameter) – The complete path to the parent data object to which the data will be moved
source_data_paths (nx.MultiPathSelectionParameter) – The complete paths to the data object(s) to be moved
- Returns:
Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.
- Return type:
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:
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.AttributeMatrixSelectionParameter) – The attribute matrix for the reference geometry
sampling_cell_attribute_matrix_path (nx.AttributeMatrixSelectionParameter) – 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:
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:
Point Sample Triangle Geometry
- class simplnx.PointSampleTriangleGeometryFilter
This Filter randomly samples point locations on Triangles in a Triangle Geometry. The sampled point locations are then used to construct a Vertex Geometry. The number of point samples may either be specified manually or by inferring from another Geometry:
Link to the full online documentation for PointSampleTriangleGeometryFilter
Mapping of UI display to python named argument
UI Display
Python Named Argument
Face Attribute Arrays to Transfer
input_data_array_paths
Triangle Geometry to Sample
input_triangle_geometry_path
Mask Array
mask_array_path
Number of Sample Points
number_of_samples
Vertex Geometry Name
output_vertex_geometry_path
Stored Seed Value Array Name
seed_array_name
Seed Value
seed_value
Face Areas
triangle_areas_array_path
Use Mask Array
use_mask
Use Seed for Random Generation
use_seed
Vertex Data
vertex_data_group_name
- Execute(data_structure, input_data_array_paths, input_triangle_geometry_path, mask_array_path, number_of_samples, output_vertex_geometry_path, seed_array_name, seed_value, triangle_areas_array_path, use_mask, use_seed, vertex_data_group_name)
- Parameters:
data_structure (DataStructure) – The DataStructure object that holds the data to be processed.
input_data_array_paths (nx.MultiArraySelectionParameter) – The paths to the Face Attribute Arrays to transfer to the created Vertex Geometry where the mask is false, if Use Mask is checked
input_triangle_geometry_path (nx.GeometrySelectionParameter) – The complete path to the triangle Geometry from which to sample
mask_array_path (nx.ArraySelectionParameter) – DataPath to the boolean mask array. Values that are true will mark that cell/point as usable.
number_of_samples (nx.Int32Parameter) – The number of sample points to use
output_vertex_geometry_path (nx.DataGroupCreationParameter) – The complete path to the DataGroup holding the Vertex Geometry that represents the sampling points
seed_array_name (nx.DataObjectNameParameter) – Name of array holding the seed value
seed_value (nx.UInt64Parameter) – The seed fed into the random generator
triangle_areas_array_path (nx.ArraySelectionParameter) – The complete path to the array specifying the area of each Face
use_mask (nx.BoolParameter) – Specifies whether or not to use a mask array
use_seed (nx.BoolParameter) – When true the user will be able to put in a seed for random generation
vertex_data_group_name (nx.DataObjectNameParameter) – The complete path to the vertex data arrays for the Vertex Geometry
- Returns:
Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.
- Return type:
Create Surface Mesh (QuickMesh)
- class simplnx.QuickSurfaceMeshFilter
This Filter generates a Triangle Geometry from a grid Geometry (either an Image Geometry or a RectGrid Geometry) that represents a surface mesh of the present Features. The algorithm proceeds by creating a pair of Triangles for each face of the Cell where the neighboring Cells have a different Feature Id value. The meshing operation is extremely quick but can result in a surface mesh that is very “stair stepped”. The user is encouraged to use a smoothing operation to reduce this “blockiness”.
Link to the full online documentation for QuickSurfaceMeshFilter
Mapping of UI display to python named argument
UI Display
Python Named Argument
Face Data [AttributeMatrix]
face_data_group_name
Face Feature Data [AttributeMatrix]
face_feature_attribute_matrix_name
Face Labels
face_labels_array_name
Cell Feature Ids
feature_ids_path
Attempt to Fix Problem Voxels
fix_problem_voxels
Generate Triple Lines
generate_triple_lines
Attribute Arrays to Transfer
input_data_array_paths
Grid Geometry
input_grid_geometry_path
Node Type
node_types_array_name
Created Triangle Geometry
output_triangle_geometry_path
Vertex Data [AttributeMatrix]
vertex_data_group_name
- Execute(data_structure, face_data_group_name, face_feature_attribute_matrix_name, face_labels_array_name, feature_ids_path, fix_problem_voxels, generate_triple_lines, input_data_array_paths, input_grid_geometry_path, node_types_array_name, output_triangle_geometry_path, vertex_data_group_name)
- Parameters:
data_structure (DataStructure) – The DataStructure object that holds the data to be processed.
face_data_group_name (nx.DataObjectNameParameter) – The complete path to the DataGroup where the Face Data of the Triangle Geometry will be created
face_feature_attribute_matrix_name (nx.DataObjectNameParameter) – The complete path to the DataGroup where the Feature Data will be stored.
face_labels_array_name (nx.DataObjectNameParameter) – The name of the Array specifying which Features are on either side of each Face in the Triangle Geometry
feature_ids_path (nx.ArraySelectionParameter) – The complete path to the Array specifying which Feature each Cell belongs to
fix_problem_voxels (nx.BoolParameter) – See help page.
generate_triple_lines (nx.BoolParameter) – Experimental feature. May not work.
input_data_array_paths (nx.MultiArraySelectionParameter) – The paths to the Arrays specifying which Cell Attribute Arrays to transfer to the created Triangle Geometry
input_grid_geometry_path (nx.GeometrySelectionParameter) – The complete path to the Grid Geometry from which to create a Triangle Geometry
node_types_array_name (nx.DataObjectNameParameter) – The name of the Array specifying the type of node in the Triangle Geometry
output_triangle_geometry_path (nx.DataGroupCreationParameter) – The name of the created Triangle Geometry
vertex_data_group_name (nx.DataObjectNameParameter) – The complete path to the DataGroup where the Vertex Data of the Triangle Geometry will be created
- Returns:
Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.
- Return type:
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:
data_structure (DataStructure) – The DataStructure object that holds the data to be processed.
cell_attribute_matrix_name (nx.DataObjectNameParameter) – The name used to create the Cell Attribute Matrix.
density_array_name (nx.DataObjectNameParameter) – The name used to create the Density data array.
end_voxel_coord (nx.VectorInt32Parameter) – The ending subvolume voxel (inclusive)
import_subvolume (nx.BoolParameter) – Import a subvolume instead of the entire volume
input_header_file (nx.FileSystemPathParameter) – The path to the .nsihdr file
input_image_geometry_path (nx.DataGroupCreationParameter) – The path that will be used to create the Image Geometry.
length_unit_index (nx.ChoicesParameter) – The length unit that will be set into the created image geometry
start_voxel_coord (nx.VectorInt32Parameter) – The starting subvolume voxel
- Returns:
Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.
- Return type:
Read CSV File
- class simplnx.ReadCSVFileFilter
This Filter reads text data from any text-based file and imports the data into DREAM3D-NX-style arrays. The user specifies which file to import, how the data is formatted, what to call each array, and what type each array should be.
Link to the full online documentation for ReadCSVFileFilter
Mapping of UI display to python named argument
UI Display
Python Named Argument
New Attribute Matrix
created_data_group_path
CSV Importer Data
read_csv_data_object
Existing Data Group or Attribute Matrix
selected_attribute_matrix_path
Use Existing Data Group or Attribute Matrix
use_existing_group
- Execute(data_structure, created_data_group_path, read_csv_data_object, selected_attribute_matrix_path, use_existing_group)
- Parameters:
data_structure (DataStructure) – The DataStructure object that holds the data to be processed.
created_data_group_path (nx.DataGroupCreationParameter) – Store the imported CSV data arrays in a newly created attribute matrix.
read_csv_data_object (nx.ReadCSVFileParameter) – Holds all relevant csv file data collected from the custom interface
selected_attribute_matrix_path (nx.DataGroupSelectionParameter) – Store the imported CSV data arrays in an existing data group or attribute matrix.
use_existing_group (nx.BoolParameter) – Store the imported CSV data arrays in an existing data group or attribute matrix.
- Returns:
Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.
- Return type:
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:
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:
data_structure (DataStructure) – The DataStructure object that holds the data to be processed.
cell_attribute_matrix_name (nx.DataObjectNameParameter) – The name of the created Attribute Matrix for cell data
input_file_path (nx.FileSystemPathParameter) – File path that points to the imported file
output_quad_geometry_path (nx.DataGroupCreationParameter) – The created Quad Geometry from imported from file
vertex_attribute_matrix_name (nx.DataObjectNameParameter) – The name of the created Attribute Matrix for vertex data
- Returns:
Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.
- Return type:
Read HDF5 Dataset
- class simplnx.ReadHDF5DatasetFilter
This Filter allows the user to import datasets from an HDF5 file and store them as attribute arrays in DREAM3D-NX. This filter supports importing datasets with any number of dimensions, as long as the created attribute array’s total number of components and the tuple count of the destination attribute matrix multiply together to match the HDF5 dataset’s total number of elements.
Link to the full online documentation for ReadHDF5DatasetFilter
Mapping of UI display to python named argument
UI Display
Python Named Argument
Select HDF5 File
import_hdf5_object
- Execute(data_structure, import_hdf5_object)
- Parameters:
data_structure (DataStructure) – The DataStructure object that holds the data to be processed.
import_hdf5_object (nx.ReadHDF5DatasetParameter) – The HDF5 file data to import
- Returns:
Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.
- Return type:
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:
data_structure (DataStructure) – The DataStructure object that holds the data to be processed.
created_attribute_array_path (nx.ArrayCreationParameter) – The complete path to the created Attribute Array
endian_index (nx.ChoicesParameter) – The endianness of the data
input_file (nx.FileSystemPathParameter) – The input binary file path
number_of_components (nx.UInt64Parameter) – The number of values at each tuple
scalar_type_index (nx.NumericTypeParameter) – Data type of the binary data
skip_header_bytes (nx.UInt64Parameter) – Number of bytes to skip before reading data
tuple_dimensions (nx.DynamicTableParameter) – Slowest to Fastest Dimensions (ZYX for example)
- Returns:
Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.
- Return type:
Read STL File
- class simplnx.ReadStlFileFilter
This Filter will read a binary STL File and create a Triangle Geometry object in memory. The STL reader is very strict to the STL specification. An explanation of the STL file format can be found on Wikipedia. The structure of the file is as follows:
Link to the full online documentation for ReadStlFileFilter
Mapping of UI display to python named argument
UI Display
Python Named Argument
Generate Triangle Face Labels
create_face_labels
Face Data [AttributeMatrix]
face_attribute_matrix_name
Created Face Labels Array
face_labels_name
Face Normals
face_normals_name
Created Triangle Geometry
output_triangle_geometry_path
Scale Factor
scale_factor
Scale Output Geometry
scale_output
STL File
stl_file_path
Vertex Data [AttributeMatrix]
vertex_attribute_matrix_name
- Execute(data_structure, create_face_labels, face_attribute_matrix_name, face_labels_name, face_normals_name, output_triangle_geometry_path, scale_factor, scale_output, stl_file_path, vertex_attribute_matrix_name)
- Parameters:
data_structure (DataStructure) – The DataStructure object that holds the data to be processed.
create_face_labels (nx.BoolParameter) – When true, the ‘Face Labels’ array will be created.
face_attribute_matrix_name (nx.DataObjectNameParameter) – The name of the AttributeMatrix where the Face Data of the Triangle Geometry will be created
face_labels_name (nx.DataObjectNameParameter) – The name of the ‘Face Labels’ data array
face_normals_name (nx.DataObjectNameParameter) – The name of the triangle normals data array
output_triangle_geometry_path (nx.DataGroupCreationParameter) – The name of the created Triangle Geometry
scale_factor (nx.Float32Parameter) – The factor by which to scale the geometry
scale_output (nx.BoolParameter) – Scale the output Triangle Geometry by the Scaling Factor
stl_file_path (nx.FileSystemPathParameter) – Input STL File
vertex_attribute_matrix_name (nx.DataObjectNameParameter) – The name of the AttributeMatrix 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:
Read String Data Array
- class simplnx.ReadStringDataArrayFilter
This Filter allows the user to import a plain text file containing the contents of a single Attribute Array. The delimeters can be one of the following:
Link to the full online documentation for ReadStringDataArrayFilter
Mapping of UI display to python named argument
UI Display
Python Named Argument
Data Format
data_format
Delimiter
delimiter_index
Input File
input_file
Data Array Dimensions (Slowest to Fastest Dimensions)
number_tuples
Created Array Path
output_data_array_path
Set Tuple Dimensions [not required if creating inside an Attribute Matrix]
set_tuple_dimensions
Skip Header Lines
skip_line_count
- Execute(data_structure, data_format, delimiter_index, input_file, number_tuples, output_data_array_path, set_tuple_dimensions, skip_line_count)
- Parameters:
data_structure (DataStructure) – The DataStructure object that holds the data to be processed.
data_format (nx.DataStoreFormatParameter) – This value will specify which data format is used by the array’s data store. An empty string results in in-memory data store.
delimiter_index (nx.ChoicesParameter) – Delimiter for values on a line
input_file (nx.FileSystemPathParameter) – File path that points to the imported file
number_tuples (nx.DynamicTableParameter) – Slowest to Fastest Dimensions. Note this might be opposite displayed by an image geometry.
output_data_array_path (nx.ArrayCreationParameter) – DataPath or Name for the underlying Data Array
set_tuple_dimensions (nx.BoolParameter) – This allows the user to set the tuple dimensions directly rather than just inheriting them. This option is NOT required if you are creating the Data Array in an Attribute Matrix
skip_line_count (nx.UInt64Parameter) – Number of lines at the start of the file to skip
- Returns:
Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.
- Return type:
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:
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:
data_structure (DataStructure) – The DataStructure object that holds the data to be processed.
cell_attribute_matrix_name (nx.DataObjectNameParameter) – The attribute matrix created as a child of the image geometry
density_array_name (nx.DataObjectNameParameter) – The data array created as a child of the attribute matrix
output_image_geometry_path (nx.DataGroupCreationParameter) – Path to create the Image Geometry
vg_header_file (nx.FileSystemPathParameter) – The input VolumeGraphics file
- Returns:
Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.
- Return type:
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:
data_structure (DataStructure) – The DataStructure object that holds the data to be processed.
cell_attribute_matrix_name (nx.DataObjectNameParameter) – The attribute matrix for the Cell Data.
input_file (nx.FileSystemPathParameter) – The path to the input file
output_image_geometry_path (nx.DataGroupCreationParameter) – The data container for the Cell Data.
output_vertex_geometry_path (nx.DataGroupCreationParameter) – The data container for the Point Data.
read_cell_data (nx.BoolParameter) – Determines whether or not the Cell Data will be read.
read_point_data (nx.BoolParameter) – Determines whether or not the Point Data will be read.
vertex_attribute_matrix_name (nx.DataObjectNameParameter) – The attribute matrix for the Point Data.
- Returns:
Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.
- Return type:
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:
data_structure (DataStructure) – The DataStructure object that holds the data to be processed.
cell_attribute_matrix_name (nx.DataObjectNameParameter) – The name for the cell data Attribute Matrix within the Image geometry
dimensions (nx.VectorUInt64Parameter) – The dimensions of the created Image geometry
feature_ids_array_name (nx.DataObjectNameParameter) – The name for the feature ids array in cell data Attribute Matrix
input_image_geometry_path (nx.DataGroupCreationParameter) – The name and path for the image geometry to be created
input_triangle_geometry_path (nx.GeometrySelectionParameter) – The geometry to be sampled onto grid
length_unit_index (nx.ChoicesParameter) – The units to be displayed below
origin (nx.VectorFloat32Parameter) – The origin of the created Image geometry
spacing (nx.VectorFloat32Parameter) – The spacing of the created Image geometry
surface_mesh_face_labels_array_path (nx.ArraySelectionParameter) – Array specifying which Features are on either side of each Face
- Returns:
Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.
- Return type:
Remove Flagged Edges
- class simplnx.RemoveFlaggedEdgesFilter
This Filter removes Edges from the supplied Edges Geometry that are flagged by a (boolean|uint8) mask array as true|1. A new reduced Edge Geometry is created that contains all the remaining Edges. It is unknown until run time how many Edges will be removed from the Geometry. Therefore, this Filter requires that a new EdgeGeom be created to contain the reduced Edge Geometry. This new Geometry will NOT contain copies of any Feature Attribute Matrix or Ensemble Attribute Matrix from the original Geometry. The mask is expected to be over the edges themselves so it should be based on something from the Edge Data Attribute Matrix.
Link to the full online documentation for RemoveFlaggedEdgesFilter
Mapping of UI display to python named argument
UI Display
Python Named Argument
Edge Data Handling
edge_data_handling_index
Edge Attribute Arrays to Copy
edge_data_selected_array_paths
Edge Data
edge_data_selected_attribute_matrix_path
Edge Geometry
input_edge_geometry_path
Mask
mask_array_path
Created Geometry
output_edge_geometry_path
Vertex Data Handling
vertex_data_handling_index
Vertex Attribute Arrays to Copy
vertex_data_selected_array_paths
Vertex Data
vertex_data_selected_attribute_matrix_path
- Execute(data_structure, edge_data_handling_index, edge_data_selected_array_paths, edge_data_selected_attribute_matrix_path, input_edge_geometry_path, mask_array_path, output_edge_geometry_path, vertex_data_handling_index, vertex_data_selected_array_paths, vertex_data_selected_attribute_matrix_path)
- Parameters:
data_structure (DataStructure) – The DataStructure object that holds the data to be processed.
edge_data_handling_index (nx.ChoicesParameter) – How to handle Data that resides on the edges
edge_data_selected_array_paths (nx.MultiArraySelectionParameter) – Edge DataPaths to copy
edge_data_selected_attribute_matrix_path (nx.AttributeMatrixSelectionParameter) – Edge Attribute Matrix that will be copied to the reduced geometry
input_edge_geometry_path (nx.GeometrySelectionParameter) – The Edge Geometry that will be processed.
mask_array_path (nx.ArraySelectionParameter) – The DataArrayPath to the mask array that marks each edge as either true (remove) or false(keep).
output_edge_geometry_path (nx.DataGroupCreationParameter) – The name of the created Edge Geometry
vertex_data_handling_index (nx.ChoicesParameter) – How to handle Data that resides on the edges
vertex_data_selected_array_paths (nx.MultiArraySelectionParameter) – Vertex DataPaths to copy
vertex_data_selected_attribute_matrix_path (nx.AttributeMatrixSelectionParameter) – Vertex Attribute Matrix that will be copied to the reduced geometry
- Returns:
Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.
- Return type:
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:
Remove Flagged Triangles
- class simplnx.RemoveFlaggedTrianglesFilter
This Filter removes Triangles from the supplied Triangle Geometry that are flagged by a boolean mask array as true. A new reduced Geometry is created that contains all the remaining Triangles. It is unknown until run time how many Triangles will be removed from the Geometry. Therefore, this Filter requires that a new TriangleGeom be created to contain the reduced Triangle Geometry. This new Geometry will NOT contain copies of any Feature Attribute Matrix or Ensemble Attribute Matrix from the original Geometry. The mask is expected to be over the triangles themselves so it should be based on something from the *Face Data* Attribute Matrix.
Link to the full online documentation for RemoveFlaggedTrianglesFilter
Mapping of UI display to python named argument
UI Display
Python Named Argument
Triangle Geometry
input_triangle_geometry_path
Mask
mask_array_path
Created Geometry
output_triangle_geometry_path
Triangle Data Handling
triangle_data_handling_index
Triangle Attribute Arrays to Copy
triangle_data_selected_array_paths
Triangle Data
triangle_data_selected_attribute_matrix_path
Vertex Data Handling
vertex_data_handling_index
Vertex Attribute Arrays to Copy
vertex_data_selected_array_paths
Vertex Data
vertex_data_selected_attribute_matrix_path
- Execute(data_structure, input_triangle_geometry_path, mask_array_path, output_triangle_geometry_path, triangle_data_handling_index, triangle_data_selected_array_paths, triangle_data_selected_attribute_matrix_path, vertex_data_handling_index, vertex_data_selected_array_paths, vertex_data_selected_attribute_matrix_path)
- Parameters:
data_structure (DataStructure) – The DataStructure object that holds the data to be processed.
input_triangle_geometry_path (nx.GeometrySelectionParameter) – The Triangle Geometry that will be processed.
mask_array_path (nx.ArraySelectionParameter) – The DataArrayPath to the mask array that marks each face as either true (remove) or false(keep).
output_triangle_geometry_path (nx.DataGroupCreationParameter) – The name of the created Triangle Geometry
triangle_data_handling_index (nx.ChoicesParameter) – How to handle Data that resides on the triangles
triangle_data_selected_array_paths (nx.MultiArraySelectionParameter) – Triangle DataPaths to copy
triangle_data_selected_attribute_matrix_path (nx.AttributeMatrixSelectionParameter) – Triangle Attribute Matrix that will be copied to the reduced geometry
vertex_data_handling_index (nx.ChoicesParameter) – How to handle Data that resides on the triangles
vertex_data_selected_array_paths (nx.MultiArraySelectionParameter) – Vertex DataPaths to copy
vertex_data_selected_attribute_matrix_path (nx.AttributeMatrixSelectionParameter) – Vertex Attribute Matrix that will be copied to the reduced geometry
- Returns:
Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.
- Return type:
Remove Flagged Vertices
- class simplnx.RemoveFlaggedVerticesFilter
This Filter removes Vertices from the supplied Vertex Geometry that are flagged as TRUE by a boolean mask array. A new reduced Vertex Geometry is created that contains all the remaining Vertices. It is unknown until run time how many Vertices will be removed from the Geometry. Therefore, this Filter requires that a new Data Container be created to contain the reduced Vertex Geometry. This new Vertex Geometry will contain copies of any Feature or Ensemble Attribute Matrices from the original Data Container. Additionally, all **Vertex* data will be copied*, with tuples removed for any Vertices removed by the Filter. The user must supply a name for the reduced Vertex Geometry, but all other copied objects (Attribute Matrices and Attribute Arrays) will retain the same names as the original source.
Link to the full online documentation for RemoveFlaggedVerticesFilter
Mapping of UI display to python named argument
UI Display
Python Named Argument
Vertex Geometry
input_vertex_geometry_path
Flagged Vertex Array (Mask)
mask_path
Reduced Vertex Geometry
output_vertex_geometry_path
- Execute(data_structure, input_vertex_geometry_path, mask_path, output_vertex_geometry_path)
- Parameters:
data_structure (DataStructure) – The DataStructure object that holds the data to be processed.
input_vertex_geometry_path (nx.GeometrySelectionParameter) – Path to the target Vertex Geometry
mask_path (nx.ArraySelectionParameter) – The DataArrayPath to the mask array that marks each face as either true (remove) or false(keep).
output_vertex_geometry_path (nx.DataGroupCreationParameter) – Created Vertex Geometry DataPath. This will be created during the filter.
- Returns:
Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.
- Return type:
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:
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:
data_structure (DataStructure) – The DataStructure object that holds the data to be processed.
comparison_data_path (nx.ArraySelectionParameter) – The DataPath to the input array to use for comparison
comparison_index (nx.ChoicesParameter) – The operator to use for comparisons. 0=Less, 1=Greater Than
input_image_geometry_path (nx.GeometrySelectionParameter) – The target geometry
loop (nx.BoolParameter) – The algorithm will keep looping until all pixels have been evaluated
min_confidence (nx.Float32Parameter) – The value to of the threshold
- Returns:
Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.
- Return type:
Require Minimum Number of Neighbors
- class simplnx.RequireMinNumNeighborsFilter
This Filter sets the minimum number of contiguous neighboring Features a Feature must have to remain in the structure. Entering zero results in nothing changing. Entering a number larger than the maximum number of neighbors of any Feature generates an error (since all Features would be removed). The user needs to proceed conservatively here when choosing the value for the minimum to avoid accidentally exceeding the maximum. After Features are removed for not having enough neighbors, the remaining Features are coarsened iteratively, one Cell per iteration, until the gaps left by the removed Features are filled. Effectively, this is an isotropic Feature growth in the regions around removed Features.
Link to the full online documentation for RequireMinNumNeighborsFilter
Mapping of UI display to python named argument
UI Display
Python Named Argument
Apply to Single Phase Only
apply_to_single_phase
Cell Feature Ids
feature_ids_path
Feature Phases
feature_phases_path
Cell Arrays to Ignore
ignored_voxel_arrays
Image Geometry
input_image_geometry_path
Minimum Number Neighbors
min_num_neighbors
Number of Neighbors
num_neighbors_path
Phase Index
phase_number
- Execute(data_structure, apply_to_single_phase, feature_ids_path, feature_phases_path, ignored_voxel_arrays, input_image_geometry_path, min_num_neighbors, num_neighbors_path, phase_number)
- Parameters:
data_structure (DataStructure) – The DataStructure object that holds the data to be processed.
apply_to_single_phase (nx.BoolParameter) – Whether to apply minimum to single ensemble or all ensembles
feature_ids_path (nx.ArraySelectionParameter) – Specifies to which Feature each Element belongs
feature_phases_path (nx.ArraySelectionParameter) – Specifies to which Ensemble each Feature belongs. Only required if Apply to Single Phase Only is checked
ignored_voxel_arrays (nx.MultiArraySelectionParameter) – The arrays to ignore when applying the minimum neighbors algorithm
input_image_geometry_path (nx.GeometrySelectionParameter) – The target geometry
min_num_neighbors (nx.UInt64Parameter) – Number of neighbors a Feature must have to remain as a Feature
num_neighbors_path (nx.ArraySelectionParameter) – Number of contiguous neighboring Features for each Feature
phase_number (nx.UInt64Parameter) – Which Ensemble to apply minimum to. Only needed if Apply to Single Phase Only is checked
- Returns:
Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.
- Return type:
Remove Minimum Size Features
- class simplnx.RequireMinimumSizeFeaturesFilter
This Filter removes Features that have a total number of Cells below the minimum threshold defined by the user. Entering a number larger than the largest Feature generates an error (since all Features would be removed). Hence, a choice of threshold should be carefully be chosen if it is not known how many Cells are in the largest Features. After removing all the small Features, the remaining Features are isotropically coarsened to fill the gaps left by the small Features.
Link to the full online documentation for RequireMinimumSizeFeaturesFilter
Mapping of UI display to python named argument
UI Display
Python Named Argument
Apply to Single Phase
apply_single_phase
Cell Feature Ids
feature_ids_path
Feature Phases
feature_phases_path
Input Image Geometry
input_image_geometry_path
Minimum Allowed Features Size
min_allowed_features_size
Feature Num. Cells Array
num_cells_path
Phase Index
phase_number
- Execute(data_structure, apply_single_phase, feature_ids_path, feature_phases_path, input_image_geometry_path, min_allowed_features_size, num_cells_path, phase_number)
- Parameters:
data_structure (DataStructure) – The DataStructure object that holds the data to be processed.
apply_single_phase (nx.BoolParameter) – Apply to Single Phase
feature_ids_path (nx.ArraySelectionParameter) – DataPath to FeatureIds DataArray
feature_phases_path (nx.ArraySelectionParameter) – DataPath to Feature Phases DataArray
input_image_geometry_path (nx.GeometrySelectionParameter) – The input image geometry (cell)
min_allowed_features_size (nx.Int64Parameter) – Minimum allowed features size
num_cells_path (nx.ArraySelectionParameter) – DataPath to NumCells DataArray
phase_number (nx.Int64Parameter) – Target phase to remove
- Returns:
Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.
- Return type:
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:
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:
data_structure (DataStructure) – The DataStructure object that holds the data to be processed.
dimensions (nx.VectorInt32Parameter) – The image geometry voxel dimensions in which to re-sample the rectilinear grid geometry
image_geom_cell_attribute_matrix_name (nx.DataObjectNameParameter) – The name of the cell data Attribute Matrix created with the Image Geometry
input_data_array_paths (nx.MultiArraySelectionParameter) – Rectilinear Grid Cell Data to possibly copy
input_image_geometry_path (nx.DataGroupCreationParameter) – Path to the created Image Geometry
rectilinear_grid_path (nx.GeometrySelectionParameter) – Path to the RectGrid Geometry to be re-sampled
- Returns:
Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.
- Return type:
Reshape Data Array
- class simplnx.ReshapeDataArrayFilter
This Filter is used to modify the tuple shape of Data Arrays, Neighbor Lists, and String Arrays within a data structure. It validates the new tuple dimensions to ensure they are positive and differ from the current shape, preventing unnecessary or invalid reshapes.
Link to the full online documentation for ReshapeDataArrayFilter
Mapping of UI display to python named argument
UI Display
Python Named Argument
Input Array
input_array_path
New Tuple Dimensions (Slowest to Fastest Dimensions)
tuple_dims
- Execute(data_structure, input_array_path, tuple_dims)
- Parameters:
data_structure (DataStructure) – The DataStructure object that holds the data to be processed.
input_array_path (nx.ArraySelectionParameter) – The input array that will be reshaped.
tuple_dims (nx.DynamicTableParameter) – Slowest to Fastest Dimensions. Note this might be opposite displayed by an image geometry.
- Returns:
Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.
- Return type:
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:
data_structure (DataStructure) – The DataStructure object that holds the data to be processed.
input_triangle_geometry_path (nx.GeometrySelectionParameter) – The DataPath to then input Triangle Geometry
- Returns:
Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.
- Return type:
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:
data_structure (DataStructure) – The DataStructure object that holds the data to be processed.
created_mask_name (nx.DataObjectNameParameter) – Created mask based on Input Array and Gradient Magnitude
gradient_array_path (nx.ArraySelectionParameter) – The complete path to the Array specifying the gradient magnitude of the Input Array
input_array_path (nx.ArraySelectionParameter) – DataArray to Threshold
- Returns:
Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.
- Return type:
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:
data_structure (DataStructure) – The DataStructure object that holds the data to be processed.
input_image_geometry_path (nx.GeometrySelectionParameter) – The target geometry on which to perform the rotation
output_image_geometry_path (nx.DataGroupCreationParameter) – The location of the rotated geometry
remove_original_geometry (nx.BoolParameter) – Performs the rotation in-place for the given Image Geometry
rotate_slice_by_slice (nx.BoolParameter) – This option is specific to EBSD Data and is not generally used.
rotation_axis_angle (nx.VectorFloat32Parameter) – Axis-Angle in sample reference frame to rotate about.
rotation_matrix (nx.DynamicTableParameter) – The 4x4 Transformation Matrix
rotation_representation_index (nx.ChoicesParameter) – Which form used to represent rotation (axis angle or rotation matrix)
- Returns:
Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.
- Return type:
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:
data_structure (DataStructure) – The DataStructure object that holds the data to be processed.
active_array_name (nx.DataObjectNameParameter) – Created array
cell_feature_group_name (nx.DataObjectNameParameter) – Created Cell Feature Attribute Matrix
feature_ids_name (nx.DataObjectNameParameter) – Path to the created Feature IDs path
input_array_path (nx.ArraySelectionParameter) – Path to the DataArray to segment
input_image_geometry_path (nx.GeometrySelectionParameter) – DataPath to input Image Geometry
mask_path (nx.ArraySelectionParameter) – Path to the DataArray Mask
randomize_features (nx.BoolParameter) – Specifies if feature IDs should be randomized during calculations
scalar_tolerance (nx.Int32Parameter) – Tolerance for segmenting input Cell Data
use_mask (nx.BoolParameter) – Determines if a mask array is used for segmenting
- Returns:
Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.
- Return type:
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:
data_structure (DataStructure) – The DataStructure object that holds the data to be processed.
center_origin (nx.BoolParameter) – Specifies if the origin should be aligned with the corner (false) or center (true)
change_origin (nx.BoolParameter) – Specifies if the origin should be changed
change_spacing (nx.BoolParameter) – Specifies if the spacing should be changed
input_image_geometry_path (nx.GeometrySelectionParameter) – Path to the target ImageGeom
origin (nx.VectorFloat32Parameter) – Specifies the new origin values in physical units.
spacing (nx.VectorFloat32Parameter) – Specifies the new spacing values in physical units.
- Returns:
Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.
- Return type:
Compute Triangle Face Ids
Silhouette
- class simplnx.SilhouetteFilter
This Filter computes the silhouette for a clustered Attribute Array. The user must select both the original array that has been clustered and the array of cluster Ids. The silhouette represents a measure for the quality of a clustering. Specifically, the silhouette provides a measure for how strongly a given point belongs to its own cluster compared to all other clusters. The silhouette is computed as follows:
Link to the full online documentation for SilhouetteFilter
Mapping of UI display to python named argument
UI Display
Python Named Argument
Distance Metric
distance_metric_index
Cluster Ids
feature_ids_array_path
Mask Array
mask_array_path
Attribute Array to Silhouette
selected_array_path
Silhouette
silhouette_array_path
Use Mask Array
use_mask
- Execute(data_structure, distance_metric_index, feature_ids_array_path, mask_array_path, selected_array_path, silhouette_array_path, use_mask)
- Parameters:
data_structure (DataStructure) – The DataStructure object that holds the data to be processed.
distance_metric_index (nx.ChoicesParameter) – Distance Metric type to be used for calculations
feature_ids_array_path (nx.ArraySelectionParameter) – The DataPath to the DataArray that specifies which cluster each point belongs
mask_array_path (nx.ArraySelectionParameter) – DataPath to the boolean or uint8 mask array. Values that are true will mark that cell/point as usable.
selected_array_path (nx.ArraySelectionParameter) – The DataPath to the input DataArray
silhouette_array_path (nx.ArrayCreationParameter) – The DataPath to the calculated output Silhouette array values
use_mask (nx.BoolParameter) – Specifies whether or not to use a mask array
- Returns:
Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.
- Return type:
Slice Triangle Geometry
- class simplnx.SliceTriangleGeometryFilter
This Filter slices an input Triangle Geometry, producing an Edge Geometry. The user can control the range over which to slice (either the entire range of the geoemtry or a specified subregion), and the spacing bewteen slices. Currently this filter only supports slicing along the direction of the z axis. The total area and perimieter of each slice is also computed and stored as an attribute on each created slice.
Link to the full online documentation for SliceTriangleGeometryFilter
Mapping of UI display to python named argument
UI Display
Python Named Argument
Edge Attribute Matrix
edge_attribute_matrix_name
Have Region Ids
have_region_ids
Triangle Geometry
input_triangle_geometry_path
Created Edge Geometry
output_edge_geometry_path
Region Ids
region_ids_array_path
Slice Attribute Matrix
slice_attribute_matrix_name
Slice Ids
slice_ids_array_name
Slice Range
slice_range_index
Slice Spacing
slice_spacing_value
Slicing End
z_end_value
Slicing Start
z_start_value
- Execute(data_structure, edge_attribute_matrix_name, have_region_ids, input_triangle_geometry_path, output_edge_geometry_path, region_ids_array_path, slice_attribute_matrix_name, slice_ids_array_name, slice_range_index, slice_spacing_value, z_end_value, z_start_value)
- Parameters:
data_structure (DataStructure) – The DataStructure object that holds the data to be processed.
edge_attribute_matrix_name (nx.DataObjectNameParameter) – Attribute Matrix to store information about the created edges
have_region_ids (nx.BoolParameter) – Whether to supply an id array that propagates to the created edges
input_triangle_geometry_path (nx.GeometrySelectionParameter) – The input triangle geometry to be sliced
output_edge_geometry_path (nx.DataGroupCreationParameter) – The name of the created Edge Geometry
region_ids_array_path (nx.ArraySelectionParameter) – Optional identifier array, if Have Region Ids is selected
slice_attribute_matrix_name (nx.DataObjectNameParameter) – Attribute Matrix to store information about the created edges
slice_ids_array_name (nx.DataObjectNameParameter) – Identifies the slice to which each edge belongs
slice_range_index (nx.ChoicesParameter) – Type of slice range to use, either Full Range or User Defined Range
slice_spacing_value (nx.Float32Parameter) – The spacing between slices
z_end_value (nx.Float32Parameter) – The z axis stop value. Only needed for ‘User Defined Range’
z_start_value (nx.Float32Parameter) – The z axis start value. Only needed for ‘User Defined Range’
- Returns:
Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.
- Return type:
Split Multi component Attribute Array
- class simplnx.SplitAttributeArrayFilter
This Filter splits an n-component Attribute Array into n scalar arrays, where each array is one of the original components. Any arbitrary component array may be split in this manner, and the output arrays will have the same primitive type as the input array. The original array is not modified (unless the option to remove the original array is selected); instead, n new arrays are created. For example, consider an unsigned 8-bit array with three components:
Link to the full online documentation for SplitAttributeArrayFilter
Mapping of UI display to python named argument
UI Display
Python Named Argument
Components to Extract
components_to_extract
Remove Original Array
delete_original_array
Multi-Component Attribute Array
multicomponent_array_path
Postfix
postfix
Select Specific Components to Extract
select_components_to_extract
- Execute(data_structure, components_to_extract, delete_original_array, multicomponent_array_path, postfix, select_components_to_extract)
- Parameters:
data_structure (DataStructure) – The DataStructure object that holds the data to be processed.
components_to_extract (nx.DynamicTableParameter) – The components from the input array to be extracted into separate arrays
delete_original_array (nx.BoolParameter) – Whether or not to remove the original multicomponent array after splitting
multicomponent_array_path (nx.ArraySelectionParameter) – The multicomponent Attribute Array to split
postfix (nx.StringParameter) – Postfix to add to the end of the split Attribute Arrays
select_components_to_extract (nx.BoolParameter) – Whether or not to specify only certain components to be extracted
- Returns:
Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.
- Return type:
Create Surface Mesh (Surface Nets)
- class simplnx.SurfaceNetsFilter
This filter uses the algorithm from {1} to produce a triangle surface mesh. The code is directly based on the sample code from the paper but has been modified towork with the simplnx library classes. This filter uses a different algorithm that aims to produce a mush that keeps sharp edgeswhile still producing a mesh superior to marching cubes or QuickMesh.
Link to the full online documentation for SurfaceNetsFilter
Mapping of UI display to python named argument
UI Display
Python Named Argument
Apply smoothing operations
apply_smoothing
Face Data [AttributeMatrix]
face_data_group_name
Face Feature Data [AttributeMatrix]
face_feature_attribute_matrix_name
Face Labels
face_labels_array_name
Cell Feature Ids
feature_ids_path
Input Image Geometry
input_grid_geometry_path
Max Distance from Voxel Center
max_distance_from_voxel
Node Type
node_types_array_name
Created Triangle Geometry
output_triangle_geometry_path
Relaxation Factor
relaxation_factor
Relaxation Iterations
smoothing_iterations
Vertex Data [AttributeMatrix]
vertex_data_group_name
- Execute(data_structure, apply_smoothing, face_data_group_name, face_feature_attribute_matrix_name, face_labels_array_name, feature_ids_path, input_grid_geometry_path, max_distance_from_voxel, node_types_array_name, output_triangle_geometry_path, relaxation_factor, smoothing_iterations, vertex_data_group_name)
- Parameters:
data_structure (DataStructure) – The DataStructure object that holds the data to be processed.
apply_smoothing (nx.BoolParameter) – Use the built in smoothing operation.
face_data_group_name (nx.DataObjectNameParameter) – The complete path to the DataGroup where the Face Data of the Triangle Geometry will be created
face_feature_attribute_matrix_name (nx.DataObjectNameParameter) – The complete path to the DataGroup where the Feature Data will be stored.
face_labels_array_name (nx.DataObjectNameParameter) – The complete path to the Array specifying which Features are on either side of each Face in the Triangle Geometry
feature_ids_path (nx.ArraySelectionParameter) – The complete path to the Array specifying which Feature each Cell belongs to
input_grid_geometry_path (nx.GeometrySelectionParameter) – DataPath to input Image Geometry
max_distance_from_voxel (nx.Float32Parameter) – The maximum allowable distance that a node can move from the voxel center
node_types_array_name (nx.DataObjectNameParameter) – The complete path to the Array specifying the type of node in the Triangle Geometry
output_triangle_geometry_path (nx.DataGroupCreationParameter) – The name of the created Triangle Geometry
relaxation_factor (nx.Float32Parameter) – The factor used to determine how far a node can move in each smoothing iteration
smoothing_iterations (nx.Int32Parameter) – Number of relaxation iterations to perform. More iterations causes more smoothing.
vertex_data_group_name (nx.DataObjectNameParameter) – The complete path to the DataGroup where the Vertex Data of the Triangle Geometry will be created
- Returns:
Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.
- Return type:
Compute Triangle Centroids
- class simplnx.TriangleCentroidFilter
This Filter computes the centroid of each Triangle in a Triangle Geometry by calculating the average position of all 3 Vertices that make up the Triangle.
Link to the full online documentation for TriangleCentroidFilter
Mapping of UI display to python named argument
UI Display
Python Named Argument
Created Face Centroids
centroids_array_name
Triangle Geometry
input_triangle_geometry_path
- Execute(data_structure, centroids_array_name, input_triangle_geometry_path)
- Parameters:
data_structure (DataStructure) – The DataStructure object that holds the data to be processed.
centroids_array_name (nx.DataObjectNameParameter) – The complete path to the array storing the calculated centroids
input_triangle_geometry_path (nx.GeometrySelectionParameter) – The complete path to the Geometry for which to calculate the normals
- Returns:
Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.
- Return type:
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:
Compute Triangle Normals
- class simplnx.TriangleNormalFilter
This Filter computes the normal of each Triangle in a Triangle Geometry by utilizing matrix subtraction, cross product, and normalization to implement the following theory:For a triangle with point1, point2, point3, if the vector U = point2 - point1 and the vector V = point3 - point1
Link to the full online documentation for TriangleNormalFilter
Mapping of UI display to python named argument
UI Display
Python Named Argument
Triangle Geometry
input_triangle_geometry_path
Created Face Normals
output_normals_array_name
- Execute(data_structure, input_triangle_geometry_path, output_normals_array_name)
- Parameters:
data_structure (DataStructure) – The DataStructure object that holds the data to be processed.
input_triangle_geometry_path (nx.GeometrySelectionParameter) – The complete path to the Geometry for which to calculate the normals
output_normals_array_name (nx.DataObjectNameParameter) – The complete path to the array storing the calculated normals
- Returns:
Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.
- Return type:
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:
data_structure (DataStructure) – The DataStructure object that holds the data to be processed.
cell_attribute_matrix_name (nx.DataObjectNameParameter) – The name for the cell data Attribute Matrix within the Image geometry
dimensions (nx.VectorUInt64Parameter) – The dimensions of the created Image geometry
feature_ids_array_name (nx.DataObjectNameParameter) – The name for the feature ids array in cell data Attribute Matrix
input_image_geometry_path (nx.DataGroupCreationParameter) – The name and path for the image geometry to be created
input_triangle_geometry_path (nx.GeometrySelectionParameter) – The geometry to be sampled onto grid
origin (nx.VectorFloat32Parameter) – The origin of the created Image geometry
seed_array_name (nx.DataObjectNameParameter) – Name of array holding the seed value
seed_value (nx.UInt64Parameter) – The seed fed into the random generator
spacing (nx.VectorFloat32Parameter) – The spacing of the created Image geometry
surface_mesh_face_labels_array_path (nx.ArraySelectionParameter) – Array specifying which Features are on either side of each Face
uncertainty (nx.VectorFloat32Parameter) – uncertainty values associated with X, Y and Z positions of Cells
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:
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:
data_structure (DataStructure) – The DataStructure object that holds the data to be processed.
delimiter_index (nx.ChoicesParameter) – The delimiter separating the data
file_extension (nx.StringParameter) – The file extension for the output file(s)
header_option_index (nx.ChoicesParameter) – Default Include is Headers only
input_data_array_paths (nx.MultiArraySelectionParameter) – Data Arrays to be written to disk
max_val_per_line (nx.Int32Parameter) – Number of tuples to print on each line. Does not apply to string arrays
output_dir (nx.FileSystemPathParameter) – The output file path
output_path (nx.FileSystemPathParameter) – The output file path
output_style_index (nx.ChoicesParameter) – Whether to output a folder of files or a single file with all the data in column form
- Returns:
Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.
- Return type:
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:
data_structure (DataStructure) – The DataStructure object that holds the data to be processed.
feature_ids_array_path (nx.ArraySelectionParameter) – Data Array that specifies to which Feature each Element belongs
file_prefix (nx.StringParameter) – The prefix to use for each output file.
hourglass_stiffness (nx.Int32Parameter) – The value to use for the Hourglass Stiffness
input_image_geometry_path (nx.GeometrySelectionParameter) – The input Image Geometry that will be written.
job_name (nx.StringParameter) – The name of the job
output_path (nx.FileSystemPathParameter) – The output file path
- Returns:
Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.
- Return type:
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:
data_structure (DataStructure) – The DataStructure object that holds the data to be processed.
feature_ids_array_path (nx.ArraySelectionParameter) – Data Array that specifies to which Feature each Element belongs
input_image_geometry_path (nx.GeometrySelectionParameter) – The path to the input image geometry
output_file (nx.FileSystemPathParameter) – Amira Mesh .am file created
units (nx.StringParameter) – The units of the data
write_binary_file (nx.BoolParameter) – Whether or not to write the output file as binary
- Returns:
Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.
- Return type:
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:
data_structure (DataStructure) – The DataStructure object that holds the data to be processed.
feature_ids_array_path (nx.ArraySelectionParameter) – Data Array that specifies to which Feature each Element belongs
input_image_geometry_path (nx.GeometrySelectionParameter) – The path to the input image geometry
output_file (nx.FileSystemPathParameter) – Amira Mesh .am file created
units (nx.StringParameter) – The units of the data
write_binary_file (nx.BoolParameter) – Whether or not to write the output file as binary
- Returns:
Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.
- Return type:
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:
data_structure (DataStructure) – The DataStructure object that holds the data to be processed.
endian_index (nx.ChoicesParameter) – Default is little endian
file_extension (nx.StringParameter) – The file extension for the output file
input_data_array_paths (nx.MultiArraySelectionParameter) – The arrays to be exported to a binary file
output_path (nx.FileSystemPathParameter) – The output file path
- Returns:
Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.
- Return type:
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:
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:
data_structure (DataStructure) – The DataStructure object that holds the data to be processed.
cell_feature_attribute_matrix_path (nx.AttributeMatrixSelectionParameter) – Input Feature Attribute Matrix
delimiter_index (nx.ChoicesParameter) – Default Delimiter is Comma
feature_data_file (nx.FileSystemPathParameter) – Path to the output file to write.
write_neighborlist_data (nx.BoolParameter) – Should the neighbor list data be written to the file
write_num_features_line (nx.BoolParameter) – Should the number of features be written to the file.
- Returns:
Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.
- Return type:
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:
data_structure (DataStructure) – The DataStructure object that holds the data to be processed.
cell_euler_angles_array_path (nx.ArraySelectionParameter) – Data Array containing the three angles defining the orientation for each of the Cell in Bunge convention (Z-X-Z)
cell_phases_array_path (nx.ArraySelectionParameter) – Data Array that specifies to which Ensemble each Cell belongs
feature_ids_array_path (nx.ArraySelectionParameter) – Data Array that specifies to which Feature each Element belongs
input_image_geometry_path (nx.GeometrySelectionParameter) – The image geometry holding the arrays to write
output_file (nx.FileSystemPathParameter) – The path to the output file
- Returns:
Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.
- Return type:
Write Nodes And Elements File(s)
- class simplnx.WriteNodesAndElementsFilesFilter
This Filter exports geometric data into structured text files. It allows users to save the following:
Link to the full online documentation for WriteNodesAndElementsFilesFilter
Mapping of UI display to python named argument
UI Display
Python Named Argument
Output Element/Cell File Path
element_file_path
Include Element/Cell File Header
include_element_file_header
Include Node File Header
include_node_file_header
Output Node File Path
node_file_path
Number Elements/Cells
number_elements
Number Nodes
number_nodes
Geometry To Write
selected_geometry_path
Write Element/Cell File
write_element_file
Write Node File
write_node_file
- Execute(data_structure, element_file_path, include_element_file_header, include_node_file_header, node_file_path, number_elements, number_nodes, selected_geometry_path, write_element_file, write_node_file)
- Parameters:
data_structure (DataStructure) – The DataStructure object that holds the data to be processed.
element_file_path (nx.FileSystemPathParameter) – The element/cell information will be written to this file path.
include_element_file_header (nx.BoolParameter) – Whether or not to include the element/cell file header in the element/cell output file.
include_node_file_header (nx.BoolParameter) – Whether or not to include the node file header in the node output file.
node_file_path (nx.FileSystemPathParameter) – The node information will be written to this file path.
number_elements (nx.BoolParameter) – Whether or not to number each element/cell in the element information output file.
number_nodes (nx.BoolParameter) – Whether or not to number each node in the node information output file.
selected_geometry_path (nx.GeometrySelectionParameter) – The Geometry that will be written to the output file(s).
write_element_file (nx.BoolParameter) – Whether or not to write the element/cell information out to a file.
write_node_file (nx.BoolParameter) – Whether or not to write the node information out to a file.
- Returns:
Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.
- Return type:
Write SPParks Sites File
- class simplnx.WriteSPParksSitesFilter
This Filter writes to a data file in a format used by SPPARKS Kinetic Monte Carlo Simulator.
Link to the full online documentation for WriteSPParksSitesFilter
Mapping of UI display to python named argument
UI Display
Python Named Argument
Cell Feature Ids
feature_ids_array_path
Input Image Geometry
input_image_geometry_path
Output File Path
output_file
- Execute(data_structure, feature_ids_array_path, input_image_geometry_path, output_file)
- Parameters:
data_structure (DataStructure) – The DataStructure object that holds the data to be processed.
feature_ids_array_path (nx.ArraySelectionParameter) – Data Array that specifies to which Feature each Element belongs
input_image_geometry_path (nx.GeometrySelectionParameter) – The image geometry holding the arrays to write
output_file (nx.FileSystemPathParameter) – The path to the output file
- Returns:
Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.
- Return type:
Write STL Files from Triangle Geometry
- class simplnx.WriteStlFileFilter
*WARNING:* The filter now provides implict overflow capabilities for very large datasets, but this will lead to many duplicated vertices being produced. Be sure to run a cleaning algorithm when importing these files into DREAM3DNX or other software. For more info see below.
Link to the full online documentation for WriteStlFileFilter
Mapping of UI display to python named argument
UI Display
Python Named Argument
Face labels
feature_ids_path
Feature Phases
feature_phases_path
File Grouping Type
grouping_type_index
Selected Triangle Geometry
input_triangle_geometry_path
Output STL Directory
output_stl_directory
Output STL File
output_stl_file
Output STL File Prefix
output_stl_prefix
Part Numbers
part_number_path
- Execute(data_structure, feature_ids_path, feature_phases_path, grouping_type_index, input_triangle_geometry_path, output_stl_directory, output_stl_file, output_stl_prefix, part_number_path)
- Parameters:
data_structure (DataStructure) – The DataStructure object that holds the data to be processed.
feature_ids_path (nx.ArraySelectionParameter) – The triangle feature ids array to order/index files by
feature_phases_path (nx.ArraySelectionParameter) – The feature phases array to further order/index files by
grouping_type_index (nx.ChoicesParameter) – How to partition the stl files
input_triangle_geometry_path (nx.GeometrySelectionParameter) – The geometry to print
output_stl_directory (nx.FileSystemPathParameter) – Directory to dump the STL file(s) to
output_stl_file (nx.FileSystemPathParameter) – STL File to dump the Triangle Geometry to
output_stl_prefix (nx.StringParameter) – The prefix name of created files (other values will be appended later - including the .stl extension)
part_number_path (nx.ArraySelectionParameter) – The Part Numbers to order/index files by
- Returns:
Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.
- Return type:
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:
data_structure (DataStructure) – The DataStructure object that holds the data to be processed.
input_data_array_paths (nx.MultiArraySelectionParameter) – The paths to the cell data arrays to write out with the geometry
input_image_geometry_path (nx.GeometrySelectionParameter) – The path to the image geometry in which to write out to the vtk file
output_file (nx.FileSystemPathParameter) – The output vtk file in which the geometry data is written
write_binary_file (nx.BoolParameter) – Whether or not to write the vtk file in binary
- Returns:
Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.
- Return type:
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:
data_structure (DataStructure) – The DataStructure object that holds the data to be processed.
input_data_array_paths (nx.MultiArraySelectionParameter) – The paths to the cell data arrays to write out with the geometry
input_image_geometry_path (nx.GeometrySelectionParameter) – The path to the image geometry in which to write out to the vtk file
output_file (nx.FileSystemPathParameter) – The output vtk file in which the geometry data is written
write_binary_file (nx.BoolParameter) – Whether or not to write the vtk file in binary
- Returns:
Returns a nx.IFilter.ExecuteResult object that holds any warnings and/or errors that were encountered during execution.
- Return type: