start analysis factory does not load map data anymore

java/com.sap.sailing.dashboards.gwt/src/main/java/com/sap/sailing/dashboards/gwt/client/startanalysis/StartAnalysisSimpleMap.java

@@ -1,329 +0,0 @@
-package com.sap.sailing.dashboards.gwt.client.startanalysis;
-
-import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.Iterator;
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
-
-import com.google.gwt.dom.client.Style.Position;
-import com.google.gwt.dom.client.Style.Unit;
-import com.google.gwt.maps.client.LoadApi;
-import com.google.gwt.maps.client.LoadApi.LoadLibrary;
-import com.google.gwt.maps.client.MapOptions;
-import com.google.gwt.maps.client.MapWidget;
-import com.google.gwt.maps.client.base.LatLng;
-import com.google.gwt.maps.client.base.LatLngBounds;
-import com.google.gwt.maps.client.controls.ControlPosition;
-import com.google.gwt.maps.client.controls.MapTypeStyle;
-import com.google.gwt.maps.client.controls.ScaleControlOptions;
-import com.google.gwt.maps.client.maptypes.MapTypeStyleFeatureType;
-import com.google.gwt.maps.client.mvc.MVCArray;
-import com.google.gwt.maps.client.overlays.Polyline;
-import com.google.gwt.maps.client.overlays.PolylineOptions;
-import com.google.gwt.user.client.ui.AbsolutePanel;
-import com.sap.sailing.dashboards.gwt.shared.dto.startanalysis.StartAnalysisCompetitorDTO;
-import com.sap.sailing.dashboards.gwt.shared.dto.startanalysis.StartAnalysisDTO;
-import com.sap.sailing.domain.common.dto.CompetitorDTO;
-import com.sap.sailing.domain.common.dto.PositionDTO;
-import com.sap.sailing.gwt.ui.client.shared.racemap.BoatOverlay;
-import com.sap.sailing.gwt.ui.client.shared.racemap.CourseMarkOverlay;
-import com.sap.sailing.gwt.ui.client.shared.racemap.RaceMapOverlaysZIndexes;
-import com.sap.sailing.gwt.ui.client.shared.racemap.TailFactory;
-import com.sap.sailing.gwt.ui.shared.GPSFixDTO;
-import com.sap.sailing.gwt.ui.shared.MarkDTO;
-import com.sap.sailing.gwt.ui.shared.racemap.GoogleMapStyleHelper;
-import com.sap.sse.common.impl.RGBColor;
-
-public class StartAnalysisSimpleMap extends AbsolutePanel implements TailFactory {
-
-    private MapWidget map;
-    private StartAnalysisDTO startAnalysisDTO;
-
-    public StartAnalysisSimpleMap(int containerID, StartAnalysisDTO startAnalysisDTO) {
-
-        this.startAnalysisDTO = startAnalysisDTO;
-
-        this.getElement().getStyle().setPosition(Position.ABSOLUTE);
-        this.getElement().getStyle().setWidth(100, Unit.PCT);
-        this.getElement().getStyle().setHeight(100, Unit.PCT);
-        loadMapsAPIV3();
-    }
-
-    private void loadMapsAPIV3() {
-        boolean sensor = true;
-        // load all the libs for use in the maps
-        ArrayList<LoadLibrary> loadLibraries = new ArrayList<LoadApi.LoadLibrary>();
-        loadLibraries.add(LoadLibrary.DRAWING);
-        loadLibraries.add(LoadLibrary.GEOMETRY);
-
-        Runnable onLoad = new Runnable() {
-            @Override
-            public void run() {
-                MapOptions mapOptions = MapOptions.newInstance();
-                mapOptions.setScrollWheel(true);
-                mapOptions.setMapTypeControl(false);
-                mapOptions.setPanControl(false);
-                mapOptions.setZoomControl(false);
-                mapOptions.setScaleControl(true);
-                mapOptions.setDraggable(false);
-                mapOptions.setPanControl(false);
-                MapTypeStyle[] mapTypeStyles = new MapTypeStyle[4];
-
-                // hide all transit lines including ferry lines
-                mapTypeStyles[0] = GoogleMapStyleHelper.createHiddenStyle(MapTypeStyleFeatureType.TRANSIT);
-                // hide points of interest
-                mapTypeStyles[1] = GoogleMapStyleHelper.createHiddenStyle(MapTypeStyleFeatureType.POI);
-                // simplify road display
-                mapTypeStyles[2] = GoogleMapStyleHelper.createSimplifiedStyle(MapTypeStyleFeatureType.ROAD);
-                // set water color
-                mapTypeStyles[3] = GoogleMapStyleHelper.createColorStyle(MapTypeStyleFeatureType.WATER, new RGBColor(0,
-                        136, 255), -35, -34);
-
-                mapOptions.setMapTypeStyles(mapTypeStyles);
-                ScaleControlOptions scaleControlOptions = ScaleControlOptions.newInstance();
-                scaleControlOptions.setPosition(ControlPosition.BOTTOM_RIGHT);
-                mapOptions.setScaleControlOptions(scaleControlOptions);
-                mapOptions.setStreetViewControl(false);
-                map = new MapWidget(mapOptions);
-                StartAnalysisSimpleMap.this.add(map, 0, 0);
-                map.setSize("100%", "100%");
-                map.getElement().getStyle().setBackgroundColor("#4293DB");
-                map.triggerResize();
-                drawStartLine(startAnalysisDTO.startLineMarks);
-                drawLinesFromStartLineToFirstMark(startAnalysisDTO.startLineMarks, startAnalysisDTO.firstMark);
-                drawStartlineMarks(startAnalysisDTO.startLineMarks);
-                drawFirstMark(startAnalysisDTO.firstMark);
-                drawTails(createGPSFixesForCompetitors(startAnalysisDTO));
-                drawBoats(createGPSPositionForCompetitors(startAnalysisDTO));
-                zoomMapToNewBounds(calculateNewBounds(startAnalysisDTO.startLineMarkPositions));
-            }
-        };
-        LoadApi.go(onLoad, loadLibraries, sensor);
-    }
-
-    private Map<CompetitorDTO, List<GPSFixDTO>> createGPSFixesForCompetitors(StartAnalysisDTO startAnalysisDTO) {
-
-        Map<CompetitorDTO, List<GPSFixDTO>> gpsFixesForCompetitors = new HashMap<CompetitorDTO, List<GPSFixDTO>>();
-        for (StartAnalysisCompetitorDTO startAnalysisCompetitorDTO : startAnalysisDTO.startAnalysisCompetitorDTOs) {
-            if (startAnalysisCompetitorDTO.gpsFixDTOs != null && !startAnalysisCompetitorDTO.gpsFixDTOs.isEmpty()) {
-                gpsFixesForCompetitors.put(startAnalysisCompetitorDTO.competitorDTO,
-                        startAnalysisCompetitorDTO.gpsFixDTOs);
-            }
-        }
-        return gpsFixesForCompetitors;
-    }
-
-    private Map<CompetitorDTO, GPSFixDTO> createGPSPositionForCompetitors(StartAnalysisDTO startAnalysisDTO) {
-        Map<CompetitorDTO, GPSFixDTO> gpsPositionForCompetitors = new HashMap<CompetitorDTO, GPSFixDTO>();
-        for (StartAnalysisCompetitorDTO startAnalysisCompetitorDTO : startAnalysisDTO.startAnalysisCompetitorDTOs) {
-            if (startAnalysisCompetitorDTO.gpsFixDTOs != null && !startAnalysisCompetitorDTO.gpsFixDTOs.isEmpty()) {
-                gpsPositionForCompetitors.put(startAnalysisCompetitorDTO.competitorDTO,
-                        startAnalysisCompetitorDTO.gpsFixDTOs.get(startAnalysisCompetitorDTO.gpsFixDTOs.size() - 1));
-            }
-        }
-        return gpsPositionForCompetitors;
-    }
-
-    private void drawStartLine(List<MarkDTO> startlineMarks) {
-        if (map != null && startlineMarks != null) {
-
-            if (startlineMarks.size() == 2) {
-                LatLng startLinePoint1 = LatLng.newInstance(startlineMarks.get(0).position.latDeg,
-                        startlineMarks.get(0).position.lngDeg);
-                LatLng startLinePoint2 = LatLng.newInstance(startlineMarks.get(1).position.latDeg,
-                        startlineMarks.get(1).position.lngDeg);
-
-                PolylineOptions options = PolylineOptions.newInstance();
-                options.setGeodesic(true);
-                options.setStrokeColor("#FFFFFF");
-                options.setStrokeWeight(2);
-                options.setStrokeOpacity(1.0);
-
-                MVCArray<LatLng> pointsAsArray = MVCArray.newInstance();
-                pointsAsArray.insertAt(0, startLinePoint1);
-                pointsAsArray.insertAt(1, startLinePoint2);
-
-                Polyline startLine = Polyline.newInstance(options);
-                startLine.setPath(pointsAsArray);
-
-                startLine.setMap(map);
-            }
-        }
-    }
-
-    private void drawLinesFromStartLineToFirstMark(List<MarkDTO> startlineMarks, MarkDTO firstMark) {
-        if (map != null && startlineMarks != null && firstMark != null) {
-            if (startlineMarks.size() == 2) {
-                LatLng startLinePoint1 = LatLng.newInstance(startlineMarks.get(0).position.latDeg,
-                        startlineMarks.get(0).position.lngDeg);
-                LatLng startLinePoint2 = LatLng.newInstance(startlineMarks.get(1).position.latDeg,
-                        startlineMarks.get(1).position.lngDeg);
-                LatLng firstMarkPoint = LatLng.newInstance(firstMark.position.latDeg, firstMark.position.lngDeg);
-
-                PolylineOptions options = PolylineOptions.newInstance();
-                options.setGeodesic(true);
-                options.setStrokeColor("#A3A3A3");
-                options.setStrokeWeight(2);
-                options.setStrokeOpacity(1.0);
-
-                MVCArray<LatLng> pointsAsArray1 = MVCArray.newInstance();
-                pointsAsArray1.insertAt(0, startLinePoint1);
-                pointsAsArray1.insertAt(1, firstMarkPoint);
-
-                MVCArray<LatLng> pointsAsArray2 = MVCArray.newInstance();
-                pointsAsArray2.insertAt(0, startLinePoint2);
-                pointsAsArray2.insertAt(1, firstMarkPoint);
-
-                Polyline startMarkFirstMark1 = Polyline.newInstance(options);
-                Polyline startMarkFirstMark2 = Polyline.newInstance(options);
-
-                startMarkFirstMark1.setPath(pointsAsArray1);
-                startMarkFirstMark2.setPath(pointsAsArray2);
-
-                startMarkFirstMark1.setMap(map);
-                startMarkFirstMark2.setMap(map);
-            }
-        }
-    }
-
-    private void drawStartlineMarks(List<MarkDTO> startlineMarks) {
-        if (map != null) {
-            for (MarkDTO markDTO : startlineMarks) {
-                CourseMarkOverlay courseMarkOverlay = createCourseMarkOverlay(
-                        RaceMapOverlaysZIndexes.COURSEMARK_ZINDEX, markDTO);
-                courseMarkOverlay.addToMap();
-            }
-        }
-    }
-
-    private void drawFirstMark(MarkDTO firstMark) {
-        CourseMarkOverlay courseMarkOverlay = createCourseMarkOverlay(RaceMapOverlaysZIndexes.COURSEMARK_ZINDEX,
-                firstMark);
-        courseMarkOverlay.addToMap();
-    }
-
-    private CourseMarkOverlay createCourseMarkOverlay(int zIndex, final MarkDTO markDTO) {
-        markDTO.position.latDeg = markDTO.position.latDeg;
-        final CourseMarkOverlay courseMarkOverlay = new CourseMarkOverlay(map, zIndex, markDTO);
-        return courseMarkOverlay;
-    }
-
-    private LatLngBounds calculateNewBounds(List<PositionDTO> startLinePositions) {
-        LatLngBounds newBounds = null;
-        List<PositionDTO> newStartLinePositionDTOs = new ArrayList<PositionDTO>(startLinePositions);
-        Iterable<PositionDTO> positionsToZoom = newStartLinePositionDTOs;
-
-        if (positionsToZoom != null) {
-            for (PositionDTO position : positionsToZoom) {
-                PositionDTO positionMoovedToNorth = position;
-                positionMoovedToNorth.latDeg = positionMoovedToNorth.latDeg - 0.0009;
-
-                LatLng markLatLng = LatLng.newInstance(positionMoovedToNorth.latDeg, positionMoovedToNorth.lngDeg);
-                LatLngBounds bounds = LatLngBounds.newInstance(markLatLng, markLatLng);
-                if (newBounds == null) {
-                    newBounds = bounds;
-                } else {
-                    newBounds.extend(markLatLng);
-                }
-                markLatLng = null;
-                position = null;
-                positionMoovedToNorth.latDeg = positionMoovedToNorth.latDeg + 0.0009;
-            }
-        }
-        // }
-        positionsToZoom = null;
-        return newBounds;
-    }
-
-    private void zoomMapToNewBounds(LatLngBounds newBounds) {
-        if (newBounds != null) {
-            map.setCenter(newBounds.getCenter());
-            map.setZoom(17);
-        }
-    }
-
-    private void drawBoats(Map<CompetitorDTO, GPSFixDTO> competitorAndLastFix) {
-
-        Set<CompetitorDTO> competitors = competitorAndLastFix.keySet();
-
-        for (CompetitorDTO competitorDTO : competitors) {
-            BoatOverlay boatOverlay = createBoatOverlay(RaceMapOverlaysZIndexes.BOATS_ZINDEX, competitorDTO, false);
-            boatOverlay.setSelected(false);
-            boatOverlay.setBoatFix(competitorAndLastFix.get(competitorDTO), 10);
-            boatOverlay.addToMap();
-        }
-    }
-
-    private BoatOverlay createBoatOverlay(int zIndex, final CompetitorDTO competitorDTO, boolean highlighted) {
-        final BoatOverlay boatCanvas = new BoatOverlay(map, zIndex, competitorDTO, competitorDTO.getColor());
-        boatCanvas.setSelected(false);
-        return boatCanvas;
-    }
-
-    private void drawTails(Map<CompetitorDTO, List<GPSFixDTO>> competitorFixes) {
-
-        Set<CompetitorDTO> competitors = competitorFixes.keySet();
-        for (CompetitorDTO competitor : competitors) {
-            Polyline competitorPolyline = createPolylineFromGPSFixDTOs(competitor, competitorFixes.get(competitor));
-            competitorPolyline.setMap(map);
-        }
-
-    }
-
-    private Polyline createPolylineFromGPSFixDTOs(CompetitorDTO competitorDTO, List<GPSFixDTO> fixes) {
-        List<LatLng> points = new ArrayList<LatLng>();
-        int indexOfFirst = -1;
-        int indexOfLast = -1;
-        int i = 0;
-        for (Iterator<GPSFixDTO> fixIter = fixes.iterator(); fixIter.hasNext() && indexOfLast == -1;) {
-            GPSFixDTO fix = fixIter.next();
-            if (!fix.timepoint.before(fixes.get(fixes.size() - 1).timepoint)) {
-                indexOfLast = i - 1;
-            } else {
-                LatLng point = null;
-                if (indexOfFirst == -1) {
-                    if (!fix.timepoint.before(fixes.get(0).timepoint)) {
-                        indexOfFirst = i;
-                        point = LatLng.newInstance(fix.position.latDeg, fix.position.lngDeg);
-                    }
-                } else {
-                    point = LatLng.newInstance(fix.position.latDeg, fix.position.lngDeg);
-                }
-                if (point != null) {
-                    points.add(point);
-                }
-            }
-            i++;
-        }
-        if (indexOfLast == -1) {
-            indexOfLast = i - 1;
-        }
-        Polyline result = createTail(competitorDTO, points);
-        return result;
-    }
-
-    @Override
-    public Polyline createTail(CompetitorDTO competitor, List<LatLng> points) {
-        PolylineOptions options = createTailStyle(competitor, false);
-        Polyline result = Polyline.newInstance(options);
-
-        MVCArray<LatLng> pointsAsArray = MVCArray.newInstance(points.toArray(new LatLng[0]));
-        result.setPath(pointsAsArray);
-
-        return result;
-    }
-
-    @Override
-    public PolylineOptions createTailStyle(CompetitorDTO competitor, boolean isHighlighted) {
-        PolylineOptions options = PolylineOptions.newInstance();
-        options.setClickable(true);
-        options.setGeodesic(true);
-        options.setStrokeOpacity(1.0);
-        options.setStrokeColor(competitor.getColor().getAsHtml());
-        options.setStrokeWeight(1);
-        options.setZindex(RaceMapOverlaysZIndexes.BOATTAILS_ZINDEX);
-        return options;
-    }
-}

