Batch 6: 21 data manipulation filter docs reviewed

Tier 2 (10 filters): CreateAttributeMatrix, CreateDataGroup, DeleteData,
RenameDataObject, MoveData, CopyFeatureArrayToElementArray,
CreateFeatureArrayFromElementArray, ConditionalSetValue,
ConvertColorToGrayScale, ReshapeDataArray.

Tier 3 (11 filters): CreateDataArray, CreateDataArrayAdvanced,
CopyDataObject, CombineAttributeArrays, ConcatenateDataArrays,
SplitDataArrayByComponent, SplitDataArrayByTuple,
ExtractComponentAsArray, ConvertData, ArrayCalculator, InitializeData.

Notable structural changes:
- CreateAttributeMatrix and CreateDataGroup: added 'What is X?' sections
  with explicit guidance on when to choose one over the other.
- DeleteData: documented cascade-delete behavior across container types.
- RenameDataObject: warning about downstream parameter references.
- MoveData: explained tuple-count vs tuple-shape compatibility.
- CreateFeatureArrayFromElementArray: promoted 'last element copied'
  footgun to a Warning section; cross-linked ComputeArrayStatistics.
- ConditionalSetValue: split the two modes (mask vs value-match) into
  their own subsections.
- ReshapeDataArray: critical 'does not move data in memory' warning
  promoted to top-level with safe-vs-dangerous examples.
- InitializeData: restructured from rambly bullets into clean
  per-mode subsections.

Build verified clean (no new Sphinx warnings).

Author: imikejackson

docs/documentation_review_tracker.md

@@ -15,7 +15,7 @@
 | 3 | Segmentation / Feature Identification | 10 | 10 | 10 | Complete |
 | 4 | Neighbor / Kernel Operations | 11 | 11 | 11 | Complete |
 | 5 | Geometry Creation / Manipulation | 15 | 15 | 15 | Complete |
-| 6 | Data Manipulation (Copy, Create, Delete, Rename) | 21 | 21 | 0 | Triaged |
+| 6 | Data Manipulation (Copy, Create, Delete, Rename) | 21 | 21 | 21 | Complete |
 | 7 | I/O Filters (Read/Write) | ~15 | 0 | 0 | Not Started |
 | 8 | Image Processing (ITK wrappers) | ~88 | 0 | 0 | Not Started |
 | 9 | Remaining SimplnxCore filters | ~varies | 0 | 0 | Not Started |
@@ -451,16 +451,16 @@ None. No filter in this batch is incomprehensible to a non-expert.
 
 | Filter | Plugin | Status |
 |--------|--------|--------|
-| CreateAttributeMatrix | SimplnxCore | Pending |
-| CreateDataGroup | SimplnxCore | Pending |
-| DeleteData | SimplnxCore | Pending |
-| RenameDataObject | SimplnxCore | Pending |
-| MoveData | SimplnxCore | Pending |
-| CopyFeatureArrayToElementArray | SimplnxCore | Pending |
-| CreateFeatureArrayFromElementArray | SimplnxCore | Pending |
-| ConditionalSetValue | SimplnxCore | Pending |
-| ConvertColorToGrayScale | SimplnxCore | Pending |
-| ReshapeDataArray | SimplnxCore | Pending |
+| CreateAttributeMatrix | SimplnxCore | Done |
+| CreateDataGroup | SimplnxCore | Done |
+| DeleteData | SimplnxCore | Done |
+| RenameDataObject | SimplnxCore | Done |
+| MoveData | SimplnxCore | Done |
+| CopyFeatureArrayToElementArray | SimplnxCore | Done |
+| CreateFeatureArrayFromElementArray | SimplnxCore | Done |
+| ConditionalSetValue | SimplnxCore | Done |
+| ConvertColorToGrayScale | SimplnxCore | Done |
+| ReshapeDataArray | SimplnxCore | Done |
 
 - [ ] **CreateAttributeMatrixFilter** (SimplnxCore)
   - **Clarity:** Extremely brief (only ~20 lines). Lone example does not explain what an Attribute Matrix conceptually represents.
@@ -523,17 +523,17 @@ None. No filter in this batch is incomprehensible to a non-expert.
 
 | Filter | Plugin | Status |
 |--------|--------|--------|
