/// <summary>
        /// If the project is an older version, then an
        /// object may not have existed in the project.
        /// This will ensure all the object are at least
        /// created with default values.
        /// </summary>
        private void CheckForNull()
        {
            if (SubsysOptions == null)
            {
                SubsysOptions = new Dictionary <string, SubsystemOptions>();
            }

            if (SubsystemConfigList == null)
            {
                SubsystemConfigList = new HashSet <SubsystemConfiguration>();
            }

            if (SmartPageOptions == null)
            {
                SmartPageOptions = new SmartPageOptions();
            }

            if (ExportDataOptions == null)
            {
                ExportDataOptions = new ExportOptions();
            }
        }
示例#2
0
        /// <summary>
        /// Open the exporters based off the selection.
        /// </summary>
        /// <param name="folderPath">Folder path of the exported files.</param>
        /// <param name="filename">File name of the exported file.</param>
        /// <param name="options">Options for exporting.</param>
        /// <param name="isCsvSelected">CSV Exporter selected.</param>
        /// <param name="isMatlabSelected">MATLAB exporter selected.</param>
        /// <param name="isMatlabMatrixSelected">MATLAB matrix selected.</param>
        /// <param name="isPd0Selected">PD0 exporter selected.</param>
        /// <param name="isEnsSelected">ENS exporter selected.</param>
        public void Open(string folderPath, string filename, ExportOptions options, bool isCsvSelected, bool isMatlabSelected, bool isMatlabMatrixSelected, bool isPd0Selected, bool isEnsSelected)
        {
            // Open all the exporters that are selected
            // The filename is name without the extension
            csv          = new CsvExporterWriter();
            matlab       = new MatlabExporterWriter();
            matlabMatrix = new MatlabMatrixExporterWriter();
            pd0          = new Pd0ExporterWriter();
            ensEx        = new EnsExporterWriter();

            try
            {
                if (isCsvSelected)
                {
                    csv.Open(folderPath, filename + ".csv", options);
                }
                if (isMatlabSelected)
                {
                    matlab.Open(folderPath, filename, options);
                }
                if (isMatlabMatrixSelected)
                {
                    matlabMatrix.Open(folderPath, filename, options);
                }
                if (isPd0Selected)
                {
                    pd0.Open(folderPath, filename + "_pd0" + ".pd0", options);
                }
                if (isEnsSelected)
                {
                    ensEx.Open(folderPath, filename + "_rtb" + ".ens", options);
                }
            }
            catch (Exception ex)
            {
                log.Error("Error opening ensemble file.", ex);
            }
        }
