private void adjustDateLineCrossingPoints() {
      ArrayList<LatLon> corners = new ArrayList<LatLon>(Arrays.asList(sw, se, nw, ne));
      if (!LatLon.locationsCrossDateLine(corners)) return;

      double lonSign = 0;
      for (LatLon corner : corners) {
        if (Math.abs(corner.getLongitude().degrees) != 180)
          lonSign = Math.signum(corner.getLongitude().degrees);
      }

      if (lonSign == 0) return;

      if (Math.abs(sw.getLongitude().degrees) == 180
          && Math.signum(sw.getLongitude().degrees) != lonSign)
        sw = new Position(sw.getLatitude(), sw.getLongitude().multiply(-1), sw.getElevation());
      if (Math.abs(se.getLongitude().degrees) == 180
          && Math.signum(se.getLongitude().degrees) != lonSign)
        se = new Position(se.getLatitude(), se.getLongitude().multiply(-1), se.getElevation());
      if (Math.abs(nw.getLongitude().degrees) == 180
          && Math.signum(nw.getLongitude().degrees) != lonSign)
        nw = new Position(nw.getLatitude(), nw.getLongitude().multiply(-1), nw.getElevation());
      if (Math.abs(ne.getLongitude().degrees) == 180
          && Math.signum(ne.getLongitude().degrees) != lonSign)
        ne = new Position(ne.getLatitude(), ne.getLongitude().multiply(-1), ne.getElevation());
    }
예제 #2
1
 private void doCurrentMethodStep() {
   switch (type) {
     case 0: // bisectiei
       if (Math.abs(function.evaluate((Cn.lastElement()).x)) < err) {
         complete = true;
         theTimer.stop();
       } else if (function.evaluate((An.lastElement()).x) * function.evaluate((Cn.lastElement()).x)
           < 0) {
         Bn.add(Cn.lastElement());
         Cn.add(new PointDP(((An.lastElement()).x + (Bn.lastElement()).x) / 2, 0.0));
       } else {
         An.add(Cn.lastElement());
         Cn.add(new PointDP(((An.lastElement()).x + (Bn.lastElement()).x) / 2, 0.0));
       }
       break;
     case 1: // coardei
       {
         double evn = function.evaluate((An.lastElement()).x);
         if (Math.abs(evn) < err) {
           complete = true;
           theTimer.stop();
         } else {
           double ev0 = function.evaluate((An.firstElement()).x);
           double newVal = (An.firstElement().x * evn - An.lastElement().x * ev0) / (evn - ev0);
           An.add(new PointDP(newVal, 0.0));
         }
       }
       break;
     case 2: // secantei
       {
         double exn = function.evaluate((An.lastElement()).x);
         if (Math.abs(exn) < err) {
           complete = true;
           theTimer.stop();
         } else {
           double exn1 = function.evaluate((An.elementAt(An.size() - 2)).x);
           double newVal =
               (An.elementAt(An.size() - 2).x * exn - (An.lastElement()).x * exn1) / (exn - exn1);
           An.add(new PointDP(newVal, 0.0));
         }
       }
       break;
     case 3: // newton
       double xn = An.lastElement().x;
       if (Math.abs(function.evaluate(xn)) < err) {
         complete = true;
         theTimer.stop();
       }
       An.add(new PointDP(xn - function.evaluate(xn) / function.evaluate_1(xn), 0.0));
       break;
   }
 }
  public Point getEmptyPosition(Dimension spriteSize) {
    Rectangle trialSpaceOccupied = new Rectangle(0, 0, spriteSize.width, spriteSize.height);
    Random rand = new Random(System.currentTimeMillis());
    boolean empty = false;
    int numTries = 0;

    // Search for an empty position
    while (!empty && numTries++ < 100) {
      // Get a trial position
      trialSpaceOccupied.x = Math.abs(rand.nextInt() % backgroundImage.getSize().width);
      trialSpaceOccupied.y = Math.abs(rand.nextInt() % backgroundImage.getSize().height);
      // Iterate through existing
      // sprites, checking if position
      // is empty
      boolean collision = false;
      for (int cnt = 0; cnt < size(); cnt++) {
        Rectangle testSpaceOccupied = ((Sprite) elementAt(cnt)).getSpaceOccupied();
        if (trialSpaceOccupied.intersects(testSpaceOccupied)) {
          collision = true;
        } // end if
      } // end for loop
      empty = !collision;
    } // end while loop
    return new Point(trialSpaceOccupied.x, trialSpaceOccupied.y);
  } // end getEmptyPosition()
