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
casacore::PagedImage::putAt
virtual void putAt(const T &value, const IPosition &where)
casacore::PagedImage::open_logtable
void open_logtable()
casacore::CoordinateSystem
Interconvert pixel and world coordinates.
Definition: CoordinateSystem.h:218
casacore::PagedImage::pixelMask
virtual Lattice< Bool > & pixelMask()
casacore::ImageInterface
A base class for astronomical images.
Definition: ImageFITSConverter.h:48
casacore::Slicer
Specify which elements to extract from an n-dimensional array.
Definition: Slicer.h:290
casacore::PagedImage::setMiscInfo
virtual Bool setMiscInfo(const RecordInterface &newInfo)
Replace the miscinfo in the PagedImage.
casacore::PagedImage::~PagedImage
~PagedImage()
casacore::PagedImage::isWritable
virtual Bool isWritable() const
Is the PagedImage writable?
casacore::PagedImage::restoreUnits
void restoreUnits(const TableRecord &rec)
casacore::PagedImage::pixelMask
virtual const Lattice< Bool > & pixelMask() const
Get access to the pixelmask used.
casacore::TableLock::LockOption
LockOption
Define the possible table locking options.
Definition: TableLock.h:81
casacore::PagedImage::tempClose
virtual void tempClose()
Close the Image and associated files temporarily.
casacore::IPosition
A Vector of integers, for indexing into Array<T> objects.
Definition: IPosition.h:120
casacore::PagedImage::regionPtr_p
LatticeRegion * regionPtr_p
Definition: PagedImage.h:433
casacore::PagedImage::PagedImage
PagedImage(const String &filename, MaskSpecifier=MaskSpecifier(), uInt rowNumber=0)
Reconstruct an image from a pre-existing file.
casacore::RegionHandler::GroupType
GroupType
Define the possible group types (regions or masks).
Definition: RegionHandler.h:99
casacore::RegionHandler::Any
@ Any
Definition: RegionHandler.h:102
casacore::PagedImage::doNiceCursorShape
virtual IPosition doNiceCursorShape(uInt maxPixels) const
Help the user pick a cursor for most efficient access.
casacore::PagedImage::applyMask
void applyMask(const String &maskName)
casacore::PagedImage::name
virtual String name(Bool stripPath=False) const
Return the current Table name.
casacore::PagedImage::setImageInfo
virtual Bool setImageInfo(const ImageInfo &info)
The ImageInfo object contains some miscellaneous information about the image, which unlike that store...
casacore::TableRecord
A hierarchical collection of named fields of various types.
Definition: TableRecord.h:183
casacore::PagedImage::imageType
virtual String imageType() const
Get the image type (returns name of this derived class).
casacore::PagedImage::advisedMaxPixels
virtual uInt advisedMaxPixels() const
Returns the maximum recommended number of pixels for a cursor.
casacore::PagedImage::makePagedImage
void makePagedImage(const String &filename, const TableLock &lockOptions, const MaskSpecifier &, uInt rowNumber)
casacore::Functional
Map a domain object into a range object via operator().
Definition: Array.h:53
casacore::FileLocker::LockType
LockType
Define the possible lock types.
Definition: FileLocker.h:95
casacore::PagedImage::setUnits
virtual Bool setUnits(const Unit &newUnits)
Function which sets the units associated with the image pixels (i.e.
casacore::PagedImage::maximumCacheSize
virtual uInt maximumCacheSize() const
Maximum size - not necessarily all used.
casacore::PagedImage::map_p
PagedArray< T > map_p
Definition: PagedImage.h:432
casacore::ImageAttrHandlerCasa
Abstract base class for an image attributes handler.
Definition: ImageAttrHandlerCasa.h:88
casacore::PagedImage::PagedImage
PagedImage(const TiledShape &mapShape, const CoordinateSystem &coordinateInfo, Table &table, uInt rowNumber=0)
Construct a new Image from shape and coordinate information.
casacore::PagedImage::getTable
static Table & getTable(void *imagePtr, Bool writable)
Function to return the internal Table object to the RegionHandler.
casacore::LatticeRegion
An optionally strided region in a Lattice.
Definition: LatticeRegion.h:75
casacore::PagedImage::attach_logtable
void attach_logtable()
This must be called in every constructor and place where the image is attached to a new image.
casacore::PagedImage::PagedImage
PagedImage(const String &filename, TableLock::LockOption, MaskSpecifier=MaskSpecifier(), uInt rowNumber=0)
Reconstruct an image from a pre-existing file with Locking.
casacore::PagedImage::table
const Table & table() const
Definition: PagedImage.h:428
casacore::PagedImage
Read, store, and manipulate astronomical images.
Definition: ImageFITSConverter.h:47
casacore::PagedImage::resize
virtual void resize(const TiledShape &newShape)
Change the shape of the image (N.B.
casacore::PagedImage::PagedImage
PagedImage(Table &table, MaskSpecifier=MaskSpecifier(), uInt rowNumber=0)
Reconstruct an image from a pre-existing file.
casacore::PagedImage::reopen
virtual void reopen()
If needed, reopen a temporarily closed Image.
casacore::Table
Main interface class to a read/write table.
Definition: Table.h:154
casacore::PagedImage::lock
virtual Bool lock(FileLocker::LockType, uInt nattempts)
Handle the (un)locking.
casacore::value
LatticeExprNode value(const LatticeExprNode &expr)
This function returns the value of the expression without a mask.
casacore::PagedImage::check_conformance
void check_conformance(const Lattice< T > &other)
casacore::LatticeNavigator
Abstract base class to steer lattice iterators.
Definition: LatticeNavigator.h:182
casacore::PagedImage::rowNumber
uInt rowNumber() const
Return the current TableColumn row number.
casacore::PagedImage::hasPixelMask
virtual Bool hasPixelMask() const
Does the image object use a pixelmask?
casacore::False
const Bool False
Definition: aipstype.h:44
casacore::uInt
unsigned int uInt
Definition: aipstype.h:51
casacore::PagedImage::cloneII
virtual ImageInterface< T > * cloneII() const
Make a copy of the object (reference semantics).
casacore::PagedImage::apply
virtual void apply(T(*function)(const T &))
casacore::PagedImage::table
Table & table()
Return the table holding the data.
Definition: PagedImage.h:292
casacore::PagedImage::doGetSlice
virtual Bool doGetSlice(Array< T > &buffer, const Slicer &theSlice)
Function which extracts an array from the map.
casacore::PagedImage::attrHandler
virtual ImageAttrHandler & attrHandler(Bool createHandler=False)
Get access to the attribute handler.
casacore::PagedImage::operator=
PagedImage< T > & operator=(const PagedImage< T > &other)
Assignment operator (reference semantics).
casacore::PagedArray
A Lattice that is read from or written to disk.
Definition: PagedArray.h:374
casacore::MaskSpecifier
Class to specify which mask to use in an image.
Definition: MaskSpecifier.h:70
casacore::PagedImage::PagedImage
PagedImage(const String &filename, const TableLock &lockOptions, MaskSpecifier=MaskSpecifier(), uInt rowNumber=0)
casacore::PagedImage::restoreAll
void restoreAll(const TableRecord &rec)
casacore::PagedImage::operator+=
PagedImage< T > & operator+=(const Lattice< T > &other)
Add a lattice to this image.
casacore::PagedImage::setTableType
void setTableType()
casacore::PagedImage::apply
virtual void apply(const Functional< T, T > &function)
casacore::PagedImage::shape
virtual IPosition shape() const
Return the shape of the image.
casacore::PagedImage::rename
void rename(const String &newName)
Function to change the name of the Table file on disk.
casacore::TableLock
Class to hold table lock options.
Definition: TableLock.h:69
casacore::PagedImage::makePagedImage
void makePagedImage(const TiledShape &mapShape, const CoordinateSystem &coordinateInfo, const String &nameOfNewFile, const TableLock &lockOptions, uInt rowNumber)
casacore
this file contains all the compiler specific defines
Definition: mainpage.dox:28
casacore::PagedImage::PagedImage
PagedImage(const TiledShape &mapShape, const CoordinateSystem &coordinateInfo, const String &nameOfNewFile, TableLock::LockOption, uInt rowNumber=0)
Construct a new Image from shape and coordinate information.
casacore::PagedImage::setCoordinateInfo
virtual Bool setCoordinateInfo(const CoordinateSystem &coords)
Flushes the new coordinate system to disk if the table is writable.
casacore::PagedImage::reopenRW
void reopenRW()
casacore::PagedImage::hasLock
virtual Bool hasLock(FileLocker::LockType) const
casacore::PagedImage::removeRegion
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).
casacore::True
const Bool True
Definition: aipstype.h:43
casacore::PagedImage::itsAttrHandler
ImageAttrHandlerCasa itsAttrHandler
Definition: PagedImage.h:434
casacore::PagedImage::isPersistent
virtual Bool isPersistent() const
A PagedImage is always persistent.
casacore::PagedImage::resync
virtual void resync()
Resynchronize the PagedImage object with the table contents.
casacore::PagedImage::makeIter
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 ...
casacore::PagedImage::clearCache
virtual void clearCache()
Clears and frees up the caches, but the maximum allowed cache size is unchanged from when setCacheSiz...
casacore::PagedImage::PagedImage
PagedImage(const PagedImage< T > &other)
Copy constructor (reference semantics).
casacore::PagedImage::setCacheSizeFromPath
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.
casacore::RecordInterface
Abstract base class for Record classes.
Definition: RecordInterface.h:145
casacore::PagedImage::restoreImageInfo
void restoreImageInfo(const TableRecord &rec)
casacore::PagedImage::flush
virtual void flush()
Flush the data.
casacore::Lattice< Bool >
casacore::Array
template <class T, class U> class vector;
Definition: Array.h:167
casacore::String
String: the storage and methods of handling collections of characters.
Definition: String.h:223
casacore::PagedImage::PagedImage
PagedImage(const TiledShape &mapShape, const CoordinateSystem &coordinateInfo, const String &nameOfNewFile, uInt rowNumber=0)
Construct a new Image from shape and coordinate information.
casacore::PagedImage::doPutSlice
virtual void doPutSlice(const Array< T > &sourceBuffer, const IPosition &where, const IPosition &stride)
Function to replace the values in the map with soureBuffer.
casacore::Bool
bool Bool
Define the standard types used by Casacore.
Definition: aipstype.h:42
casacore::PagedImage::isPaged
virtual Bool isPaged() const
A PagedImage is always paged to disk.
casacore::ImageAttrHandler
Abstract base class for an image attributes handler.
Definition: ImageAttrHandler.h:92
casacore::Unit
defines physical units
Definition: Unit.h:189
casacore::PagedImage::setMaximumCacheSize
virtual void setMaximumCacheSize(uInt howManyPixels)
Set the maximum (allowed) cache size as indicated.
casacore::PagedImage::unlock
virtual void unlock()
casacore::imagePixelType
DataType imagePixelType(const String &fileName)
Determine the pixel type in the PagedImage contained in fileName.
casacore::PagedImage::restoreMiscInfo
void restoreMiscInfo(const TableRecord &rec)
casacore::PagedImage::getRegionPtr
virtual const LatticeRegion * getRegionPtr() const
Get a pointer the default pixelmask object used with this image.
casacore::PagedImage::getAt
virtual T getAt(const IPosition &where) const
These are the true implementations of the paran operator.
casacore::PagedImage::setDefaultMask
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).
casacore::PagedImage::setCacheSizeInTiles
virtual void setCacheSizeInTiles(uInt howManyTiles)
Set the actual cache size for this Array to be be big enough for the indicated number of tiles.
casacore::PagedImage::className
static String className()
Return the name of this derived class.
Definition: PagedImage.h:199
casacore::PagedImage::ok
virtual Bool ok() const
Check for symmetry in data members.
casacore::TiledShape
Define the shape and tile shape.
Definition: TiledShape.h:100
casacore::PagedImage::PagedImage
PagedImage(const TiledShape &mapShape, const CoordinateSystem &coordinateInfo, const String &nameOfNewFile, const TableLock &lockOptions, uInt rowNumber=0)
casacore::PagedImage::useMask
virtual void useMask(MaskSpecifier=MaskSpecifier())
Use the mask as specified.
casacore::ImageInfo
Miscellaneous information related to an image.
Definition: ImageInfo.h:93
casacore::PagedImage::apply
virtual void apply(T(*function)(T))
Replace every element, x, of the lattice with the result of f(x).
casacore::PagedImage::showCacheStatistics
virtual void showCacheStatistics(ostream &os) const
Report on cache success.
casacore::LatticeIterInterface
A base class for Lattice iterators.
Definition: ImageExpr.h:47
casacore::PagedImage::applyMaskSpecifier
void applyMaskSpecifier(const MaskSpecifier &)