如何在JavaFx中重置缩放级别？

我正在用Java制作一张地图，我已经设法创建了放大和缩小的方法，但是我想实现一个功能，在这个功能中我可以将缩放级别重置为默认值。这样地图就被放大了。我曾尝试在使用canvas.zoom（）时更改该因子，但没有效果。有人知道吗

这是我现在的方法。这是我要解决的问题

FXML：

画布：

public class MapCanvas extends Canvas {
    private Model model;
    private Affine trans = new Affine();
    private Point2D max, min, point;
    private double zoomFactor = 1;
    private double initialZoomFactor;
    private double maxZoomFactor = 500000;
    private int counter = 0;
    private static ThemeDB themeDB = new ThemeDB();
    private ArrayList<Way> roadsSmall, roadsLarge, motorways;
    private Way nearest;


    //private long lastZoom;
    //private final int zoomDelay = 100; // this is in milliseconds

    public void init(Model model) throws NonInvertibleTransformException {
        this.model = model;
        pan(-model.min_x,-model.min_y);
        zoom(getWidth()/(model.max_x-model.min_x), new Point2D(0,0));
    }
 

    public void pan(double dx, double dy) throws NonInvertibleTransformException {
        trans.prependTranslation(dx, dy);
        repaint();
    }

    public void zoom(double factor, Point2D center) throws NonInvertibleTransformException {
        if (counter < 1) {
            setStartZoom(factor, center);
        } else {
            if (zoomFactor * factor >= initialZoomFactor && zoomFactor * factor <= maxZoomFactor) {
                trans.prependScale(factor, factor, center);
                zoomFactor *= factor;
            }
        }
        repaint();
    }

