added List of Points

Lsit of Points is a List<Point2d>
Added DAO
Added OutputPoints and InputPoints
Added PrintPoints Node
Added TurtleToPoints Node
Added GridOfPoints Node

Author: i-make-robots

pom.xml

@@ -569,7 +569,7 @@ It pairs really well with Marlin-polargraph, the code in the brain of the robot
 			Github/Jitpack/etc can find the copy published by Jitpack.
 			I have to do this dance every time.
 			-->
-			<groupId>com.github.marginallyclever</groupId>
+			<groupId>com.marginallyclever</groupId>
 			<artifactId>nodegraphcore</artifactId>
 			<version>1.1.0</version>
 		</dependency>
@@ -581,7 +581,7 @@ It pairs really well with Marlin-polargraph, the code in the brain of the robot
 			Github/Jitpack/etc can find the copy published by Jitpack.
 			I have to do this dance every time.
 			-->
-			<groupId>com.github.marginallyclever</groupId>
+			<groupId>com.marginallyclever</groupId>
 			<artifactId>donatello</artifactId>
 			<version>1.4.3</version>
 		</dependency>

src/main/java/com/marginallyclever/makelangelo/donatelloimpl/MakelangeloRegistry.java

@@ -1,5 +1,6 @@
 package com.marginallyclever.makelangelo.donatelloimpl;
 
+import com.marginallyclever.makelangelo.donatelloimpl.nodes.points.PointsDAO4JSON;
 import com.marginallyclever.makelangelo.donatelloimpl.nodes.turtle.TurtleDAO4JSON;
 import com.marginallyclever.makelangelo.turtle.Turtle;
 import com.marginallyclever.nodegraphcore.DAO4JSONFactory;
@@ -32,5 +33,6 @@ public void registerNodes() {
     public void registerDAO() {
         logger.info("Registering makelangelo-software DAOs");
         DAO4JSONFactory.registerDAO(new TurtleDAO4JSON());
+        DAO4JSONFactory.registerDAO(new PointsDAO4JSON());
     }
 }

src/main/java/com/marginallyclever/makelangelo/donatelloimpl/nodes/points/GridOfPoints.java

@@ -0,0 +1,45 @@
+package com.marginallyclever.makelangelo.donatelloimpl.nodes.points;
+
+import com.marginallyclever.donatello.ports.InputDouble;
+import com.marginallyclever.donatello.ports.InputInt;
+import com.marginallyclever.nodegraphcore.Node;
+
+import javax.vecmath.Point2d;
+import java.util.stream.IntStream;
+
+/**
+ * Create a grid of points controlled by the number (quantity) and spacing (distance between points).
+ */
+public class GridOfPoints extends Node {
+    private final InputInt numberAcross = new InputInt("x count",10);
+    private final InputDouble spaceAcross = new InputDouble("x spacing",10d);
+    private final InputInt numberDown = new InputInt("y count",10);
+    private final InputDouble spaceDown = new InputDouble("y spacing",10d);
+    private final OutputPoints output = new OutputPoints("output");
+
+    public GridOfPoints() {
+        super("GridOfPoints");
+        addVariable(numberAcross);
+        addVariable(spaceAcross);
+        addVariable(numberDown);
+        addVariable(spaceDown);
+        addVariable(output);
+    }
+
+    @Override
+    public void update() {
+        var nx = Math.max(1,numberAcross.getValue());
+        var ny = Math.max(1,numberDown.getValue());
+        var dx = spaceAcross.getValue();
+        var dy = spaceDown.getValue();
+
+        var list = new ListOfPoints();
+        IntStream.range(0,ny).forEach(y->{
+            IntStream.range(0,nx).forEach(x->{
+                list.add(new Point2d(x*dx,y*dy));
+            });
+        });
+
+        output.send(list);
+    }
+}

src/main/java/com/marginallyclever/makelangelo/donatelloimpl/nodes/points/InputPoints.java

@@ -0,0 +1,12 @@
+package com.marginallyclever.makelangelo.donatelloimpl.nodes.points;
+
+import com.marginallyclever.nodegraphcore.port.Input;
+
+/**
+ * {@link Input} for a {@link ListOfPoints}.
+ */
+public class InputPoints extends Input<ListOfPoints> {
+    public InputPoints(String _name) throws IllegalArgumentException {
+        super(_name, ListOfPoints.class, new ListOfPoints());
+    }
+}

src/main/java/com/marginallyclever/makelangelo/donatelloimpl/nodes/points/ListOfPoints.java

@@ -0,0 +1,9 @@
+package com.marginallyclever.makelangelo.donatelloimpl.nodes.points;
+
+import javax.vecmath.Point2d;
+import java.util.ArrayList;
+
+/**
+ * A list of 2D points with double precision.
+ */
+public class ListOfPoints extends ArrayList<Point2d> {}

src/main/java/com/marginallyclever/makelangelo/donatelloimpl/nodes/points/OutputPoints.java

@@ -0,0 +1,12 @@
+package com.marginallyclever.makelangelo.donatelloimpl.nodes.points;
+
+import com.marginallyclever.nodegraphcore.port.Output;
+
+/**
+ * {@link Output} for a {@link ListOfPoints}.
+ */
+public class OutputPoints extends Output<ListOfPoints> {
+    public OutputPoints(String _name) throws IllegalArgumentException {
+        super(_name, ListOfPoints.class, new ListOfPoints());
+    }
+}

src/main/java/com/marginallyclever/makelangelo/donatelloimpl/nodes/points/PointsDAO4JSON.java

