/** * paintComponent which paints the component. Flips if Status is normalRotation. * * @param _graphics the graphics which are painted. */ @Override public final void paintComponent(final Graphics _graphics) { // initialize values Graphics2D g2d = (Graphics2D) _graphics; AffineTransform origXform = g2d.getTransform(); AffineTransform newXform = (AffineTransform) origXform.clone(); // center of rotation is center of the panel int xRot = this.getWidth() / 2; int yRot = this.getHeight() / 2; // fetch rotation from Status double rotation = 0; // if not normal rotation if (!State.isNormalRotation()) { final int filpRotation = 180; rotation = filpRotation; } // rotate the image and draw the image to panel newXform.rotate(Math.toRadians(rotation), xRot, yRot); g2d.setTransform(newXform); super.paintComponent(g2d); g2d.setTransform(origXform); }
/** * Renders an image on the device * * @param graphics the image location on the screen, x coordinate * @param x the image location on the screen, y coordinate * @param y the image * @param image DOCUMENT ME! * @param rotation the image rotatation * @param opacity DOCUMENT ME! */ private void renderImage( Graphics2D graphics, double x, double y, BufferedImage image, double rotation, float opacity) { if (LOGGER.isLoggable(Level.FINEST)) { LOGGER.finest("drawing Image @" + x + "," + y); } AffineTransform markAT = new AffineTransform(); markAT.translate(x, y); markAT.rotate(rotation); markAT.translate(-image.getWidth() / 2.0, -image.getHeight() / 2.0); graphics.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER, opacity)); Object interpolation = graphics.getRenderingHint(RenderingHints.KEY_INTERPOLATION); if (interpolation == null) { interpolation = RenderingHints.VALUE_INTERPOLATION_NEAREST_NEIGHBOR; } try { graphics.setRenderingHint( RenderingHints.KEY_INTERPOLATION, RenderingHints.VALUE_INTERPOLATION_BILINEAR); graphics.drawRenderedImage(image, markAT); } finally { graphics.setRenderingHint(RenderingHints.KEY_INTERPOLATION, interpolation); } }
@Override void nakresli() { vystreduj(); // Area a1 = new Area([triangle 0,0 => 8,0 => 0,8]); // Area a2 = new Area([triangle 0,0 => 8,0 => 8,8]); // a1.add(a2); final Area poly = new Area(new Polygon(new int[] {0, 1, 1, 5, 0}, new int[] {0, 1, 7, 7, 12}, 5)); final Area a = new Area(); final AffineTransform rotace = new AffineTransform(); rotace.rotate(Math.PI / 2); final AffineTransform zrcadlo = new AffineTransform(); zrcadlo.scale(1, -1); for (int i = 0; i < 4; i++) { a.transform(zrcadlo); a.add(poly); a.transform(zrcadlo); a.add(poly); a.transform(rotace); } g.setColor(Color.GREEN); g.fill(a); g.setColor(Color.BLACK); g.draw(a); }
@Override public void rotate(Point2D point, double theta) { final AffineTransform transform = new AffineTransform(); transform.rotate(theta, point.getX(), point.getY()); Point2D point2D = transform.transform(getLocation(), null); setLocation(point2D); }
// TODO currently allows for collisions if same name & different filetype public void loadImage(String path) { BufferedImage readImage = null; try { readImage = ImageIO.read(new File("images/" + path)); } catch (IOException e) { e.printStackTrace(); } if (readImage != null) { BufferedImage aImages[] = new BufferedImage[8]; BufferedImage image = new BufferedImage( readImage.getWidth(), readImage.getHeight(), BufferedImage.TYPE_INT_ARGB); Graphics g = image.getGraphics(); g.drawImage(readImage, 0, 0, null); for (int i = 0; i < 8; i++) { AffineTransform trans = new AffineTransform(); trans.translate(image.getWidth() / 2, image.getHeight() / 2); trans.rotate(Math.PI * i / 4.0); trans.translate(-image.getWidth() / 2, -image.getHeight() / 2); AffineTransformOp op = new AffineTransformOp(trans, AffineTransformOp.TYPE_BILINEAR); aImages[i] = new BufferedImage(image.getWidth(), image.getHeight(), BufferedImage.TYPE_INT_ARGB); op.filter(image, aImages[i]); } images.add( new Asset( path.substring(0, path.length() - 4), aImages)); // assumes standard 3 letter postfix } }
public void Draw(Graphics2D gr) { AffineTransform transform = new AffineTransform(); transform.rotate(Direction, x + width / 2, y + height / 2); transform.translate(x, y); switch (color) { case RED: gr.drawImage(image.getSubimage(0, 0, 50, 50), transform, null); break; case YELLOW: gr.drawImage(image.getSubimage(50, 0, 50, 50), transform, null); break; case PURPLE: gr.drawImage(image.getSubimage(100, 0, 50, 50), transform, null); break; case WHITE: gr.drawImage(image.getSubimage(150, 0, 50, 50), transform, null); break; case GREEN: gr.drawImage(image.getSubimage(200, 0, 50, 50), transform, null); break; case BLUE: gr.drawImage(image.getSubimage(250, 0, 50, 50), transform, null); break; } gun.Draw(gr); }
/** * Called by the dispatcher, tells its well to paint itself at the proper location. * * @param g - graphics to paint on * @param sF - scale factor from cm to pixels */ public void paint(Graphics g, double sF, boolean isRotated) { // get the graphics objects Graphics2D g2d = (Graphics2D) g; AffineTransform at = new AffineTransform(); // draw well's outline at.translate(parentPlate.getTLcorner().getX() * sF, parentPlate.getTLcorner().getY() * sF); if (isRotated) { at.translate(parentPlate.getPlateSpecs().getBorderDimensions().getY() * sF, 0); at.rotate(Math.PI / 2); } at.translate( (relativeLocation.getX() - diameter / 2) * sF, (relativeLocation.getY() - diameter / 2) * sF); at.scale(sF, sF); g2d.setTransform(at); g2d.setColor(Color.BLACK); g2d.drawOval(0, 0, (int) diameter, (int) diameter); // highlight well if it is selected if (isSelected) { g2d.setColor(Color.LIGHT_GRAY); g2d.fillOval(0, 0, (int) diameter, (int) diameter); } }
public void tree(Graphics2D g2d, double size, int phase) { g2d.setColor(colors[phase % 3]); new TextLayout(theT.toString(), theFont, g2d.getFontRenderContext()).draw(g2d, 0.0f, 0.0f); if (size > 10.0) { AffineTransform at = new AffineTransform(); at.setToTranslation(Twidth, -0.1); at.scale(0.6, 0.6); g2d.transform(at); size *= 0.6; new TextLayout(theR.toString(), theFont, g2d.getFontRenderContext()).draw(g2d, 0.0f, 0.0f); at.setToTranslation(Rwidth + 0.75, 0); g2d.transform(at); Graphics2D g2dt = (Graphics2D) g2d.create(); at.setToRotation(-Math.PI / 2.0); g2dt.transform(at); tree(g2dt, size, phase + 1); g2dt.dispose(); at.setToTranslation(.75, 0); at.rotate(-Math.PI / 2.0); at.scale(-1.0, 1.0); at.translate(-Twidth, 0); g2d.transform(at); tree(g2d, size, phase); } g2d.setTransform(new AffineTransform()); }
public void drawPoolOrLane(String name, int x, int y, int width, int height) { g.drawRect(x, y, width, height); // Add the name as text, vertical if (name != null && name.length() > 0) { // Include some padding int availableTextSpace = height - 6; // Create rotation for derived font AffineTransform transformation = new AffineTransform(); transformation.setToIdentity(); transformation.rotate(270 * Math.PI / 180); Font currentFont = g.getFont(); Font theDerivedFont = currentFont.deriveFont(transformation); g.setFont(theDerivedFont); String truncated = fitTextToWidth(name, availableTextSpace); int realWidth = fontMetrics.stringWidth(truncated); g.drawString( truncated, x + 2 + fontMetrics.getHeight(), 3 + y + availableTextSpace - (availableTextSpace - realWidth) / 2); g.setFont(currentFont); } }
private ImageData writeImageMjpeg(OutputStream os) throws IOException { final LimitFinder limitFinder = new LimitFinder(TextBlockUtils.getDummyStringBounder(), true); udrawable.drawU(limitFinder); final Dimension2D dim = new Dimension2DDouble( limitFinder.getMaxX() + 1 + margin1 + margin2, limitFinder.getMaxY() + 1 + margin1 + margin2); final File f = new File("c:/tmp.avi"); final int nbframe = 100; final MJPEGGenerator m = new MJPEGGenerator( f, getAviImage(null).getWidth(null), getAviImage(null).getHeight(null), 12.0, nbframe); for (int i = 0; i < nbframe; i++) { // AffineTransform at = AffineTransform.getRotateInstance(1.0); AffineTransform at = AffineTransform.getTranslateInstance(dim.getWidth() / 2, dim.getHeight() / 2); at.rotate(90.0 * Math.PI / 180.0 * i / 100); at.translate(-dim.getWidth() / 2, -dim.getHeight() / 2); // final AffineTransform at = AffineTransform.getTranslateInstance(i, 0); // final ImageIcon ii = new ImageIcon(getAviImage(at)); // m.addImage(ii.getImage()); throw new UnsupportedOperationException(); } m.finishAVI(); FileUtils.copyToStream(f, os); return new ImageDataSimple(dim); }
/** * A static method for drawing an image (adapted from my first assignment) * * @param x horizontal position * @param y vertical position * @param w the scaled image width * @param h the scaled image height * @param angle the angle of rotation of the image * @param hflip whether or not to flip the image horizontally * @param vflip whether or not to flip the image vertically * @param canvas the image to draw * @param screen the destination to render to */ public static void drawImage( double x, double y, double w, double h, double angle, boolean hflip, boolean vflip, BufferedImage canvas, Graphics2D screen) { AffineTransform oldTransform = screen.getTransform(); double widthRatio = (double) w / (double) canvas.getWidth(); double heightRatio = (double) h / (double) canvas.getHeight(); AffineTransform affine = new AffineTransform(); affine.translate(x, y); affine.scale(widthRatio, heightRatio); affine.scale((hflip ? -1 : 1) * 1.0, (vflip ? -1 : 1) * 1.0); affine.rotate(angle); affine.translate((double) -canvas.getWidth() / 2.0, (double) -canvas.getHeight() / 2.0); screen.transform(affine); screen.drawImage(canvas, 0, 0, null); screen.setTransform(oldTransform); }
protected Point rotateAboutCentre(Point target, double radians) { Point result = new Point(); AffineTransform rotation = new AffineTransform(); // 'tis affine transform, cap'n rotation.rotate(radians, this.centre.x, this.centre.y); rotation.transform(target, result); return result; }
private void paintScaledTriangle( Graphics g, double x, double y, double size, int direction, boolean isEnabled) { size = Math.max(size, 2); Path2D.Double path = new Path2D.Double(); path.moveTo(-size, size / 2); path.lineTo(size, size / 2); path.lineTo(0, -size / 2); path.closePath(); AffineTransform affineTransform = new AffineTransform(); affineTransform.rotate(Math.PI * (direction - 1) / 4); path.transform(affineTransform); Graphics2D g2d = (Graphics2D) g; double tx = x + size / 2; double ty = y + size / 2; g2d.translate(tx, ty); Color oldColor = g.getColor(); if (!isEnabled) { g2d.translate(1, 0); g2d.setColor(highlight); g2d.fill(path); g2d.translate(-1, 0); } g2d.setColor(isEnabled ? darkShadow : shadow); g2d.fill(path); g2d.translate(-tx, -ty); g2d.setColor(oldColor); }
public void update() { x += Math.cos(heading) * speed; y += Math.sin(heading) * speed; rect.setLocation((int) Math.round(x), (int) Math.round(y)); affineTransform.setToTranslation(x, y); affineTransform.rotate(heading + (Math.PI / 2)); }
public void test010() { final float width = 3; final float height = 0; final Point2D.Float zero = new Point2D.Float(0, 0); final Point2D.Float ch = new Point2D.Float(0, 2); final Point2D.Float cb = new Point2D.Float(0, -1); final float h = ch.y - cb.y; final float sca = width / h; AffineTransform mat = new AffineTransform(); mat.translate(width / 2, height / 2); mat.scale(sca, sca); mat.rotate(Math.PI / 2); mat.translate(0, -(ch.y + cb.y) / 2); final Point2D.Float cht = new Point2D.Float(0, 0); final Point2D.Float cbt = new Point2D.Float(0, 0); final Point2D.Float zerot = new Point2D.Float(0, 0); mat.transform(ch, cht); mat.transform(cb, cbt); mat.transform(zero, zerot); print("Hog :", cht); print("Back:", cbt); print("0,0 :", zerot); // assertEquals("", (float) 0, p.x, (float) 1e-1); // assertEquals("", (float) 0, p.y, (float) 1e-1); }
/** * Renders an image on the device * * @param tx the image location on the screen, x coordinate * @param ty the image location on the screen, y coordinate * @param img the image * @param rotation the image rotatation */ private static void renderImage( Graphics2D graphics, double x, double y, Image image, double rotation, float opacity) { AffineTransform temp = graphics.getTransform(); AffineTransform markAT = new AffineTransform(); Point2D mapCentre = new java.awt.geom.Point2D.Double(x, y); Point2D graphicCentre = new java.awt.geom.Point2D.Double(); temp.transform(mapCentre, graphicCentre); markAT.translate(graphicCentre.getX(), graphicCentre.getY()); double shearY = temp.getShearY(); double scaleY = temp.getScaleY(); double originalRotation = Math.atan(shearY / scaleY); markAT.rotate(rotation); graphics.setTransform(markAT); graphics.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER, opacity)); // we moved the origin to the centre of the image. graphics.drawImage(image, -image.getWidth(null) / 2, -image.getHeight(null) / 2, null); graphics.setTransform(temp); return; }
public void drawConditionalSequenceFlowIndicator(Line2D.Double line) { int horizontal = (int) (CONDITIONAL_INDICATOR_WIDTH * 0.7); int halfOfHorizontal = horizontal / 2; int halfOfVertical = CONDITIONAL_INDICATOR_WIDTH / 2; Polygon conditionalIndicator = new Polygon(); conditionalIndicator.addPoint(0, 0); conditionalIndicator.addPoint(-halfOfHorizontal, halfOfVertical); conditionalIndicator.addPoint(0, CONDITIONAL_INDICATOR_WIDTH); conditionalIndicator.addPoint(halfOfHorizontal, halfOfVertical); AffineTransform transformation = new AffineTransform(); transformation.setToIdentity(); double angle = Math.atan2(line.y2 - line.y1, line.x2 - line.x1); transformation.translate(line.x1, line.y1); transformation.rotate((angle - Math.PI / 2d)); AffineTransform originalTransformation = g.getTransform(); g.setTransform(transformation); g.draw(conditionalIndicator); Paint originalPaint = g.getPaint(); g.setPaint(CONDITIONAL_INDICATOR_COLOR); g.fill(conditionalIndicator); g.setPaint(originalPaint); g.setTransform(originalTransformation); }
public static BufferedImage rotateImage(BufferedImage img, int angle, Graphics2D g) { AffineTransform at = new AffineTransform(); at.rotate(Math.toRadians(angle), img.getWidth() / 2, img.getHeight() / 2); g.drawImage(img, at, null); return img; }
private static AffineTransform nonIdentityAffineTransform() { AffineTransform transf = new AffineTransform(); transf.translate(3.0, 5.0); transf.rotate(2.0); transf.scale(6.0, 7.0); transf.shear(3.5, 4.5); return transf; }
// Update the current AffineTransform private void updateAffineTransform() { affineTransform.setToIdentity(); affineTransform.translate(getWidth() * 0.5, getHeight() * 0.5); affineTransform.scale(scale, scale); affineTransform.translate(transX, transY); affineTransform.rotate(rotateAngle); affineTransform.translate(-modelCenter.x, -modelCenter.y); }
public AffineTransform getPixelToMapTransform() { AffineTransform transform = new AffineTransform(); transform.translate(getEasting(), getNorthing()); transform.scale(getPixelSizeX(), -getPixelSizeY()); transform.rotate(Math.toRadians(-getOrientation())); transform.translate(-getPixelX(), -getPixelY()); return transform; }
public static RenderedOp transformImage( RenderedImage image, double x0, double y0, double theta, double scale) { final AffineTransform transform = new AffineTransform(); transform.rotate(theta, -0.5f * image.getWidth(), -0.5f * image.getHeight()); transform.scale(scale, scale); transform.translate(x0, y0); return transformImage(image, transform); }
public static AffineTransform makeComplexAT() { AffineTransform at = new AffineTransform(); at.scale(2.5, -3.0); at.rotate(Math.PI / 4.0); at.shear(1.0, -3.0); at.translate(25.0, 12.5); return at; };
/** * Returns the contour of the ellipse. * * @return A new {@code GeneralPath} object containing the contour of the ellipse. */ public GeneralPath contour() { final GeneralPath gp = new GeneralPath(new Ellipse2D.Double(x - major, y - minor, 2 * major, 2 * minor)); final AffineTransform at = new AffineTransform(); at.rotate(angle, x, y); gp.transform(at); return gp; }
public void render(Graphics g) { Graphics2D g2 = (Graphics2D) g; AffineTransform xform = new AffineTransform(); xform.setTransform(identity); xform.translate(getVector().getX(), getVector().getY()); xform.rotate(getVector().getBearing() + Math.PI / 2, 3, 3); g2.drawImage(sprite, xform, null); }
public void drawProjectile(Graphics2D g2d) { AffineTransform trans = new AffineTransform(); trans.rotate(rotation, x, y); trans.translate(15, 0); g2d.setTransform(trans); g2d.drawImage(texture, (int) (x) + 5, (int) (y) - sY / 2, (int) sX, sY, null); }
/** * @param drop * @param i * @return */ public static BufferedImage rotate(final BufferedImage src, final int degree) { final int w = src.getWidth(null); final int h = src.getHeight(null); // final Graphics2D g = image.createGraphics(); // g.setRenderingHint(RenderingHints.KEY_ANTIALIASING, // RenderingHints.VALUE_ANTIALIAS_ON); final AffineTransform at = new AffineTransform(); at.rotate(degree * Math.PI / 180.0); Point2D p2din, p2dout; p2din = new Point2D.Double(0.0, 0.0); p2dout = at.transform(p2din, null); double ytrans = p2dout.getY(); double xtrans = p2dout.getX(); p2din = new Point2D.Double(0, h); p2dout = at.transform(p2din, null); ytrans = Math.min(ytrans, p2dout.getY()); xtrans = Math.min(xtrans, p2dout.getX()); p2din = new Point2D.Double(w, h); p2dout = at.transform(p2din, null); ytrans = Math.min(ytrans, p2dout.getY()); xtrans = Math.min(xtrans, p2dout.getX()); p2din = new Point2D.Double(w, 0); p2dout = at.transform(p2din, null); ytrans = Math.min(ytrans, p2dout.getY()); xtrans = Math.min(xtrans, p2dout.getX()); final AffineTransform tat = new AffineTransform(); tat.translate(-xtrans, -ytrans); at.preConcatenate(tat); final AffineTransformOp bio = new AffineTransformOp(at, AffineTransformOp.TYPE_BILINEAR); final Rectangle r = bio.getBounds2D(src).getBounds(); BufferedImage image = new BufferedImage(r.width, r.height, BufferedImage.TYPE_INT_ARGB); image = bio.filter(src, image); // final Graphics g = image.getGraphics(); // g.setColor(Color.RED); // g.drawRect(0, 0, image.getWidth() - 1, image.getHeight() - 1); // g.dispose(); // try { // Dialog.getInstance().showConfirmDialog(0, "", "", new // ImageIcon(image), null, null); // } catch (final DialogClosedException e) { // // TODO Auto-generated catch block // e.printStackTrace(); // } catch (final DialogCanceledException e) { // // TODO Auto-generated catch block // e.printStackTrace(); // } return image; }
// Function to rotate spaceship using direction (left/right) public void rotate(int direction) { rotateAngle += direction * ANGLE; rotateAngle = rotateAngle % 360; double locationX = imageWidth / 2; double locationY = imageHeight / 2; this.angle = Math.toRadians(rotateAngle); tx.rotate(angle); tx = AffineTransform.getRotateInstance(angle, locationX, locationY); op = new AffineTransformOp(tx, AffineTransformOp.TYPE_BILINEAR); }
/** * Rotate the current transform over the Z-axis. Calls writeTransform(Transform). Rotating with a * positive angle theta rotates points on the positive x axis toward the positive y axis. * * @param theta radians over which to rotate */ public void rotate(double theta) { currentTransform.rotate(theta); try { writeTransform( new AffineTransform( Math.cos(theta), Math.sin(theta), -Math.sin(theta), Math.cos(theta), 0, 0)); } catch (IOException e) { handleException(e); } }
protected AffineTransform getArrowTrans( double sx, double sy, double ex, double ey, double width, double theta) { m_arrowTrans.setToTranslation(ex, ey); m_arrowTrans.rotate(-HALF_PI + theta + Math.atan2(ey - sy, ex - sx)); if (width > m_width) { double scalar = width / 3; m_arrowTrans.scale(scalar, scalar); } return m_arrowTrans; }