Java Code Examples for java.awt.Rectangle#getWidth()

/**
 * calculate similarity of given rectangle area and offset, but similarityFeatureMatrix is given. And then, build
 * similarRectangle using similarity values.
 *
 * @param expectedImage
 * @param actualImage
 * @param rectangle
 * @param similarRectangle
 * @param offset
 * @param similarityFeatureMatrix in the case of "SCALING", we use similarity already calculated. in the other
 *            cases, it has -1.
 */
public static SimilarityUnit calcSimilarity(BufferedImage expectedImage, BufferedImage actualImage,
		Rectangle rectangle, ComparedRectangleArea similarRectangle, Offset offset, double similarityFeatureMatrix) {

	Offset featureOffset = offset;
	SimilarityUnit similarityUnit = calcSimilarityPixelByPixel(expectedImage, actualImage, rectangle, offset);

	/* calculate similarity using feature matrix. */
	int comparedRectangleWidth = (int) rectangle.getWidth(), comparedRectangleHeight = (int) rectangle.getHeight();

	// execute this only when comparedRectangleWidth >= FeatureCol && comparedRectangleHeight >= FeatureRow
	if (similarityFeatureMatrix == -1
			&& SimilarityUtils.checkFeatureSize(comparedRectangleWidth, comparedRectangleHeight)) {
		similarityFeatureMatrix = calcSimilarityByFeatureMatrix(expectedImage, actualImage, rectangle,
				featureOffset);
	}
	similarityUnit.setSimilarityFeatureMatrix(similarityFeatureMatrix);

	if (similarRectangle.getCategory() == null) {
		similarRectangle.setCategory(DiffCategory.SIMILAR);
	}
	return similarityUnit;
}
 

/**
 * remove redundant rectangles. Each of them may occur raster error, or has smaller length than minLength.
 *
 * @param rectangles list of rectangles
 * @param xLimit limit of x+width of given rectangle
 * @param yLimit limit of y+height of given rectangle
 */
public static void removeRedundantRectangles(List<Rectangle> rectangles, int xLimit, int yLimit) {
	int minLength = 1;
	List<Rectangle> removeList = new ArrayList<Rectangle>();
	for (Rectangle rectangle : rectangles) {
		reshapeRect(rectangle, xLimit, yLimit);
		if (rectangle.getX() >= (xLimit - minLength) || rectangle.getY() >= (yLimit - minLength)
				|| rectangle.getWidth() < minLength || rectangle.getHeight() < minLength) {
			removeList.add(rectangle);
		}
	}

	// remove recorded rectangles
	for (Rectangle removeRect : removeList) {
		rectangles.remove(removeRect);
	}
}
 

@Override
public void propertyChange(PropertyChangeEvent e) {
	String prop = e.getPropertyName();
	if (prop.equals(ZoomModel.ZOOM)) {
		// mouse point
		Point point = getMousePosition(true);
		double oldZoom = ((Double) e.getOldValue()).doubleValue();
		Rectangle r = getViewport().getViewRect();
		double cx = (r.getX() + r.getWidth() / 2) / oldZoom;
		double cy = (r.getY() + r.getHeight() / 2) / oldZoom;

		double newZoom = ((Double) e.getNewValue()).doubleValue();
		r = getViewport().getViewRect();
		if (point != null) {// mouse is pointing something
			int newX = (int) Math
					.round(r.getX() / oldZoom * newZoom + point.getX() / oldZoom * newZoom - point.getX());
			int newY = (int) Math
					.round(r.getY() / oldZoom * newZoom + point.getY() / oldZoom * newZoom - point.getY());
			getHorizontalScrollBar().setValue(newX);
			getVerticalScrollBar().setValue(newY);
		} else {// mouse is outside from canvas panel
			int hv = (int) (cx * newZoom - r.getWidth() / 2);
			int vv = (int) (cy * newZoom - r.getHeight() / 2);
			getHorizontalScrollBar().setValue(hv);
			getVerticalScrollBar().setValue(vv);
		}
		contents.recomputeSize();
	}
}
 

/**
 * Retuns points which can be used to click on path.
 *
 * @param row a row index to click on.
 * @return a Point in component's coordinate system.
 */
public Point getPointToClick(int row) {
    Rectangle rect = getRowBounds(row);
    if (rect != null) {
        return (new Point((int) (rect.getX() + rect.getWidth() / 2),
                (int) (rect.getY() + rect.getHeight() / 2)));
    } else {
        throw (new NoSuchPathException(row));
    }
}
 