java/com.sap.sailing.dashboards.gwt/src/main/java/com/sap/sailing/dashboards/gwt/server/startanalysis/StartAnalysisDTOFactory.java

@@ -2,10 +2,8 @@ package com.sap.sailing.dashboards.gwt.server.startanalysis;
 
 import java.util.ArrayList;
 import java.util.Date;
-import java.util.HashMap;
 import java.util.Iterator;
 import java.util.List;
-import java.util.Map;
 import java.util.logging.Level;
 import java.util.logging.Logger;
 
@@ -16,27 +14,15 @@ import com.sap.sailing.dashboards.gwt.shared.dto.startanalysis.StartAnalysisDTO;
 import com.sap.sailing.dashboards.gwt.shared.dto.startanalysis.StartAnalysisRankingTableEntryDTO;
 import com.sap.sailing.dashboards.gwt.shared.dto.startanalysis.WindAndAdvantagesInfoForStartLineDTO;
 import com.sap.sailing.domain.base.Competitor;
-import com.sap.sailing.domain.base.Mark;
 import com.sap.sailing.domain.base.Waypoint;
 import com.sap.sailing.domain.common.LegType;
 import com.sap.sailing.domain.common.NoWindException;
 import com.sap.sailing.domain.common.Position;
-import com.sap.sailing.domain.common.SpeedWithBearing;
-import com.sap.sailing.domain.common.Tack;
-import com.sap.sailing.domain.common.dto.CompetitorDTO;
-import com.sap.sailing.domain.common.dto.PositionDTO;
-import com.sap.sailing.domain.tracking.GPSFix;
-import com.sap.sailing.domain.tracking.GPSFixMoving;
-import com.sap.sailing.domain.tracking.GPSFixTrack;
 import com.sap.sailing.domain.tracking.LineDetails;
 import com.sap.sailing.domain.tracking.MarkPassing;
 import com.sap.sailing.domain.tracking.TrackedLeg;
 import com.sap.sailing.domain.tracking.TrackedRace;
 import com.sap.sailing.domain.tracking.Wind;
