pdfbox-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From le...@apache.org
Subject svn commit: r1562921 - in /pdfbox/trunk/pdfbox/src/main/java/org/apache/pdfbox/pdmodel/graphics: pattern/PDShadingPatternResources.java shading/AxialShadingContext.java shading/RadialShadingContext.java
Date Thu, 30 Jan 2014 18:54:18 GMT
Author: lehmi
Date: Thu Jan 30 18:54:18 2014
New Revision: 1562921

URL: http://svn.apache.org/r1562921
Log:
PDFBOX-615: take the shading matrix into account based on a proposal by Luis Bernado, add
background support

Modified:
    pdfbox/trunk/pdfbox/src/main/java/org/apache/pdfbox/pdmodel/graphics/pattern/PDShadingPatternResources.java
    pdfbox/trunk/pdfbox/src/main/java/org/apache/pdfbox/pdmodel/graphics/shading/AxialShadingContext.java
    pdfbox/trunk/pdfbox/src/main/java/org/apache/pdfbox/pdmodel/graphics/shading/RadialShadingContext.java

Modified: pdfbox/trunk/pdfbox/src/main/java/org/apache/pdfbox/pdmodel/graphics/pattern/PDShadingPatternResources.java
URL: http://svn.apache.org/viewvc/pdfbox/trunk/pdfbox/src/main/java/org/apache/pdfbox/pdmodel/graphics/pattern/PDShadingPatternResources.java?rev=1562921&r1=1562920&r2=1562921&view=diff
==============================================================================
--- pdfbox/trunk/pdfbox/src/main/java/org/apache/pdfbox/pdmodel/graphics/pattern/PDShadingPatternResources.java
(original)
+++ pdfbox/trunk/pdfbox/src/main/java/org/apache/pdfbox/pdmodel/graphics/pattern/PDShadingPatternResources.java
Thu Jan 30 18:54:18 2014
@@ -206,10 +206,10 @@ public class PDShadingPatternResources e
         switch (shadingType)
         {
             case PDShadingResources.SHADING_TYPE2:
-                paint = new AxialShadingPaint((PDShadingType2)getShading(), null, pageHeight);
+                paint = new AxialShadingPaint((PDShadingType2)getShading(), getMatrix(),
pageHeight);
                 break;
             case PDShadingResources.SHADING_TYPE3:
-                paint = new RadialShadingPaint((PDShadingType3)getShading(), null, pageHeight);
+                paint = new RadialShadingPaint((PDShadingType3)getShading(), getMatrix(),
pageHeight);
                 break;
             case PDShadingResources.SHADING_TYPE1: 
             case PDShadingResources.SHADING_TYPE4:

Modified: pdfbox/trunk/pdfbox/src/main/java/org/apache/pdfbox/pdmodel/graphics/shading/AxialShadingContext.java
URL: http://svn.apache.org/viewvc/pdfbox/trunk/pdfbox/src/main/java/org/apache/pdfbox/pdmodel/graphics/shading/AxialShadingContext.java?rev=1562921&r1=1562920&r2=1562921&view=diff
==============================================================================
--- pdfbox/trunk/pdfbox/src/main/java/org/apache/pdfbox/pdmodel/graphics/shading/AxialShadingContext.java
(original)
+++ pdfbox/trunk/pdfbox/src/main/java/org/apache/pdfbox/pdmodel/graphics/shading/AxialShadingContext.java
Thu Jan 30 18:54:18 2014
@@ -17,9 +17,13 @@
 package org.apache.pdfbox.pdmodel.graphics.shading;
 
 import java.awt.PaintContext;
+import java.awt.Transparency;
 import java.awt.color.ColorSpace;
 import java.awt.geom.AffineTransform;
+import java.awt.geom.NoninvertibleTransformException;
 import java.awt.image.ColorModel;
+import java.awt.image.ComponentColorModel;
+import java.awt.image.DataBuffer;
 import java.awt.image.Raster;
 import java.awt.image.WritableRaster;
 import java.io.IOException;
@@ -38,23 +42,20 @@ import org.apache.pdfbox.util.Matrix;
 /**
  * This class represents the PaintContext of an axial shading.
  * 
- * @author lehmi
- * 
  */
 public class AxialShadingContext implements PaintContext 
 {
 
-    private ColorModel colorModel;
+    private ColorModel outputColorModel;
     private ColorSpace shadingColorSpace;
     private PDFunction shadingTinttransform;
     private PDShadingType2 shadingType;
 
     private float[] coords;
     private float[] domain;
-    private int[] extend0Values;
-    private int[] extend1Values;
+    private float[] background;
     private boolean[] extend;
-    private double x1x0; 
+    private double x1x0;
     private double y1y0;
     private float d1d0;
     private double denom;
@@ -70,112 +71,91 @@ public class AxialShadingContext impleme
      * @param shadingType2 the shading type to be used
      * @param colorModelValue the color model to be used
      * @param xform transformation for user to device space
-     * @param ctm current transformation matrix
+     * @param transformationMatrix the transformation matrix
      * @param pageHeight height of the current page
      * 
      */
     public AxialShadingContext(PDShadingType2 shadingType2, ColorModel colorModelValue, 
-            AffineTransform xform, Matrix ctm, int pageHeight) 
+            AffineTransform xform, Matrix transformationMatrix, int pageHeight) 
     {
         shadingType = shadingType2;
         coords = shadingType.getCoords().toFloatArray();
-        if (ctm != null)
-        {
-            // the shading is used in combination with the sh-operator
-            float[] coordsTemp = new float[coords.length]; 
-            // transform the coords from shading to user space
-            ctm.createAffineTransform().transform(coords, 0, coordsTemp, 0, 2);
-            // move the 0,0-reference
-            coordsTemp[1] = pageHeight - coordsTemp[1];
-            coordsTemp[3] = pageHeight - coordsTemp[3];
-            // transform the coords from user to device space
-            xform.transform(coordsTemp, 0, coords, 0, 2);
-        }
-        else
+
+        if (transformationMatrix != null)
         {
-            // the shading is used as pattern colorspace in combination
-            // with a fill-, stroke- or showText-operator
-            float translateY = (float)xform.getTranslateY();
-            // move the 0,0-reference including the y-translation from user to device space
-            coords[1] = pageHeight + translateY - coords[1];
-            coords[3] = pageHeight + translateY - coords[3];
+            // transform the coords using the given matrix
+            transformationMatrix.createAffineTransform().transform(coords, 0, coords, 0,
2);
         }
-        // colorSpace 
-        try 
+        xform.transform(coords, 0, coords, 0, 2);
+        // get the shading colorSpace
+        try
         {
             PDColorSpace cs = shadingType.getColorSpace();
             if (!(cs instanceof PDDeviceRGB))
             {
                 // we have to create an instance of the shading colorspace if it isn't RGB
                 shadingColorSpace = cs.getJavaColorSpace();
+                // get the tint transformation function if the colorspace has one
                 if (cs instanceof PDDeviceN)
                 {
-                    shadingTinttransform = ((PDDeviceN)cs).getTintTransform();
+                    shadingTinttransform = ((PDDeviceN) cs).getTintTransform();
                 }
                 else if (cs instanceof PDSeparation)
                 {
-                    shadingTinttransform = ((PDSeparation)cs).getTintTransform();
+                    shadingTinttransform = ((PDSeparation) cs).getTintTransform();
                 }
             }
-        } 
-        catch (IOException exception) 
-        {
-            LOG.error("error while creating colorSpace", exception);
         }
-        // colorModel
-        if (colorModelValue != null)
-        {
-            colorModel = colorModelValue;
-        }
-        else
+        catch (IOException exception)
         {
-            try
-            {
-                // TODO bpc != 8 ??  
-                colorModel = shadingType.getColorSpace().createColorModel(8);
-            }
-            catch(IOException exception)
-            {
-                LOG.error("error while creating colorModel", exception);
-            }
+            LOG.error("error while creating colorSpace", exception);
         }
+        // create the output colormodel using RGB+alpha as colorspace
+        ColorSpace outputCS = ColorSpace.getInstance(ColorSpace.CS_sRGB);
+        outputColorModel = new ComponentColorModel(outputCS, true, false, Transparency.TRANSLUCENT,
+                DataBuffer.TYPE_BYTE);
         // domain values
         if (shadingType.getDomain() != null)
         {
             domain = shadingType.getDomain().toFloatArray();
         }
-        else 
+        else
         {
             // set default values
-            domain = new float[]{0,1};
+            domain = new float[] { 0, 1 };
         }
         // extend values
         COSArray extendValues = shadingType.getExtend();
         if (shadingType.getExtend() != null)
         {
             extend = new boolean[2];
-            extend[0] = ((COSBoolean)extendValues.get(0)).getValue();
-            extend[1] = ((COSBoolean)extendValues.get(1)).getValue();
+            extend[0] = ((COSBoolean) extendValues.get(0)).getValue();
+            extend[1] = ((COSBoolean) extendValues.get(1)).getValue();
         }
         else
         {
             // set default values
-            extend = new boolean[]{false,false};
+            extend = new boolean[] { false, false };
         }
         // calculate some constants to be used in getRaster
-        x1x0 = coords[2] - coords[0]; 
+        x1x0 = coords[2] - coords[0];
         y1y0 = coords[3] - coords[1];
-        d1d0 = domain[1]-domain[0];
-        denom = Math.pow(x1x0,2) + Math.pow(y1y0, 2);
-        // TODO take a possible Background value into account
-        
+        d1d0 = domain[1] - domain[0];
+        denom = Math.pow(x1x0, 2) + Math.pow(y1y0, 2);
+
+        // get background values if available
+        COSArray bg = shadingType2.getBackground();
+        if (bg != null)
+        {
+            background = bg.toFloatArray();
+        }
     }
     /**
      * {@inheritDoc}
      */
     public void dispose() 
     {
-        colorModel = null;
+        outputColorModel = null;
         shadingColorSpace = null;
         shadingTinttransform = null;
         shadingType = null;
@@ -186,7 +166,7 @@ public class AxialShadingContext impleme
      */
     public ColorModel getColorModel() 
     {
-        return colorModel;
+        return outputColorModel;
     }
 
     /**
@@ -196,39 +176,50 @@ public class AxialShadingContext impleme
     {
         // create writable raster
         WritableRaster raster = getColorModel().createCompatibleWritableRaster(w, h);
-        int[] data = new int[w * h * 3];
-        boolean saveExtend0 = false;
-        boolean saveExtend1 = false;
-        for (int j = 0; j < h; j++) 
+        boolean useBackground = false;
+        int[] data = new int[w * h * 4];
+        for (int j = 0; j < h; j++)
         {
-            for (int i = 0; i < w; i++) 
+            for (int i = 0; i < w; i++)
             {
-                int index = (j * w + i) * 3;
-                double inputValue = x1x0 * (x + i - coords[0]); 
+                useBackground = false;
+                double inputValue = x1x0 * (x + i - coords[0]);
                 inputValue += y1y0 * (y + j - coords[1]);
-                inputValue /= denom;
+                // TODO this happens if start == end, see PDFBOX-1442
+                if (denom == 0)
+                {
+                    if (background != null)
+                    {
+                        useBackground = true;
+                    }
+                    else
+                    {
+                        continue;
+                    }
+                }
+                else
+                {
+                    inputValue /= denom;
+                }
                 // input value is out of range
                 if (inputValue < domain[0])
                 {
                     // the shading has to be extended if extend[0] == true
                     if (extend[0])
                     {
-                        if (extend0Values == null)
+                        inputValue = domain[0];
+                    }
+                    else
+                    {
+                        if (background != null)
                         {
-                            inputValue = domain[0];
-                            saveExtend0 = true;
+                            useBackground = true;
                         }
                         else
                         {
-                            // use the chached values
-                            System.arraycopy(extend0Values, 0, data, index, 3);
                             continue;
                         }
                     }
-                    else 
-                    {
-                        continue;
-                    }
                 }
                 // input value is out of range
                 else if (inputValue > domain[1])
@@ -236,61 +227,102 @@ public class AxialShadingContext impleme
                     // the shading has to be extended if extend[1] == true
                     if (extend[1])
                     {
-                        if (extend1Values == null)
+                        inputValue = domain[1];
+                    }
+                    else
+                    {
+                        if (background != null)
                         {
-                            inputValue = domain[1];
-                            saveExtend1 = true;
+                            useBackground = true;
                         }
                         else
                         {
-                            // use the chached values
-                            System.arraycopy(extend1Values, 0, data, index, 3);
                             continue;
                         }
                     }
-                    else 
+                }
+                float[] values = null;
+                int index = (j * w + i) * 4;
+                if (useBackground)
+                {
+                    // use the given backgound color values
+                    values = background;
+                }
+                else
+                {
+                    try
                     {
-                        continue;
+                        float input = (float) (domain[0] + (d1d0 * inputValue));
+                        values = shadingType.evalFunction(input);
+                    }
+                    catch (IOException exception)
+                    {
+                        LOG.error("error while processing a function", exception);
                     }
                 }
-                float input = (float)(domain[0] + (d1d0*inputValue));
-                float[] values = null;
-                try 
+                // convert color values from shading colorspace to RGB if necessary
+                if (shadingColorSpace != null)
                 {
-                    values = shadingType.evalFunction(input);
-                    // convert color values from shading colorspace to RGB 
-                    if (shadingColorSpace != null)
+                    if (shadingTinttransform != null)
                     {
-                        if (shadingTinttransform != null)
+                        try
                         {
                             values = shadingTinttransform.eval(values);
                         }
-                        values = shadingColorSpace.toRGB(values);
+                        catch (IOException exception)
+                        {
+                            LOG.error("error while processing a function", exception);
+                        }
                     }
-                } 
-                catch (IOException exception) 
-                {
-                    LOG.error("error while processing a function", exception);
-                }
-                data[index] = (int)(values[0]*255);
-                data[index+1] = (int)(values[1]*255);
-                data[index+2] = (int)(values[2]*255);
-                if (saveExtend0)
-                {
-                    // chache values
-                    extend0Values = new int[3];
-                    System.arraycopy(data, index, extend0Values, 0, 3);
-                }
-                if (saveExtend1)
-                {
-                    // chache values
-                    extend1Values = new int[3];
-                    System.arraycopy(data, index, extend1Values, 0, 3);
+                    values = shadingColorSpace.toRGB(values);
                 }
+                data[index] = (int) (values[0] * 255);
+                data[index + 1] = (int) (values[1] * 255);
+                data[index + 2] = (int) (values[2] * 255);
+                data[index + 3] = 255;
             }
         }
         raster.setPixels(0, 0, w, h, data);
         return raster;
     }
 
+    /**
+     * Returns the coords values.
+     * 
+     * @return the coords values as array
+     */
+    public float[] getCoords() 
+    {
+        return coords;
+    }
+        
+    /**
+     * Returns the domain values.
+     * 
+     * @return the domain values as array
+     */
+    public float[] getDomain() 
+    {
+        return domain;
+    }
+        
+    /**
+     * Returns the extend values.
+     * 
+     * @return the extend values as array
+     */
+    public boolean[] getExtend() 
+    {
+        return extend;
+    }
+    
+    /**
+     * Returns the function used for the shading tint transformation.
+     * 
+     * @return the shading tint transformation function
+     */
+    public PDFunction getShadingTintTransform() 
+    {
+        return shadingTinttransform;
+    }
 }

Modified: pdfbox/trunk/pdfbox/src/main/java/org/apache/pdfbox/pdmodel/graphics/shading/RadialShadingContext.java
URL: http://svn.apache.org/viewvc/pdfbox/trunk/pdfbox/src/main/java/org/apache/pdfbox/pdmodel/graphics/shading/RadialShadingContext.java?rev=1562921&r1=1562920&r2=1562921&view=diff
==============================================================================
--- pdfbox/trunk/pdfbox/src/main/java/org/apache/pdfbox/pdmodel/graphics/shading/RadialShadingContext.java
(original)
+++ pdfbox/trunk/pdfbox/src/main/java/org/apache/pdfbox/pdmodel/graphics/shading/RadialShadingContext.java
Thu Jan 30 18:54:18 2014
@@ -17,9 +17,12 @@
 package org.apache.pdfbox.pdmodel.graphics.shading;
 
 import java.awt.PaintContext;
+import java.awt.Transparency;
 import java.awt.color.ColorSpace;
 import java.awt.geom.AffineTransform;
 import java.awt.image.ColorModel;
+import java.awt.image.ComponentColorModel;
+import java.awt.image.DataBuffer;
 import java.awt.image.Raster;
 import java.awt.image.WritableRaster;
 import java.io.IOException;
@@ -38,21 +41,18 @@ import org.apache.pdfbox.util.Matrix;
 /**
  * This class represents the PaintContext of an radial shading.
  * 
- * @author lehmi
- * 
  */
 public class RadialShadingContext implements PaintContext 
 {
 
-    private ColorModel colorModel;
+    private ColorModel outputColorModel;
     private ColorSpace shadingColorSpace;
     private PDFunction shadingTinttransform;
     private PDShadingType3 shadingType;
 
     private float[] coords;
     private float[] domain;
-    private int[] extend0Values;
-    private int[] extend1Values;
+    private float[] background;
     private boolean[] extend;
     private double x1x0; 
     private double y1y0;
@@ -75,40 +75,34 @@ public class RadialShadingContext implem
      * @param shadingType3 the shading type to be used
      * @param colorModelValue the color model to be used
      * @param xform transformation for user to device space
-     * @param ctm current transformation matrix
+     * @param transformationMatrix the transformation matrix
      * @param pageHeight height of the current page
      * 
      */
     public RadialShadingContext(PDShadingType3 shadingType3, ColorModel colorModelValue,

-            AffineTransform xform, Matrix ctm, int pageHeight) 
+            AffineTransform xform, Matrix transformationMatrix, int pageHeight) 
     {
         shadingType = shadingType3;
         coords = shadingType.getCoords().toFloatArray();
-        if (ctm != null)
-        {
-            // the shading is used in combination with the sh-operator
-            float[] coordsTemp = new float[coords.length]; 
-            // transform the coords from shading to user space
-            ctm.createAffineTransform().transform(coords, 0, coordsTemp, 0, 1);
-            ctm.createAffineTransform().transform(coords, 3, coordsTemp, 3, 1);
-            // move the 0,0-reference
-            coordsTemp[1] = pageHeight - coordsTemp[1];
-            coordsTemp[4] = pageHeight - coordsTemp[4];
-            // transform the coords from user to device space
-            xform.transform(coordsTemp, 0, coords, 0, 1);
-            xform.transform(coordsTemp, 3, coords, 3, 1);
-        }
-        else
+
+        if (transformationMatrix != null)
         {
-            // the shading is used as pattern colorspace in combination
-            // with a fill-, stroke- or showText-operator
-            float translateY = (float)xform.getTranslateY();
-            // move the 0,0-reference including the y-translation from user to device space
-            coords[1] = pageHeight + translateY - coords[1];
-            coords[4] = pageHeight + translateY - coords[4];
+            // transform the coords using the given matrix
+            AffineTransform at = transformationMatrix.createAffineTransform();
+            at.transform(coords, 0, coords, 0, 1);
+            at.transform(coords, 3, coords, 3, 1);
+            coords[2] *= at.getScaleX();
+            coords[5] *= at.getScaleX();
         }
-        // colorSpace 
-        try 
+        // transform coords to device space
+        xform.transform(coords, 0, coords, 0, 1);
+        xform.transform(coords, 3, coords, 3, 1);
+        // scale radius to device space
+        coords[2] *= xform.getScaleX();
+        coords[5] *= xform.getScaleX();
+
+        // get the shading colorSpace
+        try
         {
             PDColorSpace cs = shadingType.getColorSpace();
             if (!(cs instanceof PDDeviceRGB))
@@ -117,76 +111,68 @@ public class RadialShadingContext implem
                 shadingColorSpace = cs.getJavaColorSpace();
                 if (cs instanceof PDDeviceN)
                 {
-                    shadingTinttransform = ((PDDeviceN)cs).getTintTransform();
+                    shadingTinttransform = ((PDDeviceN) cs).getTintTransform();
                 }
                 else if (cs instanceof PDSeparation)
                 {
-                    shadingTinttransform = ((PDSeparation)cs).getTintTransform();
+                    shadingTinttransform = ((PDSeparation) cs).getTintTransform();
                 }
             }
-        } 
-        catch (IOException exception) 
-        {
-            LOG.error("error while creating colorSpace", exception);
-        }
-        // colorModel
-        if (colorModelValue != null)
-        {
-            colorModel = colorModelValue;
         }
-        else
+        catch (IOException exception)
         {
-            try
-            {
-                // TODO bpc != 8 ??  
-                colorModel = shadingType.getColorSpace().createColorModel(8);
-            }
-            catch(IOException exception)
-            {
-                LOG.error("error while creating colorModel", exception);
-            }
+            LOG.error("error while creating colorSpace", exception);
         }
+        // create the output colormodel using RGB+alpha as colorspace
+        ColorSpace outputCS = ColorSpace.getInstance(ColorSpace.CS_sRGB);
+        outputColorModel = new ComponentColorModel(outputCS, true, false, Transparency.TRANSLUCENT,
+                DataBuffer.TYPE_BYTE);
         // domain values
         if (shadingType.getDomain() != null)
         {
             domain = shadingType.getDomain().toFloatArray();
         }
-        else 
+        else
         {
             // set default values
-            domain = new float[]{0,1};
+            domain = new float[] { 0, 1 };
         }
         // extend values
         COSArray extendValues = shadingType.getExtend();
         if (shadingType.getExtend() != null)
         {
             extend = new boolean[2];
-            extend[0] = ((COSBoolean)extendValues.get(0)).getValue();
-            extend[1] = ((COSBoolean)extendValues.get(1)).getValue();
+            extend[0] = ((COSBoolean) extendValues.get(0)).getValue();
+            extend[1] = ((COSBoolean) extendValues.get(1)).getValue();
         }
         else
         {
             // set default values
-            extend = new boolean[]{false,false};
+            extend = new boolean[] { false, false };
         }
         // calculate some constants to be used in getRaster
-        x1x0 = coords[3] - coords[0]; 
+        x1x0 = coords[3] - coords[0];
         y1y0 = coords[4] - coords[1];
         r1r0 = coords[5] - coords[2];
-        x1x0pow2 = Math.pow(x1x0,2);
-        y1y0pow2 = Math.pow(y1y0,2);
-        r0pow2 = Math.pow(coords[2],2);
+        x1x0pow2 = Math.pow(x1x0, 2);
+        y1y0pow2 = Math.pow(y1y0, 2);
+        r0pow2 = Math.pow(coords[2], 2);
         denom = x1x0pow2 + y1y0pow2 - Math.pow(r1r0, 2);
-        d1d0 = domain[1]-domain[0];
-        // TODO take a possible Background value into account
-        
+        d1d0 = domain[1] - domain[0];
+
+        // get background values if available
+        COSArray bg = shadingType3.getBackground();
+        if (bg != null)
+        {
+            background = bg.toFloatArray();
+        }
     }
     /**
      * {@inheritDoc}
      */
     public void dispose() 
     {
-        colorModel = null;
+        outputColorModel = null;
         shadingType = null;
         shadingColorSpace = null;
         shadingTinttransform = null;
@@ -197,7 +183,7 @@ public class RadialShadingContext implem
      */
     public ColorModel getColorModel() 
     {
-        return colorModel;
+        return outputColorModel;
     }
 
     /**
@@ -207,162 +193,225 @@ public class RadialShadingContext implem
     {
         // create writable raster
         WritableRaster raster = getColorModel().createCompatibleWritableRaster(w, h);
-        float inputValue;
-        boolean saveExtend0 = false;
-        boolean saveExtend1 = false;
-        int[] data = new int[w * h * 3];
-        for (int j = 0; j < h; j++) 
+        float inputValue = -1;
+        boolean useBackground;
+        int[] data = new int[w * h * 4];
+        for (int j = 0; j < h; j++)
         {
-            for (int i = 0; i < w; i++) 
+            for (int i = 0; i < w; i++)
             {
-                int index = (j * w + i) * 3;
+                useBackground = false;
                 float[] inputValues = calculateInputValues(x + i, y + j);
-                // choose 1 of the 2 values
-                if (inputValues[0] >= domain[0] && inputValues[0] <= domain[1])
+                if (Float.isNaN(inputValues[0]) && Float.isNaN(inputValues[1]))
                 {
-                    // both values are in the domain -> choose the larger one 
-                    if(inputValues[1] >= domain[0] && inputValues[1] <= domain[1])
+                    if (background != null)
                     {
-                        inputValue = Math.max(inputValues[0], inputValues[1]);
-                    } 
-                    // first value is in the domain, the second not -> choose first value
+                        useBackground = true;
+                    }
                     else
                     {
-                        inputValue = inputValues[0];
+                        continue;
                     }
                 }
                 else
                 {
-                    // first value is not in the domain, but the second -> choose second
value
-                    if(inputValues[1] >= domain[0] && inputValues[1] <= domain[1])
+                    // choose 1 of the 2 values
+                    if (inputValues[0] >= domain[0] && inputValues[0] <= domain[1])
                     {
-                        inputValue = inputValues[1];
+                        // both values are in the domain -> choose the larger one
+                        if (inputValues[1] >= domain[0] && inputValues[1] <=
domain[1])
+                        {
+                            inputValue = Math.max(inputValues[0], inputValues[1]);
+                        }
+                        // first value is in the domain, the second not -> choose first
value
+                        else
+                        {
+                            inputValue = inputValues[0];
+                        }
                     }
-                    // TODO
-                    // both are not in the domain -> choose the first as I don't know
it better
                     else
                     {
-                        inputValue = inputValues[0];
-                    }
-                }
-                // input value is out of range
-                if (inputValue < domain[0])
-                {
-                    // the shading has to be extended if extend[0] == true
-                    if (extend[0])
-                    {
-                        if (extend0Values == null)
+                        // first value is not in the domain, but the second -> choose
second value
+                        if (inputValues[1] >= domain[0] && inputValues[1] <=
domain[1])
                         {
-                            inputValue = domain[0];
-                            saveExtend0 = true;
+                            inputValue = inputValues[1];
                         }
+                        // both are not in the domain (is this correct, or is there some
miscalculation??)
                         else
                         {
-                            // use the chached values
-                            System.arraycopy(extend0Values, 0, data, index, 3);
-                            continue;
+                            // TODO don't know what to do in such cases. The following works
+                            // with the given examples
+                            // choose the smaller if extend[0] is set to true
+                            if (extend[0])
+                            {
+                                inputValue = Math.min(inputValues[0], inputValues[1]);
+                            }
+                            // choose the bigger one in all other cases
+                            else
+                            {
+                                inputValue = Math.max(inputValues[0], inputValues[1]);
+                            }
                         }
                     }
-                    else 
-                    {
-                        continue;
-                    }
-                }
-                // input value is out of range
-                else if (inputValue > domain[1])
-                {
-                    // the shading has to be extended if extend[1] == true
-                    if (extend[1])
+                    // input value is out of range
+                    if (inputValue > domain[1])
                     {
-                        if (extend1Values == null)
+                        // the shading has to be extended if extend[1] == true
+                        if (extend[1])
                         {
                             inputValue = domain[1];
-                            saveExtend1 = true;
                         }
                         else
                         {
-                            // use the chached values 
-                            System.arraycopy(extend1Values, 0, data, index, 3);
-                            continue;
+                            if (background != null)
+                            {
+                                useBackground = true;
+                            }
+                            else
+                            {
+                                continue;
+                            }
                         }
                     }
-                    else 
-                    {
-                        continue;
-                    }
-                }
-                float input = (float)(domain[0] + (d1d0*inputValue));
-                float[] values = null;
-                try 
-                {
-                    values = shadingType.evalFunction(input);
-                    // convert color values from shading colorspace to RGB 
-                    if (shadingColorSpace != null)
+                    // input value is out of range
+                    else if (inputValue < domain[0])
                     {
-                        if (shadingTinttransform != null)
+                        // the shading has to be extended if extend[0] == true
+                        if (extend[0])
                         {
-                            values = shadingTinttransform.eval(values);
+                            inputValue = domain[0];
+                        }
+                        else
+                        {
+                            if (background != null)
+                            {
+                                useBackground = true;
+                            }
+                            else
+                            {
+                                continue;
+                            }
                         }
-                        values = shadingColorSpace.toRGB(values);
                     }
                 }
-                catch (IOException exception) 
+                float[] values = null;
+                int index = (j * w + i) * 4;
+                if (useBackground)
                 {
-                    LOG.error("error while processing a function", exception);
+                    // use the given backgound color values
+                    values = background;
                 }
-                data[index] = (int)(values[0]*255);
-                data[index+1] = (int)(values[1]*255);
-                data[index+2] = (int)(values[2]*255);
-                if (saveExtend0)
+                else
                 {
-                    // chache values
-                    extend0Values = new int[3];
-                    System.arraycopy(data, index, extend0Values, 0, 3);
+                    try
+                    {
+                        float input = (float) (domain[0] + (d1d0 * inputValue));
+                        values = shadingType.evalFunction(input);
+                    }
+                    catch (IOException exception)
+                    {
+                        LOG.error("error while processing a function", exception);
+                    }
                 }
-                if (saveExtend1)
+                // convert color values from shading colorspace to RGB
+                if (shadingColorSpace != null)
                 {
-                    // chache values
-                    extend1Values = new int[3];
-                    System.arraycopy(data, index, extend1Values, 0, 3);
+                    if (shadingTinttransform != null)
+                    {
+                        try
+                        {
+                            values = shadingTinttransform.eval(values);
+                        }
+                        catch (IOException exception)
+                        {
+                            LOG.error("error while processing a function", exception);
+                        }
+                    }
+                    values = shadingColorSpace.toRGB(values);
                 }
+                data[index] = (int) (values[0] * 255);
+                data[index + 1] = (int) (values[1] * 255);
+                data[index + 2] = (int) (values[2] * 255);
+                data[index + 3] = 255;
             }
         }
         raster.setPixels(0, 0, w, h, data);
         return raster;
     }
 
-    private float[] calculateInputValues(int x, int y) 
+    private float[] calculateInputValues(int x, int y)
     {
-        
-        /** 
-         *  According to Adobes Technical Note #5600 we have to do the following 
-         *  
-         *  x0, y0, r0 defines the start circle
-         *  x1, y1, r1 defines the end circle
-         *  
-         *  The parametric equations for the center and radius of the gradient fill
-         *  circle moving between the start circle and the end circle as a function 
-         *  of s are as follows:
-         *  
-         *  xc(s) = x0 + s * (x1 - x0)
-         *  yc(s) = y0 + s * (y1 - y0)
-         *  r(s)  = r0 + s * (r1 - r0)
+
+        /**
+         * According to Adobes Technical Note #5600 we have to do the following
+         * 
+         * x0, y0, r0 defines the start circle x1, y1, r1 defines the end circle
+         * 
+         * The parametric equations for the center and radius of the gradient fill circle
moving between the start
+         * circle and the end circle as a function of s are as follows:
+         * 
+         * xc(s) = x0 + s * (x1 - x0) yc(s) = y0 + s * (y1 - y0) r(s) = r0 + s * (r1 - r0)
+         * 
+         * Given a geometric coordinate position (x, y) in or along the gradient fill, the
corresponding value of s can
+         * be determined by solving the quadratic constraint equation:
          * 
-         *  Given a geometric coordinate position (x, y) in or along the gradient fill, 
-         *  the corresponding value of s can be determined by solving the quadratic 
-         *  constraint equation:
-         *  
-         *  [x - xc(s)]2 + [y - yc(s)]2 = [r(s)]2
-         *  
-         *  The following code calculates the 2 possible values of s
+         * [x - xc(s)]2 + [y - yc(s)]2 = [r(s)]2
+         * 
+         * The following code calculates the 2 possible values of s
          */
+        double p = -(x - coords[0]) * x1x0 - (y - coords[1]) * y1y0 - coords[2] * r1r0;
+        double q = (Math.pow(x - coords[0], 2) + Math.pow(y - coords[1], 2) - r0pow2);
+        double root = Math.sqrt(p * p - denom * q);
+        float root1 = (float) ((-p + root) / denom);
+        float root2 = (float) ((-p - root) / denom);
+        if (denom < 0)
+        {
+            return new float[] { root1, root2 };
+        }
+        else
+        {
+            return new float[] { root2, root1 };
+        }
+    }
+
+    /**
+     * Returns the coords values.
+     * 
+     * @return the coords values as array
+     */
+    public float[] getCoords() 
+    {
+        return coords;
+    }
+        
+    /**
+     * Returns the domain values.
+     * 
+     * @return the domain values as array
+     */
+    public float[] getDomain() 
+    {
+        return domain;
+    }
         
-        float[] values = new float[2];
-        double p = (-0.25)*((x - coords[0])*x1x0 + (y - coords[1])*y1y0 - r1r0) / denom;
-        double q = (Math.pow(x - coords[0],2) + Math.pow(y - coords[1],2) - r0pow2) / denom;
-        double root = Math.sqrt(Math.pow(p , 2) - q);
-        values[0] = (float)((-1)*p + root);
-        values[1] = (float)((-1)*p - root);
-        return values;
+    /**
+     * Returns the extend values.
+     * 
+     * @return the extend values as array
+     */
+    public boolean[] getExtend() 
+    {
+        return extend;
+    }
+    
+    /**
+     * Returns the function used for the shading tint transformation.
+     * 
+     * @return the shading tint transformation function
+     */
+    public PDFunction getShadingTintTransform() 
+    {
+        return shadingTinttransform;
     }
+
 }



Mime
View raw message