public void test110_ZoomShift() {
    // final double s = 1.0 / RockLocationDisplayBase.SCALE;
    final double[] flat = new double[6];
    final Point2D dst = new Point2D.Double();
    final Point2D src = new Point2D.Double();
    final AffineTransform mat = new AffineTransform();
    final Rectangle2D wc = new Rectangle2D.Double(1, 2, 3, 4);
    Rectangle dc = new Rectangle(-1, -2, 3, 4);
    final Point2D fix = new Point2D.Double(1, 2);
    ZoomerFixPoint zom = new ZoomerFixPoint("1:1", wc, fix);

    mat.setToIdentity();
    zom.computeWc2Dc(dc, Orientation.N, true, false, mat);
    mat.getMatrix(flat);
    assertEquals("", -0.0010, flat[0], 1e-9);
    assertEquals("", 0, flat[1], 1e-9);
    assertEquals("", 0, flat[2], 1e-9);
    assertEquals("", -0.0010, flat[3], 1e-9);
    assertEquals("", 1.0, flat[4], 1e-9);
    assertEquals("", 6, flat[5], 1e-9);
    src.setLocation(fix);
    mat.transform(src, dst);
    assertEquals(new Point2D.Double(0.999, 5.998), dst);
    src.setLocation(3, 4);
    mat.transform(src, dst);
    assertEquals(new Point2D.Double(0.997, 5.996), dst);
  }
Exemple #2
0
  /**
   * Moves a Steiner Point towards the furthest neighbor
   *
   * @param source
   * @param target
   */
  private void moveTowards(Point source, Point target) {

    Point2D s = new Point2D.Double();
    Point2D t = new Point2D.Double();
    Point2D previousLocation = new Point2D.Double();
    s.setLocation(source.x, source.y);
    previousLocation.setLocation(source.x, source.y);
    t.setLocation(target.x, target.y);

    // in each step move 1 unit forward towards the target
    double step_size = 1;
    // previous PCR : Stop moving when previousPCR is better than current one.
    double previousPCR = source.getPCR();

    int distance =
        (int) Math.floor(GraphUtils.euclideanDistance(source.x, source.y, target.x, target.y));
    for (int i = 0; i < distance; i += step_size) {
      Point2D currentLocation =
          GraphUtils.getCoordinates(source.x, source.y, target.x, target.y, step_size);
      source.x = currentLocation.getX();
      source.y = currentLocation.getY();
      double currentPCR = source.getPCR();

      if (currentPCR < previousPCR) {
        previousPCR = currentPCR;
        previousLocation = currentLocation;
      } else {
        // move backwards
        source.x = previousLocation.getX();
        source.y = previousLocation.getY();
      }
    }
  }
 public void run(double frac) {
   System.err.println("auto-centering" + frac);
   if (frac == 0.0) {
     int xbias = 0, ybias = 0;
     switch (m_orientation) {
       case Constants.ORIENT_LEFT_RIGHT:
         xbias = m_bias;
         break;
       case Constants.ORIENT_RIGHT_LEFT:
         xbias = -m_bias;
         break;
       case Constants.ORIENT_TOP_BOTTOM:
         ybias = m_bias;
         break;
       case Constants.ORIENT_BOTTOM_TOP:
         ybias = -m_bias;
         break;
     }
     Rectangle2D vb = m_vis.getBounds(TREE);
     m_cur.setLocation(getWidth() / 2, getHeight() / 2);
     getAbsoluteCoordinate(m_cur, m_start);
     m_end.setLocation(vb.getX() + xbias, vb.getY() + ybias);
   } else {
     m_cur.setLocation(
         m_start.getX() + frac * (m_end.getX() - m_start.getX()),
         m_start.getY() + frac * (m_end.getY() - m_start.getY()));
     panToAbs(m_cur);
   }
 }
