Example usage for org.joda.time DateTime getMonthOfYear

List of usage examples for org.joda.time DateTime getMonthOfYear

  1. HOME
  2. Java
  3. org.joda.time
  4. org.joda.time.*
  5. DateTime
  6. getMonthOfYear

Introduction

In this page you can find the example usage for org.joda.time DateTime getMonthOfYear.

Prototype

public int getMonthOfYear()

Source Link

Document

Get the month of year field value.

Usage

From source file:net.tourbook.device.garmin.GarminSAXHandler.java

License:Open Source License

/**
 * Check if date time starts with the date 2007-04-01, this can happen when the tcx file is
 * partly corrupt. When tour starts with the date 2007-04-01, move forward in the list until
 * another date occures and use this as the start date.
 *///from   w  w w .  j a  v  a  2s. c  o m
private void adjustTourStart() {

    int validIndex = 0;
    DateTime checkedTourStart = null;

    for (final TimeData timeData : _dtList) {

        checkedTourStart = new DateTime(timeData.absoluteTime);

        if (checkedTourStart.getYear() == 2007 && checkedTourStart.getMonthOfYear() == 4
                && checkedTourStart.getDayOfMonth() == 1) {

            // this is an invalid time slice

            validIndex++;
            continue;

        } else {

            // this is a valid time slice
            break;
        }
    }

    if (validIndex == 0) {

        // date is not 2007-04-01

        return;

    } else {

        if (validIndex == _dtList.size()) {

            // all time slices have the same "invalid" date 2007-04-01 but the date also could be valid

            return;
        }
    }

    /*
     * the date starts with 2007-04-01 but it changes to another date
     */

    final TimeData[] timeSlices = _dtList.toArray(new TimeData[_dtList.size()]);

    /*
     * get average time slice duration
     */
    long sliceAvgDuration;
    if (validIndex == 1) {

        sliceAvgDuration = 8;

    } else {

        long prevSliceTime = 0;
        long sliceDuration = 0;

        for (int sliceIndex = 0; sliceIndex < validIndex; sliceIndex++) {

            final long currentTime = timeSlices[sliceIndex].absoluteTime / 1000;

            if (sliceIndex > 0) {
                sliceDuration += currentTime - prevSliceTime;
            }

            prevSliceTime = currentTime;
        }

        sliceAvgDuration = sliceDuration / validIndex;
    }

    long validTime = timeSlices[validIndex].absoluteTime / 1000;
    long prevInvalidTime = 0;

    for (int sliceIndex = validIndex - 1; sliceIndex >= 0; sliceIndex--) {

        final TimeData timeSlice = timeSlices[sliceIndex];
        final long currentInvalidTime = timeSlice.absoluteTime / 1000;

        if (sliceIndex == validIndex - 1) {

            /*
             * this is the time slice before the valid time slices, use the average time slice
             * diff to get the time, because this time cannot be evaluated it is estimated
             */

            validTime = validTime - sliceAvgDuration;

        } else {

            final long timeDiff = prevInvalidTime - currentInvalidTime;
            validTime = validTime - timeDiff;
        }

        timeSlice.absoluteTime = validTime * 1000;
        prevInvalidTime = currentInvalidTime;
    }

    StatusUtil.log(//
            NLS.bind(//
                    Messages.Garmin_SAXHandler_InvalidDate_2007_04_01, _importFilePath,
                    new DateTime(_dtList.get(0).absoluteTime).toString()));
}

From source file:net.tourbook.device.garmin.GarminSAXHandler.java

License:Open Source License

private void finalizeTour() {

    // check if data are available
    if (_dtList.size() == 0) {
        return;/*from   w ww . j av  a2 s .c  o m*/
    }

    validateTimeSeries();

    // create data object for each tour
    final TourData tourData = new TourData();

    // set tour notes
    setTourNotes(tourData);

    /*
     * set tour start date/time
     */
    adjustTourStart();
    final DateTime dtTourStart = new DateTime(_dtList.get(0).absoluteTime);

    tourData.setStartHour((short) dtTourStart.getHourOfDay());
    tourData.setStartMinute((short) dtTourStart.getMinuteOfHour());
    tourData.setStartSecond((short) dtTourStart.getSecondOfMinute());

    tourData.setStartYear((short) dtTourStart.getYear());
    tourData.setStartMonth((short) dtTourStart.getMonthOfYear());
    tourData.setStartDay((short) dtTourStart.getDayOfMonth());

    tourData.setWeek(dtTourStart);

    tourData.setIsDistanceFromSensor(_isDistanceFromSensor);
    tourData.setDeviceTimeInterval((short) -1);
    tourData.importRawDataFile = _importFilePath;
    tourData.setTourImportFilePath(_importFilePath);

    tourData.createTimeSeries(_dtList, true);

    tourData.setDeviceModeName(_activitySport);

    tourData.setCalories(_tourCalories);

    // after all data are added, the tour id can be created
    final int[] distanceSerie = tourData.getMetricDistanceSerie();
    String uniqueKey;

    if (_deviceDataReader.isCreateTourIdWithRecordingTime) {

        /*
         * 25.5.2009: added recording time to the tour distance for the unique key because tour
         * export and import found a wrong tour when exporting was done with camouflage speed ->
         * this will result in a NEW tour
         */
        final int tourRecordingTime = tourData.getTourRecordingTime();

        if (distanceSerie == null) {
            uniqueKey = Integer.toString(tourRecordingTime);
        } else {

            final long tourDistance = distanceSerie[(distanceSerie.length - 1)];

            uniqueKey = Long.toString(tourDistance + tourRecordingTime);
        }

    } else {

        /*
         * original version to create tour id
         */
        if (distanceSerie == null) {
            uniqueKey = Util.UNIQUE_ID_SUFFIX_GARMIN_TCX;
        } else {
            uniqueKey = Integer.toString(distanceSerie[distanceSerie.length - 1]);
        }
    }

    final Long tourId = tourData.createTourId(uniqueKey);

    // check if the tour is already imported
    if (_tourDataMap.containsKey(tourId) == false) {

        tourData.computeAltitudeUpDown();
        tourData.computeTourDrivingTime();
        tourData.computeComputedValues();

        final String deviceName = _sport.creatorName;
        final String majorVersion = _sport.creatorVersionMajor;
        final String minorVersion = _sport.creatorVersionMinor;

        tourData.setDeviceId(_deviceDataReader.deviceId);

        tourData.setDeviceName(
                _deviceDataReader.visibleName + (deviceName == null ? UI.EMPTY_STRING : UI.SPACE + deviceName));

        tourData.setDeviceFirmwareVersion(majorVersion == null //
                ? UI.EMPTY_STRING
                : majorVersion + (minorVersion == null //
                        ? UI.EMPTY_STRING
                        : UI.DOT + minorVersion));

        // add new tour to other tours
        _tourDataMap.put(tourId, tourData);
    }

    _isImported = true;
}

