From: Peter Duniho on
George Weis wrote:
> Hi:
> I'm trying to write a simple screen enlarger. The basic
> algorithm is this:
>
> a.) Get current mouse coordinates.
> b.) Take a screen shot using a rectangle consisting of (mouse X,
> mouse Y, 150, 150)
> c.) Create a new scaled image from the screen shot with a height and
> width of 300.
> This should "zoom" 2 X for the portion of the screen the mouse cursor
> is on and show it in a 300 X 300 box
> (the image is drawn on the glass panel on top of the other root
> panels).
>
> This doesn't produce the result I want.
>
> The screen shot looks fine if I take the screen shot 350 pixels away
> from the current mouse coordinates, in other words (mouse X + 350,
> mouse Y + 350, 150, 150).
>
> But, if I try to take the screen shot too close to the current X and
> Y, I get double or triple images of the same area in the image. [...]

Right. If you're old enough, you might remember a common video effect
accomplished by pointing the video camera at a monitor showing the image
captured by the video camera. They don't use it much these days, but it
was all the rage in the 70's. :)

Anyway, the problem is that you are capturing the image from the screen.
So of course, once you display the updated scaled image on the screen,
the next capture includes the scaled image, so that scaled portion is
scaled again and presented again. Every time your code recaptures the
display, this occurs and you get a sort of "tunnel vision" effect.

Depending on what you're trying to do, it's either simple to fix or not.
If you're trying to implement a completely general "magnifying" tool
that will scale arbitrary regions of the computer display, you're in for
an uphill battle, especially in Java. You need more control over the
rendering process than simply doing a screen capture, so that when you
obtain an image to be scaled, it's the _original_ image, not one that
includes your scaling.

On the other hand, if you're just trying to scale stuff in your own Java
application, that's a lot simpler if you're willing to write a custom
component into which the drawing happens. In your component's paint()
method, you can use the transform features of the Graphics instance to
scale whatever drawing you do in the component.

Even there, you may run into difficulty if you want to scale not only
your own drawing, but also how built-in Java components draw. It's
possible for lightweight controls you might be able to intercept the
rendering process early enough to scale the output, but for controls
that are based on platform/OS, forcing those to scale will be trickier,
if possible at all.

Pete