HatanakaCompressFilter.java
/* Copyright 2002-2022 CS GROUP
* Licensed to CS GROUP (CS) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* CS licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.orekit.gnss;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.Reader;
import java.nio.CharBuffer;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import org.hipparchus.util.FastMath;
import org.orekit.data.DataFilter;
import org.orekit.data.DataSource;
import org.orekit.errors.OrekitException;
import org.orekit.errors.OrekitMessages;
/** Decompression filter for Hatanaka compressed RINEX files.
* @see <a href="http://cedadocs.ceda.ac.uk/1254/1/Hatanaka%5C_compressed%5C_format%5C_help.pdf">A
* Compression Format and Tools for GNSS Observation Data</a>
* @since 10.1
*/
public class HatanakaCompressFilter implements DataFilter {
/** Pattern for rinex 2 observation files. */
private static final Pattern RINEX_2_PATTERN = Pattern.compile("^(\\w{4}\\d{3}[0a-x](?:\\d{2})?\\.\\d{2})[dD]$");
/** Pattern for rinex 3 observation files. */
private static final Pattern RINEX_3_PATTERN = Pattern.compile("^(\\w{9}_\\w{1}_\\d{11}_\\d{2}\\w_\\d{2}\\w{1}_\\w{2})\\.crx$");
/** {@inheritDoc} */
@Override
public DataSource filter(final DataSource original) {
final String oName = original.getName();
final DataSource.Opener oOpener = original.getOpener();
final Matcher rinex2Matcher = RINEX_2_PATTERN.matcher(oName);
if (rinex2Matcher.matches()) {
// this is a rinex 2 file compressed with Hatanaka method
final String fName = rinex2Matcher.group(1) + "o";
final DataSource.ReaderOpener fOpener = () -> new HatanakaReader(oName, oOpener.openReaderOnce());
return new DataSource(fName, fOpener);
}
final Matcher rinex3Matcher = RINEX_3_PATTERN.matcher(oName);
if (rinex3Matcher.matches()) {
// this is a rinex 3 file compressed with Hatanaka method
final String fName = rinex3Matcher.group(1) + ".rnx";
final DataSource.ReaderOpener fOpener = () -> new HatanakaReader(oName, oOpener.openReaderOnce());
return new DataSource(fName, fOpener);
}
// it is not an Hatanaka compressed rinex file
return original;
}
/** Filtering of Hatanaka compressed characters stream. */
private static class HatanakaReader extends Reader {
/** Format of the current file. */
private final CompactRinexFormat format;
/** Line-oriented input. */
private final BufferedReader reader;
/** Pending uncompressed output lines. */
private CharSequence pending;
/** Number of characters already output in pending lines. */
private int countOut;
/** Simple constructor.
* @param name file name
* @param input underlying compressed stream
* @exception IOException if first lines cannot be read
*/
HatanakaReader(final String name, final Reader input)
throws IOException {
reader = new BufferedReader(input);
// check header
format = CompactRinexFormat.getFormat(name, reader);
pending = null;
}
/** {@inheritDoc} */
@Override
public int read(final char[] b, final int offset, final int len) throws IOException {
if (pending == null) {
// we need to read another section from the underlying characters stream and uncompress it
countOut = 0;
final String firstLine = reader.readLine();
if (firstLine == null) {
// there are no lines left
return -1;
} else {
pending = format.uncompressSection(firstLine);
}
}
// copy as many characters as possible from current line
int n = FastMath.min(len, pending.length() - countOut);
for (int i = 0; i < n; ++i) {
b[offset + i] = pending.charAt(countOut + i);
}
if (n < len) {
// line has been completed and we can still output end of line
b[offset + n] = '\n';
pending = null;
++n;
} else {
// there are still some pending characters
countOut += n;
}
return n;
}
/** {@inheritDoc} */
@Override
public void close() throws IOException {
reader.close();
}
}
/** Processor handling differential compression for one numerical data field. */
private static class NumericDifferential {
/** Length of the uncompressed text field. */
private final int fieldLength;
/** Number of decimal places uncompressed text field. */
private final int decimalPlaces;
/** State vector. */
private final long[] state;
/** Number of components in the state vector. */
private int nbComponents;
/** Uncompressed value. */
private CharSequence uncompressed;
/** Simple constructor.
* @param fieldLength length of the uncompressed text field
* @param decimalPlaces number of decimal places uncompressed text field
* @param order differential order
*/
NumericDifferential(final int fieldLength, final int decimalPlaces, final int order) {
this.fieldLength = fieldLength;
this.decimalPlaces = decimalPlaces;
this.state = new long[order + 1];
this.nbComponents = 0;
}
/** Handle a new compressed value.
* @param sequence sequence containing the value to consider
*/
public void accept(final CharSequence sequence) {
// store the value as the last component of state vector
state[nbComponents] = Long.parseLong(sequence.toString());
// update state vector
for (int i = nbComponents; i > 0; --i) {
state[i - 1] += state[i];
}
if (++nbComponents == state.length) {
// the state vector is full
--nbComponents;
}
// output uncompressed value
final String unscaled = Long.toString(FastMath.abs(state[0]));
final int length = unscaled.length();
final int digits = FastMath.max(length, decimalPlaces);
final int padding = fieldLength - (digits + (state[0] < 0 ? 2 : 1));
final StringBuilder builder = new StringBuilder();
for (int i = 0; i < padding; ++i) {
builder.append(' ');
}
if (state[0] < 0) {
builder.append('-');
}
if (length > decimalPlaces) {
builder.append(unscaled, 0, length - decimalPlaces);
}
builder.append('.');
for (int i = decimalPlaces; i > 0; --i) {
builder.append(i > length ? '0' : unscaled.charAt(length - i));
}
uncompressed = builder;
}
/** Get a string representation of the uncompressed value.
* @return string representation of the uncompressed value
*/
public CharSequence getUncompressed() {
return uncompressed;
}
}
/** Processor handling text compression for one text data field. */
private static class TextDifferential {
/** Buffer holding the current state. */
private CharBuffer state;
/** Simple constructor.
* @param fieldLength length of the uncompressed text field
*/
TextDifferential(final int fieldLength) {
this.state = CharBuffer.allocate(fieldLength);
for (int i = 0; i < fieldLength; ++i) {
state.put(i, ' ');
}
}
/** Handle a new compressed value.
* @param sequence sequence containing the value to consider
*/
public void accept(final CharSequence sequence) {
// update state
final int length = FastMath.min(state.capacity(), sequence.length());
for (int i = 0; i < length; ++i) {
final char c = sequence.charAt(i);
if (c == '&') {
// update state with disappearing character
state.put(i, ' ');
} else if (c != ' ') {
// update state with changed character
state.put(i, c);
}
}
}
/** Get a string representation of the uncompressed value.
* @return string representation of the uncompressed value
*/
public CharSequence getUncompressed() {
return state;
}
}
/** Container for combined observations and flags. */
private static class CombinedDifferentials {
/** Observation differentials. */
private NumericDifferential[] observations;
/** Flags differential. */
private TextDifferential flags;
/** Simple constructor.
* Build an empty container.
* @param nbObs number of observations
*/
CombinedDifferentials(final int nbObs) {
this.observations = new NumericDifferential[nbObs];
this.flags = new TextDifferential(2 * nbObs);
}
}
/** Base class for parsing compact RINEX format. */
private abstract static class CompactRinexFormat {
/** Index of label in data lines. */
private static final int LABEL_START = 60;
/** Label for compact Rinex version. */
private static final String CRINEX_VERSION_TYPE = "CRINEX VERS / TYPE";
/** Label for compact Rinex program. */
private static final String CRINEX_PROG_DATE = "CRINEX PROG / DATE";
/** Label for number of satellites. */
private static final String NB_OF_SATELLITES = "# OF SATELLITES";
/** Label for end of header. */
private static final String END_OF_HEADER = "END OF HEADER";
/** Default number of satellites (used if not present in the file). */
private static final int DEFAULT_NB_SAT = 500;
/** File name. */
private final String name;
/** Line-oriented input. */
private final BufferedReader reader;
/** Current line number. */
private int lineNumber;
/** Maximum number of observations for one satellite. */
private final Map<SatelliteSystem, Integer> maxObs;
/** Number of satellites. */
private int nbSat;
/** Indicator for current section type. */
private Section section;
/** Satellites observed at current epoch. */
private List<String> satellites;
/** Differential engine for epoch. */
private TextDifferential epochDifferential;
/** Receiver clock offset differential. */
private NumericDifferential clockDifferential;
/** Differential engine for satellites list. */
private TextDifferential satListDifferential;
/** Differential engines for each satellite. */
private Map<String, CombinedDifferentials> differentials;
/** Simple constructor.
* @param name file name
* @param reader line-oriented input
*/
protected CompactRinexFormat(final String name, final BufferedReader reader) {
this.name = name;
this.reader = reader;
this.maxObs = new HashMap<>();
for (final SatelliteSystem system : SatelliteSystem.values()) {
maxObs.put(system, 0);
}
this.nbSat = DEFAULT_NB_SAT;
this.section = Section.HEADER;
}
/** Uncompress a section.
* @param firstLine first line of the section
* @return uncompressed section (contains several lines)
* @exception IOException if we cannot read lines from underlying stream
*/
public CharSequence uncompressSection(final String firstLine)
throws IOException {
final CharSequence uncompressed;
switch (section) {
case HEADER : {
// header lines
final StringBuilder builder = new StringBuilder();
String line = firstLine;
lineNumber = 3; // there are 2 CRINEX lines before the RINEX header line
while (section == Section.HEADER) {
if (builder.length() > 0) {
builder.append('\n');
line = readLine();
}
builder.append(parseHeaderLine(line));
trimTrailingSpaces(builder);
}
uncompressed = builder;
section = Section.EPOCH;
break;
}
case EPOCH : {
// epoch and receiver clock offset lines
++lineNumber; // the caller has read one epoch line
uncompressed = parseEpochAndClockLines(firstLine, readLine().trim());
section = Section.OBSERVATION;
break;
}
default : {
// observation lines
final String[] lines = new String[satellites.size()];
++lineNumber; // the caller has read one observation line
lines[0] = firstLine;
for (int i = 1; i < lines.length; ++i) {
lines[i] = readLine();
}
uncompressed = parseObservationLines(lines);
section = Section.EPOCH;
}
}
return uncompressed;
}
/** Parse a header line.
* @param line header line
* @return uncompressed line
*/
public CharSequence parseHeaderLine(final String line) {
if (isHeaderLine(NB_OF_SATELLITES, line)) {
// number of satellites
nbSat = parseInt(line, 0, 6);
} else if (isHeaderLine(END_OF_HEADER, line)) {
// we have reached end of header, prepare parsing of data records
section = Section.EPOCH;
}
// within header, lines are simply copied
return line;
}
/** Parse epoch and receiver clock offset lines.
* @param epochLine epoch line
* @param clockLine receiver clock offset line
* @return uncompressed line
* @exception IOException if we cannot read additional special events lines
*/
public abstract CharSequence parseEpochAndClockLines(String epochLine, String clockLine)
throws IOException;
/** Parse epoch and receiver clock offset lines.
* @param builder builder that may used to copy special event lines
* @param epochStart start of the epoch field
* @param epochLength length of epoch field
* @param eventStart start of the special events field
* @param nbSatStart start of the number of satellites field
* @param satListStart start of the satellites list
* @param clockLength length of receiver clock field
* @param clockDecimalPlaces number of decimal places for receiver clock offset
* @param epochLine epoch line
* @param clockLine receiver clock offset line
* @param resetChar character indicating differentials reset
* @exception IOException if we cannot read additional special events lines
*/
protected void doParseEpochAndClockLines(final StringBuilder builder,
final int epochStart, final int epochLength,
final int eventStart, final int nbSatStart, final int satListStart,
final int clockLength, final int clockDecimalPlaces,
final String epochLine,
final String clockLine, final char resetChar)
throws IOException {
boolean loop = true;
String loopEpochLine = epochLine;
String loopClockLine = clockLine;
while (loop) {
// check if differentials should be reset
if (epochDifferential == null || loopEpochLine.charAt(0) == resetChar) {
epochDifferential = new TextDifferential(epochLength);
satListDifferential = new TextDifferential(nbSat * 3);
differentials = new HashMap<>();
}
// check for special events
epochDifferential.accept(loopEpochLine.subSequence(epochStart,
FastMath.min(loopEpochLine.length(), epochStart + epochLength)));
if (parseInt(epochDifferential.getUncompressed(), eventStart, 1) > 1) {
// this was not really the epoch, but rather a special event
// we just copy the lines and skip to real epoch and clock lines
builder.append(epochDifferential.getUncompressed());
trimTrailingSpaces(builder);
builder.append('\n');
final int skippedLines = parseInt(epochDifferential.getUncompressed(), nbSatStart, 3);
for (int i = 0; i < skippedLines; ++i) {
builder.append(loopClockLine);
trimTrailingSpaces(builder);
builder.append('\n');
loopClockLine = readLine();
}
// the epoch and clock are in the next lines
loopEpochLine = loopClockLine;
loopClockLine = readLine();
loop = true;
} else {
loop = false;
final int n = parseInt(epochDifferential.getUncompressed(), nbSatStart, 3);
satellites = new ArrayList<>(n);
if (satListStart < loopEpochLine.length()) {
satListDifferential.accept(loopEpochLine.subSequence(satListStart, loopEpochLine.length()));
}
final CharSequence satListPart = satListDifferential.getUncompressed();
for (int i = 0; i < n; ++i) {
satellites.add(satListPart.subSequence(i * 3, (i + 1) * 3).toString());
}
// parse clock offset
if (!loopClockLine.isEmpty()) {
if (loopClockLine.length() > 2 && loopClockLine.charAt(1) == '&') {
clockDifferential = new NumericDifferential(clockLength, clockDecimalPlaces, parseInt(loopClockLine, 0, 1));
clockDifferential.accept(loopClockLine.subSequence(2, loopClockLine.length()));
} else if (clockDifferential == null) {
throw new OrekitException(OrekitMessages.UNABLE_TO_PARSE_LINE_IN_FILE,
lineNumber, name, loopClockLine);
} else {
clockDifferential.accept(loopClockLine);
}
}
}
}
}
/** Get the uncompressed epoch part.
* @return uncompressed epoch part
*/
protected CharSequence getEpochPart() {
return epochDifferential.getUncompressed();
}
/** Get the uncompressed clock part.
* @return uncompressed clock part
*/
protected CharSequence getClockPart() {
return clockDifferential == null ? "" : clockDifferential.getUncompressed();
}
/** Get the satellites for current observations.
* @return satellites for current observation
*/
protected List<String> getSatellites() {
return satellites;
}
/** Get the combined differentials for one satellite.
* @param sat satellite id
* @return observationDifferentials
*/
protected CombinedDifferentials getCombinedDifferentials(final CharSequence sat) {
return differentials.get(sat);
}
/** Parse observation lines.
* @param observationLines observation lines
* @return uncompressed lines
*/
public abstract CharSequence parseObservationLines(String[] observationLines);
/** Parse observation lines.
* @param dataLength length of data fields
* @param dataDecimalPlaces number of decimal places for data fields
* @param observationLines observation lines
*/
protected void doParseObservationLines(final int dataLength, final int dataDecimalPlaces,
final String[] observationLines) {
for (int i = 0; i < observationLines.length; ++i) {
final CharSequence line = observationLines[i];
// get the differentials associated with this observations line
final String sat = satellites.get(i);
CombinedDifferentials satDiffs = differentials.get(sat);
if (satDiffs == null) {
final SatelliteSystem system = SatelliteSystem.parseSatelliteSystem(sat.subSequence(0, 1).toString());
satDiffs = new CombinedDifferentials(maxObs.get(system));
differentials.put(sat, satDiffs);
}
// parse observations
int k = 0;
for (int j = 0; j < satDiffs.observations.length; ++j) {
if (k >= line.length() || line.charAt(k) == ' ') {
// the data field is missing
satDiffs.observations[j] = null;
} else {
// the data field is present
if (k + 1 < line.length() &&
Character.isDigit(line.charAt(k)) &&
line.charAt(k + 1) == '&') {
// reinitialize differentials
satDiffs.observations[j] = new NumericDifferential(dataLength, dataDecimalPlaces,
Character.digit(line.charAt(k), 10));
k += 2;
}
// extract the compressed differenced value
final int start = k;
while (k < line.length() && line.charAt(k) != ' ') {
++k;
}
try {
satDiffs.observations[j].accept(line.subSequence(start, k));
} catch (NumberFormatException nfe) {
throw new OrekitException(nfe,
OrekitMessages.UNABLE_TO_PARSE_LINE_IN_FILE,
lineNumber + i - (observationLines.length - 1),
name, observationLines[i]);
}
}
// skip blank separator
++k;
}
if (k < line.length()) {
satDiffs.flags.accept(line.subSequence(k, line.length()));
}
}
}
/** Check if a line corresponds to a header.
* @param label header label
* @param line header line
* @return true if line corresponds to header
*/
protected boolean isHeaderLine(final String label, final String line) {
return label.equals(parseString(line, LABEL_START, label.length()));
}
/** Update the max number of observations.
* @param system satellite system
* @param nbObs number of observations
*/
protected void updateMaxObs(final SatelliteSystem system, final int nbObs) {
maxObs.put(system, FastMath.max(maxObs.get(system), nbObs));
}
/** Read a new line.
* @return line read
* @exception IOException if a read error occurs
*/
private String readLine()
throws IOException {
final String line = reader.readLine();
if (line == null) {
throw new OrekitException(OrekitMessages.UNEXPECTED_END_OF_FILE, name);
}
lineNumber++;
return line;
}
/** Get the rinex format corresponding to this compact rinex format.
* @param name file name
* @param reader line-oriented input
* @return rinex format associated with this compact rinex format
* @exception IOException if first lines cannot be read
*/
public static CompactRinexFormat getFormat(final String name, final BufferedReader reader)
throws IOException {
// read the first two lines of the file
final String line1 = reader.readLine();
final String line2 = reader.readLine();
if (line1 == null || line2 == null) {
throw new OrekitException(OrekitMessages.NOT_A_SUPPORTED_HATANAKA_COMPRESSED_FILE, name);
}
// extract format version
final int cVersion100 = (int) FastMath.rint(100 * parseDouble(line1, 0, 9));
if (cVersion100 != 100 && cVersion100 != 300) {
throw new OrekitException(OrekitMessages.UNSUPPORTED_FILE_FORMAT, name);
}
if (!CRINEX_VERSION_TYPE.equals(parseString(line1, LABEL_START, CRINEX_VERSION_TYPE.length()))) {
throw new OrekitException(OrekitMessages.NOT_A_SUPPORTED_HATANAKA_COMPRESSED_FILE, name);
}
if (!CRINEX_PROG_DATE.equals(parseString(line2, LABEL_START, CRINEX_PROG_DATE.length()))) {
throw new OrekitException(OrekitMessages.NOT_A_SUPPORTED_HATANAKA_COMPRESSED_FILE, name);
}
// build the appropriate parser
return cVersion100 < 300 ? new CompactRinex1(name, reader) : new CompactRinex3(name, reader);
}
/** Extract a string from a line.
* @param line to parse
* @param start start index of the string
* @param length length of the string
* @return parsed string
*/
public static String parseString(final CharSequence line, final int start, final int length) {
if (line.length() > start) {
return line.subSequence(start, FastMath.min(line.length(), start + length)).toString().trim();
} else {
return null;
}
}
/** Extract an integer from a line.
* @param line to parse
* @param start start index of the integer
* @param length length of the integer
* @return parsed integer
*/
public static int parseInt(final CharSequence line, final int start, final int length) {
if (line.length() > start && parseString(line, start, length).length() > 0) {
return Integer.parseInt(parseString(line, start, length));
} else {
return 0;
}
}
/** Extract a double from a line.
* @param line to parse
* @param start start index of the real
* @param length length of the real
* @return parsed real, or {@code Double.NaN} if field was empty
*/
public static double parseDouble(final CharSequence line, final int start, final int length) {
if (line.length() > start && parseString(line, start, length).length() > 0) {
return Double.parseDouble(parseString(line, start, length));
} else {
return Double.NaN;
}
}
/** Trim trailing spaces in a builder.
* @param builder builder to trim
*/
public static void trimTrailingSpaces(final StringBuilder builder) {
for (int i = builder.length() - 1; i >= 0 && builder.charAt(i) == ' '; --i) {
builder.deleteCharAt(i);
}
}
/** Enumerate for parsing sections. */
private enum Section {
/** Header section. */
HEADER,
/** Epoch and receiver clock offset section. */
EPOCH,
/** Observation section. */
OBSERVATION;
}
}
/** Compact RINEX 1 format (for RINEX 2.x). */
private static class CompactRinex1 extends CompactRinexFormat {
/** Label for number of observations. */
private static final String NB_TYPES_OF_OBSERV = "# / TYPES OF OBSERV";
/** Start of epoch field. */
private static final int EPOCH_START = 0;
/** Length of epoch field. */
private static final int EPOCH_LENGTH = 32;
/** Start of events flag. */
private static final int EVENT_START = EPOCH_START + EPOCH_LENGTH - 4;
/** Start of number of satellites field. */
private static final int NB_SAT_START = EPOCH_START + EPOCH_LENGTH - 3;
/** Start of satellites list field. */
private static final int SAT_LIST_START = EPOCH_START + EPOCH_LENGTH;
/** Length of satellites list field. */
private static final int SAT_LIST_LENGTH = 36;
/** Maximum number of satellites per epoch line. */
private static final int MAX_SAT_EPOCH_LINE = 12;
/** Start of receiver clock field. */
private static final int CLOCK_START = SAT_LIST_START + SAT_LIST_LENGTH;
/** Length of receiver clock field. */
private static final int CLOCK_LENGTH = 12;
/** Number of decimal places for receiver clock offset. */
private static final int CLOCK_DECIMAL_PLACES = 9;
/** Length of a data field. */
private static final int DATA_LENGTH = 14;
/** Number of decimal places for data fields. */
private static final int DATA_DECIMAL_PLACES = 3;
/** Simple constructor.
* @param name file name
* @param reader line-oriented input
*/
CompactRinex1(final String name, final BufferedReader reader) {
super(name, reader);
}
@Override
/** {@inheritDoc} */
public CharSequence parseHeaderLine(final String line) {
if (isHeaderLine(NB_TYPES_OF_OBSERV, line)) {
for (final SatelliteSystem system : SatelliteSystem.values()) {
updateMaxObs(system, parseInt(line, 0, 6));
}
return line;
} else {
return super.parseHeaderLine(line);
}
}
@Override
/** {@inheritDoc} */
public CharSequence parseEpochAndClockLines(final String epochLine, final String clockLine)
throws IOException {
final StringBuilder builder = new StringBuilder();
doParseEpochAndClockLines(builder,
EPOCH_START, EPOCH_LENGTH, EVENT_START, NB_SAT_START, SAT_LIST_START,
CLOCK_LENGTH, CLOCK_DECIMAL_PLACES, epochLine,
clockLine, '&');
// build uncompressed lines, taking care of clock being put
// back in line 1 and satellites after 12th put in continuation lines
final List<String> satellites = getSatellites();
builder.append(getEpochPart());
int iSat = 0;
while (iSat < FastMath.min(satellites.size(), MAX_SAT_EPOCH_LINE)) {
builder.append(satellites.get(iSat++));
}
if (getClockPart().length() > 0) {
while (builder.length() < CLOCK_START) {
builder.append(' ');
}
builder.append(getClockPart());
}
while (iSat < satellites.size()) {
// add a continuation line
trimTrailingSpaces(builder);
builder.append('\n');
for (int k = 0; k < SAT_LIST_START; ++k) {
builder.append(' ');
}
final int iSatStart = iSat;
while (iSat < FastMath.min(satellites.size(), iSatStart + MAX_SAT_EPOCH_LINE)) {
builder.append(satellites.get(iSat++));
}
}
trimTrailingSpaces(builder);
return builder;
}
@Override
/** {@inheritDoc} */
public CharSequence parseObservationLines(final String[] observationLines) {
// parse the observation lines
doParseObservationLines(DATA_LENGTH, DATA_DECIMAL_PLACES, observationLines);
// build uncompressed lines
final StringBuilder builder = new StringBuilder();
for (final CharSequence sat : getSatellites()) {
if (builder.length() > 0) {
trimTrailingSpaces(builder);
builder.append('\n');
}
final CombinedDifferentials cd = getCombinedDifferentials(sat);
final CharSequence flags = cd.flags.getUncompressed();
for (int i = 0; i < cd.observations.length; ++i) {
if (i > 0 && i % 5 == 0) {
trimTrailingSpaces(builder);
builder.append('\n');
}
if (cd.observations[i] == null) {
// missing observation
for (int j = 0; j < DATA_LENGTH + 2; ++j) {
builder.append(' ');
}
} else {
builder.append(cd.observations[i].getUncompressed());
if (2 * i < flags.length()) {
builder.append(flags.charAt(2 * i));
}
if (2 * i + 1 < flags.length()) {
builder.append(flags.charAt(2 * i + 1));
}
}
}
}
trimTrailingSpaces(builder);
return builder;
}
}
/** Compact RINEX 3 format (for RINEX 3.x). */
private static class CompactRinex3 extends CompactRinexFormat {
/** Label for number of observation types. */
private static final String SYS_NB_OBS_TYPES = "SYS / # / OBS TYPES";
/** Start of epoch field. */
private static final int EPOCH_START = 0;
/** Length of epoch field. */
private static final int EPOCH_LENGTH = 41;
/** Start of receiver clock field. */
private static final int CLOCK_START = EPOCH_START + EPOCH_LENGTH;
/** Length of receiver clock field. */
private static final int CLOCK_LENGTH = 15;
/** Number of decimal places for receiver clock offset. */
private static final int CLOCK_DECIMAL_PLACES = 12;
/** Start of events flag. */
private static final int EVENT_START = EPOCH_START + EPOCH_LENGTH - 10;
/** Start of number of satellites field. */
private static final int NB_SAT_START = EPOCH_START + EPOCH_LENGTH - 9;
/** Start of satellites list field (only in the compact rinex). */
private static final int SAT_LIST_START = EPOCH_START + EPOCH_LENGTH;
/** Length of a data field. */
private static final int DATA_LENGTH = 14;
/** Number of decimal places for data fields. */
private static final int DATA_DECIMAL_PLACES = 3;
/** Simple constructor.
* @param name file name
* @param reader line-oriented input
*/
CompactRinex3(final String name, final BufferedReader reader) {
super(name, reader);
}
@Override
/** {@inheritDoc} */
public CharSequence parseHeaderLine(final String line) {
if (isHeaderLine(SYS_NB_OBS_TYPES, line)) {
if (line.charAt(0) != ' ') {
// it is the first line of an observation types description
// (continuation lines are ignored here)
updateMaxObs(SatelliteSystem.parseSatelliteSystem(parseString(line, 0, 1)),
parseInt(line, 1, 5));
}
return line;
} else {
return super.parseHeaderLine(line);
}
}
@Override
/** {@inheritDoc} */
public CharSequence parseEpochAndClockLines(final String epochLine, final String clockLine)
throws IOException {
final StringBuilder builder = new StringBuilder();
doParseEpochAndClockLines(builder,
EPOCH_START, EPOCH_LENGTH, EVENT_START, NB_SAT_START, SAT_LIST_START,
CLOCK_LENGTH, CLOCK_DECIMAL_PLACES, epochLine,
clockLine, '>');
// build uncompressed line
builder.append(getEpochPart());
if (getClockPart().length() > 0) {
while (builder.length() < CLOCK_START) {
builder.append(' ');
}
builder.append(getClockPart());
}
trimTrailingSpaces(builder);
return builder;
}
@Override
/** {@inheritDoc} */
public CharSequence parseObservationLines(final String[] observationLines) {
// parse the observation lines
doParseObservationLines(DATA_LENGTH, DATA_DECIMAL_PLACES, observationLines);
// build uncompressed lines
final StringBuilder builder = new StringBuilder();
for (final CharSequence sat : getSatellites()) {
if (builder.length() > 0) {
trimTrailingSpaces(builder);
builder.append('\n');
}
builder.append(sat);
final CombinedDifferentials cd = getCombinedDifferentials(sat);
final CharSequence flags = cd.flags.getUncompressed();
for (int i = 0; i < cd.observations.length; ++i) {
if (cd.observations[i] == null) {
// missing observation
for (int j = 0; j < DATA_LENGTH + 2; ++j) {
builder.append(' ');
}
} else {
builder.append(cd.observations[i].getUncompressed());
if (2 * i < flags.length()) {
builder.append(flags.charAt(2 * i));
}
if (2 * i + 1 < flags.length()) {
builder.append(flags.charAt(2 * i + 1));
}
}
}
}
trimTrailingSpaces(builder);
return builder;
}
}
}