java - 在 Applet 上使用 AWT 放大/缩小图表

Question

我是 java 新手......正在编写一段小程序代码......因为我仍在了解 OOP 概念和 java 理解，并且需要开发下面提到的功能。我的代码片段是这样工作的:首先，它从 HTML 标签中读取所有参数并将其存储在全局变量中。然后它向 CGI 发送查询以读取图形数据。然后它转换数据用于绘图并绘制图表。用户可以选择 1-24 小时。基于选择的图表将通过仅绘制选定的数据来绘制。每 30 秒它向 CGI 发送一次查询以收集数据。

代码使用以下库并使用 java 1.5 环境，由于嵌入要求，我无法更改它:

我需要通过实现放大缩小功能来增强它，并且 x-y 轴粒度随着放大而变化。我担心的是如何做到这一点？我知道这是令人沮丧的问题...但我来这里是为了从 java 专家那里获得建议，以便我可以快速学习和实现这些东西。

 import java.awt.*;
import java.awt.image.*;
import java.awt.event.*;
import java.applet.*;
import java.net.*;
import java.io.*;
import java.util.*;
import java.text.*;

/******************************************************************************
*
* Class - Graph
*
*       This is the entry point.
*   This class extends Applet class and implements Runnable.
*
*****************************************************************************/

public class GraphPerf extends Applet implements Runnable,ItemListener,MouseMotionListener

