[SCM] FreeHEP GraphicsIO Test Library branch, upstream, updated. upstream/2.1.1-1-gc9932b1
Giovanni Mascellani
gmascellani-guest at alioth.debian.org
Mon Feb 1 21:38:51 UTC 2010
This is an automated email from the git hooks/post-receive script. It was
generated because a ref change was pushed to the repository containing
the project "FreeHEP GraphicsIO Test Library".
The branch, upstream has been updated
via c9932b108e17243272311745e44a29a90812e964 (commit)
from 636ba90122f56fc1e419f7b1e5be6163ca1c8442 (commit)
Those revisions listed above that are new to this repository have
not appeared on any other notification email; so we list those
revisions in full, below.
- Log -----------------------------------------------------------------
-----------------------------------------------------------------------
Summary of changes:
.../freehep/graphicsio/test/TestCustomStrokes.java | 231 --------------------
1 files changed, 0 insertions(+), 231 deletions(-)
diff --git a/src/main/java/org/freehep/graphicsio/test/TestCustomStrokes.java b/src/main/java/org/freehep/graphicsio/test/TestCustomStrokes.java
deleted file mode 100644
index c76ee14..0000000
--- a/src/main/java/org/freehep/graphicsio/test/TestCustomStrokes.java
+++ /dev/null
@@ -1,231 +0,0 @@
-// Copyright 2006, FreeHEP
-package org.freehep.graphicsio.test;
-
-/*
- * Copyright (c) 2000 David Flanagan. All rights reserved.
- * This code is from the book Java Examples in a Nutshell, 2nd Edition.
- * It is provided AS-IS, WITHOUT ANY WARRANTY either expressed or implied.
- * You may study, use, and modify it for any non-commercial purpose.
- * You may distribute it non-commercially as long as you retain this notice.
- * For a commercial use license, or to purchase the book (recommended),
- * visit http://www.davidflanagan.com/javaexamples2.
- */
-
-import java.awt.BasicStroke;
-import java.awt.Color;
-import java.awt.Font;
-import java.awt.Graphics;
-import java.awt.RenderingHints;
-import java.awt.Shape;
-import java.awt.Stroke;
-import java.awt.font.GlyphVector;
-import java.awt.geom.GeneralPath;
-import java.awt.geom.PathIterator;
-import java.util.Random;
-
-import org.freehep.graphics2d.VectorGraphics;
-
-/**
- * @author Mark Donszelmann
- * @version $Id: TestCustomStrokes.java 12626 2007-06-08 22:23:13Z duns $
- */
-public class TestCustomStrokes extends TestingPanel {
-
- private Random random;
-
- // These are the various stroke objects we'll demonstrate
- private Stroke[] strokes = new Stroke[] {
- new BasicStroke(4.0f), // The standard, predefined stroke
- new NullStroke(), // A Stroke that does nothing
- new DoubleStroke(8.0f, 2.0f), // A Stroke that strokes twice
- new ControlPointsStroke(2.0f), // Shows the vertices & control
- // points
- new SloppyStroke(2.0f, 3.0f) // Perturbs the shape before
- // stroking
- };
-
- public TestCustomStrokes(String[] args) throws Exception {
- super(args);
- setName("Custom Strokes");
- random = new Random(123456L);
- }
-
- public void paintComponent(Graphics g) {
-
- VectorGraphics vg = VectorGraphics.create(g);
-
- // Get a shape to work with. Here we'll use the letter B
- Font f = new Font("Serif", Font.BOLD, 150);
- GlyphVector gv = f.createGlyphVector(vg.getFontRenderContext(), "B");
- Shape shape = gv.getOutline();
-
- // Set drawing attributes and starting position
- vg.setColor(Color.black);
- vg.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
- RenderingHints.VALUE_ANTIALIAS_ON);
- vg.translate(10, 175);
-
- // Draw the shape once with each stroke
- for(int i = 0; i < strokes.length; i++) {
- vg.setStroke(strokes[i]); // set the stroke
- vg.draw(shape); // draw the shape
- vg.translate(100,0); // move to the right
- }
-
- vg.translate(-strokes.length*100, 0);
- vg.translate(10, 100);
-
- for (int i=0; i < strokes.length; i++) {
- vg.setStroke(strokes[i]);
- vg.drawRect(10, 10, 80, 50);
- vg.translate(100, 0);
- }
- }
-
- /**
- * This Stroke implementation does nothing. Its createStrokedShape() method
- * returns an unmodified shape. Thus, drawing a shape with this Stroke is
- * the same as filling that shape!
- */
- class NullStroke implements Stroke {
- public Shape createStrokedShape(Shape s) { return s; }
- }
-
- /**
- * This Stroke implementation applies a BasicStroke to a shape twice. If you
- * draw with this Stroke, then instead of outlining the shape, you're
- * outlining the outline of the shape.
- */
- class DoubleStroke implements Stroke {
- BasicStroke stroke1, stroke2; // the two strokes to use
- public DoubleStroke(float width1, float width2) {
- stroke1 = new BasicStroke(width1); // Constructor arguments specify
- stroke2 = new BasicStroke(width2); // the line widths for the strokes
- }
-
- public Shape createStrokedShape(Shape s) {
- // Use the first stroke to create an outline of the shape
- Shape outline = stroke1.createStrokedShape(s);
- // Use the second stroke to create an outline of that outline.
- // It is this outline of the outline that will be filled in
- return stroke2.createStrokedShape(outline);
- }
- }
-
- /**
- * This Stroke implementation strokes the shape using a thin line, and also
- * displays the end points and Bezier curve control points of all the line
- * and curve segments that make up the shape. The radius argument to the
- * constructor specifies the size of the control point markers. Note the use
- * of PathIterator to break the shape down into its segments, and of
- * GeneralPath to build up the stroked shape.
- */
- class ControlPointsStroke implements Stroke {
- float radius; // how big the control point markers should be
- public ControlPointsStroke(float radius) { this.radius = radius; }
-
- public Shape createStrokedShape(Shape shape) {
- // Start off by stroking the shape with a thin line. Store the
- // resulting shape in a GeneralPath object so we can add to it.
- GeneralPath strokedShape =
- new GeneralPath(new BasicStroke(1.0f).createStrokedShape(shape));
-
- // Use a PathIterator object to iterate through each of the line and
- // curve segments of the shape. For each one, mark the endpoint and
- // control points (if any) by adding a rectangle to the GeneralPath
- float[] coords = new float[6];
- for(PathIterator i=shape.getPathIterator(null); !i.isDone();i.next()) {
- int type = i.currentSegment(coords);
-
- switch(type) {
- case PathIterator.SEG_CUBICTO:
- markPoint(strokedShape, coords[4], coords[5]); // falls through
- case PathIterator.SEG_QUADTO:
- markPoint(strokedShape, coords[2], coords[3]); // falls through
- case PathIterator.SEG_MOVETO:
- case PathIterator.SEG_LINETO:
- markPoint(strokedShape, coords[0], coords[1]); // falls through
- case PathIterator.SEG_CLOSE:
- break;
- }
- }
-
- return strokedShape;
- }
-
- /** Add a small square centered at (x,y) to the specified path */
- void markPoint(GeneralPath path, float x, float y) {
- path.moveTo(x-radius, y-radius); // Begin a new sub-path
- path.lineTo(x+radius, y-radius); // Add a line segment to it
- path.lineTo(x+radius, y+radius); // Add a second line segment
- path.lineTo(x-radius, y+radius); // And a third
- path.closePath(); // Go back to last moveTo position
- }
- }
-
- /**
- * This Stroke implementation randomly perturbs the line and curve segments
- * that make up a Shape, and then strokes that perturbed shape. It uses
- * PathIterator to loop through the Shape and GeneralPath to build up the
- * modified shape. Finally, it uses a BasicStroke to stroke the modified
- * shape. The result is a "sloppy" looking shape.
- */
- class SloppyStroke implements Stroke {
- BasicStroke stroke;
- float sloppiness;
-
- public SloppyStroke(float width, float sloppiness) {
- this.stroke = new BasicStroke(width); // Used to stroke modified shape
- this.sloppiness = sloppiness; // How sloppy should we be?
- }
-
- public Shape createStrokedShape(Shape shape) {
- GeneralPath newshape = new GeneralPath(); // Start with an empty shape
-
- // Iterate through the specified shape, perturb its coordinates, and
- // use them to build up the new shape.
- float[] coords = new float[6];
- for(PathIterator i=shape.getPathIterator(null); !i.isDone();i.next()) {
- int type = i.currentSegment(coords);
-
- switch(type) {
- case PathIterator.SEG_MOVETO:
- perturb(coords, 2);
- newshape.moveTo(coords[0], coords[1]);
- break;
- case PathIterator.SEG_LINETO:
- perturb(coords, 2);
- newshape.lineTo(coords[0], coords[1]);
- break;
- case PathIterator.SEG_QUADTO:
- perturb(coords, 4);
- newshape.quadTo(coords[0], coords[1], coords[2], coords[3]);
- break;
- case PathIterator.SEG_CUBICTO:
- perturb(coords, 6);
- newshape.curveTo(coords[0], coords[1], coords[2], coords[3],
- coords[4], coords[5]);
- break;
- case PathIterator.SEG_CLOSE:
- newshape.closePath();
- break;
- }
- }
-
- // Finally, stroke the perturbed shape and return the result
- return stroke.createStrokedShape(newshape);
- }
-
- // Randomly modify the specified number of coordinates, by an amount
- // specified by the sloppiness field.
- void perturb(float[] coords, int numCoords) {
- for(int i = 0; i < numCoords; i++) {
- coords[i] += (float)((random.nextDouble()*2-1.0)*sloppiness);
- }
- }
- }
-
- public static void main(String[] args) throws Exception {
- new TestCustomStrokes(args).runTest();
- }
-}
hooks/post-receive
--
FreeHEP GraphicsIO Test Library
More information about the pkg-java-commits
mailing list