예제 #4
0
  /**
   * Draw method
   *
   * @param g2 Graphics element
   * @param select Selected node
   */
  public void draw(Graphics2D g2, boolean select) {
    Point pinit = new Point(centre.x - 25, centre.y - 25);
    Point pfin = new Point(centre.x + 25, centre.y + 25);
    figure =
        new RoundRectangle2D.Float(
            pinit.x, pinit.y, Math.abs(pfin.x - pinit.x), Math.abs(pfin.y - pinit.y), 20, 20);

    g2.setColor(Color.black);
    if (select) {
      Stroke s = g2.getStroke();
      g2.setStroke(
          new BasicStroke(
              5, BasicStroke.CAP_BUTT, BasicStroke.JOIN_BEVEL, 0, new float[] {1, 1}, 0));
      g2.draw(figure);
      g2.setStroke(s);
    } else {
      g2.draw(figure);
    }
    g2.drawImage(image, centre.x - 25, centre.y - 25, 50, 50, pd);

    g2.setFont(new Font("Courier", Font.BOLD + Font.ITALIC, 12));
    FontMetrics metrics = g2.getFontMetrics();
    int width = metrics.stringWidth(dsc.getName());
    int height = metrics.getHeight();
    g2.drawString(dsc.getName(), centre.x - width / 2, centre.y + 40);
  }
예제 #5
0
  private void draw_horizon(int rad, Point center, int[] angles) {
    // Draw an arc
    int arc_angle =
        ((angles[0] > angles[1]) ? (360 - angles[0]) + angles[1] : (angles[1] - angles[0]));

    Polygon remainder = new Polygon();

    offgraphics_.setColor(GREEN);
    offgraphics_.fillArc(center.x - rad, center.y - rad, 2 * rad, 2 * rad, angles[0], arc_angle);

    if (pitch_ != 0) {
      if ((pitch_ > 0 && Math.abs(roll_) < 90) || (pitch_ < 0 && Math.abs(roll_) >= 90))
        offgraphics_.setColor(BLUE);

      int cover_angle = (angles[0] + arc_angle / 2 + ((arc_angle < 180) ? 180 : 0)) % 360;

      // System.out.println (points[0] + " " + points[1]);

      // System.out.println (accepted_point);

      remainder.addPoint(
          center.x + polar_to_rect_x(rad, cover_angle),
          center.y - polar_to_rect_y(rad, cover_angle));
      remainder.addPoint(
          center.x + polar_to_rect_x(rad, angles[0]), center.y - polar_to_rect_y(rad, angles[0]));
      remainder.addPoint(
          center.x + polar_to_rect_x(rad, angles[1]), center.y - polar_to_rect_y(rad, angles[1]));
      offgraphics_.fillPolygon(remainder);
      // offgraphics_.setColor (getBackground ());
      // offgraphics_.drawPolygon (remainder);
    }
  }
예제 #6
0
  /** Returns the supported cursor size */
  static Dimension getBestCursorSize(int preferredWidth, int preferredHeight) {

    // Fix for bug 4212593 The Toolkit.createCustomCursor does not
    //                     check absence of the image of cursor
    // We use XQueryBestCursor which accepts unsigned ints to obtain
    // the largest cursor size that could be dislpayed
    // Dimension d = new Dimension(Math.abs(preferredWidth), Math.abs(preferredHeight));
    Dimension d;

    XToolkit.awtLock();
    try {
      long display = XToolkit.getDisplay();
      long root_window = XlibWrapper.RootWindow(display, XlibWrapper.DefaultScreen(display));

      XlibWrapper.XQueryBestCursor(
          display,
          root_window,
          Math.abs(preferredWidth),
          Math.abs(preferredHeight),
          XlibWrapper.larg1,
          XlibWrapper.larg2);
      d =
          new Dimension(
              XlibWrapper.unsafe.getInt(XlibWrapper.larg1),
              XlibWrapper.unsafe.getInt(XlibWrapper.larg2));
    } finally {
      XToolkit.awtUnlock();
    }
    return d;
  }
