]> granicus.if.org Git - imagemagick/blobdiff - MagickCore/pixel-accessor.h
projects / imagemagick / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
(no commit message)
[imagemagick] / MagickCore / pixel-accessor.h
diff --git a/MagickCore/pixel-accessor.h b/MagickCore/pixel-accessor.h
index 491a70f16589c4935f9ad236ff462782c6eb9763..a53128ca23347eef2ae0c5d7ff29a7a047f55fd7 100644 (file)
--- a/MagickCore/pixel-accessor.h
+++ b/MagickCore/pixel-accessor.h
@@ -31,18 +31,24 @@ extern "C" {
 
 #undef index
 
-static inline double CompandsRGB(const double intensity)
+static inline double InversesRGBCompandor(const double pixel)
 {
-  if (intensity <= 0.0031308)
-    return(intensity*12.92);
-  return(1.055*pow(intensity,1.0/2.4)-0.055);
+  if (pixel <= (0.04045*QuantumRange))
+    return(pixel/12.92);
+  return(QuantumRange*pow((QuantumScale*pixel+0.055)/1.055,2.4));
 }
 
-static inline double DecompandsRGB(const double intensity)
+static inline double sRGBCompandor(const double pixel)
 {
-  if (intensity <= 0.04045)
-    return(intensity/12.92);
-  return(pow((intensity+0.055)/1.055,2.4));
+  if (pixel <= (0.0031308*QuantumRange))
+    return(12.92*pixel);
+  return(QuantumRange*(1.055*pow(QuantumScale*pixel,1.0/2.4)-0.055));
+}
+
+static inline Quantum GetPixela(const Image *restrict image,
+  const Quantum *restrict pixel)
+{
+  return(pixel[image->channel_map[aPixelChannel].offset]);
 }
 
 static inline Quantum GetPixelAlpha(const Image *restrict image,
@@ -58,11 +64,17 @@ static inline PixelTrait GetPixelAlphaTraits(const Image *restrict image)
   return(image->channel_map[AlphaPixelChannel].traits);
 }
 
+static inline Quantum GetPixelb(const Image *restrict image,
+  const Quantum *restrict pixel)
+{
+  return(pixel[image->channel_map[bPixelChannel].offset]);
+}
+
 static inline Quantum GetPixelBlack(const Image *restrict image,
   const Quantum *restrict pixel)
 {
   if (image->channel_map[BlackPixelChannel].traits == UndefinedPixelTrait)
-    return(0);
+    return((Quantum) 0);
   return(pixel[image->channel_map[BlackPixelChannel].offset]);
 }
 
@@ -97,7 +109,7 @@ static inline Quantum GetPixelChannel(const Image *restrict image,
   const PixelChannel channel,const Quantum *restrict pixel)
 {
   if (image->channel_map[channel].traits == UndefinedPixelTrait)
-    return(0);
+    return((Quantum) 0);
   return(pixel[image->channel_map[channel].offset]);
 }
 
@@ -172,7 +184,7 @@ static inline Quantum GetPixelIndex(const Image *restrict image,
   const Quantum *restrict pixel)
 {
   if (image->channel_map[IndexPixelChannel].traits == UndefinedPixelTrait)
-    return(0);
+    return((Quantum) 0);
   return(pixel[image->channel_map[IndexPixelChannel].offset]);
 }
 
@@ -181,65 +193,58 @@ static inline PixelTrait GetPixelIndexTraits(const Image *restrict image)
   return(image->channel_map[IndexPixelChannel].traits);
 }
 
