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

Magick::Pixels::~Pixels(void){  if (_view)    _view=DestroyCacheView(_view);  (void) DestroyExceptionInfo(&_exception);}

/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%                                                                             %%                                                                             %%                                                                             %%     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));}

/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%                                                                             %%                                                                             %%                                                                             %%     C y c l e C o l o r m a p I m a g e                                     %%                                                                             %%                                                                             %%                                                                             %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%  CycleColormap() displaces an image's colormap by a given number of%  positions.  If you cycle the colormap a number of times you can produce%  a psychodelic effect.%%  WARNING: this assumes an images colormap is in a well know and defined%  order. Currently Imagemagick has no way of setting that order.%%  The format of the CycleColormapImage method is:%%      MagickBooleanType CycleColormapImage(Image *image,const ssize_t displace,%        ExceptionInfo *exception)%%  A description of each parameter follows:%%    o image: the image.%%    o displace:  displace the colormap this amount.%%    o exception: return any errors or warnings in this structure.%*/MagickExport MagickBooleanType CycleColormapImage(Image *image,  const ssize_t displace,ExceptionInfo *exception){  CacheView    *image_view;  MagickBooleanType    status;  ssize_t    y;  assert(image != (Image *) NULL);  assert(image->signature == MagickCoreSignature);  if (image->debug != MagickFalse)    (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);  if (image->storage_class == DirectClass)    (void) SetImageType(image,PaletteType,exception);  status=MagickTrue;  image_view=AcquireAuthenticCacheView(image,exception);#if defined(MAGICKCORE_OPENMP_SUPPORT)  #pragma omp parallel for schedule(static,4) /    magick_threads(image,image,1,1)#endif  for (y=0; y < (ssize_t) image->rows; y++)  {    register ssize_t      x;    register Quantum      *restrict q;    ssize_t      index;    if (status == MagickFalse)      continue;    q=GetCacheViewAuthenticPixels(image_view,0,y,image->columns,1,exception);    if (q == (Quantum *) NULL)      {        status=MagickFalse;        continue;      }    for (x=0; x < (ssize_t) image->columns; x++)    {      index=(ssize_t) (GetPixelIndex(image,q)+displace) % image->colors;      if (index < 0)        index+=(ssize_t) image->colors;      SetPixelIndex(image,(Quantum) index,q);      SetPixelViaPixelInfo(image,image->colormap+(ssize_t) index,q);      q+=GetPixelChannels(image);    }    if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse)      status=MagickFalse;  }  image_view=DestroyCacheView(image_view);  return(status);}

/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%                                                                             %%                                                                             %%                                                                             %%     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);}

/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%                                                                             %%                                                                             %%                                                                             %%   D e s t r o y I m a g e V i e w                                           %%                                                                             %%                                                                             %%                                                                             %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%  DestroyImageView() deallocates memory associated with a image view.%%  The format of the DestroyImageView method is:%%      ImageView *DestroyImageView(ImageView *image_view)%%  A description of each parameter follows:%%    o image_view: the image view.%*/MagickExport ImageView *DestroyImageView(ImageView *image_view){  assert(image_view != (ImageView *) NULL);  assert(image_view->signature == MagickSignature);  if (image_view->description != (char *) NULL)    image_view->description=DestroyString(image_view->description);  image_view->view=DestroyCacheView(image_view->view);  image_view->exception=DestroyExceptionInfo(image_view->exception);  image_view->signature=(~MagickSignature);  image_view=(ImageView *) RelinquishMagickMemory(image_view);  return(image_view);}

WandExport PixelView *DestroyPixelView(PixelView *pixel_view){  assert(pixel_view != (PixelView *) NULL);  assert(pixel_view->signature == WandSignature);  pixel_view->pixel_wands=DestroyPixelsThreadSet(pixel_view->pixel_wands,    pixel_view->region.width,pixel_view->number_threads);  pixel_view->view=DestroyCacheView(pixel_view->view);  pixel_view->exception=DestroyExceptionInfo(pixel_view->exception);  pixel_view->signature=(~WandSignature);  RelinquishWandId(pixel_view->id);  pixel_view=(PixelView *) RelinquishMagickMemory(pixel_view);  return(pixel_view);}