private static boolean pressOK(Component comp) {

        JInternalFrame internalFrame
                = findModalInternalFrame(comp, QUESTION);

        if (internalFrame == null) {
            return false;
        }

        JButton button = (JButton) findButton(internalFrame);

        if (button == null) {
            return false;
        }

        try {
            Robot robot = new Robot();
            Point location = button.getLocationOnScreen();
            Rectangle bounds = button.getBounds();
            int centerX = (int) (location.getX() + bounds.getWidth() / 2);
            int centerY = (int) (location.getY() + bounds.getHeight() / 2);
            robot.mouseMove(centerX, centerY);
            robot.mousePress(InputEvent.BUTTON1_MASK);
            robot.mouseRelease(InputEvent.BUTTON1_MASK);
        } catch (IllegalComponentStateException ignore) {
            return false;
        } catch (AWTException e) {
            throw new RuntimeException(e);
        }
        return true;
    }
 

@Override
protected void paintComponent(Graphics graphics) {
	super.paintComponent(graphics);
	double scaleX = (double) getWidth() / (double) processRenderer.getWidth();
	double scaleY = (double) getHeight() / (double) processRenderer.getHeight();
	scale = Math.min(scaleX, scaleY);
	double scaledW = processRenderer.getWidth() * scale;
	double scaledH = processRenderer.getHeight() * scale;

	Graphics2D g = (Graphics2D) graphics.create();
	g.translate((getWidth() - scaledW) / 2d, (getHeight() - scaledH) / 2d);
	g.scale(scale, scale);

	g.setRenderingHints(ProcessDrawer.LOW_QUALITY_HINTS);
	processRenderer.getOverviewPanelDrawer().draw(g, true);

	g.setStroke(new BasicStroke((int) (1d / scale)));

	Rectangle visibleRect = processRenderer.getVisibleRect();
	Rectangle drawRect = new Rectangle((int) visibleRect.getX(), (int) visibleRect.getY(),
			(int) visibleRect.getWidth() - 1, (int) visibleRect.getHeight() - 1);

	g.setColor(FILL_COLOR);
	g.fill(drawRect);

	g.setColor(DRAW_COLOR);
	g.draw(drawRect);

	g.dispose();
}
 

private Point clipToRectangle(Point drawPoint, Rectangle mapDisplayRectangle)
{
	int clippedX = drawPoint.getX();

	if (drawPoint.getX() < mapDisplayRectangle.getX())
	{
		clippedX = (int) mapDisplayRectangle.getX();
	}

	if (drawPoint.getX() > mapDisplayRectangle.getX() + mapDisplayRectangle.getWidth())
	{
		clippedX = (int) (mapDisplayRectangle.getX() + mapDisplayRectangle.getWidth());
	}

	int clippedY = drawPoint.getY();

	if (drawPoint.getY() < mapDisplayRectangle.getY())
	{
		clippedY = (int) mapDisplayRectangle.getY();
	}

	if (drawPoint.getY() > mapDisplayRectangle.getY() + mapDisplayRectangle.getHeight())
	{
		clippedY = (int) (mapDisplayRectangle.getY() + mapDisplayRectangle.getHeight());
	}

	return new Point(clippedX, clippedY);
}
 

private static ImageIcon convertShapeToIcon(Shape seriesShape) {
    Rectangle rectangle = seriesShape.getBounds();
    if (rectangle.getWidth() > 0 && rectangle.getHeight() > 0) {
        BufferedImage image = new BufferedImage((int) (rectangle.getWidth() - rectangle.getX()),
                                                (int) (rectangle.getHeight() - rectangle.getY()), BufferedImage.TYPE_INT_ARGB);
        final Graphics2D graphics = image.createGraphics();
        graphics.translate(-rectangle.x, -rectangle.y);
        graphics.setColor(Color.BLACK);
        graphics.draw(seriesShape);
        graphics.dispose();
        return new ImageIcon(image);
    }
    return new ImageIcon();
}
 

