Package java.awt.geom

Examples of java.awt.geom.FlatteningPathIterator


    private static final float FLATNESS = 1;

    public Shape createStrokedShape (Shape shape) {
      GeneralPath result = new GeneralPath();
      shape = new BasicStroke(getWidth(), BasicStroke.CAP_SQUARE, getJoin()).createStrokedShape(shape);
      PathIterator it = new FlatteningPathIterator(shape.getPathIterator(null), FLATNESS);
      float points[] = new float[6];
      float moveX = 0, moveY = 0;
      float lastX = 0, lastY = 0;
      float thisX = 0, thisY = 0;
      int type = 0;
      float next = 0;
      while (!it.isDone()) {
        type = it.currentSegment(points);
        switch (type) {
        case PathIterator.SEG_MOVETO:
          moveX = lastX = randomize(points[0]);
          moveY = lastY = randomize(points[1]);
          result.moveTo(moveX, moveY);
          next = 0;
          break;

        case PathIterator.SEG_CLOSE:
          points[0] = moveX;
          points[1] = moveY;
          // Fall into....

        case PathIterator.SEG_LINETO:
          thisX = randomize(points[0]);
          thisY = randomize(points[1]);
          float dx = thisX - lastX;
          float dy = thisY - lastY;
          float distance = (float)Math.sqrt(dx * dx + dy * dy);
          if (distance >= next) {
            float r = 1.0f / distance;
            while (distance >= next) {
              float x = lastX + next * dx * r;
              float y = lastY + next * dy * r;
              result.lineTo(randomize(x), randomize(y));
              next += detail;
            }
          }
          next -= distance;
          lastX = thisX;
          lastY = thisY;
          break;
        }
        it.next();
      }

      return result;
    }
View Full Code Here


  {
    FontRenderContext frc = new FontRenderContext( null, true, true );
    GlyphVector glyphVector = font.createGlyphVector( frc, text );

    GeneralPath result = new GeneralPath();
    PathIterator it = new FlatteningPathIterator( shape.getPathIterator( null ), FLATNESS );
    float points[] = new float[6];
    float moveX = 0, moveY = 0;
    float lastX = 0, lastY = 0;
    float thisX = 0, thisY = 0;
    int type = 0;
    // boolean first = false;
    float next = 0;
    int currentChar = 0;
    int length = glyphVector.getNumGlyphs();

    if( length == 0 )
      return result;

    float factor = stretchToFit ? measurePathLength( shape ) / (float)glyphVector.getLogicalBounds().getWidth() : 1.0f;
    float nextAdvance = 0;

    while( currentChar < length && !it.isDone() )
    {
      type = it.currentSegment( points );
      switch( type )
      {
        case PathIterator.SEG_MOVETO:
          moveX = lastX = points[0];
          moveY = lastY = points[1];
          result.moveTo( moveX, moveY );
          // first = true;
          nextAdvance = glyphVector.getGlyphMetrics( currentChar ).getAdvance() * 0.5f;
          next = nextAdvance;
          break;

        case PathIterator.SEG_CLOSE:
          points[0] = moveX;
          points[1] = moveY;
          // Fall into....

        case PathIterator.SEG_LINETO:
          thisX = points[0];
          thisY = points[1];
          float dx = thisX - lastX;
          float dy = thisY - lastY;
          float distance = (float)Math.sqrt( dx * dx + dy * dy );
          if( distance >= next )
          {
            float r = 1.0f / distance;
            float angle = (float)Math.atan2( dy, dx );
            while( currentChar < length && distance >= next )
            {
              Shape glyph = glyphVector.getGlyphOutline( currentChar );
              Point2D p = glyphVector.getGlyphPosition( currentChar );
              float px = (float)p.getX();
              float py = (float)p.getY();
              float x = lastX + next * dx * r;
              float y = lastY + next * dy * r;
              float advance = nextAdvance;
              nextAdvance = currentChar < length - 1 ? glyphVector.getGlyphMetrics( currentChar + 1 ).getAdvance() * 0.5f : 0;
              t.setToTranslation( x, y );
              t.rotate( angle );
              t.translate( -px - advance, -py );
              result.append( t.createTransformedShape( glyph ), false );
              next += ( advance + nextAdvance ) * factor;
              currentChar++;
              if( repeat )
                currentChar %= length;
            }
          }
          next -= distance;
          // first = false;
          lastX = thisX;
          lastY = thisY;
          break;
      }
      it.next();
    }

    return result;
  }
View Full Code Here

   *            the shape
   * @return the float
   */
  public float measurePathLength( Shape shape )
  {
    PathIterator it = new FlatteningPathIterator( shape.getPathIterator( null ), FLATNESS );
    float points[] = new float[6];
    float moveX = 0, moveY = 0;
    float lastX = 0, lastY = 0;
    float thisX = 0, thisY = 0;
    int type = 0;
    float total = 0;

    while( !it.isDone() )
    {
      type = it.currentSegment( points );
      switch( type )
      {
        case PathIterator.SEG_MOVETO:
          moveX = lastX = points[0];
          moveY = lastY = points[1];
          break;

        case PathIterator.SEG_CLOSE:
          points[0] = moveX;
          points[1] = moveY;
          // Fall into....

        case PathIterator.SEG_LINETO:
          thisX = points[0];
          thisY = points[1];
          float dx = thisX - lastX;
          float dy = thisY - lastY;
          total += (float)Math.sqrt( dx * dx + dy * dy );
          lastX = thisX;
          lastY = thisY;
          break;
      }
      it.next();
    }

    return total;
  }