예제 #7
0
 public void draw(Graphics g) {
   Graphics2D g2d = (Graphics2D) g;
   g2d.setPaint(this.getPaint());
   int width = Math.abs(this.getX1() - this.getX2());
   int height = Math.abs(this.getY1() - this.getY2());
   int smallX = this.getX1() < this.getX2() ? this.getX1() : this.getX2();
   int smallY = this.getY1() < this.getY2() ? this.getY1() : this.getY2();
   Stroke myStroke;
   if (this.isDashed()) {
     myStroke =
         new BasicStroke(
             this.getWidth(),
             BasicStroke.CAP_ROUND,
             BasicStroke.JOIN_BEVEL,
             10,
             this.getDashWidth(),
             0);
   } else {
     myStroke = new BasicStroke(this.getWidth(), BasicStroke.CAP_ROUND, BasicStroke.JOIN_BEVEL);
   }
   g2d.setStroke(myStroke);
   if (this.isFilled()) {
     g2d.fillOval(smallX, smallY, width, height);
   } else {
     g2d.drawOval(smallX, smallY, width, height);
   }
 }
예제 #8
0
 /**
  * Writes the <code>shape</code>, <code>coords</code>, <code>href</code>,
  * <code>nohref</code> Attribute for the specified figure and ellipse.
  *
  * @return Returns true, if the circle is inside of the image bounds.
  */
 private boolean writeCircleAttributes(IXMLElement elem, SVGFigure f, Ellipse2D.Double ellipse) {
     AffineTransform t = TRANSFORM.getClone(f);
     if (t == null) {
         t = drawingTransform;
     } else {
         t.preConcatenate(drawingTransform);
     }
     
     if ((t.getType() &
             (AffineTransform.TYPE_UNIFORM_SCALE | AffineTransform.TYPE_TRANSLATION)) ==
             t.getType() &&
             ellipse.width == ellipse.height
             ) {
         
         Point2D.Double start = new Point2D.Double(ellipse.x, ellipse.y);
         Point2D.Double end = new Point2D.Double(ellipse.x + ellipse.width, ellipse.y + ellipse.height);
         t.transform(start, start);
         t.transform(end, end);
         ellipse.x = Math.min(start.x, end.x);
         ellipse.y = Math.min(start.y, end.y);
         ellipse.width = Math.abs(start.x - end.x);
         ellipse.height = Math.abs(start.y - end.y);
         
         elem.setAttribute("shape", "circle");
         elem.setAttribute("coords",
                 (int) (ellipse.x + ellipse.width / 2d)+","+
                 (int) (ellipse.y + ellipse.height / 2d)+","+
                 (int) (ellipse.width / 2d)
                 );
         writeHrefAttribute(elem, f);
         return bounds.intersects(ellipse.getBounds());
     } else {
         return writePolyAttributes(elem, f, (Shape) ellipse);
     }
 }
예제 #9
0
  private boolean isSignificantMouseMove() {
    if (zoomBoxEnd == null) return false;

    if (Math.abs(zoomBoxStart.x - zoomBoxEnd.x) < MIN_MOVEMENT) return false;
    if (Math.abs(zoomBoxStart.y - zoomBoxEnd.y) < MIN_MOVEMENT) return false;
    return true;
  }
예제 #10
0
파일: Geometry.java 프로젝트: tewaris/jloda
 /**
  * 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);
 }
예제 #11
0
  /**
   * Tegner raketten.
   *
   * @param g tegneflaten
   */
  public void draw(Graphics2D g) {
    int whichImage = 9;
    int adx = Math.abs((int) _xSpeed);
    int ady = Math.abs((int) _ySpeed);

    if ((_xSpeed < 0) && (adx > 2 * ady)) {
      // W
      whichImage = 0 + _age % 2;
    } else if ((_ySpeed < 0) && (ady > 2 * adx)) {
      // N
      whichImage = 4 + _age % 2;
    } else if ((_xSpeed > 0) && (adx > 2 * ady)) {
      // E
      whichImage = 8 + _age % 2;
    } else if ((_ySpeed > 0) && (ady > 2 * adx)) {
      // S
      whichImage = 12 + _age % 2;
    } else if ((_xSpeed < 0) && (_ySpeed < 0)) {
      // NW
      whichImage = 2 + _age % 2;
    } else if ((_ySpeed < 0) && (_xSpeed > 0)) {
      // NE
      whichImage = 6 + _age % 2;
    } else if ((_ySpeed > 0) && (_xSpeed > 0)) {
      // SE
      whichImage = 10 + _age % 2;
    } else if ((_xSpeed < 0) && (_ySpeed > 0)) {
      // SW
      whichImage = 14 + _age % 2;
    }
    g.drawImage(_movie[whichImage], x, y, null);
  }