-| CreateDataArray | SimplnxCore | Pending |
-| CreateDataArrayAdvanced | SimplnxCore | Pending |
-| CopyDataObject | SimplnxCore | Pending |
-| CombineAttributeArrays | SimplnxCore | Pending |
-| ConcatenateDataArrays | SimplnxCore | Pending |
-| SplitDataArrayByComponent | SimplnxCore | Pending |
-| SplitDataArrayByTuple | SimplnxCore | Pending |
-| ExtractComponentAsArray | SimplnxCore | Pending |
-| ConvertData | SimplnxCore | Pending |
-| ArrayCalculator | SimplnxCore | Pending |
-| InitializeData | SimplnxCore | Pending |
+| CreateDataArray | SimplnxCore | Done |
+| CreateDataArrayAdvanced | SimplnxCore | Done |
+| CopyDataObject | SimplnxCore | Done |
+| CombineAttributeArrays | SimplnxCore | Done |
+| ConcatenateDataArrays | SimplnxCore | Done |
+| SplitDataArrayByComponent | SimplnxCore | Done |
+| SplitDataArrayByTuple | SimplnxCore | Done |
+| ExtractComponentAsArray | SimplnxCore | Done |
+| ConvertData | SimplnxCore | Done |
+| ArrayCalculator | SimplnxCore | Done |
+| InitializeData | SimplnxCore | Done |
 
 - [ ] **CreateDataArrayFilter** (SimplnxCore)
   - **Notes:** Already has good data-type ranges table and semicolon-notation example. Minor polish: state that Number of Components must be ≥ 1; explicitly note that this filter creates a *single component dimension* (use CreateDataArrayAdvanced for multi-dimension components). Add Required Input Sources (none).

src/Plugins/SimplnxCore/docs/ArrayCalculatorFilter.md

@@ -135,6 +135,11 @@ This equation takes the cube root of *8* and stores the result in an array with
 
 This equation raises *3* to the power of the value stored in every component of every tuple in *Array1*.  The resulting array has the same tuple and component size of *Array1*.
 
+### Required Input Sources
+
+- **Source Attribute Matrix** -- the Attribute Matrix that contains the input arrays referenced in the *Infix Expression*.
+- **Output Attribute Matrix** -- an existing Attribute Matrix with the matching tuple count (or with exactly one tuple, when the expression contains no arrays).
+
 % Auto generated parameter table will be inserted here
 
 ## Example Pipelines

src/Plugins/SimplnxCore/docs/CombineAttributeArraysFilter.md

@@ -32,6 +32,12 @@ The user may also select to normalize the resulting combined array. The normaliz
 
 **NOTE:** If you are wanting to instead concatenate/append data arrays together into a longer array, please see the [Concatenate Data Arrays](ConcatenateDataArraysFilter.md) filter.
 
+A typical use case is building a multi-component coordinate or quaternion array from three or four separate single-component scalar arrays (e.g., combining `X_Coord`, `Y_Coord`, `Z_Coord` into a single 3-component `Vertices` array before passing to [Create Geometry](CreateGeometryFilter.md)).
+
+### Required Input Sources
+
+- **Input Attribute Arrays** -- two or more arrays of the same primitive type and tuple count, in the order you want their components to appear in the combined array.
+
 % Auto generated parameter table will be inserted here
 
 ## Example Pipelines

src/Plugins/SimplnxCore/docs/ConcatenateDataArraysFilter.md

@@ -14,6 +14,12 @@ This filter is designed to handle arrays of matching array types and component d
 
 **NOTE:** If you are wanting to instead combine data arrays into a multi-component array, please see the [Combine Attribute Arrays](CombineAttributeArraysFilter.md) filter.
 
+For example, given two 3-component float arrays of 5 and 7 tuples respectively, the output is a 3-component float array of 12 tuples whose first 5 tuples are the first input and last 7 tuples are the second input.
+
+### Required Input Sources
+
+- **Input Data Arrays** -- two or more arrays sharing the same primitive type and the same component dimensions.
+
 % Auto generated parameter table will be inserted here
 
 ## Example Pipelines

src/Plugins/SimplnxCore/docs/ConditionalSetValueFilter.md

@@ -6,23 +6,42 @@ Core (Misc)
 
 ## Description
 
