BezShape (Javadocs: IgnoCodeLib)

+Example

/*
 * Demonstrates the basics of creating BezShapes and loading them into a list.  
 * Steps through the list to draw shapes to the display or write them to a file.
 * Demonstrates methods for creating colors and adding them to a palette that can
 * be used in Processing and exported to an Illustrator file.  
 * Note that display in Illustrator appears flipped on a horizontal axis because
 * Illustrator and Processing use different coordinate systems. Other examples 
 * show various solutions to this problem: the simplest remedy is to use the
 * writeWithAITransform() method in a DocumentComponent.
 */

import java.util.*;
import java.io.*;  
import com.ignotus.aifile.*;   // library that defines AIFileWriter and static file i/o methods
import com.ignotus.geom.*;   

/** a list of shapes to draw and save */
ArrayList shapes;
/** a palette of colors, stored as 32-bit integers */
ArrayList farben;
/** the file we'll save to */
String fileName = "simple.ai";


public void setup() {
  size(480,720);
  background(127);
  smooth();
  shapes = new ArrayList();
  farben = new ArrayList();
  createColors();
  createShapes();
  println("type 's' to output file");
}


/**
 * To draw, we just step through the shapes and tell each one to draw, passing
 * in a reference to the Processing PApplet "this" so that the shapes have access
 * to Processing's drawing functions. 
 */
public void draw() {
  for (BezShape bez : shapes) {
     bez.draw(); 
  }
}


void keyPressed() {
  if (key == 's') {
    saveAI(fileName, shapes, farben);
  }  
}


/**
 * Add some colors to the farben array. The static method Palette.colorPermutation
 * returns an array of all the unique permutations of the r, g and b color volues.
 */
public void createColors() {
  color c = color(32, 64, 128);
  farben.add(c);
  c = color(76, 123, 199);
  color[] perm = Palette.colorPermutation(c);
  for (color pc : perm) {
    farben.add(pc);
  }
}


/**
 * We create some shapes
 */
public void createShapes() {
  float x, y, radius, h, w;
  int sides;
  color c;
  int[] channelValues = {34, 55, 89, 144, 233};
  // add a background rectangle
  shapes.add(bgRect());
  for (int i = 0; i < 10; i++) {
    x = random(width);
    y = random(height);
    radius = random(2, 48);
    sides = int(random(3, 18));
    // call static method BezShape.bezRegularPoly to create a regular polygon
    BezShape bez = BezShape.bezRegularPoly(this, x, y, radius, sides);
    // generate a color using randomly selected values from an array for r, g and b
    c = Palette.randColor(channelValues);
    farben.add(c);
    bez.setFillColor(c);
    bez.setStrokeColor(0);
    shapes.add(bez);
  }
  for (int i = 0; i < 10; i++) {
    x = random(width);
    y = random(height);
    w = random(16, 96);
    h = random(16, 96);
    sides = int(random(4, 7));
    // call static method BezShape.bezEllipse to create an ellipse
    BezShape bez = BezShape.bezEllipse(this, x, y, w, h, sides);
    c = Palette.randColor(channelValues);
    farben.add(c);
    bez.setFillColor(c);
    bez.setNoStroke();
    shapes.add(bez);
  }
}


/**
 * Creates a rectangle from four points, with fill and stroke colors
 */
public BezShape bezRect(float left, float top, float right, float bottom, color f, color s) {
  BezShape r = new BezShape(this, left, top);
  r.setFillColor(f);
  r.setStrokeColor(s);
  r.setWeight(3.0);
  r.append(right, top);
  r.append(right, bottom);
  r.append(left, bottom);
  r.append(left, top);
  return r;
}


public BezShape bgRect() {
  color f = color(233, 231, 236);
  color s = color(21, 34, 55);
  return bezRect(0, height, width, 0, f, s);
}


 /**
  * saves shapes to an Adobe Illustrator file
  * Illustrator and Porcessing use different coordinate systems, so the AI file
  * will look the Processing window flipped on its horizontal axis.
  * @param aiFilename   name fo the file to save to
  * @param comps        an array of BezShapes to save to the file
  * @param colors       an array of Processing colors to use as the palette
  */