예제 #12
0
  void MidpointLine(int x0, int y0, int x1, int y1, Graphics g) {
    if (x0 == x1) {
      for (int i = Math.min(y1, y0); i <= Math.max(y1, y0); i++) {
        WritePixel(x0, i, 10, g);
      }
    } else if (y0 == y1) {
      for (int i = Math.min(x1, x0); i <= Math.max(x1, x0); i++) {
        WritePixel(i, y0, 10, g);
      }
    } else {

      int dx = Math.abs(x1 - x0);
      int dy = Math.abs(y1 - y0);
      int d = dx - dy;
      int sx, sy, d2;
      if (x0 < x1) sx = 1;
      else sx = -1;
      if (y0 < y1) sy = 1;
      else sy = -1;
      do {
        WritePixel(x0, y0, 10, g);
        d2 = d * 2;
        if (d2 > -dy) {
          x0 += sx;
          d -= dy;
        }

        if (d2 < dx) {
          d += dx;
          y0 += sy;
        }

      } while (x0 != x1 && y0 != y1);
    }
  }
예제 #13
0
  public void renderBox(GL gl) {
    gl.glDisable(GL_TEXTURE_2D);
    int c1 = Math.abs(this.hashCode()) % 256;
    int c2 = Math.abs(getImage().hashCode()) % 256;
    gl.glColor4f(c1 / 256f, c2 / 256f, ((c1 + c2) * 34) % 256 / 256f, 0.3f);
    gl.glPushMatrix();
    gl.glTranslatef(bounds.getLeft(), bounds.getTop(), minHeight);
    gl.glScalef(bounds.getWidth(), bounds.getHeight(), maxHeight - minHeight);
    gl.glBegin(GL_QUADS);
    gl.glVertex3f(0, 0, 0);
    gl.glVertex3f(0, 1, 0);
    gl.glVertex3f(1, 1, 0);
    gl.glVertex3f(1, 0, 0);

    gl.glVertex3f(0, 0, 1);
    gl.glVertex3f(0, 1, 1);
    gl.glVertex3f(1, 1, 1);
    gl.glVertex3f(1, 0, 1);
    gl.glEnd();
    gl.glColor4f(1, 1, 0, 0.2f);
    gl.glBegin(GL_QUAD_STRIP);
    gl.glVertex3f(0, 0, 0);
    gl.glVertex3f(0, 0, 1);
    gl.glVertex3f(0, 1, 0);
    gl.glVertex3f(0, 1, 1);
    gl.glVertex3f(1, 1, 0);
    gl.glVertex3f(1, 1, 1);
    gl.glVertex3f(1, 0, 0);
    gl.glVertex3f(1, 0, 1);
    gl.glVertex3f(0, 0, 0);
    gl.glVertex3f(0, 0, 1);
    gl.glEnd();
    gl.glPopMatrix();
  }
예제 #14
0
  public Dimension getDocumentSize() {
    float pageViewWidth = 0;
    float pageViewHeight = 0;
    if (pagesPanel != null) {
      int currCompIndex = documentViewController.getCurrentPageIndex();
      int numComponents = pagesPanel.getComponentCount();
      if (currCompIndex >= 0 && currCompIndex < numComponents) {
        Component comp = pagesPanel.getComponent(currCompIndex);
        if (comp instanceof PageViewDecorator) {
          PageViewDecorator pvd = (PageViewDecorator) comp;
          Dimension dim = pvd.getPreferredSize();
          pageViewWidth = dim.width;
          pageViewHeight = dim.height;
        }
      }
    }
    // normalize the dimensions to a zoom level of zero.
    float currentZoom = documentViewModel.getViewZoom();
    pageViewWidth = Math.abs(pageViewWidth / currentZoom);
    pageViewHeight = Math.abs(pageViewHeight / currentZoom);

    // add any horizontal padding from layout manager
    pageViewWidth += AbstractDocumentView.horizontalSpace * 2;
    pageViewHeight += AbstractDocumentView.verticalSpace * 2;
    return new Dimension((int) pageViewWidth, (int) pageViewHeight);
  }