@@ -0,0 +1,48 @@
+package com.marginallyclever.makelangelo.donatelloimpl.nodes.points;
+
+import com.marginallyclever.nodegraphcore.AbstractDAO4JSON;
+import org.json.JSONArray;
+import org.json.JSONException;
+import org.json.JSONObject;
+
+import javax.vecmath.Point2d;
+import java.util.stream.IntStream;
+
+/**
+ * DAO for ListOfPoints
+ */
+public class PointsDAO4JSON extends AbstractDAO4JSON<ListOfPoints> {
+    public PointsDAO4JSON() {
+        super(ListOfPoints.class);
+    }
+
+    @Override
+    public Object toJSON(Object object) throws JSONException {
+        JSONArray array = new JSONArray();
+        ListOfPoints points = (ListOfPoints)object;
+        // for a complete snapshot, capture all the instance details, too.
+        for(var p : points) {
+            JSONObject point = new JSONObject();
+            point.put("x", p.getX());
+            point.put("y", p.getY());
+            array.put(point);
+        }
+
+        return array;
+    }
+
+    @Override
+    public ListOfPoints fromJSON(Object object) throws JSONException {
+        JSONArray array = (JSONArray)object;
+        // for a complete snapshot, restore all the instance details, too.
+        var list = new ListOfPoints();
+        IntStream.range(0, array.length()).forEach(i ->{
+            JSONObject point = array.getJSONObject(i);
+            list.add(new Point2d(
+                    point.getDouble("x"),
+                    point.getDouble("y")
+            ));
+        });
+        return list;
+    }
+}

src/main/java/com/marginallyclever/makelangelo/donatelloimpl/nodes/points/PrintPoints.java

@@ -0,0 +1,58 @@
+package com.marginallyclever.makelangelo.donatelloimpl.nodes.points;
+
+import com.marginallyclever.donatello.graphview.GraphViewPanel;
+import com.marginallyclever.donatello.ports.InputColor;
+import com.marginallyclever.donatello.ports.InputInt;
+import com.marginallyclever.nodegraphcore.Node;
+import com.marginallyclever.nodegraphcore.PrintWithGraphics;
+
+import java.awt.*;
+import java.util.concurrent.locks.ReentrantLock;
+
+/**
+ * Draw a list of points.
+ */
+public class PrintPoints extends Node implements PrintWithGraphics {
+    private final InputPoints input = new InputPoints("points");
+    private final InputInt radius = new InputInt("radius",5);
+    private final InputColor color = new InputColor("color",Color.WHITE);
+    private final ReentrantLock lock = new ReentrantLock();
+    private ListOfPoints list;
+
+    public PrintPoints() {
+        super("PrintPoints");
+        addVariable(input);
+        addVariable(radius);
+        addVariable(color);
+    }
+
+    @Override
+    public void update() {
+        lock.lock();
+        try {
+            list = input.getValue();
+        } finally {
+            lock.unlock();
+        }
+    }
+
+    @Override
+    public void print(Graphics g) {
+        if(list==null || list.isEmpty()) return;
+        lock.lock();
+        try {
+
+            Graphics2D g2 = (Graphics2D)g.create();
+            GraphViewPanel.setHints(g2);
+            g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
+            g2.setStroke(new BasicStroke(radius.getValue()));
+            g2.setColor(color.getValue());
+
+            list.stream().parallel().forEach(p -> {
+                g2.drawLine((int)p.x, (int)p.y, (int)p.x, (int)p.y);
+            });
+        } finally {
+            lock.unlock();
+        }
+    }
+}

src/main/java/com/marginallyclever/makelangelo/donatelloimpl/nodes/points/TurtleToPoints.java

@@ -0,0 +1,35 @@
+package com.marginallyclever.makelangelo.donatelloimpl.nodes.points;
+
+import com.marginallyclever.makelangelo.donatelloimpl.ports.InputTurtle;
+import com.marginallyclever.makelangelo.turtle.MovementType;
+import com.marginallyclever.nodegraphcore.Node;
+
+import javax.vecmath.Point2d;
+
+/**
+ * Converts a {@link com.marginallyclever.makelangelo.turtle.Turtle} to a {@link ListOfPoints}.
+ */
+public class TurtleToPoints extends Node {
+    private final InputTurtle turtle = new InputTurtle("Turtle");
+    private final OutputPoints points = new OutputPoints("points");
+
+    public TurtleToPoints() {
+        super("TurtleToPoints");
+        addVariable(turtle);
+        addVariable(points);
+    }
+
+    @Override
+    public void update() {
+        var in = turtle.getValue();
+        var out = new ListOfPoints();
+
+        for( var move : in.history ) {
+            if(move.type != MovementType.TOOL_CHANGE) {
+                out.add(new Point2d(move.x,move.y));
+            }
+        }
+
+        points.send(out);
+    }
+}

src/main/java/com/marginallyclever/makelangelo/donatelloimpl/nodes/turtle/TurtleDAO4JSON.java

@@ -15,13 +15,17 @@ public Object toJSON(Object object) throws JSONException {
         JSONObject json = new JSONObject();
         Turtle turtle = (Turtle)object;
         // for a complete snapshot, capture all the instance details, too.
+        // TODO save turtle to JSON.
+
         return json;
     }
 
     @Override
     public Turtle fromJSON(Object object) throws JSONException {
         JSONObject json = (JSONObject)object;
         // for a complete snapshot, restore all the instance details, too.
-        return new Turtle();
+        Turtle turtle = new Turtle();
+        // TODO load turtle from JSON
+        return turtle;
     }
 }