HatanakaCompressFilter.java

  1. /* Copyright 2002-2024 CS GROUP
  2.  * Licensed to CS GROUP (CS) under one or more
  3.  * contributor license agreements.  See the NOTICE file distributed with
  4.  * this work for additional information regarding copyright ownership.
  5.  * CS licenses this file to You under the Apache License, Version 2.0
  6.  * (the "License"); you may not use this file except in compliance with
  7.  * the License.  You may obtain a copy of the License at
  8.  *
  9.  *   http://www.apache.org/licenses/LICENSE-2.0
  10.  *
  11.  * Unless required by applicable law or agreed to in writing, software
  12.  * distributed under the License is distributed on an "AS IS" BASIS,
  13.  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14.  * See the License for the specific language governing permissions and
  15.  * limitations under the License.
  16.  */
  17. package org.orekit.files.rinex;
  18. import java.io.BufferedReader;
  19. import java.io.IOException;
  20. import java.io.Reader;
  21. import java.nio.CharBuffer;
  22. import java.util.ArrayList;
  23. import java.util.HashMap;
  24. import java.util.List;
  25. import java.util.Map;
  26. import java.util.regex.Matcher;
  27. import java.util.regex.Pattern;

  29. import org.hipparchus.util.FastMath;
  30. import org.orekit.data.DataFilter;
  31. import org.orekit.data.DataSource;
  32. import org.orekit.errors.OrekitException;
  33. import org.orekit.errors.OrekitMessages;
  34. import org.orekit.gnss.SatelliteSystem;

  36. /** Decompression filter for Hatanaka compressed RINEX files.
  37.  * @see <a href="http://cedadocs.ceda.ac.uk/1254/1/Hatanaka%5C_compressed%5C_format%5C_help.pdf">A
  38.  * Compression Format and Tools for GNSS Observation Data</a>
  39.  * @since 10.1
  40.  */
  41. public class HatanakaCompressFilter implements DataFilter {

  43.     /** Pattern for rinex 2 observation files. */
  44.     private static final Pattern RINEX_2_PATTERN = Pattern.compile("^(\\w{4}\\d{3}[0a-x](?:\\d{2})?\\.\\d{2})[dD]$");

  46.     /** Pattern for rinex 3 observation files. */
  47.     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$");

  49.     /** Empty constructor.
  50.      * <p>
  51.      * This constructor is not strictly necessary, but it prevents spurious
  52.      * javadoc warnings with JDK 18 and later.
  53.      * </p>
  54.      * @since 12.0
  55.      */
  56.     public HatanakaCompressFilter() {
  57.         // nothing to do
  58.     }

  60.     /** {@inheritDoc} */
  61.     @Override
  62.     public DataSource filter(final DataSource original) {

  64.         final String            oName   = original.getName();
  65.         final DataSource.Opener oOpener = original.getOpener();

  67.         final Matcher rinex2Matcher = RINEX_2_PATTERN.matcher(oName);
  68.         if (rinex2Matcher.matches()) {
  69.             // this is a rinex 2 file compressed with Hatanaka method
  70.             final String                  fName   = rinex2Matcher.group(1) + "o";
  71.             final DataSource.ReaderOpener fOpener = () -> new HatanakaReader(oName, oOpener.openReaderOnce());
  72.             return new DataSource(fName, fOpener);
  73.         }

  75.         final Matcher rinex3Matcher = RINEX_3_PATTERN.matcher(oName);
  76.         if (rinex3Matcher.matches()) {
  77.             // this is a rinex 3 file compressed with Hatanaka method
  78.             final String                  fName   = rinex3Matcher.group(1) + ".rnx";
  79.             final DataSource.ReaderOpener fOpener = () -> new HatanakaReader(oName, oOpener.openReaderOnce());
  80.             return new DataSource(fName, fOpener);
  81.         }

  83.         // it is not an Hatanaka compressed rinex file
  84.         return original;

  86.     }

  88.     /** Filtering of Hatanaka compressed characters stream. */
  89.     private static class HatanakaReader extends Reader {

  91.         /** Format of the current file. */
  92.         private final CompactRinexFormat format;

  94.         /** Line-oriented input. */
  95.         private final BufferedReader reader;

  97.         /** Pending uncompressed output lines. */
  98.         private CharSequence pending;

  100.         /** Number of characters already output in pending lines. */
  101.         private int countOut;

  103.         /** Simple constructor.
  104.          * @param name file name
  105.          * @param input underlying compressed stream
  106.          * @exception IOException if first lines cannot be read
  107.          */
  108.         HatanakaReader(final String name, final Reader input)
  109.             throws IOException {

  111.             reader = new BufferedReader(input);

  113.             // check header
  114.             format = CompactRinexFormat.getFormat(name, reader);

  116.             pending = null;

  118.         }

  120.         /** {@inheritDoc} */
  121.         @Override
  122.         public int read(final char[] b, final int offset, final int len) throws IOException {

  124.             if (pending == null) {
  125.                 // we need to read another section from the underlying characters stream and uncompress it
  126.                 countOut = 0;
  127.                 final String firstLine = reader.readLine();
  128.                 if (firstLine == null) {
  129.                     // there are no lines left
  130.                     return -1;
  131.                 } else {
  132.                     pending = format.uncompressSection(firstLine);
  133.                 }
  134.             }

  136.             // copy as many characters as possible from current line
  137.             int n = FastMath.min(len, pending.length() - countOut);
  138.             for (int i = 0; i < n; ++i) {
  139.                 b[offset + i] = pending.charAt(countOut + i);
  140.             }

  142.             if (n < len) {
  143.                 // line has been completed and we can still output end of line
  144.                 b[offset + n] = '\n';
  145.                 pending       = null;
  146.                 ++n;
  147.             } else {
  148.                 // there are still some pending characters
  149.                 countOut += n;
  150.             }

  152.             return n;

  154.         }

  156.         /** {@inheritDoc} */
  157.         @Override
  158.         public void close() throws IOException {
  159.             reader.close();
  160.         }

  162.     }

  164.     /** Processor handling differential compression for one numerical data field. */
  165.     private static class NumericDifferential {

  167.         /** Length of the uncompressed text field. */
  168.         private final int fieldLength;

  170.         /** Number of decimal places uncompressed text field. */
  171.         private final int decimalPlaces;

  173.         /** State vector. */
  174.         private final long[] state;

  176.         /** Number of components in the state vector. */
  177.         private int nbComponents;

  179.         /** Uncompressed value. */
  180.         private CharSequence uncompressed;

  182.         /** Simple constructor.
  183.          * @param fieldLength length of the uncompressed text field
  184.          * @param decimalPlaces number of decimal places uncompressed text field
  185.          * @param order differential order
  186.          */
  187.         NumericDifferential(final int fieldLength, final int decimalPlaces, final int order) {
  188.             this.fieldLength   = fieldLength;
  189.             this.decimalPlaces = decimalPlaces;
  190.             this.state         = new long[order + 1];
  191.             this.nbComponents  = 0;
  192.         }

  194.         /** Handle a new compressed value.
  195.          * @param sequence sequence containing the value to consider
  196.          */
  197.         public void accept(final CharSequence sequence) {

  199.             // store the value as the last component of state vector
  200.             state[nbComponents] = Long.parseLong(sequence.toString());

  202.             // update state vector
  203.             for (int i = nbComponents; i > 0; --i) {
  204.                 state[i - 1] += state[i];
  205.             }

  207.             if (++nbComponents == state.length) {
  208.                 // the state vector is full
  209.                 --nbComponents;
  210.             }

  212.             // output uncompressed value
  213.             final String unscaled = Long.toString(FastMath.abs(state[0]));
  214.             final int    length   = unscaled.length();
  215.             final int    digits   = FastMath.max(length, decimalPlaces);
  216.             final int    padding  = fieldLength - (digits + (state[0] < 0 ? 2 : 1));
  217.             final StringBuilder builder = new StringBuilder();
  218.             for (int i = 0; i < padding; ++i) {
  219.                 builder.append(' ');
  220.             }
  221.             if (state[0] < 0) {
  222.                 builder.append('-');
  223.             }
  224.             if (length > decimalPlaces) {
  225.                 builder.append(unscaled, 0, length - decimalPlaces);
  226.             }
  227.             builder.append('.');
  228.             for (int i = decimalPlaces; i > 0; --i) {
  229.                 builder.append(i > length ? '0' : unscaled.charAt(length - i));
  230.             }

  232.             uncompressed = builder;

  234.         }

  236.         /** Get a string representation of the uncompressed value.
  237.          * @return string representation of the uncompressed value
  238.          */
  239.         public CharSequence getUncompressed() {
  240.             return uncompressed;
  241.         }

  243.     }

  245.     /** Processor handling text compression for one text data field. */
  246.     private static class TextDifferential {

  248.         /** Buffer holding the current state. */
  249.         private CharBuffer state;

  251.         /** Simple constructor.
  252.          * @param fieldLength length of the uncompressed text field
  253.          */
  254.         TextDifferential(final int fieldLength) {
  255.             this.state = CharBuffer.allocate(fieldLength);
  256.             for (int i = 0; i < fieldLength; ++i) {
  257.                 state.put(i, ' ');
  258.             }
  259.         }

  261.         /** Handle a new compressed value.
  262.          * @param sequence sequence containing the value to consider
  263.          */
  264.         public void accept(final CharSequence sequence) {

  266.             // update state
  267.             final int length = FastMath.min(state.capacity(), sequence.length());
  268.             for (int i = 0; i < length; ++i) {
  269.                 final char c = sequence.charAt(i);
  270.                 if (c == '&') {
  271.                     // update state with disappearing character
  272.                     state.put(i, ' ');
  273.                 } else if (c != ' ') {
  274.                     // update state with changed character
  275.                     state.put(i, c);
  276.                 }
  277.             }

  279.         }

  281.         /** Get a string representation of the uncompressed value.
  282.          * @return string representation of the uncompressed value
  283.          */
  284.         public CharSequence getUncompressed() {
  285.             return state;
  286.         }

  288.     }

  290.     /** Container for combined observations and flags. */
  291.     private static class CombinedDifferentials {

  293.         /** Observation differentials. */
  294.         private NumericDifferential[] observations;

  296.         /** Flags differential. */
  297.         private TextDifferential flags;

  299.         /** Simple constructor.
  300.          * Build an empty container.
  301.          * @param nbObs number of observations
  302.          */
  303.         CombinedDifferentials(final int nbObs) {
  304.             this.observations = new NumericDifferential[nbObs];
  305.             this.flags        = new TextDifferential(2 * nbObs);
  306.         }

  308.     }

  310.     /** Base class for parsing compact RINEX format. */
  311.     private abstract static class CompactRinexFormat {

  313.         /** Index of label in data lines. */
  314.         private static final int LABEL_START = 60;

  316.         /** Label for compact Rinex version. */
  317.         private static final String CRINEX_VERSION_TYPE  = "CRINEX VERS   / TYPE";

  319.         /** Label for compact Rinex program. */
  320.         private static final String CRINEX_PROG_DATE     = "CRINEX PROG / DATE";

  322.         /** Label for number of satellites. */
  323.         private static final String NB_OF_SATELLITES = "# OF SATELLITES";

  325.         /** Label for end of header. */
  326.         private static final String END_OF_HEADER    = "END OF HEADER";

  328.         /** Default number of satellites (used if not present in the file). */
  329.         private static final int DEFAULT_NB_SAT = 500;

  331.         /** File name. */
  332.         private final String name;

  334.         /** Line-oriented input. */
  335.         private final BufferedReader reader;

  337.         /** Current line number. */
  338.         private int lineNumber;

  340.         /** Maximum number of observations for one satellite. */
  341.         private final Map<SatelliteSystem, Integer> maxObs;

  343.         /** Number of satellites. */
  344.         private int nbSat;

  346.         /** Indicator for current section type. */
  347.         private Section section;

  349.         /** Satellites observed at current epoch. */
  350.         private List<String> satellites;

  352.         /** Differential engine for epoch. */
  353.         private TextDifferential epochDifferential;

  355.         /** Receiver clock offset differential. */
  356.         private NumericDifferential clockDifferential;

  358.         /** Differential engine for satellites list. */
  359.         private TextDifferential satListDifferential;

  361.         /** Differential engines for each satellite. */
  362.         private Map<String, CombinedDifferentials> differentials;

  364.         /** Simple constructor.
  365.          * @param name file name
  366.          * @param reader line-oriented input
  367.          */
  368.         protected CompactRinexFormat(final String name, final BufferedReader reader) {
  369.             this.name    = name;
  370.             this.reader  = reader;
  371.             this.maxObs  = new HashMap<>();
  372.             for (final SatelliteSystem system : SatelliteSystem.values()) {
  373.                 maxObs.put(system, 0);
  374.             }
  375.             this.nbSat   = DEFAULT_NB_SAT;
  376.             this.section = Section.HEADER;
  377.         }

  379.         /** Uncompress a section.
  380.          * @param firstLine first line of the section
  381.          * @return uncompressed section (contains several lines)
  382.          * @exception IOException if we cannot read lines from underlying stream
  383.          */
  384.         public CharSequence uncompressSection(final String firstLine)
  385.             throws IOException {
  386.             final CharSequence uncompressed;
  387.             switch (section) {

  389.                 case HEADER : {
  390.                     // header lines
  391.                     final StringBuilder builder = new StringBuilder();
  392.                     String line = firstLine;
  393.                     lineNumber = 3; // there are 2 CRINEX lines before the RINEX header line
  394.                     while (section == Section.HEADER) {
  395.                         if (builder.length() > 0) {
  396.                             builder.append('\n');
  397.                             line = readLine();
  398.                         }
  399.                         builder.append(parseHeaderLine(line));
  400.                         trimTrailingSpaces(builder);
  401.                     }
  402.                     uncompressed = builder;
  403.                     section      = Section.EPOCH;
  404.                     break;
  405.                 }

  407.                 case EPOCH : {
  408.                     // epoch and receiver clock offset lines
  409.                     ++lineNumber; // the caller has read one epoch line
  410.                     uncompressed = parseEpochAndClockLines(firstLine, readLine().trim());
  411.                     section      = Section.OBSERVATION;
  412.                     break;
  413.                 }

  415.                 default : {
  416.                     // observation lines
  417.                     final String[] lines = new String[satellites.size()];
  418.                     ++lineNumber; // the caller has read one observation line
  419.                     lines[0] = firstLine;
  420.                     for (int i = 1; i < lines.length; ++i) {
  421.                         lines[i] = readLine();
  422.                     }
  423.                     uncompressed = parseObservationLines(lines);
  424.                     section      = Section.EPOCH;
  425.                 }

  427.             }

  429.             return uncompressed;

  431.         }

  433.         /** Parse a header line.
  434.          * @param line header line
  435.          * @return uncompressed line
  436.          */
  437.         public CharSequence parseHeaderLine(final String line) {

  439.             if (isHeaderLine(NB_OF_SATELLITES, line)) {
  440.                 // number of satellites
  441.                 nbSat = parseInt(line, 0, 6);
  442.             } else if (isHeaderLine(END_OF_HEADER, line)) {
  443.                 // we have reached end of header, prepare parsing of data records
  444.                 section = Section.EPOCH;
  445.             }

  447.             // within header, lines are simply copied
  448.             return line;

  450.         }

  452.         /** Parse epoch and receiver clock offset lines.
  453.          * @param epochLine epoch line
  454.          * @param clockLine receiver clock offset line
  455.          * @return uncompressed line
  456.          * @exception IOException if we cannot read additional special events lines
  457.          */
  458.         public abstract CharSequence parseEpochAndClockLines(String epochLine, String clockLine)
  459.             throws IOException;

  461.         /** Parse epoch and receiver clock offset lines.
  462.          * @param builder builder that may used to copy special event lines
  463.          * @param epochStart start of the epoch field
  464.          * @param epochLength length of epoch field
  465.          * @param eventStart start of the special events field
  466.          * @param nbSatStart start of the number of satellites field
  467.          * @param satListStart start of the satellites list
  468.          * @param clockLength length of receiver clock field
  469.          * @param clockDecimalPlaces number of decimal places for receiver clock offset
  470.          * @param epochLine epoch line
  471.          * @param clockLine receiver clock offset line
  472.          * @param resetChar character indicating differentials reset
  473.          * @exception IOException if we cannot read additional special events lines
  474.          */
  475.         protected void doParseEpochAndClockLines(final StringBuilder builder,
  476.                                                  final int epochStart, final int epochLength,
  477.                                                  final int eventStart, final int nbSatStart, final int satListStart,
  478.                                                  final int clockLength, final int clockDecimalPlaces,
  479.                                                  final String epochLine,
  480.                                                  final String clockLine, final char resetChar)
  481.             throws IOException {

  483.             boolean loop = true;
  484.             String loopEpochLine = epochLine;
  485.             String loopClockLine = clockLine;
  486.             while (loop) {

  488.                 // check if differentials should be reset
  489.                 if (epochDifferential == null || loopEpochLine.charAt(0) == resetChar) {
  490.                     epochDifferential   = new TextDifferential(epochLength);
  491.                     satListDifferential = new TextDifferential(nbSat * 3);
  492.                     differentials       = new HashMap<>();
  493.                 }

  495.                 // check for special events
  496.                 epochDifferential.accept(loopEpochLine.subSequence(epochStart,
  497.                                                                    FastMath.min(loopEpochLine.length(), epochStart + epochLength)));
  498.                 if (parseInt(epochDifferential.getUncompressed(), eventStart, 1) > 1) {
  499.                     // this was not really the epoch, but rather a special event
  500.                     // we just copy the lines and skip to real epoch and clock lines
  501.                     builder.append(epochDifferential.getUncompressed());
  502.                     trimTrailingSpaces(builder);
  503.                     builder.append('\n');
  504.                     final int skippedLines = parseInt(epochDifferential.getUncompressed(), nbSatStart, 3);
  505.                     for (int i = 0; i < skippedLines; ++i) {
  506.                         builder.append(loopClockLine);
  507.                         trimTrailingSpaces(builder);
  508.                         builder.append('\n');
  509.                         loopClockLine = readLine();
  510.                     }

  512.                     // the epoch and clock are in the next lines
  513.                     loopEpochLine = loopClockLine;
  514.                     loopClockLine = readLine();
  515.                     loop = true;

  517.                 } else {
  518.                     loop = false;
  519.                     final int n = parseInt(epochDifferential.getUncompressed(), nbSatStart, 3);
  520.                     satellites = new ArrayList<>(n);
  521.                     if (satListStart < loopEpochLine.length()) {
  522.                         satListDifferential.accept(loopEpochLine.subSequence(satListStart, loopEpochLine.length()));
  523.                     }
  524.                     final CharSequence satListPart = satListDifferential.getUncompressed();
  525.                     for (int i = 0; i < n; ++i) {
  526.                         satellites.add(satListPart.subSequence(i * 3, (i + 1) * 3).toString());
  527.                     }

  529.                     // parse clock offset
  530.                     if (!loopClockLine.isEmpty()) {
  531.                         if (loopClockLine.length() > 2 && loopClockLine.charAt(1) == '&') {
  532.                             clockDifferential = new NumericDifferential(clockLength, clockDecimalPlaces, parseInt(loopClockLine, 0, 1));
  533.                             clockDifferential.accept(loopClockLine.subSequence(2, loopClockLine.length()));
  534.                         } else if (clockDifferential == null) {
  535.                             throw new OrekitException(OrekitMessages.UNABLE_TO_PARSE_LINE_IN_FILE,
  536.                                                       lineNumber, name, loopClockLine);
  537.                         } else {
  538.                             clockDifferential.accept(loopClockLine);
  539.                         }
  540.                     }
  541.                 }
  542.             }

  544.         }

  546.         /** Get the uncompressed epoch part.
  547.          * @return uncompressed epoch part
  548.          */
  549.         protected CharSequence getEpochPart() {
  550.             return epochDifferential.getUncompressed();
  551.         }

  553.         /** Get the uncompressed clock part.
  554.          * @return uncompressed clock part
  555.          */
  556.         protected CharSequence getClockPart() {
  557.             return clockDifferential == null ? "" : clockDifferential.getUncompressed();
  558.         }

  560.         /** Get the satellites for current observations.
  561.          * @return satellites for current observation
  562.          */
  563.         protected List<String> getSatellites() {
  564.             return satellites;
  565.         }

  567.         /** Get the combined differentials for one satellite.
  568.          * @param sat satellite id
  569.          * @return observationDifferentials
  570.          */
  571.         protected CombinedDifferentials getCombinedDifferentials(final CharSequence sat) {
  572.             return differentials.get(sat);
  573.         }

  575.         /** Parse observation lines.
  576.          * @param observationLines observation lines
  577.          * @return uncompressed lines
  578.          */
  579.         public abstract CharSequence parseObservationLines(String[] observationLines);

  581.         /** Parse observation lines.
  582.          * @param dataLength length of data fields
  583.          * @param dataDecimalPlaces number of decimal places for data fields
  584.          * @param observationLines observation lines
  585.          */
  586.         protected void doParseObservationLines(final int dataLength, final int dataDecimalPlaces,
  587.                                                final String[] observationLines) {

  589.             for (int i = 0; i < observationLines.length; ++i) {

  591.                 final CharSequence line = observationLines[i];

  593.                 // get the differentials associated with this observations line
  594.                 final String sat = satellites.get(i);
  595.                 CombinedDifferentials satDiffs = differentials.get(sat);
  596.                 if (satDiffs == null) {
  597.                     final SatelliteSystem system = SatelliteSystem.parseSatelliteSystem(sat.subSequence(0, 1).toString());
  598.                     satDiffs = new CombinedDifferentials(maxObs.get(system));
  599.                     differentials.put(sat, satDiffs);
  600.                 }

  602.                 // parse observations
  603.                 int k = 0;
  604.                 for (int j = 0; j < satDiffs.observations.length; ++j) {

  606.                     if (k >= line.length() || line.charAt(k) == ' ') {
  607.                         // the data field is missing
  608.                         satDiffs.observations[j] = null;
  609.                     } else {
  610.                         // the data field is present

  612.                         if (k + 1 < line.length() &&
  613.                             Character.isDigit(line.charAt(k)) &&
  614.                             line.charAt(k + 1) == '&') {
  615.                             // reinitialize differentials
  616.                             satDiffs.observations[j] = new NumericDifferential(dataLength, dataDecimalPlaces,
  617.                                                                                Character.digit(line.charAt(k), 10));
  618.                             k += 2;
  619.                         }

  621.                         // extract the compressed differenced value
  622.                         final int start = k;
  623.                         while (k < line.length() && line.charAt(k) != ' ') {
  624.                             ++k;
  625.                         }
  626.                         try {
  627.                             satDiffs.observations[j].accept(line.subSequence(start, k));
  628.                         } catch (NumberFormatException nfe) {
  629.                             throw new OrekitException(nfe,
  630.                                                       OrekitMessages.UNABLE_TO_PARSE_LINE_IN_FILE,
  631.                                                       lineNumber + i - (observationLines.length - 1),
  632.                                                       name, observationLines[i]);
  633.                         }

  635.                     }

  637.                     // skip blank separator
  638.                     ++k;

  640.                 }

  642.                 if (k < line.length()) {
  643.                     satDiffs.flags.accept(line.subSequence(k, line.length()));
  644.                 }

  646.             }

  648.         }

  650.         /** Check if a line corresponds to a header.
  651.          * @param label header label
  652.          * @param line header line
  653.          * @return true if line corresponds to header
  654.          */
  655.         protected boolean isHeaderLine(final String label, final String line) {
  656.             return label.equals(parseString(line, LABEL_START, label.length()));
  657.         }

  659.         /** Update the max number of observations.
  660.          * @param system satellite system
  661.          * @param nbObs number of observations
  662.          */
  663.         protected void updateMaxObs(final SatelliteSystem system, final int nbObs) {
  664.             maxObs.put(system, FastMath.max(maxObs.get(system), nbObs));
  665.         }

  667.         /** Read a new line.
  668.          * @return line read
  669.          * @exception IOException if a read error occurs
  670.          */
  671.         private String readLine()
  672.             throws IOException {
  673.             final String line = reader.readLine();
  674.             if (line == null) {
  675.                 throw new OrekitException(OrekitMessages.UNEXPECTED_END_OF_FILE, name);
  676.             }
  677.             lineNumber++;
  678.             return line;
  679.         }

  681.         /** Get the rinex format corresponding to this compact rinex format.
  682.          * @param name file name
  683.          * @param reader line-oriented input
  684.          * @return rinex format associated with this compact rinex format
  685.          * @exception IOException if first lines cannot be read
  686.          */
  687.         public static CompactRinexFormat getFormat(final String name, final BufferedReader reader)
  688.             throws IOException {

  690.             // read the first two lines of the file
  691.             final String line1 = reader.readLine();
  692.             final String line2 = reader.readLine();
  693.             if (line1 == null || line2 == null) {
  694.                 throw new OrekitException(OrekitMessages.NOT_A_SUPPORTED_HATANAKA_COMPRESSED_FILE, name);
  695.             }

  697.             // extract format version
  698.             final int cVersion100 = (int) FastMath.rint(100 * parseDouble(line1, 0, 9));
  699.             if (cVersion100 != 100 && cVersion100 != 300) {
  700.                 throw new OrekitException(OrekitMessages.UNSUPPORTED_FILE_FORMAT, name);
  701.             }
  702.             if (!CRINEX_VERSION_TYPE.equals(parseString(line1, LABEL_START, CRINEX_VERSION_TYPE.length()))) {
  703.                 throw new OrekitException(OrekitMessages.NOT_A_SUPPORTED_HATANAKA_COMPRESSED_FILE, name);
  704.             }
  705.             if (!CRINEX_PROG_DATE.equals(parseString(line2, LABEL_START, CRINEX_PROG_DATE.length()))) {
  706.                 throw new OrekitException(OrekitMessages.NOT_A_SUPPORTED_HATANAKA_COMPRESSED_FILE, name);
  707.             }

  709.             // build the appropriate parser
  710.             return cVersion100 < 300 ? new CompactRinex1(name, reader) : new CompactRinex3(name, reader);

  712.         }

  714.         /** Extract a string from a line.
  715.          * @param line to parse
  716.          * @param start start index of the string
  717.          * @param length length of the string
  718.          * @return parsed string
  719.          */
  720.         public static String parseString(final CharSequence line, final int start, final int length) {
  721.             if (line.length() > start) {
  722.                 return line.subSequence(start, FastMath.min(line.length(), start + length)).toString().trim();
  723.             } else {
  724.                 return null;
  725.             }
  726.         }

  728.         /** Extract an integer from a line.
  729.          * @param line to parse
  730.          * @param start start index of the integer
  731.          * @param length length of the integer
  732.          * @return parsed integer
  733.          */
  734.         public static int parseInt(final CharSequence line, final int start, final int length) {
  735.             if (line.length() > start && parseString(line, start, length).length() > 0) {
  736.                 return Integer.parseInt(parseString(line, start, length));
  737.             } else {
  738.                 return 0;
  739.             }
  740.         }

  742.         /** Extract a double from a line.
  743.          * @param line to parse
  744.          * @param start start index of the real
  745.          * @param length length of the real
  746.          * @return parsed real, or {@code Double.NaN} if field was empty
  747.          */
  748.         public static double parseDouble(final CharSequence line, final int start, final int length) {
  749.             if (line.length() > start && parseString(line, start, length).length() > 0) {
  750.                 return Double.parseDouble(parseString(line, start, length));
  751.             } else {
  752.                 return Double.NaN;
  753.             }
  754.         }

  756.         /** Trim trailing spaces in a builder.
  757.          * @param builder builder to trim
  758.          */
  759.         public static void trimTrailingSpaces(final StringBuilder builder) {
  760.             for (int i = builder.length() - 1; i >= 0 && builder.charAt(i) == ' '; --i) {
  761.                 builder.deleteCharAt(i);
  762.             }
  763.         }

  765.         /** Enumerate for parsing sections. */
  766.         private enum Section {

  768.             /** Header section. */
  769.             HEADER,

  771.             /** Epoch and receiver clock offset section. */
  772.             EPOCH,

  774.             /** Observation section. */
  775.             OBSERVATION;

  777.         }

  779.     }

  781.     /** Compact RINEX 1 format (for RINEX 2.x). */
  782.     private static class CompactRinex1 extends CompactRinexFormat {

  784.         /** Label for number of observations. */
  785.         private static final String NB_TYPES_OF_OBSERV   = "# / TYPES OF OBSERV";

  787.         /** Start of epoch field. */
  788.         private static final int    EPOCH_START          = 0;

  790.         /** Length of epoch field. */
  791.         private static final int    EPOCH_LENGTH         = 32;

  793.         /** Start of events flag. */
  794.         private static final int    EVENT_START          = EPOCH_START + EPOCH_LENGTH - 4;

  796.         /** Start of number of satellites field. */
  797.         private static final int    NB_SAT_START         = EPOCH_START + EPOCH_LENGTH - 3;

  799.         /** Start of satellites list field. */
  800.         private static final int    SAT_LIST_START       = EPOCH_START + EPOCH_LENGTH;

  802.         /** Length of satellites list field. */
  803.         private static final int    SAT_LIST_LENGTH      = 36;

  805.         /** Maximum number of satellites per epoch line. */
  806.         private static final int    MAX_SAT_EPOCH_LINE   = 12;

  808.         /** Start of receiver clock field. */
  809.         private static final int    CLOCK_START          = SAT_LIST_START + SAT_LIST_LENGTH;

  811.         /** Length of receiver clock field. */
  812.         private static final int    CLOCK_LENGTH         = 12;

  814.         /** Number of decimal places for receiver clock offset. */
  815.         private static final int    CLOCK_DECIMAL_PLACES = 9;

  817.         /** Length of a data field. */
  818.         private static final int    DATA_LENGTH          = 14;

  820.         /** Number of decimal places for data fields. */
  821.         private static final int    DATA_DECIMAL_PLACES  = 3;

  823.         /** Simple constructor.
  824.          * @param name file name
  825.          * @param reader line-oriented input
  826.          */
  827.         CompactRinex1(final String name, final BufferedReader reader) {
  828.             super(name, reader);
  829.         }

  831.         @Override
  832.         /** {@inheritDoc} */
  833.         public CharSequence parseHeaderLine(final String line) {
  834.             if (isHeaderLine(NB_TYPES_OF_OBSERV, line)) {
  835.                 for (final SatelliteSystem system : SatelliteSystem.values()) {
  836.                     updateMaxObs(system, parseInt(line, 0, 6));
  837.                 }
  838.                 return line;
  839.             } else {
  840.                 return super.parseHeaderLine(line);
  841.             }
  842.         }

  844.         @Override
  845.         /** {@inheritDoc} */
  846.         public CharSequence parseEpochAndClockLines(final String epochLine, final String clockLine)
  847.             throws IOException {

  849.             final StringBuilder builder = new StringBuilder();
  850.             doParseEpochAndClockLines(builder,
  851.                                       EPOCH_START, EPOCH_LENGTH, EVENT_START, NB_SAT_START, SAT_LIST_START,
  852.                                       CLOCK_LENGTH, CLOCK_DECIMAL_PLACES, epochLine,
  853.                                       clockLine, '&');

  855.             // build uncompressed lines, taking care of clock being put
  856.             // back in line 1 and satellites after 12th put in continuation lines
  857.             final List<String> satellites = getSatellites();
  858.             builder.append(getEpochPart());
  859.             int iSat = 0;
  860.             while (iSat < FastMath.min(satellites.size(), MAX_SAT_EPOCH_LINE)) {
  861.                 builder.append(satellites.get(iSat++));
  862.             }
  863.             if (getClockPart().length() > 0) {
  864.                 while (builder.length() < CLOCK_START) {
  865.                     builder.append(' ');
  866.                 }
  867.                 builder.append(getClockPart());
  868.             }

  870.             while (iSat < satellites.size()) {
  871.                 // add a continuation line
  872.                 trimTrailingSpaces(builder);
  873.                 builder.append('\n');
  874.                 for (int k = 0; k < SAT_LIST_START; ++k) {
  875.                     builder.append(' ');
  876.                 }
  877.                 final int iSatStart = iSat;
  878.                 while (iSat < FastMath.min(satellites.size(), iSatStart + MAX_SAT_EPOCH_LINE)) {
  879.                     builder.append(satellites.get(iSat++));
  880.                 }
  881.             }
  882.             trimTrailingSpaces(builder);
  883.             return builder;

  885.         }

  887.         @Override
  888.         /** {@inheritDoc} */
  889.         public CharSequence parseObservationLines(final String[] observationLines) {

  891.             // parse the observation lines
  892.             doParseObservationLines(DATA_LENGTH, DATA_DECIMAL_PLACES, observationLines);

  894.             // build uncompressed lines
  895.             final StringBuilder builder = new StringBuilder();
  896.             for (final CharSequence sat : getSatellites()) {
  897.                 if (builder.length() > 0) {
  898.                     trimTrailingSpaces(builder);
  899.                     builder.append('\n');
  900.                 }
  901.                 final CombinedDifferentials cd    = getCombinedDifferentials(sat);
  902.                 final CharSequence          flags = cd.flags.getUncompressed();
  903.                 for (int i = 0; i < cd.observations.length; ++i) {
  904.                     if (i > 0 && i % 5 == 0) {
  905.                         trimTrailingSpaces(builder);
  906.                         builder.append('\n');
  907.                     }
  908.                     if (cd.observations[i] == null) {
  909.                         // missing observation
  910.                         for (int j = 0; j < DATA_LENGTH + 2; ++j) {
  911.                             builder.append(' ');
  912.                         }
  913.                     } else {
  914.                         builder.append(cd.observations[i].getUncompressed());
  915.                         if (2 * i < flags.length()) {
  916.                             builder.append(flags.charAt(2 * i));
  917.                         }
  918.                         if (2 * i + 1 < flags.length()) {
  919.                             builder.append(flags.charAt(2 * i + 1));
  920.                         }
  921.                     }
  922.                 }
  923.             }
  924.             trimTrailingSpaces(builder);
  925.             return builder;

  927.         }

  929.     }

  931.     /** Compact RINEX 3 format (for RINEX 3.x). */
  932.     private static class CompactRinex3 extends CompactRinexFormat {

  934.         /** Label for number of observation types. */
  935.         private static final String SYS_NB_OBS_TYPES     = "SYS / # / OBS TYPES";

  937.         /** Start of epoch field. */
  938.         private static final int    EPOCH_START          = 0;

  940.         /** Length of epoch field. */
  941.         private static final int    EPOCH_LENGTH         = 41;

  943.         /** Start of receiver clock field. */
  944.         private static final int    CLOCK_START          = EPOCH_START + EPOCH_LENGTH;

  946.         /** Length of receiver clock field. */
  947.         private static final int    CLOCK_LENGTH         = 15;

  949.         /** Number of decimal places for receiver clock offset. */
  950.         private static final int    CLOCK_DECIMAL_PLACES = 12;

  952.         /** Start of events flag. */
  953.         private static final int    EVENT_START          = EPOCH_START + EPOCH_LENGTH - 10;

  955.         /** Start of number of satellites field. */
  956.         private static final int    NB_SAT_START         = EPOCH_START + EPOCH_LENGTH - 9;

  958.         /** Start of satellites list field (only in the compact rinex). */
  959.         private static final int    SAT_LIST_START       = EPOCH_START + EPOCH_LENGTH;

  961.         /** Length of a data field. */
  962.         private static final int    DATA_LENGTH          = 14;

  964.         /** Number of decimal places for data fields. */
  965.         private static final int    DATA_DECIMAL_PLACES  = 3;

  967.         /** Simple constructor.
  968.          * @param name file name
  969.          * @param reader line-oriented input
  970.          */
  971.         CompactRinex3(final String name, final BufferedReader reader) {
  972.             super(name, reader);
  973.         }

  975.         @Override
  976.         /** {@inheritDoc} */
  977.         public CharSequence parseHeaderLine(final String line) {
  978.             if (isHeaderLine(SYS_NB_OBS_TYPES, line)) {
  979.                 if (line.charAt(0) != ' ') {
  980.                     // it is the first line of an observation types description
  981.                     // (continuation lines are ignored here)
  982.                     updateMaxObs(SatelliteSystem.parseSatelliteSystem(parseString(line, 0, 1)),
  983.                                  parseInt(line, 1, 5));
  984.                 }
  985.                 return line;
  986.             } else {
  987.                 return super.parseHeaderLine(line);
  988.             }
  989.         }

  991.         @Override
  992.         /** {@inheritDoc} */
  993.         public CharSequence parseEpochAndClockLines(final String epochLine, final String clockLine)
  994.             throws IOException {

  996.             final StringBuilder builder = new StringBuilder();
  997.             doParseEpochAndClockLines(builder,
  998.                                       EPOCH_START, EPOCH_LENGTH, EVENT_START, NB_SAT_START, SAT_LIST_START,
  999.                                       CLOCK_LENGTH, CLOCK_DECIMAL_PLACES, epochLine,
  1000.                                       clockLine, '>');

  1002.             // build uncompressed line
  1003.             builder.append(getEpochPart());
  1004.             if (getClockPart().length() > 0) {
  1005.                 while (builder.length() < CLOCK_START) {
  1006.                     builder.append(' ');
  1007.                 }
  1008.                 builder.append(getClockPart());
  1009.             }

  1011.             trimTrailingSpaces(builder);
  1012.             return builder;

  1014.         }

  1016.         @Override
  1017.         /** {@inheritDoc} */
  1018.         public CharSequence parseObservationLines(final String[] observationLines) {

  1020.             // parse the observation lines
  1021.             doParseObservationLines(DATA_LENGTH, DATA_DECIMAL_PLACES, observationLines);

  1023.             // build uncompressed lines
  1024.             final StringBuilder builder = new StringBuilder();
  1025.             for (final CharSequence sat : getSatellites()) {
  1026.                 if (builder.length() > 0) {
  1027.                     trimTrailingSpaces(builder);
  1028.                     builder.append('\n');
  1029.                 }
  1030.                 builder.append(sat);
  1031.                 final CombinedDifferentials cd    = getCombinedDifferentials(sat);
  1032.                 final CharSequence          flags = cd.flags.getUncompressed();
  1033.                 for (int i = 0; i < cd.observations.length; ++i) {
  1034.                     if (cd.observations[i] == null) {
  1035.                         // missing observation
  1036.                         for (int j = 0; j < DATA_LENGTH + 2; ++j) {
  1037.                             builder.append(' ');
  1038.                         }
  1039.                     } else {
  1040.                         builder.append(cd.observations[i].getUncompressed());
  1041.                         if (2 * i < flags.length()) {
  1042.                             builder.append(flags.charAt(2 * i));
  1043.                         }
  1044.                         if (2 * i + 1 < flags.length()) {
  1045.                             builder.append(flags.charAt(2 * i + 1));
  1046.                         }
  1047.                     }
  1048.                 }
  1049.             }
  1050.             trimTrailingSpaces(builder);
  1051.             return builder;

  1053.         }

  1055.     }

  1057. }
Created with JaCoCo 0.8.11.202310140853