Optimize ImageBuffer, split map selection painting out so buffered maps aren't redrawn every selection change, be more selective when to y-flip data

Author: nathanielsherry

Framework/Cyclops/Cyclops/src/main/java/org/peakaboo/framework/cyclops/visualization/drawing/map/MapDrawing.java

@@ -12,6 +12,7 @@
 import org.peakaboo.framework.cyclops.visualization.drawing.Drawing;
 import org.peakaboo.framework.cyclops.visualization.drawing.DrawingRequest;
 import org.peakaboo.framework.cyclops.visualization.drawing.map.painters.MapPainter;
+import org.peakaboo.framework.cyclops.visualization.drawing.map.painters.SelectionMaskPainter;
 import org.peakaboo.framework.cyclops.visualization.drawing.painters.PainterData;
 import org.peakaboo.framework.cyclops.visualization.drawing.painters.axis.AxisPainter;
 import org.peakaboo.framework.cyclops.visualization.palette.Palette;
@@ -126,8 +127,13 @@ public void setPainters(MapPainter painter) {
 
 
 	/**
-	 * Draws a map using the given data and the given set of {@link MapPainter}s
-	 * 
+	 * Draws a map using the given data and the given set of {@link MapPainter}s.
+	 * <p>
+	 * Note: {@link SelectionMaskPainter}s are <em>deferred</em> and are not drawn here.
+	 * The selection is rendered separately via
+	 * {@link #drawSelectionOverlay(MapPainter)} so that callers can cache the base map
+	 * and recomposite a cheap selection overlay on top without re-rendering everything.
+	 *
 	 * @param data
 	 *            the data to use to draw the map
 	 * @param mapPainters
@@ -136,9 +142,9 @@ public void setPainters(MapPainter painter) {
 	@Override
 	public void draw()
 	{
-		
+
 		if (context == null) return;
-		
+
 		float oldMaxIntensity = dr.maxYIntensity;
 
 		Coord<Bounds<Float>> borderSizes = calcAxisBorders();
@@ -149,13 +155,15 @@ public void draw()
 
 
 			context.translate(borderSizes.x.start, borderSizes.y.start);
-			
+
 			for (MapPainter t : painters) {
+				// Selection masks are drawn separately as an overlay (see class note above)
+				if (t instanceof SelectionMaskPainter) continue;
 				t.draw(new PainterData(context, dr, mapDimensions, null));
 			}
 
 
-			
+
 		context.restore();
 
 
@@ -208,6 +216,27 @@ public void draw()
 	}
 
 
+	/**
+	 * Draws a single selection-overlay painter on top of an already-drawn base map,
+	 * using the same border translate and cell geometry as {@link #draw()}. This lets
+	 * a selection change be recomposited cheaply without re-rendering the base map or
+	 * its axes.
+	 *
+	 * @param selectionPainter the selection painter to draw; ignored if {@code null}
+	 */
+	public void drawSelectionOverlay(MapPainter selectionPainter)
+	{
+		if (context == null || selectionPainter == null) return;
+
+		Coord<Bounds<Float>> borderSizes = calcAxisBorders();
+		Coord<Float> mapDimensions = calcMapSize();
+
+		context.save();
+			context.translate(borderSizes.x.start, borderSizes.y.start);
+			selectionPainter.draw(new PainterData(context, dr, mapDimensions, null));
+		context.restore();
+	}
+
 
 	/**
 	 * Calculates the dimensions of the map. Aspect ratio is preserved, and image dimensions are drawn from

Framework/Cyclops/Cyclops/src/main/java/org/peakaboo/framework/cyclops/visualization/drawing/map/painters/RasterColorMapPainter.java

@@ -60,21 +60,26 @@ public synchronized void drawMap(PainterData p, float cellSize, float rawCellSiz
 
 		p.context.save();
 
-			IntArrayList data = transformListDataForMap(p.dr, pixels);
-	
 			if (p.dr.drawToVectorSurface) {
+				// Vector surfaces can't be buffered, so we always re-transform and draw.
+				IntArrayList data = transformListDataForMap(p.dr, pixels);
 				drawAsScalar(p, data, cellSize);
 				buffer = null;
 			} else {
-				
+
 				if (buffer == null || buffer.getWidth() != p.dr.dataWidth || buffer.getHeight() != p.dr.dataHeight) {
 					buffer = createRasterBuffer(p);
+					// A freshly allocated buffer is blank and must be filled.
+					stale = true;
 				}
 				if (stale) {
+					// Only pay for the flip/transform when we actually need to rewrite
+					// the buffer; otherwise we just recomposite the cached pixels.
+					IntArrayList data = transformListDataForMap(p.dr, pixels);
 					drawToRasterBuffer(data, p.dr.dataHeight * p.dr.dataWidth);
 				}
 				p.context.compose(buffer, 0, 0, cellSize);
-				
+
 			}
 
 		p.context.restore();

Framework/Cyclops/Cyclops/src/main/java/org/peakaboo/framework/cyclops/visualization/drawing/map/painters/SelectionMaskPainter.java

@@ -1,5 +1,6 @@
 package org.peakaboo.framework.cyclops.visualization.drawing.map.painters;
 
+import java.util.Arrays;
 import java.util.logging.Level;
 
 import org.peakaboo.framework.cyclops.log.CyclopsLog;
@@ -9,6 +10,8 @@
 
 public class SelectionMaskPainter extends RasterColorMapPainter {
 
+	private static final int TRANSPARENT_ARGB = 0;
+
 	private int sizeX, sizeY;
 	private int selectionColour;
 	private IntArrayList colours;
@@ -21,29 +24,27 @@ public SelectionMaskPainter(PaletteColour c, IntArrayList points, int sizeX, int
 	}
 
 	public synchronized void configure(int dataWidth, int dataHeight, IntArrayList points) {
-		int size = sizeX*sizeY;
-		
 		if (this.sizeX != dataWidth || this.sizeY != dataHeight) {
 			super.buffer = null;
 			this.sizeX = dataWidth;
 			this.sizeY = dataHeight;
 		}
 
-		colours.clear();
-		
+		// Size is derived from the incoming dimensions, not the (possibly stale) fields.
+		int size = sizeX * sizeY;
+
 		// don't bother updating the pixel list, we won't be drawing anything when no
 		// points are in the selection.
 		if (points.isEmpty()) {
 			setEnabled(false);
 			return;
 		}
-		
-		PaletteColour transparent = new PaletteColour(0, 0, 0, 0);
-		int transparentARGB = transparent.getARGB();
-		for (int i = 0; i < size; i++) {
-			colours.add(transparentARGB);
-		}
-		
+
+		// Reuse the backing array rather than reallocating: ensure it's the right
+		// length, reset every pixel to transparent (ARGB 0), then mark selected points.
+		colours.size(size);
+		Arrays.fill(colours.elements(), 0, size, TRANSPARENT_ARGB);
+
 		for (int i = 0; i < points.size(); i++) {
 			int point = points.getInt(i);
 			if (point >= size || point < 0) {
@@ -55,7 +56,7 @@ public synchronized void configure(int dataWidth, int dataHeight, IntArrayList p
 
 		setPixels(colours);
 		setEnabled(true);
-		
+
 	}
 
 }

Framework/Cyclops/CyclopsSwing/src/main/java/org/peakaboo/framework/cyclops/visualization/backend/awt/surfaces/graphics/ImageBuffer.java

@@ -1,62 +1,91 @@
 package org.peakaboo.framework.cyclops.visualization.backend.awt.surfaces.graphics;
 
 
+import java.awt.AlphaComposite;
 import java.awt.Graphics2D;
 import java.awt.image.BufferedImage;
+import java.awt.image.DataBufferInt;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.List;
 
 import org.peakaboo.framework.cyclops.visualization.Buffer;
 import org.peakaboo.framework.cyclops.visualization.palette.PaletteColour;
-import org.peakaboo.framework.stratus.api.Stratus;
 
+/**
+ * A {@link Buffer} backed by a {@link BufferedImage}.
+ * <p>
+ * The backing image is always a {@link BufferedImage#TYPE_INT_ARGB} image, so pixel
+ * access reads and writes the image's live {@code int[]} raster directly. This avoids
+ * the full-image {@code getRGB}/{@code setRGB} copies the old implementation paid on
+ * every buffer build, which matters a great deal for large maps.
+ * <p>
+ * {@code TYPE_INT_ARGB} is <em>non-premultiplied</em>, so the stored {@code int}
+ * values are exactly the straight ARGB values passed to {@link #setPixelARGB}, which
+ * keeps semi-transparent pixels (e.g. selection masks) correct.
+ * <p>
+ * Grabbing the live raster array disables Java2D's managed-image acceleration for that
+ * image, which is fine for buffers we fill pixel-by-pixel on the CPU. Buffers that are
+ * only ever drawn to via {@link Graphics2D} (e.g. a large compositing buffer) never
+ * touch the pixel array — {@link #clear()} uses {@link AlphaComposite#Clear} in that
+ * case — so they remain managed and accelerated.
+ */
 public class ImageBuffer extends ScreenSurface implements Buffer
 {
 
-	private BufferedImage	image;
-	
-	private boolean 		dirty = false;
-	private int[]			datasource;
+	private final BufferedImage	image;
+
+	/**
+	 * The image's live raster array, lazily fetched on first pixel access. Null until
+	 * then, so Graphics2D-only buffers never grab it (and stay managed/accelerated).
+	 */
+	private int[]				datasource;
+
 
- 
 	public ImageBuffer(int x, int y) {
-		this(Stratus.acceleratedImage(x, y));
+		this(new BufferedImage(x, y, BufferedImage.TYPE_INT_ARGB));
 	}
 
-	public ImageBuffer(BufferedImage image) {
+	private ImageBuffer(BufferedImage image) {
 		super((Graphics2D) image.getGraphics());
 		this.image = image;
 	}
-	private synchronized void init()
-	{
+
+	/**
+	 * Lazily obtains the image's live raster array. Writes through it are immediately
+	 * visible on the image.
+	 */
+	private int[] pixels() {
 		if (datasource == null) {
-			datasource = image.getRGB(0, 0, image.getWidth(), image.getHeight(), null, 0, image.getWidth());
+			datasource = ((DataBufferInt) image.getRaster().getDataBuffer()).getData();
 		}
+		return datasource;
 	}
 
 	@Override
 	public BufferedImage getImageSource()
 	{
-		commitChanges();
+		// The live raster is the source of truth - nothing to flush.
 		return image;
 	}
 
-	private void commitChanges()
-	{
-		if (dirty) {
-			image.setRGB(0, 0, image.getWidth(), image.getHeight(), datasource, 0, image.getWidth());
-		}
-		dirty = false;
-	}
-	
 	@Override
 	public void clear() {
-		if (datasource == null) {
-			init();
+		if (datasource != null) {
+			// We've already taken the pixel array; clear it in place.
+			Arrays.fill(datasource, 0);
+		} else {
+			// Clear via the graphics context so the image stays managed/accelerated.
+			// This is the path large compositing buffers take, since they are never
+			// pixel-poked and so never grab the raster array.
+			Graphics2D g = (Graphics2D) image.getGraphics();
+			try {
+				g.setComposite(AlphaComposite.Clear);
+				g.fillRect(0, 0, image.getWidth(), image.getHeight());
+			} finally {
+				g.dispose();
+			}
 		}
-		Arrays.fill(datasource, 0);
-		commitChanges();
 	}
 
 	@Override
@@ -68,18 +97,12 @@ public void setPixelValue(int x, int y, PaletteColour c) {
 	public void setPixelValue(int offset, PaletteColour c) {
 		setPixelARGB(offset, c.getARGB());
 	}
-	
+
 	@Override
 	public void setPixelARGB(int offset, int c) {
-		if (datasource == null) {
-			init();
-		}
-		dirty = true;
-		datasource[offset] = c;
+		pixels()[offset] = c;
 	}
 
-	
-	
 
 	@Override
 	public PaletteColour getPixelValue(int x, int y) {
@@ -89,12 +112,7 @@ public PaletteColour getPixelValue(int x, int y) {
 
 	@Override
 	public PaletteColour getPixelValue(int index) {
-		
-		if (datasource == null) {
-			init();
-		}
-		
-		return new PaletteColour(datasource[index]);
+		return new PaletteColour(pixels()[index]);
 	}
 
 	@Override
@@ -127,7 +145,7 @@ public List<Integer> getPixelsARGB() {
 
 	@Override
 	public int getPixelARGB(int index) {
-		return datasource[index];	
+		return pixels()[index];
 	}
 
 	@Override

Framework/Stratus/src/main/java/org/peakaboo/framework/stratus/components/ui/layers/ModalLayer.java

@@ -6,6 +6,7 @@
 import java.awt.Component;
 import java.awt.Graphics;
 import java.awt.Graphics2D;
+import java.awt.Rectangle;
 import java.awt.TexturePaint;
 import java.awt.event.InputEvent;
 import java.awt.event.KeyEvent;
@@ -125,12 +126,22 @@ public void paint(Graphics g) {
 				if (Stratus.lowGraphicsMode) {
 					super.paint(g);
 				} else {
-					//Paint into a buffer
+					//Paint into a buffer, limiting the work to the region being repainted
+					//on screen. The texture fill below is clipped to that same region, so
+					//the rest of the buffer is never read from on this paint.
 					buffered.resize(this.getWidth(), this.getHeight());
-					buffered.clear();
 					var buffer = buffered.get();
 					var bufg = buffer.createGraphics();
-					
+					if (g.getClip() != null) {
+						bufg.setClip(g.getClip());
+					}
+					Rectangle dirty = bufg.getClipBounds();
+					if (dirty == null) {
+						dirty = new Rectangle(0, 0, this.getWidth(), this.getHeight());
+					}
+					bufg.setBackground(new Color(255, 255, 255, 0));
+					bufg.clearRect(dirty.x, dirty.y, dirty.width, dirty.height);
+
 					Graphics2D b2d = Stratus.modernGraphicsSettings(bufg);
 					super.paint(b2d);
 					buffered.markPainted();