Exemple #4
0
  private PBounds addNode(HierarchyNodeView from, HierarchyNodeView toNode, boolean addChildren) {
    PBounds bounds = toNode.node.getBounds();

    final PSWTPath path = new PSWTPath();
    Point2D to = toNode.node.getCenter();
    Point2D fromP = from.node.getCenter();
    if (!addChildren) {
      fromP.setLocation(fromP.getX(), fromP.getY() - (from.node.getHeight() / 2.0));
      to.setLocation(to.getX(), to.getY() + (toNode.node.getHeight() / 2.0));
    } else {
      fromP.setLocation(fromP.getX(), fromP.getY() + (from.node.getHeight() / 2.0));
      to.setLocation(to.getX(), to.getY() - (toNode.node.getHeight() / 2.0));
    }

    path.setPathToPolyline(new Point2D[] {fromP, to});
    getLayer().addChild(path);
    path.moveToBack();
    path.addInputEventListener(
        new PBasicInputEventHandler() {
          @Override
          public void mouseEntered(PInputEvent event) {
            path.setStrokeColor(Color.LIGHT_GRAY);
          }

          @Override
          public void mouseExited(PInputEvent event) {
            path.setStrokeColor(Color.BLACK);
          }
        });
    return bounds;
  }
Exemple #5
0
  public static void main(String[] args) {
    Scanner scanRadius = new Scanner(System.in);
    Scanner scanCenter = new Scanner(System.in);
    Point2D centerA = new Point2D.Double();
    Point2D centerB = new Point2D.Double();
    double x, y, radiusA = 0, radiusB = 0;

    for (char i = 'A'; i <= 'B'; i++) {
      System.out.print("\nCircle " + i);
      System.out.print("\nEnter center cordinates:" + "\n(x): ");
      x = scanCenter.nextDouble();
      System.out.print("(y): ");
      y = scanCenter.nextDouble();

      System.out.print("Enter radius: ");
      if (i == 'A') {
        radiusA = scanCenter.nextDouble();
        centerA.setLocation(x, y);
      } else if (i == 'B') {
        radiusB = scanCenter.nextDouble();
        centerB.setLocation(x, y);
      }
    }
    scanRadius.close();
    scanCenter.close();

    double distance = distance(centerA, centerB);

    if (distance == (radiusA + radiusB)) System.out.println("\nThe two circles are touching");
    else if ((distance < Math.abs(radiusA - radiusB)))
      System.out.println("\nOne circle encloses another");
    else if (distance < (radiusA + radiusB)) System.out.println("\nThe two circles overlap");
    else if (distance > (radiusA + radiusB)) System.out.println("\nThe two circles are separate");
  }
 public void run(double frac) {
   TupleSet ts = m_vis.getFocusGroup(Visualization.FOCUS_ITEMS);
   // System.err.println("auto-panning"+frac);
   if (ts.getTupleCount() == 0) return;
   if (frac == 0.0) {
     int xbias = 0, ybias = 0;
     switch (m_orientation) {
       case Constants.ORIENT_LEFT_RIGHT:
         xbias = m_bias;
         break;
       case Constants.ORIENT_RIGHT_LEFT:
         xbias = -m_bias;
         break;
       case Constants.ORIENT_TOP_BOTTOM:
         ybias = m_bias;
         break;
       case Constants.ORIENT_BOTTOM_TOP:
         ybias = -m_bias;
         break;
     }
     VisualItem vi = (VisualItem) ts.tuples().next();
     m_cur.setLocation(getWidth() / 2, getHeight() / 2);
     getAbsoluteCoordinate(m_cur, m_start);
     m_end.setLocation(vi.getX() + xbias, vi.getY() + ybias);
   } else {
     m_cur.setLocation(
         m_start.getX() + frac * (m_end.getX() - m_start.getX()),
         m_start.getY() + frac * (m_end.getY() - m_start.getY()));
     panToAbs(m_cur);
   }
 }