@Override
public Component getTableCellRendererComponent (
    JTable table, Object value,
    boolean isSelected, boolean hasFocus, int row, int column
) {
    JLabel c = (JLabel)defaultRenderer.getTableCellRendererComponent(table, value, isSelected, hasFocus, row, column);
    
    if (value instanceof String) {
        Rectangle cellRect = table.getCellRect(row, column, false);
        String scCell = (String) value;
        Dimension d = new Dimension((int) cellRect.getWidth(), (int) cellRect.getHeight());
        if (panel == null)
            panel = new ShortcutCellPanel(scCell);
        panel.setText(scCell);
        panel.setSize(d);

        if (isSelected) {
            panel.setBgColor(table.getSelectionBackground());
            if (UIManager.getLookAndFeel ().getID ().equals ("GTK"))
                panel.setFgCOlor(table.getForeground(), true);
            else
                panel.setFgCOlor(table.getSelectionForeground(), true);
        } else {
            panel.setBgColor(c.getBackground());
            panel.setFgCOlor(c.getForeground(), false);
        }
        if (hasFocus) {
            panel.setBorder(c.getBorder());
        } else {
            panel.setBorder(null);
        }

        return panel;
    }
    else {
        return c;
    }
}
 

/**
 * Center a frame on the main display
 *
 * @param frame
 *            The frame to center
 */
public static void centerFrameOnMainDisplay(final JFrame frame) {
	final GraphicsEnvironment ge = GraphicsEnvironment
			.getLocalGraphicsEnvironment();
	final GraphicsDevice[] screens = ge.getScreenDevices();
	if (screens.length < 1) {
		return; // Silently fail.
	}
	final Rectangle screenBounds = screens[0].getDefaultConfiguration()
			.getBounds();
	final int x = (int) ((screenBounds.getWidth() - frame.getWidth()) / 2);
	final int y = (int) ((screenBounds.getHeight() - frame.getHeight()) / 2);
	frame.setLocation(x, y);
}
 

/**
     * Changes the displayed bounds of the object relative to its x,y width and height
     *
     * Implemented because the canvas has no layout manager
     *
     */
    protected final void updateBounds() {
        Rectangle bounds = shape.getBounds();
        Rectangle newBounds = new Rectangle((int)(model.getCentre().getX() + bounds.getX()), (int)(model.getCentre().getY() + bounds.getY()), (int) bounds.getWidth() + getComponentDrawOffset(), (int)bounds.getHeight() + getComponentDrawOffset()) ;
        setBounds(newBounds);
//        setBounds(model.getX(), model.getY(), model.getWidth() + getComponentDrawOffset(), model.getHeight() + getComponentDrawOffset());

        //TODO: THIS IS A DIRTY HACK IN ORDER TO GET DRAGGIGN WHEN ZOOMED WORKING
        Component root = SwingUtilities.getRoot(this);
        if (root != null) {
            root.repaint();
        }
    }
 

public void generateActual(OutputStream out) throws Exception {
	Rectangle rect = mapContext.getViewport().getScreenArea();
	BufferedImage image = new BufferedImage((int) rect.getWidth(), (int) rect.getHeight(),
			BufferedImage.TYPE_4BYTE_ABGR);
	layer.draw(image.createGraphics(), mapContext, mapContext.getViewport());
	ImageIO.write(image, "PNG", out);
}
 

/**
 * I've got a big, hairy expression and it doesn’t do what I expect.
 */
public static void main(String[] args) {
    Rectangle rect = new Rectangle(0, 0, 10, 10);
    Rectangle ngle = new Rectangle(-5, -5, -5, -5);
    System.out.println(intersection(rect, ngle));

    double halfWidth = 0.5 * rect.getWidth();
    double halfHeight = 0.5 * rect.getHeight();
    int dx = (int) Math.round(halfWidth);
    int dy = (int) Math.round(halfHeight);
    rect.translate(dx, dy);
}
 

private static ImageIcon convertStrokeToIcon(Stroke stroke) {
    Shape strokeShape = new Line2D.Double(-40, 0, 40, 0);
    final Rectangle rectangle = strokeShape.getBounds();
    BufferedImage image = new BufferedImage((int) (rectangle.getWidth() - rectangle.getX()),
                                            1,
                                            BufferedImage.TYPE_INT_ARGB);
    final Graphics2D graphics = image.createGraphics();
    graphics.translate(-rectangle.x, -rectangle.y);
    graphics.setColor(Color.BLACK);
    graphics.setStroke(stroke);
    graphics.draw(strokeShape);
    graphics.dispose();
    return new ImageIcon(image);
}
 