示例#3
0
        /// <summary>
        /// Export the the data based off the exporter chosen.
        /// </summary>
        /// <param name="exporter">Exporter chosen.</param>
        private void Export(Exporters exporter)
        {
            // No project was selected
            if (_pm.IsProjectSelected)
            {
                IsExporting = true;

                string dir      = _pm.SelectedProject.ProjectFolderPath + @"\";
                string filename = "";
                //string file = dir + filename;

                // Determine which exporter to use
                IExporterWriter writer = null;
                switch (exporter)
                {
                case Exporters.CSV:
                    writer   = new CsvExporterWriter();
                    filename = _pm.SelectedProject.ProjectName + "_export.csv";
                    break;

                case Exporters.Matlab:
                    writer   = new MatlabExporterWriter();
                    filename = _pm.SelectedProject.ProjectName;
                    break;

                case Exporters.PD0:
                    writer   = new Pd0ExporterWriter();
                    filename = _pm.SelectedProject.ProjectName + "_export.pd0";
                    break;

                case Exporters.ENS:
                    writer   = new EnsExporterWriter();
                    filename = _pm.SelectedProject.ProjectName + "_export.ens";
                    break;

                default:
                    break;
                }


                if (writer != null)
                {
                    AdcpDatabaseReader dbReader = new AdcpDatabaseReader();
                    int size = dbReader.GetNumberOfEnsembles(_pm.SelectedProject);

                    uint x = 0;
                    try
                    {
                        // Display the busy indicator
                        //IsBusyIndicator = true;
                        // Create the directory if it does not exist
                        if (!Directory.Exists(dir))
                        {
                            Directory.CreateDirectory(dir);
                        }

                        // Open the file
                        writer.Open(dir, filename, _Options);

                        // Check the max value
                        if (MaxEnsembleNumber > _pm.SelectedProject.GetNumberOfEnsembles())
                        {
                            MaxEnsembleNumber = (uint)_pm.SelectedProject.GetNumberOfEnsembles();
                        }
                        // Check the min value
                        uint count = (MaxEnsembleNumber - MinEnsembleNumber) + 1;
                        if (count < 0)
                        {
                            count = 0;
                        }

                        for (x = MinEnsembleNumber; x < count; x++)
                        {
                            // Get the data from the reader
                            DataSet.Ensemble data = dbReader.GetEnsemble(_pm.SelectedProject, x);
                            if (data != null)
                            {
                                // Vessel Mount Options
                                VesselMountScreen(ref data);

                                // Screen the data
                                _screenDataVM.ScreenData(ref data, AdcpCodec.CodecEnum.Binary);

                                // Verify go data
                                if (data.IsEnsembleAvail && data.EnsembleData.EnsembleNumber != 0)
                                {
                                    try
                                    {
                                        // Write the data to the file
                                        writer.Write(data);
                                    }
                                    catch (Exception e)
                                    {
                                        log.Error(string.Format("Error writing file {0} {1}", dir + filename, x), e);
                                    }
                                }
                            }
                        }

                        // Close the writer and save the latest options
                        _Options = writer.Close();
                        //SaveDatabaseOptions();

                        // Remove the busy indicator
                        IsExporting = false;
                    }
                    catch (IOException ex)
                    {
                        System.Windows.MessageBox.Show("Export file is open or check file permissions for the folder.\n" + string.Format("{0}", dir + filename), "Export IO Error", System.Windows.MessageBoxButton.OK, System.Windows.MessageBoxImage.Error);
                        log.Error(string.Format("IO Error exporting file {0} {1}", dir + filename, x), ex);
                        if (writer != null)
                        {
                            writer.Close();
                            IsExporting = false;
                        }
                    }
                    catch (Exception e)
                    {
                        log.Error(string.Format("Error exporting file {0} {1}", dir + filename, x), e);
                        if (writer != null)
                        {
                            writer.Close();
                            IsExporting = false;
                        }
                    }
                }
            }
        }
示例#4
0
        /// <summary>
        /// Initialize the values.
        /// </summary>
        public ExportDataViewModel()
            : base("ExportViewModel")
        {
            // Initialize values
            _pm = IoC.Get <PulseManager>();
            _eventAggregator = IoC.Get <IEventAggregator>();
            _eventAggregator.Subscribe(this);
            _screenDataVM = IoC.Get <ScreenDataBaseViewModel>();                 // Get ScreenData VM

            IsExporting = false;

            _numEns = 0;
            if (_pm.IsProjectSelected)
            {
                ProjectName = _pm.SelectedProject.ProjectName;
                _numEns     = _pm.SelectedProject.GetNumberOfEnsembles();
            }

            // Bins
            MinimumBin = 0;
            if (_pm.IsProjectSelected && _numEns > 0)
            {
                MaximumBin = _pm.SelectedProject.GetFirstEnsemble().EnsembleData.NumBins - 1;
            }
            else
            {
                MaximumBin = DataSet.Ensemble.MAX_NUM_BINS;
            }

            // Ensemble Numbers
            MinEnsembleNumberEntry = 0;
            if (_pm.IsProjectSelected)
            {
                MaxEnsembleNumberEntry = (uint)_numEns - 1;
            }
            else
            {
                MaxEnsembleNumberEntry = 0;
            }

            // Coordinate Transform list
            CoordinateTransformList = new List <string>();
            CoordinateTransformList.Add(XFORM_BEAM);
            CoordinateTransformList.Add(XFORM_INSTRUMENT);
            CoordinateTransformList.Add(XFORM_EARTH);

            // Set the options
            _Options = _pm.AppConfiguration.GetExportDataOptions();
            UpdateProperties();

            // Check if options are set
            CheckOptions();

            // Export to CSV Command
            ExportCsvCommand = ReactiveCommand.CreateAsyncTask(this.WhenAny(x => x._numEns, x => x.Value > 0),
                                                               _ => ExportCsv());              // Load if there are ensembles in the project

            // Export to Matlab command
            ExportMatlabCommand = ReactiveCommand.CreateAsyncTask(this.WhenAny(x => x._numEns, x => x.Value > 0),
                                                                  _ => ExportMatlab());        // Load if there are ensembles in the project

            // Export to PD0 command
            ExportPd0Command = ReactiveCommand.CreateAsyncTask(this.WhenAny(x => x._numEns, x => x.Value > 0),
                                                               _ => ExportPd0());              // Load if there are ensembles in the project

            // Export to ENS command
            ExportEnsCommand = ReactiveCommand.CreateAsyncTask(this.WhenAny(x => x._numEns, x => x.Value > 0),
                                                               _ => ExportEns());              // Load if there are ensembles in the project
        }
