自学教程：C++ GetCacheViewVirtualPixels函数代码示例

/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%                                                                             %%                                                                             %%                                                                             %%   G e t I m a g e V i e w I t e r a t o r                                   %%                                                                             %%                                                                             %%                                                                             %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%  GetImageViewIterator() iterates over the image view in parallel and calls%  your get method for each scanline of the view.  The pixel extent is%  not confined to the image canvas-- that is you can include negative offsets%  or widths or heights that exceed the image dimension.  Any updates to%  the pixels in your callback are ignored.%%  The callback signature is:%%      MagickBooleanType GetImageViewMethod(const ImageView *source,%        const ssize_t y,const int thread_id,void *context)%%  Use this pragma if the view is not single threaded:%%    #pragma omp critical%%  to define a section of code in your callback get method that must be%  executed by a single thread at a time.%%  The format of the GetImageViewIterator method is:%%      MagickBooleanType GetImageViewIterator(ImageView *source,%        GetImageViewMethod get,void *context)%%  A description of each parameter follows:%%    o source: the source image view.%%    o get: the get callback method.%%    o context: the user defined context.%*/MagickExport MagickBooleanType GetImageViewIterator(ImageView *source,  GetImageViewMethod get,void *context){  Image    *source_image;  MagickBooleanType    status;  MagickOffsetType    progress;  ssize_t    y;  assert(source != (ImageView *) NULL);  assert(source->signature == MagickSignature);  if (get == (GetImageViewMethod) NULL)    return(MagickFalse);  source_image=source->image;  status=MagickTrue;  progress=0;#if defined(MAGICKCORE_OPENMP_SUPPORT)  #pragma omp parallel for schedule(static,1) shared(progress,status) num_threads(source->number_threads)#endif  for (y=source->extent.y; y < (ssize_t) source->extent.height; y++)  {    const int      id = GetOpenMPThreadId();    register const PixelPacket      *pixels;    if (status == MagickFalse)      continue;    pixels=GetCacheViewVirtualPixels(source->view,source->extent.x,y,      source->extent.width,1,source->exception);    if (pixels == (const PixelPacket *) NULL)      {        status=MagickFalse;        continue;      }    if (get(source,y,id,context) == MagickFalse)      status=MagickFalse;    if (source_image->progress_monitor != (MagickProgressMonitor) NULL)      {        MagickBooleanType          proceed;#if defined(MAGICKCORE_OPENMP_SUPPORT)  #pragma omp critical (MagickCore_GetImageViewIterator)#endif        proceed=SetImageProgress(source_image,source->description,progress++,          source->extent.height);        if (proceed == MagickFalse)          status=MagickFalse;      }//.........这里部分代码省略.........

/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%                                                                             %%                                                                             %%                                                                             %%     I s I m a g e G r a y                                                   %%                                                                             %%                                                                             %%                                                                             %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%  IsImageGray() returns MagickTrue if all the pixels in the image have the%  same red, green, and blue intensities.%%  The format of the IsImageGray method is:%%      MagickBooleanType IsImageGray(const Image *image,%        ExceptionInfo *exception)%%  A description of each parameter follows:%%    o image: the image.%%    o exception: return any errors or warnings in this structure.%*/MagickExport MagickBooleanType IsImageGray(const Image *image,  ExceptionInfo *exception){  CacheView    *image_view;  ImageType    type;  register const Quantum    *p;  register ssize_t    x;  ssize_t    y;  assert(image != (Image *) NULL);  assert(image->signature == MagickSignature);  if (image->debug != MagickFalse)    (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);  if ((image->type == BilevelType) || (image->type == GrayscaleType) ||      (image->type == GrayscaleMatteType))    return(MagickTrue);  if ((IsGrayColorspace(image->colorspace) == MagickFalse) &&      (IssRGBCompatibleColorspace(image->colorspace) == MagickFalse))    return(MagickFalse);  type=BilevelType;  image_view=AcquireVirtualCacheView(image,exception);  for (y=0; y < (ssize_t) image->rows; y++)  {    p=GetCacheViewVirtualPixels(image_view,0,y,image->columns,1,exception);    if (p == (const Quantum *) NULL)      break;    for (x=0; x < (ssize_t) image->columns; x++)    {      if (IsPixelGray(image,p) == MagickFalse)        {          type=UndefinedType;          break;        }      if ((type == BilevelType) &&          (IsPixelMonochrome(image,p) == MagickFalse))        type=GrayscaleType;      p+=GetPixelChannels(image);    }    if (type == UndefinedType)      break;  }  image_view=DestroyCacheView(image_view);  if (type == UndefinedType)    return(MagickFalse);  ((Image *) image)->type=type;  if ((type == GrayscaleType) && (image->alpha_trait == BlendPixelTrait))    ((Image *) image)->type=GrayscaleMatteType;  return(SetImageColorspace((Image *) image,GRAYColorspace,exception));}

/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%                                                                             %%                                                                             %%                                                                             %%     I s G r a y I m a g e                                                   %%                                                                             %%                                                                             %%                                                                             %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%  IsGrayImage() returns MagickTrue if all the pixels in the image have the%  same red, green, and blue intensities.%%  The format of the IsGrayImage method is:%%      MagickBooleanType IsGrayImage(const Image *image,%        ExceptionInfo *exception)%%  A description of each parameter follows:%%    o image: the image.%%    o exception: return any errors or warnings in this structure.%*/MagickExport MagickBooleanType IsGrayImage(const Image *image,  ExceptionInfo *exception){  CacheView    *image_view;  ImageType    type;  long    y;  register const PixelPacket    *p;  register long    x;  assert(image != (Image *) NULL);  assert(image->signature == MagickSignature);  if (image->debug != MagickFalse)    (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);  if ((image->type == BilevelType) || (image->type == GrayscaleType) ||      (image->type == GrayscaleMatteType))    return(MagickTrue);  if (image->colorspace == CMYKColorspace)    return(MagickFalse);  type=BilevelType;  image_view=AcquireCacheView(image);  for (y=0; y < (long) image->rows; y++)  {    p=GetCacheViewVirtualPixels(image_view,0,y,image->columns,1,exception);    if (p == (const PixelPacket *) NULL)      break;    for (x=0; x < (long) image->columns; x++)    {      if (IsGrayPixel(p) == MagickFalse)        {          type=UndefinedType;          break;        }      if ((type == BilevelType) && (IsMonochromePixel(p) == MagickFalse))        type=GrayscaleType;      p++;    }    if (type == UndefinedType)      break;  }  image_view=DestroyCacheView(image_view);  if (type == UndefinedType)    return(MagickFalse);  ((Image *) image)->type=type;  if ((type == GrayscaleType) && (image->matte != MagickFalse))    ((Image *) image)->type=GrayscaleMatteType;  return(MagickTrue);}

MAGICK_NET_EXPORT const Quantum *PixelCollection_GetArea(const CacheView *instance, const size_t x, const size_t y, const size_t width, const size_t height, ExceptionInfo **exception){  const Quantum    *pixels;  MAGICK_NET_GET_EXCEPTION;  pixels = GetCacheViewVirtualPixels(instance, x, y, width, height, exceptionInfo);  MAGICK_NET_SET_EXCEPTION;  return pixels;}

const Magick::PixelPacket* Magick::Pixels::getConst(const ssize_t x_,  const ssize_t y_,const size_t columns_,const size_t rows_){  _x=x_;  _y=y_;  _columns=columns_;  _rows=rows_;  GetPPException;  const PixelPacket* pixels=GetCacheViewVirtualPixels(_view,x_,y_,columns_,    rows_,exceptionInfo);  ThrowPPException(_image.quiet());  return pixels;}

