Changeset 6222 in ntrip


Ignore:
Timestamp:
Oct 11, 2014, 1:57:19 PM (8 years ago)
Author:
mervart
Message:
 
Location:
trunk/BNC/src/rinex
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • trunk/BNC/src/rinex/rnxobsfile.cpp

    r6221 r6222  
    212212}
    213213
     214// Set Default Header
     215////////////////////////////////////////////////////////////////////////////
     216void t_rnxObsHeader::setDefault(const QString& markerName, int version) {
     217
     218  _markerName = markerName;
     219
     220  if (version <= 2) {
     221    _version = t_rnxObsHeader::defaultRnxObsVersion2;
     222  }
     223  else {
     224    _version = t_rnxObsHeader::defaultRnxObsVersion3;
     225  }
     226
     227  _comments << "Default set of observation types used";
     228
     229  _obsTypes.clear();
     230  if (_version < 3.0) {
     231    _obsTypes['G'] << "C1" << "P1" << "L1" << "S1"
     232                   << "C2" << "P2" << "L2" << "S2";
     233    _obsTypes['R'] = _obsTypes['G'];
     234    _obsTypes['E'] = _obsTypes['G'];
     235    _obsTypes['J'] = _obsTypes['G'];
     236    _obsTypes['S'] = _obsTypes['G'];
     237    _obsTypes['C'] = _obsTypes['G'];
     238  }
     239  else {
     240    _obsTypes['G'] << "C1C" << "L1C"  << "S1C"
     241                   << "C2W" << "L2W"  << "S2W"
     242                   << "C5"  << "L5"   << "S5";
     243   
     244    _obsTypes['J'] = _obsTypes['G'];
     245   
     246    _obsTypes['R'] << "C1C" << "L1C" << "S1C"
     247                   << "C2P" << "L2P" << "S2P";
     248   
     249    _obsTypes['E'] << "C1" << "L1" << "S1"
     250                   << "C5" << "L5" << "S5"
     251                   << "C7" << "L7" << "S7"
     252                   << "C8" << "L8" << "S8";
     253   
     254    _obsTypes['S'] << "C1" << "L1" << "S1"
     255                   << "C5" << "L5" << "S5";
     256   
     257    _obsTypes['C'] << "C1" << "L1" << "S1"
     258                   << "C6" << "L6" << "S6"
     259                   << "C7" << "L7" << "S7";
     260  }
     261}
     262
     263// Copy header
     264////////////////////////////////////////////////////////////////////////////
     265void t_rnxObsHeader::set(const t_rnxObsHeader& header, int version,
     266                         const QStringList* useObsTypes) {
     267
     268  if (version <= 2) {
     269    _version = t_rnxObsHeader::defaultRnxObsVersion2;
     270  }
     271  else {
     272    _version = t_rnxObsHeader::defaultRnxObsVersion3;
     273  }
     274  _interval        = header._interval;   
     275  _antennaNumber   = header._antennaNumber;
     276  _antennaName     = header._antennaName;
     277  _markerName      = header._markerName; 
     278  _markerNumber    = header._markerNumber; 
     279  _antNEU          = header._antNEU;     
     280  _antXYZ          = header._antXYZ;     
     281  _antBSG          = header._antBSG;     
     282  _xyz             = header._xyz;         
     283  _observer        = header._observer;       
     284  _agency          = header._agency;         
     285  _receiverNumber  = header._receiverNumber;
     286  _receiverType    = header._receiverType;   
     287  _receiverVersion = header._receiverVersion;
     288  _startTime       =  header._startTime;   
     289  for (unsigned iPrn = 1; iPrn <= t_prn::MAXPRN_GPS; iPrn++) {
     290    _wlFactorsL1[iPrn] =  header._wlFactorsL1[iPrn];
     291    _wlFactorsL2[iPrn] =  header._wlFactorsL2[iPrn];
     292  }
     293
     294  // Set observation types
     295  // ---------------------
     296  _obsTypes.clear();
     297  if (!useObsTypes || useObsTypes->size() == 0) {
     298    if      (int(_version) == int(header._version)) {
     299      _obsTypes = header._obsTypes;
     300    }
     301    else {
     302      for (int iSys = 0; iSys < header.numSys(); iSys++) {
     303        char sys = header.system(iSys);
     304        for (int iType = 0; iType < header.nTypes(sys); iType++) {
     305          _obsTypes[sys].push_back(header.obsType(sys, iType, _version));
     306        }
     307      }
     308    }
     309  }
     310  else {
     311    for (int iType = 0; iType < useObsTypes->size(); iType++) {
     312      if (useObsTypes->at(iType).indexOf(":") != -1) {
     313        QStringList hlp = useObsTypes->at(iType).split(":", QString::SkipEmptyParts);
     314        if (hlp.size() == 2 && hlp[0].length() == 1) {
     315          char    sys  = hlp[0][0].toAscii();
     316          QString type = hlp[1];
     317          _obsTypes[sys].push_back(type);
     318        }
     319      }
     320      else {
     321        for (int iSys = 0; iSys < t_rnxObsHeader::defaultSystems.length(); iSys++) {
     322          char sys = t_rnxObsHeader::defaultSystems[iSys].toAscii();
     323          _obsTypes[sys].push_back(useObsTypes->at(iType));
     324        }
     325      }
     326    }
     327  }
     328}
     329
    214330// Write Header
    215331////////////////////////////////////////////////////////////////////////////
     
    740856}
    741857
    742 // Set Header Information
    743 ////////////////////////////////////////////////////////////////////////////
    744 void t_rnxObsFile::setHeader(const t_rnxObsHeader& header, double version,
    745                              const QStringList& useObsTypes) {
    746 
    747   if (version < 3.0) {
    748     _header._version = t_rnxObsHeader::defaultRnxObsVersion2;
    749   }
    750   else {
    751     _header._version = t_rnxObsHeader::defaultRnxObsVersion3;
    752   }
    753   _header._interval        = header._interval;   
    754   _header._antennaNumber   = header._antennaNumber;
    755   _header._antennaName     = header._antennaName;
    756   _header._markerName      = header._markerName; 
    757   _header._markerNumber    = header._markerNumber; 
    758   _header._antNEU          = header._antNEU;     
    759   _header._antXYZ          = header._antXYZ;     
    760   _header._antBSG          = header._antBSG;     
    761   _header._xyz             = header._xyz;         
    762   _header._observer        = header._observer;       
    763   _header._agency          = header._agency;         
    764   _header._receiverNumber  = header._receiverNumber;
    765   _header._receiverType    = header._receiverType;   
    766   _header._receiverVersion = header._receiverVersion;
    767   _header._startTime       =  header._startTime;   
    768   for (unsigned iPrn = 1; iPrn <= t_prn::MAXPRN_GPS; iPrn++) {
    769     _header._wlFactorsL1[iPrn] =  header._wlFactorsL1[iPrn];
    770     _header._wlFactorsL2[iPrn] =  header._wlFactorsL2[iPrn];
    771   }
    772 
    773   // Set observation types
    774   // ---------------------
    775   _header._obsTypes.clear();
    776   if (useObsTypes.size() == 0) {
    777     if      (int(_header._version) == int(header._version)) {
    778       _header._obsTypes = header._obsTypes;
    779     }
    780     else {
    781       for (int iSys = 0; iSys < header.numSys(); iSys++) {
    782         char sys = header.system(iSys);
    783         for (int iType = 0; iType < header.nTypes(sys); iType++) {
    784           _header._obsTypes[sys].push_back(header.obsType(sys, iType, _header._version));
    785         }
    786       }
    787     }
    788   }
    789   else {
    790     for (int iType = 0; iType < useObsTypes.size(); iType++) {
    791       if (useObsTypes[iType].indexOf(":") != -1) {
    792         QStringList hlp = useObsTypes[iType].split(":", QString::SkipEmptyParts);
    793         if (hlp.size() == 2 && hlp[0].length() == 1) {
    794           char    sys  = hlp[0][0].toAscii();
    795           QString type = hlp[1];
    796           _header._obsTypes[sys].push_back(type);
    797         }
    798       }
    799       else {
    800         for (int iSys = 0; iSys < t_rnxObsHeader::defaultSystems.length(); iSys++) {
    801           char sys = t_rnxObsHeader::defaultSystems[iSys].toAscii();
    802           _header._obsTypes[sys].push_back(useObsTypes[iType]);
    803         }
    804       }
    805     }
    806   }
    807 }
    808 
    809858// Write Data Epoch
    810859////////////////////////////////////////////////////////////////////////////
    811860void t_rnxObsFile::writeEpoch(const t_rnxEpo* epo) {
    812861  if (version() < 3.0) {
    813     return writeEpochV2(epo);
     862    return writeEpochV2(_stream, _header, epo);
    814863  }
    815864  else {
    816     return writeEpochV3(epo);
     865    return writeEpochV3(_stream, _header, epo);
    817866  }
    818867}
     
    820869// Write Data Epoch (RINEX Version 2)
    821870////////////////////////////////////////////////////////////////////////////
    822 void t_rnxObsFile::writeEpochV2(const t_rnxEpo* epo) {
     871void t_rnxObsFile::writeEpochV2(QTextStream* stream, const t_rnxObsHeader& header,
     872                                const t_rnxEpo* epo) {
    823873
    824874  unsigned year, month, day, hour, min;
     
    837887
    838888  int flag = 0;
    839   *_stream << dateStr << QString("%1%2").arg(flag, 3).arg(epo->rnxSat.size(), 3);
     889  *stream << dateStr << QString("%1%2").arg(flag, 3).arg(epo->rnxSat.size(), 3);
    840890  for (unsigned iSat = 0; iSat < epo->rnxSat.size(); iSat++) {
    841891    const t_rnxSat& rnxSat = epo->rnxSat[iSat];
    842892    if (iSat > 0 && iSat % 12 == 0) {
    843       *_stream << endl << QString().leftJustified(32);
    844     }
    845     *_stream << rnxSat.prn.toString().c_str();
    846   }
    847   *_stream << endl;
     893      *stream << endl << QString().leftJustified(32);
     894    }
     895    *stream << rnxSat.prn.toString().c_str();
     896  }
     897  *stream << endl;
    848898  for (unsigned iSat = 0; iSat < epo->rnxSat.size(); iSat++) {
    849899
     
    851901    char            sys    = rnxSat.prn.system();
    852902
    853     for (int iTypeV2 = 0; iTypeV2 < nTypes(sys); iTypeV2++) {
     903    for (int iTypeV2 = 0; iTypeV2 < header.nTypes(sys); iTypeV2++) {
    854904      if (iTypeV2 > 0 && iTypeV2 % 5 == 0) {
    855         *_stream << endl;
    856       }
    857       QString typeV2 = obsType(sys, iTypeV2);
     905        *stream << endl;
     906      }
     907      QString typeV2 = header.obsType(sys, iTypeV2);
    858908      bool    found  = false;
    859909      QMapIterator<QString, t_rnxObs> itObs(rnxSat.obs);
     
    865915          found = true;
    866916          if (rnxObs.value == 0.0) {
    867             *_stream << QString().leftJustified(16);
     917            *stream << QString().leftJustified(16);
    868918          }
    869919          else {
    870             *_stream << QString("%1").arg(rnxObs.value, 14, 'f', 3);
     920            *stream << QString("%1").arg(rnxObs.value, 14, 'f', 3);
    871921            if (rnxObs.lli != 0.0) {
    872               *_stream << QString("%1").arg(rnxObs.lli,1);
     922              *stream << QString("%1").arg(rnxObs.lli,1);
    873923            }
    874924            else {
    875               *_stream << ' ';
     925              *stream << ' ';
    876926            }
    877927            if (rnxObs.snr != 0.0) {
    878               *_stream << QString("%1").arg(rnxObs.snr,1);
     928              *stream << QString("%1").arg(rnxObs.snr,1);
    879929            }
    880930            else {
    881               *_stream << ' ';
     931              *stream << ' ';
    882932            }
    883933          }
     
    886936      }
    887937      if (!found) {
    888         *_stream << QString().leftJustified(16);
    889       }
    890     }
    891     *_stream << endl;
     938        *stream << QString().leftJustified(16);
     939      }
     940    }
     941    *stream << endl;
    892942  }
    893943}
     
    895945// Write Data Epoch (RINEX Version 3)
    896946////////////////////////////////////////////////////////////////////////////
    897 void t_rnxObsFile::writeEpochV3(const t_rnxEpo* epo) {
     947void t_rnxObsFile::writeEpochV3(QTextStream* stream, const t_rnxObsHeader& header,
     948                                const t_rnxEpo* epo) {
    898949
    899950  unsigned year, month, day, hour, min;
     
    912963
    913964  int flag = 0;
    914   *_stream << dateStr << QString("%1%2\n").arg(flag, 3).arg(epo->rnxSat.size(), 3);
     965  *stream << dateStr << QString("%1%2\n").arg(flag, 3).arg(epo->rnxSat.size(), 3);
    915966
    916967  for (unsigned iSat = 0; iSat < epo->rnxSat.size(); iSat++) {
     
    918969    char            sys    = rnxSat.prn.system();
    919970
    920     *_stream << rnxSat.prn.toString().c_str();
    921 
    922     for (int iTypeV3 = 0; iTypeV3 < nTypes(sys); iTypeV3++) {
    923       QString typeV3 = obsType(sys, iTypeV3);
     971    *stream << rnxSat.prn.toString().c_str();
     972
     973    for (int iTypeV3 = 0; iTypeV3 < header.nTypes(sys); iTypeV3++) {
     974      QString typeV3 = header.obsType(sys, iTypeV3);
    924975      bool    found  = false;
    925976      QMapIterator<QString, t_rnxObs> itObs(rnxSat.obs);
     
    931982          found = true;
    932983          if (rnxObs.value == 0.0) {
    933             *_stream << QString().leftJustified(16);
     984            *stream << QString().leftJustified(16);
    934985          }
    935986          else {
    936             *_stream << QString("%1").arg(rnxObs.value, 14, 'f', 3);
     987            *stream << QString("%1").arg(rnxObs.value, 14, 'f', 3);
    937988            if (rnxObs.lli != 0.0) {
    938               *_stream << QString("%1").arg(rnxObs.lli,1);
     989              *stream << QString("%1").arg(rnxObs.lli,1);
    939990            }
    940991            else {
    941               *_stream << ' ';
     992              *stream << ' ';
    942993            }
    943994            if (rnxObs.snr != 0.0) {
    944               *_stream << QString("%1").arg(rnxObs.snr,1);
     995              *stream << QString("%1").arg(rnxObs.snr,1);
    945996            }
    946997            else {
    947               *_stream << ' ';
     998              *stream << ' ';
    948999            }
    9491000          }
     
    9511002      }
    9521003      if (!found) {
    953         *_stream << QString().leftJustified(16);
    954       }
    955     }
    956     *_stream << endl;
     1004        *stream << QString().leftJustified(16);
     1005      }
     1006    }
     1007    *stream << endl;
    9571008  }
    9581009}
  • trunk/BNC/src/rinex/rnxobsfile.h

    r6221 r6222  
    5252
    5353  t_irc       read(QTextStream* stream, int maxLines = 0);
     54  void        setDefault(const QString& markerName, int version);
     55  void        set(const t_rnxObsHeader& header, int version, const QStringList* useObsTypes = 0);
    5456  int         numSys() const;
    5557  char        system(int iSys) const;
     
    145147
    146148  t_rnxEpo* nextEpoch();
     149
    147150  int wlFactorL1(unsigned iPrn) {
    148151    return iPrn <= t_prn::MAXPRN_GPS ? _header._wlFactorsL1[iPrn] : 1;
     
    153156
    154157  const t_rnxObsHeader& header() const {return _header;}
    155   void setHeader(const t_rnxObsHeader& header, double version, const QStringList& useObsTypes);
     158
     159  void setHeader(const t_rnxObsHeader& header, int version, const QStringList* useObsTypes = 0) {
     160    _header.set(header, version, useObsTypes);
     161  }
     162
    156163  void writeEpoch(const t_rnxEpo* epo);
    157164
    158165  QTextStream* stream() {return _stream;}
    159166
    160   static void setObsFromRnx(const t_rnxObsFile* rnxObsFile,
    161                             const t_rnxObsFile::t_rnxEpo* epo,
    162                             const t_rnxObsFile::t_rnxSat& rnxSat,
    163                             t_satObs& obs);
     167  static void setObsFromRnx(const t_rnxObsFile* rnxObsFile, const t_rnxObsFile::t_rnxEpo* epo,
     168                            const t_rnxObsFile::t_rnxSat& rnxSat, t_satObs& obs);
    164169
    165170  static QString type2to3(char sys, const QString& typeV2);
    166171  static QString type3to2(char sys, const QString& typeV3);
     172
     173  static void writeEpochV2(QTextStream* stream, const t_rnxObsHeader& header, const t_rnxEpo* epo);
     174  static void writeEpochV3(QTextStream* stream, const t_rnxObsHeader& header, const t_rnxEpo* epo);
    167175
    168176 private:
Note: See TracChangeset for help on using the changeset viewer.