source: trunk/src/SDMathWrapper.cc@ 304

Last change on this file since 304 was 300, checked in by kil064, 20 years ago

add resample wrappers
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 8.9 KB
Line 
1//#---------------------------------------------------------------------------
2//# SDMathWrapper.cc: Wrapper classes to use CountedPtr
3//#---------------------------------------------------------------------------
4//# Copyright (C) 2004
5//# ATNF
6//#
7//# This program is free software; you can redistribute it and/or modify it
8//# under the terms of the GNU General Public License as published by the Free
9//# Software Foundation; either version 2 of the License, or (at your option)
10//# any later version.
11//#
12//# This program is distributed in the hope that it will be useful, but
13//# WITHOUT ANY WARRANTY; without even the implied warranty of
14//# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
15//# Public License for more details.
16//#
17//# You should have received a copy of the GNU General Public License along
18//# with this program; if not, write to the Free Software Foundation, Inc.,
19//# 675 Massachusetts Ave, Cambridge, MA 02139, USA.
20//#
21//# Correspondence concerning this software should be addressed as follows:
22//# Internet email: Malte.Marquarding@csiro.au
23//# Postal address: Malte Marquarding,
24//# Australia Telescope National Facility,
25//# P.O. Box 76,
26//# Epping, NSW, 2121,
27//# AUSTRALIA
28//#
29//# $Id:
30//#---------------------------------------------------------------------------
31
32
33#include "SDMathWrapper.h"
34#include "SDMath.h"
35
36
37using namespace asap;
38using namespace casa;
39
40SDMemTableWrapper SDMathWrapper::quotient(const SDMemTableWrapper& on,
41 const SDMemTableWrapper& off,
42 Bool preserveContinuum)
43{
44 SDMath sdm;
45 Bool doTSys = True;
46 return SDMemTableWrapper(sdm.binaryOperate(on.getCP(), off.getCP(),
47 String("QUOTIENT"), preserveContinuum, doTSys));
48}
49
50
51SDMemTableWrapper SDMathWrapper::binaryOperate(const SDMemTableWrapper& left,
52 const SDMemTableWrapper& right,
53 const std::string& op, bool doTSys)
54{
55 SDMath sdm;
56 return SDMemTableWrapper(sdm.binaryOperate(left.getCP(), right.getCP(),
57 String(op), False, Bool(doTSys)));
58}
59
60
61void SDMathWrapper::scaleInSitu(SDMemTableWrapper& in, float factor, bool doAll, bool doTSys)
62{
63 SDMemTable* pIn = in.getPtr();
64 const uInt what = 0;
65//
66 SDMath sdm;
67 SDMemTable* pOut = sdm.unaryOperate (*pIn, Float(factor),
68 Bool(doAll), what, Bool(doTSys));
69 *pIn = *pOut;
70 delete pOut;
71}
72
73SDMemTableWrapper SDMathWrapper::scale(const SDMemTableWrapper& in,
74 float factor, bool doAll, bool doTSys)
75{
76 const CountedPtr<SDMemTable>& pIn = in.getCP();
77 const uInt what = 0;
78 SDMath sdm;
79 return CountedPtr<SDMemTable>(sdm.unaryOperate(*pIn, Float(factor), Bool(doAll),
80 what, Bool (doTSys)));
81}
82
83
84
85void SDMathWrapper::addInSitu(SDMemTableWrapper& in, float offset, bool doAll)
86{
87 SDMemTable* pIn = in.getPtr();
88 const uInt what = 1;
89//
90 SDMath sdm;
91 Bool doTSys = False;
92 SDMemTable* pOut = sdm.unaryOperate (*pIn, Float(offset),
93 Bool(doAll), what, doTSys);
94 *pIn = *pOut;
95 delete pOut;
96}
97
98SDMemTableWrapper SDMathWrapper::add(const SDMemTableWrapper& in,
99 float offset, bool doAll)
100{
101 const CountedPtr<SDMemTable>& pIn = in.getCP();
102 const uInt what = 1;
103 SDMath sdm;
104 Bool doTSys = False;
105 return CountedPtr<SDMemTable>(sdm.unaryOperate(*pIn, Float(offset),
106 Bool(doAll), what, doTSys));
107}
108
109
110void SDMathWrapper::smoothInSitu(SDMemTableWrapper& in,
111 const std::string& kernel, float width,
112 bool doAll)
113{
114 SDMemTable* pIn = in.getPtr();
115 SDMath sdm;
116 SDMemTable* pOut = sdm.smooth(*pIn, String(kernel),
117 Float(width), Bool(doAll));
118 *pIn = *pOut;
119 delete pOut;
120}
121
122
123SDMemTableWrapper SDMathWrapper::smooth (const SDMemTableWrapper& in,
124 const std::string& kernel,
125 float width, bool doAll)
126{
127 const CountedPtr<SDMemTable>& pIn = in.getCP();
128 SDMath sdm;
129 return CountedPtr<SDMemTable>(sdm.smooth(*pIn, String(kernel),
130 Float(width), Bool(doAll)));
131}
132
133
134
135void SDMathWrapper::binInSitu(SDMemTableWrapper& in, int width)
136{
137 SDMemTable* pIn = in.getPtr();
138 SDMath sdm;
139 SDMemTable* pOut = sdm.bin (*pIn, Int(width));
140 *pIn = *pOut;
141 delete pOut;
142}
143
144SDMemTableWrapper SDMathWrapper::bin (const SDMemTableWrapper& in,
145 int width)
146{
147 const CountedPtr<SDMemTable>& pIn = in.getCP();
148 SDMath sdm;
149 return CountedPtr<SDMemTable>(sdm.bin(*pIn, Int(width)));
150}
151
152void SDMathWrapper::resampleInSitu(SDMemTableWrapper& in, const std::string& method,
153 float width)
154{
155 SDMemTable* pIn = in.getPtr();
156 SDMath sdm;
157 SDMemTable* pOut = sdm.resample(*pIn, String(method), Float(width));
158 *pIn = *pOut;
159 delete pOut;
160}
161
162SDMemTableWrapper SDMathWrapper::resample (const SDMemTableWrapper& in,
163 const std::string& method, float width)
164{
165 const CountedPtr<SDMemTable>& pIn = in.getCP();
166 SDMath sdm;
167 return CountedPtr<SDMemTable>(sdm.resample(*pIn, String(method), Float(width)));
168}
169
170
171void SDMathWrapper::averagePolInSitu(SDMemTableWrapper& in,
172 const std::vector<bool>& mask)
173{
174 SDMemTable* pIn = in.getPtr();
175 SDMath sdm;
176 Vector<Bool> tMask(mask);
177 SDMemTable* pOut = sdm.averagePol (*pIn, tMask);
178 *pIn = *pOut;
179 delete pOut;
180}
181
182SDMemTableWrapper SDMathWrapper::averagePol (const SDMemTableWrapper& in,
183 const std::vector<bool>& mask)
184
185{
186 const CountedPtr<SDMemTable>& pIn = in.getCP();
187 SDMath sdm;
188 Vector<Bool> tMask(mask);
189 return CountedPtr<SDMemTable>(sdm.averagePol(*pIn, tMask));
190}
191
192
193std::vector<float> SDMathWrapper::statistic(const SDMemTableWrapper& in,
194 const std::vector<bool>& mask,
195 const std::string& which, int row)
196{
197 SDMath sdm;
198 Vector<Bool> tMask(mask);
199 return sdm.statistic(in.getCP(), tMask, String(which), Int(row));
200}
201
202
203void SDMathWrapper::convertFluxInSitu(SDMemTableWrapper& in,
204 float area, float eta, bool doAll)
205{
206 SDMemTable* pIn = in.getPtr();
207 SDMath sdm;
208 SDMemTable* pOut = sdm.convertFlux (*pIn, Float(area), Float(eta), Bool(doAll));
209 *pIn = *pOut;
210 delete pOut;
211}
212
213
214SDMemTableWrapper SDMathWrapper::convertFlux(const SDMemTableWrapper& in,
215 float area, float eta, bool doAll)
216{
217 const CountedPtr<SDMemTable>& pIn = in.getCP();
218 SDMath sdm;
219 return CountedPtr<SDMemTable>(sdm.convertFlux(*pIn, Float(area), Float(eta), Bool(doAll)));
220}
221
222
223void SDMathWrapper::gainElevationInSitu(SDMemTableWrapper& in,
224 const std::vector<float>& coeffs,
225 const string& fileName,
226 const string& method, bool doAll)
227{
228 SDMemTable* pIn = in.getPtr();
229 Vector<Float> tCoeffs(coeffs);
230 SDMath sdm;
231 SDMemTable* pOut = sdm.gainElevation(*pIn, tCoeffs, String(fileName),
232 String(method), Bool(doAll));
233 *pIn = *pOut;
234 delete pOut;
235}
236
237
238SDMemTableWrapper SDMathWrapper::gainElevation(const SDMemTableWrapper& in,
239 const std::vector<float>& coeffs,
240 const string& fileName,
241 const string& method, bool doAll)
242{
243 const CountedPtr<SDMemTable>& pIn = in.getCP();
244 Vector<Float> tCoeffs(coeffs);
245 SDMath sdm;
246 return CountedPtr<SDMemTable>(sdm.gainElevation(*pIn, tCoeffs, String(fileName),
247 String(method), Bool(doAll)));
248}
249
250void SDMathWrapper::velocityAlignmentInSitu (SDMemTableWrapper& in, const std::string& refTime)
251{
252 SDMemTable* pIn = in.getPtr();
253 SDMath sdm;
254 SDMemTable* pOut = sdm.velocityAlignment(*pIn, String(refTime));
255 *pIn = *pOut;
256 delete pOut;
257}
258
259
260SDMemTableWrapper SDMathWrapper::velocityAlignment (const SDMemTableWrapper& in,
261 const std::string& refTime)
262{
263 const CountedPtr<SDMemTable>& pIn = in.getCP();
264 SDMath sdm;
265 return CountedPtr<SDMemTable>(sdm.velocityAlignment(*pIn, String(refTime)));
266}
267
268void SDMathWrapper::opacityInSitu(SDMemTableWrapper& in, float tau, bool doAll)
269{
270 SDMemTable* pIn = in.getPtr();
271 SDMath sdm;
272 SDMemTable* pOut = sdm.opacity(*pIn, Float(tau), Bool(doAll));
273 *pIn = *pOut;
274 delete pOut;
275}
276
277
278SDMemTableWrapper SDMathWrapper::opacity(const SDMemTableWrapper& in,
279 float tau, bool doAll)
280{
281 const CountedPtr<SDMemTable>& pIn = in.getCP();
282 SDMath sdm;
283 return CountedPtr<SDMemTable>(sdm.opacity(*pIn, Float(tau), Bool(doAll)));
284}
285
Note: See TracBrowser for help on using the repository browser.