/** * Write the given text string in the current font, centered on (x, y) and rotated by the * specified number of degrees * * @param x the center x-coordinate of the text * @param y the center y-coordinate of the text * @param s the text * @param degrees is the number of degrees to rotate counterclockwise */ public static void text(double x, double y, String s, double degrees) { double xs = scaleX(x); double ys = scaleY(y); offscreen.rotate(Math.toRadians(-degrees), xs, ys); text(x, y, s); offscreen.rotate(Math.toRadians(+degrees), xs, ys); }
public static LatLonPoint getLatLonForPixel( double startLat, double startLon, double differenceX, double differenceY, float scale) { double startY = 20925.5249D * Math.toRadians(startLat); double startX = 20925.5249D * Math.cos(Math.toRadians(startLat)) * Math.toRadians(startLon); differenceX /= scale; differenceY /= scale; double endX = differenceX / 1000D + startX; double endY = (differenceY / 1000D - startY) * -1D; double endLat = Math.toDegrees(endY / 20925.5249D); double endLon = Math.toDegrees(endX / (20925.5249D * Math.cos(Math.toRadians(startLat)))); return new LatLonPoint(endLat, endLon); }
public void loseCoins() { int x = player1.getX(); int y = player1.getY(); double losePercentage = 0.1; for (int i = 0; i < (int) coins * losePercentage; i++) { // makes the user lose 10 percent of the coin and draws them in a circle // System.out.println(i); int xPos = x + (int) (100 * Math.cos(Math.toRadians((360 / (coins * losePercentage)) * i))); int yPos = y - (int) (100 * Math.sin(Math.toRadians((360 / (coins * losePercentage)) * i))); coinList.add(new Coin(xPos, yPos, 3)); } coins -= (int) (coins * losePercentage); }
/* CALCULATE COORDINATES: Determine new x-y coords given a start x-y and a distance and direction */ public static void calcCoords(int index, int x, int y, double dist, double dirn) { while (dirn < 0.0) dirn = 360.0 + dirn; while (dirn > 360.0) dirn = dirn - 360.0; // System.out.println("dirn = " + dirn); // North-East if (dirn <= 90.0) { xValues[index] = x + (int) (Math.sin(Math.toRadians(dirn)) * dist); yValues[index] = y - (int) (Math.cos(Math.toRadians(dirn)) * dist); return; } // South-East if (dirn <= 180.0) { xValues[index] = x + (int) (Math.cos(Math.toRadians(dirn - 90)) * dist); yValues[index] = y + (int) (Math.sin(Math.toRadians(dirn - 90)) * dist); return; } // South-West if (dirn <= 90.0) { xValues[index] = x - (int) (Math.sin(Math.toRadians(dirn - 180)) * dist); yValues[index] = y + (int) (Math.cos(Math.toRadians(dirn - 180)) * dist); } // Nort-West else { xValues[index] = x - (int) (Math.cos(Math.toRadians(dirn - 270)) * dist); yValues[index] = y - (int) (Math.sin(Math.toRadians(dirn - 270)) * dist); } }
@Override public void draw(GFX gfx) { float[] curr = toHSB(color); float[] start = toHSB(startColor); // hue, vertical gfx.translate(centerPoint.getX(), centerPoint.getY()); for (double i = 0; i < 200; i++) { FlatColor c = FlatColor.hsb(i / 200 * 360.0, curr[1], curr[2]); gfx.setPaint(c); double y = start[0] * 200; gfx.drawLine(-5, i - y, +5, i - y); } gfx.translate(-centerPoint.getX(), -centerPoint.getY()); // saturation, 30 degrees gfx.translate(centerPoint.getX(), centerPoint.getY()); for (double i = 0; i < 200; i++) { FlatColor c = FlatColor.hsb(curr[0] * 360, i / 200.0, curr[2]); gfx.setPaint(c); double sin = Math.sin(Math.toRadians(30)); double cos = Math.cos(Math.toRadians(30)); double x = cos * i - cos * start[1] * 200 + 0; double y = sin * i - sin * start[1] * 200 + 0; // tx = cos(30)*i // tx/cos(30) = i gfx.drawLine(x, y - 5, x, y + 5); } gfx.translate(-centerPoint.getX(), -centerPoint.getY()); // brightness, 150 degrees gfx.translate(centerPoint.getX(), centerPoint.getY()); for (double i = 0; i < 200; i++) { FlatColor c = FlatColor.hsb(curr[0] * 360, curr[1], i / 200.0); gfx.setPaint(c); double sin = Math.sin(Math.toRadians(150)); double cos = Math.cos(Math.toRadians(150)); double x = cos * i - cos * start[2] * 200; double y = sin * i - sin * start[2] * 200; gfx.drawLine(x, y - 5, x, y + 5); } gfx.translate(-centerPoint.getX(), -centerPoint.getY()); gfx.setPaint(color); double s = 16; gfx.fillOval(centerPoint.getX() - s / 2, centerPoint.getY() - s / 2, s, s); gfx.setPaint(FlatColor.BLACK); gfx.drawOval(centerPoint.getX() - s / 2, centerPoint.getY() - s / 2, s, s); gfx.drawRect(0, 0, getWidth(), getHeight()); }
/** * Draw picture (gif, jpg, or png) centered on (x, y), rotated given number of degrees * * @param x the center x-coordinate of the image * @param y the center y-coordinate of the image * @param s the name of the image/picture, e.g., "ball.gif" * @param degrees is the number of degrees to rotate counterclockwise * @throws RuntimeException if the image is corrupt */ public static void picture(double x, double y, String s, double degrees) { Image image = getImage(s); double xs = scaleX(x); double ys = scaleY(y); int ws = image.getWidth(null); int hs = image.getHeight(null); if (ws < 0 || hs < 0) throw new RuntimeException("image " + s + " is corrupt"); offscreen.rotate(Math.toRadians(-degrees), xs, ys); offscreen.drawImage( image, (int) Math.round(xs - ws / 2.0), (int) Math.round(ys - hs / 2.0), null); offscreen.rotate(Math.toRadians(+degrees), xs, ys); draw(); }
public static void renderAngleRotatedTexturedRect( Vector3 renderOffset, Vector3 axis, double angleRad, double scale, double u, double v, double uLength, double vLength, float partialTicks) { GL11.glPushMatrix(); removeStandartTranslationFromTESRMatrix(partialTicks); Vector3 renderStart = axis.clone().perpendicular().rotate(angleRad, axis).normalize(); Tessellator tes = Tessellator.getInstance(); VertexBuffer buf = tes.getBuffer(); buf.begin(GL11.GL_QUADS, DefaultVertexFormats.POSITION_TEX); Vector3 vec = renderStart .clone() .rotate(Math.toRadians(90), axis) .normalize() .multiply(scale) .add(renderOffset); buf.pos(vec.getX(), vec.getY(), vec.getZ()).tex(u, v + vLength).endVertex(); vec = renderStart.clone().multiply(-1).normalize().multiply(scale).add(renderOffset); buf.pos(vec.getX(), vec.getY(), vec.getZ()).tex(u + uLength, v + vLength).endVertex(); vec = renderStart .clone() .rotate(Math.toRadians(270), axis) .normalize() .multiply(scale) .add(renderOffset); buf.pos(vec.getX(), vec.getY(), vec.getZ()).tex(u + uLength, v).endVertex(); vec = renderStart.clone().normalize().multiply(scale).add(renderOffset); buf.pos(vec.getX(), vec.getY(), vec.getZ()).tex(u, v).endVertex(); tes.draw(); GL11.glPopMatrix(); }
public void createPolygonRenderer() { // make the view window the entire screen viewWindow = new ViewWindow(0, 0, screen.getWidth(), screen.getHeight(), (float) Math.toRadians(75)); Transform3D camera = new Transform3D(); polygonRenderer = new BSPRenderer(camera, viewWindow); }
public Image rotateImage(Image tilePiece, int degree) { ImageIcon icon = new ImageIcon(tilePiece); BufferedImage blankCanvas = new BufferedImage(80, 80, BufferedImage.TYPE_INT_ARGB); Graphics2D g2 = (Graphics2D) blankCanvas.getGraphics(); g2.rotate(Math.toRadians(degree), 40, 40); g2.drawImage(tilePiece, 0, 0, this); return blankCanvas; }
/** * Called back immediately after the OpenGL context is initialized. Can be used to perform * one-time initialization. Run only once. */ @Override public void init(GLAutoDrawable drawable) { GL2 gl = drawable.getGL().getGL2(); // get the OpenGL graphics context glu = new GLU(); // get GL Utilities gl.glClearColor(0.0f, 0.0f, 0.0f, 0.0f); // set background (clear) color gl.glClearDepth(1.0f); // set clear depth value to farthest gl.glEnable(GL_DEPTH_TEST); // enables depth testing gl.glDepthFunc(GL_LEQUAL); // the type of depth test to do gl.glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST); // best perspective correction gl.glShadeModel(GL_SMOOTH); // blends colors nicely, and smoothes out lighting // Load the texture image try { // Create a OpenGL Texture object from (URL, mipmap, file suffix) // Use URL so that can read from JAR and disk file. texture = TextureIO.newTexture( this.getClass().getResource(textureFileName), false, textureFileType); } catch (GLException e) { e.printStackTrace(); } catch (IOException e) { e.printStackTrace(); } // Use linear filter for texture if image is larger than the original texture gl.glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); // Use linear filter for texture if image is smaller than the original texture gl.glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); // Texture image flips vertically. Shall use TextureCoords class to retrieve // the top, bottom, left and right coordinates, instead of using 0.0f and 1.0f. TextureCoords textureCoords = texture.getImageTexCoords(); textureTop = textureCoords.top(); textureBottom = textureCoords.bottom(); // textureLeft = textureCoords.left(); // textureRight = textureCoords.right(); // Enable the texture texture.enable(gl); // gl.glEnable(GL_TEXTURE_2D); // we want back facing polygons to be filled completely and that we want front // facing polygons to be outlined only. gl.glPolygonMode(GL_BACK, GL_FILL); // Back Face Is Filled In gl.glPolygonMode(GL_FRONT, GL_LINE); // Front Face Is Drawn With Lines for (int x = 0; x < numPoints; x++) { // Loop Through The Y Plane for (int y = 0; y < numPoints; y++) { // Apply The Wave To Our Mesh // xmax is 45. Get 9 after dividing by 5. Subtract 4.5 to centralize. points[x][y][0] = (float) x / 5.0f - 4.5f; points[x][y][1] = (float) y / 5.0f - 4.5f; // Sine wave pattern points[x][y][2] = (float) (Math.sin(Math.toRadians(x / 5.0f * 40.0f))); } } }
private void loopRotation() { if (previewRotation < 0) { previewRotation = Math.toRadians(270); } else if (previewRotation >= 2 * Math.PI) { previewRotation = 0; } if (structurePreview.getWidth() == 1 && structurePreview.getHeight() == 1) { previewRotation = 0; } }
public BufferedImage rotate90(BufferedImage img) { int w = img.getWidth(); int h = img.getHeight(); BufferedImage dimg = new BufferedImage(h, w, img.getType()); Graphics2D g = dimg.createGraphics(); g.translate((h - w) / 2, (w - h) / 2); g.rotate(Math.toRadians(90), w / 2, h / 2); g.drawImage(img, null, 0, 0); g.dispose(); return dimg; }
/** * Draw picture (gif, jpg, or png) centered on (x, y), rotated given number of degrees, rescaled * to w-by-h. * * @param x the center x-coordinate of the image * @param y the center y-coordinate of the image * @param s the name of the image/picture, e.g., "ball.gif" * @param w the width of the image * @param h the height of the image * @param degrees is the number of degrees to rotate counterclockwise * @throws RuntimeException if the image is corrupt */ public static void picture(double x, double y, String s, double w, double h, double degrees) { Image image = getImage(s); double xs = scaleX(x); double ys = scaleY(y); double ws = factorX(w); double hs = factorY(h); if (ws < 0 || hs < 0) throw new RuntimeException("image " + s + " is corrupt"); if (ws <= 1 && hs <= 1) pixel(x, y); offscreen.rotate(Math.toRadians(-degrees), xs, ys); offscreen.drawImage( image, (int) Math.round(xs - ws / 2.0), (int) Math.round(ys - hs / 2.0), (int) Math.round(ws), (int) Math.round(hs), null); offscreen.rotate(Math.toRadians(+degrees), xs, ys); draw(); }
public void paintComponent(Graphics g) { super.paintComponent(g); Graphics2D g2 = (Graphics2D) g; RenderingHints hints = new RenderingHints(null); hints.put(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON); hints.put(RenderingHints.KEY_INTERPOLATION, RenderingHints.VALUE_INTERPOLATION_BICUBIC); hints.put(RenderingHints.KEY_RENDERING, RenderingHints.VALUE_RENDER_QUALITY); g2.setRenderingHints(hints); g2.rotate(-Math.toRadians(degrees), w / 2, h / 2); g2.drawImage(dimg, 0, 0, this); g2.dispose(); }
// ----------------------------------------------------------------- // Draws the fractal recursively. Base case is an order of 1 for // which a simple straight line is drawn. Otherwise three // intermediate points are computed, and each line segment is // drawn as a fractal. // ----------------------------------------------------------------- public void branch(Graphics2D g2, Double x, Double y, Double length, Double angle, int order) { // g2.draw(Line2D.Double() line = new Line2D.Double()); double angle1 = angle + bangle; double angle2 = angle - bangle; double angle3 = angle + 180; length = length * bfrac; double endX1 = (x - length * Math.sin(Math.toRadians(angle1))); double endY1 = (y - length * Math.cos(Math.toRadians(angle1))); double endX2 = (x - length * Math.sin(Math.toRadians(angle2))); double endY2 = (y - length * Math.cos(Math.toRadians(angle2))); double endX3 = (x - length * Math.sin(Math.toRadians(angle3))); double endY3 = (y - length * Math.cos(Math.toRadians(angle3))); g2.draw(new Line2D.Double(x, y, endX1, endY1)); g2.draw(new Line2D.Double(x, y, endX2, endY2)); g2.draw(new Line2D.Double(x, y, endX3, endY3)); if (order == 1) g2.draw(new Line2D.Double(x, y, x, y - length)); else { branch(g2, endX1, endY1, length, angle1, order - 1); branch(g2, endX2, endY2, length, angle2, order - 1); // branch (g2, endX3, endY3, length, angle3, order-1 ); } }
@Override public void draw(Graphics2D g) { AffineTransform save = g.getTransform(); super.draw(g); int localx = -width / 2; int localy = -height / 2; if (isPlayer) g.setColor(Color.BLUE); if (isSelected) { g.fillRect(localx, localy, width, height); } else { g.drawRect(localx, localy, width, height); } int direction = this.getDirection(); g.setColor(Color.RED); g.drawOval(0 - (size / 2), 0 - (size / 2), (int) size, (int) size); dx = ((double) Math.cos(Math.toRadians(90 - direction)) * width); dy = ((double) Math.sin(Math.toRadians(90 - direction)) * height); g.setColor(Color.black); g.drawLine(0, 0, 0, 20); g.setTransform(save); }
void draw(Graphics2D g) { // toX/toY is tip of arrow and fx/fy is a point on the line - // fx/fy is used to determine direction & angle AffineTransform at = AffineTransform.getTranslateInstance(toX, toY); int b = 9; double theta = Math.toRadians(20); // The idea of using a GeneralPath is so we can // create the (three lines that make up the) arrow // (only) one time and then use AffineTransform to // place it anywhere we want. GeneralPath path = new GeneralPath(); // distance between line and the arrow mark <** not ** // Start a new line segment from the position of (0,0). path.moveTo(0, 0); // Create one of the two arrow head lines. int x = (int) (-b * Math.cos(theta)); int y = (int) (b * Math.sin(theta)); path.lineTo(x, y); // distance between line and the arrow mark <** not ** // Make the other arrow head line. int x2 = (int) (-b * Math.cos(-theta)); int y2 = (int) (b * Math.sin(-theta)); // path.moveTo(0,0); path.lineTo(x2, y2); path.closePath(); // theta is in radians double s, t; s = toY - fy; // calculate slopes. t = toX - fx; if (t != 0) { s = s / t; theta = Math.atan(s); if (t < 0) theta += Math.PI; } else if (s < 0) theta = -(Math.PI / 2); else theta = Math.PI / 2; at.rotate(theta); // at.rotate(theta,toX,toY); Shape shape = at.createTransformedShape(path); if (checkStatus == Status.UNCHECKED) g.setColor(Color.BLACK); else if (checkStatus == Status.COMPATIBLE) g.setColor(FOREST_GREEN); else g.setColor(ORANGE_RED); g.fill(shape); g.draw(shape); }
private static LinkedList<Point2D> getCirclePoints( double centerLat, double centerLong, int numberOfPoints, double radius) { LinkedList<Point2D> Point2Ds = new LinkedList<Point2D>(); double lat1, long1; double d_rad; double delta_pts; double radial, lat_rad, dlon_rad, lon_rad; // convert coordinates to radians lat1 = Math.toRadians(centerLat); long1 = Math.toRadians(centerLong); // radius is in meters d_rad = radius / 6378137; // loop through the array and write points for (int i = 0; i <= numberOfPoints; i++) { delta_pts = 360 / (double) numberOfPoints; radial = Math.toRadians((double) i * delta_pts); // This algorithm is limited to distances such that dlon < pi/2 lat_rad = Math.asin( Math.sin(lat1) * Math.cos(d_rad) + Math.cos(lat1) * Math.sin(d_rad) * Math.cos(radial)); dlon_rad = Math.atan2( Math.sin(radial) * Math.sin(d_rad) * Math.cos(lat1), Math.cos(d_rad) - Math.sin(lat1) * Math.sin(lat_rad)); lon_rad = ((long1 + dlon_rad + Math.PI) % (2 * Math.PI)) - Math.PI; Point2Ds.add(new Point2D.Double(Math.toDegrees(lat_rad), Math.toDegrees(lon_rad))); } return Point2Ds; }
public void flecha(Graphics papel, int x1, int y1, int x2, int y2) { double ang = 0.0, angSep = 0.0; double tx = 0, ty = 0; int dist = 0; Point punto1 = null, punto2 = null; punto2 = new Point(x1, y1); punto1 = new Point(x2, y2); dist = 15; ty = -(punto1.y - punto2.y) * 1.0; tx = (punto1.x - punto2.x) * 1.0; ang = Math.atan(ty / tx); if (tx < 0) ang += Math.PI; Point p1 = new Point(), p2 = new Point(), punto = punto2; angSep = 25.0; p1.x = (int) (punto.x + dist * Math.cos(ang - Math.toRadians(angSep))); p1.y = (int) (punto.y - dist * Math.sin(ang - Math.toRadians(angSep))); p2.x = (int) (punto.x + dist * Math.cos(ang + Math.toRadians(angSep))); p2.y = (int) (punto.y - dist * Math.sin(ang + Math.toRadians(angSep))); Graphics2D g2D = (Graphics2D) papel; papel.setColor(Color.black); g2D.setStroke(new BasicStroke(1.2f)); papel.drawLine(punto1.x, punto1.y, punto.x, punto.y); int x[] = {p1.x, punto.x, p2.x}; int y[] = {p1.y, punto.y, p2.y}; Polygon myTri = new Polygon(x, y, 3); papel.setColor(Color.BLACK); papel.drawPolygon(myTri); papel.fillPolygon(myTri); }
public void paintLogo(Component c, Graphics g, int x, int y, int w, int h) { if (hasLogo(c)) { Graphics2D g2D = (Graphics2D) g; Font savedFont = g2D.getFont(); g.setFont(logoFont); FontMetrics fm = JTattooUtilities.getFontMetrics((JComponent) c, g, c.getFont()); String logo = JTattooUtilities.getClippedText( AbstractLookAndFeel.getTheme().getLogoString(), fm, h - 16); AffineTransform savedTransform = g2D.getTransform(); Color fc = getLogoColorHi(); Color bc = getLogoColorLo(); if (JTattooUtilities.isLeftToRight(c)) { g2D.translate(fm.getAscent() + 1, h - shadowSize - 4); g2D.rotate(Math.toRadians(-90)); g2D.setColor(bc); JTattooUtilities.drawString((JComponent) c, g, logo, 0, 1); g2D.setColor(fc); JTattooUtilities.drawString((JComponent) c, g, logo, 1, 0); } else { g2D.translate(w - shadowSize - 4, h - shadowSize - 4); g2D.rotate(Math.toRadians(-90)); g2D.setColor(bc); JTattooUtilities.drawString((JComponent) c, g, logo, 0, 1); g2D.setColor(fc); JTattooUtilities.drawString((JComponent) c, g, logo, 1, 0); } g2D.setTransform(savedTransform); g2D.setFont(savedFont); } }
protected void paintComponent(Graphics g) { super.paintComponent(g); Graphics2D g2d = (Graphics2D)g; 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; newXform.rotate(Math.toRadians(currentAngle), xRot, yRot); g2d.setTransform(newXform); //draw image centered in panel int x = (getWidth() - image.getWidth(this))/2; int y = (getHeight() - image.getHeight(this))/2; g2d.drawImage(image, x, y, this); g2d.setTransform(origXform); }
public static java.awt.geom.Point2D.Float getPixelsBetweenPoints( double startLat, double startLon, double endLat, double endLon, float scale) { double startY = 20925.5249D * Math.toRadians(startLat); double endY = 20925.5249D * Math.toRadians(endLat); double differenceY = (startY - endY) * 1000D; double startX = 20925.5249D * Math.cos(Math.toRadians(startLat)) * Math.toRadians(startLon); double endX = 20925.5249D * Math.cos(Math.toRadians(startLat)) * Math.toRadians(endLon); double differenceX = (endX - startX) * 1000D; return new java.awt.geom.Point2D.Float( (float) differenceX * scale, (float) (differenceY * (double) scale)); }
public static double getDistanceBetweenLatLons( double lat1, double lon1, double lat2, double lon2) { double dLat = lat2 - lat1; double dLon = lon2 - lon1; double a = Math.sin(Math.toRadians(dLat) / 2D) * Math.sin(Math.toRadians(dLat) / 2D) + Math.cos(Math.toRadians(lat1)) * Math.cos(Math.toRadians(lat2)) * Math.sin(Math.toRadians(dLon) / 2D) * Math.sin(Math.toRadians(dLon) / 2D); return 12742D * Math.atan2(Math.sqrt(a), Math.sqrt(1.0D - a)); }
public static java.awt.geom.Point2D.Float rotatePoint( java.awt.geom.Point2D.Float centerPoint, java.awt.geom.Point2D.Float point, float angle) { double radius = Math.sqrt(Math.pow(point.x - centerPoint.x, 2D) + Math.pow(point.y - centerPoint.y, 2D)); double angleB1 = Math.toDegrees(Math.acos((double) (point.x - centerPoint.x) / radius)); double x; double y; if (point.x <= centerPoint.x && point.y <= centerPoint.y) { x = (double) centerPoint.x + radius * Math.cos(Math.toRadians(angleB1 - (double) angle)); y = (double) centerPoint.y - radius * Math.sin(Math.toRadians(angleB1 - (double) angle)); } else if (point.x > centerPoint.x && point.y <= centerPoint.y) { x = (double) centerPoint.x + radius * Math.cos(Math.toRadians(angleB1 - (double) angle)); y = (double) centerPoint.y - radius * Math.sin(Math.toRadians(angleB1 - (double) angle)); } else if (point.x > centerPoint.x && point.y > centerPoint.y) { x = (double) centerPoint.x + radius * Math.cos(Math.toRadians(angleB1 + (double) angle)); y = (double) centerPoint.y + radius * Math.sin(Math.toRadians(angleB1 + (double) angle)); } else { x = (double) centerPoint.x + radius * Math.cos(Math.toRadians(angleB1 + (double) angle)); y = (double) centerPoint.y + radius * Math.sin(Math.toRadians(angleB1 + (double) angle)); } return new java.awt.geom.Point2D.Float((float) x, (float) y); }
public Enemy(int type, int rank) { this.type = type; this.rank = rank; switch (rank) { case (1): color = Color.GREEN; switch (rank) { case (1): x = Math.random() * GamePanel.WIDTH; y = 0; r = 7; speed = 2; health = 2; double angle = Math.toRadians(Math.random() * 360); dx = Math.sin(angle) * speed; dy = Math.cos(angle) * speed; } } }
private Tile[] rotate(int angle) { Tile[] newTiles = new Tile[4 * 4]; int offsetX = 3, offsetY = 3; if (angle == 90) { offsetY = 0; } else if (angle == 270) { offsetX = 0; } double rad = Math.toRadians(angle); int cos = (int) Math.cos(rad); int sin = (int) Math.sin(rad); for (int x = 0; x < 4; x++) { for (int y = 0; y < 4; y++) { int newX = (x * cos) - (y * sin) + offsetX; int newY = (x * sin) + (y * cos) + offsetY; newTiles[(newX) + (newY) * 4] = tileAt(x, y); } } return newTiles; }
/** * Paint the component. * * @param g The graphics context for painting * @see javax.swing.JComponent#paintComponent(java.awt.Graphics) */ protected void paintComponent(Graphics g) { Graphics2D g2 = (Graphics2D) g; fRenderer.paintComponent(g2, fButtonDelegate, this, 0, 0, getWidth(), getHeight(), true); ButtonModel model = getModel(); boolean doOffset = model.isPressed() && model.isArmed(); int offsetAmount = UIManager.getInt("Button.textShiftOffset"); double degrees = Math.toRadians(-90); if (fRotation == LEFT) { int h = getHeight(); g2.translate(0, h); g2.rotate(degrees); if (doOffset) { g2.translate(-offsetAmount, offsetAmount); } fRenderer.paintComponent(g2, fLabelDelegate, this, 0, 0, getHeight(), getWidth(), true); if (doOffset) { g2.translate(offsetAmount, -offsetAmount); } g2.rotate(-degrees); g2.translate(0, -h); } else { int w = getWidth(); g2.translate(w, 0); g2.rotate(-degrees); if (doOffset) { g2.translate(offsetAmount, -offsetAmount); } fRenderer.paintComponent(g2, fLabelDelegate, this, 0, 0, getHeight(), getWidth(), true); if (doOffset) { g2.translate(-offsetAmount, offsetAmount); } g2.rotate(degrees); g2.translate(-w, 0); } }
@Override public void paintIcon(SynthContext context, Graphics g, int x, int y, int w, int h) { Painter painter = null; if (context != null) { painter = (Painter) context.getStyle().get(context, key); } if (painter == null) { painter = (Painter) UIManager.get(prefix + "[Enabled]." + key); } if (painter != null && context != null) { JComponent c = context.getComponent(); boolean rotate = false; boolean flip = false; // translatex and translatey are additional translations that // must occur on the graphics context when rendering a toolbar // icon int translatex = 0; int translatey = 0; if (c instanceof JToolBar) { JToolBar toolbar = (JToolBar) c; rotate = toolbar.getOrientation() == JToolBar.VERTICAL; flip = !toolbar.getComponentOrientation().isLeftToRight(); Object o = NimbusLookAndFeel.resolveToolbarConstraint(toolbar); // we only do the +1 hack for UIResource borders, assuming // that the border is probably going to be our border if (toolbar.getBorder() instanceof UIResource) { if (o == BorderLayout.SOUTH) { translatey = 1; } else if (o == BorderLayout.EAST) { translatex = 1; } } } if (g instanceof Graphics2D) { Graphics2D gfx = (Graphics2D) g; gfx.translate(x, y); gfx.translate(translatex, translatey); if (rotate) { gfx.rotate(Math.toRadians(90)); gfx.translate(0, -w); painter.paint(gfx, context.getComponent(), h, w); gfx.translate(0, w); gfx.rotate(Math.toRadians(-90)); } else if (flip) { gfx.scale(-1, 1); gfx.translate(-w, 0); painter.paint(gfx, context.getComponent(), w, h); gfx.translate(w, 0); gfx.scale(-1, 1); } else { painter.paint(gfx, context.getComponent(), w, h); } gfx.translate(-translatex, -translatey); gfx.translate(-x, -y); } else { // use image if we are printing to a Java 1.1 PrintGraphics as // it is not a instance of Graphics2D BufferedImage img = new BufferedImage(w, h, BufferedImage.TYPE_INT_ARGB); Graphics2D gfx = img.createGraphics(); if (rotate) { gfx.rotate(Math.toRadians(90)); gfx.translate(0, -w); painter.paint(gfx, context.getComponent(), h, w); } else if (flip) { gfx.scale(-1, 1); gfx.translate(-w, 0); painter.paint(gfx, context.getComponent(), w, h); } else { painter.paint(gfx, context.getComponent(), w, h); } gfx.dispose(); g.drawImage(img, x, y, null); img = null; } } }
/** * Draws the stars on the flag. Two integer arrays are used to store the x-coordinates and * y-coordinates of a star (a total of 10 points for each of the 10 vertices). The outer radius is * then calculated by multiplying the actual height by the star diameter ratio then dividing by 2. * The inner radius is then calculated using trigonometric relationships between the first point * (outer right most point) and the point directly to the left of it (the inner right most point), * based on the assumption that the y-coordinates of these points are the same. The method then * uses a series of for loops to draw the stars, drawing them row by row and 1 by 1 across each * row. The outer most for loop increments each row while also determining the number of stars in * each row and the initial x offset for the first star, both of which vary depending on the row * number. The intermediate for loop increments each column while also determining the X and Y * coordinate centers for each star. The inner most for loop generates the x and y coordinates for * each of the 10 vertices for each star and stores them in their respective arrays to be used by * the fillPolygon method to draw each star. * * @param g The graphics component on which to draw the stars * @param initialWidthOffset The initial width offset towards the right from the left side of the * frame * @param initialHeightOffset The initial height offset towards the bottom from the top of the * frame * @param actualWidth The actual width of the window, not including the frame border * @param actualHeight The actual height of the window, not including the frame border */ public void drawStars( Graphics g, int initialWidthOffset, int initialHeightOffset, int actualWidth, int actualHeight) { g.setColor(Color.WHITE); int[] xPoints = new int[10]; int[] yPoints = new int[10]; // outer radius double r1 = actualHeight * (STAR_DIAMETER / 2); // inner radius double r2 = r1 * Math.sin(Math.toRadians(18)) / Math.sin(Math.toRadians(54)); for (int row = 0; row < 9; row++) { /* The number of stars per row initially begin at 6 for the first row and alternate between * 5 and 6 for each successive row. */ int starsPerRow = (row % 2 == 0) ? 6 : 5; /* The initial star x offset is initially 1 for the first row, but alternates between 2 * and 1 for each successive row. */ int initialStarXOffset = (row % 2 == 0) ? 1 : 2; for (int col = 0; col < starsPerRow; col++) { /* The x-coordinate center is calculated based on the initial width offset and the star x * offset proportional to the actual height, in addition to the initial star x offset and the * column number. The x-coordinate center is incremented by the 2 times the star x offset in * proportion to the actual height for each iteration of the intermediate for loop. The * y-coordinate center is calculated based on the initial height offset and the star y offset * proportional to the actual height, in addition to the row number. The y-coordinate center is * incremented by the star y offset in proportion to the actual height for each iteration of the * outer most for loop. */ int starCenterX = (initialWidthOffset) + (int) ((actualHeight * STAR_X_OFFSET) * (initialStarXOffset + 2 * col)); int starCenterY = (initialHeightOffset) + (int) ((actualHeight * STAR_Y_OFFSET) * (1 + row)); for (int i = 0; i < 10; i++) { /* Assigns different x and y coordinates for each of the 10 points on a star depending on * whether the point is an even/outer point (i % 2) == 0, or an odd/inner point. Points are * calculated based on the center x and y coordinates and with the trigonometric sin and cos * functions. The angle measure is incremented by 36 degrees for each iteration of the for loop, for * use in the cos and sin functions. */ xPoints[i] = (i % 2) == 0 ? starCenterX + (int) (r1 * Math.cos(Math.toRadians(18 + 36 * i))) : starCenterX + (int) (r2 * Math.cos(Math.toRadians(54 + 36 * (i - 1)))); yPoints[i] = (i % 2) == 0 ? starCenterY - (int) (r1 * Math.sin(Math.toRadians(18 + 36 * i))) : starCenterY - (int) (r2 * Math.sin(Math.toRadians(54 + 36 * (i - 1)))); } g.fillPolygon(xPoints, yPoints, 10); } } }
public class VJYbar implements GraphSeries { public int dataSize; public int capacity; public int lineWidth; public int pX, pY, pWidth, pHeight; // container's boundary public int[] xPoints; public int[] yPoints; public Color fgColor; public float alphaSet; public Color bgColor; public boolean bValid = false; public boolean bXorMode = false; public boolean bTopLayer = false; public Rectangle clipRect; private static double deg90 = Math.toRadians(90.0); public VJYbar() { this.dataSize = 0; this.capacity = 0; this.lineWidth = 1; this.pWidth = 100; this.pHeight = 100; this.pX = 0; this.pY = 0; this.alphaSet = 1.0f; } public int[] getXPoints() { return xPoints; } public void setXPoints(int[] pnts) { xPoints = pnts; } public int[] getYPoints() { return yPoints; } public void setYPoints(int[] pnts) { yPoints = pnts; } public void setColor(Color c) { fgColor = c; } public Color getColor() { return fgColor; } public void setBgColor(Color c) { bgColor = c; } public Color getBgColor() { return bgColor; } public void setSize(int s) { dataSize = s; setCapacity(s); } public int getSize() { return dataSize; } public void setLineWidth(int n) { lineWidth = n; if (lineWidth < 1 || lineWidth > 50) lineWidth = 1; } public int getLineWidth() { return lineWidth; } public void setCapacity(int s) { if (capacity >= s) return; if (s < 4) s = 4; capacity = s; xPoints = new int[s]; yPoints = new int[s]; } public boolean isValid() { return bValid; } public void setValid(boolean s) { bValid = s; } public void setXorMode(boolean b) { bXorMode = b; } public boolean isXorMode() { return bXorMode; } public void setTopLayer(boolean b) { bTopLayer = b; } public boolean isTopLayer() { return bTopLayer; } public void setAlpha(float n) { alphaSet = n; } public float getAlpha() { return alphaSet; } public boolean intersects(int x, int y, int x2, int y2) { if (!bValid || capacity <= 0) return false; if (x2 < xPoints[0] || x > xPoints[dataSize - 1]) return false; if (y2 < yPoints[0] || y > yPoints[0]) return false; return true; } public void setConatinerGeom(int x, int y, int w, int h) { pX = x; pY = y; pWidth = w; pHeight = h; } public void draw(Graphics2D g, boolean bVertical, boolean bRight) { if (!bValid || dataSize < 1) return; int tx = pX; int ty = pY; g.setColor(fgColor); if (bVertical) { if (bRight) { tx = pX + pWidth; ty = pY; g.translate(tx, ty); g.rotate(deg90); } else { tx = pX; ty = pY + pHeight; g.translate(tx, ty); g.rotate(-deg90); } } else { if (tx != 0 || ty != 0) g.translate(tx, ty); } if (dataSize > 1) g.drawPolyline(xPoints, yPoints, dataSize); else g.drawLine(xPoints[0], yPoints[0], xPoints[0], yPoints[0]); if (bVertical) { if (bRight) { g.rotate(-deg90); } else g.rotate(deg90); } if (tx != 0 || ty != 0) g.translate(-tx, -ty); } }