From source file:net.tourbook.device.gpx.GPX_SAX_Handler.java

License:Open Source License

private void finalizeTour() {

    if (_timeDataList.size() == 0) {
        // there is not data
        return;//  w w w  . j a  va  2s .  c o  m
    }

    final TimeData firstTimeData = _timeDataList.get(0);

    // create data object for each tour
    final TourData tourData = new TourData();

    tourData.setTourTitle(_trkName);

    /*
     * set tour start date/time
     */
    final DateTime dtTourStart = new DateTime(firstTimeData.absoluteTime);

    tourData.setStartYear((short) dtTourStart.getYear());
    tourData.setStartMonth((short) dtTourStart.getMonthOfYear());
    tourData.setStartDay((short) dtTourStart.getDayOfMonth());

    tourData.setStartHour((short) dtTourStart.getHourOfDay());
    tourData.setStartMinute((short) dtTourStart.getMinuteOfHour());
    tourData.setStartSecond((short) dtTourStart.getSecondOfMinute());

    tourData.setWeek(tourData.getStartYear(), tourData.getStartMonth(), tourData.getStartDay());

    tourData.setDeviceTimeInterval((short) -1);
    tourData.setTemperatureScale(TourbookDevice.TEMPERATURE_SCALE);

    tourData.importRawDataFile = _importFilePath;
    tourData.setTourImportFilePath(_importFilePath);

    tourData.createTimeSeries(_timeDataList, true);
    tourData.computeAltitudeUpDown();

    tourData.setWayPoints(_wptList);

    /*
     * adjust default marker which are created in tourData.createTimeSeries()
     */
    for (final TourMarker tourMarker : tourData.getTourMarkers()) {

        tourMarker.setVisualPosition(ChartLabel.VISUAL_VERTICAL_BOTTOM_CHART);

        // disable time/distance
        tourMarker.setTime(-1);
        tourMarker.setDistance(-1);
    }

    // after all data are added, the tour id can be created
    final int[] distanceSerie = tourData.getMetricDistanceSerie();
    String uniqueKey;

    if (_deviceDataReader.isCreateTourIdWithRecordingTime) {

        /*
         * 23.3.2009: added recording time to the tour distance for the unique key because tour
         * export and import found a wrong tour when exporting was done with camouflage speed ->
         * this will result in a NEW tour
         */
        final int tourRecordingTime = tourData.getTourRecordingTime();

        if (distanceSerie == null) {
            uniqueKey = Integer.toString(tourRecordingTime);
        } else {

            final long tourDistance = distanceSerie[(distanceSerie.length - 1)];

            uniqueKey = Long.toString(tourDistance + tourRecordingTime);
        }

    } else {

        /*
         * original version to create tour id
         */
        if (distanceSerie == null) {
            uniqueKey = Util.UNIQUE_ID_SUFFIX_GPX;
        } else {
            uniqueKey = Integer.toString(distanceSerie[distanceSerie.length - 1]);
        }
    }

    final Long tourId = tourData.createTourId(uniqueKey);

    // check if the tour is already imported
    if (_tourDataMap.containsKey(tourId) == false) {

        tourData.computeTourDrivingTime();
        tourData.computeComputedValues();

        tourData.setDeviceId(_deviceDataReader.deviceId);
        tourData.setDeviceName(_deviceDataReader.visibleName);

        // add new tour to other tours
        _tourDataMap.put(tourId, tourData);
    }

    _isImported = true;
}

From source file:net.tourbook.device.polar.hrm.PolarHRMDataReader.java

License:Open Source License

private void createTourData(final HashMap<Long, TourData> tourDataMap) {

    // create data object for each tour
    final TourData tourData = new TourData();

    /*/*from   w  w  w  .java2 s . co m*/
     * set tour start date/time
     */
    final DateTime dtTourStart = new DateTime(_sectionParams.startYear, _sectionParams.startMonth,
            _sectionParams.startDay, _sectionParams.startHour, _sectionParams.startMinute,
            _sectionParams.startSecond, 0);

    tourData.setStartHour((short) dtTourStart.getHourOfDay());
    tourData.setStartMinute((short) dtTourStart.getMinuteOfHour());
    tourData.setStartSecond((short) dtTourStart.getSecondOfMinute());

    tourData.setStartYear((short) dtTourStart.getYear());
    tourData.setStartMonth((short) dtTourStart.getMonthOfYear());
    tourData.setStartDay((short) dtTourStart.getDayOfMonth());

    tourData.setWeek(dtTourStart);

    tourData.setDeviceTimeInterval((short) _sectionParams.mtInterval);

    tourData.importRawDataFile = _importFilePath;
    tourData.setTourImportFilePath(_importFilePath);

    //      tourData.setCalories(_calories);
    tourData.setRestPulse(_sectionParams.restHR == Integer.MIN_VALUE ? 0 : _sectionParams.restHR);

    if (_sectionTrip != null) {
        tourData.setStartDistance(_sectionTrip.odometer == Integer.MIN_VALUE ? 0 : _sectionTrip.odometer);
    }

    final ArrayList<TimeData> timeSeries = createTourData10CreateTimeSeries(dtTourStart);
    createTourData20SetTemperature(tourData, timeSeries);

    tourData.createTimeSeries(timeSeries, true);

    createTourData30CreateMarkers(tourData);
    tourData.computeAltitudeUpDown();

    // after all data are added, the tour id can be created
    final Long tourId = tourData.createTourId(createUniqueId(tourData, Util.UNIQUE_ID_SUFFIX_POLAR_HRM));

    // check if the tour is already imported
    if (tourDataMap.containsKey(tourId) == false) {

        tourData.computeTourDrivingTime();
        tourData.computeComputedValues();

        tourData.setDeviceId(deviceId);
        tourData.setDeviceName(_sectionParams.monitorName);
        tourData.setDeviceFirmwareVersion(Integer.toString(_hrmVersion));

        // add new tour to other tours
        tourDataMap.put(tourId, tourData);
    }
}

From source file:net.tourbook.device.polartrainer.PolarTrainerSAXHandler.java

License:Open Source License