const Magick::PixelPacket* Magick::Pixels::getConst(const ssize_t x_,  const ssize_t y_,const size_t columns_,const size_t rows_){  _x=x_;  _y=y_;  _columns=columns_;  _rows=rows_;  const PixelPacket* pixels=GetCacheViewVirtualPixels(_view,x_,y_,columns_,    rows_,&_exception);  if (!pixels)    throwException(_exception);  return pixels;}

/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%                                                                             %%                                                                             %%                                                                             %%     I s I m a g e O p a q u e                                               %%                                                                             %%                                                                             %%                                                                             %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%  IsImageOpaque() returns MagickTrue if none of the pixels in the image have%  an alpha value other than OpaqueAlpha (QuantumRange).%%  Will return true immediatally is alpha channel is not available.%%  The format of the IsImageOpaque method is:%%      MagickBooleanType IsImageOpaque(const Image *image,%        ExceptionInfo *exception)%%  A description of each parameter follows:%%    o image: the image.%%    o exception: return any errors or warnings in this structure.%*/MagickExport MagickBooleanType IsImageOpaque(const Image *image,  ExceptionInfo *exception){  CacheView    *image_view;  register const Quantum    *p;  register ssize_t    x;  ssize_t    y;  /*    Determine if image is opaque.  */  assert(image != (Image *) NULL);  assert(image->signature == MagickSignature);  if (image->debug != MagickFalse)    (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);  if (image->alpha_trait != BlendPixelTrait)    return(MagickTrue);  image_view=AcquireVirtualCacheView(image,exception);  for (y=0; y < (ssize_t) image->rows; y++)  {    p=GetCacheViewVirtualPixels(image_view,0,y,image->columns,1,exception);    if (p == (const Quantum *) NULL)      break;    for (x=0; x < (ssize_t) image->columns; x++)    {      if (GetPixelAlpha(image,p) != OpaqueAlpha)        break;      p+=GetPixelChannels(image);    }    if (x < (ssize_t) image->columns)     break;  }  image_view=DestroyCacheView(image_view);  return(y < (ssize_t) image->rows ? MagickFalse : MagickTrue);}

/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%                                                                             %%                                                                             %%                                                                             %%     I s O p a q u e I m a g e                                               %%                                                                             %%                                                                             %%                                                                             %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%  IsOpaqueImage() returns MagickTrue if none of the pixels in the image have%  an opacity value other than opaque (0).%%  The format of the IsOpaqueImage method is:%%      MagickBooleanType IsOpaqueImage(const Image *image,%        ExceptionInfo *exception)%%  A description of each parameter follows:%%    o image: the image.%%    o exception: return any errors or warnings in this structure.%*/MagickExport MagickBooleanType IsOpaqueImage(const Image *image,  ExceptionInfo *exception){  CacheView    *image_view;  long    y;  register const PixelPacket    *p;  register long    x;  /*    Determine if image is opaque.  */  assert(image != (Image *) NULL);  assert(image->signature == MagickSignature);  if (image->debug != MagickFalse)    (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);  if (image->matte == MagickFalse)    return(MagickTrue);  image_view=AcquireCacheView(image);  for (y=0; y < (long) image->rows; y++)  {    p=GetCacheViewVirtualPixels(image_view,0,y,image->columns,1,exception);    if (p == (const PixelPacket *) NULL)      break;    for (x=0; x < (long) image->columns; x++)    {      if (p->opacity != OpaqueOpacity)        break;      p++;    }    if (x < (long) image->columns)     break;  }  image_view=DestroyCacheView(image_view);  return(y < (long) image->rows ? MagickFalse : MagickTrue);}

//.........这里部分代码省略.........    {      channel_features=(ChannelFeatures *) RelinquishMagickMemory(        channel_features);      (void) ThrowMagickException(exception,GetMagickModule(),        ResourceLimitError,"MemoryAllocationFailed","`%s'",image->filename);      return(channel_features);    }  for (i=0; i <= (ssize_t) MaxMap; i++)  {    grays[i].red=(~0U);    grays[i].green=(~0U);    grays[i].blue=(~0U);    grays[i].opacity=(~0U);    grays[i].index=(~0U);  }  status=MagickTrue;  image_view=AcquireCacheView(image);#if defined(MAGICKCORE_OPENMP_SUPPORT)  #pragma omp parallel for schedule(static,4) shared(status)#endif  for (y=0; y < (ssize_t) image->rows; y++)  {    register const IndexPacket      *restrict indexes;    register const PixelPacket      *restrict p;    register ssize_t      x;    if (status == MagickFalse)      continue;    p=GetCacheViewVirtualPixels(image_view,0,y,image->columns,1,exception);    if (p == (const PixelPacket *) NULL)      {        status=MagickFalse;        continue;      }    indexes=GetCacheViewVirtualIndexQueue(image_view);    for (x=0; x < (ssize_t) image->columns; x++)    {      grays[ScaleQuantumToMap(GetPixelRed(p))].red=        ScaleQuantumToMap(GetPixelRed(p));      grays[ScaleQuantumToMap(GetPixelGreen(p))].green=        ScaleQuantumToMap(GetPixelGreen(p));      grays[ScaleQuantumToMap(GetPixelBlue(p))].blue=        ScaleQuantumToMap(GetPixelBlue(p));      if (image->colorspace == CMYKColorspace)        grays[ScaleQuantumToMap(GetPixelIndex(indexes+x))].index=          ScaleQuantumToMap(GetPixelIndex(indexes+x));      if (image->matte != MagickFalse)        grays[ScaleQuantumToMap(GetPixelOpacity(p))].opacity=          ScaleQuantumToMap(GetPixelOpacity(p));      p++;    }  }  image_view=DestroyCacheView(image_view);  if (status == MagickFalse)    {      grays=(LongPixelPacket *) RelinquishMagickMemory(grays);      channel_features=(ChannelFeatures *) RelinquishMagickMemory(        channel_features);      return(channel_features);    }  (void) ResetMagickMemory(&gray,0,sizeof(gray));

//.........这里部分代码省略.........    object[i].id=i;    object[i].bounding_box.x=(ssize_t) image->columns;    object[i].bounding_box.y=(ssize_t) image->rows;    GetPixelInfo(image,&object[i].color);  }  /*    Find connected components.  */  status=MagickTrue;  progress=0;  image_view=AcquireVirtualCacheView(image,exception);  for (n=0; n < (ssize_t) (connectivity > 4 ? 4 : 2); n++)  {    ssize_t      connect4[2][2] = { { -1,  0 }, {  0, -1 } },      connect8[4][2] = { { -1, -1 }, { -1,  0 }, { -1,  1 }, {  0, -1 } },      dx,      dy;    if (status == MagickFalse)      continue;    dy=connectivity > 4 ? connect8[n][0] : connect4[n][0];    dx=connectivity > 4 ? connect8[n][1] : connect4[n][1];    for (y=0; y < (ssize_t) image->rows; y++)    {      register const Quantum        *magick_restrict p;      register ssize_t        x;      if (status == MagickFalse)        continue;      p=GetCacheViewVirtualPixels(image_view,0,y-1,image->columns,3,exception);      if (p == (const Quantum *) NULL)        {          status=MagickFalse;          continue;        }      p+=GetPixelChannels(image)*image->columns;      for (x=0; x < (ssize_t) image->columns; x++)      {        PixelInfo          pixel,          target;        ssize_t          neighbor_offset,          object,          offset,          ox,          oy,          root;        /*          Is neighbor an authentic pixel and a different color than the pixel?        */        GetPixelInfoPixel(image,p,&pixel);        neighbor_offset=dy*(GetPixelChannels(image)*image->columns)+dx*          GetPixelChannels(image);        GetPixelInfoPixel(image,p+neighbor_offset,&target);        if (((x+dx) < 0) || ((x+dx) >= (ssize_t) image->columns) ||            ((y+dy) < 0) || ((y+dy) >= (ssize_t) image->rows) ||            (IsFuzzyEquivalencePixelInfo(&pixel,&target) == MagickFalse))          {            p+=GetPixelChannels(image);

