casa  5.7.0-16
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
ImageOpener.h
Go to the documentation of this file.
1 //# ImageOpener.h: A class with static functions to open an image of any type
2 //# Copyright (C) 2005
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 //#
27 //# $Id$
28 
29 #ifndef IMAGES_IMAGEOPENER_H
30 #define IMAGES_IMAGEOPENER_H
31 
32 
33 #include <casacore/casa/aips.h>
36 #include <map>
37 
38 namespace casacore { //# NAMESPACE CASACORE - BEGIN
39 
40 //# Forward Declarations
41 class LatticeBase;
42 class LatticeExprNode;
43 class JsonKVMap;
44 
45 // <summary>
46 // Definition of image types and handlers
47 // </summary>
48 //
49 // <use visibility=local>
50 //
51 // <reviewed reviewer="" date="yyyy/mm/dd" tests="" demos="">
52 // </reviewed>
53 //
54 // <synopsis>
55 // The class contains defines the possible image types.
56 // It contains a registry containing functions to construct an image
57 // based on its type. In this way any image can be used in the image package
58 // without the need that the code must reside in the images package.
59 // </synopsis>
60 //
61 // <motivation>
62 // FITS and MIRIAD needed to be moved out of the images package.
63 // </motivation>
64 
65 
67 {
68 public:
69 // Define the possible image types.
70  enum ImageTypes {
71  // Casacore (former AIPS++)
73  // FITS
75  // Miriad
77  // Gipsy
79  // Classic AIPS
81  // Newstar
83  // HDF5
85  // ImageConcat
87  // ImageExpr
89  // ComponentListImage, CASA
91  // Unknown
93  };
94 
95  // Return the type of an image with the given name. Will throw an
96  // exception if file does not exist.
97  static ImageTypes imageType (const String& fileName);
98 
99  // Define the signature of a function opening an image.
100  // Each basic image class (like FITSImage) must have a static open function
101  // with this signature.
102  // They can be registered using registerOpenImageFunction.
103  // In this way a function like openImage can create any image object
104  // without the need that all image classes are in the images package.
105  // The LogIO object can be used for possible error reporting or logging.
106  typedef LatticeBase* OpenImageFunction (const String& fileName,
107  const MaskSpecifier&);
108 
109  // Register an openImageFunction.
111 
112  // Open an image in the file/table with the given name.
113  // The specified mask will be applied (default is default mask).
114  // A null pointer is returned for an unknown image type.
115  // Non-Casacore image types must have been registered to be known.
116  // Note that class ImageProxy has a function to open an image from a file
117  // or from an image expression.
118  static LatticeBase* openImage (const String& fileName,
119  const MaskSpecifier& = MaskSpecifier());
120 
121  // Open a Casacore paged image of any data type.
122  static LatticeBase* openPagedImage (const String& fileName,
123  const MaskSpecifier& = MaskSpecifier());
124 
125  // Open an HDF5 paged image of any data type.
126  static LatticeBase* openHDF5Image (const String& fileName,
127  const MaskSpecifier& = MaskSpecifier());
128 
129  // Open a persistent image concatenation of any type.
130  static LatticeBase* openImageConcat (const String& fileName);
131 
132  // Open a persistent image expression of any type.
133  // It reads the file written by ImageExpr::save.
134  static LatticeBase* openImageExpr (const String& fileName);
135 
136  // Parse an image expression and return the ImageExpr<T> object for it.
137  // The block of nodes represents optional $i arguments in the expression.
138  // The JsonKVMap gives the keys found in a persistent image.expr file.
139  static LatticeBase* openExpr (const String& expr,
140  const Block<LatticeExprNode>& nodes,
141  const String& fileName = String());
142  static LatticeBase* openExpr (const String& expr,
143  const Block<LatticeExprNode>& nodes,
144  const String& fileName,
145  const JsonKVMap&);
146 
147 private:
148  // Mapping of the image type to an openImage function.
149  static std::map<ImageTypes,OpenImageFunction*> theirOpenFuncMap;
150 };
151 
152 
153 } //# NAMESPACE CASACORE - END
154 
155 #endif
static std::map< ImageTypes, OpenImageFunction * > theirOpenFuncMap
Mapping of the image type to an openImage function.
Definition: ImageOpener.h:149
LatticeBase * OpenImageFunction(const String &fileName, const MaskSpecifier &)
Define the signature of a function opening an image.
Definition: ImageOpener.h:106
static LatticeBase * openImage(const String &fileName, const MaskSpecifier &=MaskSpecifier())
Open an image in the file/table with the given name.
static ImageTypes imageType(const String &fileName)
Return the type of an image with the given name.
static LatticeBase * openExpr(const String &expr, const Block< LatticeExprNode > &nodes, const String &fileName=String())
Parse an image expression and return the ImageExpr&lt;T&gt; object for it.
static LatticeBase * openImageConcat(const String &fileName)
Open a persistent image concatenation of any type.
A non-templated, abstract base class for array-like objects.
Definition: LatticeBase.h:80
ComponentListImage, CASA.
Definition: ImageOpener.h:90
Class to specify which mask to use in an image.
Definition: MaskSpecifier.h:69
Class to hold a collection of JSON key:value pairs.
Definition: JsonKVMap.h:72
ImageTypes
Define the possible image types.
Definition: ImageOpener.h:70
Definition of image types and handlers.
Definition: ImageOpener.h:66
static void registerOpenImageFunction(ImageTypes, OpenImageFunction *)
Register an openImageFunction.
simple 1-D array
Casacore (former AIPS++)
Definition: ImageOpener.h:72
String: the storage and methods of handling collections of characters.
Definition: String.h:223
static LatticeBase * openHDF5Image(const String &fileName, const MaskSpecifier &=MaskSpecifier())
Open an HDF5 paged image of any data type.
static LatticeBase * openImageExpr(const String &fileName)
Open a persistent image expression of any type.
static LatticeBase * openPagedImage(const String &fileName, const MaskSpecifier &=MaskSpecifier())
Open a Casacore paged image of any data type.
#define casacore
&lt;X11/Intrinsic.h&gt; #defines true, false, casacore::Bool, and String.
Definition: X11Intrinsic.h:42