incubator-flex-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From cframp...@apache.org
Subject svn commit: r1402274 [26/31] - in /incubator/flex/sdk/branches/develop/modules/thirdparty/batik/sources/org/apache/flex/forks/batik/ext: ./ awt/ awt/color/ awt/font/ awt/g2d/ awt/geom/ awt/image/ awt/image/codec/ awt/image/codec/jpeg/ awt/image/codec/p...
Date Thu, 25 Oct 2012 19:01:49 GMT
Added: incubator/flex/sdk/branches/develop/modules/thirdparty/batik/sources/org/apache/flex/forks/batik/ext/awt/image/rendered/BumpMap.java
URL: http://svn.apache.org/viewvc/incubator/flex/sdk/branches/develop/modules/thirdparty/batik/sources/org/apache/flex/forks/batik/ext/awt/image/rendered/BumpMap.java?rev=1402274&view=auto
==============================================================================
--- incubator/flex/sdk/branches/develop/modules/thirdparty/batik/sources/org/apache/flex/forks/batik/ext/awt/image/rendered/BumpMap.java (added)
+++ incubator/flex/sdk/branches/develop/modules/thirdparty/batik/sources/org/apache/flex/forks/batik/ext/awt/image/rendered/BumpMap.java Thu Oct 25 19:01:43 2012
@@ -0,0 +1,493 @@
+/*
+
+   Licensed to the Apache Software Foundation (ASF) under one or more
+   contributor license agreements.  See the NOTICE file distributed with
+   this work for additional information regarding copyright ownership.
+   The ASF licenses this file to You under the Apache License, Version 2.0
+   (the "License"); you may not use this file except in compliance with
+   the License.  You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+
+ */
+package org.apache.flex.forks.batik.ext.awt.image.rendered;
+
+import java.awt.Rectangle;
+import java.awt.image.DataBufferInt;
+import java.awt.image.Raster;
+import java.awt.image.RenderedImage;
+import java.awt.image.SinglePixelPackedSampleModel;
+
+/**
+ * Default BumpMap implementation.
+ *
+ * @author <a href="mailto:vincent.hardy@eng.sun.com">Vincent Hardy</a>
+ * @version $Id: BumpMap.java 501495 2007-01-30 18:00:36Z dvholten $
+ */
+public final class BumpMap {
+    /**
+     * Image whose alpha channel is used for the
+     * normal calculation
+     */
+    private RenderedImage texture;
+
+    /**
+     * Surface scale used in the normal computation
+     */
+    private double surfaceScale, surfaceScaleX, surfaceScaleY;
+
+    /**
+     * User space to device space scale factors
+     */
+    private double scaleX, scaleY;
+
+    /**
+     * Stores the normals for this bumpMap.
+     * scaleX and scaleY are the user space to device
+     * space scales.
+     */
+    public BumpMap(RenderedImage texture,
+                   double surfaceScale,
+                   double scaleX, double scaleY){
+        this.texture = texture;
+        this.surfaceScaleX = surfaceScale*scaleX;
+        this.surfaceScaleY = surfaceScale*scaleY;
+        this.surfaceScale = surfaceScale;
+        this.scaleX = scaleX;
+        this.scaleY = scaleY;
+    }
+
+    /**
+     * @return surface scale used by this bump map.
+     */
+    public double getSurfaceScale(){
+        return surfaceScale;
+    }
+
+    /**
+     * @param x x-axis coordinate for which the normal is computed
+     * @param y y-axis coordinate for which the normal is computed
+     */
+    public double[][][] getNormalArray
+        (final int x, final int y,
+         final int w, final int h)
+    {
+        final double[][][] N = new double[h][w][4];
+
+        Rectangle srcRect = new Rectangle(x-1, y-1, w+2, h+2);
+        Rectangle srcBound = new Rectangle
+            (texture.getMinX(), texture.getMinY(),
+             texture.getWidth(), texture.getHeight());
+
+        if ( ! srcRect.intersects(srcBound) )
+            return N;
+
+        srcRect = srcRect.intersection(srcBound);
+        final Raster r = texture.getData(srcRect);
+
+        srcRect = r.getBounds();
+
+        // System.out.println("SrcRect: " + srcRect);
+        // System.out.println("rect: [" +
+        //                    x + ", " + y + ", " +
+        //                    w + ", " + h + "]");
+
+        final DataBufferInt db = (DataBufferInt)r.getDataBuffer();
+
+
+        final int[] pixels = db.getBankData()[0];
+
+        final SinglePixelPackedSampleModel sppsm;
+        sppsm = (SinglePixelPackedSampleModel)r.getSampleModel();
+
+
+        final int scanStride = sppsm.getScanlineStride();
+        final int scanStridePP = scanStride + 1;
+        final int scanStrideMM = scanStride - 1;
+        double prpc=0, prcc=0, prnc=0;
+        double crpc=0, crcc=0, crnc=0;
+        double nrpc=0, nrcc=0, nrnc=0;
+        double invNorm;
+
+        final double quarterSurfaceScaleX = surfaceScaleX / 4f;
+        final double quarterSurfaceScaleY = surfaceScaleY / 4f;
+        final double halfSurfaceScaleX = surfaceScaleX / 2f;
+        final double halfSurfaceScaleY = surfaceScaleY /2;
+        final double thirdSurfaceScaleX = surfaceScaleX / 3f;
+        final double thirdSurfaceScaleY = surfaceScaleY / 3f;
+        final double twoThirdSurfaceScaleX = surfaceScaleX * 2 / 3f;
+        final double twoThirdSurfaceScaleY = surfaceScaleY * 2 / 3f;
+
+        final double pixelScale = 1.0/255;
+
+        if(w <= 0)
+            return N;
+        // Process pixels on the border
+        if(h <= 0)
+            return N;
+
+        final int xEnd   = Math.min(srcRect.x+srcRect.width -1, x+w);
+        final int yEnd   = Math.min(srcRect.y+srcRect.height-1, y+h);
+        final int offset =
+            (db.getOffset() +
+             sppsm.getOffset(srcRect.x -r.getSampleModelTranslateX(),
+                             srcRect.y -r.getSampleModelTranslateY()));
+
+        int yloc=y;
+        if (yloc < srcRect.y) {
+            yloc = srcRect.y;
+        }
+
+        // Top edge extend filters...
+        if (yloc == srcRect.y) {
+            if (yloc == yEnd) {
+                // Only one row of pixels...
+                final double [][] NRow = N[yloc-y];
+                int xloc=x;
+                if (xloc < srcRect.x)
+                    xloc = srcRect.x;
+                int p  = (offset + (xloc-srcRect.x) +
+                          scanStride*(yloc-srcRect.y));
+
+                crcc = (pixels[p] >>> 24)*pixelScale;
+
+                if (xloc != srcRect.x) {
+                    crpc = (pixels[p - 1] >>> 24)*pixelScale;
+                }
+                else if (xloc < xEnd) {
+                    // Top left pixel, in src (0, 0);
+                    crnc = (pixels[p+1] >>> 24)*pixelScale;
+
+                    final double [] n = NRow[xloc-x];
+
+                    n[0] = 2*surfaceScaleX*(crcc - crnc);
+                    invNorm = 1.0/Math.sqrt(n[0]*n[0] + 1);
+                    n[0] *= invNorm;
+                    n[1]  = 0;
+                    n[2]  = invNorm;
+                    n[3]  = crcc*surfaceScale;
+                    p++;
+                    xloc++;
+                    crpc = crcc;
+                    crcc = crnc;
+                } else {
+                    // Single pix.
+                    crpc = crcc;
+                }
+
+                for (; xloc<xEnd; xloc++) {
+                    // Middle Top row...
+                    crnc = (pixels[p+1] >>> 24)*pixelScale;
+                    final double [] n = NRow[xloc-x];
+
+                    n[0] = surfaceScaleX * (crpc - crnc );
+                    invNorm = 1.0/Math.sqrt(n[0]*n[0] + 1);
+                    n[0] *= invNorm;
+                    n[1]  = 0;
+                    n[2]  = invNorm;
+                    n[3]  = crcc*surfaceScale;
+                    p++;
+                    crpc = crcc;
+                    crcc = crnc;
+                }
+
+                if ((xloc < x+w) &&
+                    (xloc == srcRect.x+srcRect.width-1)) {
+                    // Last pixel of top row
+                    final double [] n = NRow[xloc-x];
+
+                    n[0] = 2*surfaceScaleX*(crpc - crcc);
+                    invNorm = 1.0/Math.sqrt(n[0]*n[0] + n[1]*n[1] + 1);
+                    n[0] *= invNorm;
+                    n[1] *= invNorm;
+                    n[2]  = invNorm;
+                    n[3]  = crcc*surfaceScale;
+                }
+                return N;
+            }
+
+            final double [][] NRow = N[yloc-y];
+            int p  = offset + scanStride*(yloc-srcRect.y);
+            int xloc=x;
+            if (xloc < srcRect.x)
+                xloc = srcRect.x;
+            p += xloc-srcRect.x;
+
+            crcc = (pixels[p] >>> 24)*pixelScale;
+            nrcc = (pixels[p + scanStride] >>> 24)*pixelScale;
+
+            if (xloc != srcRect.x) {
+                crpc = (pixels[p - 1] >>> 24)*pixelScale;
+                nrpc = (pixels[p + scanStrideMM] >>> 24)*pixelScale;
+            }
+            else if (xloc < xEnd) {
+                // Top left pixel, in src (0, 0);
+                crnc = (pixels[p+1] >>> 24)*pixelScale;
+                nrnc = (pixels[p + scanStridePP] >>> 24)*pixelScale;
+
+                final double [] n = NRow[xloc-x];
+
+                n[0] = - twoThirdSurfaceScaleX *
+                    ((2*crnc + nrnc - 2*crcc - nrcc));
+                n[1] = - twoThirdSurfaceScaleY *
+                    ((2*nrcc + nrnc - 2*crcc - crnc));
+                invNorm = 1.0/Math.sqrt(n[0]*n[0] + n[1]*n[1] + 1);
+                n[0] *= invNorm;
+                n[1] *= invNorm;
+                n[2]  = invNorm;
+                n[3]  = crcc*surfaceScale;
+                p++;
+                xloc++;
+                crpc = crcc;
+                nrpc = nrcc;
+                crcc = crnc;
+                nrcc = nrnc;
+            } else {
+                // Single pix
+                crpc = crcc;
+                nrpc = nrcc;
+            }
+
+            for (; xloc<xEnd; xloc++) {
+                // Middle Top row...
+                crnc = (pixels[p+1] >>> 24)*pixelScale;
+                nrnc = (pixels[p + scanStridePP] >>> 24)*pixelScale;
+
+                final double [] n = NRow[xloc-x];
+
+                n[0] = - thirdSurfaceScaleX * (( 2*crnc + nrnc)
+                                               - (2*crpc + nrpc));
+                n[1] = - halfSurfaceScaleY *(( nrpc + 2*nrcc + nrnc)
+                                             - (crpc + 2*crcc + crnc));
+
+                invNorm = 1.0/Math.sqrt(n[0]*n[0] + n[1]*n[1] + 1);
+                n[0] *= invNorm;
+                n[1] *= invNorm;
+                n[2]  = invNorm;
+                n[3]  = crcc*surfaceScale;
+                p++;
+                crpc = crcc;
+                nrpc = nrcc;
+                crcc = crnc;
+                nrcc = nrnc;
+            }
+
+            if ((xloc < x+w) &&
+                (xloc == srcRect.x+srcRect.width-1)) {
+                // Last pixel of top row
+                final double [] n = NRow[xloc-x];
+
+                n[0] = - twoThirdSurfaceScaleX *(( 2*crcc + nrcc)
+                                                 - (2*crpc + nrpc));
+                n[1] = - twoThirdSurfaceScaleY *(( 2*nrcc + nrpc)
+                                                 - (2*crcc + crpc));
+
+                invNorm = 1.0/Math.sqrt(n[0]*n[0] + n[1]*n[1] + 1);
+                n[0] *= invNorm;
+                n[1] *= invNorm;
+                n[2]  = invNorm;
+                n[3]  = crcc*surfaceScale;
+            }
+            yloc++;
+        }
+
+        for (; yloc<yEnd; yloc++) {
+            final double [][] NRow = N[yloc-y];
+            int p  = offset + scanStride*(yloc-srcRect.y);
+
+            int xloc=x;
+            if (xloc < srcRect.x)
+                xloc = srcRect.x;
+
+            p += xloc-srcRect.x;
+
+            prcc = (pixels[p - scanStride] >>> 24)*pixelScale;
+            crcc = (pixels[p] >>> 24)*pixelScale;
+            nrcc = (pixels[p + scanStride] >>> 24)*pixelScale;
+
+            if (xloc != srcRect.x) {
+                prpc = (pixels[p - scanStridePP] >>> 24)*pixelScale;
+                crpc = (pixels[p - 1] >>> 24)*pixelScale;
+                nrpc = (pixels[p + scanStrideMM] >>> 24)*pixelScale;
+            }
+            else if (xloc < xEnd) {
+                // Now, process left column, from (0, 1) to (0, h-1)
+                crnc = (pixels[p+1] >>> 24)*pixelScale;
+                prnc = (pixels[p - scanStrideMM] >>> 24)*pixelScale;
+                nrnc = (pixels[p + scanStridePP] >>> 24)*pixelScale;
+
+                final double [] n = NRow[xloc-x];
+
+                n[0] = - halfSurfaceScaleX *(( prnc + 2*crnc + nrnc)
+                                             - (prcc + 2*crcc + nrcc));
+                n[1] = - thirdSurfaceScaleY *(( 2*prcc + prnc)
+                                              - ( 2*crcc + crnc));
+
+                invNorm = 1.0/Math.sqrt(n[0]*n[0] + n[1]*n[1] + 1);
+                n[0] *= invNorm;
+                n[1] *= invNorm;
+                n[2]  = invNorm;
+                n[3]  = crcc*surfaceScale;
+
+                p++;
+                xloc++;
+
+                prpc = prcc;
+                crpc = crcc;
+                nrpc = nrcc;
+                prcc = prnc;
+                crcc = crnc;
+                nrcc = nrnc;
+            } else {
+                // Single pix
+                prpc = prcc;
+                crpc = crcc;
+                nrpc = nrcc;
+            }
+
+            for (; xloc<xEnd; xloc++) {
+                // Middle Middle row...
+                prnc = (pixels[p - scanStrideMM] >>> 24)*pixelScale;
+                crnc = (pixels[p+1] >>> 24)*pixelScale;
+                nrnc = (pixels[p + scanStridePP] >>> 24)*pixelScale;
+
+                final double [] n = NRow[xloc-x];
+
+                n[0] = - quarterSurfaceScaleX *(( prnc + 2*crnc + nrnc)
+                                                - (prpc + 2*crpc + nrpc));
+                n[1] = - quarterSurfaceScaleY *(( nrpc + 2*nrcc + nrnc)
+                                                - (prpc + 2*prcc + prnc));
+
+                invNorm = 1.0/Math.sqrt(n[0]*n[0] + n[1]*n[1] + 1);
+                n[0] *= invNorm;
+                n[1] *= invNorm;
+                n[2]  = invNorm;
+                n[3]  = crcc*surfaceScale;
+
+                p++;
+                prpc = prcc;
+                crpc = crcc;
+                nrpc = nrcc;
+                prcc = prnc;
+                crcc = crnc;
+                nrcc = nrnc;
+            }
+
+            if ((xloc < x+w) &&
+                (xloc == srcRect.x+srcRect.width-1)) {
+                // Now, proces right column, from (w-1, 1) to (w-1, h-1)
+                final double [] n = NRow[xloc-x];
+
+                n[0] = - halfSurfaceScaleX *( (prcc + 2*crcc + nrcc)
+                                             -(prpc + 2*crpc + nrpc));
+                n[1] = - thirdSurfaceScaleY *(( nrpc + 2*nrcc)
+                                              - ( prpc + 2*prcc));
+
+                invNorm = 1.0/Math.sqrt(n[0]*n[0] + n[1]*n[1] + 1);
+                n[0] *= invNorm;
+                n[1] *= invNorm;
+                n[2]  = invNorm;
+                n[3]  = crcc*surfaceScale;
+            }
+        }
+
+        if ((yloc < y+h) &&
+            (yloc == srcRect.y+srcRect.height-1)) {
+            final double [][] NRow = N[yloc-y];
+            int p  = offset + scanStride*(yloc-srcRect.y);
+            int xloc=x;
+            if (xloc < srcRect.x)
+                xloc = srcRect.x;
+
+            p += xloc-srcRect.x;
+
+            crcc = (pixels[p] >>> 24)*pixelScale;
+            prcc = (pixels[p - scanStride] >>> 24)*pixelScale;
+
+            if (xloc != srcRect.x) {
+                prpc = (pixels[p - scanStridePP] >>> 24)*pixelScale;
+                crpc = (pixels[p - 1] >>> 24)*pixelScale;
+            }
+            else if (xloc < xEnd) {
+                // Process first pixel of last row
+                crnc = (pixels[p + 1] >>> 24)*pixelScale;
+                prnc = (pixels[p - scanStrideMM] >>> 24)*pixelScale;
+
+                final double [] n = NRow[xloc-x];
+
+                n[0] = - twoThirdSurfaceScaleX * ((2*crnc + prnc - 2*crcc - prcc));
+                n[1] = - twoThirdSurfaceScaleY * ((2*crcc + crnc - 2*prcc - prnc));
+                invNorm = 1.0/Math.sqrt(n[0]*n[0] + n[1]*n[1] + 1);
+                n[0] *= invNorm;
+                n[1] *= invNorm;
+                n[2]  = invNorm;
+                n[3]  = crcc*surfaceScale;
+
+                p++;
+                xloc++;
+                crpc = crcc;
+                prpc = prcc;
+                crcc = crnc;
+                prcc = prnc;
+            } else {
+                // Single pix
+                crpc = crcc;
+                prpc = prcc;
+            }
+
+            for (; xloc<xEnd; xloc++) {
+                // Middle of Bottom row...
+                crnc = (pixels[p + 1] >>> 24)*pixelScale;
+                prnc = (pixels[p - scanStrideMM] >>> 24)*pixelScale;
+
+                // System.out.println("Vals: " +
+                //                    prpc + "," + prcc + "," + prnc + "  " +
+                //                    crpc + "," + crcc + "," + crnc );
+
+                final double [] n = NRow[xloc-x];
+
+                n[0] = - thirdSurfaceScaleX *(( 2*crnc + prnc)
+                                              - (2*crpc + prpc));
+                n[1] = - halfSurfaceScaleY *(( crpc + 2*crcc + crnc)
+                                             - (prpc + 2*prcc + prnc));
+
+                invNorm = 1.0/Math.sqrt(n[0]*n[0] + n[1]*n[1] + 1);
+                n[0] *= invNorm;
+                n[1] *= invNorm;
+                n[2]  = invNorm;
+                n[3]  = crcc*surfaceScale;
+
+                p++;
+                crpc = crcc;
+                prpc = prcc;
+                crcc = crnc;
+                prcc = prnc;
+            }
+
+            if ((xloc < x+w) &&
+                (xloc == srcRect.x+srcRect.width-1)) {
+                // Bottom right corner
+                final double [] n = NRow[xloc-x];
+
+                n[0] = - twoThirdSurfaceScaleX *(( 2*crcc + prcc)
+                                                 - (2*crpc + prpc));
+                n[1] = - twoThirdSurfaceScaleY *(( 2*crcc + crpc)
+                                                 - (2*prcc + prpc));
+
+                invNorm = 1.0/Math.sqrt(n[0]*n[0] + n[1]*n[1] + 1);
+                n[0] *= invNorm;
+                n[1] *= invNorm;
+                n[2]  = invNorm;
+                n[3]  = crcc*surfaceScale;
+            }
+        }
+        return N;
+    }
+}
+