示例#5
0
        /// <summary>
        /// Clone the options.
        /// </summary>
        /// <returns>Cloned options.</returns>
        public ExportOptions Clone()
        {
            ExportOptions newOptions = new ExportOptions();

            newOptions.MinEnsembleNumber                 = this.MinEnsembleNumber;
            newOptions.MaxEnsembleNumber                 = this.MaxEnsembleNumber;
            newOptions.MaxFileSize                       = this.MaxFileSize;
            newOptions.IsAmplitudeDataSetOn              = this.IsAmplitudeDataSetOn;
            newOptions.IsAncillaryDataSetOn              = this.IsAncillaryDataSetOn;
            newOptions.IsBeamVelocityDataSetOn           = this.IsBeamVelocityDataSetOn;
            newOptions.IsBottomTrackDataSetOn            = this.IsBottomTrackDataSetOn;
            newOptions.IsCorrelationDataSetOn            = this.IsCorrelationDataSetOn;
            newOptions.IsEarthVelocityDataSetOn          = this.IsEarthVelocityDataSetOn;
            newOptions.IsShipVelocityDataSetOn           = this.IsShipVelocityDataSetOn;
            newOptions.IsVelocityVectorDataSetOn         = this.IsVelocityVectorDataSetOn;
            newOptions.IsEarthWaterMassDataSetOn         = this.IsEarthWaterMassDataSetOn;
            newOptions.IsEnsembleDataSetOn               = this.IsEnsembleDataSetOn;
            newOptions.IsGoodBeamDataSetOn               = this.IsGoodBeamDataSetOn;
            newOptions.IsGoodEarthDataSetOn              = this.IsGoodEarthDataSetOn;
            newOptions.IsInstrumentVelocityDataSetOn     = this.IsInstrumentVelocityDataSetOn;
            newOptions.IsInstrumentWaterMassDataSetOn    = this.IsInstrumentWaterMassDataSetOn;
            newOptions.IsShipWaterMassDataSetOn          = this.IsShipWaterMassDataSetOn;
            newOptions.IsNmeaDataSetOn                   = this.IsNmeaDataSetOn;
            newOptions.IsProfileEngineeringDataSetOn     = this.IsProfileEngineeringDataSetOn;
            newOptions.IsBottomTrackEngineeringDataSetOn = this.IsBottomTrackEngineeringDataSetOn;
            newOptions.IsSystemSetupDataSetOn            = this.IsSystemSetupDataSetOn;
            newOptions.IsRangeTrackingDataSetOn          = this.IsRangeTrackingDataSetOn;
            newOptions.IsGageHeightDataSetOn             = this.IsGageHeightDataSetOn;
            newOptions.IsAdcpGpsDataSetOn                = this.IsAdcpGpsDataSetOn;
            newOptions.IsGps1DataSetOn                   = this.IsGps1DataSetOn;
            newOptions.IsGps2DataSetOn                   = this.IsGps2DataSetOn;
            newOptions.IsNmea1DataSetOn                  = this.IsNmea1DataSetOn;
            newOptions.IsNmea2DataSetOn                  = this.IsNmea2DataSetOn;
            newOptions.CoordinateTransform               = this.CoordinateTransform;
            newOptions.BeamMinBin           = this.BeamMinBin;
            newOptions.BeamMaxBin           = this.BeamMaxBin;
            newOptions.InstrumentMinBin     = this.InstrumentMinBin;
            newOptions.InstrumentMaxBin     = this.InstrumentMaxBin;
            newOptions.EarthMinBin          = this.EarthMinBin;
            newOptions.EarthMaxBin          = this.EarthMaxBin;
            newOptions.ShipMinBin           = this.ShipMinBin;
            newOptions.ShipMaxBin           = this.ShipMaxBin;
            newOptions.VelVectorMinBin      = this.VelVectorMinBin;
            newOptions.VelVectorMaxBin      = this.VelVectorMaxBin;
            newOptions.CorrelationMinBin    = this.CorrelationMinBin;
            newOptions.CorrelationMaxBin    = this.CorrelationMaxBin;
            newOptions.AmplitudeMinBin      = this.AmplitudeMinBin;
            newOptions.AmplitudeMaxBin      = this.AmplitudeMaxBin;
            newOptions.GoodBeamMinBin       = this.GoodBeamMinBin;
            newOptions.GoodBeamMaxBin       = this.GoodBeamMaxBin;
            newOptions.GoodEarthMinBin      = this.GoodEarthMinBin;
            newOptions.GoodEarthMaxBin      = this.GoodEarthMaxBin;
            newOptions.CorrelationThreshold = this.CorrelationThreshold;
            newOptions.PressureOffset       = this.PressureOffset;
            newOptions.IsRetransformData    = this.IsRetransformData;
            newOptions.IsMarkBadBelowBottom = this.IsMarkBadBelowBottom;
            newOptions.IsRemoveShipSpeedGPS = this.IsRemoveShipSpeedGPS;
            newOptions.IsRemoveShipSpeedBT  = this.IsRemoveShipSpeedBT;
            newOptions.HeadingOffset        = this.HeadingOffset;
            newOptions.PitchOffset          = this.PitchOffset;
            newOptions.RollOffset           = this.RollOffset;

            return(newOptions);
        }