Exemple #7
0
 protected int adjustEndingPointByMultipleEdge(EdgeItem e, Point2D start, Point2D end) {
   int edgeIndex = getEdgeIndex(e);
   if (edgeIndex < 0) {
     return edgeIndex;
   }
   m_edgeTrans.setToTranslation(end.getX(), end.getY());
   m_edgeTrans.rotate(-HALF_PI + Math.atan2(end.getY() - start.getY(), end.getX() - start.getX()));
   if (edgeIndex % 2 == 1) {
     end.setLocation(4 + edgeIndex, 0);
   } else {
     end.setLocation(-4 - (edgeIndex - 1), 0);
   }
   m_edgeTrans.transform(end, end);
   return edgeIndex;
 }
 public void setPositionXY(int[] positionRad) {
   Vector<Point2D> points = new Vector<Point2D>();
   for (int laser = (0 + degreesToHide); laser <= (539 - degreesToHide); laser++) {
     Point2D point = new Point();
     int invertedLaser = 541 - 2 - laser;
     point.setLocation(
         positionRad[invertedLaser] * Math.cos(invertedLaser * 0.00872664626 + ANGLE_DEPART),
         positionRad[invertedLaser] * Math.sin(invertedLaser * 0.00872664626 + ANGLE_DEPART));
     if (point.getX() == 0 && point.getY() == 0) {
       point.setLocation(10000, 10000);
     }
     points.add(point);
   }
   positionXY = points;
 }
  protected Point2D constrainCtrlPoint(int index, int side, Point2D ctrl) {
    if ((index == 0 && side == RIGHT_CONTROLPOINT && startFigure() != null)
        || (index == segments.size() && side == LEFT_CONTROLPOINT && endFigure() != null)) {
      // we are constraining the start-controlPoint

      Point2D start = getPointAt(index);
      Point2D end = getPointAt(index == 0 ? 1 : segments.size() - 1);

      double xdiff = start.getX() - end.getX();
      xdiff *= xdiff;

      double ydiff = start.getY() - end.getY();
      ydiff *= ydiff;

      double distance = Math.sqrt(xdiff + ydiff);

      Orientation orientation;
      if (index == 0) {
        distance *= getStartFactor();
        orientation = ((TagConnector) getStartConnector()).getOrientation();
      } else {
        distance *= getEndFactor();
        orientation = ((TagConnector) getEndConnector()).getOrientation();
      }

      switch (orientation) {
        case TOP:
          distance = -distance;

          // Fall through

        case BOTTOM:
          ctrl.setLocation(start.getX(), start.getY() + distance);
          break;

        case LEFT:
          distance = -distance;

          // Fall through

        case RIGHT:
          ctrl.setLocation(start.getX() + distance, start.getY());
          break;
      }
    }

    return ctrl;
  }
  /**
   * Function to check if a direction and frame intersects
   *
   * @param direction
   * @param frame
   * @return
   */
  public boolean intersects(Line2D direction, Line2D frame) {
    double d =
        (frame.getY2() - frame.getY1()) * (direction.getX2() - direction.getX1())
            - (frame.getX2() - frame.getX1()) * (direction.getY2() - direction.getY1());

    double n_a =
        (frame.getX2() - frame.getX1()) * (direction.getY1() - frame.getY1())
            - (frame.getY2() - frame.getY1()) * (direction.getX1() - frame.getX1());

    double n_b =
        (direction.getX2() - direction.getX1()) * (direction.getY1() - frame.getY1())
            - (direction.getY2() - direction.getY1()) * (direction.getX1() - frame.getX1());

    if (d == 0) return false;

    double ua = n_a / d;
    double ub = n_b / d;

    if (ua >= 0d && ua <= 1d && ub >= 0d && ub <= 1d) {
      intersection = new Point2D.Double();
      intersection.setLocation(
          direction.getX1() + (ua * (direction.getX2() - direction.getX1())),
          direction.getY1() + (ua * (direction.getY2() - direction.getY1())));
      return true;
    }
    return false;
  }
 public Point2D getPoint2D(Point2D srcPt, Point2D dstPt) {
   if (dstPt == null) {
     dstPt = new Point2D.Double();
   }
   dstPt.setLocation(srcPt.getX(), srcPt.getY());
   return dstPt;
 }