예제 #15
0
 public boolean containsPoint(int x, int y) {
   int l = Math.min(getStart().x, getEnd().x);
   int t = Math.min(getStart().y, getEnd().y);
   int w = Math.abs(getWidth());
   int h = Math.abs(getHeight());
   if (x >= l && x < l + w && y >= t && y < t + h) return true;
   else return false;
 }
예제 #16
0
 public void paint(Graphics g) {
   g.setColor(Color.black);
   super.paint(g);
   int h = Math.abs(y1 - y2) - 1, w = Math.abs(x1 - x2) - 1;
   // int x0=x1>x2?x2:x1, y0=y1>y2?y2:y1;
   int x0 = 0, y0 = 0;
   g.drawRect(x0, y0, w, h);
 }
예제 #17
0
  private void pitch_horizon(int rad, int[] angles) {
    boolean upside_down = Math.abs(roll_) >= 90;
    int angle_shift = (int) Math.round((double) (90 - (Math.abs(roll_) % 180)) / 90.0 * pitch_);

    //      System.out.println ("angle_shift " + angle_shift);

    angles[0] += angle_shift;
    angles[1] -= angle_shift;
  }
예제 #18
0
  public void update_display(int lat, int lon, int alt, int heading) {
    String lat_str = Math.abs(lat) + "" + DEGREE + ((lat > 0) ? " N" : " S");
    String long_str = Math.abs(lon) + "" + DEGREE + ((lon > 0) ? " E" : " W");

    lat_.setText(lat_str);
    long_.setText(long_str);
    alt_.setText(alt + " Kft");
    heading_.setText(heading + "" + DEGREE + "  ");
  }
예제 #19
0
 void handleMouseMove(int sx, int sy) {
   // Do rubber banding
   int tool = Toolbar.getToolId();
   if (!(tool == Toolbar.POLYGON || tool == Toolbar.POLYLINE || tool == Toolbar.ANGLE)) {
     imp.deleteRoi();
     imp.draw();
     return;
   }
   drawRubberBand(sx, sy);
   degrees = Double.NaN;
   double len = -1;
   if (nPoints > 1) {
     double x1, y1, x2, y2;
     if (xpf != null) {
       x1 = xpf[nPoints - 2];
       y1 = ypf[nPoints - 2];
       x2 = xpf[nPoints - 1];
       y2 = ypf[nPoints - 1];
     } else {
       x1 = xp[nPoints - 2];
       y1 = yp[nPoints - 2];
       x2 = xp[nPoints - 1];
       y2 = yp[nPoints - 1];
     }
     degrees =
         getAngle(
             (int) Math.round(x1),
             (int) Math.round(y1),
             (int) Math.round(x2),
             (int) Math.round(y2));
     if (tool != Toolbar.ANGLE) {
       Calibration cal = imp.getCalibration();
       double pw = cal.pixelWidth, ph = cal.pixelHeight;
       if (IJ.altKeyDown()) {
         pw = 1.0;
         ph = 1.0;
       }
       len = Math.sqrt((x2 - x1) * pw * (x2 - x1) * pw + (y2 - y1) * ph * (y2 - y1) * ph);
     }
   }
   if (tool == Toolbar.ANGLE) {
     if (nPoints == 2) angle1 = degrees;
     else if (nPoints == 3) {
       double angle2 = getAngle(xp[1], yp[1], xp[2], yp[2]);
       degrees = Math.abs(180 - Math.abs(angle1 - angle2));
       if (degrees > 180.0) degrees = 360.0 - degrees;
     }
   }
   String length = len != -1 ? ", length=" + IJ.d2s(len) : "";
   double degrees2 =
       tool == Toolbar.ANGLE && nPoints == 3 && Prefs.reflexAngle ? 360.0 - degrees : degrees;
   String angle = !Double.isNaN(degrees) ? ", angle=" + IJ.d2s(degrees2) : "";
   int ox = ic != null ? ic.offScreenX(sx) : sx;
   int oy = ic != null ? ic.offScreenY(sy) : sy;
   IJ.showStatus(imp.getLocationAsString(ox, oy) + length + angle);
 }
