feat: единая камера surface/pie3D — d = sqrt(0.25+0.25·ds²)/tan(θ/2) из c:view3D/perspective вместо CAMERA_DISTANCE=2.36; pie3D переписан на проекцию (обод/стенки/торцы по depth), PIE_DEPTH/PIE_FIT с провенансом Word-эмпирики; плоские PIE/DOUGHNUT исполняют firstSliceAng/holeSize
This commit is contained in:
@@ -12,27 +12,37 @@ import java.util.Comparator;
|
|||||||
import java.util.List;
|
import java.util.List;
|
||||||
|
|
||||||
/**
|
/**
|
||||||
* Секторная диаграмма: 2D (pie/doughnut) и 3D (pie3D) одним кодом —
|
* Секторная диаграмма: плоские PIE/DOUGHNUT — круг, PIE3D — экструдированный
|
||||||
* у 2D-варианта глубина экструзии равна нулю.
|
* диск в общей камере {@link Surface3dPainter#project} (одна формула камеры
|
||||||
|
* для surface и pie: c:view3D/perspective — угол обзора, см.
|
||||||
|
* {@link Surface3dPainter#cameraDistance}).
|
||||||
*
|
*
|
||||||
* 3D в Word — это круг, наклонённый на c:view3D/rotX вокруг горизонтальной
|
* 3D-диск лежит в модельной плоскости (u, v) (единица — диаметр диска),
|
||||||
* оси, с экструзией вниз. Рисуется художником алгоритма: сектора от задних
|
* наклонён на c:view3D/rotX и повёрнут на c:view3D/rotY, экструзия — вниз
|
||||||
* к передним, у каждого сначала боковая стенка и торцы, затем верхняя
|
* по w на {@link #PIE_DEPTH}·c:view3D/depth. Рисуется художником алгоритма:
|
||||||
* грань.
|
* сектора от задних к передним (по спроецированной глубине середины), у
|
||||||
|
* каждого стенки и торцы, затем верхняя грань. Углы Word — от 12 часов по
|
||||||
|
* часовой: обод (u, v) = (sin A, cos A)/2.
|
||||||
*/
|
*/
|
||||||
final class PiePainter {
|
final class PiePainter {
|
||||||
|
|
||||||
/** Доля радиуса, уходящая в глубину при depthPercent=100. */
|
/**
|
||||||
private static final double DEPTH_RATIO = 0.22;
|
* Маппинг Word c:depthPercent -> высота экструзии в радиусах диска
|
||||||
|
* (100 -> 0,22·R). Word-эмпирика: спека высоту экструзии pie не
|
||||||
|
* описывает; замер по word-export.pdf
|
||||||
|
* (PiePainterTest.pie3dSilhouetteMatchesWordReference).
|
||||||
|
*/
|
||||||
|
private static final double PIE_DEPTH = 0.22;
|
||||||
|
|
||||||
/**
|
/**
|
||||||
* Word рисует pie3D чуть более «пологим» и с запасом вокруг торта:
|
* Auto-layout Word: доля области построения под силуэт торта.
|
||||||
* замер по word-export.pdf (300 dpi, область 219,2×149,1 pt) — силуэт 540×316 px,
|
* Word-эмпирика: спека auto-layout не описывает; замер по
|
||||||
* ry/rx = 0,475 при rotX=30° (sin 30° = 0,5) и радиус 270 px из
|
* word-export.pdf (PiePainterTest.pie3dSilhouetteMatchesWordReference).
|
||||||
* вписанного 288 px. Без этих поправок торт на 8% выше эталона.
|
|
||||||
*/
|
*/
|
||||||
private static final double TILT_CORRECTION = 0.95;
|
private static final double PIE_FIT = 0.865;
|
||||||
private static final double FIT_MARGIN = 0.865;
|
|
||||||
|
/** Точек обода на полный круг при замере силуэта. */
|
||||||
|
private static final int RIM_SAMPLES = 128;
|
||||||
|
|
||||||
private PiePainter() {
|
private PiePainter() {
|
||||||
}
|
}
|
||||||
@@ -60,22 +70,12 @@ final class PiePainter {
|
|||||||
return;
|
return;
|
||||||
}
|
}
|
||||||
|
|
||||||
boolean threeD = spec.type == ChartSpec.Type.PIE3D;
|
double holeRatio = spec.type == ChartSpec.Type.DOUGHNUT ? spec.holeSize / 100.0 : 0.0;
|
||||||
double tilt = threeD ? Math.sin(Math.toRadians(clampRotX(spec.rotX))) * TILT_CORRECTION : 1.0;
|
|
||||||
double depthPct = threeD ? spec.depthPercent / 100.0 : 0.0;
|
|
||||||
double depthRatio = DEPTH_RATIO * depthPct;
|
|
||||||
|
|
||||||
// Подбираем радиус так, чтобы эллипс вместе с экструзией влез в box
|
|
||||||
double rx = Math.min(box.getWidth() / 2.0,
|
|
||||||
box.getHeight() / (2.0 * tilt + 2.0 * depthRatio));
|
|
||||||
rx = Math.max(4, rx * FIT_MARGIN);
|
|
||||||
double ry = rx * tilt;
|
|
||||||
double depth = rx * depthRatio;
|
|
||||||
double cx = box.getCenterX();
|
|
||||||
double cy = box.getY() + ry + (box.getHeight() - (2 * ry + depth)) / 2.0;
|
|
||||||
|
|
||||||
List<Slice> slices = new ArrayList<>();
|
List<Slice> slices = new ArrayList<>();
|
||||||
double angle = 0;
|
// c:firstSliceAng — стартовый угол первого сектора (ECMA-376, default 0;
|
||||||
|
// для PIE3D в JAXB-модели docx4j 17.3.2 геттера нет, остаётся 0)
|
||||||
|
double angle = spec.firstSliceAng;
|
||||||
for (int i = 0; i < s.values.size(); i++) {
|
for (int i = 0; i < s.values.size(); i++) {
|
||||||
Double v = s.values.get(i);
|
Double v = s.values.get(i);
|
||||||
if (v == null || v <= 0) {
|
if (v == null || v <= 0) {
|
||||||
@@ -90,16 +90,65 @@ final class PiePainter {
|
|||||||
angle += sweep;
|
angle += sweep;
|
||||||
}
|
}
|
||||||
|
|
||||||
// Задние сектора раньше, передние позже: дальняя сторона торта —
|
if (spec.type == ChartSpec.Type.PIE3D) {
|
||||||
// это 12 часов (midDeg≈0/360, cos≈1), поэтому сортировка по cos
|
paint3d(g, spec, slices, box);
|
||||||
// должна быть убывающей, иначе дальние сектора рисуются поверх
|
return;
|
||||||
// передних и перекрывают их торцы.
|
}
|
||||||
|
// Плоские PIE/DOUGHNUT: круг, вписанный в область построения.
|
||||||
|
double rx = Math.max(4, Math.min(box.getWidth() / 2.0, box.getHeight() / 2.0) * PIE_FIT);
|
||||||
|
double cx = box.getCenterX();
|
||||||
|
double cy = box.getY() + box.getHeight() / 2.0;
|
||||||
|
for (Slice sl : slices) {
|
||||||
|
drawSlice(g, sl, cx, cy, rx, rx, holeRatio);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* 3D-пирог: радиус подбирается по замеренному силуэту — обод сверху
|
||||||
|
* (w = ext) и снизу (w = 0); перспектива окружности эллипсом не является,
|
||||||
|
* поэтому вписка по эллипсу неверна. Масштаб =
|
||||||
|
* {@link #PIE_FIT}·min(доступная ширина/силуэт, высота/силуэт).
|
||||||
|
*/
|
||||||
|
private static void paint3d(Graphics2D g, ChartSpec spec, List<Slice> slices, Rectangle2D box) {
|
||||||
|
double rotX = Math.toRadians(clampRotX(spec.rotX));
|
||||||
|
// c:view3D/rotY — поворот пирога вокруг вертикали (default 0)
|
||||||
|
double rotY = -Math.toRadians(spec.rotY);
|
||||||
|
double ext = PIE_DEPTH * spec.depthPercent / 100.0 / 2.0;
|
||||||
|
double persp = spec.perspective;
|
||||||
|
double dcam = Surface3dPainter.cameraDistance(1, persp);
|
||||||
|
|
||||||
|
double minX = Double.MAX_VALUE;
|
||||||
|
double maxX = -Double.MAX_VALUE;
|
||||||
|
double minY = Double.MAX_VALUE;
|
||||||
|
double maxY = -Double.MAX_VALUE;
|
||||||
|
for (int i = 0; i < RIM_SAMPLES; i++) {
|
||||||
|
double a = 360.0 * i / RIM_SAMPLES;
|
||||||
|
for (double w : new double[]{ext, 0}) {
|
||||||
|
Surface3dPainter.Node n = rim(a, w, rotX, rotY, persp);
|
||||||
|
minX = Math.min(minX, n.x());
|
||||||
|
maxX = Math.max(maxX, n.x());
|
||||||
|
minY = Math.min(minY, n.y());
|
||||||
|
maxY = Math.max(maxY, n.y());
|
||||||
|
}
|
||||||
|
}
|
||||||
|
double silW = Math.max(1e-6, maxX - minX);
|
||||||
|
double silH = Math.max(1e-6, maxY - minY);
|
||||||
|
double scale = PIE_FIT * Math.min(box.getWidth() / silW, box.getHeight() / silH);
|
||||||
|
double midX = (minX + maxX) / 2.0;
|
||||||
|
double midY = (minY + maxY) / 2.0;
|
||||||
|
double cx = box.getCenterX();
|
||||||
|
double cy = box.getCenterY();
|
||||||
|
Cam cam = new Cam(rotX, rotY, ext, persp, dcam, scale, midX, midY, cx, cy,
|
||||||
|
cx + (minX - midX) * scale, cx + (maxX - midX) * scale);
|
||||||
|
|
||||||
|
// Задние сектора раньше, передние позже — по спроецированной глубине
|
||||||
|
// середины сектора (замена прежней сортировки по -cos(midDeg)):
|
||||||
|
// дальняя сторона торта — 12 часов.
|
||||||
slices.sort(Comparator.comparingDouble(
|
slices.sort(Comparator.comparingDouble(
|
||||||
(Slice sl) -> -Math.cos(Math.toRadians(sl.midDeg()))));
|
(Slice sl) -> -rim(sl.midDeg(), ext, rotX, rotY, persp).depth()));
|
||||||
|
|
||||||
for (Slice sl : slices) {
|
for (Slice sl : slices) {
|
||||||
drawSlice(g, sl, cx, cy, rx, ry, depth,
|
draw3dSlice(g, sl, cam);
|
||||||
spec.type == ChartSpec.Type.DOUGHNUT ? 0.5 : 0.0);
|
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
@@ -108,17 +157,15 @@ final class PiePainter {
|
|||||||
}
|
}
|
||||||
|
|
||||||
/**
|
/**
|
||||||
* Один сектор. Углы Word: от 12 часов по часовой. Перевод в параметрический
|
* Один плоский сектор. Углы Word: от 12 часов по часовой. Перевод в
|
||||||
* угол Java: theta = 90 - wordAngle (y на экране растёт вниз).
|
* параметрический угол Java: theta = 90 - wordAngle (y на экране растёт
|
||||||
|
* вниз).
|
||||||
*/
|
*/
|
||||||
private static void drawSlice(Graphics2D g, Slice sl, double cx, double cy,
|
private static void drawSlice(Graphics2D g, Slice sl, double cx, double cy,
|
||||||
double rx, double ry, double depth, double holeRatio) {
|
double rx, double ry, double holeRatio) {
|
||||||
double thetaStart = 90.0 - sl.startDeg();
|
double thetaStart = 90.0 - sl.startDeg();
|
||||||
double thetaSweep = -sl.sweepDeg();
|
double thetaSweep = -sl.sweepDeg();
|
||||||
|
|
||||||
if (depth > 0.01) {
|
|
||||||
drawWalls(g, sl, cx, cy, rx, ry, depth);
|
|
||||||
}
|
|
||||||
Arc2D.Double top = new Arc2D.Double(cx - rx, cy - ry, 2 * rx, 2 * ry,
|
Arc2D.Double top = new Arc2D.Double(cx - rx, cy - ry, 2 * rx, 2 * ry,
|
||||||
thetaStart, thetaSweep, Arc2D.PIE);
|
thetaStart, thetaSweep, Arc2D.PIE);
|
||||||
g.setColor(sl.color());
|
g.setColor(sl.color());
|
||||||
@@ -139,73 +186,117 @@ final class PiePainter {
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
/** Боковая стенка дуги + торцы радиальных граней (видимая нижняя половина). */
|
/**
|
||||||
private static void drawWalls(Graphics2D g, Slice sl, double cx, double cy,
|
* Один 3D-сектор: стенки видимой части дуги (наружная нормаль обода
|
||||||
double rx, double ry, double depth) {
|
* смотрит на камеру), торцы радиальных граней (нижняя экранная четверть —
|
||||||
double thetaStart = 90.0 - sl.startDeg();
|
* Word-эмпирика), затем верхняя грань по замеренному ободу.
|
||||||
double thetaEnd = thetaStart - sl.sweepDeg();
|
*/
|
||||||
// Боковая стенка цилиндра в Word освещена сбоку: слева ~0,75 от цвета
|
private static void draw3dSlice(Graphics2D g, Slice sl, Cam cam) {
|
||||||
// сектора, справа ~0,40 (замер по word-export.pdf, 300 dpi: ×0,71 у x=250,
|
double a0 = sl.startDeg();
|
||||||
// ×0,58 у x=440, ×0,40 у x=640). Плоская заливка делает пирог
|
double a1 = a0 + sl.sweepDeg();
|
||||||
// «бумажным», поэтому стенку красят горизонтальным градиентом.
|
|
||||||
Color left = DrawMlColor.darken(sl.color(), 0.25);
|
|
||||||
Color right = DrawMlColor.darken(sl.color(), 0.60);
|
|
||||||
|
|
||||||
// Видимая часть дуги: sin(theta) < 0 (нижняя половина эллипса)
|
// шаг 1°: при 4° хорда между точками дуги отстаёт от дуги на десятки
|
||||||
List<double[]> visible = visibleArc(thetaStart, thetaEnd);
|
// пикселей и вдоль границы сектора остаётся белый клин между стенкой
|
||||||
for (double[] seg : visible) {
|
// соседнего сектора и торцом
|
||||||
Path2D wall = new Path2D.Double();
|
List<Double> angles = new ArrayList<>();
|
||||||
boolean first = true;
|
for (double a = a0; a < a1 - 1e-9; a += 1.0) {
|
||||||
// шаг 1°: при 4° хорда между точками дуги отстаёт от дуги на
|
angles.add(a);
|
||||||
// десятки пикселей (эллипс пологий) и вдоль границы сектора
|
}
|
||||||
// остаётся белый клин между стенкой соседнего сектора и торцом
|
angles.add(a1);
|
||||||
for (double t = seg[0]; t <= seg[1] + 1e-9; t += 1.0) {
|
|
||||||
Point2D p = point(cx, cy, rx, ry, t);
|
draw3dWalls(g, sl, cam, angles);
|
||||||
if (first) {
|
Point2D topCenter = cam.screen(cam.center(cam.ext()));
|
||||||
wall.moveTo(p.getX(), p.getY());
|
draw3dEndFaces(g, sl, cam, a0, a1, topCenter);
|
||||||
first = false;
|
|
||||||
} else {
|
// Верхняя грань по замеренному ободу.
|
||||||
wall.lineTo(p.getX(), p.getY());
|
Path2D top = new Path2D.Double();
|
||||||
}
|
top.moveTo(topCenter.getX(), topCenter.getY());
|
||||||
}
|
for (double a : angles) {
|
||||||
Point2D end = point(cx, cy, rx, ry, seg[1]);
|
Point2D p = cam.rimPoint(a, cam.ext());
|
||||||
wall.lineTo(end.getX(), end.getY() + depth);
|
top.lineTo(p.getX(), p.getY());
|
||||||
for (double t = seg[1]; t >= seg[0] - 1e-9; t -= 1.0) {
|
}
|
||||||
Point2D p = point(cx, cy, rx, ry, t);
|
top.closePath();
|
||||||
wall.lineTo(p.getX(), p.getY() + depth);
|
g.setColor(sl.color());
|
||||||
}
|
g.fill(top);
|
||||||
wall.closePath();
|
if (sl.outline() != null) {
|
||||||
g.setPaint(new java.awt.GradientPaint(
|
g.setColor(sl.outline());
|
||||||
new Point2D.Double(cx - rx, 0), left,
|
g.setStroke(new BasicStroke((float) sl.outlineWidth()));
|
||||||
new Point2D.Double(cx + rx, 0), right));
|
g.draw(top);
|
||||||
g.fill(wall);
|
}
|
||||||
if (sl.outline() != null) {
|
}
|
||||||
g.setColor(sl.outline());
|
|
||||||
g.setStroke(new BasicStroke((float) sl.outlineWidth()));
|
/**
|
||||||
g.draw(wall);
|
* Стенки цилиндра: Word освещает их сбоку — слева ~0,75 от цвета сектора,
|
||||||
|
* справа ~0,40 (замер по word-export.pdf, 300 dpi: ×0,71 у x=250, ×0,58
|
||||||
|
* у x=440, ×0,40 у x=640). Плоская заливка делает пирог «бумажным»,
|
||||||
|
* поэтому стенка красится горизонтальным градиентом по ширине силуэта.
|
||||||
|
* Видимая часть дуги: наружная нормаль обода смотрит на камеру.
|
||||||
|
*/
|
||||||
|
private static void draw3dWalls(Graphics2D g, Slice sl, Cam cam, List<Double> angles) {
|
||||||
|
g.setPaint(new java.awt.GradientPaint(
|
||||||
|
new Point2D.Double(cam.leftX(), 0), DrawMlColor.darken(sl.color(), 0.25),
|
||||||
|
new Point2D.Double(cam.rightX(), 0), DrawMlColor.darken(sl.color(), 0.60)));
|
||||||
|
int runStart = -1;
|
||||||
|
for (int i = 0; i <= angles.size(); i++) {
|
||||||
|
boolean vis = i < angles.size() && cam.wallVisible(angles.get(i));
|
||||||
|
if (vis && runStart < 0) {
|
||||||
|
runStart = i;
|
||||||
|
} else if (!vis && runStart >= 0) {
|
||||||
|
fillWall(g, sl, cam, angles, runStart, i - 1);
|
||||||
|
runStart = -1;
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
}
|
||||||
|
|
||||||
// Торцы: радиальные грани на границах сектора. Видна только та грань,
|
private static void fillWall(Graphics2D g, Slice sl, Cam cam,
|
||||||
// чья внешняя нормаль смотрит «вверх» по экрану (камера наклонена на
|
List<Double> angles, int from, int to) {
|
||||||
// rotX: грань видна, если её нормаль в плоскости круга имеет
|
Path2D wall = new Path2D.Double();
|
||||||
// составляющую к наблюдателю). Для начальной границы сектора внешняя
|
Point2D p = cam.rimPoint(angles.get(from), cam.ext());
|
||||||
// нормаль — это dP/dt, для конечной — обратная, отсюда разные признаки
|
wall.moveTo(p.getX(), p.getY());
|
||||||
// cos(t). Прежний признак sin(t)<0 рисовал обе грани общей границы
|
for (int i = from + 1; i <= to; i++) {
|
||||||
// соседних секторов, и торец дальнего сектора выползал наружу.
|
p = cam.rimPoint(angles.get(i), cam.ext());
|
||||||
|
wall.lineTo(p.getX(), p.getY());
|
||||||
|
}
|
||||||
|
for (int i = to; i >= from; i--) {
|
||||||
|
p = cam.rimPoint(angles.get(i), 0);
|
||||||
|
wall.lineTo(p.getX(), p.getY());
|
||||||
|
}
|
||||||
|
wall.closePath();
|
||||||
|
g.fill(wall);
|
||||||
|
if (sl.outline() != null) {
|
||||||
|
g.setColor(sl.outline());
|
||||||
|
g.setStroke(new BasicStroke((float) sl.outlineWidth()));
|
||||||
|
g.draw(wall);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Торцы: радиальные грани на границах сектора. Word рисует торец, только
|
||||||
|
* если грань выходит в нижнюю четверть экрана относительно центра
|
||||||
|
* верхней грани: торец конца сектора — в нижне-левой, торец начала — в
|
||||||
|
* нижне-правой (Word-эмпирика по word-export.pdf: признак по истинной
|
||||||
|
* нормали камеры рисует на общей границе секторов торец дальнего сектора,
|
||||||
|
* а в Word виден торец переднего). Регрессия —
|
||||||
|
* PiePainterTest#pie3dSharedEdgeShowsOnlyCameraFacingEnd.
|
||||||
|
*/
|
||||||
|
private static void draw3dEndFaces(Graphics2D g, Slice sl, Cam cam,
|
||||||
|
double a0, double a1, Point2D topCenter) {
|
||||||
for (int e = 0; e < 2; e++) {
|
for (int e = 0; e < 2; e++) {
|
||||||
double t = e == 0 ? thetaStart : thetaEnd;
|
double a = e == 0 ? a0 : a1;
|
||||||
double outwardUp = e == 0 ? -Math.cos(Math.toRadians(t))
|
Point2D edge = cam.rimPoint(a, cam.ext());
|
||||||
: Math.cos(Math.toRadians(t));
|
boolean drawn = e == 0
|
||||||
if (outwardUp >= 0 || Math.sin(Math.toRadians(t)) >= 0) {
|
? edge.getX() > topCenter.getX() && edge.getY() > topCenter.getY()
|
||||||
|
: edge.getX() < topCenter.getX() && edge.getY() > topCenter.getY();
|
||||||
|
if (!drawn) {
|
||||||
continue;
|
continue;
|
||||||
}
|
}
|
||||||
Point2D p = point(cx, cy, rx, ry, t);
|
Point2D edgeBottom = cam.rimPoint(a, 0);
|
||||||
|
Point2D bottom = cam.screen(cam.center(0));
|
||||||
Path2D face = new Path2D.Double();
|
Path2D face = new Path2D.Double();
|
||||||
face.moveTo(cx, cy);
|
face.moveTo(topCenter.getX(), topCenter.getY());
|
||||||
face.lineTo(p.getX(), p.getY());
|
face.lineTo(edge.getX(), edge.getY());
|
||||||
face.lineTo(p.getX(), p.getY() + depth);
|
face.lineTo(edgeBottom.getX(), edgeBottom.getY());
|
||||||
face.lineTo(cx, cy + depth);
|
face.lineTo(bottom.getX(), bottom.getY());
|
||||||
face.closePath();
|
face.closePath();
|
||||||
g.setColor(DrawMlColor.darken(sl.color(), 0.30));
|
g.setColor(DrawMlColor.darken(sl.color(), 0.30));
|
||||||
g.fill(face);
|
g.fill(face);
|
||||||
@@ -217,32 +308,47 @@ final class PiePainter {
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
/**
|
/** Обод диска: Word-угол aDeg от 12 часов по часовой -> (u, v) = (sin, cos)/2. */
|
||||||
* Пересечение дуги [a,b] (может идти по убыванию) с нижней полуокружностью
|
private static Surface3dPainter.Node rim(double aDeg, double w,
|
||||||
* sin(theta) < 0. Возвращает сегменты в порядке возрастания угла.
|
double rotX, double rotY, double persp) {
|
||||||
*/
|
double t = Math.toRadians(aDeg);
|
||||||
private static List<double[]> visibleArc(double a, double b) {
|
return Surface3dPainter.project(Math.sin(t) / 2.0, Math.cos(t) / 2.0,
|
||||||
double lo = Math.min(a, b);
|
w, rotX, rotY, 1, persp);
|
||||||
double hi = Math.max(a, b);
|
|
||||||
List<double[]> out = new ArrayList<>();
|
|
||||||
// нормализуем в [0,360) и идём по виткам
|
|
||||||
double span = hi - lo;
|
|
||||||
if (span >= 360) {
|
|
||||||
out.add(new double[]{lo, lo + 360});
|
|
||||||
return out;
|
|
||||||
}
|
|
||||||
for (double base = Math.floor(lo / 360.0) * 360.0; base < hi + 360; base += 360.0) {
|
|
||||||
double segLo = Math.max(lo, base + 180.0);
|
|
||||||
double segHi = Math.min(hi, base + 360.0);
|
|
||||||
if (segHi > segLo + 1e-9) {
|
|
||||||
out.add(new double[]{segLo, segHi});
|
|
||||||
}
|
|
||||||
}
|
|
||||||
return out;
|
|
||||||
}
|
}
|
||||||
|
|
||||||
private static Point2D point(double cx, double cy, double rx, double ry, double thetaDeg) {
|
/** Камера 3D-пирога + вписка силуэта в область построения. */
|
||||||
double t = Math.toRadians(thetaDeg);
|
private record Cam(double rotX, double rotY, double ext, double persp, double dcam,
|
||||||
return new Point2D.Double(cx + rx * Math.cos(t), cy - ry * Math.sin(t));
|
double scale, double midX, double midY, double cx, double cy,
|
||||||
|
double leftX, double rightX) {
|
||||||
|
|
||||||
|
Surface3dPainter.Node center(double w) {
|
||||||
|
return Surface3dPainter.project(0, 0, w, rotX, rotY, 1, persp);
|
||||||
|
}
|
||||||
|
|
||||||
|
Point2D rimPoint(double aDeg, double w) {
|
||||||
|
Surface3dPainter.Node n = rim(aDeg, w, rotX, rotY, persp);
|
||||||
|
return screen(n);
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Стенка видна: наружная нормаль обода (2u, 2v, 0) смотрит на камеру.
|
||||||
|
* Камера в модели: (-d·cos(rotX)·sin(rotY), -d·cos(rotX)·cos(rotY),
|
||||||
|
* d·sin(rotX)); скалярное произведение нормали на (камера - точка)
|
||||||
|
* равно -2·d·cos(rotX)·y1 - 0.5, где y1 = u·sin(rotY) + v·cos(rotY)
|
||||||
|
* — повёрнутая v-координата обода. Ортография (d = ∞) => y1 < 0,
|
||||||
|
* rotX = 90 => не видно ни одной стенки.
|
||||||
|
*/
|
||||||
|
boolean wallVisible(double aDeg) {
|
||||||
|
double t = Math.toRadians(aDeg);
|
||||||
|
double y1 = (Math.sin(t) * Math.sin(rotY)
|
||||||
|
+ Math.cos(t) * Math.cos(rotY)) / 2.0;
|
||||||
|
double limit = Double.isInfinite(dcam) ? 0.0 : -0.25 / (dcam * Math.cos(rotX));
|
||||||
|
return y1 < limit;
|
||||||
|
}
|
||||||
|
|
||||||
|
Point2D screen(Surface3dPainter.Node n) {
|
||||||
|
return new Point2D.Double(cx + (n.x() - midX) * scale,
|
||||||
|
cy + (n.y() - midY) * scale);
|
||||||
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|||||||
@@ -25,14 +25,6 @@ import java.util.List;
|
|||||||
*/
|
*/
|
||||||
final class Surface3dPainter {
|
final class Surface3dPainter {
|
||||||
|
|
||||||
/**
|
|
||||||
* Расстояние камеры сцены (в долях ширины коробки построения).
|
|
||||||
* `c:view3D/perspective` (по умолчанию 30) — это НЕ угол обзора, а
|
|
||||||
* коэффициент глубины: он масштабирует расстояние относительно
|
|
||||||
* эталонных 30. Значение откалибровано по эталону Word
|
|
||||||
* (см. Surface3dPainterTest.cameraMatchesWordReference).
|
|
||||||
*/
|
|
||||||
static final double CAMERA_DISTANCE = 2.36;
|
|
||||||
|
|
||||||
/**
|
/**
|
||||||
* Глубина коробки построения относительно ширины (при c:view3D/depth = 100).
|
* Глубина коробки построения относительно ширины (при c:view3D/depth = 100).
|
||||||
@@ -521,12 +513,28 @@ final class Surface3dPainter {
|
|||||||
double height = y1 * sb + w * cb;
|
double height = y1 * sb + w * cb;
|
||||||
double k = 1.0;
|
double k = 1.0;
|
||||||
if (perspective > 0.01) {
|
if (perspective > 0.01) {
|
||||||
double d = CAMERA_DISTANCE * (30.0 / Math.max(1.0, perspective));
|
double d = cameraDistance(depthScale, perspective);
|
||||||
k = d / Math.max(0.05, d + depth);
|
k = d / Math.max(0.05, d + depth);
|
||||||
}
|
}
|
||||||
return new Node(x1 * k, -height * k, depth);
|
return new Node(x1 * k, -height * k, depth);
|
||||||
}
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Расстояние камеры от центра коробки построения (в единицах её
|
||||||
|
* полуширины): поле зрения c:view3D/perspective (θ, градусы, Word
|
||||||
|
* default 30) накрывает описанную сферу коробки — полуширина 0.5 (u) и
|
||||||
|
* полуглубина 0.5·depthScale (v) => R = sqrt(0.25 + 0.25·ds²),
|
||||||
|
* d = R/tan(θ/2). Ортография (perspective ≤ 0.01) — бесконечность.
|
||||||
|
* Единая камера surface и pie3D (PiePainter).
|
||||||
|
*/
|
||||||
|
static double cameraDistance(double depthScale, double perspective) {
|
||||||
|
if (perspective <= 0.01) {
|
||||||
|
return Double.POSITIVE_INFINITY;
|
||||||
|
}
|
||||||
|
return Math.sqrt(0.25 + 0.25 * depthScale * depthScale)
|
||||||
|
/ Math.tan(Math.toRadians(perspective) / 2.0);
|
||||||
|
}
|
||||||
|
|
||||||
private static double uOf(int c, int nCat) {
|
private static double uOf(int c, int nCat) {
|
||||||
return nCat > 1 ? (double) c / (nCat - 1) - 0.5 : 0;
|
return nCat > 1 ? (double) c / (nCat - 1) - 0.5 : 0;
|
||||||
}
|
}
|
||||||
|
|||||||
Reference in New Issue
Block a user