/*

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

%                                                                             %

%                                                                             %

%                                                                             %

%                      SSSSS  H   H  EEEEE   AAA    RRRR                      %

%                      SS     H   H  E      A   A   R   R                     %

%                       SSS   HHHHH  EEE    AAAAA   RRRR                      %

%                         SS  H   H  E      A   A   R R                       %

%                      SSSSS  H   H  EEEEE  A   A   R  R                      %

%                                                                             %

%                                                                             %

%    MagickCore Methods to Shear or Rotate an Image by an Arbitrary Angle     %

%                                                                             %

%                               Software Design                               %

%                                    Cristy                                   %

%                                  July 1992                                  %

%                                                                             %

%                                                                             %

%  Copyright @ 1999 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  %

%  obtain a copy of the License at                                            %

%                                                                             %

%    https://imagemagick.org/license/                                         %

%                                                                             %

%  Unless required by applicable law or agreed to in writing, software        %

%  distributed under the License is distributed on an "AS IS" BASIS,          %

%  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.   %

%  See the License for the specific language governing permissions and        %

%  limitations under the License.                                             %

%                                                                             %

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

%

%  The XShearImage() and YShearImage() methods are based on the paper "A Fast

%  Algorithm for General Raster Rotation" by Alan W. Paeth, Graphics

%  Interface '86 (Vancouver).  ShearRotateImage() is adapted from a similar

%  method based on the Paeth paper written by Michael Halle of the Spatial

%  Imaging Group, MIT Media Lab.

%

*/

/*

  Include declarations.

*/

#include "MagickCore/studio.h"

#include "MagickCore/artifact.h"

#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/composite-private.h"

#include "MagickCore/decorate.h"

#include "MagickCore/distort.h"

#include "MagickCore/draw.h"

#include "MagickCore/exception.h"

#include "MagickCore/exception-private.h"

#include "MagickCore/gem.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"

#include "MagickCore/monitor-private.h"

#include "MagickCore/nt-base-private.h"

#include "MagickCore/pixel-accessor.h"

#include "MagickCore/profile-private.h"

#include "MagickCore/quantum.h"

#include "MagickCore/resource_.h"

#include "MagickCore/shear.h"

#include "MagickCore/statistic.h"

#include "MagickCore/string_.h"

#include "MagickCore/string-private.h"

#include "MagickCore/thread-private.h"

#include "MagickCore/threshold.h"

#include "MagickCore/transform.h"

/*

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

%                                                                             %

%                                                                             %

%                                                                             %

%   C r o p T o F i t I m a g e                                               %

%                                                                             %

%                                                                             %

%                                                                             %

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

%

%  CropToFitImage() crops the sheared image as determined by the bounding box

%  as defined by width and height and shearing angles.

%

%  The format of the CropToFitImage method is:

%

%      MagickBooleanType CropToFitImage(Image **image,

%        const double x_shear,const double x_shear,

%        const double width,const double height,

%        const MagickBooleanType rotate,ExceptionInfo *exception)

%

%  A description of each parameter follows.

%

%    o image: the image.

%

%    o x_shear, y_shear, width, height: Defines a region of the image to crop.

%

%    o exception: return any errors or warnings in this structure.

%

*/

static MagickBooleanType CropToFitImage(Image **image,

  const double x_shear,const double y_shear,

  const double width,const double height,

  const MagickBooleanType rotate,ExceptionInfo *exception)

