Changeset 6238

Timestamp:

12/21/11 10:24:39 (17 months ago)

Author:

cristy

Message:

 

File:

• ImageMagick/trunk/MagickCore/composite.c (modified) (17 diffs)

ImageMagick/trunk/MagickCore/composite.c

@@ -2223 +2223 @@
         case AtopCompositeOp:
         case ClearCompositeOp:
+        case ColorBurnCompositeOp:
         case ColorDodgeCompositeOp:
         case CopyCompositeOp:
@@ -2236 +2237 @@
         case DstOutCompositeOp:
         case ExclusionCompositeOp:
+        case HardLightCompositeOp:
         case InCompositeOp:
         case LightenCompositeOp:
         case LightenIntensityCompositeOp:
+        case LinearBurnCompositeOp:
+        case LinearDodgeCompositeOp:
+        case LinearLightCompositeOp:
         case MathematicsCompositeOp:
         case MinusDstCompositeOp:
@@ -2248 +2253 @@
         case OutCompositeOp:
         case OverCompositeOp:
+        case OverlayCompositeOp:
+        case PegtopLightCompositeOp:
+        case PinLightCompositeOp:
         case PlusCompositeOp:
         case ReplaceCompositeOp:
         case ScreenCompositeOp:
+        case SoftLightCompositeOp:
         case SrcAtopCompositeOp:
         case SrcCompositeOp:
@@ -2256 +2265 @@
         case SrcOutCompositeOp:
         case SrcOverCompositeOp:
+        case VividLightCompositeOp:
         case XorCompositeOp:
         {
@@ -2269 +2279 @@
           Da,
           Dc,
+          Dca,
           gamma,
           Sa,
-          Sc;
+          Sc,
+          Sca;
 
         register ssize_t
@@ -2340 +2352 @@
         /*
           Authentic composite:
-            Sa: source normalized alpha.
-            Da: destination normalized alpha.
+            Sa:  normalized source alpha.
+            Da:  normalized destination alpha.
         */
         Sa=QuantumScale*GetPixelAlpha(composite_image,p);
@@ -2357 +2369 @@
             break;
           }
+          case ColorBurnCompositeOp:
           case ColorDodgeCompositeOp:
           case DifferenceCompositeOp:
@@ -2362 +2375 @@
           case DivideSrcCompositeOp:
           case ExclusionCompositeOp:
+          case HardLightCompositeOp:
+          case LinearBurnCompositeOp:
+          case LinearDodgeCompositeOp:
+          case LinearLightCompositeOp:
           case MathematicsCompositeOp:
           case MinusDstCompositeOp:
@@ -2368 +2385 @@
           case ModulusSubtractCompositeOp:
           case MultiplyCompositeOp:
+          case OverlayCompositeOp:
+          case PegtopLightCompositeOp:
+          case PinLightCompositeOp:
           case ScreenCompositeOp:
