LayerComponent (Javadocs: IgnoCodeLib)

+Example

/**
 * January 29, 2012 3:03:31 PM CST
 * Sample code for IgnoCodeLib Processing library by Paul Hertz
 * Shows how to create a document tree with layers, groups, and shapes and use it to draw 
 * to the screen, perform a global transform, and export to file. 
 */

import java.util.*;
import java.io.*;  
import java.awt.geom.Point2D;
import com.ignotus.aifile.*;   // library that handles Adobe Illustrator document structure and export
import com.ignotus.geom.*;     // library for geometric transforms and matrices

ArrayList farben;
Matrix3 aiTransform;
String fileName = "documentExport.ai";
DocumentComponent doc;


public void setup() {
  size(480,720);
  background(127);
  smooth();
  farben = new ArrayList();
  setupTransform();
  // we'll create the document up front and use it for drawing and saving
  createDocument();
  println("type 's' to output file");
}


public void draw() {
  // the document knows how to draw itself--so do layers and groups and shapes, but if they are 
  // part of the document, we just have to tell the document to draw.
  doc.draw();
}


/**
 * Processing and Illustrator use different coordinate systems. We can move from one to 
 * the other by applying a geometric transform to our graphics before outputting to Illustrator.
 * See the SaveAI() method for more information.
 * 2-D geometric transforms can be captured by a matrix with three rows and three columns.
 * The class com.ignotus.geom.Matrix3 handles transforms with such matrices.
 * In its initial state, a Matrix3 is the "identity matrix," to which we add various transforms.
 * The matrix transforms 2D geometry through the operation of matrix multiplication. The
 * nuts and bolts need not concern you: the essential thing to understand is that you can 
 * add a series of geometric transforms to the matrix and then execute them all at once.
 * The matrix is also referred to as the CTM or Current Transoformation Matrix.
 * This transform is also available directly from the document through the getAITransform() method.
 */
public void setupTransform() {
  // start with the identity matrix
  aiTransform = new Matrix3();
  // add a horizontal reflection around x = 0
  aiTransform.scaleCTM(1.0, -1.0);
  // and translate by "height" distance on the y-axis
  aiTransform.translateCTM(0, height);
}

/**
 * Creates a document tree with layers, groups, and shapes 
 * Note that the Document, Layer, and Group components need to be 
 * initialized with "this" (the PApplet that runs the show) as the first argument.
 */
public void createDocument() {
  float x, y, radius, h, w;
  int sides;
  color c;
  // initialize an integer array with values constrained to 0..255
  int[] channelValues = {34, 55, 89, 144, 233};
  float minX = width * 0.125;
  float maxX = width * 0.875;
  float minY = height * 0.125;
  float maxY = height * 0.875;
  // create a document
  doc = new DocumentComponent(this, "Layers and Groups");
  // by setting verbose to true, we get some feedback as we add components
  doc.setVerbose(true);
  // create and add a layer
  LayerComponent bg = new LayerComponent(this, "background");
  doc.add(bg);
  // add some geometry to the layer
  bg.add(bgRect());
  // create another layer and add it to the document
  LayerComponent polygons = new LayerComponent(this, "Polygons");
  doc.add(polygons);
  // create some geometry and add it to the polygons layer
  ArrayList bezzies = new ArrayList();
  for (int i = 0; i < 10; i++) {
    x = random(minX, maxX);
    y = random(minY, maxY);
    radius = random(2, 48);
    sides = int(random(3, 18));
    BezShape bez = BezShape.bezRegularPoly(this, x, y, radius, sides);
    c = Palette.randColor(channelValues);
    farben.add(c);
    bez.setFillColor(c);
    bez.setNoStroke();
    bezzies.add(bez);
    polygons.add(bez);
  }
  // create a group and add it to the polygons layer
  GroupComponent boxes = new GroupComponent(this);
  polygons.add(boxes);
  // step through the polygons we created and put a bounding box around each one
  // add the bounding boxes to the group
  for (BezShape b : bezzies) {
    float[] bounds = b.bounds(this);
    float left = bounds[0];
    float top = bounds[1];
    float right = bounds[2];
    float bottom = bounds[3];
    color s = b.fillColor();
    BezShape br = bezRect(left, top, right, bottom, color(0), s);
    br.setNoFill();
    br.setWeight(2);
    boxes.add(br);
  }
  // create a new layer and add it to the document 
  LayerComponent ellipses = new LayerComponent(this, "Ellipses");
  doc.add(ellipses);
  // add some geometry to the layer
  for (int i = 0; i < 10; i++) {
    x = random(minX, maxX);
    y = random(minY, maxY);
    w = random(16, 96);
    h = random(16, 96);
    sides = int(random(4, 7));
    BezShape bez = BezShape.bezEllipse(this, x, y, w, h, sides);
    c = Palette.randColor(channelValues);
    farben.add(c);
    bez.setFillColor(c);
    bez.setNoStroke();
    ellipses.add(bez);
  }
}


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


/**
 * 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) {
  // instatiate a BezShape with a reference to our PApplet
  //  and the x and y coordinates of its starting vertex.
  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, 220, 254);
  color s = color(21, 34, 55);
  return bezRect(0, height, width, 0, f, s);
}


/**
 * saves shapes to an Adobe Illustrator file
 */
public void saveAI(String aiFilename, DocumentComponent doc, ArrayList colors) {
  println("saving Adobe Illustrator file " + aiFilename + "...");
  PrintWriter output = createWriter(aiFilename);
  Palette pal = doc.getPalette();
  pal.addBlackWhiteGray();
  pal.addColors(colors);
  doc.setCreator("Ignotus");
  doc.setOrg("IgnoStudio");
  doc.setWidth(width);
  doc.setHeight(height);
  // the transform we created reflects everything around a horizontal line
  // it's a "symmetrical" transform: doing it a second time undoes it.
  // we do it once to flip graphics into Adobe Illustrator's coordinate system, 
  // and once more to restore Processing's coordinate system.
  // the new version of IgnoCodeLib (0.2) provides a single method, writeWithAITransform()
  // that creates and applies the Processing to Illustrator coordinate system transform.
  // "doc.writeWithAITransform(output)" could replace the next three lines, and you would 
  // not need to generate aiTransform.
  doc.transform(aiTransform);
  doc.write(output);
  doc.transform(aiTransform);
}

Constructor Summary
`LayerComponent(PApplet parent)`
`LayerComponent(PApplet parent, String name)`
`LayerComponent(PApplet parent, String name, int colorIndex)`

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 document
`void`	`add(DisplayComponent component)` Adds a component to children() of this component.
`void`	`draw()` Draws geometry or text to the Processing window.
`int`	`getColorIndex()` Returns the color index.
`String`	`getName()` Returns the namd of this layer.
`boolean`	`isTerminal()`
`void`	`setColorIndex(int colorIndex)` Sets the color index, used in Illustrator's Layers palette.
`void`	`setName(String name)` Sets the name of this layer.
`void`	`transform(Matrix3 matx)` Transforms geometry of shapes and location of text using the supplied matrix.
`void`	`write(PrintWriter pw)` Writes an Adobe Illustrator 7.0 file format encoding structure, geometry and text.

com.ignotus.aifile Class LayerComponent

LayerComponent

LayerComponent

LayerComponent

getName

setName

getColorIndex

setColorIndex

add

add

draw

isTerminal

write

transform

accept

accept

com.ignotus.aifile
Class LayerComponent