WandExport WandView *DestroyWandView(WandView *wand_view){  assert(wand_view != (WandView *) NULL);  assert(wand_view->signature == WandSignature);  wand_view->pixel_wands=DestroyPixelsThreadSet(wand_view->pixel_wands,    wand_view->extent.width,wand_view->number_threads);  wand_view->view=DestroyCacheView(wand_view->view);  wand_view->exception=DestroyExceptionInfo(wand_view->exception);  wand_view->signature=(~WandSignature);  RelinquishWandId(wand_view->id);  wand_view=(WandView *) RelinquishMagickMemory(wand_view);  return(wand_view);}

/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%                                                                             %%                                                                             %%                                                                             %%   D e s t r o y P i x e l I t e r a t o r                                   %%                                                                             %%                                                                             %%                                                                             %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%  DestroyPixelIterator() deallocates resources associated with a PixelIterator.%%  The format of the DestroyPixelIterator method is:%%      PixelIterator *DestroyPixelIterator(PixelIterator *iterator)%%  A description of each parameter follows:%%    o iterator: the pixel iterator.%*/WandExport PixelIterator *DestroyPixelIterator(PixelIterator *iterator){  assert(iterator != (const PixelIterator *) NULL);  assert(iterator->signature == WandSignature);  if (iterator->debug != MagickFalse)    (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",iterator->name);  iterator->view=DestroyCacheView(iterator->view);  iterator->pixel_wands=DestroyPixelWands(iterator->pixel_wands,    iterator->region.width);  iterator->exception=DestroyExceptionInfo(iterator->exception);  iterator->signature=(~WandSignature);  RelinquishWandId(iterator->id);  iterator=(PixelIterator *) RelinquishMagickMemory(iterator);  return(iterator);}

/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%                                                                             %%                                                                             %%                                                                             %%     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);}

/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%                                                                             %%                                                                             %%                                                                             %+   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//.........这里部分代码省略.........

// Destroy pixel viewMagick::Pixels::~Pixels( void ){  if ( _view )    _view = DestroyCacheView( _view );  }

//.........这里部分代码省略.........          q=GetCacheViewAuthenticPixels(image_view,0,y,image->columns,1,            &image->exception);          if (q == (PixelPacket *) NULL)            break;          for (x=0; x < (long) image->columns; x++)          {            px=(*q);            qx[0]=&(q->red);            qx[1]=&(q->green);            qx[2]=&(q->blue);            for (i=0; i < 3; i++)              switch (quantum_types[i])              {                case RedQuantum:   *qx[i]=px.red;   break;                case GreenQuantum: *qx[i]=px.green; break;                case BlueQuantum:  *qx[i]=px.blue;  break;                default:                            break;              }            q++;          }          length=ExportQuantumPixels(image,image_view,quantum_info,quantum_type,            pixels,&image->exception);          count=WriteBlob(image,length,pixels);          if (count != (ssize_t) length)            break;          if (image->previous == (Image *) NULL)            {              status=SetImageProgress(image,SaveImageTag,y,image->rows);              if (status == MagickFalse)                break;            }        }        image_view=DestroyCacheView(image_view);        break;      }      case LineInterlace:      {        /*          Line interlacing:  RRR...GGG...BBB...RRR...GGG...BBB...        */        for (y=0; y < (long) image->rows; y++)        {          register const PixelPacket            *__restrict p;          p=GetVirtualPixels(image,0,y,image->columns,1,&image->exception);          if (p == (const PixelPacket *) NULL)            break;          for (i=0; i < (long) channels; i++)          {            length=ExportQuantumPixels(image,(const CacheView *) NULL,              quantum_info,quantum_types[i],pixels,&image->exception);            count=WriteBlob(image,length,pixels);            if (count != (ssize_t) length)              break;          }          if (image->previous == (Image *) NULL)            {              status=SetImageProgress(image,SaveImageTag,y,image->rows);              if (status == MagickFalse)                break;            }        }        break;      }

