bug6209: show path propabilities in debug PDF output

+ # Bottom row with path vote diagnostics AND ports for OUTGOING edges

+ path_votes = node.get('pathVotes', {})

+

+ vote_info = path_votes.get(type_name, {})

+ path_count = vote_info.get('pathCount', 0)

+ quality_sum = vote_info.get('qualitySum', 0)

+ if path_count > 0:

+ # Format quality sum in scientific notation if very small

+ if quality_sum < 0.001:

+ qs_str = f'{quality_sum:.1e}'

+ else:

+ qs_str = f'{quality_sum:.3f}'

+ vote_content = f'<FONT POINT-SIZE="6" COLOR="gray40">{path_count}p/{qs_str}</FONT>'

+ else:

+ vote_content = '<FONT POINT-SIZE="6" COLOR="gray70">-</FONT>'

+ html += f'<TD PORT="{out_port_name}" BGCOLOR="white">{vote_content}</TD>'

+import java.util.ArrayList;

+import java.util.List;

+import java.util.function.Supplier;

+import java.util.stream.Collectors;

+import com.sap.sailing.windestimation.aggregator.graph.DijkstraShortestPathFinderImpl;

+import com.sap.sailing.windestimation.aggregator.graph.DijsktraShortestPathFinder;

+import com.sap.sailing.windestimation.aggregator.graph.ElementAdjacencyQualityMetric;

+import com.sap.sailing.windestimation.aggregator.graph.InnerGraphSuccessorSupplier;

+ // Collect path vote diagnostics for debugging

+ final Map<MstGraphLevel, Map<ManeuverTypeForClassification, List<Double>>> pathVotes =

+ collectPathVoteDiagnostics(graphComponents);

+

+ final Map<String, String> bestNodePerLevel = collectBestNodePerLevel(graphComponents, levelToId, pathVotes);

+ exportNode(root, writer, firstNode, exportLevelToId, exportNodeIdCounter, 0, pathVotes);

+ Map<MstGraphLevel, Integer> levelToId, int[] nodeIdCounter, int depth,

+ Map<MstGraphLevel, Map<ManeuverTypeForClassification, List<Double>>> pathVotes) throws IOException {

+ writer.write("\n ],\n");

+ // Add diagnostic info about path votes for this node

+ writer.write(" \"pathVotes\": " + formatPathVoteDiagnostics(level, pathVotes) + "\n");

+ exportNode(child, writer, firstNode, levelToId, nodeIdCounter, depth + 1, pathVotes);

+ /**

+ * Collects diagnostic information about which paths voted for which classification at each node.

+ * This runs Dijkstra from each leaf and records which classification was selected and with what path quality.

+ */

+ private Map<MstGraphLevel, Map<ManeuverTypeForClassification, List<Double>>> collectPathVoteDiagnostics(

+ MstManeuverGraphComponents graphComponents) {

+ final Map<MstGraphLevel, Map<ManeuverTypeForClassification, List<Double>>> result = new HashMap<>();

+

+ final ElementAdjacencyQualityMetric<GraphNode<MstGraphLevel>> edgeQualityMetric = (previousNode, currentNode) -> {

+ return transitionProbabilitiesCalculator.getTransitionProbability(currentNode, previousNode,

+ previousNode.getGraphLevel() == null ? 0.0 : previousNode.getGraphLevel().getDistanceToParent());

+ };

+

+ for (MstGraphLevel leaf : graphComponents.getLeaves()) {

+ final InnerGraphSuccessorSupplier<GraphNode<MstGraphLevel>, MstGraphLevel> innerGraphSuccessorSupplier =

+ new InnerGraphSuccessorSupplier<>(graphComponents,

+ (final Supplier<String> nameSupplier) -> new GraphNode<MstGraphLevel>(

+ null, null, new WindCourseRange(0, 360), 1.0, 0, null) {

+ @Override

+ public String toString() {

+ return nameSupplier.get();

+ }

+ });

+

+ final DijsktraShortestPathFinder<GraphNode<MstGraphLevel>> dijkstra =

+ new DijkstraShortestPathFinderImpl<>(

+ innerGraphSuccessorSupplier.getArtificialLeaf(leaf),

+ innerGraphSuccessorSupplier.getArtificialRoot(),

+ innerGraphSuccessorSupplier, edgeQualityMetric);

+

+ for (GraphNode<MstGraphLevel> node : dijkstra.getShortestPath()) {

+ if (node.getGraphLevel() != null) {

+ Map<ManeuverTypeForClassification, List<Double>> votesForNode =

+ result.computeIfAbsent(node.getGraphLevel(), k -> new HashMap<>());

+ votesForNode.computeIfAbsent(node.getManeuverType(), k -> new ArrayList<>())

+ .add(dijkstra.getPathQuality());

+ }

+ }

+ }

+

+ return result;

+ }

+

+ Map<MstGraphLevel, Integer> levelToId,

+ Map<MstGraphLevel, Map<ManeuverTypeForClassification, List<Double>>> pathVotes) {

+

+ // Determine best classification per node based on sum of path qualities

+ for (Map.Entry<MstGraphLevel, Map<ManeuverTypeForClassification, List<Double>>> entry : pathVotes.entrySet()) {

+ MstGraphLevel level = entry.getKey();

+ Map<ManeuverTypeForClassification, List<Double>> votes = entry.getValue();

+

+ // Find classification with highest sum of path qualities

+ double maxSum = -1;

+ ManeuverTypeForClassification bestType = null;

+

+ for (Map.Entry<ManeuverTypeForClassification, List<Double>> typeVotes : votes.entrySet()) {

+ double sum = typeVotes.getValue().stream().mapToDouble(Double::doubleValue).sum();

+ if (sum > maxSum) {

+ maxSum = sum;

+ bestType = typeVotes.getKey();

+ }

+ }

+

+ if (bestType != null) {

+ bestNodePerLevel.put(String.valueOf(nodeId), bestType.name());

+

+

+ /**

+ * Formats path vote diagnostics for a node as a JSON string for inclusion in the export.

+ */

+ private String formatPathVoteDiagnostics(MstGraphLevel level,

+ Map<MstGraphLevel, Map<ManeuverTypeForClassification, List<Double>>> pathVotes) {

+ Map<ManeuverTypeForClassification, List<Double>> votes = pathVotes.get(level);

+ if (votes == null || votes.isEmpty()) {

+ return "{}";

+ }

+

+ StringBuilder sb = new StringBuilder();

+ sb.append("{");

+ boolean first = true;

+ for (ManeuverTypeForClassification type : ManeuverTypeForClassification.values()) {

+ List<Double> typeVotes = votes.get(type);

+ if (typeVotes != null && !typeVotes.isEmpty()) {

+ if (!first) sb.append(", ");

+ first = false;

+ double sum = typeVotes.stream().mapToDouble(Double::doubleValue).sum();

+ sb.append("\"").append(type.name()).append("\": {");

+ sb.append("\"pathCount\": ").append(typeVotes.size());

+ sb.append(", \"qualitySum\": ").append(sum);

+ sb.append(", \"qualities\": [");

+ sb.append(typeVotes.stream().map(d -> String.format("%.6e", d)).collect(Collectors.joining(", ")));

+ sb.append("]}");

+ }

+ }

+ sb.append("}");

+ return sb.toString();

+ }