private void finalizeTour() throws InvalidDeviceSAXException {

    if (finalizeTour10CreateTimeSlices() == false) {
        _isImported = false;/*from   w w w  .  j  av a2 s .  c  o m*/
        return;
    }

    // create data object for each tour
    final TourData tourData = new TourData();

    /*
     * set tour start date/time
     */
    final DateTime tourStart = _currentExercise.tourStart;

    tourData.setStartHour((short) tourStart.getHourOfDay());
    tourData.setStartMinute((short) tourStart.getMinuteOfHour());
    tourData.setStartSecond((short) tourStart.getSecondOfMinute());

    tourData.setStartYear((short) tourStart.getYear());
    tourData.setStartMonth((short) tourStart.getMonthOfYear());
    tourData.setStartDay((short) tourStart.getDayOfMonth());

    tourData.setWeek(tourStart);

    tourData.setDeviceTimeInterval(_currentExercise.timeInterval);

    tourData.setTemperatureScale(TourbookDevice.TEMPERATURE_SCALE);
    tourData.importRawDataFile = _importFilePath;

    tourData.setTourImportFilePath(_importFilePath);

    tourData.setTourTitle(_currentExercise.tourTitle);
    tourData.setCalories(_currentExercise.calories);
    tourData.setRestPulse(_currentExercise.restPulse);

    tourData.createTimeSeries(_timeSlices, true);

    finalizeTour20CreateMarkers(tourData);
    finalizeTour30SetTourType(tourData);

    tourData.computeAltitudeUpDown();

    // after all data are added, the tour id can be created
    final Long tourId = tourData
            .createTourId(_device.createUniqueId(tourData, Util.UNIQUE_ID_SUFFIX_POLAR_TRAINER));

    // check if the tour is already imported
    if (_tourDataMap.containsKey(tourId) == false) {

        tourData.computeTourDrivingTime();
        tourData.computeComputedValues();

        tourData.setDeviceId(_device.deviceId);
        tourData.setDeviceName(DEVICE_NAME_POLAR_PERSONALTRAINER);

        tourData.setDeviceFirmwareVersion(_dataVersion == 1 ? TAG_ROOT_VERSION_1 : UI.EMPTY_STRING);

        // add new tour to other tours
        _tourDataMap.put(tourId, tourData);
    }

    _isImported = true;
}

From source file:net.tourbook.device.sporttracks.FitLogSAXHandler.java

License:Open Source License

private void finalizeTour() {

    boolean isComputeDrivingTime = true;

    // create data object for each tour
    final TourData tourData = new TourData();

    /*//from  w  w w  .  j a  v  a2 s. c  o  m
     * set tour start date/time
     */
    //      DateTime tourDateTime = _currentActivity.trackTourDateTime;
    //      final long trackStartTime = _currentActivity.trackTourStartTime;
    //      if (trackStartTime != Long.MIN_VALUE && trackStartTime < 0) {
    //
    //         // this case occured, e.g. year was 0002
    //         tourDateTime = _currentActivity.tourStartTime;
    //
    //      } else if (tourDateTime == null) {
    //
    //         // this case can occure when a tour do not have a track
    //         tourDateTime = _currentActivity.tourStartTime;
    //      }
    final DateTime tourStartTime = _currentActivity.tourStartTime;

    tourData.setStartHour((short) tourStartTime.getHourOfDay());
    tourData.setStartMinute((short) tourStartTime.getMinuteOfHour());
    tourData.setStartSecond((short) tourStartTime.getSecondOfMinute());

    tourData.setStartYear((short) tourStartTime.getYear());
    tourData.setStartMonth((short) tourStartTime.getMonthOfYear());
    tourData.setStartDay((short) tourStartTime.getDayOfMonth());

    tourData.setWeek(tourStartTime);

    tourData.setTourTitle(_currentActivity.name);
    tourData.setTourDescription(_currentActivity.notes);
    tourData.setTourStartPlace(_currentActivity.location);

    tourData.setCalories(_currentActivity.calories);

    /*
     * weather
     */
    tourData.setWeather(_currentActivity.weatherText);
    tourData.setWeatherClouds(_weatherId.get(_currentActivity.weatherConditions));

    final float weatherTemperature = _currentActivity.weatherTemperature;
    if (weatherTemperature != Float.MIN_VALUE) {
        tourData.setTemperatureScale(TourbookDevice.TEMPERATURE_SCALE);
        tourData.setAvgTemperature((int) (weatherTemperature * TourbookDevice.TEMPERATURE_SCALE));
    }

    tourData.importRawDataFile = _importFilePath;
    tourData.setTourImportFilePath(_importFilePath);

    tourData.setDeviceTimeInterval((short) -1);

    if (_currentActivity.timeSlices.size() == 0) {

        // tour do not contain a track

        tourData.setTourDistance(_currentActivity.distance);

        tourData.setTourRecordingTime(_currentActivity.duration);
        tourData.setTourDrivingTime(_currentActivity.duration);
        isComputeDrivingTime = false;

        tourData.setTourAltUp(_currentActivity.elevationUp);
        tourData.setTourAltDown(_currentActivity.elevationDown);

    } else {
        tourData.createTimeSeries(_currentActivity.timeSlices, false);
    }

    // after all data are added, the tour id can be created because it depends on the tour distance
    final Long tourId = tourData
            .createTourId(_device.createUniqueId(tourData, Util.UNIQUE_ID_SUFFIX_SPORT_TRACKS_FITLOG));

    // check if the tour is already imported
    if (_tourDataMap.containsKey(tourId) == false) {

        if (isComputeDrivingTime) {
            tourData.computeTourDrivingTime();
        }
        tourData.computeAltitudeUpDown();
        tourData.computeComputedValues();

        if (tourData.pulseSerie == null) {
            tourData.setAvgPulse(_currentActivity.avgPulse);
            tourData.setMaxPulse(_currentActivity.maxPulse);
        }

        if (tourData.cadenceSerie == null) {
            tourData.setAvgCadence(_currentActivity.avgCadence);
        }

        tourData.setDeviceId(_device.deviceId);
        tourData.setDeviceName(_device.visibleName);

        finalizeTour10SetTourType(tourData);
        finalizeTour20SetTags(tourData);
        finalizeTour30CreateMarkers(tourData);

        // add new tour to other tours
        _tourDataMap.put(tourId, tourData);
    }

    // cleanup
    _currentActivity.timeSlices.clear();
    _currentActivity.laps.clear();
    _currentActivity.equipmentName.clear();

    _isImported = true;
}

From source file:net.tourbook.export.gpx.DialogExportTour.java

License:Open Source License

/**
 * Set filename with the first tour date/time, when tour is merged "<#default>" is displayed
 *///from   w w w.  ja  va  2  s .c  o m
private void setFileName() {

    // search for the first tour
    TourData minTourData = null;
    final long minTourMillis = 0;

    for (final TourData tourData : _tourDataList) {
        final DateTime checkingTourDate = TourManager.getTourDateTime(tourData);

        if (minTourData == null) {
            minTourData = tourData;
        } else {

            final long tourMillis = checkingTourDate.getMillis();
            if (tourMillis < minTourMillis) {
                minTourData = tourData;
            }
        }
    }

    if (_isMultipleTourAndMultipleFile) {

        // use default file name for each exported tour

        _comboFile.setText(Messages.dialog_export_label_DefaultFileName);

    } else if ((_tourDataList.size() == 1) && (_tourStartIndex != -1) && (_tourEndIndex != -1)) {

        // display the start date/time

        final DateTime dtTour = new DateTime(minTourData.getStartYear(), minTourData.getStartMonth(),
                minTourData.getStartDay(), minTourData.getStartHour(), minTourData.getStartMinute(),
                minTourData.getStartSecond(), 0);

        // adjust start time
        final int startTime = minTourData.timeSerie[_tourStartIndex];
        final DateTime tourTime = dtTour.plusSeconds(startTime);

        _comboFile.setText(UI.format_yyyymmdd_hhmmss(tourTime.getYear(), tourTime.getMonthOfYear(),
                tourTime.getDayOfMonth(), tourTime.getHourOfDay(), tourTime.getMinuteOfHour(),
                tourTime.getSecondOfMinute()));
    } else {

        // display the tour date/time

        _comboFile.setText(UI.format_yyyymmdd_hhmmss(minTourData));
    }
}