-import com.sap.sailing.gwt.ui.shared.GPSFixDTO;
-import com.sap.sailing.gwt.ui.shared.MarkDTO;
-import com.sap.sailing.gwt.ui.shared.SpeedWithBearingDTO;
-import com.sap.sailing.gwt.ui.shared.WindDTO;
 import com.sap.sailing.server.RacingEventService;
 import com.sap.sse.common.TimePoint;
 import com.sap.sse.common.impl.MillisecondsTimePoint;
@@ -46,7 +32,6 @@ public class StartAnalysisDTOFactory extends AbstractStartAnalysisCreationValida
     private final com.sap.sailing.domain.base.DomainFactory baseDomainFactory;
     
     private static int MINIMUM_NUMBER_COMPETITORS_FOR_STARTANALYSIS = 3;
-    private final int TAILLENGHT_IN_MILLISECONDS = 200000;
     
     private static final Logger logger = Logger.getLogger(StartAnalysisDTOFactory.class.getName());
     
@@ -75,6 +60,8 @@ public class StartAnalysisDTOFactory extends AbstractStartAnalysisCreationValida
         }
         startAnalysisDTO.competitor = baseDomainFactory.getCompetitorStore().convertToCompetitorDTO(competitor);
         startAnalysisDTO.startAnalysisCompetitorDTOs = competitors;
