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 0 : Vector<String> toVectorString(const std::vector<std::string> &theVec){
16 0 : Vector<String> b(theVec.size());
17 0 : for(unsigned int i=0; i<theVec.size(); i++)
18 0 : b[i] = String(theVec[i]);
19 0 : return(b);
20 0 : }
21 :
22 0 : String toCasaString(const casac::variant& var){
23 :
24 0 : String out;
25 : //Going around a bug of toString when its a string vector
26 0 : if(var.type()==::casac::variant::STRINGVEC){
27 0 : Vector<String> outvec=toVectorString(var.toStringVec());
28 0 : if(outvec.nelements() >0)
29 0 : out=outvec[0];
30 0 : for (uInt k =1; k < outvec.nelements(); ++k){
31 0 : out=out+String(",")+outvec[k];
32 : }
33 0 : }
34 : else{
35 0 : out=String(var.toString());
36 : }
37 : // [] protection
38 0 : if (out.length()>1 && out.firstchar()=='[' && out.lastchar()==']')
39 0 : out = out.substr(1,out.length()-2);
40 :
41 0 : return out;
42 :
43 0 : }
44 :
45 0 : std::vector<string> fromVectorString(const Vector<String> &theVec){
46 0 : std::vector<string> b(theVec.size());
47 0 : for(unsigned int i=0; i<theVec.size(); i++)
48 0 : b[i] = theVec[i].c_str();
49 0 : return(b);
50 0 : }
51 :
52 0 : casac::Quantity casacQuantity(const Quantity &quant){
53 0 : casac::Quantity cquant(std::vector<double>(1,0.0), "");
54 0 : cquant.value[0] = quant.getValue();
55 0 : cquant.units = quant.getUnit().c_str();
56 0 : return cquant;
57 0 : }
58 :
59 0 : Quantity casaQuantity(const casac::Quantity &cquant){
60 0 : if(cquant.value.size() < 1)
61 0 : throw(AipsError("Bad quantity conversion"));
62 0 : return Quantity(cquant.value[0], Unit(cquant.units));
63 : }
64 :
65 5 : Quantity casaQuantity(const casac::variant &theVar){
66 5 : casacore::QuantumHolder qh;
67 5 : 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 5 : Bool triedAndFailed = false;
73 :
74 5 : const ::casac::variant::TYPE theType = theVar.type();
75 :
76 5 : if(theType == ::casac::variant::STRING ||
77 : theType == ::casac::variant::STRINGVEC){
78 4 : triedAndFailed = !qh.fromString(error, theVar.toString());
79 : }
80 1 : else if(theType == ::casac::variant::RECORD){
81 : //NOW the record has to be compatible with QuantumHolder::toRecord
82 1 : ::casac::variant localvar(theVar); // Because theVar is const.
83 1 : std::unique_ptr<Record> ptrRec(toRecord(localvar.asRecord()));
84 :
85 1 : triedAndFailed = !qh.fromRecord(error, *ptrRec);
86 1 : }
87 0 : else if(::casac::variant::compatible_type(theType, ::casac::variant::DOUBLE)
88 0 : == ::casac::variant::DOUBLE){
89 0 : const casacore::Unit unitless("_"); // Dimensionless
90 :
91 : //qh = casacore::QuantumHolder(casacore::Quantity(const_cast<Double &>(const_cast<casac::variant &>(theVar).asDouble()),
92 : //unitless));
93 0 : qh = casacore::QuantumHolder(casacore::Quantity(const_cast<Double &>(const_cast<casac::variant &>(theVar).asDouble())));
94 :
95 0 : triedAndFailed = false;
96 0 : }
97 0 : else if(::casac::variant::compatible_type(theType, ::casac::variant::COMPLEX)
98 0 : == ::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 5 : if(triedAndFailed){
109 0 : ostringstream oss;
110 :
111 0 : oss << "Error " << error << " in converting quantity";
112 0 : throw(AipsError(oss.str()));
113 0 : }
114 :
115 5 : if(qh.isQuantum()){ // Remember casac::Quantity is a broader class
116 5 : return qh.asQuantity(); // than casacore::Quantity, so use qh.isQuantum().
117 : }
118 : else{ // Probably variant's type was not handled above.
119 0 : casacore::Quantity retval; // Defaults to 0.0.
120 :
121 0 : return retval;
122 0 : }
123 5 : }
124 :
125 0 : Quantum<Vector<Double> > casaQuantumVector(const casac::variant& thevar){
126 0 : 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 0 : if(thevar.type() != ::casac::variant::RECORD){
129 0 : return retval;
130 : }
131 0 : ::casac::variant localvar(thevar); //cause its const
132 0 : std::unique_ptr<Record> ptrRec(toRecord(localvar.asRecord()));
133 0 : QuantumHolder qh;
134 0 : String error;
135 0 : if(qh.fromRecord(error, *ptrRec)){
136 : try {
137 0 : if(qh.isQuantumVectorDouble()){
138 0 : Quantum<Vector<Double> >retval1=qh.asQuantumVectorDouble();
139 0 : return retval1;
140 0 : }
141 : }
142 0 : catch(...){
143 0 : return retval;
144 0 : }
145 : }
146 :
147 0 : return retval;
148 0 : }
149 :
150 0 : Bool toCasaVectorQuantity(const ::casac::variant& theval, casacore::Vector<casacore::Quantity>& theQuants){
151 :
152 0 : casacore::Vector<casacore::String> lesStrings;
153 0 : if (theval.type()== ::casac::variant::STRING){
154 0 : sepCommaEmptyToVectorStrings(lesStrings, theval.toString());
155 : }
156 0 : else if(theval.type()== ::casac::variant::STRINGVEC){
157 : //Force resize as toStringVec sometimes give the wrong length (bug?)
158 0 : Vector<Int> leShape(theval.arrayshape());
159 0 : lesStrings=toVectorString(theval.toStringVec());
160 0 : lesStrings.resize(product(leShape), true);
161 0 : }
162 :
163 0 : casacore::QuantumHolder qh;
164 0 : String error;
165 0 : theQuants.resize(lesStrings.nelements());
166 0 : for (uInt k=0; k < lesStrings.nelements(); ++k){
167 : //Drat QuantumHolder does not handle pix
168 0 : 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 0 : 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 0 : theQuants[k]=qh.asQuantity();
180 :
181 :
182 : }
183 : }
184 :
185 0 : return true;
186 :
187 0 : }
188 :
189 0 : ::casac::record* recordFromQuantity(const Quantity q)
190 : {
191 0 : ::casac::record *r=0;
192 : try{
193 0 : String error;
194 0 : Record R;
195 0 : if(QuantumHolder(q).toRecord(error, R))
196 0 : r = fromRecord(R);
197 : else
198 0 : throw(AipsError("Could not convert quantity to record."));
199 0 : }
200 0 : catch(AipsError x){
201 0 : ostringstream oss;
202 :
203 0 : oss << "Exception Reported: " << x.getMesg();
204 0 : RETHROW(x);
205 0 : }
206 0 : 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 8 : ::casac::record *fromRecord(const Record &theRec){
234 8 : ::casac::record *transcribedRec = new ::casac::record();
235 24 : for(uInt i=0; i<theRec.nfields(); i++){
236 : // std::cerr << theRec.name(i) << " " << theRec.dataType(i) << std::endl;
237 16 : switch(theRec.dataType(i)){
238 0 : case TpBool :
239 0 : transcribedRec->insert(theRec.name(i).c_str(), theRec.asBool(i));
240 0 : 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 0 : case TpUInt :
250 0 : transcribedRec->insert(theRec.name(i).c_str(), (unsigned long) theRec.asuInt(i));
251 0 : break;
252 0 : case TpInt :
253 0 : transcribedRec->insert(theRec.name(i).c_str(), long(theRec.asInt(i)));
254 0 : break;
255 0 : case TpInt64 :
256 : {
257 0 : casac::variant val((long)theRec.asInt64(i));
258 0 : transcribedRec->insert(theRec.name(i).c_str(), val);
259 0 : }
260 0 : break;
261 0 : case TpFloat :
262 0 : transcribedRec->insert(theRec.name(i).c_str(), double(theRec.asFloat(i)));
263 0 : break;
264 8 : case TpDouble :
265 8 : transcribedRec->insert(theRec.name(i).c_str(), theRec.asDouble(i));
266 8 : 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 8 : case TpString :
274 8 : transcribedRec->insert(theRec.name(i).c_str(), theRec.asString(i));
275 8 : break;
276 0 : case TpTable :
277 0 : transcribedRec->insert(theRec.name(i).c_str(), theRec.asString(i));
278 0 : break;
279 0 : case TpArrayBool :
280 : {
281 0 : Array<Bool> tmpArray = theRec.asArrayBool(i);
282 : //Vector<ssize_t> tmpShape = (tmpArray.shape()).asVector();
283 0 : Vector<ssize_t> tmpShape(tmpArray.shape( ).begin( ),tmpArray.shape( ).end( ));
284 : //std::cerr << "Vector Shape " << tmpShape << std::endl;
285 0 : std::vector<ssize_t> vecShape;
286 0 : 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 0 : std::vector<bool> tmpVec;
292 0 : tmpArray.tovector(tmpVec);
293 0 : transcribedRec->insert(theRec.name(i).c_str(), casac::variant(tmpVec, vecShape));
294 0 : }
295 0 : break;
296 0 : case TpArrayChar :
297 : case TpArrayUChar :
298 : case TpArrayShort :
299 : case TpArrayUShort :
300 : case TpArrayInt :
301 : {
302 0 : Array<int> tmpArray = theRec.asArrayInt(i);
303 0 : Vector<Int> tmpShape = (tmpArray.shape()).asVector();
304 0 : std::vector<ssize_t> vecShape(tmpShape.begin(),tmpShape.end());
305 0 : std::vector<long> tmpVec;
306 0 : std::for_each( tmpArray.begin( ), tmpArray.end( ), [&](int v){tmpVec.push_back((long)v);} );
307 0 : transcribedRec->insert(theRec.name(i).c_str(), casac::variant(tmpVec, vecShape));
308 0 : }
309 0 : break;
310 0 : case TpArrayUInt :
311 : {
312 0 : Array<uInt> tmpArray = theRec.asArrayuInt(i);
313 0 : Vector<Int> tmpShape = (tmpArray.shape()).asVector();
314 0 : std::vector<ssize_t> vecShape(tmpShape.begin( ),tmpShape.end( ));
315 0 : std::vector<unsigned long> tmpVec;
316 0 : std::for_each( tmpArray.begin( ), tmpArray.end( ), [&](uInt v){tmpVec.push_back((unsigned long)v);} );
317 0 : transcribedRec->insert(theRec.name(i).c_str(), casac::variant(tmpVec, vecShape));
318 0 : }
319 0 : break;
320 0 : case TpArrayInt64 :
321 : {
322 0 : Array<Int64> tmpArray = theRec.asArrayInt64(i);
323 0 : Vector<Int> tmpShape = (tmpArray.shape()).asVector();
324 0 : std::vector<ssize_t> vecShape(tmpShape.begin( ),tmpShape.end( ));
325 0 : std::vector<long> tmpVec(tmpArray.begin(),tmpArray.end());
326 0 : transcribedRec->insert(theRec.name(i).c_str(), casac::variant(tmpVec, vecShape));
327 0 : }
328 0 : break;
329 0 : case TpArrayFloat :
330 : {
331 0 : Array<Float> tmpArray = theRec.asArrayFloat(i);
332 0 : Vector<Int> tmpShape = (tmpArray.shape()).asVector();
333 : //std::cerr << "Vector Shape " << tmpShape << std::endl;
334 0 : std::vector<ssize_t> vecShape(tmpShape.begin( ),tmpShape.end( ));
335 0 : std::vector<Float> tmpVec;
336 0 : tmpArray.tovector(tmpVec);
337 0 : std::vector<Double> dtmpVec(tmpVec.size());
338 0 : for(unsigned int j=0;j<tmpVec.size();j++)
339 0 : dtmpVec[j] = tmpVec[j];
340 0 : transcribedRec->insert(theRec.name(i).c_str(), casac::variant(dtmpVec, vecShape));
341 0 : }
342 0 : break;
343 0 : case TpArrayDouble :
344 : {
345 0 : Array<Double> tmpArray = theRec.asArrayDouble(i);
346 0 : Vector<Int> tmpShape = (tmpArray.shape()).asVector();
347 : //std::cerr << "Vector Shape " << tmpShape << std::endl;
348 0 : std::vector<ssize_t> vecShape(tmpShape.begin( ),tmpShape.end( ));
349 0 : std::vector<Double> tmpVec;
350 0 : tmpArray.tovector(tmpVec);
351 0 : transcribedRec->insert(theRec.name(i).c_str(), casac::variant(tmpVec, vecShape));
352 0 : }
353 0 : break;
354 0 : case TpArrayComplex :
355 : {
356 0 : Array<casacore::Complex> tmpArray = theRec.asArrayComplex(i);
357 0 : Vector<Int> tmpShape = (tmpArray.shape()).asVector();
358 0 : std::vector<ssize_t> vecShape(tmpShape.begin( ),tmpShape.end( ));
359 0 : std::vector<casacore::Complex> tmpVec;
360 0 : tmpArray.tovector(tmpVec);
361 0 : std::vector<std::complex<double> > dtmpVec(tmpVec.size());
362 0 : for(unsigned int j=0;j<tmpVec.size();j++)
363 0 : dtmpVec[j] = tmpVec[j];
364 0 : transcribedRec->insert(theRec.name(i).c_str(), casac::variant(dtmpVec, vecShape));
365 0 : }
366 0 : 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 0 : case TpArrayString :
381 : {
382 0 : Array<String> tmpArray = theRec.asArrayString(i);
383 0 : Vector<Int> tmpShape = (tmpArray.shape()).asVector();
384 0 : std::vector<ssize_t> vecShape(tmpShape.begin( ),tmpShape.end( ));
385 0 : std::vector<casacore::String> tmpVec;
386 0 : tmpArray.tovector(tmpVec);
387 0 : std::vector<std::string> dtmpVec(tmpVec.size());
388 0 : for(unsigned int j=0;j<tmpVec.size();j++)
389 0 : dtmpVec[j] = tmpVec[j].c_str();
390 0 : transcribedRec->insert(theRec.name(i).c_str(), casac::variant(dtmpVec, vecShape));
391 0 : }
392 0 : break;
393 0 : case TpRecord :
394 : {
395 : //std::cerr << "fromRecord is Record" << std::endl;
396 0 : casac::record *dummy = fromRecord(theRec.asRecord(i));
397 0 : casac::variant dum2(dummy);
398 0 : transcribedRec->insert(theRec.name(i).c_str(), dum2);
399 0 : }
400 0 : 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 8 : return transcribedRec;
416 : }
417 :
418 2 : Record *toRecord(const ::casac::record &theRec){
419 2 : Record *transcribedRec = new Record();
420 2 : casac::rec_map::const_iterator rec_end = theRec.end();
421 6 : 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 4 : switch((*rec_it).second.type()){
424 0 : case ::casac::variant::RECORD :
425 : {
426 0 : std::unique_ptr<Record> tmpRecord(toRecord((*rec_it).second.getRecord()));
427 0 : transcribedRec->defineRecord(RecordFieldId((*rec_it).first), *tmpRecord);
428 0 : }
429 0 : break;
430 0 : case ::casac::variant::BOOL :
431 0 : {transcribedRec->define(RecordFieldId((*rec_it).first), (*rec_it).second.toBool());}
432 0 : break;
433 0 : case ::casac::variant::INT :
434 0 : {transcribedRec->define(RecordFieldId((*rec_it).first), Int((*rec_it).second.getInt()));}
435 0 : break;
436 0 : case ::casac::variant::UINT :
437 0 : {transcribedRec->define(RecordFieldId((*rec_it).first), Int((*rec_it).second.getuInt()));}
438 0 : break;
439 2 : case ::casac::variant::DOUBLE :
440 2 : transcribedRec->define(RecordFieldId((*rec_it).first), (*rec_it).second.getDouble());
441 2 : break;
442 0 : case ::casac::variant::COMPLEX :
443 0 : transcribedRec->define(RecordFieldId((*rec_it).first), (*rec_it).second.getComplex());
444 0 : break;
445 2 : case ::casac::variant::STRING :
446 2 : transcribedRec->define(RecordFieldId((*rec_it).first), (*rec_it).second.getString());
447 2 : break;
448 0 : case ::casac::variant::BOOLVEC :
449 : {
450 0 : Vector<Int> shapeVec((*rec_it).second.arrayshape());
451 0 : Vector<Bool>boolVec((*rec_it).second.getBoolVec());
452 0 : IPosition tshape(shapeVec);
453 0 : Array<Bool> boolArr(tshape);
454 0 : int i(0);
455 0 : Array<Bool>::iterator boolArrend = boolArr.end();
456 0 : for(Array<Bool>::iterator iter = boolArr.begin();
457 0 : iter != boolArrend; ++iter)
458 0 : *iter = boolVec[i++];
459 0 : transcribedRec->define(RecordFieldId((*rec_it).first), boolArr);
460 0 : }
461 0 : break;
462 0 : case ::casac::variant::INTVEC :
463 : {
464 0 : Vector<Int> shapeVec((*rec_it).second.arrayshape());
465 0 : Vector<Int> intVec((*rec_it).second.getIntVec());
466 0 : IPosition tshape(shapeVec);
467 0 : Array<Int> intArr(tshape);
468 0 : int i(0);
469 0 : Array<Int>::iterator intArrend = intArr.end();
470 0 : for(Array<Int>::iterator iter = intArr.begin();
471 0 : iter != intArrend; ++iter)
472 0 : *iter = intVec[i++];
473 0 : transcribedRec->define(RecordFieldId((*rec_it).first), intArr);
474 0 : }
475 0 : 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 0 : case ::casac::variant::DOUBLEVEC :
491 : {
492 0 : Vector<Double> doubleVec((*rec_it).second.getDoubleVec());
493 0 : Vector<Int> shapeVec((*rec_it).second.arrayshape());
494 0 : IPosition tshape(shapeVec);
495 0 : Array<Double> doubleArr(tshape);
496 0 : int i(0);
497 0 : Array<Double>::iterator doubleArrEnd = doubleArr.end();
498 0 : for(Array<Double>::iterator iter = doubleArr.begin();
499 0 : iter != doubleArrEnd; ++iter)
500 0 : *iter = doubleVec[i++];
501 0 : transcribedRec->define(RecordFieldId((*rec_it).first), doubleArr);
502 0 : }
503 0 : 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 0 : case ::casac::variant::STRINGVEC :
519 : {
520 0 : Vector<Int> shapeVec((*rec_it).second.arrayshape());
521 0 : std::vector<std::string> tmp = (*rec_it).second.getStringVec();
522 0 : const Array<String> &stringArr(toVectorString(tmp));
523 : //stringArr.reform(IPosition(shapeVec));
524 0 : transcribedRec->define(RecordFieldId((*rec_it).first), stringArr);
525 : //transcribedRec->define((*rec_it).first, Vector<String>((*rec_it).second.getStringVec()));
526 0 : }
527 0 : break;
528 0 : default :
529 0 : std::cerr << "Unknown type: " << (*rec_it).second.type() << std::endl;
530 0 : break;
531 : }
532 : }
533 2 : return transcribedRec;
534 : }
535 :
536 0 : casac::variant *fromValueHolder(const ValueHolder &theVH){
537 0 : casac::variant *theV(0);
538 0 : if(!theVH.isNull()){
539 0 : switch(theVH.dataType()){
540 0 : case TpBool :
541 0 : theV = new casac::variant(theVH.asBool());
542 0 : 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 0 : case TpInt :
553 0 : theV = new casac::variant((long)theVH.asInt());
554 0 : 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 0 : case TpFloat :
562 0 : theV = new casac::variant(theVH.asFloat());
563 0 : break;
564 0 : case TpDouble :
565 0 : theV = new casac::variant(theVH.asDouble());
566 0 : 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 0 : case TpString :
574 0 : theV = new casac::variant(theVH.asString().c_str());
575 0 : break;
576 0 : case TpArrayBool :
577 : {
578 0 : Array<Bool> tArr(theVH.asArrayBool());
579 0 : Vector<Int> ts = tArr.shape().asVector();
580 0 : std::vector<ssize_t> tShape(ts.begin( ),ts.end( ));
581 0 : std::vector<bool> tData;
582 0 : tArr.tovector(tData);
583 0 : theV = new casac::variant(tData, tShape);
584 0 : }
585 0 : 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 0 : case TpArrayInt :
626 : {
627 0 : Array<Int> tArr(theVH.asArrayInt());
628 0 : Vector<Int> ts = tArr.shape().asVector();
629 : //std::cerr << "Vector Shape " << ts << std::endl;
630 0 : std::vector<ssize_t> tShape(ts.begin( ),ts.end( ));
631 0 : std::vector<long> tData;
632 0 : std::for_each( tArr.begin( ), tArr.end( ), [&](Int v){tData.push_back((long)v);} );
633 0 : theV = new casac::variant(tData, tShape);
634 0 : }
635 0 : break;
636 0 : case TpArrayUInt :
637 : {
638 0 : Array<uInt> tArr(theVH.asArrayuInt());
639 0 : Vector<Int> ts = tArr.shape().asVector();
640 0 : std::vector<ssize_t> tShape(ts.begin( ),ts.end( ));
641 0 : std::vector<unsigned long> tData;
642 0 : std::for_each( tArr.begin( ), tArr.end( ), [&](Int v){tData.push_back((unsigned long)v);} );
643 0 : theV = new casac::variant(tData, tShape);
644 0 : }
645 0 : break;
646 0 : case TpArrayFloat :
647 : {
648 0 : Array<Float> tArr(theVH.asArrayFloat());
649 0 : Vector<Int> ts = tArr.shape().asVector();
650 : //std::cerr << ts << std::endl;
651 : //std::cerr << "Vector Shape " << ts << std::endl;
652 0 : std::vector<ssize_t> tShape(ts.begin( ),ts.end( ));
653 0 : std::vector<float> tData;
654 0 : tArr.tovector(tData);
655 0 : std::vector<double> tD(tData.size());
656 0 : for(unsigned int i=0;i<tData.size();i++)
657 0 : tD[i] = tData[i];
658 0 : theV = new casac::variant(tD, tShape);
659 0 : }
660 0 : break;
661 0 : case TpArrayDouble :
662 : {
663 0 : Array<Double> tArr(theVH.asArrayDouble());
664 0 : Vector<Int> ts = tArr.shape().asVector();
665 : //std::cerr << "Vector Shape " << ts << std::endl;
666 0 : std::vector<ssize_t> tShape(ts.begin( ),ts.end( ));
667 0 : std::vector<double> tData;
668 0 : tArr.tovector(tData);
669 0 : theV = new casac::variant(tData, tShape);
670 0 : }
671 0 : break;
672 0 : case TpArrayComplex :
673 : {
674 0 : Array<Complex> tArr(theVH.asArrayComplex());
675 0 : Vector<Int> ts = tArr.shape().asVector();
676 0 : std::vector<ssize_t> tShape(ts.begin( ),ts.end( ));
677 0 : std::vector<std::complex<float> > tData;
678 0 : tArr.tovector(tData);
679 0 : std::vector<std::complex<double> > tD(tData.size());
680 0 : for(unsigned int i=0;i<tData.size();i++)
681 0 : tD[i] = tData[i];
682 0 : theV = new casac::variant(tD, tShape);
683 0 : }
684 0 : break;
685 0 : case TpArrayDComplex :
686 : {
687 0 : Array<DComplex> tArr(theVH.asArrayDComplex());
688 0 : Vector<Int> ts = tArr.shape().asVector();
689 0 : std::vector<ssize_t> tShape(ts.begin( ),ts.end( ));
690 0 : std::vector<std::complex<double> > tData;
691 0 : tArr.tovector(tData);
692 0 : theV = new casac::variant(tData, tShape);
693 0 : }
694 0 : break;
695 0 : case TpArrayString :
696 : {
697 : // Truly ugly...
698 0 : Array<String> tArr(theVH.asArrayString());
699 0 : Vector<Int> ts = tArr.shape().asVector();
700 0 : std::vector<ssize_t> tShape(ts.begin( ),ts.end( ));
701 0 : std::vector<String> tData;
702 0 : tArr.tovector(tData);
703 0 : std::vector<string> tData2(tData.size());
704 0 : for(unsigned int i=0; i<tData.size(); i++)
705 0 : tData2[i] = tData[i].c_str();
706 0 : theV = new casac::variant(tData2, tShape);
707 0 : }
708 0 : break;
709 0 : case TpRecord :
710 0 : theV = new casac::variant(fromRecord(theVH.asRecord()));
711 0 : break;
712 0 : default :
713 0 : throw(AipsError("Unknown casa DataType!"));
714 : break;
715 : }
716 : }
717 0 : 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 0 : ValueHolder *toValueHolder(const casac::variant &theV){
724 0 : ValueHolder *theVH(0);
725 0 : std::unique_ptr<Record> tmpRec;
726 0 : switch(theV.type()){
727 0 : case casac::variant::RECORD :
728 0 : tmpRec.reset(toRecord(theV.getRecord()));
729 0 : theVH = new ValueHolder(*tmpRec);
730 0 : break;
731 0 : case casac::variant::BOOL :
732 0 : theVH = new ValueHolder(theV.getBool());
733 0 : break;
734 0 : case casac::variant::INT :
735 : /*** need range check ***/
736 0 : theVH = new ValueHolder((int)theV.getInt());
737 0 : break;
738 0 : case casac::variant::DOUBLE :
739 0 : theVH = new ValueHolder(theV.getDouble());
740 0 : break;
741 0 : case casac::variant::COMPLEX :
742 0 : theVH = new ValueHolder(theV.getComplex());
743 0 : break;
744 0 : case casac::variant::STRING :
745 0 : theVH = new ValueHolder(theV.getString());
746 0 : break;
747 0 : case casac::variant::BOOLVEC :
748 : {
749 0 : Vector<Bool> boolVec(theV.getBoolVec());
750 0 : Vector<Int>shapeVec(theV.arrayshape());
751 0 : IPosition tshape(shapeVec);
752 0 : Array<Bool> tVec(tshape);
753 0 : int i(0);
754 0 : Array<Bool>::iterator tVecEnd = tVec.end();
755 0 : for(Array<Bool>::iterator iter = tVec.begin();
756 0 : iter != tVecEnd; ++iter)
757 0 : *iter = boolVec[i++];
758 0 : theVH = new ValueHolder(tVec);
759 0 : }
760 0 : break;
761 0 : case casac::variant::INTVEC :
762 : {
763 0 : Vector<Int> intVec(theV.getIntVec());
764 0 : Vector<Int>shapeVec(theV.arrayshape());
765 0 : IPosition tshape(shapeVec);
766 0 : Array<Int> tVec(tshape);
767 0 : int i(0);
768 0 : Array<Int>::iterator tVecEnd = tVec.end();
769 0 : for(Array<Int>::iterator iter = tVec.begin();
770 0 : iter != tVecEnd; ++iter)
771 0 : *iter = intVec[i++];
772 0 : theVH = new ValueHolder(tVec);
773 0 : }
774 0 : break;
775 0 : case casac::variant::DOUBLEVEC :
776 : {
777 0 : Vector<Double> doubleVec(theV.getDoubleVec());
778 0 : Vector<Int>shapeVec(theV.arrayshape());
779 0 : IPosition tshape(shapeVec);
780 0 : Array<Double> tVec(tshape);
781 0 : Array<Double>::iterator tVecEnd = tVec.end();
782 0 : int i(0);
783 0 : for(Array<Double>::iterator iter = tVec.begin();
784 0 : iter != tVecEnd; ++iter)
785 0 : *iter = doubleVec[i++];
786 0 : theVH = new ValueHolder(tVec);
787 0 : }
788 0 : break;
789 0 : case casac::variant::COMPLEXVEC :
790 : {
791 0 : Vector<DComplex> complexVec(theV.getComplexVec());
792 0 : Vector<Int>shapeVec(theV.arrayshape());
793 0 : IPosition tshape(shapeVec);
794 0 : Array<DComplex> tVec(tshape);
795 0 : Array<DComplex>::iterator tVecEnd = tVec.end();
796 0 : int i(0);
797 0 : for(Array<DComplex>::iterator iter = tVec.begin();
798 0 : iter != tVecEnd; ++iter)
799 0 : *iter = complexVec[i++];
800 0 : theVH = new ValueHolder(tVec);
801 0 : }
802 0 : break;
803 0 : case casac::variant::STRINGVEC :
804 : // Unclear whether this may leak
805 : {
806 0 : std::vector<std::string> tmp = theV.getStringVec();
807 0 : Vector<String> stringArr(toVectorString(tmp));
808 0 : Vector<Int>shapeVec(theV.arrayshape());
809 0 : IPosition tshape(shapeVec);
810 0 : Array<String> tVec(tshape);
811 0 : int i(0);
812 0 : Array<String>::iterator tVecEnd = tVec.end();
813 0 : for(Array<String>::iterator iter = tVec.begin();
814 0 : iter != tVecEnd; ++iter)
815 0 : *iter = stringArr[i++];
816 0 : theVH = new ValueHolder(tVec);
817 0 : }
818 0 : break;
819 0 : default :
820 0 : throw(AipsError("Unknown variant type!"));
821 : break;
822 : }
823 0 : return theVH;
824 0 : }
825 :
826 0 : Bool casaMDirection(const ::casac::variant& theVar,
827 : MDirection& theMeas){
828 :
829 0 : casacore::MeasureHolder mh;
830 0 : casacore::QuantumHolder qh;
831 0 : String error;
832 0 : if(theVar.type()== ::casac::variant::RECORD){
833 0 : ::casac::variant localvar(theVar); //cause its const
834 0 : std::unique_ptr<Record> ptrRec(toRecord(localvar.asRecord()));
835 0 : if(mh.fromRecord(error, *ptrRec)){
836 0 : theMeas=mh.asMDirection();
837 0 : 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 0 : }
846 0 : if(theVar.type()== ::casac::variant::STRING ||
847 0 : theVar.type()== ::casac::variant::STRINGVEC){
848 0 : Vector<String> str;
849 : //In case of compound strings with commas or empty space
850 0 : if (theVar.type()== ::casac::variant::STRING){
851 0 : sepCommaEmptyToVectorStrings(str, theVar.toString());
852 : }
853 : else{
854 0 : str=toVectorString(theVar.toStringVec());
855 : }
856 0 : if(str.nelements()==3){
857 0 : qh.fromString(error, str[1]);
858 0 : casacore::Quantity val1=qh.asQuantity();
859 0 : qh.fromString(error, str[2]);
860 0 : casacore::Quantity val2=qh.asQuantity();
861 0 : if(val2.getFullUnit()==Unit("deg") && str[2].contains(":")){
862 0 : ostringstream oss;
863 0 : oss << "NOTE: you provided the Declination/Latitude value \""<< str[2]
864 : << "\" which is understood to be in units of hours.\n"
865 0 : << " If you meant degrees, please replace \":\" by \".\".";
866 0 : cerr << oss.str() << endl;
867 0 : }
868 : MDirection::Types tp;
869 0 : if(!MDirection::getType(tp, str[0])){
870 0 : ostringstream oss;
871 0 : oss << "Could not understand Direction frame...defaulting to J2000 " ;
872 0 : cerr << oss.str() << endl;
873 0 : tp=MDirection::J2000;
874 0 : }
875 0 : theMeas=MDirection(val1,val2, tp);
876 0 : return true;
877 0 : }
878 0 : 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 0 : else if(str.nelements()==1){
894 : //Must be a string like sun, moon, jupiter
895 0 : casacore::Quantity val1(0.0, "deg");
896 0 : casacore::Quantity val2(90.0, "deg");
897 0 : theMeas=MDirection(val1, val2);
898 : MDirection::Types ref;
899 : Int numAll;
900 : Int numExtra;
901 : const uInt *dum;
902 0 : const String *allTypes=MDirection::allMyTypes(numAll, numExtra, dum);
903 : //if it is SUN moon etc
904 0 : if(MDirection::getType(ref,str[0])){
905 :
906 0 : theMeas=MDirection(val1, val2, ref);
907 0 : 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 0 : }
926 :
927 0 : }
928 : ///If i am here i don't know how to interprete this
929 :
930 :
931 0 : return false;
932 0 : }
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 0 : Bool ang_as_formatted_str(string& out, const casacore::Quantity& qang,
941 : const std::string& format, const Int precision=2)
942 : {
943 0 : Bool retval = true;
944 :
945 : try{
946 : //hms, dms, deg, rad, +deg.
947 0 : casacore::String form(format);
948 0 : form.downcase();
949 :
950 0 : Int ndig=6+precision;
951 :
952 0 : MVAngle ang(qang);
953 0 : if(form == "dms"){
954 0 : out = ang(-0.5).string(MVAngle::ANGLE, ndig+1).c_str();
955 : }
956 0 : else if(form == "hms"){
957 0 : 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 0 : }
979 0 : catch(AipsError x){
980 0 : retval = false;
981 0 : RETHROW(x);
982 0 : }
983 0 : 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 0 : Bool casaMFrequency(const ::casac::variant& theVar,
1014 : MFrequency& theMeas){
1015 0 : casacore::MeasureHolder mh;
1016 0 : casacore::QuantumHolder qh;
1017 0 : String error;
1018 0 : if(theVar.type()== ::casac::variant::RECORD){
1019 0 : ::casac::variant localvar(theVar); //cause its const
1020 0 : std::unique_ptr<Record> ptrRec(toRecord(localvar.asRecord()));
1021 0 : if(mh.fromRecord(error, *ptrRec)){
1022 0 : theMeas=mh.asMFrequency();
1023 0 : return true;
1024 : }
1025 : else{//could be a quantity
1026 0 : if(qh.fromRecord(error, *ptrRec)){
1027 0 : theMeas=MFrequency(qh.asQuantity());
1028 0 : 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 0 : }
1039 0 : if(theVar.type()== ::casac::variant::STRING ||
1040 0 : theVar.type()== ::casac::variant::STRINGVEC){
1041 0 : Vector<String> str;
1042 0 : if (theVar.type()== ::casac::variant::STRING){
1043 0 : sepCommaEmptyToVectorStrings(str, theVar.toString());
1044 : }
1045 : else{
1046 0 : str=toVectorString(theVar.toStringVec());
1047 : }
1048 0 : if(str.nelements()==2){
1049 0 : qh.fromString(error, str[1]);
1050 0 : casacore::Quantity val=qh.asQuantity();
1051 : MFrequency::Types tp;
1052 0 : if(!MFrequency::getType(tp, str[0])){
1053 :
1054 0 : cerr << "Could not understand frequency frame..defaulting to LSRK "
1055 0 : << endl;
1056 0 : tp=MFrequency::LSRK;
1057 0 : qh.fromString(error, str[0]+str[1]);
1058 0 : val=qh.asQuantity();
1059 : }
1060 0 : theMeas=MFrequency(val, tp);
1061 0 : return true;
1062 0 : }
1063 0 : else if(str.nelements()==1){
1064 0 : if(str[0]=="")
1065 0 : return false;
1066 0 : qh.fromString(error, str[0]);
1067 0 : theMeas=MFrequency(qh.asQuantity());
1068 0 : return true;
1069 : }
1070 0 : }
1071 : ///If i am here then it can be an integer or double then using Hz
1072 0 : theMeas=MFrequency(casacore::Quantity(theVar.toDouble(), "Hz"));
1073 :
1074 :
1075 0 : return true;
1076 :
1077 0 : }
1078 :
1079 0 : Bool casaMPosition(const ::casac::variant& theVar,
1080 : MPosition& theMeas){
1081 0 : casacore::MeasureHolder mh;
1082 0 : casacore::QuantumHolder qh;
1083 0 : String error;
1084 0 : if(theVar.type()== ::casac::variant::RECORD){
1085 0 : ::casac::variant localvar(theVar); //cause its const
1086 0 : std::unique_ptr<Record> ptrRec(toRecord(localvar.asRecord()));
1087 0 : if(mh.fromRecord(error, *ptrRec)){
1088 0 : theMeas=mh.asMPosition();
1089 0 : 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 0 : }
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 0 : }
1152 :
1153 :
1154 0 : Bool casaMRadialVelocity(const ::casac::variant& theVar,
1155 : MRadialVelocity& theMeas){
1156 0 : casacore::MeasureHolder mh;
1157 0 : casacore::QuantumHolder qh;
1158 0 : String error;
1159 0 : 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 0 : if(theVar.type()== ::casac::variant::STRING ||
1181 0 : theVar.type()== ::casac::variant::STRINGVEC){
1182 0 : Vector<String> str;
1183 0 : if (theVar.type()== ::casac::variant::STRING){
1184 0 : sepCommaEmptyToVectorStrings(str, theVar.toString());
1185 : }
1186 : else{
1187 0 : str=toVectorString(theVar.toStringVec());
1188 : }
1189 0 : if(str.nelements()==2){
1190 0 : qh.fromString(error, str[1]);
1191 0 : casacore::Quantity val=qh.asQuantity();
1192 : MRadialVelocity::Types tp;
1193 0 : 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 0 : theMeas=MRadialVelocity(val, tp);
1199 0 : return true;
1200 0 : }
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 0 : }
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 0 : }
1214 :
1215 0 : Bool casaMEpoch(const ::casac::variant& theVar,
1216 : MEpoch& theMeas){
1217 :
1218 0 : casacore::MeasureHolder mh;
1219 0 : casacore::QuantumHolder qh;
1220 0 : String error;
1221 0 : if(theVar.type()== ::casac::variant::RECORD){
1222 0 : ::casac::variant localvar(theVar); //cause its const
1223 0 : std::unique_ptr<Record> ptrRec(toRecord(localvar.asRecord()));
1224 0 : if(mh.fromRecord(error, *ptrRec)){
1225 0 : theMeas=mh.asMEpoch();
1226 0 : 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 0 : }
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 0 : }
1279 0 : Int sepCommaEmptyToVectorStrings(Vector<String>& lesStrings,
1280 : const std::string& str){
1281 :
1282 0 : casacore::String oneStr=String(str);
1283 0 : Int nsep=0;
1284 : // decide if its comma seperated or empty space seperated
1285 0 : casacore::String sep;
1286 0 : if((nsep=oneStr.freq(",")) > 0){
1287 0 : sep=",";
1288 : }
1289 : else {
1290 0 : nsep=oneStr.freq(" ");
1291 0 : sep=" ";
1292 : }
1293 0 : if(nsep == 0){
1294 0 : lesStrings.resize(1);
1295 0 : lesStrings=oneStr;
1296 0 : nsep=1;
1297 : }
1298 : else{
1299 0 : String *splitstrings = new String[nsep+1];
1300 0 : nsep=split(oneStr, splitstrings, nsep+1, sep);
1301 0 : lesStrings.resize(nsep);
1302 0 : Int index=0;
1303 0 : for (Int k=0; k < nsep; ++k){
1304 0 : if((String(splitstrings[k]) == String(""))
1305 0 : || (String(splitstrings[k]) == String(" "))){
1306 0 : lesStrings.resize(lesStrings.nelements()-1, true);
1307 : }
1308 : else{
1309 0 : lesStrings[index]=splitstrings[k];
1310 0 : ++index;
1311 : }
1312 : }
1313 0 : delete [] splitstrings;
1314 : }
1315 :
1316 0 : return nsep;
1317 :
1318 0 : }
1319 :
1320 0 : Int sepCommaToVectorStrings(Vector<String>& lesStrings,
1321 : const std::string& str){
1322 :
1323 0 : casacore::String oneStr=String(str);
1324 : // decide if its comma seperated or empty space seperated
1325 0 : String sep=",";
1326 0 : Int nsep=oneStr.freq(sep);
1327 0 : if(nsep == 0){
1328 0 : lesStrings.resize(1);
1329 0 : lesStrings=oneStr;
1330 0 : nsep=1;
1331 : }
1332 : else{
1333 0 : String *splitstrings = new String[nsep+1];
1334 0 : nsep=split(oneStr, splitstrings, nsep+1, sep);
1335 0 : lesStrings.resize(nsep);
1336 0 : Int index=0;
1337 0 : for (Int k=0; k < nsep; ++k){
1338 0 : if((String(splitstrings[k]) == String(""))
1339 0 : || (String(splitstrings[k]) == String(" "))){
1340 0 : lesStrings.resize(lesStrings.nelements()-1, true);
1341 : }
1342 : else{
1343 0 : lesStrings[index]=splitstrings[k];
1344 0 : ++index;
1345 : }
1346 : }
1347 0 : delete [] splitstrings;
1348 : }
1349 :
1350 0 : return nsep;
1351 :
1352 0 : }
1353 :
1354 0 : vector<double> toVectorDouble(const casac::variant& v, const String& varName) {
1355 0 : vector<double> ret(0);
1356 0 : switch (v.type()) {
1357 0 : case casac::variant::BOOLVEC:
1358 0 : 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 0 : case casac::variant::INTVEC:
1364 : case casac::variant::DOUBLEVEC:
1365 0 : 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 0 : }
1379 :
1380 0 : vector<string> toVectorString(const ::casac::variant& v, const String& varName) {
1381 0 : vector<string> ret(0);
1382 0 : switch (v.type()) {
1383 0 : case casac::variant::BOOLVEC:
1384 0 : return ret;
1385 0 : case casac::variant::STRING:
1386 0 : if (v.toString().size() > 0) {
1387 0 : ret.push_back(v.toString());
1388 : }
1389 0 : return ret;
1390 0 : case casac::variant::STRINGVEC:
1391 0 : 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 0 : }
1398 :
1399 0 : vector<int> toVectorInt(const ::casac::variant& v, const String& varName) {
1400 0 : vector<int> ret(0);
1401 0 : switch (v.type()) {
1402 0 : case casac::variant::BOOLVEC:
1403 0 : return ret;
1404 0 : case casac::variant::INT:
1405 0 : ret.push_back(v.toInt());
1406 0 : 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 0 : }
1425 :
1426 0 : vector<bool> toVectorBool(const ::casac::variant& v, const String& varName) {
1427 0 : vector<bool> ret(0);
1428 0 : switch (v.type()) {
1429 0 : case casac::variant::BOOLVEC:
1430 0 : 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 0 : }
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
|