예제 #20
0
  public void paint(Graphics g) {
    System.out.println("paint");
    Graphics2D g2d = (Graphics2D) g;

    Point1 p1, p2;

    n = paintInfo.size();

    if (toolFlag == 2) g2d.clearRect(0, 0, getSize().width - 100, getSize().height - 100); // 清除

    for (int i = 0; i < n - 1; i++) {
      p1 = (Point1) paintInfo.elementAt(i);
      p2 = (Point1) paintInfo.elementAt(i + 1);
      size = new BasicStroke(p1.boarder, BasicStroke.CAP_BUTT, BasicStroke.JOIN_BEVEL);

      g2d.setColor(p1.col);
      g2d.setStroke(size);

      if (p1.tool == p2.tool) {
        switch (p1.tool) {
          case 0: // 画笔
            Line2D line1 = new Line2D.Double(p1.x, p1.y, p2.x, p2.y);
            g2d.draw(line1);
            break;

          case 1: // 橡皮
            g.clearRect(p1.x, p1.y, p1.boarder, p1.boarder);
            break;

          case 3: // 画直线
            Line2D line2 = new Line2D.Double(p1.x, p1.y, p2.x, p2.y);
            g2d.draw(line2);
            break;

          case 4: // 画圆
            Ellipse2D ellipse =
                new Ellipse2D.Double(p1.x, p1.y, Math.abs(p2.x - p1.x), Math.abs(p2.y - p1.y));
            g2d.draw(ellipse);
            break;

          case 5: // 画矩形
            Rectangle2D rect =
                new Rectangle2D.Double(p1.x, p1.y, Math.abs(p2.x - p1.x), Math.abs(p2.y - p1.y));
            g2d.draw(rect);
            break;

          case 6: // 截断,跳过
            i = i + 1;
            break;

          default:
        } // end switch
      } // end if
    } // end for
  }
예제 #21
0
  public void setXY(double x, double y) {
    // not validated
    // x and y between -1 and 1
    double sigmoidSteepness, sigmoidZero, baseLength;
    double sensitivity =
        1.1; // evaluated with set to 1.1: a sensitivity of 1 means the complete space of the button
             // is used. 2 means only the middle part is used, making it more sensitive and more
             // easy to get to extreme arousal (from a CHI perspective).
    if (!down) {
      p = x * sensitivity;
      d = y * sensitivity;
      baseLength = Math.max(Math.abs(p), Math.abs(d)); // MAX (P, D) base
      // baseLength=Math.sqrt(Math.pow(p,2)+Math.pow(d,2))/Math.sqrt(2.0); //euclid P,D base

      // now do the mapping to arousal.
      // Arousal is controlled simple by using a Sigmoid function based on length of PD vector
      sigmoidSteepness = 11;
      sigmoidZero = 8;
      a = 2 / (1 + Math.exp(-(sigmoidSteepness * baseLength - sigmoidZero))) - 1;
      a_base = a;
      // Arousal is controlled simply by using a quadratic function that has 0,0,0 as middle point,
      // then drops to -1, then to 1 based MIN (P,D) length (mimics better original linear)
      // sigmoidSteepness=6;
      // sigmoidZero=0.35;
      // a=sigmoidSteepness*Math.pow(Math.max(Math.abs(p),Math.abs(d))-sigmoidZero, 2)-1;

      p = (p > 1 ? 1 : (p < -1 ? -1 : p));
      d = (d > 1 ? 1 : (d < -1 ? -1 : d));
      a = (a > 1 ? 1 : (a < -1 ? -1 : a));

    } else {
      double tmp_p, tmp_d;
      tmp_p = x * sensitivity;
      tmp_d = y * sensitivity;
      baseLength = Math.max(Math.abs(tmp_p), Math.abs(tmp_d)); // MAX (P, D) base
      // baseLength=Math.sqrt(Math.pow(p,2)+Math.pow(d,2))/Math.sqrt(2.0); //euclid P,D base

      // now do the mapping to arousal.
      // Arousal is controlled simple by using a Sigmoid function based on length of PD vector
      sigmoidSteepness = 11;
      sigmoidZero = 8;
      // a=a_base-(d-tmp_d)+2/(1+Math.exp(-(sigmoidSteepness*baseLength-sigmoidZero)))-1;
      a = tmp_d;
      // Arousal is controlled simply by using a quadratic function that has 0,0,0 as middle point,
      // then drops to -1, then to 1 based MIN (P,D) length (mimics better original linear)
      // sigmoidSteepness=6;
      // sigmoidZero=0.35;
      // a=sigmoidSteepness*Math.pow(Math.max(Math.abs(p),Math.abs(d))-sigmoidZero, 2)-1;

      // p=(p>1?1:(p<-1?-1:p));
      // d=(d>1?1:(d<-1?-1:d));
      a = (a > 1 ? 1 : (a < -1 ? -1 : a));
    }
  }
