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 301970 : Vector<String> toVectorString(const std::vector<std::string> &theVec){
16 301970 : Vector<String> b(theVec.size());
17 1049308 : for(unsigned int i=0; i<theVec.size(); i++)
18 747338 : b[i] = String(theVec[i]);
19 301970 : return(b);
20 : }
21 :
22 36259 : String toCasaString(const casac::variant& var){
23 :
24 36259 : String out;
25 : //Going around a bug of toString when its a string vector
26 36259 : if(var.type()==::casac::variant::STRINGVEC){
27 318 : Vector<String> outvec=toVectorString(var.toStringVec());
28 159 : if(outvec.nelements() >0)
29 159 : out=outvec[0];
30 185 : for (uInt k =1; k < outvec.nelements(); ++k){
31 26 : out=out+String(",")+outvec[k];
32 : }
33 : }
34 : else{
35 36100 : out=String(var.toString());
36 : }
37 : // [] protection
38 36259 : if (out.length()>1 && out.firstchar()=='[' && out.lastchar()==']')
39 15908 : out = out.substr(1,out.length()-2);
40 :
41 36259 : return out;
42 :
43 : }
44 :
45 289506 : std::vector<string> fromVectorString(const Vector<String> &theVec){
46 289506 : std::vector<string> b(theVec.size());
47 793207 : for(unsigned int i=0; i<theVec.size(); i++)
48 503701 : b[i] = theVec[i].c_str();
49 289506 : return(b);
50 : }
51 :
52 2034 : casac::Quantity casacQuantity(const Quantity &quant){
53 4068 : casac::Quantity cquant(std::vector<double>(1,0.0), "");
54 2034 : cquant.value[0] = quant.getValue();
55 2034 : cquant.units = quant.getUnit().c_str();
56 2034 : return cquant;
57 : }
58 :
59 6446 : Quantity casaQuantity(const casac::Quantity &cquant){
60 6446 : if(cquant.value.size() < 1)
61 0 : throw(AipsError("Bad quantity conversion"));
62 6446 : return Quantity(cquant.value[0], Unit(cquant.units));
63 : }
64 :
65 866734 : Quantity casaQuantity(const casac::variant &theVar){
66 1733468 : casacore::QuantumHolder qh;
67 1733468 : 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 866734 : Bool triedAndFailed = false;
73 :
74 866734 : const ::casac::variant::TYPE theType = theVar.type();
75 :
76 866734 : if(theType == ::casac::variant::STRING ||
77 : theType == ::casac::variant::STRINGVEC){
78 289932 : triedAndFailed = !qh.fromString(error, theVar.toString());
79 : }
80 576802 : else if(theType == ::casac::variant::RECORD){
81 : //NOW the record has to be compatible with QuantumHolder::toRecord
82 1141746 : ::casac::variant localvar(theVar); // Because theVar is const.
83 570873 : std::unique_ptr<Record> ptrRec(toRecord(localvar.asRecord()));
84 :
85 570873 : triedAndFailed = !qh.fromRecord(error, *ptrRec);
86 : }
87 5929 : else if(::casac::variant::compatible_type(theType, ::casac::variant::DOUBLE)
88 5929 : == ::casac::variant::DOUBLE){
89 4605 : const casacore::Unit unitless("_"); // Dimensionless
90 :
91 : //qh = casacore::QuantumHolder(casacore::Quantity(const_cast<Double &>(const_cast<casac::variant &>(theVar).asDouble()),
92 : //unitless));
93 4605 : qh = casacore::QuantumHolder(casacore::Quantity(const_cast<Double &>(const_cast<casac::variant &>(theVar).asDouble())));
94 :
95 4605 : triedAndFailed = false;
96 : }
97 1324 : else if(::casac::variant::compatible_type(theType, ::casac::variant::COMPLEX)
98 1324 : == ::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 : }
107 :
108 866734 : if(triedAndFailed){
109 50 : ostringstream oss;
110 :
111 25 : oss << "Error " << error << " in converting quantity";
112 25 : throw(AipsError(oss.str()));
113 : }
114 :
115 866709 : if(qh.isQuantum()){ // Remember casac::Quantity is a broader class
116 865385 : return qh.asQuantity(); // than casacore::Quantity, so use qh.isQuantum().
117 : }
118 : else{ // Probably variant's type was not handled above.
119 2648 : casacore::Quantity retval; // Defaults to 0.0.
120 :
121 1324 : return retval;
122 : }
123 : }
124 :
125 486 : Quantum<Vector<Double> > casaQuantumVector(const casac::variant& thevar){
126 1458 : 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 972 : ::casac::variant localvar(thevar); //cause its const
132 972 : std::unique_ptr<Record> ptrRec(toRecord(localvar.asRecord()));
133 972 : QuantumHolder qh;
134 972 : String error;
135 486 : if(qh.fromRecord(error, *ptrRec)){
136 : try {
137 486 : if(qh.isQuantumVectorDouble()){
138 486 : Quantum<Vector<Double> >retval1=qh.asQuantumVectorDouble();
139 243 : return retval1;
140 : }
141 : }
142 0 : catch(...){
143 0 : return retval;
144 : }
145 : }
146 :
147 243 : return retval;
148 : }
149 :
150 33 : Bool toCasaVectorQuantity(const ::casac::variant& theval, casacore::Vector<casacore::Quantity>& theQuants){
151 :
152 66 : 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 64 : Vector<Int> leShape(theval.arrayshape());
159 32 : lesStrings=toVectorString(theval.toStringVec());
160 32 : lesStrings.resize(product(leShape), true);
161 : }
162 :
163 66 : 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 : }
179 65 : theQuants[k]=qh.asQuantity();
180 :
181 :
182 : }
183 : }
184 :
185 66 : return true;
186 :
187 : }
188 :
189 277 : ::casac::record* recordFromQuantity(const Quantity q)
190 : {
191 277 : ::casac::record *r=0;
192 : try{
193 554 : String error;
194 554 : 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 : }
200 0 : catch(AipsError x){
201 0 : ostringstream oss;
202 :
203 0 : oss << "Exception Reported: " << x.getMesg();
204 0 : RETHROW(x);
205 : }
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 : }
220 0 : catch(AipsError x){
221 0 : ostringstream oss;
222 :
223 0 : oss << "Exception Reported: " << x.getMesg();
224 0 : RETHROW(x);
225 : }
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 1225000 : ::casac::record *fromRecord(const Record &theRec){
234 1225000 : ::casac::record *transcribedRec = new ::casac::record();
235 5147947 : for(uInt i=0; i<theRec.nfields(); i++){
236 : // std::cerr << theRec.name(i) << " " << theRec.dataType(i) << std::endl;
237 3922947 : switch(theRec.dataType(i)){
238 43272 : case TpBool :
239 43272 : transcribedRec->insert(theRec.name(i).c_str(), theRec.asBool(i));
240 43272 : 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 4983 : case TpUInt :
250 4983 : transcribedRec->insert(theRec.name(i).c_str(), (unsigned long) theRec.asuInt(i));
251 4983 : break;
252 230430 : case TpInt :
253 230430 : transcribedRec->insert(theRec.name(i).c_str(), long(theRec.asInt(i)));
254 230430 : break;
255 52785 : case TpInt64 :
256 : {
257 52785 : casac::variant val((long)theRec.asInt64(i));
258 52785 : transcribedRec->insert(theRec.name(i).c_str(), val);
259 : }
260 52785 : break;
261 53421 : case TpFloat :
262 53421 : transcribedRec->insert(theRec.name(i).c_str(), double(theRec.asFloat(i)));
263 53421 : break;
264 1089470 : case TpDouble :
265 1089470 : transcribedRec->insert(theRec.name(i).c_str(), theRec.asDouble(i));
266 1089470 : 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 1343566 : case TpString :
274 1343566 : transcribedRec->insert(theRec.name(i).c_str(), theRec.asString(i));
275 1343566 : 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 573842 : Array<Bool> tmpArray = theRec.asArrayBool(i);
282 : //Vector<ssize_t> tmpShape = (tmpArray.shape()).asVector();
283 573842 : Vector<ssize_t> tmpShape(tmpArray.shape( ).begin( ),tmpArray.shape( ).end( ));
284 : //std::cerr << "Vector Shape " << tmpShape << std::endl;
285 573842 : 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 : }
295 286921 : break;
296 155876 : case TpArrayChar :
297 : case TpArrayUChar :
298 : case TpArrayShort :
299 : case TpArrayUShort :
300 : case TpArrayInt :
301 : {
302 311752 : Array<int> tmpArray = theRec.asArrayInt(i);
303 311752 : Vector<Int> tmpShape = (tmpArray.shape()).asVector();
304 467628 : std::vector<ssize_t> vecShape(tmpShape.begin(),tmpShape.end());
305 155876 : std::vector<long> tmpVec;
306 1113748 : std::for_each( tmpArray.begin( ), tmpArray.end( ), [&](int v){tmpVec.push_back((long)v);} );
307 155876 : transcribedRec->insert(theRec.name(i).c_str(), casac::variant(tmpVec, vecShape));
308 : }
309 155876 : break;
310 348 : case TpArrayUInt :
311 : {
312 696 : Array<uInt> tmpArray = theRec.asArrayuInt(i);
313 696 : Vector<Int> tmpShape = (tmpArray.shape()).asVector();
314 1044 : std::vector<ssize_t> vecShape(tmpShape.begin( ),tmpShape.end( ));
315 348 : std::vector<unsigned long> tmpVec;
316 5644 : std::for_each( tmpArray.begin( ), tmpArray.end( ), [&](uInt v){tmpVec.push_back((unsigned long)v);} );
317 348 : transcribedRec->insert(theRec.name(i).c_str(), casac::variant(tmpVec, vecShape));
318 : }
319 348 : break;
320 8405 : case TpArrayInt64 :
321 : {
322 16810 : Array<Int64> tmpArray = theRec.asArrayInt64(i);
323 16810 : Vector<Int> tmpShape = (tmpArray.shape()).asVector();
324 25215 : std::vector<ssize_t> vecShape(tmpShape.begin( ),tmpShape.end( ));
325 16810 : std::vector<long> tmpVec(tmpArray.begin(),tmpArray.end());
326 8405 : transcribedRec->insert(theRec.name(i).c_str(), casac::variant(tmpVec, vecShape));
327 : }
328 8405 : break;
329 22288 : case TpArrayFloat :
330 : {
331 44576 : Array<Float> tmpArray = theRec.asArrayFloat(i);
332 44576 : Vector<Int> tmpShape = (tmpArray.shape()).asVector();
333 : //std::cerr << "Vector Shape " << tmpShape << std::endl;
334 66864 : std::vector<ssize_t> vecShape(tmpShape.begin( ),tmpShape.end( ));
335 44576 : std::vector<Float> tmpVec;
336 22288 : tmpArray.tovector(tmpVec);
337 22288 : std::vector<Double> dtmpVec(tmpVec.size());
338 5381981 : for(unsigned int j=0;j<tmpVec.size();j++)
339 5359693 : dtmpVec[j] = tmpVec[j];
340 22288 : transcribedRec->insert(theRec.name(i).c_str(), casac::variant(dtmpVec, vecShape));
341 : }
342 22288 : break;
343 76789 : case TpArrayDouble :
344 : {
345 153578 : Array<Double> tmpArray = theRec.asArrayDouble(i);
346 153578 : Vector<Int> tmpShape = (tmpArray.shape()).asVector();
347 : //std::cerr << "Vector Shape " << tmpShape << std::endl;
348 230367 : std::vector<ssize_t> vecShape(tmpShape.begin( ),tmpShape.end( ));
349 76789 : std::vector<Double> tmpVec;
350 76789 : tmpArray.tovector(tmpVec);
351 76789 : transcribedRec->insert(theRec.name(i).c_str(), casac::variant(tmpVec, vecShape));
352 : }
353 76789 : break;
354 118396 : case TpArrayComplex :
355 : {
356 236792 : Array<casacore::Complex> tmpArray = theRec.asArrayComplex(i);
357 236792 : Vector<Int> tmpShape = (tmpArray.shape()).asVector();
358 355188 : std::vector<ssize_t> vecShape(tmpShape.begin( ),tmpShape.end( ));
359 236792 : 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 : }
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 : }
379 0 : break;
380 26792 : case TpArrayString :
381 : {
382 53584 : Array<String> tmpArray = theRec.asArrayString(i);
383 53584 : Vector<Int> tmpShape = (tmpArray.shape()).asVector();
384 80376 : std::vector<ssize_t> vecShape(tmpShape.begin( ),tmpShape.end( ));
385 53584 : std::vector<casacore::String> tmpVec;
386 26792 : tmpArray.tovector(tmpVec);
387 26792 : std::vector<std::string> dtmpVec(tmpVec.size());
388 646213 : for(unsigned int j=0;j<tmpVec.size();j++)
389 619421 : dtmpVec[j] = tmpVec[j].c_str();
390 26792 : transcribedRec->insert(theRec.name(i).c_str(), casac::variant(dtmpVec, vecShape));
391 : }
392 26792 : break;
393 409205 : case TpRecord :
394 : {
395 : //std::cerr << "fromRecord is Record" << std::endl;
396 409205 : casac::record *dummy = fromRecord(theRec.asRecord(i));
397 409205 : casac::variant dum2(dummy);
398 409205 : transcribedRec->insert(theRec.name(i).c_str(), dum2);
399 : }
400 409205 : 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 1225000 : return transcribedRec;
416 : }
417 :
418 1251466 : Record *toRecord(const ::casac::record &theRec){
419 1251466 : Record *transcribedRec = new Record();
420 1251466 : casac::rec_map::const_iterator rec_end = theRec.end();
421 4079781 : 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 2828315 : switch((*rec_it).second.type()){
424 288616 : case ::casac::variant::RECORD :
425 : {
426 288616 : std::unique_ptr<Record> tmpRecord(toRecord((*rec_it).second.getRecord()));
427 288616 : transcribedRec->defineRecord(RecordFieldId((*rec_it).first), *tmpRecord);
428 : }
429 288616 : break;
430 30535 : case ::casac::variant::BOOL :
431 30535 : {transcribedRec->define(RecordFieldId((*rec_it).first), (*rec_it).second.toBool());}
432 30535 : break;
433 99127 : case ::casac::variant::INT :
434 99127 : {transcribedRec->define(RecordFieldId((*rec_it).first), Int((*rec_it).second.getInt()));}
435 99127 : break;
436 0 : case ::casac::variant::UINT :
437 0 : {transcribedRec->define(RecordFieldId((*rec_it).first), Int((*rec_it).second.getuInt()));}
438 0 : break;
439 931634 : case ::casac::variant::DOUBLE :
440 931634 : transcribedRec->define(RecordFieldId((*rec_it).first), (*rec_it).second.getDouble());
441 931634 : break;
442 0 : case ::casac::variant::COMPLEX :
443 0 : transcribedRec->define(RecordFieldId((*rec_it).first), (*rec_it).second.getComplex());
444 0 : break;
445 1387831 : case ::casac::variant::STRING :
446 1387831 : transcribedRec->define(RecordFieldId((*rec_it).first), (*rec_it).second.getString());
447 1387831 : break;
448 5356 : case ::casac::variant::BOOLVEC :
449 : {
450 10712 : Vector<Int> shapeVec((*rec_it).second.arrayshape());
451 10712 : Vector<Bool>boolVec((*rec_it).second.getBoolVec());
452 10712 : IPosition tshape(shapeVec);
453 10712 : Array<Bool> boolArr(tshape);
454 5356 : int i(0);
455 5356 : Array<Bool>::iterator boolArrend = boolArr.end();
456 12917 : for(Array<Bool>::iterator iter = boolArr.begin();
457 7561 : iter != boolArrend; ++iter)
458 2205 : *iter = boolVec[i++];
459 5356 : transcribedRec->define(RecordFieldId((*rec_it).first), boolArr);
460 : }
461 5356 : break;
462 21566 : case ::casac::variant::INTVEC :
463 : {
464 43132 : Vector<Int> shapeVec((*rec_it).second.arrayshape());
465 43132 : Vector<Int> intVec((*rec_it).second.getIntVec());
466 43132 : IPosition tshape(shapeVec);
467 43132 : Array<Int> intArr(tshape);
468 21566 : int i(0);
469 21566 : Array<Int>::iterator intArrend = intArr.end();
470 84381 : for(Array<Int>::iterator iter = intArr.begin();
471 62815 : iter != intArrend; ++iter)
472 41249 : *iter = intVec[i++];
473 21566 : transcribedRec->define(RecordFieldId((*rec_it).first), intArr);
474 : }
475 21566 : 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 : }
489 0 : break;
490 43185 : case ::casac::variant::DOUBLEVEC :
491 : {
492 86370 : Vector<Double> doubleVec((*rec_it).second.getDoubleVec());
493 86370 : Vector<Int> shapeVec((*rec_it).second.arrayshape());
494 86370 : IPosition tshape(shapeVec);
495 86370 : Array<Double> doubleArr(tshape);
496 43185 : int i(0);
497 43185 : Array<Double>::iterator doubleArrEnd = doubleArr.end();
498 427235 : for(Array<Double>::iterator iter = doubleArr.begin();
499 384050 : iter != doubleArrEnd; ++iter)
500 340865 : *iter = doubleVec[i++];
501 43185 : transcribedRec->define(RecordFieldId((*rec_it).first), doubleArr);
502 : }
503 43185 : 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 : }
517 0 : break;
518 20465 : case ::casac::variant::STRINGVEC :
519 : {
520 40930 : Vector<Int> shapeVec((*rec_it).second.arrayshape());
521 40930 : std::vector<std::string> tmp = (*rec_it).second.getStringVec();
522 20465 : const Array<String> &stringArr(toVectorString(tmp));
523 : //stringArr.reform(IPosition(shapeVec));
524 20465 : transcribedRec->define(RecordFieldId((*rec_it).first), stringArr);
525 : //transcribedRec->define((*rec_it).first, Vector<String>((*rec_it).second.getStringVec()));
526 : }
527 20465 : break;
528 0 : default :
529 0 : std::cerr << "Unknown type: " << (*rec_it).second.type() << std::endl;
530 0 : break;
531 : }
532 : }
533 1251466 : return transcribedRec;
534 : }
535 :
536 5742407 : casac::variant *fromValueHolder(const ValueHolder &theVH){
537 5742407 : casac::variant *theV(0);
538 5742407 : if(!theVH.isNull()){
539 5742407 : 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 670579 : case TpInt :
553 670579 : theV = new casac::variant((long)theVH.asInt());
554 670579 : 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 7427 : case TpDouble :
565 7427 : theV = new casac::variant(theVH.asDouble());
566 7427 : 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 2558 : case TpString :
574 2558 : theV = new casac::variant(theVH.asString().c_str());
575 2558 : break;
576 50942 : case TpArrayBool :
577 : {
578 101884 : Array<Bool> tArr(theVH.asArrayBool());
579 101884 : Vector<Int> ts = tArr.shape().asVector();
580 152826 : std::vector<ssize_t> tShape(ts.begin( ),ts.end( ));
581 50942 : std::vector<bool> tData;
582 50942 : tArr.tovector(tData);
583 50942 : theV = new casac::variant(tData, tShape);
584 : }
585 50942 : 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 : }
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 : }
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 : }
624 0 : break;
625 6028 : case TpArrayInt :
626 : {
627 12056 : Array<Int> tArr(theVH.asArrayInt());
628 12056 : Vector<Int> ts = tArr.shape().asVector();
629 : //std::cerr << "Vector Shape " << ts << std::endl;
630 18084 : std::vector<ssize_t> tShape(ts.begin( ),ts.end( ));
631 6028 : std::vector<long> tData;
632 38650493 : std::for_each( tArr.begin( ), tArr.end( ), [&](Int v){tData.push_back((long)v);} );
633 6028 : theV = new casac::variant(tData, tShape);
634 : }
635 6028 : break;
636 146 : case TpArrayUInt :
637 : {
638 292 : Array<uInt> tArr(theVH.asArrayuInt());
639 292 : Vector<Int> ts = tArr.shape().asVector();
640 438 : 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 : }
645 146 : break;
646 152801 : case TpArrayFloat :
647 : {
648 305602 : Array<Float> tArr(theVH.asArrayFloat());
649 305602 : Vector<Int> ts = tArr.shape().asVector();
650 : //std::cerr << ts << std::endl;
651 : //std::cerr << "Vector Shape " << ts << std::endl;
652 458403 : std::vector<ssize_t> tShape(ts.begin( ),ts.end( ));
653 305602 : std::vector<float> tData;
654 152801 : tArr.tovector(tData);
655 152801 : std::vector<double> tD(tData.size());
656 340300557 : for(unsigned int i=0;i<tData.size();i++)
657 340147756 : tD[i] = tData[i];
658 152801 : theV = new casac::variant(tD, tShape);
659 : }
660 152801 : break;
661 11907 : case TpArrayDouble :
662 : {
663 23814 : Array<Double> tArr(theVH.asArrayDouble());
664 23814 : Vector<Int> ts = tArr.shape().asVector();
665 : //std::cerr << "Vector Shape " << ts << std::endl;
666 35721 : std::vector<ssize_t> tShape(ts.begin( ),ts.end( ));
667 11907 : std::vector<double> tData;
668 11907 : tArr.tovector(tData);
669 11907 : theV = new casac::variant(tData, tShape);
670 : }
671 11907 : break;
672 4836494 : case TpArrayComplex :
673 : {
674 9672988 : Array<Complex> tArr(theVH.asArrayComplex());
675 9672988 : Vector<Int> ts = tArr.shape().asVector();
676 14509482 : std::vector<ssize_t> tShape(ts.begin( ),ts.end( ));
677 9672988 : std::vector<std::complex<float> > tData;
678 4836494 : tArr.tovector(tData);
679 4836494 : std::vector<std::complex<double> > tD(tData.size());
680 1142331086 : for(unsigned int i=0;i<tData.size();i++)
681 1137494592 : tD[i] = tData[i];
682 4836494 : theV = new casac::variant(tD, tShape);
683 : }
684 4836494 : break;
685 22 : case TpArrayDComplex :
686 : {
687 44 : Array<DComplex> tArr(theVH.asArrayDComplex());
688 44 : Vector<Int> ts = tArr.shape().asVector();
689 66 : 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 : }
694 22 : break;
695 2919 : case TpArrayString :
696 : {
697 : // Truly ugly...
698 5838 : Array<String> tArr(theVH.asArrayString());
699 5838 : Vector<Int> ts = tArr.shape().asVector();
700 8757 : std::vector<ssize_t> tShape(ts.begin( ),ts.end( ));
701 5838 : std::vector<String> tData;
702 2919 : tArr.tovector(tData);
703 2919 : std::vector<string> tData2(tData.size());
704 1539988 : for(unsigned int i=0; i<tData.size(); i++)
705 1537069 : tData2[i] = tData[i].c_str();
706 2919 : theV = new casac::variant(tData2, tShape);
707 : }
708 2919 : break;
709 558 : case TpRecord :
710 558 : theV = new casac::variant(fromRecord(theVH.asRecord()));
711 558 : break;
712 0 : default :
713 0 : throw(AipsError("Unknown casa DataType!"));
714 : break;
715 : }
716 : }
717 5742407 : 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 7058999 : ValueHolder *toValueHolder(const casac::variant &theV){
724 7058999 : ValueHolder *theVH(0);
725 0 : std::unique_ptr<Record> tmpRec;
726 7058999 : switch(theV.type()){
727 27 : case casac::variant::RECORD :
728 27 : tmpRec.reset(toRecord(theV.getRecord()));
729 27 : theVH = new ValueHolder(*tmpRec);
730 27 : break;
731 23 : case casac::variant::BOOL :
732 23 : theVH = new ValueHolder(theV.getBool());
733 23 : break;
734 50686 : case casac::variant::INT :
735 : /*** need range check ***/
736 50686 : theVH = new ValueHolder((int)theV.getInt());
737 50686 : break;
738 3920 : case casac::variant::DOUBLE :
739 3920 : theVH = new ValueHolder(theV.getDouble());
740 3920 : break;
741 0 : case casac::variant::COMPLEX :
742 0 : theVH = new ValueHolder(theV.getComplex());
743 0 : break;
744 6462 : case casac::variant::STRING :
745 6462 : theVH = new ValueHolder(theV.getString());
746 6462 : break;
747 799184 : case casac::variant::BOOLVEC :
748 : {
749 1598368 : Vector<Bool> boolVec(theV.getBoolVec());
750 1598368 : Vector<Int>shapeVec(theV.arrayshape());
751 1598368 : IPosition tshape(shapeVec);
752 1598368 : Array<Bool> tVec(tshape);
753 799184 : int i(0);
754 799184 : Array<Bool>::iterator tVecEnd = tVec.end();
755 78532057 : for(Array<Bool>::iterator iter = tVec.begin();
756 77732873 : iter != tVecEnd; ++iter)
757 76933689 : *iter = boolVec[i++];
758 799184 : theVH = new ValueHolder(tVec);
759 : }
760 799184 : break;
761 1393 : case casac::variant::INTVEC :
762 : {
763 2786 : Vector<Int> intVec(theV.getIntVec());
764 2786 : Vector<Int>shapeVec(theV.arrayshape());
765 2786 : IPosition tshape(shapeVec);
766 2786 : Array<Int> tVec(tshape);
767 1393 : int i(0);
768 1393 : Array<Int>::iterator tVecEnd = tVec.end();
769 5645673 : for(Array<Int>::iterator iter = tVec.begin();
770 5644280 : iter != tVecEnd; ++iter)
771 5642887 : *iter = intVec[i++];
772 1393 : theVH = new ValueHolder(tVec);
773 : }
774 1393 : break;
775 3317524 : case casac::variant::DOUBLEVEC :
776 : {
777 6635048 : Vector<Double> doubleVec(theV.getDoubleVec());
778 6635048 : Vector<Int>shapeVec(theV.arrayshape());
779 6635048 : IPosition tshape(shapeVec);
780 6635048 : Array<Double> tVec(tshape);
781 3317524 : Array<Double>::iterator tVecEnd = tVec.end();
782 3317524 : int i(0);
783 120401899 : for(Array<Double>::iterator iter = tVec.begin();
784 117084375 : iter != tVecEnd; ++iter)
785 113766851 : *iter = doubleVec[i++];
786 3317524 : theVH = new ValueHolder(tVec);
787 : }
788 3317524 : break;
789 2879387 : case casac::variant::COMPLEXVEC :
790 : {
791 5758774 : Vector<DComplex> complexVec(theV.getComplexVec());
792 5758774 : Vector<Int>shapeVec(theV.arrayshape());
793 5758774 : IPosition tshape(shapeVec);
794 5758774 : Array<DComplex> tVec(tshape);
795 2879387 : Array<DComplex>::iterator tVecEnd = tVec.end();
796 2879387 : int i(0);
797 114240794 : for(Array<DComplex>::iterator iter = tVec.begin();
798 111361407 : iter != tVecEnd; ++iter)
799 108482020 : *iter = complexVec[i++];
800 2879387 : theVH = new ValueHolder(tVec);
801 : }
802 2879387 : break;
803 393 : case casac::variant::STRINGVEC :
804 : // Unclear whether this may leak
805 : {
806 786 : std::vector<std::string> tmp = theV.getStringVec();
807 786 : Vector<String> stringArr(toVectorString(tmp));
808 786 : Vector<Int>shapeVec(theV.arrayshape());
809 786 : IPosition tshape(shapeVec);
810 786 : Array<String> tVec(tshape);
811 393 : int i(0);
812 393 : Array<String>::iterator tVecEnd = tVec.end();
813 405337 : for(Array<String>::iterator iter = tVec.begin();
814 809495 : iter != tVecEnd; ++iter)
815 404551 : *iter = stringArr[i++];
816 393 : theVH = new ValueHolder(tVec);
817 : }
818 393 : break;
819 0 : default :
820 0 : throw(AipsError("Unknown variant type!"));
821 : break;
822 : }
823 14117998 : return theVH;
824 : }
825 :
826 1095 : Bool casaMDirection(const ::casac::variant& theVar,
827 : MDirection& theMeas){
828 :
829 2190 : casacore::MeasureHolder mh;
830 2190 : casacore::QuantumHolder qh;
831 2190 : String error;
832 1095 : if(theVar.type()== ::casac::variant::RECORD){
833 48 : ::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 : }
845 : }
846 1101 : if(theVar.type()== ::casac::variant::STRING ||
847 30 : theVar.type()== ::casac::variant::STRINGVEC){
848 1072 : 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 2139 : 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 : }
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 : }
875 1069 : theMeas=MDirection(val1,val2, tp);
876 1069 : return true;
877 : }
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 : }
890 0 : theMeas=MDirection(val1, val2);
891 0 : return true;
892 : }
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 : }
924 :
925 : }
926 :
927 : }
928 : ///If i am here i don't know how to interprete this
929 :
930 :
931 0 : return false;
932 : }
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 13814 : casacore::String form(format);
948 6907 : form.downcase();
949 :
950 6907 : Int ndig=6+precision;
951 :
952 13814 : 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 : }
964 0 : else if(form == "rad"){
965 0 : ostringstream os;
966 0 : os << ang().radian();
967 0 : out = os.str();
968 : }
969 0 : else if(form == "+deg"){
970 0 : ostringstream os;
971 0 : os << ang(0.0).degree();
972 0 : out = os.str();
973 : }
974 : else{
975 0 : retval = false; // Format not understood - return false instead of
976 : // throwing an exception.
977 : }
978 : }
979 0 : catch(AipsError x){
980 0 : retval = false;
981 0 : RETHROW(x);
982 : }
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 : }
1012 :
1013 15547 : Bool casaMFrequency(const ::casac::variant& theVar,
1014 : MFrequency& theMeas){
1015 31094 : casacore::MeasureHolder mh;
1016 31094 : casacore::QuantumHolder qh;
1017 31094 : String error;
1018 15547 : if(theVar.type()== ::casac::variant::RECORD){
1019 162 : ::casac::variant localvar(theVar); //cause its const
1020 162 : 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 : }
1037 : }
1038 : }
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 : }
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 : }
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 : }
1078 :
1079 38 : Bool casaMPosition(const ::casac::variant& theVar,
1080 : MPosition& theMeas){
1081 76 : casacore::MeasureHolder mh;
1082 76 : casacore::QuantumHolder qh;
1083 76 : String error;
1084 38 : if(theVar.type()== ::casac::variant::RECORD){
1085 76 : ::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 : }
1097 : }
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 : }
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 : }
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 : }
1145 : ///If i am here i don't know how to interprete this
1146 :
1147 :
1148 0 : return false;
1149 :
1150 :
1151 : }
1152 :
1153 :
1154 3 : Bool casaMRadialVelocity(const ::casac::variant& theVar,
1155 : MRadialVelocity& theMeas){
1156 6 : casacore::MeasureHolder mh;
1157 6 : casacore::QuantumHolder qh;
1158 6 : 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 : }
1178 : }
1179 : }
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 : }
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 : }
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 : }
1214 :
1215 31 : Bool casaMEpoch(const ::casac::variant& theVar,
1216 : MEpoch& theMeas){
1217 :
1218 62 : casacore::MeasureHolder mh;
1219 62 : casacore::QuantumHolder qh;
1220 62 : String error;
1221 31 : if(theVar.type()== ::casac::variant::RECORD){
1222 62 : ::casac::variant localvar(theVar); //cause its const
1223 62 : 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 : }
1240 : }
1241 : }
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 : }
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 : }
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 : }
1279 1105 : Int sepCommaEmptyToVectorStrings(Vector<String>& lesStrings,
1280 : const std::string& str){
1281 :
1282 2210 : 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 2210 : return nsep;
1317 :
1318 : }
1319 :
1320 116 : Int sepCommaToVectorStrings(Vector<String>& lesStrings,
1321 : const std::string& str){
1322 :
1323 232 : 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 232 : return nsep;
1351 :
1352 : }
1353 :
1354 1023 : vector<double> toVectorDouble(const casac::variant& v, const String& varName) {
1355 2046 : 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 : }
1379 :
1380 279 : vector<string> toVectorString(const ::casac::variant& v, const String& varName) {
1381 558 : 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 : }
1398 :
1399 2 : vector<int> toVectorInt(const ::casac::variant& v, const String& varName) {
1400 4 : 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 : }
1425 :
1426 186 : vector<bool> toVectorBool(const ::casac::variant& v, const String& varName) {
1427 372 : 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 : }
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 : }
1459 :
1460 :
1461 :
1462 : using namespace casacore;
1463 : } // End namespace casa
|
