import sun.java2d.marlin.DHelpers.IndexStack;

import sun.java2d.marlin.DHelpers.PolyStack;

    private final DRendererContext rdrCtx;

    // recycled ClosedPathDetector instance from detectClosedPath()

    private final ClosedPathDetector   cpDetector;

    // recycled PathClipFilter instance from pathClipper()

    private final PathClipFilter       pathClipper;

    // recycled DPathConsumer2D instance from wrapPath2D()

    // recycled DPathConsumer2D instances from inverseDeltaTransformConsumer()

    private final DeltaScaleFilter     iv_DeltaScaleFilter     = new DeltaScaleFilter();

    private final DeltaTransformFilter iv_DeltaTransformFilter = new DeltaTransformFilter();

    // recycled PathTracer instances from tracer...() methods

    private final PathTracer tracerInput      = new PathTracer("[Input]");

    private final PathTracer tracerCPDetector = new PathTracer("ClosedPathDetector");

    private final PathTracer tracerFiller     = new PathTracer("Filler");

    private final PathTracer tracerStroker    = new PathTracer("Stroker");

    DTransformingPathConsumer2D(final DRendererContext rdrCtx) {

        // used by RendererContext

        this.rdrCtx = rdrCtx;

        this.cpDetector = new ClosedPathDetector(rdrCtx);

        this.pathClipper = new PathClipFilter(rdrCtx);

    }

    DPathConsumer2D wrapPath2D(Path2D.Double p2d) {

        return wp_Path2DWrapper.init(p2d);

    }

    DPathConsumer2D traceInput(DPathConsumer2D out) {

        return tracerInput.init(out);

    }

    DPathConsumer2D traceClosedPathDetector(DPathConsumer2D out) {

        return tracerCPDetector.init(out);

    }

    DPathConsumer2D traceFiller(DPathConsumer2D out) {

        return tracerFiller.init(out);

    }

    DPathConsumer2D traceStroker(DPathConsumer2D out) {

        return tracerStroker.init(out);

    }

    DPathConsumer2D detectClosedPath(DPathConsumer2D out) {

        return cpDetector.init(out);

    }

    DPathConsumer2D pathClipper(DPathConsumer2D out) {

        return pathClipper.init(out);

    }

        final double mxx = at.getScaleX();

        final double mxy = at.getShearX();

        final double myx = at.getShearY();

        final double myy = at.getScaleY();

                // Scale only

                if (rdrCtx.doClip) {

                    // adjust clip rectangle (ymin, ymax, xmin, xmax):

                    adjustClipScale(rdrCtx.clipRect, mxx, myy);

                }

            if (rdrCtx.doClip) {

                // adjust clip rectangle (ymin, ymax, xmin, xmax):

                adjustClipInverseDelta(rdrCtx.clipRect, mxx, mxy, myx, myy);

            }

    private static void adjustClipOffset(final double[] clipRect) {

        clipRect[0] += Renderer.RDR_OFFSET_Y;

        clipRect[1] += Renderer.RDR_OFFSET_Y;

        clipRect[2] += Renderer.RDR_OFFSET_X;

        clipRect[3] += Renderer.RDR_OFFSET_X;

    }

    private static void adjustClipScale(final double[] clipRect,

                                        final double mxx, final double myy)

    {

        adjustClipOffset(clipRect);

        // Adjust the clipping rectangle (iv_DeltaScaleFilter):

        clipRect[0] /= myy;

        clipRect[1] /= myy;

        clipRect[2] /= mxx;

        clipRect[3] /= mxx;

    }

    private static void adjustClipInverseDelta(final double[] clipRect,

                                               final double mxx, final double mxy,

                                               final double myx, final double myy)

    {

        adjustClipOffset(clipRect);

        // Adjust the clipping rectangle (iv_DeltaTransformFilter):

        final double det = mxx * myy - mxy * myx;

        final double imxx =  myy / det;

        final double imxy = -mxy / det;

        final double imyx = -myx / det;

        final double imyy =  mxx / det;

        double xmin, xmax, ymin, ymax;

        double x, y;

        // xmin, ymin:

        x = clipRect[2] * imxx + clipRect[0] * imxy;

        y = clipRect[2] * imyx + clipRect[0] * imyy;

        xmin = xmax = x;

        ymin = ymax = y;

        // xmax, ymin:

        x = clipRect[3] * imxx + clipRect[0] * imxy;

        y = clipRect[3] * imyx + clipRect[0] * imyy;

        if (x < xmin) { xmin = x; } else if (x > xmax) { xmax = x; }

        if (y < ymin) { ymin = y; } else if (y > ymax) { ymax = y; }

        // xmin, ymax:

        x = clipRect[2] * imxx + clipRect[1] * imxy;

        y = clipRect[2] * imyx + clipRect[1] * imyy;

        if (x < xmin) { xmin = x; } else if (x > xmax) { xmax = x; }

        if (y < ymin) { ymin = y; } else if (y > ymax) { ymax = y; }

        // xmax, ymax:

        x = clipRect[3] * imxx + clipRect[1] * imxy;

        y = clipRect[3] * imyx + clipRect[1] * imyy;

        if (x < xmin) { xmin = x; } else if (x > xmax) { xmax = x; }

        if (y < ymin) { ymin = y; } else if (y > ymax) { ymax = y; }

        clipRect[0] = ymin;

        clipRect[1] = ymax;

        clipRect[2] = xmin;

        clipRect[3] = xmax;

    }

            final double det = mxx * myy - mxy * myx;

    static final class ClosedPathDetector implements DPathConsumer2D {

        private final DRendererContext rdrCtx;

        private final PolyStack stack;

        private DPathConsumer2D out;

        ClosedPathDetector(final DRendererContext rdrCtx) {

            this.rdrCtx = rdrCtx;

            this.stack = (rdrCtx.stats != null) ?

                new PolyStack(rdrCtx,

                        rdrCtx.stats.stat_cpd_polystack_types,

                        rdrCtx.stats.stat_cpd_polystack_curves,

                        rdrCtx.stats.hist_cpd_polystack_curves,

                        rdrCtx.stats.stat_array_cpd_polystack_curves,

                        rdrCtx.stats.stat_array_cpd_polystack_types)

                : new PolyStack(rdrCtx);

        }

        ClosedPathDetector init(DPathConsumer2D out) {

            this.out = out;

            return this; // fluent API

        }

        /**

         * Disposes this instance:

         * clean up before reusing this instance

         */

        void dispose() {

            stack.dispose();

        }

        @Override

        public void pathDone() {

            // previous path is not closed:

            finish(false);

            out.pathDone();

            // TODO: fix possible leak if exception happened

            // Dispose this instance:

            dispose();

        }

        @Override

        public void closePath() {

            // path is closed

            finish(true);

            out.closePath();

        }

        @Override

        public void moveTo(double x0, double y0) {

            // previous path is not closed:

            finish(false);

            out.moveTo(x0, y0);

        }

        private void finish(final boolean closed) {

            rdrCtx.closedPath = closed;

            stack.pullAll(out);

        }

        @Override

        public void lineTo(double x1, double y1) {

            stack.pushLine(x1, y1);

        }

        @Override

        public void curveTo(double x3, double y3,

                            double x2, double y2,

                            double x1, double y1)

        {

            stack.pushCubic(x1, y1, x2, y2, x3, y3);

        }

        @Override

        public void quadTo(double x2, double y2, double x1, double y1) {

            stack.pushQuad(x1, y1, x2, y2);

        }

        @Override

        public long getNativeConsumer() {

            throw new InternalError("Not using a native peer");

        }

    }

    static final class PathClipFilter implements DPathConsumer2D {

        private DPathConsumer2D out;

        // Bounds of the drawing region, at pixel precision.

        private final double[] clipRect;

        private final double[] corners = new double[8];

        private boolean init_corners = false;

        private final IndexStack stack;

        // the current outcode of the current sub path

        private int cOutCode = 0;

        // the cumulated (and) outcode of the complete path

        private int gOutCode = MarlinConst.OUTCODE_MASK_T_B_L_R;

        private boolean outside = false;

        // The current point OUTSIDE

        private double cx0, cy0;

        PathClipFilter(final DRendererContext rdrCtx) {

            this.clipRect = rdrCtx.clipRect;

            this.stack = (rdrCtx.stats != null) ?

                new IndexStack(rdrCtx,

                        rdrCtx.stats.stat_pcf_idxstack_indices,

                        rdrCtx.stats.hist_pcf_idxstack_indices,