{

  Image

    *crop_image;

  PointInfo

    extent[4],

    min,

    max;

  RectangleInfo

    geometry,

    page;

  ssize_t

    i;

  /*

    Calculate the rotated image size.

  */

  extent[0].x=(double) (-width/2.0);

  extent[0].y=(double) (-height/2.0);

  extent[1].x=(double) width/2.0;

  extent[1].y=(double) (-height/2.0);

  extent[2].x=(double) (-width/2.0);

  extent[2].y=(double) height/2.0;

  extent[3].x=(double) width/2.0;

  extent[3].y=(double) height/2.0;

  for (i=3; i >= 0; i--)

  {

    extent[i].x+=x_shear*extent[i].y;

    extent[i].y+=y_shear*extent[i].x;

    if (rotate != MagickFalse)

      extent[i].x+=x_shear*extent[i].y;

    extent[i].x+=(double) (*image)->columns/2.0;

    extent[i].y+=(double) (*image)->rows/2.0;

  }

  min=extent[0];

  max=extent[0];

  for (i=1; i < 4; i++)

  {

    if (min.x > extent[i].x)

      min.x=extent[i].x;

    if (min.y > extent[i].y)

      min.y=extent[i].y;

    if (max.x < extent[i].x)

      max.x=extent[i].x;

    if (max.y < extent[i].y)

      max.y=extent[i].y;

  }

  geometry.x=CastDoubleToSsizeT(ceil(min.x-0.5));

  geometry.y=CastDoubleToSsizeT(ceil(min.y-0.5));

  geometry.width=(size_t) CastDoubleToSsizeT(floor(max.x-min.x+0.5));

  geometry.height=(size_t) CastDoubleToSsizeT(floor(max.y-min.y+0.5));

  page=(*image)->page;

  (void) ParseAbsoluteGeometry("0x0+0+0",&(*image)->page);

  crop_image=CropImage(*image,&geometry,exception);

  if (crop_image == (Image *) NULL)

    return(MagickFalse);

  crop_image->page=page;

  *image=DestroyImage(*image);

  *image=crop_image;

  return(MagickTrue);

}

/*

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

%                                                                             %

%                                                                             %

%                                                                             %

%     D e s k e w I m a g e                                                   %

%                                                                             %

%                                                                             %

%                                                                             %

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

%

%  DeskewImage() removes skew from the image.  Skew is an artifact that

%  occurs in scanned images because of the camera being misaligned,

%  imperfections in the scanning or surface, or simply because the paper was

%  not placed completely flat when scanned.

%

%  The result will be auto-cropped 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".

%

%  The format of the DeskewImage method is:

%

%      Image *DeskewImage(const Image *image,const double threshold,

%        ExceptionInfo *exception)

%

%  A description of each parameter follows:

%

%    o image: the image.

%

%    o threshold: separate background from foreground.

%

%    o exception: return any errors or warnings in this structure.

%

*/

static void RadonProjection(MatrixInfo *source_matrices,

  MatrixInfo *destination_matrices,const ssize_t sign,size_t *projection)

