Java Image.getHeight方法代码示例

import javafx.scene.image.Image; //导入方法依赖的package包/类
private void adaptMapPaneToImage(Image image) {
    mapPane.getChildren().remove(importMapText);

    if(image.getWidth() < mapViewPort.getWidth())
        mapViewPort.setMaxWidth(image.getWidth());

    if(image.getHeight() < mapViewPort.getHeight())
        mapViewPort.setMaxHeight(image.getHeight());

    mapPane.setPrefWidth(image.getWidth());
    mapPane.setMinWidth(image.getWidth());
    mapPane.setPrefHeight(image.getHeight());
    mapPane.setMinHeight(image.getHeight());

    mapPane.setAlignment(Pos.TOP_LEFT);
    mapPane.getChildren().add(new ImageView(image));
}
 

import javafx.scene.image.Image; //导入方法依赖的package包/类
private void resetState(Scene scene) {
    Image image = new Image(pictureResourceLocation);

    double imageWidth = image.getWidth();
    double imageHeight = image.getHeight();
    double imageHeightToWidthRatio = imageHeight / imageWidth;

    double initialHeight = scene.getHeight() * pictureInitialHeightToSceneHeightRatio;
    double initialWidth = initialHeight / imageHeightToWidthRatio;

    double positionX = (scene.getWidth() - initialWidth) / 2;
    double positionY = (scene.getHeight() - initialHeight) / 2;

    setFill(new ImagePattern(image));

    setX(positionX);
    setY(positionY);
    setWidth(initialWidth);
    setHeight(initialHeight);

    setTranslateX(0);
    setScaleX(1);
    setScaleY(1);
    setScaleZ(1);

    setOpacity(0);

    toFront(); // bug when it is uncommented (with bloc at least).
}
 

import javafx.scene.image.Image; //导入方法依赖的package包/类
public void setFillImageKeepingAspectRatio(Rectangle rectangle, Image image, Dimension2D gamingContextDimension2D) {
    double imageWidth = image.getWidth();
    double imageHeight = image.getHeight();
    double imageHeightToWidthRatio = imageHeight / imageWidth;

    double initialHeight = rectangle.getHeight();
    double initialWidth = initialHeight / imageHeightToWidthRatio;

    double positionX = (gamingContextDimension2D.getWidth() - initialWidth) / 2;
    double positionY = (gamingContextDimension2D.getHeight() - initialHeight) / 2;

    rectangle.setFill(new ImagePattern(image));

    rectangle.setX(positionX);
    rectangle.setY(positionY);
    rectangle.setWidth(initialWidth);
    rectangle.setHeight(initialHeight);

    rectangle.setTranslateX(0);
    rectangle.setScaleX(1);
    rectangle.setScaleY(1);
    rectangle.setScaleZ(1);
}
 

import javafx.scene.image.Image; //导入方法依赖的package包/类
private Rectangle createErrorImageRectangle() {
    final Image image = new Image("data/common/images/error.png");

    double imageWidth = image.getWidth();
    double imageHeight = image.getHeight();
    double imageHeightToWidthRatio = imageHeight / imageWidth;

    double rectangleWidth = imageRectangle.getFitWidth() / 3;
    double rectangleHeight = imageHeightToWidthRatio * rectangleWidth;

    double positionX = imageRectangle.getX() + (imageRectangle.getFitWidth() - rectangleWidth) / 2;
    double positionY = imageRectangle.getY() + (imageRectangle.getFitHeight() - rectangleHeight) / 2;

    Rectangle errorImageRectangle = new Rectangle(rectangleWidth, rectangleHeight);
    errorImageRectangle.setFill(new ImagePattern(image));
    errorImageRectangle.setX(positionX);
    errorImageRectangle.setY(positionY);
    errorImageRectangle.setOpacity(0);
    errorImageRectangle.setVisible(false);
    return errorImageRectangle;
}
 