Magick::Pixels::~Pixels(void){  if (_view != (MagickCore::CacheView *) NULL)    _view=DestroyCacheView(_view);}

//.........这里部分代码省略.........        {          oy=object;          status=GetMatrixElement(equivalences,oy,0,&object);        }        if (ox < oy)          {            status=SetMatrixElement(equivalences,oy,0,&ox);            root=ox;          }        else          {            status=SetMatrixElement(equivalences,ox,0,&oy);            root=oy;          }        ox=offset;        status=GetMatrixElement(equivalences,ox,0,&object);        while (object != root)        {          status=GetMatrixElement(equivalences,ox,0,&object);          status=SetMatrixElement(equivalences,ox,0,&root);        }        oy=offset+neighbor_offset;        status=GetMatrixElement(equivalences,oy,0,&object);        while (object != root)        {          status=GetMatrixElement(equivalences,oy,0,&object);          status=SetMatrixElement(equivalences,oy,0,&root);        }        status=SetMatrixElement(equivalences,y*image->columns+x,0,&root);        p+=GetPixelChannels(image);      }    }  }  image_view=DestroyCacheView(image_view);  /*    Label connected components.  */  n=0;  image_view=AcquireVirtualCacheView(image,exception);  component_view=AcquireAuthenticCacheView(component_image,exception);  for (y=0; y < (ssize_t) component_image->rows; y++)  {    register const Quantum      *magick_restrict p;    register Quantum      *magick_restrict q;    register ssize_t      x;    if (status == MagickFalse)      continue;    p=GetCacheViewVirtualPixels(image_view,0,y,image->columns,1,exception);    q=QueueCacheViewAuthenticPixels(component_view,0,y,component_image->columns,      1,exception);    if ((p == (const Quantum *) NULL) || (q == (Quantum *) NULL))      {        status=MagickFalse;        continue;      }    for (x=0; x < (ssize_t) component_image->columns; x++)    {      ssize_t        id,        offset;

//.........这里部分代码省略.........        }        case BlueChannel:        {          phase_source[i]=QuantumScale*GetPixelBlue(p);          break;        }        case OpacityChannel:        {          phase_source[i]=QuantumScale*GetPixelOpacity(p);          break;        }        case IndexChannel:        {          phase_source[i]=QuantumScale*GetPixelIndex(indexes+x);          break;        }        case GrayChannels:        {          phase_source[i]=QuantumScale*GetPixelGray(p);          break;        }      }      i++;      p++;    }  }  if (fourier_info->modulus != MagickFalse)    {      i=0L;      for (y=0L; y < (ssize_t) fourier_info->height; y++)        for (x=0L; x < (ssize_t) fourier_info->width; x++)        {          phase_source[i]-=0.5;          phase_source[i]*=(2.0*MagickPI);          i++;        }    }  magnitude_view=DestroyCacheView(magnitude_view);  phase_view=DestroyCacheView(phase_view);  magnitude=(double *) AcquireQuantumMemory((size_t) fourier_info->height,    fourier_info->center*sizeof(*magnitude));  if (magnitude == (double *) NULL)    {      (void) ThrowMagickException(exception,GetMagickModule(),        ResourceLimitError,"MemoryAllocationFailed","`%s'",        magnitude_image->filename);      magnitude_source=(double *) RelinquishMagickMemory(magnitude_source);      phase_source=(double *) RelinquishMagickMemory(phase_source);      return(MagickFalse);    }  status=InverseQuadrantSwap(fourier_info->width,fourier_info->height,    magnitude_source,magnitude);  magnitude_source=(double *) RelinquishMagickMemory(magnitude_source);  phase=(double *) AcquireQuantumMemory((size_t) fourier_info->height,    fourier_info->width*sizeof(*phase));  if (phase == (double *) NULL)    {      (void) ThrowMagickException(exception,GetMagickModule(),        ResourceLimitError,"MemoryAllocationFailed","`%s'",        magnitude_image->filename);      phase_source=(double *) RelinquishMagickMemory(phase_source);      return(MagickFalse);    }  CorrectPhaseLHS(fourier_info->width,fourier_info->width,phase_source);  if (status != MagickFalse)    status=InverseQuadrantSwap(fourier_info->width,fourier_info->height,      phase_source,phase);  phase_source=(double *) RelinquishMagickMemory(phase_source);  /*    Merge two sets.  */  i=0L;  if (fourier_info->modulus != MagickFalse)    for (y=0L; y < (ssize_t) fourier_info->height; y++)       for (x=0L; x < (ssize_t) fourier_info->center; x++)       {#if defined(MAGICKCORE_HAVE_COMPLEX_H)         fourier[i]=magnitude[i]*cos(phase[i])+I*magnitude[i]*sin(phase[i]);#else         fourier[i][0]=magnitude[i]*cos(phase[i]);         fourier[i][1]=magnitude[i]*sin(phase[i]);#endif         i++;      }  else    for (y=0L; y < (ssize_t) fourier_info->height; y++)      for (x=0L; x < (ssize_t) fourier_info->center; x++)      {#if defined(MAGICKCORE_HAVE_COMPLEX_H)        fourier[i]=magnitude[i]+I*phase[i];#else        fourier[i][0]=magnitude[i];        fourier[i][1]=phase[i];#endif        i++;      }  phase=(double *) RelinquishMagickMemory(phase);  magnitude=(double *) RelinquishMagickMemory(magnitude);  return(status);}