{
//Global variables
int MAX_DATA_X  ;
int    SIZE_X= 480;
int    SIZE_Y= 250;
int    SIZE_Y1= 240;
int MIN_ERROR = -1;
int MAX_LOG10_ERROR_COUNT = 1001;
int MAX_ERROR_COUNT = 101;
int SIZE_Y_EXTENDED_BOTTOM = 20;
int MAX_DISP_PARMS = 16;
int MAX_NUM_INTERVELL_PER_DAY = 96;
int MAX_DISP_PARMS_STD = 7;
int refreshTime;
String  serverAddress,hostAddr;
Color   plotColor1,plotColor8;

float graphData[][];
float graph_data_rf_east,graph_data_rf_west;

int xOffset = 50;
int yOffset = 40;

int Y1_MAX_VALUE = 100;
int Y2_MAX_VALUE = 3;

float RANGE2;

Thread  graphThread;
Image   Buffer;
Graphics plot;

Choice  timeChoice, modeChoice, seloptChoice;
int     duration=1, viewMode=1, line_type = 0,viewOpt = 1;

Label valueLabel1, valueLabel2,valueLabel3,valueLabel4,valueLabel5;
boolean GraphBottomExtendFlag=true;


/******************************************************************************
*
* method - init
*
*       This is the method called first after applet loaded in to browser.
*   This function reads configurable parameters from HTML tag and updates
*   global variables.
*****************************************************************************/

public void init()
{

MAX_DATA_X = 672;//Integer.parseInt(getParameter("max_data_x"));
//refreshTime       = 30;//Integer.parseInt(getParameter("refresh_sec"));
/*URL url = getDocumentBase();
String host = url.getHost();
try
{
    InetAddress addr =  InetAddress.getByName(host);
    hostAddr=addr.getHostAddress();
}catch (UnknownHostException ex) {
    ex.printStackTrace();
}
 */
//serverAddress     = new String ( getParameter("access_str")+ hostAddr + getParameter("data_server"));
graphData       = new float[MAX_DISP_PARMS][MAX_DATA_X+1];
/*initialize the array with -1 not with 0(0 also valid for graph data)  */
int i =0,j = 0;
for( j=0; j<MAX_DISP_PARMS; j++)
{
    for( i=0; i<MAX_DATA_X+1; i++)
    {
        graphData[j][i] = -1;
    }
}
graph_data_rf_east = -1;
graph_data_rf_west = -1;

plotColor1      = Color.orange;
plotColor2      = Color.black;
plotColor8      = Color.red;
plotColor9      = Color.green;

setBackground(Color.white);
setLayout(null);

timeChoice   = new Choice();
timeChoice.add("1");
timeChoice.add("2");
timeChoice.add("3");
timeChoice.add("4");
timeChoice.add("5");
timeChoice.add("6");
timeChoice.add("7");
add(timeChoice);

timeChoice.setBounds(190,340,40,23);
timeChoice.addItemListener(this);

Label timeLabel1 = new Label("View graph for last");
Label timeLabel2 = new Label("day(s)");
add(timeLabel1);
timeLabel1.setBounds(xOffset+30,340,160,23);

add(timeLabel2);
timeLabel2.setBounds(240,340,50,23);

valueLabel1 = new Label();
add(valueLabel1);
valueLabel1.setBounds(300,340,50,23);
valueLabel2 = new Label();
add(valueLabel2);
valueLabel2.setBounds(370,340,70,23);
valueLabel3 = new Label();
add(valueLabel3);
valueLabel3.setBounds(440,340,70,23);
valueLabel4 = new Label();
add(valueLabel4);
valueLabel4.setBounds(500,340,70,23);
valueLabel5 = new Label();
add(valueLabel5);
valueLabel5.setBounds(370,370,80,25);
modeChoice = new Choice();
modeChoice.add("East");
modeChoice.add("West");
/* Display this only for Protected and East-West Mode */
if(2/*Integer.parseInt(getParameter("mode"))*/ == 2)
{
    add(modeChoice);
}
else
{
    viewOpt = 1;
}
modeChoice.setBounds(xOffset+SIZE_X-55, 0, 60, 25);
modeChoice.addItemListener(this);
addMouseMotionListener(this);
}

public void start()
{
graphThread = new Thread(this);
graphThread.start();
}

public void stop()
{
graphThread = null;
}

/******************************************************************************
*
*   This method will be called after starting the thread. This is a
*   infinite loop which will call query method for every 30 sec to read data
*   from CGI. Then it plots graph by calling plotGraph method
*   the thread.
*****************************************************************************/

public void run()
{
/*while (false)
{
    try
    {//getData(serverAddress);
        int sizeY = SIZE_Y;
        if(GraphBottomExtendFlag)
        {
            sizeY += SIZE_Y_EXTENDED_BOTTOM;
        }
        repaint(xOffset+1,yOffset+1,SIZE_X-1,sizeY-1);
        //graphThread.sleep(refreshTime*1000);
    }catch (Exception e) { System.out.println(e); }
}*/
}

/******************************************************************************
*
* method - paint
*
*       This method displays the graph plotted by plotGraph method
*   in the screen. Then it draws axis for the graph
*
*****************************************************************************/

public void paint(Graphics g1)
{
int sizeY = SIZE_Y;
/*If  Graph Bottom is to be Etended
 *soo that zero is displayed properly
 */
if(GraphBottomExtendFlag)
{
    sizeY += SIZE_Y_EXTENDED_BOTTOM;
}

if( duration <= 5 )
{
    Buffer = createImage(SIZE_X, sizeY);
    plot = Buffer.getGraphics();
    plotGraph(plot);
    g1.drawImage (Buffer,xOffset,yOffset,this);
}
else
{
    Buffer = createImage(MAX_DATA_X*duration/7,sizeY);
    plot = Buffer.getGraphics();
    plotGraph(plot);
    g1.drawImage (Buffer,xOffset,yOffset,SIZE_X,sizeY,this);
}

g1.setColor(Color.black);

g1.drawRect(70,150,270,80);
/*Dram Graph boarder */
g1.drawRect(xOffset,yOffset,SIZE_X,sizeY);
g1.drawRect(xOffset-1,yOffset-1,SIZE_X+2,sizeY+2);

      /*Plot X axis*/
int max_x_marks = 8;
int temp = 1,cnt_graph = 0;
int float_temp,float_temp2;

/*max 8 plots on x axis*/
for(int x=max_x_marks; x>0; x--)
{

    float_temp = (int)((MAX_NUM_INTERVELL_PER_DAY*duration)/max_x_marks)*((max_x_marks+1)-x);
    float_temp2 = SIZE_X-(60*cnt_graph);

    g1.drawString(String.valueOf(float_temp),(float_temp2-20) ,SIZE_Y+yOffset+35);
    cnt_graph++;
}

/*Plot Y1 AXIS*/
temp = Y1_MAX_VALUE;
for(int x = 0; x <= SIZE_Y; x+= 25)
{
    g1.drawString(String.valueOf(temp), 25, x + yOffset+10);
    temp -= (Y1_MAX_VALUE - 0)/10;
}
temp = 1000;
 /*Plot Y2 AXIS*/
int index_log = 1;
for(int x = 0; x <= SIZE_Y1; x+= 80)
{
    if(x== 240)
    index_log--;
    if(temp>=1)
    {
        g1.drawString(String.valueOf(temp), 550, x+yOffset+8-index_log);
        g1.drawLine(530,x+yOffset+5-index_log, 540, x+yOffset+5-index_log);
    }
    temp = temp/10;
}
Font thisFont = new Font("Times New Roman", Font.BOLD, 14);
g1.setFont(thisFont);
g1.drawString("Y2", 550, 160);
g1.drawString("Y1",5, 160);

}
/******************************************************************************
 *
 * method - plotGraph
 *
 *      Depending on the mode, "East", "West" or "Combined", it plots
 *  single or two graphs in the same applet.
 *
 *  Inputs :
 *          g - Graphics object
 *****************************************************************************/

public void plotGraph(Graphics g)
{
g.setColor(new Color(255,255,220));

/*If  Error-Sec-Count Graph
 *Then extend the lower portion
 *soo that zero is displayed properly
 */
if(GraphBottomExtendFlag)
{
    g.fillRect(0,0,MAX_DATA_X,SIZE_Y + SIZE_Y_EXTENDED_BOTTOM);
}
else
{
    g.fillRect(0,0,MAX_DATA_X,SIZE_Y);
}


switch(viewMode)
{
    case 1 :
        plot1(g);
        plot_timeelapsed_east(g);
        break;

    case 2 :
        plot8(g);
        plot_timeelapsed_west(g);
        break;
}
}
/******************************************************************************
 *
 * method - plot1
 *
 *      This method uses graphData[0][] global variable and plots series of lines
 *  in the applet
 *
 *  Inputs :
 *          g - Graphics object
 *****************************************************************************/