static MagickBooleanType InverseFourier(FourierInfo *fourier_info,  const Image *magnitude_image,const Image *phase_image,fftw_complex *fourier,  ExceptionInfo *exception){  CacheView    *magnitude_view,    *phase_view;  double    *magnitude,    *phase,    *magnitude_source,    *phase_source;  MagickBooleanType    status;  register const IndexPacket    *indexes;  register const PixelPacket    *p;  register ssize_t    i,    x;  ssize_t    y;  /*    Inverse fourier - read image and break down into a double array.  */  magnitude_source=(double *) AcquireQuantumMemory((size_t)    fourier_info->height,fourier_info->width*sizeof(*magnitude_source));  if (magnitude_source == (double *) NULL)    {      (void) ThrowMagickException(exception,GetMagickModule(),        ResourceLimitError,"MemoryAllocationFailed","`%s'",        magnitude_image->filename);      return(MagickFalse);    }  phase_source=(double *) AcquireQuantumMemory((size_t) fourier_info->height,    fourier_info->width*sizeof(*phase_source));  if (phase_source == (double *) NULL)    {      (void) ThrowMagickException(exception,GetMagickModule(),        ResourceLimitError,"MemoryAllocationFailed","`%s'",        magnitude_image->filename);      magnitude_source=(double *) RelinquishMagickMemory(magnitude_source);      return(MagickFalse);    }  i=0L;  magnitude_view=AcquireVirtualCacheView(magnitude_image,exception);  for (y=0L; y < (ssize_t) fourier_info->height; y++)  {    p=GetCacheViewVirtualPixels(magnitude_view,0L,y,fourier_info->width,1UL,      exception);    if (p == (const PixelPacket *) NULL)      break;    indexes=GetCacheViewAuthenticIndexQueue(magnitude_view);    for (x=0L; x < (ssize_t) fourier_info->width; x++)    {      switch (fourier_info->channel)      {        case RedChannel:        default:        {          magnitude_source[i]=QuantumScale*GetPixelRed(p);          break;        }        case GreenChannel:        {          magnitude_source[i]=QuantumScale*GetPixelGreen(p);          break;        }        case BlueChannel:        {          magnitude_source[i]=QuantumScale*GetPixelBlue(p);          break;        }        case OpacityChannel:        {          magnitude_source[i]=QuantumScale*GetPixelOpacity(p);          break;        }        case IndexChannel:        {          magnitude_source[i]=QuantumScale*GetPixelIndex(indexes+x);          break;        }        case GrayChannels:        {          magnitude_source[i]=QuantumScale*GetPixelGray(p);          break;        }      }      i++;      p++;    }//.........这里部分代码省略.........

static MagickBooleanType ForwardFourierTransform(FourierInfo *fourier_info,  const Image *image,double *magnitude,double *phase,ExceptionInfo *exception){  CacheView    *image_view;  double    n,    *source;  fftw_complex    *fourier;  fftw_plan    fftw_r2c_plan;  register const IndexPacket    *indexes;  register const PixelPacket    *p;  register ssize_t    i,    x;  ssize_t    y;  /*    Generate the forward Fourier transform.  */  source=(double *) AcquireQuantumMemory((size_t) fourier_info->height,    fourier_info->width*sizeof(*source));  if (source == (double *) NULL)    {      (void) ThrowMagickException(exception,GetMagickModule(),        ResourceLimitError,"MemoryAllocationFailed","`%s'",image->filename);      return(MagickFalse);    }  ResetMagickMemory(source,0,fourier_info->height*fourier_info->width*    sizeof(*source));  i=0L;  image_view=AcquireVirtualCacheView(image,exception);  for (y=0L; y < (ssize_t) fourier_info->height; y++)  {    p=GetCacheViewVirtualPixels(image_view,0L,y,fourier_info->width,1UL,      exception);    if (p == (const PixelPacket *) NULL)      break;    indexes=GetCacheViewVirtualIndexQueue(image_view);    for (x=0L; x < (ssize_t) fourier_info->width; x++)    {      switch (fourier_info->channel)      {        case RedChannel:        default:        {          source[i]=QuantumScale*GetPixelRed(p);          break;        }        case GreenChannel:        {          source[i]=QuantumScale*GetPixelGreen(p);          break;        }        case BlueChannel:        {          source[i]=QuantumScale*GetPixelBlue(p);          break;        }        case OpacityChannel:        {          source[i]=QuantumScale*GetPixelOpacity(p);          break;        }        case IndexChannel:        {          source[i]=QuantumScale*GetPixelIndex(indexes+x);          break;        }        case GrayChannels:        {          source[i]=QuantumScale*GetPixelGray(p);          break;        }      }      i++;      p++;    }  }  image_view=DestroyCacheView(image_view);  fourier=(fftw_complex *) AcquireQuantumMemory((size_t) fourier_info->height,    fourier_info->center*sizeof(*fourier));  if (fourier == (fftw_complex *) NULL)    {      (void) ThrowMagickException(exception,GetMagickModule(),        ResourceLimitError,"MemoryAllocationFailed","`%s'",image->filename);      source=(double *) RelinquishMagickMemory(source);      return(MagickFalse);//.........这里部分代码省略.........

//.........这里部分代码省略.........  */  assert(image != (const Image *) NULL);  assert(image->signature == MagickSignature);  if (image->debug != MagickFalse)    (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);  assert(exception != (ExceptionInfo *) NULL);  assert(exception->signature == MagickSignature);  combine_image=CloneImage(image,0,0,MagickTrue,exception);  if (combine_image == (Image *) NULL)    return((Image *) NULL);  if (SetImageStorageClass(combine_image,DirectClass,exception) == MagickFalse)    {      combine_image=DestroyImage(combine_image);      return((Image *) NULL);    }  (void) SetImageColorspace(combine_image,colorspace,exception);  if ((GetPixelAlphaTraits(image) & UpdatePixelTrait) != 0)    combine_image->alpha_trait=BlendPixelTrait;  /*    Combine images.  */  status=MagickTrue;  progress=0;  combine_view=AcquireAuthenticCacheView(combine_image,exception);  for (y=0; y < (ssize_t) combine_image->rows; y++)  {    CacheView      *image_view;    const Image      *next;    Quantum      *pixels;    register const Quantum      *restrict p;    register Quantum      *restrict q;    register ssize_t      i;    if (status == MagickFalse)      continue;    pixels=GetCacheViewAuthenticPixels(combine_view,0,y,combine_image->columns,      1,exception);    if (pixels == (Quantum *) NULL)      {        status=MagickFalse;        continue;      }    next=image;    for (i=0; i < (ssize_t) GetPixelChannels(combine_image); i++)    {      register ssize_t        x;      PixelChannel channel=GetPixelChannelChannel(combine_image,i);      PixelTrait traits=GetPixelChannelTraits(combine_image,channel);      if (traits == UndefinedPixelTrait)        continue;      if (next == (Image *) NULL)        continue;      image_view=AcquireVirtualCacheView(next,exception);      p=GetCacheViewVirtualPixels(image_view,0,y,next->columns,1,exception);      if (p == (const Quantum *) NULL)        continue;      q=pixels;      for (x=0; x < (ssize_t) combine_image->columns; x++)      {        if (x < (ssize_t) next->columns)          {            q[i]=GetPixelGray(next,p);            p+=GetPixelChannels(next);          }        q+=GetPixelChannels(combine_image);      }      image_view=DestroyCacheView(image_view);      next=GetNextImageInList(next);    }    if (SyncCacheViewAuthenticPixels(combine_view,exception) == MagickFalse)      status=MagickFalse;    if (image->progress_monitor != (MagickProgressMonitor) NULL)      {        MagickBooleanType          proceed;        proceed=SetImageProgress(image,CombineImageTag,progress++,          combine_image->rows);        if (proceed == MagickFalse)          status=MagickFalse;      }  }  combine_view=DestroyCacheView(combine_view);  if (status == MagickFalse)    combine_image=DestroyImage(combine_image);  return(combine_image);}

/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%                                                                             %%                                                                             %%                                                                             %%   S i g n a t u r e I m a g e                                               %%                                                                             %%                                                                             %%                                                                             %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%  SignatureImage() computes a message digest from an image pixel stream with%  an implementation of the NIST SHA-256 Message Digest algorithm.  This%  signature uniquely identifies the image and is convenient for determining%  if an image has been modified or whether two images are identical.%%  The format of the SignatureImage method is:%%      MagickBooleanType SignatureImage(Image *image,ExceptionInfo *exception)%%  A description of each parameter follows:%%    o image: the image.%%    o exception: return any errors or warnings in this structure.%*/MagickExport MagickBooleanType SignatureImage(Image *image,  ExceptionInfo *exception){  CacheView    *image_view;  char    *hex_signature;  double    pixel;  register const Quantum    *p;  SignatureInfo    *signature_info;  ssize_t    y;  StringInfo    *signature;  unsigned char    *pixels;  /*    Compute image digital signature.  */  assert(image != (Image *) NULL);  assert(image->signature == MagickSignature);  if (image->debug != MagickFalse)    (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);  signature_info=AcquireSignatureInfo();  signature=AcquireStringInfo(image->columns*GetPixelChannels(image)*    sizeof(pixel));  image_view=AcquireVirtualCacheView(image,exception);  for (y=0; y < (ssize_t) image->rows; y++)  {    register ssize_t      x;    register unsigned char      *q;    p=GetCacheViewVirtualPixels(image_view,0,y,image->columns,1,exception);    if (p == (const Quantum *) NULL)      break;    SetStringInfoLength(signature,image->columns*GetPixelChannels(image)*      sizeof(pixel));    pixels=GetStringInfoDatum(signature);    q=pixels;    for (x=0; x < (ssize_t) image->columns; x++)    {      register ssize_t        i;      if (GetPixelReadMask(image,p) == 0)        {          p+=GetPixelChannels(image);          continue;        }      for (i=0; i < (ssize_t) GetPixelChannels(image); i++)      {        register ssize_t          j;        PixelChannel channel=GetPixelChannelChannel(image,i);        PixelTrait traits=GetPixelChannelTraits(image,channel);        if (traits == UndefinedPixelTrait)          continue;        pixel=QuantumScale*p[i];//.........这里部分代码省略.........

/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%                                                                             %%                                                                             %%                                                                             %+   G e t I m a g e B o u n d i n g B o x                                     %%                                                                             %%                                                                             %%                                                                             %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%  GetImageBoundingBox() returns the bounding box of an image canvas.%%  The format of the GetImageBoundingBox method is:%%      RectangleInfo GetImageBoundingBox(const Image *image,%        ExceptionInfo *exception)%%  A description of each parameter follows:%%    o bounds: Method GetImageBoundingBox returns the bounding box of an%      image canvas.%%    o image: the image.%%    o exception: return any errors or warnings in this structure.%*/MagickExport RectangleInfo GetImageBoundingBox(const Image *image,  ExceptionInfo *exception){  CacheView    *image_view;  MagickBooleanType    status;  PixelInfo    target[3],    zero;  RectangleInfo    bounds;  register const Quantum    *p;  ssize_t    y;  assert(image != (Image *) NULL);  assert(image->signature == MagickSignature);  if (image->debug != MagickFalse)    (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);  bounds.width=0;  bounds.height=0;  bounds.x=(ssize_t) image->columns;  bounds.y=(ssize_t) image->rows;  GetPixelInfo(image,&target[0]);  image_view=AcquireVirtualCacheView(image,exception);  p=GetCacheViewVirtualPixels(image_view,0,0,1,1,exception);  if (p == (const Quantum *) NULL)    {      image_view=DestroyCacheView(image_view);      return(bounds);    }  GetPixelInfoPixel(image,p,&target[0]);  GetPixelInfo(image,&target[1]);  p=GetCacheViewVirtualPixels(image_view,(ssize_t) image->columns-1,0,1,1,    exception);  GetPixelInfoPixel(image,p,&target[1]);  GetPixelInfo(image,&target[2]);  p=GetCacheViewVirtualPixels(image_view,0,(ssize_t) image->rows-1,1,1,    exception);  GetPixelInfoPixel(image,p,&target[2]);  status=MagickTrue;  GetPixelInfo(image,&zero);#if defined(MAGICKCORE_OPENMP_SUPPORT)  #pragma omp parallel for schedule(static,4) shared(status) /    magick_threads(image,image,image->rows,1)#endif  for (y=0; y < (ssize_t) image->rows; y++)  {    PixelInfo      pixel;    RectangleInfo      bounding_box;    register const Quantum      *restrict p;    register ssize_t      x;    if (status == MagickFalse)      continue;#if defined(MAGICKCORE_OPENMP_SUPPORT)#  pragma omp critical (MagickCore_GetImageBoundingBox)#endif//.........这里部分代码省略.........

//.........这里部分代码省略.........  for (y=0; y < (ssize_t) combine_image->rows; y++)  {    CacheView      *image_view;    const Image      *next;    PixelPacket      *pixels;    register const PixelPacket      *restrict p;    register PixelPacket      *restrict q;    register ssize_t      x;    if (status == MagickFalse)      continue;    pixels=GetCacheViewAuthenticPixels(combine_view,0,y,combine_image->columns,      1,exception);    if (pixels == (PixelPacket *) NULL)      {        status=MagickFalse;        continue;      }    next=image;    if (((channel & RedChannel) != 0) && (next != (Image *) NULL))      {        image_view=AcquireVirtualCacheView(next,exception);        p=GetCacheViewVirtualPixels(image_view,0,y,next->columns,1,exception);        if (p == (const PixelPacket *) NULL)          continue;        q=pixels;        for (x=0; x < (ssize_t) combine_image->columns; x++)        {          SetPixelRed(q,ClampToQuantum(GetPixelIntensity(image,p)));          p++;          q++;        }        image_view=DestroyCacheView(image_view);        next=GetNextImageInList(next);      }    if (((channel & GreenChannel) != 0) && (next != (Image *) NULL))      {        image_view=AcquireVirtualCacheView(next,exception);        p=GetCacheViewVirtualPixels(image_view,0,y,next->columns,1,exception);        if (p == (const PixelPacket *) NULL)          continue;        q=pixels;        for (x=0; x < (ssize_t) combine_image->columns; x++)        {          SetPixelGreen(q,ClampToQuantum(GetPixelIntensity(image,p)));          p++;          q++;        }        image_view=DestroyCacheView(image_view);        next=GetNextImageInList(next);      }    if (((channel & BlueChannel) != 0) && (next != (Image *) NULL))      {        image_view=AcquireVirtualCacheView(next,exception);        p=GetCacheViewVirtualPixels(image_view,0,y,next->columns,1,exception);

//.........这里部分代码省略.........    brightness_sum_x=0.0;    brightness_sum_x2=0.0;    brightness_sum_x3=0.0;    brightness_sum_x4=0.0;    brightness_mean=0.0;    brightness_standard_deviation=0.0;    brightness_kurtosis=0.0;    brightness_skewness=0.0;    saturation_sum_x=0.0;    saturation_sum_x2=0.0;    saturation_sum_x3=0.0;    saturation_sum_x4=0.0;    saturation_mean=0.0;    saturation_standard_deviation=0.0;    saturation_kurtosis=0.0;    saturation_skewness=0.0;    area=0.0;    status=MagickTrue;    image_view=AcquireCacheView(image);#if defined(MAGICKCORE_OPENMP_SUPPORT)    #pragma omp parallel for schedule(dynamic,4) shared(status)#endif    for (y=0; y < (ssize_t) image->rows; y++)    {      register const PixelPacket        *p;      register ssize_t        x;      if (status == MagickFalse)        continue;      p=GetCacheViewVirtualPixels(image_view,0,y,image->columns,1,exception);      if (p == (const PixelPacket *) NULL)        {          status=MagickFalse;          continue;        }      for (x=0; x < (ssize_t) image->columns; x++)      {        ConvertRGBToHSB(GetRedPixelComponent(p),GetGreenPixelComponent(p),          GetBluePixelComponent(p),&hue,&saturation,&brightness);        brightness*=QuantumRange;        brightness_sum_x+=brightness;        brightness_sum_x2+=brightness*brightness;        brightness_sum_x3+=brightness*brightness*brightness;        brightness_sum_x4+=brightness*brightness*brightness*brightness;        saturation*=QuantumRange;        saturation_sum_x+=saturation;        saturation_sum_x2+=saturation*saturation;        saturation_sum_x3+=saturation*saturation*saturation;        saturation_sum_x4+=saturation*saturation*saturation*saturation;        area++;        p++;      }    }    image_view=DestroyCacheView(image_view);    if (area <= 0.0)      break;    brightness_mean=brightness_sum_x/area;    (void) FormatMagickString(text,MaxTextExtent,"%g",brightness_mean);    (void) SetImageProperty(image,"filter:brightness:mean",text);    brightness_standard_deviation=sqrt(brightness_sum_x2/area-(brightness_sum_x/      area*brightness_sum_x/area));    (void) FormatMagickString(text,MaxTextExtent,"%g",

/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%                                                                             %%                                                                             %%                                                                             %%   I s M o n o c h r o m e I m a g e                                         %%                                                                             %%                                                                             %%                                                                             %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%  IsMonochromeImage() returns MagickTrue if all the pixels in the image have%  the same red, green, and blue intensities and the intensity is either%  0 or QuantumRange.%%  The format of the IsMonochromeImage method is:%%      MagickBooleanType IsMonochromeImage(const Image *image,%        ExceptionInfo *exception)%%  A description of each parameter follows:%%    o image: the image.%%    o exception: return any errors or warnings in this structure.%*/MagickExport MagickBooleanType IsMonochromeImage(const Image *image,  ExceptionInfo *exception){  ImageType    type;  register const PixelPacket    *p;  assert(image != (Image *) NULL);  assert(image->signature == MagickSignature);  if (image->debug != MagickFalse)    (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);  if (image->type == BilevelType)    return(MagickTrue);  if (image->colorspace == CMYKColorspace)    return(MagickFalse);  type=BilevelType;  switch (image->storage_class)  {    case DirectClass:    case UndefinedClass:    {      long        y;      register long        x;      CacheView        *image_view;      image_view=AcquireCacheView(image);      for (y=0; y < (long) image->rows; y++)      {        p=GetCacheViewVirtualPixels(image_view,0,y,image->columns,1,exception);        if (p == (const PixelPacket *) NULL)          break;        for (x=0; x < (long) image->columns; x++)        {          if (IsMonochromePixel(p) == MagickFalse)            {              type=UndefinedType;              break;            }          p++;        }        if (type == UndefinedType)          break;      }      image_view=DestroyCacheView(image_view);      if (y == (long) image->rows)        ((Image *) image)->type=BilevelType;      break;    }    case PseudoClass:    {      register long        i;      p=image->colormap;      for (i=0; i < (long) image->colors; i++)      {        if (IsMonochromePixel(p) == MagickFalse)          {            type=UndefinedType;            break;          }        p++;      }      break;    }  }//.........这里部分代码省略.........

//.........这里部分代码省略.........      frame_indexes++;    }    for (x=0; x < (ssize_t) (frame_info->x-bevel_width); x++)    {      SetPixelPacket(frame_image,&matte,q,frame_indexes);      q++;      frame_indexes++;    }    for (x=0; x < (ssize_t) frame_info->inner_bevel; x++)    {      SetPixelPacket(frame_image,&shadow,q,frame_indexes);      q++;      frame_indexes++;    }    /*      Set frame interior to interior color.    */    if ((image->compose != CopyCompositeOp) &&        ((image->compose != OverCompositeOp) || (image->matte != MagickFalse)))      for (x=0; x < (ssize_t) image->columns; x++)      {        SetPixelPacket(frame_image,&interior,q,frame_indexes);        q++;        frame_indexes++;      }    else      {        register const IndexPacket          *indexes;        register const PixelPacket          *p;        p=GetCacheViewVirtualPixels(image_view,0,y,image->columns,1,exception);        if (p == (const PixelPacket *) NULL)          {            status=MagickFalse;            continue;          }        indexes=GetCacheViewVirtualIndexQueue(image_view);        (void) CopyMagickMemory(q,p,image->columns*sizeof(*p));        if ((image->colorspace == CMYKColorspace) &&            (frame_image->colorspace == CMYKColorspace))          {            (void) CopyMagickMemory(frame_indexes,indexes,image->columns*              sizeof(*indexes));            frame_indexes+=image->columns;          }        q+=image->columns;      }    for (x=0; x < (ssize_t) frame_info->inner_bevel; x++)    {      SetPixelPacket(frame_image,&highlight,q,frame_indexes);      q++;      frame_indexes++;    }    width=frame_info->width-frame_info->x-image->columns-bevel_width;    for (x=0; x < (ssize_t) width; x++)    {      SetPixelPacket(frame_image,&matte,q,frame_indexes);      q++;      frame_indexes++;    }    for (x=0; x < (ssize_t) frame_info->outer_bevel; x++)    {      SetPixelPacket(frame_image,&shadow,q,frame_indexes);

//.........这里部分代码省略.........        status=MagickFalse;        continue;      }    for (x=0; x < (ssize_t) frame_info->outer_bevel; x++)    {      SetPixelInfoPixel(frame_image,&highlight,q);      q+=GetPixelChannels(frame_image);    }    for (x=0; x < (ssize_t) (frame_info->x-bevel_width); x++)    {      SetPixelInfoPixel(frame_image,&matte,q);      q+=GetPixelChannels(frame_image);    }    for (x=0; x < (ssize_t) frame_info->inner_bevel; x++)    {      SetPixelInfoPixel(frame_image,&shadow,q);      q+=GetPixelChannels(frame_image);    }    /*      Set frame interior to interior color.    */    if ((compose != CopyCompositeOp) && ((compose != OverCompositeOp) ||        (image->matte != MagickFalse)))      for (x=0; x < (ssize_t) image->columns; x++)      {        SetPixelInfoPixel(frame_image,&interior,q);        q+=GetPixelChannels(frame_image);      }    else      {        register const Quantum          *p;        p=GetCacheViewVirtualPixels(image_view,0,y,image->columns,1,exception);        if (p == (const Quantum *) NULL)          {            status=MagickFalse;            continue;          }        for (x=0; x < (ssize_t) image->columns; x++)        {          if ((GetPixelRedTraits(image) & UpdatePixelTrait) != 0)            SetPixelRed(frame_image,GetPixelRed(image,p),q);          if ((GetPixelGreenTraits(image) & UpdatePixelTrait) != 0)            SetPixelGreen(frame_image,GetPixelGreen(image,p),q);          if ((GetPixelBlueTraits(image) & UpdatePixelTrait) != 0)            SetPixelBlue(frame_image,GetPixelBlue(image,p),q);          if ((GetPixelBlackTraits(image) & UpdatePixelTrait) != 0)            SetPixelBlack(frame_image,GetPixelBlack(image,p),q);          if ((GetPixelAlphaTraits(image) & UpdatePixelTrait) != 0)            SetPixelAlpha(frame_image,GetPixelAlpha(image,p),q);          p+=GetPixelChannels(image);          q+=GetPixelChannels(frame_image);        }      }    for (x=0; x < (ssize_t) frame_info->inner_bevel; x++)    {      SetPixelInfoPixel(frame_image,&highlight,q);      q+=GetPixelChannels(frame_image);    }    width=frame_info->width-frame_info->x-image->columns-bevel_width;    for (x=0; x < (ssize_t) width; x++)    {      SetPixelInfoPixel(frame_image,&matte,q);      q+=GetPixelChannels(frame_image);    }

/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%                                                                             %%                                                                             %%                                                                             %%     S e p a r a t e I m a g e                                               %%                                                                             %%                                                                             %%                                                                             %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%  SeparateImage() separates a channel from the image and returns it as a%  grayscale image.%%  The format of the SeparateImage method is:%%      Image *SeparateImage(const Image *image,const ChannelType channel,%        ExceptionInfo *exception)%%  A description of each parameter follows:%%    o image: the image.%%    o channel: the image channel.%%    o exception: return any errors or warnings in this structure.%*/MagickExport Image *SeparateImage(const Image *image,  const ChannelType channel_type,ExceptionInfo *exception){#define GetChannelBit(mask,bit)  (((size_t) (mask) >> (size_t) (bit)) & 0x01)#define SeparateImageTag  "Separate/Image"  CacheView    *image_view,    *separate_view;  Image    *separate_image;  MagickBooleanType    status;  MagickOffsetType    progress;  ssize_t    y;  /*    Initialize separate image attributes.  */  assert(image != (Image *) NULL);  assert(image->signature == MagickSignature);  if (image->debug != MagickFalse)    (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);  assert(exception != (ExceptionInfo *) NULL);  assert(exception->signature == MagickSignature);  separate_image=CloneImage(image,image->columns,image->rows,MagickTrue,    exception);  if (separate_image == (Image *) NULL)    return((Image *) NULL);  if (SetImageStorageClass(separate_image,DirectClass,exception) == MagickFalse)    {      separate_image=DestroyImage(separate_image);      return((Image *) NULL);    }  (void) SetImageColorspace(separate_image,GRAYColorspace,exception);  separate_image->alpha_trait=UndefinedPixelTrait;  /*    Separate image.  */  status=MagickTrue;  progress=0;  image_view=AcquireVirtualCacheView(image,exception);  separate_view=AcquireAuthenticCacheView(separate_image,exception);#if defined(MAGICKCORE_OPENMP_SUPPORT)  #pragma omp parallel for schedule(static,4) shared(progress,status) /    magick_threads(image,image,image->rows,1)#endif  for (y=0; y < (ssize_t) image->rows; y++)  {    register const Quantum      *restrict p;    register Quantum      *restrict q;    register ssize_t      x;    if (status == MagickFalse)      continue;    p=GetCacheViewVirtualPixels(image_view,0,y,image->columns,1,exception);    q=QueueCacheViewAuthenticPixels(separate_view,0,y,separate_image->columns,1,      exception);    if ((p == (const Quantum *) NULL) || (q == (Quantum *) NULL))      {        status=MagickFalse;//.........这里部分代码省略.........

//.........这里部分代码省略.........%    o context: the user defined context.%*/MagickExport MagickBooleanType DuplexTransferImageViewIterator(  ImageView *source,ImageView *duplex,ImageView *destination,  DuplexTransferImageViewMethod transfer,void *context){  ExceptionInfo    *exception;  Image    *destination_image,    *source_image;  MagickBooleanType    status;  MagickOffsetType    progress;  ssize_t    y;  assert(source != (ImageView *) NULL);  assert(source->signature == MagickSignature);  if (transfer == (DuplexTransferImageViewMethod) NULL)    return(MagickFalse);  source_image=source->image;  destination_image=destination->image;  if (SetImageStorageClass(destination_image,DirectClass) == MagickFalse)    return(MagickFalse);  status=MagickTrue;  progress=0;  exception=destination->exception;#if defined(MAGICKCORE_OPENMP_SUPPORT)  #pragma omp parallel for schedule(static,1) shared(progress,status) num_threads(source->number_threads)#endif  for (y=source->extent.y; y < (ssize_t) source->extent.height; y++)  {    const int      id = GetOpenMPThreadId();    MagickBooleanType      sync;    register const PixelPacket      *__restrict__ duplex_pixels,      *__restrict__ pixels;    register PixelPacket      *__restrict__ destination_pixels;    if (status == MagickFalse)      continue;    pixels=GetCacheViewVirtualPixels(source->view,source->extent.x,y,      source->extent.width,1,source->exception);    if (pixels == (const PixelPacket *) NULL)      {        status=MagickFalse;        continue;      }    duplex_pixels=GetCacheViewVirtualPixels(duplex->view,duplex->extent.x,y,      duplex->extent.width,1,duplex->exception);    if (duplex_pixels == (const PixelPacket *) NULL)      {        status=MagickFalse;        continue;      }    destination_pixels=GetCacheViewAuthenticPixels(destination->view,      destination->extent.x,y,destination->extent.width,1,exception);    if (destination_pixels == (PixelPacket *) NULL)      {        status=MagickFalse;        continue;      }    if (transfer(source,duplex,destination,y,id,context) == MagickFalse)      status=MagickFalse;    sync=SyncCacheViewAuthenticPixels(destination->view,exception);    if (sync == MagickFalse)      {        InheritException(destination->exception,GetCacheViewException(          source->view));        status=MagickFalse;      }    if (source_image->progress_monitor != (MagickProgressMonitor) NULL)      {        MagickBooleanType          proceed;#if defined(MAGICKCORE_OPENMP_SUPPORT)  #pragma omp critical (MagickCore_DuplexTransferImageViewIterator)#endif        proceed=SetImageProgress(source_image,source->description,progress++,          source->extent.height);        if (proceed == MagickFalse)          status=MagickFalse;      }  }  return(status);}

//.........这里部分代码省略.........        for (depth=1; depth < MAGICKCORE_QUANTUM_DEPTH; depth++)        {          Quantum            pixel;          QuantumAny            range;          range=GetQuantumRange(depth);          pixel=(Quantum) i;          if (pixel == ScaleAnyToQuantum(ScaleQuantumToAny(pixel,range),range))            break;        }        depth_map[i]=depth;      }#if defined(MAGICKCORE_OPENMP_SUPPORT)      #pragma omp parallel for schedule(static,4) shared(status) /        magick_threads(image,image,image->rows,1)#endif      for (y=0; y < (ssize_t) image->rows; y++)      {        const int          id = GetOpenMPThreadId();        register const Quantum          *restrict p;        register ssize_t          x;        if (status == MagickFalse)          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++)        {          register ssize_t            i;          if (GetPixelReadMask(image,p) == 0)            {              p+=GetPixelChannels(image);              continue;            }          for (i=0; i < (ssize_t) GetPixelChannels(image); i++)          {            PixelChannel channel=GetPixelChannelChannel(image,i);            PixelTrait traits=GetPixelChannelTraits(image,channel);            if ((traits == UndefinedPixelTrait) ||                (channel == IndexPixelChannel) ||                (channel == ReadMaskPixelChannel) || (channel == MetaPixelChannel))              continue;            if (depth_map[ScaleQuantumToMap(p[i])] > current_depth[id])              current_depth[id]=depth_map[ScaleQuantumToMap(p[i])];          }          p+=GetPixelChannels(image);        }        if (current_depth[id] == MAGICKCORE_QUANTUM_DEPTH)          status=MagickFalse;      }      image_view=DestroyCacheView(image_view);      depth=current_depth[0];      for (id=1; id < (ssize_t) number_threads; id++)        if (depth < current_depth[id])

//.........这里部分代码省略.........          continue;        while (current_depth[id] < MAGICKCORE_QUANTUM_DEPTH)        {          MagickStatusType            status;          QuantumAny            range;          status=0;          range=GetQuantumRange(current_depth[id]);          if ((GetPixelRedTraits(image) & UpdatePixelTrait) != 0)            status|=p->red != ScaleAnyToQuantum(ScaleQuantumToAny(p->red,              range),range);          if ((GetPixelGreenTraits(image) & UpdatePixelTrait) != 0)            status|=p->green != ScaleAnyToQuantum(ScaleQuantumToAny(p->green,              range),range);          if ((GetPixelBlueTraits(image) & UpdatePixelTrait) != 0)            status|=p->blue != ScaleAnyToQuantum(ScaleQuantumToAny(p->blue,              range),range);          if (status == 0)            break;          current_depth[id]++;        }        p++;      }      depth=current_depth[0];      for (id=1; id < (ssize_t) number_threads; id++)        if (depth < current_depth[id])          depth=current_depth[id];      current_depth=(size_t *) RelinquishMagickMemory(current_depth);      return(depth);    }  image_view=AcquireCacheView(image);#if defined(MAGICKCORE_OPENMP_SUPPORT)  #pragma omp parallel for schedule(static,4) shared(status)#endif  for (y=0; y < (ssize_t) image->rows; y++)  {    const int      id = GetOpenMPThreadId();    register const Quantum      *restrict p;    register ssize_t      x;    if (status == MagickFalse)      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++)    {      register ssize_t        i;      for (i=0; i < (ssize_t) GetPixelChannels(image); i++)      {        PixelChannel          channel;        PixelTrait          traits;        channel=GetPixelChannelMapChannel(image,i);        traits=GetPixelChannelMapTraits(image,channel);        if (traits == UndefinedPixelTrait)          continue;        while (current_depth[id] < MAGICKCORE_QUANTUM_DEPTH)        {          MagickStatusType            status;          QuantumAny            range;          status=0;          range=GetQuantumRange(current_depth[id]);          status|=p[i] != ScaleAnyToQuantum(ScaleQuantumToAny(p[i],range),            range);          if (status == 0)            break;          current_depth[id]++;        }      }      p+=GetPixelChannels(image);    }    if (current_depth[id] == MAGICKCORE_QUANTUM_DEPTH)      status=MagickFalse;  }  image_view=DestroyCacheView(image_view);  depth=current_depth[0];  for (id=1; id < (ssize_t) number_threads; id++)    if (depth < current_depth[id])      depth=current_depth[id];  current_depth=(size_t *) RelinquishMagickMemory(current_depth);  return(depth);}

/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%                                                                             %%                                                                             %%                                                                             %+   G e t I m a g e B o u n d i n g B o x                                     %%                                                                             %%                                                                             %%                                                                             %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%  GetImageBoundingBox() returns the bounding box of an image canvas.%%  The format of the GetImageBoundingBox method is:%%      RectangleInfo GetImageBoundingBox(const Image *image,%        ExceptionInfo *exception)%%  A description of each parameter follows:%%    o bounds: Method GetImageBoundingBox returns the bounding box of an%      image canvas.%%    o image: the image.%%    o exception: return any errors or warnings in this structure.%*/MagickExport RectangleInfo GetImageBoundingBox(const Image *image,  ExceptionInfo *exception){  CacheView    *image_view;  long    y;  MagickBooleanType    status;  MagickPixelPacket    target[3],    zero;  RectangleInfo    bounds;  register const PixelPacket    *p;  assert(image != (Image *) NULL);  assert(image->signature == MagickSignature);  if (image->debug != MagickFalse)    (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);  bounds.width=0;  bounds.height=0;  bounds.x=(long) image->columns;  bounds.y=(long) image->rows;  GetMagickPixelPacket(image,&target[0]);  image_view=AcquireCacheView(image);  p=GetCacheViewVirtualPixels(image_view,0,0,1,1,exception);  if (p == (const PixelPacket *) NULL)    {      image_view=DestroyCacheView(image_view);      return(bounds);    }  SetMagickPixelPacket(image,p,GetCacheViewAuthenticIndexQueue(image_view),    &target[0]);  GetMagickPixelPacket(image,&target[1]);  p=GetCacheViewVirtualPixels(image_view,(long) image->columns-1,0,1,1,    exception);  SetMagickPixelPacket(image,p,GetCacheViewAuthenticIndexQueue(image_view),    &target[1]);  GetMagickPixelPacket(image,&target[2]);  p=GetCacheViewVirtualPixels(image_view,0,(long) image->rows-1,1,1,exception);  SetMagickPixelPacket(image,p,GetCacheViewAuthenticIndexQueue(image_view),    &target[2]);  status=MagickTrue;  GetMagickPixelPacket(image,&zero);#if defined(MAGICKCORE_OPENMP_SUPPORT)  #pragma omp parallel for schedule(dynamic,4) shared(status)#endif  for (y=0; y < (long) image->rows; y++)  {    MagickPixelPacket      pixel;    RectangleInfo      bounding_box;    register const IndexPacket      *restrict indexes;    register const PixelPacket      *restrict p;    register long      x;    if (status == MagickFalse)//.........这里部分代码省略.........

static MagickBooleanType ChannelImage(Image *destination_image,  const PixelChannel destination_channel,const ChannelFx channel_op,  const Image *source_image,const PixelChannel source_channel,  const Quantum pixel,ExceptionInfo *exception){  CacheView    *source_view,    *destination_view;  MagickBooleanType    status;  size_t    height,    width;  ssize_t    y;  status=MagickTrue;  source_view=AcquireVirtualCacheView(source_image,exception);  destination_view=AcquireAuthenticCacheView(destination_image,exception);  height=MagickMin(source_image->rows,destination_image->rows);  width=MagickMin(source_image->columns,destination_image->columns);#if defined(MAGICKCORE_OPENMP_SUPPORT)  #pragma omp parallel for schedule(static,4) shared(status) /    magick_threads(source_image,source_image,height,1)#endif  for (y=0; y < (ssize_t) height; y++)  {    PixelTrait      destination_traits,      source_traits;    register const Quantum      *restrict p;    register Quantum      *restrict q;    register ssize_t      x;    if (status == MagickFalse)      continue;    p=GetCacheViewVirtualPixels(source_view,0,y,source_image->columns,1,      exception);    q=GetCacheViewAuthenticPixels(destination_view,0,y,      destination_image->columns,1,exception);    if ((p == (const Quantum *) NULL) || (q == (Quantum *) NULL))      {        status=MagickFalse;        continue;      }    destination_traits=GetPixelChannelTraits(destination_image,      destination_channel);    source_traits=GetPixelChannelTraits(source_image,source_channel);    if ((destination_traits == UndefinedPixelTrait) ||        (source_traits == UndefinedPixelTrait))      continue;    for (x=0; x < (ssize_t) width; x++)    {      if (channel_op == AssignChannelOp)        SetPixelChannel(destination_image,destination_channel,pixel,q);      else        SetPixelChannel(destination_image,destination_channel,          GetPixelChannel(source_image,source_channel,p),q);      p+=GetPixelChannels(source_image);      q+=GetPixelChannels(destination_image);    }    if (SyncCacheViewAuthenticPixels(destination_view,exception) == MagickFalse)      status=MagickFalse;  }  destination_view=DestroyCacheView(destination_view);  source_view=DestroyCacheView(source_view);  return(status);}

/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%                                                                             %%                                                                             %%                                                                             %%   G e t I m a g e T o t a l I n k D e n s i t y                             %%                                                                             %%                                                                             %%                                                                             %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%  GetImageTotalInkDensity() returns the total ink density for a CMYK image.%  Total Ink Density (TID) is determined by adding the CMYK values in the%  darkest shadow area in an image.%%  The format of the GetImageTotalInkDensity method is:%%      double GetImageTotalInkDensity(const Image *image,%        ExceptionInfo *exception)%%  A description of each parameter follows:%%    o image: the image.%%    o exception: return any errors or warnings in this structure.%*/MagickExport double GetImageTotalInkDensity(Image *image,  ExceptionInfo *exception){  CacheView    *image_view;  double    total_ink_density;  MagickBooleanType    status;  ssize_t    y;  assert(image != (Image *) NULL);  if (image->debug != MagickFalse)    (void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");  assert(image->signature == MagickCoreSignature);  if (image->colorspace != CMYKColorspace)    {      (void) ThrowMagickException(exception,GetMagickModule(),ImageError,        "ColorSeparatedImageRequired","`%s'",image->filename);      return(0.0);    }  status=MagickTrue;  total_ink_density=0.0;  image_view=AcquireVirtualCacheView(image,exception);#if defined(MAGICKCORE_OPENMP_SUPPORT)  #pragma omp parallel for schedule(static,4) shared(status) /    magick_threads(image,image,image->rows,1)#endif  for (y=0; y < (ssize_t) image->rows; y++)  {    double      density;    register const Quantum      *p;    register ssize_t      x;    p=GetCacheViewVirtualPixels(image_view,0,y,image->columns,1,exception);    if (p == (const Quantum *) NULL)      {        status=MagickFalse;        continue;      }    for (x=0; x < (ssize_t) image->columns; x++)    {      density=(double) GetPixelRed(image,p)+GetPixelGreen(image,p)+        GetPixelBlue(image,p)+GetPixelBlack(image,p);      if (density > total_ink_density)#if defined(MAGICKCORE_OPENMP_SUPPORT)        #pragma omp critical (MagickCore_GetImageTotalInkDensity)#endif        {          if (density > total_ink_density)            total_ink_density=density;        }      p+=GetPixelChannels(image);    }  }  image_view=DestroyCacheView(image_view);  if (status == MagickFalse)    total_ink_density=0.0;  return(total_ink_density);}

//.........这里部分代码省略.........        while (current_depth[id] < MAGICKCORE_QUANTUM_DEPTH)        {          MagickStatusType            status;          QuantumAny            range;          status=0;          range=GetQuantumRange(current_depth[id]);          if ((channel & RedChannel) != 0)            status|=p->red != ScaleAnyToQuantum(ScaleQuantumToAny(p->red,              range),range);          if ((channel & GreenChannel) != 0)            status|=p->green != ScaleAnyToQuantum(ScaleQuantumToAny(p->green,              range),range);          if ((channel & BlueChannel) != 0)            status|=p->blue != ScaleAnyToQuantum(ScaleQuantumToAny(p->blue,              range),range);          if (status == 0)            break;          current_depth[id]++;        }        p++;      }      depth=current_depth[0];      for (id=1; id < (long) number_threads; id++)        if (depth < current_depth[id])          depth=current_depth[id];      current_depth=(unsigned long *) RelinquishMagickMemory(current_depth);      return(depth);    }  image_view=AcquireCacheView(image);#if defined(MAGICKCORE_OPENMP_SUPPORT)  #pragma omp parallel for schedule(dynamic,4) shared(status)#endif  for (y=0; y < (long) image->rows; y++)  {    register const IndexPacket      *restrict indexes;    register const PixelPacket      *restrict p;    register long      id,      x;    if (status == MagickFalse)      continue;    id=GetOpenMPThreadId();    p=GetCacheViewVirtualPixels(image_view,0,y,image->columns,1,exception);    if (p == (const PixelPacket *) NULL)      continue;    indexes=GetCacheViewVirtualIndexQueue(image_view);    for (x=0; x < (long) image->columns; x++)    {      while (current_depth[id] < MAGICKCORE_QUANTUM_DEPTH)      {        MagickStatusType          status;        QuantumAny          range;        status=0;        range=GetQuantumRange(current_depth[id]);        if ((channel & RedChannel) != 0)          status|=p->red != ScaleAnyToQuantum(ScaleQuantumToAny(p->red,range),            range);        if ((channel & GreenChannel) != 0)          status|=p->green != ScaleAnyToQuantum(ScaleQuantumToAny(p->green,            range),range);        if ((channel & BlueChannel) != 0)          status|=p->blue != ScaleAnyToQuantum(ScaleQuantumToAny(p->blue,range),            range);        if (((channel & OpacityChannel) != 0) && (image->matte != MagickFalse))          status|=p->opacity != ScaleAnyToQuantum(ScaleQuantumToAny(p->opacity,            range),range);        if (((channel & IndexChannel) != 0) &&            (image->colorspace == CMYKColorspace))          status|=indexes[x] != ScaleAnyToQuantum(ScaleQuantumToAny(indexes[x],            range),range);        if (status == 0)          break;        current_depth[id]++;      }      p++;    }    if (current_depth[id] == MAGICKCORE_QUANTUM_DEPTH)      status=MagickFalse;  }  image_view=DestroyCacheView(image_view);  depth=current_depth[0];  for (id=1; id < (long) number_threads; id++)    if (depth < current_depth[id])      depth=current_depth[id];  current_depth=(unsigned long *) RelinquishMagickMemory(current_depth);  return(depth);}