Java SnapshotParameters类代码示例

import javafx.scene.SnapshotParameters; //导入依赖的package包/类
/**
 * Takes a snapshot of a canvas and saves it to the destination.
 * <p>
 * After the screenshot is taken it shows a dialogue to the user indicating the location of the snapshot.
 *
 * @param canvas a JavaFX {@link Canvas} object
 * @return the destination of the screenshot
 */
public String take(final Canvas canvas) {
    final WritableImage writableImage = new WritableImage((int) canvas.getWidth(), (int) canvas.getHeight());
    final WritableImage snapshot = canvas.snapshot(new SnapshotParameters(), writableImage);

    try {
        ImageIO.write(SwingFXUtils.fromFXImage(snapshot, null), FILE_FORMAT, destination);
        new InformationDialogue(
                "Snapshot taken",
                "You can find your snapshot here: " + destination.getAbsolutePath()
        ).show();
    } catch (final IOException e) {
        LOGGER.error("Snapshot could not be taken.", e);
        new ErrorDialogue(e).show();
    }

    return destination.getAbsolutePath();
}
 

import javafx.scene.SnapshotParameters; //导入依赖的package包/类
/**
 * Converts charts to Java {@link WritableImage}s
 *
 * @param charts the charts to be converted to {@link WritableImage}s
 * @return a {@link List} of {@link WritableImage}s
 */
private List<WritableImage> chartsToImages(List<Chart> charts) {
    List<WritableImage> chartImages = new ArrayList<>();

    // Scaling the chart image gives it a higher resolution
    // which results in a better image quality when the
    // image is exported to the pdf
    SnapshotParameters snapshotParameters = new SnapshotParameters();
    snapshotParameters.setTransform(new Scale(2, 2));

    for (Chart chart : charts) {
        chartImages.add(chart.snapshot(snapshotParameters, null));
    }

    return  chartImages;
}
 

import javafx.scene.SnapshotParameters; //导入依赖的package包/类
/**
 * Kirajzol egy TrainPartot a GraphicsContextre, elforgatva a sebessege iranyaba.
 */
private void drawSprite(TrainPart trainPart, Image sprite) {
    ImageView iv = new ImageView(sprite);
    Coordinate dir = trainPart.getDirection();
    // Az elforgatas szoget az (1,0) vektorhoz viszonyitjuk, mert vizszintesen es jobbra allva taroljuk a spriteokat
    Coordinate ref = new Coordinate(1, 0);
    double deg = Math.toDegrees(Math.acos(Coordinate.dot(dir, ref)));
    // Ha az elforgatas szoge > 180 fok, akkor is jo iranyba forgassuk
    if (Coordinate.cross(dir, ref) > 0) {
        deg = 360 - deg;
    }
    iv.setRotate(deg);
    SnapshotParameters param = new SnapshotParameters();
    param.setFill(Color.TRANSPARENT);
    Image rotatedImage = iv.snapshot(param, null);
    graphicsContext.drawImage(rotatedImage, trainPart.getPos().getX() - rotatedImage.getWidth() / 2, trainPart.getPos().getY() - rotatedImage.getHeight() / 2);
}
 

import javafx.scene.SnapshotParameters; //导入依赖的package包/类
private void updatePlaceholder(Node newView) {
    if (view.getWidth() > 0 && view.getHeight() > 0) {
        SnapshotParameters parameters = new SnapshotParameters();
        parameters.setFill(Color.TRANSPARENT);
        Image placeholderImage = view.snapshot(parameters,
            new WritableImage((int) view.getWidth(), (int) view.getHeight()));
        placeholder.setImage(placeholderImage);
        placeholder.setFitWidth(placeholderImage.getWidth());
        placeholder.setFitHeight(placeholderImage.getHeight());
    } else {
        placeholder.setImage(null);
    }
    placeholder.setVisible(true);
    placeholder.setOpacity(1.0);
    view.getChildren().setAll(placeholder, newView);
    placeholder.toFront();
}
 

import javafx.scene.SnapshotParameters; //导入依赖的package包/类
public static boolean saveSnapshot(QuPathViewer viewer, File file) {
    ByteArrayOutputStream byteOutput = new ByteArrayOutputStream();

    javafx.scene.canvas.Canvas canvas = viewer.getCanvas();
    WritableImage image = new WritableImage((int)canvas.getWidth(), (int)canvas.getHeight());
    image = canvas.snapshot(new SnapshotParameters(), image);

    try {
        ImageIO.write(SwingFXUtils.fromFXImage(image, null ),
                "png",
                byteOutput);
        FileOutputStream fileOutputStream = new FileOutputStream(file);
        fileOutputStream.write(byteOutput.toByteArray());
        fileOutputStream.close();
        byteOutput.close();
    } catch (IOException e) {
        e.printStackTrace();
        return false;
    }
    return true;
}
 

