From: cristy <urban-warrior@git.imagemagick.org>
Date: Thu, 4 Aug 2011 19:09:38 +0000 (+0000)
Subject: (no commit message)
X-Git-Tag: 7.0.1-0~7233
X-Git-Url: https://granicus.if.org/sourcecode?a=commitdiff_plain;h=7cb21986cf889bdf4ae92e5338ab4ff3a733ffdb;p=imagemagick

---

diff --git a/MagickCore/resize.c b/MagickCore/resize.c
index 969289c91..52c288630 100644
--- a/MagickCore/resize.c
+++ b/MagickCore/resize.c
@@ -2839,16 +2839,21 @@ MagickExport Image *ScaleImage(const Image *image,const size_t columns,
     next_row,
     proceed;
 
-  PixelInfo
-    pixel,
+  MagickRealType
+    alpha,
+    gamma,
+    pixel[MaxPixelChannels],
     *scale_scanline,
     *scanline,
     *x_vector,
-    *y_vector,
-    zero;
+    *y_vector;
 
-  MagickRealType
-    alpha;
+  PixelChannel
+    channel;
+
+  PixelTrait
+    scale_traits,
+    traits;
 
   PointInfo
     scale,
@@ -2858,6 +2863,7 @@ MagickExport Image *ScaleImage(const Image *image,const size_t columns,
     i;
 
   ssize_t
+    n,
     number_rows,
     y;
 
@@ -2886,20 +2892,20 @@ MagickExport Image *ScaleImage(const Image *image,const size_t columns,
   /*
     Allocate memory.
   */
-  x_vector=(PixelInfo *) AcquireQuantumMemory((size_t) image->columns,
-    sizeof(*x_vector));
+  x_vector=(MagickRealType *) AcquireQuantumMemory((size_t) image->columns,
+    GetPixelChannels(image)*sizeof(*x_vector));
   scanline=x_vector;
   if (image->rows != scale_image->rows)
-    scanline=(PixelInfo *) AcquireQuantumMemory((size_t) image->columns,
-      sizeof(*scanline));
-  scale_scanline=(PixelInfo *) AcquireQuantumMemory((size_t)
-    scale_image->columns,sizeof(*scale_scanline));
-  y_vector=(PixelInfo *) AcquireQuantumMemory((size_t) image->columns,
-    sizeof(*y_vector));
-  if ((scanline == (PixelInfo *) NULL) ||
-      (scale_scanline == (PixelInfo *) NULL) ||
-      (x_vector == (PixelInfo *) NULL) ||
-      (y_vector == (PixelInfo *) NULL))
+    scanline=(MagickRealType *) AcquireQuantumMemory((size_t) image->columns,
+      GetPixelChannels(image)*sizeof(*scanline));
+  scale_scanline=(MagickRealType *) AcquireQuantumMemory((size_t)
+    scale_image->columns,GetPixelChannels(scale_image)*sizeof(*scale_scanline));
+  y_vector=(MagickRealType *) AcquireQuantumMemory((size_t) image->columns,
+    GetPixelChannels(image)*sizeof(*y_vector));
+  if ((scanline == (MagickRealType *) NULL) ||
+      (scale_scanline == (MagickRealType *) NULL) ||
+      (x_vector == (MagickRealType *) NULL) ||
+      (y_vector == (MagickRealType *) NULL))
     {
       scale_image=DestroyImage(scale_image);
       ThrowImageException(ResourceLimitError,"MemoryAllocationFailed");
@@ -2911,11 +2917,9 @@ MagickExport Image *ScaleImage(const Image *image,const size_t columns,
   next_row=MagickTrue;
   span.y=1.0;
   scale.y=(double) scale_image->rows/(double) image->rows;
-  (void) ResetMagickMemory(y_vector,0,(size_t) image->columns*
-    sizeof(*y_vector));
-  GetPixelInfo(image,&pixel);
-  (void) ResetMagickMemory(&zero,0,sizeof(zero));
-  i=0;
+  for (i=0; i < (ssize_t) (GetPixelChannels(image)*image->columns); i++)
+    y_vector[i]=0.0;
+  n=0;
   image_view=AcquireCacheView(image);
   scale_view=AcquireCacheView(scale_image);
   for (y=0; y < (ssize_t) scale_image->rows; y++)
@@ -2923,10 +2927,6 @@ MagickExport Image *ScaleImage(const Image *image,const size_t columns,
     register const Quantum
       *restrict p;
 
-    register PixelInfo
-      *restrict s,
-      *restrict t;
-
     register Quantum
       *restrict q;
 
@@ -2943,21 +2943,23 @@ MagickExport Image *ScaleImage(const Image *image,const size_t columns,
         /*
           Read a new scanline.
         */
-        p=GetCacheViewVirtualPixels(image_view,0,i++,image->columns,1,
+        p=GetCacheViewVirtualPixels(image_view,0,n++,image->columns,1,
           exception);
         if (p == (const Quantum *) NULL)
           break;
         for (x=0; x < (ssize_t) image->columns; x++)
         {
-          if (image->matte != MagickFalse)
+          for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
+          {
+            traits=GetPixelChannelMapTraits(image,(PixelChannel) i);
+            if ((traits & BlendPixelTrait) == 0)
+              {
+                x_vector[x*GetPixelChannels(image)+i]=(MagickRealType) p[i];
+                continue;
+              }
             alpha=QuantumScale*GetPixelAlpha(image,p);
-          x_vector[x].red=(MagickRealType) (alpha*GetPixelRed(image,p));
-          x_vector[x].green=(MagickRealType) (alpha*GetPixelGreen(image,p));
-          x_vector[x].blue=(MagickRealType) (alpha*GetPixelBlue(image,p));
-          if (image->matte != MagickFalse)
-            x_vector[x].alpha=(MagickRealType) GetPixelAlpha(image,p);
-          if (image->colorspace == CMYKColorspace)
-            x_vector[x].black=(MagickRealType) (alpha*GetPixelBlack(image,p));
+            x_vector[x*GetPixelChannels(image)+i]=alpha*p[i];
+          }
           p+=GetPixelChannels(image);
         }
       }
@@ -2974,41 +2976,32 @@ MagickExport Image *ScaleImage(const Image *image,const size_t columns,
               /*
                 Read a new scanline.
               */
-              p=GetCacheViewVirtualPixels(image_view,0,i++,image->columns,1,
+              p=GetCacheViewVirtualPixels(image_view,0,n++,image->columns,1,
                 exception);
               if (p == (const Quantum *) NULL)
                 break;
               for (x=0; x < (ssize_t) image->columns; x++)
               {
-                if (image->matte != MagickFalse)
-                  alpha=QuantumScale*
-                    GetPixelAlpha(image,p);
-                x_vector[x].red=(MagickRealType) (alpha*
-                  GetPixelRed(image,p));
-                x_vector[x].green=(MagickRealType) (alpha*
-                  GetPixelGreen(image,p));
-                x_vector[x].blue=(MagickRealType) (alpha*
-                  GetPixelBlue(image,p));
-                if (image->colorspace == CMYKColorspace)
-                  x_vector[x].black=(MagickRealType) (alpha*
-                    GetPixelBlack(image,p));
-                if (image->matte != MagickFalse)
-                  x_vector[x].alpha=(MagickRealType)
-                    GetPixelAlpha(image,p);
+                for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
+                {
+                  traits=GetPixelChannelMapTraits(image,(PixelChannel) i);
+                  if ((traits & BlendPixelTrait) == 0)
+                    {
+                      x_vector[x*GetPixelChannels(image)+i]=(MagickRealType)
+                        p[i];
+                      continue;
+                    }
+                  alpha=QuantumScale*GetPixelAlpha(image,p);
+                  x_vector[x*GetPixelChannels(image)+i]=alpha*p[i];
+                }
                 p+=GetPixelChannels(image);
               }
               number_rows++;
             }
           for (x=0; x < (ssize_t) image->columns; x++)
-          {
-            y_vector[x].red+=scale.y*x_vector[x].red;
-            y_vector[x].green+=scale.y*x_vector[x].green;
-            y_vector[x].blue+=scale.y*x_vector[x].blue;
-            if (scale_image->colorspace == CMYKColorspace)
-              y_vector[x].black+=scale.y*x_vector[x].black;
-            if (scale_image->matte != MagickFalse)
-              y_vector[x].alpha+=scale.y*x_vector[x].alpha;
-          }
+            for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
+              y_vector[x*GetPixelChannels(image)+i]+=scale.y*
+                x_vector[x*GetPixelChannels(image)+i];
           span.y-=scale.y;
           scale.y=(double) scale_image->rows/(double) image->rows;
           next_row=MagickTrue;
@@ -3018,46 +3011,37 @@ MagickExport Image *ScaleImage(const Image *image,const size_t columns,
             /*
               Read a new scanline.
             */
-            p=GetCacheViewVirtualPixels(image_view,0,i++,image->columns,1,
+            p=GetCacheViewVirtualPixels(image_view,0,n++,image->columns,1,
               exception);
             if (p == (const Quantum *) NULL)
               break;
             for (x=0; x < (ssize_t) image->columns; x++)
             {
-              if (image->matte != MagickFalse)
+              for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
+              {
+                traits=GetPixelChannelMapTraits(image,(PixelChannel) i);
+                if ((traits & BlendPixelTrait) == 0)
+                  {
+                    x_vector[x*GetPixelChannels(image)+i]=(MagickRealType) p[i];
+                    continue;
+                  }
                 alpha=QuantumScale*GetPixelAlpha(image,p);
-              x_vector[x].red=(MagickRealType) (alpha*GetPixelRed(image,p));
-              x_vector[x].green=(MagickRealType) (alpha*GetPixelGreen(image,p));
-              x_vector[x].blue=(MagickRealType) (alpha*GetPixelBlue(image,p));
-              if (image->colorspace == CMYKColorspace)
-                x_vector[x].black=(MagickRealType) (alpha*
-                  GetPixelBlack(image,p));
-              if (image->matte != MagickFalse)
-                x_vector[x].alpha=(MagickRealType) GetPixelAlpha(image,p);
+                x_vector[x*GetPixelChannels(image)+i]=alpha*p[i];
+              }
               p+=GetPixelChannels(image);
             }
             number_rows++;
             next_row=MagickFalse;
           }
-        s=scanline;
         for (x=0; x < (ssize_t) image->columns; x++)
         {
-          pixel.red=y_vector[x].red+span.y*x_vector[x].red;
-          pixel.green=y_vector[x].green+span.y*x_vector[x].green;
-          pixel.blue=y_vector[x].blue+span.y*x_vector[x].blue;
-          if (image->colorspace == CMYKColorspace)
-            pixel.black=y_vector[x].black+span.y*x_vector[x].black;
-          if (image->matte != MagickFalse)
-            pixel.alpha=y_vector[x].alpha+span.y*x_vector[x].alpha;
-          s->red=pixel.red;
-          s->green=pixel.green;
-          s->blue=pixel.blue;
-          if (scale_image->colorspace == CMYKColorspace)
-            s->black=pixel.black;
-          if (scale_image->matte != MagickFalse)
-            s->alpha=pixel.alpha;
-          s++;
-          y_vector[x]=zero;
+          for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
+          {
+            pixel[i]=y_vector[x*GetPixelChannels(image)+i]+span.y*
+              x_vector[x*GetPixelChannels(image)+i];
+            scanline[x*GetPixelChannels(image)+i]=pixel[i];
+            y_vector[x*GetPixelChannels(image)+i]=0.0;
+          }
         }
         scale.y-=span.y;
         if (scale.y <= 0)
@@ -3072,33 +3056,45 @@ MagickExport Image *ScaleImage(const Image *image,const size_t columns,
         /*
           Transfer scanline to scaled image.
         */
-        s=scanline;
         for (x=0; x < (ssize_t) scale_image->columns; x++)
         {
-          if (scale_image->matte != MagickFalse)
-            alpha=QuantumScale*s->alpha;
-          alpha=1.0/(fabs(alpha) <= MagickEpsilon ? 1.0 : alpha);
-          SetPixelRed(scale_image,ClampToQuantum(alpha*s->red),q);
-          SetPixelGreen(scale_image,ClampToQuantum(alpha*s->green),q);
-          SetPixelBlue(scale_image,ClampToQuantum(alpha*s->blue),q);
-          if (scale_image->colorspace == CMYKColorspace)
-            SetPixelBlack(scale_image,ClampToQuantum(alpha*s->black),q);
-          if (scale_image->matte != MagickFalse)
-            SetPixelAlpha(scale_image,ClampToQuantum(s->alpha),q);
+          for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
+          {
+            traits=GetPixelChannelMapTraits(image,(PixelChannel) i);
+            if (traits == UndefinedPixelTrait)
+              continue;
+            channel=GetPixelChannelMapChannel(image,(PixelChannel) i);
+            scale_traits=GetPixelChannelMapTraits(scale_image,channel);
+            if (scale_traits == UndefinedPixelTrait)
+              continue;
+            if ((scale_traits & BlendPixelTrait) == 0)
+              {
+                q[channel]=ClampToQuantum(scanline[x*
+                  GetPixelChannels(image)+i]);
+                continue;
+              }
+            alpha=QuantumScale*scanline[x*GetPixelChannels(image)+
+              GetPixelChannelMapChannel(image,AlphaPixelChannel)];
+            gamma=1.0/(fabs((double) alpha) <= MagickEpsilon ? 1.0 : alpha);
+            q[channel]=ClampToQuantum(gamma*scanline[x*
+              GetPixelChannels(image)+i]);
+          }
           q+=GetPixelChannels(scale_image);
-          s++;
         }
       }
     else
       {
+        ssize_t
+          n;
+
         /*
           Scale X direction.
         */
-        pixel=zero;
         next_column=MagickFalse;
+        n=0;
         span.x=1.0;
-        s=scanline;
-        t=scale_scanline;
+        for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
+          pixel[i]=0.0;
         for (x=0; x < (ssize_t) image->columns; x++)
         {
           scale.x=(double) scale_image->columns/(double) image->columns;
@@ -3106,23 +3102,15 @@ MagickExport Image *ScaleImage(const Image *image,const size_t columns,
           {
             if (next_column != MagickFalse)
               {
-                pixel=zero;
-                t++;
+                for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
+                  pixel[i]=0.0;
+                n++;
               }
-            pixel.red+=span.x*s->red;
-            pixel.green+=span.x*s->green;
-            pixel.blue+=span.x*s->blue;
-            if (scale_image->colorspace == CMYKColorspace)
-              pixel.black+=span.x*s->black;
-            if (image->matte != MagickFalse)
-              pixel.alpha+=span.x*s->alpha;
-            t->red=pixel.red;
-            t->green=pixel.green;
-            t->blue=pixel.blue;
-            if (scale_image->colorspace == CMYKColorspace)
-              t->black=pixel.black;
-            if (scale_image->matte != MagickFalse)
-              t->alpha=pixel.alpha;
+            for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
+            {
+              pixel[i]+=span.x*scanline[x*GetPixelChannels(image)+i];
+              scale_scanline[n*GetPixelChannels(scale_image)+i]=pixel[i];
+            }
             scale.x-=span.x;
             span.x=1.0;
             next_column=MagickTrue;
@@ -3131,60 +3119,53 @@ MagickExport Image *ScaleImage(const Image *image,const size_t columns,
           {
             if (next_column != MagickFalse)
               {
-                pixel=zero;
+                for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
+                  pixel[i]=0.0;
+                n++;
                 next_column=MagickFalse;
-                t++;
               }
-            pixel.red+=scale.x*s->red;
-            pixel.green+=scale.x*s->green;
-            pixel.blue+=scale.x*s->blue;
-            if (scale_image->colorspace == CMYKColorspace)
-              pixel.black+=scale.x*s->black;
-            if (scale_image->matte != MagickFalse)
-              pixel.alpha+=scale.x*s->alpha;
+            for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
+              pixel[i]+=scale.x*scanline[x*GetPixelChannels(image)+i];
             span.x-=scale.x;
           }
-        s++;
       }
       if (span.x > 0)
         {
-          s--;
-          pixel.red+=span.x*s->red;
-          pixel.green+=span.x*s->green;
-          pixel.blue+=span.x*s->blue;
-          if (scale_image->colorspace == CMYKColorspace)
-            pixel.black+=span.x*s->black;
-          if (scale_image->matte != MagickFalse)
-            pixel.alpha+=span.x*s->alpha;
+          for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
+            pixel[i]+=span.x*scanline[(x-1)*GetPixelChannels(image)+i];
         }
       if ((next_column == MagickFalse) &&
-          ((ssize_t) (t-scale_scanline) < (ssize_t) scale_image->columns))
+          ((ssize_t) n < (ssize_t) scale_image->columns))
         {
-          t->red=pixel.red;
-          t->green=pixel.green;
-          t->blue=pixel.blue;
-          if (scale_image->colorspace == CMYKColorspace)
-            t->black=pixel.black;
-          if (scale_image->matte != MagickFalse)
-            t->alpha=pixel.alpha;
+          for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
+            scale_scanline[n*GetPixelChannels(image)+i]=pixel[i];
         }
       /*
         Transfer scanline to scaled image.
       */
-      t=scale_scanline;
       for (x=0; x < (ssize_t) scale_image->columns; x++)
       {
-        if (scale_image->matte != MagickFalse)
-          alpha=QuantumScale*s->alpha;
-        alpha=1.0/(fabs(alpha) <= MagickEpsilon ? 1.0 : alpha);
-        SetPixelRed(scale_image,ClampToQuantum(alpha*t->red),q);
-        SetPixelGreen(scale_image,ClampToQuantum(alpha*t->green),q);
-        SetPixelBlue(scale_image,ClampToQuantum(alpha*t->blue),q);
-        if (scale_image->colorspace == CMYKColorspace)
-          SetPixelBlack(scale_image,ClampToQuantum(alpha*t->black),q);
-        if (scale_image->matte != MagickFalse)
-          SetPixelAlpha(scale_image,ClampToQuantum(t->alpha),q);
-        t++;
+        for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
+        {
+          traits=GetPixelChannelMapTraits(image,(PixelChannel) i);
+          if (traits == UndefinedPixelTrait)
+            continue;
+          channel=GetPixelChannelMapChannel(image,(PixelChannel) i);
+          scale_traits=GetPixelChannelMapTraits(scale_image,channel);
+          if (scale_traits == UndefinedPixelTrait)
+            continue;
+          if ((scale_traits & BlendPixelTrait) == 0)
+            {
+              q[channel]=ClampToQuantum(scale_scanline[x*
+                GetPixelChannels(scale_image)+i]);
+              continue;
+            }
+          alpha=QuantumScale*scanline[x*GetPixelChannels(image)+
+            GetPixelChannelMapChannel(image,AlphaPixelChannel)];
+          gamma=1.0/(fabs((double) alpha) <= MagickEpsilon ? 1.0 : alpha);
+          q[channel]=ClampToQuantum(gamma*scale_scanline[
+            GetPixelChannels(scale_image)+i]);
+        }
         q+=GetPixelChannels(scale_image);
       }
     }
@@ -3200,11 +3181,11 @@ MagickExport Image *ScaleImage(const Image *image,const size_t columns,
   /*
     Free allocated memory.
   */
-  y_vector=(PixelInfo *) RelinquishMagickMemory(y_vector);
-  scale_scanline=(PixelInfo *) RelinquishMagickMemory(scale_scanline);
+  y_vector=(MagickRealType *) RelinquishMagickMemory(y_vector);
+  scale_scanline=(MagickRealType *) RelinquishMagickMemory(scale_scanline);
   if (scale_image->rows != image->rows)
-    scanline=(PixelInfo *) RelinquishMagickMemory(scanline);
-  x_vector=(PixelInfo *) RelinquishMagickMemory(x_vector);
+    scanline=(MagickRealType *) RelinquishMagickMemory(scanline);
+  x_vector=(MagickRealType *) RelinquishMagickMemory(x_vector);
   scale_image->type=image->type;
   return(scale_image);
 }