Propchange: incubator/flex/sdk/branches/develop/modules/thirdparty/batik/sources/org/apache/flex/forks/batik/ext/awt/image/rendered/BumpMap.java
------------------------------------------------------------------------------
    svn:eol-style = native

Added: incubator/flex/sdk/branches/develop/modules/thirdparty/batik/sources/org/apache/flex/forks/batik/ext/awt/image/rendered/CachableRed.java
URL: http://svn.apache.org/viewvc/incubator/flex/sdk/branches/develop/modules/thirdparty/batik/sources/org/apache/flex/forks/batik/ext/awt/image/rendered/CachableRed.java?rev=1402274&view=auto
==============================================================================
--- incubator/flex/sdk/branches/develop/modules/thirdparty/batik/sources/org/apache/flex/forks/batik/ext/awt/image/rendered/CachableRed.java (added)
+++ incubator/flex/sdk/branches/develop/modules/thirdparty/batik/sources/org/apache/flex/forks/batik/ext/awt/image/rendered/CachableRed.java Thu Oct 25 19:01:43 2012
@@ -0,0 +1,65 @@
+/*
+
+   Licensed to the Apache Software Foundation (ASF) under one or more
+   contributor license agreements.  See the NOTICE file distributed with
+   this work for additional information regarding copyright ownership.
+   The ASF licenses this file to You under the Apache License, Version 2.0
+   (the "License"); you may not use this file except in compliance with
+   the License.  You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+
+ */
+package org.apache.flex.forks.batik.ext.awt.image.rendered;
+
+import java.awt.Rectangle;
+import java.awt.Shape;
+import java.awt.image.RenderedImage;
+
+/**
+ * This provides a number of extra methods that enable a system to
+ * better analyse the dependencies between nodes in a render graph.
+ *
+ * @author <a href="mailto:Thomas.DeWeeese@Kodak.com">Thomas DeWeese</a>
+ * @version $Id: CachableRed.java 478276 2006-11-22 18:33:37Z dvholten $
+*/
+public interface CachableRed extends RenderedImage {
+
+    /**
+     * Returns the bounds of the current image.
+     * This should be 'in sync' with getMinX, getMinY, getWidth, getHeight
+     */
+    Rectangle getBounds();
+
+    /**
+     * Returns the region of input data is is required to generate
+     * outputRgn.
+     * @param srcIndex  The source to do the dependency calculation for.
+     * @param outputRgn The region of output you are interested in
+     * generating dependencies for.  The is given in the output pixel
+     * coordiate system for this node.
+     * @return The region of input required.  This is in the output pixel
+     * coordinate system for the source indicated by srcIndex.
+     */
+    Shape getDependencyRegion(int srcIndex, Rectangle outputRgn);
+
+    /**
+     * This calculates the region of output that is affected by a change
+     * in a region of input.
+     * @param srcIndex The input that inputRgn reflects changes in.
+     * @param inputRgn the region of input that has changed, used to
+     *  calculate the returned shape.  This is given in the pixel
+     *  coordinate system of the source indicated by srcIndex.
+     * @return The region of output that would be invalid given
+     *  a change to inputRgn of the source selected by srcIndex.
+     *  this is in the output pixel coordinate system of this node.
+     */
+    Shape getDirtyRegion(int srcIndex, Rectangle inputRgn);
+}
+

