eclipse-sailing-analytics/sailing-analytics
1
0 Fork 0
mirror of https://github.com/eclipse-sailing-analytics/sailing-analytics.git synced 2026-10-27 06:17:27 +00:00
Code Activity

start analysis factory does not load map data anymore

Browse Source
This commit is contained in:
Alexander Ries committed 2015-03-19 13:45:12 +01:00
1 parent 8ff59df803
commit 57e3a9639e
4 files changed
+16 -524
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

java/com.sap.sailing.dashboards.gwt/src/main/java/com/sap/sailing/dashboards/gwt/client/startanalysis/StartAnalysisSimpleMap.java
-329
View File
@@ -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 -185
View File
@@ -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
-3
View File
@@ -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
+14 -7
View File
@@ -1,11 +1,11 @@
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> {
@@ -13,17 +13,24 @@ public class StartAnalysisDTO implements Serializable, Comparable<StartAnalysisD
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;
}
}