OrientationAnalysis Filter API ================================ This is the documentation for all filters included in the OrientationAnalysis module. These filters can be used by importing the appropriate module. Each filter is contained in the module: .. code:: python import orientationanalysis # Instantiate and execute a filter from the module result = orientationanalysis.SomeFilterName.execute(...) .. py:module:: OrientationAnalysis Align Sections (Misorientation) ------------------------------- .. index:: pair: Filter Human Names; Align Sections (Misorientation) .. index:: pair: Filter Class Names; AlignSectionsMisorientationFilter .. _AlignSectionsMisorientationFilter: .. py:class:: AlignSectionsMisorientationFilter This **Filter** attempts to align consecutive 'sections' perpendicular to the Z-direction of the sample by determining the position that results in the minimum amount of misorientation between **Cells** directly above-below each other. The algorithm of this **Filter** is as follows: `Link to the full online documentation for AlignSectionsMisorientationFilter `_ Mapping of UI display to python named argument +---------------------------------------------+---------------------------------+ | UI Display | Python Named Argument | +=============================================+=================================+ | Alignment Attribute Matrix Name | alignment_attribute_matrix_name | +---------------------------------------------+---------------------------------+ | Cell Phases | cell_phases_array_path | +---------------------------------------------+---------------------------------+ | Crystal Structures | crystal_structures_array_path | +---------------------------------------------+---------------------------------+ | Alignment Cumulative Shifts Data Array Name | cumulative_shifts_array_name | +---------------------------------------------+---------------------------------+ | Selected Image Geometry | input_image_geometry_path | +---------------------------------------------+---------------------------------+ | Cell Mask Array | mask_array_path | +---------------------------------------------+---------------------------------+ | Misorientation Tolerance (Degrees) | misorientation_tolerance | +---------------------------------------------+---------------------------------+ | Cell Quaternions | quats_array_path | +---------------------------------------------+---------------------------------+ | 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 Mask Array | use_mask | +---------------------------------------------+---------------------------------+ .. py:method:: Execute(data_structure, alignment_attribute_matrix_name, cell_phases_array_path, crystal_structures_array_path, cumulative_shifts_array_name, input_image_geometry_path, mask_array_path, misorientation_tolerance, quats_array_path, relative_shifts_array_name, slices_array_name, store_alignment_shifts, use_mask) :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.ArraySelectionParameter cell_phases_array_path: Specifies to which Ensemble each cell belongs :param nx.ArraySelectionParameter crystal_structures_array_path: Enumeration representing the crystal structure for each Ensemble :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: Path to the DataArray Mask :param nx.Float32Parameter misorientation_tolerance: Tolerance used to decide if Cells above/below one another should be considered to be the same. The value selected should be similar to the tolerance one would use to define Features (i.e., 2-10 degrees) :param nx.ArraySelectionParameter quats_array_path: Specifies the orientation of the Cell in quaternion representation :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_mask: Whether to remove some Cells from consideration in the alignment process :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 (Mutual Information) ----------------------------------- .. index:: pair: Filter Human Names; Align Sections (Mutual Information) .. index:: pair: Filter Class Names; AlignSectionsMutualInformationFilter .. _AlignSectionsMutualInformationFilter: .. py:class:: AlignSectionsMutualInformationFilter This **Filter** segments each 2D slice, creating *Feature Ids* that are used when determining the *mutual information* between neighboring slices. The slices are shifted relative to one another until the position of maximum *mutual information* is determined for each section. The *Feature Ids* are temporary, they apply to this **Filter** only and are not related to the *Feature Ids* generated in other **Filters**. The algorithm of this **Filter** is listed below: `Link to the full online documentation for AlignSectionsMutualInformationFilter `_ Mapping of UI display to python named argument +---------------------------------------------+---------------------------------+ | UI Display | Python Named Argument | +=============================================+=================================+ | Alignment Attribute Matrix Name | alignment_attribute_matrix_name | +---------------------------------------------+---------------------------------+ | Cell Phases | cell_phases_array_path | +---------------------------------------------+---------------------------------+ | Crystal Structures | crystal_structures_array_path | +---------------------------------------------+---------------------------------+ | Alignment Cumulative Shifts Data Array Name | cumulative_shifts_array_name | +---------------------------------------------+---------------------------------+ | Selected Image Geometry | input_image_geometry_path | +---------------------------------------------+---------------------------------+ | Cell Mask Array | mask_array_path | +---------------------------------------------+---------------------------------+ | Misorientation Tolerance (Degrees) | misorientation_tolerance | +---------------------------------------------+---------------------------------+ | Cell Quaternions | quats_array_path | +---------------------------------------------+---------------------------------+ | 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 Mask Array | use_mask | +---------------------------------------------+---------------------------------+ .. py:method:: Execute(data_structure, alignment_attribute_matrix_name, cell_phases_array_path, crystal_structures_array_path, cumulative_shifts_array_name, input_image_geometry_path, mask_array_path, misorientation_tolerance, quats_array_path, relative_shifts_array_name, slices_array_name, store_alignment_shifts, use_mask) :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.ArraySelectionParameter cell_phases_array_path: Specifies to which Ensemble each Cell belongs. :param nx.ArraySelectionParameter crystal_structures_array_path: Enumeration representing the crystal structure for each Ensemble. :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. Only required if Use Mask Array is checked. :param nx.Float32Parameter misorientation_tolerance: Tolerance used to decide if Cells above/below one another should be considered to be the same. The value selected should be similar to the tolerance one would use to define Features (i.e., 2-10 degrees). :param nx.ArraySelectionParameter quats_array_path: Specifies the orientation of the Cell in quaternion representation. :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_mask: Whether to remove some Cells from consideration in the alignment process. :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 ` Neighbor Orientation Comparison (Bad Data) ------------------------------------------ .. index:: pair: Filter Human Names; Neighbor Orientation Comparison (Bad Data) .. index:: pair: Filter Class Names; BadDataNeighborOrientationCheckFilter .. _BadDataNeighborOrientationCheckFilter: .. py:class:: BadDataNeighborOrientationCheckFilter This filter will calculate the misorientation between a cell and its 6 face neighbor cells if the *Mask* value is true of the target cell. If the misorientation falls below the user defined threshold for the user defined minimum number of neighbors, then the target cell will have its *Mask* value changed from false to true. `Link to the full online documentation for BadDataNeighborOrientationCheckFilter `_ Mapping of UI display to python named argument +------------------------------------+-------------------------------+ | UI Display | Python Named Argument | +====================================+===============================+ | Cell Phases | cell_phases_array_path | +------------------------------------+-------------------------------+ | Crystal Structures | crystal_structures_array_path | +------------------------------------+-------------------------------+ | Image Geometry | input_image_geometry_path | +------------------------------------+-------------------------------+ | Cell Mask Array | mask_array_path | +------------------------------------+-------------------------------+ | Misorientation Tolerance (Degrees) | misorientation_tolerance | +------------------------------------+-------------------------------+ | Required Number of Neighbors | number_of_neighbors | +------------------------------------+-------------------------------+ | Cell Quaternions | quats_array_path | +------------------------------------+-------------------------------+ .. py:method:: Execute(data_structure, cell_phases_array_path, crystal_structures_array_path, input_image_geometry_path, mask_array_path, misorientation_tolerance, number_of_neighbors, quats_array_path) :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 crystal_structures_array_path: Enumeration representing the crystal structure for each phase :param nx.GeometrySelectionParameter input_image_geometry_path: The target geometry :param nx.ArraySelectionParameter mask_array_path: Used to define Cells as good or bad :param nx.Float32Parameter misorientation_tolerance: Angular tolerance used to compare with neighboring Cells :param nx.Int32Parameter number_of_neighbors: Minimum number of neighbor Cells that must have orientations within above tolerance to allow Cell to be changed :param nx.ArraySelectionParameter quats_array_path: Specifies the orientation of the Cell in quaternion representation :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 (C-Axis Misalignment) -------------------------------------- .. index:: pair: Filter Human Names; Segment Features (C-Axis Misalignment) .. index:: pair: Filter Class Names; CAxisSegmentFeaturesFilter .. _CAxisSegmentFeaturesFilter: .. py:class:: CAxisSegmentFeaturesFilter This **Filter** segments the **Features** by grouping neighboring **Cells** that satisfy the *C-axis misalignment tolerance*, i.e., have misalignment angle less than the value set by the user. The *C-axis misalignment* refers to the angle between the <001> directions (C-axis in the hexagonal system) that is present between neighboring **Cells**. The process by which the **Features** are identified is given below and is a standard *burn algorithm*. `Link to the full online documentation for CAxisSegmentFeaturesFilter `_ 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 | +-------------------------------------------+------------------------------------+ | Cell Phases | cell_phases_array_path | +-------------------------------------------+------------------------------------+ | Crystal Structures | crystal_structures_array_path | +-------------------------------------------+------------------------------------+ | Cell Feature Ids | feature_ids_array_name | +-------------------------------------------+------------------------------------+ | Input Grid Geometry | input_image_geometry_path | +-------------------------------------------+------------------------------------+ | Cell Mask Array | mask_array_path | +-------------------------------------------+------------------------------------+ | C-Axis Misorientation Tolerance (Degrees) | misorientation_tolerance | +-------------------------------------------+------------------------------------+ | Cell Quaternions | quats_array_path | +-------------------------------------------+------------------------------------+ | Randomize Feature Ids | randomize_feature_ids | +-------------------------------------------+------------------------------------+ | Use Mask Array | use_mask | +-------------------------------------------+------------------------------------+ .. py:method:: Execute(data_structure, active_array_name, cell_feature_attribute_matrix_name, cell_phases_array_path, crystal_structures_array_path, feature_ids_array_name, input_image_geometry_path, mask_array_path, misorientation_tolerance, quats_array_path, randomize_feature_ids, use_mask) :param DataStructure data_structure: The DataStructure object that holds the data to be processed. :param nx.DataObjectNameParameter active_array_name: The name of the array which 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.ArraySelectionParameter cell_phases_array_path: Specifies to which Ensemble each Cell belongs :param nx.ArraySelectionParameter crystal_structures_array_path: Enumeration representing the crystal structure for each Ensemble :param nx.DataObjectNameParameter feature_ids_array_name: Specifies to which Feature each Cell belongs :param nx.GeometrySelectionParameter input_image_geometry_path: DataPath to input Grid Geometry :param nx.ArraySelectionParameter mask_array_path: Specifies if the Cell is to be counted in the algorithm. Only required if Use Mask Array is checked :param nx.Float32Parameter misorientation_tolerance: Tolerance (in degrees) used to determine if neighboring Cells belong to the same Feature :param nx.ArraySelectionParameter quats_array_path: Specifies the orientation of the Cell in quaternion representation :param nx.BoolParameter randomize_feature_ids: Specifies whether to randomize the feature ids :param nx.BoolParameter use_mask: Specifies whether to use a boolean array to exclude some Cells from the Feature identification process :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 Average C-Axis Orientations ----------------------------------- .. index:: pair: Filter Human Names; Compute Average C-Axis Orientations .. index:: pair: Filter Class Names; ComputeAvgCAxesFilter .. _ComputeAvgCAxesFilter: .. py:class:: ComputeAvgCAxesFilter This **Filter** determines the average C-axis location of each **Feature** by the following algorithm: `Link to the full online documentation for ComputeAvgCAxesFilter `_ Mapping of UI display to python named argument +--------------------------+------------------------------------+ | UI Display | Python Named Argument | +==========================+====================================+ | Average C-Axes | avg_c_axes_array_name | +--------------------------+------------------------------------+ | Feature Attribute Matrix | cell_feature_attribute_matrix_path | +--------------------------+------------------------------------+ | Cell Phases | cell_phases_array_path | +--------------------------+------------------------------------+ | Crystal Structures | crystal_structures_array_path | +--------------------------+------------------------------------+ | Cell Feature Ids | feature_ids_array_path | +--------------------------+------------------------------------+ | Cell Quaternions | quats_array_path | +--------------------------+------------------------------------+ .. py:method:: Execute(data_structure, avg_c_axes_array_name, cell_feature_attribute_matrix_path, cell_phases_array_path, crystal_structures_array_path, feature_ids_array_path, quats_array_path) :param DataStructure data_structure: The DataStructure object that holds the data to be processed. :param nx.DataObjectNameParameter avg_c_axes_array_name: The output average C-Axis values for each feature :param nx.AttributeMatrixSelectionParameter cell_feature_attribute_matrix_path: The path to the cell feature attribute matrix :param nx.ArraySelectionParameter cell_phases_array_path: Specifies to which Ensemble each Cell belongs :param nx.ArraySelectionParameter crystal_structures_array_path: Enumeration representing the crystal structure for each Ensemble :param nx.ArraySelectionParameter feature_ids_array_path: Data Array that specifies to which Feature each Element belongs :param nx.ArraySelectionParameter quats_array_path: Input quaternion 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 Average Orientations ------------------------------------ .. index:: pair: Filter Human Names; Compute Feature Average Orientations .. index:: pair: Filter Class Names; ComputeAvgOrientationsFilter .. _ComputeAvgOrientationsFilter: .. py:class:: ComputeAvgOrientationsFilter This **Filter** determines the average orientation of each **Feature** by the following algorithm: `Link to the full online documentation for ComputeAvgOrientationsFilter `_ Mapping of UI display to python named argument +--------------------------+------------------------------------+ | UI Display | Python Named Argument | +==========================+====================================+ | Average Euler Angles | avg_euler_angles_array_name | +--------------------------+------------------------------------+ | Average Quaternions | avg_quats_array_name | +--------------------------+------------------------------------+ | Feature Attribute Matrix | cell_feature_attribute_matrix_path | +--------------------------+------------------------------------+ | Cell Feature Ids | cell_feature_ids_array_path | +--------------------------+------------------------------------+ | Cell Phases | cell_phases_array_path | +--------------------------+------------------------------------+ | Cell Quaternions | cell_quats_array_path | +--------------------------+------------------------------------+ | Crystal Structures | crystal_structures_array_path | +--------------------------+------------------------------------+ .. py:method:: Execute(data_structure, avg_euler_angles_array_name, avg_quats_array_name, cell_feature_attribute_matrix_path, cell_feature_ids_array_path, cell_phases_array_path, cell_quats_array_path, crystal_structures_array_path) :param DataStructure data_structure: The DataStructure object that holds the data to be processed. :param nx.DataObjectNameParameter avg_euler_angles_array_name: The name of the array specifying the orientation of each Feature in Bunge convention (Z-X-Z) :param nx.DataObjectNameParameter avg_quats_array_name: The name of the array specifying the average orientation of the Feature in quaternion representation :param nx.AttributeMatrixSelectionParameter cell_feature_attribute_matrix_path: The path to the cell feature attribute matrix :param nx.ArraySelectionParameter cell_feature_ids_array_path: Specifies to which Feature each Cell belongs. :param nx.ArraySelectionParameter cell_phases_array_path: Specifies to which Ensemble each Cell belongs :param nx.ArraySelectionParameter cell_quats_array_path: Specifies the orientation of the Cell in quaternion representation :param nx.ArraySelectionParameter crystal_structures_array_path: Enumeration representing the crystal structure for 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 Feature Boundary Strength Metrics ----------------------------------------- .. index:: pair: Filter Human Names; Compute Feature Boundary Strength Metrics .. index:: pair: Filter Class Names; ComputeBoundaryStrengthsFilter .. _ComputeBoundaryStrengthsFilter: .. py:class:: ComputeBoundaryStrengthsFilter **THIS FILTER ONLY WORKS ON Cubic m-3m LAUE CLASSES** `Link to the full online documentation for ComputeBoundaryStrengthsFilter `_ Mapping of UI display to python named argument +-------------------------+-------------------------------------+ | UI Display | Python Named Argument | +=========================+=====================================+ | Average Quaternions | avg_quats_array_path | +-------------------------+-------------------------------------+ | Crystal Structures | crystal_structures_array_path | +-------------------------+-------------------------------------+ | Phases | feature_phases_array_path | +-------------------------+-------------------------------------+ | Loading Direction (XYZ) | loading | +-------------------------+-------------------------------------+ | F1s | surface_mesh_f1s_array_name | +-------------------------+-------------------------------------+ | F1spts | surface_mesh_f1spts_array_name | +-------------------------+-------------------------------------+ | F7s | surface_mesh_f7s_array_name | +-------------------------+-------------------------------------+ | Face Labels | surface_mesh_face_labels_array_path | +-------------------------+-------------------------------------+ | mPrimes | surface_meshm_primes_array_name | +-------------------------+-------------------------------------+ .. py:method:: Execute(data_structure, avg_quats_array_path, crystal_structures_array_path, feature_phases_array_path, loading, surface_mesh_f1s_array_name, surface_mesh_f1spts_array_name, surface_mesh_f7s_array_name, surface_mesh_face_labels_array_path, surface_meshm_primes_array_name) :param DataStructure data_structure: The DataStructure object that holds the data to be processed. :param nx.ArraySelectionParameter avg_quats_array_path: Data Array that specifies the average orientation of each Feature in quaternion representation :param nx.ArraySelectionParameter crystal_structures_array_path: Enumeration representing the crystal structure for each phase :param nx.ArraySelectionParameter feature_phases_array_path: Data Array that specifies to which Ensemble each Feature belongs :param nx.VectorFloat64Parameter loading: The loading axis for the sample :param nx.DataObjectNameParameter surface_mesh_f1s_array_name: DataArray Name to store the calculated F1s Values :param nx.DataObjectNameParameter surface_mesh_f1spts_array_name: DataArray Name to store the calculated F1spts Values :param nx.DataObjectNameParameter surface_mesh_f7s_array_name: DataArray Name to store the calculated F7s Values :param nx.ArraySelectionParameter surface_mesh_face_labels_array_path: Data Array that specifies which Features are on either side of each Face :param nx.DataObjectNameParameter surface_meshm_primes_array_name: DataArray Name to store the calculated mPrimes 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 ` Compute C-Axis Locations ------------------------ .. index:: pair: Filter Human Names; Compute C-Axis Locations .. index:: pair: Filter Class Names; ComputeCAxisLocationsFilter .. _ComputeCAxisLocationsFilter: .. py:class:: ComputeCAxisLocationsFilter This **Filter** determines the direction of the C-axis for each **Element** by applying the quaternion of the **Element** to the <001> direction, which is the C-axis for *Hexagonal* materials. This will tell where the C-axis of the **Element** sits in the *sample reference frame*. `Link to the full online documentation for ComputeCAxisLocationsFilter `_ Mapping of UI display to python named argument +--------------------+-------------------------------+ | UI Display | Python Named Argument | +====================+===============================+ | C-Axis Locations | c_axis_locations_array_name | +--------------------+-------------------------------+ | Cell Phases | cell_phases_array_path | +--------------------+-------------------------------+ | Crystal Structures | crystal_structures_array_path | +--------------------+-------------------------------+ | Cell Quaternions | quats_array_path | +--------------------+-------------------------------+ .. py:method:: Execute(data_structure, c_axis_locations_array_name, cell_phases_array_path, crystal_structures_array_path, quats_array_path) :param DataStructure data_structure: The DataStructure object that holds the data to be processed. :param nx.DataObjectNameParameter c_axis_locations_array_name: DataPath to calculated C-Axis locations :param nx.ArraySelectionParameter cell_phases_array_path: Specifies to which Ensemble each Cell belongs :param nx.ArraySelectionParameter crystal_structures_array_path: Enumeration representing the crystal structure for each Ensemble :param nx.ArraySelectionParameter quats_array_path: DataPath to input quaternion 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 ` Compute Fundamental Zone Orientations ------------------------------------- .. index:: pair: Filter Human Names; Compute Fundamental Zone Orientations .. index:: pair: Filter Class Names; ComputeFZQuaternionsFilter .. _ComputeFZQuaternionsFilter: .. py:class:: ComputeFZQuaternionsFilter This **Filter** reduces input orientations (Quaternions) into the fundamental zone for the given Laue group. `Link to the full online documentation for ComputeFZQuaternionsFilter `_ Mapping of UI display to python named argument +----------------------------------------------------------+-------------------------------+ | UI Display | Python Named Argument | +==========================================================+===============================+ | Input Phases | cell_phases_array_path | +----------------------------------------------------------+-------------------------------+ | Crystal Structures | crystal_structures_array_path | +----------------------------------------------------------+-------------------------------+ | Input Quaternions | input_quats_array_path | +----------------------------------------------------------+-------------------------------+ | Input Mask [Optional] | mask_array_path | +----------------------------------------------------------+-------------------------------+ | Created FZ Quaternions | output_fz_quats_array_name | +----------------------------------------------------------+-------------------------------+ | Apply to Good Elements Only (Bad Elements Will Be Black) | use_mask | +----------------------------------------------------------+-------------------------------+ .. py:method:: Execute(data_structure, cell_phases_array_path, crystal_structures_array_path, input_quats_array_path, mask_array_path, output_fz_quats_array_name, use_mask) :param DataStructure data_structure: The DataStructure object that holds the data to be processed. :param nx.ArraySelectionParameter cell_phases_array_path: The phases of the data. The data should be the indices into the Crystal Structures Data Array. :param nx.ArraySelectionParameter crystal_structures_array_path: Enumeration representing the crystal structure for each Ensemble :param nx.ArraySelectionParameter input_quats_array_path: The input quaternions to convert. :param nx.ArraySelectionParameter mask_array_path: Optional Mask array where valid data is TRUE or 1. :param nx.DataObjectNameParameter output_fz_quats_array_name: The name of the array containing the Quaternion that represents an orientation within the fundamental zone for each Element :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 ` Compute IPF Colors (Face) ------------------------- .. index:: pair: Filter Human Names; Compute IPF Colors (Face) .. index:: pair: Filter Class Names; ComputeFaceIPFColoringFilter .. _ComputeFaceIPFColoringFilter: .. py:class:: ComputeFaceIPFColoringFilter This **Filter** generates a pair of colors for each **Triangle** in a **Triangle Geometry** based on the inverse pole figure (IPF) color scheme for the present crystal structure. Each **Triangle** has 2 colors since any **Face** sits at a boundary between 2 **Features** for a well-connected set of **Features** that represent _grains_. The reference direction used for the IPF color generation is the _normal_ of the **Triangle**. `Link to the full online documentation for ComputeFaceIPFColoringFilter `_ Mapping of UI display to python named argument +----------------------+-----------------------------------------+ | UI Display | Python Named Argument | +======================+=========================================+ | Crystal Structures | crystal_structures_array_path | +----------------------+-----------------------------------------+ | Average Euler Angles | feature_euler_angles_array_path | +----------------------+-----------------------------------------+ | Phases | feature_phases_array_path | +----------------------+-----------------------------------------+ | IPF Colors | surface_mesh_face_ipf_colors_array_name | +----------------------+-----------------------------------------+ | Face Labels | surface_mesh_face_labels_array_path | +----------------------+-----------------------------------------+ | Face Normals | surface_mesh_face_normals_array_path | +----------------------+-----------------------------------------+ .. py:method:: Execute(data_structure, crystal_structures_array_path, feature_euler_angles_array_path, feature_phases_array_path, surface_mesh_face_ipf_colors_array_name, surface_mesh_face_labels_array_path, surface_mesh_face_normals_array_path) :param DataStructure data_structure: The DataStructure object that holds the data to be processed. :param nx.ArraySelectionParameter crystal_structures_array_path: Enumeration representing the crystal structure for each Ensemble :param nx.ArraySelectionParameter feature_euler_angles_array_path: Three angles defining the orientation of the Feature in Bunge convention (Z-X-Z) :param nx.ArraySelectionParameter feature_phases_array_path: Specifies to which phase each Feature belongs :param nx.DataObjectNameParameter surface_mesh_face_ipf_colors_array_name: A set of two RGB color schemes encoded as unsigned chars for each Face :param nx.ArraySelectionParameter surface_mesh_face_labels_array_path: Specifies which Features are on either side of each Face :param nx.ArraySelectionParameter surface_mesh_face_normals_array_path: Specifies the normal 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 ` Compute Feature Face Misorientation (Face) ------------------------------------------ .. index:: pair: Filter Human Names; Compute Feature Face Misorientation (Face) .. index:: pair: Filter Class Names; ComputeFeatureFaceMisorientationFilter .. _ComputeFeatureFaceMisorientationFilter: .. py:class:: ComputeFeatureFaceMisorientationFilter This **Filter** generates a 3 component vector for each **Triangle** in a **Triangle Geometry** that is the axis-angle of the misorientation associated with the **Features** that lie on either side of the **Triangle**. The axis is normalized, so if the magnitude of the vector is viewed, it will be the *misorientation angle* in degrees. `Link to the full online documentation for ComputeFeatureFaceMisorientationFilter `_ Mapping of UI display to python named argument +-----------------------+----------------------------------------------------+ | UI Display | Python Named Argument | +=======================+====================================================+ | Average Quaternions | avg_quats_array_path | +-----------------------+----------------------------------------------------+ | Crystal Structures | crystal_structures_array_path | +-----------------------+----------------------------------------------------+ | Phases | feature_phases_array_path | +-----------------------+----------------------------------------------------+ | Face Labels | surface_mesh_face_labels_array_path | +-----------------------+----------------------------------------------------+ | Misorientation Colors | surface_mesh_face_misorientation_colors_array_name | +-----------------------+----------------------------------------------------+ .. py:method:: Execute(data_structure, avg_quats_array_path, crystal_structures_array_path, feature_phases_array_path, surface_mesh_face_labels_array_path, surface_mesh_face_misorientation_colors_array_name) :param DataStructure data_structure: The DataStructure object that holds the data to be processed. :param nx.ArraySelectionParameter avg_quats_array_path: Specifies the average orientation of each Feature in quaternion representation :param nx.ArraySelectionParameter crystal_structures_array_path: Enumeration representing the crystal structure for each Ensemble :param nx.ArraySelectionParameter feature_phases_array_path: Specifies to which phase each Feature belongs :param nx.ArraySelectionParameter surface_mesh_face_labels_array_path: Specifies which Features are on either side of each Face :param nx.DataObjectNameParameter surface_mesh_face_misorientation_colors_array_name: A set of RGB color schemes encoded as floats for 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 ` Compute Feature Neighbor C-Axis Misalignments --------------------------------------------- .. index:: pair: Filter Human Names; Compute Feature Neighbor C-Axis Misalignments .. index:: pair: Filter Class Names; ComputeFeatureNeighborCAxisMisalignmentsFilter .. _ComputeFeatureNeighborCAxisMisalignmentsFilter: .. py:class:: ComputeFeatureNeighborCAxisMisalignmentsFilter This **Filter** determines, for each **Feature**, the C-axis misalignments with the **Features** that are in contact with it. The C-axis misalignments are stored as a list (for each **Feature**) of angles (in degrees). `Link to the full online documentation for ComputeFeatureNeighborCAxisMisalignmentsFilter `_ Mapping of UI display to python named argument +---------------------------------------+-------------------------------------+ | UI Display | Python Named Argument | +=======================================+=====================================+ | Average C-Axis Misalignments | avg_c_axis_misalignments_array_name | +---------------------------------------+-------------------------------------+ | Average Quaternions | avg_quats_array_path | +---------------------------------------+-------------------------------------+ | C-Axis Misalignment List | c_axis_misalignment_list_array_name | +---------------------------------------+-------------------------------------+ | Crystal Structures | crystal_structures_array_path | +---------------------------------------+-------------------------------------+ | Phases | feature_phases_array_path | +---------------------------------------+-------------------------------------+ | Find Average Misalignment Per Feature | find_avg_misals | +---------------------------------------+-------------------------------------+ | Neighbor List | neighbor_list_array_path | +---------------------------------------+-------------------------------------+ .. py:method:: Execute(data_structure, avg_c_axis_misalignments_array_name, avg_quats_array_path, c_axis_misalignment_list_array_name, crystal_structures_array_path, feature_phases_array_path, find_avg_misals, neighbor_list_array_path) :param DataStructure data_structure: The DataStructure object that holds the data to be processed. :param nx.DataObjectNameParameter avg_c_axis_misalignments_array_name: Number weighted average of neighbor C-axis misalignments. Only created if Find Average Misalignment Per Feature is checked :param nx.ArraySelectionParameter avg_quats_array_path: Defines the average orientation of the Feature in quaternion representation :param nx.DataObjectNameParameter c_axis_misalignment_list_array_name: List of the C-axis misalignment angles (in degrees) with the contiguous neighboring Features for a given Feature :param nx.ArraySelectionParameter crystal_structures_array_path: Enumeration representing the crystal structure for each Ensemble :param nx.ArraySelectionParameter feature_phases_array_path: Specifies to which Ensemble each **Feature** belongs :param nx.BoolParameter find_avg_misals: Whether the average of the C-axis misalignments with the neighboring Features should be stored for each Feature :param nx.NeighborListSelectionParameter neighbor_list_array_path: List of the contiguous neighboring Features for a given 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 Feature Neighbor Misorientations ---------------------------------------- .. index:: pair: Filter Human Names; Compute Feature Neighbor Misorientations .. index:: pair: Filter Class Names; ComputeFeatureNeighborMisorientationsFilter .. _ComputeFeatureNeighborMisorientationsFilter: .. py:class:: ComputeFeatureNeighborMisorientationsFilter This **Filter** determines, for each **Feature**, the misorientations with each of the **Features** that are in contact with it. The misorientations are stored as a list (for each **Feature**) of angles (in degrees). The axis of the misorientation is not stored by this **Filter**. `Link to the full online documentation for ComputeFeatureNeighborMisorientationsFilter `_ Mapping of UI display to python named argument +--------------------------------------------+--------------------------------+ | UI Display | Python Named Argument | +============================================+================================+ | Average Misorientations | avg_misorientations_array_name | +--------------------------------------------+--------------------------------+ | Feature Average Quaternions | avg_quats_array_path | +--------------------------------------------+--------------------------------+ | Compute Average Misorientation Per Feature | compute_avg_misors | +--------------------------------------------+--------------------------------+ | Crystal Structures | crystal_structures_array_path | +--------------------------------------------+--------------------------------+ | Feature Phases | feature_phases_array_path | +--------------------------------------------+--------------------------------+ | Misorientation List | misorientation_list_array_name | +--------------------------------------------+--------------------------------+ | Feature Neighbor List | neighbor_list_array_path | +--------------------------------------------+--------------------------------+ .. py:method:: Execute(data_structure, avg_misorientations_array_name, avg_quats_array_path, compute_avg_misors, crystal_structures_array_path, feature_phases_array_path, misorientation_list_array_name, neighbor_list_array_path) :param DataStructure data_structure: The DataStructure object that holds the data to be processed. :param nx.DataObjectNameParameter avg_misorientations_array_name: The name of the array containing the number weighted average of neighbor misorientations. :param nx.ArraySelectionParameter avg_quats_array_path: Defines the average orientation of the Feature in quaternion representation :param nx.BoolParameter compute_avg_misors: Specifies if the average of the misorienations with the neighboring Features should be stored for each Feature :param nx.ArraySelectionParameter crystal_structures_array_path: Enumeration representing the crystal structure for each Ensemble :param nx.ArraySelectionParameter feature_phases_array_path: Specifies to which Ensemble each Feature belongs :param nx.DataObjectNameParameter misorientation_list_array_name: The name of the data object containing the list of the misorientation angles with the contiguous neighboring Features for a given Feature :param nx.NeighborListSelectionParameter neighbor_list_array_path: List of the contiguous neighboring Features for a given 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 Feature Reference C-Axis Misalignments ---------------------------------------------- .. index:: pair: Filter Human Names; Compute Feature Reference C-Axis Misalignments .. index:: pair: Filter Class Names; ComputeFeatureReferenceCAxisMisorientationsFilter .. _ComputeFeatureReferenceCAxisMisorientationsFilter: .. py:class:: ComputeFeatureReferenceCAxisMisorientationsFilter This **Filter** calculates the misorientation angle between the C-axis of each **Cell** within a **Feature** and the average C-axis for that **Feature** and stores that value for each **Cell**. The average and standard deviation of those values for all **Cells** belonging to the same **Feature** is also stored for each **Feature**. `Link to the full online documentation for ComputeFeatureReferenceCAxisMisorientationsFilter `_ Mapping of UI display to python named argument +------------------------------------------+-----------------------------------------------------+ | UI Display | Python Named Argument | +==========================================+=====================================================+ | Average C-Axes | avg_c_axes_array_path | +------------------------------------------+-----------------------------------------------------+ | Cell Phases | cell_phases_array_path | +------------------------------------------+-----------------------------------------------------+ | Crystal Structures | crystal_structures_array_path | +------------------------------------------+-----------------------------------------------------+ | Average C-Axis Misorientations | feature_avg_c_axis_misorientations_array_name | +------------------------------------------+-----------------------------------------------------+ | Cell Feature Ids | feature_ids_array_path | +------------------------------------------+-----------------------------------------------------+ | Feature Reference C-Axis Misorientations | feature_reference_c_axis_misorientations_array_name | +------------------------------------------+-----------------------------------------------------+ | Feature Stdev C-Axis Misorientations | feature_stdev_c_axis_misorientations_array_name | +------------------------------------------+-----------------------------------------------------+ | Image Geometry | input_image_geometry_path | +------------------------------------------+-----------------------------------------------------+ | Cell Quaternions | quats_array_path | +------------------------------------------+-----------------------------------------------------+ .. py:method:: Execute(data_structure, avg_c_axes_array_path, cell_phases_array_path, crystal_structures_array_path, feature_avg_c_axis_misorientations_array_name, feature_ids_array_path, feature_reference_c_axis_misorientations_array_name, feature_stdev_c_axis_misorientations_array_name, input_image_geometry_path, quats_array_path) :param DataStructure data_structure: The DataStructure object that holds the data to be processed. :param nx.ArraySelectionParameter avg_c_axes_array_path: The direction of the Feature's C-axis in the sample reference frame :param nx.ArraySelectionParameter cell_phases_array_path: Specifies to which Ensemble each Cell belongs :param nx.ArraySelectionParameter crystal_structures_array_path: Enumeration representing the crystal structure for each Ensemble :param nx.DataObjectNameParameter feature_avg_c_axis_misorientations_array_name: Average of the Feature Reference CAxis Misorientation values for all of the Cells that belong to the Feature :param nx.ArraySelectionParameter feature_ids_array_path: Data Array that specifies to which Feature each Element belongs :param nx.DataObjectNameParameter feature_reference_c_axis_misorientations_array_name: Misorientation angle (in degrees) between Cell's C-axis and the C-axis of the Feature that owns that Cell :param nx.DataObjectNameParameter feature_stdev_c_axis_misorientations_array_name: Standard deviation of the Feature Reference CAxis Misorientation values for all of the Cells that belong to the Feature :param nx.GeometrySelectionParameter input_image_geometry_path: The path to the input image geometry :param nx.ArraySelectionParameter quats_array_path: Specifies the orientation of the Cell in quaternion representation :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 Reference Misorientations ----------------------------------------- .. index:: pair: Filter Human Names; Compute Feature Reference Misorientations .. index:: pair: Filter Class Names; ComputeFeatureReferenceMisorientationsFilter .. _ComputeFeatureReferenceMisorientationsFilter: .. py:class:: ComputeFeatureReferenceMisorientationsFilter This **Filter** calculates the misorientation angle between each **Cell** within a **Feature** and a *reference orientation* for that **Feature**. The user can choose the *reference orientation* to be used for the **Features** from a drop-down menu. The options for the *reference orientation* are the average orientation of the **Feature** or the orientation of the **Cell** that is furthest from the *boundary* of the **Feature**. `Link to the full online documentation for ComputeFeatureReferenceMisorientationsFilter `_ Mapping of UI display to python named argument +-----------------------------------+----------------------------------------------+ | UI Display | Python Named Argument | +===================================+==============================================+ | Average Quaternions | avg_quats_array_path | +-----------------------------------+----------------------------------------------+ | Feature Attribute Matrix | cell_feature_attribute_matrix_path | +-----------------------------------+----------------------------------------------+ | Cell Phases | cell_phases_array_path | +-----------------------------------+----------------------------------------------+ | Crystal Structures | crystal_structures_array_path | +-----------------------------------+----------------------------------------------+ | Average Misorientations | feature_avg_misorientations_array_name | +-----------------------------------+----------------------------------------------+ | Cell Feature Ids | feature_ids_path | +-----------------------------------+----------------------------------------------+ | Feature Reference Misorientations | feature_reference_misorientations_array_name | +-----------------------------------+----------------------------------------------+ | Boundary Euclidean Distances | gb_euclidean_distances_array_path | +-----------------------------------+----------------------------------------------+ | Cell Quaternions | quats_array_path | +-----------------------------------+----------------------------------------------+ | Reference Orientation | reference_orientation_index | +-----------------------------------+----------------------------------------------+ .. py:method:: Execute(data_structure, avg_quats_array_path, cell_feature_attribute_matrix_path, cell_phases_array_path, crystal_structures_array_path, feature_avg_misorientations_array_name, feature_ids_path, feature_reference_misorientations_array_name, gb_euclidean_distances_array_path, quats_array_path, reference_orientation_index) :param DataStructure data_structure: The DataStructure object that holds the data to be processed. :param nx.ArraySelectionParameter avg_quats_array_path: Specifies the average orientation of the Feature in quaternion representation (, w). Only required if the reference orientation is selected to be the average of the Feature :param nx.AttributeMatrixSelectionParameter cell_feature_attribute_matrix_path: The path to the cell feature attribute matrix :param nx.ArraySelectionParameter cell_phases_array_path: Specifies to which Ensemble each Cell belongs :param nx.ArraySelectionParameter crystal_structures_array_path: Enumeration representing the crystal structure for each Ensemble :param nx.DataObjectNameParameter feature_avg_misorientations_array_name: The name of the array containing the average of the Feature reference misorientation values for all of the Cells that belong to the Feature :param nx.ArraySelectionParameter feature_ids_path: Specifies to which Feature each cell belongs :param nx.DataObjectNameParameter feature_reference_misorientations_array_name: The name of the array containing the misorientation angle (in degrees) between Cell's orientation and the reference orientation of the Feature that owns that Cell :param nx.ArraySelectionParameter gb_euclidean_distances_array_path: Distance the Cells are from the boundary of the Feature they belong to. Only required if the reference orientation is selected to be the orientation at the Feature centroid :param nx.ArraySelectionParameter quats_array_path: Specifies the orientation of the Cell in quaternion representation :param nx.ChoicesParameter reference_orientation_index: Specifies the reference orientation to use when comparing to each Cell :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 GBCD ------------ .. index:: pair: Filter Human Names; Compute GBCD .. index:: pair: Filter Class Names; ComputeGBCDFilter .. _ComputeGBCDFilter: .. py:class:: ComputeGBCDFilter This **Filter** computes the 5D grain boundary character distribution (GBCD) for a **Triangle Geometry**, which is the relative area of grain boundary for a given misorientation and normal. The GBCD can be visualized by using either the **Write GBCD Pole Figure (GMT)** or the **Write GBCD Pole Figure (VTK)** **Filters**. `Link to the full online documentation for ComputeGBCDFilter `_ Mapping of UI display to python named argument +--------------------------------+--------------------------------------+ | UI Display | Python Named Argument | +================================+======================================+ | Crystal Structures | crystal_structures_array_path | +--------------------------------+--------------------------------------+ | Face Ensemble Attribute Matrix | face_ensemble_attribute_matrix_name | +--------------------------------+--------------------------------------+ | Average Euler Angles | feature_euler_angles_array_path | +--------------------------------+--------------------------------------+ | Phases | feature_phases_array_path | +--------------------------------+--------------------------------------+ | GBCD | gbcd_array_name | +--------------------------------+--------------------------------------+ | GBCD Spacing (Degrees) | gbcd_resolution | +--------------------------------+--------------------------------------+ | Triangle Geometry | input_triangle_geometry_path | +--------------------------------+--------------------------------------+ | Face Areas | surface_mesh_face_areas_array_path | +--------------------------------+--------------------------------------+ | Face Labels | surface_mesh_face_labels_array_path | +--------------------------------+--------------------------------------+ | Face Normals | surface_mesh_face_normals_array_path | +--------------------------------+--------------------------------------+ .. py:method:: Execute(data_structure, crystal_structures_array_path, face_ensemble_attribute_matrix_name, feature_euler_angles_array_path, feature_phases_array_path, gbcd_array_name, gbcd_resolution, input_triangle_geometry_path, surface_mesh_face_areas_array_path, surface_mesh_face_labels_array_path, surface_mesh_face_normals_array_path) :param DataStructure data_structure: The DataStructure object that holds the data to be processed. :param nx.ArraySelectionParameter crystal_structures_array_path: Enumeration representing the crystal structure for each Ensemble :param nx.DataObjectNameParameter face_ensemble_attribute_matrix_name: The name of the created face ensemble attribute matrix :param nx.ArraySelectionParameter feature_euler_angles_array_path: Array specifying three angles defining the orientation of the Feature in Bunge convention (Z-X-Z) :param nx.ArraySelectionParameter feature_phases_array_path: Specifies to which phase each Feature belongs :param nx.DataObjectNameParameter gbcd_array_name: 5 parameter GBCD data. The 6th component is used internally to track the northern vs. southern hemisphere of the Lambert sphere :param nx.Float32Parameter gbcd_resolution: The resolution in degrees for the GBCD calculation :param nx.GeometrySelectionParameter input_triangle_geometry_path: Path to the triangle geometry for which to calculate the GBCD :param nx.ArraySelectionParameter surface_mesh_face_areas_array_path: Array specifying the area of each Face :param nx.ArraySelectionParameter surface_mesh_face_labels_array_path: Array specifying which Features are on either side of each Face :param nx.ArraySelectionParameter surface_mesh_face_normals_array_path: Array specifying the normal 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 ` Compute GBCD (Metric-Based Approach) ------------------------------------ .. index:: pair: Filter Human Names; Compute GBCD (Metric-Based Approach) .. index:: pair: Filter Class Names; ComputeGBCDMetricBasedFilter .. _ComputeGBCDMetricBasedFilter: .. py:class:: ComputeGBCDMetricBasedFilter This **Filter** computes a section through the five-dimensional grain boundary distirbution for a fixed misorientation. An example of such a section is shown in Fig. 1. Differently than **Compute GBCD Filter**, which uses a method based on partition of the boundary space into bins, this **Filter** implements an alternative metric-based approach described by K. Glowinski and A. Morawiec in `Analysis of experimental grain boundary distributions based on boundary-space metrics, Metall. Mater. Trans. A 45, 3189-3194 (2014) `_ `Link to the full online documentation for ComputeGBCDMetricBasedFilter `_ Mapping of UI display to python named argument +-------------------------------------------------------+---------------------------------------------+ | UI Display | Python Named Argument | +=======================================================+=============================================+ | Limiting Distances | chosen_limit_dists_index | +-------------------------------------------------------+---------------------------------------------+ | Crystal Structures | crystal_structures_array_path | +-------------------------------------------------------+---------------------------------------------+ | Output Distribution File | dist_output_file | +-------------------------------------------------------+---------------------------------------------+ | Output Distribution Errors File | err_output_file | +-------------------------------------------------------+---------------------------------------------+ | Exclude Triangles Directly Neighboring Triple Lines | exclude_triple_lines | +-------------------------------------------------------+---------------------------------------------+ | Average Euler Angles | feature_euler_angles_array_path | +-------------------------------------------------------+---------------------------------------------+ | Phases | feature_phases_array_path | +-------------------------------------------------------+---------------------------------------------+ | Triangle Geometry | input_triangle_geometry_path | +-------------------------------------------------------+---------------------------------------------+ | Fixed Misorientation | misorientation_rotation | +-------------------------------------------------------+---------------------------------------------+ | Node Types | node_types_array_path | +-------------------------------------------------------+---------------------------------------------+ | Number of Sampling Points (on a Hemisphere) | num_sampl_pts | +-------------------------------------------------------+---------------------------------------------+ | Phase of Interest | phase_of_interest | +-------------------------------------------------------+---------------------------------------------+ | Save Relative Errors Instead of Their Absolute Values | save_relative_err | +-------------------------------------------------------+---------------------------------------------+ | Face Areas | surface_mesh_face_areas_array_path | +-------------------------------------------------------+---------------------------------------------+ | Face Labels | surface_mesh_face_labels_array_path | +-------------------------------------------------------+---------------------------------------------+ | Face Normals | surface_mesh_face_normals_array_path | +-------------------------------------------------------+---------------------------------------------+ | Feature Face Labels | surface_mesh_feature_face_labels_array_path | +-------------------------------------------------------+---------------------------------------------+ .. py:method:: Execute(data_structure, chosen_limit_dists_index, crystal_structures_array_path, dist_output_file, err_output_file, exclude_triple_lines, feature_euler_angles_array_path, feature_phases_array_path, input_triangle_geometry_path, misorientation_rotation, node_types_array_path, num_sampl_pts, phase_of_interest, save_relative_err, surface_mesh_face_areas_array_path, surface_mesh_face_labels_array_path, surface_mesh_face_normals_array_path, surface_mesh_feature_face_labels_array_path) :param DataStructure data_structure: The DataStructure object that holds the data to be processed. :param nx.ChoicesParameter chosen_limit_dists_index: The max angles from within which boundary segments are selected for the misorientations and plane inclinations :param nx.ArraySelectionParameter crystal_structures_array_path: Enumeration representing the crystal structure for each Ensemble :param nx.FileSystemPathParameter dist_output_file: The output distribution file path (extension .dat, GMT format) :param nx.FileSystemPathParameter err_output_file: The output distribution errors file path (extension .dat, GMT format) :param nx.BoolParameter exclude_triple_lines: If checked, only interiors of Faces are included in GBCD :param nx.ArraySelectionParameter feature_euler_angles_array_path: Three angles defining the orientation of the Feature in Bunge convention (Z-X-Z) :param nx.ArraySelectionParameter feature_phases_array_path: Specifies to which phase each Feature belongs :param nx.GeometrySelectionParameter input_triangle_geometry_path: The complete path to the triangle geometry :param nx.VectorFloat32Parameter misorientation_rotation: Axis-angle representation of the misorientation of interest. Angle value should be in degrees. :param nx.ArraySelectionParameter node_types_array_path: Specifies the type of node in the Geometry :param nx.Int32Parameter num_sampl_pts: The approximate number of sampling directions :param nx.Int32Parameter phase_of_interest: Index of the Ensemble for which to compute GBCD; boundaries having grains of this phase on both its sides will only be taken into account :param nx.BoolParameter save_relative_err: Whether or not to save the distribution errors as relative (if exceeds 100%, then rounded down) or absolute :param nx.ArraySelectionParameter surface_mesh_face_areas_array_path: Specifies the area of each Face :param nx.ArraySelectionParameter surface_mesh_face_labels_array_path: Specifies which Features are on either side of each Face :param nx.ArraySelectionParameter surface_mesh_face_normals_array_path: Specifies the normal of each Face :param nx.ArraySelectionParameter surface_mesh_feature_face_labels_array_path: Specifies which original Features are on either side of each boundary 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 GBCD Pole Figure ------------------------ .. index:: pair: Filter Human Names; Compute GBCD Pole Figure .. index:: pair: Filter Class Names; ComputeGBCDPoleFigureFilter .. _ComputeGBCDPoleFigureFilter: .. py:class:: ComputeGBCDPoleFigureFilter This **Filter** creates a pole figure from the Grain Boundary Character Distribution (GBCD) data. The user must select the relevant phase for which to generate the pole figure by entering the *phase index*. `Link to the full online documentation for ComputeGBCDPoleFigureFilter `_ Mapping of UI display to python named argument +----------------------------+-------------------------------+ | UI Display | Python Named Argument | +============================+===============================+ | Cell Attribute Matrix Name | cell_attribute_matrix_name | +----------------------------+-------------------------------+ | Cell MRD Array Name | cell_intensity_array_name | +----------------------------+-------------------------------+ | Crystal Structures | crystal_structures_array_path | +----------------------------+-------------------------------+ | Input GBCD | gbcd_array_path | +----------------------------+-------------------------------+ | Misorientation Angle-Axis | misorientation_rotation | +----------------------------+-------------------------------+ | Output Image Dimension | output_image_dimension | +----------------------------+-------------------------------+ | Image Geometry | output_image_geometry_path | +----------------------------+-------------------------------+ | Phase of Interest | phase_of_interest | +----------------------------+-------------------------------+ .. py:method:: Execute(data_structure, cell_attribute_matrix_name, cell_intensity_array_name, crystal_structures_array_path, gbcd_array_path, misorientation_rotation, output_image_dimension, output_image_geometry_path, phase_of_interest) :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 cell attribute matrix for the created image geometry :param nx.DataObjectNameParameter cell_intensity_array_name: The name of the created cell intensity data array :param nx.ArraySelectionParameter crystal_structures_array_path: Enumeration representing the crystal structure for each Ensemble :param nx.ArraySelectionParameter gbcd_array_path: 5 parameter GBCD data. The 6th component is used internally to track the northern vs. southern hemisphere of the Lambert sphere :param nx.VectorFloat32Parameter misorientation_rotation: Angle-Axis values for drawing GBCD :param nx.Int32Parameter output_image_dimension: The value to use for the dimensions for the image geometry :param nx.DataGroupCreationParameter output_image_geometry_path: The path to the created image geometry :param nx.Int32Parameter phase_of_interest: Index of the Ensemble for which to plot the pole figure :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 GBPD (Metric-Based Approach) ------------------------------------ .. index:: pair: Filter Human Names; Compute GBPD (Metric-Based Approach) .. index:: pair: Filter Class Names; ComputeGBPDMetricBasedFilter .. _ComputeGBPDMetricBasedFilter: .. py:class:: ComputeGBPDMetricBasedFilter This **Filter** computes the grain boundary plane distribution (GBPD) like that shown in Fig. 1. It should be noted that most GBPDs presented so far in literature were obtained using a method based on partition of the grain boundary space into bins, similar to that implemented in the *Compute GBCD* **Filter**. This **Filter** calculates the GBPD using an alternative approach adapted from the one included in the *Compute GBCD (Metric-based Approach)* **Filter** and described by K. Glowinski and A. Morawiec in `Analysis of experimental grain boundary distributions based on boundary-space metrics, Metall. Mater. Trans. A 45, 3189-3194 (2014) `_. Briefly, the GBPD is probed at evenly distributed sampling directions (similarly to *Compute GBCD (Metric-based Approach)* **Filter**) and areas of mesh segments with their normal vectors deviated by less than a limiting angle ρp from a given direction are summed. If *n*S is the number of crystal symmetry transformations, each boundary plane segment is represented by up to 4 × *n*S equivalent vectors, and all of them are processed. It is enough to sample the distribution at directions corresponding to the standard stereographic triangle (or, in general, to a fundamental region corresponding to a considered crystallographic point group); values at remaining points are obtained based on crystal symmetries. After summing the boundary areas, the distribution is normalized. First, the values at sampling vectors are divided by the total area of all segments. Then, in order to express the distribution in the conventional units, i.e., multiples of random distribution (MRDs), the obtained fractional values are divided by the volume *v* = (*A* nS) / (4π), where *A* is the area of a spherical cap determined by ρp. `Link to the full online documentation for ComputeGBPDMetricBasedFilter `_ Mapping of UI display to python named argument +-------------------------------------------------------+---------------------------------------------+ | UI Display | Python Named Argument | +=======================================================+=============================================+ | Crystal Structures | crystal_structures_array_path | +-------------------------------------------------------+---------------------------------------------+ | Output Distribution File | dist_output_file | +-------------------------------------------------------+---------------------------------------------+ | Output Distribution Errors File | err_output_file | +-------------------------------------------------------+---------------------------------------------+ | Exclude Triangles Directly Neighboring Triple Lines | exclude_triple_lines | +-------------------------------------------------------+---------------------------------------------+ | Average Euler Angles | feature_euler_angles_array_path | +-------------------------------------------------------+---------------------------------------------+ | Phases | feature_phases_array_path | +-------------------------------------------------------+---------------------------------------------+ | Triangle Geometry | input_triangle_geometry_path | +-------------------------------------------------------+---------------------------------------------+ | Limiting Distance [deg.] | limit_dist | +-------------------------------------------------------+---------------------------------------------+ | Node Types | node_types_array_path | +-------------------------------------------------------+---------------------------------------------+ | Number of Sampling Points (on a Hemisphere) | num_sampl_pts | +-------------------------------------------------------+---------------------------------------------+ | Phase of Interest | phase_of_interest | +-------------------------------------------------------+---------------------------------------------+ | Save Relative Errors Instead of Their Absolute Values | save_relative_err | +-------------------------------------------------------+---------------------------------------------+ | Face Areas | surface_mesh_face_areas_array_path | +-------------------------------------------------------+---------------------------------------------+ | Face Labels | surface_mesh_face_labels_array_path | +-------------------------------------------------------+---------------------------------------------+ | Face Normals | surface_mesh_face_normals_array_path | +-------------------------------------------------------+---------------------------------------------+ | Feature Face Labels | surface_mesh_feature_face_labels_array_path | +-------------------------------------------------------+---------------------------------------------+ .. py:method:: Execute(data_structure, crystal_structures_array_path, dist_output_file, err_output_file, exclude_triple_lines, feature_euler_angles_array_path, feature_phases_array_path, input_triangle_geometry_path, limit_dist, node_types_array_path, num_sampl_pts, phase_of_interest, save_relative_err, surface_mesh_face_areas_array_path, surface_mesh_face_labels_array_path, surface_mesh_face_normals_array_path, surface_mesh_feature_face_labels_array_path) :param DataStructure data_structure: The DataStructure object that holds the data to be processed. :param nx.ArraySelectionParameter crystal_structures_array_path: Enumeration representing the crystal structure for each Ensemble :param nx.FileSystemPathParameter dist_output_file: The output distribution file path (extension .dat, GMT format) :param nx.FileSystemPathParameter err_output_file: The output distribution errors file path (extension .dat, GMT format) :param nx.BoolParameter exclude_triple_lines: If checked, only interiors of Faces are included in GBCD :param nx.ArraySelectionParameter feature_euler_angles_array_path: Three angles defining the orientation of the Feature in Bunge convention (Z-X-Z) :param nx.ArraySelectionParameter feature_phases_array_path: Specifies to which phase each Feature belongs :param nx.GeometrySelectionParameter input_triangle_geometry_path: The complete path to the triangle geometry :param nx.Float32Parameter limit_dist: The max angle from within which mesh segments are selected :param nx.ArraySelectionParameter node_types_array_path: Specifies the type of node in the Geometry :param nx.Int32Parameter num_sampl_pts: The approximate number of sampling directions :param nx.Int32Parameter phase_of_interest: Index of the Ensemble for which to compute GBPD; boundaries having grains of this phase on both its sides will only be taken into account :param nx.BoolParameter save_relative_err: Whether or not to save the distribution errors as relative (if exceeds 100%, then rounded down) or absolute :param nx.ArraySelectionParameter surface_mesh_face_areas_array_path: Specifies the area of each Face :param nx.ArraySelectionParameter surface_mesh_face_labels_array_path: Specifies which Features are on either side of each Face :param nx.ArraySelectionParameter surface_mesh_face_normals_array_path: Specifies the normal of each Face :param nx.ArraySelectionParameter surface_mesh_feature_face_labels_array_path: Specifies which original Features are on either side of each boundary 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 IPF Colors ------------------ .. index:: pair: Filter Human Names; Compute IPF Colors .. index:: pair: Filter Class Names; ComputeIPFColorsFilter .. _ComputeIPFColorsFilter: .. py:class:: ComputeIPFColorsFilter This **Filter** will generate *inverse pole figure* (IPF) colors. The user can enter the *Reference Direction*, which defaults to [001]. The **Filter** also has the option to apply a black color to all "bad" **Elements**, as defined by a boolean *mask* array, which can be generated using the Threshold Objects **Filter** or any other filter that generates a "mask" of the data and outputs either a bool or uint8 array. `Link to the full online documentation for ComputeIPFColorsFilter `_ Mapping of UI display to python named argument +---------------------+-------------------------------+ | UI Display | Python Named Argument | +=====================+===============================+ | Euler Angles | cell_euler_angles_array_path | +---------------------+-------------------------------+ | IPF Colors | cell_ipf_colors_array_name | +---------------------+-------------------------------+ | Phases | cell_phases_array_path | +---------------------+-------------------------------+ | Crystal Structures | crystal_structures_array_path | +---------------------+-------------------------------+ | Mask Array | mask_array_path | +---------------------+-------------------------------+ | Reference Direction | reference_dir | +---------------------+-------------------------------+ | Use Mask Array | use_mask | +---------------------+-------------------------------+ .. py:method:: Execute(data_structure, cell_euler_angles_array_path, cell_ipf_colors_array_name, cell_phases_array_path, crystal_structures_array_path, mask_array_path, reference_dir, use_mask) :param DataStructure data_structure: The DataStructure object that holds the data to be processed. :param nx.ArraySelectionParameter cell_euler_angles_array_path: Three angles defining the orientation of the Element in Bunge convention (Z-X-Z) :param nx.DataObjectNameParameter cell_ipf_colors_array_name: The name of the array containing the RGB colors encoded as RGB unsigned chars (x3) for each Element :param nx.ArraySelectionParameter cell_phases_array_path: Specifies to which Ensemble each cell belongs :param nx.ArraySelectionParameter crystal_structures_array_path: Enumeration representing the crystal structure for each Ensemble :param nx.ArraySelectionParameter mask_array_path: Path to the data array used to define Elements as good or bad. :param nx.VectorFloat32Parameter reference_dir: The reference axis with respect to compute the IPF colors :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 ` Compute Kernel Average Misorientations -------------------------------------- .. index:: pair: Filter Human Names; Compute Kernel Average Misorientations .. index:: pair: Filter Class Names; ComputeKernelAvgMisorientationsFilter .. _ComputeKernelAvgMisorientationsFilter: .. py:class:: ComputeKernelAvgMisorientationsFilter This **Filter** determines the Kernel Average Misorientation (KAM) for each **Cell**. The user can select the size of the kernel to be used in the calculation. The kernel size entered by the user is the *radius* of the kernel (i.e., entering values of *1*, *2*, *3* will result in a kernel that is *3*, *5*, and *7* **Cells** in size in the X, Y and Z directions, respectively). The algorithm for determination of KAM is as follows: `Link to the full online documentation for ComputeKernelAvgMisorientationsFilter `_ Mapping of UI display to python named argument +--------------------------------+-------------------------------------------+ | UI Display | Python Named Argument | +================================+===========================================+ | Cell Phases | cell_phases_array_path | +--------------------------------+-------------------------------------------+ | Crystal Structures | crystal_structures_array_path | +--------------------------------+-------------------------------------------+ | Cell Feature Ids | feature_ids_path | +--------------------------------+-------------------------------------------+ | Selected Image Geometry | input_image_geometry_path | +--------------------------------+-------------------------------------------+ | Kernel Average Misorientations | kernel_average_misorientations_array_name | +--------------------------------+-------------------------------------------+ | Kernel Radius | kernel_size | +--------------------------------+-------------------------------------------+ | Cell Quaternions | quats_array_path | +--------------------------------+-------------------------------------------+ .. py:method:: Execute(data_structure, cell_phases_array_path, crystal_structures_array_path, feature_ids_path, input_image_geometry_path, kernel_average_misorientations_array_name, kernel_size, quats_array_path) :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 crystal_structures_array_path: Enumeration representing the crystal structure for each Ensemble :param nx.ArraySelectionParameter feature_ids_path: Specifies to which Feature each cell belongs :param nx.GeometrySelectionParameter input_image_geometry_path: Path to the target geometry :param nx.DataObjectNameParameter kernel_average_misorientations_array_name: The name of the array containing the average misorientation (in Degrees) for all Cells within the kernel and the central Cell :param nx.VectorInt32Parameter kernel_size: Size of the kernel in the X, Y and Z directions (in number of Cells) :param nx.ArraySelectionParameter quats_array_path: Specifies the orientation of the Cell in quaternion representation :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 Misorientation ---------------------- .. index:: pair: Filter Human Names; Compute Misorientation .. index:: pair: Filter Class Names; ComputeMisorientationsFilter .. _ComputeMisorientationsFilter: .. py:class:: ComputeMisorientationsFilter This filter will compute the misorientation as an Axis-Angle representation between a pair ofEuler Angles or an Euler Angle and a Reference Axis-Angle. `Link to the full online documentation for ComputeMisorientationsFilter `_ Mapping of UI display to python named argument +------------------------+--------------------------------+ | UI Display | Python Named Argument | +========================+================================+ | Computation Type | computation_type_index | +------------------------+--------------------------------+ | Crystal Structures | crystal_structures_array_path | +------------------------+--------------------------------+ | Euler Angles 1 | input_orientation_1_array_path | +------------------------+--------------------------------+ | Euler Angles 2 | input_orientation_2_array_path | +------------------------+--------------------------------+ | Phases | input_phases_array_path | +------------------------+--------------------------------+ | Output Misorientations | output_orientation_array_name | +------------------------+--------------------------------+ | Reference Axis-Angle | reference_orientation | +------------------------+--------------------------------+ .. py:method:: Execute(data_structure, computation_type_index, crystal_structures_array_path, input_orientation_1_array_path, input_orientation_2_array_path, input_phases_array_path, output_orientation_array_name, reference_orientation) :param DataStructure data_structure: The DataStructure object that holds the data to be processed. :param nx.ChoicesParameter computation_type_index: The type of computation to perform :param nx.ArraySelectionParameter crystal_structures_array_path: Enumeration representing the crystal structure for each Ensemble :param nx.ArraySelectionParameter input_orientation_1_array_path: Three angles defining the orientation of the Element in Bunge convention (Z-X-Z) :param nx.ArraySelectionParameter input_orientation_2_array_path: Three angles defining the orientation of the Element in Bunge convention (Z-X-Z) :param nx.ArraySelectionParameter input_phases_array_path: Specifies to which Ensemble each cell belongs :param nx.DataObjectNameParameter output_orientation_array_name: The DataPath to the created output array that will hold the computed misorientations as Axis-Angles :param nx.VectorFloat32Parameter reference_orientation: w (w in degrees) :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 Quaternion Conjugate ---------------------------- .. index:: pair: Filter Human Names; Compute Quaternion Conjugate .. index:: pair: Filter Class Names; ComputeQuaternionConjugateFilter .. _ComputeQuaternionConjugateFilter: .. py:class:: ComputeQuaternionConjugateFilter This filter will generate the transpose of a [1x4] *Quaternion* laid out in memory such that < x, y, z >, w. This can behandy when the user wants to convert the orientation transformation to an opposite effect. The algorihtm will calculatethe conjugate of each quaternion in the array of input quaternions `Link to the full online documentation for ComputeQuaternionConjugateFilter `_ Mapping of UI display to python named argument +------------------------------+------------------------+ | UI Display | Python Named Argument | +==============================+========================+ | Delete Original Data | delete_original_data | +------------------------------+------------------------+ | Quaternions | input_quats_data_path | +------------------------------+------------------------+ | Created Quaternion Conjugate | output_data_array_name | +------------------------------+------------------------+ .. py:method:: Execute(data_structure, delete_original_data, input_quats_data_path, output_data_array_name) :param DataStructure data_structure: The DataStructure object that holds the data to be processed. :param nx.BoolParameter delete_original_data: Should the original Data be deleted from the DataStructure :param nx.ArraySelectionParameter input_quats_data_path: Specifies the quaternions to convert :param nx.DataObjectNameParameter output_data_array_name: The name of the generated quaternion conjugate 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 Schmid Factors ---------------------- .. index:: pair: Filter Human Names; Compute Schmid Factors .. index:: pair: Filter Class Names; ComputeSchmidsFilter .. _ComputeSchmidsFilter: .. py:class:: ComputeSchmidsFilter This **Filter** calculates the Schmid factor of each **Feature** given its average orientation and a user defined loading axis. The Schmid Factor is the combination of the component of the axial force *F* that lies parallel to the slip direction and the component that lies perpendicular to the slip plane. The equation for the Schmid Factor is given as: `Link to the full online documentation for ComputeSchmidsFilter `_ Mapping of UI display to python named argument +-----------------------------------------+-------------------------------+ | UI Display | Python Named Argument | +=========================================+===============================+ | Average Quaternions | avg_quats_array_path | +-----------------------------------------+-------------------------------+ | Crystal Structures | crystal_structures_array_path | +-----------------------------------------+-------------------------------+ | Phases | feature_phases_array_path | +-----------------------------------------+-------------------------------+ | Lambdas | lambdas_array_name | +-----------------------------------------+-------------------------------+ | Loading Direction | loading_direction | +-----------------------------------------+-------------------------------+ | Override Default Slip System | override_system | +-----------------------------------------+-------------------------------+ | Phis | phis_array_name | +-----------------------------------------+-------------------------------+ | Poles | poles_array_name | +-----------------------------------------+-------------------------------+ | Schmids | schmids_array_name | +-----------------------------------------+-------------------------------+ | Slip Direction | slip_direction | +-----------------------------------------+-------------------------------+ | Slip Plane | slip_plane | +-----------------------------------------+-------------------------------+ | Slip Systems | slip_systems_array_name | +-----------------------------------------+-------------------------------+ | Store Angle Components of Schmid Factor | store_angle_components | +-----------------------------------------+-------------------------------+ .. py:method:: Execute(data_structure, avg_quats_array_path, crystal_structures_array_path, feature_phases_array_path, lambdas_array_name, loading_direction, override_system, phis_array_name, poles_array_name, schmids_array_name, slip_direction, slip_plane, slip_systems_array_name, store_angle_components) :param DataStructure data_structure: The DataStructure object that holds the data to be processed. :param nx.ArraySelectionParameter avg_quats_array_path: Specifies the average orienation of each Feature in quaternion representation :param nx.ArraySelectionParameter crystal_structures_array_path: Enumeration representing the crystal structure for each Ensemble :param nx.ArraySelectionParameter feature_phases_array_path: Specifies to which Ensemble each cell belongs :param nx.DataObjectNameParameter lambdas_array_name: The name of the array containing the angle between tensile axis and slip direction. :param nx.VectorFloat32Parameter loading_direction: The loading axis for the sample :param nx.BoolParameter override_system: Allows the user to manually input the slip plane and slip direction :param nx.DataObjectNameParameter phis_array_name: The name of the array containing the angle between tensile axis and slip plane normal. :param nx.DataObjectNameParameter poles_array_name: The name of the array specifying the crystallographic pole that points along the user defined loading direction :param nx.DataObjectNameParameter schmids_array_name: The name of the array containing the value of the Schmid factor for the most favorably oriented slip system (i.e., the one with the highest Schmid factor) :param nx.VectorFloat32Parameter slip_direction: Vector defining the slip direction. :param nx.VectorFloat32Parameter slip_plane: Vector defining the slip plane normal. :param nx.DataObjectNameParameter slip_systems_array_name: The name of the array containing the enumeration of the slip system that has the highest Schmid factor :param nx.BoolParameter store_angle_components: Whether to store the angle components 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 Feature Shapes (Image Geometry) --------------------------------------- .. index:: pair: Filter Human Names; Compute Feature Shapes (Image Geometry) .. index:: pair: Filter Class Names; ComputeShapesFilter .. _ComputeShapesFilter: .. py:class:: ComputeShapesFilter This **Filter** calculates the second-order moments of each **Feature** in order to determine the *principal axis lengths, principal axis directions, aspect ratios and moment invariant Omega3s*. The *principal axis lengths* are those of a "best-fit" ellipsoid. The algorithm for determining the moments and these values is as follows: `Link to the full online documentation for ComputeShapesFilter `_ Mapping of UI display to python named argument +-------------------------+------------------------------+ | UI Display | Python Named Argument | +=========================+==============================+ | Aspect Ratios | aspect_ratios_array_name | +-------------------------+------------------------------+ | Axis Euler Angles | axis_euler_angles_array_name | +-------------------------+------------------------------+ | Axis Lengths | axis_lengths_array_name | +-------------------------+------------------------------+ | Feature Centroids | centroids_array_path | +-------------------------+------------------------------+ | Cell Feature Ids | feature_ids_path | +-------------------------+------------------------------+ | Selected Image Geometry | input_image_geometry_path | +-------------------------+------------------------------+ | Omega3s | omega3s_array_name | +-------------------------+------------------------------+ | Volumes | volumes_array_name | +-------------------------+------------------------------+ .. py:method:: Execute(data_structure, aspect_ratios_array_name, axis_euler_angles_array_name, axis_lengths_array_name, centroids_array_path, feature_ids_path, input_image_geometry_path, omega3s_array_name, volumes_array_name) :param DataStructure data_structure: The DataStructure object that holds the data to be processed. :param nx.DataObjectNameParameter aspect_ratios_array_name: Ratio of semi-axis lengths (b/a and c/a) for best-fit ellipsoid to Feature :param nx.DataObjectNameParameter axis_euler_angles_array_name: Euler angles (in radians) necessary to rotate the sample reference frame to the reference frame of the Feature, where the principal axes of the best-fit ellipsoid are (X, Y, Z) :param nx.DataObjectNameParameter axis_lengths_array_name: Semi-axis lengths (a, b, c) for best-fit ellipsoid to Feature :param nx.ArraySelectionParameter centroids_array_path: X, Y, Z coordinates of Feature center of mass :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.DataObjectNameParameter omega3s_array_name: 3rd invariant of the second-order moment matrix for the Feature, does not assume a shape type (i.e., ellipsoid) :param nx.DataObjectNameParameter volumes_array_name: The volume of 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 Feature Shapes (Triangle Geometry) ------------------------------------------ .. index:: pair: Filter Human Names; Compute Feature Shapes (Triangle Geometry) .. index:: pair: Filter Class Names; ComputeShapesTriangleGeomFilter .. _ComputeShapesTriangleGeomFilter: .. py:class:: ComputeShapesTriangleGeomFilter This **Filter** calculates the second-order moments of each enclosed **Feature** in a **Triangle Geometry**. Thesecond-order moments allow for the determination of the *principal axis lengths, principal axis directions, aspectratios and moment invariant Omega3s*. The *principal axis lengths* are those of a "best-fit" ellipsoid. The algorithmfor determining the moments and these values is as follows: `Link to the full online documentation for ComputeShapesTriangleGeomFilter `_ Mapping of UI display to python named argument +-------------------------------+-------------------------------+ | UI Display | Python Named Argument | +===============================+===============================+ | Aspect Ratios | aspect_ratios_array_name | +-------------------------------+-------------------------------+ | Axis Euler Angles | axis_euler_angles_array_name | +-------------------------------+-------------------------------+ | Axis Lengths | axis_lengths_array_name | +-------------------------------+-------------------------------+ | Face Feature Centroids | centroids_array_path | +-------------------------------+-------------------------------+ | Face Labels | face_labels_array_path | +-------------------------------+-------------------------------+ | Face Feature Attribute Matrix | feature_attribute_matrix_path | +-------------------------------+-------------------------------+ | Triangle Geometry | input_triangle_geometry_path | +-------------------------------+-------------------------------+ | Omega3s | omega3s_array_name | +-------------------------------+-------------------------------+ .. py:method:: Execute(data_structure, aspect_ratios_array_name, axis_euler_angles_array_name, axis_lengths_array_name, centroids_array_path, face_labels_array_path, feature_attribute_matrix_path, input_triangle_geometry_path, omega3s_array_name) :param DataStructure data_structure: The DataStructure object that holds the data to be processed. :param nx.DataObjectNameParameter aspect_ratios_array_name: The name of the DataArray that holds the calculated Aspect Ratios values :param nx.DataObjectNameParameter axis_euler_angles_array_name: The name of the DataArray that holds the calculated Axis Euler Angles values :param nx.DataObjectNameParameter axis_lengths_array_name: The name of the DataArray that holds the calculated Axis Lengths values :param nx.ArraySelectionParameter centroids_array_path: Input DataPath to the **Feature Centroids** for the face 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 :param nx.DataObjectNameParameter omega3s_array_name: The name of the DataArray that holds the calculated Omega3 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 ` Compute Neighbor Slip Transmission Metrics ------------------------------------------ .. index:: pair: Filter Human Names; Compute Neighbor Slip Transmission Metrics .. index:: pair: Filter Class Names; ComputeSlipTransmissionMetricsFilter .. _ComputeSlipTransmissionMetricsFilter: .. py:class:: ComputeSlipTransmissionMetricsFilter **THIS FILTER ONLY WORKS ON Cubic m-3m LAUE CLASSES** `Link to the full online documentation for ComputeSlipTransmissionMetricsFilter `_ Mapping of UI display to python named argument +---------------------------------------+-------------------------------+ | UI Display | Python Named Argument | +=======================================+===============================+ | Average Quaternions | avg_quats_array_path | +---------------------------------------+-------------------------------+ | Crystal Structures | crystal_structures_array_path | +---------------------------------------+-------------------------------+ | Fracture Initiation Parameter (F1) | f1_list_array_name | +---------------------------------------+-------------------------------+ | Fracture Initiation Parameter (F1spt) | f1spt_list_array_name | +---------------------------------------+-------------------------------+ | Fracture Initiation Parameter (F7) | f7_list_array_name | +---------------------------------------+-------------------------------+ | Feature Phases | feature_phases_array_path | +---------------------------------------+-------------------------------+ | Luster-Morris M-Prime | m_prime_list_array_name | +---------------------------------------+-------------------------------+ | Feature Neighbor List | neighbor_list_array_path | +---------------------------------------+-------------------------------+ .. py:method:: Execute(data_structure, avg_quats_array_path, crystal_structures_array_path, f1_list_array_name, f1spt_list_array_name, f7_list_array_name, feature_phases_array_path, m_prime_list_array_name, neighbor_list_array_path) :param DataStructure data_structure: The DataStructure object that holds the data to be processed. :param nx.ArraySelectionParameter avg_quats_array_path: Data Array that specifies the average orientation of each Feature as a quaternion :param nx.ArraySelectionParameter crystal_structures_array_path: Enumeration representing the crystal structure for each phase :param nx.DataObjectNameParameter f1_list_array_name: DataArray Name to store the calculated F1 Values :param nx.DataObjectNameParameter f1spt_list_array_name: DataArray Name to store the calculated F1spt Values :param nx.DataObjectNameParameter f7_list_array_name: DataArray Name to store the calculated F7 Values :param nx.ArraySelectionParameter feature_phases_array_path: Data Array that specifies to which Ensemble each Feature belongs :param nx.DataObjectNameParameter m_prime_list_array_name: DataArray Name to store the calculated Luster-Morris Parameters :param nx.NeighborListSelectionParameter neighbor_list_array_path: List of the contiguous neighboring Features for a given 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 Twin Boundaries ----------------------- .. index:: pair: Filter Human Names; Compute Twin Boundaries .. index:: pair: Filter Class Names; ComputeTwinBoundariesFilter .. _ComputeTwinBoundariesFilter: .. py:class:: ComputeTwinBoundariesFilter This **Filter** identifies all **Triangles** between neighboring **Features** that have a σ = 3 twin relationship. The **Filter** uses the average orientation of the **Features** on either side of the **Triangle** to determine the *misorientation* between the **Features**. If the *axis-angle* that describes the *misorientation* is within both the axis and angle user-defined tolerance, then the **Triangle** is flagged as being a twin. After the **Triangle** is flagged as a twin, the crystal direction parallel to the **Face** normal is determined and compared with the *misorientation axis* if *Compute Coherence* is selected. The misalignment of these two crystal directions is stored as the incoherence value for the **Triangle** (in degrees). Note that this **Filter** will only extract twin boundaries if the twin **Feature** is the same phase as the parent **Feature**. `Link to the full online documentation for ComputeTwinBoundariesFilter `_ Mapping of UI display to python named argument +----------------------------------------+----------------------------------+ | UI Display | Python Named Argument | +========================================+==================================+ | Angle Tolerance (Degrees) | angle_tolerance | +----------------------------------------+----------------------------------+ | Average Quaternions | avg_quats_array_path | +----------------------------------------+----------------------------------+ | Axis Tolerance (Degrees) | axis_tolerance | +----------------------------------------+----------------------------------+ | Output Type for Twin Boundaries Array | boundaries_array_type_index | +----------------------------------------+----------------------------------+ | Crystal Structures | crystal_structures_array_path | +----------------------------------------+----------------------------------+ | Face Labels | face_labels_array_path | +----------------------------------------+----------------------------------+ | Face Normals | face_normals_array_path | +----------------------------------------+----------------------------------+ | Feature Phases | feature_phases_array_path | +----------------------------------------+----------------------------------+ | Find Coherence | find_coherence | +----------------------------------------+----------------------------------+ | Twin Boundaries Incoherence Array name | twin_boundaries_incoherence_name | +----------------------------------------+----------------------------------+ | Twin Boundaries Array name | twin_boundaries_name | +----------------------------------------+----------------------------------+ .. py:method:: Execute(data_structure, angle_tolerance, avg_quats_array_path, axis_tolerance, boundaries_array_type_index, crystal_structures_array_path, face_labels_array_path, face_normals_array_path, feature_phases_array_path, find_coherence, twin_boundaries_incoherence_name, twin_boundaries_name) :param DataStructure data_structure: The DataStructure object that holds the data to be processed. :param nx.Float32Parameter angle_tolerance: Degree of tolerance for angular deviation from 60 degrees :param nx.ArraySelectionParameter avg_quats_array_path: Specifies the average orientation of the Feature in quaternion representation :param nx.Float32Parameter axis_tolerance: Degree of tolerance for angular distance from the [111] axis :param nx.ChoicesParameter boundaries_array_type_index: The Twin Boundaries Array is essentially a mask; This allows for determining how the mask is stored; uint8 recommended. :param nx.ArraySelectionParameter crystal_structures_array_path: Specifies the crystal structure for each phase (in enumeration representation) :param nx.ArraySelectionParameter face_labels_array_path: Specifies to which Feature each Face of Triangle belongs to :param nx.ArraySelectionParameter face_normals_array_path: Specifies the Normal of each face. Only required if Find Coherence is checked :param nx.ArraySelectionParameter feature_phases_array_path: Specifies to which Ensemble each Feature belongs :param nx.BoolParameter find_coherence: If true, compute the coherence between the Face normal and the misorientation axis :param nx.DataObjectNameParameter twin_boundaries_incoherence_name: The name of array that contains the crystal direction parallel to the Face normal determined relative to the misorientation; values are 180 by default :param nx.DataObjectNameParameter twin_boundaries_name: The name of the array that will act as a mask for which triangles do make up a twin boundary (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 ` Convert EDAX Hex Grid to Square Grid (.ang) ------------------------------------------- .. index:: pair: Filter Human Names; Convert EDAX Hex Grid to Square Grid (.ang) .. index:: pair: Filter Class Names; ConvertHexGridToSquareGridFilter .. _ConvertHexGridToSquareGridFilter: .. py:class:: ConvertHexGridToSquareGridFilter This **Filter** will convert TSL .ang files on hexagonal grids to TSL .ang files on square grids by means of interpolation between points. Note that the resulting square grid .ang files may have more or less rows of data and that some data may be interpolated based on its neighbor data. By default, the spacing of the square grid will be the spacing between columns in the hexagonal grid. `Link to the full online documentation for ConvertHexGridToSquareGridFilter `_ Mapping of UI display to python named argument +------------------------+-----------------------+ | UI Display | Python Named Argument | +========================+=======================+ | Generated File List | generated_file_list | +------------------------+-----------------------+ | Input File | input_path | +------------------------+-----------------------+ | Convert Multiple Files | multiple_files | +------------------------+-----------------------+ | Output Directory | output_path | +------------------------+-----------------------+ | Output Prefix | output_prefix | +------------------------+-----------------------+ | Spacing | spacing | +------------------------+-----------------------+ .. py:method:: Execute(data_structure, generated_file_list, input_path, multiple_files, output_path, output_prefix, spacing) :param DataStructure data_structure: The DataStructure object that holds the data to be processed. :param nx.GeneratedFileListParameter generated_file_list: The values that are used to generate the input file list. See GeneratedFileListParameter for more information. :param nx.FileSystemPathParameter input_path: Path to the single file to convert :param nx.BoolParameter multiple_files: True=Convert a list of files, False, just convert a single file :param nx.FileSystemPathParameter output_path: The path to store the converted file. Should NOT be in the same directory. :param nx.StringParameter output_prefix: A string to prepend the name of each converted file :param nx.VectorFloat32Parameter spacing: Specifies the new spacing 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 ` Convert Orientation Representation ---------------------------------- .. index:: pair: Filter Human Names; Convert Orientation Representation .. index:: pair: Filter Class Names; ConvertOrientationsFilter .. _ConvertOrientationsFilter: .. py:class:: ConvertOrientationsFilter This **Filter** generates a new orientation representation (see Data Layout Table below)for each **Element**, given the *Input Orientation Representation* for the **Element**.The following table lists the various orientation representations that are supported. DREAM3Dis capable of converting between any representation with some caveats. The Input andOutput Orientation Type are represented as a zero based index into the combo box widget. `Link to the full online documentation for ConvertOrientationsFilter `_ Mapping of UI display to python named argument +-------------------------+-------------------------------+ | UI Display | Python Named Argument | +=========================+===============================+ | Input Orientations | input_orientation_array_path | +-------------------------+-------------------------------+ | Input Orientation Type | input_representation_index | +-------------------------+-------------------------------+ | Output Orientations | output_orientation_array_name | +-------------------------+-------------------------------+ | Output Orientation Type | output_representation_index | +-------------------------+-------------------------------+ .. py:method:: Execute(data_structure, input_orientation_array_path, input_representation_index, output_orientation_array_name, output_representation_index) :param DataStructure data_structure: The DataStructure object that holds the data to be processed. :param nx.ArraySelectionParameter input_orientation_array_path: The complete path to the incoming orientation representation data array :param nx.ChoicesParameter input_representation_index: Specifies the incoming orientation representation enumeration index :param nx.DataObjectNameParameter output_orientation_array_name: The name of the data array with the converted orientation representation :param nx.ChoicesParameter output_representation_index: Specifies to which orientation representation to convert the incoming data. Specified as an enumeration index :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 Quaternion Order ------------------------ .. index:: pair: Filter Human Names; Convert Quaternion Order .. index:: pair: Filter Class Names; ConvertQuaternionFilter .. _ConvertQuaternionFilter: .. py:class:: ConvertQuaternionFilter Internally DREAM3D-NX assumes that a quaternion is laid out in the order such that < x, y, z >, w or Vector-Scalar ordering. Codes and algorithms external to DREAM3D-NX may store quaternions in the opposite or Scalar-Vector order (w < x,y,z >). This filter will allow the user to easily convert imported Quaternions into the representation that DREAM3D-NX expects. `Link to the full online documentation for ConvertQuaternionFilter `_ Mapping of UI display to python named argument +----------------------+------------------------+ | UI Display | Python Named Argument | +======================+========================+ | Conversion Type | conversion_index | +----------------------+------------------------+ | Delete Original Data | delete_original_data | +----------------------+------------------------+ | Input Quaternions | input_data_array_path | +----------------------+------------------------+ | Output Quaternions | output_data_array_name | +----------------------+------------------------+ .. py:method:: Execute(data_structure, conversion_index, delete_original_data, input_data_array_path, output_data_array_name) :param DataStructure data_structure: The DataStructure object that holds the data to be processed. :param nx.ChoicesParameter conversion_index: The conversion type: To Scalar Vector=0, To Vector Scalar=1 :param nx.BoolParameter delete_original_data: Should the original quaternions array be deleted from the DataStructure :param nx.ArraySelectionParameter input_data_array_path: Specifies the quaternions to convert :param nx.DataObjectNameParameter output_data_array_name: The DataPath to the converted quaternions :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 Ensemble Info -------------------- .. index:: pair: Filter Human Names; Create Ensemble Info .. index:: pair: Filter Class Names; CreateEnsembleInfoFilter .. _CreateEnsembleInfoFilter: .. py:class:: CreateEnsembleInfoFilter This **Filter** allows the user to enter basic crystallographic information about each phase. The Laue class, Phase Type, and Phase Name can all be entered by the user. The information is stored in an EnsembleAttributeMatrix. These values are needed to allow the calculation of certain kinds of crystallographic statistics on the volume, if they have not already been provided by some other means. Each row in the table lists the **Crystal Structure**, **Phase Type**, and **Phase Name**. The proper values for the crystal structure and phase type come from internal constants within DREAM3D-NX and are listed here: `Link to the full online documentation for CreateEnsembleInfoFilter `_ Mapping of UI display to python named argument +---------------------------+-------------------------------------+ | UI Display | Python Named Argument | +===========================+=====================================+ | Ensemble Attribute Matrix | cell_ensemble_attribute_matrix_path | +---------------------------+-------------------------------------+ | Crystal Structures | crystal_structures_array_name | +---------------------------+-------------------------------------+ | Created Ensemble Info | ensemble | +---------------------------+-------------------------------------+ | Phase Names | phase_names_array_name | +---------------------------+-------------------------------------+ | Phase Types | phase_types_array_name | +---------------------------+-------------------------------------+ .. py:method:: Execute(data_structure, cell_ensemble_attribute_matrix_path, crystal_structures_array_name, ensemble, phase_names_array_name, phase_types_array_name) :param DataStructure data_structure: The DataStructure object that holds the data to be processed. :param nx.DataGroupCreationParameter cell_ensemble_attribute_matrix_path: The complete path to the attribute matrix in which to store the ensemble phase data arrays :param nx.DataObjectNameParameter crystal_structures_array_name: The name of the data array representing the crystal structure for each Ensemble :param nx.EnsembleInfoParameter ensemble: The values with which to populate the crystal structures, phase types, and phase names data arrays. Each row corresponds to an ensemble phase. :param nx.DataObjectNameParameter phase_names_array_name: The name of the string array representing the phase names for each Ensemble :param nx.DataObjectNameParameter phase_types_array_name: The name of the data array representing the phase types for 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 ` Segment Features (Misorientation) --------------------------------- .. index:: pair: Filter Human Names; Segment Features (Misorientation) .. index:: pair: Filter Class Names; EBSDSegmentFeaturesFilter .. _EBSDSegmentFeaturesFilter: .. py:class:: EBSDSegmentFeaturesFilter This **Filter** segments the **Features** by grouping neighboring **Cells** that satisfy the *misorientation tolerance*, i.e., have misorientation angle 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 EBSDSegmentFeaturesFilter `_ 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 | +------------------------------------+------------------------------------+ | Cell Mask Array | cell_mask_array_path | +------------------------------------+------------------------------------+ | Cell Phases | cell_phases_array_path | +------------------------------------+------------------------------------+ | Cell Quaternions | cell_quats_array_path | +------------------------------------+------------------------------------+ | Crystal Structures | crystal_structures_array_path | +------------------------------------+------------------------------------+ | Cell Feature Ids | feature_ids_array_name | +------------------------------------+------------------------------------+ | Input Grid Geometry | input_image_geometry_path | +------------------------------------+------------------------------------+ | Misorientation Tolerance (Degrees) | misorientation_tolerance | +------------------------------------+------------------------------------+ | Randomize Feature IDs | randomize_features | +------------------------------------+------------------------------------+ | Use Mask Array | use_mask | +------------------------------------+------------------------------------+ .. py:method:: Execute(data_structure, active_array_name, cell_feature_attribute_matrix_name, cell_mask_array_path, cell_phases_array_path, cell_quats_array_path, crystal_structures_array_path, feature_ids_array_name, input_image_geometry_path, misorientation_tolerance, randomize_features, use_mask) :param DataStructure data_structure: The DataStructure object that holds the data to be processed. :param nx.DataObjectNameParameter active_array_name: The name of the array which 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 cell feature attribute matrix :param nx.ArraySelectionParameter cell_mask_array_path: Path to the data array that specifies if the Cell is to be counted in the algorithm :param nx.ArraySelectionParameter cell_phases_array_path: Specifies to which Ensemble each cell belongs :param nx.ArraySelectionParameter cell_quats_array_path: Specifies the orientation of the Cell in quaternion representation :param nx.ArraySelectionParameter crystal_structures_array_path: Enumeration representing the crystal structure for each Ensemble :param nx.DataObjectNameParameter feature_ids_array_name: Specifies to which Feature each Cell belongs. :param nx.GeometrySelectionParameter input_image_geometry_path: DataPath to input Grid Geometry :param nx.Float32Parameter misorientation_tolerance: Tolerance (in degrees) used to determine if neighboring Cells belong to the same Feature :param nx.BoolParameter randomize_features: Specifies if feature IDs should be randomized during calculations :param nx.BoolParameter use_mask: Specifies whether to use a boolean array to exclude some Cells from the Feature identification process :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 ` Import Orientation File(s) to H5EBSD ------------------------------------ .. index:: pair: Filter Human Names; Import Orientation File(s) to H5EBSD .. index:: pair: Filter Class Names; EbsdToH5EbsdFilter .. _EbsdToH5EbsdFilter: .. py:class:: EbsdToH5EbsdFilter This **Filter** will convert orientation data obtained from Electron Backscatter Diffraction (EBSD) experiments into a single file archive based on the `HDF5 `_ file specification. See the **Supported File Formats** section below for information on file compatibility. This **Filter** is typically run as a single **Filter** **Pipeline** to perform the conversion. All subsequent **Pipelines** should then use the Read H5EBSD File **Filter** to import the H5EBSD file into DREAM3D-NX for analysis, as opposed to re-importing the raw EBSD files. The primary purpose of this **Filter** is to import a stack of data that forms a 3D volume. If the user wishes to import a single data file, then the **Filters** Read EDAX EBSD Data (.ang), Read EDAX EBSD Data (.h5), or Read Oxford Instr. EBSD Data (.ctf) should be used for EDAX .ang, EDAX .h5, or Oxford .ctf files, respectively. `Link to the full online documentation for EbsdToH5EbsdFilter `_ Mapping of UI display to python named argument +-------------------------+------------------------+ | UI Display | Python Named Argument | +=========================+========================+ | Input File List | input_file_list_object | +-------------------------+------------------------+ | Output H5Ebsd File | output_file_path | +-------------------------+------------------------+ | Reference Frame Options | reference_frame_index | +-------------------------+------------------------+ | Stacking Order | stacking_order_index | +-------------------------+------------------------+ | Z Spacing (Microns) | z_spacing | +-------------------------+------------------------+ .. py:method:: Execute(data_structure, input_file_list_object, output_file_path, reference_frame_index, stacking_order_index, z_spacing) :param DataStructure data_structure: The DataStructure object that holds the data to be processed. :param nx.GeneratedFileListParameter input_file_list_object: The values that are used to generate the input file list. See GeneratedFileListParameter for more information. :param nx.FileSystemPathParameter output_file_path: The path to the generated .h5ebsd file :param nx.ChoicesParameter reference_frame_index: The reference frame transformation. 0=EDAX(.ang), 1=Oxford(.ctf), 2=No/Unknown Transformation, 3=HEDM-IceNine :param nx.ChoicesParameter stacking_order_index: The order the files should be placed into the :param nx.Float32Parameter z_spacing: The spacing between each slice of 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 ` Merge Twins ----------- .. index:: pair: Filter Human Names; Merge Twins .. index:: pair: Filter Class Names; MergeTwinsFilter .. _MergeTwinsFilter: .. py:class:: MergeTwinsFilter *THIS FILTER ONLY WORKS ON CUBIC-HIGH (m3m) Laue Classes.* `Link to the full online documentation for MergeTwinsFilter `_ Mapping of UI display to python named argument +--------------------------------+---------------------------------------+ | UI Display | Python Named Argument | +================================+=======================================+ | Active | active_array_name | +--------------------------------+---------------------------------------+ | Angle Tolerance (Degrees) | angle_tolerance | +--------------------------------+---------------------------------------+ | Average Quaternions | avg_quats_array_path | +--------------------------------+---------------------------------------+ | Axis Tolerance (Degrees) | axis_tolerance | +--------------------------------+---------------------------------------+ | Parent Ids | cell_parent_ids_array_name | +--------------------------------+---------------------------------------+ | Contiguous Neighbor List | contiguous_neighbor_list_array_path | +--------------------------------+---------------------------------------+ | Feature Attribute Matrix | created_feature_attribute_matrix_name | +--------------------------------+---------------------------------------+ | Crystal Structures | crystal_structures_array_path | +--------------------------------+---------------------------------------+ | Cell Feature Ids | feature_ids_path | +--------------------------------+---------------------------------------+ | Parent Ids | feature_parent_ids_array_name | +--------------------------------+---------------------------------------+ | Phases | feature_phases_array_path | +--------------------------------+---------------------------------------+ | Stored Seed Value Array Name | seed_array_name | +--------------------------------+---------------------------------------+ | Seed Value | seed_value | +--------------------------------+---------------------------------------+ | Use Seed for Random Generation | use_seed | +--------------------------------+---------------------------------------+ .. py:method:: Execute(data_structure, active_array_name, angle_tolerance, avg_quats_array_path, axis_tolerance, cell_parent_ids_array_name, contiguous_neighbor_list_array_path, created_feature_attribute_matrix_name, crystal_structures_array_path, feature_ids_path, feature_parent_ids_array_name, feature_phases_array_path, seed_array_name, seed_value, use_seed) :param DataStructure data_structure: The DataStructure object that holds the data to be processed. :param nx.DataObjectNameParameter active_array_name: The name of the array specifying 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.Float32Parameter angle_tolerance: Tolerance allowed when comparing the angle part of the axis-angle representation of the misorientation :param nx.ArraySelectionParameter avg_quats_array_path: Specifies the average orientation of each Feature in quaternion representation :param nx.Float32Parameter axis_tolerance: Tolerance allowed when comparing the axis part of the axis-angle representation of the misorientation :param nx.DataObjectNameParameter cell_parent_ids_array_name: The name of the array specifying to which parent each cell belongs :param nx.NeighborListSelectionParameter contiguous_neighbor_list_array_path: List of contiguous neighbors for each Feature. :param nx.DataObjectNameParameter created_feature_attribute_matrix_name: The name of the created cell feature attribute matrix :param nx.ArraySelectionParameter crystal_structures_array_path: Enumeration representing the crystal structure for each Ensemble :param nx.ArraySelectionParameter feature_ids_path: Specifies to which Feature each cell belongs :param nx.DataObjectNameParameter feature_parent_ids_array_name: The name of the array specifying to which parent each Feature belongs :param nx.ArraySelectionParameter feature_phases_array_path: Specifies to which Ensemble each cell belongs :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 ` Neighbor Orientation Correlation -------------------------------- .. index:: pair: Filter Human Names; Neighbor Orientation Correlation .. index:: pair: Filter Class Names; NeighborOrientationCorrelationFilter .. _NeighborOrientationCorrelationFilter: .. py:class:: NeighborOrientationCorrelationFilter This filter first identifies all cells that have a *Confidence Index* below the minimum set by the user. Then, for each of those cells, their neighboring cells are checked to determine the number of neighbor cells with orientations different than the reference cell by more than the user defined *Misorientation Tolerance*. In addition the neighboring cells are compared with each other to determine the number of neighboring cells that have the same orientation (again within the user defined tolerance). The *Cleanup Level* set by the user is then used to determine which cells are replaced. If a level of 5 is set, at least 5 of the neighboring cells must be within the same misorientation tolerance (and so on for other *Cleanup Level*). If a cell meets the replacement criteria, then all of its attributes are replaced with the attributes of one of the neighboring cells that are the same as each other. `Link to the full online documentation for NeighborOrientationCorrelationFilter `_ Mapping of UI display to python named argument +------------------------------------+-------------------------------+ | UI Display | Python Named Argument | +====================================+===============================+ | Cell Phases | cell_phases_array_path | +------------------------------------+-------------------------------+ | Confidence Index | correlation_array_path | +------------------------------------+-------------------------------+ | Crystal Structures | crystal_structures_array_path | +------------------------------------+-------------------------------+ | Attribute Arrays to Ignore | ignored_data_array_paths | +------------------------------------+-------------------------------+ | Image Geometry | input_image_geometry_path | +------------------------------------+-------------------------------+ | Cleanup Level | level | +------------------------------------+-------------------------------+ | Minimum Confidence Index | min_confidence | +------------------------------------+-------------------------------+ | Misorientation Tolerance (Degrees) | misorientation_tolerance | +------------------------------------+-------------------------------+ | Cell Quaternions | quats_array_path | +------------------------------------+-------------------------------+ .. py:method:: Execute(data_structure, cell_phases_array_path, correlation_array_path, crystal_structures_array_path, ignored_data_array_paths, input_image_geometry_path, level, min_confidence, misorientation_tolerance, quats_array_path) :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 correlation_array_path: Specifies the confidence in the orientation of the Cell (TSL data) :param nx.ArraySelectionParameter crystal_structures_array_path: Enumeration representing the crystal structure for each Ensemble :param nx.MultiArraySelectionParameter ignored_data_array_paths: The list of arrays to ignore :param nx.GeometrySelectionParameter input_image_geometry_path: Path to the target geometry :param nx.Int32Parameter level: Minimum number of neighbor Cells that must have orientations within above tolerance to allow Cell to be changed :param nx.Float32Parameter min_confidence: Sets the minimum value of 'confidence' a Cell must have :param nx.Float32Parameter misorientation_tolerance: Angular tolerance used to compare with neighboring Cells :param nx.ArraySelectionParameter quats_array_path: Specifies the orientation of the Cell in quaternion representation :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 EDAX EBSD Data (.ang) -------------------------- .. index:: pair: Filter Human Names; Read EDAX EBSD Data (.ang) .. index:: pair: Filter Class Names; ReadAngDataFilter .. _ReadAngDataFilter: .. py:class:: ReadAngDataFilter This **Filter** will read a single .ang file into a new **Image Geometry**, allowing the immediate use of **Filters** on the data instead of having to generate the intermediate .h5ebsd file. A **Cell Attribute Matrix** and Ensemble Attribute Matrix** will also be created to hold the imported EBSD information. Currently, the user has no control over the names of the created **Attribute Arrays**. The user should be aware that simply reading the file then performing operations that are dependent on the proper crystallographic and sample reference frame will be undefined or simply **wrong**. In order to bring the crystal reference frame and sample reference frame into coincidence, rotations will need to be applied to the data. `Link to the full online documentation for ReadAngDataFilter `_ Mapping of UI display to python named argument +---------------------------+-------------------------------------+ | UI Display | Python Named Argument | +===========================+=====================================+ | Cell Attribute Matrix | cell_attribute_matrix_name | +---------------------------+-------------------------------------+ | Ensemble Attribute Matrix | cell_ensemble_attribute_matrix_name | +---------------------------+-------------------------------------+ | Input File | input_file | +---------------------------+-------------------------------------+ | Image Geometry | output_image_geometry_path | +---------------------------+-------------------------------------+ .. py:method:: Execute(data_structure, cell_attribute_matrix_name, cell_ensemble_attribute_matrix_name, input_file, output_image_geometry_path) :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 cell data attribute matrix for the created Image Geometry :param nx.DataObjectNameParameter cell_ensemble_attribute_matrix_name: The Attribute Matrix where the phase information is stored. :param nx.FileSystemPathParameter input_file: The input .ang file path :param nx.DataGroupCreationParameter output_image_geometry_path: The path to the created 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 ` Read Oxford Instr. Channel 5 (.cpr/.crc) ---------------------------------------- .. index:: pair: Filter Human Names; Read Oxford Instr. Channel 5 (.cpr/.crc) .. index:: pair: Filter Class Names; ReadChannel5DataFilter .. _ReadChannel5DataFilter: .. py:class:: ReadChannel5DataFilter This filter will read a single .cpr/.crc file pair into a new ImageGeometry. A **Cell Attribute Matrix** andEnsemble Attribute Matrix** will also be created to hold the imported EBSD information. Currently, the user has nocontrol over the names of the created **Attribute Arrays**. The user should be aware that simply reading the filethen performing operations that are dependent on the proper crystallographic and sample reference frame will be**undefined, inaccurate and/or wrong**. In order to bring the crystal reference frame and sample reference frameinto coincidence, rotations will need to be applied to the data. An excellent reference for this is the following PDF file:`http://pajarito.materials.cmu.edu/rollett/27750/L17-EBSD-analysis-31Mar16.pdf `_ `Link to the full online documentation for ReadChannel5DataFilter `_ Mapping of UI display to python named argument +--------------------------------------------------------+-------------------------------------+ | UI Display | Python Named Argument | +========================================================+=====================================+ | Cell Attribute Matrix | cell_attribute_matrix_name | +--------------------------------------------------------+-------------------------------------+ | Ensemble Attribute Matrix | cell_ensemble_attribute_matrix_name | +--------------------------------------------------------+-------------------------------------+ | Convert Data Arrays to be more compatible with DREAM3D | create_compatible_arrays | +--------------------------------------------------------+-------------------------------------+ | Convert Hexagonal X-Axis to EDAX Standard | edax_hexagonal_alignment | +--------------------------------------------------------+-------------------------------------+ | Input File (.cpr) | input_file | +--------------------------------------------------------+-------------------------------------+ | Image Geometry | output_image_geometry_path | +--------------------------------------------------------+-------------------------------------+ .. py:method:: Execute(data_structure, cell_attribute_matrix_name, cell_ensemble_attribute_matrix_name, create_compatible_arrays, edax_hexagonal_alignment, input_file, output_image_geometry_path) :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 cell data attribute matrix for the created Image Geometry :param nx.DataObjectNameParameter cell_ensemble_attribute_matrix_name: The Attribute Matrix where the phase information is stored. :param nx.BoolParameter create_compatible_arrays: Some arrays will be converted from the type they are in the file to more compatible types. :param nx.BoolParameter edax_hexagonal_alignment: Whether or not to convert a Hexagonal phase to the EDAX standard for x-axis alignment :param nx.FileSystemPathParameter input_file: The input .cpr file path. The .crc file must also exist. :param nx.DataGroupCreationParameter output_image_geometry_path: The path to the created 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 ` Read Oxford Instr. EBSD Data (.ctf) ----------------------------------- .. index:: pair: Filter Human Names; Read Oxford Instr. EBSD Data (.ctf) .. index:: pair: Filter Class Names; ReadCtfDataFilter .. _ReadCtfDataFilter: .. py:class:: ReadCtfDataFilter This **Filter** will read a single .ctf file into a new **Image Geometry**, allowing the immediate use of **Filters** on the data instead of having to generate the intermediate .h5ebsd file. A **Cell Attribute Matrix** and Ensemble Attribute Matrix** will also be created to hold the imported EBSD information. Currently, the user has no control over the names of the created **Attribute Arrays**. The user should be aware that simply reading the file then performing operations that are dependent on the proper crystallographic and sample reference frame will be **undefined, inaccurate and/or wrong**. In order to bring the crystal reference frame and sample reference frame into coincidence, rotations will need to be applied to the data. An excellent reference for this is the following PDF file:`http://pajarito.materials.cmu.edu/rollett/27750/L17-EBSD-analysis-31Mar16.pdf `_ `Link to the full online documentation for ReadCtfDataFilter `_ Mapping of UI display to python named argument +-------------------------------------------+-------------------------------------+ | UI Display | Python Named Argument | +===========================================+=====================================+ | Cell Attribute Matrix | cell_attribute_matrix_name | +-------------------------------------------+-------------------------------------+ | Ensemble Attribute Matrix | cell_ensemble_attribute_matrix_name | +-------------------------------------------+-------------------------------------+ | Convert Euler Angles to Radians | degrees_to_radians | +-------------------------------------------+-------------------------------------+ | Convert Hexagonal X-Axis to EDAX Standard | edax_hexagonal_alignment | +-------------------------------------------+-------------------------------------+ | Input File | input_file | +-------------------------------------------+-------------------------------------+ | Image Geometry | output_image_geometry_path | +-------------------------------------------+-------------------------------------+ .. py:method:: Execute(data_structure, cell_attribute_matrix_name, cell_ensemble_attribute_matrix_name, degrees_to_radians, edax_hexagonal_alignment, input_file, output_image_geometry_path) :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 cell data attribute matrix for the created Image Geometry :param nx.DataObjectNameParameter cell_ensemble_attribute_matrix_name: The Attribute Matrix where the phase information is stored. :param nx.BoolParameter degrees_to_radians: Whether or not to convert the Euler angles to Radians :param nx.BoolParameter edax_hexagonal_alignment: Whether or not to convert a Hexagonal phase to the EDAX standard for x-axis alignment :param nx.FileSystemPathParameter input_file: The input .ctf file path :param nx.DataGroupCreationParameter output_image_geometry_path: The path to the created 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 ` Read Ensemble Info File ----------------------- .. index:: pair: Filter Human Names; Read Ensemble Info File .. index:: pair: Filter Class Names; ReadEnsembleInfoFilter .. _ReadEnsembleInfoFilter: .. py:class:: ReadEnsembleInfoFilter This **Filter** reads in information about the crystal structure and phase types of all the **Features** that are contained in a **Cell** based volume. These values are needed to allow the calculation of statistics on the volume, if they have not already been provided by some other means. The format of the input file is a simple ASCII text file with the extension .ini or .txt. The first group in the file is the name [EnsembleInfo] in square brackets with the key Number_Phases=*number of phases* that are contained in the volume. Subsequent groups in the file list the **Phase Number**, **Crystal Structure** and **Phase Type**. The proper values for the crystal structure and phase type come from internal constants within DREAM3D-NX and are listed here: `Link to the full online documentation for ReadEnsembleInfoFilter `_ Mapping of UI display to python named argument +---------------------------+-------------------------------------+ | UI Display | Python Named Argument | +===========================+=====================================+ | Ensemble Attribute Matrix | cell_ensemble_attribute_matrix_name | +---------------------------+-------------------------------------+ | Crystal Structures | crystal_structures_array_name | +---------------------------+-------------------------------------+ | Input Ensemble Info File | input_file | +---------------------------+-------------------------------------+ | Data Container | parent_group_path | +---------------------------+-------------------------------------+ | Phase Types | phase_types_array_name | +---------------------------+-------------------------------------+ .. py:method:: Execute(data_structure, cell_ensemble_attribute_matrix_name, crystal_structures_array_name, input_file, parent_group_path, phase_types_array_name) :param DataStructure data_structure: The DataStructure object that holds the data to be processed. :param nx.DataObjectNameParameter cell_ensemble_attribute_matrix_name: The name of the created Ensemble Attribute Matrix :param nx.DataObjectNameParameter crystal_structures_array_name: The name of the created array representing the crystal structure for each Ensemble :param nx.FileSystemPathParameter input_file: The path to the ini formatted input file :param nx.DataGroupSelectionParameter parent_group_path: The path to the data object in which the ensemble information will be stored :param nx.DataObjectNameParameter phase_types_array_name: The name of the created array representing the phase type for 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 ` Read GrainMapper3D File ----------------------- .. index:: pair: Filter Human Names; Read GrainMapper3D File .. index:: pair: Filter Class Names; ReadGrainMapper3DFilter .. _ReadGrainMapper3DFilter: .. py:class:: ReadGrainMapper3DFilter This filter will read Version 4 and Version 5 GrainMapper3D HDF5 files. `Link to the full online documentation for ReadGrainMapper3DFilter `_ Mapping of UI display to python named argument +------------------------------------+---------------------------------------+ | UI Display | Python Named Argument | +====================================+=======================================+ | Cell Attribute Matrix | cell_absorption_attribute_matrix_name | +------------------------------------+---------------------------------------+ | Cell Attribute Matrix | cell_attribute_matrix_name | +------------------------------------+---------------------------------------+ | Ensemble Attribute Matrix | cell_ensemble_attribute_matrix_name | +------------------------------------+---------------------------------------+ | Create Compatible Orientation Data | convert_orientation_data | +------------------------------------+---------------------------------------+ | Create Compatible Phase Data | convert_phase_to_int32 | +------------------------------------+---------------------------------------+ | Input File | input_file | +------------------------------------+---------------------------------------+ | Image Geometry | output_absorption_image_geometry_path | +------------------------------------+---------------------------------------+ | Image Geometry | output_dct_image_geometry_path | +------------------------------------+---------------------------------------+ | Read AbsorptionCT Data | read_absorption_ct_data | +------------------------------------+---------------------------------------+ | Read LabDCT Data | read_lab_dct_data | +------------------------------------+---------------------------------------+ .. py:method:: Execute(data_structure, cell_absorption_attribute_matrix_name, cell_attribute_matrix_name, cell_ensemble_attribute_matrix_name, convert_orientation_data, convert_phase_to_int32, input_file, output_absorption_image_geometry_path, output_dct_image_geometry_path, read_absorption_ct_data, read_lab_dct_data) :param DataStructure data_structure: The DataStructure object that holds the data to be processed. :param nx.DataObjectNameParameter cell_absorption_attribute_matrix_name: The name of the cell data attribute matrix for the created Image Geometry :param nx.DataObjectNameParameter cell_attribute_matrix_name: The name of the cell data attribute matrix for the created Image Geometry :param nx.DataObjectNameParameter cell_ensemble_attribute_matrix_name: The Attribute Matrix where the phase information is stored. :param nx.BoolParameter convert_orientation_data: Orientation data such as Quaternions and Rodrigues vectors will be converted to be DREAM3D-NX compatible :param nx.BoolParameter convert_phase_to_int32: Native Phases data value is uint8. Convert to Int32 for better filter compatibility :param nx.FileSystemPathParameter input_file: The input .hdf5 file path :param nx.DataGroupCreationParameter output_absorption_image_geometry_path: The path to the created Image Geometry :param nx.DataGroupCreationParameter output_dct_image_geometry_path: The path to the created Image Geometry :param nx.BoolParameter read_absorption_ct_data: Read the AbsorptionCT data :param nx.BoolParameter read_lab_dct_data: Read the LabDCT 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 H5EBSD File ---------------- .. index:: pair: Filter Human Names; Read H5EBSD File .. index:: pair: Filter Class Names; ReadH5EbsdFilter .. _ReadH5EbsdFilter: .. py:class:: ReadH5EbsdFilter This **Filter** reads from the .h5ebsd file that was generated with the *Import Orientation File(s) to H5EBSD* **Filter**. `Link to the full online documentation for ReadH5EbsdFilter `_ Mapping of UI display to python named argument +---------------------------+-------------------------------------+ | UI Display | Python Named Argument | +===========================+=====================================+ | Cell Attribute Matrix | cell_attribute_matrix_name | +---------------------------+-------------------------------------+ | Ensemble Attribute Matrix | cell_ensemble_attribute_matrix_name | +---------------------------+-------------------------------------+ | Image Geometry | output_image_geometry_path | +---------------------------+-------------------------------------+ | Import H5Ebsd File | read_h5_ebsd_object | +---------------------------+-------------------------------------+ .. py:method:: Execute(data_structure, cell_attribute_matrix_name, cell_ensemble_attribute_matrix_name, output_image_geometry_path, read_h5_ebsd_object) :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 cell data attribute matrix for the created Image Geometry :param nx.DataObjectNameParameter cell_ensemble_attribute_matrix_name: The Attribute Matrix where the phase information is stored. :param nx.DataGroupCreationParameter output_image_geometry_path: The path to the created Image Geometry :param nx.ReadH5EbsdFileParameter read_h5_ebsd_object: Object that holds all relevant information to import data from 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 ` Read Bruker Nano Esprit Data (.h5) ---------------------------------- .. index:: pair: Filter Human Names; Read Bruker Nano Esprit Data (.h5) .. index:: pair: Filter Class Names; ReadH5EspritDataFilter .. _ReadH5EspritDataFilter: .. py:class:: ReadH5EspritDataFilter This **Filter** will read a single .h5 file into a new **Image Geometry**, allowing the immediate use of **Filters** on the data instead of having to generate the intermediate .h5ebsd file. A **Cell Attribute Matrix** and Ensemble Attribute Matrix** will also be created to hold the imported EBSD information. Currently, the user has no control over the names of the created **Attribute Arrays**. `Link to the full online documentation for ReadH5EspritDataFilter `_ Mapping of UI display to python named argument +---------------------------------+-------------------------------------+ | UI Display | Python Named Argument | +=================================+=====================================+ | Cell Attribute Matrix | cell_attribute_matrix_name | +---------------------------------+-------------------------------------+ | Ensemble Attribute Matrix | cell_ensemble_attribute_matrix_name | +---------------------------------+-------------------------------------+ | Convert Euler Angles to Radians | degrees_to_radians | +---------------------------------+-------------------------------------+ | Origin | origin | +---------------------------------+-------------------------------------+ | Image Geometry | output_image_geometry_path | +---------------------------------+-------------------------------------+ | Import Pattern Data | read_pattern_data | +---------------------------------+-------------------------------------+ | Scan Names | selected_scan_names | +---------------------------------+-------------------------------------+ | Z Spacing (Microns) | z_spacing | +---------------------------------+-------------------------------------+ .. py:method:: Execute(data_structure, cell_attribute_matrix_name, cell_ensemble_attribute_matrix_name, degrees_to_radians, origin, output_image_geometry_path, read_pattern_data, selected_scan_names, z_spacing) :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 cell data attribute matrix for the created Image Geometry :param nx.DataObjectNameParameter cell_ensemble_attribute_matrix_name: The Attribute Matrix where the phase information is stored. :param nx.BoolParameter degrees_to_radians: Whether or not to convert the euler angles to radians :param nx.VectorFloat32Parameter origin: The origin of the volume :param nx.DataGroupCreationParameter output_image_geometry_path: The path to the created Image Geometry :param nx.BoolParameter read_pattern_data: Whether or not to import the pattern data :param nx.OEMEbsdScanSelectionParameter selected_scan_names: The name of the scan(s) in the .h5 file. Esprit can store multiple scans in a single file :param nx.Float32Parameter z_spacing: The spacing in microns between each layer. :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 EDAX OIMAnalysis Data (.h5) -------------------------------- .. index:: pair: Filter Human Names; Read EDAX OIMAnalysis Data (.h5) .. index:: pair: Filter Class Names; ReadH5OimDataFilter .. _ReadH5OimDataFilter: .. py:class:: ReadH5OimDataFilter This **Filter** will read a single .h5 file into a new **Image Geometry**, allowing the immediate use of **Filters** on the data instead of having to generate the intermediate .h5ebsd file. A **Cell Attribute Matrix** and Ensemble Attribute Matrix** will also be created to hold the imported EBSD information. Currently, the user has no control over the names of the created **Attribute Arrays**. `Link to the full online documentation for ReadH5OimDataFilter `_ Mapping of UI display to python named argument +---------------------------+-------------------------------------+ | UI Display | Python Named Argument | +===========================+=====================================+ | Cell Attribute Matrix | cell_attribute_matrix_name | +---------------------------+-------------------------------------+ | Ensemble Attribute Matrix | cell_ensemble_attribute_matrix_name | +---------------------------+-------------------------------------+ | Origin | origin | +---------------------------+-------------------------------------+ | Image Geometry | output_image_geometry_path | +---------------------------+-------------------------------------+ | Import Pattern Data | read_pattern_data | +---------------------------+-------------------------------------+ | Scan Names | selected_scan_names | +---------------------------+-------------------------------------+ | Z Spacing (Microns) | z_spacing | +---------------------------+-------------------------------------+ .. py:method:: Execute(data_structure, cell_attribute_matrix_name, cell_ensemble_attribute_matrix_name, origin, output_image_geometry_path, read_pattern_data, selected_scan_names, z_spacing) :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 cell data attribute matrix for the created Image Geometry :param nx.DataObjectNameParameter cell_ensemble_attribute_matrix_name: The Attribute Matrix where the phase information is stored. :param nx.VectorFloat32Parameter origin: The origin of the volume :param nx.DataGroupCreationParameter output_image_geometry_path: The path to the created Image Geometry :param nx.BoolParameter read_pattern_data: Whether or not to import the pattern data :param nx.OEMEbsdScanSelectionParameter selected_scan_names: The name of the scan in the .h5 file. EDAX can store multiple scans in a single file :param nx.Float32Parameter z_spacing: The spacing in microns between each layer. :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 Oxford Aztec Data (.h5oina) -------------------------------- .. index:: pair: Filter Human Names; Read Oxford Aztec Data (.h5oina) .. index:: pair: Filter Class Names; ReadH5OinaDataFilter .. _ReadH5OinaDataFilter: .. py:class:: ReadH5OinaDataFilter This filter will read data from a single .h5oina file into a new **Image Geometry**, allowing the immediate use of**Filters** on the data instead of having to generate the intermediate .h5ebsd file. A **Cell Attribute Matrix** and**Ensemble Attribute Matrix** will also be created to hold the imported EBSD information. Currently, the user has no controlover the names of the created **Attribute Arrays**. `Link to the full online documentation for ReadH5OinaDataFilter `_ Mapping of UI display to python named argument +-------------------------------------------+-------------------------------------+ | UI Display | Python Named Argument | +===========================================+=====================================+ | Cell Attribute Matrix | cell_attribute_matrix_name | +-------------------------------------------+-------------------------------------+ | Ensemble Attribute Matrix | cell_ensemble_attribute_matrix_name | +-------------------------------------------+-------------------------------------+ | Convert Phase Data to Int32 | convert_phase_to_int32 | +-------------------------------------------+-------------------------------------+ | Convert Hexagonal X-Axis to EDAX Standard | edax_hexagonal_alignment | +-------------------------------------------+-------------------------------------+ | Origin | origin | +-------------------------------------------+-------------------------------------+ | Image Geometry | output_image_geometry_path | +-------------------------------------------+-------------------------------------+ | Import Pattern Data | read_pattern_data | +-------------------------------------------+-------------------------------------+ | Scan Names | selected_scan_names | +-------------------------------------------+-------------------------------------+ | Z Spacing (Microns) | z_spacing | +-------------------------------------------+-------------------------------------+ .. py:method:: Execute(data_structure, cell_attribute_matrix_name, cell_ensemble_attribute_matrix_name, convert_phase_to_int32, edax_hexagonal_alignment, origin, output_image_geometry_path, read_pattern_data, selected_scan_names, z_spacing) :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 cell data attribute matrix for the created Image Geometry :param nx.DataObjectNameParameter cell_ensemble_attribute_matrix_name: The Attribute Matrix where the phase information is stored. :param nx.BoolParameter convert_phase_to_int32: Native Phases data value is uint8. Convert to Int32 for better filter compatibility :param nx.BoolParameter edax_hexagonal_alignment: Whether or not to convert a Hexagonal phase to the EDAX standard for x-axis alignment :param nx.VectorFloat32Parameter origin: The origin of the volume :param nx.DataGroupCreationParameter output_image_geometry_path: The path to the created Image Geometry :param nx.BoolParameter read_pattern_data: Whether or not to import the pattern data :param nx.OEMEbsdScanSelectionParameter selected_scan_names: The name of the scan in the .h5oina file. Oxford can store multiple scans in a single file :param nx.Float32Parameter z_spacing: The spacing in microns between each layer. :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 ` Rodrigues Convertor ------------------- .. index:: pair: Filter Human Names; Rodrigues Convertor .. index:: pair: Filter Class Names; RodriguesConvertorFilter .. _RodriguesConvertorFilter: .. py:class:: RodriguesConvertorFilter This *filter* will convert a 3 component Rodrigues vector into a 4 component vector that DREAM3D-NX expects in itsequations and algorithms. The algorithm is the following: `Link to the full online documentation for RodriguesConvertorFilter `_ Mapping of UI display to python named argument +--------------------------------+------------------------+ | UI Display | Python Named Argument | +================================+========================+ | Delete Original Data | delete_original_data | +--------------------------------+------------------------+ | Input Rodrigues Vectors | input_data_array_path | +--------------------------------+------------------------+ | Converted Rodrigues Data Array | output_data_array_name | +--------------------------------+------------------------+ .. py:method:: Execute(data_structure, delete_original_data, input_data_array_path, output_data_array_name) :param DataStructure data_structure: The DataStructure object that holds the data to be processed. :param nx.BoolParameter delete_original_data: Should the original Rodrigues data array be deleted from the DataStructure :param nx.ArraySelectionParameter input_data_array_path: Specifies the Rodrigues data to convert :param nx.DataObjectNameParameter output_data_array_name: The DataArray name of the converted Rodrigues vectors :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 Euler Reference Frame ---------------------------- .. index:: pair: Filter Human Names; Rotate Euler Reference Frame .. index:: pair: Filter Class Names; RotateEulerRefFrameFilter .. _RotateEulerRefFrameFilter: .. py:class:: RotateEulerRefFrameFilter This **Filter** performs a passive rotation (Right hand rule) of the Euler Angles about a user defined axis. The *reference frame* is being rotated and thus the *Euler Angles* necessary to represent the same orientation must change to account for the new *reference frame*. The user can set an *angle* and an *axis* to define the rotation of the *reference frame*. `Link to the full online documentation for RotateEulerRefFrameFilter `_ Mapping of UI display to python named argument +------------------------------+-------------------------+ | UI Display | Python Named Argument | +==============================+=========================+ | Input Euler Angles | euler_angles_array_path | +------------------------------+-------------------------+ | Rotation Axis-Angle [w] | rotation_axis_angle | +------------------------------+-------------------------+ .. py:method:: Execute(data_structure, euler_angles_array_path, rotation_axis_angle) :param DataStructure data_structure: The DataStructure object that holds the data to be processed. :param nx.ArraySelectionParameter euler_angles_array_path: Three angles defining the orientation of the Cell in Bunge convention (Z-X-Z) :param nx.VectorFloat32Parameter rotation_axis_angle: Axis-Angle in sample reference frame to rotate about. :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 GBCD Pole Figure (GMT 5) ------------------------------ .. index:: pair: Filter Human Names; Write GBCD Pole Figure (GMT 5) .. index:: pair: Filter Class Names; WriteGBCDGMTFileFilter .. _WriteGBCDGMTFileFilter: .. py:class:: WriteGBCDGMTFileFilter This **Filter** creates a .dat file that can be used in conjunction with `GMT `_ to generate a grain boundary character distribution (GBCD) pole figure. The user must select the relevant phase for which to write the pole figure by entering the *phase index*. `Link to the full online documentation for WriteGBCDGMTFileFilter `_ Mapping of UI display to python named argument +---------------------------+-------------------------------+ | UI Display | Python Named Argument | +===========================+===============================+ | Crystal Structures | crystal_structures_array_path | +---------------------------+-------------------------------+ | GBCD | gbcd_array_path | +---------------------------+-------------------------------+ | Misorientation Axis-Angle | misorientation_rotation | +---------------------------+-------------------------------+ | Output GMT File | output_file | +---------------------------+-------------------------------+ | Phase of Interest | phase_of_interest | +---------------------------+-------------------------------+ .. py:method:: Execute(data_structure, crystal_structures_array_path, gbcd_array_path, misorientation_rotation, output_file, phase_of_interest) :param DataStructure data_structure: The DataStructure object that holds the data to be processed. :param nx.ArraySelectionParameter crystal_structures_array_path: Enumeration representing the crystal structure for each Ensemble :param nx.ArraySelectionParameter gbcd_array_path: 5 parameter GBCD data. The 6th component is used internally to track the northern vs. southern hemisphere of the Lambert sphere :param nx.VectorFloat32Parameter misorientation_rotation: Axis-Angle pair values for drawing GBCD :param nx.FileSystemPathParameter output_file: The output .dat file path :param nx.Int32Parameter phase_of_interest: Index of the Ensemble for which to plot the pole figure :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 GBCD Triangles File ------------------------- .. index:: pair: Filter Human Names; Write GBCD Triangles File .. index:: pair: Filter Class Names; WriteGBCDTriangleDataFilter .. _WriteGBCDTriangleDataFilter: .. py:class:: WriteGBCDTriangleDataFilter This **Filter** writes relevant information about the Grain Boundary Character Distribution (GBCD) on an existing set of triangles. The information written includes the inward and outward Euler angles, normals, and areas for each triangle. The file format was originally defined by Prof. Greg Rohrer (CMU). `Link to the full online documentation for WriteGBCDTriangleDataFilter `_ Mapping of UI display to python named argument +----------------------+--------------------------------------+ | UI Display | Python Named Argument | +======================+======================================+ | Average Euler Angles | feature_euler_angles_array_path | +----------------------+--------------------------------------+ | Output File | output_file | +----------------------+--------------------------------------+ | Face Areas | surface_mesh_face_areas_array_path | +----------------------+--------------------------------------+ | Face Labels | surface_mesh_face_labels_array_path | +----------------------+--------------------------------------+ | Face Normals | surface_mesh_face_normals_array_path | +----------------------+--------------------------------------+ .. py:method:: Execute(data_structure, feature_euler_angles_array_path, output_file, surface_mesh_face_areas_array_path, surface_mesh_face_labels_array_path, surface_mesh_face_normals_array_path) :param DataStructure data_structure: The DataStructure object that holds the data to be processed. :param nx.ArraySelectionParameter feature_euler_angles_array_path: Three angles defining the orientation of the Feature in Bunge convention (Z-X-Z). :param nx.FileSystemPathParameter output_file: The output GBCD triangle file path :param nx.ArraySelectionParameter surface_mesh_face_areas_array_path: Specifies the area of each Face :param nx.ArraySelectionParameter surface_mesh_face_labels_array_path: Specifies which Features are on either side of each Face :param nx.ArraySelectionParameter surface_mesh_face_normals_array_path: Specifies the normal 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 ` Write INL File -------------- .. index:: pair: Filter Human Names; Write INL File .. index:: pair: Filter Class Names; WriteINLFileFilter .. _WriteINLFileFilter: .. py:class:: WriteINLFileFilter This **Filter** writes out **Cell** data from an **Image Geometry** to a file format used by the Idaho National Laboratory (INL). The format is columnar and space delimited, with header lines denoted by the "#" character. The columns are the following: `Link to the full online documentation for WriteINLFileFilter `_ 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 | +--------------------+-------------------------------+ | Crystal Structures | crystal_structures_array_path | +--------------------+-------------------------------+ | Cell Feature Ids | feature_ids_array_path | +--------------------+-------------------------------+ | Image Geometry | input_image_geometry_path | +--------------------+-------------------------------+ | Material Names | material_name_array_path | +--------------------+-------------------------------+ | Number of Features | num_features_array_path | +--------------------+-------------------------------+ | Output File | output_file | +--------------------+-------------------------------+ .. py:method:: Execute(data_structure, cell_euler_angles_array_path, cell_phases_array_path, crystal_structures_array_path, feature_ids_array_path, input_image_geometry_path, material_name_array_path, num_features_array_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: Three angles defining the orientation of the Cell in Bunge convention (Z-X-Z) :param nx.ArraySelectionParameter cell_phases_array_path: Specifies to which Ensemble each Cell belongs :param nx.ArraySelectionParameter crystal_structures_array_path: Enumeration representing the crystal structure for each Ensemble :param nx.ArraySelectionParameter feature_ids_array_path: Specifies to which Feature each Cell belongs :param nx.GeometrySelectionParameter input_image_geometry_path: The selected image geometry :param nx.DataPathSelectionParameter material_name_array_path: Name of each Ensemble :param nx.ArraySelectionParameter num_features_array_path: The number of Features per Ensemble :param nx.FileSystemPathParameter output_file: The output .inl 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 ` Generate and Write Pole Figure Images ------------------------------------- .. index:: pair: Filter Human Names; Generate and Write Pole Figure Images .. index:: pair: Filter Class Names; WritePoleFigureFilter .. _WritePoleFigureFilter: .. py:class:: WritePoleFigureFilter This **Filter** creates a standard crystallographic pole figure image for each **Ensemble** (phase) in a selected **Data Container**. The **Filter** uses Euler angles in radians and requires the crystal structures and material names for each **Ensemble** array and the corresponding **Ensemble** Ids on the **Cells**. The **Filter** also optionally can use a *mask* array to determine which angles are valid for the pole figure computation. `Link to the full online documentation for WritePoleFigureFilter `_ Mapping of UI display to python named argument +-------------------------------+-------------------------------+ | UI Display | Python Named Argument | +===============================+===============================+ | Euler Angles | cell_euler_angles_array_path | +-------------------------------+-------------------------------+ | Phases | cell_phases_array_path | +-------------------------------+-------------------------------+ | Crystal Structures | crystal_structures_array_path | +-------------------------------+-------------------------------+ | Pole Figure Type | generation_algorithm_index | +-------------------------------+-------------------------------+ | Image Layout | image_layout_index | +-------------------------------+-------------------------------+ | Pole Figure File Prefix | image_prefix | +-------------------------------+-------------------------------+ | Image Size (Square Pixels) | image_size | +-------------------------------+-------------------------------+ | Output Count Image Geometry | intensity_geometry_path | +-------------------------------+-------------------------------+ | Count Plot 1 | intensity_plot_1_name | +-------------------------------+-------------------------------+ | Count Plot 2 | intensity_plot_2_name | +-------------------------------+-------------------------------+ | Count Plot 3 | intensity_plot_3_name | +-------------------------------+-------------------------------+ | Lambert Image Size (Pixels) | lambert_size | +-------------------------------+-------------------------------+ | Mask Array | mask_array_path | +-------------------------------+-------------------------------+ | Material Name | material_name_array_path | +-------------------------------+-------------------------------+ | Normalize Count Data to MRD | normalize_to_mrd | +-------------------------------+-------------------------------+ | Number of Colors | num_colors | +-------------------------------+-------------------------------+ | Output Image Geometry | output_image_geometry_path | +-------------------------------+-------------------------------+ | Output Directory Path | output_path | +-------------------------------+-------------------------------+ | Save Output as Image Geometry | save_as_image_geometry | +-------------------------------+-------------------------------+ | Save Count Images | save_intensity_plots | +-------------------------------+-------------------------------+ | Figure Title | title | +-------------------------------+-------------------------------+ | Use Mask Array | use_mask | +-------------------------------+-------------------------------+ | Write Pole Figure as Image | write_image_to_disk | +-------------------------------+-------------------------------+ .. py:method:: Execute(data_structure, cell_euler_angles_array_path, cell_phases_array_path, crystal_structures_array_path, generation_algorithm_index, image_layout_index, image_prefix, image_size, intensity_geometry_path, intensity_plot_1_name, intensity_plot_2_name, intensity_plot_3_name, lambert_size, mask_array_path, material_name_array_path, normalize_to_mrd, num_colors, output_image_geometry_path, output_path, save_as_image_geometry, save_intensity_plots, title, use_mask, write_image_to_disk) :param DataStructure data_structure: The DataStructure object that holds the data to be processed. :param nx.ArraySelectionParameter cell_euler_angles_array_path: Three angles defining the orientation of the Element in Bunge convention (Z-X-Z) :param nx.ArraySelectionParameter cell_phases_array_path: Specifies to which Ensemble each Euler angle belongs :param nx.ArraySelectionParameter crystal_structures_array_path: Enumeration representing the crystal structure for each Ensemble :param nx.ChoicesParameter generation_algorithm_index: The type of pole figure generated. 0=Color, 1=Discrete :param nx.ChoicesParameter image_layout_index: How to layout the 3 pole figures. 0=Horizontal, 1=Vertical, 2=Square :param nx.StringParameter image_prefix: The prefix to apply to each generated pole figure. Each Phase will have its own pole figure. :param nx.Int32Parameter image_size: The number of pixels that define the height and width of **each** output pole figure :param nx.DataGroupCreationParameter intensity_geometry_path: The path to the created Count Image Geometries :param nx.DataObjectNameParameter intensity_plot_1_name: The counts data for the plot :param nx.DataObjectNameParameter intensity_plot_2_name: The counts data for the plot :param nx.DataObjectNameParameter intensity_plot_3_name: The counts data for the plot :param nx.Int32Parameter lambert_size: The height/width of the internal Lambert Square that is used for interpolation :param nx.ArraySelectionParameter mask_array_path: DataPath to the input Mask DataArray :param nx.DataPathSelectionParameter material_name_array_path: DataPath to the input DataArray that holds the material names :param nx.BoolParameter normalize_to_mrd: The Pole Figure data should be normalized to MRD values :param nx.Int32Parameter num_colors: The number of colors to use for the Color Intensity pole figures :param nx.DataGroupCreationParameter output_image_geometry_path: The path to the created Image Geometry :param nx.FileSystemPathParameter output_path: This is the path to the directory where the pole figures will be created. One file for each phase. :param nx.BoolParameter save_as_image_geometry: Save the generated pole figure as an ImageGeometry :param nx.BoolParameter save_intensity_plots: Save the Count Plots (x3) :param nx.StringParameter title: The title to place at the top of the Pole Figure :param nx.BoolParameter use_mask: Should the algorithm use a mask array to remove non-indexed points :param nx.BoolParameter write_image_to_disk: Should the filter write the pole figure plots 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 StatsGenerator ODF Angle File ----------------------------------- .. index:: pair: Filter Human Names; Write StatsGenerator ODF Angle File .. index:: pair: Filter Class Names; WriteStatsGenOdfAngleFileFilter .. _WriteStatsGenOdfAngleFileFilter: .. py:class:: WriteStatsGenOdfAngleFileFilter This **Filter** is used in a workflow where the user would like to generate a synthetic microstructure with an ODF that matches (as closely as possible) an existing experimental data set or other data set that is being mimicked. The basic workflow is the following: `Link to the full online documentation for WriteStatsGenOdfAngleFileFilter `_ Mapping of UI display to python named argument +--------------------------+------------------------------+ | UI Display | Python Named Argument | +==========================+==============================+ | Euler Angles | cell_euler_angles_array_path | +--------------------------+------------------------------+ | Phases | cell_phases_array_path | +--------------------------+------------------------------+ | Convert to Degrees | convert_to_degrees | +--------------------------+------------------------------+ | Delimiter | delimiter_index | +--------------------------+------------------------------+ | Mask Array | mask_array_path | +--------------------------+------------------------------+ | Output File | output_file | +--------------------------+------------------------------+ | Default Sigma | sigma | +--------------------------+------------------------------+ | Only Write Good Elements | use_mask | +--------------------------+------------------------------+ | Default Weight | weight | +--------------------------+------------------------------+ .. py:method:: Execute(data_structure, cell_euler_angles_array_path, cell_phases_array_path, convert_to_degrees, delimiter_index, mask_array_path, output_file, sigma, use_mask, weight) :param DataStructure data_structure: The DataStructure object that holds the data to be processed. :param nx.ArraySelectionParameter cell_euler_angles_array_path: Three angles defining the orientation of the Element in Bunge convention (Z-X-Z) :param nx.ArraySelectionParameter cell_phases_array_path: Specifies to which Ensemble each Element belongs :param nx.BoolParameter convert_to_degrees: Whether to convert the Euler angles from radians to degrees. If the Euler angles are already in degrees, this option will 'convert' the data again, resulting in garbage orientations! :param nx.ChoicesParameter delimiter_index: The delimiter separating the data :param nx.ArraySelectionParameter mask_array_path: Used to define Elements as good or bad. Only required if Only Write Good Elements is checked :param nx.FileSystemPathParameter output_file: The output angles file path :param nx.Int32Parameter sigma: This value will be used for the Sigma column :param nx.BoolParameter use_mask: Whether to only write the Euler angles for those elements denoted as true in the supplied mask array :param nx.Float32Parameter weight: This value will be used for the Weight column :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 `