If you wish to extract elements from the array
at intervals, these intervals must be regular. The interval is one
constant integer for each dimension of the array: it cannot be a function.
- endIsLength
- The end-values given in the constructor define the lengths.
- endIsLast
- The end-values given in the constructor define the trc.
Slicer has many constructors. Of these, some require that the programmer supply a full specification of the array elements he wants to extract; other constructors make do with partial information. In the latter case, the constructor will assume sensible default values or, when directed, infer missing information from the array that's getting sliced (hereafter, the "source" array).
To fully specify a subarray, you must supply three pieces of information for each axis of the subarray:
The most basic constructor for Slicer illustrates this. To create an Slicer for getting selected elements from a 3D array:
IPosition start (3,0,0,0), length (3,10,10,10), stride (3,3,3,3); Slicer slicer (start, length, stride); // assume proper declarations, and meaningful values in the source array subArray = sourceArray (slicer);
IPosition start (3,0,0,0), end (3,27,27,27), stride (3,3,3,3); Slicer slicer (start, end, stride, Slicer::endIsLast); subArray = sourceArray (slicer);(We use "end" as the name of the formal parameter because it supports both meanings -- "last index" or "length." You may wish to use a clarifying name for the actual parameter in your code, as we have above when we used "length".)
Some of the constructors don't require complete information: Slicer either calculates sensible default values or deduces them from the source array. If you do not specify a "stride" argument, for example, a value of 1 will be used for all dimensions. If you specify a "start" but nothing else, a stride of 1, and (perhaps against expectation) a length of 1 will be used.
To instruct the Slicer to get otherwise unspecified information from the source array, you can create an IPosition like "end" as shown here:
IPosition start (3,0,0,0), stride (3,3,3,3);
IPosition end (3,Slicer::MimicSource, Slicer::MimicSource,
Slicer::MimicSource);
Slicer smartSlicer (start, end, stride);
// assume proper declarations...
subArray = sourceArray (smartSlicer)
If you are a library programmer, and write a class that can be sliced by the Slicer class, you need to understand the mechanism for completing the information which the application programmer, in using your class, specified incompletely. (If you are an application programmer, who wants to slice a library class, this explanation will be only of academic interest.)
When the source array (the library class you provide) gets the Slicer -- which typically comes when the source array is asked to return a reference to a subarray -- the source does a callback to the Slicer object. The source array passes its own shape as one of the arguments to the Slicer callback and asks the Slicer to fill in the missing values from that shape.
In use, and with an imagined class "MyVector", code would look like this:
// first, a fragment from the application program:
IPosition start (1,10), end (1, Slicer::MimicSource);
Slicer slicer (start, end);
MyVector <Int> v0 (100);
MyVector <Int> v1 = v0 (slicer);
//....
// second, a fragment from a constructor of the library class "MyVector":
// the MyVector class will construct v1 as a reference to
// selected elements of v0, using (among other things) a
// callback to the slicer it was passed (above, in the
// construction of v1.
//
IPosition start, end, stride;
fullSliceInformation =
slicer.inferShapeFromSource (MyVector::shape(), start, end, stride);
// now the MyVector instance knows everything it needs to
// construct the instance.
Please note that v1 will have a length of 90, and refer to elements
10-99 of v0.
An exception will be thrown if the positions defined in the Slicer exceed the source array's shape.
Image <Float> image ("N5364.fits"); // a 4-d VLA map, 4096 x 4096 x 3 x 1
IPosition start (4,0,0,0,0), stride (4,4,4,1,1);
IPosition end (4, Slicer::MimicSource, Slicer::MimicSource,
Slicer::MimicSource, Slicer::MimicSource);
Slicer smartSlicer (start, end, stride);
// assume proper declarations...
Image <Float> subImage = image (smartSlicer);
For example, imagine a 100 x 100 x 100 array from which you want to extract various subarrays. Here are some of the ways you might specify the the subarray in the -absence- of Slicer.
// preliminaries: create a cube and assign values to all elements -- // this will be "source" array Cube <Int> bigCube (IPosition (3, 100, 100, 100)); assignValues (bigCube); // declare a smaller cube, the destination array. Cube <Int> smallCube (IPosition (3, 10, 10, 10)); // example 1: use Slice objects to extract a subcube -- the first // ten elements along each axis Slice xIndices (0,10,1), yIndices (0,10,1), zIndices (0,10,1); smallCube = bigCube (xIndices, yIndices, zIndices); // example 2: get the same subcube using three IPosition arguments IPosition start (3,0,0,0), end (3,10,10,10), stride (3,1,1,1); smallCube = bigCube (start, end, stride); // example 3: use 2 IPositions, letting the 3rd (stride) default to // IPosition (3,1,1,1) smallCube = bigCube (start, end);
So the Cube class (together with its base class) must define three separate member functions for the essentially identical operation of extracting a subcube. The same replication is also required of Image, Array, and the other Array subclasses (Matrix and Vector).
The Slicer class collapses all of this into a single member function per class:
Slicer slicer = (call the constructor that best suits your problem) smallCube = bigCube (slicer);
Since there are many constructors available for Slicer, you can still specify the subarray that you may want in a number of different ways, by constructing the Slicer in the way most natural to your circumstances. You then pass the Slicer to the array, and you will get back the slice you want.
This class also offers the application programmer considerable flexibility by allowing the shape of the source array to determine some of the slice specification. This benefit is explained and demonstrated above.
The member function inferShapeFromSource (invoked as a callback by the source array) will use the shape of the source array for the unspecified values: IPosition elements with the value Slicer::MimicSource
Create a Slicer object from Slice objects. In a Slice object one defines the start, length, and stride for one axis. The default Slice constructor (called with no arguments) creates a Slice with start and length equal to zero, and an undefined stride.
Create a Slicer for a 2-dim array.
Create a Slicer object from Slice objects. In a Slice object one defines the start, length, and stride for one axis. The default Slice constructor (called with no arguments) creates a Slice with start and length equal to zero, and an undefined stride.
Create a Slicer for a 3-dim array.
Create a Slicer object from Slice objects. In a Slice object one defines the start, length, and stride for one axis. The default Slice constructor (called with no arguments) creates a Slice with start and length equal to zero, and an undefined stride.
Copy constructor (copy semantics).
Assignment (copy semantics).
Equality
Return the number of dimensions of the Slicer.
This function checks all of the start, length (or end), and stride IPositions, and fills in missing values by getting the corresponding values from the shape of the source array. These will first be resized, if necessary. If, for a given axis, (end < start) , it means that a length of zero was specified. An exception is thrown if the start, end, or length exceeds the array shape or if the dimensionality of the array and Slicer do not conform.
Infer the slicer's shape from an array, using a zero origin.
This function checks all of the start, length (or end), and stride IPositions, and fills in missing values by getting the corresponding values from the shape of the source array. These will first be resized, if necessary. If, for a given axis, (end < start) , it means that a length of zero was specified. An exception is thrown if the start, end, or length exceeds the array shape or if the dimensionality of the array and Slicer do not conform.
Infer the slicer shape from an array, with the given origin. The returned values are based on a zero origin.
Report the defined starting position.
Report the defined ending position.
Report the defined stride.
Report the length of the resulting axes..
Are all values fixed (i.e., no MimicSource given)?
Define a private constructor taking an Int. This is to prevent the user from the unexpected and meaningless Slicer that would result when the Int argument is promoted to an IPosition.
Check the given start, end/length and stride. Fill in the length or end. It also call fillFixed to fill the fixed flag.
Fill in start, len and stride from a Slice.
Fill the fixed flag.