diff --git a/pom.xml b/pom.xml
index 2920712a6..06e97842c 100644
--- a/pom.xml
+++ b/pom.xml
@@ -555,12 +555,12 @@ It pairs really well with Marlin-polargraph, the code in the brain of the robot
 		<dependency>
 			<groupId>org.marginallyclever</groupId>
 			<artifactId>donatello</artifactId>
-			<version>1.1</version>
+			<version>1.2</version>
 		</dependency>
 		<dependency>
 			<groupId>com.marginallyclever</groupId>
 			<artifactId>nodegraphcore</artifactId>
-			<version>1.0.21</version>
+			<version>1.0.22</version>
 		</dependency>
 
 		<!-- dockable windows -->
diff --git a/src/main/java/com/marginallyclever/makelangelo/donatelloimpl/DonatelloRegistry.java b/src/main/java/com/marginallyclever/makelangelo/donatelloimpl/DonatelloRegistry.java
index cd640086e..441317e95 100644
--- a/src/main/java/com/marginallyclever/makelangelo/donatelloimpl/DonatelloRegistry.java
+++ b/src/main/java/com/marginallyclever/makelangelo/donatelloimpl/DonatelloRegistry.java
@@ -42,6 +42,7 @@ public void registerNodes() {
         NodeFactory.registerNode(AddTurtles.class);
         NodeFactory.registerNode(ColorTurtle.class);
         NodeFactory.registerNode(LoadTurtle.class);
+        NodeFactory.registerNode(LineWeightByImage.class);
         NodeFactory.registerNode(PathImageMask.class);
         NodeFactory.registerNode(PatternOnPath.class);
         NodeFactory.registerNode(PointOnPath.class);
diff --git a/src/main/java/com/marginallyclever/makelangelo/donatelloimpl/nodes/AddTurtles.java b/src/main/java/com/marginallyclever/makelangelo/donatelloimpl/nodes/AddTurtles.java
index 20b9ffde2..b1e969c82 100644
--- a/src/main/java/com/marginallyclever/makelangelo/donatelloimpl/nodes/AddTurtles.java
+++ b/src/main/java/com/marginallyclever/makelangelo/donatelloimpl/nodes/AddTurtles.java
@@ -1,8 +1,8 @@
 package com.marginallyclever.makelangelo.donatelloimpl.nodes;
 
 import com.marginallyclever.makelangelo.turtle.Turtle;
-import com.marginallyclever.nodegraphcore.dock.Input;
-import com.marginallyclever.nodegraphcore.dock.Output;
+import com.marginallyclever.nodegraphcore.port.Input;
+import com.marginallyclever.nodegraphcore.port.Output;
 import com.marginallyclever.nodegraphcore.Node;
 
 public class AddTurtles extends Node {
diff --git a/src/main/java/com/marginallyclever/makelangelo/donatelloimpl/nodes/ColorTurtle.java b/src/main/java/com/marginallyclever/makelangelo/donatelloimpl/nodes/ColorTurtle.java
index 846adf0e5..a01d909db 100644
--- a/src/main/java/com/marginallyclever/makelangelo/donatelloimpl/nodes/ColorTurtle.java
+++ b/src/main/java/com/marginallyclever/makelangelo/donatelloimpl/nodes/ColorTurtle.java
@@ -3,8 +3,8 @@
 import com.marginallyclever.makelangelo.turtle.MovementType;
 import com.marginallyclever.makelangelo.turtle.Turtle;
 import com.marginallyclever.makelangelo.turtle.TurtleMove;
-import com.marginallyclever.nodegraphcore.dock.Input;
-import com.marginallyclever.nodegraphcore.dock.Output;
+import com.marginallyclever.nodegraphcore.port.Input;
+import com.marginallyclever.nodegraphcore.port.Output;
 import com.marginallyclever.nodegraphcore.Node;
 
 import java.awt.*;
diff --git a/src/main/java/com/marginallyclever/makelangelo/donatelloimpl/nodes/LineWeightByImage.java b/src/main/java/com/marginallyclever/makelangelo/donatelloimpl/nodes/LineWeightByImage.java
new file mode 100644
index 000000000..1158afa64
--- /dev/null
+++ b/src/main/java/com/marginallyclever/makelangelo/donatelloimpl/nodes/LineWeightByImage.java
@@ -0,0 +1,367 @@
+package com.marginallyclever.makelangelo.donatelloimpl.nodes;
+
+import com.marginallyclever.convenience.LineCollection;
+import com.marginallyclever.convenience.LineSegment2D;
+import com.marginallyclever.convenience.Point2D;
+import com.marginallyclever.makelangelo.makeart.TransformedImage;
+import com.marginallyclever.makelangelo.makeart.turtlegenerator.lineweight.LineWeight;
+import com.marginallyclever.makelangelo.makeart.turtlegenerator.lineweight.LineWeightSegment;
+import com.marginallyclever.makelangelo.turtle.Turtle;
+import com.marginallyclever.nodegraphcore.Node;
+import com.marginallyclever.nodegraphcore.port.Input;
+import com.marginallyclever.nodegraphcore.port.Output;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import javax.vecmath.Vector2d;
+import java.awt.image.BufferedImage;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.LinkedList;
+import java.util.List;
+
+/**
+ * Use an image to mask a path.  Lay the path over the image and modulate the width of the line by the intensity of the
+ * image at the same location.  The fine grain resolution (and the amount of testing) is controlled by the stepSize.
+ * @author Dan Royer
+ * @since 2025-01-07
+ */
+public class LineWeightByImage extends Node {
+    private static final Logger logger = LoggerFactory.getLogger(LineWeightByImage.class);
+
+    private static final double EPSILON = 0.0001;
+
+    private final Input<BufferedImage> image = new Input<>("image", BufferedImage.class,new BufferedImage(1,1,BufferedImage.TYPE_INT_RGB));
+    private final Input<Turtle> turtle = new Input<>("turtle", Turtle.class,new Turtle());
+    private final Input<Number> stepSize = new Input<>("stepSize", Number.class, 5);
+    private final Input<Number> thickness = new Input<>("thickness", Number.class, 5);
+    private final Output<Turtle> result = new Output<>("result", Turtle.class,new Turtle());
+
+    private static final LinkedList<LineWeightSegment> unsorted = new LinkedList<>();
+
+    // segments sorted for drawing efficiency
+    private static final List<LineWeight> sortedLines = new ArrayList<>();
+    private TransformedImage sourceImage = null;
+
+    public LineWeightByImage() {
+        super("LineWeightByImage");
+        addVariable(image);
+        addVariable(turtle);
+        addVariable(stepSize);
+        addVariable(result);
+        addVariable(thickness);
+    }
+
+    @Override
+    public void update() {
+        Turtle myTurtle = turtle.getValue();
+        if(myTurtle==null || myTurtle.history.isEmpty()) return;
+
+        sourceImage = new TransformedImage(image.getValue());
+        sourceImage.setScale(1,1);
+        sourceImage.setTranslation(0,0);
+        Turtle turtle = new Turtle();
+        List<Turtle> colors = myTurtle.splitByToolChange();
+        for( Turtle t2 : colors ) {
+            turtle.add(calculate(t2));
+        }
+
+        result.send(turtle);
+    }
+
+    private Turtle calculate(Turtle from) {
+        Turtle turtle = new Turtle();
+        buildSegmentList(from);
+        sortSegmentsIntoLines();
+        generateThickLines(turtle);
+        //generateThinLines(turtle);
+
+        // clean up
+        unsorted.clear();
+        sortedLines.clear();
+        return turtle;
+    }
+
+    /**
+     * Generate thin lines for debugging
+     * @param turtle the turtle to draw with
+     */
+    private void generateThinLines(Turtle turtle) {
+        logger.debug("generateThinLines {}",sortedLines.size());
+        for(LineWeight line : sortedLines) {
+            boolean first=true;
+            for(LineWeightSegment w : line.segments) {
+                if (first) {
+                    turtle.jumpTo(w.start.x, w.start.y);
+                    first = false;
+                }
+                turtle.moveTo(w.end.x, w.end.y);
+            }
+        }
+    }
+
+    private void generateThickLines(Turtle turtle) {
+        logger.debug("generateThickLines");
+        for(LineWeight i : sortedLines) {
+            if(i.segments.isEmpty()) continue;
+            generateOneThickLine(turtle,i);
+        }
+    }
+
+    private void generateOneThickLine(Turtle turtle, LineWeight line) {
+        // find the thickest part of the line, which tells us how many cycles we'll have to make.
+        double numPasses=0;
+        for(LineWeightSegment s : line.segments) {
+            numPasses = Math.max(numPasses,s.weight);
+        }
+        numPasses = Math.max(1,Math.ceil(numPasses));
+
+        LineWeightSegment start = line.segments.get(0);
+
+        boolean first=true;
+        // collect all the points, write them at the end.
+        for(int pass=0; pass<=numPasses; ++pass) {
+            double ratio = pass/numPasses;
+            List<Point2D> offsetLine = generateOneThickLinePass(line,start,ratio);
+            if((pass%2)==1) Collections.reverse(offsetLine);
+
+            // draw pass
+            for( Point2D p : offsetLine ) {
+                if(first) {
+                    turtle.jumpTo(p.x,p.y);
+                    first=false;
+                }
+                turtle.moveTo(p.x,p.y);
+            }
+        }
+    }
+
+    private List<Point2D> generateOneThickLinePass(LineWeight line,LineWeightSegment start,double distance) {
+        List<Point2D> offsetSequence = new ArrayList<>();
+
+        // add first point at start of line
+        double [] s0 = getOffsetLine(start, adjustedOffset(start.weight,distance));
+
+        Vector2d unit = line.segments.get(0).getUnit();
+        unit.scale(distance);
+        offsetSequence.add(new Point2D(s0[0]-unit.x,s0[1]-unit.y));
+
+        // add the middle points of the line
+        for(int i=1;i<line.segments.size();++i) {
+            LineWeightSegment seg = line.segments.get(i);
+            double [] s1 = getOffsetLine(seg, adjustedOffset(seg.weight,distance));
+            if(Math.abs(dotProduct(s0,s1))<Math.cos(Math.toRadians(75))) {
+                // this is a corner.  add a point at the intersection of the two lines.
+                double [] inter = findIntersection(
+                        s0[0],s0[1],s0[2],s0[3],
+                        s1[0],s1[1],s1[2],s1[3]
+                );
+                offsetSequence.add(new Point2D(inter[0],inter[1]));
+                //offsetSequence.add(new Point2D(s1[0],s1[1]));
+            } else {
+                offsetSequence.add(new Point2D(s1[0], s1[1]));
+            }
+            s0=s1;
+        }
+        // add the last point of the line
+        unit = line.segments.get(line.segments.size()-1).getUnit();
+        unit.scale(distance);
+        offsetSequence.add(new Point2D(s0[2]+unit.x,s0[3]+unit.y));
+        return offsetSequence;
+    }
+
+    /**
+     * @param s0 the first line segment
+     * @param s1 the second line
+     * @return the dot product of the two lines
+     */
+    private double dotProduct(double[] s0, double[] s1) {
+        double dx0 = s0[2]-s0[0];
+        double dy0 = s0[3]-s0[1];
+        double dx1 = s1[2]-s1[0];
+        double dy1 = s1[3]-s1[1];
+        return dx0*dx1 + dy0*dy1;
+    }
+
+    private double [] findIntersection(double x1,double y1,double x2,double y2,double x3,double y3,double x4,double y4) {
+        double d = ((x1-x2)*(y3-y4) - (y1-y2)*(x3-x4));
+        if(Math.abs(d)<0.01) {
+            // lines are colinear (infinite solutions) or parallel (no solutions).
+            double ix = (x4+x1)/2;
+            double iy = (y4+y1)/2;
+            return new double [] { ix, iy };
+        }
+
+        double t = ((x1-x3)*(y3-y4) - (y1-y3)*(x3-x4)) / d;
+        //double u = ((x1-x2)*(y1-y3) - (y1-y2)*(x1-x3)) / d;
+
+        double ix = x1+t*(x2-x1);
+        double iy = y1+t*(y2-y1);
+        return new double[] { ix, iy };
+    }
+
+    private double adjustedOffset(double weight,double ratio) {
+        return weight*ratio - weight/2.0;
+    }
+
+    double[] getOffsetLine(LineWeightSegment line,double distance) {
+        // get normal of each line, then scale by distance.
+        double nx = line.end.y - line.start.y;
+        double ny = line.start.x - line.end.x;
+        double nd = Math.sqrt(nx*nx + ny*ny);
+        if(nd==0) nd=1;
+        nx *= distance / nd;
+        ny *= distance / nd;
+
+        // offset from the original line
+        return new double[] {
+                line.start.x+nx, line.start.y+ny,
+                line.end.x  +nx, line.end.y  +ny
+        };
+    }
+
+    /**
+     * Search through all unsorted segments for adjacent segments.  Start from a random segment and then
+     * Find any segment that touches the head or the tail of this segment.  Track the head and tail as we go.
+     */
+    private void sortSegmentsIntoLines() {
+        logger.debug("sortSegmentsIntoLines");
+
+        while(!unsorted.isEmpty()) {
+            LineWeight activeLine = new LineWeight();
+            activeLine.segments.add(unsorted.removeFirst());
+            sortedLines.add(activeLine);
+
+            growActiveLine(activeLine);
+        }
+
+        logger.debug("sortedLines="+sortedLines.size());
+    }
+
+    private void growActiveLine(LineWeight activeLine) {
+        LineWeightSegment head = activeLine.segments.get(0);
+        LineWeightSegment tail = head;
+
+        boolean found;
+        do {
+            found=false;
+            for (LineWeightSegment s : unsorted) {
+                if (closeEnoughToHead(head, s)) {  // try to match with head of line
+                    activeLine.segments.addFirst(s);
+                    head = s;
+                    unsorted.remove(s);
+                    found = true;
+                    break;
+                } else if (closeEnoughToTail(tail, s)) {  // try to match with tail of line
+                    activeLine.segments.addLast(s);
+                    tail = s;
+                    unsorted.remove(s);
+                    found = true;
+                    break;
+                }
+            }
+        } while(found);
+    }
+
+    /**
+     * @param head the first line
+     * @param next the second line
+     * @return true if {@link LineWeightSegment} head and next are in sequence.
+     */
+    private boolean closeEnoughToHead(LineWeightSegment head,LineWeightSegment next) {
+        if(next==null) {
+            throw new IllegalArgumentException("next is null");
+        }
+        // fast reject if truchet index too far apart
+        if(Math.abs(head.ix-next.ix)>6 || Math.abs(head.iy-next.iy)>6) return false;
+        if(closeEnough(head.start,next.end)) return true;
+        if(closeEnough(head.start,next.start)) {
+            // next is backwards
+            next.flip();
+            return true;
+        }
+        return false;
+    }
+
+    /**
+     * @param tail the first line
+     * @param next the second line
+     * @return true if {@link LineWeightSegment} tail and next are in sequence.
+     */
+    private boolean closeEnoughToTail(LineWeightSegment tail, LineWeightSegment next) {
+        if(next==null) {
+            throw new IllegalArgumentException("next is null");
+        }
+        // fast reject if truchet index too far apart
+        if(Math.abs(tail.ix-next.ix)>2 || Math.abs(tail.iy-next.iy)>2) return false;
+        if(closeEnough(tail.end,next.start)) return true;
+        if(closeEnough(tail.end,next.end)) {
+            next.flip();
+            return true;
+        }
+        return false;
+    }
+
+    boolean closeEnough(Point2D p0,Point2D p1) {
+        return p0.distanceSquared(p1)<EPSILON;
+    }
+
+    private void buildSegmentList(Turtle from) {
+        logger.debug("buildSegmentList before={}",from.countLoops());
+
+        LineCollection originalLines = from.getAsLineSegments();
+        logger.debug("originalLines={}",originalLines.size());
+
+        for(LineSegment2D before : originalLines) {
+            maybeSplitLine(before);
+        }
+
+        logger.debug("unsorted={}",unsorted.size());
+    }
+
+    /**
+     * Add a segment to the list of unsorted lines.  Splits long lines into smaller pieces.
+     * @param segment the segment to split
+     */
+    private void maybeSplitLine(LineSegment2D segment) {
+        double beforeLen = Math.sqrt(segment.lengthSquared());
+        int pieces = (int)Math.max(1,Math.ceil(beforeLen / stepSize.getValue().doubleValue()));
+        if(pieces==1) {
+            addOneUnsortedSegment(segment.start,segment.end);
+            return;
+        }
+
+        Vector2d diff = new Vector2d(
+                segment.end.x - segment.start.x,
+                segment.end.y - segment.start.y
+        );
+
+        Point2D a = segment.start;
+        for(int i=0;i<pieces-1;++i) {
+            double t1 = (double)(i+1) / (double)pieces;
+            Point2D b = new Point2D(
+                    segment.start.x + diff.x * t1,
+                    segment.start.y + diff.y * t1);
+            addOneUnsortedSegment(a,b);
+            a=b;
+        }
+        addOneUnsortedSegment(a,segment.end);
+    }
+
+    private void addOneUnsortedSegment(Point2D start, Point2D end) {
+        unsorted.add(createLSW(start,end));
+    }
+
+    private LineWeightSegment createLSW(Point2D start, Point2D end) {
+        // sample image intensity here from 0...1
+        double mx = (start.x+end.x)/2.0;
+        double my = (start.y+end.y)/2.0;
+        var s = stepSize.getValue().doubleValue();
+        double intensity = 1.0-(sourceImage.sample(mx,my,s/2)/255.0);
+        LineWeightSegment a = new LineWeightSegment(start,end,intensity*thickness.getValue().doubleValue());
+        // make a fast search index
+        a.ix = (int)Math.floor(mx / s);
+        a.iy = (int)Math.floor(my / s);
+        return a;
+    }
+}
diff --git a/src/main/java/com/marginallyclever/makelangelo/donatelloimpl/nodes/LoadTurtle.java b/src/main/java/com/marginallyclever/makelangelo/donatelloimpl/nodes/LoadTurtle.java
index 43df45f0d..a4d817de3 100644
--- a/src/main/java/com/marginallyclever/makelangelo/donatelloimpl/nodes/LoadTurtle.java
+++ b/src/main/java/com/marginallyclever/makelangelo/donatelloimpl/nodes/LoadTurtle.java
@@ -1,16 +1,17 @@
 package com.marginallyclever.makelangelo.donatelloimpl.nodes;
 
+import com.marginallyclever.donatello.Filename;
 import com.marginallyclever.makelangelo.makeart.io.TurtleFactory;
 import com.marginallyclever.makelangelo.turtle.Turtle;
-import com.marginallyclever.nodegraphcore.dock.Input;
-import com.marginallyclever.nodegraphcore.dock.Output;
+import com.marginallyclever.nodegraphcore.port.Input;
+import com.marginallyclever.nodegraphcore.port.Output;
 import com.marginallyclever.nodegraphcore.Node;
 
 
 import java.awt.geom.Rectangle2D;
 
 public class LoadTurtle extends Node {
-    private final Input<String> filename = new Input<>("filename",String.class,null);
+    private final Input<Filename> filename = new Input<>("filename",Filename.class,new Filename(""));
     private final Output<Turtle> contents = new Output<>("contents", Turtle.class, new Turtle());
     private final Output<Number> w = new Output<>("width", Number.class, 0);
     private final Output<Number> h = new Output<>("height", Number.class, 0);
@@ -27,9 +28,8 @@ public LoadTurtle() {
 
     @Override
     public void update() {
-
         try {
-            Turtle t = TurtleFactory.load(filename.getValue());
+            Turtle t = TurtleFactory.load(filename.getValue().get());
             contents.send(t);
             Rectangle2D r = t.getBounds();
             w.send(r.getWidth());
diff --git a/src/main/java/com/marginallyclever/makelangelo/donatelloimpl/nodes/PathImageMask.java b/src/main/java/com/marginallyclever/makelangelo/donatelloimpl/nodes/PathImageMask.java
index 68f7feddd..07cc192d9 100644
--- a/src/main/java/com/marginallyclever/makelangelo/donatelloimpl/nodes/PathImageMask.java
+++ b/src/main/java/com/marginallyclever/makelangelo/donatelloimpl/nodes/PathImageMask.java
@@ -2,8 +2,8 @@
 
 import com.marginallyclever.convenience.*;
 import com.marginallyclever.makelangelo.turtle.Turtle;
-import com.marginallyclever.nodegraphcore.dock.Input;
-import com.marginallyclever.nodegraphcore.dock.Output;
+import com.marginallyclever.nodegraphcore.port.Input;
+import com.marginallyclever.nodegraphcore.port.Output;
 import com.marginallyclever.nodegraphcore.Node;
 
 
diff --git a/src/main/java/com/marginallyclever/makelangelo/donatelloimpl/nodes/PatternOnPath.java b/src/main/java/com/marginallyclever/makelangelo/donatelloimpl/nodes/PatternOnPath.java
index 7c7496d3a..d35d8a5a7 100644
--- a/src/main/java/com/marginallyclever/makelangelo/donatelloimpl/nodes/PatternOnPath.java
+++ b/src/main/java/com/marginallyclever/makelangelo/donatelloimpl/nodes/PatternOnPath.java
@@ -2,8 +2,8 @@
 
 import com.marginallyclever.convenience.Point2D;
 import com.marginallyclever.makelangelo.turtle.Turtle;
-import com.marginallyclever.nodegraphcore.dock.Input;
-import com.marginallyclever.nodegraphcore.dock.Output;
+import com.marginallyclever.nodegraphcore.port.Input;
+import com.marginallyclever.nodegraphcore.port.Output;
 import com.marginallyclever.nodegraphcore.Node;
 
 
diff --git a/src/main/java/com/marginallyclever/makelangelo/donatelloimpl/nodes/PointOnPath.java b/src/main/java/com/marginallyclever/makelangelo/donatelloimpl/nodes/PointOnPath.java
index 221cb3051..595c6a992 100644
--- a/src/main/java/com/marginallyclever/makelangelo/donatelloimpl/nodes/PointOnPath.java
+++ b/src/main/java/com/marginallyclever/makelangelo/donatelloimpl/nodes/PointOnPath.java
@@ -2,8 +2,8 @@
 
 import com.marginallyclever.convenience.Point2D;
 import com.marginallyclever.makelangelo.turtle.Turtle;
-import com.marginallyclever.nodegraphcore.dock.Input;
-import com.marginallyclever.nodegraphcore.dock.Output;
+import com.marginallyclever.nodegraphcore.port.Input;
+import com.marginallyclever.nodegraphcore.port.Output;
 import com.marginallyclever.nodegraphcore.Node;
 
 
diff --git a/src/main/java/com/marginallyclever/makelangelo/donatelloimpl/nodes/PrintTurtle.java b/src/main/java/com/marginallyclever/makelangelo/donatelloimpl/nodes/PrintTurtle.java
index 72e88e0f9..2ed5b5567 100644
--- a/src/main/java/com/marginallyclever/makelangelo/donatelloimpl/nodes/PrintTurtle.java
+++ b/src/main/java/com/marginallyclever/makelangelo/donatelloimpl/nodes/PrintTurtle.java
@@ -1,15 +1,17 @@
 package com.marginallyclever.makelangelo.donatelloimpl.nodes;
 
+import com.marginallyclever.donatello.graphview.GraphViewPanel;
 import com.marginallyclever.makelangelo.turtle.Turtle;
 import com.marginallyclever.makelangelo.turtle.TurtleMove;
-import com.marginallyclever.nodegraphcore.dock.Input;
-import com.marginallyclever.nodegraphcore.dock.Output;
 import com.marginallyclever.nodegraphcore.Node;
 import com.marginallyclever.nodegraphcore.PrintWithGraphics;
+import com.marginallyclever.nodegraphcore.port.Input;
+import com.marginallyclever.nodegraphcore.port.Output;
 
 import java.awt.*;
 
 public class PrintTurtle extends Node implements PrintWithGraphics {
+    //private static final Logger logger = LoggerFactory.getLogger(PrintTurtle.class);
     private final Input<Turtle> turtle = new Input<>("turtle", Turtle.class,new Turtle());
     private final Input<Number> px = new Input<>("X",Number.class,0);
     private final Input<Number> py = new Input<>("Y",Number.class,0);
@@ -31,9 +33,12 @@ public void print(Graphics g) {
         Turtle myTurtle = turtle.getValue();
         if(myTurtle==null || myTurtle.history.isEmpty()) return;
 
+        Graphics2D g2 = (Graphics2D)g.create();
+        GraphViewPanel.setHints(g2);
+
         int dx=px.getValue().intValue();
         int dy=py.getValue().intValue();
-        g.translate(dx,dy);
+        g2.translate(dx,dy);
 
         // where we're at in the drawing (to check if we're between first & last)
         boolean showPenUp = showTravel.getValue();
@@ -56,8 +61,8 @@ public void print(Graphics g) {
                     case TRAVEL -> {
                         if (inShow && previousMove != null) {
                             if (showPenUp) {
-                                g.setColor(upColor);
-                                g.drawLine((int) previousMove.x, (int)previousMove.y, (int) m.x, (int) m.y);
+                                g2.setColor(upColor);
+                                g2.drawLine((int) previousMove.x, (int)previousMove.y, (int) m.x, (int) m.y);
                             }
                         }
                         count++;
@@ -65,23 +70,21 @@ public void print(Graphics g) {
                     }
                     case DRAW_LINE -> {
                         if (inShow && previousMove != null) {
-                            g.setColor(downColor);
-                            g.drawLine((int) previousMove.x, (int)previousMove.y, (int) m.x, (int) m.y);
+                            g2.setColor(downColor);
+                            g2.drawLine((int) previousMove.x, (int)previousMove.y, (int) m.x, (int) m.y);
                         }
                         count++;
                         previousMove = m;
                     }
                     case TOOL_CHANGE -> {
                         downColor = m.getColor();
-                        ((Graphics2D) g).setStroke(new BasicStroke((int) m.getDiameter()));
+                        g2.setStroke(new BasicStroke((int) m.getDiameter()));
                     }
                 }
             }
         }
         catch(Exception e) {
-            //Log.error(e.getMessage());
+            //logger.error(e.getMessage());
         }
-
-        g.translate(-dx,-dy);
     }
 }
diff --git a/src/main/java/com/marginallyclever/makelangelo/donatelloimpl/nodes/SaveTurtle.java b/src/main/java/com/marginallyclever/makelangelo/donatelloimpl/nodes/SaveTurtle.java
index c982fb56e..c49faf779 100644
--- a/src/main/java/com/marginallyclever/makelangelo/donatelloimpl/nodes/SaveTurtle.java
+++ b/src/main/java/com/marginallyclever/makelangelo/donatelloimpl/nodes/SaveTurtle.java
@@ -2,8 +2,8 @@
 
 import com.marginallyclever.makelangelo.plotter.plottersettings.PlotterSettings;
 import com.marginallyclever.makelangelo.plotter.plottersettings.PlotterSettingsManager;
-import com.marginallyclever.nodegraphcore.dock.Input;
-import com.marginallyclever.nodegraphcore.dock.Output;
+import com.marginallyclever.nodegraphcore.port.Input;
+import com.marginallyclever.nodegraphcore.port.Output;
 import com.marginallyclever.nodegraphcore.Node;
 import com.marginallyclever.makelangelo.makeart.io.TurtleFactory;
 import com.marginallyclever.makelangelo.turtle.Turtle;
diff --git a/src/main/java/com/marginallyclever/makelangelo/donatelloimpl/nodes/TransformTurtle.java b/src/main/java/com/marginallyclever/makelangelo/donatelloimpl/nodes/TransformTurtle.java
index 1c6d3fd20..a3d7e09fe 100644
--- a/src/main/java/com/marginallyclever/makelangelo/donatelloimpl/nodes/TransformTurtle.java
+++ b/src/main/java/com/marginallyclever/makelangelo/donatelloimpl/nodes/TransformTurtle.java
@@ -1,7 +1,7 @@
 package com.marginallyclever.makelangelo.donatelloimpl.nodes;
 
-import com.marginallyclever.nodegraphcore.dock.Input;
-import com.marginallyclever.nodegraphcore.dock.Output;
+import com.marginallyclever.nodegraphcore.port.Input;
+import com.marginallyclever.nodegraphcore.port.Output;
 import com.marginallyclever.nodegraphcore.Node;
 import com.marginallyclever.makelangelo.turtle.Turtle;
 
diff --git a/src/main/java/com/marginallyclever/makelangelo/donatelloimpl/nodes/TurtleToBufferedImage.java b/src/main/java/com/marginallyclever/makelangelo/donatelloimpl/nodes/TurtleToBufferedImage.java
index 1f516b174..2f0779fe6 100644
--- a/src/main/java/com/marginallyclever/makelangelo/donatelloimpl/nodes/TurtleToBufferedImage.java
+++ b/src/main/java/com/marginallyclever/makelangelo/donatelloimpl/nodes/TurtleToBufferedImage.java
@@ -2,8 +2,8 @@
 
 import com.marginallyclever.makelangelo.turtle.Turtle;
 import com.marginallyclever.makelangelo.turtle.TurtleMove;
-import com.marginallyclever.nodegraphcore.dock.Input;
-import com.marginallyclever.nodegraphcore.dock.Output;
+import com.marginallyclever.nodegraphcore.port.Input;
+import com.marginallyclever.nodegraphcore.port.Output;
 import com.marginallyclever.nodegraphcore.Node;
 
 
@@ -16,7 +16,7 @@ public class TurtleToBufferedImage extends Node {
     private final Output<BufferedImage> output = new Output<>("output", BufferedImage.class, new BufferedImage(1,1,BufferedImage.TYPE_INT_ARGB));
 
     public TurtleToBufferedImage() {
-        super("TurtleToImage");
+        super("TurtleToBufferedImage");
         addVariable(turtle);
         addVariable(output);
     }
@@ -29,7 +29,12 @@ public void update() {
             int h = (int)Math.ceil(r.getHeight());
             int w = (int)Math.ceil(r.getWidth());
             BufferedImage img = new BufferedImage(w,h,BufferedImage.TYPE_INT_ARGB);
-            Graphics2D g = img.createGraphics();
+            Graphics2D g = (Graphics2D)img.createGraphics();
+            g.setRenderingHint(RenderingHints.KEY_ANTIALIASING,RenderingHints.VALUE_ANTIALIAS_ON);
+            g.setRenderingHint(RenderingHints.KEY_RENDERING,RenderingHints.VALUE_RENDER_QUALITY);
+            g.setRenderingHint(RenderingHints.KEY_STROKE_CONTROL,RenderingHints.VALUE_STROKE_PURE);
+            g.setRenderingHint(RenderingHints.KEY_COLOR_RENDERING,RenderingHints.VALUE_COLOR_RENDER_QUALITY);
+            g.setRenderingHint(RenderingHints.KEY_ANTIALIASING,RenderingHints.VALUE_ANTIALIAS_ON);
             g.translate(-r.getX(),-r.getY());
 
             TurtleMove previousMove = null;
diff --git a/src/main/java/com/marginallyclever/makelangelo/donatelloimpl/nodes/TurtleToRectangle.java b/src/main/java/com/marginallyclever/makelangelo/donatelloimpl/nodes/TurtleToRectangle.java
index 2aa8f7985..51bda6431 100644
--- a/src/main/java/com/marginallyclever/makelangelo/donatelloimpl/nodes/TurtleToRectangle.java
+++ b/src/main/java/com/marginallyclever/makelangelo/donatelloimpl/nodes/TurtleToRectangle.java
@@ -2,8 +2,8 @@
 
 import com.marginallyclever.makelangelo.turtle.Turtle;
 import com.marginallyclever.nodegraphcore.Node;
-import com.marginallyclever.nodegraphcore.dock.Input;
-import com.marginallyclever.nodegraphcore.dock.Output;
+import com.marginallyclever.nodegraphcore.port.Input;
+import com.marginallyclever.nodegraphcore.port.Output;
 
 import java.awt.*;
 import java.awt.geom.Rectangle2D;
diff --git a/src/main/java/com/marginallyclever/makelangelo/donatelloimpl/nodes/shapes/Circle.java b/src/main/java/com/marginallyclever/makelangelo/donatelloimpl/nodes/shapes/Circle.java
index 8881ad312..26d68998c 100644
--- a/src/main/java/com/marginallyclever/makelangelo/donatelloimpl/nodes/shapes/Circle.java
+++ b/src/main/java/com/marginallyclever/makelangelo/donatelloimpl/nodes/shapes/Circle.java
@@ -1,8 +1,8 @@
 package com.marginallyclever.makelangelo.donatelloimpl.nodes.shapes;
 
 import com.marginallyclever.makelangelo.turtle.Turtle;
-import com.marginallyclever.nodegraphcore.dock.Input;
-import com.marginallyclever.nodegraphcore.dock.Output;
+import com.marginallyclever.nodegraphcore.port.Input;
+import com.marginallyclever.nodegraphcore.port.Output;
 import com.marginallyclever.nodegraphcore.Node;
 
 import org.slf4j.Logger;
diff --git a/src/main/java/com/marginallyclever/makelangelo/donatelloimpl/nodes/shapes/Line.java b/src/main/java/com/marginallyclever/makelangelo/donatelloimpl/nodes/shapes/Line.java
index 6356c5f82..75b8d7a3e 100644
--- a/src/main/java/com/marginallyclever/makelangelo/donatelloimpl/nodes/shapes/Line.java
+++ b/src/main/java/com/marginallyclever/makelangelo/donatelloimpl/nodes/shapes/Line.java
@@ -2,8 +2,8 @@
 
 import com.marginallyclever.makelangelo.turtle.Turtle;
 import com.marginallyclever.nodegraphcore.*;
-import com.marginallyclever.nodegraphcore.dock.Input;
-import com.marginallyclever.nodegraphcore.dock.Output;
+import com.marginallyclever.nodegraphcore.port.Input;
+import com.marginallyclever.nodegraphcore.port.Output;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
diff --git a/src/main/java/com/marginallyclever/makelangelo/donatelloimpl/nodes/shapes/NGon.java b/src/main/java/com/marginallyclever/makelangelo/donatelloimpl/nodes/shapes/NGon.java
index b1e63a6a6..d695172a5 100644
--- a/src/main/java/com/marginallyclever/makelangelo/donatelloimpl/nodes/shapes/NGon.java
+++ b/src/main/java/com/marginallyclever/makelangelo/donatelloimpl/nodes/shapes/NGon.java
@@ -1,8 +1,8 @@
 package com.marginallyclever.makelangelo.donatelloimpl.nodes.shapes;
 
 import com.marginallyclever.makelangelo.turtle.Turtle;
-import com.marginallyclever.nodegraphcore.dock.Input;
-import com.marginallyclever.nodegraphcore.dock.Output;
+import com.marginallyclever.nodegraphcore.port.Input;
+import com.marginallyclever.nodegraphcore.port.Output;
 import com.marginallyclever.nodegraphcore.Node;
 
 import org.slf4j.Logger;
diff --git a/src/main/java/com/marginallyclever/makelangelo/donatelloimpl/nodes/shapes/Rectangle.java b/src/main/java/com/marginallyclever/makelangelo/donatelloimpl/nodes/shapes/Rectangle.java
index 57ddae3e4..51d9df27a 100644
--- a/src/main/java/com/marginallyclever/makelangelo/donatelloimpl/nodes/shapes/Rectangle.java
+++ b/src/main/java/com/marginallyclever/makelangelo/donatelloimpl/nodes/shapes/Rectangle.java
@@ -1,8 +1,8 @@
 package com.marginallyclever.makelangelo.donatelloimpl.nodes.shapes;
 
 import com.marginallyclever.makelangelo.turtle.Turtle;
-import com.marginallyclever.nodegraphcore.dock.Input;
-import com.marginallyclever.nodegraphcore.dock.Output;
+import com.marginallyclever.nodegraphcore.port.Input;
+import com.marginallyclever.nodegraphcore.port.Output;
 import com.marginallyclever.nodegraphcore.Node;
 
 import org.slf4j.Logger;
diff --git a/src/main/java/com/marginallyclever/makelangelo/makeart/TransformedImage.java b/src/main/java/com/marginallyclever/makelangelo/makeart/TransformedImage.java
index 4342e6771..ebd21a858 100644
--- a/src/main/java/com/marginallyclever/makelangelo/makeart/TransformedImage.java
+++ b/src/main/java/com/marginallyclever/makelangelo/makeart/TransformedImage.java
@@ -221,6 +221,10 @@ public void setScale(float x,float y) {
 		scaleY = y;
 	}
 
+	public void setTranslation(float x,float y) {
+		translateX = x;
+		translateY = y;
+	}
 
 	public void setRGB(float x, float y, int c) {
 		sourceImage.setRGB(getTransformedX(x), getTransformedY(y), c);
diff --git a/src/main/java/com/marginallyclever/makelangelo/makeart/imagefilter/FilterContrastAdjust.java b/src/main/java/com/marginallyclever/makelangelo/makeart/imagefilter/FilterContrastAdjust.java
index 3d3d6ad03..1863a8b89 100644
--- a/src/main/java/com/marginallyclever/makelangelo/makeart/imagefilter/FilterContrastAdjust.java
+++ b/src/main/java/com/marginallyclever/makelangelo/makeart/imagefilter/FilterContrastAdjust.java
@@ -40,16 +40,16 @@ public TransformedImage filter() {
 		BufferedImage bi = img.getSourceImage();
 		TransformedImage after = new TransformedImage(img);
 		BufferedImage afterBI = after.getSourceImage();
-
+		var cm = bi.getColorModel();
 		for (int y = 0; y < h; ++y) {
 			for (int x = 0; x < w; ++x) {
 				int color = bi.getRGB(x, y);
-				int red = adjust(red32(color));
-				int green = adjust(green32(color));
-				int blue = adjust(blue32(color));
-				int alpha = alpha32(color);
-
-				afterBI.setRGB(x, y, ImageFilter.encode32bit(red,green,blue,alpha));
+				int red = adjust(cm.getRed(color));
+				int green = adjust(cm.getGreen(color));
+				int blue = adjust(cm.getBlue(color));
+				int alpha = cm.getAlpha(color);
+				Color c = new Color(red,green,blue,alpha);
+				afterBI.setRGB(x, y, c.getRGB());
 			}
 		}
 
diff --git a/src/main/java/com/marginallyclever/makelangelo/makeart/imagefilter/ImageFilter.java b/src/main/java/com/marginallyclever/makelangelo/makeart/imagefilter/ImageFilter.java
index 62cbab300..a35353b61 100644
--- a/src/main/java/com/marginallyclever/makelangelo/makeart/imagefilter/ImageFilter.java
+++ b/src/main/java/com/marginallyclever/makelangelo/makeart/imagefilter/ImageFilter.java
@@ -9,48 +9,13 @@
  * @author dan Royer
  */
 public abstract class ImageFilter {
-	protected static int red32(int color) {
-		return ((color >> 16) & 0xff);
-	}
-
-	protected static int green32(int color) {
-		return ((color >> 8) & 0xff);
-	}
-
-	protected static int blue32(int color) {
-		return ((color) & 0xff);
-	}
-
-	protected static int alpha32(int color) {
-		return ((color >> 24) & 0xff);
-	}
-
 	/**
 	 * @param color RGBA
 	 * @return grayscale value
 	 */
 	public static int decode32bit(int color) {
-		int r = red32(color);
-		int g = green32(color);
-		int b = blue32(color);
-		int a = alpha32(color);
-
-		return average(r, g, b, a / 255.0);
-	}
-
-	/**
-	 * @param red 0-255
-	 * @param green 0-255
-	 * @param blue 0-255
-	 * @param alpha 0-255
-	 * @return RGB color
-	 */
-	public static int encode32bit(int red,int green,int blue,int alpha) {
-		red &= 0xff;
-		green &= 0xff;
-		blue &= 0xff;
-		alpha &= 0xff;
-		return (alpha << 24) | (red << 16) | (green << 8) | blue;
+		Color c = new Color(color);
+		return (c.getRed() + c.getGreen() + c.getBlue()) / 3;
 	}
 
 	/**
@@ -59,34 +24,8 @@ public static int encode32bit(int red,int green,int blue,int alpha) {
 	 */
 	public static int encode32bit(int greyscale) {
 		greyscale &= 0xff;
-		return encode32bit(greyscale,greyscale,greyscale,0xff);
-	}
-
-	/**
-	 * @param color RGBA
-	 * @return grayscale value
-	 */
-	protected static int decodeColor(Color color) {
-		int r = color.getRed();
-		int g = color.getGreen();
-		int b = color.getBlue();
-		int a = color.getAlpha();
-		return average(r, g, b, a / 255.0);
-	}
-
-	/**
-	 * @param r red
-	 * @param g green
-	 * @param b blue
-	 * @param a alpha
-	 * @return grayscale value
-	 */
-	private static int average(int r, int g, int b, double a) {
-		int r2 = (int)(r * a);
-		int g2 = (int)(g * a);
-		int b2 = (int)(b * a);
-
-		return (r2 + g2 + b2) / 3;
+		Color c = new Color(greyscale,greyscale,greyscale);
+		return c.getRGB();
 	}
 
 	/**
diff --git a/src/main/java/com/marginallyclever/makelangelo/makeart/turtlegenerator/lineweight/LineWeight.java b/src/main/java/com/marginallyclever/makelangelo/makeart/turtlegenerator/lineweight/LineWeight.java
index 93721f0b7..e3ba68672 100644
--- a/src/main/java/com/marginallyclever/makelangelo/makeart/turtlegenerator/lineweight/LineWeight.java
+++ b/src/main/java/com/marginallyclever/makelangelo/makeart/turtlegenerator/lineweight/LineWeight.java
@@ -3,7 +3,7 @@
 import java.util.Collections;
 import java.util.LinkedList;
 
-class LineWeight {
+public class LineWeight {
     public LinkedList<LineWeightSegment> segments = new LinkedList<>();
 
     public void flip() {
diff --git a/src/main/java/com/marginallyclever/makelangelo/makeart/turtlegenerator/lineweight/LineWeightByImageIntensity.java b/src/main/java/com/marginallyclever/makelangelo/makeart/turtlegenerator/lineweight/LineWeightByImageIntensity.java
index 0599fcf09..98df87b3f 100644
--- a/src/main/java/com/marginallyclever/makelangelo/makeart/turtlegenerator/lineweight/LineWeightByImageIntensity.java
+++ b/src/main/java/com/marginallyclever/makelangelo/makeart/turtlegenerator/lineweight/LineWeightByImageIntensity.java
@@ -25,7 +25,6 @@ public class LineWeightByImageIntensity extends TurtleGenerator {
     private static final Logger logger = LoggerFactory.getLogger(LineWeightByImageIntensity.class);
 
     private final double EPSILON = 0.001;
-    private final double CORNER_THRESHOLD = Math.cos(Math.toRadians(15));
 
     /**
      * must be greater than zero.
diff --git a/src/main/java/com/marginallyclever/makelangelo/makeart/turtlegenerator/lineweight/LineWeightSegment.java b/src/main/java/com/marginallyclever/makelangelo/makeart/turtlegenerator/lineweight/LineWeightSegment.java
index e98450820..eff739f51 100644
--- a/src/main/java/com/marginallyclever/makelangelo/makeart/turtlegenerator/lineweight/LineWeightSegment.java
+++ b/src/main/java/com/marginallyclever/makelangelo/makeart/turtlegenerator/lineweight/LineWeightSegment.java
@@ -8,7 +8,7 @@
  * Many segments make up a {@link LineWeight}.
  * @author Dan Royer
  */
-class LineWeightSegment {
+public class LineWeightSegment {
     public Point2D start, end;
     public int ix, iy;  // index for faster search
     public double weight;
diff --git a/src/test/java/com/marginallyclever/makelangelo/donatelloimpl/TestNodeGraphMakelangelo.java b/src/test/java/com/marginallyclever/makelangelo/donatelloimpl/TestNodeGraphMakelangelo.java
index e872c63de..89a1a066c 100644
--- a/src/test/java/com/marginallyclever/makelangelo/donatelloimpl/TestNodeGraphMakelangelo.java
+++ b/src/test/java/com/marginallyclever/makelangelo/donatelloimpl/TestNodeGraphMakelangelo.java
@@ -3,7 +3,7 @@
 import com.marginallyclever.makelangelo.donatelloimpl.nodes.TurtleDAO4JSON;
 import com.marginallyclever.makelangelo.turtle.Turtle;
 import com.marginallyclever.nodegraphcore.DAO4JSONFactory;
-import com.marginallyclever.nodegraphcore.dock.*;
+import com.marginallyclever.nodegraphcore.port.*;
 import com.marginallyclever.nodegraphcore.Graph;
 import com.marginallyclever.nodegraphcore.NodeFactory;
 import org.junit.jupiter.api.BeforeAll;