< prev index next >
modules/javafx.graphics/src/main/java/com/sun/marlin/TransformingPathConsumer2D.java
Print this page
@@ -96,21 +96,16 @@
public PathConsumer2D detectClosedPath(PathConsumer2D out) {
return cpDetector.init(out);
}
- public PathConsumer2D pathClipper(PathConsumer2D out,
- final float rdrOffX,
- final float rdrOffY)
- {
- return pathClipper.init(out, rdrOffX, rdrOffY);
+ public PathConsumer2D pathClipper(PathConsumer2D out) {
+ return pathClipper.init(out);
}
public PathConsumer2D deltaTransformConsumer(PathConsumer2D out,
- BaseTransform at,
- final float rdrOffX,
- final float rdrOffY)
+ BaseTransform at)
{
if (at == null) {
return out;
}
final float mxx = (float) at.getMxx();
@@ -123,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 float[] clipRect,
- final float rdrOffX,
- final float rdrOffY)
- {
- clipRect[0] += rdrOffY;
- clipRect[1] += rdrOffY;
- clipRect[2] += rdrOffX;
- clipRect[3] += rdrOffX;
- }
-
- private static void adjustClipScale(final float[] clipRect,
+ private static float adjustClipScale(final float[] clipRect,
final float mxx, final float myy)
{
// Adjust the clipping rectangle (iv_DeltaScaleFilter):
- clipRect[0] /= myy;
- clipRect[1] /= myy;
- clipRect[2] /= mxx;
- clipRect[3] /= mxx;
+ final float scaleY = 1.0f / myy;
+ clipRect[0] *= scaleY;
+ clipRect[1] *= scaleY;
+
+ if (clipRect[1] < clipRect[0]) {
+ float tmp = clipRect[0];
+ clipRect[0] = clipRect[1];
+ clipRect[1] = tmp;
}
- private static void adjustClipInverseDelta(final float[] clipRect,
+ final float scaleX = 1.0f / mxx;
+ clipRect[2] *= scaleX;
+ clipRect[3] *= scaleX;
+
+ if (clipRect[3] < clipRect[2]) {
+ float tmp = clipRect[2];
+ clipRect[2] = clipRect[3];
+ clipRect[3] = tmp;
+ }
+
+ if (MarlinConst.DO_LOG_CLIP) {
+ MarlinUtils.logInfo("clipRect (ClipScale): "
+ + Arrays.toString(clipRect));
+ }
+ return 0.5f * (Math.abs(scaleX) + Math.abs(scaleY));
+ }
+
+ private static float adjustClipInverseDelta(final float[] clipRect,
final float mxx, final float mxy,
final float myx, final float myy)
{
// Adjust the clipping rectangle (iv_DeltaTransformFilter):
final float det = mxx * myy - mxy * myx;
@@ -203,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 float scaleX = (float) Math.sqrt(imxx * imxx + imxy * imxy);
+ final float scaleY = (float) Math.sqrt(imyx * imyx + imyy * imyy);
+
+ return 0.5f * (scaleX + scaleY);
}
public PathConsumer2D inverseDeltaTransformConsumer(PathConsumer2D out,
BaseTransform at)
{
@@ -220,11 +236,11 @@
if (mxy == 0.0f && myx == 0.0f) {
if (mxx == 1.0f && myy == 1.0f) {
return out;
} else {
- return iv_DeltaScaleFilter.init(out, 1.0f/mxx, 1.0f/myy);
+ return iv_DeltaScaleFilter.init(out, 1.0f / mxx, 1.0f / myy);
}
} else {
final float det = mxx * myy - mxy * myx;
return iv_DeltaTransformFilter.init(out,
myy / det,
@@ -514,26 +530,13 @@
rdrCtx.stats.hist_pcf_idxstack_indices,
rdrCtx.stats.stat_array_pcf_idxstack_indices)
: new IndexStack(rdrCtx);
}
- PathClipFilter init(final PathConsumer2D out,
- final double rdrOffX,
- final double rdrOffY)
- {
+ PathClipFilter init(final PathConsumer2D out) {
this.out = out;
- // add a small rounding error:
- final float margin = 1e-3f;
-
- final float[] _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 +850,15 @@
private static final boolean TRACE = false;
private static final int MAX_N_CURVES = 3 * 4;
+ private final RendererContext rdrCtx;
+
+ // scaled length threshold:
+ private float minLength;
+
// clip rectangle (ymin, ymax, xmin, xmax):
final float[] clipRect;
// clip rectangle (ymin, ymax, xmin, xmax) including padding:
final float[] clipRectPad = new float[4];
@@ -864,16 +872,27 @@
// dirty curve
private final Curve curve;
CurveClipSplitter(final RendererContext 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.0f) ? 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 +905,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 float x0, final float y0,
final float x1, final float y1,
@@ -899,11 +918,11 @@
{
if (TRACE) {
MarlinUtils.logInfo("divLine P0(" + x0 + ", " + y0 + ") P1(" + x1 + ", " + y1 + ")");
}
- if (DO_CHECK_LENGTH && Helpers.fastLineLen(x0, y0, x1, y1) <= LEN_TH) {
+ if (DO_CHECK_LENGTH && Helpers.fastLineLen(x0, y0, x1, y1) <= minLength) {
return false;
}
final float[] mid = middle;
mid[0] = x0; mid[1] = y0;
@@ -920,11 +939,11 @@
{
if (TRACE) {
MarlinUtils.logInfo("divQuad P0(" + x0 + ", " + y0 + ") P1(" + x1 + ", " + y1 + ") P2(" + x2 + ", " + y2 + ")");
}
- if (DO_CHECK_LENGTH && Helpers.fastQuadLen(x0, y0, x1, y1, x2, y2) <= LEN_TH) {
+ if (DO_CHECK_LENGTH && Helpers.fastQuadLen(x0, y0, x1, y1, x2, y2) <= minLength) {
return false;
}
final float[] mid = middle;
mid[0] = x0; mid[1] = y0;
@@ -943,11 +962,11 @@
{
if (TRACE) {
MarlinUtils.logInfo("divCurve P0(" + x0 + ", " + y0 + ") P1(" + x1 + ", " + y1 + ") P2(" + x2 + ", " + y2 + ") P3(" + x3 + ", " + y3 + ")");
}
- if (DO_CHECK_LENGTH && Helpers.fastCurvelen(x0, y0, x1, y1, x2, y2, x3, y3) <= LEN_TH) {
+ if (DO_CHECK_LENGTH && Helpers.fastCurvelen(x0, y0, x1, y1, x2, y2, x3, y3) <= minLength) {
return false;
}
final float[] mid = middle;
mid[0] = x0; mid[1] = y0;
@@ -971,11 +990,11 @@
final int nSplits = Helpers.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 >