+        startAnalysisDTO.timeOfStartInMilliSeconds = trackedRace.getStartOfRace().asMillis();
+        startAnalysisDTO.regattaAndRaceIdentifier = trackedRace.getRaceIdentifier();
         logger.log(Level.INFO, "Created StartAnalysis For Competitor "+competitor.getName()+" and "+trackedRace.getRace().getName());
         return startAnalysisDTO;
     }
@@ -101,26 +88,10 @@ public class StartAnalysisDTOFactory extends AbstractStartAnalysisCreationValida
     
     private StartAnalysisDTO addStaticDataToStartAnalysisDTOFrom(StartAnalysisDTO startAnalysisDTO,TrackedRace trackedRace) {
         startAnalysisDTO.raceName = trackedRace.getRace().getName();
-        startAnalysisDTO.startLineMarkPositions = getStartLineBoyPositions(trackedRace);
-        startAnalysisDTO.firstMark = getMarksOfWayPoint(trackedRace, getFirstMarkWayPoint(trackedRace)).get(0);
         startAnalysisDTO.startAnalysisWindLineInfoDTO = createStartAnalysisWindAndLineData(trackedRace);
-        startAnalysisDTO.startLineMarks = getMarksOfWayPoint(trackedRace,
-                trackedRace.getStartLine(trackedRace.getStartTimeReceived()).getWaypoint());
         return startAnalysisDTO;
     }
 
