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

/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%                                                                             %%                                                                             %%                                                                             %%   P i x e l S y n c I t e r a t o r                                         %%                                                                             %%                                                                             %%                                                                             %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%  PixelSyncIterator() syncs the pixel iterator.%%  The format of the PixelSyncIterator method is:%%      MagickBooleanType PixelSyncIterator(PixelIterator *iterator)%%  A description of each parameter follows:%%    o iterator: the pixel iterator.%*/WandExport MagickBooleanType PixelSyncIterator(PixelIterator *iterator){  MagickBooleanType    status;  register ssize_t    x;  register Quantum    *_magickcore_restrict pixels;  assert(iterator != (const PixelIterator *) NULL);  assert(iterator->signature == MagickWandSignature);  if (iterator->debug != MagickFalse)    (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",iterator->name);  status=SetCacheViewStorageClass(iterator->view,DirectClass,    iterator->exception);  if (status == MagickFalse)    return(MagickFalse);  pixels=GetCacheViewAuthenticPixels(iterator->view,iterator->region.x,    iterator->region.y+iterator->y,iterator->region.width,1,    iterator->exception);  if (pixels == (Quantum *) NULL)    return(MagickFalse);  for (x=0; x < (ssize_t) iterator->region.width; x++)  {    PixelGetQuantumPixel(GetCacheViewImage(iterator->view),      iterator->pixel_wands[x],pixels);    pixels+=GetPixelChannels(GetCacheViewImage(iterator->view));  }  if (SyncCacheViewAuthenticPixels(iterator->view,iterator->exception) == MagickFalse)    return(MagickFalse);  return(MagickTrue);}

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

Magick::PixelPacket* Magick::Pixels::get(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;  PixelPacket* pixels=GetCacheViewAuthenticPixels(_view,x_,y_,columns_,rows_,    exceptionInfo);  ThrowPPException(_image.quiet());  return pixels;}

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

/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%                                                                             %%                                                                             %%                                                                             %%   P i x e l S y n c I t e r a t o r                                         %%                                                                             %%                                                                             %%                                                                             %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%  PixelSyncIterator() syncs the pixel iterator.%%  The format of the PixelSyncIterator method is:%%      MagickBooleanType PixelSyncIterator(PixelIterator *iterator)%%  A description of each parameter follows:%%    o iterator: the pixel iterator.%*/WandExport MagickBooleanType PixelSyncIterator(PixelIterator *iterator){  ExceptionInfo    *exception;  register IndexPacket    *restrict indexes;  register ssize_t    x;  register PixelPacket    *restrict pixels;  assert(iterator != (const PixelIterator *) NULL);  assert(iterator->signature == WandSignature);  if (iterator->debug != MagickFalse)    (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",iterator->name);  if (SetCacheViewStorageClass(iterator->view,DirectClass) == MagickFalse)    return(MagickFalse);  exception=iterator->exception;  pixels=GetCacheViewAuthenticPixels(iterator->view,iterator->region.x,    iterator->region.y+iterator->y,iterator->region.width,1,exception);  if (pixels == (PixelPacket *) NULL)    {      InheritException(iterator->exception,GetCacheViewException(        iterator->view));      return(MagickFalse);    }  indexes=GetCacheViewAuthenticIndexQueue(iterator->view);  for (x=0; x < (ssize_t) iterator->region.width; x++)    PixelGetQuantumColor(iterator->pixel_wands[x],pixels+x);  if (GetCacheViewColorspace(iterator->view) == CMYKColorspace)    for (x=0; x < (ssize_t) iterator->region.width; x++)      SetPixelBlack(indexes+x,PixelGetBlackQuantum(        iterator->pixel_wands[x]));  if (SyncCacheViewAuthenticPixels(iterator->view,exception) == MagickFalse)    {      InheritException(iterator->exception,GetCacheViewException(        iterator->view));      return(MagickFalse);    }  return(MagickTrue);}

MagickExport MagickBooleanType SetImageAlphaChannel(Image *image,  const AlphaChannelOption alpha_type,ExceptionInfo *exception){  CacheView    *image_view;  MagickBooleanType    status;  ssize_t    y;  assert(image != (Image *) NULL);  if (image->debug != MagickFalse)    (void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");  assert(image->signature == MagickSignature);  status=MagickTrue;  switch (alpha_type)  {    case ActivateAlphaChannel:    {      image->alpha_trait=BlendPixelTrait;      break;    }    case AssociateAlphaChannel:    {      /*        Associate alpha.      */      status=SetImageStorageClass(image,DirectClass,exception);      if (status == MagickFalse)        break;      image_view=AcquireAuthenticCacheView(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++)      {        register Quantum          *restrict q;        register ssize_t          x;        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++)        {          double            Sa;            register ssize_t            i;            if (GetPixelReadMask(image,q) == 0)            {              q+=GetPixelChannels(image);              continue;            }          Sa=QuantumScale*GetPixelAlpha(image,q);          for (i=0; i < (ssize_t) GetPixelChannels(image); i++)          {            PixelChannel channel=GetPixelChannelChannel(image,i);            PixelTrait traits=GetPixelChannelTraits(image,channel);            if ((traits & UpdatePixelTrait) == 0)              continue;            q[i]=ClampToQuantum(Sa*q[i]);          }          q+=GetPixelChannels(image);        }        if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse)          status=MagickFalse;      }      image_view=DestroyCacheView(image_view);      image->alpha_trait=CopyPixelTrait;      return(status);    }    case BackgroundAlphaChannel:    {      /*        Set transparent pixels to background color.      */      if (image->alpha_trait != BlendPixelTrait)        break;      status=SetImageStorageClass(image,DirectClass,exception);      if (status == MagickFalse)        break;      image_view=AcquireAuthenticCacheView(image,exception);#if defined(MAGICKCORE_OPENMP_SUPPORT)      #pragma omp parallel for schedule(static,4) shared(status) /        magick_threads(image,image,image->rows,1)#endif//.........这里部分代码省略.........

//.........这里部分代码省略.........        Set transparent pixels to background color.      */      if (image->matte == MagickFalse)        break;      if (SetImageStorageClass(image,DirectClass) == MagickFalse)        break;      GetMagickPixelPacket(image,&background);      SetMagickPixelPacket(image,&image->background_color,(const IndexPacket *)        NULL,&background);      if (image->colorspace == CMYKColorspace)        ConvertRGBToCMYK(&background);      index=0;      SetPixelPacket(image,&background,&pixel,&index);      status=MagickTrue;      exception=(&image->exception);      image_view=AcquireAuthenticCacheView(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++)      {        register IndexPacket          *restrict indexes;        register PixelPacket          *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:    {      /*

//.........这里部分代码省略.........    object[i].color.green=object[i].color.green/object[i].area;    object[i].color.blue=object[i].color.blue/object[i].area;    object[i].color.alpha=object[i].color.alpha/object[i].area;    object[i].color.black=object[i].color.black/object[i].area;    object[i].centroid.x=object[i].centroid.x/object[i].area;    object[i].centroid.y=object[i].centroid.y/object[i].area;  }  artifact=GetImageArtifact(image,"connected-components:area-threshold");  area_threshold=0.0;  if (artifact != (const char *) NULL)    area_threshold=StringToDouble(artifact,(char **) NULL);  if (area_threshold > 0.0)    {      /*        Merge object below area threshold.      */      component_view=AcquireAuthenticCacheView(component_image,exception);      for (i=0; i < (ssize_t) component_image->colors; i++)      {        double          census;        RectangleInfo          bounding_box;        register ssize_t          j;        size_t          id;        if (status == MagickFalse)          continue;        if ((double) object[i].area >= area_threshold)          continue;        for (j=0; j < (ssize_t) component_image->colors; j++)          object[j].census=0;        bounding_box=object[i].bounding_box;        for (y=0; y < (ssize_t) bounding_box.height+2; y++)        {          register const Quantum            *magick_restrict p;          register ssize_t            x;          if (status == MagickFalse)            continue;          p=GetCacheViewVirtualPixels(component_view,bounding_box.x-1,            bounding_box.y+y-1,bounding_box.width+2,1,exception);          if (p == (const Quantum *) NULL)            {              status=MagickFalse;              continue;            }          for (x=0; x < (ssize_t) bounding_box.width+2; x++)          {            j=(ssize_t) GetPixelIndex(component_image,p);            if (j != i)              object[j].census++;          }        }        census=0;        id=0;        for (j=0; j < (ssize_t) component_image->colors; j++)          if (census < object[j].census)            {              census=object[j].census;              id=(size_t) j;            }        object[id].area+=object[i].area;        for (y=0; y < (ssize_t) bounding_box.height; y++)        {          register Quantum            *magick_restrict q;          register ssize_t            x;          if (status == MagickFalse)            continue;          q=GetCacheViewAuthenticPixels(component_view,bounding_box.x,            bounding_box.y+y,bounding_box.width,1,exception);          if (q == (Quantum *) NULL)            {              status=MagickFalse;              continue;            }          for (x=0; x < (ssize_t) bounding_box.width; x++)          {            if ((ssize_t) GetPixelIndex(component_image,q) == i)              SetPixelIndex(image,(Quantum) id,q);            q+=GetPixelChannels(component_image);          }          if (SyncCacheViewAuthenticPixels(component_view,exception) == MagickFalse)            status=MagickFalse;        }      }      (void) SyncImage(component_image,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.%%  The format of the CycleColormapImage method is:%%      MagickBooleanType CycleColormapImage(Image *image,const long displace)%%  A description of each parameter follows:%%    o image: the image.%%    o displace:  displace the colormap this amount.%*/MagickExport MagickBooleanType CycleColormapImage(Image *image,  const long displace){  CacheView    *image_view;  ExceptionInfo    *exception;  long    y;  MagickBooleanType    status;  assert(image != (Image *) NULL);  assert(image->signature == MagickSignature);  if (image->debug != MagickFalse)    (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);  if (image->storage_class == DirectClass)    (void) SetImageType(image,PaletteType);  status=MagickTrue;  exception=(&image->exception);  image_view=AcquireCacheView(image);#if defined(MAGICKCORE_OPENMP_SUPPORT)  #pragma omp parallel for schedule(static) shared(status)#endif  for (y=0; y < (long) image->rows; y++)  {    long      index;    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++)    {      index=(long) (indexes[x]+displace) % image->colors;      if (index < 0)        index+=image->colors;      indexes[x]=(IndexPacket) index;      q->red=image->colormap[index].red;      q->green=image->colormap[index].green;      q->blue=image->colormap[index].blue;      q++;    }    if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse)      status=MagickFalse;  }  image_view=DestroyCacheView(image_view);  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);}

/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%                                                                             %%                                                                             %%                                                                             %%   S e t I m a g e V i e w I t e r a t o r                                   %%                                                                             %%                                                                             %%                                                                             %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%  SetImageViewIterator() iterates over the image view in parallel and calls%  your set method for each scanline of the view.  The pixel extent is%  confined to the image canvas-- that is no negative offsets or widths or%  heights that exceed the image dimension.  The pixels are initiallly%  undefined and any settings you make in the callback method are automagically%  synced back to your image.%%  The callback signature is:%%      MagickBooleanType SetImageViewMethod(ImageView *destination,%        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 set method that must be%  executed by a single thread at a time.%%  The format of the SetImageViewIterator method is:%%      MagickBooleanType SetImageViewIterator(ImageView *destination,%        SetImageViewMethod set,void *context)%%  A description of each parameter follows:%%    o destination: the image view.%%    o set: the set callback method.%%    o context: the user defined context.%*/MagickExport MagickBooleanType SetImageViewIterator(ImageView *destination,  SetImageViewMethod set,void *context){  ExceptionInfo    *exception;  Image    *destination_image;  MagickBooleanType    status;  MagickOffsetType    progress;  ssize_t    y;  assert(destination != (ImageView *) NULL);  assert(destination->signature == MagickSignature);  if (set == (SetImageViewMethod) NULL)    return(MagickFalse);  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(destination->number_threads)#endif  for (y=destination->extent.y; y < (ssize_t) destination->extent.height; y++)  {    const int      id = GetOpenMPThreadId();    MagickBooleanType      sync;    register PixelPacket      *__restrict__ pixels;    if (status == MagickFalse)      continue;    pixels=GetCacheViewAuthenticPixels(destination->view,destination->extent.x,      y,destination->extent.width,1,exception);    if (pixels == (PixelPacket *) NULL)      {        InheritException(destination->exception,GetCacheViewException(          destination->view));        status=MagickFalse;        continue;      }    if (set(destination,y,id,context) == MagickFalse)      status=MagickFalse;    sync=SyncCacheViewAuthenticPixels(destination->view,exception);//.........这里部分代码省略.........

MagickExport MagickBooleanType SortColormapByIntensity(Image *image){  CacheView    *image_view;  ExceptionInfo    *exception;  long    y;  MagickBooleanType    status;  register long    i;  unsigned short    *pixels;  assert(image != (Image *) NULL);  if (image->debug != MagickFalse)    (void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");  assert(image->signature == MagickSignature);  if (image->storage_class != PseudoClass)    return(MagickTrue);  /*    Allocate memory for pixel indexes.  */  pixels=(unsigned short *) AcquireQuantumMemory((size_t) image->colors,    sizeof(*pixels));  if (pixels == (unsigned short *) NULL)    ThrowBinaryException(ResourceLimitError,"MemoryAllocationFailed",      image->filename);  /*    Assign index values to colormap entries.  */#if defined(MAGICKCORE_OPENMP_SUPPORT)  #pragma omp parallel for schedule(dynamic,4) shared(status)#endif  for (i=0; i < (long) image->colors; i++)    image->colormap[i].opacity=(IndexPacket) i;  /*    Sort image colormap by decreasing color popularity.  */  qsort((void *) image->colormap,(size_t) image->colors,    sizeof(*image->colormap),IntensityCompare);  /*    Update image colormap indexes to sorted colormap order.  */#if defined(MAGICKCORE_OPENMP_SUPPORT)  #pragma omp parallel for schedule(dynamic,4) shared(status)#endif  for (i=0; i < (long) image->colors; i++)    pixels[(long) image->colormap[i].opacity]=(unsigned short) i;  status=MagickTrue;  exception=(&image->exception);  image_view=AcquireCacheView(image);  for (y=0; y < (long) image->rows; y++)  {    IndexPacket      index;    register long      x;    register IndexPacket      *restrict indexes;    register PixelPacket      *restrict q;    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++)    {      index=(IndexPacket) pixels[(long) indexes[x]];      indexes[x]=index;      *q++=image->colormap[(long) index];    }    if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse)      status=MagickFalse;    if (status == MagickFalse)      break;  }  image_view=DestroyCacheView(image_view);  pixels=(unsigned short *) RelinquishMagickMemory(pixels);  return(status);}

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

/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%                                                                             %%                                                                             %%                                                                             %%   S e t W a n d V i e w I t e r a t o r                                     %%                                                                             %%                                                                             %%                                                                             %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%  SetWandViewIterator() iterates over the wand view in parallel and calls%  your set method for each scanline of the view.  The pixel extent is%  confined to the image canvas-- that is no negative offsets or widths or%  heights that exceed the image dimension.  The pixels are initiallly%  undefined and any settings you make in the callback method are automagically%  synced back to your image.%%  The callback signature is:%%      MagickBooleanType SetImageViewMethod(ImageView *destination,%        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 set method that must be%  executed by a single thread at a time.%%  The format of the SetWandViewIterator method is:%%      MagickBooleanType SetWandViewIterator(WandView *destination,%        SetWandViewMethod set,void *context)%%  A description of each parameter follows:%%    o destination: the wand view.%%    o set: the set callback method.%%    o context: the user defined context.%*/WandExport MagickBooleanType SetWandViewIterator(WandView *destination,  SetWandViewMethod set,void *context){  ExceptionInfo    *exception;  Image    *destination_image;  MagickBooleanType    status;  MagickOffsetType    progress;  ssize_t    y;  assert(destination != (WandView *) NULL);  assert(destination->signature == WandSignature);  if (set == (SetWandViewMethod) NULL)    return(MagickFalse);  destination_image=destination->wand->images;  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(destination->number_threads)#endif  for (y=destination->extent.y; y < (ssize_t) destination->extent.height; y++)  {    const int      id = GetOpenMPThreadId();    MagickBooleanType      sync;    register IndexPacket      *restrict indexes;    register ssize_t      x;    register PixelPacket      *restrict pixels;    if (status == MagickFalse)      continue;    pixels=GetCacheViewAuthenticPixels(destination->view,destination->extent.x,      y,destination->extent.width,1,exception);    if (pixels == (PixelPacket *) NULL)      {        InheritException(destination->exception,GetCacheViewException(          destination->view));//.........这里部分代码省略.........

/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%                                                                             %%                                                                             %%                                                                             %%   R a i s e I m a g e                                                       %%                                                                             %%                                                                             %%                                                                             %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%  RaiseImage() creates a simulated three-dimensional button-like effect%  by lightening and darkening the edges of the image.  Members width and%  height of raise_info define the width of the vertical and horizontal%  edge of the effect.%%  The format of the RaiseImage method is:%%      MagickBooleanType RaiseImage(const Image *image,%        const RectangleInfo *raise_info,const MagickBooleanType raise)%%  A description of each parameter follows:%%    o image: the image.%%    o raise_info: Define the width and height of the raise area.%%    o raise: A value other than zero creates a 3-D raise effect,%      otherwise it has a lowered effect.%*/MagickExport MagickBooleanType RaiseImage(Image *image,  const RectangleInfo *raise_info,const MagickBooleanType raise){#define AccentuateFactor  ScaleCharToQuantum(135)#define HighlightFactor  ScaleCharToQuantum(190)#define ShadowFactor  ScaleCharToQuantum(190)#define RaiseImageTag  "Raise/Image"#define TroughFactor  ScaleCharToQuantum(135)  CacheView    *image_view;  ExceptionInfo    *exception;  MagickBooleanType    status;  MagickOffsetType    progress;  Quantum    foreground,    background;  ssize_t    y;  assert(image != (Image *) NULL);  assert(image->signature == MagickSignature);  if (image->debug != MagickFalse)    (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);  assert(raise_info != (RectangleInfo *) NULL);  if ((image->columns <= (raise_info->width << 1)) ||      (image->rows <= (raise_info->height << 1)))    ThrowBinaryException(OptionError,"ImageSizeMustExceedBevelWidth",      image->filename);  foreground=(Quantum) QuantumRange;  background=(Quantum) 0;  if (raise == MagickFalse)    {      foreground=(Quantum) 0;      background=(Quantum) QuantumRange;    }  if (SetImageStorageClass(image,DirectClass) == MagickFalse)    return(MagickFalse);  /*    Raise image.  */  status=MagickTrue;  progress=0;  exception=(&image->exception);  image_view=AcquireCacheView(image);#if defined(MAGICKCORE_OPENMP_SUPPORT)   #pragma omp parallel for schedule(dynamic,4) shared(progress,status) omp_throttle(1)#endif  for (y=0; y < (ssize_t) raise_info->height; y++)  {    register ssize_t      x;    register PixelPacket      *restrict q;    if (status == MagickFalse)      continue;    q=GetCacheViewAuthenticPixels(image_view,0,y,image->columns,1,exception);    if (q == (PixelPacket *) NULL)      {//.........这里部分代码省略.........

/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%                                                                             %%                                                                             %%                                                                             %%     T r a n s p a r e n t P a i n t I m a g e                               %%                                                                             %%                                                                             %%                                                                             %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%  TransparentPaintImage() changes the opacity value associated with any pixel%  that matches color to the value defined by opacity.%%  By default color must match a particular pixel color exactly.  However, in%  many cases two colors may differ by a small amount.  Fuzz defines how much%  tolerance is acceptable to consider two colors as the same.  For example,%  set fuzz to 10 and the color red at intensities of 100 and 102 respectively%  are now interpreted as the same color.%%  The format of the TransparentPaintImage method is:%%      MagickBooleanType TransparentPaintImage(Image *image,%        const PixelInfo *target,const Quantum opacity,%        const MagickBooleanType invert,ExceptionInfo *exception)%%  A description of each parameter follows:%%    o image: the image.%%    o target: the target color.%%    o opacity: the replacement opacity value.%%    o invert: paint any pixel that does not match the target color.%%    o exception: return any errors or warnings in this structure.%*/MagickExport MagickBooleanType TransparentPaintImage(Image *image,  const PixelInfo *target,const Quantum opacity,const MagickBooleanType invert,  ExceptionInfo *exception){#define TransparentPaintImageTag  "Transparent/Image"  CacheView    *image_view;  MagickBooleanType    status;  MagickOffsetType    progress;  PixelInfo    zero;  ssize_t    y;  assert(image != (Image *) NULL);  assert(image->signature == MagickCoreSignature);  assert(target != (PixelInfo *) NULL);  if (image->debug != MagickFalse)    (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);  if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)    return(MagickFalse);  if (image->alpha_trait == UndefinedPixelTrait)    (void) SetImageAlphaChannel(image,OpaqueAlphaChannel,exception);  /*    Make image color transparent.  */  status=MagickTrue;  progress=0;  GetPixelInfo(image,&zero);  image_view=AcquireAuthenticCacheView(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++)  {    PixelInfo      pixel;    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;      }    pixel=zero;//.........这里部分代码省略.........

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

//.........这里部分代码省略.........    if ((LocaleCompare(image_info->magick,"RGBA") == 0) &&        (image->matte == MagickFalse))      (void) SetImageAlphaChannel(image,ResetAlphaChannel);    quantum_info=AcquireQuantumInfo(image_info,image);    if (quantum_info == (QuantumInfo *) NULL)      ThrowWriterException(ResourceLimitError,"MemoryAllocationFailed");    pixels=GetQuantumPixels(quantum_info);    switch (image_info->interlace)    {      case NoInterlace:      default:      {        CacheView          *image_view;                  PixelPacket          px;        Quantum          *qx[3];        /*          No interlacing:  RGBRGBRGBRGBRGBRGB...        */        image_view=AcquireCacheView(image);        for (y=0; y < (long) image->rows; y++)        {          register long            x;          register PixelPacket            *__restrict q;          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);

static MagickBooleanType ForwardFourier(const FourierInfo *fourier_info,  Image *image,double *magnitude,double *phase,ExceptionInfo *exception){  CacheView    *magnitude_view,    *phase_view;  double    *magnitude_source,    *phase_source;  Image    *magnitude_image,    *phase_image;  MagickBooleanType    status;  register IndexPacket    *indexes;  register ssize_t    x;  register PixelPacket    *q;  ssize_t    i,    y;  magnitude_image=GetFirstImageInList(image);  phase_image=GetNextImageInList(image);  if (phase_image == (Image *) NULL)    {      (void) ThrowMagickException(exception,GetMagickModule(),ImageError,        "ImageSequenceRequired","`%s'",image->filename);      return(MagickFalse);    }  /*    Create "Fourier Transform" image from constituent arrays.  */  magnitude_source=(double *) AcquireQuantumMemory((size_t)    fourier_info->height,fourier_info->width*sizeof(*magnitude_source));  if (magnitude_source == (double *) NULL)    return(MagickFalse);  (void) ResetMagickMemory(magnitude_source,0,fourier_info->height*    fourier_info->width*sizeof(*magnitude_source));  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'",image->filename);      magnitude_source=(double *) RelinquishMagickMemory(magnitude_source);      return(MagickFalse);    }  status=ForwardQuadrantSwap(fourier_info->height,fourier_info->height,    magnitude,magnitude_source);  if (status != MagickFalse)    status=ForwardQuadrantSwap(fourier_info->height,fourier_info->height,phase,      phase_source);  CorrectPhaseLHS(fourier_info->height,fourier_info->height,phase_source);  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]/=(2.0*MagickPI);          phase_source[i]+=0.5;          i++;        }    }  magnitude_view=AcquireAuthenticCacheView(magnitude_image,exception);  i=0L;  for (y=0L; y < (ssize_t) fourier_info->height; y++)  {    q=GetCacheViewAuthenticPixels(magnitude_view,0L,y,fourier_info->height,1UL,      exception);    if (q == (PixelPacket *) NULL)      break;    indexes=GetCacheViewAuthenticIndexQueue(magnitude_view);    for (x=0L; x < (ssize_t) fourier_info->width; x++)    {      switch (fourier_info->channel)      {        case RedChannel:        default:        {          SetPixelRed(q,ClampToQuantum(QuantumRange*            magnitude_source[i]));          break;        }        case GreenChannel:        {          SetPixelGreen(q,ClampToQuantum(QuantumRange*            magnitude_source[i]));          break;        }//.........这里部分代码省略.........

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

MagickExport MagickBooleanType SortColormapByIntensity(Image *image,  ExceptionInfo *exception){  CacheView    *image_view;  MagickBooleanType    status;  register ssize_t    i;  ssize_t    y;  unsigned short    *pixels;  assert(image != (Image *) NULL);  if (image->debug != MagickFalse)    (void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");  assert(image->signature == MagickCoreSignature);  if (image->storage_class != PseudoClass)    return(MagickTrue);  /*    Allocate memory for pixel indexes.  */  pixels=(unsigned short *) AcquireQuantumMemory((size_t) image->colors,    sizeof(*pixels));  if (pixels == (unsigned short *) NULL)    ThrowBinaryException(ResourceLimitError,"MemoryAllocationFailed",      image->filename);  /*    Assign index values to colormap entries.  */#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++)    image->colormap[i].alpha=(double) i;  /*    Sort image colormap by decreasing color popularity.  */  qsort((void *) image->colormap,(size_t) image->colors,    sizeof(*image->colormap),IntensityCompare);  /*    Update image colormap indexes to sorted colormap order.  */#if defined(MAGICKCORE_OPENMP_SUPPORT)  #pragma omp parallel for schedule(static,4) shared(status)#endif  for (i=0; i < (ssize_t) image->colors; i++)    pixels[(ssize_t) image->colormap[i].alpha]=(unsigned short) i;  status=MagickTrue;  image_view=AcquireAuthenticCacheView(image,exception);  for (y=0; y < (ssize_t) image->rows; y++)  {    Quantum      index;    register ssize_t      x;    register Quantum      *restrict q;    q=GetCacheViewAuthenticPixels(image_view,0,y,image->columns,1,exception);    if (q == (Quantum *) NULL)      {        status=MagickFalse;        break;      }    for (x=0; x < (ssize_t) image->columns; x++)    {      index=(Quantum) pixels[(ssize_t) GetPixelIndex(image,q)];      SetPixelIndex(image,index,q);      SetPixelViaPixelInfo(image,image->colormap+(ssize_t) index,q);      q+=GetPixelChannels(image);    }    if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse)      status=MagickFalse;    if (status == MagickFalse)      break;  }  image_view=DestroyCacheView(image_view);  pixels=(unsigned short *) RelinquishMagickMemory(pixels);  return(status);}

/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%                                                                             %%                                                                             %%                                                                             %%   S e t I m a g e D e p t h                                                 %%                                                                             %%                                                                             %%                                                                             %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%  SetImageDepth() sets the depth of the image.%%  The format of the SetImageDepth method is:%%      MagickBooleanType SetImageDepth(Image *image,const size_t depth,%        ExceptionInfo *exception)%%  A description of each parameter follows:%%    o image: the image.%%    o channel: the channel.%%    o depth: the image depth.%%    o exception: return any errors or warnings in this structure.%*/MagickExport MagickBooleanType SetImageDepth(Image *image,  const size_t depth,ExceptionInfo *exception){  CacheView    *image_view;  MagickBooleanType    status;  QuantumAny    range;  ssize_t    y;  assert(image != (Image *) NULL);  if (image->debug != MagickFalse)    (void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");  assert(image->signature == MagickSignature);  if (GetImageDepth(image,exception) <= (size_t)      MagickMin((double) depth,(double) MAGICKCORE_QUANTUM_DEPTH))    {      image->depth=depth;      return(MagickTrue);    }  /*    Scale pixels to desired depth.  */  status=MagickTrue;  range=GetQuantumRange(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++)  {    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;      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;        q[i]=ScaleAnyToQuantum(ScaleQuantumToAny(q[i],range),range);      }      q+=GetPixelChannels(image);    }//.........这里部分代码省略.........

MagickExport MagickBooleanType SeparateImageChannel(Image *image,  const ChannelType channel){#define SeparateImageTag  "Separate/Image"  CacheView    *image_view;  ExceptionInfo    *exception;  MagickBooleanType    status;  MagickOffsetType    progress;  ssize_t    y;  assert(image != (Image *) NULL);  assert(image->signature == MagickSignature);  if (image->debug != MagickFalse)    (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);  if (SetImageStorageClass(image,DirectClass) == MagickFalse)    return(MagickFalse);  if (channel == GrayChannels)    image->matte=MagickTrue;  /*    Separate image channels.  */  status=MagickTrue;  progress=0;  exception=(&image->exception);  image_view=AcquireAuthenticCacheView(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 IndexPacket      *restrict indexes;    register PixelPacket      *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;      }    indexes=GetCacheViewAuthenticIndexQueue(image_view);    switch (channel)    {      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++;        }//.........这里部分代码省略.........

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

//.........这里部分代码省略.........  if (IssRGBCompatibleColorspace(image->colorspace) != MagickFalse)    (void) SetImageColorspace(combine_image,sRGBColorspace);  if ((channel & OpacityChannel) != 0)    combine_image->matte=MagickTrue;  (void) SetImageBackgroundColor(combine_image);  /*    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;    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++)        {

/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%                                                                             %%                                                                             %%                                                                             %%     C o m b i n e I m a g e s                                               %%                                                                             %%                                                                             %%                                                                             %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%  CombineImages() combines one or more images into a single image.  The%  grayscale value of the pixels of each image in the sequence is assigned in%  order to the specified channels of the combined image.   The typical%  ordering would be image 1 => Red, 2 => Green, 3 => Blue, etc.%%  The format of the CombineImages method is:%%      Image *CombineImages(const Image *images,const ColorspaceType colorspace,%        ExceptionInfo *exception)%%  A description of each parameter follows:%%    o images: the image sequence.%%    o colorspace: the image colorspace.%%    o exception: return any errors or warnings in this structure.%*/MagickExport Image *CombineImages(const Image *image,  const ColorspaceType colorspace,ExceptionInfo *exception){#define CombineImageTag  "Combine/Image"  CacheView    *combine_view;  Image    *combine_image;  MagickBooleanType    status;  MagickOffsetType    progress;  ssize_t    y;  /*    Ensure the image are the same size.  */  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);//.........这里部分代码省略.........