[3716] | 1 | // Part of BNC, a utility for retrieving decoding and
|
---|
| 2 | // converting GNSS data streams from NTRIP broadcasters.
|
---|
| 3 | //
|
---|
| 4 | // Copyright (C) 2007
|
---|
| 5 | // German Federal Agency for Cartography and Geodesy (BKG)
|
---|
| 6 | // http://www.bkg.bund.de
|
---|
| 7 | // Czech Technical University Prague, Department of Geodesy
|
---|
| 8 | // http://www.fsv.cvut.cz
|
---|
| 9 | //
|
---|
| 10 | // Email: euref-ip@bkg.bund.de
|
---|
| 11 | //
|
---|
| 12 | // This program is free software; you can redistribute it and/or
|
---|
| 13 | // modify it under the terms of the GNU General Public License
|
---|
| 14 | // as published by the Free Software Foundation, version 2.
|
---|
| 15 | //
|
---|
| 16 | // This program is distributed in the hope that it will be useful,
|
---|
| 17 | // but WITHOUT ANY WARRANTY; without even the implied warranty of
|
---|
| 18 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
---|
| 19 | // GNU General Public License for more details.
|
---|
| 20 | //
|
---|
| 21 | // You should have received a copy of the GNU General Public License
|
---|
| 22 | // along with this program; if not, write to the Free Software
|
---|
| 23 | // Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
---|
| 24 |
|
---|
| 25 | /* -------------------------------------------------------------------------
|
---|
| 26 | * BKG NTRIP Client
|
---|
| 27 | * -------------------------------------------------------------------------
|
---|
| 28 | *
|
---|
| 29 | * Class: t_rnxObsFile
|
---|
| 30 | *
|
---|
| 31 | * Purpose: Reads RINEX Observation File
|
---|
| 32 | *
|
---|
| 33 | * Author: L. Mervart
|
---|
| 34 | *
|
---|
| 35 | * Created: 24-Jan-2012
|
---|
| 36 | *
|
---|
| 37 | * Changes:
|
---|
| 38 | *
|
---|
| 39 | * -----------------------------------------------------------------------*/
|
---|
| 40 |
|
---|
| 41 | #include <iostream>
|
---|
| 42 | #include <iomanip>
|
---|
| 43 | #include <sstream>
|
---|
[3722] | 44 | #include "rnxobsfile.h"
|
---|
[3716] | 45 | #include "bncutils.h"
|
---|
[3927] | 46 | #include "bncapp.h"
|
---|
[3716] | 47 |
|
---|
| 48 | using namespace std;
|
---|
| 49 |
|
---|
[3718] | 50 | const QString t_rnxObsFile::t_rnxObsHeader::_emptyStr;
|
---|
[3716] | 51 |
|
---|
| 52 | // Constructor
|
---|
| 53 | ////////////////////////////////////////////////////////////////////////////
|
---|
| 54 | t_rnxObsFile::t_rnxObsHeader::t_rnxObsHeader() {
|
---|
| 55 | _antNEU.ReSize(3); _antNEU = 0.0;
|
---|
| 56 | _antXYZ.ReSize(3); _antXYZ = 0.0;
|
---|
| 57 | _antBSG.ReSize(3); _antBSG = 0.0;
|
---|
| 58 | _xyz.ReSize(3); _xyz = 0.0;
|
---|
| 59 | _version = 0.0;
|
---|
| 60 | _interval = 0.0;
|
---|
| 61 | for (unsigned iPrn = 1; iPrn <= MAXPRN_GPS; iPrn++) {
|
---|
| 62 | _wlFactorsL1[iPrn] = 1;
|
---|
| 63 | _wlFactorsL2[iPrn] = 1;
|
---|
| 64 | }
|
---|
| 65 | }
|
---|
| 66 |
|
---|
| 67 | // Destructor
|
---|
| 68 | ////////////////////////////////////////////////////////////////////////////
|
---|
| 69 | t_rnxObsFile::t_rnxObsHeader::~t_rnxObsHeader() {
|
---|
| 70 | }
|
---|
| 71 |
|
---|
| 72 | // Read Header
|
---|
| 73 | ////////////////////////////////////////////////////////////////////////////
|
---|
[3718] | 74 | t_irc t_rnxObsFile::t_rnxObsHeader::read(QTextStream* stream, int maxLines) {
|
---|
[3716] | 75 | int numLines = 0;
|
---|
[3718] | 76 | while ( stream->status() == QTextStream::Ok && !stream->atEnd() ) {
|
---|
| 77 | QString line = stream->readLine(); ++ numLines;
|
---|
| 78 | if (line.isEmpty()) {
|
---|
[3716] | 79 | continue;
|
---|
| 80 | }
|
---|
[3718] | 81 | if (line.indexOf("END OF FILE") != -1) {
|
---|
[3716] | 82 | break;
|
---|
| 83 | }
|
---|
[3718] | 84 | QString value = line.mid(0,60).trimmed();
|
---|
| 85 | QString key = line.mid(60).trimmed();
|
---|
[3716] | 86 | if (key == "END OF HEADER") {
|
---|
| 87 | break;
|
---|
| 88 | }
|
---|
| 89 | else if (key == "RINEX VERSION / TYPE") {
|
---|
[3718] | 90 | QTextStream in(value.toAscii(), QIODevice::ReadOnly);
|
---|
[3716] | 91 | in >> _version;
|
---|
| 92 | }
|
---|
| 93 | else if (key == "MARKER NAME") {
|
---|
| 94 | _markerName = value;
|
---|
| 95 | }
|
---|
[3930] | 96 | else if (key == "MARKER NUMBER") {
|
---|
| 97 | _markerNumber = line.mid(0,20).trimmed();
|
---|
| 98 | }
|
---|
[3716] | 99 | else if (key == "ANT # / TYPE") {
|
---|
[3930] | 100 | _antennaNumber = line.mid( 0,20).trimmed();
|
---|
| 101 | _antennaName = line.mid(20,20).trimmed();
|
---|
[3716] | 102 | }
|
---|
[3930] | 103 | else if (key == "OBSERVER / AGENCY") {
|
---|
| 104 | _observer = line.mid( 0,20).trimmed();
|
---|
| 105 | _agency = line.mid(20,40).trimmed();
|
---|
| 106 | }
|
---|
| 107 | else if (key == "REC # / TYPE / VERS") {
|
---|
| 108 | _receiverNumber = line.mid( 0,20).trimmed();
|
---|
| 109 | _receiverType = line.mid(20,20).trimmed();
|
---|
| 110 | _receiverVersion = line.mid(40,20).trimmed();
|
---|
| 111 | }
|
---|
[3716] | 112 | else if (key == "INTERVAL") {
|
---|
[3718] | 113 | QTextStream in(value.toAscii(), QIODevice::ReadOnly);
|
---|
[3716] | 114 | in >> _interval;
|
---|
| 115 | }
|
---|
| 116 | else if (key == "WAVELENGTH FACT L1/2") {
|
---|
[3718] | 117 | QTextStream in(value.toAscii(), QIODevice::ReadOnly);
|
---|
[3716] | 118 | int wlFactL1 = 0;
|
---|
| 119 | int wlFactL2 = 0;
|
---|
| 120 | int numSat = 0;
|
---|
| 121 | in >> wlFactL1 >> wlFactL2 >> numSat;
|
---|
| 122 | if (numSat == 0) {
|
---|
| 123 | for (unsigned iPrn = 1; iPrn <= MAXPRN_GPS; iPrn++) {
|
---|
| 124 | _wlFactorsL1[iPrn] = wlFactL1;
|
---|
| 125 | _wlFactorsL2[iPrn] = wlFactL2;
|
---|
| 126 | }
|
---|
| 127 | }
|
---|
| 128 | else {
|
---|
| 129 | for (int ii = 0; ii < numSat; ii++) {
|
---|
[3718] | 130 | QString prn; in >> prn;
|
---|
[3716] | 131 | if (prn[0] == 'G') {
|
---|
| 132 | int iPrn;
|
---|
| 133 | readInt(prn, 1, 2, iPrn);
|
---|
| 134 | _wlFactorsL1[iPrn] = wlFactL1;
|
---|
| 135 | _wlFactorsL2[iPrn] = wlFactL2;
|
---|
| 136 | }
|
---|
| 137 | }
|
---|
| 138 | }
|
---|
| 139 | }
|
---|
| 140 | else if (key == "APPROX POSITION XYZ") {
|
---|
[3718] | 141 | QTextStream in(value.toAscii(), QIODevice::ReadOnly);
|
---|
[3716] | 142 | in >> _xyz[0] >> _xyz[1] >> _xyz[2];
|
---|
| 143 | }
|
---|
| 144 | else if (key == "ANTENNA: DELTA H/E/N") {
|
---|
[3718] | 145 | QTextStream in(value.toAscii(), QIODevice::ReadOnly);
|
---|
[3716] | 146 | in >> _antNEU[2] >> _antNEU[1] >> _antNEU[0];
|
---|
| 147 | }
|
---|
| 148 | else if (key == "ANTENNA: DELTA X/Y/Z") {
|
---|
[3718] | 149 | QTextStream in(value.toAscii(), QIODevice::ReadOnly);
|
---|
[3716] | 150 | in >> _antXYZ[0] >> _antXYZ[1] >> _antXYZ[2];
|
---|
| 151 | }
|
---|
| 152 | else if (key == "ANTENNA: B.SIGHT XYZ") {
|
---|
[3718] | 153 | QTextStream in(value.toAscii(), QIODevice::ReadOnly);
|
---|
[3716] | 154 | in >> _antBSG[0] >> _antBSG[1] >> _antBSG[2];
|
---|
| 155 | }
|
---|
| 156 | else if (key == "# / TYPES OF OBSERV") {
|
---|
[3864] | 157 | QTextStream* in = new QTextStream(value.toAscii(), QIODevice::ReadOnly);
|
---|
[3716] | 158 | int nTypes;
|
---|
[3864] | 159 | *in >> nTypes;
|
---|
[3716] | 160 | _obsTypesV2.clear();
|
---|
| 161 | for (int ii = 0; ii < nTypes; ii++) {
|
---|
[3864] | 162 | if (ii > 0 && ii % 9 == 0) {
|
---|
| 163 | line = stream->readLine(); ++numLines;
|
---|
| 164 | delete in;
|
---|
| 165 | in = new QTextStream(line.toAscii(), QIODevice::ReadOnly);
|
---|
| 166 | }
|
---|
[3718] | 167 | QString hlp;
|
---|
[3864] | 168 | *in >> hlp;
|
---|
[4053] | 169 | _obsTypesV2.append(hlp);
|
---|
[3716] | 170 | }
|
---|
| 171 | }
|
---|
| 172 | else if (key == "SYS / # / OBS TYPES") {
|
---|
[3718] | 173 | QTextStream* in = new QTextStream(value.toAscii(), QIODevice::ReadOnly);
|
---|
[3716] | 174 | char sys;
|
---|
| 175 | int nTypes;
|
---|
| 176 | *in >> sys >> nTypes;
|
---|
| 177 | _obsTypesV3[sys].clear();
|
---|
| 178 | for (int ii = 0; ii < nTypes; ii++) {
|
---|
| 179 | if (ii > 0 && ii % 13 == 0) {
|
---|
[3718] | 180 | line = stream->readLine(); ++numLines;
|
---|
[3716] | 181 | delete in;
|
---|
[3718] | 182 | in = new QTextStream(line.toAscii(), QIODevice::ReadOnly);
|
---|
[3716] | 183 | }
|
---|
[3718] | 184 | QString hlp;
|
---|
[3716] | 185 | *in >> hlp;
|
---|
| 186 | _obsTypesV3[sys].push_back(hlp);
|
---|
| 187 | }
|
---|
| 188 | delete in;
|
---|
| 189 | }
|
---|
[3837] | 190 | else if (key == "TIME OF FIRST OBS") {
|
---|
| 191 | QTextStream in(value.toAscii(), QIODevice::ReadOnly);
|
---|
| 192 | int year, month, day, hour, min;
|
---|
| 193 | double sec;
|
---|
| 194 | in >> year >> month >> day >> hour >> min >> sec;
|
---|
| 195 | _startTime.set(year, month, day, hour, min, sec);
|
---|
| 196 | }
|
---|
[3716] | 197 | if (maxLines > 0 && numLines == maxLines) {
|
---|
| 198 | break;
|
---|
| 199 | }
|
---|
| 200 | }
|
---|
| 201 |
|
---|
| 202 | return success;
|
---|
| 203 | }
|
---|
| 204 |
|
---|
| 205 | // Number of Observation Types (satellite-system specific)
|
---|
| 206 | ////////////////////////////////////////////////////////////////////////////
|
---|
| 207 | int t_rnxObsFile::t_rnxObsHeader::nTypes(char sys) const {
|
---|
| 208 | if (_version < 3.0) {
|
---|
| 209 | return _obsTypesV2.size();
|
---|
| 210 | }
|
---|
| 211 | else {
|
---|
[4053] | 212 | if (_obsTypesV3.contains(sys)) {
|
---|
| 213 | return _obsTypesV3[sys].size();
|
---|
[3716] | 214 | }
|
---|
| 215 | else {
|
---|
| 216 | return 0;
|
---|
| 217 | }
|
---|
| 218 | }
|
---|
| 219 | }
|
---|
| 220 |
|
---|
| 221 | // Observation Type (satellite-system specific)
|
---|
| 222 | ////////////////////////////////////////////////////////////////////////////
|
---|
[3718] | 223 | const QString& t_rnxObsFile::t_rnxObsHeader::obsType(char sys, int index) const {
|
---|
[3716] | 224 | if (_version < 3.0) {
|
---|
| 225 | return _obsTypesV2.at(index);
|
---|
| 226 | }
|
---|
| 227 | else {
|
---|
[4053] | 228 | if (_obsTypesV3.contains(sys)) {
|
---|
| 229 | return _obsTypesV3[sys].at(index);
|
---|
[3716] | 230 | }
|
---|
| 231 | else {
|
---|
| 232 | return _emptyStr;
|
---|
| 233 | }
|
---|
| 234 | }
|
---|
| 235 | }
|
---|
| 236 |
|
---|
| 237 | // Constructor
|
---|
| 238 | ////////////////////////////////////////////////////////////////////////////
|
---|
[3843] | 239 | t_rnxObsFile::t_rnxObsFile(const QString& fileName, e_inpOut inpOut) {
|
---|
| 240 | _inpOut = inpOut;
|
---|
[3716] | 241 | _stream = 0;
|
---|
| 242 | _flgPowerFail = false;
|
---|
[3956] | 243 | _trafo = trafoNone;
|
---|
[3843] | 244 | if (_inpOut == input) {
|
---|
| 245 | openRead(fileName);
|
---|
| 246 | }
|
---|
| 247 | else {
|
---|
[3845] | 248 | openWrite(fileName);
|
---|
[3843] | 249 | }
|
---|
[3716] | 250 | }
|
---|
| 251 |
|
---|
[3845] | 252 | // Open for input
|
---|
[3716] | 253 | ////////////////////////////////////////////////////////////////////////////
|
---|
[3843] | 254 | void t_rnxObsFile::openRead(const QString& fileName) {
|
---|
[3718] | 255 |
|
---|
| 256 | _fileName = fileName; expandEnvVar(_fileName);
|
---|
| 257 | _file = new QFile(_fileName);
|
---|
| 258 | _file->open(QIODevice::ReadOnly | QIODevice::Text);
|
---|
| 259 | _stream = new QTextStream();
|
---|
| 260 | _stream->setDevice(_file);
|
---|
| 261 |
|
---|
[3716] | 262 | _header.read(_stream);
|
---|
| 263 |
|
---|
| 264 | // Guess Observation Interval
|
---|
| 265 | // --------------------------
|
---|
| 266 | if (_header._interval == 0.0) {
|
---|
| 267 | bncTime ttPrev;
|
---|
| 268 | for (int iEpo = 0; iEpo < 10; iEpo++) {
|
---|
| 269 | const t_rnxEpo* rnxEpo = nextEpoch();
|
---|
| 270 | if (!rnxEpo) {
|
---|
[3718] | 271 | throw QString("t_rnxObsFile: not enough epochs");
|
---|
[3716] | 272 | }
|
---|
| 273 | if (iEpo > 0) {
|
---|
| 274 | double dt = rnxEpo->tt - ttPrev;
|
---|
| 275 | if (_header._interval == 0.0 || dt < _header._interval) {
|
---|
| 276 | _header._interval = dt;
|
---|
| 277 | }
|
---|
| 278 | }
|
---|
| 279 | ttPrev = rnxEpo->tt;
|
---|
| 280 | }
|
---|
[3719] | 281 | _stream->seek(0);
|
---|
[3716] | 282 | _header.read(_stream);
|
---|
| 283 | }
|
---|
[3837] | 284 |
|
---|
| 285 | // Time of first observation
|
---|
| 286 | // -------------------------
|
---|
| 287 | if (!_header._startTime.valid()) {
|
---|
| 288 | const t_rnxEpo* rnxEpo = nextEpoch();
|
---|
| 289 | if (!rnxEpo) {
|
---|
| 290 | throw QString("t_rnxObsFile: not enough epochs");
|
---|
| 291 | }
|
---|
| 292 | _header._startTime = rnxEpo->tt;
|
---|
| 293 | _stream->seek(0);
|
---|
| 294 | _header.read(_stream);
|
---|
| 295 | }
|
---|
[3716] | 296 | }
|
---|
| 297 |
|
---|
[3845] | 298 | // Open for output
|
---|
| 299 | ////////////////////////////////////////////////////////////////////////////
|
---|
| 300 | void t_rnxObsFile::openWrite(const QString& fileName) {
|
---|
| 301 |
|
---|
| 302 | _fileName = fileName; expandEnvVar(_fileName);
|
---|
| 303 | _file = new QFile(_fileName);
|
---|
| 304 | _file->open(QIODevice::WriteOnly | QIODevice::Text);
|
---|
| 305 | _stream = new QTextStream();
|
---|
| 306 | _stream->setDevice(_file);
|
---|
| 307 | }
|
---|
| 308 |
|
---|
[3716] | 309 | // Destructor
|
---|
| 310 | ////////////////////////////////////////////////////////////////////////////
|
---|
| 311 | t_rnxObsFile::~t_rnxObsFile() {
|
---|
| 312 | close();
|
---|
| 313 | }
|
---|
| 314 |
|
---|
| 315 | // Close
|
---|
| 316 | ////////////////////////////////////////////////////////////////////////////
|
---|
| 317 | void t_rnxObsFile::close() {
|
---|
| 318 | delete _stream; _stream = 0;
|
---|
[3718] | 319 | delete _file; _file = 0;
|
---|
[3716] | 320 | }
|
---|
| 321 |
|
---|
| 322 | // Handle Special Epoch Flag
|
---|
| 323 | ////////////////////////////////////////////////////////////////////////////
|
---|
[3718] | 324 | void t_rnxObsFile::handleEpochFlag(int flag, const QString& line) {
|
---|
[3716] | 325 |
|
---|
| 326 | // Power Failure
|
---|
| 327 | // -------------
|
---|
| 328 | if (flag == 1) {
|
---|
| 329 | _flgPowerFail = true;
|
---|
| 330 | }
|
---|
| 331 |
|
---|
| 332 | // Start moving antenna
|
---|
| 333 | // --------------------
|
---|
| 334 | else if (flag == 2) {
|
---|
| 335 | // no action
|
---|
| 336 | }
|
---|
| 337 |
|
---|
| 338 | // Re-Read Header
|
---|
| 339 | // --------------
|
---|
| 340 | else if (flag == 3 || flag == 4) {
|
---|
| 341 | int numLines = 0;
|
---|
| 342 | if (version() < 3.0) {
|
---|
| 343 | readInt(line, 29, 3, numLines);
|
---|
| 344 | }
|
---|
| 345 | else {
|
---|
| 346 | readInt(line, 32, 3, numLines);
|
---|
| 347 | }
|
---|
| 348 | _header.read(_stream, numLines);
|
---|
| 349 | }
|
---|
| 350 |
|
---|
| 351 | // Unhandled Flag
|
---|
| 352 | // --------------
|
---|
| 353 | else {
|
---|
[3718] | 354 | throw QString("t_rnxObsFile: unhandled flag\n" + line);
|
---|
[3716] | 355 | }
|
---|
| 356 | }
|
---|
| 357 |
|
---|
| 358 | // Retrieve single Epoch
|
---|
| 359 | ////////////////////////////////////////////////////////////////////////////
|
---|
[3994] | 360 | t_rnxObsFile::t_rnxEpo* t_rnxObsFile::nextEpoch() {
|
---|
[3716] | 361 |
|
---|
| 362 | _currEpo.clear();
|
---|
| 363 |
|
---|
| 364 | if (version() < 3.0) {
|
---|
| 365 | return nextEpochV2();
|
---|
| 366 | }
|
---|
| 367 | else {
|
---|
| 368 | return nextEpochV3();
|
---|
| 369 | }
|
---|
| 370 | }
|
---|
| 371 |
|
---|
| 372 | // Retrieve single Epoch (RINEX Version 3)
|
---|
| 373 | ////////////////////////////////////////////////////////////////////////////
|
---|
[3994] | 374 | t_rnxObsFile::t_rnxEpo* t_rnxObsFile::nextEpochV3() {
|
---|
[3716] | 375 |
|
---|
[3719] | 376 | while ( _stream->status() == QTextStream::Ok && !_stream->atEnd() ) {
|
---|
[3716] | 377 |
|
---|
[3718] | 378 | QString line = _stream->readLine();
|
---|
[3716] | 379 |
|
---|
[3718] | 380 | if (line.isEmpty()) {
|
---|
[3716] | 381 | continue;
|
---|
| 382 | }
|
---|
| 383 |
|
---|
| 384 | int flag = 0;
|
---|
| 385 | readInt(line, 31, 1, flag);
|
---|
| 386 | if (flag > 0) {
|
---|
| 387 | handleEpochFlag(flag, line);
|
---|
| 388 | continue;
|
---|
| 389 | }
|
---|
| 390 |
|
---|
[3718] | 391 | QTextStream in(line.mid(1).toAscii(), QIODevice::ReadOnly);
|
---|
[3716] | 392 |
|
---|
| 393 | // Epoch Time
|
---|
| 394 | // ----------
|
---|
| 395 | int year, month, day, hour, min;
|
---|
| 396 | double sec;
|
---|
| 397 | in >> year >> month >> day >> hour >> min >> sec;
|
---|
[3720] | 398 | _currEpo.tt.set(year, month, day, hour, min, sec);
|
---|
[3716] | 399 |
|
---|
| 400 | // Number of Satellites
|
---|
| 401 | // --------------------
|
---|
| 402 | int numSat;
|
---|
| 403 | readInt(line, 32, 3, numSat);
|
---|
| 404 |
|
---|
| 405 | _currEpo.rnxSat.resize(numSat);
|
---|
| 406 |
|
---|
| 407 | // Observations
|
---|
| 408 | // ------------
|
---|
| 409 | for (int iSat = 0; iSat < numSat; iSat++) {
|
---|
[3718] | 410 | line = _stream->readLine();
|
---|
[3719] | 411 | _currEpo.rnxSat[iSat].satSys = line.toAscii()[0];
|
---|
[3716] | 412 | readInt(line, 1, 2, _currEpo.rnxSat[iSat].satNum);
|
---|
[3719] | 413 | char sys = line.toAscii()[0];
|
---|
[3716] | 414 | for (int iType = 0; iType < _header.nTypes(sys); iType++) {
|
---|
| 415 | int pos = 3 + 16*iType;
|
---|
| 416 | double obsValue = 0.0;
|
---|
| 417 | int lli = 0;
|
---|
| 418 | int snr = 0;
|
---|
| 419 | readDbl(line, pos, 14, obsValue);
|
---|
| 420 | readInt(line, pos + 14, 1, lli);
|
---|
| 421 | readInt(line, pos + 15, 1, snr);
|
---|
| 422 |
|
---|
| 423 | if (_flgPowerFail) {
|
---|
| 424 | lli |= 1;
|
---|
| 425 | }
|
---|
| 426 |
|
---|
| 427 | _currEpo.rnxSat[iSat].obs.push_back(obsValue);
|
---|
| 428 | _currEpo.rnxSat[iSat].lli.push_back(lli);
|
---|
| 429 | _currEpo.rnxSat[iSat].snr.push_back(snr);
|
---|
| 430 | }
|
---|
| 431 | }
|
---|
| 432 |
|
---|
| 433 | _flgPowerFail = false;
|
---|
| 434 |
|
---|
| 435 | return &_currEpo;
|
---|
| 436 | }
|
---|
| 437 |
|
---|
| 438 | return 0;
|
---|
| 439 | }
|
---|
| 440 |
|
---|
| 441 | // Retrieve single Epoch (RINEX Version 2)
|
---|
| 442 | ////////////////////////////////////////////////////////////////////////////
|
---|
[3994] | 443 | t_rnxObsFile::t_rnxEpo* t_rnxObsFile::nextEpochV2() {
|
---|
[3716] | 444 |
|
---|
[3719] | 445 | while ( _stream->status() == QTextStream::Ok && !_stream->atEnd() ) {
|
---|
[3716] | 446 |
|
---|
[3718] | 447 | QString line = _stream->readLine();
|
---|
[3716] | 448 |
|
---|
[3718] | 449 | if (line.isEmpty()) {
|
---|
[3716] | 450 | continue;
|
---|
| 451 | }
|
---|
| 452 |
|
---|
| 453 | int flag = 0;
|
---|
| 454 | readInt(line, 28, 1, flag);
|
---|
| 455 | if (flag > 0) {
|
---|
| 456 | handleEpochFlag(flag, line);
|
---|
| 457 | continue;
|
---|
| 458 | }
|
---|
| 459 |
|
---|
[3718] | 460 | QTextStream in(line.toAscii(), QIODevice::ReadOnly);
|
---|
[3716] | 461 |
|
---|
| 462 | // Epoch Time
|
---|
| 463 | // ----------
|
---|
| 464 | int year, month, day, hour, min;
|
---|
| 465 | double sec;
|
---|
| 466 | in >> year >> month >> day >> hour >> min >> sec;
|
---|
| 467 | if (year < 80) {
|
---|
| 468 | year += 2000;
|
---|
| 469 | }
|
---|
| 470 | else if (year < 100) {
|
---|
| 471 | year += 1900;
|
---|
| 472 | }
|
---|
[3720] | 473 | _currEpo.tt.set(year, month, day, hour, min, sec);
|
---|
[3716] | 474 |
|
---|
| 475 | // Number of Satellites
|
---|
| 476 | // --------------------
|
---|
| 477 | int numSat;
|
---|
| 478 | readInt(line, 29, 3, numSat);
|
---|
| 479 |
|
---|
| 480 | _currEpo.rnxSat.resize(numSat);
|
---|
| 481 |
|
---|
| 482 | // Read Satellite Numbers
|
---|
| 483 | // ----------------------
|
---|
| 484 | int pos = 32;
|
---|
| 485 | for (int iSat = 0; iSat < numSat; iSat++) {
|
---|
| 486 | if (iSat > 0 && iSat % 12 == 0) {
|
---|
[3718] | 487 | line = _stream->readLine();
|
---|
[3716] | 488 | pos = 32;
|
---|
| 489 | }
|
---|
| 490 |
|
---|
[3719] | 491 | _currEpo.rnxSat[iSat].satSys = line.toAscii()[pos];
|
---|
[3716] | 492 | readInt(line, pos + 1, 2, _currEpo.rnxSat[iSat].satNum);
|
---|
| 493 |
|
---|
| 494 | pos += 3;
|
---|
| 495 | }
|
---|
| 496 |
|
---|
| 497 | // Read Observation Records
|
---|
| 498 | // ------------------------
|
---|
| 499 | for (int iSat = 0; iSat < numSat; iSat++) {
|
---|
[3718] | 500 | line = _stream->readLine();
|
---|
[3716] | 501 | pos = 0;
|
---|
| 502 | for (int iType = 0; iType < _header.nTypes(_currEpo.rnxSat[iSat].satSys); iType++) {
|
---|
| 503 | if (iType > 0 && iType % 5 == 0) {
|
---|
[3718] | 504 | line = _stream->readLine();
|
---|
[3716] | 505 | pos = 0;
|
---|
| 506 | }
|
---|
| 507 | double obsValue = 0.0;
|
---|
| 508 | int lli = 0;
|
---|
| 509 | int snr = 0;
|
---|
| 510 | readDbl(line, pos, 14, obsValue);
|
---|
| 511 | readInt(line, pos + 14, 1, lli);
|
---|
| 512 | readInt(line, pos + 15, 1, snr);
|
---|
| 513 |
|
---|
| 514 | if (_flgPowerFail) {
|
---|
| 515 | lli |= 1;
|
---|
| 516 | }
|
---|
| 517 |
|
---|
| 518 | _currEpo.rnxSat[iSat].obs.push_back(obsValue);
|
---|
| 519 | _currEpo.rnxSat[iSat].lli.push_back(lli);
|
---|
| 520 | _currEpo.rnxSat[iSat].snr.push_back(snr);
|
---|
| 521 |
|
---|
| 522 | pos += 16;
|
---|
| 523 | }
|
---|
| 524 | }
|
---|
| 525 |
|
---|
| 526 | _flgPowerFail = false;
|
---|
| 527 |
|
---|
| 528 | return &_currEpo;
|
---|
| 529 | }
|
---|
| 530 |
|
---|
| 531 | return 0;
|
---|
| 532 | }
|
---|
| 533 |
|
---|
[3844] | 534 | // Set Header Information
|
---|
| 535 | ////////////////////////////////////////////////////////////////////////////
|
---|
[3956] | 536 | void t_rnxObsFile::setHeader(const t_rnxObsHeader& header, double version) {
|
---|
| 537 |
|
---|
| 538 | if (int(header._version) == int(version)) {
|
---|
| 539 | _trafo = trafoNone;
|
---|
| 540 | _header._version = header._version;
|
---|
| 541 | }
|
---|
| 542 | else if (version >= 3.0) {
|
---|
| 543 | _trafo = trafo2to3;
|
---|
| 544 | _header._version = 3.01;
|
---|
| 545 | }
|
---|
| 546 | else {
|
---|
| 547 | _trafo = trafo3to2;
|
---|
| 548 | _header._version = 2.11;
|
---|
| 549 | }
|
---|
| 550 |
|
---|
[3930] | 551 | _header._interval = header._interval;
|
---|
| 552 | _header._antennaNumber = header._antennaNumber;
|
---|
| 553 | _header._antennaName = header._antennaName;
|
---|
| 554 | _header._markerName = header._markerName;
|
---|
| 555 | _header._markerNumber = header._markerNumber;
|
---|
| 556 | _header._antNEU = header._antNEU;
|
---|
| 557 | _header._antXYZ = header._antXYZ;
|
---|
| 558 | _header._antBSG = header._antBSG;
|
---|
| 559 | _header._xyz = header._xyz;
|
---|
| 560 | _header._observer = header._observer;
|
---|
| 561 | _header._agency = header._agency;
|
---|
| 562 | _header._receiverNumber = header._receiverNumber;
|
---|
| 563 | _header._receiverType = header._receiverType;
|
---|
| 564 | _header._receiverVersion = header._receiverVersion;
|
---|
| 565 |
|
---|
[3844] | 566 | for (unsigned iPrn = 1; iPrn <= MAXPRN_GPS; iPrn++) {
|
---|
| 567 | _header._wlFactorsL1[iPrn] = header._wlFactorsL1[iPrn];
|
---|
| 568 | _header._wlFactorsL2[iPrn] = header._wlFactorsL2[iPrn];
|
---|
| 569 | }
|
---|
[3956] | 570 |
|
---|
[3844] | 571 | _header._startTime = header._startTime;
|
---|
[3956] | 572 |
|
---|
[3962] | 573 | static const string systems = "GRES";
|
---|
| 574 |
|
---|
[4053] | 575 | _header._obsTypesV2.clear();
|
---|
| 576 | _header._obsTypesV3.clear();
|
---|
| 577 |
|
---|
[3956] | 578 | // Copy Observation Types
|
---|
| 579 | // ----------------------
|
---|
[3962] | 580 | if (_trafo == trafoNone) {
|
---|
[4053] | 581 | for (int ii = 0; ii < header._obsTypesV2.size(); ii++) {
|
---|
| 582 | _header._obsTypesV2.append(header._obsTypesV2[ii]);
|
---|
[3844] | 583 | }
|
---|
[4053] | 584 | QMapIterator<char, QVector<QString> > it(header._obsTypesV3);
|
---|
| 585 | while (it.hasNext()) {
|
---|
| 586 | it.next();
|
---|
| 587 | char sys = it.key();
|
---|
| 588 | const QVector<QString>& typesV3 = it.value();
|
---|
| 589 | for (int ii = 0; ii < typesV3.size(); ii++) {
|
---|
[3962] | 590 | _header._obsTypesV3[sys].push_back(typesV3[ii]);
|
---|
| 591 | }
|
---|
| 592 | }
|
---|
[3844] | 593 | }
|
---|
[3956] | 594 |
|
---|
| 595 | // Translate Observation Types v2 --> v3
|
---|
| 596 | // -------------------------------------
|
---|
[3962] | 597 | else if (_trafo == trafo2to3) {
|
---|
[4053] | 598 | for (int i2 = 0; i2 < header._obsTypesV2.size(); i2++) {
|
---|
[3967] | 599 | const QString& typeV2 = header._obsTypesV2[i2];
|
---|
[3956] | 600 | for (unsigned iSys = 0; iSys < systems.length(); iSys++) {
|
---|
[3960] | 601 | char sys = systems[iSys];
|
---|
[3967] | 602 | QString typeV3 = type2to3(sys, typeV2);
|
---|
| 603 | if (!typeV3.isEmpty()) {
|
---|
[3960] | 604 | _header._obsTypesV3[sys].push_back(typeV3);
|
---|
[3967] | 605 | int i3 = _header._obsTypesV3[sys].size() - 1;
|
---|
| 606 | _indexMap3to2[sys][i3] = i2;
|
---|
[3960] | 607 | }
|
---|
[3956] | 608 | }
|
---|
| 609 | }
|
---|
| 610 | }
|
---|
| 611 |
|
---|
| 612 | // Translate Observation Types v3 --> v2
|
---|
| 613 | // -------------------------------------
|
---|
| 614 | else if (_trafo == trafo3to2) {
|
---|
[3965] | 615 | for (unsigned iSys = 0; iSys < systems.length(); iSys++) {
|
---|
| 616 | char sys = systems[iSys];
|
---|
[4053] | 617 | if (header._obsTypesV3.contains(sys)) {
|
---|
| 618 | const QVector<QString>& typesV3 = header._obsTypesV3[sys];
|
---|
| 619 | for (int i3 = 0; i3 < typesV3.size(); i3++) {
|
---|
[3967] | 620 | const QString& typeV3 = typesV3[i3];
|
---|
[3965] | 621 | QString typeV2 = type3to2(typeV3);
|
---|
[3969] | 622 | if (!typeV2.isEmpty()) {
|
---|
| 623 | bool found = false;
|
---|
[4053] | 624 | for (int i2 = 0; i2 < _header._obsTypesV2.size(); i2++) {
|
---|
[3969] | 625 | if (_header._obsTypesV2[i2] == typeV2) {
|
---|
| 626 | found = true;
|
---|
[3971] | 627 | if (_indexMap2to3[sys].find(i2) == _indexMap2to3[sys].end()) {
|
---|
[3970] | 628 | _indexMap2to3[sys][i2] = i3;
|
---|
| 629 | }
|
---|
[3969] | 630 | break;
|
---|
| 631 | }
|
---|
[3965] | 632 | }
|
---|
[3969] | 633 | if (!found) {
|
---|
[4053] | 634 | _header._obsTypesV2.append(typeV2);
|
---|
[3969] | 635 | int i2 = _header._obsTypesV2.size() - 1;
|
---|
| 636 | _indexMap2to3[sys][i2] = i3;
|
---|
| 637 | }
|
---|
[3965] | 638 | }
|
---|
| 639 | }
|
---|
| 640 | }
|
---|
| 641 | }
|
---|
[3956] | 642 | }
|
---|
[3844] | 643 | }
|
---|
[3845] | 644 |
|
---|
| 645 | // Write Header
|
---|
| 646 | ////////////////////////////////////////////////////////////////////////////
|
---|
[4137] | 647 | void t_rnxObsFile::writeHeader(const QMap<QString, QString>* txtMap) {
|
---|
[3927] | 648 |
|
---|
| 649 | bncApp* app = (bncApp*) qApp;
|
---|
| 650 |
|
---|
[4123] | 651 | QString runBy = app->userName();
|
---|
[4116] | 652 | QStringList comments;
|
---|
| 653 |
|
---|
[4137] | 654 | if (txtMap) {
|
---|
| 655 | QMapIterator<QString, QString> it(*txtMap);
|
---|
| 656 | while (it.hasNext()) {
|
---|
| 657 | it.next();
|
---|
| 658 | if (it.key() == "RUN BY") {
|
---|
| 659 | runBy = it.value();
|
---|
| 660 | }
|
---|
| 661 | else if (it.key() == "COMMENT") {
|
---|
| 662 | comments = it.value().split("\\n", QString::SkipEmptyParts);
|
---|
| 663 | }
|
---|
[4114] | 664 | }
|
---|
| 665 | }
|
---|
| 666 |
|
---|
[3849] | 667 | *_stream << QString("%1 Observation data Mixed")
|
---|
[3848] | 668 | .arg(_header._version, 9, 'f', 2)
|
---|
[3849] | 669 | .leftJustified(60)
|
---|
[3848] | 670 | << "RINEX VERSION / TYPE\n";
|
---|
| 671 |
|
---|
| 672 | *_stream << QString("%1%2%3")
|
---|
[3927] | 673 | .arg(app->pgmName(), -20)
|
---|
[4123] | 674 | .arg(runBy.trimmed().left(20), -20)
|
---|
[3848] | 675 | .arg(currentDateAndTimeGPS().date().toString("dd-MMM-yyyy"), -20)
|
---|
[3849] | 676 | .leftJustified(60)
|
---|
[3848] | 677 | << "PGM / RUN BY / DATE\n";
|
---|
[3849] | 678 |
|
---|
[4116] | 679 | QStringListIterator itCmnt(comments);
|
---|
| 680 | while (itCmnt.hasNext()) {
|
---|
[4122] | 681 | *_stream << itCmnt.next().trimmed().left(60).leftJustified(60) << "COMMENT\n";
|
---|
[4116] | 682 | }
|
---|
| 683 |
|
---|
[3849] | 684 | *_stream << QString("%1")
|
---|
| 685 | .arg(_header._markerName, -60)
|
---|
| 686 | .leftJustified(60)
|
---|
| 687 | << "MARKER NAME\n";
|
---|
| 688 |
|
---|
[3929] | 689 | if (!_header._markerNumber.isEmpty()) {
|
---|
| 690 | *_stream << QString("%1")
|
---|
| 691 | .arg(_header._markerNumber, -20)
|
---|
| 692 | .leftJustified(60)
|
---|
| 693 | << "MARKER NUMBER\n";
|
---|
| 694 | }
|
---|
| 695 |
|
---|
[3849] | 696 | *_stream << QString("%1%2")
|
---|
[3927] | 697 | .arg(_header._observer, -20)
|
---|
[3930] | 698 | .arg(_header._agency, -40)
|
---|
[3849] | 699 | .leftJustified(60)
|
---|
| 700 | << "OBSERVER / AGENCY\n";
|
---|
| 701 |
|
---|
| 702 | *_stream << QString("%1%2%3")
|
---|
[3927] | 703 | .arg(_header._receiverNumber, -20)
|
---|
| 704 | .arg(_header._receiverType, -20)
|
---|
| 705 | .arg(_header._receiverVersion, -20)
|
---|
[3849] | 706 | .leftJustified(60)
|
---|
| 707 | << "REC # / TYPE / VERS\n";
|
---|
| 708 |
|
---|
| 709 | *_stream << QString("%1%2")
|
---|
[3930] | 710 | .arg(_header._antennaNumber, -20)
|
---|
| 711 | .arg(_header._antennaName, -20)
|
---|
[3851] | 712 | .leftJustified(60)
|
---|
[3849] | 713 | << "ANT # / TYPE\n";
|
---|
| 714 |
|
---|
[3851] | 715 | *_stream << QString("%1%2%3")
|
---|
| 716 | .arg(_header._xyz(1), 14, 'f', 4)
|
---|
| 717 | .arg(_header._xyz(2), 14, 'f', 4)
|
---|
| 718 | .arg(_header._xyz(3), 14, 'f', 4)
|
---|
| 719 | .leftJustified(60)
|
---|
| 720 | << "APPROX POSITION XYZ\n";
|
---|
| 721 |
|
---|
| 722 | *_stream << QString("%1%2%3")
|
---|
| 723 | .arg(_header._antNEU(3), 14, 'f', 4)
|
---|
| 724 | .arg(_header._antNEU(2), 14, 'f', 4)
|
---|
| 725 | .arg(_header._antNEU(1), 14, 'f', 4)
|
---|
| 726 | .leftJustified(60)
|
---|
| 727 | << "ANTENNA: DELTA H/E/N\n";
|
---|
| 728 |
|
---|
[3937] | 729 | if (_header._version < 3.0) {
|
---|
| 730 | int defaultWlFact1 = _header._wlFactorsL1[1];
|
---|
| 731 | int defaultWlFact2 = _header._wlFactorsL2[1]; // TODO check all prns
|
---|
| 732 | *_stream << QString("%1%2")
|
---|
| 733 | .arg(defaultWlFact1, 6)
|
---|
| 734 | .arg(defaultWlFact2, 6)
|
---|
| 735 | .leftJustified(60)
|
---|
| 736 | << "WAVELENGTH FACT L1/2\n";
|
---|
| 737 | }
|
---|
| 738 |
|
---|
[4055] | 739 | *_stream << obsTypesStrings().join("");
|
---|
| 740 |
|
---|
| 741 | *_stream << QString("%1")
|
---|
| 742 | .arg(_header._interval, 10, 'f', 3)
|
---|
| 743 | .leftJustified(60)
|
---|
| 744 | << "INTERVAL\n";
|
---|
| 745 |
|
---|
| 746 | unsigned year, month, day, hour, min;
|
---|
| 747 | double sec;
|
---|
| 748 | _header._startTime.civil_date(year, month, day);
|
---|
| 749 | _header._startTime.civil_time(hour, min, sec);
|
---|
| 750 | *_stream << QString("%1%2%3%4%5%6%7")
|
---|
| 751 | .arg(year, 6)
|
---|
| 752 | .arg(month, 6)
|
---|
| 753 | .arg(day, 6)
|
---|
| 754 | .arg(hour, 6)
|
---|
| 755 | .arg(min, 6)
|
---|
| 756 | .arg(sec, 13, 'f', 7)
|
---|
| 757 | .arg("GPS", 8)
|
---|
| 758 | .leftJustified(60)
|
---|
| 759 | << "TIME OF FIRST OBS\n";
|
---|
| 760 |
|
---|
| 761 | *_stream << QString()
|
---|
| 762 | .leftJustified(60)
|
---|
| 763 | << "END OF HEADER\n";
|
---|
| 764 | }
|
---|
| 765 |
|
---|
| 766 | // Write Observation Types
|
---|
| 767 | ////////////////////////////////////////////////////////////////////////////
|
---|
| 768 | QStringList t_rnxObsFile::obsTypesStrings() {
|
---|
| 769 |
|
---|
| 770 | QStringList strList;
|
---|
| 771 |
|
---|
[3938] | 772 | if (_header._version < 3.0) {
|
---|
| 773 | QString hlp;
|
---|
| 774 | QTextStream(&hlp) << QString("%1").arg(_header._obsTypesV2.size(), 6);
|
---|
[4053] | 775 | for (int ii = 0; ii < _header._obsTypesV2.size(); ii++) {
|
---|
[3938] | 776 | QTextStream(&hlp) << QString("%1").arg(_header._obsTypesV2[ii], 6);
|
---|
| 777 | if (ii > 0 && (ii % 8 == 0 || ii == _header._obsTypesV2.size()-1)) {
|
---|
[4055] | 778 | strList.append(hlp.leftJustified(60) + "# / TYPES OF OBSERV\n");
|
---|
[3938] | 779 | hlp = QString().leftJustified(6);
|
---|
| 780 | }
|
---|
[3864] | 781 | }
|
---|
[3852] | 782 | }
|
---|
[3938] | 783 | else {
|
---|
[4053] | 784 | QMapIterator<char, QVector<QString> > it(_header._obsTypesV3);
|
---|
| 785 | while (it.hasNext()) {
|
---|
| 786 | it.next();
|
---|
| 787 | char sys = it.key();
|
---|
| 788 | const QVector<QString>& types = it.value();
|
---|
[3938] | 789 | QString hlp;
|
---|
[3939] | 790 | QTextStream(&hlp) << QString("%1 %2").arg(sys).arg(types.size(), 3);
|
---|
[4053] | 791 | for (int ii = 0; ii < types.size(); ii++) {
|
---|
[3940] | 792 | QTextStream(&hlp) << QString(" %1").arg(types[ii], -3);
|
---|
[3939] | 793 | if (ii > 0 && (ii % 12 == 0 || ii == types.size()-1)) {
|
---|
[4055] | 794 | strList.append(hlp.leftJustified(60) + "SYS / # / OBS TYPES\n");
|
---|
[3938] | 795 | hlp = QString().leftJustified(6);
|
---|
| 796 | }
|
---|
| 797 | }
|
---|
| 798 | }
|
---|
| 799 | }
|
---|
[3852] | 800 |
|
---|
[4055] | 801 | return strList;
|
---|
[3845] | 802 | }
|
---|
| 803 |
|
---|
| 804 | // Write Data Epoch
|
---|
| 805 | ////////////////////////////////////////////////////////////////////////////
|
---|
| 806 | void t_rnxObsFile::writeEpoch(const t_rnxEpo* epo) {
|
---|
[3866] | 807 | if (version() < 3.0) {
|
---|
| 808 | return writeEpochV2(epo);
|
---|
| 809 | }
|
---|
| 810 | else {
|
---|
| 811 | return writeEpochV3(epo);
|
---|
| 812 | }
|
---|
| 813 | }
|
---|
[3855] | 814 |
|
---|
[3866] | 815 | // Write Data Epoch (RINEX Version 2)
|
---|
| 816 | ////////////////////////////////////////////////////////////////////////////
|
---|
| 817 | void t_rnxObsFile::writeEpochV2(const t_rnxEpo* epo) {
|
---|
| 818 |
|
---|
[3855] | 819 | unsigned year, month, day, hour, min;
|
---|
| 820 | double sec;
|
---|
| 821 | epo->tt.civil_date(year, month, day);
|
---|
| 822 | epo->tt.civil_time(hour, min, sec);
|
---|
| 823 |
|
---|
| 824 | QString dateStr;
|
---|
[3868] | 825 | QTextStream(&dateStr) << QString(" %1 %2 %3 %4 %5%6")
|
---|
[3856] | 826 | .arg(int(fmod(year, 100)), 2, 10, QChar('0'))
|
---|
[3868] | 827 | .arg(month, 2, 10, QChar('0'))
|
---|
| 828 | .arg(day, 2, 10, QChar('0'))
|
---|
| 829 | .arg(hour, 2, 10, QChar('0'))
|
---|
| 830 | .arg(min, 2, 10, QChar('0'))
|
---|
| 831 | .arg(sec, 11, 'f', 7);
|
---|
[3855] | 832 |
|
---|
[3857] | 833 | int flag = 0;
|
---|
| 834 | *_stream << dateStr
|
---|
| 835 | << QString("%1%2").arg(flag, 3).arg(epo->rnxSat.size(), 3);
|
---|
[3858] | 836 | for (unsigned iSat = 0; iSat < epo->rnxSat.size(); iSat++) {
|
---|
[3869] | 837 | const t_rnxSat& rnxSat = epo->rnxSat[iSat];
|
---|
[3858] | 838 | if (iSat > 0 && iSat % 12 == 0) {
|
---|
[3857] | 839 | *_stream << endl << QString().leftJustified(32);
|
---|
| 840 | }
|
---|
[3869] | 841 | *_stream << rnxSat.satSys << QString("%1").arg(rnxSat.satNum, 2);
|
---|
[3857] | 842 | }
|
---|
| 843 | *_stream << endl;
|
---|
[3858] | 844 | for (unsigned iSat = 0; iSat < epo->rnxSat.size(); iSat++) {
|
---|
[3967] | 845 |
|
---|
[3858] | 846 | const t_rnxSat& rnxSat = epo->rnxSat[iSat];
|
---|
[3971] | 847 | char sys = rnxSat.satSys;
|
---|
[3966] | 848 |
|
---|
[3971] | 849 | for (int iTypeV2 = 0; iTypeV2 < nTypes(sys); iTypeV2++) {
|
---|
[3967] | 850 |
|
---|
| 851 | if (iTypeV2 > 0 && iTypeV2 % 5 == 0) {
|
---|
| 852 | *_stream << endl;
|
---|
| 853 | }
|
---|
| 854 |
|
---|
[3971] | 855 | int iType = -1;
|
---|
[3966] | 856 | if (_trafo == trafoNone) {
|
---|
[3967] | 857 | iType = iTypeV2;
|
---|
[3966] | 858 | }
|
---|
| 859 | else {
|
---|
[3971] | 860 | if (_indexMap2to3[sys].find(iTypeV2) != _indexMap2to3[sys].end()) {
|
---|
| 861 | iType = _indexMap2to3[sys][iTypeV2];
|
---|
| 862 | }
|
---|
[3966] | 863 | }
|
---|
| 864 |
|
---|
[3971] | 865 | if (iType == -1 || rnxSat.obs[iType] == 0.0) {
|
---|
[3858] | 866 | *_stream << QString().leftJustified(16);
|
---|
| 867 | }
|
---|
| 868 | else {
|
---|
[3979] | 869 | *_stream << QString("%1").arg(rnxSat.obs[iType], 14, 'f', 3);
|
---|
| 870 | if (rnxSat.lli[iType] != 0.0) {
|
---|
| 871 | *_stream << QString("%1").arg(rnxSat.lli[iType],1);
|
---|
| 872 | }
|
---|
| 873 | else {
|
---|
| 874 | *_stream << ' ';
|
---|
| 875 | }
|
---|
| 876 | if (rnxSat.snr[iType] != 0.0) {
|
---|
| 877 | *_stream << QString("%1").arg(rnxSat.snr[iType],1);
|
---|
| 878 | }
|
---|
| 879 | else {
|
---|
| 880 | *_stream << ' ';
|
---|
| 881 | }
|
---|
[3858] | 882 | }
|
---|
| 883 | }
|
---|
| 884 | *_stream << endl;
|
---|
| 885 | }
|
---|
[3845] | 886 | }
|
---|
[3866] | 887 |
|
---|
| 888 | // Write Data Epoch (RINEX Version 3)
|
---|
| 889 | ////////////////////////////////////////////////////////////////////////////
|
---|
| 890 | void t_rnxObsFile::writeEpochV3(const t_rnxEpo* epo) {
|
---|
| 891 |
|
---|
| 892 | unsigned year, month, day, hour, min;
|
---|
| 893 | double sec;
|
---|
| 894 | epo->tt.civil_date(year, month, day);
|
---|
| 895 | epo->tt.civil_time(hour, min, sec);
|
---|
| 896 |
|
---|
[3867] | 897 | QString dateStr;
|
---|
[3868] | 898 | QTextStream(&dateStr) << QString("> %1 %2 %3 %4 %5%6")
|
---|
[3867] | 899 | .arg(year, 4)
|
---|
| 900 | .arg(month, 2, 10, QChar('0'))
|
---|
| 901 | .arg(day, 2, 10, QChar('0'))
|
---|
| 902 | .arg(hour, 2, 10, QChar('0'))
|
---|
| 903 | .arg(min, 2, 10, QChar('0'))
|
---|
| 904 | .arg(sec, 11, 'f', 7);
|
---|
[3866] | 905 |
|
---|
[3867] | 906 | int flag = 0;
|
---|
| 907 | *_stream << dateStr
|
---|
| 908 | << QString("%1%2\n").arg(flag, 3).arg(epo->rnxSat.size(), 3);
|
---|
| 909 |
|
---|
[3869] | 910 | for (unsigned iSat = 0; iSat < epo->rnxSat.size(); iSat++) {
|
---|
| 911 | const t_rnxSat& rnxSat = epo->rnxSat[iSat];
|
---|
[3971] | 912 | char sys = rnxSat.satSys;
|
---|
| 913 | *_stream << sys
|
---|
[3869] | 914 | << QString("%1").arg(rnxSat.satNum, 2, 10, QChar('0'));
|
---|
[3964] | 915 |
|
---|
[3971] | 916 | for (int iTypeV3 = 0; iTypeV3 < nTypes(sys); iTypeV3++) {
|
---|
[3964] | 917 |
|
---|
[3971] | 918 | int iType = -1;
|
---|
[3964] | 919 | if (_trafo == trafoNone) {
|
---|
[3967] | 920 | iType = iTypeV3;
|
---|
[3964] | 921 | }
|
---|
| 922 | else {
|
---|
[3971] | 923 | if (_indexMap3to2[sys].find(iTypeV3) != _indexMap3to2[sys].end()) {
|
---|
| 924 | iType = _indexMap3to2[sys][iTypeV3];
|
---|
| 925 | }
|
---|
[3964] | 926 | }
|
---|
| 927 |
|
---|
[3971] | 928 | if (iType == -1 || rnxSat.obs[iType] == 0.0) {
|
---|
[3869] | 929 | *_stream << QString().leftJustified(16);
|
---|
| 930 | }
|
---|
| 931 | else {
|
---|
[3979] | 932 | *_stream << QString("%1").arg(rnxSat.obs[iType], 14, 'f', 3);
|
---|
| 933 | if (rnxSat.lli[iType] != 0.0) {
|
---|
| 934 | *_stream << QString("%1").arg(rnxSat.lli[iType],1);
|
---|
| 935 | }
|
---|
| 936 | else {
|
---|
| 937 | *_stream << ' ';
|
---|
| 938 | }
|
---|
| 939 | if (rnxSat.snr[iType] != 0.0) {
|
---|
| 940 | *_stream << QString("%1").arg(rnxSat.snr[iType],1);
|
---|
| 941 | }
|
---|
| 942 | else {
|
---|
| 943 | *_stream << ' ';
|
---|
| 944 | }
|
---|
[3869] | 945 | }
|
---|
| 946 | }
|
---|
| 947 | *_stream << endl;
|
---|
| 948 | }
|
---|
[3866] | 949 | }
|
---|
[3956] | 950 |
|
---|
| 951 | // Translate Observation Type v2 --> v3
|
---|
| 952 | ////////////////////////////////////////////////////////////////////////////
|
---|
| 953 | QString t_rnxObsFile::type2to3(char sys, const QString& typeV2) {
|
---|
| 954 |
|
---|
| 955 | if (sys == 'G') {
|
---|
| 956 | if (typeV2 == "C1") return "C1C";
|
---|
| 957 | if (typeV2 == "C2") return "C2C";
|
---|
| 958 | if (typeV2 == "C5") return "C5C";
|
---|
| 959 | if (typeV2 == "P1") return "C1P";
|
---|
| 960 | if (typeV2 == "P2") return "C2P";
|
---|
| 961 | if (typeV2 == "L1") return "L1";
|
---|
| 962 | if (typeV2 == "L2") return "L2";
|
---|
| 963 | if (typeV2 == "L5") return "L5";
|
---|
| 964 | if (typeV2 == "D1") return "D1";
|
---|
| 965 | if (typeV2 == "D2") return "D2";
|
---|
| 966 | if (typeV2 == "D5") return "D5";
|
---|
| 967 | if (typeV2 == "S1") return "S1";
|
---|
| 968 | if (typeV2 == "S2") return "S2";
|
---|
| 969 | if (typeV2 == "S5") return "S5";
|
---|
| 970 | }
|
---|
| 971 |
|
---|
| 972 | else if (sys == 'R') {
|
---|
| 973 | if (typeV2 == "C1") return "C1C";
|
---|
| 974 | if (typeV2 == "C2") return "C2C";
|
---|
| 975 | if (typeV2 == "P1") return "C1P";
|
---|
| 976 | if (typeV2 == "P2") return "C2P";
|
---|
| 977 | if (typeV2 == "L1") return "L1";
|
---|
| 978 | if (typeV2 == "L2") return "L2";
|
---|
| 979 | if (typeV2 == "D1") return "D1";
|
---|
| 980 | if (typeV2 == "D2") return "D2";
|
---|
| 981 | if (typeV2 == "S1") return "S1";
|
---|
| 982 | if (typeV2 == "S2") return "S2";
|
---|
| 983 | }
|
---|
| 984 |
|
---|
| 985 | else if (sys == 'E') {
|
---|
| 986 | if (typeV2 == "C1") return "C1";
|
---|
| 987 | if (typeV2 == "C5") return "C5";
|
---|
| 988 | if (typeV2 == "C6") return "C6";
|
---|
| 989 | if (typeV2 == "C7") return "C7";
|
---|
| 990 | if (typeV2 == "C8") return "C8";
|
---|
| 991 | if (typeV2 == "L1") return "L1";
|
---|
| 992 | if (typeV2 == "L5") return "L5";
|
---|
| 993 | if (typeV2 == "L6") return "L6";
|
---|
| 994 | if (typeV2 == "L7") return "L7";
|
---|
| 995 | if (typeV2 == "L8") return "L8";
|
---|
| 996 | if (typeV2 == "D1") return "D1";
|
---|
| 997 | if (typeV2 == "D5") return "D5";
|
---|
| 998 | if (typeV2 == "D6") return "D6";
|
---|
| 999 | if (typeV2 == "D7") return "D7";
|
---|
| 1000 | if (typeV2 == "D8") return "D8";
|
---|
| 1001 | if (typeV2 == "S1") return "S1";
|
---|
| 1002 | if (typeV2 == "S5") return "S5";
|
---|
| 1003 | if (typeV2 == "S6") return "S6";
|
---|
| 1004 | if (typeV2 == "S7") return "S7";
|
---|
| 1005 | if (typeV2 == "S8") return "S8";
|
---|
| 1006 | }
|
---|
| 1007 |
|
---|
| 1008 | else if (sys == 'S') {
|
---|
| 1009 | if (typeV2 == "C1") return "C1C";
|
---|
| 1010 | if (typeV2 == "C5") return "C5C";
|
---|
| 1011 | if (typeV2 == "L1") return "L1";
|
---|
| 1012 | if (typeV2 == "L5") return "L5";
|
---|
| 1013 | if (typeV2 == "D1") return "D1";
|
---|
| 1014 | if (typeV2 == "D5") return "D5";
|
---|
| 1015 | if (typeV2 == "S1") return "S1";
|
---|
| 1016 | if (typeV2 == "S5") return "S5";
|
---|
| 1017 | }
|
---|
| 1018 |
|
---|
| 1019 | return "";
|
---|
| 1020 | }
|
---|
[3962] | 1021 |
|
---|
| 1022 | // Translate Observation Type v3 --> v2
|
---|
| 1023 | ////////////////////////////////////////////////////////////////////////////
|
---|
| 1024 | QString t_rnxObsFile::type3to2(const QString& typeV3) {
|
---|
| 1025 | if (typeV3 == "C1P") {
|
---|
| 1026 | return "P1";
|
---|
| 1027 | }
|
---|
| 1028 | else if (typeV3 == "C2P") {
|
---|
| 1029 | return "P2";
|
---|
| 1030 | }
|
---|
| 1031 | else {
|
---|
| 1032 | return typeV3.left(2);
|
---|
| 1033 | }
|
---|
[3965] | 1034 |
|
---|
| 1035 | return "";
|
---|
[3962] | 1036 | }
|
---|
[4053] | 1037 |
|
---|
| 1038 | // Check for Changes in Header
|
---|
| 1039 | ////////////////////////////////////////////////////////////////////////////
|
---|
| 1040 | void t_rnxObsFile::checkNewHeader(const t_rnxObsHeader& header) {
|
---|
| 1041 |
|
---|
| 1042 | t_rnxObsHeader oldHeader(_header);
|
---|
| 1043 | setHeader(header, oldHeader._version);
|
---|
| 1044 |
|
---|
[4054] | 1045 | // Check Observation Types
|
---|
| 1046 | // -----------------------
|
---|
| 1047 | bool same = true;
|
---|
| 1048 | if (_header._version < 3.0) {
|
---|
| 1049 | if (_header._obsTypesV2 != oldHeader._obsTypesV2) {
|
---|
| 1050 | same = false;
|
---|
| 1051 | }
|
---|
| 1052 | }
|
---|
| 1053 | else {
|
---|
| 1054 | QMapIterator<char, QVector<QString> > it(_header._obsTypesV3);
|
---|
| 1055 | while (it.hasNext()) {
|
---|
| 1056 | it.next();
|
---|
| 1057 | char sys = it.key();
|
---|
| 1058 | const QVector<QString>& typesV3 = it.value();
|
---|
| 1059 | if (!oldHeader._obsTypesV3.contains(sys) ||
|
---|
| 1060 | oldHeader._obsTypesV3[sys] != typesV3) {
|
---|
| 1061 | same = false;
|
---|
| 1062 | break;
|
---|
| 1063 | }
|
---|
| 1064 | }
|
---|
| 1065 | }
|
---|
[4053] | 1066 |
|
---|
[4054] | 1067 | if (!same) {
|
---|
[4056] | 1068 | QStringList strLst = obsTypesStrings();
|
---|
[4058] | 1069 | int numBlanks = _header._version < 3.0 ? 26 : 29;
|
---|
| 1070 | *_stream << QString().leftJustified(numBlanks)
|
---|
[4056] | 1071 | << QString(" 4%1\n").arg(strLst.size(), 3)
|
---|
| 1072 | << strLst.join("");
|
---|
[4053] | 1073 | }
|
---|
| 1074 | }
|
---|