Propchange: incubator/flex/sdk/branches/develop/modules/thirdparty/batik/sources/org/apache/flex/forks/batik/ext/awt/image/rendered/CachableRed.java
------------------------------------------------------------------------------
    svn:eol-style = native

Added: incubator/flex/sdk/branches/develop/modules/thirdparty/batik/sources/org/apache/flex/forks/batik/ext/awt/image/rendered/ColorMatrixRed.java
URL: http://svn.apache.org/viewvc/incubator/flex/sdk/branches/develop/modules/thirdparty/batik/sources/org/apache/flex/forks/batik/ext/awt/image/rendered/ColorMatrixRed.java?rev=1402274&view=auto
==============================================================================
--- incubator/flex/sdk/branches/develop/modules/thirdparty/batik/sources/org/apache/flex/forks/batik/ext/awt/image/rendered/ColorMatrixRed.java (added)
+++ incubator/flex/sdk/branches/develop/modules/thirdparty/batik/sources/org/apache/flex/forks/batik/ext/awt/image/rendered/ColorMatrixRed.java Thu Oct 25 19:01:43 2012
@@ -0,0 +1,204 @@
+/*
+
+   Licensed to the Apache Software Foundation (ASF) under one or more
+   contributor license agreements.  See the NOTICE file distributed with
+   this work for additional information regarding copyright ownership.
+   The ASF licenses this file to You under the Apache License, Version 2.0
+   (the "License"); you may not use this file except in compliance with
+   the License.  You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+
+ */
+package org.apache.flex.forks.batik.ext.awt.image.rendered;
+
+import java.awt.color.ColorSpace;
+import java.awt.image.ColorModel;
+import java.awt.image.DataBufferInt;
+import java.awt.image.SampleModel;
+import java.awt.image.SinglePixelPackedSampleModel;
+import java.awt.image.WritableRaster;
+
+import org.apache.flex.forks.batik.ext.awt.image.GraphicsUtil;
+
+/**
+ *
+ * @author <a href="mailto:vincent.hardy@eng.sun.com">Vincent Hardy</a>
+ * @version $Id: ColorMatrixRed.java 479564 2006-11-27 09:56:57Z dvholten $
+ */
+public class ColorMatrixRed extends AbstractRed{
+    /**
+     * Matrix to apply to color components
+     */
+    private float[][] matrix;
+
+    public float[][] getMatrix(){
+        return copyMatrix(matrix);
+    }
+
+    public void setMatrix(float[][] matrix){
+        float[][] tmp = copyMatrix(matrix);
+
+        if(tmp == null){
+            throw new IllegalArgumentException();
+        }
+
+        if(tmp.length != 4){
+            throw new IllegalArgumentException();
+        }
+
+        for(int i=0; i<4; i++){
+            if(tmp[i].length != 5){
+                throw new IllegalArgumentException( String.valueOf( i ) + " : " + tmp[i].length);
+            }
+        }
+        this.matrix = matrix;
+    }
+
+    private float[][] copyMatrix(float[][] m){
+        if(m == null){
+            return null;
+        }
+
+        float[][] cm = new float[m.length][];
+        for(int i=0; i<m.length; i++){
+            if(m[i] != null){
+                cm[i] = new float[m[i].length];
+                System.arraycopy(m[i], 0, cm[i], 0, m[i].length);
+            }
+        }
+
+        return cm;
+    }
+
+    public ColorMatrixRed(CachableRed src, float[][] matrix){
+        setMatrix(matrix);
+
+        ColorModel srcCM = src.getColorModel();
+        ColorSpace srcCS = null;
+        if (srcCM != null)
+            srcCS = srcCM.getColorSpace();
+        ColorModel cm;
+        if (srcCS == null)
+            cm = GraphicsUtil.Linear_sRGB_Unpre;
+        else {
+            if (srcCS == ColorSpace.getInstance(ColorSpace.CS_LINEAR_RGB))
+                cm = GraphicsUtil.Linear_sRGB_Unpre;
+            else
+                cm = GraphicsUtil.sRGB_Unpre;
+        }
+
+        SampleModel sm =
+            cm.createCompatibleSampleModel(src.getWidth(),
+                                           src.getHeight());
+
+        init(src, src.getBounds(), cm, sm,
+             src.getTileGridXOffset(), src.getTileGridYOffset(), null);
+    }
+
+
+    public WritableRaster copyData(WritableRaster wr){
+        //System.out.println("Getting data for : " + wr.getWidth() + "/" + wr.getHeight() + "/" + wr.getMinX() + "/" + wr.getMinY());
+
+        //
+        // First, get source data
+        //
+        CachableRed src = (CachableRed)getSources().get(0);
+        // System.out.println("Hello");
+        // System.out.println("src class : " + src.getClass().getName());
+        // System.out.println("this : " + this);
+        wr = src.copyData(wr);
+        // System.out.println("Hi");
+        //System.out.println("Source was : " + wr.getWidth() + "/" + wr.getHeight()+ "/" + wr.getMinX() + "/" + wr.getMinY());
+
+        // Unpremultiply data if required
+        ColorModel cm = src.getColorModel();
+        GraphicsUtil.coerceData(wr, cm, false);
+
+        //
+        // Now, process pixel values
+        //
+        final int minX = wr.getMinX();
+        final int minY = wr.getMinY();
+        final int w = wr.getWidth();
+        final int h = wr.getHeight();
+        DataBufferInt dbf = (DataBufferInt)wr.getDataBuffer();
+        final int[] pixels = dbf.getBankData()[0];
+
+        SinglePixelPackedSampleModel sppsm;
+        sppsm = (SinglePixelPackedSampleModel)wr.getSampleModel();
+
+        final int offset =
+            (dbf.getOffset() +
+             sppsm.getOffset(minX-wr.getSampleModelTranslateX(),
+                             minY-wr.getSampleModelTranslateY()));
+
+        // final int offset = dbf.getOffset();
+
+        final int scanStride =
+            ((SinglePixelPackedSampleModel)wr.getSampleModel())
+            .getScanlineStride();
+        final int adjust = scanStride - w;
+        int p = offset;
+        int i=0, j=0;
+
+        final float a00=matrix[0][0]/255f, a01=matrix[0][1]/255f, a02=matrix[0][2]/255f, a03=matrix[0][3]/255f, a04=matrix[0][4]/255f;
+        final float a10=matrix[1][0]/255f, a11=matrix[1][1]/255f, a12=matrix[1][2]/255f, a13=matrix[1][3]/255f, a14=matrix[1][4]/255f;
+        final float a20=matrix[2][0]/255f, a21=matrix[2][1]/255f, a22=matrix[2][2]/255f, a23=matrix[2][3]/255f, a24=matrix[2][4]/255f;
+        final float a30=matrix[3][0]/255f, a31=matrix[3][1]/255f, a32=matrix[3][2]/255f, a33=matrix[3][3]/255f, a34=matrix[3][4]/255f;
+
+        for(i=0; i<h; i++){
+            for(j=0; j<w; j++){
+                int pel = pixels[p];
+
+                int a = pel >>> 24;
+                int r = (pel >> 16) & 0xff;
+                int g = (pel >> 8 ) & 0xff;
+                int b =  pel        & 0xff;
+
+                int dr = (int)((a00*r + a01*g + a02*b + a03*a + a04)*255.0f);
+                int dg = (int)((a10*r + a11*g + a12*b + a13*a + a14)*255.0f);
+                int db = (int)((a20*r + a21*g + a22*b + a23*a + a24)*255.0f);
+                int da = (int)((a30*r + a31*g + a32*b + a33*a + a34)*255.0f);
+
+                /*dr = dr > 255 ? 255 : dr < 0 ? 0 : dr;
+                dg = dg > 255 ? 255 : dg < 0 ? 0 : dg;
+                db = db > 255 ? 255 : db < 0 ? 0 : db;
+                da = da > 255 ? 255 : da < 0 ? 0 : da;*/
+
+
+                // If any high bits are set we are not in range.
+                // If the highest bit is set then we are negative so
+                // clamp to zero else we are > 255 so clamp to 255.
+                if ((dr & 0xFFFFFF00) != 0)
+                    dr = ((dr & 0x80000000) != 0)?0:255;
+                if ((dg & 0xFFFFFF00) != 0)
+                    dg = ((dg & 0x80000000) != 0)?0:255;
+                if ((db & 0xFFFFFF00) != 0)
+                    db = ((db & 0x80000000) != 0)?0:255;
+                if ((da & 0xFFFFFF00) != 0)
+                    da = ((da & 0x80000000) != 0)?0:255;
+
+                pixels[p++] = (da << 24
+                               |
+                               dr << 16
+                               |
+                               dg << 8
+                               |
+                               db);
+
+            }
+            p += adjust;
+        }
+
+        //System.out.println("Result is : " + wr.getWidth() + "/" + wr.getHeight()+ "/" + wr.getMinX() + "/" + wr.getMinY());
+        return wr;
+    }
+
+}

Propchange: incubator/flex/sdk/branches/develop/modules/thirdparty/batik/sources/org/apache/flex/forks/batik/ext/awt/image/rendered/ColorMatrixRed.java
------------------------------------------------------------------------------
    svn:eol-style = native