{

  MatrixInfo

    *p,

    *q,

    *swap;

  size_t

    step;

  ssize_t

    x;

  p=source_matrices;

  q=destination_matrices;

  for (step=1; step < GetMatrixColumns(p); step*=2)

  {

    for (x=0; x < (ssize_t) GetMatrixColumns(p); x+=2*(ssize_t) step)

    {

      ssize_t

        i,

        y;

      unsigned short

        element,

        neighbor;

      for (i=0; i < (ssize_t) step; i++)

      {

        for (y=0; y < ((ssize_t) GetMatrixRows(p)-i-1); y++)

        {

          if (GetMatrixElement(p,x+i,y,&element) == MagickFalse)

            continue;

          if (GetMatrixElement(p,x+i+(ssize_t) step,y+i,&neighbor) == MagickFalse)

            continue;

          neighbor+=element;

          if (SetMatrixElement(q,x+2*i,y,&neighbor) == MagickFalse)

            continue;

          if (GetMatrixElement(p,x+i+(ssize_t) step,y+i+1,&neighbor) == MagickFalse)

            continue;

          neighbor+=element;

          if (SetMatrixElement(q,x+2*i+1,y,&neighbor) == MagickFalse)

            continue;

        }

        for ( ; y < ((ssize_t) GetMatrixRows(p)-i); y++)

        {

          if (GetMatrixElement(p,x+i,y,&element) == MagickFalse)

            continue;

          if (GetMatrixElement(p,x+i+(ssize_t) 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) GetMatrixRows(p); y++)

        {

          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;

        }

      }

    }

    swap=p;

    p=q;

    q=swap;

  }

#if defined(MAGICKCORE_OPENMP_SUPPORT)

  #pragma omp parallel for schedule(static) \

    num_threads((int) GetMagickResourceLimit(ThreadResource))

#endif

  for (x=0; x < (ssize_t) GetMatrixColumns(p); x++)

  {

    size_t

      sum;

    ssize_t

      y;

    sum=0;

    for (y=0; y < (ssize_t) (GetMatrixRows(p)-1); y++)

    {

      ssize_t

        delta;

      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+=(size_t) (delta*delta);

    }

    projection[(ssize_t) GetMatrixColumns(p)+sign*x-1]=sum;

  }

}

static MagickBooleanType RadonTransform(const Image *image,

  const double threshold,size_t *projection,ExceptionInfo *exception)

{

  CacheView

    *image_view;

  MatrixInfo

    *destination_matrices,

    *source_matrices;

  MagickBooleanType

    status;

  size_t

    count,

    width;

  ssize_t

    j,

    y;

  unsigned char

    c;

  unsigned short

    bits[256];

  for (width=1; width < ((image->columns+7)/8); width<<=1) ;

  source_matrices=AcquireMatrixInfo(width,image->rows,sizeof(unsigned short),

    exception);

  destination_matrices=AcquireMatrixInfo(width,image->rows,

    sizeof(unsigned short),exception);

  if ((source_matrices == (MatrixInfo *) NULL) ||

      (destination_matrices == (MatrixInfo *) NULL))

    {

      if (destination_matrices != (MatrixInfo *) NULL)

        destination_matrices=DestroyMatrixInfo(destination_matrices);

      if (source_matrices != (MatrixInfo *) NULL)

        source_matrices=DestroyMatrixInfo(source_matrices);

      return(MagickFalse);

    }

  if (NullMatrix(source_matrices) == MagickFalse)

    {

      destination_matrices=DestroyMatrixInfo(destination_matrices);

      source_matrices=DestroyMatrixInfo(source_matrices);

      return(MagickFalse);

    }

  for (j=0; j < 256; j++)

  {

    c=(unsigned char) j;

    for (count=0; c != 0; c>>=1)

      count+=c & 0x01;

    bits[j]=(unsigned short) count;

  }

  status=MagickTrue;

  image_view=AcquireVirtualCacheView(image,exception);

#if defined(MAGICKCORE_OPENMP_SUPPORT)

  #pragma omp parallel for schedule(static) shared(status) \

    magick_number_threads(image,image,image->rows,2)

#endif

  for (y=0; y < (ssize_t) image->rows; y++)

  {

    const Quantum

      *magick_restrict p;

    size_t

      bit,

      byte;

    ssize_t

      i,

      x;

    unsigned short

      value;

    if (status == MagickFalse)

      continue;

    p=GetCacheViewVirtualPixels(image_view,0,y,image->columns,1,exception);

    if (p == (const Quantum *) NULL)

      {

        status=MagickFalse;

        continue;

      }

    bit=0;

    byte=0;

    i=(ssize_t) (image->columns+7)/8;

    for (x=0; x < (ssize_t) image->columns; x++)

    {

      byte<<=1;

      if (((MagickRealType) GetPixelRed(image,p) < threshold) ||

          ((MagickRealType) GetPixelGreen(image,p) < threshold) ||

          ((MagickRealType) GetPixelBlue(image,p) < threshold))

        byte|=0x01;

      bit++;

      if (bit == 8)

        {

          value=bits[byte];

          (void) SetMatrixElement(source_matrices,--i,y,&value);

          bit=0;

          byte=0;

        }

      p+=(ptrdiff_t) GetPixelChannels(image);

    }

    if (bit != 0)

      {

        byte<<=(8-bit);

        value=bits[byte];

        (void) SetMatrixElement(source_matrices,--i,y,&value);

      }

  }

  RadonProjection(source_matrices,destination_matrices,-1,projection);

  (void) NullMatrix(source_matrices);

#if defined(MAGICKCORE_OPENMP_SUPPORT)

  #pragma omp parallel for schedule(static) shared(status) \

    magick_number_threads(image,image,image->rows,2)

#endif

  for (y=0; y < (ssize_t) image->rows; y++)

  {

    const Quantum

      *magick_restrict p;

    size_t

      bit,

      byte;

    ssize_t

      i,

      x;

    unsigned short

     value;

    if (status == MagickFalse)

      continue;

    p=GetCacheViewVirtualPixels(image_view,0,y,image->columns,1,exception);

    if (p == (const Quantum *) NULL)

      {

        status=MagickFalse;

        continue;

      }

    bit=0;

    byte=0;

    i=0;

    for (x=0; x < (ssize_t) image->columns; x++)

    {

      byte<<=1;

      if (((MagickRealType) GetPixelRed(image,p) < threshold) ||

          ((MagickRealType) GetPixelGreen(image,p) < threshold) ||

          ((MagickRealType) GetPixelBlue(image,p) < threshold))

        byte|=0x01;

      bit++;

      if (bit == 8)

        {

          value=bits[byte];

          (void) SetMatrixElement(source_matrices,i++,y,&value);

          bit=0;

          byte=0;

        }

      p+=(ptrdiff_t) GetPixelChannels(image);

    }

    if (bit != 0)

      {

        byte<<=(8-bit);

        value=bits[byte];

        (void) SetMatrixElement(source_matrices,i++,y,&value);

      }

  }

  RadonProjection(source_matrices,destination_matrices,1,projection);

  image_view=DestroyCacheView(image_view);

  destination_matrices=DestroyMatrixInfo(destination_matrices);

  source_matrices=DestroyMatrixInfo(source_matrices);

  return(MagickTrue);

}

static void GetImageBackgroundColor(Image *image,const ssize_t offset,

  ExceptionInfo *exception)

{

  CacheView

    *image_view;

  double

    count;

  PixelInfo

    background;

  ssize_t

    y;

  /*

    Compute average background color.

  */

  if (offset <= 0)

    return;

  GetPixelInfo(image,&background);

  count=0.0;

  image_view=AcquireVirtualCacheView(image,exception);

  for (y=0; y < (ssize_t) image->rows; y++)

  {

    const Quantum

      *magick_restrict p;

    ssize_t

      x;

    if ((y >= offset) && (y < ((ssize_t) image->rows-offset)))

      continue;

    p=GetCacheViewVirtualPixels(image_view,0,y,image->columns,1,exception);

    if (p == (const Quantum *) NULL)

      continue;

    for (x=0; x < (ssize_t) image->columns; x++)

    {

      if ((x >= offset) && (x < ((ssize_t) image->columns-offset)))

        continue;

      background.red+=QuantumScale*(double) GetPixelRed(image,p);

      background.green+=QuantumScale*(double) GetPixelGreen(image,p);

      background.blue+=QuantumScale*(double) GetPixelBlue(image,p);

      if ((GetPixelAlphaTraits(image) & UpdatePixelTrait) != 0)

        background.alpha+=QuantumScale*(double) GetPixelAlpha(image,p);

      count++;

      p+=(ptrdiff_t) GetPixelChannels(image);

    }

  }

  image_view=DestroyCacheView(image_view);

  image->background_color.red=(double) ClampToQuantum((double) QuantumRange*

    (double) background.red/count);

  image->background_color.green=(double) ClampToQuantum((double) QuantumRange*

    (double) background.green/count);

  image->background_color.blue=(double) ClampToQuantum((double) QuantumRange*

    (double) background.blue/count);

  if ((GetPixelAlphaTraits(image) & UpdatePixelTrait) != 0)

    image->background_color.alpha=(double) ClampToQuantum((double) QuantumRange*

      (double) background.alpha/count);

}

MagickExport Image *DeskewImage(const Image *image,const double threshold,

  ExceptionInfo *exception)

{

  AffineMatrix

    affine_matrix;

  const char

    *artifact;

  double

    degrees;

  Image

    *clone_image,

    *crop_image,

    *deskew_image,

    *median_image;

  MagickBooleanType

    status;

  RectangleInfo

    geometry;

  size_t

    max_projection,

    *projection,

    width;

  ssize_t

    i,

    skew;

  /*

    Compute deskew angle.

  */

  for (width=1; width < ((image->columns+7)/8); width<<=1) ;

  projection=(size_t *) AcquireQuantumMemory((size_t) (2*width-1),

    sizeof(*projection));

  if (projection == (size_t *) NULL)

    ThrowImageException(ResourceLimitError,"MemoryAllocationFailed");

  status=RadonTransform(image,threshold,projection,exception);

  if (status == MagickFalse)

    {

      projection=(size_t *) RelinquishMagickMemory(projection);

      ThrowImageException(ResourceLimitError,"MemoryAllocationFailed");

    }

  max_projection=0;

  skew=0;

  for (i=0; i < (ssize_t) (2*width-1); i++)

  {

    if (projection[i] > max_projection)

      {

        skew=i-(ssize_t) width+1;

        max_projection=projection[i];

      }

  }

  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[MagickPathExtent];

    (void) FormatLocaleString(angle,MagickPathExtent,"%.20g",degrees);

    (void) SetImageArtifact(clone_image,"deskew:angle",angle);

  }

  (void) SetImageVirtualPixelMethod(clone_image,BackgroundVirtualPixelMethod,

    exception);

  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))));

  affine_matrix.sy=cos(DegreesToRadians(fmod((double) degrees,360.0)));

  affine_matrix.tx=0.0;

  affine_matrix.ty=0.0;

  artifact=GetImageArtifact(image,"deskew:auto-crop");

  if (IsStringTrue(artifact) == MagickFalse)

    {

      deskew_image=AffineTransformImage(clone_image,&affine_matrix,exception);

      clone_image=DestroyImage(clone_image);

      return(deskew_image);

    }

  /*

    Auto-crop image.

  */

  GetImageBackgroundColor(clone_image,(ssize_t) StringToLong(artifact),

    exception);

  deskew_image=AffineTransformImage(clone_image,&affine_matrix,exception);

  clone_image=DestroyImage(clone_image);

  if (deskew_image == (Image *) NULL)

    return((Image *) NULL);

  median_image=StatisticImage(deskew_image,MedianStatistic,3,3,exception);

  if (median_image == (Image *) NULL)

    {

      deskew_image=DestroyImage(deskew_image);

      return((Image *) NULL);

    }

  geometry=GetImageBoundingBox(median_image,exception);

  median_image=DestroyImage(median_image);

  if (image->debug != MagickFalse)

    (void) LogMagickEvent(TransformEvent,GetMagickModule(),"  Deskew geometry: "

      "%.20gx%.20g%+.20g%+.20g",(double) geometry.width,(double)

      geometry.height,(double) geometry.x,(double) geometry.y);

  crop_image=CropImage(deskew_image,&geometry,exception);

  deskew_image=DestroyImage(deskew_image);

  return(crop_image);

}