/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%                                                                             %%                                                                             %%                                                                             %%   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;    }  }//.........这里部分代码省略.........

//.........这里部分代码省略.........    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);        if (p == (const PixelPacket *) NULL)          continue;        q=pixels;        for (x=0; x < (ssize_t) combine_image->columns; x++)        {          SetPixelBlue(q,ClampToQuantum(GetPixelIntensity(image,p)));          p++;          q++;        }        image_view=DestroyCacheView(image_view);

//.........这里部分代码省略.........    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",      brightness_standard_deviation);    (void) SetImageProperty(image,"filter:brightness:standard-deviation",text);    if (brightness_standard_deviation != 0)      brightness_kurtosis=(brightness_sum_x4/area-4.0*brightness_mean*        brightness_sum_x3/area+6.0*brightness_mean*brightness_mean*        brightness_sum_x2/area-3.0*brightness_mean*brightness_mean*        brightness_mean*brightness_mean)/(brightness_standard_deviation*        brightness_standard_deviation*brightness_standard_deviation*        brightness_standard_deviation)-3.0;    (void) FormatMagickString(text,MaxTextExtent,"%g",brightness_kurtosis);    (void) SetImageProperty(image,"filter:brightness:kurtosis",text);    if (brightness_standard_deviation != 0)      brightness_skewness=(brightness_sum_x3/area-3.0*brightness_mean*        brightness_sum_x2/area+2.0*brightness_mean*brightness_mean*        brightness_mean)/(brightness_standard_deviation*        brightness_standard_deviation*brightness_standard_deviation);    (void) FormatMagickString(text,MaxTextExtent,"%g",brightness_skewness);    (void) SetImageProperty(image,"filter:brightness:skewness",text);    saturation_mean=saturation_sum_x/area;    (void) FormatMagickString(text,MaxTextExtent,"%g",saturation_mean);    (void) SetImageProperty(image,"filter:saturation:mean",text);    saturation_standard_deviation=sqrt(saturation_sum_x2/area-(saturation_sum_x/      area*saturation_sum_x/area));    (void) FormatMagickString(text,MaxTextExtent,"%g",      saturation_standard_deviation);    (void) SetImageProperty(image,"filter:saturation:standard-deviation",text);    if (saturation_standard_deviation != 0)      saturation_kurtosis=(saturation_sum_x4/area-4.0*saturation_mean*        saturation_sum_x3/area+6.0*saturation_mean*saturation_mean*        saturation_sum_x2/area-3.0*saturation_mean*saturation_mean*        saturation_mean*saturation_mean)/(saturation_standard_deviation*        saturation_standard_deviation*saturation_standard_deviation*        saturation_standard_deviation)-3.0;    (void) FormatMagickString(text,MaxTextExtent,"%g",saturation_kurtosis);    (void) SetImageProperty(image,"filter:saturation:kurtosis",text);    if (saturation_standard_deviation != 0)      saturation_skewness=(saturation_sum_x3/area-3.0*saturation_mean*        saturation_sum_x2/area+2.0*saturation_mean*saturation_mean*        saturation_mean)/(saturation_standard_deviation*        saturation_standard_deviation*saturation_standard_deviation);    (void) FormatMagickString(text,MaxTextExtent,"%g",saturation_skewness);    (void) SetImageProperty(image,"filter:saturation:skewness",text);  }  return(MagickImageFilterSignature);}

