Is Java2D broken in general, or just on my config?

Question

Hi all,
I am working with java 6.0_10 or _11 (is that out?) on a Linux Ubuntu 8.04 machine
Below is my code. I was just working on adding an 2 small additional features to my MouseDragOutliner class. First first addition was to add line drawing (works), and the second was to allow the user to specify a custom shape to be used in drawing the outline. In my test example, I used a star shape (a Polygon). It actually works great, but sometimes (especially it I move up and to the left) it throws an java.lang.InternalError in the run area (where the painting is happening)
Here's what the InternalError says:
Unable to Stroke shape (setDashT4: invalid dash transformation (singular))
     at sun.java2d.pipe.LoopPipe.getStrokeSpans(LoopPipe.java:234)
     at sun.java2d.x11.X11Renderer.draw(X11Renderer.java:325)
     at sun.java2d.pipe.ValidatePipe.draw(ValidatePipe.java:136)
So now I am catching this Error (probably a very bad idea, but what is the alternative?) and it works fine.
Can anybody confirm that this is a problem on other platforms? Any thoughts on handling this in a different way ie not catching the InternalError?
package tjacobs.ui.drag;
import java.awt.BasicStroke;
import java.awt.Color;
import java.awt.Component;
import java.awt.Container;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.Point;
import java.awt.Rectangle;
import java.awt.Shape;
import java.awt.Stroke;
import java.awt.event.*;
import java.awt.geom.AffineTransform;
import java.util.ArrayList;
import java.util.Iterator;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.SwingUtilities;
import tjacobs.ui.util.PaintUtils;
import tjacobs.ui.util.WindowClosingActions;
* See the public static method addAMouseDragOutliner
public class MouseDragOutliner extends MouseAdapter implements MouseMotionListener {
     public static final BasicStroke DASH_STROKE = new BasicStroke(1.0f, BasicStroke.CAP_SQUARE, BasicStroke.JOIN_BEVEL, 10.0f, new float[] {8, 8}, 0);
     public static final int RECTANGLE = 0;
     public static final int OVAL = 1;
     public static final int LINE = 2;
     private boolean mUseMove = false;
     private Point mStart;
     private Point mEnd;
     private int mShape = RECTANGLE;
     private Shape mCustomShape;
     private Component mComponent;
     private MyRunnable mRunner= new MyRunnable();
     private ArrayList mListeners = new ArrayList(1);
     public MouseDragOutliner() {
          super();
     public MouseDragOutliner(boolean useMove) {
          this();
          mUseMove = useMove;
     public void setShape(int s) {
          mShape = s;
     public int getShape() {
          return mShape;
     public void setCustomShape(Shape s) {
          mCustomShape = s;
     public Shape getCustomShape() {
          return mCustomShape;
     public void mouseDragged(MouseEvent me) {
          doMouseDragged(me);
     public void mousePressed(MouseEvent me) {
          mStart = me.getPoint();
     public void mouseEntered(MouseEvent me) {
          mStart = me.getPoint();
     public void mouseReleased(MouseEvent me) {
          Iterator i = mListeners.iterator();
          Point end = me.getPoint();
          while (i.hasNext()) {
               ((OutlineListener)i.next()).mouseDragEnded(mStart, end);
          //mStart = null;
     public void mouseMoved(MouseEvent me) {
          if (mUseMove) {
               doMouseDragged(me);
     public     void addOutlineListener(OutlineListener ol) {
          mListeners.add(ol);
     public void removeOutlineListener(OutlineListener ol) {
          mListeners.remove(ol);
     private class MyRunnable implements Runnable {
          public void run() {
               Graphics g = mComponent.getGraphics();
               if (g == null) {
                    return;
               Graphics2D g2 = (Graphics2D) g;
               Stroke s = g2.getStroke();
               g2.setStroke(DASH_STROKE);
               int x = Math.min(mStart.x, mEnd.x);
               int y = Math.min(mStart.y, mEnd.y);
               int w = Math.abs(mEnd.x - mStart.x);
               int h = Math.abs(mEnd.y - mStart.y);
               g2.setXORMode(Color.WHITE);
               if (mCustomShape != null) {
                    Rectangle r = mCustomShape.getBounds();
                    AffineTransform scale = AffineTransform.getScaleInstance(w / (double)r.width, h / (double)r.height);
                    AffineTransform trans = AffineTransform.getTranslateInstance(x - r.x, y-r.y);
                    g2.transform(trans);
                    g2.transform(scale);
                    try {
                         g2.draw(mCustomShape);
                    catch (java.lang.InternalError error) {
                         //this is a really bad thing to be catching!
                         error.printStackTrace();
                    //something
               } else {
                    if (mShape == RECTANGLE) g2.drawRect(x, y, w, h);
                    else if (mShape == OVAL) g2.drawOval(x, y, w, h);
                    else if (mShape == LINE) g2.drawLine(mStart.x, mStart.y, mEnd.x, mEnd.y);
               g2.setStroke(s);     
     public void doMouseDragged(MouseEvent me) {
          mEnd = me.getPoint();
          if (mStart != null) {
               mComponent = me.getComponent();
               mComponent.repaint();
               SwingUtilities.invokeLater(mRunner);
     public static MouseDragOutliner addAMouseDragOutliner(Component c) {
          MouseDragOutliner mdo = new MouseDragOutliner();
          c.addMouseListener(mdo);
          c.addMouseMotionListener(mdo);
          return mdo;
     public static interface OutlineListener {
          public void mouseDragEnded(Point start, Point finish);
     public static void main(String[] args) {
          JFrame f = new JFrame("MouseDragOutliner Test");
          Container c = f.getContentPane();
          JPanel p = new JPanel();
          //p.setBackground(Color.BLACK);
          c.add(p);
          MouseDragOutliner outliner = addAMouseDragOutliner(p);
          outliner.setShape(LINE);
          Shape a = PaintUtils.createStandardStar(100, 100, 5, .3, 0);
          outliner.setCustomShape(a);
          f.setBounds(200, 200, 400, 400);
          f.addWindowListener(new WindowClosingActions.Exit());
          f.setVisible(true);
============
PaintUtils
============
* Created on Jun 25, 2005 by @author Tom Jacobs
package tjacobs.ui.util;
import java.awt.Color;
import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.GraphicsConfiguration;
import java.awt.GraphicsDevice;
import java.awt.GraphicsEnvironment;
import java.awt.Point;
import java.awt.Polygon;
import java.awt.Shape;
import java.awt.Transparency;
import java.awt.geom.Area;
import java.awt.geom.Ellipse2D;
import java.awt.image.BufferedImage;
import javax.swing.JPanel;
public class PaintUtils {
     private PaintUtils() {
          super();
          // TODO Auto-generated constructor stub
     public static StringBuffer printPoint(Point p) {
          return new StringBuffer("" + p.x + "," + p.y);
     public static void drawArc(Graphics2D g, int x, int y, int width, int height, double start, double end, int innerXOffset, int innerYOffset) {
          Area a = createArc(x, y, width, height, start, end, innerXOffset, innerYOffset);
          g.draw(a);
     public static void fillArc(Graphics2D g, int x, int y, int width, int height, double start, double end, int innerXOffset, int innerYOffset) {
          Area a = createArc(x, y, width, height, start, end, innerXOffset, innerYOffset);
          g.fill(a);
     public static Area createArc(int x, int y, int width, int height, double start, double end, int innerXOffset, int innerYOffset) {
           Shape s = new Ellipse2D.Double(x,y, width, height);
           Area a = new Area(s);
           int center_x = x + width / 2;
           int center_y = y + height / 2;
           int xs[] = new int[6];
           int ys[] = new int[6];
           xs[0] = center_x;
           ys[0] = center_y;
           double middle = start + (end -start) / 2;
           double quarter1 =start + (middle - start)/2; //new point in the polygon between start and middle
           double quarter2 =middle + (end - middle)/2; //new point in the polygon between middle and end
           int pt1_x = (int) (center_x + width * Math.cos(start));
           int pt1_y = (int) (center_y + height * Math.sin(start));
           int pt2_x = (int) (center_x + width * Math.cos(end));
           int pt2_y = (int) (center_y + height * Math.sin(end));
           int mid_x = (int) (center_x + width * Math.cos(middle)); //now there is no need to *2 because with a polygon with 6 points the worst case (360 degrees) is guaranteed
           int mid_y = (int) (center_y + height * Math.sin(middle));
           int quar1_x= (int) (center_x + height * Math.cos(quarter1)); //calculates the x and y for the new points
           int quar1_y= (int) (center_y + height * Math.sin(quarter1));
           int quar2_x= (int) (center_x + height * Math.cos(quarter2));
           int quar2_y= (int) (center_y + height * Math.sin(quarter2));
           //inserts the new points in the polygon' array in the rigth order
           xs[1] = pt1_x;
           ys[1] = pt1_y;
           xs[2] = quar1_x;
           ys[2] = quar1_y;
           xs[3] = mid_x;
           ys[3] = mid_y;
           xs[4] = quar2_x;
           ys[4] = quar2_y;
           xs[5] = pt2_x;
           ys[5] = pt2_y;
           Polygon p = new Polygon(xs, ys, 6); // create the new polygon with the 6 points
           Area clip = new Area(p);
           a.intersect(clip);
          Ellipse2D.Double inner = new Ellipse2D.Double(x + innerXOffset, y + innerYOffset, width - innerXOffset * 2, height - innerYOffset * 2);
          a.subtract(new Area(inner));
          return a;
     public static Polygon createStandardStar(double width, double height, int points, double centerRatio, double angleOffset) {
          int pts = points * 2;
          int xs[] = new int[pts];
          int ys[] = new int[pts];
          double xrad = width / 2;
          double yrad = height / 2;
          int innerx = (int) (xrad * centerRatio);
          int innery = (int) (yrad * centerRatio);
          double startangle = 0 + angleOffset;
          double anglePer = 2 * Math.PI / points;
          for (int i = 0; i < points ; i++) {
               double angle = startangle + anglePer * i;
               xs[i * 2] = (int) (xrad + xrad * Math.sin(angle));
               ys[i * 2] = (int) (yrad - yrad * Math.cos(angle));
               xs[i * 2 + 1] = (int) (xrad + innerx * Math.sin(angle + anglePer / 2));
               ys[i * 2 + 1] = (int) (yrad - innery * Math.cos(angle + anglePer / 2));
          Polygon p = new Polygon(xs, ys, pts);
          return p;
     public static BufferedImage optimizeImage(BufferedImage img)
          GraphicsDevice gd = GraphicsEnvironment.getLocalGraphicsEnvironment().getDefaultScreenDevice();                    
          GraphicsConfiguration gc = gd.getDefaultConfiguration();
          boolean istransparent = img.getColorModel().hasAlpha();
          BufferedImage img2 = gc.createCompatibleImage(img.getWidth(), img.getHeight(), istransparent ? Transparency.BITMASK : Transparency.OPAQUE);
          Graphics2D g = img2.createGraphics();
          g.drawImage(img, 0, 0, null);
          g.dispose();
          return img2;
     public static void main (String[] args) {
          //arcTest();
          standardStarTest();
     public static void standardStarTest() {
          final Polygon gon = createStandardStar(100,100, 5, .3, 0);
          JPanel jp = new JPanel() {
               public void paintComponent(Graphics g) {
                    super.paintComponent(g);
                    g.setColor(Color.BLACK);
                    ((Graphics2D)g).fill(gon);
//                    for (int i = 0; i < gon.npoints - 1; i++) {
//                         g.drawLine(gon.xpoints, gon.ypoints[i], gon.xpoints[i + 1], gon.ypoints[i + 1]);
                    g.drawLine(gon.xpoints[gon.npoints - 1], gon.ypoints[gon.npoints - 1], gon.xpoints[0], gon.ypoints[0]);
          jp.setPreferredSize(new Dimension(100,100));
          WindowUtilities.visualize(jp);
     public static void arcTest() {
          JPanel jp = new JPanel() {
               public void paintComponent(Graphics g) {
                    Graphics2D g2 = (Graphics2D) g;
                    g2.setColor(Color.RED);
                    drawArc(g2, 10,10,50,50, Math.PI / 2, 3 * Math.PI / 2, 12, 0);
                    g2.setColor(Color.MAGENTA);
                    fillArc(g2, 60,10,50,50, 0, 3 * Math.PI / 4, 6, 6);
                    g2.setColor(Color.GREEN);
                    fillArc(g2, 10,60, 50,50, 0, 3.5 * Math.PI / 2, 15, 6);
          jp.setPreferredSize(new Dimension(100,100));
          WindowUtilities.visualize(jp);

Answer 1

Add some System.out.println's
AffineTransform scale = AffineTransform.getScaleInstance(w / (double)r.width, h / (double)r.height);
System.out.println("Scale: " + scale);
AffineTransform trans = AffineTransform.getTranslateInstance(x - r.x, y-r.y);
System.out.println("Translation: " + trans);
System.out.println("G2 Transform: " + g2.getTransform());
g2.transform(trans);
System.out.println("G2 Transform after Trans: " + g2.getTransform());
g2.transform(scale);
System.out.println("G2 Transform after Scale: " + g2.getTransform());
try {
          g2.draw(mCustomShape);
}Here's an example output that I get when the error is thrown
Scale: AffineTransform[[0.010526315789474, 0.0, 0.0], [0.0, 0.0, 0.0]]
Translation: AffineTransform[[1.0, 0.0, 37.0], [0.0, 1.0, 35.0]]
G2 Transform: AffineTransform[[1.0, 0.0, 0.0], [0.0, 1.0, 0.0]]
G2 Transform after Trans: AffineTransform[[1.0, 0.0, 37.0], [0.0, 1.0, 35.0]]
G2 Transform after Scale: AffineTransform[[0.010526315789474, 0.0, 37.0], [0.0, 0.0, 35.0]]Basically the scale transformation is screwing things up. When I initially click on the panel and start dragging
y-r.ysometimes equals zero. This makes the y-scale factor zero, which in turn causes the graphics object to have a singular matrix when all is said and done. And I guess java2D doesn't like a singular matrix. The fix would be to make sure x-r.x or y-r.y doesen't equal zero.