SimplnxReview Filter API ========================== This is the documentation for all filters included in the SimplnxReview module. These filters can be used by importing the appropriate module. Each filter is contained in the module: .. code:: python import simplnxreview # Instantiate and execute a filter from the module result = simplnxreview.SomeFilterName.execute(...) .. py:module:: SimplnxReview Compute Grouping Densities -------------------------- .. index:: pair: Filter Human Names; Compute Grouping Densities .. index:: pair: Filter Class Names; ComputeGroupingDensityFilter .. _ComputeGroupingDensityFilter: .. py:class:: ComputeGroupingDensityFilter This **Filter** calculates the grouping densities for specific **Parent Features**. This filter is intended to be used for hierarchical reconstructions (i.e., reconstructions involving more than one segmentation; thus, the **Feature**-**Parent Feature** relationship). The **Filter** iterates through all **Features** that belong to each **Parent Feature,** querying each of the **Feature** **Neighbors** to determine if it was checked during grouping. A list of **Checked Features** is kept for each **Parent Feature**. Then, each **Parent Volume** is divided by the corresponding total volume of **Checked Features** to give the **Grouping Densities**. `Link to the full online documentation for ComputeGroupingDensityFilter `_ Mapping of UI display to python named argument +------------------------------+-----------------------------------+ | UI Display | Python Named Argument | +==============================+===================================+ | Checked Features Name | checked_features_name | +------------------------------+-----------------------------------+ | Contiguous Neighbor List | contiguous_neighbor_list_path | +------------------------------+-----------------------------------+ | Find Checked Features | find_checked_features | +------------------------------+-----------------------------------+ | Grouping Densities Name | grouping_densities_name | +------------------------------+-----------------------------------+ | Non-Contiguous Neighbor List | non_contiguous_neighbor_list_path | +------------------------------+-----------------------------------+ | Parent Ids | parent_ids_path | +------------------------------+-----------------------------------+ | Parent Volumes | parent_volumes_path | +------------------------------+-----------------------------------+ | Use Non-Contiguous Neighbors | use_non_contiguous_neighbors | +------------------------------+-----------------------------------+ | Volumes | volumes_path | +------------------------------+-----------------------------------+ .. py:method:: Execute(data_structure, checked_features_name, contiguous_neighbor_list_path, find_checked_features, grouping_densities_name, non_contiguous_neighbor_list_path, parent_ids_path, parent_volumes_path, use_non_contiguous_neighbors, volumes_path) :param DataStructure data_structure: The DataStructure object that holds the data to be processed. :param nx.DataObjectNameParameter checked_features_name: :param nx.NeighborListSelectionParameter contiguous_neighbor_list_path: :param nx.BoolParameter find_checked_features: :param nx.DataObjectNameParameter grouping_densities_name: :param nx.NeighborListSelectionParameter non_contiguous_neighbor_list_path: :param nx.ArraySelectionParameter parent_ids_path: :param nx.ArraySelectionParameter parent_volumes_path: :param nx.BoolParameter use_non_contiguous_neighbors: :param nx.ArraySelectionParameter volumes_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 ` Compute Local Average C-Axis Misalignments ------------------------------------------ .. index:: pair: Filter Human Names; Compute Local Average C-Axis Misalignments .. index:: pair: Filter Class Names; ComputeLocalAverageCAxisMisalignmentsFilter .. _ComputeLocalAverageCAxisMisalignmentsFilter: .. py:class:: ComputeLocalAverageCAxisMisalignmentsFilter This filter finds parent average feature kernel average c-axis misalignment. Alternatively, if the "Calculate Unbiased Local Average C-Axis Misalignment" parameter is TRUE, the parent average sub-boundary misalignment is calculated. `Link to the full online documentation for ComputeLocalAverageCAxisMisalignmentsFilter `_ Mapping of UI display to python named argument +-----------------------------------------------+------------------------------------------+ | UI Display | Python Named Argument | +===============================================+==========================================+ | Average C-Axis Misalignments | avg_c_axis_misalignments_path | +-----------------------------------------------+------------------------------------------+ | C-Axis Misalignment List | c_axis_misalignment_list_path | +-----------------------------------------------+------------------------------------------+ | Calculate Local C-Axis Misalignments | calc_biased_avg | +-----------------------------------------------+------------------------------------------+ | Calculate Unbiased Local C-Axis Misalignments | calc_unbiased_avg | +-----------------------------------------------+------------------------------------------+ | Feature Parent Ids | feature_parent_ids_path | +-----------------------------------------------+------------------------------------------+ | Local C-Axis Misalignments Array Name | local_c_axis_misalignments_name | +-----------------------------------------------+------------------------------------------+ | Neighbor List | neighbor_list_path | +-----------------------------------------------+------------------------------------------+ | New Cell Feature Attribute Matrix Name | new_cell_feature_attribute_matrix_path | +-----------------------------------------------+------------------------------------------+ | Number of Features Per Parent Array Name | num_features_per_parent_name | +-----------------------------------------------+------------------------------------------+ | Unbiased Local CAxis Misalignments Array Name | unbiased_local_c_axis_misalignments_name | +-----------------------------------------------+------------------------------------------+ .. py:method:: Execute(data_structure, avg_c_axis_misalignments_path, c_axis_misalignment_list_path, calc_biased_avg, calc_unbiased_avg, feature_parent_ids_path, local_c_axis_misalignments_name, neighbor_list_path, new_cell_feature_attribute_matrix_path, num_features_per_parent_name, unbiased_local_c_axis_misalignments_name) :param DataStructure data_structure: The DataStructure object that holds the data to be processed. :param nx.ArraySelectionParameter avg_c_axis_misalignments_path: :param nx.NeighborListSelectionParameter c_axis_misalignment_list_path: :param nx.BoolParameter calc_biased_avg: :param nx.BoolParameter calc_unbiased_avg: :param nx.ArraySelectionParameter feature_parent_ids_path: :param nx.DataObjectNameParameter local_c_axis_misalignments_name: :param nx.NeighborListSelectionParameter neighbor_list_path: :param nx.DataGroupSelectionParameter new_cell_feature_attribute_matrix_path: :param nx.DataObjectNameParameter num_features_per_parent_name: :param nx.DataObjectNameParameter unbiased_local_c_axis_misalignments_name: :return: Returns a :ref:`nx.IFilter.ExecuteResult ` object that holds any warnings and/or errors that were encountered during execution. :rtype: :ref:`nx.IFilter.ExecuteResult ` Compute MicroTexture Regions ---------------------------- .. index:: pair: Filter Human Names; Compute MicroTexture Regions .. index:: pair: Filter Class Names; ComputeMicroTextureRegionsFilter .. _ComputeMicroTextureRegionsFilter: .. py:class:: ComputeMicroTextureRegionsFilter This filter does the following... `Link to the full online documentation for ComputeMicroTextureRegionsFilter `_ Mapping of UI display to python named argument +---------------------------------------------------+---------------------------------------------------+ | UI Display | Python Named Argument | +===================================================+===================================================+ | Parent Cell Feature Attribute Matrix | cell_feature_attribute_matrix_path | +---------------------------------------------------+---------------------------------------------------+ | Cell Feature Ids | feature_ids_array_path | +---------------------------------------------------+---------------------------------------------------+ | Selected Image Geometry | image_geom_path | +---------------------------------------------------+---------------------------------------------------+ | Micro Texture Region Fraction Occupied Array Name | micro_texture_region_fraction_occupied_array_name | +---------------------------------------------------+---------------------------------------------------+ | Micro Texture Region Number of Cells Array Name | micro_texture_region_num_cells_array_name | +---------------------------------------------------+---------------------------------------------------+ .. py:method:: Execute(data_structure, cell_feature_attribute_matrix_path, feature_ids_array_path, image_geom_path, micro_texture_region_fraction_occupied_array_name, micro_texture_region_num_cells_array_name) :param DataStructure data_structure: The DataStructure object that holds the data to be processed. :param nx.DataGroupSelectionParameter cell_feature_attribute_matrix_path: :param nx.ArraySelectionParameter feature_ids_array_path: :param nx.GeometrySelectionParameter image_geom_path: :param nx.DataObjectNameParameter micro_texture_region_fraction_occupied_array_name: :param nx.DataObjectNameParameter micro_texture_region_num_cells_array_name: :return: Returns a :ref:`nx.IFilter.ExecuteResult ` object that holds any warnings and/or errors that were encountered during execution. :rtype: :ref:`nx.IFilter.ExecuteResult ` Compute Feature Saltykov Sizes ------------------------------ .. index:: pair: Filter Human Names; Compute Feature Saltykov Sizes .. index:: pair: Filter Class Names; ComputeSaltykovSizesFilter .. _ComputeSaltykovSizesFilter: .. py:class:: ComputeSaltykovSizesFilter This filter calculates the Saltykov sizes of all **Features**. The filter takes the **EquavalentDiameters**, of assumed 2D data, and estimates the 3D equivalent diameters.The filter will continue iteratively performing the Saltykov Method of spheres, starting with an initial guess of 10 size bins, until the number of features equals the number of Saltykov equivalent diameters to be sampled. If the number of **Features** to be sampled from the Saltykov bins is not equal to the number of **Features** then the difference between the two is calculated. Then, the number of attempts is incremented and the number of bins is increased/decreased based on the "difference" and the bin arrays are resized accordingly. This approach allows for the correct number of **Features** to result because increasing the number of bins increases the number of **SaltykovEquavalentDiameters** to be sampled and decreasing the number of bins does the opposite. However, if the number of maximum attempts, hardcoded at 10, is reached, random Saltykov bins are selected to add samples to until the the number of **SaltykovEquavalentDiameters** to be sampled equals the number of **Features**. This is done because it is assumed that after 10 attempts the solution is ocsillating between the minima.The filter is applied in such a way so that **SaltykovEquivalentDiameters** has the correct feature-level data length. This way, a direct one-to-one comparies between **EquivalentDiameters** and **SaltykovEquivalentDiameters** is possible. However, it is important to note that the **SaltykovEquivalentDiameters** are not a direct transformation of **EquivalentDiameters** that they are matched up with.For more information, see: Joseph C. Tucker, Lisa H. Chan, Gregory S. Rohrer, Michael A. Groeber, and Anthony D. Rollett. Comparison of grain size distributions in a ni-based superalloy in three and two dimensions using the saltykov method. Scripta Materialia, 66(8):554 - 557, 2012. `Link to the full online documentation for ComputeSaltykovSizesFilter `_ Mapping of UI display to python named argument +------------------------------------+------------------------------------+ | UI Display | Python Named Argument | +====================================+====================================+ | Equivalent Diameters | equivalent_diameters_array_path | +------------------------------------+------------------------------------+ | Saltykov Equivalent Diameters Name | saltykov_equivalent_diameters_name | +------------------------------------+------------------------------------+ | Seed | seed_value | +------------------------------------+------------------------------------+ | Use Seed for Random Generation | use_seed | +------------------------------------+------------------------------------+ .. py:method:: Execute(data_structure, equivalent_diameters_array_path, saltykov_equivalent_diameters_name, seed_value, use_seed) :param DataStructure data_structure: The DataStructure object that holds the data to be processed. :param nx.ArraySelectionParameter equivalent_diameters_array_path: :param nx.DataObjectNameParameter saltykov_equivalent_diameters_name: :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 ` Group MicroTexture Regions -------------------------- .. index:: pair: Filter Human Names; Group MicroTexture Regions .. index:: pair: Filter Class Names; GroupMicroTextureRegionsFilter .. _GroupMicroTextureRegionsFilter: .. py:class:: GroupMicroTextureRegionsFilter This Filter groups neighboring **Features** that have c-axes aligned within a user defined tolerance. The algorithm for grouping the **Features** is analogous to the algorithm for segmenting the **Features** - only the average orientation of the **Features** are used instead of the orientations of the individual **Cells** and the criterion for grouping only considers the alignment of the c-axes. The user can specify a tolerance for how closely aligned the c-axes must be for neighbor **Features** to be grouped. `Link to the full online documentation for GroupMicroTextureRegionsFilter `_ Mapping of UI display to python named argument +--------------------------------------+-----------------------------------------+ | UI Display | Python Named Argument | +======================================+=========================================+ | Active Array Name | active_array_name | +--------------------------------------+-----------------------------------------+ | Average Quaternions | avg_quats_array_path | +--------------------------------------+-----------------------------------------+ | C-Axis Alignment Tolerance (Degrees) | c_axis_tolerance | +--------------------------------------+-----------------------------------------+ | Cell Parent Ids Array name | cell_parent_ids_array_name | +--------------------------------------+-----------------------------------------+ | Contiguous Neighbor List | contiguous_neighbor_list_array_path | +--------------------------------------+-----------------------------------------+ | Crystal Structures | crystal_structures_array_path | +--------------------------------------+-----------------------------------------+ | Cell Feature Ids | feature_ids_array_path | +--------------------------------------+-----------------------------------------+ | Feature Parent Ids Array Name | feature_parent_ids_array_name | +--------------------------------------+-----------------------------------------+ | Feature Phases | feature_phases_array_path | +--------------------------------------+-----------------------------------------+ | New Cell Feature Attribute Matrix | new_cell_feature_attribute_matrix_path | +--------------------------------------+-----------------------------------------+ | Non-Contiguous Neighbor List | non_contiguous_neighbor_list_array_path | +--------------------------------------+-----------------------------------------+ | Stored Seed Value Array Name | seed_array_name | +--------------------------------------+-----------------------------------------+ | Seed | seed_value | +--------------------------------------+-----------------------------------------+ | Use Non-Contiguous Neighbors | use_non_contiguous_neighbors | +--------------------------------------+-----------------------------------------+ | Group C-Axes With Running Average | use_running_average | +--------------------------------------+-----------------------------------------+ | Use Seed for Random Generation | use_seed | +--------------------------------------+-----------------------------------------+ | Volumes | volumes_array_path | +--------------------------------------+-----------------------------------------+ .. py:method:: Execute(data_structure, active_array_name, avg_quats_array_path, c_axis_tolerance, cell_parent_ids_array_name, contiguous_neighbor_list_array_path, crystal_structures_array_path, feature_ids_array_path, feature_parent_ids_array_name, feature_phases_array_path, new_cell_feature_attribute_matrix_path, non_contiguous_neighbor_list_array_path, seed_array_name, seed_value, use_non_contiguous_neighbors, use_running_average, use_seed, volumes_array_path) :param DataStructure data_structure: The DataStructure object that holds the data to be processed. :param nx.DataObjectNameParameter active_array_name: :param nx.ArraySelectionParameter avg_quats_array_path: Specifies the average orientation of each Feature in quaternion representation :param nx.Float32Parameter c_axis_tolerance: :param nx.DataObjectNameParameter cell_parent_ids_array_name: :param nx.NeighborListSelectionParameter contiguous_neighbor_list_array_path: List of contiguous neighbors for each Feature. :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.DataObjectNameParameter feature_parent_ids_array_name: :param nx.ArraySelectionParameter feature_phases_array_path: Specifies to which Ensemble each Feature belongs :param nx.DataGroupCreationParameter new_cell_feature_attribute_matrix_path: :param nx.NeighborListSelectionParameter non_contiguous_neighbor_list_array_path: List of non-contiguous neighbors for each Feature. :param nx.DataObjectNameParameter seed_array_name: :param nx.UInt64Parameter seed_value: The seed fed into the random generator :param nx.BoolParameter use_non_contiguous_neighbors: :param nx.BoolParameter use_running_average: :param nx.BoolParameter use_seed: When true the user will be able to put in a seed for random generation :param nx.ArraySelectionParameter volumes_array_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 ` Interpolate Values To Unstructured Grid --------------------------------------- .. index:: pair: Filter Human Names; Interpolate Values To Unstructured Grid .. index:: pair: Filter Class Names; InterpolateValuesToUnstructuredGridFilter .. _InterpolateValuesToUnstructuredGridFilter: .. py:class:: InterpolateValuesToUnstructuredGridFilter This filter will sample a point cloud's data onto a target unstructured grid (Vertex, Edge, Triangle, Quad, Hex, Tet Geometry) via a nearest neighbor algorithm. `Link to the full online documentation for InterpolateValuesToUnstructuredGridFilter `_ Mapping of UI display to python named argument +------------------------------------+---------------------------+ | UI Display | Python Named Argument | +====================================+===========================+ | Created Vertex Attribute Matrix | created_attr_matrix_name | +------------------------------------+---------------------------+ | Interpolated Node-Based Geometry | destination_geometry_path | +------------------------------------+---------------------------+ | Vertex Attribute Matrix | existing_attr_matrix_path | +------------------------------------+---------------------------+ | Attribute Arrays to Interpolate | interpolated_array_paths | +------------------------------------+---------------------------+ | Node-Based Geometry To Interpolate | source_geometry_path | +------------------------------------+---------------------------+ | Use Existing Attribute Matrix | use_existing_attr_matrix | +------------------------------------+---------------------------+ .. py:method:: Execute(data_structure, created_attr_matrix_name, destination_geometry_path, existing_attr_matrix_path, interpolated_array_paths, source_geometry_path, use_existing_attr_matrix) :param DataStructure data_structure: The DataStructure object that holds the data to be processed. :param nx.DataObjectNameParameter created_attr_matrix_name: DataPath to created AttributeMatrix for interpolated data :param nx.GeometrySelectionParameter destination_geometry_path: DataPath to node-based interpolated geometry :param nx.AttributeMatrixSelectionParameter existing_attr_matrix_path: Vertex attribute matrix to store the interpolated data :param nx.MultiArraySelectionParameter interpolated_array_paths: DataPaths to interpolate :param nx.GeometrySelectionParameter source_geometry_path: DataPath to node-based geometry to interpolate :param nx.BoolParameter use_existing_attr_matrix: Use an existing attribute matrix to store the interpolated arrays. :return: Returns a :ref:`nx.IFilter.ExecuteResult ` object that holds any warnings and/or errors that were encountered during execution. :rtype: :ref:`nx.IFilter.ExecuteResult ` Merge Colonies -------------- .. index:: pair: Filter Human Names; Merge Colonies .. index:: pair: Filter Class Names; MergeColoniesFilter .. _MergeColoniesFilter: .. py:class:: MergeColoniesFilter This **Filter** groups neighboring **Features** that have a *special* misorientation that is associated with *alpha* variants that transformed from the same *beta* grain in titanium. The algorithm for grouping the **Features** is analogous to the algorithm for segmenting the **Features**, except the average orientation of the **Features** are used instead of the orientations of the individual **Elements** and the criterion for grouping is specific to the *alpha-beta transformation*. The user can specify a tolerance on both the *axis* and the *angle* that defines the misorientation relationship (i.e., a tolerance of 1 degree for both tolerances would allow the neighboring **Features** to be grouped if their misorientation was between 59-61 degrees about an axis within 1 degree of a2, as given by the 3rd *special* misorientation below). `Link to the full online documentation for MergeColoniesFilter `_ 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 | +--------------------------------+-----------------------------------------+ | Cell Parent Ids | cell_parent_ids_array_name | +--------------------------------+-----------------------------------------+ | Cell Phases | cell_phases_array_path | +--------------------------------+-----------------------------------------+ | Contiguous Neighbor List | contiguous_neighbor_list_array_path | +--------------------------------+-----------------------------------------+ | Crystal Structures | crystal_structures_array_path | +--------------------------------+-----------------------------------------+ | Cell Feature Ids | feature_ids_array_path | +--------------------------------+-----------------------------------------+ | Feature Parent Ids | feature_parent_ids_array_name | +--------------------------------+-----------------------------------------+ | Feature Phases | feature_phases_array_path | +--------------------------------+-----------------------------------------+ | Feature Attribute Matrix | new_cell_feature_attribute_matrix_path | +--------------------------------+-----------------------------------------+ | Non-Contiguous Neighbor List | non_contiguous_neighbor_list_array_path | +--------------------------------+-----------------------------------------+ | Seed | seed_value | +--------------------------------+-----------------------------------------+ | Use Non-Contiguous Neighbors | use_non_contiguous_neighbors | +--------------------------------+-----------------------------------------+ | 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, cell_phases_array_path, contiguous_neighbor_list_array_path, crystal_structures_array_path, feature_ids_array_path, feature_parent_ids_array_name, feature_phases_array_path, new_cell_feature_attribute_matrix_path, non_contiguous_neighbor_list_array_path, seed_value, use_non_contiguous_neighbors, use_seed) :param DataStructure data_structure: The DataStructure object that holds the data to be processed. :param nx.DataObjectNameParameter active_array_name: :param nx.Float32Parameter angle_tolerance: :param nx.ArraySelectionParameter avg_quats_array_path: :param nx.Float32Parameter axis_tolerance: :param nx.DataObjectNameParameter cell_parent_ids_array_name: :param nx.ArraySelectionParameter cell_phases_array_path: :param nx.NeighborListSelectionParameter contiguous_neighbor_list_array_path: :param nx.ArraySelectionParameter crystal_structures_array_path: :param nx.ArraySelectionParameter feature_ids_array_path: :param nx.DataObjectNameParameter feature_parent_ids_array_name: :param nx.ArraySelectionParameter feature_phases_array_path: :param nx.DataGroupCreationParameter new_cell_feature_attribute_matrix_path: :param nx.NeighborListSelectionParameter non_contiguous_neighbor_list_array_path: :param nx.UInt64Parameter seed_value: The seed fed into the random generator :param nx.BoolParameter use_non_contiguous_neighbors: :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 ` Read Zeiss TXM/TXRM Files ------------------------- .. index:: pair: Filter Human Names; Read Zeiss TXM/TXRM Files .. index:: pair: Filter Class Names; ReadZeissTxmFileFilter .. _ReadZeissTxmFileFilter: .. py:class:: ReadZeissTxmFileFilter This filter will read the entire volume or optionally a subvolume from a .txm or .txrm file. These filesare Zeiss xCT reconstrucion files. `Link to the full online documentation for ReadZeissTxmFileFilter `_ Mapping of UI display to python named argument +-----------------------+----------------------------+ | UI Display | Python Named Argument | +=======================+============================+ | Cell Attribute Matrix | cell_attribute_matrix_name | +-----------------------+----------------------------+ | CT Data | ct_data_array_name | +-----------------------+----------------------------+ | Zeiss TXM/TXRM File | input_file_path | +-----------------------+----------------------------+ | Image Geometry | output_image_geometry_path | +-----------------------+----------------------------+ | Slice End (inclusive) | sub_volume_end_slice | +-----------------------+----------------------------+ | Slice Start | sub_volume_start_slice | +-----------------------+----------------------------+ | Use Z Sub-volume | use_sub_volume | +-----------------------+----------------------------+ .. py:method:: Execute(data_structure, cell_attribute_matrix_name, ct_data_array_name, input_file_path, output_image_geometry_path, sub_volume_end_slice, sub_volume_start_slice, use_sub_volume) :param DataStructure data_structure: The DataStructure object that holds the data to be processed. :param nx.DataObjectNameParameter cell_attribute_matrix_name: The attribute matrix created as a child of the image geometry :param nx.DataObjectNameParameter ct_data_array_name: The data array created as a child of the attribute matrix :param nx.FileSystemPathParameter input_file_path: The input Zeiss TXM/TXRM file :param nx.DataGroupCreationParameter output_image_geometry_path: Path to create the Image Geometry :param nx.UInt32Parameter sub_volume_end_slice: The ending slice to import (inclusive) :param nx.UInt32Parameter sub_volume_start_slice: The starting slice to import :param nx.BoolParameter use_sub_volume: Only import a sub-set of the slices :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 `