added robot rendering

src/main/java/jarhead/ButtonPanel.java

@@ -7,8 +7,7 @@
 import java.awt.event.ActionEvent;
 import java.awt.event.ActionListener;
 import java.io.*;
-import java.util.HashMap;
-import java.util.LinkedList;
+import java.util.*;
 import java.util.List;
 
 public class ButtonPanel extends JPanel {
@@ -175,20 +174,20 @@ public void export(){
                 case splineToConstantHeading:
                     sb.append(String.format(".splineToConstantHeading(new Vector2d(%.2f, %.2f), Math.toRadians(%.2f))%n", x, -y, (node.splineHeading +90)));
                     break;
-                case lineTo:
-                    sb.append(String.format(".lineTo(new Vector2d(%.2f, %.2f))%n", x, -y));
-                    break;
-                case lineToSplineHeading:
-                    sb.append(String.format(".lineToSplineHeading(new Pose2d(%.2f, %.2f, Math.toRadians(%.2f)))%n", x, -y, (node.robotHeading +90)));
-                    break;
-                case lineToLinearHeading:
-                    sb.append(String.format(".lineToLinearHeading(new Pose2d(%.2f, %.2f, Math.toRadians(%.2f)))%n", x, -y, (node.robotHeading +90)));
-                    break;
-                case lineToConstantHeading:
-                    sb.append(String.format(".lineToConstantHeading(new Vector2d(%.2f, %.2f))%n", x, -y, (node.splineHeading +90)));
-                    break;
-                case addTemporalMarker:
-                    break;
+//                case lineTo:
+//                    sb.append(String.format(".lineTo(new Vector2d(%.2f, %.2f))%n", x, -y));
+//                    break;
+//                case lineToSplineHeading:
+//                    sb.append(String.format(".lineToSplineHeading(new Pose2d(%.2f, %.2f, Math.toRadians(%.2f)))%n", x, -y, (node.robotHeading +90)));
+//                    break;
+//                case lineToLinearHeading:
+//                    sb.append(String.format(".lineToLinearHeading(new Pose2d(%.2f, %.2f, Math.toRadians(%.2f)))%n", x, -y, (node.robotHeading +90)));
+//                    break;
+//                case lineToConstantHeading:
+//                    sb.append(String.format(".lineToConstantHeading(new Vector2d(%.2f, %.2f))%n", x, -y, (node.splineHeading +90)));
+//                    break;
+//                case addTemporalMarker:
+//                    break;
                 default:
                     sb.append("couldn't find type");
                     break;

src/main/java/jarhead/Main.java

@@ -14,8 +14,8 @@ public class Main extends JFrame {
 
     public static boolean debug = false;
 
-    private ProgramProperties properties;
-    public double scale = 1;// = Toolkit.getDefaultToolkit().getScreenSize().height > 1080 ? 8 : 6; //set scale to 6 for 1080p and 8 for 1440p
+    public static ProgramProperties properties;
+    public static double scale = 1;// = Toolkit.getDefaultToolkit().getScreenSize().height > 1080 ? 8 : 6; //set scale to 6 for 1080p and 8 for 1440p
     private static NodeManager currentManager = new NodeManager(new ArrayList<>(), 0);
     private static LinkedList<NodeManager> managers = new LinkedList<>();
 
@@ -143,7 +143,7 @@ public void componentResized(ComponentEvent e) {
     public static void undo() {
         undo(false);
     }
-    public void flip() {
+    public static void flip() {
         for (int i = 0; i < getCurrentManager().size(); i++) {
             Node node = getCurrentManager().get(i);
             node.y = 144*scale-node.y;

src/main/java/jarhead/Marker.java

@@ -5,7 +5,7 @@ public class Marker extends Node {
     public String code;
 
     public Marker(double displacement){
-        this(displacement, "", Type.addTemporalMarker);
+        this(displacement, "", Type.splineTo);
         super.isMidpoint = true;
     }
 

src/main/java/jarhead/Node.java

@@ -93,4 +93,4 @@ public String toString(){
 
         return "{x: " + x + " y: " + y + " robotHeading: " + robotHeading + " spline heading: " + splineHeading + " type: " + type + "}";
     }
-}
+}

src/main/java/jarhead/Render.kt

@@ -6,13 +6,24 @@ import com.acmerobotics.roadrunner.Vector2d
 import jarhead.roadrunner.DriveShim
 import jarhead.roadrunner.Timeline
 import jarhead.roadrunner.TrajectoryAction
-import jarhead.roadrunner.TurnAction
 import java.awt.Color
 import java.awt.Graphics2D
+import java.awt.Polygon
+import java.awt.geom.AffineTransform
 import java.awt.geom.Path2D
+import java.awt.image.BufferedImage
+import kotlin.math.absoluteValue
 import kotlin.math.roundToInt
 
 class Render {
+
+    var tx = AffineTransform()
+    var outLine = AffineTransform()
+    var xPoly = intArrayOf(0, -2, 0, 2)
+    var yPoly = intArrayOf(0, -4, -3, -4)
+    var poly = Polygon(xPoly, yPoly, xPoly.size)
+    private val preRenderedSplines: BufferedImage? = null
+
     fun generateTrajectory(driveShim: DriveShim, exclude: Node, scale: Double, manager: NodeManager): Action? {
         if (manager.size() < 2) return null
         val node: Node = exclude.shrink(scale)
@@ -23,7 +34,6 @@ class Render {
             val node = manager[i].shrink(scale)
 
             if(exclude.equals(manager.get(i))) continue //stops empty path segment error
-            println(node)
             try {
                 when (node.type) {
                     Node.Type.splineTo -> builder = builder.splineTo(
@@ -62,15 +72,54 @@ class Render {
         return if (manager.size() > 1) builder.build() else null
     }
 
+    fun renderRobotPath(g: Graphics2D, timeline: Timeline, color: Color, transparency: Float, width: Int, height: Int) {
+        var image: BufferedImage? = null
+        if(width != height) println("width and height are not equal")
+        if(height > 0)
+            image = BufferedImage(width, height, BufferedImage.TYPE_4BYTE_ABGR)
+        else
+            image = BufferedImage(1, 1, BufferedImage.TYPE_4BYTE_ABGR)
+        val g2 = image.createGraphics()
+        g2.color = color
+        var rX = Main.properties.robotLength * Main.scale/2
+        var rY = Main.properties.robotWidth * Main.scale/2
+        val robot = Polygon(
+            intArrayOf(-rX.toInt(), -rX.toInt(), rX.toInt(), rX.toInt()),
+            intArrayOf(-rY.toInt(), rY.toInt(), rY.toInt(), -rY.toInt()),
+            4
+        )
+        for ((t0, action) in timeline) {
+            when (action) {
+                is TrajectoryAction -> {
+                    val displacementSamples = (action.t.path.length() / 0.1).roundToInt()
+                    val displacements = (0..displacementSamples).map {
+                        it / displacementSamples.toDouble() * action.t.path.length()
+                    }
+                    val poses = displacements.map { action.t.path[it, 1].value() }
+                    for (pose in poses) {
+                        val coord = pose.position
+                        tx.setToIdentity()
+                        val heading = pose.heading.log()
+                        println(-heading)
+                        tx.translate(coord.x*Main.scale, coord.y*Main.scale)
+                        tx.rotate(heading)
+//                        tx.scale(Main.scale, Main.scale)
+                        g2.transform = tx
+                        g2.fill(robot)
+                    }
+                }
+            }
+        }
+        g.drawImage(image, 0, 0, null)
+    }
+
     fun renderSplines(g: Graphics2D, timeline: Timeline, color: Color, ovalScale: Int, scale: Double) {
         val trajectoryDrawnPath = Path2D.Double()
         var first = true
         g.color = color
         for ((t0, action) in timeline) {
-            println(action.javaClass.simpleName)
             when (action) {
                 is TrajectoryAction -> {
-                    println("trajectoryaction")
                     val displacementSamples = (action.t.path.length() / 1).roundToInt()
 
                     val displacements = (0..displacementSamples).map {
@@ -84,10 +133,8 @@ class Render {
                         if (first) {
                             trajectoryDrawnPath.moveTo(coord.x*scale, coord.y*scale)
                             first = false
-                            println(coord.x*scale)
                         } else {
                             trajectoryDrawnPath.lineTo(coord.x*scale, coord.y*scale)
-                            println(coord.x*scale)
                         }
                     }
                 }
@@ -104,4 +151,41 @@ class Render {
         }
         g.draw(trajectoryDrawnPath)
     }
+
+//    fun renderArrows(g: Graphics2D, manager: NodeManager, color1: Color, color2: Color, color3: Color, ovalScale: Int, scale: Double) {
+//        g.color = color1
+//        for (i in 0 until manager.size()) {
+//            val node = manager[i]
+//            g.drawOval(
+//                (node.x * scale).toInt() - ovalScale / 2,
+//                (node.y * scale).toInt() - ovalScale / 2,
+//                ovalScale,
+//                ovalScale
+//            )
+//        }
+//        val bufferedImage =
+//            BufferedImage(preRenderedSplines.getWidth(), preRenderedSplines.getHeight(), BufferedImage.TYPE_4BYTE_ABGR)
+//        val g2 = bufferedImage.createGraphics()
+//        val nodes: List<Node> = nodeM.getNodes()
+//        for (node in nodes) {
+//            tx.setToIdentity()
+//            tx.translate(node.x, node.y)
+//            if (!node.reversed) tx.rotate(Math.toRadians(-node.robotHeading + 180)) else tx.rotate(Math.toRadians(-node.robotHeading))
+//            tx.scale(Main.scale, Main.scale)
+//            g2.transform = tx
+//            g2.color = color1
+//            g2.fillOval(-ovalScale, -ovalScale, 2 * ovalScale, 2 * ovalScale)
+//            when (node.type) {
+//                Node.Type.splineTo -> g2.color = color2
+//                Node.Type.splineToSplineHeading -> g2.color = color2.brighter()
+//                Node.Type.splineToLinearHeading -> g2.color = Color.magenta
+//                Node.Type.splineToConstantHeading -> g2.color = color3.brighter()
+//                else -> g2.color = color3.brighter()
+//            }
+//            g2.fill(poly)
+//        }
+//        g2d.drawImage(bufferedImage, 0, 0, null)
+//    }
+
+
 }