import javafx.scene.SnapshotParameters; //导入依赖的package包/类
/**
 * 把一个Node导出为png图片
 *
 * @param node      节点
 * @param saveFile  图片文件
 * @param width     宽
 * @param height    高
 * @return  是否导出成功
 */
public static boolean node2Png(Node node, File saveFile, double width, double height) {
    SnapshotParameters parameters = new SnapshotParameters();
    // 背景透明
    parameters.setFill(Color.TRANSPARENT);
    WritableImage image = node.snapshot(parameters, null);

    // 重置图片大小
    ImageView imageView = new ImageView(image);
    imageView.setFitWidth(width);
    imageView.setFitHeight(height);
    WritableImage exportImage = imageView.snapshot(parameters, null);

    try {
        return ImageIO.write(SwingFXUtils.fromFXImage(exportImage, null), "png", saveFile);
    } catch (IOException e) {
        e.printStackTrace();
    }
    return false;
}
 

import javafx.scene.SnapshotParameters; //导入依赖的package包/类
public void testCommon(String toplevel_name /*, String innerlevel_name*/, String testname,
        SnapshotParameters _sp) {

    boolean pageOpeningOk = true;
    setWaitImageDelay(300);
    try {
        testCommon(toplevel_name, "node_1", false, false);
    } catch (org.jemmy.TimeoutExpiredException ex) {
        pageOpeningOk = false;
    }

    testNodeSnapshotWithParameters (toplevel_name, innerlevel_name, _sp, testname);

    if (!pageOpeningOk) {
        throw new org.jemmy.TimeoutExpiredException("testCommon failed:" + toplevel_name + "-" + innerlevel_name);
    }
}
 

import javafx.scene.SnapshotParameters; //导入依赖的package包/类
public void testNodeSnapshotWithParameters (String toplevel_name, String innerlevel_name,
        final SnapshotParameters _sp, final String param_name) {

    final Wrap<? extends Node> noda = ScreenshotUtils.getPageContent();
    doRenderToImageAndWait(noda, _sp);

    org.jemmy.TimeoutExpiredException saved_ex = null;
    try {

            Wrap<? extends Node> imViewWrap =
                    Lookups.byID(getScene(), "ViewOfNodeSnapshot", ImageView.class);

            ScreenshotUtils.checkScreenshot(new StringBuilder(getName()).append("-")
                    .append(param_name).toString(), imViewWrap);

    } catch (org.jemmy.TimeoutExpiredException ex) {
        saved_ex = ex;
    } finally {
        restoreSceneRoot();
    }
    if ( null != saved_ex) {
        throw saved_ex;
    }
}
 

import javafx.scene.SnapshotParameters; //导入依赖的package包/类
@Override
public WritableImage export(int width, int height) {
    VBox root = new VBox();
    root.setStyle("-fx-background-color: transparent;");
    root.setPadding(new Insets(25));
    
    root.getChildren().add(generate(false));         
    
    Stage newStage = new Stage();
    newStage.initModality(Modality.NONE);
    newStage.setScene(new Scene(root, width, height));
    newStage.setResizable(false);       
    newStage.show();
    
    SnapshotParameters sp = new SnapshotParameters();
    sp.setTransform(Transform.scale(width / root.getWidth(), height / root.getHeight()));
    newStage.close();
    
    return root.snapshot(sp, null);
}
 

import javafx.scene.SnapshotParameters; //导入依赖的package包/类
@Override
public void write(final ReportSummaryWriter writer) {

	// Snapshots must be taken on the application thread, so tell the application thread to take care of this when it has a chance...
	final Task<WritableImage> getImageSnapshotTask = new Task<WritableImage>() {

		@Override
		protected WritableImage call() throws Exception {
			new Scene(HeatMapSummaryComponent.this.chart, -1, -1);
			return HeatMapSummaryComponent.this.chart.snapshot(new SnapshotParameters(), null);
		}
	};
	Platform.runLater(getImageSnapshotTask);

	// Wait for the application thread to do it's stuff, then write the image
	try {
		final WritableImage image = getImageSnapshotTask.get();
		writer.writeImage(SwingFXUtils.fromFXImage(image, null));
	} catch (InterruptedException | ExecutionException e) {
		throw new RuntimeException(e);
	}
}
 