示例#6
0
        /// <summary>
        /// Create the Amplitude header based off the options selected.
        /// </summary>
        /// <param name="options">Export Options.</param>
        /// <returns>Amplitude Header</returns>
        public static string CreateAmplitudeHeader(ExportOptions options)
        {
            StringBuilder sb = new StringBuilder();

            for (int bin = options.AmplitudeMinBin; bin < options.AmplitudeMaxBin + 1; bin++)
            {
                for (int beam = 0; beam < DataSet.Ensemble.DEFAULT_NUM_BEAMS_BEAM; beam++)
                {
                    sb.Append(string.Format("Amp{0}_{1},", bin, beam));
                }
            }

            return sb.ToString();
        }
示例#7
0
        /// <summary>
        /// Output the Beam Velocity dataset to CSV format.
        /// </summary>
        /// <param name="ensemble">Data.</param>
        /// <param name="options">Export Options.</param>
        /// <returns>Beam Velocity DataSet data in CSV format.</returns>
        public static string WriteBeamVelocityData(Ensemble ensemble, ExportOptions options)
        {
            StringBuilder sb = new StringBuilder();

            if (ensemble.IsBeamVelocityAvail)
            {
                for (int bin = options.BeamMinBin; bin < options.BeamMaxBin + 1; bin++)
                {
                    for (int beam = 0; beam < ensemble.BeamVelocityData.BeamVelocityData.GetLength(1); beam++)
                    {
                        sb.Append(string.Format("{0},", ensemble.BeamVelocityData.BeamVelocityData[bin, beam]));
                    }

                    // If a vertical beam
                    if (ensemble.BeamVelocityData.BeamVelocityData.GetLength(1) <= 1)
                    {
                        sb.Append(",,,");
                    }
                }
            }
            else
            {
                // Put blank data
                for (int bin = options.BeamMinBin; bin < options.BeamMaxBin + 1; bin++)
                {
                    sb.Append(",,,,");
                }
            }

            return sb.ToString();
        }
示例#8
0
 /// <summary>
 /// Initializes a new instance of the CsvExporterWriter class.
 /// </summary>
 public CsvExporterWriter()
 {
     _options = new ExportOptions();
 }
