startanalysis works now for gate starts

This commit is contained in:
Alexander Ries committed 2015-04-01 10:00:15 +02:00
1 parent 0a7d338103
commit 37ff2061b8
7 files changed
+142 -53

No files matched your search

@@ -64,10 +64,13 @@
.startanalysis_card_table {
position: absolute;
bottom: 10pt;
right: 10pt;
left: 10pt;
background-color: white;
bottom: 0pt;
right: 0pt;
left: 0pt;
padding-left:10pt;
padding-right:10pt;
padding-bottom: 10pt;
background-color: #004384;;
z-index: 2;
}
@@ -85,7 +88,6 @@
right: 0pt;
width: 45pt;
height: 25pt;
background-color: white;
line-height: 25pt;
vertical-align: middle;
font-size: 11pt;
@@ -99,6 +101,20 @@
width: 215pt;
text-align: left;
padding-left: 7pt;
background-color: white;
}
.startanalysis_card_race_time{
position: absolute;
top: 10pt;
right: 10pt;
width: 200px;
text-align: right;
color: white;
line-height: 25pt;
font-size: 11pt;
font-family: "Arial";
z-index: 1;
}
.startanalysis_card_line_data_geo {
@@ -106,6 +122,7 @@
left: 220pt;
width: 100pt;
text-align: left;
background-color: white;
}
.left_focus_panel {
@@ -20,6 +20,7 @@ import com.google.gwt.user.client.ui.HasWidgets;
import com.google.gwt.user.client.ui.Widget;
import com.sap.sailing.dashboards.gwt.client.startanalysis.rankingtable.StartAnalysisStartRankTable;
import com.sap.sailing.dashboards.gwt.shared.dto.startanalysis.StartAnalysisDTO;
import com.sap.sailing.domain.common.racelog.RacingProcedureType;
import com.sap.sailing.gwt.ui.client.CompetitorSelectionModel;
import com.sap.sailing.gwt.ui.client.RaceTimesInfoProvider;
import com.sap.sailing.gwt.ui.client.SailingServiceAsync;
@@ -53,6 +54,9 @@ public class StartlineAnalysisCard extends Composite implements HasWidgets, Star
@UiField
DivElement startanalysis_card_line_advantage;
@UiField
DivElement startanalysis_card_race_time;
private int cardid;
private StartAnalysisDTO startAnalysisDTO;
@@ -64,7 +68,8 @@ public class StartlineAnalysisCard extends Composite implements HasWidgets, Star
private final double WIND_LINE_ADVANTAGE_DIV_WIDTH_IN_PT = 185;
private final double GEOMETRIC_LINE_ADVANTAGE_DIV_WIDTH_IN_PT = 210;
private final int TAIL_LENGHT_IN_MILLISECONDS = 900000;
private final int TABLE_MARGIN_IN_PT = 10;
private final String RACE_TIME_START = "00:00:00";
private static StartAnalysisResources resources = GWT.create(StartAnalysisResources.class);
@@ -74,12 +79,13 @@ public class StartlineAnalysisCard extends Composite implements HasWidgets, Star
resources.combinedWindPanelStyle().ensureInjected();
this.sailingServiceAsync = sailingServiceAsync;
competitorSelectionModel = new CompetitorSelectionModel(/* hasMultiSelection */true);
competitorSelectionModel.setCompetitors(startAnalysisDTO.getCompetitorDTOsFromStartAnaylsisCompetitorDTOs(),
raceMap);
initWidget(uiBinder.createAndBindUi(this));
startanalysis_card.getElement().getStyle().setLeft(leftCSSProperty, Unit.PCT);
this.startAnalysisDTO = startAnalysisDTO;
this.cardid = cardId;
startanalysis_card_table.add(new StartAnalysisStartRankTable(startAnalysisDTO.startAnalysisCompetitorDTOs));
startanalysis_card_table.add(new StartAnalysisStartRankTable(startAnalysisDTO.startAnalysisCompetitorDTOs, competitorSelectionModel));
fillWindAndStartLineData(this.startAnalysisDTO);
}
@@ -100,8 +106,22 @@ public class StartlineAnalysisCard extends Composite implements HasWidgets, Star
.getFormat("#0.0")
.format(startAnalysisDTO.startAnalysisWindLineInfoDTO.startLineAdvantage.startLineAdvantage)
+ " m");
String formattedTimeSinceStart;
if (startAnalysisDTO.racingProcedureType.equals(RacingProcedureType.GateStart)) {
formattedTimeSinceStart = getRaceTimeStringFromMilliseconds(startAnalysisDTO.tailLenghtInMilliseconds);
} else {
formattedTimeSinceStart = RACE_TIME_START;
}
startanalysis_card_race_time.setInnerHTML("Elapsed Time: "+formattedTimeSinceStart);
}
}
private String getRaceTimeStringFromMilliseconds(long milliseconds){
int seconds = (int) (milliseconds / 1000) % 60 ;
int minutes = (int) ((milliseconds / (1000*60)) % 60);
int hours = (int) ((milliseconds / (1000*60*60)) % 24);
return NumberFormat.getFormat("00").format(hours)+":"+NumberFormat.getFormat("00").format(minutes)+":"+NumberFormat.getFormat("00").format(seconds);
}
private void setLineAdvantageDivWidth(StartlineAdvantageType startlineAdvantageType) {
if (startAnalysisDTO.startAnalysisWindLineInfoDTO.startLineAdvantage.startLineAdvatageType
@@ -113,26 +133,28 @@ public class StartlineAnalysisCard extends Composite implements HasWidgets, Star
}
private void addMap(final int cardID, final StartAnalysisDTO startAnalysisDTO) {
AsyncActionsExecutor asyncActionsExecutor = new AsyncActionsExecutor();
com.sap.sse.gwt.client.player.Timer timer = new com.sap.sse.gwt.client.player.Timer(PlayModes.Live, 1000l);
timer.setTime(startAnalysisDTO.timeOfStartInMilliSeconds);
timer.pause();
ArrayList<ZoomTypes> zoomTypes = new ArrayList<ZoomTypes>();
if(startAnalysisDTO.racingProcedureType.equals(RacingProcedureType.GateStart)){
timer.setTime(startAnalysisDTO.timeOfStartInMilliSeconds+startAnalysisDTO.tailLenghtInMilliseconds);
zoomTypes.add(ZoomTypes.BUOYS);
}else{
timer.setTime(startAnalysisDTO.timeOfStartInMilliSeconds);
zoomTypes.add(ZoomTypes.TAILS);
}
AsyncActionsExecutor asyncActionsExecutor = new AsyncActionsExecutor();
RaceTimesInfoProvider raceTimesInfoProvider = new RaceTimesInfoProvider(sailingServiceAsync,
asyncActionsExecutor, null, Collections.singletonList(startAnalysisDTO.regattaAndRaceIdentifier), 5000l /* requestInterval */);
raceMap = new RaceMap(sailingServiceAsync, asyncActionsExecutor, null, timer, competitorSelectionModel,
StringMessages.INSTANCE, false, false, false, startAnalysisDTO.regattaAndRaceIdentifier,
resources.combinedWindPanelStyle());
competitorSelectionModel.setCompetitors(startAnalysisDTO.getCompetitorDTOsFromStartAnaylsisCompetitorDTOs(),
raceMap);
raceMap.onRaceSelectionChange(Collections.singletonList(startAnalysisDTO.regattaAndRaceIdentifier));
ArrayList<ZoomTypes> zoomTypes = new ArrayList<ZoomTypes>();
zoomTypes.add(ZoomTypes.TAILS);
raceMap.getSettings().setZoomSettings(new RaceMapZoomSettings(zoomTypes, false));
raceMap.getSettings().setHelpLinesSettings(getHelpLineSettings());
raceMap.getSettings().setTailLengthInMilliseconds(TAIL_LENGHT_IN_MILLISECONDS);
raceMap.getSettings().setTailLengthInMilliseconds(startAnalysisDTO.tailLenghtInMilliseconds);
raceTimesInfoProvider.addRaceTimesInfoProviderListener(raceMap);
raceMap.setSize("100%", getHeightForRaceMapInPixels()+"px");
startanalysis_card.add(raceMap);
/**
* Executes onResize() after the reflow of the DOM. Otherwise it has no effect.
@@ -146,12 +168,17 @@ public class StartlineAnalysisCard extends Composite implements HasWidgets, Star
}
});
}
private int getHeightForRaceMapInPixels(){
return this.getElement().getOffsetHeight() - startanalysis_card_table.getElement().getOffsetHeight() + (TABLE_MARGIN_IN_PT*3);
}
private RaceMapHelpLinesSettings getHelpLineSettings() {
HashSet<HelpLineTypes> visibleHelpLines = new HashSet<HelpLineTypes>();
visibleHelpLines.add(HelpLineTypes.STARTLINE);
visibleHelpLines.add(HelpLineTypes.BOATTAILS);
visibleHelpLines.add(HelpLineTypes.STARTLINETOFIRSTMARKTRIANGLE);
visibleHelpLines.add(HelpLineTypes.ADVANTAGELINE);
return new RaceMapHelpLinesSettings(visibleHelpLines);
}
@@ -11,6 +11,8 @@
<div ui:field="startanalysis_card_line_advantage"
class="{style.startanalysis_card_data} {style.startanalysis_card_line_advantage}"></div>
</div>
<div ui:field="startanalysis_card_race_time"
class="{style.startanalysis_card_race_time}">Time: 00:05:00</div>
<g:HTMLPanel ui:field="startanalysis_card_table"
styleName="{style.startanalysis_card_table}"></g:HTMLPanel>
</g:HTMLPanel>
@@ -240,7 +240,7 @@ public class StartlineAnalysisComponent extends Composite implements HasWidgets
ribDashboardServiceAsync.getCompetitorsInLeaderboard(leaderboardName, new AsyncCallback<List<CompetitorDTO>>() {
@Override
public void onSuccess(List<CompetitorDTO> result) {
if (result != null && !competitorSelectionPopup.isShown())
if (result != null && result.size() > 0 && !competitorSelectionPopup.isShown())
competitorSelectionPopup.show(result);
}
@@ -10,6 +10,7 @@ import com.google.gwt.user.cellview.client.HasKeyboardSelectionPolicy.KeyboardSe
import com.google.gwt.user.cellview.client.TextColumn;
import com.google.gwt.user.client.ui.AbsolutePanel;
import com.sap.sailing.dashboards.gwt.shared.dto.startanalysis.StartAnalysisCompetitorDTO;
import com.sap.sailing.gwt.ui.client.CompetitorSelectionModel;
import com.sap.sailing.gwt.ui.client.StringMessages;
import com.sap.sse.common.Util.Pair;
@@ -17,9 +18,11 @@ public class StartAnalysisStartRankTable extends AbsolutePanel {
private CellTable<StartAnalysisCompetitorDTO> table;
private StringMessages stringConstants;
private CompetitorSelectionModel competitorSelectionModel;
public StartAnalysisStartRankTable(List<StartAnalysisCompetitorDTO> saCompetitors) {
public StartAnalysisStartRankTable(List<StartAnalysisCompetitorDTO> saCompetitors, CompetitorSelectionModel competitorSelectionModel) {
stringConstants = StringMessages.INSTANCE;
this.competitorSelectionModel = competitorSelectionModel;
initTable(saCompetitors);
}
@@ -36,14 +39,22 @@ public class StartAnalysisStartRankTable extends AbsolutePanel {
StartAnalysisStartRankTableRankAtFirstMarkColumn<StartAnalysisCompetitorDTO> rankColumn = new StartAnalysisStartRankTableRankAtFirstMarkColumn<StartAnalysisCompetitorDTO>() {
@Override
public Pair<String, String> getValue(StartAnalysisCompetitorDTO saCompetitor) {
return new Pair<String, String>(""+saCompetitor.rankingTableEntryDTO.rankAtFirstMark, saCompetitor.rankingTableEntryDTO.tailColor);
String competitorColorAsHTML = competitorSelectionModel.getColor(saCompetitor.competitorDTO).getAsHtml();
if(competitorColorAsHTML == null){
competitorColorAsHTML = "#121212";
}
return new Pair<String, String>(""+saCompetitor.rankingTableEntryDTO.rankAtFirstMark, competitorColorAsHTML);
}
};
StartAnalysisStartRankTableTeamCollumn<StartAnalysisCompetitorDTO> teamColumn = new StartAnalysisStartRankTableTeamCollumn<StartAnalysisCompetitorDTO>() {
@Override
public Pair<String, String> getValue(StartAnalysisCompetitorDTO saCompetitor) {
return new Pair<String, String>(saCompetitor.rankingTableEntryDTO.teamName, saCompetitor.rankingTableEntryDTO.tailColor);
String competitorColorAsHTML = competitorSelectionModel.getColor(saCompetitor.competitorDTO).getAsHtml();
if(competitorColorAsHTML == null){
competitorColorAsHTML = "#121212";
}
return new Pair<String, String>(saCompetitor.rankingTableEntryDTO.teamName, competitorColorAsHTML);
}
};
@@ -18,6 +18,7 @@ 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.racelog.RacingProcedureType;
import com.sap.sailing.domain.tracking.LineDetails;
import com.sap.sailing.domain.tracking.MarkPassing;
import com.sap.sailing.domain.tracking.TrackedLeg;
@@ -27,72 +28,94 @@ import com.sap.sailing.server.RacingEventService;
import com.sap.sse.common.TimePoint;
import com.sap.sse.common.impl.MillisecondsTimePoint;
public class StartAnalysisDTOFactory extends AbstractStartAnalysisCreationValidator{
public class StartAnalysisDTOFactory extends AbstractStartAnalysisCreationValidator {
private final com.sap.sailing.domain.base.DomainFactory baseDomainFactory;
private static int MINIMUM_NUMBER_COMPETITORS_FOR_STARTANALYSIS = 3;
private static int DEFAULT_GATE_START_INTERVALL_IN_MILLISECONDS = 5*60*1000;
private static final Logger logger = Logger.getLogger(StartAnalysisDTOFactory.class.getName());
public StartAnalysisDTOFactory(RacingEventService racingEventService){
public StartAnalysisDTOFactory(RacingEventService racingEventService) {
baseDomainFactory = racingEventService.getBaseDomainFactory();
}
public StartAnalysisDTO createStartAnalysisForCompetitorAndTrackedRace(Competitor competitor, TrackedRace trackedRace) {
public StartAnalysisDTO createStartAnalysisForCompetitorAndTrackedRace(Competitor competitor,
TrackedRace trackedRace) {
StartAnalysisDTO startAnalysisDTO = new StartAnalysisDTO();
addStaticDataToStartAnalysisDTOFrom(startAnalysisDTO, trackedRace);
List<StartAnalysisCompetitorDTO> competitors = new ArrayList<StartAnalysisCompetitorDTO>();
Waypoint secondWaypoint = trackedRace.getRace().getCourse().getFirstLeg().getTo();
List<MarkPassing> markPassingsInOrder = convertMarkpPassingsIteratorToList(trackedRace.getMarkPassingsInOrder(secondWaypoint).iterator());
List<MarkPassing> markPassingsInOrder = convertMarkpPassingsIteratorToList(trackedRace.getMarkPassingsInOrder(
secondWaypoint).iterator());
boolean isCompetitorOneOfFirstThree = false;
for (int i = 0; i < MINIMUM_NUMBER_COMPETITORS_FOR_STARTANALYSIS; i++) {
competitors.add(createStartAnalysisCompetitorDTO(trackedRace, i + 1,
markPassingsInOrder.get(i).getCompetitor()));
competitors.add(createStartAnalysisCompetitorDTO(trackedRace, i + 1, markPassingsInOrder.get(i)
.getCompetitor()));
if (markPassingsInOrder.get(i).getCompetitor().equals(competitor)) {
isCompetitorOneOfFirstThree = true;
}
}
if (!isCompetitorOneOfFirstThree) {
int rankOfCompetitorWhilePassingSecondWaypoint = getRankOfCompetitorWhilePassingSecondWaypoint(competitor, trackedRace);
competitors.add(createStartAnalysisCompetitorDTO(trackedRace, rankOfCompetitorWhilePassingSecondWaypoint, competitor));
int rankOfCompetitorWhilePassingSecondWaypoint = getRankOfCompetitorWhilePassingSecondWaypoint(competitor,
trackedRace);
competitors.add(createStartAnalysisCompetitorDTO(trackedRace, rankOfCompetitorWhilePassingSecondWaypoint,
competitor));
}
startAnalysisDTO.competitor = baseDomainFactory.getCompetitorStore().convertToCompetitorDTO(competitor);
startAnalysisDTO.startAnalysisCompetitorDTOs = competitors;
startAnalysisDTO.timeOfStartInMilliSeconds = trackedRace.getStartOfRace().asMillis();
if (trackedRace.isGateStart()) {
logger.log(Level.INFO, "IS GATESTART");
startAnalysisDTO.racingProcedureType = RacingProcedureType.GateStart;
// Waypoint startLineWaypoint = trackedRace.getStartLine(trackedRace.getStartOfRace()).getWaypoint();
long timePointOfGolfDownTime = trackedRace.getGateStartGolfDownTime();
startAnalysisDTO.timeOfStartInMilliSeconds = trackedRace.getStartOfRace().asMillis();
if(timePointOfGolfDownTime < trackedRace.getStartOfRace().asMillis() || timePointOfGolfDownTime == 0){
startAnalysisDTO.tailLenghtInMilliseconds = DEFAULT_GATE_START_INTERVALL_IN_MILLISECONDS;
}else{
startAnalysisDTO.tailLenghtInMilliseconds = timePointOfGolfDownTime-trackedRace.getStartOfRace().asMillis();
}
} else {
startAnalysisDTO.racingProcedureType = RacingProcedureType.ESS;
startAnalysisDTO.timeOfStartInMilliSeconds = trackedRace.getStartOfRace().asMillis();
}
startAnalysisDTO.regattaAndRaceIdentifier = trackedRace.getRaceIdentifier();
logger.log(Level.INFO, "Created StartAnalysis For Competitor "+competitor.getName()+" and "+trackedRace.getRace().getName());
logger.log(Level.INFO, "Created StartAnalysis For Competitor " + competitor.getName() + " and "+ trackedRace.getRace().getName());
return startAnalysisDTO;
}
private List<MarkPassing> convertMarkpPassingsIteratorToList(Iterator<MarkPassing> iterator){
private List<MarkPassing> convertMarkpPassingsIteratorToList(Iterator<MarkPassing> iterator) {
List<MarkPassing> list = new ArrayList<MarkPassing>();
while(iterator.hasNext()){
while (iterator.hasNext()) {
list.add(iterator.next());
}
return list;
}
private int getRankOfCompetitorWhilePassingSecondWaypoint(Competitor competitor, TrackedRace trackedRace){
private int getRankOfCompetitorWhilePassingSecondWaypoint(Competitor competitor, TrackedRace trackedRace) {
Waypoint secondWaypoint = trackedRace.getRace().getCourse().getFirstLeg().getTo();
Iterator<MarkPassing> markPassings = trackedRace.getMarkPassingsInOrder(secondWaypoint).iterator();
int counter = 0;
while(markPassings.hasNext()){
counter ++;
if(markPassings.next().getCompetitor().getId().equals(competitor.getId()))
while (markPassings.hasNext()) {
counter++;
if (markPassings.next().getCompetitor().getId().equals(competitor.getId()))
return counter;
}
return 0;
}
private StartAnalysisDTO addStaticDataToStartAnalysisDTOFrom(StartAnalysisDTO startAnalysisDTO,TrackedRace trackedRace) {
private StartAnalysisDTO addStaticDataToStartAnalysisDTOFrom(StartAnalysisDTO startAnalysisDTO,
TrackedRace trackedRace) {
startAnalysisDTO.raceName = trackedRace.getRace().getName();
startAnalysisDTO.startAnalysisWindLineInfoDTO = createStartAnalysisWindAndLineData(trackedRace);
return startAnalysisDTO;
}
private StartAnalysisRankingTableEntryDTO createRankTableEntry(TrackedRace trackedRace, int rank,
Competitor competitor) {
StartAnalysisRankingTableEntryDTO startAnalysisRankTableEntryDTO = createStartAnalysisRankTableEntryDTOWithRankAndStartTimepoint(
@@ -106,8 +129,13 @@ public class StartAnalysisDTOFactory extends AbstractStartAnalysisCreationValida
tableentry.rankAtFirstMark = rank;
tableentry.teamName = competitor.getName();
tableentry.speedAtStartTime = trackedRace.getSpeed(competitor, 1).getKnots();
tableentry.distanceToLineAtStartTime = trackedRace.getDistanceToStartLine(competitor, 1).getMeters();
tableentry.tailColor = competitor.getColor().getAsHtml();
if (trackedRace.isGateStart()) {
tableentry.distanceToLineAtStartTime = trackedRace.getDistanceFromStarboardSideOfStartLineWhenPassingStart(
competitor).getMeters();
} else {
tableentry.distanceToLineAtStartTime = trackedRace.getDistanceToStartLine(competitor, 0).getMeters();
}
tableentry.tailColor = "#100100";
return tableentry;
}
@@ -115,7 +143,8 @@ public class StartAnalysisDTOFactory extends AbstractStartAnalysisCreationValida
WindAndAdvantagesInfoForStartLineDTO startAnalysisWindLineInfoDTO = new WindAndAdvantagesInfoForStartLineDTO();
LineDetails startline = trackedRace.getStartLine(trackedRace.getStartTimeReceived());
StartLineAdvantageDTO startLineAdvantageDTO = new StartLineAdvantageDTO();
startLineAdvantageDTO.startLineAdvatageType = getStartlineAdvantageType(trackedRace, new MillisecondsTimePoint(new Date()));
startLineAdvantageDTO.startLineAdvatageType = getStartlineAdvantageType(trackedRace, new MillisecondsTimePoint(
new Date()));
startLineAdvantageDTO.startLineAdvantage = startline.getAdvantage().getMeters();
startAnalysisWindLineInfoDTO.startLineAdvantage = startLineAdvantageDTO;
Position portMarkPosition = trackedRace.getOrCreateTrack(
@@ -146,7 +175,6 @@ public class StartAnalysisDTOFactory extends AbstractStartAnalysisCreationValida
}
}
private LegType getFirstLegTypeOfTrackedRaceAtTimePoint(TrackedRace trackedRace, TimePoint timePoint)
throws NoWindException {
Iterable<TrackedLeg> trackedLegs = trackedRace.getTrackedLegs();
@@ -161,7 +189,8 @@ public class StartAnalysisDTOFactory extends AbstractStartAnalysisCreationValida
private StartAnalysisCompetitorDTO createStartAnalysisCompetitorDTO(TrackedRace trackedRace, int rank,
Competitor competitor) {
StartAnalysisCompetitorDTO startAnalysisCompetitorDTOsForRace = new StartAnalysisCompetitorDTO();
startAnalysisCompetitorDTOsForRace.competitorDTO = baseDomainFactory.getCompetitorStore().convertToCompetitorDTO(competitor);
startAnalysisCompetitorDTOsForRace.competitorDTO = baseDomainFactory.getCompetitorStore()
.convertToCompetitorDTO(competitor);
startAnalysisCompetitorDTOsForRace.rankingTableEntryDTO = createRankTableEntry(trackedRace, rank, competitor);
return startAnalysisCompetitorDTOsForRace;
}
@@ -6,6 +6,7 @@ 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.racelog.RacingProcedureType;
public class StartAnalysisDTO implements Serializable, Comparable<StartAnalysisDTO> {
@@ -17,6 +18,8 @@ public class StartAnalysisDTO implements Serializable, Comparable<StartAnalysisD
public List<StartAnalysisCompetitorDTO> startAnalysisCompetitorDTOs;
public long timeOfStartInMilliSeconds;
public RegattaAndRaceIdentifier regattaAndRaceIdentifier;
public RacingProcedureType racingProcedureType;
public long tailLenghtInMilliseconds;
public StartAnalysisDTO() {
}