 void plot1(Graphics g)
 {
int end = MAX_DATA_X;
int localPlotBuffer[];

localPlotBuffer = new int[2];

g.setColor(plotColor1);
if(duration > 5)
{
    for(int x=(duration*MAX_NUM_INTERVELL_PER_DAY); x > 0 ; x--)
    {
        /*if data is valid data then plot else ignore*/
        if((graphData[0][end]>MIN_ERROR)&&(graphData[0][end-1]<MAX_LOG10_ERROR_COUNT)&&(graphData[0][end-1]>MIN_ERROR)&&(graphData[0][end]<MAX_LOG10_ERROR_COUNT))
        {
            /*if data present is 0, log10(0) is not define so then plot this graph in normal scale */
            if(graphData[0][end] == 0)
            {
                localPlotBuffer[0] = (int)((float)(SIZE_Y )*(float)(1 - (float)graphData[0][end]/(float)Y1_MAX_VALUE)) ;
            }
            else
            {
                localPlotBuffer[0] = (int)((float)(SIZE_Y1 )*(float)(1 - (float)Math.log10(graphData[0][end])/(float)Y2_MAX_VALUE));
            }
            /*if data present is 0, log10(0) is not define so then plot this graph in normal scale */
            if(graphData[0][end-1] == 0)
            {
                localPlotBuffer[1] = (int)((float)(SIZE_Y )*(float)(1 - (float)graphData[0][end-1]/(float)Y1_MAX_VALUE)) ;
            }
            else
            {
                localPlotBuffer[1] = (int)((float)(SIZE_Y1 )*(float)(1 - (float)Math.log10(graphData[0][end-1])/(float)Y2_MAX_VALUE));
            }
            g.drawLine(x-1,(localPlotBuffer[0]+5), x-2,(localPlotBuffer[1]+5));
            g.drawLine(x,(localPlotBuffer[0]+5), x-1,(localPlotBuffer[1]+5));
        }
        end--;
    }
}
else
{
    float temp = SIZE_X;
    for(int x=(duration*MAX_NUM_INTERVELL_PER_DAY) ; x > 0 ; x--)
    {
        float LocalTemp1 = temp;
        float LocalTemp2 = (int)(temp-(double)5/(double)duration);
        /*Normalise the pixcel positions */
        /*Normalise the pixcel positions */
        if(duration == 1)
        {
            if(LocalTemp1>(SIZE_X-3))
            LocalTemp1 = SIZE_X;
            if(LocalTemp2>(SIZE_X-3))
            LocalTemp2 = SIZE_X;
        }
        /*Normalise the pixcel positions */
        else if(duration == 2)
        {
            if(LocalTemp1>(SIZE_X-2))
            LocalTemp1 = SIZE_X;
            if(LocalTemp2>(SIZE_X-2))
            LocalTemp2 = SIZE_X;
        }
        /*Normalise the pixcel positions */
        else if(duration == 3)
        {
            if(LocalTemp1>(SIZE_X-1))
            LocalTemp1 = SIZE_X;
            if(LocalTemp2>(SIZE_X-1))
            LocalTemp2 = SIZE_X;
        }
        /*if data is valid data then plot else ignore*/
        if((graphData[0][end]>MIN_ERROR)&&(graphData[0][end-1]<MAX_LOG10_ERROR_COUNT)&&(graphData[0][end-1]>MIN_ERROR)&&(graphData[0][end]<MAX_LOG10_ERROR_COUNT))
        {
            /*if data present is 0, log10(0) is not define so then plot this graph in normal scale */
            if(graphData[0][end] == 0)
            {
                localPlotBuffer[0] = (int)((float)(SIZE_Y )*(float)(1 - (float)graphData[0][end]/(float)Y1_MAX_VALUE)) ;
            }
            else
            {
                localPlotBuffer[0] = (int)((float)(SIZE_Y1 )*(float)(1 - (float)Math.log10(graphData[0][end])/(float)Y2_MAX_VALUE));
            }
            /*if data present is 0, log10(0) is not define so then plot this graph in normal scale */
            if(graphData[0][end-1] == 0)
            {
                localPlotBuffer[1] = (int)((float)(SIZE_Y )*(float)(1 - (float)graphData[0][end-1]/(float)Y1_MAX_VALUE)) ;
            }
            else
            {
                localPlotBuffer[1] = (int)((float)(SIZE_Y1 )*(float)(1 - (float)Math.log10(graphData[0][end-1])/(float)Y2_MAX_VALUE));
            }
            g.drawLine((int)LocalTemp1,(localPlotBuffer[0]+5), (int)LocalTemp2,(localPlotBuffer[1]+5));
        }
        temp-=(double)5/(double)duration;
        end--;
    }
}
}

/******************************************************************************
*
* method - plot8
*
*       This method uses graphData[7][] global variable and plots series of lines
*   in the applet
*
*   Inputs :
*           g - Graphics object
*****************************************************************************/

void plot8(Graphics g)
{
int end = MAX_DATA_X;
int localPlotBuffer[];
localPlotBuffer = new int[2];

g.setColor(plotColor1);

if(duration > 5)
{
    for(int x=(duration*MAX_NUM_INTERVELL_PER_DAY); x > 0 ;x-- )
    {
        /*if data is valid data then plot else ignore*/
        if((graphData[8][end]>MIN_ERROR)&&(graphData[8][end-1]<MAX_LOG10_ERROR_COUNT)&&(graphData[8][end-1]>MIN_ERROR)&&(graphData[8][end]<MAX_LOG10_ERROR_COUNT))
        {
            /*if data present is 0, log10(0) is not define so then plot this graph in normal scale */
            if(graphData[8][end] == 0)
            {
                localPlotBuffer[0] = (int)((float)(SIZE_Y )*(float)(1 - (float)graphData[8][end]/(float)Y1_MAX_VALUE)) ;
            }
            else
            {
                localPlotBuffer[0] = (int)((float)(SIZE_Y1 )*(float)(1 - (float)Math.log10(graphData[8][end])/(float)Y2_MAX_VALUE));
            }
            /*if data present is 0, log10(0) is not define so then plot this graph in normal scale */
            if(graphData[8][end-1]== 0)
            {
                localPlotBuffer[1] = (int)((float)(SIZE_Y )*(float)(1 - (float)graphData[8][end-1]/(float)Y1_MAX_VALUE)) ;
            }
            else
            {
                localPlotBuffer[1] = (int)((float)(SIZE_Y1 )*(float)(1 - (float)Math.log10(graphData[8][end-1])/(float)Y2_MAX_VALUE));
            }
            g.drawLine(x-1,(localPlotBuffer[0]+5), x-2,(localPlotBuffer[1]+5));
            g.drawLine(x,(localPlotBuffer[0]+5), x-1,(localPlotBuffer[1]+5));
        }
        end--;
    }
}
else
{
    float temp = SIZE_X;
    for(int x=(duration*MAX_NUM_INTERVELL_PER_DAY) ; x > 0 ; x--)
    {
        float LocalTemp1 = temp;
        float LocalTemp2 = (int)(temp-(double)5/(double)duration);
        /*Normalise the pixcel positions */
        if(duration == 1)
        {
            if(LocalTemp1>(SIZE_X-3))
            LocalTemp1 = SIZE_X;
            if(LocalTemp2>(SIZE_X-3))
            LocalTemp2 = SIZE_X;
        }
        /*Normalise the pixcel positions */
        else if(duration == 2)
        {
            if(LocalTemp1>(SIZE_X-2))
            LocalTemp1 = SIZE_X;
            if(LocalTemp2>(SIZE_X-2))
            LocalTemp2 = SIZE_X;
        }
        /*Normalise the pixcel positions */
        else if(duration == 3)
        {
            if(LocalTemp1>(SIZE_X-1))
            LocalTemp1 = SIZE_X;
            if(LocalTemp2>(SIZE_X-1))
            LocalTemp2 = SIZE_X;
        }
        /*if data is valid data then plot else ignore*/
        if((graphData[8][end]>MIN_ERROR)&&(graphData[8][end-1]<MAX_LOG10_ERROR_COUNT)&&(graphData[8][end-1]>MIN_ERROR)&&(graphData[8][end]<MAX_LOG10_ERROR_COUNT))
        {
            /*if data present is 0, log10(0) is not define so then plot this graph in normal scale */
            if(graphData[8][end] == 0)
            {
                localPlotBuffer[0] = (int)((float)(SIZE_Y )*(float)(1 - (float)graphData[8][end]/(float)Y1_MAX_VALUE)) ;
            }
            else
            {
                localPlotBuffer[0] = (int)((float)(SIZE_Y1 )*(float)(1 - (float)Math.log10(graphData[8][end])/(float)Y2_MAX_VALUE));
            }
            /*if data present is 0, log10(0) is not define so then plot this graph in normal scale */
            if(graphData[8][end-1]== 0)
            {
                localPlotBuffer[1] = (int)((float)(SIZE_Y )*(float)(1 - (float)graphData[8][end-1]/(float)Y1_MAX_VALUE)) ;
            }
            else
            {
                localPlotBuffer[1] = (int)((float)(SIZE_Y1 )*(float)(1 - (float)Math.log10(graphData[8][end-1])/(float)Y2_MAX_VALUE));
            }
            g.drawLine((int)LocalTemp1,(localPlotBuffer[0]+5), (int)LocalTemp2,(localPlotBuffer[1]+5));
        }
        temp-=(double)5/(double)duration;
        end--;
    }
}
}

/******************************************************************************
 *
 * method - plot_timeelapsed_east
 *
 *      This method uses graph_data_rf_east global variable and plots series of lines
 *  in the applet
*****************************************************************************/

void plot_timeelapsed_east(Graphics g)
{
int end = MAX_DATA_X;
int localPlotBuffer[];
int x= 0;

localPlotBuffer = new int[2];
x= (duration*MAX_NUM_INTERVELL_PER_DAY);
g.setColor(plotColor9);
/*if data is valid data then plot else ignore*/
if((graph_data_rf_east>0)&&(graph_data_rf_east<MAX_LOG10_ERROR_COUNT))
{
    localPlotBuffer[0] = (int)((float)(SIZE_Y1 )*(float)(1 - (float)Math.log10(graph_data_rf_east)/(float)Y2_MAX_VALUE));
    if(duration>5)
    g.drawLine(x-1,SIZE_Y+5, x-2,(localPlotBuffer[0]+5));
    else
    g.drawLine(SIZE_X,SIZE_Y+5, 474+duration,(localPlotBuffer[0]+5));
}
  }/*End for plot_timeelapsed_east() */

