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: .. code:: python import simplnx # Instantiate and execute a filter from the module result = simplnx.SomeFilterName.execute(...) .. py:module:: simplnx Add Bad Data ------------ .. index:: pair: Filter Human Names; Add Bad Data .. index:: pair: Filter Class Names; AddBadDataFilter .. _AddBadDataFilter: .. py:class:: 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 | +-----------------------------------+-----------------------------------+ .. py:method:: 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) :param DataStructure data_structure: The DataStructure object that holds the data to be processed. :param nx.BoolParameter boundary_noise: If true the user may set the boundary volume fraction :param nx.Float32Parameter boundary_vol_fraction: A value between 0 and 1 inclusive that is compared against random generation :param nx.ArraySelectionParameter gb_euclidean_distances_array_path: This is the GB Manhattan Distances array :param nx.GeometrySelectionParameter input_image_geometry_path: The selected image geometry :param nx.BoolParameter poisson_noise: If true the user may set the poisson volume fraction :param nx.Float32Parameter poisson_vol_fraction: A value between 0 and 1 inclusive that is compared against random generation :param nx.DataObjectNameParameter seed_array_name: Name of array holding the seed value :param nx.UInt64Parameter seed_value: The seed fed into the random generator :param nx.BoolParameter use_seed: When true the user will be able to put in a seed for random generation :return: Returns a :ref:`nx.IFilter.ExecuteResult ` object that holds any warnings and/or errors that were encountered during execution. :rtype: :ref:`nx.IFilter.ExecuteResult ` Align Geometries ---------------- .. index:: pair: Filter Human Names; Align Geometries .. index:: pair: Filter Class Names; AlignGeometriesFilter .. _AlignGeometriesFilter: .. py:class:: 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 | +-----------------+----------------------------+ .. py:method:: Execute(data_structure, alignment_type_index, input_moving_geometry_path, input_target_geometry_path) :param DataStructure data_structure: The DataStructure object that holds the data to be processed. :param nx.ChoicesParameter alignment_type_index: The type of alignment to perform (Origin or Centroid. :param nx.GeometrySelectionParameter input_moving_geometry_path: The geometry that will be moved. :param nx.GeometrySelectionParameter input_target_geometry_path: The geometry that does *not* move. :return: Returns a :ref:`nx.IFilter.ExecuteResult ` object that holds any warnings and/or errors that were encountered during execution. :rtype: :ref:`nx.IFilter.ExecuteResult ` Align Sections (Feature Centroid) --------------------------------- .. index:: pair: Filter Human Names; Align Sections (Feature Centroid) .. index:: pair: Filter Class Names; AlignSectionsFeatureCentroidFilter .. _AlignSectionsFeatureCentroidFilter: .. py:class:: 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 | +---------------------------------------------+---------------------------------+ .. py:method:: 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) :param DataStructure data_structure: The DataStructure object that holds the data to be processed. :param nx.DataObjectNameParameter alignment_attribute_matrix_name: The output attribute matrix where the shifts applied to the section to be stored as DataArrays. :param nx.DataObjectNameParameter centroids_array_name: The output array name where the centroid information will be stored. :param nx.DataObjectNameParameter cumulative_shifts_array_name: The output array name where the accumulated shift information will be stored. :param nx.GeometrySelectionParameter input_image_geometry_path: The target geometry on which to perform the alignment :param nx.ArraySelectionParameter mask_array_path: Specifies if the Cell is to be counted in the algorithm. :param nx.Int32Parameter reference_slice: Slice number to use as reference :param nx.DataObjectNameParameter relative_shifts_array_name: The output array name where the new shifts relative to previous slice information will be stored. :param nx.DataObjectNameParameter slices_array_name: The output array name where the slice information related to shifts will be stored. :param nx.BoolParameter store_alignment_shifts: Whether to store the shifts applied to each section to a collection of Arrays in a new Attribute Matrix :param nx.BoolParameter use_reference_slice: Whether the centroids of each section should be compared to a reference slice instead of their neighboring section :return: Returns a :ref:`nx.IFilter.ExecuteResult ` object that holds any warnings and/or errors that were encountered during execution. :rtype: :ref:`nx.IFilter.ExecuteResult ` Align Sections (List) --------------------- .. index:: pair: Filter Human Names; Align Sections (List) .. index:: pair: Filter Class Names; AlignSectionsListFilter .. _AlignSectionsListFilter: .. py:class:: 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 | +-------------------------+---------------------------+ .. py:method:: Execute(data_structure, input_array_type_index, input_image_geometry_path, shifts_array_path) :param DataStructure data_structure: The DataStructure object that holds the data to be processed. :param nx.ChoicesParameter input_array_type_index: 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 :param nx.GeometrySelectionParameter input_image_geometry_path: The target geometry on which to perform the alignment :param nx.ArraySelectionParameter shifts_array_path: The array containing the relative or cumulative shifts for each slice :return: Returns a :ref:`nx.IFilter.ExecuteResult ` object that holds any warnings and/or errors that were encountered during execution. :rtype: :ref:`nx.IFilter.ExecuteResult ` Append Image Geometry --------------------- .. index:: pair: Filter Human Names; Append Image Geometry .. index:: pair: Filter Class Names; AppendImageGeometryFilter .. _AppendImageGeometryFilter: .. py:class:: 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 | +------------------------------+---------------------------------+ .. py:method:: 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) :param DataStructure data_structure: The DataStructure object that holds the data to be processed. :param nx.BoolParameter check_resolution: Checks to make sure the spacing for the input geometry and destination geometry match :param nx.GeometrySelectionParameter destination_image_geometry_path: The destination image geometry (cell data) that is the final location for the appended data. :param nx.ChoicesParameter direction_index: The direction that will be used to append the geometries. :param nx.MultiPathSelectionParameter input_image_geometries_paths: The incoming image geometries (cell data) that will be appended to the destination image geometry. :param nx.BoolParameter mirror_geometry: Mirrors the resulting geometry in the chosen direction. :param nx.DataGroupCreationParameter output_image_geometry_path: The path to the new geometry with the combined data from the input & destination geometry :param nx.BoolParameter save_as_new_geometry: Save the combined data as a new geometry instead of appending the input data to the destination geometry :return: Returns a :ref:`nx.IFilter.ExecuteResult ` object that holds any warnings and/or errors that were encountered during execution. :rtype: :ref:`nx.IFilter.ExecuteResult ` Apply Transformation to Geometry -------------------------------- .. index:: pair: Filter Human Names; Apply Transformation to Geometry .. index:: pair: Filter Class Names; ApplyTransformationToGeometryFilter .. _ApplyTransformationToGeometryFilter: .. py:class:: 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 | +-----------------------------------------------------------+-------------------------------------+ .. py:method:: 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) :param DataStructure data_structure: The DataStructure object that holds the data to be processed. :param nx.AttributeMatrixSelectionParameter cell_attribute_matrix_path: The path to the Cell level data that should be interpolated. Only applies when selecting an Image Geometry. :param nx.ArraySelectionParameter computed_transformation_matrix_path: A precomputed 4x4 transformation matrix :param nx.GeometrySelectionParameter input_image_geometry_path: The target geometry on which to perform the transformation :param nx.ChoicesParameter interpolation_type_index: Select the type of interpolation algorithm. (0)Nearest Neighbor, (1)Linear Interpolation, (3)No Interpolation :param nx.DynamicTableParameter manual_transformation_matrix: The 4x4 Transformation Matrix :param nx.ArrayCreationParameter output_transform_matrix_path: The output array that contains the transformation Matrix. :param nx.VectorFloat32Parameter rotation: w (w in degrees) :param nx.BoolParameter save_transform_matrix: Save the generated transform matrix as a Data Array :param nx.VectorFloat32Parameter scale: 0>= value < 1: Shrink, value = 1: No transform, value > 1.0 enlarge :param nx.ChoicesParameter transformation_type_index: The type of transformation to perform. :param nx.BoolParameter translate_geometry_to_global_origin: Specifies whether to translate the geometry to (0, 0, 0), apply the transformation, and then translate the geometry back to its original origin. :param nx.VectorFloat32Parameter translation: A pure translation vector :return: Returns a :ref:`nx.IFilter.ExecuteResult ` object that holds any warnings and/or errors that were encountered during execution. :rtype: :ref:`nx.IFilter.ExecuteResult ` Approximate Point Cloud Hull ---------------------------- .. index:: pair: Filter Human Names; Approximate Point Cloud Hull .. index:: pair: Filter Class Names; ApproximatePointCloudHullFilter .. _ApproximatePointCloudHullFilter: .. py:class:: 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 | +-----------------------------------+-----------------------------+ .. py:method:: Execute(data_structure, grid_resolution, input_vertex_geometry_path, min_empty_neighbors, output_vertex_geometry_path) :param DataStructure data_structure: The DataStructure object that holds the data to be processed. :param nx.VectorFloat32Parameter grid_resolution: Geometry resolution :param nx.GeometrySelectionParameter input_vertex_geometry_path: Path to the target Vertex geometry :param nx.UInt64Parameter min_empty_neighbors: Minimum number of empty neighbors :param nx.DataGroupCreationParameter output_vertex_geometry_path: Path to create the hull Vertex geometry :return: Returns a :ref:`nx.IFilter.ExecuteResult ` object that holds any warnings and/or errors that were encountered during execution. :rtype: :ref:`nx.IFilter.ExecuteResult ` Attribute Array Calculator -------------------------- .. index:: pair: Filter Human Names; Attribute Array Calculator .. index:: pair: Filter Class Names; ArrayCalculatorFilter .. _ArrayCalculatorFilter: .. py:class:: 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 | +-------------------------+-----------------------+ .. py:method:: Execute(data_structure, calculated_array_path, calculator_parameter, scalar_type_index) :param DataStructure data_structure: The DataStructure object that holds the data to be processed. :param nx.ArrayCreationParameter calculated_array_path: The path to the calculated array :param nx.CalculatorParameter calculator_parameter: The mathematical expression used to calculate the output array :param nx.NumericTypeParameter scalar_type_index: The data type of the calculated array :return: Returns a :ref:`nx.IFilter.ExecuteResult ` object that holds any warnings and/or errors that were encountered during execution. :rtype: :ref:`nx.IFilter.ExecuteResult ` Convert Angles to Degrees or Radians ------------------------------------ .. index:: pair: Filter Human Names; Convert Angles to Degrees or Radians .. index:: pair: Filter Class Names; ChangeAngleRepresentationFilter .. _ChangeAngleRepresentationFilter: .. py:class:: 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 | +-----------------+-----------------------+ .. py:method:: Execute(data_structure, angles_array_path, conversion_type_index) :param DataStructure data_structure: The DataStructure object that holds the data to be processed. :param nx.ArraySelectionParameter angles_array_path: The DataArray containing the angles to be converted. :param nx.ChoicesParameter conversion_type_index: Tells the Filter which conversion is being made :return: Returns a :ref:`nx.IFilter.ExecuteResult ` object that holds any warnings and/or errors that were encountered during execution. :rtype: :ref:`nx.IFilter.ExecuteResult ` Combine Attribute Arrays ------------------------ .. index:: pair: Filter Human Names; Combine Attribute Arrays .. index:: pair: Filter Class Names; CombineAttributeArraysFilter .. _CombineAttributeArraysFilter: .. py:class:: 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 | +-----------------------------+------------------------+ .. py:method:: Execute(data_structure, input_data_array_paths, move_values, normalize_data, output_data_array_name) :param DataStructure data_structure: The DataStructure object that holds the data to be processed. :param nx.MultiArraySelectionParameter input_data_array_paths: The complete path to each of the Attribute Arrays to combine :param nx.BoolParameter move_values: Whether to remove the original arrays after combining the data :param nx.BoolParameter normalize_data: Whether to normalize the combine data on the interval [0, 1] :param nx.DataObjectNameParameter output_data_array_name: This is the name of the created output array of the combined attribute arrays. :return: Returns a :ref:`nx.IFilter.ExecuteResult ` object that holds any warnings and/or errors that were encountered during execution. :rtype: :ref:`nx.IFilter.ExecuteResult ` Combine Node Based Geometries ----------------------------- .. index:: pair: Filter Human Names; Combine Node Based Geometries .. index:: pair: Filter Class Names; CombineNodeBasedGeometriesFilter .. _CombineNodeBasedGeometriesFilter: .. py:class:: 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 | +-------------------+-----------------------+ .. py:method:: Execute(data_structure, input_geometry_paths, output_geometry_path) :param DataStructure data_structure: The DataStructure object that holds the data to be processed. :param nx.MultiPathSelectionParameter input_geometry_paths: The incoming geometries that will be combined together into the destination geometry. All geometries must be of the same geometry type. :param nx.DataGroupCreationParameter output_geometry_path: The path to the combined geometry :return: Returns a :ref:`nx.IFilter.ExecuteResult ` object that holds any warnings and/or errors that were encountered during execution. :rtype: :ref:`nx.IFilter.ExecuteResult ` Combine STL Files ----------------- .. index:: pair: Filter Human Names; Combine STL Files .. index:: pair: Filter Class Names; CombineStlFilesFilter .. _CombineStlFilesFilter: .. py:class:: 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 | +--------------------------------+------------------------------------+ .. py:method:: 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) :param DataStructure data_structure: The DataStructure object that holds the data to be processed. :param nx.DataObjectNameParameter active_array_name: 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 :param nx.DataObjectNameParameter cell_feature_attribute_matrix_name: The name of the created feature attribute matrix :param nx.BoolParameter create_face_labels: When true, the 'Face Labels' array will be created. :param nx.BoolParameter create_part_numbers: When true, each triangle will get an index associated with the index of the STL file :param nx.DataObjectNameParameter face_attribute_matrix_name: The name of the face level attribute matrix to be created with the geometry :param nx.DataObjectNameParameter face_labels_name: The name of the 'Face Labels' data array :param nx.DataObjectNameParameter face_normals_array_name: The name of the data array in which to store the face normals for the created triangle geometry :param nx.BoolParameter label_vertices: When true, each vertex will get an index associated with the index of the STL file :param nx.DataObjectNameParameter output_file_list_name: The path to a String array that will store the input paths of each file that was read. :param nx.DataGroupCreationParameter output_triangle_geometry_path: The path to the triangle geometry to be created from the combined STL files :param nx.DataObjectNameParameter part_numbers_name: The name of the part numbers data array :param nx.FileSystemPathParameter stl_files_path: The path to the folder containing all the STL files to be combined :param nx.DataObjectNameParameter vertex_attribute_matrix_name: The name of the vertex level attribute matrix to be created with the geometry :param nx.DataObjectNameParameter vertex_label_name: The name of the part numbers data array :return: Returns a :ref:`nx.IFilter.ExecuteResult ` object that holds any warnings and/or errors that were encountered during execution. :rtype: :ref:`nx.IFilter.ExecuteResult ` Compute Attribute Array Frequency Histogram ------------------------------------------- .. index:: pair: Filter Human Names; Compute Attribute Array Frequency Histogram .. index:: pair: Filter Class Names; ComputeArrayHistogramFilter .. _ComputeArrayHistogramFilter: .. py:class:: 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 | +-----------------------------------------+----------------------------+ .. py:method:: 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) :param DataStructure data_structure: The DataStructure object that holds the data to be processed. :param nx.BoolParameter create_new_data_group: Whether or not to store the calculated histogram(s) in a new DataGroup :param nx.StringParameter histogram_bin_count_suffix: String appended to the end of the histogram array names :param nx.StringParameter histogram_bin_range_suffix: String appended to the end of the histogram array names :param nx.Float64Parameter max_range: Specifies the exclusive upper bound of the histogram. :param nx.Float64Parameter min_range: Specifies the inclusive lower bound of the histogram. :param nx.DataGroupCreationParameter new_data_group_path: The path to the new DataGroup in which to store the calculated histogram(s) :param nx.Int32Parameter number_of_bins: Specifies number of histogram bins (greater than zero) :param nx.DataGroupSelectionParameter output_data_group_path: The complete path to the DataGroup in which to store the calculated histogram(s) :param nx.MultiArraySelectionParameter selected_array_paths: The list of arrays to calculate histogram(s) for :param nx.BoolParameter user_defined_range: Whether the user can set the min and max values to consider for the histogram :return: Returns a :ref:`nx.IFilter.ExecuteResult ` object that holds any warnings and/or errors that were encountered during execution. :rtype: :ref:`nx.IFilter.ExecuteResult ` Compute Attribute Array Statistics ---------------------------------- .. index:: pair: Filter Human Names; Compute Attribute Array Statistics .. index:: pair: Filter Class Names; ComputeArrayStatisticsFilter .. _ComputeArrayStatisticsFilter: .. py:class:: 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 | +-----------------------------------------+-----------------------------------+ .. py:method:: 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) :param DataStructure data_structure: The DataStructure object that holds the data to be processed. :param nx.BoolParameter compute_by_index: Whether the statistics should be computed on a Feature/Ensemble basis :param nx.DataGroupCreationParameter destination_attribute_matrix_path: Attribute Matrix in which to store the computed statistics :param nx.DataObjectNameParameter feature_has_data_array_name: 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. :param nx.ArraySelectionParameter feature_ids_path: Specifies to which Feature each Element belongs :param nx.BoolParameter find_histogram: Whether to compute the histogram of the input array :param nx.BoolParameter find_length: Whether to compute the length of the input array :param nx.BoolParameter find_max: Whether to compute the maximum of the input array :param nx.BoolParameter find_mean: Whether to compute the arithmetic mean of the input array :param nx.BoolParameter find_median: Whether to compute the median of the input array :param nx.BoolParameter find_min: Whether to compute the minimum of the input array :param nx.BoolParameter find_modal_bin_ranges: Whether to compute the histogram bin ranges that contain the mode values. This option requires that " Find Mode " is turned on. :param nx.BoolParameter find_mode: Whether to compute the mode of the input array :param nx.BoolParameter find_std_deviation: Whether to compute the standard deviation of the input array :param nx.BoolParameter find_summation: Whether to compute the summation of the input array :param nx.BoolParameter find_unique_values: Whether to compute the number of unique values in the input array :param nx.DataObjectNameParameter histogram_bin_count_name: The name of the histogram bin counts array :param nx.DataObjectNameParameter histogram_bin_range_name: The name of the histogram bin ranges array :param nx.DataObjectNameParameter length_array_name: The name of the length array :param nx.ArraySelectionParameter mask_array_path: DataPath to the boolean mask array. Values that are true will mark that cell/point as usable. :param nx.Float64Parameter max_range: Max cutoff value for histogram :param nx.DataObjectNameParameter maximum_array_name: The name of the maximum array :param nx.DataObjectNameParameter mean_array_name: The name of the mean array :param nx.DataObjectNameParameter median_array_name: The name of the median array :param nx.Float64Parameter min_range: Min cutoff value for histogram :param nx.DataObjectNameParameter minimum_array_name: The name of the minimum array :param nx.DataObjectNameParameter modal_bin_array_name: The name of the array that stores the histogram bin range(s) that contain the mode(s) of the data. :param nx.DataObjectNameParameter mode_array_name: The name of the mode array :param nx.DataObjectNameParameter most_populated_bin_array_name: The name of the Most Populated Bin array :param nx.Int32Parameter num_bins: Number of bins in histogram :param nx.DataObjectNameParameter number_unique_values_name: The name of the array which stores the calculated number of unique values :param nx.ArraySelectionParameter selected_array_path: Input Attribute Array for which to compute statistics :param nx.BoolParameter standardize_data: Should a standardized data array be generated :param nx.DataObjectNameParameter standardized_array_name: The name of the standardized data array :param nx.DataObjectNameParameter std_deviation_array_name: The name of the standard deviation array :param nx.DataObjectNameParameter summation_array_name: The name of the summation array :param nx.BoolParameter use_full_range: If true, ignore min and max and use min and max from array upon which histogram is computed :param nx.BoolParameter use_mask: Specifies whether or not to use a mask array :return: Returns a :ref:`nx.IFilter.ExecuteResult ` object that holds any warnings and/or errors that were encountered during execution. :rtype: :ref:`nx.IFilter.ExecuteResult ` Compute Biased Features (Bounding Box) -------------------------------------- .. index:: pair: Filter Human Names; Compute Biased Features (Bounding Box) .. index:: pair: Filter Class Names; ComputeBiasedFeaturesFilter .. _ComputeBiasedFeaturesFilter: .. py:class:: 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 | +----------------------+-----------------------------+ .. py:method:: Execute(data_structure, biased_features_array_name, calc_by_phase, centroids_array_path, input_image_geometry_path, phases_array_path, surface_features_array_path) :param DataStructure data_structure: The DataStructure object that holds the data to be processed. :param nx.DataObjectNameParameter biased_features_array_name: Flag of 1 if Feature is biased or of 0 if it is not :param nx.BoolParameter calc_by_phase: Whether to apply the biased Features algorithm per Ensemble :param nx.ArraySelectionParameter centroids_array_path: X, Y, Z coordinates of Feature center of mass :param nx.GeometrySelectionParameter input_image_geometry_path: The selected geometry in which to the (biased) features belong :param nx.ArraySelectionParameter phases_array_path: Specifies to which Ensemble each Feature belongs. Only required if Apply Phase by Phase is checked :param nx.ArraySelectionParameter surface_features_array_path: Flag of 1 if Feature touches an outer surface or of 0 if it does not :return: Returns a :ref:`nx.IFilter.ExecuteResult ` object that holds any warnings and/or errors that were encountered during execution. :rtype: :ref:`nx.IFilter.ExecuteResult ` Compute Boundary Cells (Image) ------------------------------ .. index:: pair: Filter Human Names; Compute Boundary Cells (Image) .. index:: pair: Filter Class Names; ComputeBoundaryCellsFilter .. _ComputeBoundaryCellsFilter: .. py:class:: 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 | +-------------------------+---------------------------+ .. py:method:: Execute(data_structure, boundary_cells_array_name, feature_ids_array_path, ignore_feature_zero, include_volume_boundary, input_image_geometry_path) :param DataStructure data_structure: The DataStructure object that holds the data to be processed. :param nx.DataObjectNameParameter boundary_cells_array_name: The number of neighboring Cells of a given Cell that belong to a different Feature than itself. Values will range from 0 to 6 :param nx.ArraySelectionParameter feature_ids_array_path: Data Array that specifies to which Feature each Element belongs :param nx.BoolParameter ignore_feature_zero: Do not use feature 0 :param nx.BoolParameter include_volume_boundary: Include the Cell boundaries :param nx.GeometrySelectionParameter input_image_geometry_path: The selected geometry to which the cells belong :return: Returns a :ref:`nx.IFilter.ExecuteResult ` object that holds any warnings and/or errors that were encountered during execution. :rtype: :ref:`nx.IFilter.ExecuteResult ` Compute Feature Boundary Element Fractions ------------------------------------------ .. index:: pair: Filter Human Names; Compute Feature Boundary Element Fractions .. index:: pair: Filter Class Names; ComputeBoundaryElementFractionsFilter .. _ComputeBoundaryElementFractionsFilter: .. py:class:: 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 | +---------------------------+------------------------------------+ .. py:method:: Execute(data_structure, boundary_cell_fractions_array_name, boundary_cells_array_path, feature_data_attribute_matrix_path, feature_ids_array_path) :param DataStructure data_structure: The DataStructure object that holds the data to be processed. :param nx.DataObjectNameParameter boundary_cell_fractions_array_name: Name of created Data Array containing fraction of Elements belonging to the Feature that are "surface" Elements :param nx.ArraySelectionParameter boundary_cells_array_path: DataArray containing the number of neighboring Elements of a given Element that belong to a different Feature than itself :param nx.AttributeMatrixSelectionParameter feature_data_attribute_matrix_path: Parent Attribute Matrix for the Surface Element Fractions Array to be created in :param nx.ArraySelectionParameter feature_ids_array_path: Data Array that specifies to which Feature each Element belongs :return: Returns a :ref:`nx.IFilter.ExecuteResult ` object that holds any warnings and/or errors that were encountered during execution. :rtype: :ref:`nx.IFilter.ExecuteResult ` Compute Differences Map ----------------------- .. index:: pair: Filter Human Names; Compute Differences Map .. index:: pair: Filter Class Names; ComputeDifferencesMapFilter .. _ComputeDifferencesMapFilter: .. py:class:: 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 | +--------------------+---------------------------+ .. py:method:: Execute(data_structure, difference_map_array_path, first_input_array_path, second_input_array_path) :param DataStructure data_structure: The DataStructure object that holds the data to be processed. :param nx.ArrayCreationParameter difference_map_array_path: DataPath for created Difference Map DataArray :param nx.ArraySelectionParameter first_input_array_path: DataPath to the first input DataArray :param nx.ArraySelectionParameter second_input_array_path: DataPath to the second input DataArray :return: Returns a :ref:`nx.IFilter.ExecuteResult ` object that holds any warnings and/or errors that were encountered during execution. :rtype: :ref:`nx.IFilter.ExecuteResult ` Compute Euclidean Distance Map ------------------------------ .. index:: pair: Filter Human Names; Compute Euclidean Distance Map .. index:: pair: Filter Class Names; ComputeEuclideanDistMapFilter .. _ComputeEuclideanDistMapFilter: .. py:class:: 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 | +----------------------------------------------+------------------------------+ .. py:method:: 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) :param DataStructure data_structure: The DataStructure object that holds the data to be processed. :param nx.BoolParameter calc_manhattan_dist: If Manhattan distance is used then results are stored as int32 otherwise results are stored as float32 :param nx.BoolParameter do_boundaries: Whether the distance of each Cell to a Feature boundary is calculated :param nx.BoolParameter do_quad_points: Whether the distance of each Cell to a quadruple point between Features is calculated :param nx.BoolParameter do_triple_lines: Whether the distance of each Cell to a triple line between Features is calculated :param nx.ArraySelectionParameter feature_ids_path: Specifies to which Feature each cell belongs :param nx.DataObjectNameParameter g_bdistances_array_name: The name of the array with the distance the cells are from the boundary of the Feature they belong to. :param nx.GeometrySelectionParameter input_image_geometry_path: The target geometry :param nx.DataObjectNameParameter nearest_neighbors_array_name: The name of the array with the indices of the closest cell that touches a boundary, triple and quadruple point for each cell. :param nx.DataObjectNameParameter q_pdistances_array_name: The name of the array with the distance the cells are from a quadruple point of Features. :param nx.BoolParameter save_nearest_neighbors: Whether to store the nearest neighbors of Cell :param nx.DataObjectNameParameter t_jdistances_array_name: The name of the array with the distance the cells are from a triple junction of Features. :return: Returns a :ref:`nx.IFilter.ExecuteResult ` object that holds any warnings and/or errors that were encountered during execution. :rtype: :ref:`nx.IFilter.ExecuteResult ` Compute Feature Centroids ------------------------- .. index:: pair: Filter Human Names; Compute Feature Centroids .. index:: pair: Filter Class Names; ComputeFeatureCentroidsFilter .. _ComputeFeatureCentroidsFilter: .. py:class:: 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 | +--------------------------+-------------------------------+ .. py:method:: Execute(data_structure, centroids_array_name, feature_attribute_matrix_path, feature_ids_path, input_image_geometry_path) :param DataStructure data_structure: The DataStructure object that holds the data to be processed. :param nx.DataObjectNameParameter centroids_array_name: DataPath to create the 'Centroids' output array :param nx.AttributeMatrixSelectionParameter feature_attribute_matrix_path: The cell feature attribute matrix :param nx.ArraySelectionParameter feature_ids_path: Specifies to which Feature each cell belongs :param nx.GeometrySelectionParameter input_image_geometry_path: The target geometry whose Features' centroids will be calculated :return: Returns a :ref:`nx.IFilter.ExecuteResult ` object that holds any warnings and/or errors that were encountered during execution. :rtype: :ref:`nx.IFilter.ExecuteResult ` Compute Feature Clustering -------------------------- .. index:: pair: Filter Human Names; Compute Feature Clustering .. index:: pair: Filter Class Names; ComputeFeatureClusteringFilter .. _ComputeFeatureClusteringFilter: .. py:class:: 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 | +----------------------------------+-------------------------------------+ .. py:method:: 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) :param DataStructure data_structure: The DataStructure object that holds the data to be processed. :param nx.ArraySelectionParameter biased_features_array_path: Specifies which features are biased and therefor should be removed if the Remove Biased Features option is on; True values removed :param nx.AttributeMatrixSelectionParameter cell_ensemble_attribute_matrix_path: The path to the cell ensemble attribute matrix where the RDF and RDF min and max distance arrays will be stored :param nx.ArraySelectionParameter centroids_array_path: X, Y, Z coordinates of Feature center of mass :param nx.DataObjectNameParameter clustering_list_array_name: Distance of each Feature's centroid to every other Feature's centroid :param nx.ArraySelectionParameter feature_phases_array_path: Specifies to which Ensemble each Feature belongs :param nx.GeometrySelectionParameter input_image_geometry_path: The target geometry :param nx.DataObjectNameParameter max_min_array_name: The max and min distance found between Features :param nx.Int32Parameter number_of_bins: Number of bins to split the RDF :param nx.Int32Parameter phase_number: Ensemble number for which to calculate the RDF and clustering list :param nx.DataObjectNameParameter rdf_array_name: A histogram of the normalized frequency at each bin :param nx.BoolParameter remove_biased_features: Remove the biased features :param nx.DataObjectNameParameter seed_array_name: Name of array holding the seed value :param nx.UInt64Parameter seed_value: The seed value used to randomly generate the points in the RDF :param nx.BoolParameter set_random_seed: When checked, allows the user to set the seed value used to randomly generate the points in the RDF :return: Returns a :ref:`nx.IFilter.ExecuteResult ` object that holds any warnings and/or errors that were encountered during execution. :rtype: :ref:`nx.IFilter.ExecuteResult ` Compute Feature Neighbors ------------------------- .. index:: pair: Filter Human Names; Compute Feature Neighbors .. index:: pair: Filter Class Names; ComputeFeatureNeighborsFilter .. _ComputeFeatureNeighborsFilter: .. py:class:: 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 | +------------------------------+-------------------------------+ .. py:method:: 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) :param DataStructure data_structure: The DataStructure object that holds the data to be processed. :param nx.DataObjectNameParameter boundary_cells_name: 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 :param nx.AttributeMatrixSelectionParameter cell_feature_array_path: Feature Attribute Matrix of the selected Feature Ids :param nx.ArraySelectionParameter feature_ids_path: Specifies to which Feature each cell belongs :param nx.GeometrySelectionParameter input_image_geometry_path: The geometry in which to identify feature neighbors :param nx.DataObjectNameParameter neighbor_list_name: List of the contiguous neighboring Features for a given Feature :param nx.DataObjectNameParameter number_of_neighbors_name: Number of contiguous neighboring Features for a given Feature :param nx.DataObjectNameParameter shared_surface_area_list_name: List of the shared surface area for each of the contiguous neighboring Features for a given Feature :param nx.BoolParameter store_boundary_cells: Whether to store the boundary Cells array :param nx.BoolParameter store_surface_features: Whether to store the surface Features array :param nx.DataObjectNameParameter surface_features_name: 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 :return: Returns a :ref:`nx.IFilter.ExecuteResult ` object that holds any warnings and/or errors that were encountered during execution. :rtype: :ref:`nx.IFilter.ExecuteResult ` Compute Feature Phases Binary ----------------------------- .. index:: pair: Filter Human Names; Compute Feature Phases Binary .. index:: pair: Filter Class Names; ComputeFeaturePhasesBinaryFilter .. _ComputeFeaturePhasesBinaryFilter: .. py:class:: 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 | +----------------------------------+---------------------------------+ .. py:method:: Execute(data_structure, cell_data_attribute_matrix_path, feature_ids_array_path, feature_phases_array_name, mask_array_path) :param DataStructure data_structure: The DataStructure object that holds the data to be processed. :param nx.AttributeMatrixSelectionParameter cell_data_attribute_matrix_path: The Cell Data Attribute Matrix within the Image Geometry where the Binary Phases Array will be created :param nx.ArraySelectionParameter feature_ids_array_path: Data Array that specifies to which Feature each Element belongs :param nx.DataObjectNameParameter feature_phases_array_name: Created Data Array name to specify to which Ensemble each Feature belongs :param nx.ArraySelectionParameter mask_array_path: Data Array that specifies if the Cell is to be counted in the algorithm :return: Returns a :ref:`nx.IFilter.ExecuteResult ` object that holds any warnings and/or errors that were encountered during execution. :rtype: :ref:`nx.IFilter.ExecuteResult ` Compute Feature Phases ---------------------- .. index:: pair: Filter Human Names; Compute Feature Phases .. index:: pair: Filter Class Names; ComputeFeaturePhasesFilter .. _ComputeFeaturePhasesFilter: .. py:class:: 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 | +--------------------------+-------------------------------------+ .. py:method:: Execute(data_structure, cell_features_attribute_matrix_path, cell_phases_array_path, feature_ids_path, feature_phases_array_name) :param DataStructure data_structure: The DataStructure object that holds the data to be processed. :param nx.AttributeMatrixSelectionParameter cell_features_attribute_matrix_path: The AttributeMatrix that stores the feature data for the input **Feature Ids**. :param nx.ArraySelectionParameter cell_phases_array_path: Specifies to which Ensemble each Element belongs :param nx.ArraySelectionParameter feature_ids_path: Specifies to which Feature each Element belongs :param nx.DataObjectNameParameter feature_phases_array_name: The name of the feature attribute matrix in which to store the found feature phases array :return: Returns a :ref:`nx.IFilter.ExecuteResult ` object that holds any warnings and/or errors that were encountered during execution. :rtype: :ref:`nx.IFilter.ExecuteResult ` Compute Feature Corners ----------------------- .. index:: pair: Filter Human Names; Compute Feature Corners .. index:: pair: Filter Class Names; ComputeFeatureRectFilter .. _ComputeFeatureRectFilter: .. py:class:: 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 | +-------------------------------+------------------------------------+ .. py:method:: Execute(data_structure, feature_data_attribute_matrix_path, feature_ids_array_path, feature_rect_array_name) :param DataStructure data_structure: The DataStructure object that holds the data to be processed. :param nx.AttributeMatrixSelectionParameter feature_data_attribute_matrix_path: The path to the feature data attribute matrix associated with the input feature ids array :param nx.ArraySelectionParameter feature_ids_array_path: Data Array that specifies to which Feature each Element belongs :param nx.DataObjectNameParameter feature_rect_array_name: The feature rect calculated from the feature ids :return: Returns a :ref:`nx.IFilter.ExecuteResult ` object that holds any warnings and/or errors that were encountered during execution. :rtype: :ref:`nx.IFilter.ExecuteResult ` Compute Feature Sizes --------------------- .. index:: pair: Filter Human Names; Compute Feature Sizes .. index:: pair: Filter Class Names; ComputeFeatureSizesFilter .. _ComputeFeatureSizesFilter: .. py:class:: 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 | +--------------------------------+-------------------------------+ .. py:method:: 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) :param DataStructure data_structure: The DataStructure object that holds the data to be processed. :param nx.DataObjectNameParameter equivalent_diameters_name: DataPath to equivalent diameters array :param nx.AttributeMatrixSelectionParameter feature_attribute_matrix_path: Feature Attribute Matrix of the selected Feature Ids :param nx.ArraySelectionParameter feature_ids_path: Specifies to which Feature each Element belongs :param nx.GeometrySelectionParameter input_image_geometry_path: DataPath to input Image Geometry :param nx.DataObjectNameParameter num_elements_name: DataPath to Num Elements array :param nx.BoolParameter save_element_sizes: If checked this will generate and store the element sizes ONLY if the geometry does not already contain them. :param nx.DataObjectNameParameter volumes_name: DataPath to volumes array :return: Returns a :ref:`nx.IFilter.ExecuteResult ` object that holds any warnings and/or errors that were encountered during execution. :rtype: :ref:`nx.IFilter.ExecuteResult ` Compute K Means --------------- .. index:: pair: Filter Human Names; Compute K Means .. index:: pair: Filter Class Names; ComputeKMeansFilter .. _ComputeKMeansFilter: .. py:class:: 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 | +--------------------------------+-------------------------------+ .. py:method:: 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) :param DataStructure data_structure: The DataStructure object that holds the data to be processed. :param nx.ChoicesParameter distance_metric_index: Distance Metric type to be used for calculations :param nx.DataGroupCreationParameter feature_attribute_matrix_path: name and path of Attribute Matrix to hold Cluster Data :param nx.DataObjectNameParameter feature_ids_array_name: name of the ids array to be created in Attribute Array to Cluster's parent group :param nx.UInt64Parameter init_clusters: This will be the tuple size for Cluster Attribute Matrix and the values within :param nx.ArraySelectionParameter mask_array_path: DataPath to the boolean or uint8 mask array. Values that are true will mark that cell/point as usable. :param nx.DataObjectNameParameter means_array_name: name of the Means array to be created in Cluster Attribute Matrix :param nx.DataObjectNameParameter seed_array_name: Name of array holding the seed value :param nx.UInt64Parameter seed_value: The seed fed into the random generator :param nx.ArraySelectionParameter selected_array_path: The array to cluster from :param nx.BoolParameter use_mask: Specifies whether or not to use a mask array :param nx.BoolParameter use_seed: When true the user will be able to put in a seed for random generation :return: Returns a :ref:`nx.IFilter.ExecuteResult ` object that holds any warnings and/or errors that were encountered during execution. :rtype: :ref:`nx.IFilter.ExecuteResult ` Compute K Medoids ----------------- .. index:: pair: Filter Human Names; Compute K Medoids .. index:: pair: Filter Class Names; ComputeKMedoidsFilter .. _ComputeKMedoidsFilter: .. py:class:: 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 | +--------------------------------+-------------------------------+ .. py:method:: 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) :param DataStructure data_structure: The DataStructure object that holds the data to be processed. :param nx.ChoicesParameter distance_metric_index: Distance Metric type to be used for calculations :param nx.DataGroupCreationParameter feature_attribute_matrix_path: name and path of Attribute Matrix to hold Cluster Data :param nx.DataObjectNameParameter feature_ids_array_name: name of the ids array to be created in Attribute Array to Cluster's parent group :param nx.UInt64Parameter init_clusters: This will be the tuple size for Cluster Attribute Matrix and the values within :param nx.ArraySelectionParameter mask_array_path: DataPath to the boolean or uint8 mask array. Values that are true will mark that cell/point as usable. :param nx.DataObjectNameParameter medoids_array_name: name of the medoids array to be created in Cluster Attribute Matrix :param nx.DataObjectNameParameter seed_array_name: Name of array holding the seed value :param nx.UInt64Parameter seed_value: The seed fed into the random generator :param nx.ArraySelectionParameter selected_array_path: The array to find the medoids for :param nx.BoolParameter use_mask: Specifies whether or not to use a mask array :param nx.BoolParameter use_seed: When true the user will be able to put in a seed for random generation :return: Returns a :ref:`nx.IFilter.ExecuteResult ` object that holds any warnings and/or errors that were encountered during execution. :rtype: :ref:`nx.IFilter.ExecuteResult ` Compute Feature Largest Cross-Section Areas ------------------------------------------- .. index:: pair: Filter Human Names; Compute Feature Largest Cross-Section Areas .. index:: pair: Filter Class Names; ComputeLargestCrossSectionsFilter .. _ComputeLargestCrossSectionsFilter: .. py:class:: 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 | +--------------------------+------------------------------------+ .. py:method:: Execute(data_structure, cell_feature_attribute_matrix_path, feature_ids_array_path, input_image_geometry_path, largest_cross_sections_array_name, plane_index) :param DataStructure data_structure: The DataStructure object that holds the data to be processed. :param nx.AttributeMatrixSelectionParameter cell_feature_attribute_matrix_path: The path to the cell feature attribute matrix :param nx.ArraySelectionParameter feature_ids_array_path: Data Array that specifies to which Feature each Element belongs :param nx.GeometrySelectionParameter input_image_geometry_path: The complete path to the input image geometry :param nx.DataObjectNameParameter largest_cross_sections_array_name: Area of largest cross-section for Feature perpendicular to the user specified direction :param nx.ChoicesParameter plane_index: Specifies which plane to consider when determining the maximum cross-section for each Feature :return: Returns a :ref:`nx.IFilter.ExecuteResult ` object that holds any warnings and/or errors that were encountered during execution. :rtype: :ref:`nx.IFilter.ExecuteResult ` Compute Moment Invariants (2D) ------------------------------ .. index:: pair: Filter Human Names; Compute Moment Invariants (2D) .. index:: pair: Filter Class Names; ComputeMomentInvariants2DFilter .. _ComputeMomentInvariants2DFilter: .. py:class:: 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 | +-----------------------------+-------------------------------+ .. py:method:: 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) :param DataStructure data_structure: The DataStructure object that holds the data to be processed. :param nx.DataObjectNameParameter central_moments_array_name: Central Moments value :param nx.AttributeMatrixSelectionParameter feature_attribute_matrix_path: The path to the cell feature attribute matrix where the created data arrays will be stored :param nx.ArraySelectionParameter feature_ids_array_path: Data Array that specifies to which Feature each Element belongs :param nx.ArraySelectionParameter feature_rect_array_path: Array holding the min xy and max xy pixel coordinates of each feature id :param nx.GeometrySelectionParameter input_image_geometry_path: The path to the 2D image geometry to be used as input :param nx.BoolParameter normalize_moment_invariants: Should the algorithm normalize the results to unit circle. :param nx.DataObjectNameParameter omega1_array_name: Omega1 value :param nx.DataObjectNameParameter omega2_array_name: Omega2 value :param nx.BoolParameter save_central_moments: Write the Central Moments to a new Data Array :return: Returns a :ref:`nx.IFilter.ExecuteResult ` object that holds any warnings and/or errors that were encountered during execution. :rtype: :ref:`nx.IFilter.ExecuteResult ` Compute Neighbor List Statistics -------------------------------- .. index:: pair: Filter Human Names; Compute Neighbor List Statistics .. index:: pair: Filter Class Names; ComputeNeighborListStatisticsFilter .. _ComputeNeighborListStatisticsFilter: .. py:class:: 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 | +------------------------------------+-------------------------------+ .. py:method:: 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) :param DataStructure data_structure: The DataStructure object that holds the data to be processed. :param nx.BoolParameter find_length: Specifies whether or not the filter creates the Length array during calculations :param nx.BoolParameter find_maximum: Specifies whether or not the filter creates the Maximum array during calculations :param nx.BoolParameter find_mean: Specifies whether or not the filter creates the Mean array during calculations :param nx.BoolParameter find_median: Specifies whether or not the filter creates the Median array during calculations :param nx.BoolParameter find_minimum: Specifies whether or not the filter creates the Minimum array during calculations :param nx.BoolParameter find_standard_deviation: Specifies whether or not the filter creates the Standard Deviation array during calculations :param nx.BoolParameter find_summation: Specifies whether or not the filter creates the Summation array during calculations :param nx.NeighborListSelectionParameter input_neighbor_list_path: Input Data Array to compute statistics :param nx.DataObjectNameParameter length_array_name: Path to create the Length array during calculations :param nx.DataObjectNameParameter maximum_array_name: Path to create the Maximum array during calculations :param nx.DataObjectNameParameter mean_array_name: Path to create the Mean array during calculations :param nx.DataObjectNameParameter median_array_name: Path to create the Median array during calculations :param nx.DataObjectNameParameter minimum_array_name: Path to create the Minimum array during calculations :param nx.DataObjectNameParameter standard_deviation_array_name: Path to create the Standard Deviation array during calculations :param nx.DataObjectNameParameter summation_array_name: Path to create the Summation array during calculations :return: Returns a :ref:`nx.IFilter.ExecuteResult ` object that holds any warnings and/or errors that were encountered during execution. :rtype: :ref:`nx.IFilter.ExecuteResult ` Compute Feature Neighborhoods ----------------------------- .. index:: pair: Filter Human Names; Compute Feature Neighborhoods .. index:: pair: Filter Class Names; ComputeNeighborhoodsFilter .. _ComputeNeighborhoodsFilter: .. py:class:: 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 | +-------------------------------+---------------------------------+ .. py:method:: 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) :param DataStructure data_structure: The DataStructure object that holds the data to be processed. :param nx.ArraySelectionParameter centroids_array_path: Path to the array specifying the X, Y, Z coordinates of Feature center of mass :param nx.ArraySelectionParameter equivalent_diameters_array_path: Path to the array specifying the diameter of a sphere with the same volume as the Feature :param nx.ArraySelectionParameter feature_phases_array_path: Path to the array specifying to which Ensemble each Feature belongs :param nx.GeometrySelectionParameter input_image_geometry_path: The target geometry :param nx.Float32Parameter multiples_of_average: Defines the search radius to use when looking for 'neighboring' Features :param nx.DataObjectNameParameter neighborhood_list_array_name: List of the Features whose centroids are within the user specified multiple of equivalent sphere diameter from each Feature :param nx.DataObjectNameParameter neighborhoods_array_name: Number of Features that have their centroid within the user specified multiple of equivalent sphere diameters from each Feature :return: Returns a :ref:`nx.IFilter.ExecuteResult ` object that holds any warnings and/or errors that were encountered during execution. :rtype: :ref:`nx.IFilter.ExecuteResult ` Compute Number of Features -------------------------- .. index:: pair: Filter Human Names; Compute Number of Features .. index:: pair: Filter Class Names; ComputeNumFeaturesFilter .. _ComputeNumFeaturesFilter: .. py:class:: 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 | +---------------------------+--------------------------------+ .. py:method:: Execute(data_structure, ensemble_attribute_matrix_path, feature_phases_array_path, num_features_array_name) :param DataStructure data_structure: The DataStructure object that holds the data to be processed. :param nx.AttributeMatrixSelectionParameter ensemble_attribute_matrix_path: The path to the ensemble attribute matrix where the number of features array will be stored :param nx.ArraySelectionParameter feature_phases_array_path: Array specifying which Ensemble each Feature belongs :param nx.DataObjectNameParameter num_features_array_name: The number of Features that belong to each Ensemble :return: Returns a :ref:`nx.IFilter.ExecuteResult ` object that holds any warnings and/or errors that were encountered during execution. :rtype: :ref:`nx.IFilter.ExecuteResult ` Compute Surface Area to Volume & Sphericity ------------------------------------------- .. index:: pair: Filter Human Names; Compute Surface Area to Volume & Sphericity .. index:: pair: Filter Class Names; ComputeSurfaceAreaToVolumeFilter .. _ComputeSurfaceAreaToVolumeFilter: .. py:class:: 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 | +------------------------------+--------------------------------------+ .. py:method:: 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) :param DataStructure data_structure: The DataStructure object that holds the data to be processed. :param nx.BoolParameter calculate_sphericity: Whether or not to calculate the sphericity of each Feature :param nx.ArraySelectionParameter feature_ids_path: Specifies to which Feature each cell belongs :param nx.GeometrySelectionParameter input_image_geometry_path: The target geometry :param nx.ArraySelectionParameter num_cells_array_path: 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 :param nx.DataObjectNameParameter sphericity_array_name: The sphericity of each feature :param nx.DataObjectNameParameter surface_area_volume_ratio_array_name: Ratio of surface area to volume for each Feature. The units are inverse length :return: Returns a :ref:`nx.IFilter.ExecuteResult ` object that holds any warnings and/or errors that were encountered during execution. :rtype: :ref:`nx.IFilter.ExecuteResult ` Compute Surface Features ------------------------ .. index:: pair: Filter Human Names; Compute Surface Features .. index:: pair: Filter Class Names; ComputeSurfaceFeaturesFilter .. _ComputeSurfaceFeaturesFilter: .. py:class:: 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 | +--------------------------+-------------------------------+ .. py:method:: Execute(data_structure, feature_attribute_matrix_path, feature_ids_path, input_image_geometry_path, mark_feature_0_neighbors, surface_features_array_name) :param DataStructure data_structure: The DataStructure object that holds the data to be processed. :param nx.AttributeMatrixSelectionParameter feature_attribute_matrix_path: The path to the cell feature attribute matrix associated with the input feature ids array :param nx.ArraySelectionParameter feature_ids_path: Specifies to which Feature each cell belongs :param nx.GeometrySelectionParameter input_image_geometry_path: The geometry in which to find surface features :param nx.BoolParameter mark_feature_0_neighbors: 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. :param nx.DataObjectNameParameter surface_features_array_name: The created surface features array. Flag of 1 if Feature touches an outer surface or of 0 if it does not :return: Returns a :ref:`nx.IFilter.ExecuteResult ` object that holds any warnings and/or errors that were encountered during execution. :rtype: :ref:`nx.IFilter.ExecuteResult ` Compute Triangle Areas ---------------------- .. index:: pair: Filter Human Names; Compute Triangle Areas .. index:: pair: Filter Class Names; ComputeTriangleAreasFilter .. _ComputeTriangleAreasFilter: .. py:class:: 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 | +--------------------+------------------------------+ .. py:method:: Execute(data_structure, input_triangle_geometry_path, triangle_areas_array_name) :param DataStructure data_structure: The DataStructure object that holds the data to be processed. :param nx.GeometrySelectionParameter input_triangle_geometry_path: The complete path to the Geometry for which to calculate the face areas :param nx.DataObjectNameParameter triangle_areas_array_name: The complete path to the array storing the calculated face areas :return: Returns a :ref:`nx.IFilter.ExecuteResult ` object that holds any warnings and/or errors that were encountered during execution. :rtype: :ref:`nx.IFilter.ExecuteResult ` Compute Feature Centroids from Triangle Geometry ------------------------------------------------ .. index:: pair: Filter Human Names; Compute Feature Centroids from Triangle Geometry .. index:: pair: Filter Class Names; ComputeTriangleGeomCentroidsFilter .. _ComputeTriangleGeomCentroidsFilter: .. py:class:: 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 | +-------------------------------+-------------------------------+ .. py:method:: Execute(data_structure, centroids_array_name, face_labels_array_path, feature_attribute_matrix_path, input_triangle_geometry_path) :param DataStructure data_structure: The DataStructure object that holds the data to be processed. :param nx.DataObjectNameParameter centroids_array_name: Centroid values created in the Face Feature Data :param nx.ArraySelectionParameter face_labels_array_path: The DataPath to the FaceLabels values. :param nx.AttributeMatrixSelectionParameter feature_attribute_matrix_path: The DataPath to the AttributeMatrix that holds feature data for the faces :param nx.GeometrySelectionParameter input_triangle_geometry_path: The complete path to the Geometry for which to calculate the normals :return: Returns a :ref:`nx.IFilter.ExecuteResult ` object that holds any warnings and/or errors that were encountered during execution. :rtype: :ref:`nx.IFilter.ExecuteResult ` Compute Feature Volumes from Triangle Geometry ---------------------------------------------- .. index:: pair: Filter Human Names; Compute Feature Volumes from Triangle Geometry .. index:: pair: Filter Class Names; ComputeTriangleGeomVolumesFilter .. _ComputeTriangleGeomVolumesFilter: .. py:class:: 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 | +-------------------------------+-------------------------------+ .. py:method:: Execute(data_structure, face_labels_array_path, feature_attribute_matrix_path, input_triangle_geometry_path, volumes_array_name) :param DataStructure data_structure: The DataStructure object that holds the data to be processed. :param nx.ArraySelectionParameter face_labels_array_path: The DataPath to the FaceLabels values. :param nx.AttributeMatrixSelectionParameter feature_attribute_matrix_path: The DataPath to the AttributeMatrix that holds feature data for the faces :param nx.GeometrySelectionParameter input_triangle_geometry_path: The complete path to the Geometry for which to calculate the normals :param nx.DataObjectNameParameter volumes_array_name: Calculated volumes data created in the Face Feature Data Attribute Matrix :return: Returns a :ref:`nx.IFilter.ExecuteResult ` object that holds any warnings and/or errors that were encountered during execution. :rtype: :ref:`nx.IFilter.ExecuteResult ` Generate Vector Colors ---------------------- .. index:: pair: Filter Human Names; Generate Vector Colors .. index:: pair: Filter Class Names; ComputeVectorColorsFilter .. _ComputeVectorColorsFilter: .. py:class:: 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 | +------------------------------------------------------+-------------------------------+ .. py:method:: Execute(data_structure, cell_vector_colors_array_name, mask_array_path, use_mask, vectors_array_path) :param DataStructure data_structure: The DataStructure object that holds the data to be processed. :param nx.DataObjectNameParameter cell_vector_colors_array_name: RGB colors :param nx.ArraySelectionParameter mask_array_path: Used to define Elements as good or bad :param nx.BoolParameter use_mask: Whether or not to assign colors to bad voxels or leave them black :param nx.ArraySelectionParameter vectors_array_path: Vectors the colors will represent :return: Returns a :ref:`nx.IFilter.ExecuteResult ` object that holds any warnings and/or errors that were encountered during execution. :rtype: :ref:`nx.IFilter.ExecuteResult ` Compute Vertex to Triangle Distances ------------------------------------ .. index:: pair: Filter Human Names; Compute Vertex to Triangle Distances .. index:: pair: Filter Class Names; ComputeVertexToTriangleDistancesFilter .. _ComputeVertexToTriangleDistancesFilter: .. py:class:: 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 | +----------------------------+--------------------------------+ .. py:method:: Execute(data_structure, closest_triangle_id_array_name, distances_array_name, input_triangle_geometry_path, input_vertex_geometry_path, triangle_normals_array_path) :param DataStructure data_structure: The DataStructure object that holds the data to be processed. :param nx.DataObjectNameParameter closest_triangle_id_array_name: The array to store the ID of the closest triangle :param nx.DataObjectNameParameter distances_array_name: The array to store distance between vertex and triangle :param nx.GeometrySelectionParameter input_triangle_geometry_path: The triangle geometry to compare against :param nx.GeometrySelectionParameter input_vertex_geometry_path: The Vertex Geometry point cloud to map to triangles :param nx.ArraySelectionParameter triangle_normals_array_path: The triangle geometry's normals array :return: Returns a :ref:`nx.IFilter.ExecuteResult ` object that holds any warnings and/or errors that were encountered during execution. :rtype: :ref:`nx.IFilter.ExecuteResult ` Compute Volume Fractions of Ensembles ------------------------------------- .. index:: pair: Filter Human Names; Compute Volume Fractions of Ensembles .. index:: pair: Filter Class Names; ComputeVolumeFractionsFilter .. _ComputeVolumeFractionsFilter: .. py:class:: 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 | +--------------------------------+-------------------------------------+ .. py:method:: Execute(data_structure, cell_ensemble_attribute_matrix_path, cell_phases_array_path, vol_fractions_array_name) :param DataStructure data_structure: The DataStructure object that holds the data to be processed. :param nx.AttributeMatrixSelectionParameter cell_ensemble_attribute_matrix_path: The path to the cell ensemble attribute matrix where the output volume fractions array will be stored :param nx.ArraySelectionParameter cell_phases_array_path: Array specifying which Ensemble each Cell belong :param nx.DataObjectNameParameter vol_fractions_array_name: Fraction of volume that belongs to each Ensemble :return: Returns a :ref:`nx.IFilter.ExecuteResult ` object that holds any warnings and/or errors that were encountered during execution. :rtype: :ref:`nx.IFilter.ExecuteResult ` Concatenate Data Arrays ----------------------- .. index:: pair: Filter Human Names; Concatenate Data Arrays .. index:: pair: Filter Class Names; ConcatenateDataArraysFilter .. _ConcatenateDataArraysFilter: .. py:class:: 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 | +-----------------------+-----------------------+ .. py:method:: Execute(data_structure, input_arrays, output_array_path) :param DataStructure data_structure: The DataStructure object that holds the data to be processed. :param nx.MultiArraySelectionParameter input_arrays: Select the arrays that will be concatenated together. The arrays will be concatenated in the order they are listed here. :param nx.ArrayCreationParameter output_array_path: The output array that contains the concatenated arrays. :return: Returns a :ref:`nx.IFilter.ExecuteResult ` object that holds any warnings and/or errors that were encountered during execution. :rtype: :ref:`nx.IFilter.ExecuteResult ` Replace Value in Array (Conditional) ------------------------------------ .. index:: pair: Filter Human Names; Replace Value in Array (Conditional) .. index:: pair: Filter Class Names; ConditionalSetValueFilter .. _ConditionalSetValueFilter: .. py:class:: 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 | +----------------------+------------------------+ .. py:method:: Execute(data_structure, conditional_array_path, invert_mask, remove_value, replace_value, selected_array_path, use_conditional) :param DataStructure data_structure: The DataStructure object that holds the data to be processed. :param nx.ArraySelectionParameter conditional_array_path: The complete path to the conditional array that will determine which values/entries will be replaced if index is TRUE :param nx.BoolParameter invert_mask: This makes the filter replace values that are marked FALSE in the conditional array :param nx.StringParameter remove_value: The numerical value that will be replaced in the array :param nx.StringParameter replace_value: The value that will be used as the replacement value :param nx.ArraySelectionParameter selected_array_path: The complete path to array that will have values replaced :param nx.BoolParameter use_conditional: Whether to use a boolean mask array to replace values marked TRUE :return: Returns a :ref:`nx.IFilter.ExecuteResult ` object that holds any warnings and/or errors that were encountered during execution. :rtype: :ref:`nx.IFilter.ExecuteResult ` Color to GrayScale ------------------ .. index:: pair: Filter Human Names; Color to GrayScale .. index:: pair: Filter Class Names; ConvertColorToGrayScaleFilter .. _ConvertColorToGrayScaleFilter: .. py:class:: 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 | +--------------------------+----------------------------+ .. py:method:: Execute(data_structure, color_channel, color_weights, conversion_algorithm_index, input_data_array_paths, output_array_prefix) :param DataStructure data_structure: The DataStructure object that holds the data to be processed. :param nx.Int32Parameter color_channel: The specific R|G|B channel to use as the GrayScale values :param nx.VectorFloat32Parameter color_weights: The weightings for each R|G|B component when using the luminosity conversion algorithm :param nx.ChoicesParameter conversion_algorithm_index: Which method to use when flattening the RGB array :param nx.MultiArraySelectionParameter input_data_array_paths: Select all DataArrays that need to be converted to GrayScale :param nx.StringParameter output_array_prefix: This prefix will be added to each array name that is selected for conversion to form the new array name :return: Returns a :ref:`nx.IFilter.ExecuteResult ` object that holds any warnings and/or errors that were encountered during execution. :rtype: :ref:`nx.IFilter.ExecuteResult ` Convert AttributeArray DataType ------------------------------- .. index:: pair: Filter Human Names; Convert AttributeArray DataType .. index:: pair: Filter Class Names; ConvertDataFilter .. _ConvertDataFilter: .. py:class:: 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 | +-----------------------+-----------------------+ .. py:method:: Execute(data_structure, array_to_convert_path, converted_array_name, delete_original_array, scalar_type_index) :param DataStructure data_structure: The DataStructure object that holds the data to be processed. :param nx.ArraySelectionParameter array_to_convert_path: The complete path to the Data Array to Convert :param nx.DataObjectNameParameter converted_array_name: The name of the converted Data Array :param nx.BoolParameter delete_original_array: Whether or not to remove the original array after conversion :param nx.ChoicesParameter scalar_type_index: Convert to this data type :return: Returns a :ref:`nx.IFilter.ExecuteResult ` object that holds any warnings and/or errors that were encountered during execution. :rtype: :ref:`nx.IFilter.ExecuteResult ` Copy Data Object ---------------- .. index:: pair: Filter Human Names; Copy Data Object .. index:: pair: Filter Class Names; CopyDataObjectFilter .. _CopyDataObjectFilter: .. py:class:: 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 | +-------------------------+-----------------------+ .. py:method:: Execute(data_structure, existing_data_path, new_data_path, new_path_suffix, use_new_parent) :param DataStructure data_structure: The DataStructure object that holds the data to be processed. :param nx.MultiPathSelectionParameter existing_data_path: A list of DataPaths to the DataObjects to be copied :param nx.DataGroupSelectionParameter new_data_path: DataPath to parent Group in which to store the copied DataObject(s) :param nx.StringParameter new_path_suffix: Suffix string to be appended to each copied DataObject. Can be blank. :param nx.BoolParameter use_new_parent: Copy all the DataObjects to a different Group :return: Returns a :ref:`nx.IFilter.ExecuteResult ` object that holds any warnings and/or errors that were encountered during execution. :rtype: :ref:`nx.IFilter.ExecuteResult ` Create Element Array from Feature Array --------------------------------------- .. index:: pair: Filter Human Names; Create Element Array from Feature Array .. index:: pair: Filter Class Names; CopyFeatureArrayToElementArrayFilter .. _CopyFeatureArrayToElementArrayFilter: .. py:class:: 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 | +-----------------------------------+------------------------------+ .. py:method:: Execute(data_structure, created_array_suffix, feature_ids_path, selected_feature_array_paths) :param DataStructure data_structure: The DataStructure object that holds the data to be processed. :param nx.StringParameter created_array_suffix: The suffix to add to the input attribute array name when creating the copied array :param nx.ArraySelectionParameter feature_ids_path: Specifies to which Feature each cell belongs :param nx.MultiArraySelectionParameter selected_feature_array_paths: The DataPath to the feature data that should be copied to the cell level :return: Returns a :ref:`nx.IFilter.ExecuteResult ` object that holds any warnings and/or errors that were encountered during execution. :rtype: :ref:`nx.IFilter.ExecuteResult ` Create AM Scan Paths -------------------- .. index:: pair: Filter Human Names; Create AM Scan Paths .. index:: pair: Filter Class Names; CreateAMScanPathsFilter .. _CreateAMScanPathsFilter: .. py:class:: 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 | +--------------------------------+-------------------------------+ .. py:method:: 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) :param DataStructure data_structure: The DataStructure object that holds the data to be processed. :param nx.ArraySelectionParameter cad_region_ids_array_path: Identifies the region to which each edge belongs :param nx.GeometrySelectionParameter cad_slice_data_container_path: The input edge geometry from which to create the scan paths :param nx.ArraySelectionParameter cad_slice_ids_array_path: Identifies the slice to which each edge belongs :param nx.DataObjectNameParameter hatch_attribute_matrix_name: The name of the attribute matrix containing the scan path's Edge data :param nx.DataGroupCreationParameter hatch_data_container_path: The created edge geometry representing the scan paths :param nx.Float32Parameter hatch_length: The length of each vector that is created. :param nx.Float32Parameter hatch_spacing: The orthogonal distance between each generated vector. :param nx.DataObjectNameParameter region_ids_array_name: The name of the array identifying the region to which each scan path belongs :param nx.Float32Parameter rotation_angle: The angle in degrees by which each slice's hatches are rotated :param nx.DataObjectNameParameter vertex_attribute_matrix_name: The name of the attribute matrix containing the scan paths' vertex data :return: Returns a :ref:`nx.IFilter.ExecuteResult ` object that holds any warnings and/or errors that were encountered during execution. :rtype: :ref:`nx.IFilter.ExecuteResult ` Create Attribute Matrix ----------------------- .. index:: pair: Filter Human Names; Create Attribute Matrix .. index:: pair: Filter Class Names; CreateAttributeMatrixFilter .. _CreateAttributeMatrixFilter: .. py:class:: 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 | +-------------------------------------------------------------+-----------------------+ .. py:method:: Execute(data_structure, data_object_path, tuple_dimensions) :param DataStructure data_structure: The DataStructure object that holds the data to be processed. :param nx.DataGroupCreationParameter data_object_path: The complete path to the Attribute Matrix being created :param nx.DynamicTableParameter tuple_dimensions: Slowest to Fastest Dimensions :return: Returns a :ref:`nx.IFilter.ExecuteResult ` object that holds any warnings and/or errors that were encountered during execution. :rtype: :ref:`nx.IFilter.ExecuteResult ` Create Color Map ---------------- .. index:: pair: Filter Human Names; Create Color Map .. index:: pair: Filter Class Names; CreateColorMapFilter .. _CreateColorMapFilter: .. py:class:: 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 | +--------------------+-----------------------+ .. py:method:: Execute(data_structure, input_data_array_path, invalid_color_value, mask_array_path, output_rgb_array_name, selected_preset, use_mask) :param DataStructure data_structure: The DataStructure object that holds the data to be processed. :param nx.ArraySelectionParameter input_data_array_path: The complete path to the data array from which to create the rgb array by applying the selected preset color scheme :param nx.VectorUInt8Parameter invalid_color_value: The color to assign to voxels that have a mask value of FALSE :param nx.ArraySelectionParameter mask_array_path: Path to the data array used to define Elements as good or bad. :param nx.DataObjectNameParameter output_rgb_array_name: The rgb array created by normalizing each element of the input array and converting to a color based on the selected preset color scheme :param nx.CreateColorMapParameter selected_preset: Select a preset color scheme to apply to the created array :param nx.BoolParameter use_mask: Whether to assign a black color to 'bad' Elements :return: Returns a :ref:`nx.IFilter.ExecuteResult ` object that holds any warnings and/or errors that were encountered during execution. :rtype: :ref:`nx.IFilter.ExecuteResult ` Create Data Array (Advanced) ---------------------------- .. index:: pair: Filter Human Names; Create Data Array (Advanced) .. index:: pair: Filter Class Names; CreateDataArrayAdvancedFilter .. _CreateDataArrayAdvancedFilter: .. py:class:: 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 | +-------------------------------------------------------------------------------------+-----------------------+ .. py:method:: 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) :param DataStructure data_structure: The DataStructure object that holds the data to be processed. :param nx.DynamicTableParameter component_dimensions: Slowest to Fastest Component Dimensions. :param nx.DataStoreFormatParameter data_format: This value will specify which data format is used by the array's data store. An empty string results in in-memory data store. :param nx.StringParameter init_end_range: [Inclusive] The upper bound initialization range for random values :param nx.StringParameter init_start_range: [Inclusive] The lower bound initialization range for random values :param nx.ChoicesParameter init_type_index: Method for determining the what values of the data in the array should be initialized to :param nx.StringParameter init_value: Specify values for each component. Ex: A 3-component array would be 6;8;12 and every tuple would have these same component values :param nx.NumericTypeParameter numeric_type_index: Numeric Type of data to create :param nx.ArrayCreationParameter output_array_path: Array storing the data :param nx.DataObjectNameParameter seed_array_name: Name of the array holding the seed value :param nx.UInt64Parameter seed_value: The seed fed into the random generator :param nx.BoolParameter set_tuple_dimensions: 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 :param nx.BoolParameter standardize_seed: When true the same seed will be used for each component's generator in a multi-component array :param nx.StringParameter starting_fill_value: 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. :param nx.ChoicesParameter step_operation_index: The type of step operation to perform :param nx.StringParameter step_value: The number to add/subtract the fill value by :param nx.DynamicTableParameter tuple_dimensions: Slowest to Fastest Dimensions. Note this might be opposite displayed by an image geometry. :param nx.BoolParameter use_seed: When true, the Seed Value will be used to seed the generator :return: Returns a :ref:`nx.IFilter.ExecuteResult ` object that holds any warnings and/or errors that were encountered during execution. :rtype: :ref:`nx.IFilter.ExecuteResult ` Create Data Array ----------------- .. index:: pair: Filter Human Names; Create Data Array .. index:: pair: Filter Class Names; CreateDataArrayFilter .. _CreateDataArrayFilter: .. py:class:: 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 | +----------------------------------------------------------------------------+--------------------------+ .. py:method:: Execute(data_structure, component_count, data_format, initialization_value_str, numeric_type_index, output_array_path, set_tuple_dimensions, tuple_dimensions) :param DataStructure data_structure: The DataStructure object that holds the data to be processed. :param nx.UInt64Parameter component_count: Total number of components. Do not set the component dimensions. :param nx.DataStoreFormatParameter data_format: This value will specify which data format is used by the array's data store. An empty string results in in-memory data store. :param nx.StringParameter initialization_value_str: This value will be used to fill the new array :param nx.NumericTypeParameter numeric_type_index: Numeric Type of data to create :param nx.ArrayCreationParameter output_array_path: Array storing the data :param nx.BoolParameter set_tuple_dimensions: 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 :param nx.DynamicTableParameter tuple_dimensions: Slowest to Fastest Dimensions. Note this might be opposite displayed by an image geometry. :return: Returns a :ref:`nx.IFilter.ExecuteResult ` object that holds any warnings and/or errors that were encountered during execution. :rtype: :ref:`nx.IFilter.ExecuteResult ` Create Data Group ----------------- .. index:: pair: Filter Human Names; Create Data Group .. index:: pair: Filter Class Names; CreateDataGroupFilter .. _CreateDataGroupFilter: .. py:class:: 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 | +-----------------+-----------------------+ .. py:method:: Execute(data_structure, data_object_path) :param DataStructure data_structure: The DataStructure object that holds the data to be processed. :param nx.DataGroupCreationParameter data_object_path: The complete path to the DataObject being created :return: Returns a :ref:`nx.IFilter.ExecuteResult ` object that holds any warnings and/or errors that were encountered during execution. :rtype: :ref:`nx.IFilter.ExecuteResult ` Create Feature Array from Element Array --------------------------------------- .. index:: pair: Filter Human Names; Create Feature Array from Element Array .. index:: pair: Filter Class Names; CreateFeatureArrayFromElementArrayFilter .. _CreateFeatureArrayFromElementArrayFilter: .. py:class:: 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 | +---------------------------------+------------------------------------+ .. py:method:: Execute(data_structure, cell_feature_attribute_matrix_path, created_array_name, feature_ids_path, selected_cell_array_path) :param DataStructure data_structure: The DataStructure object that holds the data to be processed. :param nx.AttributeMatrixSelectionParameter cell_feature_attribute_matrix_path: The path to the cell feature attribute matrix where the converted output feature array will be stored :param nx.DataObjectNameParameter created_array_name: The path to the copied AttributeArray :param nx.ArraySelectionParameter feature_ids_path: Specifies to which Feature each Element belongs :param nx.ArraySelectionParameter selected_cell_array_path: Element Data to Copy to Feature Data :return: Returns a :ref:`nx.IFilter.ExecuteResult ` object that holds any warnings and/or errors that were encountered during execution. :rtype: :ref:`nx.IFilter.ExecuteResult ` Create Geometry --------------- .. index:: pair: Filter Human Names; Create Geometry .. index:: pair: Filter Class Names; CreateGeometryFilter .. _CreateGeometryFilter: .. py:class:: 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 | +-----------------------------------+------------------------------+ .. py:method:: 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) :param DataStructure data_structure: The DataStructure object that holds the data to be processed. :param nx.ChoicesParameter array_handling_index: Determines if the arrays that make up the geometry primitives should be Moved or Copied to the created Geometry object. :param nx.DataObjectNameParameter cell_attribute_matrix_name: The name of the cell attribute matrix to be created with the geometry :param nx.VectorUInt64Parameter dimensions: The number of cells in each of the X, Y, Z directions :param nx.DataObjectNameParameter edge_attribute_matrix_name: The name of the edge attribute matrix to be created with the geometry :param nx.ArraySelectionParameter edge_list_path: The complete path to the data array defining the edges for the geometry :param nx.DataObjectNameParameter face_attribute_matrix_name: The name of the face attribute matrix to be created with the geometry :param nx.ChoicesParameter geometry_type_index: The type of Geometry to create :param nx.ArraySelectionParameter hexahedral_list_path: The complete path to the data array defining the hexahedral elements for the geometry :param nx.ChoicesParameter length_unit_index: The length unit to be used in the geometry :param nx.VectorFloat32Parameter origin: The origin of each of the axes in X, Y, Z order :param nx.DataGroupCreationParameter output_geometry_path: The complete path to the geometry to be created :param nx.ArraySelectionParameter quadrilateral_list_path: The complete path to the data array defining the (quad) faces for the geometry :param nx.VectorFloat32Parameter spacing: The length scale of each voxel/pixel :param nx.ArraySelectionParameter tetrahedral_list_path: The complete path to the data array defining the tetrahedral elements for the geometry :param nx.ArraySelectionParameter triangle_list_path: The complete path to the data array defining the (triangular) faces for the geometry :param nx.DataObjectNameParameter vertex_attribute_matrix_name: The name of the vertex attribute matrix to be created with the geometry :param nx.ArraySelectionParameter vertex_list_path: The complete path to the data array defining the point coordinates for the geometry :param nx.BoolParameter warnings_as_errors: Whether run time warnings for Geometries should be treated as errors :param nx.ArraySelectionParameter x_bounds_path: The spatial locations of the planes along the x direction :param nx.ArraySelectionParameter y_bounds_path: The spatial locations of the planes along the y direction :param nx.ArraySelectionParameter z_bounds_path: The spatial locations of the planes along the z direction :return: Returns a :ref:`nx.IFilter.ExecuteResult ` object that holds any warnings and/or errors that were encountered during execution. :rtype: :ref:`nx.IFilter.ExecuteResult ` Create Geometry (Image) ----------------------- .. index:: pair: Filter Human Names; Create Geometry (Image) .. index:: pair: Filter Class Names; CreateImageGeometryFilter .. _CreateImageGeometryFilter: .. py:class:: 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 | +----------------------+----------------------------+ .. py:method:: Execute(data_structure, cell_data_name, dimensions, origin, output_image_geometry_path, spacing) :param DataStructure data_structure: The DataStructure object that holds the data to be processed. :param nx.DataObjectNameParameter cell_data_name: The name of the cell Attribute Matrix to be created :param nx.VectorUInt64Parameter dimensions: The number of cells in each of the X, Y, Z directions :param nx.VectorFloat32Parameter origin: The origin of each of the axes in X, Y, Z order :param nx.DataGroupCreationParameter output_image_geometry_path: The complete path to the Geometry being created :param nx.VectorFloat32Parameter spacing: The length scale of each voxel/pixel :return: Returns a :ref:`nx.IFilter.ExecuteResult ` object that holds any warnings and/or errors that were encountered during execution. :rtype: :ref:`nx.IFilter.ExecuteResult ` Create Python Plugin and/or Filters ----------------------------------- .. index:: pair: Filter Human Names; Create Python Plugin and/or Filters .. index:: pair: Filter Class Names; CreatePythonSkeletonFilter .. _CreatePythonSkeletonFilter: .. py:class:: 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 | +--------------------------------+-------------------------+ .. py:method:: Execute(data_structure, filter_names, plugin_human_name, plugin_input_directory, plugin_name, plugin_output_directory, use_existing_plugin) :param DataStructure data_structure: The DataStructure object that holds the data to be processed. :param nx.StringParameter filter_names: The names of filters that will be created, separated by commas (,). :param nx.StringParameter plugin_human_name: This is the user facing name of the plugin. :param nx.FileSystemPathParameter plugin_input_directory: The location of the existing plugin's top level directory on the file system. :param nx.StringParameter plugin_name: This is the name of the plugin. :param nx.FileSystemPathParameter plugin_output_directory: The path to the output directory where the new plugin will be generated. :param nx.BoolParameter use_existing_plugin: Generate the list of filters into an existing plugin instead of creating a new plugin. :return: Returns a :ref:`nx.IFilter.ExecuteResult ` object that holds any warnings and/or errors that were encountered during execution. :rtype: :ref:`nx.IFilter.ExecuteResult ` Crop Geometry (Edge) -------------------- .. index:: pair: Filter Human Names; Crop Geometry (Edge) .. index:: pair: Filter Class Names; CropEdgeGeometryFilter .. _CropEdgeGeometryFilter: .. py:class:: 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 | +--------------------------------+--------------------------------------+ .. py:method:: 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) :param DataStructure data_structure: The DataStructure object that holds the data to be processed. :param nx.ChoicesParameter boundary_intersection_behavior_index: 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 :ref:`nx.IFilter.ExecuteResult ` object that holds any warnings and/or errors that were encountered during execution. :rtype: :ref:`nx.IFilter.ExecuteResult ` Crop Geometry (Image) --------------------- .. index:: pair: Filter Human Names; Crop Geometry (Image) .. index:: pair: Filter Class Names; CropImageGeometryFilter .. _CropImageGeometryFilter: .. py:class:: 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 | +---------------------------------------------+------------------------------------+ .. py:method:: 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) :param DataStructure data_structure: The DataStructure object that holds the data to be processed. :param nx.AttributeMatrixSelectionParameter cell_feature_attribute_matrix_path: DataPath to the feature Attribute Matrix :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.ArraySelectionParameter feature_ids_path: DataPath to Cell Feature IDs array :param nx.GeometrySelectionParameter input_image_geometry_path: DataPath to the source Image Geometry :param nx.VectorFloat64Parameter max_coord: Upper bound in real units of the volume to crop. :param nx.VectorUInt64Parameter max_voxel: Upper bound in voxels of the volume to crop out :param nx.VectorFloat64Parameter min_coord: Lower bound in real units of the volume to crop. :param nx.VectorUInt64Parameter min_voxel: Lower bound of voxels of the volume to crop out :param nx.DataGroupCreationParameter output_image_geometry_path: The DataPath to store the created Image Geometry :param nx.BoolParameter remove_original_geometry: Removes the original Image Geometry after filter is completed :param nx.BoolParameter renumber_features: Specifies if the feature IDs should be renumbered :param nx.BoolParameter use_physical_bounds: If true define physical coordinates for bounds, If false define voxel indices for bounds :return: Returns a :ref:`nx.IFilter.ExecuteResult ` object that holds any warnings and/or errors that were encountered during execution. :rtype: :ref:`nx.IFilter.ExecuteResult ` Crop Geometry (Vertex) ---------------------- .. index:: pair: Filter Human Names; Crop Geometry (Vertex) .. index:: pair: Filter Class Names; CropVertexGeometryFilter .. _CropVertexGeometryFilter: .. py:class:: 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 | +----------------------------+------------------------------+ .. py:method:: Execute(data_structure, input_vertex_geometry_path, max_pos, min_pos, output_vertex_geometry_path, target_array_paths, vertex_attribute_matrix_name) :param DataStructure data_structure: The DataStructure object that holds the data to be processed. :param nx.GeometrySelectionParameter input_vertex_geometry_path: DataPath to target VertexGeom :param nx.VectorFloat32Parameter max_pos: Maximum vertex position :param nx.VectorFloat32Parameter min_pos: Minimum vertex position :param nx.DataGroupCreationParameter output_vertex_geometry_path: Created VertexGeom path :param nx.MultiArraySelectionParameter target_array_paths: The complete path to all the vertex data arrays to crop :param nx.DataObjectNameParameter vertex_attribute_matrix_name: Name of the vertex data AttributeMatrix :return: Returns a :ref:`nx.IFilter.ExecuteResult ` object that holds any warnings and/or errors that were encountered during execution. :rtype: :ref:`nx.IFilter.ExecuteResult ` DBSCAN ------ .. index:: pair: Filter Human Names; DBSCAN .. index:: pair: Filter Class Names; DBSCANFilter .. _DBSCANFilter: .. py:class:: 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 | +------------------------------+-------------------------------+ .. py:method:: 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) :param DataStructure data_structure: The DataStructure object that holds the data to be processed. :param nx.ChoicesParameter distance_metric_index: Distance Metric type to be used for calculations :param nx.Float32Parameter epsilon: The epsilon-neighborhood around each point is queried :param nx.DataGroupCreationParameter feature_attribute_matrix_path: The complete path to the attribute matrix in which to store to hold Cluster Data :param nx.DataObjectNameParameter feature_ids_array_name: Name of the ids array to be created in Attribute Array to Cluster's parent group :param nx.ChoicesParameter init_type_index: Whether to use random or iterative for start state. See Documentation for further detail :param nx.ArraySelectionParameter mask_array_path: DataPath to the boolean or uint8 mask array. Values that are true will mark that cell/point as usable. :param nx.Int32Parameter min_points: The minimum number of points needed to form a 'dense region' (i.e., the minimum number of points needed to be called a cluster) :param nx.DataObjectNameParameter seed_array_name: Name of array holding the seed value :param nx.UInt64Parameter seed_value: The seed fed into the random generator :param nx.ArraySelectionParameter selected_array_path: The data array to cluster :param nx.BoolParameter use_mask: Specifies whether or not to use a mask array :param nx.BoolParameter use_precaching: If true the algorithm will be significantly faster, but it requires more memory :return: Returns a :ref:`nx.IFilter.ExecuteResult ` object that holds any warnings and/or errors that were encountered during execution. :rtype: :ref:`nx.IFilter.ExecuteResult ` Delete Data ----------- .. index:: pair: Filter Human Names; Delete Data .. index:: pair: Filter Class Names; DeleteDataFilter .. _DeleteDataFilter: .. py:class:: 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 | +---------------------+-----------------------+ .. py:method:: Execute(data_structure, removed_data_path) :param DataStructure data_structure: The DataStructure object that holds the data to be processed. :param nx.MultiPathSelectionParameter removed_data_path: The complete path to the DataObjects to be removed :return: Returns a :ref:`nx.IFilter.ExecuteResult ` object that holds any warnings and/or errors that were encountered during execution. :rtype: :ref:`nx.IFilter.ExecuteResult ` Erode/Dilate Bad Data --------------------- .. index:: pair: Filter Human Names; Erode/Dilate Bad Data .. index:: pair: Filter Class Names; ErodeDilateBadDataFilter .. _ErodeDilateBadDataFilter: .. py:class:: 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 | +----------------------------+---------------------------+ .. py:method:: 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) :param DataStructure data_structure: The DataStructure object that holds the data to be processed. :param nx.ArraySelectionParameter feature_ids_path: Specifies to which Feature each Cell belongs :param nx.MultiArraySelectionParameter ignored_data_array_paths: The list of arrays to ignore when performing the algorithm :param nx.GeometrySelectionParameter input_image_geometry_path: The target geometry :param nx.Int32Parameter num_iterations: The number of iterations to use for erosion/dilation :param nx.ChoicesParameter operation_index: Whether to dilate or erode :param nx.BoolParameter x_dir_on: Whether to erode/dilate in the X direction :param nx.BoolParameter y_dir_on: Whether to erode/dilate in the Y direction :param nx.BoolParameter z_dir_on: Whether to erode/dilate in the Z direction :return: Returns a :ref:`nx.IFilter.ExecuteResult ` object that holds any warnings and/or errors that were encountered during execution. :rtype: :ref:`nx.IFilter.ExecuteResult ` Erode/Dilate Coordination Number -------------------------------- .. index:: pair: Filter Human Names; Erode/Dilate Coordination Number .. index:: pair: Filter Class Names; ErodeDilateCoordinationNumberFilter .. _ErodeDilateCoordinationNumberFilter: .. py:class:: 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 | +---------------------------------+---------------------------+ .. py:method:: Execute(data_structure, coordination_number, feature_ids_path, ignored_data_array_paths, input_image_geometry_path, loop) :param DataStructure data_structure: The DataStructure object that holds the data to be processed. :param nx.Int32Parameter coordination_number: Number of neighboring **Cells** that can be of opposite classification before a **Cell** will be removed :param nx.ArraySelectionParameter feature_ids_path: Specifies to which Feature each Cell belongs :param nx.MultiArraySelectionParameter ignored_data_array_paths: The list of arrays to ignore when performing the algorithm :param nx.GeometrySelectionParameter input_image_geometry_path: The target geometry :param nx.BoolParameter loop: Keep looping until all criteria is met :return: Returns a :ref:`nx.IFilter.ExecuteResult ` object that holds any warnings and/or errors that were encountered during execution. :rtype: :ref:`nx.IFilter.ExecuteResult ` Erode/Dilate Mask ----------------- .. index:: pair: Filter Human Names; Erode/Dilate Mask .. index:: pair: Filter Class Names; ErodeDilateMaskFilter .. _ErodeDilateMaskFilter: .. py:class:: 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 | +-------------------------+---------------------------+ .. py:method:: Execute(data_structure, input_image_geometry_path, mask_array_path, num_iterations, operation_index, x_dir_on, y_dir_on, z_dir_on) :param DataStructure data_structure: The DataStructure object that holds the data to be processed. :param nx.GeometrySelectionParameter input_image_geometry_path: The target geometry :param nx.ArraySelectionParameter mask_array_path: Boolean array where true voxels are used. False voxels are ignored. :param nx.Int32Parameter num_iterations: Number of erode/dilate iterations to perform :param nx.ChoicesParameter operation_index: Whether to dilate (0) or erode (1) :param nx.BoolParameter x_dir_on: Whether to erode/dilate in the X direction :param nx.BoolParameter y_dir_on: Whether to erode/dilate in the Y direction :param nx.BoolParameter z_dir_on: Whether to erode/dilate in the Z direction :return: Returns a :ref:`nx.IFilter.ExecuteResult ` object that holds any warnings and/or errors that were encountered during execution. :rtype: :ref:`nx.IFilter.ExecuteResult ` Execute Process --------------- .. index:: pair: Filter Human Names; Execute Process .. index:: pair: Filter Class Names; ExecuteProcessFilter .. _ExecuteProcessFilter: .. py:class:: 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 | +------------------------+-----------------------+ .. py:method:: Execute(data_structure, arguments, blocking, output_log_file, timeout) :param DataStructure data_structure: The DataStructure object that holds the data to be processed. :param nx.StringParameter arguments: The complete command to execute. :param nx.BoolParameter blocking: Whether to block the process while the command executes or not :param nx.FileSystemPathParameter output_log_file: The log file where the output from the process will be stored :param nx.Int32Parameter timeout: The amount of time to wait for the command to start/finish when blocking is selected :return: Returns a :ref:`nx.IFilter.ExecuteResult ` object that holds any warnings and/or errors that were encountered during execution. :rtype: :ref:`nx.IFilter.ExecuteResult ` Extract/Remove Components ------------------------- .. index:: pair: Filter Human Names; Extract/Remove Components .. index:: pair: Filter Class Names; ExtractComponentAsArrayFilter .. _ExtractComponentAsArrayFilter: .. py:class:: 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 | +--------------------------------------------+------------------------------+ .. py:method:: Execute(data_structure, comp_number, move_components_to_new_array, new_array_name, remove_components_from_array, selected_array_path) :param DataStructure data_structure: The DataStructure object that holds the data to be processed. :param nx.Int32Parameter comp_number: The index of the component in each tuple to be removed :param nx.BoolParameter move_components_to_new_array: If true the extracted components will be placed in a new array :param nx.DataObjectNameParameter new_array_name: The DataArray to store the extracted components :param nx.BoolParameter remove_components_from_array: If true the extracted components will be deleted :param nx.ArraySelectionParameter selected_array_path: The array to extract components from :return: Returns a :ref:`nx.IFilter.ExecuteResult ` object that holds any warnings and/or errors that were encountered during execution. :rtype: :ref:`nx.IFilter.ExecuteResult ` Extract Internal Surfaces From Triangle Geometry ------------------------------------------------ .. index:: pair: Filter Human Names; Extract Internal Surfaces From Triangle Geometry .. index:: pair: Filter Class Names; ExtractInternalSurfacesFromTriangleGeometryFilter .. _ExtractInternalSurfacesFromTriangleGeometryFilter: .. py:class:: 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 | +--------------------------------------+--------------------------------+ .. py:method:: 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) :param DataStructure data_structure: The DataStructure object that holds the data to be processed. :param nx.MultiArraySelectionParameter copy_triangle_array_paths: Paths to face-related DataArrays that should be copied to the new geometry :param nx.MultiArraySelectionParameter copy_vertex_array_paths: Paths to vertex-related DataArrays that should be copied to the new geometry :param nx.GeometrySelectionParameter input_triangle_geometry_path: Path to the existing Triangle Geometry :param nx.VectorInt8Parameter node_type_range: The min and max (inclusive) Node Type values that distinguish an internal surface from an external surface :param nx.ArraySelectionParameter node_types_path: Path to the Node Types array :param nx.DataGroupCreationParameter output_triangle_geometry_path: Path to create the new Triangle Geometry :param nx.DataObjectNameParameter triangle_attribute_matrix_name: Created face data AttributeMatrix name :param nx.DataObjectNameParameter vertex_attribute_matrix_name: Created vertex data AttributeMatrix name :return: Returns a :ref:`nx.IFilter.ExecuteResult ` object that holds any warnings and/or errors that were encountered during execution. :rtype: :ref:`nx.IFilter.ExecuteResult ` Extract DREAM3D-NX Pipeline To File ----------------------------------- .. index:: pair: Filter Human Names; Extract DREAM3D-NX Pipeline To File .. index:: pair: Filter Class Names; ExtractPipelineToFileFilter .. _ExtractPipelineToFileFilter: .. py:class:: 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 | +-------------------------+-----------------------+ .. py:method:: Execute(data_structure, input_file_path, output_file_path) :param DataStructure data_structure: The DataStructure object that holds the data to be processed. :param nx.FileSystemPathParameter input_file_path: The file path to the .dream3d that holds the pipeline to be extracted. :param nx.FileSystemPathParameter output_file_path: The file path in which to save the extracted pipeline :return: Returns a :ref:`nx.IFilter.ExecuteResult ` object that holds any warnings and/or errors that were encountered during execution. :rtype: :ref:`nx.IFilter.ExecuteResult ` Extract Vertex Geometry ----------------------- .. index:: pair: Filter Human Names; Extract Vertex Geometry .. index:: pair: Filter Class Names; ExtractVertexGeometryFilter .. _ExtractVertexGeometryFilter: .. py:class:: 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 | +-------------------------------------+--------------------------------+ .. py:method:: 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) :param DataStructure data_structure: The DataStructure object that holds the data to be processed. :param nx.ChoicesParameter array_handling_index: [0] Move or [1] Copy input data arrays :param nx.MultiArraySelectionParameter included_data_array_paths: The arrays to copy/move to the vertex array :param nx.GeometrySelectionParameter input_grid_geometry_path: The input Image/RectilinearGrid Geometry to convert :param nx.ArraySelectionParameter mask_array_path: DataPath to the boolean mask array. Values that are true will mark that cell/point as usable. :param nx.DataObjectNameParameter output_shared_vertex_list_name: The name of the shared vertex list that will be created :param nx.DataObjectNameParameter output_vertex_attr_matrix_name: The name of the vertex attribute matrix that will be created :param nx.DataGroupCreationParameter output_vertex_geometry_path: The complete path to the vertex geometry that will be created :param nx.BoolParameter use_mask: Specifies whether or not to use a mask array :return: Returns a :ref:`nx.IFilter.ExecuteResult ` object that holds any warnings and/or errors that were encountered during execution. :rtype: :ref:`nx.IFilter.ExecuteResult ` Compute Feature Face Curvature ------------------------------ .. index:: pair: Filter Human Names; Compute Feature Face Curvature .. index:: pair: Filter Class Names; FeatureFaceCurvatureFilter .. _FeatureFaceCurvatureFilter: .. py:class:: 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 | +-------------------------------------+------------------------------+ .. py:method:: 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) :param DataStructure data_structure: The DataStructure object that holds the data to be processed. :param nx.BoolParameter compute_gaussian_curvature: Compute the Gaussian Curvature values :param nx.BoolParameter compute_mean_curvature_path: Compute the Mean Curvature values :param nx.BoolParameter compute_principal_direction: Compute the Principal Direction Vectors :param nx.BoolParameter compute_weingarten_matrix: Compute the Weingarten Matrix values :param nx.AttributeMatrixSelectionParameter face_attribute_matrix_path: The AttributeMatrix that holds the triangle face data. :param nx.ArraySelectionParameter face_centroids_path: The DataPath to the 'Face Centroids' DataArray :param nx.ArraySelectionParameter face_labels_path: The DataPath to the 'Face Labels' DataArray :param nx.ArraySelectionParameter face_normals_path: The DataPath to the 'Feature Normals' DataArray :param nx.ArraySelectionParameter feature_face_ids_path: The DataPath to the 'FeatureIds' DataArray :param nx.ArrayCreationParameter gaussian_curvature_path: Output DataPath to hold the 'Gaussian Curvature' values :param nx.GeometrySelectionParameter input_triangle_geometry_path: The input Triangle Geometry to compute the curvature values :param nx.ArrayCreationParameter mean_curvature_path: Output DataPath to hold the 'Mean Curvature' values :param nx.Int32Parameter neighborhood_ring: The number of ring neighbors to use :param nx.ArrayCreationParameter principal_curvature_1_path: Output DataPath to hold the 'Principal Curvature 1' values :param nx.ArrayCreationParameter principal_curvature_2_path: Output DataPath to hold the 'Principal Curvature 2' values :param nx.ArrayCreationParameter principal_direction_1_path: Output DataPath to hold the 'Principal Direction 1' values :param nx.ArrayCreationParameter principal_direction_2_path: Output DataPath to hold the 'Principal Direction 2' values :param nx.BoolParameter use_normals: Use the face normals for curve fitting. :param nx.ArrayCreationParameter weingarten_matrix_path: Output DataPath to hold the 'Weingarten Matrix' values :return: Returns a :ref:`nx.IFilter.ExecuteResult ` object that holds any warnings and/or errors that were encountered during execution. :rtype: :ref:`nx.IFilter.ExecuteResult ` Fill Bad Data ------------- .. index:: pair: Filter Human Names; Fill Bad Data .. index:: pair: Filter Class Names; FillBadDataFilter .. _FillBadDataFilter: .. py:class:: 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 | +-----------------------------+---------------------------+ .. py:method:: 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) :param DataStructure data_structure: The DataStructure object that holds the data to be processed. :param nx.ArraySelectionParameter cell_phases_array_path: Specifies to which Ensemble each Cell belongs. :param nx.ArraySelectionParameter feature_ids_path: Specifies to which Feature each Element belongs :param nx.MultiArraySelectionParameter ignored_data_array_paths: The list of arrays to ignore when performing the algorithm :param nx.GeometrySelectionParameter input_image_geometry_path: The target geometry :param nx.Int32Parameter min_allowed_defect_size: The size at which a group of bad Cells are left unfilled as a 'defect' :param nx.BoolParameter store_as_new_phase: Whether to change the phase of 'defect' larger than the minimum allowed size above :return: Returns a :ref:`nx.IFilter.ExecuteResult ` object that holds any warnings and/or errors that were encountered during execution. :rtype: :ref:`nx.IFilter.ExecuteResult ` Surface Contour Filter (Flying Edges 3D) ---------------------------------------- .. index:: pair: Filter Human Names; Surface Contour Filter (Flying Edges 3D) .. index:: pair: Filter Class Names; FlyingEdges3DFilter .. _FlyingEdges3DFilter: .. py:class:: 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 | +----------------------------------+-------------------------------+ .. py:method:: Execute(data_structure, contour_value, input_data_array_path, input_image_geometry_path, output_triangle_geometry_path) :param DataStructure data_structure: The DataStructure object that holds the data to be processed. :param nx.Float64Parameter contour_value: The value to contour on :param nx.ArraySelectionParameter input_data_array_path: This is the data that will be checked for the contouring iso value :param nx.GeometrySelectionParameter input_image_geometry_path: The target geometry :param nx.DataGroupCreationParameter output_triangle_geometry_path: This is where the contouring line will be stored :return: Returns a :ref:`nx.IFilter.ExecuteResult ` object that holds any warnings and/or errors that were encountered during execution. :rtype: :ref:`nx.IFilter.ExecuteResult ` Isolate Largest Feature (Identify Sample) ----------------------------------------- .. index:: pair: Filter Human Names; Isolate Largest Feature (Identify Sample) .. index:: pair: Filter Class Names; IdentifySampleFilter .. _IdentifySampleFilter: .. py:class:: 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 | +-------------------------------+----------------------------+ .. py:method:: Execute(data_structure, fill_holes, input_image_geometry_path, mask_array_path, slice_by_slice, slice_by_slice_plane_index) :param DataStructure data_structure: The DataStructure object that holds the data to be processed. :param nx.BoolParameter fill_holes: Whether to fill holes within sample after it is identified :param nx.GeometrySelectionParameter input_image_geometry_path: DataPath to the target ImageGeom :param nx.ArraySelectionParameter mask_array_path: DataPath to the mask array defining what is sample and what is not :param nx.BoolParameter slice_by_slice: 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. :param nx.ChoicesParameter slice_by_slice_plane_index: 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. :return: Returns a :ref:`nx.IFilter.ExecuteResult ` object that holds any warnings and/or errors that were encountered during execution. :rtype: :ref:`nx.IFilter.ExecuteResult ` Initialize Data --------------- .. index:: pair: Filter Human Names; Initialize Data .. index:: pair: Filter Class Names; InitializeDataFilter .. _InitializeDataFilter: .. py:class:: 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 | +-----------------------------------------------+-----------------------+ .. py:method:: 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) :param DataStructure data_structure: The DataStructure object that holds the data to be processed. :param nx.ArraySelectionParameter array_path: The data array in which to initialize the data :param nx.StringParameter init_end_range: [Inclusive] The upper bound initialization range for random values :param nx.StringParameter init_start_range: [Inclusive] The lower bound initialization range for random values :param nx.ChoicesParameter init_type_index: Method for determining the what values of the data in the array should be initialized to :param nx.StringParameter init_value: Specify values for each component. Ex: A 3-component array would be 6;8;12 and every tuple would have these same component values :param nx.DataObjectNameParameter seed_array_name: Name of array holding the seed value :param nx.UInt64Parameter seed_value: The seed fed into the random generator :param nx.BoolParameter standardize_seed: When true the same seed will be used for each component's generator in a multi-component array :param nx.StringParameter starting_fill_value: The value to start incrementing from :param nx.ChoicesParameter step_operation_index: The type of step operation to preform :param nx.StringParameter step_value: The number to add/subtract the fill value by :param nx.BoolParameter use_seed: When true the Seed Value will be used to seed the generator :return: Returns a :ref:`nx.IFilter.ExecuteResult ` object that holds any warnings and/or errors that were encountered during execution. :rtype: :ref:`nx.IFilter.ExecuteResult ` Initialize Image Geometry Cell Data ----------------------------------- .. index:: pair: Filter Human Names; Initialize Image Geometry Cell Data .. index:: pair: Filter Class Names; InitializeImageGeomCellDataFilter .. _InitializeImageGeomCellDataFilter: .. py:class:: 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 | +--------------------------------+---------------------------+ .. py:method:: 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) :param DataStructure data_structure: The DataStructure object that holds the data to be processed. :param nx.MultiArraySelectionParameter cell_arrays: The cell data arrays in which to initialize a sub-volume to zeros :param nx.VectorFloat64Parameter init_range: The initialization range if Random With Range Initialization Type is selected :param nx.ChoicesParameter init_type_index: Tells how to initialize the data :param nx.Float64Parameter init_value: The initialization value if Manual Initialization Type is selected :param nx.GeometrySelectionParameter input_image_geometry_path: The geometry containing the cell data for which to initialize :param nx.VectorUInt64Parameter max_point: The maximum x, y, z bound in cells :param nx.VectorUInt64Parameter min_point: The minimum x, y, z bound in cells :param nx.DataObjectNameParameter seed_array_name: Name of array holding the seed value :param nx.UInt64Parameter seed_value: The seed fed into the random generator :param nx.BoolParameter use_seed: When true the user will be able to put in a seed for random generation :return: Returns a :ref:`nx.IFilter.ExecuteResult ` object that holds any warnings and/or errors that were encountered during execution. :rtype: :ref:`nx.IFilter.ExecuteResult ` Interpolate Point Cloud to Regular Grid --------------------------------------- .. index:: pair: Filter Human Names; Interpolate Point Cloud to Regular Grid .. index:: pair: Filter Class Names; InterpolatePointCloudToRegularGridFilter .. _InterpolatePointCloudToRegularGridFilter: .. py:class:: 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 | +---------------------------------+-----------------------------+ .. py:method:: 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) :param DataStructure data_structure: The DataStructure object that holds the data to be processed. :param nx.MultiArraySelectionParameter copy_arrays: DataPaths to copy :param nx.VectorFloat32Parameter gaussian_sigmas: Specifies the Gaussian sigmas :param nx.GeometrySelectionParameter input_image_geometry_path: DataPath to interpolated geometry :param nx.ArraySelectionParameter input_mask_path: DataPath to the boolean mask array. Values that are true will mark that cell/point as usable. :param nx.GeometrySelectionParameter input_vertex_geometry_path: DataPath to geometry to interpolate :param nx.MultiArraySelectionParameter interpolate_arrays: DataPaths to interpolate :param nx.DataObjectNameParameter interpolated_group_name: DataPath to created DataGroup for interpolated data :param nx.ChoicesParameter interpolation_index: Selected Interpolation Technique :param nx.DataObjectNameParameter kernel_distances_array_name: DataPath to created DataGroup for kernel distances data :param nx.VectorFloat32Parameter kernel_size: Specifies the kernel size :param nx.BoolParameter store_kernel_distances: Specifies whether or not to store kernel distances :param nx.BoolParameter use_mask: Specifies whether or not to use a mask array :param nx.ArraySelectionParameter voxel_indices_path: DataPath to voxel indices :return: Returns a :ref:`nx.IFilter.ExecuteResult ` object that holds any warnings and/or errors that were encountered during execution. :rtype: :ref:`nx.IFilter.ExecuteResult ` Iterative Closest Point ----------------------- .. index:: pair: Filter Human Names; Iterative Closest Point .. index:: pair: Filter Class Names; IterativeClosestPointFilter .. _IterativeClosestPointFilter: .. py:class:: 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 | +-----------------------------------------+-----------------------------------+ .. py:method:: Execute(data_structure, apply_transformation, input_moving_vertex_geometry_path, input_target_vertex_geometry_path, num_iterations, transform_array_path) :param DataStructure data_structure: The DataStructure object that holds the data to be processed. :param nx.BoolParameter apply_transformation: If checked, geometry will be updated implicitly :param nx.GeometrySelectionParameter input_moving_vertex_geometry_path: The geometry to align [mutable] :param nx.GeometrySelectionParameter input_target_vertex_geometry_path: The geometry to be matched against [immutable] :param nx.UInt64Parameter num_iterations: The number of times to run the algorithm [more increases accuracy] :param nx.ArrayCreationParameter transform_array_path: This is the array to store the transform matrix in :return: Returns a :ref:`nx.IFilter.ExecuteResult ` object that holds any warnings and/or errors that were encountered during execution. :rtype: :ref:`nx.IFilter.ExecuteResult ` Label CAD Geometry ------------------ .. index:: pair: Filter Human Names; Label CAD Geometry .. index:: pair: Filter Class Names; LabelTriangleGeometryFilter .. _LabelTriangleGeometryFilter: .. py:class:: 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 | +------------------------------------+--------------------------------+ .. py:method:: Execute(data_structure, created_region_ids_path, input_triangle_geometry_path, num_triangles_name, triangle_attribute_matrix_name) :param DataStructure data_structure: The DataStructure object that holds the data to be processed. :param nx.ArrayCreationParameter created_region_ids_path: The triangle id array for indexing into triangle groupings :param nx.GeometrySelectionParameter input_triangle_geometry_path: The CAD Geometry to be labeled (TriangleGeom) :param nx.DataObjectNameParameter num_triangles_name: The name of array created in the new AM that stores the number of triangles per group :param nx.DataObjectNameParameter triangle_attribute_matrix_name: The name of the Cell Feature Attribute Matrix that will hold information arrays about each group; created in the CAD geometry :return: Returns a :ref:`nx.IFilter.ExecuteResult ` object that holds any warnings and/or errors that were encountered during execution. :rtype: :ref:`nx.IFilter.ExecuteResult ` Laplacian Smoothing ------------------- .. index:: pair: Filter Human Names; Laplacian Smoothing .. index:: pair: Filter Class Names; LaplacianSmoothingFilter .. _LaplacianSmoothingFilter: .. py:class:: 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 | +-------------------------------+-----------------------------------+ .. py:method:: 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) :param DataStructure data_structure: The DataStructure object that holds the data to be processed. :param nx.GeometrySelectionParameter input_triangle_geometry_path: The complete path to the surface mesh Geometry for which to apply Laplacian smoothing :param nx.Int32Parameter iteration_steps: 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! :param nx.Float32Parameter lambda_value: Value of λ to apply to general internal nodes that are not triple lines, quadruple points or on the surface of the volume :param nx.Float32Parameter mu_factor: 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. :param nx.Float32Parameter quad_point_lambda: Value of λ to apply to nodes designated as quadruple points. :param nx.ArraySelectionParameter surface_mesh_node_type_array_path: The complete path to the array specifying the type of node in the Geometry :param nx.Float32Parameter surface_point_lambda: The value of λ to apply to nodes that lie on the outer surface of the volume :param nx.Float32Parameter surface_quad_point_lambda: Value of λ for the quadruple Points that lie on the outer surface of the volume. :param nx.Float32Parameter surface_triple_line_lambda: Value of λ for triple lines that lie on the outer surface of the volume :param nx.Float32Parameter triple_line_lambda: Value of λ to apply to nodes designated as triple line nodes. :param nx.BoolParameter use_taubin_smoothing: Use Taubin's Lambda-Mu algorithm. :return: Returns a :ref:`nx.IFilter.ExecuteResult ` object that holds any warnings and/or errors that were encountered during execution. :rtype: :ref:`nx.IFilter.ExecuteResult ` Map Point Cloud to Regular Grid ------------------------------- .. index:: pair: Filter Human Names; Map Point Cloud to Regular Grid .. index:: pair: Filter Class Names; MapPointCloudToRegularGridFilter .. _MapPointCloudToRegularGridFilter: .. py:class:: 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 | +-------------------------+------------------------------+ .. py:method:: 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) :param DataStructure data_structure: The DataStructure object that holds the data to be processed. :param nx.DataObjectNameParameter cell_data_name: The name of the cell data attribute matrix to be created within the created Image Geometry :param nx.VectorInt32Parameter grid_dimensions: Target grid size :param nx.GeometrySelectionParameter input_image_geometry_path: Path to the existing Image Geometry :param nx.GeometrySelectionParameter input_vertex_geometry_path: Path to the target Vertex Geometry :param nx.ArraySelectionParameter mask_path: DataPath to the boolean/uint8 mask array. Values that are true will mark that cell/point as usable. :param nx.ChoicesParameter out_of_bounds_handling_index: Specifies how data outside the image bounds is handled, see documentation for specification :param nx.UInt64Parameter out_of_bounds_value: The value to be put in voxel indices slots, occurs when the vertex geometry's coordinate point falls outside the image geometry's bounds :param nx.DataGroupCreationParameter output_image_geometry_path: Path to create the Image Geometry :param nx.ChoicesParameter sampling_grid_index: Specifies how data is saved or accessed :param nx.BoolParameter use_mask: Specifies whether or not to use a mask array :param nx.DataObjectNameParameter voxel_indices_name: Path to the created Voxel Indices array :return: Returns a :ref:`nx.IFilter.ExecuteResult ` object that holds any warnings and/or errors that were encountered during execution. :rtype: :ref:`nx.IFilter.ExecuteResult ` Move Data --------- .. index:: pair: Filter Human Names; Move Data .. index:: pair: Filter Class Names; MoveDataFilter .. _MoveDataFilter: .. py:class:: 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 | +--------------+-------------------------+ .. py:method:: Execute(data_structure, destination_parent_path, source_data_paths) :param DataStructure data_structure: The DataStructure object that holds the data to be processed. :param nx.DataGroupSelectionParameter destination_parent_path: The complete path to the parent data object to which the data will be moved :param nx.MultiPathSelectionParameter source_data_paths: The complete paths to the data object(s) to be moved :return: Returns a :ref:`nx.IFilter.ExecuteResult ` object that holds any warnings and/or errors that were encountered during execution. :rtype: :ref:`nx.IFilter.ExecuteResult ` Multi-Threshold Objects ----------------------- .. index:: pair: Filter Human Names; Multi-Threshold Objects .. index:: pair: Filter Class Names; MultiThresholdObjectsFilter .. _MultiThresholdObjectsFilter: .. py:class:: 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 | +------------------------+-------------------------+ .. py:method:: 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) :param DataStructure data_structure: The DataStructure object that holds the data to be processed. :param nx.ArrayThresholdsParameter array_thresholds_object: DataArray thresholds to mask :param nx.DataTypeParameter created_mask_type: DataType used for the created Mask Array :param nx.Float64Parameter custom_false_value: This is the custom FALSE value that will be output to the mask array :param nx.Float64Parameter custom_true_value: This is the custom TRUE value that will be output to the mask array :param nx.DataObjectNameParameter output_data_array_name: DataPath to the created Mask Array :param nx.BoolParameter use_custom_false_value: Specifies whether to output a custom FALSE value (the default value is 0) :param nx.BoolParameter use_custom_true_value: Specifies whether to output a custom TRUE value (the default value is 1) :return: Returns a :ref:`nx.IFilter.ExecuteResult ` object that holds any warnings and/or errors that were encountered during execution. :rtype: :ref:`nx.IFilter.ExecuteResult ` Fuse Regular Grids (Nearest Point) ---------------------------------- .. index:: pair: Filter Human Names; Fuse Regular Grids (Nearest Point) .. index:: pair: Filter Class Names; NearestPointFuseRegularGridsFilter .. _NearestPointFuseRegularGridsFilter: .. py:class:: 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 | +---------------------------------+--------------------------------------+ .. py:method:: 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) :param DataStructure data_structure: The DataStructure object that holds the data to be processed. :param nx.Float64Parameter fill_value: This is the value that will appear in the arrays outside the overlap :param nx.GeometrySelectionParameter input_reference_image_geometry__path: This is the geometry that will store the values from the overlap :param nx.GeometrySelectionParameter input_sampling_image_geometry_path: This is the geometry that will be copied into the reference geometry at the overlap :param nx.AttributeMatrixSelectionParameter reference_cell_attribute_matrix_path: The attribute matrix for the reference geometry :param nx.AttributeMatrixSelectionParameter sampling_cell_attribute_matrix_path: The attribute matrix for the sampling geometry :param nx.BoolParameter use_fill: If false all copied arrays will be filled with 0 by default :return: Returns a :ref:`nx.IFilter.ExecuteResult ` object that holds any warnings and/or errors that were encountered during execution. :rtype: :ref:`nx.IFilter.ExecuteResult ` Partition Geometry ------------------ .. index:: pair: Filter Human Names; Partition Geometry .. index:: pair: Filter Class Names; PartitionGeometryFilter .. _PartitionGeometryFilter: .. py:class:: 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 | +----------------------------------------+--------------------------------------+ .. py:method:: 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) :param DataStructure data_structure: The DataStructure object that holds the data to be processed. :param nx.DataObjectNameParameter created_attribute_matrix_name: The name of the cell attribute matrix that will contain the partition grid's cell data arrays. :param nx.DataObjectNameParameter created_feature_ids_name: The name of the feature ids array that will contain the feature ids of the generated partition grid. :param nx.GeometrySelectionParameter existing_partitioning_scheme_path: This is an existing Image Geometry that defines the partition grid that will be used. :param nx.DataObjectNameParameter feature_attr_matrix_name: The name of the feature attribute matrix that will be created as a child of the input geometry. :param nx.AttributeMatrixSelectionParameter input_geometry_attribute_matrix_path: The attribute matrix that represents the cell data for the geometry.(Vertex=>Node Geometry, Cell=>Image/Rectilinear) :param nx.GeometrySelectionParameter input_geometry_path: The input geometry that will be partitioned :param nx.VectorFloat32Parameter length_per_partition: The length in physical units for each cell in the partition grid. The physical units are automatically set by the input geometry. :param nx.VectorFloat32Parameter lower_left_coord: Minimum grid coordinate used to create the partition grid :param nx.VectorInt32Parameter number_of_partitions_per_axis: The number of cells along each axis of the partition grid :param nx.Int32Parameter out_of_bounds_value: The value used as the feature id for voxels/nodes that are outside the bounds of the partition grid. :param nx.DataGroupCreationParameter output_image_geometry_path: The complete path to the created partition grid geometry :param nx.DataObjectNameParameter partition_ids_array_name: The name of the partition ids output array stored in the input cell attribute matrix :param nx.ChoicesParameter partitioning_mode_index: Mode can be 'Basic (0)', 'Advanced (1)', 'Bounding Box (2)', 'Existing Partition Grid (3)' :param nx.VectorFloat32Parameter partitioning_scheme_origin: The origin of the generated partition geometry :param nx.Int32Parameter starting_partition_id: The value to start the partition grid's feature ids at. :param nx.VectorFloat32Parameter upper_right_coord: Maximum grid coordinate used to create the partition grid :param nx.BoolParameter use_vertex_mask: 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 :param nx.ArraySelectionParameter vertex_mask_path: The complete path to the vertex mask array. :return: Returns a :ref:`nx.IFilter.ExecuteResult ` object that holds any warnings and/or errors that were encountered during execution. :rtype: :ref:`nx.IFilter.ExecuteResult ` Point Sample Triangle Geometry ------------------------------ .. index:: pair: Filter Human Names; Point Sample Triangle Geometry .. index:: pair: Filter Class Names; PointSampleTriangleGeometryFilter .. _PointSampleTriangleGeometryFilter: .. py:class:: 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 | +-----------------------------------+------------------------------+ .. py:method:: 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) :param DataStructure data_structure: The DataStructure object that holds the data to be processed. :param nx.MultiArraySelectionParameter input_data_array_paths: The paths to the Face Attribute Arrays to transfer to the created Vertex Geometry where the mask is false, if Use Mask is checked :param nx.GeometrySelectionParameter input_triangle_geometry_path: The complete path to the triangle Geometry from which to sample :param nx.ArraySelectionParameter mask_array_path: DataPath to the boolean mask array. Values that are true will mark that cell/point as usable. :param nx.Int32Parameter number_of_samples: The number of sample points to use :param nx.DataGroupCreationParameter output_vertex_geometry_path: The complete path to the DataGroup holding the Vertex Geometry that represents the sampling points :param nx.DataObjectNameParameter seed_array_name: Name of array holding the seed value :param nx.UInt64Parameter seed_value: The seed fed into the random generator :param nx.ArraySelectionParameter triangle_areas_array_path: The complete path to the array specifying the area of each Face :param nx.BoolParameter use_mask: Specifies whether or not to use a mask array :param nx.BoolParameter use_seed: When true the user will be able to put in a seed for random generation :param nx.DataObjectNameParameter vertex_data_group_name: The complete path to the vertex data arrays for the Vertex Geometry :return: Returns a :ref:`nx.IFilter.ExecuteResult ` object that holds any warnings and/or errors that were encountered during execution. :rtype: :ref:`nx.IFilter.ExecuteResult ` Create Surface Mesh (QuickMesh) ------------------------------- .. index:: pair: Filter Human Names; Create Surface Mesh (QuickMesh) .. index:: pair: Filter Class Names; QuickSurfaceMeshFilter .. _QuickSurfaceMeshFilter: .. py:class:: 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 | +-------------------------------------+------------------------------------+ .. py:method:: 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) :param DataStructure data_structure: The DataStructure object that holds the data to be processed. :param nx.DataObjectNameParameter face_data_group_name: The complete path to the DataGroup where the Face Data of the Triangle Geometry will be created :param nx.DataObjectNameParameter face_feature_attribute_matrix_name: The complete path to the DataGroup where the Feature Data will be stored. :param nx.DataObjectNameParameter face_labels_array_name: The name of the Array specifying which Features are on either side of each Face in the Triangle Geometry :param nx.ArraySelectionParameter feature_ids_path: The complete path to the Array specifying which Feature each Cell belongs to :param nx.BoolParameter fix_problem_voxels: See help page. :param nx.BoolParameter generate_triple_lines: Experimental feature. May not work. :param nx.MultiArraySelectionParameter input_data_array_paths: The paths to the Arrays specifying which Cell Attribute Arrays to transfer to the created Triangle Geometry :param nx.GeometrySelectionParameter input_grid_geometry_path: The complete path to the Grid Geometry from which to create a Triangle Geometry :param nx.DataObjectNameParameter node_types_array_name: The name of the Array specifying the type of node in the Triangle Geometry :param nx.DataGroupCreationParameter output_triangle_geometry_path: The name of the created Triangle Geometry :param nx.DataObjectNameParameter vertex_data_group_name: The complete path to the DataGroup where the Vertex Data of the Triangle Geometry will be created :return: Returns a :ref:`nx.IFilter.ExecuteResult ` object that holds any warnings and/or errors that were encountered during execution. :rtype: :ref:`nx.IFilter.ExecuteResult ` Read North Star Imaging CT (.nsihdr/.nsidat) -------------------------------------------- .. index:: pair: Filter Human Names; Read North Star Imaging CT (.nsihdr/.nsidat) .. index:: pair: Filter Class Names; ReadBinaryCTNorthstarFilter .. _ReadBinaryCTNorthstarFilter: .. py:class:: 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 | +----------------------------------+----------------------------+ .. py:method:: 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) :param DataStructure data_structure: The DataStructure object that holds the data to be processed. :param nx.DataObjectNameParameter cell_attribute_matrix_name: The name used to create the Cell Attribute Matrix. :param nx.DataObjectNameParameter density_array_name: The name used to create the Density data array. :param nx.VectorInt32Parameter end_voxel_coord: The ending subvolume voxel (inclusive) :param nx.BoolParameter import_subvolume: Import a subvolume instead of the entire volume :param nx.FileSystemPathParameter input_header_file: The path to the .nsihdr file :param nx.DataGroupCreationParameter input_image_geometry_path: The path that will be used to create the Image Geometry. :param nx.ChoicesParameter length_unit_index: The length unit that will be set into the created image geometry :param nx.VectorInt32Parameter start_voxel_coord: The starting subvolume voxel :return: Returns a :ref:`nx.IFilter.ExecuteResult ` object that holds any warnings and/or errors that were encountered during execution. :rtype: :ref:`nx.IFilter.ExecuteResult ` Read CSV File ------------- .. index:: pair: Filter Human Names; Read CSV File .. index:: pair: Filter Class Names; ReadCSVFileFilter .. _ReadCSVFileFilter: .. py:class:: 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 | +---------------------------------------------+--------------------------------+ .. py:method:: Execute(data_structure, created_data_group_path, read_csv_data_object, selected_attribute_matrix_path, use_existing_group) :param DataStructure data_structure: The DataStructure object that holds the data to be processed. :param nx.DataGroupCreationParameter created_data_group_path: Store the imported CSV data arrays in a newly created attribute matrix. :param nx.ReadCSVFileParameter read_csv_data_object: Holds all relevant csv file data collected from the custom interface :param nx.DataGroupSelectionParameter selected_attribute_matrix_path: Store the imported CSV data arrays in an existing data group or attribute matrix. :param nx.BoolParameter use_existing_group: Store the imported CSV data arrays in an existing data group or attribute matrix. :return: Returns a :ref:`nx.IFilter.ExecuteResult ` object that holds any warnings and/or errors that were encountered during execution. :rtype: :ref:`nx.IFilter.ExecuteResult ` Read DREAM3D-NX File -------------------- .. index:: pair: Filter Human Names; Read DREAM3D-NX File .. index:: pair: Filter Class Names; ReadDREAM3DFilter .. _ReadDREAM3DFilter: .. py:class:: 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 | +------------------+-----------------------+ .. py:method:: Execute(data_structure, import_data_object) :param DataStructure data_structure: The DataStructure object that holds the data to be processed. :param nx.Dream3dImportParameter import_data_object: The HDF5 file path the DataStructure should be imported from. :return: Returns a :ref:`nx.IFilter.ExecuteResult ` object that holds any warnings and/or errors that were encountered during execution. :rtype: :ref:`nx.IFilter.ExecuteResult ` Read Deform Key File (v12) -------------------------- .. index:: pair: Filter Human Names; Read Deform Key File (v12) .. index:: pair: Filter Class Names; ReadDeformKeyFileV12Filter .. _ReadDeformKeyFileV12Filter: .. py:class:: 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 | +------------------+------------------------------+ .. py:method:: Execute(data_structure, cell_attribute_matrix_name, input_file_path, output_quad_geometry_path, vertex_attribute_matrix_name) :param DataStructure data_structure: The DataStructure object that holds the data to be processed. :param nx.DataObjectNameParameter cell_attribute_matrix_name: The name of the created Attribute Matrix for cell data :param nx.FileSystemPathParameter input_file_path: File path that points to the imported file :param nx.DataGroupCreationParameter output_quad_geometry_path: The created Quad Geometry from imported from file :param nx.DataObjectNameParameter vertex_attribute_matrix_name: The name of the created Attribute Matrix for vertex data :return: Returns a :ref:`nx.IFilter.ExecuteResult ` object that holds any warnings and/or errors that were encountered during execution. :rtype: :ref:`nx.IFilter.ExecuteResult ` Read HDF5 Dataset ----------------- .. index:: pair: Filter Human Names; Read HDF5 Dataset .. index:: pair: Filter Class Names; ReadHDF5DatasetFilter .. _ReadHDF5DatasetFilter: .. py:class:: 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 | +------------------+-----------------------+ .. py:method:: Execute(data_structure, import_hdf5_object) :param DataStructure data_structure: The DataStructure object that holds the data to be processed. :param nx.ReadHDF5DatasetParameter import_hdf5_object: The HDF5 file data to import :return: Returns a :ref:`nx.IFilter.ExecuteResult ` object that holds any warnings and/or errors that were encountered during execution. :rtype: :ref:`nx.IFilter.ExecuteResult ` Read Raw Binary --------------- .. index:: pair: Filter Human Names; Read Raw Binary .. index:: pair: Filter Class Names; ReadRawBinaryFilter .. _ReadRawBinaryFilter: .. py:class:: 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 | +------------------------+------------------------------+ .. py:method:: Execute(data_structure, created_attribute_array_path, endian_index, input_file, number_of_components, scalar_type_index, skip_header_bytes, tuple_dimensions) :param DataStructure data_structure: The DataStructure object that holds the data to be processed. :param nx.ArrayCreationParameter created_attribute_array_path: The complete path to the created Attribute Array :param nx.ChoicesParameter endian_index: The endianness of the data :param nx.FileSystemPathParameter input_file: The input binary file path :param nx.UInt64Parameter number_of_components: The number of values at each tuple :param nx.NumericTypeParameter scalar_type_index: Data type of the binary data :param nx.UInt64Parameter skip_header_bytes: Number of bytes to skip before reading data :param nx.DynamicTableParameter tuple_dimensions: Slowest to Fastest Dimensions (ZYX for example) :return: Returns a :ref:`nx.IFilter.ExecuteResult ` object that holds any warnings and/or errors that were encountered during execution. :rtype: :ref:`nx.IFilter.ExecuteResult ` Read STL File ------------- .. index:: pair: Filter Human Names; Read STL File .. index:: pair: Filter Class Names; ReadStlFileFilter .. _ReadStlFileFilter: .. py:class:: 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 | +-------------------------------+-------------------------------+ .. py:method:: 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) :param DataStructure data_structure: The DataStructure object that holds the data to be processed. :param nx.BoolParameter create_face_labels: When true, the 'Face Labels' array will be created. :param nx.DataObjectNameParameter face_attribute_matrix_name: The name of the AttributeMatrix where the Face Data of the Triangle Geometry will be created :param nx.DataObjectNameParameter face_labels_name: The name of the 'Face Labels' data array :param nx.DataObjectNameParameter face_normals_name: The name of the triangle normals data array :param nx.DataGroupCreationParameter output_triangle_geometry_path: The name of the created Triangle Geometry :param nx.Float32Parameter scale_factor: The factor by which to scale the geometry :param nx.BoolParameter scale_output: Scale the output Triangle Geometry by the Scaling Factor :param nx.FileSystemPathParameter stl_file_path: Input STL File :param nx.DataObjectNameParameter vertex_attribute_matrix_name: The name of the AttributeMatrix where the Vertex Data of the Triangle Geometry will be created :return: Returns a :ref:`nx.IFilter.ExecuteResult ` object that holds any warnings and/or errors that were encountered during execution. :rtype: :ref:`nx.IFilter.ExecuteResult ` Read String Data Array ---------------------- .. index:: pair: Filter Human Names; Read String Data Array .. index:: pair: Filter Class Names; ReadStringDataArrayFilter .. _ReadStringDataArrayFilter: .. py:class:: 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 | +----------------------------------------------------------------------------+------------------------+ .. py:method:: Execute(data_structure, data_format, delimiter_index, input_file, number_tuples, output_data_array_path, set_tuple_dimensions, skip_line_count) :param DataStructure data_structure: The DataStructure object that holds the data to be processed. :param nx.DataStoreFormatParameter data_format: This value will specify which data format is used by the array's data store. An empty string results in in-memory data store. :param nx.ChoicesParameter delimiter_index: Delimiter for values on a line :param nx.FileSystemPathParameter input_file: File path that points to the imported file :param nx.DynamicTableParameter number_tuples: Slowest to Fastest Dimensions. Note this might be opposite displayed by an image geometry. :param nx.ArrayCreationParameter output_data_array_path: DataPath or Name for the underlying Data Array :param nx.BoolParameter set_tuple_dimensions: 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 :param nx.UInt64Parameter skip_line_count: Number of lines at the start of the file to skip :return: Returns a :ref:`nx.IFilter.ExecuteResult ` object that holds any warnings and/or errors that were encountered during execution. :rtype: :ref:`nx.IFilter.ExecuteResult ` Read Text Data Array -------------------- .. index:: pair: Filter Human Names; Read Text Data Array .. index:: pair: Filter Class Names; ReadTextDataArrayFilter .. _ReadTextDataArrayFilter: .. py:class:: 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 | +----------------------------------------------------------------------------+------------------------+ .. py:method:: 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) :param DataStructure data_structure: The DataStructure object that holds the data to be processed. :param nx.DataStoreFormatParameter data_format: This value will specify which data format is used by the array's data store. An empty string results in in-memory data store. :param nx.ChoicesParameter delimiter_index: Delimiter for values on a line :param nx.FileSystemPathParameter input_file: File path that points to the imported file :param nx.UInt64Parameter number_comp: Number of columns :param nx.DynamicTableParameter number_tuples: Slowest to Fastest Dimensions. Note this might be opposite displayed by an image geometry. :param nx.ArrayCreationParameter output_data_array_path: DataPath or Name for the underlying Data Array :param nx.NumericTypeParameter scalar_type_index: Data Type to interpret and store data into. :param nx.BoolParameter set_tuple_dimensions: 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 :param nx.UInt64Parameter skip_line_count: Number of lines at the start of the file to skip :return: Returns a :ref:`nx.IFilter.ExecuteResult ` object that holds any warnings and/or errors that were encountered during execution. :rtype: :ref:`nx.IFilter.ExecuteResult ` Read Volume Graphics File (.vgi/.vol) ------------------------------------- .. index:: pair: Filter Human Names; Read Volume Graphics File (.vgi/.vol) .. index:: pair: Filter Class Names; ReadVolumeGraphicsFileFilter .. _ReadVolumeGraphicsFileFilter: .. py:class:: 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 | +---------------------------+----------------------------+ .. py:method:: Execute(data_structure, cell_attribute_matrix_name, density_array_name, output_image_geometry_path, vg_header_file) :param DataStructure data_structure: The DataStructure object that holds the data to be processed. :param nx.DataObjectNameParameter cell_attribute_matrix_name: The attribute matrix created as a child of the image geometry :param nx.DataObjectNameParameter density_array_name: The data array created as a child of the attribute matrix :param nx.DataGroupCreationParameter output_image_geometry_path: Path to create the Image Geometry :param nx.FileSystemPathParameter vg_header_file: The input VolumeGraphics file :return: Returns a :ref:`nx.IFilter.ExecuteResult ` object that holds any warnings and/or errors that were encountered during execution. :rtype: :ref:`nx.IFilter.ExecuteResult ` Read Vtk Structured Points File ------------------------------- .. index:: pair: Filter Human Names; Read Vtk Structured Points File .. index:: pair: Filter Class Names; ReadVtkStructuredPointsFilter .. _ReadVtkStructuredPointsFilter: .. py:class:: 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 | +------------------------------------+------------------------------+ .. py:method:: 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) :param DataStructure data_structure: The DataStructure object that holds the data to be processed. :param nx.DataObjectNameParameter cell_attribute_matrix_name: The attribute matrix for the Cell Data. :param nx.FileSystemPathParameter input_file: The path to the input file :param nx.DataGroupCreationParameter output_image_geometry_path: The data container for the Cell Data. :param nx.DataGroupCreationParameter output_vertex_geometry_path: The data container for the Point Data. :param nx.BoolParameter read_cell_data: Determines whether or not the Cell Data will be read. :param nx.BoolParameter read_point_data: Determines whether or not the Point Data will be read. :param nx.DataObjectNameParameter vertex_attribute_matrix_name: The attribute matrix for the Point Data. :return: Returns a :ref:`nx.IFilter.ExecuteResult ` object that holds any warnings and/or errors that were encountered during execution. :rtype: :ref:`nx.IFilter.ExecuteResult ` Sample Triangle Geometry on Regular Grid ---------------------------------------- .. index:: pair: Filter Human Names; Sample Triangle Geometry on Regular Grid .. index:: pair: Filter Class Names; RegularGridSampleSurfaceMeshFilter .. _RegularGridSampleSurfaceMeshFilter: .. py:class:: 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 | +-------------------------------------+-------------------------------------+ .. py:method:: 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) :param DataStructure data_structure: The DataStructure object that holds the data to be processed. :param nx.DataObjectNameParameter cell_attribute_matrix_name: The name for the cell data Attribute Matrix within the Image geometry :param nx.VectorUInt64Parameter dimensions: The dimensions of the created Image geometry :param nx.DataObjectNameParameter feature_ids_array_name: The name for the feature ids array in cell data Attribute Matrix :param nx.DataGroupCreationParameter input_image_geometry_path: The name and path for the image geometry to be created :param nx.GeometrySelectionParameter input_triangle_geometry_path: The geometry to be sampled onto grid :param nx.ChoicesParameter length_unit_index: The units to be displayed below :param nx.VectorFloat32Parameter origin: The origin of the created Image geometry :param nx.VectorFloat32Parameter spacing: The spacing of the created Image geometry :param nx.ArraySelectionParameter surface_mesh_face_labels_array_path: Array specifying which Features are on either side of each Face :return: Returns a :ref:`nx.IFilter.ExecuteResult ` object that holds any warnings and/or errors that were encountered during execution. :rtype: :ref:`nx.IFilter.ExecuteResult ` Remove Flagged Edges -------------------- .. index:: pair: Filter Human Names; Remove Flagged Edges .. index:: pair: Filter Class Names; RemoveFlaggedEdgesFilter .. _RemoveFlaggedEdgesFilter: .. py:class:: 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 | +---------------------------------+--------------------------------------------+ .. py:method:: 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) :param DataStructure data_structure: The DataStructure object that holds the data to be processed. :param nx.ChoicesParameter edge_data_handling_index: How to handle Data that resides on the edges :param nx.MultiArraySelectionParameter edge_data_selected_array_paths: Edge DataPaths to copy :param nx.AttributeMatrixSelectionParameter edge_data_selected_attribute_matrix_path: Edge Attribute Matrix that will be copied to the reduced geometry :param nx.GeometrySelectionParameter input_edge_geometry_path: The Edge Geometry that will be processed. :param nx.ArraySelectionParameter mask_array_path: The DataArrayPath to the mask array that marks each edge as either true (remove) or false(keep). :param nx.DataGroupCreationParameter output_edge_geometry_path: The name of the created Edge Geometry :param nx.ChoicesParameter vertex_data_handling_index: How to handle Data that resides on the edges :param nx.MultiArraySelectionParameter vertex_data_selected_array_paths: Vertex DataPaths to copy :param nx.AttributeMatrixSelectionParameter vertex_data_selected_attribute_matrix_path: Vertex Attribute Matrix that will be copied to the reduced geometry :return: Returns a :ref:`nx.IFilter.ExecuteResult ` object that holds any warnings and/or errors that were encountered during execution. :rtype: :ref:`nx.IFilter.ExecuteResult ` Remove/Extract Flagged Features ------------------------------- .. index:: pair: Filter Human Names; Remove/Extract Flagged Features .. index:: pair: Filter Class Names; RemoveFlaggedFeaturesFilter .. _RemoveFlaggedFeaturesFilter: .. py:class:: 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 | +-------------------------------+------------------------------+ .. py:method:: 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) :param DataStructure data_structure: The DataStructure object that holds the data to be processed. :param nx.ArraySelectionParameter feature_ids_path: Specifies to which Feature each cell belongs :param nx.BoolParameter fill_removed_features: Whether or not to fill in the gaps left by the removed Features :param nx.ArraySelectionParameter flagged_features_array_path: Specifies whether the Feature will remain in the structure or not :param nx.MultiArraySelectionParameter ignored_data_array_paths: The list of arrays to ignore when removing flagged features :param nx.GeometrySelectionParameter input_image_geometry_path: The target geometry :param nx.ChoicesParameter operation_type_index: Whether to [0] remove features, [1] extract features into new geometry or [2] extract and then remove :param nx.StringParameter output_image_geometry_prefix: The prefix name for each of new cropped (extracted) geometry NOTE: a '-' will automatically be added between the prefix and number :return: Returns a :ref:`nx.IFilter.ExecuteResult ` object that holds any warnings and/or errors that were encountered during execution. :rtype: :ref:`nx.IFilter.ExecuteResult ` Remove Flagged Triangles ------------------------ .. index:: pair: Filter Human Names; Remove Flagged Triangles .. index:: pair: Filter Class Names; RemoveFlaggedTrianglesFilter .. _RemoveFlaggedTrianglesFilter: .. py:class:: 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 | +-----------------------------------+----------------------------------------------+ .. py:method:: 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) :param DataStructure data_structure: The DataStructure object that holds the data to be processed. :param nx.GeometrySelectionParameter input_triangle_geometry_path: The Triangle Geometry that will be processed. :param nx.ArraySelectionParameter mask_array_path: The DataArrayPath to the mask array that marks each face as either true (remove) or false(keep). :param nx.DataGroupCreationParameter output_triangle_geometry_path: The name of the created Triangle Geometry :param nx.ChoicesParameter triangle_data_handling_index: How to handle Data that resides on the triangles :param nx.MultiArraySelectionParameter triangle_data_selected_array_paths: Triangle DataPaths to copy :param nx.AttributeMatrixSelectionParameter triangle_data_selected_attribute_matrix_path: Triangle Attribute Matrix that will be copied to the reduced geometry :param nx.ChoicesParameter vertex_data_handling_index: How to handle Data that resides on the triangles :param nx.MultiArraySelectionParameter vertex_data_selected_array_paths: Vertex DataPaths to copy :param nx.AttributeMatrixSelectionParameter vertex_data_selected_attribute_matrix_path: Vertex Attribute Matrix that will be copied to the reduced geometry :return: Returns a :ref:`nx.IFilter.ExecuteResult ` object that holds any warnings and/or errors that were encountered during execution. :rtype: :ref:`nx.IFilter.ExecuteResult ` Remove Flagged Vertices ----------------------- .. index:: pair: Filter Human Names; Remove Flagged Vertices .. index:: pair: Filter Class Names; RemoveFlaggedVerticesFilter .. _RemoveFlaggedVerticesFilter: .. py:class:: 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 | +-----------------------------+-----------------------------+ .. py:method:: Execute(data_structure, input_vertex_geometry_path, mask_path, output_vertex_geometry_path) :param DataStructure data_structure: The DataStructure object that holds the data to be processed. :param nx.GeometrySelectionParameter input_vertex_geometry_path: Path to the target Vertex Geometry :param nx.ArraySelectionParameter mask_path: The DataArrayPath to the mask array that marks each face as either true (remove) or false(keep). :param nx.DataGroupCreationParameter output_vertex_geometry_path: Created Vertex Geometry DataPath. This will be created during the filter. :return: Returns a :ref:`nx.IFilter.ExecuteResult ` object that holds any warnings and/or errors that were encountered during execution. :rtype: :ref:`nx.IFilter.ExecuteResult ` Rename DataObject ----------------- .. index:: pair: Filter Human Names; Rename DataObject .. index:: pair: Filter Class Names; RenameDataObjectFilter .. _RenameDataObjectFilter: .. py:class:: 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 | +----------------------+-------------------------+ .. py:method:: Execute(data_structure, allow_overwrite, new_name, source_data_object_path) :param DataStructure data_structure: The DataStructure object that holds the data to be processed. :param nx.BoolParameter allow_overwrite: 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 :param nx.StringParameter new_name: Target DataObject name :param nx.DataPathSelectionParameter source_data_object_path: DataPath pointing to the target DataObject :return: Returns a :ref:`nx.IFilter.ExecuteResult ` object that holds any warnings and/or errors that were encountered during execution. :rtype: :ref:`nx.IFilter.ExecuteResult ` Replace Element Attributes with Neighbor (Threshold) ---------------------------------------------------- .. index:: pair: Filter Human Names; Replace Element Attributes with Neighbor (Threshold) .. index:: pair: Filter Class Names; ReplaceElementAttributesWithNeighborValuesFilter .. _ReplaceElementAttributesWithNeighborValuesFilter: .. py:class:: 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 | +-------------------------+---------------------------+ .. py:method:: Execute(data_structure, comparison_data_path, comparison_index, input_image_geometry_path, loop, min_confidence) :param DataStructure data_structure: The DataStructure object that holds the data to be processed. :param nx.ArraySelectionParameter comparison_data_path: The DataPath to the input array to use for comparison :param nx.ChoicesParameter comparison_index: The operator to use for comparisons. 0=Less, 1=Greater Than :param nx.GeometrySelectionParameter input_image_geometry_path: The target geometry :param nx.BoolParameter loop: The algorithm will keep looping until all pixels have been evaluated :param nx.Float32Parameter min_confidence: The value to of the threshold :return: Returns a :ref:`nx.IFilter.ExecuteResult ` object that holds any warnings and/or errors that were encountered during execution. :rtype: :ref:`nx.IFilter.ExecuteResult ` Require Minimum Number of Neighbors ----------------------------------- .. index:: pair: Filter Human Names; Require Minimum Number of Neighbors .. index:: pair: Filter Class Names; RequireMinNumNeighborsFilter .. _RequireMinNumNeighborsFilter: .. py:class:: 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 | +----------------------------+---------------------------+ .. py:method:: 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) :param DataStructure data_structure: The DataStructure object that holds the data to be processed. :param nx.BoolParameter apply_to_single_phase: Whether to apply minimum to single ensemble or all ensembles :param nx.ArraySelectionParameter feature_ids_path: Specifies to which Feature each Element belongs :param nx.ArraySelectionParameter feature_phases_path: Specifies to which Ensemble each Feature belongs. Only required if Apply to Single Phase Only is checked :param nx.MultiArraySelectionParameter ignored_voxel_arrays: The arrays to ignore when applying the minimum neighbors algorithm :param nx.GeometrySelectionParameter input_image_geometry_path: The target geometry :param nx.UInt64Parameter min_num_neighbors: Number of neighbors a Feature must have to remain as a Feature :param nx.ArraySelectionParameter num_neighbors_path: Number of contiguous neighboring Features for each Feature :param nx.UInt64Parameter phase_number: Which Ensemble to apply minimum to. Only needed if Apply to Single Phase Only is checked :return: Returns a :ref:`nx.IFilter.ExecuteResult ` object that holds any warnings and/or errors that were encountered during execution. :rtype: :ref:`nx.IFilter.ExecuteResult ` Remove Minimum Size Features ---------------------------- .. index:: pair: Filter Human Names; Remove Minimum Size Features .. index:: pair: Filter Class Names; RequireMinimumSizeFeaturesFilter .. _RequireMinimumSizeFeaturesFilter: .. py:class:: 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 | +-------------------------------+---------------------------+ .. py:method:: 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) :param DataStructure data_structure: The DataStructure object that holds the data to be processed. :param nx.BoolParameter apply_single_phase: Apply to Single Phase :param nx.ArraySelectionParameter feature_ids_path: DataPath to FeatureIds DataArray :param nx.ArraySelectionParameter feature_phases_path: DataPath to Feature Phases DataArray :param nx.GeometrySelectionParameter input_image_geometry_path: The input image geometry (cell) :param nx.Int64Parameter min_allowed_features_size: Minimum allowed features size :param nx.ArraySelectionParameter num_cells_path: DataPath to NumCells DataArray :param nx.Int64Parameter phase_number: Target phase to remove :return: Returns a :ref:`nx.IFilter.ExecuteResult ` object that holds any warnings and/or errors that were encountered during execution. :rtype: :ref:`nx.IFilter.ExecuteResult ` Resample Data (Image Geometry) ------------------------------ .. index:: pair: Filter Human Names; Resample Data (Image Geometry) .. index:: pair: Filter Class Names; ResampleImageGeomFilter .. _ResampleImageGeomFilter: .. py:class:: 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 | +----------------------------+------------------------------------+ .. py:method:: 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) :param DataStructure data_structure: The DataStructure object that holds the data to be processed. :param nx.AttributeMatrixSelectionParameter cell_feature_attribute_matrix_path: DataPath to the feature Attribute Matrix :param nx.VectorUInt64Parameter exact_dimensions: The exact dimension size values (dx, dy, dz) to resample the geometry, in pixels. :param nx.ArraySelectionParameter feature_ids_path: DataPath to Cell Feature IDs array :param nx.GeometrySelectionParameter input_image_geometry_path: The target geometry to resample :param nx.DataGroupCreationParameter new_data_container_path: The location of the resampled geometry :param nx.BoolParameter remove_original_geometry: Removes the original Image Geometry after filter is completed :param nx.BoolParameter renumber_features: Specifies if the feature IDs should be renumbered :param nx.ChoicesParameter resampling_mode_index: Mode can be [0] Spacing, [1] Scaling as Percent, [2] Exact Dimensions as voxels :param nx.VectorFloat32Parameter scaling: 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. :param nx.VectorFloat32Parameter spacing: The new spacing values (dx, dy, dz). Larger spacing will cause less voxels, smaller spacing will cause more voxels. :return: Returns a :ref:`nx.IFilter.ExecuteResult ` object that holds any warnings and/or errors that were encountered during execution. :rtype: :ref:`nx.IFilter.ExecuteResult ` Resample Rectilinear Grid to Image Geom --------------------------------------- .. index:: pair: Filter Human Names; Resample Rectilinear Grid to Image Geom .. index:: pair: Filter Class Names; ResampleRectGridToImageGeomFilter .. _ResampleRectGridToImageGeomFilter: .. py:class:: 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 | +--------------------------+---------------------------------------+ .. py:method:: Execute(data_structure, dimensions, image_geom_cell_attribute_matrix_name, input_data_array_paths, input_image_geometry_path, rectilinear_grid_path) :param DataStructure data_structure: The DataStructure object that holds the data to be processed. :param nx.VectorInt32Parameter dimensions: The image geometry voxel dimensions in which to re-sample the rectilinear grid geometry :param nx.DataObjectNameParameter image_geom_cell_attribute_matrix_name: The name of the cell data Attribute Matrix created with the Image Geometry :param nx.MultiArraySelectionParameter input_data_array_paths: Rectilinear Grid Cell Data to possibly copy :param nx.DataGroupCreationParameter input_image_geometry_path: Path to the created Image Geometry :param nx.GeometrySelectionParameter rectilinear_grid_path: Path to the RectGrid Geometry to be re-sampled :return: Returns a :ref:`nx.IFilter.ExecuteResult ` object that holds any warnings and/or errors that were encountered during execution. :rtype: :ref:`nx.IFilter.ExecuteResult ` Reshape Data Array ------------------ .. index:: pair: Filter Human Names; Reshape Data Array .. index:: pair: Filter Class Names; ReshapeDataArrayFilter .. _ReshapeDataArrayFilter: .. py:class:: 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 | +------------------------------------------------------+-----------------------+ .. py:method:: Execute(data_structure, input_array_path, tuple_dims) :param DataStructure data_structure: The DataStructure object that holds the data to be processed. :param nx.ArraySelectionParameter input_array_path: The input array that will be reshaped. :param nx.DynamicTableParameter tuple_dims: Slowest to Fastest Dimensions. Note this might be opposite displayed by an image geometry. :return: Returns a :ref:`nx.IFilter.ExecuteResult ` object that holds any warnings and/or errors that were encountered during execution. :rtype: :ref:`nx.IFilter.ExecuteResult ` Reverse Triangle Winding ------------------------ .. index:: pair: Filter Human Names; Reverse Triangle Winding .. index:: pair: Filter Class Names; ReverseTriangleWindingFilter .. _ReverseTriangleWindingFilter: .. py:class:: 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 | +-------------------+------------------------------+ .. py:method:: Execute(data_structure, input_triangle_geometry_path) :param DataStructure data_structure: The DataStructure object that holds the data to be processed. :param nx.GeometrySelectionParameter input_triangle_geometry_path: The DataPath to then input Triangle Geometry :return: Returns a :ref:`nx.IFilter.ExecuteResult ` object that holds any warnings and/or errors that were encountered during execution. :rtype: :ref:`nx.IFilter.ExecuteResult ` Robust Automatic Threshold -------------------------- .. index:: pair: Filter Human Names; Robust Automatic Threshold .. index:: pair: Filter Class Names; RobustAutomaticThresholdFilter .. _RobustAutomaticThresholdFilter: .. py:class:: 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 | +-------------------------+-----------------------+ .. py:method:: Execute(data_structure, created_mask_name, gradient_array_path, input_array_path) :param DataStructure data_structure: The DataStructure object that holds the data to be processed. :param nx.DataObjectNameParameter created_mask_name: Created mask based on Input Array and Gradient Magnitude :param nx.ArraySelectionParameter gradient_array_path: The complete path to the Array specifying the gradient magnitude of the Input Array :param nx.ArraySelectionParameter input_array_path: DataArray to Threshold :return: Returns a :ref:`nx.IFilter.ExecuteResult ` object that holds any warnings and/or errors that were encountered during execution. :rtype: :ref:`nx.IFilter.ExecuteResult ` Rotate Sample Reference Frame ----------------------------- .. index:: pair: Filter Human Names; Rotate Sample Reference Frame .. index:: pair: Filter Class Names; RotateSampleRefFrameFilter .. _RotateSampleRefFrameFilter: .. py:class:: 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 [w] | rotation_axis_angle | +----------------------------------+-------------------------------+ | Transformation Matrix | rotation_matrix | +----------------------------------+-------------------------------+ | Rotation Representation | rotation_representation_index | +----------------------------------+-------------------------------+ .. py:method:: 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) :param DataStructure data_structure: The DataStructure object that holds the data to be processed. :param nx.GeometrySelectionParameter input_image_geometry_path: The target geometry on which to perform the rotation :param nx.DataGroupCreationParameter output_image_geometry_path: The location of the rotated geometry :param nx.BoolParameter remove_original_geometry: Performs the rotation in-place for the given Image Geometry :param nx.BoolParameter rotate_slice_by_slice: This option is specific to EBSD Data and is not generally used. :param nx.VectorFloat32Parameter rotation_axis_angle: Axis-Angle in sample reference frame to rotate about. :param nx.DynamicTableParameter rotation_matrix: The 4x4 Transformation Matrix :param nx.ChoicesParameter rotation_representation_index: Which form used to represent rotation (axis angle or rotation matrix) :return: Returns a :ref:`nx.IFilter.ExecuteResult ` object that holds any warnings and/or errors that were encountered during execution. :rtype: :ref:`nx.IFilter.ExecuteResult ` Segment Features (Scalar) ------------------------- .. index:: pair: Filter Human Names; Segment Features (Scalar) .. index:: pair: Filter Class Names; ScalarSegmentFeaturesFilter .. _ScalarSegmentFeaturesFilter: .. py:class:: 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 | +--------------------------+---------------------------+ .. py:method:: 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) :param DataStructure data_structure: The DataStructure object that holds the data to be processed. :param nx.DataObjectNameParameter active_array_name: Created array :param nx.DataObjectNameParameter cell_feature_group_name: Created Cell Feature Attribute Matrix :param nx.DataObjectNameParameter feature_ids_name: Path to the created Feature IDs path :param nx.ArraySelectionParameter input_array_path: Path to the DataArray to segment :param nx.GeometrySelectionParameter input_image_geometry_path: DataPath to input Image Geometry :param nx.ArraySelectionParameter mask_path: Path to the DataArray Mask :param nx.BoolParameter randomize_features: Specifies if feature IDs should be randomized during calculations :param nx.Int32Parameter scalar_tolerance: Tolerance for segmenting input Cell Data :param nx.BoolParameter use_mask: Determines if a mask array is used for segmenting :return: Returns a :ref:`nx.IFilter.ExecuteResult ` object that holds any warnings and/or errors that were encountered during execution. :rtype: :ref:`nx.IFilter.ExecuteResult ` Set Origin & Spacing (Image Geom) --------------------------------- .. index:: pair: Filter Human Names; Set Origin & Spacing (Image Geom) .. index:: pair: Filter Class Names; SetImageGeomOriginScalingFilter .. _SetImageGeomOriginScalingFilter: .. py:class:: 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 | +--------------------------------------------+---------------------------+ .. py:method:: Execute(data_structure, center_origin, change_origin, change_spacing, input_image_geometry_path, origin, spacing) :param DataStructure data_structure: The DataStructure object that holds the data to be processed. :param nx.BoolParameter center_origin: Specifies if the origin should be aligned with the corner (false) or center (true) :param nx.BoolParameter change_origin: Specifies if the origin should be changed :param nx.BoolParameter change_spacing: Specifies if the spacing should be changed :param nx.GeometrySelectionParameter input_image_geometry_path: Path to the target ImageGeom :param nx.VectorFloat32Parameter origin: Specifies the new origin values in physical units. :param nx.VectorFloat32Parameter spacing: Specifies the new spacing values in physical units. :return: Returns a :ref:`nx.IFilter.ExecuteResult ` object that holds any warnings and/or errors that were encountered during execution. :rtype: :ref:`nx.IFilter.ExecuteResult ` Compute Triangle Face Ids ------------------------- .. index:: pair: Filter Human Names; Compute Triangle Face Ids .. index:: pair: Filter Class Names; SharedFeatureFaceFilter .. _SharedFeatureFaceFilter: .. py:class:: SharedFeatureFaceFilter This **Filter** assigns a unique Id to each **Triangle** in a **Triangle Geometry** that represents the _unique boundary_on which that **Triangle** resides. For example, if there were only two **Features** that shared one boundary,then the **Triangles** on that boundary would be labeled with a single unique Id. This procedure creates _unique groups_of **Triangles**, which themselves are a set of **Features**. Thus, this **Filter** also creates a **Feature AttributeMatrix** for this new set of **Features**, and creates **Attribute Arrays** for their Ids and number of **Triangles**. Thisprocess can be considered a **segmentation** where each unique id is the shared boundary between two features. `Link to the full online documentation for SharedFeatureFaceFilter `_ Mapping of UI display to python named argument +-------------------------------+--------------------------------------+ | UI Display | Python Named Argument | +===============================+======================================+ | Face Labels | face_labels_array_path | +-------------------------------+--------------------------------------+ | Feature Face Ids | feature_face_ids_array_name | +-------------------------------+--------------------------------------+ | Feature Face Labels | feature_face_labels_array_name | +-------------------------------+--------------------------------------+ | Feature Number of Triangles | feature_num_triangles_array_name | +-------------------------------+--------------------------------------+ | Face Feature Attribute Matrix | grain_boundary_attribute_matrix_name | +-------------------------------+--------------------------------------+ | Triangle Geometry | input_triangle_geometry_path | +-------------------------------+--------------------------------------+ | Randomize Face IDs | randomize_features | +-------------------------------+--------------------------------------+ .. py:method:: Execute(data_structure, face_labels_array_path, feature_face_ids_array_name, feature_face_labels_array_name, feature_num_triangles_array_name, grain_boundary_attribute_matrix_name, input_triangle_geometry_path, randomize_features) :param DataStructure data_structure: The DataStructure object that holds the data to be processed. :param nx.ArraySelectionParameter face_labels_array_path: The DataPath to the FaceLabels values. :param nx.DataObjectNameParameter feature_face_ids_array_name: The name of the calculated Feature Face Ids DataArray :param nx.DataObjectNameParameter feature_face_labels_array_name: The name of the array that holds the calculated Feature Face Labels :param nx.DataObjectNameParameter feature_num_triangles_array_name: The name of the array that holds the calculated number of triangles for each feature face :param nx.DataObjectNameParameter grain_boundary_attribute_matrix_name: The name of the AttributeMatrix that holds the **Feature Face** data :param nx.GeometrySelectionParameter input_triangle_geometry_path: The complete path to the Geometry for which to calculate the normals :param nx.BoolParameter randomize_features: Specifies if feature IDs should be randomized. Can be helpful when visualizing the faces. :return: Returns a :ref:`nx.IFilter.ExecuteResult ` object that holds any warnings and/or errors that were encountered during execution. :rtype: :ref:`nx.IFilter.ExecuteResult ` Silhouette ---------- .. index:: pair: Filter Human Names; Silhouette .. index:: pair: Filter Class Names; SilhouetteFilter .. _SilhouetteFilter: .. py:class:: 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 | +-------------------------------+------------------------+ .. py:method:: Execute(data_structure, distance_metric_index, feature_ids_array_path, mask_array_path, selected_array_path, silhouette_array_path, use_mask) :param DataStructure data_structure: The DataStructure object that holds the data to be processed. :param nx.ChoicesParameter distance_metric_index: Distance Metric type to be used for calculations :param nx.ArraySelectionParameter feature_ids_array_path: The DataPath to the DataArray that specifies which cluster each point belongs :param nx.ArraySelectionParameter mask_array_path: DataPath to the boolean or uint8 mask array. Values that are true will mark that cell/point as usable. :param nx.ArraySelectionParameter selected_array_path: The DataPath to the input DataArray :param nx.ArrayCreationParameter silhouette_array_path: The DataPath to the calculated output Silhouette array values :param nx.BoolParameter use_mask: Specifies whether or not to use a mask array :return: Returns a :ref:`nx.IFilter.ExecuteResult ` object that holds any warnings and/or errors that were encountered during execution. :rtype: :ref:`nx.IFilter.ExecuteResult ` Slice Triangle Geometry ----------------------- .. index:: pair: Filter Human Names; Slice Triangle Geometry .. index:: pair: Filter Class Names; SliceTriangleGeometryFilter .. _SliceTriangleGeometryFilter: .. py:class:: 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 | +------------------------+------------------------------+ .. py:method:: 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) :param DataStructure data_structure: The DataStructure object that holds the data to be processed. :param nx.DataObjectNameParameter edge_attribute_matrix_name: Attribute Matrix to store information about the created edges :param nx.BoolParameter have_region_ids: Whether to supply an id array that propagates to the created edges :param nx.GeometrySelectionParameter input_triangle_geometry_path: The input triangle geometry to be sliced :param nx.DataGroupCreationParameter output_edge_geometry_path: The name of the created Edge Geometry :param nx.ArraySelectionParameter region_ids_array_path: Optional identifier array, if Have Region Ids is selected :param nx.DataObjectNameParameter slice_attribute_matrix_name: Attribute Matrix to store information about the created edges :param nx.DataObjectNameParameter slice_ids_array_name: Identifies the slice to which each edge belongs :param nx.ChoicesParameter slice_range_index: Type of slice range to use, either Full Range or User Defined Range :param nx.Float32Parameter slice_spacing_value: The spacing between slices :param nx.Float32Parameter z_end_value: The z axis stop value. Only needed for 'User Defined Range' :param nx.Float32Parameter z_start_value: The z axis start value. Only needed for 'User Defined Range' :return: Returns a :ref:`nx.IFilter.ExecuteResult ` object that holds any warnings and/or errors that were encountered during execution. :rtype: :ref:`nx.IFilter.ExecuteResult ` Split Multi component Attribute Array ------------------------------------- .. index:: pair: Filter Human Names; Split Multi component Attribute Array .. index:: pair: Filter Class Names; SplitAttributeArrayFilter .. _SplitAttributeArrayFilter: .. py:class:: 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 | +---------------------------------------+------------------------------+ .. py:method:: Execute(data_structure, components_to_extract, delete_original_array, multicomponent_array_path, postfix, select_components_to_extract) :param DataStructure data_structure: The DataStructure object that holds the data to be processed. :param nx.DynamicTableParameter components_to_extract: The components from the input array to be extracted into separate arrays :param nx.BoolParameter delete_original_array: Whether or not to remove the original multicomponent array after splitting :param nx.ArraySelectionParameter multicomponent_array_path: The multicomponent Attribute Array to split :param nx.StringParameter postfix: Postfix to add to the end of the split Attribute Arrays :param nx.BoolParameter select_components_to_extract: Whether or not to specify only certain components to be extracted :return: Returns a :ref:`nx.IFilter.ExecuteResult ` object that holds any warnings and/or errors that were encountered during execution. :rtype: :ref:`nx.IFilter.ExecuteResult ` Create Surface Mesh (Surface Nets) ---------------------------------- .. index:: pair: Filter Human Names; Create Surface Mesh (Surface Nets) .. index:: pair: Filter Class Names; SurfaceNetsFilter .. _SurfaceNetsFilter: .. py:class:: 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 | +-------------------------------------+------------------------------------+ .. py:method:: 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) :param DataStructure data_structure: The DataStructure object that holds the data to be processed. :param nx.BoolParameter apply_smoothing: Use the built in smoothing operation. :param nx.DataObjectNameParameter face_data_group_name: The complete path to the DataGroup where the Face Data of the Triangle Geometry will be created :param nx.DataObjectNameParameter face_feature_attribute_matrix_name: The complete path to the DataGroup where the Feature Data will be stored. :param nx.DataObjectNameParameter face_labels_array_name: The complete path to the Array specifying which Features are on either side of each Face in the Triangle Geometry :param nx.ArraySelectionParameter feature_ids_path: The complete path to the Array specifying which Feature each Cell belongs to :param nx.GeometrySelectionParameter input_grid_geometry_path: DataPath to input Image Geometry :param nx.Float32Parameter max_distance_from_voxel: The maximum allowable distance that a node can move from the voxel center :param nx.DataObjectNameParameter node_types_array_name: The complete path to the Array specifying the type of node in the Triangle Geometry :param nx.DataGroupCreationParameter output_triangle_geometry_path: The name of the created Triangle Geometry :param nx.Float32Parameter relaxation_factor: The factor used to determine how far a node can move in each smoothing iteration :param nx.Int32Parameter smoothing_iterations: Number of relaxation iterations to perform. More iterations causes more smoothing. :param nx.DataObjectNameParameter vertex_data_group_name: The complete path to the DataGroup where the Vertex Data of the Triangle Geometry will be created :return: Returns a :ref:`nx.IFilter.ExecuteResult ` object that holds any warnings and/or errors that were encountered during execution. :rtype: :ref:`nx.IFilter.ExecuteResult ` Compute Triangle Centroids -------------------------- .. index:: pair: Filter Human Names; Compute Triangle Centroids .. index:: pair: Filter Class Names; TriangleCentroidFilter .. _TriangleCentroidFilter: .. py:class:: 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 | +------------------------+------------------------------+ .. py:method:: Execute(data_structure, centroids_array_name, input_triangle_geometry_path) :param DataStructure data_structure: The DataStructure object that holds the data to be processed. :param nx.DataObjectNameParameter centroids_array_name: The complete path to the array storing the calculated centroids :param nx.GeometrySelectionParameter input_triangle_geometry_path: The complete path to the Geometry for which to calculate the normals :return: Returns a :ref:`nx.IFilter.ExecuteResult ` object that holds any warnings and/or errors that were encountered during execution. :rtype: :ref:`nx.IFilter.ExecuteResult ` Calculate Triangle Minimum Dihedral Angle ----------------------------------------- .. index:: pair: Filter Human Names; Calculate Triangle Minimum Dihedral Angle .. index:: pair: Filter Class Names; TriangleDihedralAngleFilter .. _TriangleDihedralAngleFilter: .. py:class:: 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 | +-------------------------+--------------------------------------------------+ .. py:method:: Execute(data_structure, input_triangle_geometry_path, surface_mesh_triangle_dihedral_angles_array_name) :param DataStructure data_structure: The DataStructure object that holds the data to be processed. :param nx.GeometrySelectionParameter input_triangle_geometry_path: The complete path to the Geometry for which to calculate the dihedral angles :param nx.DataObjectNameParameter surface_mesh_triangle_dihedral_angles_array_name: The name of the array storing the calculated dihedral angles :return: Returns a :ref:`nx.IFilter.ExecuteResult ` object that holds any warnings and/or errors that were encountered during execution. :rtype: :ref:`nx.IFilter.ExecuteResult ` Compute Triangle Normals ------------------------ .. index:: pair: Filter Human Names; Compute Triangle Normals .. index:: pair: Filter Class Names; TriangleNormalFilter .. _TriangleNormalFilter: .. py:class:: 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 | +----------------------+------------------------------+ .. py:method:: Execute(data_structure, input_triangle_geometry_path, output_normals_array_name) :param DataStructure data_structure: The DataStructure object that holds the data to be processed. :param nx.GeometrySelectionParameter input_triangle_geometry_path: The complete path to the Geometry for which to calculate the normals :param nx.DataObjectNameParameter output_normals_array_name: The complete path to the array storing the calculated normals :return: Returns a :ref:`nx.IFilter.ExecuteResult ` object that holds any warnings and/or errors that were encountered during execution. :rtype: :ref:`nx.IFilter.ExecuteResult ` Sample Triangle Geometry on Uncertain Regular Grid -------------------------------------------------- .. index:: pair: Filter Human Names; Sample Triangle Geometry on Uncertain Regular Grid .. index:: pair: Filter Class Names; UncertainRegularGridSampleSurfaceMeshFilter .. _UncertainRegularGridSampleSurfaceMeshFilter: .. py:class:: 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 | +--------------------------------+-------------------------------------+ .. py:method:: 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) :param DataStructure data_structure: The DataStructure object that holds the data to be processed. :param nx.DataObjectNameParameter cell_attribute_matrix_name: The name for the cell data Attribute Matrix within the Image geometry :param nx.VectorUInt64Parameter dimensions: The dimensions of the created Image geometry :param nx.DataObjectNameParameter feature_ids_array_name: The name for the feature ids array in cell data Attribute Matrix :param nx.DataGroupCreationParameter input_image_geometry_path: The name and path for the image geometry to be created :param nx.GeometrySelectionParameter input_triangle_geometry_path: The geometry to be sampled onto grid :param nx.VectorFloat32Parameter origin: The origin of the created Image geometry :param nx.DataObjectNameParameter seed_array_name: Name of array holding the seed value :param nx.UInt64Parameter seed_value: The seed fed into the random generator :param nx.VectorFloat32Parameter spacing: The spacing of the created Image geometry :param nx.ArraySelectionParameter surface_mesh_face_labels_array_path: Array specifying which Features are on either side of each Face :param nx.VectorFloat32Parameter uncertainty: uncertainty values associated with X, Y and Z positions of Cells :param nx.BoolParameter use_seed: When true the user will be able to put in a seed for random generation :return: Returns a :ref:`nx.IFilter.ExecuteResult ` object that holds any warnings and/or errors that were encountered during execution. :rtype: :ref:`nx.IFilter.ExecuteResult ` Write ASCII Data ---------------- .. index:: pair: Filter Human Names; Write ASCII Data .. index:: pair: Filter Class Names; WriteASCIIDataFilter .. _WriteASCIIDataFilter: .. py:class:: 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 | +----------------------------+------------------------+ .. py:method:: 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) :param DataStructure data_structure: The DataStructure object that holds the data to be processed. :param nx.ChoicesParameter delimiter_index: The delimiter separating the data :param nx.StringParameter file_extension: The file extension for the output file(s) :param nx.ChoicesParameter header_option_index: Default Include is Headers only :param nx.MultiArraySelectionParameter input_data_array_paths: Data Arrays to be written to disk :param nx.Int32Parameter max_val_per_line: Number of tuples to print on each line. Does not apply to string arrays :param nx.FileSystemPathParameter output_dir: The output file path :param nx.FileSystemPathParameter output_path: The output file path :param nx.ChoicesParameter output_style_index: Whether to output a folder of files or a single file with all the data in column form :return: Returns a :ref:`nx.IFilter.ExecuteResult ` object that holds any warnings and/or errors that were encountered during execution. :rtype: :ref:`nx.IFilter.ExecuteResult ` Write Abaqus Hexahedron ----------------------- .. index:: pair: Filter Human Names; Write Abaqus Hexahedron .. index:: pair: Filter Class Names; WriteAbaqusHexahedronFilter .. _WriteAbaqusHexahedronFilter: .. py:class:: 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 | +---------------------------+---------------------------+ .. py:method:: Execute(data_structure, feature_ids_array_path, file_prefix, hourglass_stiffness, input_image_geometry_path, job_name, output_path) :param DataStructure data_structure: The DataStructure object that holds the data to be processed. :param nx.ArraySelectionParameter feature_ids_array_path: Data Array that specifies to which Feature each Element belongs :param nx.StringParameter file_prefix: The prefix to use for each output file. :param nx.Int32Parameter hourglass_stiffness: The value to use for the Hourglass Stiffness :param nx.GeometrySelectionParameter input_image_geometry_path: The input Image Geometry that will be written. :param nx.StringParameter job_name: The name of the job :param nx.FileSystemPathParameter output_path: The output file path :return: Returns a :ref:`nx.IFilter.ExecuteResult ` object that holds any warnings and/or errors that were encountered during execution. :rtype: :ref:`nx.IFilter.ExecuteResult ` Write Avizo Rectilinear Coordinate ---------------------------------- .. index:: pair: Filter Human Names; Write Avizo Rectilinear Coordinate .. index:: pair: Filter Class Names; WriteAvizoRectilinearCoordinateFilter .. _WriteAvizoRectilinearCoordinateFilter: .. py:class:: 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 | +-------------------+---------------------------+ .. py:method:: Execute(data_structure, feature_ids_array_path, input_image_geometry_path, output_file, units, write_binary_file) :param DataStructure data_structure: The DataStructure object that holds the data to be processed. :param nx.ArraySelectionParameter feature_ids_array_path: Data Array that specifies to which Feature each Element belongs :param nx.GeometrySelectionParameter input_image_geometry_path: The path to the input image geometry :param nx.FileSystemPathParameter output_file: Amira Mesh .am file created :param nx.StringParameter units: The units of the data :param nx.BoolParameter write_binary_file: Whether or not to write the output file as binary :return: Returns a :ref:`nx.IFilter.ExecuteResult ` object that holds any warnings and/or errors that were encountered during execution. :rtype: :ref:`nx.IFilter.ExecuteResult ` Write Avizo Uniform Coordinate ------------------------------ .. index:: pair: Filter Human Names; Write Avizo Uniform Coordinate .. index:: pair: Filter Class Names; WriteAvizoUniformCoordinateFilter .. _WriteAvizoUniformCoordinateFilter: .. py:class:: 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 | +-------------------+---------------------------+ .. py:method:: Execute(data_structure, feature_ids_array_path, input_image_geometry_path, output_file, units, write_binary_file) :param DataStructure data_structure: The DataStructure object that holds the data to be processed. :param nx.ArraySelectionParameter feature_ids_array_path: Data Array that specifies to which Feature each Element belongs :param nx.GeometrySelectionParameter input_image_geometry_path: The path to the input image geometry :param nx.FileSystemPathParameter output_file: Amira Mesh .am file created :param nx.StringParameter units: The units of the data :param nx.BoolParameter write_binary_file: Whether or not to write the output file as binary :return: Returns a :ref:`nx.IFilter.ExecuteResult ` object that holds any warnings and/or errors that were encountered during execution. :rtype: :ref:`nx.IFilter.ExecuteResult ` Write Binary Data ----------------- .. index:: pair: Filter Human Names; Write Binary Data .. index:: pair: Filter Class Names; WriteBinaryDataFilter .. _WriteBinaryDataFilter: .. py:class:: 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 | +----------------------------+------------------------+ .. py:method:: Execute(data_structure, endian_index, file_extension, input_data_array_paths, output_path) :param DataStructure data_structure: The DataStructure object that holds the data to be processed. :param nx.ChoicesParameter endian_index: Default is little endian :param nx.StringParameter file_extension: The file extension for the output file :param nx.MultiArraySelectionParameter input_data_array_paths: The arrays to be exported to a binary file :param nx.FileSystemPathParameter output_path: The output file path :return: Returns a :ref:`nx.IFilter.ExecuteResult ` object that holds any warnings and/or errors that were encountered during execution. :rtype: :ref:`nx.IFilter.ExecuteResult ` Write DREAM3D NX File --------------------- .. index:: pair: Filter Human Names; Write DREAM3D NX File .. index:: pair: Filter Class Names; WriteDREAM3DFilter .. _WriteDREAM3DFilter: .. py:class:: 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 | +------------------+-----------------------+ .. py:method:: Execute(data_structure, export_file_path, write_xdmf_file) :param DataStructure data_structure: The DataStructure object that holds the data to be processed. :param nx.FileSystemPathParameter export_file_path: The file path the DataStructure should be written to as an HDF5 file. :param nx.BoolParameter write_xdmf_file: Whether or not to write the data out an XDMF file :return: Returns a :ref:`nx.IFilter.ExecuteResult ` object that holds any warnings and/or errors that were encountered during execution. :rtype: :ref:`nx.IFilter.ExecuteResult ` Write Feature Data as CSV File ------------------------------ .. index:: pair: Filter Human Names; Write Feature Data as CSV File .. index:: pair: Filter Class Names; WriteFeatureDataCSVFilter .. _WriteFeatureDataCSVFilter: .. py:class:: 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 | +-------------------------------+------------------------------------+ .. py:method:: Execute(data_structure, cell_feature_attribute_matrix_path, delimiter_index, feature_data_file, write_neighborlist_data, write_num_features_line) :param DataStructure data_structure: The DataStructure object that holds the data to be processed. :param nx.AttributeMatrixSelectionParameter cell_feature_attribute_matrix_path: Input Feature Attribute Matrix :param nx.ChoicesParameter delimiter_index: Default Delimiter is Comma :param nx.FileSystemPathParameter feature_data_file: Path to the output file to write. :param nx.BoolParameter write_neighborlist_data: Should the neighbor list data be written to the file :param nx.BoolParameter write_num_features_line: Should the number of features be written to the file. :return: Returns a :ref:`nx.IFilter.ExecuteResult ` object that holds any warnings and/or errors that were encountered during execution. :rtype: :ref:`nx.IFilter.ExecuteResult ` Write Los Alamos FFT File ------------------------- .. index:: pair: Filter Human Names; Write Los Alamos FFT File .. index:: pair: Filter Class Names; WriteLosAlamosFFTFilter .. _WriteLosAlamosFFTFilter: .. py:class:: 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 | +----------------------+------------------------------+ .. py:method:: Execute(data_structure, cell_euler_angles_array_path, cell_phases_array_path, feature_ids_array_path, input_image_geometry_path, output_file) :param DataStructure data_structure: The DataStructure object that holds the data to be processed. :param nx.ArraySelectionParameter cell_euler_angles_array_path: Data Array containing the three angles defining the orientation for each of the Cell in Bunge convention (Z-X-Z) :param nx.ArraySelectionParameter cell_phases_array_path: Data Array that specifies to which Ensemble each Cell belongs :param nx.ArraySelectionParameter feature_ids_array_path: Data Array that specifies to which Feature each Element belongs :param nx.GeometrySelectionParameter input_image_geometry_path: The image geometry holding the arrays to write :param nx.FileSystemPathParameter output_file: The path to the output file :return: Returns a :ref:`nx.IFilter.ExecuteResult ` object that holds any warnings and/or errors that were encountered during execution. :rtype: :ref:`nx.IFilter.ExecuteResult ` Write Nodes And Elements File(s) -------------------------------- .. index:: pair: Filter Human Names; Write Nodes And Elements File(s) .. index:: pair: Filter Class Names; WriteNodesAndElementsFilesFilter .. _WriteNodesAndElementsFilesFilter: .. py:class:: 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 | +----------------------------------+-----------------------------+ .. py:method:: 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) :param DataStructure data_structure: The DataStructure object that holds the data to be processed. :param nx.FileSystemPathParameter element_file_path: The element/cell information will be written to this file path. :param nx.BoolParameter include_element_file_header: Whether or not to include the element/cell file header in the element/cell output file. :param nx.BoolParameter include_node_file_header: Whether or not to include the node file header in the node output file. :param nx.FileSystemPathParameter node_file_path: The node information will be written to this file path. :param nx.BoolParameter number_elements: Whether or not to number each element/cell in the element information output file. :param nx.BoolParameter number_nodes: Whether or not to number each node in the node information output file. :param nx.GeometrySelectionParameter selected_geometry_path: The Geometry that will be written to the output file(s). :param nx.BoolParameter write_element_file: Whether or not to write the element/cell information out to a file. :param nx.BoolParameter write_node_file: Whether or not to write the node information out to a file. :return: Returns a :ref:`nx.IFilter.ExecuteResult ` object that holds any warnings and/or errors that were encountered during execution. :rtype: :ref:`nx.IFilter.ExecuteResult ` Write SPParks Sites File ------------------------ .. index:: pair: Filter Human Names; Write SPParks Sites File .. index:: pair: Filter Class Names; WriteSPParksSitesFilter .. _WriteSPParksSitesFilter: .. py:class:: 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 | +----------------------+---------------------------+ .. py:method:: Execute(data_structure, feature_ids_array_path, input_image_geometry_path, output_file) :param DataStructure data_structure: The DataStructure object that holds the data to be processed. :param nx.ArraySelectionParameter feature_ids_array_path: Data Array that specifies to which Feature each Element belongs :param nx.GeometrySelectionParameter input_image_geometry_path: The image geometry holding the arrays to write :param nx.FileSystemPathParameter output_file: The path to the output file :return: Returns a :ref:`nx.IFilter.ExecuteResult ` object that holds any warnings and/or errors that were encountered during execution. :rtype: :ref:`nx.IFilter.ExecuteResult ` Write STL Files from Triangle Geometry -------------------------------------- .. index:: pair: Filter Human Names; Write STL Files from Triangle Geometry .. index:: pair: Filter Class Names; WriteStlFileFilter .. _WriteStlFileFilter: .. py:class:: 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 | +----------------------------+------------------------------+ .. py:method:: 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) :param DataStructure data_structure: The DataStructure object that holds the data to be processed. :param nx.ArraySelectionParameter feature_ids_path: The triangle feature ids array to order/index files by :param nx.ArraySelectionParameter feature_phases_path: The feature phases array to further order/index files by :param nx.ChoicesParameter grouping_type_index: How to partition the stl files :param nx.GeometrySelectionParameter input_triangle_geometry_path: The geometry to print :param nx.FileSystemPathParameter output_stl_directory: Directory to dump the STL file(s) to :param nx.FileSystemPathParameter output_stl_file: STL File to dump the Triangle Geometry to :param nx.StringParameter output_stl_prefix: The prefix name of created files (other values will be appended later - including the .stl extension) :param nx.ArraySelectionParameter part_number_path: The Part Numbers to order/index files by :return: Returns a :ref:`nx.IFilter.ExecuteResult ` object that holds any warnings and/or errors that were encountered during execution. :rtype: :ref:`nx.IFilter.ExecuteResult ` Write Vtk Rectilinear Grid -------------------------- .. index:: pair: Filter Human Names; Write Vtk Rectilinear Grid .. index:: pair: Filter Class Names; WriteVtkRectilinearGridFilter .. _WriteVtkRectilinearGridFilter: .. py:class:: 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 | +---------------------------+---------------------------+ .. py:method:: Execute(data_structure, input_data_array_paths, input_image_geometry_path, output_file, write_binary_file) :param DataStructure data_structure: The DataStructure object that holds the data to be processed. :param nx.MultiArraySelectionParameter input_data_array_paths: The paths to the cell data arrays to write out with the geometry :param nx.GeometrySelectionParameter input_image_geometry_path: The path to the image geometry in which to write out to the vtk file :param nx.FileSystemPathParameter output_file: The output vtk file in which the geometry data is written :param nx.BoolParameter write_binary_file: Whether or not to write the vtk file in binary :return: Returns a :ref:`nx.IFilter.ExecuteResult ` object that holds any warnings and/or errors that were encountered during execution. :rtype: :ref:`nx.IFilter.ExecuteResult ` Write Vtk Structured Points --------------------------- .. index:: pair: Filter Human Names; Write Vtk Structured Points .. index:: pair: Filter Class Names; WriteVtkStructuredPointsFilter .. _WriteVtkStructuredPointsFilter: .. py:class:: 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 | +---------------------------+---------------------------+ .. py:method:: Execute(data_structure, input_data_array_paths, input_image_geometry_path, output_file, write_binary_file) :param DataStructure data_structure: The DataStructure object that holds the data to be processed. :param nx.MultiArraySelectionParameter input_data_array_paths: The paths to the cell data arrays to write out with the geometry :param nx.GeometrySelectionParameter input_image_geometry_path: The path to the image geometry in which to write out to the vtk file :param nx.FileSystemPathParameter output_file: The output vtk file in which the geometry data is written :param nx.BoolParameter write_binary_file: Whether or not to write the vtk file in binary :return: Returns a :ref:`nx.IFilter.ExecuteResult ` object that holds any warnings and/or errors that were encountered during execution. :rtype: :ref:`nx.IFilter.ExecuteResult `