+          case SoftLightCompositeOp:
+          case VividLightCompositeOp:
           {
             alpha=RoundToUnity(Sa+Da-Sa*Da);
@@ -2431 +2453 @@
           /*
             Sc: source color.
+            Sca: source normalized color multiplied by alpha.
             Dc: destination color.
+            Dca: normalized destination color multiplied by alpha.
           */
           Sc=(MagickRealType) GetPixelChannel(composite_image,channel,p);
+          Sca=QuantumScale*Sa*Sc;
           Dc=(MagickRealType) q[i];
+          Dca=QuantumScale*Da*Dc;
           if ((traits & CopyPixelTrait) != 0)
             {
@@ -2512 +2538 @@
               break;
             }
+            case ColorBurnCompositeOp:
+            {
+              if ((fabs(Sca) < MagickEpsilon) && (fabs(Dca-Da) < MagickEpsilon))
+                {
+                  pixel=gamma*(Sa*Da+Dca*(1.0-Sa));
+                  break;
+                }
+              if (Sca < MagickEpsilon)
+                {
+                  pixel=gamma*(Dca*(1.0-Sa));
+                  break;
+                }
+              pixel=gamma*(Sa*Da-Sa*MagickMin(Da,(Da-Dca)*Sa/Sca)+Sca*(1.0-Da)+
+                Dca*(1.0-Sa));
+              break;
+            }
             case ColorDodgeCompositeOp:
             {
@@ -2559 +2601 @@
             case DivideDstCompositeOp:
             {
-              if ((fabs((QuantumScale*Sa*Sc)) < MagickEpsilon) &&
-                  (fabs((QuantumScale*Da*Dc)) < MagickEpsilon))
+              if ((fabs(Sca) < MagickEpsilon) && (fabs(Dca) < MagickEpsilon))
                 {
-                  pixel=gamma*((QuantumScale*Sa*Sc)*(1.0-Da)+
-                    (QuantumScale*Da*Dc)*(1.0-Sa));
+                  pixel=gamma*(Sca*(1.0-Da)+Dca*(1.0-Sa));
                   break;
                 }
-              if (fabs((QuantumScale*Da*Dc)) < MagickEpsilon)
+              if (fabs(Dca) < MagickEpsilon)
                 {
-                  pixel=gamma*(Sa*Da+(QuantumScale*Sa*Sc)*(1.0-Da)+
-                    (QuantumScale*Da*Dc)*(1.0-Sa));
+                  pixel=gamma*(Sa*Da+Sca*(1.0-Da)+Dca*(1.0-Sa));
                   break;
                 }
-              pixel=gamma*((QuantumScale*Sa*Sc)*Da*Da/(QuantumScale*Da*Dc)+
-                (QuantumScale*Sa*Sc)*(1.0-Da)+(QuantumScale*Da*Dc)*(1.0-Sa));
+              pixel=gamma*(Sca*Da*Da/Dca+Sca*(1.0-Da)+Dca*(1.0-Sa));
               break;
             }
             case DivideSrcCompositeOp:
             {
-              if ((fabs((QuantumScale*Da*Dc)) < MagickEpsilon) &&
-                  (fabs((QuantumScale*Sa*Sc)) < MagickEpsilon))
+              if ((fabs(Dca) < MagickEpsilon) && (fabs(Sca) < MagickEpsilon))
                 {
-                  pixel=gamma*((QuantumScale*Da*Dc)*(1.0-Sa)+
-                    (QuantumScale*Sa*Sc)*(1.0-Da));
+                  pixel=gamma*(Dca*(1.0-Sa)+Sca*(1.0-Da));
                   break;
                 }
-              if (fabs((QuantumScale*Sa*Sc)) < MagickEpsilon)
+              if (fabs(Sca) < MagickEpsilon)
                 {
-                  pixel=gamma*(Da*Sa+(QuantumScale*Da*Dc)*(1.0-Sa)+
-                    (QuantumScale*Sa*Sc)*(1.0-Da));
+                  pixel=gamma*(Da*Sa+Dca*(1.0-Sa)+Sca*(1.0-Da));
                   break;
                 }
-              pixel=gamma*((QuantumScale*Da*Dc)*Sa*Sa/(QuantumScale*Sa*Sc)+
-                (QuantumScale*Da*Dc)*(1.0-Sa)+(QuantumScale*Sa*Sc)*(1.0-Da));
+              pixel=gamma*(Dca*Sa*Sa/Sca+Dca*(1.0-Sa)+Sca*(1.0-Da));
               break;
             }
@@ -2623 +2657 @@
             case ExclusionCompositeOp:
             {
-              pixel=gamma*((QuantumScale*Sa*Sc)*Da+(QuantumScale*Da*Dc)*Sa-2.0*
-                (QuantumScale*Sa*Sc)*(QuantumScale*Da*Dc)+(QuantumScale*Sa*Sc)*
-                (1.0-Da)+(QuantumScale*Da*Dc)*(1.0-Sa));
+              pixel=gamma*(Sca*Da+Dca*Sa-2.0*Sca*Dca+Sca*(1.0-Da)+Dca*(1.0-Sa));
+              break;
+            }
+            case HardLightCompositeOp:
+            {
+              if ((2.0*Sca) < Sa)
+                pixel=gamma*(2.0*Sca*Dca+Sca*(1.0-Da)+Dca*(1.0-Sa));
+              pixel=gamma*(Sa*Da-2.0*(Da-Dca)*(Sa-Sca)+Sca*(1.0-Da)+
+                Dca*(1.0-Sa));
               break;
             }
@@ -2638 +2678 @@
               pixel=Sa*GetPixelIntensity(composite_image,p) >
                 Da*GetPixelIntensity(image,q) ? Sc : Dc;
+              break;
+            }
+            case LinearBurnCompositeOp:
+            {
+              pixel=gamma*(Sca+Dca-Sa*Da);
+              break;
+            }
+            case LinearDodgeCompositeOp:
+            {
+              pixel=gamma*(Sa*Sc+Da*Dc);
+              break;
+            }
+            case LinearLightCompositeOp:
+            {
+              pixel=gamma*((Sca-Sa)*Da+Sca+
+                Dca);
               break;
             }
@@ -2685 +2741 @@
             case MultiplyCompositeOp:
             {
-              pixel=gamma*((QuantumScale*Sa*Sc)*(QuantumScale*Da*Dc)+
-                (QuantumScale*Sa*Sc)*(1.0-Da)+(QuantumScale*Da*Dc)*(1.0-Sa));
+              pixel=gamma*(Sca*Dca+Sca*(1.0-Da)+Dca*(1.0-Sa));
               break;
             }
@@ -2701 +2756 @@
               break;
             }
