Java аплет

import java.awt.*;
import java.awt.geom.FlatteningPathIterator;
import java.awt.geom.GeneralPath;
import java.awt.geom.PathIterator;
 
 
public class SloppyStroke implements Stroke {
    private float amplitude;
    private float wavelength;
    private BasicStroke stroke = new BasicStroke(1);
 
    public SloppyStroke(float amplitude, float wavelength) {
        this.amplitude = amplitude;
        this.wavelength = wavelength;
    }
 
    public Shape createStrokedShape(Shape shape) {
        GeneralPath result = new GeneralPath();
        PathIterator it = new FlatteningPathIterator(shape.getPathIterator(null), 1);
        float points[] = new float[2];
        float moveX = 0, moveY = 0, lastX = 0, lastY = 0, thisX, thisY, next = 0;
        int type, 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;
                break;
            case PathIterator.SEG_CLOSE:
                points[0] = moveX;
                points[1] = moveY;
            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;
                        result.lineTo(x, y);
                        if ((phase % 2) == 1)
                            result.lineTo(x, y);
                        else
                            result.lineTo(x - amplitude * 2 * dy * r, y + amplitude * 2 * dx * r);
                        next += wavelength;
                        phase++;
                    }
                }
                next -= distance;
                lastX = thisX;
                lastY = thisY;
                if (type == PathIterator.SEG_CLOSE)
                    result.closePath();
                break;
            }
            it.next();
        }
        return stroke.createStrokedShape(result);
    }
    
}