Exemple #12
0
 private static Point2D vectorToLocation(
     double angle, double length, Point2D sourceLocation, Point2D targetLocation) {
   targetLocation.setLocation(
       sourceLocation.getX() + Math.sin(angle) * length,
       sourceLocation.getY() + Math.cos(angle) * length);
   return targetLocation;
 }
 public void mouseMoved(MouseEvent e) {
   // check if the mouse is over something hot:
   // - a speed handle
   // - a rock
   tmp.setLocation(e.getX(), e.getY());
   panel.findHotDc(tmp, hot);
 }
 /**
  * Inverse transform from projected coordinates to latitude/longitude in radians.
  *
  * @see
  *     org.geotools.referencing.operation.projection.MapProjection#inverseTransformNormalized(double,
  *     double, java.awt.geom.Point2D)
  */
 @Override
 protected Point2D inverseTransformNormalized(double x, double y, Point2D ptDst)
     throws ProjectionException {
   double lambda = 0;
   double phi = 0;
   double c = hypot(x, y);
   if (c < EPS10) {
     phi = latitudeOfOrigin;
     lambda = 0;
   } else {
     if (mode == Mode.OBLIQUE || mode == Mode.EQUATORIAL) {
       double x2 = x * semiMajor;
       double y2 = y * semiMajor;
       double azi1 = atan2(x2, y2);
       double s12 = sqrt(x2 * x2 + y2 * y2);
       GeodesicData g =
           geodesic.Direct(
               toDegrees(latitudeOfOrigin), toDegrees(centralMeridian), toDegrees(azi1), s12);
       phi = toRadians(g.lat2);
       lambda = toRadians(g.lon2);
       lambda -= centralMeridian;
     } else { // Polar
       phi = inv_mlfn((mode == Mode.NORTH_POLAR) ? (Mp - c) : (Mp + c));
       lambda = atan2(x, (mode == Mode.NORTH_POLAR) ? -y : y);
     }
   }
   if (ptDst == null) {
     return new Point2D.Double(lambda, phi);
   } else {
     ptDst.setLocation(lambda, phi);
     return ptDst;
   }
 }
Exemple #15
0
  /**
   * Forward project a point. If the point is not within the viewable hemisphere, return flags in
   * AzimuthVar variable if specified.
   *
   * @param phi double latitude in radians
   * @param lambda double longitude in radians
   * @param p Point2D
   * @param azVar AzimuthVar or null
   * @return Point2D pt
   */
  protected Point2D _forward(double phi, double lambda, Point2D p, AzimuthVar azVar) {
    double c = hemisphere_distance(centerY, centerX, phi, lambda);
    // normalize invalid point to the edge of the sphere
    if (c > HEMISPHERE_EDGE) {
      double az = GreatCircle.sphericalAzimuth(centerY, centerX, phi, lambda);
      if (azVar != null) {
        azVar.invalid_forward = true; // set the invalid
        // flag
        azVar.current_azimuth = (float) az; // record azimuth
        // of this
        // point
      }
      return edge_point(p, az);
    }

    double kPrime = 1 / Math.cos(c);
    double cosPhi = Math.cos(phi);
    double sinPhi = Math.sin(phi);
    double lambdaMinusCtrLon = lambda - centerX;
    double cosLambdaMinusCtrLon = Math.cos(lambdaMinusCtrLon);
    double sinLambdaMinusCtrLon = Math.sin(lambdaMinusCtrLon);

    double x = (scaled_radius * kPrime * cosPhi * sinLambdaMinusCtrLon) + wx;
    double y =
        hy
            - (scaled_radius
                * kPrime
                * (cosCtrLat * sinPhi - sinCtrLat * cosPhi * cosLambdaMinusCtrLon));
    p.setLocation(x, y);
    return p;
  }
  protected void makeSawtooth() {
    // TODO Auto-generated method stub
    // 规定一个取点间隙

    for (int i = 0; i < sawtooth.size(); i++) {
      Point2D point = sawtooth.get(i);
      point.setLocation(point.getX() + vx[0], point.getY() + vy[0]);
    }

    try {
      int x =
          (int) pointList.get(sawtoothIndex).getX()
              - (int) pointList.get(sawtoothIndex + grap).getX();
      int y =
          (int) pointList.get(sawtoothIndex).getY()
              - (int) pointList.get(sawtoothIndex + grap).getY();

      double rate = Math.random() / 2;

      int formerX = (int) pointList.get(sawtoothIndex + grap / 2).getX();
      int formerY = (int) pointList.get(sawtoothIndex + grap / 2).getY();

      if ((sawtoothIndex % (2 * grap)) == 0) {
        rate = -rate;
      }
      pointList.get(sawtoothIndex + grap / 2).setLocation(formerX + rate * y, formerY - rate * x);

      sawtooth.add(pointList.get(sawtoothIndex));
      sawtooth.add(pointList.get(sawtoothIndex + grap / 2));
      sawtooth.add(pointList.get(sawtoothIndex + grap));

      sawtoothIndex = sawtoothIndex + grap;
    } catch (Exception ex) {
    }
  }