/*

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

%                                                                             %

%                                                                             %

%                                                                             %

%   I n t e g r a l R o t a t e I m a g e                                     %

%                                                                             %

%                                                                             %

%                                                                             %

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

%

%  IntegralRotateImage() rotates the image an integral of 90 degrees.  It

%  allocates the memory necessary for the new Image structure and returns a

%  pointer to the rotated image.

%

%  The format of the IntegralRotateImage method is:

%

%      Image *IntegralRotateImage(const Image *image,size_t rotations,

%        ExceptionInfo *exception)

%

%  A description of each parameter follows.

%

%    o image: the image.

%

%    o rotations: Specifies the number of 90 degree rotations.

%

*/

MagickExport Image *IntegralRotateImage(const Image *image,size_t rotations,

  ExceptionInfo *exception)

{

#define RotateImageTag  "Rotate/Image"

  CacheView

    *image_view,

    *rotate_view;

  Image

    *rotate_image;

  MagickBooleanType

    status;

  MagickOffsetType

    progress;

  RectangleInfo

    page;

  /*

    Initialize rotated image attributes.

  */

  assert(image != (Image *) NULL);

  page=image->page;

  rotations%=4;

  switch (rotations)

  {

    case 0:

    default:

    {

      rotate_image=CloneImage(image,0,0,MagickTrue,exception);

      break;

    }

    case 2:

    {

      rotate_image=CloneImage(image,image->columns,image->rows,MagickTrue,

        exception);

      break;

    }

    case 1:

    case 3:

    {

      rotate_image=CloneImage(image,image->rows,image->columns,MagickTrue,

        exception);

      break;

    }

  }

  if (rotate_image == (Image *) NULL)

    return((Image *) NULL);

  if (rotations == 0)

    return(rotate_image);

  /*

    Integral rotate the image.

  */

  status=MagickTrue;

  progress=0;

  image_view=AcquireVirtualCacheView(image,exception);

  rotate_view=AcquireAuthenticCacheView(rotate_image,exception);

  switch (rotations)

  {

    case 1:

    {

      size_t

        tile_height,

        tile_width;

      ssize_t

        tile_y;

      /*

        Rotate 90 degrees.

      */

      GetPixelCacheTileSize(image,&tile_width,&tile_height);

      tile_width=image->columns;

#if defined(MAGICKCORE_OPENMP_SUPPORT)

      #pragma omp parallel for schedule(static) shared(status) \

        magick_number_threads(image,rotate_image,image->rows/tile_height,2)

#endif

      for (tile_y=0; tile_y < (ssize_t) image->rows; tile_y+=(ssize_t) tile_height)

      {

        ssize_t

          tile_x;

        if (status == MagickFalse)

          continue;

        tile_x=0;

        for ( ; tile_x < (ssize_t) image->columns; tile_x+=(ssize_t) tile_width)

        {

          const Quantum

            *magick_restrict p;

          MagickBooleanType

            sync;

          Quantum

            *magick_restrict q;

          size_t

            height,

            width;

          ssize_t

            y;

          width=tile_width;

          if ((tile_width+(size_t) tile_x) > image->columns)

            width=(size_t) ((ssize_t) tile_width-(tile_x+(ssize_t) tile_width-

              (ssize_t) image->columns));

          height=tile_height;

          if ((tile_height+(size_t) tile_y) > image->rows)

            height=(size_t) ((ssize_t) tile_height-(tile_y+(ssize_t)

              tile_height-(ssize_t) image->rows));

          p=GetCacheViewVirtualPixels(image_view,tile_x,tile_y,width,height,

            exception);

          if (p == (const Quantum *) NULL)

            {

              status=MagickFalse;

              break;

            }

          for (y=0; y < (ssize_t) width; y++)

          {

            const Quantum

              *magick_restrict tile_pixels;

            ssize_t

              x;

            if (status == MagickFalse)

              continue;

            q=QueueCacheViewAuthenticPixels(rotate_view,(ssize_t)

              rotate_image->columns-(tile_y+(ssize_t) height),y+tile_x,height,

              1,exception);

            if (q == (Quantum *) NULL)

              {

                status=MagickFalse;

                continue;

              }

            tile_pixels=p+(((ssize_t) height-1)*(ssize_t) width+y)*(ssize_t)

              GetPixelChannels(image);

            for (x=0; x < (ssize_t) height; x++)

            {

              ssize_t

                i;

              for (i=0; i < (ssize_t) GetPixelChannels(image); i++)

              {

                PixelChannel channel = GetPixelChannelChannel(image,i);

                PixelTrait traits = GetPixelChannelTraits(image,channel);

                PixelTrait rotate_traits = GetPixelChannelTraits(rotate_image,

                  channel);

                if ((traits == UndefinedPixelTrait) ||

                    (rotate_traits == UndefinedPixelTrait))

                  continue;

                SetPixelChannel(rotate_image,channel,tile_pixels[i],q);

              }

              tile_pixels-=width*GetPixelChannels(image);

              q+=(ptrdiff_t) GetPixelChannels(rotate_image);

            }

            sync=SyncCacheViewAuthenticPixels(rotate_view,exception);

            if (sync == MagickFalse)

              status=MagickFalse;

          }

        }

        if (image->progress_monitor != (MagickProgressMonitor) NULL)

          {

            MagickBooleanType

              proceed;

            proceed=SetImageProgress(image,RotateImageTag,

              progress+=(MagickOffsetType) tile_height,image->rows);

            if (proceed == MagickFalse)

              status=MagickFalse;

          }

      }

      (void) SetImageProgress(image,RotateImageTag,(MagickOffsetType)

        image->rows-1,image->rows);

      Swap(page.width,page.height);

      Swap(page.x,page.y);

      if (page.width != 0)

        page.x=(ssize_t) page.width-(ssize_t) rotate_image->columns-page.x;

      break;

    }

    case 2:

    {

      ssize_t

        y;

      /*

        Rotate 180 degrees.

      */

#if defined(MAGICKCORE_OPENMP_SUPPORT)

      #pragma omp parallel for schedule(static) shared(status) \

        magick_number_threads(image,rotate_image,image->rows,2)

#endif

      for (y=0; y < (ssize_t) image->rows; y++)

      {

        const Quantum

          *magick_restrict p;

        MagickBooleanType

          sync;

        Quantum

          *magick_restrict q;

        ssize_t

          x;

        if (status == MagickFalse)

          continue;

        p=GetCacheViewVirtualPixels(image_view,0,y,image->columns,1,exception);

        q=QueueCacheViewAuthenticPixels(rotate_view,0,(ssize_t) image->rows-y-1,

          image->columns,1,exception);

        if ((p == (const Quantum *) NULL) || (q == (Quantum *) NULL))

          {