LaneStructureAnimation.java

  1. package org.opentrafficsim.animation.lane;

  3. import java.awt.BasicStroke;
  4. import java.awt.Color;
  5. import java.awt.Graphics2D;
  6. import java.awt.geom.Path2D;
  7. import java.awt.image.ImageObserver;
  8. import java.lang.reflect.Field;
  9. import java.rmi.RemoteException;
  10. import java.util.LinkedHashSet;
  11. import java.util.Set;

  13. import javax.naming.NamingException;

  15. import org.djutils.draw.point.OrientedPoint2d;
  16. import org.djutils.draw.point.Point2d;
  17. import org.djutils.exceptions.Try;
  18. import org.opentrafficsim.base.geometry.OtsRenderable;
  19. import org.opentrafficsim.core.geometry.OtsLine2d;
  20. import org.opentrafficsim.core.gtu.Gtu;
  21. import org.opentrafficsim.road.gtu.lane.perception.LaneStructureRecord;
  22. import org.opentrafficsim.road.gtu.lane.perception.RollingLaneStructure;
  23. import org.opentrafficsim.road.gtu.lane.perception.RollingLaneStructureRecord;
  24. import org.opentrafficsim.road.gtu.lane.perception.RollingLaneStructureRecord.RecordLink;

  26. /**
  27.  * LaneStructureAnimation.java.
  28.  * <p>
  29.  * Copyright (c) 2013-2024 Delft University of Technology, PO Box 5, 2600 AA, Delft, the Netherlands. All rights reserved. <br>
  30.  * BSD-style license. See <a href="https://opentrafficsim.org/docs/license.html">OpenTrafficSim License</a>.
  31.  * </p>
  32.  * @author <a href="https://github.com/averbraeck" target="_blank">Alexander Verbraeck</a>
  33.  */
  34. public class LaneStructureAnimation extends OtsRenderable<LaneStructureLocatable>
  35. {
  36.     /** Destroyed. */
  37.     private boolean isDestroyed = false;

  39.     /**
  40.      * @param source LaneStructureLocatable; dummy locatable
  41.      * @throws NamingException on naming exception
  42.      * @throws RemoteException on remote exception
  43.      */
  44.     LaneStructureAnimation(final LaneStructureLocatable source) throws NamingException, RemoteException
  45.     {
  46.         super(source, source.getGtu().getSimulator());
  47.         this.setFlip(false);
  48.         this.setRotate(false);
  49.     }

  51.     /** {@inheritDoc} */
  52.     @Override
  53.     public void paint(final Graphics2D graphics, final ImageObserver observer)
  54.     {
  55.         if (!this.isDestroyed)
  56.         {
  57.             setRendering(graphics);
  58.             if (getSource().getGtu().isDestroyed())
  59.             {
  60.                 this.isDestroyed = true;
  61.                 Try.execute(() -> destroy(getSource().getGtu().getSimulator()),
  62.                         "Exception during deletion of LaneStructureAnimation.");
  63.                 return;
  64.             }
  65.             else
  66.             {
  67.                 LaneStructureRecord rt = getSource().getRollingLaneStructure().getRootRecord();
  68.                 if (rt != null)
  69.                 {
  70.                     paintRecord(rt, graphics);
  71.                 }
  72.             }
  73.             resetRendering(graphics);
  74.         }
  75.     }

  77.     /**
  78.      * @param lsr LaneStructureRecord; record
  79.      * @param graphics Graphics2D; graphics
  80.      */
  81.     @SuppressWarnings({"unchecked"})
  82.     private void paintRecord(final LaneStructureRecord lsr, final Graphics2D graphics)
  83.     {
  84.         // line
  85.         OrientedPoint2d loc = Try.assign(() -> getSource().getLocation(), "Unable to return location.");
  86.         graphics.setStroke(new BasicStroke(
  87.                 getSource().getRollingLaneStructure().animationAccess.getCrossSectionRecords().containsValue(lsr) ? 1.0f
  88.                         : 0.5f));
  89.         graphics.setColor(
  90.                 getSource().getRollingLaneStructure().animationAccess.getCrossSectionRecords().containsValue(lsr) ? Color.PINK
  91.                         : getSource().getRollingLaneStructure().animationAccess.getUpstreamEdge().contains(lsr) ? Color.MAGENTA
  92.                                 : getSource().getRollingLaneStructure().animationAccess.getDownstreamEdge().contains(lsr)
  93.                                         ? Color.GREEN : Color.CYAN);
  94.         OtsLine2d line = Try.assign(() -> lsr.getLane().getCenterLine().extractFractional(0.1, 0.9),
  95.                 "Exception while painting LaneStructures");
  96.         Path2D.Double path = new Path2D.Double();
  97.         boolean start = true;
  98.         for (Point2d point : line.getPoints())
  99.         {
  100.             if (start)
  101.             {
  102.                 path.moveTo(point.x - loc.x, -(point.y - loc.y));
  103.                 start = false;
  104.             }
  105.             else
  106.             {
  107.                 path.lineTo(point.x - loc.x, -(point.y - loc.y));
  108.             }
  109.         }
  110.         graphics.draw(path);
  111.         // connection
  112.         Field sourceField = Try.assign(() -> RollingLaneStructureRecord.class.getDeclaredField("source"),
  113.                 "Exception while painting LaneStructure");
  114.         sourceField.setAccessible(true);
  115.         LaneStructureRecord src =
  116.                 Try.assign(() -> (LaneStructureRecord) sourceField.get(lsr), "Exception while painting LaneStructure");
  117.         if (src != null)
  118.         {
  119.             Field sourceLinkField = Try.assign(() -> RollingLaneStructureRecord.class.getDeclaredField("sourceLink"),
  120.                     "Exception while painting LaneStructure");
  121.             sourceLinkField.setAccessible(true);
  122.             RecordLink link = (RecordLink) Try.assign(() -> sourceLinkField.get(lsr), "Exception while painting LaneStructure");
  123.             float f1 = link.equals(RecordLink.DOWN) ? 0.9f : link.equals(RecordLink.UP) ? 0.1f : 0.5f;
  124.             float f2 = link.equals(RecordLink.DOWN) ? 0.0f : link.equals(RecordLink.UP) ? 1.0f : 0.5f;
  125.             float f3 = f1;
  126.             float f4 = f2;
  127.             OrientedPoint2d p1 = Try.assign(() -> src.getLane().getCenterLine().getLocationFraction(f3),
  128.                     "Exception while painting LaneStructure");
  129.             OrientedPoint2d p2 = Try.assign(() -> line.getLocationFraction(f4), "Exception while painting LaneStructure");
  130.             path = new Path2D.Double();
  131.             path.moveTo(p1.x - loc.x, -(p1.y - loc.y));
  132.             path.lineTo(p2.x - loc.x, -(p2.y - loc.y));
  133.             graphics.setStroke(
  134.                     new BasicStroke(0.15f, BasicStroke.CAP_SQUARE, BasicStroke.JOIN_MITER, 10f, new float[] {.3f, 1.2f}, 0f));
  135.             graphics.setColor(Color.DARK_GRAY);
  136.             graphics.draw(path);
  137.         }
  138.         // left/right
  139.         paintLateralConnection(lsr, lsr.getLeft(), Color.RED, graphics, loc);
  140.         paintLateralConnection(lsr, lsr.getRight(), Color.BLUE, graphics, loc);
  141.         // recursion to depending records
  142.         Field dependentField = Try.assign(() -> RollingLaneStructureRecord.class.getDeclaredField("dependentRecords"),
  143.                 "Exception while painting LaneStructure");
  144.         dependentField.setAccessible(true);
  145.         Set<LaneStructureRecord> dependables =
  146.                 (Set<LaneStructureRecord>) Try.assign(() -> dependentField.get(lsr), "Exception while painting LaneStructure");
  147.         if (dependables != null)
  148.         {
  149.             for (LaneStructureRecord dependable : new LinkedHashSet<>(dependables)) // concurrency
  150.             {
  151.                 paintRecord(dependable, graphics);
  152.             }
  153.         }
  154.     }

  156.     /**
  157.      * Paint the connection to a lateral record.
  158.      * @param main LaneStructureRecord; main record
  159.      * @param adj LaneStructureRecord; adjacent record, can be {@code null}
  160.      * @param color Color; color
  161.      * @param graphics Graphics2D; graphics
  162.      * @param loc OrientedPoint2d; location
  163.      */
  164.     private void paintLateralConnection(final LaneStructureRecord main, final LaneStructureRecord adj, final Color color,
  165.             final Graphics2D graphics, final OrientedPoint2d loc)
  166.     {
  167.         if (adj == null)
  168.         {
  169.             return;
  170.         }
  171.         float f1 = 0.45f;
  172.         float f2 = 0.55f;
  173.         OrientedPoint2d p1 = Try.assign(() -> main.getLane().getCenterLine().getLocationFraction(f1),
  174.                 "Exception while painting LaneStructure");
  175.         OrientedPoint2d p2 = Try.assign(() -> adj.getLane().getCenterLine().getLocationFraction(f2),
  176.                 "Exception while painting LaneStructure");
  177.         Path2D.Double path = new Path2D.Double();
  178.         path.moveTo(p1.x - loc.x, -(p1.y - loc.y));
  179.         path.lineTo(p2.x - loc.x, -(p2.y - loc.y));
  180.         graphics.setStroke(
  181.                 new BasicStroke(0.05f, BasicStroke.CAP_SQUARE, BasicStroke.JOIN_MITER, 10f, new float[] {.15f, 0.6f}, 0f));
  182.         graphics.setColor(color);
  183.         graphics.draw(path);
  184.     }

  186.     /**
  187.      * Enables visualization of this lane structure. This is purely for debugging purposes.
  188.      * @param rollingLaneStructure RollingLaneStructure; the lane structure to visualize
  189.      * @param gtu Gtu; GTU to animate the LaneStructure of
  190.      */
  191.     public static final void visualize(final RollingLaneStructure rollingLaneStructure, final Gtu gtu)
  192.     {
  193.         Try.execute(() -> new LaneStructureAnimation(new LaneStructureLocatable(rollingLaneStructure, gtu)),
  194.                 "Could not create animation.");
  195.     }

  197. }
Created with JaCoCo 0.8.12.202403310830