View Full Code Here

    protected void initialise() {

  pathLength = 0f;

  FlatteningPathIterator fpi = new FlatteningPathIterator(path.getPathIterator(new AffineTransform()), 0.01f);
  segments = new Vector(20);
  float lastMoveX = 0f;
  float lastMoveY = 0f;
  float currentX = 0f;
  float currentY = 0f;
  float seg[] = new float[6];
  int segType;
   
  segments.add(new PathSegment(PathIterator.SEG_MOVETO, 0f, 0f, 0f));

  while (!fpi.isDone()) {
     
      segType = fpi.currentSegment(seg);
     
      switch (segType) {
   
      case PathIterator.SEG_MOVETO:
   
    //System.out.println("== MOVE TO " + seg[0] + " " + seg[1]);
   
    segments.add(new PathSegment(segType, seg[0], seg[1], pathLength));
    currentX = seg[0];
    currentY = seg[1];
    lastMoveX = currentX;
    lastMoveY = currentY;
   
    break;
   
      case PathIterator.SEG_LINETO:
   
    //System.out.println("== LINE TO " + seg[0] + " " + seg[1]);
   
    pathLength += Point2D.distance(currentX, currentY, seg[0], seg[1]);
    segments.add(new PathSegment(segType, seg[0], seg[1], pathLength));

    currentX = seg[0];
    currentY = seg[1];
   
    break;
   
      case PathIterator.SEG_CLOSE:
   
    //System.out.println("== CLOSE TO " + lastMoveX + " " + lastMoveY);

    pathLength += Point2D.distance(currentX, currentY, lastMoveX, lastMoveY);
    segments.add(new PathSegment(PathIterator.SEG_LINETO, lastMoveX, lastMoveY, pathLength));
       
    currentX = lastMoveX;
    currentY = lastMoveY;
       
    break;

      default:
       
    // ouch, where have these come from
    System.out.println("Bad path segment types");
   
      }
     
      fpi.next();
     
  }

  initialised = true;
View Full Code Here

    /**
     * @see java.awt.Stroke#createStrokedShape(java.awt.Shape)
     */
    public Shape createStrokedShape (Shape shape) {
      GeneralPath result = new GeneralPath();
      PathIterator it = new FlatteningPathIterator(shape.getPathIterator(null), FLATNESS);
      float points[] = new float[6];
      float moveX = 0, moveY = 0;
      float lastX = 0, lastY = 0;
      float thisX = 0, thisY = 0;
      int type = 0;
      float next = 0;
      int phase = 0;
      while (!it.isDone()) {
        type = it.currentSegment(points);
        switch (type) {
        case PathIterator.SEG_MOVETO:
          moveX = lastX = points[0];
          moveY = lastY = points[1];
          result.moveTo(moveX, moveY);
          next = wavelength / 2;
          break;

        case PathIterator.SEG_CLOSE:
          points[0] = moveX;
          points[1] = moveY;
          // Fall into....

        case PathIterator.SEG_LINETO:
          thisX = points[0];
          thisY = points[1];
          float dx = thisX - lastX;
          float dy = thisY - lastY;
          float distance = (float)Math.sqrt(dx * dx + dy * dy);
          if (distance >= next) {
            float r = 1.0f / distance;
            while (distance >= next) {
              float x = lastX + next * dx * r;
              float y = lastY + next * dy * r;
              if ((phase & 1) == 0)
                result.lineTo(x + amplitude * dy * r, y - amplitude * dx * r);
              else
                result.lineTo(x - amplitude * dy * r, y + amplitude * dx * r);
              next += wavelength;
              phase++;
            }
          }
          next -= distance;
          lastX = thisX;
          lastY = thisY;
          if (type == PathIterator.SEG_CLOSE) result.closePath();
          break;
        }
        it.next();
      }
      return new BasicStroke(getWidth(), BasicStroke.CAP_SQUARE, getJoin()).createStrokedShape(result);
    }
View Full Code Here

     * @see java.awt.Stroke#createStrokedShape(java.awt.Shape)
     */
    public Shape createStrokedShape (Shape shape) {
      GeneralPath result = new GeneralPath();
      shape = new BasicStroke(getWidth(), BasicStroke.CAP_SQUARE, getJoin()).createStrokedShape(shape);
      PathIterator it = new FlatteningPathIterator(shape.getPathIterator(null), FLATNESS);
      float points[] = new float[6];
      float moveX = 0, moveY = 0;
      float lastX = 0, lastY = 0;
      float thisX = 0, thisY = 0;
      int type = 0;
      float next = 0;
      while (!it.isDone()) {
        type = it.currentSegment(points);
        switch (type) {
        case PathIterator.SEG_MOVETO:
          moveX = lastX = randomize(points[0]);
          moveY = lastY = randomize(points[1]);
          result.moveTo(moveX, moveY);
          next = 0;
          break;

        case PathIterator.SEG_CLOSE:
          points[0] = moveX;
          points[1] = moveY;
          // Fall into....

        case PathIterator.SEG_LINETO:
          thisX = randomize(points[0]);
          thisY = randomize(points[1]);
          float dx = thisX - lastX;
          float dy = thisY - lastY;
          float distance = (float)Math.sqrt(dx * dx + dy * dy);
          if (distance >= next) {
            float r = 1.0f / distance;
            while (distance >= next) {
              float x = lastX + next * dx * r;
              float y = lastY + next * dy * r;
              result.lineTo(randomize(x), randomize(y));
              next += detail;
            }
          }
          next -= distance;
          lastX = thisX;
          lastY = thisY;
          break;
        }
        it.next();
      }

      return result;
    }
View Full Code Here

TOP

Related Classes of java.awt.geom.FlatteningPathIterator

Copyright © 2018 www.massapicom. All rights reserved.
All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.