% MagickCore Methods to Shear or Rotate an Image by an Arbitrary Angle %
% %
% Software Design %
-% John Cristy %
+% Cristy %
% July 1992 %
% %
% %
-% Copyright 1999-2013 ImageMagick Studio LLC, a non-profit organization %
+% Copyright 1999-2014 ImageMagick Studio LLC, a non-profit organization %
% dedicated to making software imaging solutions freely available. %
% %
% You may not use this file except in compliance with the License. You may %
#include "MagickCore/attribute.h"
#include "MagickCore/blob-private.h"
#include "MagickCore/cache-private.h"
+#include "MagickCore/channel.h"
#include "MagickCore/color-private.h"
#include "MagickCore/colorspace-private.h"
#include "MagickCore/composite.h"
#include "MagickCore/geometry.h"
#include "MagickCore/image.h"
#include "MagickCore/image-private.h"
+#include "MagickCore/matrix.h"
#include "MagickCore/memory_.h"
#include "MagickCore/list.h"
#include "MagickCore/monitor.h"
% imperfections in the scanning or surface, or simply because the paper was
% not placed completely flat when scanned.
%
+% The result will be auto-croped if the artifact "deskew:auto-crop" is
+% defined, while the amount the image is to be deskewed, in degrees is also
+% saved as the artifact "deskew:angle".
+%
+% If the artifact "deskew:auto-crop" is given the image will be automatically
+% cropped of the excess background. The value is the border width of all
+% pixels around the edge that will be used to determine an average border
+% color for the automatic trim.
+%
% The format of the DeskewImage method is:
%
% Image *DeskewImage(const Image *image,const double threshold,
%
*/
-typedef struct _RadonInfo
-{
- CacheType
- type;
-
- size_t
- width,
- height;
-
- MagickSizeType
- length;
-
- MagickBooleanType
- mapped;
-
- char
- path[MaxTextExtent];
-
- int
- file;
-
- unsigned short
- *cells;
-} RadonInfo;
-
-static RadonInfo *DestroyRadonInfo(RadonInfo *radon_info)
+static void RadonProjection(const Image *image,MatrixInfo *source_matrixs,
+ MatrixInfo *destination_matrixs,const ssize_t sign,size_t *projection)
{
- assert(radon_info != (RadonInfo *) NULL);
- switch (radon_info->type)
- {
- case MemoryCache:
- {
- if (radon_info->mapped == MagickFalse)
- radon_info->cells=(unsigned short *) RelinquishMagickMemory(
- radon_info->cells);
- else
- radon_info->cells=(unsigned short *) UnmapBlob(radon_info->cells,
- (size_t) radon_info->length);
- RelinquishMagickResource(MemoryResource,radon_info->length);
- break;
- }
- case MapCache:
- {
- radon_info->cells=(unsigned short *) UnmapBlob(radon_info->cells,(size_t)
- radon_info->length);
- RelinquishMagickResource(MapResource,radon_info->length);
- }
- case DiskCache:
- {
- if (radon_info->file != -1)
- (void) close(radon_info->file);
- (void) RelinquishUniqueFileResource(radon_info->path);
- RelinquishMagickResource(DiskResource,radon_info->length);
- break;
- }
- default:
- break;
- }
- return((RadonInfo *) RelinquishMagickMemory(radon_info));
-}
-
-static MagickBooleanType ResetRadonCells(RadonInfo *radon_info)
-{
- register ssize_t
- x;
-
- ssize_t
- count,
- y;
-
- unsigned short
- value;
-
- if (radon_info->type != DiskCache)
- {
- (void) ResetMagickMemory(radon_info->cells,0,(size_t) radon_info->length);
- return(MagickTrue);
- }
- value=0;
- (void) lseek(radon_info->file,0,SEEK_SET);
- for (y=0; y < (ssize_t) radon_info->height; y++)
- {
- for (x=0; x < (ssize_t) radon_info->width; x++)
- {
- count=write(radon_info->file,&value,sizeof(*radon_info->cells));
- if (count != (ssize_t) sizeof(*radon_info->cells))
- break;
- }
- if (x < (ssize_t) radon_info->width)
- break;
- }
- return(y < (ssize_t) radon_info->height ? MagickFalse : MagickTrue);
-}
-
-static RadonInfo *AcquireRadonInfo(const Image *image,const size_t width,
- const size_t height,ExceptionInfo *exception)
-{
- MagickBooleanType
- status;
-
- RadonInfo
- *radon_info;
-
- radon_info=(RadonInfo *) AcquireMagickMemory(sizeof(*radon_info));
- if (radon_info == (RadonInfo *) NULL)
- return((RadonInfo *) NULL);
- (void) ResetMagickMemory(radon_info,0,sizeof(*radon_info));
- radon_info->width=width;
- radon_info->height=height;
- radon_info->length=(MagickSizeType) width*height*sizeof(*radon_info->cells);
- radon_info->type=MemoryCache;
- status=AcquireMagickResource(AreaResource,radon_info->length);
- if ((status != MagickFalse) &&
- (radon_info->length == (MagickSizeType) ((size_t) radon_info->length)))
- {
- status=AcquireMagickResource(MemoryResource,radon_info->length);
- if (status != MagickFalse)
- {
- radon_info->mapped=MagickFalse;
- radon_info->cells=(unsigned short *) AcquireMagickMemory((size_t)
- radon_info->length);
- if (radon_info->cells == (unsigned short *) NULL)
- {
- radon_info->mapped=MagickTrue;
- radon_info->cells=(unsigned short *) MapBlob(-1,IOMode,0,(size_t)
- radon_info->length);
- }
- if (radon_info->cells == (unsigned short *) NULL)
- RelinquishMagickResource(MemoryResource,radon_info->length);
- }
- }
- radon_info->file=(-1);
- if (radon_info->cells == (unsigned short *) NULL)
- {
- status=AcquireMagickResource(DiskResource,radon_info->length);
- if (status == MagickFalse)
- {
- (void) ThrowMagickException(exception,GetMagickModule(),CacheError,
- "CacheResourcesExhausted","'%s'",image->filename);
- return(DestroyRadonInfo(radon_info));
- }
- radon_info->type=DiskCache;
- (void) AcquireMagickResource(MemoryResource,radon_info->length);
- radon_info->file=AcquireUniqueFileResource(radon_info->path);
- if (radon_info->file == -1)
- return(DestroyRadonInfo(radon_info));
- status=AcquireMagickResource(MapResource,radon_info->length);
- if (status != MagickFalse)
- {
- status=ResetRadonCells(radon_info);
- if (status != MagickFalse)
- {
- radon_info->cells=(unsigned short *) MapBlob(radon_info->file,
- IOMode,0,(size_t) radon_info->length);
- if (radon_info->cells != (unsigned short *) NULL)
- radon_info->type=MapCache;
- else
- RelinquishMagickResource(MapResource,radon_info->length);
- }
- }
- }
- return(radon_info);
-}
-
-static inline size_t MagickMin(const size_t x,const size_t y)
-{
- if (x < y)
- return(x);
- return(y);
-}
-
-static inline ssize_t ReadRadonCell(const RadonInfo *radon_info,
- const MagickOffsetType offset,const size_t length,unsigned char *buffer)
-{
- register ssize_t
- i;
-
- ssize_t
- count;
-
-#if !defined(MAGICKCORE_HAVE_PPREAD)
-#if defined(MAGICKCORE_OPENMP_SUPPORT)
- #pragma omp critical (MagickCore_ReadRadonCell)
-#endif
- {
- i=(-1);
- if (lseek(radon_info->file,offset,SEEK_SET) >= 0)
- {
-#endif
- count=0;
- for (i=0; i < (ssize_t) length; i+=count)
- {
-#if !defined(MAGICKCORE_HAVE_PPREAD)
- count=read(radon_info->file,buffer+i,MagickMin(length-i,(size_t)
- SSIZE_MAX));
-#else
- count=pread(radon_info->file,buffer+i,MagickMin(length-i,(size_t)
- SSIZE_MAX),offset+i);
-#endif
- if (count > 0)
- continue;
- count=0;
- if (errno != EINTR)
- {
- i=(-1);
- break;
- }
- }
-#if !defined(MAGICKCORE_HAVE_PPREAD)
- }
- }
-#endif
- return(i);
-}
-
-static inline ssize_t WriteRadonCell(const RadonInfo *radon_info,
- const MagickOffsetType offset,const size_t length,const unsigned char *buffer)
-{
- register ssize_t
- i;
-
- ssize_t
- count;
-
-#if !defined(MAGICKCORE_HAVE_PWRITE)
-#if defined(MAGICKCORE_OPENMP_SUPPORT)
- #pragma omp critical (MagickCore_WriteRadonCell)
-#endif
- {
- if (lseek(radon_info->file,offset,SEEK_SET) >= 0)
- {
-#endif
- count=0;
- for (i=0; i < (ssize_t) length; i+=count)
- {
-#if !defined(MAGICKCORE_HAVE_PWRITE)
- count=write(radon_info->file,buffer+i,MagickMin(length-i,(size_t)
- SSIZE_MAX));
-#else
- count=pwrite(radon_info->file,buffer+i,MagickMin(length-i,(size_t)
- SSIZE_MAX),offset+i);
-#endif
- if (count > 0)
- continue;
- count=0;
- if (errno != EINTR)
- {
- i=(-1);
- break;
- }
- }
-#if !defined(MAGICKCORE_HAVE_PWRITE)
- }
- }
-#endif
- return(i);
-}
-
-static inline unsigned short GetRadonCell(const RadonInfo *radon_info,
- const ssize_t x,const ssize_t y)
-{
- MagickOffsetType
- i;
-
- unsigned short
- value;
-
- i=(MagickOffsetType) radon_info->height*x+y;
- if ((i < 0) ||
- ((MagickSizeType) (i*sizeof(*radon_info->cells)) >= radon_info->length))
- return(0);
- if (radon_info->type != DiskCache)
- return(radon_info->cells[i]);
- value=0;
- (void) ReadRadonCell(radon_info,i*sizeof(*radon_info->cells),
- sizeof(*radon_info->cells),(unsigned char *) &value);
- return(value);
-}
-
-static inline MagickBooleanType SetRadonCell(const RadonInfo *radon_info,
- const ssize_t x,const ssize_t y,const unsigned short value)
-{
- MagickOffsetType
- i;
-
- ssize_t
- count;
-
- i=(MagickOffsetType) radon_info->height*x+y;
- if ((i < 0) ||
- ((MagickSizeType) (i*sizeof(*radon_info->cells)) >= radon_info->length))
- return(MagickFalse);
- if (radon_info->type != DiskCache)
- {
- radon_info->cells[i]=value;
- return(MagickTrue);
- }
- count=WriteRadonCell(radon_info,i*sizeof(*radon_info->cells),
- sizeof(*radon_info->cells),(const unsigned char *) &value);
- if (count != (ssize_t) sizeof(*radon_info->cells))
- return(MagickFalse);
- return(MagickTrue);
-}
-
-static void RadonProjection(const Image *image,RadonInfo *source_cells,
- RadonInfo *destination_cells,const ssize_t sign,size_t *projection)
-{
- RadonInfo
+ MatrixInfo
*swap;
- register ssize_t
- x;
-
- register RadonInfo
+ register MatrixInfo
*p,
*q;
+ register ssize_t
+ x;
+
size_t
step;
- p=source_cells;
- q=destination_cells;
- for (step=1; step < p->width; step*=2)
+ p=source_matrixs;
+ q=destination_matrixs;
+ for (step=1; step < GetMatrixColumns(p); step*=2)
{
- for (x=0; x < (ssize_t) p->width; x+=2*(ssize_t) step)
+ for (x=0; x < (ssize_t) GetMatrixColumns(p); x+=2*(ssize_t) step)
{
register ssize_t
i;
y;
unsigned short
- cell;
+ element,
+ neighbor;
for (i=0; i < (ssize_t) step; i++)
{
- for (y=0; y < (ssize_t) (p->height-i-1); y++)
+ for (y=0; y < (ssize_t) (GetMatrixRows(p)-i-1); y++)
{
- cell=GetRadonCell(p,x+i,y);
- (void) SetRadonCell(q,x+2*i,y,cell+GetRadonCell(p,x+i+(ssize_t)
- step,y+i));
- (void) SetRadonCell(q,x+2*i+1,y,cell+GetRadonCell(p,x+i+(ssize_t)
- step,y+i+1));
+ if (GetMatrixElement(p,x+i,y,&element) == MagickFalse)
+ continue;
+ if (GetMatrixElement(p,x+i+step,y+i,&neighbor) == MagickFalse)
+ continue;
+ neighbor+=element;
+ if (SetMatrixElement(q,x+2*i,y,&neighbor) == MagickFalse)
+ continue;
+ if (GetMatrixElement(p,x+i+step,y+i+1,&neighbor) == MagickFalse)
+ continue;
+ neighbor+=element;
+ if (SetMatrixElement(q,x+2*i+1,y,&neighbor) == MagickFalse)
+ continue;
}
- for ( ; y < (ssize_t) (p->height-i); y++)
+ for ( ; y < (ssize_t) (GetMatrixRows(p)-i); y++)
{
- cell=GetRadonCell(p,x+i,y);
- (void) SetRadonCell(q,x+2*i,y,cell+GetRadonCell(p,x+i+(ssize_t) step,
- y+i));
- (void) SetRadonCell(q,x+2*i+1,y,cell);
+ if (GetMatrixElement(p,x+i,y,&element) == MagickFalse)
+ continue;
+ if (GetMatrixElement(p,x+i+step,y+i,&neighbor) == MagickFalse)
+ continue;
+ neighbor+=element;
+ if (SetMatrixElement(q,x+2*i,y,&neighbor) == MagickFalse)
+ continue;
+ if (SetMatrixElement(q,x+2*i+1,y,&element) == MagickFalse)
+ continue;
}
- for ( ; y < (ssize_t) p->height; y++)
+ for ( ; y < (ssize_t) GetMatrixRows(p); y++)
{
- cell=GetRadonCell(p,x+i,y);
- (void) SetRadonCell(q,x+2*i,y,cell);
- (void) SetRadonCell(q,x+2*i+1,y,cell);
+ if (GetMatrixElement(p,x+i,y,&element) == MagickFalse)
+ continue;
+ if (SetMatrixElement(q,x+2*i,y,&element) == MagickFalse)
+ continue;
+ if (SetMatrixElement(q,x+2*i+1,y,&element) == MagickFalse)
+ continue;
}
}
}
}
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) \
- dynamic_number_threads(image,image,p->width,1)
+ magick_threads(image,image,1,1)
#endif
- for (x=0; x < (ssize_t) p->width; x++)
+ for (x=0; x < (ssize_t) GetMatrixColumns(p); x++)
{
register ssize_t
y;
sum;
sum=0;
- for (y=0; y < (ssize_t) (p->height-1); y++)
+ for (y=0; y < (ssize_t) (GetMatrixRows(p)-1); y++)
{
ssize_t
delta;
- delta=GetRadonCell(p,x,y)-(ssize_t) GetRadonCell(p,x,y+1);
+ unsigned short
+ element,
+ neighbor;
+
+ if (GetMatrixElement(p,x,y,&element) == MagickFalse)
+ continue;
+ if (GetMatrixElement(p,x,y+1,&neighbor) == MagickFalse)
+ continue;
+ delta=(ssize_t) element-(ssize_t) neighbor;
sum+=delta*delta;
}
- projection[p->width+sign*x-1]=sum;
+ projection[GetMatrixColumns(p)+sign*x-1]=sum;
}
}
CacheView
*image_view;
+ MatrixInfo
+ *destination_matrixs,
+ *source_matrixs;
+
MagickBooleanType
status;
- RadonInfo
- *destination_cells,
- *source_cells;
-
register ssize_t
i;
bits[256];
for (width=1; width < ((image->columns+7)/8); width<<=1) ;
- source_cells=AcquireRadonInfo(image,width,image->rows,exception);
- destination_cells=AcquireRadonInfo(image,width,image->rows,exception);
- if ((source_cells == (RadonInfo *) NULL) ||
- (destination_cells == (RadonInfo *) NULL))
+ source_matrixs=AcquireMatrixInfo(width,image->rows,sizeof(unsigned short),
+ exception);
+ destination_matrixs=AcquireMatrixInfo(width,image->rows,sizeof(unsigned short),
+ exception);
+ if ((source_matrixs == (MatrixInfo *) NULL) ||
+ (destination_matrixs == (MatrixInfo *) NULL))
{
- if (destination_cells != (RadonInfo *) NULL)
- destination_cells=DestroyRadonInfo(destination_cells);
- if (source_cells != (RadonInfo *) NULL)
- source_cells=DestroyRadonInfo(source_cells);
+ if (destination_matrixs != (MatrixInfo *) NULL)
+ destination_matrixs=DestroyMatrixInfo(destination_matrixs);
+ if (source_matrixs != (MatrixInfo *) NULL)
+ source_matrixs=DestroyMatrixInfo(source_matrixs);
return(MagickFalse);
}
- if (ResetRadonCells(source_cells) == MagickFalse)
+ if (NullMatrix(source_matrixs) == MagickFalse)
{
- destination_cells=DestroyRadonInfo(destination_cells);
- source_cells=DestroyRadonInfo(source_cells);
+ destination_matrixs=DestroyMatrixInfo(destination_matrixs);
+ source_matrixs=DestroyMatrixInfo(source_matrixs);
return(MagickFalse);
}
for (i=0; i < 256; i++)
image_view=AcquireVirtualCacheView(image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(status) \
- dynamic_number_threads(image,image,image->rows,1)
+ magick_threads(image,image,1,1)
#endif
for (y=0; y < (ssize_t) image->rows; y++)
{
bit,
byte;
+ unsigned short
+ value;
+
if (status == MagickFalse)
continue;
p=GetCacheViewVirtualPixels(image_view,0,y,image->columns,1,exception);
for (x=0; x < (ssize_t) image->columns; x++)
{
byte<<=1;
- if (GetPixelIntensity(image,p) < threshold)
+ if (((MagickRealType) GetPixelRed(image,p) < threshold) ||
+ ((MagickRealType) GetPixelGreen(image,p) < threshold) ||
+ ((MagickRealType) GetPixelBlue(image,p) < threshold))
byte|=0x01;
bit++;
if (bit == 8)
{
- (void) SetRadonCell(source_cells,--i,y,bits[byte]);
+ value=bits[byte];
+ (void) SetMatrixElement(source_matrixs,--i,y,&value);
bit=0;
byte=0;
}
if (bit != 0)
{
byte<<=(8-bit);
- (void) SetRadonCell(source_cells,--i,y,bits[byte]);
+ value=bits[byte];
+ (void) SetMatrixElement(source_matrixs,--i,y,&value);
}
}
- RadonProjection(image,source_cells,destination_cells,-1,projection);
- (void) ResetRadonCells(source_cells);
+ RadonProjection(image,source_matrixs,destination_matrixs,-1,projection);
+ (void) NullMatrix(source_matrixs);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(status) \
- dynamic_number_threads(image,image,image->rows,1)
+ magick_threads(image,image,image->rows,1)
#endif
for (y=0; y < (ssize_t) image->rows; y++)
{
bit,
byte;
+ unsigned short
+ value;
+
if (status == MagickFalse)
continue;
p=GetCacheViewVirtualPixels(image_view,0,y,image->columns,1,exception);
for (x=0; x < (ssize_t) image->columns; x++)
{
byte<<=1;
- if (GetPixelIntensity(image,p) < threshold)
+ if (((MagickRealType) GetPixelRed(image,p) < threshold) ||
+ ((MagickRealType) GetPixelGreen(image,p) < threshold) ||
+ ((MagickRealType) GetPixelBlue(image,p) < threshold))
byte|=0x01;
bit++;
if (bit == 8)
{
- (void) SetRadonCell(source_cells,i++,y,bits[byte]);
+ value=bits[byte];
+ (void) SetMatrixElement(source_matrixs,i++,y,&value);
bit=0;
byte=0;
}
if (bit != 0)
{
byte<<=(8-bit);
- (void) SetRadonCell(source_cells,i++,y,bits[byte]);
+ value=bits[byte];
+ (void) SetMatrixElement(source_matrixs,i++,y,&value);
}
}
- RadonProjection(image,source_cells,destination_cells,1,projection);
+ RadonProjection(image,source_matrixs,destination_matrixs,1,projection);
image_view=DestroyCacheView(image_view);
- destination_cells=DestroyRadonInfo(destination_cells);
- source_cells=DestroyRadonInfo(source_cells);
+ destination_matrixs=DestroyMatrixInfo(destination_matrixs);
+ source_matrixs=DestroyMatrixInfo(source_matrixs);
return(MagickTrue);
}
}
}
projection=(size_t *) RelinquishMagickMemory(projection);
+ degrees=RadiansToDegrees(-atan((double) skew/width/8));
+ if (image->debug != MagickFalse)
+ (void) LogMagickEvent(TransformEvent,GetMagickModule(),
+ " Deskew angle: %g",degrees);
/*
Deskew image.
*/
clone_image=CloneImage(image,0,0,MagickTrue,exception);
if (clone_image == (Image *) NULL)
return((Image *) NULL);
+ {
+ char
+ angle[MaxTextExtent];
+
+ (void) FormatLocaleString(angle,MaxTextExtent,"%.20g",degrees);
+ (void) SetImageArtifact(clone_image,"deskew:angle",angle);
+ }
(void) SetImageVirtualPixelMethod(clone_image,BackgroundVirtualPixelMethod,
exception);
- degrees=RadiansToDegrees(-atan((double) skew/width/8));
- if (image->debug != MagickFalse)
- (void) LogMagickEvent(TransformEvent,GetMagickModule(),
- " Deskew angle: %g",degrees);
affine_matrix.sx=cos(DegreesToRadians(fmod((double) degrees,360.0)));
affine_matrix.rx=sin(DegreesToRadians(fmod((double) degrees,360.0)));
affine_matrix.ry=(-sin(DegreesToRadians(fmod((double) degrees,360.0))));
GetPixelCacheTileSize(image,&tile_width,&tile_height);
tile_width=image->columns;
#if defined(MAGICKCORE_OPENMP_SUPPORT)
- #pragma omp parallel for schedule(static,4) shared(progress,status) \
- dynamic_number_threads(image,image,image->rows/tile_height,1)
+ #pragma omp parallel for schedule(static,4) shared(status) \
+ magick_threads(image,image,1,1)
#endif
for (tile_y=0; tile_y < (ssize_t) image->rows; tile_y+=(ssize_t) tile_height)
{
register ssize_t
i;
- if (GetPixelMask(image,tile_pixels) != 0)
+ if (GetPixelReadMask(image,tile_pixels) == 0)
{
tile_pixels-=width*GetPixelChannels(image);
q+=GetPixelChannels(rotate_image);
}
for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
{
- PixelChannel
- channel;
-
- PixelTrait
- rotate_traits,
- traits;
-
- channel=GetPixelChannelChannel(image,i);
- traits=GetPixelChannelTraits(image,channel);
- rotate_traits=GetPixelChannelTraits(rotate_image,channel);
+ PixelChannel channel=GetPixelChannelChannel(image,i);
+ PixelTrait traits=GetPixelChannelTraits(image,channel);
+ PixelTrait rotate_traits=GetPixelChannelTraits(rotate_image,
+ channel);
if ((traits == UndefinedPixelTrait) ||
(rotate_traits == UndefinedPixelTrait))
continue;
/*
Rotate 180 degrees.
*/
+#if defined(MAGICKCORE_OPENMP_SUPPORT)
+ #pragma omp parallel for schedule(static,4) shared(status) \
+ magick_threads(image,image,1,1)
+#endif
for (y=0; y < (ssize_t) image->rows; y++)
{
MagickBooleanType
i;
q-=GetPixelChannels(rotate_image);
- if (GetPixelMask(image,p) != 0)
+ if (GetPixelReadMask(image,p) == 0)
{
p+=GetPixelChannels(image);
continue;
}
for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
{
- PixelChannel
- channel;
-
- PixelTrait
- rotate_traits,
- traits;
-
- channel=GetPixelChannelChannel(image,i);
- traits=GetPixelChannelTraits(image,channel);
- rotate_traits=GetPixelChannelTraits(rotate_image,channel);
+ PixelChannel channel=GetPixelChannelChannel(image,i);
+ PixelTrait traits=GetPixelChannelTraits(image,channel);
+ PixelTrait rotate_traits=GetPixelChannelTraits(rotate_image,
+ channel);
if ((traits == UndefinedPixelTrait) ||
(rotate_traits == UndefinedPixelTrait))
continue;
MagickBooleanType
proceed;
+#if defined(MAGICKCORE_OPENMP_SUPPORT)
+ #pragma omp critical (MagickCore_IntegralRotateImage)
+#endif
proceed=SetImageProgress(image,RotateImageTag,progress++,
image->rows);
if (proceed == MagickFalse)
GetPixelCacheTileSize(image,&tile_width,&tile_height);
tile_width=image->columns;
#if defined(MAGICKCORE_OPENMP_SUPPORT)
- #pragma omp parallel for schedule(static,4) shared(progress,status) \
- dynamic_number_threads(image,image,image->rows/tile_height,1)
+ #pragma omp parallel for schedule(static,4) shared(status) \
+ magick_threads(image,image,1,1)
#endif
for (tile_y=0; tile_y < (ssize_t) image->rows; tile_y+=(ssize_t) tile_height)
{
register ssize_t
i;
- if (GetPixelMask(image,tile_pixels) != 0)
+ if (GetPixelReadMask(image,tile_pixels) == 0)
{
tile_pixels+=width*GetPixelChannels(image);
q+=GetPixelChannels(rotate_image);
}
for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
{
- PixelChannel
- channel;
-
- PixelTrait
- rotate_traits,
- traits;
-
- channel=GetPixelChannelChannel(image,i);
- traits=GetPixelChannelTraits(image,channel);
- rotate_traits=GetPixelChannelTraits(rotate_image,channel);
+ PixelChannel channel=GetPixelChannelChannel(image,i);
+ PixelTrait traits=GetPixelChannelTraits(image,channel);
+ PixelTrait rotate_traits=GetPixelChannelTraits(rotate_image,
+ channel);
if ((traits == UndefinedPixelTrait) ||
(rotate_traits == UndefinedPixelTrait))
continue;
image_view=AcquireAuthenticCacheView(image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(progress,status) \
- dynamic_number_threads(image,image,height,1)
+ magick_threads(image,image,height,1)
#endif
for (y=0; y < (ssize_t) height; y++)
{
{
p-=GetPixelChannels(image);
q-=GetPixelChannels(image);
- if ((size_t) (x_offset+width+step-i) >= image->columns)
+ if ((size_t) (x_offset+width+step-i) > image->columns)
continue;
GetPixelInfoPixel(image,p,&source);
CompositePixelInfoAreaBlend(&pixel,(double) pixel.alpha,
image_view=AcquireAuthenticCacheView(image,exception);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(static,4) shared(progress,status) \
- dynamic_number_threads(image,image,width,1)
+ magick_threads(image,image,width,1)
#endif
for (x=0; x < (ssize_t) width; x++)
{
{
p-=GetPixelChannels(image);
q-=GetPixelChannels(image);
- if ((size_t) (y_offset+height+step-i) >= image->rows)
+ if ((size_t) (y_offset+height+step-i) > image->rows)
continue;
GetPixelInfoPixel(image,p,&source);
CompositePixelInfoAreaBlend(&pixel,(double) pixel.alpha,
*integral_image,
*shear_image;
- ssize_t
- x_offset,
- y_offset;
-
MagickBooleanType
status;
shear;
RectangleInfo
- border_info;
-
- size_t
- y_width;
+ border_info,
+ bounds;
assert(image != (Image *) NULL);
assert(image->signature == MagickSignature);
/*
Compute image size.
*/
- y_width=image->columns+(ssize_t) floor(fabs(shear.x)*image->rows+0.5);
- x_offset=(ssize_t) ceil((double) image->columns+((fabs(shear.x)*image->rows)-
+ bounds.width=image->columns+(ssize_t) floor(fabs(shear.x)*image->rows+0.5);
+ bounds.x=(ssize_t) ceil((double) image->columns+((fabs(shear.x)*image->rows)-
image->columns)/2.0-0.5);
- y_offset=(ssize_t) ceil((double) image->rows+((fabs(shear.y)*y_width)-
+ bounds.y=(ssize_t) ceil((double) image->rows+((fabs(shear.y)*bounds.width)-
image->rows)/2.0-0.5);
/*
Surround image with border.
*/
integral_image->border_color=integral_image->background_color;
integral_image->compose=CopyCompositeOp;
- border_info.width=(size_t) x_offset;
- border_info.height=(size_t) y_offset;
+ border_info.width=(size_t) bounds.x;
+ border_info.height=(size_t) bounds.y;
shear_image=BorderImage(integral_image,&border_info,image->compose,exception);
integral_image=DestroyImage(integral_image);
if (shear_image == (Image *) NULL)
*/
if (shear_image->alpha_trait != BlendPixelTrait)
(void) SetImageAlphaChannel(shear_image,OpaqueAlphaChannel,exception);
- status=XShearImage(shear_image,shear.x,image->columns,image->rows,x_offset,
+ status=XShearImage(shear_image,shear.x,image->columns,image->rows,bounds.x,
(ssize_t) (shear_image->rows-image->rows)/2,exception);
if (status == MagickFalse)
{
shear_image=DestroyImage(shear_image);
return((Image *) NULL);
}
- status=YShearImage(shear_image,shear.y,y_width,image->rows,(ssize_t)
- (shear_image->columns-y_width)/2,y_offset,exception);
+ status=YShearImage(shear_image,shear.y,bounds.width,image->rows,(ssize_t)
+ (shear_image->columns-bounds.width)/2,bounds.y,exception);
if (status == MagickFalse)
{
shear_image=DestroyImage(shear_image);
return((Image *) NULL);
}
- status=CropToFitImage(&shear_image,shear.x,shear.y,(double)
- image->columns,(double) image->rows,MagickFalse,exception);
+ status=CropToFitImage(&shear_image,shear.x,shear.y,(MagickRealType)
+ image->columns,(MagickRealType) image->rows,MagickFalse,exception);
shear_image->compose=image->compose;
shear_image->page.width=0;
shear_image->page.height=0;
MagickBooleanType
status;
- double
+ MagickRealType
angle;
PointInfo
shear;
RectangleInfo
- border_info;
+ border_info,
+ bounds;
size_t
height,
rotations,
- width,
- y_width;
-
- ssize_t
- x_offset,
- y_offset;
+ shear_width,
+ width;
/*
Adjust rotation angle.
if (integral_image->alpha_trait != BlendPixelTrait)
(void) SetImageAlphaChannel(integral_image,OpaqueAlphaChannel,exception);
/*
- Compute image size.
+ Compute maximum bounds for 3 shear operations.
*/
- width=image->columns;
- height=image->rows;
- if ((rotations == 1) || (rotations == 3))
- {
- width=image->rows;
- height=image->columns;
- }
- y_width=width+(ssize_t) floor(fabs(shear.x)*height+0.5);
- x_offset=(ssize_t) ceil((double) width+((fabs(shear.y)*height)-width)/2.0-
- 0.5);
- y_offset=(ssize_t) ceil((double) height+((fabs(shear.y)*y_width)-height)/2.0-
- 0.5);
+ width=integral_image->columns;
+ height=integral_image->rows;
+ bounds.width=(size_t) floor(fabs((double) height*shear.x)+width+0.5);
+ bounds.height=(size_t) floor(fabs((double) bounds.width*shear.y)+height+0.5);
+ shear_width=(size_t) floor(fabs((double) bounds.height*shear.x)+
+ bounds.width+0.5);
+ bounds.x=(ssize_t) floor((double) ((shear_width > bounds.width) ? width :
+ bounds.width-shear_width+2)/2.0+0.5);
+ bounds.y=(ssize_t) floor(((double) bounds.height-height+2)/2.0+0.5);
/*
Surround image with a border.
*/
integral_image->border_color=integral_image->background_color;
integral_image->compose=CopyCompositeOp;
- border_info.width=(size_t) x_offset;
- border_info.height=(size_t) y_offset;
+ border_info.width=(size_t) bounds.x;
+ border_info.height=(size_t) bounds.y;
rotate_image=BorderImage(integral_image,&border_info,image->compose,
exception);
integral_image=DestroyImage(integral_image);
/*
Rotate the image.
*/
- status=XShearImage(rotate_image,shear.x,width,height,x_offset,(ssize_t)
+ status=XShearImage(rotate_image,shear.x,width,height,bounds.x,(ssize_t)
(rotate_image->rows-height)/2,exception);
if (status == MagickFalse)
{
rotate_image=DestroyImage(rotate_image);
return((Image *) NULL);
}
- status=YShearImage(rotate_image,shear.y,y_width,height,(ssize_t)
- (rotate_image->columns-y_width)/2,y_offset,exception);
+ status=YShearImage(rotate_image,shear.y,bounds.width,height,(ssize_t)
+ (rotate_image->columns-bounds.width)/2,bounds.y,exception);
if (status == MagickFalse)
{
rotate_image=DestroyImage(rotate_image);
return((Image *) NULL);
}
- status=XShearImage(rotate_image,shear.x,y_width,rotate_image->rows,(ssize_t)
- (rotate_image->columns-y_width)/2,0,exception);
+ status=XShearImage(rotate_image,shear.x,bounds.width,bounds.height,(ssize_t)
+ (rotate_image->columns-bounds.width)/2,(ssize_t) (rotate_image->rows-
+ bounds.height)/2,exception);
if (status == MagickFalse)
{
rotate_image=DestroyImage(rotate_image);
return((Image *) NULL);
}
- status=CropToFitImage(&rotate_image,shear.x,shear.y,(double) width,
- (double) height,MagickTrue,exception);
+ status=CropToFitImage(&rotate_image,shear.x,shear.y,(MagickRealType) width,
+ (MagickRealType) height,MagickTrue,exception);
rotate_image->compose=image->compose;
rotate_image->page.width=0;
rotate_image->page.height=0;
projects / imagemagick / blobdiff