-This **Filter** replaces values in a user specified **Attribute Array** with a user specified value a second boolean **Attribute Array** specifies, but only when **Use Conditional Mask** is *true*. For example, if the user entered a *Replace Value* of *5.5*, then for every occurence of *true* in the conditional boolean array, the selected **Attribute Array** would be changed to 5.5. If **Use Conditional Mask** is *false*, then **Value to Replace** will be searched for in the provided **Attribute Array** and all instances will be replaced. Below are the ranges for the values that can be entered for the different primitive types of arrays (for user reference). The selected **Attribute Array** must be a scalar array.
-
-### Primitive Data Types
-
-| Type             | Size |        Range       |
-|------------------|------|--------------------|
-| Signed Integer | 8 bit |-128 to 127|
-| Unsigned Integer | 8 bit |0 to 255|
-| Signed Integer | 16 bit |-32,768 to 32,767|
-| Unsigned Integer | 16 bit |0 to 65,535|
-| Signed Integer | 32 bit |-2,147,483,648 to 2,147,483,647|
-| Unsigned Integer | 32 bit |0 to 4,294,967,295|
-| Signed Integer | 64 bit |   9,223,372,036,854,775,808 to 9,223,372,036,854,775,807|
-| Unsigned Integer | 64 bit |0 to 18,446,744,073,709,551,615|
-| Float | 32 bit | -3.4e+38 to -1.1e-38, 0.0, 1.1e-38 to 3.4e+38 (7 digits)|
-| Double | 64 bit | -1.7e+308 to -2.2e-308, 0.0, 2.2e-308 to 1.7e+308 (15 digits)|
-| Boolean | 8 bit |0 = false and any other value will be forced to 1 = true|
+This **Filter** replaces selected values in a scalar **Attribute Array** with a user-specified value. The filter operates in one of two modes selected by the *Use Conditional Mask* parameter.
+
+### Mode 1 -- Conditional Mask (Use Conditional Mask = ON)
+
+A second boolean array (the *Conditional Mask*) of the same length picks which tuples to overwrite. Every tuple where the mask is *true* has its scalar value set to *Replace Value*; tuples where the mask is *false* are unchanged.
+
+Typical use case: replace cell values flagged by an upstream threshold (e.g., set all "bad" cells to 0).
+
+### Mode 2 -- Value Match (Use Conditional Mask = OFF)
+
+Every occurrence of *Value to Replace* in the target array is replaced with *Replace Value*. The Conditional Mask parameter is ignored.
+
+Typical use case: remap a specific sentinel value (e.g., turn every -1 into 0).
+
+### Numeric Type Compatibility
+
+The target array must be a **scalar** (single-component) array. *Replace Value* (and *Value to Replace* in Mode 2) are reinterpreted as the array's data type. The valid range for each primitive type:
+
+| Type | Size | Range |
+|------|------|-------|
+| Signed Integer | 8 bit | -128 to 127 |
+| Unsigned Integer | 8 bit | 0 to 255 |
+| Signed Integer | 16 bit | -32,768 to 32,767 |
+| Unsigned Integer | 16 bit | 0 to 65,535 |
+| Signed Integer | 32 bit | -2,147,483,648 to 2,147,483,647 |
+| Unsigned Integer | 32 bit | 0 to 4,294,967,295 |
+| Signed Integer | 64 bit | -9.2e18 to 9.2e18 |
+| Unsigned Integer | 64 bit | 0 to 1.8e19 |
+| Float | 32 bit | ±1.1e-38 to ±3.4e+38 (7 digits) |
+| Double | 64 bit | ±2.2e-308 to ±1.7e+308 (15 digits) |
+| Boolean | 8 bit | 0 = false, non-zero = true |
+
+### Required Input Sources
+
+- **Target Array** -- the scalar cell-level (or other tuple-level) array whose values will be overwritten.
+- **Conditional Mask** (only when *Use Conditional Mask* is enabled) -- a boolean array with the same number of tuples; typically produced by [Multi-Threshold Objects](MultiThresholdObjectsFilter.md).
 
 % Auto generated parameter table will be inserted here
 

src/Plugins/SimplnxCore/docs/ConvertColorToGrayScaleFilter.md

@@ -6,25 +6,34 @@ Processing (Image)
 
 ## Description
 
-This **Filter** allows the user to select a *flattening* method for turning an array of RGB or RGBa values into grayscale values.
+This **Filter** converts one or more color image arrays (3-component RGB or 4-component RGBA, uint8) into single-component grayscale image arrays using one of four standard flattening algorithms. Use this filter as a preprocessing step before any image-processing filter that expects single-channel intensity data.
 
 ### Conversion Algorithm
 
-The *Conversion Algorithm* parameter provides the following choices:
+The *Conversion Algorithm* parameter selects how the three (or four) color channels are combined into a single value:
 