    private void setStartZoom (double factor, Point2D center) {
        initialZoomFactor = factor;
        trans.prependScale(factor, factor, center);
        zoomFactor *= factor;
        counter++;
    }

公共类MapCanvas扩展了画布{
私有模型；
私有仿射变换=新仿射（）；
专用点2D最大值、最小值、点；
私有双zoomFactor=1；
私人双首字母；
专用双maxZoomFactor=500000；
专用整数计数器=0；
私有静态主题化B主题化B=新主题化B（）；
私人ArrayList道路、小型道路、高速公路；
最近的私家路；
//私人长焦；
//private final int zoomDelay=100；//以毫秒为单位
public void init（模型）引发不可逆的TransformException{
this.model=模型；
pan（-model.min_x，-model.min_y）；
缩放（getWidth（）/（model.max_x-model.min_x），新点2D（0,0））；
}
public void pan（双dx，双dy）抛出不可逆的TransformException{
翻译前翻译（dx，dy）；
重新油漆（）；
}
公共空心缩放（双因子，点2D中心）引发不可逆的TransformException{
如果（计数器<1）{
设置开始缩放（因子，中心）；
}否则{
如果（zoomFactor*factor>=initialZoomFactor&&zoomFactor*factor与

public void resetZoom（）引发不可逆的TransformException{
点2D p1=反变换（0,0）；
Point2D p2=trans.inverseTransform（getWidth（），getHeight（））；
矩形2D rect=新矩形2D(
Math.min（p1.getX（），p2.getX（）），
Math.min（p1.getY（），p2.getY（）），
max（p1.getX（），p2.getX（））-Math.min（p1.getX（），p2.getX（）），
max（p1.getY（），p2.getY（））-Math.min（p1.getY（），p2.getY（））；
trans.prependScale（initialZoomFactor/zoomFactor，initialZoomFactor/zoomFactor，rect.getMaxX（）-rect.getMinX（）/2，rect.getMaxY（）-rect.getMinY（）/2）；
zoomFactor=初始zoomFactor；
重新油漆（）；
}

通过返回到
initialZoomFactor
，确定部分正在反转缩放

现在您需要确定我不清楚的轴心点。在这里，我尝试使用视图的当前中心，以便画布的图形大致位于视图端口内

如果我不设置轴心点或使用（0，0），它们会完全失去焦点

可用类

package test.mapcanvas；
导入javafx.application.Platform；
导入javafx.geometry.Point2D；
导入javafx.geometry.Rectangle2D；
导入javafx.scene.canvas.canvas；
导入javafx.scene.canvas.GraphicsContext；
导入javafx.scene.image.image；
导入javafx.scene.transform.Affine；
导入javafx.scene.transform.NonInvertibleTransformException；
公共类MapCanvas扩展了画布{
私有仿射变换=新仿射（）；
私有双zoomFactor=1；
私人双首字母；
专用双maxZoomFactor=500000；
专用整数计数器=0；
public void init（）引发NonVertibleTransformException{
缩放（2，新点2D（0,0））；
}
public void pan（双dx，双dy）抛出不可逆的TransformException{
翻译前翻译（dx，dy）；
重新油漆（）；
}
公共空心缩放（双因子，点2D中心）引发不可逆的TransformException{
如果（计数器<1）{
设置开始缩放（因子，中心）；
}否则{
如果（zoomFactor*因子>=初始zoomFactor&&zoomFactor*因子{
试一试{
/*“类”包中需要文件example.jpg*/
Image Image=newimage（getClass（）.getResource（“example.jpg”）.toExternalForm（））；
GraphicsContext g=getGraphicsContext2D（）；
g、 setTransform（trans）；
矩形2D rect=getCurrentViewBounds（）；
g、 clearRect（rect.getMinX（），rect.getMinY（），rect.getWidth（），rect.getHeight（））；
g、 drawImage（图像，0，0）；
}捕获（不可逆转换异常）{
e、 printStackTrace（）；
}
});
}
私有Rectangle2D getCurrentViewBounds（）引发NonInvertibleTransformException{
点2D p1=反变换（0,0）；
Point2D p2=trans.inverseTransform（getWidth（），getHeight（））；
返回新矩形2D(
Math.min（p1.getX（），p2.getX（）），
Math.min（p1.getY（），p2.getY（）），
max（p1.getX（），p2.getX（））-Math.min（p1.getX（），p2.getX（）），
max（p1.getY（），p2.getY（））-Math.min（p1.getY（），p2.getY（））；
}
}
类似于

public void resetZoom（）引发不可逆的TransformException{
点2D p1=反变换（0,0）；
Point2D p2=trans.inverseTransform（getWidth（），getHeight（））；
矩形2D rect=新矩形2D(
Math.min（p1.getX（），p2.getX（）），
Math.min（p1.getY（），p2.getY（）），
max（p1.getX（），p2.getX（））-Math.min（p1.getX（），p2.getX（）），
max（p1.getY（），p2.getY（））-Math.min（p1.getY（），p2.getY（））；
trans.prependScale（initialZoomFactor/zoomFactor，initialZoomFactor/zoomFactor，rect.getMaxX（）-rect.getMinX（）/2，rect.getMaxY（）-rect.getMinY（）/2）；
zoomFactor=初始zoomFactor；
重新油漆（）；
}

通过返回到
initialZoomFactor
，确定部分正在反转缩放

现在您需要确定我不清楚的轴心点。在这里，我尝试使用视图的当前中心，以便画布的图形大致位于视图端口内

他们走了


public class Controller{
    private Model model;
    private Point2D lastMouse;

   ...

    public void init(Model model) throws NonInvertibleTransformException {
        this.model = model;
        canvas.init(model);
    }

  
    @FXML
    private void onMousePressed(MouseEvent e) throws NonInvertibleTransformException {
        lastMouse = new Point2D(e.getX(), e.getY());
        if (e.getButton() == MouseButton.SECONDARY) {
            canvas.drawNearest(lastMouse);
        }
        if (canvas.getNearestName() != null) {
            NearestRoadText.setText(canvas.getNearestName());
        } else {
            NearestRoadText.setText("Unnamed road/path");
        }


    }

    @FXML
    private void repaint() throws NonInvertibleTransformException{
        canvas.repaint();;
    }

    @FXML
    private void TabResetBtnAction() throws NonInvertibleTransformException {
      
        Point2D center = new Point2D(ZoomInBtn.getScene().getWindow().getWidth()/2,ZoomInBtn.getScene().getWindow().getHeight()/2);
        canvas.zoom(1.0 ,center);

    }

    @FXML
    private void ZoomInBtnAction () throws  NonInvertibleTransformException{
        Point2D center = new Point2D(ZoomInBtn.getScene().getWindow().getWidth()/2,ZoomInBtn.getScene().getWindow().getHeight()/2);
        canvas.zoom(1.4888637335882213,center);
    }
    @FXML
    private void ZoomOutBtnAction () throws NonInvertibleTransformException {
        Point2D center = new Point2D(ZoomInBtn.getScene().getWindow().getWidth()/2,ZoomInBtn.getScene().getWindow().getHeight()/2);
        canvas.zoom(0.6716531388604381,center);
    }
   



public class MapCanvas extends Canvas {
    private Model model;
    private Affine trans = new Affine();
    private Point2D max, min, point;
    private double zoomFactor = 1;
    private double initialZoomFactor;
    private double maxZoomFactor = 500000;
    private int counter = 0;
    private static ThemeDB themeDB = new ThemeDB();
    private ArrayList<Way> roadsSmall, roadsLarge, motorways;
    private Way nearest;


    //private long lastZoom;
    //private final int zoomDelay = 100; // this is in milliseconds

    public void init(Model model) throws NonInvertibleTransformException {
        this.model = model;
        pan(-model.min_x,-model.min_y);
        zoom(getWidth()/(model.max_x-model.min_x), new Point2D(0,0));
    }
 

    public void pan(double dx, double dy) throws NonInvertibleTransformException {
        trans.prependTranslation(dx, dy);
        repaint();
    }

    public void zoom(double factor, Point2D center) throws NonInvertibleTransformException {
        if (counter < 1) {
            setStartZoom(factor, center);
        } else {
            if (zoomFactor * factor >= initialZoomFactor && zoomFactor * factor <= maxZoomFactor) {
                trans.prependScale(factor, factor, center);
                zoomFactor *= factor;
            }
        }
        repaint();
    }

    private void setStartZoom (double factor, Point2D center) {
        initialZoomFactor = factor;
        trans.prependScale(factor, factor, center);
        zoomFactor *= factor;
        counter++;
    }


public class MapCanvas extends Canvas {

    // ...

//    public void init(Model model) throws NonInvertibleTransformException {
//        this.model = model;
//        pan(-model.min_x,-model.min_y);
//        zoom(getWidth()/(model.max_x-model.min_x), new Point2D(0,0));
//    }

    public void init(Model model) throws NonInvertibleTransformException {
        this.model = model;
        init();
    }

    private void init() throws NonInvertibleTransformException {
        pan(-model.min_x,-model.min_y);
        zoom(getWidth()/(model.max_x-model.min_x), new Point2D(0,0));
    }

    public void resetZoom() throws NonInvertibleTransformException {
        trans.setToTransform(1, 0, 0, 1, 0, 0);
        init();
    }

    // ...

}