示例#9
0
        /// <summary>
        /// Get the Header for the CSV file.
        /// </summary>
        /// <param name="options">Export options.</param>
        /// <returns>CSV Header.</returns>
        public static string GetHeader(ExportOptions options)
        {
            StringBuilder sb = new StringBuilder();

            // Ensemble DataSet
            sb.Append(CreateEnsembleHeader());
            sb.Append(",");

            // Ancillary DataSet
            sb.Append(CreateAncillaryHeader());
            sb.Append(",");

            // Beam Velocity
            if (options.IsBeamVelocityDataSetOn)
            {
                sb.Append(CreateBeamVelocityHeader(options));
                sb.Append(",");
            }

            // Instrument Velocity
            if (options.IsInstrumentVelocityDataSetOn)
            {
                sb.Append(CreateInstrumentVelocityHeader(options));
                sb.Append(",");
            }

            // Earth Velocity
            if (options.IsEarthVelocityDataSetOn)
            {
                sb.Append(CreateEarthVelocityHeader(options));
                sb.Append(",");
            }

            // Amplitude DataSet
            if (options.IsAmplitudeDataSetOn)
            {
                sb.Append(CreateAmplitudeHeader(options));
                sb.Append(",");
            }

            // Correlation DataSet
            if (options.IsCorrelationDataSetOn)
            {
                sb.Append(CreateAmplitudeHeader(options));
                sb.Append(",");
            }

            // Earth Water Mass DataSet
            if (options.IsEarthWaterMassDataSetOn)
            {
                sb.Append(CreateEarthWaterMassHeader());
                sb.Append(",");
            }

            // Instrument Water Mass DataSet
            if (options.IsInstrumentWaterMassDataSetOn)
            {
                sb.Append(CreateInstrumentWaterMassHeader());
                sb.Append(",");
            }

            // Good Beam DataSet
            if (options.IsGoodBeamDataSetOn)
            {
                sb.Append(CreateGoodBeamHeader(options));
                sb.Append(",");
            }

            // Good Earth DataSet
            if (options.IsGoodEarthDataSetOn)
            {
                sb.Append(CreateGoodEarthHeader(options));
                sb.Append(",");
            }

            // Bottom Track DataSet
            if (options.IsBottomTrackDataSetOn)
            {
                sb.Append(CreateBottomTrackHeader());
                sb.Append(",");
            }

            // Bottom Track Engineering DataSet
            if (options.IsBottomTrackEngineeringDataSetOn)
            {
                sb.Append(CreateBottomTrackEngineeringHeader());
                sb.Append(",");
            }

            // Profile Engineering DataSet
            if (options.IsProfileEngineeringDataSetOn)
            {
                sb.Append(CreateProfileEngineeringHeader());
                sb.Append(",");
            }

            // System Setup DataSet
            if (options.IsSystemSetupDataSetOn)
            {
                sb.Append(CreateSystemSetupHeader());
                sb.Append(",");
            }

            return sb.ToString();
        }
示例#10
0
        /// <summary>
        /// Encode the given ensemble in a CSV format.  This will be
        /// based off the options given.
        /// </summary>
        /// <param name="ensemble">Ensemble to encode to CSV.</param>
        /// <param name="options">Options for encoding the CSV file.</param>
        /// <returns>A string of the ensemble in CSV format.</returns>
        public static string EncodeCSV(DataSet.Ensemble ensemble, ExportOptions options)
        {
            if (ensemble != null)
            {
                StringBuilder sb = new StringBuilder();

                // Ensemble Data
                sb.Append(WriteEnsembleData(ensemble));
                sb.Append(",");

                // Ancillary Data
                sb.Append(WriteAncillaryData(ensemble));
                sb.Append(",");

                // Beam Velocity
                if (options.IsBeamVelocityDataSetOn)
                {
                    sb.Append(WriteBeamVelocityData(ensemble, options));
                    sb.Append(",");
                }

                // Instrument Velocity
                if (options.IsInstrumentVelocityDataSetOn)
                {
                    sb.Append(WriteInstrumentVelocityData(ensemble, options));
                    sb.Append(",");
                }

                // Earth Velocity
                if (options.IsEarthVelocityDataSetOn)
                {
                    sb.Append(WriteEarthVelocityData(ensemble, options));
                    sb.Append(",");
                }

                // Amplitude Data
                if (options.IsAmplitudeDataSetOn)
                {
                    sb.Append(WriteAmplitudeData(ensemble, options));
                    sb.Append(",");
                }

                // Correlation Data
                if (options.IsCorrelationDataSetOn)
                {
                    sb.Append(WriteCorrelationData(ensemble, options));
                    sb.Append(",");
                }

                // Earth Water Mass Data
                if (options.IsEarthWaterMassDataSetOn)
                {
                    sb.Append(WriteEarthWaterMassData(ensemble));
                    sb.Append(",");
                }

                // Instrument Water Mass Data
                if (options.IsInstrumentWaterMassDataSetOn)
                {
                    sb.Append(WriteInstrumentWaterMassData(ensemble));
                    sb.Append(",");
                }

                // Good Beam Data
                if (options.IsGoodBeamDataSetOn)
                {
                    sb.Append(WriteGoodBeamData(ensemble, options));
                    sb.Append(",");
                }

                // Good Earth Data
                if (options.IsGoodEarthDataSetOn)
                {
                    sb.Append(WriteGoodEarthData(ensemble, options));
                    sb.Append(",");
                }

                // Bottom Track Data
                if (options.IsBottomTrackDataSetOn)
                {
                    sb.Append(WriteBottomTrackData(ensemble));
                    sb.Append(",");
                }

                // Bottom Track Engineering Data
                if (options.IsBottomTrackEngineeringDataSetOn)
                {
                    sb.Append(WriteBottomTrackEngineeringData(ensemble));
                    sb.Append(",");
                }

                // Profile Engineering Data
                if (options.IsProfileEngineeringDataSetOn)
                {
                    sb.Append(WriteProfileEngineeringData(ensemble));
                    sb.Append(",");
                }

                // System Setup Data
                if (options.IsSystemSetupDataSetOn)
                {
                    sb.Append(WriteSystemSetupData(ensemble));
                    sb.Append(",");
                }

                return sb.ToString();
            }

            return string.Empty;
        }
