source: trunk/src/SDMathWrapper.cc@ 298

Last change on this file since 298 was 295, checked in by kil064, 20 years ago

track some small changes to SDMath interface (addition of
doTSys arg here and there)
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 8.3 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
152
153void SDMathWrapper::averagePolInSitu(SDMemTableWrapper& in,
154 const std::vector<bool>& mask)
155{
156 SDMemTable* pIn = in.getPtr();
157 SDMath sdm;
158 Vector<Bool> tMask(mask);
159 SDMemTable* pOut = sdm.averagePol (*pIn, tMask);
160 *pIn = *pOut;
161 delete pOut;
162}
163
164SDMemTableWrapper SDMathWrapper::averagePol (const SDMemTableWrapper& in,
165 const std::vector<bool>& mask)
166
167{
168 const CountedPtr<SDMemTable>& pIn = in.getCP();
169 SDMath sdm;
170 Vector<Bool> tMask(mask);
171 return CountedPtr<SDMemTable>(sdm.averagePol(*pIn, tMask));
172}
173
174
175std::vector<float> SDMathWrapper::statistic(const SDMemTableWrapper& in,
176 const std::vector<bool>& mask,
177 const std::string& which, int row)
178{
179 SDMath sdm;
180 Vector<Bool> tMask(mask);
181 return sdm.statistic(in.getCP(), tMask, String(which), Int(row));
182}
183
184
185void SDMathWrapper::convertFluxInSitu(SDMemTableWrapper& in,
186 float area, float eta, bool doAll)
187{
188 SDMemTable* pIn = in.getPtr();
189 SDMath sdm;
190 SDMemTable* pOut = sdm.convertFlux (*pIn, Float(area), Float(eta), Bool(doAll));
191 *pIn = *pOut;
192 delete pOut;
193}
194
195
196SDMemTableWrapper SDMathWrapper::convertFlux(const SDMemTableWrapper& in,
197 float area, float eta, bool doAll)
198{
199 const CountedPtr<SDMemTable>& pIn = in.getCP();
200 SDMath sdm;
201 return CountedPtr<SDMemTable>(sdm.convertFlux(*pIn, Float(area), Float(eta), Bool(doAll)));
202}
203
204
205void SDMathWrapper::gainElevationInSitu(SDMemTableWrapper& in,
206 const std::vector<float>& coeffs,
207 const string& fileName,
208 const string& method, bool doAll)
209{
210 SDMemTable* pIn = in.getPtr();
211 Vector<Float> tCoeffs(coeffs);
212 SDMath sdm;
213 SDMemTable* pOut = sdm.gainElevation(*pIn, tCoeffs, String(fileName),
214 String(method), Bool(doAll));
215 *pIn = *pOut;
216 delete pOut;
217}
218
219
220SDMemTableWrapper SDMathWrapper::gainElevation(const SDMemTableWrapper& in,
221 const std::vector<float>& coeffs,
222 const string& fileName,
223 const string& method, bool doAll)
224{
225 const CountedPtr<SDMemTable>& pIn = in.getCP();
226 Vector<Float> tCoeffs(coeffs);
227 SDMath sdm;
228 return CountedPtr<SDMemTable>(sdm.gainElevation(*pIn, tCoeffs, String(fileName),
229 String(method), Bool(doAll)));
230}
231
232void SDMathWrapper::velocityAlignmentInSitu (SDMemTableWrapper& in, const std::string& refTime)
233{
234 SDMemTable* pIn = in.getPtr();
235 SDMath sdm;
236 SDMemTable* pOut = sdm.velocityAlignment(*pIn, String(refTime));
237 *pIn = *pOut;
238 delete pOut;
239}
240
241
242SDMemTableWrapper SDMathWrapper::velocityAlignment (const SDMemTableWrapper& in,
243 const std::string& refTime)
244{
245 const CountedPtr<SDMemTable>& pIn = in.getCP();
246 SDMath sdm;
247 return CountedPtr<SDMemTable>(sdm.velocityAlignment(*pIn, String(refTime)));
248}
249
250void SDMathWrapper::opacityInSitu(SDMemTableWrapper& in, float tau, bool doAll)
251{
252 SDMemTable* pIn = in.getPtr();
253 SDMath sdm;
254 SDMemTable* pOut = sdm.opacity(*pIn, Float(tau), Bool(doAll));
255 *pIn = *pOut;
256 delete pOut;
257}
258
259
260SDMemTableWrapper SDMathWrapper::opacity(const SDMemTableWrapper& in,
261 float tau, bool doAll)
262{
263 const CountedPtr<SDMemTable>& pIn = in.getCP();
264 SDMath sdm;
265 return CountedPtr<SDMemTable>(sdm.opacity(*pIn, Float(tau), Bool(doAll)));
266}
267
Note: See TracBrowser for help on using the repository browser.