CaveConverter_src/0000755000000000000000000000000012242136246013173 5ustar rootrootCaveConverter_src/src/0000755000000000000000000000000012242136246013762 5ustar rootrootCaveConverter_src/src/footleg/0000755000000000000000000000000012165540164015423 5ustar rootrootCaveConverter_src/src/footleg/cavesurvey/0000755000000000000000000000000012165542140017613 5ustar rootrootCaveConverter_src/src/footleg/cavesurvey/data/0000755000000000000000000000000012165540164020530 5ustar rootrootCaveConverter_src/src/footleg/cavesurvey/data/model/0000755000000000000000000000000012205646674021640 5ustar rootrootCaveConverter_src/src/footleg/cavesurvey/data/model/CaveSurvey.java0000644000000000000000000000742312205646766024607 0ustar rootroot/** * Copyright (C) 2009-2013 Paul Fretwell - aka 'Footleg' (drfootleg@gmail.com) * * This file is part of Cave Converter. * * Cave Converter is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation, either version 3 of the License, or * (at your option) any later version. * * Cave Converter is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with Cave Converter. If not, see . */ package footleg.cavesurvey.data.model; import java.util.ArrayList; import java.util.Iterator; import java.util.List; import java.util.ListIterator; import footleg.cavesurvey.cmdline.CaveConverter; /** * Class representing a complete cave survey data model. This can consist of * one or more cave surveys. * * @author Footleg * @version 2013.07.18 (ISO 8601 YYYY.MM.DD) * @since 1.6 (The Java version used) */ public class CaveSurvey { private List survey; /** * */ public CaveSurvey() { //Create new list of survey series to hold data survey = new ArrayList(); } public int size() { return survey.size(); } public boolean isEmpty() { return survey.isEmpty(); } public boolean contains(Object o) { return survey.contains(o); } public Iterator iterator() { return survey.listIterator(); } public boolean add(SurveySeries e) { return survey.add(e); } public boolean remove(SurveySeries o) { return survey.remove(o); } public void clear() { survey.clear(); } public SurveySeries get(int index) { return survey.get(index); } public SurveySeries set(int index, SurveySeries element) { return survey.set(index, element); } public void add(int index, SurveySeries element) { survey.add(index, element); } public SurveySeries remove(int index) { return survey.remove(index); } public ListIterator listIterator() { return survey.listIterator(); } public ListIterator listIterator(int index) { return survey.listIterator(index); } /** * Generates LRUD data from splays for all legs in all series */ public void generateLRUDfromSplays() { CaveConverter.logMessage("Generating LRUD data from splays..."); //Loop through all series ListIterator seriesIterator = survey.listIterator(); while ( seriesIterator.hasNext() ) { SurveySeries series = seriesIterator.next(); //Process series and then recursively call inner series processLRUDfromSplays( series ); } } /** * Process the legs in this series to generate LRUD data from splays, * then loop through all inner series recursively to process them too. * @param series The survey series to process */ private void processLRUDfromSplays( SurveySeries series ) { //Process series and then recursively call inner series series.generateLRUDFromSplays(); //TODO Fix the way the option to remove splays used for LRUD is triggered, and don't do it by default. //series.removeSplaysUsedForLRUD(); //Loop through all inner series ListIterator seriesIterator = series.getInnerSeriesList().listIterator(); while ( seriesIterator.hasNext() ) { SurveySeries innerSeries = seriesIterator.next(); processLRUDfromSplays( innerSeries ); } } } CaveConverter_src/src/footleg/cavesurvey/data/model/SurveySeries.java0000644000000000000000000010027312242116776025152 0ustar rootroot/** * Copyright (C) 2009-2013 Paul Fretwell - aka 'Footleg' (drfootleg@gmail.com) * * This file is part of Cave Converter. * * Cave Converter is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation, either version 3 of the License, or * (at your option) any later version. * * Cave Converter is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with Cave Converter. If not, see . */ package footleg.cavesurvey.data.model; import java.util.ArrayList; import java.util.Date; import java.util.Iterator; import java.util.List; import java.util.ListIterator; import footleg.cavesurvey.cmdline.CaveConverter; import footleg.cavesurvey.tools.UtilityFunctions; /** * This class represents a series of cave survey legs joined together by * sharing stations in common. Branches are allowed, but all legs in a series * are required to have the same instrument calibration values and have the * same date. A series can also contain other series, and details of how they * are linked together. * * A survey series contains the survey legs in the series, the date, * calibrations for instruments (these default to zero if not set) * and magnetic declination (defaults to zero if not set). * A series name is required. Optionally a series can also indicate that stations * used in legs in the series are equivalent (i.e. Represent the same point in * the cave). The series can also contain other series, and details of links * between them. * * @author Footleg * @version 2013.11.17 (ISO 8601 YYYY.MM.DD) * @since 1.6 (The Java version used) * * @to.do * TODO Add support for calibration comments fields * TODO Add support for team fields * TODO Add support for instrument fields */ public class SurveySeries { private String seriesName; private List legs; private List links; private List innerSeries; private int stnRenumberSequence; private List stnRenameCache; private double declination = 0; private double tapeCalibration = 0; private double compassCalibration = 0; private double clinoCalibration = 0; private double clinoCalScaleFactor = 1; private Date surveyDate; private String comment = ""; /** * Constructor */ public SurveySeries( String name ) { super(); init(); this.seriesName = name; } private void init() { legs = new ArrayList(); links = new ArrayList(); innerSeries = new ArrayList(); stnRenameCache = new ArrayList(); stnRenumberSequence = 0; } public void addLeg(SurveyLeg leg) { //Create duplicate of leg to break reference this.legs.add(leg.clone()); } public void addLeg(SurveyLeg leg, int position) { //Create duplicate of leg to break reference this.legs.add( position, leg.clone() ); } public int legCount() { return legs.size(); } /** * Counts the number of survey legs in the series, excluding those with negative length. * Negative length legs are used to hold LRUD data for the terminal station in a chain * of legs, but putting the LRUD data on a dummy leg with a length of -1, but the bearing * and clino to match the preceding leg. * @return Count of all real legs in the series */ public int countSurveyedLegs() { int realLegCount = 0; Iterator legsIterator = legs.listIterator(); while ( legsIterator.hasNext() ) { SurveyLeg leg = legsIterator.next(); if ( leg.getLength() >= 0 ) { realLegCount++; } } return realLegCount; } /** * Assigns a survey station a unique Id for the station name. The survey * station name is mapped to an integer which is assigned as the station id. * This can be used for file formats which do not support text station names. * If the name is a string which represents * a positive integer number already then that number is returned. * For non-numeric station names the name is assigned * a unique negative integer number. Negative numbers are used so they will * not clash with any positive number station names in the series. The negative * station ids also indicate which stations have names which are not numeric. * A map of names to numbers already added to the series is used so that the * same name is not translated into different numbers if passed in more than * once. When all legs have been added to a series, the negative numbered * stations could be assigned new positive number IDs which are not already * used by other stations in the series. * * @param stn The survey station with a name property to be assigned an id */ public void setStationIdFromName( SurveyStation stn ) { int stnId = stnNameToNumber( stn.getName() ); stn.setId( stnId ); } /** * @param stnName * @return a station number linked to the text name for this series */ private int stnNameToNumber( String stnName ) { int stn; try { stn = Integer.parseInt( stnName ); } catch (NumberFormatException nfe) { //Stn name not an integer, so translate name to a negative number stn = this.getNumberToRepresentStnName( stnName ); } return stn; } /** * Returns a negative integer number for a station name string. * * The number will be unique to this series for this station name. * This enables station names to be converted to numbers for file formats * which do not support strings. The name is mapped to a number in this * series by looking up the name in a cache for the series. If the name * is not found in the cache then a new negative number is returned, and * the new name and number mapping is added to the cache for the series. * * @param stnName Name of the survey station to map to a number. * @return Number which can be used to represent this station. */ public int getNumberToRepresentStnName(String stnName) { int mappedStnNum = 0; //Look for station name in cache ListIterator stnCacheIterator = stnRenameCache.listIterator(); int stnIdx = 0; while ( ( mappedStnNum == 0 ) && ( stnCacheIterator.hasNext() ) ) { String cachedName = stnCacheIterator.next(); stnIdx--; if ( stnName.compareToIgnoreCase(cachedName) == 0 ) { //Found matching stn in cache, so get number from index mappedStnNum = stnIdx; } } if ( mappedStnNum == 0 ) { //No match found in cache, so create a new mapping and cache it stnRenumberSequence--; mappedStnNum = stnRenumberSequence; /** * As the mapped stns are added to the cache, the index in the * cache will correspond to the mapped number of the stn: * idx 0 = map -1 * idx 1 = map -2 * etc. */ stnRenameCache.add(stnName); } return mappedStnNum; } public String getMappedStnName(int stn) { //If number is negative then lookup name in map, //otherwise just return station number as the name if ( stn < 0 ) { return stnRenameCache.get( Math.abs(stn) - 1 ); } else { return "" + stn; } } //Apply instrument calibration corrections to all measurements in returned leg public SurveyLeg getLegCorrected(int index) { SurveyLeg originalLeg = legs.get(index); SurveyLeg correctedLeg = originalLeg.clone(); //Over-ride leg length,compass and clino with calibration corrected values correctedLeg.setLength( originalLeg.getLength() - tapeCalibration ); Double compass = originalLeg.getCompass(); if ( compass >= 0 && compass <= 360 ) { //Apply calibration only to valid bearings compass -= (compassCalibration + declination); } correctedLeg.setCompass( compass ); Double clino = originalLeg.getClino(); if ( clino >= -90 && clino <= 180 ) { //Apply calibration only to valid clino clino = (clino - clinoCalibration) * clinoCalScaleFactor; } correctedLeg.setClino( clino ); //Don't correct LRUD using tape calibration as these are assumed to be estimated by eye return correctedLeg; } public SurveyLeg getLegRaw(int index) { return legs.get(index); } public void addSeries(SurveySeries series) { this.innerSeries.add(series); } public int innerSeriesCount() { return innerSeries.size(); } public SurveySeries getInnerSeries(int index) { return innerSeries.get(index); } public List getInnerSeriesList() { return innerSeries; } public SurveySeries findInnerSeriesByName(String name) { SurveySeries match = null; //Look in inner series ListIterator innerIterator = innerSeries.listIterator(); while ( innerIterator.hasNext() ) { SurveySeries innerSeries = innerIterator.next(); if ( innerSeries.getSeriesName().equalsIgnoreCase( name ) ) { //Found series, so return this match = innerSeries; break; } } return match; } public void addLink(String series1Path, SurveyStation stn1, String series2Path, SurveyStation stn2 ) { //Add link to array SeriesLink link = new SeriesLink(series1Path, stn1, series2Path, stn2 ); links.add(link); } public List getLinks() { return links; } public String getSeriesName() { return seriesName; } public void setSeriesName(String seriesName) { this.seriesName = seriesName; } public double getTapeCalibration() { return tapeCalibration; } public void setTapeCalibration(double tapeCalibration) { this.tapeCalibration = tapeCalibration; } public double getDeclination() { return declination; } public void setDeclination(double declination) { this.declination = declination; } public double getCompassCalibration() { return compassCalibration; } public void setCompassCalibration(double compassCalibration) { this.compassCalibration = compassCalibration; } public double getClinoCalibration() { return clinoCalibration; } public double getClinoScaleFactor() { return clinoCalScaleFactor; } public void setClinoCalibration(double clinoCalibration) { this.clinoCalibration = clinoCalibration; this.clinoCalScaleFactor = 1; } public void setClinoCalibration(double clinoCalibration, double clinoCalScaleFactor) { this.clinoCalibration = clinoCalibration; this.clinoCalScaleFactor = clinoCalScaleFactor; } public Date getSurveyDate() { return surveyDate; } public void setSurveyDate(Date surveyDate) { this.surveyDate = surveyDate; } public String getComment() { return comment; } public void setComment(String comment) { this.comment = comment; } public void setCalibrationFromAnotherSeries(SurveySeries series) { setDeclination( series.getDeclination() ); setTapeCalibration( series.getTapeCalibration() ); setCompassCalibration( series.getCompassCalibration() ); setClinoCalibration( series.getClinoCalibration(), series.getClinoScaleFactor() ); } public SurveyLeg removeLeg(int index){ return legs.remove(index); } public void removeSplaysUsedForLRUD() { int i = legs.size() - 1; while ( i >= 0 ) { SurveyLeg leg = legs.get(i); if ( leg.isSplay() && leg.getDown() == -999 ) { //Splay leg used for LRUD generation removeLeg(i); } else { i--; } } } /** * Examines all splay shots from the start station for each leg and generates LRUD data * from them for each leg. The algorithm examines all legs which meet at the station, and * splays which are close to equivalent to any of the legs are not used (to prevent back shots and * splays up side passages which were then surveyed being used to calculate passage dimensions). * Up and down dimensions are calculated from the splay with the greatest vertical length * up or down as appropriate. Splays which are less than 20 degrees from horizontal are * ignored when determining up and down dimensions. Splays with an angle steeper than 70 degrees * from horizontal are excluded from the splays used to determine horizontal passage dimensions. * The passage dimension directions for left and right are calculated along the horizontal * vector bisecting the angle between the forward survey leg, and the most in-line previous * leg arriving at the station. The best matching splay is selected from the suitable * splays by determining which splay gives the greatest distance along the left or right * dimension vector. */ public void generateLRUDFromSplays() { List caveLegs = new ArrayList(); List> splayLegGroups = new ArrayList>(); List> previousLegGroups = new ArrayList>(); //Loop through all legs in series to build arrays of splays and non-splay underground legs ListIterator legsIterator = legs.listIterator(); while ( legsIterator.hasNext() ) { SurveyLeg leg = legsIterator.next(); //Put all non-surface legs into either the cave legs (non-splays) or splay groups lists if ( leg.isSurface() == false ) { if ( leg.isSplay() ) { //Add to splays group identified by station name String stnName = leg.getFromStn().getName(); //Look for a group matching this station int groupIdx = -1; for ( int i = 0; groupIdx < 0 && i < splayLegGroups.size(); i++ ) { if ( splayLegGroups.get(i).get(0).getFromStn().getName().compareTo(stnName) == 0 ) { //Found group, so get index groupIdx = i; } } if ( groupIdx >= 0 ) { //Add to this group splayLegGroups.get(groupIdx).add(leg); } else { //Create new group and add leg to this List splays = new ArrayList(); splays.add(leg); splayLegGroups.add(splays); } } else { //Add to legs array to be processed caveLegs.add(leg); } } } //Loop through all legs non-splay legs to build arrays of legs radiating from the station of each leg for ( int caveLegIdx = 0; caveLegIdx < caveLegs.size(); caveLegIdx++ ) { SurveyLeg leg = caveLegs.get(caveLegIdx); String legStartStn = leg.getFromStn().getName(); //Create list to hold legs radiating out from this leg fromStn List legGrp = new ArrayList(); //Find all other legs which radiate out from the fromStn of this leg for ( int otherLegIdx = 0; otherLegIdx < caveLegs.size(); otherLegIdx++ ) { //Ignore ourself if ( otherLegIdx != caveLegIdx ) { SurveyLeg chkLeg = caveLegs.get(otherLegIdx); if ( legStartStn.compareToIgnoreCase( chkLeg.getToStn().getName() ) == 0 ) { //Add leg to group legGrp.add(chkLeg); } else if ( legStartStn.compareToIgnoreCase( chkLeg.getFromStn().getName() ) == 0 ) { //Reverse leg so it leads to this station and add leg to group SurveyLeg revLeg = chkLeg.clone(); revLeg.reverseDirection(); legGrp.add( revLeg ); } } } //Add group to list for this leg previousLegGroups.add( legGrp ); } //Loop through splay groups and process all the legs with a from stn matching the from stn of the splays in each group ListIterator> spGroupsIter = splayLegGroups.listIterator(); List stnsUsed = new ArrayList(); while ( spGroupsIter.hasNext() ) { List splaysGroup = spGroupsIter.next(); String stnName = splaysGroup.get(0).getFromStn().getName(); ListIterator legsIter = caveLegs.listIterator(); int caveLegIdx = -1; while ( legsIter.hasNext() ) { SurveyLeg leg = legsIter.next(); caveLegIdx++; if ( leg.getFromStn().getName().compareTo(stnName) == 0 ) { //Generate LRUD data for leg, using the splays starting from that leg from station generateLRUDForLeg( leg, splaysGroup, previousLegGroups.get(caveLegIdx) ); //Store station name of splays group that was used stnsUsed.add(stnName); //Remove leg from list now it has been processed legsIter.remove(); //Remove corresponding previous legs group so lists remain in sync previousLegGroups.remove(caveLegIdx); caveLegIdx--; } } } //Build list of splays groups which were not used, as these will be for terminal //stations in branches of the series. These splays will only be from the toStn of a leg. ListIterator> spGroupsIter2 = splayLegGroups.listIterator(); List> unusedSplayGroups = new ArrayList>(); while ( spGroupsIter2.hasNext() ) { List splaysGroup = spGroupsIter2.next(); String stnName = splaysGroup.get(0).getFromStn().getName(); //Check for this group in the used stations list boolean foundMatch = false; ListIterator stnsUsedIter = stnsUsed.listIterator(); while ( stnsUsedIter.hasNext() ) { String grpName = stnsUsedIter.next(); if ( stnName.compareTo( grpName ) == 0 ) { //Set flag to indicate group was used foundMatch = true; break; } } if ( foundMatch == false ) { //Add group to unused groups list unusedSplayGroups.add( splaysGroup ); } } //Loop through unused splays groups and find the leg where the toStn for these //splays occur. Then add a dummy leg for the LRUD data for the toStn. The dummy //leg will have only a fromStn and the LRUD data. ListIterator> spGroupsIter3 = unusedSplayGroups.listIterator(); while ( spGroupsIter3.hasNext() ) { List splaysGroup = spGroupsIter3.next(); String stnName = splaysGroup.get(0).getFromStn().getName(); //Find leg with a matching toStn for these splays for ( int legsIdx = 0; legsIdx < legs.size(); legsIdx++ ) { SurveyLeg leg = legs.get( legsIdx ); if ( ( leg.isSplay() == false ) && ( leg.getToStn() != null ) && ( leg.getToStn().getName().compareTo(stnName) == 0 ) ) { //Create a dummy leg to hold the LRUD for this toStn SurveyLeg newLeg = new SurveyLeg(); newLeg.setFromStn( leg.getToStn() ); newLeg.setLength( -1 ); newLeg.setCompass( leg.getCompass() ); newLeg.setClino( leg.getClino() ); //Check for any other legs terminating at this station, as if there are any then //their bearings should be used to average with the bearing for the leg we are creating here. List otherLegs = new ArrayList(); //Find any other legs which terminate at this station for ( int legsIdx2 = legsIdx + 1; legsIdx2 < legs.size(); legsIdx2++ ) { SurveyLeg chkLeg = legs.get( legsIdx2 ); if ( ( chkLeg.isSplay() == false ) && ( chkLeg.getToStn() != null ) && ( chkLeg.getToStn().getName().compareTo(stnName) == 0 ) ) { //Found another leg to this station, we need to reverse it as //LRUD function takes group of legs from the station SurveyLeg revLeg = chkLeg.clone(); revLeg.reverseDirection(); otherLegs.add(revLeg); } } //Generate LRUD data for leg, using the splays starting from that leg from station generateLRUDForLeg( newLeg, splaysGroup, otherLegs ); //Insert the new LRUD leg into the series after the current leg legs.add(legsIdx + 1, newLeg); //Stop checking series as toStn on terminal leg will only occur once legsIdx = legs.size(); } } } } /** * Generates a Left, Right, Up and Down dimension at the from station for a survey leg * using the splays recorded at that station, and stores them in the leg. * @param leg The survey leg to generate LRUD data for (at the From station) * @param splaysGroup A list of splay legs measured from the From station of the leg * @param otherLegs A list of survey legs arriving at the same station as the From station of the leg */ private void generateLRUDForLeg( SurveyLeg masterLeg, List splayShots, List otherLegs ) { int bearingTolerance = 3; List leftShots = new ArrayList(); List rightShots = new ArrayList(); List upShots = new ArrayList(); List downShots = new ArrayList(); //Determine best previous leg (use leg with closest bearing to onward leg) double bestPrevBearing = 360.0; int bestPrevLegIdx = -1; for ( int i = 0; i < otherLegs.size(); i++ ) { //Looking for bearing closest to master leg bearing double testBearing = UtilityFunctions.bearingDifference( otherLegs.get(i).getCompass(), masterLeg.getCompass() ); if ( testBearing < bestPrevBearing ) { //Found better match, so store value and index bestPrevBearing = testBearing; bestPrevLegIdx = i; } } //If a previous leg was found then calculate average bearing between previous and onward legs double bearing = masterLeg.getCompass(); if ( bestPrevLegIdx >= 0 ) { double[] bearings = new double[2]; bearings[0] = masterLeg.getCompass(); bearings[1] = otherLegs.get(bestPrevLegIdx).getCompass(); bearing = UtilityFunctions.averageCompassBearings(bearings); } //Loop through all the splays and categorise each shot into groups of L,R,U,D for ( int i = 0; i < splayShots.size(); i++ ) { SurveyLeg splayLeg = splayShots.get(i); //Ignore any splays which are along the path of any legs to/from this station //This will remove backshots and splays fired up side passages which were then surveyed //as side passage splays are not going to represent passage dimensions. boolean backShot = false; for ( int olegsIdx = -1; olegsIdx < otherLegs.size(); olegsIdx++ ) { //First check against main leg SurveyLeg testLeg = masterLeg; if (olegsIdx > -1) { //Then loop through other legs reversed (as we need bearing from this station, not to it) testLeg = otherLegs.get(olegsIdx).clone(); testLeg.reverseDirection(); } //Check if splay is equivalent to leg shot double bearingDiff = UtilityFunctions.bearingDifference( testLeg.getCompass(), splayLeg.getCompass() ); if ( bearingDiff < bearingTolerance ) { //Within 3 degrees of leg, so check clino double clinoDiff = UtilityFunctions.bearingDifference( testLeg.getClino(), splayLeg.getClino() ); if ( clinoDiff < bearingTolerance ) { //Within 3 degrees of leg, so check length double lengthDiff = Math.abs( testLeg.getLength() - splayLeg.getLength() ); if ( lengthDiff < 0.2 ) { //Under 20cm difference in length, assume a back shot for a leg backShot = true; CaveConverter.logMessage("Ignoring splay from " + getSeriesName() + "." + splayLeg.getFromStn().getName() + " with length of " + splayLeg.getLength() + " as splay too closely matching a leg and so assumed to be a back-shot."); } } } } if ( backShot == false ) { if ( splayLeg.getClino() > 20 ) { //Up shot upShots.add(splayLeg); } else if ( splayLeg.getClino() < -20 ) { //Down shot downShots.add(splayLeg); } //As well as up or down, some splays may also be the best Left or Right if ( ( splayLeg.getClino() < 70 ) && ( splayLeg.getClino() > -70 ) ) { //Left or right shots (not steeper than 70 deg.) //Determine whether left or right shot double masterBearing = masterLeg.getCompass(); //Normalise bearings to reference of zero degrees for onward leg double splayCorrected = splayLeg.getCompass() - masterBearing; if ( splayCorrected < 0 ) { splayCorrected += 360; } if ( bestPrevLegIdx >= 0 ) { //Two legs to consider double prevLegBearing = otherLegs.get(bestPrevLegIdx).getCompass(); //Convert previous leg bearing to bearing from the station for the splay adjusted with respect to onward leg bearing double prevLegBackBearingCorrected = UtilityFunctions.adjustBearingWithinDegreesRange( 180 + prevLegBearing - masterBearing, 0, 360 ); /* We now have three bearings. The onward leg is adjusted to zero deg. * The back bearing for the previous leg is adjusted relative to the zero bearing of the onward leg. * The splay is also adjusted relative to the zero bearing of the onward leg. * Splays which are aligned with any leg from the station should already have been discarded. * So now we just need to determine if this splay as a left or right splay. */ if ( splayCorrected < prevLegBackBearingCorrected ) { //Right rightShots.add(splayLeg); } else { //Left leftShots.add(splayLeg); } } else { //Only the one leg to consider as first or last leg of chain of legs in series //Angle between splay and leg bearings is now in the range 0-360 deg. if ( ( splayCorrected > bearingTolerance ) || ( splayCorrected > (360 - bearingTolerance) ) ) { if ( splayCorrected < ( 180 - bearingTolerance) ) { //Right rightShots.add(splayLeg); } else if ( splayCorrected > ( 180 + bearingTolerance) ) { //Left leftShots.add(splayLeg); } else { //Splay is within tolerance of back bearing for leg, so too shallow an angle to use for LRUD calc. CaveConverter.logMessage("Ignoring splay from " + getSeriesName() + "." + splayLeg.getFromStn().getName() + " with bearing of " + splayLeg.getCompass() + " as bearing is < " + bearingTolerance + " degrees off back bearing of leg."); } } else { //Splay is within tolerance of bearing for leg, so too shallow an angle to use for LRUD calc. CaveConverter.logMessage("Ignoring splay from " + getSeriesName() + "." + splayLeg.getFromStn().getName() + " with bearing of " + splayLeg.getCompass() + " as bearing is < " + bearingTolerance + " degrees off bearing of leg."); } } } } } //Set flag for this station to say whether all splays should be output boolean keepAllSplays = false; if (( upShots.size() > 1 ) || ( downShots.size() > 1 ) || ( leftShots.size() > 1 ) || ( rightShots.size() > 1 )) { keepAllSplays = true; } //Find best up shot double bestValue = 0.0; int bestIdx = -1; for ( int i = 0; i < upShots.size(); i++ ) { //Looking for highest clino reading if ( upShots.get(i).getClino() > bestValue ) { //Found better match, so store value and index bestValue = upShots.get(i).getClino(); bestIdx = i; } } //Add up shot if found if ( bestIdx >= 0 ) { //Found best up shot masterLeg.setUp( upShots.get(bestIdx).getVerticalLength() ); //Flag splay as used for Up if ( keepAllSplays == false ) { upShots.get(bestIdx).setDown(-999); } } //Find best down shot bestValue = 0.0; bestIdx = -1; for ( int i = 0; i < downShots.size(); i++ ) { //Looking for lowest clino reading if ( downShots.get(i).getClino() < bestValue ) { //Found better match, so store value and index bestValue = downShots.get(i).getClino(); bestIdx = i; } } //Add down shot if found if ( bestIdx >= 0 ) { //Found best down shot masterLeg.setDown( downShots.get(bestIdx).getVerticalLength() ); //Flag splay as used for Down if ( keepAllSplays == false ) { downShots.get(bestIdx).setDown(-999); } } //Find best left shot bestIdx = findBestSplayForHorizontalDimension(leftShots, bearing, true); //Add left shot if found if ( bestIdx >= 0 ) { //Found best left shot double horizontalLength = leftShots.get(bestIdx).getHorizontalLength(); double leftOrthoganal = bearing - 90; if ( leftOrthoganal < 0 ) { leftOrthoganal += 360; } masterLeg.setLeft( extentAlongBearing(leftOrthoganal, horizontalLength, leftShots.get(bestIdx).getCompass() ) ); //Flag splay as used for Left if ( keepAllSplays == false ) { leftShots.get(bestIdx).setDown(-999); } } //Find best right shot bestIdx = findBestSplayForHorizontalDimension(rightShots, bearing, false); //Add right shot if found if ( bestIdx >= 0 ) { //Found best right shot double horizontalLength = rightShots.get(bestIdx).getHorizontalLength(); double rightOrthoganal = bearing + 90; if ( rightOrthoganal >= 360 ) { rightOrthoganal -= 360; } masterLeg.setRight( extentAlongBearing(rightOrthoganal, horizontalLength, rightShots.get(bestIdx).getCompass() ) ); //Flag splay as used for Right if ( keepAllSplays == false ) { rightShots.get(bestIdx).setDown(-999); } } } /** * Determines which of the splays is the best one to use to calculate the horizontal dimension for the * cave passage at this station * * @param splays Array of splay shots to pick the best shot from * @param forwardBearing Bearing from the station to represent the passage direction * @param left Flag to indicate if we want to find the best left shot or best right shot * @return Index of the best matching splay shot from the input array of splays */ private int findBestSplayForHorizontalDimension(List splays, double forwardBearing, boolean left) { //Find best shot (greatest horizontal extent along vector orthogonal to leg bearing) double bestValue = 0.0; int bestIdx = -1; for ( int i = 0; i < splays.size(); i++ ) { //Calculate corrected compass bearing for splay, normalised to a passage trending due North (zero degrees) double shotCorrected = splays.get(i).getCompass() - forwardBearing; if ( shotCorrected < 0 ) { shotCorrected += 360; } //Calculate horizontal extent of leg in direction orthogonal to corrected bearing (left or right) double orthogonal; if ( left ) { orthogonal = 270.0; } else { orthogonal = 90.0; } double horizontalLength = splays.get(i).getHorizontalLength(); double orthogonalExtent = extentAlongBearing(orthogonal, horizontalLength, shotCorrected ); if ( orthogonalExtent > bestValue ) { //Found better match, so store value and index bestValue = orthogonalExtent; bestIdx = i; } } return bestIdx; } /** * Calculates the distance a vector extends along a bearing. Used to work out the distance of the cave wall * for a left or right passage dimension in a given direction from a station for a horizontal length measured * along another bearing * @param bearing The direction we need the distance to the wall for * @param vectorLength The length of the horizontal measurement we have * @param vectorBearing The direction of the horizontal measurement we have * @return The calculated distance to the wall from the station in the direction of the bearing */ private double extentAlongBearing( double bearing, double vectorLength, double vectorBearing) { double bearingDifference = UtilityFunctions.bearingDifference(bearing, vectorBearing); double distance = vectorLength * Math.cos(Math.PI * bearingDifference / 180) ; return distance; //Math.abs(distance); } /** * Reverses the order of all legs in the series, so in a linear chain of stations the last * station is placed first, and the first station is placed last. * Was written to Toporobot export, but then was not needed. Leaving the code here but * commented out as not currently used. public void reverseSeries() { //Loop through all legs, moving each one to the start of the series for (int idx = 0; idx < legs.size(); idx++) { SurveyLeg leg = legs.remove(idx); //Reverse leg direction SurveyStation stn = leg.getFromStn(); leg.setFromStn( leg.getToStn() ); leg.setToStn( stn ); double compass = leg.getCompass(); if ( compass > 180 ) { compass -= 180; } else { compass += 180; } leg.setCompass( compass ); leg.setClino( -leg.getClino() ); //Put leg at start of series legs.add(0, leg); } } */ } CaveConverter_src/src/footleg/cavesurvey/data/model/SurveyStation.java0000644000000000000000000000744312076252374025346 0ustar rootroot/** * Copyright (C) 2009-2013 Paul Fretwell - aka 'Footleg' (drfootleg@gmail.com) * * This file is part of Cave Converter. * * Cave Converter is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation, either version 3 of the License, or * (at your option) any later version. * * Cave Converter is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with Cave Converter. If not, see . */ package footleg.cavesurvey.data.model; /** * Represents a survey station in a cave survey. A station is a specific location in * the cave which might be marked, or a natural feature which can be described in a * comment, or it might be a temporary point which is not marked but was just used * to join two legs during the survey. * * @author Footleg * @version 2012.12.20 (ISO 8601 YYYY.MM.DD) * @since 1.6 (The Java version used) * */ public class SurveyStation { /** * Create station directly specifying an id number * @param id */ public SurveyStation(int id) { super(); this.id = id; } private int id = -1; private String name = ""; private String comment = ""; //FIXED POSITION private FixType fixType = FixType.NONE; private double easting; private double northing; private double altitude; private boolean entrance = false; public enum FixType { NONE (0), GPS (1), OTHER (2); FixType( int type ) { } } public boolean isEntrance() { return ( entrance ); } public void setEntrance(boolean entrance) { this.entrance = entrance; } public boolean isFixed() { return ( fixType != FixType.NONE ); } public FixType getFixType() { return fixType; } public double getEasting() { return easting; } public double getNorthing() { return northing; } public double getAltitude() { return altitude; } /** * Sets a fixed position for the station. * * @param fixType The type of fix (GPS, other) * @param easting Grid position (in metres) of the fix position * @param northing Grid position (in metres) of the fix position * @param altitude Elevation (in metres) of the fix position */ public void setFixed(FixType fixType, double easting, double northing, double altitude) { this.fixType = fixType; this.easting = easting; this.northing = northing; this.altitude = altitude; } public void clearFixedStn() { this.fixType = FixType.NONE; this.easting = 0; this.northing = 0; this.altitude = 0; } public int getId() { return id; } public void setId(int id) { this.id = id; } public String getName() { String stnName = this.name; //Return number as name if no name set if (stnName.length() == 0) { stnName = "" + this.id; } return stnName; } public void setName(String name) { this.name = name; } public String getComment() { return comment; } public void setComment(String comment) { this.comment = comment; } public SurveyStation clone() { SurveyStation clone = new SurveyStation( this.id ); clone.name = this.name; clone.comment = this.comment; clone.entrance = this.entrance; clone.fixType = this.fixType; clone.easting = this.easting; clone.northing = this.northing; clone.altitude = this.altitude; return clone; } } CaveConverter_src/src/footleg/cavesurvey/data/model/Equate.java0000644000000000000000000000541112077054466023727 0ustar rootroot/** * Copyright (C) 2009-2013 Paul Fretwell - aka 'Footleg' (drfootleg@gmail.com) * * This file is part of Cave Converter. * * Cave Converter is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation, either version 3 of the License, or * (at your option) any later version. * * Cave Converter is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with Cave Converter. If not, see . */ package footleg.cavesurvey.data.model; /** * Class to represent an equate between two survey stations in different series * * @author Footleg * @version 2013.01.20 (ISO 8601 YYYY.MM.DD) * @since 1.6 (The Java version used) * */ public class Equate { private String series1; private String stn1; private String series2; private String stn2; /** * @param seriesPrefix1 * @param stnName1 * @param seriesPrefix2 * @param stnName2 */ public Equate(String seriesPrefix1, String stnName1, String seriesPrefix2, String stnName2) { //Need to combine series prefix with station name and then split off //the station name from full series name String[] resplitStnRef1 = combineAndResplitFullStnRef( seriesPrefix1, stnName1 ); String[] resplitStnRef2 = combineAndResplitFullStnRef( seriesPrefix2, stnName2 ); this.series1 = resplitStnRef1[0]; this.stn1 = resplitStnRef1[1]; this.series2 = resplitStnRef2[0]; this.stn2 = resplitStnRef2[1]; } public String getSeries1() { return series1; } public String getStn1() { return stn1; } public String getSeries2() { return series2; } public String getStn2() { return stn2; } private String[] combineAndResplitFullStnRef( String seriesPrefix, String stnName ) { String[] results = new String[2]; //Combine prefix and station name into fully qualified station reference String fullStnRef = seriesPrefix + "." + stnName; //Split series name from station name int pos = fullStnRef.lastIndexOf('.'); if ( pos > 0 ) { //Split at this position results[0] = fullStnRef.substring( 0, pos ); results[1] = fullStnRef.substring( pos + 1 ); } else { //No '.' separator in equate, so throw error throw new RuntimeException( "Equate does not contain a series name and station." ); } return results; } } CaveConverter_src/src/footleg/cavesurvey/data/model/SurveyLeg.java0000644000000000000000000001245412207741614024426 0ustar rootroot/** * Copyright (C) 2009-2013 Paul Fretwell - aka 'Footleg' (drfootleg@gmail.com) * * This file is part of Cave Converter. * * Cave Converter is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation, either version 3 of the License, or * (at your option) any later version. * * Cave Converter is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with Cave Converter. If not, see . */ package footleg.cavesurvey.data.model; /** * Represents a leg in a cave survey. A leg is a set of measurements which define the * location of a point in the cave relative to another point (a survey station). The * second point defined by the leg can be another survey station or may just be a point * in the cave on the wall or used to measure the position of a significant feature. * @author Footleg * @version 2013.08.29 (ISO 8601 YYYY.MM.DD) * @since 1.6 (The Java version used) * * @to.do * TODO Add support for diving data */ public class SurveyLeg implements Comparable { private SurveyStation fromStn; private SurveyStation toStn; private double length = -1; private double compass = -1; private double clino = -99; private String comment = ""; //LRUD applies to fromStn private double left; private double right; private double up; private double down; //Leg flags private boolean splay = false; private boolean duplicate = false; private boolean surface = false; /** * Support sorting by from station name, then to station name */ public int compareTo(SurveyLeg anotherLeg) { SurveyLeg leg = (SurveyLeg)anotherLeg; int fromTest = this.fromStn.getId() - leg.getFromStn().getId(); if ( fromTest == 0 ) { //Same from station, so use toStn to sort return this.toStn.getId() - leg.getToStn().getId(); } else { return fromTest; } } /** * @return A copy of the survey leg */ public SurveyLeg clone() { SurveyLeg clone = new SurveyLeg(); if (fromStn != null){ clone.fromStn = fromStn.clone(); } if (toStn != null){ clone.toStn = toStn.clone(); } clone.length = length; clone.compass = compass; clone.clino = clino; clone.comment = comment; clone.left = left; clone.right = right; clone.up = up; clone.down = down; clone.splay = splay; clone.duplicate = duplicate; clone.surface = surface; return clone; } /** * Reverses the direction of a survey leg */ public void reverseDirection() { //Reverse leg direction SurveyStation stn = getFromStn(); setFromStn( getToStn() ); setToStn( stn ); double compass = getCompass(); if ( compass > 180 ) { compass -= 180; } else { compass += 180; } setCompass( compass ); setClino( -getClino() ); } /** * Calculates the horizontal length of the leg * @return calculated horizontal length */ public double getHorizontalLength() { double hLength = Math.abs( length * Math.cos(Math.PI * clino / 180) ); return hLength; } /** * Calculates the vertical height of the leg * @return calculated vertical height */ public double getVerticalLength() { double vLength = Math.abs( length * Math.sin(Math.PI * clino / 180) ); return vLength; } //Getters and Setters public SurveyStation getFromStn() { return fromStn; } public void setFromStn(SurveyStation fromStn) { this.fromStn = fromStn; } public SurveyStation getToStn() { return toStn; } public void setToStn(SurveyStation toStn) { this.toStn = toStn; } public double getLength() { return length; } public void setLength(double length) { this.length = length; } public double getCompass() { return compass; } public void setCompass(double compass) { this.compass = compass; } public double getClino() { return clino; } public void setClino(double clino) { this.clino = clino; } public double getLeft() { return left; } public void setLeft(double left) { this.left = left; } public double getRight() { return right; } public void setRight(double right) { this.right = right; } public double getUp() { return up; } public void setUp(double up) { this.up = up; } public double getDown() { return down; } public void setDown(double down) { this.down = down; } public String getComment() { return comment; } public void setComment(String comment) { this.comment = comment; } public boolean isSplay() { return splay; } public void setSplay(boolean splay) { this.splay = splay; } public boolean isDuplicate() { return duplicate; } public void setDuplicate(boolean duplicate) { this.duplicate = duplicate; } public boolean isSurface() { return surface; } public void setSurface(boolean surface) { this.surface = surface; } } CaveConverter_src/src/footleg/cavesurvey/data/model/SeriesLink.java0000644000000000000000000000372312100236212024531 0ustar rootroot/** * Copyright (C) 2009-2013 Paul Fretwell - aka 'Footleg' (drfootleg@gmail.com) * * This file is part of Cave Converter. * * Cave Converter is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation, either version 3 of the License, or * (at your option) any later version. * * Cave Converter is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with Cave Converter. If not, see . */ package footleg.cavesurvey.data.model; /** * Represents a link or join between two survey series. The link specifies a series and * station for each of the two series being joined which are the same point in the cave. * The series link lives in a series which both the linked series are inside (or the * same as). * * @author Footleg * @version 2013.01.20 (ISO 8601 YYYY.MM.DD) * @since 1.6 (The Java version used) * */ public class SeriesLink { private String series1; private String series2; private SurveyStation stn2; private SurveyStation stn1; public SeriesLink(String series1, SurveyStation stn1, String series2, SurveyStation stn2) { this.series1 = series1; this.series2 = series2; this.stn1 = stn1; this.stn2 = stn2; } public String getSeries1() { return series1; } public String getSeries2() { return series2; } public SurveyStation getStn2() { return stn2; } public SurveyStation getStn1() { return stn1; } public void setSeries2(String series2) { this.series2 = series2; } } CaveConverter_src/src/footleg/cavesurvey/data/writer/0000755000000000000000000000000012225765120022042 5ustar rootrootCaveConverter_src/src/footleg/cavesurvey/data/writer/CompassWriter.java0000644000000000000000000002510712204413600025502 0ustar rootroot/** * Copyright (C) 2009-2013 Paul Fretwell - aka 'Footleg' (drfootleg@gmail.com) * * This file is part of Cave Converter. * * Cave Converter is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation, either version 3 of the License, or * (at your option) any later version. * * Cave Converter is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with Cave Converter. If not, see . */ package footleg.cavesurvey.data.writer; import java.util.ArrayList; import java.util.List; import footleg.cavesurvey.cmdline.CaveConverter; import footleg.cavesurvey.data.model.CaveSurvey; import footleg.cavesurvey.data.model.SurveyLeg; import footleg.cavesurvey.data.model.SurveySeries; /** * Writer for Compass file format text data. * * @author Footleg * @version 2013.01.20 (ISO 8601 YYYY.MM.DD) * @since 1.6 (The Java version used) */ public class CompassWriter { private final double feetPerMetre = 3.28; private List shortNames = new ArrayList(); /** * Generates Compass format data from a cave survey * * THIS CLASS IS NOT FULLY IMPLEMENTED YET AND WILL NOT GENERATE VALID DATA * * @param surveyData The cave survey model to generate Compass data for * @return Text lines of Compass format data */ public List generateCompassData( CaveSurvey surveyData ) { List outputData = new ArrayList(); String caveName = "cave"; //See if we can determine cave name from series name of first series SurveySeries series1 = surveyData.get(0); if ( series1.getSeriesName().length() > 0 ) { //Check for dot separator int pos = series1.getSeriesName().indexOf('.'); if ( pos > 0) { //Take name before first separator caveName = series1.getSeriesName().substring(0, pos); } else { //Work backwards until first non-numeric character found for ( int nameIdx = series1.getSeriesName().length() - 1; nameIdx > -1; nameIdx-- ) { //Check for non-numerical character int charCode = series1.getSeriesName().charAt(nameIdx); if ( charCode < 48 || charCode > 57 ) { //Take name prior to this point caveName = series1.getSeriesName().substring(0, nameIdx + 1); nameIdx = 0; } } } } //Generate short names for all series for ( int seriesIdx = 0; seriesIdx < surveyData.size(); seriesIdx++ ) { String seriesName = surveyData.get(seriesIdx).getSeriesName(); String reducedName = ""; /* //Remove cave name prefix if found if ( seriesName.substring(0, caveName.length() + 1 ).compareTo( caveName + "." ) == 0 ) { seriesName = seriesName.substring(caveName.length() + 1); } */ //Look for last part of multi-part names String nameLastPart = seriesName; int lstIdx = seriesName.lastIndexOf('.'); if ( lstIdx > -1 && lstIdx < (seriesName.length() - 1) ) { //Take just last part of name nameLastPart = seriesName.substring(lstIdx + 1); } //Remove illegal characters for ( int idx = 0; reducedName.length() < 4 && idx < nameLastPart.length(); idx ++ ) { if ( nameLastPart.charAt(idx) != '.' ) { reducedName += nameLastPart.charAt(idx); } } int trys = 0; while ( trys < 110 ) { trys++; String testName = " "; switch (trys) { case 1: //Try using first 4 chars of name padded with leading spaces testName = reducedName; break; case 2: //Try removing vowels reducedName = ""; for ( int idx = 0; reducedName.length() < 4 && idx < nameLastPart.length(); idx ++ ) { if ( nameLastPart.charAt(idx) != '.' && nameLastPart.charAt(idx) != 'a' && nameLastPart.charAt(idx) != 'e' && nameLastPart.charAt(idx) != 'i' && nameLastPart.charAt(idx) != 'o' && nameLastPart.charAt(idx) != 'u' && nameLastPart.charAt(idx) != 'A' && nameLastPart.charAt(idx) != 'E' && nameLastPart.charAt(idx) != 'I' && nameLastPart.charAt(idx) != 'O' && nameLastPart.charAt(idx) != 'U' ) { reducedName += nameLastPart.charAt(idx); } } testName += reducedName; break; case 3: case 4: case 5: case 6: case 7: case 8: case 9: case 10: case 11: //Try adding increment number to end of 3 char name testName += reducedName.substring(0,3) + ( trys - 2 ); break; default : //Try adding increment number to end of 2 char name testName += reducedName.substring(0,2) + ( trys - 11 ); } //Trim to 4 chars testName = testName.substring( testName.length() - 4 ); //Check if name already used if ( nameAlreadyUsed( testName ) == false ) { //Use this name shortNames.add( testName ); trys = 999; } } //Check name was added if (trys != 999) { RuntimeException ex = new RuntimeException("Failed to generate unique short name for series name: " + seriesName ); throw ex; } } //Loop through all series for ( int seriesIdx = 0; seriesIdx < surveyData.size(); seriesIdx++ ) { SurveySeries series = surveyData.get(seriesIdx); List legsData = new ArrayList(); List fixedStnsData = new ArrayList(); List passageData = new ArrayList(); //Write header lines for series outputData.add( caveName ); outputData.add( "SURVEY NAME: " + series.getSeriesName() ); outputData.add( "SURVEY DATE: " + series.getSurveyDate() ); outputData.add( "SURVEY TEAM: "); outputData.add( " "); outputData.add( "DECLINATION: " + series.getCompassCalibration() + " FORMAT: DMMDLRUDLADN CORRECTIONS: 0.00 0.00 0.00"); outputData.add( " "); outputData.add( "FROM TO LENGTH BEARING INC LEFT UP DOWN RIGHT FLAGS COMMENTS"); /* //Add equates to output for ( int linkIdx = 0; linkIdx < series.getLinks().size(); linkIdx++ ) { SeriesLink link = series.getLinks().get(linkIdx); String equate = "*EQUATE "; if ( link.getLinkedSeries() == -1 ) { //Link to series not in current data file, so create 'false' equate placeholder in file equate = ";" + equate + series.getSeriesName() + "." + link.getLocalStation().getName() + " " + "CAVE" + "." + link.getLocalStation(); } else { equate += series.getSeriesName() + "." + link.getLocalStation().getName() + " " + surveyData.get( link.getLinkedSeries() ).getSeriesName() + "." + link.getLinkedStation().getName(); } outputData.add( equate ); } outputData.add( ""); */ //Start series block outputData.add( "*BEGIN " + series.getSeriesName() ); //TODO Write date if present // if ( series.getSurveyDate().length() > 0 ) { // compassData.add( ";Date " + series.getSurveyDate() ); // } //Write calibration lines if ( series.getTapeCalibration() != 0 ) { outputData.add( "*CALIBRATE tape " + series.getTapeCalibration() ); } if ( series.getCompassCalibration() != 0 ) { outputData.add( "*CALIBRATE declination " + series.getCompassCalibration() ); } if ( series.getClinoCalibration() != 0 ) { outputData.add( "*CALIBRATE clino " + series.getClinoCalibration() ); } outputData.add( ""); //Loop through the series legs writing details of each leg found for ( int legIdx = 0; legIdx < series.legCount(); legIdx++ ) { SurveyLeg leg = series.getLegRaw(legIdx); //Check for valid leg String fromStn = leg.getFromStn().getName(); String toStn = leg.getToStn().getName(); if ( leg.getLength() > 0 ) { //Write leg data legsData.add( fromStn + "\t" + toStn + "\t" + CaveConverter.padNumber( leg.getLength(), 2, 5 ) + "\t" + CaveConverter.padNumber( leg.getCompass(), 2, 6 ) + "\t" + CaveConverter.padNumber( leg.getClino(), 2, 6 ) + "\t"); } else { //Zero length leg //Get to stn name if there is one if ( leg.isSplay() == false ) { //Valid leg, so write as equate legsData.add( "*EQUATE " + fromStn + "\t" + toStn ); } } //Add FIXed points to fixed stns block for series // if (leg.hasFixedStn() == true) { // String fixedStnLine = "*FIX "; // if ( leg.isFromStnFixed() == true ) { // fixedStnLine += fromStn; // } // else { // fixedStnLine += getActualStationName( series, leg.getToStn() ); // } // fixedStnLine += "\t" + leg.getEasting() + "\t" + leg.getNorthing() + "\t" + // leg.getAltitude(); // fixedStnsData.add( fixedStnLine ); // } //Add LRUD to passages block for series if ( leg.getLeft() + leg.getRight() + leg.getUp() + leg.getDown() > 0.0 ) { passageData.add( fromStn + "\t" + leg.getLeft() + "\t" + leg.getRight() + "\t" + leg.getUp() + "\t" + leg.getDown() + "\t" ); } } //Write fixes data block if ( fixedStnsData.size() > 0 ) { outputData.addAll( fixedStnsData ); } //Write legs data block outputData.addAll( legsData ); //Write passage data block if ( passageData.size() > 0 ) { outputData.add( ""); outputData.add( "*data passage station left right up down"); outputData.addAll( passageData ); } //Close the series outputData.add( "*END " + series.getSeriesName() + "\n"); } //Close the cave name outputData.add( "*END " + caveName ); return outputData; } /** * Looks up short series name for series from array of names created previously * @param seriesIdx * @return short (4 character) name for series */ private String getShortSeriesName( int seriesIdx ) { return shortNames.get(seriesIdx); } /** * Looks for short series name in array of names used * @param name * @return true if name has already been used for another series */ private boolean nameAlreadyUsed( String name ) { boolean found = false; for ( int i = 0; i < shortNames.size(); i++ ) { if ( shortNames.get(i).compareToIgnoreCase( name ) == 0 ) { found = true; i = shortNames.size(); } } return found; } } CaveConverter_src/src/footleg/cavesurvey/data/writer/TopoRobotWriter.java0000644000000000000000000005037512217351332026040 0ustar rootroot/** * Copyright (C) 2009-2013 Paul Fretwell - aka 'Footleg' (drfootleg@gmail.com) * * This file is part of Cave Converter. * * Cave Converter is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation, either version 3 of the License, or * (at your option) any later version. * * Cave Converter is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with Cave Converter. If not, see . */ package footleg.cavesurvey.data.writer; import java.util.ArrayList; import java.util.Date; import java.util.List; import java.util.ListIterator; import footleg.cavesurvey.cmdline.CaveConverter; import footleg.cavesurvey.data.model.CaveSurvey; import footleg.cavesurvey.data.model.SeriesLink; import footleg.cavesurvey.data.model.SurveyLeg; import footleg.cavesurvey.data.model.SurveySeries; import footleg.cavesurvey.tools.UtilityFunctions; /** * Writer for TopoRobot file format text data. * * @author Footleg * @version 2013.09.21 (ISO 8601 YYYY.MM.DD) * @since 1.6 (The Java version used) */ public class TopoRobotWriter { private List terminalLRUDCache; /** * Generates TopoRobot format data from a cave survey * * @param surveyData The cave survey model to generate TopoRobot data for * @param defaultDate The date to put in the data header * @param outputSplays Flag to switch on/off whether splay legs are included in the output * @return Text lines of TopoRobot format data */ public List generateToporobotData( CaveSurvey surveyData, Date defaultDate, boolean outputSplays ) { List outputData = new ArrayList(); terminalLRUDCache = new ArrayList(); /** * Pre-process series data to make it suitable for toporobot export. Toporobot only supports * numeric station names, and linear chains of survey legs (i.e. No branching in a survey * series). To convert the data to a suitable structure from a hierarchical nested set of * potentially branched survey series the following processes are applied to the data. * 1) Create a new list of survey series where no series contains any inner series. All * series are named using the fully expanded original hierarchical name for the series. * All links between series are stored in one of the series involved in the link rather * than at a higher level outside the series. * 2) All branches in the resulting series are removed by spliting each series containing * a branch at the junction. * 3) Merge series which are joined end to end into a single series to minimise the number * of linear series in the survey. * 4) Split series which are not linked by their start stations at the linking station so * that all series links use only the first station to link to another series. * * The result of this is that the naming of series will no longer reflect the original * naming of series form the input survey, and stations will be renumbered. * * TODO This writer has some issues. Some surveys with multiple loops can get split into * two parts which are not linked to each other. Some links have comments indicating the * stations are id -1 and some series report they are not linked to any others. */ CaveConverter.logMessage("Generating Toporobot format data..."); //Convert all series including nested series into one big series with full qualified names in links cache SurveySeries rawData = convertToSingleSeries(surveyData, outputSplays); //Convert this to linear series SurveySeries processedSurveyData = UtilityFunctions.convertToLinearSeries( rawData ); List preferredLinkSeriesCache = new ArrayList(); //Generate formatted date and time strings for headers String dateFormat = "yy/MM/dd HH:mm:ss"; String dateTime = UtilityFunctions.dateToString(defaultDate, dateFormat); String todaysDate = dateTime.substring(6, 8) + '/' + dateTime.substring(3, 5) + '/' + dateTime.substring(0, 2); //Create file header outputData.add( " -6 1 1 1 1 Cave Name"); outputData.add( " -5 1 1 1 1 0.00 0.00 0.00 1 0"); outputData.add( " -4 1 1 1 1 " + dateTime + " CaveConverter"); outputData.add( " -3 1 1 1 1"); outputData.add( " -2 1 1 1 1 " + todaysDate + " Converted Data 0 0.00 0 1"); outputData.add( " -1 1 1 1 1 360.00 360.00 0.05 1.00 1.00 100.00 0.00"); //Generate data lines from survey data List links = processedSurveyData.getLinks(); ListIterator seriesItr = processedSurveyData.getInnerSeriesList().listIterator(); int seriesNo = 0; //1 based index of stations, for writing directly into file while ( seriesItr.hasNext() ) { SurveySeries series = seriesItr.next(); seriesNo++; //Generate series header outputData.add( CaveConverter.padNumber(seriesNo,6) + " -2 1 1 1 Series " + series.getSeriesName() ); //Initialise links data line String linkLine = CaveConverter.padNumber(seriesNo,6) + " -1 1 1 1"; //Initialise link from ourself to ourself, as that is how toborobot represents unlinked series int linkSeries1 = seriesNo; int linkStn1 = 0; int linkSeries2 = seriesNo; int linkStn2 = series.legCount(); boolean foundFirstLink = false; //Now find the links to any series this one starts or ends at a connection with //Loop through links looking for links to start stn or end stn of this series for (int i = 0; i < links.size(); i++ ) { //Check whether this link is to this series if ( series.getSeriesName() == links.get(i).getSeries1() ) { //Found link to our series, check if it is to start or end of this series int linkType = 0; //0=not to this series, 1=to start of this series, 2=to end of this series if ( series.getLegRaw(0).getFromStn().getId() == links.get(i).getStn1().getId() ) { linkType = 1; } else if ( series.getLegRaw( series.legCount() - 1 ).getToStn().getId() == links.get(i).getStn1().getId() ) { linkType = 2; } if ( linkType > 0 ) { //Found a link to this series, so determine the index of the linked series int linkSeriesIdx = -1; int j = 0; String series2Name = links.get(i).getSeries2(); while ( linkSeriesIdx < 0 && j < processedSurveyData.getInnerSeriesList().size() ) { if ( processedSurveyData.getInnerSeriesList().get(j).getSeriesName() == series2Name ) { linkSeriesIdx = j; } j++; } if ( linkSeriesIdx >= 0 ) { //Found the index of the parent series, now need to find the index of the link station //Stn number should be 1 based index of station in series, //not the actual value stored in that series int idx = 0; int linkStnIdx = -1; int linkStnId = links.get(i).getStn2().getId(); /* * Cache series index as preferred for this stn number if not already found. * This is so that where multiple series all branch off from the same point, * all the links are to the same one of these series. Otherwise we can end * up with multiple sets of series linked to the others in the group, but * the groups not connected to each other. This preferred series cache * ensures that the first series found is used for all other links to * series starting at this station. */ int preferredLinkSeries = 0 ; //Look for this stn num in cache for ( int k = 0; k < preferredLinkSeriesCache.size(); k++ ) { if ( preferredLinkSeriesCache.get(k)[0] == linkStnId ) { //Found, so get preferred series from cache preferredLinkSeries = preferredLinkSeriesCache.get(k)[1]; k = preferredLinkSeriesCache.size(); } } //If not found in cache then cache this series as the preferred one if ( preferredLinkSeries == 0 ) { int[] rec = new int[2]; rec[0] = linkStnId; rec[1] = linkSeriesIdx; preferredLinkSeriesCache.add(rec); } //Get link series SurveySeries linkSeries; if ( ( preferredLinkSeries > 0 ) && ( preferredLinkSeries != seriesNo ) ) { //Use preferred series instead of the given link linkSeries = processedSurveyData.getInnerSeries(preferredLinkSeries); linkSeriesIdx = preferredLinkSeries; } else { linkSeries = processedSurveyData.getInnerSeries(linkSeriesIdx); } while ( linkStnIdx == -1) { //Check if stn name matches our link name if ( idx >= linkSeries.legCount() ) { //Check if link is to final stn if ( linkSeries.getLegRaw(idx-1).getToStn().getId() == linkStnId ) { //Found match linkStnIdx = idx; } else { //No matches, set value to cause loop to exit linkStnIdx = -2; } } else if ( linkSeries.getLegRaw(idx).getFromStn().getId() == linkStnId ) { //Found match linkStnIdx = idx; } else { //Keep looking idx++; } } //We have now identified the series number and station number for the link int linkSeriesNum = linkSeriesIdx + 1; //Set link to start or end station if ( linkType == 1 ) { linkSeries1 = linkSeriesNum; linkStn1 = linkStnIdx; if ( foundFirstLink == false ) { //This is first link for this series, so set flag foundFirstLink = true; } else { //This is 2nd link to this series, so stop looking for more break; } } else { linkSeries2 = linkSeriesNum; linkStn2 = linkStnIdx; if ( foundFirstLink == false ) { //This is first link for this series, so set flag foundFirstLink = true; } else { //This is 2nd link to this series, so stop looking for more break; } } } } } } //Add link details to data line: linked series no, linked station index, this series number, first station (0) linkLine += CaveConverter.padNumber(linkSeries1,8) + CaveConverter.padNumber(linkStn1,8); linkLine += CaveConverter.padNumber(linkSeries2,8) + CaveConverter.padNumber(linkStn2,8); //Finish line linkLine += CaveConverter.padNumber(series.legCount(),8) + " 3 0"; outputData.add( linkLine ); //First line is LRUD for first station String blankLRUD = " 0.00 0.00 0.00 0.00"; String lrud = blankLRUD; if ( series.legCount() > 0 ) { lrud = lrudForLeg( series.getLegCorrected( 0 ) ); } outputData.add( CaveConverter.padNumber(seriesNo,6) + CaveConverter.padNumber(0,6) + " 1 1 1" + " 0.00 0.00 0.00" + lrud); //Loop through legs in series to write out remaining stations for (int legIdx = 0; legIdx < series.legCount(); legIdx++ ) { SurveyLeg leg = series.getLegCorrected(legIdx); //Use lrud from next leg as toporobot puts lrud on 'to' station of each leg lrud = blankLRUD; if ( series.legCount() > legIdx + 1 ) { lrud = lrudForLeg( series.getLegCorrected( legIdx + 1 ) ); } else if ( series.legCount() == legIdx + 1 ) { //Last leg in chain, so check for cached LRUD data for toStn ListIterator legIter = terminalLRUDCache.listIterator(); while (legIter.hasNext() ) { SurveyLeg lrudLeg = legIter.next(); if ( lrudLeg.getFromStn().getName().compareTo( leg.getToStn().getName() ) == 0 ) { //Found dummy leg with terminal station lrud data lrud = lrudForLeg( lrudLeg ); //Remove from iterator and exit loop legIter.remove(); break; } } } String dataLine = CaveConverter.padNumber(seriesNo,6) + CaveConverter.padNumber(legIdx+1,6) + " 1 1 1" + CaveConverter.padNumber(leg.getLength(),2,8) + CaveConverter.padNumber(leg.getCompass(),2,8) + CaveConverter.padNumber(leg.getClino(),2,8) + lrud; outputData.add( dataLine ); } } return outputData; } private String lrudForLeg(SurveyLeg leg) { double down = leg.getDown(); if ( down < 0 ) { down = 0.0; } return CaveConverter.padNumber(leg.getLeft(),2,8) + CaveConverter.padNumber(leg.getRight(),2,8) + CaveConverter.padNumber(leg.getUp(),2,8) + CaveConverter.padNumber(down,2,8); } private void addLegsToMasterSeries( SurveySeries series, SurveySeries rawData, String parentSeriesPrefix, List> linkCache, boolean outputSplays ) { //Copy legs from this series into master series, translating using links cache when matching for ( int j = 0; j < series.legCount(); j++ ) { SurveyLeg leg = series.getLegCorrected(j); //Cache LRUD data from legs with negative length as these are to provide LRUD data on final station in a series if ( leg.getLength() < 0 ) { // double[] lrud = new double[5]; // lrud[0] = leg.getFromStn().getId(); // lrud[1] = leg.getLeft(); // lrud[2] = leg.getRight(); // lrud[3] = leg.getUp(); // lrud[4] = leg.getDown(); //Get fully expanded station name for from stn and set as stn name in cache String fromStn = parentSeriesPrefix + "." + series.getSeriesName() + "." + leg.getFromStn().getName(); leg.getFromStn().setName(fromStn); terminalLRUDCache.add(leg); } else { //Ignore splay legs if output splays option is set to false if ( ( ( outputSplays == false ) && leg.isSplay() ) == false ) { //Get fully expanded station names for leg String fromStn = parentSeriesPrefix + "." + series.getSeriesName() + "." + leg.getFromStn().getName(); String toStn = parentSeriesPrefix + "." + series.getSeriesName() + "." + leg.getToStn().getName(); /* * Check for these stn names in links cache and if found, use name of first equivalent station * so no links are required because all stations will be linked via a common named station */ for ( int k = 0; k < linkCache.size(); k++ ) { List rec = linkCache.get(k); for ( int m = 1; m < rec.size(); m++ ) { if ( rec.get(m).compareTo( fromStn ) == 0 ) { fromStn = rec.get(0); } else if ( rec.get(m).compareTo( toStn ) == 0 ) { toStn = rec.get(0); } } } //Clone leg and create new stn numbers from stn full names SurveyLeg newLeg = leg.clone(); newLeg.setFromStn( UtilityFunctions.createStationFromNameForSeries(fromStn, rawData) ); newLeg.setToStn(UtilityFunctions.createStationFromNameForSeries(toStn, rawData) ); //Add to master raw survey series rawData.addLeg(newLeg); } } } } private void addLinksToCache(SurveySeries series, String parentSeriesPrefix, List> linkCache ){ String seriesFullName = parentSeriesPrefix + "." + series.getSeriesName(); List links = series.getLinks(); for ( int j = 0; j < links.size(); j++ ) { //Get fully expanded linked station pair String linkSeries1 = ""; if ( links.get(j).getSeries1().length() > 0 ) { linkSeries1 = "." + links.get(j).getSeries1(); } String stn1 = seriesFullName + linkSeries1 + "." + links.get(j).getStn1().getName(); String linkSeries2 = ""; if ( links.get(j).getSeries2().length() > 0 ) { linkSeries2 = "." + links.get(j).getSeries2(); } String stn2 = seriesFullName + linkSeries2 + "." + links.get(j).getStn2().getName(); /** * Need one station name to always take precedence in all links * so check if either of these stations is already in the cache, * and if so add other station to the existing entry */ boolean newRec = true; for ( int k = 0; k < linkCache.size(); k++ ) { List rec = linkCache.get(k); for ( int m = 0; m < rec.size(); m++ ) { if ( rec.get(m).equalsIgnoreCase( stn1 ) ) { newRec = false; //Add other stn to this list rec.add( stn2 ); m = rec.size(); } else if ( rec.get(m).equalsIgnoreCase( stn2 ) ) { newRec = false; //Add other stn to this list rec.add( stn1 ); m = rec.size(); } } } if ( newRec ) { //Cache this link as a new record List rec = new ArrayList(); rec.add(stn1); rec.add(stn2); linkCache.add(rec); } } } private void processSeriesLinks(SurveySeries series, String masterSeriesNamePrefix, List> linkCache){ //Process links for this series CaveConverter.logMessage("Processing links from series: " + series.getSeriesName() ); addLinksToCache( series, masterSeriesNamePrefix, linkCache ); //Process any inner series String seriesNamePrefix = masterSeriesNamePrefix + "." + series.getSeriesName(); ListIterator iterator = series.getInnerSeriesList().listIterator(); while (iterator.hasNext() ) { SurveySeries innerSeries = iterator.next(); //Process any inner series processSeriesLinks(innerSeries, seriesNamePrefix, linkCache); } } private void processSeriesLegs(SurveySeries series, SurveySeries masterSeries, String masterSeriesNamePrefix, List> linkCache, boolean outputSplays ){ //Process legs from this series CaveConverter.logMessage("Processing legs from series: " + series.getSeriesName() ); addLegsToMasterSeries( series, masterSeries, masterSeriesNamePrefix, linkCache, outputSplays ); //Process any inner series String seriesNamePrefix = masterSeriesNamePrefix + "." + series.getSeriesName(); ListIterator iterator = series.getInnerSeriesList().listIterator(); while (iterator.hasNext() ) { SurveySeries innerSeries = iterator.next(); //Process any inner series processSeriesLegs(innerSeries, masterSeries, seriesNamePrefix, linkCache, outputSplays); } } /** * Creates one master survey series from a cave survey * * @param surveyData The cave survey model to convert to a single series * @return The single survey series representing the cave survey */ public SurveySeries convertToSingleSeries( CaveSurvey surveyData, boolean outputSplays ) { CaveConverter.logMessage("Flattening survey series heirarchy..."); SurveySeries rawData = new SurveySeries("root"); List> linkCache = new ArrayList>(); String seriesNamePrefix = rawData.getSeriesName(); //Create cache of links from all series ListIterator iterator = surveyData.listIterator(); while (iterator.hasNext() ) { SurveySeries series = iterator.next(); //Process links from this series processSeriesLinks(series, seriesNamePrefix, linkCache); } //Process legs from all series once all series links have been handled ListIterator iterator2 = surveyData.listIterator(); while (iterator2.hasNext() ) { SurveySeries series = iterator2.next(); //Process legs from this series processSeriesLegs(series, rawData, seriesNamePrefix, linkCache, outputSplays); } /* * At this stage the legs are all in one master series, and the station names have been set so * that any links are implicit due to having mapped all equivalent stations to the same station names. */ //Debug dump links cache for ( int k = 0; k < linkCache.size(); k++ ) { List rec = linkCache.get(k); String msg = "Linked"; for ( int m = 0; m < rec.size(); m++ ) { msg += ":" + rec.get(m); } CaveConverter.logMessage(msg); } return rawData; } } CaveConverter_src/src/footleg/cavesurvey/data/writer/SurvexWriter.java0000644000000000000000000005635712242133266025415 0ustar rootroot/** * Copyright (C) 2009-2013 Paul Fretwell - aka 'Footleg' (drfootleg@gmail.com) * * This file is part of Cave Converter. * * Cave Converter is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation, either version 3 of the License, or * (at your option) any later version. * * Cave Converter is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with Cave Converter. If not, see . */ package footleg.cavesurvey.data.writer; import java.util.ArrayList; import java.util.List; import java.util.ListIterator; import footleg.cavesurvey.cmdline.CaveConverter; import footleg.cavesurvey.data.model.CaveSurvey; import footleg.cavesurvey.data.model.SeriesLink; import footleg.cavesurvey.data.model.SurveyLeg; import footleg.cavesurvey.data.model.SurveySeries; import footleg.cavesurvey.data.model.SurveyStation; import footleg.cavesurvey.tools.UtilityFunctions; /** * Writer for Survex file format text data. * * @author Footleg * @version 2013.11.17 (ISO 8601 YYYY.MM.DD) * @since 1.6 (The Java version used) * * @to.do * TODO Output entrance flags * TODO Output fix flags * TODO Output calibration comments fields * TODO Output team fields * TODO Output instrument fields * TODO Support option to output multiple files using includes and equates in master file and one series per file in child files */ public class SurvexWriter { /** * Generates Survex format data from a cave survey * * @param surveyData The cave survey model to generate Survex data for * @param outputSplays Flag to switch on/off whether splay legs are included in the output * @return Text lines of Survex format data */ public List generateSurvexData( CaveSurvey surveyData, boolean outputSplays ) { List outputData = new ArrayList(); CaveConverter.logMessage("Generating Survex format data..."); //Create dummy parent series to pass in neutral calibration settings for top level series SurveySeries parentSeries = new SurveySeries("parent"); //Loop through all series ListIterator seriesIterator = surveyData.listIterator(); while ( seriesIterator.hasNext() ) { SurveySeries series = seriesIterator.next(); outputData.addAll( generateSurvexDataSeries( series, parentSeries, outputSplays ) ); } return outputData; } /** * Generates Survex format data for a survey series * * @param series Survey series to generate Survex format data from * @param parentSeries Survey series which is the parent of the series being passed in (used for calibrations) * @return Text lines for a Survex format series data block */ private List generateSurvexDataSeries( SurveySeries series, SurveySeries parentSeries, boolean outputSplays ) { List outputData = new ArrayList(); List legsData = new ArrayList(); List fixedStnsData = new ArrayList(); //List of passage data blocks. Each block is a child list of the station name and the LRUD data line. List> passageData = new ArrayList>(); boolean duplicateFlagOn = false; boolean surfaceFlagOn = false; boolean splayFlagOn = false; int splayNameSequence = 0; //Start series block outputData.add( "*BEGIN " + series.getSeriesName() ); //Write comment if present if ( series.getComment().length() > 0 ) { String[] dataItems = UtilityFunctions.parseTripComment( series.getComment() ); for (String line : dataItems) { outputData.add( ";" + line ); } outputData.add( "" ); } //Write date if present if ( series.getSurveyDate() != null ) { outputData.add( "*DATE " + UtilityFunctions.dateToString( series.getSurveyDate(), UtilityFunctions.SURVEXDATE_FORMAT) ); } //Write calibration lines if different to parent series if ( series.getDeclination() != parentSeries.getDeclination() ) { outputData.add( "*CALIBRATE declination " + series.getDeclination() ); } if ( series.getTapeCalibration() != parentSeries.getTapeCalibration() ) { outputData.add( "*CALIBRATE tape " + series.getTapeCalibration() ); } if ( series.getCompassCalibration() != parentSeries.getCompassCalibration() ) { outputData.add( "*CALIBRATE compass " + series.getCompassCalibration() ); } if ( series.getClinoCalibration() != parentSeries.getClinoCalibration() ) { outputData.add( "*CALIBRATE clino " + series.getClinoCalibration() ); } outputData.add( "" ); //Add equates to output ListIterator linksIterator = series.getLinks().listIterator(); while ( linksIterator.hasNext() ) { SeriesLink link = linksIterator.next(); String equate = "*EQUATE "; String series1Prefix = ""; String series2Prefix = ""; if ( link.getSeries1().length() > 0 ) { series1Prefix = link.getSeries1() + "."; } if ( link.getSeries2().length() > 0 ) { series2Prefix = link.getSeries2() + "."; } equate += series1Prefix + link.getStn1().getName() + " " + series2Prefix + link.getStn2().getName(); outputData.add( equate ); } outputData.add( ""); //Loop through the series legs writing details of each leg found for ( int legIdx = 0; legIdx < series.legCount(); legIdx++ ) { SurveyLeg leg = series.getLegRaw(legIdx); String fromStn = leg.getFromStn().getName(); /* Check for valid leg * Final 'leg' in a series can be just a 'from station' with LRUD data on it, * so only write leg data if a 'to station' exists or leg is a splay */ if ( ( leg.isSplay() ) || ( leg.getToStn() != null ) ) { String toStn; if ( leg.getToStn() == null ) { //Splay leg without a 'to' station. Create a station name from the leg from station toStn = leg.getFromStn().getName() + "-" + splayNameSequence++; } else { toStn = leg.getToStn().getName(); } if ( leg.getLength() > 0 ) { //Determine if any flags need setting String flagsSetting = ""; //Determine whether to set or clear duplicate flag if ( ( leg.isDuplicate() ) && duplicateFlagOn == false ) { flagsSetting += " DUPLICATE"; duplicateFlagOn = true; } else if ( ( leg.isDuplicate() == false ) && duplicateFlagOn ) { flagsSetting += " NOT DUPLICATE"; duplicateFlagOn = false; } //Determine whether to set or clear surface flag if ( ( leg.isSurface() ) && surfaceFlagOn == false ) { flagsSetting += " SURFACE"; surfaceFlagOn = true; } else if ( ( leg.isSurface() == false ) && surfaceFlagOn ) { flagsSetting += " NOT SURFACE"; surfaceFlagOn = false; } if ( outputSplays ) { //Determine whether to set or clear splays flag if ( ( leg.isSplay() ) && splayFlagOn == false ) { flagsSetting += " SPLAY"; splayFlagOn = true; } else if ( ( leg.isSplay() == false ) && splayFlagOn ) { flagsSetting += " NOT SPLAY"; splayFlagOn = false; } } //Write flags line if any flags changed if ( flagsSetting.length() > 0 ) { legsData.add( "*FLAGS" + flagsSetting); } if ( ( ( outputSplays == false ) && leg.isSplay() ) == false ) { //Write leg data String legLine = fromStn + "\t" + toStn + "\t" + CaveConverter.padNumber( leg.getLength(), 2, 5 ) + "\t" + CaveConverter.padNumber( leg.getCompass(), 2, 6 ) + "\t" + CaveConverter.padNumber( leg.getClino(), 2, 6 ); if ( leg.getComment().length() > 0 ) { legLine += "\t;" + leg.getComment(); } legsData.add( legLine ); } } else { //Zero length leg if ( leg.isSplay() == false ) { //Valid leg, so write as equate legsData.add( "*EQUATE " + fromStn + "\t" + toStn ); } } //Add FIXed points to fixed stns block for series SurveyStation stn = leg.getFromStn(); for (int i=0; i < 2; i++) { //Loop twice, to process from and to stations if ( stn.isFixed() == true ) { String fixedStnLine = "*FIX " + stn.getName(); fixedStnLine += "\t" + stn.getEasting() + "\t" + stn.getNorthing() + "\t" + stn.getAltitude(); fixedStnsData.add( fixedStnLine ); } //After first pass using FromStn, get toStn if there is one for second pass if ( leg.getToStn() == null ) { break; } stn = leg.getToStn(); } } //Process LRUD data for non-splay, non-surface legs, including legs with no LRUD data. if ( ( leg.isSplay() == false ) && ( leg.isSurface() == false ) ) { //Start new passage data block if leg does not connect the fromStn containing the LRUD data //to the start or end of another passage data block in the file boolean newBlock = false; int activeBlockIdx = passageData.size() - 1; //Initialise to last block in list boolean addAtFront = false; if ( passageData.size() == 0 ) { //Create first block for first lrud station in series newBlock = true; } else { //Check if station linked to a station at either end of an existing block /* We are looking for the toStn at either end of an existing block */ boolean foundExistingBlock = false; for (int idx = 0; idx < passageData.size(); idx++ ) { List block = passageData.get(idx); if ( leg.getToStn() != null ) { //Check if this block starts with the toStn for the leg if ( ( block.size() == 1 ) && ( block.get(0)[0].equals( leg.getToStn().getName() ) ) ) { //Leg toStn matches only station in block, so leg could go before or after this LRUD //We need to know which direction the leg for the existing LRUD measurements was in if ( block.get(0)[2].equals( leg.getFromStn().getName() ) ) { //This leg follows the one previously added to this block, so add at end activeBlockIdx = idx; addAtFront = false; foundExistingBlock = true; } else { //This leg does NOT follow the one which started this block, so it must go before it activeBlockIdx = idx; addAtFront = true; foundExistingBlock = true; } } else if ( block.get(block.size() - 1)[0].equals( leg.getToStn().getName() ) ) { //Matching toStn at end, so add LRUD to end of this block activeBlockIdx = idx; addAtFront = false; foundExistingBlock = true; } else if ( block.get(0)[0].equals( leg.getToStn().getName() ) ) { //Matching toStn at start, so add LRUD to start of this block activeBlockIdx = idx; addAtFront = true; foundExistingBlock = true; } } if ( foundExistingBlock == false ) { //Need to find another leg which has a toStn matching the fromStn of this leg for (int idx2 = 0; idx2 < series.legCount(); idx2++ ) { SurveyLeg chkLeg = series.getLegRaw(idx2); if ( ( chkLeg.getToStn() != null ) && ( chkLeg.getToStn().getName().equals(leg.getFromStn().getName() ) ) ) { //Found a leg which precedes the leg we are adding LRUD data from. //Check if the fromStn of this preceding leg is the last stn in the block if ( block.get(block.size() - 1)[0].equals( chkLeg.getFromStn().getName() ) ) { //Matching fromStn for previous leg at end or block, so add LRUD to end of this block activeBlockIdx = idx; addAtFront = false; foundExistingBlock = true; } // This last case turns out not to be needed as it is generally better to start a new passage data block in this case. // else { // //Check if the preceding leg starts this block // //(but is not already covered going down this block) // int blockIdx2 = 1; // if ( block.size() == 1 ) { // blockIdx2 = 0; // } // if ( ( block.get(0)[0].equals( chkLeg.getFromStn().getName() ) ) // && ( block.get(blockIdx2)[0].equals( chkLeg.getToStn().getName() ) == false ) ) { // //Matching toStn at start, so add LRUD to start of this block // activeBlockIdx = idx; // addAtFront = true; // foundExistingBlock = true; // CaveConverter.logMessage("Stn " + leg.getFromStn().getName() + " fromStn for leg matched toStn of leg " + // chkLeg.getFromStn().getName() + "-" + chkLeg.getToStn().getName() + // " where fromStn was at start of PD block but leg is not covered in this block"); // } // } } } } if ( foundExistingBlock ) { break; } } if ( foundExistingBlock == false ) { //Create new block for station as it is not connected to any other existing block newBlock = true; } } if (newBlock) { passageData.add( new ArrayList() ); activeBlockIdx = passageData.size() - 1; } String[] lrudLine = createLrudLine( leg ); if ( addAtFront ) { passageData.get(activeBlockIdx).add(0, lrudLine); } else { passageData.get(activeBlockIdx).add( lrudLine ); } } } //Add missing toStns from legs which close loops addMissingPassageDataAtLoopClosureStations( series, passageData ); //Finally, replace LRUD values with those from the actual legs matching the pairs of stations //for the current and next line in each block and remove single station blocks reprocessPassageDataBlocks( series, passageData ); //Write fixes data block if ( fixedStnsData.size() > 0 ) { outputData.addAll( fixedStnsData ); } //Write legs data block outputData.addAll( legsData ); //Turn off splays flag if on if ( splayFlagOn ) { outputData.add( "*FLAGS NOT SPLAY"); splayFlagOn = false; } //Write passage data block if ( passageData.size() > 0 ) { outputData.add( ""); //outputData.addAll( passageData ); ListIterator> blocksIter = passageData.listIterator(); while ( blocksIter.hasNext() ) { List block = blocksIter.next(); outputData.add("*data passage station left right up down"); ListIterator blockIter = block.listIterator(); while ( blockIter.hasNext() ) { String[] line = blockIter.next(); outputData.add( line[0] + "\t" + line[1] ); } } } //Loop through inner series ListIterator seriesIterator = series.getInnerSeriesList().listIterator(); while ( seriesIterator.hasNext() ) { SurveySeries innerSeries = seriesIterator.next(); outputData.addAll( generateSurvexDataSeries( innerSeries, series, outputSplays ) ); } //Close the series outputData.add( "*END " + series.getSeriesName() ); outputData.add( "" ); return outputData; } /* Replace LRUD values with those from actual leg represented by current and next station in block * and remove single station blocks. Sometimes at junctions the initial LRUD data put into the block * is from a leg which is not the correct leg for the next station added to the block. So where a * leg can be matched to both the station on the data line, and the next station in the block then * we can update the LRUD data to be from that leg. */ private void reprocessPassageDataBlocks( SurveySeries series, List> passageData ) { //Process all blocks ListIterator> blocksIter = passageData.listIterator(); while ( blocksIter.hasNext() ) { List block = blocksIter.next(); //Remove block if only contains a single station at these are obsolete if ( block.size() < 2 ) { blocksIter.remove(); } else { //Update LRUD data for lines in block boolean noLrudDataInBlock = true; //Loop through each pair of stations in the block for ( int blockIdx = 0; blockIdx < ( block.size() - 1 ); blockIdx++ ) { String[] line1 = block.get(blockIdx); String[] line2 = block.get(blockIdx + 1); //Look for a leg representing this line1 boolean legMatchesPassageData = false; for ( int legIdx = 0; legIdx < series.legCount(); legIdx++ ) { SurveyLeg leg = series.getLegRaw(legIdx); if ( ( leg.isSplay() == false ) && ( leg.getToStn() != null ) && ( leg.getLeft() + leg.getRight() + leg.getUp() + leg.getDown() > 0.0 ) ) { //Leg is a real leg with LRUD data, check for match both ways if ( ( line1[0].equals( leg.getFromStn().getName() ) ) && ( line2[0].equals( leg.getToStn().getName() ) ) ) { legMatchesPassageData = true; } //Do not look for reverse leg match because LRUD will be on opposite end of leg to the passage data line we are updating // else if ( ( line2[0].equals( leg.getFromStn().getName() ) ) // && ( line1[0].equals( leg.getToStn().getName() ) ) ) { // legMatchesPassageData = true; // } } //If a matching leg was found then regenerate LRUD data for this line using the leg if ( legMatchesPassageData ) { //Replace LRUD data for this line with data from this leg String[] newLine = createLrudLine(leg); if ( line1[1].equals( newLine[1] ) == false ) { block.remove(blockIdx); block.add(blockIdx, newLine); } break; //Exit legs for loop } } //Check if the line has any LRUD data if this block has not had any so far if ( ( noLrudDataInBlock ) && ( ( line1[1].equals( " 0.00\t 0.00\t 0.00\t 0.00" ) == false ) || ( line2[1].equals( " 0.00\t 0.00\t 0.00\t 0.00" ) == false ) ) ) { noLrudDataInBlock = false; } } //Remove block if no LRUD data on any station if ( noLrudDataInBlock ) { blocksIter.remove(); } } } } /* When a leg closes a loop, we need to add the LRUD for the toStn of the loop closure by finding that station * with the LRUD data in another leg. In Stomps, the leg 31-25 has LRUD on 31. But there is no terminal stn25. * Perhaps there should be? Or easier to analyse all passage data blocks here, consolidate blocks which are adjoined * and then look for any legs where the toStn is not represented and add them by copying data from another leg. */ private void addMissingPassageDataAtLoopClosureStations( SurveySeries series, List> passageData ) { //Check for legs with LRUD data on the toStn which are not represented in blocks for ( int legIdx = 0; legIdx < series.legCount(); legIdx++ ) { SurveyLeg leg = series.getLegRaw(legIdx); if ( ( leg.isSplay() == false ) && ( leg.getLeft() + leg.getRight() + leg.getUp() + leg.getDown() > 0.0 ) ) { //Check for a leg which has LRUD data on the toStn of this leg for ( int legIdx2 = 0; legIdx2 < series.legCount(); legIdx2++ ) { SurveyLeg leg2 = series.getLegRaw(legIdx2); if ( ( leg.isSplay() == false ) && ( leg.getToStn() != null ) && ( leg.getLeft() + leg.getRight() + leg.getUp() + leg.getDown() > 0.0 ) && ( leg.getToStn().getName().equals( leg2.getFromStn().getName() ) ) ) { //Check if the leg is represented in a passage data block boolean foundLegInPassData = false; ListIterator> blocksIter = passageData.listIterator(); while ( blocksIter.hasNext() ) { List block = blocksIter.next(); //Look for pair of lines in this block which represent this leg for ( int blockIdx = 0; blockIdx < ( block.size() - 1 ); blockIdx++ ) { String[] line1 = block.get(blockIdx); String[] line2 = block.get(blockIdx + 1); if ( ( line1[0].equals( leg.getFromStn().getName() ) ) && ( line2[0].equals( leg.getToStn().getName() ) ) ) { foundLegInPassData = true; break; //Exit block for loop } else if ( ( line2[0].equals( leg.getFromStn().getName() ) ) && ( line1[0].equals( leg.getToStn().getName() ) ) ) { foundLegInPassData = true; break; //Exit block for loop } } if ( foundLegInPassData ) { break; //Exit passage data blocks loop } } if ( foundLegInPassData == false ) { //Leg with toStn LRUD is missing from passage data. //Check if any passage data block starts or ends with one of the stns from the leg //so we can add it ListIterator> blocksIter2 = passageData.listIterator(); while ( blocksIter2.hasNext() ) { List blockForAdd = blocksIter2.next(); int insertPoint = 0; //0=not found, 1=start, 2=end if ( blockForAdd.get(blockForAdd.size() - 1)[0].equals( leg.getFromStn().getName() ) ) { //Leg from station found at end of block insertPoint = 2; } else if ( blockForAdd.get(0)[0].equals( leg.getFromStn().getName() ) ) { //Leg from station found at start of block insertPoint = 1; } if ( insertPoint > 0 ) { //Loop through all passage data block lines looking for one which matches the toStn ListIterator> blocksIter3 = passageData.listIterator(); while ( blocksIter3.hasNext() ) { List blockToCopyFrom = blocksIter3.next(); boolean lineAdded = false; ListIterator blockIter = blockToCopyFrom.listIterator(); while ( blockIter.hasNext() ) { String[] line = blockIter.next(); if ( line[0].equals( leg.getToStn().getName() ) ) { //Insert suitable LRUD line here if ( insertPoint == 1) { //Insert at start blockForAdd.add(0, line); } else { //Insert at end blockForAdd.add(line); } lineAdded = true; break; //Exit loop through block looking for line to add } } if ( lineAdded ) { break; //Exit loop looking for passage data block to add line from } } break; //Exit passage data blocks2 loop } } } break; //Exit loop leg2 as leg has been processed } } } } } private String[] createLrudLine( SurveyLeg bestLeg ) { String[] lrudLine = new String[3]; lrudLine[0] = bestLeg.getFromStn().getName(); lrudLine[1] = CaveConverter.padNumber(bestLeg.getLeft(),2,5) + "\t" + CaveConverter.padNumber(bestLeg.getRight(),2,5) + "\t" + CaveConverter.padNumber(bestLeg.getUp(),2,5) + "\t" + CaveConverter.padNumber(bestLeg.getDown(),2,5); if ( bestLeg.getToStn() != null ) { lrudLine[2] = bestLeg.getToStn().getName(); } return lrudLine; } } CaveConverter_src/src/footleg/cavesurvey/data/reader/0000755000000000000000000000000012165540164021772 5ustar rootrootCaveConverter_src/src/footleg/cavesurvey/data/reader/DxfParser.java0000644000000000000000000006026212115213054024527 0ustar rootroot/** * Copyright (C) 2009-2013 Paul Fretwell - aka 'Footleg' (drfootleg@gmail.com) * * This file is part of Cave Converter. * * Cave Converter is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation, either version 3 of the License, or * (at your option) any later version. * * Cave Converter is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with Cave Converter. If not, see . */ package footleg.cavesurvey.data.reader; import java.util.ArrayList; import java.util.Date; import java.util.List; import footleg.cavesurvey.cmdline.CaveConverter; import footleg.cavesurvey.data.model.CaveSurvey; import footleg.cavesurvey.data.model.SurveyLeg; import footleg.cavesurvey.data.model.SurveySeries; import footleg.cavesurvey.data.model.SurveyStation; import footleg.cavesurvey.data.model.SurveyStation.FixType; import footleg.cavesurvey.tools.UtilityFunctions; /** * Parser for DXF format text data files. * * @author Footleg * @version 2013.03.04 (ISO 8601 YYYY.MM.DD) * @since 1.6 (The Java version used) */ public class DxfParser { private Date seriesDate; /** * Parse Autocad DXF file into the cave data model. * * Converts polylines into series with fixed point at start. * * @param surveyFileData ListArray of data lines from a DXF file * @param parseMode An enumeration to indicate whether to parse file for contour polylines, spot heights or survey legs * @return Cave Survey object */ public CaveSurvey parseFile( List surveyFileData, int parseMode ) { int legCount = 0; int iPolylineCount = 0; int iVertexCount = 0; int iPlainlineCount = 0; //Create new list of survey series to hold data CaveSurvey surveyData = new CaveSurvey(); SurveySeries outerSeries = null; //Create arrays to data while processing lines List> allChains = new ArrayList>(); List arSurveyChain = new ArrayList(); List arLines = new ArrayList(); //Define read state values final int stateParsingHeader = 0; final int stateFindPolyline = 1; final int stateFindVertex = 2; final int parseModeSurveyLegs = 0; final int parseModeSurfaceContours = 1; final int parseModeSpotHeights = 2; //Initialise read state int state = stateParsingHeader; //Local vars int iPointCount = 0; String sLineName = ""; double dEastValue = 0; double dNorthValue = 0; double dElevValue = 0; double dLastEastValue = 0; double dLastNorthValue = 0; double dLastElevValue = 0; //Range bounds int iNorthEdge = 999999999; int iSouthEdge = -999999999; int iEastEdge = 999999999; int iWestEdge = -999999999; int iMinElev = -999999999; //Write output file header CaveConverter.logMessage("Generating survey data from lines and polylines in DXF data file"); outerSeries = new SurveySeries( "SurveyFromDXF" ); surveyData.add( outerSeries ); //Loop through all data lines for ( int i=0; i < surveyFileData.size(); i++ ) { String dataLine = surveyFileData.get(i); //Proceed based on state switch( state ) { case stateParsingHeader : //First look for line: // ENTITIES //This signifies start of data after header stuff which we ignore. if ( dataLine.trim().compareToIgnoreCase("ENTITIES") == 0 ) { //Found end of header section, so change state to searching for new polyline state = stateFindPolyline; } break; case stateFindPolyline: //} loop through all polylines, each indicated with header line: // POLYLINE //and ending with: // SEQEND if ( dataLine.trim().compareToIgnoreCase("POLYLINE") == 0 ) { //Found polyline //Check next 15 lines looking for AcDbEntity start int iSkipLoop = 1; do { dataLine = surveyFileData.get(++i); } while ( ( dataLine.trim().compareToIgnoreCase("AcDbEntity") != 0 ) || ( iSkipLoop > 15 ) ); //If found it then process if ( dataLine.trim().compareToIgnoreCase("AcDbEntity") == 0 ) { //(skip 1 line) dataLine = surveyFileData.get(++i); //Read entity type from next line: dataLine = surveyFileData.get(++i); //if Strings.Left(Trim(dataLine), 4) = "1100" { //Found a contour line entity (they are all 1100x) //Increment line counter iPolylineCount += 1; //Start new section heading, removing spaces from station names sLineName = dataLine.replace(" ", "_"); if ( parseMode == parseModeSurfaceContours ) { sLineName = sLineName + iPolylineCount; } //Set state to finding vertices state = stateFindVertex; //Reset point counter iPointCount = 0; //} } } //loop through all lines, each indicated with header line: // LINE //and ending after a fixed number of lines else if ( dataLine.trim().compareToIgnoreCase("LINE") == 0 ) { //Found line iPlainlineCount++; //Check next 15 lines looking for AcDbEntity start int iSkipLoop = 0; do { dataLine = surveyFileData.get(++i); iSkipLoop++; } while ( (dataLine.trim().compareToIgnoreCase("AcDbEntity") != 0 && dataLine.trim().compareToIgnoreCase("CentreLine") != 0 ) && ( iSkipLoop < 4 ) ); //Allow anything if 4 lines read boolean allowAnyLineName = false; if ( iSkipLoop == 4 ) { allowAnyLineName = true; } //If found it then process if ( dataLine.trim().compareToIgnoreCase("AcDbEntity") == 0 || dataLine.trim().compareToIgnoreCase("CentreLine") == 0 || allowAnyLineName == true ) { if ( dataLine.trim().compareToIgnoreCase("CentreLine") != 0 && allowAnyLineName == false ) { //Check next 15 lines looking for AcDbLine start iSkipLoop = 1; do { dataLine = surveyFileData.get(++i); } while ( ( dataLine.trim().compareToIgnoreCase("AcDbLine") != 0 ) || ( iSkipLoop > 15 ) ); } //If found it then process if ( dataLine.trim().compareToIgnoreCase("AcDbLine") == 0 || ( dataLine.trim().compareToIgnoreCase("CentreLine") == 0 ) || allowAnyLineName ) { //Check for next line: //10: dataLine = surveyFileData.get(++i); if ( dataLine.trim().compareToIgnoreCase("10") == 0 ) { //Read Easting dataLine = surveyFileData.get(++i); dEastValue = roundedDataValue(dataLine); //Check for next line: //20: dataLine = surveyFileData.get(++i); if ( dataLine.trim().compareToIgnoreCase("20") == 0 ) { //Read Northing dataLine = surveyFileData.get(++i); dNorthValue = roundedDataValue(dataLine); //Check for next line: //30: dataLine = surveyFileData.get(++i); if ( dataLine.trim().compareToIgnoreCase("30") == 0 ) { //Read Elevation dataLine = surveyFileData.get(++i); dElevValue = roundedDataValue(dataLine); //Check for next line: //11: dataLine = surveyFileData.get(++i); if ( dataLine.trim().compareToIgnoreCase("11") == 0 ) { //Read Easting dataLine = surveyFileData.get(++i); dLastEastValue = roundedDataValue(dataLine); //Check for next line: //21: dataLine = surveyFileData.get(++i); if ( dataLine.trim().compareToIgnoreCase("21") == 0 ) { //Read Northing dataLine = surveyFileData.get(++i); dLastNorthValue = roundedDataValue(dataLine); //Check for next line: //31: dataLine = surveyFileData.get(++i); if ( dataLine.trim().compareToIgnoreCase("31") == 0 ) { //Read Elevation dataLine = surveyFileData.get(++i); dLastElevValue = roundedDataValue(dataLine); //Now generate data to output if ( ( dEastValue >= iWestEdge ) && ( dEastValue <= iEastEdge ) && ( dNorthValue <= iNorthEdge ) && ( dNorthValue >= iSouthEdge ) && ( dElevValue >= iMinElev ) && ( dLastEastValue >= iWestEdge ) && ( dLastEastValue <= iEastEdge ) && ( dLastNorthValue <= iNorthEdge ) && ( dLastNorthValue >= iSouthEdge ) && ( dLastElevValue >= iMinElev )) { //Increment point counter iPointCount += 1; if ( parseMode == parseModeSurveyLegs ) { //Add points to line array double[] point = new double[6]; point[0] = dEastValue; point[1] = dNorthValue; point[2] = dElevValue; point[3] = dLastEastValue; point[4] = dLastNorthValue; point[5] = dLastElevValue; arLines.add(point); } } else { //Record outside specified area dEastValue = dNorthValue; } } } } } } } } } } break; case stateFindVertex: //Within each polyline, look for vertices indicated by lines: // VERTEX if ( dataLine.trim().compareToIgnoreCase("VERTEX") == 0 ) { //Reset flag boolean bValidRecord = false; //Increment count iVertexCount += 1; //Check next 15 lines looking for AcDbEntity start int iSkipLoop = 1; do { dataLine = surveyFileData.get(++i); } while ( ( dataLine.trim().compareToIgnoreCase("AcDbEntity") != 0 ) || ( iSkipLoop > 15 ) ); if ( dataLine.trim().compareToIgnoreCase("AcDbEntity") == 0 ) { //Check next 15 lines looking for AcDbVertex start iSkipLoop = 1; do { dataLine = surveyFileData.get(++i); } while ( ( dataLine.trim().compareToIgnoreCase("AcDbVertex") != 0 ) || ( iSkipLoop > 15 ) ); if ( dataLine.trim().compareToIgnoreCase("AcDbVertex") == 0 ) { //Check next 15 lines looking for AcDb3dPolylineVertex start iSkipLoop = 1; do { dataLine = surveyFileData.get(++i); } while ( ( dataLine.trim().compareToIgnoreCase("AcDb3dPolylineVertex") != 0 ) || ( iSkipLoop > 15 ) ); if ( dataLine.trim().compareToIgnoreCase("AcDb3dPolylineVertex") == 0 ) { //Check for next line: //10: dataLine = surveyFileData.get(++i); if ( dataLine.trim().compareToIgnoreCase("10") == 0 ) { //Read Easting dataLine = surveyFileData.get(++i); dEastValue = roundedDataValue(dataLine); //Check for next line: //20: dataLine = surveyFileData.get(++i); if ( dataLine.trim().compareToIgnoreCase("20") == 0 ) { //Read Northing dataLine = surveyFileData.get(++i); dNorthValue = roundedDataValue(dataLine); //Check for next line: //30: dataLine = surveyFileData.get(++i); if ( dataLine.trim().compareToIgnoreCase("30") == 0 ) { //Read Elevation dataLine = surveyFileData.get(++i); dElevValue = roundedDataValue(dataLine); //Now generate data to output if ( ( dEastValue >= iWestEdge ) && ( dEastValue <= iEastEdge ) && ( dNorthValue <= iNorthEdge ) && ( dNorthValue >= iSouthEdge ) && ( dElevValue >= iMinElev ) ) { //Increment point counter iPointCount += 1; if ( parseMode == parseModeSurveyLegs ) { //Add point to chain double[] point = new double[3]; point[0] = dEastValue; point[1] = dNorthValue; point[2] = dElevValue; arSurveyChain.add(point); } else { //Generate station name String sStnName = "S" + iPolylineCount + "P" + iPointCount; //Reset station position string String sPointPosition = ""; if ( iPointCount == 1 ) { //First point, so fix it sPointPosition = "*fix " + sStnName + " " + dEastValue + " " + dNorthValue + " " + dElevValue; if ( parseMode == parseModeSurfaceContours ) { //Write line header CaveConverter.logMessage("*begin " + sLineName); } else { //} point, so write differences for leg sPointPosition = " " + (dEastValue - dLastEastValue) + " " + (dNorthValue - dLastNorthValue) + " " + (dElevValue - dLastElevValue); } } if ( parseMode == parseModeSpotHeights ) { CaveConverter.logMessage( String.valueOf(Math.round(dEastValue) - iEastEdge) ); CaveConverter.logMessage( String.valueOf( (iNorthEdge - iSouthEdge) - ( Math.round(dNorthValue) - iSouthEdge) ) ); CaveConverter.logMessage( String.valueOf(dElevValue) ); } else { //Write position and station number CaveConverter.logMessage(sPointPosition); CaveConverter.logMessage(sStnName); } } //Update last positions dLastEastValue = dEastValue; dLastNorthValue = dNorthValue; dLastElevValue = dElevValue; } else { //Record outside specified area dEastValue = dNorthValue; } bValidRecord = true; } } } } } } //Check for invalid records if ( bValidRecord == false ) { //Invalid record CaveConverter.logMessage("Bad Line"); //Set state back to searching for next vertex state = stateFindPolyline; } } //Find either next VERTEX or SEQEND else if ( dataLine.trim().compareToIgnoreCase("SEQEND") == 0 ) { //End of polyline //Write final station name if any points were written if ( parseMode == parseModeSurveyLegs ) { //Check that line name is unique String sUniqueName = sLineName; int k = 1; boolean bUnique = false; while ( bUnique == false ) { //Search existing chains for matching name bUnique = true; for ( int j = 0; j < outerSeries.innerSeriesCount(); j++ ) { //Check for matching series if ( outerSeries.getInnerSeries(j).getSeriesName().compareTo( sUniqueName ) == 0 ) { //Not unique, so add number to end sUniqueName = sLineName + k; k++; bUnique = false; //Exit loop j = outerSeries.innerSeriesCount(); } } } //Add new series to list for this polyline outerSeries.addSeries( makeSeriesFromPolyline( arSurveyChain, sUniqueName ) ); legCount += (arSurveyChain.size() - 1); //Store chain for linking to other chains later allChains.add(arSurveyChain); //Reset series data array arSurveyChain = new ArrayList(); } else if ( parseMode == parseModeSurfaceContours ) { //End section if any points were in target area if ( iPointCount > 0 ) { CaveConverter.logMessage("*end " + sLineName); } } //Set state back to searching for next vertex state = stateFindPolyline; } break; default: } } //Attempt to join up lines into connected polylines int newlines = 0; while ( arLines.size() > 0 ) { //Get first line out double[] line = arLines.remove(0); //Start new polyline arSurveyChain = new ArrayList(); //Add points to chain double[] firstPoint = new double[3]; firstPoint[0] = line[0]; firstPoint[1] = line[1]; firstPoint[2] = line[2]; arSurveyChain.add(firstPoint); double[] lastPoint = new double[3]; lastPoint[0] = line[3]; lastPoint[1] = line[4]; lastPoint[2] = line[5]; arSurveyChain.add(lastPoint); //Search for ajoining lines boolean added = true; while ( added == true ) { added = false; for ( int linesIdx = 0; linesIdx < arLines.size(); linesIdx++ ) { boolean match = false; line = arLines.get(linesIdx); if ( firstPoint[0] == line[0] && firstPoint[1] == line[1] && firstPoint[2] == line[2] ) { //Add new first point to start of polyline firstPoint = new double[3]; firstPoint[0] = line[3]; firstPoint[1] = line[4]; firstPoint[2] = line[5]; arSurveyChain.add(0, firstPoint); match = true; } else if ( firstPoint[0] == line[3] && firstPoint[1] == line[4] && firstPoint[2] == line[5] ) { //Add new first point to start of polyline firstPoint = new double[3]; firstPoint[0] = line[0]; firstPoint[1] = line[1]; firstPoint[2] = line[2]; arSurveyChain.add(0, firstPoint); match = true; } else if ( lastPoint[0] == line[0] && lastPoint[1] == line[1] && lastPoint[2] == line[2] ) { //Add new last point to end of polyline lastPoint = new double[3]; lastPoint[0] = line[3]; lastPoint[1] = line[4]; lastPoint[2] = line[5]; arSurveyChain.add(lastPoint); match = true; } else if ( lastPoint[0] == line[3] && lastPoint[1] == line[4] && lastPoint[2] == line[5] ) { //Add new last point to end of polyline lastPoint = new double[3]; lastPoint[0] = line[0]; lastPoint[1] = line[1]; lastPoint[2] = line[2]; arSurveyChain.add(lastPoint); match = true; } if ( match == true ) { //Remove line and decrement index so next item is picked up arLines.remove(linesIdx); linesIdx--; added = true; } } } //Add chain to array and create series allChains.add(arSurveyChain); newlines++; outerSeries.addSeries( makeSeriesFromPolyline( arSurveyChain, "SeriesFromLines" + newlines ) ); legCount += (arSurveyChain.size() - 1); } //Search for connected stations for any station in each polyline for ( int seriesIdx = 0; seriesIdx < outerSeries.innerSeriesCount(); seriesIdx++ ) { //Get chain corresponding to this series List srcChain = allChains.get(seriesIdx); for ( int point1Idx = 0; point1Idx < srcChain.size(); point1Idx++ ) { //Get fixed position for this station in chain double fixX = srcChain.get(point1Idx)[0]; double fixY = srcChain.get(point1Idx)[1]; double fixZ = srcChain.get(point1Idx)[2]; //Check all chains except self for a matching point for ( int chainIdx = 0; chainIdx < allChains.size(); chainIdx++ ) { List chain = allChains.get(chainIdx); for ( int pointIdx = 0; pointIdx < chain.size(); pointIdx++ ) { if ( ( fixX == chain.get(pointIdx)[0] ) && ( fixY == chain.get(pointIdx)[1] ) && ( fixZ == chain.get(pointIdx)[2] ) ) { //Found matching point boolean addEquate = true; if (chainIdx == seriesIdx ) { //Matching point is in same series, so only add equate //when matching station occurs after test station to avoid adding //equate twice or equating stations onto themselves if ( pointIdx <= point1Idx) { addEquate = false; } } if ( addEquate == true ) { //Replace fixed point in leg with equate outerSeries.addLink(outerSeries.getInnerSeries(seriesIdx).getSeriesName(), new SurveyStation(point1Idx), outerSeries.getInnerSeries(chainIdx).getSeriesName(), new SurveyStation(pointIdx)); } //Clear fixed points apart from first one in first series if ( seriesIdx > 0 ) { SurveyStation stn = outerSeries.getInnerSeries(seriesIdx).getLegRaw(0).getFromStn(); double easting = stn.getEasting(); double northing = stn.getNorthing(); double altitude = stn.getAltitude(); stn.setFixed(FixType.NONE, easting, northing, altitude); } } } } } } //Debug dump UtilityFunctions.logSurveyDebugData(surveyData); //Completed file parsing CaveConverter.logMessage("Processed " + legCount + " survey legs in " + outerSeries.innerSeriesCount() + " series."); CaveConverter.logMessage("Found:"); CaveConverter.logMessage("Polylines: " + iPolylineCount + " containing " + iVertexCount + " line segments."); CaveConverter.logMessage("Lines: " + iPlainlineCount); CaveConverter.logMessage("Total line segments: " + (iPlainlineCount + iVertexCount)); return surveyData; } /** * Converts a series of points in a polyline with absolute coordinates into a series * of connected survey legs,calculating tape, compass and clino data. * @param List List of all points in polyline as x,y,z coordinates * @return SurveySeries of all the legs represented by the polyline. Fixed by position of first stn. */ private SurveySeries makeSeriesFromPolyline( List arSurveyChain, String seriesName ) { //Create new series from this chain SurveySeries series = new SurveySeries( seriesName ); //Set date series.setSurveyDate( seriesDate ); //Loop through all points in chain for ( int i = 1; i < arSurveyChain.size(); i++ ) { SurveyLeg leg = new SurveyLeg(); SurveyStation fromStn = new SurveyStation( i - 1 ); SurveyStation toStn = new SurveyStation( i ); double[] startPoint = arSurveyChain.get( i - 1 ); double[] endPoint = arSurveyChain.get(i); if ( i == 1 ) { //First leg, so fix first station fromStn.setFixed(FixType.OTHER, startPoint[0], startPoint[1], startPoint[2]); } //Calculate leg data double x = endPoint[0] - startPoint[0]; double y = endPoint[1] - startPoint[1]; double z = endPoint[2] - startPoint[2]; //Only add point if in a different position to previous point in polyline if ( x != 0 || y != 0 || z != 0 ) { double hori = Math.pow( Math.pow( x, 2 ) + Math.pow( y, 2 ), 0.5 ); double tape = Math.pow( Math.pow( hori, 2 ) + Math.pow( z, 2 ), 0.5 ); double compass = bearing(x, y); double clino = bearing(z, hori); if ( clino > 90 ) { clino = clino - 360; } leg.setFromStn( fromStn ); leg.setToStn( toStn ); leg.setLength(tape); leg.setCompass(compass); leg.setClino(clino); series.addLeg(leg); } } return series; } /** * bearing * * Returns bearing for angle described by x and y lengths */ private double bearing(double x, double y) { double res = 0; if ( x == 0 ) { if ( y < 0 ) { res = 180; } else { res = 0; } } else if ( x < 0 ) { if ( y == 0 ) { res = 270; } else if ( y < 0 ) { //180-270 res = 180 + (Math.atan(x / y) * 180 / Math.PI); } else { //270-360 res = 360 + (Math.atan(x / y) * 180 / Math.PI); } } else { if ( y == 0 ) { res = 90; } else if ( y < 0 ) { //90-180 res = 180 + (Math.atan(x / y) * 180 / Math.PI); } else { //0-90 res = (Math.atan(x / y) * 180 / Math.PI); } } return res; } private double roundedDataValue( String dataLine ) { double roundedVal = ( (double)Math.round( Double.valueOf(dataLine) * 10000 ) ) / 10000; return roundedVal; } } CaveConverter_src/src/footleg/cavesurvey/data/reader/SurvexParser.java0000644000000000000000000004106412171572554025320 0ustar rootroot/** * Copyright (C) 2009-2013 Paul Fretwell - aka 'Footleg' (drfootleg@gmail.com) * * This file is part of Cave Converter. * * Cave Converter is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation, either version 3 of the License, or * (at your option) any later version. * * Cave Converter is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with Cave Converter. If not, see . */ package footleg.cavesurvey.data.reader; import java.text.ParseException; import java.util.ArrayList; import java.util.Date; import java.util.Iterator; import java.util.List; import footleg.cavesurvey.cmdline.CaveConverter; import footleg.cavesurvey.data.model.CaveSurvey; import footleg.cavesurvey.data.model.Equate; import footleg.cavesurvey.data.model.SurveyLeg; import footleg.cavesurvey.data.model.SurveySeries; import footleg.cavesurvey.tools.UtilityFunctions; /** * Parser for Survex format text data files. * * @author Footleg * @version 2013.07.17 (ISO 8601 YYYY.MM.DD) * @since 1.6 (The Java version used) * * @to.do * TODO Parse entrance flags * TODO Parse fix flags * TODO Parse calibration comments fields * TODO Parse team fields * TODO Parse instrument fields * TODO Parse units declarations * TODO Add support for reading multiple files using includes to build up the survey */ public class SurvexParser { /** * Parse survex format data into the cave data model * * @param surveyFileData ListArray of data lines from a survex file * @return Cave Survey object * @throws ParseException */ public CaveSurvey parseSurvexFile( List surveyFileData ) throws ParseException { /** * Read state codes: * 0=starting new file * 1=inside begin/end block * 2=LRUD block */ int state = 0; //Create new list of survey series to hold data CaveSurvey allSeries = new CaveSurvey(); //Create stack to hold open series while processing data lines List seriesStack = new ArrayList(); //Create stack to hold open series names while processing data lines List nameStack = new ArrayList(); //Create list for equates List equates = new ArrayList(); //Create a series instance to use as a pointer to the active series data is being read from SurveySeries liveSeries = null; //Declare flags to store status of legs being read boolean duplicateFlag = false; boolean splayFlag = false; boolean surfaceFlag = false; //Loop through all data lines for ( int i=0; i < surveyFileData.size(); i++ ) { int lineNo = i + 1; String dataLine = surveyFileData.get(i); //Discard text after comment character //TODO Keep comments and add into data model for legs, series and file heading int commentPos = dataLine.indexOf(';'); if ( commentPos > -1 ) { dataLine = dataLine.substring(0, commentPos); } //Trim whitespace off line ends dataLine = dataLine.trim(); //Skip blank lines if ( dataLine.length() > 0 ) { //Check line for commands if ( dataLine.charAt(0) == '*' ) { //Process line into individual items String[] data = cleanAndSplitData(dataLine); //Get command keyword String cmd = data[0].substring(1); //Check for expected commands if ( cmd.compareToIgnoreCase("BEGIN") == 0 ) { //Start of new block state = 1; if (data.length == 2) { //Create series liveSeries = new SurveySeries(data[1]); //Reset flags for new series duplicateFlag = false; splayFlag = false; surfaceFlag = false; //Add name to stack nameStack.add(data[1]); //Get calibrations from last series and apply to new child series (if present) Double tapeCal = 0.0; Double compassCal = 0.0; Double clinoCal = 0.0; Double declinationCal = 0.0; //Check if a parent series exists if (seriesStack.size() > 0) { SurveySeries series = seriesStack.get( seriesStack.size() - 1 ); tapeCal = series.getTapeCalibration(); compassCal = series.getCompassCalibration(); clinoCal = series.getClinoCalibration(); declinationCal = series.getDeclination(); } //Put new series onto stack seriesStack.add(liveSeries); //Apply calibrations from parent series. //These will get overwritten if this series has it's own calibrations. liveSeries.setTapeCalibration(tapeCal); liveSeries.setCompassCalibration(compassCal); liveSeries.setClinoCalibration(clinoCal); liveSeries.setDeclination(declinationCal); } else if (data.length < 2) { //TODO support begin/end blocks without names throw new ParseException( formatError("BEGIN/END blocks without names are not supported.", lineNo ), lineNo ); } else { //Do not support begin/end blocks names with white space throw new ParseException( formatError("BEGIN/END blocks names containing spaces are not supported.", lineNo ), lineNo ); } } else if ( cmd.compareToIgnoreCase("END") == 0 ) { //End block String blockEndName = data[1]; //Check end matches end of section name String currentBlockName = nameStack.get( nameStack.size() - 1 ); if ( currentBlockName.compareToIgnoreCase(blockEndName) == 0 ) { //Found matching end block, so close series //Remove live series from stack, as it is closed SurveySeries endedSeries = seriesStack.remove( seriesStack.size() - 1 ); nameStack.remove( nameStack.size() - 1 ); if ( seriesStack.size() > 0) { //Series is inside another, so make that live and add finished series to it liveSeries = seriesStack.get( seriesStack.size() - 1 ); liveSeries.addSeries( endedSeries ); //Return state to 1 state = 1; } else { //No other series on stack, so add to main cave survey allSeries.add( endedSeries ); //Clear reference to live series liveSeries = null; //Return state to 0 state = 0; } } else { //Names of begin end blocks do not match throw new ParseException( formatError("Names of begin end blocks do not match. Begin=" + currentBlockName + " End=" + blockEndName + ".", lineNo ), lineNo ); } } else if ( cmd.compareToIgnoreCase("EQUATE") == 0 ) { //Get two parts of the equate, expanding to full nested series names String fullSeriesPrefix = fullNestedSeriesName(nameStack); Equate equate = new Equate( fullSeriesPrefix, data[1], fullSeriesPrefix, data[2] ); //Add to cache equates.add(equate); } else if ( cmd.compareToIgnoreCase("DATA") == 0 ) { //Check data command type if ( data[1].compareToIgnoreCase("PASSAGE") == 0 ) { //LRUD data block state = 2; } else if ( data[1].compareToIgnoreCase("NORMAL") == 0 ) { state = 1; //Check data order //TODO Add support for different data line ordering than default CaveConverter.logMessage( "Found normal data line. Checking format." ); boolean dataOrderOk = false; if ( data.length > 6 ) { //Check supported order if ( data[2].compareToIgnoreCase("FROM") == 0 ) { if ( data[3].compareToIgnoreCase("TO") == 0 ) { if ( ( data[4].compareToIgnoreCase("TAPE") == 0 ) || ( data[4].compareToIgnoreCase("LENGTH") == 0 ) ) { if ( ( data[5].compareToIgnoreCase("COMPASS") == 0 ) || ( data[5].compareToIgnoreCase("BEARING") == 0 ) ) { if ( ( data[6].compareToIgnoreCase("CLINO") == 0 ) || ( data[6].compareToIgnoreCase("GRADIENT") == 0 ) ) { //Data order is fine, so we can support this line dataOrderOk = true; } } } } } } if ( dataOrderOk == false ) { //Other data order is not supported. throw new ParseException( formatError("Unsupported survex data order. Only '*data normal from to tape compass clino' ordering is supported.", lineNo ), lineNo ); } } else { //Other data settings not currently supported (assumes file use default order) throw new ParseException( formatError("Unsupported survex data command: " + data[2], lineNo ), lineNo ); } } else if ( cmd.compareToIgnoreCase("CALIBRATE") == 0 ) { //Process calibration command if (data.length == 3) { String type = data[1]; Double value = Double.valueOf( data[2] ); if ( type.compareToIgnoreCase("tape") == 0 ) { //Set tape calibration in active series liveSeries.setTapeCalibration(value); } else if ( type.compareToIgnoreCase("declination") == 0 ) { //Set declination calibration in active series liveSeries.setDeclination(value); } else if ( type.compareToIgnoreCase("compass") == 0 ) { //Set compass calibration in active series liveSeries.setCompassCalibration(value); } else if ( type.compareToIgnoreCase("clino") == 0 ) { //Set compass calibration in active series liveSeries.setClinoCalibration(value); } //TODO Add support for calibration scale factors } else { //Invalid calibration lie throw new ParseException( formatError("CALIBRATE command did not contain a single instrument type plus value.", lineNo ), lineNo ); } } else if ( cmd.compareToIgnoreCase("DATE") == 0 ) { //Process date if (data.length == 2) { Date value = UtilityFunctions.stringToDate(data[1], "yyyy.MM.dd"); liveSeries.setSurveyDate(value); } } else if ( cmd.compareToIgnoreCase("FLAGS") == 0 ) { //Process flags boolean notPrefixed = false; for (int iFlags = 1; iFlags < data.length; iFlags++) { //Read all flags settings to determine what is being turned on or off if (data[iFlags].compareToIgnoreCase("NOT") == 0 ) { notPrefixed = true; } else if (data[iFlags].compareToIgnoreCase("DUPLICATE") == 0 ) { duplicateFlag = (notPrefixed == false); notPrefixed = false; } else if (data[iFlags].compareToIgnoreCase("SPLAY") == 0 ) { splayFlag = (notPrefixed == false); notPrefixed = false; } else if (data[iFlags].compareToIgnoreCase("SURFACE") == 0 ) { surfaceFlag = (notPrefixed == false); notPrefixed = false; } else { //Reset notPrefixed flag if any other value notPrefixed = false; } } } else { //Ignore other commands inside begin end block //TODO Add support for FIX stations //TODO Add support for ENTRANCE stations //TODO Add support for UNITS grads, feet, other common non-default units including topofil clino range CaveConverter.logMessage("Unsupported Survex command ignored: " + cmd); } } else { //Data line //CaveConverter.logMessage("Data line " + CaveConverter.padNumber(lineNo, 4) + ": " + dataLine); if ( liveSeries != null ) { //Process line into individual items String[] data = cleanAndSplitData(dataLine); switch (state) { case 1: //Create new survey leg SurveyLeg leg = new SurveyLeg(); //Create record from the items int index = 0; while ( index < data.length ) { String item = data[index]; //Check for end of line if ( item.charAt(0) == ';' ) { //Comments, so ignore rest of line //TODO Add support for leg comments index = data.length; } else { //Put item into appropriate value switch ( index ) { case 0: //TODO Add support for retaining station name when not a number leg.setFromStn( UtilityFunctions.createStationFromNameForSeries( data[index], liveSeries ) ); break; case 1: //TODO Add support for retaining station name when not a number leg.setToStn( UtilityFunctions.createStationFromNameForSeries( data[index], liveSeries ) ); break; case 2: leg.setLength( Double.parseDouble( data[index] ) ); break; case 3: if ( data[index].compareTo("-") == 0 ) { leg.setCompass(0); } else { leg.setCompass( Double.parseDouble( data[index] ) ); } break; case 4: //Trim data item after ';' if present String val = data[index]; int commentCharPos = val.indexOf(';'); if ( commentCharPos > 0 ) { val = val.substring(0, commentCharPos); } if ( val.compareToIgnoreCase("-V") == 0 ) { leg.setClino(-90); } else if ( val.compareToIgnoreCase("down") == 0 ) { leg.setClino(-90); } else if ( val.compareToIgnoreCase("d") == 0 ) { leg.setClino(-90); } else if ( val.compareToIgnoreCase("+V") == 0 ) { leg.setClino(90); } else if ( val.compareToIgnoreCase("up") == 0 ) { leg.setClino(90); } else if ( val.compareToIgnoreCase("u") == 0 ) { leg.setClino(90); } else if ( val.compareToIgnoreCase("-") == 0 ) { leg.setClino(0); } else if ( val.compareToIgnoreCase("level") == 0 ) { leg.setClino(0); } else { leg.setClino( Double.parseDouble( val ) ); } break; } } index++; } //Check leg was found if ( leg.getLength() > -1 ) { //Set flags for leg leg.setDuplicate(duplicateFlag); leg.setSplay(splayFlag); leg.setSurface(surfaceFlag); //Add leg to series liveSeries.addLeg(leg); } break; case 2: //Add data to LRUD cache /** * TODO Need to store all the LRUD lines in groups to match with * the legs once the series is complete. Need to match legs to lrud * from two consecutive lines to be sure the LRUD is for that leg, and * not another leg from the same station. Create the LRUD group in * the command parsing switch, as that is where we know a new LRUD group has * been started. */ break; } } else { //Data line outside of series throw new ParseException( formatError("Data line found outside of any begin/end block.", lineNo ), lineNo ); } } } } //Process equates UtilityFunctions.processEquates(equates, allSeries); //Debug dump UtilityFunctions.logSurveyDebugData(allSeries); //Completed file parsing return allSeries; } //Get series names in stack to generate full series name private String fullNestedSeriesName(List stack) { String name = ""; Iterator stackIterator = stack.listIterator(); while ( stackIterator.hasNext() ) { name += "." + stackIterator.next(); } //Remove initial dot return name.substring(1); } /* * cleanAndSplitData * * Removes whitespace and splits a line into items separated by whitespace * Returns and array of items from the input data */ private String[] cleanAndSplitData( String dataIn ) { //Process all white space down to single space chars String dataLine = dataIn.replace('\t', ' '); while ( dataLine.contains(" ") ) { dataLine = dataLine.replaceAll(" ", " "); } return dataLine.split(" "); } private String formatError( String message, int lineNo ) { String msg = message; msg += " At line: " + lineNo; return msg; } } CaveConverter_src/src/footleg/cavesurvey/data/reader/PocketTopoParser.java0000644000000000000000000006363612227575214026122 0ustar rootroot/** * Copyright (C) 2009-2013 Paul Fretwell - aka 'Footleg' (drfootleg@gmail.com) * * This file is part of Cave Converter. * * Cave Converter is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation, either version 3 of the License, or * (at your option) any later version. * * Cave Converter is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with Cave Converter. If not, see . */ package footleg.cavesurvey.data.reader; import java.text.ParseException; import java.util.ArrayList; import java.util.Date; import java.util.List; import footleg.cavesurvey.cmdline.CaveConverter; import footleg.cavesurvey.data.model.CaveSurvey; import footleg.cavesurvey.data.model.Equate; import footleg.cavesurvey.data.model.SurveyLeg; import footleg.cavesurvey.data.model.SurveySeries; import footleg.cavesurvey.data.model.SurveyStation; import footleg.cavesurvey.tools.UtilityFunctions; /** * Parser for PocketTopo Text export files. * * @author Footleg * @version 2013.10.16 (ISO 8601 YYYY.MM.DD) * @since 1.6 (The Java version used) */ public class PocketTopoParser { //Constants used to indicate what type of data is encoded on a data line in the file being parsed private final int LINE_TYPE_LEG = 1; private final int LINE_TYPE_SPLAY = 2; private final int LINE_TYPE_EQUATE = 3; private final int LINE_TYPE_COMMENT = 4; /** * Class to hold data parsed from a line in a PocketTopo exported text data file */ private class TopoDataLine { // start stepping through the array from the beginning private String fromStn = ""; private String toStn = ""; private double tape = 0; private double compass = 0; private double clino = 0; private String trip = ""; private String comment = ""; private int lineType = -1; public String getFromStn() { return fromStn; } public void setFromStn(String fromStn) { this.fromStn = fromStn; } public String getToStn() { return toStn; } public void setToStn(String toStn) { this.toStn = toStn; } public double getTape() { return tape; } public void setTape(double tape) { this.tape = tape; } public double getCompass() { return compass; } public void setCompass(double compass) { this.compass = compass; } public double getClino() { return clino; } public void setClino(double clino) { this.clino = clino; } public String getTrip() { return trip; } public void setTrip(String trip) { this.trip = trip; } public String getComment() { return comment; } public void setComment(String comment) { this.comment = comment; } public int getLineType() { return lineType; } public void setLineType(int lineType) { this.lineType = lineType; } } /** * Parse PocketTopo exported text data file into the cave data model * * @param surveyFileData ListArray of data lines from a PocketTopo text file * @return Cave Survey object * @throws ParseException */ public CaveSurvey parseFile( List surveyFileData ) throws ParseException { //Create new list of survey series to hold data CaveSurvey surveyData = new CaveSurvey(); SurveySeries outerSeries = null; String caveName = ""; //Create cache for trip settings (contains list of arrays each //containing 3 strings for the id, date and magnetic declination) List trips = new ArrayList(); //Create list for equates List equates = new ArrayList(); //Initialise read state int state = 0; //Create arrays to cache shots while processing each leg List legShots = new ArrayList(); List splayShots = new ArrayList(); //Cache vars for last leg processed String lastShotStart = ""; int lastToStn = -1; int lastSeriesNo = -1; String lastTripCode = ""; boolean newLeg = false; //Gets set to true when a new leg is started //Create vars for active series refs SurveySeries series = null; int activeSeries = -1; //Loop through all data lines for ( int lineIdx = 0; lineIdx <= surveyFileData.size(); lineIdx++ ) { int lineNo = lineIdx + 1; //Need to allow final pass through loop after all lines processed String dataLine = null; if ( lineIdx < surveyFileData.size() ) { dataLine = surveyFileData.get(lineIdx); } //Skip blank lines but not null line as this indicates end of file //and data cached from previous lines needs to be output if ( ( dataLine == null ) || ( dataLine.length() > 0 ) ) { //Process data switch (state) { case 0: //Header line //My Cave (m, 360) //Check for triple space separator with bracket int pos = dataLine.indexOf(" ("); if ( pos > 0 ) { String part1 = dataLine.substring(0, pos); String part2 = dataLine.substring(pos + 3); if ( part2.compareTo("(m, 360)") != 0 ) { //Not a valid header ParseException ex = new ParseException("Invalid file header. Unsupported units: " + part2, lineNo); throw ex; } else { //Take cave name from header, and create a new series for the cave caveName = part1.replace(' ', '_'); outerSeries = new SurveySeries( caveName ); surveyData.add( outerSeries ); CaveConverter.logMessage("Cave name: " + caveName); } } state = 1; break; case 1: //Trip settings in Header if ( dataLine.substring(0, 1).compareTo("[") == 0 ){ //Trip settings List tripData = UtilityFunctions.parseDataStringIntoDataItems(dataLine); //Copy into string array as rest of code uses a simple string array to store trip details String[] trip = new String[tripData.size()]; if ( tripData.size() >= 3 ) { if ( tripData.size() <= 4 ) { //Write first 3 items into trip data record for (int i = 0; i < tripData.size(); i++) { trip[i] = tripData.get(i); } } else { //Invalid trip line (more than 4 items) ParseException ex = new ParseException("Invalid file header. Trip data contain more than 4 items in line: " + dataLine, lineNo ); throw ex; } } else { //Invalid trip line (less than 3 items) ParseException ex = new ParseException("Invalid file header. Trip data does not contain at least 3 items in line: " + dataLine, lineNo ); throw ex; } //Remove colon from trip code if ( trip[0].charAt( trip[0].length() - 1 ) == ':' ) { trip[0] = trip[0].substring( 0, trip[0].length() - 1 ); } else { //Invalid trip code ParseException ex = new ParseException("Invalid file header. Unexpected trip code: " + trip[0] + " in line: " + dataLine, lineNo ); throw ex; } trips.add(trip); CaveConverter.logMessage("Trip settings: " + trip[0] + " " + trip[1] + " " + trip[2]); break; } else { //Start of legs, so don't break, just update state state = 2; } case 2: //Data lines //Create temporary survey leg to parse the data line into SurveyLeg shot = new SurveyLeg(); int seriesNo = -1; String trip = ""; TopoDataLine data = null; //Process data line if not at end of file if ( dataLine != null ) { // CaveConverter.logMessage("Data line " + CaveConverter.padNumber(lineNo, 4) + ": " + dataLine); //Parse items into Topoline object data = parseDataLine( UtilityFunctions.parseDataStringIntoDataItems( dataLine ) ); //Skip blank or all whitespace lines if ( data.getLineType() > 0 ) { //Add fields in common to all types of data line int[] seriesStn = splitSeriesFromStn( data.getFromStn() ); seriesNo = seriesStn[0]; shot.setFromStn( new SurveyStation( seriesStn[1] ) ); shot.setLength( data.getTape() ); shot.setCompass( data.getCompass() ); shot.setClino( data.getClino() ); shot.setComment( data.getComment() ); trip = data.getTrip(); if ( ( data.getLineType() == LINE_TYPE_LEG ) || ( data.getLineType() == LINE_TYPE_EQUATE ) ) { //Survey Leg or equate also have a To Stn int[] seriesStn2 = splitSeriesFromStn( data.getToStn() ); shot.setToStn( new SurveyStation( seriesStn2[1] ) ); //Check whether both stations are in same series if ( seriesNo != seriesStn2[0] ) { if ( data.getLineType() != LINE_TYPE_EQUATE ) { //Leg changes series. Only allowed for equates. ParseException ex = new ParseException("Legs linking different series must be zero length.", lineNo ); throw ex; } else { //Series equate Equate equate = new Equate( outerSeries.getSeriesName() + "." + seriesNo, shot.getFromStn().getName(), outerSeries.getSeriesName() + "." + seriesStn2[0], shot.getToStn().getName() ); //Add to cache equates.add(equate); } } else if ( data.getLineType() == LINE_TYPE_EQUATE ) { //Equate within series Equate equate = new Equate( outerSeries.getSeriesName() + "." + seriesNo, shot.getFromStn().getName(), outerSeries.getSeriesName() + "." + seriesStn2[0], shot.getToStn().getName() ); //Add to cache equates.add(equate); } } else { //Splays do not have a to station, but the code relies on their being //a dummy station, so create one with id = -1 shot.setToStn( new SurveyStation( -1 ) ); } } } else { //No more data, so just cached data to output from previous lines //Initialise leg to dummy data so conditions below enable cached data to be processed data = parseDataLine( UtilityFunctions.parseDataStringIntoDataItems( "DUMMY DUMMY 42.0 0.0 0.0 [1]" ) ); shot.setLength( data.getTape() ); //Set dummy value so cached legs get processed } //Process shot if not an equate if ( shot.getLength() > 0 ) { /** * Check if this data is part of same leg already being processed. * If the start station is different to the last one, or there is * a to station which is different to the last to station then it * is a new leg. */ if ( lastShotStart.length() == 0 ) { //First shot in file, so store start station lastShotStart = data.getFromStn(); } else if ( data.getFromStn().compareTo( lastShotStart ) != 0 ) { //Start of new leg (start stn is different to last data line) newLeg = true; } else if ( ( shot.getToStn().getId() != -1 ) && ( ( lastToStn != -1 ) ) && ( shot.getToStn().getId() != lastToStn ) ) { //Start of new leg (end stn is different to to stn on last data line where last data line had a to stn) newLeg = true; } else if ( ( lastToStn != -1 ) && ( shot.getToStn().getId() == -1 ) ) { //New leg (no to stn on current data line, but last line had one) newLeg = true; } if ( newLeg ) { //Starting new leg, so process data for last one before //storing this data //Create new leg to store store processed data SurveyLeg masterLeg = new SurveyLeg(); if ( legShots.size() > 0 ) { //Set stations using first leg masterLeg.setFromStn( legShots.get(0).getFromStn() ); masterLeg.setToStn( legShots.get(0).getToStn() ); //Calculate averages for leg shots double tape = 0.0; double clino = 0.0; String comments = ""; //Use utility function to average bearings so values either side of north average correctly double[] bearings = new double[legShots.size()]; for ( int i = 0; i < legShots.size(); i++ ) { tape += legShots.get(i).getLength(); bearings[i] = legShots.get(i).getCompass(); clino += legShots.get(i).getClino(); //Append comments from multiple shots into one comment if ( legShots.get(i).getComment().length() > 0 ) { if ( comments.length() > 0 ) { comments += "; " + legShots.get(i).getComment(); } else { comments = legShots.get(i).getComment(); } } } double aveCompass = UtilityFunctions.averageCompassBearings(bearings); //Update master leg masterLeg.setLength( tape / legShots.size() ); masterLeg.setCompass( aveCompass ); masterLeg.setClino( clino / legShots.size() ); masterLeg.setComment( comments ); } //Determine if this leg belongs to the active series if ( activeSeries != lastSeriesNo ) { //Different series, see if this series already exists boolean gotSeries = false; for ( int j = 0; j < outerSeries.innerSeriesCount(); j++ ) { //Check for matching series if ( outerSeries.getInnerSeries(j).getSeriesName().compareTo( "" + lastSeriesNo ) == 0 ) { //Found match, so get reference to this one series = outerSeries.getInnerSeries(j); gotSeries = true; //Exit loop j = outerSeries.innerSeriesCount(); } } if ( gotSeries == false ) { //No series found, so need to create one series = new SurveySeries( "" + lastSeriesNo ); //Find compass calibration for this new series for ( int j = 0; j < trips.size(); j++ ) { if ( lastTripCode.compareTo( trips.get(j)[0] ) == 0 ) { //Use calibration for this trip series.setDeclination( Double.valueOf( trips.get(j)[2] ) ); //Set date for trip (will be string of format yyyy/mm/dd) String tripDateString = trips.get(j)[1]; Date tripDate = UtilityFunctions.stringToDate(tripDateString, "yyyy/MM/dd"); series.setSurveyDate( tripDate ); //Add comment to series if a trip comment exists if ( trips.get(j).length == 4 ) { series.setComment(trips.get(j)[3]); } } } //Add new series to list outerSeries.addSeries( series ); } //Set active series number to match new active series activeSeries = lastSeriesNo; } //Process Splays for this leg int stnSplayCount = 0; String lastSplayFromStn = ""; for ( int i = 0; i < splayShots.size(); i++ ) { //Need to increment splay count for number of splays already added to series from this station //unless we already know this due to last splay being from the same station if ( ( i == 0 ) || ( lastSplayFromStn.equals( splayShots.get(i).getFromStn().getName() ) == false ) ) { //Count previous splays matching this fromStn in series stnSplayCount = 0; for ( int legIdx = 0; legIdx < series.legCount(); legIdx++ ) { SurveyLeg chkLeg = series.getLegRaw( legIdx ); if ( ( chkLeg.isSplay() ) && ( chkLeg.getFromStn().getName().equals( splayShots.get(i).getFromStn().getName() ) ) ) { stnSplayCount++; } } } //Add shot as a splay stnSplayCount++; addSplayShot(series, splayShots.get(i), stnSplayCount); } //Add master leg to series unless a dummy leg (will have negative length) if ( masterLeg.getLength() >= 0 ) { series.addLeg( masterLeg ); } //Clear caches legShots = new ArrayList(); splayShots = new ArrayList(); //Update stn names for this new leg lastShotStart = data.getFromStn(); //Reset flags newLeg = false; } //Process current leg unless a dummy end of file line if ( dataLine != null ) { //Determine whether a splay shot or a leg shot if ( shot.getToStn().getId() == -1 ) { //Passage dimension shot splayShots.add(shot); } else { //Survey Leg, add to list legShots.add(shot); } //Cache series no for this leg to be used next loop lastSeriesNo = seriesNo; lastTripCode = trip; //Store to stn for comparison on next pass lastToStn = shot.getToStn().getId(); } } break; default: } } } //Process equates UtilityFunctions.processEquates(equates, surveyData); //Debug dump UtilityFunctions.logSurveyDebugData(surveyData); //Completed file parsing // CaveConverter.logMessage("Processed " + legCount + " survey legs in " + // surveyData.size() + " series."); return surveyData; } /** * Splits a series.station name string into the component integers * * @param dataIn String consisting of a numeric series name and numeric station name separated with a dot * @return An array of two integers, the series number and the station number */ private int[] splitSeriesFromStn( String dataIn ) { //Split a series.station into the component integers int[] result = new int[2]; int pos = dataIn.indexOf('.'); if ( pos > 0 ) { result[0] = Integer.valueOf( dataIn.substring( 0, pos ) ); result[1] = Integer.valueOf( dataIn.substring( pos + 1 ) ); } else { //Invalid series+station name RuntimeException ex = new RuntimeException("Invalid dot separated series and station name : " + dataIn); throw ex; } return result; } /** * Determines what type of data a line of the file is representing */ private TopoDataLine parseDataLine( List dataItems ) { //Equate lines do not always have trip numbers ( [1] ) //Lines may be and equate with an optional trip and optional comment //e.g. 1.0 1.1 0.000 0.00 0.00 //e.g. 1.10 3.0 0.000 0.00 0.00 [1] //e.g. 1.0 1.1 0.000 0.00 0.00 "Equate with a comment." //e.g. 1.10 3.0 0.000 0.00 0.00 [1] "Equate with a comment." //Lines can define a station with no other data, or just a comment //e.g. 1.0 0.00 0.00 0.00 //e.g. 1.0 0.000 0.00 0.00 "Just a comment." //Lines can represent legs, with or without comments //e.g. 1.1 1.2 2.050 260.84 -56.40 [1] //e.g. 1.0 1.2 5.234 3.18 -5.07 [1] "1.2=rawl plug on rear wall of blockhouse " //Lines can represent splay shots, with or without comments //e.g. 1.1 0.670 344.92 4.15 [1] //e.g. 1.1 0.670 344.92 4.15 [1] "Splay with a comment." TopoDataLine result = new TopoDataLine(); //Check line is valid (has at least 4 items) if ( dataItems.size() > 4 ) { //There will be either 4 or 5 data items in any line, followed by optional trip and comment items int tripIdx = -1; int commentIdx = -1; String lastItem = dataItems.get( dataItems.size() - 1 ); String lastButOneItem = dataItems.get( dataItems.size() - 2 ); //Check if last item is a trip if ( itemIsTrip( lastItem ) ) { //Last item is trip tripIdx = dataItems.size() - 1; } else if ( itemIsTrip( lastButOneItem ) ) { //Last item is trip tripIdx = dataItems.size() - 2; //Last item in line has to be a comment commentIdx = dataItems.size() - 1; } else { //No trip, but is last item a comment? if ( dataItems.size() > 5 ) { //Last item in line has to be a comment commentIdx = dataItems.size() - 1; } else if ( dataItems.size() == 5 ) { //Last item in line is either a comment or a zero value if ( itemIsZeroValue( lastItem ) == false ) { //Last item in line has to be a comment commentIdx = dataItems.size() - 1; } } } //All items have a from station result.setFromStn( dataItems.get(0) ); if ( ( tripIdx == 4 ) || ( commentIdx == 4 ) ) { //If trip or comment idx=4 then line is a splay leg result.setTape( Double.valueOf( dataItems.get(1) ) ); result.setCompass( Double.valueOf( dataItems.get(2) ) ); result.setClino( Double.valueOf( dataItems.get(3) ) ); //Check whether line is really a splay, null data, or just a comment if ( ( result.getTape() == 0.0 ) && ( result.getCompass() == 0.0 ) && ( result.getClino() == 0.0 ) ) { if ( commentIdx > 0 ) { result.setLineType( LINE_TYPE_COMMENT ); } else { //No data on line apart from from stn. Null line. result.setLineType( 0 ); } } else { result.setLineType( LINE_TYPE_SPLAY ); } } else if ( ( tripIdx == 5 ) || ( commentIdx == 5 ) || ( ( tripIdx == -1 ) && ( commentIdx == -1 ) ) ) { //If trip or comment idx=5, or there is neither a trip or comment then line is a survey leg result.setToStn( dataItems.get(1) ); result.setTape( Double.valueOf( dataItems.get(2) ) ); result.setCompass( Double.valueOf( dataItems.get(3) ) ); result.setClino( Double.valueOf( dataItems.get(4) ) ); //Check whether line is an equate or a leg if ( ( result.getTape() == 0.0 ) && ( result.getCompass() == 0.0 ) && ( result.getClino() == 0.0 ) ) { result.setLineType( LINE_TYPE_EQUATE ); } else { result.setLineType( LINE_TYPE_LEG ); } } //Add trip and comment if present if ( tripIdx > 0 ) { result.setTrip( dataItems.get( tripIdx ) ); } if ( commentIdx > 0 ) { result.setComment( dataItems.get( commentIdx ) ); } } return result; } private boolean itemIsTrip( String dataItem ) { boolean isTrip = false; if ( ( dataItem.length() > 2 ) && ( dataItem.length() < 4 ) && ( dataItem.charAt( 0 ) == '[' ) && ( dataItem.charAt( dataItem.length() - 1 ) == ']' ) ) { //Found trip item isTrip = true; } return isTrip; } private boolean itemIsZeroValue( String dataItem ) { boolean isZero = false; //Check items starts with '0.0' if ( dataItem.length() > 2 ) { if ( ( dataItem.charAt(0) == '0' ) && ( dataItem.charAt(1) == '.' ) && ( dataItem.charAt(2) == '0' ) ) { //Potentially a zero value string isZero = true; //Loop through remaining characters checking they are all zeros for (int i = 3; i < dataItem.length(); i++) { if ( dataItem.charAt(i) != '0' ) { //Item is not a zero value isZero = false; i = dataItem.length(); } } } } else { //Allow '0' and '00' //Potentially a zero value string isZero = true; //Loop through remaining characters checking they are all zeros for (int i = 0; i < dataItem.length(); i++) { if ( dataItem.charAt(i) != '0' ) { //Item is not a zero value isZero = false; i = dataItem.length(); } } } return isZero; } /* * processSplaysArray * * Processes an array of splay shots. Will return an LRUD dimension or private double processSplaysArray( SurveyLeg splays[], int bestIdx, SurveySeries series ) { for ( int i = 0; i < upShots.size(); i++ ) { if ( i == bestIdx ) { //Found best up shot masterLeg.setUp( upShots.get(i).getLength() ); } else { //Other shots, add as splay SurveyLeg splayShot = new SurveyLeg(); splayShot.setFromStn( upShots.get(i).getFromStn() ); String toStn = upShots.get(i).getFromStn() + new Character( (char)stnLetterCode++ ).toString(); splayShot.setToStn( CaveConverter.stnNameToNumber( toStn, series ) ); splayShot.setLength( upShots.get(i).getLength() ); splayShot.setCompass( upShots.get(i).getCompass() ); splayShot.setClino( upShots.get(i).getClino() ); splayShot.setSplay( true ); series.addLeg( splayShot ); legCount++; } } } */ private void addSplayShot( SurveySeries series, SurveyLeg shot, int splayCount ){ //Generate station name suffix for splay (97 = letter 'a') int increment = splayCount - 1; //Zero based int stnLetterCode = 97; //97 = letter 'a' String stnSuffix = ""; if ( splayCount < 27 ) { stnSuffix = new Character( (char)(stnLetterCode + increment) ).toString(); } else { int primaryCount = (increment - 26) / 26; int secondaryCount = (increment % 26); stnSuffix = new Character( (char)(stnLetterCode + primaryCount) ).toString(); stnSuffix += new Character( (char)(stnLetterCode + secondaryCount) ).toString(); } //Add shot as a splay //TODO Stns names should be screened against legal character list, wherever it is that they are set SurveyLeg splayShot = shot.clone(); String toStn = shot.getFromStn().getName() + stnSuffix; splayShot.setToStn( UtilityFunctions.createStationFromNameForSeries( toStn, series ) ); splayShot.setLength( shot.getLength() ); splayShot.setCompass( shot.getCompass() ); splayShot.setClino( shot.getClino() ); splayShot.setSplay( true ); series.addLeg( splayShot ); } } CaveConverter_src/src/footleg/cavesurvey/tools/0000755000000000000000000000000012215572460020757 5ustar rootrootCaveConverter_src/src/footleg/cavesurvey/tools/UtilityFunctions.java0000644000000000000000000010255012216352566025165 0ustar rootroot/** * Copyright (C) 2009-2013 Paul Fretwell - aka 'Footleg' (drfootleg@gmail.com) * * This file is part of Cave Converter. * * Cave Converter is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation, either version 3 of the License, or * (at your option) any later version. * * Cave Converter is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with Cave Converter. If not, see . */ package footleg.cavesurvey.tools; import java.io.BufferedReader; import java.io.BufferedWriter; import java.io.File; import java.io.FileNotFoundException; import java.io.FileReader; import java.io.FileWriter; import java.io.IOException; import java.text.ParseException; import java.text.SimpleDateFormat; import java.util.ArrayList; import java.util.Arrays; import java.util.Calendar; import java.util.Date; import java.util.Iterator; import java.util.List; import java.util.ListIterator; import java.util.TimeZone; import footleg.cavesurvey.cmdline.CaveConverter; import footleg.cavesurvey.data.model.CaveSurvey; import footleg.cavesurvey.data.model.Equate; import footleg.cavesurvey.data.model.SurveyLeg; import footleg.cavesurvey.data.model.SurveySeries; import footleg.cavesurvey.data.model.SurveyStation; /** * Utility class for functions shared with other code in application. * * @author Footleg * @version 2013.09.18 (ISO 8601 YYYY.MM.DD) * @since 1.6 (The Java version used) */ public final class UtilityFunctions { public static final String POCKETTOPO_DATE_FORMAT = "yyyy/MM/dd"; public static final String SURVEXDATE_FORMAT = "yyyy.MM.dd"; //TODO Convert format codes to enum public static final char pocketTopoFormat = 'p'; public static final char dxfFormat = 'd'; public static final char survexFormat = 's'; public static final char toporobotFormat = 't'; public static final char compassFormat = 'c'; /** * Math function to calculate the average compass bearing from a set * of compass readings. The calculation used determines the sum of the * vectors. This is the equivalent of converting the bearings from unit * vectors each with a polar coordinate to x and y components, averaging * the x and y components to produce a resulting vector, and then taking * the polar coordinate bearing of that vector as the result. For a pair * of compass readings this average represents the mean direction of the * two survey legs. For a set of two or more readings it represents to * mean direction of all the bearings giving them equal weight. This is * different to the numerical average of several repeated readings of an * instrument (like 3 DistoX shots from PocketTopo), but the results are * the same (at a precision of two decimal places) for either averaging * method for sets of bearings with no more than 2 degrees variation * between the readings. * * @param bearings Array of compass bearings to calculate average from * @return Mean compass bearing in range 0-360 degrees */ public static double averageCompassBearings( double[] bearings ) { double meanBearing = 0.0; double accumulatorCos = 0.0; double accumulatorSin = 0.0; //Loop through all bearings for ( int bearingIdx = 0; bearingIdx < bearings.length; bearingIdx++ ) { //Convert bearing to radians Double bearing = Math.toRadians( bearings[bearingIdx] ); //Accumulate sum of sin and cos of bearings accumulatorCos += Math.cos(bearing); accumulatorSin += Math.sin(bearing); } double average_angle_atan2 = Math.atan2(accumulatorSin, accumulatorCos); meanBearing = Math.toDegrees(average_angle_atan2); //Adjust bearing to within range of 0-360 degrees return adjustBearingWithinDegreesRange( meanBearing, 0, 360 ); } /** * Adjusts a bearing in degrees to a value within the range given * @param bearing The bearing to adjust * @param min The minimum value to allow * @param max The lowest value to adjust down (adjusted bearing must be less than this value) * @return Bearing adjusted to within range given */ public static double adjustBearingWithinDegreesRange(double bearing, double min, double max) { double adjustedBearing = bearing; while ( adjustedBearing < min ) { adjustedBearing += 360; } while ( adjustedBearing >= max ) { adjustedBearing -= 360; } return adjustedBearing; } /** * Math function to calculate the difference between two compass bearings * @param angle1 * @param angle2 * @return */ public static double bearingDifference(double angle1, double angle2) { double dif = Math.abs(angle1 - angle2) % 360; if (dif > 180) dif = 360 - dif; return dif; } /** * Creates a new survey station for a series using a given name for the station. * * The name is mapped to a numerical station id using the series, and the station * is created with that id. If the name is already in use then the id will be the * same id as that used for the matching station in the series. * * @param stnName The name to give the new survey station * @param series The survey series which this station is going to be added to * @return New survey station object with an id mapped to the name for this series */ public static SurveyStation createStationFromNameForSeries( String stnName, SurveySeries series ) { SurveyStation stn = new SurveyStation( 0 ); stn.setName( stnName ); series.setStationIdFromName(stn); return stn; } /** * Date string parsing function to return a date type from a text representation of the date. * * @param dateString Text representation of a date * @param dateFormat Defines the format for the text representation of the date * @throws ParseException if the string is not a valid date * @return The date parsed from the string parameter */ public static Date stringToDate( String dateString, String dateFormat ) throws ParseException { Date dateVal; SimpleDateFormat sdf = new SimpleDateFormat(dateFormat); sdf.setTimeZone(TimeZone.getDefault()); dateVal = sdf.parse(dateString); return dateVal; } /** * Method which generates a string representing a given date. * * @param date The date to be converted to text * @param dateFormat Defines the format for the text representation of the date * @return Text representation of the date in the format requested */ public static String dateToString( Date date, String dateFormat ) { SimpleDateFormat sdf = new SimpleDateFormat(dateFormat); sdf.setTimeZone(TimeZone.getDefault()); return sdf.format( date ); } /** * Generates a string representing the date on the day the method * is called. * * @param dateFormat Defines the format for the text representation of the date * @return Text representation of today's date in the format requested */ public static String todaysDateAsString( String dateFormat ) { Calendar cal = Calendar.getInstance(TimeZone.getDefault()); Date dateTimeNow = cal.getTime(); return dateToString( dateTimeNow, dateFormat ); } /** * Converts a string list into a string of items from the list * separated with a given string * * @param list String list of items to convert to a string * @param separator String to separate items with in the output * @return Dot separated string of the items from the input list */ public static String stringListToDotSeparatedString( List list, String separator) { String items = ""; ListIterator primaryIterator = list.listIterator(); if ( primaryIterator.hasNext() ) { //First item items += primaryIterator.next(); } while ( primaryIterator.hasNext() ) { items += separator + primaryIterator.next(); } return items; } /** * Splits a string of data items separated by whitespace into an array of * individual data items. Tab and space characters are treated as * separators unless enclosed in quotes. * * @param dataString String of data items separated by white space * @return Array of data items extracted from the input data string */ public static List parseDataStringIntoDataItems( String dataString ) { List dataItems = new ArrayList(); String currItem = ""; boolean insideQuotes = false; //Parse input string character by character for (int i = 0; i < dataString.length(); i++) { //Check if inside quotes if ( insideQuotes ) { //Check for ending quotes if ( dataString.charAt(i) == '\"' ) { //End of item, so update array with data for this item dataItems.add( currItem ); //Reset for next item currItem = ""; insideQuotes = false; } else { //Non-quote, and non-whitespace character, so add to end of current item currItem += dataString.charAt(i); } } else if ( dataString.charAt(i) == '\"' ) { //Found start of new quoted data item insideQuotes = true; } else if ( dataString.charAt(i) == ' ' || dataString.charAt(i) == '\t' ) { //Found whitespace, check if this is the end of a data item if ( currItem.length() > 0 ) { //End of item, so update array with data for this item dataItems.add( currItem ); //Reset for next item currItem = ""; } } else { //Non-quote, and non-whitespace character, so add to end of current item currItem += dataString.charAt(i); } } //End of data, check if the last item was added if ( currItem.length() > 0 ) { //Last item, so update array with data for this item dataItems.add( currItem ); } return dataItems; } /** * Splits a comment string into comment lines, splitting at line separator * characters and removing enclosing quotes. * * @param comment Comment string to be parsed * @return Array of comment line from the input comment string */ public static String[] parseTripComment( String comment ) { String dataString = comment.replace("\\r", "\r"); String[] dataItems = dataString.split("\r"); return dataItems; } /** * Converts a list of equates gathered during file parsing into series links in the survey. * * A helper function shared by some of the data readers, which generate a list * of equate classes from equivalent stations in the input files. This method * matches these equates to series in the survey, and creates a series link in the * appropriate series to link the series to another series in the survey. * * @param equates ArrayList of equates to be processed * @param allSeries The cave survey to add the series links into */ public static void processEquates( List equates, CaveSurvey allSeries ) { //Process each of the equates in turn Iterator equateIterator = equates.listIterator(); while ( equateIterator.hasNext() ) { Equate equate = equateIterator.next(); //Find the series path in common between the equates and determine which is the inner series if nested String innerSeries; String outerSeries; String innerSeriesStn; String outerSeriesStn; if ( equate.getSeries1().length() > equate.getSeries2().length() ) { //First series is inner series to second series outerSeries = equate.getSeries2(); outerSeriesStn = equate.getStn2(); innerSeries = equate.getSeries1(); innerSeriesStn = equate.getStn1(); } else { //First series is same as or outer series to second series outerSeries = equate.getSeries1(); outerSeriesStn = equate.getStn1(); innerSeries = equate.getSeries2(); innerSeriesStn = equate.getStn2(); } //Find parent series, and remove path to it from the two series paths List outerHierarchy = new ArrayList(Arrays.asList(outerSeries.split("[.]"))); List innerHierarchy = new ArrayList(Arrays.asList(innerSeries.split("[.]"))); List parentHierarchy = new ArrayList(); boolean matching = true; while ( matching && (outerHierarchy.size() > 0 ) ) { if (outerHierarchy.get(0).equalsIgnoreCase( innerHierarchy.get(0) ) ) { //Common series name to both series in equate, so move to parent parentHierarchy.add( outerHierarchy.remove(0) ); innerHierarchy.remove(0); } else { matching = false; } } //Find innermost series which is a parent of the equates series SurveySeries liveSeries = null; // boolean dealtWithUnmatchedSeries = false; if ( parentHierarchy.size() > 0 ) { //Iterate over series names in parent path looking for matching inner most series ListIterator pathIterator = parentHierarchy.listIterator(); String liveName = pathIterator.next(); //First find the outer series for the outer path name ListIterator primaryIterator = allSeries.listIterator(); while ( primaryIterator.hasNext() ) { SurveySeries outermostSeries = primaryIterator.next(); if ( outermostSeries.getSeriesName().equalsIgnoreCase( liveName ) ) { //Go to next level in path liveSeries = outermostSeries; break; } else { //Not found, so keep looking matching = false; //Just here to allow breakpoint debugging } } //Did we find outer series? if ( liveSeries != null ) { //Now iterate over path looking for matching inner series for each level if ( pathIterator.hasNext() ) { liveSeries = findInnerSeriesByName( liveSeries, pathIterator); } //If we got here without any exceptions being thrown then we should have the correct parent series matching = true; //Just here to allow breakpoint debugging } else { //Failed to find matching outer series throw new RuntimeException( "Equate series outer name '" + liveName + "' did not match any cave name." ); } } else { //No parent in common which indicates that the link is invalid as one of //the series is not in the cave survey at all. //TODO Fix this for pockettopo imports where only part of a cave is present. Need a dummy link in this case. //This is no longer where the PocketTopo files raise an error. throw new RuntimeException( "Series in equate did not match any series name. Series1: '" + equate.getSeries1() + "'. Series2: '" + equate.getSeries2() + "'." ); //Check that at least one of the series matches a series name // int series1Idx = lookupSeriesIndexFromSeriesName( equate.getSeries1(), allSeries ); // if ( series1Idx >= 0 ) { // //Add link to series 1 // SurveyStation stn = createStationFromNameForSeries( equate.getStn1(), allSeries.get( series1Idx ) ); // SurveyStation fake = new SurveyStation( 0 ); // fake.setName( equate.getStn2() ); // allSeries.get( series1Idx ).addLink( equate.getSeries1(), stn, equate.getSeries2(), fake ); // dealtWithUnmatchedSeries = true; // } // else { // int series2Idx = lookupSeriesIndexFromSeriesName( equate.getSeries2(), allSeries ); // if ( series2Idx >= 0 ) { // //Add link to series 2 // SurveyStation stn = createStationFromNameForSeries( equate.getStn2(), allSeries.get( series2Idx ) ); // SurveyStation fake = new SurveyStation( 0 ); // fake.setName( equate.getStn1() ); // allSeries.get( series2Idx ).addLink( equate.getSeries1(), fake, equate.getSeries2(), stn ); // dealtWithUnmatchedSeries = true; // } // } } //By here, live series is the parent series for both equates. //The outer and inner hierarchies indicate the paths to the inner series from this point if ( liveSeries != null ) { String equatePart1; SurveySeries part1Series; SurveyStation stn1 = null; if ( outerHierarchy.isEmpty() ) { equatePart1 = ""; part1Series = liveSeries; stn1 = createStationFromNameForSeries( outerSeriesStn, part1Series ); } else { equatePart1 = stringListToDotSeparatedString( outerHierarchy, "."); try { part1Series = findInnerSeriesByName( liveSeries, outerHierarchy.listIterator() ); stn1 = createStationFromNameForSeries( outerSeriesStn, part1Series ); } catch (RuntimeException ex) { //PocketTopo files often have equates to stations in series not in the file stn1 = new SurveyStation( 0 ); stn1.setName( equate.getStn1() ); } } String equatePart2; SurveySeries part2Series; SurveyStation stn2 = null; if ( innerHierarchy.isEmpty() ) { equatePart2 = ""; part2Series = liveSeries; stn2 = createStationFromNameForSeries( innerSeriesStn, part2Series ); } else { equatePart2 = stringListToDotSeparatedString( innerHierarchy, "."); try { part2Series = findInnerSeriesByName( liveSeries, innerHierarchy.listIterator() ); stn2 = createStationFromNameForSeries( innerSeriesStn, part2Series ); } catch (RuntimeException ex) { //PocketTopo files often have equates to stations in series not in the file stn2 = new SurveyStation( 0 ); stn2.setName( equate.getStn2() ); } } //Put link into the parent series of the two linked series liveSeries.addLink(equatePart1, stn1, equatePart2, stn2); } else { //No parent series found for this equate throw new RuntimeException( "Equate series are not inside same series. Series1: '" + equate.getSeries1() + "'. Series2: '" + equate.getSeries2() + "'." ); } } } /** * * @param outerSeries * @param pathIterator * @return */ private static SurveySeries findInnerSeriesByName( SurveySeries outerSeries, ListIterator pathIterator) { SurveySeries liveSeries = outerSeries; //Now iterate over path looking for matching inner series for each level while ( pathIterator.hasNext() ) { String liveName = pathIterator.next(); liveSeries = liveSeries.findInnerSeriesByName( liveName ); if (liveSeries == null ) { //Failed to match a series at this level throw new RuntimeException( "Equate series name '" + liveName + "' did not match any inner series name." ); } } return liveSeries; } public static void logSurveyDebugData( CaveSurvey allSeries ) { //Debug dump CaveConverter.logMessage("============================ Cave Survey Data Summary ============================"); CaveConverter.logMessage("Survey contains " + allSeries.size() + " top level series."); for (int i = 0; i < allSeries.size(); i++ ) { logSurveySeriesSummary( allSeries.get(i), "" ); } } private static void logSurveySeriesSummary( SurveySeries series, String seriesParent ) { String fullSeriesPath = seriesParent + series.getSeriesName(); String message = "Series: " + fullSeriesPath; if ( series.legCount() > 0 ) { message += " (" + series.legCount() + " legs)"; } if ( series.innerSeriesCount() > 0 ) { message += " (contains " + series.innerSeriesCount() + " child series)"; } CaveConverter.logMessage( message ); //Recursively log details of inner series for (int i = 0; i < series.innerSeriesCount(); i++ ) { logSurveySeriesSummary( series.getInnerSeries(i), fullSeriesPath + "/" ); } } /** * Reads a text file and builds an ArrayList of strings, one for each line * of the file. * * @param inputFile File to be read * @return ArrayList of strings, one for each line of the input filename */ public static List readTextFile( File inputFile ) { List dataLines = new ArrayList(); BufferedReader bufferedReader = null; try { bufferedReader = new BufferedReader( new FileReader( inputFile ) ); String text; while ( ( text = bufferedReader.readLine() ) != null) { dataLines.add( text ); } } catch (FileNotFoundException ex) { CaveConverter.logMessage( ex.getMessage() ); } catch (IOException ex) { CaveConverter.logMessage( ex.getMessage() ); } finally { if ( bufferedReader != null ) { try { bufferedReader.close(); } catch (IOException ex) { CaveConverter.logMessage( ex.getMessage() ); } } } return dataLines; } /** * Write a text file from the data in an ArrayList of strings, one line * in the file per string in the List. * * @param fileContents ArrayList of strings, one for each line of the input filename * @param fileName Full path and name of file to be written * @return Error message if write failed, or empty string if success */ public static String writeTextFile (List fileContents, String fileName) { String error = ""; BufferedWriter textWriter = null; try { //Create file writer textWriter = new BufferedWriter( new FileWriter(fileName) ); //Write strings from list to the file Iterator iterator = fileContents.listIterator(); while ( iterator.hasNext() ) { String line = iterator.next(); if ( iterator.hasNext() ) { textWriter.write( line + System.getProperty("line.separator") ); } else { textWriter.write( line ); } } } catch (IOException ex) { error = "Error writing file: " + ex.getLocalizedMessage(); } finally { if ( textWriter != null ) { try { textWriter.close(); } catch (IOException ex) { error = "Error closing file: " + ex.getLocalizedMessage(); } } } return error; } /** * Checks for station in the series being built. If found then adding this leg would mean the * series looped back onto itself, which we cannot do in Toporobot format. * @param iter Iterator for the list of stations already added to the series * @param checkStn The station to check for in the series being built up * @return True if station is found in the list cache */ private static boolean checkForLoopback( ListIterator iter, SurveyStation checkStn ) { boolean loopDetected = false; while ( iter.hasNext() ) { if ( checkStn.getId() == iter.next().getId() ) { loopDetected = true; break; } } return loopDetected; } /** * Checks for a station in all the series so far, to avoid series crossing other series in * the middle of each other, as TopoRobot format cannot support links of this sort. * @param caveSoFar * @param checkStn * @return */ private static boolean checkForCrossover( SurveySeries caveSoFar, SurveyStation checkStn ) { boolean crossingDetected = false; ListIterator seriesIter = caveSoFar.getInnerSeriesList().listIterator(); while ( seriesIter.hasNext() ) { //Check for station in all legs bar the final one in this series SurveySeries series = seriesIter.next(); for ( int i=0; i < series.legCount() - 1; i++ ) { SurveyLeg leg = series.getLegRaw(i); //Check leg to station as from station in first leg starts series //so not a crossover, and all other from stations are also to stations if ( checkStn.getId() == leg.getToStn().getId() ) { crossingDetected = true; i = series.legCount(); } } if ( crossingDetected == true ) { break; } } return crossingDetected; } /** * Splits a single survey series into a list of series without branches or loops. * The input series must not contain any nested series. The output series will * contain one or more inner series and the links between them, but no legs itself. * This method requires that any survey station can be identified by it's ID alone, * so stations with different names but the same ID are assumed to be the same station. * * TODO Somewhere in here is a bug which allows series to be linked together in unconnected * groups. It happens when two series are linked to each other via the same station. The * link is in effect duplicated, rather than one of the series being linked to another part of * the cave. There is also an issue that both ends of the series do not get linked to the * rest of the cave. Sometimes both the start and end stations are linked to another series * but only one of these links is created in the toporobot file. * * @param seriesIn A survey series which contains branches * @return A series containing one or more inner series, all linked by their first * stations to one of the other series. All series will be linear chains. */ public static SurveySeries convertToLinearSeries( SurveySeries seriesIn ) { SurveySeries outputSeries = new SurveySeries( seriesIn.getSeriesName() ); //Check the input series contain no inner series if ( seriesIn.innerSeriesCount() > 0 ) { throw new RuntimeException( "Nested series cannot be converted to linear chains." ); } //Loop through all the legs creating inner series of linear chains until all legs are //handled or remaining legs cannot be linked to any other legs. boolean legsRemain = true; while (legsRemain) { //Create a new series to start building a new linear chain SurveySeries series = new SurveySeries( seriesIn.getSeriesName() ); series.setCalibrationFromAnotherSeries( seriesIn ); //Create cache of all stations used to check for loops back onto stations already used List seriesStns = new ArrayList(); //Initialise last station flag to invalid id int lastStnId = -999; //Loop through all remaining legs and add connected legs to new series int addedLegsCount = 0; boolean legsAdded = true; //Initialise true to get into first pass of loops //Keep looping over all remaining legs until no more are being added to this series while ( legsAdded ) { legsAdded = false; //Reset int i = 0; while ( i < seriesIn.legCount() ) { int initialInnerAddedLegCount = addedLegsCount; SurveyLeg curLeg = seriesIn.getLegRaw(i); //Check if first leg for new series (always add), or leg follows last leg added if ( ( series.legCount() == 0 ) || ( lastStnId == curLeg.getFromStn().getId() ) ) { //Check that 'to' station has not already been used in the series boolean loopDetected = checkForLoopback( seriesStns.listIterator(), curLeg.getToStn() ); if (loopDetected == false) { boolean crossDetected = false; if ( series.legCount() > 0 ) { //Only check for cross over if not first station in a new series crossDetected = checkForCrossover( outputSeries, curLeg.getFromStn() ); } if (crossDetected == false) { //Add leg to end of series series.addLeg(curLeg); //Update last stn lastStnId = curLeg.getToStn().getId(); //Increment added legs count addedLegsCount++; //Add new station from this leg into stations cache seriesStns.add( curLeg.getToStn() ); } } } else if ( curLeg.getToStn().getId() == series.getLegRaw(0).getFromStn().getId() ) { //Leg fits on start of series, so insert at beginning if not looping back onto series //Check that 'from' station has not already been used in the series boolean loopDetected = checkForLoopback( seriesStns.listIterator(), curLeg.getFromStn() ); if (loopDetected == false) { boolean crossDetected = checkForCrossover( outputSeries, curLeg.getToStn() ); if (crossDetected == false) { series.addLeg(curLeg, 0); //Increment added legs count addedLegsCount++; //Add new station from this leg into stations cache seriesStns.add( curLeg.getFromStn() ); } } } if (initialInnerAddedLegCount < addedLegsCount ) { //Leg was added, so remove from input series seriesIn.removeLeg(i); //Update flag to indicate a leg has been added legsAdded = true; } else { //Leg was not used, so increment index to test next leg i++; } } } //Check whether any legs were added to this series (if not then exit) if ( series.legCount() > 0 ) { /* * New series created, set name from to station of first leg (fromStn name has often been changed by equating) * up to the last dot, and add the series index to ensure series name is unique */ String originalSeriesStn2Name = seriesIn.getMappedStnName( series.getLegRaw(0).getToStn().getId() ); //Base new series name on parent series and station name String originalSeriesName = seriesIn.getSeriesName() + "-" + originalSeriesStn2Name; int dotPos = originalSeriesStn2Name.lastIndexOf("."); if ( dotPos > 0 ) { //Station name has a series name prefix, so use this in preference to parent series name originalSeriesName = originalSeriesStn2Name.substring(0, dotPos ); } series.setSeriesName( (outputSeries.innerSeriesCount() + 1) + "-" + originalSeriesName ); //Add to list outputSeries.addSeries(series); } else { //No legs were processed on last pass, so exit the loop legsRemain = false; } } //Check that all legs were moved into output series if ( seriesIn.legCount() > 0 ) { throw new RuntimeException( "Some legs could not be linked to other legs in the series." ); } //Now loop through all the series and for each one match the start //station to a station in another series CaveConverter.logMessage( "Linking series:" ); for ( int searchIdx = 0; searchIdx < outputSeries.innerSeriesCount(); searchIdx++ ) { SurveySeries seriesToLink = outputSeries.getInnerSeries(searchIdx); //Get first and last stns SurveyStation firstStn = seriesToLink.getLegRaw(0).getFromStn(); SurveyStation endStn = seriesToLink.getLegRaw( seriesToLink.legCount() - 1 ).getToStn(); //Check all the other series for station matching the start station for this series int matchingIdx = findStationMatchingIdInInnerSeries(firstStn.getId(), searchIdx, outputSeries); if ( matchingIdx > -1 ){ CaveConverter.logMessage( "Series: " + outputSeries.getInnerSeries(searchIdx).getSeriesName() + " start stn linked to " + outputSeries.getInnerSeries(matchingIdx).getSeriesName() ); //Found match, so add link to parent series outputSeries.addLink(outputSeries.getInnerSeries(searchIdx).getSeriesName(), firstStn, outputSeries.getInnerSeries(matchingIdx).getSeriesName(), firstStn); } // else { /* * Need to check for end stn matches even if a start station link was found or loops are never closed * and sets of series can be created which are not connected to other sets. * TODO The commented out else block fixes the links not being set, but now a series which * starts where another series ends is linked twice, once in each direction. We should add a method * to the series class to check if a link already exists, and only add these links if not already defined * in the reverse direction. */ //No links to start of this series, so check if end station matches matchingIdx = findStationMatchingIdInInnerSeries(endStn.getId(), searchIdx, outputSeries); if ( matchingIdx > -1 ){ CaveConverter.logMessage( "Series: " + outputSeries.getInnerSeries(searchIdx).getSeriesName() + " end stn linked to " + outputSeries.getInnerSeries(matchingIdx).getSeriesName() ); //Found match, so need to reverse this series and add a link for it //No need to reverse as we now support end links outputSeries.getInnerSeries(searchIdx).reverseSeries(); outputSeries.addLink(outputSeries.getInnerSeries(searchIdx).getSeriesName(), endStn, outputSeries.getInnerSeries(matchingIdx).getSeriesName(), endStn); } // } } return outputSeries; } /** * Looks for an inner series with a station which matches the id given, and if found * then returns the index of that inner series. An index of an inner series to * exclude can be provided, to prevent a series being matched to itself. */ private static int findStationMatchingIdInInnerSeries(int id, int excludeSeriesIdx, SurveySeries series){ int matchingIdx = -1; ListIterator innerItr = series.getInnerSeriesList().listIterator(); int checkIdx = -1; while ( matchingIdx == -1 && innerItr.hasNext() ) { SurveySeries check = innerItr.next(); checkIdx++; //Do not check against the same series as ourself if ( excludeSeriesIdx != checkIdx ) { //Loop through legs in check series for ( int legIdx = 0; legIdx < check.legCount(); legIdx++ ) { SurveyLeg leg = check.getLegRaw(legIdx); //Looking for matching stations if ( id == leg.getFromStn().getId() ) { //Found match to a from station matchingIdx = checkIdx; break; } else if ( id == leg.getToStn().getId() ) { //Found match to a to stn matchingIdx = checkIdx; break; } } } } return matchingIdx; } } CaveConverter_src/src/footleg/cavesurvey/cmdline/0000755000000000000000000000000012165540164021232 5ustar rootrootCaveConverter_src/src/footleg/cavesurvey/cmdline/CaveConverter.java0000644000000000000000000002371112171756234024653 0ustar rootroot/** * Copyright (C) 2009-2013 Paul Fretwell - aka 'Footleg' (drfootleg@gmail.com) * * This file is part of Cave Converter. * * Cave Converter is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation, either version 3 of the License, or * (at your option) any later version. * * Cave Converter is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with Cave Converter. If not, see . */ package footleg.cavesurvey.cmdline; import java.io.File; import java.text.DecimalFormat; import java.text.ParseException; import java.text.SimpleDateFormat; import java.util.ArrayList; import java.util.Calendar; import java.util.Date; import java.util.List; import java.util.TimeZone; import footleg.cavesurvey.data.model.CaveSurvey; import footleg.cavesurvey.data.reader.DxfParser; import footleg.cavesurvey.data.reader.PocketTopoParser; import footleg.cavesurvey.data.reader.SurvexParser; import footleg.cavesurvey.data.writer.CompassWriter; import footleg.cavesurvey.data.writer.SurvexWriter; import footleg.cavesurvey.data.writer.TopoRobotWriter; import footleg.cavesurvey.tools.UtilityFunctions; /** * Command line application for converting cave survey data from one file format to another. * Currently it can read some survex files, text export files from PocketTopo and DXF format * data. It can write toporobot and survex files. * * @author Footleg * @version 2013.07.18 (ISO 8601 YYYY.MM.DD) * @since 1.6 (The Java version used) */ public class CaveConverter { private static List log = new ArrayList(); private static final String filePath = "./"; private static Date today; public static String newline = System.getProperty("line.separator"); /** * Command line options for True, False or 'Use Default' */ public enum CmdlineOpt { T, F, D } /** * @param args Command line arguments */ public static void main( String[] args ) { //Default input and output filenames String inputFilename = "input.svx"; String outputFilename = "output.text"; char inputFormat = 'x'; //x = not valid char outputFormat = 'x'; //x = not valid //Set date if not already set if ( today == null ) { //Set date to todays datetime Calendar cal = Calendar.getInstance(TimeZone.getDefault()); today = cal.getTime(); } //Check for arguments if (args.length > 0) { //Set input filename from 1st argument inputFilename = args[0]; if (args.length > 1) { //Set output filename from 2nd argument outputFilename = args[1]; if (args.length > 2) { //Set input format from 3rd argument try { inputFormat = parseSingleCharacterArgument( args[2] ); if (args.length > 3) { //Set input format from 4th argument outputFormat = parseSingleCharacterArgument( args[3] ); //Set options flags from 5th argument onwards CmdlineOpt splaysOpt = CmdlineOpt.D; CmdlineOpt genLRUDOpt = CmdlineOpt.F; for (int iOpts = 4; iOpts < args.length; iOpts++ ) { if ( args[iOpts].compareToIgnoreCase("nosplays") == 0 ) { splaysOpt = CmdlineOpt.F; } else if ( args[iOpts].compareToIgnoreCase("splays") == 0 ) { splaysOpt = CmdlineOpt.T; } if ( args[iOpts].compareToIgnoreCase("lrud") == 0 ) { genLRUDOpt = CmdlineOpt.T; } } //Call file convert method convertFile(inputFilename, outputFilename, inputFormat, outputFormat, splaysOpt, genLRUDOpt ); } } catch (ParseException e) { //Log error e.printStackTrace(); } } } } } public static void setToday(Date date) { CaveConverter.today = date; } /** * Parses a string argument into a single character. * * @param argument String to be converting into a single character * @throws ParseException If the argument is not a single string */ private static char parseSingleCharacterArgument( String argument ) throws ParseException { char[] chars = argument.toCharArray(); char argChar = 'x'; if ( chars.length == 1 ) { argChar = chars[0]; } else { ParseException e = new ParseException("Failed to parse argument to single character. " + "Argument was '" + argument + "'.", 1); throw e; } return argChar; } /** * Reads in a survey data file and converts it to another format which is written out to a file. * * @param inputFilename Name and location of file to be converted * @param outputFilename Name and location of file to be output * @param inputFormat Format of input file * @param outputFormat Format of file to be generated * @param splaysOpt Indicates if a splays output option was set to True, False or to use default for writer (T,F,D) * @param generateLRUDOpt Indicates whether to generate LRUD data from splays before writing out data * @throws ParseException */ public static void convertFile( String inputFilename, String outputFilename, char inputFormat, char outputFormat, CmdlineOpt splaysOpt, CmdlineOpt generateLRUDOpt ) throws ParseException { //Declare structure to hold survey data CaveSurvey surveyData = null; //Read input data file CaveConverter.logMessage( "Reading data file: " + inputFilename ); List fileData = UtilityFunctions.readTextFile( new File( inputFilename ) ); //Parse file data if ( inputFormat == UtilityFunctions.survexFormat ) { //Parse Survex data SurvexParser parser = new SurvexParser(); surveyData = parser.parseSurvexFile( fileData ); } else if ( inputFormat == UtilityFunctions.pocketTopoFormat ) { //Parse PocketTopo data PocketTopoParser parser = new PocketTopoParser(); surveyData = parser.parseFile( fileData ); } else if ( inputFormat == UtilityFunctions.dxfFormat ) { //Parse Autocad DXF data polylines into survey series DxfParser parser = new DxfParser(); surveyData = parser.parseFile(fileData, 0); } else { //Unsupported input format argument logMessage("Unsupported input format argument: " + inputFormat + " is not a valid input format."); } //Set options flag for generating LRUD data boolean generateLRUD = false; if (generateLRUDOpt == CmdlineOpt.T) { generateLRUD = true; } //Generate LRUD data if required if ( generateLRUD ) { surveyData.generateLRUDfromSplays(); } //Convert data to output format List outputData = null; if ( surveyData != null ) { if ( outputFormat == UtilityFunctions.compassFormat ) { //Generate Compass format data CompassWriter writer = new CompassWriter(); outputData = writer.generateCompassData( surveyData ); } else if ( outputFormat == UtilityFunctions.survexFormat ) { //Set options flag for splays (default to true) boolean outputSplays = true; if (splaysOpt == CmdlineOpt.F) { outputSplays = false; } //Generate Survex format data SurvexWriter writer = new SurvexWriter(); outputData = writer.generateSurvexData( surveyData, outputSplays ); } else if ( outputFormat == UtilityFunctions.toporobotFormat ) { //Set options flag for splays (default to false) boolean outputSplays = false; if (splaysOpt == CmdlineOpt.T) { outputSplays = true; } //Generate Toporobot format data TopoRobotWriter writer = new TopoRobotWriter(); outputData = writer.generateToporobotData( surveyData, today, outputSplays ); } else { //Unsupported output format argument logMessage("Unsupported output format argument: " + outputFormat + " is not a valid output format."); } } //Write output file if ( outputData.size() > 0 ) { String outputFilePath = filePath + outputFilename; CaveConverter.logMessage( "Writing output file: " + outputFilePath ); String error = UtilityFunctions.writeTextFile(outputData, outputFilePath); if ( error.length() > 0 ) { logMessage( error ); } } //Write log file UtilityFunctions.writeTextFile(log, filePath + "CaveConverter.log"); } /** * logMessage * * Formats message with date time stamp, then outputs to console and log */ public static void logMessage( String message ) { String logLine; Calendar cal = Calendar.getInstance(TimeZone.getDefault()); String DATE_FORMAT = "yyyy-MM-dd HH:mm:ss"; SimpleDateFormat sdf = new SimpleDateFormat(DATE_FORMAT); sdf.setTimeZone(TimeZone.getDefault()); logLine = sdf.format(cal.getTime()) + ": " + message; log.add( logLine ); System.out.println(logLine); } public static String padNumber(int num, int padWidth) { String numStr = "" + num; return padString(numStr,padWidth); } public static String padNumber(double num, int decPlaces, int padWidth) { String formatStr = "0."; for (int i = 0; i < decPlaces; i++) { formatStr += '0'; } DecimalFormat formatter = new DecimalFormat(formatStr); return padString(formatter.format(num), padWidth); } public static String padString(String data, int padWidth) { String padded; //Pad number with spaces if not already as wide as pad width if ( data.length() < padWidth ) { //Pad with lots of spaces padded = " " + data; //then trim to padded width padded = padded.substring(padded.length() - padWidth); } else { //Already wide enough, so just return as is padded = data; } return padded; } } CaveConverter_src/test/0000755000000000000000000000000012242136246014152 5ustar rootrootCaveConverter_src/test/data/0000755000000000000000000000000012242136246015063 5ustar rootrootCaveConverter_src/test/data/regression/0000755000000000000000000000000012242136246017243 5ustar rootrootCaveConverter_src/test/data/regression/T_LRUD_ps_ref.svx0000644000000000000000000000572412242133266022403 0ustar rootroot*BEGIN T *BEGIN 1 *DATE 2004.11.06 *FLAGS SPLAY 0 0a 2.22 155.07 -6.40 0 0b 1.84 133.24 -87.58 0 0c 8.97 68.59 -7.44 0 0d 6.07 262.41 7.25 *FLAGS NOT SPLAY 1 0 3.75 38.83 16.00 *FLAGS SPLAY 1 1a 0.66 132.46 -9.51 1 1b 1.35 120.54 81.60 1 1c 0.62 321.23 5.67 *FLAGS NOT SPLAY 2 1 2.85 359.77 -44.11 *FLAGS SPLAY 2 2a 3.73 262.13 3.55 2 2b 1.87 298.42 4.42 2 2c 1.40 3.96 7.32 2 2d 1.31 98.59 10.72 2 2e 0.70 19.12 79.66 2 2f 0.57 207.27 -82.52 *FLAGS NOT SPLAY 3 2 3.21 356.28 -10.33 *FLAGS SPLAY 3 3a 0.40 16.10 55.83 3 3b 0.97 228.49 32.14 3 3c 13.32 292.75 53.20 3 3d 0.67 121.73 88.40 3 3e 1.59 41.18 2.58 *FLAGS NOT SPLAY 4 3 3.14 296.29 4.60 *FLAGS SPLAY 4 4a 0.49 325.93 86.36 4 4b 0.99 45.65 8.48 4 4c 1.04 216.58 8.20 *FLAGS NOT SPLAY 5 4 2.04 315.42 14.57 *FLAGS SPLAY 5 5a 1.00 303.58 78.66 5 5b 1.08 132.05 9.66 5 5c 1.05 12.79 14.14 5 5d 0.93 257.40 8.73 *FLAGS NOT SPLAY 6 5 4.43 247.02 6.24 *FLAGS SPLAY 6 6a 1.13 291.01 83.64 6 6b 0.55 343.52 0.66 6 6c 0.38 169.34 1.97 *FLAGS NOT SPLAY 7 6 4.30 270.59 -2.57 *FLAGS SPLAY 7 7a 0.46 338.63 5.07 7 7b 0.31 257.49 86.93 7 7c 0.52 32.05 -88.23 *FLAGS NOT SPLAY 8 7 2.54 232.91 16.90 *FLAGS SPLAY 8 8a 0.91 135.16 86.15 8 8b 0.28 70.02 7.81 8 8c 0.32 289.59 3.66 *FLAGS NOT SPLAY 9 8 2.44 161.69 1.32 *FLAGS SPLAY 9 9a 0.28 50.74 -0.39 9 9b 0.82 141.52 82.58 9 9c 0.52 232.22 4.93 9 9d 2.24 331.35 37.29 *FLAGS NOT SPLAY 10 9 1.30 83.75 4.89 *FLAGS SPLAY 10 10a 0.28 144.57 81.81 10 10b 0.42 206.99 -3.70 10 10c 0.22 17.73 11.54 10 10d 0.51 309.96 -84.07 10 10e 0.86 132.99 -0.15 *FLAGS NOT SPLAY 11 10 1.49 113.13 8.65 *FLAGS SPLAY 11 11a 0.35 91.22 81.36 11 11b 1.54 55.43 73.20 11 11c 0.22 14.46 0.99 11 11d 0.71 293.51 -84.27 11 11e 2.28 294.59 -29.60 *FLAGS NOT SPLAY 12 5 3.52 19.55 -12.66 *FLAGS SPLAY 12 12a 1.08 313.28 85.16 12 12b 0.31 223.51 1.01 12 12c 0.93 80.12 6.52 12 12d 0.59 125.92 -83.93 *FLAGS NOT SPLAY 13 12 4.50 319.93 -1.59 *FLAGS SPLAY 13 13a 0.84 13.20 79.99 13 13b 0.15 68.57 6.43 13 13c 0.61 248.49 12.06 *FLAGS NOT SPLAY 14 13 2.95 10.30 -15.72 *FLAGS SPLAY 14 14a 0.77 55.88 0.37 14 14b 0.58 331.51 80.78 14 14c 0.55 135.86 -86.18 14 14d 0.13 239.04 4.24 *FLAGS NOT SPLAY 14 15 2.82 146.44 -9.17 *data passage station left right up down 11 0.22 0.00 0.35 0.71 10 0.21 0.49 0.28 0.51 9 0.85 0.49 0.81 0.00 8 0.22 0.32 0.91 0.00 7 0.00 0.46 0.31 0.52 6 0.38 0.55 1.12 0.00 5 0.92 0.62 0.98 0.00 4 1.03 0.96 0.49 0.00 3 4.41 1.53 0.67 0.00 2 3.70 1.27 0.69 0.57 1 0.52 0.60 1.34 0.00 0 4.15 4.41 0.00 1.84 *data passage station left right up down 14 0.12 0.71 0.57 0.55 13 0.59 0.15 0.83 0.00 12 0.25 0.92 1.08 0.59 5 0.92 0.62 0.98 0.00 *END 1 *END T CaveConverter_src/test/data/regression/SwilEnt_ss_cmdsl_ref.svx0000644000000000000000000012564412242115744024131 0ustar rootroot*BEGIN Swildons *EQUATE Ent EntranceZigZags.3 *EQUATE surfacegps.4 EntranceZigZags.3 *EQUATE LongDryWay.0 EntranceZigZags.5 *EQUATE LongDryWay.5 EntranceZigZags.21 *EQUATE LongDryWay.5 ShortDryWay.pt1.0 *EQUATE LongDryWay.39 NewGrottoes.0 *EQUATE LongDryWay.62 OldGrotto2WC.4 *EQUATE LongDryWay.59 OldGrotto2WC.0 *EQUATE LongDryWay.59 ShortDryWay.pt2.3 *EQUATE WaterRift.0 OldGrotto2WC.11 *EQUATE WaterRift.4 FortyRoute.0 *EQUATE WaterRift.12 FortyRoute.11 *EQUATE 10.0 LongDryWay.8 *EQUATE 10.20 LongDryWay.2 *EQUATE 10.13 20.20 *EQUATE 10.18 20.27 *EQUATE 20.0 EntranceZigZags.5 *EQUATE 20.23 ShortDryWay.pt1.3 *EQUATE 20.19 EntranceZigZags.5 *BEGIN surfacegps *DATE 2013.06.30 *CALIBRATE declination 1.58 *FLAGS SURFACE 0 1 9.84 94.37 -5.88 1 2 7.84 97.65 -8.05 2 3 11.76 94.27 -17.67 3 4 4.38 7.38 -23.29 3 5 5.45 262.93 13.06 5 6 8.80 174.95 11.61 6 7 13.78 168.31 12.55 *END surfacegps *BEGIN EntranceZigZags *DATE 2012.09.09 *CALIBRATE declination 1.7 *FLAGS SURFACE 0 1 2.98 10.26 -2.01 0 2 5.24 3.23 -5.04 *FLAGS SPLAY 2 2a 5.24 182.16 5.06 2 2b 1.89 187.97 3.09 2 2c 1.91 168.82 1.18 2 2d 1.38 218.59 -0.17 2 2e 0.64 248.05 1.54 2 2f 0.68 105.32 -3.30 2 2g 1.56 140.40 -2.98 2 2h 1.84 176.52 -47.48 2 2i 1.82 167.81 -47.93 2 2j 1.54 189.90 -63.97 2 2k 1.61 132.31 -59.62 *FLAGS NOT SPLAY 2 3 2.64 166.70 -60.11 *FLAGS NOT SURFACE SPLAY 3 3a 0.22 345.81 60.30 3 3b 2.63 347.89 60.51 3 3c 0.94 9.90 76.67 3 3d 0.31 232.08 12.34 3 3e 0.35 31.05 10.29 3 3f 0.47 8.50 -70.77 *FLAGS NOT SPLAY 3 4 3.10 330.76 -25.13 *FLAGS SPLAY 4 4a 3.12 152.39 25.35 4 4b 0.56 208.59 -0.68 4 4c 0.59 140.67 80.22 4 4d 1.32 189.06 -86.08 4 4e 1.50 43.79 87.42 *FLAGS NOT SPLAY 4 5 4.51 275.80 -12.10 *FLAGS SPLAY 5 5a 4.51 94.74 12.12 5 5b 3.45 123.81 5.64 5 5c 3.51 134.15 0.14 5 5d 6.66 129.46 11.11 5 5e 2.32 149.61 -6.69 5 5f 1.64 153.47 -11.17 5 5g 0.79 252.58 -12.22 5 5h 1.22 296.10 -7.82 5 5i 2.96 296.71 -23.02 5 5j 1.51 42.54 10.51 5 5k 4.24 72.82 11.85 5 5l 0.70 333.90 81.49 5 5m 0.55 114.68 -67.13 *FLAGS NOT SPLAY 5 6 2.41 50.67 -22.33 *FLAGS SPLAY 6 6a 2.38 230.76 22.40 6 6b 0.35 2.58 81.25 6 6c 0.30 220.39 -79.38 6 6d 0.51 299.09 -0.90 6 6e 0.21 108.28 1.25 *FLAGS NOT SPLAY 6 7 1.08 37.30 11.53 *FLAGS SPLAY 7 7a 1.09 217.24 -12.21 7 7b 0.80 327.16 66.53 7 7c 4.12 176.11 -83.10 7 7d 0.72 287.69 -77.51 7 7e 0.60 292.40 -18.76 7 7f 2.02 100.10 16.73 *FLAGS NOT SPLAY 7 8 2.00 6.10 11.51 *FLAGS SPLAY 8 8a 2.00 184.82 -11.17 8 8b 1.47 98.32 -7.52 8 8c 0.19 105.24 52.84 8 8d 1.24 102.22 -61.02 8 8e 0.88 109.39 0.40 *FLAGS NOT SPLAY 8 9 1.01 56.60 0.18 *FLAGS SPLAY 9 9a 1.02 236.71 -0.46 9 9b 0.48 12.78 64.51 9 9c 0.60 279.77 -8.53 9 9d 0.47 275.64 -73.34 *FLAGS NOT SPLAY 9 10 3.07 336.52 5.81 *FLAGS SPLAY 10 10a 3.08 156.19 -6.26 10 10b 0.58 232.61 -1.43 10 10c 1.31 64.76 -58.36 10 10d 1.43 101.23 -11.90 10 10e 1.14 78.33 -36.92 *FLAGS NOT SPLAY 9 11 2.42 64.64 5.29 *FLAGS SPLAY 11 11a 2.42 245.35 -5.41 11 11b 0.44 233.11 24.20 11 11c 0.20 42.71 -21.97 11 11d 0.45 239.67 46.05 11 11e 0.49 178.37 -53.68 11 11f 3.30 118.39 17.88 *FLAGS NOT SPLAY 11 12 4.50 106.56 19.29 *FLAGS SPLAY 12 12a 0.25 297.10 84.93 12 12b 0.26 127.16 -84.07 12 12c 0.60 197.87 18.66 12 12d 1.17 327.17 -9.65 12 12e 1.63 13.18 -2.28 12 12f 1.86 96.76 12.16 10 10f 3.76 209.97 51.34 *FLAGS NOT SPLAY 10 13 0.94 80.55 -45.63 *FLAGS SPLAY 13 13a 0.94 259.78 45.32 13 13b 0.84 97.15 56.57 13 13c 1.16 144.82 14.01 13 13d 0.48 130.78 -25.41 13 13e 0.58 324.87 25.54 *FLAGS NOT SPLAY 13 14 5.31 65.16 19.50 *FLAGS SPLAY 14 14a 5.82 246.22 -19.66 14 14b 0.64 206.92 -10.28 14 14c 0.54 185.33 -53.51 14 14d 0.21 279.32 69.67 14 14e 2.09 161.86 8.15 14 14f 0.85 285.98 -13.42 *FLAGS NOT SPLAY 10 15 3.27 329.15 -18.16 *FLAGS SPLAY 15 15a 3.25 149.02 17.88 15 15b 0.77 63.28 -13.22 15 15c 0.70 243.58 79.61 15 15d 0.80 97.26 -82.81 15 15e 2.37 233.98 -23.81 15 15f 0.94 168.26 10.56 *FLAGS NOT SPLAY 15 16 3.57 334.08 -6.33 *FLAGS SPLAY 16 16a 3.58 154.40 6.43 16 16b 0.29 52.63 -10.96 16 16c 0.70 63.17 -62.51 16 16d 0.73 221.54 2.28 16 16e 1.82 250.10 55.64 16 16f 0.86 237.55 47.64 16 16g 0.86 195.09 5.98 *FLAGS NOT SPLAY 16 17 2.41 207.98 -9.43 *FLAGS SPLAY 17 17a 2.40 28.72 9.44 17 17b 1.55 24.59 -70.16 17 17c 1.33 336.78 -9.34 17 17d 0.48 26.59 -33.63 17 17e 0.66 83.59 13.58 17 17f 1.67 193.75 -23.62 *FLAGS NOT SPLAY 17 18 4.05 308.01 -19.25 *FLAGS SPLAY 18 18a 4.05 128.34 19.12 18 18b 1.54 155.56 12.30 18 18c 0.60 300.02 2.80 18 18d 0.28 261.46 65.07 18 18e 0.68 182.87 -85.38 *FLAGS NOT SPLAY 18 19 2.06 211.48 -16.06 *FLAGS SPLAY 19 19a 2.04 31.72 16.13 19 19b 0.55 320.99 71.97 19 19c 1.54 308.22 -85.39 19 19d 0.46 306.67 -13.63 *FLAGS NOT SPLAY 19 20 2.94 233.55 -35.84 *FLAGS SPLAY 20 20a 2.95 53.57 35.69 20 20b 0.98 64.26 12.43 20 20c 0.93 44.01 13.78 20 20d 1.56 84.07 80.29 20 20e 1.62 301.40 -84.42 *FLAGS NOT SPLAY 20 21 2.04 14.57 -39.09 *FLAGS SPLAY 21 21a 2.04 195.35 38.69 21 21b 1.80 235.96 12.16 21 21c 0.21 339.46 -76.92 21 21d 0.34 53.17 3.81 21 21e 3.17 230.10 64.31 *FLAGS NOT SPLAY *data passage station left right up down 3 0.30 0.38 0.91 0.44 4 0.56 0.00 1.50 1.32 5 1.98 4.15 0.69 0.51 6 0.49 0.19 0.35 0.29 7 0.57 1.89 0.73 4.09 8 0.00 1.34 0.15 1.08 9 0.37 0.00 0.43 0.45 11 0.13 1.70 0.32 0.39 12 1.63 0.57 0.25 0.26 *data passage station left right up down 9 0.59 0.00 0.43 0.45 10 0.54 2.34 2.94 1.12 13 0.50 1.07 0.70 0.21 14 0.54 2.05 0.20 0.43 *data passage station left right up down 10 1.97 1.10 2.94 1.12 15 2.15 0.75 0.69 0.79 16 0.83 0.18 1.50 0.62 17 1.38 1.29 0.00 1.46 18 1.46 0.39 0.25 0.68 19 0.00 0.44 0.52 1.54 20 0.00 0.89 1.54 1.61 21 1.16 0.21 2.86 0.20 *END EntranceZigZags *BEGIN LongDryWay *DATE 2013.02.23 *CALIBRATE declination 1.63 *EQUATE 44 46 *FLAGS SPLAY 0 0a 0.57 190.50 0.73 0 0b 0.67 258.82 80.80 0 0c 1.35 2.03 3.08 0 0d 0.56 96.94 -85.13 0 0e 4.05 271.96 -24.99 0 0f 4.25 271.79 -25.07 *FLAGS NOT SPLAY 0 1 4.08 270.72 -25.50 *FLAGS SPLAY 1 1a 1.99 51.56 -3.25 1 1b 0.46 105.97 80.16 1 1c 1.51 94.64 -80.82 1 1d 4.22 97.98 -2.77 1 1e 3.40 122.23 -12.40 1 1f 3.13 150.51 -15.80 1 1g 6.66 142.47 -10.55 *FLAGS NOT SPLAY 1 2 3.77 354.35 -29.81 *FLAGS SPLAY 2 2a 0.66 241.86 -8.20 2 2b 1.94 85.48 -81.67 2 2c 0.59 61.84 0.46 2 2d 0.74 236.38 81.47 2 2e 1.67 66.88 -56.31 2 2f 1.30 149.63 -32.25 *FLAGS NOT SPLAY 2 3 4.33 336.10 -24.79 *FLAGS SPLAY 3 3a 1.20 273.33 77.00 3 3b 0.46 54.65 1.29 3 3c 0.19 248.98 6.64 3 3d 0.49 67.19 -81.38 3 3e 0.44 244.00 2.33 *FLAGS NOT SPLAY 3 4 2.77 337.70 -4.41 *FLAGS SPLAY 4 4a 1.44 45.43 -70.35 4 4b 0.50 246.88 -7.75 4 4c 2.23 271.73 60.68 *FLAGS NOT SPLAY 4 5 3.14 343.71 -25.59 *FLAGS SPLAY 5 5a 0.31 68.00 4.55 5 5b 0.23 200.44 -82.34 5 5c 3.01 212.74 65.59 5 5d 1.83 228.77 1.96 5 5e 2.24 149.67 -4.84 5 5f 1.07 119.80 -19.64 *FLAGS NOT SPLAY 5 6 1.87 332.43 6.50 *FLAGS SPLAY 6 6a 0.33 85.05 2.16 6 6b 0.81 234.74 4.03 6 6c 0.46 76.22 -85.16 6 6d 1.31 224.58 20.79 6 6e 2.65 233.44 69.74 *FLAGS NOT SPLAY 6 7 2.26 343.32 -5.29 *FLAGS SPLAY 7 7a 0.51 89.65 -82.84 7 7b 0.44 225.38 -8.27 7 7c 1.81 226.26 51.07 *FLAGS NOT SPLAY 7 8 1.72 258.62 12.28 *FLAGS SPLAY 8 8a 0.79 122.45 -3.92 8 8b 0.82 125.25 -80.01 8 8c 1.02 113.36 59.45 *FLAGS NOT SPLAY 7 9 1.10 310.47 4.46 *FLAGS SPLAY 9 9a 0.57 99.03 -87.47 9 9b 0.90 250.68 3.72 9 9c 0.88 233.37 70.96 9 9d 0.60 60.03 -19.66 *FLAGS NOT SPLAY 9 10 2.37 334.59 4.19 *FLAGS SPLAY 10 10a 0.26 51.75 0.96 10 10b 0.43 43.34 -88.13 10 10c 0.44 235.87 0.68 10 10d 2.30 241.44 71.10 *FLAGS NOT SPLAY 10 11 1.12 263.77 46.91 *FLAGS SPLAY 11 11a 0.64 52.79 1.87 11 11b 1.45 190.34 76.03 11 11c 0.98 0.32 -83.36 *FLAGS NOT SPLAY 11 12 3.53 351.74 -3.89 *FLAGS SPLAY 12 12a 0.83 261.49 10.43 12 12b 1.01 249.00 60.34 *FLAGS NOT SPLAY 12 13 1.97 312.50 39.30 *FLAGS SPLAY 13 13a 0.91 98.78 -1.21 13 13b 0.46 59.54 83.75 13 13c 1.07 62.56 -71.75 *FLAGS NOT SPLAY 13 14 2.39 28.12 3.33 *FLAGS SPLAY 14 14a 1.53 267.21 -13.19 14 14b 0.59 261.25 -82.95 14 14c 0.50 137.83 73.72 *FLAGS NOT SPLAY 14 15 0.86 306.09 -13.02 *FLAGS SPLAY 15 15a 0.46 78.21 4.93 15 15b 0.65 248.76 6.64 15 15c 0.41 265.85 -88.54 15 15d 0.40 124.70 82.35 15 15e 0.47 23.47 0.91 *FLAGS NOT SPLAY 15 16 4.55 48.38 7.37 *FLAGS SPLAY 16 16a 2.92 223.69 -3.46 16 16b 3.00 236.59 2.01 16 16c 1.64 276.31 -3.03 16 16d 0.90 237.99 72.78 16 16e 1.59 109.59 -71.63 16 16f 2.40 204.15 -9.08 16 16g 1.26 254.43 2.93 *FLAGS NOT SPLAY 16 17 2.34 328.01 -9.83 *FLAGS SPLAY 17 17a 1.50 103.75 -2.42 17 17b 1.22 173.37 80.16 *FLAGS NOT SPLAY 17 18 2.65 86.23 -7.24 *FLAGS SPLAY 18 18a 2.10 185.84 6.37 18 18b 0.40 223.80 82.63 18 18c 0.51 10.73 10.61 18 18d 0.52 174.98 -79.44 *FLAGS NOT SPLAY 18 19 0.84 146.67 18.49 *FLAGS SPLAY 19 19a 1.39 43.52 3.89 19 19b 0.51 159.85 17.51 19 19c 0.40 97.95 87.19 *FLAGS NOT SPLAY 19 20 1.81 87.93 13.23 *FLAGS SPLAY 20 20a 0.60 43.10 4.22 20 20b 1.64 208.49 63.28 20 20c 0.87 209.39 -0.95 *FLAGS NOT SPLAY 20 21 1.73 164.45 7.33 *FLAGS SPLAY 21 21a 0.68 33.20 4.40 21 21b 1.20 234.09 82.95 21 21c 0.25 41.06 -84.36 *FLAGS NOT SPLAY 21 22 2.91 113.95 7.56 *FLAGS SPLAY 22 22a 1.33 255.18 77.95 22 22b 0.88 220.17 0.04 22 22c 0.40 136.32 -85.39 22 22d 2.39 358.28 2.05 22 22e 4.28 320.27 -8.84 *FLAGS NOT SPLAY 22 23 1.51 181.21 30.14 *FLAGS SPLAY 23 23a 0.20 214.51 -9.54 23 23b 1.26 55.54 -74.20 23 23c 0.38 35.19 9.16 23 23d 0.40 243.28 88.13 23 23e 1.79 34.58 -40.94 *FLAGS NOT SPLAY 23 24 4.59 108.18 -8.18 *FLAGS SPLAY 24 24a 2.12 27.47 19.01 24 24b 1.44 265.31 83.06 24 24c 2.74 209.33 20.17 24 24d 3.06 204.37 31.06 24 24e 2.70 172.96 38.49 24 24f 2.76 119.14 44.68 24 24g 4.29 105.49 35.63 24 24h 3.31 94.03 37.41 24 24i 3.41 321.99 7.71 *FLAGS NOT SPLAY 24 25 3.22 188.75 35.45 *FLAGS SPLAY 25 25a 1.17 228.03 4.30 25 25b 2.44 342.35 79.94 25 25c 0.87 172.80 80.92 25 25d 0.37 33.36 9.50 25 25e 4.18 97.27 36.04 *FLAGS NOT SPLAY 25 26 4.13 139.60 16.69 *FLAGS SPLAY 26 26a 0.48 231.41 -0.43 26 26b 0.56 131.73 89.68 26 26c 1.15 13.53 28.43 26 26d 0.53 146.88 -77.01 26 26e 3.06 118.05 16.64 *FLAGS NOT SPLAY 25 27 4.94 97.33 39.05 *FLAGS SPLAY 27 27a 0.53 73.50 39.91 27 27b 2.86 145.99 24.42 27 27c 2.08 181.17 14.96 27 27d 3.64 159.34 16.76 *FLAGS NOT SPLAY 24 28 2.78 323.60 -24.94 *FLAGS SPLAY 28 28a 2.01 240.61 79.48 28 28b 1.17 150.81 -80.16 28 28c 0.42 153.56 -10.07 *FLAGS NOT SPLAY 28 29 0.89 90.00 -48.92 *FLAGS SPLAY 29 29a 0.66 345.81 68.52 29 29b 0.74 153.15 1.62 29 29c 0.65 303.35 1.69 29 29d 1.17 85.81 -77.61 29 29e 1.26 23.75 -19.21 *FLAGS NOT SPLAY 29 30 6.28 324.60 -29.83 *FLAGS SPLAY 30 30a 1.95 224.71 72.46 30 30b 1.49 213.57 5.25 30 30c 0.32 52.79 6.31 30 30d 0.43 224.41 -83.42 *FLAGS NOT SPLAY 30 31 1.55 264.23 41.75 *FLAGS SPLAY 31 31a 1.18 36.18 2.86 31 31b 1.41 7.15 4.71 31 31c 0.98 76.71 80.67 31 31d 0.43 206.64 4.65 31 31e 1.50 164.76 -87.26 *FLAGS NOT SPLAY 31 32 2.26 15.83 12.57 *FLAGS SPLAY 32 32a 0.88 258.32 -39.46 32 32b 0.41 254.53 -1.76 32 32c 0.62 258.09 37.38 32 32d 0.76 1.51 -83.57 *FLAGS NOT SPLAY 32 35 6.03 323.45 -41.61 31 34 5.13 314.22 -30.46 *FLAGS SPLAY 34 34a 1.81 117.94 6.32 34 34b 1.67 169.45 73.19 34 34c 0.78 104.73 -65.15 *FLAGS NOT SPLAY 34 35 2.76 19.79 -19.74 *FLAGS SPLAY 35 35a 3.60 249.79 75.43 35 35b 0.58 4.89 17.88 35 35c 1.23 222.29 3.93 *FLAGS NOT SPLAY 35 36 4.45 91.00 26.23 *FLAGS SPLAY 36 36a 2.37 172.41 2.46 36 36b 2.48 280.23 82.99 36 36c 1.17 0.68 7.77 36 36d 0.38 351.51 -81.72 36 36e 4.81 16.95 43.97 *FLAGS NOT SPLAY 36 37 6.61 112.79 18.69 *FLAGS SPLAY 37 37a 2.77 143.57 88.42 37 37b 1.24 47.17 8.65 37 37c 2.20 237.64 2.14 37 37d 0.52 23.20 -72.57 *FLAGS NOT SPLAY 37 38 3.92 158.52 22.40 *FLAGS SPLAY 38 38a 2.57 265.36 79.77 38 38b 1.77 258.21 76.02 38 38c 0.83 188.45 -87.34 38 38d 1.09 247.04 2.21 38 38e 1.13 47.31 -9.21 *FLAGS NOT SPLAY 38 39 5.06 158.54 15.55 *FLAGS SPLAY 39 39a 0.81 95.41 80.83 39 39b 0.36 243.34 -2.19 39 39c 1.36 68.36 1.57 39 39d 0.31 143.52 -87.32 39 39e 2.22 37.38 14.64 39 39f 1.24 124.14 29.01 39 39g 1.52 169.90 20.43 39 39h 3.17 184.03 6.76 *FLAGS NOT SPLAY 39 40 3.30 137.29 35.75 *FLAGS SPLAY 40 40a 0.41 330.85 80.32 40 40b 0.72 24.63 16.27 40 40c 0.43 242.41 10.73 *FLAGS NOT SPLAY 40 41 1.54 156.92 21.03 *FLAGS SPLAY 41 41a 1.17 313.23 86.69 41 41b 0.76 273.70 17.56 41 41c 1.15 52.78 9.22 *FLAGS NOT SPLAY 41 42 1.23 188.42 54.13 *FLAGS SPLAY 42 42a 0.31 20.21 65.90 42 42b 0.56 64.53 1.80 42 42c 0.25 246.58 30.01 42 42d 1.21 119.22 24.03 *FLAGS NOT SPLAY 35 43 7.82 271.86 -10.72 *FLAGS SPLAY 43 43a 2.96 340.05 72.39 43 43b 0.62 18.69 7.95 43 43c 0.66 202.11 10.96 43 43d 1.72 172.80 -79.05 *FLAGS NOT SPLAY 43 44 1.58 132.75 -54.76 43 45 4.22 283.16 -3.82 *FLAGS SPLAY 45 45a 0.26 5.45 2.81 45 45b 0.92 147.26 -80.05 45 45c 2.17 187.63 77.31 45 45d 1.42 144.48 74.70 45 45e 1.03 171.63 2.41 46 46a 1.17 359.83 20.74 46 46b 1.04 279.77 44.73 *FLAGS NOT SPLAY 46 47 4.08 278.14 -22.89 *FLAGS SPLAY 47 47a 1.17 175.15 69.16 47 47b 0.66 146.16 -60.94 47 47c 0.96 181.60 1.29 *FLAGS NOT SPLAY 47 48 1.62 127.59 7.41 *FLAGS SPLAY 48 48a 0.32 222.85 -13.13 48 48b 0.43 203.78 77.03 48 48c 0.71 106.46 -84.42 48 48d 6.38 143.21 1.27 48 48e 9.20 143.56 0.28 *FLAGS NOT SPLAY 45 49 2.40 265.00 1.41 *FLAGS SPLAY 49 49a 2.28 354.04 78.68 49 49b 0.52 198.25 -1.65 49 49c 0.89 19.99 9.05 49 49d 0.71 358.32 -81.38 49 49e 3.78 142.08 -59.73 *FLAGS NOT SPLAY 49 50 2.06 297.62 28.08 *FLAGS SPLAY 50 50a 0.69 36.66 83.53 50 50b 0.46 191.30 6.20 50 50c 0.76 186.66 -84.09 *FLAGS NOT SPLAY 50 51 2.38 317.24 16.74 *FLAGS SPLAY 51 51a 0.35 91.28 79.27 51 51b 0.67 44.19 5.41 51 51c 1.90 251.77 -12.45 51 51d 4.01 13.33 -82.25 *FLAGS NOT SPLAY 51 52 2.80 335.01 -5.36 *FLAGS SPLAY 52 52a 2.10 212.50 -9.20 52 52b 0.66 156.09 88.10 52 52c 1.10 206.43 -87.82 52 52d 0.70 140.09 -4.62 *FLAGS NOT SPLAY 52 53 8.00 77.58 15.81 52 54 2.99 251.79 -11.14 *FLAGS SPLAY 54 54a 1.50 7.07 14.17 54 54b 4.94 156.76 -77.22 54 54c 1.38 326.54 73.27 *FLAGS NOT SPLAY 54 55 2.75 287.69 -14.31 *FLAGS SPLAY 55 55a 0.48 212.28 8.16 55 55b 1.78 2.22 0.72 55 55c 1.25 356.97 51.33 55 55d 4.84 0.83 -70.83 55 55e 2.30 347.76 56.75 *FLAGS NOT SPLAY 55 56 6.04 280.29 -11.16 *FLAGS SPLAY 56 56a 2.58 173.80 -9.68 56 56b 0.91 210.62 72.78 56 56c 5.52 258.49 -78.70 56 56d 1.22 355.76 -2.47 *FLAGS NOT SPLAY 56 57 4.72 167.79 -69.81 *FLAGS SPLAY 57 57a 5.53 35.74 84.02 57 57b 1.48 358.49 5.81 57 57c 0.71 175.94 -0.18 57 57d 0.76 90.98 -86.28 *FLAGS NOT SPLAY 57 58 6.26 266.27 3.98 *FLAGS SPLAY 58 58a 0.91 320.07 6.44 58 58b 2.54 289.66 73.92 58 58c 2.05 155.98 1.05 58 58d 0.77 137.62 -73.53 58 58e 4.37 86.04 -33.48 *FLAGS NOT SPLAY 58 59 5.34 221.34 -28.43 *FLAGS SPLAY 59 59a 5.41 309.94 9.33 59 59b 1.86 144.63 3.09 59 59c 3.04 302.62 79.62 59 59d 0.68 132.99 -79.35 59 59e 4.71 353.28 -42.52 59 59f 2.89 67.97 28.72 59 59g 2.49 85.86 13.93 59 59h 2.95 112.78 22.54 59 59i 1.83 207.67 8.62 59 59j 5.28 237.30 -3.61 59 59k 5.32 272.91 -3.40 59 59l 3.22 8.05 23.97 *FLAGS NOT SPLAY 59 60 3.64 249.87 -18.27 *FLAGS SPLAY 60 60a 2.91 98.61 33.34 60 60b 4.04 127.08 30.32 60 60c 3.55 153.59 27.64 60 60d 5.46 181.97 11.17 60 60e 2.54 10.68 -16.02 60 60f 3.08 23.70 -10.67 60 60g 4.51 196.88 -31.47 *FLAGS NOT SPLAY 60 61 6.14 188.00 -36.35 *FLAGS SPLAY 61 61a 0.93 109.00 -3.73 61 61b 4.46 154.64 72.91 61 61c 3.27 191.41 -82.47 *FLAGS NOT SPLAY 61 62 1.04 31.64 -42.73 *data passage station left right up down 0 0.56 1.35 0.66 0.56 1 1.13 1.96 0.45 1.49 2 0.64 0.92 0.73 1.92 3 0.44 0.45 1.17 0.48 4 1.02 0.00 1.94 1.36 5 1.73 0.62 2.74 0.23 6 1.12 0.32 2.49 0.46 7 1.10 0.00 1.41 0.51 8 0.55 0.00 0.88 0.81 *data passage station left right up down 7 1.12 0.00 1.41 0.51 9 0.85 0.56 0.83 0.57 10 0.39 0.24 2.18 0.43 11 0.00 0.62 1.41 0.97 12 0.77 0.00 0.88 0.00 13 0.00 0.86 0.46 1.02 14 1.47 0.00 0.48 0.59 15 0.61 0.45 0.40 0.41 16 2.24 0.00 0.86 1.51 17 0.00 1.46 1.20 0.00 18 0.48 1.95 0.40 0.51 19 1.33 0.33 0.40 0.00 20 0.59 0.86 1.46 0.00 21 0.65 0.00 1.19 0.25 22 1.22 0.84 1.30 0.40 23 1.27 0.19 0.40 1.21 24 3.04 1.76 1.43 0.00 25 3.11 1.05 0.86 0.00 26 1.08 0.48 0.56 0.52 *data passage station left right up down 25 2.42 1.16 0.86 0.00 27 0.16 3.08 0.34 0.00 *data passage station left right up down 24 1.76 3.04 1.43 0.00 28 0.00 0.00 1.98 1.15 29 0.65 0.60 0.61 1.14 30 1.46 0.28 1.86 0.43 31 0.39 1.14 0.97 1.50 32 0.68 0.00 0.38 0.76 35 0.55 0.93 3.48 0.00 36 3.45 2.23 2.46 0.38 37 1.23 2.15 2.77 0.50 38 1.04 1.09 2.53 0.83 39 2.01 1.86 0.80 0.31 40 0.58 0.42 0.40 0.00 41 0.98 0.71 1.17 0.00 42 1.03 0.18 0.28 0.00 *data passage station left right up down 31 0.43 1.37 0.97 1.50 34 0.00 1.36 1.60 0.71 35 0.93 0.55 3.48 0.00 43 0.63 0.60 2.82 1.69 45 1.00 0.26 2.12 0.91 49 1.24 0.87 2.24 0.70 50 0.41 0.00 0.69 0.76 51 1.79 0.65 0.34 3.97 52 1.39 0.00 0.66 1.10 54 0.00 1.44 1.32 4.82 55 0.45 1.74 1.92 4.57 56 0.00 0.91 0.87 5.41 57 0.47 0.00 5.50 0.76 58 2.05 0.88 2.44 0.74 59 2.29 5.14 2.99 0.67 60 3.49 1.16 1.60 2.35 61 0.00 0.00 4.26 3.24 *data passage station left right up down 46 0.00 1.08 0.73 0.00 47 0.00 0.00 1.09 0.58 48 0.00 2.53 0.42 0.71 *END LongDryWay *BEGIN ShortDryWay *EQUATE pt1.13 pt2.0 *BEGIN pt1 *DATE 2013.02.24 *CALIBRATE declination 1.63 0 1 1.43 131.61 -13.25 *FLAGS SPLAY 1 1a 1.42 311.07 12.80 1 1b 0.58 327.33 -0.57 1 1c 0.94 171.13 -6.41 1 1d 0.50 258.56 -34.18 *FLAGS NOT SPLAY 1 2 3.89 73.29 -51.63 *FLAGS SPLAY 2 2a 3.91 252.77 52.00 2 2b 0.91 252.72 -4.04 2 2c 0.80 250.31 -35.24 2 2d 2.44 239.99 47.81 *FLAGS NOT SPLAY 2 3 4.50 170.72 19.68 *FLAGS SPLAY 3 3a 4.46 350.50 -20.39 3 3b 0.46 71.39 -4.30 3 3c 0.39 251.63 -13.19 3 3d 1.54 358.12 82.08 3 3e 0.94 170.44 -79.46 3 3f 0.45 220.38 -6.59 *FLAGS NOT SPLAY 3 4 1.11 246.49 -14.16 *FLAGS SPLAY 4 4a 0.68 212.13 -85.64 4 4b 0.28 4.71 4.35 4 4c 0.60 345.93 65.79 4 4d 2.84 294.88 -9.50 *FLAGS NOT SPLAY 2 5 4.91 323.66 2.34 *FLAGS SPLAY 5 5a 4.91 143.73 -2.57 5 5b 0.74 236.15 -6.85 5 5c 0.87 46.77 -82.61 5 5d 1.68 227.27 67.16 5 5e 1.03 103.39 -8.81 5 5f 2.18 148.83 -2.53 *FLAGS NOT SPLAY 5 6 5.05 279.35 -25.23 *FLAGS SPLAY 6 6a 5.05 99.27 25.32 6 6b 0.58 34.79 1.49 6 6c 1.16 111.26 -85.03 6 6d 2.83 16.27 74.62 6 6e 2.60 99.05 2.63 6 6f 2.79 105.09 4.91 *FLAGS NOT SPLAY 6 7 5.02 336.36 -13.85 *FLAGS SPLAY 7 7a 5.00 156.87 13.29 7 7b 0.41 231.77 -3.06 7 7c 3.73 254.43 80.33 7 7d 0.54 182.41 -84.02 7 7e 2.55 328.39 -82.67 *FLAGS NOT SPLAY 7 8 3.19 303.08 -33.11 *FLAGS SPLAY 8 8a 3.21 123.01 33.05 8 8b 0.53 23.07 -5.56 8 8c 4.46 353.35 80.60 8 8d 1.45 224.40 -78.95 8 8e 1.87 72.08 1.35 *FLAGS NOT SPLAY 8 9 6.71 295.69 -12.15 *FLAGS SPLAY 9 9a 6.72 115.55 11.83 9 9b 0.56 196.48 2.10 9 9c 1.16 244.84 81.25 9 9d 1.09 201.63 -76.54 9 9e 3.56 117.58 -4.92 *FLAGS NOT SPLAY 9 10 1.11 265.93 2.35 *FLAGS SPLAY 10 10a 1.10 86.87 -3.67 10 10b 0.45 26.25 1.63 10 10c 1.16 88.18 -83.85 10 10d 0.84 103.85 84.38 *FLAGS NOT SPLAY 10 11 4.30 323.22 3.80 *FLAGS SPLAY 11 11a 4.28 143.46 -4.52 11 11b 0.57 212.81 2.62 11 11c 2.07 237.99 81.23 11 11d 1.72 204.15 -67.89 *FLAGS NOT SPLAY 11 12 3.28 275.99 -17.30 *FLAGS SPLAY 12 12a 3.28 96.34 17.39 12 12b 0.52 17.73 -1.02 12 12c 0.81 128.05 -86.09 12 12d 1.79 345.81 78.34 *FLAGS NOT SPLAY 12 13 4.68 298.00 -3.29 *FLAGS SPLAY 13 13a 4.68 118.39 3.00 13 13b 0.57 34.60 -3.75 13 13c 0.38 17.11 84.09 13 13d 0.72 158.62 -86.15 13 13e 2.72 321.69 70.91 *FLAGS NOT SPLAY *data passage station left right up down 0 0.00 0.00 0.00 0.00 1 0.41 0.87 0.00 0.28 2 0.00 1.63 1.81 0.46 3 0.31 0.26 1.53 0.92 4 0.00 2.09 0.55 0.68 *data passage station left right up down 2 1.63 0.00 1.81 0.46 5 1.00 0.32 1.55 0.86 6 0.00 1.25 2.73 1.16 7 0.41 0.00 3.68 0.54 8 0.00 1.37 4.40 1.42 9 1.02 0.00 1.15 1.06 10 0.00 0.45 0.84 1.15 11 0.64 0.00 2.05 1.59 12 0.00 0.52 1.75 0.81 13 0.00 0.57 0.38 0.72 *END pt1 *BEGIN pt2 *DATE 2013.02.24 *CALIBRATE declination 1.63 *FLAGS SPLAY 0 0a 0.57 34.03 -0.51 0 0b 0.76 110.14 -85.72 0 0c 2.74 327.08 86.41 *FLAGS NOT SPLAY 0 1 3.20 316.66 0.98 *FLAGS SPLAY 1 1a 3.22 136.76 -1.39 1 1b 0.57 38.38 3.06 1 1c 1.47 103.34 -84.18 1 1d 2.40 260.62 87.93 *FLAGS NOT SPLAY 1 2 7.10 308.84 -15.08 *FLAGS SPLAY 2 2a 7.10 128.55 14.54 2 2b 0.66 194.88 1.13 2 2c 2.89 349.78 82.91 2 2d 0.88 179.54 -65.42 *FLAGS NOT SPLAY 2 3 4.24 278.91 -12.53 *FLAGS SPLAY 3 3a 4.21 98.44 12.28 3 3b 3.16 81.24 88.43 3 3c 0.77 354.83 -84.93 *FLAGS NOT SPLAY *data passage station left right up down 0 0.00 0.56 2.73 0.76 1 0.00 0.57 2.40 1.46 2 0.65 0.00 2.87 0.80 3 0.00 0.00 3.16 0.77 *END pt2 *END ShortDryWay *BEGIN NewGrottoes *DATE 2013.02.24 *CALIBRATE declination 1.63 0 1 1.56 49.36 7.27 *FLAGS SPLAY 1 1a 0.50 331.16 9.17 1 1b 0.40 271.22 77.61 1 1c 0.73 254.64 -87.94 1 1d 0.61 352.02 40.11 1 1e 0.56 43.52 51.47 *FLAGS NOT SPLAY 1 2 1.75 10.53 51.20 *FLAGS SPLAY 2 2a 1.76 189.76 -51.66 2 2b 0.29 258.50 0.35 2 2c 0.88 338.65 -79.23 2 2d 0.70 150.96 76.26 *FLAGS NOT SPLAY 2 3 4.07 347.52 12.12 *FLAGS SPLAY 3 3a 4.11 169.15 -12.51 3 3b 4.10 169.13 -12.74 3 3c 1.83 347.89 14.57 3 3d 0.96 250.24 -6.20 3 3e 0.41 84.04 87.54 3 3f 0.44 216.05 -86.92 3 3g 0.82 148.72 -10.96 3 3h 1.22 190.30 -16.89 *FLAGS NOT SPLAY 3 4 3.62 50.60 25.22 *FLAGS SPLAY 4 4a 3.63 230.43 -25.57 4 4b 0.43 348.10 4.44 4 4c 1.63 170.52 -5.86 4 4d 0.89 61.11 -81.94 4 4e 2.11 344.82 -7.61 *FLAGS NOT SPLAY 4 5 3.25 67.67 12.62 *FLAGS SPLAY 5 5a 3.28 247.14 -13.26 5 5b 0.25 323.66 84.61 5 5c 0.95 170.46 5.78 5 5d 2.13 330.90 -6.07 5 5e 0.77 222.68 -84.36 *FLAGS NOT SPLAY 5 6 3.45 56.57 19.52 *FLAGS SPLAY 6 6a 3.49 237.94 -19.53 6 6b 1.42 154.07 -15.19 6 6c 0.56 71.63 -87.16 6 6d 0.62 341.85 -3.41 6 6e 2.15 233.89 -20.79 6 6f 4.02 168.54 2.89 6 6g 2.44 124.70 10.45 6 6h 1.87 106.22 14.43 6 6i 2.75 182.55 1.05 *FLAGS NOT SPLAY 6 7 1.42 151.95 -12.13 *FLAGS SPLAY 7 7a 1.42 329.66 11.34 7 7b 1.55 42.07 39.53 7 7c 3.00 180.55 4.65 7 7d 0.89 354.61 85.36 7 7e 0.44 28.33 -87.65 *FLAGS NOT SPLAY 7 8 6.30 84.91 26.43 *FLAGS SPLAY 8 8a 0.81 355.74 6.08 8 8b 0.32 173.04 9.98 8 8c 0.19 349.50 82.00 8 8d 0.36 157.86 -75.31 *FLAGS NOT SPLAY *data passage station left right up down 0 0.00 0.00 0.00 0.00 1 0.42 0.08 0.39 0.73 2 0.29 0.00 0.68 0.86 3 0.92 0.62 0.41 0.44 4 2.01 1.51 0.00 0.88 5 2.12 0.90 0.25 0.77 6 0.52 3.62 0.00 0.56 7 1.16 2.64 0.89 0.44 8 0.81 0.31 0.19 0.35 *END NewGrottoes *BEGIN OldGrotto2WC *DATE 2013.02.24 *CALIBRATE declination 1.63 0 1 3.32 25.03 -14.33 *FLAGS SPLAY 1 1a 3.26 206.41 14.30 1 1b 0.98 315.03 -8.83 1 1c 0.76 174.77 -0.38 1 1d 2.49 219.51 -12.94 1 1e 1.90 280.22 -27.03 *FLAGS NOT SPLAY 1 2 5.70 255.27 -30.20 *FLAGS SPLAY 2 2a 5.71 74.10 29.84 2 2b 1.06 162.52 -1.36 2 2c 1.22 220.20 80.94 2 2d 0.39 332.89 1.22 2 2e 1.14 198.72 -82.80 *FLAGS NOT SPLAY 2 3 3.09 201.53 -10.26 *FLAGS SPLAY 3 3a 3.10 20.12 10.18 3 3b 1.30 263.57 -6.52 3 3c 0.93 284.07 -86.47 3 3d 0.93 75.35 -2.53 3 3e 0.32 234.48 85.69 *FLAGS NOT SPLAY 3 4 4.55 164.72 -15.92 *FLAGS SPLAY 4 4a 4.52 344.84 15.77 4 4b 0.61 258.46 -2.19 4 4c 0.63 86.33 -2.22 4 4d 5.53 284.88 86.05 4 4e 2.47 181.69 -82.25 *FLAGS NOT SPLAY 4 5 2.38 199.29 -26.79 *FLAGS SPLAY 5 5a 2.37 18.11 26.15 5 5b 0.82 318.06 0.68 5 5c 0.73 143.34 2.75 5 5d 5.25 191.96 83.34 5 5e 1.53 247.03 -88.07 *FLAGS NOT SPLAY 5 6 6.29 239.56 -9.79 *FLAGS SPLAY 6 6a 6.26 58.58 9.67 6 6b 1.26 349.18 -5.78 6 6c 1.45 42.58 -84.89 6 6d 0.23 174.05 2.52 6 6e 4.36 340.22 65.14 *FLAGS NOT SPLAY 6 7 7.66 284.16 -7.14 *FLAGS SPLAY 7 7a 7.65 104.12 6.94 7 7b 1.11 184.42 -3.02 7 7c 1.22 315.42 -87.56 7 7d 5.90 284.36 87.68 *FLAGS NOT SPLAY 7 8 2.58 224.20 -8.54 *FLAGS SPLAY 8 8a 2.58 43.16 8.82 8 8b 1.49 307.59 -0.90 8 8c 5.16 259.48 81.94 8 8d 1.06 108.65 -87.34 *FLAGS NOT SPLAY 8 9 6.80 205.89 -6.51 *FLAGS SPLAY 9 9a 6.77 24.81 6.09 9 9b 1.40 71.99 -5.17 9 9c 3.44 82.58 71.46 9 9d 1.27 18.89 -83.92 *FLAGS NOT SPLAY 9 10 2.09 108.56 -5.31 *FLAGS SPLAY 10 10a 2.12 289.79 4.09 10 10b 1.18 243.19 -9.20 10 10c 1.15 300.27 -85.48 10 10d 5.46 281.63 67.93 *FLAGS NOT SPLAY 10 11 7.85 204.84 6.96 *FLAGS SPLAY 11 11a 7.85 23.37 -7.47 11 11b 4.04 20.69 -17.03 11 11c 4.08 31.33 -11.00 11 11d 3.58 122.93 1.76 11 11e 5.02 146.17 5.40 11 11f 3.82 258.28 -10.90 11 11g 3.95 291.06 -0.53 11 11h 5.88 341.35 -3.35 11 11i 6.54 332.39 -2.75 11 11j 3.22 124.37 87.58 11 11k 1.02 81.55 -78.82 *FLAGS NOT SPLAY *data passage station left right up down 0 0.00 0.00 0.00 0.00 1 2.39 0.00 0.00 0.86 2 0.97 0.38 1.20 1.13 3 0.88 1.27 0.32 0.93 4 0.63 0.59 5.52 2.45 5 0.71 0.81 5.21 1.53 6 0.23 1.80 3.96 1.44 7 1.04 0.00 5.90 1.22 8 0.00 1.49 5.11 1.06 9 1.39 0.00 3.26 1.26 10 0.00 1.68 5.06 1.15 11 4.27 5.18 3.22 1.00 *END OldGrotto2WC *BEGIN FortyRoute *DATE 2013.06.29 *CALIBRATE declination 1.58 *FLAGS SPLAY 0 0a 1.22 222.85 -1.27 0 0b 1.46 156.87 -86.76 0 0c 1.04 248.22 75.18 *FLAGS NOT SPLAY 0 1 2.76 327.91 18.03 *FLAGS SPLAY 1 1a 2.78 146.77 -18.73 1 1b 0.75 233.19 -9.76 1 1c 3.76 236.60 -61.01 1 1d 5.96 283.50 83.29 *FLAGS NOT SPLAY 1 2 5.35 306.91 5.35 *FLAGS SPLAY 2 2a 5.34 127.04 -5.34 2 2b 0.93 37.11 -9.90 2 2c 0.20 232.85 8.71 2 2d 0.77 47.20 -45.75 2 2e 5.18 303.14 -81.62 2 2f 2.15 89.72 81.91 *FLAGS NOT SPLAY 2 3 3.55 321.41 38.17 *FLAGS SPLAY 3 3a 3.53 140.66 -38.25 3 3b 0.25 241.41 3.91 3 3c 0.79 64.43 3.52 3 3d 2.35 116.75 81.52 3 3e 0.76 47.06 -63.29 3 3f 3.35 110.73 -74.59 3 3g 7.46 126.02 -72.97 *FLAGS NOT SPLAY 3 4 1.12 7.71 3.63 *FLAGS SPLAY 4 4a 1.10 186.02 -4.47 4 4b 0.67 231.66 -2.98 4 4c 2.21 239.56 80.82 4 4d 0.66 261.89 -73.67 *FLAGS NOT SPLAY 4 5 1.06 263.40 33.43 *FLAGS SPLAY 5 5a 1.05 82.92 -33.40 5 5b 0.57 40.65 -2.91 5 5c 1.16 37.56 -82.40 5 5d 1.63 42.68 77.79 *FLAGS NOT SPLAY 5 6 2.53 351.94 5.11 *FLAGS SPLAY 6 6a 2.52 171.57 -5.45 6 6b 0.49 251.10 -0.42 6 6c 1.24 242.62 -65.46 6 6d 1.46 223.45 74.25 *FLAGS NOT SPLAY 6 7 2.96 317.31 -3.31 *FLAGS SPLAY 7 7a 2.94 137.40 3.36 7 7b 0.49 69.22 2.25 7 7c 1.67 337.77 83.13 7 7d 1.64 62.33 -86.14 *FLAGS NOT SPLAY 7 8 5.25 326.28 -29.19 *FLAGS SPLAY 8 8a 5.24 144.41 28.59 8 8b 0.86 189.62 -3.22 8 8c 0.38 17.72 -13.79 8 8d 1.17 125.13 -68.29 8 8e 1.74 198.87 87.16 8 8f 1.48 138.91 36.33 8 8g 1.35 154.31 37.64 8 8h 1.31 145.24 3.36 8 8i 1.68 357.07 -42.58 8 8j 0.97 289.48 -24.64 *FLAGS NOT SPLAY 8 9 1.45 273.15 -22.26 *FLAGS SPLAY 9 9a 1.43 93.33 24.76 9 9b 0.34 20.18 -0.69 9 9c 1.39 262.30 -4.33 9 9d 0.77 190.18 -1.47 9 9e 4.31 268.96 75.35 9 9f 0.52 82.52 -53.29 9 9g 2.71 169.49 -81.00 *FLAGS NOT SPLAY 9 10 7.65 252.29 -71.60 *FLAGS SPLAY 10 10a 7.66 71.90 71.88 10 10b 2.79 105.38 2.13 10 10c 1.94 102.39 -80.10 10 10d 2.30 52.40 -8.53 *FLAGS NOT SPLAY 10 11 2.32 146.39 -8.38 *FLAGS SPLAY 11 11a 2.33 327.27 7.87 11 11b 2.32 327.44 7.88 11 11c 1.58 246.33 79.18 11 11d 1.73 335.02 -87.87 11 11e 0.62 102.51 -8.28 11 11f 0.98 265.19 1.62 *FLAGS NOT SPLAY *data passage station left right up down 0 1.18 0.00 1.01 1.46 1 1.80 0.00 5.92 3.29 2 0.20 0.91 2.13 5.12 3 0.24 0.78 2.32 3.23 4 0.67 0.00 2.18 0.63 5 0.00 0.57 1.59 1.15 6 0.51 0.00 1.41 1.13 7 0.00 0.47 1.66 1.64 8 0.81 1.04 1.74 1.09 9 0.73 0.30 4.17 2.68 10 2.78 0.00 0.00 1.91 11 0.43 0.86 1.55 1.73 *END FortyRoute *BEGIN WaterRift *DATE 2013.06.29 *CALIBRATE declination 1.58 *FLAGS SPLAY 0 0a 5.35 17.95 22.62 0 0b 4.13 22.58 -15.64 0 0c 8.42 335.52 5.44 0 0d 8.89 333.03 6.81 0 0e 5.30 346.43 8.54 0 0f 5.13 294.43 17.44 0 0g 7.66 281.52 0.94 0 0h 6.92 262.96 5.04 0 0i 6.86 253.61 5.31 0 0j 5.23 247.20 7.41 0 0k 3.51 202.89 21.45 0 0l 5.06 195.97 22.67 0 0m 6.28 160.68 22.30 0 0n 8.67 132.59 16.67 0 0o 6.28 121.89 11.57 0 0p 3.27 114.10 12.54 *FLAGS NOT SPLAY 0 1 5.77 334.28 -11.88 *FLAGS SPLAY 1 1a 5.76 154.47 11.49 1 1b 1.98 166.16 -38.83 1 1c 3.75 244.92 84.64 1 1d 1.82 180.79 -73.82 *FLAGS NOT SPLAY 1 2 4.33 195.52 -26.62 *FLAGS SPLAY 2 2a 4.32 13.06 26.42 2 2b 0.76 316.99 -3.19 2 2c 0.28 114.54 1.61 2 2d 1.02 123.59 -85.18 2 2e 0.70 2.62 84.20 2 2f 4.92 233.56 80.23 *FLAGS NOT SPLAY 2 3 6.36 270.39 -36.08 *FLAGS SPLAY 3 3a 6.38 90.74 35.86 3 3b 7.22 164.95 87.99 3 3c 1.50 350.89 -85.48 3 3d 0.60 17.37 -5.81 3 3e 4.37 94.08 26.89 3 3f 2.04 96.97 2.01 *FLAGS NOT SPLAY 3 4 1.54 305.04 -17.83 *FLAGS SPLAY 4 4a 1.56 124.70 18.36 4 4b 1.18 214.55 -3.95 4 4c 1.80 281.84 -85.97 4 4d 0.92 184.19 78.11 4 4e 5.88 261.80 85.59 *FLAGS NOT SPLAY 4 5 4.45 302.01 -20.17 *FLAGS SPLAY 5 5a 4.45 122.05 20.68 5 5b 0.66 42.61 -0.43 5 5c 0.79 295.82 80.77 5 5d 3.44 40.04 71.75 5 5e 1.19 159.77 -84.25 *FLAGS NOT SPLAY 5 6 2.13 320.38 -11.71 *FLAGS SPLAY 6 6a 2.12 139.96 12.80 6 6b 0.40 65.25 1.27 6 6c 1.37 29.54 74.80 6 6d 0.97 226.69 -87.04 6 6e 1.93 9.54 -74.91 *FLAGS NOT SPLAY 6 7 5.02 333.92 -11.98 *FLAGS SPLAY 7 7a 5.07 155.07 11.54 7 7b 0.32 233.46 -2.11 7 7c 3.09 147.72 83.95 7 7d 1.42 334.08 -84.41 *FLAGS NOT SPLAY 7 8 1.63 323.46 -34.24 *FLAGS SPLAY 8 8a 1.65 141.45 35.60 8 8b 0.74 242.86 -4.71 8 8c 2.20 121.85 85.11 8 8d 0.57 265.91 -86.27 *FLAGS NOT SPLAY 8 9 6.72 325.55 -5.61 *FLAGS SPLAY 9 9a 6.71 148.04 5.85 9 9b 0.67 85.11 -3.81 9 9c 1.21 68.18 77.77 9 9d 0.38 45.26 -87.04 *FLAGS NOT SPLAY 9 10 2.39 1.38 10.24 *FLAGS SPLAY 10 10a 2.40 179.07 -10.67 10 10b 0.87 224.61 -18.06 10 10c 2.55 202.57 79.97 10 10d 1.00 211.64 -85.65 10 10e 1.28 263.59 -11.49 10 10f 1.20 324.42 7.72 *FLAGS NOT SPLAY 10 11 3.73 245.25 -24.06 *FLAGS SPLAY 11 11a 3.72 63.01 24.03 11 11b 1.16 6.02 4.03 11 11c 0.49 155.26 4.00 11 11d 2.42 200.28 -80.22 11 11e 10.92 339.54 83.66 *FLAGS NOT SPLAY 11 12 1.75 211.67 -24.54 *FLAGS SPLAY 12 12a 1.74 34.17 24.31 12 12b 0.94 259.38 1.16 12 12c 0.59 89.49 -3.42 12 12d 1.75 155.02 -82.92 12 12e 1.64 258.51 84.25 *FLAGS NOT SPLAY 12 13 8.34 181.38 -8.14 *FLAGS SPLAY 13 13a 8.39 2.63 8.00 13 13b 0.85 281.78 -0.49 13 13c 3.43 284.92 82.46 13 13d 0.81 114.24 -89.45 13 13e 0.20 95.00 3.81 *FLAGS NOT SPLAY 13 14 4.39 179.79 -2.78 *FLAGS SPLAY 14 14a 4.39 357.83 2.72 14 14b 1.53 261.41 0.73 14 14c 3.11 221.34 84.26 14 14d 0.84 76.55 -85.25 *FLAGS NOT SPLAY 14 15 7.89 176.25 -1.64 *FLAGS SPLAY 15 15a 7.89 354.31 1.68 15 15b 0.39 271.84 -0.76 15 15c 0.43 81.78 2.27 15 15d 0.98 17.06 -84.71 15 15e 3.06 326.61 82.70 *FLAGS NOT SPLAY 15 16 4.52 194.00 -4.00 *FLAGS SPLAY 16 16a 4.55 11.12 3.98 16 16b 1.39 8.20 -1.40 16 16c 1.31 314.18 0.17 16 16d 2.88 210.72 3.57 16 16e 2.19 158.12 24.87 16 16f 3.69 159.38 30.12 16 16g 1.68 80.18 14.09 16 16h 1.36 3.78 83.92 16 16i 0.91 118.43 -86.27 *FLAGS NOT SPLAY *data passage station left right up down 0 6.74 3.41 1.95 0.00 1 1.52 0.00 3.73 1.75 2 0.25 0.75 0.70 1.02 3 0.00 0.60 7.22 1.50 4 1.18 0.00 5.86 1.80 5 0.00 0.66 0.78 1.18 6 0.00 0.40 1.32 0.97 7 0.32 0.00 3.07 1.41 8 0.73 0.00 2.19 0.57 9 0.00 0.65 1.18 0.38 10 0.81 0.43 2.51 1.00 11 0.47 0.78 10.85 2.38 12 0.56 0.84 1.63 1.74 13 0.20 0.83 3.40 0.81 14 0.00 1.52 3.09 0.84 15 0.42 0.39 3.04 0.98 16 1.81 1.13 1.35 0.91 *END WaterRift *BEGIN 10 *DATE 2013.06.30 *CALIBRATE declination 1.58 *FLAGS SPLAY 0 0a 0.79 122.45 -3.92 0 0b 0.82 125.25 -80.01 0 0c 1.02 113.36 59.45 *FLAGS NOT SPLAY 0 1 2.19 193.96 16.02 *FLAGS SPLAY 1 1a 0.60 276.70 12.05 1 1b 1.13 263.53 84.69 1 1c 0.86 340.30 -87.68 1 1d 0.22 130.33 11.67 *FLAGS NOT SPLAY 1 2 1.14 228.14 32.64 *FLAGS SPLAY 2 2a 0.70 84.60 -2.91 2 2b 0.51 245.48 7.63 2 2c 0.88 181.29 75.58 2 2d 1.15 205.42 -86.76 *FLAGS NOT SPLAY 2 3 3.27 163.30 -22.86 *FLAGS SPLAY 3 3a 0.64 68.81 -0.15 3 3b 1.80 103.28 -83.45 3 3c 1.69 279.44 83.39 3 3d 1.80 104.43 -50.09 3 3e 0.90 125.15 -23.23 3 3f 0.84 162.44 -25.10 3 3g 0.53 177.50 -0.32 *FLAGS NOT SPLAY 3 4 6.91 267.13 3.53 *FLAGS SPLAY 4 4a 0.55 178.10 2.86 4 4b 0.33 358.62 9.99 4 4c 0.38 76.20 84.09 4 4d 0.44 211.43 -83.57 *FLAGS NOT SPLAY 3 5 2.54 190.56 -63.18 *FLAGS SPLAY 5 5a 0.60 308.44 -0.68 5 5b 0.72 295.04 -61.80 *FLAGS NOT SPLAY 5 6 4.59 251.07 -25.44 *FLAGS SPLAY 6 6a 1.06 89.99 22.23 6 6b 0.26 275.62 12.96 6 6c 0.49 129.38 84.49 6 6d 1.44 31.18 16.46 *FLAGS NOT SPLAY 6 7 2.94 167.27 7.15 *FLAGS SPLAY 7 7a 1.29 326.65 -21.82 7 7b 0.99 316.84 -22.29 7 7c 0.76 256.67 -44.96 7 7d 0.98 216.45 -34.57 7 7e 0.19 302.09 85.19 7 7f 1.57 162.77 -85.97 *FLAGS NOT SPLAY 7 8 3.72 165.59 -0.44 *FLAGS SPLAY 8 8a 0.75 39.89 9.56 8 8b 0.42 37.36 78.00 8 8c 1.07 126.50 -89.16 *FLAGS NOT SPLAY 8 9 2.10 111.50 19.76 *FLAGS SPLAY 9 9a 0.90 221.02 0.31 9 9b 1.10 120.62 -83.53 9 9c 0.21 316.09 84.80 9 9d 0.25 17.06 -3.95 9 9e 1.74 167.67 -7.64 9 9f 1.77 152.97 -6.07 9 9g 3.17 165.43 5.99 9 9h 2.88 146.54 8.77 9 9i 2.84 106.66 13.82 9 9j 1.24 97.33 -8.06 *FLAGS NOT SPLAY 9 10 7.71 161.72 1.86 *FLAGS SPLAY 10 10a 0.46 262.62 2.57 10 10b 0.36 13.53 -1.36 10 10c 0.65 315.92 77.50 10 10d 0.63 99.67 -84.98 *FLAGS NOT SPLAY 10 11 2.16 102.08 5.76 9 12 8.35 93.72 17.83 *FLAGS SPLAY 12 12a 1.67 330.14 -0.55 12 12b 0.52 155.45 -0.04 12 12c 0.44 246.87 82.62 12 12d 0.44 67.03 -84.94 *FLAGS NOT SPLAY 12 13 4.34 9.47 9.01 *FLAGS SPLAY 13 13a 0.79 243.90 -9.22 13 13b 0.90 67.62 -18.81 13 13c 0.65 256.16 -85.98 *FLAGS NOT SPLAY 13 14 2.15 152.81 2.05 *FLAGS SPLAY 14 14a 3.84 296.58 51.55 14 14b 4.81 296.42 51.44 14 14c 3.83 296.46 51.33 *FLAGS NOT SPLAY 13 15 3.68 88.63 11.54 *FLAGS SPLAY 15 15a 1.22 317.35 3.30 15 15b 0.85 119.43 28.64 15 15c 0.50 294.64 80.22 15 15d 0.30 71.24 -88.13 15 15e 0.53 327.66 -14.96 15 15f 0.25 257.11 80.01 *FLAGS NOT SPLAY 15 16 5.88 47.35 18.38 *FLAGS SPLAY 16 16a 0.54 335.23 0.80 16 16b 1.45 160.46 6.63 16 16c 0.27 280.29 80.80 *FLAGS NOT SPLAY 16 17 5.34 79.73 18.79 *FLAGS SPLAY 17 17a 1.70 8.32 14.34 17 17b 2.11 303.47 88.21 17 17c 0.65 314.37 -88.24 17 17d 0.83 195.12 7.12 17 17e 2.82 295.58 -11.71 17 17f 2.08 255.83 -15.91 17 17g 1.17 134.29 25.92 17 17h 2.06 89.62 30.46 17 17i 1.20 51.23 52.50 17 17j 3.76 32.80 57.89 17 17k 0.98 313.51 23.51 3 3x 0.37 221.12 0.55 *FLAGS NOT SPLAY 3 18 1.80 104.97 -49.81 *FLAGS SPLAY 18 18a 0.78 175.26 4.50 18 18b 0.26 37.36 24.21 18 18c 0.31 183.81 49.92 *FLAGS NOT SPLAY 14 20 3.88 295.15 51.22 *data passage station left right up down 0 0.75 0.00 0.88 0.81 1 0.21 0.53 1.13 0.86 2 0.65 0.39 0.85 1.15 3 0.70 0.29 1.68 1.79 4 0.55 0.32 0.38 0.44 *data passage station left right up down 3 0.65 0.26 1.68 1.79 5 0.00 0.60 0.00 0.63 6 0.86 0.23 0.49 0.00 7 0.00 0.62 0.19 1.57 8 0.73 0.00 0.41 1.07 9 1.38 1.52 0.21 1.09 10 0.32 0.35 0.63 0.63 *data passage station left right up down 9 0.25 2.80 0.21 1.09 12 1.65 0.50 0.44 0.44 13 0.20 0.00 0.00 0.65 15 1.14 0.58 0.49 0.30 16 0.54 1.43 0.27 0.00 17 1.62 0.86 2.11 0.65 *data passage station left right up down 13 0.00 0.43 0.00 0.65 14 0.00 2.86 3.76 0.00 *data passage station left right up down 3 0.29 0.70 1.68 1.79 18 0.22 0.73 0.24 0.00 *END 10 *BEGIN 20 *DATE 2013.06.30 *CALIBRATE declination 1.58 0 1 3.87 261.79 -26.31 1 2 2.55 125.69 -19.31 *FLAGS SPLAY 2 2a 0.91 250.27 7.92 2 2b 0.77 171.08 -87.61 2 2c 0.81 255.66 49.75 2 2d 0.24 67.33 -0.18 2 2e 3.81 229.59 62.45 *FLAGS NOT SPLAY 2 3 5.29 150.86 -7.60 *FLAGS SPLAY 3 3a 0.98 5.09 -20.60 3 3b 0.45 330.90 23.74 3 3c 1.15 347.72 -26.49 *FLAGS NOT SPLAY 3 4 1.83 63.94 -43.21 *FLAGS SPLAY 4 4a 0.88 254.64 -4.95 4 4b 0.31 92.19 22.06 4 4c 0.77 180.62 67.03 4 4d 0.57 170.18 -74.58 *FLAGS NOT SPLAY 4 5 3.13 176.57 -12.17 *FLAGS SPLAY 5 5a 0.89 62.62 28.28 5 5b 0.61 237.44 -20.17 5 5c 0.89 293.48 79.22 5 5d 0.56 337.49 -44.42 *FLAGS NOT SPLAY 5 6 1.40 257.65 -52.47 *FLAGS SPLAY 6 6a 0.52 318.37 75.96 6 6b 0.35 16.99 1.82 6 6c 0.19 324.08 -71.45 *FLAGS NOT SPLAY 6 7 2.40 284.49 -13.04 *FLAGS SPLAY 7 7a 0.40 195.25 -1.25 7 7b 0.32 213.01 45.13 7 7c 0.42 157.49 -56.01 *FLAGS NOT SPLAY 3 8 2.58 64.30 1.85 *FLAGS SPLAY 8 8a 0.98 338.09 -7.20 8 8b 1.33 152.73 8.89 8 8c 0.38 331.75 81.25 8 8d 1.90 340.12 -69.71 8 8e 0.89 274.97 -54.79 8 8f 1.08 232.73 0.66 *FLAGS NOT SPLAY 8 9 2.80 61.94 1.42 *FLAGS SPLAY 9 9a 2.81 191.74 9.89 9 9b 2.16 134.18 25.75 9 9c 2.16 50.11 -6.32 9 9d 1.26 6.31 -16.99 9 9e 1.13 289.11 75.43 9 9f 2.72 79.01 66.64 9 9g 0.85 267.86 -82.70 *FLAGS NOT SPLAY 9 10 5.67 274.30 -29.92 *FLAGS SPLAY 10 10a 0.67 2.50 88.13 10 10b 0.23 135.92 -83.36 10 10c 1.22 201.08 3.08 10 10d 3.64 11.56 12.96 10 10e 1.92 335.12 9.74 10 10f 2.38 307.32 -7.29 *FLAGS NOT SPLAY 10 11 4.21 315.24 -5.18 *FLAGS SPLAY 11 11a 0.55 90.17 -18.10 11 11b 0.85 207.55 -12.11 11 11c 0.48 85.91 -82.18 11 11d 1.30 348.21 -63.09 *FLAGS NOT SPLAY 11 12 0.46 277.24 -49.35 *FLAGS SPLAY 12 12a 0.21 238.72 1.25 *FLAGS NOT SPLAY 12 13 2.99 11.93 3.89 *FLAGS SPLAY 13 13a 1.42 174.80 78.06 13 13b 0.30 315.88 -80.15 13 13c 2.31 246.88 74.77 13 13d 1.56 189.37 17.65 13 13e 3.02 211.37 -11.39 13 13f 3.15 248.27 -16.57 13 13g 1.77 297.77 -6.34 13 13h 3.86 328.15 -4.42 13 13i 4.28 343.90 -3.07 13 13j 3.09 19.95 6.70 13 13k 4.26 37.78 13.46 13 13l 3.80 64.26 16.75 13 13m 4.72 82.28 18.14 13 13n 1.83 98.00 23.43 *FLAGS NOT SPLAY 13 14 1.51 326.89 1.17 *FLAGS SPLAY 13 13a 1.80 134.62 18.89 *FLAGS NOT SPLAY 13 15 4.27 118.28 31.59 *FLAGS SPLAY 15 15a 2.10 311.12 -18.89 15 15b 0.29 304.38 72.17 15 15c 0.86 355.38 -83.90 15 15d 1.91 225.82 -10.33 *FLAGS NOT SPLAY 15 16 2.48 36.12 13.37 *FLAGS SPLAY 16 16a 0.50 296.88 -8.43 16 16b 1.10 323.19 -84.96 16 16c 1.15 357.90 17.17 16 16d 1.74 355.61 -47.54 16 16e 3.34 281.30 -47.10 *FLAGS NOT SPLAY 16 17 3.13 327.92 82.94 *FLAGS SPLAY 17 17a 0.72 273.55 72.14 17 17b 0.51 284.99 -34.65 *FLAGS NOT SPLAY 17 18 1.35 214.32 -12.67 18 19 2.43 231.25 22.63 13 20 2.14 331.93 -1.84 *FLAGS SPLAY 20 20a 1.14 42.18 -54.87 20 20b 1.18 122.45 -68.05 20 20c 0.36 67.41 74.28 20 20d 1.30 38.86 -71.88 20 20e 1.14 43.52 -52.40 *FLAGS NOT SPLAY 20 21 2.84 49.23 -61.41 *FLAGS SPLAY 21 21a 0.38 306.70 3.51 21 21b 0.58 42.06 -16.72 21 21c 0.36 346.21 52.74 *FLAGS NOT SPLAY 21 22 1.87 345.57 -9.57 *FLAGS SPLAY 22 22a 1.17 258.11 42.02 22 22b 0.37 242.14 -55.73 22 22c 0.36 39.38 -52.79 *FLAGS NOT SPLAY 22 23 1.63 311.27 20.13 *FLAGS SPLAY 23 23a 0.42 64.58 4.20 23 23b 0.32 213.47 -9.32 23 23c 0.99 86.07 -87.31 23 23d 0.25 94.22 48.88 *FLAGS NOT SPLAY 23 24 1.57 250.05 -33.27 *FLAGS SPLAY 24 24a 0.24 7.88 -0.38 24 24b 1.15 13.91 67.66 *FLAGS NOT SPLAY 24 25 2.11 302.88 3.36 *FLAGS SPLAY 25 25a 0.59 203.43 -39.91 25 25b 0.73 124.92 74.91 25 25c 0.46 19.39 -52.00 *FLAGS NOT SPLAY 25 26 2.60 267.02 31.57 *FLAGS SPLAY 26 26a 0.45 275.41 -83.91 26 26b 0.45 328.61 -88.28 26 26c 0.40 220.39 -21.96 26 26d 0.39 207.53 -25.01 26 26e 0.45 27.25 6.50 *FLAGS NOT SPLAY 27 26 1.86 143.63 -4.35 *FLAGS SPLAY 26 26a 0.44 24.90 6.93 27 27a 0.78 175.30 4.50 27 27b 0.26 37.40 24.20 27 27c 0.31 183.80 49.90 *FLAGS NOT SPLAY *data passage station left right up down 0 0.00 0.00 0.00 0.00 1 0.00 0.00 0.00 0.00 2 0.23 1.76 3.38 0.77 3 0.90 0.00 0.18 0.51 4 0.14 0.26 0.71 0.55 5 0.34 0.35 0.87 0.39 6 0.00 0.34 0.50 0.18 7 0.40 0.00 0.23 0.35 *data passage station left right up down 3 0.90 0.00 0.18 0.51 8 0.97 1.31 0.38 1.78 9 0.00 1.90 1.09 0.84 10 1.22 3.45 0.67 0.23 11 0.83 0.46 0.00 0.48 12 0.21 0.00 0.00 0.00 13 4.13 2.90 1.39 0.30 15 1.61 0.98 0.28 0.86 16 2.24 0.00 0.00 1.10 17 0.00 0.10 0.69 0.29 18 0.00 0.00 0.00 0.00 *data passage station left right up down 13 2.88 4.11 1.39 0.30 20 0.00 0.41 0.35 1.24 21 0.36 0.23 0.29 0.00 22 0.82 0.21 0.78 0.31 23 0.29 0.25 0.19 0.99 24 0.00 0.43 1.06 0.00 25 0.45 0.28 0.70 0.36 26 0.36 0.45 0.00 0.45 27 0.23 0.41 0.24 0.00 *END 20 *END Swildons CaveConverter_src/test/data/regression/2649_Mares_from3d_ds_ref.svx0000644000000000000000000000432312115213060024323 0ustar rootroot*BEGIN SurveyFromDXF *EQUATE SeriesFromLines1.6 SeriesFromLines2.0 *EQUATE SeriesFromLines2.0 SeriesFromLines1.6 *EQUATE SeriesFromLines2.3 SeriesFromLines3.0 *EQUATE SeriesFromLines3.0 SeriesFromLines2.3 *EQUATE SeriesFromLines3.13 SeriesFromLines5.0 *EQUATE SeriesFromLines3.14 SeriesFromLines4.0 *EQUATE SeriesFromLines4.0 SeriesFromLines3.14 *EQUATE SeriesFromLines5.0 SeriesFromLines3.13 *EQUATE SeriesFromLines5.4 SeriesFromLines6.0 *EQUATE SeriesFromLines6.0 SeriesFromLines5.4 *EQUATE SeriesFromLines6.1 SeriesFromLines7.0 *EQUATE SeriesFromLines7.0 SeriesFromLines6.1 *EQUATE SeriesFromLines7.5 SeriesFromLines8.0 *EQUATE SeriesFromLines8.0 SeriesFromLines7.5 *BEGIN SeriesFromLines1 *FIX 0 452220.0 4800904.0 274.0 0 1 1.72 142.64 -47.12 1 2 2.90 350.59 -49.12 2 3 4.22 0.00 -90.00 3 4 4.96 100.66 11.05 4 5 2.17 69.61 39.87 5 6 2.50 97.85 -35.10 6 7 6.89 219.66 -10.95 *END SeriesFromLines1 *BEGIN SeriesFromLines2 0 1 2.98 65.71 18.98 1 2 3.00 107.65 -1.91 2 3 2.58 95.89 -10.95 3 4 4.80 0.00 -90.00 *END SeriesFromLines2 *BEGIN SeriesFromLines3 0 1 4.40 45.66 -11.00 1 2 2.30 17.68 -43.07 2 3 7.35 47.76 -3.98 3 4 7.35 32.74 -5.07 4 5 4.10 22.63 14.12 5 6 5.90 70.73 -5.05 6 7 7.40 29.69 -2.94 7 8 5.64 46.73 -3.05 8 9 3.91 107.78 -3.96 9 10 4.02 82.72 1.99 10 11 3.00 35.76 -3.06 11 12 3.30 147.73 -11.00 12 13 6.57 96.74 0.00 13 14 1.81 179.68 3.16 14 15 1.90 25.75 6.95 *END SeriesFromLines3 *BEGIN SeriesFromLines4 0 1 2.50 199.59 19.84 *END SeriesFromLines4 *BEGIN SeriesFromLines5 0 1 3.00 88.85 6.70 1 2 2.91 18.25 3.54 2 3 4.11 17.73 -2.23 3 4 2.03 328.99 4.81 4 5 2.42 26.97 -37.65 *END SeriesFromLines5 *BEGIN SeriesFromLines6 0 1 1.92 61.82 -5.99 1 2 3.34 30.26 -4.29 *END SeriesFromLines6 *BEGIN SeriesFromLines7 0 1 8.17 102.88 -1.40 1 2 1.78 137.05 4.83 2 3 2.69 98.76 0.21 3 4 4.73 54.32 -3.76 4 5 1.25 67.34 -4.59 5 6 2.94 110.53 -3.90 *END SeriesFromLines7 *BEGIN SeriesFromLines8 0 1 3.96 134.08 3.91 1 2 1.44 67.21 -26.37 2 3 2.30 129.81 -17.99 *END SeriesFromLines8 *END SurveyFromDXF CaveConverter_src/test/data/regression/HSC_in.txt0000644000000000000000000004757511172317744021136 0ustar rootrootnew090417 (m, 360) [1]: 2009/04/17 2.08 1.20 0.00 0.00 0.00 1.20 118.0 0.000 0.00 0.00 [1] 118.0 0.960 22.53 -1.72 [1] 118.0 0.230 209.86 13.47 [1] 118.0 4.620 344.93 83.50 [1] 118.0 1.330 234.49 -86.05 [1] 118.0 118.1 4.410 85.64 56.42 [1] 118.0 118.1 4.410 85.56 56.46 [1] 118.0 118.1 4.410 85.69 56.48 [1] 118.1 5.210 286.13 -1.99 [1] 118.1 1.250 97.37 3.15 [1] 118.1 1.560 321.06 80.51 [1] 118.1 4.370 145.94 -88.53 [1] 118.1 118.2 2.570 17.55 8.88 [1] 118.1 118.2 2.570 17.34 8.88 [1] 118.1 118.2 2.570 17.44 8.88 [1] 118.2 1.220 287.61 0.03 [1] 118.2 0.400 105.36 4.08 [1] 118.2 0.310 293.53 87.17 [1] 118.2 0.380 21.24 -85.59 [1] 118.2 118.3 6.090 17.22 -0.31 [1] 118.2 118.3 6.090 17.21 -0.37 [1] 118.2 118.3 6.090 17.25 -0.40 [1] 118.3 1.340 209.51 15.20 [1] 118.3 0.200 26.53 2.06 [1] 118.3 0.330 19.33 83.86 [1] 118.3 0.440 187.04 -85.42 [1] 118.3 118.4 6.260 288.72 0.88 [1] 118.3 118.4 6.260 288.72 0.88 [1] 118.3 118.4 6.260 288.73 0.90 [1] 118.4 0.480 196.35 -3.11 [1] 118.4 0.440 12.77 10.01 [1] 118.4 0.340 324.14 88.50 [1] 118.4 0.370 218.56 -87.98 [1] 118.3 118.5 2.080 143.40 1.35 [1] 118.3 118.5 2.080 143.34 1.25 [1] 118.3 118.5 2.080 143.01 1.28 [1] 118.5 0.820 10.33 3.35 [1] 118.5 0.210 95.58 86.04 [1] 118.5 0.190 205.48 -87.92 [1] 118.5 118.6 2.630 92.97 -6.52 [1] 118.5 118.6 2.630 92.97 -6.52 [1] 118.5 118.6 2.630 93.04 -6.54 [1] 118.6 0.360 355.91 0.44 [1] 118.6 0.310 168.00 6.41 [1] 118.6 0.210 76.60 85.20 [1] 118.6 1.940 132.41 -84.27 [1] 118.1 118.7 1.920 171.13 38.90 [1] 118.1 118.7 1.920 171.28 38.89 [1] 118.1 118.7 1.920 171.33 38.97 [1] 118.7 0.990 23.62 1.01 [1] 118.7 0.960 219.73 0.84 [1] 118.7 2.060 276.93 84.38 [1] 118.7 0.480 160.02 -83.30 [1] 118.7 118.8 4.090 118.90 8.05 [1] 118.7 118.8 4.090 118.83 8.06 [1] 118.7 118.8 4.090 118.70 8.10 [1] 118.8 0.590 14.54 -1.30 [1] 118.8 1.160 64.30 86.33 [1] 118.8 0.810 4.19 -88.04 [1] 118.8 118.9 6.840 102.67 6.76 [1] 118.8 118.9 6.840 102.68 6.77 [1] 118.8 118.9 6.840 102.91 6.66 [1] 118.9 0.640 9.27 -0.28 [1] 118.9 0.400 186.72 9.03 [1] 118.9 0.220 28.87 85.75 [1] 118.9 0.220 217.52 -85.24 [1] 118.7 118.10 3.610 220.76 21.45 [1] 118.7 118.10 3.610 220.79 21.43 [1] 118.7 118.10 3.610 220.82 21.40 [1] 118.10 1.230 116.25 2.68 [1] 118.10 0.760 285.24 7.71 [1] 118.10 0.740 109.40 86.98 [1] 118.10 0.220 100.33 -89.49 [1] 118.10 118.11 1.780 180.55 16.59 [1] 118.10 118.11 1.780 180.34 16.48 [1] 118.10 118.11 1.780 180.29 16.42 [1] 118.11 0.310 103.13 -2.29 [1] 118.11 1.000 282.91 1.18 [1] 118.11 0.240 314.51 86.50 [1] 118.11 0.200 162.79 -79.23 [1] 118.11 118.12 15.040 195.43 0.34 [1] 118.11 118.12 15.030 195.25 0.34 [1] 118.11 118.12 15.030 195.19 0.29 [1] 118.12 6.010 17.32 2.01 [1] 118.12 3.080 347.79 3.07 [1] 118.12 2.200 320.84 4.71 [1] 118.12 3.830 49.89 -0.50 [1] 118.12 0.740 110.79 8.92 [1] 118.12 0.690 198.64 10.54 [1] 118.12 118.13 7.300 264.14 2.58 [1] 118.12 118.13 7.300 264.14 2.61 [1] 118.12 118.13 7.300 263.98 2.51 [1] 118.13 0.700 182.13 3.06 [1] 118.13 0.210 11.63 19.31 [1] 118.13 0.230 184.92 77.90 [1] 118.13 118.14 3.710 279.79 4.71 [1] 118.13 118.14 3.710 279.83 4.76 [1] 118.13 118.14 3.710 279.83 4.85 [1] 118.14 0.430 188.00 1.46 [1] 118.14 0.850 13.90 -0.77 [1] 118.14 0.340 176.03 -80.18 [1] 118.14 118.15 6.700 266.27 -26.49 [1] 118.14 118.15 6.690 266.33 -26.46 [1] 118.14 118.15 6.690 266.19 -26.38 [1] 118.15 0.980 170.84 8.55 [1] 118.15 2.490 64.23 11.72 [1] 118.15 2.610 244.87 21.84 [1] 118.15 3.370 292.48 11.33 [1] 118.15 2.000 342.97 10.72 [1] 118.15 118.16 2.920 52.58 0.51 [1] 118.15 118.16 2.920 52.58 0.48 [1] 118.15 118.16 2.920 52.56 0.50 [1] 118.16 1.130 335.93 -3.42 [1] 118.16 0.310 152.53 2.42 [1] 118.16 0.620 333.07 87.23 [1] 118.16 0.380 146.54 -87.21 [1] 118.16 118.17 7.380 58.27 0.42 [1] 118.16 118.17 7.380 58.26 0.39 [1] 118.16 118.17 7.360 58.21 0.35 [1] 118.17 0.980 324.42 3.22 [1] 118.17 0.310 144.32 3.31 [1] 118.17 0.280 300.73 87.16 [1] 118.17 0.050 126.22 -81.67 [1] 118.17 118.18 3.300 34.03 -4.62 [1] 118.17 118.18 3.300 34.00 -4.56 [1] 118.17 118.18 3.300 34.15 -4.51 [1] 118.18 2.980 85.15 -2.52 [1] 118.18 2.970 124.59 0.62 [1] 118.18 7.760 126.15 1.14 [1] 118.18 6.420 141.39 0.59 [1] 118.18 3.290 164.25 2.96 [1] 118.18 2.760 240.68 7.36 [1] 118.18 0.870 282.27 12.06 [1] 118.18 118.19 4.750 270.77 2.03 [1] 118.18 118.19 4.750 270.83 2.05 [1] 118.18 118.19 4.750 270.77 2.03 [1] 118.19 0.200 182.59 2.55 [1] 118.19 1.540 11.61 -0.79 [1] 118.19 0.630 297.61 84.85 [1] 118.19 0.400 87.62 -85.16 [1] 118.19 118.20 5.160 306.50 4.35 [1] 118.19 118.20 5.160 306.55 4.31 [1] 118.19 118.20 5.160 306.47 4.28 [1] 118.20 1.600 212.01 -0.93 [1] 118.20 0.260 50.02 -84.91 [1] 118.20 118.21 2.770 223.52 -6.64 [1] 118.20 118.21 2.770 223.48 -6.69 [1] 118.20 118.21 2.760 223.30 -6.92 [1] 118.21 1.600 180.63 6.26 [1] 118.21 0.600 338.00 1.74 [1] 118.21 0.760 212.74 88.20 [1] 118.21 118.22 4.110 249.40 5.40 [1] 118.21 118.22 4.110 249.44 5.40 [1] 118.21 118.22 4.110 249.46 5.42 [1] 118.22 0.390 162.23 -0.01 [1] 118.22 0.580 347.00 0.42 [1] 118.22 0.460 271.51 75.36 [1] 118.22 0.260 90.53 -87.49 [1] 118.22 118.23 4.040 274.31 6.81 [1] 118.22 118.23 4.040 274.37 6.82 [1] 118.22 118.23 4.040 274.26 6.66 [1] 118.21 118.24 2.040 127.75 8.54 [1] 118.21 118.24 2.040 127.78 8.50 [1] 118.21 118.24 2.040 127.49 8.43 [1] 118.24 1.050 1.79 1.44 [1] 118.24 0.230 100.12 86.02 [1] 118.24 0.270 278.61 -83.60 [1] 118.24 118.25 4.170 85.35 -5.62 [1] 118.24 118.25 4.170 86.27 -6.31 [1] 118.24 118.25 4.170 86.18 -6.30 [1] 118.15 118.26 4.820 275.39 11.74 [1] 118.15 118.26 4.820 275.33 11.67 [1] 118.15 118.26 4.820 275.29 11.63 [1] 118.26 0.670 193.39 11.97 [1] 118.26 0.450 359.40 1.02 [1] 118.26 0.320 29.04 -85.64 [1] 118.26 118.27 9.450 283.85 -1.76 [1] 118.26 118.27 9.420 283.97 -1.82 [1] 118.26 118.27 9.460 283.97 -1.83 [1] 118.27 0.330 200.74 4.08 [1] 118.27 0.290 18.18 10.78 [1] 118.27 0.350 6.27 85.39 [1] 118.27 0.240 165.10 -87.87 [1] 118.15 118.28 5.320 258.06 15.01 [1] 118.15 118.28 5.330 258.06 15.07 [1] 118.15 118.28 5.340 258.10 15.08 [1] 118.28 0.600 161.13 4.17 [1] 118.28 0.850 353.50 8.71 [1] 118.28 2.120 50.09 81.34 [1] 118.28 118.29 2.160 242.45 48.11 [1] 118.28 118.29 2.130 242.44 47.99 [1] 118.28 118.29 2.170 242.14 47.93 [1] 118.29 2.970 33.03 0.82 [1] 118.29 2.220 320.50 -0.21 [1] 118.29 2.010 217.71 7.64 [1] 118.29 1.670 157.78 9.94 [1] 118.29 1.400 89.26 -9.57 [1] 118.29 118.30 4.360 106.07 -31.28 [1] 118.29 118.30 4.360 106.03 -31.34 [1] 118.29 118.30 4.360 105.92 -31.27 [1] 118.30 0.300 9.95 1.38 [1] 118.30 0.480 199.82 0.95 [1] 118.30 0.460 287.87 78.94 [1] 118.29 118.31 2.090 225.75 5.70 [1] 118.29 118.31 2.090 225.75 5.76 [1] 118.29 118.31 2.090 225.96 5.62 [1] 118.31 0.240 157.70 0.95 [1] 118.31 1.250 331.67 1.19 [1] 118.31 0.200 175.76 86.96 [1] 118.31 0.360 317.54 -83.62 [1] 118.31 118.32 4.450 242.35 0.44 [1] 118.31 118.32 4.450 242.36 0.53 [1] 118.31 118.32 4.450 242.30 0.46 [1] 118.32 0.520 203.42 5.06 [1] 118.32 3.190 303.43 6.37 [1] 118.32 4.630 339.31 2.41 [1] 118.32 3.020 0.72 5.70 [1] 118.32 3.100 30.34 2.17 [1] 118.32 3.630 67.71 3.17 [1] 118.32 3.210 100.79 -1.01 [1] 118.32 118.33 3.290 101.72 1.30 [1] 118.32 118.33 3.280 101.62 1.38 [1] 118.32 118.33 3.280 101.71 1.32 [1] 118.33 0.950 34.52 0.59 [1] 118.33 0.340 214.65 16.64 [1] 118.33 0.290 122.89 84.71 [1] 118.33 0.190 292.02 -83.48 [1] 118.33 118.34 4.790 105.85 -13.74 [1] 118.33 118.34 4.790 105.76 -13.67 [1] 118.33 118.34 4.790 105.87 -13.74 [1] 118.34 0.290 207.59 -3.35 [1] 118.34 0.200 173.84 86.48 [1] 118.34 1.470 178.88 -87.03 [1] 118.34 118.35 2.380 121.18 -61.01 [1] 118.34 118.35 2.370 121.51 -61.00 [1] 118.34 118.35 2.370 121.13 -60.99 [1] 118.35 1.020 20.04 -5.91 [1] 118.35 0.720 201.68 6.82 [1] 118.35 1.170 125.10 82.70 [1] 118.35 1.640 292.70 -81.73 [1] 118.35 118.36 2.970 70.89 10.56 [1] 118.35 118.36 2.980 70.94 10.56 [1] 118.35 118.36 2.970 70.85 10.56 [1] 118.36 0.790 325.76 2.66 [1] 118.36 0.420 139.95 3.69 [1] 118.36 0.850 34.54 84.25 [1] 118.36 118.37 2.400 81.45 2.72 [1] 118.36 118.37 2.400 81.50 2.73 [1] 118.36 118.37 2.400 81.35 2.80 [1] 118.37 0.520 358.49 2.72 [1] 118.37 0.500 166.22 5.62 [1] 118.37 0.490 352.29 88.26 [1] 118.36 118.38 3.440 199.71 3.19 [1] 118.36 118.38 3.440 199.73 3.18 [1] 118.36 118.38 3.440 199.76 3.20 [1] 118.38 0.240 135.39 -2.25 [1] 118.38 0.310 318.27 11.13 [1] 118.38 0.410 119.61 80.85 [1] 118.38 0.190 318.28 -81.47 [1] 118.36 118.39 3.240 245.58 -25.97 [1] 118.36 118.39 3.240 245.67 -25.96 [1] 118.36 118.39 3.240 245.69 -25.88 [1] 118.39 0.430 25.03 1.52 [1] 118.39 0.560 7.33 84.71 [1] 118.39 1.470 236.88 -81.55 [1] 118.39 118.40 3.120 126.41 -36.37 [1] 118.39 118.40 3.120 126.40 -36.48 [1] 118.39 118.40 3.130 126.54 -36.50 [1] 118.39 118.41 2.460 288.61 -19.76 [1] 118.39 118.41 2.460 288.56 -19.55 [1] 118.39 118.41 2.460 288.44 -19.58 [1] 118.41 0.360 200.49 1.35 [1] 118.41 0.280 23.85 4.36 [1] 118.41 0.550 300.08 85.86 [1] 118.41 118.42 2.830 298.00 28.00 [1] 118.41 118.42 2.830 297.81 27.90 [1] 118.41 118.42 2.820 297.89 27.98 [1] 118.42 0.740 181.72 3.85 [1] 118.42 0.480 340.78 0.38 [1] 118.42 2.690 269.10 86.13 [1] 118.42 0.520 115.64 -84.70 [1] 118.42 118.43 1.840 310.40 50.45 [1] 118.42 118.43 1.830 310.63 50.50 [1] 118.42 118.43 1.840 310.27 50.38 [1] 118.43 118.44 7.340 226.88 12.40 [1] 118.43 118.44 7.350 226.93 12.40 [1] 118.43 118.44 7.350 226.88 12.35 [1] 118.44 0.560 328.97 6.99 [1] 118.44 1.050 212.94 78.82 [1] 118.44 0.350 301.67 -85.91 [1] 118.44 118.45 1.080 265.81 18.44 [1] 118.44 118.45 1.070 265.91 18.37 [1] 118.44 118.45 1.070 265.75 18.33 [1] 118.45 0.510 15.60 4.39 [1] 118.45 0.570 194.98 0.17 [1] 118.45 0.540 180.85 83.08 [1] 118.45 0.500 224.46 -88.24 [1] 118.45 118.46 2.400 112.22 14.39 [1] 118.45 118.46 2.410 112.29 14.33 [1] 118.45 118.46 2.400 112.18 14.40 [1] 118.46 0.790 17.98 6.40 [1] 118.46 0.530 207.16 5.75 [1] 118.46 0.500 243.62 84.24 [1] 118.46 0.910 125.65 -81.45 [1] 118.46 118.47 2.520 132.69 26.59 [1] 118.46 118.47 2.520 132.64 26.35 [1] 118.46 118.47 2.520 132.73 26.38 [1] 118.47 3.850 1.01 2.48 [1] 118.47 5.830 317.39 2.51 [1] 118.47 10.340 296.43 3.28 [1] 118.47 10.790 286.75 3.18 [1] 118.47 2.680 266.70 5.84 [1] 118.47 0.500 172.45 13.22 [1] 118.47 118.48 2.500 63.02 0.34 [1] 118.47 118.48 2.500 63.12 0.28 [1] 118.47 118.48 2.500 63.13 0.37 [1] 118.48 2.010 358.17 2.41 [1] 118.48 0.550 162.50 4.70 [1] 118.48 0.360 41.60 84.49 [1] 118.48 2.610 87.26 -2.01 [1] 118.48 118.49 4.480 87.05 -2.02 [1] 118.48 118.49 4.480 87.07 -2.03 [1] 118.48 118.49 4.480 87.31 -1.97 [1] 118.49 2.830 350.35 0.10 [1] 118.49 1.180 152.31 4.71 [1] 118.49 0.400 118.05 77.67 [1] 118.49 118.50 3.820 87.56 -4.58 [1] 118.49 118.50 3.820 87.49 -4.55 [1] 118.49 118.50 3.820 87.45 -4.44 [1] 118.50 3.980 347.14 2.28 [1] 118.50 0.340 177.04 4.50 [1] 118.50 0.560 350.94 87.59 [1] 118.50 0.670 224.41 -87.87 [1] 118.43 118.51 1.800 310.28 50.29 [1] 118.43 118.51 1.810 310.53 50.38 [1] 118.43 118.51 1.800 310.56 50.32 [1] 118.51 0.830 211.09 -1.29 [1] 118.51 0.350 27.20 5.53 [1] 118.51 1.200 241.74 87.79 [1] 118.51 0.380 131.38 -84.70 [1] 118.51 118.52 8.860 287.98 -2.52 [1] 118.51 118.52 8.850 288.01 -2.39 [1] 118.51 118.52 8.850 287.94 -2.46 [1] CaveConverter_src/test/data/regression/2649_Mareserection_in.svx0000644000000000000000000000507311171637522023767 0ustar rootroot*begin 2649_Mareserection *EQUATE Mares070701.25 Mares0904085.0 *begin Mares070701 *EXPORT 25 ;surveyors: Dave Garman, Paul Dold, Chris Agnew, Tony Radmall (Badger) ;name: Mareserection ;date 2007-07-01 *CALIBRATE declination 2.28 ;declination is 2 41' (2.68) for 2004 changing by 8'E per year. ; 2.55 used for 2005 ; 2.42 used for 2006 ; 2.28 used for 2007 ; 2.15 used for 2008 *fix 1 452220 4800904 274 ;Altitude fixed using surface mesh *entrance 1 1 2 1.72 145 -47; .2 .3 .1 .4 2 3 2.90 353 -49; .7 .1 1 1 3 4 4.22 - -V; .2 .2 .1 4 5 4.95 103 11; 1 .8 4 .2 5 6 2.17 72 40; .5 .3 2 1 6 7 2.51 100 -35; .2 .4 1.5 .6 7 8 6.9 222 -11 7 9 2.98 68 19; .3 .3 .5 1.6 9 10 3.00 110 -2; .1 .3 1 3 10 11 2.58 98 -11; .5 0 1.5 3 11 12 4.8 - -V; 4.1 5.6 1.3 11 13 4.4 48 -11 13 14 2.3 20 -43; 0 .5 .6 1.7 14 15 7.35 50 -4; .1 .6 1.8 .4 15 16 7.35 35 -5; 1 .1 2 1 16 17 4.1 25 14; 1 0 2 1 17 18 5.9 73 -5; 0 .7 1.4 1.6 18 19 7.4 32 -3; 1.2 0 1.4 1.5 19 20 5.63 49 -3; 1 .1 1.5 .93 20 21 3.91 110 -4; 0 1.2 1.4 1 21 22 4.02 85 2; 1 0 1 1.3 22 23 3.00 38 -3; .8 .3 .5 1.4 23 24 3.3 150 -11; 0 1.3 .7 1.7 24 25 6.57 99 0; 2 .2 1.3 1.4 25 26 1.82 182 3; 1.5 1.3 1 0 26 27 1.91 28 7 26 28 2.5 202 20 *data passage station left right up down 1 .2 .3 .1 .4 2 .7 .1 1 1 3 .2 .2 .1 2 4 1 .8 2 .2 5 .5 .3 2 1 6 .2 .4 1.5 .6 7 .3 .3 .5 1.6 9 .1 .3 1 3 10 .5 0 1.5 3 11 4.1 5.6 1.3 4.8 13 0 .5 .6 1.7 14 .1 .6 1.8 .4 15 1 .1 2 1 16 1 0 2 1 17 0 .7 1.4 1.6 18 1.2 0 1.4 1.5 19 1 .1 1.5 .93 20 0 1.2 1.4 1 21 1 0 1 1.3 22 .8 .3 .5 1.4 23 0 1.3 .7 1.7 24 2 .2 1.3 1.4 25 1.5 1.3 1 0 *END Mares070701 *BEGIN Mares0904085 *EXPORT 0 ;surveyors: Footleg, Alister Smith, Steve Woolvern ;Date 2009/04/08 *CALIBRATE declination 2.08 0 1 3.00 91.06 6.73 1 2 2.91 20.29 3.57 2 3 4.11 19.88 -2.27 3 4 2.03 331.14 4.87 4 5 2.43 28.98 -37.75 4 6 1.91 63.99 -6.15 6 7 3.35 32.37 -4.35 6 8 8.17 104.93 -1.38 8 9 1.78 139.35 4.60 9 10 2.70 100.81 0.36 10 11 4.72 56.33 -3.82 11 12 1.25 69.40 -4.66 12 13 2.95 112.51 -3.77 12 14 3.97 136.09 3.99 14 15 1.44 68.87 -26.54 15 16 2.30 131.94 -17.98 *data passage station left right up down 0 0.86 1.02 1.4 1.06 1 0.38 0.0 0.29 0.38 2 0.67 0.57 0.43 1.36 3 1.26 0.27 0.26 0.37 4 0.65 1.4 0.0 0.79 6 1.44 1.38 0.0 0.53 8 0.28 2.13 0.22 0.19 9 0.7 0.0 0.0 0.37 10 0.34 0.0 0.0 0.58 11 0.57 1.05 0.51 0.28 12 0.7 1.0 0.47 0.23 14 0.5 0.0 0.26 0.4 15 0.0 0.52 0.48 0.66 *END Mares0904085 *end 2649_MareserectionCaveConverter_src/test/data/regression/Stomps_pt_ref.text0000644000000000000000000001114012217344034022770 0ustar rootroot -6 1 1 1 1 Cave Name -5 1 1 1 1 0.00 0.00 0.00 1 0 -4 1 1 1 1 12/08/16 13:14:15 CaveConverter -3 1 1 1 1 -2 1 1 1 1 16/08/12 Converted Data 0 0.00 0 1 -1 1 1 1 1 360.00 360.00 0.05 1.00 1.00 100.00 0.00 1 -2 1 1 1 Series 1-root.Stomps2010.156 1 -1 1 1 1 1 0 2 0 30 3 0 1 0 1 1 1 0.00 0.00 0.00 0.79 8.89 3.11 0.74 1 1 1 1 1 9.08 187.39 -7.43 7.12 6.02 4.36 1.24 1 2 1 1 1 18.55 115.06 -0.10 1.82 8.64 3.64 1.64 1 3 1 1 1 3.94 107.42 5.39 1.71 5.64 3.59 1.77 1 4 1 1 1 14.13 94.84 -0.61 0.86 10.19 3.34 1.68 1 5 1 1 1 14.76 105.50 10.11 2.73 6.16 1.19 2.01 1 6 1 1 1 9.56 77.51 -2.48 0.00 11.90 1.67 1.71 1 7 1 1 1 12.97 126.63 -9.80 4.63 10.62 4.99 1.50 1 8 1 1 1 5.84 87.44 1.83 4.55 13.02 4.41 0.00 1 9 1 1 1 11.81 115.74 18.69 5.13 14.63 2.38 3.41 1 10 1 1 1 17.53 166.53 -7.51 9.10 4.01 4.40 2.04 1 11 1 1 1 16.73 146.94 -11.30 9.95 2.97 5.13 2.24 1 12 1 1 1 15.14 116.86 -5.89 1.83 7.76 6.87 0.44 1 13 1 1 1 12.56 156.16 3.43 3.81 3.04 5.52 1.62 1 14 1 1 1 20.99 140.30 1.02 3.34 6.72 7.30 1.78 1 15 1 1 1 14.28 157.77 1.84 6.61 5.60 6.70 2.15 1 16 1 1 1 10.37 161.06 2.49 11.08 3.78 7.06 1.67 1 17 1 1 1 7.85 124.71 -11.48 8.94 12.34 5.73 1.18 1 18 1 1 1 23.70 155.43 -4.37 7.65 10.37 1.16 0.00 1 19 1 1 1 13.16 100.01 26.51 7.33 15.73 1.88 0.00 1 20 1 1 1 14.46 143.40 8.27 12.73 10.63 1.48 0.84 1 21 1 1 1 11.00 138.49 13.34 11.75 11.68 0.00 8.06 1 22 1 1 1 19.39 45.15 -3.39 3.55 7.89 0.00 2.65 1 23 1 1 1 12.26 180.65 0.88 1.87 0.00 1.15 0.92 1 24 1 1 1 9.37 135.07 -31.89 1.83 1.14 3.68 0.33 1 25 1 1 1 16.12 64.36 8.82 0.00 4.07 1.48 0.60 1 26 1 1 1 20.53 206.33 -0.25 0.00 1.96 3.65 1.82 1 27 1 1 1 23.08 215.55 -11.66 1.49 15.96 8.28 0.00 1 28 1 1 1 9.44 335.64 -7.14 2.81 8.55 0.83 1.75 1 29 1 1 1 11.12 24.72 -1.45 10.36 4.83 0.00 0.00 1 30 1 1 1 7.38 57.21 18.23 0.00 0.00 0.00 0.00 2 -2 1 1 1 Series 2-root.Stomps2010.156 2 -1 1 1 1 2 0 1 24 1 3 0 2 0 1 1 1 0.00 0.00 0.00 6.00 2.38 1.65 0.81 2 1 1 1 1 7.67 7.48 10.35 0.00 0.00 0.00 0.00 3 -2 1 1 1 Series 3-root.Stomps2010.156 3 -1 1 1 1 1 27 3 14 14 3 0 3 0 1 1 1 0.00 0.00 0.00 2.81 6.13 7.69 1.64 3 1 1 1 1 26.57 217.53 -1.21 3.32 5.49 5.20 3.05 3 2 1 1 1 30.49 224.85 -3.52 8.27 5.09 9.56 1.34 3 3 1 1 1 24.02 123.82 -0.07 2.66 2.70 0.73 1.57 3 4 1 1 1 4.42 102.73 6.02 2.11 9.00 5.81 1.88 3 5 1 1 1 10.68 162.10 12.16 3.76 5.77 6.02 4.21 3 6 1 1 1 12.55 151.10 -2.14 2.70 10.23 6.28 4.20 3 7 1 1 1 26.21 112.92 -7.27 3.37 19.77 9.71 3.62 3 8 1 1 1 26.69 164.00 -1.74 8.30 14.94 10.74 2.28 3 9 1 1 1 29.35 155.72 4.26 18.01 9.64 7.73 5.34 3 10 1 1 1 25.13 121.70 -2.35 4.11 20.87 9.34 4.88 3 11 1 1 1 24.15 166.99 -8.72 8.06 13.42 12.49 1.95 3 12 1 1 1 13.32 166.43 10.48 4.68 17.79 9.98 4.91 3 13 1 1 1 28.90 187.39 16.45 8.70 9.57 3.41 3.98 3 14 1 1 1 22.48 192.12 5.14 12.46 5.44 1.65 2.50CaveConverter_src/test/data/regression/2649_Mareserection_ss_ref.svx0000644000000000000000000000253012114131474024626 0ustar rootroot*BEGIN 2649_Mareserection *EQUATE Mares070701.25 Mares0904085.0 *BEGIN Mares070701 *CALIBRATE declination 2.28 1 2 1.72 145.00 -47.00 2 3 2.90 353.00 -49.00 3 4 4.22 0.00 -90.00 4 5 4.95 103.00 11.00 5 6 2.17 72.00 40.00 6 7 2.51 100.00 -35.00 7 8 6.90 222.00 -11.00 7 9 2.98 68.00 19.00 9 10 3.00 110.00 -2.00 10 11 2.58 98.00 -11.00 11 12 4.80 0.00 -90.00 11 13 4.40 48.00 -11.00 13 14 2.30 20.00 -43.00 14 15 7.35 50.00 -4.00 15 16 7.35 35.00 -5.00 16 17 4.10 25.00 14.00 17 18 5.90 73.00 -5.00 18 19 7.40 32.00 -3.00 19 20 5.63 49.00 -3.00 20 21 3.91 110.00 -4.00 21 22 4.02 85.00 2.00 22 23 3.00 38.00 -3.00 23 24 3.30 150.00 -11.00 24 25 6.57 99.00 0.00 25 26 1.82 182.00 3.00 26 27 1.91 28.00 7.00 26 28 2.50 202.00 20.00 *END Mares070701 *BEGIN Mares0904085 *CALIBRATE declination 2.08 0 1 3.00 91.06 6.73 1 2 2.91 20.29 3.57 2 3 4.11 19.88 -2.27 3 4 2.03 331.14 4.87 4 5 2.43 28.98 -37.75 4 6 1.91 63.99 -6.15 6 7 3.35 32.37 -4.35 6 8 8.17 104.93 -1.38 8 9 1.78 139.35 4.60 9 10 2.70 100.81 0.36 10 11 4.72 56.33 -3.82 11 12 1.25 69.40 -4.66 12 13 2.95 112.51 -3.77 12 14 3.97 136.09 3.99 14 15 1.44 68.87 -26.54 15 16 2.30 131.94 -17.98 *END Mares0904085 *END 2649_Mareserection CaveConverter_src/test/data/regression/GourAven_pt_ref.text0000644000000000000000000000606012217344034023236 0ustar rootroot -6 1 1 1 1 Cave Name -5 1 1 1 1 0.00 0.00 0.00 1 0 -4 1 1 1 1 12/08/16 13:14:15 CaveConverter -3 1 1 1 1 -2 1 1 1 1 16/08/12 Converted Data 0 0.00 0 1 -1 1 1 1 1 360.00 360.00 0.05 1.00 1.00 100.00 0.00 1 -2 1 1 1 Series 1-root.GourAven2010.154 1 -1 1 1 1 1 0 1 31 31 3 0 1 0 1 1 1 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1 1 1 1 1 2.24 138.03 28.32 0.00 0.00 0.00 0.00 1 2 1 1 1 5.91 68.94 27.68 4.68 5.81 1.03 1.09 1 3 1 1 1 5.08 325.55 56.76 0.99 0.00 1.03 3.60 1 4 1 1 1 4.92 67.91 23.86 5.52 9.34 2.80 1.75 1 5 1 1 1 2.00 335.66 33.09 1.32 1.35 1.84 0.75 1 6 1 1 1 11.33 254.92 -5.02 0.98 2.71 0.90 1.13 1 7 1 1 1 4.83 313.49 34.36 4.27 4.00 5.17 1.33 1 8 1 1 1 10.95 53.79 35.32 0.00 2.18 3.27 1.36 1 9 1 1 1 9.78 63.92 3.27 1.68 0.83 1.69 0.61 1 10 1 1 1 4.02 63.11 22.07 0.27 0.24 0.52 0.36 1 11 1 1 1 2.66 122.85 6.23 1.47 1.13 0.98 0.26 1 12 1 1 1 4.68 26.31 41.16 2.09 5.63 6.53 2.98 1 13 1 1 1 4.74 255.91 20.70 0.31 0.00 0.60 0.83 1 14 1 1 1 3.65 236.22 -5.06 0.27 0.36 8.22 0.28 1 15 1 1 1 1.18 302.23 22.54 0.29 0.00 4.58 0.80 1 16 1 1 1 3.01 252.40 20.56 0.28 0.32 0.76 0.93 1 17 1 1 1 2.80 260.36 32.10 0.77 0.00 1.87 1.01 1 18 1 1 1 2.51 128.54 27.56 1.71 0.28 1.80 0.48 1 19 1 1 1 1.60 80.91 -6.44 0.00 0.63 1.34 0.48 1 20 1 1 1 2.62 204.21 -3.57 0.00 0.70 3.65 0.47 1 21 1 1 1 2.74 271.25 46.82 0.25 1.41 9.90 0.00 1 22 1 1 1 5.18 24.86 41.32 3.03 2.57 11.68 0.84 1 23 1 1 1 6.09 67.51 35.08 0.00 0.58 1.94 1.37 1 24 1 1 1 2.80 328.47 -45.49 0.00 0.84 0.83 0.81 1 25 1 1 1 3.96 22.72 -39.81 0.88 0.66 0.00 0.69 1 26 1 1 1 2.56 115.80 -45.71 1.17 0.00 1.02 0.39 1 27 1 1 1 2.20 84.02 -7.90 0.92 0.19 0.00 0.38 1 28 1 1 1 1.36 70.41 62.56 0.31 1.45 0.00 0.59 1 29 1 1 1 1.39 120.04 -18.84 1.58 0.00 1.80 6.23 1 30 1 1 1 0.86 108.40 6.35 0.00 0.00 0.00 0.00 1 31 1 1 1 8.52 166.76 -79.71 0.00 0.00 0.00 0.00CaveConverter_src/test/data/regression/T_LRUD_in.txt0000644000000000000000000001405012242127730021521 0ustar rootrootT (m, 360) [1]: 2004/11/06 0.00 1.0 0.000 0.00 0.00 1.0 2.220 155.07 -6.40 [1] 1.0 1.840 133.24 -87.58 [1] 1.0 8.970 68.59 -7.44 [1] 1.0 6.070 262.41 7.25 [1] 1.1 1.0 3.750 38.38 16.41 [1] 1.1 1.0 3.750 39.15 15.81 [1] 1.1 1.0 3.750 38.97 15.77 [1] 1.1 0.660 132.46 -9.51 [1] 1.1 1.350 120.54 81.60 [1] 1.1 0.620 321.23 5.67 [1] 1.2 1.1 2.860 359.74 -44.03 [1] 1.2 1.1 2.850 359.83 -44.12 [1] 1.2 1.1 2.840 359.73 -44.17 [1] 1.2 3.730 262.13 3.55 [1] 1.2 1.870 298.42 4.42 [1] 1.2 1.400 3.96 7.32 [1] 1.2 1.310 98.59 10.72 [1] 1.2 0.700 19.12 79.66 [1] 1.2 0.570 207.27 -82.52 [1] 1.3 1.2 3.220 356.13 -10.43 [1] 1.3 1.2 3.200 356.47 -10.24 [1] 1.3 1.2 3.210 356.25 -10.32 [1] 1.3 0.400 16.10 55.83 [1] 1.3 0.970 228.49 32.14 [1] 1.3 13.320 292.75 53.20 [1] 1.3 0.670 121.73 88.40 [1] 1.3 1.590 41.18 2.58 [1] 1.4 1.3 3.140 296.16 4.53 [1] 1.4 1.3 3.140 296.30 4.62 [1] 1.4 1.3 3.140 296.41 4.64 [1] 1.4 0.490 325.93 86.36 [1] 1.4 0.990 45.65 8.48 [1] 1.4 1.040 216.58 8.20 [1] 1.5 1.4 2.040 315.48 14.49 [1] 1.5 1.4 2.040 315.31 14.54 [1] 1.5 1.4 2.040 315.48 14.68 [1] 1.5 1.000 303.58 78.66 [1] 1.5 1.080 132.05 9.66 [1] 1.5 1.050 12.79 14.14 [1] 1.5 0.930 257.40 8.73 [1] 1.6 1.5 4.440 247.32 6.10 [1] 1.6 1.5 4.430 246.92 6.31 [1] 1.6 1.5 4.430 246.82 6.30 [1] 1.6 1.130 291.01 83.64 [1] 1.6 0.550 343.52 0.66 [1] 1.6 0.380 169.34 1.97 [1] 1.7 1.6 4.300 270.80 -2.47 [1] 1.7 1.6 4.290 270.44 -2.62 [1] 1.7 1.6 4.300 270.54 -2.62 [1] 1.7 0.460 338.63 5.07 [1] 1.7 0.310 257.49 86.93 [1] 1.7 0.520 32.05 -88.23 [1] 1.8 1.7 2.550 232.96 17.02 [1] 1.8 1.7 2.520 232.94 16.59 [1] 1.8 1.7 2.550 232.84 17.08 [1] 1.8 0.910 135.16 86.15 [1] 1.8 0.280 70.02 7.81 [1] 1.8 0.320 289.59 3.66 [1] 1.9 1.8 2.440 161.57 1.33 [1] 1.9 1.8 2.440 161.69 1.27 [1] 1.9 1.8 2.450 161.80 1.36 [1] 1.9 0.280 50.74 -0.39 [1] 1.9 0.820 141.52 82.58 [1] 1.9 0.520 232.22 4.93 [1] 1.9 2.240 331.35 37.29 [1] 1.10 1.9 1.300 83.37 4.53 [1] 1.10 1.9 1.300 83.77 5.02 [1] 1.10 1.9 1.300 84.11 5.11 [1] 1.10 0.280 144.57 81.81 [1] 1.10 0.420 206.99 -3.70 [1] 1.10 0.220 17.73 11.54 [1] 1.10 0.510 309.96 -84.07 [1] 1.10 0.860 132.99 -0.15 [1] 1.11 1.10 1.490 113.18 9.03 [1] 1.11 1.10 1.490 113.14 8.42 [1] 1.11 1.10 1.490 113.08 8.51 [1] 1.11 0.350 91.22 81.36 [1] 1.11 1.540 55.43 73.20 [1] 1.11 0.220 14.46 0.99 [1] 1.11 0.710 293.51 -84.27 [1] 1.11 2.280 294.59 -29.60 [1] 1.12 1.5 3.530 19.47 -12.56 [1] 1.12 1.5 3.510 19.54 -12.63 [1] 1.12 1.5 3.520 19.64 -12.78 [1] 1.12 1.080 313.28 85.16 [1] 1.12 0.310 223.51 1.01 [1] 1.12 0.930 80.12 6.52 [1] 1.12 0.590 125.92 -83.93 [1] 1.13 1.12 4.490 319.83 -1.46 [1] 1.13 1.12 4.500 319.96 -1.50 [1] 1.13 1.12 4.500 319.99 -1.82 [1] 1.13 0.840 13.20 79.99 [1] 1.13 0.150 68.57 6.43 [1] 1.13 0.610 248.49 12.06 [1] 1.14 1.13 2.940 10.29 -15.69 [1] 1.14 1.13 2.940 10.32 -15.79 [1] 1.14 1.13 2.960 10.28 -15.69 [1] 1.14 0.770 55.88 0.37 [1] 1.14 0.580 331.51 80.78 [1] 1.14 0.550 135.86 -86.18 [1] 1.14 0.130 239.04 4.24 [1] 1.14 1.15 2.710 145.81 -8.92 [1] 1.14 1.15 2.920 147.06 -9.42 [1] CaveConverter_src/test/data/regression/2649_Mares_from3d_in.dxf0000644000000000000000000003250411267320260023442 0ustar rootroot0 SECTION 2 HEADER 9 $EXTMIN 10 452220.000000 20 4800899.130000 30 261.730000 9 $EXTMAX 10 452310.550000 20 4800946.410000 30 274.000000 9 $PDMODE 70 3 9 $PDSIZE 40 0.80 0 ENDSEC 0 SECTION 2 TABLES 0 TABLE 2 LTYPE 70 10 0 LTYPE 2 CONTINUOUS 70 64 3 Continuous 72 65 73 0 40 0.0 0 LTYPE 2 DASHED 70 64 3 Dashed 72 65 73 2 40 2.5 49 1.25 49 -1.25 0 ENDTAB 0 TABLE 2 LAYER 70 10 0 LAYER 2 CentreLine 70 64 62 5 6 CONTINUOUS 0 LAYER 2 Stations 70 64 62 7 6 CONTINUOUS 0 LAYER 2 Labels 70 64 62 7 6 CONTINUOUS 0 LAYER 2 Surface 70 64 62 5 6 DASHED 0 LAYER 2 SurfaceStations 70 64 62 7 6 CONTINUOUS 0 LAYER 2 SurfaceLabels 70 64 62 7 6 CONTINUOUS 0 ENDTAB 0 ENDSEC 0 SECTION 2 ENTITIES 0 LINE 8 CentreLine 10 452220.00 20 4800904.00 30 274.00 11 452220.71 21 4800903.07 31 272.74 0 LINE 8 CentreLine 10 452220.71 20 4800903.07 30 272.74 11 452220.40 21 4800904.94 31 270.55 0 LINE 8 CentreLine 10 452220.40 20 4800904.94 30 270.55 11 452220.40 21 4800904.94 31 266.33 0 LINE 8 CentreLine 10 452220.40 20 4800904.94 30 266.33 11 452225.18 21 4800904.04 31 267.28 0 LINE 8 CentreLine 10 452225.18 20 4800904.04 30 267.28 11 452226.74 21 4800904.62 31 268.67 0 LINE 8 CentreLine 10 452226.74 20 4800904.62 30 268.67 11 452228.77 21 4800904.34 31 267.23 0 LINE 8 CentreLine 10 452228.77 20 4800904.34 30 267.23 11 452224.45 21 4800899.13 31 265.92 0 LINE 8 CentreLine 10 452228.77 20 4800904.34 30 267.23 11 452231.34 21 4800905.50 31 268.20 0 LINE 8 CentreLine 10 452231.34 20 4800905.50 30 268.20 11 452234.20 21 4800904.59 31 268.10 0 LINE 8 CentreLine 10 452234.20 20 4800904.59 30 268.10 11 452236.72 21 4800904.33 31 267.61 0 LINE 8 CentreLine 10 452236.72 20 4800904.33 30 267.61 11 452236.72 21 4800904.33 31 262.81 0 LINE 8 CentreLine 10 452236.72 20 4800904.33 30 267.61 11 452239.81 21 4800907.35 31 266.77 0 LINE 8 CentreLine 10 452239.81 20 4800907.35 30 266.77 11 452240.32 21 4800908.95 31 265.20 0 LINE 8 CentreLine 10 452240.32 20 4800908.95 30 265.20 11 452245.75 21 4800913.88 31 264.69 0 LINE 8 CentreLine 10 452245.75 20 4800913.88 30 264.69 11 452249.71 21 4800920.04 31 264.04 0 LINE 8 CentreLine 10 452249.71 20 4800920.04 30 264.04 11 452251.24 21 4800923.71 31 265.04 0 LINE 8 CentreLine 10 452251.24 20 4800923.71 30 265.04 11 452256.79 21 4800925.65 31 264.52 0 LINE 8 CentreLine 10 452256.79 20 4800925.65 30 264.52 11 452260.45 21 4800932.07 31 264.14 0 LINE 8 CentreLine 10 452260.45 20 4800932.07 30 264.14 11 452264.55 21 4800935.93 31 263.84 0 LINE 8 CentreLine 10 452264.55 20 4800935.93 30 263.84 11 452268.26 21 4800934.74 31 263.57 0 LINE 8 CentreLine 10 452268.26 20 4800934.74 30 263.57 11 452272.25 21 4800935.25 31 263.71 0 LINE 8 CentreLine 10 452272.25 20 4800935.25 30 263.71 11 452274.00 21 4800937.68 31 263.55 0 LINE 8 CentreLine 10 452274.00 20 4800937.68 30 263.55 11 452275.73 21 4800934.94 31 262.92 0 LINE 8 CentreLine 10 452275.73 20 4800934.94 30 262.92 11 452282.25 21 4800934.17 31 262.92 0 LINE 8 CentreLine 10 452282.25 20 4800934.17 30 262.92 11 452282.26 21 4800932.36 31 263.02 0 LINE 8 CentreLine 10 452282.26 20 4800932.36 30 263.02 11 452283.08 21 4800934.06 31 263.25 0 LINE 8 CentreLine 10 452282.26 20 4800932.36 30 263.02 11 452281.47 21 4800930.14 31 263.87 0 LINE 8 CentreLine 10 452282.25 20 4800934.17 30 262.92 11 452285.23 21 4800934.23 31 263.27 0 LINE 8 CentreLine 10 452285.23 20 4800934.23 30 263.27 11 452286.14 21 4800936.99 31 263.45 0 LINE 8 CentreLine 10 452286.14 20 4800936.99 30 263.45 11 452287.39 21 4800940.90 31 263.29 0 LINE 8 CentreLine 10 452287.39 20 4800940.90 30 263.29 11 452286.35 21 4800942.63 31 263.46 0 LINE 8 CentreLine 10 452286.35 20 4800942.63 30 263.46 11 452287.22 21 4800944.34 31 261.98 0 LINE 8 CentreLine 10 452286.35 20 4800942.63 30 263.46 11 452288.03 21 4800943.53 31 263.26 0 LINE 8 CentreLine 10 452288.03 20 4800943.53 30 263.26 11 452289.71 21 4800946.41 31 263.01 0 LINE 8 CentreLine 10 452288.03 20 4800943.53 30 263.26 11 452295.99 21 4800941.71 31 263.06 0 LINE 8 CentreLine 10 452295.99 20 4800941.71 30 263.06 11 452297.20 21 4800940.41 31 263.21 0 LINE 8 CentreLine 10 452297.20 20 4800940.41 30 263.21 11 452299.86 21 4800940.00 31 263.22 0 LINE 8 CentreLine 10 452299.86 20 4800940.00 30 263.22 11 452303.69 21 4800942.75 31 262.91 0 LINE 8 CentreLine 10 452303.69 20 4800942.75 30 262.91 11 452304.84 21 4800943.23 31 262.81 0 LINE 8 CentreLine 10 452304.84 20 4800943.23 30 262.81 11 452307.59 21 4800942.20 31 262.61 0 LINE 8 CentreLine 10 452304.84 20 4800943.23 30 262.81 11 452307.68 21 4800940.48 31 263.08 0 LINE 8 CentreLine 10 452307.68 20 4800940.48 30 263.08 11 452308.87 21 4800940.98 31 262.44 0 LINE 8 CentreLine 10 452308.87 20 4800940.98 30 262.44 11 452310.55 21 4800939.58 31 261.73 0 TEXT 8 Labels 10 452310.55 20 4800939.58 30 261.73 40 0.60 1 2649_mareserection.mares0904085.16 0 POINT 8 Stations 10 452310.55 20 4800939.58 30 261.73 0 TEXT 8 Labels 10 452308.87 20 4800940.98 30 262.44 40 0.60 1 2649_mareserection.mares0904085.15 0 POINT 8 Stations 10 452308.87 20 4800940.98 30 262.44 0 TEXT 8 Labels 10 452307.68 20 4800940.48 30 263.08 40 0.60 1 2649_mareserection.mares0904085.14 0 POINT 8 Stations 10 452307.68 20 4800940.48 30 263.08 0 TEXT 8 Labels 10 452307.59 20 4800942.20 30 262.61 40 0.60 1 2649_mareserection.mares0904085.13 0 POINT 8 Stations 10 452307.59 20 4800942.20 30 262.61 0 TEXT 8 Labels 10 452304.84 20 4800943.23 30 262.81 40 0.60 1 2649_mareserection.mares0904085.12 0 POINT 8 Stations 10 452304.84 20 4800943.23 30 262.81 0 TEXT 8 Labels 10 452303.69 20 4800942.75 30 262.91 40 0.60 1 2649_mareserection.mares0904085.11 0 POINT 8 Stations 10 452303.69 20 4800942.75 30 262.91 0 TEXT 8 Labels 10 452299.86 20 4800940.00 30 263.22 40 0.60 1 2649_mareserection.mares0904085.10 0 POINT 8 Stations 10 452299.86 20 4800940.00 30 263.22 0 TEXT 8 Labels 10 452297.20 20 4800940.41 30 263.21 40 0.60 1 2649_mareserection.mares0904085.9 0 POINT 8 Stations 10 452297.20 20 4800940.41 30 263.21 0 TEXT 8 Labels 10 452295.99 20 4800941.71 30 263.06 40 0.60 1 2649_mareserection.mares0904085.8 0 POINT 8 Stations 10 452295.99 20 4800941.71 30 263.06 0 TEXT 8 Labels 10 452289.71 20 4800946.41 30 263.01 40 0.60 1 2649_mareserection.mares0904085.7 0 POINT 8 Stations 10 452289.71 20 4800946.41 30 263.01 0 TEXT 8 Labels 10 452288.03 20 4800943.53 30 263.26 40 0.60 1 2649_mareserection.mares0904085.6 0 POINT 8 Stations 10 452288.03 20 4800943.53 30 263.26 0 TEXT 8 Labels 10 452287.22 20 4800944.34 30 261.98 40 0.60 1 2649_mareserection.mares0904085.5 0 POINT 8 Stations 10 452287.22 20 4800944.34 30 261.98 0 TEXT 8 Labels 10 452286.35 20 4800942.63 30 263.46 40 0.60 1 2649_mareserection.mares0904085.4 0 POINT 8 Stations 10 452286.35 20 4800942.63 30 263.46 0 TEXT 8 Labels 10 452287.39 20 4800940.90 30 263.29 40 0.60 1 2649_mareserection.mares0904085.3 0 POINT 8 Stations 10 452287.39 20 4800940.90 30 263.29 0 TEXT 8 Labels 10 452286.14 20 4800936.99 30 263.45 40 0.60 1 2649_mareserection.mares0904085.2 0 POINT 8 Stations 10 452286.14 20 4800936.99 30 263.45 0 TEXT 8 Labels 10 452285.23 20 4800934.23 30 263.27 40 0.60 1 2649_mareserection.mares0904085.1 0 POINT 8 Stations 10 452285.23 20 4800934.23 30 263.27 0 TEXT 8 Labels 10 452282.25 20 4800934.17 30 262.92 40 0.60 1 2649_mareserection.mares0904085.0 0 POINT 8 Stations 10 452282.25 20 4800934.17 30 262.92 0 TEXT 8 Labels 10 452281.47 20 4800930.14 30 263.87 40 0.60 1 2649_mareserection.mares070701.28 0 POINT 8 Stations 10 452281.47 20 4800930.14 30 263.87 0 TEXT 8 Labels 10 452283.08 20 4800934.06 30 263.25 40 0.60 1 2649_mareserection.mares070701.27 0 POINT 8 Stations 10 452283.08 20 4800934.06 30 263.25 0 TEXT 8 Labels 10 452282.26 20 4800932.36 30 263.02 40 0.60 1 2649_mareserection.mares070701.26 0 POINT 8 Stations 10 452282.26 20 4800932.36 30 263.02 0 TEXT 8 Labels 10 452282.25 20 4800934.17 30 262.92 40 0.60 1 2649_mareserection.mares070701.25 0 POINT 8 Stations 10 452282.25 20 4800934.17 30 262.92 0 TEXT 8 Labels 10 452275.73 20 4800934.94 30 262.92 40 0.60 1 2649_mareserection.mares070701.24 0 POINT 8 Stations 10 452275.73 20 4800934.94 30 262.92 0 TEXT 8 Labels 10 452274.00 20 4800937.68 30 263.55 40 0.60 1 2649_mareserection.mares070701.23 0 POINT 8 Stations 10 452274.00 20 4800937.68 30 263.55 0 TEXT 8 Labels 10 452272.25 20 4800935.25 30 263.71 40 0.60 1 2649_mareserection.mares070701.22 0 POINT 8 Stations 10 452272.25 20 4800935.25 30 263.71 0 TEXT 8 Labels 10 452268.26 20 4800934.74 30 263.57 40 0.60 1 2649_mareserection.mares070701.21 0 POINT 8 Stations 10 452268.26 20 4800934.74 30 263.57 0 TEXT 8 Labels 10 452264.55 20 4800935.93 30 263.84 40 0.60 1 2649_mareserection.mares070701.20 0 POINT 8 Stations 10 452264.55 20 4800935.93 30 263.84 0 TEXT 8 Labels 10 452260.45 20 4800932.07 30 264.14 40 0.60 1 2649_mareserection.mares070701.19 0 POINT 8 Stations 10 452260.45 20 4800932.07 30 264.14 0 TEXT 8 Labels 10 452256.79 20 4800925.65 30 264.52 40 0.60 1 2649_mareserection.mares070701.18 0 POINT 8 Stations 10 452256.79 20 4800925.65 30 264.52 0 TEXT 8 Labels 10 452251.24 20 4800923.71 30 265.04 40 0.60 1 2649_mareserection.mares070701.17 0 POINT 8 Stations 10 452251.24 20 4800923.71 30 265.04 0 TEXT 8 Labels 10 452249.71 20 4800920.04 30 264.04 40 0.60 1 2649_mareserection.mares070701.16 0 POINT 8 Stations 10 452249.71 20 4800920.04 30 264.04 0 TEXT 8 Labels 10 452245.75 20 4800913.88 30 264.69 40 0.60 1 2649_mareserection.mares070701.15 0 POINT 8 Stations 10 452245.75 20 4800913.88 30 264.69 0 TEXT 8 Labels 10 452240.32 20 4800908.95 30 265.20 40 0.60 1 2649_mareserection.mares070701.14 0 POINT 8 Stations 10 452240.32 20 4800908.95 30 265.20 0 TEXT 8 Labels 10 452239.81 20 4800907.35 30 266.77 40 0.60 1 2649_mareserection.mares070701.13 0 POINT 8 Stations 10 452239.81 20 4800907.35 30 266.77 0 TEXT 8 Labels 10 452236.72 20 4800904.33 30 262.81 40 0.60 1 2649_mareserection.mares070701.12 0 POINT 8 Stations 10 452236.72 20 4800904.33 30 262.81 0 TEXT 8 Labels 10 452236.72 20 4800904.33 30 267.61 40 0.60 1 2649_mareserection.mares070701.11 0 POINT 8 Stations 10 452236.72 20 4800904.33 30 267.61 0 TEXT 8 Labels 10 452234.20 20 4800904.59 30 268.10 40 0.60 1 2649_mareserection.mares070701.10 0 POINT 8 Stations 10 452234.20 20 4800904.59 30 268.10 0 TEXT 8 Labels 10 452231.34 20 4800905.50 30 268.20 40 0.60 1 2649_mareserection.mares070701.9 0 POINT 8 Stations 10 452231.34 20 4800905.50 30 268.20 0 TEXT 8 Labels 10 452224.45 20 4800899.13 30 265.92 40 0.60 1 2649_mareserection.mares070701.8 0 POINT 8 Stations 10 452224.45 20 4800899.13 30 265.92 0 TEXT 8 Labels 10 452228.77 20 4800904.34 30 267.23 40 0.60 1 2649_mareserection.mares070701.7 0 POINT 8 Stations 10 452228.77 20 4800904.34 30 267.23 0 TEXT 8 Labels 10 452226.74 20 4800904.62 30 268.67 40 0.60 1 2649_mareserection.mares070701.6 0 POINT 8 Stations 10 452226.74 20 4800904.62 30 268.67 0 TEXT 8 Labels 10 452225.18 20 4800904.04 30 267.28 40 0.60 1 2649_mareserection.mares070701.5 0 POINT 8 Stations 10 452225.18 20 4800904.04 30 267.28 0 TEXT 8 Labels 10 452220.40 20 4800904.94 30 266.33 40 0.60 1 2649_mareserection.mares070701.4 0 POINT 8 Stations 10 452220.40 20 4800904.94 30 266.33 0 TEXT 8 Labels 10 452220.40 20 4800904.94 30 270.55 40 0.60 1 2649_mareserection.mares070701.3 0 POINT 8 Stations 10 452220.40 20 4800904.94 30 270.55 0 TEXT 8 Labels 10 452220.71 20 4800903.07 30 272.74 40 0.60 1 2649_mareserection.mares070701.2 0 POINT 8 Stations 10 452220.71 20 4800903.07 30 272.74 0 TEXT 8 Labels 10 452220.00 20 4800904.00 30 274.00 40 0.60 1 2649_mareserection.mares070701.1 0 POINT 8 Stations 10 452220.00 20 4800904.00 30 274.00 000 ENDSEC 000 EOF CaveConverter_src/test/data/regression/Sloppy2ZigZags_ps_ref.svx0000644000000000000000000003325712226764012024224 0ustar rootroot*BEGIN uzu110810sloppypt2 *EQUATE 158.12 161.0 *EQUATE 161.4 165.1 *BEGIN 161 *DATE 2009.01.07 *FLAGS SPLAY 0 0a 1.29 125.73 0.46 0 0b 1.61 306.94 3.61 0 0c 8.58 203.24 85.39 0 0d 1.79 169.15 -88.07 0 0e 2.53 190.96 4.20 0 0f 2.31 237.87 9.54 0 0g 2.83 253.54 9.73 0 0h 2.16 277.70 11.01 0 0i 1.31 43.80 6.31 *FLAGS NOT SPLAY 0 1 8.84 224.95 74.29 *FLAGS SPLAY 1 1a 0.77 135.02 -4.75 1 1b 1.85 55.20 85.87 1 1c 0.68 190.60 -87.21 *FLAGS NOT SPLAY 1 2 1.29 177.76 16.14 *FLAGS SPLAY 2 2a 0.72 31.98 -4.09 2 2b 2.25 349.48 77.56 2 2c 0.82 175.67 -88.21 *FLAGS NOT SPLAY 2 3 9.45 62.80 8.45 *FLAGS SPLAY 3 3a 0.76 207.08 2.14 3 3b 4.88 114.75 84.07 3 3c 1.07 299.88 -83.79 3 3d 1.45 243.11 1.63 3 3e 2.05 261.73 3.02 *FLAGS NOT SPLAY 3 4 3.09 174.44 77.16 *FLAGS SPLAY 4 4a 0.79 15.24 0.85 4 4b 4.21 52.64 86.09 4 4c 1.25 226.64 -88.43 *FLAGS NOT SPLAY 4 5 3.04 80.70 -0.77 *FLAGS SPLAY 5 5a 0.49 313.79 -1.74 5 5b 4.40 124.69 83.71 5 5c 0.97 67.93 -87.52 *FLAGS NOT SPLAY 5 6 7.44 29.62 5.20 *FLAGS SPLAY 6 6a 0.77 127.34 17.64 6 6b 4.97 41.63 85.19 6 6c 0.73 257.84 -82.51 *FLAGS NOT SPLAY 6 7 5.85 35.05 1.09 *FLAGS SPLAY 7 7a 0.58 282.01 8.71 7 7b 8.62 351.28 81.03 7 7c 0.55 153.97 -74.30 7 7d 3.17 349.34 3.84 7 7e 3.04 20.21 3.70 *FLAGS NOT SPLAY 7 8 9.45 7.85 51.31 *FLAGS SPLAY 8 8a 0.69 134.64 -0.49 8 8b 4.51 93.69 78.99 8 8c 1.88 52.36 -82.29 *FLAGS NOT SPLAY 8 9 2.60 65.73 -6.30 *FLAGS SPLAY 9 9a 0.62 298.10 5.15 9 9b 4.36 19.40 82.85 9 9c 1.08 191.79 -82.85 *FLAGS NOT SPLAY 9 10 4.48 6.77 7.25 *FLAGS SPLAY 10 10a 0.67 115.96 -1.72 10 10b 4.30 115.63 80.16 10 10c 0.74 273.75 -86.19 *FLAGS NOT SPLAY 10 11 3.86 56.51 1.91 *FLAGS SPLAY 11 11a 0.67 323.14 -8.75 11 11b 4.24 25.54 78.35 11 11c 0.56 60.57 -78.89 11 11d 2.62 20.06 7.07 *FLAGS NOT SPLAY 11 12 7.66 28.32 10.32 *FLAGS SPLAY 12 12a 0.47 241.61 -4.41 12 12b 3.69 68.94 85.50 12 12c 0.82 238.09 -83.13 *FLAGS NOT SPLAY 12 13 1.09 289.21 11.36 *FLAGS SPLAY 13 13a 0.63 170.24 -3.66 13 13b 3.37 228.42 84.55 13 13c 0.97 278.10 -82.95 *FLAGS NOT SPLAY 13 14 3.87 230.95 3.41 *FLAGS SPLAY 14 14a 0.70 333.35 5.84 14 14b 3.42 255.12 80.83 14 14c 0.94 291.68 -80.13 *FLAGS NOT SPLAY 14 15 4.60 249.81 2.49 *FLAGS SPLAY 15 15a 0.76 354.29 2.52 15 15b 3.44 282.49 80.49 15 15c 0.84 294.69 -76.37 *FLAGS NOT SPLAY 15 16 4.46 260.87 6.91 *FLAGS SPLAY 16 16a 0.60 149.22 -7.74 16 16b 2.28 213.07 85.82 16 16c 0.94 293.42 -82.12 *FLAGS NOT SPLAY 16 17 7.41 236.86 0.94 *FLAGS SPLAY 17 17a 1.14 336.21 12.30 17 17b 7.30 273.47 83.19 17 17c 0.82 344.65 -74.47 *FLAGS NOT SPLAY 17 18 1.79 282.80 9.24 *FLAGS SPLAY 18 18a 1.40 148.94 -7.89 18 18b 6.31 248.22 83.95 18 18c 1.08 124.24 -85.92 *FLAGS NOT SPLAY 18 19 14.75 240.76 9.56 *FLAGS SPLAY 19 19a 0.59 2.64 1.55 19 19b 1.25 157.25 -8.40 19 19c 48.31 69.00 85.56 19 19d 1.91 72.56 -82.37 19 19e 4.57 16.43 28.14 19 19f 7.14 49.84 15.92 19 19g 7.11 72.91 15.16 *FLAGS NOT SPLAY *data passage station left right up down 0 1.41 1.69 8.55 1.79 1 0.71 0.00 1.85 0.67 2 0.72 0.00 2.20 0.82 3 0.00 0.76 4.85 1.06 4 0.73 0.00 4.20 1.25 5 0.48 0.00 4.37 0.97 6 0.00 0.73 4.95 0.72 7 1.68 0.00 8.51 0.53 8 0.00 0.68 4.43 1.86 9 0.61 0.00 4.33 1.07 10 0.00 0.67 4.23 0.74 11 0.99 0.00 4.15 0.55 12 0.46 0.00 3.68 0.81 13 0.63 0.00 3.35 0.96 14 0.00 0.70 3.37 0.93 15 0.00 0.75 3.39 0.82 16 0.59 0.00 2.27 0.93 17 0.00 1.09 7.25 0.79 18 1.28 0.00 6.28 1.08 19 1.44 2.82 48.16 1.89 *END 161 *BEGIN 165 *DATE 2012.04.10 *CALIBRATE declination 2.0 *FLAGS SPLAY 1 1a 0.57 195.52 4.07 1 1b 0.49 9.16 1.22 1 1c 3.84 348.92 79.39 1 1d 1.62 119.01 -75.94 *FLAGS NOT SPLAY 1 2 3.48 281.26 27.52 *FLAGS SPLAY 2 2a 0.97 136.15 5.76 2 2b 1.76 127.66 70.72 2 2c 1.46 148.72 -73.46 *FLAGS NOT SPLAY 2 3 2.13 191.02 1.42 *FLAGS SPLAY 3 3a 0.52 307.04 3.20 3 3b 1.70 163.78 88.49 3 3c 1.49 307.66 -88.82 *FLAGS NOT SPLAY 3 4 7.43 222.22 -1.21 *FLAGS SPLAY 4 4a 0.42 135.38 -2.58 4 4b 1.50 120.01 74.02 4 4c 1.52 141.14 -83.93 *FLAGS NOT SPLAY 4 5 2.23 224.28 -4.17 *FLAGS SPLAY 5 5a 0.43 123.66 -2.22 5 5b 1.49 167.01 79.72 5 5c 1.39 129.13 -67.70 *FLAGS NOT SPLAY 5 6 3.41 205.94 2.50 *FLAGS SPLAY 6 6a 0.60 306.67 2.25 6 6b 1.44 286.64 87.04 6 6c 1.42 254.09 -86.11 *FLAGS NOT SPLAY 6 7 3.12 212.10 -3.17 *FLAGS SPLAY 7 7a 0.46 300.23 3.93 7 7b 1.64 295.43 79.84 7 7c 1.29 330.51 -77.32 *FLAGS NOT SPLAY 7 8 3.01 223.50 -0.83 8 9 1.53 227.01 0.71 *FLAGS SPLAY 9 9a 0.50 135.95 1.21 9 9b 1.60 213.07 84.96 9 9c 1.28 103.24 -86.61 *FLAGS NOT SPLAY 9 10 4.13 230.74 -1.52 *FLAGS SPLAY 10 10a 0.52 325.70 -0.62 10 10b 1.63 297.20 82.81 10 10c 1.23 73.64 -86.45 *FLAGS NOT SPLAY 10 11 3.15 233.34 3.49 *FLAGS SPLAY 11 11a 0.59 131.07 4.86 11 11b 1.56 120.17 77.10 11 11c 1.27 116.04 -80.16 *FLAGS NOT SPLAY 11 12 7.29 213.25 -3.92 *FLAGS SPLAY 12 12a 1.69 146.32 87.47 12 12b 0.42 126.70 -0.32 12 12c 1.28 252.88 -86.19 *FLAGS NOT SPLAY 12 13 6.48 212.26 -46.98 *FLAGS SPLAY 13 13a 4.12 42.62 77.87 13 13b 1.06 314.62 6.76 13 13c 0.20 124.55 9.65 13 13d 1.60 286.44 -72.64 *FLAGS NOT SPLAY 13 14 2.54 235.48 -15.60 *FLAGS SPLAY 14 14a 0.63 107.29 -5.03 14 14b 1.50 136.97 79.16 14 14c 1.64 119.00 -83.97 *FLAGS NOT SPLAY 14 15 1.92 202.22 -38.76 *FLAGS SPLAY 15 15a 0.89 53.89 -6.97 15 15b 2.58 44.23 83.91 15 15c 1.54 98.15 -88.39 *FLAGS NOT SPLAY 15 16 3.08 81.63 -16.60 *FLAGS SPLAY 16 16a 0.44 352.06 0.95 16 16b 1.29 359.99 78.22 16 16c 1.03 228.83 -82.68 *FLAGS NOT SPLAY 16 17 2.89 92.67 -62.02 *FLAGS SPLAY 17 17a 0.75 321.88 -5.34 17 17b 3.74 21.79 78.45 17 17c 1.45 2.70 -78.49 *FLAGS NOT SPLAY 17 18 4.26 53.58 -27.46 *FLAGS SPLAY 18 18a 0.32 136.32 6.59 18 18b 8.45 197.33 81.96 18 18c 0.89 342.97 -73.79 *FLAGS NOT SPLAY 18 19 4.32 46.44 -3.26 *FLAGS SPLAY 19 19a 0.42 306.43 -0.14 19 19b 1.11 259.87 88.38 19 19c 0.19 125.54 0.08 19 19d 0.58 205.77 -87.87 *FLAGS NOT SPLAY 19 20 1.58 52.71 -1.32 *FLAGS SPLAY 20 20a 0.45 166.31 -2.61 20 20b 1.01 159.34 77.94 20 20c 0.52 232.63 -86.75 20 20d 0.94 312.95 2.07 20 20e 2.52 351.69 -10.78 *FLAGS NOT SPLAY 20 21 2.13 80.12 -0.95 *FLAGS SPLAY 21 21a 0.41 332.70 -0.54 21 21b 0.43 132.90 6.63 21 21c 0.94 342.23 -80.06 *FLAGS NOT SPLAY 21 22 1.40 48.91 -4.57 *FLAGS SPLAY 22 22a 1.00 290.40 -3.78 22 22b 0.37 99.12 -88.04 22 22c 1.32 324.20 59.29 *FLAGS NOT SPLAY 22 23 3.09 6.26 -4.89 *FLAGS SPLAY 23 23a 0.43 256.35 2.38 23 23b 1.00 238.69 83.28 23 23c 0.22 190.83 -84.72 *FLAGS NOT SPLAY 23 24 3.19 42.15 4.79 *FLAGS SPLAY 24 24a 0.78 125.57 -5.13 24 24b 0.80 142.71 55.91 24 24c 0.48 280.12 -86.86 *FLAGS NOT SPLAY 24 25 3.04 29.71 -4.19 *FLAGS SPLAY 25 25a 0.34 112.86 -4.40 25 25b 1.46 127.38 85.25 25 25c 0.44 170.35 -87.52 *FLAGS NOT SPLAY 25 26 5.16 27.70 -2.06 *FLAGS SPLAY 26 26a 0.77 171.11 -0.62 26 26b 1.71 170.49 74.14 26 26c 0.78 178.54 -63.02 *FLAGS NOT SPLAY 26 27 0.89 133.24 21.14 *FLAGS SPLAY 27 27a 0.44 357.20 -2.32 27 27b 1.20 355.05 86.80 27 27c 1.00 115.85 -87.48 *FLAGS NOT SPLAY 27 28 3.49 84.55 -0.49 *FLAGS SPLAY 28 28a 0.37 344.06 -1.58 28 28b 1.23 19.15 79.45 28 28c 1.10 354.08 -82.52 *FLAGS NOT SPLAY 28 29 4.49 57.41 0.19 *FLAGS SPLAY 29 29a 0.54 322.47 -0.38 29 29b 0.87 358.54 75.77 29 29c 1.23 333.67 -79.23 *FLAGS NOT SPLAY 29 30 4.20 52.71 -1.95 *FLAGS SPLAY 30 30a 0.56 140.60 -1.62 30 30b 1.11 146.54 80.67 30 30c 1.19 240.45 -85.53 *FLAGS NOT SPLAY 30 31 3.19 70.91 1.33 *FLAGS SPLAY 31 31a 0.35 314.08 -0.84 31 31b 1.00 0.39 80.18 31 31c 1.46 312.34 -75.60 *FLAGS NOT SPLAY 31 32 1.95 41.99 -0.84 *FLAGS SPLAY 32 32a 0.39 186.52 -0.46 32 32b 1.14 178.57 73.45 32 32c 1.44 169.78 -83.20 *FLAGS NOT SPLAY 32 33 1.18 108.78 -27.67 *FLAGS SPLAY 33 33a 0.59 334.23 -1.87 33 33b 0.24 158.16 0.40 33 33c 0.82 320.62 -85.87 33 33d 1.84 7.88 79.12 *FLAGS NOT SPLAY 33 34 2.03 41.06 -1.30 *FLAGS SPLAY 34 34a 0.53 325.09 5.51 34 34b 1.80 189.89 84.38 34 34c 0.82 37.21 -83.66 *FLAGS NOT SPLAY 34 35 4.68 61.76 1.03 *FLAGS SPLAY 35 35a 0.44 143.45 -4.62 35 35b 1.38 128.03 79.97 35 35c 0.98 108.51 -80.68 *FLAGS NOT SPLAY 35 36 3.57 48.05 1.36 *FLAGS SPLAY 36 36a 0.49 160.34 -9.61 36 36b 0.76 117.65 78.72 36 36c 1.26 168.57 -78.98 *FLAGS NOT SPLAY 36 37 2.13 86.68 -1.42 *FLAGS SPLAY 37 37a 0.51 323.59 5.31 37 37b 0.84 327.69 77.28 37 37c 1.07 336.30 -83.29 *FLAGS NOT SPLAY 37 38 2.37 49.91 -8.73 *FLAGS SPLAY 38 38a 0.48 142.08 14.04 38 38b 1.35 145.26 78.67 38 38c 0.80 318.62 -84.61 *FLAGS NOT SPLAY 38 39 3.65 63.15 4.37 *FLAGS SPLAY 39 39a 0.44 300.17 0.71 39 39b 1.04 328.75 82.92 39 39c 1.05 30.60 -77.32 *FLAGS NOT SPLAY 39 40 2.65 25.59 -2.53 *FLAGS SPLAY 40 40a 0.41 141.83 0.73 40 40b 1.02 117.47 80.38 40 40c 0.96 102.40 -69.23 *FLAGS NOT SPLAY 40 41 7.85 65.58 1.85 *FLAGS SPLAY 41 41a 0.83 225.24 7.58 41 41b 0.87 171.67 86.94 41 41c 1.53 219.66 -55.51 *FLAGS NOT SPLAY 41 42 3.98 215.85 -4.71 *FLAGS SPLAY 42 42a 0.48 316.97 -2.80 42 42b 1.06 300.08 80.57 42 42c 0.99 285.35 -78.94 *FLAGS NOT SPLAY 42 43 2.22 233.70 0.55 *FLAGS SPLAY 43 43a 0.49 125.18 -0.62 43 43b 1.25 162.06 78.16 43 43c 1.04 121.55 -82.42 *FLAGS NOT SPLAY 43 44 4.04 203.86 -0.25 *FLAGS SPLAY 44 44a 0.43 299.26 1.05 44 44b 1.07 200.85 78.05 44 44c 1.17 304.96 -85.05 *FLAGS NOT SPLAY 44 45 5.66 233.77 0.58 ;Disto batteries changed and disto recalibrated before this leg. *FLAGS SPLAY 45 45a 0.46 114.52 -12.27 45 45b 0.96 123.34 64.03 45 45c 1.36 146.04 -73.97 *FLAGS NOT SPLAY 45 46 2.15 186.79 -5.67 *FLAGS SPLAY 46 46a 0.34 284.71 6.20 46 46b 1.03 303.37 79.18 46 46c 1.23 216.15 -83.25 *FLAGS NOT SPLAY 46 47 2.69 210.08 -0.93 *FLAGS SPLAY 47 47a 0.42 132.35 2.41 47 47b 0.94 148.66 82.13 47 47c 1.03 152.70 -87.23 *FLAGS NOT SPLAY 47 48 1.42 230.57 -1.37 *FLAGS SPLAY 48 48a 0.42 143.81 -1.72 48 48b 1.21 164.82 72.39 48 48c 1.17 178.23 -82.45 *FLAGS NOT SPLAY 48 49 2.10 240.59 0.28 *FLAGS SPLAY 49 49a 0.34 144.54 -2.81 49 49b 1.07 140.06 72.28 49 49c 1.14 148.33 -84.52 *FLAGS NOT SPLAY 49 50 3.47 237.36 -2.97 *FLAGS SPLAY 50 50a 0.39 342.06 4.00 50 50b 1.00 213.59 85.36 50 50c 1.12 355.33 -83.46 *FLAGS NOT SPLAY 50 51 2.90 256.53 4.59 *FLAGS SPLAY 51 51a 0.34 148.28 -8.51 51 51b 0.88 141.02 77.66 51 51c 1.43 132.19 -87.31 *FLAGS NOT SPLAY 51 52 3.17 240.12 -3.07 *FLAGS SPLAY 52 52a 0.42 319.87 -2.28 52 52b 0.87 109.67 87.31 52 52c 1.36 303.04 -83.50 *FLAGS NOT SPLAY 52 53 2.60 232.18 -0.80 *FLAGS SPLAY 53 53a 0.35 305.99 3.07 53 53b 1.01 139.41 87.41 53 53c 1.66 309.66 -77.10 *FLAGS NOT SPLAY 53 54 4.54 221.12 -21.78 *FLAGS SPLAY 54 54a 0.56 125.43 -3.35 54 54b 2.11 135.69 69.41 54 54c 1.13 232.20 -85.00 *FLAGS NOT SPLAY 54 55 1.20 181.22 -8.12 *FLAGS SPLAY 55 55a 0.62 284.76 -5.11 55 55b 2.02 219.37 82.06 55 55c 3.36 237.83 -84.61 *FLAGS NOT SPLAY 55 56 1.94 154.16 -70.71 *FLAGS SPLAY 56 56a 1.45 280.79 0.23 56 56b 3.92 286.08 82.18 56 56c 1.94 266.28 -63.29 *FLAGS NOT SPLAY 56 57 5.60 228.25 -6.94 *FLAGS SPLAY 57 57a 0.66 140.56 -17.36 57 57b 0.66 148.24 53.81 57 57c 1.18 95.03 -74.03 *FLAGS NOT SPLAY 57 58 6.32 217.05 -41.16 *FLAGS SPLAY 58 58a 1.04 141.20 -11.06 58 58b 1.98 317.32 -13.13 58 58c 2.96 289.31 83.86 58 58d 0.38 164.39 -87.86 58 58e 4.16 41.63 18.73 *FLAGS NOT SPLAY *data passage station left right up down 1 0.57 0.49 3.78 1.58 2 0.95 0.00 1.66 1.40 3 0.00 0.51 1.70 1.49 4 0.42 0.00 1.44 1.51 5 0.53 0.00 1.47 1.29 6 0.00 0.59 1.44 1.42 7 0.00 0.46 1.61 1.26 8 0.00 0.00 0.00 0.00 9 0.49 0.00 1.59 1.28 10 0.00 0.52 1.61 1.23 11 0.59 0.00 1.52 1.25 12 0.42 0.00 1.69 1.28 13 0.20 1.05 4.03 1.53 14 0.58 0.00 1.47 1.63 15 0.89 0.00 2.57 1.54 16 0.44 0.00 1.27 1.02 17 0.70 0.00 3.66 1.42 18 0.00 0.32 8.36 0.85 19 0.41 0.18 1.11 0.58 20 2.39 0.45 0.98 0.52 21 0.41 0.40 0.00 0.92 22 0.99 0.00 1.14 0.37 23 0.34 0.00 1.00 0.22 24 0.00 0.78 0.66 0.48 25 0.00 0.34 1.46 0.44 26 0.00 0.77 1.64 0.69 27 0.41 0.00 1.19 1.00 28 0.37 0.00 1.21 1.09 29 0.54 0.00 0.84 1.20 30 0.00 0.55 1.10 1.19 31 0.34 0.00 0.98 1.42 32 0.00 0.36 1.09 1.43 33 0.58 0.24 1.81 0.82 34 0.53 0.00 1.79 0.81 35 0.00 0.44 1.35 0.97 36 0.00 0.48 0.75 1.24 37 0.49 0.00 0.81 1.06 38 0.00 0.46 1.32 0.80 39 0.43 0.00 1.03 1.02 40 0.00 0.41 1.00 0.89 41 0.00 0.85 0.87 1.26 42 0.00 0.48 1.04 0.97 43 0.49 0.00 1.23 1.04 44 0.00 0.42 1.05 1.16 45 0.45 0.00 0.86 1.31 46 0.00 0.34 1.01 1.22 47 0.42 0.00 0.93 1.03 48 0.41 0.00 1.15 1.16 49 0.34 0.00 1.02 1.13 50 0.00 0.38 1.00 1.12 51 0.34 0.00 0.86 1.43 52 0.00 0.42 0.87 1.35 53 0.00 0.35 1.00 1.62 54 0.68 0.00 1.98 1.12 55 0.00 0.55 2.00 3.34 56 0.00 1.45 3.88 1.73 57 0.63 0.00 0.53 1.13 58 0.99 1.90 2.95 0.37 *END 165 *END uzu110810sloppypt2 CaveConverter_src/test/data/regression/calibrations_ss_ref.svx0000644000000000000000000000706212172776722024040 0ustar rootroot*BEGIN Swildons *EQUATE Ent EntranceZigZags.3 *EQUATE surfacegps.4 EntranceZigZags.3 *EQUATE EntranceZigZags.5 LongDryWay.part1.0 *EQUATE EntranceZigZags.21 LongDryWay.part1.5 *EQUATE ShortDryWay.0 EntranceZigZags.21 *BEGIN surfacegps *CALIBRATE declination 1.58 0 1 9.84 94.37 -5.88 1 2 7.84 97.65 -8.05 2 3 11.76 94.27 -17.67 3 4 4.38 7.38 -23.29 3 5 5.45 262.93 13.06 5 6 8.80 174.95 11.61 6 7 13.78 168.31 12.55 *END surfacegps *BEGIN EntranceZigZags *CALIBRATE declination 0.6 *CALIBRATE compass 1.1 *CALIBRATE clino -0.1 0 1 2.98 10.26 -2.01 0 2 5.24 3.23 -5.04 2 3 2.64 166.70 -60.11 3 4 3.10 330.76 -25.13 4 5 4.51 275.80 -12.10 5 6 2.41 50.67 -22.33 6 7 1.08 37.30 11.53 7 8 2.00 6.10 11.51 8 9 1.01 56.60 0.18 9 10 3.07 336.52 5.81 9 11 2.42 64.64 5.29 11 12 4.50 106.56 19.29 10 13 0.94 80.55 -45.63 13 14 5.31 65.16 19.50 10 15 3.27 329.15 -18.16 15 16 3.57 334.08 -6.33 16 17 2.41 207.98 -9.43 17 18 4.05 308.01 -19.25 18 19 2.06 211.48 -16.06 19 20 2.94 233.55 -35.84 20 21 2.04 14.57 -39.09 *END EntranceZigZags *BEGIN LongDryWay *CALIBRATE declination 3.63 *CALIBRATE compass -2.0 *CALIBRATE clino 0.1 *EQUATE part1.31 part2.31 *EQUATE part2.33 part1.35 *BEGIN part1 *EQUATE 35 BoulderChamber.35 *EQUATE 35 DownStream.35 0 1 4.08 270.72 -25.50 1 2 3.77 354.35 -29.81 2 3 4.33 336.10 -24.79 3 4 2.77 337.70 -4.41 4 5 3.14 343.71 -25.59 5 6 1.87 332.43 6.50 6 7 2.26 343.32 -5.29 7 8 1.72 258.62 12.28 7 9 1.10 310.47 4.46 9 10 2.37 334.59 4.19 10 11 1.12 263.77 46.91 11 12 3.53 351.74 -3.89 12 13 1.97 312.50 39.30 13 14 2.39 28.12 3.33 14 15 0.86 306.09 -13.02 15 16 4.55 48.38 7.37 16 17 2.34 328.01 -9.83 17 18 2.65 86.23 -7.24 18 19 0.84 146.67 18.49 19 20 1.81 87.93 13.23 20 21 1.73 164.45 7.33 21 22 2.91 113.95 7.56 22 23 1.51 181.21 30.14 23 24 4.59 108.18 -8.18 24 25 3.22 188.75 35.45 25 26 4.13 139.60 16.69 25 27 4.94 97.33 39.05 24 28 2.78 323.60 -24.94 28 29 0.89 90.00 -48.92 29 30 6.28 324.60 -29.83 30 31 1.55 264.23 41.75 31 34 5.13 314.22 -30.46 34 35 2.76 19.79 -19.74 *BEGIN DownStream *CALIBRATE declination 0.0 *CALIBRATE compass 0.0 *CALIBRATE clino 0.0 *EQUATE 44 46 35 43 7.82 271.86 -10.72 43 44 1.58 132.75 -54.76 43 45 4.22 283.16 -3.82 46 47 4.08 278.14 -22.89 47 48 1.62 127.59 7.41 45 49 2.40 265.00 1.41 49 50 2.06 297.62 28.08 50 51 2.38 317.24 16.74 51 52 2.80 335.01 -5.36 52 53 8.00 77.58 15.81 52 54 2.99 251.79 -11.14 54 55 2.75 287.69 -14.31 55 56 6.04 280.29 -11.16 56 57 4.72 167.79 -69.81 57 58 6.26 266.27 3.98 58 59 5.34 221.34 -28.43 59 60 3.64 249.87 -18.27 60 61 6.14 188.00 -36.35 61 62 1.04 31.64 -42.73 *END DownStream *BEGIN BoulderChamber 35 36 4.45 91.00 26.23 36 37 6.61 112.79 18.69 37 38 3.92 158.52 22.40 38 39 5.06 158.54 15.55 39 40 3.30 137.29 35.75 40 41 1.54 156.92 21.03 41 42 1.23 188.42 54.13 *END BoulderChamber *END part1 *BEGIN part2 31 32 2.26 15.83 12.57 32 33 6.03 323.45 -41.61 *END part2 *END LongDryWay *BEGIN ShortDryWay *CALIBRATE declination 5.13 *CALIBRATE compass -2.5 *CALIBRATE clino 0.1 0 1 1.43 131.61 -13.25 1 2 3.89 73.29 -51.63 2 3 4.50 170.72 19.68 3 4 1.11 246.49 -14.16 2 5 4.91 323.66 2.34 5 6 5.05 279.35 -25.23 6 7 5.02 336.36 -13.85 7 8 3.19 303.08 -33.11 8 9 6.71 295.69 -12.15 9 10 1.11 265.93 2.35 *END ShortDryWay *END Swildons CaveConverter_src/test/data/regression/HSC_ps_ref.svx0000644000000000000000000002406112227233126021761 0ustar rootroot*BEGIN new090417 *EQUATE 1.20 118.0 *BEGIN 118 *DATE 2009.04.17 *CALIBRATE declination 2.08 *FLAGS SPLAY 0 0a 0.96 22.53 -1.72 0 0b 0.23 209.86 13.47 0 0c 4.62 344.93 83.50 0 0d 1.33 234.49 -86.05 *FLAGS NOT SPLAY 0 1 4.41 85.63 56.45 *FLAGS SPLAY 1 1a 5.21 286.13 -1.99 1 1b 1.25 97.37 3.15 1 1c 1.56 321.06 80.51 1 1d 4.37 145.94 -88.53 *FLAGS NOT SPLAY 1 2 2.57 17.44 8.88 *FLAGS SPLAY 2 2a 1.22 287.61 0.03 2 2b 0.40 105.36 4.08 2 2c 0.31 293.53 87.17 2 2d 0.38 21.24 -85.59 *FLAGS NOT SPLAY 2 3 6.09 17.23 -0.36 *FLAGS SPLAY 3 3a 1.34 209.51 15.20 3 3b 0.20 26.53 2.06 3 3c 0.33 19.33 83.86 3 3d 0.44 187.04 -85.42 *FLAGS NOT SPLAY 3 4 6.26 288.72 0.89 *FLAGS SPLAY 4 4a 0.48 196.35 -3.11 4 4b 0.44 12.77 10.01 4 4c 0.34 324.14 88.50 4 4d 0.37 218.56 -87.98 *FLAGS NOT SPLAY 3 5 2.08 143.25 1.29 *FLAGS SPLAY 5 5a 0.82 10.33 3.35 5 5b 0.21 95.58 86.04 5 5c 0.19 205.48 -87.92 *FLAGS NOT SPLAY 5 6 2.63 92.99 -6.53 *FLAGS SPLAY 6 6a 0.36 355.91 0.44 6 6b 0.31 168.00 6.41 6 6c 0.21 76.60 85.20 6 6d 1.94 132.41 -84.27 *FLAGS NOT SPLAY 1 7 1.92 171.25 38.92 *FLAGS SPLAY 7 7a 0.99 23.62 1.01 7 7b 0.96 219.73 0.84 7 7c 2.06 276.93 84.38 7 7d 0.48 160.02 -83.30 *FLAGS NOT SPLAY 7 8 4.09 118.81 8.07 *FLAGS SPLAY 8 8a 0.59 14.54 -1.30 8 8b 1.16 64.30 86.33 8 8c 0.81 4.19 -88.04 *FLAGS NOT SPLAY 8 9 6.84 102.75 6.73 *FLAGS SPLAY 9 9a 0.64 9.27 -0.28 9 9b 0.40 186.72 9.03 9 9c 0.22 28.87 85.75 9 9d 0.22 217.52 -85.24 *FLAGS NOT SPLAY 7 10 3.61 220.79 21.43 *FLAGS SPLAY 10 10a 1.23 116.25 2.68 10 10b 0.76 285.24 7.71 10 10c 0.74 109.40 86.98 10 10d 0.22 100.33 -89.49 *FLAGS NOT SPLAY 10 11 1.78 180.39 16.50 *FLAGS SPLAY 11 11a 0.31 103.13 -2.29 11 11b 1.00 282.91 1.18 11 11c 0.24 314.51 86.50 11 11d 0.20 162.79 -79.23 *FLAGS NOT SPLAY 11 12 15.03 195.29 0.32 *FLAGS SPLAY 12 12a 6.01 17.32 2.01 12 12b 3.08 347.79 3.07 12 12c 2.20 320.84 4.71 12 12d 3.83 49.89 -0.50 12 12e 0.74 110.79 8.92 12 12f 0.69 198.64 10.54 *FLAGS NOT SPLAY 12 13 7.30 264.09 2.57 *FLAGS SPLAY 13 13a 0.70 182.13 3.06 13 13b 0.21 11.63 19.31 13 13c 0.23 184.92 77.90 *FLAGS NOT SPLAY 13 14 3.71 279.82 4.77 *FLAGS SPLAY 14 14a 0.43 188.00 1.46 14 14b 0.85 13.90 -0.77 14 14c 0.34 176.03 -80.18 *FLAGS NOT SPLAY 14 15 6.69 266.26 -26.44 *FLAGS SPLAY 15 15a 0.98 170.84 8.55 15 15b 2.49 64.23 11.72 15 15c 2.61 244.87 21.84 15 15d 3.37 292.48 11.33 15 15e 2.00 342.97 10.72 *FLAGS NOT SPLAY 15 16 2.92 52.57 0.50 *FLAGS SPLAY 16 16a 1.13 335.93 -3.42 16 16b 0.31 152.53 2.42 16 16c 0.62 333.07 87.23 16 16d 0.38 146.54 -87.21 *FLAGS NOT SPLAY 16 17 7.37 58.25 0.39 *FLAGS SPLAY 17 17a 0.98 324.42 3.22 17 17b 0.31 144.32 3.31 17 17c 0.28 300.73 87.16 17 17d 0.05 126.22 -81.67 *FLAGS NOT SPLAY 17 18 3.30 34.06 -4.56 *FLAGS SPLAY 18 18a 2.98 85.15 -2.52 18 18b 2.97 124.59 0.62 18 18c 7.76 126.15 1.14 18 18d 6.42 141.39 0.59 18 18e 3.29 164.25 2.96 18 18f 2.76 240.68 7.36 18 18g 0.87 282.27 12.06 *FLAGS NOT SPLAY 18 19 4.75 270.79 2.04 *FLAGS SPLAY 19 19a 0.20 182.59 2.55 19 19b 1.54 11.61 -0.79 19 19c 0.63 297.61 84.85 19 19d 0.40 87.62 -85.16 *FLAGS NOT SPLAY 19 20 5.16 306.51 4.31 *FLAGS SPLAY 20 20a 1.60 212.01 -0.93 20 20b 0.26 50.02 -84.91 *FLAGS NOT SPLAY 20 21 2.77 223.43 -6.75 *FLAGS SPLAY 21 21a 1.60 180.63 6.26 21 21b 0.60 338.00 1.74 21 21c 0.76 212.74 88.20 *FLAGS NOT SPLAY 21 22 4.11 249.43 5.41 *FLAGS SPLAY 22 22a 0.39 162.23 -0.01 22 22b 0.58 347.00 0.42 22 22c 0.46 271.51 75.36 22 22d 0.26 90.53 -87.49 *FLAGS NOT SPLAY 22 23 4.04 274.31 6.76 21 24 2.04 127.67 8.49 *FLAGS SPLAY 24 24a 1.05 1.79 1.44 24 24b 0.23 100.12 86.02 24 24c 0.27 278.61 -83.60 *FLAGS NOT SPLAY 24 25 4.17 85.93 -6.08 15 26 4.82 275.34 11.68 *FLAGS SPLAY 26 26a 0.67 193.39 11.97 26 26b 0.45 359.40 1.02 26 26c 0.32 29.04 -85.64 *FLAGS NOT SPLAY 26 27 9.44 283.93 -1.80 *FLAGS SPLAY 27 27a 0.33 200.74 4.08 27 27b 0.29 18.18 10.78 27 27c 0.35 6.27 85.39 27 27d 0.24 165.10 -87.87 *FLAGS NOT SPLAY 15 28 5.33 258.07 15.05 *FLAGS SPLAY 28 28a 0.60 161.13 4.17 28 28b 0.85 353.50 8.71 28 28c 2.12 50.09 81.34 *FLAGS NOT SPLAY 28 29 2.15 242.34 48.01 *FLAGS SPLAY 29 29a 2.97 33.03 0.82 29 29b 2.22 320.50 -0.21 29 29c 2.01 217.71 7.64 29 29d 1.67 157.78 9.94 29 29e 1.40 89.26 -9.57 *FLAGS NOT SPLAY 29 30 4.36 106.01 -31.30 *FLAGS SPLAY 30 30a 0.30 9.95 1.38 30 30b 0.48 199.82 0.95 30 30c 0.46 287.87 78.94 *FLAGS NOT SPLAY 29 31 2.09 225.82 5.69 *FLAGS SPLAY 31 31a 0.24 157.70 0.95 31 31b 1.25 331.67 1.19 31 31c 0.20 175.76 86.96 31 31d 0.36 317.54 -83.62 *FLAGS NOT SPLAY 31 32 4.45 242.34 0.48 *FLAGS SPLAY 32 32a 0.52 203.42 5.06 32 32b 3.19 303.43 6.37 32 32c 4.63 339.31 2.41 32 32d 3.02 0.72 5.70 32 32e 3.10 30.34 2.17 32 32f 3.63 67.71 3.17 32 32g 3.21 100.79 -1.01 *FLAGS NOT SPLAY 32 33 3.28 101.68 1.33 *FLAGS SPLAY 33 33a 0.95 34.52 0.59 33 33b 0.34 214.65 16.64 33 33c 0.29 122.89 84.71 33 33d 0.19 292.02 -83.48 *FLAGS NOT SPLAY 33 34 4.79 105.83 -13.72 *FLAGS SPLAY 34 34a 0.29 207.59 -3.35 34 34b 0.20 173.84 86.48 34 34c 1.47 178.88 -87.03 *FLAGS NOT SPLAY 34 35 2.37 121.27 -61.00 *FLAGS SPLAY 35 35a 1.02 20.04 -5.91 35 35b 0.72 201.68 6.82 35 35c 1.17 125.10 82.70 35 35d 1.64 292.70 -81.73 *FLAGS NOT SPLAY 35 36 2.97 70.89 10.56 *FLAGS SPLAY 36 36a 0.79 325.76 2.66 36 36b 0.42 139.95 3.69 36 36c 0.85 34.54 84.25 *FLAGS NOT SPLAY 36 37 2.40 81.43 2.75 *FLAGS SPLAY 37 37a 0.52 358.49 2.72 37 37b 0.50 166.22 5.62 37 37c 0.49 352.29 88.26 *FLAGS NOT SPLAY 36 38 3.44 199.73 3.19 *FLAGS SPLAY 38 38a 0.24 135.39 -2.25 38 38b 0.31 318.27 11.13 38 38c 0.41 119.61 80.85 38 38d 0.19 318.28 -81.47 *FLAGS NOT SPLAY 36 39 3.24 245.65 -25.94 *FLAGS SPLAY 39 39a 0.43 25.03 1.52 39 39b 0.56 7.33 84.71 39 39c 1.47 236.88 -81.55 *FLAGS NOT SPLAY 39 40 3.12 126.45 -36.45 39 41 2.46 288.54 -19.63 *FLAGS SPLAY 41 41a 0.36 200.49 1.35 41 41b 0.28 23.85 4.36 41 41c 0.55 300.08 85.86 *FLAGS NOT SPLAY 41 42 2.83 297.90 27.96 *FLAGS SPLAY 42 42a 0.74 181.72 3.85 42 42b 0.48 340.78 0.38 42 42c 2.69 269.10 86.13 42 42d 0.52 115.64 -84.70 *FLAGS NOT SPLAY 42 43 1.84 310.43 50.44 43 44 7.35 226.90 12.38 *FLAGS SPLAY 44 44a 0.56 328.97 6.99 44 44b 1.05 212.94 78.82 44 44c 0.35 301.67 -85.91 *FLAGS NOT SPLAY 44 45 1.07 265.82 18.38 *FLAGS SPLAY 45 45a 0.51 15.60 4.39 45 45b 0.57 194.98 0.17 45 45c 0.54 180.85 83.08 45 45d 0.50 224.46 -88.24 *FLAGS NOT SPLAY 45 46 2.40 112.23 14.37 *FLAGS SPLAY 46 46a 0.79 17.98 6.40 46 46b 0.53 207.16 5.75 46 46c 0.50 243.62 84.24 46 46d 0.91 125.65 -81.45 *FLAGS NOT SPLAY 46 47 2.52 132.69 26.44 *FLAGS SPLAY 47 47a 3.85 1.01 2.48 47 47b 5.83 317.39 2.51 47 47c 10.34 296.43 3.28 47 47d 10.79 286.75 3.18 47 47e 2.68 266.70 5.84 47 47f 0.50 172.45 13.22 *FLAGS NOT SPLAY 47 48 2.50 63.09 0.33 *FLAGS SPLAY 48 48a 2.01 358.17 2.41 48 48b 0.55 162.50 4.70 48 48c 0.36 41.60 84.49 48 48d 2.61 87.26 -2.01 *FLAGS NOT SPLAY 48 49 4.48 87.14 -2.01 *FLAGS SPLAY 49 49a 2.83 350.35 0.10 49 49b 1.18 152.31 4.71 49 49c 0.40 118.05 77.67 *FLAGS NOT SPLAY 49 50 3.82 87.50 -4.52 *FLAGS SPLAY 50 50a 3.98 347.14 2.28 50 50b 0.34 177.04 4.50 50 50c 0.56 350.94 87.59 50 50d 0.67 224.41 -87.87 *FLAGS NOT SPLAY 43 51 1.80 310.46 50.33 *FLAGS SPLAY 51 51a 0.83 211.09 -1.29 51 51b 0.35 27.20 5.53 51 51c 1.20 241.74 87.79 51 51d 0.38 131.38 -84.70 *FLAGS NOT SPLAY 51 52 8.85 287.98 -2.46 *data passage station left right up down 0 0.86 0.18 4.59 1.33 1 5.10 1.25 1.54 4.37 2 1.22 0.40 0.31 0.38 3 1.28 0.20 0.33 0.44 4 0.48 0.43 0.34 0.37 *data passage station left right up down 3 0.20 1.28 0.33 0.44 5 0.78 0.00 0.21 0.19 6 0.36 0.30 0.21 1.93 *data passage station left right up down 1 1.25 5.10 1.54 4.37 7 0.84 0.93 2.05 0.48 8 0.59 0.00 1.16 0.81 9 0.64 0.39 0.22 0.22 *data passage station left right up down 7 0.13 0.00 2.05 0.48 10 1.22 0.75 0.74 0.22 11 0.31 1.00 0.24 0.20 12 0.64 2.71 0.00 0.00 13 0.70 0.20 0.22 0.00 14 0.43 0.83 0.00 0.34 15 2.42 0.93 0.97 0.00 16 1.11 0.31 0.62 0.38 17 0.97 0.31 0.28 0.05 18 2.74 3.43 0.00 0.00 19 0.19 1.53 0.63 0.40 20 1.28 0.00 0.00 0.26 21 1.32 0.59 0.76 0.00 22 0.38 0.58 0.45 0.26 *data passage station left right up down 21 0.52 1.58 0.76 0.00 24 1.01 0.00 0.23 0.27 *data passage station left right up down 15 1.06 1.87 0.97 0.00 26 0.65 0.44 0.00 0.32 27 0.33 0.28 0.35 0.24 *data passage station left right up down 15 0.97 1.94 0.97 0.00 28 0.60 0.82 2.10 0.00 29 2.02 1.63 0.00 0.00 30 0.30 0.48 0.45 0.00 *data passage station left right up down 29 1.60 2.22 0.00 0.00 31 0.23 1.24 0.20 0.36 32 3.51 2.38 0.00 0.00 33 0.89 0.30 0.29 0.19 34 0.00 0.29 0.20 1.47 35 0.98 0.69 1.16 1.62 36 0.74 0.38 0.85 0.00 37 0.52 0.50 0.49 0.00 *data passage station left right up down 36 0.42 0.79 0.85 0.00 38 0.22 0.27 0.40 0.19 *data passage station left right up down 36 0.38 0.75 0.85 0.00 39 0.00 0.43 0.56 1.45 41 0.36 0.28 0.55 0.00 42 0.62 0.29 2.68 0.52 43 0.00 0.00 0.00 0.00 44 0.00 0.55 1.03 0.35 45 0.00 0.06 0.54 0.50 46 0.76 0.53 0.50 0.90 47 3.82 0.52 0.00 0.00 48 1.96 0.55 0.36 0.00 49 2.81 1.07 0.39 0.00 50 3.91 0.34 0.56 0.67 *data passage station left right up down 43 0.00 0.00 0.00 0.00 51 0.83 0.35 1.20 0.38 *END 118 *END new090417 CaveConverter_src/test/data/regression/HSC_pt_ref.text0000644000000000000000000001611012217344034022122 0ustar rootroot -6 1 1 1 1 Cave Name -5 1 1 1 1 0.00 0.00 0.00 1 0 -4 1 1 1 1 12/08/16 13:14:15 CaveConverter -3 1 1 1 1 -2 1 1 1 1 16/08/12 Converted Data 0 0.00 0 1 -1 1 1 1 1 360.00 360.00 0.05 1.00 1.00 100.00 0.00 1 -2 1 1 1 Series 1-root.new090417.118 1 -1 1 1 1 1 0 1 4 4 3 0 1 0 1 1 1 0.00 0.00 0.00 0.86 0.18 4.59 1.33 1 1 1 1 1 4.41 83.55 56.45 5.10 1.25 1.54 4.37 1 2 1 1 1 2.57 15.36 8.88 1.22 0.40 0.31 0.38 1 3 1 1 1 6.09 15.15 -0.36 1.28 0.20 0.33 0.44 1 4 1 1 1 6.26 286.64 0.89 0.48 0.43 0.34 0.37 2 -2 1 1 1 Series 2-root.new090417.118 2 -1 1 1 1 1 3 2 2 2 3 0 2 0 1 1 1 0.00 0.00 0.00 0.20 1.28 0.33 0.44 2 1 1 1 1 2.08 141.17 1.29 0.78 0.00 0.21 0.19 2 2 1 1 1 2.63 90.91 -6.53 0.36 0.30 0.21 1.93 3 -2 1 1 1 Series 3-root.new090417.118 3 -1 1 1 1 1 1 3 3 3 3 0 3 0 1 1 1 0.00 0.00 0.00 1.25 5.10 1.54 4.37 3 1 1 1 1 1.92 169.17 38.92 0.84 0.93 2.05 0.48 3 2 1 1 1 4.09 116.73 8.07 0.59 0.00 1.16 0.81 3 3 1 1 1 6.84 100.67 6.73 0.64 0.39 0.22 0.22 4 -2 1 1 1 Series 4-root.new090417.118 4 -1 1 1 1 3 1 4 14 14 3 0 4 0 1 1 1 0.00 0.00 0.00 0.13 0.00 2.05 0.48 4 1 1 1 1 3.61 218.71 21.43 1.22 0.75 0.74 0.22 4 2 1 1 1 1.78 178.31 16.50 0.31 1.00 0.24 0.20 4 3 1 1 1 15.03 193.21 0.32 0.64 2.71 0.00 0.00 4 4 1 1 1 7.30 262.01 2.57 0.70 0.20 0.22 0.00 4 5 1 1 1 3.71 277.74 4.77 0.43 0.83 0.00 0.34 4 6 1 1 1 6.69 264.18 -26.44 2.42 0.93 0.97 0.00 4 7 1 1 1 2.92 50.49 0.50 1.11 0.31 0.62 0.38 4 8 1 1 1 7.37 56.17 0.39 0.97 0.31 0.28 0.05 4 9 1 1 1 3.30 31.98 -4.56 2.74 3.43 0.00 0.00 4 10 1 1 1 4.75 268.71 2.04 0.19 1.53 0.63 0.40 4 11 1 1 1 5.16 304.43 4.31 1.28 0.00 0.00 0.26 4 12 1 1 1 2.77 221.35 -6.75 1.32 0.59 0.76 0.00 4 13 1 1 1 4.11 247.35 5.41 0.38 0.58 0.45 0.26 4 14 1 1 1 4.04 272.23 6.76 0.00 0.00 0.00 0.00 5 -2 1 1 1 Series 5-root.new090417.118 5 -1 1 1 1 4 12 5 2 2 3 0 5 0 1 1 1 0.00 0.00 0.00 0.52 1.58 0.76 0.00 5 1 1 1 1 2.04 125.59 8.49 1.01 0.00 0.23 0.27 5 2 1 1 1 4.17 83.85 -6.08 0.00 0.00 0.00 0.00 6 -2 1 1 1 Series 6-root.new090417.118 6 -1 1 1 1 4 6 6 2 2 3 0 6 0 1 1 1 0.00 0.00 0.00 1.06 1.87 0.97 0.00 6 1 1 1 1 4.82 273.26 11.68 0.65 0.44 0.00 0.32 6 2 1 1 1 9.44 281.85 -1.80 0.33 0.28 0.35 0.24 7 -2 1 1 1 Series 7-root.new090417.118 7 -1 1 1 1 4 6 7 3 3 3 0 7 0 1 1 1 0.00 0.00 0.00 0.97 1.94 0.97 0.00 7 1 1 1 1 5.33 255.99 15.05 0.60 0.82 2.10 0.00 7 2 1 1 1 2.15 240.26 48.01 2.02 1.63 0.00 0.00 7 3 1 1 1 4.36 103.93 -31.30 0.30 0.48 0.45 0.00 8 -2 1 1 1 Series 8-root.new090417.118 8 -1 1 1 1 7 2 8 7 7 3 0 8 0 1 1 1 0.00 0.00 0.00 1.60 2.22 0.00 0.00 8 1 1 1 1 2.09 223.74 5.69 0.23 1.24 0.20 0.36 8 2 1 1 1 4.45 240.26 0.48 3.51 2.38 0.00 0.00 8 3 1 1 1 3.28 99.60 1.33 0.89 0.30 0.29 0.19 8 4 1 1 1 4.79 103.75 -13.72 0.00 0.29 0.20 1.47 8 5 1 1 1 2.37 119.19 -61.00 0.98 0.69 1.16 1.62 8 6 1 1 1 2.97 68.81 10.56 0.74 0.38 0.85 0.00 8 7 1 1 1 2.40 79.35 2.75 0.52 0.50 0.49 0.00 9 -2 1 1 1 Series 9-root.new090417.118 9 -1 1 1 1 8 6 9 1 1 3 0 9 0 1 1 1 0.00 0.00 0.00 0.42 0.79 0.85 0.00 9 1 1 1 1 3.44 197.65 3.19 0.22 0.27 0.40 0.19 10 -2 1 1 1 Series 10-root.new090417.118 10 -1 1 1 1 8 6 10 2 2 3 0 10 0 1 1 1 0.00 0.00 0.00 0.38 0.75 0.85 0.00 10 1 1 1 1 3.24 243.57 -25.94 0.43 0.00 0.56 1.45 10 2 1 1 1 3.12 124.37 -36.45 0.00 0.00 0.00 0.00 11 -2 1 1 1 Series 11-root.new090417.118 11 -1 1 1 1 10 1 11 10 10 3 0 11 0 1 1 1 0.00 0.00 0.00 0.00 0.43 0.56 1.45 11 1 1 1 1 2.46 286.46 -19.63 0.36 0.28 0.55 0.00 11 2 1 1 1 2.83 295.82 27.96 0.62 0.29 2.68 0.52 11 3 1 1 1 1.84 308.35 50.44 0.00 0.00 0.00 0.00 11 4 1 1 1 7.35 224.82 12.38 0.00 0.55 1.03 0.35 11 5 1 1 1 1.07 263.74 18.38 0.00 0.06 0.54 0.50 11 6 1 1 1 2.40 110.15 14.37 0.76 0.53 0.50 0.90 11 7 1 1 1 2.52 130.61 26.44 3.82 0.52 0.00 0.00 11 8 1 1 1 2.50 61.01 0.33 1.96 0.55 0.36 0.00 11 9 1 1 1 4.48 85.06 -2.01 2.81 1.07 0.39 0.00 11 10 1 1 1 3.82 85.42 -4.52 3.91 0.34 0.56 0.67 12 -2 1 1 1 Series 12-root.new090417.118 12 -1 1 1 1 11 3 12 2 2 3 0 12 0 1 1 1 0.00 0.00 0.00 0.00 0.00 0.00 0.00 12 1 1 1 1 1.80 308.38 50.33 0.83 0.35 1.20 0.38 12 2 1 1 1 8.85 285.90 -2.46 0.00 0.00 0.00 0.00CaveConverter_src/test/data/regression/Uzu-Gour_in.txt0000644000000000000000000007443511167742064022212 0ustar rootrootUzu-Gour090410 (m, 360) [1]: 2009/04/10 2.01 134.44 153.0 0.000 0.00 0.00 [1] 153.0 0.660 310.69 9.16 [1] 153.0 1.170 138.22 11.97 [1] 153.0 1.620 80.27 84.63 [1] 153.0 1.320 136.77 -83.24 [1] 153.0 153.1 4.010 55.15 2.86 [1] 153.0 153.1 4.010 55.08 2.87 [1] 153.0 153.1 4.010 55.13 2.91 [1] 153.1 0.670 357.48 5.13 [1] 153.1 1.240 169.73 4.45 [1] 153.1 6.480 131.19 71.93 [1] 153.1 1.270 111.18 -86.81 [1] 153.1 153.2 6.670 109.22 -1.39 [1] 153.1 153.2 6.670 109.22 -1.33 [1] 153.1 153.2 6.670 109.17 -1.38 [1] 153.2 0.710 12.77 -2.39 [1] 153.2 0.970 175.96 -0.60 [1] 153.2 2.480 5.80 77.81 [1] 153.2 1.160 80.73 -86.86 [1] 153.2 153.3 7.570 82.70 -1.50 [1] 153.2 153.3 7.570 82.85 -1.44 [1] 153.2 153.3 7.560 82.92 -1.43 [1] 153.3 1.070 299.77 -0.43 [1] 153.3 0.700 116.08 5.84 [1] 153.3 5.830 351.61 76.20 [1] 153.3 0.880 309.05 -87.42 [1] 153.3 153.4 15.710 17.44 1.22 [1] 153.3 153.4 15.710 17.53 1.19 [1] 153.3 153.4 15.700 17.54 1.18 [1] 153.4 1.950 226.25 -0.27 [1] 153.4 0.460 66.80 13.93 [1] 153.4 5.650 182.84 82.67 [1] 153.4 1.040 275.59 -86.30 [1] 153.4 153.5 2.730 244.47 2.62 [1] 153.4 153.5 2.730 244.58 2.58 [1] 153.4 153.5 2.730 244.58 2.62 [1] 153.5 2.100 11.50 -1.38 [1] 153.5 5.420 302.47 83.96 [1] 153.5 1.230 134.51 -88.40 [1] 153.5 153.6 4.220 318.38 0.38 [1] 153.5 153.6 4.220 318.27 0.40 [1] 153.5 153.6 4.210 318.26 0.44 [1] 153.6 5.310 71.33 24.03 [1] 153.6 0.720 307.95 86.30 [1] 153.6 1.800 125.36 -84.77 [1] 153.6 153.7 4.920 29.50 -2.13 [1] 153.6 153.7 4.920 29.67 -2.13 [1] 153.6 153.7 4.910 29.57 -2.10 [1] 153.7 1.720 326.24 -2.97 [1] 153.7 4.860 114.49 33.83 [1] 153.7 1.490 119.34 82.62 [1] 153.7 0.880 52.77 -83.97 [1] 153.7 153.8 9.810 58.65 0.98 [1] 153.7 153.8 9.810 58.76 0.90 [1] 153.7 153.8 9.810 58.76 0.93 [1] 153.8 0.600 30.89 4.65 [1] 153.8 1.400 194.75 6.76 [1] 153.8 1.870 143.21 80.26 [1] 153.8 1.170 163.90 -84.89 [1] 153.8 153.9 8.590 128.80 -6.75 [1] 153.8 153.9 8.600 128.68 -6.65 [1] 153.8 153.9 8.600 128.61 -6.64 [1] 153.9 1.220 16.91 8.45 [1] 153.9 1.010 194.87 -5.80 [1] 153.9 1.190 115.77 79.03 [1] 153.9 0.260 324.87 -86.69 [1] 153.9 153.10 5.680 82.90 5.74 [1] 153.9 153.10 5.680 82.95 5.64 [1] 153.9 153.10 5.680 82.92 5.67 [1] 153.10 1.200 327.38 -6.61 [1] 153.10 0.950 146.85 7.78 [1] 153.10 1.560 51.96 85.81 [1] 153.10 0.760 270.01 -85.55 [1] 153.10 153.11 6.560 44.65 4.51 [1] 153.10 153.11 6.560 44.70 4.51 [1] 153.10 153.11 6.560 44.59 4.59 [1] 153.11 1.060 323.36 10.84 [1] 153.11 1.220 147.77 -0.82 [1] 153.11 3.260 239.56 88.17 [1] 153.11 1.180 137.10 -80.05 [1] 153.11 153.12 9.030 72.13 1.18 [1] 153.11 153.12 9.020 72.20 1.25 [1] 153.11 153.12 9.030 72.23 1.22 [1] 153.12 1.220 333.74 -2.77 [1] 153.12 0.390 157.20 6.88 [1] 153.12 9.070 306.85 88.13 [1] 153.12 1.170 32.13 -85.98 [1] 153.12 153.13 3.050 46.20 1.33 [1] 153.12 153.13 3.050 46.21 1.22 [1] 153.12 153.13 3.050 46.26 1.29 [1] 153.13 0.960 333.36 11.12 [1] 153.13 1.080 162.52 0.43 [1] 153.13 9.410 103.09 74.92 [1] 153.13 1.510 134.98 -73.22 [1] 153.13 153.14 6.890 86.27 -0.49 [1] 153.13 153.14 6.890 86.27 -0.48 [1] 153.13 153.14 6.880 86.27 -0.55 [1] 153.14 1.060 337.15 -3.35 [1] 153.14 7.650 102.01 82.12 [1] 153.14 1.290 173.81 -89.40 [1] 153.14 153.15 6.610 61.50 0.18 [1] 153.14 153.15 6.620 61.42 0.05 [1] 153.14 153.15 6.610 61.53 0.03 [1] 153.15 1.540 303.07 -1.24 [1] 153.15 0.240 134.42 12.32 [1] 153.15 6.360 9.40 84.82 [1] 153.15 1.070 310.69 -84.97 [1] 153.15 153.16 5.130 18.51 -1.16 [1] 153.15 153.16 5.130 18.54 -1.18 [1] 153.15 153.16 5.120 18.54 -1.28 [1] 153.16 0.550 311.69 6.18 [1] 153.16 1.300 135.99 -4.45 [1] 153.16 1.400 58.32 82.47 [1] 153.16 1.100 224.97 -87.41 [1] 153.16 153.17 6.850 62.63 1.93 [1] 153.16 153.17 6.850 62.62 2.01 [1] 153.16 153.17 6.850 62.64 2.08 [1] 153.17 1.380 167.09 -2.95 [1] 153.17 4.990 102.11 87.59 [1] 153.17 1.180 212.70 -86.61 [1] 153.17 153.18 5.380 102.12 1.21 [1] 153.17 153.18 5.380 102.21 1.21 [1] 153.17 153.18 5.380 102.21 1.25 [1] 153.18 1.270 16.14 3.17 [1] 153.18 11.110 43.73 75.72 [1] 153.18 1.380 180.93 -87.42 [1] 153.18 153.19 2.600 105.63 -1.04 [1] "19=stn 60 from August 2008" 153.18 153.19 2.600 105.49 -1.05 [1] 153.18 153.19 2.600 105.36 -1.05 [1] 153.19 1.430 243.30 5.15 [1] 153.19 5.180 94.35 80.68 [1] 153.19 1.110 212.90 -87.67 [1] 153.19 153.20 6.930 178.17 -2.10 [1] 153.19 153.20 6.960 178.24 -2.14 [1] 153.19 153.20 6.930 178.10 -2.07 [1] 153.20 0.410 85.52 6.85 [1] 153.20 0.700 269.28 4.70 [1] 153.20 2.870 290.90 87.19 [1] 153.20 1.040 329.38 -84.46 [1] 153.20 153.21 4.010 196.02 3.11 [1] 153.20 153.21 4.010 196.12 3.13 [1] 153.20 153.21 4.010 196.08 3.19 [1] 153.21 1.430 76.94 2.96 [1] 153.21 0.640 246.93 0.76 [1] 153.21 5.240 171.27 84.67 [1] 153.21 1.070 306.36 -85.58 [1] 153.21 153.22 4.150 139.35 -0.17 [1] 153.21 153.22 4.150 139.26 -0.15 [1] 153.21 153.22 4.150 139.22 -0.12 [1] 153.22 0.350 96.03 4.53 [1] 153.22 3.670 279.77 20.06 [1] 153.22 0.960 136.65 84.20 [1] 153.22 1.170 260.34 -85.03 [1] 153.22 153.23 4.700 205.66 -0.37 [1] 153.22 153.23 4.710 205.85 -0.39 [1] 153.22 153.23 4.710 205.77 -0.38 [1] 153.23 0.670 100.63 7.72 [1] 153.23 0.900 284.24 1.46 [1] 153.23 2.030 266.53 85.53 [1] 153.23 1.140 125.32 -83.92 [1] 153.23 153.24 6.520 198.50 5.53 [1] 153.23 153.24 6.520 198.48 5.53 [1] 153.23 153.24 6.520 198.37 5.51 [1] 153.24 0.670 118.59 3.67 [1] 153.24 0.940 305.13 0.53 [1] 153.24 4.720 141.69 87.99 [1] 153.24 1.310 293.36 -72.03 [1] 153.24 153.25 8.680 224.12 -4.18 [1] 153.24 153.25 8.690 223.95 -4.26 [1] 153.24 153.25 8.690 223.95 -4.33 [1] 153.25 1.780 141.39 18.75 [1] 153.25 1.110 337.22 -0.91 [1] 153.25 1.830 242.61 82.90 [1] 153.25 1.050 299.11 -87.89 [1] 153.25 153.26 5.690 246.10 2.21 [1] 153.25 153.26 5.690 246.26 2.24 [1] 153.25 153.26 5.690 246.36 2.39 [1] 153.26 2.880 110.99 19.61 [1] 153.26 1.740 123.76 77.81 [1] 153.26 1.180 84.70 -81.34 [1] 153.26 153.27 2.460 153.08 -9.56 [1] 153.26 153.27 2.460 153.14 -9.62 [1] 153.26 153.27 2.460 153.07 -9.51 [1] 153.27 1.170 272.63 6.40 [1] 153.27 2.030 148.32 86.47 [1] 153.27 0.820 219.90 -89.23 [1] 153.27 153.28 16.850 204.21 -2.13 [1] 153.27 153.28 16.840 204.24 -2.05 [1] 153.27 153.28 16.850 204.26 -2.06 [1] 153.28 1.840 71.44 8.08 [1] 153.28 0.870 257.22 6.27 [1] 153.28 1.100 14.88 73.52 [1] 153.28 153.29 10.280 139.22 5.64 [1] 153.28 153.29 10.280 139.18 5.65 [1] 153.28 153.29 10.280 139.21 5.65 [1] 153.29 1.660 30.10 15.39 [1] 153.29 0.400 203.86 7.65 [1] 153.29 8.090 67.11 77.32 [1] 153.29 0.830 81.38 -87.37 [1] 153.29 153.30 5.840 105.80 5.92 [1] 153.29 153.30 5.840 105.92 5.85 [1] 153.29 153.30 5.840 105.76 5.81 [1] 153.30 1.920 7.20 9.53 [1] 153.30 0.440 160.39 4.71 [1] 153.30 3.250 108.05 82.68 [1] 153.30 1.280 255.16 -87.21 [1] 153.30 153.31 10.740 79.28 -0.95 [1] 153.30 153.31 10.730 79.24 -0.90 [1] 153.30 153.31 10.740 79.40 -1.01 [1] 153.31 2.960 313.97 15.64 [1] 153.31 0.390 134.29 11.27 [1] 153.31 1.300 77.16 82.61 [1] 153.31 1.170 86.89 -84.64 [1] 153.31 153.32 5.990 21.41 2.86 [1] 153.31 153.32 5.990 21.30 2.79 [1] 153.31 153.32 6.000 21.17 2.74 [1] 153.32 1.900 156.21 1.51 [1] 153.32 1.710 343.53 87.98 [1] 153.32 1.270 73.92 -84.80 [1] 153.32 153.33 8.260 124.55 -0.95 [1] 153.32 153.33 8.260 124.62 -0.94 [1] 153.32 153.33 8.260 124.69 -1.01 [1] 153.33 2.260 3.19 18.54 [1] 153.33 0.770 182.19 6.10 [1] 153.33 3.370 12.67 85.55 [1] 153.33 1.260 246.33 -87.14 [1] 153.33 153.34 11.470 86.34 0.10 [1] 153.33 153.34 11.460 86.22 0.17 [1] 153.33 153.34 11.460 86.16 0.15 [1] 153.34 0.520 6.08 8.87 [1] 153.34 0.890 187.81 1.74 [1] 153.34 13.040 45.58 80.50 [1] 153.34 1.370 130.80 -82.35 [1] 153.34 153.35 10.240 104.58 -0.15 [1] 153.34 153.35 10.250 104.62 -0.15 [1] 153.34 153.35 10.250 104.62 -0.15 [1] 153.35 2.390 334.20 16.80 [1] 153.35 1.560 350.17 81.57 [1] 153.35 1.120 53.73 -85.78 [1] 153.35 153.36 6.540 36.47 2.81 [1] 153.35 153.36 6.550 36.43 2.75 [1] 153.35 153.36 6.540 36.48 2.83 [1] 153.36 1.080 290.80 -0.12 [1] 153.36 0.260 107.29 9.29 [1] 153.36 4.780 67.20 78.00 [1] 153.36 1.610 127.33 -86.11 [1] 153.36 153.37 7.850 352.47 0.32 [1] 153.36 153.37 7.850 352.58 0.38 [1] 153.36 153.37 7.850 352.64 0.39 [1] 153.37 1.970 114.20 2.44 [1] 153.37 3.860 29.40 79.16 [1] 153.37 1.500 43.36 -74.01 [1] 153.37 153.38 12.500 59.52 -0.29 [1] 153.37 153.38 12.490 59.62 -0.31 [1] 153.37 153.38 12.490 59.61 -0.27 [1] 153.38 3.710 196.43 25.48 [1] 153.38 1.000 101.32 82.16 [1] 153.38 1.140 83.86 -82.25 [1] 153.38 153.39 6.470 144.31 -0.68 [1] 153.38 153.39 6.470 144.21 -0.63 [1] 153.38 153.39 6.470 144.38 -0.66 [1] 153.39 1.780 256.50 4.97 [1] 153.39 5.460 245.76 79.39 [1] 153.39 1.400 7.99 -88.60 [1] 153.39 153.40 12.200 176.54 2.80 [1] 153.39 153.40 12.180 176.60 2.79 [1] 153.39 153.40 12.190 176.72 2.74 [1] 153.40 0.940 294.81 -3.35 [1] 153.40 8.530 269.05 75.20 [1] 153.40 1.860 227.20 -83.19 [1] 153.40 153.41 8.030 217.47 -3.11 [1] 153.40 153.41 8.030 217.49 -3.14 [1] 153.40 153.41 8.030 217.55 -3.15 [1] 153.41 0.760 112.64 0.91 [1] 153.41 0.390 300.05 13.28 [1] 153.41 10.110 273.70 83.77 [1] 153.41 1.480 282.10 -85.81 [1] 153.41 153.42 5.060 197.76 0.73 [1] 153.41 153.42 5.060 197.69 0.77 [1] 153.41 153.42 5.060 197.61 0.73 [1] 153.42 0.820 87.13 -12.02 [1] 153.42 0.910 271.51 28.37 [1] 153.42 9.380 261.83 78.26 [1] 153.42 1.470 332.21 -86.18 [1] 153.42 153.43 5.140 164.36 -5.76 [1] 153.42 153.43 5.140 164.37 -5.70 [1] 153.42 153.43 5.130 164.35 -5.80 [1] 153.43 1.240 25.91 -2.84 [1] 153.43 1.280 223.96 28.43 [1] 153.43 1.910 212.36 79.68 [1] 153.43 0.880 286.64 -86.20 [1] 153.43 153.44 4.120 90.66 -11.44 [1] 153.43 153.44 4.120 90.69 -11.45 [1] 153.43 153.44 4.120 90.66 -11.54 [1] 153.44 2.410 57.95 5.26 [1] 153.44 1.250 222.00 8.75 [1] 153.44 1.180 198.31 83.84 [1] 153.44 153.45 12.400 173.97 6.86 [1] 153.44 153.45 12.390 174.04 6.87 [1] 153.44 153.45 12.380 173.95 6.85 [1] 153.45 1.420 43.19 -4.13 [1] 153.45 1.000 215.21 22.64 [1] 153.45 3.520 16.66 74.76 [1] 153.45 1.430 272.80 -85.47 [1] 153.45 153.46 7.370 104.88 0.83 [1] 153.45 153.46 7.380 104.92 0.85 [1] 153.45 153.46 7.380 104.92 0.77 [1] 153.46 0.980 352.37 -5.19 [1] 153.46 3.910 3.72 83.25 [1] 153.46 1.190 177.07 -85.49 [1] 153.46 153.47 4.770 62.00 -3.62 [1] 153.46 153.47 4.770 61.96 -3.63 [1] 153.46 153.47 4.770 61.90 -3.58 [1] 153.47 0.850 309.66 1.57 [1] 153.47 0.510 134.97 21.12 [1] 153.47 5.120 95.91 72.50 [1] 153.47 0.900 178.61 -86.89 [1] 153.47 153.48 5.770 23.57 0.26 [1] 153.47 153.48 5.760 23.58 0.39 [1] 153.47 153.48 5.770 23.58 0.32 [1] 153.48 0.960 278.66 -1.41 [1] 153.48 0.910 84.37 -1.28 [1] 153.48 8.950 50.33 87.07 [1] 153.48 0.870 154.03 -87.03 [1] 153.48 153.49 10.870 6.04 2.72 [1] 153.48 153.49 10.870 6.02 2.74 [1] 153.48 153.49 10.870 6.05 2.74 [1] 153.49 3.530 303.46 -22.08 [1] 153.49 1.490 109.10 12.22 [1] 153.49 4.180 271.96 83.18 [1] 153.49 0.250 222.51 -84.71 [1] 153.49 153.50 1.560 17.77 -9.73 [1] 153.49 153.50 1.560 17.58 -9.67 [1] 153.49 153.50 1.560 17.56 -9.68 [1] 153.50 3.090 310.29 -16.03 [1] 153.50 1.810 123.41 3.37 [1] 153.50 2.820 107.70 88.07 [1] 153.50 0.870 32.83 -88.59 [1] 153.50 153.51 11.640 51.07 0.98 [1] 153.50 153.51 11.640 51.16 1.02 [1] 153.50 153.51 11.640 51.06 1.01 [1] 153.51 0.880 291.17 -11.07 [1] 153.51 2.620 163.62 87.41 [1] 153.51 1.340 102.52 -83.95 [1] 153.51 153.52 6.840 26.54 -5.82 [1] 153.51 153.52 6.840 26.58 -5.80 [1] 153.51 153.52 6.830 26.60 -5.74 [1] 153.52 1.100 9.43 2.05 [1] 153.52 2.180 183.91 3.39 [1] 153.52 1.060 147.54 83.46 [1] 153.52 0.690 193.69 -84.93 [1] 153.52 153.53 6.430 119.01 2.72 [1] 153.52 153.53 6.430 119.15 2.66 [1] 153.52 153.53 6.430 119.12 2.63 [1] 153.53 2.460 316.37 -3.18 [1] 153.53 0.350 134.32 6.93 [1] 153.53 1.320 0.65 81.40 [1] 153.53 0.750 219.60 -87.78 [1] 153.53 153.54 16.810 345.83 -2.21 [1] 153.53 153.54 16.800 345.87 -2.24 [1] 153.53 153.54 16.810 345.83 -2.25 [1] 153.54 9.480 121.96 18.18 [1] 153.54 1.340 88.18 80.69 [1] 153.54 0.220 128.68 -85.33 [1] 153.54 153.55 11.680 100.32 4.95 [1] 153.54 153.55 11.680 100.34 4.92 [1] 153.54 153.55 11.660 100.45 4.78 [1] 153.55 0.680 353.36 -0.15 [1] 153.55 5.390 12.73 75.03 [1] 153.55 1.000 50.40 -89.71 [1] 153.55 153.56 1.660 96.15 -19.75 [1] 153.55 153.56 1.660 96.40 -19.81 [1] 153.55 153.56 1.670 96.21 -19.82 [1] 153.56 0.400 38.17 6.20 [1] 153.56 1.050 225.93 5.47 [1] 153.56 2.340 96.97 80.74 [1] 153.56 0.560 294.92 -87.67 [1] 153.56 153.57 5.390 160.72 -3.98 [1] 153.56 153.57 5.390 160.77 -4.06 [1] 153.56 153.57 5.390 160.64 -3.98 [1] 153.57 1.810 25.53 1.62 [1] 153.57 0.530 220.15 1.24 [1] 153.57 2.270 47.01 85.24 [1] 153.57 0.200 12.33 -85.15 [1] 153.57 153.58 4.720 73.19 10.50 [1] 153.57 153.58 4.720 73.13 10.46 [1] 153.57 153.58 4.720 73.36 10.32 [1] 153.58 0.330 16.81 2.17 [1] 153.58 1.180 189.78 0.04 [1] 153.58 4.010 77.71 86.61 [1] 153.58 0.940 144.63 -82.64 [1] 153.58 153.59 5.120 139.89 -5.15 [1] 153.58 153.59 5.120 139.77 -5.11 [1] 153.58 153.59 5.120 139.83 -5.07 [1] 153.59 1.140 5.50 9.72 [1] 153.59 1.160 165.35 20.33 [1] 153.59 1.390 21.12 85.08 [1] 153.59 0.480 248.26 -87.58 [1] 153.59 153.60 8.820 74.99 2.77 [1] 153.59 153.60 8.820 75.06 2.70 [1] 153.59 153.60 8.810 75.02 2.73 [1] 153.60 0.970 320.91 -0.74 [1] 153.60 0.250 141.85 1.28 [1] 153.60 7.570 288.95 79.51 [1] 153.60 0.880 71.53 -85.03 [1] 153.60 153.61 1.710 17.44 9.22 [1] 153.60 153.61 1.710 17.50 9.09 [1] 153.60 153.61 1.710 17.51 9.04 [1] 153.61 0.500 119.39 2.08 [1] 153.61 6.590 87.13 75.75 [1] 153.61 1.170 342.08 -77.77 [1] 153.61 153.62 7.730 52.03 -4.45 [1] 153.61 153.62 7.730 51.92 -4.41 [1] 153.61 153.62 7.730 51.88 -4.33 [1] 153.62 1.600 290.77 -0.14 [1] 153.62 0.220 112.40 8.61 [1] 153.62 4.840 289.04 83.90 [1] 153.62 0.540 263.45 -79.21 [1] 153.62 153.63 2.970 348.12 3.82 [1] 153.62 153.63 2.970 348.16 3.84 [1] 153.62 153.63 2.970 348.14 3.91 [1] 153.63 0.940 108.22 0.43 [1] 153.63 5.020 359.20 80.02 [1] 153.63 0.770 287.97 -88.61 [1] 153.63 153.64 10.870 23.34 -1.94 [1] 153.63 153.64 10.870 23.33 -1.94 [1] 153.63 153.64 10.870 23.30 -1.99 [1] 153.64 1.170 132.36 9.67 [1] 153.64 9.310 35.43 83.06 [1] 153.64 0.430 84.37 -84.49 [1] 153.64 153.65 4.520 55.63 4.75 [1] 153.64 153.65 4.530 55.62 4.64 [1] 153.64 153.65 4.530 55.64 4.80 [1] 153.65 1.400 293.82 8.38 [1] 153.65 8.350 317.08 87.04 [1] 153.65 0.560 60.05 -86.93 [1] 153.65 153.66 3.190 344.47 -2.98 [1] 153.65 153.66 3.200 344.39 -3.24 [1] 153.65 153.66 3.190 344.35 -3.24 [1] 153.66 0.920 211.48 9.89 [1] 153.66 0.260 39.37 20.78 [1] 153.66 10.300 235.93 86.42 [1] 153.66 0.510 191.40 -85.42 [1] 153.66 153.67 2.480 284.64 17.65 [1] 153.66 153.67 2.480 284.91 17.87 [1] 153.66 153.67 2.480 284.87 18.06 [1] 153.67 1.190 61.63 3.00 [1] 153.67 9.550 90.90 83.48 [1] 153.67 1.190 21.67 -82.71 [1] 153.67 153.68 5.470 5.30 0.27 [1] 153.67 153.68 5.470 5.25 0.10 [1] 153.67 153.68 5.470 5.22 0.31 [1] 153.68 0.910 135.70 2.18 [1] 153.68 10.360 129.84 88.37 [1] 153.68 1.300 90.71 -82.74 [1] 153.68 153.69 3.210 73.58 0.27 [1] 153.68 153.69 3.210 73.41 0.28 [1] 153.68 153.69 3.210 73.58 0.17 [1] 153.69 0.850 319.91 5.62 [1] 153.69 4.450 346.56 83.35 [1] 153.69 1.220 324.86 -77.89 [1] 153.69 153.70 6.880 27.75 1.40 [1] 153.69 153.70 6.880 27.76 1.38 [1] 153.69 153.70 6.880 27.72 1.39 [1] 153.70 2.320 330.70 23.53 [1] 153.70 1.410 153.25 28.90 [1] 153.70 2.110 50.40 82.88 [1] 153.70 1.170 116.09 -85.44 [1] 153.70 153.71 5.880 104.57 4.20 [1] 153.70 153.71 5.880 104.68 4.09 [1] 153.70 153.71 5.870 104.58 4.08 [1] 153.71 0.600 8.59 5.70 [1] 153.71 0.990 182.74 6.14 [1] 153.71 3.450 22.79 85.05 [1] 153.71 1.240 130.89 -84.59 [1] 153.71 153.72 7.570 99.21 -5.42 [1] 153.71 153.72 7.570 99.33 -5.51 [1] 153.71 153.72 7.570 99.33 -5.40 [1] 153.72 1.510 348.65 8.10 [1] 153.72 1.100 171.46 5.08 [1] 153.72 11.090 217.02 85.71 [1] 153.72 0.190 293.19 -86.30 [1] 153.72 153.73 5.640 88.59 15.14 [1] 153.72 153.73 5.640 88.57 15.14 [1] 153.72 153.73 5.630 88.61 15.16 [1] 153.73 3.240 192.60 35.24 [1] 153.73 5.160 123.70 74.79 [1] 153.73 1.350 50.38 -81.74 [1] 153.73 153.74 2.170 131.42 8.66 [1] 153.73 153.74 2.170 131.35 8.66 [1] 153.73 153.74 2.170 131.35 8.73 [1] 153.74 2.160 342.38 15.27 [1] 153.74 4.560 167.45 21.67 [1] 153.74 12.110 234.38 84.14 [1] 153.74 1.550 294.57 -87.26 [1] 153.74 153.75 4.580 27.25 14.57 [1] 153.74 153.75 4.570 27.39 14.29 [1] 153.74 153.75 4.570 27.54 14.30 [1] 153.75 0.820 147.55 1.96 [1] 153.75 8.360 189.98 83.08 [1] 153.75 1.100 197.11 -86.67 [1] 153.75 153.76 8.470 60.89 19.33 [1] 153.75 153.76 8.470 60.74 19.33 [1] 153.75 153.76 8.470 60.77 19.23 [1] 153.76 0.410 359.12 11.97 [1] 153.76 0.920 190.46 10.73 [1] 153.76 1.180 70.36 88.64 [1] 153.76 1.280 120.95 -83.97 [1] 153.76 153.77 5.730 104.51 1.01 [1] 153.76 153.77 5.730 104.62 1.02 [1] 153.76 153.77 5.730 104.60 0.90 [1] 153.77 0.490 333.81 -8.65 [1] 153.77 2.350 164.36 23.76 [1] 153.77 2.110 45.37 82.47 [1] 153.77 0.340 300.28 -87.27 [1] 153.77 153.78 5.190 84.15 24.35 [1] 153.77 153.78 5.190 84.16 24.27 [1] 153.77 153.78 5.190 84.26 24.32 [1] 153.78 1.850 189.88 5.06 [1] 153.78 0.420 110.15 87.16 [1] 153.78 0.450 342.41 -88.96 [1] 153.78 153.79 1.270 102.91 2.42 [1] 153.78 153.79 1.270 103.06 2.38 [1] 153.78 153.79 1.280 102.85 2.48 [1] CaveConverter_src/test/data/regression/TripComment_ps_ref.svx0000644000000000000000000000373512226764012023614 0ustar rootroot*BEGIN TrainingRoom *BEGIN 1 ;WSCC DistoX - Footleg ;Dell PDA drawing - Bob *DATE 2012.11.24 *FLAGS SPLAY 0 0a 1.17 8.87 6.87 0 0b 1.11 175.45 -0.10 0 0c 5.95 98.10 6.04 0 0d 5.01 277.41 17.22 0 0e 1.04 47.72 83.13 0 0f 1.09 153.35 -85.85 *FLAGS NOT SPLAY 0 1 5.08 327.47 56.76 *FLAGS SPLAY 1 1a 0.86 248.16 84.61 1 1b 1.97 36.72 85.36 1 1c 2.90 0.21 79.16 1 1d 3.57 0.44 76.99 1 1e 3.33 6.81 73.92 1 1f 3.08 9.73 72.19 1 1g 1.51 33.34 73.27 1 1h 1.13 41.39 63.01 1 1i 0.91 55.93 43.46 1 1j 0.95 54.38 25.70 1 1k 0.71 50.23 15.55 1 1l 0.80 52.99 -17.45 1 1m 0.78 47.54 -32.25 1 1n 0.80 49.21 -38.08 1 1o 1.22 48.37 -40.44 1 1p 1.44 44.13 -46.36 1 1q 1.83 42.45 -54.49 1 1r 1.84 35.11 -63.47 1 1s 1.51 111.18 -81.34 1 1t 1.56 208.58 -80.33 1 1u 0.80 65.58 -74.77 1 1v 0.63 17.58 -85.44 1 1w 0.55 281.21 -80.62 1 1x 0.86 174.05 0.08 1 1y 1.51 155.18 1.24 1 1z 1.96 140.40 -3.29 1 1aa 2.58 131.69 -4.78 1 1ab 2.68 130.29 -4.55 1 1ac 0.58 315.38 2.25 1 1ad 1.05 326.37 2.41 1 1ae 1.28 112.92 -6.48 1 1af 1.03 99.66 -5.08 1 1ag 0.74 82.81 -4.14 1 1ah 0.62 62.72 -5.29 1 1ai 0.71 34.15 -9.16 1 1aj 1.52 4.78 -10.78 1 1ak 1.62 348.65 -11.00 1 1al 1.85 336.13 -6.26 1 1am 2.39 329.33 -3.53 *FLAGS NOT SPLAY 1 2 4.92 69.83 23.86 *FLAGS SPLAY 2 2a 0.95 165.48 0.82 2 2b 3.80 331.85 24.88 2 2c 2.96 27.78 70.94 2 2d 1.76 85.45 -85.86 2 2e 13.10 71.82 16.81 2 2f 7.76 33.32 29.66 2 2g 5.74 289.73 15.19 2 2h 5.02 257.83 -9.98 2 2i 2.80 233.18 -16.44 *FLAGS NOT SPLAY 2 3 2.00 337.58 33.09 *FLAGS SPLAY 3 3a 1.67 169.43 -3.02 3 3b 2.00 339.94 5.13 3 3c 1.85 274.03 82.17 3 3d 0.75 63.40 -83.13 *FLAGS NOT SPLAY *data passage station left right up down 0 3.67 4.49 1.03 1.09 1 1.81 2.48 1.96 0.63 2 5.52 9.34 2.80 1.75 3 0.34 0.00 1.84 0.75 *END 1 *END TrainingRoom CaveConverter_src/test/data/regression/NightMare_in.svx0000644000000000000000000000570212076527374022370 0ustar rootroot*begin NightMare *EQUATE 25 Mares090408a.0 *EQUATE 7 2007a.7 *EQUATE Mares090408a.4 Mares090408b.4 ;surveyors: Dave Garman, Paul Dold, Chris Agnew, Tony Radmall (Badger) ;name: Mareserection *date 2007.07.01 *CALIBRATE declination 2.28 ;declination is 2 41' (2.68) for 2004 changing by 8'E per year. ; 2.55 used for 2005 ; 2.42 used for 2006 ; 2.28 used for 2007 ; 2.15 used for 2008 *fix 1 452220 4800904 274 ;Altitude fixed using surface mesh *entrance 1 1 2 1.72 145 -47; .2 .3 .1 .4 2 3 2.90 353 -49; .7 .1 1 1 3 4 4.22 - -V; .2 .2 .1 4 5 4.95 103 11; 1 .8 4 .2 5 6 2.17 72 40; .5 .3 2 1 6 7 2.51 100 -35; .2 .4 1.5 .6 7 9 2.98 68 19; .3 .3 .5 1.6 9 10 3.00 110 -2; .1 .3 1 3 10 11 2.58 98 -11; .5 0 1.5 3 11 12 4.8 - -V; 4.1 5.6 1.3 11 13 4.4 48 -11 13 14 2.3 20 -43; 0 .5 .6 1.7 14 15 7.35 50 -4; .1 .6 1.8 .4 15 16 7.35 35 -5; 1 .1 2 1 16 17 4.1 25 14; 1 0 2 1 17 18 5.9 73 -5; 0 .7 1.4 1.6 18 19 7.4 32 -3; 1.2 0 1.4 1.5 19 20 5.63 49 -3; 1 .1 1.5 .93 20 21 3.91 110 -4; 0 1.2 1.4 1 21 22 4.02 85 2; 1 0 1 1.3 22 23 3.00 38 -3; .8 .3 .5 1.4 23 24 3.3 150 -11; 0 1.3 .7 1.7 24 25 6.57 99 0; 2 .2 1.3 1.4 25 26 1.82 182 3; 1.5 1.3 1 0 26 27 1.91 28 7 26 28 2.5 202 20 *data passage station left right up down 1 .2 .3 .1 .4 2 .7 .1 1 1 3 .2 .2 .1 2 4 1 .8 2 .2 5 .5 .3 2 1 6 .2 .4 1.5 .6 7 .3 .3 .5 1.6 9 .1 .3 1 3 10 .5 0 1.5 3 11 4.1 5.6 1.3 4.8 13 0 .5 .6 1.7 14 .1 .6 1.8 .4 15 1 .1 2 1 16 1 0 2 1 17 0 .7 1.4 1.6 18 1.2 0 1.4 1.5 19 1 .1 1.5 .93 20 0 1.2 1.4 1 21 1 0 1 1.3 22 .8 .3 .5 1.4 23 0 1.3 .7 1.7 24 2 .2 1.3 1.4 25 1.5 1.3 1 0 *begin 2007a *export 7 *date 2007.07.01 *data normal from to tape compass clino 7 8 6.9 222 -11 *end 2007a *BEGIN Mares090408a *EXPORT 0 4 ;surveyors: Footleg, Alister Smith, Steve Woolvern *Date 2009.04.08 *CALIBRATE declination 2.08 *data normal from to tape compass clino 0 1 3.00 91.06 6.73 1 2 2.91 20.29 3.57 2 3 4.11 19.88 -2.27 3 4 2.03 331.14 4.87 4 5 2.43 28.98 -37.75 *data passage station left right up down 0 0.86 1.02 1.4 1.06 1 0.38 0.0 0.29 0.38 2 0.67 0.57 0.43 1.36 3 1.26 0.27 0.26 0.37 4 0.65 1.4 0.0 0.79 *END Mares090408a *BEGIN Mares090408b *EXPORT 4 *Equate 6 6a ;surveyors: Footleg, Alister Smith, Steve Woolvern *Date 2009.04.08 *CALIBRATE declination 2.08 *data normal from to tape compass clino 4 6a 1.91 63.99 -6.15 6a 7 3.35 32.37 -4.35 6 8 8.17 104.93 -1.38 8 9 1.78 139.35 4.60 9 10 2.70 100.81 0.36 10 11 4.72 56.33 -3.82 11 12 1.25 69.40 -4.66 12 13 2.95 112.51 -3.77 12 14 3.97 136.09 3.99 14 15 1.44 68.87 -26.54 15 16 2.30 131.94 -17.98 *data passage station left right up down 4 0.65 1.4 0.0 0.79 6 1.44 1.38 0.0 0.53 8 0.28 2.13 0.22 0.19 9 0.7 0.0 0.0 0.37 10 0.34 0.0 0.0 0.58 11 0.57 1.05 0.51 0.28 12 0.7 1.0 0.47 0.23 14 0.5 0.0 0.26 0.4 15 0.0 0.52 0.48 0.66 *END Mares090408b *end NightMareCaveConverter_src/test/data/regression/comments_in.svx0000644000000000000000000001160512166255214022325 0ustar rootroot*BEGIN Swildons *ENTRANCE Ent *EQUATE Ent EntranceZigZags.3 *EQUATE surfacegps.4 EntranceZigZags.3 *EQUATE EntranceZigZags.5 LongDryWay.0 *EQUATE LongDryWay.5 EntranceZigZags.21 *EQUATE LongDryWay.5 ShortDryWay.0 *BEGIN surfacegps ;Not using blockhouse fix as GPS under trees not great. Loop error between other ;two better GPS fixes is 2.56m. These two fixes average the position of the grating ;inside the blockhouse at 53122.3 51308.5 237.3 ;surface gps tie in for entrance using good WAAS GPS fixes ;WSCC DistoX-Footleg *DATE 2013.06.30 *CALIBRATE declination +1.58 *FIX 0 53094 51306 245 ;WAAS fix with good clear sky view of 8 satellites *FIX 7 53119 51282 245 ;WAAS fix with good clear sky view of 8 satellites *FLAGS SURFACE 0 1 9.84 94.37 -5.88 ;stn0=left hand gate post as seen from cave entrance. gps fixed 1 2 7.84 97.65 -8.05 2 3 11.76 94.27 -17.67 3 4 4.38 7.38 -23.29 ;stn4=rh front corner of entrance grating in blockhouse 3 5 5.45 262.93 13.06 5 6 8.80 174.95 11.61 6 7 13.78 168.31 12.55 ;stn7=2nd fence post from corner. Taller of the two fences. gps fixed. *END surfacegps *BEGIN EntranceZigZags *DATE 2012.09.09 *CALIBRATE declination .6 *CALIBRATE compass 1.1 *CALIBRATE clino -0.1 *FLAGS SURFACE 0 1 2.98 10.26 -2.01 ;1.1 has magnetic problems. So surveyed to it from knot on tree opposite door=1.0 Then from knot to rear wall of blockhouse 1.0-1.2 0 2 5.24 3.23 -5.04 ;1.2=rawl plug on rear wall of blockhouse 2 3 2.64 166.70 -60.11 ;1.3=Top left corner of stream culvert when looking out of cave *FLAGS NOT SURFACE 3 4 3.10 330.76 -25.13 4 5 4.51 275.80 -12.10 ;1.5=polished tip of pointy boulder by top of drop into lower level of chamber. Boulder is dark grey with white flecks and fossils. 5 6 2.41 50.67 -22.33 6 7 1.08 37.30 11.53 7 8 2.00 6.10 11.51 8 9 1.01 56.60 0.18 ;1.9=bottom point of sharp vertical edge of boulder forming ceiling 9 10 3.07 336.52 5.81 ;1.10=bottom of cream calcite rib running down RH wall 9 11 2.42 64.64 5.29 11 12 4.50 106.56 19.29 10 13 0.94 80.55 -45.63 13 14 5.31 65.16 19.50 10 15 3.27 329.15 -18.16 15 16 3.57 334.08 -6.33 16 17 2.41 207.98 -9.43 17 18 4.05 308.01 -19.25 18 19 2.06 211.48 -16.06 19 20 2.94 233.55 -35.84 20 21 2.04 14.57 -39.09 ;1.21=25cm tall stumpy stalagmite on floor to left of top of Jacob's Ladder. Stn is centre of flat ring on top. *END EntranceZigZags *BEGIN LongDryWay ;Badger, Cave Ferret, Footleg *DATE 2013.02.23 *CALIBRATE declination +3.63 *CALIBRATE compass -2 *CALIBRATE clino 0.1 0 1 4.08 270.72 -25.50 1 2 3.77 354.35 -29.81 ;2.2=bottom tip of point of flowstone on RH wall looking into cave. Two tone calcite point. 2 3 4.33 336.10 -24.79 3 4 2.77 337.70 -4.41 4 5 3.14 343.71 -25.59 *END LongDryWay *BEGIN ShortDryWay ;Badger, Paul Dold, Footleg *DATE 2013.02.24 *CALIBRATE declination +5.13 ;Declination comment *CALIBRATE compass -2.5 ;Compass calibration comment *CALIBRATE clino 0.1 ;Clino calibration comment 0 1 1.43 131.61 -13.25 *FLAGS SPLAY 1 1a 1.42 311.07 12.80 1 1b 0.58 327.33 -0.57 1 1c 0.50 258.56 -34.18 1 1d 0.94 171.13 -6.41 *FLAGS NOT SPLAY DUPLICATE 1 2 3.89 73.29 -51.63 *FLAGS SPLAY NOT DUPLICATE 2 2a 3.91 252.77 52.00 2 2b 2.44 239.99 47.81 2 2c 0.91 252.72 -4.04 2 2d 0.80 250.31 -35.24 *FLAGS NOT SPLAY NOT DUPLICATE 2 3 4.50 170.72 19.68 ;3.3=tip of downward pointing rock spike on ceiling *FLAGS SPLAY DUPLICATE 3 3a 1.54 358.12 82.08 3 3b 0.94 170.44 -79.46 3 3c 0.46 71.39 -4.30 3 3d 0.45 220.38 -6.59 3 3e 4.46 350.50 -20.39 3 3f 0.39 251.63 -13.19 *FLAGS NOT SPLAY 3 4 1.11 246.49 -14.16 *FLAGS SPLAY 4 4a 0.60 345.93 65.79 4 4b 0.68 212.13 -85.64 4 4c 0.28 4.71 4.35 4 4d 2.84 294.88 -9.50 *FLAGS NOT SPLAY 2 5 4.91 323.66 2.34 *FLAGS SPLAY 5 5a 1.68 227.27 67.16 5 5b 0.87 46.77 -82.61 5 5c 4.91 143.73 -2.57 5 5d 0.74 236.15 -6.85 5 5e 1.03 103.39 -8.81 5 5f 2.18 148.83 -2.53 *FLAGS NOT SPLAY 5 6 5.05 279.35 -25.23 *FLAGS SPLAY 6 6a 2.83 16.27 74.62 6 6b 1.16 111.26 -85.03 6 6c 5.05 99.27 25.32 6 6d 0.58 34.79 1.49 6 6e 2.60 99.05 2.63 6 6f 2.79 105.09 4.91 *FLAGS NOT SPLAY 6 7 5.02 336.36 -13.85 *FLAGS SPLAY 7 7a 3.73 254.43 80.33 7 7b 0.54 182.41 -84.02 7 7c 2.55 328.39 -82.67 7 7d 5.00 156.87 13.29 7 7e 0.41 231.77 -3.06 *FLAGS NOT SPLAY 7 8 3.19 303.08 -33.11 *FLAGS SPLAY 8 8a 4.46 353.35 80.60 8 8b 1.45 224.40 -78.95 8 8c 3.21 123.01 33.05 8 8d 0.53 23.07 -5.56 8 8e 1.87 72.08 1.35 *FLAGS NOT SPLAY 8 9 6.71 295.69 -12.15 ;3.9=lone little knobby white stalagmite on wall *FLAGS SPLAY 9 9a 1.16 244.84 81.25 9 9b 1.09 201.63 -76.54 9 9c 6.72 115.55 11.83 9 9d 0.56 196.48 2.10 9 9e 3.56 117.58 -4.92 *FLAGS NOT SPLAY 9 10 1.11 265.93 2.35 *END ShortDryWay *END Swildons CaveConverter_src/test/data/regression/flags_st_cmds_ref.text0000644000000000000000000004560112167345702023630 0ustar rootroot -6 1 1 1 1 Cave Name -5 1 1 1 1 0.00 0.00 0.00 1 0 -4 1 1 1 1 12/08/16 13:14:15 CaveConverter -3 1 1 1 1 -2 1 1 1 1 16/08/12 Converted Data 0 0.00 0 1 -1 1 1 1 1 360.00 360.00 0.05 1.00 1.00 100.00 0.00 1 -2 1 1 1 Series 1-root.Swildons.surfacegps 1 -1 1 1 1 1 0 1 13 13 3 0 1 0 1 1 1 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1 1 1 1 1 9.84 94.37 -5.88 0.00 0.00 0.00 0.00 1 2 1 1 1 7.84 97.65 -8.05 0.00 0.00 0.00 0.00 1 3 1 1 1 11.76 94.27 -17.67 0.00 0.00 0.00 0.00 1 4 1 1 1 4.38 7.38 -23.29 0.00 0.00 0.00 0.00 1 5 1 1 1 3.10 330.76 -25.13 0.00 0.00 0.00 0.00 1 6 1 1 1 4.51 275.80 -12.10 0.00 0.00 0.00 0.00 1 7 1 1 1 2.41 50.67 -22.33 0.00 0.00 0.00 0.00 1 8 1 1 1 1.08 37.30 11.53 0.00 0.00 0.00 0.00 1 9 1 1 1 2.00 6.10 11.51 0.00 0.00 0.00 0.00 1 10 1 1 1 1.01 56.60 0.18 0.00 0.00 0.00 0.00 1 11 1 1 1 3.07 336.52 5.81 0.00 0.00 0.00 0.00 1 12 1 1 1 0.94 80.55 -45.63 0.00 0.00 0.00 0.00 1 13 1 1 1 5.31 65.16 19.50 0.00 0.00 0.00 0.00 2 -2 1 1 1 Series 2-root.Swildons.surfacegps 2 -1 1 1 1 1 3 2 3 3 3 0 2 0 1 1 1 0.00 0.00 0.00 0.00 0.00 0.00 0.00 2 1 1 1 1 5.45 262.93 13.06 0.00 0.00 0.00 0.00 2 2 1 1 1 8.80 174.95 11.61 0.00 0.00 0.00 0.00 2 3 1 1 1 13.78 168.31 12.55 0.00 0.00 0.00 0.00 3 -2 1 1 1 Series 3-root.Swildons.EntranceZigZags 3 -1 1 1 1 4 0 3 1 1 3 0 3 0 1 1 1 0.00 0.00 0.00 0.00 0.00 0.00 0.00 3 1 1 1 1 2.98 10.26 -2.01 0.00 0.00 0.00 0.00 4 -2 1 1 1 Series 4-root.Swildons.EntranceZigZags 4 -1 1 1 1 4 0 1 4 2 3 0 4 0 1 1 1 0.00 0.00 0.00 0.00 0.00 0.00 0.00 4 1 1 1 1 5.24 3.23 -5.04 0.00 0.00 0.00 0.00 4 2 1 1 1 2.64 166.70 -60.11 0.00 0.00 0.00 0.00 5 -2 1 1 1 Series 5-root.Swildons.EntranceZigZags 5 -1 1 1 1 1 10 5 2 2 3 0 5 0 1 1 1 0.00 0.00 0.00 0.00 0.00 0.00 0.00 5 1 1 1 1 2.42 64.64 5.29 0.00 0.00 0.00 0.00 5 2 1 1 1 4.50 106.56 19.29 0.00 0.00 0.00 0.00 6 -2 1 1 1 Series 6-root.Swildons.EntranceZigZags 6 -1 1 1 1 1 11 6 9 9 3 0 6 0 1 1 1 0.00 0.00 0.00 0.00 0.00 0.00 0.00 6 1 1 1 1 3.27 329.15 -18.16 0.00 0.00 0.00 0.00 6 2 1 1 1 3.57 334.08 -6.33 0.00 0.00 0.00 0.00 6 3 1 1 1 2.41 207.98 -9.43 0.00 0.00 0.00 0.00 6 4 1 1 1 4.05 308.01 -19.25 0.00 0.00 0.00 0.00 6 5 1 1 1 2.06 211.48 -16.06 0.00 0.00 0.00 0.00 6 6 1 1 1 2.94 233.55 -35.84 0.00 0.00 0.00 0.00 6 7 1 1 1 2.04 14.57 -39.09 0.00 0.00 0.00 0.00 6 8 1 1 1 1.43 131.61 -13.25 0.00 0.00 0.00 0.00 6 9 1 1 1 1.42 311.07 12.80 0.00 0.00 0.00 0.00 7 -2 1 1 1 Series 7-root.Swildons.LongDryWay 7 -1 1 1 1 1 6 6 7 5 3 0 7 0 1 1 1 0.00 0.00 0.00 0.00 0.00 0.00 0.00 7 1 1 1 1 4.08 270.72 -25.50 0.00 0.00 0.00 0.00 7 2 1 1 1 3.77 354.35 -29.81 0.00 0.00 0.00 0.00 7 3 1 1 1 4.33 336.10 -24.79 0.00 0.00 0.00 0.00 7 4 1 1 1 2.77 337.70 -4.41 0.00 0.00 0.00 0.00 7 5 1 1 1 3.14 343.71 -25.59 0.00 0.00 0.00 0.00 8 -2 1 1 1 Series 8-root.Swildons.ShortDryWay 8 -1 1 1 1 6 8 8 1 1 3 0 8 0 1 1 1 0.00 0.00 0.00 0.00 0.00 0.00 0.00 8 1 1 1 1 0.58 327.33 -0.57 0.00 0.00 0.00 0.00 9 -2 1 1 1 Series 9-root.Swildons.ShortDryWay 9 -1 1 1 1 6 8 9 1 1 3 0 9 0 1 1 1 0.00 0.00 0.00 0.00 0.00 0.00 0.00 9 1 1 1 1 0.50 258.56 -34.18 0.00 0.00 0.00 0.00 10 -2 1 1 1 Series 10-root.Swildons.ShortDryWay 10 -1 1 1 1 6 8 10 1 1 3 0 10 0 1 1 1 0.00 0.00 0.00 0.00 0.00 0.00 0.00 10 1 1 1 1 0.94 171.13 -6.41 0.00 0.00 0.00 0.00 11 -2 1 1 1 Series 11-root.Swildons.ShortDryWay 11 -1 1 1 1 6 8 11 2 2 3 0 11 0 1 1 1 0.00 0.00 0.00 0.00 0.00 0.00 0.00 11 1 1 1 1 3.89 73.29 -51.63 0.00 0.00 0.00 0.00 11 2 1 1 1 3.91 252.77 52.00 0.00 0.00 0.00 0.00 12 -2 1 1 1 Series 12-root.Swildons.ShortDryWay 12 -1 1 1 1 11 1 12 1 1 3 0 12 0 1 1 1 0.00 0.00 0.00 0.00 0.00 0.00 0.00 12 1 1 1 1 2.44 239.99 47.81 0.00 0.00 0.00 0.00 13 -2 1 1 1 Series 13-root.Swildons.ShortDryWay 13 -1 1 1 1 11 1 13 1 1 3 0 13 0 1 1 1 0.00 0.00 0.00 0.00 0.00 0.00 0.00 13 1 1 1 1 0.91 252.72 -4.04 0.00 0.00 0.00 0.00 14 -2 1 1 1 Series 14-root.Swildons.ShortDryWay 14 -1 1 1 1 11 1 14 1 1 3 0 14 0 1 1 1 0.00 0.00 0.00 0.00 0.00 0.00 0.00 14 1 1 1 1 0.80 250.31 -35.24 0.00 0.00 0.00 0.00 15 -2 1 1 1 Series 15-root.Swildons.ShortDryWay 15 -1 1 1 1 11 1 15 2 2 3 0 15 0 1 1 1 0.00 0.00 0.00 0.00 0.00 0.00 0.00 15 1 1 1 1 4.50 170.72 19.68 0.00 0.00 0.00 0.00 15 2 1 1 1 1.54 358.12 82.08 0.00 0.00 0.00 0.00 16 -2 1 1 1 Series 16-root.Swildons.ShortDryWay 16 -1 1 1 1 15 1 16 1 1 3 0 16 0 1 1 1 0.00 0.00 0.00 0.00 0.00 0.00 0.00 16 1 1 1 1 0.94 170.44 -79.46 0.00 0.00 0.00 0.00 17 -2 1 1 1 Series 17-root.Swildons.ShortDryWay 17 -1 1 1 1 15 1 17 1 1 3 0 17 0 1 1 1 0.00 0.00 0.00 0.00 0.00 0.00 0.00 17 1 1 1 1 0.46 71.39 -4.30 0.00 0.00 0.00 0.00 18 -2 1 1 1 Series 18-root.Swildons.ShortDryWay 18 -1 1 1 1 15 1 18 1 1 3 0 18 0 1 1 1 0.00 0.00 0.00 0.00 0.00 0.00 0.00 18 1 1 1 1 0.45 220.38 -6.59 0.00 0.00 0.00 0.00 19 -2 1 1 1 Series 19-root.Swildons.ShortDryWay 19 -1 1 1 1 15 1 19 1 1 3 0 19 0 1 1 1 0.00 0.00 0.00 0.00 0.00 0.00 0.00 19 1 1 1 1 4.46 350.50 -20.39 0.00 0.00 0.00 0.00 20 -2 1 1 1 Series 20-root.Swildons.ShortDryWay 20 -1 1 1 1 15 1 20 1 1 3 0 20 0 1 1 1 0.00 0.00 0.00 0.00 0.00 0.00 0.00 20 1 1 1 1 0.39 251.63 -13.19 0.00 0.00 0.00 0.00 21 -2 1 1 1 Series 21-root.Swildons.ShortDryWay 21 -1 1 1 1 15 1 21 2 2 3 0 21 0 1 1 1 0.00 0.00 0.00 0.00 0.00 0.00 0.00 21 1 1 1 1 1.11 246.49 -14.16 0.00 0.00 0.00 0.00 21 2 1 1 1 0.60 345.93 65.79 0.00 0.00 0.00 0.00 22 -2 1 1 1 Series 22-root.Swildons.ShortDryWay 22 -1 1 1 1 21 1 22 1 1 3 0 22 0 1 1 1 0.00 0.00 0.00 0.00 0.00 0.00 0.00 22 1 1 1 1 0.68 212.13 -85.64 0.00 0.00 0.00 0.00 23 -2 1 1 1 Series 23-root.Swildons.ShortDryWay 23 -1 1 1 1 21 1 23 1 1 3 0 23 0 1 1 1 0.00 0.00 0.00 0.00 0.00 0.00 0.00 23 1 1 1 1 0.28 4.71 4.35 0.00 0.00 0.00 0.00 24 -2 1 1 1 Series 24-root.Swildons.ShortDryWay 24 -1 1 1 1 21 1 24 1 1 3 0 24 0 1 1 1 0.00 0.00 0.00 0.00 0.00 0.00 0.00 24 1 1 1 1 2.84 294.88 -9.50 0.00 0.00 0.00 0.00 25 -2 1 1 1 Series 25-root.Swildons.ShortDryWay 25 -1 1 1 1 11 1 25 2 2 3 0 25 0 1 1 1 0.00 0.00 0.00 0.00 0.00 0.00 0.00 25 1 1 1 1 4.91 323.66 2.34 0.00 0.00 0.00 0.00 25 2 1 1 1 1.68 227.27 67.16 0.00 0.00 0.00 0.00 26 -2 1 1 1 Series 26-root.Swildons.ShortDryWay 26 -1 1 1 1 25 1 26 1 1 3 0 26 0 1 1 1 0.00 0.00 0.00 0.00 0.00 0.00 0.00 26 1 1 1 1 0.87 46.77 -82.61 0.00 0.00 0.00 0.00 27 -2 1 1 1 Series 27-root.Swildons.ShortDryWay 27 -1 1 1 1 25 1 27 1 1 3 0 27 0 1 1 1 0.00 0.00 0.00 0.00 0.00 0.00 0.00 27 1 1 1 1 4.91 143.73 -2.57 0.00 0.00 0.00 0.00 28 -2 1 1 1 Series 28-root.Swildons.ShortDryWay 28 -1 1 1 1 25 1 28 1 1 3 0 28 0 1 1 1 0.00 0.00 0.00 0.00 0.00 0.00 0.00 28 1 1 1 1 0.74 236.15 -6.85 0.00 0.00 0.00 0.00 29 -2 1 1 1 Series 29-root.Swildons.ShortDryWay 29 -1 1 1 1 25 1 29 1 1 3 0 29 0 1 1 1 0.00 0.00 0.00 0.00 0.00 0.00 0.00 29 1 1 1 1 1.03 103.39 -8.81 0.00 0.00 0.00 0.00 30 -2 1 1 1 Series 30-root.Swildons.ShortDryWay 30 -1 1 1 1 25 1 30 1 1 3 0 30 0 1 1 1 0.00 0.00 0.00 0.00 0.00 0.00 0.00 30 1 1 1 1 2.18 148.83 -2.53 0.00 0.00 0.00 0.00 31 -2 1 1 1 Series 31-root.Swildons.ShortDryWay 31 -1 1 1 1 25 1 31 2 2 3 0 31 0 1 1 1 0.00 0.00 0.00 0.00 0.00 0.00 0.00 31 1 1 1 1 5.05 279.35 -25.23 0.00 0.00 0.00 0.00 31 2 1 1 1 2.83 16.27 74.62 0.00 0.00 0.00 0.00 32 -2 1 1 1 Series 32-root.Swildons.ShortDryWay 32 -1 1 1 1 31 1 32 1 1 3 0 32 0 1 1 1 0.00 0.00 0.00 0.00 0.00 0.00 0.00 32 1 1 1 1 1.16 111.26 -85.03 0.00 0.00 0.00 0.00 33 -2 1 1 1 Series 33-root.Swildons.ShortDryWay 33 -1 1 1 1 31 1 33 1 1 3 0 33 0 1 1 1 0.00 0.00 0.00 0.00 0.00 0.00 0.00 33 1 1 1 1 5.05 99.27 25.32 0.00 0.00 0.00 0.00 34 -2 1 1 1 Series 34-root.Swildons.ShortDryWay 34 -1 1 1 1 31 1 34 1 1 3 0 34 0 1 1 1 0.00 0.00 0.00 0.00 0.00 0.00 0.00 34 1 1 1 1 0.58 34.79 1.49 0.00 0.00 0.00 0.00 35 -2 1 1 1 Series 35-root.Swildons.ShortDryWay 35 -1 1 1 1 31 1 35 1 1 3 0 35 0 1 1 1 0.00 0.00 0.00 0.00 0.00 0.00 0.00 35 1 1 1 1 2.60 99.05 2.63 0.00 0.00 0.00 0.00 36 -2 1 1 1 Series 36-root.Swildons.ShortDryWay 36 -1 1 1 1 31 1 36 1 1 3 0 36 0 1 1 1 0.00 0.00 0.00 0.00 0.00 0.00 0.00 36 1 1 1 1 2.79 105.09 4.91 0.00 0.00 0.00 0.00 37 -2 1 1 1 Series 37-root.Swildons.ShortDryWay 37 -1 1 1 1 31 1 37 2 2 3 0 37 0 1 1 1 0.00 0.00 0.00 0.00 0.00 0.00 0.00 37 1 1 1 1 5.02 336.36 -13.85 0.00 0.00 0.00 0.00 37 2 1 1 1 3.73 254.43 80.33 0.00 0.00 0.00 0.00 38 -2 1 1 1 Series 38-root.Swildons.ShortDryWay 38 -1 1 1 1 37 1 38 1 1 3 0 38 0 1 1 1 0.00 0.00 0.00 0.00 0.00 0.00 0.00 38 1 1 1 1 0.54 182.41 -84.02 0.00 0.00 0.00 0.00 39 -2 1 1 1 Series 39-root.Swildons.ShortDryWay 39 -1 1 1 1 37 1 39 1 1 3 0 39 0 1 1 1 0.00 0.00 0.00 0.00 0.00 0.00 0.00 39 1 1 1 1 2.55 328.39 -82.67 0.00 0.00 0.00 0.00 40 -2 1 1 1 Series 40-root.Swildons.ShortDryWay 40 -1 1 1 1 37 1 40 1 1 3 0 40 0 1 1 1 0.00 0.00 0.00 0.00 0.00 0.00 0.00 40 1 1 1 1 5.00 156.87 13.29 0.00 0.00 0.00 0.00 41 -2 1 1 1 Series 41-root.Swildons.ShortDryWay 41 -1 1 1 1 37 1 41 1 1 3 0 41 0 1 1 1 0.00 0.00 0.00 0.00 0.00 0.00 0.00 41 1 1 1 1 0.41 231.77 -3.06 0.00 0.00 0.00 0.00 42 -2 1 1 1 Series 42-root.Swildons.ShortDryWay 42 -1 1 1 1 37 1 42 2 2 3 0 42 0 1 1 1 0.00 0.00 0.00 0.00 0.00 0.00 0.00 42 1 1 1 1 3.19 303.08 -33.11 0.00 0.00 0.00 0.00 42 2 1 1 1 4.46 353.35 80.60 0.00 0.00 0.00 0.00 43 -2 1 1 1 Series 43-root.Swildons.ShortDryWay 43 -1 1 1 1 42 1 43 1 1 3 0 43 0 1 1 1 0.00 0.00 0.00 0.00 0.00 0.00 0.00 43 1 1 1 1 1.45 224.40 -78.95 0.00 0.00 0.00 0.00 44 -2 1 1 1 Series 44-root.Swildons.ShortDryWay 44 -1 1 1 1 42 1 44 1 1 3 0 44 0 1 1 1 0.00 0.00 0.00 0.00 0.00 0.00 0.00 44 1 1 1 1 3.21 123.01 33.05 0.00 0.00 0.00 0.00 45 -2 1 1 1 Series 45-root.Swildons.ShortDryWay 45 -1 1 1 1 42 1 45 1 1 3 0 45 0 1 1 1 0.00 0.00 0.00 0.00 0.00 0.00 0.00 45 1 1 1 1 0.53 23.07 -5.56 0.00 0.00 0.00 0.00 46 -2 1 1 1 Series 46-root.Swildons.ShortDryWay 46 -1 1 1 1 42 1 46 1 1 3 0 46 0 1 1 1 0.00 0.00 0.00 0.00 0.00 0.00 0.00 46 1 1 1 1 1.87 72.08 1.35 0.00 0.00 0.00 0.00 47 -2 1 1 1 Series 47-root.Swildons.ShortDryWay 47 -1 1 1 1 42 1 47 2 2 3 0 47 0 1 1 1 0.00 0.00 0.00 0.00 0.00 0.00 0.00 47 1 1 1 1 6.71 295.69 -12.15 0.00 0.00 0.00 0.00 47 2 1 1 1 1.16 244.84 81.25 0.00 0.00 0.00 0.00 48 -2 1 1 1 Series 48-root.Swildons.ShortDryWay 48 -1 1 1 1 47 1 48 1 1 3 0 48 0 1 1 1 0.00 0.00 0.00 0.00 0.00 0.00 0.00 48 1 1 1 1 1.09 201.63 -76.54 0.00 0.00 0.00 0.00 49 -2 1 1 1 Series 49-root.Swildons.ShortDryWay 49 -1 1 1 1 47 1 49 1 1 3 0 49 0 1 1 1 0.00 0.00 0.00 0.00 0.00 0.00 0.00 49 1 1 1 1 6.72 115.55 11.83 0.00 0.00 0.00 0.00 50 -2 1 1 1 Series 50-root.Swildons.ShortDryWay 50 -1 1 1 1 47 1 50 1 1 3 0 50 0 1 1 1 0.00 0.00 0.00 0.00 0.00 0.00 0.00 50 1 1 1 1 0.56 196.48 2.10 0.00 0.00 0.00 0.00 51 -2 1 1 1 Series 51-root.Swildons.ShortDryWay 51 -1 1 1 1 47 1 51 1 1 3 0 51 0 1 1 1 0.00 0.00 0.00 0.00 0.00 0.00 0.00 51 1 1 1 1 3.56 117.58 -4.92 0.00 0.00 0.00 0.00 52 -2 1 1 1 Series 52-root.Swildons.ShortDryWay 52 -1 1 1 1 47 1 52 1 1 3 0 52 0 1 1 1 0.00 0.00 0.00 0.00 0.00 0.00 0.00 52 1 1 1 1 1.11 265.93 2.35 0.00 0.00 0.00 0.00CaveConverter_src/test/data/regression/2649_Mares_from3d_dt_ref.text0000644000000000000000000001320312115213060024465 0ustar rootroot -6 1 1 1 1 Cave Name -5 1 1 1 1 0.00 0.00 0.00 1 0 -4 1 1 1 1 12/08/16 13:14:15 CaveConverter -3 1 1 1 1 -2 1 1 1 1 16/08/12 Converted Data 0 0.00 0 1 -1 1 1 1 1 360.00 360.00 0.05 1.00 1.00 100.00 0.00 1 -2 1 1 1 Series 1-root.SurveyFromDXF.SeriesFromLines1 1 -1 1 1 1 1 0 1 7 7 3 0 1 0 1 1 1 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1 1 1 1 1 1.72 142.64 -47.12 0.00 0.00 0.00 0.00 1 2 1 1 1 2.90 350.59 -49.12 0.00 0.00 0.00 0.00 1 3 1 1 1 4.22 0.00 -90.00 0.00 0.00 0.00 0.00 1 4 1 1 1 4.96 100.66 11.05 0.00 0.00 0.00 0.00 1 5 1 1 1 2.17 69.61 39.87 0.00 0.00 0.00 0.00 1 6 1 1 1 2.50 97.85 -35.10 0.00 0.00 0.00 0.00 1 7 1 1 1 6.89 219.66 -10.95 0.00 0.00 0.00 0.00 2 -2 1 1 1 Series 2-root.SurveyFromDXF.SeriesFromLines2 2 -1 1 1 1 1 6 2 4 4 3 0 2 0 1 1 1 0.00 0.00 0.00 0.00 0.00 0.00 0.00 2 1 1 1 1 2.98 65.71 18.98 0.00 0.00 0.00 0.00 2 2 1 1 1 3.00 107.65 -1.91 0.00 0.00 0.00 0.00 2 3 1 1 1 2.58 95.89 -10.95 0.00 0.00 0.00 0.00 2 4 1 1 1 4.80 0.00 -90.00 0.00 0.00 0.00 0.00 3 -2 1 1 1 Series 3-root.SurveyFromDXF.SeriesFromLines3 3 -1 1 1 1 2 3 3 15 15 3 0 3 0 1 1 1 0.00 0.00 0.00 0.00 0.00 0.00 0.00 3 1 1 1 1 4.40 45.66 -11.00 0.00 0.00 0.00 0.00 3 2 1 1 1 2.30 17.68 -43.07 0.00 0.00 0.00 0.00 3 3 1 1 1 7.35 47.76 -3.98 0.00 0.00 0.00 0.00 3 4 1 1 1 7.35 32.74 -5.07 0.00 0.00 0.00 0.00 3 5 1 1 1 4.10 22.63 14.12 0.00 0.00 0.00 0.00 3 6 1 1 1 5.90 70.73 -5.05 0.00 0.00 0.00 0.00 3 7 1 1 1 7.40 29.69 -2.94 0.00 0.00 0.00 0.00 3 8 1 1 1 5.64 46.73 -3.05 0.00 0.00 0.00 0.00 3 9 1 1 1 3.91 107.78 -3.96 0.00 0.00 0.00 0.00 3 10 1 1 1 4.02 82.72 1.99 0.00 0.00 0.00 0.00 3 11 1 1 1 3.00 35.76 -3.06 0.00 0.00 0.00 0.00 3 12 1 1 1 3.30 147.73 -11.00 0.00 0.00 0.00 0.00 3 13 1 1 1 6.57 96.74 0.00 0.00 0.00 0.00 0.00 3 14 1 1 1 1.81 179.68 3.16 0.00 0.00 0.00 0.00 3 15 1 1 1 1.90 25.75 6.95 0.00 0.00 0.00 0.00 4 -2 1 1 1 Series 4-root.SurveyFromDXF.SeriesFromLines4 4 -1 1 1 1 3 14 4 1 1 3 0 4 0 1 1 1 0.00 0.00 0.00 0.00 0.00 0.00 0.00 4 1 1 1 1 2.50 199.59 19.84 0.00 0.00 0.00 0.00 5 -2 1 1 1 Series 5-root.SurveyFromDXF.SeriesFromLines5 5 -1 1 1 1 3 13 5 5 5 3 0 5 0 1 1 1 0.00 0.00 0.00 0.00 0.00 0.00 0.00 5 1 1 1 1 3.00 88.85 6.70 0.00 0.00 0.00 0.00 5 2 1 1 1 2.91 18.25 3.54 0.00 0.00 0.00 0.00 5 3 1 1 1 4.11 17.73 -2.23 0.00 0.00 0.00 0.00 5 4 1 1 1 2.03 328.99 4.81 0.00 0.00 0.00 0.00 5 5 1 1 1 2.42 26.97 -37.65 0.00 0.00 0.00 0.00 6 -2 1 1 1 Series 6-root.SurveyFromDXF.SeriesFromLines6 6 -1 1 1 1 5 4 6 2 2 3 0 6 0 1 1 1 0.00 0.00 0.00 0.00 0.00 0.00 0.00 6 1 1 1 1 1.92 61.82 -5.99 0.00 0.00 0.00 0.00 6 2 1 1 1 3.34 30.26 -4.29 0.00 0.00 0.00 0.00 7 -2 1 1 1 Series 7-root.SurveyFromDXF.SeriesFromLines7 7 -1 1 1 1 6 1 7 6 6 3 0 7 0 1 1 1 0.00 0.00 0.00 0.00 0.00 0.00 0.00 7 1 1 1 1 8.17 102.88 -1.40 0.00 0.00 0.00 0.00 7 2 1 1 1 1.78 137.05 4.83 0.00 0.00 0.00 0.00 7 3 1 1 1 2.69 98.76 0.21 0.00 0.00 0.00 0.00 7 4 1 1 1 4.73 54.32 -3.76 0.00 0.00 0.00 0.00 7 5 1 1 1 1.25 67.34 -4.59 0.00 0.00 0.00 0.00 7 6 1 1 1 2.94 110.53 -3.90 0.00 0.00 0.00 0.00 8 -2 1 1 1 Series 8-root.SurveyFromDXF.SeriesFromLines8 8 -1 1 1 1 7 5 8 3 3 3 0 8 0 1 1 1 0.00 0.00 0.00 0.00 0.00 0.00 0.00 8 1 1 1 1 3.96 134.08 3.91 0.00 0.00 0.00 0.00 8 2 1 1 1 1.44 67.21 -26.37 0.00 0.00 0.00 0.00 8 3 1 1 1 2.30 129.81 -17.99 0.00 0.00 0.00 0.00CaveConverter_src/test/data/regression/flags_ss_ref.svx0000644000000000000000000000576412166352230022454 0ustar rootroot*BEGIN Swildons *EQUATE Ent EntranceZigZags.3 *EQUATE surfacegps.4 EntranceZigZags.3 *EQUATE LongDryWay.0 EntranceZigZags.5 *EQUATE LongDryWay.5 EntranceZigZags.21 *EQUATE LongDryWay.5 ShortDryWay.0 *BEGIN surfacegps *FLAGS SURFACE 0 1 9.84 94.37 -5.88 1 2 7.84 97.65 -8.05 2 3 11.76 94.27 -17.67 3 4 4.38 7.38 -23.29 3 5 5.45 262.93 13.06 5 6 8.80 174.95 11.61 6 7 13.78 168.31 12.55 *END surfacegps *BEGIN EntranceZigZags *FLAGS SURFACE 0 1 2.98 10.26 -2.01 0 2 5.24 3.23 -5.04 2 3 2.64 166.70 -60.11 *FLAGS NOT SURFACE 3 4 3.10 330.76 -25.13 4 5 4.51 275.80 -12.10 5 6 2.41 50.67 -22.33 6 7 1.08 37.30 11.53 7 8 2.00 6.10 11.51 8 9 1.01 56.60 0.18 9 10 3.07 336.52 5.81 9 11 2.42 64.64 5.29 11 12 4.50 106.56 19.29 10 13 0.94 80.55 -45.63 13 14 5.31 65.16 19.50 10 15 3.27 329.15 -18.16 15 16 3.57 334.08 -6.33 16 17 2.41 207.98 -9.43 17 18 4.05 308.01 -19.25 18 19 2.06 211.48 -16.06 19 20 2.94 233.55 -35.84 20 21 2.04 14.57 -39.09 *END EntranceZigZags *BEGIN LongDryWay 0 1 4.08 270.72 -25.50 1 2 3.77 354.35 -29.81 2 3 4.33 336.10 -24.79 3 4 2.77 337.70 -4.41 4 5 3.14 343.71 -25.59 *END LongDryWay *BEGIN ShortDryWay 0 1 1.43 131.61 -13.25 *FLAGS SPLAY 1 1a 1.42 311.07 12.80 1 1b 0.58 327.33 -0.57 1 1c 0.50 258.56 -34.18 1 1d 0.94 171.13 -6.41 *FLAGS DUPLICATE NOT SPLAY 1 2 3.89 73.29 -51.63 *FLAGS SPLAY 2 2a 3.91 252.77 52.00 2 2b 2.44 239.99 47.81 2 2c 0.91 252.72 -4.04 2 2d 0.80 250.31 -35.24 *FLAGS NOT DUPLICATE NOT SPLAY 2 3 4.50 170.72 19.68 *FLAGS SPLAY 3 3a 1.54 358.12 82.08 3 3b 0.94 170.44 -79.46 3 3c 0.46 71.39 -4.30 3 3d 0.45 220.38 -6.59 3 3e 4.46 350.50 -20.39 3 3f 0.39 251.63 -13.19 *FLAGS NOT SPLAY 3 4 1.11 246.49 -14.16 *FLAGS SPLAY 4 4a 0.60 345.93 65.79 4 4b 0.68 212.13 -85.64 4 4c 0.28 4.71 4.35 4 4d 2.84 294.88 -9.50 *FLAGS NOT SPLAY 2 5 4.91 323.66 2.34 *FLAGS SPLAY 5 5a 1.68 227.27 67.16 5 5b 0.87 46.77 -82.61 5 5c 4.91 143.73 -2.57 5 5d 0.74 236.15 -6.85 5 5e 1.03 103.39 -8.81 5 5f 2.18 148.83 -2.53 *FLAGS NOT SPLAY 5 6 5.05 279.35 -25.23 *FLAGS SPLAY 6 6a 2.83 16.27 74.62 6 6b 1.16 111.26 -85.03 6 6c 5.05 99.27 25.32 6 6d 0.58 34.79 1.49 6 6e 2.60 99.05 2.63 6 6f 2.79 105.09 4.91 *FLAGS NOT SPLAY 6 7 5.02 336.36 -13.85 *FLAGS DUPLICATE SPLAY 7 7a 3.73 254.43 80.33 7 7b 0.54 182.41 -84.02 7 7c 2.55 328.39 -82.67 7 7d 5.00 156.87 13.29 7 7e 0.41 231.77 -3.06 *FLAGS NOT DUPLICATE NOT SPLAY 7 8 3.19 303.08 -33.11 *FLAGS SPLAY 8 8a 4.46 353.35 80.60 8 8b 1.45 224.40 -78.95 8 8c 3.21 123.01 33.05 8 8d 0.53 23.07 -5.56 8 8e 1.87 72.08 1.35 *FLAGS NOT SPLAY 8 9 6.71 295.69 -12.15 *FLAGS SPLAY 9 9a 1.16 244.84 81.25 9 9b 1.09 201.63 -76.54 9 9c 6.72 115.55 11.83 9 9d 0.56 196.48 2.10 9 9e 3.56 117.58 -4.92 *FLAGS NOT SPLAY 9 10 1.11 265.93 2.35 *END ShortDryWay *END Swildons CaveConverter_src/test/data/regression/2649_Mares_fromaven_in.dxf0000644000000000000000000001154211267320242024064 0ustar rootroot0 SECTION 2 HEADER 9 $EXTMIN 10 -45.275000 20 -23.640000 30 -6.135000 9 $EXTMAX 10 45.275000 20 23.640000 30 6.135000 9 $PDMODE 70 3 9 $PDSIZE 40 0.80 0 ENDSEC 0 SECTION 2 TABLES 0 TABLE 2 LTYPE 70 10 0 LTYPE 2 CONTINUOUS 70 64 3 Continuous 72 65 73 0 40 0.0 0 LTYPE 2 DASHED 70 64 3 Dashed 72 65 73 2 40 2.5 49 1.25 49 -1.25 0 ENDTAB 0 TABLE 2 LAYER 70 10 0 LAYER 2 CentreLine 70 64 62 5 6 CONTINUOUS 0 LAYER 2 Stations 70 64 62 7 6 CONTINUOUS 0 LAYER 2 Labels 70 64 62 7 6 CONTINUOUS 0 LAYER 2 Surface 70 64 62 5 6 DASHED 0 LAYER 2 SurfaceStations 70 64 62 7 6 CONTINUOUS 0 LAYER 2 SurfaceLabels 70 64 62 7 6 CONTINUOUS 0 ENDTAB 0 ENDSEC 0 SECTION 2 ENTITIES 0 LINE 8 CentreLine 10 -45.28 20 -18.77 30 6.13 11 -44.57 21 -19.70 31 4.88 0 LINE 8 CentreLine 10 -44.57 20 -19.70 30 4.88 11 -44.88 21 -17.83 31 2.69 0 LINE 8 CentreLine 10 -44.88 20 -17.83 30 2.69 11 -44.88 21 -17.83 31 -1.54 0 LINE 8 CentreLine 10 -44.88 20 -17.83 30 -1.54 11 -40.10 21 -18.73 31 -0.59 0 LINE 8 CentreLine 10 -40.10 20 -18.73 30 -0.59 11 -38.54 21 -18.15 31 0.81 0 LINE 8 CentreLine 10 -38.54 20 -18.15 30 0.81 11 -36.51 21 -18.43 31 -0.63 0 LINE 8 CentreLine 10 -36.51 20 -18.43 30 -0.63 11 -40.83 21 -23.64 31 -1.94 0 LINE 8 CentreLine 10 -36.51 20 -18.43 30 -0.63 11 -33.93 21 -17.27 31 0.33 0 LINE 8 CentreLine 10 -33.93 20 -17.27 30 0.33 11 -31.08 21 -18.18 31 0.24 0 LINE 8 CentreLine 10 -31.08 20 -18.18 30 0.24 11 -28.56 21 -18.44 31 -0.25 0 LINE 8 CentreLine 10 -28.56 20 -18.44 30 -0.25 11 -28.56 21 -18.44 31 -5.06 0 LINE 8 CentreLine 10 -28.56 20 -18.44 30 -0.25 11 -25.47 21 -15.42 31 -1.10 0 LINE 8 CentreLine 10 -25.47 20 -15.42 30 -1.10 11 -24.96 21 -13.82 31 -2.67 0 LINE 8 CentreLine 10 -24.96 20 -13.82 30 -2.67 11 -19.53 21 -8.89 31 -3.18 0 LINE 8 CentreLine 10 -19.53 20 -8.89 30 -3.18 11 -15.57 21 -2.73 31 -3.82 0 LINE 8 CentreLine 10 -15.57 20 -2.73 30 -3.82 11 -14.04 21 0.94 31 -2.82 0 LINE 8 CentreLine 10 -14.04 20 0.94 30 -2.82 11 -8.49 21 2.88 31 -3.35 0 LINE 8 CentreLine 10 -8.49 20 2.88 30 -3.35 11 -4.83 21 9.30 31 -3.73 0 LINE 8 CentreLine 10 -4.83 20 9.30 30 -3.73 11 -0.73 21 13.16 31 -4.03 0 LINE 8 CentreLine 10 -0.73 20 13.16 30 -4.03 11 2.98 21 11.97 31 -4.30 0 LINE 8 CentreLine 10 2.98 20 11.97 30 -4.30 11 6.97 21 12.48 31 -4.16 0 LINE 8 CentreLine 10 6.97 20 12.48 30 -4.16 11 8.72 21 14.91 31 -4.31 0 LINE 8 CentreLine 10 8.72 20 14.91 30 -4.31 11 10.45 21 12.17 31 -4.94 0 LINE 8 CentreLine 10 10.45 20 12.17 30 -4.94 11 16.97 21 11.40 31 -4.94 0 LINE 8 CentreLine 10 16.97 20 11.40 30 -4.94 11 16.98 21 9.59 31 -4.85 0 LINE 8 CentreLine 10 16.98 20 9.59 30 -4.85 11 17.80 21 11.29 31 -4.62 0 LINE 8 CentreLine 10 16.98 20 9.59 30 -4.85 11 16.19 21 7.37 31 -4.00 0 LINE 8 CentreLine 10 16.97 20 11.40 30 -4.94 11 19.95 21 11.46 31 -4.60 0 LINE 8 CentreLine 10 19.95 20 11.46 30 -4.60 11 20.86 21 14.22 31 -4.42 0 LINE 8 CentreLine 10 20.86 20 14.22 30 -4.42 11 22.11 21 18.13 31 -4.57 0 LINE 8 CentreLine 10 22.11 20 18.13 30 -4.57 11 21.07 21 19.86 31 -4.41 0 LINE 8 CentreLine 10 21.07 20 19.86 30 -4.41 11 21.94 21 21.57 31 -5.88 0 LINE 8 CentreLine 10 21.07 20 19.86 30 -4.41 11 22.76 21 20.76 31 -4.61 0 LINE 8 CentreLine 10 22.76 20 20.76 30 -4.61 11 24.43 21 23.64 31 -4.86 0 LINE 8 CentreLine 10 22.76 20 20.76 30 -4.61 11 30.71 21 18.94 31 -4.81 0 LINE 8 CentreLine 10 30.71 20 18.94 30 -4.81 11 31.92 21 17.64 31 -4.66 0 LINE 8 CentreLine 10 31.92 20 17.64 30 -4.66 11 34.58 21 17.23 31 -4.64 0 LINE 8 CentreLine 10 34.58 20 17.23 30 -4.64 11 38.41 21 19.98 31 -4.95 0 LINE 8 CentreLine 10 38.41 20 19.98 30 -4.95 11 39.57 21 20.46 31 -5.06 0 LINE 8 CentreLine 10 39.57 20 20.46 30 -5.06 11 42.32 21 19.43 31 -5.25 0 LINE 8 CentreLine 10 39.57 20 20.46 30 -5.06 11 42.40 21 17.71 31 -4.79 0 LINE 8 CentreLine 10 42.40 20 17.71 30 -4.79 11 43.59 21 18.21 31 -5.43 0 LINE 8 CentreLine 10 43.59 20 18.21 30 -5.43 11 45.27 21 16.81 31 -6.13 000 ENDSEC 000 EOF CaveConverter_src/test/data/regression/Stomps_ps_ref.svx0000644000000000000000000002377112226751562022650 0ustar rootroot*BEGIN Stomps2010 *EQUATE 155.1 156.1 *EQUATE 156.9 127.0 *BEGIN 156 *DATE 2010.08.11 *CALIBRATE declination 1.92 *EQUATE 28 32 *FLAGS SPLAY 1 1a 1.68 37.77 8.97 1 1b 9.67 232.64 2.24 1 1c 3.12 97.12 86.67 1 1d 0.74 77.17 -89.50 1 1e 15.03 226.71 -13.08 1 1f 6.82 210.56 28.68 *FLAGS NOT SPLAY 1 2 9.08 189.31 -7.43 *FLAGS SPLAY 2 2a 7.47 208.36 -11.11 2 2b 8.06 39.11 14.74 2 2c 4.41 128.49 81.69 2 2d 1.26 358.86 -82.11 *FLAGS NOT SPLAY 2 3 18.55 116.98 -0.10 *FLAGS SPLAY 3 3a 2.10 353.60 5.03 3 3b 8.88 190.22 4.19 3 3c 3.69 137.39 81.12 3 3d 1.65 101.41 -87.20 *FLAGS NOT SPLAY 3 4 3.94 109.34 5.39 *FLAGS SPLAY 4 4a 1.72 13.50 -2.13 4 4b 5.78 180.90 3.13 4 4c 3.62 131.58 82.07 4 4d 1.77 11.41 -89.12 *FLAGS NOT SPLAY 4 5 14.13 96.76 -0.61 *FLAGS SPLAY 5 5a 0.89 21.68 11.66 5 5b 4.92 187.59 1.55 5 5c 3.34 152.86 86.38 5 5d 1.68 93.35 -86.43 5 5e 10.70 195.39 -17.40 *FLAGS NOT SPLAY 5 6 14.76 107.42 10.11 *FLAGS SPLAY 6 6a 2.77 353.39 1.57 6 6b 6.30 194.68 -4.39 6 6c 1.21 240.65 80.78 6 6d 2.02 357.90 -83.47 *FLAGS NOT SPLAY 6 7 9.56 79.43 -2.48 *FLAGS SPLAY 7 7a 12.22 207.03 2.29 7 7b 1.68 97.50 85.86 7 7c 1.71 241.95 -86.22 *FLAGS NOT SPLAY 7 8 12.97 128.55 -9.80 *FLAGS SPLAY 8 8a 5.12 354.01 2.57 8 8b 5.91 181.07 -1.30 8 8c 5.02 174.58 84.02 8 8d 1.51 132.53 -81.84 8 8e 13.39 235.87 7.15 8 8f 4.13 271.01 46.40 *FLAGS NOT SPLAY 8 9 5.84 89.36 1.83 *FLAGS SPLAY 9 9a 4.62 19.88 -7.87 9 9b 14.51 183.22 24.27 9 9c 4.47 145.46 80.50 *FLAGS NOT SPLAY 9 10 11.81 117.66 18.69 *FLAGS SPLAY 10 10a 5.38 40.87 -12.73 10 10b 15.76 211.64 3.96 10 10c 2.39 262.28 85.82 10 10d 8.08 203.51 -24.97 *FLAGS NOT SPLAY 10 11 17.53 168.45 -7.51 *FLAGS SPLAY 11 11a 11.16 40.65 22.54 11 11b 5.81 202.33 -0.42 11 11c 4.42 170.80 84.77 11 11d 2.04 127.28 -88.53 *FLAGS NOT SPLAY 11 12 16.73 148.86 -11.30 *FLAGS SPLAY 12 12a 10.78 54.37 20.06 12 12b 2.98 221.85 -4.24 12 12c 5.15 185.63 84.72 12 12d 2.27 188.16 -80.50 *FLAGS NOT SPLAY 12 13 15.14 118.78 -5.89 *FLAGS SPLAY 13 13a 1.67 61.44 5.64 13 13b 7.80 233.20 3.15 13 13c 6.12 304.49 0.88 13 13d 3.61 348.94 1.85 13 13e 5.07 331.32 -2.18 13 13f 6.90 69.83 84.81 13 13g 0.44 268.26 -88.34 *FLAGS NOT SPLAY 13 14 12.56 158.08 3.43 *FLAGS SPLAY 14 14a 3.84 53.87 -4.42 14 14b 3.12 227.31 2.93 14 14c 5.53 300.37 87.43 14 14d 1.63 169.51 -86.65 *FLAGS NOT SPLAY 14 15 20.99 142.22 1.02 *FLAGS SPLAY 15 15a 3.37 59.85 -7.03 15 15b 6.88 228.82 -1.60 15 15c 1.81 165.82 -81.12 15 15d 7.31 156.10 87.72 *FLAGS NOT SPLAY 15 16 14.28 159.69 1.84 *FLAGS SPLAY 16 16a 3.99 50.15 5.15 16 16b 6.30 223.94 0.27 16 16c 6.76 212.56 82.75 16 16d 2.16 75.37 -85.02 16 16e 7.35 53.81 -19.26 *FLAGS NOT SPLAY 16 17 10.37 162.98 2.49 *FLAGS SPLAY 17 17a 8.03 85.24 5.30 17 17b 4.58 268.81 4.80 17 17c 7.08 117.31 85.78 17 17d 1.67 30.75 -87.87 17 17e 11.57 65.79 -12.79 *FLAGS NOT SPLAY 17 18 7.85 126.63 -11.48 *FLAGS SPLAY 18 18a 9.04 57.55 -6.54 18 18b 12.85 221.83 12.63 18 18c 5.78 227.99 82.52 18 18d 1.20 269.82 -79.45 18 18e 9.67 145.31 -10.88 18 18f 10.53 166.40 -10.22 18 18g 8.33 104.33 -11.12 *FLAGS NOT SPLAY 18 19 23.70 157.35 -4.37 *FLAGS SPLAY 19 19a 9.34 73.19 10.78 19 19b 11.84 245.81 12.69 19 19c 1.17 287.39 83.26 19 19d 2.42 51.41 38.56 *FLAGS NOT SPLAY 19 20 13.16 101.93 26.51 *FLAGS SPLAY 20 20a 8.13 59.17 2.11 20 20b 3.99 319.43 -1.32 20 20c 19.28 269.18 2.35 20 20d 21.11 255.42 1.62 20 20e 9.96 233.12 -18.11 20 20f 1.90 168.29 81.35 20 20g 12.67 132.37 13.97 *FLAGS NOT SPLAY 20 21 14.46 145.32 8.27 *FLAGS SPLAY 21 21a 14.26 78.44 8.06 21 21b 3.68 250.66 -18.99 21 21c 7.18 227.58 -16.64 21 21d 12.39 206.43 -26.43 21 21e 16.36 186.99 -21.04 21 21f 17.98 167.17 -10.43 21 21g 21.27 136.38 4.37 21 21h 18.97 113.75 8.27 21 21i 1.58 137.96 69.16 21 21j 0.84 62.80 -88.10 21 21k 9.40 19.51 12.23 *FLAGS NOT SPLAY 21 22 11.00 140.41 13.34 *FLAGS SPLAY 22 22a 18.00 237.95 -37.04 22 22b 12.64 198.26 -39.64 22 22c 15.78 148.75 -25.36 22 22d 16.36 126.26 -16.70 22 22e 11.77 93.31 -5.76 22 22f 13.48 67.73 -1.47 22 22g 13.79 35.24 -1.65 *FLAGS NOT SPLAY 22 23 19.39 47.07 -3.39 *FLAGS SPLAY 23 23a 7.24 83.01 -21.44 23 23b 8.47 183.50 1.18 23 23c 10.48 171.25 -0.49 23 23d 7.11 147.60 -3.96 *FLAGS NOT SPLAY 23 24 12.26 182.57 0.88 *FLAGS SPLAY 24 24a 1.92 82.91 0.63 24 24b 1.15 120.51 84.75 24 24c 0.92 76.07 -84.15 *FLAGS NOT SPLAY 24 25 9.37 136.99 -31.89 *FLAGS SPLAY 25 25a 1.16 119.38 3.47 25 25b 2.94 355.15 23.42 25 25c 3.69 310.01 86.34 25 25d 0.33 193.17 -87.50 *FLAGS NOT SPLAY 25 26 16.12 66.28 8.82 *FLAGS SPLAY 26 26a 4.09 231.84 0.23 26 26b 1.48 42.67 87.21 26 26c 0.60 329.87 -86.96 *FLAGS NOT SPLAY 26 27 20.53 208.25 -0.25 *FLAGS SPLAY 27 27a 1.97 300.95 -6.53 27 27b 3.70 311.97 80.68 27 27c 1.85 292.76 -79.95 *FLAGS NOT SPLAY 27 28 23.08 217.47 -11.66 *FLAGS SPLAY 28 28a 2.88 128.79 -0.08 28 28b 6.22 310.56 2.64 28 28c 8.32 349.65 84.55 28 28d 28.39 23.01 54.31 28 28e 13.96 7.70 59.65 28 28f 12.78 4.70 10.78 28 28g 8.89 49.16 13.35 *FLAGS NOT SPLAY 28 29 9.44 337.56 -7.14 *FLAGS SPLAY 29 29a 2.88 283.39 -6.23 29 29b 10.43 124.26 14.34 29 29c 0.85 25.33 78.60 29 29d 1.76 324.20 -83.85 *FLAGS NOT SPLAY 29 30 11.12 26.64 -1.45 *FLAGS SPLAY 30 30a 4.37 251.83 1.05 30 30b 8.10 252.77 -8.28 30 30c 13.30 274.36 -5.31 30 30d 5.94 168.28 4.29 30 30e 3.36 125.62 9.29 30 30f 11.33 60.91 17.00 30 30g 6.48 357.65 15.32 *FLAGS NOT SPLAY 30 31 7.38 59.13 18.23 *FLAGS SPLAY 31 31a 6.38 284.87 4.02 31 31b 3.28 81.68 10.06 31 31c 1.65 268.12 86.30 31 31d 0.81 305.44 -85.22 *FLAGS NOT SPLAY 31 25 7.67 9.40 10.35 *FLAGS SPLAY 32 32a 2.87 117.70 -1.62 32 32b 6.26 302.62 9.50 32 32c 7.77 227.86 81.72 32 32d 1.77 169.28 -67.64 *FLAGS NOT SPLAY 32 33 26.57 219.45 -1.21 *FLAGS SPLAY 33 33a 2.53 307.33 4.40 33 33b 3.36 124.91 2.33 33 33c 5.20 170.50 89.34 33 33d 3.24 328.02 -70.36 33 33e 6.56 290.15 -24.69 *FLAGS NOT SPLAY 33 34 30.49 226.77 -3.52 *FLAGS SPLAY 34 34a 5.86 236.75 -3.69 34 34b 4.04 262.63 -3.89 34 34c 8.40 95.41 4.69 34 34d 9.61 62.57 84.14 34 34e 1.35 158.37 -84.56 *FLAGS NOT SPLAY 34 35 24.02 125.74 -0.07 *FLAGS SPLAY 35 35a 2.68 30.69 -5.75 35 35b 2.81 197.88 -14.73 35 35c 0.73 66.43 86.00 35 35d 1.58 127.05 -83.96 *FLAGS NOT SPLAY 35 36 4.42 104.65 6.02 *FLAGS SPLAY 36 36a 2.49 21.29 -22.90 36 36b 2.24 260.57 -1.29 36 36c 5.82 217.21 86.87 36 36d 1.89 140.80 -83.24 36 36e 9.41 213.65 -13.20 *FLAGS NOT SPLAY 36 37 10.68 164.02 12.16 *FLAGS SPLAY 37 37a 3.80 53.48 -4.48 37 37b 6.19 229.59 9.87 37 37c 6.08 146.27 82.26 37 37d 8.28 10.38 -30.58 *FLAGS NOT SPLAY 37 38 12.55 153.02 -2.14 *FLAGS SPLAY 38 38a 2.42 41.61 -6.10 38 38b 10.27 228.39 1.96 38 38c 6.31 200.74 84.49 38 38d 5.42 81.95 -50.82 *FLAGS NOT SPLAY 38 39 26.21 114.84 -7.27 *FLAGS SPLAY 39 39a 3.40 52.39 6.37 39 39b 20.50 219.16 10.44 39 39c 13.28 207.48 46.99 39 39d 9.50 182.35 -22.41 *FLAGS NOT SPLAY 39 40 26.69 165.92 -1.74 *FLAGS SPLAY 40 40a 8.67 60.90 12.75 40 40b 15.33 247.49 12.29 40 40c 10.78 304.71 85.18 40 40d 2.29 6.12 -84.82 *FLAGS NOT SPLAY 40 41 29.35 157.64 4.26 *FLAGS SPLAY 41 41a 10.62 252.68 11.74 41 41b 12.75 22.64 8.50 41 41c 7.88 18.58 78.68 41 41d 22.88 13.29 8.03 41 41e 12.85 343.23 -24.55 *FLAGS NOT SPLAY 41 42 25.13 123.62 -2.35 *FLAGS SPLAY 42 42a 4.46 66.37 20.49 42 42b 21.37 242.80 10.60 42 42c 10.42 232.44 63.69 42 42d 7.43 221.79 -41.05 42 42e 13.88 308.37 1.63 *FLAGS NOT SPLAY 42 43 24.15 168.91 -8.72 *FLAGS SPLAY 43 43a 14.40 256.04 21.06 43 43b 10.07 101.29 29.82 43 43c 12.51 150.27 86.71 43 43d 2.00 248.22 -77.51 *FLAGS NOT SPLAY 43 44 13.32 168.35 10.48 *FLAGS SPLAY 44 44a 4.83 75.77 6.03 44 44b 18.29 275.87 11.43 44 44c 10.21 26.26 77.78 44 44d 7.37 297.13 -41.78 44 44e 6.22 274.92 -17.88 *FLAGS NOT SPLAY 44 45 28.90 189.31 16.45 *FLAGS SPLAY 45 45a 10.63 135.54 9.88 45 45b 9.58 280.49 -1.90 45 45c 3.41 209.50 87.61 45 45d 4.30 270.17 -67.62 *FLAGS NOT SPLAY 45 46 22.48 194.04 5.14 *FLAGS SPLAY 46 46a 14.53 63.91 5.51 46 46b 6.66 255.94 -22.06 46 46c 1.68 238.04 77.50 46 46d 12.99 117.87 8.99 *FLAGS NOT SPLAY *data passage station left right up down 1 0.79 8.89 3.11 0.74 2 7.12 6.02 4.36 1.24 3 1.82 8.64 3.64 1.64 4 1.71 5.64 3.59 1.77 5 0.86 10.19 3.34 1.68 6 2.73 6.16 1.19 2.01 7 0.00 11.90 1.67 1.71 8 4.63 10.62 4.99 1.50 9 4.55 13.02 4.41 0.00 10 5.13 14.63 2.38 3.41 11 9.10 4.01 4.40 2.04 12 9.95 2.97 5.13 2.24 13 1.83 7.76 6.87 0.44 14 3.81 3.04 5.52 1.62 15 3.34 6.72 7.30 1.78 16 6.61 5.60 6.70 2.15 17 11.08 3.78 7.06 1.67 18 8.94 12.34 5.73 1.18 19 7.65 10.37 1.16 0.00 20 7.33 15.73 1.88 0.00 21 12.73 10.63 1.48 0.84 22 11.75 11.68 0.00 8.06 23 3.55 7.89 0.00 2.65 24 1.87 0.00 1.15 0.92 25 1.83 1.14 3.68 0.33 26 0.00 4.07 1.48 0.60 27 0.00 1.96 3.65 1.82 28 1.49 15.96 8.28 0.00 29 2.81 8.55 0.83 1.75 30 10.36 4.83 0.00 0.00 31 6.00 2.38 1.65 0.81 25 1.83 1.14 3.68 0.33 *data passage station left right up down 32 2.81 6.13 7.69 1.64 33 3.32 5.49 5.20 3.05 34 8.27 5.09 9.56 1.34 35 2.66 2.70 0.73 1.57 36 2.11 9.00 5.81 1.88 37 3.76 5.77 6.02 4.21 38 2.70 10.23 6.28 4.20 39 3.37 19.77 9.71 3.62 40 8.30 14.94 10.74 2.28 41 18.01 9.64 7.73 5.34 42 4.11 20.87 9.34 4.88 43 8.06 13.42 12.49 1.95 44 4.68 17.79 9.98 4.91 45 8.70 9.57 3.41 3.98 46 12.46 5.44 1.65 2.50 *END 156 *END Stomps2010 CaveConverter_src/test/data/regression/SwilEnt_in.svx0000644000000000000000000014006112227510604022057 0ustar rootroot*BEGIN Swildons *ENTRANCE Ent ;*FIX Ent 53122.3 51308.5 237.3 ;From surface survey using two GPS fixes nearby under open clear sky *EQUATE Ent EntranceZigZags.3 *EQUATE surfacegps.4 EntranceZigZags.3 *EQUATE EntranceZigZags.5 LongDryWay.0 *EQUATE LongDryWay.5 EntranceZigZags.21 *EQUATE LongDryWay.5 ShortDryWay.pt1.0 *EQUATE LongDryWay.39 NewGrottoes.0 *EQUATE LongDryWay.62 OldGrotto2WC.4 *EQUATE LongDryWay.59 OldGrotto2WC.0 *EQUATE LongDryWay.59 ShortDryWay.pt2.3 *EQUATE OldGrotto2WC.11 WaterRift.0 *EQUATE WaterRift.4 FortyRoute.0 *EQUATE WaterRift.12 FortyRoute.11 *EQUATE LongDryWay.8 10.0 *EQUATE 10.20 LongDryWay.2 *EQUATE 10.13 20.20 *EQUATE 10.18 20.27 *EQUATE EntranceZigZags.5 20.0 *EQUATE 20.23 ShortDryWay.pt1.3 *EQUATE 20.19 EntranceZigZags.5 *BEGIN surfacegps ;Not using blockhouse fix as GPS under trees not great. Loop error between other ;two better GPS fixes is 2.56m. These two fixes average the position of the grating ;inside the blockhouse at 53122.3 51308.5 237.3 ;Surface GPS tie in for entrance using good WAAS GPS fixes ;WSCC DistoX-Footleg *DATE 2013.06.30 *CALIBRATE declination +1.58 *FIX 0 53094 51306 245 ;WAAS fix with good clear sky view of 8 satellites *FIX 7 53119 51282 245 ;WAAS fix with good clear sky view of 8 satellites *FLAGS SURFACE 0 1 9.84 94.37 -5.88 ;stn0=left hand gate post as seen from cave entrance. GPS fixed 1 2 7.84 97.65 -8.05 2 3 11.76 94.27 -17.67 3 4 4.38 7.38 -23.29 ;stn4=rh front corner of entrance grating in blockhouse 3 5 5.45 262.93 13.06 5 6 8.80 174.95 11.61 6 7 13.78 168.31 12.55 ;stn7=2nd fence post from corner. Taller of the two fences. GPS fixed. *END surfacegps *BEGIN EntranceZigZags *DATE 2012.09.09 *CALIBRATE declination +1.70 *FLAGS SURFACE 0 1 2.98 10.26 -2.01 ;1 has magnetic problems. So surveyed to it from knot on tree opposite door=1.0 Then from knot to rear wall of blockhouse 1.0-1.2 0 2 5.24 3.23 -5.04 ;2=rawl plug on rear wall of blockhouse *FLAGS SPLAY 2 2a 5.24 182.16 5.06 2 2b 1.89 187.97 3.09 2 2c 1.91 168.82 1.18 2 2d 1.38 218.59 -0.17 2 2e 0.64 248.05 1.54 2 2f 0.68 105.32 -3.30 2 2g 1.56 140.40 -2.98 2 2h 1.84 176.52 -47.48 2 2i 1.82 167.81 -47.93 2 2j 1.54 189.90 -63.97 2 2k 1.61 132.31 -59.62 *FLAGS NOT SPLAY 2 3 2.64 166.70 -60.11 ;3=Top left corner of stream culvert when looking out of cave *FLAGS NOT SURFACE *FLAGS SPLAY 3 3a 0.22 345.81 60.30 3 3b 2.63 347.89 60.51 3 3c 0.94 9.90 76.67 3 3d 0.31 232.08 12.34 3 3e 0.35 31.05 10.29 3 3f 0.47 8.50 -70.77 *FLAGS NOT SPLAY 3 4 3.10 330.76 -25.13 *FLAGS SPLAY 4 4a 3.12 152.39 25.35 4 4b 0.56 208.59 -0.68 4 4c 0.59 140.67 80.22 4 4d 1.32 189.06 -86.08 4 4e 1.50 43.79 87.42 *FLAGS NOT SPLAY 4 5 4.51 275.80 -12.10 ;5=polished tip of pointy boulder by top of drop into lower level of chamber. Boulder is dark grey with white flecks and fossils. *FLAGS SPLAY 5 5a 4.51 94.74 12.12 5 5b 3.45 123.81 5.64 5 5c 3.51 134.15 0.14 5 5d 6.66 129.46 11.11 5 5e 2.32 149.61 -6.69 5 5f 1.64 153.47 -11.17 5 5g 0.79 252.58 -12.22 5 5h 1.22 296.10 -7.82 5 5i 2.96 296.71 -23.02 5 5j 1.51 42.54 10.51 5 5k 4.24 72.82 11.85 5 5l 0.70 333.90 81.49 5 5m 0.55 114.68 -67.13 *FLAGS NOT SPLAY 5 6 2.41 50.67 -22.33 *FLAGS SPLAY 6 6a 2.38 230.76 22.40 6 6b 0.35 2.58 81.25 6 6c 0.30 220.39 -79.38 6 6d 0.51 299.09 -0.90 6 6e 0.21 108.28 1.25 *FLAGS NOT SPLAY 6 7 1.08 37.30 11.53 *FLAGS SPLAY 7 7a 1.09 217.24 -12.21 7 7b 0.80 327.16 66.53 7 7c 4.12 176.11 -83.10 7 7d 0.72 287.69 -77.51 7 7e 0.60 292.40 -18.76 7 7f 2.02 100.10 16.73 *FLAGS NOT SPLAY 7 8 2.00 6.10 11.51 *FLAGS SPLAY 8 8a 2.00 184.82 -11.17 8 8b 1.47 98.32 -7.52 8 8c 0.19 105.24 52.84 8 8d 1.24 102.22 -61.02 8 8e 0.88 109.39 0.40 *FLAGS NOT SPLAY 8 9 1.01 56.60 0.18 ;9=bottom point of sharp vertical edge of boulder forming ceiling *FLAGS SPLAY 9 9a 1.02 236.71 -0.46 9 9b 0.48 12.78 64.51 9 9c 0.60 279.77 -8.53 9 9d 0.47 275.64 -73.34 ;9 9e 3.54 74.99 6.08 *FLAGS NOT SPLAY 9 10 3.07 336.52 5.81 ;10=bottom of cream calcite rib running down RH wall *FLAGS SPLAY 10 10a 3.08 156.19 -6.26 10 10b 0.58 232.61 -1.43 10 10c 1.31 64.76 -58.36 10 10d 1.43 101.23 -11.90 10 10e 1.14 78.33 -36.92 *FLAGS NOT SPLAY 9 11 2.42 64.64 5.29 *FLAGS SPLAY 11 11a 2.42 245.35 -5.41 11 11b 0.44 233.11 24.20 11 11c 0.20 42.71 -21.97 11 11d 0.45 239.67 46.05 11 11e 0.49 178.37 -53.68 11 11f 3.30 118.39 17.88 *FLAGS NOT SPLAY 11 12 4.50 106.56 19.29 *FLAGS SPLAY 12 12a 0.25 297.10 84.93 12 12b 0.26 127.16 -84.07 12 12c 0.60 197.87 18.66 12 12d 1.17 327.17 -9.65 12 12e 1.63 13.18 -2.28 12 12f 1.86 96.76 12.16 10 10f 3.76 209.97 51.34 *FLAGS NOT SPLAY 10 13 0.94 80.55 -45.63 *FLAGS SPLAY 13 13a 0.94 259.78 45.32 13 13b 0.84 97.15 56.57 13 13c 1.16 144.82 14.01 13 13d 0.48 130.78 -25.41 13 13e 0.58 324.87 25.54 *FLAGS NOT SPLAY 13 14 5.31 65.16 19.50 *FLAGS SPLAY 14 14a 5.82 246.22 -19.66 14 14b 0.64 206.92 -10.28 14 14c 0.54 185.33 -53.51 14 14d 0.21 279.32 69.67 14 14e 2.09 161.86 8.15 14 14f 0.85 285.98 -13.42 *FLAGS NOT SPLAY 10 15 3.27 329.15 -18.16 *FLAGS SPLAY 15 15a 3.25 149.02 17.88 15 15b 0.77 63.28 -13.22 15 15c 0.70 243.58 79.61 15 15d 0.80 97.26 -82.81 15 15e 2.37 233.98 -23.81 15 15f 0.94 168.26 10.56 *FLAGS NOT SPLAY 15 16 3.57 334.08 -6.33 *FLAGS SPLAY 16 16a 3.58 154.40 6.43 16 16b 0.29 52.63 -10.96 16 16c 0.70 63.17 -62.51 16 16d 0.73 221.54 2.28 16 16e 1.82 250.10 55.64 16 16f 0.86 237.55 47.64 16 16g 0.86 195.09 5.98 *FLAGS NOT SPLAY 16 17 2.41 207.98 -9.43 *FLAGS SPLAY 17 17a 2.40 28.72 9.44 17 17b 1.55 24.59 -70.16 17 17c 1.33 336.78 -9.34 17 17d 0.48 26.59 -33.63 17 17e 0.66 83.59 13.58 17 17f 1.67 193.75 -23.62 *FLAGS NOT SPLAY 17 18 4.05 308.01 -19.25 *FLAGS SPLAY 18 18a 4.05 128.34 19.12 18 18b 1.54 155.56 12.30 18 18c 0.60 300.02 2.80 18 18d 0.28 261.46 65.07 18 18e 0.68 182.87 -85.38 *FLAGS NOT SPLAY 18 19 2.06 211.48 -16.06 *FLAGS SPLAY 19 19a 2.04 31.72 16.13 19 19b 0.55 320.99 71.97 19 19c 1.54 308.22 -85.39 19 19d 0.46 306.67 -13.63 *FLAGS NOT SPLAY 19 20 2.94 233.55 -35.84 *FLAGS SPLAY 20 20a 2.95 53.57 35.69 20 20b 0.98 64.26 12.43 20 20c 0.93 44.01 13.78 20 20d 1.56 84.07 80.29 20 20e 1.62 301.40 -84.42 *FLAGS NOT SPLAY 20 21 2.04 14.57 -39.09 ;21= 25cm tall stumpy stalagmite on floor to left of top of Jacob's Ladder. Stn is centre of flat ring on top. *FLAGS SPLAY 21 21a 2.04 195.35 38.69 21 21b 1.80 235.96 12.16 21 21c 0.21 339.46 -76.92 21 21d 0.34 53.17 3.81 21 21e 3.17 230.10 64.31 *FLAGS NOT SPLAY *data passage station left right up down 3 0.09 0.11 0.91 0.44 4 0.56 0.00 1.49 1.31 5 1.98 4.15 0.69 0.50 6 0.49 0.19 0.35 0.29 7 0.57 1.90 0.73 4.09 8 0.00 1.34 0.15 1.09 9 0.59 3.00 0.43 0.45 10 1.97 1.09 2.93 1.11 *data passage station left right up down 9 0.38 0.87 0.43 0.45 11 0.13 1.70 0.33 0.40 12 1.63 0.57 0.25 0.26 *data passage station left right up down 10 0.54 2.34 2.93 1.11 13 0.50 1.07 0.70 0.21 14 0.54 2.05 0.20 0.44 *data passage station left right up down 10 1.97 1.09 2.93 1.11 15 2.15 0.75 0.68 0.80 16 0.83 0.18 1.51 0.62 17 1.38 1.29 0.00 1.46 18 1.46 0.38 0.25 0.68 19 0.00 0.45 0.53 1.54 20 0.00 0.89 1.53 1.62 21 1.16 0.21 2.86 0.21 *END EntranceZigZags *BEGIN LongDryWay ;Badger, Cave Ferret, Footleg *DATE 2013.02.23 *CALIBRATE declination +1.63 *EQUATE 44 46 *FLAGS SPLAY 0 0a 0.57 190.50 0.73 0 0b 0.67 258.82 80.80 0 0c 1.35 2.03 3.08 0 0d 0.56 96.94 -85.13 0 0e 4.05 271.96 -24.99 0 0f 4.25 271.79 -25.07 *FLAGS NOT SPLAY 0 1 4.08 270.72 -25.50 *FLAGS SPLAY 1 1a 1.99 51.56 -3.25 1 1b 0.46 105.97 80.16 1 1c 1.51 94.64 -80.82 1 1d 4.22 97.98 -2.77 1 1e 3.40 122.23 -12.40 1 1f 3.13 150.51 -15.80 1 1g 6.66 142.47 -10.55 *FLAGS NOT SPLAY 1 2 3.77 354.35 -29.81 ;2=bottom tip of point of flowstone on RH wall looking into cave. Two tone calcite point. *FLAGS SPLAY 2 2a 0.66 241.86 -8.20 2 2b 1.94 85.48 -81.67 2 2c 0.59 61.84 0.46 2 2d 0.74 236.38 81.47 2 2e 1.67 66.88 -56.31 2 2f 1.30 149.63 -32.25 *FLAGS NOT SPLAY 2 3 4.33 336.10 -24.79 *FLAGS SPLAY 3 3a 1.20 273.33 77.00 3 3b 0.46 54.65 1.29 3 3c 0.19 248.98 6.64 3 3d 0.49 67.19 -81.38 3 3e 0.44 244.00 2.33 *FLAGS NOT SPLAY 3 4 2.77 337.70 -4.41 *FLAGS SPLAY 4 4a 1.44 45.43 -70.35 4 4b 0.50 246.88 -7.75 4 4c 2.23 271.73 60.68 *FLAGS NOT SPLAY 4 5 3.14 343.71 -25.59 *FLAGS SPLAY 5 5a 0.31 68.00 4.55 5 5b 0.23 200.44 -82.34 5 5c 3.01 212.74 65.59 5 5d 1.83 228.77 1.96 5 5e 2.24 149.67 -4.84 5 5f 1.07 119.80 -19.64 *FLAGS NOT SPLAY 5 6 1.87 332.43 6.50 *FLAGS SPLAY 6 6a 0.33 85.05 2.16 6 6b 0.81 234.74 4.03 6 6c 0.46 76.22 -85.16 6 6d 1.31 224.58 20.79 6 6e 2.65 233.44 69.74 *FLAGS NOT SPLAY 6 7 2.26 343.32 -5.29 *FLAGS SPLAY 7 7a 0.51 89.65 -82.84 7 7b 0.44 225.38 -8.27 7 7c 1.81 226.26 51.07 *FLAGS NOT SPLAY 7 8 1.72 258.62 12.28 ;8=centre top of rounded stumpy stalagmite on wall at junction 0.82m off floor *FLAGS SPLAY 8 8a 0.79 122.45 -3.92 8 8b 0.82 125.25 -80.01 8 8c 1.02 113.36 59.45 *FLAGS NOT SPLAY 7 9 1.10 310.47 4.46 *FLAGS SPLAY 9 9a 0.57 99.03 -87.47 9 9b 0.90 250.68 3.72 9 9c 0.88 233.37 70.96 9 9d 0.60 60.03 -19.66 *FLAGS NOT SPLAY 9 10 2.37 334.59 4.19 *FLAGS SPLAY 10 10a 0.26 51.75 0.96 10 10b 0.43 43.34 -88.13 10 10c 0.44 235.87 0.68 10 10d 2.30 241.44 71.10 *FLAGS NOT SPLAY 10 11 1.12 263.77 46.91 *FLAGS SPLAY 11 11a 0.64 52.79 1.87 11 11b 1.45 190.34 76.03 11 11c 0.98 0.32 -83.36 *FLAGS NOT SPLAY 11 12 3.53 351.74 -3.89 *FLAGS SPLAY 12 12a 0.83 261.49 10.43 12 12b 1.01 249.00 60.34 *FLAGS NOT SPLAY 12 13 1.97 312.50 39.30 *FLAGS SPLAY 13 13a 0.91 98.78 -1.21 13 13b 0.46 59.54 83.75 13 13c 1.07 62.56 -71.75 *FLAGS NOT SPLAY 13 14 2.39 28.12 3.33 *FLAGS SPLAY 14 14a 1.53 267.21 -13.19 14 14b 0.59 261.25 -82.95 14 14c 0.50 137.83 73.72 *FLAGS NOT SPLAY 14 15 0.86 306.09 -13.02 ;15=notch on stal column *FLAGS SPLAY 15 15a 0.46 78.21 4.93 15 15b 0.65 248.76 6.64 15 15c 0.41 265.85 -88.54 15 15d 0.40 124.70 82.35 15 15e 0.47 23.47 0.91 *FLAGS NOT SPLAY 15 16 4.55 48.38 7.37 *FLAGS SPLAY 16 16a 2.92 223.69 -3.46 16 16b 3.00 236.59 2.01 16 16c 1.64 276.31 -3.03 16 16d 0.90 237.99 72.78 16 16e 1.59 109.59 -71.63 16 16f 2.40 204.15 -9.08 16 16g 1.26 254.43 2.93 *FLAGS NOT SPLAY 16 17 2.34 328.01 -9.83 *FLAGS SPLAY 17 17a 1.50 103.75 -2.42 17 17b 1.22 173.37 80.16 *FLAGS NOT SPLAY 17 18 2.65 86.23 -7.24 *FLAGS SPLAY 18 18a 2.10 185.84 6.37 18 18b 0.40 223.80 82.63 18 18c 0.51 10.73 10.61 18 18d 0.52 174.98 -79.44 *FLAGS NOT SPLAY 18 19 0.84 146.67 18.49 *FLAGS SPLAY 19 19a 1.39 43.52 3.89 19 19b 0.51 159.85 17.51 19 19c 0.40 97.95 87.19 *FLAGS NOT SPLAY 19 20 1.81 87.93 13.23 *FLAGS SPLAY 20 20a 0.60 43.10 4.22 20 20b 1.64 208.49 63.28 20 20c 0.87 209.39 -0.95 *FLAGS NOT SPLAY 20 21 1.73 164.45 7.33 *FLAGS SPLAY 21 21a 0.68 33.20 4.40 21 21b 1.20 234.09 82.95 21 21c 0.25 41.06 -84.36 *FLAGS NOT SPLAY 21 22 2.91 113.95 7.56 *FLAGS SPLAY 22 22a 1.33 255.18 77.95 22 22b 0.88 220.17 0.04 22 22c 0.40 136.32 -85.39 22 22d 2.39 358.28 2.05 22 22e 4.28 320.27 -8.84 *FLAGS NOT SPLAY 22 23 1.51 181.21 30.14 *FLAGS SPLAY 23 23a 0.20 214.51 -9.54 23 23b 1.26 55.54 -74.20 23 23c 0.38 35.19 9.16 23 23d 0.40 243.28 88.13 23 23e 1.79 34.58 -40.94 *FLAGS NOT SPLAY 23 24 4.59 108.18 -8.18 *FLAGS SPLAY 24 24a 2.12 27.47 19.01 24 24b 1.44 265.31 83.06 24 24c 2.74 209.33 20.17 24 24d 3.06 204.37 31.06 24 24e 2.70 172.96 38.49 24 24f 2.76 119.14 44.68 24 24g 4.29 105.49 35.63 24 24h 3.31 94.03 37.41 24 24i 3.41 321.99 7.71 *FLAGS NOT SPLAY 24 25 3.22 188.75 35.45 ;25=tip of obvious pointed boulder in middle of lower section *FLAGS SPLAY 25 25a 1.17 228.03 4.30 25 25b 2.44 342.35 79.94 25 25c 0.87 172.80 80.92 25 25d 0.37 33.36 9.50 25 25e 4.18 97.27 36.04 *FLAGS NOT SPLAY 25 26 4.13 139.60 16.69 *FLAGS SPLAY 26 26a 0.48 231.41 -0.43 26 26b 0.56 131.73 89.68 26 26c 1.15 13.53 28.43 26 26d 0.53 146.88 -77.01 26 26e 3.06 118.05 16.64 *FLAGS NOT SPLAY 25 27 4.94 97.33 39.05 *FLAGS SPLAY 27 27a 0.53 73.50 39.91 27 27b 2.86 145.99 24.42 27 27c 2.08 181.17 14.96 27 27d 3.64 159.34 16.76 *FLAGS NOT SPLAY 24 28 2.78 323.60 -24.94 ;28=shiny black square block protruding from calcite on left side of hole when looking down hole *FLAGS SPLAY 28 28a 2.01 240.61 79.48 28 28b 1.17 150.81 -80.16 28 28c 0.42 153.56 -10.07 *FLAGS NOT SPLAY 28 29 0.89 90.00 -48.92 *FLAGS SPLAY 29 29a 0.66 345.81 68.52 29 29b 0.74 153.15 1.62 29 29c 0.65 303.35 1.69 29 29d 1.17 85.81 -77.61 29 29e 1.26 23.75 -19.21 *FLAGS NOT SPLAY 29 30 6.28 324.60 -29.83 *FLAGS SPLAY 30 30a 1.95 224.71 72.46 30 30b 1.49 213.57 5.25 30 30c 0.32 52.79 6.31 30 30d 0.43 224.41 -83.42 *FLAGS NOT SPLAY 30 31 1.55 264.23 41.75 ;31=tip of stalagmite which is 10cm below tip of stalactite above it *FLAGS SPLAY 31 31a 1.18 36.18 2.86 31 31b 1.41 7.15 4.71 31 31c 0.98 76.71 80.67 31 31d 0.43 206.64 4.65 31 31e 1.50 164.76 -87.26 *FLAGS NOT SPLAY 31 32 2.26 15.83 12.57 *FLAGS SPLAY 32 32a 0.88 258.32 -39.46 32 32b 0.41 254.53 -1.76 32 32c 0.62 258.09 37.38 32 32d 0.76 1.51 -83.57 *FLAGS NOT SPLAY 32 35 6.03 323.45 -41.61 31 34 5.13 314.22 -30.46 *FLAGS SPLAY 34 34a 1.81 117.94 6.32 34 34b 1.67 169.45 73.19 34 34c 0.78 104.73 -65.15 *FLAGS NOT SPLAY 34 35 2.76 19.79 -19.74 ;33=35 tip of little stumpy stalagmite on floor directly opposite junction *FLAGS SPLAY 35 35a 3.60 249.79 75.43 35 35b 0.58 4.89 17.88 35 35c 1.23 222.29 3.93 *FLAGS NOT SPLAY 35 36 4.45 91.00 26.23 *FLAGS SPLAY 36 36a 2.37 172.41 2.46 36 36b 2.48 280.23 82.99 36 36c 1.17 0.68 7.77 36 36d 0.38 351.51 -81.72 36 36e 4.81 16.95 43.97 *FLAGS NOT SPLAY 36 37 6.61 112.79 18.69 *FLAGS SPLAY 37 37a 2.77 143.57 88.42 37 37b 1.24 47.17 8.65 37 37c 2.20 237.64 2.14 37 37d 0.52 23.20 -72.57 *FLAGS NOT SPLAY 37 38 3.92 158.52 22.40 *FLAGS SPLAY 38 38a 2.57 265.36 79.77 38 38b 1.77 258.21 76.02 38 38c 0.83 188.45 -87.34 38 38d 1.09 247.04 2.21 38 38e 1.13 47.31 -9.21 *FLAGS NOT SPLAY 38 39 5.06 158.54 15.55 ;39=tip of little stumpy stalagmite on edge of boulder. 15cm high stal. 60cm tall boulder face. *FLAGS SPLAY 39 39a 0.81 95.41 80.83 39 39b 0.36 243.34 -2.19 39 39c 1.36 68.36 1.57 39 39d 0.31 143.52 -87.32 39 39e 2.22 37.38 14.64 39 39f 1.24 124.14 29.01 39 39g 1.52 169.90 20.43 39 39h 3.17 184.03 6.76 *FLAGS NOT SPLAY 39 40 3.30 137.29 35.75 *FLAGS SPLAY 40 40a 0.41 330.85 80.32 40 40b 0.72 24.63 16.27 40 40c 0.43 242.41 10.73 *FLAGS NOT SPLAY 40 41 1.54 156.92 21.03 *FLAGS SPLAY 41 41a 1.17 313.23 86.69 41 41b 0.76 273.70 17.56 41 41c 1.15 52.78 9.22 *FLAGS NOT SPLAY 41 42 1.23 188.42 54.13 *FLAGS SPLAY 42 42a 0.31 20.21 65.90 42 42b 0.56 64.53 1.80 42 42c 0.25 246.58 30.01 42 42d 1.21 119.22 24.03 *FLAGS NOT SPLAY 35 43 7.82 271.86 -10.72 *FLAGS SPLAY 43 43a 2.96 340.05 72.39 43 43b 0.62 18.69 7.95 43 43c 0.66 202.11 10.96 43 43d 1.72 172.80 -79.05 *FLAGS NOT SPLAY 43 44 1.58 132.75 -54.76 ;44=breast like stalagmite on floor against left wall. Right on the white nipple spot washed clean by drips. 43 45 4.22 283.16 -3.82 *FLAGS SPLAY 45 45a 0.26 5.45 2.81 45 45b 0.92 147.26 -80.05 45 45c 2.17 187.63 77.31 45 45d 1.42 144.48 74.70 45 45e 1.03 171.63 2.41 46 46a 1.17 359.83 20.74 46 46b 1.04 279.77 44.73 *FLAGS NOT SPLAY 46 47 4.08 278.14 -22.89 ;47=little stumpy stalagmite on RH wall *FLAGS SPLAY 47 47a 1.17 175.15 69.16 47 47b 0.66 146.16 -60.94 47 47c 0.96 181.60 1.29 *FLAGS NOT SPLAY 47 48 1.62 127.59 7.41 *FLAGS SPLAY 48 48a 0.32 222.85 -13.13 48 48b 0.43 203.78 77.03 48 48c 0.71 106.46 -84.42 48 48d 6.38 143.21 1.27 48 48e 9.20 143.56 0.28 *FLAGS NOT SPLAY 45 49 2.40 265.00 1.41 ;49=nipple on tip of big stalagmite boss *FLAGS SPLAY 49 49a 2.28 354.04 78.68 49 49b 0.52 198.25 -1.65 49 49c 0.89 19.99 9.05 49 49d 0.71 358.32 -81.38 49 49e 3.78 142.08 -59.73 *FLAGS NOT SPLAY 49 50 2.06 297.62 28.08 *FLAGS SPLAY 50 50a 0.69 36.66 83.53 50 50b 0.46 191.30 6.20 50 50c 0.76 186.66 -84.09 *FLAGS NOT SPLAY 50 51 2.38 317.24 16.74 ;51=tip of larger stalagmite reaching close to ceiling *FLAGS SPLAY 51 51a 0.35 91.28 79.27 51 51b 0.67 44.19 5.41 51 51c 1.90 251.77 -12.45 51 51d 4.01 13.33 -82.25 *FLAGS NOT SPLAY 51 52 2.80 335.01 -5.36 *FLAGS SPLAY 52 52a 2.10 212.50 -9.20 52 52b 0.66 156.09 88.10 52 52c 1.10 206.43 -87.82 52 52d 0.70 140.09 -4.62 *FLAGS NOT SPLAY 52 53 8.00 77.58 15.81 52 54 2.99 251.79 -11.14 *FLAGS SPLAY 54 54a 1.50 7.07 14.17 54 54b 4.94 156.76 -77.22 54 54c 1.38 326.54 73.27 *FLAGS NOT SPLAY 54 55 2.75 287.69 -14.31 *FLAGS SPLAY 55 55a 0.48 212.28 8.16 55 55b 1.78 2.22 0.72 55 55c 1.25 356.97 51.33 55 55d 4.84 0.83 -70.83 55 55e 2.30 347.76 56.75 *FLAGS NOT SPLAY 55 56 6.04 280.29 -11.16 *FLAGS SPLAY 56 56a 2.58 173.80 -9.68 56 56b 0.91 210.62 72.78 56 56c 5.52 258.49 -78.70 56 56d 1.22 355.76 -2.47 *FLAGS NOT SPLAY 56 57 4.72 167.79 -69.81 ;57=top of rounded calcite blob stuck out from wall *FLAGS SPLAY 57 57a 5.53 35.74 84.02 57 57b 1.48 358.49 5.81 57 57c 0.71 175.94 -0.18 57 57d 0.76 90.98 -86.28 *FLAGS NOT SPLAY 57 58 6.26 266.27 3.98 *FLAGS SPLAY 58 58a 0.91 320.07 6.44 58 58b 2.54 289.66 73.92 58 58c 2.05 155.98 1.05 58 58d 0.77 137.62 -73.53 58 58e 4.37 86.04 -33.48 *FLAGS NOT SPLAY 58 59 5.34 221.34 -28.43 ;59=little dimple in middle of large stalagmite boss directly in front of you when entering from Short Dry Way *FLAGS SPLAY 59 59a 5.41 309.94 9.33 59 59b 1.86 144.63 3.09 59 59c 3.04 302.62 79.62 59 59d 0.68 132.99 -79.35 59 59e 4.71 353.28 -42.52 59 59f 2.89 67.97 28.72 59 59g 2.49 85.86 13.93 59 59h 2.95 112.78 22.54 59 59i 1.83 207.67 8.62 59 59j 5.28 237.30 -3.61 59 59k 5.32 272.91 -3.40 59 59l 3.22 8.05 23.97 *FLAGS NOT SPLAY 59 60 3.64 249.87 -18.27 *FLAGS SPLAY 60 60a 2.91 98.61 33.34 60 60b 4.04 127.08 30.32 60 60c 3.55 153.59 27.64 60 60d 5.46 181.97 11.17 60 60e 2.54 10.68 -16.02 60 60f 3.08 23.70 -10.67 60 60g 4.51 196.88 -31.47 *FLAGS NOT SPLAY 60 61 6.14 188.00 -36.35 *FLAGS SPLAY 61 61a 0.93 109.00 -3.73 61 61b 4.46 154.64 72.91 61 61c 3.27 191.41 -82.47 *FLAGS NOT SPLAY 61 62 1.04 31.64 -42.73 *data passage station left right up down 0 0.56 1.34 0.66 0.56 1 1.13 1.96 0.46 1.49 2 0.63 0.92 0.74 1.91 3 0.44 0.45 1.17 0.48 4 1.02 0.00 1.95 1.36 5 1.73 0.62 2.74 0.23 6 1.12 0.32 2.48 0.46 7 1.10 0.00 1.41 0.50 8 0.55 0.00 0.88 0.81 *data passage station left right up down 7 1.12 0.00 1.41 0.50 9 0.85 0.56 0.83 0.57 10 0.39 0.24 2.18 0.43 11 0.00 0.61 1.41 0.97 12 0.77 0.00 0.88 0.00 13 0.00 0.86 0.46 1.02 14 1.47 0.00 0.48 0.59 15 0.61 0.45 0.40 0.41 16 2.24 0.00 0.86 1.51 17 0.00 1.46 1.20 0.00 18 0.48 1.95 0.40 0.51 19 1.33 0.33 0.40 0.00 20 0.60 0.87 1.46 0.00 21 0.65 0.00 1.19 0.25 22 1.22 0.84 1.30 0.40 23 1.27 0.18 0.40 1.22 24 3.04 1.76 1.43 0.00 25 3.11 1.05 0.86 0.00 26 1.08 0.47 0.56 0.51 *data passage station left right up down 25 2.42 1.16 0.86 0.00 27 0.16 3.08 0.34 0.00 *data passage station left right up down 24 1.76 3.04 1.43 0.00 28 0.00 0.00 1.98 1.15 29 0.64 0.60 0.61 1.15 30 1.46 0.28 1.86 0.43 31 0.39 1.15 0.96 1.50 32 0.68 0.00 0.38 0.75 *data passage station left right up down 31 0.43 1.38 0.96 1.50 34 0.00 1.36 1.60 0.70 35 0.55 0.93 3.48 0.00 36 3.45 2.23 2.46 0.38 37 1.22 2.15 2.77 0.50 38 1.04 1.09 2.53 0.83 39 2.01 1.86 0.80 0.31 40 0.59 0.42 0.40 0.00 41 0.98 0.71 1.17 0.00 42 1.04 0.19 0.28 0.00 *data passage station left right up down 35 0.93 0.55 3.48 0.00 43 0.61 0.64 2.82 1.68 *data passage station left right up down 43 0.62 0.61 2.82 1.68 45 1.00 0.26 2.12 0.91 *data passage station left right up down 46 0.00 1.08 0.73 0.00 47 0.42 0.00 1.09 0.58 *data passage station left right up down 47 0.00 0.70 1.09 0.58 48 0.00 0.31 0.42 0.70 *data passage station left right up down 45 1.00 0.26 2.12 0.91 49 1.24 0.87 2.24 0.71 50 0.42 0.00 0.69 0.75 51 1.79 0.65 0.34 3.97 52 0.00 1.39 0.66 1.10 *data passage station left right up down 52 1.39 0.00 0.66 1.10 54 0.00 1.44 1.32 4.82 55 0.45 1.75 1.92 4.58 56 0.00 0.91 0.87 5.42 57 0.47 0.00 5.50 0.75 58 2.05 0.88 2.44 0.74 59 2.29 5.14 2.99 0.67 60 3.48 1.15 1.60 2.35 61 0.00 0.00 4.26 3.24 *END LongDryWay *BEGIN ShortDryWay *EQUATE pt1.13 pt2.0 *BEGIN pt1 ;Badger, Paul Dold, Footleg *DATE 2013.02.24 *CALIBRATE declination +1.63 0 1 1.43 131.61 -13.25 *FLAGS SPLAY 1 1a 1.42 311.07 12.80 1 1b 0.58 327.33 -0.57 1 1c 0.94 171.13 -6.41 1 1d 0.50 258.56 -34.18 *FLAGS NOT SPLAY 1 2 3.89 73.29 -51.63 *FLAGS SPLAY 2 2a 3.91 252.77 52.00 2 2b 0.91 252.72 -4.04 2 2c 0.80 250.31 -35.24 2 2d 2.44 239.99 47.81 *FLAGS NOT SPLAY 2 3 4.50 170.72 19.68 ;3=tip of downward pointing rock spike on ceiling *FLAGS SPLAY 3 3a 4.46 350.50 -20.39 3 3b 0.46 71.39 -4.30 3 3c 0.39 251.63 -13.19 3 3d 1.54 358.12 82.08 3 3e 0.94 170.44 -79.46 3 3f 0.45 220.38 -6.59 *FLAGS NOT SPLAY 3 4 1.11 246.49 -14.16 *FLAGS SPLAY 4 4a 0.68 212.13 -85.64 4 4b 0.28 4.71 4.35 4 4c 0.60 345.93 65.79 4 4d 2.84 294.88 -9.50 *FLAGS NOT SPLAY 2 5 4.91 323.66 2.34 *FLAGS SPLAY 5 5a 4.91 143.73 -2.57 5 5b 0.74 236.15 -6.85 5 5c 0.87 46.77 -82.61 5 5d 1.68 227.27 67.16 5 5e 1.03 103.39 -8.81 5 5f 2.18 148.83 -2.53 *FLAGS NOT SPLAY 5 6 5.05 279.35 -25.23 *FLAGS SPLAY 6 6a 5.05 99.27 25.32 6 6b 0.58 34.79 1.49 6 6c 1.16 111.26 -85.03 6 6d 2.83 16.27 74.62 6 6e 2.60 99.05 2.63 6 6f 2.79 105.09 4.91 *FLAGS NOT SPLAY 6 7 5.02 336.36 -13.85 *FLAGS SPLAY 7 7a 5.00 156.87 13.29 7 7b 0.41 231.77 -3.06 7 7c 3.73 254.43 80.33 7 7d 0.54 182.41 -84.02 7 7e 2.55 328.39 -82.67 *FLAGS NOT SPLAY 7 8 3.19 303.08 -33.11 *FLAGS SPLAY 8 8a 3.21 123.01 33.05 8 8b 0.53 23.07 -5.56 8 8c 4.46 353.35 80.60 8 8d 1.45 224.40 -78.95 8 8e 1.87 72.08 1.35 *FLAGS NOT SPLAY 8 9 6.71 295.69 -12.15 ;9=lone little knobby white stalagmite on wall *FLAGS SPLAY 9 9a 6.72 115.55 11.83 9 9b 0.56 196.48 2.10 9 9c 1.16 244.84 81.25 9 9d 1.09 201.63 -76.54 9 9e 3.56 117.58 -4.92 *FLAGS NOT SPLAY 9 10 1.11 265.93 2.35 *FLAGS SPLAY 10 10a 1.10 86.87 -3.67 10 10b 0.45 26.25 1.63 10 10c 1.16 88.18 -83.85 10 10d 0.84 103.85 84.38 *FLAGS NOT SPLAY 10 11 4.30 323.22 3.80 *FLAGS SPLAY 11 11a 4.28 143.46 -4.52 11 11b 0.57 212.81 2.62 11 11c 2.07 237.99 81.23 11 11d 1.72 204.15 -67.89 *FLAGS NOT SPLAY 11 12 3.28 275.99 -17.30 *FLAGS SPLAY 12 12a 3.28 96.34 17.39 12 12b 0.52 17.73 -1.02 12 12c 0.81 128.05 -86.09 12 12d 1.79 345.81 78.34 *FLAGS NOT SPLAY 12 13 4.68 298.00 -3.29 *FLAGS SPLAY 13 13a 4.68 118.39 3.00 13 13b 0.57 34.60 -3.75 13 13c 0.38 17.11 84.09 13 13d 0.72 158.62 -86.15 13 13e 2.72 321.69 70.91 *FLAGS NOT SPLAY *data passage station left right up down 1 0.41 0.87 0.00 0.28 2 0.00 1.62 1.80 0.46 3 0.31 0.26 1.52 0.92 4 0.00 0.28 0.55 0.68 *data passage station left right up down 2 1.62 0.00 1.80 0.46 5 1.00 0.32 1.55 0.87 6 0.00 1.25 2.73 1.15 7 0.41 0.00 3.67 0.53 8 0.00 1.38 4.40 1.42 9 1.02 0.00 1.15 1.06 10 0.00 0.45 0.84 1.16 11 0.64 0.00 2.05 1.59 12 0.00 0.52 1.75 0.80 13 0.00 0.57 0.38 0.71 *END pt1 *BEGIN pt2 ;Badger, Paul Dold, Footleg *DATE 2013.02.24 *CALIBRATE declination +1.63 *FLAGS SPLAY 0 0a 0.57 34.03 -0.51 0 0b 0.76 110.14 -85.72 0 0c 2.74 327.08 86.41 *FLAGS NOT SPLAY 0 1 3.20 316.66 0.98 *FLAGS SPLAY 1 1a 3.22 136.76 -1.39 1 1b 0.57 38.38 3.06 1 1c 1.47 103.34 -84.18 1 1d 2.40 260.62 87.93 *FLAGS NOT SPLAY 1 2 7.10 308.84 -15.08 *FLAGS SPLAY 2 2a 7.10 128.55 14.54 2 2b 0.66 194.88 1.13 2 2c 2.89 349.78 82.91 2 2d 0.88 179.54 -65.42 *FLAGS NOT SPLAY 2 3 4.24 278.91 -12.53 ;Stn3=little dimple in middle of large stalagmite boss directly in front of you when entering Old Grotto from Short Dry Way = Long Dry Way stn 59 *FLAGS SPLAY 3 3a 4.21 98.44 12.28 3 3b 3.16 81.24 88.43 3 3c 0.77 354.83 -84.93 *FLAGS NOT SPLAY *data passage station left right up down 0 0.00 0.56 2.73 0.76 1 0.00 0.57 2.40 1.46 2 0.65 0.00 2.87 0.80 3 0.66 0.81 3.16 0.76 *END pt2 *END ShortDryWay *BEGIN NewGrottoes ;Badger, Paul Dold, Footleg *DATE 2013.02.24 *CALIBRATE declination +1.63 0 1 1.56 49.36 7.27 *FLAGS SPLAY 1 1a 0.50 331.16 9.17 1 1b 0.40 271.22 77.61 1 1c 0.73 254.64 -87.94 1 1d 0.61 352.02 40.11 1 1e 0.56 43.52 51.47 *FLAGS NOT SPLAY 1 2 1.75 10.53 51.20 *FLAGS SPLAY 2 2a 1.76 189.76 -51.66 2 2b 0.29 258.50 0.35 2 2c 0.88 338.65 -79.23 2 2d 0.70 150.96 76.26 *FLAGS NOT SPLAY 2 3 4.07 347.52 12.12 *FLAGS SPLAY 3 3a 4.11 169.15 -12.51 3 3b 4.10 169.13 -12.74 3 3c 1.83 347.89 14.57 3 3d 0.96 250.24 -6.20 3 3e 0.41 84.04 87.54 3 3f 0.44 216.05 -86.92 3 3g 0.82 148.72 -10.96 3 3h 1.22 190.30 -16.89 *FLAGS NOT SPLAY 3 4 3.62 50.60 25.22 *FLAGS SPLAY 4 4a 3.63 230.43 -25.57 4 4b 0.43 348.10 4.44 4 4c 1.63 170.52 -5.86 4 4d 0.89 61.11 -81.94 4 4e 2.11 344.82 -7.61 *FLAGS NOT SPLAY 4 5 3.25 67.67 12.62 *FLAGS SPLAY 5 5a 3.28 247.14 -13.26 5 5b 0.25 323.66 84.61 5 5c 0.95 170.46 5.78 5 5d 2.13 330.90 -6.07 5 5e 0.77 222.68 -84.36 *FLAGS NOT SPLAY 5 6 3.45 56.57 19.52 *FLAGS SPLAY 6 6a 3.49 237.94 -19.53 6 6b 1.42 154.07 -15.19 6 6c 0.56 71.63 -87.16 6 6d 0.62 341.85 -3.41 6 6e 2.15 233.89 -20.79 6 6f 4.02 168.54 2.89 6 6g 2.44 124.70 10.45 6 6h 1.87 106.22 14.43 6 6i 2.75 182.55 1.05 *FLAGS NOT SPLAY 6 7 1.42 151.95 -12.13 *FLAGS SPLAY 7 7a 1.42 329.66 11.34 7 7b 1.55 42.07 39.53 7 7c 3.00 180.55 4.65 7 7d 0.89 354.61 85.36 7 7e 0.44 28.33 -87.65 *FLAGS NOT SPLAY 7 8 6.30 84.91 26.43 *FLAGS SPLAY 8 8a 0.81 355.74 6.08 8 8b 0.32 173.04 9.98 8 8c 0.19 349.50 82.00 8 8d 0.36 157.86 -75.31 *FLAGS NOT SPLAY *data passage station left right up down 1 0.42 0.08 0.39 0.73 2 0.28 0.00 0.68 0.87 3 0.92 0.62 0.41 0.44 4 2.01 1.51 0.00 0.89 5 2.12 0.90 0.25 0.76 6 0.52 3.62 0.00 0.56 7 1.16 2.64 0.89 0.44 8 0.81 0.32 0.19 0.35 *END NewGrottoes *BEGIN OldGrotto2WC ;Badger, Paul Dold, Footleg *DATE 2013.02.24 *CALIBRATE declination +1.63 0 1 3.32 25.03 -14.33 *FLAGS SPLAY 1 1a 3.26 206.41 14.30 1 1b 0.98 315.03 -8.83 1 1c 0.76 174.77 -0.38 1 1d 2.49 219.51 -12.94 1 1e 1.90 280.22 -27.03 *FLAGS NOT SPLAY 1 2 5.70 255.27 -30.20 *FLAGS SPLAY 2 2a 5.71 74.10 29.84 2 2b 1.06 162.52 -1.36 2 2c 1.22 220.20 80.94 2 2d 0.39 332.89 1.22 2 2e 1.14 198.72 -82.80 *FLAGS NOT SPLAY 2 3 3.09 201.53 -10.26 *FLAGS SPLAY 3 3a 3.10 20.12 10.18 3 3b 1.30 263.57 -6.52 3 3c 0.93 284.07 -86.47 3 3d 0.93 75.35 -2.53 3 3e 0.32 234.48 85.69 *FLAGS NOT SPLAY 3 4 4.55 164.72 -15.92 ;4=small rounded boss stalagmite on calcite bridge in centre of passage. Top of boss has contour like line pattern. *FLAGS SPLAY 4 4a 4.52 344.84 15.77 4 4b 0.61 258.46 -2.19 4 4c 0.63 86.33 -2.22 4 4d 5.53 284.88 86.05 4 4e 2.47 181.69 -82.25 *FLAGS NOT SPLAY 4 5 2.38 199.29 -26.79 *FLAGS SPLAY 5 5a 2.37 18.11 26.15 5 5b 0.82 318.06 0.68 5 5c 0.73 143.34 2.75 5 5d 5.25 191.96 83.34 5 5e 1.53 247.03 -88.07 *FLAGS NOT SPLAY 5 6 6.29 239.56 -9.79 *FLAGS SPLAY 6 6a 6.26 58.58 9.67 6 6b 1.26 349.18 -5.78 6 6c 1.45 42.58 -84.89 6 6d 0.23 174.05 2.52 6 6e 4.36 340.22 65.14 *FLAGS NOT SPLAY 6 7 7.66 284.16 -7.14 *FLAGS SPLAY 7 7a 7.65 104.12 6.94 7 7b 1.11 184.42 -3.02 7 7c 1.22 315.42 -87.56 7 7d 5.90 284.36 87.68 *FLAGS NOT SPLAY 7 8 2.58 224.20 -8.54 *FLAGS SPLAY 8 8a 2.58 43.16 8.82 8 8b 1.49 307.59 -0.90 8 8c 5.16 259.48 81.94 8 8d 1.06 108.65 -87.34 *FLAGS NOT SPLAY 8 9 6.80 205.89 -6.51 *FLAGS SPLAY 9 9a 6.77 24.81 6.09 9 9b 1.40 71.99 -5.17 9 9c 3.44 82.58 71.46 9 9d 1.27 18.89 -83.92 *FLAGS NOT SPLAY 9 10 2.09 108.56 -5.31 *FLAGS SPLAY 10 10a 2.12 289.79 4.09 10 10b 1.18 243.19 -9.20 10 10c 1.15 300.27 -85.48 10 10d 5.46 281.63 67.93 *FLAGS NOT SPLAY 10 11 7.85 204.84 6.96 ;11=RH of 3 points on top of boulder as seen when entering from Old Grotto. Point chipped by bashing so has white impact marks. *FLAGS SPLAY 11 11a 7.85 23.37 -7.47 11 11b 4.04 20.69 -17.03 11 11c 4.08 31.33 -11.00 11 11d 3.58 122.93 1.76 11 11e 5.02 146.17 5.40 11 11f 3.82 258.28 -10.90 11 11g 3.95 291.06 -0.53 11 11h 5.88 341.35 -3.35 11 11i 6.54 332.39 -2.75 11 11j 3.22 124.37 87.58 11 11k 1.02 81.55 -78.82 *FLAGS NOT SPLAY *data passage station left right up down 1 2.38 0.00 0.00 0.86 2 0.97 0.38 1.20 1.13 3 0.89 1.27 0.32 0.93 4 0.63 0.60 5.51 2.45 5 0.70 0.81 5.21 1.53 6 0.23 1.80 3.96 1.45 7 1.04 0.00 5.90 1.22 8 0.00 1.49 5.10 1.06 9 1.39 0.00 3.26 1.26 10 0.00 1.68 5.06 1.15 11 4.27 5.18 3.22 1.00 *END OldGrotto2WC *BEGIN FortyRoute ;WSCC DistoX-Footleg ;PDA-Ben Kent *DATE 2013.06.29 *CALIBRATE declination +1.58 *FLAGS SPLAY 0 0a 1.22 222.85 -1.27 0 0b 1.46 156.87 -86.76 0 0c 1.04 248.22 75.18 *FLAGS NOT SPLAY 0 1 2.76 327.91 18.03 ;0=calcite testicle. Tie in stn for stream level survey *FLAGS SPLAY 1 1a 2.78 146.77 -18.73 1 1b 0.75 233.19 -9.76 1 1c 3.76 236.60 -61.01 1 1d 5.96 283.50 83.29 *FLAGS NOT SPLAY 1 2 5.35 306.91 5.35 *FLAGS SPLAY 2 2a 5.34 127.04 -5.34 2 2b 0.93 37.11 -9.90 2 2c 0.20 232.85 8.71 2 2d 0.77 47.20 -45.75 2 2e 5.18 303.14 -81.62 2 2f 2.15 89.72 81.91 *FLAGS NOT SPLAY 2 3 3.55 321.41 38.17 *FLAGS SPLAY 3 3a 3.53 140.66 -38.25 3 3b 0.25 241.41 3.91 3 3c 0.79 64.43 3.52 3 3d 2.35 116.75 81.52 3 3e 0.76 47.06 -63.29 3 3f 3.35 110.73 -74.59 3 3g 7.46 126.02 -72.97 *FLAGS NOT SPLAY 3 4 1.12 7.71 3.63 *FLAGS SPLAY 4 4a 1.10 186.02 -4.47 4 4b 0.67 231.66 -2.98 4 4c 2.21 239.56 80.82 4 4d 0.66 261.89 -73.67 *FLAGS NOT SPLAY 4 5 1.06 263.40 33.43 *FLAGS SPLAY 5 5a 1.05 82.92 -33.40 5 5b 0.57 40.65 -2.91 5 5c 1.16 37.56 -82.40 5 5d 1.63 42.68 77.79 *FLAGS NOT SPLAY 5 6 2.53 351.94 5.11 *FLAGS SPLAY 6 6a 2.52 171.57 -5.45 6 6b 0.49 251.10 -0.42 6 6c 1.24 242.62 -65.46 6 6d 1.46 223.45 74.25 *FLAGS NOT SPLAY 6 7 2.96 317.31 -3.31 *FLAGS SPLAY 7 7a 2.94 137.40 3.36 7 7b 0.49 69.22 2.25 7 7c 1.67 337.77 83.13 7 7d 1.64 62.33 -86.14 *FLAGS NOT SPLAY 7 8 5.25 326.28 -29.19 *FLAGS SPLAY 8 8a 5.24 144.41 28.59 8 8b 0.86 189.62 -3.22 8 8c 0.38 17.72 -13.79 8 8d 1.17 125.13 -68.29 8 8e 1.74 198.87 87.16 8 8f 1.48 138.91 36.33 8 8g 1.35 154.31 37.64 8 8h 1.31 145.24 3.36 8 8i 1.68 357.07 -42.58 8 8j 0.97 289.48 -24.64 *FLAGS NOT SPLAY 8 9 1.45 273.15 -22.26 *FLAGS SPLAY 9 9a 1.43 93.33 24.76 9 9b 0.34 20.18 -0.69 9 9c 1.39 262.30 -4.33 9 9d 0.77 190.18 -1.47 9 9e 4.31 268.96 75.35 ;splay to old stemple belay 9 9f 0.52 82.52 -53.29 9 9g 2.71 169.49 -81.00 *FLAGS NOT SPLAY 9 10 7.65 252.29 -71.60 *FLAGS SPLAY 10 10a 7.66 71.90 71.88 10 10b 2.79 105.38 2.13 10 10c 1.94 102.39 -80.10 10 10d 2.30 52.40 -8.53 *FLAGS NOT SPLAY 10 11 2.32 146.39 -8.38 ;stn11=RH point of broken tipped stalactite at head height in middle of stream (looking downstream) *FLAGS SPLAY 11 11a 2.33 327.27 7.87 11 11b 2.32 327.44 7.88 11 11c 1.58 246.33 79.18 11 11d 1.73 335.02 -87.87 11 11e 0.62 102.51 -8.28 11 11f 0.98 265.19 1.62 *FLAGS NOT SPLAY *data passage station left right up down 0 1.18 0.00 1.00 1.45 1 1.80 0.00 5.91 3.29 2 0.20 0.91 2.13 5.13 3 0.25 0.77 2.32 3.23 4 0.66 0.00 2.18 0.63 5 0.00 0.57 1.60 1.14 6 0.51 0.00 1.40 1.12 7 0.00 0.47 1.66 1.64 8 0.81 1.04 1.74 1.09 9 0.73 0.30 4.17 2.68 10 2.78 0.00 0.00 1.91 11 0.42 0.86 1.55 1.73 *END FortyRoute *BEGIN WaterRift ;Badger, Paul Dold, Footleg, Ben Kent, Josh White . *DATE 2013.06.29 *CALIBRATE declination +1.58 *FLAGS SPLAY 0 0a 5.35 17.95 22.62 0 0b 4.13 22.58 -15.64 0 0c 8.42 335.52 5.44 0 0d 8.89 333.03 6.81 0 0e 5.30 346.43 8.54 0 0f 5.13 294.43 17.44 0 0g 7.66 281.52 0.94 0 0h 6.92 262.96 5.04 0 0i 6.86 253.61 5.31 0 0j 5.23 247.20 7.41 0 0k 3.51 202.89 21.45 0 0l 5.06 195.97 22.67 0 0m 6.28 160.68 22.30 0 0n 8.67 132.59 16.67 0 0o 6.28 121.89 11.57 0 0p 3.27 114.10 12.54 *FLAGS NOT SPLAY 0 1 5.77 334.28 -11.88 *FLAGS SPLAY 1 1a 5.76 154.47 11.49 1 1b 1.98 166.16 -38.83 1 1c 3.75 244.92 84.64 1 1d 1.82 180.79 -73.82 *FLAGS NOT SPLAY 1 2 4.33 195.52 -26.62 *FLAGS SPLAY 2 2a 4.32 13.06 26.42 2 2b 0.76 316.99 -3.19 2 2c 0.28 114.54 1.61 2 2d 1.02 123.59 -85.18 2 2e 0.70 2.62 84.20 2 2f 4.92 233.56 80.23 *FLAGS NOT SPLAY 2 3 6.36 270.39 -36.08 *FLAGS SPLAY 3 3a 6.38 90.74 35.86 3 3b 7.22 164.95 87.99 3 3c 1.50 350.89 -85.48 3 3d 0.60 17.37 -5.81 3 3e 4.37 94.08 26.89 3 3f 2.04 96.97 2.01 *FLAGS NOT SPLAY 3 4 1.54 305.04 -17.83 ;4=testicle tie in to 40 route survey *FLAGS SPLAY 4 4a 1.56 124.70 18.36 4 4b 1.18 214.55 -3.95 4 4c 1.80 281.84 -85.97 4 4d 0.92 184.19 78.11 4 4e 5.88 261.80 85.59 *FLAGS NOT SPLAY 4 5 4.45 302.01 -20.17 ;passage continues up above route to 40's splay leg is to right side back wall *FLAGS SPLAY 5 5a 4.45 122.05 20.68 5 5b 0.66 42.61 -0.43 5 5c 0.79 295.82 80.77 5 5d 3.44 40.04 71.75 5 5e 1.19 159.77 -84.25 *FLAGS NOT SPLAY 5 6 2.13 320.38 -11.71 *FLAGS SPLAY 6 6a 2.12 139.96 12.80 6 6b 0.40 65.25 1.27 6 6c 1.37 29.54 74.80 6 6d 0.97 226.69 -87.04 6 6e 1.93 9.54 -74.91 *FLAGS NOT SPLAY 6 7 5.02 333.92 -11.98 *FLAGS SPLAY 7 7a 5.07 155.07 11.54 7 7b 0.32 233.46 -2.11 7 7c 3.09 147.72 83.95 7 7d 1.42 334.08 -84.41 *FLAGS NOT SPLAY 7 8 1.63 323.46 -34.24 *FLAGS SPLAY 8 8a 1.65 141.45 35.60 8 8b 0.74 242.86 -4.71 8 8c 2.20 121.85 85.11 8 8d 0.57 265.91 -86.27 *FLAGS NOT SPLAY 8 9 6.72 325.55 -5.61 *FLAGS SPLAY 9 9a 6.71 148.04 5.85 9 9b 0.67 85.11 -3.81 9 9c 1.21 68.18 77.77 9 9d 0.38 45.26 -87.04 *FLAGS NOT SPLAY 9 10 2.39 1.38 10.24 *FLAGS SPLAY 10 10a 2.40 179.07 -10.67 ;top of the climb down from the water rift 10 10b 0.87 224.61 -18.06 10 10c 2.55 202.57 79.97 10 10d 1.00 211.64 -85.65 10 10e 1.28 263.59 -11.49 10 10f 1.20 324.42 7.72 *FLAGS NOT SPLAY 10 11 3.73 245.25 -24.06 *FLAGS SPLAY 11 11a 3.72 63.01 24.03 11 11b 1.16 6.02 4.03 11 11c 0.49 155.26 4.00 11 11d 2.42 200.28 -80.22 11 11e 10.92 339.54 83.66 *FLAGS NOT SPLAY 11 12 1.75 211.67 -24.54 ;12=RH point of broken tipped stalactite at head height in middle of stream (looking downstream) *FLAGS SPLAY 12 12a 1.74 34.17 24.31 12 12b 0.94 259.38 1.16 12 12c 0.59 89.49 -3.42 12 12d 1.75 155.02 -82.92 12 12e 1.64 258.51 84.25 *FLAGS NOT SPLAY 12 13 8.34 181.38 -8.14 *FLAGS SPLAY 13 13a 8.39 2.63 8.00 13 13b 0.85 281.78 -0.49 13 13c 3.43 284.92 82.46 13 13d 0.81 114.24 -89.45 13 13e 0.20 95.00 3.81 *FLAGS NOT SPLAY 13 14 4.39 179.79 -2.78 *FLAGS SPLAY 14 14a 4.39 357.83 2.72 14 14b 1.53 261.41 0.73 14 14c 3.11 221.34 84.26 14 14d 0.84 76.55 -85.25 *FLAGS NOT SPLAY 14 15 7.89 176.25 -1.64 ;15=tip of fat stalactite in middle of passage *FLAGS SPLAY 15 15a 7.89 354.31 1.68 15 15b 0.39 271.84 -0.76 15 15c 0.43 81.78 2.27 15 15d 0.98 17.06 -84.71 15 15e 3.06 326.61 82.70 *FLAGS NOT SPLAY 15 16 4.52 194.00 -4.00 ;16=tip of calcite floor mound. highest point of calcited cobbles *FLAGS SPLAY 16 16a 4.55 11.12 3.98 16 16b 1.39 8.20 -1.40 16 16c 1.31 314.18 0.17 16 16d 2.88 210.72 3.57 16 16e 2.19 158.12 24.87 16 16f 3.69 159.38 30.12 16 16g 1.68 80.18 14.09 16 16h 1.36 3.78 83.92 16 16i 0.91 118.43 -86.27 *FLAGS NOT SPLAY *data passage station left right up down 0 6.74 3.41 1.95 0.00 1 1.53 0.00 3.73 1.74 2 0.24 0.75 0.69 1.02 3 0.00 0.60 7.22 1.50 4 1.18 0.00 5.87 1.80 5 0.00 0.66 0.78 1.18 6 0.00 0.40 1.32 0.96 7 0.32 0.00 3.07 1.41 8 0.73 0.00 2.19 0.57 9 0.00 0.66 1.18 0.38 10 0.81 0.43 2.51 1.00 11 0.47 0.78 10.85 2.39 12 0.56 0.84 1.64 1.73 13 0.19 0.84 3.40 0.81 14 0.00 1.52 3.09 0.84 15 0.42 0.39 3.04 0.98 16 1.81 1.13 1.35 0.91 *END WaterRift *BEGIN 10 ;pda Badger ;distoX (Owned by Gary Cullen) operated by Paul Dold *DATE 2013.06.30 *CALIBRATE declination +1.58 *FLAGS SPLAY 0 0a 0.79 122.45 -3.92 0 0b 0.82 125.25 -80.01 0 0c 1.02 113.36 59.45 *FLAGS NOT SPLAY 0 1 2.19 193.96 16.02 *FLAGS SPLAY 1 1a 0.60 276.70 12.05 1 1b 1.13 263.53 84.69 1 1c 0.86 340.30 -87.68 1 1d 0.22 130.33 11.67 *FLAGS NOT SPLAY 1 2 1.14 228.14 32.64 *FLAGS SPLAY 2 2a 0.70 84.60 -2.91 2 2b 0.51 245.48 7.63 2 2c 0.88 181.29 75.58 2 2d 1.15 205.42 -86.76 *FLAGS NOT SPLAY 2 3 3.27 163.30 -22.86 *FLAGS SPLAY 3 3a 0.64 68.81 -0.15 3 3b 1.80 103.28 -83.45 3 3c 1.69 279.44 83.39 3 3d 1.80 104.43 -50.09 3 3e 0.90 125.15 -23.23 3 3f 0.84 162.44 -25.10 3 3g 0.53 177.50 -0.32 *FLAGS NOT SPLAY 3 4 6.91 267.13 3.53 ;3 to 4 dig 4 being centre of dig face, muddy floor dig face muddy and pebbly *FLAGS SPLAY 4 4a 0.55 178.10 2.86 4 4b 0.33 358.62 9.99 4 4c 0.38 76.20 84.09 4 4d 0.44 211.43 -83.57 *FLAGS NOT SPLAY 3 5 2.54 190.56 -63.18 *FLAGS SPLAY 5 5a 0.60 308.44 -0.68 5 5b 0.72 295.04 -61.80 *FLAGS NOT SPLAY 5 6 4.59 251.07 -25.44 *FLAGS SPLAY 6 6a 1.06 89.99 22.23 6 6b 0.26 275.62 12.96 6 6c 0.49 129.38 84.49 6 6d 1.44 31.18 16.46 *FLAGS NOT SPLAY 6 7 2.94 167.27 7.15 *FLAGS SPLAY 7 7a 1.29 326.65 -21.82 7 7b 0.99 316.84 -22.29 7 7c 0.76 256.67 -44.96 7 7d 0.98 216.45 -34.57 7 7e 0.19 302.09 85.19 7 7f 1.57 162.77 -85.97 *FLAGS NOT SPLAY 7 8 3.72 165.59 -0.44 *FLAGS SPLAY 8 8a 0.75 39.89 9.56 8 8b 0.42 37.36 78.00 8 8c 1.07 126.50 -89.16 *FLAGS NOT SPLAY 8 9 2.10 111.50 19.76 *FLAGS SPLAY 9 9a 0.90 221.02 0.31 9 9b 1.10 120.62 -83.53 9 9c 0.21 316.09 84.80 9 9d 0.25 17.06 -3.95 9 9e 1.74 167.67 -7.64 9 9f 1.77 152.97 -6.07 9 9g 3.17 165.43 5.99 ;9 station looking up stream at t junction left hand wall on roof orange white calcite tip with lines of development I.e different bands of shading 9 9h 2.88 146.54 8.77 9 9i 2.84 106.66 13.82 ;9 cross section is looking upstream 9 9j 1.24 97.33 -8.06 *FLAGS NOT SPLAY 9 10 7.71 161.72 1.86 *FLAGS SPLAY 10 10a 0.46 262.62 2.57 10 10b 0.36 13.53 -1.36 10 10c 0.65 315.92 77.50 10 10d 0.63 99.67 -84.98 *FLAGS NOT SPLAY 10 11 2.16 102.08 5.76 ;11 the centre line of the left hand passage needs to be moved so it is between the width of the drawn passage. passage continues narrows too tight 9 12 8.35 93.72 17.83 *FLAGS SPLAY 12 12a 1.67 330.14 -0.55 12 12b 0.52 155.45 -0.04 12 12c 0.44 246.87 82.62 ;12 looking downstream passage keyhole shape 12 12d 0.44 67.03 -84.94 *FLAGS NOT SPLAY 12 13 4.34 9.47 9.01 *FLAGS SPLAY 13 13a 0.79 243.90 -9.22 13 13b 0.90 67.62 -18.81 13 13c 0.65 256.16 -85.98 *FLAGS NOT SPLAY 13 14 2.15 152.81 2.05 *FLAGS SPLAY 14 14a 3.84 296.58 51.55 14 14b 4.81 296.42 51.44 14 14c 3.83 296.46 51.33 ;leg stn4 to tie in point start of dry ways not numbered on this drawing *FLAGS NOT SPLAY 13 15 3.68 88.63 11.54 *FLAGS SPLAY 15 15a 1.22 317.35 3.30 15 15b 0.85 119.43 28.64 15 15c 0.50 294.64 80.22 15 15d 0.30 71.24 -88.13 15 15e 0.53 327.66 -14.96 15 15f 0.25 257.11 80.01 *FLAGS NOT SPLAY 15 16 5.88 47.35 18.38 *FLAGS SPLAY 16 16a 0.54 335.23 0.80 16 16b 1.45 160.46 6.63 16 16c 0.27 280.29 80.80 *FLAGS NOT SPLAY 16 17 5.34 79.73 18.79 *FLAGS SPLAY 17 17a 1.70 8.32 14.34 17 17b 2.11 303.47 88.21 17 17c 0.65 314.37 -88.24 17 17d 0.83 195.12 7.12 17 17e 2.82 295.58 -11.71 17 17f 2.08 255.83 -15.91 ;17 water 17 17g 1.17 134.29 25.92 17 17h 2.06 89.62 30.46 17 17i 1.20 51.23 52.50 17 17j 3.76 32.80 57.89 17 17k 0.98 313.51 23.51 ;17 a gully leading away from the chamber although dry today 20130630 evidence at times takes water 3 3x 0.37 221.12 0.55 *FLAGS NOT SPLAY 3 18 1.80 104.97 -49.81 ;18 19 1.86 143.63 -4.35 *FLAGS SPLAY 18 18a 0.78 175.26 4.50 18 18b 0.26 37.36 24.21 18 18c 0.31 183.81 49.92 *FLAGS NOT SPLAY 14 20 3.88 295.15 51.22 ;14=point of rock in middle of floor 20=two tone calcite point tie in for long dry way survey *data passage station left right up down 1 0.21 0.53 1.13 0.86 2 0.65 0.39 0.85 1.15 3 0.70 0.29 1.68 1.79 4 0.55 0.32 0.38 0.44 *data passage station left right up down 3 0.65 0.26 1.68 1.79 5 0.00 0.60 0.00 0.63 6 0.86 0.23 0.49 0.00 7 0.00 0.62 0.19 1.57 8 0.73 0.00 0.41 1.07 9 1.38 1.52 0.21 1.09 10 0.32 0.35 0.63 0.63 *data passage station left right up down 9 0.25 2.80 0.21 1.09 12 1.65 0.50 0.44 0.44 13 0.00 0.43 0.00 0.65 14 0.00 2.86 3.76 0.00 *data passage station left right up down 13 0.20 0.00 0.00 0.65 15 1.14 0.58 0.49 0.30 16 0.54 1.43 0.27 0.00 17 1.62 0.86 2.11 0.65 *data passage station left right up down 3 0.29 0.70 1.68 1.79 18 0.24 0.60 0.24 0.00 *END 10 *BEGIN 20 ;WSCC DistoX-Footleg ;PDA-Ben Kent *DATE 2013.06.30 *CALIBRATE declination +1.58 0 1 3.87 261.79 -26.31 ;1=small grey double hump stalagmite on back wall 1 2 2.55 125.69 -19.31 *FLAGS SPLAY 2 2a 0.91 250.27 7.92 2 2b 0.77 171.08 -87.61 2 2c 0.81 255.66 49.75 2 2d 0.24 67.33 -0.18 2 2e 3.81 229.59 62.45 *FLAGS NOT SPLAY 2 3 5.29 150.86 -7.60 *FLAGS SPLAY 3 3a 0.98 5.09 -20.60 3 3b 0.45 330.90 23.74 3 3c 1.15 347.72 -26.49 *FLAGS NOT SPLAY 3 4 1.83 63.94 -43.21 *FLAGS SPLAY 4 4a 0.88 254.64 -4.95 4 4b 0.31 92.19 22.06 4 4c 0.77 180.62 67.03 4 4d 0.57 170.18 -74.58 *FLAGS NOT SPLAY 4 5 3.13 176.57 -12.17 *FLAGS SPLAY 5 5a 0.89 62.62 28.28 5 5b 0.61 237.44 -20.17 5 5c 0.89 293.48 79.22 5 5d 0.56 337.49 -44.42 *FLAGS NOT SPLAY 5 6 1.40 257.65 -52.47 *FLAGS SPLAY 6 6a 0.52 318.37 75.96 6 6b 0.35 16.99 1.82 6 6c 0.19 324.08 -71.45 *FLAGS NOT SPLAY 6 7 2.40 284.49 -13.04 *FLAGS SPLAY 7 7a 0.40 195.25 -1.25 7 7b 0.32 213.01 45.13 7 7c 0.42 157.49 -56.01 *FLAGS NOT SPLAY 3 8 2.58 64.30 1.85 ;8=calcite knob highest point on boulder *FLAGS SPLAY 8 8a 0.98 338.09 -7.20 8 8b 1.33 152.73 8.89 8 8c 0.38 331.75 81.25 8 8d 1.90 340.12 -69.71 8 8e 0.89 274.97 -54.79 8 8f 1.08 232.73 0.66 *FLAGS NOT SPLAY 8 9 2.80 61.94 1.42 *FLAGS SPLAY 9 9a 2.81 191.74 9.89 9 9b 2.16 134.18 25.75 9 9c 2.16 50.11 -6.32 9 9d 1.26 6.31 -16.99 9 9e 1.13 289.11 75.43 9 9f 2.72 79.01 66.64 9 9g 0.85 267.86 -82.70 *FLAGS NOT SPLAY 9 10 5.67 274.30 -29.92 *FLAGS SPLAY 10 10a 0.67 2.50 88.13 10 10b 0.23 135.92 -83.36 10 10c 1.22 201.08 3.08 10 10d 3.64 11.56 12.96 10 10e 1.92 335.12 9.74 10 10f 2.38 307.32 -7.29 *FLAGS NOT SPLAY 10 11 4.21 315.24 -5.18 *FLAGS SPLAY 11 11a 0.55 90.17 -18.10 11 11b 0.85 207.55 -12.11 11 11c 0.48 85.91 -82.18 11 11d 1.30 348.21 -63.09 *FLAGS NOT SPLAY 11 12 0.46 277.24 -49.35 ;12= red paint mark *FLAGS SPLAY 12 12a 0.21 238.72 1.25 *FLAGS NOT SPLAY 12 13 2.99 11.93 3.89 *FLAGS SPLAY 13 13a 1.42 174.80 78.06 13 13b 0.30 315.88 -80.15 13 13c 2.31 246.88 74.77 13 13d 1.56 189.37 17.65 13 13e 3.02 211.37 -11.39 13 13f 3.15 248.27 -16.57 13 13g 1.77 297.77 -6.34 13 13h 3.86 328.15 -4.42 13 13i 4.28 343.90 -3.07 13 13j 3.09 19.95 6.70 13 13k 4.26 37.78 13.46 13 13l 3.80 64.26 16.75 13 13m 4.72 82.28 18.14 13 13n 1.83 98.00 23.43 *FLAGS NOT SPLAY 13 14 1.51 326.89 1.17 ;14=calcite tipped spike on ceiling over pit *FLAGS SPLAY 13 13a 1.80 134.62 18.89 *FLAGS NOT SPLAY 13 15 4.27 118.28 31.59 *FLAGS SPLAY 15 15a 2.10 311.12 -18.89 15 15b 0.29 304.38 72.17 15 15c 0.86 355.38 -83.90 15 15d 1.91 225.82 -10.33 *FLAGS NOT SPLAY 15 16 2.48 36.12 13.37 *FLAGS SPLAY 16 16a 0.50 296.88 -8.43 16 16b 1.10 323.19 -84.96 16 16c 1.15 357.90 17.17 16 16d 1.74 355.61 -47.54 16 16e 3.34 281.30 -47.10 *FLAGS NOT SPLAY 16 17 3.13 327.92 82.94 *FLAGS SPLAY 17 17a 0.72 273.55 72.14 17 17b 0.51 284.99 -34.65 *FLAGS NOT SPLAY 17 18 1.35 214.32 -12.67 18 19 2.43 231.25 22.63 13 20 2.14 331.93 -1.84 *FLAGS SPLAY 20 20a 1.14 42.18 -54.87 20 20b 1.18 122.45 -68.05 20 20c 0.36 67.41 74.28 20 20d 1.30 38.86 -71.88 20 20e 1.14 43.52 -52.40 *FLAGS NOT SPLAY 20 21 2.84 49.23 -61.41 *FLAGS SPLAY 21 21a 0.38 306.70 3.51 21 21b 0.58 42.06 -16.72 21 21c 0.36 346.21 52.74 *FLAGS NOT SPLAY 21 22 1.87 345.57 -9.57 *FLAGS SPLAY 22 22a 1.17 258.11 42.02 22 22b 0.37 242.14 -55.73 22 22c 0.36 39.38 -52.79 *FLAGS NOT SPLAY 22 23 1.63 311.27 20.13 *FLAGS SPLAY 23 23a 0.42 64.58 4.20 23 23b 0.32 213.47 -9.32 23 23c 0.99 86.07 -87.31 23 23d 0.25 94.22 48.88 *FLAGS NOT SPLAY 23 24 1.57 250.05 -33.27 *FLAGS SPLAY 24 24a 0.24 7.88 -0.38 24 24b 1.15 13.91 67.66 *FLAGS NOT SPLAY 24 25 2.11 302.88 3.36 *FLAGS SPLAY 25 25a 0.59 203.43 -39.91 25 25b 0.73 124.92 74.91 25 25c 0.46 19.39 -52.00 *FLAGS NOT SPLAY 25 26 2.60 267.02 31.57 *FLAGS SPLAY 26 26a 0.45 275.41 -83.91 26 26b 0.45 328.61 -88.28 26 26c 0.40 220.39 -21.96 26 26d 0.39 207.53 -25.01 26 26e 0.45 27.25 6.50 *FLAGS NOT SPLAY 27 26 1.86 143.63 -4.35 ;Reversed leg 18-19 in Series 10 *FLAGS SPLAY 26 26a 0.44 24.90 6.93 27 27a 0.78 175.30 4.50 27 27b 0.26 37.40 24.20 27 27c 0.31 183.80 49.90 *FLAGS NOT SPLAY *data passage station left right up down 2 0.23 1.76 3.38 0.77 3 0.90 0.00 0.18 0.51 4 0.13 0.26 0.71 0.55 5 0.34 0.35 0.88 0.39 6 0.00 0.34 0.51 0.18 7 0.40 0.00 0.22 0.34 *data passage station left right up down 3 0.90 0.00 0.18 0.51 8 0.96 1.31 0.38 1.78 9 0.00 1.90 1.09 0.84 10 1.21 3.46 0.67 0.23 11 0.83 0.46 0.00 0.47 12 0.21 0.00 0.00 0.00 13 2.90 4.13 1.39 0.29 *data passage station left right up down 13 4.13 2.90 1.39 0.29 15 1.61 0.98 0.28 0.85 16 2.24 0.00 0.00 1.09 17 0.00 0.10 0.69 0.29 *data passage station left right up down 13 2.88 4.11 1.39 0.29 20 0.00 0.41 0.35 1.23 21 0.35 0.23 0.29 0.00 22 0.82 0.21 0.78 0.31 23 0.29 0.25 0.19 0.98 24 0.00 0.43 1.06 0.00 25 0.45 0.28 0.70 0.36 26 0.31 0.39 0.00 0.45 27 0.73 0.22 0.24 0.00 *END 20 *END Swildons CaveConverter_src/test/data/regression/calibrations_in.svx0000644000000000000000000000716512172776722023171 0ustar rootroot*BEGIN Swildons *EQUATE Ent EntranceZigZags.3 *EQUATE surfacegps.4 EntranceZigZags.3 *EQUATE EntranceZigZags.5 LongDryWay.part1.0 *EQUATE LongDryWay.part1.5 EntranceZigZags.21 *EQUATE EntranceZigZags.21 ShortDryWay.0 *BEGIN surfacegps *CALIBRATE declination +1.58 0 1 9.84 94.37 -5.88 1 2 7.84 97.65 -8.05 2 3 11.76 94.27 -17.67 3 4 4.38 7.38 -23.29 3 5 5.45 262.93 13.06 5 6 8.80 174.95 11.61 6 7 13.78 168.31 12.55 *END surfacegps *BEGIN EntranceZigZags *CALIBRATE declination .6 *CALIBRATE compass 1.1 *CALIBRATE clino -0.1 0 1 2.98 10.26 -2.01 0 2 5.24 3.23 -5.04 2 3 2.64 166.70 -60.11 3 4 3.10 330.76 -25.13 4 5 4.51 275.80 -12.10 5 6 2.41 50.67 -22.33 6 7 1.08 37.30 11.53 7 8 2.00 6.10 11.51 8 9 1.01 56.60 0.18 9 10 3.07 336.52 5.81 9 11 2.42 64.64 5.29 11 12 4.50 106.56 19.29 10 13 0.94 80.55 -45.63 13 14 5.31 65.16 19.50 10 15 3.27 329.15 -18.16 15 16 3.57 334.08 -6.33 16 17 2.41 207.98 -9.43 17 18 4.05 308.01 -19.25 18 19 2.06 211.48 -16.06 19 20 2.94 233.55 -35.84 20 21 2.04 14.57 -39.09 *END EntranceZigZags *BEGIN LongDryWay *CALIBRATE declination +3.63 *CALIBRATE compass -2 *CALIBRATE clino 0.1 *EQUATE part1.31 part2.31 *EQUATE part2.33 part1.35 *begin part1 *EQUATE 35 BoulderChamber.35 *EQUATE 35 DownStream.35 0 1 4.08 270.72 -25.50 1 2 3.77 354.35 -29.81 2 3 4.33 336.10 -24.79 3 4 2.77 337.70 -4.41 4 5 3.14 343.71 -25.59 5 6 1.87 332.43 6.50 6 7 2.26 343.32 -5.29 7 8 1.72 258.62 12.28 7 9 1.10 310.47 4.46 9 10 2.37 334.59 4.19 10 11 1.12 263.77 46.91 11 12 3.53 351.74 -3.89 12 13 1.97 312.50 39.30 13 14 2.39 28.12 3.33 14 15 0.86 306.09 -13.02 15 16 4.55 48.38 7.37 16 17 2.34 328.01 -9.83 17 18 2.65 86.23 -7.24 18 19 0.84 146.67 18.49 19 20 1.81 87.93 13.23 20 21 1.73 164.45 7.33 21 22 2.91 113.95 7.56 22 23 1.51 181.21 30.14 23 24 4.59 108.18 -8.18 24 25 3.22 188.75 35.45 25 26 4.13 139.60 16.69 25 27 4.94 97.33 39.05 24 28 2.78 323.60 -24.94 28 29 0.89 90.00 -48.92 29 30 6.28 324.60 -29.83 30 31 1.55 264.23 41.75 31 34 5.13 314.22 -30.46 34 35 2.76 19.79 -19.74 *BEGIN DownStream *CALIBRATE declination 0 *CALIBRATE compass 0 *CALIBRATE clino 0 *EQUATE 44 46 35 43 7.82 271.86 -10.72 43 44 1.58 132.75 -54.76 43 45 4.22 283.16 -3.82 46 47 4.08 278.14 -22.89 47 48 1.62 127.59 7.41 45 49 2.40 265.00 1.41 49 50 2.06 297.62 28.08 50 51 2.38 317.24 16.74 51 52 2.80 335.01 -5.36 52 53 8.00 77.58 15.81 52 54 2.99 251.79 -11.14 54 55 2.75 287.69 -14.31 55 56 6.04 280.29 -11.16 56 57 4.72 167.79 -69.81 57 58 6.26 266.27 3.98 58 59 5.34 221.34 -28.43 59 60 3.64 249.87 -18.27 60 61 6.14 188.00 -36.35 61 62 1.04 31.64 -42.73 *END DownStream *BEGIN BoulderChamber 35 36 4.45 91.00 26.23 36 37 6.61 112.79 18.69 37 38 3.92 158.52 22.40 38 39 5.06 158.54 15.55 39 40 3.30 137.29 35.75 40 41 1.54 156.92 21.03 41 42 1.23 188.42 54.13 *END BoulderChamber *END part1 *BEGIN part2 31 32 2.26 15.83 12.57 32 33 6.03 323.45 -41.61 *END part2 *END LongDryWay *BEGIN ShortDryWay *CALIBRATE declination +5.13 ;Declination comment *CALIBRATE compass -2.5 ;Compass calibration comment *CALIBRATE clino 0.1 ;Clino calibration comment 0 1 1.43 131.61 -13.25 1 2 3.89 73.29 -51.63 2 3 4.50 170.72 19.68 3 4 1.11 246.49 -14.16 2 5 4.91 323.66 2.34 5 6 5.05 279.35 -25.23 6 7 5.02 336.36 -13.85 7 8 3.19 303.08 -33.11 8 9 6.71 295.69 -12.15 9 10 1.11 265.93 2.35 *END ShortDryWay *END Swildons CaveConverter_src/test/data/regression/Crossover_st_cmd_ref.text0000644000000000000000000000345212121061052024313 0ustar rootroot -6 1 1 1 1 Cave Name -5 1 1 1 1 0.00 0.00 0.00 1 0 -4 1 1 1 1 12/08/16 13:14:15 CaveConverter -3 1 1 1 1 -2 1 1 1 1 16/08/12 Converted Data 0 0.00 0 1 -1 1 1 1 1 360.00 360.00 0.05 1.00 1.00 100.00 0.00 1 -2 1 1 1 Series 1-root.CrossTest.Leg1 1 -1 1 1 1 1 0 1 5 5 3 0 1 0 1 1 1 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1 1 1 1 1 1.10 350.00 0.00 0.00 0.00 0.00 0.00 1 2 1 1 1 1.20 0.00 0.00 0.00 0.00 0.00 0.00 1 3 1 1 1 1.30 10.00 0.00 0.00 0.00 0.00 0.00 1 4 1 1 1 1.40 5.00 0.00 0.00 0.00 0.00 0.00 1 5 1 1 1 1.50 355.00 0.00 0.00 0.00 0.00 0.00 2 -2 1 1 1 Series 2-root.CrossTest.Leg2 2 -1 1 1 1 2 0 1 2 3 3 0 2 0 1 1 1 0.00 0.00 0.00 0.00 0.00 0.00 0.00 2 1 1 1 1 2.10 90.00 0.00 0.00 0.00 0.00 0.00 2 2 1 1 1 2.20 80.00 0.00 0.00 0.00 0.00 0.00 2 3 1 1 1 2.30 100.00 0.00 0.00 0.00 0.00 0.00 3 -2 1 1 1 Series 3-root.CrossTest.Leg2 3 -1 1 1 1 1 2 3 2 2 3 0 3 0 1 1 1 0.00 0.00 0.00 0.00 0.00 0.00 0.00 3 1 1 1 1 2.40 95.00 0.00 0.00 0.00 0.00 0.00 3 2 1 1 1 2.50 85.00 0.00 0.00 0.00 0.00 0.00CaveConverter_src/test/data/regression/Stomps_in.txt0000644000000000000000000005101211430605764021762 0ustar rootrootStomps2010 (m, 360) [1]: 2010/08/11 1.92 155.1 156.1 0.000 0.00 0.00 [1] 156.1 1.685 37.77 8.97 [1] 156.1 9.668 232.64 2.24 [1] 156.1 3.115 97.12 86.67 [1] 156.1 0.745 77.17 -89.50 [1] 156.1 15.030 226.71 -13.08 [1] 156.1 6.815 210.56 28.68 [1] 156.1 156.2 9.082 189.32 -7.47 [1] 156.1 156.2 9.083 189.34 -7.44 [1] 156.1 156.2 9.082 189.28 -7.39 [1] 156.2 7.472 208.36 -11.11 [1] 156.2 8.061 39.11 14.74 [1] 156.2 4.407 128.49 81.69 [1] 156.2 1.255 358.86 -82.11 [1] 156.2 156.3 18.548 116.97 -0.10 [1] 156.2 156.3 18.549 117.04 -0.17 [1] 156.2 156.3 18.549 116.93 -0.04 [1] 156.3 2.098 353.60 5.03 [1] 156.3 8.884 190.22 4.19 [1] 156.3 3.688 137.39 81.12 [1] 156.3 1.646 101.41 -87.20 [1] 156.3 156.4 3.936 109.44 5.34 [1] 156.3 156.4 3.938 109.22 5.48 [1] 156.3 156.4 3.938 109.37 5.36 [1] 156.4 1.715 13.50 -2.13 [1] 156.4 5.781 180.90 3.13 [1] 156.4 3.620 131.58 82.07 [1] 156.4 1.770 11.41 -89.12 [1] 156.4 156.5 14.131 96.88 -0.68 [1] 156.4 156.5 14.132 96.70 -0.55 [1] 156.4 156.5 14.132 96.70 -0.60 [1] 156.5 0.893 21.68 11.66 [1] 156.5 4.925 187.59 1.55 [1] 156.5 3.344 152.86 86.38 [1] 156.5 1.684 93.35 -86.43 [1] 156.5 10.695 195.39 -17.40 [1] 156.5 156.6 14.760 107.50 10.06 [1] 156.5 156.6 14.759 107.33 10.17 [1] 156.5 156.6 14.759 107.44 10.10 [1] 156.6 2.772 353.39 1.57 [1] 156.6 6.301 194.68 -4.39 [1] 156.6 1.207 240.65 80.78 [1] 156.6 2.024 357.90 -83.47 [1] 156.6 156.7 9.561 79.45 -2.42 [1] 156.6 156.7 9.565 79.40 -2.46 [1] 156.6 156.7 9.565 79.44 -2.57 [1] 156.7 12.221 207.03 2.29 [1] 156.7 1.677 97.50 85.86 [1] 156.7 1.712 241.95 -86.22 [1] 156.7 156.8 12.973 128.48 -9.76 [1] 156.7 156.8 12.975 128.57 -9.82 [1] 156.7 156.8 12.975 128.61 -9.82 [1] 156.8 5.115 354.01 2.57 [1] 156.8 5.906 181.07 -1.30 [1] 156.8 5.017 174.58 84.02 [1] 156.8 1.511 132.53 -81.84 [1] 156.8 13.390 235.87 7.15 [1] 156.8 4.134 271.01 46.40 [1] 156.8 156.9 5.842 89.35 1.87 [1] 156.8 156.9 5.839 89.31 1.83 [1] 156.8 156.9 5.839 89.43 1.79 [1] 156.9 127.0 0.000 0.00 0.00 [1] 156.9 4.619 19.88 -7.87 [1] 156.9 14.511 183.22 24.27 [1] 156.9 4.472 145.46 80.50 [1] 156.9 156.10 11.809 117.69 18.69 [1] 156.9 156.10 11.809 117.59 18.69 [1] 156.9 156.10 11.811 117.69 18.70 [1] 156.10 5.381 40.87 -12.73 [1] 156.10 15.757 211.64 3.96 [1] 156.10 2.391 262.28 85.82 [1] 156.10 8.082 203.51 -24.97 [1] 156.10 156.11 17.550 168.45 -7.49 [1] 156.10 156.11 17.521 168.46 -7.50 [1] 156.10 156.11 17.519 168.43 -7.53 [1] 156.11 11.161 40.65 22.54 [1] 156.11 5.811 202.33 -0.42 [1] 156.11 4.416 170.80 84.77 [1] 156.11 2.043 127.28 -88.53 [1] 156.11 156.12 16.732 148.80 -11.28 [1] 156.11 156.12 16.721 148.91 -11.33 [1] 156.11 156.12 16.730 148.87 -11.28 [1] 156.12 10.776 54.37 20.06 [1] 156.12 2.977 221.85 -4.24 [1] 156.12 5.149 185.63 84.72 [1] 156.12 2.270 188.16 -80.50 [1] 156.12 156.13 15.139 118.82 -5.89 [1] 156.12 156.13 15.139 118.82 -5.91 [1] 156.12 156.13 15.134 118.70 -5.87 [1] 156.13 1.673 61.44 5.64 [1] 156.13 7.796 233.20 3.15 [1] 156.13 6.120 304.49 0.88 [1] 156.13 3.606 348.94 1.85 [1] 156.13 5.067 331.32 -2.18 [1] 156.13 6.896 69.83 84.81 [1] 156.13 0.445 268.26 -88.34 [1] 156.13 156.14 12.563 158.14 3.41 [1] 156.13 156.14 12.564 158.04 3.44 [1] 156.13 156.14 12.563 158.07 3.44 [1] 156.14 3.844 53.87 -4.42 [1] 156.14 3.119 227.31 2.93 [1] 156.14 5.528 300.37 87.43 [1] 156.14 1.627 169.51 -86.65 [1] 156.14 156.15 20.984 142.26 0.98 [1] 156.14 156.15 20.986 142.23 1.04 [1] 156.14 156.15 20.988 142.18 1.05 [1] 156.15 3.368 59.85 -7.03 [1] 156.15 6.875 228.82 -1.60 [1] 156.15 1.806 165.82 -81.12 [1] 156.15 7.308 156.10 87.72 [1] 156.15 156.16 14.275 159.71 1.84 [1] 156.15 156.16 14.276 159.70 1.84 [1] 156.15 156.16 14.276 159.67 1.84 [1] 156.16 3.988 50.15 5.15 [1] 156.16 6.304 223.94 0.27 [1] 156.16 6.757 212.56 82.75 [1] 156.16 2.158 75.37 -85.02 [1] 156.16 7.348 53.81 -19.26 [1] 156.16 156.17 10.367 162.95 2.52 [1] 156.16 156.17 10.364 162.98 2.42 [1] 156.16 156.17 10.367 163.01 2.53 [1] 156.17 8.027 85.24 5.30 [1] 156.17 4.577 268.81 4.80 [1] 156.17 7.078 117.31 85.78 [1] 156.17 1.673 30.75 -87.87 [1] 156.17 11.569 65.79 -12.79 [1] 156.17 156.18 7.843 126.74 -11.50 [1] 156.17 156.18 7.852 126.60 -11.44 [1] 156.17 156.18 7.852 126.55 -11.49 [1] 156.18 9.038 57.55 -6.54 [1] 156.18 12.852 221.83 12.63 [1] 156.18 5.779 227.99 82.52 [1] 156.18 1.204 269.82 -79.45 [1] 156.18 9.671 145.31 -10.88 [1] 156.18 10.526 166.40 -10.22 [1] 156.18 8.326 104.33 -11.12 [1] 156.18 156.19 23.709 157.38 -4.42 [1] 156.18 156.19 23.700 157.26 -4.35 [1] 156.18 156.19 23.702 157.42 -4.35 [1] 156.19 9.339 73.19 10.78 [1] 156.19 11.843 245.81 12.69 [1] 156.19 1.166 287.39 83.26 [1] 156.19 2.420 51.41 38.56 [1] 156.19 156.20 13.185 101.94 26.53 [1] 156.19 156.20 13.149 102.01 26.46 [1] 156.19 156.20 13.139 101.85 26.53 [1] 156.20 8.130 59.17 2.11 [1] 156.20 3.988 319.43 -1.32 [1] 156.20 19.284 269.18 2.35 [1] 156.20 21.108 255.42 1.62 [1] 156.20 9.955 233.12 -18.11 [1] 156.20 1.902 168.29 81.35 [1] 156.20 12.668 132.37 13.97 [1] 156.20 156.21 14.462 145.26 8.28 [1] 156.20 156.21 14.460 145.32 8.26 [1] 156.20 156.21 14.464 145.37 8.28 [1] 156.21 14.256 78.44 8.06 [1] 156.21 3.685 250.66 -18.99 [1] 156.21 7.179 227.58 -16.64 [1] 156.21 12.386 206.43 -26.43 [1] 156.21 16.364 186.99 -21.04 [1] 156.21 17.979 167.17 -10.43 [1] 156.21 21.266 136.38 4.37 [1] 156.21 18.968 113.75 8.27 [1] 156.21 1.580 137.96 69.16 [1] 156.21 0.839 62.80 -88.10 [1] 156.21 9.404 19.51 12.23 [1] 156.21 156.22 10.999 140.38 13.29 [1] 156.21 156.22 10.996 140.43 13.40 [1] 156.21 156.22 10.994 140.43 13.33 [1] 156.22 17.998 237.95 -37.04 [1] 156.22 12.636 198.26 -39.64 [1] 156.22 15.783 148.75 -25.36 [1] 156.22 16.363 126.26 -16.70 [1] 156.22 11.772 93.31 -5.76 [1] 156.22 13.482 67.73 -1.47 [1] 156.22 13.786 35.24 -1.65 [1] 156.22 156.23 19.386 47.04 -3.35 [1] 156.22 156.23 19.388 47.10 -3.41 [1] 156.22 156.23 19.388 47.06 -3.41 [1] 156.23 7.241 83.01 -21.44 [1] 156.23 8.473 183.50 1.18 [1] 156.23 10.477 171.25 -0.49 [1] 156.23 7.107 147.60 -3.96 [1] 156.23 156.24 12.258 182.64 0.90 [1] 156.23 156.24 12.256 182.50 0.91 [1] 156.23 156.24 12.259 182.58 0.83 [1] 156.24 1.920 82.91 0.63 [1] 156.24 1.151 120.51 84.75 [1] 156.24 0.925 76.07 -84.15 [1] 156.24 156.25 9.369 136.98 -31.91 [1] 156.24 156.25 9.373 136.99 -31.91 [1] 156.24 156.25 9.374 136.99 -31.85 [1] 156.25 1.155 119.38 3.47 [1] 156.25 2.938 355.15 23.42 [1] 156.25 3.686 310.01 86.34 [1] 156.25 0.328 193.17 -87.50 [1] 156.25 156.26 16.108 66.35 8.77 [1] 156.25 156.26 16.122 66.25 8.83 [1] 156.25 156.26 16.117 66.24 8.86 [1] 156.26 4.087 231.84 0.23 [1] 156.26 1.485 42.67 87.21 [1] 156.26 0.596 329.87 -86.96 [1] 156.26 156.27 20.526 208.25 -0.28 [1] 156.26 156.27 20.528 208.27 -0.27 [1] 156.26 156.27 20.525 208.23 -0.21 [1] 156.27 1.974 300.95 -6.53 [1] 156.27 3.695 311.97 80.68 [1] 156.27 1.849 292.76 -79.95 [1] 156.27 156.28 23.080 217.47 -11.63 [1] 156.27 156.28 23.075 217.44 -11.67 [1] 156.27 156.28 23.083 217.50 -11.67 [1] 156.28 2.876 128.79 -0.08 [1] 156.28 6.224 310.56 2.64 [1] 156.28 8.322 349.65 84.55 [1] 156.28 28.386 23.01 54.31 [1] 156.28 13.961 7.70 59.65 [1] 156.28 12.779 4.70 10.78 [1] 156.28 8.894 49.16 13.35 [1] 156.28 156.29 9.439 337.59 -7.19 [1] 156.28 156.29 9.441 337.60 -7.15 [1] 156.28 156.29 9.436 337.49 -7.09 [1] 156.29 2.879 283.39 -6.23 [1] 156.29 10.427 124.26 14.34 [1] 156.29 0.851 25.33 78.60 [1] 156.29 1.758 324.20 -83.85 [1] 156.29 156.30 11.120 26.68 -1.43 [1] 156.29 156.30 11.120 26.64 -1.41 [1] 156.29 156.30 11.119 26.60 -1.51 [1] 156.30 4.372 251.83 1.05 [1] 156.30 8.095 252.77 -8.28 [1] 156.30 13.295 274.36 -5.31 [1] 156.30 5.945 168.28 4.29 [1] 156.30 3.359 125.62 9.29 [1] 156.30 11.331 60.91 17.00 [1] 156.30 6.484 357.65 15.32 [1] 156.30 156.31 7.376 59.14 18.25 [1] 156.30 156.31 7.377 59.14 18.23 [1] 156.30 156.31 7.378 59.11 18.22 [1] 156.31 6.381 284.87 4.02 [1] 156.31 3.277 81.68 10.06 [1] 156.31 1.653 268.12 86.30 [1] 156.31 0.814 305.44 -85.22 [1] 156.31 156.25 7.676 9.38 10.39 [1] 156.31 156.25 7.673 9.33 10.34 [1] 156.31 156.25 7.672 9.48 10.33 [1] 156.28 156.32 0.000 0.00 0.00 [1] 156.32 2.868 117.70 -1.62 [1] 156.32 6.256 302.62 9.50 [1] 156.32 7.767 227.86 81.72 [1] 156.32 1.774 169.28 -67.64 [1] 156.32 156.33 26.566 219.44 -1.19 [1] 156.32 156.33 26.564 219.46 -1.25 [1] 156.32 156.33 26.566 219.44 -1.19 [1] 156.33 2.532 307.33 4.40 [1] 156.33 3.357 124.91 2.33 [1] 156.33 5.201 170.50 89.34 [1] 156.33 3.235 328.02 -70.36 [1] 156.33 6.562 290.15 -24.69 [1] 156.33 156.34 30.489 226.77 -3.53 [1] 156.33 156.34 30.484 226.81 -3.51 [1] 156.33 156.34 30.485 226.72 -3.53 [1] 156.34 5.858 236.75 -3.69 [1] 156.34 4.039 262.63 -3.89 [1] 156.34 8.402 95.41 4.69 [1] 156.34 9.614 62.57 84.14 [1] 156.34 1.348 158.37 -84.56 [1] 156.34 156.35 24.033 125.74 -0.09 [1] 156.34 156.35 24.016 125.70 -0.01 [1] 156.34 156.35 24.016 125.77 -0.12 [1] 156.35 2.683 30.69 -5.75 [1] 156.35 2.813 197.88 -14.73 [1] 156.35 0.727 66.43 86.00 [1] 156.35 1.575 127.05 -83.96 [1] 156.35 156.36 4.417 104.52 6.16 [1] 156.35 156.36 4.423 104.71 5.99 [1] 156.35 156.36 4.417 104.71 5.91 [1] 156.36 2.493 21.29 -22.90 [1] 156.36 2.244 260.57 -1.29 [1] 156.36 5.819 217.21 86.87 [1] 156.36 1.892 140.80 -83.24 [1] 156.36 9.410 213.65 -13.20 [1] 156.36 156.37 10.681 164.01 12.18 [1] 156.36 156.37 10.681 163.95 12.18 [1] 156.36 156.37 10.688 164.10 12.13 [1] 156.37 3.803 53.48 -4.48 [1] 156.37 6.189 229.59 9.87 [1] 156.37 6.078 146.27 82.26 [1] 156.37 8.285 10.38 -30.58 [1] 156.37 156.38 12.554 153.03 -2.14 [1] 156.37 156.38 12.551 152.97 -2.10 [1] 156.37 156.38 12.552 153.06 -2.18 [1] 156.38 2.415 41.61 -6.10 [1] 156.38 10.270 228.39 1.96 [1] 156.38 6.308 200.74 84.49 [1] 156.38 5.415 81.95 -50.82 [1] 156.38 156.39 26.215 114.86 -7.26 [1] 156.38 156.39 26.214 114.87 -7.29 [1] 156.38 156.39 26.213 114.79 -7.27 [1] 156.39 3.396 52.39 6.37 [1] 156.39 20.495 219.16 10.44 [1] 156.39 13.281 207.48 46.99 [1] 156.39 9.497 182.35 -22.41 [1] 156.39 156.40 26.685 165.86 -1.74 [1] 156.39 156.40 26.689 165.92 -1.76 [1] 156.39 156.40 26.689 165.99 -1.72 [1] 156.40 8.666 60.90 12.75 [1] 156.40 15.330 247.49 12.29 [1] 156.40 10.782 304.71 85.18 [1] 156.40 2.294 6.12 -84.82 [1] 156.40 156.41 29.350 157.69 4.29 [1] 156.40 156.41 29.349 157.53 4.22 [1] 156.40 156.41 29.347 157.70 4.26 [1] 156.41 10.618 252.68 11.74 [1] 156.41 12.751 22.64 8.50 [1] 156.41 7.880 18.58 78.68 [1] 156.41 22.876 13.29 8.03 [1] 156.41 12.847 343.23 -24.55 [1] 156.41 156.42 25.137 123.66 -2.35 [1] 156.41 156.42 25.129 123.63 -2.36 [1] 156.41 156.42 25.133 123.57 -2.35 [1] 156.42 4.459 66.37 20.49 [1] 156.42 21.374 242.80 10.60 [1] 156.42 10.424 232.44 63.69 [1] 156.42 7.432 221.79 -41.05 [1] 156.42 13.883 308.37 1.63 [1] 156.42 156.43 24.150 168.89 -8.71 [1] 156.42 156.43 24.151 168.93 -8.73 [1] 156.42 156.43 24.152 168.90 -8.73 [1] 156.43 14.396 256.04 21.06 [1] 156.43 10.067 101.29 29.82 [1] 156.43 12.510 150.27 86.71 [1] 156.43 2.000 248.22 -77.51 [1] 156.43 156.44 13.326 168.43 10.44 [1] 156.43 156.44 13.324 168.25 10.49 [1] 156.43 156.44 13.324 168.37 10.50 [1] 156.44 4.831 75.77 6.03 [1] 156.44 18.290 275.87 11.43 [1] 156.44 10.208 26.26 77.78 [1] 156.44 7.368 297.13 -41.78 [1] 156.44 6.217 274.92 -17.88 [1] 156.44 156.45 28.902 189.23 16.41 [1] 156.44 156.45 28.898 189.32 16.47 [1] 156.44 156.45 28.904 189.38 16.47 [1] 156.45 10.630 135.54 9.88 [1] 156.45 9.581 280.49 -1.90 [1] 156.45 3.411 209.50 87.61 [1] 156.45 4.305 270.17 -67.62 [1] 156.45 156.46 22.480 194.02 5.15 [1] 156.45 156.46 22.478 194.00 5.08 [1] 156.45 156.46 22.485 194.09 5.19 [1] 156.46 14.529 63.91 5.51 [1] 156.46 6.659 255.94 -22.06 [1] 156.46 1.685 238.04 77.50 [1] 156.46 12.990 117.87 8.99 [1] CaveConverter_src/test/data/regression/SwilEnt_ss_cmdnl_ref.svx0000644000000000000000000003232012242115744024110 0ustar rootroot*BEGIN Swildons *EQUATE Ent EntranceZigZags.3 *EQUATE surfacegps.4 EntranceZigZags.3 *EQUATE LongDryWay.0 EntranceZigZags.5 *EQUATE LongDryWay.5 EntranceZigZags.21 *EQUATE LongDryWay.5 ShortDryWay.pt1.0 *EQUATE LongDryWay.39 NewGrottoes.0 *EQUATE LongDryWay.62 OldGrotto2WC.4 *EQUATE LongDryWay.59 OldGrotto2WC.0 *EQUATE LongDryWay.59 ShortDryWay.pt2.3 *EQUATE WaterRift.0 OldGrotto2WC.11 *EQUATE WaterRift.4 FortyRoute.0 *EQUATE WaterRift.12 FortyRoute.11 *EQUATE 10.0 LongDryWay.8 *EQUATE 10.20 LongDryWay.2 *EQUATE 10.13 20.20 *EQUATE 10.18 20.27 *EQUATE 20.0 EntranceZigZags.5 *EQUATE 20.23 ShortDryWay.pt1.3 *EQUATE 20.19 EntranceZigZags.5 *BEGIN surfacegps *DATE 2013.06.30 *CALIBRATE declination 1.58 *FLAGS SURFACE 0 1 9.84 94.37 -5.88 1 2 7.84 97.65 -8.05 2 3 11.76 94.27 -17.67 3 4 4.38 7.38 -23.29 3 5 5.45 262.93 13.06 5 6 8.80 174.95 11.61 6 7 13.78 168.31 12.55 *END surfacegps *BEGIN EntranceZigZags *DATE 2012.09.09 *CALIBRATE declination 1.7 *FLAGS SURFACE 0 1 2.98 10.26 -2.01 0 2 5.24 3.23 -5.04 2 3 2.64 166.70 -60.11 *FLAGS NOT SURFACE 3 4 3.10 330.76 -25.13 4 5 4.51 275.80 -12.10 5 6 2.41 50.67 -22.33 6 7 1.08 37.30 11.53 7 8 2.00 6.10 11.51 8 9 1.01 56.60 0.18 9 10 3.07 336.52 5.81 9 11 2.42 64.64 5.29 11 12 4.50 106.56 19.29 10 13 0.94 80.55 -45.63 13 14 5.31 65.16 19.50 10 15 3.27 329.15 -18.16 15 16 3.57 334.08 -6.33 16 17 2.41 207.98 -9.43 17 18 4.05 308.01 -19.25 18 19 2.06 211.48 -16.06 19 20 2.94 233.55 -35.84 20 21 2.04 14.57 -39.09 *data passage station left right up down 3 0.30 0.38 0.91 0.44 4 0.56 0.00 1.50 1.32 5 1.98 4.15 0.69 0.51 6 0.49 0.19 0.35 0.29 7 0.57 1.89 0.73 4.09 8 0.00 1.34 0.15 1.08 9 0.37 0.00 0.43 0.45 11 0.13 1.70 0.32 0.39 12 1.63 0.57 0.25 0.26 *data passage station left right up down 9 0.59 0.00 0.43 0.45 10 0.54 2.34 2.94 1.12 13 0.50 1.07 0.70 0.21 14 0.54 2.05 0.20 0.43 *data passage station left right up down 10 1.97 1.10 2.94 1.12 15 2.15 0.75 0.69 0.79 16 0.83 0.18 1.50 0.62 17 1.38 1.29 0.00 1.46 18 1.46 0.39 0.25 0.68 19 0.00 0.44 0.52 1.54 20 0.00 0.89 1.54 1.61 21 1.16 0.21 2.86 0.20 *END EntranceZigZags *BEGIN LongDryWay *DATE 2013.02.23 *CALIBRATE declination 1.63 *EQUATE 44 46 0 1 4.08 270.72 -25.50 1 2 3.77 354.35 -29.81 2 3 4.33 336.10 -24.79 3 4 2.77 337.70 -4.41 4 5 3.14 343.71 -25.59 5 6 1.87 332.43 6.50 6 7 2.26 343.32 -5.29 7 8 1.72 258.62 12.28 7 9 1.10 310.47 4.46 9 10 2.37 334.59 4.19 10 11 1.12 263.77 46.91 11 12 3.53 351.74 -3.89 12 13 1.97 312.50 39.30 13 14 2.39 28.12 3.33 14 15 0.86 306.09 -13.02 15 16 4.55 48.38 7.37 16 17 2.34 328.01 -9.83 17 18 2.65 86.23 -7.24 18 19 0.84 146.67 18.49 19 20 1.81 87.93 13.23 20 21 1.73 164.45 7.33 21 22 2.91 113.95 7.56 22 23 1.51 181.21 30.14 23 24 4.59 108.18 -8.18 24 25 3.22 188.75 35.45 25 26 4.13 139.60 16.69 25 27 4.94 97.33 39.05 24 28 2.78 323.60 -24.94 28 29 0.89 90.00 -48.92 29 30 6.28 324.60 -29.83 30 31 1.55 264.23 41.75 31 32 2.26 15.83 12.57 32 35 6.03 323.45 -41.61 31 34 5.13 314.22 -30.46 34 35 2.76 19.79 -19.74 35 36 4.45 91.00 26.23 36 37 6.61 112.79 18.69 37 38 3.92 158.52 22.40 38 39 5.06 158.54 15.55 39 40 3.30 137.29 35.75 40 41 1.54 156.92 21.03 41 42 1.23 188.42 54.13 35 43 7.82 271.86 -10.72 43 44 1.58 132.75 -54.76 43 45 4.22 283.16 -3.82 46 47 4.08 278.14 -22.89 47 48 1.62 127.59 7.41 45 49 2.40 265.00 1.41 49 50 2.06 297.62 28.08 50 51 2.38 317.24 16.74 51 52 2.80 335.01 -5.36 52 53 8.00 77.58 15.81 52 54 2.99 251.79 -11.14 54 55 2.75 287.69 -14.31 55 56 6.04 280.29 -11.16 56 57 4.72 167.79 -69.81 57 58 6.26 266.27 3.98 58 59 5.34 221.34 -28.43 59 60 3.64 249.87 -18.27 60 61 6.14 188.00 -36.35 61 62 1.04 31.64 -42.73 *data passage station left right up down 0 0.56 1.35 0.66 0.56 1 1.13 1.96 0.45 1.49 2 0.64 0.92 0.73 1.92 3 0.44 0.45 1.17 0.48 4 1.02 0.00 1.94 1.36 5 1.73 0.62 2.74 0.23 6 1.12 0.32 2.49 0.46 7 1.10 0.00 1.41 0.51 8 0.55 0.00 0.88 0.81 *data passage station left right up down 7 1.12 0.00 1.41 0.51 9 0.85 0.56 0.83 0.57 10 0.39 0.24 2.18 0.43 11 0.00 0.62 1.41 0.97 12 0.77 0.00 0.88 0.00 13 0.00 0.86 0.46 1.02 14 1.47 0.00 0.48 0.59 15 0.61 0.45 0.40 0.41 16 2.24 0.00 0.86 1.51 17 0.00 1.46 1.20 0.00 18 0.48 1.95 0.40 0.51 19 1.33 0.33 0.40 0.00 20 0.59 0.86 1.46 0.00 21 0.65 0.00 1.19 0.25 22 1.22 0.84 1.30 0.40 23 1.27 0.19 0.40 1.21 24 3.04 1.76 1.43 0.00 25 3.11 1.05 0.86 0.00 26 1.08 0.48 0.56 0.52 *data passage station left right up down 25 2.42 1.16 0.86 0.00 27 0.16 3.08 0.34 0.00 *data passage station left right up down 24 1.76 3.04 1.43 0.00 28 0.00 0.00 1.98 1.15 29 0.65 0.60 0.61 1.14 30 1.46 0.28 1.86 0.43 31 0.39 1.14 0.97 1.50 32 0.68 0.00 0.38 0.76 35 0.55 0.93 3.48 0.00 36 3.45 2.23 2.46 0.38 37 1.23 2.15 2.77 0.50 38 1.04 1.09 2.53 0.83 39 2.01 1.86 0.80 0.31 40 0.58 0.42 0.40 0.00 41 0.98 0.71 1.17 0.00 42 1.03 0.18 0.28 0.00 *data passage station left right up down 31 0.43 1.37 0.97 1.50 34 0.00 1.36 1.60 0.71 35 0.93 0.55 3.48 0.00 43 0.63 0.60 2.82 1.69 45 1.00 0.26 2.12 0.91 49 1.24 0.87 2.24 0.70 50 0.41 0.00 0.69 0.76 51 1.79 0.65 0.34 3.97 52 1.39 0.00 0.66 1.10 54 0.00 1.44 1.32 4.82 55 0.45 1.74 1.92 4.57 56 0.00 0.91 0.87 5.41 57 0.47 0.00 5.50 0.76 58 2.05 0.88 2.44 0.74 59 2.29 5.14 2.99 0.67 60 3.49 1.16 1.60 2.35 61 0.00 0.00 4.26 3.24 *data passage station left right up down 46 0.00 1.08 0.73 0.00 47 0.00 0.00 1.09 0.58 48 0.00 2.53 0.42 0.71 *END LongDryWay *BEGIN ShortDryWay *EQUATE pt1.13 pt2.0 *BEGIN pt1 *DATE 2013.02.24 *CALIBRATE declination 1.63 0 1 1.43 131.61 -13.25 1 2 3.89 73.29 -51.63 2 3 4.50 170.72 19.68 3 4 1.11 246.49 -14.16 2 5 4.91 323.66 2.34 5 6 5.05 279.35 -25.23 6 7 5.02 336.36 -13.85 7 8 3.19 303.08 -33.11 8 9 6.71 295.69 -12.15 9 10 1.11 265.93 2.35 10 11 4.30 323.22 3.80 11 12 3.28 275.99 -17.30 12 13 4.68 298.00 -3.29 *data passage station left right up down 0 0.00 0.00 0.00 0.00 1 0.41 0.87 0.00 0.28 2 0.00 1.63 1.81 0.46 3 0.31 0.26 1.53 0.92 4 0.00 2.09 0.55 0.68 *data passage station left right up down 2 1.63 0.00 1.81 0.46 5 1.00 0.32 1.55 0.86 6 0.00 1.25 2.73 1.16 7 0.41 0.00 3.68 0.54 8 0.00 1.37 4.40 1.42 9 1.02 0.00 1.15 1.06 10 0.00 0.45 0.84 1.15 11 0.64 0.00 2.05 1.59 12 0.00 0.52 1.75 0.81 13 0.00 0.57 0.38 0.72 *END pt1 *BEGIN pt2 *DATE 2013.02.24 *CALIBRATE declination 1.63 0 1 3.20 316.66 0.98 1 2 7.10 308.84 -15.08 2 3 4.24 278.91 -12.53 *data passage station left right up down 0 0.00 0.56 2.73 0.76 1 0.00 0.57 2.40 1.46 2 0.65 0.00 2.87 0.80 3 0.00 0.00 3.16 0.77 *END pt2 *END ShortDryWay *BEGIN NewGrottoes *DATE 2013.02.24 *CALIBRATE declination 1.63 0 1 1.56 49.36 7.27 1 2 1.75 10.53 51.20 2 3 4.07 347.52 12.12 3 4 3.62 50.60 25.22 4 5 3.25 67.67 12.62 5 6 3.45 56.57 19.52 6 7 1.42 151.95 -12.13 7 8 6.30 84.91 26.43 *data passage station left right up down 0 0.00 0.00 0.00 0.00 1 0.42 0.08 0.39 0.73 2 0.29 0.00 0.68 0.86 3 0.92 0.62 0.41 0.44 4 2.01 1.51 0.00 0.88 5 2.12 0.90 0.25 0.77 6 0.52 3.62 0.00 0.56 7 1.16 2.64 0.89 0.44 8 0.81 0.31 0.19 0.35 *END NewGrottoes *BEGIN OldGrotto2WC *DATE 2013.02.24 *CALIBRATE declination 1.63 0 1 3.32 25.03 -14.33 1 2 5.70 255.27 -30.20 2 3 3.09 201.53 -10.26 3 4 4.55 164.72 -15.92 4 5 2.38 199.29 -26.79 5 6 6.29 239.56 -9.79 6 7 7.66 284.16 -7.14 7 8 2.58 224.20 -8.54 8 9 6.80 205.89 -6.51 9 10 2.09 108.56 -5.31 10 11 7.85 204.84 6.96 *data passage station left right up down 0 0.00 0.00 0.00 0.00 1 2.39 0.00 0.00 0.86 2 0.97 0.38 1.20 1.13 3 0.88 1.27 0.32 0.93 4 0.63 0.59 5.52 2.45 5 0.71 0.81 5.21 1.53 6 0.23 1.80 3.96 1.44 7 1.04 0.00 5.90 1.22 8 0.00 1.49 5.11 1.06 9 1.39 0.00 3.26 1.26 10 0.00 1.68 5.06 1.15 11 4.27 5.18 3.22 1.00 *END OldGrotto2WC *BEGIN FortyRoute *DATE 2013.06.29 *CALIBRATE declination 1.58 0 1 2.76 327.91 18.03 1 2 5.35 306.91 5.35 2 3 3.55 321.41 38.17 3 4 1.12 7.71 3.63 4 5 1.06 263.40 33.43 5 6 2.53 351.94 5.11 6 7 2.96 317.31 -3.31 7 8 5.25 326.28 -29.19 8 9 1.45 273.15 -22.26 9 10 7.65 252.29 -71.60 10 11 2.32 146.39 -8.38 *data passage station left right up down 0 1.18 0.00 1.01 1.46 1 1.80 0.00 5.92 3.29 2 0.20 0.91 2.13 5.12 3 0.24 0.78 2.32 3.23 4 0.67 0.00 2.18 0.63 5 0.00 0.57 1.59 1.15 6 0.51 0.00 1.41 1.13 7 0.00 0.47 1.66 1.64 8 0.81 1.04 1.74 1.09 9 0.73 0.30 4.17 2.68 10 2.78 0.00 0.00 1.91 11 0.43 0.86 1.55 1.73 *END FortyRoute *BEGIN WaterRift *DATE 2013.06.29 *CALIBRATE declination 1.58 0 1 5.77 334.28 -11.88 1 2 4.33 195.52 -26.62 2 3 6.36 270.39 -36.08 3 4 1.54 305.04 -17.83 4 5 4.45 302.01 -20.17 5 6 2.13 320.38 -11.71 6 7 5.02 333.92 -11.98 7 8 1.63 323.46 -34.24 8 9 6.72 325.55 -5.61 9 10 2.39 1.38 10.24 10 11 3.73 245.25 -24.06 11 12 1.75 211.67 -24.54 12 13 8.34 181.38 -8.14 13 14 4.39 179.79 -2.78 14 15 7.89 176.25 -1.64 15 16 4.52 194.00 -4.00 *data passage station left right up down 0 6.74 3.41 1.95 0.00 1 1.52 0.00 3.73 1.75 2 0.25 0.75 0.70 1.02 3 0.00 0.60 7.22 1.50 4 1.18 0.00 5.86 1.80 5 0.00 0.66 0.78 1.18 6 0.00 0.40 1.32 0.97 7 0.32 0.00 3.07 1.41 8 0.73 0.00 2.19 0.57 9 0.00 0.65 1.18 0.38 10 0.81 0.43 2.51 1.00 11 0.47 0.78 10.85 2.38 12 0.56 0.84 1.63 1.74 13 0.20 0.83 3.40 0.81 14 0.00 1.52 3.09 0.84 15 0.42 0.39 3.04 0.98 16 1.81 1.13 1.35 0.91 *END WaterRift *BEGIN 10 *DATE 2013.06.30 *CALIBRATE declination 1.58 0 1 2.19 193.96 16.02 1 2 1.14 228.14 32.64 2 3 3.27 163.30 -22.86 3 4 6.91 267.13 3.53 3 5 2.54 190.56 -63.18 5 6 4.59 251.07 -25.44 6 7 2.94 167.27 7.15 7 8 3.72 165.59 -0.44 8 9 2.10 111.50 19.76 9 10 7.71 161.72 1.86 10 11 2.16 102.08 5.76 9 12 8.35 93.72 17.83 12 13 4.34 9.47 9.01 13 14 2.15 152.81 2.05 13 15 3.68 88.63 11.54 15 16 5.88 47.35 18.38 16 17 5.34 79.73 18.79 3 18 1.80 104.97 -49.81 14 20 3.88 295.15 51.22 *data passage station left right up down 0 0.75 0.00 0.88 0.81 1 0.21 0.53 1.13 0.86 2 0.65 0.39 0.85 1.15 3 0.70 0.29 1.68 1.79 4 0.55 0.32 0.38 0.44 *data passage station left right up down 3 0.65 0.26 1.68 1.79 5 0.00 0.60 0.00 0.63 6 0.86 0.23 0.49 0.00 7 0.00 0.62 0.19 1.57 8 0.73 0.00 0.41 1.07 9 1.38 1.52 0.21 1.09 10 0.32 0.35 0.63 0.63 *data passage station left right up down 9 0.25 2.80 0.21 1.09 12 1.65 0.50 0.44 0.44 13 0.20 0.00 0.00 0.65 15 1.14 0.58 0.49 0.30 16 0.54 1.43 0.27 0.00 17 1.62 0.86 2.11 0.65 *data passage station left right up down 13 0.00 0.43 0.00 0.65 14 0.00 2.86 3.76 0.00 *data passage station left right up down 3 0.29 0.70 1.68 1.79 18 0.22 0.73 0.24 0.00 *END 10 *BEGIN 20 *DATE 2013.06.30 *CALIBRATE declination 1.58 0 1 3.87 261.79 -26.31 1 2 2.55 125.69 -19.31 2 3 5.29 150.86 -7.60 3 4 1.83 63.94 -43.21 4 5 3.13 176.57 -12.17 5 6 1.40 257.65 -52.47 6 7 2.40 284.49 -13.04 3 8 2.58 64.30 1.85 8 9 2.80 61.94 1.42 9 10 5.67 274.30 -29.92 10 11 4.21 315.24 -5.18 11 12 0.46 277.24 -49.35 12 13 2.99 11.93 3.89 13 14 1.51 326.89 1.17 13 15 4.27 118.28 31.59 15 16 2.48 36.12 13.37 16 17 3.13 327.92 82.94 17 18 1.35 214.32 -12.67 18 19 2.43 231.25 22.63 13 20 2.14 331.93 -1.84 20 21 2.84 49.23 -61.41 21 22 1.87 345.57 -9.57 22 23 1.63 311.27 20.13 23 24 1.57 250.05 -33.27 24 25 2.11 302.88 3.36 25 26 2.60 267.02 31.57 27 26 1.86 143.63 -4.35 *data passage station left right up down 0 0.00 0.00 0.00 0.00 1 0.00 0.00 0.00 0.00 2 0.23 1.76 3.38 0.77 3 0.90 0.00 0.18 0.51 4 0.14 0.26 0.71 0.55 5 0.34 0.35 0.87 0.39 6 0.00 0.34 0.50 0.18 7 0.40 0.00 0.23 0.35 *data passage station left right up down 3 0.90 0.00 0.18 0.51 8 0.97 1.31 0.38 1.78 9 0.00 1.90 1.09 0.84 10 1.22 3.45 0.67 0.23 11 0.83 0.46 0.00 0.48 12 0.21 0.00 0.00 0.00 13 4.13 2.90 1.39 0.30 15 1.61 0.98 0.28 0.86 16 2.24 0.00 0.00 1.10 17 0.00 0.10 0.69 0.29 18 0.00 0.00 0.00 0.00 *data passage station left right up down 13 2.88 4.11 1.39 0.30 20 0.00 0.41 0.35 1.24 21 0.36 0.23 0.29 0.00 22 0.82 0.21 0.78 0.31 23 0.29 0.25 0.19 0.99 24 0.00 0.43 1.06 0.00 25 0.45 0.28 0.70 0.36 26 0.36 0.45 0.00 0.45 27 0.23 0.41 0.24 0.00 *END 20 *END Swildons CaveConverter_src/test/data/regression/Crossover_in.svx0000644000000000000000000000037412120711032022447 0ustar rootroot*begin CrossTest *equate Leg1.3 Leg2.4 *begin Leg1 1 2 1.1 350 0 2 3 1.2 0 0 3 4 1.3 10 0 4 5 1.4 5 0 5 6 1.5 355 0 *end Leg1 *begin Leg2 1 2 2.1 90 0 2 3 2.2 80 0 3 4 2.3 100 0 4 5 2.4 95 0 5 6 2.5 85 0 *end Leg2 *end CrossTestCaveConverter_src/test/data/regression/Swil20120909_ps_ref.svx0000644000000000000000000001352712226766252023130 0ustar rootroot*BEGIN Swil20120909 *BEGIN 1 *DATE 2012.09.09 0 1 2.98 10.26 -2.01 ;1.1 has magnetic problems. So surveyed to it from knot on tree opposite door=1.0\rThen from knot to rear wall of blockhouse 1.0-1.2 0 2 5.24 3.23 -5.04 ;1.2=rawl plug on rear wall of blockhouse *FLAGS SPLAY 2 2a 5.24 182.16 5.06 2 2b 1.89 187.97 3.09 2 2c 1.91 168.82 1.18 2 2d 1.38 218.59 -0.17 2 2e 0.64 248.05 1.54 2 2f 0.68 105.32 -3.30 2 2g 1.56 140.40 -2.98 2 2h 1.84 176.52 -47.48 2 2i 1.82 167.81 -47.93 2 2j 1.54 189.90 -63.97 2 2k 1.61 132.31 -59.62 *FLAGS NOT SPLAY 2 3 2.64 166.70 -60.11 ;1.3=Top left corner of stream culvert when looking out of cave *FLAGS SPLAY 3 3a 0.22 345.81 60.30 3 3b 2.63 347.89 60.51 3 3c 0.94 9.90 76.67 3 3d 0.31 232.08 12.34 3 3e 0.35 31.05 10.29 3 3f 0.47 8.50 -70.77 *FLAGS NOT SPLAY 3 4 3.10 330.76 -25.13 *FLAGS SPLAY 4 4a 3.12 152.39 25.35 4 4b 0.56 208.59 -0.68 4 4c 0.59 140.67 80.22 4 4d 1.32 189.06 -86.08 4 4e 1.50 43.79 87.42 *FLAGS NOT SPLAY 4 5 4.51 275.80 -12.10 ;1.5=polished tip of pointy boulder by top of drop into lower level of chamber. Boulder is dark grey with white flecks and fossils. *FLAGS SPLAY 5 5a 4.51 94.74 12.12 5 5b 3.45 123.81 5.64 5 5c 3.51 134.15 0.14 5 5d 6.66 129.46 11.11 5 5e 2.32 149.61 -6.69 5 5f 1.64 153.47 -11.17 5 5g 0.79 252.58 -12.22 5 5h 1.22 296.10 -7.82 5 5i 2.96 296.71 -23.02 5 5j 1.51 42.54 10.51 5 5k 4.24 72.82 11.85 5 5l 0.70 333.90 81.49 5 5m 0.55 114.68 -67.13 *FLAGS NOT SPLAY 5 6 2.41 50.67 -22.33 *FLAGS SPLAY 6 6a 2.38 230.76 22.40 6 6b 0.35 2.58 81.25 6 6c 0.30 220.39 -79.38 6 6d 0.51 299.09 -0.90 6 6e 0.21 108.28 1.25 *FLAGS NOT SPLAY 6 7 1.08 37.30 11.53 *FLAGS SPLAY 7 7a 1.09 217.24 -12.21 7 7b 0.80 327.16 66.53 7 7c 4.12 176.11 -83.10 7 7d 0.72 287.69 -77.51 7 7e 0.60 292.40 -18.76 7 7f 2.02 100.10 16.73 *FLAGS NOT SPLAY 7 8 2.00 6.10 11.51 *FLAGS SPLAY 8 8a 2.00 184.82 -11.17 8 8b 1.47 98.32 -7.52 8 8c 0.19 105.24 52.84 8 8d 1.24 102.22 -61.02 8 8e 0.88 109.39 0.40 *FLAGS NOT SPLAY 8 9 1.01 56.60 0.18 ;1.9=bottom point of sharp vertical edge of boulder forming ceiling *FLAGS SPLAY 9 9a 1.02 236.71 -0.46 9 9b 0.48 12.78 64.51 9 9c 0.60 279.77 -8.53 9 9d 0.47 275.64 -73.34 9 9e 3.54 74.99 6.08 *FLAGS NOT SPLAY 9 10 3.07 336.52 5.81 ;1.10=bottom of cream calcite rib running down RH wall *FLAGS SPLAY 10 10a 3.08 156.19 -6.26 10 10b 0.58 232.61 -1.43 10 10c 1.31 64.76 -58.36 10 10d 1.43 101.23 -11.90 10 10e 1.14 78.33 -36.92 *FLAGS NOT SPLAY 9 11 2.42 64.64 5.29 *FLAGS SPLAY 11 11a 2.42 245.35 -5.41 11 11b 0.44 233.11 24.20 11 11c 0.20 42.71 -21.97 11 11d 0.45 239.67 46.05 11 11e 0.49 178.37 -53.68 11 11f 3.30 118.39 17.88 *FLAGS NOT SPLAY 11 12 4.50 106.56 19.29 *FLAGS SPLAY 12 12a 0.25 297.10 84.93 12 12b 0.26 127.16 -84.07 12 12c 0.60 197.87 18.66 12 12d 1.17 327.17 -9.65 12 12e 1.63 13.18 -2.28 12 12f 1.86 96.76 12.16 10 10f 3.76 209.97 51.34 *FLAGS NOT SPLAY 10 13 0.94 80.55 -45.63 *FLAGS SPLAY 13 13a 0.94 259.78 45.32 13 13b 0.84 97.15 56.57 13 13c 1.16 144.82 14.01 13 13d 0.48 130.78 -25.41 13 13e 0.58 324.87 25.54 *FLAGS NOT SPLAY 13 14 5.31 65.16 19.50 *FLAGS SPLAY 14 14a 5.82 246.22 -19.66 14 14b 0.64 206.92 -10.28 14 14c 0.54 185.33 -53.51 14 14d 0.21 279.32 69.67 14 14e 2.09 161.86 8.15 14 14f 0.85 285.98 -13.42 *FLAGS NOT SPLAY 10 15 3.27 329.15 -18.16 *FLAGS SPLAY 15 15a 3.25 149.02 17.88 15 15b 0.77 63.28 -13.22 15 15c 0.70 243.58 79.61 15 15d 0.80 97.26 -82.81 15 15e 2.37 233.98 -23.81 15 15f 0.94 168.26 10.56 *FLAGS NOT SPLAY 15 16 3.57 334.08 -6.33 *FLAGS SPLAY 16 16a 3.58 154.40 6.43 16 16b 0.29 52.63 -10.96 16 16c 0.70 63.17 -62.51 16 16d 0.73 221.54 2.28 16 16e 1.82 250.10 55.64 16 16f 0.86 237.55 47.64 16 16g 0.86 195.09 5.98 *FLAGS NOT SPLAY 16 17 2.41 207.98 -9.43 *FLAGS SPLAY 17 17a 2.40 28.72 9.44 17 17b 1.55 24.59 -70.16 17 17c 1.33 336.78 -9.34 17 17d 0.48 26.59 -33.63 17 17e 0.66 83.59 13.58 17 17f 1.67 193.75 -23.62 *FLAGS NOT SPLAY 17 18 4.05 308.01 -19.25 *FLAGS SPLAY 18 18a 4.05 128.34 19.12 18 18b 1.54 155.56 12.30 18 18c 0.60 300.02 2.80 18 18d 0.28 261.46 65.07 18 18e 0.68 182.87 -85.38 *FLAGS NOT SPLAY 18 19 2.06 211.48 -16.06 *FLAGS SPLAY 19 19a 2.04 31.72 16.13 19 19b 0.55 320.99 71.97 19 19c 1.54 308.22 -85.39 19 19d 0.46 306.67 -13.63 *FLAGS NOT SPLAY 19 20 2.94 233.55 -35.84 *FLAGS SPLAY 20 20a 2.95 53.57 35.69 20 20b 0.98 64.26 12.43 20 20c 0.93 44.01 13.78 20 20d 1.56 84.07 80.29 20 20e 1.62 301.40 -84.42 *FLAGS NOT SPLAY 20 21 2.04 14.57 -39.09 ;1.21=25cm tall stumpy stalagmite on floor to left of top of Jacob's Ladder. Stn is centre of flat ring on top. *FLAGS SPLAY 21 21a 2.04 195.35 38.69 21 21b 1.80 235.96 12.16 21 21c 0.21 339.46 -76.92 21 21d 0.34 53.17 3.81 21 21e 3.17 230.10 64.31 *FLAGS NOT SPLAY *data passage station left right up down 0 0.00 0.00 0.00 0.00 2 0.00 1.90 0.00 1.38 3 0.09 0.11 0.91 0.44 4 0.56 0.00 1.49 1.31 5 1.98 4.15 0.69 0.50 6 0.49 0.19 0.35 0.29 7 0.57 1.90 0.73 4.09 8 0.00 1.34 0.15 1.09 9 0.38 0.87 0.43 0.45 11 0.13 1.70 0.33 0.40 12 1.63 0.57 0.25 0.26 *data passage station left right up down 9 0.59 3.00 0.43 0.45 10 0.54 2.34 2.93 1.11 13 0.50 1.07 0.70 0.21 14 0.54 2.05 0.20 0.44 *data passage station left right up down 10 1.97 1.09 2.93 1.11 15 2.15 0.75 0.68 0.80 16 0.83 0.18 1.51 0.62 17 1.38 1.29 0.00 1.46 18 1.46 0.38 0.25 0.68 19 0.00 0.45 0.53 1.54 20 0.00 0.89 1.53 1.62 21 1.16 0.21 2.86 0.21 *END 1 *END Swil20120909 CaveConverter_src/test/data/regression/2649_Mares_fromaven_ds_ref.svx0000644000000000000000000000431512115213060024747 0ustar rootroot*BEGIN SurveyFromDXF *EQUATE SeriesFromLines1.6 SeriesFromLines2.0 *EQUATE SeriesFromLines2.0 SeriesFromLines1.6 *EQUATE SeriesFromLines2.3 SeriesFromLines3.0 *EQUATE SeriesFromLines3.0 SeriesFromLines2.3 *EQUATE SeriesFromLines3.13 SeriesFromLines5.0 *EQUATE SeriesFromLines3.14 SeriesFromLines4.0 *EQUATE SeriesFromLines4.0 SeriesFromLines3.14 *EQUATE SeriesFromLines5.0 SeriesFromLines3.13 *EQUATE SeriesFromLines5.4 SeriesFromLines6.0 *EQUATE SeriesFromLines6.0 SeriesFromLines5.4 *EQUATE SeriesFromLines6.1 SeriesFromLines7.0 *EQUATE SeriesFromLines7.0 SeriesFromLines6.1 *EQUATE SeriesFromLines7.5 SeriesFromLines8.0 *EQUATE SeriesFromLines8.0 SeriesFromLines7.5 *BEGIN SeriesFromLines1 *FIX 0 -45.28 -18.77 6.13 0 1 1.71 142.64 -46.89 1 2 2.90 350.59 -49.12 2 3 4.23 0.00 -90.00 3 4 4.96 100.66 11.05 4 5 2.17 69.61 40.07 5 6 2.50 97.85 -35.10 6 7 6.89 219.66 -10.95 *END SeriesFromLines1 *BEGIN SeriesFromLines2 0 1 2.99 65.79 18.75 1 2 2.99 107.71 -1.72 2 3 2.58 95.89 -10.95 3 4 4.81 0.00 -90.00 *END SeriesFromLines2 *BEGIN SeriesFromLines3 0 1 4.40 45.66 -11.13 1 2 2.30 17.68 -43.07 2 3 7.35 47.76 -3.98 3 4 7.35 32.74 -4.99 4 5 4.10 22.63 14.12 5 6 5.90 70.73 -5.15 6 7 7.40 29.69 -2.94 7 8 5.64 46.73 -3.05 8 9 3.91 107.78 -3.96 9 10 4.02 82.72 1.99 10 11 3.00 35.76 -2.87 11 12 3.30 147.73 -11.00 12 13 6.57 96.74 0.00 13 14 1.81 179.68 2.85 14 15 1.90 25.75 6.95 *END SeriesFromLines3 *BEGIN SeriesFromLines4 0 1 2.50 199.59 19.84 *END SeriesFromLines4 *BEGIN SeriesFromLines5 0 1 3.00 88.85 6.51 1 2 2.91 18.25 3.54 2 3 4.11 17.73 -2.09 3 4 2.02 328.99 4.53 4 5 2.42 26.97 -37.46 *END SeriesFromLines5 *BEGIN SeriesFromLines6 0 1 1.93 61.96 -5.96 1 2 3.34 30.11 -4.29 *END SeriesFromLines6 *BEGIN SeriesFromLines7 0 1 8.16 102.89 -1.40 1 2 1.78 137.05 4.83 2 3 2.69 98.76 0.43 3 4 4.73 54.32 -3.76 4 5 1.26 67.52 -5.01 5 6 2.94 110.53 -3.70 *END SeriesFromLines7 *BEGIN SeriesFromLines8 0 1 3.96 134.18 3.91 1 2 1.44 67.21 -26.37 2 3 2.30 129.81 -17.75 *END SeriesFromLines8 *END SurveyFromDXF CaveConverter_src/test/data/regression/TripComment_pt_ref.text0000644000000000000000000000146612217344034023756 0ustar rootroot -6 1 1 1 1 Cave Name -5 1 1 1 1 0.00 0.00 0.00 1 0 -4 1 1 1 1 12/08/16 13:14:15 CaveConverter -3 1 1 1 1 -2 1 1 1 1 16/08/12 Converted Data 0 0.00 0 1 -1 1 1 1 1 360.00 360.00 0.05 1.00 1.00 100.00 0.00 1 -2 1 1 1 Series 1-root.TrainingRoom.1 1 -1 1 1 1 1 0 1 3 3 3 0 1 0 1 1 1 0.00 0.00 0.00 3.67 4.49 1.03 1.09 1 1 1 1 1 5.08 327.47 56.76 1.81 2.48 1.96 0.63 1 2 1 1 1 4.92 69.83 23.86 5.52 9.34 2.80 1.75 1 3 1 1 1 2.00 337.58 33.09 0.34 0.00 1.84 0.75CaveConverter_src/test/data/regression/SwilEnt_st_nsp_ref.text0000644000000000000000000005470412242115746023774 0ustar rootroot -6 1 1 1 1 Cave Name -5 1 1 1 1 0.00 0.00 0.00 1 0 -4 1 1 1 1 12/08/16 13:14:15 CaveConverter -3 1 1 1 1 -2 1 1 1 1 16/08/12 Converted Data 0 0.00 0 1 -1 1 1 1 1 360.00 360.00 0.05 1.00 1.00 100.00 0.00 1 -2 1 1 1 Series 1-root.Swildons.surfacegps 1 -1 1 1 1 1 0 1 13 13 3 0 1 0 1 1 1 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1 1 1 1 1 9.84 92.79 -5.88 0.00 0.00 0.00 0.00 1 2 1 1 1 7.84 96.07 -8.05 0.00 0.00 0.00 0.00 1 3 1 1 1 11.76 92.69 -17.67 0.00 0.00 0.00 0.00 1 4 1 1 1 4.38 5.80 -23.29 0.30 0.38 0.91 0.44 1 5 1 1 1 3.10 329.06 -25.13 0.56 0.00 1.50 1.32 1 6 1 1 1 4.51 274.10 -12.10 1.98 4.15 0.69 0.51 1 7 1 1 1 2.41 48.97 -22.33 0.49 0.19 0.35 0.29 1 8 1 1 1 1.08 35.60 11.53 0.57 1.89 0.73 4.09 1 9 1 1 1 2.00 4.40 11.51 0.00 1.34 0.15 1.08 1 10 1 1 1 1.01 54.90 0.18 0.59 0.00 0.43 0.45 1 11 1 1 1 3.07 334.82 5.81 0.54 2.34 2.94 1.12 1 12 1 1 1 0.94 78.85 -45.63 0.50 1.07 0.70 0.21 1 13 1 1 1 5.31 63.46 19.50 0.54 2.05 0.20 0.43 2 -2 1 1 1 Series 2-root.Swildons.surfacegps 2 -1 1 1 1 1 3 2 3 3 3 0 2 0 1 1 1 0.00 0.00 0.00 0.00 0.00 0.00 0.00 2 1 1 1 1 5.45 261.35 13.06 0.00 0.00 0.00 0.00 2 2 1 1 1 8.80 173.37 11.61 0.00 0.00 0.00 0.00 2 3 1 1 1 13.78 166.73 12.55 0.00 0.00 0.00 0.00 3 -2 1 1 1 Series 3-root.Swildons.EntranceZigZags 3 -1 1 1 1 4 0 3 1 1 3 0 3 0 1 1 1 0.00 0.00 0.00 0.00 0.00 0.00 0.00 3 1 1 1 1 2.98 8.56 -2.01 0.00 0.00 0.00 0.00 4 -2 1 1 1 Series 4-root.Swildons.EntranceZigZags 4 -1 1 1 1 4 0 1 4 2 3 0 4 0 1 1 1 0.00 0.00 0.00 0.00 0.00 0.00 0.00 4 1 1 1 1 5.24 1.53 -5.04 0.00 0.00 0.00 0.00 4 2 1 1 1 2.64 165.00 -60.11 0.00 0.00 0.00 0.00 5 -2 1 1 1 Series 5-root.Swildons.EntranceZigZags 5 -1 1 1 1 1 10 5 2 2 3 0 5 0 1 1 1 0.00 0.00 0.00 0.37 0.00 0.43 0.45 5 1 1 1 1 2.42 62.94 5.29 0.13 1.70 0.32 0.39 5 2 1 1 1 4.50 104.86 19.29 1.63 0.57 0.25 0.26 6 -2 1 1 1 Series 6-root.Swildons.EntranceZigZags 6 -1 1 1 1 1 11 6 14 14 3 0 6 0 1 1 1 0.00 0.00 0.00 1.97 1.10 2.94 1.12 6 1 1 1 1 3.27 327.45 -18.16 2.15 0.75 0.69 0.79 6 2 1 1 1 3.57 332.38 -6.33 0.83 0.18 1.50 0.62 6 3 1 1 1 2.41 206.28 -9.43 1.38 1.29 0.00 1.46 6 4 1 1 1 4.05 306.31 -19.25 1.46 0.39 0.25 0.68 6 5 1 1 1 2.06 209.78 -16.06 0.00 0.44 0.52 1.54 6 6 1 1 1 2.94 231.85 -35.84 0.00 0.89 1.54 1.61 6 7 1 1 1 2.04 12.87 -39.09 1.73 0.62 2.74 0.23 6 8 1 1 1 1.87 330.80 6.50 1.12 0.32 2.49 0.46 6 9 1 1 1 2.26 341.69 -5.29 1.10 0.00 1.41 0.51 6 10 1 1 1 1.72 256.99 12.28 0.75 0.00 0.88 0.81 6 11 1 1 1 2.19 192.38 16.02 0.21 0.53 1.13 0.86 6 12 1 1 1 1.14 226.56 32.64 0.65 0.39 0.85 1.15 6 13 1 1 1 3.27 161.72 -22.86 0.70 0.29 1.68 1.79 6 14 1 1 1 6.91 265.55 3.53 0.55 0.32 0.38 0.44 7 -2 1 1 1 Series 7-root.Swildons.LongDryWay 7 -1 1 1 1 1 6 6 7 5 3 0 7 0 1 1 1 0.00 0.00 0.00 0.56 1.35 0.66 0.56 7 1 1 1 1 4.08 269.09 -25.50 1.13 1.96 0.45 1.49 7 2 1 1 1 3.77 352.72 -29.81 0.64 0.92 0.73 1.92 7 3 1 1 1 4.33 334.47 -24.79 0.44 0.45 1.17 0.48 7 4 1 1 1 2.77 336.07 -4.41 1.02 0.00 1.94 1.36 7 5 1 1 1 3.14 342.08 -25.59 0.00 0.00 0.00 0.00 8 -2 1 1 1 Series 8-root.Swildons.LongDryWay 8 -1 1 1 1 6 9 8 18 18 3 0 8 0 1 1 1 0.00 0.00 0.00 1.12 0.00 1.41 0.51 8 1 1 1 1 1.10 308.84 4.46 0.85 0.56 0.83 0.57 8 2 1 1 1 2.37 332.96 4.19 0.39 0.24 2.18 0.43 8 3 1 1 1 1.12 262.14 46.91 0.00 0.62 1.41 0.97 8 4 1 1 1 3.53 350.11 -3.89 0.77 0.00 0.88 0.00 8 5 1 1 1 1.97 310.87 39.30 0.00 0.86 0.46 1.02 8 6 1 1 1 2.39 26.49 3.33 1.47 0.00 0.48 0.59 8 7 1 1 1 0.86 304.46 -13.02 0.61 0.45 0.40 0.41 8 8 1 1 1 4.55 46.75 7.37 2.24 0.00 0.86 1.51 8 9 1 1 1 2.34 326.38 -9.83 0.00 1.46 1.20 0.00 8 10 1 1 1 2.65 84.60 -7.24 0.48 1.95 0.40 0.51 8 11 1 1 1 0.84 145.04 18.49 1.33 0.33 0.40 0.00 8 12 1 1 1 1.81 86.30 13.23 0.59 0.86 1.46 0.00 8 13 1 1 1 1.73 162.82 7.33 0.65 0.00 1.19 0.25 8 14 1 1 1 2.91 112.32 7.56 1.22 0.84 1.30 0.40 8 15 1 1 1 1.51 179.58 30.14 1.27 0.19 0.40 1.21 8 16 1 1 1 4.59 106.55 -8.18 3.04 1.76 1.43 0.00 8 17 1 1 1 3.22 187.12 35.45 3.11 1.05 0.86 0.00 8 18 1 1 1 4.13 137.97 16.69 1.08 0.48 0.56 0.52 9 -2 1 1 1 Series 9-root.Swildons.LongDryWay 9 -1 1 1 1 8 17 9 1 1 3 0 9 0 1 1 1 0.00 0.00 0.00 2.42 1.16 0.86 0.00 9 1 1 1 1 4.94 95.70 39.05 0.16 3.08 0.34 0.00 10 -2 1 1 1 Series 10-root.Swildons.LongDryWay 10 -1 1 1 1 8 16 10 13 13 3 0 10 0 1 1 1 0.00 0.00 0.00 1.76 3.04 1.43 0.00 10 1 1 1 1 2.78 321.97 -24.94 0.00 0.00 1.98 1.15 10 2 1 1 1 0.89 88.37 -48.92 0.65 0.60 0.61 1.14 10 3 1 1 1 6.28 322.97 -29.83 1.46 0.28 1.86 0.43 10 4 1 1 1 1.55 262.60 41.75 0.39 1.14 0.97 1.50 10 5 1 1 1 2.26 14.20 12.57 0.68 0.00 0.38 0.76 10 6 1 1 1 6.03 321.82 -41.61 0.55 0.93 3.48 0.00 10 7 1 1 1 4.45 89.37 26.23 3.45 2.23 2.46 0.38 10 8 1 1 1 6.61 111.16 18.69 1.23 2.15 2.77 0.50 10 9 1 1 1 3.92 156.89 22.40 1.04 1.09 2.53 0.83 10 10 1 1 1 5.06 156.91 15.55 2.01 1.86 0.80 0.31 10 11 1 1 1 3.30 135.66 35.75 0.58 0.42 0.40 0.00 10 12 1 1 1 1.54 155.29 21.03 0.98 0.71 1.17 0.00 10 13 1 1 1 1.23 186.79 54.13 1.03 0.18 0.28 0.00 11 -2 1 1 1 Series 11-root.Swildons.LongDryWay 11 -1 1 1 1 10 4 10 6 2 3 0 11 0 1 1 1 0.00 0.00 0.00 0.43 1.37 0.97 1.50 11 1 1 1 1 5.13 312.59 -30.46 0.00 1.36 1.60 0.71 11 2 1 1 1 2.76 18.16 -19.74 0.00 0.00 0.00 0.00 12 -2 1 1 1 Series 12-root.Swildons.LongDryWay 12 -1 1 1 1 10 6 12 4 4 3 0 12 0 1 1 1 0.00 0.00 0.00 0.93 0.55 3.48 0.00 12 1 1 1 1 7.82 270.23 -10.72 0.61 0.64 2.82 1.69 12 2 1 1 1 1.58 131.12 -54.76 0.00 1.08 0.73 0.00 12 3 1 1 1 4.08 276.51 -22.89 0.00 0.00 1.09 0.58 12 4 1 1 1 1.62 125.96 7.41 0.00 2.53 0.42 0.71 13 -2 1 1 1 Series 13-root.Swildons.LongDryWay 13 -1 1 1 1 12 1 13 6 6 3 0 13 0 1 1 1 0.00 0.00 0.00 0.63 0.60 2.82 1.69 13 1 1 1 1 4.22 281.53 -3.82 1.00 0.26 2.12 0.91 13 2 1 1 1 2.40 263.37 1.41 1.24 0.87 2.24 0.70 13 3 1 1 1 2.06 295.99 28.08 0.41 0.00 0.69 0.76 13 4 1 1 1 2.38 315.61 16.74 1.79 0.65 0.34 3.97 13 5 1 1 1 2.80 333.38 -5.36 0.00 1.39 0.66 1.10 13 6 1 1 1 8.00 75.95 15.81 0.00 0.00 0.00 0.00 14 -2 1 1 1 Series 14-root.Swildons.LongDryWay 14 -1 1 1 1 13 5 14 32 32 3 0 14 0 1 1 1 0.00 0.00 0.00 1.39 0.00 0.66 1.10 14 1 1 1 1 2.99 250.16 -11.14 0.00 1.44 1.32 4.82 14 2 1 1 1 2.75 286.06 -14.31 0.45 1.74 1.92 4.57 14 3 1 1 1 6.04 278.66 -11.16 0.00 0.91 0.87 5.41 14 4 1 1 1 4.72 166.16 -69.81 0.47 0.00 5.50 0.76 14 5 1 1 1 6.26 264.64 3.98 2.05 0.88 2.44 0.74 14 6 1 1 1 5.34 219.71 -28.43 2.29 5.14 2.99 0.67 14 7 1 1 1 3.64 248.24 -18.27 3.49 1.16 1.60 2.35 14 8 1 1 1 6.14 186.37 -36.35 0.00 0.00 4.26 3.24 14 9 1 1 1 1.04 30.01 -42.73 0.63 0.59 5.52 2.45 14 10 1 1 1 2.38 197.66 -26.79 0.71 0.81 5.21 1.53 14 11 1 1 1 6.29 237.93 -9.79 0.23 1.80 3.96 1.44 14 12 1 1 1 7.66 282.53 -7.14 1.04 0.00 5.90 1.22 14 13 1 1 1 2.58 222.57 -8.54 0.00 1.49 5.11 1.06 14 14 1 1 1 6.80 204.26 -6.51 1.39 0.00 3.26 1.26 14 15 1 1 1 2.09 106.93 -5.31 0.00 1.68 5.06 1.15 14 16 1 1 1 7.85 203.21 6.96 6.74 3.41 1.95 0.00 14 17 1 1 1 5.77 332.70 -11.88 1.52 0.00 3.73 1.75 14 18 1 1 1 4.33 193.94 -26.62 0.25 0.75 0.70 1.02 14 19 1 1 1 6.36 268.81 -36.08 0.00 0.60 7.22 1.50 14 20 1 1 1 1.54 303.46 -17.83 1.18 0.00 5.86 1.80 14 21 1 1 1 4.45 300.43 -20.17 0.00 0.66 0.78 1.18 14 22 1 1 1 2.13 318.80 -11.71 0.00 0.40 1.32 0.97 14 23 1 1 1 5.02 332.34 -11.98 0.32 0.00 3.07 1.41 14 24 1 1 1 1.63 321.88 -34.24 0.73 0.00 2.19 0.57 14 25 1 1 1 6.72 323.97 -5.61 0.00 0.65 1.18 0.38 14 26 1 1 1 2.39 -0.20 10.24 0.81 0.43 2.51 1.00 14 27 1 1 1 3.73 243.67 -24.06 0.47 0.78 10.85 2.38 14 28 1 1 1 1.75 210.09 -24.54 0.56 0.84 1.63 1.74 14 29 1 1 1 8.34 179.80 -8.14 0.20 0.83 3.40 0.81 14 30 1 1 1 4.39 178.21 -2.78 0.00 1.52 3.09 0.84 14 31 1 1 1 7.89 174.67 -1.64 0.42 0.39 3.04 0.98 14 32 1 1 1 4.52 192.42 -4.00 1.81 1.13 1.35 0.91 15 -2 1 1 1 Series 15-root.Swildons.ShortDryWay.pt1 15 -1 1 1 1 6 7 15 4 4 3 0 15 0 1 1 1 0.00 0.00 0.00 0.00 0.00 0.00 0.00 15 1 1 1 1 1.43 129.98 -13.25 0.41 0.87 0.00 0.28 15 2 1 1 1 3.89 71.66 -51.63 0.00 1.63 1.81 0.46 15 3 1 1 1 4.50 169.09 19.68 0.31 0.26 1.53 0.92 15 4 1 1 1 1.11 244.86 -14.16 0.00 2.09 0.55 0.68 16 -2 1 1 1 Series 16-root.Swildons.ShortDryWay.pt1 16 -1 1 1 1 15 2 14 6 12 3 0 16 0 1 1 1 0.00 0.00 0.00 1.63 0.00 1.81 0.46 16 1 1 1 1 4.91 322.03 2.34 1.00 0.32 1.55 0.86 16 2 1 1 1 5.05 277.72 -25.23 0.00 1.25 2.73 1.16 16 3 1 1 1 5.02 334.73 -13.85 0.41 0.00 3.68 0.54 16 4 1 1 1 3.19 301.45 -33.11 0.00 1.37 4.40 1.42 16 5 1 1 1 6.71 294.06 -12.15 1.02 0.00 1.15 1.06 16 6 1 1 1 1.11 264.30 2.35 0.00 0.45 0.84 1.15 16 7 1 1 1 4.30 321.59 3.80 0.64 0.00 2.05 1.59 16 8 1 1 1 3.28 274.36 -17.30 0.00 0.52 1.75 0.81 16 9 1 1 1 4.68 296.37 -3.29 0.00 0.56 2.73 0.76 16 10 1 1 1 3.20 315.03 0.98 0.00 0.57 2.40 1.46 16 11 1 1 1 7.10 307.21 -15.08 0.65 0.00 2.87 0.80 16 12 1 1 1 4.24 277.28 -12.53 0.00 0.00 0.00 0.00 17 -2 1 1 1 Series 17-root.Swildons.NewGrottoes 17 -1 1 1 1 10 10 17 8 8 3 0 17 0 1 1 1 0.00 0.00 0.00 0.00 0.00 0.00 0.00 17 1 1 1 1 1.56 47.73 7.27 0.42 0.08 0.39 0.73 17 2 1 1 1 1.75 8.90 51.20 0.29 0.00 0.68 0.86 17 3 1 1 1 4.07 345.89 12.12 0.92 0.62 0.41 0.44 17 4 1 1 1 3.62 48.97 25.22 2.01 1.51 0.00 0.88 17 5 1 1 1 3.25 66.04 12.62 2.12 0.90 0.25 0.77 17 6 1 1 1 3.45 54.94 19.52 0.52 3.62 0.00 0.56 17 7 1 1 1 1.42 150.32 -12.13 1.16 2.64 0.89 0.44 17 8 1 1 1 6.30 83.28 26.43 0.81 0.31 0.19 0.35 18 -2 1 1 1 Series 18-root.Swildons.OldGrotto2WC 18 -1 1 1 1 14 6 14 9 4 3 0 18 0 1 1 1 0.00 0.00 0.00 0.00 0.00 0.00 0.00 18 1 1 1 1 3.32 23.40 -14.33 2.39 0.00 0.00 0.86 18 2 1 1 1 5.70 253.64 -30.20 0.97 0.38 1.20 1.13 18 3 1 1 1 3.09 199.90 -10.26 0.88 1.27 0.32 0.93 18 4 1 1 1 4.55 163.09 -15.92 0.00 0.00 0.00 0.00 19 -2 1 1 1 Series 19-root.Swildons.FortyRoute 19 -1 1 1 1 14 20 14 28 11 3 0 19 0 1 1 1 0.00 0.00 0.00 1.18 0.00 1.01 1.46 19 1 1 1 1 2.76 326.33 18.03 1.80 0.00 5.92 3.29 19 2 1 1 1 5.35 305.33 5.35 0.20 0.91 2.13 5.12 19 3 1 1 1 3.55 319.83 38.17 0.24 0.78 2.32 3.23 19 4 1 1 1 1.12 6.13 3.63 0.67 0.00 2.18 0.63 19 5 1 1 1 1.06 261.82 33.43 0.00 0.57 1.59 1.15 19 6 1 1 1 2.53 350.36 5.11 0.51 0.00 1.41 1.13 19 7 1 1 1 2.96 315.73 -3.31 0.00 0.47 1.66 1.64 19 8 1 1 1 5.25 324.70 -29.19 0.81 1.04 1.74 1.09 19 9 1 1 1 1.45 271.57 -22.26 0.73 0.30 4.17 2.68 19 10 1 1 1 7.65 250.71 -71.60 2.78 0.00 0.00 1.91 19 11 1 1 1 2.32 144.81 -8.38 0.00 0.00 0.00 0.00 20 -2 1 1 1 Series 20-root.Swildons.10 20 -1 1 1 1 6 13 20 7 7 3 0 20 0 1 1 1 0.00 0.00 0.00 0.65 0.26 1.68 1.79 20 1 1 1 1 2.54 188.98 -63.18 0.00 0.60 0.00 0.63 20 2 1 1 1 4.59 249.49 -25.44 0.86 0.23 0.49 0.00 20 3 1 1 1 2.94 165.69 7.15 0.00 0.62 0.19 1.57 20 4 1 1 1 3.72 164.01 -0.44 0.73 0.00 0.41 1.07 20 5 1 1 1 2.10 109.92 19.76 1.38 1.52 0.21 1.09 20 6 1 1 1 7.71 160.14 1.86 0.32 0.35 0.63 0.63 20 7 1 1 1 2.16 100.50 5.76 0.00 0.00 0.00 0.00 21 -2 1 1 1 Series 21-root.Swildons.10 21 -1 1 1 1 20 5 7 2 4 3 0 21 0 1 1 1 0.00 0.00 0.00 0.25 2.80 0.21 1.09 21 1 1 1 1 8.35 92.14 17.83 1.65 0.50 0.44 0.44 21 2 1 1 1 4.34 7.89 9.01 0.00 0.43 0.00 0.65 21 3 1 1 1 2.15 151.23 2.05 0.00 2.86 3.76 0.00 21 4 1 1 1 3.88 293.57 51.22 0.00 0.00 0.00 0.00 22 -2 1 1 1 Series 22-root.Swildons.10 22 -1 1 1 1 21 2 22 3 3 3 0 22 0 1 1 1 0.00 0.00 0.00 0.20 0.00 0.00 0.65 22 1 1 1 1 3.68 87.05 11.54 1.14 0.58 0.49 0.30 22 2 1 1 1 5.88 45.77 18.38 0.54 1.43 0.27 0.00 22 3 1 1 1 5.34 78.15 18.79 1.62 0.86 2.11 0.65 23 -2 1 1 1 Series 23-root.Swildons.10 23 -1 1 1 1 6 13 29 3 2 3 0 23 0 1 1 1 0.00 0.00 0.00 0.29 0.70 1.68 1.79 23 1 1 1 1 1.80 103.39 -49.81 0.23 0.41 0.24 0.00 23 2 1 1 1 1.86 142.05 -4.35 0.36 0.45 0.00 0.45 24 -2 1 1 1 Series 24-root.Swildons.20 24 -1 1 1 1 1 6 24 7 7 3 0 24 0 1 1 1 0.00 0.00 0.00 0.00 0.00 0.00 0.00 24 1 1 1 1 3.87 260.21 -26.31 0.00 0.00 0.00 0.00 24 2 1 1 1 2.55 124.11 -19.31 0.23 1.76 3.38 0.77 24 3 1 1 1 5.29 149.28 -7.60 0.90 0.00 0.18 0.51 24 4 1 1 1 1.83 62.36 -43.21 0.14 0.26 0.71 0.55 24 5 1 1 1 3.13 174.99 -12.17 0.34 0.35 0.87 0.39 24 6 1 1 1 1.40 256.07 -52.47 0.00 0.34 0.50 0.18 24 7 1 1 1 2.40 282.91 -13.04 0.40 0.00 0.23 0.35 25 -2 1 1 1 Series 25-root.Swildons.20 25 -1 1 1 1 24 3 25 7 7 3 0 25 0 1 1 1 0.00 0.00 0.00 0.90 0.00 0.18 0.51 25 1 1 1 1 2.58 62.72 1.85 0.97 1.31 0.38 1.78 25 2 1 1 1 2.80 60.36 1.42 0.00 1.90 1.09 0.84 25 3 1 1 1 5.67 272.72 -29.92 1.22 3.45 0.67 0.23 25 4 1 1 1 4.21 313.66 -5.18 0.83 0.46 0.00 0.48 25 5 1 1 1 0.46 275.66 -49.35 0.21 0.00 0.00 0.00 25 6 1 1 1 2.99 10.35 3.89 2.90 4.13 1.39 0.30 25 7 1 1 1 1.51 325.31 1.17 0.00 0.00 0.00 0.00 26 -2 1 1 1 Series 26-root.Swildons.20 26 -1 1 1 1 25 6 1 6 5 3 0 26 0 1 1 1 0.00 0.00 0.00 4.13 2.90 1.39 0.30 26 1 1 1 1 4.27 116.70 31.59 1.61 0.98 0.28 0.86 26 2 1 1 1 2.48 34.54 13.37 2.24 0.00 0.00 1.10 26 3 1 1 1 3.13 326.34 82.94 0.00 0.10 0.69 0.29 26 4 1 1 1 1.35 212.74 -12.67 0.00 0.00 0.00 0.00 26 5 1 1 1 2.43 229.67 22.63 0.00 0.00 0.00 0.00 27 -2 1 1 1 Series 27-root.Swildons.10 27 -1 1 1 1 25 6 21 2 1 3 0 27 0 1 1 1 0.00 0.00 0.00 2.88 4.11 1.39 0.30 27 1 1 1 1 2.14 330.35 -1.84 0.00 0.00 0.00 0.00 28 -2 1 1 1 Series 28-root.Swildons.20 28 -1 1 1 1 21 2 15 3 3 3 0 28 0 1 1 1 0.00 0.00 0.00 0.00 0.41 0.35 1.24 28 1 1 1 1 2.84 47.65 -61.41 0.36 0.23 0.29 0.00 28 2 1 1 1 1.87 343.99 -9.57 0.82 0.21 0.78 0.31 28 3 1 1 1 1.63 309.69 20.13 0.00 0.00 0.00 0.00 29 -2 1 1 1 Series 29-root.Swildons.20 29 -1 1 1 1 15 3 29 3 3 3 0 29 0 1 1 1 0.00 0.00 0.00 0.29 0.25 0.19 0.99 29 1 1 1 1 1.57 248.47 -33.27 0.00 0.43 1.06 0.00 29 2 1 1 1 2.11 301.30 3.36 0.45 0.28 0.70 0.36 29 3 1 1 1 2.60 265.44 31.57 0.00 0.00 0.00 0.00CaveConverter_src/test/data/regression/Swil20120909_in.txt0000644000000000000000000002703312023324004022230 0ustar rootrootSwil20120909 (m, 360) [1]: 2012/09/09 0.00 1.0 0.000 0.00 0.00 "Entrance stn 1.1 is top tip of sticking out rock on RH side of blockhouse doorway, 56cm below lintel." 1.0 1.1 2.985 10.23 -2.01 [1] "1.1 has magnetic problems. So surveyed to it from knot on tree opposite door=1.0\rThen from knot to rear wall of blockhouse 1.0-1.2" 1.0 1.1 2.983 10.29 -2.02 [1] 1.0 1.2 5.234 3.18 -5.07 [1] "1.2=rawl plug on rear wall of blockhouse " 1.0 1.2 5.240 3.25 -4.96 [1] 1.0 1.2 5.234 3.25 -5.08 [1] 1.2 5.236 182.16 5.06 [1] 1.2 1.893 187.97 3.09 [1] 1.2 1.914 168.82 1.18 [1] 1.2 1.383 218.59 -0.17 [1] 1.2 0.644 248.05 1.54 [1] 1.2 0.684 105.32 -3.30 [1] 1.2 1.558 140.40 -2.98 [1] 1.2 1.840 176.52 -47.48 [1] 1.2 1.821 167.81 -47.93 [1] 1.2 1.541 189.90 -63.97 [1] 1.2 1.608 132.31 -59.62 [1] 1.2 1.3 2.635 166.54 -60.05 [1] "1.3=Top left corner of stream culvert when looking out of cave" 1.2 1.3 2.636 166.81 -60.10 [1] 1.2 1.3 2.634 166.74 -60.18 [1] 1.3 0.225 345.81 60.30 [1] 1.3 2.631 347.89 60.51 [1] 1.3 0.938 9.90 76.67 [1] 1.3 0.312 232.08 12.34 [1] 1.3 0.351 31.05 10.29 [1] 1.3 0.468 8.50 -70.77 [1] 1.3 1.4 3.108 330.39 -25.13 [1] 1.3 1.4 3.111 330.55 -25.13 [1] 1.3 1.4 3.085 331.35 -25.13 [1] 1.4 3.116 152.39 25.35 [1] 1.4 0.561 208.59 -0.68 [1] 1.4 0.589 140.67 80.22 [1] 1.4 1.318 189.06 -86.08 [1] 1.4 1.496 43.79 87.42 [1] 1.4 1.5 4.507 275.74 -12.18 [1] "1.5=polished tip of pointy boulder by top of drop into lower level of chamber. Boulder is dark grey with white flecks and fossils." 1.4 1.5 4.518 275.89 -12.06 [1] 1.4 1.5 4.511 275.76 -12.05 [1] 1.5 4.511 94.74 12.12 [1] 1.5 3.446 123.81 5.64 [1] 1.5 3.514 134.15 0.14 [1] 1.5 6.656 129.46 11.11 [1] 1.5 2.325 149.61 -6.69 [1] 1.5 1.639 153.47 -11.17 [1] 1.5 0.791 252.58 -12.22 [1] 1.5 1.217 296.10 -7.82 [1] 1.5 2.959 296.71 -23.02 [1] 1.5 1.507 42.54 10.51 [1] 1.5 4.241 72.82 11.85 [1] 1.5 0.696 333.90 81.49 [1] 1.5 0.547 114.68 -67.13 [1] 1.5 1.6 2.414 50.56 -22.29 [1] 1.5 1.6 2.403 50.78 -22.36 [1] 1.5 1.6 2.408 50.67 -22.34 [1] 1.6 2.376 230.76 22.40 [1] 1.6 0.351 2.58 81.25 [1] 1.6 0.296 220.39 -79.38 [1] 1.6 0.507 299.09 -0.90 [1] 1.6 0.208 108.28 1.25 [1] 1.6 1.7 1.085 37.46 11.50 [1] 1.6 1.7 1.085 37.33 11.54 [1] 1.6 1.7 1.084 37.11 11.54 [1] 1.7 1.090 217.24 -12.21 [1] 1.7 0.797 327.16 66.53 [1] 1.7 4.115 176.11 -83.10 [1] 1.7 0.723 287.69 -77.51 [1] 1.7 0.599 292.40 -18.76 [1] 1.7 2.024 100.10 16.73 [1] 1.7 1.8 2.002 6.04 11.52 [1] 1.7 1.8 1.999 6.07 11.51 [1] 1.7 1.8 1.996 6.18 11.49 [1] 1.8 2.005 184.82 -11.17 [1] 1.8 1.469 98.32 -7.52 [1] 1.8 0.191 105.24 52.84 [1] 1.8 1.241 102.22 -61.02 [1] 1.8 0.884 109.39 0.40 [1] 1.8 1.9 1.004 56.71 0.14 [1] "1.9=bottom point of sharp vertical edge of boulder forming ceiling " 1.8 1.9 1.010 56.56 0.24 [1] 1.8 1.9 1.010 56.54 0.17 [1] 1.9 1.024 236.71 -0.46 [1] 1.9 0.479 12.78 64.51 [1] 1.9 0.602 279.77 -8.53 [1] 1.9 0.469 275.64 -73.34 [1] 1.9 3.537 74.99 6.08 [1] 1.9 1.10 3.064 336.58 5.75 [1] "1.10=bottom of cream calcite rib running down RH wall" 1.9 1.10 3.065 336.43 5.74 [1] 1.9 1.10 3.072 336.55 5.93 [1] 1.10 3.079 156.19 -6.26 [1] 1.10 0.580 232.61 -1.43 [1] 1.10 1.308 64.76 -58.36 [1] 1.10 1.426 101.23 -11.90 [1] 1.10 1.139 78.33 -36.92 [1] 1.9 1.11 2.423 64.65 5.31 [1] 1.9 1.11 2.422 64.64 5.28 [1] 1.9 1.11 2.418 64.64 5.29 [1] 1.11 2.423 245.35 -5.41 [1] 1.11 0.438 233.11 24.20 [1] 1.11 0.199 42.71 -21.97 [1] 1.11 0.452 239.67 46.05 [1] 1.11 0.493 178.37 -53.68 [1] 1.11 3.298 118.39 17.88 [1] 1.11 1.12 4.506 106.48 19.33 [1] 1.11 1.12 4.499 106.54 19.29 [1] 1.11 1.12 4.497 106.66 19.25 [1] 1.12 0.246 297.10 84.93 [1] 1.12 0.262 127.16 -84.07 [1] 1.12 0.597 197.87 18.66 [1] 1.12 1.169 327.17 -9.65 [1] 1.12 1.632 13.18 -2.28 [1] 1.12 1.864 96.76 12.16 [1] 1.10 3.756 209.97 51.34 [1] 1.10 1.13 0.942 80.62 -45.73 [1] 1.10 1.13 0.942 80.46 -45.58 [1] 1.10 1.13 0.943 80.57 -45.59 [1] 1.13 0.936 259.78 45.32 [1] 1.13 0.843 97.15 56.57 [1] 1.13 1.155 144.82 14.01 [1] 1.13 0.485 130.78 -25.41 [1] 1.13 0.583 324.87 25.54 [1] 1.13 1.14 5.317 65.34 19.51 [1] 1.13 1.14 5.311 65.12 19.54 [1] 1.13 1.14 5.309 65.03 19.45 [1] 1.14 5.822 246.22 -19.66 [1] 1.14 0.643 206.92 -10.28 [1] 1.14 0.545 185.33 -53.51 [1] 1.14 0.212 279.32 69.67 [1] 1.14 2.086 161.86 8.15 [1] 1.14 0.850 285.98 -13.42 [1] 1.10 0.000 0.00 0.00 [1] 1.10 1.15 3.267 329.14 -18.23 [1] 1.10 1.15 3.270 329.11 -18.15 [1] 1.10 1.15 3.269 329.20 -18.11 [1] 1.15 3.253 149.02 17.88 [1] 1.15 0.773 63.28 -13.22 [1] 1.15 0.696 243.58 79.61 [1] 1.15 0.805 97.26 -82.81 [1] 1.15 2.373 233.98 -23.81 [1] 1.15 0.942 168.26 10.56 [1] 1.15 1.16 3.562 334.13 -6.32 [1] 1.15 1.16 3.574 334.08 -6.36 [1] 1.15 1.16 3.572 334.03 -6.31 [1] 1.16 3.580 154.40 6.43 [1] 1.16 0.291 52.63 -10.96 [1] 1.16 0.699 63.17 -62.51 [1] 1.16 0.727 221.54 2.28 [1] 1.16 1.825 250.10 55.64 [1] 1.16 0.855 237.55 47.64 [1] 1.16 0.861 195.09 5.98 [1] 1.16 1.17 2.408 208.01 -9.40 [1] 1.16 1.17 2.408 207.93 -9.51 [1] 1.16 1.17 2.407 207.99 -9.37 [1] 1.17 2.405 28.72 9.44 [1] 1.17 1.549 24.59 -70.16 [1] 1.17 1.331 336.78 -9.34 [1] 1.17 0.485 26.59 -33.63 [1] 1.17 0.663 83.59 13.58 [1] 1.17 1.671 193.75 -23.62 [1] 1.17 1.18 4.056 307.88 -19.29 [1] 1.17 1.18 4.046 308.05 -19.18 [1] 1.17 1.18 4.052 308.10 -19.29 [1] 1.18 4.053 128.34 19.12 [1] 1.18 1.543 155.56 12.30 [1] 1.18 0.595 300.02 2.80 [1] 1.18 0.280 261.46 65.07 [1] 1.18 0.685 182.87 -85.38 [1] 1.18 1.19 2.049 211.43 -16.07 [1] 1.18 1.19 2.060 211.58 -16.05 [1] 1.18 1.19 2.059 211.42 -16.05 [1] 1.19 2.045 31.72 16.13 [1] 1.19 0.553 320.99 71.97 [1] 1.19 1.545 308.22 -85.39 [1] 1.19 0.461 306.67 -13.63 [1] 1.19 1.20 2.938 233.57 -35.79 [1] 1.19 1.20 2.936 233.46 -35.86 [1] 1.19 1.20 2.937 233.62 -35.86 [1] 1.20 2.952 53.57 35.69 [1] 1.20 0.984 64.26 12.43 [1] 1.20 0.929 44.01 13.78 [1] 1.20 1.555 84.07 80.29 [1] 1.20 1.624 301.40 -84.42 [1] 1.20 1.21 2.038 14.45 -39.04 [1] "1.21=25cm tall stumpy stalagmite on floor to left of top of Jacob's Ladder. Stn is centre of flat ring on top." 1.20 1.21 2.045 14.42 -39.06 [1] 1.20 1.21 2.045 14.84 -39.16 [1] 1.21 2.042 195.35 38.69 [1] 1.21 1.800 235.96 12.16 [1] 1.21 0.214 339.46 -76.92 [1] 1.21 0.343 53.17 3.81 [1] 1.21 3.170 230.10 64.31 [1] CaveConverter_src/test/data/regression/Uzu-Gour_pt_ref.text0000644000000000000000000001562212217344034023211 0ustar rootroot -6 1 1 1 1 Cave Name -5 1 1 1 1 0.00 0.00 0.00 1 0 -4 1 1 1 1 12/08/16 13:14:15 CaveConverter -3 1 1 1 1 -2 1 1 1 1 16/08/12 Converted Data 0 0.00 0 1 -1 1 1 1 1 360.00 360.00 0.05 1.00 1.00 100.00 0.00 1 -2 1 1 1 Series 1-root.Uzu-Gour090410.153 1 -1 1 1 1 1 0 1 79 79 3 0 1 0 1 1 1 0.00 0.00 0.00 0.63 1.14 1.61 1.31 1 1 1 1 1 4.01 53.11 2.88 0.66 1.24 6.16 1.27 1 2 1 1 1 6.67 107.19 -1.37 0.70 0.96 2.42 1.16 1 3 1 1 1 7.57 80.81 -1.46 1.00 0.64 5.66 0.88 1 4 1 1 1 15.71 15.49 1.20 1.94 0.40 5.60 1.04 1 5 1 1 1 2.73 242.53 2.61 0.00 2.10 5.39 1.23 1 6 1 1 1 4.22 316.29 0.41 0.00 4.73 0.72 1.79 1 7 1 1 1 4.92 27.57 -2.12 1.68 3.80 1.48 0.88 1 8 1 1 1 9.81 56.71 0.94 0.53 1.36 1.84 1.17 1 9 1 1 1 8.60 126.69 -6.68 1.21 1.00 1.17 0.26 1 10 1 1 1 5.68 80.91 5.68 1.18 0.93 1.56 0.76 1 11 1 1 1 6.56 42.64 4.54 1.04 1.22 3.26 1.16 1 12 1 1 1 9.03 70.18 1.22 1.21 0.38 9.07 1.17 1 13 1 1 1 3.05 44.21 1.28 0.94 1.07 9.09 1.45 1 14 1 1 1 6.89 84.26 -0.51 1.05 0.00 7.58 1.29 1 15 1 1 1 6.61 59.47 0.09 1.53 0.23 6.33 1.07 1 16 1 1 1 5.13 16.52 -1.21 0.55 1.29 1.39 1.10 1 17 1 1 1 6.85 60.62 2.01 0.00 1.37 4.99 1.18 1 18 1 1 1 5.38 100.17 1.22 1.27 0.00 10.77 1.38 1 19 1 1 1 2.60 103.48 -1.05 0.00 1.40 5.11 1.11 1 20 1 1 1 6.94 176.16 -2.10 0.40 0.69 2.87 1.04 1 21 1 1 1 4.01 194.06 3.14 1.43 0.63 5.22 1.07 1 22 1 1 1 4.15 137.27 -0.15 0.34 3.29 0.96 1.17 1 23 1 1 1 4.71 203.75 -0.38 0.65 0.89 2.02 1.13 1 24 1 1 1 6.52 196.44 5.52 0.67 0.94 4.72 1.25 1 25 1 1 1 8.69 222.00 -4.26 1.68 1.09 1.82 1.05 1 26 1 1 1 5.69 244.23 2.28 2.71 0.00 1.70 1.17 1 27 1 1 1 2.46 151.09 -9.56 0.00 1.16 2.03 0.82 1 28 1 1 1 16.85 202.23 -2.08 1.79 0.86 1.05 0.00 1 29 1 1 1 10.28 137.19 5.65 1.60 0.39 7.89 0.83 1 30 1 1 1 5.84 103.82 5.86 1.89 0.41 3.22 1.28 1 31 1 1 1 10.74 77.30 -0.95 2.83 0.38 1.29 1.16 1 32 1 1 1 5.99 19.28 2.80 0.00 1.89 1.71 1.26 1 33 1 1 1 8.26 122.61 -0.97 2.09 0.75 3.36 1.26 1 34 1 1 1 11.46 84.23 0.14 0.51 0.89 12.86 1.36 1 35 1 1 1 10.25 102.60 -0.15 2.27 0.00 1.54 1.12 1 36 1 1 1 6.54 34.45 2.80 1.07 0.26 4.68 1.61 1 37 1 1 1 7.85 350.55 0.36 0.00 1.97 3.79 1.44 1 38 1 1 1 12.49 57.57 -0.29 0.00 3.34 0.99 1.13 1 39 1 1 1 6.47 142.29 -0.66 0.00 1.76 5.37 1.40 1 40 1 1 1 12.19 174.61 2.78 0.00 0.93 8.25 1.85 1 41 1 1 1 8.03 215.49 -3.13 0.76 0.38 10.05 1.48 1 42 1 1 1 5.06 195.68 0.74 0.80 0.80 9.18 1.47 1 43 1 1 1 5.14 162.35 -5.75 1.21 1.12 1.88 0.88 1 44 1 1 1 4.12 88.66 -11.48 2.31 1.24 1.17 0.00 1 45 1 1 1 12.39 171.98 6.86 1.41 0.89 3.40 1.43 1 46 1 1 1 7.38 102.90 0.82 0.98 0.00 3.88 1.19 1 47 1 1 1 4.77 59.94 -3.61 0.85 0.48 4.88 0.90 1 48 1 1 1 5.77 21.57 0.32 0.95 0.85 8.94 0.87 1 49 1 1 1 10.87 4.03 2.73 3.04 1.44 4.15 0.25 1 50 1 1 1 1.56 15.63 -9.69 2.95 1.81 2.82 0.87 1 51 1 1 1 11.64 49.09 1.00 0.82 0.00 2.62 1.33 1 52 1 1 1 6.84 24.56 -5.79 0.98 2.03 1.05 0.69 1 53 1 1 1 6.43 117.08 2.67 2.44 0.34 1.31 0.75 1 54 1 1 1 16.81 343.83 -2.23 0.00 8.84 1.32 0.22 1 55 1 1 1 11.67 98.36 4.88 0.66 0.00 5.21 1.00 1 56 1 1 1 1.66 94.24 -19.79 0.40 1.04 2.31 0.56 1 57 1 1 1 5.39 158.70 -4.01 1.81 0.52 2.26 0.20 1 58 1 1 1 4.72 71.22 10.43 0.33 1.17 4.00 0.93 1 59 1 1 1 5.12 137.82 -5.11 1.10 0.92 1.38 0.48 1 60 1 1 1 8.82 73.01 2.73 0.97 0.25 7.44 0.88 1 61 1 1 1 1.71 15.47 9.12 0.00 0.50 6.39 1.14 1 62 1 1 1 7.73 49.93 -4.40 1.60 0.22 4.81 0.53 1 63 1 1 1 2.97 346.13 3.86 0.00 0.92 4.94 0.77 1 64 1 1 1 10.87 21.31 -1.96 0.00 1.15 9.24 0.43 1 65 1 1 1 4.53 53.62 4.73 1.38 0.00 8.34 0.56 1 66 1 1 1 3.19 342.39 -3.15 0.88 0.24 10.28 0.51 1 67 1 1 1 2.48 282.80 17.86 0.00 1.18 9.49 1.18 1 68 1 1 1 5.47 3.25 0.23 0.00 0.90 10.36 1.29 1 69 1 1 1 3.21 71.51 0.24 0.85 0.00 4.42 1.19 1 70 1 1 1 6.88 25.73 1.39 2.12 1.23 2.09 1.17 1 71 1 1 1 5.88 102.60 4.12 0.60 0.97 3.44 1.23 1 72 1 1 1 7.57 97.28 -5.44 1.44 1.07 11.06 0.19 1 73 1 1 1 5.64 86.58 15.15 0.00 2.62 4.98 1.34 1 74 1 1 1 2.17 129.36 8.68 2.07 4.24 12.05 1.55 1 75 1 1 1 4.57 25.38 14.39 0.00 0.80 8.30 1.10 1 76 1 1 1 8.47 58.79 19.30 0.40 0.86 1.18 1.27 1 77 1 1 1 5.73 102.57 0.98 0.42 2.02 2.09 0.34 1 78 1 1 1 5.19 82.18 24.31 0.00 1.83 0.42 0.45 1 79 1 1 1 1.27 100.93 2.43 0.00 0.00 0.00 0.00CaveConverter_src/test/data/regression/Sloppy2ZigZags_in.txt0000644000000000000000000007005212024357640023346 0ustar rootrootuzu110810sloppypt2 (m, 360) [1]: 2009/01/07 0.00 [2]: 2012/04/10 2.00 158.12 161.0 0.000 0.00 0.00 161.0 1.288 125.73 0.46 [1] 161.0 1.608 306.94 3.61 [1] 161.0 8.580 203.24 85.39 [1] 161.0 1.790 169.15 -88.07 [1] 161.0 2.530 190.96 4.20 [1] 161.0 2.307 237.87 9.54 [1] 161.0 2.833 253.54 9.73 [1] 161.0 2.159 277.70 11.01 [1] 161.0 1.314 43.80 6.31 [1] 161.0 161.1 8.842 224.91 74.30 [1] 161.0 161.1 8.842 224.85 74.25 [1] 161.0 161.1 8.837 225.09 74.32 [1] 161.1 0.773 135.02 -4.75 [1] 161.1 1.853 55.20 85.87 [1] 161.1 0.675 190.60 -87.21 [1] 161.1 161.2 1.295 177.75 16.22 [1] 161.1 161.2 1.291 177.72 16.10 [1] 161.1 161.2 1.291 177.82 16.10 [1] 161.2 0.722 31.98 -4.09 [1] 161.2 2.252 349.48 77.56 [1] 161.2 0.816 175.67 -88.21 [1] 161.2 161.3 9.445 62.83 8.43 [1] 161.2 161.3 9.453 62.80 8.48 [1] 161.2 161.3 9.462 62.77 8.44 [1] 161.3 0.757 207.08 2.14 [1] 161.3 4.881 114.75 84.07 [1] 161.3 1.066 299.88 -83.79 [1] 161.3 1.447 243.11 1.63 [1] 161.3 2.051 261.73 3.02 [1] 161.3 161.4 3.088 174.37 77.16 [1] 161.3 161.4 3.091 174.44 77.16 [1] 161.3 161.4 3.096 174.50 77.16 [1] 161.4 0.794 15.24 0.85 [1] 161.4 4.206 52.64 86.09 [1] 161.4 1.247 226.64 -88.43 [1] 161.4 161.5 3.047 80.68 -0.76 [1] 161.4 161.5 3.045 80.67 -0.79 [1] 161.4 161.5 3.041 80.74 -0.77 [1] 161.5 0.488 313.79 -1.74 [1] 161.5 4.398 124.69 83.71 [1] 161.5 0.974 67.93 -87.52 [1] 161.5 161.6 7.451 29.60 5.19 [1] 161.5 161.6 7.431 29.73 5.15 [1] 161.5 161.6 7.431 29.54 5.26 [1] 161.6 0.767 127.34 17.64 [1] 161.6 4.969 41.63 85.19 [1] 161.6 0.727 257.84 -82.51 [1] 161.6 161.7 5.860 34.90 1.18 [1] 161.6 161.7 5.857 35.16 1.02 [1] 161.6 161.7 5.847 35.10 1.08 [1] 161.7 0.576 282.01 8.71 [1] 161.7 8.620 351.28 81.03 [1] 161.7 0.551 153.97 -74.30 [1] 161.7 3.167 349.34 3.84 [1] 161.7 3.042 20.21 3.70 [1] 161.7 161.8 9.453 8.00 51.33 [1] 161.7 161.8 9.445 7.86 51.33 [1] 161.7 161.8 9.448 7.68 51.27 [1] 161.8 0.686 134.64 -0.49 [1] 161.8 4.513 93.69 78.99 [1] 161.8 1.882 52.36 -82.29 [1] 161.8 161.9 2.595 65.65 -6.32 [1] 161.8 161.9 2.594 65.79 -6.30 [1] 161.8 161.9 2.597 65.76 -6.27 [1] 161.9 0.619 298.10 5.15 [1] 161.9 4.364 19.40 82.85 [1] 161.9 1.078 191.79 -82.85 [1] 161.9 161.10 4.486 6.88 7.32 [1] 161.9 161.10 4.476 6.83 7.19 [1] 161.9 161.10 4.478 6.61 7.25 [1] 161.10 0.671 115.96 -1.72 [1] 161.10 4.298 115.63 80.16 [1] 161.10 0.741 273.75 -86.19 [1] 161.10 161.11 3.867 56.46 1.90 [1] 161.10 161.11 3.863 56.54 1.96 [1] 161.10 161.11 3.845 56.53 1.88 [1] 161.11 0.670 323.14 -8.75 [1] 161.11 4.241 25.54 78.35 [1] 161.11 0.558 60.57 -78.89 [1] 161.11 2.619 20.06 7.07 [1] 161.11 161.12 7.659 28.53 10.32 [1] 161.11 161.12 7.658 28.22 10.32 [1] 161.11 161.12 7.662 28.20 10.32 [1] 161.12 0.470 241.61 -4.41 [1] 161.12 3.688 68.94 85.50 [1] 161.12 0.816 238.09 -83.13 [1] 161.12 161.13 1.090 289.22 11.34 [1] 161.12 161.13 1.090 289.21 11.40 [1] 161.12 161.13 1.091 289.20 11.34 [1] 161.13 0.634 170.24 -3.66 [1] 161.13 3.367 228.42 84.55 [1] 161.13 0.971 278.10 -82.95 [1] 161.13 161.14 3.877 230.98 3.41 [1] 161.13 161.14 3.864 230.88 3.40 [1] 161.13 161.14 3.867 231.00 3.41 [1] 161.14 0.702 333.35 5.84 [1] 161.14 3.415 255.12 80.83 [1] 161.14 0.941 291.68 -80.13 [1] 161.14 161.15 4.603 249.76 2.42 [1] 161.14 161.15 4.603 249.79 2.53 [1] 161.14 161.15 4.604 249.88 2.52 [1] 161.15 0.755 354.29 2.52 [1] 161.15 3.435 282.49 80.49 [1] 161.15 0.844 294.69 -76.37 [1] 161.15 161.16 4.448 260.96 6.92 [1] 161.15 161.16 4.454 260.82 6.90 [1] 161.15 161.16 4.466 260.83 6.90 [1] 161.16 0.605 149.22 -7.74 [1] 161.16 2.276 213.07 85.82 [1] 161.16 0.939 293.42 -82.12 [1] 161.16 161.17 7.414 236.79 0.94 [1] 161.16 161.17 7.412 236.87 0.95 [1] 161.16 161.17 7.413 236.93 0.93 [1] 161.17 1.145 336.21 12.30 [1] 161.17 7.298 273.47 83.19 [1] 161.17 0.815 344.65 -74.47 [1] 161.17 161.18 1.792 282.61 9.16 [1] 161.17 161.18 1.789 282.91 9.27 [1] 161.17 161.18 1.787 282.88 9.28 [1] 161.18 1.401 148.94 -7.89 [1] 161.18 6.314 248.22 83.95 [1] 161.18 1.079 124.24 -85.92 [1] 161.18 161.19 14.746 240.77 9.51 [1] 161.18 161.19 14.739 240.74 9.54 [1] 161.18 161.19 14.758 240.77 9.63 [1] 161.19 0.593 2.64 1.55 [1] 161.19 1.246 157.25 -8.40 [1] 161.19 48.307 69.00 85.56 [1] 161.19 1.906 72.56 -82.37 [1] 161.19 4.574 16.43 28.14 [1] 161.19 7.144 49.84 15.92 [1] 161.19 7.110 72.91 15.16 [1] 161.4 165.1 0.000 0.00 0.00 [2] 165.1 0.571 195.52 4.07 [2] 165.1 0.494 9.16 1.22 [2] 165.1 3.841 348.92 79.39 [2] 165.1 1.625 119.01 -75.94 [2] 165.1 165.2 3.481 281.39 27.53 [2] 165.1 165.2 3.487 281.22 27.49 [2] 165.1 165.2 3.487 281.18 27.55 [2] 165.2 0.968 136.15 5.76 [2] 165.2 1.761 127.66 70.72 [2] 165.2 1.464 148.72 -73.46 [2] 165.2 165.3 2.129 190.96 1.71 [2] 165.2 165.3 2.136 191.00 1.17 [2] 165.2 165.3 2.138 191.11 1.38 [2] 165.3 0.520 307.04 3.20 [2] 165.3 1.696 163.78 88.49 [2] 165.3 1.486 307.66 -88.82 [2] 165.3 165.4 7.427 222.17 -1.27 [2] 165.3 165.4 7.429 222.20 -1.22 [2] 165.3 165.4 7.429 222.29 -1.14 [2] 165.4 0.421 135.38 -2.58 [2] 165.4 1.496 120.01 74.02 [2] 165.4 1.523 141.14 -83.93 [2] 165.4 165.5 2.229 224.30 -4.11 [2] 165.4 165.5 2.232 224.31 -4.20 [2] 165.4 165.5 2.232 224.24 -4.19 [2] 165.5 0.429 123.66 -2.22 [2] 165.5 1.489 167.01 79.72 [2] 165.5 1.391 129.13 -67.70 [2] 165.5 165.6 3.407 205.97 2.48 [2] 165.5 165.6 3.408 205.97 2.53 [2] 165.5 165.6 3.408 205.87 2.50 [2] 165.6 0.600 306.67 2.25 [2] 165.6 1.440 286.64 87.04 [2] 165.6 1.425 254.09 -86.11 [2] 165.6 165.7 3.125 212.11 -3.18 [2] 165.6 165.7 3.123 211.89 -3.15 [2] 165.6 165.7 3.124 212.29 -3.19 [2] 165.7 0.465 300.23 3.93 [2] 165.7 1.636 295.43 79.84 [2] 165.7 1.288 330.51 -77.32 [2] 165.7 165.8 3.006 223.51 -0.84 [2] 165.7 165.8 3.009 223.52 -0.83 [2] 165.7 165.8 3.007 223.47 -0.83 [2] 165.8 165.9 1.527 226.98 0.65 [2] 165.8 165.9 1.527 227.11 0.71 [2] 165.8 165.9 1.525 226.94 0.76 [2] 165.9 0.495 135.95 1.21 [2] 165.9 1.596 213.07 84.96 [2] 165.9 1.279 103.24 -86.61 [2] 165.9 165.10 4.129 230.73 -1.54 [2] 165.9 165.10 4.129 230.77 -1.50 [2] 165.9 165.10 4.127 230.71 -1.51 [2] 165.10 0.520 325.70 -0.62 [2] 165.10 1.626 297.20 82.81 [2] 165.10 1.230 73.64 -86.45 [2] 165.10 165.11 3.150 233.36 3.20 [2] 165.10 165.11 3.152 233.42 3.63 [2] 165.10 165.11 3.153 233.25 3.63 [2] 165.11 0.593 131.07 4.86 [2] 165.11 1.556 120.17 77.10 [2] 165.11 1.270 116.04 -80.16 [2] 165.11 165.12 7.287 213.32 -3.92 [2] 165.11 165.12 7.287 213.20 -3.92 [2] 165.11 165.12 7.285 213.24 -3.93 [2] 165.12 1.694 146.32 87.47 [2] 165.12 0.423 126.70 -0.32 [2] 165.12 1.279 252.88 -86.19 [2] 165.12 165.13 6.475 212.17 -46.93 [2] 165.12 165.13 6.484 212.36 -47.01 [2] 165.12 165.13 6.483 212.26 -46.99 [2] 165.13 4.120 42.62 77.87 [2] 165.13 1.061 314.62 6.76 [2] 165.13 0.202 124.55 9.65 [2] 165.13 1.604 286.44 -72.64 [2] 165.13 165.14 2.543 235.41 -15.58 [2] 165.13 165.14 2.543 235.64 -15.49 [2] 165.13 165.14 2.545 235.40 -15.74 [2] 165.14 0.631 107.29 -5.03 [2] 165.14 1.496 136.97 79.16 [2] 165.14 1.640 119.00 -83.97 [2] 165.14 165.15 1.922 201.91 -38.93 [2] 165.14 165.15 1.919 201.84 -38.84 [2] 165.14 165.15 1.920 202.91 -38.50 [2] 165.15 0.894 53.89 -6.97 [2] 165.15 2.581 44.23 83.91 [2] 165.15 1.544 98.15 -88.39 [2] 165.15 165.16 3.086 81.60 -16.59 [2] 165.15 165.16 3.079 81.67 -16.59 [2] 165.15 165.16 3.084 81.62 -16.61 [2] 165.16 0.438 352.06 0.95 [2] 165.16 1.294 359.99 78.22 [2] 165.16 1.026 228.83 -82.68 [2] 165.16 165.17 2.891 92.50 -62.03 [2] 165.16 165.17 2.891 92.73 -61.97 [2] 165.16 165.17 2.888 92.79 -62.07 [2] 165.17 0.754 321.88 -5.34 [2] 165.17 3.736 21.79 78.45 [2] 165.17 1.448 2.70 -78.49 [2] 165.17 165.18 4.259 53.40 -27.30 [2] 165.17 165.18 4.265 53.64 -27.54 [2] 165.17 165.18 4.269 53.70 -27.53 [2] 165.18 0.324 136.32 6.59 [2] 165.18 8.446 197.33 81.96 [2] 165.18 0.886 342.97 -73.79 [2] 165.18 165.19 4.318 46.41 -3.24 [2] 165.18 165.19 4.321 46.36 -3.24 [2] 165.18 165.19 4.318 46.54 -3.29 [2] 165.19 0.417 306.43 -0.14 [2] 165.19 1.112 259.87 88.38 [2] 165.19 0.187 125.54 0.08 [2] 165.19 0.578 205.77 -87.87 [2] 165.19 165.20 1.579 52.53 -1.32 [2] 165.19 165.20 1.579 52.84 -1.32 [2] 165.19 165.20 1.578 52.77 -1.33 [2] 165.20 0.454 166.31 -2.61 [2] 165.20 1.006 159.34 77.94 [2] 165.20 0.525 232.63 -86.75 [2] 165.20 0.938 312.95 2.07 [2] 165.20 2.520 351.69 -10.78 [2] 165.20 165.21 2.123 80.39 -1.16 [2] 165.20 165.21 2.132 80.02 -0.93 [2] 165.20 165.21 2.133 79.94 -0.76 [2] 165.21 0.410 332.70 -0.54 [2] 165.21 0.428 132.90 6.63 [2] 165.21 0.936 342.23 -80.06 [2] 165.21 165.22 1.406 48.93 -4.75 [2] 165.21 165.22 1.400 48.82 -4.55 [2] 165.21 165.22 1.402 48.97 -4.41 [2] 165.22 0.998 290.40 -3.78 [2] 165.22 0.371 99.12 -88.04 [2] 165.22 1.325 324.20 59.29 [2] 165.22 165.23 3.088 6.43 -5.04 [2] 165.22 165.23 3.085 6.49 -4.93 [2] 165.22 165.23 3.087 5.87 -4.69 [2] 165.23 0.426 256.35 2.38 [2] 165.23 1.002 238.69 83.28 [2] 165.23 0.219 190.83 -84.72 [2] 165.23 165.24 3.180 42.18 4.86 [2] 165.23 165.24 3.192 42.09 4.76 [2] 165.23 165.24 3.196 42.17 4.75 [2] 165.24 0.779 125.57 -5.13 [2] 165.24 0.802 142.71 55.91 [2] 165.24 0.485 280.12 -86.86 [2] 165.24 165.25 3.059 29.62 -4.14 [2] 165.24 165.25 3.043 29.67 -4.14 [2] 165.24 165.25 3.029 29.84 -4.28 [2] 165.25 0.344 112.86 -4.40 [2] 165.25 1.464 127.38 85.25 [2] 165.25 0.439 170.35 -87.52 [2] 165.25 165.26 5.159 27.66 -2.10 [2] 165.25 165.26 5.160 27.79 -2.05 [2] 165.25 165.26 5.160 27.66 -2.03 [2] 165.26 0.771 171.11 -0.62 [2] 165.26 1.707 170.49 74.14 [2] 165.26 0.779 178.54 -63.02 [2] 165.26 165.27 0.891 133.41 21.01 [2] 165.26 165.27 0.889 132.96 21.29 [2] 165.26 165.27 0.890 133.34 21.13 [2] 165.27 0.441 357.20 -2.32 [2] 165.27 1.196 355.05 86.80 [2] 165.27 0.997 115.85 -87.48 [2] 165.27 165.28 3.494 84.49 -0.37 [2] 165.27 165.28 3.493 84.49 -0.49 [2] 165.27 165.28 3.494 84.66 -0.60 [2] 165.28 0.370 344.06 -1.58 [2] 165.28 1.231 19.15 79.45 [2] 165.28 1.098 354.08 -82.52 [2] 165.28 165.29 4.488 57.42 0.17 [2] 165.28 165.29 4.490 57.39 0.21 [2] 165.28 165.29 4.490 57.43 0.18 [2] 165.29 0.541 322.47 -0.38 [2] 165.29 0.868 358.54 75.77 [2] 165.29 1.226 333.67 -79.23 [2] 165.29 165.30 4.197 52.63 -1.90 [2] 165.29 165.30 4.197 52.81 -1.97 [2] 165.29 165.30 4.195 52.70 -1.97 [2] 165.30 0.559 140.60 -1.62 [2] 165.30 1.112 146.54 80.67 [2] 165.30 1.189 240.45 -85.53 [2] 165.30 165.31 3.190 71.01 1.41 [2] 165.30 165.31 3.187 70.82 1.30 [2] 165.30 165.31 3.187 70.90 1.28 [2] 165.31 0.352 314.08 -0.84 [2] 165.31 0.997 0.39 80.18 [2] 165.31 1.465 312.34 -75.60 [2] 165.31 165.32 1.955 41.95 -0.80 [2] 165.31 165.32 1.955 41.95 -0.83 [2] 165.31 165.32 1.953 42.06 -0.90 [2] 165.32 0.388 186.52 -0.46 [2] 165.32 1.138 178.57 73.45 [2] 165.32 1.444 169.78 -83.20 [2] 165.32 165.33 1.183 108.77 -27.61 [2] 165.32 165.33 1.182 108.89 -27.76 [2] 165.32 165.33 1.182 108.67 -27.65 [2] 165.33 0.594 334.23 -1.87 [2] 165.33 0.242 158.16 0.40 [2] 165.33 0.822 320.62 -85.87 [2] 165.33 1.845 7.88 79.12 [2] 165.33 165.34 2.027 41.01 -1.29 [2] 165.33 165.34 2.028 40.95 -1.24 [2] 165.33 165.34 2.029 41.22 -1.36 [2] 165.34 0.534 325.09 5.51 [2] 165.34 1.803 189.89 84.38 [2] 165.34 0.815 37.21 -83.66 [2] 165.34 165.35 4.690 61.94 0.93 [2] 165.34 165.35 4.688 61.72 1.07 [2] 165.34 165.35 4.647 61.63 1.10 [2] 165.35 0.445 143.45 -4.62 [2] 165.35 1.376 128.03 79.97 [2] 165.35 0.980 108.51 -80.68 [2] 165.35 165.36 3.567 48.00 1.36 [2] 165.35 165.36 3.568 48.06 1.36 [2] 165.35 165.36 3.573 48.10 1.36 [2] 165.36 0.490 160.34 -9.61 [2] 165.36 0.761 117.65 78.72 [2] 165.36 1.261 168.57 -78.98 [2] 165.36 165.37 2.145 86.70 -1.39 [2] 165.36 165.37 2.118 86.93 -1.57 [2] 165.36 165.37 2.117 86.41 -1.30 [2] 165.37 0.509 323.59 5.31 [2] 165.37 0.835 327.69 77.28 [2] 165.37 1.067 336.30 -83.29 [2] 165.37 165.38 2.368 49.92 -8.75 [2] 165.37 165.38 2.368 49.92 -8.73 [2] 165.37 165.38 2.368 49.89 -8.72 [2] 165.38 0.476 142.08 14.04 [2] 165.38 1.350 145.26 78.67 [2] 165.38 0.804 318.62 -84.61 [2] 165.38 165.39 3.649 63.08 4.42 [2] 165.38 165.39 3.648 63.19 4.35 [2] 165.38 165.39 3.650 63.17 4.33 [2] 165.39 0.442 300.17 0.71 [2] 165.39 1.040 328.75 82.92 [2] 165.39 1.049 30.60 -77.32 [2] 165.39 165.40 2.660 25.53 -2.59 [2] 165.39 165.40 2.641 25.69 -2.57 [2] 165.39 165.40 2.639 25.54 -2.44 [2] 165.40 0.411 141.83 0.73 [2] 165.40 1.019 117.47 80.38 [2] 165.40 0.955 102.40 -69.23 [2] 165.40 165.41 7.849 65.65 1.88 [2] 165.40 165.41 7.847 65.56 1.84 [2] 165.40 165.41 7.845 65.53 1.84 [2] 165.41 0.826 225.24 7.58 [2] 165.41 0.874 171.67 86.94 [2] 165.41 1.534 219.66 -55.51 [2] 165.41 165.42 3.982 215.97 -4.62 [2] 165.41 165.42 3.983 215.76 -4.75 [2] 165.41 165.42 3.982 215.82 -4.76 [2] 165.42 0.483 316.97 -2.80 [2] 165.42 1.055 300.08 80.57 [2] 165.42 0.986 285.35 -78.94 [2] 165.42 165.43 2.216 233.48 0.55 [2] 165.42 165.43 2.215 233.81 0.53 [2] 165.42 165.43 2.214 233.82 0.57 [2] 165.43 0.486 125.18 -0.62 [2] 165.43 1.252 162.06 78.16 [2] 165.43 1.045 121.55 -82.42 [2] 165.43 165.44 4.040 203.86 -0.21 [2] 165.43 165.44 4.041 203.87 -0.27 [2] 165.43 165.44 4.039 203.85 -0.28 [2] 165.44 0.428 299.26 1.05 [2] 165.44 1.074 200.85 78.05 [2] 165.44 1.168 304.96 -85.05 [2] 165.44 165.45 5.659 233.81 0.62 [2] "Disto batteries changed and disto recalibrated before this leg." 165.44 165.45 5.651 233.76 0.62 [2] 165.44 165.45 5.656 233.73 0.51 [2] 165.45 0.463 114.52 -12.27 [2] 165.45 0.955 123.34 64.03 [2] 165.45 1.363 146.04 -73.97 [2] 165.45 165.46 2.155 186.82 -5.64 [2] 165.45 165.46 2.152 186.77 -5.80 [2] 165.45 165.46 2.155 186.77 -5.56 [2] 165.46 0.343 284.71 6.20 [2] 165.46 1.033 303.37 79.18 [2] 165.46 1.227 216.15 -83.25 [2] 165.46 165.47 2.686 210.05 -0.95 [2] 165.46 165.47 2.687 210.16 -1.01 [2] 165.46 165.47 2.687 210.02 -0.82 [2] 165.47 0.421 132.35 2.41 [2] 165.47 0.941 148.66 82.13 [2] 165.47 1.031 152.70 -87.23 [2] 165.47 165.48 1.426 230.00 -1.49 [2] 165.47 165.48 1.424 231.50 -1.33 [2] 165.47 165.48 1.424 230.20 -1.28 [2] 165.48 0.415 143.81 -1.72 [2] 165.48 1.208 164.82 72.39 [2] 165.48 1.169 178.23 -82.45 [2] 165.48 165.49 2.099 240.45 0.17 [2] 165.48 165.49 2.100 240.68 0.32 [2] 165.48 165.49 2.101 240.63 0.34 [2] 165.49 0.338 144.54 -2.81 [2] 165.49 1.067 140.06 72.28 [2] 165.49 1.137 148.33 -84.52 [2] 165.49 165.50 3.472 237.35 -2.93 [2] 165.49 165.50 3.471 237.42 -2.92 [2] 165.49 165.50 3.473 237.32 -3.07 [2] 165.50 0.387 342.06 4.00 [2] 165.50 1.001 213.59 85.36 [2] 165.50 1.123 355.33 -83.46 [2] 165.50 165.51 2.902 256.55 4.58 [2] 165.50 165.51 2.901 256.50 4.58 [2] 165.50 165.51 2.903 256.54 4.61 [2] 165.51 0.345 148.28 -8.51 [2] 165.51 0.885 141.02 77.66 [2] 165.51 1.431 132.19 -87.31 [2] 165.51 165.52 3.164 240.12 -3.09 [2] 165.51 165.52 3.167 240.09 -3.07 [2] 165.51 165.52 3.165 240.16 -3.06 [2] 165.52 0.419 319.87 -2.28 [2] 165.52 0.871 109.67 87.31 [2] 165.52 1.361 303.04 -83.50 [2] 165.52 165.53 2.599 232.29 -0.79 [2] 165.52 165.53 2.599 232.12 -0.80 [2] 165.52 165.53 2.599 232.14 -0.80 [2] 165.53 0.354 305.99 3.07 [2] 165.53 1.006 139.41 87.41 [2] 165.53 1.662 309.66 -77.10 [2] 165.53 165.54 4.538 221.11 -21.77 [2] 165.53 165.54 4.539 221.13 -21.78 [2] 165.53 165.54 4.540 221.11 -21.78 [2] 165.54 0.564 125.43 -3.35 [2] 165.54 2.112 135.69 69.41 [2] 165.54 1.128 232.20 -85.00 [2] 165.54 165.55 1.202 181.29 -8.15 [2] 165.54 165.55 1.203 181.14 -8.10 [2] 165.54 165.55 1.204 181.22 -8.10 [2] 165.55 0.622 284.76 -5.11 [2] 165.55 2.015 219.37 82.06 [2] 165.55 3.358 237.83 -84.61 [2] 165.55 165.56 1.948 153.95 -70.77 [2] 165.55 165.56 1.942 154.40 -70.67 [2] 165.55 165.56 1.943 154.12 -70.69 [2] 165.56 1.450 280.79 0.23 [2] 165.56 3.918 286.08 82.18 [2] 165.56 1.940 266.28 -63.29 [2] 165.56 165.57 5.593 228.31 -7.01 [2] 165.56 165.57 5.610 228.21 -6.94 [2] 165.56 165.57 5.607 228.22 -6.88 [2] 165.57 0.662 140.56 -17.36 [2] 165.57 0.657 148.24 53.81 [2] 165.57 1.176 95.03 -74.03 [2] 165.57 165.58 6.312 217.05 -41.17 [2] 165.57 165.58 6.316 217.04 -41.17 [2] 165.57 165.58 6.329 217.07 -41.13 [2] 165.58 1.042 141.20 -11.06 [2] 165.58 1.979 317.32 -13.13 [2] 165.58 2.963 289.31 83.86 [2] 165.58 0.375 164.39 -87.86 [2] 165.58 4.156 41.63 18.73 [2] CaveConverter_src/test/data/regression/Sloppy2ZigZags_pt_ref.text0000644000000000000000000001560312217344034024362 0ustar rootroot -6 1 1 1 1 Cave Name -5 1 1 1 1 0.00 0.00 0.00 1 0 -4 1 1 1 1 12/08/16 13:14:15 CaveConverter -3 1 1 1 1 -2 1 1 1 1 16/08/12 Converted Data 0 0.00 0 1 -1 1 1 1 1 360.00 360.00 0.05 1.00 1.00 100.00 0.00 1 -2 1 1 1 Series 1-root.uzu110810sloppypt2.161 1 -1 1 1 1 1 0 1 19 19 3 0 1 0 1 1 1 0.00 0.00 0.00 1.41 1.69 8.55 1.79 1 1 1 1 1 8.84 224.95 74.29 0.71 0.00 1.85 0.67 1 2 1 1 1 1.29 177.76 16.14 0.72 0.00 2.20 0.82 1 3 1 1 1 9.45 62.80 8.45 0.00 0.76 4.85 1.06 1 4 1 1 1 3.09 174.44 77.16 0.73 0.00 4.20 1.25 1 5 1 1 1 3.04 80.70 -0.77 0.48 0.00 4.37 0.97 1 6 1 1 1 7.44 29.62 5.20 0.00 0.73 4.95 0.72 1 7 1 1 1 5.85 35.05 1.09 1.68 0.00 8.51 0.53 1 8 1 1 1 9.45 7.85 51.31 0.00 0.68 4.43 1.86 1 9 1 1 1 2.60 65.73 -6.30 0.61 0.00 4.33 1.07 1 10 1 1 1 4.48 6.77 7.25 0.00 0.67 4.23 0.74 1 11 1 1 1 3.86 56.51 1.91 0.99 0.00 4.15 0.55 1 12 1 1 1 7.66 28.32 10.32 0.46 0.00 3.68 0.81 1 13 1 1 1 1.09 289.21 11.36 0.63 0.00 3.35 0.96 1 14 1 1 1 3.87 230.95 3.41 0.00 0.70 3.37 0.93 1 15 1 1 1 4.60 249.81 2.49 0.00 0.75 3.39 0.82 1 16 1 1 1 4.46 260.87 6.91 0.59 0.00 2.27 0.93 1 17 1 1 1 7.41 236.86 0.94 0.00 1.09 7.25 0.79 1 18 1 1 1 1.79 282.80 9.24 1.28 0.00 6.28 1.08 1 19 1 1 1 14.75 240.76 9.56 1.44 2.82 48.16 1.89 2 -2 1 1 1 Series 2-root.uzu110810sloppypt2.165 2 -1 1 1 1 1 4 2 57 57 3 0 2 0 1 1 1 0.00 0.00 0.00 0.57 0.49 3.78 1.58 2 1 1 1 1 3.48 279.26 27.52 0.95 0.00 1.66 1.40 2 2 1 1 1 2.13 189.02 1.42 0.00 0.51 1.70 1.49 2 3 1 1 1 7.43 220.22 -1.21 0.42 0.00 1.44 1.51 2 4 1 1 1 2.23 222.28 -4.17 0.53 0.00 1.47 1.29 2 5 1 1 1 3.41 203.94 2.50 0.00 0.59 1.44 1.42 2 6 1 1 1 3.12 210.10 -3.17 0.00 0.46 1.61 1.26 2 7 1 1 1 3.01 221.50 -0.83 0.00 0.00 0.00 0.00 2 8 1 1 1 1.53 225.01 0.71 0.49 0.00 1.59 1.28 2 9 1 1 1 4.13 228.74 -1.52 0.00 0.52 1.61 1.23 2 10 1 1 1 3.15 231.34 3.49 0.59 0.00 1.52 1.25 2 11 1 1 1 7.29 211.25 -3.92 0.42 0.00 1.69 1.28 2 12 1 1 1 6.48 210.26 -46.98 0.20 1.05 4.03 1.53 2 13 1 1 1 2.54 233.48 -15.60 0.58 0.00 1.47 1.63 2 14 1 1 1 1.92 200.22 -38.76 0.89 0.00 2.57 1.54 2 15 1 1 1 3.08 79.63 -16.60 0.44 0.00 1.27 1.02 2 16 1 1 1 2.89 90.67 -62.02 0.70 0.00 3.66 1.42 2 17 1 1 1 4.26 51.58 -27.46 0.00 0.32 8.36 0.85 2 18 1 1 1 4.32 44.44 -3.26 0.41 0.18 1.11 0.58 2 19 1 1 1 1.58 50.71 -1.32 2.39 0.45 0.98 0.52 2 20 1 1 1 2.13 78.12 -0.95 0.41 0.40 0.00 0.92 2 21 1 1 1 1.40 46.91 -4.57 0.99 0.00 1.14 0.37 2 22 1 1 1 3.09 4.26 -4.89 0.34 0.00 1.00 0.22 2 23 1 1 1 3.19 40.15 4.79 0.00 0.78 0.66 0.48 2 24 1 1 1 3.04 27.71 -4.19 0.00 0.34 1.46 0.44 2 25 1 1 1 5.16 25.70 -2.06 0.00 0.77 1.64 0.69 2 26 1 1 1 0.89 131.24 21.14 0.41 0.00 1.19 1.00 2 27 1 1 1 3.49 82.55 -0.49 0.37 0.00 1.21 1.09 2 28 1 1 1 4.49 55.41 0.19 0.54 0.00 0.84 1.20 2 29 1 1 1 4.20 50.71 -1.95 0.00 0.55 1.10 1.19 2 30 1 1 1 3.19 68.91 1.33 0.34 0.00 0.98 1.42 2 31 1 1 1 1.95 39.99 -0.84 0.00 0.36 1.09 1.43 2 32 1 1 1 1.18 106.78 -27.67 0.58 0.24 1.81 0.82 2 33 1 1 1 2.03 39.06 -1.30 0.53 0.00 1.79 0.81 2 34 1 1 1 4.68 59.76 1.03 0.00 0.44 1.35 0.97 2 35 1 1 1 3.57 46.05 1.36 0.00 0.48 0.75 1.24 2 36 1 1 1 2.13 84.68 -1.42 0.49 0.00 0.81 1.06 2 37 1 1 1 2.37 47.91 -8.73 0.00 0.46 1.32 0.80 2 38 1 1 1 3.65 61.15 4.37 0.43 0.00 1.03 1.02 2 39 1 1 1 2.65 23.59 -2.53 0.00 0.41 1.00 0.89 2 40 1 1 1 7.85 63.58 1.85 0.00 0.85 0.87 1.26 2 41 1 1 1 3.98 213.85 -4.71 0.00 0.48 1.04 0.97 2 42 1 1 1 2.22 231.70 0.55 0.49 0.00 1.23 1.04 2 43 1 1 1 4.04 201.86 -0.25 0.00 0.42 1.05 1.16 2 44 1 1 1 5.66 231.77 0.58 0.45 0.00 0.86 1.31 2 45 1 1 1 2.15 184.79 -5.67 0.00 0.34 1.01 1.22 2 46 1 1 1 2.69 208.08 -0.93 0.42 0.00 0.93 1.03 2 47 1 1 1 1.42 228.57 -1.37 0.41 0.00 1.15 1.16 2 48 1 1 1 2.10 238.59 0.28 0.34 0.00 1.02 1.13 2 49 1 1 1 3.47 235.36 -2.97 0.00 0.38 1.00 1.12 2 50 1 1 1 2.90 254.53 4.59 0.34 0.00 0.86 1.43 2 51 1 1 1 3.17 238.12 -3.07 0.00 0.42 0.87 1.35 2 52 1 1 1 2.60 230.18 -0.80 0.00 0.35 1.00 1.62 2 53 1 1 1 4.54 219.12 -21.78 0.68 0.00 1.98 1.12 2 54 1 1 1 1.20 179.22 -8.12 0.00 0.55 2.00 3.34 2 55 1 1 1 1.94 152.16 -70.71 0.00 1.45 3.88 1.73 2 56 1 1 1 5.60 226.25 -6.94 0.63 0.00 0.53 1.13 2 57 1 1 1 6.32 215.05 -41.16 0.99 1.90 2.95 0.37CaveConverter_src/test/data/regression/GourAven_in.txt0000644000000000000000000003202611430100560022207 0ustar rootrootGourAven2010 (m, 360) [1]: 2010/08/09 1.92 153.58 154.0 0.000 0.00 0.00 [1] 154.0 154.1 2.241 139.84 28.25 [1] 154.0 154.1 2.243 140.02 28.37 [1] 154.0 154.1 2.243 139.99 28.33 [1] 154.1 154.2 5.911 71.00 27.67 [1] 154.1 154.2 5.911 70.74 27.67 [1] 154.1 154.2 5.911 70.85 27.69 [1] 154.2 1.168 8.87 6.87 [1] 154.2 1.113 175.45 -0.10 [1] 154.2 5.951 98.10 6.04 [1] 154.2 5.008 277.41 17.22 [1] 154.2 1.035 47.72 83.13 [1] 154.2 1.094 153.35 -85.85 [1] 154.2 154.3 5.082 327.58 56.79 [1] 154.2 154.3 5.086 327.41 56.75 [1] 154.2 154.3 5.084 327.41 56.75 [1] 154.3 1.825 181.36 -15.46 [1] 154.3 1.334 327.55 17.32 [1] 154.3 1.039 351.41 82.16 [1] 154.3 3.638 226.41 -81.95 [1] 154.3 154.4 4.911 69.77 23.92 [1] 154.3 154.4 4.911 69.80 23.86 [1] 154.3 154.4 4.926 69.93 23.79 [1] 154.4 0.954 165.48 0.82 [1] 154.4 3.803 331.85 24.88 [1] 154.4 2.960 27.78 70.94 [1] 154.4 1.755 85.45 -85.86 [1] 154.4 13.104 71.82 16.81 [1] 154.4 7.755 33.32 29.66 [1] 154.4 5.735 289.73 15.19 [1] 154.4 5.017 257.83 -9.98 [1] 154.4 2.805 233.18 -16.44 [1] 154.4 154.5 1.996 337.60 33.03 [1] 154.4 154.5 1.996 337.69 33.12 [1] 154.4 154.5 1.997 337.46 33.11 [1] 154.5 1.670 169.43 -3.02 [1] 154.5 1.996 339.94 5.13 [1] 154.5 1.854 274.03 82.17 [1] 154.5 0.754 63.40 -83.13 [1] 154.5 154.6 11.329 256.77 -5.07 [1] 154.5 154.6 11.329 256.87 -4.98 [1] 154.5 154.6 11.329 256.88 -5.02 [1] 154.6 1.214 159.96 0.46 [1] 154.6 3.669 337.52 19.11 [1] 154.6 0.922 247.84 78.92 [1] 154.6 1.131 41.95 -84.98 [1] 154.6 154.7 4.828 315.30 34.34 [1] 154.6 154.7 4.828 315.54 34.36 [1] 154.6 154.7 4.828 315.38 34.37 [1] 154.7 2.040 300.83 20.04 [1] 154.7 3.282 141.10 -6.14 [1] 154.7 5.227 73.82 81.18 [1] 154.7 1.337 110.40 -86.27 [1] 154.7 4.046 103.53 3.40 [1] 154.7 4.140 69.26 18.44 [1] 154.7 4.706 21.66 32.61 [1] 154.7 3.117 254.93 11.55 [1] 154.7 7.307 221.39 2.77 [1] 154.7 7.078 196.12 -0.28 [1] 154.7 154.8 10.949 55.60 35.29 [1] 154.7 154.8 10.955 55.76 35.30 [1] 154.7 154.8 10.960 55.76 35.37 [1] 154.8 2.211 141.89 4.58 [1] 154.8 3.299 91.35 82.63 [1] 154.8 1.359 275.45 -87.94 [1] 154.8 154.9 9.780 65.87 3.29 [1] 154.8 154.9 9.776 65.81 3.28 [1] 154.8 154.9 9.774 65.85 3.24 [1] 154.9 1.711 329.31 8.11 [1] 154.9 0.795 142.99 2.96 [1] 154.9 1.702 334.25 82.05 [1] 154.9 0.611 34.54 -85.87 [1] 154.9 3.983 233.45 -1.12 [1] 154.9 154.10 4.019 65.15 22.02 [1] 154.9 154.10 4.020 65.03 22.06 [1] 154.9 154.10 4.020 64.92 22.13 [1] 154.10 0.323 331.55 9.28 [1] 154.10 0.250 189.16 11.19 [1] 154.10 0.532 224.81 78.61 [1] 154.10 0.365 85.36 -83.64 [1] 154.10 154.11 2.664 124.88 6.25 [1] 154.10 154.11 2.659 124.74 6.23 [1] 154.10 154.11 2.660 124.70 6.20 [1] 154.11 1.635 326.77 17.05 [1] 154.11 0.422 169.26 -0.39 [1] 154.11 0.981 164.51 86.78 [1] 154.11 0.261 25.57 -86.76 [1] 154.11 6.436 244.26 -33.76 [1] 154.11 154.12 4.676 28.05 41.17 [1] 154.11 154.12 4.684 28.16 41.13 [1] 154.11 154.12 4.685 28.49 41.17 [1] 154.12 0.488 163.24 -3.84 [1] 154.12 2.054 326.35 6.05 [1] 154.12 6.639 296.93 79.59 [1] 154.12 3.007 156.92 -82.68 [1] 154.12 3.452 44.58 36.15 [1] 154.12 7.313 45.38 40.15 [1] 154.12 7.437 59.56 40.31 [1] 154.12 5.499 20.21 43.16 [1] 154.12 2.856 2.96 33.73 [1] 154.12 2.892 291.62 14.24 [1] 154.12 2.349 256.10 14.98 [1] 154.12 12.698 20.35 69.18 [1] 154.12 154.13 4.741 257.83 20.69 [1] 154.12 154.13 4.732 257.83 20.73 [1] 154.12 154.13 4.739 257.83 20.68 [1] 154.13 0.326 143.07 -2.33 [1] 154.13 0.613 117.22 76.36 [1] 154.13 0.841 289.69 -81.40 [1] 154.13 154.14 3.646 238.11 -5.08 [1] 154.13 154.14 3.645 238.15 -5.03 [1] 154.13 154.14 3.647 238.15 -5.07 [1] 154.14 0.398 134.05 0.55 [1] 154.14 0.451 325.26 7.61 [1] 154.14 8.219 65.42 88.46 [1] 154.14 0.277 75.71 -85.74 [1] 154.14 154.15 1.183 304.19 22.56 [1] 154.14 154.15 1.184 304.15 22.51 [1] 154.14 154.15 1.184 304.10 22.54 [1] 154.15 0.293 177.36 -2.22 [1] 154.15 4.625 186.26 82.17 [1] 154.15 0.801 117.91 -84.94 [1] 154.15 154.16 3.004 254.39 20.66 [1] 154.15 154.16 3.009 254.36 20.55 [1] 154.15 154.16 3.009 254.20 20.48 [1] 154.16 0.306 186.04 14.63 [1] 154.16 0.354 13.09 -6.44 [1] 154.16 0.759 28.25 88.09 [1] 154.16 0.942 254.97 -82.68 [1] 154.16 154.17 2.799 262.32 32.14 [1] 154.16 154.17 2.801 262.28 32.09 [1] 154.16 154.17 2.798 262.23 32.07 [1] 154.17 1.871 272.52 88.42 [1] 154.17 1.015 46.41 -85.96 [1] 154.17 0.820 86.30 -3.90 [1] 154.17 154.18 2.505 130.44 27.50 [1] 154.17 154.18 2.506 130.46 27.58 [1] 154.17 154.18 2.506 130.49 27.59 [1] 154.18 1.108 346.65 2.19 [1] 154.18 0.508 253.02 6.82 [1] 154.18 1.912 43.25 -1.46 [1] 154.18 1.806 40.33 85.61 [1] 154.18 0.479 47.06 -88.61 [1] 154.18 154.19 1.599 82.86 -6.48 [1] 154.18 154.19 1.598 82.85 -6.44 [1] 154.18 154.19 1.599 82.79 -6.41 [1] 154.19 0.645 247.70 3.08 [1] 154.19 1.366 325.71 78.59 [1] 154.19 0.481 21.99 -87.43 [1] 154.19 154.20 2.616 206.21 -3.63 [1] 154.19 154.20 2.615 206.09 -3.57 [1] 154.19 154.20 2.616 206.10 -3.51 [1] 154.20 0.709 324.21 6.09 [1] 154.20 3.671 28.83 83.37 [1] 154.20 0.472 22.70 -85.65 [1] 154.20 154.21 2.743 273.17 46.72 [1] 154.20 154.21 2.740 273.15 46.90 [1] 154.20 154.21 2.739 273.19 46.83 [1] 154.21 0.766 150.79 -11.23 [1] 154.21 3.231 324.73 31.68 [1] 154.21 1.447 67.41 10.21 [1] 154.21 9.983 19.22 82.51 [1] 154.21 154.22 5.183 26.76 41.33 [1] 154.21 154.22 5.179 26.81 41.35 [1] 154.21 154.22 5.180 26.77 41.29 [1] 154.22 1.733 308.53 4.45 [1] 154.22 2.167 133.73 2.41 [1] 154.22 11.689 263.63 88.10 [1] 154.22 0.845 270.34 -88.39 [1] 154.22 8.279 215.65 -4.87 [1] 154.22 8.345 236.94 -5.86 [1] 154.22 16.081 233.79 -2.48 [1] 154.22 5.264 1.49 37.58 [1] 154.22 5.752 61.72 37.02 [1] 154.22 6.381 77.99 35.97 [1] 154.22 154.23 6.090 69.38 35.14 [1] 154.22 154.23 6.087 69.41 35.07 [1] 154.22 154.23 6.088 69.51 35.04 [1] 154.23 0.593 337.77 0.96 [1] 154.23 0.895 158.22 11.19 [1] 154.23 1.967 131.11 80.39 [1] 154.23 1.371 52.83 -84.85 [1] 154.23 154.24 2.803 330.54 -45.59 [1] 154.23 154.24 2.803 330.33 -45.47 [1] 154.23 154.24 2.804 330.29 -45.41 [1] 154.24 0.855 96.82 1.32 [1] 154.24 0.838 81.63 84.42 [1] 154.24 0.808 97.55 -86.69 [1] 154.24 154.25 3.965 24.86 -39.94 [1] 154.24 154.25 3.947 24.80 -39.93 [1] 154.24 154.25 3.954 24.26 -39.55 [1] 154.25 0.951 319.89 3.51 [1] 154.25 0.666 156.49 -5.81 [1] 154.25 0.693 60.41 -86.00 [1] 154.25 154.26 2.563 117.61 -45.70 [1] 154.25 154.26 2.561 117.77 -45.75 [1] 154.25 154.26 2.558 117.77 -45.69 [1] 154.26 1.178 13.93 -5.75 [1] 154.26 1.029 32.39 84.20 [1] 154.26 0.405 312.35 -76.72 [1] 154.26 154.27 2.203 86.00 -7.92 [1] 154.26 154.27 2.203 85.96 -7.95 [1] 154.26 154.27 2.204 85.86 -7.84 [1] 154.27 0.976 329.16 1.13 [1] 154.27 0.384 237.47 -79.56 [1] 154.27 0.269 125.51 -0.87 [1] 154.27 154.28 1.360 72.44 62.52 [1] 154.27 154.28 1.359 72.33 62.62 [1] 154.27 154.28 1.360 72.22 62.55 [1] 154.28 1.453 186.85 -3.82 [1] 154.28 0.320 24.31 -0.28 [1] 154.28 0.591 261.97 -84.55 [1] 154.28 154.29 1.405 121.83 -18.92 [1] 154.28 154.29 1.389 122.13 -18.81 [1] 154.28 154.29 1.387 121.92 -18.80 [1] 154.29 0.898 115.27 -1.66 [1] 154.29 1.599 299.34 0.63 [1] 154.29 1.871 125.54 73.79 [1] 154.29 6.929 84.61 -64.07 [1] 154.29 154.30 0.858 110.18 6.30 [1] 154.29 154.30 0.860 110.37 6.41 [1] 154.29 154.30 0.860 110.40 6.34 [1] 154.30 154.31 8.547 169.23 -79.60 [1] 154.30 154.31 8.511 168.81 -79.71 [1] 154.30 154.31 8.502 168.00 -79.83 [1] CaveConverter_src/test/data/regression/NightMare_ss_ref.svx0000644000000000000000000000301312172776722023234 0ustar rootroot*BEGIN NightMare *DATE 2007.07.01 *CALIBRATE declination 2.28 *EQUATE 25 Mares090408a.0 *EQUATE 7 2007a.7 *EQUATE Mares090408a.4 Mares090408b.4 1 2 1.72 145.00 -47.00 2 3 2.90 353.00 -49.00 3 4 4.22 0.00 -90.00 4 5 4.95 103.00 11.00 5 6 2.17 72.00 40.00 6 7 2.51 100.00 -35.00 7 9 2.98 68.00 19.00 9 10 3.00 110.00 -2.00 10 11 2.58 98.00 -11.00 11 12 4.80 0.00 -90.00 11 13 4.40 48.00 -11.00 13 14 2.30 20.00 -43.00 14 15 7.35 50.00 -4.00 15 16 7.35 35.00 -5.00 16 17 4.10 25.00 14.00 17 18 5.90 73.00 -5.00 18 19 7.40 32.00 -3.00 19 20 5.63 49.00 -3.00 20 21 3.91 110.00 -4.00 21 22 4.02 85.00 2.00 22 23 3.00 38.00 -3.00 23 24 3.30 150.00 -11.00 24 25 6.57 99.00 0.00 25 26 1.82 182.00 3.00 26 27 1.91 28.00 7.00 26 28 2.50 202.00 20.00 *BEGIN 2007a *DATE 2007.07.01 7 8 6.90 222.00 -11.00 *END 2007a *BEGIN Mares090408a *DATE 2009.04.08 *CALIBRATE declination 2.08 0 1 3.00 91.06 6.73 1 2 2.91 20.29 3.57 2 3 4.11 19.88 -2.27 3 4 2.03 331.14 4.87 4 5 2.43 28.98 -37.75 *END Mares090408a *BEGIN Mares090408b *DATE 2009.04.08 *CALIBRATE declination 2.08 *EQUATE 6 6a 4 6a 1.91 63.99 -6.15 6a 7 3.35 32.37 -4.35 6 8 8.17 104.93 -1.38 8 9 1.78 139.35 4.60 9 10 2.70 100.81 0.36 10 11 4.72 56.33 -3.82 11 12 1.25 69.40 -4.66 12 13 2.95 112.51 -3.77 12 14 3.97 136.09 3.99 14 15 1.44 68.87 -26.54 15 16 2.30 131.94 -17.98 *END Mares090408b *END NightMare CaveConverter_src/test/data/regression/flags_in.svx0000644000000000000000000000577212166352206021603 0ustar rootroot*BEGIN Swildons *EQUATE Ent EntranceZigZags.3 *EQUATE surfacegps.4 EntranceZigZags.3 *EQUATE EntranceZigZags.5 LongDryWay.0 *EQUATE LongDryWay.5 EntranceZigZags.21 *EQUATE LongDryWay.5 ShortDryWay.0 *BEGIN surfacegps *FLAGS SURFACE 0 1 9.84 94.37 -5.88 1 2 7.84 97.65 -8.05 2 3 11.76 94.27 -17.67 3 4 4.38 7.38 -23.29 3 5 5.45 262.93 13.06 5 6 8.80 174.95 11.61 6 7 13.78 168.31 12.55 *END surfacegps *BEGIN EntranceZigZags *FLAGS SURFACE 0 1 2.98 10.26 -2.01 0 2 5.24 3.23 -5.04 2 3 2.64 166.70 -60.11 *FLAGS NOT SURFACE 3 4 3.10 330.76 -25.13 4 5 4.51 275.80 -12.10 5 6 2.41 50.67 -22.33 6 7 1.08 37.30 11.53 7 8 2.00 6.10 11.51 8 9 1.01 56.60 0.18 9 10 3.07 336.52 5.81 9 11 2.42 64.64 5.29 11 12 4.50 106.56 19.29 10 13 0.94 80.55 -45.63 13 14 5.31 65.16 19.50 10 15 3.27 329.15 -18.16 15 16 3.57 334.08 -6.33 16 17 2.41 207.98 -9.43 17 18 4.05 308.01 -19.25 18 19 2.06 211.48 -16.06 19 20 2.94 233.55 -35.84 20 21 2.04 14.57 -39.09 *END EntranceZigZags *BEGIN LongDryWay 0 1 4.08 270.72 -25.50 1 2 3.77 354.35 -29.81 2 3 4.33 336.10 -24.79 3 4 2.77 337.70 -4.41 4 5 3.14 343.71 -25.59 *END LongDryWay *BEGIN ShortDryWay 0 1 1.43 131.61 -13.25 *FLAGS SPLAY 1 1a 1.42 311.07 12.80 1 1b 0.58 327.33 -0.57 1 1c 0.50 258.56 -34.18 1 1d 0.94 171.13 -6.41 *FLAGS NOT SPLAY DUPLICATE 1 2 3.89 73.29 -51.63 *FLAGS SPLAY 2 2a 3.91 252.77 52.00 2 2b 2.44 239.99 47.81 2 2c 0.91 252.72 -4.04 2 2d 0.80 250.31 -35.24 *FLAGS NOT SPLAY NOT DUPLICATE 2 3 4.50 170.72 19.68 *FLAGS SPLAY 3 3a 1.54 358.12 82.08 3 3b 0.94 170.44 -79.46 3 3c 0.46 71.39 -4.30 3 3d 0.45 220.38 -6.59 3 3e 4.46 350.50 -20.39 3 3f 0.39 251.63 -13.19 *FLAGS NOT SPLAY 3 4 1.11 246.49 -14.16 *FLAGS SPLAY 4 4a 0.60 345.93 65.79 4 4b 0.68 212.13 -85.64 4 4c 0.28 4.71 4.35 4 4d 2.84 294.88 -9.50 *FLAGS NOT SPLAY 2 5 4.91 323.66 2.34 *FLAGS SPLAY 5 5a 1.68 227.27 67.16 5 5b 0.87 46.77 -82.61 5 5c 4.91 143.73 -2.57 5 5d 0.74 236.15 -6.85 5 5e 1.03 103.39 -8.81 5 5f 2.18 148.83 -2.53 *FLAGS NOT SPLAY 5 6 5.05 279.35 -25.23 *FLAGS SPLAY 6 6a 2.83 16.27 74.62 6 6b 1.16 111.26 -85.03 6 6c 5.05 99.27 25.32 6 6d 0.58 34.79 1.49 6 6e 2.60 99.05 2.63 6 6f 2.79 105.09 4.91 *FLAGS NOT SPLAY 6 7 5.02 336.36 -13.85 *FLAGS SPLAY DUPLICATE 7 7a 3.73 254.43 80.33 7 7b 0.54 182.41 -84.02 7 7c 2.55 328.39 -82.67 7 7d 5.00 156.87 13.29 7 7e 0.41 231.77 -3.06 *FLAGS NOT SPLAY NOT DUPLICATE 7 8 3.19 303.08 -33.11 *FLAGS SPLAY NOT DUPLICATE 8 8a 4.46 353.35 80.60 8 8b 1.45 224.40 -78.95 8 8c 3.21 123.01 33.05 8 8d 0.53 23.07 -5.56 8 8e 1.87 72.08 1.35 *FLAGS NOT SPLAY 8 9 6.71 295.69 -12.15 *FLAGS SPLAY 9 9a 1.16 244.84 81.25 9 9b 1.09 201.63 -76.54 9 9c 6.72 115.55 11.83 9 9d 0.56 196.48 2.10 9 9e 3.56 117.58 -4.92 *FLAGS NOT SPLAY 9 10 1.11 265.93 2.35 *END ShortDryWay *END Swildons CaveConverter_src/test/data/regression/GourAven_ps_ref.svx0000644000000000000000000001427712226764012023104 0ustar rootroot*BEGIN GourAven2010 *EQUATE 153.58 154.0 *BEGIN 154 *DATE 2010.08.09 *CALIBRATE declination 1.92 0 1 2.24 139.95 28.32 1 2 5.91 70.86 27.68 *FLAGS SPLAY 2 2a 1.17 8.87 6.87 2 2b 1.11 175.45 -0.10 2 2c 5.95 98.10 6.04 2 2d 5.01 277.41 17.22 2 2e 1.04 47.72 83.13 2 2f 1.09 153.35 -85.85 *FLAGS NOT SPLAY 2 3 5.08 327.47 56.76 *FLAGS SPLAY 3 3a 1.82 181.36 -15.46 3 3b 1.33 327.55 17.32 3 3c 1.04 351.41 82.16 3 3d 3.64 226.41 -81.95 *FLAGS NOT SPLAY 3 4 4.92 69.83 23.86 *FLAGS SPLAY 4 4a 0.95 165.48 0.82 4 4b 3.80 331.85 24.88 4 4c 2.96 27.78 70.94 4 4d 1.76 85.45 -85.86 4 4e 13.10 71.82 16.81 4 4f 7.76 33.32 29.66 4 4g 5.74 289.73 15.19 4 4h 5.02 257.83 -9.98 4 4i 2.80 233.18 -16.44 *FLAGS NOT SPLAY 4 5 2.00 337.58 33.09 *FLAGS SPLAY 5 5a 1.67 169.43 -3.02 5 5b 2.00 339.94 5.13 5 5c 1.85 274.03 82.17 5 5d 0.75 63.40 -83.13 *FLAGS NOT SPLAY 5 6 11.33 256.84 -5.02 *FLAGS SPLAY 6 6a 1.21 159.96 0.46 6 6b 3.67 337.52 19.11 6 6c 0.92 247.84 78.92 6 6d 1.13 41.95 -84.98 *FLAGS NOT SPLAY 6 7 4.83 315.41 34.36 *FLAGS SPLAY 7 7a 2.04 300.83 20.04 7 7b 3.28 141.10 -6.14 7 7c 5.23 73.82 81.18 7 7d 1.34 110.40 -86.27 7 7e 4.05 103.53 3.40 7 7f 4.14 69.26 18.44 7 7g 4.71 21.66 32.61 7 7h 3.12 254.93 11.55 7 7i 7.31 221.39 2.77 7 7j 7.08 196.12 -0.28 *FLAGS NOT SPLAY 7 8 10.95 55.71 35.32 *FLAGS SPLAY 8 8a 2.21 141.89 4.58 8 8b 3.30 91.35 82.63 8 8c 1.36 275.45 -87.94 *FLAGS NOT SPLAY 8 9 9.78 65.84 3.27 *FLAGS SPLAY 9 9a 1.71 329.31 8.11 9 9b 0.80 142.99 2.96 9 9c 1.70 334.25 82.05 9 9d 0.61 34.54 -85.87 9 9e 3.98 233.45 -1.12 *FLAGS NOT SPLAY 9 10 4.02 65.03 22.07 *FLAGS SPLAY 10 10a 0.32 331.55 9.28 10 10b 0.25 189.16 11.19 10 10c 0.53 224.81 78.61 10 10d 0.36 85.36 -83.64 *FLAGS NOT SPLAY 10 11 2.66 124.77 6.23 *FLAGS SPLAY 11 11a 1.64 326.77 17.05 11 11b 0.42 169.26 -0.39 11 11c 0.98 164.51 86.78 11 11d 0.26 25.57 -86.76 11 11e 6.44 244.26 -33.76 *FLAGS NOT SPLAY 11 12 4.68 28.23 41.16 *FLAGS SPLAY 12 12a 0.49 163.24 -3.84 12 12b 2.05 326.35 6.05 12 12c 6.64 296.93 79.59 12 12d 3.01 156.92 -82.68 12 12e 3.45 44.58 36.15 12 12f 7.31 45.38 40.15 12 12g 7.44 59.56 40.31 12 12h 5.50 20.21 43.16 12 12i 2.86 2.96 33.73 12 12j 2.89 291.62 14.24 12 12k 2.35 256.10 14.98 12 12l 12.70 20.35 69.18 *FLAGS NOT SPLAY 12 13 4.74 257.83 20.70 *FLAGS SPLAY 13 13a 0.33 143.07 -2.33 13 13b 0.61 117.22 76.36 13 13c 0.84 289.69 -81.40 *FLAGS NOT SPLAY 13 14 3.65 238.14 -5.06 *FLAGS SPLAY 14 14a 0.40 134.05 0.55 14 14b 0.45 325.26 7.61 14 14c 8.22 65.42 88.46 14 14d 0.28 75.71 -85.74 *FLAGS NOT SPLAY 14 15 1.18 304.15 22.54 *FLAGS SPLAY 15 15a 0.29 177.36 -2.22 15 15b 4.62 186.26 82.17 15 15c 0.80 117.91 -84.94 *FLAGS NOT SPLAY 15 16 3.01 254.32 20.56 *FLAGS SPLAY 16 16a 0.31 186.04 14.63 16 16b 0.35 13.09 -6.44 16 16c 0.76 28.25 88.09 16 16d 0.94 254.97 -82.68 *FLAGS NOT SPLAY 16 17 2.80 262.28 32.10 *FLAGS SPLAY 17 17a 1.87 272.52 88.42 17 17b 1.02 46.41 -85.96 17 17c 0.82 86.30 -3.90 *FLAGS NOT SPLAY 17 18 2.51 130.46 27.56 *FLAGS SPLAY 18 18a 1.11 346.65 2.19 18 18b 0.51 253.02 6.82 18 18c 1.91 43.25 -1.46 18 18d 1.81 40.33 85.61 18 18e 0.48 47.06 -88.61 *FLAGS NOT SPLAY 18 19 1.60 82.83 -6.44 *FLAGS SPLAY 19 19a 0.64 247.70 3.08 19 19b 1.37 325.71 78.59 19 19c 0.48 21.99 -87.43 *FLAGS NOT SPLAY 19 20 2.62 206.13 -3.57 *FLAGS SPLAY 20 20a 0.71 324.21 6.09 20 20b 3.67 28.83 83.37 20 20c 0.47 22.70 -85.65 *FLAGS NOT SPLAY 20 21 2.74 273.17 46.82 *FLAGS SPLAY 21 21a 0.77 150.79 -11.23 21 21b 3.23 324.73 31.68 21 21c 1.45 67.41 10.21 21 21d 9.98 19.22 82.51 *FLAGS NOT SPLAY 21 22 5.18 26.78 41.32 *FLAGS SPLAY 22 22a 1.73 308.53 4.45 22 22b 2.17 133.73 2.41 22 22c 11.69 263.63 88.10 22 22d 0.84 270.34 -88.39 22 22e 8.28 215.65 -4.87 22 22f 8.34 236.94 -5.86 22 22g 16.08 233.79 -2.48 22 22h 5.26 1.49 37.58 22 22i 5.75 61.72 37.02 22 22j 6.38 77.99 35.97 *FLAGS NOT SPLAY 22 23 6.09 69.43 35.08 *FLAGS SPLAY 23 23a 0.59 337.77 0.96 23 23b 0.90 158.22 11.19 23 23c 1.97 131.11 80.39 23 23d 1.37 52.83 -84.85 *FLAGS NOT SPLAY 23 24 2.80 330.39 -45.49 *FLAGS SPLAY 24 24a 0.86 96.82 1.32 24 24b 0.84 81.63 84.42 24 24c 0.81 97.55 -86.69 *FLAGS NOT SPLAY 24 25 3.96 24.64 -39.81 *FLAGS SPLAY 25 25a 0.95 319.89 3.51 25 25b 0.67 156.49 -5.81 25 25c 0.69 60.41 -86.00 *FLAGS NOT SPLAY 25 26 2.56 117.72 -45.71 *FLAGS SPLAY 26 26a 1.18 13.93 -5.75 26 26b 1.03 32.39 84.20 26 26c 0.40 312.35 -76.72 *FLAGS NOT SPLAY 26 27 2.20 85.94 -7.90 *FLAGS SPLAY 27 27a 0.98 329.16 1.13 27 27b 0.38 237.47 -79.56 27 27c 0.27 125.51 -0.87 *FLAGS NOT SPLAY 27 28 1.36 72.33 62.56 *FLAGS SPLAY 28 28a 1.45 186.85 -3.82 28 28b 0.32 24.31 -0.28 28 28c 0.59 261.97 -84.55 *FLAGS NOT SPLAY 28 29 1.39 121.96 -18.84 *FLAGS SPLAY 29 29a 0.90 115.27 -1.66 29 29b 1.60 299.34 0.63 29 29c 1.87 125.54 73.79 29 29d 6.93 84.61 -64.07 *FLAGS NOT SPLAY 29 30 0.86 110.32 6.35 30 31 8.52 168.68 -79.71 *data passage station left right up down 0 0.00 0.00 0.00 0.00 1 0.00 0.00 0.00 0.00 2 4.68 5.81 1.03 1.09 3 0.99 0.00 1.03 3.60 4 5.52 9.34 2.80 1.75 5 1.32 1.35 1.84 0.75 6 0.98 2.71 0.90 1.13 7 4.27 4.00 5.17 1.33 8 0.00 2.18 3.27 1.36 9 1.68 0.83 1.69 0.61 10 0.27 0.24 0.52 0.36 11 1.47 1.13 0.98 0.26 12 2.09 5.63 6.53 2.98 13 0.31 0.00 0.60 0.83 14 0.27 0.36 8.22 0.28 15 0.29 0.00 4.58 0.80 16 0.28 0.32 0.76 0.93 17 0.77 0.00 1.87 1.01 18 1.71 0.28 1.80 0.48 19 0.00 0.63 1.34 0.48 20 0.00 0.70 3.65 0.47 21 0.25 1.41 9.90 0.00 22 3.03 2.57 11.68 0.84 23 0.00 0.58 1.94 1.37 24 0.00 0.84 0.83 0.81 25 0.88 0.66 0.00 0.69 26 1.17 0.00 1.02 0.39 27 0.92 0.19 0.00 0.38 28 0.31 1.45 0.00 0.59 29 1.58 0.00 1.80 6.23 30 0.00 0.00 0.00 0.00 *END 154 *END GourAven2010 CaveConverter_src/test/data/regression/TripComment_in.txt0000644000000000000000000001002612064431254022731 0ustar rootrootTrainingRoom (m, 360) [1]: 2012/11/24 0.00 "WSCC DistoX - Footleg\rDell PDA drawing - Bob" 1.0 0.000 0.00 0.00 1.0 1.168 8.87 6.87 [1] 1.0 1.113 175.45 -0.10 [1] 1.0 5.951 98.10 6.04 [1] 1.0 5.008 277.41 17.22 [1] 1.0 1.035 47.72 83.13 [1] 1.0 1.094 153.35 -85.85 [1] 1.0 1.1 5.082 327.58 56.79 [1] 1.0 1.1 5.086 327.41 56.75 [1] 1.0 1.1 5.084 327.41 56.75 [1] 1.1 0.856 248.16 84.61 [1] 1.1 1.966 36.72 85.36 [1] 1.1 2.899 0.21 79.16 [1] 1.1 3.567 0.44 76.99 [1] 1.1 3.327 6.81 73.92 [1] 1.1 3.077 9.73 72.19 [1] 1.1 1.512 33.34 73.27 [1] 1.1 1.127 41.39 63.01 [1] 1.1 0.910 55.93 43.46 [1] 1.1 0.951 54.38 25.70 [1] 1.1 0.712 50.23 15.55 [1] 1.1 0.800 52.99 -17.45 [1] 1.1 0.785 47.54 -32.25 [1] 1.1 0.802 49.21 -38.08 [1] 1.1 1.224 48.37 -40.44 [1] 1.1 1.442 44.13 -46.36 [1] 1.1 1.832 42.45 -54.49 [1] 1.1 1.842 35.11 -63.47 [1] 1.1 1.507 111.18 -81.34 [1] 1.1 1.558 208.58 -80.33 [1] 1.1 0.805 65.58 -74.77 [1] 1.1 0.632 17.58 -85.44 [1] 1.1 0.551 281.21 -80.62 [1] 1.1 0.856 174.05 0.08 [1] 1.1 1.507 155.18 1.24 [1] 1.1 1.960 140.40 -3.29 [1] 1.1 2.575 131.69 -4.78 [1] 1.1 2.681 130.29 -4.55 [1] 1.1 0.577 315.38 2.25 [1] 1.1 1.046 326.37 2.41 [1] 1.1 1.282 112.92 -6.48 [1] 1.1 1.027 99.66 -5.08 [1] 1.1 0.735 82.81 -4.14 [1] 1.1 0.625 62.72 -5.29 [1] 1.1 0.706 34.15 -9.16 [1] 1.1 1.517 4.78 -10.78 [1] 1.1 1.620 348.65 -11.00 [1] 1.1 1.849 336.13 -6.26 [1] 1.1 2.388 329.33 -3.53 [1] 1.1 1.2 4.911 69.77 23.92 [1] 1.1 1.2 4.911 69.80 23.86 [1] 1.1 1.2 4.926 69.93 23.79 [1] 1.2 0.954 165.48 0.82 [1] 1.2 3.803 331.85 24.88 [1] 1.2 2.960 27.78 70.94 [1] 1.2 1.755 85.45 -85.86 [1] 1.2 13.104 71.82 16.81 [1] 1.2 7.755 33.32 29.66 [1] 1.2 5.735 289.73 15.19 [1] 1.2 5.017 257.83 -9.98 [1] 1.2 2.805 233.18 -16.44 [1] 1.2 1.3 1.996 337.60 33.03 [1] 1.2 1.3 1.996 337.69 33.12 [1] 1.2 1.3 1.997 337.46 33.11 [1] 1.3 1.670 169.43 -3.02 [1] 1.3 1.996 339.94 5.13 [1] 1.3 1.854 274.03 82.17 [1] 1.3 0.754 63.40 -83.13 [1] CaveConverter_src/test/data/regression/Uzu-Gour_ps_ref.svx0000644000000000000000000003522112226751562023051 0ustar rootroot*BEGIN Uzu-Gour090410 *EQUATE 134.44 153.0 *BEGIN 153 *DATE 2009.04.10 *CALIBRATE declination 2.01 *FLAGS SPLAY 0 0a 0.66 310.69 9.16 0 0b 1.17 138.22 11.97 0 0c 1.62 80.27 84.63 0 0d 1.32 136.77 -83.24 *FLAGS NOT SPLAY 0 1 4.01 55.12 2.88 *FLAGS SPLAY 1 1a 0.67 357.48 5.13 1 1b 1.24 169.73 4.45 1 1c 6.48 131.19 71.93 1 1d 1.27 111.18 -86.81 *FLAGS NOT SPLAY 1 2 6.67 109.20 -1.37 *FLAGS SPLAY 2 2a 0.71 12.77 -2.39 2 2b 0.97 175.96 -0.60 2 2c 2.48 5.80 77.81 2 2d 1.16 80.73 -86.86 *FLAGS NOT SPLAY 2 3 7.57 82.82 -1.46 *FLAGS SPLAY 3 3a 1.07 299.77 -0.43 3 3b 0.70 116.08 5.84 3 3c 5.83 351.61 76.20 3 3d 0.88 309.05 -87.42 *FLAGS NOT SPLAY 3 4 15.71 17.50 1.20 *FLAGS SPLAY 4 4a 1.95 226.25 -0.27 4 4b 0.46 66.80 13.93 4 4c 5.65 182.84 82.67 4 4d 1.04 275.59 -86.30 *FLAGS NOT SPLAY 4 5 2.73 244.54 2.61 *FLAGS SPLAY 5 5a 2.10 11.50 -1.38 5 5b 5.42 302.47 83.96 5 5c 1.23 134.51 -88.40 *FLAGS NOT SPLAY 5 6 4.22 318.30 0.41 *FLAGS SPLAY 6 6a 5.31 71.33 24.03 6 6b 0.72 307.95 86.30 6 6c 1.80 125.36 -84.77 *FLAGS NOT SPLAY 6 7 4.92 29.58 -2.12 *FLAGS SPLAY 7 7a 1.72 326.24 -2.97 7 7b 4.86 114.49 33.83 7 7c 1.49 119.34 82.62 7 7d 0.88 52.77 -83.97 *FLAGS NOT SPLAY 7 8 9.81 58.72 0.94 *FLAGS SPLAY 8 8a 0.60 30.89 4.65 8 8b 1.40 194.75 6.76 8 8c 1.87 143.21 80.26 8 8d 1.17 163.90 -84.89 *FLAGS NOT SPLAY 8 9 8.60 128.70 -6.68 *FLAGS SPLAY 9 9a 1.22 16.91 8.45 9 9b 1.01 194.87 -5.80 9 9c 1.19 115.77 79.03 9 9d 0.26 324.87 -86.69 *FLAGS NOT SPLAY 9 10 5.68 82.92 5.68 *FLAGS SPLAY 10 10a 1.20 327.38 -6.61 10 10b 0.95 146.85 7.78 10 10c 1.56 51.96 85.81 10 10d 0.76 270.01 -85.55 *FLAGS NOT SPLAY 10 11 6.56 44.65 4.54 *FLAGS SPLAY 11 11a 1.06 323.36 10.84 11 11b 1.22 147.77 -0.82 11 11c 3.26 239.56 88.17 11 11d 1.18 137.10 -80.05 *FLAGS NOT SPLAY 11 12 9.03 72.19 1.22 *FLAGS SPLAY 12 12a 1.22 333.74 -2.77 12 12b 0.39 157.20 6.88 12 12c 9.07 306.85 88.13 12 12d 1.17 32.13 -85.98 *FLAGS NOT SPLAY 12 13 3.05 46.22 1.28 *FLAGS SPLAY 13 13a 0.96 333.36 11.12 13 13b 1.08 162.52 0.43 13 13c 9.41 103.09 74.92 13 13d 1.51 134.98 -73.22 *FLAGS NOT SPLAY 13 14 6.89 86.27 -0.51 *FLAGS SPLAY 14 14a 1.06 337.15 -3.35 14 14b 7.65 102.01 82.12 14 14c 1.29 173.81 -89.40 *FLAGS NOT SPLAY 14 15 6.61 61.48 0.09 *FLAGS SPLAY 15 15a 1.54 303.07 -1.24 15 15b 0.24 134.42 12.32 15 15c 6.36 9.40 84.82 15 15d 1.07 310.69 -84.97 *FLAGS NOT SPLAY 15 16 5.13 18.53 -1.21 *FLAGS SPLAY 16 16a 0.55 311.69 6.18 16 16b 1.30 135.99 -4.45 16 16c 1.40 58.32 82.47 16 16d 1.10 224.97 -87.41 *FLAGS NOT SPLAY 16 17 6.85 62.63 2.01 *FLAGS SPLAY 17 17a 1.38 167.09 -2.95 17 17b 4.99 102.11 87.59 17 17c 1.18 212.70 -86.61 *FLAGS NOT SPLAY 17 18 5.38 102.18 1.22 *FLAGS SPLAY 18 18a 1.27 16.14 3.17 18 18b 11.11 43.73 75.72 18 18c 1.38 180.93 -87.42 *FLAGS NOT SPLAY 18 19 2.60 105.49 -1.05 ;19=stn 60 from August 2008 *FLAGS SPLAY 19 19a 1.43 243.30 5.15 19 19b 5.18 94.35 80.68 19 19c 1.11 212.90 -87.67 *FLAGS NOT SPLAY 19 20 6.94 178.17 -2.10 *FLAGS SPLAY 20 20a 0.41 85.52 6.85 20 20b 0.70 269.28 4.70 20 20c 2.87 290.90 87.19 20 20d 1.04 329.38 -84.46 *FLAGS NOT SPLAY 20 21 4.01 196.07 3.14 *FLAGS SPLAY 21 21a 1.43 76.94 2.96 21 21b 0.64 246.93 0.76 21 21c 5.24 171.27 84.67 21 21d 1.07 306.36 -85.58 *FLAGS NOT SPLAY 21 22 4.15 139.28 -0.15 *FLAGS SPLAY 22 22a 0.35 96.03 4.53 22 22b 3.67 279.77 20.06 22 22c 0.96 136.65 84.20 22 22d 1.17 260.34 -85.03 *FLAGS NOT SPLAY 22 23 4.71 205.76 -0.38 *FLAGS SPLAY 23 23a 0.67 100.63 7.72 23 23b 0.90 284.24 1.46 23 23c 2.03 266.53 85.53 23 23d 1.14 125.32 -83.92 *FLAGS NOT SPLAY 23 24 6.52 198.45 5.52 *FLAGS SPLAY 24 24a 0.67 118.59 3.67 24 24b 0.94 305.13 0.53 24 24c 4.72 141.69 87.99 24 24d 1.31 293.36 -72.03 *FLAGS NOT SPLAY 24 25 8.69 224.01 -4.26 *FLAGS SPLAY 25 25a 1.78 141.39 18.75 25 25b 1.11 337.22 -0.91 25 25c 1.83 242.61 82.90 25 25d 1.05 299.11 -87.89 *FLAGS NOT SPLAY 25 26 5.69 246.24 2.28 *FLAGS SPLAY 26 26a 2.88 110.99 19.61 26 26b 1.74 123.76 77.81 26 26c 1.18 84.70 -81.34 *FLAGS NOT SPLAY 26 27 2.46 153.10 -9.56 *FLAGS SPLAY 27 27a 1.17 272.63 6.40 27 27b 2.03 148.32 86.47 27 27c 0.82 219.90 -89.23 *FLAGS NOT SPLAY 27 28 16.85 204.24 -2.08 *FLAGS SPLAY 28 28a 1.84 71.44 8.08 28 28b 0.87 257.22 6.27 28 28c 1.10 14.88 73.52 *FLAGS NOT SPLAY 28 29 10.28 139.20 5.65 *FLAGS SPLAY 29 29a 1.66 30.10 15.39 29 29b 0.40 203.86 7.65 29 29c 8.09 67.11 77.32 29 29d 0.83 81.38 -87.37 *FLAGS NOT SPLAY 29 30 5.84 105.83 5.86 *FLAGS SPLAY 30 30a 1.92 7.20 9.53 30 30b 0.44 160.39 4.71 30 30c 3.25 108.05 82.68 30 30d 1.28 255.16 -87.21 *FLAGS NOT SPLAY 30 31 10.74 79.31 -0.95 *FLAGS SPLAY 31 31a 2.96 313.97 15.64 31 31b 0.39 134.29 11.27 31 31c 1.30 77.16 82.61 31 31d 1.17 86.89 -84.64 *FLAGS NOT SPLAY 31 32 5.99 21.29 2.80 *FLAGS SPLAY 32 32a 1.90 156.21 1.51 32 32b 1.71 343.53 87.98 32 32c 1.27 73.92 -84.80 *FLAGS NOT SPLAY 32 33 8.26 124.62 -0.97 *FLAGS SPLAY 33 33a 2.26 3.19 18.54 33 33b 0.77 182.19 6.10 33 33c 3.37 12.67 85.55 33 33d 1.26 246.33 -87.14 *FLAGS NOT SPLAY 33 34 11.46 86.24 0.14 *FLAGS SPLAY 34 34a 0.52 6.08 8.87 34 34b 0.89 187.81 1.74 34 34c 13.04 45.58 80.50 34 34d 1.37 130.80 -82.35 *FLAGS NOT SPLAY 34 35 10.25 104.61 -0.15 *FLAGS SPLAY 35 35a 2.39 334.20 16.80 35 35b 1.56 350.17 81.57 35 35c 1.12 53.73 -85.78 *FLAGS NOT SPLAY 35 36 6.54 36.46 2.80 *FLAGS SPLAY 36 36a 1.08 290.80 -0.12 36 36b 0.26 107.29 9.29 36 36c 4.78 67.20 78.00 36 36d 1.61 127.33 -86.11 *FLAGS NOT SPLAY 36 37 7.85 352.56 0.36 *FLAGS SPLAY 37 37a 1.97 114.20 2.44 37 37b 3.86 29.40 79.16 37 37c 1.50 43.36 -74.01 *FLAGS NOT SPLAY 37 38 12.49 59.58 -0.29 *FLAGS SPLAY 38 38a 3.71 196.43 25.48 38 38b 1.00 101.32 82.16 38 38c 1.14 83.86 -82.25 *FLAGS NOT SPLAY 38 39 6.47 144.30 -0.66 *FLAGS SPLAY 39 39a 1.78 256.50 4.97 39 39b 5.46 245.76 79.39 39 39c 1.40 7.99 -88.60 *FLAGS NOT SPLAY 39 40 12.19 176.62 2.78 *FLAGS SPLAY 40 40a 0.94 294.81 -3.35 40 40b 8.53 269.05 75.20 40 40c 1.86 227.20 -83.19 *FLAGS NOT SPLAY 40 41 8.03 217.50 -3.13 *FLAGS SPLAY 41 41a 0.76 112.64 0.91 41 41b 0.39 300.05 13.28 41 41c 10.11 273.70 83.77 41 41d 1.48 282.10 -85.81 *FLAGS NOT SPLAY 41 42 5.06 197.69 0.74 *FLAGS SPLAY 42 42a 0.82 87.13 -12.02 42 42b 0.91 271.51 28.37 42 42c 9.38 261.83 78.26 42 42d 1.47 332.21 -86.18 *FLAGS NOT SPLAY 42 43 5.14 164.36 -5.75 *FLAGS SPLAY 43 43a 1.24 25.91 -2.84 43 43b 1.28 223.96 28.43 43 43c 1.91 212.36 79.68 43 43d 0.88 286.64 -86.20 *FLAGS NOT SPLAY 43 44 4.12 90.67 -11.48 *FLAGS SPLAY 44 44a 2.41 57.95 5.26 44 44b 1.25 222.00 8.75 44 44c 1.18 198.31 83.84 *FLAGS NOT SPLAY 44 45 12.39 173.99 6.86 *FLAGS SPLAY 45 45a 1.42 43.19 -4.13 45 45b 1.00 215.21 22.64 45 45c 3.52 16.66 74.76 45 45d 1.43 272.80 -85.47 *FLAGS NOT SPLAY 45 46 7.38 104.91 0.82 *FLAGS SPLAY 46 46a 0.98 352.37 -5.19 46 46b 3.91 3.72 83.25 46 46c 1.19 177.07 -85.49 *FLAGS NOT SPLAY 46 47 4.77 61.95 -3.61 *FLAGS SPLAY 47 47a 0.85 309.66 1.57 47 47b 0.51 134.97 21.12 47 47c 5.12 95.91 72.50 47 47d 0.90 178.61 -86.89 *FLAGS NOT SPLAY 47 48 5.77 23.58 0.32 *FLAGS SPLAY 48 48a 0.96 278.66 -1.41 48 48b 0.91 84.37 -1.28 48 48c 8.95 50.33 87.07 48 48d 0.87 154.03 -87.03 *FLAGS NOT SPLAY 48 49 10.87 6.04 2.73 *FLAGS SPLAY 49 49a 3.53 303.46 -22.08 49 49b 1.49 109.10 12.22 49 49c 4.18 271.96 83.18 49 49d 0.25 222.51 -84.71 *FLAGS NOT SPLAY 49 50 1.56 17.64 -9.69 *FLAGS SPLAY 50 50a 3.09 310.29 -16.03 50 50b 1.81 123.41 3.37 50 50c 2.82 107.70 88.07 50 50d 0.87 32.83 -88.59 *FLAGS NOT SPLAY 50 51 11.64 51.10 1.00 *FLAGS SPLAY 51 51a 0.88 291.17 -11.07 51 51b 2.62 163.62 87.41 51 51c 1.34 102.52 -83.95 *FLAGS NOT SPLAY 51 52 6.84 26.57 -5.79 *FLAGS SPLAY 52 52a 1.10 9.43 2.05 52 52b 2.18 183.91 3.39 52 52c 1.06 147.54 83.46 52 52d 0.69 193.69 -84.93 *FLAGS NOT SPLAY 52 53 6.43 119.09 2.67 *FLAGS SPLAY 53 53a 2.46 316.37 -3.18 53 53b 0.35 134.32 6.93 53 53c 1.32 0.65 81.40 53 53d 0.75 219.60 -87.78 *FLAGS NOT SPLAY 53 54 16.81 345.84 -2.23 *FLAGS SPLAY 54 54a 9.48 121.96 18.18 54 54b 1.34 88.18 80.69 54 54c 0.22 128.68 -85.33 *FLAGS NOT SPLAY 54 55 11.67 100.37 4.88 *FLAGS SPLAY 55 55a 0.68 353.36 -0.15 55 55b 5.39 12.73 75.03 55 55c 1.00 50.40 -89.71 *FLAGS NOT SPLAY 55 56 1.66 96.25 -19.79 *FLAGS SPLAY 56 56a 0.40 38.17 6.20 56 56b 1.05 225.93 5.47 56 56c 2.34 96.97 80.74 56 56d 0.56 294.92 -87.67 *FLAGS NOT SPLAY 56 57 5.39 160.71 -4.01 *FLAGS SPLAY 57 57a 1.81 25.53 1.62 57 57b 0.53 220.15 1.24 57 57c 2.27 47.01 85.24 57 57d 0.20 12.33 -85.15 *FLAGS NOT SPLAY 57 58 4.72 73.23 10.43 *FLAGS SPLAY 58 58a 0.33 16.81 2.17 58 58b 1.18 189.78 0.04 58 58c 4.01 77.71 86.61 58 58d 0.94 144.63 -82.64 *FLAGS NOT SPLAY 58 59 5.12 139.83 -5.11 *FLAGS SPLAY 59 59a 1.14 5.50 9.72 59 59b 1.16 165.35 20.33 59 59c 1.39 21.12 85.08 59 59d 0.48 248.26 -87.58 *FLAGS NOT SPLAY 59 60 8.82 75.02 2.73 *FLAGS SPLAY 60 60a 0.97 320.91 -0.74 60 60b 0.25 141.85 1.28 60 60c 7.57 288.95 79.51 60 60d 0.88 71.53 -85.03 *FLAGS NOT SPLAY 60 61 1.71 17.48 9.12 *FLAGS SPLAY 61 61a 0.50 119.39 2.08 61 61b 6.59 87.13 75.75 61 61c 1.17 342.08 -77.77 *FLAGS NOT SPLAY 61 62 7.73 51.94 -4.40 *FLAGS SPLAY 62 62a 1.60 290.77 -0.14 62 62b 0.22 112.40 8.61 62 62c 4.84 289.04 83.90 62 62d 0.54 263.45 -79.21 *FLAGS NOT SPLAY 62 63 2.97 348.14 3.86 *FLAGS SPLAY 63 63a 0.94 108.22 0.43 63 63b 5.02 359.20 80.02 63 63c 0.77 287.97 -88.61 *FLAGS NOT SPLAY 63 64 10.87 23.32 -1.96 *FLAGS SPLAY 64 64a 1.17 132.36 9.67 64 64b 9.31 35.43 83.06 64 64c 0.43 84.37 -84.49 *FLAGS NOT SPLAY 64 65 4.53 55.63 4.73 *FLAGS SPLAY 65 65a 1.40 293.82 8.38 65 65b 8.35 317.08 87.04 65 65c 0.56 60.05 -86.93 *FLAGS NOT SPLAY 65 66 3.19 344.40 -3.15 *FLAGS SPLAY 66 66a 0.92 211.48 9.89 66 66b 0.26 39.37 20.78 66 66c 10.30 235.93 86.42 66 66d 0.51 191.40 -85.42 *FLAGS NOT SPLAY 66 67 2.48 284.81 17.86 *FLAGS SPLAY 67 67a 1.19 61.63 3.00 67 67b 9.55 90.90 83.48 67 67c 1.19 21.67 -82.71 *FLAGS NOT SPLAY 67 68 5.47 5.26 0.23 *FLAGS SPLAY 68 68a 0.91 135.70 2.18 68 68b 10.36 129.84 88.37 68 68c 1.30 90.71 -82.74 *FLAGS NOT SPLAY 68 69 3.21 73.52 0.24 *FLAGS SPLAY 69 69a 0.85 319.91 5.62 69 69b 4.45 346.56 83.35 69 69c 1.22 324.86 -77.89 *FLAGS NOT SPLAY 69 70 6.88 27.74 1.39 *FLAGS SPLAY 70 70a 2.32 330.70 23.53 70 70b 1.41 153.25 28.90 70 70c 2.11 50.40 82.88 70 70d 1.17 116.09 -85.44 *FLAGS NOT SPLAY 70 71 5.88 104.61 4.12 *FLAGS SPLAY 71 71a 0.60 8.59 5.70 71 71b 0.99 182.74 6.14 71 71c 3.45 22.79 85.05 71 71d 1.24 130.89 -84.59 *FLAGS NOT SPLAY 71 72 7.57 99.29 -5.44 *FLAGS SPLAY 72 72a 1.51 348.65 8.10 72 72b 1.10 171.46 5.08 72 72c 11.09 217.02 85.71 72 72d 0.19 293.19 -86.30 *FLAGS NOT SPLAY 72 73 5.64 88.59 15.15 *FLAGS SPLAY 73 73a 3.24 192.60 35.24 73 73b 5.16 123.70 74.79 73 73c 1.35 50.38 -81.74 *FLAGS NOT SPLAY 73 74 2.17 131.37 8.68 *FLAGS SPLAY 74 74a 2.16 342.38 15.27 74 74b 4.56 167.45 21.67 74 74c 12.11 234.38 84.14 74 74d 1.55 294.57 -87.26 *FLAGS NOT SPLAY 74 75 4.57 27.39 14.39 *FLAGS SPLAY 75 75a 0.82 147.55 1.96 75 75b 8.36 189.98 83.08 75 75c 1.10 197.11 -86.67 *FLAGS NOT SPLAY 75 76 8.47 60.80 19.30 *FLAGS SPLAY 76 76a 0.41 359.12 11.97 76 76b 0.92 190.46 10.73 76 76c 1.18 70.36 88.64 76 76d 1.28 120.95 -83.97 *FLAGS NOT SPLAY 76 77 5.73 104.58 0.98 *FLAGS SPLAY 77 77a 0.49 333.81 -8.65 77 77b 2.35 164.36 23.76 77 77c 2.11 45.37 82.47 77 77d 0.34 300.28 -87.27 *FLAGS NOT SPLAY 77 78 5.19 84.19 24.31 *FLAGS SPLAY 78 78a 1.85 189.88 5.06 78 78b 0.42 110.15 87.16 78 78c 0.45 342.41 -88.96 *FLAGS NOT SPLAY 78 79 1.27 102.94 2.43 *data passage station left right up down 0 0.63 1.14 1.61 1.31 1 0.66 1.24 6.16 1.27 2 0.70 0.96 2.42 1.16 3 1.00 0.64 5.66 0.88 4 1.94 0.40 5.60 1.04 5 0.00 2.10 5.39 1.23 6 0.00 4.73 0.72 1.79 7 1.68 3.80 1.48 0.88 8 0.53 1.36 1.84 1.17 9 1.21 1.00 1.17 0.26 10 1.18 0.93 1.56 0.76 11 1.04 1.22 3.26 1.16 12 1.21 0.38 9.07 1.17 13 0.94 1.07 9.09 1.45 14 1.05 0.00 7.58 1.29 15 1.53 0.23 6.33 1.07 16 0.55 1.29 1.39 1.10 17 0.00 1.37 4.99 1.18 18 1.27 0.00 10.77 1.38 19 0.00 1.40 5.11 1.11 20 0.40 0.69 2.87 1.04 21 1.43 0.63 5.22 1.07 22 0.34 3.29 0.96 1.17 23 0.65 0.89 2.02 1.13 24 0.67 0.94 4.72 1.25 25 1.68 1.09 1.82 1.05 26 2.71 0.00 1.70 1.17 27 0.00 1.16 2.03 0.82 28 1.79 0.86 1.05 0.00 29 1.60 0.39 7.89 0.83 30 1.89 0.41 3.22 1.28 31 2.83 0.38 1.29 1.16 32 0.00 1.89 1.71 1.26 33 2.09 0.75 3.36 1.26 34 0.51 0.89 12.86 1.36 35 2.27 0.00 1.54 1.12 36 1.07 0.26 4.68 1.61 37 0.00 1.97 3.79 1.44 38 0.00 3.34 0.99 1.13 39 0.00 1.76 5.37 1.40 40 0.00 0.93 8.25 1.85 41 0.76 0.38 10.05 1.48 42 0.80 0.80 9.18 1.47 43 1.21 1.12 1.88 0.88 44 2.31 1.24 1.17 0.00 45 1.41 0.89 3.40 1.43 46 0.98 0.00 3.88 1.19 47 0.85 0.48 4.88 0.90 48 0.95 0.85 8.94 0.87 49 3.04 1.44 4.15 0.25 50 2.95 1.81 2.82 0.87 51 0.82 0.00 2.62 1.33 52 0.98 2.03 1.05 0.69 53 2.44 0.34 1.31 0.75 54 0.00 8.84 1.32 0.22 55 0.66 0.00 5.21 1.00 56 0.40 1.04 2.31 0.56 57 1.81 0.52 2.26 0.20 58 0.33 1.17 4.00 0.93 59 1.10 0.92 1.38 0.48 60 0.97 0.25 7.44 0.88 61 0.00 0.50 6.39 1.14 62 1.60 0.22 4.81 0.53 63 0.00 0.92 4.94 0.77 64 0.00 1.15 9.24 0.43 65 1.38 0.00 8.34 0.56 66 0.88 0.24 10.28 0.51 67 0.00 1.18 9.49 1.18 68 0.00 0.90 10.36 1.29 69 0.85 0.00 4.42 1.19 70 2.12 1.23 2.09 1.17 71 0.60 0.97 3.44 1.23 72 1.44 1.07 11.06 0.19 73 0.00 2.62 4.98 1.34 74 2.07 4.24 12.05 1.55 75 0.00 0.80 8.30 1.10 76 0.40 0.86 1.18 1.27 77 0.42 2.02 2.09 0.34 78 0.00 1.83 0.42 0.45 *END 153 *END Uzu-Gour090410 CaveConverter_src/test/data/regression/2649_Mares_fromaven_dt_ref.text0000644000000000000000000001320312115213060025110 0ustar rootroot -6 1 1 1 1 Cave Name -5 1 1 1 1 0.00 0.00 0.00 1 0 -4 1 1 1 1 12/08/16 13:14:15 CaveConverter -3 1 1 1 1 -2 1 1 1 1 16/08/12 Converted Data 0 0.00 0 1 -1 1 1 1 1 360.00 360.00 0.05 1.00 1.00 100.00 0.00 1 -2 1 1 1 Series 1-root.SurveyFromDXF.SeriesFromLines1 1 -1 1 1 1 1 0 1 7 7 3 0 1 0 1 1 1 0.00 0.00 0.00 0.00 0.00 0.00 0.00 1 1 1 1 1 1.71 142.64 -46.89 0.00 0.00 0.00 0.00 1 2 1 1 1 2.90 350.59 -49.12 0.00 0.00 0.00 0.00 1 3 1 1 1 4.23 0.00 -90.00 0.00 0.00 0.00 0.00 1 4 1 1 1 4.96 100.66 11.05 0.00 0.00 0.00 0.00 1 5 1 1 1 2.17 69.61 40.07 0.00 0.00 0.00 0.00 1 6 1 1 1 2.50 97.85 -35.10 0.00 0.00 0.00 0.00 1 7 1 1 1 6.89 219.66 -10.95 0.00 0.00 0.00 0.00 2 -2 1 1 1 Series 2-root.SurveyFromDXF.SeriesFromLines2 2 -1 1 1 1 1 6 2 4 4 3 0 2 0 1 1 1 0.00 0.00 0.00 0.00 0.00 0.00 0.00 2 1 1 1 1 2.99 65.79 18.75 0.00 0.00 0.00 0.00 2 2 1 1 1 2.99 107.71 -1.72 0.00 0.00 0.00 0.00 2 3 1 1 1 2.58 95.89 -10.95 0.00 0.00 0.00 0.00 2 4 1 1 1 4.81 0.00 -90.00 0.00 0.00 0.00 0.00 3 -2 1 1 1 Series 3-root.SurveyFromDXF.SeriesFromLines3 3 -1 1 1 1 2 3 3 15 15 3 0 3 0 1 1 1 0.00 0.00 0.00 0.00 0.00 0.00 0.00 3 1 1 1 1 4.40 45.66 -11.13 0.00 0.00 0.00 0.00 3 2 1 1 1 2.30 17.68 -43.07 0.00 0.00 0.00 0.00 3 3 1 1 1 7.35 47.76 -3.98 0.00 0.00 0.00 0.00 3 4 1 1 1 7.35 32.74 -4.99 0.00 0.00 0.00 0.00 3 5 1 1 1 4.10 22.63 14.12 0.00 0.00 0.00 0.00 3 6 1 1 1 5.90 70.73 -5.15 0.00 0.00 0.00 0.00 3 7 1 1 1 7.40 29.69 -2.94 0.00 0.00 0.00 0.00 3 8 1 1 1 5.64 46.73 -3.05 0.00 0.00 0.00 0.00 3 9 1 1 1 3.91 107.78 -3.96 0.00 0.00 0.00 0.00 3 10 1 1 1 4.02 82.72 1.99 0.00 0.00 0.00 0.00 3 11 1 1 1 3.00 35.76 -2.87 0.00 0.00 0.00 0.00 3 12 1 1 1 3.30 147.73 -11.00 0.00 0.00 0.00 0.00 3 13 1 1 1 6.57 96.74 0.00 0.00 0.00 0.00 0.00 3 14 1 1 1 1.81 179.68 2.85 0.00 0.00 0.00 0.00 3 15 1 1 1 1.90 25.75 6.95 0.00 0.00 0.00 0.00 4 -2 1 1 1 Series 4-root.SurveyFromDXF.SeriesFromLines4 4 -1 1 1 1 3 14 4 1 1 3 0 4 0 1 1 1 0.00 0.00 0.00 0.00 0.00 0.00 0.00 4 1 1 1 1 2.50 199.59 19.84 0.00 0.00 0.00 0.00 5 -2 1 1 1 Series 5-root.SurveyFromDXF.SeriesFromLines5 5 -1 1 1 1 3 13 5 5 5 3 0 5 0 1 1 1 0.00 0.00 0.00 0.00 0.00 0.00 0.00 5 1 1 1 1 3.00 88.85 6.51 0.00 0.00 0.00 0.00 5 2 1 1 1 2.91 18.25 3.54 0.00 0.00 0.00 0.00 5 3 1 1 1 4.11 17.73 -2.09 0.00 0.00 0.00 0.00 5 4 1 1 1 2.02 328.99 4.53 0.00 0.00 0.00 0.00 5 5 1 1 1 2.42 26.97 -37.46 0.00 0.00 0.00 0.00 6 -2 1 1 1 Series 6-root.SurveyFromDXF.SeriesFromLines6 6 -1 1 1 1 5 4 6 2 2 3 0 6 0 1 1 1 0.00 0.00 0.00 0.00 0.00 0.00 0.00 6 1 1 1 1 1.93 61.96 -5.96 0.00 0.00 0.00 0.00 6 2 1 1 1 3.34 30.11 -4.29 0.00 0.00 0.00 0.00 7 -2 1 1 1 Series 7-root.SurveyFromDXF.SeriesFromLines7 7 -1 1 1 1 6 1 7 6 6 3 0 7 0 1 1 1 0.00 0.00 0.00 0.00 0.00 0.00 0.00 7 1 1 1 1 8.16 102.89 -1.40 0.00 0.00 0.00 0.00 7 2 1 1 1 1.78 137.05 4.83 0.00 0.00 0.00 0.00 7 3 1 1 1 2.69 98.76 0.43 0.00 0.00 0.00 0.00 7 4 1 1 1 4.73 54.32 -3.76 0.00 0.00 0.00 0.00 7 5 1 1 1 1.26 67.52 -5.01 0.00 0.00 0.00 0.00 7 6 1 1 1 2.94 110.53 -3.70 0.00 0.00 0.00 0.00 8 -2 1 1 1 Series 8-root.SurveyFromDXF.SeriesFromLines8 8 -1 1 1 1 7 5 8 3 3 3 0 8 0 1 1 1 0.00 0.00 0.00 0.00 0.00 0.00 0.00 8 1 1 1 1 3.96 134.18 3.91 0.00 0.00 0.00 0.00 8 2 1 1 1 1.44 67.21 -26.37 0.00 0.00 0.00 0.00 8 3 1 1 1 2.30 129.81 -17.75 0.00 0.00 0.00 0.00CaveConverter_src/test/cavesurvey/0000755000000000000000000000000012165540164016350 5ustar rootrootCaveConverter_src/test/cavesurvey/data/0000755000000000000000000000000012165540164017261 5ustar rootrootCaveConverter_src/test/cavesurvey/data/model/0000755000000000000000000000000012224522030020345 5ustar rootrootCaveConverter_src/test/cavesurvey/data/model/SurveySeriesLrudTest.java0000644000000000000000000002310012242117242025350 0ustar rootroot/** * Copyright (C) 2009-2013 Paul Fretwell - aka 'Footleg' (drfootleg@gmail.com) * * This file is part of Cave Converter. * * Cave Converter is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation, either version 3 of the License, or * (at your option) any later version. * * Cave Converter is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with Cave Converter. If not, see . */ package cavesurvey.data.model; import static org.junit.Assert.assertEquals; import java.util.List; import org.junit.Test; import cavesurvey.tools.TestHelper; import footleg.cavesurvey.data.model.CaveSurvey; import footleg.cavesurvey.data.model.SurveySeries; import footleg.cavesurvey.data.writer.SurvexWriter; import footleg.cavesurvey.tools.UtilityFunctions; /** * Unit test class which tests the generation of LRUD passage dimension data from splays. * Various test sets of data in a survey series are set up and tested. * * @author Footleg * @version 2013.11.17 (ISO 8601 YYYY.MM.DD) * @since 1.6 (The Java version used) */ public class SurveySeriesLrudTest { final String PASSAGE_DATA_HEADER = "*data passage station left right up down"; @Test public void testLrudGenerationsStandardLinearSeriesOfForwardShots() { SurveySeries series = TestHelper.createSimpleForward3SurveyingSeriesWith3Splays(); //Generate LRUD data from splays series.generateLRUDFromSplays(); //Generate Survex format data List outputData = survexDataFromSeries(series); UtilityFunctions.writeTextFile(outputData, "../testdata/Forwards.svx"); /* *data passage station left right up down 1 0.51 0.00 1.55 0.86 2 0.00 0.58 2.73 1.16 3 0.41 0.00 3.68 0.54 4 0.00 0.52 4.40 1.42 */ //Check LRUD data block from Survex Writer assertEquals("File Length check.", 34, outputData.size() ); int line = 27; assertEquals(PASSAGE_DATA_HEADER, outputData.get(line++) ); assertEquals("1 0.51 0.00 1.55 0.86", outputData.get(line++) ); assertEquals("2 0.00 0.58 2.73 1.16", outputData.get(line++) ); assertEquals("3 0.41 0.00 3.68 0.54", outputData.get(line++) ); assertEquals("4 0.00 0.52 4.40 1.42", outputData.get(line++) ); } @Test public void testLrudGenerationsStandardLinearSeriesOfBackwardShots() { SurveySeries series = TestHelper.createSimpleBackwardsSurveyingSeriesWithSplays(); //Generate LRUD data from splays series.generateLRUDFromSplays(); //Generate Survex format data List outputData = survexDataFromSeries(series); UtilityFunctions.writeTextFile(outputData, "../testdata/Backwards.svx"); /* *data passage station left right up down 4 0.52 0.00 4.40 1.42 3 0.00 0.41 3.68 0.54 2 0.58 0.00 2.73 1.16 1 0.00 0.51 1.55 0.86 */ //Check LRUD data block from Survex Writer assertEquals("File Length check.", 34, outputData.size() ); int line = 27; assertEquals(PASSAGE_DATA_HEADER, outputData.get(line++) ); assertEquals("4 0.52 0.00 4.40 1.42", outputData.get(line++) ); assertEquals("3 0.00 0.41 3.68 0.54", outputData.get(line++) ); assertEquals("2 0.58 0.00 2.73 1.16", outputData.get(line++) ); assertEquals("1 0.00 0.51 1.55 0.86", outputData.get(line++) ); } @Test public void testLrudGenerationsBranchedSeriesOfForwardShots() { SurveySeries series = TestHelper.createBranched222ForwardSurveyingSeriesWithSplays(); //Generate LRUD data from splays series.generateLRUDFromSplays(); //Generate Survex format data List outputData = survexDataFromSeries(series); UtilityFunctions.writeTextFile(outputData, "../testdata/ForwardsT222.svx"); /* *data passage station left right up down 1 0.50 1.49 2.00 0.40 2 0.57 0.91 0.00 0.28 3 0.00 1.59 1.81 0.46 4 0.45 0.42 1.53 0.92 5 0.50 0.34 1.16 0.36 *data passage station left right up down 3 1.59 0.00 1.81 0.46 6 0.41 0.00 3.68 0.54 7 0.00 0.52 4.40 1.42 */ //Check LRUD data block from Survex Writer assertEquals("File Length check.", 60, outputData.size() ); int line = 48; assertEquals(PASSAGE_DATA_HEADER, outputData.get(line++) ); assertEquals("1 0.50 1.49 2.00 0.40", outputData.get(line++) ); assertEquals("2 0.57 0.91 0.00 0.28", outputData.get(line++) ); assertEquals("3 0.00 1.59 1.81 0.46", outputData.get(line++) ); assertEquals("4 0.45 0.42 1.53 0.92", outputData.get(line++) ); assertEquals("5 0.50 0.34 1.16 0.36", outputData.get(line++) ); assertEquals(PASSAGE_DATA_HEADER, outputData.get(line++) ); assertEquals("3 1.59 0.00 1.81 0.46", outputData.get(line++) ); assertEquals("6 0.41 0.00 3.68 0.54", outputData.get(line++) ); assertEquals("7 0.00 0.52 4.40 1.42", outputData.get(line++) ); } @Test public void testLrudGenerationsBranched122SeriesOfForwardShots() { SurveySeries series = TestHelper.createBranched122ForwardSurveyingSeriesWithSplays(); //Generate LRUD data from splays series.generateLRUDFromSplays(); //Generate Survex format data List outputData = survexDataFromSeries(series); UtilityFunctions.writeTextFile(outputData, "../testdata/ForwardsT122.svx"); /* *data passage station left right up down 1 0.56 0.93 0.00 0.28 2 0.00 1.59 1.81 0.46 3 0.45 0.42 1.53 0.92 4 0.50 0.34 1.16 0.36 *data passage station left right up down 2 1.59 0.00 1.81 0.46 5 0.41 0.00 3.68 0.54 6 0.00 0.52 4.40 1.42 */ //Check LRUD data block from Survex Writer assertEquals("File Length check.", 52, outputData.size() ); int line = 41; assertEquals(PASSAGE_DATA_HEADER, outputData.get(line++) ); assertEquals("1 0.56 0.93 0.00 0.28", outputData.get(line++) ); assertEquals("2 0.00 1.59 1.81 0.46", outputData.get(line++) ); assertEquals("3 0.45 0.42 1.53 0.92", outputData.get(line++) ); assertEquals("4 0.50 0.34 1.16 0.36", outputData.get(line++) ); assertEquals(PASSAGE_DATA_HEADER, outputData.get(line++) ); assertEquals("2 1.59 0.00 1.81 0.46", outputData.get(line++) ); assertEquals("5 0.41 0.00 3.68 0.54", outputData.get(line++) ); assertEquals("6 0.00 0.52 4.40 1.42", outputData.get(line++) ); } @Test public void testLrudGenerationsLinearSeriesOfForwardShots4Splays() { SurveySeries series = TestHelper.createSimpleForward5SurveyingSeriesWith4Splays(); //Generate LRUD data from splays series.generateLRUDFromSplays(); //Generate Survex format data List outputData = survexDataFromSeries(series); UtilityFunctions.writeTextFile(outputData, "../testdata/Forward5.svx"); /* *data passage station left right up down 1 0.07 0.73 1.28 0.86 2 0.15 0.78 0.83 1.16 3 1.21 0.21 1.21 0.54 4 0.47 1.56 1.44 1.45 5 1.21 0.19 1.23 0.54 6 0.49 1.36 1.63 1.65 */ //Check LRUD data block from Survex Writer assertEquals("File Length check.", 54, outputData.size() ); int line = 45; assertEquals(PASSAGE_DATA_HEADER, outputData.get(line++) ); assertEquals("1 0.07 0.73 1.28 0.86", outputData.get(line++) ); assertEquals("2 0.15 0.78 0.83 1.16", outputData.get(line++) ); assertEquals("3 1.21 0.21 1.21 0.54", outputData.get(line++) ); assertEquals("4 0.47 1.56 1.44 1.45", outputData.get(line++) ); assertEquals("5 1.21 0.19 1.23 0.54", outputData.get(line++) ); assertEquals("6 0.49 1.36 1.63 1.65", outputData.get(line++) ); } @Test public void testLrudGenerationsLinearSeriesOfLeapfrogShots() { SurveySeries series = TestHelper.createLinearLeapfrogSurveyingSeriesWithSplays(); //Generate LRUD data from splays series.generateLRUDFromSplays(); //Generate Survex format data List outputData = survexDataFromSeries(series); UtilityFunctions.writeTextFile(outputData, "../testdata/Leapfrog.svx"); /* *data passage station left right up down 1 0.07 0.73 1.28 0.86 2 0.15 0.78 0.83 1.16 3 1.21 0.21 1.21 0.54 4 0.47 1.56 1.44 1.45 5 1.21 0.19 1.23 0.54 6 0.49 1.36 1.63 1.65 */ //Check LRUD data block from Survex Writer assertEquals("File Length check.", 54, outputData.size() ); int line = 45; assertEquals(PASSAGE_DATA_HEADER, outputData.get(line++) ); assertEquals("1 0.07 0.73 1.28 0.86", outputData.get(line++) ); assertEquals("2 0.15 0.78 0.83 1.16", outputData.get(line++) ); assertEquals("3 1.21 0.21 1.21 0.54", outputData.get(line++) ); assertEquals("4 0.47 1.56 1.44 1.45", outputData.get(line++) ); assertEquals("5 1.21 0.19 1.23 0.54", outputData.get(line++) ); assertEquals("6 0.49 1.36 1.63 1.65", outputData.get(line++) ); } private List survexDataFromSeries( SurveySeries series ) { //Declare structure to hold survey data CaveSurvey surveyData = new CaveSurvey(); surveyData.add(series); SurvexWriter writer = new SurvexWriter(); List outputData = writer.generateSurvexData(surveyData, true ); return outputData; } } CaveConverter_src/test/cavesurvey/data/model/SurveySeriesTest.java0000644000000000000000000005551412204413600024532 0ustar rootroot/** * Copyright (C) 2009-2013 Paul Fretwell - aka 'Footleg' (drfootleg@gmail.com) * * This file is part of Cave Converter. * * Cave Converter is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation, either version 3 of the License, or * (at your option) any later version. * * Cave Converter is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with Cave Converter. If not, see . */ package cavesurvey.data.model; import static org.junit.Assert.*; import java.text.ParseException; import java.util.Date; import org.junit.Test; import cavesurvey.tools.TestHelper; import footleg.cavesurvey.data.model.SeriesLink; import footleg.cavesurvey.data.model.SurveySeries; import footleg.cavesurvey.data.model.SurveyStation; import footleg.cavesurvey.tools.UtilityFunctions; public class SurveySeriesTest { /** * Test method for {@link footleg.cavesurvey.data.model.SurveyLeg#constructor(String)}, * {@link footleg.cavesurvey.data.model.SurveyLeg#getSeriesName(String)}, * {@link footleg.cavesurvey.data.model.SurveyLeg#setSeriesName(String)}. */ @Test public void testSurveySeriesName() { String seriesName1 = "Test Series"; String seriesName2 = "Renamed Series"; //Create series with a name SurveySeries series = new SurveySeries( seriesName1 ); //Check name returned matches the name given assertTrue("Series name matches name given in contructor.", series.getSeriesName() == seriesName1 ); //Change the series name series.setSeriesName( seriesName2 ); //Check the name returned matches the updated name assertTrue("Series name matches the updated name.", series.getSeriesName() == seriesName2 ); } @Test public void testSeriesDateGetSet() { SurveySeries series = new SurveySeries( "Test" ); String dateString = "12/02/1982 01:15:53"; String dateFormat = "dd/MM/yyyy HH:mm:ss"; try { Date date = UtilityFunctions.stringToDate(dateString, dateFormat); series.setSurveyDate(date); } catch (ParseException e) { //Just print out error (will never happen with hard coded arguments used in method call above) e.printStackTrace(); } assertEquals("Date returned should match date set.", dateString, UtilityFunctions.dateToString(series.getSurveyDate(), dateFormat) ); } @Test public void testSeriesCommentSetSet() { SurveySeries series = new SurveySeries( "Test" ); String comment = "My surveying is perfect."; series.setComment(comment); assertEquals("Comment returned should match comment set.", comment, series.getComment() ); } @Test public void testSetStationIdFromName() { SurveySeries series = new SurveySeries( "Test" ); SurveyStation stn = new SurveyStation(0); //Set name which is numeric stn.setName("42"); series.setStationIdFromName( stn ); assertTrue("Station id matches name string as number 42.", stn.getId() == 42 ); stn.setName("text"); series.setStationIdFromName( stn ); assertTrue("Station id from non-numeric name should be negative.", stn.getId() == -1 ); } @Test public void testAddLegSurveyLeg() { SurveySeries series = new SurveySeries( "Test" ); Double leg1Length = 1.0; Double leg2Length = 2.0; Double leg3Length = 3.0; assertEquals("Series leg count is zero when first created.", 0, series.legCount() ); series.addLeg( TestHelper.createTestLeg(1,2,leg1Length,58,-14) ); assertEquals("Series leg count is one when one leg added.", 1, series.legCount() ); //Add leg 3 next series.addLeg( TestHelper.createTestLeg(3,4,leg3Length,0,0) ); assertEquals("Series leg count is 2 when 2 legs added.", 2, series.legCount() ); assertEquals("First leg added is at the start.", series.getLegRaw(0).getLength(), leg1Length, 0.0 ); assertEquals("Last leg added is at the end.", series.getLegRaw(series.legCount() - 1).getLength(), leg3Length, 0.0 ); //Insert leg 2 into second position series.addLeg( TestHelper.createTestLeg(2,3,leg2Length,12,34), 1 ); assertEquals("Series leg count is 3 when 3 legs added.", 3, series.legCount() ); assertEquals("First leg added is at the start.", series.getLegRaw(0).getLength(), leg1Length, 0.0 ); assertEquals("Leg 3 is at the end.", series.getLegRaw(series.legCount() - 1).getLength(), leg3Length, 0.0 ); assertEquals("Leg 2 is in the middle.", series.getLegRaw(1).getLength(), leg2Length, 0.0 ); } /** * Test method for {@link footleg.cavesurvey.data.model.SurveyLeg#getNumberToRepresentStnName(String)}. */ @Test public void testGetNumberToRepresentStnName() { SurveySeries series = new SurveySeries( "Test" ); //Add first station name to get a mapped number String stn1A = "1A"; int stn1 = series.getNumberToRepresentStnName(stn1A); //Check number is negative assertTrue("Mapped station number should be negative.", stn1 < 0 ); //Add a second station name String stn2A = "2A"; int stn2 = series.getNumberToRepresentStnName(stn2A); //Check number is negative assertTrue("Mapped station number should be negative.", stn2 < 0 ); //Check number is not the same as previous station number assertFalse("Mapped station numbers should be unique.", stn1 == stn2 ); //Add same mapped name again int stn1b = series.getNumberToRepresentStnName(stn1A); //Check same number was returned as last time this name was added assertTrue("Mapped station number should be the same when the same string is passed in a second time.", stn1 == stn1b ); } /** * Test method for {@link footleg.cavesurvey.data.model.SurveyLeg#getMappedStnName(String)}. */ @Test public void testGetMappedStnName() { SurveySeries series = new SurveySeries( "Test" ); //Add first station name to get a mapped number String stn1A = "1A"; int stn1 = series.getNumberToRepresentStnName(stn1A); assertTrue("Station number should be negative for a numeric name.", stn1 < 0); //Add a second station name String stn2A = "2A"; int stn2 = series.getNumberToRepresentStnName(stn2A); assertTrue("Station number should be negative for a numeric name.", stn2 < 0); //Add a third station name with a name already used String stn3N = stn2A; int stn3 = series.getNumberToRepresentStnName(stn3N); assertEquals("Station number should be same as last time this name was used.", stn2, stn3); //Check name returned for first number assertEquals("Returned station name should match name specified for number.", stn1A, series.getMappedStnName( stn1 ) ); //Check name returned for 2nd number assertEquals("Returned station name should match name specified for number.", stn2A, series.getMappedStnName( stn2 ) ); //Check name returned for 3rd number assertEquals("Returned station name should match name specified for number.", stn3N, series.getMappedStnName( stn3 ) ); //Check that a positive numeric ID returns the name which is that number assertEquals("Station name should match number for positive ids", "123", series.getMappedStnName( 123 )); } @Test public void testCalibrationGettersSetters() { SurveySeries series = new SurveySeries( "Test" ); assertEquals("Tape calibration should be zero by default.", 0.0, series.getTapeCalibration(), 0.0); assertEquals("Compass calibration should be zero by default.", 0.0, series.getCompassCalibration(), 0.0); assertEquals("Clino calibration should be zero by default.", 0.0, series.getClinoCalibration(), 0.0); assertEquals("Declination should be zero by default.", 0.0, series.getDeclination(), 0.0); Double tapeCal = 1.45; Double compassCal = 0.52; Double clinoCal = -3.74; Double decl = 2.56; series.setTapeCalibration(tapeCal); series.setCompassCalibration(compassCal); series.setClinoCalibration(clinoCal); series.setDeclination(decl); assertEquals("Tape calibration should match value that was set.", tapeCal, series.getTapeCalibration(), 0.0); assertEquals("Compass calibration should match value that was set.", compassCal, series.getCompassCalibration(), 0.0); assertEquals("Clino calibration should match value that was set.", clinoCal, series.getClinoCalibration(), 0.0); assertEquals("Declination should match value that was set.", decl, series.getDeclination(), 0.0); } @Test public void testAddLink() { SurveySeries series = new SurveySeries( "Test" ); String series1 = "ser1"; SurveyStation stn1 = new SurveyStation(1); String series2 = "ser2"; SurveyStation stn2 = new SurveyStation(2); assertEquals("Series link count is zero when first created.", 0, series.getLinks().size() ); series.addLink(series1, stn1, series2, stn2); assertEquals("Series link count is one when first link has been added.", 1, series.getLinks().size() ); SeriesLink link = series.getLinks().get(0); assertEquals("Link series 1 matches series set when adding link.", series1, link.getSeries1() ); assertEquals("Link station 1 matches station set when adding link.", stn1, link.getStn1() ); assertEquals("Link series 2 matches series set when adding link.", series2, link.getSeries2() ); assertEquals("Link station 2 matches station set when adding link.", stn2, link.getStn2() ); } @Test public void testAddSeries() { SurveySeries series = new SurveySeries( "Parent" ); assertEquals("Inner series count is zero when first created.", 0, series.innerSeriesCount() ); String innerSeries1 = "inner1"; SurveySeries inner1 = new SurveySeries( innerSeries1 ); series.addSeries(inner1); assertEquals("Inner series count is one when first inner series is added.", 1, series.innerSeriesCount() ); String innerSeries2 = "inner2"; SurveySeries inner2 = new SurveySeries( innerSeries2 ); series.addSeries(inner2); assertEquals("Inner series count is two when 2nd inner series is added.", 2, series.innerSeriesCount() ); String innerSeries3 = "inner3"; SurveySeries inner3 = new SurveySeries( innerSeries3 ); series.addSeries(inner3); assertEquals("Inner series count is 3 when 3rd inner series is added.", 3, series.innerSeriesCount() ); SurveySeries inner3rd = series.getInnerSeries(2); assertEquals("Inner series at index 2 is 3rd inner series added.", innerSeries3, inner3rd.getSeriesName() ); SurveySeries innerSearchMatch = series.findInnerSeriesByName(innerSeries2); assertEquals("Inner series matching name used to fin by name.", innerSeries2, innerSearchMatch.getSeriesName() ); } /* * TODO Test support for true vertical legs and true horizontal legs * * TODO Test that calibrations are applied somehow to inner series * * TODO Test that clino readings from 0 to 180 work with appropriate calibration */ @Test public void testGetLegCorrectedWithCalibrations() { SurveySeries series = new SurveySeries( "Test" ); Double leg1Length = 1.0; Double leg1Compass = 83.0; Double leg1Clino = -2.0; Double leg2Length = 2.0; Double leg2Compass = 359.9; Double leg2Clino = -90.0; Double leg3Length = 3.0; Double leg3Compass = 260.5; Double leg3Clino = 0.0; //Add 3 test legs to series series.addLeg( TestHelper.createTestLeg(1,2,leg1Length,leg1Compass,leg1Clino) ); series.addLeg( TestHelper.createTestLeg(2,3,leg2Length,leg2Compass,leg2Clino) ); series.addLeg( TestHelper.createTestLeg(3,4,leg3Length,leg3Compass,leg3Clino) ); //Check lengths are the same as set when no calibration assertEquals("First leg length with no calibration set.", leg1Length, series.getLegCorrected(0).getLength(), 0.0 ); assertEquals("Second leg length with no calibration set.", leg2Length, series.getLegCorrected(1).getLength(), 0.0 ); assertEquals("Third leg length with no calibration set.", leg3Length, series.getLegCorrected(2).getLength(), 0.0 ); //Check compass bearings are the same as set when no calibration assertEquals("First leg bearing with no calibration set.", leg1Compass, series.getLegCorrected(0).getCompass(), 0.0 ); assertEquals("Second leg bearing with no calibration set.", leg2Compass, series.getLegCorrected(1).getCompass(), 0.0 ); assertEquals("Third leg bearing with no calibration set.", leg3Compass, series.getLegCorrected(2).getCompass(), 0.0 ); //Check clino readings are the same as set when no calibration assertEquals("First leg clino with no calibration set.", leg1Clino, series.getLegCorrected(0).getClino(), 0.0 ); assertEquals("Second leg clino with no calibration set.", leg2Clino, series.getLegCorrected(1).getClino(), 0.0 ); assertEquals("Third leg clino with no calibration set.", leg3Clino, series.getLegCorrected(2).getClino(), 0.0 ); //Set tape calibration Double tapeCal = 0.1; //Tape is 10cm short series.setTapeCalibration(tapeCal); //Lengths recorded in legs are now 10cm too long, so corrected lengths should be shorter leg1Length -= tapeCal; leg2Length -= tapeCal; leg3Length -= tapeCal; //Check lengths are the same as set when no calibration assertEquals("First leg length with tape calibration set.", leg1Length, series.getLegCorrected(0).getLength(), 0.0 ); assertEquals("Second leg length with tape calibration set.", leg2Length, series.getLegCorrected(1).getLength(), 0.0 ); assertEquals("Third leg length with tape calibration set.", leg3Length, series.getLegCorrected(2).getLength(), 0.0 ); //Check compass bearings are the same as set when no calibration assertEquals("First leg bearing with tape calibration set.", leg1Compass, series.getLegCorrected(0).getCompass(), 0.0 ); assertEquals("Second leg bearing with tape calibration set.", leg2Compass, series.getLegCorrected(1).getCompass(), 0.0 ); assertEquals("Third leg bearing with tape calibration set.", leg3Compass, series.getLegCorrected(2).getCompass(), 0.0 ); //Check clino readings are the same as set when no calibration assertEquals("First leg clino with tape calibration set.", leg1Clino, series.getLegCorrected(0).getClino(), 0.0 ); assertEquals("Second leg clino with tape calibration set.", leg2Clino, series.getLegCorrected(1).getClino(), 0.0 ); assertEquals("Third leg clino with tape calibration set.", leg3Clino, series.getLegCorrected(2).getClino(), 0.0 ); //Set compass calibration Double compassCal = 0.5; //Compass reads 0.5 for North series.setCompassCalibration(compassCal); //Bearing of 0.5 should be zero degrees, so subtract cal value from actuals leg1Compass -= compassCal; leg2Compass -= compassCal; leg3Compass -= compassCal; //Check lengths are the same as set when no calibration assertEquals("First leg length with tape and compass calibration set.", leg1Length, series.getLegCorrected(0).getLength(), 0.0 ); assertEquals("Second leg length with tape and compass calibration set.", leg2Length, series.getLegCorrected(1).getLength(), 0.0 ); assertEquals("Third leg length with tape and compass calibration set.", leg3Length, series.getLegCorrected(2).getLength(), 0.0 ); //Check compass bearings are the same as set when no calibration assertEquals("First leg bearing with tape and compass calibration set.", leg1Compass, series.getLegCorrected(0).getCompass(), 0.0 ); assertEquals("Second leg bearing with tape and compass calibration set.", leg2Compass, series.getLegCorrected(1).getCompass(), 0.0 ); assertEquals("Third leg bearing with tape and compass calibration set.", leg3Compass, series.getLegCorrected(2).getCompass(), 0.0 ); //Check clino readings are the same as set when no calibration assertEquals("First leg clino with tape and compass calibration set.", leg1Clino, series.getLegCorrected(0).getClino(), 0.0 ); assertEquals("Second leg clino with tape and compass calibration set.", leg2Clino, series.getLegCorrected(1).getClino(), 0.0 ); assertEquals("Third leg clino with tape and compass calibration set.", leg3Clino, series.getLegCorrected(2).getClino(), 0.0 ); //Set clino calibration Double clinoCal = -1.2; //Clino reads -1.2 for level series.setClinoCalibration(clinoCal); //Bearing of 0.5 should be zero degrees, so subtract cal value from actuals leg1Clino -= clinoCal; leg2Clino -= clinoCal; leg3Clino -= clinoCal; //Check lengths are the same as set when no calibration assertEquals("First leg length with tape, compass and clino calibration set.", leg1Length, series.getLegCorrected(0).getLength(), 0.0 ); assertEquals("Second leg length with tape, compass and clino calibration set.", leg2Length, series.getLegCorrected(1).getLength(), 0.0 ); assertEquals("Third leg length with tape, compass and clino calibration set.", leg3Length, series.getLegCorrected(2).getLength(), 0.0 ); //Check compass bearings are the same as set when no calibration assertEquals("First leg bearing with tape, compass and clino calibration set.", leg1Compass, series.getLegCorrected(0).getCompass(), 0.0 ); assertEquals("Second leg bearing with tape, compass and clino calibration set.", leg2Compass, series.getLegCorrected(1).getCompass(), 0.0 ); assertEquals("Third leg bearing with tape, compass and clino calibration set.", leg3Compass, series.getLegCorrected(2).getCompass(), 0.0 ); //Check clino readings are the same as set when no calibration assertEquals("First leg clino with tape, compass and clino calibration set.", leg1Clino, series.getLegCorrected(0).getClino(), 0.0 ); assertEquals("Second leg clino with tape, compass and clino calibration set.", leg2Clino, series.getLegCorrected(1).getClino(), 0.0 ); assertEquals("Third leg clino with tape, compass and clino calibration set.", leg3Clino, series.getLegCorrected(2).getClino(), 0.0 ); //Set declination adjustment Double declination = 2.36; // series.setDeclination(declination); //Bearing of 0.5 should be zero degrees, so subtract cal value from actuals leg1Compass -= declination; leg2Compass -= declination; leg3Compass -= declination; //Check lengths are the same as set when no calibration assertEquals("First leg length with all calibrations set plus declination.", leg1Length, series.getLegCorrected(0).getLength(), 0.0 ); assertEquals("Second leg length with all calibrations set plus declination.", leg2Length, series.getLegCorrected(1).getLength(), 0.0 ); assertEquals("Third leg length with all calibrations set plus declination.", leg3Length, series.getLegCorrected(2).getLength(), 0.0 ); //Check compass bearings are the same as set when no calibration assertEquals("First leg bearing with all calibrations set plus declination.", leg1Compass, series.getLegCorrected(0).getCompass(), 0.0 ); assertEquals("Second leg bearing with all calibrations set plus declination.", leg2Compass, series.getLegCorrected(1).getCompass(), 0.0 ); assertEquals("Third leg bearing with all calibrations set plus declination.", leg3Compass, series.getLegCorrected(2).getCompass(), 0.0 ); //Check clino readings are the same as set when no calibration assertEquals("First leg clino with all calibrations set plus declination.", leg1Clino, series.getLegCorrected(0).getClino(), 0.0 ); assertEquals("Second leg clino with all calibrations set plus declination.", leg2Clino, series.getLegCorrected(1).getClino(), 0.0 ); assertEquals("Third leg clino with all calibrations set plus declination.", leg3Clino, series.getLegCorrected(2).getClino(), 0.0 ); } /* * On Vulcain topofil the clino is from 0 to 180 and * 0 = +90 * 90 = 0 * 180 = -90 * * measured value = (read value - zero error) x scale * calibrate clino 90 -1 * */ @Test public void testClinoCalibrationsForTopofil() { SurveySeries series = new SurveySeries( "Test" ); //Set clino calibration for topofil series.setClinoCalibration(90.0, -1); //Clino of 0 should be +90 degrees Double clinoReading = 0.0; Double clinoCorrected = 90.0; series.addLeg( TestHelper.createTestLeg(1,2,1.1,158.0,clinoReading) ); assertEquals("Clino corrected for topofil data.", clinoCorrected, series.getLegCorrected(0).getClino(), 0.0 ); //Clino of 90 should be 0 degrees clinoReading = 90.0; clinoCorrected = 0.0; series.addLeg( TestHelper.createTestLeg(2,3,2.2,274.0,clinoReading) ); assertEquals("Clino corrected for topofil data.", clinoCorrected, series.getLegCorrected(1).getClino(), 0.0 ); //Clino of 180 should be -90 degrees clinoReading = 180.0; clinoCorrected = -90.0; series.addLeg( TestHelper.createTestLeg(3,4,3.3,64.0,clinoReading) ); assertEquals("Clino corrected for topofil data.", clinoCorrected, series.getLegCorrected(2).getClino(), 0.0 ); } /* Reverse series method is no longer used, so is commented out in series class @Test public void testReverseSeries() { SurveySeries series = new SurveySeries( "Test" ); Double tape1 = 1.0; Double tape2 = 2.0; Double tape3 = 3.0; Double tape4 = 4.0; series.addLeg( TestHelper.createTestLeg( 1, 2, tape1, 10, 10 ) ); series.addLeg( TestHelper.createTestLeg( 2, 3, tape2, 100, 20 ) ); series.addLeg( TestHelper.createTestLeg( 3, 4, tape3, 190, 0 ) ); series.addLeg( TestHelper.createTestLeg( 4, 5, tape4, 340, -5 ) ); series.reverseSeries(); SurveyLeg leg = series.getLegRaw(0); assertEquals("From stn of first leg", 5, leg.getFromStn().getId() ); assertEquals("To stn of first leg", 4, leg.getToStn().getId() ); assertEquals("Length of first leg", tape4, leg.getLength(), 0.0 ); assertEquals("Compass for first leg", 160, leg.getCompass(), 0.0 ); assertEquals("Clino for first leg", 5, leg.getClino(), 0.0 ); leg = series.getLegRaw(1); assertEquals("From stn of 2nd leg", 4, leg.getFromStn().getId() ); assertEquals("To stn of 2nd leg", 3, leg.getToStn().getId() ); assertEquals("Length of 2nd leg", tape3, leg.getLength(), 0.0 ); assertEquals("Compass for 2nd leg", 10, leg.getCompass(), 0.0 ); assertEquals("Clino for 2nd leg", 0, leg.getClino(), 0.0 ); leg = series.getLegRaw(2); assertEquals("From stn of 3rd leg", 3, leg.getFromStn().getId() ); assertEquals("To stn of 3rd leg", 2, leg.getToStn().getId() ); assertEquals("Length of 3rd leg", tape2, leg.getLength(), 0.0 ); assertEquals("Compass for 3rd leg", 280, leg.getCompass(), 0.0 ); assertEquals("Clino for 3rd leg", -20, leg.getClino(), 0.0 ); leg = series.getLegRaw(3); assertEquals("From stn of 4th leg", 2, leg.getFromStn().getId() ); assertEquals("To stn of 4th leg", 1, leg.getToStn().getId() ); assertEquals("Length of 4th leg", tape1, leg.getLength(), 0.0 ); assertEquals("Compass for 4th leg", 190, leg.getCompass(), 0.0 ); assertEquals("Clino for 4th leg", -10, leg.getClino(), 0.0 ); } */ } CaveConverter_src/test/cavesurvey/data/model/SurveyLegTest.java0000644000000000000000000002261412076252374024022 0ustar rootroot/** * Copyright (C) 2009-2013 Paul Fretwell - aka 'Footleg' (drfootleg@gmail.com) * * This file is part of Cave Converter. * * Cave Converter is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation, either version 3 of the License, or * (at your option) any later version. * * Cave Converter is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with Cave Converter. If not, see . */ package cavesurvey.data.model; import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertTrue; import org.junit.Test; import footleg.cavesurvey.data.model.SurveyLeg; import footleg.cavesurvey.data.model.SurveyStation; /** * Unit test class for {@link footleg.cavesurvey.data.model.SurveyLeg} * * @author Footleg * @version 2012.12.26 (ISO 8601 YYYY.MM.DD) * @since 1.6 (The Java version used) */ public class SurveyLegTest { // double easting = 4800456.0; // double northing = 4800789.75; // double altitude = 8900.45; /** * Test method for {@link footleg.cavesurvey.data.model.SurveyLeg#setFromStn(int)}. */ @Test public void testSetFromStn() { SurveyLeg leg = new SurveyLeg(); int stnID = 543; SurveyStation stn = new SurveyStation( stnID ); leg.setFromStn(stn); assertEquals( stnID, leg.getFromStn().getId() ); } /** * Test method for {@link footleg.cavesurvey.data.model.SurveyLeg#setToStn(int)}. */ @Test public void testSetToStn() { SurveyLeg leg = new SurveyLeg(); int stnID = 12345; SurveyStation stn = new SurveyStation( stnID ); leg.setToStn(stn); assertEquals( stnID, leg.getToStn().getId() ); } /** * Test method for {@link footleg.cavesurvey.data.model.SurveyLeg#setLength(double)}. */ @Test public void testSetLength() { SurveyLeg leg = new SurveyLeg(); double length = 123.45; leg.setLength(length); assertEquals( length, leg.getLength(), 0.0 ); } /** * Test method for {@link footleg.cavesurvey.data.model.SurveyLeg#setCompass(double)}. */ @Test public void testSetCompass() { SurveyLeg leg = new SurveyLeg(); double compass = 123.45; leg.setCompass(compass); assertEquals( compass, leg.getCompass(), 0.0 ); } /** * Test method for {@link footleg.cavesurvey.data.model.SurveyLeg#setClino(double)}. */ @Test public void testSetClino() { SurveyLeg leg = new SurveyLeg(); double clino = 123.45; leg.setClino(clino); assertEquals( clino, leg.getClino(), 0.0 ); } /** * Test method for {@link footleg.cavesurvey.data.model.SurveyLeg#setLeft(double)}. */ @Test public void testSetLeft() { SurveyLeg leg = new SurveyLeg(); double left = 0.45; leg.setLeft(left); assertEquals( left, leg.getLeft(), 0.0 ); left = 0.0; leg.setLeft(left); assertEquals( left, leg.getLeft(), 0.0 ); //TODO: Should error left = -0.1; leg.setLeft(left); assertEquals( left, leg.getLeft(), 0.0 ); } /** * Test method for {@link footleg.cavesurvey.data.model.SurveyLeg#setRight(double)}. */ @Test public void testSetRight() { SurveyLeg leg = new SurveyLeg(); double right = 0.45; leg.setRight(right); assertEquals( right, leg.getRight(), 0.0 ); right = 0.0; leg.setRight(right); assertEquals( right, leg.getRight(), 0.0 ); } /** * Test method for {@link footleg.cavesurvey.data.model.SurveyLeg#setUp(double)}. */ @Test public void testSetUp() { SurveyLeg leg = new SurveyLeg(); double up = 0.45; leg.setUp(up); assertEquals( up, leg.getUp(), 0.0 ); up = 0.0; leg.setUp(up); assertEquals( up, leg.getUp(), 0.0 ); } /** * Test method for {@link footleg.cavesurvey.data.model.SurveyLeg#setDown(double)}. */ @Test public void testSetDown() { SurveyLeg leg = new SurveyLeg(); double down = 0.45; leg.setDown(down); assertEquals( down, leg.getDown(), 0.0 ); down = 0.0; leg.setDown(down); assertEquals( down, leg.getDown(), 0.0 ); } // /** // * Test method for {@link footleg.cavesurvey.data.model.SurveyLeg#setFixedStn(boolean, double, double, double)}, // * {@link footleg.cavesurvey.data.model.SurveyLeg#clearFixedStn()} and associated getters. // */ // @Test // public void testSetFixedStnFrom() { // SurveyLeg leg = new SurveyLeg(); // // leg.setFixedStn(true, easting, northing, altitude); // // assertEquals( easting, leg.getEasting(), 0.0 ); // assertEquals( northing, leg.getNorthing(), 0.0 ); // assertEquals( altitude, leg.getAltitude(), 0.0 ); // assertTrue( leg.hasFixedStn() ); // assertTrue( leg.isFromStnFixed() ); // assertTrue( leg.isToStnFixed() == false ); // // leg.clearFixedStn(); // assertTrue( leg.hasFixedStn() == false ); // assertTrue( leg.isFromStnFixed() == false ); // assertTrue( leg.isToStnFixed() == false ); // } // // /** // * Test method for {@link footleg.cavesurvey.data.model.SurveyLeg#setFixedStn(boolean, double, double, double)}, // * {@link footleg.cavesurvey.data.model.SurveyLeg#clearFixedStn()} and associated getters. // */ // @Test // public void testSetFixedStnTo() { // SurveyLeg leg = new SurveyLeg(); // // leg.setFixedStn(false, easting, northing, altitude); // // assertEquals( easting, leg.getEasting(), 0.0 ); // assertEquals( northing, leg.getNorthing(), 0.0 ); // assertEquals( altitude, leg.getAltitude(), 0.0 ); // assertTrue( leg.hasFixedStn() ); // assertTrue( leg.isFromStnFixed() == false ); // assertTrue( leg.isToStnFixed() ); // // leg.clearFixedStn(); // assertTrue( leg.hasFixedStn() == false ); // assertTrue( leg.isFromStnFixed() == false ); // assertTrue( leg.isToStnFixed() == false ); // } /** * Test method for {@link footleg.cavesurvey.data.model.SurveyLeg#setSplay(boolean)}. */ @Test public void testSetSplay() { SurveyLeg leg = new SurveyLeg(); leg.setSplay( true ); assertTrue( leg.isSplay() ); leg.setSplay( false ); assertTrue( leg.isSplay() == false ); } /** * Test method for {@link footleg.cavesurvey.data.model.SurveyLeg#compareTo(footleg.cavesurvey.data.model.SurveyLeg)}. */ @Test public void testCompareTo() { SurveyLeg leg1 = new SurveyLeg(); SurveyLeg leg2 = new SurveyLeg(); SurveyLeg leg3 = new SurveyLeg(); SurveyLeg leg4 = new SurveyLeg(); int stnID1 = 1; int stnID2 = 2; int stnID3 = 3; int stnID4 = 4; SurveyStation stn1 = new SurveyStation(stnID1); SurveyStation stn2 = new SurveyStation(stnID2); SurveyStation stn3 = new SurveyStation(stnID3); SurveyStation stn4 = new SurveyStation(stnID4); leg1.setFromStn(stn1); leg1.setToStn(stn2); leg2.setFromStn(stn2); leg2.setToStn(stn3); leg3.setFromStn(stn2); leg3.setToStn(stn4); leg4.setFromStn(stn2); leg4.setToStn(stn1); assertTrue( leg1.compareTo(leg2) < 0 ); assertTrue( leg2.compareTo(leg1) > 0 ); assertTrue( leg2.compareTo(leg3) < 0 ); assertTrue( leg3.compareTo(leg2) > 0 ); assertTrue( leg2.compareTo(leg4) > 0 ); assertTrue( leg4.compareTo(leg2) < 0 ); } /** * Test method for {@link footleg.cavesurvey.data.model.SurveyLeg#clone()}. */ @Test public void testClone() { SurveyLeg leg = new SurveyLeg(); int fromStnId = 123; int toStnId = 456; SurveyStation fromStn = new SurveyStation( fromStnId ); SurveyStation toStn = new SurveyStation( toStnId ); double length = 123.45; double compass = 123.45; double clino = 123.45; double left = 1.2; double right = 0.1; double up = 0.23; double down = 0.92; boolean splay = true; // boolean fixFromStn = true; //Create leg fully populated with test data leg.setFromStn(fromStn); leg.setToStn(toStn); leg.setLength(length); leg.setCompass(compass); leg.setClino(clino); leg.setLeft(left); leg.setRight(right); leg.setUp(up); leg.setDown(down); leg.setSplay(splay); //TODO remove leg.setFixedStn(fixFromStn, easting, northing, altitude); //Clone leg SurveyLeg legClone = leg.clone(); //Set clone has the correct data values assertEquals( fromStnId, legClone.getFromStn().getId() ); assertEquals( toStnId, legClone.getToStn().getId() ); assertEquals( length, legClone.getLength(), 0.0 ); assertEquals( compass, legClone.getCompass(), 0.0 ); assertEquals( clino, legClone.getClino(), 0.0 ); assertEquals( left, legClone.getLeft(), 0.0 ); assertEquals( right, legClone.getRight(), 0.0 ); assertEquals( up, legClone.getUp(), 0.0 ); assertEquals( down, legClone.getDown(), 0.0 ); assertTrue( legClone.isSplay() == splay ); //TODO remove assertEquals( easting, legClone.getEasting(), 0.0 ); //TODO remove assertEquals( northing, legClone.getNorthing(), 0.0 ); //TODO remove assertEquals( altitude, legClone.getAltitude(), 0.0 ); //TODO remove assertTrue( legClone.hasFixedStn() ); //TODO remove assertTrue( legClone.isFromStnFixed() == fixFromStn ); //TODO remove assertTrue( legClone.isToStnFixed() != fixFromStn ); } } CaveConverter_src/test/cavesurvey/data/model/SurveyStationTest.java0000644000000000000000000001522712076252374024736 0ustar rootroot/** * Copyright (C) 2009-2013 Paul Fretwell - aka 'Footleg' (drfootleg@gmail.com) * * This file is part of Cave Converter. * * Cave Converter is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation, either version 3 of the License, or * (at your option) any later version. * * Cave Converter is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with Cave Converter. If not, see . */ package cavesurvey.data.model; import static org.junit.Assert.*; import org.junit.Test; import footleg.cavesurvey.data.model.SurveyStation; import footleg.cavesurvey.data.model.SurveyStation.FixType; /** * Unit test class for {@link footleg.cavesurvey.data.model.SurveyStation} * * @author Footleg * @version 2012.12.26 (ISO 8601 YYYY.MM.DD) * @since 1.6 (The Java version used) */ public class SurveyStationTest { @Test public void testSetEntrance() { int stnID = 123; SurveyStation stn = new SurveyStation( stnID ); assertFalse( "Station entrance should be false if not set.", stn.isEntrance() ); stn.setEntrance(true); assertTrue( "Checking station was set to be an entrance.", stn.isEntrance() ); stn.setEntrance(false); assertFalse( "Checking station was reset to not be an entrance", stn.isEntrance() ); } @Test public void testSetFixed() { int stnID = 123; double easting = 4800456.0; double northing = 4800789.75; double altitude = 8900.45; double easting2 = 123.45; double northing2 = 678.00; double altitude2 = 0.0; SurveyStation stn = new SurveyStation( stnID ); assertFalse( "Station should not be fixed by default.", stn.isFixed() ); //Set GPS type fix stn.setFixed(FixType.GPS, easting, northing, altitude); assertTrue( "Checking station was set to be fixed.", stn.isFixed() ); assertEquals("Getter for Easting", easting, stn.getEasting(), 0.0 ); assertEquals("Getter for Northing", northing, stn.getNorthing(), 0.0 ); assertEquals("Getter for Altitude", altitude, stn.getAltitude(), 0.0 ); assertEquals("Getter for fix type GPS", FixType.GPS, stn.getFixType() ); //Set Other type fix stn.setFixed(FixType.OTHER, easting2, northing2, altitude2); assertTrue( "Checking station was set to be fixed.", stn.isFixed() ); assertEquals("Getter for Easting", easting2, stn.getEasting(), 0.0 ); assertEquals("Getter for Northing", northing2, stn.getNorthing(), 0.0 ); assertEquals("Getter for Altitude", altitude2, stn.getAltitude(), 0.0 ); assertEquals("Getter for fix type Other", FixType.OTHER, stn.getFixType() ); //Clear fix stn.clearFixedStn(); assertFalse( "Station fix was cleared", stn.isFixed() ); } @Test public void testSetId() { int stnID = 67899035; SurveyStation stn = new SurveyStation( stnID ); assertEquals("Getter for Id", stnID, stn.getId() ); } @Test public void testGetName() { int stnID = 12; String defaultName = "12"; int stnID2 = 345; String defaultName2 = "345"; String newName = "ABC"; SurveyStation stn = new SurveyStation( stnID ); //If not set then name should be string of the Id assertEquals("Getter for Name based on Id", defaultName, stn.getName() ); //Change ID, check name changes stn.setId(stnID2); assertEquals("Getter for Name based on changed Id", defaultName2, stn.getName() ); //Set name to something else stn.setName(newName); assertEquals("Getter for Name set explicitly", newName, stn.getName() ); //Change ID after name was set, and check name is not changed stn.setId(92364); assertEquals("Getter for Name set explicitly", newName, stn.getName() ); } @Test public void testSetComment() { int stnID = 12; String commentText = "This is a station comment. It is quite long can contains\ra line break."; SurveyStation stn = new SurveyStation( stnID ); stn.setComment(commentText); assertEquals("Getter for Comment", commentText, stn.getComment() ); } @Test public void testClone() { int stnID = 12; String newName = "ABC"; String commentText = "This is a station comment. It is quite long can contains\ra line break."; double easting = 4800456.0; double northing = 4800789.75; double altitude = 8900.45; SurveyStation stn = new SurveyStation( stnID ); stn.setName(newName); stn.setComment(commentText); stn.setEntrance(true); stn.setFixed(FixType.GPS, easting, northing, altitude); SurveyStation clone = stn.clone(); assertEquals( "Station ID from clone", stnID, clone.getId() ); assertEquals( "Station Name from clone", newName, clone.getName() ); assertEquals( "Station Comment from clone", commentText, clone.getComment() ); assertTrue( "Station is entrance from clone", clone.isEntrance() ); assertTrue( "Station is fixed from clone", clone.isFixed() ); assertEquals( "Station is fix type from clone", FixType.GPS, clone.getFixType() ); assertEquals( "Station easting from clone", easting, clone.getEasting(), 0.0 ); assertEquals( "Station northing from clone", northing, clone.getNorthing(), 0.0 ); assertEquals( "Station altitude from clone", altitude, clone.getAltitude(), 0.0 ); //Change values of original station, and check clone was not changed //(checks clone is not a pointer to the same object) stn.setId(8765); stn.setName("iusdfhbs"); stn.setComment("iadrkuKAJ RDFC J JGV JYG BHF HF NJH B CN HJC NGF XB HGF CBNJCFN JFC NJ CF"); stn.setEntrance(false); stn.setFixed(FixType.OTHER, 1.2, 3.4, 5.6); assertEquals( "Station ID from clone", stnID, clone.getId() ); assertEquals( "Station Name from clone", newName, clone.getName() ); assertEquals( "Station Comment from clone", commentText, clone.getComment() ); assertTrue( "Station is entrance from clone", clone.isEntrance() ); assertTrue( "Station is fixed from clone", clone.isFixed() ); assertEquals( "Station is fix type from clone", FixType.GPS, clone.getFixType() ); assertEquals( "Station easting from clone", easting, clone.getEasting(), 0.0 ); assertEquals( "Station northing from clone", northing, clone.getNorthing(), 0.0 ); assertEquals( "Station altitude from clone", altitude, clone.getAltitude(), 0.0 ); } } CaveConverter_src/test/cavesurvey/data/writer/0000755000000000000000000000000012165540164020575 5ustar rootrootCaveConverter_src/test/cavesurvey/data/writer/TopoRobotWriterTest.java0000644000000000000000000001034412167002274025423 0ustar rootrootpackage cavesurvey.data.writer; import static org.junit.Assert.*; import org.junit.Test; import cavesurvey.tools.TestHelper; import footleg.cavesurvey.data.model.CaveSurvey; import footleg.cavesurvey.data.model.SurveySeries; import footleg.cavesurvey.data.writer.TopoRobotWriter; import footleg.cavesurvey.tools.UtilityFunctions; public class TopoRobotWriterTest { @Test public void testConvertToSingleSeries() { TopoRobotWriter writer = new TopoRobotWriter(); //Create test survey CaveSurvey surveyData = new CaveSurvey(); //Create master series SurveySeries masterSeries = new SurveySeries("outer"); //Add 3 test legs to series masterSeries.addLeg( TestHelper.createTestLeg(1,2,1.0,0.0,0.0) ); masterSeries.addLeg( TestHelper.createTestLeg(2,3,1.0,20.0,0.0) ); masterSeries.addLeg( TestHelper.createTestLeg(3,4,1.0,40.0,0.0) ); //Create inner series SurveySeries innerSeries = new SurveySeries("inner"); //Add a couple of test legs innerSeries.addLeg( TestHelper.createTestLeg(1,2,1.0,100.0,0.0) ); innerSeries.addLeg( TestHelper.createTestLeg(2,3,1.0,120.0,0.0) ); //Link station in inner series to a station in the outer series masterSeries.addLink("", masterSeries.getLegRaw(2).getToStn(), "inner", innerSeries.getLegRaw(0).getFromStn()); //Add inner series to master series masterSeries.addSeries(innerSeries); //Add master series to survey surveyData.add(masterSeries); //Convert to single series SurveySeries convertedSeries = writer.convertToSingleSeries(surveyData, false); assertEquals("root", convertedSeries.getSeriesName() ); } @Test public void testConvertToLinearSeriesFig8() { //Create master series SurveySeries masterSeries = new SurveySeries("test"); //Add 3 test legs to series masterSeries.addLeg( TestHelper.createTestLeg(1,2,1.0,010.0,0.0) ); masterSeries.addLeg( TestHelper.createTestLeg(2,3,1.0,100.0,0.0) ); masterSeries.addLeg( TestHelper.createTestLeg(3,4,1.0,190.0,0.0) ); masterSeries.addLeg( TestHelper.createTestLeg(4,1,1.0,280.0,0.0) ); masterSeries.addLeg( TestHelper.createTestLeg(1,5,1.0,270.0,0.0) ); masterSeries.addLeg( TestHelper.createTestLeg(5,6,1.0,180.0,0.0) ); masterSeries.addLeg( TestHelper.createTestLeg(6,7,1.0,090.0,0.0) ); masterSeries.addLeg( TestHelper.createTestLeg(7,1,1.0,000.0,0.0) ); //Convert to single series SurveySeries convertedSeries = UtilityFunctions.convertToLinearSeries(masterSeries); assertEquals("Expect 2 series from figure of 8 loop.", 2, convertedSeries.innerSeriesCount() ); } @Test public void testConvertToLinearSeriesOrderedT() { //Create master series SurveySeries masterSeries = new SurveySeries("test"); //Add 3 test legs to series masterSeries.addLeg( TestHelper.createTestLeg(1,2,1.0,110.0,0.0) ); masterSeries.addLeg( TestHelper.createTestLeg(2,3,1.0,100.0,0.0) ); masterSeries.addLeg( TestHelper.createTestLeg(3,4,1.0,190.0,0.0) ); masterSeries.addLeg( TestHelper.createTestLeg(4,5,1.0,180.0,0.0) ); masterSeries.addLeg( TestHelper.createTestLeg(3,6,1.0,270.0,0.0) ); masterSeries.addLeg( TestHelper.createTestLeg(6,7,1.0,290.0,0.0) ); //Convert to single series SurveySeries convertedSeries = UtilityFunctions.convertToLinearSeries(masterSeries); assertEquals("Expect 2 series from t-shaped single series.", 2, convertedSeries.innerSeriesCount() ); } @Test public void testConvertToLinearSeriesScrambledT() { //Create master series SurveySeries masterSeries = new SurveySeries("test"); //Add 3 test legs to series masterSeries.addLeg( TestHelper.createTestLeg(4,5,1.0,180.0,0.0) ); masterSeries.addLeg( TestHelper.createTestLeg(3,6,1.0,270.0,0.0) ); masterSeries.addLeg( TestHelper.createTestLeg(2,3,1.0,100.0,0.0) ); masterSeries.addLeg( TestHelper.createTestLeg(6,7,1.0,290.0,0.0) ); masterSeries.addLeg( TestHelper.createTestLeg(3,4,1.0,190.0,0.0) ); masterSeries.addLeg( TestHelper.createTestLeg(1,2,1.0,110.0,0.0) ); //Convert to single series SurveySeries convertedSeries = UtilityFunctions.convertToLinearSeries(masterSeries); assertEquals("Expect 2 series from t-shaped single series.", 2, convertedSeries.innerSeriesCount() ); } } CaveConverter_src/test/cavesurvey/tools/0000755000000000000000000000000012215572460017510 5ustar rootrootCaveConverter_src/test/cavesurvey/tools/UtilityFunctionsTest.java0000644000000000000000000006363212227231320024547 0ustar rootroot/** * Copyright (C) 2009-2013 Paul Fretwell - aka 'Footleg' (drfootleg@gmail.com) * * This file is part of Cave Converter. * * Cave Converter is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation, either version 3 of the License, or * (at your option) any later version. * * Cave Converter is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with Cave Converter. If not, see . */ package cavesurvey.tools; import static org.junit.Assert.*; import java.text.ParseException; import java.util.Date; import java.util.List; import org.junit.Test; import footleg.cavesurvey.data.model.SeriesLink; import footleg.cavesurvey.data.model.SurveySeries; import footleg.cavesurvey.tools.UtilityFunctions; public class UtilityFunctionsTest { /** * Test helper method to call the UtilityFunctions.averageCompassBearings method for * two given bearings */ private double calcMeanBearing( double bearing1, double bearing2 ) { double[] bearings = new double[2]; bearings[0] = bearing1; bearings[1] = bearing2; double meanBearing = UtilityFunctions.averageCompassBearings(bearings); if ( meanBearing > 359.999) { meanBearing = 0; } return meanBearing; } /** * Test helper method to call the UtilityFunctions.averageCompassBearings method for * three given bearings */ private double calcMeanBearing( double bearing1, double bearing2, double bearing3 ) { double[] bearings = new double[3]; bearings[0] = bearing1; bearings[1] = bearing2; bearings[2] = bearing3; double meanBearing = UtilityFunctions.averageCompassBearings(bearings); return meanBearing; } /** * Test helper method to call the UtilityFunctions.averageCompassBearings method for * two given bearings and an expected result, which formats a useful assertion message * on test failure. */ private void testMean2(double a, double b, double expectedMean) { double mean = calcMeanBearing(a, b); assertEquals("Mean bearing for values of " + a + " and " + b + "." , expectedMean, mean, 0.001); } /** * Test helper method to call the UtilityFunctions.averageCompassBearings method for * three given bearings and an expected result, which formats a useful assertion message * on test failure. */ private void testMean3(double a, double b, double c, double expected) { double expectedMean = expected; double mean = calcMeanBearing(a, b, c); if ( ( expectedMean > 359.5 ) && ( mean < 0.5 ) ) { mean += 360; } else if ( ( mean > 359.5 ) && ( expectedMean < 0.5 ) ) { expectedMean += 360; } assertEquals("Mean bearing for values of " + a + ", " + b + ", and " + c + "." , expectedMean, mean, 0.001); } /** * Test helper method to compare the result from UtilityFunctions.averageCompassBearings method * for three given bearings with the result from the numerical average method */ private void testMean3VerusNumericalAverage(double a, double b, double c) { double expectedMean = numericalMeanBearing3(a, b, c); testMean3(a, b, c, expectedMean); } /** * Test method which calculates the numerical average of two bearings using logical cases * for relative positions of the two legs. This method essentially adds the two bearings * together and divides by two to get an average but also handles the case where the bearings * are either side of North (i.e. 359 & 1 should average to 0 and not 180). * This method works for any pair of bearings in the range 0 - 360 degrees with any * angle between them. */ private double numericalMeanBearing2( double bearing1, double bearing2 ) { double smallerBearing; double largerBearing; double meanBearing; //If bearings are the same then average is the value of either bearing if ( bearing1 == bearing2 ) { meanBearing = bearing1; } else { //Determine which is the larger value of the two bearings if ( bearing1 > bearing2 ) { largerBearing = bearing1; smallerBearing = bearing2; } else { largerBearing = bearing2; smallerBearing = bearing1; } //Adjust bearings so smaller is zero, and larger is relative to smaller double adjustedBearing = largerBearing - smallerBearing; if (adjustedBearing > 180) { //Larger bearing is on West side of compass dial, so average will be half way //between this and 360 deg. meanBearing = UtilityFunctions.adjustBearingWithinDegreesRange( 360 - ((360 - adjustedBearing) / 2) + smallerBearing, 0, 360); } else { //Larger bearing is on East side of compass dial, so average will be half way //between this and 0 deg. meanBearing = (adjustedBearing / 2) + smallerBearing; } } return meanBearing; } /** * Test method which calculates the numerical average of three bearings using logical cases * for relative positions of the three legs when all within 180 segment of each other. This * method essentially adds the three bearings together and divides by three to get an average * but also handles the case where the bearings are either side of North (i.e. 359, 357, 1 * should average to 359 and not 239) */ private double numericalMeanBearing3( double bearing1, double bearing2, double bearing3 ) { double bearingA = bearing1; double bearingB = bearing2; double bearingC = bearing3; double meanBearing; //If bearings are the same then average is the value of any bearing if ( ( bearingA == bearingB ) && ( bearingA == bearingC ) ) { meanBearing = bearingA; } else { //Check for case where all bearings are in the northern half of the compass dial //and split either side of North if ( ( ( bearingA > 270 ) || ( bearingA < 90 ) ) && ( ( bearingB > 270 ) || ( bearingB < 90 ) ) && ( ( bearingC > 270 ) || ( bearingC < 90 ) ) ) { if ( ( bearingA < 180 ) || ( bearingB < 180 ) || ( bearingC < 180 ) ) { //At least one bearing on East side of dial, make any West side bearings negative if ( bearingA > 180 ) { bearingA -= 360; } if ( bearingB > 180 ) { bearingB -= 360; } if ( bearingC > 180 ) { bearingC -= 360; } } } //Determine which is the smallest and largest value of the three bearings if ( bearingA > bearingB ) { double park = bearingA; bearingA = bearingB; bearingB = park; } if ( bearingA > bearingC ) { double park = bearingA; bearingA = bearingC; bearingC = park; } if ( bearingB > bearingC ) { double park = bearingB; bearingB = bearingC; bearingC = park; } //Adjust bearings so smallest is zero, and larger are relative to smallest double adjustedBearing2 = bearingB - bearingA; double adjustedBearing3 = bearingC - bearingA; if (adjustedBearing3 > 180) { //Bearings span more than 180 degree range. Not supported by this function. meanBearing = -999; } else { //All bearings between 0-180 degrees, so safe to average meanBearing = ( (adjustedBearing2 + adjustedBearing3) / 3) + bearingA; } } return UtilityFunctions.adjustBearingWithinDegreesRange(meanBearing, 0, 360); } /** * Test method for {@link footleg.cavesurvey.tools.UtilityFunctions#averageCompassBearings(double[] bearings)}. */ @Test public void testMeanBearings() { //Test average trend of a pair of bearings using vector averaging (atan2 method) is the same as //the numerical average of the two angles, for values in all possible ranges for (int diff = 0; diff < 180; diff += 4) { for (int start = 0; start < 360 - diff; start += 1) { double a = start; double b = a + diff + 0.07; double expectedMean = numericalMeanBearing2(a, b); testMean2( a, b, expectedMean); testMean2( b, a, expectedMean); } } for (int diff = 0; diff < 180; diff += 4) { for (int start = 1; start < 90; start += 1) { double a = start; double b = 360 - a - diff + 0.02; double expectedMean = numericalMeanBearing2(a, b); testMean2( a, b, expectedMean); testMean2( b, a, expectedMean); } } } /** * Test method for {@link footleg.cavesurvey.tools.UtilityFunctions#averageCompassBearings(double[] bearings)}. */ @Test public void testMeanCompassBearing() { double expectedMean = 0.2; double mean; mean = calcMeanBearing(0.1, 0.3); assertEquals("Mean bearing for 2 similar values just over zero.", expectedMean, mean, 0.001); expectedMean = 180.0; mean = calcMeanBearing(179, 181); assertEquals("Mean bearing for 2 similar values around 180 deg.", expectedMean, mean, 0.001); expectedMean = 180.0; mean = calcMeanBearing(90, 270); assertEquals("Mean bearing for 2 values exactly East and West", expectedMean, mean, 0.001); expectedMean = 180.0; mean = calcMeanBearing(270, 90); assertEquals("Mean bearing for 2 values exactly West and East", expectedMean, mean, 0.001); expectedMean = 0.0; mean = calcMeanBearing(271, 89); assertEquals("Mean bearing for 2 values just North of West and East", expectedMean, mean, 0.001); expectedMean = 320.0; mean = calcMeanBearing(20, 260); assertEquals("Mean bearing for 2 values over 180 degrees different", expectedMean, mean, 0.001); //Some pairs to survey legs and expected average trend of passage testMean2( 0.0, 0.0, 0.0); testMean2( 0.0, 24.0, 12.0); testMean2( 90.0, 0.0, 45.0); testMean2( 120.0, 0.0, 60.0); testMean2( 180.0, 180.0, 180.0); testMean2( 180.0, 359.0, 269.5); } @Test public void testMeanBearings3() { boolean rigourousTests = false; //Default increments for fast testing (test takes approx. 1 sec. with these values) double mainBearingIncrement = 7.3; //Bearing 1 tested from 0-360 deg in steps of this size double bearingSpreadIncrement = 0.3; //Maximum difference between all 3 bearings varies from 0-5 deg in steps of this size double bearingSpreadDiffIncrement = 0.07; //Difference between bearing 1 and 2 varies in steps of this size between min and max. if ( rigourousTests ) { //Use smaller increments for better test coverage of numeric space at cost of running time // (test takes approx. 1 minute with these values) mainBearingIncrement = 0.37; bearingSpreadIncrement = 0.13; bearingSpreadDiffIncrement = 0.07; } //Full revolution for bearing 1 for (double start = 0; start < 360; start += mainBearingIncrement) { double bearing1 = start; //Vary maximum bearing spread from 0 - 5 degrees for (double diff = 0; diff < 5; diff += bearingSpreadIncrement) { double bearing3 = start + diff; //Vary difference between 0 and max spread for (double mid = 0; mid < diff; mid += bearingSpreadDiffIncrement) { double bearing2 = start + mid; //Test all ways double a = bearing1; double b = UtilityFunctions.adjustBearingWithinDegreesRange(bearing2, 0, 360); double c = UtilityFunctions.adjustBearingWithinDegreesRange(bearing3, 0, 360); testMean3VerusNumericalAverage( a, b, c); testMean3VerusNumericalAverage( a, c, b); testMean3VerusNumericalAverage( b, a, c); testMean3VerusNumericalAverage( b, c, a); testMean3VerusNumericalAverage( c, a, b); testMean3VerusNumericalAverage( c, b, a); } } } } /** * Test method for {@link footleg.cavesurvey.tools.UtilityFunctions#averageCompassBearings(double[] bearings)}. */ @Test public void testAverageCompassBearings() { double expectedMean; double mean; double tolerance = 0.001; expectedMean = 0.2; mean = calcMeanBearing(0.1, 0.2, 0.3); assertEquals("Mean bearing for 3 similar values just over zero.", expectedMean, mean, tolerance); expectedMean = 180.0; mean = calcMeanBearing(179, 180, 181); assertEquals("Mean bearing for 3 similar values around 180 deg.", expectedMean, mean, tolerance); expectedMean = 359.5; mean = calcMeanBearing(359.9, 359.2, 359.4); assertEquals("Mean bearing for 3 similar values around 359.5 deg.", expectedMean, mean, tolerance); expectedMean = 0.09; mean = calcMeanBearing(359.94, 0.21, 0.12); assertEquals("Mean bearing for 3 values either side of North", expectedMean, mean, tolerance); expectedMean = 359.9966667; mean = calcMeanBearing(359.94, 0.03, 0.02); assertEquals("Mean bearing for 3 values either side of North", expectedMean, mean, tolerance); //These bearings spread over 10 degree range show difference between mean vector angle and //straight numerical averaging methods of calculating. So the correct answer is not 2.000 expectedMean = 2.002; mean = calcMeanBearing(356, 4, 6); assertEquals("Mean bearing for 3 values around 0", expectedMean, mean, tolerance); //These bearings spread over 10 degree range show difference between mean vector angle and //straight numerical averaging methods of calculating. So the correct answer is not 358.000 expectedMean = 358.002; mean = calcMeanBearing(2, 352, 0); assertEquals("Mean bearing for 3 values around 0", expectedMean, mean, tolerance); //These bearings spread over 10 degree range show difference between mean vector angle and //straight numerical averaging methods of calculating. So the correct answer is not 43.000 expectedMean = 43.002; mean = calcMeanBearing(45, 37, 47); assertEquals("Mean bearing for 3 values around 45", expectedMean, mean, tolerance); //These bearings spread over 10 degree range show difference between mean vector angle and //straight numerical averaging methods of calculating. So the correct answer is not 88.000 expectedMean = 88.002; mean = calcMeanBearing(90,92,82); assertEquals("Mean bearing for 3 values around 90", expectedMean, mean, tolerance); //These bearings spread over 10 degree range show difference between mean vector angle and //straight numerical averaging methods of calculating. So the correct answer is not 133.000 expectedMean = 133.002; mean = calcMeanBearing(135,137,127); assertEquals("Mean bearing for 3 values around 135", expectedMean, mean, tolerance); //These bearings spread over 10 degree range show difference between mean vector angle and //straight numerical averaging methods of calculating. So the correct answer is not 178.000 expectedMean = 178.002; mean = calcMeanBearing(180,182,172); assertEquals("Mean bearing for 3 values around 180", expectedMean, mean, tolerance); expectedMean = 223.002; mean = calcMeanBearing(225,227,217); assertEquals("Mean bearing for 3 values around 225", expectedMean, mean, tolerance); expectedMean = 268.002; mean = calcMeanBearing(270,272,262); assertEquals("Mean bearing for 3 values around 270", expectedMean, mean, tolerance); expectedMean = 313.002; mean = calcMeanBearing(315,317,307); assertEquals("Mean bearing for 3 values around 315", expectedMean, mean, tolerance); expectedMean = 357.002; mean = calcMeanBearing(359,1,351); assertEquals("Mean bearing for 3 values around 360", expectedMean, mean, tolerance); expectedMean = 4.610; mean = calcMeanBearing(0.0, 0.0, 13.86); assertEquals("Mean bearing for 3 values around 360", expectedMean, mean, tolerance); //These bearings spread over 22.5 degree range show difference between mean vector angle and //straight numerical averaging methods of calculating. So the correct answer is not 116.533 expectedMean = 116.548; testMean3(104.06, 118.87, 126.67, expectedMean); //These bearings spread over 160 degree range show difference between mean vector angle and //straight numerical averaging methods of calculating. So the correct answer is not 126.667 //as clearly with bearings pulling almost North or South the average trend would be in the //North-South direction, and pulling Eastwards nearly as much as a numerical average suggests. expectedMean = 162.122; testMean3(180, 180, 20, expectedMean); } /** * Test method for helper method in this test file. */ @Test public void testNumericalMeanBearing3() { double expectedMean = 0.2; double mean; mean = numericalMeanBearing3(0.1, 0.2, 0.3); assertEquals("Mean bearing for 3 similar values just over zero.", expectedMean, mean, 0.004); expectedMean = 180.0; mean = numericalMeanBearing3(179, 180, 181); assertEquals("Mean bearing for 3 similar values around 180 deg.", expectedMean, mean, 0.004); expectedMean = 359.5; mean = numericalMeanBearing3(359.9, 359.2, 359.4); assertEquals("Mean bearing for 3 similar values around 359.5 deg.", expectedMean, mean, 0.004); expectedMean = 0.09; mean = numericalMeanBearing3(359.94, 0.21, 0.12); assertEquals("Mean bearing for 3 values either side of North", expectedMean, mean, 0.004); expectedMean = 359.9966667; mean = numericalMeanBearing3(359.94, 0.03, 0.02); assertEquals("Mean bearing for 3 values either side of North", expectedMean, mean, 0.004); expectedMean = 2; mean = numericalMeanBearing3(356, 4, 6); assertEquals("Mean bearing for 3 values around 0", expectedMean, mean, 0.004); expectedMean = 358; mean = numericalMeanBearing3(2, 352, 0); assertEquals("Mean bearing for 3 values around 0", expectedMean, mean, 0.004); expectedMean = 43; mean = numericalMeanBearing3(45, 37, 47); assertEquals("Mean bearing for 3 values around 45", expectedMean, mean, 0.004); expectedMean = 88; mean = numericalMeanBearing3(90,92,82); assertEquals("Mean bearing for 3 values around 90", expectedMean, mean, 0.004); expectedMean = 133; mean = numericalMeanBearing3(135,137,127); assertEquals("Mean bearing for 3 values around 135", expectedMean, mean, 0.004); expectedMean = 178; mean = numericalMeanBearing3(180,182,172); assertEquals("Mean bearing for 3 values around 180", expectedMean, mean, 0.004); expectedMean = 223; mean = numericalMeanBearing3(225,227,217); assertEquals("Mean bearing for 3 values around 225", expectedMean, mean, 0.004); expectedMean = 268; mean = numericalMeanBearing3(270,272,262); assertEquals("Mean bearing for 3 values around 270", expectedMean, mean, 0.004); expectedMean = 313; mean = numericalMeanBearing3(315,317,307); assertEquals("Mean bearing for 3 values around 315", expectedMean, mean, 0.004); expectedMean = 357; mean = numericalMeanBearing3(359,1,351); assertEquals("Mean bearing for 3 values around 360", expectedMean, mean, 0.004); expectedMean = 116.533333; mean = numericalMeanBearing3(104.06, 118.87, 126.67); assertEquals("Mean bearing for 3 values around 360", expectedMean, mean, 0.004); } /** * Test method for {@link footleg.cavesurvey.tools.UtilityFunctions#bearingDifference(double angle1, double angle2)}. */ @Test public void testBearingDifference() { double expectedDiff = 10.0; double calcDiff; calcDiff = UtilityFunctions.bearingDifference( 5.0, 355.0 ); assertEquals("Difference between two bearings either side of North", expectedDiff, calcDiff, 0.001); expectedDiff = 180.0; calcDiff = UtilityFunctions.bearingDifference( 90.0, 270.0 ); assertEquals("Difference between two bearings of exactly East and West", expectedDiff, calcDiff, 0.001); expectedDiff = 4.8; calcDiff = UtilityFunctions.bearingDifference( 120.4, 125.2 ); assertEquals("Difference between two bearings of similar direction", expectedDiff, calcDiff, 0.001); } /** * Test method for {@link footleg.cavesurvey.tools.UtilityFunctions#stringToDate( String dateString, String dateFormat )}, * {@link footleg.cavesurvey.tools.UtilityFunctions#dateToString( Date date, String dateFormat )}. */ @Test public void testDateStringConversionPocketTopo() { String dateOutFormat = UtilityFunctions.POCKETTOPO_DATE_FORMAT; String dateInFormat = "dd-MM-yyyy"; String dateIn = "27-12-1984"; String dateExpectedOut = "1984/12/27"; doDateStringConversion(dateIn, dateInFormat, dateExpectedOut, dateOutFormat); dateIn = "01-02-1947"; dateExpectedOut = "1947/02/01"; doDateStringConversion(dateIn, dateInFormat, dateExpectedOut, dateOutFormat); dateIn = "31-12-2012"; dateExpectedOut = "2012/12/31"; doDateStringConversion(dateIn, dateInFormat, dateExpectedOut, dateOutFormat); dateInFormat = "MM-dd-yy"; dateIn = "03-05-07"; dateExpectedOut = "2007/03/05"; doDateStringConversion(dateIn, dateInFormat, dateExpectedOut, dateOutFormat); } /** * Test method for {@link footleg.cavesurvey.tools.UtilityFunctions#stringToDate( String dateString, String dateFormat )}, * {@link footleg.cavesurvey.tools.UtilityFunctions#dateToString( Date date, String dateFormat )}. */ @Test public void testDateStringConversionSurvex() { String dateOutFormat = UtilityFunctions.SURVEXDATE_FORMAT; String dateInFormat = "dd-MM-yyyy"; String dateIn = "27-12-1984"; String dateExpectedOut = "1984.12.27"; doDateStringConversion(dateIn, dateInFormat, dateExpectedOut, dateOutFormat); dateIn = "01-02-1947"; dateExpectedOut = "1947.02.01"; doDateStringConversion(dateIn, dateInFormat, dateExpectedOut, dateOutFormat); dateIn = "31-12-2012"; dateExpectedOut = "2012.12.31"; doDateStringConversion(dateIn, dateInFormat, dateExpectedOut, dateOutFormat); dateInFormat = "MM-dd-yy"; dateIn = "03-05-07"; dateExpectedOut = "2007.03.05"; doDateStringConversion(dateIn, dateInFormat, dateExpectedOut, dateOutFormat); } /** * Converts a string from one data format to another, with parse exception handling. * Tests that the string generated matches the specified expected string. */ private void doDateStringConversion( String dateIn, String dateInFormat, String dateExpectedOut, String dateOutFormat ) { try { Date testDate = UtilityFunctions.stringToDate( dateIn, dateInFormat); String dateOut = UtilityFunctions.dateToString( testDate, dateOutFormat ); assertEquals("Date converted from one string format to another", dateExpectedOut, dateOut); } catch (ParseException e) { fail("Date string '" + dateIn + "' raised parse exception using format '" + dateInFormat + "'."); } } /** * Test method for {@link footleg.cavesurvey.tools.UtilityFunctions#parseDataStringIntoDataItems( String dataIn )}. */ @Test public void testParseDataLineIntoDataItems() { String dataLine = ""; String[] dataItems = new String[6]; dataItems[0] = "Item1"; dataItems[1] = "2"; dataItems[2] = "Item3"; dataItems[3] = ""; dataItems[4] = "Item 5"; dataItems[5] = "Item6"; dataLine = dataItems[0] + " " + dataItems[1] + " " + dataItems[2] + "\t\"" + dataItems[3] + "\" \t\"" + dataItems[4] + "\"\t " + dataItems[5]; splitStringIntoItemsTest( dataLine, dataItems ); dataLine = dataItems[0] + " " + dataItems[1] + " " + dataItems[2] + " \t \"" + dataItems[3] + "\" \t \"" + dataItems[4] + "\" \t \t " + dataItems[5]; splitStringIntoItemsTest( dataLine, dataItems ); dataItems = new String[1]; dataItems[0] = "Item1"; dataLine = dataItems[0]; splitStringIntoItemsTest( dataLine, dataItems ); dataLine = "\"" + dataItems[0] + "\""; splitStringIntoItemsTest( dataLine, dataItems ); dataItems[0] = "A long sentance of misc text"; dataLine = "\"" + dataItems[0] + "\""; splitStringIntoItemsTest( dataLine, dataItems ); dataItems[0] = "Some\ttext\ncontaining\rtabs and new line chars "; dataLine = "\"" + dataItems[0] + "\""; splitStringIntoItemsTest( dataLine, dataItems ); dataItems = new String[2]; dataItems[0] = "Item\t1"; dataItems[1] = "Item 2"; dataLine = "\"" + dataItems[0] + "\"" + "\"" + dataItems[1] + "\""; splitStringIntoItemsTest( dataLine, dataItems ); } private void splitStringIntoItemsTest( String dataLine, String[] items ) { //Parse data string into items List parsedData = UtilityFunctions.parseDataStringIntoDataItems( dataLine ); //Check expected number of items were returned assertEquals( "Data string '" + dataLine + "' returns expected number of items.", items.length, parsedData.size() ); //Check each item returned matches expected data item for (int i = 0; i < items.length; i++) { assertEquals( "Item " + (i + 1) + " in '" + dataLine + "'.", items[i], parsedData.get(i) ); } } @Test public void testConvertToLinearSeriesOrderedT() { //Create series of test data SurveySeries masterSeries = new SurveySeries("test"); //Add legs to series masterSeries.addLeg( TestHelper.createTestLeg(1,2,1.0,110.0,0.0) ); masterSeries.addLeg( TestHelper.createTestLeg(2,3,1.0,100.0,0.0) ); masterSeries.addLeg( TestHelper.createTestLeg(3,4,1.0,190.0,0.0) ); masterSeries.addLeg( TestHelper.createTestLeg(4,5,1.0,180.0,0.0) ); masterSeries.addLeg( TestHelper.createTestLeg(3,6,1.0,270.0,0.0) ); masterSeries.addLeg( TestHelper.createTestLeg(6,7,1.0,290.0,0.0) ); //Convert to single series SurveySeries convertedSeries = UtilityFunctions.convertToLinearSeries(masterSeries); assertEquals("Expect 2 series from t-shaped single series.", 2, convertedSeries.innerSeriesCount() ); assertEquals("Expect links between all series.", 1, convertedSeries.getLinks().size() ); SeriesLink firstLink = convertedSeries.getLinks().get(0); assertEquals("Expect link from series 1.", convertedSeries.getInnerSeries(0).getSeriesName(), firstLink.getSeries2() ); assertEquals("Expect link to series 2.", convertedSeries.getInnerSeries(1).getSeriesName(), firstLink.getSeries1() ); } } CaveConverter_src/test/cavesurvey/tools/TestHelper.java0000644000000000000000000004472412242117242022436 0ustar rootroot/** * Copyright (C) 2009-2013 Paul Fretwell - aka 'Footleg' (drfootleg@gmail.com) * * This file is part of Cave Converter. * * Cave Converter is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation, either version 3 of the License, or * (at your option) any later version. * * Cave Converter is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with Cave Converter. If not, see . */ package cavesurvey.tools; import footleg.cavesurvey.data.model.SurveyLeg; import footleg.cavesurvey.data.model.SurveySeries; import footleg.cavesurvey.data.model.SurveyStation; /** * Test helper class containing methods to assist in building survey models for test scenarios. * * @author Footleg * @version 2013.11.17 (ISO 8601 YYYY.MM.DD) * @since 1.6 (The Java version used) */ public final class TestHelper { /** * Creates a survey leg from a set of measurements * * @param from From-station number * @param to To-station number * @param tape Length of leg * @param compass Bearing of leg * @param clino Inclination angle of leg * @return SurveyLeg object */ public static SurveyLeg createTestLeg(int from, int to, double tape, double compass, double clino) { SurveyLeg leg = new SurveyLeg(); leg.setFromStn(new SurveyStation(from)); leg.setToStn(new SurveyStation(to)); leg.setLength(tape); leg.setCompass(compass); leg.setClino(clino); return leg; } /** * Creates a survey splay leg from a set of measurements. The leg will have no to-station. * * @param from From-station number * @param tape Length of leg * @param compass Bearing of leg * @param clino Inclination angle of leg * @return SurveyLeg object */ public static SurveyLeg createSplayLeg(int from, double tape, double compass, double clino) { SurveyLeg leg = new SurveyLeg(); leg.setFromStn(new SurveyStation(from)); leg.setLength(tape); leg.setCompass(compass); leg.setClino(clino); leg.setSplay(true); return leg; } /** * Creates a short linear survey series of 3 legs with splays measured for LRUD passage * dimension at each station. All legs are measured in the forward direction for the survey. * (e.g. 1-2, 2-3, 3-4). All stations have all three splays for LRUD (only a L or R per station). * * @return SurveySeries object */ public static SurveySeries createSimpleForward3SurveyingSeriesWith3Splays() { SurveySeries series = new SurveySeries( "Test" ); //Add test legs to series with splays for LRUD int fromStn = 1; series.addLeg( TestHelper.createSplayLeg( fromStn, 0.74, 236.15, -6.85 ) ); series.addLeg( TestHelper.createSplayLeg( fromStn, 0.87, 46.77, -82.61 ) ); series.addLeg( TestHelper.createSplayLeg( fromStn, 1.68, 227.27, 67.16 ) ); series.addLeg( TestHelper.createTestLeg( fromStn, fromStn + 1, 5.05, 279.35, -25.23 ) ); fromStn++; series.addLeg( TestHelper.createSplayLeg( fromStn, 0.58, 34.79, 1.49 ) ); series.addLeg( TestHelper.createSplayLeg( fromStn, 1.16, 111.26, -85.03 ) ); series.addLeg( TestHelper.createSplayLeg( fromStn, 2.83, 16.27, 74.62 ) ); series.addLeg( TestHelper.createTestLeg( fromStn, fromStn + 1, 5.02, 336.36, -13.85 ) ); fromStn++; series.addLeg( TestHelper.createSplayLeg( fromStn, 0.41, 231.77, -3.06 ) ); series.addLeg( TestHelper.createSplayLeg( fromStn, 3.73, 254.43, 80.33 ) ); series.addLeg( TestHelper.createSplayLeg( fromStn, 0.54, 182.41, -84.02 ) ); series.addLeg( TestHelper.createTestLeg( fromStn, fromStn + 1, 3.19, 303.08, -33.11 ) ); fromStn++; series.addLeg( TestHelper.createSplayLeg( fromStn, 0.53, 23.07, -5.56 ) ); series.addLeg( TestHelper.createSplayLeg( fromStn, 4.46, 353.35, 80.60 ) ); series.addLeg( TestHelper.createSplayLeg( fromStn, 1.45, 224.40, -78.95 ) ); return series; } /** * Creates a short linear survey series of 5 legs with splays measured for LRUD passage * dimension at each station. All legs are measured in the forward direction for the survey. * (e.g. 1-2, 2-3, 3-4). All stations have all four splays for LRUD. * * @return SurveySeries object */ public static SurveySeries createSimpleForward5SurveyingSeriesWith4Splays() { SurveySeries series = new SurveySeries( "Test" ); //Add test legs to series with splays for LRUD int fromStn = 1; series.addLeg( TestHelper.createSplayLeg( fromStn, 0.07, 194.15, 2 ) ); series.addLeg( TestHelper.createSplayLeg( fromStn, 0.74, 16.15, -6 ) ); series.addLeg( TestHelper.createSplayLeg( fromStn, 1.28, 227.27, 87 ) ); series.addLeg( TestHelper.createSplayLeg( fromStn, 0.87, 46.77, -82 ) ); series.addLeg( TestHelper.createTestLeg( fromStn, fromStn + 1, 5.05, 279.15, -5.23 ) ); fromStn++; series.addLeg( TestHelper.createSplayLeg( fromStn, 0.15, 217.28, -3 ) ); series.addLeg( TestHelper.createSplayLeg( fromStn, 0.78, 34.79, 1 ) ); series.addLeg( TestHelper.createSplayLeg( fromStn, 0.83, 16.27, 84 ) ); series.addLeg( TestHelper.createSplayLeg( fromStn, 1.16, 111.26, -85 ) ); series.addLeg( TestHelper.createTestLeg( fromStn, fromStn + 1, 5.02, 336.26, -3.85 ) ); fromStn++; series.addLeg( TestHelper.createSplayLeg( fromStn, 1.21, 231.77, 2 ) ); series.addLeg( TestHelper.createSplayLeg( fromStn, 0.21, 45.17, -3 ) ); series.addLeg( TestHelper.createSplayLeg( fromStn, 1.23, 254.43, 80 ) ); series.addLeg( TestHelper.createSplayLeg( fromStn, 0.54, 182.41, -84 ) ); series.addLeg( TestHelper.createTestLeg( fromStn, fromStn + 1, 3.19, 303.38, -6 ) ); fromStn++; series.addLeg( TestHelper.createSplayLeg( fromStn, 0.53, 228.49, -2 ) ); series.addLeg( TestHelper.createSplayLeg( fromStn, 1.62, 60.07, -5 ) ); series.addLeg( TestHelper.createSplayLeg( fromStn, 1.46, 353.35, 80 ) ); series.addLeg( TestHelper.createSplayLeg( fromStn, 1.45, 224.40, -89 ) ); series.addLeg( TestHelper.createTestLeg( fromStn, fromStn + 1, 5.02, 26.42, -5.85 ) ); fromStn++; series.addLeg( TestHelper.createSplayLeg( fromStn, 1.21, 251.77, 2 ) ); series.addLeg( TestHelper.createSplayLeg( fromStn, 0.21, 45.17, -5 ) ); series.addLeg( TestHelper.createSplayLeg( fromStn, 1.25, 254.45, 80 ) ); series.addLeg( TestHelper.createSplayLeg( fromStn, 0.54, 182.41, -84 ) ); series.addLeg( TestHelper.createTestLeg( fromStn, fromStn + 1, 3.19, 297.57, -6 ) ); fromStn++; series.addLeg( TestHelper.createSplayLeg( fromStn, 0.53, 228.69, -2 ) ); series.addLeg( TestHelper.createSplayLeg( fromStn, 1.62, 60.07, -5 ) ); series.addLeg( TestHelper.createSplayLeg( fromStn, 1.66, 353.35, 80 ) ); series.addLeg( TestHelper.createSplayLeg( fromStn, 1.65, 226.60, -89 ) ); return series; } /** * Creates a short linear survey series of 3 legs with splays measured for LRUD passage * dimension at each station. All legs are measured in the backwards direction for the survey. * (e.g. 2-1, 3-2, 4-3) * * @return SurveySeries object */ public static SurveySeries createSimpleBackwardsSurveyingSeriesWithSplays() { SurveySeries series = new SurveySeries( "Test" ); //Add test legs to series with splays for LRUD int fromStn = 1; series.addLeg( TestHelper.createSplayLeg( fromStn, 0.74, 236.15, -6.85 ) ); series.addLeg( TestHelper.createSplayLeg( fromStn, 0.87, 46.77, -82.61 ) ); series.addLeg( TestHelper.createSplayLeg( fromStn, 1.68, 227.27, 67.16 ) ); series.addLeg( TestHelper.createTestLeg( fromStn + 1, fromStn, 5.05, 99.35, 25.23 ) ); fromStn++; series.addLeg( TestHelper.createSplayLeg( fromStn, 0.58, 34.79, 1.49 ) ); series.addLeg( TestHelper.createSplayLeg( fromStn, 1.16, 111.26, -85.03 ) ); series.addLeg( TestHelper.createSplayLeg( fromStn, 2.83, 16.27, 74.62 ) ); series.addLeg( TestHelper.createTestLeg( fromStn + 1, fromStn, 5.02, 156.36, 13.85 ) ); fromStn++; series.addLeg( TestHelper.createSplayLeg( fromStn, 0.41, 231.77, -3.06 ) ); series.addLeg( TestHelper.createSplayLeg( fromStn, 3.73, 254.43, 80.33 ) ); series.addLeg( TestHelper.createSplayLeg( fromStn, 0.54, 182.41, -84.02 ) ); series.addLeg( TestHelper.createTestLeg( fromStn + 1, fromStn, 3.19, 123.08, 33.11 ) ); fromStn++; series.addLeg( TestHelper.createSplayLeg( fromStn, 0.53, 23.07, -5.56 ) ); series.addLeg( TestHelper.createSplayLeg( fromStn, 4.46, 353.35, 80.60 ) ); series.addLeg( TestHelper.createSplayLeg( fromStn, 1.45, 224.40, -78.95 ) ); return series; } /** * Creates a short t-shaped survey series of 6 legs with splays measured for LRUD passage * dimension at each station. Branch lengths 2,2,2 * All legs are measured in the forward direction for the survey (e.g. 1-2, 2-3, 3-4, etc.) * * @return SurveySeries object */ public static SurveySeries createBranched222ForwardSurveyingSeriesWithSplays() { SurveySeries series = new SurveySeries( "Test" ); //Add test legs to series with splays for LRUD int fromStn = 1; series.addLeg( TestHelper.createSplayLeg( fromStn, 0.5, 330, 3 ) ); series.addLeg( TestHelper.createSplayLeg( fromStn, 1.5, 150, -6 ) ); series.addLeg( TestHelper.createSplayLeg( fromStn, 2, 60, 88 ) ); series.addLeg( TestHelper.createSplayLeg( fromStn, 0.4, 60, -89 ) ); series.addLeg( TestHelper.createTestLeg( fromStn, fromStn + 1, 1.43, 61.61, -13.25 ) ); fromStn++; series.addLeg( TestHelper.createSplayLeg( fromStn, 0.58, 327.33, -0.57 ) ); series.addLeg( TestHelper.createSplayLeg( fromStn, 0.94, 171.13, -6.41 ) ); series.addLeg( TestHelper.createSplayLeg( fromStn, 0.50, 258.56, -34.18 ) ); series.addLeg( TestHelper.createTestLeg( fromStn, fromStn + 1, 3.89, 73.29, -51.63 ) ); fromStn++; series.addLeg( TestHelper.createSplayLeg( fromStn, 0.91, 252.72, -4.04 ) ); series.addLeg( TestHelper.createSplayLeg( fromStn, 0.80, 250.31, -35.24 ) ); series.addLeg( TestHelper.createSplayLeg( fromStn, 2.44, 239.99, 47.81 ) ); series.addLeg( TestHelper.createTestLeg( fromStn, fromStn + 1, 4.50, 170.72, 19.68 ) ); fromStn++; series.addLeg( TestHelper.createSplayLeg( fromStn, 0.46, 71.39, -4.30 ) ); series.addLeg( TestHelper.createSplayLeg( fromStn, 1.54, 358.12, 82.08 ) ); series.addLeg( TestHelper.createSplayLeg( fromStn, 0.94, 170.44, -79.46 ) ); series.addLeg( TestHelper.createSplayLeg( fromStn, 0.45, 220.38, -6.59 ) ); series.addLeg( TestHelper.createTestLeg( fromStn, fromStn + 1, 1.63, 131.27, 20.13 ) ); fromStn++; series.addLeg( TestHelper.createSplayLeg( fromStn, 0.37, 242.14, -5.73 ) ); series.addLeg( TestHelper.createSplayLeg( fromStn, 0.36, 39.38, -82.79 ) ); series.addLeg( TestHelper.createSplayLeg( fromStn, 1.17, 258.11, 84.02 ) ); series.addLeg( TestHelper.createSplayLeg( fromStn, 0.5, 41, 2 ) ); //Branch from 2 stations back series.addLeg( TestHelper.createTestLeg( fromStn - 2, fromStn + 1, 5.02, 336.36, -13.85 ) ); fromStn++; series.addLeg( TestHelper.createSplayLeg( fromStn, 0.41, 231.77, -3.06 ) ); series.addLeg( TestHelper.createSplayLeg( fromStn, 3.73, 254.43, 80.33 ) ); series.addLeg( TestHelper.createSplayLeg( fromStn, 0.54, 182.41, -84.02 ) ); series.addLeg( TestHelper.createTestLeg( fromStn, fromStn + 1, 3.19, 303.08, -33.11 ) ); fromStn++; series.addLeg( TestHelper.createSplayLeg( fromStn, 0.53, 23.07, -5.56 ) ); series.addLeg( TestHelper.createSplayLeg( fromStn, 4.46, 353.35, 80.60 ) ); series.addLeg( TestHelper.createSplayLeg( fromStn, 1.45, 224.40, -78.95 ) ); return series; } /** * Creates a short t-shaped survey series of 6 legs with splays measured for LRUD passage * dimension at each station. Branch lengths 1,2,2 * All legs are measured in the forward direction for the survey (e.g. 1-2, 2-3, 3-4, etc.) * * @return SurveySeries object */ public static SurveySeries createBranched122ForwardSurveyingSeriesWithSplays() { SurveySeries series = new SurveySeries( "Test" ); //Add test legs to series with splays for LRUD int fromStn = 1; series.addLeg( TestHelper.createSplayLeg( fromStn, 0.58, 327.33, -0.57 ) ); series.addLeg( TestHelper.createSplayLeg( fromStn, 0.94, 171.13, -6.41 ) ); series.addLeg( TestHelper.createSplayLeg( fromStn, 0.50, 258.56, -34.18 ) ); series.addLeg( TestHelper.createTestLeg( fromStn, fromStn + 1, 3.89, 73.29, -51.63 ) ); fromStn++; series.addLeg( TestHelper.createSplayLeg( fromStn, 0.91, 252.72, -4.04 ) ); series.addLeg( TestHelper.createSplayLeg( fromStn, 0.80, 250.31, -35.24 ) ); series.addLeg( TestHelper.createSplayLeg( fromStn, 2.44, 239.99, 47.81 ) ); series.addLeg( TestHelper.createTestLeg( fromStn, fromStn + 1, 4.50, 170.72, 19.68 ) ); fromStn++; series.addLeg( TestHelper.createSplayLeg( fromStn, 0.46, 71.39, -4.30 ) ); series.addLeg( TestHelper.createSplayLeg( fromStn, 1.54, 358.12, 82.08 ) ); series.addLeg( TestHelper.createSplayLeg( fromStn, 0.94, 170.44, -79.46 ) ); series.addLeg( TestHelper.createSplayLeg( fromStn, 0.45, 220.38, -6.59 ) ); series.addLeg( TestHelper.createTestLeg( fromStn, fromStn + 1, 1.63, 131.27, 20.13 ) ); fromStn++; series.addLeg( TestHelper.createSplayLeg( fromStn, 0.37, 242.14, -5.73 ) ); series.addLeg( TestHelper.createSplayLeg( fromStn, 0.36, 39.38, -82.79 ) ); series.addLeg( TestHelper.createSplayLeg( fromStn, 1.17, 258.11, 84.02 ) ); series.addLeg( TestHelper.createSplayLeg( fromStn, 0.5, 41, 2 ) ); //Branch from 2 stations back series.addLeg( TestHelper.createTestLeg( fromStn - 2, fromStn + 1, 5.02, 336.36, -13.85 ) ); fromStn++; series.addLeg( TestHelper.createSplayLeg( fromStn, 0.41, 231.77, -3.06 ) ); series.addLeg( TestHelper.createSplayLeg( fromStn, 3.73, 254.43, 80.33 ) ); series.addLeg( TestHelper.createSplayLeg( fromStn, 0.54, 182.41, -84.02 ) ); series.addLeg( TestHelper.createTestLeg( fromStn, fromStn + 1, 3.19, 303.08, -33.11 ) ); fromStn++; series.addLeg( TestHelper.createSplayLeg( fromStn, 0.53, 23.07, -5.56 ) ); series.addLeg( TestHelper.createSplayLeg( fromStn, 4.46, 353.35, 80.60 ) ); series.addLeg( TestHelper.createSplayLeg( fromStn, 1.45, 224.40, -78.95 ) ); return series; } /** * Creates a short linear survey series of 5 legs with splays measured for LRUD passage * dimension at each station. Alternate legs are measured forwards then backwards as * instrument reader leapfrogs station target setter (e.g. 1-2, 3-2, 3-4, 4-3 etc.) * * @return SurveySeries object */ public static SurveySeries createLinearLeapfrogSurveyingSeriesWithSplays() { SurveySeries series = new SurveySeries( "Test" ); //Add test legs to series with splays for LRUD int fromStn = 1; series.addLeg( TestHelper.createSplayLeg( fromStn, 0.07, 194.15, 2 ) ); series.addLeg( TestHelper.createSplayLeg( fromStn, 0.74, 16.15, -6 ) ); series.addLeg( TestHelper.createSplayLeg( fromStn, 1.28, 227.27, 87 ) ); series.addLeg( TestHelper.createSplayLeg( fromStn, 0.87, 46.77, -82 ) ); series.addLeg( TestHelper.createTestLeg( fromStn, fromStn + 1, 5.05, 279.15, -5.23 ) ); fromStn++; series.addLeg( TestHelper.createSplayLeg( fromStn, 0.15, 217.28, -3 ) ); series.addLeg( TestHelper.createSplayLeg( fromStn, 0.78, 34.79, 1 ) ); series.addLeg( TestHelper.createSplayLeg( fromStn, 0.83, 16.27, 84 ) ); series.addLeg( TestHelper.createSplayLeg( fromStn, 1.16, 111.26, -85 ) ); series.addLeg( TestHelper.createTestLeg( fromStn + 1, fromStn, 5.02, 156.26, 3.85 ) ); fromStn++; series.addLeg( TestHelper.createSplayLeg( fromStn, 1.21, 231.77, 2 ) ); series.addLeg( TestHelper.createSplayLeg( fromStn, 0.21, 45.17, -3 ) ); series.addLeg( TestHelper.createSplayLeg( fromStn, 1.23, 254.43, 80 ) ); series.addLeg( TestHelper.createSplayLeg( fromStn, 0.54, 182.41, -84 ) ); series.addLeg( TestHelper.createTestLeg( fromStn, fromStn + 1, 3.19, 303.38, -6 ) ); fromStn++; series.addLeg( TestHelper.createSplayLeg( fromStn, 0.53, 228.49, -2 ) ); series.addLeg( TestHelper.createSplayLeg( fromStn, 1.62, 60.07, -5 ) ); series.addLeg( TestHelper.createSplayLeg( fromStn, 1.46, 353.35, 80 ) ); series.addLeg( TestHelper.createSplayLeg( fromStn, 1.45, 224.40, -89 ) ); series.addLeg( TestHelper.createTestLeg( fromStn + 1, fromStn, 5.02, 206.42, 5.85 ) ); fromStn++; series.addLeg( TestHelper.createSplayLeg( fromStn, 1.21, 251.77, 2 ) ); series.addLeg( TestHelper.createSplayLeg( fromStn, 0.21, 45.17, -5 ) ); series.addLeg( TestHelper.createSplayLeg( fromStn, 1.25, 254.45, 80 ) ); series.addLeg( TestHelper.createSplayLeg( fromStn, 0.54, 182.41, -84 ) ); series.addLeg( TestHelper.createTestLeg( fromStn, fromStn + 1, 3.19, 297.57, -6 ) ); fromStn++; series.addLeg( TestHelper.createSplayLeg( fromStn, 0.53, 228.69, -2 ) ); series.addLeg( TestHelper.createSplayLeg( fromStn, 1.62, 60.07, -5 ) ); series.addLeg( TestHelper.createSplayLeg( fromStn, 1.66, 353.35, 80 ) ); series.addLeg( TestHelper.createSplayLeg( fromStn, 1.65, 226.60, -89 ) ); return series; } /* int fromStn = 1; series.addLeg( TestHelper.createSplayLeg( fromStn, , , ) ); series.addLeg( TestHelper.createSplayLeg( fromStn, , , ) ); series.addLeg( TestHelper.createSplayLeg( fromStn, , , ) ); series.addLeg( TestHelper.createTestLeg( fromStn, fromStn + 1, , , ) ); fromStn++; *FLAGS SPLAY 1 1-L 0.07 194.15 2 1 1-R 0.74 16.15 -6 1 1-U 1.28 227.27 87 1 1-D 0.87 46.77 -82 *FLAGS NOT SPLAY 1 2 5.05 279.35 -5.23 *FLAGS SPLAY 2 2-L 0.15 217.28 -3 2 2-R 0.78 34.79 1 2 2-U 0.83 16.27 84 2 2-D 1.16 111.26 -85 *FLAGS NOT SPLAY 2 3 5.02 336.36 -3.85 *FLAGS SPLAY 3 3-L 1.21 231.77 2 3 3-R 0.21 45.17 -3 3 3-U 1.23 254.43 80 3 3-D 0.54 182.41 -84 *FLAGS NOT SPLAY 3 4 3.19 303.08 -6 *FLAGS SPLAY 4 4-L 0.53 228.49 -2 4 4-R 1.62 60.07 -5 4 4-U 1.46 353.35 80 4 4-D 1.45 224.40 -89 *FLAGS NOT SPLAY 4 5 5.02 26.56 -5.85 *FLAGS SPLAY 5 5-L 1.21 251.77 2 5 5-R 0.21 45.17 -5 5 5-U 1.25 254.45 80 5 5-D 0.54 182.41 -84 *FLAGS NOT SPLAY 5 6 3.19 303.08 -6 *FLAGS SPLAY 6 6-L 0.53 228.69 -2 6 6-R 1.62 60.07 -5 6 6-U 1.66 353.35 80 6 6-D 1.65 226.60 -89 *FLAGS NOT SPLAY */ } CaveConverter_src/test/cavesurvey/regression/0000755000000000000000000000000012215312674020527 5ustar rootrootCaveConverter_src/test/cavesurvey/regression/DiffFiles.java0000644000000000000000000000502512204414320023214 0ustar rootroot/** * Copyright (C) 2009-2013 Paul Fretwell - aka 'Footleg' (drfootleg@gmail.com) * * This file is part of Cave Converter. * * Cave Converter is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation, either version 3 of the License, or * (at your option) any later version. * * Cave Converter is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with Cave Converter. If not, see . */ package cavesurvey.regression; import java.io.File; import java.util.List; import footleg.cavesurvey.tools.UtilityFunctions; /** * File differencing class which checks the contents of two files for any difference. * Used for regressions tests. * * @author Footleg * @version 2013.08.19 (ISO 8601 YYYY.MM.DD) * @since 1.6 (The Java version used) */ public final class DiffFiles { final static String FILES_IDENTICAL = "IDENTICAL"; public static String diffFiles(String referenceFile, String testFile) { String result = FILES_IDENTICAL; List original = UtilityFunctions.readTextFile( new File( referenceFile ) ); List revised = UtilityFunctions.readTextFile( new File( testFile ) ); int shortestFileLength = original.size(); if (revised.size() < shortestFileLength ) { shortestFileLength = revised.size(); } //Check for differences in file lines for (int i = 0; i < shortestFileLength; i++) { String ori = original.get(i); String rev = revised.get(i); if ( ori.equals( rev ) == false ) { //Found a difference, so report lines and exit loop result = "Files differ at line " + (i + 1) + ". Reference line: '" + original.get(i) + "'; Generated line: '" + revised.get(i) + "'."; break; } } //Check for different file lengths if no line differences found if ( ( original.size() != revised.size() ) && ( result.equals(FILES_IDENTICAL) ) ) { result = "Files are different lengths. " + "Reference file length: " + original.size() + "; Generated file length: " + revised.size() + "."; } return result; } } CaveConverter_src/test/cavesurvey/regression/PocketTopoToToporobotTest.java0000644000000000000000000000774512204412776026553 0ustar rootroot/** * Copyright (C) 2009-2013 Paul Fretwell - aka 'Footleg' (drfootleg@gmail.com) * * This file is part of Cave Converter. * * Cave Converter is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation, either version 3 of the License, or * (at your option) any later version. * * Cave Converter is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with Cave Converter. If not, see . */ package cavesurvey.regression; import static org.junit.Assert.*; import java.text.ParseException; import org.junit.Test; import footleg.cavesurvey.cmdline.CaveConverter.CmdlineOpt; /** * Regression test class which runs data file conversions and compares the output with reference * files. Tests pass if the output file is identical to the reference file. A file name prefix * is given as the argument for each test conversion. The test will look for an input file with * this prefix and the suffix '_in.txt' and compare the output with a reference file with * this prefix and the suffix '_ref.text'. * * @author Footleg * @version 2013.08.19 (ISO 8601 YYYY.MM.DD) * @since 1.6 (The Java version used) */ public class PocketTopoToToporobotTest { @Test public void testPocketTopoToToporobotGourAven() throws ParseException { //Convert PocketTopo text export file to Toporobot format data String fileCompare = RunFileConverter.convertPocketTopoToToporobot( "GourAven", CmdlineOpt.D, CmdlineOpt.T ); assertEquals("Comparing GourAven toporobot file from PocketTopo with reference.", DiffFiles.FILES_IDENTICAL, fileCompare); } @Test public void testPocketTopoToToporobotHSC() throws ParseException { //Convert PocketTopo text export file to Toporobot format data String fileCompare = RunFileConverter.convertPocketTopoToToporobot( "HSC", CmdlineOpt.D, CmdlineOpt.T ); assertEquals("Comparing HSC toporobot file from PocketTopo with reference.", DiffFiles.FILES_IDENTICAL, fileCompare); } @Test public void testPocketTopoToToporobotStomps() throws ParseException { //Convert PocketTopo text export file to Toporobot format data String fileCompare = RunFileConverter.convertPocketTopoToToporobot( "Stomps", CmdlineOpt.D, CmdlineOpt.T ); assertEquals("Comparing Stomps toporobot file from PocketTopo with reference.", DiffFiles.FILES_IDENTICAL, fileCompare); } @Test public void testPocketTopoToToporobotUzuGour() throws ParseException { //Convert PocketTopo text export file to Toporobot format data String fileCompare = RunFileConverter.convertPocketTopoToToporobot( "Uzu-Gour", CmdlineOpt.D, CmdlineOpt.T ); assertEquals("Comparing Uzu-Gour toporobot file from PocketTopo with reference.", DiffFiles.FILES_IDENTICAL, fileCompare); } @Test public void testPocketTopoToToporobotSloppy2ZigZags() throws ParseException { //Convert PocketTopo text export file to Toporobot format data String fileCompare = RunFileConverter.convertPocketTopoToToporobot( "Sloppy2ZigZags", CmdlineOpt.D, CmdlineOpt.T ); assertEquals("Comparing Sloppy2ZigZags toporobot file from PocketTopo with reference.", DiffFiles.FILES_IDENTICAL, fileCompare); } @Test public void testPocketTopoToToporobotTripComment() throws ParseException { //Convert PocketTopo text export file to Toporobot format data String fileCompare = RunFileConverter.convertPocketTopoToToporobot( "TripComment", CmdlineOpt.D, CmdlineOpt.T ); assertEquals("Comparing TripComment toporobot file from PocketTopo with reference.", DiffFiles.FILES_IDENTICAL, fileCompare); } } CaveConverter_src/test/cavesurvey/regression/SurvexToSurvexTest.java0000644000000000000000000000654012227504520025247 0ustar rootroot/** * Copyright (C) 2009-2013 Paul Fretwell - aka 'Footleg' (drfootleg@gmail.com) * * This file is part of Cave Converter. * * Cave Converter is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation, either version 3 of the License, or * (at your option) any later version. * * Cave Converter is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with Cave Converter. If not, see . */ package cavesurvey.regression; import static org.junit.Assert.*; import java.text.ParseException; import org.junit.Test; import footleg.cavesurvey.cmdline.CaveConverter.CmdlineOpt; /** * Regression test class which runs data file conversions and compares the output with reference * files. Tests pass if the output file is identical to the reference file. A file name prefix * is given as the argument for each test conversion. The test will look for an input file with * this prefix and the suffix '_in.svx' and compare the output with a reference file with * this prefix and the suffix '_ref.svx'. * * @author Footleg * @version 2013.08.19 (ISO 8601 YYYY.MM.DD) * @since 1.6 (The Java version used) */ public class SurvexToSurvexTest { @Test public void testNightMare() throws ParseException { //Read and Write Survex format data String fileCompare = RunFileConverter.convertSurvexToSurvex( "NightMare", CmdlineOpt.D, CmdlineOpt.T ); assertEquals("Comparing NightMare Survex file from Survex with reference.", DiffFiles.FILES_IDENTICAL, fileCompare); } @Test public void testCalibrations() throws ParseException { //Read and Write Survex format data String fileCompare = RunFileConverter.convertSurvexToSurvex( "calibrations", CmdlineOpt.D, CmdlineOpt.T ); assertEquals("Comparing calibrations Survex file from Survex with reference.", DiffFiles.FILES_IDENTICAL, fileCompare); } @Test public void testFlags() throws ParseException { //Read and Write Survex format data String fileCompare = RunFileConverter.convertSurvexToSurvex( "flags", CmdlineOpt.D, CmdlineOpt.F ); assertEquals("Comparing flags Survex file from Survex with reference.", DiffFiles.FILES_IDENTICAL, fileCompare); } @Test public void testSwilEntNosplays() throws ParseException { //Read and Write Survex format data, removing splays String fileCompare = RunFileConverter.convertUsingCmdLine("SwilEnt", 's', 's', "nosplays lrud"); assertEquals("Comparing SwilEnt Survex file from Survex with reference, removing splays.", DiffFiles.FILES_IDENTICAL, fileCompare); } @Test public void testSwilEntSplaysLRUD() throws ParseException { //Read and Write Survex format data, removing splays String fileCompare = RunFileConverter.convertUsingCmdLine("SwilEnt", 's', 's', "splays lrud"); assertEquals("Comparing SwilEnt Survex file from Survex with reference, removing splays.", DiffFiles.FILES_IDENTICAL, fileCompare); } } CaveConverter_src/test/cavesurvey/regression/SurvexToToporobotTest.java0000644000000000000000000000547012227570746025760 0ustar rootroot/** * Copyright (C) 2009-2013 Paul Fretwell - aka 'Footleg' (drfootleg@gmail.com) * * This file is part of Cave Converter. * * Cave Converter is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation, either version 3 of the License, or * (at your option) any later version. * * Cave Converter is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with Cave Converter. If not, see . */ package cavesurvey.regression; import static org.junit.Assert.*; import java.text.ParseException; import org.junit.Test; import footleg.cavesurvey.cmdline.CaveConverter.CmdlineOpt; /** * Regression test class which runs data file conversions and compares the output with reference * files. Tests pass if the output file is identical to the reference file. A file name prefix * is given as the argument for each test conversion. The test will look for an input file with * this prefix and the suffix '_in.svx' and compare the output with a reference file with * this prefix and the suffix '_ref.text'. * * @author Footleg * @version 2013.10.16 (ISO 8601 YYYY.MM.DD) * @since 1.6 (The Java version used) */ public class SurvexToToporobotTest { @Test public void testCrossoverCmdline() throws ParseException { //Convert Survex data file to Toporobot text format using default settings and test result String fileCompare = RunFileConverter.convertUsingCmdLine("Crossover", 's', 't', ""); assertEquals("Comparing Crossover Toporobot file from Survex with reference.", DiffFiles.FILES_IDENTICAL, fileCompare); } @Test public void testFlagsSplaysCmdline() throws ParseException { //Convert Survex data file to Toporobot text format retaining splays and test result String fileCompare = RunFileConverter.convertUsingCmdLine("flags", 's', 't', "splays"); assertEquals("Comparing Flags Toporobot file from Survex with reference.", DiffFiles.FILES_IDENTICAL, fileCompare); } @Test public void testSwilEnt() throws ParseException { //Convert Survex data file to Toporobot text format removing splays but generating LRUD data from them and test result String fileCompare = RunFileConverter.convertSurvexToTopoRobot( "SwilEnt", CmdlineOpt.F, CmdlineOpt.T ); assertEquals("Comparing SwilEnt Toporobot file from Survex with reference.", DiffFiles.FILES_IDENTICAL, fileCompare); } } CaveConverter_src/test/cavesurvey/regression/DxfToSurvexTest.java0000644000000000000000000000466012204412776024503 0ustar rootroot/** * Copyright (C) 2009-2013 Paul Fretwell - aka 'Footleg' (drfootleg@gmail.com) * * This file is part of Cave Converter. * * Cave Converter is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation, either version 3 of the License, or * (at your option) any later version. * * Cave Converter is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with Cave Converter. If not, see . */ package cavesurvey.regression; import static org.junit.Assert.*; import java.text.ParseException; import org.junit.Test; import footleg.cavesurvey.cmdline.CaveConverter.CmdlineOpt; /** * Regression test class which runs data file conversions and compares the output with reference * files. Tests pass if the output file is identical to the reference file. A file name prefix * is given as the argument for each test conversion. The test will look for an input file with * this prefix and the suffix '_in.dxf' and compare the output with a reference file with * this prefix and the suffix '_ref.dxf'. * * @author Footleg * @version 2013.08.19 (ISO 8601 YYYY.MM.DD) * @since 1.6 (The Java version used) */ public class DxfToSurvexTest { @Test public void testDxfToSurvexMares3d() throws ParseException { //Convert DXF file generated from a Survex .3d file to Survex format data String fileCompare = RunFileConverter.convertDxfToSurvex( "2649_Mares_from3d", CmdlineOpt.D, CmdlineOpt.F ); assertEquals("Comparing 2649_Mares_from3d survex file from DXF with reference.", DiffFiles.FILES_IDENTICAL, fileCompare); } @Test public void testDxfToSurvexMaresFromAven() throws ParseException { //Convert DXF file saved from the Aven viewer to Survex format data String fileCompare = RunFileConverter.convertDxfToSurvex( "2649_Mares_fromaven", CmdlineOpt.D, CmdlineOpt.F ); assertEquals("Comparing 2649_Mares_fromaven survex file from DXF with reference.", DiffFiles.FILES_IDENTICAL, fileCompare); } } CaveConverter_src/test/cavesurvey/regression/DxfToTopoRobotTest.java0000644000000000000000000000471212204412776025134 0ustar rootroot/** * Copyright (C) 2009-2013 Paul Fretwell - aka 'Footleg' (drfootleg@gmail.com) * * This file is part of Cave Converter. * * Cave Converter is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation, either version 3 of the License, or * (at your option) any later version. * * Cave Converter is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with Cave Converter. If not, see . */ package cavesurvey.regression; import static org.junit.Assert.*; import java.text.ParseException; import org.junit.Test; import footleg.cavesurvey.cmdline.CaveConverter.CmdlineOpt; /** * Regression test class which runs data file conversions and compares the output with reference * files. Tests pass if the output file is identical to the reference file. A file name prefix * is given as the argument for each test conversion. The test will look for an input file with * this prefix and the suffix '_in.dxf' and compare the output with a reference file with * this prefix and the suffix '_ref.text'. * * @author Footleg * @version 2013.08.19 (ISO 8601 YYYY.MM.DD) * @since 1.6 (The Java version used) */ public class DxfToTopoRobotTest { @Test public void testDxfToTopoRobotMares3d() throws ParseException { //Convert DXF file generated from a Survex .3d file to Toporobot format data String fileCompare = RunFileConverter.convertDxfToTopoRobot( "2649_Mares_from3d", CmdlineOpt.D, CmdlineOpt.F ); assertEquals("Comparing 2649_Mares_from3d TopoRobot file from DXF with reference.", DiffFiles.FILES_IDENTICAL, fileCompare); } @Test public void testDxfToTopoRobotMaresFromAven() throws ParseException { //Convert DXF file saved from the Aven viewer to Toporobot format data String fileCompare = RunFileConverter.convertDxfToTopoRobot( "2649_Mares_fromaven", CmdlineOpt.D, CmdlineOpt.F ); assertEquals("Comparing 2649_Mares_fromaven TopoRobot file from DXF with reference.", DiffFiles.FILES_IDENTICAL, fileCompare); } } CaveConverter_src/test/cavesurvey/regression/RunFileConverter.java0000644000000000000000000002032312227504520024622 0ustar rootroot/** * Copyright (C) 2009-2013 Paul Fretwell - aka 'Footleg' (drfootleg@gmail.com) * * This file is part of Cave Converter. * * Cave Converter is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation, either version 3 of the License, or * (at your option) any later version. * * Cave Converter is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with Cave Converter. If not, see . */ package cavesurvey.regression; import java.text.ParseException; import footleg.cavesurvey.cmdline.CaveConverter; import footleg.cavesurvey.cmdline.CaveConverter.CmdlineOpt; import footleg.cavesurvey.tools.UtilityFunctions; /** * Regression helper class which runs data file conversions and compares the output with reference * files. Tests pass if the output file is identical to the reference file. A file name prefix * is given as the argument for each test conversion. The test will look for an input file with * this prefix and the suffix '_in._extn_' and compare the output with a reference file with * this prefix and the suffix '_ref._extn_' (where _extn_ is the appropriate file extension for * the file format. * * @author Footleg * @version 2013.08.19 (ISO 8601 YYYY.MM.DD) * @since 1.6 (The Java version used) */ public final class RunFileConverter { final static String refFilesLocation = "./test/data/regression/"; final static String genFilesLocation = "./build/test/data/"; public static String convertDxfToSurvex( String filePrefix, CmdlineOpt splaysOpt, CmdlineOpt genLRUDOpt ) throws ParseException { //Compare resulting file with expected file String fileCompare = convertFile(filePrefix, UtilityFunctions.dxfFormat, UtilityFunctions.survexFormat, splaysOpt, genLRUDOpt); return fileCompare; } public static String convertSurvexToSurvex( String filePrefix, CmdlineOpt splaysOpt, CmdlineOpt genLRUDOpt ) throws ParseException { //Compare resulting file with expected file String fileCompare = convertFile(filePrefix, UtilityFunctions.survexFormat, UtilityFunctions.survexFormat, splaysOpt, genLRUDOpt); return fileCompare; } public static String convertSurvexToTopoRobot( String filePrefix, CmdlineOpt splaysOpt, CmdlineOpt genLRUDOpt ) throws ParseException { //Compare resulting file with expected file String fileCompare = convertFile(filePrefix, UtilityFunctions.survexFormat, UtilityFunctions.toporobotFormat, splaysOpt, genLRUDOpt); return fileCompare; } public static String convertDxfToTopoRobot( String filePrefix, CmdlineOpt splaysOpt, CmdlineOpt genLRUDOpt ) throws ParseException { //Compare resulting file with expected file String fileCompare = convertFile(filePrefix, UtilityFunctions.dxfFormat, UtilityFunctions.toporobotFormat, splaysOpt, genLRUDOpt); return fileCompare; } public static String convertPocketTopoToSurvex( String filePrefix, CmdlineOpt splaysOpt, CmdlineOpt genLRUDOpt ) throws ParseException { //Compare resulting file with expected file String fileCompare = convertFile(filePrefix, UtilityFunctions.pocketTopoFormat, UtilityFunctions.survexFormat, splaysOpt, genLRUDOpt); return fileCompare; } public static String convertPocketTopoToToporobot( String filePrefix, CmdlineOpt splaysOpt, CmdlineOpt genLRUDOpt ) throws ParseException { //Compare resulting file with expected file String fileCompare = convertFile(filePrefix, UtilityFunctions.pocketTopoFormat, UtilityFunctions.toporobotFormat, splaysOpt, genLRUDOpt); return fileCompare; } private static String generateFileSuffix( char format ) { String fileSuffix = ""; if( format == UtilityFunctions.pocketTopoFormat ) { fileSuffix = ".txt"; } else if( format == UtilityFunctions.dxfFormat ) { fileSuffix = ".dxf"; } else if( format == UtilityFunctions.survexFormat ) { fileSuffix = ".svx"; } else if( format == UtilityFunctions.toporobotFormat ) { fileSuffix = ".text"; } else { fileSuffix = ".txt"; } return fileSuffix; } private static String generateInputFilename( String filePrefix, char fromFormat ) { return refFilesLocation + filePrefix + "_in" + generateFileSuffix( fromFormat ); } private static String generateFilename( String location, String filePrefix, char fromFormat, char toFormat, CmdlineOpt splaysOpt, String suffix ) { String splayOptString = ""; if ( splaysOpt == CmdlineOpt.T ) { splayOptString = "_spl"; } else if ( splaysOpt == CmdlineOpt.F ) { splayOptString = "_nsp"; } return location + filePrefix + "_" + fromFormat + toFormat + splayOptString + "_" + suffix + generateFileSuffix( toFormat ); } private static String generateRefFilename( String filePrefix, char fromFormat, char toFormat, CmdlineOpt splaysOpt ) { return generateFilename( refFilesLocation, filePrefix, fromFormat, toFormat, splaysOpt, "ref" ); } private static String generateOutputFilename( String filePrefix, char fromFormat, char toFormat, CmdlineOpt splaysOpt ) { return generateFilename( genFilesLocation, filePrefix, fromFormat, toFormat, splaysOpt, "testgen" ); } /** * Sets the date used as 'today' in conversions so that output files match reference files * with dates in them */ private static void setDateForConversions() { //Set date to a fixed date rather than the actual date at runtime so that test output uses a known date try { CaveConverter.setToday( UtilityFunctions.stringToDate("16/08/2012 13:14:15", "dd/MM/yyyy HH:mm:ss") ); } catch (ParseException e) { //Just print out error (will never happen with hard coded arguments used in method call above) e.printStackTrace(); } } private static String convertFile( String filePrefix, char fromFormat, char toFormat, CmdlineOpt splaysOpt, CmdlineOpt genLRUDOpt ) throws ParseException { String inputFile = generateInputFilename(filePrefix, fromFormat); String outputFile = generateOutputFilename(filePrefix, fromFormat, toFormat, splaysOpt); String referenceFile = generateRefFilename(filePrefix, fromFormat, toFormat, splaysOpt); setDateForConversions(); //Do file conversion CaveConverter.convertFile(inputFile, outputFile, fromFormat, toFormat, splaysOpt, genLRUDOpt); //Compare resulting file with expected file String fileCompare = DiffFiles.diffFiles( referenceFile, outputFile ); return fileCompare; } public static String convertUsingCmdLine( String filePrefix, char fromFormat, char toFormat, String options ) throws ParseException { String inputFile = generateInputFilename(filePrefix, fromFormat); String outputFile = generateOutputFilename(filePrefix, fromFormat, toFormat, CmdlineOpt.F); String referenceFile = generateRefFilename(filePrefix, fromFormat, toFormat, CmdlineOpt.F); //Set file suffix from command line parameters String fileSuffix = "_cmd"; if ( options.contains("nosplays") ) { fileSuffix += "n"; } else if ( options.contains("splays") ) { fileSuffix += "s"; } if ( options.contains("lrud") ) { fileSuffix += "l"; } //Change output and ref filenames to cmdline suffixes outputFile = outputFile.replace("_nsp", fileSuffix); referenceFile = referenceFile.replace("_nsp", fileSuffix); setDateForConversions(); String[] opts = options.split(" "); int numArgs = 4 + opts.length; String[] args = new String[numArgs]; args[0] = inputFile; args[1] = outputFile; args[2] = "" + fromFormat; args[3] = "" + toFormat; for (int iArg = 0; iArg < opts.length; iArg++ ) { args[4 + iArg] = opts[iArg]; } CaveConverter.main(args); //Compare resulting file with expected file String fileCompare = DiffFiles.diffFiles( referenceFile, outputFile ); return fileCompare; } } CaveConverter_src/test/cavesurvey/regression/PocketTopoToSurvexTest.java0000644000000000000000000001224512242133456026044 0ustar rootroot/** * Copyright (C) 2009-2013 Paul Fretwell - aka 'Footleg' (drfootleg@gmail.com) * * This file is part of Cave Converter. * * Cave Converter is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation, either version 3 of the License, or * (at your option) any later version. * * Cave Converter is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with Cave Converter. If not, see . */ package cavesurvey.regression; import static org.junit.Assert.*; import java.text.ParseException; import org.junit.Test; import cavesurvey.regression.RunFileConverter; import footleg.cavesurvey.cmdline.CaveConverter.CmdlineOpt; /** * Regression test class which runs data file conversions and compares the output with reference * files. Tests pass if the output file is identical to the reference file. A file name prefix * is given as the argument for each test conversion. The test will look for an input file with * this prefix and the suffix '_in.txt' and compare the output with a reference file with * this prefix and the suffix '_ref.svx'. * * @author Footleg * @version 2013.11.17 (ISO 8601 YYYY.MM.DD) * @since 1.6 (The Java version used) */ public class PocketTopoToSurvexTest { @Test public void testPocketTopoToSurvexGourAven() throws ParseException { //Convert PocketTopo text export file to Survex format data String fileCompare = RunFileConverter.convertPocketTopoToSurvex( "GourAven", CmdlineOpt.D, CmdlineOpt.T ); assertEquals("Comparing GourAven survex file from PocketTopo with reference.", DiffFiles.FILES_IDENTICAL, fileCompare); } @Test public void testPocketTopoToSurvexHSC() throws ParseException { //Convert PocketTopo text export file to Survex format data String fileCompare = RunFileConverter.convertPocketTopoToSurvex( "HSC", CmdlineOpt.D, CmdlineOpt.T ); assertEquals("Comparing HSC survex file from PocketTopo with reference.", DiffFiles.FILES_IDENTICAL, fileCompare); } @Test public void testPocketTopoToSurvexStomps() throws ParseException { //Convert PocketTopo text export file to Survex format data String fileCompare = RunFileConverter.convertPocketTopoToSurvex( "Stomps", CmdlineOpt.D, CmdlineOpt.T ); assertEquals("Comparing Stomps survex file from PocketTopo with reference.", DiffFiles.FILES_IDENTICAL, fileCompare); } @Test public void testPocketTopoToSurvexUzuGour() throws ParseException { //Convert PocketTopo text export file to Survex format data String fileCompare = RunFileConverter.convertPocketTopoToSurvex( "Uzu-Gour", CmdlineOpt.D, CmdlineOpt.T ); assertEquals("Comparing Uzu-Gour survex file from PocketTopo with reference.", DiffFiles.FILES_IDENTICAL, fileCompare); } @Test public void testPocketTopoToSurvexSwil20120909() throws ParseException { //Convert PocketTopo text export file to Survex format data String fileCompare = RunFileConverter.convertPocketTopoToSurvex( "Swil20120909", CmdlineOpt.D, CmdlineOpt.T ); assertEquals("Comparing Swil20120909 survex file from PocketTopo with reference.", DiffFiles.FILES_IDENTICAL, fileCompare); } @Test public void testPocketTopoToSurvexSloppy2ZigZags() throws ParseException { //Convert PocketTopo text export file to Survex format data String fileCompare = RunFileConverter.convertPocketTopoToSurvex( "Sloppy2ZigZags", CmdlineOpt.D, CmdlineOpt.T ); assertEquals("Comparing Sloppy2ZigZags survex file from PocketTopo with reference.", DiffFiles.FILES_IDENTICAL, fileCompare); } @Test public void testPocketTopoToSurvexT_LRUD() throws ParseException { //Convert PocketTopo text export file to Survex format data /* This was a particularly difficult case for LRUD generation in Survex as reverse legs get put * into a passage data block after the first leg in the passage data was forwards, so the rest * of the block got build with all the LRUD backwards. This case is now fixed and it detects the * 2nd leg going into the block does not follow the leg already added and put it before that leg * in the block, resulting the data being in the correct order. */ String fileCompare = RunFileConverter.convertPocketTopoToSurvex( "T_LRUD", CmdlineOpt.D, CmdlineOpt.T ); assertEquals("Comparing T_LRUD survex file from PocketTopo with reference.", DiffFiles.FILES_IDENTICAL, fileCompare); } @Test public void testPocketTopoToSurvexTripComment() throws ParseException { //Convert PocketTopo text export file to Survex format data String fileCompare = RunFileConverter.convertPocketTopoToSurvex( "TripComment", CmdlineOpt.D, CmdlineOpt.T ); assertEquals("Comparing TripComment survex file from PocketTopo with reference.", DiffFiles.FILES_IDENTICAL, fileCompare); } } CaveConverter_src/README0000644000000000000000000000605612227760236014067 0ustar rootrootCave Converter -------------- Copyright (C) 2009-2013 Paul Fretwell - aka 'Footleg' (drfootleg@gmail.com) Cave Converter is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. Cave Converter is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with Cave Converter. If not, see . ------------------------------------------------------------------------------- Building from Source -------------------- Cave Converter can be built from the Java source code using the provided ant build script. But first you will need to download a couple of dependencies required to run the unit tests and generate code coverage reports for the tests. These dependencies need to be placed in folders with the following names two levels higher in your directory hierarchy than folder containing the build.xml ant script: cobertura-1.9.4.1 junit Cobertura can be downloaded from http://cobertura.sourceforge.net/ Junit can be downloaded via http://junit.sourceforge.net/ The cobertura zip file downloaded can be unzipped to create the directory structure required. The junit-4.10.jar file needs to be placed it in a 'junit' directory (or edit the paths in the build.xml to point to the jar files if you want to use a different location or version). Once the dependencies are in place (including a Java JDK 6 or later and Apache Ant 1.8 or later), you can run the following ant commands from a command prompt in the CaveConverter_src folder where you unzipped the source. NOTE: To enable the ant script to work on Linux (Debian) with Open-JDK it was necessary to define the env.JAVA_HOME property in the build.properties file. This was not necessary when building on a Windows machine where the system environment variable JAVA_HOME was already pointing to a JDK. To build on Debian I added this line to build.properties: env.JAVA_HOME=/usr/lib/jvm/java-7-openjdk-amd64/ To just build the release distribution: ant zip This should generate the jar file in a build folder, and a complete distributable zip file in a dist folder. To run full unit and regression tests, and generate code coverage reports: ant coverage.regressions To generate the Javadoc: ant javadoc To do a full clean build and generate everything (this is the default target): ant all Other primary ant targets can be listed by running: ant -p Note that some internal targets will not work with the source distribution as they are related to code in development which is not yet functional :-) This source package has been put together with the full code needed to build the command line cave converter tool using OpenJDK6 CaveConverter_src/doc/0000755000000000000000000000000012242136246013740 5ustar rootrootCaveConverter_src/doc/COPYING0000644000000000000000000010451312071277424015003 0ustar rootroot GNU GENERAL PUBLIC LICENSE Version 3, 29 June 2007 Copyright (C) 2007 Free Software Foundation, Inc. Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed. Preamble The GNU General Public License is a free, copyleft license for software and other kinds of works. The licenses for most software and other practical works are designed to take away your freedom to share and change the works. By contrast, the GNU General Public License is intended to guarantee your freedom to share and change all versions of a program--to make sure it remains free software for all its users. We, the Free Software Foundation, use the GNU General Public License for most of our software; it applies also to any other work released this way by its authors. You can apply it to your programs, too. When we speak of free software, we are referring to freedom, not price. Our General Public Licenses are designed to make sure that you have the freedom to distribute copies of free software (and charge for them if you wish), that you receive source code or can get it if you want it, that you can change the software or use pieces of it in new free programs, and that you know you can do these things. To protect your rights, we need to prevent others from denying you these rights or asking you to surrender the rights. Therefore, you have certain responsibilities if you distribute copies of the software, or if you modify it: responsibilities to respect the freedom of others. For example, if you distribute copies of such a program, whether gratis or for a fee, you must pass on to the recipients the same freedoms that you received. You must make sure that they, too, receive or can get the source code. And you must show them these terms so they know their rights. Developers that use the GNU GPL protect your rights with two steps: (1) assert copyright on the software, and (2) offer you this License giving you legal permission to copy, distribute and/or modify it. For the developers' and authors' protection, the GPL clearly explains that there is no warranty for this free software. For both users' and authors' sake, the GPL requires that modified versions be marked as changed, so that their problems will not be attributed erroneously to authors of previous versions. Some devices are designed to deny users access to install or run modified versions of the software inside them, although the manufacturer can do so. This is fundamentally incompatible with the aim of protecting users' freedom to change the software. The systematic pattern of such abuse occurs in the area of products for individuals to use, which is precisely where it is most unacceptable. Therefore, we have designed this version of the GPL to prohibit the practice for those products. If such problems arise substantially in other domains, we stand ready to extend this provision to those domains in future versions of the GPL, as needed to protect the freedom of users. Finally, every program is threatened constantly by software patents. States should not allow patents to restrict development and use of software on general-purpose computers, but in those that do, we wish to avoid the special danger that patents applied to a free program could make it effectively proprietary. To prevent this, the GPL assures that patents cannot be used to render the program non-free. The precise terms and conditions for copying, distribution and modification follow. TERMS AND CONDITIONS 0. Definitions. "This License" refers to version 3 of the GNU General Public License. "Copyright" also means copyright-like laws that apply to other kinds of works, such as semiconductor masks. "The Program" refers to any copyrightable work licensed under this License. Each licensee is addressed as "you". "Licensees" and "recipients" may be individuals or organizations. To "modify" a work means to copy from or adapt all or part of the work in a fashion requiring copyright permission, other than the making of an exact copy. The resulting work is called a "modified version" of the earlier work or a work "based on" the earlier work. A "covered work" means either the unmodified Program or a work based on the Program. To "propagate" a work means to do anything with it that, without permission, would make you directly or secondarily liable for infringement under applicable copyright law, except executing it on a computer or modifying a private copy. Propagation includes copying, distribution (with or without modification), making available to the public, and in some countries other activities as well. To "convey" a work means any kind of propagation that enables other parties to make or receive copies. Mere interaction with a user through a computer network, with no transfer of a copy, is not conveying. An interactive user interface displays "Appropriate Legal Notices" to the extent that it includes a convenient and prominently visible feature that (1) displays an appropriate copyright notice, and (2) tells the user that there is no warranty for the work (except to the extent that warranties are provided), that licensees may convey the work under this License, and how to view a copy of this License. If the interface presents a list of user commands or options, such as a menu, a prominent item in the list meets this criterion. 1. Source Code. The "source code" for a work means the preferred form of the work for making modifications to it. "Object code" means any non-source form of a work. A "Standard Interface" means an interface that either is an official standard defined by a recognized standards body, or, in the case of interfaces specified for a particular programming language, one that is widely used among developers working in that language. The "System Libraries" of an executable work include anything, other than the work as a whole, that (a) is included in the normal form of packaging a Major Component, but which is not part of that Major Component, and (b) serves only to enable use of the work with that Major Component, or to implement a Standard Interface for which an implementation is available to the public in source code form. A "Major Component", in this context, means a major essential component (kernel, window system, and so on) of the specific operating system (if any) on which the executable work runs, or a compiler used to produce the work, or an object code interpreter used to run it. The "Corresponding Source" for a work in object code form means all the source code needed to generate, install, and (for an executable work) run the object code and to modify the work, including scripts to control those activities. However, it does not include the work's System Libraries, or general-purpose tools or generally available free programs which are used unmodified in performing those activities but which are not part of the work. For example, Corresponding Source includes interface definition files associated with source files for the work, and the source code for shared libraries and dynamically linked subprograms that the work is specifically designed to require, such as by intimate data communication or control flow between those subprograms and other parts of the work. The Corresponding Source need not include anything that users can regenerate automatically from other parts of the Corresponding Source. The Corresponding Source for a work in source code form is that same work. 2. Basic Permissions. All rights granted under this License are granted for the term of copyright on the Program, and are irrevocable provided the stated conditions are met. This License explicitly affirms your unlimited permission to run the unmodified Program. The output from running a covered work is covered by this License only if the output, given its content, constitutes a covered work. This License acknowledges your rights of fair use or other equivalent, as provided by copyright law. You may make, run and propagate covered works that you do not convey, without conditions so long as your license otherwise remains in force. You may convey covered works to others for the sole purpose of having them make modifications exclusively for you, or provide you with facilities for running those works, provided that you comply with the terms of this License in conveying all material for which you do not control copyright. Those thus making or running the covered works for you must do so exclusively on your behalf, under your direction and control, on terms that prohibit them from making any copies of your copyrighted material outside their relationship with you. Conveying under any other circumstances is permitted solely under the conditions stated below. Sublicensing is not allowed; section 10 makes it unnecessary. 3. Protecting Users' Legal Rights From Anti-Circumvention Law. No covered work shall be deemed part of an effective technological measure under any applicable law fulfilling obligations under article 11 of the WIPO copyright treaty adopted on 20 December 1996, or similar laws prohibiting or restricting circumvention of such measures. When you convey a covered work, you waive any legal power to forbid circumvention of technological measures to the extent such circumvention is effected by exercising rights under this License with respect to the covered work, and you disclaim any intention to limit operation or modification of the work as a means of enforcing, against the work's users, your or third parties' legal rights to forbid circumvention of technological measures. 4. Conveying Verbatim Copies. You may convey verbatim copies of the Program's source code as you receive it, in any medium, provided that you conspicuously and appropriately publish on each copy an appropriate copyright notice; keep intact all notices stating that this License and any non-permissive terms added in accord with section 7 apply to the code; keep intact all notices of the absence of any warranty; and give all recipients a copy of this License along with the Program. You may charge any price or no price for each copy that you convey, and you may offer support or warranty protection for a fee. 5. Conveying Modified Source Versions. You may convey a work based on the Program, or the modifications to produce it from the Program, in the form of source code under the terms of section 4, provided that you also meet all of these conditions: a) The work must carry prominent notices stating that you modified it, and giving a relevant date. b) The work must carry prominent notices stating that it is released under this License and any conditions added under section 7. This requirement modifies the requirement in section 4 to "keep intact all notices". c) You must license the entire work, as a whole, under this License to anyone who comes into possession of a copy. This License will therefore apply, along with any applicable section 7 additional terms, to the whole of the work, and all its parts, regardless of how they are packaged. This License gives no permission to license the work in any other way, but it does not invalidate such permission if you have separately received it. d) If the work has interactive user interfaces, each must display Appropriate Legal Notices; however, if the Program has interactive interfaces that do not display Appropriate Legal Notices, your work need not make them do so. A compilation of a covered work with other separate and independent works, which are not by their nature extensions of the covered work, and which are not combined with it such as to form a larger program, in or on a volume of a storage or distribution medium, is called an "aggregate" if the compilation and its resulting copyright are not used to limit the access or legal rights of the compilation's users beyond what the individual works permit. Inclusion of a covered work in an aggregate does not cause this License to apply to the other parts of the aggregate. 6. Conveying Non-Source Forms. You may convey a covered work in object code form under the terms of sections 4 and 5, provided that you also convey the machine-readable Corresponding Source under the terms of this License, in one of these ways: a) Convey the object code in, or embodied in, a physical product (including a physical distribution medium), accompanied by the Corresponding Source fixed on a durable physical medium customarily used for software interchange. b) Convey the object code in, or embodied in, a physical product (including a physical distribution medium), accompanied by a written offer, valid for at least three years and valid for as long as you offer spare parts or customer support for that product model, to give anyone who possesses the object code either (1) a copy of the Corresponding Source for all the software in the product that is covered by this License, on a durable physical medium customarily used for software interchange, for a price no more than your reasonable cost of physically performing this conveying of source, or (2) access to copy the Corresponding Source from a network server at no charge. c) Convey individual copies of the object code with a copy of the written offer to provide the Corresponding Source. This alternative is allowed only occasionally and noncommercially, and only if you received the object code with such an offer, in accord with subsection 6b. d) Convey the object code by offering access from a designated place (gratis or for a charge), and offer equivalent access to the Corresponding Source in the same way through the same place at no further charge. You need not require recipients to copy the Corresponding Source along with the object code. If the place to copy the object code is a network server, the Corresponding Source may be on a different server (operated by you or a third party) that supports equivalent copying facilities, provided you maintain clear directions next to the object code saying where to find the Corresponding Source. Regardless of what server hosts the Corresponding Source, you remain obligated to ensure that it is available for as long as needed to satisfy these requirements. e) Convey the object code using peer-to-peer transmission, provided you inform other peers where the object code and Corresponding Source of the work are being offered to the general public at no charge under subsection 6d. A separable portion of the object code, whose source code is excluded from the Corresponding Source as a System Library, need not be included in conveying the object code work. A "User Product" is either (1) a "consumer product", which means any tangible personal property which is normally used for personal, family, or household purposes, or (2) anything designed or sold for incorporation into a dwelling. In determining whether a product is a consumer product, doubtful cases shall be resolved in favor of coverage. For a particular product received by a particular user, "normally used" refers to a typical or common use of that class of product, regardless of the status of the particular user or of the way in which the particular user actually uses, or expects or is expected to use, the product. A product is a consumer product regardless of whether the product has substantial commercial, industrial or non-consumer uses, unless such uses represent the only significant mode of use of the product. "Installation Information" for a User Product means any methods, procedures, authorization keys, or other information required to install and execute modified versions of a covered work in that User Product from a modified version of its Corresponding Source. The information must suffice to ensure that the continued functioning of the modified object code is in no case prevented or interfered with solely because modification has been made. If you convey an object code work under this section in, or with, or specifically for use in, a User Product, and the conveying occurs as part of a transaction in which the right of possession and use of the User Product is transferred to the recipient in perpetuity or for a fixed term (regardless of how the transaction is characterized), the Corresponding Source conveyed under this section must be accompanied by the Installation Information. But this requirement does not apply if neither you nor any third party retains the ability to install modified object code on the User Product (for example, the work has been installed in ROM). The requirement to provide Installation Information does not include a requirement to continue to provide support service, warranty, or updates for a work that has been modified or installed by the recipient, or for the User Product in which it has been modified or installed. Access to a network may be denied when the modification itself materially and adversely affects the operation of the network or violates the rules and protocols for communication across the network. Corresponding Source conveyed, and Installation Information provided, in accord with this section must be in a format that is publicly documented (and with an implementation available to the public in source code form), and must require no special password or key for unpacking, reading or copying. 7. Additional Terms. "Additional permissions" are terms that supplement the terms of this License by making exceptions from one or more of its conditions. Additional permissions that are applicable to the entire Program shall be treated as though they were included in this License, to the extent that they are valid under applicable law. If additional permissions apply only to part of the Program, that part may be used separately under those permissions, but the entire Program remains governed by this License without regard to the additional permissions. When you convey a copy of a covered work, you may at your option remove any additional permissions from that copy, or from any part of it. (Additional permissions may be written to require their own removal in certain cases when you modify the work.) You may place additional permissions on material, added by you to a covered work, for which you have or can give appropriate copyright permission. Notwithstanding any other provision of this License, for material you add to a covered work, you may (if authorized by the copyright holders of that material) supplement the terms of this License with terms: a) Disclaiming warranty or limiting liability differently from the terms of sections 15 and 16 of this License; or b) Requiring preservation of specified reasonable legal notices or author attributions in that material or in the Appropriate Legal Notices displayed by works containing it; or c) Prohibiting misrepresentation of the origin of that material, or requiring that modified versions of such material be marked in reasonable ways as different from the original version; or d) Limiting the use for publicity purposes of names of licensors or authors of the material; or e) Declining to grant rights under trademark law for use of some trade names, trademarks, or service marks; or f) Requiring indemnification of licensors and authors of that material by anyone who conveys the material (or modified versions of it) with contractual assumptions of liability to the recipient, for any liability that these contractual assumptions directly impose on those licensors and authors. All other non-permissive additional terms are considered "further restrictions" within the meaning of section 10. If the Program as you received it, or any part of it, contains a notice stating that it is governed by this License along with a term that is a further restriction, you may remove that term. If a license document contains a further restriction but permits relicensing or conveying under this License, you may add to a covered work material governed by the terms of that license document, provided that the further restriction does not survive such relicensing or conveying. If you add terms to a covered work in accord with this section, you must place, in the relevant source files, a statement of the additional terms that apply to those files, or a notice indicating where to find the applicable terms. Additional terms, permissive or non-permissive, may be stated in the form of a separately written license, or stated as exceptions; the above requirements apply either way. 8. Termination. You may not propagate or modify a covered work except as expressly provided under this License. Any attempt otherwise to propagate or modify it is void, and will automatically terminate your rights under this License (including any patent licenses granted under the third paragraph of section 11). However, if you cease all violation of this License, then your license from a particular copyright holder is reinstated (a) provisionally, unless and until the copyright holder explicitly and finally terminates your license, and (b) permanently, if the copyright holder fails to notify you of the violation by some reasonable means prior to 60 days after the cessation. Moreover, your license from a particular copyright holder is reinstated permanently if the copyright holder notifies you of the violation by some reasonable means, this is the first time you have received notice of violation of this License (for any work) from that copyright holder, and you cure the violation prior to 30 days after your receipt of the notice. Termination of your rights under this section does not terminate the licenses of parties who have received copies or rights from you under this License. If your rights have been terminated and not permanently reinstated, you do not qualify to receive new licenses for the same material under section 10. 9. Acceptance Not Required for Having Copies. You are not required to accept this License in order to receive or run a copy of the Program. Ancillary propagation of a covered work occurring solely as a consequence of using peer-to-peer transmission to receive a copy likewise does not require acceptance. However, nothing other than this License grants you permission to propagate or modify any covered work. These actions infringe copyright if you do not accept this License. Therefore, by modifying or propagating a covered work, you indicate your acceptance of this License to do so. 10. Automatic Licensing of Downstream Recipients. Each time you convey a covered work, the recipient automatically receives a license from the original licensors, to run, modify and propagate that work, subject to this License. You are not responsible for enforcing compliance by third parties with this License. An "entity transaction" is a transaction transferring control of an organization, or substantially all assets of one, or subdividing an organization, or merging organizations. If propagation of a covered work results from an entity transaction, each party to that transaction who receives a copy of the work also receives whatever licenses to the work the party's predecessor in interest had or could give under the previous paragraph, plus a right to possession of the Corresponding Source of the work from the predecessor in interest, if the predecessor has it or can get it with reasonable efforts. You may not impose any further restrictions on the exercise of the rights granted or affirmed under this License. For example, you may not impose a license fee, royalty, or other charge for exercise of rights granted under this License, and you may not initiate litigation (including a cross-claim or counterclaim in a lawsuit) alleging that any patent claim is infringed by making, using, selling, offering for sale, or importing the Program or any portion of it. 11. Patents. A "contributor" is a copyright holder who authorizes use under this License of the Program or a work on which the Program is based. The work thus licensed is called the contributor's "contributor version". A contributor's "essential patent claims" are all patent claims owned or controlled by the contributor, whether already acquired or hereafter acquired, that would be infringed by some manner, permitted by this License, of making, using, or selling its contributor version, but do not include claims that would be infringed only as a consequence of further modification of the contributor version. For purposes of this definition, "control" includes the right to grant patent sublicenses in a manner consistent with the requirements of this License. Each contributor grants you a non-exclusive, worldwide, royalty-free patent license under the contributor's essential patent claims, to make, use, sell, offer for sale, import and otherwise run, modify and propagate the contents of its contributor version. In the following three paragraphs, a "patent license" is any express agreement or commitment, however denominated, not to enforce a patent (such as an express permission to practice a patent or covenant not to sue for patent infringement). To "grant" such a patent license to a party means to make such an agreement or commitment not to enforce a patent against the party. If you convey a covered work, knowingly relying on a patent license, and the Corresponding Source of the work is not available for anyone to copy, free of charge and under the terms of this License, through a publicly available network server or other readily accessible means, then you must either (1) cause the Corresponding Source to be so available, or (2) arrange to deprive yourself of the benefit of the patent license for this particular work, or (3) arrange, in a manner consistent with the requirements of this License, to extend the patent license to downstream recipients. "Knowingly relying" means you have actual knowledge that, but for the patent license, your conveying the covered work in a country, or your recipient's use of the covered work in a country, would infringe one or more identifiable patents in that country that you have reason to believe are valid. If, pursuant to or in connection with a single transaction or arrangement, you convey, or propagate by procuring conveyance of, a covered work, and grant a patent license to some of the parties receiving the covered work authorizing them to use, propagate, modify or convey a specific copy of the covered work, then the patent license you grant is automatically extended to all recipients of the covered work and works based on it. A patent license is "discriminatory" if it does not include within the scope of its coverage, prohibits the exercise of, or is conditioned on the non-exercise of one or more of the rights that are specifically granted under this License. You may not convey a covered work if you are a party to an arrangement with a third party that is in the business of distributing software, under which you make payment to the third party based on the extent of your activity of conveying the work, and under which the third party grants, to any of the parties who would receive the covered work from you, a discriminatory patent license (a) in connection with copies of the covered work conveyed by you (or copies made from those copies), or (b) primarily for and in connection with specific products or compilations that contain the covered work, unless you entered into that arrangement, or that patent license was granted, prior to 28 March 2007. Nothing in this License shall be construed as excluding or limiting any implied license or other defenses to infringement that may otherwise be available to you under applicable patent law. 12. No Surrender of Others' Freedom. If conditions are imposed on you (whether by court order, agreement or otherwise) that contradict the conditions of this License, they do not excuse you from the conditions of this License. If you cannot convey a covered work so as to satisfy simultaneously your obligations under this License and any other pertinent obligations, then as a consequence you may not convey it at all. For example, if you agree to terms that obligate you to collect a royalty for further conveying from those to whom you convey the Program, the only way you could satisfy both those terms and this License would be to refrain entirely from conveying the Program. 13. Use with the GNU Affero General Public License. Notwithstanding any other provision of this License, you have permission to link or combine any covered work with a work licensed under version 3 of the GNU Affero General Public License into a single combined work, and to convey the resulting work. The terms of this License will continue to apply to the part which is the covered work, but the special requirements of the GNU Affero General Public License, section 13, concerning interaction through a network will apply to the combination as such. 14. Revised Versions of this License. The Free Software Foundation may publish revised and/or new versions of the GNU General Public License from time to time. Such new versions will be similar in spirit to the present version, but may differ in detail to address new problems or concerns. Each version is given a distinguishing version number. If the Program specifies that a certain numbered version of the GNU General Public License "or any later version" applies to it, you have the option of following the terms and conditions either of that numbered version or of any later version published by the Free Software Foundation. If the Program does not specify a version number of the GNU General Public License, you may choose any version ever published by the Free Software Foundation. If the Program specifies that a proxy can decide which future versions of the GNU General Public License can be used, that proxy's public statement of acceptance of a version permanently authorizes you to choose that version for the Program. Later license versions may give you additional or different permissions. However, no additional obligations are imposed on any author or copyright holder as a result of your choosing to follow a later version. 15. Disclaimer of Warranty. THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION. 16. Limitation of Liability. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. 17. Interpretation of Sections 15 and 16. If the disclaimer of warranty and limitation of liability provided above cannot be given local legal effect according to their terms, reviewing courts shall apply local law that most closely approximates an absolute waiver of all civil liability in connection with the Program, unless a warranty or assumption of liability accompanies a copy of the Program in return for a fee. END OF TERMS AND CONDITIONS How to Apply These Terms to Your New Programs If you develop a new program, and you want it to be of the greatest possible use to the public, the best way to achieve this is to make it free software which everyone can redistribute and change under these terms. To do so, attach the following notices to the program. It is safest to attach them to the start of each source file to most effectively state the exclusion of warranty; and each file should have at least the "copyright" line and a pointer to where the full notice is found. Copyright (C) This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program. If not, see . Also add information on how to contact you by electronic and paper mail. If the program does terminal interaction, make it output a short notice like this when it starts in an interactive mode: Copyright (C) This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'. This is free software, and you are welcome to redistribute it under certain conditions; type `show c' for details. The hypothetical commands `show w' and `show c' should show the appropriate parts of the General Public License. Of course, your program's commands might be different; for a GUI interface, you would use an "about box". You should also get your employer (if you work as a programmer) or school, if any, to sign a "copyright disclaimer" for the program, if necessary. For more information on this, and how to apply and follow the GNU GPL, see . The GNU General Public License does not permit incorporating your program into proprietary programs. If your program is a subroutine library, you may consider it more useful to permit linking proprietary applications with the library. If this is what you want to do, use the GNU Lesser General Public License instead of this License. But first, please read . CaveConverter_src/doc/readme.html0000644000000000000000000001744412242134676016102 0ustar rootroot Footleg's Cave Converter

Cave Converter

Version: 20131117

Cave Converter is a program for converting cave survey data from one format into another. It can read and write a variety of cave survey data file formats.

Download the latest version here: CaveConverter.zip

Cave Converter is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.

Cave Converter is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

The latest version of the source code can be downloaded from here: CaveConverter_src.zip

Older releases can be downloaded from the release archive page.

The current release is able to read the following formats:

  • Survex - Supports the most common data formats (from to tape compass clino) assuming units are metres and degrees. Single data files only.
  • PocketTopo text export - Text export option in PocketTopo menu.
  • DXF - Reads Lines and Polylines as survey centreline data.

and write the following formats:

  • Toporobot - For using to import data into PocketTopo software on a PDA.
  • Survex - Normal formated metric units only.

Cave Converter is written in Java and is available as a JAR file. You will need a Java runtime (v6 or later) installed on your computer to run the converter. The JAR file can be run with the following command line arguments:

input_filename output_filename input_format_code output_format_code [options]

The first argument is the name of the file containing the data you want to convert, and second argument is the name of the file you want to be created in the new format. The next two arguments are single letter format codes to indicate the input and output data formats. Finally some option codes can be specified. The format codes are as follows:

  • d - DXF
  • p - PocketTopo text export
  • s - Survex
  • t - Toporobot

The following options can also be specified:

  • splays - Include splay legs in output file
  • nosplays - Exclude splays from output file
  • lrud - Generate LRUD passage dimension data from splays

If no splay option is specified then splays are output by default in Survex files, but are excluded by default from Toporobot files (as Toporobot file export does not distinguish between splays and other legs so all splays exported to this file format become legs).

Here are some example command lines to illustrate some useful conversions:

  • To convert existing Survex data into Toporobot format so you can import it into PocketTopo (generating passage dimension data from any splays):
java -jar CaveConverter.jar survexfile.svx output.text s t lrud
  • To convert data exported from PocketTopo into Survex format (and generate passage data blocks from splays):
java -jar CaveConverter.jar pdaexport.txt survexfile.svx p s lrud
  • To generate LRUD passage data in a Survex file which contains splays:
java -jar CaveConverter.jar survexfilein.svx survexfileout.svx s s lrud
  • To convert data from DXF format into Toporobot format so you can import it into PocketTopo:
java -jar CaveConverter.jar datafile.dxf toporobotfileout.text d t
  • To convert data from DXF format into Survex format:
java -jar CaveConverter.jar datafile.dxf survexfile.svx d s

This last example shows how editable survey data can be regenerated from Survex .3d files via the Convert to DXF option provided by Survex (right-click on a .3d file to select this option from the pop-up menu on Windows). This is also how you can generate a DXF file to convert to Toporobot using the Cave Converter, enabling existing cave surveys to be imported into PocketTopo regardless of the original Survex format data. So if your Survex file is not readable by the Cave Converter (because it contains diving data, or different units or data ordering than the default) then you can still process it using Survex to generate a 3d file and convert that to DXF using Survex. Then convert it to Toporobot format using Cave Converter and import that file into PocketTopo. This enables existing surveys to be loaded into PocketTopo so that new data can be tied into the known cave on surveying trips.

Converting Survex data to Toporobot will cause all the survey station numbers and series names to get regenerated unfortunately. This is because Toporobot format requires survey series to consist only of linear chains of survey stations. Junctions are not allowed in series. This means that data from other formats cannot be simply converted, so all stations are renumbered and reorganised into new numbered series to conform to these constraints of the Toporobot format.

Some example Windows batch files are included in the download to illustrate the most useful conversions. You can edit the file names in these batch files to the names of the files you want to convert and then run the converter by double-clicking on the batch file in Windows Explorer. If you don't get any output when running the converter from a batch file then run the program from a command prompt rather than double clicking on a batch file and you will see the errors output. Send me your data file and I will work on a bug fix. I can be contacted by email: drfootleg [at] gmail.com

While Cave Converter can regenerate survey data files from DXF files generated from Survex .3d files, you will not get back the complete original data. What you do get is the equivalent calculated survey leg data (tape, compass, clino) for the positions of the stations in the DXF file. So any loop closure corrections and instrument calibrations will have already been applied to the data. This feature is really intended as a way to recover some sort of workable data when the original data has been lost and only the 3d files remain. Some small rounding errors occur during the Conversion to DXF from the .3d file, so the exact positions of survey stations and the cave length reported may differ by a few cm compared to the original data. This is because in the DXF file, Survex has rounded all station positions to the nearest 1cm.

The Survex file reader does not currently read passage data blocks. So any passage data blocks will be removed if a Survex file is read in and written out again. However if the Survex file contains splays and the lrud option is specified on the command line then new passage data blocks will be generated from the splays and replace any previously present passage data blocks in the file which is generated.

If you are reading a downloaded copy of this help page then check for a more recent version online here: Cave Converter Information Page.


Last updated:
17th November 2013
CaveConverter_src/doc/change_log.txt0000644000000000000000000002014612242134544016571 0ustar rootrootCave Converter Change Log ------------------------- 17 Nov. 2013 - Fixed a bug in LRUD data generation which caused LRUD data at stations only appearing as the 'to station' in a pair of legs to be calculated using the bearing of only one of the two legs (i.e. When two legs are measured to the same station as typically happens when the instruments are read at alternate stations 'leap frogging' stations). - Fixed a bug in Survex Writer passage data block generation which meant it could get the left and right measurements reversed when the first leg in a block is in a forward direction but the second leg is in reverse. 16 Oct. 2013 - Fixed bugs in Survex Writer passage data block generation which meant it only generated sensible data if all survey legs were measured in the direction the survey was travelling. Now legs measured in the reverse direction are handled, and legs do not have immediately follow from the previous 'to' station of the last leg for the passage data to be structured sensibly. - Fixed bug in PocketTopo parser which repeated the station name given to the 'to' station for a splay leg when the splays were not all located together in the survey. 21 Sep. 2013 (beta) - Moved code to generate LRUD (left, right, up, down) passage dimensions from the PocketTopo parser into the Survey Series class. - Added additional command line options: - splays/nosplays: Survex writer and Toporobot writer now have option to not output splays. - lrud: Option to generate LRUD data from splays (can be used on any conversion). - Added rounding of LRUD values to 2 decimal places in Survex file writer. - Changed LRUD generation to better select the best splay for each dimension, and to calculate the distance for the LRUD dimensions based on the angle of the splay to the passage direction instead of using the total length of the splay. The splay selected when there is a choice is now the splay giving the biggest dimension in the direction of the LRUD measurement rather than using the splay closest to the compass bearing of the passage dimension measurement direction. Passage direction is now calculated from the average bearing of the forward leg and the previous leg arriving at the station. When more than two legs join at a station then the previous leg will be the one with the closest bearing to the bearing of the onward leg. - Splays fired as back shots are now excluded from LRUD generation. - Splays are no longer removed from the output when used to generate LRUD dimensions. - The Survex writer now groups passage data from LRUD dimensions into blocks of readings corresponding to the survey legs in the file (previously one block of passage data was output per series with all stations listed with no respect for their connectivity). - Fixed bug where compass calibration was used instead of declination calibration in PocketTopo parser, Survex parser and Survex writer. - Added duplicate and surface flags to leg class, and added reading of flags to Survex parser and writing them to Survex writer. - Added date reading to Survex parser. - Fixed bug in utility function to calculate the average of a set of compass bearings (thanks to Peter Kellaway for pointing me to a much more robust and elegant solution). This bug does not affect the use of the function in previous versions (where it was only used to convert PocketTopo triple leg readings into one average leg) but it did show up in the new LRUD generation code when calculating the average bearing of two legs either side of a station when the passage went round a sharp bend. - Fixed bug in Toporobot Writer which caused passage dimensions data to be output on the wrong station (LRUD values for the 'from' station of each leg were being put on the 'to' station of each leg). - PocketTopo file reader no longer reorders the splay legs for each station (something which used to happen due to the old code which sorted splays into groups for L,R,U,D measurements in this reader). - Made the logging output less verbose, and fixed the survey summary details log output to include inner series. 16 Mar. 2013 - Fixed bug in Toporobot writer which left survey series unlinked when two series crossed over each other in the middle of each series (i.e. Not joined at the start or end of either series). 05 Mar. 2013 - Added support for nested series in the data model. Survex reader and writer no longer flatten the survey series hierarchy when series are inside other series. - Fixed issue where Survex output files put data inside duplicated begin/end blocks. - Improved series naming in PocketTopo converted data. Series now have the series number as their name rather than the full cave name and series number, so the name is not duplicated in the outer series name and inner series names. The outer series name is now the full name from the input file (previously any numbers on the end of the name were removed). - PocketTopo converted data links to series not included in the PocketTopo file now use the correct series number and station number for the linked external series instead of dummy data. - Toporobot format generation is much faster, and handles more complex cave surveys which could crash the converter in previous versions. - Fixed crash in Toporobot writer when converting directly from PocketTopo format. 31 Dec. 2012 - Major refactoring of internal data model of converter. All code changes are now tested using an automated test framework to ensure conversions still produce the same output as previous releases of the converter. - Renamed main class and jar file to 'CaveConverter' and attempted to use this name consistently in code and documentation. - Added support for trip comments in PocketTopo txt export format file reader. Previous versions threw an error if files contained trip comments. - Added support for stations having more than 26 splays. Previous versions generated invalid survey station names in output files for splays when there were more than 26 splays off a single station. Now the first 26 stations are numbered a-z, then the sequence of generated 'to' station names will continue aa, ab, ac .. az, ba, bb, etc. - Fixed output file line endings issue where previous versions always generated Unix style line endings. Now files will have the line endings applicable to the platform the converter is being run on. So on Windows the output files will have Windows style line endings. 09 Aug. 2011 - Changed PocketTopo txt file reader to keep all the splay shots at any station where more than just a single left, right, up and down dimension was measured. Previously the code picked one of the shots to be converted into an LRUD dimension and only retained the others as splays. Now it retains all of them in case the user did not agree with the one which the code picked as the best match for a passage dimension number. If there is just one splay for each of the left, right, up, down directions then these are converted to LRUD data and no splays are output for that station. 04 Oct. 2010 - Fixed DXF file reading code to handle a wider range of dxf files. Specifically files that do not contain either 'Centreline' or 'AcDbEntity' headings in LINE definitions. Now it will just try to locate the '10', '20', '30' headers in the LINE definition. 15 Aug. 2010 - Fixed bug where zero length legs to equate a station with one in a survey series not in the Pocket Topo txt file being converted would crash the converter if the station in the series not in the file was the second station in the leg. i.e. When in Pocket Topo you had tied in to another survey part way along the survey of new passages, or surveyed back from the end point in a new passage to tie in to a known passage at the end of the survey. - The Survex writer will now output survey dates so that survex can process the date and allow the survey to be viewed by date in Aven. - The Survex writer will now put SPLAY and NOT SPLAY flags around splay legs so that they do not get counted in the total length calculated by Survex. CaveConverter_src/doc/conv-d2t.bat0000644000000000000000000000010212063426354016060 0ustar rootrootjava -jar CaveConverter.jar datafile.dxf toporobotfileout.text d tCaveConverter_src/doc/conv-d2s.bat0000644000000000000000000000007612063426354016071 0ustar rootrootjava -jar CaveConverter.jar datafile.dxf survexfileout.svx d sCaveConverter_src/doc/conv-p2s.bat0000644000000000000000000000010712216406760016077 0ustar rootrootjava -jar CaveConverter.jar exportedcave.txt survexfileout.svx p s lrudCaveConverter_src/doc/conv-s2t.bat0000644000000000000000000000012012216407010016063 0ustar rootrootjava -jar CaveConverter.jar survexfiletoimport.svx toporobotoutput.text s t lrudCaveConverter_src/build.xml0000644000000000000000000004261712227762102015025 0ustar rootroot Compiles the CaveSurveyConverter project and builds a JAR. . Ant could not find the JavaFX SDK. Either install JDK 7u6 or above and set JAVA_HOME to the JDK or set [javafx.sdk] on the command line (e.g. on Windows: ant -Djavafx.sdk="C:\Program Files (x86)\Oracle\JavaFX 2.2 SDK or ant -Djavafx.sdk="C:\Program Files (x86)\Oracle\JavaFX 2.2 SDK") Footleg Cave]]> Copyright © 2013 Footleg. Distributed under the terms of the GNU General Public License.]]> CaveConverter_src/build.properties0000644000000000000000000000016112242120266016401 0ustar rootroot# build properties application.vendor = Footleg application.title = Cave Converter build.version = 20131117-beta