Added: incubator/flex/sdk/branches/develop/modules/thirdparty/batik/sources/org/apache/flex/forks/batik/ext/awt/image/rendered/ComponentTransferRed.java
URL: http://svn.apache.org/viewvc/incubator/flex/sdk/branches/develop/modules/thirdparty/batik/sources/org/apache/flex/forks/batik/ext/awt/image/rendered/ComponentTransferRed.java?rev=1402274&view=auto
==============================================================================
--- incubator/flex/sdk/branches/develop/modules/thirdparty/batik/sources/org/apache/flex/forks/batik/ext/awt/image/rendered/ComponentTransferRed.java (added)
+++ incubator/flex/sdk/branches/develop/modules/thirdparty/batik/sources/org/apache/flex/forks/batik/ext/awt/image/rendered/ComponentTransferRed.java Thu Oct 25 19:01:43 2012
@@ -0,0 +1,81 @@
+/*
+
+   Licensed to the Apache Software Foundation (ASF) under one or more
+   contributor license agreements.  See the NOTICE file distributed with
+   this work for additional information regarding copyright ownership.
+   The ASF licenses this file to You under the Apache License, Version 2.0
+   (the "License"); you may not use this file except in compliance with
+   the License.  You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+
+ */
+package org.apache.flex.forks.batik.ext.awt.image.rendered;
+
+import java.awt.RenderingHints;
+import java.awt.image.ByteLookupTable;
+import java.awt.image.LookupOp;
+import java.awt.image.WritableRaster;
+
+import org.apache.flex.forks.batik.ext.awt.image.GraphicsUtil;
+import org.apache.flex.forks.batik.ext.awt.image.TransferFunction;
+
+/**
+ *
+ * @author <a href="mailto:thomas.deweese@kodak.com">Thomas DeWeese</a>
+ * @version $Id: ComponentTransferRed.java 479564 2006-11-27 09:56:57Z dvholten $
+ */
+public class ComponentTransferRed extends AbstractRed {
+    LookupOp operation;
+
+    /**
+     * The constructor will instantiate a LookupOp instance using
+     * a LookupOp, which is built using the four LUT
+     * data obtained by the TransferFunction objects
+     * funcs[0] : Alpha component transfer function
+     * funcs[1] : Red component transfer function
+     * funcs[2] : Green component transfer function
+     * funcs[3] : Blue component transfer function
+     */
+    public ComponentTransferRed(CachableRed src,
+                                TransferFunction [] funcs,
+                                RenderingHints hints) {
+        super(src, src.getBounds(),
+              GraphicsUtil.coerceColorModel(src.getColorModel(), false),
+              src.getSampleModel(),
+              null);
+
+        byte [][] tableData = {funcs[1].getLookupTable(),
+                               funcs[2].getLookupTable(),
+                               funcs[3].getLookupTable(),
+                               funcs[0].getLookupTable()};
+
+        // Note that we create an anonymous subclass here.
+        // For what ever reason this makes the Op work correctly.
+        // If you remove this, it seems to get the color channels messed
+        // up.  The downside is that I suspect that this means we are
+        // falling into a more general, and hence slower case, but
+        // at least it works....
+        operation  =  new LookupOp(new ByteLookupTable(0, tableData), hints)
+            { };
+    }
+
+    public WritableRaster copyData(WritableRaster wr){
+        CachableRed src = (CachableRed)getSources().get(0);
+
+        wr = src.copyData(wr);
+        GraphicsUtil.coerceData(wr, src.getColorModel(), false);
+
+        WritableRaster srcWR = wr.createWritableTranslatedChild(0,0);
+
+        operation.filter(srcWR, srcWR);
+
+        return wr;
+    }
+}

Propchange: incubator/flex/sdk/branches/develop/modules/thirdparty/batik/sources/org/apache/flex/forks/batik/ext/awt/image/rendered/ComponentTransferRed.java
------------------------------------------------------------------------------
    svn:eol-style = native

Added: incubator/flex/sdk/branches/develop/modules/thirdparty/batik/sources/org/apache/flex/forks/batik/ext/awt/image/rendered/CompositeRed.java
URL: http://svn.apache.org/viewvc/incubator/flex/sdk/branches/develop/modules/thirdparty/batik/sources/org/apache/flex/forks/batik/ext/awt/image/rendered/CompositeRed.java?rev=1402274&view=auto
==============================================================================
--- incubator/flex/sdk/branches/develop/modules/thirdparty/batik/sources/org/apache/flex/forks/batik/ext/awt/image/rendered/CompositeRed.java (added)
+++ incubator/flex/sdk/branches/develop/modules/thirdparty/batik/sources/org/apache/flex/forks/batik/ext/awt/image/rendered/CompositeRed.java Thu Oct 25 19:01:43 2012
@@ -0,0 +1,310 @@
+/*
+
+   Licensed to the Apache Software Foundation (ASF) under one or more
+   contributor license agreements.  See the NOTICE file distributed with
+   this work for additional information regarding copyright ownership.
+   The ASF licenses this file to You under the Apache License, Version 2.0
+   (the "License"); you may not use this file except in compliance with
+   the License.  You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+
+ */
+package org.apache.flex.forks.batik.ext.awt.image.rendered;
+
+import java.awt.CompositeContext;
+import java.awt.Graphics2D;
+import java.awt.Point;
+import java.awt.Rectangle;
+import java.awt.color.ColorSpace;
+import java.awt.image.BufferedImage;
+import java.awt.image.ColorModel;
+import java.awt.image.DataBuffer;
+import java.awt.image.DirectColorModel;
+import java.awt.image.Raster;
+import java.awt.image.SampleModel;
+import java.awt.image.WritableRaster;
+import java.util.Iterator;
+import java.util.List;
+import java.util.ArrayList;
+
+import org.apache.flex.forks.batik.ext.awt.image.CompositeRule;
+import org.apache.flex.forks.batik.ext.awt.image.GraphicsUtil;
+import org.apache.flex.forks.batik.ext.awt.image.PadMode;
+import org.apache.flex.forks.batik.ext.awt.image.SVGComposite;
+
+/**
+ * This is an implementation of an affine operation as a RenderedImage.
+ * Right now the implementation makes use of the AffineBufferedImageOp
+ * to do the work.  Eventually this may move to be more tiled in nature.
+ *
+ * @author <a href="mailto:Thomas.DeWeeese@Kodak.com">Thomas DeWeese</a>
+ * @version $Id: CompositeRed.java 489226 2006-12-21 00:05:36Z cam $
+ */
+public class CompositeRed extends AbstractRed {
+
+    CompositeRule rule;
+    CompositeContext [] contexts;
+
+    public CompositeRed(List srcs, CompositeRule rule) {
+        super(); // We _must_ call init...
+
+        CachableRed src = (CachableRed)srcs.get(0);
+
+        ColorModel  cm = fixColorModel (src);
+
+        this.rule = rule;
+
+        SVGComposite comp = new SVGComposite(rule);
+        contexts = new CompositeContext[srcs.size()];
+
+        int idx = 0;
+        Iterator i = srcs.iterator();
+        Rectangle myBounds = null;
+        while (i.hasNext()) {
+            CachableRed cr = (CachableRed)i.next();
+
+            contexts[idx++] = comp.createContext(cr.getColorModel(), cm, null);
+
+            Rectangle newBound = cr.getBounds();
+            if (myBounds == null) {
+                myBounds = newBound;
+                continue;
+            }
+
+            switch (rule.getRule()) {
+            case CompositeRule.RULE_IN:
+                if (myBounds.intersects(newBound))
+                    myBounds = myBounds.intersection(newBound);
+                else {
+                    myBounds.width = 0;
+                    myBounds.height = 0;
+                }
+                break;
+            case CompositeRule.RULE_OUT:
+                // Last node determines bounds...
+                myBounds = newBound;
+                break;
+            default:
+                // myBounds= myBounds.union(newBound);
+                myBounds.add( newBound );
+            }
+        }
+
+        if (myBounds == null)
+            throw new IllegalArgumentException
+                ("Composite Operation Must have some source!");
+
+        if (rule.getRule() == CompositeRule.RULE_ARITHMETIC) {
+            List vec = new ArrayList( srcs.size() );
+            i = srcs.iterator();
+            while (i.hasNext()) {
+                CachableRed cr = (CachableRed)i.next();
+                Rectangle r = cr.getBounds();
+                // For arithmetic make sure they are all the same size...
+                if ((r.x      != myBounds.x) ||
+                    (r.y      != myBounds.y) ||
+                    (r.width  != myBounds.width) ||
+                    (r.height != myBounds.height))
+                    cr = new PadRed(cr, myBounds, PadMode.ZERO_PAD, null);
+                vec.add(cr);
+            }
+            srcs = vec;
+        }
+
+        // fix my sample model so it makes sense given my size.
+        SampleModel sm = fixSampleModel(src, cm, myBounds);
+
+        // System.out.println("Comp: " + myBounds);
+        // System.out.println("  SM: " + sm.getWidth()+"x"+sm.getHeight());
+
+        int defSz = AbstractTiledRed.getDefaultTileSize();
+
+        // Make tile(0,0) fall on the closest intersection of defaultSz.
+        int tgX = defSz*(int)Math.floor(myBounds.x/defSz);
+        int tgY = defSz*(int)Math.floor(myBounds.y/defSz);
+
+        // Finish initializing our base class...
+        init(srcs, myBounds, cm, sm, tgX, tgY, null);
+    }
+
+    public WritableRaster copyData(WritableRaster wr) {
+        // copyToRaster(wr);
+        genRect(wr);
+        return wr;
+    }
+
+    public Raster getTile(int x, int y) {
+        int tx = tileGridXOff+x*tileWidth;
+        int ty = tileGridYOff+y*tileHeight;
+        Point pt = new Point(tx, ty);
+        WritableRaster wr = Raster.createWritableRaster(sm, pt);
+        genRect(wr);
+
+        return wr;
+    }
+
+    public void emptyRect(WritableRaster wr) {
+        PadRed.ZeroRecter zr = PadRed.ZeroRecter.getZeroRecter(wr);
+        zr.zeroRect(new Rectangle(wr.getMinX(), wr.getMinY(),
+                                  wr.getWidth(), wr.getHeight()));
+    }
+
+    public void genRect(WritableRaster wr) {
+        // long startTime = System.currentTimeMillis();
+        // System.out.println("Comp GenR: " + wr);
+        Rectangle r = wr.getBounds();
+
+        int idx = 0;
+        Iterator i = srcs.iterator();
+        boolean first = true;
+        while (i.hasNext()) {
+            CachableRed cr = (CachableRed)i.next();
+            if (first) {
+                Rectangle crR = cr.getBounds();
+                if ((r.x < crR.x)                   ||
+                    (r.y < crR.y)                   ||
+                    (r.x+r.width > crR.x+crR.width) ||
+                    (r.y+r.height > crR.y+crR.height))
+                    // Portions outside my bounds, zero them...
+                    emptyRect(wr);
+
+                // Fill in initial image...
+                cr.copyData(wr);
+
+                if ( ! cr.getColorModel().isAlphaPremultiplied() )
+                    GraphicsUtil.coerceData(wr, cr.getColorModel(), true);
+                first = false;
+            } else {
+                Rectangle crR = cr.getBounds();
+                if (crR.intersects(r)) {
+                    Rectangle smR = crR.intersection(r);
+                    Raster ras = cr.getData(smR);
+                    WritableRaster smWR = wr.createWritableChild
+                        (smR.x, smR.y, smR.width, smR.height,
+                         smR.x, smR.y, null);
+
+                    contexts[idx].compose(ras, smWR, smWR);
+                }
+            }
+
+            idx++;
+        }
+        // long endTime = System.currentTimeMillis();
+        // System.out.println("Other: " + (endTime-startTime));
+    }
+
+    // This is an alternate Implementation that uses drawImage.
+    // In testing this was not significantly faster and it had some
+    // problems with alpha premultiplied.
+    public void genRect_OVER(WritableRaster wr) {
+        // long startTime = System.currentTimeMillis();
+        // System.out.println("Comp GenR: " + wr);
+        Rectangle r = wr.getBounds();
+
+        ColorModel cm = getColorModel();
+
+        BufferedImage bi = new BufferedImage
+            (cm, wr.createWritableTranslatedChild(0,0),
+             cm.isAlphaPremultiplied(), null);
+
+        Graphics2D g2d = GraphicsUtil.createGraphics(bi);
+        g2d.translate(-r.x, -r.y);
+
+        Iterator i = srcs.iterator();
+        boolean first = true;
+        while (i.hasNext()) {
+            CachableRed cr = (CachableRed)i.next();
+            if (first) {
+                Rectangle crR = cr.getBounds();
+                if ((r.x < crR.x)                   ||
+                    (r.y < crR.y)                   ||
+                    (r.x+r.width > crR.x+crR.width) ||
+                    (r.y+r.height > crR.y+crR.height))
+                    // Portions outside my bounds, zero them...
+                    emptyRect(wr);
+
+                // Fill in initial image...
+                cr.copyData(wr);
+
+                GraphicsUtil.coerceData(wr, cr.getColorModel(),
+                                        cm.isAlphaPremultiplied());
+                first = false;
+            } else {
+                GraphicsUtil.drawImage(g2d, cr);
+            }
+        }
+        // long endTime = System.currentTimeMillis();
+        // System.out.println("OVER: " + (endTime-startTime));
+    }
+
+        /**
+         * This function 'fixes' the source's sample model.
+         * right now it just ensures that the sample model isn't
+         * much larger than my width.
+         */
+    protected static SampleModel fixSampleModel(CachableRed src,
+                                                ColorModel  cm,
+                                                Rectangle   bounds) {
+        int defSz = AbstractTiledRed.getDefaultTileSize();
+
+        // Make tile(0,0) fall on the closest intersection of defaultSz.
+        int tgX = defSz*(int)Math.floor(bounds.x/defSz);
+        int tgY = defSz*(int)Math.floor(bounds.y/defSz);
+
+        int tw  = (bounds.x+bounds.width)-tgX;
+        int th  = (bounds.y+bounds.height)-tgY;
+
+        SampleModel sm = src.getSampleModel();
+
+        int  w  = sm.getWidth();
+        if (w < defSz) w = defSz;
+        if (w > tw)    w = tw;
+
+        int h   = sm.getHeight();
+        if (h < defSz) h = defSz;
+        if (h > th)    h = th;
+
+        if ((w <= 0) || (h <= 0)) {
+            w = 1;
+            h = 1;
+        }
+
+        // System.out.println("tg: " + tgX + "x" + tgY);
+        // System.out.println("t: " + tw + "x" + th);
+        // System.out.println("sz: " + w + "x" + h);
+
+        return cm.createCompatibleSampleModel(w, h);
+    }
+
+    protected static ColorModel fixColorModel(CachableRed src) {
+        ColorModel  cm = src.getColorModel();
+
+        if (cm.hasAlpha()) {
+            if (!cm.isAlphaPremultiplied())
+                cm = GraphicsUtil.coerceColorModel(cm, true);
+            return cm;
+        }
+
+        int b = src.getSampleModel().getNumBands()+1;
+        if (b > 4)
+            throw new IllegalArgumentException
+                ("CompositeRed can only handle up to three band images");
+
+        int [] masks = new int[4];
+        for (int i=0; i < b-1; i++)
+            masks[i] = 0xFF0000 >> (8*i);
+        masks[3] = 0xFF << (8*(b-1));
+        ColorSpace cs = cm.getColorSpace();
+
+        return new DirectColorModel(cs, 8*b, masks[0], masks[1],
+                                    masks[2], masks[3],
+                                    true, DataBuffer.TYPE_INT);
+    }
+}