-- **Luminosity [0]**: A weighted average of RGB channels that accounts for human perception (more sensitive to green). Uses the BT709 formula by default: Red: 0.2125, Green: 0.7154, Blue: 0.0721. The user can set custom weightings.
-- **Average [1]**: Computes a simple arithmetic average of R, G, and B channel values: (R + G + B) / 3.
-- **Lightness [2]**: Averages the maximum and minimum channel values: (max(R, G, B) + min(R, G, B)) / 2.
-- **SingleChannel [3]**: The user selects a specific R, G, or B channel to use directly as the grayscale values.
+- **Luminosity [0]**: weighted average accounting for human perception (more sensitive to green). Default weights are the BT.709 standard: R=0.2125, G=0.7154, B=0.0721. The user may supply custom weights.
+- **Average [1]**: simple arithmetic mean of the three channels: (R + G + B) / 3.
+- **Lightness [2]**: average of the maximum and minimum channel values: (max(R, G, B) + min(R, G, B)) / 2.
+- **SingleChannel [3]**: the user picks one channel (R, G, or B) and that channel's value is used directly.
 
-The user can select 1 or more image data arrays which are assumed to be multi-component arrays of unsigned 8 bit values. The user can create a new AttributeMatrix if they want to store all the newly created arrays in a separate AttributeMatrix.
+### Additional Standard Weights
 
-### Additional GrayScale Conversions
+Other widely-used weighting schemes (not built-in, but easy to supply as custom Luminosity weights):
 
-The following are some additional accepted grayscale conversions
+- **RMY Greyscale**: R=0.500, G=0.419, B=0.081
+- **YIQ / NTSC**: R=0.299, G=0.587, B=0.114
 
-+ RMY Greyscale: Red: 0.5 Green: 0.419 Blue: 0.081
-+ (YIQ/NTSC): Red: 0.299 Green: 0.587 Blue: 0.114
+### Input/Output Format
+
+- **Input arrays** must be uint8 with 3 components (RGB) or 4 components (RGBA). With RGBA input, the alpha channel is ignored.
+- **Output arrays** are single-component uint8.
+
+Multiple input arrays can be processed in one filter pass; each produces its own output array. If *Output to New Attribute Matrix* is enabled, the new arrays are placed in a separate Attribute Matrix to keep them organized; otherwise they live alongside the originals.
+
+### Required Input Sources
+
+- **Input Image Arrays** -- 3- or 4-component uint8 arrays, typically produced by [ITK Import Image Stack](../ITKImageProcessing/ITKImportImageStackFilter.md) or another color-image reader.
 
 % Auto generated parameter table will be inserted here
 

src/Plugins/SimplnxCore/docs/ConvertDataFilter.md

@@ -40,6 +40,15 @@ Down casting can have undefined behavior depending on the primitive types involv
 
 When converting data from signed values to unsigned values or vice-versa, there can also be undefined behavior. For example, if the user were to convert a signed 4 byte integer array to an unsigned 4 byte integer array and the input array has negative values, then the conversion rules are undefined and may differ from operating system to operating system.
 
+### Related Filters
+
+- [Reshape Data Array](ReshapeDataArrayFilter.md) -- changes the tuple-dimensions interpretation of an array without converting its underlying data type. Use Reshape (not Convert) when you want to interpret existing bytes under a different shape.
+- [Create Data Array](CreateDataArrayFilter.md) -- create a fresh array of the desired type and copy values into it manually.
+
+### Required Input Sources
+
+- **Input Array** -- the **Data Array** whose values will be cast to the new type.
+
 % Auto generated parameter table will be inserted here
 
 ## Example Pipelines

src/Plugins/SimplnxCore/docs/CopyDataObjectFilter.md

@@ -19,7 +19,12 @@ Commonly used _BaseGroup_ children:
 
 See the DataStructure section of the reference manual for a complete hierarchy.
 
-When the _Copy to New Parent_ is toggled true a new parameter will appear. This parameter, _Copied Parent Group_, allows for the selected arrays to all be copied into whatever data container you place here.
+When *Copy to New Parent* is toggled on, a new parameter appears. This parameter, *Copied Parent Group*, lets the selected objects be copied into a different parent **DataGroup**, **Attribute Matrix**, or **Geometry** rather than alongside their originals.
+
+### Required Input Sources
+
+- **Objects to Copy** -- one or more existing **DataObjects** in the Data Structure.
+- **Copied Parent Group** (only when *Copy to New Parent* is enabled) -- an existing parent container where the copies will be placed.
 
 % Auto generated parameter table will be inserted here
 

src/Plugins/SimplnxCore/docs/CopyFeatureArrayToElementArrayFilter.md

@@ -6,7 +6,19 @@ Core (Memory/Management)
 
 ## Description
 