public void saveAI(String aiFilename, ArrayList comps, ArrayList colors) {
  println("saving Adobe Illustrator file " + aiFilename + "...");
  PrintWriter output = createWriter(aiFilename);
  // create the document
  DocumentComponent doc = new DocumentComponent(this, "Simple Shape Export");
  // get its palette
  Palette pal = doc.getPalette();
  // add black, white, and gray to the palette
  pal.addBlackWhiteGray();
  // add our array of colors to the palette
  pal.addColors(colors);
  // include some information for Illustrator's header
  doc.setCreator("Ignotus");
  doc.setOrg("IgnoStudio");
  // set width and height of the document
  doc.setWidth(width);
  doc.setHeight(height);
  println("adding components...");
  // add the components to the the default layer of the document
  for (BezShape b : comps) {
    doc.add(b);
  }
  // writeWithAITransform(output) will transform Processing geometry 
  // into the Adobe Illustrator coordinate system
  doc.write(output);
}

Field Summary
`BezShape.BezType`	`bezType` type of BEZ_PATH, BEZ_TRIANGLE, BEZ_CIRCLE, BEZ_ELLIPSE, BEZ_CURVE_POLY, BEZ_REGULAR_POLY, etc.
`static int`	`CURVE_SEGMENT` flag for curve segment type, associated with BezVertex
`static double`	`KAPPA` KAPPA = (distance between Bezier anchor and its associated control point) / (circle radius) when a circle is divided into 4 sectors of 90 degrees.
`static int`	`LINE_SEGMENT` flag for line segment type, associated with LineVertex

Constructor Summary
`BezShape(PApplet parent)` Creates a closed shape with initial point 0,0 Fill, stroke, and weight of shapes are set from their values in the Processing environment.
`BezShape(PApplet parent, float x, float y)` Creates a closed shape with initial point x,y.
`BezShape(PApplet parent, float x, float y, boolean isClosed)` Creates a BezShape with initial point x,y, closed or open according to the value of isClosed.
`BezShape(PApplet parent, float ax1, float ay1, float cx1, float cy1, float cx2, float cy2, float ax2, float ay2)` Creates a closed BezShape with initial point ax1, ay1, and appends a curve segment.
`BezShape(PApplet parent, float ax1, float ay1, float cx1, float cy1, float cx2, float cy2, float ax2, float ay2, boolean isClosed)` Creates a BezShape with initial point ax1, ay1, and appends a curve segment.

