(no commit message)

diff --git a/ChangeLog b/ChangeLog
index 5e90840ebdb7aa2945423d2cd762ab7c0d9ba8ae..ce182713189fb22de8f0de6743bc1475d61912cd 100644 (file)
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,6 @@
+2011-03-10  6.6.8-4 Cristy  <quetzlzacatenango@image...>
+  * Fx is a mathematicals function.  Do not treat transparency as black.
+
 2011-03-10  6.6.8-3 Cristy  <quetzlzacatenango@image...>
   * New version 6.6.8-3.
 

diff --git a/magick/fx.c b/magick/fx.c
index d41e50e7be52881f01a9eea02b7ab18e8b9ade11..6e3873212a8f60572cbdf36817d46a1920e346f0 100644 (file)
--- a/magick/fx.c
+++ b/magick/fx.c
@@ -183,6 +183,7 @@ MagickExport FxInfo *AcquireFxInfo(const Image *image,const char *expression)
     fx_info->resample_filter[i]=AcquireResampleFilter(GetImageFromList(
       fx_info->images,i),fx_info->exception);
     SetResampleFilter(fx_info->resample_filter[i],PointFilter,1.0);
+    SetResampleFilterMatte(fx_info->resample_filter[i],MagickFalse);
   }
   fx_info->random_info=AcquireRandomInfo();
   fx_info->expression=ConstantString(expression);

diff --git a/magick/resample.c b/magick/resample.c
index 573f5d71083dd894da2fa0b5f3b3068ad2f23e54..537715da47b085009f9ce4c0c348f232e909b0fb 100644 (file)
--- a/magick/resample.c
+++ b/magick/resample.c
@@ -92,6 +92,12 @@ struct _ResampleFilter
   Image
     *image;
 
+  MagickBooleanType
+    matte;
+
+  ColorspaceType
+    colorspace;
+
   ExceptionInfo
     *exception;
 