-static inline Quantum GetPixelInfoIntensity(
-  const PixelInfo *restrict pixel_info)
+static inline double GetPixelInfoChannel(const PixelInfo *restrict pixel_info,
+  const PixelChannel channel)
+{
+  switch (channel)
+  {
+    case RedPixelChannel: return(pixel_info->red);
+    case GreenPixelChannel: return(pixel_info->green);
+    case BluePixelChannel: return(pixel_info->blue);
+    case BlackPixelChannel: return(pixel_info->black);
+    case AlphaPixelChannel: return(pixel_info->alpha);
+    case IndexPixelChannel: return(pixel_info->index);
+    default: return(0.0);
+  }
+}
+
+static inline double GetPixelInfoIntensity(const PixelInfo *restrict pixel_info)
 {
   double
     blue,
     green,
     red;
 
+  if (pixel_info->colorspace == GRAYColorspace)
+    return(pixel_info->red);
   if (pixel_info->colorspace != sRGBColorspace)
-    {
-      red=pixel_info->red;
-      green=pixel_info->green;
-      blue=pixel_info->blue;
-    }
-  else
-    {
-      red=QuantumRange*DecompandsRGB(QuantumScale*pixel_info->red);
-      green=QuantumRange*DecompandsRGB(QuantumScale*pixel_info->green);
-      blue=QuantumRange*DecompandsRGB(QuantumScale*pixel_info->blue);
-    }
-#if !defined(MAGICKCORE_HDRI_SUPPORT)
-  return((Quantum) (0.298839*red+0.586811*green+0.114350*blue+0.5));
-#else
-  return((Quantum) (0.298839*red+0.586811*green+0.114350*blue));
-#endif
+    return(0.298839*pixel_info->red+0.586811*pixel_info->green+
+      0.114350*pixel_info->blue);
+  red=InversesRGBCompandor(pixel_info->red);
+  green=InversesRGBCompandor(pixel_info->green);
+  blue=InversesRGBCompandor(pixel_info->blue);
+  return(0.298839*red+0.586811*green+0.114350*blue);
 }
 
-static inline Quantum GetPixelInfoLuminance(
-  const PixelInfo *restrict pixel_info)
+static inline double GetPixelInfoLuminance(const PixelInfo *restrict pixel_info)
 {
   double
     blue,
     green,
     red;
 
-  Quantum
-    luminance;
-
+  if (pixel_info->colorspace == GRAYColorspace)
+    return(pixel_info->red);
   if (pixel_info->colorspace != sRGBColorspace)
-    {
-      red=pixel_info->red;
-      green=pixel_info->green;
-      blue=pixel_info->blue;
-    }
-  else
-    {
-      red=QuantumRange*DecompandsRGB(QuantumScale*pixel_info->red);
-      green=QuantumRange*DecompandsRGB(QuantumScale*pixel_info->green);
-      blue=QuantumRange*DecompandsRGB(QuantumScale*pixel_info->blue);
-    }
-#if !defined(MAGICKCORE_HDRI_SUPPORT)
-  luminance=(Quantum) (0.21267*red+0.71516*green+0.07217*blue+0.5);
-#else
-  luminance=(Quantum) (0.21267*red+0.71516*green+0.07217*blue);
-#endif
-  return((Quantum) luminance);
+    return(0.21267*pixel_info->red+0.71516*pixel_info->green+
+      0.07217*pixel_info->blue);
+  red=InversesRGBCompandor(pixel_info->red);
+  green=InversesRGBCompandor(pixel_info->green);
+  blue=InversesRGBCompandor(pixel_info->blue);
+  return(0.21267*red+0.71516*green+0.07217*blue);
 }
 
