Paint Component using scaled Graphics with TiledImage

Question

Hello,
I am in the process of adding minor image manipulation in an application I created. I have paint overridden on the component that displays the image and in that component I am scaling the graphics to a representation of the image at 300 dpi versus the screen resolution. The image is a TiledImage which gave me pretty good performance benefits when I was painting at screen resolution. Now I want to know if there is something I can do to the tiles to get the performance benefit back. I understand this
may not be possible because the entire image displays at once with the scaled graphics instance.
Here is a copy of my paint method:
public void paintComponent(Graphics gc) {
          Graphics2D g = (Graphics2D) gc;
          g.scale(scale, scale);
          Rectangle rect = this.getBounds();
          rect.width *= (1/scale);
          rect.height *= (1/scale);
          if ((viewerWidth != rect.width) || (viewerHeight != rect.height)) {
               viewerWidth = rect.width;
               viewerHeight = rect.height;
          setDoubleBuffered(false);
          g.setColor(Color.BLACK);
          g.fillRect(0, 0, viewerWidth, viewerHeight);
          if (displayImage == null)     return;
          int ti = 0, tj = 0;
          Rectangle bounds = new Rectangle(0, 0, rect.width, rect.height);
          bounds.translate(-panX, -panY);
          int leftIndex = displayImage.XToTileX(bounds.x);
          if (leftIndex < ImageManip.getMinTileIndexX())
               leftIndex = ImageManip.getMinTileIndexX();
          if (leftIndex > ImageManip.getMaxTileIndexX())
               leftIndex = ImageManip.getMaxTileIndexX();
          int rightIndex = displayImage.XToTileX(bounds.x + bounds.width - 1);
          if (rightIndex < ImageManip.getMinTileIndexX())
               rightIndex = ImageManip.getMinTileIndexX();
          if (rightIndex > ImageManip.getMaxTileIndexX())
               rightIndex = ImageManip.getMaxTileIndexX();
          int topIndex = displayImage.YToTileY(bounds.y);
          if (topIndex < ImageManip.getMinTileIndexY())
               topIndex = ImageManip.getMinTileIndexY();
          if (topIndex > ImageManip.getMaxTileIndexY())
               topIndex = ImageManip.getMaxTileIndexY();
          int bottomIndex = displayImage.YToTileY(bounds.y + bounds.height - 1);
          if (bottomIndex < ImageManip.getMinTileIndexY())
               bottomIndex = ImageManip.getMinTileIndexY();
          if (bottomIndex > ImageManip.getMaxTileIndexY())
               bottomIndex = ImageManip.getMaxTileIndexY();
          for (tj = topIndex; tj <= bottomIndex; tj++) {
               for (ti = leftIndex; ti <= rightIndex; ti++) {
                    Raster tile = displayImage.getTile(ti, tj);
                    DataBuffer dataBuffer = tile.getDataBuffer();
                    WritableRaster wr = Raster.createWritableRaster(sampleModel,
                              dataBuffer, new Point(0, 0));
                    BufferedImage bi = new BufferedImage(colorModel, wr,
                              colorModel.isAlphaPremultiplied(), null);
                    if (bi == null) continue;
                    int xInTile = displayImage.tileXToX(ti);
                    int yInTile = displayImage.tileYToY(tj);
                    atx = AffineTransform.getTranslateInstance(
                              xInTile + panX, yInTile + panY);
                    g.drawRenderedImage(bi, atx);
          imageDrawn = true;
          if (cropOn) {
               Rectangle cropRect = getDimensions();
               if (cropRect == null) return;
               g.setColor(Color.BLACK);
               g.drawRect(cropRect.x, cropRect.y, cropRect.width, cropRect.height);
               g.setComposite(makeComposite(0.5f));
               g.fillRect(0, 0, cropRect.x, cropRect.y);
               g.fillRect(cropRect.x, 0, viewerWidth - cropRect.x, cropRect.y);
               g.fillRect(0, cropRect.y, cropRect.x, viewerHeight - cropRect.y);
               g.fillRect(cropRect.x + cropRect.width, cropRect.y,
                         viewerWidth - cropRect.x, viewerHeight - cropRect.y);
               g.fillRect(cropRect.x, cropRect.y + cropRect.height, cropRect.width,
                         viewerHeight - cropRect.y);
          g.dispose();
          if (((double)GarbageCollection.getFreeMem() /
                    (double)GarbageCollection.getRuntimeMem()) > 0.7d) {
               System.out.println("Memory Usage: " +
                         (int)(((double)GarbageCollection.getFreeMem() /
                         (double)GarbageCollection.getRuntimeMem()) * 100) + "%");
               System.out.println("Requesting garbage collection.");
               GarbageCollection.runGc();
          setDoubleBuffered(true);
Thank you in advance for support

Answer 1

I moved the sizing out of the paint method and put in a component listener. I am still getting approx. the
same performance. Possibly because I am trying to do too much. I have a mouse listener that allows
the user to pan the image. I also have crop, rotate, shear, and flip methods. The main problem I think
is when I change graphics to scale at (72d / 300d) which puts the display comparable to 300 dpi.
My main reason for this was to allow zooming for the user. Am I overtasking the graphics object by
doing this?