/* 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); } }
private void renderBlackout(Graphics g, int x, int y, int radius) { if (radius > 320) return; int[] xp = new int[20]; int[] yp = new int[20]; for (int i = 0; i < 16; i++) { xp[i] = x + (int) (Math.cos(i * Math.PI / 15) * radius); yp[i] = y + (int) (Math.sin(i * Math.PI / 15) * radius); } xp[16] = 320; yp[16] = y; xp[17] = 320; yp[17] = 240; xp[18] = 0; yp[18] = 240; xp[19] = 0; yp[19] = y; g.fillPolygon(xp, yp, xp.length); for (int i = 0; i < 16; i++) { xp[i] = x - (int) (Math.cos(i * Math.PI / 15) * radius); yp[i] = y - (int) (Math.sin(i * Math.PI / 15) * radius); } xp[16] = 320; yp[16] = y; xp[17] = 320; yp[17] = 0; xp[18] = 0; yp[18] = 0; xp[19] = 0; yp[19] = y; g.fillPolygon(xp, yp, xp.length); }
// ----------------------------------------------------------------- // 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 ); } }
public void paintComponent(Graphics g) { super.paintComponent(g); int xCenter = getSize().width / 2; int yCenter = getSize().height / 2; int radius = (int) (Math.min(getSize().width, getSize().height) * 0.4); // Create a Polygon object Polygon polygon = new Polygon(); // Add points to the polygon polygon.addPoint(xCenter + radius, yCenter); polygon.addPoint( (int) (xCenter + radius * Math.cos(2 * Math.PI / 6)), (int) (yCenter - radius * Math.sin(2 * Math.PI / 6))); polygon.addPoint( (int) (xCenter + radius * Math.cos(2 * 2 * Math.PI / 6)), (int) (yCenter - radius * Math.sin(2 * 2 * Math.PI / 6))); polygon.addPoint( (int) (xCenter + radius * Math.cos(3 * 2 * Math.PI / 6)), (int) (yCenter - radius * Math.sin(3 * 2 * Math.PI / 6))); polygon.addPoint( (int) (xCenter + radius * Math.cos(4 * 2 * Math.PI / 6)), (int) (yCenter - radius * Math.sin(4 * 2 * Math.PI / 6))); polygon.addPoint( (int) (xCenter + radius * Math.cos(5 * 2 * Math.PI / 6)), (int) (yCenter - radius * Math.sin(5 * 2 * Math.PI / 6))); // Draw the polygon g.drawPolygon(polygon); }
private void drawArrow(Graphics2D g2, double theta, double x0, double y0) { double x = x0 - barb * Math.cos(theta + phi); double y = y0 - barb * Math.sin(theta + phi); g2.draw(new Line2D.Double(x0, y0, x, y)); x = x0 - barb * Math.cos(theta - phi); y = y0 - barb * Math.sin(theta - phi); g2.draw(new Line2D.Double(x0, y0, x, y)); }
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 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 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)); }
/** * Calculate great circle distance from country's capitolLocation to another MapPoint. Formula * from http://www.gcmap.com/faq/gccalc * * @param otherCapitol * @return great circle distance in km */ public final double getShippingDistance(MapPoint otherCapitol) { double radianConversion = (Math.PI) / 180; double lon1 = getCapitolLocation().getLon() * radianConversion; double lat1 = capitolLocation.getLat() * radianConversion; double lon2 = otherCapitol.getLon() * radianConversion; double lat2 = otherCapitol.getLat() * radianConversion; double theta = lon2 - lon1; double dist = Math.acos( Math.sin(lat1) * Math.sin(lat2) + Math.cos(lat1) * Math.cos(lat2) * Math.cos(theta)); if (dist < 0) dist = dist + Math.PI; dist = dist * 6371.2; return 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()); }
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); }
// For now the final output is unusable. The associated quantization step // needs some tweaking. If you get this part working, please let me know. public double[][] forwardDCTExtreme(float[][] input) { double[][] output = new double[N][N]; double tmp0; double tmp1; double tmp2; double tmp3; double tmp4; double tmp5; double tmp6; double tmp7; double tmp10; double tmp11; double tmp12; double tmp13; double z1; double z2; double z3; double z4; double z5; double z11; double z13; int i; int j; int v; int u; int x; int y; for (v = 0; v < 8; v++) { for (u = 0; u < 8; u++) { for (x = 0; x < 8; x++) { for (y = 0; y < 8; y++) { output[v][u] += (((double) input[x][y]) * Math.cos(((double) ((2 * x) + 1) * (double) u * Math.PI) / (double) 16) * Math.cos(((double) ((2 * y) + 1) * (double) v * Math.PI) / (double) 16)); } } output[v][u] *= ((double) (0.25) * ((u == 0) ? ((double) 1.0 / Math.sqrt(2)) : (double) 1.0) * ((v == 0) ? ((double) 1.0 / Math.sqrt(2)) : (double) 1.0)); } } return output; }
/** * Rotates a two-dimensional vector by the angle alpha. * * @param p Point * @param alpha double * @return q Point */ public static Point rotate(Point p, double alpha) { double sina = Math.sin(alpha); double cosa = Math.cos(alpha); Point q = new Point(); q.setLocation(p.getX() * cosa - p.getY() * sina, p.getX() * sina + p.getY() * cosa); return q; }
public static void main(String[] args) { Plot2DPanel p2 = new Plot2DPanel(); double[][] XYZ = new double[100][2]; for (int j = 0; j < XYZ.length; j++) { XYZ[j][0] = 2 * Math.PI * (double) j / XYZ.length; XYZ[j][1] = Math.sin(XYZ[j][0]); } double[][] XYZ2 = new double[100][2]; for (int j = 0; j < XYZ2.length; j++) { XYZ2[j][0] = 2 * Math.PI * (double) j / XYZ.length; XYZ2[j][1] = Math.sin(2 * XYZ2[j][0]); } p2.addLinePlot("sin", Color.RED, AbstractDrawer.DOTTED_LINE, XYZ); p2.setBackground(new Color(200, 0, 0)); p2.addLinePlot("sin2", Color.BLUE, AbstractDrawer.CROSS_DOT, XYZ2); p2.setLegendOrientation(PlotPanel.SOUTH); new FrameView(p2).setDefaultCloseOperation(JFrame.DO_NOTHING_ON_CLOSE); Plot3DPanel p = new Plot3DPanel(); XYZ = new double[100][3]; for (int j = 0; j < XYZ.length; j++) { XYZ[j][0] = 2 * Math.PI * (double) j / XYZ.length; XYZ[j][1] = Math.sin(XYZ[j][0]); XYZ[j][2] = Math.sin(XYZ[j][0]) * Math.cos(XYZ[j][1]); } p.addLinePlot("toto", XYZ); p.setLegendOrientation(PlotPanel.SOUTH); new FrameView(p).setDefaultCloseOperation(JFrame.DO_NOTHING_ON_CLOSE); }
/** * Draws an open star with a specified number of points.<br> * The center of this star is specified by centerX,centerY and its size is specified by radius * <br> * (As in the radius of the circle the star would fit inside). <br> * Precondition: points >= 2 <br> * Example: <br> * Expo.drawStar(g,300,200,100,8); <br> * Draws an open star with 8 points and a radius of 100 pixels whose center is located at the * coordinate (300,200). */ public static void drawStar(Graphics g, int centerX, int centerY, int radius, int points) { int halfRadius = getHalfRadius(radius, points); int p = points; points *= 2; int xCoord[] = new int[points]; int yCoord[] = new int[points]; int currentRadius; for (int k = 0; k < points; k++) { if (k % 2 == 0) currentRadius = radius; else currentRadius = halfRadius; xCoord[k] = (int) Math.round(Math.cos(twoPI * k / points - halfPI) * currentRadius) + centerX; yCoord[k] = (int) Math.round(Math.sin(twoPI * k / points - halfPI) * currentRadius) + centerY; } int x = (p - 5) / 2 + 1; if (p >= 5 && p <= 51) switch (p % 4) { case 1: yCoord[x] = yCoord[x + 1] = yCoord[points - x - 1] = yCoord[points - x]; break; case 2: yCoord[x] = yCoord[x + 1] = yCoord[points - x - 1] = yCoord[points - x]; yCoord[x + 3] = yCoord[x + 4] = yCoord[points - x - 4] = yCoord[points - x - 3]; break; case 3: yCoord[x + 2] = yCoord[x + 3] = yCoord[points - x - 3] = yCoord[points - x - 2]; } g.drawPolygon(xCoord, yCoord, points); }
void act() { if (crashed) return; if (missionBuffer == 0) setMissions(); playerZ += SPEED * Math.cos(turn); playerX += SPEED * Math.sin(turn); if (!region(1).contains(playerX, playerZ)) { for (int i = 0; i < NUM_TURNS - 1; i++) centerHinges[i] = centerHinges[i + 1]; createTurn(NUM_TURNS - 1); if (!region(1).contains(playerX, playerZ)) crash(); turnIndex++; if (missionBuffer > 0) missionBuffer--; if (barrierBuffer > 0) barrierBuffer--; } if (playerY + 100 >= centerHinges[3].barrierY && playerY + 100 <= centerHinges[3].barrierY + BARRIER_HEIGHT) { crash(); } if (up && playerY > START_Y + 50) playerY--; if (down && playerY < START_Y + HEIGHT - 150) playerY++; if (left) turn -= .005; if (right) turn += .005; }
protected double read(boolean first) { Point2D centre = new Point2D.Double(localPosition.getX(), localPosition.getY()); Point2D front = new Point2D.Double( localPosition.getX() + range * Math.cos(localPosition.getT()), localPosition.getY() + range * Math.sin(localPosition.getT())); robot.readPosition(robotPosition); robotPosition.rotateAroundAxis(centre); robotPosition.rotateAroundAxis(front); double minDistance = -1.0; for (int i = 0; i < environment.getObstacles().size(); i++) { Obstacle obstacle = environment.getObstacles().get(i); if (obstacle.getOpaque()) { double dist = pointToObstacle(obstacle.getPolygon(), centre, front, first); if (minDistance == -1.0 || (dist > 0 && dist < minDistance)) { minDistance = dist; if (minDistance > -1 && first) { return minDistance; } } } } if (minDistance > 0) { return minDistance; } return -1.0; }
public void method352( int i, int j, int ai[], int k, int ai1[], int i1, int j1, int k1, int l1, int i2) { try { int j2 = -l1 / 2; int k2 = -i / 2; int l2 = (int) (Math.sin((double) j / 326.11000000000001D) * 65536D); int i3 = (int) (Math.cos((double) j / 326.11000000000001D) * 65536D); l2 = l2 * k >> 8; i3 = i3 * k >> 8; int j3 = (i2 << 16) + (k2 * l2 + j2 * i3); int k3 = (i1 << 16) + (k2 * i3 - j2 * l2); int l3 = k1 + j1 * DrawingArea.width; for (j1 = 0; j1 < i; j1++) { int i4 = ai1[j1]; int j4 = l3 + i4; int k4 = j3 + i3 * i4; int l4 = k3 - l2 * i4; for (k1 = -ai[j1]; k1 < 0; k1++) { DrawingArea.pixels[j4++] = myPixels[(k4 >> 16) + (l4 >> 16) * myWidth]; k4 += i3; l4 -= l2; } j3 += l2; k3 += i3; l3 += DrawingArea.width; } } catch (Exception _ex) { } }
/** * Translate a point in the direction specified by an angle. * * @param apt Point2D * @param alpha double * @param dist double * @return Point2D */ public static Point2D translateByAngle(Point2D apt, double alpha, double dist) { double dx = dist * Math.cos(alpha); double dy = dist * Math.sin(alpha); if (Math.abs(dx) < 0.000000001) dx = 0; if (Math.abs(dy) < 0.000000001) dy = 0; return new Point2D.Double(apt.getX() + dx, apt.getY() + dy); }
@Override public void paint(Graphics2D g2, State s, float cWidth, float cHeight) { InvertedPendulumState is = (InvertedPendulumState) s; double x = is instanceof CartPoleState ? ((CartPoleState) is).x : 0.; double a = is.angle; double xmin = -2.4; double xmax = 2.4; double xrange = xmax - xmin; // manage cart rendering float nx = (float) ((x - xmin) / xrange); float cartRadius = 0.05f * cWidth; float scx = nx * cWidth; float scy = cHeight - cartRadius; g2.setColor(Color.black); g2.fill( new Rectangle2D.Float( scx - cartRadius, scy - cartRadius, 2 * cartRadius, 2 * cartRadius)); // manage pole rendering float poleLength = 0.5f * cHeight; float poleTipX = poleLength * (float) Math.sin(a) + scx; float poleTipY = -poleLength * (float) Math.cos(a) + (scy - cartRadius); g2.setColor(Color.gray); g2.setStroke(new BasicStroke(10, BasicStroke.CAP_ROUND, BasicStroke.JOIN_BEVEL)); g2.draw(new Line2D.Float(scx, scy - cartRadius, poleTipX, poleTipY)); }
public void enemyPosition(ScannedRobotEvent e, double x, double y) { // poll subtargetters for their opinions virtualBulletTick++; lastEnemyScanTime = owner.getTime(); // only log it when we actually fire: the enemy may respond to that if (owner.shouldFireShot(e)) { double bulletPower = e.getDistance() > 500.0 ? 2.0 : 3.0; for (int i = 0; i < numVirtualGuns; i++) { double angle = targetters[i].target(e, bulletPower); VirtualBullet bullet = new VirtualBullet(); bullet.targetter = i; bullet.x = owner.getX(); bullet.y = owner.getY(); bullet.velX = Targetting.bulletSpeed(bulletPower) * Math.sin(angle); bullet.velY = Targetting.bulletSpeed(bulletPower) * Math.cos(angle); bullet.lastUpdateTime = lastEnemyScanTime; virtualBullets.add(bullet); } } for (int i = 0; i < numVirtualGuns; i++) { targetters[i].enemyPosition(e, x, y); } enemyX = x; enemyY = y; }
void draw(Graphics2D g) { g.setColor(darkColor); int x = (int) (center_x + distance * Math.sin(-unit * current / num)); int y = (int) (center_y + distance * Math.cos(-unit * current / num)); Area area = new Area(new Ellipse2D.Double(x, y, ball_r, ball_r)); g.fill(area); }
@Override public void dessiner(Graphics2D g2) { double xAttaquant = attaquant.getCenterX(); double yAttaquant = attaquant.getCenterY(); // calcul de l'angle entre la cible et la tour // /!\ Math.atan2(y,x) /!\ double angle = Math.atan2(cible.getCenterY() - yAttaquant, cible.getCenterX() - xAttaquant); // calcul de la tete et de la queue de la fleche xCentreBoule = Math.cos(angle) * distanceCentreBoule + xAttaquant; // x yCentreBoule = Math.sin(angle) * distanceCentreBoule + yAttaquant; // y int diametre = 0; // on ne tire pas en cloche tout le temps // si l'ennemi est trop proche on tire normal if (distanceMaxInitiale > 100.0) { double p = distanceCentreBoule / (distanceMax / 2.0); if (distanceCentreBoule > distanceMax / 2.0) p = 1 - (p - 1); diametre = (int) (p * DIAMETRE_BOULE_MAX + DIAMETRE_BOULE); } else { diametre = DIAMETRE_BOULE; } // dessin de la boule de feu g2.drawImage( IMAGE_BOULE, (int) xCentreBoule - diametre / 2, (int) yCentreBoule - diametre / 2, diametre, diametre, null); }
public BPRadSprite(float rad) { super(null, null); int per = Math.max(24, (int) (2 * Math.PI * (double) rad / 11.0D)); FloatBuffer pa = Utils.mkfbuf(per * 3 * 2); FloatBuffer na = Utils.mkfbuf(per * 3 * 2); ShortBuffer sa = Utils.mksbuf(per * 6); for (int i = 0; i < per; ++i) { float s = (float) Math.sin(2 * Math.PI * (double) i / (double) per); float c = (float) Math.cos(2 * Math.PI * (double) i / (double) per); pa.put(i * 3 + 0, c * rad).put(i * 3 + 1, s * rad).put(i * 3 + 2, 10.0F); pa.put((per + i) * 3 + 0, c * rad) .put((per + i) * 3 + 1, s * rad) .put((per + i) * 3 + 2, -10.0F); na.put(i * 3 + 0, c).put(i * 3 + 1, s).put(i * 3 + 2, 0.0F); na.put((per + i) * 3 + 0, c).put((per + i) * 3 + 1, s).put((per + i) * 3 + 2, 0.0F); int v = i * 6; sa.put(v + 0, (short) i).put(v + 1, (short) (i + per)).put(v + 2, (short) ((i + 1) % per)); sa.put(v + 3, (short) (i + per)) .put(v + 4, (short) ((i + 1) % per + per)) .put(v + 5, (short) ((i + 1) % per)); } this.posa = new VertexArray(pa); this.nrma = new NormalArray(na); this.sidx = sa; }
// calculate the radius of a given ellipse with give angle private double getEllipseRadius(double a, double b, double theta) { double d = Math.pow(a, 2) * Math.pow(Math.cos(theta), 2) + Math.pow(b, 2) * Math.pow(Math.sin(theta), 2); double sd = Math.sqrt(d); return a * b / sd; }
Point2D rightHinge(int index) { Turn turn = centerHinges[index]; double angle = (turn.angle + turn.prevAngle) / 2 + Math.PI / 2; double x = turn.x + WIDTH / 2 * Math.sin(angle); double z = turn.z + WIDTH / 2 * Math.cos(angle); return new Point2D(x, z); }
static Rgb hisToRgb(double h, double i, double s) { double m1, m2, i1; m1 = s * Math.sin(h * Math.PI / 180); m2 = s * Math.cos(h * Math.PI / 180); i1 = i / Math.sqrt(3); Rgb rgb = new Rgb(); rgb.r = m1 * 2 / Math.sqrt(6) + i1 / Math.sqrt(3); rgb.g = -m1 / Math.sqrt(6) + m2 / Math.sqrt(2) + i1 / Math.sqrt(3); rgb.b = -m1 / Math.sqrt(6) - m2 / Math.sqrt(2) + i1 / Math.sqrt(3); rgb.r = rgb.r / 2 + 0.5; rgb.g = rgb.g / 2 + 0.5; rgb.b = rgb.b / 2 + 0.5; if (rgb.r > 1) rgb.r = 1; if (rgb.r < 0) rgb.r = 0; if (rgb.g > 1) rgb.g = 1; if (rgb.g < 0) rgb.g = 0; if (rgb.b > 1) rgb.b = 1; if (rgb.b < 0) rgb.b = 0; return rgb; }
void createEllipse(ImagePlus imp) { IJ.showStatus("Fitting ellipse"); Roi roi = imp.getRoi(); if (roi == null) { noRoi("Fit Ellipse"); return; } if (roi.isLine()) { IJ.error("Fit Ellipse", "\"Fit Ellipse\" does not work with line selections"); return; } ImageProcessor ip = imp.getProcessor(); ip.setRoi(roi); int options = Measurements.CENTROID + Measurements.ELLIPSE; ImageStatistics stats = ImageStatistics.getStatistics(ip, options, null); double dx = stats.major * Math.cos(stats.angle / 180.0 * Math.PI) / 2.0; double dy = -stats.major * Math.sin(stats.angle / 180.0 * Math.PI) / 2.0; double x1 = stats.xCentroid - dx; double x2 = stats.xCentroid + dx; double y1 = stats.yCentroid - dy; double y2 = stats.yCentroid + dy; double aspectRatio = stats.minor / stats.major; imp.killRoi(); imp.setRoi(new EllipseRoi(x1, y1, x2, y2, aspectRatio)); }
public BufferedImage filter(BufferedImage src, BufferedImage dst) { if (dst == null) dst = createCompatibleDestImage(src, null); int width = src.getWidth(); int height = src.getHeight(); int numScratches = (int) (density * width * height / 100); ArrayList<Line2D> lines = new ArrayList<Line2D>(); { float l = length * width; Random random = new Random(seed); Graphics2D g = dst.createGraphics(); g.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON); g.setColor(new Color(color)); g.setStroke(new BasicStroke(this.width)); for (int i = 0; i < numScratches; i++) { float x = width * random.nextFloat(); float y = height * random.nextFloat(); float a = angle + ImageMath.TWO_PI * (angleVariation * (random.nextFloat() - 0.5f)); float s = (float) Math.sin(a) * l; float c = (float) Math.cos(a) * l; float x1 = x - c; float y1 = y - s; float x2 = x + c; float y2 = y + s; g.drawLine((int) x1, (int) y1, (int) x2, (int) y2); lines.add(new Line2D.Float(x1, y1, x2, y2)); } g.dispose(); } if (false) { // int[] inPixels = getRGB( src, 0, 0, width, height, null ); int[] inPixels = new int[width * height]; int index = 0; for (int y = 0; y < height; y++) { for (int x = 0; x < width; x++) { float sx = x, sy = y; for (int i = 0; i < numScratches; i++) { Line2D.Float l = (Line2D.Float) lines.get(i); float dot = (l.x2 - l.x1) * (sx - l.x1) + (l.y2 - l.y1) * (sy - l.y1); if (dot > 0) inPixels[index] |= (1 << i); } index++; } } Colormap colormap = new LinearColormap(); index = 0; for (int y = 0; y < height; y++) { for (int x = 0; x < width; x++) { float f = (float) (inPixels[index] & 0x7fffffff) / 0x7fffffff; inPixels[index] = colormap.getColor(f); index++; } } setRGB(dst, 0, 0, width, height, inPixels); } return dst; }
@Override public void decelerate(float s) { setSpeed(body.getVelocity().length()); s = Math.max(s, 0); float dx = (float) (s * (float) Math.cos(body.getRotation() - Math.PI / 2)); float dy = (float) (s * (float) Math.sin(body.getRotation() - Math.PI / 2)); body.adjustVelocity(new Vector2f(-dx, -dy)); }