Propchange: incubator/flex/sdk/branches/develop/modules/thirdparty/batik/sources/org/apache/flex/forks/batik/ext/awt/image/rendered/CompositeRed.java
------------------------------------------------------------------------------
    svn:eol-style = native

Added: incubator/flex/sdk/branches/develop/modules/thirdparty/batik/sources/org/apache/flex/forks/batik/ext/awt/image/rendered/DiffuseLightingRed.java
URL: http://svn.apache.org/viewvc/incubator/flex/sdk/branches/develop/modules/thirdparty/batik/sources/org/apache/flex/forks/batik/ext/awt/image/rendered/DiffuseLightingRed.java?rev=1402274&view=auto
==============================================================================
--- incubator/flex/sdk/branches/develop/modules/thirdparty/batik/sources/org/apache/flex/forks/batik/ext/awt/image/rendered/DiffuseLightingRed.java (added)
+++ incubator/flex/sdk/branches/develop/modules/thirdparty/batik/sources/org/apache/flex/forks/batik/ext/awt/image/rendered/DiffuseLightingRed.java Thu Oct 25 19:01:43 2012
@@ -0,0 +1,213 @@
+/*
+
+   Licensed to the Apache Software Foundation (ASF) under one or more
+   contributor license agreements.  See the NOTICE file distributed with
+   this work for additional information regarding copyright ownership.
+   The ASF licenses this file to You under the Apache License, Version 2.0
+   (the "License"); you may not use this file except in compliance with
+   the License.  You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+
+ */
+package org.apache.flex.forks.batik.ext.awt.image.rendered;
+
+import java.awt.Rectangle;
+import java.awt.image.ColorModel;
+import java.awt.image.DataBufferInt;
+import java.awt.image.SampleModel;
+import java.awt.image.SinglePixelPackedSampleModel;
+import java.awt.image.WritableRaster;
+
+import org.apache.flex.forks.batik.ext.awt.image.GraphicsUtil;
+import org.apache.flex.forks.batik.ext.awt.image.Light;
+
+/**
+ * 
+ * @author <a href="mailto:vincent.hardy@eng.sun.com">Vincent Hardy</a>
+ * @version $Id: DiffuseLightingRed.java 475477 2006-11-15 22:44:28Z cam $
+ */
+public class DiffuseLightingRed extends AbstractRed{
+    /**
+     * Diffuse lighting constant
+     */
+    private double kd;
+
+    /**
+     * Light used for diffuse lighting
+     */
+    private Light light;
+
+    /**
+     * BumpMap source
+     */
+    private BumpMap bumpMap;
+
+    /**
+     * Device space to user space scale factors, along
+     * each axis
+     */
+    private double scaleX, scaleY;
+
+    /**
+     * LitRegion
+     */
+    private Rectangle litRegion;
+
+    /**
+     * true if calculations should be performed in linear sRGB
+     */
+    private boolean linear;
+
+
+    public DiffuseLightingRed(double kd,
+                              Light light,
+                              BumpMap bumpMap,
+                              Rectangle litRegion,
+                              double scaleX, double scaleY,
+                              boolean linear){
+        this.kd = kd;
+        this.light = light;
+        this.bumpMap = bumpMap;
+        this.litRegion = litRegion;
+        this.scaleX = scaleX;
+        this.scaleY = scaleY;
+        this.linear = linear;
+
+        ColorModel cm;
+        if (linear)
+            cm = GraphicsUtil.Linear_sRGB_Pre;
+        else
+            cm = GraphicsUtil.sRGB_Pre;
+
+        SampleModel sm = 
+            cm.createCompatibleSampleModel(litRegion.width,
+                                           litRegion.height);
+                                             
+        init((CachableRed)null, litRegion, cm, sm,
+             litRegion.x, litRegion.y, null);
+    }
+
+    public WritableRaster copyData(WritableRaster wr){
+        final double[] lightColor = light.getColor(linear);
+        
+        final int w = wr.getWidth();
+        final int h = wr.getHeight();
+        final int minX = wr.getMinX();
+        final int minY = wr.getMinY();
+
+        final DataBufferInt db = (DataBufferInt)wr.getDataBuffer();
+        final int[] pixels = db.getBankData()[0];
+
+        final SinglePixelPackedSampleModel sppsm;
+        sppsm = (SinglePixelPackedSampleModel)wr.getSampleModel();
+        
+        final int offset = 
+            (db.getOffset() +
+             sppsm.getOffset(minX-wr.getSampleModelTranslateX(), 
+                             minY-wr.getSampleModelTranslateY()));
+
+        final int scanStride = sppsm.getScanlineStride();
+        final int adjust = scanStride - w;
+        int p = offset;
+        int r=0, g=0, b=0;
+        int i=0, j=0;
+
+        // System.out.println("Getting diffuse red : " + minX + "/" + minY + "/" + w + "/" + h);
+        double x = scaleX*minX;
+        double y = scaleY*minY;
+        double NL = 0;
+
+        // final double[] L = new double[3];
+        final double[][][] NA = bumpMap.getNormalArray(minX, minY, w, h);
+        if(!light.isConstant()){
+            final double[][] LA = new double[w][3];
+
+            for(i=0; i<h; i++){
+                final double [][] NR = NA[i];
+                light.getLightRow(x, y+i*scaleY, scaleX, w, NR, LA);
+                for(j=0; j<w; j++){
+                    // Get Normal 
+                    final double [] N = NR[j];
+                    
+                    // Get Light Vector
+                    final double [] L = LA[j];
+                    
+                    NL = 255.*kd*(N[0]*L[0] + N[1]*L[1] + N[2]*L[2]);
+                    
+                    r = (int)(NL*lightColor[0]);
+                    g = (int)(NL*lightColor[1]);
+                    b = (int)(NL*lightColor[2]);
+                    
+                    // If any high bits are set we are not in range.
+                    // If the highest bit is set then we are negative so
+                    // clamp to zero else we are > 255 so clamp to 255.
+                    if ((r & 0xFFFFFF00) != 0)
+                        r = ((r & 0x80000000) != 0)?0:255;
+                    if ((g & 0xFFFFFF00) != 0)
+                        g = ((g & 0x80000000) != 0)?0:255;
+                    if ((b & 0xFFFFFF00) != 0)
+                        b = ((b & 0x80000000) != 0)?0:255;
+                    
+                    pixels[p++] = (0xff000000
+                                   |
+                                   r << 16
+                                   |
+                                   g << 8
+                                   |
+                                   b);
+                    
+                }
+                p += adjust;
+            }
+        }
+        else{
+            // System.out.println(">>>>>>>> Processing constant light ...");
+            // Constant light
+            final double[] L = new double[3];
+            light.getLight(0, 0, 0, L);
+
+            for(i=0; i<h; i++){
+                final double [][] NR = NA[i];
+                for(j=0; j<w; j++){
+                    // Get Normal 
+                    final double[] N = NR[j];
+                    
+                    NL = 255.*kd*(N[0]*L[0] + N[1]*L[1] + N[2]*L[2]);
+                    
+                    r = (int)(NL*lightColor[0]);
+                    g = (int)(NL*lightColor[1]);
+                    b = (int)(NL*lightColor[2]);
+                    
+                    // If any high bits are set we are not in range.
+                    // If the highest bit is set then we are negative so
+                    // clamp to zero else we are > 255 so clamp to 255.
+                    if ((r & 0xFFFFFF00) != 0)
+                        r = ((r & 0x80000000) != 0)?0:255;
+                    if ((g & 0xFFFFFF00) != 0)
+                        g = ((g & 0x80000000) != 0)?0:255;
+                    if ((b & 0xFFFFFF00) != 0)
+                        b = ((b & 0x80000000) != 0)?0:255;
+                    
+                    pixels[p++] = (0xff000000
+                                   |
+                                   r << 16
+                                   |
+                                   g << 8
+                                   |
+                                   b);
+                }
+                p += adjust;
+            }
+        }
+        
+        return wr;
+    }
+
+}

Propchange: incubator/flex/sdk/branches/develop/modules/thirdparty/batik/sources/org/apache/flex/forks/batik/ext/awt/image/rendered/DiffuseLightingRed.java
------------------------------------------------------------------------------
    svn:eol-style = native