From source file:net.tourbook.printing.DialogPrintTour.java

License:Open Source License

/**
 * Overwrite filename with the first tour date/time when the tour is not merged
 *//*from   w  w w .ja v a  2 s . c o m*/
private void setFileName() {

    // search for the first tour
    TourData minTourData = null;
    final long minTourMillis = 0;

    for (final TourData tourData : _tourDataList) {
        final DateTime checkingTourDate = TourManager.getTourDateTime(tourData);

        if (minTourData == null) {
            minTourData = tourData;
        } else {

            final long tourMillis = checkingTourDate.getMillis();
            if (tourMillis < minTourMillis) {
                minTourData = tourData;
            }
        }
    }

    if ((_tourDataList.size() == 1) && (_tourStartIndex != -1) && (_tourEndIndex != -1)) {

        // display the start date/time

        final DateTime dtTour = new DateTime(minTourData.getStartYear(), minTourData.getStartMonth(),
                minTourData.getStartDay(), minTourData.getStartHour(), minTourData.getStartMinute(),
                minTourData.getStartSecond(), 0);

        final int startTime = minTourData.timeSerie[_tourStartIndex];
        final DateTime tourTime = dtTour.plusSeconds(startTime);

        _comboFile.setText(UI.format_yyyymmdd_hhmmss(tourTime.getYear(), tourTime.getMonthOfYear(),
                tourTime.getDayOfMonth(), tourTime.getHourOfDay(), tourTime.getMinuteOfHour(),
                tourTime.getSecondOfMinute()));
    } else {

        // display the tour date/time

        _comboFile.setText(UI.format_yyyymmdd_hhmmss(minTourData));
    }
}

From source file:net.tourbook.tour.DialogExtractTour.java

License:Open Source License

/**
 * Create a new tour with the extracted time slices
 *//* w ww.  j  a v a  2s .co m*/