private void renderWiw(Graphics2D g, Object wiw, Color color)
{
	g.setColor(color);

	if (wiw instanceof WidgetItem)
	{
		WidgetItem wi = (WidgetItem) wiw;
		Rectangle bounds = wi.getCanvasBounds();
		g.draw(bounds);

		String text = wi.getId() + "";
		FontMetrics fm = g.getFontMetrics();
		Rectangle2D textBounds = fm.getStringBounds(text, g);

		int textX = (int) (bounds.getX() + (bounds.getWidth() / 2) - (textBounds.getWidth() / 2));
		int textY = (int) (bounds.getY() + (bounds.getHeight() / 2) + (textBounds.getHeight() / 2));

		g.setColor(Color.BLACK);
		g.drawString(text, textX + 1, textY + 1);
		g.setColor(Color.ORANGE);
		g.drawString(text, textX, textY);
	}
	else
	{
		Widget w = (Widget) wiw;
		g.draw(w.getBounds());
	}
}
 

/**
 * Initializes a number of things about this frame.
 */
private void initializeFrame() {
    frame = new JFrame(Messages.getString("ClientGUI.title")); //$NON-NLS-1$
    frame.setJMenuBar(menuBar);
    Rectangle virtualBounds = getVirtualBounds();
    int x, y, w, h;
    if (GUIPreferences.getInstance().getWindowSizeHeight() != 0) {
        x = GUIPreferences.getInstance().getWindowPosX();
        y = GUIPreferences.getInstance().getWindowPosY();
        w = GUIPreferences.getInstance().getWindowSizeWidth();
        h = GUIPreferences.getInstance().getWindowSizeHeight();
        if ((x < virtualBounds.getMinX())
                || ((x + w) > virtualBounds.getMaxX())) {
            x = 0;
        }
        if ((y < virtualBounds.getMinY())
                || ((y + h) > virtualBounds.getMaxY())) {
            y = 0;
        }
        if (w > virtualBounds.getWidth()) {
            w = (int) virtualBounds.getWidth();
        }
        if (h > virtualBounds.getHeight()) {
            h = (int) virtualBounds.getHeight();
        }
        frame.setLocation(x, y);
        frame.setSize(w, h);
    } else {
        frame.setSize(800, 600);
    }
    frame.setMinimumSize(new Dimension(640, 480));
    frame.setBackground(SystemColor.menu);
    frame.setForeground(SystemColor.menuText);
    List<Image> iconList = new ArrayList<Image>();
    iconList.add(frame.getToolkit().getImage(
            new MegaMekFile(Configuration.miscImagesDir(), FILENAME_ICON_16X16)
                    .toString()));
    iconList.add(frame.getToolkit().getImage(
            new MegaMekFile(Configuration.miscImagesDir(), FILENAME_ICON_32X32)
                    .toString()));
    iconList.add(frame.getToolkit().getImage(
            new MegaMekFile(Configuration.miscImagesDir(), FILENAME_ICON_48X48)
                    .toString()));
    iconList.add(frame.getToolkit().getImage(
            new MegaMekFile(Configuration.miscImagesDir(), FILENAME_ICON_256X256)
                    .toString()));
    frame.setIconImages(iconList);

    mechW = new JDialog(frame, Messages.getString("ClientGUI.MechDisplay"), false);
    x = GUIPreferences.getInstance().getDisplayPosX();
    y = GUIPreferences.getInstance().getDisplayPosY();
    h = GUIPreferences.getInstance().getDisplaySizeHeight();
    w = GUIPreferences.getInstance().getDisplaySizeWidth();
    if ((x + w) > virtualBounds.getWidth()) {
        x = 0;
        w = Math.min(w, (int)virtualBounds.getWidth());
    }
    if ((y + h) > virtualBounds.getHeight()) {
        y = 0;
        h = Math.min(h, (int)virtualBounds.getHeight());
    }
    mechW.setLocation(x, y);
    mechW.setSize(w, h);
    mechW.setResizable(true);
    unitDisplay = new UnitDisplay(null);
    mechW.add(unitDisplay);
    mechW.setVisible(true);
    unitDisplay.displayEntity(testEntity);
}
 