示例#11
0
        /// <summary>
        /// Open the file given and add the CSV header.
        /// </summary>
        /// <param name="filePath">File path to export the file to.</param>
        /// <param name="fileName">File Name to create.</param>
        /// <param name="options">Export options.</param>
        public void Open(string filePath, string fileName, ExportOptions options)
        {
            // Create the file name with file path
            string file = filePath + fileName;

            // Options
            _options = options;

            // If the writer exist, make sure it is closed
            if (_writer != null)
            {
                _writer.Close();
            }

            _writer = new StreamWriter(file, false);

            // Write the header
            _writer.WriteLine(GetHeader(options));
        }
示例#12
0
        /// <summary>
        /// Open the export to begin the writing process.
        /// The filename will be used to give the sub-filename.
        /// Files will be broken up by ensemble.
        /// </summary>
        /// <param name="filePath">File path to the write to.</param>
        /// <param name="fileName">Sub-Filename to use to for each file.</param>
        /// <param name="options">Export options.</param>
        public void Open(string filePath, string fileName, ExportOptions options)
        {
            //Set the file path and name
            _filePath = filePath;
            _fileName = fileName;
            _options = options;
            _fileSize = 0;

            _writer = new BinaryWriter(File.Open(_filePath + _fileName, FileMode.Append, FileAccess.Write));
        }
示例#13
0
        /// <summary>
        /// Output the Beam Velocity dataset to CSV format.
        /// </summary>
        /// <param name="ensemble">Data.</param>
        /// <param name="options">Export Options.</param>
        /// <returns>Beam Velocity DataSet data in CSV format.</returns>
        public static string WriteBeamVelocityData(Ensemble ensemble, ExportOptions options)
        {
            StringBuilder sb = new StringBuilder();

            if (ensemble.IsBeamVelocityAvail)
            {
                //// Check values
                //int minBin = options.BeamMinBin;
                //if (minBin >= ensemble.BeamVelocityData.BeamVelocityData.GetLength(0))
                //{
                //    minBin = 0;
                //}
                //int maxBin = options.BeamMaxBin;
                //if (maxBin >= ensemble.BeamVelocityData.BeamVelocityData.GetLength(0))
                //{
                //    maxBin = ensemble.BeamVelocityData.BeamVelocityData.GetLength(0) - 1;
                //}

                for (int bin = options.BeamMinBin; bin < options.BeamMaxBin + 1; bin++)
                {
                    for (int beam = 0; beam < ensemble.BeamVelocityData.BeamVelocityData.GetLength(1); beam++)
                    {
                        sb.Append(string.Format("{0},", ensemble.BeamVelocityData.BeamVelocityData[bin, beam].ToString(new CultureInfo("en-US"))));
                    }

                    // If a vertical beam
                    if (ensemble.BeamVelocityData.BeamVelocityData.GetLength(1) <= 1)
                    {
                        sb.Append(",,,");
                    }
                }
            }
            else
            {
                // Put blank data
                for (int bin = options.BeamMinBin; bin < options.BeamMaxBin + 1; bin++)
                {
                    sb.Append(",,,,");
                }
            }

            return sb.ToString();
        }