예제 #22
0
  public boolean ManipBoxPattern(int xMin, int yMin, int xMax, int yMax, double amount) {
    int x;
    int y;
    y = yMin;
    while (y < yMax) {
      x = xMin;
      while (x < xMax) {
        Pixel p = this.getPixel(x, y);
        int yOffset = Math.abs(yMin - y);
        int xOffset = Math.abs(xMin - x);

        double ra = normal(x, xMin, xMax);

        if (ra >= 1.0) {

          int R = (int) (p.getRed() * amount);
          int G = (int) (p.getGreen() * amount);
          int B = (int) (255 * amount);

          p.setRed(R);
          p.setGreen(G);
          p.setBlue(B);

          p.getColor().brighter();
        } else {

          int R = (int) (p.getRed() * amount);
          int G = (int) (255 * amount);
          int B = (int) (p.getBlue() * amount);

          p.setRed(R);
          p.setGreen(G);
          p.setBlue(B);
        }

        if (x % 2 == 0) {

          int R = (int) (255 * amount);
          int G = (int) (p.getGreen() * amount);
          int B = (int) (p.getBlue() * amount);

          p.setRed(R);
          p.setGreen(G);
          p.setBlue(B);
        }
        x = x + 1;
      }
      y = y + 1;
    }

    return true;
  }
예제 #23
0
 private void squareGradient(int[] pixels, int y, int w, int h) {
   int off = 0;
   float radius = Math.max(Math.abs(p2.x - p1.x), Math.abs(p2.y - p1.y));
   for (int x = 0; x < w; x++) {
     float distance = Math.max(Math.abs(x - p1.x), Math.abs(y - p1.y));
     float ratio = distance / radius;
     if (repeat) ratio = ratio % 2;
     else if (ratio > 1.0) ratio = 1.0f;
     int rgb = colormap.getColor(map(ratio));
     pixels[off] = PixelUtils.combinePixels(rgb, pixels[off], paintMode);
     off++;
   }
 }
예제 #24
0
    private Line addLine(Point p1, Point p2) {
      if (Math.abs(p1.getX() - p2.getX()) < 5 || Math.abs(p1.getY() - p2.getY()) < 5) {
        return null;
      }

      Line line = null;
      if (p1 != null && p2 != null) {
        line = new Line(p1, p2);
        canvas.add(line);
      }
      repaint();
      return line;
    }
예제 #25
0
  public void mouseDrag(MouseEvent e, int x, int y) {
    super.mouseDrag(e, x, y);
    fMoved = (Math.abs(x - fAnchorX) > 4) || (Math.abs(y - fAnchorY) > 4);

    if (fMoved) {
      FigureEnumeration figures = getUndoActivity().getAffectedFigures();
      while (figures.hasMoreElements()) {
        figures.nextFigure().moveBy(x - fLastX, y - fLastY);
      }
    }
    fLastX = x;
    fLastY = y;
  }
 private String readablePeriod(Period period) {
   if (period.isZero()) return "Hoy";
   String startsWith = period.isNegative() ? "Hace " : "En ";
   long months = Math.abs(period.toTotalMonths());
   int days = Math.abs(period.getDays());
   if (Math.abs(months) > 0) {
     String endsWith = (months > 1) ? "es" : "";
     return startsWith + months + " mes" + endsWith;
   } else {
     String endsWith = (days > 1) ? "s" : "";
     return startsWith + days + " dia" + endsWith;
   }
 }
