LatticeConcat.h

Slicer setup2 (Bool& first, IPosition& blc2, IPosition& trc2, Int shape2, Int axis, const IPosition& blc, const IPosition& trc, const IPosition& stride, Int start)

Bool getSlice1 (Array<T>& buffer, const Slicer& section, uInt nLattices)

Bool getSlice2 (Array<T>& buffer, const Slicer& section, uInt nLattices)

Bool putSlice1 (const Array<T>& buffer, const IPosition& where, const IPosition& stride, uInt nLattices)

Bool putSlice2 (const Array<T>& buffer, const IPosition& where, const IPosition& stride, uInt nLattices)

Bool getMaskSlice1 (Array<Bool>& buffer, const Slicer& section, uInt nLattices)

Bool getMaskSlice2 (Array<Bool>& buffer, const Slicer& section, uInt nLattices)

Description

Review Status

Date Reviewed:: yyyy/mm/dd

Prerequisite

MaskedLattice (base class)

Etymology

This is a class designed to concatenate lattices along a specified axis

Synopsis

This is a class designed to concatenate lattices along a specified axis. This means you can join them together. E.g., join lattices of shape [10,20,30] and [10,20,40] into a lattice of shape [10,20,70].

In addition, you can increase the dimensionality and join lattices [10,20] and [10,20] to [10,20,2]. This is done by specifying the concatenation axis to be higher than currently exists in the input lattices

The LatticeConcat object does not copy the input lattices, it just references them. You can use the Lattice::copyData(Lattice) function to fill an output lattice with the concatenated input lattices.

If you use the putSlice function, be aware that it will change the underlying lattices if they are writable.

Example

    
    // Make ArrayLattices 
    
       ArrayLattice<Float> al1(a1); al1.set(1.0);
       ArrayLattice<Float> al2(a2); al2.set(10.0);
    
    // Turn these into MaskedLattices
    
      SubLattice<Float> ml1(al1, True);
      SubLattice<Float> ml2(al2, True);
    
    // Concatenate along axis 1
            
      LatticeConcat<Float> lc (1);
      lc.setLattice(ml1);
      lc.setLattice(ml2);
            
    // Make output
            
      ArrayLattice<Float> al3(lc.shape());
      SubLattice<Float> ml3(al3, True);
    
    // Copy data to output (mask has to be copied separately)
            
      ml3.copyData(lc);

In this example no masks are involved. See tLatticeConcat for more examples.

Motivation

Image concatentation is a useful enduser requirement. An object of this class is contained by an ImageConcat object.

To Do

Member Description

LatticeConcat (uInt axis, Bool tempClose=True)

Constructor. Argument axis specifies the concatenation axis (0 relative). If this is one more than the number of axes in the input lattices (set with function setLattice) then the resultant concatenated lattice has dimension one greater than that the input lattices. Argument tempClose specifies whether you wish all internal lattice copies to be opened/closed on demand, rather than just being left open. This prevents open file limits being reached

LatticeConcat ()

Default constructor. Sets the concatenation axis to 0 and tempClose is True

LatticeConcat(const LatticeConcat<T> &other)

Copy constructor (reference semantics)

virtual ~LatticeConcat ()

Destructor

LatticeConcat<T> &operator=(const LatticeConcat<T> &other)

Assignment operator (reference semantics)

void setLattice (MaskedLattice<T>& lattice)

Sets a new lattice into the list to be concatenated. Exception thrown if lattices are incompatible

uInt nlattices() const

Return the number of lattices set so far

uInt axis () const

Returns the current concatenation axis (0 relative)

Bool isTempClose () const

Returns the tempClose constructor state

uInt latticeDim() const

Returns the number of dimensions of the *input* lattices (may be different by one from output lattice). Returns 0 if none yet set.

MaskedLattice<T>* lattice(uInt i) const

Return pointer for specified lattice. Do not delete this.

virtual Bool lock (FileLocker::LockType, uInt nattempts)
virtual void unlock()
virtual Bool hasLock (FileLocker::LockType) const
virtual void resync()
virtual void flush()
virtual void tempClose()
virtual void reopen()

Handle the (un)locking and syncing, etc..

void tempClose(uInt which)
void reopen(uInt which)

Close/reopen a specific lattice. It is your responsibility to leave the LatticeConcat object in a fully closed state. So always pair a reopen with a tempClose.

virtual String name (Bool stripPath=False) const

Name. Since many lattices may go into the concatenation, the name is rather meaningless. Returns the string "Concatenation :"

virtual LatticeConcat<T>* cloneML() const

Make a copy of the derived object (reference semantics).

virtual Bool isMasked() const

Has the object really a mask?

virtual const LatticeRegion* getRegionPtr() const

Get the region used (always returns 0).

virtual Bool isWritable() const

If all of the underlying lattices are writable returns True

virtual Bool hasPixelMask() const

Does the lattice have a pixelmask?

virtual const Lattice<Bool>& pixelMask() const
virtual Lattice<Bool>& pixelMask()

Get access to the pixelmask. An exception is thrown if the lattice does not have a pixelmask

virtual IPosition shape () const

Find the shape that the concatenated lattice will be. Returns a null IPosition if function setLattice has not yet been called

virtual IPosition doNiceCursorShape (uInt maxPixels) const

Return the best cursor shape. This isn't very meaningful for a LatticeConcat Lattice since it isn't on disk ! But if you do copy it out, this is what you should use. The maxPixels aregument is ignored.

virtual Bool doGetSlice (Array<T>& buffer, const Slicer& section)

Do the actual get of the data. The return value is always False, thus the buffer does not reference another array. Generally the user should use function getSlice

virtual Bool doGetMaskSlice (Array<Bool>& buffer, const Slicer& section)

Do the actual get of the mask data. The return value is always False, thus the buffer does not reference another array. Generally the user should use function getMaskSlice

virtual void doPutSlice (const Array<T>& sourceBuffer, const IPosition& where, const IPosition& stride)

Do the actual put of the data into the Lattice. This will change the underlying lattices (if they are writable) that were used to create the LatticeConcat object. It throws an exception if not writable. Generally the user should use function putSlice

void checkAxis(uInt axis, uInt ndim) const

void setup1 (IPosition& blc, IPosition& trc, IPosition& stride, IPosition& blc2, IPosition& trc2, IPosition& blc3, IPosition& trc3, IPosition& stride3, const Slicer& section)

Slicer setup2 (Bool& first, IPosition& blc2, IPosition& trc2, Int shape2, Int axis, const IPosition& blc, const IPosition& trc, const IPosition& stride, Int start)