Line data Source code
1 : #include <stdcasa/StdCasa/CasacSupport.h>
2 : #include <casacore/casa/Arrays/ArrayMath.h>
3 : #include <casacore/casa/Exceptions/Error.h>
4 : #include <casacore/casa/Containers/Record.h>
5 : #include <casacore/casa/Containers/ValueHolder.h>
6 : #include <casacore/casa/Quanta/QuantumHolder.h>
7 : #include <casacore/casa/Quanta/MVAngle.h>
8 : #include <casacore/measures/Measures/MeasureHolder.h>
9 : #include <casacore/measures/Measures/MeasTable.h>
10 : #include <algorithm>
11 :
12 : using namespace casacore;
13 : namespace casa {
14 :
15 333839 : Vector<String> toVectorString(const std::vector<std::string> &theVec){
16 333839 : Vector<String> b(theVec.size());
17 1159760 : for(unsigned int i=0; i<theVec.size(); i++)
18 825921 : b[i] = String(theVec[i]);
19 667678 : return(b);
20 333839 : }
21 :
22 36497 : String toCasaString(const casac::variant& var){
23 :
24 36497 : String out;
25 : //Going around a bug of toString when its a string vector
26 36497 : if(var.type()==::casac::variant::STRINGVEC){
27 153 : Vector<String> outvec=toVectorString(var.toStringVec());
28 153 : if(outvec.nelements() >0)
29 153 : out=outvec[0];
30 179 : for (uInt k =1; k < outvec.nelements(); ++k){
31 26 : out=out+String(",")+outvec[k];
32 : }
33 153 : }
34 : else{
35 36344 : out=String(var.toString());
36 : }
37 : // [] protection
38 36497 : if (out.length()>1 && out.firstchar()=='[' && out.lastchar()==']')
39 15794 : out = out.substr(1,out.length()-2);
40 :
41 36497 : return out;
42 :
43 0 : }
44 :
45 321151 : std::vector<string> fromVectorString(const Vector<String> &theVec){
46 321151 : std::vector<string> b(theVec.size());
47 863989 : for(unsigned int i=0; i<theVec.size(); i++)
48 542838 : b[i] = theVec[i].c_str();
49 642302 : return(b);
50 321151 : }
51 :
52 2050 : casac::Quantity casacQuantity(const Quantity &quant){
53 4100 : casac::Quantity cquant(std::vector<double>(1,0.0), "");
54 2050 : cquant.value[0] = quant.getValue();
55 2050 : cquant.units = quant.getUnit().c_str();
56 2050 : return cquant;
57 0 : }
58 :
59 6455 : Quantity casaQuantity(const casac::Quantity &cquant){
60 6455 : if(cquant.value.size() < 1)
61 0 : throw(AipsError("Bad quantity conversion"));
62 12910 : return Quantity(cquant.value[0], Unit(cquant.units));
63 : }
64 :
65 907917 : Quantity casaQuantity(const casac::variant &theVar){
66 907917 : casacore::QuantumHolder qh;
67 907917 : String error;
68 :
69 : // Strange "defaults" like BOOLVECs can come in are expected to go out as
70 : // 0.0. Therefore unhandled types should produce a default Quantity, not an
71 : // exception.
72 907917 : Bool triedAndFailed = false;
73 :
74 907917 : const ::casac::variant::TYPE theType = theVar.type();
75 :
76 907917 : if(theType == ::casac::variant::STRING ||
77 : theType == ::casac::variant::STRINGVEC){
78 296223 : triedAndFailed = !qh.fromString(error, theVar.toString());
79 : }
80 611694 : else if(theType == ::casac::variant::RECORD){
81 : //NOW the record has to be compatible with QuantumHolder::toRecord
82 605656 : ::casac::variant localvar(theVar); // Because theVar is const.
83 605656 : std::unique_ptr<Record> ptrRec(toRecord(localvar.asRecord()));
84 :
85 605656 : triedAndFailed = !qh.fromRecord(error, *ptrRec);
86 605656 : }
87 6038 : else if(::casac::variant::compatible_type(theType, ::casac::variant::DOUBLE)
88 6038 : == ::casac::variant::DOUBLE){
89 4668 : const casacore::Unit unitless("_"); // Dimensionless
90 :
91 : //qh = casacore::QuantumHolder(casacore::Quantity(const_cast<Double &>(const_cast<casac::variant &>(theVar).asDouble()),
92 : //unitless));
93 4668 : qh = casacore::QuantumHolder(casacore::Quantity(const_cast<Double &>(const_cast<casac::variant &>(theVar).asDouble())));
94 :
95 4668 : triedAndFailed = false;
96 4668 : }
97 1370 : else if(::casac::variant::compatible_type(theType, ::casac::variant::COMPLEX)
98 1370 : == ::casac::variant::COMPLEX){
99 0 : const casacore::Unit unitless("_"); // Dimensionless
100 0 : const casacore::Complex casaVal(const_cast<casac::variant &>(theVar).asComplex());
101 :
102 : //qh = casacore::QuantumHolder(casacore::Quantum<casacore::Complex>(casaVal,
103 : //unitless));
104 0 : qh = casacore::QuantumHolder(casacore::Quantum<casacore::Complex>(casaVal));
105 0 : triedAndFailed = false;
106 0 : }
107 :
108 907917 : if(triedAndFailed){
109 25 : ostringstream oss;
110 :
111 25 : oss << "Error " << error << " in converting quantity";
112 25 : throw(AipsError(oss.str()));
113 25 : }
114 :
115 907892 : if(qh.isQuantum()){ // Remember casac::Quantity is a broader class
116 906522 : return qh.asQuantity(); // than casacore::Quantity, so use qh.isQuantum().
117 : }
118 : else{ // Probably variant's type was not handled above.
119 1370 : casacore::Quantity retval; // Defaults to 0.0.
120 :
121 1370 : return retval;
122 1370 : }
123 907942 : }
124 :
125 486 : Quantum<Vector<Double> > casaQuantumVector(const casac::variant& thevar){
126 972 : Quantum<Vector<Double> > retval(Vector<Double> (), Unit(""));
127 : //For now we know (at least till we have more time) how to deal with records only
128 486 : if(thevar.type() != ::casac::variant::RECORD){
129 0 : return retval;
130 : }
131 486 : ::casac::variant localvar(thevar); //cause its const
132 486 : std::unique_ptr<Record> ptrRec(toRecord(localvar.asRecord()));
133 486 : QuantumHolder qh;
134 486 : String error;
135 486 : if(qh.fromRecord(error, *ptrRec)){
136 : try {
137 486 : if(qh.isQuantumVectorDouble()){
138 243 : Quantum<Vector<Double> >retval1=qh.asQuantumVectorDouble();
139 243 : return retval1;
140 243 : }
141 : }
142 0 : catch(...){
143 0 : return retval;
144 0 : }
145 : }
146 :
147 243 : return retval;
148 486 : }
149 :
150 33 : Bool toCasaVectorQuantity(const ::casac::variant& theval, casacore::Vector<casacore::Quantity>& theQuants){
151 :
152 33 : casacore::Vector<casacore::String> lesStrings;
153 33 : if (theval.type()== ::casac::variant::STRING){
154 1 : sepCommaEmptyToVectorStrings(lesStrings, theval.toString());
155 : }
156 32 : else if(theval.type()== ::casac::variant::STRINGVEC){
157 : //Force resize as toStringVec sometimes give the wrong length (bug?)
158 32 : Vector<Int> leShape(theval.arrayshape());
159 32 : lesStrings=toVectorString(theval.toStringVec());
160 32 : lesStrings.resize(product(leShape), true);
161 32 : }
162 :
163 33 : casacore::QuantumHolder qh;
164 33 : String error;
165 33 : theQuants.resize(lesStrings.nelements());
166 98 : for (uInt k=0; k < lesStrings.nelements(); ++k){
167 : //Drat QuantumHolder does not handle pix
168 65 : if(lesStrings[k].contains("pix")){
169 0 : lesStrings[k]=lesStrings[k].before("pix");
170 0 : Double value=atof(lesStrings[k].chars());
171 0 : theQuants[k]=casacore::Quantity(value, "pix");
172 : }
173 : else{
174 65 : if(!qh.fromString(error, lesStrings[k])){
175 0 : ostringstream oss;
176 0 : oss << "Error " << error << " In converting quantity " << lesStrings[k];
177 0 : throw( AipsError(oss.str()));
178 0 : }
179 65 : theQuants[k]=qh.asQuantity();
180 :
181 :
182 : }
183 : }
184 :
185 33 : return true;
186 :
187 33 : }
188 :
189 277 : ::casac::record* recordFromQuantity(const Quantity q)
190 : {
191 277 : ::casac::record *r=0;
192 : try{
193 277 : String error;
194 277 : Record R;
195 277 : if(QuantumHolder(q).toRecord(error, R))
196 277 : r = fromRecord(R);
197 : else
198 0 : throw(AipsError("Could not convert quantity to record."));
199 277 : }
200 0 : catch(AipsError x){
201 0 : ostringstream oss;
202 :
203 0 : oss << "Exception Reported: " << x.getMesg();
204 0 : RETHROW(x);
205 0 : }
206 277 : return r;
207 : }
208 :
209 0 : ::casac::record* recordFromQuantity(const Quantum<Vector<Double> >& q)
210 : {
211 0 : ::casac::record *r=0;
212 : try {
213 0 : String error;
214 0 : casacore::Record R;
215 0 : if(QuantumHolder(q).toRecord(error, R))
216 0 : r = fromRecord(R);
217 : else
218 0 : throw(AipsError("Could not convert quantity to record."));
219 0 : }
220 0 : catch(AipsError x){
221 0 : ostringstream oss;
222 :
223 0 : oss << "Exception Reported: " << x.getMesg();
224 0 : RETHROW(x);
225 0 : }
226 0 : return r;
227 : }
228 :
229 : /*
230 : * Note to self, asArrayDouble doesn't cut it. We'll have to do asType and convert element by element,
231 : * sigh.....
232 : */
233 1381925 : ::casac::record *fromRecord(const Record &theRec){
234 1381925 : ::casac::record *transcribedRec = new ::casac::record();
235 5815911 : for(uInt i=0; i<theRec.nfields(); i++){
236 : // std::cerr << theRec.name(i) << " " << theRec.dataType(i) << std::endl;
237 4433986 : switch(theRec.dataType(i)){
238 43666 : case TpBool :
239 43666 : transcribedRec->insert(theRec.name(i).c_str(), theRec.asBool(i));
240 43666 : break;
241 0 : case TpChar :
242 : case TpUChar :
243 0 : transcribedRec->insert(theRec.name(i).c_str(), long(theRec.asuChar(i)));
244 0 : break;
245 0 : case TpShort :
246 : case TpUShort :
247 0 : transcribedRec->insert(theRec.name(i).c_str(), long(theRec.asShort(i)));
248 0 : break;
249 6035 : case TpUInt :
250 6035 : transcribedRec->insert(theRec.name(i).c_str(), (unsigned long) theRec.asuInt(i));
251 6035 : break;
252 318323 : case TpInt :
253 318323 : transcribedRec->insert(theRec.name(i).c_str(), long(theRec.asInt(i)));
254 318323 : break;
255 52789 : case TpInt64 :
256 : {
257 52789 : casac::variant val((long)theRec.asInt64(i));
258 52789 : transcribedRec->insert(theRec.name(i).c_str(), val);
259 52789 : }
260 52789 : break;
261 54297 : case TpFloat :
262 54297 : transcribedRec->insert(theRec.name(i).c_str(), double(theRec.asFloat(i)));
263 54297 : break;
264 1144342 : case TpDouble :
265 1144342 : transcribedRec->insert(theRec.name(i).c_str(), theRec.asDouble(i));
266 1144342 : break;
267 0 : case TpComplex :
268 0 : transcribedRec->insert(theRec.name(i).c_str(), DComplex(theRec.asComplex(i)));
269 0 : break;
270 0 : case TpDComplex :
271 0 : transcribedRec->insert(theRec.name(i).c_str(), theRec.asDComplex(i));
272 0 : break;
273 1572416 : case TpString :
274 1572416 : transcribedRec->insert(theRec.name(i).c_str(), theRec.asString(i));
275 1572416 : break;
276 0 : case TpTable :
277 0 : transcribedRec->insert(theRec.name(i).c_str(), theRec.asString(i));
278 0 : break;
279 286921 : case TpArrayBool :
280 : {
281 286921 : Array<Bool> tmpArray = theRec.asArrayBool(i);
282 : //Vector<ssize_t> tmpShape = (tmpArray.shape()).asVector();
283 286921 : Vector<ssize_t> tmpShape(tmpArray.shape( ).begin( ),tmpArray.shape( ).end( ));
284 : //std::cerr << "Vector Shape " << tmpShape << std::endl;
285 286921 : std::vector<ssize_t> vecShape;
286 286921 : tmpShape.tovector(vecShape);
287 : //std::cerr << "vector shape ";
288 : //for(int i=0;i<vecShape.size();i++)
289 : //std::cerr << vecShape[i] << " ";
290 : //std::cerr << std::endl;
291 286921 : std::vector<bool> tmpVec;
292 286921 : tmpArray.tovector(tmpVec);
293 286921 : transcribedRec->insert(theRec.name(i).c_str(), casac::variant(tmpVec, vecShape));
294 286921 : }
295 286921 : break;
296 157302 : case TpArrayChar :
297 : case TpArrayUChar :
298 : case TpArrayShort :
299 : case TpArrayUShort :
300 : case TpArrayInt :
301 : {
302 157302 : Array<int> tmpArray = theRec.asArrayInt(i);
303 157302 : Vector<Int> tmpShape = (tmpArray.shape()).asVector();
304 314604 : std::vector<ssize_t> vecShape(tmpShape.begin(),tmpShape.end());
305 157302 : std::vector<long> tmpVec;
306 1118259 : std::for_each( tmpArray.begin( ), tmpArray.end( ), [&](int v){tmpVec.push_back((long)v);} );
307 157302 : transcribedRec->insert(theRec.name(i).c_str(), casac::variant(tmpVec, vecShape));
308 157302 : }
309 157302 : break;
310 888 : case TpArrayUInt :
311 : {
312 888 : Array<uInt> tmpArray = theRec.asArrayuInt(i);
313 888 : Vector<Int> tmpShape = (tmpArray.shape()).asVector();
314 1776 : std::vector<ssize_t> vecShape(tmpShape.begin( ),tmpShape.end( ));
315 888 : std::vector<unsigned long> tmpVec;
316 16016 : std::for_each( tmpArray.begin( ), tmpArray.end( ), [&](uInt v){tmpVec.push_back((unsigned long)v);} );
317 888 : transcribedRec->insert(theRec.name(i).c_str(), casac::variant(tmpVec, vecShape));
318 888 : }
319 888 : break;
320 9696 : case TpArrayInt64 :
321 : {
322 9696 : Array<Int64> tmpArray = theRec.asArrayInt64(i);
323 9696 : Vector<Int> tmpShape = (tmpArray.shape()).asVector();
324 19392 : std::vector<ssize_t> vecShape(tmpShape.begin( ),tmpShape.end( ));
325 19392 : std::vector<long> tmpVec(tmpArray.begin(),tmpArray.end());
326 9696 : transcribedRec->insert(theRec.name(i).c_str(), casac::variant(tmpVec, vecShape));
327 9696 : }
328 9696 : break;
329 22318 : case TpArrayFloat :
330 : {
331 22318 : Array<Float> tmpArray = theRec.asArrayFloat(i);
332 22318 : Vector<Int> tmpShape = (tmpArray.shape()).asVector();
333 : //std::cerr << "Vector Shape " << tmpShape << std::endl;
334 44636 : std::vector<ssize_t> vecShape(tmpShape.begin( ),tmpShape.end( ));
335 22318 : std::vector<Float> tmpVec;
336 22318 : tmpArray.tovector(tmpVec);
337 22318 : std::vector<Double> dtmpVec(tmpVec.size());
338 5382131 : for(unsigned int j=0;j<tmpVec.size();j++)
339 5359813 : dtmpVec[j] = tmpVec[j];
340 22318 : transcribedRec->insert(theRec.name(i).c_str(), casac::variant(dtmpVec, vecShape));
341 22318 : }
342 22318 : break;
343 83639 : case TpArrayDouble :
344 : {
345 83639 : Array<Double> tmpArray = theRec.asArrayDouble(i);
346 83639 : Vector<Int> tmpShape = (tmpArray.shape()).asVector();
347 : //std::cerr << "Vector Shape " << tmpShape << std::endl;
348 167278 : std::vector<ssize_t> vecShape(tmpShape.begin( ),tmpShape.end( ));
349 83639 : std::vector<Double> tmpVec;
350 83639 : tmpArray.tovector(tmpVec);
351 83639 : transcribedRec->insert(theRec.name(i).c_str(), casac::variant(tmpVec, vecShape));
352 83639 : }
353 83639 : break;
354 118396 : case TpArrayComplex :
355 : {
356 118396 : Array<casacore::Complex> tmpArray = theRec.asArrayComplex(i);
357 118396 : Vector<Int> tmpShape = (tmpArray.shape()).asVector();
358 236792 : std::vector<ssize_t> vecShape(tmpShape.begin( ),tmpShape.end( ));
359 118396 : std::vector<casacore::Complex> tmpVec;
360 118396 : tmpArray.tovector(tmpVec);
361 118396 : std::vector<std::complex<double> > dtmpVec(tmpVec.size());
362 16813696 : for(unsigned int j=0;j<tmpVec.size();j++)
363 16695300 : dtmpVec[j] = tmpVec[j];
364 118396 : transcribedRec->insert(theRec.name(i).c_str(), casac::variant(dtmpVec, vecShape));
365 118396 : }
366 118396 : break;
367 0 : case TpArrayDComplex :
368 : {
369 0 : Array<DComplex> tmpArray = theRec.asArrayDComplex(i);
370 0 : Vector<Int> tmpShape = (tmpArray.shape()).asVector();
371 0 : std::vector<ssize_t> vecShape(tmpShape.begin( ),tmpShape.end( ));
372 0 : std::vector<DComplex> tmpVec;
373 0 : tmpArray.tovector(tmpVec);
374 0 : std::vector<std::complex <double> > dtmpVec(tmpVec.size());
375 0 : for(unsigned int j=0;j<tmpVec.size();j++)
376 0 : dtmpVec[j] = tmpVec[j];
377 0 : transcribedRec->insert(theRec.name(i).c_str(), casac::variant(dtmpVec, vecShape));
378 0 : }
379 0 : break;
380 43248 : case TpArrayString :
381 : {
382 43248 : Array<String> tmpArray = theRec.asArrayString(i);
383 43248 : Vector<Int> tmpShape = (tmpArray.shape()).asVector();
384 86496 : std::vector<ssize_t> vecShape(tmpShape.begin( ),tmpShape.end( ));
385 43248 : std::vector<casacore::String> tmpVec;
386 43248 : tmpArray.tovector(tmpVec);
387 43248 : std::vector<std::string> dtmpVec(tmpVec.size());
388 688301 : for(unsigned int j=0;j<tmpVec.size();j++)
389 645053 : dtmpVec[j] = tmpVec[j].c_str();
390 43248 : transcribedRec->insert(theRec.name(i).c_str(), casac::variant(dtmpVec, vecShape));
391 43248 : }
392 43248 : break;
393 519710 : case TpRecord :
394 : {
395 : //std::cerr << "fromRecord is Record" << std::endl;
396 519710 : casac::record *dummy = fromRecord(theRec.asRecord(i));
397 519710 : casac::variant dum2(dummy);
398 519710 : transcribedRec->insert(theRec.name(i).c_str(), dum2);
399 519710 : }
400 519710 : break;
401 0 : case TpOther :
402 0 : std::cerr << "casac::fromRecord TpOther, oops" << std::endl;
403 0 : break;
404 0 : case TpQuantity :
405 0 : std::cerr << "casac::fromRecord TpQuantity, oops" << std::endl;
406 0 : break;
407 0 : case TpArrayQuantity :
408 0 : std::cerr << "casac::fromRecord TpArrayQuantity, oops" << std::endl;
409 0 : break;
410 0 : default :
411 0 : std::cerr << "casac::fromRecord unknown type, oops" << std::endl;
412 0 : break;
413 : }
414 : }
415 1381925 : return transcribedRec;
416 : }
417 :
418 1329218 : Record *toRecord(const ::casac::record &theRec){
419 1329218 : Record *transcribedRec = new Record();
420 1329218 : casac::rec_map::const_iterator rec_end = theRec.end();
421 4339201 : for(::casac::rec_map::const_iterator rec_it = theRec.begin(); rec_it != rec_end; ++rec_it){
422 : //std::cerr << (*rec_it).first << " type is: " << (*rec_it).second.type() << std::endl;
423 3009983 : switch((*rec_it).second.type()){
424 319604 : case ::casac::variant::RECORD :
425 : {
426 319604 : std::unique_ptr<Record> tmpRecord(toRecord((*rec_it).second.getRecord()));
427 319604 : transcribedRec->defineRecord(RecordFieldId((*rec_it).first), *tmpRecord);
428 319604 : }
429 319604 : break;
430 31217 : case ::casac::variant::BOOL :
431 31217 : {transcribedRec->define(RecordFieldId((*rec_it).first), (*rec_it).second.toBool());}
432 31217 : break;
433 99937 : case ::casac::variant::INT :
434 99937 : {transcribedRec->define(RecordFieldId((*rec_it).first), Int((*rec_it).second.getInt()));}
435 99937 : break;
436 0 : case ::casac::variant::UINT :
437 0 : {transcribedRec->define(RecordFieldId((*rec_it).first), Int((*rec_it).second.getuInt()));}
438 0 : break;
439 989734 : case ::casac::variant::DOUBLE :
440 989734 : transcribedRec->define(RecordFieldId((*rec_it).first), (*rec_it).second.getDouble());
441 989734 : break;
442 0 : case ::casac::variant::COMPLEX :
443 0 : transcribedRec->define(RecordFieldId((*rec_it).first), (*rec_it).second.getComplex());
444 0 : break;
445 1469434 : case ::casac::variant::STRING :
446 1469434 : transcribedRec->define(RecordFieldId((*rec_it).first), (*rec_it).second.getString());
447 1469434 : break;
448 5483 : case ::casac::variant::BOOLVEC :
449 : {
450 5483 : Vector<Int> shapeVec((*rec_it).second.arrayshape());
451 5483 : Vector<Bool>boolVec((*rec_it).second.getBoolVec());
452 5483 : IPosition tshape(shapeVec);
453 5483 : Array<Bool> boolArr(tshape);
454 5483 : int i(0);
455 5483 : Array<Bool>::iterator boolArrend = boolArr.end();
456 5483 : for(Array<Bool>::iterator iter = boolArr.begin();
457 7688 : iter != boolArrend; ++iter)
458 7688 : *iter = boolVec[i++];
459 5483 : transcribedRec->define(RecordFieldId((*rec_it).first), boolArr);
460 5483 : }
461 5483 : break;
462 22078 : case ::casac::variant::INTVEC :
463 : {
464 22078 : Vector<Int> shapeVec((*rec_it).second.arrayshape());
465 22078 : Vector<Int> intVec((*rec_it).second.getIntVec());
466 22078 : IPosition tshape(shapeVec);
467 22078 : Array<Int> intArr(tshape);
468 22078 : int i(0);
469 22078 : Array<Int>::iterator intArrend = intArr.end();
470 22078 : for(Array<Int>::iterator iter = intArr.begin();
471 64027 : iter != intArrend; ++iter)
472 64027 : *iter = intVec[i++];
473 22078 : transcribedRec->define(RecordFieldId((*rec_it).first), intArr);
474 22078 : }
475 22078 : break;
476 0 : case ::casac::variant::UINTVEC :
477 : {
478 0 : Vector<Int> shapeVec((*rec_it).second.arrayshape());
479 0 : Vector<uInt> uintVec((*rec_it).second.getuIntVec());
480 0 : IPosition tshape(shapeVec);
481 0 : Array<uInt> intArr(tshape);
482 0 : int i(0);
483 0 : Array<uInt>::iterator intArrend = intArr.end();
484 0 : for(Array<uInt>::iterator iter = intArr.begin();
485 0 : iter != intArrend; ++iter)
486 0 : *iter = uintVec[i++];
487 0 : transcribedRec->define(RecordFieldId((*rec_it).first), intArr);
488 0 : }
489 0 : break;
490 51699 : case ::casac::variant::DOUBLEVEC :
491 : {
492 51699 : Vector<Double> doubleVec((*rec_it).second.getDoubleVec());
493 51699 : Vector<Int> shapeVec((*rec_it).second.arrayshape());
494 51699 : IPosition tshape(shapeVec);
495 51699 : Array<Double> doubleArr(tshape);
496 51699 : int i(0);
497 51699 : Array<Double>::iterator doubleArrEnd = doubleArr.end();
498 51699 : for(Array<Double>::iterator iter = doubleArr.begin();
499 385238 : iter != doubleArrEnd; ++iter)
500 385238 : *iter = doubleVec[i++];
501 51699 : transcribedRec->define(RecordFieldId((*rec_it).first), doubleArr);
502 51699 : }
503 51699 : break;
504 0 : case ::casac::variant::COMPLEXVEC :
505 : {
506 0 : Vector<DComplex> complexVec((*rec_it).second.getComplexVec());
507 0 : Vector<Int> shapeVec((*rec_it).second.arrayshape());
508 0 : IPosition tshape(shapeVec);
509 0 : Array<DComplex> complexArr(tshape);
510 0 : Array<DComplex>::iterator complexArrEnd = complexArr.end();
511 0 : int i(0);
512 0 : for(Array<DComplex>::iterator iter = complexArr.begin();
513 0 : iter != complexArrEnd; ++iter)
514 0 : *iter = complexVec[i++];
515 0 : transcribedRec->define(RecordFieldId((*rec_it).first), complexArr);
516 0 : }
517 0 : break;
518 20797 : case ::casac::variant::STRINGVEC :
519 : {
520 20797 : Vector<Int> shapeVec((*rec_it).second.arrayshape());
521 20797 : std::vector<std::string> tmp = (*rec_it).second.getStringVec();
522 20797 : const Array<String> &stringArr(toVectorString(tmp));
523 : //stringArr.reform(IPosition(shapeVec));
524 20797 : transcribedRec->define(RecordFieldId((*rec_it).first), stringArr);
525 : //transcribedRec->define((*rec_it).first, Vector<String>((*rec_it).second.getStringVec()));
526 20797 : }
527 20797 : break;
528 0 : default :
529 0 : std::cerr << "Unknown type: " << (*rec_it).second.type() << std::endl;
530 0 : break;
531 : }
532 : }
533 1329218 : return transcribedRec;
534 : }
535 :
536 5746036 : casac::variant *fromValueHolder(const ValueHolder &theVH){
537 5746036 : casac::variant *theV(0);
538 5746036 : if(!theVH.isNull()){
539 5746036 : switch(theVH.dataType()){
540 20 : case TpBool :
541 20 : theV = new casac::variant(theVH.asBool());
542 20 : break;
543 0 : case TpUChar :
544 0 : theV = new casac::variant((long)theVH.asuChar());
545 0 : break;
546 0 : case TpShort :
547 0 : theV = new casac::variant((long)theVH.asShort());
548 0 : break;
549 0 : case TpUShort :
550 0 : theV = new casac::variant((long)theVH.asuShort());
551 0 : break;
552 670641 : case TpInt :
553 670641 : theV = new casac::variant((long)theVH.asInt());
554 670641 : break;
555 0 : case TpUInt :
556 0 : theV = new casac::variant((unsigned long)theVH.asuInt());
557 0 : break;
558 0 : case TpInt64 :
559 0 : theV = new casac::variant((long)theVH.asInt64());
560 0 : break;
561 6 : case TpFloat :
562 6 : theV = new casac::variant(theVH.asFloat());
563 6 : break;
564 7707 : case TpDouble :
565 7707 : theV = new casac::variant(theVH.asDouble());
566 7707 : break;
567 0 : case TpComplex :
568 0 : theV = new casac::variant(theVH.asComplex());
569 0 : break;
570 0 : case TpDComplex :
571 0 : theV = new casac::variant(theVH.asDComplex());
572 0 : break;
573 2406 : case TpString :
574 2406 : theV = new casac::variant(theVH.asString().c_str());
575 2406 : break;
576 51356 : case TpArrayBool :
577 : {
578 51356 : Array<Bool> tArr(theVH.asArrayBool());
579 51356 : Vector<Int> ts = tArr.shape().asVector();
580 102712 : std::vector<ssize_t> tShape(ts.begin( ),ts.end( ));
581 51356 : std::vector<bool> tData;
582 51356 : tArr.tovector(tData);
583 51356 : theV = new casac::variant(tData, tShape);
584 51356 : }
585 51356 : break;
586 0 : case TpArrayUChar :
587 : {
588 0 : Array<uChar> tArr(theVH.asArrayuChar());
589 0 : Vector<Int> ts = tArr.shape().asVector();
590 0 : std::vector<ssize_t> tShape(ts.begin( ),ts.end( ));
591 0 : std::vector<uChar> tData;
592 0 : tArr.tovector(tData);
593 0 : std::vector<long> tD(tData.size());
594 0 : for(unsigned int i=0;i<tData.size();i++)
595 0 : tD[i] = tData[i];
596 0 : theV = new casac::variant(tD, tShape);
597 0 : }
598 0 : break;
599 0 : case TpArrayShort :
600 : {
601 0 : Array<Short> tArr(theVH.asArrayShort());
602 0 : Vector<Int> ts = tArr.shape().asVector();
603 0 : std::vector<ssize_t> tShape(ts.begin( ),ts.end( ));
604 0 : std::vector<Short> tData;
605 0 : tArr.tovector(tData);
606 0 : std::vector<long> tD(tData.size());
607 0 : for(unsigned int i=0;i<tData.size();i++)
608 0 : tD[i] = tD[i];
609 0 : theV = new casac::variant(tD, tShape);
610 0 : }
611 0 : break;
612 0 : case TpArrayUShort :
613 : {
614 0 : Array<uShort> tArr(theVH.asArrayuShort());
615 0 : Vector<Int> ts = tArr.shape().asVector();
616 0 : std::vector<ssize_t> tShape(ts.begin( ),ts.end( ));
617 0 : std::vector<uShort> tData;
618 0 : tArr.tovector(tData);
619 0 : std::vector<long> tD(tData.size());
620 0 : for(unsigned int i=0;i<tData.size();i++)
621 0 : tD[i] = tData[i];
622 0 : theV = new casac::variant(tD, tShape);
623 0 : }
624 0 : break;
625 6336 : case TpArrayInt :
626 : {
627 6336 : Array<Int> tArr(theVH.asArrayInt());
628 6336 : Vector<Int> ts = tArr.shape().asVector();
629 : //std::cerr << "Vector Shape " << ts << std::endl;
630 12672 : std::vector<ssize_t> tShape(ts.begin( ),ts.end( ));
631 6336 : std::vector<long> tData;
632 41887176 : std::for_each( tArr.begin( ), tArr.end( ), [&](Int v){tData.push_back((long)v);} );
633 6336 : theV = new casac::variant(tData, tShape);
634 6336 : }
635 6336 : break;
636 146 : case TpArrayUInt :
637 : {
638 146 : Array<uInt> tArr(theVH.asArrayuInt());
639 146 : Vector<Int> ts = tArr.shape().asVector();
640 292 : std::vector<ssize_t> tShape(ts.begin( ),ts.end( ));
641 146 : std::vector<unsigned long> tData;
642 526 : std::for_each( tArr.begin( ), tArr.end( ), [&](Int v){tData.push_back((unsigned long)v);} );
643 146 : theV = new casac::variant(tData, tShape);
644 146 : }
645 146 : break;
646 153595 : case TpArrayFloat :
647 : {
648 153595 : Array<Float> tArr(theVH.asArrayFloat());
649 153595 : Vector<Int> ts = tArr.shape().asVector();
650 : //std::cerr << ts << std::endl;
651 : //std::cerr << "Vector Shape " << ts << std::endl;
652 307190 : std::vector<ssize_t> tShape(ts.begin( ),ts.end( ));
653 153595 : std::vector<float> tData;
654 153595 : tArr.tovector(tData);
655 153595 : std::vector<double> tD(tData.size());
656 343583365 : for(unsigned int i=0;i<tData.size();i++)
657 343429770 : tD[i] = tData[i];
658 153595 : theV = new casac::variant(tD, tShape);
659 153595 : }
660 153595 : break;
661 13158 : case TpArrayDouble :
662 : {
663 13158 : Array<Double> tArr(theVH.asArrayDouble());
664 13158 : Vector<Int> ts = tArr.shape().asVector();
665 : //std::cerr << "Vector Shape " << ts << std::endl;
666 26316 : std::vector<ssize_t> tShape(ts.begin( ),ts.end( ));
667 13158 : std::vector<double> tData;
668 13158 : tArr.tovector(tData);
669 13158 : theV = new casac::variant(tData, tShape);
670 13158 : }
671 13158 : break;
672 4836392 : case TpArrayComplex :
673 : {
674 4836392 : Array<Complex> tArr(theVH.asArrayComplex());
675 4836392 : Vector<Int> ts = tArr.shape().asVector();
676 9672784 : std::vector<ssize_t> tShape(ts.begin( ),ts.end( ));
677 4836392 : std::vector<std::complex<float> > tData;
678 4836392 : tArr.tovector(tData);
679 4836392 : std::vector<std::complex<double> > tD(tData.size());
680 1143004594 : for(unsigned int i=0;i<tData.size();i++)
681 1138168202 : tD[i] = tData[i];
682 4836392 : theV = new casac::variant(tD, tShape);
683 4836392 : }
684 4836392 : break;
685 22 : case TpArrayDComplex :
686 : {
687 22 : Array<DComplex> tArr(theVH.asArrayDComplex());
688 22 : Vector<Int> ts = tArr.shape().asVector();
689 44 : std::vector<ssize_t> tShape(ts.begin( ),ts.end( ));
690 22 : std::vector<std::complex<double> > tData;
691 22 : tArr.tovector(tData);
692 22 : theV = new casac::variant(tData, tShape);
693 22 : }
694 22 : break;
695 2942 : case TpArrayString :
696 : {
697 : // Truly ugly...
698 2942 : Array<String> tArr(theVH.asArrayString());
699 2942 : Vector<Int> ts = tArr.shape().asVector();
700 5884 : std::vector<ssize_t> tShape(ts.begin( ),ts.end( ));
701 2942 : std::vector<String> tData;
702 2942 : tArr.tovector(tData);
703 2942 : std::vector<string> tData2(tData.size());
704 1540508 : for(unsigned int i=0; i<tData.size(); i++)
705 1537566 : tData2[i] = tData[i].c_str();
706 2942 : theV = new casac::variant(tData2, tShape);
707 2942 : }
708 2942 : break;
709 1309 : case TpRecord :
710 1309 : theV = new casac::variant(fromRecord(theVH.asRecord()));
711 1309 : break;
712 0 : default :
713 0 : throw(AipsError("Unknown casa DataType!"));
714 : break;
715 : }
716 : }
717 5746036 : return theV;
718 : }
719 :
720 : // I have some doubts about this, we may need to avoid the const ness of the variant
721 : // if we run into some speed issues.
722 : //
723 7085472 : ValueHolder *toValueHolder(const casac::variant &theV){
724 7085472 : ValueHolder *theVH(0);
725 7085472 : std::unique_ptr<Record> tmpRec;
726 7085472 : switch(theV.type()){
727 111 : case casac::variant::RECORD :
728 111 : tmpRec.reset(toRecord(theV.getRecord()));
729 111 : theVH = new ValueHolder(*tmpRec);
730 111 : break;
731 23 : case casac::variant::BOOL :
732 23 : theVH = new ValueHolder(theV.getBool());
733 23 : break;
734 71777 : case casac::variant::INT :
735 : /*** need range check ***/
736 71777 : theVH = new ValueHolder((int)theV.getInt());
737 71777 : break;
738 4807 : case casac::variant::DOUBLE :
739 4807 : theVH = new ValueHolder(theV.getDouble());
740 4807 : break;
741 0 : case casac::variant::COMPLEX :
742 0 : theVH = new ValueHolder(theV.getComplex());
743 0 : break;
744 6536 : case casac::variant::STRING :
745 6536 : theVH = new ValueHolder(theV.getString());
746 6536 : break;
747 799191 : case casac::variant::BOOLVEC :
748 : {
749 799191 : Vector<Bool> boolVec(theV.getBoolVec());
750 799191 : Vector<Int>shapeVec(theV.arrayshape());
751 799191 : IPosition tshape(shapeVec);
752 799191 : Array<Bool> tVec(tshape);
753 799191 : int i(0);
754 799191 : Array<Bool>::iterator tVecEnd = tVec.end();
755 799191 : for(Array<Bool>::iterator iter = tVec.begin();
756 77748456 : iter != tVecEnd; ++iter)
757 77748456 : *iter = boolVec[i++];
758 799191 : theVH = new ValueHolder(tVec);
759 799191 : }
760 799191 : break;
761 1407 : case casac::variant::INTVEC :
762 : {
763 1407 : Vector<Int> intVec(theV.getIntVec());
764 1407 : Vector<Int>shapeVec(theV.arrayshape());
765 1407 : IPosition tshape(shapeVec);
766 1407 : Array<Int> tVec(tshape);
767 1407 : int i(0);
768 1407 : Array<Int>::iterator tVecEnd = tVec.end();
769 1407 : for(Array<Int>::iterator iter = tVec.begin();
770 5690494 : iter != tVecEnd; ++iter)
771 5690494 : *iter = intVec[i++];
772 1407 : theVH = new ValueHolder(tVec);
773 1407 : }
774 1407 : break;
775 3321740 : case casac::variant::DOUBLEVEC :
776 : {
777 3321740 : Vector<Double> doubleVec(theV.getDoubleVec());
778 3321740 : Vector<Int>shapeVec(theV.arrayshape());
779 3321740 : IPosition tshape(shapeVec);
780 3321740 : Array<Double> tVec(tshape);
781 3321740 : Array<Double>::iterator tVecEnd = tVec.end();
782 3321740 : int i(0);
783 3321740 : for(Array<Double>::iterator iter = tVec.begin();
784 117140299 : iter != tVecEnd; ++iter)
785 117140299 : *iter = doubleVec[i++];
786 3321740 : theVH = new ValueHolder(tVec);
787 3321740 : }
788 3321740 : break;
789 2879363 : case casac::variant::COMPLEXVEC :
790 : {
791 2879363 : Vector<DComplex> complexVec(theV.getComplexVec());
792 2879363 : Vector<Int>shapeVec(theV.arrayshape());
793 2879363 : IPosition tshape(shapeVec);
794 2879363 : Array<DComplex> tVec(tshape);
795 2879363 : Array<DComplex>::iterator tVecEnd = tVec.end();
796 2879363 : int i(0);
797 2879363 : for(Array<DComplex>::iterator iter = tVec.begin();
798 111361431 : iter != tVecEnd; ++iter)
799 111361431 : *iter = complexVec[i++];
800 2879363 : theVH = new ValueHolder(tVec);
801 2879363 : }
802 2879363 : break;
803 517 : case casac::variant::STRINGVEC :
804 : // Unclear whether this may leak
805 : {
806 517 : std::vector<std::string> tmp = theV.getStringVec();
807 517 : Vector<String> stringArr(toVectorString(tmp));
808 517 : Vector<Int>shapeVec(theV.arrayshape());
809 517 : IPosition tshape(shapeVec);
810 517 : Array<String> tVec(tshape);
811 517 : int i(0);
812 517 : Array<String>::iterator tVecEnd = tVec.end();
813 517 : for(Array<String>::iterator iter = tVec.begin();
814 451656 : iter != tVecEnd; ++iter)
815 451656 : *iter = stringArr[i++];
816 517 : theVH = new ValueHolder(tVec);
817 517 : }
818 517 : break;
819 0 : default :
820 0 : throw(AipsError("Unknown variant type!"));
821 : break;
822 : }
823 7085472 : return theVH;
824 7085472 : }
825 :
826 1095 : Bool casaMDirection(const ::casac::variant& theVar,
827 : MDirection& theMeas){
828 :
829 1095 : casacore::MeasureHolder mh;
830 1095 : casacore::QuantumHolder qh;
831 1095 : String error;
832 1095 : if(theVar.type()== ::casac::variant::RECORD){
833 24 : ::casac::variant localvar(theVar); //cause its const
834 24 : std::unique_ptr<Record> ptrRec(toRecord(localvar.asRecord()));
835 24 : if(mh.fromRecord(error, *ptrRec)){
836 24 : theMeas=mh.asMDirection();
837 24 : return true;
838 : }
839 : else{
840 0 : ostringstream oss;
841 0 : oss << "Error " << error << " in converting Direction parameter";
842 0 : throw( AipsError(oss.str()));
843 : return false;
844 0 : }
845 24 : }
846 1101 : if(theVar.type()== ::casac::variant::STRING ||
847 30 : theVar.type()== ::casac::variant::STRINGVEC){
848 1071 : Vector<String> str;
849 : //In case of compound strings with commas or empty space
850 1071 : if (theVar.type()== ::casac::variant::STRING){
851 1041 : sepCommaEmptyToVectorStrings(str, theVar.toString());
852 : }
853 : else{
854 30 : str=toVectorString(theVar.toStringVec());
855 : }
856 1071 : if(str.nelements()==3){
857 1070 : qh.fromString(error, str[1]);
858 1070 : casacore::Quantity val1=qh.asQuantity();
859 1069 : qh.fromString(error, str[2]);
860 1069 : casacore::Quantity val2=qh.asQuantity();
861 1069 : if(val2.getFullUnit()==Unit("deg") && str[2].contains(":")){
862 16 : ostringstream oss;
863 16 : oss << "NOTE: you provided the Declination/Latitude value \""<< str[2]
864 : << "\" which is understood to be in units of hours.\n"
865 16 : << " If you meant degrees, please replace \":\" by \".\".";
866 16 : cerr << oss.str() << endl;
867 16 : }
868 : MDirection::Types tp;
869 1069 : if(!MDirection::getType(tp, str[0])){
870 6 : ostringstream oss;
871 6 : oss << "Could not understand Direction frame...defaulting to J2000 " ;
872 6 : cerr << oss.str() << endl;
873 6 : tp=MDirection::J2000;
874 6 : }
875 1069 : theMeas=MDirection(val1,val2, tp);
876 1069 : return true;
877 1069 : }
878 1 : else if(str.nelements()==2){
879 0 : qh.fromString(error, str[0]);
880 0 : casacore::Quantity val1=qh.asQuantity();
881 0 : qh.fromString(error, str[1]);
882 0 : casacore::Quantity val2=qh.asQuantity();
883 0 : if(val2.getFullUnit()==Unit("deg") && str[1].contains(":")){
884 0 : ostringstream oss;
885 0 : oss << "NOTE: you provided the Declination/Latitude value \""<< str[2]
886 : << "\" which is understood to be in units of hours.\n"
887 0 : << " If you meant degrees, please replace \":\" by \".\".";
888 0 : cerr << oss.str() << endl;
889 0 : }
890 0 : theMeas=MDirection(val1, val2);
891 0 : return true;
892 0 : }
893 1 : else if(str.nelements()==1){
894 : //Must be a string like sun, moon, jupiter
895 1 : casacore::Quantity val1(0.0, "deg");
896 1 : casacore::Quantity val2(90.0, "deg");
897 1 : theMeas=MDirection(val1, val2);
898 : MDirection::Types ref;
899 : Int numAll;
900 : Int numExtra;
901 : const uInt *dum;
902 1 : const String *allTypes=MDirection::allMyTypes(numAll, numExtra, dum);
903 : //if it is SUN moon etc
904 1 : if(MDirection::getType(ref,str[0])){
905 :
906 1 : theMeas=MDirection(val1, val2, ref);
907 1 : return true;
908 : }
909 0 : if(MeasTable::Source(theMeas, str[0])){
910 0 : return true;
911 : }
912 0 : if(!MDirection::getType(ref, str[0])){
913 0 : Vector<String> all(numExtra);
914 0 : for(Int k =0; k < numExtra; ++k){
915 0 : all[k]=*(allTypes+numAll-k-1);
916 : }
917 0 : ostringstream oss;
918 0 : oss << "Could not understand Direction string " <<str[0] << "\n" ;
919 0 : oss << "Valid ones are " << all;
920 0 : cerr << oss.str() << " or one of the valid known sources in the data repos" << endl;
921 0 : theMeas=MDirection(val1, val2);
922 0 : return false;
923 0 : }
924 :
925 2 : }
926 :
927 1071 : }
928 : ///If i am here i don't know how to interprete this
929 :
930 :
931 0 : return false;
932 1097 : }
933 :
934 : //Bool ang_as_formatted_str(string& out, const casacore::Quantity& qang,
935 : // const std::string& format)
936 : //{
937 : // return ang_as_formatted_str(out,qang,format,precision=2);
938 : //}
939 :
940 6907 : Bool ang_as_formatted_str(string& out, const casacore::Quantity& qang,
941 : const std::string& format, const Int precision=2)
942 : {
943 6907 : Bool retval = true;
944 :
945 : try{
946 : //hms, dms, deg, rad, +deg.
947 6907 : casacore::String form(format);
948 6907 : form.downcase();
949 :
950 6907 : Int ndig=6+precision;
951 :
952 6907 : MVAngle ang(qang);
953 6907 : if(form == "dms"){
954 2970 : out = ang(-0.5).string(MVAngle::ANGLE, ndig+1).c_str();
955 : }
956 3937 : else if(form == "hms"){
957 3937 : out = ang.string(MVAngle::TIME, ndig).c_str();
958 : }
959 0 : else if(form == "deg"){
960 0 : ostringstream os;
961 0 : os << ang().degree();
962 0 : out = os.str();
963 0 : }
964 0 : else if(form == "rad"){
965 0 : ostringstream os;
966 0 : os << ang().radian();
967 0 : out = os.str();
968 0 : }
969 0 : else if(form == "+deg"){
970 0 : ostringstream os;
971 0 : os << ang(0.0).degree();
972 0 : out = os.str();
973 0 : }
974 : else{
975 0 : retval = false; // Format not understood - return false instead of
976 : // throwing an exception.
977 : }
978 6907 : }
979 0 : catch(AipsError x){
980 0 : retval = false;
981 0 : RETHROW(x);
982 0 : }
983 6907 : return retval;
984 : }
985 :
986 0 : Bool MDirection2str(const MDirection& in, std::string& out)
987 : {
988 0 : Quantum<Vector<Double> > lonlat(in.getAngle());
989 0 : Vector<Double> lonlatval(lonlat.getValue());
990 0 : Unit inunit(lonlat.getUnit());
991 0 : string refcode(in.getRefString());
992 :
993 0 : casacore::Quantity qlon(lonlatval[0], inunit);
994 0 : casacore::Quantity qlat(lonlatval[1], inunit);
995 :
996 0 : string lon("");
997 0 : string lat("");
998 : Bool success;
999 0 : if(refcode == "J2000" || refcode[0] == 'B'){
1000 0 : success = ang_as_formatted_str(lon, qlon, "hms", 2);
1001 0 : success = success && ang_as_formatted_str(lat, qlat, "dms", 2);
1002 : }
1003 : else{
1004 0 : success = ang_as_formatted_str(lon, qlon, "deg", 2);
1005 0 : success = success && ang_as_formatted_str(lat, qlat, "deg", 2);
1006 : }
1007 :
1008 0 : if(success)
1009 0 : out = refcode + " " + lon + " " + lat;
1010 0 : return success;
1011 0 : }
1012 :
1013 15547 : Bool casaMFrequency(const ::casac::variant& theVar,
1014 : MFrequency& theMeas){
1015 15547 : casacore::MeasureHolder mh;
1016 15547 : casacore::QuantumHolder qh;
1017 15547 : String error;
1018 15547 : if(theVar.type()== ::casac::variant::RECORD){
1019 81 : ::casac::variant localvar(theVar); //cause its const
1020 81 : std::unique_ptr<Record> ptrRec(toRecord(localvar.asRecord()));
1021 81 : if(mh.fromRecord(error, *ptrRec)){
1022 0 : theMeas=mh.asMFrequency();
1023 0 : return true;
1024 : }
1025 : else{//could be a quantity
1026 81 : if(qh.fromRecord(error, *ptrRec)){
1027 81 : theMeas=MFrequency(qh.asQuantity());
1028 81 : return true;
1029 : }
1030 : else{
1031 0 : ostringstream oss;
1032 0 : oss << "Error " << error
1033 0 : << "In converting Frequency parameter";
1034 0 : throw( AipsError(oss.str()));
1035 : return false;
1036 0 : }
1037 : }
1038 81 : }
1039 30885 : if(theVar.type()== ::casac::variant::STRING ||
1040 15419 : theVar.type()== ::casac::variant::STRINGVEC){
1041 79 : Vector<String> str;
1042 79 : if (theVar.type()== ::casac::variant::STRING){
1043 47 : sepCommaEmptyToVectorStrings(str, theVar.toString());
1044 : }
1045 : else{
1046 32 : str=toVectorString(theVar.toStringVec());
1047 : }
1048 79 : if(str.nelements()==2){
1049 40 : qh.fromString(error, str[1]);
1050 40 : casacore::Quantity val=qh.asQuantity();
1051 : MFrequency::Types tp;
1052 40 : if(!MFrequency::getType(tp, str[0])){
1053 :
1054 3 : cerr << "Could not understand frequency frame..defaulting to LSRK "
1055 3 : << endl;
1056 3 : tp=MFrequency::LSRK;
1057 3 : qh.fromString(error, str[0]+str[1]);
1058 3 : val=qh.asQuantity();
1059 : }
1060 40 : theMeas=MFrequency(val, tp);
1061 40 : return true;
1062 40 : }
1063 39 : else if(str.nelements()==1){
1064 39 : if(str[0]=="")
1065 0 : return false;
1066 39 : qh.fromString(error, str[0]);
1067 39 : theMeas=MFrequency(qh.asQuantity());
1068 39 : return true;
1069 : }
1070 79 : }
1071 : ///If i am here then it can be an integer or double then using Hz
1072 15387 : theMeas=MFrequency(casacore::Quantity(theVar.toDouble(), "Hz"));
1073 :
1074 :
1075 15387 : return true;
1076 :
1077 15547 : }
1078 :
1079 38 : Bool casaMPosition(const ::casac::variant& theVar,
1080 : MPosition& theMeas){
1081 38 : casacore::MeasureHolder mh;
1082 38 : casacore::QuantumHolder qh;
1083 38 : String error;
1084 38 : if(theVar.type()== ::casac::variant::RECORD){
1085 38 : ::casac::variant localvar(theVar); //cause its const
1086 38 : std::unique_ptr<Record> ptrRec(toRecord(localvar.asRecord()));
1087 38 : if(mh.fromRecord(error, *ptrRec)){
1088 38 : theMeas=mh.asMPosition();
1089 38 : return true;
1090 : }
1091 : else{
1092 0 : ostringstream oss;
1093 0 : oss << "Error " << error << "In converting Position parameter";
1094 0 : throw( AipsError(oss.str()));
1095 : return false;
1096 0 : }
1097 38 : }
1098 0 : if(theVar.type()== ::casac::variant::STRING ||
1099 0 : theVar.type()== ::casac::variant::STRINGVEC){
1100 0 : Vector<String> str;
1101 0 : if (theVar.type()== ::casac::variant::STRING){
1102 0 : sepCommaEmptyToVectorStrings(str, theVar.toString());
1103 : }
1104 : else{
1105 0 : str=toVectorString(theVar.toStringVec());
1106 : }
1107 0 : if(str.nelements()==4){
1108 0 : qh.fromString(error, str[1]);
1109 0 : casacore::Quantity val1=qh.asQuantity();
1110 0 : qh.fromString(error, str[2]);
1111 0 : casacore::Quantity val2=qh.asQuantity();
1112 0 : qh.fromString(error, str[3]);
1113 0 : casacore::Quantity val3=qh.asQuantity();
1114 : MPosition::Types tp;
1115 0 : if(!MPosition::getType(tp, str[0])){
1116 0 : cerr << "Could not understand Position frame...defaulting to ITRF"
1117 0 : << endl;
1118 0 : tp=MPosition::ITRF;
1119 : }
1120 0 : theMeas=MPosition(val1, val2, val3, tp);
1121 0 : return true;
1122 0 : }
1123 0 : else if(str.nelements()==3){
1124 0 : qh.fromString(error, str[0]);
1125 0 : casacore::Quantity val1=qh.asQuantity();
1126 0 : qh.fromString(error, str[1]);
1127 0 : casacore::Quantity val2=qh.asQuantity();
1128 0 : qh.fromString(error, str[2]);
1129 0 : casacore::Quantity val3=qh.asQuantity();
1130 0 : theMeas=MPosition(val1, val2, val3);
1131 0 : return true;
1132 0 : }
1133 0 : else if(str.nelements()==1){
1134 : //must be an observatory string hopefully
1135 0 : str[0].upcase();
1136 0 : if(casacore::MeasTable::Observatory(theMeas, str[0])){
1137 0 : return true;
1138 : }
1139 : else{
1140 0 : throw( AipsError("Could not understand Position parameter"));
1141 : return false;
1142 : }
1143 : }
1144 0 : }
1145 : ///If i am here i don't know how to interprete this
1146 :
1147 :
1148 0 : return false;
1149 :
1150 :
1151 38 : }
1152 :
1153 :
1154 3 : Bool casaMRadialVelocity(const ::casac::variant& theVar,
1155 : MRadialVelocity& theMeas){
1156 3 : casacore::MeasureHolder mh;
1157 3 : casacore::QuantumHolder qh;
1158 3 : String error;
1159 3 : if(theVar.type()== ::casac::variant::RECORD){
1160 0 : ::casac::variant localvar(theVar); //cause its const
1161 0 : std::unique_ptr<Record> ptrRec(toRecord(localvar.asRecord()));
1162 0 : if(mh.fromRecord(error, *ptrRec)){
1163 0 : theMeas=mh.asMRadialVelocity();
1164 0 : return true;
1165 : }
1166 : else{//could be a quantity
1167 0 : if(qh.fromRecord(error, *ptrRec)){
1168 0 : theMeas=MRadialVelocity(qh.asQuantity());
1169 0 : return true;
1170 : }
1171 : else{
1172 0 : ostringstream oss;
1173 0 : oss << "Error " << error
1174 0 : << "In converting Radial velocity parameter";
1175 0 : throw( AipsError(oss.str()));
1176 : return false;
1177 0 : }
1178 : }
1179 0 : }
1180 6 : if(theVar.type()== ::casac::variant::STRING ||
1181 3 : theVar.type()== ::casac::variant::STRINGVEC){
1182 3 : Vector<String> str;
1183 3 : if (theVar.type()== ::casac::variant::STRING){
1184 0 : sepCommaEmptyToVectorStrings(str, theVar.toString());
1185 : }
1186 : else{
1187 3 : str=toVectorString(theVar.toStringVec());
1188 : }
1189 3 : if(str.nelements()==2){
1190 3 : qh.fromString(error, str[1]);
1191 3 : casacore::Quantity val=qh.asQuantity();
1192 : MRadialVelocity::Types tp;
1193 3 : if(!MRadialVelocity::getType(tp, str[0])){
1194 0 : cerr << "Could not understand velocity frame..defaulting to LSRK "
1195 0 : << endl;
1196 0 : tp=MRadialVelocity::LSRK;
1197 : }
1198 3 : theMeas=MRadialVelocity(val, tp);
1199 3 : return true;
1200 3 : }
1201 0 : else if(str.nelements()==1){
1202 0 : if(str[0]=="")
1203 0 : return false;
1204 0 : qh.fromString(error, str[0]);
1205 0 : theMeas=MRadialVelocity(qh.asQuantity());
1206 0 : return true;
1207 : }
1208 3 : }
1209 : ///If i am here then it can be an integer or double then using m/s
1210 0 : theMeas=MRadialVelocity(casacore::Quantity(theVar.toDouble(), "m/s"));
1211 :
1212 0 : return true;
1213 3 : }
1214 :
1215 31 : Bool casaMEpoch(const ::casac::variant& theVar,
1216 : MEpoch& theMeas){
1217 :
1218 31 : casacore::MeasureHolder mh;
1219 31 : casacore::QuantumHolder qh;
1220 31 : String error;
1221 31 : if(theVar.type()== ::casac::variant::RECORD){
1222 31 : ::casac::variant localvar(theVar); //cause its const
1223 31 : std::unique_ptr<Record> ptrRec(toRecord(localvar.asRecord()));
1224 31 : if(mh.fromRecord(error, *ptrRec)){
1225 31 : theMeas=mh.asMEpoch();
1226 31 : return true;
1227 : }
1228 : else{//could be a quantity
1229 0 : if(qh.fromRecord(error, *ptrRec)){
1230 0 : theMeas=MEpoch(qh.asQuantity());
1231 0 : return true;
1232 : }
1233 : else{
1234 0 : ostringstream oss;
1235 0 : oss << "Error " << error
1236 0 : << "In converting Epoch parameter";
1237 0 : throw( AipsError(oss.str()));
1238 : return false;
1239 0 : }
1240 : }
1241 31 : }
1242 0 : if(theVar.type()== ::casac::variant::STRING ||
1243 0 : theVar.type()== ::casac::variant::STRINGVEC){
1244 0 : Vector<String> str;
1245 0 : if (theVar.type()== ::casac::variant::STRING){
1246 0 : sepCommaEmptyToVectorStrings(str, theVar.toString());
1247 : }
1248 : else{
1249 0 : str=toVectorString(theVar.toStringVec());
1250 : }
1251 0 : if(str.nelements()==2){
1252 0 : qh.fromString(error, str[1]);
1253 0 : casacore::Quantity val=qh.asQuantity();
1254 : MEpoch::Types tp;
1255 0 : if(!MEpoch::getType(tp, str[0])){
1256 0 : cerr << "Could not understand epoch frame...defaulting to UTC "
1257 0 : << endl;
1258 0 : tp=MEpoch::UTC;
1259 : }
1260 0 : theMeas=MEpoch(val, tp);
1261 0 : return true;
1262 0 : }
1263 0 : else if(str.nelements()==1){
1264 0 : if(str[0]=="")
1265 0 : return false;
1266 0 : qh.fromString(error, str[0]);
1267 0 : theMeas=MEpoch(qh.asQuantity());
1268 0 : return true;
1269 : }
1270 0 : }
1271 : ///If i am here then it can be an integer or double then using days
1272 0 : theMeas=MEpoch(casacore::Quantity(theVar.toDouble(), "d"));
1273 :
1274 :
1275 0 : return true;
1276 :
1277 :
1278 31 : }
1279 1105 : Int sepCommaEmptyToVectorStrings(Vector<String>& lesStrings,
1280 : const std::string& str){
1281 :
1282 1105 : casacore::String oneStr=String(str);
1283 1105 : Int nsep=0;
1284 : // decide if its comma seperated or empty space seperated
1285 1105 : casacore::String sep;
1286 1105 : if((nsep=oneStr.freq(",")) > 0){
1287 3 : sep=",";
1288 : }
1289 : else {
1290 1102 : nsep=oneStr.freq(" ");
1291 1102 : sep=" ";
1292 : }
1293 1105 : if(nsep == 0){
1294 50 : lesStrings.resize(1);
1295 50 : lesStrings=oneStr;
1296 50 : nsep=1;
1297 : }
1298 : else{
1299 4215 : String *splitstrings = new String[nsep+1];
1300 1055 : nsep=split(oneStr, splitstrings, nsep+1, sep);
1301 1055 : lesStrings.resize(nsep);
1302 1055 : Int index=0;
1303 4215 : for (Int k=0; k < nsep; ++k){
1304 3160 : if((String(splitstrings[k]) == String(""))
1305 3160 : || (String(splitstrings[k]) == String(" "))){
1306 0 : lesStrings.resize(lesStrings.nelements()-1, true);
1307 : }
1308 : else{
1309 3160 : lesStrings[index]=splitstrings[k];
1310 3160 : ++index;
1311 : }
1312 : }
1313 5270 : delete [] splitstrings;
1314 : }
1315 :
1316 1105 : return nsep;
1317 :
1318 1105 : }
1319 :
1320 116 : Int sepCommaToVectorStrings(Vector<String>& lesStrings,
1321 : const std::string& str){
1322 :
1323 116 : casacore::String oneStr=String(str);
1324 : // decide if its comma seperated or empty space seperated
1325 116 : String sep=",";
1326 116 : Int nsep=oneStr.freq(sep);
1327 116 : if(nsep == 0){
1328 112 : lesStrings.resize(1);
1329 112 : lesStrings=oneStr;
1330 112 : nsep=1;
1331 : }
1332 : else{
1333 12 : String *splitstrings = new String[nsep+1];
1334 4 : nsep=split(oneStr, splitstrings, nsep+1, sep);
1335 4 : lesStrings.resize(nsep);
1336 4 : Int index=0;
1337 12 : for (Int k=0; k < nsep; ++k){
1338 8 : if((String(splitstrings[k]) == String(""))
1339 8 : || (String(splitstrings[k]) == String(" "))){
1340 0 : lesStrings.resize(lesStrings.nelements()-1, true);
1341 : }
1342 : else{
1343 8 : lesStrings[index]=splitstrings[k];
1344 8 : ++index;
1345 : }
1346 : }
1347 16 : delete [] splitstrings;
1348 : }
1349 :
1350 116 : return nsep;
1351 :
1352 116 : }
1353 :
1354 1023 : vector<double> toVectorDouble(const casac::variant& v, const String& varName) {
1355 1023 : vector<double> ret(0);
1356 1023 : switch (v.type()) {
1357 545 : case casac::variant::BOOLVEC:
1358 545 : return ret;
1359 0 : case casac::variant::INT:
1360 : case casac::variant::DOUBLE:
1361 0 : ret.push_back(v.toDouble());
1362 0 : return ret;
1363 478 : case casac::variant::INTVEC:
1364 : case casac::variant::DOUBLEVEC:
1365 478 : return v.toDoubleVec();
1366 0 : case casac::variant::STRING:
1367 0 : if (v.toString().size() > 0) {
1368 0 : throw AipsError(varName + " cannot be a non-empty string");
1369 : }
1370 : else {
1371 0 : return ret;
1372 : }
1373 0 : default:
1374 0 : ostringstream os;
1375 0 : os << "Illegal type for " << varName << ": " << v.type();
1376 0 : throw AipsError(os.str());
1377 : }
1378 1023 : }
1379 :
1380 279 : vector<string> toVectorString(const ::casac::variant& v, const String& varName) {
1381 279 : vector<string> ret(0);
1382 279 : switch (v.type()) {
1383 77 : case casac::variant::BOOLVEC:
1384 77 : return ret;
1385 201 : case casac::variant::STRING:
1386 201 : if (v.toString().size() > 0) {
1387 0 : ret.push_back(v.toString());
1388 : }
1389 201 : return ret;
1390 1 : case casac::variant::STRINGVEC:
1391 1 : return v.toStringVec();
1392 0 : default:
1393 0 : ostringstream os;
1394 0 : os << "Illegal type for " << varName;
1395 0 : throw AipsError(os.str());
1396 : }
1397 279 : }
1398 :
1399 2 : vector<int> toVectorInt(const ::casac::variant& v, const String& varName) {
1400 2 : vector<int> ret(0);
1401 2 : switch (v.type()) {
1402 0 : case casac::variant::BOOLVEC:
1403 0 : return ret;
1404 2 : case casac::variant::INT:
1405 2 : ret.push_back(v.toInt());
1406 2 : return ret;
1407 0 : case casac::variant::INTVEC: {
1408 0 : auto input = v.toIntVec( );
1409 0 : std::vector<int> ret;
1410 0 : std::for_each( input.begin( ), input.end( ), [&](long x){ret.push_back((int)x);} );
1411 0 : return ret; }
1412 0 : case casac::variant::STRING:
1413 0 : if (v.toString().size() > 0) {
1414 0 : throw AipsError(varName + " cannot be a non-empty string");
1415 : }
1416 : else {
1417 0 : return ret;
1418 : }
1419 0 : default:
1420 0 : ostringstream os;
1421 0 : os << "Illegal type for " << varName << ": " << v.type();
1422 0 : throw AipsError(os.str());
1423 : }
1424 2 : }
1425 :
1426 186 : vector<bool> toVectorBool(const ::casac::variant& v, const String& varName) {
1427 186 : vector<bool> ret(0);
1428 186 : switch (v.type()) {
1429 186 : case casac::variant::BOOLVEC:
1430 186 : return v.toBoolVec();
1431 0 : case casac::variant::BOOL:
1432 0 : ret.push_back(v.toBool());
1433 0 : return ret;
1434 0 : case casac::variant::STRING:
1435 0 : if (v.toString().size() > 0) {
1436 0 : throw AipsError(varName + " cannot be a non-empty string");
1437 : }
1438 : else {
1439 0 : return ret;
1440 : }
1441 0 : default:
1442 0 : ostringstream os;
1443 0 : os << "Illegal type for " << varName << ": " << v.type();
1444 0 : throw AipsError(os.str());
1445 : }
1446 186 : }
1447 0 : Vector<String> toCasaVectorString(const vector<string>& vs) {
1448 0 : Vector<String> res(vs.size());
1449 0 : vector<string>::const_iterator vsiter = vs.begin();
1450 0 : Vector<String>::iterator resiter = res.begin();
1451 0 : vector<string>::const_iterator end = vs.end();
1452 0 : while (vsiter != end) {
1453 0 : *resiter = *vsiter;
1454 0 : resiter++;
1455 0 : vsiter++;
1456 : }
1457 0 : return res;
1458 0 : }
1459 :
1460 :
1461 :
1462 : using namespace casacore;
1463 : } // End namespace casa
|
