Changeset 6119 in ntrip


Ignore:
Timestamp:
Sep 11, 2014, 2:06:12 PM (7 years ago)
Author:
mervart
Message:
 
Location:
trunk/BNC/src/rinex
Files:
2 edited

Legend:

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

    r5883 r6119  
    4848using namespace std;
    4949
    50 const QString t_rnxObsHeader::_emptyStr;
     50const QString t_rnxObsHeader::defaultSystems = "GRES";
    5151
    5252// Constructor
     
    162162      int nTypes;
    163163      *in >> nTypes;
    164       _obsTypesV2.clear();
     164      char sys = defaultSystems[0].toAscii();
     165      _obsTypes[sys].clear();
    165166      for (int ii = 0; ii < nTypes; ii++) {
    166167        if (ii > 0 && ii % 9 == 0) {
     
    171172        QString hlp;
    172173        *in >> hlp;
    173         _obsTypesV2.append(hlp);
     174        _obsTypes[sys].append(hlp);
     175      }
     176      for (int ii = 1; ii < defaultSystems.length(); ii++) {
     177        char sys = defaultSystems[ii].toAscii();
     178        _obsTypes[sys] = _obsTypes[0];
    174179      }
    175180    }
     
    179184      int nTypes;
    180185      *in >> sys >> nTypes;
    181       _obsTypesV3[sys].clear();
     186      _obsTypes[sys].clear();
    182187      for (int ii = 0; ii < nTypes; ii++) {
    183188        if (ii > 0 && ii % 13 == 0) {
     
    188193        QString hlp;
    189194        *in >> hlp;
    190         _obsTypesV3[sys].push_back(hlp);
     195        _obsTypes[sys].push_back(hlp);
    191196      }
    192197      delete in;
     
    331336}
    332337
     338// Number of Different Systems
     339////////////////////////////////////////////////////////////////////////////
     340int t_rnxObsHeader::numSys() const {
     341  return _obsTypes.size();
     342}
     343
    333344// Number of Observation Types (satellite-system specific)
    334345////////////////////////////////////////////////////////////////////////////
    335346int t_rnxObsHeader::nTypes(char sys) const {
     347  if (_obsTypes.contains(sys)) {
     348    return _obsTypes[sys].size();
     349  }
     350  else {
     351    return 0;
     352  }
     353}
     354
     355// Observation Type (satellite-system specific)
     356////////////////////////////////////////////////////////////////////////////
     357QString t_rnxObsHeader::obsType(char sys, int index) const {
     358  if (_obsTypes.contains(sys)) {
     359    return _obsTypes[sys].at(index);
     360  }
     361  else {
     362    return "";
     363  }
     364}
     365
     366// Write Observation Types
     367////////////////////////////////////////////////////////////////////////////
     368QStringList t_rnxObsHeader::obsTypesStrings() const {
     369
     370  QStringList strList;
     371
    336372  if (_version < 3.0) {
    337     return _obsTypesV2.size();
    338   }
    339   else {
    340     if (_obsTypesV3.contains(sys)) {
    341       return _obsTypesV3[sys].size();
    342     }
    343     else {
    344       return 0;
    345     }
    346   }
    347 }
    348 
    349 // Observation Type (satellite-system specific)
    350 ////////////////////////////////////////////////////////////////////////////
    351 const QString& t_rnxObsHeader::obsType(char sys, int index) const {
    352   if (_version < 3.0) {
    353     return _obsTypesV2.at(index);
    354   }
    355   else {
    356     if (_obsTypesV3.contains(sys)) {
    357       return _obsTypesV3[sys].at(index);
    358     }
    359     else {
    360       return _emptyStr;
    361     }
    362   }
    363 }
    364 
    365 // Write Observation Types
    366 ////////////////////////////////////////////////////////////////////////////
    367 QStringList t_rnxObsHeader::obsTypesStrings() const {
    368 
    369   QStringList strList;
    370 
    371   if (_version < 3.0) {
     373    char sys = defaultSystems[0].toAscii();
    372374    QString hlp;
    373     QTextStream(&hlp) << QString("%1").arg(_obsTypesV2.size(), 6);
    374     for (int ii = 0; ii < _obsTypesV2.size(); ii++) {
    375       QTextStream(&hlp) << QString("%1").arg(_obsTypesV2[ii], 6);   
    376       if ((ii+1) % 9 == 0 || ii == _obsTypesV2.size()-1) {
     375    QTextStream(&hlp) << QString("%1").arg(_obsTypes[sys].size(), 6);
     376    for (int ii = 0; ii < _obsTypes[sys].size(); ii++) {
     377      QTextStream(&hlp) << QString("%1").arg(_obsTypes[sys][ii], 6);   
     378      if ((ii+1) % 9 == 0 || ii == _obsTypes[sys].size()-1) {
    377379        strList.append(hlp.leftJustified(60) + "# / TYPES OF OBSERV\n");
    378380        hlp = QString().leftJustified(6);
     
    381383  }
    382384  else {
    383     QMapIterator<char, QVector<QString> > it(_obsTypesV3);
     385    QMapIterator<char, QVector<QString> > it(_obsTypes);
    384386    while (it.hasNext()) {
    385387      it.next();
     
    407409  _stream       = 0;
    408410  _flgPowerFail = false;
    409   _trafo        = trafoNone;
    410411  if (_inpOut == input) {
    411412    openRead(fileName);
     
    536537////////////////////////////////////////////////////////////////////////////
    537538t_rnxObsFile::t_rnxEpo* t_rnxObsFile::nextEpoch() {
    538 
    539539  _currEpo.clear();
    540 
    541540  if (version() < 3.0) {
    542541    return nextEpochV2();
     
    589588    for (int iSat = 0; iSat < numSat; iSat++) {
    590589      line = _stream->readLine();
    591       _currEpo.rnxSat[iSat].satSys = line.toAscii()[0];
    592       readInt(line, 1, 2, _currEpo.rnxSat[iSat].satNum);
    593       char sys = line.toAscii()[0];
     590      t_prn prn; prn.set(line.left(3).toAscii().data());
     591      _currEpo.rnxSat[iSat].prn = prn;
     592      char sys = prn.system();
    594593      for (int iType = 0; iType < _header.nTypes(sys); iType++) {
    595594        int pos = 3 + 16*iType;
     
    600599        readInt(line, pos + 14, 1, lli);
    601600        readInt(line, pos + 15, 1, snr);
    602 
    603601        if (_flgPowerFail) {
    604602          lli |= 1;
    605603        }
    606 
    607         _currEpo.rnxSat[iSat].obs.push_back(obsValue);
    608         _currEpo.rnxSat[iSat].lli.push_back(lli);
    609         _currEpo.rnxSat[iSat].snr.push_back(snr);
     604        QString type = obsType(sys, iType);
     605        _currEpo.rnxSat[iSat].obs[type].value = obsValue;
     606        _currEpo.rnxSat[iSat].obs[type].lli   = lli;
     607        _currEpo.rnxSat[iSat].obs[type].snr   = snr;
    610608      }
    611609    }
     
    672670      }
    673671
    674       _currEpo.rnxSat[iSat].satSys = line.toAscii()[pos];
    675       if (_currEpo.rnxSat[iSat].satSys == ' ') {
    676         _currEpo.rnxSat[iSat].satSys = 'G';
    677       }
    678       readInt(line, pos + 1, 2, _currEpo.rnxSat[iSat].satNum);
    679 
     672      char sys = line.toAscii()[pos];
     673      int satNum; readInt(line, pos + 1, 2, satNum);
     674      _currEpo.rnxSat[iSat].prn.set(sys, satNum);
     675 
    680676      pos += 3;
    681677    }
     
    684680    // ------------------------
    685681    for (int iSat = 0; iSat < numSat; iSat++) {
     682      char sys = _currEpo.rnxSat[iSat].prn.system();
    686683      line = _stream->readLine();
    687684      pos  = 0;
    688       for (int iType = 0; iType < _header.nTypes(_currEpo.rnxSat[iSat].satSys); iType++) {
     685      for (int iType = 0; iType < _header.nTypes(sys); iType++) {
    689686        if (iType > 0 && iType % 5 == 0) {
    690687          line = _stream->readLine();
     
    702699        }
    703700
    704         _currEpo.rnxSat[iSat].obs.push_back(obsValue);
    705         _currEpo.rnxSat[iSat].lli.push_back(lli);
    706         _currEpo.rnxSat[iSat].snr.push_back(snr);
     701        QString type = obsType(sys, iType);
     702        _currEpo.rnxSat[iSat].obs[type].value = obsValue;
     703        _currEpo.rnxSat[iSat].obs[type].lli   = lli;
     704        _currEpo.rnxSat[iSat].obs[type].snr   = snr;
    707705
    708706        pos += 16;
     
    720718// Set Header Information
    721719////////////////////////////////////////////////////////////////////////////
    722 void t_rnxObsFile::setHeader(const t_rnxObsHeader& header, double version) {
    723 
    724   if      (int(header._version) == int(version)) {
    725     _trafo           = trafoNone;
    726     _header._version = header._version;
    727   }
    728   else if (version >= 3.0) {
    729     _trafo           = trafo2to3;
     720void t_rnxObsFile::setHeader(const t_rnxObsHeader& header, double version,
     721                             const QStringList& useObsTypes) {
     722
     723  if (version >= 3.0) {
    730724    _header._version = t_rnxObsHeader::defaultRnxObsVersion3;
    731725  }
    732726  else {
    733     _trafo           = trafo3to2;
    734727    _header._version = t_rnxObsHeader::defaultRnxObsVersion2;
    735728  }
    736 
    737729  _header._interval        = header._interval;   
    738730  _header._antennaNumber   = header._antennaNumber;
     
    749741  _header._receiverType    = header._receiverType;   
    750742  _header._receiverVersion = header._receiverVersion;
    751 
     743  _header._startTime       =  header._startTime;   
    752744  for (unsigned iPrn = 1; iPrn <= t_prn::MAXPRN_GPS; iPrn++) {
    753745    _header._wlFactorsL1[iPrn] =  header._wlFactorsL1[iPrn];
     
    755747  }
    756748
    757   _header._startTime   =  header._startTime;   
    758 
    759   static const string systems = "GRES";
    760 
    761   _header._obsTypesV2.clear();
    762   _header._obsTypesV3.clear();
    763 
    764   // Copy Observation Types
    765   // ----------------------
    766   if      (_trafo == trafoNone) {
    767     for (int ii = 0; ii < header._obsTypesV2.size(); ii++) {
    768       _header._obsTypesV2.append(header._obsTypesV2[ii]);
    769     }
    770     QMapIterator<char, QVector<QString> > it(header._obsTypesV3);
    771     while (it.hasNext()) {
    772       it.next();
    773       char                    sys     = it.key();
    774       const QVector<QString>& typesV3 = it.value();
    775       for (int ii = 0; ii < typesV3.size(); ii++) {
    776         _header._obsTypesV3[sys].push_back(typesV3[ii]);
    777       }
    778     }
    779   }
    780 
    781   // Translate Observation Types v2 --> v3
    782   // -------------------------------------
    783   else if (_trafo == trafo2to3) {
    784     for (int i2 = 0; i2 < header._obsTypesV2.size(); i2++) {
    785       const QString& typeV2 = header._obsTypesV2[i2];
    786       for (unsigned iSys = 0; iSys < systems.length(); iSys++) {
    787         char    sys    = systems[iSys];
    788         QString typeV3 = type2to3(sys, typeV2);
    789         if (!typeV3.isEmpty()) {
    790           _header._obsTypesV3[sys].push_back(typeV3);
    791           int i3 = _header._obsTypesV3[sys].size() - 1;
    792           _indexMap3to2[sys][i3] = i2;
    793         }
    794       }
    795     }
    796   }
    797 
    798   // Translate Observation Types v3 --> v2
    799   // -------------------------------------
    800   else if (_trafo == trafo3to2) {
    801     for (unsigned iSys = 0; iSys < systems.length(); iSys++) {
    802       char sys = systems[iSys];
    803       if (header._obsTypesV3.contains(sys)) {
    804         const QVector<QString>& typesV3 = header._obsTypesV3[sys];
    805         for (int i3 = 0; i3 < typesV3.size(); i3++) {
    806           const QString& typeV3 = typesV3[i3];
    807           QString        typeV2 = type3to2(typeV3);
    808           if (!typeV2.isEmpty()) {
    809             bool found = false;
    810             for (int i2 = 0; i2 < _header._obsTypesV2.size(); i2++) {
    811               if (_header._obsTypesV2[i2] == typeV2) {
    812                 found = true;
    813                 if (_indexMap2to3[sys].find(i2) == _indexMap2to3[sys].end()) {
    814                   _indexMap2to3[sys][i2] = i3;
    815                 }
    816                 break;
    817               }
    818             }
    819             if (!found) {
    820               _header._obsTypesV2.append(typeV2);
    821               int i2 = _header._obsTypesV2.size() - 1;
    822               _indexMap2to3[sys][i2] = i3;
    823             }
    824           }
     749  // Set observation types
     750  // ---------------------
     751  _header._obsTypes.clear();
     752  if (useObsTypes.size() == 0) {
     753    _header._obsTypes = header._obsTypes;
     754  }
     755  else {
     756    if (_header._version < 3.0) {
     757      char sys = t_rnxObsHeader::defaultSystems[0].toAscii();
     758      for (int ii = 0; ii < useObsTypes.size(); ii++) {
     759        _header._obsTypes[sys].push_back(useObsTypes[ii]);
     760      }
     761      for (int ii = 1; ii < t_rnxObsHeader::defaultSystems.length(); ii++) {
     762        char sys = t_rnxObsHeader::defaultSystems[ii].toAscii();
     763        _header._obsTypes[sys] = _header._obsTypes[0];
     764      }
     765    }
     766    else {
     767      for (int ii = 0; ii < useObsTypes.size(); ii++) {
     768        QStringList hlp = useObsTypes[ii].split(":", QString::SkipEmptyParts);
     769        if (hlp.size() == 2 && hlp[0].length() == 1) {
     770          char    sys  = hlp[0][0].toAscii();
     771          QString type = hlp[1];
     772          _header._obsTypes[sys].push_back(type);
    825773        }
    826774      }
     
    866814      *_stream << endl << QString().leftJustified(32);
    867815    }
    868     *_stream << rnxSat.satSys << QString("%1").arg(rnxSat.satNum, 2);
     816    *_stream << rnxSat.prn;
    869817  }
    870818  *_stream << endl;
     
    872820
    873821    const t_rnxSat& rnxSat = epo->rnxSat[iSat];
    874     char            sys    = rnxSat.satSys;
    875 
    876     for (int iTypeV2 = 0; iTypeV2 < nTypes(sys); iTypeV2++) {
    877 
    878       if (iTypeV2 > 0 && iTypeV2 % 5 == 0) {
     822    char            sys    = rnxSat.prn.system();
     823
     824    for (int iType = 0; iType < nTypes(sys); iType++) {
     825      if (iType > 0 && iType % 5 == 0) {
    879826        *_stream << endl;
    880827      }
    881 
    882       int iType = -1;
    883       if   (_trafo == trafoNone) {
    884         iType = iTypeV2;
     828      QString type = obsType(sys, iType);
     829      if (!rnxSat.obs.contains(type)) {
     830        *_stream << QString().leftJustified(16);
    885831      }
    886832      else {
    887         if (_indexMap2to3[sys].find(iTypeV2) != _indexMap2to3[sys].end()) {
    888           iType = _indexMap2to3[sys][iTypeV2];
    889         }
    890       }
    891 
    892       if (iType == -1 || rnxSat.obs[iType] == 0.0) {
    893         *_stream << QString().leftJustified(16);
    894       }
    895       else {
    896         *_stream << QString("%1").arg(rnxSat.obs[iType], 14, 'f', 3);
    897         if (rnxSat.lli[iType] != 0.0) {
    898           *_stream << QString("%1").arg(rnxSat.lli[iType],1);
     833        const t_rnxObs& rnxObs = rnxSat.obs[type];
     834        *_stream << QString("%1").arg(rnxObs.value, 14, 'f', 3);
     835        if (rnxObs.lli != 0.0) {
     836          *_stream << QString("%1").arg(rnxObs.lli,1);
    899837        }
    900838        else {
    901839          *_stream << ' ';
    902840        }
    903         if (rnxSat.snr[iType] != 0.0) {
    904           *_stream << QString("%1").arg(rnxSat.snr[iType],1);
     841        if (rnxObs.snr != 0.0) {
     842          *_stream << QString("%1").arg(rnxObs.snr,1);
    905843        }
    906844        else {
     
    937875  for (unsigned iSat = 0; iSat < epo->rnxSat.size(); iSat++) {
    938876    const t_rnxSat& rnxSat = epo->rnxSat[iSat];
    939     char            sys    = rnxSat.satSys;
    940     *_stream << sys
    941              << QString("%1").arg(rnxSat.satNum, 2, 10, QChar('0'));
    942 
    943     for (int iTypeV3 = 0; iTypeV3 < nTypes(sys); iTypeV3++) {
    944 
    945       int iType = -1;
    946       if   (_trafo == trafoNone) {
    947         iType = iTypeV3;
     877    char            sys    = rnxSat.prn.system();
     878
     879    *_stream << rnxSat.prn;
     880    for (int iType = 0; iType < nTypes(sys); iType++) {
     881      QString type = obsType(sys, iType);
     882      if (!rnxSat.obs.contains(type)) {
     883        *_stream << QString().leftJustified(16);
    948884      }
    949885      else {
    950         if (_indexMap3to2[sys].find(iTypeV3) != _indexMap3to2[sys].end()) {
    951           iType = _indexMap3to2[sys][iTypeV3];
    952         }
    953       }
    954 
    955       if (iType == -1 || rnxSat.obs[iType] == 0.0) {
    956         *_stream << QString().leftJustified(16);
    957       }
    958       else {
    959         *_stream << QString("%1").arg(rnxSat.obs[iType], 14, 'f', 3);
    960         if (rnxSat.lli[iType] != 0.0) {
    961           *_stream << QString("%1").arg(rnxSat.lli[iType],1);
     886        const t_rnxObs& rnxObs = rnxSat.obs[type];
     887        *_stream << QString("%1").arg(rnxObs.value, 14, 'f', 3);
     888        if (rnxObs.lli != 0.0) {
     889          *_stream << QString("%1").arg(rnxObs.lli,1);
    962890        }
    963891        else {
    964892          *_stream << ' ';
    965893        }
    966         if (rnxSat.snr[iType] != 0.0) {
    967           *_stream << QString("%1").arg(rnxSat.snr[iType],1);
     894        if (rnxObs.snr != 0.0) {
     895          *_stream << QString("%1").arg(rnxObs.snr,1);
    968896        }
    969897        else {
     
    1068996
    1069997  t_rnxObsHeader oldHeader(_header);
    1070   setHeader(header, oldHeader._version);
     998  setHeader(header, oldHeader._version, QStringList());
    1071999
    10721000  // Check Observation Types
    10731001  // -----------------------
    10741002  bool same = true;
    1075   if (_header._version < 3.0) {
    1076     if (_header._obsTypesV2 != oldHeader._obsTypesV2) {
     1003  QMapIterator<char, QVector<QString> > it(_header._obsTypes);
     1004  while (it.hasNext()) {
     1005    it.next();
     1006    char                    sys   = it.key();
     1007    const QVector<QString>& types = it.value();
     1008    if (!oldHeader._obsTypes.contains(sys) || oldHeader._obsTypes[sys] != types) {
    10771009      same = false;
    1078     }
    1079   }
    1080   else {
    1081     QMapIterator<char, QVector<QString> > it(_header._obsTypesV3);
    1082     while (it.hasNext()) {
    1083       it.next();
    1084       char                    sys     = it.key();
    1085       const QVector<QString>& typesV3 = it.value();
    1086       if (!oldHeader._obsTypesV3.contains(sys) ||
    1087           oldHeader._obsTypesV3[sys] != typesV3) {
    1088         same = false;
    1089         break;
    1090       }
     1010      break;
    10911011    }
    10921012  }
     
    11151035          sizeof(obs.StatID));
    11161036
    1117   obs.satSys   = rnxSat.satSys;
    1118   obs.satNum   = rnxSat.satNum;
     1037  obs.satSys   = rnxSat.prn.system();
     1038  obs.satNum   = rnxSat.prn.number();
    11191039  obs.GPSWeek  = epo->tt.gpsw();
    11201040  obs.GPSWeeks = epo->tt.gpssec();
    11211041
    11221042  for (int iType = 0; iType < rnxObsFile->nTypes(obs.satSys); iType++) {
    1123     QString type = rnxObsFile->obsType(obs.satSys,iType).toAscii();
    1124     obs.setMeasdata(type, rnxObsFile->version(), rnxSat.obs[iType]);
    1125     if      (type.indexOf("L1") == 0) {
    1126       obs.snrL1  = rnxSat.snr[iType];
    1127       obs.slipL1 = (rnxSat.lli[iType] & 1);
    1128     }
    1129     else if (type.indexOf("L2") == 0) {
    1130       obs.snrL2  = rnxSat.snr[iType];
    1131       obs.slipL2 = (rnxSat.lli[iType] & 1);
    1132     }
    1133     else if (type.indexOf("L5") == 0) {
    1134       obs.snrL5  = rnxSat.snr[iType];
    1135       obs.slipL5 = (rnxSat.lli[iType] & 1);
    1136     }
    1137   }
    1138 }
    1139 
     1043    QString type   = rnxObsFile->obsType(obs.satSys, iType);
     1044    if (rnxSat.obs.contains(type)) {
     1045      const t_rnxObs& rnxObs = rnxSat.obs[type];
     1046      obs.setMeasdata(type, rnxObsFile->version(), rnxObs.value);
     1047      if      (type.indexOf("L1") == 0) {
     1048        obs.snrL1  = rnxObs.snr;
     1049        obs.slipL1 = (rnxObs.lli & 1);
     1050      }
     1051      else if (type.indexOf("L2") == 0) {
     1052        obs.snrL2  = rnxObs.snr;
     1053        obs.slipL2 = (rnxObs.lli & 1);
     1054      }
     1055      else if (type.indexOf("L5") == 0) {
     1056        obs.snrL5  = rnxObs.snr;
     1057        obs.slipL5 = (rnxObs.lli & 1);
     1058      }
     1059    }
     1060  }
     1061}
     1062
     1063// Set Observations from RINEX File
     1064////////////////////////////////////////////////////////////////////////////
     1065bool t_rnxObsFile::useType(const QStringList& useObsTypes, const QString& type) {
     1066
     1067  if (useObsTypes.size() == 0) {
     1068    return true;
     1069  }
     1070  for (int ii = 0; ii < useObsTypes.size(); ii++) {
     1071    if (type.left(2) == useObsTypes[ii].left(2)) {
     1072      return true;
     1073    }
     1074  }
     1075  return false;
     1076}
  • trunk/BNC/src/rinex/rnxobsfile.h

    r6118 r6119  
    3939
    4040class t_rnxObsHeader {
     41
     42 friend class t_rnxObsFile;
     43
    4144 public:
    42   static const double defaultRnxObsVersion2 = 2.11;
    43   static const double defaultRnxObsVersion3 = 3.02;
     45  static const double  defaultRnxObsVersion2 = 2.11;
     46  static const double  defaultRnxObsVersion3 = 3.02;
     47  static const QString defaultSystems;
    4448
    4549  t_rnxObsHeader();
    4650  ~t_rnxObsHeader();
    4751
    48   t_irc           read(QTextStream* stream, int maxLines = 0);
    49   int             nTypes(char sys) const;
    50   const QString&  obsType(char sys, int index) const;
    51   QStringList     obsTypesStrings() const;
    52   void            write(QTextStream* stream,
    53                         const QMap<QString, QString>* txtMap = 0) const;
     52  t_irc       read(QTextStream* stream, int maxLines = 0);
     53  int         numSys() const;
     54  int         nTypes(char sys) const;
     55  QString     obsType(char sys, int index) const;
     56  QStringList obsTypesStrings() const;
     57  void        write(QTextStream* stream, const QMap<QString, QString>* txtMap = 0) const;
    5458
    55   static const QString          _emptyStr;
     59 private:
    5660  float                         _version;
    5761  double                        _interval;
     
    7074  ColumnVector                  _antBSG;
    7175  ColumnVector                  _xyz;
    72   QVector<QString>              _obsTypesV2;
    73   QMap<char, QVector<QString> > _obsTypesV3;
     76  QMap<char, QVector<QString> > _obsTypes;
    7477  int                           _wlFactorsL1[t_prn::MAXPRN_GPS+1];
    7578  int                           _wlFactorsL2[t_prn::MAXPRN_GPS+1];
     
    8487  }
    8588
     89  class t_rnxObs {
     90   public:
     91    double value;
     92    int    lli;
     93    int    snr;
     94  };
     95
    8696  class t_rnxSat {
    8797   public:
    88     char                satSys;
    89     int                 satNum;
    90     std::vector<double> obs;
    91     std::vector<int>    lli;
    92     std::vector<int>    snr;
     98    t_prn                   prn;
     99    QMap<QString, t_rnxObs> obs;
    93100  };
    94101
     
    96103   public:
    97104    void clear() {
     105      tt.reset();
    98106      rnxSat.clear();
    99107    }
     
    107115  ~t_rnxObsFile();
    108116 
    109   float               version() const {return _header._version;}
    110   double              interval() const {return _header._interval;}
    111   int                 nTypes(char sys) const {return _header.nTypes(sys);}
    112   const QString&      fileName() const {return _fileName;}
    113   const QString&      obsType(char sys, int index) const {return _header.obsType(sys, index);}
    114 
    115   const QString&      antennaName() const {return _header._antennaName;}
    116   const QString&      markerName() const {return _header._markerName;}
    117   const QString&      receiverType() const {return _header._receiverType;}
     117  float          version() const {return _header._version;}
     118  double         interval() const {return _header._interval;}
     119  int            numSys() const {return _header.numSys();}
     120  int            nTypes(char sys) const {return _header.nTypes(sys);}
     121  const QString& fileName() const {return _fileName;}
     122  QString        obsType(char sys, int index) const {return _header.obsType(sys, index);}
     123  const QString& antennaName() const {return _header._antennaName;}
     124  const QString& markerName() const {return _header._markerName;}
     125  const QString& receiverType() const {return _header._receiverType;}
    118126
    119127  void setInterval(double interval) {_header._interval = interval;}
     
    154162
    155163 private:
    156   enum e_trafo {trafoNone, trafo2to2, trafo3to3, trafo2to3, trafo3to2};
    157 
    158164  t_rnxObsFile() {};
    159165  void openRead(const QString& fileName);
     
    179185  t_rnxEpo       _currEpo;
    180186  bool           _flgPowerFail;
    181   e_trafo        _trafo;
    182187};
    183188
Note: See TracChangeset for help on using the changeset viewer.