Added: incubator/flex/sdk/branches/develop/modules/thirdparty/batik/sources/org/apache/flex/forks/batik/ext/awt/image/rendered/DisplacementMapRed.java
URL: http://svn.apache.org/viewvc/incubator/flex/sdk/branches/develop/modules/thirdparty/batik/sources/org/apache/flex/forks/batik/ext/awt/image/rendered/DisplacementMapRed.java?rev=1402274&view=auto
==============================================================================
--- incubator/flex/sdk/branches/develop/modules/thirdparty/batik/sources/org/apache/flex/forks/batik/ext/awt/image/rendered/DisplacementMapRed.java (added)
+++ incubator/flex/sdk/branches/develop/modules/thirdparty/batik/sources/org/apache/flex/forks/batik/ext/awt/image/rendered/DisplacementMapRed.java Thu Oct 25 19:01:43 2012
@@ -0,0 +1,755 @@
+/*
+
+   Licensed to the Apache Software Foundation (ASF) under one or more
+   contributor license agreements.  See the NOTICE file distributed with
+   this work for additional information regarding copyright ownership.
+   The ASF licenses this file to You under the Apache License, Version 2.0
+   (the "License"); you may not use this file except in compliance with
+   the License.  You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+
+ */
+package org.apache.flex.forks.batik.ext.awt.image.rendered;
+
+import java.awt.Rectangle;
+import java.awt.RenderingHints;
+import java.awt.image.ColorModel;
+import java.awt.image.DataBufferInt;
+import java.awt.image.Raster;
+import java.awt.image.SinglePixelPackedSampleModel;
+import java.awt.image.WritableRaster;
+
+import org.apache.flex.forks.batik.ext.awt.image.ARGBChannel;
+import org.apache.flex.forks.batik.ext.awt.image.GraphicsUtil;
+import org.apache.flex.forks.batik.ext.awt.image.PadMode;
+
+
+/**
+ * This implementation of RenderableImage will render its input
+ * GraphicsNode on demand for tiles.
+ *
+ * @author <a href="mailto:vincent.hardy@eng.sun.com">Vincent Hardy</a>
+ * @version $Id: DisplacementMapRed.java 478276 2006-11-22 18:33:37Z dvholten $
+ */
+public class DisplacementMapRed extends AbstractRed {
+    // Use these to control timing and Nearest Neighbot vs. Bilinear Interp.
+    private static final boolean TIME   = false;
+    private static final boolean USE_NN = false;
+
+    /**
+     * The displacement scale factor along the x axis
+     */
+    private float scaleX;
+
+    /**
+     * The displacement scale factor along the y axis
+     */
+    private float scaleY;
+
+    /**
+     * The channel type of the operation on X axis
+     */
+    private ARGBChannel xChannel;
+
+    /**
+     * The channel type of the operation on Y axis
+     */
+    private ARGBChannel yChannel;
+
+    /**
+     * The image to distort.
+     */
+    CachableRed image;
+
+    /**
+     * The offset image (displacement map).
+     */
+    CachableRed offsets;
+
+    /**
+     * The maximum possible offsets in x and y
+     */
+    int maxOffX, maxOffY;
+
+    /**
+     * The set of rendering hints
+     */
+    RenderingHints hints;
+
+    /**
+     * Computed tile Offsets Soft referencces to TileOffsets instances...
+     */
+    TileOffsets [] xOffsets;
+    TileOffsets [] yOffsets;
+
+    static class TileOffsets {
+        int [] tile;
+        int [] off;
+        TileOffsets(int len, int base, int stride,
+                    int loc, int endLoc, int slop, int tile, int endTile) {
+            this.tile = new int[len+1];
+            this.off  = new int[len+1];
+
+            if (tile == endTile) endLoc -= slop;
+
+            for (int i=0; i<len; i++) {
+                this.tile[i] = tile;
+                this.off [i] = base+(loc*stride);
+                loc++;
+                if (loc == endLoc) {
+                    loc = 0;
+                    tile++;
+                    if (tile == endTile) endLoc -=slop;
+                }
+            }
+            this.tile[len] = this.tile[len-1];
+            this.off [len] = this.off [len-1];
+        }
+    }
+
+    /**
+     * @param image the image to distort
+     * @param offsets the displacement map
+     * @param xChannel defines the channel of off whose values will be
+     *                 on X-axis operation
+     * @param yChannel defines the channel of off whose values will be
+     * @param scaleX defines the scale factor of the filter operation
+     *               on the X axis.
+     * @param scaleY defines the scale factor of the filter operation
+     *               on the Y axis
+     * @param rh the rendering hints
+     */
+    public DisplacementMapRed(CachableRed image,
+                              CachableRed offsets,
+                              ARGBChannel xChannel,
+                              ARGBChannel yChannel,
+                              float scaleX, float scaleY,
+                              RenderingHints rh) {
+
+        if(xChannel == null){
+            throw new IllegalArgumentException("Must provide xChannel");
+        }
+
+        if(yChannel == null){
+            throw new IllegalArgumentException("Must provide yChannel");
+        }
+
+        this.offsets = offsets;
+        this.scaleX = scaleX;
+        this.scaleY = scaleY;
+        this.xChannel = xChannel;
+        this.yChannel = yChannel;
+        this.hints   = rh;
+
+        maxOffX = (int)Math.ceil(scaleX/2);
+        maxOffY = (int)Math.ceil(scaleY/2);
+
+        Rectangle rect = image.getBounds();
+
+        Rectangle r    = image.getBounds();
+        r.x -= maxOffX; r.width  += 2*maxOffX;
+        r.y -= maxOffY; r.height += 2*maxOffY;
+        image = new PadRed(image, r, PadMode.ZERO_PAD, null);
+        image = new TileCacheRed(image);
+        this.image = image;
+        ColorModel cm = image.getColorModel();
+        if (!USE_NN)
+            // For Bilinear we need alpha premult.
+            cm = GraphicsUtil.coerceColorModel(cm, true);
+
+        init(image, rect, cm, image.getSampleModel(),
+             rect.x, rect.y, null);
+
+        xOffsets = new TileOffsets[getNumXTiles()];
+        yOffsets = new TileOffsets[getNumYTiles()];
+    }
+
+    public WritableRaster copyData(WritableRaster wr) {
+        copyToRaster(wr);
+        return wr;
+    }
+
+    public Raster getTile(int tileX, int tileY) {
+        WritableRaster dest = makeTile(tileX, tileY);
+        Rectangle srcR   = dest.getBounds();
+
+        // Get Raster from offsetes
+        Raster     mapRas = offsets.getData(srcR);
+        ColorModel mapCM  = offsets.getColorModel();
+        // ensure map isn't pre-multiplied.
+        GraphicsUtil.coerceData((WritableRaster)mapRas, mapCM, false);
+
+        TileOffsets xinfo = getXOffsets(tileX);
+        TileOffsets yinfo = getYOffsets(tileY);
+
+        if (USE_NN)
+            filterNN(mapRas, dest,
+                     xinfo.tile, xinfo.off,
+                     yinfo.tile, yinfo.off);
+        else if (image.getColorModel().isAlphaPremultiplied())
+            filterBL(mapRas, dest,
+                     xinfo.tile, xinfo.off,
+                     yinfo.tile, yinfo.off);
+        else
+            filterBLPre(mapRas, dest,
+                        xinfo.tile, xinfo.off,
+                        yinfo.tile, yinfo.off);
+
+        return dest;
+    }
+
+    public TileOffsets getXOffsets(int xTile) {
+        TileOffsets ret = xOffsets[xTile-getMinTileX()];
+        if (ret != null)
+            return ret;
+
+        SinglePixelPackedSampleModel sppsm;
+        sppsm = (SinglePixelPackedSampleModel)getSampleModel();
+        int base  = sppsm.getOffset(0, 0);
+        int tw    = sppsm.getWidth();
+
+        // The span we need to cover in the input image.
+        int width = tw+2*maxOffX;
+
+        // The start and end X in image's tile coordinate system...
+        int x0      = getTileGridXOffset() + xTile * tw - maxOffX
+                          - image.getTileGridXOffset();
+        int x1      = x0 + width-1;
+
+        int tile    = (int)Math.floor(x0/(double)tw);
+        int endTile = (int)Math.floor(x1/(double)tw);
+        int loc     = x0-(tile*tw);
+        int endLoc  = tw;
+
+        // Amount not used from right edge tile
+        int slop = ((endTile+1)*tw-1) - x1;
+
+        ret = new TileOffsets(width, base, 1,
+                              loc, endLoc, slop, tile, endTile);
+
+        xOffsets[xTile-getMinTileX()] = ret;
+        return ret;
+    }
+
+    public TileOffsets getYOffsets(int yTile) {
+        TileOffsets ret = yOffsets[yTile-getMinTileY()];
+        if (ret != null)
+            return ret;
+
+        SinglePixelPackedSampleModel sppsm;
+        sppsm = (SinglePixelPackedSampleModel)getSampleModel();
+        int stride  = sppsm.getScanlineStride();
+        int th      = sppsm.getHeight();
+
+        // The span we need to cover in the input image.
+        int height  = th+2*maxOffY;
+
+        // The start and end Y in image's tile coordinate system...
+        int y0      = getTileGridYOffset() + yTile * th - maxOffY
+                          - image.getTileGridYOffset();
+        int y1      = y0 + height - 1;
+
+        int tile    = (int)Math.floor(y0/(double)th);
+        int endTile = (int)Math.floor(y1/(double)th);
+        int loc     = y0-(tile*th);
+        int endLoc  = th;
+
+        // Amount not used from bottom edge tile
+        int slop = ((endTile+1)*th-1) - y1;
+
+        ret = new TileOffsets(height, 0, stride,
+                              loc, endLoc, slop, tile, endTile);
+
+        yOffsets[yTile-getMinTileY()] = ret;
+        return ret;
+    }
+
+    public void filterBL(Raster off, WritableRaster dst,
+                         int [] xTile, int [] xOff,
+                         int [] yTile, int [] yOff) {
+        final int w      = dst.getWidth();
+        final int h      = dst.getHeight();
+        final int xStart = maxOffX;
+        final int yStart = maxOffY;
+        final int xEnd   = xStart+w;
+        final int yEnd   = yStart+h;
+
+        // Access the integer buffer for each image.
+        DataBufferInt dstDB = (DataBufferInt)dst.getDataBuffer();
+        DataBufferInt offDB = (DataBufferInt)off.getDataBuffer();
+
+        // Offset defines where in the stack the real data begin
+        SinglePixelPackedSampleModel dstSPPSM, offSPPSM;
+
+        dstSPPSM = (SinglePixelPackedSampleModel)dst.getSampleModel();
+        final int dstOff = dstDB.getOffset() +
+            dstSPPSM.getOffset(dst.getMinX() - dst.getSampleModelTranslateX(),
+                               dst.getMinY() - dst.getSampleModelTranslateY());
+
+        offSPPSM = (SinglePixelPackedSampleModel)off.getSampleModel();
+        final int offOff = offDB.getOffset() +
+            offSPPSM.getOffset(dst.getMinX() - off.getSampleModelTranslateX(),
+                               dst.getMinY() - off.getSampleModelTranslateY());
+
+        // Stride is the distance between two consecutive column elements,
+        // in the one-dimention dataBuffer
+        final int dstScanStride = dstSPPSM.getScanlineStride();
+        final int offScanStride = offSPPSM.getScanlineStride();
+
+        final int dstAdjust = dstScanStride - w;
+        final int offAdjust = offScanStride - w;
+
+        // Access the pixel value array
+        final int[] dstPixels = dstDB.getBankData()[0];
+        final int[] offPixels = offDB.getBankData()[0];
+
+        // Below is the number of shifts for each axis
+        // e.g when xChannel is ALPHA, the pixel needs
+        // to be shifted 24, RED 16, GREEN 8 and BLUE 0
+        final int xShift = xChannel.toInt()*8;
+        final int yShift = yChannel.toInt()*8;
+
+        // The pointer of img and dst indicating where the pixel values are
+        int dp = dstOff, ip = offOff;
+
+        // Fixed point representation of scale factor.
+        final int fpScaleX = (int)((scaleX/255.0)*(1<<15)+0.5);
+        final int fpAdjX   = (int)(-127.5*fpScaleX-0.5);
+        final int fpScaleY = (int)((scaleY/255.0)*(1<<15)+0.5);
+        final int fpAdjY   = (int)(-127.5*fpScaleY-0.5);
+
+        long start = System.currentTimeMillis();
+
+        int pel00, pel01, pel10, pel11, xFrac, yFrac, newPel;
+        int sp0, sp1, pel0, pel1;
+
+        int x, y, x0, y0, xDisplace, yDisplace, dPel;
+
+        int xt=xTile[0]-1, yt=yTile[0]-1, xt1, yt1;
+        int [] imgPix = null;
+
+        for (y=yStart; y<yEnd; y++) {
+            for (x=xStart; x<xEnd; x++, dp++, ip++) {
+                dPel = offPixels[ip];
+
+                xDisplace = (fpScaleX*((dPel>>xShift)&0xff))+fpAdjX;
+                yDisplace = (fpScaleY*((dPel>>yShift)&0xff))+fpAdjY;
+
+                x0 = x+(xDisplace>>15);
+                y0 = y+(yDisplace>>15);
+
+                if ((xt != xTile[x0]) ||
+                    (yt != yTile[y0])) {
+                    xt = xTile[x0]; yt = yTile[y0];
+                    imgPix = ((DataBufferInt)image.getTile(xt, yt)
+                              .getDataBuffer()).getBankData()[0];
+                }
+                pel00  = imgPix[xOff[x0]+yOff[y0]];
+
+                xt1 = xTile[x0+1];
+                yt1 = yTile[y0+1];
+                if ((yt == yt1)) {
+                    // Same tile vertically, check across...
+                    if ((xt == xt1)) {
+                        // All from same tile..
+                        pel10  = imgPix[xOff[x0+1]+yOff[y0]];
+                        pel01  = imgPix[xOff[x0]  +yOff[y0+1]];
+                        pel11  = imgPix[xOff[x0+1]+yOff[y0+1]];
+                    } else {
+                        // Different tile horizontally...
+                        pel01  = imgPix[xOff[x0]+yOff[y0+1]];
+
+                        imgPix = ((DataBufferInt)image.getTile(xt1, yt)
+                                  .getDataBuffer()).getBankData()[0];
+                        pel10  = imgPix[xOff[x0+1]+yOff[y0]];
+                        pel11  = imgPix[xOff[x0+1]+yOff[y0+1]];
+                        xt = xt1;
+                    }
+                } else {
+                    // Steped into next tile down, check across...
+                    if ((xt == xt1)) {
+                        // Different tile horizontally.
+                        pel10  = imgPix[xOff[x0+1]+yOff[y0]];
+
+                        imgPix = ((DataBufferInt)image.getTile(xt, yt1)
+                                  .getDataBuffer()).getBankData()[0];
+                        pel01  = imgPix[xOff[x0]  +yOff[y0+1]];
+                        pel11  = imgPix[xOff[x0+1]+yOff[y0+1]];
+                        yt = yt1;
+                    } else {
+                        // Ugg we are at the 4way intersection of tiles...
+                        imgPix = ((DataBufferInt)image.getTile(xt, yt1)
+                                  .getDataBuffer()).getBankData()[0];
+                        pel01  = imgPix[xOff[x0]+yOff[y0+1]];
+
+                        imgPix = ((DataBufferInt)image.getTile(xt1, yt1)
+                                  .getDataBuffer()).getBankData()[0];
+                        pel11  = imgPix[xOff[x0+1]+yOff[y0+1]];
+
+                        imgPix = ((DataBufferInt)image.getTile(xt1, yt)
+                                  .getDataBuffer()).getBankData()[0];
+                        pel10  = imgPix[xOff[x0+1]+yOff[y0]];
+                        xt = xt1;
+                    }
+                }
+
+                xFrac = xDisplace&0x7FFF;
+                yFrac = yDisplace&0x7FFF;
+
+                // Combine the alpha channels.
+                sp0  = (pel00>>>16) & 0xFF00;
+                sp1  = (pel10>>>16) & 0xFF00;
+                pel0 = (sp0 + (((sp1-sp0)*xFrac+0x4000)>>15)) & 0xFFFF;
+                sp0  = (pel01>>>16) & 0xFF00;
+                sp1  = (pel11>>>16) & 0xFF00;
+                pel1 = (sp0 + (((sp1-sp0)*xFrac+0x4000)>>15)) & 0xFFFF;
+                newPel = (((pel0<<15) + (pel1-pel0)*yFrac + 0x00400000)
+                          &0x7F800000)<<  1;
+
+                // Combine the red channels.
+                sp0  = (pel00>>  8) & 0xFF00;
+                sp1  = (pel10>>  8) & 0xFF00;
+                pel0 = (sp0 + (((sp1-sp0)*xFrac+0x4000)>>15)) & 0xFFFF;
+                sp0  = (pel01>>  8) & 0xFF00;
+                sp1  = (pel11>>  8) & 0xFF00;
+                pel1 = (sp0 + (((sp1-sp0)*xFrac+0x4000)>>15)) & 0xFFFF;
+                newPel |= (((pel0<<15) + (pel1-pel0)*yFrac + 0x00400000)
+                           &0x7F800000)>>> 7;
+
+                // Combine the green channels.
+                sp0  = (pel00     ) & 0xFF00;
+                sp1  = (pel10     ) & 0xFF00;
+                pel0 = (sp0 + (((sp1-sp0)*xFrac+0x4000)>>15)) & 0xFFFF;
+                sp0  = (pel01     ) & 0xFF00;
+                sp1  = (pel11     ) & 0xFF00;
+                pel1 = (sp0 + (((sp1-sp0)*xFrac+0x4000)>>15)) & 0xFFFF;
+                newPel |= (((pel0<<15) + (pel1-pel0)*yFrac + 0x00400000)
+                           &0x7F800000)>>>15;
+
+                // Combine the blue channels.
+                sp0  = (pel00<<  8) & 0xFF00;
+                sp1  = (pel10<<  8) & 0xFF00;
+                pel0 = (sp0 + (((sp1-sp0)*xFrac+0x4000)>>15)) & 0xFFFF;
+                sp0  = (pel01<<  8) & 0xFF00;
+                sp1  = (pel11<<  8) & 0xFF00;
+                pel1 = (sp0 + (((sp1-sp0)*xFrac+0x4000)>>15)) & 0xFFFF;
+                newPel |= (((pel0<<15) + (pel1-pel0)*yFrac + 0x00400000)
+                           &0x7F800000)>>>23;
+
+                dstPixels[dp] = newPel;
+            }
+
+            dp += dstAdjust;
+            ip += offAdjust;
+        }
+
+        if (TIME) {
+            long end = System.currentTimeMillis();
+            System.out.println("Time: " + (end-start));
+        }
+    }// end of the filter() method for Raster
+
+    public void filterBLPre(Raster off, WritableRaster dst,
+                            int [] xTile, int [] xOff,
+                            int [] yTile, int [] yOff) {
+        final int w      = dst.getWidth();
+        final int h      = dst.getHeight();
+        final int xStart = maxOffX;
+        final int yStart = maxOffY;
+        final int xEnd   = xStart+w;
+        final int yEnd   = yStart+h;
+
+        // Access the integer buffer for each image.
+        DataBufferInt dstDB = (DataBufferInt)dst.getDataBuffer();
+        DataBufferInt offDB = (DataBufferInt)off.getDataBuffer();
+
+        // Offset defines where in the stack the real data begin
+        SinglePixelPackedSampleModel dstSPPSM, offSPPSM;
+
+        dstSPPSM = (SinglePixelPackedSampleModel)dst.getSampleModel();
+        final int dstOff = dstDB.getOffset() +
+            dstSPPSM.getOffset(dst.getMinX() - dst.getSampleModelTranslateX(),
+                               dst.getMinY() - dst.getSampleModelTranslateY());
+
+        offSPPSM = (SinglePixelPackedSampleModel)off.getSampleModel();
+        final int offOff = offDB.getOffset() +
+            offSPPSM.getOffset(dst.getMinX() - off.getSampleModelTranslateX(),
+                               dst.getMinY() - off.getSampleModelTranslateY());
+
+        // Stride is the distance between two consecutive column elements,
+        // in the one-dimention dataBuffer
+        final int dstScanStride = dstSPPSM.getScanlineStride();
+        final int offScanStride = offSPPSM.getScanlineStride();
+
+        final int dstAdjust = dstScanStride - w;
+        final int offAdjust = offScanStride - w;
+
+        // Access the pixel value array
+        final int[] dstPixels = dstDB.getBankData()[0];
+        final int[] offPixels = offDB.getBankData()[0];
+
+        // Below is the number of shifts for each axis
+        // e.g when xChannel is ALPHA, the pixel needs
+        // to be shifted 24, RED 16, GREEN 8 and BLUE 0
+        final int xShift = xChannel.toInt()*8;
+        final int yShift = yChannel.toInt()*8;
+
+        // The pointer of img and dst indicating where the pixel values are
+        int dp = dstOff, ip = offOff;
+
+        // Fixed point representation of scale factor.
+        // Fixed point representation of scale factor.
+        final int fpScaleX = (int)((scaleX/255.0)*(1<<15)+0.5);
+        final int fpAdjX   = (int)(-127.5*fpScaleX-0.5);
+        final int fpScaleY = (int)((scaleY/255.0)*(1<<15)+0.5);
+        final int fpAdjY   = (int)(-127.5*fpScaleY-0.5);
+
+        long start = System.currentTimeMillis();
+
+        int pel00, pel01, pel10, pel11, xFrac, yFrac, newPel;
+        int sp0, sp1, pel0, pel1, a00, a01, a10, a11;
+
+        int x, y, x0, y0, xDisplace, yDisplace, dPel;
+        final int norm = (1<<24)/255;
+
+        int xt=xTile[0]-1, yt=yTile[0]-1, xt1, yt1;
+        int [] imgPix = null;
+
+        for (y=yStart; y<yEnd; y++) {
+            for (x=xStart; x<xEnd; x++, dp++, ip++) {
+                dPel = offPixels[ip];
+
+                xDisplace = (fpScaleX*((dPel>>xShift)&0xff))+fpAdjX;
+                yDisplace = (fpScaleY*((dPel>>yShift)&0xff))+fpAdjY;
+
+                x0 = x+(xDisplace>>15);
+                y0 = y+(yDisplace>>15);
+
+                if ((xt != xTile[x0]) || (yt != yTile[y0])) {
+                    xt = xTile[x0];
+                    yt = yTile[y0];
+                    imgPix = ((DataBufferInt)image.getTile(xt, yt)
+                              .getDataBuffer()).getBankData()[0];
+                }
+                pel00  = imgPix[xOff[x0]+yOff[y0]];
+
+                xt1 = xTile[x0+1];
+                yt1 = yTile[y0+1];
+                if ((yt == yt1)) {
+                    // Same tile vertically, check across...
+                    if ((xt == xt1)) {
+                        // All from same tile..
+                        pel10  = imgPix[xOff[x0+1]+yOff[y0]];
+                        pel01  = imgPix[xOff[x0]  +yOff[y0+1]];
+                        pel11  = imgPix[xOff[x0+1]+yOff[y0+1]];
+                    } else {
+                        // Different tile horizontally...
+                        pel01  = imgPix[xOff[x0]+yOff[y0+1]];
+
+                        imgPix = ((DataBufferInt)image.getTile(xt1, yt)
+                                  .getDataBuffer()).getBankData()[0];
+                        pel10  = imgPix[xOff[x0+1]+yOff[y0]];
+                        pel11  = imgPix[xOff[x0+1]+yOff[y0+1]];
+                        xt = xt1;
+                    }
+                } else {
+                    // Steped into next tile down, check across...
+                    if ((xt == xt1)) {
+                        // Different tile horizontally.
+                        pel10  = imgPix[xOff[x0+1]+yOff[y0]];
+
+                        imgPix = ((DataBufferInt)image.getTile(xt, yt1)
+                                  .getDataBuffer()).getBankData()[0];
+                        pel01  = imgPix[xOff[x0]  +yOff[y0+1]];
+                        pel11  = imgPix[xOff[x0+1]+yOff[y0+1]];
+                        yt = yt1;
+                    } else {
+                        // Ugg we are at the 4way intersection of tiles...
+                        imgPix = ((DataBufferInt)image.getTile(xt, yt1)
+                                  .getDataBuffer()).getBankData()[0];
+                        pel01  = imgPix[xOff[x0]+yOff[y0+1]];
+
+                        imgPix = ((DataBufferInt)image.getTile(xt1, yt1)
+                                  .getDataBuffer()).getBankData()[0];
+                        pel11  = imgPix[xOff[x0+1]+yOff[y0+1]];
+
+                        imgPix = ((DataBufferInt)image.getTile(xt1, yt)
+                                  .getDataBuffer()).getBankData()[0];
+                        pel10  = imgPix[xOff[x0+1]+yOff[y0]];
+                        xt = xt1;
+                    }
+                }
+
+                xFrac = xDisplace&0x7FFF;
+                yFrac = yDisplace&0x7FFF;
+
+                // Combine the alpha channels.
+                sp0  = (pel00>>>16) & 0xFF00;
+                sp1  = (pel10>>>16) & 0xFF00;
+                pel0 = (sp0 + (((sp1-sp0)*xFrac+0x4000)>>15)) & 0xFFFF;
+                a00 = ((sp0>>8)*norm + 0x80)>>8;
+                a10 = ((sp1>>8)*norm + 0x80)>>8;
+
+                sp0  = (pel01>>>16) & 0xFF00;
+                sp1  = (pel11>>>16) & 0xFF00;
+                pel1 = (sp0 + (((sp1-sp0)*xFrac+0x4000)>>15)) & 0xFFFF;
+                a01 = ((sp0>>8)*norm + 0x80)>>8;
+                a11 = ((sp1>>8)*norm + 0x80)>>8;
+                newPel = (((pel0<<15) + (pel1-pel0)*yFrac + 0x00400000)
+                          &0x7F800000)<<  1;
+
+                // Combine the red channels.
+                sp0  = ((((pel00>> 16) & 0xFF)*a00) + 0x80)>>8;
+                sp1  = ((((pel10>> 16) & 0xFF)*a10) + 0x80)>>8;
+                pel0 = (sp0 + (((sp1-sp0)*xFrac+0x4000)>>15)) & 0xFFFF;
+                sp0  = ((((pel01>> 16) & 0xFF)*a01) + 0x80)>>8;
+                sp1  = ((((pel11>> 16) & 0xFF)*a11) + 0x80)>>8;
+                pel1 = (sp0 + (((sp1-sp0)*xFrac+0x4000)>>15)) & 0xFFFF;
+                newPel |= (((pel0<<15) + (pel1-pel0)*yFrac + 0x00400000)
+                           &0x7F800000)>>> 7;
+
+                // Combine the green channels.
+                sp0  = ((((pel00>> 8) & 0xFF)*a00) + 0x80)>>8;
+                sp1  = ((((pel10>> 8) & 0xFF)*a10) + 0x80)>>8;
+                pel0 = (sp0 + (((sp1-sp0)*xFrac+0x4000)>>15)) & 0xFFFF;
+                sp0  = ((((pel01>> 8) & 0xFF)*a01) + 0x80)>>8;
+                sp1  = ((((pel11>> 8) & 0xFF)*a11) + 0x80)>>8;
+                pel1 = (sp0 + (((sp1-sp0)*xFrac+0x4000)>>15)) & 0xFFFF;
+                newPel |= (((pel0<<15) + (pel1-pel0)*yFrac + 0x00400000)
+                           &0x7F800000)>>>15;
+
+                // Combine the blue channels.
+                sp0  = (((pel00 & 0xFF)*a00) + 0x80)>>8;
+                sp1  = (((pel10 & 0xFF)*a10) + 0x80)>>8;
+                pel0 = (sp0 + (((sp1-sp0)*xFrac+0x4000)>>15)) & 0xFFFF;
+                sp0  = (((pel01 & 0xFF)*a01) + 0x80)>>8;
+                sp1  = (((pel11 & 0xFF)*a11) + 0x80)>>8;
+                pel1 = (sp0 + (((sp1-sp0)*xFrac+0x4000)>>15)) & 0xFFFF;
+                newPel |= (((pel0<<15) + (pel1-pel0)*yFrac + 0x00400000)
+                           &0x7F800000)>>>23;
+
+                dstPixels[dp] = newPel;
+            }
+
+            dp += dstAdjust;
+            ip += offAdjust;
+        }
+
+        if (TIME) {
+            long end = System.currentTimeMillis();
+            System.out.println("Time: " + (end-start));
+        }
+    }// end of the filter() method for Raster
+
+    /**
+     * Does displacement map using Nearest neighbor interpolation
+     *
+     * @param off the displacement map
+     * @param dst stores the filtered image. If null, a destination will
+     *        be created. img and dst can refer to the same Raster, in
+     *        which situation the img will be modified.
+     */
+    public void filterNN(Raster off, WritableRaster dst,
+                         int [] xTile, int [] xOff,
+                         int [] yTile, int [] yOff) {
+        final int w      = dst.getWidth();
+        final int h      = dst.getHeight();
+        final int xStart = maxOffX;
+        final int yStart = maxOffY;
+        final int xEnd   = xStart+w;
+        final int yEnd   = yStart+h;
+
+        // Access the integer buffer for each image.
+        DataBufferInt dstDB = (DataBufferInt)dst.getDataBuffer();
+        DataBufferInt offDB = (DataBufferInt)off.getDataBuffer();
+
+        // Offset defines where in the stack the real data begin
+        SinglePixelPackedSampleModel dstSPPSM, offSPPSM;
+
+        dstSPPSM = (SinglePixelPackedSampleModel)dst.getSampleModel();
+        final int dstOff = dstDB.getOffset() +
+            dstSPPSM.getOffset(dst.getMinX() - dst.getSampleModelTranslateX(),
+                               dst.getMinY() - dst.getSampleModelTranslateY());
+
+        offSPPSM = (SinglePixelPackedSampleModel)off.getSampleModel();
+        final int offOff = offDB.getOffset() +
+            offSPPSM.getOffset(off.getMinX() - off.getSampleModelTranslateX(),
+                               off.getMinY() - off.getSampleModelTranslateY());
+
+        // Stride is the distance between two consecutive column elements,
+        // in the one-dimention dataBuffer
+        final int dstScanStride = dstSPPSM.getScanlineStride();
+        final int offScanStride = offSPPSM.getScanlineStride();
+
+        final int dstAdjust = dstScanStride - w;
+        final int offAdjust = offScanStride - w;
+
+        // Access the pixel value array
+        final int[] dstPixels = dstDB.getBankData()[0];
+        final int[] offPixels = offDB.getBankData()[0];
+
+        // Below is the number of shifts for each axis
+        // e.g when xChannel is ALPHA, the pixel needs
+        // to be shifted 24, RED 16, GREEN 8 and BLUE 0
+        final int xShift = xChannel.toInt()*8;
+        final int yShift = yChannel.toInt()*8;
+
+        final int fpScaleX = (int)((scaleX/255.0)*(1<<15)+0.5);
+        final int fpScaleY = (int)((scaleY/255.0)*(1<<15)+0.5);
+
+        // Calculate the shift to make '.5' no movement.
+        // This also includes rounding factor (0x4000) for Fixed Point stuff.
+        final int fpAdjX   = (int)(-127.5*fpScaleX-0.5) + 0x4000;
+        final int fpAdjY   = (int)(-127.5*fpScaleY-0.5) + 0x4000;
+
+        // The pointer of img and dst indicating where the pixel values are
+        int dp = dstOff, ip = offOff;
+
+        long start = System.currentTimeMillis();
+        int y=yStart, xt=xTile[0]-1, yt=yTile[0]-1;
+        int [] imgPix = null;
+
+        int x0, y0, xDisplace, yDisplace, dPel;
+        while (y<yEnd) {
+            int x=xStart;
+            while (x<xEnd) {
+                dPel = offPixels[ip];
+
+                xDisplace = (fpScaleX*((dPel>>xShift)&0xff))+fpAdjX;
+                yDisplace = (fpScaleY*((dPel>>yShift)&0xff))+fpAdjY;
+
+                x0 = x+(xDisplace>>15);
+                y0 = y+(yDisplace>>15);
+
+                if ((xt != xTile[x0]) ||
+                    (yt != yTile[y0])) {
+                    xt = xTile[x0]; yt = yTile[y0];
+                    imgPix = ((DataBufferInt)image.getTile(xt, yt)
+                              .getDataBuffer()).getBankData()[0];
+                }
+                dstPixels[dp] = imgPix[xOff[x0]+yOff[y0]];
+
+                dp++;
+                ip++;
+                x++;
+            }
+
+            dp += dstAdjust;
+            ip += offAdjust;
+            y++;
+        }
+        if (TIME) {
+            long end = System.currentTimeMillis();
+            System.out.println("Time: " + (end-start));
+        }
+    }// end of the filter() method for Raster
+}
+
+

Propchange: incubator/flex/sdk/branches/develop/modules/thirdparty/batik/sources/org/apache/flex/forks/batik/ext/awt/image/rendered/DisplacementMapRed.java
------------------------------------------------------------------------------
    svn:eol-style = native



Mime
View raw message