-    private Map<String, Date> createPerCompetitorIdAsString(TrackedRace currentRace, Date fiveSecondsBeforeStart) {
-        Map<String, Date> fromPerCompetitorIdAsString = new HashMap<String, Date>();
-        try {
-            for (Competitor competitor : currentRace.getCompetitorsFromBestToWorst(new MillisecondsTimePoint(new Date()
-                    .getTime()))) {
-                fromPerCompetitorIdAsString.put(competitor.getId().toString(), fiveSecondsBeforeStart);
-            }
-        } catch (NoWindException e) {
-            e.printStackTrace();
-        }
-        return fromPerCompetitorIdAsString;
-    }
 
     private StartAnalysisRankingTableEntryDTO createRankTableEntry(TrackedRace trackedRace, int rank,
             Competitor competitor) {
@@ -140,66 +111,6 @@ public class StartAnalysisDTOFactory extends AbstractStartAnalysisCreationValida
         return tableentry;
     }
 
-    private List<PositionDTO> getStartLineBoyPositions(TrackedRace trackedRace) {
-        return getMarkPositionDTOs(trackedRace.getStartTimeReceived(), trackedRace, trackedRace.getRace().getCourse()
-                .getFirstWaypoint());
-    }
-
-    private Waypoint getFirstMarkWayPoint(TrackedRace trackedRace) {
-        Waypoint firstMarkWayPoint = null;
-        Iterator<Waypoint> waypoints = trackedRace.getRace().getCourse().getWaypoints().iterator();
-        int wayPointCounter = 0;
-        while (waypoints.hasNext()) {
-            Waypoint wayPoint = waypoints.next();
-            if (wayPointCounter == 1) {
-                return wayPoint;
-            }
-            wayPointCounter++;
-        }
-        return firstMarkWayPoint;
-    }
-
-    private List<PositionDTO> getMarkPositionDTOs(TimePoint timePoint, TrackedRace trackedRace, Waypoint waypoint) {
-
-        List<PositionDTO> markPositionDTOs = new ArrayList<PositionDTO>();
-        for (Mark startMark : waypoint.getMarks()) {
-            final Position estimatedMarkPosition = trackedRace.getOrCreateTrack(startMark).getEstimatedPosition(
-                    timePoint, /* extrapolate */false);
-            if (estimatedMarkPosition != null) {
-                markPositionDTOs.add(new PositionDTO(estimatedMarkPosition.getLatDeg(), estimatedMarkPosition
-                        .getLngDeg()));
-            }
-        }
-        return markPositionDTOs;
-    }
-
-    private List<MarkDTO> getMarksOfWayPoint(TrackedRace trackedRace, Waypoint wayPoint) {
-        List<MarkDTO> startLineMarks = new ArrayList<MarkDTO>();
-        for (Mark startMark : wayPoint.getMarks()) {
-            final Position estimatedMarkPosition = trackedRace.getOrCreateTrack(startMark).getEstimatedPosition(
-                    trackedRace.getStartTimeReceived(), /* extrapolate */false);
-            if (estimatedMarkPosition != null) {
-                startLineMarks.add(convertToMarkDTO(startMark, estimatedMarkPosition));
-            }
-        }
-        return startLineMarks;
-    }
-
-    private MarkDTO convertToMarkDTO(Mark mark, Position position) {
-        MarkDTO markDTO;
-        if (position != null) {
-            markDTO = new MarkDTO(mark.getId().toString(), mark.getName(), position.getLatDeg(), position.getLngDeg());
-        } else {
-            markDTO = new MarkDTO(mark.getId().toString(), mark.getName());
-        }
-        markDTO.color = mark.getColor();
-        markDTO.shape = mark.getShape();
-        markDTO.pattern = mark.getPattern();
-        markDTO.type = mark.getType();
-
-        return markDTO;
-    }
-
     private WindAndAdvantagesInfoForStartLineDTO createStartAnalysisWindAndLineData(TrackedRace trackedRace) {
         WindAndAdvantagesInfoForStartLineDTO startAnalysisWindLineInfoDTO = new WindAndAdvantagesInfoForStartLineDTO();
         LineDetails startline = trackedRace.getStartLine(trackedRace.getStartTimeReceived());
@@ -235,87 +146,6 @@ public class StartAnalysisDTOFactory extends AbstractStartAnalysisCreationValida
         }
     }
 