+            case OverlayCompositeOp:
+            {
+              if ((2.0*Dca) < Da)
+                pixel=gamma*(2.0*Dca*Sca+Dca*(1.0-Sa)+Sca*(1.0-Da));
+              pixel=gamma*(Da*Sa-2.0*(Sa-Sca)*(Da-Dca)+Dca*(1.0-Sa)+Sca*
+                (1.0-Da));
+              break;
+            }
+            case PegtopLightCompositeOp:
+            {
+              if (fabs(Da) < MagickEpsilon)
+                {
+                  pixel=gamma*(Sca);
+                  break;
+                }
+              pixel=gamma*(Dca*Dca*(Sa-2.0*Sca)/Da+Sca*(2.0*Dca+1.0-Da)+Dca*
+                (1.0-Sa));
+              break;
+            }
+            case PinLightCompositeOp:
+            {
+              if ((Dca*Sa) < (Da*(2.0*Sca-Sa)))
+                {
+                  pixel=gamma*(Sca*(Da+1.0)-Sa*Da+Dca*(1.0-Sa));
+                  break;
+                }
+              if ((Dca*Sa) > (2.0*Sca*Da))
+                {
+                  pixel=gamma*(Sca*Da+Sca+Dca*(1.0-Sa));
+                  break;
+                }
+              pixel=gamma*(Sca*(1.0-Da)+Dca);
+              break;
+            }
             case PlusCompositeOp:
             {
@@ -2709 +2798 @@
             {
               pixel=gamma*((Sa*Sc)+(Da*Dc)-(Sa*Sc)*(Da*Dc));
+              break;
+            }
+            case SoftLightCompositeOp:
+            {
+              if ((2.0*Sca) < Sa)
+                {
+                  pixel=gamma*(Dca*(Sa+(2.0*Sca-Sa)*(1.0-(Dca/Da)))+Sca*
+                    (1.0-Da)+Dca*(1.0-Sa));
+                  break;
+                }
+              if (((2.0*Sca) > Sa) && ((4.0*Dca) <= Da))
+                {
+                  pixel=gamma*(Dca*Sa+Da*(2.0*Sca-Sa)*(4.0*(Dca/Da)*(4.0*
+                    (Dca/Da)+1.0)*((Dca/Da)-1.0)+7.0*(Dca/Da))+Sca*(1.0-Da)+Dca*
+                    (1.0-Sa));
+                  break;
+                }
+              pixel=gamma*(Dca*Sa+Da*(2.0*Sca-Sa)*(pow((Dca/Da),0.5)-(Dca/Da))+
+                Sca*(1.0-Da)+Dca*(1.0-Sa));
+              break;
+            }
+            case VividLightCompositeOp:
+            {
+              if ((fabs(Sa) < MagickEpsilon) || (fabs(Sca-Sa) < MagickEpsilon))
+                {
+                  pixel=gamma*(Sa*Da+Sca*(1.0-Da)+Dca*(1.0-Sa));
+                  break;
+                }
+              if ((2.0*Sca) <= Sa)
+                {
+                  pixel=gamma*(Sa*(Da+Sa*(Dca-Da)/(2.0*Sca))+Sca*(1.0-Da)+Dca*
+                    (1.0-Sa));
+                  break;
+                }
+              pixel=gamma*(Dca*Sa*Sa/(2.0*(Sa-Sca))+Sca*(1.0-Da)+Dca*(1.0-Sa));
               break;
             }