-static inline Quantum GetPixelIntensity(const Image *restrict image,
+static inline double GetPixelIntensity(const Image *restrict image,
   const Quantum *restrict pixel)
 {
   double
@@ -248,41 +253,27 @@ static inline Quantum GetPixelIntensity(const Image *restrict image,
     red;
 
   if (image->colorspace == GRAYColorspace)
-    return(pixel[image->channel_map[GrayPixelChannel].offset]);
+    return((double) pixel[image->channel_map[GrayPixelChannel].offset]);
   if (image->colorspace != sRGBColorspace)
-    {
-      red=(double) pixel[image->channel_map[RedPixelChannel].offset];
-      green=(double) pixel[image->channel_map[GreenPixelChannel].offset];
-      blue=(double) pixel[image->channel_map[BluePixelChannel].offset];
-    }
-  else
-    {
-      red=QuantumRange*DecompandsRGB(QuantumScale*
-        pixel[image->channel_map[RedPixelChannel].offset]);
-      green=QuantumRange*DecompandsRGB(QuantumScale*
-        pixel[image->channel_map[GreenPixelChannel].offset]);
-      blue=QuantumRange*DecompandsRGB(QuantumScale*
-        pixel[image->channel_map[BluePixelChannel].offset]);
-    }
-#if !defined(MAGICKCORE_HDRI_SUPPORT)
-  return((Quantum) (0.298839*red+0.586811*green+0.114350*blue+0.5));
-#else
-  {
-    double
-      alpha,
-      beta;
-
-    alpha=red-(double) green;
-    beta=green-(double) blue;
-    if ((fabs((double) alpha) <= MagickEpsilon) &&
-        (fabs(beta) <= MagickEpsilon))
-      return(red);
-    return((Quantum) (0.298839*red+0.586811*green+0.114350*blue));
-  }
-#endif
+    return(0.298839*pixel[image->channel_map[RedPixelChannel].offset]+
+      0.586811*pixel[image->channel_map[GreenPixelChannel].offset]+
+      0.114350*pixel[image->channel_map[BluePixelChannel].offset]);
+  red=InversesRGBCompandor((double)
+    pixel[image->channel_map[RedPixelChannel].offset]);
+  green=InversesRGBCompandor((double)
+    pixel[image->channel_map[GreenPixelChannel].offset]);
+  blue=InversesRGBCompandor((double)
+    pixel[image->channel_map[BluePixelChannel].offset]);
+  return(0.298839*red+0.586811*green+0.114350*blue);
+}
+
+static inline Quantum GetPixelL(const Image *restrict image,
+  const Quantum *restrict pixel)
+{
+  return(pixel[image->channel_map[LPixelChannel].offset]);
 }
 
-static inline Quantum GetPixelLuminance(const Image *restrict image,
+static inline double GetPixelLuminance(const Image *restrict image,
   const Quantum *restrict pixel)
 {
   double
@@ -290,26 +281,19 @@ static inline Quantum GetPixelLuminance(const Image *restrict image,
     green,
     red;
 
+  if (image->colorspace == GRAYColorspace)
+    return((double) pixel[image->channel_map[GrayPixelChannel].offset]);
   if (image->colorspace != sRGBColorspace)
-    {
-      red=(double) pixel[image->channel_map[RedPixelChannel].offset];
-      green=(double) pixel[image->channel_map[GreenPixelChannel].offset];
-      blue=(double) pixel[image->channel_map[BluePixelChannel].offset];
-    }
-  else
-    {
-      red=QuantumRange*DecompandsRGB(QuantumScale*
-        pixel[image->channel_map[RedPixelChannel].offset]);
-      green=QuantumRange*DecompandsRGB(QuantumScale*
-        pixel[image->channel_map[GreenPixelChannel].offset]);
-      blue=QuantumRange*DecompandsRGB(QuantumScale*
-        pixel[image->channel_map[BluePixelChannel].offset]);
-    }
-#if !defined(MAGICKCORE_HDRI_SUPPORT)
-  return((Quantum) (0.21267*red+0.71516*green+0.07217*blue+0.5));
-#else
-  return((Quantum) (0.21267*red+0.71516*green+0.07217*blue));
-#endif
+    return(0.298839*pixel[image->channel_map[RedPixelChannel].offset]+
+      0.586811*pixel[image->channel_map[GreenPixelChannel].offset]+
+      0.114350*pixel[image->channel_map[BluePixelChannel].offset]);
+  red=InversesRGBCompandor((double)
+    pixel[image->channel_map[RedPixelChannel].offset]);
+  green=InversesRGBCompandor((double)
+    pixel[image->channel_map[GreenPixelChannel].offset]);
+  blue=InversesRGBCompandor((double)
+    pixel[image->channel_map[BluePixelChannel].offset]);
+  return(0.21267*red+0.71516*green+0.07217*blue);
 }
 
 static inline Quantum GetPixelMagenta(const Image *restrict image,
@@ -327,7 +311,7 @@ static inline Quantum GetPixelMask(const Image *restrict image,
   const Quantum *restrict pixel)
 {
   if (image->channel_map[MaskPixelChannel].traits == UndefinedPixelTrait)
-    return(0);
+    return((Quantum) 0);
   return(pixel[image->channel_map[MaskPixelChannel].offset]);
 }
 
@@ -374,7 +358,7 @@ static inline void GetPixelInfoPixel(const Image *restrict image,
     pixel[image->channel_map[GreenPixelChannel].offset];
   pixel_info->blue=(double)
     pixel[image->channel_map[BluePixelChannel].offset];
-  pixel_info->black=0;
+  pixel_info->black=0.0;
   if (image->channel_map[BlackPixelChannel].traits != UndefinedPixelTrait)
     pixel_info->black=(double)
       pixel[image->channel_map[BlackPixelChannel].offset];
@@ -382,7 +366,7 @@ static inline void GetPixelInfoPixel(const Image *restrict image,
   if (image->channel_map[AlphaPixelChannel].traits != UndefinedPixelTrait)
     pixel_info->alpha=(double)
       pixel[image->channel_map[AlphaPixelChannel].offset];
-  pixel_info->index=0;
+  pixel_info->index=0.0;
   if (image->channel_map[IndexPixelChannel].traits != UndefinedPixelTrait)
     pixel_info->index=(double)
       pixel[image->channel_map[IndexPixelChannel].offset];
@@ -419,9 +403,17 @@ static inline PixelTrait GetPixelYellowTraits(const Image *restrict image)
 static inline MagickBooleanType IsPixelEquivalent(const Image *restrict image,
   const Quantum *restrict p,const PixelInfo *restrict q)
 {
-  if (((double) p[image->channel_map[RedPixelChannel].offset] == q->red) &&
-      ((double) p[image->channel_map[GreenPixelChannel].offset] == q->green) &&
-      ((double) p[image->channel_map[BluePixelChannel].offset] == q->blue))
+  double
+    blue,
+    green,
+    red;
+
+  red=(double) p[image->channel_map[RedPixelChannel].offset];
+  green=(double) p[image->channel_map[GreenPixelChannel].offset];
+  blue=(double) p[image->channel_map[BluePixelChannel].offset];
+  if ((fabs(red-q->red) < MagickEpsilon) &&
+      (fabs(green-q->green) < MagickEpsilon) &&
+      (fabs(blue-q->blue) < MagickEpsilon))
     return(MagickTrue);
   return(MagickFalse);
 }
@@ -429,26 +421,16 @@ static inline MagickBooleanType IsPixelEquivalent(const Image *restrict image,
 static inline MagickBooleanType IsPixelGray(const Image *restrict image,
   const Quantum *restrict pixel)
 {
-#if !defined(MAGICKCORE_HDRI_SUPPORT)
-  if ((pixel[image->channel_map[RedPixelChannel].offset] ==
-       pixel[image->channel_map[GreenPixelChannel].offset]) &&
-      (pixel[image->channel_map[GreenPixelChannel].offset] ==
-       pixel[image->channel_map[BluePixelChannel].offset]))
+  double
+    blue,
+    green,
+    red;
+
+  red=(double) pixel[image->channel_map[RedPixelChannel].offset];
+  green=(double) pixel[image->channel_map[GreenPixelChannel].offset];
+  blue=(double) pixel[image->channel_map[BluePixelChannel].offset];
+  if ((fabs(red-green) < MagickEpsilon) && (fabs(green-blue) < MagickEpsilon))
     return(MagickTrue);
-#else
-  {
-    double
-      alpha,
-      beta;
-
-    alpha=pixel[image->channel_map[RedPixelChannel].offset]-(double)
-      pixel[image->channel_map[GreenPixelChannel].offset];
-    beta=pixel[image->channel_map[GreenPixelChannel].offset]-(double)
-      pixel[image->channel_map[BluePixelChannel].offset];
-    if ((fabs((double) alpha) <= MagickEpsilon) && (fabs(beta) <= MagickEpsilon))
-      return(MagickTrue);
-  }
-#endif
   return(MagickFalse);
 }
 
@@ -456,25 +438,26 @@ static inline MagickBooleanType IsPixelInfoEquivalent(
   const PixelInfo *restrict p,const PixelInfo *restrict q)
 {
   if ((p->matte != MagickFalse) && (q->matte == MagickFalse) &&
-      (fabs(p->alpha-OpaqueAlpha) > 0.5))
+      (fabs(p->alpha-OpaqueAlpha) >= MagickEpsilon))
     return(MagickFalse);
   if ((q->matte != MagickFalse) && (p->matte == MagickFalse) &&
-      (fabs(q->alpha-OpaqueAlpha)) > 0.5)
+      (fabs(q->alpha-OpaqueAlpha)) >= MagickEpsilon)
     return(MagickFalse);
   if ((p->matte != MagickFalse) && (q->matte != MagickFalse))
     {
-      if (fabs(p->alpha-q->alpha) > 0.5)
+      if (fabs(p->alpha-q->alpha) >= MagickEpsilon)
         return(MagickFalse);
-      if (fabs(p->alpha-TransparentAlpha) <= 0.5)
+      if (fabs(p->alpha-TransparentAlpha) < MagickEpsilon)
         return(MagickTrue);
     }
-  if (fabs(p->red-q->red) > 0.5)
+  if (fabs(p->red-q->red) >= MagickEpsilon)
     return(MagickFalse);
-  if (fabs(p->green-q->green) > 0.5)
+  if (fabs(p->green-q->green) >= MagickEpsilon)
     return(MagickFalse);
-  if (fabs(p->blue-q->blue) > 0.5)
+  if (fabs(p->blue-q->blue) >= MagickEpsilon)
     return(MagickFalse);
-  if ((p->colorspace == CMYKColorspace) && (fabs(p->black-q->black) > 0.5))
+  if ((p->colorspace == CMYKColorspace) &&
+      (fabs(p->black-q->black) >= MagickEpsilon))
     return(MagickFalse);
   return(MagickTrue);
 }
@@ -482,83 +465,55 @@ static inline MagickBooleanType IsPixelInfoEquivalent(
 static inline MagickBooleanType IsPixelMonochrome(const Image *restrict image,
   const Quantum *restrict pixel)
 {
-#if !defined(MAGICKCORE_HDRI_SUPPORT)
-  if (((pixel[image->channel_map[RedPixelChannel].offset] == 0) ||
-      (pixel[image->channel_map[RedPixelChannel].offset] == (Quantum) QuantumRange)) &&
-      (pixel[image->channel_map[RedPixelChannel].offset] ==
-       pixel[image->channel_map[GreenPixelChannel].offset]) &&
-      (pixel[image->channel_map[GreenPixelChannel].offset] ==
-       pixel[image->channel_map[BluePixelChannel].offset]))
+  double
+    blue,
+    green,
+    red;
+
+  red=(double) pixel[image->channel_map[RedPixelChannel].offset];
+  if ((fabs(red) >= MagickEpsilon) || (fabs(red-QuantumRange) >= MagickEpsilon))
+    return(MagickFalse);
+  green=(double) pixel[image->channel_map[GreenPixelChannel].offset];
+  blue=(double) pixel[image->channel_map[BluePixelChannel].offset];
+  if ((fabs(red-green) < MagickEpsilon) && (fabs(green-blue) < MagickEpsilon))
     return(MagickTrue);
-#else
-  {
-    double
-      alpha,
-      beta;
-
-    alpha=pixel[image->channel_map[RedPixelChannel].offset]-(double)
-      pixel[image->channel_map[GreenPixelChannel].offset];
-    beta=pixel[image->channel_map[GreenPixelChannel].offset]-(double)
-      pixel[image->channel_map[BluePixelChannel].offset];
-    if (((fabs(pixel[image->channel_map[RedPixelChannel].offset]) <= MagickEpsilon) ||
-         (fabs(pixel[image->channel_map[RedPixelChannel].offset]-QuantumRange) <= MagickEpsilon)) &&
-        (fabs((double) alpha) <= MagickEpsilon) && (fabs(beta) <= MagickEpsilon))
-      return(MagickTrue);
-    }
-#endif
   return(MagickFalse);
 }
 
 static inline MagickBooleanType IsPixelInfoGray(
   const PixelInfo *restrict pixel_info)
 {
-  if ((IsGrayColorspace(pixel_info->colorspace) == MagickFalse) &&
-      (IsRGBColorspace(pixel_info->colorspace) == MagickFalse))
+  if ((pixel_info->colorspace != GRAYColorspace) &&
+      (pixel_info->colorspace != RGBColorspace))
     return(MagickFalse);
-#if !defined(MAGICKCORE_HDRI_SUPPORT)
-  if ((pixel_info->red == pixel_info->green) &&
-      (pixel_info->green == pixel_info->blue))
+  if ((fabs(pixel_info->red-pixel_info->green) < MagickEpsilon) &&
+      (fabs(pixel_info->green-pixel_info->blue) < MagickEpsilon))
     return(MagickTrue);
-#else
-  {
-    double
-      alpha,
-      beta;
-
-    alpha=pixel_info->red-(double) pixel_info->green;
-    beta=pixel_info->green-(double) pixel_info->blue;
-    if ((fabs((double) alpha) <= MagickEpsilon) && (fabs(beta) <= MagickEpsilon))
-      return(MagickTrue);
-  }
-#endif
   return(MagickFalse);
 }
 
 static inline MagickBooleanType IsPixelInfoMonochrome(
   const PixelInfo *restrict pixel_info)
 {
-#if !defined(MAGICKCORE_HDRI_SUPPORT)
-  if (((pixel_info->red == 0) || (pixel_info->red == (Quantum) QuantumRange)) &&
-      (pixel_info->red == pixel_info->green) &&
-      (pixel_info->green == pixel_info->blue))
+  if ((pixel_info->colorspace != GRAYColorspace) &&
+      (pixel_info->colorspace != RGBColorspace))
+    return(MagickFalse);
+  if ((fabs(pixel_info->red) >= MagickEpsilon) ||
+      (fabs(pixel_info->red-QuantumRange) >= MagickEpsilon))
+    return(MagickFalse);
+  if ((fabs(pixel_info->red-pixel_info->green) < MagickEpsilon) &&
+      (fabs(pixel_info->green-pixel_info->blue) < MagickEpsilon))
     return(MagickTrue);
-#else
-  {
-    double
-      alpha,
-      beta;
-
-    alpha=pixel_info->red-(double) pixel_info->green;
-    beta=pixel_info->green-(double) pixel_info->blue;
-    if (((fabs(pixel_info->red) <= MagickEpsilon) ||
-         (fabs(pixel_info->red-QuantumRange) <= MagickEpsilon)) &&
-        (fabs((double) alpha) <= MagickEpsilon) && (fabs(beta) <= MagickEpsilon))
-      return(MagickTrue);
-    }
-#endif
   return(MagickFalse);
 }
 
+static inline void SetPixela(const Image *restrict image,
+  const Quantum a,Quantum *restrict pixel)
+{
+  if (image->channel_map[aPixelChannel].traits != UndefinedPixelTrait)
+    pixel[image->channel_map[aPixelChannel].offset]=a;
+}
+
 static inline void SetPixelAlpha(const Image *restrict image,
   const Quantum alpha,Quantum *restrict pixel)
 {
@@ -571,6 +526,13 @@ static inline void SetPixelAlphaTraits(Image *image,const PixelTrait traits)
   image->channel_map[AlphaPixelChannel].traits=traits;
 }
 
+static inline void SetPixelb(const Image *restrict image,
+  const Quantum b,Quantum *restrict pixel)
+{
+  if (image->channel_map[bPixelChannel].traits != UndefinedPixelTrait)
+    pixel[image->channel_map[bPixelChannel].offset]=b;
+}
+
 static inline void SetPixelBlack(const Image *restrict image,
   const Quantum black,Quantum *restrict pixel)
 {
@@ -712,6 +674,13 @@ static inline void SetPixelInfoPixel(const Image *restrict image,
       MagickFalse ? OpaqueAlpha : ClampToQuantum(pixel_info->alpha);
 }
 
+static inline void SetPixelL(const Image *restrict image,
+  const Quantum L,Quantum *restrict pixel)
+{
+  if (image->channel_map[LPixelChannel].traits != UndefinedPixelTrait)
+    pixel[image->channel_map[LPixelChannel].offset]=L;
+}
+
 static inline void SetPixelMagenta(const Image *restrict image,
   const Quantum magenta,Quantum *restrict pixel)
 {
Unnamed repository; edit this file 'description' to name the repository.