-    private Map<String, List<GPSFixDTO>> getGPSFixDTOListForCompetitorName(TrackedRace trackedRace,
-            Map<String, Date> fromPerCompetitorIdAsString, Map<String, Date> toPerCompetitorIdAsString,
-            boolean extrapolate) throws NoWindException {
-        Map<String, List<GPSFixDTO>> result = new HashMap<String, List<GPSFixDTO>>();
-        if (trackedRace != null) {
-            for (Competitor competitor : trackedRace.getRace().getCompetitors()) {
-                if (fromPerCompetitorIdAsString.containsKey(competitor.getId().toString())) {
-                    CompetitorDTO competitorDTO = baseDomainFactory.convertToCompetitorDTO(competitor);
-                    List<GPSFixDTO> fixesForCompetitor = new ArrayList<GPSFixDTO>();
-                    result.put(competitorDTO.getName(), fixesForCompetitor);
-                    GPSFixTrack<Competitor, GPSFixMoving> track = trackedRace.getTrack(competitor);
-                    TimePoint fromTimePoint = new MillisecondsTimePoint(fromPerCompetitorIdAsString.get(competitorDTO
-                            .getIdAsString()));
-                    TimePoint toTimePoint = new MillisecondsTimePoint(toPerCompetitorIdAsString.get(competitorDTO
-                            .getIdAsString()));
-                    // copy the fixes into a list while holding the monitor;
-                    // then release the monitor to avoid deadlocks
-                    // during wind estimations required for tack determination
-                    List<GPSFixMoving> fixes = new ArrayList<GPSFixMoving>();
-                    track.lockForRead();
-                    try {
-                        Iterator<GPSFixMoving> fixIter = track.getFixesIterator(fromTimePoint, /* inclusive */
-                                true);
-                        while (fixIter.hasNext()) {
-                            GPSFixMoving fix = fixIter.next();
-                            if (fix.getTimePoint().after(fromTimePoint) && fix.getTimePoint().before(toTimePoint)) {
-                                fixes.add(fix);
-                            }
-                        }
-                    } finally {
-                        track.unlockAfterRead();
-                    }
-
-                    Iterator<GPSFixMoving> fixIter = fixes.iterator();
-                    while (fixIter.hasNext()) {
-                        GPSFixMoving fix = fixIter.next();
-                        Wind wind = trackedRace.getWind(fix.getPosition(), toTimePoint);
-                        final SpeedWithBearing estimatedSpeed = track.getEstimatedSpeed(fix.getTimePoint());
-                        Tack tack = wind == null ? null : trackedRace.getTack(estimatedSpeed, wind, fix.getTimePoint());
-                        LegType legType = null;
-                        WindDTO windDTO = wind == null ? null : createWindDTOFromAlreadyAveraged(wind, toTimePoint);
-                        GPSFixDTO fixDTO = createGPSFixDTO(fix, estimatedSpeed, windDTO, tack, legType, /* extrapolate */
-                                false);
-                        fixesForCompetitor.add(fixDTO);
-                    }
-                }
-            }
-        }
-        return result;
-    }
-
-    protected WindDTO createWindDTOFromAlreadyAveraged(Wind wind, TimePoint requestTimepoint) {
-        WindDTO windDTO = new WindDTO();
-        windDTO.requestTimepoint = requestTimepoint.asMillis();
-        windDTO.trueWindBearingDeg = wind.getBearing().getDegrees();
-        windDTO.trueWindFromDeg = wind.getBearing().reverse().getDegrees();
-        windDTO.trueWindSpeedInKnots = wind.getKnots();
-        windDTO.trueWindSpeedInMetersPerSecond = wind.getMetersPerSecond();
-        windDTO.dampenedTrueWindBearingDeg = wind.getBearing().getDegrees();
-        windDTO.dampenedTrueWindFromDeg = wind.getBearing().reverse().getDegrees();
-        windDTO.dampenedTrueWindSpeedInKnots = wind.getKnots();
-        windDTO.dampenedTrueWindSpeedInMetersPerSecond = wind.getMetersPerSecond();
-        if (wind.getPosition() != null) {
-            windDTO.position = new PositionDTO(wind.getPosition().getLatDeg(), wind.getPosition().getLngDeg());
-        }
-        if (wind.getTimePoint() != null) {
-            windDTO.measureTimepoint = wind.getTimePoint().asMillis();
-        }
-        return windDTO;
-    }
-
-    private SpeedWithBearingDTO createSpeedWithBearingDTO(SpeedWithBearing speedWithBearing) {
-        return new SpeedWithBearingDTO(speedWithBearing.getKnots(), speedWithBearing.getBearing().getDegrees());
-    }
-
-    private GPSFixDTO createGPSFixDTO(GPSFix fix, SpeedWithBearing speedWithBearing, WindDTO windDTO, Tack tack,
-            LegType legType, boolean extrapolated) {
-        return new GPSFixDTO(fix.getTimePoint().asDate(), fix.getPosition() == null ? null : new PositionDTO(fix
-                .getPosition().getLatDeg(), fix.getPosition().getLngDeg()), speedWithBearing == null ? null
-                : createSpeedWithBearingDTO(speedWithBearing), windDTO, tack, legType, extrapolated);
-    }
 
     private LegType getFirstLegTypeOfTrackedRaceAtTimePoint(TrackedRace trackedRace, TimePoint timePoint)
             throws NoWindException {
@@ -333,19 +163,6 @@ public class StartAnalysisDTOFactory extends AbstractStartAnalysisCreationValida
         StartAnalysisCompetitorDTO startAnalysisCompetitorDTOsForRace = new StartAnalysisCompetitorDTO();
         startAnalysisCompetitorDTOsForRace.competitorDTO = baseDomainFactory.getCompetitorStore().convertToCompetitorDTO(competitor);
         startAnalysisCompetitorDTOsForRace.rankingTableEntryDTO = createRankTableEntry(trackedRace, rank, competitor);
-        List<GPSFixDTO> boatPositions = getOrCreateGPSFixDTOsForCompetitorForTrackedRace(trackedRace).get(
-                competitor.getName());
-        startAnalysisCompetitorDTOsForRace.gpsFixDTOs = boatPositions;
         return startAnalysisCompetitorDTOsForRace;
     }