Exemple #17
0
 /**
  * Rotates a two-dimensional vector by the angle alpha.
  *
  * @param p point
  * @param alpha angle in radian
  * @return q point rotated around origin
  */
 public static Point2D rotate(Point2D p, double alpha) {
   double sina = Math.sin(alpha);
   double cosa = Math.cos(alpha);
   Point2D q = new Point2D.Double();
   q.setLocation(p.getX() * cosa - p.getY() * sina, p.getX() * sina + p.getY() * cosa);
   return q;
 }
  /**
   * Transforms the specified (<var>&lambda;</var>,<var>&phi;</var>) coordinates (units in radians)
   * and stores the result in {@code ptDst} (linear distance on a unit sphere).
   */
  protected Point2D transformNormalized(double lam, double phi, final Point2D ptDst)
      throws ProjectionException {
    double c, d;
    double x, y;

    if ((d = acos(cos(phi) * cos(c = 0.5 * lam))) != 0) {
        /* basic Aitoff */
      x = 2. * d * cos(phi) * sin(c) * (y = 1. / sin(d));
      y *= d * sin(phi);
    } else {
      x = y = 0;
    }

    if (mode == ProjectionMode.Winkel) {
      x = (x + lam * cosphi1) * 0.5;
      y = (y + phi) * 0.5;
    }

    if (ptDst != null) {
      ptDst.setLocation(x, y);
      return ptDst;
    } else {
      return new Point2D.Double(x, y);
    }
  }
Exemple #19
0
  private void expandLocationToInclude(Point2D pt) {
    Point2D pt0 = getLocationPt(0);
    Point2D pt2 = getLocationPt(2);
    int leftmostPtIndex = (pt0.getX() < pt2.getX() ? 0 : 2);
    int rightmostPtIndex = 2 - leftmostPtIndex;
    int topmostPtIndex = (pt0.getY() < pt2.getY() ? 0 : 2);
    int bottommostPtIndex = 2 - topmostPtIndex;

    Point2D leftmostPt = getLocationPt(leftmostPtIndex);
    Point2D rightmostPt = getLocationPt(rightmostPtIndex);
    Point2D topmostPt;
    Point2D bottommostPt;
    if (topmostPtIndex == leftmostPtIndex) {
      topmostPt = leftmostPt;
      bottommostPt = rightmostPt;
    } else {
      topmostPt = rightmostPt;
      bottommostPt = leftmostPt;
    }

    Location newLocation = new Location(getLocation());
    boolean locationChanged = false;
    if (pt.getX() < leftmostPt.getX()) {
      leftmostPt.setLocation(pt.getX(), leftmostPt.getY());
      newLocation.setPt(leftmostPtIndex, leftmostPt);
      locationChanged = true;
    }
    if (pt.getX() > rightmostPt.getX()) {
      rightmostPt.setLocation(pt.getX(), rightmostPt.getY());
      newLocation.setPt(rightmostPtIndex, rightmostPt);
      locationChanged = true;
    }
    if (pt.getY() < topmostPt.getY()) {
      topmostPt.setLocation(topmostPt.getX(), pt.getY());
      newLocation.setPt(topmostPtIndex, topmostPt);
      locationChanged = true;
    }
    if (pt.getY() > bottommostPt.getY()) {
      bottommostPt.setLocation(bottommostPt.getX(), pt.getY());
      newLocation.setPt(bottommostPtIndex, bottommostPt);
      locationChanged = true;
    }

    if (locationChanged) {
      internalSetLocation(newLocation);
    }
  }