Method Summary
`void`	`accept(ComponentVisitor visitor)` Accepts a ComponentVisitor that traverses a document structure tree.
`void`	`accept(ComponentVisitor visitor, boolean order)` Accepts a ComponentVisitor that traverses a document structure tree in preorder or postorder.
`void`	`add(ArrayList<? extends DisplayComponent> comps)` Adds all components in a list to this component, throws an `UnsupportedOperationException` if component is terminal.
`void`	`add(DisplayComponent component)` Adds a component to children of this component, throws an `UnsupportedOperationException` if component is terminal.
`void`	`append(float x, float y)` Appends a LineVertex (line segment) to this BezShape.
`void`	`append(float cx1, float cy1, float cx2, float cy2, float x, float y)` Appends a BezVertex (cubic B�zier segment) to this BezShape.
`void`	`append(Vertex2DINF vt)` Appends a Vertex2DINF to this BezShape
`float[]`	`asPolygon()`
`float[]`	`asPolygon(int steps)`
`float[]`	`asPolygon(PApplet parent)` Extracts an approximated polygon from path data.
`float[]`	`asPolygon(PApplet parent, int steps)` Extracts an approximated polygon from path data, returning it as an array of floats.
`static BezCircle`	`bezCircle(PApplet parent, float xctr, float yctr, float radius, int sectors)` Creates a circular BezShape with sectors number of Bezier curves.
`static BezShape`	`bezCurve(PApplet parent, float ax1, float ay1, float cx1, float cy1, float cx2, float cy2, float ax2, float ay2)` Constructs a single B�zier curve.
`static BezCurveShape`	`bezCurveShape(PApplet parent, float[] coords)` Returns a multi-segment B�zier curve from an array of float.
`static BezEllipse`	`bezEllipse(PApplet parent, float xctr, float yctr, float width, float height, int sectors)` Creates an elliptical BezShape with sectors number of Bezier curves.
`static BezLine`	`bezLine(PApplet parent, float x1, float y1, float x2, float y2)` Constructs a straight line between (x1, y1) and (x2, y2).
`static BezMultiCurve`	`bezMultiCurve(PApplet parent, float[] coords)` Constructs a multi-segment B�zier curve from an array of float.
`static BezMultiLine`	`bezMultiLine(PApplet parent, float[] coords)` Constructs a multi-segment line from an array of float.
`static BezPoly`	`bezPoly(PApplet parent, float[] coords)` Constructs a multi-segment line from an array of float.
`static BezRectangle`	`bezRectangle(PApplet parent, float left, float top, float right, float bottom)` Constructs a rectangular BezShape.
`static BezRegularPoly`	`bezRegularPoly(PApplet parent, float xctr, float yctr, float radius, int sides)` Constructs a regular polygon BezShape with `sides` edges and radius `radius`.
`static BezTriangle`	`bezTriangle(PApplet parent, float xctr, float yctr, float radius)` Constructs an equilateral triangle with supplied center (xctr, yctr) and radius.
`static BezTriangle`	`bezTriangle(PApplet parent, float x1, float y1, float x2, float y2, float x3, float y3)` Constructs a triangle from three points.
`BezShape.BezType`	`bezType()`
`float[]`	`bounds()` returns array of floats with top, left, bottom, right coordinates of bounding box These are an approximation based on the derived polygon, accuracy can be improved by first calling asPolygon with an argument greater than the default of 16 segments per curve.
`float[]`	`bounds(PApplet parent)` returns array of floats with top, left, bottom, right coordinates of bounding box These are an approximation based on the derived polygon, accuracy can be improved by first calling asPolygon with an argument greater than the default of 16 segments per curve.
`BezRectangle`	`boundsRect()` Returns the bounding rectangle of this shape.
`void`	`calculateCenter()` Sets the center of transformation to the center of the bounding rectangle of this shape.
`LineVertex`	`centerVertex()`
`ArrayList<DisplayComponent>`	`children()` Returns `null`: this is a terminal node, with no children.
`BezShape`	`clone()` Creates a deep copy of this BezShape.
`boolean`	`containsPoint(float x, float y)`
`boolean`	`containsPoint(PApplet parent, float x, float y)` Tests if a point is inside this shape by generating a polygon approximation to curved paths and testing that.
`ListIterator<Vertex2DINF>`	`curveIterator()` Returns an iterator over the geometry of this shape.
`ArrayList<Vertex2DINF>`	`curves()` Returns the geometry of this shape as an `ArrayList`.
`ArrayList<Vertex2DINF>`	`curvesCopy()` Returns a copy of the geometry of this shape as an `ArrayList`.
`void`	`draw()` Draws this shape to the display.
`void`	`draw(PGraphics pg)` Draws this shape to an offscreen PGraphics.
`void`	`drawQuick()` Draws this shape to the display.
`int`	`fillColor()`
`int`	`fillOpacity()`
`DisplayComponent`	`get(int index)` Returns the component at index from the children of this component, throws an `UnsupportedOperationException` if component is terminal.
`LineVertex`	`getAnchorCenter(BezShape shape)` Returns the average of all anchor points of the vertices of this shape.
`LineVertex`	`getBoundsCenter()` Returns the center of the bounding rectangle of this shape as a LineVertex.
`float[]`	`getCoords()` Returns an array of all vertex coordinates.
`Matrix3`	`getCtm()` Returns a copy of the most recent transformation matrix.
`LineVertex`	`getGeoCenter()` Returns the average of the x- and y-coordinates of this shape as a `LineVertex`.
`static Matrix3`	`getMatrix(PApplet applet)` Captures a transformation matrix from a PApplet, for later use.
`boolean`	`hasFill()`
`boolean`	`hasStroke()`
`boolean`	`isClosed()`
`boolean`	`isTerminal()` Returns `true`: this is a terminal component.
`Iterator<DisplayComponent>`	`iterator()` Returns an iterator over children, throws an `UnsupportedOperationException` if component is terminal.
`void`	`moveTo(float newXCtr, float newYCtr)` Handy method to translate center point (xctr, yctr) and shape to a new location.
`int`	`polySize()`
`int`	`polySize(PApplet parent)`
`int`	`polySteps()` Returns the number of straight line segments used in fast calculation
`boolean`	`remove(DisplayComponent component)` Removes a component from children of this component, throws an `UnsupportedOperationException` if component is terminal.
`void`	`rotateShape(float theta)` Rotates this shape around its center point.
`void`	`rotateShape(float xctr, float yctr, float theta)` Rotates this shape around a supplied center point.
`void`	`scaleShape(float xyScale)` Uniformly scales this shape around its center point.
`void`	`scaleShape(float xScale, float yScale)` Scales this shape around its center point.
`void`	`scaleShape(float xyScale, float x0, float y0)` Uniformly scales this shape around a given point.
`void`	`scaleShape(float xScale, float yScale, float x0, float y0)` Scales this shape around a given point.
`void`	`setBezType(BezShape.BezType newBezType)`
`void`	`setCenter(float xctr, float yctr)` Sets center point for geometric transforms on this shape.
`void`	`setCenter(LineVertex centerPoint)` Sets the values of `xctr` and `yctr`
`void`	`setCenter(Point2D pt)` Sets center point for geometric transforms on this shape.
`void`	`setColors(PApplet host)` Sets fill and stroke using the current graphics state.
`void`	`setCtm(Matrix3 ctm)`
`void`	`setCtm(PApplet applet)` Captures the current transformation matrix from a PApplet and uses it to set our ctm.
`void`	`setCtm(PMatrix2D m)` Sets our ctm from a PMatrix2D.
`void`	`setCurves(ArrayList<Vertex2DINF> newCurves)`
`void`	`setFillColor(int newFillColor)` Sets the current fill color.
`void`	`setFillOpacity(int opacity)` Sets opacity of current fill color.
`void`	`setHasFill(boolean newHasFill)`
`void`	`setHasStroke(boolean newHasStroke)`
`void`	`setIsClosed(boolean newIsClosed)`
`void`	`setNoFill()` Equivalent to setHasFill(false).
`void`	`setNoStroke()` Equivalent to setHasStroke(false).
`void`	`setPolySteps(int newPolySteps)`
`void`	`setStartPoint(float newX, float newY)` Sets a new initial vertex for this BezShape.
`void`	`setStartPoint(LineVertex startPoint)`
`void`	`setStartPoint(Point2D pt)` Sets a new initial vertex for this BezShape.
`void`	`setStrokeColor(int newStrokeColor)` Sets the current stroke color.
`void`	`setStrokeOpacity(int opacity)` Sets opacity of current stroke color.
`static void`	`setUseTransparency(boolean useTransparency)` Deprecated. preferred usage is `AIFileWriter.setUseTransparency()`.
`void`	`setWeight(float newWeight)`
`void`	`setX(float newX)` Sets the x-coordinate of the initial point of the geometry of this shape.
`void`	`setY(float newY)` Sets the y-coordinate of the initial point of the geometry of this shape.
`LineVertex`	`startVertex()`
`float[]`	`startVertexArray()` return initial vertex as an array of two floats
`int`	`strokeColor()`
`int`	`strokeOpacity()`
`void`	`transform()` Calls transform with this shape's ctm, current transformation matrix.
`void`	`transform(Matrix3 matx)` Performs an affine geometric transformation on this shape using 3x3 matrix multiplication.
`void`	`transformShape(Matrix3 matx)` Deprecated.
`void`	`translateShape(float xTrans, float yTrans)` Translates this shape.
`static boolean`	`useTransparency()`
`float`	`weight()` Returns the current weight (in points) of stroked lines.
`void`	`write(int pathOp, PrintWriter output)` Writes Adobe Illustrator 7.0 tags describing the geometry of this shape to PrintWriter.
`void`	`write(PrintWriter pw)` Writes Adobe Illustrator 7.0 tags describing the geometry of this shape to PrintWriter.
`float`	`x()` Returns the x-coordinate of the initial point of the geometry of this shape.
`float[]`	`xcoords()`
`float[]`	`xcoords(PApplet parent)` Returns x-coordinates of the geometry of this shape.
`float`	`xctr()` Returns the value of the x-coordinate of center of transformation.
`float`	`y()` Returns the y-coordinate of the initial point of the geometry of this shape.
`float[]`	`ycoords()`
`float[]`	`ycoords(PApplet parent)` Returns y-coordinates of the geometry of this shape.
`float`	`yctr()` Returns the of the y-coordinate of center of transformation.

com.ignotus.aifile Class BezShape

LINE_SEGMENT

CURVE_SEGMENT

bezType

KAPPA

BezShape

BezShape

BezShape

BezShape

BezShape

clone

add

add

remove

get

iterator

children

isTerminal

append

append

append

isClosed

setIsClosed

setColors

hasFill

setHasFill

setNoFill

hasStroke

setHasStroke

setNoStroke

fillColor

setFillColor

strokeColor

setStrokeColor

useTransparency

setUseTransparency

setFillOpacity

fillOpacity

setStrokeOpacity

strokeOpacity

weight

setWeight

bezType

setBezType

x

setX

y

setY

startVertex

setStartPoint

setStartPoint

setStartPoint

startVertexArray

xctr

yctr

centerVertex

setCenter

setCenter

setCenter

calculateCenter

getBoundsCenter

getAnchorCenter

getGeoCenter

curveIterator

curves

curvesCopy

setCurves

getCoords

asPolygon

asPolygon

asPolygon

asPolygon

containsPoint

containsPoint

xcoords

xcoords

ycoords

ycoords

polySize

polySize

com.ignotus.aifile
Class BezShape