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

/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%                                                                             %%                                                                             %%                                                                             %%   G e t I m a g e V i e w A u t h e n t i c I n d e x e s                   %%                                                                             %%                                                                             %%                                                                             %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%  GetImageViewAuthenticIndexes() returns the image view authentic indexes.%%  The format of the GetImageViewAuthenticPixels method is:%%      IndexPacket *GetImageViewAuthenticIndexes(const ImageView *image_view)%%  A description of each parameter follows:%%    o image_view: the image view.%*/MagickExport IndexPacket *GetImageViewAuthenticIndexes(  const ImageView *image_view){  assert(image_view != (ImageView *) NULL);  assert(image_view->signature == MagickSignature);  return(GetCacheViewAuthenticIndexQueue(image_view->view));}

// Return pixel colormap index arrayMagick::IndexPacket* Magick::Pixels::indexes ( void ){  IndexPacket* pixel_indexes = GetCacheViewAuthenticIndexQueue( _view );  if ( !pixel_indexes )    _image.throwImageException();  return pixel_indexes;}

/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%                                                                             %%                                                                             %%                                                                             %%   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 SortColormapByIntensity(Image *image){  CacheView    *image_view;  ExceptionInfo    *exception;  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 == 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(static,4) shared(status) /    magick_threads(image,image,1,1)#endif  for (i=0; i < (ssize_t) 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(static,4) shared(status)#endif  for (i=0; i < (ssize_t) image->colors; i++)    pixels[(ssize_t) image->colormap[i].opacity]=(unsigned short) i;  status=MagickTrue;  exception=(&image->exception);  image_view=AcquireAuthenticCacheView(image,exception);  for (y=0; y < (ssize_t) image->rows; y++)  {    IndexPacket      index;    register ssize_t      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 < (ssize_t) image->columns; x++)    {      index=(IndexPacket) pixels[(ssize_t) GetPixelIndex(indexes+x)];      SetPixelIndex(indexes+x,index);      SetPixelRGBO(q,image->colormap+(ssize_t) index);      q++;    }    if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse)      status=MagickFalse;    if (status == MagickFalse)      break;  }  image_view=DestroyCacheView(image_view);  pixels=(unsigned short *) RelinquishMagickMemory(pixels);  return(status);}

MagickExport MagickBooleanType OpaquePaintImageChannel(Image *image,  const ChannelType channel,const MagickPixelPacket *target,  const MagickPixelPacket *fill,const MagickBooleanType invert){#define OpaquePaintImageTag  "Opaque/Image"  ExceptionInfo    *exception;  long    progress,    y;  MagickBooleanType    status;  MagickPixelPacket    zero;  CacheView    *image_view;  assert(image != (Image *) NULL);  assert(image->signature == MagickSignature);  assert(target != (MagickPixelPacket *) NULL);  assert(fill != (MagickPixelPacket *) NULL);  if (image->debug != MagickFalse)    (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);  if (SetImageStorageClass(image,DirectClass) == MagickFalse)    return(MagickFalse);  /*    Make image color opaque.  */  status=MagickTrue;  progress=0;  exception=(&image->exception);  GetMagickPixelPacket(image,&zero);  image_view=AcquireCacheView(image);#if defined(MAGICKCORE_OPENMP_SUPPORT)  #pragma omp parallel for schedule(dynamic,4) shared(progress,status)#endif  for (y=0; y < (long) image->rows; y++)  {    MagickPixelPacket      pixel;    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);    pixel=zero;    for (x=0; x < (long) image->columns; x++)    {      SetMagickPixelPacket(image,q,indexes+x,&pixel);      if (IsMagickColorSimilar(&pixel,target) != invert)        {          if ((channel & RedChannel) != 0)            q->red=RoundToQuantum(fill->red);          if ((channel & GreenChannel) != 0)            q->green=RoundToQuantum(fill->green);          if ((channel & BlueChannel) != 0)            q->blue=RoundToQuantum(fill->blue);          if ((channel & OpacityChannel) != 0)            q->opacity=RoundToQuantum(fill->opacity);          if (((channel & IndexChannel) != 0) &&              (image->colorspace == CMYKColorspace))            indexes[x]=RoundToQuantum(fill->index);        }      q++;    }    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_OpaquePaintImageChannel)#endif        proceed=SetImageProgress(image,OpaquePaintImageTag,progress++,          image->rows);        if (proceed == MagickFalse)          status=MagickFalse;      }  }//.........这里部分代码省略.........

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

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

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

//.........这里部分代码省略.........%*/MagickExport MagickBooleanType TransparentPaintImageChroma(Image *image,  const MagickPixelPacket *low,const MagickPixelPacket *high,  const Quantum opacity,const MagickBooleanType invert){#define TransparentPaintImageTag  "Transparent/Image"  CacheView    *image_view;  ExceptionInfo    *exception;  MagickBooleanType    status;  MagickOffsetType    progress;  ssize_t    y;  assert(image != (Image *) NULL);  assert(image->signature == MagickSignature);  assert(high != (MagickPixelPacket *) NULL);  assert(low != (MagickPixelPacket *) NULL);  if (image->debug != MagickFalse)    (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);  if (SetImageStorageClass(image,DirectClass) == MagickFalse)    return(MagickFalse);  if (image->matte == MagickFalse)    (void) SetImageAlphaChannel(image,ResetAlphaChannel);  /*    Make image color transparent.  */  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)#endif  for (y=0; y < (ssize_t) image->rows; y++)  {    MagickBooleanType      match;    MagickPixelPacket      pixel;    register IndexPacket      *restrict indexes;    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)      {        status=MagickFalse;        continue;      }    indexes=GetCacheViewAuthenticIndexQueue(image_view);    GetMagickPixelPacket(image,&pixel);    for (x=0; x < (ssize_t) image->columns; x++)    {      SetMagickPixelPacket(image,q,indexes+x,&pixel);      match=((pixel.red >= low->red) && (pixel.red <= high->red) &&        (pixel.green >= low->green) && (pixel.green <= high->green) &&        (pixel.blue  >= low->blue) && (pixel.blue <= high->blue)) ?        MagickTrue : MagickFalse;      if (match != invert)        q->opacity=opacity;      q++;    }    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_TransparentPaintImageChroma)#endif        proceed=SetImageProgress(image,TransparentPaintImageTag,progress++,          image->rows);        if (proceed == MagickFalse)          status=MagickFalse;      }  }  image_view=DestroyCacheView(image_view);  return(status);}

/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%                                                                             %%                                                                             %%                                                                             %%   S e t P i x e l V i e w I t e r a t o r                                   %%                                                                             %%                                                                             %%                                                                             %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%  SetPixelViewIterator() iterates over the pixel view in parallel and calls%  your set method for each scanline of the view.  The pixel region 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.%%  Use this pragma:%%    #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 SetPixelViewIterator method is:%%      MagickBooleanType SetPixelViewIterator(PixelView *destination,%        SetPixelViewMethod set,void *context)%%  A description of each parameter follows:%%    o destination: the pixel view.%%    o set: the set callback method.%%    o context: the user defined context.%*/WandExport MagickBooleanType SetPixelViewIterator(PixelView *destination,  SetPixelViewMethod set,void *context){#define SetPixelViewTag  "PixelView/Set"  ExceptionInfo    *exception;  Image    *destination_image;  long    progress,    y;  MagickBooleanType    status;  assert(destination != (PixelView *) NULL);  assert(destination->signature == WandSignature);  if (set == (SetPixelViewMethod) 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(dynamic,4) shared(progress,status)#endif  for (y=destination->region.y; y < (long) destination->region.height; y++)  {    MagickBooleanType      sync;    register IndexPacket      *__restrict indexes;    register long      id,      x;    register PixelPacket      *__restrict pixels;    if (status == MagickFalse)      continue;    id=GetOpenMPThreadId();    pixels=GetCacheViewAuthenticPixels(destination->view,destination->region.x,      y,destination->region.width,1,exception);    if (pixels == (PixelPacket *) NULL)      {        InheritException(destination->exception,GetCacheViewException(          destination->view));        status=MagickFalse;        continue;      }    indexes=GetCacheViewAuthenticIndexQueue(destination->view);    if (set(destination,context) == MagickFalse)      status=MagickFalse;//.........这里部分代码省略.........

//.........这里部分代码省略.........    register const PixelPacket      *__restrict duplex_pixels,      *__restrict pixels;    register IndexPacket      *__restrict destination_indexes;    register long      id,      x;    register PixelPacket      *__restrict destination_pixels;    if (status == MagickFalse)      continue;    id=GetOpenMPThreadId();    pixels=GetCacheViewVirtualPixels(source->view,source->region.x,y,      source->region.width,1,source->exception);    if (pixels == (const PixelPacket *) NULL)      {        status=MagickFalse;        continue;      }    indexes=GetCacheViewVirtualIndexQueue(source->view);    for (x=0; x < (long) source->region.width; x++)      PixelSetQuantumColor(source->pixel_wands[id][x],pixels+x);    if (source_image->colorspace == CMYKColorspace)      for (x=0; x < (long) source->region.width; x++)        PixelSetBlackQuantum(source->pixel_wands[id][x],indexes[x]);    if (source_image->storage_class == PseudoClass)      for (x=0; x < (long) source->region.width; x++)        PixelSetIndex(source->pixel_wands[id][x],indexes[x]);    duplex_pixels=GetCacheViewVirtualPixels(duplex->view,duplex->region.x,y,      duplex->region.width,1,duplex->exception);    if (duplex_pixels == (const PixelPacket *) NULL)      {        status=MagickFalse;        continue;      }    duplex_indexes=GetCacheViewVirtualIndexQueue(duplex->view);    for (x=0; x < (long) duplex->region.width; x++)      PixelSetQuantumColor(duplex->pixel_wands[id][x],duplex_pixels+x);    if (duplex_image->colorspace == CMYKColorspace)      for (x=0; x < (long) duplex->region.width; x++)        PixelSetBlackQuantum(duplex->pixel_wands[id][x],duplex_indexes[x]);    if (duplex_image->storage_class == PseudoClass)      for (x=0; x < (long) duplex->region.width; x++)        PixelSetIndex(duplex->pixel_wands[id][x],duplex_indexes[x]);    destination_pixels=GetCacheViewAuthenticPixels(destination->view,      destination->region.x,y,destination->region.width,1,exception);    if (destination_pixels == (PixelPacket *) NULL)      {        status=MagickFalse;        continue;      }    destination_indexes=GetCacheViewAuthenticIndexQueue(destination->view);    for (x=0; x < (long) destination->region.width; x++)      PixelSetQuantumColor(destination->pixel_wands[id][x],        destination_pixels+x);    if (destination_image->colorspace == CMYKColorspace)      for (x=0; x < (long) destination->region.width; x++)        PixelSetBlackQuantum(destination->pixel_wands[id][x],          destination_indexes[x]);    if (destination_image->storage_class == PseudoClass)      for (x=0; x < (long) destination->region.width; x++)        PixelSetIndex(destination->pixel_wands[id][x],destination_indexes[x]);    if (transfer(source,duplex,destination,context) == MagickFalse)      status=MagickFalse;    for (x=0; x < (long) destination->region.width; x++)      PixelGetQuantumColor(destination->pixel_wands[id][x],        destination_pixels+x);    if (destination_image->colorspace == CMYKColorspace)      for (x=0; x < (long) destination->region.width; x++)        destination_indexes[x]=PixelGetBlackQuantum(          destination->pixel_wands[id][x]);    sync=SyncCacheViewAuthenticPixels(destination->view,exception);    if (sync == MagickFalse)      {        InheritException(destination->exception,GetCacheViewException(          source->view));        status=MagickFalse;      }    if (source_image->progress_monitor != (MagickProgressMonitor) NULL)      {        MagickBooleanType          proceed;#if defined(MAGICKCORE_OPENMP_SUPPORT)  #pragma omp critical (MagickWand_DuplexTransferPixelViewIterator)#endif        proceed=SetImageProgress(source_image,DuplexTransferPixelViewTag,          progress++,source->region.height);        if (proceed == MagickFalse)          status=MagickFalse;      }  }  return(status);}

//.........这里部分代码省略.........  trough.opacity=matte.opacity;  if (image->colorspace == CMYKColorspace)    {      ConvertRGBToCMYK(&interior);      ConvertRGBToCMYK(&matte);      ConvertRGBToCMYK(&border);      ConvertRGBToCMYK(&accentuate);      ConvertRGBToCMYK(&highlight);      ConvertRGBToCMYK(&shadow);      ConvertRGBToCMYK(&trough);    }  status=MagickTrue;  progress=0;  image_view=AcquireCacheView(image);  frame_view=AcquireCacheView(frame_image);  height=(size_t) (frame_info->outer_bevel+(frame_info->y-bevel_width)+    frame_info->inner_bevel);  if (height != 0)    {      register IndexPacket        *restrict frame_indexes;      register ssize_t        x;      register PixelPacket        *restrict q;      /*        Draw top of ornamental border.      */      q=QueueCacheViewAuthenticPixels(frame_view,0,0,frame_image->columns,        height,exception);      frame_indexes=GetCacheViewAuthenticIndexQueue(frame_view);      if (q != (PixelPacket *) NULL)        {          /*            Draw top of ornamental border.          */          for (y=0; y < (ssize_t) frame_info->outer_bevel; y++)          {            for (x=0; x < (ssize_t) (frame_image->columns-y); x++)            {              if (x < y)                SetPixelPacket(frame_image,&highlight,q,frame_indexes);              else                SetPixelPacket(frame_image,&accentuate,q,frame_indexes);              q++;              frame_indexes++;            }            for ( ; x < (ssize_t) frame_image->columns; x++)            {              SetPixelPacket(frame_image,&shadow,q,frame_indexes);              q++;              frame_indexes++;            }          }          for (y=0; y < (ssize_t) (frame_info->y-bevel_width); y++)          {            for (x=0; x < (ssize_t) frame_info->outer_bevel; x++)            {              SetPixelPacket(frame_image,&highlight,q,frame_indexes);              q++;              frame_indexes++;            }            width=frame_image->columns-2*frame_info->outer_bevel;

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

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

//.........这里部分代码省略.........%  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));        status=MagickFalse;        continue;      }    indexes=GetCacheViewAuthenticIndexQueue(destination->view);    if (set(destination,y,id,context) == MagickFalse)      status=MagickFalse;    for (x=0; x < (ssize_t) destination->extent.width; x++)      PixelGetQuantumColor(destination->pixel_wands[id][x],pixels+x);    if (destination_image->colorspace == CMYKColorspace)      for (x=0; x < (ssize_t) destination->extent.width; x++)        SetPixelBlack(indexes+x,PixelGetBlackQuantum(          destination->pixel_wands[id][x]));    sync=SyncCacheViewAuthenticPixels(destination->view,exception);    if (sync == MagickFalse)      {        InheritException(destination->exception,GetCacheViewException(          destination->view));        status=MagickFalse;      }    if (destination_image->progress_monitor != (MagickProgressMonitor) NULL)      {        MagickBooleanType          proceed;#if defined(MAGICKCORE_OPENMP_SUPPORT)  #pragma omp critical (MagickWand_SetWandViewIterator)#endif        proceed=SetImageProgress(destination_image,destination->description,          progress++,destination->extent.height);        if (proceed == MagickFalse)          status=MagickFalse;      }  }  return(status);}

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

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

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

/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%                                                                             %%                                                                             %%                                                                             %%     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 ssize_t displace)%%  A description of each parameter follows:%%    o image: the image.%%    o displace:  displace the colormap this amount.%*/MagickExport MagickBooleanType CycleColormapImage(Image *image,  const ssize_t displace){  CacheView    *image_view;  ExceptionInfo    *exception;  MagickBooleanType    status;  ssize_t    y;  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=AcquireAuthenticCacheView(image,exception);#if defined(MAGICKCORE_OPENMP_SUPPORT)  #pragma omp parallel for schedule(static,4) shared(status) /    magick_threads(image,image,1,1)#endif  for (y=0; y < (ssize_t) image->rows; y++)  {    register IndexPacket      *restrict indexes;    register ssize_t      x;    register PixelPacket      *restrict q;    ssize_t      index;    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 < (ssize_t) image->columns; x++)    {      index=(ssize_t) (GetPixelIndex(indexes+x)+displace) %        image->colors;      if (index < 0)        index+=(ssize_t) image->colors;      SetPixelIndex(indexes+x,index);      SetPixelRGBO(q,image->colormap+(ssize_t) index);      q++;    }    if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse)      status=MagickFalse;  }  image_view=DestroyCacheView(image_view);  return(status);}

//.........这里部分代码省略.........        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);        next=GetNextImageInList(next);      }    if (((channel & OpacityChannel) != 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++)        {          SetPixelAlpha(q,ClampToQuantum(GetPixelIntensity(image,p)));          p++;          q++;        }        image_view=DestroyCacheView(image_view);        next=GetNextImageInList(next);      }    if (((channel & IndexChannel) != 0) &&        (image->colorspace == CMYKColorspace) && (next != (Image *) NULL))      {        IndexPacket          *indexes;        image_view=AcquireVirtualCacheView(next,exception);        p=GetCacheViewVirtualPixels(image_view,0,y,next->columns,1,exception);        if (p == (const PixelPacket *) NULL)          continue;        indexes=GetCacheViewAuthenticIndexQueue(combine_view);        for (x=0; x < (ssize_t) combine_image->columns; x++)        {          SetPixelIndex(indexes+x,ClampToQuantum(GetPixelIntensity(image,p)));          p++;        }        image_view=DestroyCacheView(image_view);        next=GetNextImageInList(next);      }    if (SyncCacheViewAuthenticPixels(combine_view,exception) == MagickFalse)      status=MagickFalse;    if (image->progress_monitor != (MagickProgressMonitor) NULL)      {        MagickBooleanType          proceed;        proceed=SetImageProgress(image,CombineImageTag,progress++,          combine_image->rows);        if (proceed == MagickFalse)          status=MagickFalse;      }  }  combine_view=DestroyCacheView(combine_view);  if (IsGrayColorspace(combine_image->colorspace) != MagickFalse)    (void) TransformImageColorspace(combine_image,sRGBColorspace);  if (status == MagickFalse)    combine_image=DestroyImage(combine_image);  return(combine_image);}

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