import javafx.scene.SnapshotParameters; //导入依赖的package包/类
public void renderPath(Path2D p2d, Path p, WritableImage wimg) {
    if (useJava2D) {
        BufferedImage bimg = new BufferedImage(TESTW, TESTH, BufferedImage.TYPE_INT_ARGB);
        Graphics2D g2d = bimg.createGraphics();
        g2d.setRenderingHint(RenderingHints.KEY_STROKE_CONTROL,
                             RenderingHints.VALUE_STROKE_PURE);
        g2d.setColor(java.awt.Color.WHITE);
        g2d.fillRect(0, 0, TESTW, TESTH);
        g2d.setColor(java.awt.Color.BLACK);
        if (useJava2DClip) {
            g2d.setClip(p2d);
            g2d.fillRect(0, 0, TESTW, TESTH);
            g2d.setClip(null);
        } else {
            g2d.fill(p2d);
        }
        copy(bimg, wimg);
    } else {
        setPath(p, p2d);
        SnapshotParameters sp = new SnapshotParameters();
        sp.setViewport(new Rectangle2D(0, 0, TESTW, TESTH));
        p.snapshot(sp, wimg);
    }
}
 

import javafx.scene.SnapshotParameters; //导入依赖的package包/类
/**
 * Adapted from http://wecode4fun.blogspot.co.uk/2015/07/particles.html (Roland C.)
 *
 * Snapshot an image out of a node, consider transparency.
 */
private static Image createImage(Node node) {
    SnapshotParameters parameters = new SnapshotParameters();
    parameters.setFill(Color.TRANSPARENT);

    int imageWidth = (int) node.getBoundsInLocal().getWidth();
    int imageHeight = (int) node.getBoundsInLocal().getHeight();

    WritableImage image = new WritableImage(imageWidth, imageHeight);

    Async.startFX(() -> {
        node.snapshot(parameters, image);
    }).await();

    return image;
}
 

import javafx.scene.SnapshotParameters; //导入依赖的package包/类
@Override protected void layoutChildren() {
    super.layoutChildren();
    if (getParent() != null && isVisible()) {
        setVisible(false);
        getChildren().remove(imageView);

        SnapshotParameters parameters = new SnapshotParameters();
        Point2D startPointInScene = this.localToScene(0, 0);

        Rectangle2D toPaint = new Rectangle2D(startPointInScene.getX(), startPointInScene.getY(),
                getLayoutBounds().getWidth(), getLayoutBounds().getHeight());
        parameters.setViewport(toPaint);
        WritableImage image = new WritableImage(100, 100);
        image = getScene().getRoot().snapshot(parameters, image);
        imageView.setImage(image);

        getChildren().add(imageView);
        imageView.toBack();
        setClip(new Rectangle(toPaint.getWidth(), toPaint.getHeight()));
        setVisible(true);
    }
}
 

import javafx.scene.SnapshotParameters; //导入依赖的package包/类
private void startTimer()
{
    timer = new AnimationTimer()
    {

        @Override
        public void handle(long now)
        {
            WritableImage image = dash.snapshot(new SnapshotParameters(), null);
            WritableImage imageCrop = new WritableImage(image.getPixelReader(), (int) getLayoutX(), (int) getLayoutY(), (int) getPrefWidth(), (int) getPrefHeight());
            view.setImage(imageCrop);
        }
    };

    timer.start();
}
 

import javafx.scene.SnapshotParameters; //导入依赖的package包/类
/**
 * Repaints the view.
 */
private void repaint() {

    wrapper.snapshot(new SnapshotParameters(), new WritableImage(5, 5));
    if (graph != null) {
        if (model == null) {
            model = new GraphContainer(graph, reference);
        }
        if (diagram == null) {
            diagram = new StackedMutationContainer(model.getBucketCache(),
                    visibleSequences);
        }

        view = new TileView(this,
                wrapper.getBoundsInParent().getHeight() * 0.9);
        diagramView = new DiagramView();

        scrollPane.hvalueProperty().addListener(
                (observable, oldValue, newValue) -> {
                    repaintPosition(newValue.doubleValue());
                });

        repaintPosition(scrollPane.hvalueProperty().doubleValue());
    }
    getMiniMapController().drawMiniMap();
}