import javafx.scene.image.Image; //导入方法依赖的package包/类
public void drawShuffledPieces() {
    fillBackgroundWithColor(Color.BLACK);

    if (shuffledPieces.isEmpty()) {
        return;
    }

    Image originalImage = shuffledPieces.get(0).getOriginalImage();
    Iterator<Piece> iterator = shuffledPieces.iterator();
    for (int h = 0; h < AppConstants.NUM_HORIZONTAL_SLICES; h++) {
        int originalXPos = (int) ((originalImage.getWidth() / AppConstants.NUM_HORIZONTAL_SLICES) * h);

        for (int v = 0; v < AppConstants.NUM_VERTICAL_SLICES; v++) {
            int originalYPos = (int) ((originalImage.getHeight() / AppConstants.NUM_VERTICAL_SLICES) * v);
            Piece piece = iterator.hasNext() ? iterator.next() : null;
            if (piece != null) {
                graphicsContext.getPixelWriter().setPixels(
                        originalXPos, originalYPos,
                        piece.getWidth(), piece.getHeight(),
                        piece.getOriginalImage().getPixelReader(),
                        piece.getXPos(), piece.getYPos());
            }
        }
    }
}
 

import javafx.scene.image.Image; //导入方法依赖的package包/类
private void centerImage() {
    Image img = showImage.getImage();
    if (img != null) {
        double w = 0;
        double h = 0;

        double ratioX = showImage.getFitWidth() / img.getWidth();
        double ratioY = showImage.getFitHeight() / img.getHeight();

        double reducCoeff = 0;
        if(ratioX >= ratioY) {
            reducCoeff = ratioY;
        } else {
            reducCoeff = ratioX;
        }

        w = img.getWidth() * reducCoeff;
        h = img.getHeight() * reducCoeff;

        showImage.setX((showImage.getFitWidth() - w) / 2);
        showImage.setY((showImage.getFitHeight() - h) / 2);

    }
}
 

import javafx.scene.image.Image; //导入方法依赖的package包/类
@Override
public Set<Point2D> getMask(Image image, Color color) {
	PixelReader pixelReader = image.getPixelReader();
	Set<Point2D> mask = new HashSet<>();
	int pixel;
	boolean isTransparent, isBackgroundColor;
	for(int i =0; i < image.getWidth(); i++){
		for(int j = 0; j < image.getHeight(); j++){
			pixel = pixelReader.getArgb(i, j);
			//check the transparency of the pixel at (i,j)
			isTransparent = (pixel >> 24) == 0x00;				
			Color backgroundColor = pixelReader.getColor(i, j);
			isBackgroundColor = (color.equals(backgroundColor));
			if(!isTransparent && !isBackgroundColor){
				Point2D p = new Point2D(i,j);
				mask.add(p);
			}
		}
	}
	return mask;
}
 

import javafx.scene.image.Image; //导入方法依赖的package包/类
public Bonus(int type) {
    content = new ImageView();
    getChildren().add(content);
    this.type = type;
    Image image = Config.getBonusesImages().get(type);
    width = (int)image.getWidth() - Config.SHADOW_WIDTH;
    height = (int)image.getHeight() - Config.SHADOW_HEIGHT;
    content.setImage(image);
    setMouseTransparent(true);
}
 

import javafx.scene.image.Image; //导入方法依赖的package包/类
@Override
public double prefHeight(double width) {
  Image image = getImage();
  if (image == null) {
    return minHeight(width);
  }
  return image.getHeight();
}
 

import javafx.scene.image.Image; //导入方法依赖的package包/类
/**
 * Constructor
 *
 * @param photoURI the URI of the photo file.
 */
public Photo(URI photoURI) throws FileNotFoundException {
    file = new File(photoURI);
    String filePath = file.getAbsolutePath();
    Image img = buildImage();

    baseName = FilenameUtils.getBaseName(filePath);
    format = FilenameUtils.getExtension(filePath);
    height = img.getHeight();
    width = img.getWidth();
}
 

import javafx.scene.image.Image; //导入方法依赖的package包/类
/**
 * Computes the actual scaling of an Image in an ImageView. If the preserveRatio
 * property on the ImageView is false the scaling has no meaning so NaN is
 * returned.
 *
 * @return The scale factor of the image in relation to display coordinates
 */