//.........这里部分代码省略.........          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])          depth=current_depth[id];      depth_map=(size_t *) RelinquishMagickMemory(depth_map);      current_depth=(size_t *) RelinquishMagickMemory(current_depth);      return(depth);    }#endif  /*    Compute pixel 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;

/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%                                                                             %%                                                                             %%                                                                             %+   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)//.........这里部分代码省略.........

//.........这里部分代码省略.........        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);}

MagickExport MagickBooleanType SetImageChannelDepth(Image *image,  const ChannelType channel,const unsigned long depth){  CacheView    *image_view;  ExceptionInfo    *exception;  long    y;  MagickBooleanType    status;  QuantumAny    range;  assert(image != (Image *) NULL);  if (image->debug != MagickFalse)    (void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");  assert(image->signature == MagickSignature);  if (GetImageDepth(image,&image->exception) <= (unsigned long)      MagickMin((double) depth,(double) MAGICKCORE_QUANTUM_DEPTH))    {      image->depth=depth;      return(MagickTrue);    }  /*    Scale pixels to desired depth.  */  status=MagickTrue;  range=GetQuantumRange(depth);  exception=(&image->exception);  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 IndexPacket      *restrict indexes;    register long      x;    register PixelPacket      *restrict q;    if (status == MagickFalse)      continue;    q=GetCacheViewAuthenticPixels(image_view,0,y,image->columns,1,      exception);    if (q == (PixelPacket *) NULL)      {        status=MagickFalse;        continue;      }    indexes=GetCacheViewAuthenticIndexQueue(image_view);    for (x=0; x < (long) image->columns; x++)    {      if ((channel & RedChannel) != 0)        q->red=ScaleAnyToQuantum(ScaleQuantumToAny(q->red,range),range);      if ((channel & GreenChannel) != 0)        q->green=ScaleAnyToQuantum(ScaleQuantumToAny(q->green,range),range);      if ((channel & BlueChannel) != 0)        q->blue=ScaleAnyToQuantum(ScaleQuantumToAny(q->blue,range),range);      if (((channel & OpacityChannel) != 0) && (image->matte != MagickFalse))        q->opacity=ScaleAnyToQuantum(ScaleQuantumToAny(q->opacity,range),range);      if (((channel & IndexChannel) != 0) &&          (image->colorspace == CMYKColorspace))        indexes[x]=ScaleAnyToQuantum(ScaleQuantumToAny(indexes[x],range),range);      q++;    }    if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse)      {        status=MagickFalse;        continue;      }  }  image_view=DestroyCacheView(image_view);  if (image->storage_class == PseudoClass)    {      QuantumAny        range;      register long        i;      register PixelPacket        *restrict p;      p=image->colormap;      range=GetQuantumRange(depth);#if defined(MAGICKCORE_OPENMP_SUPPORT)  #pragma omp parallel for schedule(dynamic,4) shared(status)#endif      for (i=0; i < (long) image->colors; i++)      {        if ((channel & RedChannel) != 0)//.........这里部分代码省略.........

//.........这里部分代码省略.........    {      case RedChannel:      {        for (x=0; x < (ssize_t) image->columns; x++)        {          SetPixelGreen(q,GetPixelRed(q));          SetPixelBlue(q,GetPixelRed(q));          q++;        }        break;      }      case GreenChannel:      {        for (x=0; x < (ssize_t) image->columns; x++)        {          SetPixelRed(q,GetPixelGreen(q));          SetPixelBlue(q,GetPixelGreen(q));          q++;        }        break;      }      case BlueChannel:      {        for (x=0; x < (ssize_t) image->columns; x++)        {          SetPixelRed(q,GetPixelBlue(q));          SetPixelGreen(q,GetPixelBlue(q));          q++;        }        break;      }      case OpacityChannel:      {        for (x=0; x < (ssize_t) image->columns; x++)        {          SetPixelRed(q,GetPixelOpacity(q));          SetPixelGreen(q,GetPixelOpacity(q));          SetPixelBlue(q,GetPixelOpacity(q));          q++;        }        break;      }      case BlackChannel:      {        if ((image->storage_class != PseudoClass) &&            (image->colorspace != CMYKColorspace))          break;        for (x=0; x < (ssize_t) image->columns; x++)        {          SetPixelRed(q,GetPixelIndex(indexes+x));          SetPixelGreen(q,GetPixelIndex(indexes+x));          SetPixelBlue(q,GetPixelIndex(indexes+x));          q++;        }        break;      }      case TrueAlphaChannel:      {        for (x=0; x < (ssize_t) image->columns; x++)        {          SetPixelRed(q,GetPixelAlpha(q));          SetPixelGreen(q,GetPixelAlpha(q));          SetPixelBlue(q,GetPixelAlpha(q));          q++;        }        break;      }      case GrayChannels:      {        for (x=0; x < (ssize_t) image->columns; x++)        {          SetPixelAlpha(q,ClampToQuantum(GetPixelIntensity(image,q)));          q++;        }        break;      }      default:        break;    }    if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse)      status=MagickFalse;    if (image->progress_monitor != (MagickProgressMonitor) NULL)      {        MagickBooleanType          proceed;#if defined(MAGICKCORE_OPENMP_SUPPORT)        #pragma omp critical (MagickCore_SeparateImageChannel)#endif        proceed=SetImageProgress(image,SeparateImageTag,progress++,image->rows);        if (proceed == MagickFalse)          status=MagickFalse;      }  }  image_view=DestroyCacheView(image_view);  if (channel != GrayChannels)    image->matte=MagickFalse;  (void) SetImageColorspace(image,GRAYColorspace);  return(status);}

//.........这里部分代码省略.........#if defined(MAGICKCORE_OPENMP_SUPPORT)      #pragma omp parallel for schedule(static,4) shared(status) /        magick_threads(image,image,1,1)#endif      for (i=0; i < (ssize_t) image->colors; i++)      {        if ((GetPixelRedTraits(image) & UpdatePixelTrait) != 0)          image->colormap[i].red=(double) ScaleAnyToQuantum(ScaleQuantumToAny(            ClampToQuantum(image->colormap[i].red),range),range);        if ((GetPixelGreenTraits(image) & UpdatePixelTrait) != 0)          image->colormap[i].green=(double) ScaleAnyToQuantum(ScaleQuantumToAny(            ClampToQuantum(image->colormap[i].green),range),range);        if ((GetPixelBlueTraits(image) & UpdatePixelTrait) != 0)          image->colormap[i].blue=(double) ScaleAnyToQuantum(ScaleQuantumToAny(            ClampToQuantum(image->colormap[i].blue),range),range);        if ((GetPixelAlphaTraits(image) & UpdatePixelTrait) != 0)          image->colormap[i].alpha=(double) ScaleAnyToQuantum(ScaleQuantumToAny(            ClampToQuantum(image->colormap[i].alpha),range),range);      }    }  status=MagickTrue;  image_view=AcquireAuthenticCacheView(image,exception);#if !defined(MAGICKCORE_HDRI_SUPPORT)  if (QuantumRange <= MaxMap)    {      Quantum        *depth_map;      register ssize_t        i;      /*        Scale pixels to desired (optimized with depth map).      */      depth_map=(Quantum *) AcquireQuantumMemory(MaxMap+1,sizeof(*depth_map));      if (depth_map == (Quantum *) NULL)        ThrowFatalException(ResourceLimitFatalError,"MemoryAllocationFailed");      for (i=0; i <= (ssize_t) MaxMap; i++)        depth_map[i]=ScaleAnyToQuantum(ScaleQuantumToAny((Quantum) i,range),          range);#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++)      {        register ssize_t          x;        register Quantum          *restrict q;        if (status == MagickFalse)          continue;        q=GetCacheViewAuthenticPixels(image_view,0,y,image->columns,1,          exception);        if (q == (Quantum *) NULL)          {            status=MagickFalse;            continue;          }        for (x=0; x < (ssize_t) image->columns; x++)        {          register ssize_t            i;          if (GetPixelReadMask(image,q) == 0)            {              q+=GetPixelChannels(image);              continue;            }          for (i=0; i < (ssize_t) GetPixelChannels(image); i++)          {            PixelChannel              channel;            PixelTrait              traits;            channel=GetPixelChannelChannel(image,i);            traits=GetPixelChannelTraits(image,channel);            if ((traits == UndefinedPixelTrait) ||                (channel == IndexPixelChannel) || (channel == ReadMaskPixelChannel))              continue;            q[i]=depth_map[ScaleQuantumToMap(q[i])];          }          q+=GetPixelChannels(image);        }        if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse)          {            status=MagickFalse;            continue;          }      }      image_view=DestroyCacheView(image_view);      depth_map=(Quantum *) RelinquishMagickMemory(depth_map);      if (status != MagickFalse)        image->depth=depth;      return(status);    }

static MagickBooleanType InverseFourierTransform(FourierInfo *fourier_info,  fftw_complex *fourier,Image *image,ExceptionInfo *exception){  CacheView    *image_view;  double    *source;  fftw_plan    fftw_c2r_plan;  register IndexPacket    *indexes;  register PixelPacket    *q;  register ssize_t    i,    x;  ssize_t    y;  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);    }#if defined(MAGICKCORE_OPENMP_SUPPORT)  #pragma omp critical (MagickCore_InverseFourierTransform)#endif  {    fftw_c2r_plan=fftw_plan_dft_c2r_2d(fourier_info->width,fourier_info->height,      fourier,source,FFTW_ESTIMATE);    fftw_execute(fftw_c2r_plan);    fftw_destroy_plan(fftw_c2r_plan);  }  i=0L;  image_view=AcquireAuthenticCacheView(image,exception);  for (y=0L; y < (ssize_t) fourier_info->height; y++)  {    if (y >= (ssize_t) image->rows)      break;    q=GetCacheViewAuthenticPixels(image_view,0L,y,fourier_info->width >      image->columns ? image->columns : fourier_info->width,1UL,exception);    if (q == (PixelPacket *) NULL)      break;    indexes=GetCacheViewAuthenticIndexQueue(image_view);    for (x=0L; x < (ssize_t) fourier_info->width; x++)    {      if (x < (ssize_t) image->columns)        switch (fourier_info->channel)        {          case RedChannel:          default:          {            SetPixelRed(q,ClampToQuantum(QuantumRange*source[i]));            break;          }          case GreenChannel:          {            SetPixelGreen(q,ClampToQuantum(QuantumRange*source[i]));            break;          }          case BlueChannel:          {            SetPixelBlue(q,ClampToQuantum(QuantumRange*source[i]));            break;          }          case OpacityChannel:          {            SetPixelOpacity(q,ClampToQuantum(QuantumRange*source[i]));            break;          }          case IndexChannel:          {            SetPixelIndex(indexes+x,ClampToQuantum(QuantumRange*source[i]));            break;          }          case GrayChannels:          {            SetPixelGray(q,ClampToQuantum(QuantumRange*source[i]));            break;          }        }      i++;      q++;    }    if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse)      break;  }  image_view=DestroyCacheView(image_view);  source=(double *) RelinquishMagickMemory(source);  return(MagickTrue);}

//.........这里部分代码省略.........          *restrict q;        register ssize_t          x;        if (status == MagickFalse)          continue;        q=GetCacheViewAuthenticPixels(image_view,0,y,image->columns,1,          exception);        if (q == (PixelPacket *) NULL)          {            status=MagickFalse;            continue;          }        for (x=0; x < (ssize_t) image->columns; x++)        {          if (q->opacity == TransparentOpacity)            {              SetPixelRed(q,pixel.red);              SetPixelGreen(q,pixel.green);              SetPixelBlue(q,pixel.blue);            }          q++;        }        if (image->colorspace == CMYKColorspace)          {            indexes=GetCacheViewAuthenticIndexQueue(image_view);            for (x=0; x < (ssize_t) image->columns; x++)              SetPixelIndex(indexes+x,index);          }        if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse)          status=MagickFalse;      }      image_view=DestroyCacheView(image_view);      return(status);    }    case CopyAlphaChannel:    case ShapeAlphaChannel:    {      /*        Special usage case for SeparateImageChannel(): copy grayscale color to        the alpha channel.      */      status=SeparateImageChannel(image,GrayChannels);      image->matte=MagickTrue; /* make sure transparency is now on! */      if (alpha_type == ShapeAlphaChannel)        {          MagickPixelPacket            background;          /*            Reset all color channels to background color.          */          GetMagickPixelPacket(image,&background);          SetMagickPixelPacket(image,&(image->background_color),(IndexPacket *)            NULL,&background);          (void) LevelColorsImage(image,&background,&background,MagickTrue);        }      break;    }    case DeactivateAlphaChannel:    {      image->matte=MagickFalse;      break;    }    case ExtractAlphaChannel:

//.........这里部分代码省略.........          SetPixelRed(q,ClampToQuantum(QuantumRange*            magnitude_source[i]));          break;        }        case GreenChannel:        {          SetPixelGreen(q,ClampToQuantum(QuantumRange*            magnitude_source[i]));          break;        }        case BlueChannel:        {          SetPixelBlue(q,ClampToQuantum(QuantumRange*            magnitude_source[i]));          break;        }        case OpacityChannel:        {          SetPixelOpacity(q,ClampToQuantum(QuantumRange*            magnitude_source[i]));          break;        }        case IndexChannel:        {          SetPixelIndex(indexes+x,ClampToQuantum(QuantumRange*            magnitude_source[i]));          break;        }        case GrayChannels:        {          SetPixelGray(q,ClampToQuantum(QuantumRange*            magnitude_source[i]));          break;        }      }      i++;      q++;    }    status=SyncCacheViewAuthenticPixels(magnitude_view,exception);    if (status == MagickFalse)      break;  }  magnitude_view=DestroyCacheView(magnitude_view);  i=0L;  phase_view=AcquireAuthenticCacheView(phase_image,exception);  for (y=0L; y < (ssize_t) fourier_info->height; y++)  {    q=GetCacheViewAuthenticPixels(phase_view,0L,y,fourier_info->height,1UL,      exception);    if (q == (PixelPacket *) NULL)      break;    indexes=GetCacheViewAuthenticIndexQueue(phase_view);    for (x=0L; x < (ssize_t) fourier_info->width; x++)    {      switch (fourier_info->channel)      {        case RedChannel:        default:        {          SetPixelRed(q,ClampToQuantum(QuantumRange*phase_source[i]));          break;        }        case GreenChannel:        {          SetPixelGreen(q,ClampToQuantum(QuantumRange*phase_source[i]));          break;        }        case BlueChannel:        {          SetPixelBlue(q,ClampToQuantum(QuantumRange*phase_source[i]));          break;        }        case OpacityChannel:        {          SetPixelOpacity(q,ClampToQuantum(QuantumRange*phase_source[i]));          break;        }        case IndexChannel:        {          SetPixelIndex(indexes+x,ClampToQuantum(QuantumRange*phase_source[i]));          break;        }        case GrayChannels:        {          SetPixelGray(q,ClampToQuantum(QuantumRange*phase_source[i]));          break;        }      }      i++;      q++;    }    status=SyncCacheViewAuthenticPixels(phase_view,exception);    if (status == MagickFalse)      break;   }  phase_view=DestroyCacheView(phase_view);  phase_source=(double *) RelinquishMagickMemory(phase_source);  magnitude_source=(double *) RelinquishMagickMemory(magnitude_source);  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);}

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);//.........这里部分代码省略.........