private boolean extractTour() {

    /*
     * get data series
     */
    final int[] tourAltitudeSerie = _tourDataSource.altitudeSerie;
    final int[] tourCadenceSerie = _tourDataSource.cadenceSerie;
    final int[] tourDistanceSerie = _tourDataSource.distanceSerie;
    final double[] tourLatitudeSerie = _tourDataSource.latitudeSerie;
    final double[] tourLongitudeSerie = _tourDataSource.longitudeSerie;
    final int[] tourPulseSerie = _tourDataSource.pulseSerie;
    final int[] tourTemperatureSerie = _tourDataSource.temperatureSerie;
    final int[] tourTimeSerie = _tourDataSource.timeSerie;

    final boolean isTourAltitude = (tourAltitudeSerie != null) && (tourAltitudeSerie.length > 0);
    final boolean isTourCadence = (tourCadenceSerie != null) && (tourCadenceSerie.length > 0);
    final boolean isTourDistance = (tourDistanceSerie != null) && (tourDistanceSerie.length > 0);
    final boolean isTourLat = (tourLatitudeSerie != null) && (tourLatitudeSerie.length > 0);
    final boolean isTourLon = (tourLongitudeSerie != null) && (tourLongitudeSerie.length > 0);
    final boolean isTourPulse = (tourPulseSerie != null) && (tourPulseSerie.length > 0);
    final boolean isTourTemperature = (tourTemperatureSerie != null) && (tourTemperatureSerie.length > 0);
    final boolean isTourTime = (tourTimeSerie != null) && (tourTimeSerie.length > 0);

    /*
     * get speed/power data when data are created by the device
     */
    int[] tourPowerSerie = null;
    int[] tourSpeedSerie = null;
    final boolean isTourPower = _tourDataSource.isPowerSerieFromDevice();
    final boolean isTourSpeed = _tourDataSource.isSpeedSerieFromDevice();
    if (isTourPower) {
        tourPowerSerie = _tourDataSource.getPowerSerie();
    }
    if (isTourSpeed) {
        tourSpeedSerie = _tourDataSource.getSpeedSerie();
    }

    int dataSerieLength = -1;

    if (isTourAltitude) {
        dataSerieLength = tourAltitudeSerie.length;
    } else if (isTourCadence) {
        dataSerieLength = tourCadenceSerie.length;
    } else if (isTourDistance) {
        dataSerieLength = tourDistanceSerie.length;
    } else if (isTourLat) {
        dataSerieLength = tourLatitudeSerie.length;
    } else if (isTourLon) {
        dataSerieLength = tourLongitudeSerie.length;
    } else if (isTourPower) {
        dataSerieLength = tourPowerSerie.length;
    } else if (isTourPulse) {
        dataSerieLength = tourPulseSerie.length;
    } else if (isTourSpeed) {
        dataSerieLength = tourSpeedSerie.length;
    } else if (isTourTemperature) {
        dataSerieLength = tourTemperatureSerie.length;
    } else if (isTourTime) {
        dataSerieLength = tourTimeSerie.length;
    }

    if (dataSerieLength == -1) {
        StatusUtil.showStatus(Messages.NT001_DialogExtractTour_InvalidTourData);
        return false;
    }

    if (_isSplitTour) {
        // _extractEndIndex contains -1, set end index to the last time slice
        _extractEndIndex = dataSerieLength - 1;
    }

    final int extractSerieLength = _extractEndIndex - _extractStartIndex + 1;

    final int[] extractAltitudeSerie = new int[extractSerieLength];
    final int[] extractCadenceSerie = new int[extractSerieLength];
    final int[] extractDistanceSerie = new int[extractSerieLength];
    final double[] extractLatitudeSerie = new double[extractSerieLength];
    final double[] extractLongitudeSerie = new double[extractSerieLength];
    final int[] extractPowerSerie = new int[extractSerieLength];
    final int[] extractPulseSerie = new int[extractSerieLength];
    final int[] extractSpeedSerie = new int[extractSerieLength];
    final int[] extractTemperatureSerie = new int[extractSerieLength];
    final int[] extractTimeSerie = new int[extractSerieLength];

    final HashSet<TourMarker> extractedTourMarker = new HashSet<TourMarker>();
    final ArrayList<TourWayPoint> extractedWayPoints = new ArrayList<TourWayPoint>();

    /*
     * get start date/time
     */
    DateTime extractedTourStart = null;
    final boolean isOriginalTime = _chkKeepOriginalDateTime.getSelection();
    if (isOriginalTime) {
        extractedTourStart = _extractedTourStartTime;
    } else {
        extractedTourStart = new DateTime(_dtTourDate.getYear(), _dtTourDate.getMonth() + 1,
                _dtTourDate.getDay(), _dtTourTime.getHours(), _dtTourTime.getMinutes(),
                _dtTourTime.getSeconds(), 0);
    }

    int relTourStartTime = 0;
    int extractedRecordingTime = 0;
    if (isTourTime) {
        relTourStartTime = tourTimeSerie[_extractStartIndex];
        extractedRecordingTime = tourTimeSerie[_extractEndIndex] - relTourStartTime;
    }

    // get distance
    int extractedDistance = 0;
    int relTourStartDistance = 0;
    if (isTourDistance) {
        relTourStartDistance = tourDistanceSerie[_extractStartIndex];
        extractedDistance = tourDistanceSerie[_extractEndIndex] - relTourStartDistance;
    }

    /*
     * copy existing data series
     */
    int extractedSerieIndex = 0;
    for (int sourceSerieIndex = _extractStartIndex; sourceSerieIndex <= _extractEndIndex; sourceSerieIndex++) {

        if (isTourTime) {
            extractTimeSerie[extractedSerieIndex] = tourTimeSerie[sourceSerieIndex] - relTourStartTime;
        }

        if (isTourAltitude) {
            extractAltitudeSerie[extractedSerieIndex] = tourAltitudeSerie[sourceSerieIndex];
        }
        if (isTourCadence) {
            extractCadenceSerie[extractedSerieIndex] = tourCadenceSerie[sourceSerieIndex];
        }

        if (isTourDistance) {
            extractDistanceSerie[extractedSerieIndex] = tourDistanceSerie[sourceSerieIndex]
                    - relTourStartDistance;
        }

        if (isTourPulse) {
            extractPulseSerie[extractedSerieIndex] = tourPulseSerie[sourceSerieIndex];
        }
        if (isTourLat) {
            extractLatitudeSerie[extractedSerieIndex] = tourLatitudeSerie[sourceSerieIndex];
        }
        if (isTourLon) {
            extractLongitudeSerie[extractedSerieIndex] = tourLongitudeSerie[sourceSerieIndex];
        }
        if (isTourTemperature) {
            extractTemperatureSerie[extractedSerieIndex] = tourTemperatureSerie[sourceSerieIndex];
        }
        if (isTourPower) {
            extractPowerSerie[extractedSerieIndex] = tourPowerSerie[sourceSerieIndex];
        }
        if (isTourSpeed) {
            extractSpeedSerie[extractedSerieIndex] = tourSpeedSerie[sourceSerieIndex];
        }

        extractedSerieIndex++;
    }

    /*
     * get tour markers, way points
     */
    final Set<TourMarker> tourMarkers = _tourDataSource.getTourMarkers();
    if (_chkIncludeMarkerWaypoints.getSelection()) {

        for (final TourMarker tourMarker : tourMarkers) {

            final int markerSerieIndex = tourMarker.getSerieIndex();

            // skip marker which are not within the extracted time slices
            if (markerSerieIndex < _extractStartIndex || markerSerieIndex > _extractEndIndex) {
                continue;
            }

            final int extractedMarkerIndex = markerSerieIndex - _extractStartIndex;

            final TourMarker extractedMarker = tourMarker.clone(_tourDataTarget);

            // adjust marker position, position is relativ to the tour start
            extractedMarker.setSerieIndex(extractedMarkerIndex);

            if (isTourTime) {
                tourMarker.setTime(extractTimeSerie[extractedMarkerIndex]);
            }
            if (isTourDistance) {
                tourMarker.setDistance(extractDistanceSerie[extractedMarkerIndex]);
            }

            extractedTourMarker.add(extractedMarker);
        }

        /*
         * copy all way points, they can be independant of the tour
         */
        for (final TourWayPoint wayPoint : _tourDataSource.getTourWayPoints()) {
            extractedWayPoints.add((TourWayPoint) wayPoint.clone());
        }
    }

    // get description
    String extractedDescription = UI.EMPTY_STRING;
    if (_chkIncludeDescription.getSelection()) {
        extractedDescription = _tourDataSource.getTourDescription();
    }

    /*
     * get calories
     */
    int extractedCalories = 0;
    if (_extractStartIndex == 0 && _extractEndIndex == (dataSerieLength - 1)) {

        // tour is copied, the calories can also be copied
        extractedCalories = _tourDataSource.getCalories();

    } else {
        // TODO calories should be set when they are computed
    }

    /*
     * set target tour data
     */
    _tourDataTarget.setStartYear((short) extractedTourStart.getYear());
    _tourDataTarget.setStartMonth((short) extractedTourStart.getMonthOfYear());
    _tourDataTarget.setStartDay((short) extractedTourStart.getDayOfMonth());
    _tourDataTarget.setStartHour((short) extractedTourStart.getHourOfDay());
    _tourDataTarget.setStartMinute((short) extractedTourStart.getMinuteOfHour());
    _tourDataTarget.setStartSecond((short) extractedTourStart.getSecondOfMinute());

    _tourDataTarget.setWeek(extractedTourStart);

    // tour id must be created after the tour date/time is set
    _tourDataTarget.createTourId();

    _tourDataTarget.setTourTitle(_txtTourTitle.getText());
    _tourDataTarget.setTourDescription(extractedDescription.toString());

    _tourDataTarget.setTourMarkers(extractedTourMarker);
    _tourDataTarget.setWayPoints(extractedWayPoints);
    _tourDataTarget.setDeviceName(_isSplitTour ? Messages.Dialog_SplitTour_Label_DeviceName
            : Messages.Dialog_ExtractTour_Label_DeviceName);

    _tourDataTarget.setIsDistanceFromSensor(_tourDataSource.isDistanceSensorPresent());
    _tourDataTarget.setDeviceTimeInterval(_tourDataSource.getDeviceTimeInterval());

    _tourDataTarget.setTourRecordingTime(extractedRecordingTime);
    _tourDataTarget.setTourDistance(extractedDistance);

    _tourDataTarget.setWeather(_tourDataSource.getWeather());
    _tourDataTarget.setWeatherClouds(_tourDataSource.getWeatherClouds());
    _tourDataTarget.setWeatherWindDir(_tourDataSource.getWeatherWindDir());
    _tourDataTarget.setWeatherWindSpeed(_tourDataSource.getWeatherWindSpeed());

    _tourDataTarget.setRestPulse(_tourDataSource.getRestPulse());
    _tourDataTarget.setCalories(extractedCalories);

    _tourDataTarget.setDpTolerance(_tourDataSource.getDpTolerance());

    if (isTourAltitude) {
        _tourDataTarget.altitudeSerie = extractAltitudeSerie;
    }
    if (isTourDistance) {
        _tourDataTarget.distanceSerie = extractDistanceSerie;
    }
    if (isTourCadence) {
        _tourDataTarget.cadenceSerie = extractCadenceSerie;
    }
    if (isTourLat) {
        _tourDataTarget.latitudeSerie = extractLatitudeSerie;
    }
    if (isTourLon) {
        _tourDataTarget.longitudeSerie = extractLongitudeSerie;
    }
    if (isTourPower) {
        _tourDataTarget.setPowerSerie(extractPowerSerie);
    }
    if (isTourPulse) {
        _tourDataTarget.pulseSerie = extractPulseSerie;
    }
    if (isTourSpeed) {
        _tourDataTarget.setSpeedSerie(extractSpeedSerie);
    }
    if (isTourTemperature) {
        _tourDataTarget.temperatureSerie = extractTemperatureSerie;
    }
    if (isTourTime) {
        _tourDataTarget.timeSerie = extractTimeSerie;
    }

    _tourDataTarget.setTemperatureScale(_tourDataSource.getTemperatureScale());

    _tourDataTarget.computeAltitudeUpDown();
    _tourDataTarget.computeTourDrivingTime();
    _tourDataTarget.computeComputedValues();

    // set person which is required to save a tour
    _tourDataTarget.setTourPerson(getSelectedPerson());

    /*
     * check size of the fields
     */
    if (_tourDataTarget.isValidForSave() == false) {
        return false;
    }

    TourManager.saveModifiedTour(_tourDataTarget);

    // check if time slices should be removed
    if (getStateSplitMethod().equals(STATE_EXTRACT_METHOD_REMOVE)) {

        TourManager.removeTimeSlices(_tourDataSource, _extractStartIndex, _extractEndIndex, true);

        _tourDataEditor.updateUI(_tourDataSource, true);

        TourManager.fireEvent(TourEventId.TOUR_CHANGED, new TourEvent(_tourDataSource));
    }

    return true;
}

