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

/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%                                                                             %%                                                                             %%                                                                             %+   I n t e g r a l R o t a t e I m a g e                                     %%                                                                             %%                                                                             %%                                                                             %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%  IntegralRotateImage()  rotates the image an integral of 90 degrees.  It%  allocates the memory necessary for the new Image structure and returns a%  pointer to the rotated image.%%  The format of the IntegralRotateImage method is:%%      Image *IntegralRotateImage(const Image *image,unsigned long rotations,%        ExceptionInfo *exception)%%  A description of each parameter follows.%%    o image: The image.%%    o rotations: Specifies the number of 90 degree rotations.%%*/static Image *IntegralRotateImage(const Image *image,unsigned long rotations,  ExceptionInfo *exception){#define RotateImageTag  "Rotate/Image"  Image    *rotate_image;  long    y;  MagickBooleanType    status;  RectangleInfo    page;  register IndexPacket    *indexes,    *rotate_indexes;  register const PixelPacket    *p;  register long    x;  register PixelPacket    *q;  /*    Initialize rotated image attributes.  */  assert(image != (Image *) NULL);  page=image->page;  rotations%=4;  if ((rotations == 1) || (rotations == 3))    rotate_image=CloneImage(image,image->rows,image->columns,MagickTrue,      exception);  else    rotate_image=CloneImage(image,image->columns,image->rows,MagickTrue,      exception);  if (rotate_image == (Image *) NULL)    return((Image *) NULL);  /*    Integral rotate the image.  */  switch (rotations)  {    case 0:    {      /*        Rotate 0 degrees.      */      for (y=0; y < (long) image->rows; y++)      {        p=AcquireImagePixels(image,0,y,image->columns,1,exception);        q=SetImagePixels(rotate_image,0,y,rotate_image->columns,1);        if ((p == (const PixelPacket *) NULL) || (q == (PixelPacket *) NULL))          break;        (void) CopyMagickMemory(q,p,(size_t) image->columns*sizeof(*q));        indexes=GetIndexes(image);        rotate_indexes=GetIndexes(rotate_image);        if ((indexes != (IndexPacket *) NULL) &&            (rotate_indexes != (IndexPacket *) NULL))          (void) CopyMagickMemory(rotate_indexes,indexes,(size_t)            image->columns*sizeof(*rotate_indexes));        if (SyncImagePixels(rotate_image) == MagickFalse)          break;        if ((image->progress_monitor != (MagickProgressMonitor) NULL) &&            (QuantumTick(y,image->rows) != MagickFalse))          {//.........这里部分代码省略.........

/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%                                                                             %%                                                                             %%                                                                             %%   R e a d G R A Y I m a g e                                                 %%                                                                             %%                                                                             %%                                                                             %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%  ReadGRAYImage() reads an image of raw grayscale samples and returns%  it.  It allocates the memory necessary for the new Image structure and%  returns a pointer to the new image.%%  The format of the ReadGRAYImage method is:%%      Image *ReadGRAYImage(const ImageInfo *image_info,%        ExceptionInfo *exception)%%  A description of each parameter follows:%%    o image_info: the image info.%%    o exception: return any errors or warnings in this structure.%*/static Image *ReadGRAYImage(const ImageInfo *image_info,  ExceptionInfo *exception){  const unsigned char    *pixels;  Image    *canvas_image,    *image;  MagickBooleanType    status;  MagickOffsetType    scene;  QuantumInfo    *quantum_info;  QuantumType    quantum_type;  size_t    length;  ssize_t    count,    y;  /*    Open image file.  */  assert(image_info != (const ImageInfo *) NULL);  assert(image_info->signature == MagickCoreSignature);  if (image_info->debug != MagickFalse)    (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",      image_info->filename);  assert(exception != (ExceptionInfo *) NULL);  assert(exception->signature == MagickCoreSignature);  image=AcquireImage(image_info,exception);  if ((image->columns == 0) || (image->rows == 0))    ThrowReaderException(OptionError,"MustSpecifyImageSize");  status=OpenBlob(image_info,image,ReadBinaryBlobMode,exception);  if (status == MagickFalse)    {      image=DestroyImageList(image);      return((Image *) NULL);    }  if (DiscardBlobBytes(image,(size_t) image->offset) == MagickFalse)    ThrowFileException(exception,CorruptImageError,"UnexpectedEndOfFile",      image->filename);  /*    Create virtual canvas to support cropping (i.e. image.gray[100x100+10+20]).  */  SetImageColorspace(image,GRAYColorspace,exception);  canvas_image=CloneImage(image,image->extract_info.width,1,MagickFalse,    exception);  (void) SetImageVirtualPixelMethod(canvas_image,BlackVirtualPixelMethod,    exception);  quantum_type=GrayQuantum;  quantum_info=AcquireQuantumInfo(image_info,canvas_image);  if (quantum_info == (QuantumInfo *) NULL)    ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");  pixels=(const unsigned char *) NULL;  if (image_info->number_scenes != 0)    while (image->scene < image_info->scene)    {      /*        Skip to next image.      */      image->scene++;      length=GetQuantumExtent(canvas_image,quantum_info,quantum_type);      for (y=0; y < (ssize_t) image->rows; y++)//.........这里部分代码省略.........

/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%                                                                             %%                                                                             %%                                                                             %%   R e a d X T R N I m a g e                                                 %%                                                                             %%                                                                             %%                                                                             %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%  ReadXTRNImage() reads a XTRN image file and returns it.  It%  allocates the memory necessary for the new Image structure and returns a%  pointer to the new image.%%  The format of the ReadXTRNImage method is:%%      Image *ReadXTRNImage(const ImageInfo *image_info,%        ExceptionInfo *exception)%%  A description of each parameter follows:%%    o image_info: Specifies a pointer to an ImageInfo structure.%%    o exception: return any errors or warnings in this structure.%*/static Image *ReadXTRNImage(const ImageInfo *image_info,  ExceptionInfo *exception){  Image    *image;  ImageInfo    *clone_info;  void    *param1,    *param2,    *param3;  param1 = param2 = param3 = (void *) NULL;  image = (Image *) NULL;  clone_info=CloneImageInfo(image_info);  if (clone_info->filename == NULL)    {      clone_info=DestroyImageInfo(clone_info);      ThrowReaderException(FileOpenWarning,"No filename specified");    }  if (LocaleCompare(image_info->magick,"XTRNFILE") == 0)    {      image=ReadImage(clone_info,exception);      CatchException(exception);    }  else if (LocaleCompare(image_info->magick,"XTRNIMAGE") == 0)    {      Image        **image_ptr;#ifdef ALL_IMAGEINFO      ImageInfo        **image_info_ptr;#endif      (void) sscanf(clone_info->filename,"%lx,%lx",&param1,&param2);      image_ptr=(Image **) param2;      if (*image_ptr != (Image *)NULL)        image=CloneImage(*image_ptr,0,0,MagickFalse,&(*image_ptr)->exception);#ifdef ALL_IMAGEINFO      image_info_ptr=(ImageInfo **) param1;      if (*image_info_ptr != (ImageInfo *)NULL)        image_info=*image_info_ptr;#endif    }  else if (LocaleCompare(image_info->magick,"XTRNBLOB") == 0)    {      char        **blob_data;      size_t        *blob_length;      char        filename[MaxTextExtent];      (void) sscanf(clone_info->filename,"%lx,%lx,%s",&param1,&param2,&filename);      blob_data=(char **) param1;      blob_length=(size_t *) param2;      image=BlobToImage(clone_info,*blob_data,*blob_length,exception);      CatchException(exception);    }  else if (LocaleCompare(image_info->magick,"XTRNARRAY") == 0)    {      char        *blob_data,        filename[MaxTextExtent];      HRESULT        hr;//.........这里部分代码省略.........

MagickExport Image *ChannelFxImage(const Image *image,const char *expression,                                   ExceptionInfo *exception){#define ChannelFxImageTag  "ChannelFx/Image"    ChannelFx    channel_op;    ChannelType    channel_mask;    char    token[MagickPathExtent];    const char    *p;    const Image    *source_image;    double    pixel;    Image    *destination_image;    MagickBooleanType    status;    PixelChannel    source_channel,    destination_channel;    ssize_t    channels;    assert(image != (Image *) NULL);    assert(image->signature == MagickCoreSignature);    if (image->debug != MagickFalse)        (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);    assert(exception != (ExceptionInfo *) NULL);    assert(exception->signature == MagickCoreSignature);    source_image=image;    destination_image=CloneImage(source_image,0,0,MagickTrue,exception);    if (destination_image == (Image *) NULL)        return((Image *) NULL);    if (expression == (const char *) NULL)        return(destination_image);    destination_channel=RedPixelChannel;    channel_mask=UndefinedChannel;    pixel=0.0;    p=(char *) expression;    GetMagickToken(p,&p,token);    channel_op=ExtractChannelOp;    for (channels=0; *token != '/0'; )    {        ssize_t        i;        /*          Interpret channel expression.        */        switch (*token)        {        case ',':        {            GetMagickToken(p,&p,token);            break;        }        case '|':        {            if (GetNextImageInList(source_image) != (Image *) NULL)                source_image=GetNextImageInList(source_image);            else                source_image=GetFirstImageInList(source_image);            GetMagickToken(p,&p,token);            break;        }        case ';':        {            Image            *canvas;            (void) SetPixelChannelMask(destination_image,channel_mask);            if ((channel_op == ExtractChannelOp) && (channels == 1))                (void) SetImageColorspace(destination_image,GRAYColorspace,exception);            status=SetImageStorageClass(destination_image,DirectClass,exception);            if (status == MagickFalse)            {                destination_image=DestroyImageList(destination_image);                return(destination_image);            }            canvas=CloneImage(source_image,0,0,MagickTrue,exception);            if (canvas == (Image *) NULL)            {                destination_image=DestroyImageList(destination_image);                return(destination_image);            }            AppendImageToList(&destination_image,canvas);            destination_image=GetLastImageInList(destination_image);//.........这里部分代码省略.........

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

/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%                                                                             %%                                                                             %%     A v e r a g e I m a g e s                                               %%                                                                             %%                                                                             %%                                                                             %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%  The Average() method takes a set of images and averages them together.%  Each image in the set must have the same width and height.  Average()%  returns a single image with each corresponding pixel component of%  each image averaged.   On failure, a NULL image is returned and%  exception describes the reason for the failure.%%  The format of the AverageImage method is:%%      Image *AverageImages(Image *image,ExceptionInfo *exception)%%  A description of each parameter follows:%%    o image: The image sequence.%%    o exception: Return any errors or warnings in this structure.%%*/MagickExport Image *AverageImages(const Image *image,ExceptionInfo *exception){  ThreadViewDataSet    *pixels_sums;  Image    *average_image;  const Image    *last_image;  long    y;  unsigned long    row_count=0;  double    number_scenes;      unsigned long    number_pixels;  MagickPassFail    status=MagickPass;  /*    Ensure the image are the same size.  */  assert(image != (Image *) NULL);  assert(image->signature == MagickSignature);  assert(exception != (ExceptionInfo *) NULL);  assert(exception->signature == MagickSignature);  if (image->next == (Image *) NULL)    ThrowImageException3(ImageError,ImageSequenceIsRequired,                         UnableToAverageImage);  {    const Image      *next;          for (next=image; next != (Image *) NULL; next=next->next)      {        if ((next->columns != image->columns) || (next->rows != image->rows))          ThrowImageException3(OptionError,UnableToAverageImageSequence,                               ImageWidthsOrHeightsDiffer);      }  }  /*    Allocate sum accumulation buffer.  */  number_pixels=image->columns;  pixels_sums=AllocateThreadViewDataArray(image,exception,number_pixels,                                          sizeof(DoublePixelPacket));  if (pixels_sums == (ThreadViewDataSet *) NULL)    ThrowImageException3(ResourceLimitError,MemoryAllocationFailed,                         UnableToAverageImageSequence);  /*    Initialize average next attributes.  */  average_image=CloneImage(image,image->columns,image->rows,True,exception);  if (average_image == (Image *) NULL)    {      DestroyThreadViewDataSet(pixels_sums);      return((Image *) NULL);    }  average_image->storage_class=DirectClass;  number_scenes=(double) GetImageListLength(image);  last_image=GetLastImageInList(image);#if defined(HAVE_OPENMP)#  pragma omp parallel for schedule(dynamic) shared(row_count, status)#endif//.........这里部分代码省略.........

static MagickBooleanType load_level(Image *image,XCFDocInfo *inDocInfo,  XCFLayerInfo *inLayerInfo){  ExceptionInfo    *exception;  int    destLeft = 0,    destTop = 0;  Image*    tile_image;  MagickBooleanType    status;  MagickOffsetType    saved_pos,    offset,    offset2;  register ssize_t    i;  size_t    width,    height,    ntiles,    ntile_rows,    ntile_cols,    tile_image_width,    tile_image_height;  /* start reading the data */  exception=inDocInfo->exception;  width=ReadBlobMSBLong(image);  height=ReadBlobMSBLong(image);  /*    Read in the first tile offset.  If it is '0', then this tile level is empty    and we can simply return.  */  offset=(MagickOffsetType) ReadBlobMSBLong(image);  if (offset == 0)    return(MagickTrue);  /*    Initialize the reference for the in-memory tile-compression.  */  ntile_rows=(height+TILE_HEIGHT-1)/TILE_HEIGHT;  ntile_cols=(width+TILE_WIDTH-1)/TILE_WIDTH;  ntiles=ntile_rows*ntile_cols;  for (i = 0; i < (ssize_t) ntiles; i++)  {    status=MagickFalse;    if (offset == 0)      ThrowBinaryException(CorruptImageError,"NotEnoughTiles",image->filename);    /* save the current position as it is where the     *  next tile offset is stored.     */    saved_pos=TellBlob(image);    /* read in the offset of the next tile so we can calculate the amount       of data needed for this tile*/    offset2=(MagickOffsetType)ReadBlobMSBLong(image);    /* if the offset is 0 then we need to read in the maximum possible       allowing for negative compression */    if (offset2 == 0)      offset2=(MagickOffsetType) (offset + TILE_WIDTH * TILE_WIDTH * 4* 1.5);    /* seek to the tile offset */    offset=SeekBlob(image, offset, SEEK_SET);      /* allocate the image for the tile        NOTE: the last tile in a row or column may not be a full tile!      */      tile_image_width=(size_t) (destLeft == (int) ntile_cols-1 ?        (int) width % TILE_WIDTH : TILE_WIDTH);      if (tile_image_width == 0)        tile_image_width=TILE_WIDTH;      tile_image_height = (size_t) (destTop == (int) ntile_rows-1 ?        (int) height % TILE_HEIGHT : TILE_HEIGHT);      if (tile_image_height == 0)        tile_image_height=TILE_HEIGHT;      tile_image=CloneImage(inLayerInfo->image,tile_image_width,        tile_image_height,MagickTrue,exception);      /* read in the tile */      switch (inDocInfo->compression)      {        case COMPRESS_NONE:          if (load_tile(image,tile_image,inDocInfo,inLayerInfo,(size_t) (offset2-offset)) == 0)            status=MagickTrue;          break;        case COMPRESS_RLE:          if (load_tile_rle (image,tile_image,inDocInfo,inLayerInfo,              (int) (offset2-offset)) == 0)            status=MagickTrue;          break;        case COMPRESS_ZLIB:          ThrowBinaryException(CoderError,"ZipCompressNotSupported",            image->filename)        case COMPRESS_FRACTAL://.........这里部分代码省略.........

voidAPITests::testBasicOperations(int width, int height) {  const PixelFormat format = PF_R8G8B8A8;  const int bpp = 4;  auto_ptr<Image> image(CreateImage(width, height, format));  CPPUNIT_ASSERT(image->getWidth()  == width);  CPPUNIT_ASSERT(image->getHeight() == height);  CPPUNIT_ASSERT(image->getFormat() == format);  // verify that the image is black  byte* pixels = (byte*)image->getPixels();  for (int i = 0; i < width * height * bpp; ++i) {    CPPUNIT_ASSERT(pixels[i] == 0);  }  // fill the image with random pixels  for (int i = 0; i < width * height * bpp; ++i) {    pixels[i] = rand() % 256;  }  auto_ptr<Image> create_clone(      CreateImage(image->getWidth(), image->getHeight(),                  image->getFormat(), image->getPixels()));  CPPUNIT_ASSERT(create_clone.get() != 0);  CPPUNIT_ASSERT(image->getWidth()  == create_clone->getWidth());  CPPUNIT_ASSERT(image->getHeight() == create_clone->getHeight());  CPPUNIT_ASSERT(image->getFormat() == create_clone->getFormat());  CPPUNIT_ASSERT(memcmp(image->getPixels(),                        create_clone->getPixels(),                        width * height * bpp) == 0);  // clone the image (use same pixel format)  auto_ptr<Image> identical_clone(CloneImage(image.get()));  CPPUNIT_ASSERT(image->getWidth()  == identical_clone->getWidth());  CPPUNIT_ASSERT(image->getHeight() == identical_clone->getHeight());  CPPUNIT_ASSERT(image->getFormat() == identical_clone->getFormat());  CPPUNIT_ASSERT(memcmp(image->getPixels(),                        identical_clone->getPixels(),                        width * height * bpp) == 0);  // clone the image, removing the alpha channel  auto_ptr<Image> other_clone(CloneImage(identical_clone.get(), PF_R8G8B8));  CPPUNIT_ASSERT(image->getWidth()  == other_clone->getWidth());  CPPUNIT_ASSERT(image->getHeight() == other_clone->getHeight());  CPPUNIT_ASSERT(other_clone->getFormat() == PF_R8G8B8);  byte* image_p = (byte*)image->getPixels();  byte* other_p = (byte*)other_clone->getPixels();  for (int i = 0; i < width * height; ++i) {    CPPUNIT_ASSERT(*image_p++ == *other_p++);    CPPUNIT_ASSERT(*image_p++ == *other_p++);    CPPUNIT_ASSERT(*image_p++ == *other_p++);    ++image_p;  // skip alpha  }  // flip the image  // clone source first, since flip frees the original  auto_ptr<Image> flip_none(FlipImage(CloneImage(image.get()), 0));  auto_ptr<Image> flip_x   (FlipImage(CloneImage(image.get()), CA_X));  auto_ptr<Image> flip_y   (FlipImage(CloneImage(image.get()), CA_Y));  auto_ptr<Image> flip_xy  (FlipImage(CloneImage(image.get()), CA_X | CA_Y));  AssertImagesEqual("No flipping", flip_none.get(), image.get());  CPPUNIT_ASSERT(flip_x.get() != 0);  CPPUNIT_ASSERT(width  == flip_x->getWidth());  CPPUNIT_ASSERT(height == flip_x->getHeight());  CPPUNIT_ASSERT(format == flip_x->getFormat());  CPPUNIT_ASSERT(flip_y.get() != 0);  CPPUNIT_ASSERT(width  == flip_y->getWidth());  CPPUNIT_ASSERT(height == flip_y->getHeight());  CPPUNIT_ASSERT(format == flip_y->getFormat());  CPPUNIT_ASSERT(flip_xy.get() != 0);  CPPUNIT_ASSERT(width  == flip_xy->getWidth());   CPPUNIT_ASSERT(height == flip_xy->getHeight());  CPPUNIT_ASSERT(format == flip_xy->getFormat());  const byte* flip_x_pixels  = (const byte*)flip_x->getPixels();  const byte* flip_y_pixels  = (const byte*)flip_y->getPixels();  const byte* flip_xy_pixels = (const byte*)flip_xy->getPixels();  for (int h = 0; h < height; h++) {    for (int w = 0; w < width; w++) {      const int image_index = (h * width + w) * bpp;      const int opp_w = width  - 1 - w;      const int opp_h = height - 1 - h;      const int flip_x_index  = (opp_h * width + w) * bpp;      const int flip_y_index  = (h * width + opp_w) * bpp;      const int flip_xy_index = (opp_h * width + opp_w) * bpp;            for (int p = 0; p < bpp; p++) {        CPPUNIT_ASSERT(pixels[image_index] == flip_x_pixels [flip_x_index]);        CPPUNIT_ASSERT(pixels[image_index] == flip_y_pixels [flip_y_index]);        CPPUNIT_ASSERT(pixels[image_index] == flip_xy_pixels[flip_xy_index]);      }    }  }//.........这里部分代码省略.........

//.........这里部分代码省略.........    *segment_stack;  ssize_t    offset,    start,    x,    x1,    x2,    y;  /*    Check boundary conditions.  */  assert(image != (Image *) NULL);  assert(image->signature == MagickSignature);  if (image->debug != MagickFalse)    (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);  assert(draw_info != (DrawInfo *) NULL);  assert(draw_info->signature == MagickSignature);  if ((x_offset < 0) || (x_offset >= (ssize_t) image->columns))    return(MagickFalse);  if ((y_offset < 0) || (y_offset >= (ssize_t) image->rows))    return(MagickFalse);  if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)    return(MagickFalse);  if (IsGrayColorspace(image->colorspace) != MagickFalse)    (void) SetImageColorspace(image,sRGBColorspace,exception);  if ((image->alpha_trait != BlendPixelTrait) &&      (draw_info->fill.alpha_trait == BlendPixelTrait))    (void) SetImageAlpha(image,OpaqueAlpha,exception);  /*    Set floodfill state.  */  floodplane_image=CloneImage(image,image->columns,image->rows,MagickTrue,    exception);  if (floodplane_image == (Image *) NULL)    return(MagickFalse);  floodplane_image->alpha_trait=UndefinedPixelTrait;  floodplane_image->colorspace=GRAYColorspace;  (void) QueryColorCompliance("#000",AllCompliance,    &floodplane_image->background_color,exception);  (void) SetImageBackgroundColor(floodplane_image,exception);  segment_info=AcquireVirtualMemory(MaxStacksize,sizeof(*segment_stack));  if (segment_info == (MemoryInfo *) NULL)    {      floodplane_image=DestroyImage(floodplane_image);      ThrowBinaryException(ResourceLimitError,"MemoryAllocationFailed",        image->filename);    }  segment_stack=(SegmentInfo *) GetVirtualMemoryBlob(segment_info);  /*    Push initial segment on stack.  */  status=MagickTrue;  x=x_offset;  y=y_offset;  start=0;  s=segment_stack;  PushSegmentStack(y,x,x,1);  PushSegmentStack(y+1,x,x,-1);  GetPixelInfo(image,&pixel);  image_view=AcquireVirtualCacheView(image,exception);  floodplane_view=AcquireAuthenticCacheView(floodplane_image,exception);  while (s > segment_stack)  {    register const Quantum

/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%                                                                             %%                                                                             %%                                                                             %%   W r i t e E P T I m a g e                                                 %%                                                                             %%                                                                             %%                                                                             %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%  WriteEPTImage() writes an image in the Encapsulated Postscript format%  with a TIFF preview.%%  The format of the WriteEPTImage method is:%%      MagickBooleanType WriteEPTImage(const ImageInfo *image_info,Image *image)%%  A description of each parameter follows.%%    o image_info: the image info.%%    o image:  The image.%*/static MagickBooleanType WriteEPTImage(const ImageInfo *image_info,Image *image){  EPTInfo    ept_info;  Image    *write_image;  ImageInfo    *write_info;  MagickBooleanType    status;  /*    Write EPT image.  */  assert(image_info != (const ImageInfo *) NULL);  assert(image_info->signature == MagickSignature);  assert(image != (Image *) NULL);  assert(image->signature == MagickSignature);  if (image->debug != MagickFalse)    (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);  status=OpenBlob(image_info,image,WriteBinaryBlobMode,&image->exception);  if (status == MagickFalse)    return(status);  write_image=CloneImage(image,0,0,MagickTrue,&image->exception);  if (write_image == (Image *) NULL)    return(MagickFalse);  DestroyBlob(write_image);  write_image->blob=CloneBlobInfo((BlobInfo *) NULL);  write_info=CloneImageInfo(image_info);  (void) CopyMagickString(write_info->magick,"EPS",MaxTextExtent);  if (LocaleCompare(image_info->magick,"EPT2") == 0)    (void) CopyMagickString(write_info->magick,"EPS2",MaxTextExtent);  if (LocaleCompare(image_info->magick,"EPT3") == 0)    (void) CopyMagickString(write_info->magick,"EPS3",MaxTextExtent);  (void) ResetMagickMemory(&ept_info,0,sizeof(ept_info));  ept_info.magick=0xc6d3d0c5ul;  ept_info.postscript=(unsigned char *) ImageToBlob(write_info,write_image,    &ept_info.postscript_length,&image->exception);  write_image=DestroyImage(write_image);  write_info=DestroyImageInfo(write_info);  if (ept_info.postscript == (void *) NULL)    return(MagickFalse);  write_image=CloneImage(image,0,0,MagickTrue,&image->exception);  if (write_image == (Image *) NULL)    return(MagickFalse);  DestroyBlob(write_image);  write_image->blob=CloneBlobInfo((BlobInfo *) NULL);  write_info=CloneImageInfo(image_info);  (void) CopyMagickString(write_info->magick,"TIFF",MaxTextExtent);  (void) FormatMagickString(write_info->filename,MaxTextExtent,"tiff:%.1024s",    write_info->filename);   (void) TransformImage(&write_image,(char *) NULL,"512x512>");  if ((write_image->storage_class == DirectClass) ||      (write_image->colors > 256))    {      QuantizeInfo        quantize_info;      /*        EPT preview requires that the image is colormapped.      */      GetQuantizeInfo(&quantize_info);      quantize_info.dither=IsPaletteImage(write_image,&image->exception) ==        MagickFalse ? MagickTrue : MagickFalse;      (void) QuantizeImage(&quantize_info,write_image);    }  write_image->compression=NoCompression;  ept_info.tiff=(unsigned char *) ImageToBlob(write_info,write_image,    &ept_info.tiff_length,&image->exception);  write_image=DestroyImage(write_image);  write_info=DestroyImageInfo(write_info);  if (ept_info.tiff == (void *) NULL)//.........这里部分代码省略.........

  bool SavePNG(File* file, Image* image) {    COR_GUARD("SavePNG");    if (!image) {      return false;    }    // If the image format isn't supported directly by this function,    // clone to a supported format and try to save with that.    switch (image->getFormat()) {      case PF_R8G8B8A8:      case PF_R8G8B8:      case PF_I8:	break;      default: {	COR_LOG("Unsupported pixel format... cloning");	std::auto_ptr<Image> cloned(CloneImage(image, PF_R8G8B8A8));	return SavePNG(file, cloned.get());      }    }    // create write struct    png_structp png_ptr = png_create_write_struct(      PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);    if (!png_ptr) {      return false;    }    // error handling!    if (setjmp(png_jmpbuf(png_ptr))) {      png_destroy_write_struct(&png_ptr, NULL);      return false;    }    // create info struct    png_infop info_ptr = png_create_info_struct(png_ptr);    if (!info_ptr) {      png_destroy_write_struct(&png_ptr, NULL);      return false;    }    int width  = image->getWidth();    int height = image->getHeight();    // set image characteristics    png_set_write_fn(png_ptr, file, PNG_write, PNG_flush);    int color_format = 0; // png output format    int color_format_bpp = 0; // png bytes per pixel    bool color_format_paletted = false; // png palette needed flag    // figure out output format    switch (image->getFormat()) {      case PF_R8G8B8A8:        color_format = PNG_COLOR_TYPE_RGB_ALPHA;        color_format_bpp = 4;        break;      case PF_R8G8B8:        color_format = PNG_COLOR_TYPE_RGB;        color_format_bpp = 3;        break;      case PF_I8:        color_format = PNG_COLOR_TYPE_PALETTE;        color_format_bpp = 1;        color_format_paletted = true;        break;      default:        // Unsupported format.  This should already be taken care of        // by the test at the beginning of this function.        return false;    }    png_set_IHDR(      png_ptr, info_ptr,      width, height,      8,      color_format,      PNG_INTERLACE_NONE,      PNG_COMPRESSION_TYPE_DEFAULT,      PNG_FILTER_TYPE_DEFAULT);    if (color_format_paletted) {      COR_LOG("Saving palettized image...");      int image_palette_format = image->getPaletteFormat(); // palette format      int image_palette_size = image->getPaletteSize(); // palette size      // allocate png palette and get pointer to image palette      png_color* png_palette = (png_color*)png_malloc(	png_ptr, sizeof(png_color) * image_palette_size);      byte* image_palette = (byte*)image->getPalette();      if (image_palette_format == PF_R8G8B8) {	// 24 bit source palette	for (int i = 0; i < image_palette_size; i++) {	  // copy entry directly	  png_palette[i].red   = *image_palette++;	  png_palette[i].green = *image_palette++;	  png_palette[i].blue  = *image_palette++;	}      } else if (image_palette_format == PF_R8G8B8A8) {	// 32 bit source palette//.........这里部分代码省略.........

/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%                                                                             %%                                                                             %%     A f f i n e T r a n s f o r m I m a g e                                 %%                                                                             %%                                                                             %%                                                                             %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%  AffineTransformImage() transforms an image as dictated by the affine matrix.%  It allocates the memory necessary for the new Image structure and returns%  a pointer to the new image.%%  The format of the AffineTransformImage method is:%%      Image *AffineTransformImage(const Image *image,AffineMatrix *affine,%        ExceptionInfo *exception)%%  A description of each parameter follows:%%    o image: The image.%%    o affine: The affine transform.%%    o exception: Return any errors or warnings in this structure.%%*/MagickExport Image *AffineTransformImage(const Image *image,  const AffineMatrix *affine,ExceptionInfo *exception){  AffineMatrix    transform;  Image    *affine_image;  PointInfo    extent[4],    min,    max,    point;  register long    i;  /*    Determine bounding box.  */  assert(image != (const Image *) NULL);  assert(image->signature == MagickSignature);  if (image->debug != MagickFalse)    (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);  assert(affine != (AffineMatrix *) NULL);  assert(exception != (ExceptionInfo *) NULL);  assert(exception->signature == MagickSignature);  extent[0].x=0.0;  extent[0].y=0.0;  extent[1].x=(double) image->columns;  extent[1].y=0.0;  extent[2].x=(double) image->columns;  extent[2].y=(double) image->rows;  extent[3].x=0.0;  extent[3].y=(double) image->rows;  for (i=0; i < 4; i++)  {    point=extent[i];    extent[i].x=(double) (point.x*affine->sx+point.y*affine->ry+affine->tx);    extent[i].y=(double) (point.x*affine->rx+point.y*affine->sy+affine->ty);  }  min=extent[0];  max=extent[0];  for (i=1; i < 4; i++)  {    if (min.x > extent[i].x)      min.x=extent[i].x;    if (min.y > extent[i].y)      min.y=extent[i].y;    if (max.x < extent[i].x)      max.x=extent[i].x;    if (max.y < extent[i].y)      max.y=extent[i].y;  }  /*    Affine transform image.  */  affine_image=CloneImage(image,(unsigned long) (max.x-min.x+0.5),    (unsigned long) (max.y-min.y+0.5),MagickTrue,exception);  if (affine_image == (Image *) NULL)    return((Image *) NULL);  affine_image->background_color.opacity=TransparentOpacity;  SetImageBackgroundColor(affine_image);  transform.sx=affine->sx;  transform.rx=affine->rx;  transform.ry=affine->ry;  transform.sy=affine->sy;  transform.tx=min.x;  transform.ty=min.y;  (void) DrawAffineImage(affine_image,image,&transform);//.........这里部分代码省略.........

/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%                                                                             %%                                                                             %%                                                                             %%   F r a m e I m a g e                                                       %%                                                                             %%                                                                             %%                                                                             %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%  FrameImage() adds a simulated three-dimensional border around the image.%  The color of the border is defined by the matte_color member of image.%  Members width and height of frame_info specify the border width of the%  vertical and horizontal sides of the frame.  Members inner and outer%  indicate the width of the inner and outer shadows of the frame.%%  The format of the FrameImage method is:%%      Image *FrameImage(const Image *image,const FrameInfo *frame_info,%        ExceptionInfo *exception)%%  A description of each parameter follows:%%    o image: the image.%%    o frame_info: Define the width and height of the frame and its bevels.%%    o exception: return any errors or warnings in this structure.%*/MagickExport Image *FrameImage(const Image *image,const FrameInfo *frame_info,  ExceptionInfo *exception){#define FrameImageTag  "Frame/Image"  CacheView    *image_view,    *frame_view;  Image    *frame_image;  MagickBooleanType    status;  MagickOffsetType    progress;  MagickPixelPacket    accentuate,    border,    highlight,    interior,    matte,    shadow,    trough;  register ssize_t    x;  size_t    bevel_width,    height,    width;  ssize_t    y;  /*    Check frame geometry.  */  assert(image != (Image *) NULL);  assert(image->signature == MagickSignature);  if (image->debug != MagickFalse)    (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);  assert(frame_info != (FrameInfo *) NULL);  if ((frame_info->outer_bevel < 0) || (frame_info->inner_bevel < 0))    ThrowImageException(OptionError,"FrameIsLessThanImageSize");  bevel_width=(size_t) (frame_info->outer_bevel+frame_info->inner_bevel);  width=frame_info->width-frame_info->x-bevel_width;  height=frame_info->height-frame_info->y-bevel_width;  if ((width < image->columns) || (height < image->rows))    ThrowImageException(OptionError,"FrameIsLessThanImageSize");  /*    Initialize framed image attributes.  */  frame_image=CloneImage(image,frame_info->width,frame_info->height,MagickTrue,    exception);  if (frame_image == (Image *) NULL)    return((Image *) NULL);  if (SetImageStorageClass(frame_image,DirectClass) == MagickFalse)    {      InheritException(exception,&frame_image->exception);      frame_image=DestroyImage(frame_image);      return((Image *) NULL);    }  if ((IsPixelGray(&frame_image->border_color) == MagickFalse) &&      (IsGrayColorspace(frame_image->colorspace) != MagickFalse))    (void) SetImageColorspace(frame_image,RGBColorspace);//.........这里部分代码省略.........

MagickExport Image *OilPaintImage(const Image *image,const double radius,  const double sigma,ExceptionInfo *exception){#define NumberPaintBins  256#define OilPaintImageTag  "OilPaint/Image"  CacheView    *image_view,    *paint_view;  Image    *linear_image,    *paint_image;  MagickBooleanType    status;  MagickOffsetType    progress;  size_t    **histograms,    width;  ssize_t    center,    y;  /*    Initialize painted image attributes.  */  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);  width=GetOptimalKernelWidth2D(radius,sigma);  linear_image=CloneImage(image,0,0,MagickTrue,exception);  paint_image=CloneImage(image,image->columns,image->rows,MagickTrue,exception);  if ((linear_image == (Image *) NULL) || (paint_image == (Image *) NULL))    {      if (linear_image != (Image *) NULL)        linear_image=DestroyImage(linear_image);      if (paint_image != (Image *) NULL)        linear_image=DestroyImage(paint_image);      return((Image *) NULL);    }  if (SetImageStorageClass(paint_image,DirectClass,exception) == MagickFalse)    {      linear_image=DestroyImage(linear_image);      paint_image=DestroyImage(paint_image);      return((Image *) NULL);    }  histograms=AcquireHistogramThreadSet(NumberPaintBins);  if (histograms == (size_t **) NULL)    {      linear_image=DestroyImage(linear_image);      paint_image=DestroyImage(paint_image);      ThrowImageException(ResourceLimitError,"MemoryAllocationFailed");    }  /*    Oil paint image.  */  status=MagickTrue;  progress=0;  center=(ssize_t) GetPixelChannels(linear_image)*(linear_image->columns+width)*    (width/2L)+GetPixelChannels(linear_image)*(width/2L);  image_view=AcquireVirtualCacheView(linear_image,exception);  paint_view=AcquireAuthenticCacheView(paint_image,exception);#if defined(MAGICKCORE_OPENMP_SUPPORT)  #pragma omp parallel for schedule(static,4) shared(progress,status) /    magick_threads(linear_image,paint_image,linear_image->rows,1)#endif  for (y=0; y < (ssize_t) linear_image->rows; y++)  {    register const Quantum      *restrict p;    register Quantum      *restrict q;    register size_t      *histogram;    register ssize_t      x;    if (status == MagickFalse)      continue;    p=GetCacheViewVirtualPixels(image_view,-((ssize_t) width/2L),y-(ssize_t)      (width/2L),linear_image->columns+width,width,exception);    q=QueueCacheViewAuthenticPixels(paint_view,0,y,paint_image->columns,1,      exception);    if ((p == (const Quantum *) NULL) || (q == (Quantum *) NULL))      {        status=MagickFalse;        continue;      }    histogram=histograms[GetOpenMPThreadId()];//.........这里部分代码省略.........

/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%                                                                             %%                                                                             %%                                                                             %%   R e a d Y C b C r I m a g e                                               %%                                                                             %%                                                                             %%                                                                             %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%  ReadYCBCRImage() reads an image of raw YCbCr or YCbCrA samples and returns%  it. It allocates the memory necessary for the new Image structure and%  returns a pointer to the new image.%%  The format of the ReadYCBCRImage method is:%%      Image *ReadYCBCRImage(const ImageInfo *image_info,%        ExceptionInfo *exception)%%  A description of each parameter follows:%%    o image_info: the image info.%%    o exception: return any errors or warnings in this structure.%*/static Image *ReadYCBCRImage(const ImageInfo *image_info,  ExceptionInfo *exception){  Image    *canvas_image,    *image;  ssize_t    y;  MagickBooleanType    status;  MagickOffsetType    scene;  QuantumInfo    *quantum_info;  QuantumType    quantum_type;  register const PixelPacket    *p;  register ssize_t    i,    x;  register PixelPacket    *q;  ssize_t    count;  size_t    length;  unsigned char    *pixels;  /*    Open image file.  */  assert(image_info != (const ImageInfo *) NULL);  assert(image_info->signature == MagickSignature);  if (image_info->debug != MagickFalse)    (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",      image_info->filename);  assert(exception != (ExceptionInfo *) NULL);  assert(exception->signature == MagickSignature);  image=AcquireImage(image_info);  if ((image->columns == 0) || (image->rows == 0))    ThrowReaderException(OptionError,"MustSpecifyImageSize");  image->colorspace=YCbCrColorspace;  if (image_info->interlace != PartitionInterlace)    {      status=OpenBlob(image_info,image,ReadBinaryBlobMode,exception);      if (status == MagickFalse)        {          image=DestroyImageList(image);          return((Image *) NULL);        }      if (DiscardBlobBytes(image,image->offset) == MagickFalse)        ThrowFileException(exception,CorruptImageError,"UnexpectedEndOfFile",          image->filename);    }  /*    Create virtual canvas to support cropping (i.e. image.rgb[100x100+10+20]).  */  canvas_image=CloneImage(image,image->extract_info.width,1,MagickFalse,    exception);  (void) SetImageVirtualPixelMethod(canvas_image,BlackVirtualPixelMethod);//.........这里部分代码省略.........

MagickExport Image *ConnectedComponentsImage(const Image *image,        const size_t connectivity,ExceptionInfo *exception){#define ConnectedComponentsImageTag  "ConnectedComponents/Image"    CacheView    *image_view,    *component_view;    const char    *artifact;    double    area_threshold;    Image    *component_image;    MagickBooleanType    status;    MagickOffsetType    progress;    MatrixInfo    *equivalences;    size_t    size;    ssize_t    n,    y;    /*      Initialize connected components image attributes.    */    assert(image != (Image *) NULL);    assert(image->signature == MagickCoreSignature);    if (image->debug != MagickFalse)        (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);    assert(exception != (ExceptionInfo *) NULL);    assert(exception->signature == MagickCoreSignature);    component_image=CloneImage(image,image->columns,image->rows,MagickTrue,                               exception);    if (component_image == (Image *) NULL)        return((Image *) NULL);    component_image->depth=MAGICKCORE_QUANTUM_DEPTH;    component_image->colorspace=GRAYColorspace;    status=SetImageStorageClass(component_image,DirectClass,exception);    if (status == MagickFalse)    {        component_image=DestroyImage(component_image);        return((Image *) NULL);    }    /*      Initialize connected components equivalences.    */    size=image->columns*image->rows;    if (image->columns != (size/image->rows))    {        component_image=DestroyImage(component_image);        ThrowImageException(ResourceLimitError,"MemoryAllocationFailed");    }    equivalences=AcquireMatrixInfo(size,1,sizeof(ssize_t),exception);    if (equivalences == (MatrixInfo *) NULL)    {        component_image=DestroyImage(component_image);        return((Image *) NULL);    }    for (n=0; n < (ssize_t) (image->columns*image->rows); n++)        status=SetMatrixElement(equivalences,n,0,&n);    /*      Find connected components.    */    status=MagickTrue;    progress=0;    image_view=AcquireVirtualCacheView(image,exception);    for (n=0; n < (ssize_t) (connectivity > 4 ? 4 : 2); n++)    {        ssize_t        connect4[2][2] = { { -1,  0 }, {  0, -1 } },        connect8[4][2] = { { -1, -1 }, { -1,  0 }, { -1,  1 }, {  0, -1 } },        dx,        dy;        if (status == MagickFalse)            continue;        dy=connectivity > 4 ? connect8[n][0] : connect4[n][0];        dx=connectivity > 4 ? connect8[n][1] : connect4[n][1];        for (y=0; y < (ssize_t) image->rows; y++)        {            register const Quantum            *magick_restrict p;            register ssize_t            x;            if (status == MagickFalse)                continue;//.........这里部分代码省略.........

//.........这里部分代码省略.........    ThrowCompareException(OptionError,"UnbalancedParenthesis",argv[i]);  if (i-- != (ssize_t) (argc-1))    ThrowCompareException(OptionError,"MissingAnImageFilename",argv[i]);  if ((image == (Image *) NULL) || (GetImageListLength(image) < 2))    ThrowCompareException(OptionError,"MissingAnImageFilename",argv[i]);  FinalizeImageSettings(image_info,image,MagickTrue);  if ((image == (Image *) NULL) || (GetImageListLength(image) < 2))    ThrowCompareException(OptionError,"MissingAnImageFilename",argv[i]);  image=GetImageFromList(image,0);  reconstruct_image=GetImageFromList(image,1);  if (subimage_search != MagickFalse)    {      similarity_image=SimilarityImage(image,reconstruct_image,metric,        similarity_threshold,&offset,&similarity_metric,exception);      if (similarity_metric > dissimilarity_threshold)        ThrowCompareException(ImageError,"ImagesTooDissimilar",image->filename);    }  if ((reconstruct_image->columns == image->columns) &&      (reconstruct_image->rows == image->rows))    difference_image=CompareImages(image,reconstruct_image,metric,&distortion,      exception);  else    if (similarity_image == (Image *) NULL)      ThrowCompareException(OptionError,"ImageWidthsOrHeightsDiffer",        image->filename)    else      {        Image          *composite_image;        /*          Determine if reconstructed image is a subimage of the image.        */        composite_image=CloneImage(image,0,0,MagickTrue,exception);        if (composite_image == (Image *) NULL)          difference_image=CompareImages(image,reconstruct_image,metric,            &distortion,exception);        else          {            Image              *distort_image;            RectangleInfo              page;            (void) CompositeImage(composite_image,reconstruct_image,              CopyCompositeOp,MagickTrue,offset.x,offset.y,exception);            difference_image=CompareImages(image,composite_image,metric,              &distortion,exception);            if (difference_image != (Image *) NULL)              {                difference_image->page.x=offset.x;                difference_image->page.y=offset.y;              }            composite_image=DestroyImage(composite_image);            page.width=reconstruct_image->columns;            page.height=reconstruct_image->rows;            page.x=offset.x;            page.y=offset.y;            distort_image=CropImage(image,&page,exception);            if (distort_image != (Image *) NULL)              {                Image                  *sans_image;                sans_image=CompareImages(distort_image,reconstruct_image,metric,

/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%                                                                             %%                                                                             %%                                                                             %%   W r i t e I N L I N E I m a g e                                           %%                                                                             %%                                                                             %%                                                                             %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%  WriteINLINEImage() writes an image to a file in INLINE format (Base64).%%  The format of the WriteINLINEImage method is:%%      MagickBooleanType WriteINLINEImage(const ImageInfo *image_info,%        Image *image,ExceptionInfo *exception)%%  A description of each parameter follows.%%    o image_info: the image info.%%    o image:  The image.%%    o exception: return any errors or warnings in this structure.%*/static MagickBooleanType WriteINLINEImage(const ImageInfo *image_info,  Image *image,ExceptionInfo *exception){  char    *base64,    message[MagickPathExtent];  const MagickInfo    *magick_info;  Image    *write_image;  ImageInfo    *write_info;  MagickBooleanType    status;  size_t    blob_length,    encode_length;  unsigned char    *blob;  /*    Convert image to base64-encoding.  */  assert(image_info != (const ImageInfo *) NULL);  assert(image_info->signature == MagickCoreSignature);  assert(image != (Image *) NULL);  assert(image->signature == MagickCoreSignature);  if (image->debug != MagickFalse)    (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);  write_info=CloneImageInfo(image_info);  (void) SetImageInfo(write_info,1,exception);  if (LocaleCompare(write_info->magick,"INLINE") == 0)    (void) CopyMagickString(write_info->magick,image->magick,MagickPathExtent);  magick_info=GetMagickInfo(write_info->magick,exception);  if ((magick_info == (const MagickInfo *) NULL) ||      (GetMagickMimeType(magick_info) == (const char *) NULL))    ThrowWriterException(CorruptImageError,"ImageTypeNotSupported");  (void) CopyMagickString(image->filename,write_info->filename,MagickPathExtent);  blob_length=2048;  write_image=CloneImage(image,0,0,MagickTrue,exception);  if (write_image == (Image *) NULL)    {      write_info=DestroyImageInfo(write_info);      return(MagickTrue);    }  blob=(unsigned char *) ImageToBlob(write_info,write_image,&blob_length,    exception);  write_image=DestroyImage(write_image);  write_info=DestroyImageInfo(write_info);  if (blob == (unsigned char *) NULL)    return(MagickFalse);  encode_length=0;  base64=Base64Encode(blob,blob_length,&encode_length);  blob=(unsigned char *) RelinquishMagickMemory(blob);  if (base64 == (char *) NULL)    ThrowWriterException(ResourceLimitError,"MemoryAllocationFailed");  /*    Write base64-encoded image.  */  status=OpenBlob(image_info,image,WriteBinaryBlobMode,exception);  if (status == MagickFalse)    {      base64=DestroyString(base64);      return(status);    }  (void) FormatLocaleString(message,MagickPathExtent,"data:%s;base64,",    GetMagickMimeType(magick_info));//.........这里部分代码省略.........

static MagickBooleanType ReadOneLayer(Image* image,XCFDocInfo* inDocInfo,  XCFLayerInfo *outLayer, ExceptionInfo *exception ){  MagickOffsetType    offset;  unsigned int    foundPropEnd = 0;  size_t    hierarchy_offset,    layer_mask_offset;  /* clear the block! */  (void) ResetMagickMemory( outLayer, 0, sizeof( XCFLayerInfo ) );  /* read in the layer width, height, type and name */  outLayer->width = ReadBlobMSBLong(image);  outLayer->height = ReadBlobMSBLong(image);  outLayer->type = ReadBlobMSBLong(image);  (void) ReadBlobStringWithLongSize(image, outLayer->name,    sizeof(outLayer->name),exception);  /* allocate the image for this layer */  outLayer->image=CloneImage(image,outLayer->width, outLayer->height,MagickTrue,     exception);  if (outLayer->image == (Image *) NULL)    return MagickFalse;  /* read the layer properties! */  foundPropEnd = 0;  while ( (foundPropEnd == MagickFalse) && (EOFBlob(image) == MagickFalse) ) {  PropType    prop_type = (PropType) ReadBlobMSBLong(image);  size_t  prop_size = ReadBlobMSBLong(image);    switch (prop_type)    {    case PROP_END:      foundPropEnd = 1;      break;    case PROP_ACTIVE_LAYER:      outLayer->active = 1;      break;    case PROP_FLOATING_SELECTION:      outLayer->floating_offset = ReadBlobMSBLong(image);      break;    case PROP_OPACITY:      outLayer->opacity = ReadBlobMSBLong(image);      break;    case PROP_VISIBLE:      outLayer->visible = ReadBlobMSBLong(image);      break;    case PROP_LINKED:      outLayer->linked = ReadBlobMSBLong(image);      break;    case PROP_PRESERVE_TRANSPARENCY:      outLayer->preserve_trans = ReadBlobMSBLong(image);      break;    case PROP_APPLY_MASK:      outLayer->apply_mask = ReadBlobMSBLong(image);      break;    case PROP_EDIT_MASK:      outLayer->edit_mask = ReadBlobMSBLong(image);      break;    case PROP_SHOW_MASK:      outLayer->show_mask = ReadBlobMSBLong(image);      break;    case PROP_OFFSETS:      outLayer->offset_x = (int) ReadBlobMSBLong(image);      outLayer->offset_y = (int) ReadBlobMSBLong(image);      break;    case PROP_MODE:      outLayer->mode = ReadBlobMSBLong(image);      break;    case PROP_TATTOO:      outLayer->preserve_trans = ReadBlobMSBLong(image);      break;     case PROP_PARASITES:     {       if (DiscardBlobBytes(image,prop_size) == MagickFalse)         ThrowFileException(exception,CorruptImageError,           "UnexpectedEndOfFile",image->filename);        /*       ssize_t base = info->cp;       GimpParasite *p;       while (info->cp - base < prop_size)       {       p = xcf_load_parasite(info);       gimp_drawable_parasite_attach(GIMP_DRAWABLE(layer), p);       gimp_parasite_free(p);       }       if (info->cp - base != prop_size)       g_message ("Error detected while loading a layer's parasites");       */     }     break;    default:      /* g_message ("unexpected/unknown layer property: %d (skipping)",         prop_type); */      {      int buf[16];      ssize_t amount;//.........这里部分代码省略.........

//.........这里部分代码省略.........    height,    images_per_page,    max_height,    number_images,    number_lines,    sans,    tiles_per_column,    tiles_per_page,    tiles_per_row,    title_offset,    total_tiles,    width;  /*    Create image tiles.  */  assert(images != (Image *) NULL);  assert(images->signature == MagickSignature);  if (images->debug != MagickFalse)    (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",images->filename);  assert(montage_info != (MontageInfo *) NULL);  assert(montage_info->signature == MagickSignature);  assert(exception != (ExceptionInfo *) NULL);  assert(exception->signature == MagickSignature);  number_images=GetImageListLength(images);  master_list=ImageListToArray(images,exception);  image_list=master_list;  image=image_list[0];  if (master_list == (Image **) NULL)    ThrowImageException(ResourceLimitError,"MemoryAllocationFailed");  thumbnail=NewImageList();  for (i=0; i < (long) number_images; i++)  {    image=CloneImage(image_list[i],0,0,MagickTrue,exception);    if (image == (Image *) NULL)      break;    (void) ParseAbsoluteGeometry("0x0+0+0",&image->page);    progress_monitor=SetImageProgressMonitor(image,(MagickProgressMonitor) NULL,      image->client_data);    flags=ParseRegionGeometry(image,montage_info->geometry,&geometry,exception);    thumbnail=ThumbnailImage(image,geometry.width,geometry.height,exception);    if (thumbnail == (Image *) NULL)      break;    image_list[i]=thumbnail;    (void) SetImageProgressMonitor(image,progress_monitor,image->client_data);    proceed=SetImageProgress(image,TileImageTag,i,number_images);    if (proceed == MagickFalse)      break;    image=DestroyImage(image);  }  if (i < (long) number_images)    {      if (thumbnail == (Image *) NULL)        i--;      for (tile=0; (long) tile <= i; tile++)        if (image_list[tile] != (Image *) NULL)          image_list[tile]=DestroyImage(image_list[tile]);      master_list=(Image **) RelinquishMagickMemory(master_list);      return((Image *) NULL);    }  /*    Sort image list by increasing tile number.  */  for (i=0; i < (long) number_images; i++)    if (image_list[i]->scene == 0)      break;

/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%                                                                             %%                                                                             %%                                                                             %%     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 == MagickCoreSignature);    if (image->debug != MagickFalse)        (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);    assert(exception != (ExceptionInfo *) NULL);    assert(exception->signature == MagickCoreSignature);    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);    }    if ((colorspace == UndefinedColorspace) || (image->number_channels == 1))        (void) SetImageColorspace(combine_image,sRGBColorspace,exception);    else        (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        *magick_restrict p;        register Quantum        *magick_restrict q;        register ssize_t        i;        if (status == MagickFalse)//.........这里部分代码省略.........

static MagickBooleanType WritePS3MaskImage(const ImageInfo *image_info,  Image *image,const CompressionType compression){  char    buffer[MaxTextExtent];  Image    *mask_image;  MagickBooleanType    status;  MagickOffsetType    offset,    start,    stop;  register long    i;  size_t    length;  unsigned char    *pixels;  assert(image_info != (ImageInfo *) NULL);  assert(image_info->signature == MagickSignature);  assert(image != (Image *) NULL);  assert(image->signature == MagickSignature);  if (image->debug != MagickFalse)    (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);  assert(image->matte != MagickFalse);  status=MagickTrue;  /*    Note BeginData DSC comment for update later.  */  start=TellBlob(image);  (void) FormatMagickString(buffer,MaxTextExtent,    "%%%%BeginData:%13ld %s Bytes/n",0L,    compression == NoCompression ? "ASCII" : "BINARY");  (void) WriteBlobString(image,buffer);  stop=TellBlob(image);  /*    Only lossless compressions for the mask.  */  switch (compression)  {    case NoCompression:    default:    {      (void) FormatMagickString(buffer,MaxTextExtent,        "currentfile %lu %lu "PS3_NoCompression" ByteStreamDecodeFilter/n",        image->columns,image->rows);      break;    }    case FaxCompression:    case Group4Compression:    {      (void) FormatMagickString(buffer,MaxTextExtent,        "currentfile %lu %lu "PS3_FaxCompression" ByteStreamDecodeFilter/n",        image->columns,image->rows);      break;    }    case LZWCompression:    {      (void) FormatMagickString(buffer,MaxTextExtent,        "currentfile %lu %lu "PS3_LZWCompression" ByteStreamDecodeFilter/n",        image->columns,image->rows);      break;    }    case RLECompression:    {      (void) FormatMagickString(buffer,MaxTextExtent,        "currentfile %lu %lu "PS3_RLECompression" ByteStreamDecodeFilter/n",        image->columns,image->rows);      break;    }    case ZipCompression:    {      (void) FormatMagickString(buffer,MaxTextExtent,        "currentfile %lu %lu "PS3_ZipCompression" ByteStreamDecodeFilter/n",        image->columns,image->rows);      break;    }  }  (void) WriteBlobString(image,buffer);  (void) WriteBlobString(image,"/ReusableStreamDecode filter/n");  mask_image=CloneImage(image,0,0,MagickTrue,&image->exception);  if (mask_image == (Image *) NULL)    ThrowWriterException(CoderError,image->exception.reason);  status=SeparateImageChannel(mask_image,OpacityChannel);  if (status == MagickFalse)    {      mask_image=DestroyImage(mask_image);      return(MagickFalse);    }  (void) SetImageType(mask_image,BilevelType);  (void) SetImageType(mask_image,PaletteType);  mask_image->matte=MagickFalse;//.........这里部分代码省略.........

static MagickBooleanType WriteMPEGImage(const ImageInfo *image_info,  Image *image){#define WriteMPEGIntermediateFormat "jpg"  char    basename[MaxTextExtent],    filename[MaxTextExtent];  double    delay;  Image    *coalesce_image;  ImageInfo    *write_info;  int    file;  MagickBooleanType    status;  register Image    *p;  register ssize_t    i;  size_t    count,    length,    scene;  unsigned char    *blob;  /*    Open output image file.  */  assert(image_info != (const ImageInfo *) NULL);  assert(image_info->signature == MagickSignature);  assert(image != (Image *) NULL);  assert(image->signature == MagickSignature);  if (image->debug != MagickFalse)    (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);  status=OpenBlob(image_info,image,WriteBinaryBlobMode,&image->exception);  if (status == MagickFalse)    return(status);  (void) CloseBlob(image);  /*    Write intermediate files.  */  coalesce_image=CoalesceImages(image,&image->exception);  if (coalesce_image == (Image *) NULL)    return(MagickFalse);  file=AcquireUniqueFileResource(basename);  if (file != -1)    file=close(file)-1;  (void) FormatLocaleString(coalesce_image->filename,MaxTextExtent,"%s",    basename);  count=0;  write_info=CloneImageInfo(image_info);  *write_info->magick='/0';  for (p=coalesce_image; p != (Image *) NULL; p=GetNextImageInList(p))  {    char      previous_image[MaxTextExtent];    blob=(unsigned char *) NULL;    length=0;    scene=p->scene;    delay=100.0*p->delay/MagickMax(1.0*p->ticks_per_second,1.0);    for (i=0; i < (ssize_t) MagickMax((1.0*delay+1.0)/3.0,1.0); i++)    {      p->scene=count;      count++;      status=MagickFalse;      switch (i)      {        case 0:        {          Image            *frame;          (void) FormatLocaleString(p->filename,MaxTextExtent,"%s%.20g.%s",            basename,(double) p->scene,WriteMPEGIntermediateFormat);          (void) FormatLocaleString(filename,MaxTextExtent,"%s%.20g.%s",            basename,(double) p->scene,WriteMPEGIntermediateFormat);          (void) FormatLocaleString(previous_image,MaxTextExtent,            "%s%.20g.%s",basename,(double) p->scene,            WriteMPEGIntermediateFormat);          frame=CloneImage(p,0,0,MagickTrue,&p->exception);          if (frame == (Image *) NULL)            break;          status=WriteImage(write_info,frame);          frame=DestroyImage(frame);          break;        }//.........这里部分代码省略.........

MagickExport Image *InverseFourierTransformImage(const Image *magnitude_image,  const Image *phase_image,const MagickBooleanType modulus,  ExceptionInfo *exception){  Image    *fourier_image;  assert(magnitude_image != (Image *) NULL);  assert(magnitude_image->signature == MagickSignature);  if (magnitude_image->debug != MagickFalse)    (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",      magnitude_image->filename);  if (phase_image == (Image *) NULL)    {      (void) ThrowMagickException(exception,GetMagickModule(),ImageError,        "ImageSequenceRequired","`%s'",magnitude_image->filename);      return((Image *) NULL);    }#if !defined(MAGICKCORE_FFTW_DELEGATE)  fourier_image=(Image *) NULL;  (void) modulus;  (void) ThrowMagickException(exception,GetMagickModule(),    MissingDelegateWarning,"DelegateLibrarySupportNotBuiltIn","`%s' (FFTW)",    magnitude_image->filename);#else  {    fourier_image=CloneImage(magnitude_image,magnitude_image->columns,      magnitude_image->rows,MagickFalse,exception);    if (fourier_image != (Image *) NULL)      {        MagickBooleanType          is_gray,          status;        register long          i;        status=MagickTrue;        is_gray=IsGrayImage(magnitude_image,exception);        if (is_gray != MagickFalse)          is_gray=IsGrayImage(phase_image,exception);#if defined(MAGICKCORE_OPENMP_SUPPORT)        #pragma omp parallel for schedule(dynamic,4) shared(status)#endif        for (i=0L; i < 5L; i++)        {          MagickBooleanType            thread_status;          thread_status=MagickTrue;          switch (i)          {            case 0:            {              if (is_gray != MagickFalse)                {                  thread_status=InverseFourierTransformChannel(magnitude_image,                    phase_image,GrayChannels,modulus,fourier_image,exception);                  break;                }              thread_status=InverseFourierTransformChannel(magnitude_image,                phase_image,RedChannel,modulus,fourier_image,exception);              break;            }            case 1:            {              if (is_gray == MagickFalse)                thread_status=InverseFourierTransformChannel(magnitude_image,                  phase_image,GreenChannel,modulus,fourier_image,exception);              break;            }            case 2:            {              if (is_gray == MagickFalse)                thread_status=InverseFourierTransformChannel(magnitude_image,                  phase_image,BlueChannel,modulus,fourier_image,exception);              break;            }            case 3:            {              if (magnitude_image->matte != MagickFalse)                thread_status=InverseFourierTransformChannel(magnitude_image,                  phase_image,OpacityChannel,modulus,fourier_image,exception);              break;            }            case 4:            {              if (magnitude_image->colorspace == CMYKColorspace)                thread_status=InverseFourierTransformChannel(magnitude_image,                  phase_image,IndexChannel,modulus,fourier_image,exception);              break;            }          }          if (thread_status == MagickFalse)            status=thread_status;        }        if (status == MagickFalse)          fourier_image=DestroyImage(fourier_image);      }      fftw_cleanup();//.........这里部分代码省略.........

static MagickBooleanType WriteHISTOGRAMImage(const ImageInfo *image_info,  Image *image){#define HistogramDensity  "256x200"  ChannelType    channel;  char    filename[MaxTextExtent];  ExceptionInfo    *exception;  FILE    *file;  Image    *histogram_image;  ImageInfo    *write_info;  int    unique_file;  long    y;  MagickBooleanType    status;  MagickPixelPacket    *histogram;  MagickRealType    maximum,    scale;  RectangleInfo    geometry;  register const PixelPacket    *p;  register long    x;  register PixelPacket    *q,    *r;  size_t    length;  /*    Allocate histogram image.  */  assert(image_info != (const ImageInfo *) NULL);  assert(image_info->signature == MagickSignature);  assert(image != (Image *) NULL);  assert(image->signature == MagickSignature);  if (image->debug != MagickFalse)    (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",      image_info->filename);  SetGeometry(image,&geometry);  if (image_info->density == (char *) NULL)    (void) ParseAbsoluteGeometry(HistogramDensity,&geometry);  else    (void) ParseAbsoluteGeometry(image_info->density,&geometry);  histogram_image=CloneImage(image,geometry.width,geometry.height,MagickTrue,    &image->exception);  if (histogram_image == (Image *) NULL)    ThrowWriterException(ResourceLimitError,"MemoryAllocationFailed");  (void) SetImageStorageClass(histogram_image,DirectClass);  /*    Allocate histogram count arrays.  */  length=MagickMax((size_t) ScaleQuantumToChar((Quantum) QuantumRange)+1UL,    histogram_image->columns);  histogram=(MagickPixelPacket *) AcquireQuantumMemory(length,    sizeof(*histogram));  if (histogram == (MagickPixelPacket *) NULL)    {      histogram_image=DestroyImage(histogram_image);      ThrowWriterException(ResourceLimitError,"MemoryAllocationFailed");    }  /*    Initialize histogram count arrays.  */  channel=image_info->channel;  (void) ResetMagickMemory(histogram,0,length*sizeof(*histogram));  for (y=0; y < (long) image->rows; y++)  {    p=GetVirtualPixels(image,0,y,image->columns,1,&image->exception);    if (p == (const PixelPacket *) NULL)      break;    for (x=0; x < (long) image->columns; x++)    {      if ((channel & RedChannel) != 0)//.........这里部分代码省略.........

MagickExport Image *ForwardFourierTransformImage(const Image *image,  const MagickBooleanType modulus,ExceptionInfo *exception){  Image    *fourier_image;  fourier_image=NewImageList();#if !defined(MAGICKCORE_FFTW_DELEGATE)  (void) modulus;  (void) ThrowMagickException(exception,GetMagickModule(),    MissingDelegateWarning,"DelegateLibrarySupportNotBuiltIn","`%s' (FFTW)",    image->filename);#else  {    Image      *magnitude_image;    unsigned long      extent,      width;    width=image->columns;    if ((image->columns != image->rows) || ((image->columns % 2) != 0) ||        ((image->rows % 2) != 0))      {        extent=image->columns < image->rows ? image->rows : image->columns;        width=(extent & 0x01) == 1 ? extent+1UL : extent;      }    magnitude_image=CloneImage(image,width,width,MagickFalse,exception);    if (magnitude_image != (Image *) NULL)      {        Image          *phase_image;        magnitude_image->storage_class=DirectClass;        magnitude_image->depth=32UL;        phase_image=CloneImage(image,width,width,MagickFalse,exception);        if (phase_image == (Image *) NULL)          magnitude_image=DestroyImage(magnitude_image);        else          {            MagickBooleanType              is_gray,              status;            register long              i;            phase_image->storage_class=DirectClass;            phase_image->depth=32UL;            AppendImageToList(&fourier_image,magnitude_image);            AppendImageToList(&fourier_image,phase_image);            status=MagickTrue;            is_gray=IsGrayImage(image,exception);#if defined(MAGICKCORE_OPENMP_SUPPORT)  #pragma omp parallel for schedule(dynamic,4) shared(status)#endif            for (i=0L; i < 5L; i++)            {              MagickBooleanType                thread_status;              thread_status=MagickTrue;              switch (i)              {                case 0:                {                  if (is_gray != MagickFalse)                    {                      thread_status=ForwardFourierTransformChannel(image,                        GrayChannels,modulus,fourier_image,exception);                      break;                    }                  thread_status=ForwardFourierTransformChannel(image,RedChannel,                    modulus,fourier_image,exception);                  break;                }                case 1:                {                  if (is_gray == MagickFalse)                    thread_status=ForwardFourierTransformChannel(image,                      GreenChannel,modulus,fourier_image,exception);                  break;                }                case 2:                {                  if (is_gray == MagickFalse)                    thread_status=ForwardFourierTransformChannel(image,                      BlueChannel,modulus,fourier_image,exception);                  break;                }                case 4:                {                  if (image->matte != MagickFalse)                    thread_status=ForwardFourierTransformChannel(image,                      OpacityChannel,modulus,fourier_image,exception);                  break;                }                case 5:                {//.........这里部分代码省略.........

static MagickBooleanType WriteXTRNImage(const ImageInfo *image_info,  Image *image){  Image *    p;  ImageInfo    *clone_info;  int    scene;  MagickBooleanType    status;  void    *param1,    *param2,    *param3;  param1 = param2 = param3 = (void *) NULL;  if (LocaleCompare(image_info->magick,"XTRNFILE") == 0)    {      clone_info=CloneImageInfo(image_info);      status=WriteImage(image_info,image);      if (status == MagickFalse)        CatchImageException(image);      clone_info=DestroyImageInfo(clone_info);    }  else if (LocaleCompare(image_info->magick,"XTRNIMAGE") == 0)    {      Image        **image_ptr;      ImageInfo        **image_info_ptr;      clone_info=CloneImageInfo(image_info);      if (clone_info->filename[0])        {          (void) sscanf(clone_info->filename,"%lx,%lx",&param1,&param2);          image_info_ptr=(ImageInfo **) param1;          image_ptr=(Image **) param2;          if ((image_info_ptr != (ImageInfo **) NULL) &&              (image_ptr != (Image **) NULL))            {              *image_ptr=CloneImage(image,0,0,MagickFalse,&(image->exception));              *image_info_ptr=clone_info;            }        }    }  else if (LocaleCompare(image_info->magick,"XTRNBLOB") == 0)    {      char        **blob_data;      ExceptionInfo        *exception;      size_t        *blob_length;      char        filename[MaxTextExtent];      clone_info=CloneImageInfo(image_info);      if (clone_info->filename[0])        {          (void) sscanf(clone_info->filename,"%lx,%lx,%s",            &param1,&param2,&filename);          blob_data=(char **) param1;          blob_length=(size_t *) param2;          scene = 0;          (void) CopyMagickString(clone_info->filename,filename,MaxTextExtent);          for (p=image; p != (Image *) NULL; p=GetNextImageInList(p))          {            (void) CopyMagickString(p->filename,filename,MaxTextExtent);            p->scene=scene++;          }          SetImageInfo(clone_info,1,&image->exception);          (void) CopyMagickString(image->magick,clone_info->magick,            MaxTextExtent);          exception=AcquireExceptionInfo();          if (*blob_length == 0)            *blob_length=8192;          *blob_data=(char *) ImageToBlob(clone_info,image,blob_length,            exception);          exception=DestroyExceptionInfo(exception);          if (*blob_data == NULL)            status=MagickFalse;          if (status == MagickFalse)            CatchImageException(image);        }      clone_info=DestroyImageInfo(clone_info);    }  else if (LocaleCompare(image_info->magick,"XTRNARRAY") == 0)    {      char        filename[MaxTextExtent];//.........这里部分代码省略.........

/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%                                                                             %%                                                                             %%                                                                             %%   S h e a r I m a g e                                                       %%                                                                             %%                                                                             %%                                                                             %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%  ShearImage() creates a new image that is a shear_image copy of an existing%  one.  Shearing slides one edge of an image along the X or Y axis, creating%  a parallelogram.  An X direction shear slides an edge along the X axis,%  while a Y direction shear slides an edge along the Y axis.  The amount of%  the shear is controlled by a shear angle.  For X direction shears, x_shear%  is measured relative to the Y axis, and similarly, for Y direction shears%  y_shear is measured relative to the X axis.  Empty triangles left over from%  shearing the image are filled with the background color defined by member%  'background_color' of the image..  ShearImage() allocates the memory%  necessary for the new Image structure and returns a pointer to the new image.%%  ShearImage() is based on the paper "A Fast Algorithm for General Raster%  Rotatation" by Alan W. Paeth.%%  The format of the ShearImage method is:%%      Image *ShearImage(const Image *image,const double x_shear,%        const double y_shear,ExceptionInfo *exception)%%  A description of each parameter follows.%%    o image: The image.%%    o x_shear, y_shear: Specifies the number of degrees to shear the image.%%    o exception: Return any errors or warnings in this structure.%%*/MagickExport Image *ShearImage(const Image *image,const double x_shear,  const double y_shear,ExceptionInfo *exception){  Image    *integral_image,    *shear_image;  long    x_offset,    y_offset;  PointInfo    shear;  RectangleInfo    border_info;  unsigned long    y_width;  assert(image != (Image *) NULL);  assert(image->signature == MagickSignature);  if (image->debug != MagickFalse)    (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);  assert(exception != (ExceptionInfo *) NULL);  assert(exception->signature == MagickSignature);  if ((x_shear != 0.0) && (fmod(x_shear,90.0) == 0.0))    ThrowImageException(ImageError,"AngleIsDiscontinuous");  if ((y_shear != 0.0) && (fmod(y_shear,90.0) == 0.0))    ThrowImageException(ImageError,"AngleIsDiscontinuous");  /*    Initialize shear angle.  */  integral_image=CloneImage(image,0,0,MagickTrue,exception);  if (integral_image == (Image *) NULL)    ThrowImageException(ResourceLimitError,"MemoryAllocationFailed");  shear.x=(-tan(DegreesToRadians(x_shear)));  shear.y=tan(DegreesToRadians(y_shear));  if ((shear.x == 0.0) && (shear.y == 0.0))    return(integral_image);  integral_image->storage_class=DirectClass;  if (integral_image->matte == MagickFalse)    SetImageOpacity(integral_image,OpaqueOpacity);  /*    Compute image size.  */  x_offset=(long) (fabs((double) image->rows*shear.x)+0.5);  y_width=(unsigned long)    (fabs((double) image->rows*shear.x)+image->columns+0.5);  y_offset=(long) (fabs((double) y_width*shear.y)+0.5);  /*    Surround image with border.  */  integral_image->border_color=integral_image->background_color;  border_info.width=(unsigned long) x_offset;  border_info.height=(unsigned long) y_offset;  shear_image=BorderImage(integral_image,&border_info,exception);  if (shear_image == (Image *) NULL)    ThrowImageException(ResourceLimitError,"MemoryAllocationFailed");  integral_image=DestroyImage(integral_image);//.........这里部分代码省略.........