示例#14
0
        /// <summary>
        /// Output the Amplitude dataset to CSV format.
        /// </summary>
        /// <param name="ensemble">Data.</param>
        /// <param name="options">Export Options.</param>
        /// <returns>Amplitude DataSet data in CSV format.</returns>
        public static string WriteAmplitudeData(Ensemble ensemble, ExportOptions options)
        {
            StringBuilder sb = new StringBuilder();

            if (ensemble.IsAmplitudeAvail)
            {
                for (int bin = options.AmplitudeMinBin; bin < options.AmplitudeMaxBin + 1; bin++)
                {
                    for (int beam = 0; beam < ensemble.AmplitudeData.AmplitudeData.GetLength(1); beam++)
                    {
                        sb.Append(string.Format("{0},", ensemble.AmplitudeData.AmplitudeData[bin, beam].ToString(new CultureInfo("en-US"))));
                    }

                    // If a vertical beam
                    if (ensemble.AmplitudeData.AmplitudeData.GetLength(1) <= 1)
                    {
                        sb.Append(",,,");
                    }
                }
            }
            else
            {
                // Put blank data
                for (int bin = options.AmplitudeMinBin; bin < options.AmplitudeMaxBin + 1; bin++)
                {
                    sb.Append(",,,,");
                }
            }

            return sb.ToString();
        }