public double computeActualScale() {

    if (!imageView.isPreserveRatio()) {
        actualScale = Double.NaN;
    }
    else if (doScaleRecompute) {
        Image localImage = imageView.getImage();
        Rectangle2D localViewport = imageView.getViewport();

        double w = 0;
        double h = 0;
        if (localViewport != null && localViewport.getWidth() > 0 && localViewport.getHeight() > 0) {
            w = localViewport.getWidth();
            h = localViewport.getHeight();
        } else if (localImage != null) {
            w = localImage.getWidth();
            h = localImage.getHeight();
        }

        double localFitWidth = imageView.getFitWidth();
        double localFitHeight = imageView.getFitHeight();

        if (w > 0 && h > 0 && (localFitWidth > 0 || localFitHeight > 0)) {
            if (localFitWidth <= 0 || (localFitHeight > 0 && localFitWidth * h > localFitHeight * w)) {
                w = w * localFitHeight / h;
            } else {
                w = localFitWidth;
            }

            actualScale = w / localImage.getWidth();
        }

        doScaleRecompute = false;

    }

    return actualScale;
}
 

import javafx.scene.image.Image; //导入方法依赖的package包/类
public static List<Piece> createPieces(Image originalImage, int numHorizontalSlices, int numVerticalSlices) {
    List<Piece> pieces = new ArrayList();
    for (int h = 0; h < numHorizontalSlices; h++) {
        int originalXPos = (int) ((originalImage.getWidth() / numHorizontalSlices) * h);
        int width = (int) (originalImage.getWidth() / numHorizontalSlices);

        for (int v = 0; v < numVerticalSlices; v++) {
            int originalYPos = (int) ((originalImage.getHeight() / numVerticalSlices) * v);
            int height = (int) (originalImage.getHeight() / numVerticalSlices);
            pieces.add(new Piece(originalImage, originalXPos, originalYPos, width, height));
        }
    }
    return Collections.unmodifiableList(pieces);
}
 

import javafx.scene.image.Image; //导入方法依赖的package包/类
public double height() {
	Image image = getFXImage();
	if (image != null) {
		return (image.getHeight() >= 100) ? 100 : image.getHeight();
	}
	else {
		return 0;
	}
}
 

import javafx.scene.image.Image; //导入方法依赖的package包/类
@Override
public Node mkRoot() {


	Image image = new Image(LenaSample.LENA);

	GesturePane gesturePane = new GesturePane(new ImageView(image));
	gesturePane.setMaxSize(image.getWidth(), image.getHeight());

	ImageView background = new ImageView(LenaSample.LENA);
	background.setFitWidth(image.getWidth());
	background.setFitHeight(image.getHeight());

	Rectangle shade = new Rectangle(image.getWidth(),
			                               image.getHeight(),
			                               Color.grayRgb(0, 0.5));
	Rectangle viewRect = new Rectangle();
	viewRect.setStroke(Color.WHITE);
	viewRect.setStrokeWidth(2);
	viewRect.setFill(Color.WHITE);
	// shade * rect
	Group group = new Group(shade, viewRect);
	group.setBlendMode(BlendMode.MULTIPLY);
	Pane viewportSim = new Pane(background, group);
	viewportSim.maxWidthProperty().bind(background.fitWidthProperty());
	viewportSim.maxHeightProperty().bind(background.fitHeightProperty());

	gesturePane.targetViewportProperty().addListener((o, p, n) -> {
		viewRect.setTranslateX(n.getMinX());
		viewRect.setTranslateY(n.getMinY());
		viewRect.setWidth(n.getWidth());
		viewRect.setHeight(n.getHeight());
	});

	HBox box = new HBox(gesturePane, viewportSim);
	box.setAlignment(Pos.CENTER);
	VBox.setVgrow(box, Priority.ALWAYS);
	Label description = new Label("Zoom and scroll on the left image(wrapped in a GesturePane)" +
			                              "; the right image will reflect the actual viewport " +
			                              "of the current transformation");
	description.setWrapText(true);
	description.setPadding(new Insets(16));
	return new VBox(description, box);
}