mirror of https://github.com/octoleo/plantuml.git
273 lines
9.9 KiB
Java
273 lines
9.9 KiB
Java
/* ========================================================================
|
|
* PlantUML : a free UML diagram generator
|
|
* ========================================================================
|
|
*
|
|
* (C) Copyright 2009-2020, Arnaud Roques
|
|
*
|
|
* Project Info: http://plantuml.com
|
|
*
|
|
* If you like this project or if you find it useful, you can support us at:
|
|
*
|
|
* http://plantuml.com/patreon (only 1$ per month!)
|
|
* http://plantuml.com/paypal
|
|
*
|
|
* This file is part of PlantUML.
|
|
*
|
|
* PlantUML is free software; you can redistribute it and/or modify it
|
|
* under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation, either version 3 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* PlantUML distributed in the hope that it will be useful, but
|
|
* WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
|
|
* or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
|
|
* License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public
|
|
* License along with this library; if not, write to the Free Software
|
|
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
|
|
* USA.
|
|
*
|
|
*
|
|
* Original Author: Arnaud Roques
|
|
*
|
|
*
|
|
*/
|
|
package net.sourceforge.plantuml.graphic;
|
|
|
|
import java.awt.geom.Dimension2D;
|
|
import java.awt.geom.Point2D;
|
|
import java.util.ArrayList;
|
|
import java.util.List;
|
|
import java.util.Random;
|
|
|
|
import net.sourceforge.plantuml.Dimension2DDouble;
|
|
import net.sourceforge.plantuml.style.SName;
|
|
import net.sourceforge.plantuml.ugraphic.UGraphic;
|
|
import net.sourceforge.plantuml.ugraphic.UGraphicStencil;
|
|
import net.sourceforge.plantuml.ugraphic.UPath;
|
|
import net.sourceforge.plantuml.ugraphic.UTranslate;
|
|
// https://stackoverflow.com/questions/39552127/algorithm-for-drawing-random-comic-style-clouds
|
|
// http://martin-oehm.de/data/cloud.html
|
|
// https://stackoverflow.com/questions/34623855/what-is-the-algorithm-behind-the-pdf-cloud-annotation
|
|
// https://stackoverflow.com/questions/3177121/how-do-i-paint-clouds
|
|
|
|
class USymbolCloud extends USymbol {
|
|
|
|
private final static boolean NEW = true;
|
|
private final static boolean DEBUG = false;
|
|
|
|
@Override
|
|
public SkinParameter getSkinParameter() {
|
|
return SkinParameter.CLOUD;
|
|
}
|
|
|
|
@Override
|
|
public SName getSName() {
|
|
return SName.cloud;
|
|
}
|
|
|
|
|
|
private void drawCloud(UGraphic ug, double width, double height, double shadowing) {
|
|
final UPath shape = getSpecificFrontierForCloud(width, height);
|
|
shape.setDeltaShadow(shadowing);
|
|
|
|
ug.apply(UTranslate.dy(0)).draw(shape);
|
|
}
|
|
|
|
private UPath getSpecificFrontierForCloudNew(double width, double height) {
|
|
final Random rnd = new Random((long) width + 7919L * (long) height);
|
|
final List<Point2D> points = new ArrayList<>();
|
|
|
|
double bubbleSize = 11;
|
|
if (Math.max(width, height) / bubbleSize > 16) {
|
|
bubbleSize = Math.max(width, height) / 16;
|
|
}
|
|
|
|
final double margin1 = 8;
|
|
|
|
final Point2D.Double pointA = new Point2D.Double(margin1, margin1);
|
|
final Point2D.Double pointB = new Point2D.Double(width - margin1, margin1);
|
|
final Point2D.Double pointC = new Point2D.Double(width - margin1, height - margin1);
|
|
final Point2D.Double pointD = new Point2D.Double(margin1, height - margin1);
|
|
|
|
if (width > 100 && height > 100) {
|
|
complex(rnd, points, bubbleSize, pointA, pointB, pointC, pointD);
|
|
} else {
|
|
simple(rnd, points, bubbleSize, pointA, pointB, pointC, pointD);
|
|
}
|
|
|
|
points.add(points.get(0));
|
|
|
|
final UPath result = new UPath();
|
|
result.moveTo(points.get(0));
|
|
for (int i = 0; i < points.size() - 1; i++) {
|
|
if (DEBUG) {
|
|
result.lineTo(points.get(i + 1));
|
|
} else {
|
|
addCurve(rnd, result, points.get(i), points.get(i + 1));
|
|
}
|
|
}
|
|
return result;
|
|
|
|
}
|
|
|
|
private void complex(final Random rnd, final List<Point2D> points, double bubbleSize, final Point2D.Double pointA,
|
|
final Point2D.Double pointB, final Point2D.Double pointC, final Point2D.Double pointD) {
|
|
final double margin2 = 7;
|
|
specialLine(bubbleSize, rnd, points, mvX(pointA, margin2), mvX(pointB, -margin2));
|
|
points.add(mvY(pointB, margin2));
|
|
specialLine(bubbleSize, rnd, points, mvY(pointB, margin2), mvY(pointC, -margin2));
|
|
points.add(mvX(pointC, -margin2));
|
|
specialLine(bubbleSize, rnd, points, mvX(pointC, -margin2), mvX(pointD, margin2));
|
|
points.add(mvY(pointD, -margin2));
|
|
specialLine(bubbleSize, rnd, points, mvY(pointD, -margin2), mvY(pointA, margin2));
|
|
points.add(mvX(pointA, margin2));
|
|
}
|
|
|
|
private void simple(final Random rnd, final List<Point2D> points, double bubbleSize, final Point2D.Double pointA,
|
|
final Point2D.Double pointB, final Point2D.Double pointC, final Point2D.Double pointD) {
|
|
specialLine(bubbleSize, rnd, points, pointA, pointB);
|
|
specialLine(bubbleSize, rnd, points, pointB, pointC);
|
|
specialLine(bubbleSize, rnd, points, pointC, pointD);
|
|
specialLine(bubbleSize, rnd, points, pointD, pointA);
|
|
}
|
|
|
|
private static Point2D mvX(Point2D pt, double dx) {
|
|
return new Point2D.Double(pt.getX() + dx, pt.getY());
|
|
}
|
|
|
|
private static Point2D mvY(Point2D pt, double dy) {
|
|
return new Point2D.Double(pt.getX(), pt.getY() + dy);
|
|
}
|
|
|
|
private void specialLine(double bubbleSize, Random rnd, List<Point2D> points, Point2D p1, Point2D p2) {
|
|
final CoordinateChange change = new CoordinateChange(p1, p2);
|
|
final double length = change.getLength();
|
|
final Point2D middle = change.getTrueCoordinate(length / 2, -rnd(rnd, 1, 1 + Math.min(12, bubbleSize * 0.8)));
|
|
// final Point2D middle = change.getTrueCoordinate(length / 2, -13);
|
|
if (DEBUG) {
|
|
points.add(middle);
|
|
points.add(p2);
|
|
} else {
|
|
bubbleLine(rnd, points, p1, middle, bubbleSize);
|
|
bubbleLine(rnd, points, middle, p2, bubbleSize);
|
|
}
|
|
}
|
|
|
|
private void bubbleLine(Random rnd, List<Point2D> points, Point2D p1, Point2D p2, double bubbleSize) {
|
|
final CoordinateChange change = new CoordinateChange(p1, p2);
|
|
final double length = change.getLength();
|
|
int nb = (int) (length / bubbleSize);
|
|
if (nb == 0) {
|
|
bubbleSize = length / 2;
|
|
nb = (int) (length / bubbleSize);
|
|
}
|
|
for (int i = 0; i < nb; i++) {
|
|
points.add(rnd(rnd, change.getTrueCoordinate(i * length / nb, 0), bubbleSize * .2));
|
|
}
|
|
}
|
|
|
|
private void addCurve(Random rnd, UPath path, Point2D p1, Point2D p2) {
|
|
final CoordinateChange change = new CoordinateChange(p1, p2);
|
|
final double length = change.getLength();
|
|
final double coef = rnd(rnd, .25, .35);
|
|
final Point2D middle = change.getTrueCoordinate(length * coef, -length * rnd(rnd, .4, .55));
|
|
final Point2D middle2 = change.getTrueCoordinate(length * (1 - coef), -length * rnd(rnd, .4, .55));
|
|
path.cubicTo(middle, middle2, p2);
|
|
|
|
}
|
|
|
|
static private double rnd(Random rnd, double a, double b) {
|
|
return rnd.nextDouble() * (b - a) + a;
|
|
}
|
|
|
|
static private Point2D rnd(Random rnd, Point2D pt, double v) {
|
|
final double x = pt.getX() + v * rnd.nextDouble();
|
|
final double y = pt.getY() + v * rnd.nextDouble();
|
|
return new Point2D.Double(x, y);
|
|
}
|
|
|
|
private UPath getSpecificFrontierForCloud(double width, double height) {
|
|
if (NEW) {
|
|
return getSpecificFrontierForCloudNew(width, height);
|
|
}
|
|
final UPath path = new UPath();
|
|
path.moveTo(0, 10);
|
|
double x = 0;
|
|
for (int i = 0; i < width - 9; i += 10) {
|
|
path.cubicTo(i, -3 + 10, 2 + i, -5 + 10, 5 + i, -5 + 10);
|
|
path.cubicTo(8 + i, -5 + 10, 10 + i, -3 + 10, 10 + i, 10);
|
|
x = i + 10;
|
|
}
|
|
double y = 0;
|
|
for (int j = 10; j < height - 9; j += 10) {
|
|
path.cubicTo(x + 3, j, x + 5, 2 + j, x + 5, 5 + j);
|
|
path.cubicTo(x + 5, 8 + j, x + 3, 10 + j, x, 10 + j);
|
|
y = j + 10;
|
|
}
|
|
for (int i = 0; i < width - 9; i += 10) {
|
|
path.cubicTo(x - i, y + 3, x - 3 - i, y + 5, x - 5 - i, y + 5);
|
|
path.cubicTo(x - 8 - i, y + 5, x - 10 - i, y + 3, x - 10 - i, y);
|
|
}
|
|
for (int j = 0; j < height - 9 - 10; j += 10) {
|
|
path.cubicTo(-3, y - j, -5, y - 2 - j, -5, y - 5 - j);
|
|
path.cubicTo(-5, y - 8 - j, -3, y - 10 - j, 0, y - 10 - j);
|
|
}
|
|
return path;
|
|
}
|
|
|
|
private Margin getMargin() {
|
|
if (NEW)
|
|
return new Margin(15, 15, 15, 15);
|
|
return new Margin(10, 10, 10, 10);
|
|
}
|
|
|
|
@Override
|
|
public TextBlock asSmall(TextBlock name, final TextBlock label, final TextBlock stereotype,
|
|
final SymbolContext symbolContext, final HorizontalAlignment stereoAlignment) {
|
|
return new AbstractTextBlock() {
|
|
|
|
public void drawU(UGraphic ug) {
|
|
final Dimension2D dim = calculateDimension(ug.getStringBounder());
|
|
ug = UGraphicStencil.create(ug, dim);
|
|
ug = symbolContext.apply(ug);
|
|
drawCloud(ug, dim.getWidth(), dim.getHeight(), symbolContext.getDeltaShadow());
|
|
final Margin margin = getMargin();
|
|
final TextBlock tb = TextBlockUtils.mergeTB(stereotype, label, HorizontalAlignment.CENTER);
|
|
tb.drawU(ug.apply(new UTranslate(margin.getX1(), margin.getY1())));
|
|
}
|
|
|
|
public Dimension2D calculateDimension(StringBounder stringBounder) {
|
|
final Dimension2D dimLabel = label.calculateDimension(stringBounder);
|
|
final Dimension2D dimStereo = stereotype.calculateDimension(stringBounder);
|
|
return getMargin().addDimension(Dimension2DDouble.mergeTB(dimStereo, dimLabel));
|
|
}
|
|
};
|
|
}
|
|
|
|
@Override
|
|
public TextBlock asBig(final TextBlock title, HorizontalAlignment labelAlignment, final TextBlock stereotype,
|
|
final double width, final double height, final SymbolContext symbolContext,
|
|
final HorizontalAlignment stereoAlignment) {
|
|
return new AbstractTextBlock() {
|
|
|
|
public void drawU(UGraphic ug) {
|
|
final Dimension2D dim = calculateDimension(ug.getStringBounder());
|
|
ug = symbolContext.apply(ug);
|
|
drawCloud(ug, dim.getWidth(), dim.getHeight(), symbolContext.getDeltaShadow());
|
|
final Dimension2D dimStereo = stereotype.calculateDimension(ug.getStringBounder());
|
|
final double posStereo = (width - dimStereo.getWidth()) / 2;
|
|
stereotype.drawU(ug.apply(new UTranslate(posStereo, 13)));
|
|
final Dimension2D dimTitle = title.calculateDimension(ug.getStringBounder());
|
|
final double posTitle = (width - dimTitle.getWidth()) / 2;
|
|
title.drawU(ug.apply(new UTranslate(posTitle, 13 + dimStereo.getHeight())));
|
|
}
|
|
|
|
public Dimension2D calculateDimension(StringBounder stringBounder) {
|
|
return new Dimension2DDouble(width, height);
|
|
}
|
|
};
|
|
}
|
|
|
|
} |