예제 #27
0
 /**
  * When the ERASE or SMUDGE tools are used and the mouse jumps from (x1,y1) to (x2,y2), the tool
  * has to be applied to a line of pixel positions between the two points in order to cover the
  * entire line that the mouse moves along. The change is made to the off-screen canvas, and
  * repaint() is called to copy the changes to the screen.
  */
 void applyToolAlongLine(int x1, int y1, int x2, int y2) {
   Graphics g = OSC.getGraphics();
   g.setColor(fillColor); // (for ERASE only)
   int w = OSC.getWidth(); // (for SMUDGE only)
   int h = OSC.getHeight(); // (for SMUDGE only)
   int dist = Math.max(Math.abs(x2 - x1), Math.abs(y2 - y1));
   // dist is the number of points along the line from
   // (x1,y1) to (x2,y2) at which the tool will be applied.
   double dx = (double) (x2 - x1) / dist;
   double dy = (double) (y2 - y1) / dist;
   for (int d = 1; d <= dist; d++) {
     // Apply the tool at one of the points (x,y) along the
     // line from (x1,y1) to (x2,y2).
     int x = (int) Math.round(x1 + dx * d);
     int y = (int) Math.round(y1 + dy * d);
     if (currentTool == Tool.ERASE) {
       // Erase a 10-by-10 block of pixels around (x,y)
       g.fillRect(x - 5, y - 5, 10, 10);
       repaint(x - 5, y - 5, 10, 10);
     } else {
       // For the SMUDGE tool, blend some of the color from
       // the smudgeRed, smudgeGreen, and smudgeBlue arrays
       // into the pixels in a 7-by-7 block around (x,y), and
       // vice versa.  The effect is to smear out the color
       // of pixels that are visited by the tool.
       for (int i = 0; i < 7; i++) {
         for (int j = 0; j < 7; j++) {
           int r = y + j - 3;
           int c = x + i - 3;
           if (!(r < 0 || r >= h || c < 0 || c >= w || smudgeRed[i][j] == -1)) {
             int curCol = OSC.getRGB(c, r);
             int curRed = (curCol >> 16) & 0xFF;
             int curGreen = (curCol >> 8) & 0xFF;
             int curBlue = curCol & 0xFF;
             int newRed = (int) (curRed * 0.7 + smudgeRed[i][j] * 0.3);
             int newGreen = (int) (curGreen * 0.7 + smudgeGreen[i][j] * 0.3);
             int newBlue = (int) (curBlue * 0.7 + smudgeBlue[i][j] * 0.3);
             int newCol = newRed << 16 | newGreen << 8 | newBlue;
             OSC.setRGB(c, r, newCol);
             smudgeRed[i][j] = curRed * 0.3 + smudgeRed[i][j] * 0.7;
             smudgeGreen[i][j] = curGreen * 0.3 + smudgeGreen[i][j] * 0.7;
             smudgeBlue[i][j] = curBlue * 0.3 + smudgeBlue[i][j] * 0.7;
           }
         }
       }
       repaint(x - 3, y - 3, 7, 7);
     }
   }
   g.dispose();
 }
예제 #28
0
  private int computeDifference(int PIXEL_OG, int PIXEL_MD) {

    int OG_RED = (PIXEL_OG & 0xff0000) >> 16;
    int OG_GREEN = (PIXEL_OG & 0xff00) >> 8;
    int OG_BLUE = (PIXEL_OG & 0xff);

    int MD_RED = (PIXEL_MD & 0xff0000) >> 16;
    int MD_GREEN = (PIXEL_MD & 0xff00) >> 8;
    int MD_BLUE = (PIXEL_MD & 0xff);

    int difference =
        Math.abs(OG_RED - MD_RED) + Math.abs(OG_GREEN - MD_GREEN) + Math.abs(OG_BLUE - MD_BLUE);
    return difference;
  }
    protected void updateNearest(double[] vec, int ax, int ay, int x, int y) {
      int type = this.map[x][y] - 1;
      if (type > -1) {

        int dx = x - ax;
        int dy = y - ay;
        int d = Math.abs(dx) + Math.abs(dy);

        int ind = this.numCells + type;

        if (d < vec[ind]) {
          vec[ind] = d;
        }
      }
    }
예제 #30
0
파일: TriacElm.java 프로젝트: genko/jcirsim
 void doStep() {
   double vac = volts[anode] - volts[cnode]; // typically negative
   double vag = volts[anode] - volts[gnode]; // typically positive
   if (Math.abs(vac - lastvac) > .01 || Math.abs(vag - lastvag) > .01) sim.converged = false;
   lastvac = vac;
   lastvag = vag;
   diode.doStep(volts[inode] - volts[gnode]);
   double icmult = 1 / triggerI;
   double iamult = 1 / holdingI - icmult;
   // System.out.println(icmult + " " + iamult);
   aresistance = (-icmult * ic + ia * iamult > 1) ? .0105 : 10e5;
   // System.out.println(vac + " " + vag + " " + sim.converged + " " + ic + " " + ia + " " +
   // aresistance + " " + volts[inode] + " " + volts[gnode] + " " + volts[anode]);
   sim.stampResistor(nodes[anode], nodes[inode], aresistance);
 }