< prev index next >
modules/javafx.graphics/src/main/java/com/sun/marlin/DTransformingPathConsumer2D.java
Print this page
@@ -95,21 +95,17 @@
public DPathConsumer2D detectClosedPath(DPathConsumer2D out) {
return cpDetector.init(out);
}
- public DPathConsumer2D pathClipper(DPathConsumer2D out,
- final double rdrOffX,
- final double rdrOffY)
+ public DPathConsumer2D pathClipper(DPathConsumer2D out)
{
- return pathClipper.init(out, rdrOffX, rdrOffY);
+ return pathClipper.init(out);
}
public DPathConsumer2D deltaTransformConsumer(DPathConsumer2D out,
- BaseTransform at,
- final double rdrOffX,
- final double rdrOffY)
+ BaseTransform at)
{
if (at == null) {
return out;
}
final double mxx = at.getMxx();
@@ -122,46 +118,57 @@
return out;
} else {
// Scale only
if (rdrCtx.doClip) {
// adjust clip rectangle (ymin, ymax, xmin, xmax):
- adjustClipOffset(rdrCtx.clipRect, rdrOffX, rdrOffY);
- adjustClipScale(rdrCtx.clipRect, mxx, myy);
+ rdrCtx.clipInvScale = adjustClipScale(rdrCtx.clipRect,
+ mxx, myy);
}
return dt_DeltaScaleFilter.init(out, mxx, myy);
}
} else {
if (rdrCtx.doClip) {
// adjust clip rectangle (ymin, ymax, xmin, xmax):
- adjustClipOffset(rdrCtx.clipRect, rdrOffX, rdrOffY);
- adjustClipInverseDelta(rdrCtx.clipRect, mxx, mxy, myx, myy);
+ rdrCtx.clipInvScale = adjustClipInverseDelta(rdrCtx.clipRect,
+ mxx, mxy, myx, myy);
}
return dt_DeltaTransformFilter.init(out, mxx, mxy, myx, myy);
}
}
- private static void adjustClipOffset(final double[] clipRect,
- final double rdrOffX,
- final double rdrOffY)
- {
- clipRect[0] += rdrOffY;
- clipRect[1] += rdrOffY;
- clipRect[2] += rdrOffX;
- clipRect[3] += rdrOffX;
- }
-
- private static void adjustClipScale(final double[] clipRect,
+ private static double adjustClipScale(final double[] clipRect,
final double mxx, final double myy)
{
// Adjust the clipping rectangle (iv_DeltaScaleFilter):
- clipRect[0] /= myy;
- clipRect[1] /= myy;
- clipRect[2] /= mxx;
- clipRect[3] /= mxx;
+ final double scaleY = 1.0d / myy;
+ clipRect[0] *= scaleY;
+ clipRect[1] *= scaleY;
+
+ if (clipRect[1] < clipRect[0]) {
+ double tmp = clipRect[0];
+ clipRect[0] = clipRect[1];
+ clipRect[1] = tmp;
}
- private static void adjustClipInverseDelta(final double[] clipRect,
+ final double scaleX = 1.0d / mxx;
+ clipRect[2] *= scaleX;
+ clipRect[3] *= scaleX;
+
+ if (clipRect[3] < clipRect[2]) {
+ double tmp = clipRect[2];
+ clipRect[2] = clipRect[3];
+ clipRect[3] = tmp;
+ }
+
+ if (MarlinConst.DO_LOG_CLIP) {
+ MarlinUtils.logInfo("clipRect (ClipScale): "
+ + Arrays.toString(clipRect));
+ }
+ return 0.5d * (Math.abs(scaleX) + Math.abs(scaleY));
+ }
+
+ private static double adjustClipInverseDelta(final double[] clipRect,
final double mxx, final double mxy,
final double myx, final double myy)
{
// Adjust the clipping rectangle (iv_DeltaTransformFilter):
final double det = mxx * myy - mxy * myx;
@@ -202,10 +209,20 @@
clipRect[0] = ymin;
clipRect[1] = ymax;
clipRect[2] = xmin;
clipRect[3] = xmax;
+
+ if (MarlinConst.DO_LOG_CLIP) {
+ MarlinUtils.logInfo("clipRect (ClipInverseDelta): "
+ + Arrays.toString(clipRect));
+ }
+
+ final double scaleX = Math.sqrt(imxx * imxx + imxy * imxy);
+ final double scaleY = Math.sqrt(imyx * imyx + imyy * imyy);
+
+ return 0.5d * (scaleX + scaleY);
}
public DPathConsumer2D inverseDeltaTransformConsumer(DPathConsumer2D out,
BaseTransform at)
{
@@ -219,11 +236,11 @@
if (mxy == 0.0d && myx == 0.0d) {
if (mxx == 1.0d && myy == 1.0d) {
return out;
} else {
- return iv_DeltaScaleFilter.init(out, 1.0d/mxx, 1.0d/myy);
+ return iv_DeltaScaleFilter.init(out, 1.0d / mxx, 1.0d / myy);
}
} else {
final double det = mxx * myy - mxy * myx;
return iv_DeltaTransformFilter.init(out,
myy / det,
@@ -514,26 +531,13 @@
rdrCtx.stats.hist_pcf_idxstack_indices,
rdrCtx.stats.stat_array_pcf_idxstack_indices)
: new IndexStack(rdrCtx);
}
- PathClipFilter init(final DPathConsumer2D out,
- final double rdrOffX,
- final double rdrOffY)
- {
+ PathClipFilter init(final DPathConsumer2D out) {
this.out = out;
- // add a small rounding error:
- final double margin = 1e-3d;
-
- final double[] _clipRect = this.clipRect;
- // Adjust the clipping rectangle with the renderer offsets
- _clipRect[0] -= margin - rdrOffY;
- _clipRect[1] += margin + rdrOffY;
- _clipRect[2] -= margin - rdrOffX;
- _clipRect[3] += margin + rdrOffX;
-
if (MarlinConst.DO_CLIP_SUBDIVIDER) {
// adjust padded clip rectangle:
curveSplitter.init();
}
@@ -847,10 +851,15 @@
private static final boolean TRACE = false;
private static final int MAX_N_CURVES = 3 * 4;
+ private final DRendererContext rdrCtx;
+
+ // scaled length threshold:
+ private double minLength;
+
// clip rectangle (ymin, ymax, xmin, xmax):
final double[] clipRect;
// clip rectangle (ymin, ymax, xmin, xmax) including padding:
final double[] clipRectPad = new double[4];
@@ -864,16 +873,27 @@
// dirty curve
private final DCurve curve;
CurveClipSplitter(final DRendererContext rdrCtx) {
+ this.rdrCtx = rdrCtx;
this.clipRect = rdrCtx.clipRect;
this.curve = rdrCtx.curve;
}
void init() {
this.init_clipRectPad = true;
+
+ if (DO_CHECK_LENGTH) {
+ this.minLength = (this.rdrCtx.clipInvScale == 0.0d) ? LEN_TH
+ : (LEN_TH * this.rdrCtx.clipInvScale);
+
+ if (MarlinConst.DO_LOG_CLIP) {
+ MarlinUtils.logInfo("CurveClipSplitter.minLength = "
+ + minLength);
+ }
+ }
}
private void initPaddedClip() {
// bounds as half-open intervals: minX <= x < maxX and minY <= y < maxY
// adjust padded clip rectangle (ymin, ymax, xmin, xmax):
@@ -886,11 +906,11 @@
_clipRectPad[2] = _clipRect[2] - CLIP_RECT_PADDING;
_clipRectPad[3] = _clipRect[3] + CLIP_RECT_PADDING;
if (TRACE) {
MarlinUtils.logInfo("clip: X [" + _clipRectPad[2] + " .. " + _clipRectPad[3] +"] "
- + "Y ["+ _clipRectPad[0] + " .. " + _clipRectPad[1] +"]");
+ + "Y [" + _clipRectPad[0] + " .. " + _clipRectPad[1] +"]");
}
}
boolean splitLine(final double x0, final double y0,
final double x1, final double y1,
@@ -899,11 +919,11 @@
{
if (TRACE) {
MarlinUtils.logInfo("divLine P0(" + x0 + ", " + y0 + ") P1(" + x1 + ", " + y1 + ")");
}
- if (DO_CHECK_LENGTH && DHelpers.fastLineLen(x0, y0, x1, y1) <= LEN_TH) {
+ if (DO_CHECK_LENGTH && DHelpers.fastLineLen(x0, y0, x1, y1) <= minLength) {
return false;
}
final double[] mid = middle;
mid[0] = x0; mid[1] = y0;
@@ -920,11 +940,11 @@
{
if (TRACE) {
MarlinUtils.logInfo("divQuad P0(" + x0 + ", " + y0 + ") P1(" + x1 + ", " + y1 + ") P2(" + x2 + ", " + y2 + ")");
}
- if (DO_CHECK_LENGTH && DHelpers.fastQuadLen(x0, y0, x1, y1, x2, y2) <= LEN_TH) {
+ if (DO_CHECK_LENGTH && DHelpers.fastQuadLen(x0, y0, x1, y1, x2, y2) <= minLength) {
return false;
}
final double[] mid = middle;
mid[0] = x0; mid[1] = y0;
@@ -943,11 +963,11 @@
{
if (TRACE) {
MarlinUtils.logInfo("divCurve P0(" + x0 + ", " + y0 + ") P1(" + x1 + ", " + y1 + ") P2(" + x2 + ", " + y2 + ") P3(" + x3 + ", " + y3 + ")");
}
- if (DO_CHECK_LENGTH && DHelpers.fastCurvelen(x0, y0, x1, y1, x2, y2, x3, y3) <= LEN_TH) {
+ if (DO_CHECK_LENGTH && DHelpers.fastCurvelen(x0, y0, x1, y1, x2, y2, x3, y3) <= minLength) {
return false;
}
final double[] mid = middle;
mid[0] = x0; mid[1] = y0;
@@ -971,11 +991,11 @@
final int nSplits = DHelpers.findClipPoints(curve, mid, subTs, type,
outCodeOR, clipRectPad);
if (TRACE) {
- MarlinUtils.logInfo("nSplits: "+ nSplits);
+ MarlinUtils.logInfo("nSplits: " + nSplits);
MarlinUtils.logInfo("subTs: " + Arrays.toString(Arrays.copyOfRange(subTs, 0, nSplits)));
}
if (nSplits == 0) {
// only curve support shortcut
return false;
< prev index next >