• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3 %                                                                             %
4 %                                                                             %
5 %                        W   W   AAA   N   N  DDDD                            %
6 %                        W   W  A   A  NN  N  D   D                           %
7 %                        W W W  AAAAA  N N N  D   D                           %
8 %                        WW WW  A   A  N  NN  D   D                           %
9 %                        W   W  A   A  N   N  DDDD                            %
10 %                                                                             %
11 %                        V   V  IIIII  EEEEE  W   W                           %
12 %                        V   V    I    E      W   W                           %
13 %                        V   V    I    EEE    W W W                           %
14 %                         V V     I    E      WW WW                           %
15 %                          V    IIIII  EEEEE  W   W                           %
16 %                                                                             %
17 %                                                                             %
18 %                        MagickWand Wand View Methods                         %
19 %                                                                             %
20 %                              Software Design                                %
21 %                                   Cristy                                    %
22 %                                March 2003                                   %
23 %                                                                             %
24 %                                                                             %
25 %  Copyright 1999-2016 ImageMagick Studio LLC, a non-profit organization      %
26 %  dedicated to making software imaging solutions freely available.           %
27 %                                                                             %
28 %  You may not use this file except in compliance with the License.  You may  %
29 %  obtain a copy of the License at                                            %
30 %                                                                             %
31 %    http://www.imagemagick.org/script/license.php                            %
32 %                                                                             %
33 %  Unless required by applicable law or agreed to in writing, software        %
34 %  distributed under the License is distributed on an "AS IS" BASIS,          %
35 %  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.   %
36 %  See the License for the specific language governing permissions and        %
37 %  limitations under the License.                                             %
38 %                                                                             %
39 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
40 %
41 %
42 %
43 */
44 
45 /*
46   Include declarations.
47 */
48 #include "MagickWand/studio.h"
49 #include "MagickWand/MagickWand.h"
50 #include "MagickWand/magick-wand-private.h"
51 #include "MagickWand/wand.h"
52 #include "MagickCore/monitor-private.h"
53 #include "MagickCore/thread-private.h"
54 /*
55  Define declarations.
56 */
57 #define WandViewId  "WandView"
58 
59 /*
60   Typedef declarations.
61 */
62 struct _WandView
63 {
64   size_t
65     id;
66 
67   char
68     name[MagickPathExtent],
69     *description;
70 
71   RectangleInfo
72     extent;
73 
74   MagickWand
75     *wand;
76 
77   Image
78     *image;
79 
80   CacheView
81     *view;
82 
83   PixelWand
84     ***pixel_wands;
85 
86   ExceptionInfo
87     *exception;
88 
89   MagickBooleanType
90     debug;
91 
92   size_t
93     signature;
94 };
95 
96 /*
97 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
98 %                                                                             %
99 %                                                                             %
100 %                                                                             %
101 %   C l o n e W a n d V i e w                                                 %
102 %                                                                             %
103 %                                                                             %
104 %                                                                             %
105 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
106 %
107 %  CloneWandView() makes a copy of the specified wand view.
108 %
109 %  The format of the CloneWandView method is:
110 %
111 %      WandView *CloneWandView(const WandView *wand_view)
112 %
113 %  A description of each parameter follows:
114 %
115 %    o wand_view: the wand view.
116 %
117 */
CloneWandView(const WandView * wand_view)118 WandExport WandView *CloneWandView(const WandView *wand_view)
119 {
120   WandView
121     *clone_view;
122 
123   register ssize_t
124     i;
125 
126   assert(wand_view != (WandView *) NULL);
127   assert(wand_view->signature == MagickWandSignature);
128   if (wand_view->debug != MagickFalse)
129     (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand_view->name);
130   clone_view=(WandView *) AcquireMagickMemory(sizeof(*clone_view));
131   if (clone_view == (WandView *) NULL)
132     ThrowWandFatalException(ResourceLimitFatalError,"MemoryAllocationFailed",
133       wand_view->name);
134   (void) ResetMagickMemory(clone_view,0,sizeof(*clone_view));
135   clone_view->id=AcquireWandId();
136   (void) FormatLocaleString(clone_view->name,MagickPathExtent,"%s-%.20g",
137     WandViewId,(double) clone_view->id);
138   clone_view->description=ConstantString(wand_view->description);
139   clone_view->image=CloneImage(wand_view->image,0,0,MagickTrue,
140     wand_view->exception);
141   clone_view->view=CloneCacheView(wand_view->view);
142   clone_view->extent=wand_view->extent;
143   clone_view->exception=AcquireExceptionInfo();
144   InheritException(clone_view->exception,wand_view->exception);
145   for (i=0; i < (ssize_t) GetMagickResourceLimit(ThreadResource); i++)
146     clone_view->pixel_wands[i]=ClonePixelWands((const PixelWand **)
147       wand_view->pixel_wands[i],wand_view->extent.width);
148   clone_view->debug=wand_view->debug;
149   if (clone_view->debug != MagickFalse)
150     (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",clone_view->name);
151   clone_view->signature=MagickWandSignature;
152   return(clone_view);
153 }
154 
155 /*
156 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
157 %                                                                             %
158 %                                                                             %
159 %                                                                             %
160 %   D e s t r o y W a n d V i e w                                             %
161 %                                                                             %
162 %                                                                             %
163 %                                                                             %
164 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
165 %
166 %  DestroyWandView() deallocates memory associated with a wand view.
167 %
168 %  The format of the DestroyWandView method is:
169 %
170 %      WandView *DestroyWandView(WandView *wand_view)
171 %
172 %  A description of each parameter follows:
173 %
174 %    o wand_view: the wand view.
175 %
176 */
177 
DestroyPixelsThreadSet(PixelWand *** pixel_wands,const size_t number_wands)178 static PixelWand ***DestroyPixelsThreadSet(PixelWand ***pixel_wands,
179   const size_t number_wands)
180 {
181   register ssize_t
182     i;
183 
184   assert(pixel_wands != (PixelWand ***) NULL);
185   for (i=0; i < (ssize_t) GetMagickResourceLimit(ThreadResource); i++)
186     if (pixel_wands[i] != (PixelWand **) NULL)
187       pixel_wands[i]=DestroyPixelWands(pixel_wands[i],number_wands);
188   pixel_wands=(PixelWand ***) RelinquishMagickMemory(pixel_wands);
189   return(pixel_wands);
190 }
191 
DestroyWandView(WandView * wand_view)192 WandExport WandView *DestroyWandView(WandView *wand_view)
193 {
194   assert(wand_view != (WandView *) NULL);
195   assert(wand_view->signature == MagickWandSignature);
196   wand_view->pixel_wands=DestroyPixelsThreadSet(wand_view->pixel_wands,
197     wand_view->extent.width);
198   wand_view->image=DestroyImage(wand_view->image);
199   wand_view->view=DestroyCacheView(wand_view->view);
200   wand_view->exception=DestroyExceptionInfo(wand_view->exception);
201   wand_view->signature=(~MagickWandSignature);
202   RelinquishWandId(wand_view->id);
203   wand_view=(WandView *) RelinquishMagickMemory(wand_view);
204   return(wand_view);
205 }
206 
207 /*
208 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
209 %                                                                             %
210 %                                                                             %
211 %                                                                             %
212 %   D u p l e x T r a n s f e r W a n d V i e w I t e r a t o r               %
213 %                                                                             %
214 %                                                                             %
215 %                                                                             %
216 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
217 %
218 %  DuplexTransferWandViewIterator() iterates over three wand views in
219 %  parallel and calls your transfer method for each scanline of the view.  The
220 %  source and duplex pixel extent is not confined to the image canvas-- that is
221 %  you can include negative offsets or widths or heights that exceed the image
222 %  dimension.  However, the destination wand view is confined to the image
223 %  canvas-- that is no negative offsets or widths or heights that exceed the
224 %  image dimension are permitted.
225 %
226 %  The callback signature is:
227 %
228 %      MagickBooleanType DuplexTransferImageViewMethod(const WandView *source,
229 %        const WandView *duplex,WandView *destination,const ssize_t y,
230 %        const int thread_id,void *context)
231 %
232 %  Use this pragma if the view is not single threaded:
233 %
234 %    #pragma omp critical
235 %
236 %  to define a section of code in your callback transfer method that must be
237 %  executed by a single thread at a time.
238 %
239 %  The format of the DuplexTransferWandViewIterator method is:
240 %
241 %      MagickBooleanType DuplexTransferWandViewIterator(WandView *source,
242 %        WandView *duplex,WandView *destination,
243 %        DuplexTransferWandViewMethod transfer,void *context)
244 %
245 %  A description of each parameter follows:
246 %
247 %    o source: the source wand view.
248 %
249 %    o duplex: the duplex wand view.
250 %
251 %    o destination: the destination wand view.
252 %
253 %    o transfer: the transfer callback method.
254 %
255 %    o context: the user defined context.
256 %
257 */
DuplexTransferWandViewIterator(WandView * source,WandView * duplex,WandView * destination,DuplexTransferWandViewMethod transfer,void * context)258 WandExport MagickBooleanType DuplexTransferWandViewIterator(WandView *source,
259   WandView *duplex,WandView *destination,DuplexTransferWandViewMethod transfer,
260   void *context)
261 {
262   Image
263     *destination_image,
264     *source_image;
265 
266   MagickBooleanType
267     status;
268 
269   MagickOffsetType
270     progress;
271 
272 #if defined(MAGICKCORE_OPENMP_SUPPORT)
273   size_t
274     height;
275 #endif
276 
277   ssize_t
278     y;
279 
280   assert(source != (WandView *) NULL);
281   assert(source->signature == MagickWandSignature);
282   if (transfer == (DuplexTransferWandViewMethod) NULL)
283     return(MagickFalse);
284   source_image=source->wand->images;
285   destination_image=destination->wand->images;
286   status=SetImageStorageClass(destination_image,DirectClass,
287     destination->exception);
288   if (status == MagickFalse)
289     return(MagickFalse);
290   status=MagickTrue;
291   progress=0;
292 #if defined(MAGICKCORE_OPENMP_SUPPORT)
293   height=source->extent.height-source->extent.y;
294   #pragma omp parallel for schedule(static,4) shared(progress,status) \
295     magick_threads(source_image,destination_image,height,1)
296 #endif
297   for (y=source->extent.y; y < (ssize_t) source->extent.height; y++)
298   {
299     const int
300       id = GetOpenMPThreadId();
301 
302     MagickBooleanType
303       sync;
304 
305     register const Quantum
306       *magick_restrict duplex_pixels,
307       *magick_restrict pixels;
308 
309     register ssize_t
310       x;
311 
312     register Quantum
313       *magick_restrict destination_pixels;
314 
315     if (status == MagickFalse)
316       continue;
317     pixels=GetCacheViewVirtualPixels(source->view,source->extent.x,y,
318       source->extent.width,1,source->exception);
319     if (pixels == (const Quantum *) NULL)
320       {
321         status=MagickFalse;
322         continue;
323       }
324     for (x=0; x < (ssize_t) source->extent.width; x++)
325     {
326       PixelSetQuantumPixel(source->image,pixels,source->pixel_wands[id][x]);
327       pixels+=GetPixelChannels(source->image);
328     }
329     duplex_pixels=GetCacheViewVirtualPixels(duplex->view,duplex->extent.x,y,
330       duplex->extent.width,1,duplex->exception);
331     if (duplex_pixels == (const Quantum *) NULL)
332       {
333         status=MagickFalse;
334         continue;
335       }
336     for (x=0; x < (ssize_t) duplex->extent.width; x++)
337     {
338       PixelSetQuantumPixel(duplex->image,duplex_pixels,
339         duplex->pixel_wands[id][x]);
340       duplex_pixels+=GetPixelChannels(duplex->image);
341     }
342     destination_pixels=GetCacheViewAuthenticPixels(destination->view,
343       destination->extent.x,y,destination->extent.width,1,
344       destination->exception);
345     if (destination_pixels == (Quantum *) NULL)
346       {
347         status=MagickFalse;
348         continue;
349       }
350     for (x=0; x < (ssize_t) destination->extent.width; x++)
351     {
352       PixelSetQuantumPixel(destination->image,destination_pixels,
353         destination->pixel_wands[id][x]);
354       destination_pixels+=GetPixelChannels(destination->image);
355     }
356     if (transfer(source,duplex,destination,y,id,context) == MagickFalse)
357       status=MagickFalse;
358     destination_pixels=GetCacheViewAuthenticPixels(destination->view,
359       destination->extent.x,y,destination->extent.width,1,
360       destination->exception);
361     for (x=0; x < (ssize_t) destination->extent.width; x++)
362     {
363       PixelGetQuantumPixel(destination->image,destination->pixel_wands[id][x],
364         destination_pixels);
365       destination_pixels+=GetPixelChannels(destination->image);
366     }
367     sync=SyncCacheViewAuthenticPixels(destination->view,destination->exception);
368     if (sync == MagickFalse)
369       status=MagickFalse;
370     if (source_image->progress_monitor != (MagickProgressMonitor) NULL)
371       {
372         MagickBooleanType
373           proceed;
374 
375 #if defined(MAGICKCORE_OPENMP_SUPPORT)
376         #pragma omp critical (MagickWand_DuplexTransferWandViewIterator)
377 #endif
378         proceed=SetImageProgress(source_image,source->description,progress++,
379           source->extent.height);
380         if (proceed == MagickFalse)
381           status=MagickFalse;
382       }
383   }
384   return(status);
385 }
386 
387 /*
388 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
389 %                                                                             %
390 %                                                                             %
391 %                                                                             %
392 %   G e t W a n d V i e w E x c e p t i o n                                   %
393 %                                                                             %
394 %                                                                             %
395 %                                                                             %
396 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
397 %
398 %  GetWandViewException() returns the severity, reason, and description of any
399 %  error that occurs when utilizing a wand view.
400 %
401 %  The format of the GetWandViewException method is:
402 %
403 %      char *GetWandViewException(const WandView *wand_view,
404 %        ExceptionType *severity)
405 %
406 %  A description of each parameter follows:
407 %
408 %    o wand_view: the pixel wand_view.
409 %
410 %    o severity: the severity of the error is returned here.
411 %
412 */
GetWandViewException(const WandView * wand_view,ExceptionType * severity)413 WandExport char *GetWandViewException(const WandView *wand_view,
414   ExceptionType *severity)
415 {
416   char
417     *description;
418 
419   assert(wand_view != (const WandView *) NULL);
420   assert(wand_view->signature == MagickWandSignature);
421   if (wand_view->debug != MagickFalse)
422     (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand_view->name);
423   assert(severity != (ExceptionType *) NULL);
424   *severity=wand_view->exception->severity;
425   description=(char *) AcquireQuantumMemory(2UL*MagickPathExtent,
426     sizeof(*description));
427   if (description == (char *) NULL)
428     ThrowWandFatalException(ResourceLimitFatalError,"MemoryAllocationFailed",
429       wand_view->name);
430   *description='\0';
431   if (wand_view->exception->reason != (char *) NULL)
432     (void) CopyMagickString(description,GetLocaleExceptionMessage(
433       wand_view->exception->severity,wand_view->exception->reason),
434         MagickPathExtent);
435   if (wand_view->exception->description != (char *) NULL)
436     {
437       (void) ConcatenateMagickString(description," (",MagickPathExtent);
438       (void) ConcatenateMagickString(description,GetLocaleExceptionMessage(
439         wand_view->exception->severity,wand_view->exception->description),
440         MagickPathExtent);
441       (void) ConcatenateMagickString(description,")",MagickPathExtent);
442     }
443   return(description);
444 }
445 
446 /*
447 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
448 %                                                                             %
449 %                                                                             %
450 %                                                                             %
451 %   G e t W a n d V i e w E x t e n t                                         %
452 %                                                                             %
453 %                                                                             %
454 %                                                                             %
455 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
456 %
457 %  GetWandViewExtent() returns the wand view extent.
458 %
459 %  The format of the GetWandViewExtent method is:
460 %
461 %      RectangleInfo GetWandViewExtent(const WandView *wand_view)
462 %
463 %  A description of each parameter follows:
464 %
465 %    o wand_view: the wand view.
466 %
467 */
GetWandViewExtent(const WandView * wand_view)468 WandExport RectangleInfo GetWandViewExtent(const WandView *wand_view)
469 {
470   assert(wand_view != (WandView *) NULL);
471   assert(wand_view->signature == MagickWandSignature);
472   return(wand_view->extent);
473 }
474 
475 /*
476 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
477 %                                                                             %
478 %                                                                             %
479 %                                                                             %
480 %   G e t W a n d V i e w I t e r a t o r                                     %
481 %                                                                             %
482 %                                                                             %
483 %                                                                             %
484 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
485 %
486 %  GetWandViewIterator() iterates over the wand view in parallel and calls
487 %  your get method for each scanline of the view.  The pixel extent is
488 %  not confined to the image canvas-- that is you can include negative offsets
489 %  or widths or heights that exceed the image dimension.  Any updates to
490 %  the pixels in your callback are ignored.
491 %
492 %  The callback signature is:
493 %
494 %      MagickBooleanType GetImageViewMethod(const WandView *source,
495 %        const ssize_t y,const int thread_id,void *context)
496 %
497 %  Use this pragma if the view is not single threaded:
498 %
499 %    #pragma omp critical
500 %
501 %  to define a section of code in your callback get method that must be
502 %  executed by a single thread at a time.
503 %
504 %  The format of the GetWandViewIterator method is:
505 %
506 %      MagickBooleanType GetWandViewIterator(WandView *source,
507 %        GetWandViewMethod get,void *context)
508 %
509 %  A description of each parameter follows:
510 %
511 %    o source: the source wand view.
512 %
513 %    o get: the get callback method.
514 %
515 %    o context: the user defined context.
516 %
517 */
GetWandViewIterator(WandView * source,GetWandViewMethod get,void * context)518 WandExport MagickBooleanType GetWandViewIterator(WandView *source,
519   GetWandViewMethod get,void *context)
520 {
521   Image
522     *source_image;
523 
524   MagickBooleanType
525     status;
526 
527   MagickOffsetType
528     progress;
529 
530 #if defined(MAGICKCORE_OPENMP_SUPPORT)
531   size_t
532     height;
533 #endif
534 
535   ssize_t
536     y;
537 
538   assert(source != (WandView *) NULL);
539   assert(source->signature == MagickWandSignature);
540   if (get == (GetWandViewMethod) NULL)
541     return(MagickFalse);
542   source_image=source->wand->images;
543   status=MagickTrue;
544   progress=0;
545 #if defined(MAGICKCORE_OPENMP_SUPPORT)
546   height=source->extent.height-source->extent.y;
547   #pragma omp parallel for schedule(static,4) shared(progress,status) \
548     magick_threads(source_image,source_image,height,1)
549 #endif
550   for (y=source->extent.y; y < (ssize_t) source->extent.height; y++)
551   {
552     const int
553       id = GetOpenMPThreadId();
554 
555     register const Quantum
556       *pixels;
557 
558     register ssize_t
559       x;
560 
561     if (status == MagickFalse)
562       continue;
563     pixels=GetCacheViewVirtualPixels(source->view,source->extent.x,y,
564       source->extent.width,1,source->exception);
565     if (pixels == (const Quantum *) NULL)
566       {
567         status=MagickFalse;
568         continue;
569       }
570     for (x=0; x < (ssize_t) source->extent.width; x++)
571     {
572       PixelSetQuantumPixel(source->image,pixels,source->pixel_wands[id][x]);
573       pixels+=GetPixelChannels(source->image);
574     }
575     if (get(source,y,id,context) == MagickFalse)
576       status=MagickFalse;
577     if (source_image->progress_monitor != (MagickProgressMonitor) NULL)
578       {
579         MagickBooleanType
580           proceed;
581 
582 #if defined(MAGICKCORE_OPENMP_SUPPORT)
583         #pragma omp critical (MagickWand_GetWandViewIterator)
584 #endif
585         proceed=SetImageProgress(source_image,source->description,progress++,
586           source->extent.height);
587         if (proceed == MagickFalse)
588           status=MagickFalse;
589       }
590   }
591   return(status);
592 }
593 
594 /*
595 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
596 %                                                                             %
597 %                                                                             %
598 %                                                                             %
599 %   G e t W a n d V i e w P i x e l s                                         %
600 %                                                                             %
601 %                                                                             %
602 %                                                                             %
603 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
604 %
605 %  GetWandViewPixels() returns the wand view pixel_wands.
606 %
607 %  The format of the GetWandViewPixels method is:
608 %
609 %      PixelWand *GetWandViewPixels(const WandView *wand_view)
610 %
611 %  A description of each parameter follows:
612 %
613 %    o wand_view: the wand view.
614 %
615 */
GetWandViewPixels(const WandView * wand_view)616 WandExport PixelWand **GetWandViewPixels(const WandView *wand_view)
617 {
618   const int
619     id = GetOpenMPThreadId();
620 
621   assert(wand_view != (WandView *) NULL);
622   assert(wand_view->signature == MagickWandSignature);
623   return(wand_view->pixel_wands[id]);
624 }
625 
626 /*
627 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
628 %                                                                             %
629 %                                                                             %
630 %                                                                             %
631 %   G e t W a n d V i e w W a n d                                             %
632 %                                                                             %
633 %                                                                             %
634 %                                                                             %
635 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
636 %
637 %  GetWandViewWand() returns the magick wand associated with the wand view.
638 %
639 %  The format of the GetWandViewWand method is:
640 %
641 %      MagickWand *GetWandViewWand(const WandView *wand_view)
642 %
643 %  A description of each parameter follows:
644 %
645 %    o wand_view: the wand view.
646 %
647 */
GetWandViewWand(const WandView * wand_view)648 WandExport MagickWand *GetWandViewWand(const WandView *wand_view)
649 {
650   assert(wand_view != (WandView *) NULL);
651   assert(wand_view->signature == MagickWandSignature);
652   return(wand_view->wand);
653 }
654 
655 /*
656 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
657 %                                                                             %
658 %                                                                             %
659 %                                                                             %
660 %   I s W a n d V i e w                                                       %
661 %                                                                             %
662 %                                                                             %
663 %                                                                             %
664 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
665 %
666 %  IsWandView() returns MagickTrue if the the parameter is verified as a wand
667 %  view object.
668 %
669 %  The format of the IsWandView method is:
670 %
671 %      MagickBooleanType IsWandView(const WandView *wand_view)
672 %
673 %  A description of each parameter follows:
674 %
675 %    o wand_view: the wand view.
676 %
677 */
IsWandView(const WandView * wand_view)678 WandExport MagickBooleanType IsWandView(const WandView *wand_view)
679 {
680   size_t
681     length;
682 
683   if (wand_view == (const WandView *) NULL)
684     return(MagickFalse);
685   if (wand_view->signature != MagickWandSignature)
686     return(MagickFalse);
687   length=strlen(WandViewId);
688   if (LocaleNCompare(wand_view->name,WandViewId,length) != 0)
689     return(MagickFalse);
690   return(MagickTrue);
691 }
692 
693 /*
694 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
695 %                                                                             %
696 %                                                                             %
697 %                                                                             %
698 %   N e w W a n d V i e w                                                     %
699 %                                                                             %
700 %                                                                             %
701 %                                                                             %
702 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
703 %
704 %  NewWandView() returns a wand view required for all other methods in the
705 %  Wand View API.
706 %
707 %  The format of the NewWandView method is:
708 %
709 %      WandView *NewWandView(MagickWand *wand)
710 %
711 %  A description of each parameter follows:
712 %
713 %    o wand: the wand.
714 %
715 */
716 
AcquirePixelsThreadSet(const size_t number_wands)717 static PixelWand ***AcquirePixelsThreadSet(const size_t number_wands)
718 {
719   PixelWand
720     ***pixel_wands;
721 
722   register ssize_t
723     i;
724 
725   size_t
726     number_threads;
727 
728   number_threads=GetOpenMPMaximumThreads();
729   pixel_wands=(PixelWand ***) AcquireQuantumMemory(number_threads,
730     sizeof(*pixel_wands));
731   if (pixel_wands == (PixelWand ***) NULL)
732     return((PixelWand ***) NULL);
733   (void) ResetMagickMemory(pixel_wands,0,number_threads*sizeof(*pixel_wands));
734   for (i=0; i < (ssize_t) number_threads; i++)
735   {
736     pixel_wands[i]=NewPixelWands(number_wands);
737     if (pixel_wands[i] == (PixelWand **) NULL)
738       return(DestroyPixelsThreadSet(pixel_wands,number_wands));
739   }
740   return(pixel_wands);
741 }
742 
NewWandView(MagickWand * wand)743 WandExport WandView *NewWandView(MagickWand *wand)
744 {
745   ExceptionInfo
746     *exception;
747 
748   WandView
749     *wand_view;
750 
751   assert(wand != (MagickWand *) NULL);
752   assert(wand->signature == MagickWandSignature);
753   wand_view=(WandView *) AcquireMagickMemory(sizeof(*wand_view));
754   if (wand_view == (WandView *) NULL)
755     ThrowWandFatalException(ResourceLimitFatalError,"MemoryAllocationFailed",
756       GetExceptionMessage(errno));
757   (void) ResetMagickMemory(wand_view,0,sizeof(*wand_view));
758   wand_view->id=AcquireWandId();
759   (void) FormatLocaleString(wand_view->name,MagickPathExtent,"%s-%.20g",
760     WandViewId,(double) wand_view->id);
761   wand_view->description=ConstantString("WandView");
762   wand_view->wand=wand;
763   exception=AcquireExceptionInfo();
764   wand_view->view=AcquireVirtualCacheView(wand_view->wand->images,exception);
765   wand_view->extent.width=wand->images->columns;
766   wand_view->extent.height=wand->images->rows;
767   wand_view->pixel_wands=AcquirePixelsThreadSet(wand_view->extent.width);
768   wand_view->exception=exception;
769   if (wand_view->pixel_wands == (PixelWand ***) NULL)
770     ThrowWandFatalException(ResourceLimitFatalError,"MemoryAllocationFailed",
771       GetExceptionMessage(errno));
772   wand_view->debug=IsEventLogging();
773   wand_view->signature=MagickWandSignature;
774   return(wand_view);
775 }
776 
777 /*
778 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
779 %                                                                             %
780 %                                                                             %
781 %                                                                             %
782 %   N e w W a n d V i e w E x t e n t                                         %
783 %                                                                             %
784 %                                                                             %
785 %                                                                             %
786 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
787 %
788 %  NewWandViewExtent() returns a wand view required for all other methods
789 %  in the Wand View API.
790 %
791 %  The format of the NewWandViewExtent method is:
792 %
793 %      WandView *NewWandViewExtent(MagickWand *wand,const ssize_t x,
794 %        const ssize_t y,const size_t width,const size_t height)
795 %
796 %  A description of each parameter follows:
797 %
798 %    o wand: the magick wand.
799 %
800 %    o x,y,columns,rows:  These values define the perimeter of a extent of
801 %      pixel_wands view.
802 %
803 */
NewWandViewExtent(MagickWand * wand,const ssize_t x,const ssize_t y,const size_t width,const size_t height)804 WandExport WandView *NewWandViewExtent(MagickWand *wand,const ssize_t x,
805   const ssize_t y,const size_t width,const size_t height)
806 {
807   ExceptionInfo
808     *exception;
809 
810   WandView
811     *wand_view;
812 
813   assert(wand != (MagickWand *) NULL);
814   assert(wand->signature == MagickWandSignature);
815   wand_view=(WandView *) AcquireMagickMemory(sizeof(*wand_view));
816   if (wand_view == (WandView *) NULL)
817     ThrowWandFatalException(ResourceLimitFatalError,"MemoryAllocationFailed",
818       GetExceptionMessage(errno));
819   (void) ResetMagickMemory(wand_view,0,sizeof(*wand_view));
820   wand_view->id=AcquireWandId();
821   (void) FormatLocaleString(wand_view->name,MagickPathExtent,"%s-%.20g",
822     WandViewId,(double) wand_view->id);
823   wand_view->description=ConstantString("WandView");
824   exception=AcquireExceptionInfo();
825   wand_view->view=AcquireVirtualCacheView(wand_view->wand->images,exception);
826   wand_view->wand=wand;
827   wand_view->extent.width=width;
828   wand_view->extent.height=height;
829   wand_view->extent.x=x;
830   wand_view->extent.y=y;
831   wand_view->exception=exception;
832   wand_view->pixel_wands=AcquirePixelsThreadSet(wand_view->extent.width);
833   if (wand_view->pixel_wands == (PixelWand ***) NULL)
834     ThrowWandFatalException(ResourceLimitFatalError,"MemoryAllocationFailed",
835       GetExceptionMessage(errno));
836   wand_view->debug=IsEventLogging();
837   wand_view->signature=MagickWandSignature;
838   return(wand_view);
839 }
840 
841 /*
842 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
843 %                                                                             %
844 %                                                                             %
845 %                                                                             %
846 %   S e t W a n d V i e w D e s c r i p t i o n                               %
847 %                                                                             %
848 %                                                                             %
849 %                                                                             %
850 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
851 %
852 %  SetWandViewDescription() associates a description with an image view.
853 %
854 %  The format of the SetWandViewDescription method is:
855 %
856 %      void SetWandViewDescription(WandView *image_view,const char *description)
857 %
858 %  A description of each parameter follows:
859 %
860 %    o wand_view: the wand view.
861 %
862 %    o description: the wand view description.
863 %
864 */
SetWandViewDescription(WandView * wand_view,const char * description)865 MagickExport void SetWandViewDescription(WandView *wand_view,
866   const char *description)
867 {
868   assert(wand_view != (WandView *) NULL);
869   assert(wand_view->signature == MagickWandSignature);
870   wand_view->description=ConstantString(description);
871 }
872 
873 /*
874 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
875 %                                                                             %
876 %                                                                             %
877 %                                                                             %
878 %   S e t W a n d V i e w I t e r a t o r                                     %
879 %                                                                             %
880 %                                                                             %
881 %                                                                             %
882 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
883 %
884 %  SetWandViewIterator() iterates over the wand view in parallel and calls
885 %  your set method for each scanline of the view.  The pixel extent is
886 %  confined to the image canvas-- that is no negative offsets or widths or
887 %  heights that exceed the image dimension.  The pixels are initiallly
888 %  undefined and any settings you make in the callback method are automagically
889 %  synced back to your image.
890 %
891 %  The callback signature is:
892 %
893 %      MagickBooleanType SetImageViewMethod(ImageView *destination,
894 %        const ssize_t y,const int thread_id,void *context)
895 %
896 %  Use this pragma if the view is not single threaded:
897 %
898 %    #pragma omp critical
899 %
900 %  to define a section of code in your callback set method that must be
901 %  executed by a single thread at a time.
902 %
903 %  The format of the SetWandViewIterator method is:
904 %
905 %      MagickBooleanType SetWandViewIterator(WandView *destination,
906 %        SetWandViewMethod set,void *context)
907 %
908 %  A description of each parameter follows:
909 %
910 %    o destination: the wand view.
911 %
912 %    o set: the set callback method.
913 %
914 %    o context: the user defined context.
915 %
916 */
SetWandViewIterator(WandView * destination,SetWandViewMethod set,void * context)917 WandExport MagickBooleanType SetWandViewIterator(WandView *destination,
918   SetWandViewMethod set,void *context)
919 {
920   Image
921     *destination_image;
922 
923   MagickBooleanType
924     status;
925 
926   MagickOffsetType
927     progress;
928 
929 #if defined(MAGICKCORE_OPENMP_SUPPORT)
930   size_t
931     height;
932 #endif
933 
934   ssize_t
935     y;
936 
937   assert(destination != (WandView *) NULL);
938   assert(destination->signature == MagickWandSignature);
939   if (set == (SetWandViewMethod) NULL)
940     return(MagickFalse);
941   destination_image=destination->wand->images;
942   status=SetImageStorageClass(destination_image,DirectClass,
943     destination->exception);
944   if (status == MagickFalse)
945     return(MagickFalse);
946   status=MagickTrue;
947   progress=0;
948 #if defined(MAGICKCORE_OPENMP_SUPPORT)
949   height=destination->extent.height-destination->extent.y;
950   #pragma omp parallel for schedule(static,4) shared(progress,status) \
951     magick_threads(destination_image,destination_image,height,1)
952 #endif
953   for (y=destination->extent.y; y < (ssize_t) destination->extent.height; y++)
954   {
955     const int
956       id = GetOpenMPThreadId();
957 
958     MagickBooleanType
959       sync;
960 
961     register ssize_t
962       x;
963 
964     register Quantum
965       *magick_restrict pixels;
966 
967     if (status == MagickFalse)
968       continue;
969     pixels=GetCacheViewAuthenticPixels(destination->view,destination->extent.x,
970       y,destination->extent.width,1,destination->exception);
971     if (pixels == (Quantum *) NULL)
972       {
973         status=MagickFalse;
974         continue;
975       }
976     if (set(destination,y,id,context) == MagickFalse)
977       status=MagickFalse;
978     for (x=0; x < (ssize_t) destination->extent.width; x++)
979     {
980       PixelGetQuantumPixel(destination->image,destination->pixel_wands[id][x],
981         pixels);
982       pixels+=GetPixelChannels(destination->image);
983     }
984     sync=SyncCacheViewAuthenticPixels(destination->view,destination->exception);
985     if (sync == MagickFalse)
986       status=MagickFalse;
987     if (destination_image->progress_monitor != (MagickProgressMonitor) NULL)
988       {
989         MagickBooleanType
990           proceed;
991 
992 #if defined(MAGICKCORE_OPENMP_SUPPORT)
993         #pragma omp critical (MagickWand_SetWandViewIterator)
994 #endif
995         proceed=SetImageProgress(destination_image,destination->description,
996           progress++,destination->extent.height);
997         if (proceed == MagickFalse)
998           status=MagickFalse;
999       }
1000   }
1001   return(status);
1002 }
1003 
1004 /*
1005 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1006 %                                                                             %
1007 %                                                                             %
1008 %                                                                             %
1009 %   T r a n s f e r W a n d V i e w I t e r a t o r                           %
1010 %                                                                             %
1011 %                                                                             %
1012 %                                                                             %
1013 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1014 %
1015 %  TransferWandViewIterator() iterates over two wand views in parallel and
1016 %  calls your transfer method for each scanline of the view.  The source pixel
1017 %  extent is not confined to the image canvas-- that is you can include
1018 %  negative offsets or widths or heights that exceed the image dimension.
1019 %  However, the destination wand view is confined to the image canvas-- that
1020 %  is no negative offsets or widths or heights that exceed the image dimension
1021 %  are permitted.
1022 %
1023 %  The callback signature is:
1024 %
1025 %      MagickBooleanType TransferImageViewMethod(const WandView *source,
1026 %        WandView *destination,const ssize_t y,const int thread_id,
1027 %        void *context)
1028 %
1029 %  Use this pragma if the view is not single threaded:
1030 %
1031 %    #pragma omp critical
1032 %
1033 %  to define a section of code in your callback transfer method that must be
1034 %  executed by a single thread at a time.
1035 %
1036 %  The format of the TransferWandViewIterator method is:
1037 %
1038 %      MagickBooleanType TransferWandViewIterator(WandView *source,
1039 %        WandView *destination,TransferWandViewMethod transfer,void *context)
1040 %
1041 %  A description of each parameter follows:
1042 %
1043 %    o source: the source wand view.
1044 %
1045 %    o destination: the destination wand view.
1046 %
1047 %    o transfer: the transfer callback method.
1048 %
1049 %    o context: the user defined context.
1050 %
1051 */
TransferWandViewIterator(WandView * source,WandView * destination,TransferWandViewMethod transfer,void * context)1052 WandExport MagickBooleanType TransferWandViewIterator(WandView *source,
1053   WandView *destination,TransferWandViewMethod transfer,void *context)
1054 {
1055   Image
1056     *destination_image,
1057     *source_image;
1058 
1059   MagickBooleanType
1060     status;
1061 
1062   MagickOffsetType
1063     progress;
1064 
1065 #if defined(MAGICKCORE_OPENMP_SUPPORT)
1066   size_t
1067     height;
1068 #endif
1069 
1070   ssize_t
1071     y;
1072 
1073   assert(source != (WandView *) NULL);
1074   assert(source->signature == MagickWandSignature);
1075   if (transfer == (TransferWandViewMethod) NULL)
1076     return(MagickFalse);
1077   source_image=source->wand->images;
1078   destination_image=destination->wand->images;
1079   status=SetImageStorageClass(destination_image,DirectClass,
1080     destination->exception);
1081   if (status == MagickFalse)
1082     return(MagickFalse);
1083   status=MagickTrue;
1084   progress=0;
1085 #if defined(MAGICKCORE_OPENMP_SUPPORT)
1086   height=source->extent.height-source->extent.y;
1087   #pragma omp parallel for schedule(static,4) shared(progress,status) \
1088     magick_threads(source_image,destination_image,height,1)
1089 #endif
1090   for (y=source->extent.y; y < (ssize_t) source->extent.height; y++)
1091   {
1092     const int
1093       id = GetOpenMPThreadId();
1094 
1095     MagickBooleanType
1096       sync;
1097 
1098     register const Quantum
1099       *magick_restrict pixels;
1100 
1101     register ssize_t
1102       x;
1103 
1104     register Quantum
1105       *magick_restrict destination_pixels;
1106 
1107     if (status == MagickFalse)
1108       continue;
1109     pixels=GetCacheViewVirtualPixels(source->view,source->extent.x,y,
1110       source->extent.width,1,source->exception);
1111     if (pixels == (const Quantum *) NULL)
1112       {
1113         status=MagickFalse;
1114         continue;
1115       }
1116     for (x=0; x < (ssize_t) source->extent.width; x++)
1117     {
1118       PixelSetQuantumPixel(source->image,pixels,source->pixel_wands[id][x]);
1119       pixels+=GetPixelChannels(source->image);
1120     }
1121     destination_pixels=GetCacheViewAuthenticPixels(destination->view,
1122       destination->extent.x,y,destination->extent.width,1,
1123       destination->exception);
1124     if (destination_pixels == (Quantum *) NULL)
1125       {
1126         status=MagickFalse;
1127         continue;
1128       }
1129     for (x=0; x < (ssize_t) destination->extent.width; x++)
1130     {
1131       PixelSetQuantumPixel(destination->image,destination_pixels,
1132         destination->pixel_wands[id][x]);
1133       destination_pixels+=GetPixelChannels(destination->image);
1134     }
1135     if (transfer(source,destination,y,id,context) == MagickFalse)
1136       status=MagickFalse;
1137     destination_pixels=GetCacheViewAuthenticPixels(destination->view,
1138       destination->extent.x,y,destination->extent.width,1,
1139       destination->exception);
1140     for (x=0; x < (ssize_t) destination->extent.width; x++)
1141     {
1142       PixelGetQuantumPixel(destination->image,destination->pixel_wands[id][x],
1143         destination_pixels);
1144       destination_pixels+=GetPixelChannels(destination->image);
1145     }
1146     sync=SyncCacheViewAuthenticPixels(destination->view,destination->exception);
1147     if (sync == MagickFalse)
1148       status=MagickFalse;
1149     if (source_image->progress_monitor != (MagickProgressMonitor) NULL)
1150       {
1151         MagickBooleanType
1152           proceed;
1153 
1154 #if defined(MAGICKCORE_OPENMP_SUPPORT)
1155         #pragma omp critical (MagickWand_TransferWandViewIterator)
1156 #endif
1157         proceed=SetImageProgress(source_image,source->description,progress++,
1158           source->extent.height);
1159         if (proceed == MagickFalse)
1160           status=MagickFalse;
1161       }
1162   }
1163   return(status);
1164 }
1165 
1166 /*
1167 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1168 %                                                                             %
1169 %                                                                             %
1170 %                                                                             %
1171 %   U p d a t e W a n d V i e w I t e r a t o r                               %
1172 %                                                                             %
1173 %                                                                             %
1174 %                                                                             %
1175 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1176 %
1177 %  UpdateWandViewIterator() iterates over the wand view in parallel and calls
1178 %  your update method for each scanline of the view.  The pixel extent is
1179 %  confined to the image canvas-- that is no negative offsets or widths or
1180 %  heights that exceed the image dimension are permitted.  Updates to pixels
1181 %  in your callback are automagically synced back to the image.
1182 %
1183 %  The callback signature is:
1184 %
1185 %      MagickBooleanType UpdateImageViewMethod(WandView *source,const ssize_t y,
1186 %        const int thread_id,void *context)
1187 %
1188 %  Use this pragma if the view is not single threaded:
1189 %
1190 %    #pragma omp critical
1191 %
1192 %  to define a section of code in your callback update method that must be
1193 %  executed by a single thread at a time.
1194 %
1195 %  The format of the UpdateWandViewIterator method is:
1196 %
1197 %      MagickBooleanType UpdateWandViewIterator(WandView *source,
1198 %        UpdateWandViewMethod update,void *context)
1199 %
1200 %  A description of each parameter follows:
1201 %
1202 %    o source: the source wand view.
1203 %
1204 %    o update: the update callback method.
1205 %
1206 %    o context: the user defined context.
1207 %
1208 */
UpdateWandViewIterator(WandView * source,UpdateWandViewMethod update,void * context)1209 WandExport MagickBooleanType UpdateWandViewIterator(WandView *source,
1210   UpdateWandViewMethod update,void *context)
1211 {
1212   Image
1213     *source_image;
1214 
1215   MagickBooleanType
1216     status;
1217 
1218   MagickOffsetType
1219     progress;
1220 
1221 #if defined(MAGICKCORE_OPENMP_SUPPORT)
1222   size_t
1223     height;
1224 #endif
1225 
1226   ssize_t
1227     y;
1228 
1229   assert(source != (WandView *) NULL);
1230   assert(source->signature == MagickWandSignature);
1231   if (update == (UpdateWandViewMethod) NULL)
1232     return(MagickFalse);
1233   source_image=source->wand->images;
1234   status=SetImageStorageClass(source_image,DirectClass,source->exception);
1235   if (status == MagickFalse)
1236     return(MagickFalse);
1237   status=MagickTrue;
1238   progress=0;
1239 #if defined(MAGICKCORE_OPENMP_SUPPORT)
1240   height=source->extent.height-source->extent.y;
1241   #pragma omp parallel for schedule(static,4) shared(progress,status) \
1242     magick_threads(source_image,source_image,height,1)
1243 #endif
1244   for (y=source->extent.y; y < (ssize_t) source->extent.height; y++)
1245   {
1246     const int
1247       id = GetOpenMPThreadId();
1248 
1249     MagickBooleanType
1250       sync;
1251 
1252     register ssize_t
1253       x;
1254 
1255     register Quantum
1256       *magick_restrict pixels;
1257 
1258     if (status == MagickFalse)
1259       continue;
1260     pixels=GetCacheViewAuthenticPixels(source->view,source->extent.x,y,
1261       source->extent.width,1,source->exception);
1262     if (pixels == (Quantum *) NULL)
1263       {
1264         status=MagickFalse;
1265         continue;
1266       }
1267     for (x=0; x < (ssize_t) source->extent.width; x++)
1268     {
1269       PixelSetQuantumPixel(source->image,pixels,source->pixel_wands[id][x]);
1270       pixels+=GetPixelChannels(source->image);
1271     }
1272     if (update(source,y,id,context) == MagickFalse)
1273       status=MagickFalse;
1274     for (x=0; x < (ssize_t) source->extent.width; x++)
1275     {
1276       PixelGetQuantumPixel(source->image,source->pixel_wands[id][x],pixels);
1277       pixels+=GetPixelChannels(source->image);
1278     }
1279     sync=SyncCacheViewAuthenticPixels(source->view,source->exception);
1280     if (sync == MagickFalse)
1281       status=MagickFalse;
1282     if (source_image->progress_monitor != (MagickProgressMonitor) NULL)
1283       {
1284         MagickBooleanType
1285           proceed;
1286 
1287 #if defined(MAGICKCORE_OPENMP_SUPPORT)
1288         #pragma omp critical (MagickWand_UpdateWandViewIterator)
1289 #endif
1290         proceed=SetImageProgress(source_image,source->description,progress++,
1291           source->extent.height);
1292         if (proceed == MagickFalse)
1293           status=MagickFalse;
1294       }
1295   }
1296   return(status);
1297 }
1298