 /******************************************************************************
 *
 * method - plot_timeelapsed_west
 *
 *      This method uses graph_data_rf_east global variable and plots series of lines
 *  in the applet
 *****************************************************************************/

void plot_timeelapsed_west(Graphics g)
{
int end = MAX_DATA_X;
int localPlotBuffer[];
int x= 0;

localPlotBuffer = new int[2];
x= (duration*MAX_NUM_INTERVELL_PER_DAY);

g.setColor(plotColor9);
/*if data is valid data then plot else ignore*/
if((graph_data_rf_east>MIN_ERROR)&&(graph_data_rf_east<MAX_LOG10_ERROR_COUNT))
{
    localPlotBuffer[0] = (int)((float)(SIZE_Y1 )*(float)(1 - (float)Math.log10(graph_data_rf_west)/(float)Y2_MAX_VALUE));
    if(duration>5)
    g.drawLine(x-1,SIZE_Y+5, x-2,(localPlotBuffer[0]+5));
    else
    g.drawLine(SIZE_X,SIZE_Y+5, 474+duration,(localPlotBuffer[0]+5));
}
}

/******************************************************************************
*
* method - getData
*
*       This method sends query to CGI to collect data. Then it converts the
*   data for applet area then updates global variable.
*
*   Inputs :
*           serverAddress - server CGI path
*****************************************************************************/

public void getData(String serverAddress)
{

URL addr;
BufferedReader in;
String inputLine;
int count = 0;
int i=0,j = 0;
try
{
    addr = new URL(serverAddress);
    URLConnection connection = addr.openConnection();
    in = new BufferedReader(new InputStreamReader(addr.openStream()));
    /*Read data for first link */
    for( j=0; j<MAX_DISP_PARMS_STD; j++)
    {
        for( i=0; i<MAX_DATA_X+1; i++)
        {
            inputLine = in.readLine();
            graphData[j][i] = Integer.parseInt(inputLine);
        }
    }
    for( i=0; i<MAX_DATA_X; i++)
    {
        inputLine = in.readLine();
        graphData[7][i] = Integer.parseInt(inputLine);
        if(graphData[7][i] == 1)
        graphData[7][i] = 10;
    }
    inputLine = in.readLine();
    graph_data_rf_east = Integer.parseInt(inputLine);
    /*Reading data for second link */
    if(Integer.parseInt(getParameter("mode")) == 2)
    {
        for( j=8; j<15; j++)
        {
            for( i=0; i<MAX_DATA_X+1; i++)
            {
                inputLine = in.readLine();
                graphData[j][i] = Integer.parseInt(inputLine);
            }

        }
        for( i=0; i<MAX_DATA_X; i++)
        {
            inputLine = in.readLine();
            graphData[15][i] = Integer.parseInt(inputLine);
            if(graphData[15][i] == 1)
            graphData[15][i] = 10;
        }
        inputLine = in.readLine();
        graph_data_rf_west = Integer.parseInt(inputLine);
    }
    in.close();
}catch (Exception e) { System.out.println("Server Data Read Error:"+e); }
}

/******************************************************************************
 *
 * method - itemStateChanged
 *
 *      This method will be called whenever event occured on this choice.
 *  it read the current status and changes scale accordingly.
 * *****************************************************************************/

public void itemStateChanged(ItemEvent evt)
{
if( evt.getSource() == timeChoice )
    duration = Integer.parseInt(timeChoice.getSelectedItem());
else
    viewMode = modeChoice.getSelectedIndex()+1;
repaint();
}
/******************************************************************************
 *
 * method - mouseMoved
 *
 *      This method will be called whenever mouse cursor is moved over the
 *  applet. Depending on the cursor position, it will display Actual
 *  X and Y values of the graph.
 *****************************************************************************/

public void mouseMoved(MouseEvent evt)
{
    int x = evt.getX()-xOffset;
    int y = evt.getY()-yOffset-5;

    int a = evt.getX();
    int b = evt.getY();

    int duration = Integer.parseInt(timeChoice.getSelectedItem());
    if( (x>=0) && (x<=SIZE_X) && (y>=0) && (y<=SIZE_Y) )
    {
        valueLabel1.setText("X ");
        valueLabel2.setText("Y1 ");
        valueLabel3.setText("Y2 ");
        try
        {
            int x_max_value = ((SIZE_X*duration)/5);
            int x1  = (int)((float)((float)((float)(SIZE_X*duration))/5)  * ((float)((float)(SIZE_X - x))/((float)SIZE_X)));
            /*For Durations less than 16 scale starts with 1*/
            int y1  = (int)((float)Y1_MAX_VALUE  * (((float)SIZE_Y - (float)y)/((float)SIZE_Y)));
            int y2 = (int) Math.pow(10,((float)(3 * ((float)(1 - (float)y/((float)SIZE_Y1))))));
            valueLabel1.setText("X="+x1);
            valueLabel2.setText("X pix="+a);
            valueLabel3.setText("Y="+y1);
            valueLabel4.setText("Y pix="+b);
            valueLabel5.setText("Y2="+y2);
        }
        catch(Exception e) {System.out.println("Mouse Moved Error" + e);}
    }
    else
    {
        valueLabel1.setText(" ");
        valueLabel2.setText(" ");
        valueLabel3.setText(" ");

    }
}
public void mouseDragged(MouseEvent evt) { }
}

Answer 1

有很多方法可以做到这一点。这里有两个:

1. 您可以简单地缩放值:将每个坐标乘以缩放系数。

2. 使用 Java2D 和 AffineTransform:

   AffineTransform transformer = new AffineTransform();
   transformer.scale(zoom, zoom);
   Graphics2D g2d = (Graphics2D)g;
   g2d.setTransform(transformer);
   // draw to g2d.
   

[编辑]如果您想自己完成所有事情，请参阅此页面以刷新基本线性代数:2D Transformations

不要介意顶部的 3D 示例；页面的其余部分是关于 2D 的。