-This **Filter** copies the values associated with a **Feature** to all the **Elements** that belong to that **Feature**.  Xmdf visualization files write only the **Element** attributes, so if the user wants to display a spatial map of a **Feature** level attribute, this **Filter** will transfer that information down to the **Element** level.
+This **Filter** broadcasts a per-**Feature** value to every **Cell** (element) that belongs to that Feature, producing a new cell-level **Data Array** that has the same length as the Feature Ids array. Each cell receives the value of the Feature it belongs to.
+
+### When to Use This Filter
+
+- **Visualization.** Most exporters (Xdmf, VTK, ParaView state files) treat Cell-level arrays as the natural per-voxel scalar to render. Broadcasting a per-grain statistic (size, average misorientation, Schmid factor, biased flag, etc.) down to the Cell level produces a colorable map of that quantity.
+- **Downstream filtering on cells.** When you want to threshold cells based on a Feature-level criterion (e.g., "keep cells whose parent grain is unbiased"), it is simpler to broadcast the Feature flag to all cells and then apply a cell-level threshold.
+
+The output is always the same data type and component shape as the source Feature array.
+
+### Required Input Sources
+
+- **Feature Array to Copy** -- any feature-level array; common sources include [Compute Feature Sizes](ComputeFeatureSizesFilter.md), [Compute Average Orientations](../OrientationAnalysis/ComputeAvgOrientationsFilter.md), [Compute Schmid Factors](../OrientationAnalysis/ComputeSchmidsFilter.md), or a custom flag from [Compute Biased Features](ComputeBiasedFeaturesFilter.md) / [Compute Surface Features](ComputeSurfaceFeaturesFilter.md).
+- **Cell Feature Ids** -- produced by a segmentation filter such as [Segment Features (Misorientation)](../OrientationAnalysis/EBSDSegmentFeaturesFilter.md) or [Segment Features (Scalar)](ScalarSegmentFeaturesFilter.md).
 
 % Auto generated parameter table will be inserted here
 

src/Plugins/SimplnxCore/docs/CreateAttributeMatrixFilter.md

@@ -6,11 +6,29 @@ Core (Generation)
 
 ## Description
 
-This **Filter** creates a new **Attribute Matrix**.
+This **Filter** creates a new empty **Attribute Matrix** at a user-specified location in the **Data Structure**. The matrix is created with a user-specified set of *tuple dimensions* but contains no arrays initially; subsequent filters can add arrays to it.
 
-### Example Usage
+### What is an Attribute Matrix?
 
-If you wanted to create an **Attribute Matrix** to represent a 3D volume where the dimensions of the 3 orthogonal axesare X=3, y=4 and Z=5, then the *Tuple Dimensions* would have a value of (3, 4, 5).
+An **Attribute Matrix** is a container for **Data Arrays** that share the same *number of tuples* and the same *tuple shape*. All arrays inside one Attribute Matrix represent values "at the same set of points" -- for example, all per-cell arrays of an Image Geometry live in a single Cell Attribute Matrix, all per-feature arrays for a segmented dataset live in a single Feature Attribute Matrix, and all per-ensemble (phase) arrays live in an Ensemble Attribute Matrix.
+
+This shared-tuple-shape contract is enforced: any array added to an existing Attribute Matrix must match the matrix's tuple dimensions. Use an Attribute Matrix when the values you are grouping are all parallel arrays over the same domain.
+
+### When to Use This Filter
+
+- Pre-building the destination for a future filter that creates new feature-level or ensemble-level arrays.
+- Creating a custom Attribute Matrix for organizational purposes (e.g., grouping all "computed" arrays separately from the "raw" arrays in the same Cell-level domain).
+- Restructuring imported data so that arrays sharing a common dimension end up in the same matrix.
+
+For containers that hold heterogeneous data (arrays of different sizes, geometries, sub-groups), use [Create Data Group](CreateDataGroupFilter.md) instead.
+
+### Tuple Dimensions
+
+For a 3D volume with axes X=3, Y=4, Z=5, the *Tuple Dimensions* are (3, 4, 5). For a 1D feature-list with 100 features, the tuple dimensions are (100). The product of all dimensions equals the total number of tuples that any array added to this matrix must have.
+
+### Required Input Sources
+
+- **Parent Data Object Path** -- an existing **DataGroup** or **Geometry** under which the new Attribute Matrix will be created. Typically the output of [Create Image Geometry](CreateImageGeometryFilter.md), [Create Geometry](CreateGeometryFilter.md), or [Create Data Group](CreateDataGroupFilter.md).
 
 % Auto generated parameter table will be inserted here