From source file:net.tourbook.tour.DialogJoinTours.java

License:Open Source License

/**
 * Join the tours and create a new tour/*  www. ja  v a  2  s .  c  o m*/
 */
private boolean joinTours() {

    final boolean isOriginalTime = getStateJoinMethod().equals(STATE_JOIN_METHOD_ORIGINAL);

    /**
     * number of slices, time series are already checked in ActionJoinTours
     */
    int joinedSliceCounter = 0;

    for (final TourData tourData : _selectedTours) {

        final int[] tourTimeSerie = tourData.timeSerie;
        final int[] tourDistanceSerie = tourData.distanceSerie;
        final double[] tourLatitudeSerie = tourData.latitudeSerie;

        final boolean isTourTime = (tourTimeSerie != null) && (tourTimeSerie.length > 0);
        final boolean isTourDistance = (tourDistanceSerie != null) && (tourDistanceSerie.length > 0);
        final boolean isTourLat = (tourLatitudeSerie != null) && (tourLatitudeSerie.length > 0);

        if (isTourTime) {
            joinedSliceCounter += tourTimeSerie.length;
        } else if (isTourDistance) {
            joinedSliceCounter += tourDistanceSerie.length;
        } else if (isTourLat) {
            joinedSliceCounter += tourLatitudeSerie.length;
        }
    }

    boolean isJoinAltitude = false;
    boolean isJoinDistance = false;
    boolean isJoinCadence = false;
    boolean isJoinLat = false;
    boolean isJoinLon = false;
    boolean isJoinPower = false;
    boolean isJoinPulse = false;
    boolean isJoinSpeed = false;
    //      boolean isJoinTemperature = false;
    boolean isJoinTime = false;

    final int[] joinedAltitudeSerie = new int[joinedSliceCounter];
    final int[] joinedCadenceSerie = new int[joinedSliceCounter];
    final int[] joinedDistanceSerie = new int[joinedSliceCounter];
    final double[] joinedLatitudeSerie = new double[joinedSliceCounter];
    final double[] joinedLongitudeSerie = new double[joinedSliceCounter];
    final int[] joinedPowerSerie = new int[joinedSliceCounter];
    final int[] joinedPulseSerie = new int[joinedSliceCounter];
    final int[] joinedSpeedSerie = new int[joinedSliceCounter];
    final int[] joinedTemperatureSerie = new int[joinedSliceCounter];
    final int[] joinedTimeSerie = new int[joinedSliceCounter];

    final StringBuilder joinedDescription = new StringBuilder();
    final HashSet<TourMarker> joinedTourMarker = new HashSet<TourMarker>();
    final ArrayList<TourWayPoint> joinedWayPoints = new ArrayList<TourWayPoint>();

    int joinedSerieIndex = 0;
    int joinedTourStartIndex = 0;
    int joinedTourStartDistance = 0;
    int joinedRecordingTime = 0;
    int joinedDrivingTime = 0;
    int joinedDistance = 0;
    int joinedCalories = 0;
    boolean isJoinedDistanceFromSensor = false;
    short joinedDeviceTimeInterval = -1;
    String joinedWeatherClouds = UI.EMPTY_STRING;
    String joinedWeather = UI.EMPTY_STRING;
    int joinedWeatherWindDir = 0;
    int joinedWeatherWindSpeed = 0;
    int joinedRestPulse = 0;
    int joinedTemperatureScale = 1;

    int relTourTime = 0;
    long relTourTimeOffset = 0;
    long absFirstTourStartTimeSec = 0;
    long absJoinedTourStartTimeSec = 0;
    DateTime joinedTourStart = null;

    boolean isFirstTour = true;

    /*
     * copy tour data series into joined data series
     */
    for (final TourData tourTourData : _selectedTours) {

        final int[] tourAltitudeSerie = tourTourData.altitudeSerie;
        final int[] tourCadenceSerie = tourTourData.cadenceSerie;
        final int[] tourDistanceSerie = tourTourData.distanceSerie;
        final double[] tourLatitudeSerie = tourTourData.latitudeSerie;
        final double[] tourLongitudeSerie = tourTourData.longitudeSerie;
        final int[] tourPulseSerie = tourTourData.pulseSerie;
        final int[] tourTemperatureSerie = tourTourData.temperatureSerie;
        final int[] tourTimeSerie = tourTourData.timeSerie;

        final boolean isTourAltitude = (tourAltitudeSerie != null) && (tourAltitudeSerie.length > 0);
        final boolean isTourCadence = (tourCadenceSerie != null) && (tourCadenceSerie.length > 0);
        final boolean isTourDistance = (tourDistanceSerie != null) && (tourDistanceSerie.length > 0);
        final boolean isTourLat = (tourLatitudeSerie != null) && (tourLatitudeSerie.length > 0);
        final boolean isTourLon = (tourLongitudeSerie != null) && (tourLongitudeSerie.length > 0);
        final boolean isTourPulse = (tourPulseSerie != null) && (tourPulseSerie.length > 0);
        final boolean isTourTemperature = (tourTemperatureSerie != null) && (tourTemperatureSerie.length > 0);
        final boolean isTourTime = (tourTimeSerie != null) && (tourTimeSerie.length > 0);

        /*
         * get speed/power data when it's from the device
         */
        int[] tourPowerSerie = null;
        int[] tourSpeedSerie = null;
        final boolean isTourPower = tourTourData.isPowerSerieFromDevice();
        final boolean isTourSpeed = tourTourData.isSpeedSerieFromDevice();
        if (isTourPower) {
            tourPowerSerie = tourTourData.getPowerSerie();
        }
        if (isTourSpeed) {
            tourSpeedSerie = tourTourData.getSpeedSerie();
        }

        /*
         * set tour time
         */
        final DateTime tourStartTime = new DateTime(tourTourData.getStartYear(), tourTourData.getStartMonth(),
                tourTourData.getStartDay(), tourTourData.getStartHour(), tourTourData.getStartMinute(),
                tourTourData.getStartSecond(), 0);

        if (isFirstTour) {

            // get start date/time

            if (isOriginalTime) {

                joinedTourStart = tourStartTime;

            } else {

                joinedTourStart = new DateTime(_dtTourDate.getYear(), _dtTourDate.getMonth() + 1,
                        _dtTourDate.getDay(), _dtTourTime.getHours(), _dtTourTime.getMinutes(),
                        _dtTourTime.getSeconds(), 0);
            }

            // tour start in absolute seconds
            absJoinedTourStartTimeSec = joinedTourStart.getMillis() / 1000;
            absFirstTourStartTimeSec = absJoinedTourStartTimeSec;

        } else {

            // get relative time offset

            if (isOriginalTime) {

                final DateTime tourStart = tourStartTime;

                final long absTourStartTimeSec = tourStart.getMillis() / 1000;

                // keep original time
                relTourTimeOffset = absTourStartTimeSec - absFirstTourStartTimeSec;

            } else {

                /*
                 * remove time gaps between tours, add relative time from the last tour and add
                 * 1 second for the start of the next tour
                 */
                relTourTimeOffset += relTourTime + 1;
            }
        }

        /*
         * get number of slices
         */
        int tourSliceCounter = 0;
        if (isTourTime) {
            tourSliceCounter = tourTimeSerie.length;
        } else if (isTourDistance) {
            tourSliceCounter = tourDistanceSerie.length;
        } else if (isTourLat) {
            tourSliceCounter = tourLatitudeSerie.length;
        }

        int relTourDistance = 0;

        /*
         * copy data series
         */
        for (int tourSerieIndex = 0; tourSerieIndex < tourSliceCounter; tourSerieIndex++) {

            if (isTourTime) {

                relTourTime = tourTimeSerie[tourSerieIndex];

                joinedTimeSerie[joinedSerieIndex] = (int) (relTourTimeOffset + relTourTime);

                isJoinTime = true;
            }

            if (isTourAltitude) {
                joinedAltitudeSerie[joinedSerieIndex] = tourAltitudeSerie[tourSerieIndex];
                isJoinAltitude = true;
            }
            if (isTourCadence) {
                joinedCadenceSerie[joinedSerieIndex] = tourCadenceSerie[tourSerieIndex];
                isJoinCadence = true;
            }

            if (isTourDistance) {

                relTourDistance = tourDistanceSerie[tourSerieIndex];

                joinedDistanceSerie[joinedSerieIndex] = joinedTourStartDistance + relTourDistance;
                isJoinDistance = true;
            }

            if (isTourPulse) {
                joinedPulseSerie[joinedSerieIndex] = tourPulseSerie[tourSerieIndex];
                isJoinPulse = true;
            }
            if (isTourLat) {
                joinedLatitudeSerie[joinedSerieIndex] = tourLatitudeSerie[tourSerieIndex];
                isJoinLat = true;
            }
            if (isTourLon) {
                joinedLongitudeSerie[joinedSerieIndex] = tourLongitudeSerie[tourSerieIndex];
                isJoinLon = true;
            }

            if (isTourTemperature) {
                joinedTemperatureSerie[joinedSerieIndex] = tourTemperatureSerie[tourSerieIndex];
            } else {
                // set temperature to temporarily value
                joinedTemperatureSerie[joinedSerieIndex] = Integer.MIN_VALUE;
            }

            if (isTourPower) {
                joinedPowerSerie[joinedSerieIndex] = tourPowerSerie[tourSerieIndex];
                isJoinPower = true;
            }
            if (isTourSpeed) {
                joinedSpeedSerie[joinedSerieIndex] = tourSpeedSerie[tourSerieIndex];
                isJoinSpeed = true;
            }

            joinedSerieIndex++;
        }

        final Set<TourMarker> tourMarkers = tourTourData.getTourMarkers();

        if (_chkIncludeMarkerWaypoints.getSelection()) {

            /*
             * copy tour markers
             */
            for (final TourMarker tourMarker : tourMarkers) {

                final TourMarker clonedMarker = tourMarker.clone(_joinedTourData);

                int joinMarkerIndex = joinedTourStartIndex + clonedMarker.getSerieIndex();
                if (joinMarkerIndex >= joinedSliceCounter) {
                    joinMarkerIndex = joinedSliceCounter - 1;
                }

                // adjust marker position, position is relativ to the tour start
                clonedMarker.setSerieIndex(joinMarkerIndex);

                if (isJoinTime) {
                    clonedMarker.setTime(joinedTimeSerie[joinMarkerIndex]);
                }
                if (isJoinDistance) {
                    clonedMarker.setDistance(joinedDistanceSerie[joinMarkerIndex]);
                }

                joinedTourMarker.add(clonedMarker);
            }

            /*
             * copy way points
             */
            for (final TourWayPoint wayPoint : tourTourData.getTourWayPoints()) {
                joinedWayPoints.add((TourWayPoint) wayPoint.clone());
            }
        }

        if (_chkCreateTourMarker.getSelection()) {

            /*
             * create a tour marker
             */

            // first find a free marker position in the tour
            int tourMarkerIndex = -1;
            for (int tourSerieIndex = 0; tourSerieIndex < tourSliceCounter; tourSerieIndex++) {

                boolean isIndexAvailable = true;

                // check if a marker occupies the current index
                for (final TourMarker tourMarker : tourMarkers) {
                    if (tourMarker.getSerieIndex() == tourSerieIndex) {
                        isIndexAvailable = false;
                        break;
                    }
                }

                if (isIndexAvailable) {
                    // free index was found
                    tourMarkerIndex = tourSerieIndex;
                    break;
                }
            }

            if (tourMarkerIndex != -1) {

                // create tour marker label
                final String stateTourMarker = getStateTourMarker();
                final long tourStartTimeMS = tourStartTime.getMillis();

                String markerLabel = UI.EMPTY_STRING;

                if (stateTourMarker.equals(STATE_MARKER_TYPE_SMALL)) {
                    markerLabel = _dtFormatterShort.print(tourStartTimeMS);
                } else if (stateTourMarker.equals(STATE_MARKER_TYPE_MEDIUM)) {
                    markerLabel = _dtFormatterMedium.print(tourStartTimeMS);
                } else if (stateTourMarker.equals(STATE_MARKER_TYPE_LARGE)) {
                    markerLabel = _dtFormatterFull.print(tourStartTimeMS);
                }

                final int joinMarkerIndex = joinedTourStartIndex + tourMarkerIndex;

                final TourMarker tourMarker = new TourMarker(_joinedTourData, ChartLabel.MARKER_TYPE_CUSTOM);

                tourMarker.setSerieIndex(joinMarkerIndex);
                tourMarker.setLabel(markerLabel);
                tourMarker.setVisualPosition(ChartLabel.VISUAL_VERTICAL_ABOVE_GRAPH);

                if (isJoinTime) {
                    tourMarker.setTime(joinedTimeSerie[joinMarkerIndex]);
                }
                if (isJoinDistance) {
                    tourMarker.setDistance(joinedDistanceSerie[joinMarkerIndex]);
                }

                joinedTourMarker.add(tourMarker);
            }
        }

        /*
         * create description
         */
        if (_chkIncludeDescription.getSelection()) {

            final String tourDescription = tourTourData.getTourDescription();

            if (joinedDescription.length() > 0) {
                // set space between two tours
                joinedDescription.append(UI.NEW_LINE2);
            }

            joinedDescription.append(Messages.Dialog_JoinTours_Label_Tour);
            joinedDescription.append(TourManager.getTourTitleDetailed(tourTourData));
            if (tourDescription.length() > 0) {
                joinedDescription.append(UI.NEW_LINE);
                joinedDescription.append(tourDescription);
            }
        }

        /*
         * other tour values
         */
        if (isFirstTour) {
            isJoinedDistanceFromSensor = tourTourData.isDistanceSensorPresent();
            joinedDeviceTimeInterval = tourTourData.getDeviceTimeInterval();

            joinedWeather = tourTourData.getWeather();
            joinedWeatherClouds = tourTourData.getWeatherClouds();
            joinedWeatherWindDir = tourTourData.getWeatherWindDir();
            joinedWeatherWindSpeed = tourTourData.getWeatherWindSpeed();

            joinedRestPulse = tourTourData.getRestPulse();
            joinedTemperatureScale = tourTourData.getTemperatureScale();

        } else {
            if (isJoinedDistanceFromSensor && tourTourData.isDistanceSensorPresent()) {
                // keep TRUE state
            } else {
                isJoinedDistanceFromSensor = false;
            }
            if (joinedDeviceTimeInterval == tourTourData.getDeviceTimeInterval()) {
                // keep value
            } else {
                joinedDeviceTimeInterval = -1;
            }
        }

        /*
         * summarize other fields
         */
        tourTourData.computeTourDrivingTime();

        joinedRecordingTime += tourTourData.getTourRecordingTime();
        joinedDrivingTime += tourTourData.getTourDrivingTime();

        joinedDistance += tourTourData.getTourDistance();
        joinedCalories += tourTourData.getCalories();

        /*
         * init next tour
         */
        isFirstTour = false;
        joinedTourStartIndex = joinedSerieIndex;
        joinedTourStartDistance += relTourDistance;
    }

    /*
     * setup tour data
     */
    _joinedTourData.setStartHour((short) joinedTourStart.getHourOfDay());
    _joinedTourData.setStartMinute((short) joinedTourStart.getMinuteOfHour());
    _joinedTourData.setStartSecond((short) joinedTourStart.getSecondOfMinute());
    _joinedTourData.setStartYear((short) joinedTourStart.getYear());
    _joinedTourData.setStartMonth((short) joinedTourStart.getMonthOfYear());
    _joinedTourData.setStartDay((short) joinedTourStart.getDayOfMonth());

    _joinedTourData.setWeek(joinedTourStart);

    // tour id must be created after the tour date/time is set
    _joinedTourData.createTourId();

    _joinedTourData.setTourTitle(_txtTourTitle.getText());
    _joinedTourData.setTourDescription(joinedDescription.toString());

    _joinedTourData.setTourMarkers(joinedTourMarker);
    _joinedTourData.setWayPoints(joinedWayPoints);
    _joinedTourData.setDeviceName(Messages.Dialog_JoinTours_Label_DeviceName);

    _joinedTourData.setIsDistanceFromSensor(isJoinedDistanceFromSensor);
    _joinedTourData.setDeviceTimeInterval(joinedDeviceTimeInterval);

    _joinedTourData.setCalories(joinedCalories);
    _joinedTourData.setRestPulse(joinedRestPulse);

    _joinedTourData.setWeather(joinedWeather);
    _joinedTourData.setWeatherClouds(joinedWeatherClouds);
    _joinedTourData.setWeatherWindDir(joinedWeatherWindDir);
    _joinedTourData.setWeatherWindSpeed(joinedWeatherWindSpeed);

    _joinedTourData.setTourRecordingTime(joinedRecordingTime);
    _joinedTourData.setTourDrivingTime(joinedDrivingTime);
    _joinedTourData.setTourDistance(joinedDistance);

    // !! tour type and tour tags are already set !!

    if (isJoinAltitude) {
        _joinedTourData.altitudeSerie = joinedAltitudeSerie;
    }
    if (isJoinDistance) {
        _joinedTourData.distanceSerie = joinedDistanceSerie;
    }
    if (isJoinCadence) {
        _joinedTourData.cadenceSerie = joinedCadenceSerie;
    }
    if (isJoinLat) {
        _joinedTourData.latitudeSerie = joinedLatitudeSerie;
    }
    if (isJoinLon) {
        _joinedTourData.longitudeSerie = joinedLongitudeSerie;
    }
    if (isJoinPower) {
        _joinedTourData.setPowerSerie(joinedPowerSerie);
    }
    if (isJoinPulse) {
        _joinedTourData.pulseSerie = joinedPulseSerie;
    }
    if (isJoinSpeed) {
        _joinedTourData.setSpeedSerie(joinedSpeedSerie);
    }

    _joinedTourData.temperatureSerie = joinedTemperatureSerie;
    _joinedTourData.setTemperatureScale(joinedTemperatureScale);

    if (isJoinTime) {
        _joinedTourData.timeSerie = joinedTimeSerie;
    }

    _joinedTourData.computeAltitudeUpDown();
    _joinedTourData.computeComputedValues();

    // set person which is required to save a tour
    _joinedTourData.setTourPerson(getSelectedPerson());

    /*
     * check size of the fields
     */
    if (_joinedTourData.isValidForSave() == false) {
        return false;
    }

    /*
     * TourData.computeComputedValues() creates speed data serie which must be removed that
     * cleanupDataSeries() works correctly
     */
    _joinedTourData.setSpeedSerie(null);

    _joinedTourData.cleanupDataSeries();

    _joinedTourData = TourManager.saveModifiedTour(_joinedTourData);

    return true;
}