示例#15
0
        /// <summary>
        /// Encode the given ensemble in a CSV format.  This will be
        /// based off the options given.
        /// </summary>
        /// <param name="ensemble">Ensemble to encode to CSV.</param>
        /// <param name="options">Options for encoding the CSV file.</param>
        /// <returns>A string of the ensemble in CSV format.</returns>
        public static string EncodeCSV(DataSet.Ensemble ensemble, ExportOptions options)
        {
            if (ensemble != null)
            {
                StringBuilder sb = new StringBuilder();

                // Ensemble Data
                sb.Append(WriteEnsembleData(ensemble));
                sb.Append(",");

                // Ancillary Data
                sb.Append(WriteAncillaryData(ensemble));
                sb.Append(",");

                // Check values
                #region Check Values

                // Beam Velocity
                if (ensemble.IsBeamVelocityAvail)
                {
                    if (options.BeamMinBin >= ensemble.BeamVelocityData.BeamVelocityData.GetLength(0))
                    {
                        options.BeamMinBin = 0;
                        options.GoodBeamMinBin = 0;
                    }
                    if (options.BeamMaxBin >= ensemble.BeamVelocityData.BeamVelocityData.GetLength(0))
                    {
                        options.BeamMaxBin = ensemble.BeamVelocityData.BeamVelocityData.GetLength(0) - 1;
                        options.GoodBeamMaxBin = ensemble.BeamVelocityData.BeamVelocityData.GetLength(0) - 1;
                    }
                }

                // Instrument Velocity
                if (ensemble.IsInstrumentVelocityAvail)
                {
                    if (options.InstrumentMinBin >= ensemble.InstrumentVelocityData.InstrumentVelocityData.GetLength(0))
                    {
                        options.InstrumentMinBin = 0;
                    }
                    if (options.InstrumentMaxBin >= ensemble.InstrumentVelocityData.InstrumentVelocityData.GetLength(0))
                    {
                        options.InstrumentMaxBin = ensemble.InstrumentVelocityData.InstrumentVelocityData.GetLength(0) - 1;
                    }
                }

                // Earth Velocity
                if (ensemble.IsEarthVelocityAvail)
                {
                    if (options.EarthMinBin >= ensemble.EarthVelocityData.EarthVelocityData.GetLength(0))
                    {
                        options.EarthMinBin = 0;
                        options.GoodEarthMinBin = 0;
                    }
                    if (options.EarthMaxBin >= ensemble.EarthVelocityData.EarthVelocityData.GetLength(0))
                    {
                        options.EarthMaxBin = ensemble.EarthVelocityData.EarthVelocityData.GetLength(0) - 1;
                        options.GoodEarthMaxBin = ensemble.EarthVelocityData.EarthVelocityData.GetLength(0) - 1;
                    }
                }

                // Amplitude
                if (ensemble.IsAmplitudeAvail)
                {
                    if (options.AmplitudeMinBin >= ensemble.AmplitudeData.AmplitudeData.GetLength(0))
                    {
                        options.AmplitudeMinBin = 0;
                    }
                    if (options.AmplitudeMaxBin >= ensemble.AmplitudeData.AmplitudeData.GetLength(0))
                    {
                        options.AmplitudeMaxBin = ensemble.AmplitudeData.AmplitudeData.GetLength(0) - 1;
                    }
                }

                // Correlation
                if (ensemble.IsCorrelationAvail)
                {
                    if (options.CorrelationMinBin >= ensemble.CorrelationData.CorrelationData.GetLength(0))
                    {
                        options.CorrelationMinBin = 0;
                    }
                    if (options.CorrelationMaxBin >= ensemble.CorrelationData.CorrelationData.GetLength(0))
                    {
                        options.CorrelationMaxBin = ensemble.CorrelationData.CorrelationData.GetLength(0) - 1;
                    }
                }

                #endregion

                // Beam Velocity
                if (options.IsBeamVelocityDataSetOn)
                {
                    sb.Append(WriteBeamVelocityData(ensemble, options));
                    sb.Append(",");
                }

                // Instrument Velocity
                if (options.IsInstrumentVelocityDataSetOn)
                {
                    sb.Append(WriteInstrumentVelocityData(ensemble, options));
                    sb.Append(",");
                }

                // Earth Velocity
                if (options.IsEarthVelocityDataSetOn)
                {
                    sb.Append(WriteEarthVelocityData(ensemble, options));
                    sb.Append(",");
                }

                // Amplitude Data
                if (options.IsAmplitudeDataSetOn)
                {
                    sb.Append(WriteAmplitudeData(ensemble, options));
                    sb.Append(",");
                }

                // Correlation Data
                if (options.IsCorrelationDataSetOn)
                {
                    sb.Append(WriteCorrelationData(ensemble, options));
                    sb.Append(",");
                }

                // Earth Water Mass Data
                if (options.IsEarthWaterMassDataSetOn)
                {
                    sb.Append(WriteEarthWaterMassData(ensemble));
                    sb.Append(",");
                }

                // Instrument Water Mass Data
                if (options.IsInstrumentWaterMassDataSetOn)
                {
                    sb.Append(WriteInstrumentWaterMassData(ensemble));
                    sb.Append(",");
                }

                // Good Beam Data
                if (options.IsGoodBeamDataSetOn)
                {
                    sb.Append(WriteGoodBeamData(ensemble, options));
                    sb.Append(",");
                }

                // Good Earth Data
                if (options.IsGoodEarthDataSetOn)
                {
                    sb.Append(WriteGoodEarthData(ensemble, options));
                    sb.Append(",");
                }

                // Bottom Track Data
                if (options.IsBottomTrackDataSetOn)
                {
                    sb.Append(WriteBottomTrackData(ensemble));
                    sb.Append(",");
                }

                // Range Tracking Data
                if (options.IsRangeTrackingDataSetOn)
                {
                    sb.Append(WriteRangeTrackingData(ensemble));
                    sb.Append(",");
                }

                // Gage Height Data
                if (options.IsGageHeightDataSetOn)
                {
                    sb.Append(WriteGageHeightData(ensemble));
                    sb.Append(",");
                }

                // Bottom Track Engineering Data
                if (options.IsBottomTrackEngineeringDataSetOn)
                {
                    sb.Append(WriteBottomTrackEngineeringData(ensemble));
                    sb.Append(",");
                }

                // Profile Engineering Data
                if (options.IsProfileEngineeringDataSetOn)
                {
                    sb.Append(WriteProfileEngineeringData(ensemble));
                    sb.Append(",");
                }

                // System Setup Data
                if (options.IsSystemSetupDataSetOn)
                {
                    sb.Append(WriteSystemSetupData(ensemble));
                    sb.Append(",");
                }

                // Range Tracking Data
                if (options.IsRangeTrackingDataSetOn)
                {
                    sb.Append(WriteRangeTrackingData(ensemble));
                    sb.Append(",");
                }

                // NMEA Data
                if (options.IsNmeaDataSetOn)
                {
                    sb.Append(WriteNmeaData(ensemble));
                    sb.Append(",");
                }

                return sb.ToString();
            }

            return string.Empty;
        }