@Override
public Transition2DInstruction[] getInstructions(float progress,
                                                 Dimension size) {

    Rectangle r1 = new Rectangle(0, 0, size.width, size.height);
    float k1 = 0.6f;
    float k2 = 0.95f - k1;
    float k3 = (1 - k1) / 2;


    float cutOff = 0.4f;
    Rectangle2D r2;
    if (type == RIGHT) {
        r2 = new Rectangle2D.Float(k2 * r1.width,
                k3 * r1.height,
                k1 * r1.width,
                k1 * r1.height);
    } else if (type == LEFT) {
        r2 = new Rectangle2D.Float(0.05f * r1.width,
                k3 * r1.height,
                k1 * r1.width,
                k1 * r1.height);
    } else if (type == DOWN) {
        r2 = new Rectangle2D.Float(k3 * r1.width,
                k2 * r1.height,
                k1 * r1.width,
                k1 * r1.height);
    } else {  //up
        r2 = new Rectangle2D.Float(k3 * r1.width,
                0.05f * r1.height,
                k1 * r1.width,
                k1 * r1.height);
    }
    float zoomProgress;
    float panProgress = (float) (0.5 + 0.5 * sin(PI * (progress * progress - 0.5)));
    if (progress < cutOff) {
        //we're zooming in
        zoomProgress = progress / cutOff;
    } else {
        zoomProgress = 1;
    }

    Rectangle2D r3 = new Rectangle2D.Float(
            (float) (r2.getX() * (1 - panProgress) + r1.getX() * panProgress),
            (float) (r2.getY() * (1 - panProgress) + r1.getY() * panProgress),
            (float) (r2.getWidth() * (1 - panProgress) + r1.getWidth() * panProgress),
            (float) (r2.getHeight() * (1 - panProgress) + r1.getHeight() * panProgress)
    );

    List<Transition2DInstruction> v = new ArrayList<>();

    AffineTransform t = RectangularTransform.create(r3, r1);
    v.add(new ImageInstruction(false, t, r1));

    if (zoomProgress != 1) {
        v.add(new ImageInstruction(true, 1 - zoomProgress));
    }

    return v.toArray(new Transition2DInstruction[v.size()]);
}
 

public RotatedRectangle(Rectangle r, double theta) {
    this(r.getX(), r.getY(), r.getWidth(), r.getHeight(), theta);
}
 

/**
 * sets the rectangles/bounds for each node
 * also sets the bounds for the entire grid
 */
private void updateGridRectangles() {

	//create/set rectangles for each location in grid
	for (int row = 0; row < gridTable.getNumRows(); ++row) {
		for (int col = 0; col < gridTable.getNumCols(); ++col) {
			
			//find the bounds from the cell at this row/col
			//use that rectangle as the node's rectangle
			String cellID = "ROW" + row + "_COL" + col;
			
			if (graph != null && graph.getGridRectangleCellFromID(cellID) != null) {
				
				//set the component sizes (which may have changed due to zooming)
				String compId = grid.get(row).get(col).getComponent();
				
				if (compId != null) {
					
					mxCell compCell = graph.getComponentCell(compId);
					
					if (compCell != null) {
						
						Rectangle compCellRect = graph.getCellGeometry(compCell).getRectangle();							
						componentGeomHeight = compCellRect.getHeight();
						componentGeomWidth = compCellRect.getWidth();
					}
				}
				
				//set the zoom scale
				zoomAmount = graph.getView().getScale();
				
				//get the bounds information from the graph and set the grid
				//rectangle's data to fit with the graph's data
				mxCell cell = graph.getGridRectangleCellFromID(cellID);					
				Rectangle cellGeom = graph.getCellGeometry(cell).getRectangle();
				
				gridGeomHeight = cellGeom.getHeight();
				gridGeomWidth = cellGeom.getWidth();				
				gridHeight = gridGeomHeight * zoomAmount;
				gridWidth = gridGeomWidth * zoomAmount;
				
				//set the current padding value (which may have changed due to zooming)
				//this is usually going to be 30
				padding = gridGeomWidth - componentGeomWidth;
				
				grid.get(row).get(col).setRectangle(cellGeom);
			}
		}
	}
	
	//set the total grid bounds
	int outerX = (int)gridWidth * gridTable.getNumCols();
	int outerY = (int)gridHeight * gridTable.getNumRows() + verticalOffset;
	
	gridBounds.setBounds(15, 15, outerX, outerY);
}
 

/**
 * Converts an AWT rectangle to a JavaFX bounds object.
 * <p/>
 * @param rect the rectangle to convert.
 * @return the equivalent bounds.
 */
public static Bounds getBoundsFromRect(Rectangle rect) {
	return new BoundingBox(rect.getX(), rect.getY(), rect.getWidth(), rect.getHeight());
}