-
-    private Map<String, List<GPSFixDTO>> getOrCreateGPSFixDTOsForCompetitorForTrackedRace(TrackedRace trackedRace) {
-        try {
-            return getGPSFixDTOListForCompetitorName(trackedRace, createPerCompetitorIdAsString(trackedRace, new Date(trackedRace.getStartTimeReceived()
-                                            .asMillis() - TAILLENGHT_IN_MILLISECONDS)), createPerCompetitorIdAsString(trackedRace, new Date(trackedRace.getStartTimeReceived()
-                                                  .asMillis())), true);
-        } catch (NoWindException e) {
-            return null;
-        }
-    }
 }

java/com.sap.sailing.dashboards.gwt/src/main/java/com/sap/sailing/dashboards/gwt/shared/dto/startanalysis/StartAnalysisCompetitorDTO.java

@@ -1,10 +1,8 @@
 package com.sap.sailing.dashboards.gwt.shared.dto.startanalysis;
 
 import java.io.Serializable;
-import java.util.List;
 
 import com.sap.sailing.domain.common.dto.CompetitorDTO;
-import com.sap.sailing.gwt.ui.shared.GPSFixDTO;
 
 public class StartAnalysisCompetitorDTO implements Serializable{
     
@@ -12,5 +10,4 @@ public class StartAnalysisCompetitorDTO implements Serializable{
     
     public CompetitorDTO competitorDTO;
     public StartAnalysisRankingTableEntryDTO rankingTableEntryDTO;
-    public List<GPSFixDTO> gpsFixDTOs;
 }

java/com.sap.sailing.dashboards.gwt/src/main/java/com/sap/sailing/dashboards/gwt/shared/dto/startanalysis/StartAnalysisDTO.java

@@ -1,29 +1,36 @@
 package com.sap.sailing.dashboards.gwt.shared.dto.startanalysis;
 
 import java.io.Serializable;
+import java.util.ArrayList;
 import java.util.List;
 
+import com.sap.sailing.domain.common.RegattaAndRaceIdentifier;
 import com.sap.sailing.domain.common.dto.CompetitorDTO;
-import com.sap.sailing.domain.common.dto.PositionDTO;
-import com.sap.sailing.gwt.ui.shared.MarkDTO;
 
-public class StartAnalysisDTO implements Serializable, Comparable<StartAnalysisDTO>{
+public class StartAnalysisDTO implements Serializable, Comparable<StartAnalysisDTO> {
-    
+
     private static final long serialVersionUID = -1325150193180234561L;
-    
+
     public String raceName;
     public CompetitorDTO competitor;
-    public List<PositionDTO> startLineMarkPositions;
-    public List<MarkDTO> startLineMarks;
-    public MarkDTO firstMark;
     public WindAndAdvantagesInfoForStartLineDTO startAnalysisWindLineInfoDTO;
     public List<StartAnalysisCompetitorDTO> startAnalysisCompetitorDTOs;
- 
+    public long timeOfStartInMilliSeconds;
-    
+    public RegattaAndRaceIdentifier regattaAndRaceIdentifier;
-    public StartAnalysisDTO(){}
+
+    public StartAnalysisDTO() {
+    }
 
     @Override
     public int compareTo(StartAnalysisDTO o) {
         return raceName.compareTo(o.raceName);
     }
+
+    public List<CompetitorDTO> getCompetitorDTOsFromStartAnaylsisCompetitorDTOs() {
+        List<CompetitorDTO> competitorDTOs = new ArrayList<CompetitorDTO>();
+        for (StartAnalysisCompetitorDTO startAnalysisCompetitorDTO : startAnalysisCompetitorDTOs) {
+            competitorDTOs.add(startAnalysisCompetitorDTO.competitorDTO);
+        }
+        return competitorDTOs;
+    }
 }