Merge remote-tracking branch 'eclipse/main' into eclipse-main

Author: axeluhl

java/com.sap.sailing.domain.common/src/com/sap/sailing/domain/common/confidence/impl/ScalableWind.java

@@ -13,8 +13,6 @@
  * Wind values are scaled by separately scaling their speed and bearing, and separately scaling their time point, and
  * separately scaling their position. For the separate speed/bearing scaling see also {@link ScalableSpeedWithBearing}.<p>
  * 
- * Internally, the 
- * 
  * @author Axel Uhl (d043530)
  *
  */

java/com.sap.sailing.gwt.ui/src/main/java/com/sap/sailing/gwt/home/desktop/places/whatsnew/resources/SailingAnalyticsNotes.html

@@ -14,6 +14,11 @@ <h5 class="articleSubheadline">August 2026</h5>
                 year's episode of that event.</li>
             <li>Show one decimal place in wind chart tool-tips, so, e.g., a wind speed series tool-tip
                 may read "16.6kts" now.</li>
+            <li>New API method on end point /sailingserver/api/v1/regattas/{regattaname}/races/{racename}/wind_at_position
+                allows clients with the <tt>TRACKED_RACE:EXPORT</tt> permission for the race in question
+                to obtain position-based interpolated wind data taking all non-excluded wind sources available
+                for that race into account, computing a weighted average that matches what is being used for
+                competitor-specific VMG and TWA calculations alike.</li>
          </ul>
          <h5 class="articleSubheadline">July 2026</h5>
          <ul class="bulletList">

java/com.sap.sailing.gwt.ui/src/main/java/com/sap/sailing/gwt/ui/client/SailingService.java