Exemple #20
0
  public void onScannedRobot(ScannedRobotEvent e) {
    oldRobotLocation.setLocation(robotLocation);
    robotLocation.setLocation(getX(), getY());
    enemyAbsoluteBearing = getHeadingRadians() + e.getBearingRadians();
    enemyDistance = e.getDistance();
    oldEnemyLocation.setLocation(enemyLocation);
    toLocation(enemyAbsoluteBearing, enemyDistance, robotLocation, enemyLocation);

    deltaBearing =
        Utils.normalRelativeAngle(
            absoluteBearing(oldRobotLocation, enemyLocation)
                - absoluteBearing(oldRobotLocation, oldEnemyLocation));

    currentAimFactors =
        aimFactors[aimDirectionSegment()][
            Math.min(
                (int) (enemyDistance / (getBattleFieldWidth() / DISTANCE_SEGMENTS)),
                DISTANCE_SEGMENTS - 1)][
            Math.min(
                (int) (enemyLocation.getY() / (getBattleFieldHeight() / VERTICAL_SEGMENTS)),
                VERTICAL_SEGMENTS - 1)];

    setTurnGunRightRadians(
        Utils.normalRelativeAngle(
            enemyAbsoluteBearing
                + maxEnemyBearing * sign(deltaBearing) * mostVisitedFactor()
                - getGunHeadingRadians()));

    if (getEnergy() > 3.1) {
      Bullet bullet = setFireBullet(3);
      if (bullet != null) {
        Wave wave = new Wave();
        wave.wTime = getTime();
        wave.bearingDelta = deltaBearing;
        wave.oldRLocation.setLocation(robotLocation);
        wave.oldELocation.setLocation(enemyLocation);
        wave.wAimFactors = currentAimFactors;
        addCustomEvent(wave);
      }
    }

    setAhead(getY() > enemyLocation.getY() ? -50 : 50);

    setTurnRadarRightRadians(
        Utils.normalRelativeAngle(enemyAbsoluteBearing - getRadarHeadingRadians()) * 2);
  }
 private void insertConnectionPointToNode(Connection c, int outcode, int index) {
   Point2D newpoint = new Point2D.Double();
   Point2D segmentPoint = getConnection().getPoints().get(index);
   if (outcode == Rectangle2D.OUT_BOTTOM) {
     newpoint.setLocation(segmentPoint.getX(), c.getAbsoluteY2());
     addEditPoint(index, newpoint);
   } else if (outcode == Rectangle2D.OUT_TOP) {
     newpoint.setLocation(segmentPoint.getX(), c.getAbsoluteY1());
     addEditPoint(index, newpoint);
   } else if (outcode == Rectangle2D.OUT_LEFT) {
     newpoint.setLocation(c.getAbsoluteX1(), segmentPoint.getY());
     addEditPoint(index, newpoint);
   } else if (outcode == Rectangle2D.OUT_RIGHT) {
     newpoint.setLocation(c.getAbsoluteX2(), segmentPoint.getY());
     addEditPoint(index, newpoint);
   }
 }
  private static MeshCoords transformSector(AffineTransform transform, Sector sector) {
    java.awt.geom.Point2D p = new java.awt.geom.Point2D.Double();
    java.awt.geom.Point2D ll = new java.awt.geom.Point2D.Double();
    java.awt.geom.Point2D ur = new java.awt.geom.Point2D.Double();

    p.setLocation(sector.getMinLongitude().degrees, sector.getMinLatitude().degrees);
    transform.transform(p, ll);

    p.setLocation(sector.getMaxLongitude().degrees, sector.getMaxLatitude().degrees);
    transform.transform(p, ur);

    return new MeshCoords(
        (float) ur.getY(), // Top
        (float) ll.getX(), // Left
        (float) ll.getY(), // Bottom
        (float) ur.getX()); // Right
  }
Exemple #23
0
 @Override
 public Point2D calculate(Point2D point) {
   double x = point.getX();
   double y = point.getY();
   double r = Math.sqrt(x * x + y * y) + 0.000001;
   double t = Math.atan2(x, y);
   point.setLocation(Math.sin(t) / r * _coefficient, r * Math.cos(t) * _coefficient);
   return point;
 }
 public DiagramElement(DiagramElement element) {
   this.stroke = element.stroke;
   this.paint = element.paint;
   this.size = element.size;
   position.setLocation(
       position.getX() - size.getWidth() / 2, position.getY() - size.getHeight() / 2);
   this.position = element.position;
   this.scale = 1;
   this.rotation = 0;
 }