@@ -218,9 +224,10 @@ MagickExport ResampleFilter *AcquireResampleFilter(const Image *image,
     ThrowFatalException(ResourceLimitFatalError,"MemoryAllocationFailed");
   (void) ResetMagickMemory(resample_filter,0,sizeof(*resample_filter));
 
+  resample_filter->exception=exception;
   resample_filter->image=ReferenceImage((Image *) image);
+  resample_filter->matte=image->matte;
   resample_filter->view=AcquireCacheView(resample_filter->image);
-  resample_filter->exception=exception;
 
   resample_filter->debug=IsEventLogging();
   resample_filter->signature=MagickSignature;
@@ -437,13 +444,13 @@ static MagickBooleanType InterpolateResampleFilter(
         GetMagickPixelPacket(resample_filter->image,pixels+i);
         SetMagickPixelPacket(resample_filter->image,p,indexes+i,pixels+i);
         alpha[i]=1.0;
-        if (resample_filter->image->matte != MagickFalse)
+        if (resample_filter->matte != MagickFalse)
           {
             alpha[i]=QuantumScale*((MagickRealType) GetAlphaPixelComponent(p));
             pixels[i].red*=alpha[i];
             pixels[i].green*=alpha[i];
             pixels[i].blue*=alpha[i];
-            if (resample_filter->image->colorspace == CMYKColorspace)
+            if (pixels[i].colorspace == CMYKColorspace)
               pixels[i].index*=alpha[i];
           }
         gamma=alpha[i];
@@ -452,7 +459,7 @@ static MagickBooleanType InterpolateResampleFilter(
         pixel->green+=gamma*0.0625*pixels[i].green;
         pixel->blue+=gamma*0.0625*pixels[i].blue;
         pixel->opacity+=0.0625*pixels[i].opacity;
-        if (resample_filter->image->colorspace == CMYKColorspace)
+        if (pixel->colorspace == CMYKColorspace)
           pixel->index+=gamma*0.0625*pixels[i].index;
         p++;
       }
@@ -483,13 +490,13 @@ static MagickBooleanType InterpolateResampleFilter(
         GetMagickPixelPacket(resample_filter->image,pixels+i);
         SetMagickPixelPacket(resample_filter->image,p,indexes+i,pixels+i);
         alpha[i]=1.0;
-        if (resample_filter->image->matte != MagickFalse)
+        if (resample_filter->matte != MagickFalse)
           {
             alpha[i]=QuantumScale*((MagickRealType) GetAlphaPixelComponent(p));
             pixels[i].red*=alpha[i];
             pixels[i].green*=alpha[i];
             pixels[i].blue*=alpha[i];
-            if (resample_filter->image->colorspace == CMYKColorspace)
+            if (pixels[i].colorspace == CMYKColorspace)
               pixels[i].index*=alpha[i];
           }
         p++;
@@ -531,7 +538,7 @@ static MagickBooleanType InterpolateResampleFilter(
         pixels[i].opacity=(MagickRealType) p[i].opacity;
         alpha[i]=1.0;
       }
-      if (resample_filter->image->matte != MagickFalse)
+      if (resample_filter->matte != MagickFalse)
         for (i=0; i < 4L; i++)
         {
           alpha[i]=QuantumScale*((MagickRealType) QuantumRange-p[i].opacity);
@@ -543,7 +550,7 @@ static MagickBooleanType InterpolateResampleFilter(
         for (i=0; i < 4L; i++)
         {
           pixels[i].index=(MagickRealType) indexes[i];
-          if (resample_filter->image->colorspace == CMYKColorspace)
+          if (pixels[i].colorspace == CMYKColorspace)
             pixels[i].index*=alpha[i];
         }
       delta.x=x-floor(x);
@@ -564,7 +571,7 @@ static MagickBooleanType InterpolateResampleFilter(
       pixel->opacity=(epsilon.y*(epsilon.x*pixels[0].opacity+delta.x*
         pixels[1].opacity)+delta.y*(epsilon.x*pixels[2].opacity+delta.x*
         pixels[3].opacity));
-      if (resample_filter->image->colorspace == CMYKColorspace)
+      if (pixel->colorspace == CMYKColorspace)
         pixel->index=gamma*(epsilon.y*(epsilon.x*pixels[0].index+delta.x*
           pixels[1].index)+delta.y*(epsilon.x*pixels[2].index+delta.x*
           pixels[3].index));
@@ -657,13 +664,13 @@ static MagickBooleanType InterpolateResampleFilter(
         GetMagickPixelPacket(resample_filter->image,pixels+i);
         SetMagickPixelPacket(resample_filter->image,p,indexes+i,pixels+i);
         alpha[i]=1.0;
-        if (resample_filter->image->matte != MagickFalse)
+        if (resample_filter->matte != MagickFalse)
           {
             alpha[i]=QuantumScale*((MagickRealType) GetAlphaPixelComponent(p));
             pixels[i].red*=alpha[i];
             pixels[i].green*=alpha[i];
             pixels[i].blue*=alpha[i];
-            if (resample_filter->image->colorspace == CMYKColorspace)
+            if (pixels[i].colorspace == CMYKColorspace)
               pixels[i].index*=alpha[i];
           }
         p++;
@@ -693,7 +700,7 @@ static MagickBooleanType InterpolateResampleFilter(
                 pixels[3].blue,pixels[0].blue);
               pixel->opacity=gamma*MeshInterpolate(&delta,pixels[2].opacity,
                 pixels[3].opacity,pixels[0].opacity);
-              if (resample_filter->image->colorspace == CMYKColorspace)
+              if (pixel->colorspace == CMYKColorspace)
                 pixel->index=gamma*MeshInterpolate(&delta,pixels[2].index,
                   pixels[3].index,pixels[0].index);
             }
@@ -713,7 +720,7 @@ static MagickBooleanType InterpolateResampleFilter(
                 pixels[0].blue,pixels[3].blue);
               pixel->opacity=gamma*MeshInterpolate(&delta,pixels[1].opacity,
                 pixels[0].opacity,pixels[3].opacity);
-              if (resample_filter->image->colorspace == CMYKColorspace)
+              if (pixel->colorspace == CMYKColorspace)
                 pixel->index=gamma*MeshInterpolate(&delta,pixels[1].index,
                   pixels[0].index,pixels[3].index);
             }
@@ -738,7 +745,7 @@ static MagickBooleanType InterpolateResampleFilter(
                 pixels[1].blue,pixels[2].blue);
               pixel->opacity=gamma*MeshInterpolate(&delta,pixels[0].opacity,
                 pixels[1].opacity,pixels[2].opacity);
-              if (resample_filter->image->colorspace == CMYKColorspace)
+              if (pixel->colorspace == CMYKColorspace)
                 pixel->index=gamma*MeshInterpolate(&delta,pixels[0].index,
                   pixels[1].index,pixels[2].index);
             }
@@ -759,7 +766,7 @@ static MagickBooleanType InterpolateResampleFilter(
                 pixels[2].blue,pixels[1].blue);
               pixel->opacity=gamma*MeshInterpolate(&delta,pixels[3].opacity,
                 pixels[2].opacity,pixels[1].opacity);
-              if (resample_filter->image->colorspace == CMYKColorspace)
+              if (pixel->colorspace == CMYKColorspace)
                 pixel->index=gamma*MeshInterpolate(&delta,pixels[3].index,
                   pixels[2].index,pixels[1].index);
             }
@@ -820,14 +827,14 @@ static MagickBooleanType InterpolateResampleFilter(
           GetMagickPixelPacket(resample_filter->image,pixels+n);
           SetMagickPixelPacket(resample_filter->image,p,indexes+n,pixels+n);
           alpha[n]=1.0;
-          if (resample_filter->image->matte != MagickFalse)
+          if (resample_filter->matte != MagickFalse)
             {
               alpha[n]=QuantumScale*((MagickRealType)
                 GetAlphaPixelComponent(p));
               pixels[n].red*=alpha[n];
               pixels[n].green*=alpha[n];
               pixels[n].blue*=alpha[n];
-              if (resample_filter->image->colorspace == CMYKColorspace)
+              if (pixels[i].colorspace == CMYKColorspace)
                 pixels[n].index*=alpha[n];
             }
           dx=CubicWeightingFunction(delta.x-(MagickRealType) j);
@@ -836,9 +843,9 @@ static MagickBooleanType InterpolateResampleFilter(
           pixel->red+=gamma*dx*dy*pixels[n].red;
           pixel->green+=gamma*dx*dy*pixels[n].green;
           pixel->blue+=gamma*dx*dy*pixels[n].blue;
-          if (resample_filter->image->matte != MagickFalse)
+          if (resample_filter->matte != MagickFalse)
             pixel->opacity+=dx*dy*pixels[n].opacity;
-          if (resample_filter->image->colorspace == CMYKColorspace)
+          if (pixel->colorspace == CMYKColorspace)
             pixel->index+=gamma*dx*dy*pixels[n].index;
           n++;
           p++;
@@ -1100,8 +1107,8 @@ MagickExport MagickBooleanType ResamplePixelColor(
   divisor_c = 0.0;
   divisor_m = 0.0;
   pixel->red = pixel->green = pixel->blue = 0.0;
-  if (resample_filter->image->matte != MagickFalse) pixel->opacity = 0.0;
-  if (resample_filter->image->colorspace == CMYKColorspace) pixel->index = 0.0;
+  if (resample_filter->matte != MagickFalse) pixel->opacity = 0.0;
+  if (pixel->colorspace == CMYKColorspace) pixel->index = 0.0;
 
   /*
     Determine the parellelogram bounding box fitted to the ellipse
@@ -1166,12 +1173,12 @@ MagickExport MagickBooleanType ResamplePixelColor(
         pixel->opacity  += weight*pixels->opacity;
         divisor_m += weight;
 
-        if (resample_filter->image->matte != MagickFalse)
+        if (resample_filter->matte != MagickFalse)
           weight *= QuantumScale*((MagickRealType)(QuantumRange-pixels->opacity));
         pixel->red   += weight*pixels->red;
         pixel->green += weight*pixels->green;
         pixel->blue  += weight*pixels->blue;
-        if (resample_filter->image->colorspace == CMYKColorspace)
+        if (pixel->colorspace == CMYKColorspace)
           pixel->index += weight*(*indexes);
         divisor_c += weight;
 
@@ -1226,7 +1233,7 @@ MagickExport MagickBooleanType ResamplePixelColor(
   pixel->red   = (MagickRealType) ClampToQuantum(divisor_c*pixel->red);
   pixel->green = (MagickRealType) ClampToQuantum(divisor_c*pixel->green);
   pixel->blue  = (MagickRealType) ClampToQuantum(divisor_c*pixel->blue);
-  if (resample_filter->image->colorspace == CMYKColorspace)
+  if (pixel->colorspace == CMYKColorspace)
     pixel->index = (MagickRealType) ClampToQuantum(divisor_c*pixel->index);
   return(MagickTrue);
 }
@@ -1922,8 +1929,8 @@ MagickExport void SetResampleFilter(ResampleFilter *resample_filter,
 %                                                                             %
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 %
-%  SetResampleFilterInterpolateMethod() changes the interpolation method
-%  associated with the specified resample filter.
+%  SetResampleFilterInterpolateMethod() sets the resample filter interpolation
+%  method.
 %
 %  The format of the SetResampleFilterInterpolateMethod method is:
 %
@@ -1943,13 +1950,48 @@ MagickExport MagickBooleanType SetResampleFilterInterpolateMethod(
   assert(resample_filter != (ResampleFilter *) NULL);
   assert(resample_filter->signature == MagickSignature);
   assert(resample_filter->image != (Image *) NULL);
-
   if (resample_filter->debug != MagickFalse)
     (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",
       resample_filter->image->filename);
-
   resample_filter->interpolate=method;
-
+  return(MagickTrue);
+}
+\f
+/*
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%                                                                             %
+%                                                                             %
+%                                                                             %
+%   S e t R e s a m p l e F i l t e r M a t t e                               %
+%                                                                             %
+%                                                                             %
+%                                                                             %
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%
+%  SetResampleFilterColorspace() sets the resample filter matte.
+%
+%  The format of the SetResampleFilterColorspace method is:
+%
+%      MagickBooleanType SetResampleFilterColorspace(
+%        ResampleFilter *resample_filter,const MagickBooleanType matte)
+%
+%  A description of each parameter follows:
+%
+%    o resample_filter: the resample filter.
+%
+%    o matte: the filter matte.
+%
+*/
+MagickExport MagickBooleanType SetResampleFilterMatte(
+  ResampleFilter *resample_filter,const MagickBooleanType matte)
+{
+  assert(resample_filter != (ResampleFilter *) NULL);
+  assert(resample_filter->signature == MagickSignature);
+  assert(resample_filter->image != (Image *) NULL);
+  if (resample_filter->debug != MagickFalse)
+    (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",
+      resample_filter->image->filename);
+  resample_filter->matte=matte;
   return(MagickTrue);
 }
 \f

diff --git a/magick/resample.h b/magick/resample.h
index e5c16de46fcca13f0d45ed1957157758233b6fd6..8e298bb9237046f1ead61c1d230e46b89f0e43ae 100644 (file)
--- a/magick/resample.h
+++ b/magick/resample.h
@@ -62,13 +62,13 @@ typedef enum
   SentinelFilter  /* a count of all the filters, not a real filter */
 } FilterTypes;
 
-/* Backward compatibility for the more correctly named Jinc Filter
-  Original sorce of this filter is from "zoom" but it refers to
-  a reference by Pratt, who does not actualy name the filter.
+/*
+  Backward compatibility for the more correctly named Jinc Filter.  Original
+  source of this filter is from "zoom" but it refers to a reference by Pratt,
+  who does not actualy name the filter.
 */
 #define BesselFilter JincFilter
 
-
 typedef enum
 {
   UndefinedInterpolatePixel,
@@ -90,6 +90,7 @@ extern MagickExport MagickBooleanType
     MagickPixelPacket *),
   SetResampleFilterInterpolateMethod(ResampleFilter *,
     const InterpolatePixelMethod),
+  SetResampleFilterMatte(ResampleFilter *,const MagickBooleanType),
   SetResampleFilterVirtualPixelMethod(ResampleFilter *,
     const VirtualPixelMethod);