@@ -443,7 +443,7 @@ Iterable<DetailType> determineDetailTypesForCompetitorChart(String leaderboardGr
      *             is thrown if the leaderboard is not found by name
      */
     PairingListTemplateDTO calculatePairingListTemplate(final int flightCount, final int groupCount,
-            final int competitorCount, final int flightMultiplier, final int tolerance)
+            final int competitorCount, final int flightMultiplier, final int boatChangeFactor)
             throws UnauthorizedException, NotFoundException, IllegalArgumentException;
 
     PairingListDTO getPairingListFromTemplate(String leaderboardName, int flightMultiplier,

java/com.sap.sailing.gwt.ui/src/main/java/com/sap/sailing/gwt/ui/client/shared/racemap/Colorline.java

@@ -171,11 +171,19 @@ public void setPath(final MVCArray<LatLng> path) {
             polylines.add(createPolyline(path, 0));
             break;
         case POLYCHROMATIC:
-            for (int i = 0; i < path.getLength() - 1; i++) {
-                MVCArray<LatLng> subPath = MVCArray.newInstance();
-                subPath.push(path.get(i));
-                subPath.push(path.get(i + 1));
-                polylines.add(createPolyline(subPath, i));
+            if (path.getLength() == 1) {
+                // A single vertex cannot form a segment; represent it as one Polyline holding just that vertex,
+                // mirroring the interim single-vertex representation insertAt builds up and getLength's case 1 expects
+                final MVCArray<LatLng> subPath = MVCArray.newInstance();
+                subPath.push(path.get(/* i */ 0));
+                polylines.add(createPolyline(subPath, /* fixIndexInTail */ 0));
+            } else {
+                for (int i = 0; i < path.getLength() - 1; i++) {
+                    final MVCArray<LatLng> subPath = MVCArray.newInstance();
+                    subPath.push(path.get(i));
+                    subPath.push(path.get(i + 1));
+                    polylines.add(createPolyline(subPath, i));
+                }
             }
             break;
         }

java/com.sap.sailing.gwt.ui/src/main/java/com/sap/sailing/gwt/ui/server/SailingServiceImpl.java

@@ -5050,10 +5050,10 @@ public List<ExpeditionDeviceConfiguration> getExpeditionDeviceConfigurations() {
 
     @Override
     public PairingListTemplateDTO calculatePairingListTemplate(final int flightCount, final int groupCount,
-            final int competitorCount, final int flightMultiplier, final int tolerance) {
+            final int competitorCount, final int flightMultiplier, final int boatChangeFactor) {
         PairingListTemplate template = getService().createPairingListTemplate(flightCount, groupCount, competitorCount,
-                flightMultiplier, tolerance);
-        return new PairingListTemplateDTO(flightCount, groupCount, competitorCount, flightMultiplier, tolerance,
+                flightMultiplier, boatChangeFactor);
+        return new PairingListTemplateDTO(flightCount, groupCount, competitorCount, flightMultiplier, boatChangeFactor,
                 template.getBoatChanges(), template.getPairingListTemplate(), template.getQuality(), template.getBoatAssignmentsQuality());
     }
 

java/com.sap.sailing.server.gateway.serialization/src/com/sap/sailing/server/gateway/serialization/impl/DefaultWindTrackJsonSerializer.java

@@ -1,7 +1,6 @@
 package com.sap.sailing.server.gateway.serialization.impl;
 
-import java.util.ArrayList;
-import java.util.Iterator;
+import java.util.function.Function;
 
 import org.json.simple.JSONArray;
 import org.json.simple.JSONObject;
@@ -36,39 +35,48 @@ public DefaultWindTrackJsonSerializer(int maxNumberOfFixes, TimePoint fromTime,
     }
 
     public JSONObject serialize(final WindTrack windTrack) {
-        JSONObject result = new JSONObject();
-        JSONArray jsonWindFixes = new JSONArray();
-        // quickly extract relevant fixes to hold locks as shortly as possible; process later
-        ArrayList<Wind> fixes = new ArrayList<>();
         windTrack.lockForRead();
         try {
-            Iterator<Wind> windIter = windTrack.getFixesIterator(fromTime, /* inclusive */true, toTime, /* inclusive */ false);
-            int count = 0;
-            while ((maxNumberOfFixes == -1 || count++<maxNumberOfFixes) && windIter.hasNext()) {
-                fixes.add(windIter.next());
-            }
+            return serializeFixesFromWindSource(windSource, ()->windTrack.getFixesIterator(fromTime, /* inclusive */true, toTime, /* inclusive */ false),
+                    /* averager */ wind->windTrack.getAveragedWind(wind.getPosition(), wind.getTimePoint()), maxNumberOfFixes);
         } finally {
             windTrack.unlockAfterRead();
         }
-        for (Wind wind : fixes) {
-            JSONObject jsonWind = new JSONObject();
-            jsonWind.put("trueBearing-deg", RoundingUtil.bearingDecimalFormatter.format(wind.getBearing().getDegrees()));
-            jsonWind.put("speed-kts", RoundingUtil.speedDecimalFormatter.format(wind.getKnots()));
-            jsonWind.put("speed-m/s", RoundingUtil.speedDecimalFormatter.format(wind.getMetersPerSecond()));
-            if (wind.getTimePoint() != null) {
-                jsonWind.put("timepoint-ms", wind.getTimePoint().asMillis());
-                final Wind averagedWind = windTrack.getAveragedWind(wind.getPosition(), wind.getTimePoint());
-                jsonWind.put("dampenedTrueBearing-deg", RoundingUtil.bearingDecimalFormatter.format(averagedWind.getBearing().getDegrees()));
-                jsonWind.put("dampenedSpeed-kts", RoundingUtil.speedDecimalFormatter.format(averagedWind.getKnots()));
-                jsonWind.put("dampenedSpeed-m/s", RoundingUtil.speedDecimalFormatter.format(averagedWind.getMetersPerSecond()));
-            }
-            if (wind.getPosition() != null) {
-                jsonWind.put("lat-deg", RoundingUtil.latLngDecimalFormatter.format(wind.getPosition().getLatDeg()));
-                jsonWind.put("lng-deg", RoundingUtil.latLngDecimalFormatter.format(wind.getPosition().getLngDeg()));
+    }
+
+    public static JSONObject serializeFixesFromWindSource(final WindSource windSource, final Iterable<Wind> fixes, final Function<Wind, Wind> averager, int maxNumberOfFixes) {
+        final JSONObject result = new JSONObject();
+        final JSONArray jsonWindFixes = new JSONArray();
+        int count = 0;
+        for (final Wind wind : fixes) {
+            if (maxNumberOfFixes == 1 || count++ >= maxNumberOfFixes) {
+                break;
             }
+            final Wind averagedWind = wind.getTimePoint() == null ? null : averager.apply(wind);
+            JSONObject jsonWind = getWindAsJson(wind, averagedWind);
             jsonWindFixes.add(jsonWind);
         }
         result.put(windSource.getType() + (windSource.getId() != null ? "-"+windSource.getId().toString() : ""), jsonWindFixes);
         return result;
     }
+
+    public static JSONObject getWindAsJson(Wind wind, final Wind averagedWind) {
+        final JSONObject jsonWind = new JSONObject();
+        jsonWind.put("trueBearing-deg", RoundingUtil.bearingDecimalFormatter.format(wind.getBearing().getDegrees()));
+        jsonWind.put("speed-kts", RoundingUtil.speedDecimalFormatter.format(wind.getKnots()));
+        jsonWind.put("speed-m/s", RoundingUtil.speedDecimalFormatter.format(wind.getMetersPerSecond()));
+        if (wind.getTimePoint() != null) {
+            jsonWind.put("timepoint-ms", wind.getTimePoint().asMillis());
+        }
+        if (averagedWind != null) {
+            jsonWind.put("dampenedTrueBearing-deg", RoundingUtil.bearingDecimalFormatter.format(averagedWind.getBearing().getDegrees()));
+            jsonWind.put("dampenedSpeed-kts", RoundingUtil.speedDecimalFormatter.format(averagedWind.getKnots()));
+            jsonWind.put("dampenedSpeed-m/s", RoundingUtil.speedDecimalFormatter.format(averagedWind.getMetersPerSecond()));
+        }
+        if (wind.getPosition() != null) {
+            jsonWind.put("lat-deg", RoundingUtil.latLngDecimalFormatter.format(wind.getPosition().getLatDeg()));
+            jsonWind.put("lng-deg", RoundingUtil.latLngDecimalFormatter.format(wind.getPosition().getLngDeg()));
+        }
+        return jsonWind;
+    }
 }

java/com.sap.sailing.server.gateway.serialization/src/com/sap/sailing/server/gateway/serialization/impl/TrackedRaceJsonSerializer.java

@@ -26,11 +26,11 @@ public class TrackedRaceJsonSerializer implements JsonSerializer<TrackedRace> {
     private final String windSourceIdToSerialize;
     private final Function<WindSource, WindTrackJsonSerializer> windTrackSerializerProducer;
 
-    public TrackedRaceJsonSerializer(Function<WindSource, WindTrackJsonSerializer> windTrackSerializer, String windSourceToSerialize, String windSourceIdToSerialize) {
+    public TrackedRaceJsonSerializer(final Function<WindSource, WindTrackJsonSerializer> windTrackSerializer,
+            final String windSourceToSerialize, final String windSourceIdToSerialize) {
         this.windTrackSerializerProducer = windTrackSerializer;
         this.windSourceToSerialize = windSourceToSerialize;
         this.windSourceIdToSerialize = windSourceIdToSerialize;
-        windSourceToSerialize = WindSourceType.COMBINED.name();
     }
 
     public JSONObject serialize(TrackedRace trackedRace) {

java/com.sap.sailing.server.gateway/src/com/sap/sailing/server/gateway/jaxrs/api/RegattasResource.java

@@ -91,14 +91,17 @@
 import com.sap.sailing.domain.common.RegattaNameAndRaceName;
 import com.sap.sailing.domain.common.Tack;
 import com.sap.sailing.domain.common.TargetTimeInfo;
+import com.sap.sailing.domain.common.Wind;
 import com.sap.sailing.domain.common.WindSource;
+import com.sap.sailing.domain.common.WindSourceType;
 import com.sap.sailing.domain.common.abstractlog.NotRevokableException;
 import com.sap.sailing.domain.common.dto.CompetitorDTO;
 import com.sap.sailing.domain.common.dto.FleetDTO;
 import com.sap.sailing.domain.common.dto.LeaderboardDTO;
 import com.sap.sailing.domain.common.dto.LeaderboardEntryDTO;
 import com.sap.sailing.domain.common.dto.LeaderboardRowDTO;
 import com.sap.sailing.domain.common.dto.LegEntryDTO;
+import com.sap.sailing.domain.common.impl.WindImpl;
 import com.sap.sailing.domain.common.polars.NotEnoughDataHasBeenAddedException;
 import com.sap.sailing.domain.common.security.SecuredDomainType;
 import com.sap.sailing.domain.common.security.SecuredDomainType.LeaderboardActions;
@@ -178,6 +181,7 @@
 import com.sap.sse.common.Color;
 import com.sap.sse.common.Distance;
 import com.sap.sse.common.Duration;
+import com.sap.sse.common.Position;
 import com.sap.sse.common.Speed;
 import com.sap.sse.common.SpeedWithBearing;
 import com.sap.sse.common.TimePoint;
@@ -186,6 +190,7 @@
 import com.sap.sse.common.Util.Pair;
 import com.sap.sse.common.Util.Triple;
 import com.sap.sse.common.WithID;
+import com.sap.sse.common.impl.DegreePosition;
 import com.sap.sse.common.impl.MillisecondsDurationImpl;
 import com.sap.sse.common.impl.MillisecondsTimePoint;
 import com.sap.sse.common.impl.RGBColor;
@@ -209,7 +214,7 @@
 @Path("/v1/regattas")
 public class RegattasResource extends AbstractSailingServerResource {
     private static final String SECONDARY_USER_BEARER_TOKEN = "secondaryuserbearertoken";
-
+    private static final int MAX_NUMBER_OF_WIND_FIXES_PER_REQUEST = 10000;
     private static final Logger logger = Logger.getLogger(RegattasResource.class.getName());
 
     private DataMiningResource dataMiningResource;
@@ -1775,6 +1780,11 @@ public Response getHighQualityWindFixes(@PathParam("regattaname") String regatta
         return response;
     }
 
+    @FunctionalInterface
+    private static interface WindForTrackedRaceSerializerFactory {
+        JsonSerializer<TrackedRace> getSerializer(TimePoint finalFrom, TimePoint finalTo);
+    }
+
     @GET
     @Produces("application/json;charset=UTF-8")
     @Path("{regattaname}/races/{racename}/wind")
@@ -1785,6 +1795,93 @@ public Response getWind(@PathParam("regattaname") String regattaName, @PathParam
             @QueryParam("totimeasmillis") Long totimeasmillis,
             @HeaderParam(SECONDARY_USER_BEARER_TOKEN) String secondaryUserBearerToken,
             @Context HttpServletRequest request) {
+        return getWindWithSerializer(regattaName, raceName, fromtime, fromtimeasmillis, totime, totimeasmillis, secondaryUserBearerToken, request,
+                (finalFrom, finalTo)->new TrackedRaceJsonSerializer(
+                        ws -> new DefaultWindTrackJsonSerializer(MAX_NUMBER_OF_WIND_FIXES_PER_REQUEST, finalFrom, finalTo,ws), windSource, windSourceId));
+    }
+
+    @GET
+    @Produces("application/json;charset=UTF-8")
+    @Path("{regattaname}/races/{racename}/wind_at_position")
+    public Response getWindAtPosition(@PathParam("regattaname") String regattaName, @PathParam("racename") String raceName,
+            @QueryParam("fromtime") String fromtime,
+            @QueryParam("fromtimeasmillis") Long fromtimeasmillis, @QueryParam("totime") String totime,
+            @QueryParam("totimeasmillis") Long totimeasmillis,
+            @QueryParam("intervalasmillis") Long intervalasmillis,
+            @QueryParam("latDeg[]") List<Double> latitudesInDegrees,
+            @QueryParam("lngDeg[]") List<Double> longitudesInDegrees,
+            @HeaderParam(SECONDARY_USER_BEARER_TOKEN) String secondaryUserBearerToken,
+            @Context HttpServletRequest request) {
+        final Response response;
+        if (latitudesInDegrees == null || longitudesInDegrees == null) {
+            response = Response.serverError().entity("Latitudes and longitudes must be provided as query parameters latDeg[] and lngDeg[]").build();
+        } else if (latitudesInDegrees.size() != longitudesInDegrees.size()) {
+            response = Response.serverError().entity("Latitudes and longitudes arrays in query parameters latDeg[] and lngDeg[] must have equal count").build();
+        } else if (intervalasmillis == null) {
+            response = Response.serverError().entity("intervalasmillis query parameter is missing").build();
+        } else if (intervalasmillis <= 0) {
+            response = Response.serverError().entity("intervalasmillis query parameter must be a positive value").build();
+        } else {
+            response = getWindWithSerializer(regattaName, raceName, fromtime, fromtimeasmillis, totime, totimeasmillis, secondaryUserBearerToken, request,
+                new WindForTrackedRaceSerializerFactory() {
+                    @Override
+                    public JsonSerializer<TrackedRace> getSerializer(TimePoint finalFrom, TimePoint finalTo) {
+                        return new JsonSerializer<TrackedRace>() {
+                            @Override
+                            public JSONObject serialize(TrackedRace trackedRace) {
+                                return serializeWindAtPositionsAndTimePoints(trackedRace, finalFrom, finalTo,
+                                        new MillisecondsDurationImpl(intervalasmillis), latitudesInDegrees,
+                                        longitudesInDegrees);
+                            }
+                        };
+                    }
+                });
+        }
+        return response;
+    }
+    
+    private JSONObject serializeWindAtPositionsAndTimePoints(TrackedRace trackedRace, TimePoint from,
+            TimePoint to, Duration interval, List<Double> latitudesInDegrees, List<Double> longitudesInDegrees) {
+        final Iterable<Wind> windIterable = new Iterable<Wind>() {
+            @Override
+            public Iterator<Wind> iterator() {
+                return new Iterator<Wind>() {
+                    private TimePoint timePoint = from;
+                    private int count = 0;
+                    
+                    @Override
+                    public boolean hasNext() {
+                        return timePoint != null && (to == null || !timePoint.after(to));
+                    }
+
+                    @Override
+                    public Wind next() {
+                        final Position position = new DegreePosition(latitudesInDegrees.get(count), longitudesInDegrees.get(count));
+                        // TODO bug6281: the position gets lost when asking the tracked race for wind at that position because we get an average from all wind sources,
+                        // including the averaged position. We may want to pass the requested position into the response, too, but how?
+                        final Wind windFromRace = trackedRace.getWind(position, timePoint);
+                        final Wind result = new WindImpl(position, timePoint, windFromRace);
+                        count++;
+                        if (count >= latitudesInDegrees.size()) {
+                            timePoint = timePoint.plus(interval);
+                            count = 0;
+                        }
+                        return result;
+                    }
+                };
+            }
+        };
+        return DefaultWindTrackJsonSerializer.serializeFixesFromWindSource(trackedRace.getWindSources(WindSourceType.COMBINED).iterator().next(),
+                windIterable, wind->wind, MAX_NUMBER_OF_WIND_FIXES_PER_REQUEST);
+    }
+
+    private Response getWindWithSerializer(final String regattaName, final String raceName,
+            final String fromtime,
+            final Long fromtimeasmillis, final String totime,
+            final Long totimeasmillis,
+            final String secondaryUserBearerToken,
+            final HttpServletRequest request,
+            final WindForTrackedRaceSerializerFactory serializerFactory) {
         Response response;
         final String clientIP = HttpRequestUtils.getClientIP(request);
         final String userAgent = HttpRequestUtils.getUserAgent(request);
@@ -1830,12 +1927,7 @@ public Response getWind(@PathParam("regattaname") String regattaName, @PathParam
                     final TimePoint finalFrom = Util.getLatestOfTimePoints(from, trackedRace.getStartOfTracking());
                     final TimePoint finalTo = Util.getEarliestOfTimePoints(to, Util.getEarliestOfTimePoints(
                             trackedRace.getEndOfTracking(), trackedRace.getTimePointOfNewestEvent()));
-                    final TrackedRaceJsonSerializer serializer = new TrackedRaceJsonSerializer(
-                            ws -> new DefaultWindTrackJsonSerializer(/* maxNumberOfFixes */ 10000, finalFrom, finalTo,
-                                    ws),
-                            windSource, windSourceId);
-
-                    final JSONObject jsonWindTracks = serializer.serialize(trackedRace);
+                    final JSONObject jsonWindTracks = serializerFactory.getSerializer(finalFrom, finalTo).serialize(trackedRace);
                     response = Response.ok(streamingOutput(jsonWindTracks)).build();
                 }
             }