casacore
PagedImage.h
Go to the documentation of this file.
1 //# PagedImage.h: read, store and manipulate astronomical images
2 //# Copyright (C) 1994,1995,1996,1997,1998,1999,2000,2001,2003
3 //# Associated Universities, Inc. Washington DC, USA.
4 //#
5 //# This library is free software; you can redistribute it and/or modify it
6 //# under the terms of the GNU Library General Public License as published by
7 //# the Free Software Foundation; either version 2 of the License, or (at your
8 //# option) any later version.
9 //#
10 //# This library is distributed in the hope that it will be useful, but WITHOUT
11 //# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
12 //# FITNESS FOR A PARTICULAR PURPOSE. See the GNU Library General Public
13 //# License for more details.
14 //#
15 //# You should have received a copy of the GNU Library General Public License
16 //# along with this library; if not, write to the Free Software Foundation,
17 //# Inc., 675 Massachusetts Ave, Cambridge, MA 02139, USA.
18 //#
19 //# Correspondence concerning AIPS++ should be addressed as follows:
20 //# Internet email: aips2-request@nrao.edu.
21 //# Postal address: AIPS++ Project Office
22 //# National Radio Astronomy Observatory
23 //# 520 Edgemont Road
24 //# Charlottesville, VA 22903-2475 USA
25 //#
26 //# $Id$
27 
28 #ifndef IMAGES_PAGEDIMAGE_H
29 #define IMAGES_PAGEDIMAGE_H
30 
31 
32 //# Includes
33 #include <casacore/casa/aips.h>
34 #include <casacore/images/Images/ImageInterface.h>
35 #include <casacore/images/Images/ImageAttrHandlerCasa.h>
36 #include <casacore/lattices/Lattices/PagedArray.h>
37 #include <casacore/tables/Tables/Table.h>
38 #include <casacore/casa/Utilities/DataType.h>
39 #include <casacore/tables/Tables/TableRecord.h>
40 
41 //# Forward Declarations
42 #include <casacore/casa/iosfwd.h>
43 
44 namespace casacore { //# NAMESPACE CASACORE - BEGIN
45 
46 // <summary>
47 // Read, store, and manipulate astronomical images.
48 // </summary>
49 
50 // <use visibility=export>
51 
52 // <reviewed reviewer="" date="" tests="tPagedmage.cc" demos="dPagedImage.cc">
53 // </reviewed>
54 
55 // <prerequisite>
56 // <li> <linkto class=CoordinateSystem>CoordinateSystem</linkto>
57 // <li> <linkto class=ImageInterface>ImageInterface</linkto>
58 // <li> <linkto class=Lattice>Lattice</linkto>
59 // <li> <linkto class=LatticeIterator>LatticeIterator</linkto>
60 // <li> <linkto class=LatticeNavigator>LatticeNavigator</linkto>
61 // <li> <linkto class=ImageRegion>ImageRegion</linkto>
62 // </prerequisite>
63 
64 // <etymology>
65 // The PagedImage name comes from its role as the Image class with paging
66 // from persistent memory. Users are thus invited to treat the
67 // PagedImage instances like Casacore Lattices
68 // </etymology>
69 
70 // <synopsis>
71 // All Casacore Images are Lattices. They may be treated like any other Lattice;
72 // getSlice(...), putSlice(...), LatticeIterator for iterating, etc.
73 // ArrayImages contain a map, a mask for that map, and coordinate
74 // information. This provides a Lattice interface for images and their
75 // respective coordinates. Additional functionality is defined by the
76 // ImageInterface class.
77 //
78 // You can use the global function <src>imagePixelType</src> to determine
79 // what the pixel type of an image is before you open the image if your
80 // code can work with Images of many possible types, or for error checking.
81 //
82 // </synopsis>
83 
84 // <example>
85 // This example shows how to create a mask for an image, fill it, and
86 // make it known to the image.
87 // <srcblock>
88 // // Open the image (as readonly for the moment).
89 // PagedImage<Float> myimage ("image.name");
90 // // Create a mask for the image.
91 // // The mask will be stored in a subtable of the image.
92 // LCPagedMask mask (RegionHandler::makeMask (myimage, "mask.name"));
93 // // Fill the mask with whatever values (e.g. all True).
94 // mask.set (True);
95 // // Make the mask known to the image (with name mask1).
96 // myimage.defineRegion ("mask1", mask, RegionHandler::Masks);
97 // // Make the mask the default mask for this image.
98 // myimage.setDefaultMask ("mask1");
99 // </srcblock>
100 // It is possible to create as many masks as one likes. They can all
101 // be defined as masks for the image (with different names, of course).
102 // However, only one of them can be the default mask (the mask used
103 // by default when the image is opened). When another mask has to be
104 // used, one can do two things:
105 // <ul>
106 // <li> Use setDefaultMask to make the other mask the default mask.
107 // This is advisable when the change should be more or less permanent.
108 // <li> Open the PagedImage without using a default mask. Thereafter
109 // a <linkto class=SubImage>SubImage</linkto> object can be created
110 // from the PagedImage and the mask. This is advisable when it the
111 // mask has to be used only one time.
112 // </ul>
113 // </example>
114 
115 // <motivation>
116 // The size of astronomical data can be very large. The ability to fit an
117 // entire image into random access memory cannot be guaranteed. Paging from
118 // disk pieces of the image appeared to be the way to deal with this problem.
119 // </motivation>
120 
121 //
122 // <note>
123 // When you make a new PagedImage, and you are transferring
124 // information from some other PagedImage, be aware that you
125 // must copy, manually, things like miscInfo, imageInfo, units,
126 // logSink (history) to the new file.
127 // </note>
128 // <todo asof="1996/09/04">
129 // <li> The CoordinateSystem::store() function returns a TableRecord. That
130 // TableRecord should be stored in the same row as our image. This will
131 // allow ImageStack members to have their own coordinate frames.
132 // </todo>
133 
134 
135 template <class T> class PagedImage: public ImageInterface<T>
136 {
137 public:
138  // Construct a new Image from shape and coordinate information.
139  // Data will be stored in the argument table.
140  PagedImage (const TiledShape& mapShape,
141  const CoordinateSystem& coordinateInfo,
142  Table& table,
143  uInt rowNumber = 0);
144 
145  // Construct a new Image from shape and coordinate information. Table
146  // will be stored in the named file.
147  PagedImage (const TiledShape& mapShape,
148  const CoordinateSystem& coordinateInfo,
149  const String& nameOfNewFile,
150  uInt rowNumber = 0);
151 
152  // Construct a new Image from shape and coordinate information. Table
153  // will be stored in the named file.
154  // The lock options may be specified
155  // <group>
156  PagedImage (const TiledShape& mapShape,
157  const CoordinateSystem& coordinateInfo,
158  const String& nameOfNewFile,
160  uInt rowNumber = 0);
161  PagedImage (const TiledShape& mapShape,
162  const CoordinateSystem& coordinateInfo,
163  const String& nameOfNewFile,
164  const TableLock& lockOptions,
165  uInt rowNumber = 0);
166  // </group>
167 
168  // Reconstruct an image from a pre-existing file.
169  // By default the default pixelmask (if available) is used.
171  uInt rowNumber = 0);
172 
173  // Reconstruct an image from a pre-existing file.
174  // By default the default pixelmask (if available) is used.
175  explicit PagedImage (const String& filename, MaskSpecifier = MaskSpecifier(),
176  uInt rowNumber = 0);
177 
178  // Reconstruct an image from a pre-existing file with Locking.
179  // By default the default pixelmask (if available) is used.
180  // <group>
183  PagedImage (const String& filename, const TableLock& lockOptions,
185  // </group>
186 
187  // Copy constructor (reference semantics).
188  PagedImage (const PagedImage<T>& other);
189 
191 
192  // Assignment operator (reference semantics).
194 
195  // Make a copy of the object (reference semantics).
196  virtual ImageInterface<T>* cloneII() const;
197 
198  // Return the name of this derived class.
199  static String className()
200  { return "PagedImage"; }
201 
202  // Get the image type (returns name of this derived class).
203  virtual String imageType() const;
204 
205  // A PagedImage is always persistent.
206  virtual Bool isPersistent() const;
207 
208  // A PagedImage is always paged to disk.
209  virtual Bool isPaged() const;
210 
211  // Is the PagedImage writable?
212  virtual Bool isWritable() const;
213 
214  // Does the image object use a pixelmask?
215  virtual Bool hasPixelMask() const;
216 
217  // Get access to the pixelmask used.
218  // An exception is thrown if the image does not use a pixelmask.
219  // <group>
220  virtual const Lattice<Bool>& pixelMask() const;
222  // </group>
223 
224  // Get a pointer the default pixelmask object used with this image.
225  // It returns 0 if no default pixelmask is used.
226  virtual const LatticeRegion* getRegionPtr() const;
227 
228  // Set the default pixelmask to the mask with the given name
229  // (which has to exist in the "masks" group).
230  // If the image table is writable, the setting is persistent by writing
231  // the name as a keyword.
232  // If the given regionName is the empty string,
233  // the default pixelmask is unset.
234  virtual void setDefaultMask (const String& maskName);
235 
236  // Use the mask as specified.
237  // If a mask was already in use, it is replaced by the new one.
238  virtual void useMask (MaskSpecifier = MaskSpecifier());
239 
240  // Function to change the name of the Table file on disk.
241  // PagedImage is given a file name at construction time. You may change
242  // that name here.
243  void rename (const String& newName);
244 
245  // Return the current Table name. By default this includes the full path.
246  // the path preceding the file name can be stripped off on request.
247  virtual String name (Bool stripPath=False) const;
248 
249  // Return the current TableColumn row number.
250  uInt rowNumber() const;
251 
252  // Return the shape of the image.
253  virtual IPosition shape() const;
254 
255  // Change the shape of the image (N.B. the data is thrown away).
256  virtual void resize (const TiledShape& newShape);
257 
258  // Function which extracts an array from the map.
259  virtual Bool doGetSlice (Array<T>& buffer, const Slicer& theSlice);
260 
261  // Function to replace the values in the map with soureBuffer.
262  virtual void doPutSlice (const Array<T>& sourceBuffer,
263  const IPosition& where,
264  const IPosition& stride);
265 
266  // Replace every element, x, of the lattice with the result of f(x).
267  // you must pass in the address of the function -- so the function
268  // must be declared and defined in the scope of your program.
269  // Both versions of apply require a function that accepts a single
270  // argument of type T (the Lattice template actual type) and returns
271  // a result of the same type. The first apply expects a function with
272  // an argument passed by value; the second expects the argument to
273  // be passed by const reference. The first form ought to run faster
274  // for the built-in types, which may be an issue for large Lattices
275  // stored in memory, where disk access is not an issue.
276  // <group>
277  virtual void apply (T (*function)(T));
278  virtual void apply (T (*function)(const T& ));
279  virtual void apply (const Functional<T,T>& function);
280  // </group>
281 
282  // Add a lattice to this image.
284 
285  // Function which sets the units associated with the image
286  // pixels (i.e. the "brightness" unit). <src>setUnits()</src> returns
287  // False if it cannot set the unit for some reason (e.g. the underlying
288  // file is not writable).
289  virtual Bool setUnits (const Unit& newUnits);
290 
291  // Return the table holding the data.
293  { return map_p.table(); }
294 
295  // Flushes the new coordinate system to disk if the table is writable.
296  virtual Bool setCoordinateInfo (const CoordinateSystem& coords);
297 
298  // Check for symmetry in data members.
299  virtual Bool ok() const;
300 
301  // These are the true implementations of the paran operator.
302  // <note> Not for public use </note>
303  // <group>
304  virtual T getAt (const IPosition& where) const;
305  virtual void putAt (const T& value, const IPosition& where);
306  // </group>
307 
308  // Replace the miscinfo in the PagedImage.
309  // It can fail if, e.g., the underlying table is not writable.
310  virtual Bool setMiscInfo (const RecordInterface& newInfo);
311 
312  // The ImageInfo object contains some miscellaneous information about the
313  // image, which unlike that stored in MiscInfo, has a standard list of
314  // things, such as the restoring beam.
315  // Note that setImageInfo REPLACES the information with the new information.
316  // It can fail if, e.g., the underlying table is not writable.
317  virtual Bool setImageInfo(const ImageInfo& info);
318 
319  // Get access to the attribute handler.
320  // If a handler keyword does not exist yet, it is created if
321  // <src>createHandler</src> is set.
322  // Otherwise the handler is empty and no groups can be created for it.
323  virtual ImageAttrHandler& attrHandler (Bool createHandler=False);
324 
325  // Remove a region/mask belonging to the image from the given group
326  // (which can be Any).
327  // If a mask removed is the default mask, the image gets unmasked.
328  // <br>Optionally an exception is thrown if the region does not exist.
329  virtual void removeRegion (const String& name,
331  Bool throwIfUnknown = True);
332 
333  // This is the implementation of the letter for the envelope Iterator
334  // class. <note> Not for public use </note>.
336  (const LatticeNavigator& navigator,
337  Bool useRef) const;
338 
339  // Returns the maximum recommended number of pixels for a cursor. This is
340  // the number of pixels in a tile.
341  virtual uInt advisedMaxPixels() const;
342 
343  // Help the user pick a cursor for most efficient access.
344  virtual IPosition doNiceCursorShape (uInt maxPixels) const;
345 
346  // Maximum size - not necessarily all used. In pixels.
347  virtual uInt maximumCacheSize() const;
348 
349  // Set the maximum (allowed) cache size as indicated.
350  virtual void setMaximumCacheSize (uInt howManyPixels);
351 
352  // Set the cache size as to "fit" the indicated path.
353  virtual void setCacheSizeFromPath (const IPosition& sliceShape,
354  const IPosition& windowStart,
355  const IPosition& windowLength,
356  const IPosition& axisPath);
357 
358  // Set the actual cache size for this Array to be be big enough for the
359  // indicated number of tiles. This cache is not shared with PagedArrays
360  // in other rows and is always clipped to be less than the maximum value
361  // set using the setMaximumCacheSize member function.
362  // tiles. Tiles are cached using a first in first out algorithm.
363  virtual void setCacheSizeInTiles (uInt howManyTiles);
364 
365  // Clears and frees up the caches, but the maximum allowed cache size is
366  // unchanged from when setCacheSize was called
367  virtual void clearCache();
368 
369  // Report on cache success.
370  virtual void showCacheStatistics (ostream& os) const;
371 
372  // Handle the (un)locking.
373  // Unlocking also unlocks the logtable and a possible mask table.
374  // Locking only locks the image itself.
375  // <group>
376  virtual Bool lock (FileLocker::LockType, uInt nattempts);
377  virtual void unlock();
379  // </group>
380 
381  // Resynchronize the PagedImage object with the table contents.
382  // The logtable and possible mask table are also synchronized if
383  // they do not have a readlock.
384  // <br>This function is only useful if no read-locking is used, ie.
385  // if the table lock option is UserNoReadLocking or AutoNoReadLocking.
386  // In that cases the table system does not acquire a read-lock, thus
387  // does not synchronize itself automatically.
388  virtual void resync();
389 
390  // Flush the data.
391  virtual void flush();
392 
393  // Close the Image and associated files temporarily.
394  // It'll be reopened automatically when needed or when
395  // <src>reopen</src> is called explicitly.
396  virtual void tempClose();
397 
398  // If needed, reopen a temporarily closed Image.
399  virtual void reopen();
400 
401 
402 private:
403  // Function to return the internal Table object to the RegionHandler.
404  static Table& getTable (void* imagePtr, Bool writable);
405 
406  // This must be called in every constructor and place where the image
407  // is attached to a new image.
410  void restoreUnits (const TableRecord& rec);
411  void restoreMiscInfo (const TableRecord& rec);
412  void restoreImageInfo (const TableRecord& rec);
413  void restoreAll (const TableRecord& rec);
414 
415  void check_conformance (const Lattice<T>& other);
416  void reopenRW();
417  void setTableType();
419  void applyMask (const String& maskName);
420  void makePagedImage (const TiledShape& mapShape,
421  const CoordinateSystem& coordinateInfo,
422  const String& nameOfNewFile,
423  const TableLock& lockOptions,
424  uInt rowNumber);
425  void makePagedImage (const String& filename, const TableLock& lockOptions,
426  const MaskSpecifier&, uInt rowNumber);
427 
428  const Table& table() const
429  { return const_cast<PagedImage<T>*>(this)->table(); }
430 
431 
435 
436  //# Make members of parent class known.
437 public:
445 protected:
451 };
452 
453 
454 //# A nasty - the column name is hard-coded into this function, needs to
455 //# be centralized somewhere.
456 // Determine the pixel type in the PagedImage contained in
457 // <src>fileName</src>. If the file doesn't appear to be a Table or cannot
458 // be opened, TpOther is returned.
459 // <group name="pixeltype")
460  DataType imagePixelType(const String& fileName);
461 // </group>
462 
463 
464 //# Declare extern templates for often used types.
465  extern template class PagedImage<Float>;
466  extern template class PagedImage<Complex>;
467 
468 
469 
470 } //# NAMESPACE CASACORE - END
471 
472 #ifndef CASACORE_NO_AUTO_TEMPLATES
473 #include <casacore/images/Images/PagedImage.tcc>
474 #endif //# CASACORE_NO_AUTO_TEMPLATES
475 #endif
LockType
Define the possible lock types.
Definition: FileLocker.h:95
void restoreMiscInfo(const TableRecord &rec)
LatticeRegion * regionPtr_p
Definition: PagedImage.h:433
virtual void reopen()
If needed, reopen a temporarily closed Image.
uInt rowNumber() const
Return the current TableColumn row number.
virtual IPosition shape() const
Return the shape of the image.
PagedImage(const PagedImage< T > &other)
Copy constructor (reference semantics).
PagedImage(const TiledShape &mapShape, const CoordinateSystem &coordinateInfo, Table &table, uInt rowNumber=0)
Construct a new Image from shape and coordinate information.
virtual void clearCache()
Clears and frees up the caches, but the maximum allowed cache size is unchanged from when setCacheSiz...
virtual Bool setCoordinateInfo(const CoordinateSystem &coords)
Flushes the new coordinate system to disk if the table is writable.
virtual ImageAttrHandler & attrHandler(Bool createHandler=False)
Get access to the attribute handler.
virtual void useMask(MaskSpecifier=MaskSpecifier())
Use the mask as specified.
virtual uInt advisedMaxPixels() const
Returns the maximum recommended number of pixels for a cursor.
virtual void apply(T(*function)(T))
Replace every element, x, of the lattice with the result of f(x).
virtual Bool isPersistent() const
A PagedImage is always persistent.
static Table & getTable(void *imagePtr, Bool writable)
Function to return the internal Table object to the RegionHandler.
virtual String name(Bool stripPath=False) const
Return the current Table name.
virtual const LatticeRegion * getRegionPtr() const
Get a pointer the default pixelmask object used with this image.
PagedImage< T > & operator+=(const Lattice< T > &other)
Add a lattice to this image.
virtual void apply(const Functional< T, T > &function)
virtual void resize(const TiledShape &newShape)
Change the shape of the image (N.B.
virtual Lattice< Bool > & pixelMask()
virtual void resync()
Resynchronize the PagedImage object with the table contents.
PagedImage(Table &table, MaskSpecifier=MaskSpecifier(), uInt rowNumber=0)
Reconstruct an image from a pre-existing file.
virtual void putAt(const T &value, const IPosition &where)
Put the value of a single element.
virtual void setDefaultMask(const String &maskName)
Set the default pixelmask to the mask with the given name (which has to exist in the "masks" group).
virtual void setCacheSizeFromPath(const IPosition &sliceShape, const IPosition &windowStart, const IPosition &windowLength, const IPosition &axisPath)
Set the cache size as to "fit" the indicated path.
virtual Bool isPaged() const
A PagedImage is always paged to disk.
virtual void removeRegion(const String &name, RegionHandler::GroupType=RegionHandler::Any, Bool throwIfUnknown=True)
Remove a region/mask belonging to the image from the given group (which can be Any).
PagedArray< T > map_p
Definition: PagedImage.h:432
void applyMaskSpecifier(const MaskSpecifier &)
void rename(const String &newName)
Function to change the name of the Table file on disk.
virtual Bool setMiscInfo(const RecordInterface &newInfo)
Replace the miscinfo in the PagedImage.
virtual void apply(T(*function)(const T &))
virtual const Lattice< Bool > & pixelMask() const
Get access to the pixelmask used.
virtual void showCacheStatistics(ostream &os) const
Report on cache success.
PagedImage(const String &filename, MaskSpecifier=MaskSpecifier(), uInt rowNumber=0)
Reconstruct an image from a pre-existing file.
static String className()
Return the name of this derived class.
Definition: PagedImage.h:199
ImageAttrHandlerCasa itsAttrHandler
Definition: PagedImage.h:434
virtual Bool isWritable() const
Is the PagedImage writable?
PagedImage(const TiledShape &mapShape, const CoordinateSystem &coordinateInfo, const String &nameOfNewFile, TableLock::LockOption, uInt rowNumber=0)
Construct a new Image from shape and coordinate information.
PagedImage(const TiledShape &mapShape, const CoordinateSystem &coordinateInfo, const String &nameOfNewFile, const TableLock &lockOptions, uInt rowNumber=0)
virtual IPosition doNiceCursorShape(uInt maxPixels) const
Help the user pick a cursor for most efficient access.
Table & table()
Return the table holding the data.
Definition: PagedImage.h:292
PagedImage< T > & operator=(const PagedImage< T > &other)
Assignment operator (reference semantics).
virtual T getAt(const IPosition &where) const
These are the true implementations of the paran operator.
virtual void doPutSlice(const Array< T > &sourceBuffer, const IPosition &where, const IPosition &stride)
Function to replace the values in the map with soureBuffer.
virtual void setCacheSizeInTiles(uInt howManyTiles)
Set the actual cache size for this Array to be be big enough for the indicated number of tiles.
virtual Bool ok() const
Check for symmetry in data members.
void applyMask(const String &maskName)
virtual Bool setUnits(const Unit &newUnits)
Function which sets the units associated with the image pixels (i.e.
virtual void setMaximumCacheSize(uInt howManyPixels)
Set the maximum (allowed) cache size as indicated.
virtual Bool hasLock(FileLocker::LockType) const
virtual void tempClose()
Close the Image and associated files temporarily.
const Table & table() const
Definition: PagedImage.h:428
virtual Bool doGetSlice(Array< T > &buffer, const Slicer &theSlice)
Function which extracts an array from the map.
void restoreImageInfo(const TableRecord &rec)
PagedImage(const String &filename, const TableLock &lockOptions, MaskSpecifier=MaskSpecifier(), uInt rowNumber=0)
virtual Bool lock(FileLocker::LockType, uInt nattempts)
Handle the (un)locking.
virtual ImageInterface< T > * cloneII() const
Make a copy of the object (reference semantics).
virtual void unlock()
void makePagedImage(const TiledShape &mapShape, const CoordinateSystem &coordinateInfo, const String &nameOfNewFile, const TableLock &lockOptions, uInt rowNumber)
virtual LatticeIterInterface< T > * makeIter(const LatticeNavigator &navigator, Bool useRef) const
This is the implementation of the letter for the envelope Iterator class; Note: Not for public use ...
void makePagedImage(const String &filename, const TableLock &lockOptions, const MaskSpecifier &, uInt rowNumber)
virtual Bool setImageInfo(const ImageInfo &info)
The ImageInfo object contains some miscellaneous information about the image, which unlike that store...
void restoreAll(const TableRecord &rec)
void attach_logtable()
This must be called in every constructor and place where the image is attached to a new image.
void restoreUnits(const TableRecord &rec)
PagedImage(const TiledShape &mapShape, const CoordinateSystem &coordinateInfo, const String &nameOfNewFile, uInt rowNumber=0)
Construct a new Image from shape and coordinate information.
void check_conformance(const Lattice< T > &other)
virtual uInt maximumCacheSize() const
Maximum size - not necessarily all used.
virtual Bool hasPixelMask() const
Does the image object use a pixelmask?
virtual String imageType() const
Get the image type (returns name of this derived class).
virtual void flush()
Flush the data.
PagedImage(const String &filename, TableLock::LockOption, MaskSpecifier=MaskSpecifier(), uInt rowNumber=0)
Reconstruct an image from a pre-existing file with Locking.
GroupType
Define the possible group types (regions or masks).
Definition: RegionHandler.h:99
String: the storage and methods of handling collections of characters.
Definition: String.h:225
LockOption
Define the possible table locking options.
Definition: TableLock.h:81
this file contains all the compiler specific defines
Definition: mainpage.dox:28
const Bool False
Definition: aipstype.h:44
unsigned int uInt
Definition: aipstype.h:51
bool Bool
Define the standard types used by Casacore.
Definition: aipstype.h:42
LatticeExprNode value(const LatticeExprNode &expr)
This function returns the value of the expression without a mask.
DataType imagePixelType(const String &fileName)
Determine the pixel type in the PagedImage contained in fileName.
const Bool True
Definition: aipstype.h:43