public void setLocation(GeneralPath gp) { if (gp != null) { Rectangle rect = gp.getBounds(); double x = rect.getX(); double y = rect.getY(); if (anchor == ANCHOR_TOP || anchor == ANCHOR_CENTER || anchor == ANCHOR_BOTTOM) { x += rect.getWidth() / 2; } else if (anchor == ANCHOR_TOPRIGHT || anchor == ANCHOR_RIGHT || anchor == ANCHOR_BOTTOMRIGHT) { x += rect.getWidth(); } if (anchor == ANCHOR_LEFT || anchor == ANCHOR_CENTER || anchor == ANCHOR_RIGHT) { y += rect.getHeight() / 2; } else if (anchor == ANCHOR_BOTTOMLEFT || anchor == ANCHOR_BOTTOM || anchor == ANCHOR_BOTTOMRIGHT) { y += rect.getHeight(); } setLocation(new Point((int) x, (int) y)); } }
/** * Compute the screen location of the controls overall rectangle bottom right corner according to * either the location center if not null, or the screen position. * * @param viewport the current viewport rectangle. * @param controls the overall controls rectangle * @return the screen location of the bottom left corner - south west corner. */ protected Point computeLocation(Rectangle viewport, Rectangle controls) { double x; double y; if (this.locationCenter != null) { x = this.locationCenter.x - controls.width / 2; y = this.locationCenter.y - controls.height / 2; } else if (this.position.equals(AVKey.NORTHEAST)) { x = viewport.getWidth() - controls.width - this.borderWidth; y = viewport.getHeight() - controls.height - this.borderWidth; } else if (this.position.equals(AVKey.SOUTHEAST)) { x = viewport.getWidth() - controls.width - this.borderWidth; y = 0d + this.borderWidth; } else if (this.position.equals(AVKey.NORTHWEST)) { x = 0d + this.borderWidth; y = viewport.getHeight() - controls.height - this.borderWidth; } else if (this.position.equals(AVKey.SOUTHWEST)) { x = 0d + this.borderWidth; y = 0d + this.borderWidth; } else // use North East as default { x = viewport.getWidth() - controls.width - this.borderWidth; y = viewport.getHeight() - controls.height - this.borderWidth; } if (this.locationOffset != null) { x += this.locationOffset.x; y += this.locationOffset.y; } return new Point((int) x, (int) y); }
public boolean wallCollision(Bullet bullet) { Rectangle boundingBox = bullet.getBoundingBox(); int tile; int tileWidth = tileMap.getTileWidth(); int tileHeight = tileMap.getTileHeight(); /* * nested four loop only is grabbing the 4 corners of the * bullet's hit box and checking the type of tiles that they * contact. The current bullets range from 8x8 to 17x17, so they * all can contact the same range of tiles at any given time: * 1-4 A bullet expires on contact with a solid object(besides * ring bullets) */ for (int y = bullet.yPos; y <= bullet.yPos + boundingBox.getHeight(); y += boundingBox.getHeight()) { for (int x = bullet.xPos; x <= bullet.xPos + boundingBox.getWidth(); x += boundingBox.getWidth()) { int tileCoordX = (int) (x + distanceScrolled) / tileWidth; int tileCoordY = y / tileHeight; tile = tileMap.getTile(((tileCoordY) * tileMap.getTileMapWidth()) + (tileCoordX)); if (tile < 17 || 23 < tile) { return true; } } } return false; }
public void paintSelection(Graphics g, int rowMin, int rowMax, int colMin, int colMax) { for (int row = rowMin; row <= rowMax; row++) { for (int column = colMin; column <= colMax; column++) { if (!grid.isCellSpan(row, column)) { Rectangle cellBounds = grid.getCellBounds(row, column); if (grid.getSelectionModel().isSelected(row, column)) { g.setColor(Color.RED); g.drawRect( (int) cellBounds.getX() + 1, (int) cellBounds.getY() + 1, (int) cellBounds.getWidth() - 2, (int) cellBounds.getHeight() - 2); } } else { CellSpan span = grid.getSpanModel().getSpanOver(row, column); if (grid.getSelectionModel().isSelected(span.getRow(), span.getColumn())) { g.setColor(Color.RED); Rectangle cellBounds = grid.getCellBounds(span.getFirstRow(), span.getLastColumn()); g.drawRect( (int) cellBounds.getX() + 1, (int) cellBounds.getY() + 1, (int) cellBounds.getWidth() - 2, (int) cellBounds.getHeight() - 2); } } } } }
public void paintTransition(Graphics2D g2, int state, Rectangle size, Image prev) { int length = getAnimationLength(); int half = length / 2; double scale = size.getHeight() / length; int offset = 0; // calculate the fade out part if (state >= 0 && state < half) { // draw the saved version of the old tab component if (prev != null) { g2.drawImage(prev, (int) size.getX(), (int) size.getY(), null); } offset = (int) ((10 - state) * scale); } // calculate the fade in part if (state >= half && state < length) { g2.setColor(Color.white); offset = (int) ((state - 10) * scale); } // do the drawing g2.setColor(Color.white); Rectangle area = new Rectangle( (int) (size.getX() + offset), (int) (size.getY() + offset), (int) (size.getWidth() - offset * 2), (int) (size.getHeight() - offset * 2)); g2.fill(area); }
/* (non-Javadoc) * @see at.fhhgb.mc.Shapes.GraphicPrimitive#draw(java.awt.Graphics) */ @Override public void draw(Graphics g) { g.setColor(new Color(0, 0, 255)); g.drawLine(x, y, x2, y2); if (getHovered()) { java.awt.Rectangle bounds = getBoundingBox(); g.setColor(new Color(10, 10, 10)); g.drawRect( (int) bounds.getX(), (int) bounds.getY(), (int) bounds.getWidth(), (int) bounds.getHeight()); } if (getSelected()) { java.awt.Rectangle bounds = getBoundingBox(); g.setColor(new Color(255, 0, 0)); Graphics2D g2 = (Graphics2D) g; g2.setStroke(new BasicStroke(3)); g2.drawRect( (int) bounds.getX(), (int) bounds.getY(), (int) bounds.getWidth(), (int) bounds.getHeight()); } }
private Vec4 computeLocation(java.awt.Rectangle viewport, double scale) { double scaledWidth = scale * this.size.width; double scaledHeight = scale * this.size.height; double x; double y; if (this.locationCenter != null) { x = this.locationCenter.x - scaledWidth / 2; y = this.locationCenter.y - scaledHeight / 2; } else if (this.position.equals(AVKey.NORTHEAST)) { x = viewport.getWidth() - scaledWidth - this.borderWidth; y = viewport.getHeight() - scaledHeight - this.borderWidth; } else if (this.position.equals(AVKey.SOUTHEAST)) { x = viewport.getWidth() - scaledWidth - this.borderWidth; y = 0d + this.borderWidth; } else if (this.position.equals(AVKey.NORTHWEST)) { x = 0d + this.borderWidth; y = viewport.getHeight() - scaledHeight - this.borderWidth; } else if (this.position.equals(AVKey.SOUTHWEST)) { x = 0d + this.borderWidth; y = 0d + this.borderWidth; } else // use North East { x = viewport.getWidth() - scaledWidth / 2 - this.borderWidth; y = viewport.getHeight() - scaledHeight / 2 - this.borderWidth; } if (this.locationOffset != null) { x += this.locationOffset.x; y += this.locationOffset.y; } return new Vec4(x, y, 0); }
public static com.parkingfinder.web.model.Rectangle convert(java.awt.Rectangle rect) { com.parkingfinder.web.model.Rectangle result = new com.parkingfinder.web.model.Rectangle(); result.setMaxLeft(new Point(rect.getX(), rect.getY())); result.setMaxRight(new Point(rect.getX() + rect.getWidth(), rect.getY())); result.setMinRight(new Point(rect.getX() + rect.getWidth(), rect.getY() + rect.getHeight())); result.setMinLeft(new Point(rect.getX(), rect.getY() + rect.getHeight())); return result; }
public void setVisible(boolean flag) { Rectangle rc = m_mainframe.getBounds(); Rectangle rcthis = getBounds(); setBounds( (int) (rc.getWidth() - rcthis.getWidth()) / 2 + rc.x, (int) (rc.getHeight() - rcthis.getHeight()) / 2 + rc.y, (int) rcthis.getWidth(), (int) rcthis.getHeight()); super.setVisible(flag); }
@Override public void dropPerformed(CWidgetDropEvent event) { CandlestickWidget widget = event.getWidget(); Point loc = widget.getWidget().getLocation(); Rectangle sbounds = scene.getScene().getBounds(); Rectangle wbounds = widget.getWidget().getBounds(); double len = (sbounds.getHeight() - loc.y - wbounds.getHeight()) * point2pixel; FIHelper.add(widget.getCandlestick().instrument(), len); }
private static Rectangle fitToScreen( @NotNull Dimension newDim, @NotNull RelativePoint popupPosition, JTable table) { Rectangle rectangle = new Rectangle(popupPosition.getScreenPoint(), newDim); ScreenUtil.fitToScreen(rectangle); if (rectangle.getHeight() != newDim.getHeight()) { int newHeight = (int) rectangle.getHeight(); int roundedHeight = newHeight - newHeight % table.getRowHeight(); rectangle.setSize((int) rectangle.getWidth(), Math.max(roundedHeight, table.getRowHeight())); } return rectangle; }
/** * TODO summary sentence for worldToScreenTransform ... * * @param bounds * @param rectangle * @return */ public static AffineTransform worldToScreenTransform( BoundingBox mapExtent, Rectangle screenSize) { double scaleX = screenSize.getWidth() / mapExtent.getWidth(); double scaleY = screenSize.getHeight() / mapExtent.getHeight(); double tx = -mapExtent.getMinX() * scaleX; double ty = (mapExtent.getMinY() * scaleY) + screenSize.getHeight(); AffineTransform at = new AffineTransform(scaleX, 0.0d, 0.0d, -scaleY, tx, ty); return at; }
protected java.awt.Point adjustDrawPointToViewport( int x, int y, java.awt.geom.Rectangle2D bounds, java.awt.Rectangle viewport) { if (x + bounds.getMaxX() > viewport.getWidth()) x = (int) (viewport.getWidth() - bounds.getWidth()) - 1; else if (x < 0) x = 0; if (y + bounds.getMaxY() > viewport.getHeight()) y = (int) (viewport.getHeight() - bounds.getHeight()) - 1; else if (y < 0) y = 0; return new java.awt.Point(x, y); }
public void paintComponent(Graphics g) { Graphics2D g2 = (Graphics2D) g; Dimension d = getSize(); double w = d.getWidth(); double h = d.getHeight(); double ew = w; double eh = h; if (h > PROP * w) { eh = PROP * w; } else if (w > h / PROP) { ew = h / PROP; } int rw = (int) (ew * 0.80) - 1; int rx = (int) (ew - rw) - 1; if (left) { rx = (int) (w - rx - rw); } /* g.setColor(Color.RED); g.drawRect(0,0,(int)w,(int)h-1); g.setColor(Color.BLUE); g.drawRect(0,0,(int)ew,(int)eh-1); g.setColor(Color.BLACK); */ Rectangle s = new Rectangle(rx, 0, rw, (int) (eh * 0.70)); g2.setColor(background); g2.fill(s); g2.setColor(Color.BLACK); g2.draw(s); double ow = eh * 0.25; int ox = (int) (rx + (rw - ow) / 2); Rectangle o = new Rectangle(ox, (int) (eh * 0.73), (int) ow, (int) ow); g2.setColor(background); g2.fillOval((int) o.getX(), (int) o.getY(), (int) o.getWidth(), (int) o.getHeight()); g2.setColor(Color.BLACK); g2.drawOval((int) o.getX(), (int) o.getY(), (int) o.getWidth(), (int) o.getHeight()); }
/** Sets the displayed region to the whole board. */ public void zoom_all() { board_panel.board_handling.adjust_design_bounds(); java.awt.Rectangle display_rect = board_panel.get_viewport_bounds(); java.awt.Rectangle design_bounds = board_panel.board_handling.graphics_context.get_design_bounds(); double width_factor = display_rect.getWidth() / design_bounds.getWidth(); double height_factor = display_rect.getHeight() / design_bounds.getHeight(); double zoom_factor = Math.min(width_factor, height_factor); java.awt.geom.Point2D zoom_center = board_panel.board_handling.graphics_context.get_design_center(); board_panel.zoom(zoom_factor, zoom_center); java.awt.geom.Point2D new_vieport_center = board_panel.board_handling.graphics_context.get_design_center(); board_panel.set_viewport_center(new_vieport_center); }
@Override public boolean isContainedInSelection(Rectangle drawingViewSelection, double scale) { FGERectangle drawingViewBounds = new FGERectangle( drawingViewSelection.getX(), drawingViewSelection.getY(), drawingViewSelection.getWidth(), drawingViewSelection.getHeight(), Filling.FILLED); boolean isFullyContained = true; for (ControlArea<?> ca : getConnector().getControlAreas()) { if (ca instanceof ControlPoint) { ControlPoint cp = (ControlPoint) ca; Point cpInContainerView = convertLocalNormalizedPointToRemoteViewCoordinates( cp.getPoint(), getDrawingGraphicalRepresentation(), scale); FGEPoint preciseCPInContainerView = new FGEPoint(cpInContainerView.x, cpInContainerView.y); if (!drawingViewBounds.containsPoint(preciseCPInContainerView)) { // System.out.println("Going outside: point="+preciseCPInContainerView+" // bounds="+containerViewBounds); isFullyContained = false; } } } return isFullyContained; }
/** * Makes sure the current editor height matches its content if the annotation was never resized. * If the annotation has been manually resized before, does nothing. * * @param anno the annotation currently in the editor */ private void updateEditorHeight(final WorkflowAnnotation anno) { if (anno.wasResized()) { return; } Rectangle bounds = editPane.getBounds(); // height is either the pref height or the current height, depending on what is bigger int prefHeight; if (anno instanceof ProcessAnnotation) { prefHeight = (int) Math.max(getContentHeightOfEditor((int) bounds.getWidth()), bounds.getHeight()); } else { prefHeight = Math.max( getContentHeightOfEditor((int) bounds.getWidth()), OperatorAnnotation.MIN_HEIGHT); } Rectangle newBounds = new Rectangle( (int) bounds.getX(), (int) bounds.getY(), (int) bounds.getWidth(), prefHeight); if (!bounds.equals(newBounds)) { editPane.setBounds(newBounds); updateEditPanelPosition(newBounds, true); view.getModel().fireAnnotationMiscChanged(anno); } }
private void setSceneRasterStartAndStopTime(Product product) { final Product sourceProduct = getSourceProduct(); final ProductData.UTC startTime = sourceProduct.getStartTime(); final ProductData.UTC stopTime = sourceProduct.getEndTime(); final ProductSubsetDef subsetDef = getSubsetDef(); if (startTime != null && stopTime != null && subsetDef != null && subsetDef.getRegion() != null) { final double height = sourceProduct.getSceneRasterHeight(); final Rectangle region = subsetDef.getRegion(); final double regionY = region.getY(); final double regionHeight = region.getHeight(); final double dStart = startTime.getMJD(); final double dStop = stopTime.getMJD(); final double vPerLine = (dStop - dStart) / (height - 1); final double newStart = vPerLine * regionY + dStart; final double newStop = vPerLine * (regionHeight - 1) + newStart; product.setStartTime(new ProductData.UTC(newStart)); product.setEndTime(new ProductData.UTC(newStop)); } else { product.setStartTime(startTime); product.setEndTime(stopTime); } }
// ------------------------------ public void scrollToCaret() { // not called - fixed with putting visible scrollbars on JScrollPane // Rectangle rect1 = scroller1.getViewport().getViewRect(); double x1 = rect1.getX(); double y1 = rect1.getY(); double r1height = rect1.getHeight(); double r1width = rect1.getWidth(); Caret caret1 = editor1.getCaret(); Point pt2 = caret1.getMagicCaretPosition(); // the end of the string double x2 = pt2.getX(); double y2 = pt2.getY(); if (((x2 > x1) && (x2 < (x1 + r1width))) && ((y2 > y1) && (y2 < (y1 + r1height)))) { // inview } else { double newheight = r1height / 2; double newwidth = r1width / 2; double x3 = pt2.getX() - newwidth; double y3 = pt2.getY() - newheight; if (x3 < 0) x3 = 0; if (y3 < 0) y3 = 0; Rectangle rect3 = new Rectangle((int) x3, (int) y3, (int) newwidth, (int) newheight); editor1.scrollRectToVisible(rect3); } } // end scrollToCaret
/** {@inheritDoc } */ @Override public double[] getResolution(final CoordinateReferenceSystem crs) { if (CRS.equalsIgnoreMetadata(objectiveCRS, crs)) { return getResolution(); } else { final double[] res = new double[crs.getCoordinateSystem().getDimension()]; final Envelope env; try { env = CRS.transform(canvasObjectiveBBox2D, crs); final Rectangle2D canvasCRSBounds = new Rectangle2D.Double(0, 0, env.getSpan(0), env.getSpan(1)); res[0] = Math.abs(canvasCRSBounds.getWidth() / canvasDisplaybounds.getWidth()); res[1] = Math.abs(canvasCRSBounds.getHeight() / canvasDisplaybounds.getHeight()); for (int i = 2; i < res.length; i++) { // other dimension are likely to be the temporal and elevation one. // we set a hug resolution to ensure that only one slice of data will be retrived. res[i] = Double.MAX_VALUE; } } catch (TransformException ex) { LOGGER.log(Level.WARNING, null, ex); } catch (IllegalArgumentException ex) { LOGGER.log(Level.WARNING, null, ex); } catch (Exception ex) { LOGGER.log(Level.WARNING, null, ex); } return adjustResolutionWithDPI(res); } }
/** * Calculate the affine transforms used to convert between world and pixel coordinates. The * calculations here are very basic and assume a cartesian reference system. * * <p>Tne transform is calculated such that {@code envelope} will be centred in the display * * @param envelope the current map extent (world coordinates) * @param paintArea the current map pane extent (screen units) */ private void setTransforms(final Envelope envelope, final Rectangle paintArea) { ReferencedEnvelope refEnv = null; if (envelope != null) { refEnv = new ReferencedEnvelope(envelope); } else { refEnv = worldEnvelope(); // FIXME content.setCoordinateReferenceSystem(DefaultGeographicCRS.WGS84); } java.awt.Rectangle awtPaintArea = Utils.toAwtRectangle(paintArea); double xscale = awtPaintArea.getWidth() / refEnv.getWidth(); double yscale = awtPaintArea.getHeight() / refEnv.getHeight(); double scale = Math.min(xscale, yscale); double xoff = refEnv.getMedian(0) * scale - awtPaintArea.getCenterX(); double yoff = refEnv.getMedian(1) * scale + awtPaintArea.getCenterY(); worldToScreen = new AffineTransform(scale, 0, 0, -scale, -xoff, yoff); try { screenToWorld = worldToScreen.createInverse(); } catch (NoninvertibleTransformException ex) { ex.printStackTrace(); } }
/** * Loads the location/size of a frame from the properties file and positions the frame as * appropriate. * * @param frame the frame to position. * @param name the name of the property to load from */ public WindowPosition loadFrame(int windowID) { if (windowCoords == null) loadConfiguration(); WindowPosition result = windowCoords.get(windowID); if (result == null) { // invent default coordinates, using // http://java.sun.com/j2se/1.5.0/docs/api/java/awt/GraphicsDevice.html#getDefaultConfiguration() GraphicsEnvironment ge = GraphicsEnvironment.getLocalGraphicsEnvironment(); GraphicsDevice[] gs = ge.getScreenDevices(); int deviceToUse = Integer.valueOf(getProperty(G_PROPERTIES.GRAPHICS_MONITOR)); if (deviceToUse >= gs.length) deviceToUse = statechum.GlobalConfiguration .DEFAULT_SCREEN; // use the first one if cannot use the requested one. GraphicsConfiguration gc = gs[deviceToUse].getDefaultConfiguration(); // from http://java.sun.com/j2se/1.4.2/docs/api/index.html Rectangle shape = gc.getBounds(); Rectangle rect = new Rectangle(new Rectangle(shape.x, shape.y, 400, 300)); if (rect.height > shape.height) rect.height = shape.height; if (rect.width > shape.width) rect.width = shape.width; rect.y += windowID * (rect.getHeight() + 30); int yLimit = shape.height - rect.height; if (rect.y > yLimit) rect.y = yLimit; int xLimit = shape.width - rect.width; if (rect.x > xLimit) rect.x = xLimit; result = new WindowPosition(rect, deviceToUse); windowCoords.put(windowID, result); } return result; }
// ---------------------------------------------------------------- // Rationing ROI's // // ---------------------------------------------------------------- // public static void setAcqRoi(Rectangle roi) { acqRoi = roi; Prefs.usr.putInt("acqRatioRoi_X", (int) acqRoi.getX()); Prefs.usr.putInt("acqRatioRoi_Y", (int) acqRoi.getY()); Prefs.usr.putInt("acqRatioRoi_W", (int) acqRoi.getWidth()); Prefs.usr.putInt("acqRatioRoi_H", (int) acqRoi.getHeight()); }
/** * only a short version of toString() * * @return like S(0) [0,0, 1440x900] */ @Override public String toStringShort() { Rectangle r = getBounds(); return String.format( "S(%d)[%d,%d %dx%d]", curID, (int) r.getX(), (int) r.getY(), (int) r.getWidth(), (int) r.getHeight()); }
public void paintEntityLayer(final int layer, final long timestamp, final Graphics g) { final int w = getWidth(); final int h = getHeight(); Rectangle gClip = g.getClipBounds(); TRectangle wClip = new TRectangle( centerX + (gClip.getMinX() - w / 2) / scale, centerY + (gClip.getMinY() - h / 2) / scale, gClip.getWidth() / scale, gClip.getHeight() / scale); plane.eachEntity( wClip, layer << 1, (~layer << 1) & (0x7 << 1), new Iterated() { /** Position buffer */ double[] pbuf = new double[3]; @Override public void item(Object o) { AWTDrawableEntity e = (AWTDrawableEntity) o; e.getPosition(timestamp, pbuf); e.draw( (Graphics2D) g, (float) ((pbuf[0] - centerX) * scale + w / 2), (float) ((pbuf[1] - centerY) * scale + h / 2), (float) scale, (float) e.getRotation(timestamp), timestamp, layer); } }); }
public TaskbarPositionTest() { super("Use CTRL-down to show a JPopupMenu"); setContentPane(panel = createContentPane()); setJMenuBar(createMenuBar("1 - First Menu", true)); setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); // CTRL-down will show the popup. panel .getInputMap() .put(KeyStroke.getKeyStroke(KeyEvent.VK_DOWN, InputEvent.CTRL_MASK), "OPEN_POPUP"); panel.getActionMap().put("OPEN_POPUP", new PopupHandler()); pack(); Toolkit toolkit = Toolkit.getDefaultToolkit(); fullScreenBounds = new Rectangle(new Point(), toolkit.getScreenSize()); screenBounds = new Rectangle(new Point(), toolkit.getScreenSize()); // Place the frame near the bottom. This is a pretty wild guess. this.setLocation(0, (int) screenBounds.getHeight() - 2 * this.getHeight()); // Reduce the screen bounds by the insets. GraphicsConfiguration gc = this.getGraphicsConfiguration(); if (gc != null) { Insets screenInsets = toolkit.getScreenInsets(gc); screenBounds = gc.getBounds(); screenBounds.width -= (screenInsets.left + screenInsets.right); screenBounds.height -= (screenInsets.top + screenInsets.bottom); screenBounds.x += screenInsets.left; screenBounds.y += screenInsets.top; } setVisible(true); }
public void drawImage( final Graphics2D g2d, final Rectangle2D rectangle2d, ReportSubjectLocation location, boolean pixelateImages) throws KettleException { // Load the transformation // TransMeta transMeta = loadTransformation(location); Point min = transMeta.getMinimum(); Point area = transMeta.getMaximum(); int iconsize = 32; ScrollBarInterface bar = new ScrollBarInterface() { public void setThumb(int thumb) {} public int getSelection() { return 0; } }; // Paint the transformation... // Rectangle rect = new java.awt.Rectangle(0, 0, area.x, area.y); double magnificationX = rectangle2d.getWidth() / rect.getWidth(); double magnificationY = rectangle2d.getHeight() / rect.getHeight(); double magnification = Math.min(magnificationX, magnificationY); SwingGC gc = new SwingGC(g2d, rect, iconsize, 0, 0); gc.setDrawingPixelatedImages(pixelateImages); TransPainter painter = new TransPainter( gc, transMeta, area, bar, bar, null, null, null, new ArrayList<AreaOwner>(), new ArrayList<StepMeta>(), iconsize, 1, 0, 0, true, "FreeSans", 10); painter.setMagnification((float) Math.min(magnification, 1)); if (pixelateImages) { painter.setTranslationX(100 + min.x); painter.setTranslationY(100 + min.y); } painter.buildTransformationImage(); }
public static BufferedImage rotateImage(BufferedImage image, double theta) { int degrees = (int) Math.abs(Math.toDegrees(theta)); double xCenter = image.getWidth() / 2; double yCenter = image.getHeight() / 2; AffineTransform rotateTransform = AffineTransform.getRotateInstance(-theta, xCenter, yCenter); // Translation adjustments so image still centered after rotate width/height changes if (image.getHeight() != image.getWidth() && degrees != 180 && degrees != 0) { Point2D origin = new Point2D.Double(0.0, 0.0); origin = rotateTransform.transform(origin, null); double yTranslate = origin.getY(); Point2D yMax = new Point2D.Double(0, image.getHeight()); yMax = rotateTransform.transform(yMax, null); double xTranslate = yMax.getX(); AffineTransform translationAdjustment = AffineTransform.getTranslateInstance(-xTranslate, -yTranslate); rotateTransform.preConcatenate(translationAdjustment); } AffineTransformOp op = new AffineTransformOp(rotateTransform, AffineTransformOp.TYPE_BILINEAR); // Have to recopy image because of JDK bug #4723021, AffineTransformationOp throwing exception // sometimes image = copyImage(image, BufferedImage.TYPE_INT_ARGB); // Need to create filter dest image ourselves since AffineTransformOp's own dest image creation // throws exceptions in some cases. Rectangle bounds = op.getBounds2D(image).getBounds(); BufferedImage finalImage = new BufferedImage( (int) bounds.getWidth(), (int) bounds.getHeight(), BufferedImage.TYPE_INT_ARGB); return op.filter(image, finalImage); }
private boolean checkLayering(Area b) { ArrayList<Number> id = getVisible(); Vector<Rectangle> rects = new Vector<Rectangle>(id.size()); for (Number n : id) { rects.add(getIE().get(n).toRectangle()); } Rectangle r = b.toRectangle(); int index = 0; for (Rectangle rect : rects) { if (r.equals(rect)) { index = rects.indexOf(rect) + 1; } } for (int i = index; i < rects.size(); i++) { Rectangle rect = rects.get(i); if (r.intersects(rect)) { Rectangle isect = r.intersection(rect); isect.setRect(isect.x, isect.y, isect.getWidth() + 1, isect.getHeight() + 2); if (isect.contains(mascot.getAnchor())) { return false; } } } return true; }
public Rectangle makeDouble(Rectangle original) { // Double the width and height, leave x and y alone. return new Rectangle( (int) original.getX(), (int) original.getY(), (int) original.getWidth() * 2, (int) original.getHeight() * 2); }