Graphics2D transformation result does not match manual transformation
===

I am using Java's Graphics2D to draw on a component using AffineTransform's to manipulate my drawing.
Graphics2D offers an method transform for this, which takes an AffineTransform.

Sometimes I need to manipulate a point manually without using the builtin-transformation.
But when I try to transform a point using the same transformation I gave to Graphics2D.transform sometimes the resulting point is not the same.

The following code reproduces the problem (It's Scala code, but I think you can imagine the Java code.):

       var transformationMatrix = new AffineTransform()
       /*
        * transformationMatrix is modified throughout the program
        * ...
        */
       override def paintComponent(g: Graphics2D) = {
          super.paintComponent(g)
          /* 1. transform using graphics transform */
          g.transform(transformationMatrix)
          g.setColor(Color.RED)
          g.fill(new Rectangle(0, 0, 1, 1))
          /* 2. transform point manually */
          g.setTransform(new AffineTransform) // reset transformation to standard
          val p0 = new Point(0, 0)
          val pDest = new Point()
          transformationMatrix.transform(p0, pDest)
          g.setColor(Color.BLUE)
          g.fill(new Rectangle(pDest.x, pDest.y, 1, 1)
       }

**Expected behaviour**

The blue rectangle (manually calculated) overdraws the red one (calculated by transform).

**Experienced behaviour**

![The blue rectangle has an offset of 1][1]

I admit that my transformationMatrix is not really integer, but that should'nt be the problem, should it?

       affineTransform = 1.1, 0.0, 520.55
                         0.0, 1.1, 182.54999999999995
                         0.0, 0.0,    1.0


Is this a bug or am I missing some deep insight?


  [1]: http://i.stack.imgur.com/RmEnU.png