Changeset 11613 for ImageMagick/trunk

Timestamp:

07/12/08 14:24:54 (3 months ago)

Author:

cristy

Message:

 

Location:

ImageMagick/trunk

Files:

• magick/color.c (modified) (3 diffs)
• magick/shear.c (modified) (14 diffs)
• wand/mogrify.c (modified) (1 diff)

ImageMagick/trunk/magick/color.c

@@ -642 +642 @@
       break;
     }
-    case OpacityChannel:
-    {
-      color=pixel->opacity;
+    case AlphaChannel:
+    {
+      color=QuantumRange-pixel->opacity;
       break;
     }
@@ -1322 +1322 @@
     {
       (void) ConcatenateMagickString(tuple,",",MaxTextExtent);
-      ConcatenateColorComponent(&color,OpacityChannel,SVGCompliance,tuple);
+      ConcatenateColorComponent(&color,AlphaChannel,SVGCompliance,tuple);
     }
   (void) ConcatenateMagickString(tuple,")",MaxTextExtent);
@@ -1599 +1599 @@
       {
         (void) ConcatenateMagickString(tuple,",",MaxTextExtent);
-        ConcatenateColorComponent(&pixel,OpacityChannel,X11Compliance,
-          tuple);
+        ConcatenateColorComponent(&pixel,OpacityChannel,X11Compliance,tuple);
       }
     (void) ConcatenateMagickString(tuple,")",MaxTextExtent);

ImageMagick/trunk/magick/shear.c

@@ -47 +47 @@
 */
 #include "magick/studio.h"
+#include "magick/artifact.h"
 #include "magick/blob-private.h"
 #include "magick/cache-private.h"
@@ -580 +581 @@
   off_t
     i;
-    
+
   unsigned short
-    value; 
-    
+    value;
+
   i=(off_t) radon_info->height*x+y;
-  if ((i < 0) || 
-      ((i*sizeof(*radon_info->cells)) >= radon_info->length))
+  if ((i < 0) ||
+      ((MagickSizeType) (i*sizeof(*radon_info->cells)) >= radon_info->length))
     return(0);
   if (radon_info->type != DiskCache)
@@ -606 +607 @@
 
   i=(off_t) radon_info->height*x+y;
-  if ((i < 0) || 
-      ((i*sizeof(*radon_info->cells)) >= radon_info->length))
+  if ((i < 0) ||
+      ((MagickSizeType) (i*sizeof(*radon_info->cells)) >= radon_info->length))
     return(0);
   if (radon_info->type != DiskCache)
@@ -651 +652 @@
 
       unsigned short
-        value;
+        cell;
 
       for (i=0; i < (long) step; i++)
       {
-        for (y=0; y < (long) p->height; y++)
+        for (y=0; y < (long) (p->height-i-1); y++)
         {
-          value=GetRadonCell(p,x+i,y);
-          (void) SetRadonCell(q,x+2*i,y,value+GetRadonCell(p,x+i+step,y+i));
-          (void) SetRadonCell(q,x+2*i+1,y,value+GetRadonCell(p,x+i+step,y+i+1));
+          cell=GetRadonCell(p,x+i,y);
+          (void) SetRadonCell(q,x+2*i,y,cell+GetRadonCell(p,x+i+step,y+i));
+          (void) SetRadonCell(q,x+2*i+1,y,cell+GetRadonCell(p,x+i+step,y+i+1));
+        }
+        for ( ; y < (long) (p->height-i); y++)
+        {
+          cell=GetRadonCell(p,x+i,y);
+          (void) SetRadonCell(q,x+2*i,y,cell+GetRadonCell(p,x+i+step,y+i));
+          (void) SetRadonCell(q,x+2*i+1,y,cell);
+        }
+        for ( ; y < (long) p->height; y++)
+        {
+          cell=GetRadonCell(p,x+i,y);
+          (void) SetRadonCell(q,x+2*i,y,cell);
+          (void) SetRadonCell(q,x+2*i+1,y,cell);
         }
       }
@@ -771 +784 @@
     bit=0;
     byte=0;
-    i=0;
+    i=(long) (image->columns+7)/8;
     for (x=0; x < (long) image->columns; x++)
     {
       byte<<=1;
-      if ((p->red < threshold) || (p->green < threshold) ||
-          (p->blue < threshold))
+      if (((MagickRealType) p->red < threshold) ||
+          ((MagickRealType) p->green < threshold) ||
+          ((MagickRealType) p->blue < threshold))
         byte|=0x01;
       bit++;
       if (bit == 8)
         {
-          (void) SetRadonCell(source_cells,i++,y,bits[byte]);
+          (void) SetRadonCell(source_cells,--i,y,bits[byte]);
           bit=0;
           byte=0;
@@ -790 +804 @@
       {
         byte<<=(8-bit);
-        (void) SetRadonCell(source_cells,i++,y,bits[byte]);
+        (void) SetRadonCell(source_cells,--i,y,bits[byte]);
       }
   }
@@ -821 +835 @@
     bit=0;
     byte=0;
-    i=(long) (image->columns+7)/8;
+    i=0;
     for (x=0; x < (long) image->columns; x++)
     {
       byte<<=1;
-      if ((p->red < threshold) || (p->green < threshold) ||
-          (p->blue < threshold))
+      if (((MagickRealType) p->red < threshold) ||
+          ((MagickRealType) p->green < threshold) ||
+          ((MagickRealType) p->blue < threshold))
         byte|=0x01;
       bit++;
       if (bit == 8)
         {
-          (void) SetRadonCell(source_cells,--i,y,bits[byte]);
+          (void) SetRadonCell(source_cells,i++,y,bits[byte]);
           bit=0;
           byte=0;
@@ -840 +855 @@
       {
         byte<<=(8-bit);
-        (void) SetRadonCell(source_cells,--i,y,bits[byte]);
+        (void) SetRadonCell(source_cells,i++,y,bits[byte]);
       }
   }
@@ -850 +865 @@
 }
 
+static void GetImageBackgroundColor(Image *image,const long offset,
+  ExceptionInfo *exception)
+{
+  long
+    y;
+
+  MagickPixelPacket
+    background;
+
+  MagickRealType
+    count;
+
+  ViewInfo
+    *image_view;
+
+  /*
+    Compute average background color.
+  */
+  if (offset <= 0)
+    return;
+  GetMagickPixelPacket(image,&background);
+  count=0.0;
+  image_view=AcquireCacheView(image);
+  for (y=0; y < (long) image->rows; y++)
+  {
+    register const PixelPacket
+      *p;
+
+    register long
+      x;
+
+    if ((y >= offset) && (y < ((long) image->rows-offset)))
+      continue;
+    p=AcquireCacheViewPixels(image_view,0,y,image->columns,1,exception);
+    if (p == (const PixelPacket *) NULL)
+      continue;
+    for (x=0; x < (long) image->columns; x++)
+    {
+      if ((x >= offset) && (x < ((long) image->columns-offset)))
+        continue;
+      background.red+=QuantumScale*p->red;
+      background.green+=QuantumScale*p->green;
+      background.blue+=QuantumScale*p->blue;
+      background.opacity+=QuantumScale*p->opacity;
+      count++;
+      p++;
+    }
+  }
+  image_view=DestroyCacheView(image_view);
+  image->background_color.red=RoundToQuantum((MagickRealType) QuantumRange*
+    background.red/count);
+  image->background_color.green=RoundToQuantum((MagickRealType) QuantumRange*
+    background.green/count);
+  image->background_color.blue=RoundToQuantum((MagickRealType) QuantumRange*
+    background.blue/count);
+  image->background_color.opacity=RoundToQuantum((MagickRealType) QuantumRange*
+    background.opacity/count);
+}
+
 MagickExport Image *DeskewImage(const Image *image,const double threshold,
   ExceptionInfo *exception)
 {
+  const char
+    *artifact;
+
   double
     degrees,
@@ -858 +935 @@
 
   Image
-    *deskew_image;
+    *clone_image,
+    *median_image,
+    *rotate_image;
 
   long
@@ -865 +944 @@
   MagickBooleanType
     status;
+
+  RectangleInfo
+    geometry;
 
   register long
@@ -904 +986 @@
     Deskew image.
   */
-  degrees=RadiansToDegrees(atan((double) skew/width/8));
+  degrees=RadiansToDegrees(-atan((double) skew/width/8));
   if (image->debug != MagickFalse)
     (void) LogMagickEvent(TransformEvent,GetMagickModule(),"  Deskew angle: %g",
       degrees);
-  deskew_image=RotateImage(image,degrees,exception);
-  if (image->fuzz != 0.0)
-    {
-      Image
-        *image;
-
-      RectangleInfo
-        geometry;
-
-      /*
-        Trim image.
-      */
-      image=ReduceNoiseImage(deskew_image,0.0,exception);
-      if (image != (Image *) NULL)
-        {
-          geometry=GetImageBoundingBox(image,exception);
-          image=DestroyImage(image);
-          image=CropImage(deskew_image,&geometry,exception);
-          if (image != (Image *) NULL)
-            {
-              deskew_image=DestroyImage(deskew_image);
-              deskew_image=image;
-            }
-        }
-    }
-  return(deskew_image);
+  artifact=GetImageArtifact(image,"deskew:auto-crop");
+  if (artifact == (const char *) NULL)
+    return(RotateImage(image,degrees,exception));
+  /*
+    Auto-crop image.
+  */
+  clone_image=CloneImage(image,0,0,MagickTrue,exception);
+  if (clone_image == (Image *) NULL)
+    return((Image *) NULL);
+  GetImageBackgroundColor(clone_image,atol(artifact),exception);
+  rotate_image=RotateImage(clone_image,degrees,exception);
+  clone_image=DestroyImage(clone_image);
+  if (rotate_image == (Image *) NULL)
+    return((Image *) NULL);
+  median_image=MedianFilterImage(rotate_image,0.0,exception);
+  rotate_image=DestroyImage(rotate_image);
+  if (median_image == (Image *) NULL)
+    return((Image *) NULL);
+  geometry=GetImageBoundingBox(median_image,exception);
+  median_image=DestroyImage(median_image);
+  if (image->debug != MagickFalse)
+    (void) LogMagickEvent(TransformEvent,GetMagickModule(),"  Deskew geometry: "
+      "%lux%lu%+ld%+ld",geometry.width,geometry.height,geometry.x,geometry.y);
+  return(CropImage(image,&geometry,exception));
 }
 
@@ -1333 +1413 @@
   status=MagickTrue;
   image_view=AcquireCacheViewThreadSet(image);
-  #pragma omp parallel for
+//  #pragma omp parallel for
   for (y=0; y < (long) height; y++)
   {
@@ -1527 +1607 @@
   status=MagickTrue;
   image_view=AcquireCacheViewThreadSet(image);
-  #pragma omp parallel for
+//  #pragma omp parallel for
   for (x=0; x < (long) width; x++)
   {

ImageMagick/trunk/wand/mogrify.c

@@ -870 +870 @@
             */
             if (*option == '+')
-              threshold=QuantumRange/2.2;
+              threshold=40.0*QuantumRange/100.0;
             else
               threshold=StringToDouble(argv[i+1],QuantumRange);