Exemple #25
0
 @Override
 public Point2D calculate(Point2D point) {
   double x = point.getX();
   double y = point.getY();
   double r = Math.sqrt(x * x + y * y);
   double t = Math.atan2(x, y);
   double pot = Math.pow(r, Math.sin(t));
   point.setLocation(pot * Math.cos(t) * _coefficient, pot * Math.sin(t) * _coefficient);
   return point;
 }
 public DiagramElement(Point2D position, Dimension size, Stroke stroke, Paint paint) {
   setStroke(stroke);
   this.paint = paint;
   this.size = size;
   position.setLocation(
       position.getX() - size.getWidth() / 2, position.getY() - size.getHeight() / 2);
   this.position = position;
   this.scale = 1;
   this.rotation = 0;
 }
Exemple #27
0
 @Override
 public Point2D calculate(Point2D point) {
   double x = point.getX();
   double y = point.getY();
   double r = Math.sqrt(x * x + y * y);
   double p = _parameters.get(0) * _parameters.get(0) + 0.000001;
   double theta = Math.atan2(x, y);
   double t = r - 2 * p * Math.floor((r + p) / 2 * p) + r * (1 - p);
   point.setLocation(t * Math.sin(theta) * _coefficient, t * Math.cos(theta) * _coefficient);
   return point;
 }
  private void traceBallPath() {
    int abort = leftSide ? HEADING_LEFT : HEADING_RIGHT;

    // if(false)
    // fakeBall.ballVelX*paddle.direction>0 &&
    int cycles = 0;
    while (heading != abort) {
      if (++cycles > 100) {
        // System.out.println( this.getClass().getName() + ": to manny cycles, something went
        // wrong\n prevent infinite loop ...");
        break;
      }
      remainingTime = Float.MAX_VALUE;

      boolean positiveX = Math.cos(fakeBall.heading) > 0;
      boolean positiveY = Math.sin(fakeBall.heading) > 0;

      Vector3D path =
          Vector3D.crossProduct(
              new Vector3D(fakeBall.x, fakeBall.y, 1),
              new Vector3D(
                  fakeBall.x + Math.cos(fakeBall.heading),
                  fakeBall.y + Math.sin(fakeBall.heading),
                  1));

      if (positiveX) {
        if (acceptIfCloser(path, right)) {
          heading = HEADING_RIGHT;
        }
      } else {
        if (acceptIfCloser(path, left)) {
          heading = HEADING_LEFT;
        }
      }

      if (positiveY) {
        if (acceptIfCloser(path, bottom)) {
          heading = HEADING_BOTTOM;
        }
      } else {
        if (acceptIfCloser(path, top)) {
          heading = HEADING_TOP;
        }
      }
      if (heading == HEADING_TOP || heading == HEADING_BOTTOM) fakeBall.horizontalBounce();
      else if (heading == HEADING_LEFT || heading == HEADING_RIGHT) fakeBall.verticalBounce();
      else break;

      fakeBall.x = (float) hitPoint.getX();
      fakeBall.y = (float) hitPoint.getY();
    }

    requiredPaddlePos.setLocation(fakeBall.x, fakeBall.y);
  }
  /**
   * Computes the source point corresponding to the supplied point.
   *
   * @param destPt the position in destination image coordinates to map to source image coordinates.
   * @return a <code>Point2D</code> of the same class as <code>destPt</code>.
   * @throws IllegalArgumentException if <code>destPt</code> is <code>null</code>.
   * @since JAI 1.1.2
   */
  public Point2D mapDestPoint(Point2D destPt) {
    if (destPt == null) {
      throw new IllegalArgumentException(JaiI18N.getString("Generic0"));
    }

    Point2D pt = (Point2D) destPt.clone();

    pt.setLocation(destPt.getX() * 4.0, destPt.getY() * 4.0);

    return pt;
  }
  /**
   * Computes the destination point corresponding to the supplied point.
   *
   * @param sourcePt the position in source image coordinates to map to destination image
   *     coordinates.
   * @return a <code>Point2D</code> of the same class as <code>sourcePt</code>.
   * @throws IllegalArgumentException if <code>sourcePt</code> is <code>null</code>.
   * @since JAI 1.1.2
   */
  public Point2D mapSourcePoint(Point2D sourcePt) {
    if (sourcePt == null) {
      throw new IllegalArgumentException(JaiI18N.getString("Generic0"));
    }

    Point2D pt = (Point2D) sourcePt.clone();

    pt.setLocation(sourcePt.getX() / 4.0, sourcePt.getY() / 4.0);

    return pt;
  }