2 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
6 % RRRR EEEEE SSSSS AAA M M PPPP L EEEEE %
7 % R R E SS A A MM MM P P L E %
8 % RRRR EEE SSS AAAAA M M M PPPP L EEE %
9 % R R E SS A A M M P L E %
10 % R R EEEEE SSSSS A A M M P LLLLL EEEEE %
13 % MagickCore Pixel Resampling Methods %
21 % Copyright 1999-2012 ImageMagick Studio LLC, a non-profit organization %
22 % dedicated to making software imaging solutions freely available. %
24 % You may not use this file except in compliance with the License. You may %
25 % obtain a copy of the License at %
27 % http://www.imagemagick.org/script/license.php %
29 % Unless required by applicable law or agreed to in writing, software %
30 % distributed under the License is distributed on an "AS IS" BASIS, %
31 % WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. %
32 % See the License for the specific language governing permissions and %
33 % limitations under the License. %
35 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
43 #include "MagickCore/studio.h"
44 #include "MagickCore/artifact.h"
45 #include "MagickCore/color-private.h"
46 #include "MagickCore/cache.h"
47 #include "MagickCore/draw.h"
48 #include "MagickCore/exception-private.h"
49 #include "MagickCore/gem.h"
50 #include "MagickCore/image.h"
51 #include "MagickCore/image-private.h"
52 #include "MagickCore/log.h"
53 #include "MagickCore/magick.h"
54 #include "MagickCore/memory_.h"
55 #include "MagickCore/pixel.h"
56 #include "MagickCore/pixel-accessor.h"
57 #include "MagickCore/quantum.h"
58 #include "MagickCore/random_.h"
59 #include "MagickCore/resample.h"
60 #include "MagickCore/resize.h"
61 #include "MagickCore/resize-private.h"
62 #include "MagickCore/transform.h"
63 #include "MagickCore/signature-private.h"
64 #include "MagickCore/utility.h"
65 #include "MagickCore/utility-private.h"
67 EWA Resampling Options
70 /* select ONE resampling method */
71 #define EWA 1 /* Normal EWA handling - raw or clamped */
72 /* if 0 then use "High Quality EWA" */
73 #define EWA_CLAMP 1 /* EWA Clamping from Nicolas Robidoux */
75 #define FILTER_LUT 1 /* Use a LUT rather then direct filter calls */
77 /* output debugging information */
78 #define DEBUG_ELLIPSE 0 /* output ellipse info for debug */
79 #define DEBUG_HIT_MISS 0 /* output hit/miss pixels (as gnuplot commands) */
80 #define DEBUG_NO_PIXEL_HIT 0 /* Make pixels that fail to hit anything - RED */
83 #define WLUT_WIDTH 1024 /* size of the filter cache */
89 struct _ResampleFilter
103 /* Information about image being resampled */
107 PixelInterpolateMethod
116 /* processing settings needed */
125 /* current ellipitical area being resampled around center point */
128 Vlimit, Ulimit, Uwidth, slope;
131 /* LUT of weights for filtered average in elliptical area */
133 filter_lut[WLUT_WIDTH];
135 /* Use a Direct call to the filter functions */
143 /* the practical working support of the filter */
152 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
156 % A c q u i r e R e s a m p l e I n f o %
160 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
162 % AcquireResampleFilter() initializes the information resample needs do to a
163 % scaled lookup of a color from an image, using area sampling.
165 % The algorithm is based on a Elliptical Weighted Average, where the pixels
166 % found in a large elliptical area is averaged together according to a
167 % weighting (filter) function. For more details see "Fundamentals of Texture
168 % Mapping and Image Warping" a master's thesis by Paul.S.Heckbert, June 17,
169 % 1989. Available for free from, http://www.cs.cmu.edu/~ph/
171 % As EWA resampling (or any sort of resampling) can require a lot of
172 % calculations to produce a distorted scaling of the source image for each
173 % output pixel, the ResampleFilter structure generated holds that information
174 % between individual image resampling.
176 % This function will make the appropriate AcquireCacheView() calls
177 % to view the image, calling functions do not need to open a cache view.
180 % resample_filter=AcquireResampleFilter(image,exception);
181 % SetResampleFilter(resample_filter, GaussianFilter, 1.0);
182 % for (y=0; y < (ssize_t) image->rows; y++) {
183 % for (x=0; x < (ssize_t) image->columns; x++) {
185 % ScaleResampleFilter(resample_filter, ... scaling vectors ...);
186 % (void) ResamplePixelColor(resample_filter,u,v,&pixel);
187 % ... assign resampled pixel value ...
190 % DestroyResampleFilter(resample_filter);
192 % The format of the AcquireResampleFilter method is:
194 % ResampleFilter *AcquireResampleFilter(const Image *image,
195 % ExceptionInfo *exception)
197 % A description of each parameter follows:
199 % o image: the image.
201 % o exception: return any errors or warnings in this structure.
204 MagickExport ResampleFilter *AcquireResampleFilter(const Image *image,
205 ExceptionInfo *exception)
207 register ResampleFilter
210 assert(image != (Image *) NULL);
211 assert(image->signature == MagickSignature);
212 if (image->debug != MagickFalse)
213 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
214 assert(exception != (ExceptionInfo *) NULL);
215 assert(exception->signature == MagickSignature);
217 resample_filter=(ResampleFilter *) AcquireMagickMemory(
218 sizeof(*resample_filter));
219 if (resample_filter == (ResampleFilter *) NULL)
220 ThrowFatalException(ResourceLimitFatalError,"MemoryAllocationFailed");
221 (void) ResetMagickMemory(resample_filter,0,sizeof(*resample_filter));
223 resample_filter->exception=exception;
224 resample_filter->image=ReferenceImage((Image *) image);
225 resample_filter->view=AcquireCacheView(resample_filter->image);
227 resample_filter->debug=IsEventLogging();
228 resample_filter->signature=MagickSignature;
230 resample_filter->image_area=(ssize_t) (image->columns*image->rows);
231 resample_filter->average_defined = MagickFalse;
233 /* initialise the resampling filter settings */
234 SetResampleFilter(resample_filter, image->filter, image->blur);
235 (void) SetResampleFilterInterpolateMethod(resample_filter,
237 (void) SetResampleFilterVirtualPixelMethod(resample_filter,
238 GetImageVirtualPixelMethod(image));
240 return(resample_filter);
244 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
248 % D e s t r o y R e s a m p l e I n f o %
252 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
254 % DestroyResampleFilter() finalizes and cleans up the resampling
255 % resample_filter as returned by AcquireResampleFilter(), freeing any memory
256 % or other information as needed.
258 % The format of the DestroyResampleFilter method is:
260 % ResampleFilter *DestroyResampleFilter(ResampleFilter *resample_filter)
262 % A description of each parameter follows:
264 % o resample_filter: resampling information structure
267 MagickExport ResampleFilter *DestroyResampleFilter(
268 ResampleFilter *resample_filter)
270 assert(resample_filter != (ResampleFilter *) NULL);
271 assert(resample_filter->signature == MagickSignature);
272 assert(resample_filter->image != (Image *) NULL);
273 if (resample_filter->debug != MagickFalse)
274 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",
275 resample_filter->image->filename);
276 resample_filter->view=DestroyCacheView(resample_filter->view);
277 resample_filter->image=DestroyImage(resample_filter->image);
279 resample_filter->filter_def=DestroyResizeFilter(resample_filter->filter_def);
281 resample_filter->signature=(~MagickSignature);
282 resample_filter=(ResampleFilter *) RelinquishMagickMemory(resample_filter);
283 return(resample_filter);
287 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
291 % R e s a m p l e P i x e l C o l o r %
295 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
297 % ResamplePixelColor() samples the pixel values surrounding the location
298 % given using an elliptical weighted average, at the scale previously
299 % calculated, and in the most efficent manner possible for the
300 % VirtualPixelMethod setting.
302 % The format of the ResamplePixelColor method is:
304 % MagickBooleanType ResamplePixelColor(ResampleFilter *resample_filter,
305 % const double u0,const double v0,PixelInfo *pixel)
307 % A description of each parameter follows:
309 % o resample_filter: the resample filter.
311 % o u0,v0: A double representing the center of the area to resample,
312 % The distortion transformed transformed x,y coordinate.
314 % o pixel: the resampled pixel is returned here.
317 MagickExport MagickBooleanType ResamplePixelColor(
318 ResampleFilter *resample_filter,const double u0,const double v0,
324 ssize_t u,v, v1, v2, uw, hit;
327 double divisor_c,divisor_m;
328 register double weight;
329 register const Quantum *pixels;
330 assert(resample_filter != (ResampleFilter *) NULL);
331 assert(resample_filter->signature == MagickSignature);
334 /* GetPixelInfo(resample_filter->image,pixel); */
335 if ( resample_filter->do_interpolate ) {
336 status=InterpolatePixelInfo(resample_filter->image,resample_filter->view,
337 resample_filter->interpolate,u0,v0,pixel,resample_filter->exception);
342 (void) FormatLocaleFile(stderr, "u0=%lf; v0=%lf;\n", u0, v0);
346 Does resample area Miss the image?
347 And is that area a simple solid color - then return that color
350 switch ( resample_filter->virtual_pixel ) {
351 case BackgroundVirtualPixelMethod:
352 case TransparentVirtualPixelMethod:
353 case BlackVirtualPixelMethod:
354 case GrayVirtualPixelMethod:
355 case WhiteVirtualPixelMethod:
356 case MaskVirtualPixelMethod:
357 if ( resample_filter->limit_reached
358 || u0 + resample_filter->Ulimit < 0.0
359 || u0 - resample_filter->Ulimit > (double) resample_filter->image->columns
360 || v0 + resample_filter->Vlimit < 0.0
361 || v0 - resample_filter->Vlimit > (double) resample_filter->image->rows
366 case UndefinedVirtualPixelMethod:
367 case EdgeVirtualPixelMethod:
368 if ( ( u0 + resample_filter->Ulimit < 0.0 && v0 + resample_filter->Vlimit < 0.0 )
369 || ( u0 + resample_filter->Ulimit < 0.0
370 && v0 - resample_filter->Vlimit > (double) resample_filter->image->rows )
371 || ( u0 - resample_filter->Ulimit > (double) resample_filter->image->columns
372 && v0 + resample_filter->Vlimit < 0.0 )
373 || ( u0 - resample_filter->Ulimit > (double) resample_filter->image->columns
374 && v0 - resample_filter->Vlimit > (double) resample_filter->image->rows )
378 case HorizontalTileVirtualPixelMethod:
379 if ( v0 + resample_filter->Vlimit < 0.0
380 || v0 - resample_filter->Vlimit > (double) resample_filter->image->rows
382 hit++; /* outside the horizontally tiled images. */
384 case VerticalTileVirtualPixelMethod:
385 if ( u0 + resample_filter->Ulimit < 0.0
386 || u0 - resample_filter->Ulimit > (double) resample_filter->image->columns
388 hit++; /* outside the vertically tiled images. */
390 case DitherVirtualPixelMethod:
391 if ( ( u0 + resample_filter->Ulimit < -32.0 && v0 + resample_filter->Vlimit < -32.0 )
392 || ( u0 + resample_filter->Ulimit < -32.0
393 && v0 - resample_filter->Vlimit > (double) resample_filter->image->rows+32.0 )
394 || ( u0 - resample_filter->Ulimit > (double) resample_filter->image->columns+32.0
395 && v0 + resample_filter->Vlimit < -32.0 )
396 || ( u0 - resample_filter->Ulimit > (double) resample_filter->image->columns+32.0
397 && v0 - resample_filter->Vlimit > (double) resample_filter->image->rows+32.0 )
401 case TileVirtualPixelMethod:
402 case MirrorVirtualPixelMethod:
403 case RandomVirtualPixelMethod:
404 case HorizontalTileEdgeVirtualPixelMethod:
405 case VerticalTileEdgeVirtualPixelMethod:
406 case CheckerTileVirtualPixelMethod:
407 /* resampling of area is always needed - no VP limits */
411 /* whole area is a solid color -- just return that color */
412 status=InterpolatePixelInfo(resample_filter->image,
413 resample_filter->view,IntegerInterpolatePixel,u0,v0,pixel,
414 resample_filter->exception);
419 Scaling limits reached, return an 'averaged' result.
421 if ( resample_filter->limit_reached ) {
422 switch ( resample_filter->virtual_pixel ) {
423 /* This is always handled by the above, so no need.
424 case BackgroundVirtualPixelMethod:
425 case ConstantVirtualPixelMethod:
426 case TransparentVirtualPixelMethod:
427 case GrayVirtualPixelMethod,
428 case WhiteVirtualPixelMethod
429 case MaskVirtualPixelMethod:
431 case UndefinedVirtualPixelMethod:
432 case EdgeVirtualPixelMethod:
433 case DitherVirtualPixelMethod:
434 case HorizontalTileEdgeVirtualPixelMethod:
435 case VerticalTileEdgeVirtualPixelMethod:
436 /* We need an average edge pixel, from the correct edge!
437 How should I calculate an average edge color?
438 Just returning an averaged neighbourhood,
439 works well in general, but falls down for TileEdge methods.
440 This needs to be done properly!!!!!!
442 status=InterpolatePixelInfo(resample_filter->image,
443 resample_filter->view,AverageInterpolatePixel,u0,v0,pixel,
444 resample_filter->exception);
446 case HorizontalTileVirtualPixelMethod:
447 case VerticalTileVirtualPixelMethod:
448 /* just return the background pixel - Is there more direct way? */
449 status=InterpolatePixelInfo(resample_filter->image,
450 resample_filter->view,IntegerInterpolatePixel,-1.0,-1.0,pixel,
451 resample_filter->exception);
453 case TileVirtualPixelMethod:
454 case MirrorVirtualPixelMethod:
455 case RandomVirtualPixelMethod:
456 case CheckerTileVirtualPixelMethod:
458 /* generate a average color of the WHOLE image */
459 if ( resample_filter->average_defined == MagickFalse ) {
466 GetPixelInfo(resample_filter->image,(PixelInfo *)
467 &resample_filter->average_pixel);
468 resample_filter->average_defined=MagickTrue;
470 /* Try to get an averaged pixel color of whole image */
471 average_image=ResizeImage(resample_filter->image,1,1,BoxFilter,1.0,
472 resample_filter->exception);
473 if (average_image == (Image *) NULL)
475 *pixel=resample_filter->average_pixel; /* FAILED */
478 average_view=AcquireCacheView(average_image);
479 pixels=GetCacheViewVirtualPixels(average_view,0,0,1,1,
480 resample_filter->exception);
481 if (pixels == (const Quantum *) NULL) {
482 average_view=DestroyCacheView(average_view);
483 average_image=DestroyImage(average_image);
484 *pixel=resample_filter->average_pixel; /* FAILED */
487 GetPixelInfoPixel(resample_filter->image,pixels,
488 &(resample_filter->average_pixel));
489 average_view=DestroyCacheView(average_view);
490 average_image=DestroyImage(average_image);
492 if ( resample_filter->virtual_pixel == CheckerTileVirtualPixelMethod )
494 /* CheckerTile is avergae of image average half background */
495 /* FUTURE: replace with a 50% blend of both pixels */
497 weight = QuantumScale*((MagickRealType)
498 resample_filter->average_pixel.alpha);
499 resample_filter->average_pixel.red *= weight;
500 resample_filter->average_pixel.green *= weight;
501 resample_filter->average_pixel.blue *= weight;
504 weight = QuantumScale*((MagickRealType)
505 resample_filter->image->background_color.alpha);
506 resample_filter->average_pixel.red +=
507 weight*resample_filter->image->background_color.red;
508 resample_filter->average_pixel.green +=
509 weight*resample_filter->image->background_color.green;
510 resample_filter->average_pixel.blue +=
511 weight*resample_filter->image->background_color.blue;
512 resample_filter->average_pixel.alpha +=
513 resample_filter->image->background_color.alpha;
516 resample_filter->average_pixel.red /= divisor_c;
517 resample_filter->average_pixel.green /= divisor_c;
518 resample_filter->average_pixel.blue /= divisor_c;
519 resample_filter->average_pixel.alpha /= 2;
523 *pixel=resample_filter->average_pixel;
530 Initialize weighted average data collection
535 pixel->red = pixel->green = pixel->blue = 0.0;
536 if (pixel->colorspace == CMYKColorspace)
538 if (pixel->matte != MagickFalse)
542 Determine the parellelogram bounding box fitted to the ellipse
543 centered at u0,v0. This area is bounding by the lines...
545 v1 = (ssize_t)ceil(v0 - resample_filter->Vlimit); /* range of scan lines */
546 v2 = (ssize_t)floor(v0 + resample_filter->Vlimit);
548 /* scan line start and width accross the parallelogram */
549 u1 = u0 + (v1-v0)*resample_filter->slope - resample_filter->Uwidth;
550 uw = (ssize_t)(2.0*resample_filter->Uwidth)+1;
553 (void) FormatLocaleFile(stderr, "v1=%ld; v2=%ld\n", (long)v1, (long)v2);
554 (void) FormatLocaleFile(stderr, "u1=%ld; uw=%ld\n", (long)u1, (long)uw);
556 # define DEBUG_HIT_MISS 0 /* only valid if DEBUG_ELLIPSE is enabled */
560 Do weighted resampling of all pixels, within the scaled ellipse,
561 bound by a Parellelogram fitted to the ellipse.
563 DDQ = 2*resample_filter->A;
564 for( v=v1; v<=v2; v++ ) {
566 long uu = ceil(u1); /* actual pixel location (for debug only) */
567 (void) FormatLocaleFile(stderr, "# scan line from pixel %ld, %ld\n", (long)uu, (long)v);
569 u = (ssize_t)ceil(u1); /* first pixel in scanline */
570 u1 += resample_filter->slope; /* start of next scan line */
573 /* location of this first pixel, relative to u0,v0 */
577 /* Q = ellipse quotent ( if Q<F then pixel is inside ellipse) */
578 Q = (resample_filter->A*U + resample_filter->B*V)*U + resample_filter->C*V*V;
579 DQ = resample_filter->A*(2.0*U+1) + resample_filter->B*V;
581 /* get the scanline of pixels for this v */
582 pixels=GetCacheViewVirtualPixels(resample_filter->view,u,v,(size_t) uw,
583 1,resample_filter->exception);
584 if (pixels == (const Quantum *) NULL)
587 /* count up the weighted pixel colors */
588 for( u=0; u<uw; u++ ) {
590 /* Note that the ellipse has been pre-scaled so F = WLUT_WIDTH */
591 if ( Q < (double)WLUT_WIDTH ) {
592 weight = resample_filter->filter_lut[(int)Q];
594 /* Note that the ellipse has been pre-scaled so F = support^2 */
595 if ( Q < (double)resample_filter->F ) {
596 weight = GetResizeFilterWeight(resample_filter->filter_def,
597 sqrt(Q)); /* a SquareRoot! Arrggghhhhh... */
600 pixel->alpha += weight*GetPixelAlpha(resample_filter->image,pixels);
603 if (pixel->matte != MagickFalse)
604 weight *= QuantumScale*((MagickRealType) GetPixelAlpha(resample_filter->image,pixels));
605 pixel->red += weight*GetPixelRed(resample_filter->image,pixels);
606 pixel->green += weight*GetPixelGreen(resample_filter->image,pixels);
607 pixel->blue += weight*GetPixelBlue(resample_filter->image,pixels);
608 if (pixel->colorspace == CMYKColorspace)
609 pixel->black += weight*GetPixelBlack(resample_filter->image,pixels);
614 /* mark the pixel according to hit/miss of the ellipse */
615 (void) FormatLocaleFile(stderr, "set arrow from %lf,%lf to %lf,%lf nohead ls 3\n",
616 (long)uu-.1,(double)v-.1,(long)uu+.1,(long)v+.1);
617 (void) FormatLocaleFile(stderr, "set arrow from %lf,%lf to %lf,%lf nohead ls 3\n",
618 (long)uu+.1,(double)v-.1,(long)uu-.1,(long)v+.1);
620 (void) FormatLocaleFile(stderr, "set arrow from %lf,%lf to %lf,%lf nohead ls 1\n",
621 (long)uu-.1,(double)v-.1,(long)uu+.1,(long)v+.1);
622 (void) FormatLocaleFile(stderr, "set arrow from %lf,%lf to %lf,%lf nohead ls 1\n",
623 (long)uu+.1,(double)v-.1,(long)uu-.1,(long)v+.1);
629 pixels+=GetPixelChannels(resample_filter->image);
635 (void) FormatLocaleFile(stderr, "Hit=%ld; Total=%ld;\n", (long)hit, (long)uw*(v2-v1) );
639 Result sanity check -- this should NOT happen
642 /* not enough pixels in resampling, resort to direct interpolation */
643 #if DEBUG_NO_PIXEL_HIT
644 pixel->alpha = pixel->red = pixel->green = pixel->blue = 0;
645 pixel->red = QuantumRange; /* show pixels for which EWA fails */
647 status=InterpolatePixelInfo(resample_filter->image,
648 resample_filter->view,resample_filter->interpolate,u0,v0,pixel,
649 resample_filter->exception);
655 Finialize results of resampling
657 divisor_m = 1.0/divisor_m;
658 pixel->alpha = (MagickRealType) ClampToQuantum(divisor_m*pixel->alpha);
659 divisor_c = 1.0/divisor_c;
660 pixel->red = (MagickRealType) ClampToQuantum(divisor_c*pixel->red);
661 pixel->green = (MagickRealType) ClampToQuantum(divisor_c*pixel->green);
662 pixel->blue = (MagickRealType) ClampToQuantum(divisor_c*pixel->blue);
663 if (pixel->colorspace == CMYKColorspace)
664 pixel->black = (MagickRealType) ClampToQuantum(divisor_c*pixel->black);
670 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
674 - C l a m p U p A x e s %
678 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
680 % ClampUpAxes() function converts the input vectors into a major and
681 % minor axis unit vectors, and their magnitude. This allows us to
682 % ensure that the ellipse generated is never smaller than the unit
683 % circle and thus never too small for use in EWA resampling.
685 % This purely mathematical 'magic' was provided by Professor Nicolas
686 % Robidoux and his Masters student Chantal Racette.
688 % Reference: "We Recommend Singular Value Decomposition", David Austin
689 % http://www.ams.org/samplings/feature-column/fcarc-svd
691 % By generating major and minor axis vectors, we can actually use the
692 % ellipse in its "canonical form", by remapping the dx,dy of the
693 % sampled point into distances along the major and minor axis unit
696 % Reference: http://en.wikipedia.org/wiki/Ellipse#Canonical_form
698 static inline void ClampUpAxes(const double dux,
704 double *major_unit_x,
705 double *major_unit_y,
706 double *minor_unit_x,
707 double *minor_unit_y)
710 * ClampUpAxes takes an input 2x2 matrix
712 * [ a b ] = [ dux duy ]
713 * [ c d ] = [ dvx dvy ]
715 * and computes from it the major and minor axis vectors [major_x,
716 * major_y] and [minor_x,minor_y] of the smallest ellipse containing
717 * both the unit disk and the ellipse which is the image of the unit
718 * disk by the linear transformation
720 * [ dux duy ] [S] = [s]
721 * [ dvx dvy ] [T] = [t]
723 * (The vector [S,T] is the difference between a position in output
724 * space and [X,Y]; the vector [s,t] is the difference between a
725 * position in input space and [x,y].)
730 * major_mag is the half-length of the major axis of the "new"
733 * minor_mag is the half-length of the minor axis of the "new"
736 * major_unit_x is the x-coordinate of the major axis direction vector
737 * of both the "old" and "new" ellipses.
739 * major_unit_y is the y-coordinate of the major axis direction vector.
741 * minor_unit_x is the x-coordinate of the minor axis direction vector.
743 * minor_unit_y is the y-coordinate of the minor axis direction vector.
745 * Unit vectors are useful for computing projections, in particular,
746 * to compute the distance between a point in output space and the
747 * center of a unit disk in output space, using the position of the
748 * corresponding point [s,t] in input space. Following the clamping,
749 * the square of this distance is
751 * ( ( s * major_unit_x + t * major_unit_y ) / major_mag )^2
753 * ( ( s * minor_unit_x + t * minor_unit_y ) / minor_mag )^2
755 * If such distances will be computed for many [s,t]'s, it makes
756 * sense to actually compute the reciprocal of major_mag and
757 * minor_mag and multiply them by the above unit lengths.
759 * Now, if you want to modify the input pair of tangent vectors so
760 * that it defines the modified ellipse, all you have to do is set
762 * newdux = major_mag * major_unit_x
763 * newdvx = major_mag * major_unit_y
764 * newduy = minor_mag * minor_unit_x = minor_mag * -major_unit_y
765 * newdvy = minor_mag * minor_unit_y = minor_mag * major_unit_x
767 * and use these tangent vectors as if they were the original ones.
768 * Usually, this is a drastic change in the tangent vectors even if
769 * the singular values are not clamped; for example, the minor axis
770 * vector always points in a direction which is 90 degrees
771 * counterclockwise from the direction of the major axis vector.
776 * GOAL: Fix things so that the pullback, in input space, of a disk
777 * of radius r in output space is an ellipse which contains, at
778 * least, a disc of radius r. (Make this hold for any r>0.)
780 * ESSENCE OF THE METHOD: Compute the product of the first two
781 * factors of an SVD of the linear transformation defining the
782 * ellipse and make sure that both its columns have norm at least 1.
783 * Because rotations and reflexions map disks to themselves, it is
784 * not necessary to compute the third (rightmost) factor of the SVD.
786 * DETAILS: Find the singular values and (unit) left singular
787 * vectors of Jinv, clampling up the singular values to 1, and
788 * multiply the unit left singular vectors by the new singular
789 * values in order to get the minor and major ellipse axis vectors.
791 * Image resampling context:
793 * The Jacobian matrix of the transformation at the output point
794 * under consideration is defined as follows:
796 * Consider the transformation (x,y) -> (X,Y) from input locations
797 * to output locations. (Anthony Thyssen, elsewhere in resample.c,
798 * uses the notation (u,v) -> (x,y).)
800 * The Jacobian matrix of the transformation at (x,y) is equal to
802 * J = [ A, B ] = [ dX/dx, dX/dy ]
803 * [ C, D ] [ dY/dx, dY/dy ]
805 * that is, the vector [A,C] is the tangent vector corresponding to
806 * input changes in the horizontal direction, and the vector [B,D]
807 * is the tangent vector corresponding to input changes in the
808 * vertical direction.
810 * In the context of resampling, it is natural to use the inverse
811 * Jacobian matrix Jinv because resampling is generally performed by
812 * pulling pixel locations in the output image back to locations in
813 * the input image. Jinv is
815 * Jinv = [ a, b ] = [ dx/dX, dx/dY ]
816 * [ c, d ] [ dy/dX, dy/dY ]
818 * Note: Jinv can be computed from J with the following matrix
821 * Jinv = 1/(A*D-B*C) [ D, -B ]
824 * What we do is modify Jinv so that it generates an ellipse which
825 * is as close as possible to the original but which contains the
826 * unit disk. This can be accomplished as follows:
832 * be an SVD decomposition of Jinv. (The SVD is not unique, but the
833 * final ellipse does not depend on the particular SVD.)
835 * We could clamp up the entries of the diagonal matrix Sigma so
836 * that they are at least 1, and then set
838 * Jinv = U newSigma V^T.
840 * However, we do not need to compute V for the following reason:
841 * V^T is an orthogonal matrix (that is, it represents a combination
842 * of rotations and reflexions) so that it maps the unit circle to
843 * itself. For this reason, the exact value of V does not affect the
844 * final ellipse, and we can choose V to be the identity
849 * In the end, we return the two diagonal entries of newSigma
850 * together with the two columns of U.
853 * ClampUpAxes was written by Nicolas Robidoux and Chantal Racette
854 * of Laurentian University with insightful suggestions from Anthony
855 * Thyssen and funding from the National Science and Engineering
856 * Research Council of Canada. It is distinguished from its
857 * predecessors by its efficient handling of degenerate cases.
859 * The idea of clamping up the EWA ellipse's major and minor axes so
860 * that the result contains the reconstruction kernel filter support
861 * is taken from Andreas Gustaffson's Masters thesis "Interactive
862 * Image Warping", Helsinki University of Technology, Faculty of
863 * Information Technology, 59 pages, 1993 (see Section 3.6).
865 * The use of the SVD to clamp up the singular values of the
866 * Jacobian matrix of the pullback transformation for EWA resampling
867 * is taken from the astrophysicist Craig DeForest. It is
868 * implemented in his PDL::Transform code (PDL = Perl Data
871 const double a = dux;
872 const double b = duy;
873 const double c = dvx;
874 const double d = dvy;
876 * n is the matrix Jinv * transpose(Jinv). Eigenvalues of n are the
877 * squares of the singular values of Jinv.
879 const double aa = a*a;
880 const double bb = b*b;
881 const double cc = c*c;
882 const double dd = d*d;
884 * Eigenvectors of n are left singular vectors of Jinv.
886 const double n11 = aa+bb;
887 const double n12 = a*c+b*d;
888 const double n21 = n12;
889 const double n22 = cc+dd;
890 const double det = a*d-b*c;
891 const double twice_det = det+det;
892 const double frobenius_squared = n11+n22;
893 const double discriminant =
894 (frobenius_squared+twice_det)*(frobenius_squared-twice_det);
895 const double sqrt_discriminant = sqrt(discriminant);
897 * s1 is the largest singular value of the inverse Jacobian
898 * matrix. In other words, its reciprocal is the smallest singular
899 * value of the Jacobian matrix itself.
900 * If s1 = 0, both singular values are 0, and any orthogonal pair of
901 * left and right factors produces a singular decomposition of Jinv.
904 * Initially, we only compute the squares of the singular values.
906 const double s1s1 = 0.5*(frobenius_squared+sqrt_discriminant);
908 * s2 the smallest singular value of the inverse Jacobian
909 * matrix. Its reciprocal is the largest singular value of the
910 * Jacobian matrix itself.
912 const double s2s2 = 0.5*(frobenius_squared-sqrt_discriminant);
913 const double s1s1minusn11 = s1s1-n11;
914 const double s1s1minusn22 = s1s1-n22;
916 * u1, the first column of the U factor of a singular decomposition
917 * of Jinv, is a (non-normalized) left singular vector corresponding
918 * to s1. It has entries u11 and u21. We compute u1 from the fact
919 * that it is an eigenvector of n corresponding to the eigenvalue
922 const double s1s1minusn11_squared = s1s1minusn11*s1s1minusn11;
923 const double s1s1minusn22_squared = s1s1minusn22*s1s1minusn22;
925 * The following selects the largest row of n-s1^2 I as the one
926 * which is used to find the eigenvector. If both s1^2-n11 and
927 * s1^2-n22 are zero, n-s1^2 I is the zero matrix. In that case,
928 * any vector is an eigenvector; in addition, norm below is equal to
929 * zero, and, in exact arithmetic, this is the only case in which
930 * norm = 0. So, setting u1 to the simple but arbitrary vector [1,0]
931 * if norm = 0 safely takes care of all cases.
933 const double temp_u11 =
934 ( (s1s1minusn11_squared>=s1s1minusn22_squared) ? n12 : s1s1minusn22 );
935 const double temp_u21 =
936 ( (s1s1minusn11_squared>=s1s1minusn22_squared) ? s1s1minusn11 : n21 );
937 const double norm = sqrt(temp_u11*temp_u11+temp_u21*temp_u21);
939 * Finalize the entries of first left singular vector (associated
940 * with the largest singular value).
942 const double u11 = ( (norm>0.0) ? temp_u11/norm : 1.0 );
943 const double u21 = ( (norm>0.0) ? temp_u21/norm : 0.0 );
945 * Clamp the singular values up to 1.
947 *major_mag = ( (s1s1<=1.0) ? 1.0 : sqrt(s1s1) );
948 *minor_mag = ( (s2s2<=1.0) ? 1.0 : sqrt(s2s2) );
950 * Return the unit major and minor axis direction vectors.
954 *minor_unit_x = -u21;
960 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
964 % S c a l e R e s a m p l e F i l t e r %
968 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
970 % ScaleResampleFilter() does all the calculations needed to resample an image
971 % at a specific scale, defined by two scaling vectors. This not using
972 % a orthogonal scaling, but two distorted scaling vectors, to allow the
973 % generation of a angled ellipse.
975 % As only two deritive scaling vectors are used the center of the ellipse
976 % must be the center of the lookup. That is any curvature that the
977 % distortion may produce is discounted.
979 % The input vectors are produced by either finding the derivitives of the
980 % distortion function, or the partial derivitives from a distortion mapping.
981 % They do not need to be the orthogonal dx,dy scaling vectors, but can be
982 % calculated from other derivatives. For example you could use dr,da/r
983 % polar coordinate vector scaling vectors
985 % If u,v = DistortEquation(x,y) OR u = Fu(x,y); v = Fv(x,y)
986 % Then the scaling vectors are determined from the deritives...
987 % du/dx, dv/dx and du/dy, dv/dy
988 % If the resulting scaling vectors is othogonally aligned then...
989 % dv/dx = 0 and du/dy = 0
990 % Producing an othogonally alligned ellipse in source space for the area to
993 % Note that scaling vectors are different to argument order. Argument order
994 % is the general order the deritives are extracted from the distortion
995 % equations, and not the scaling vectors. As such the middle two vaules
996 % may be swapped from what you expect. Caution is advised.
998 % WARNING: It is assumed that any SetResampleFilter() method call will
999 % always be performed before the ScaleResampleFilter() method, so that the
1000 % size of the ellipse will match the support for the resampling filter being
1003 % The format of the ScaleResampleFilter method is:
1005 % void ScaleResampleFilter(const ResampleFilter *resample_filter,
1006 % const double dux,const double duy,const double dvx,const double dvy)
1008 % A description of each parameter follows:
1010 % o resample_filter: the resampling resample_filterrmation defining the
1011 % image being resampled
1013 % o dux,duy,dvx,dvy:
1014 % The deritives or scaling vectors defining the EWA ellipse.
1015 % NOTE: watch the order, which is based on the order deritives
1016 % are usally determined from distortion equations (see above).
1017 % The middle two values may need to be swapped if you are thinking
1018 % in terms of scaling vectors.
1021 MagickExport void ScaleResampleFilter(ResampleFilter *resample_filter,
1022 const double dux,const double duy,const double dvx,const double dvy)
1026 assert(resample_filter != (ResampleFilter *) NULL);
1027 assert(resample_filter->signature == MagickSignature);
1029 resample_filter->limit_reached = MagickFalse;
1031 /* A 'point' filter forces use of interpolation instead of area sampling */
1032 if ( resample_filter->filter == PointFilter )
1033 return; /* EWA turned off - nothing to do */
1036 (void) FormatLocaleFile(stderr, "# -----\n" );
1037 (void) FormatLocaleFile(stderr, "dux=%lf; dvx=%lf; duy=%lf; dvy=%lf;\n",
1038 dux, dvx, duy, dvy);
1041 /* Find Ellipse Coefficents such that
1042 A*u^2 + B*u*v + C*v^2 = F
1043 With u,v relative to point around which we are resampling.
1044 And the given scaling dx,dy vectors in u,v space
1045 du/dx,dv/dx and du/dy,dv/dy
1048 /* Direct conversion of derivatives into elliptical coefficients
1049 However when magnifying images, the scaling vectors will be small
1050 resulting in a ellipse that is too small to sample properly.
1051 As such we need to clamp the major/minor axis to a minumum of 1.0
1052 to prevent it getting too small.
1062 ClampUpAxes(dux,dvx,duy,dvy, &major_mag, &minor_mag,
1063 &major_x, &major_y, &minor_x, &minor_y);
1064 major_x *= major_mag; major_y *= major_mag;
1065 minor_x *= minor_mag; minor_y *= minor_mag;
1067 (void) FormatLocaleFile(stderr, "major_x=%lf; major_y=%lf; minor_x=%lf; minor_y=%lf;\n",
1068 major_x, major_y, minor_x, minor_y);
1070 A = major_y*major_y+minor_y*minor_y;
1071 B = -2.0*(major_x*major_y+minor_x*minor_y);
1072 C = major_x*major_x+minor_x*minor_x;
1073 F = major_mag*minor_mag;
1074 F *= F; /* square it */
1076 #else /* raw unclamped EWA */
1077 A = dvx*dvx+dvy*dvy;
1078 B = -2.0*(dux*dvx+duy*dvy);
1079 C = dux*dux+duy*duy;
1080 F = dux*dvy-duy*dvx;
1081 F *= F; /* square it */
1082 #endif /* EWA_CLAMP */
1086 This Paul Heckbert's "Higher Quality EWA" formula, from page 60 in his
1087 thesis, which adds a unit circle to the elliptical area so as to do both
1088 Reconstruction and Prefiltering of the pixels in the resampling. It also
1089 means it is always likely to have at least 4 pixels within the area of the
1090 ellipse, for weighted averaging. No scaling will result with F == 4.0 and
1091 a circle of radius 2.0, and F smaller than this means magnification is
1094 NOTE: This method produces a very blury result at near unity scale while
1095 producing perfect results for strong minitification and magnifications.
1097 However filter support is fixed to 2.0 (no good for Windowed Sinc filters)
1099 A = dvx*dvx+dvy*dvy+1;
1100 B = -2.0*(dux*dvx+duy*dvy);
1101 C = dux*dux+duy*duy+1;
1106 (void) FormatLocaleFile(stderr, "A=%lf; B=%lf; C=%lf; F=%lf\n", A,B,C,F);
1108 /* Figure out the various information directly about the ellipse.
1109 This information currently not needed at this time, but may be
1110 needed later for better limit determination.
1112 It is also good to have as a record for future debugging
1114 { double alpha, beta, gamma, Major, Minor;
1115 double Eccentricity, Ellipse_Area, Ellipse_Angle;
1119 gamma = sqrt(beta*beta + B*B );
1121 if ( alpha - gamma <= MagickEpsilon )
1124 Major = sqrt(2*F/(alpha - gamma));
1125 Minor = sqrt(2*F/(alpha + gamma));
1127 (void) FormatLocaleFile(stderr, "# Major=%lf; Minor=%lf\n", Major, Minor );
1129 /* other information about ellipse include... */
1130 Eccentricity = Major/Minor;
1131 Ellipse_Area = MagickPI*Major*Minor;
1132 Ellipse_Angle = atan2(B, A-C);
1134 (void) FormatLocaleFile(stderr, "# Angle=%lf Area=%lf\n",
1135 RadiansToDegrees(Ellipse_Angle), Ellipse_Area);
1139 /* If one or both of the scaling vectors is impossibly large
1140 (producing a very large raw F value), we may as well not bother
1141 doing any form of resampling since resampled area is very large.
1142 In this case some alternative means of pixel sampling, such as
1143 the average of the whole image is needed to get a reasonable
1144 result. Calculate only as needed.
1146 if ( (4*A*C - B*B) > MagickHuge ) {
1147 resample_filter->limit_reached = MagickTrue;
1151 /* Scale ellipse to match the filters support
1152 (that is, multiply F by the square of the support).
1154 F *= resample_filter->support;
1155 F *= resample_filter->support;
1157 /* Orthogonal bounds of the ellipse */
1158 resample_filter->Ulimit = sqrt(C*F/(A*C-0.25*B*B));
1159 resample_filter->Vlimit = sqrt(A*F/(A*C-0.25*B*B));
1161 /* Horizontally aligned parallelogram fitted to Ellipse */
1162 resample_filter->Uwidth = sqrt(F/A); /* Half of the parallelogram width */
1163 resample_filter->slope = -B/(2.0*A); /* Reciprocal slope of the parallelogram */
1166 (void) FormatLocaleFile(stderr, "Ulimit=%lf; Vlimit=%lf; UWidth=%lf; Slope=%lf;\n",
1167 resample_filter->Ulimit, resample_filter->Vlimit,
1168 resample_filter->Uwidth, resample_filter->slope );
1171 /* Check the absolute area of the parallelogram involved.
1172 * This limit needs more work, as it is too slow for larger images
1173 * with tiled views of the horizon.
1175 if ( (resample_filter->Uwidth * resample_filter->Vlimit)
1176 > (4.0*resample_filter->image_area)) {
1177 resample_filter->limit_reached = MagickTrue;
1181 /* Scale ellipse formula to directly index the Filter Lookup Table */
1182 { register double scale;
1184 /* scale so that F = WLUT_WIDTH; -- hardcoded */
1185 scale = (double)WLUT_WIDTH/F;
1187 /* scale so that F = resample_filter->F (support^2) */
1188 scale = resample_filter->F/F;
1190 resample_filter->A = A*scale;
1191 resample_filter->B = B*scale;
1192 resample_filter->C = C*scale;
1197 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1201 % S e t R e s a m p l e F i l t e r %
1205 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1207 % SetResampleFilter() set the resampling filter lookup table based on a
1208 % specific filter. Note that the filter is used as a radial filter not as a
1209 % two pass othogonally aligned resampling filter.
1211 % The default Filter, is Gaussian, which is the standard filter used by the
1212 % original paper on the Elliptical Weighted Everage Algorithm. However other
1213 % filters can also be used.
1215 % The format of the SetResampleFilter method is:
1217 % void SetResampleFilter(ResampleFilter *resample_filter,
1218 % const FilterTypes filter,const double blur)
1220 % A description of each parameter follows:
1222 % o resample_filter: resampling resample_filterrmation structure
1224 % o filter: the resize filter for elliptical weighting LUT
1226 % o blur: filter blur factor (radial scaling) for elliptical weighting LUT
1229 MagickExport void SetResampleFilter(ResampleFilter *resample_filter,
1230 const FilterTypes filter,const double blur)
1235 assert(resample_filter != (ResampleFilter *) NULL);
1236 assert(resample_filter->signature == MagickSignature);
1238 resample_filter->do_interpolate = MagickFalse;
1239 resample_filter->filter = filter;
1241 if ( filter == PointFilter )
1243 resample_filter->do_interpolate = MagickTrue;
1244 return; /* EWA turned off - nothing more to do */
1247 /* Set a default cylindrical filter of a 'low blur' Jinc windowed Jinc */
1248 if ( filter == UndefinedFilter )
1249 resample_filter->filter = RobidouxFilter;
1251 resize_filter = AcquireResizeFilter(resample_filter->image,
1252 resample_filter->filter,blur,MagickTrue,resample_filter->exception);
1253 if (resize_filter == (ResizeFilter *) NULL)
1255 (void) ThrowMagickException(resample_filter->exception,GetMagickModule(),
1256 ModuleError, "UnableToSetFilteringValue",
1257 "Fall back to default EWA gaussian filter");
1258 resample_filter->filter = PointFilter;
1261 /* Get the practical working support for the filter,
1262 * after any API call blur factors have been accoded for.
1265 resample_filter->support = GetResizeFilterSupport(resize_filter);
1267 resample_filter->support = 2.0; /* fixed support size for HQ-EWA */
1271 /* Fill the LUT with the weights from the selected filter function */
1276 /* Scale radius so the filter LUT covers the full support range */
1277 r_scale = resample_filter->support*sqrt(1.0/(double)WLUT_WIDTH);
1278 for(Q=0; Q<WLUT_WIDTH; Q++)
1279 resample_filter->filter_lut[Q] = (double)
1280 GetResizeFilterWeight(resize_filter,sqrt((double)Q)*r_scale);
1282 /* finished with the resize filter */
1283 resize_filter = DestroyResizeFilter(resize_filter);
1286 /* save the filter and the scaled ellipse bounds needed for filter */
1287 resample_filter->filter_def = resize_filter;
1288 resample_filter->F = resample_filter->support*resample_filter->support;
1292 Adjust the scaling of the default unit circle
1293 This assumes that any real scaling changes will always
1294 take place AFTER the filter method has been initialized.
1296 ScaleResampleFilter(resample_filter, 1.0, 0.0, 0.0, 1.0);
1299 /* This is old code kept as a reference only. It is very wrong,
1300 and I don't understand exactly what it was attempting to do.
1303 Create Normal Gaussian 2D Filter Weighted Lookup Table.
1304 A normal EWA guassual lookup would use exp(Q*ALPHA)
1305 where Q = distance squared from 0.0 (center) to 1.0 (edge)
1306 and ALPHA = -4.0*ln(2.0) ==> -2.77258872223978123767
1307 The table is of length 1024, and equates to support radius of 2.0
1308 thus needs to be scaled by ALPHA*4/1024 and any blur factor squared
1310 The above came from some reference code provided by Fred Weinhaus
1311 and seems to have been a guess that was appropriate for its use
1312 in a 3d perspective landscape mapping program.
1314 r_scale = -2.77258872223978123767/(WLUT_WIDTH*blur*blur);
1315 for(Q=0; Q<WLUT_WIDTH; Q++)
1316 resample_filter->filter_lut[Q] = exp((double)Q*r_scale);
1317 resample_filter->support = WLUT_WIDTH;
1322 #if defined(MAGICKCORE_OPENMP_SUPPORT)
1330 /* Scale radius so the filter LUT covers the full support range */
1331 r_scale = resample_filter->support*sqrt(1.0/(double)WLUT_WIDTH);
1332 if (IsMagickTrue(GetImageArtifact(resample_filter->image,"resample:verbose")) )
1334 /* Debug output of the filter weighting LUT
1335 Gnuplot the LUT with hoizontal adjusted to 'r' using...
1336 plot [0:2][-.2:1] "lut.dat" using (sqrt($0/1024)*2):1 with lines
1337 The filter values is normalized for comparision
1340 printf("# Resampling Filter LUT (%d values)\n", WLUT_WIDTH);
1342 printf("# Note: values in table are using a squared radius lookup.\n");
1343 printf("# And the whole table represents the filters support.\n");
1344 printf("\n"); /* generates a 'break' in gnuplot if multiple outputs */
1345 for(Q=0; Q<WLUT_WIDTH; Q++)
1346 printf("%8.*g %.*g\n",
1347 GetMagickPrecision(),sqrt((double)Q)*r_scale,
1348 GetMagickPrecision(),resample_filter->filter_lut[Q] );
1350 /* output the above once only for each image, and each setting */
1351 (void) DeleteImageArtifact(resample_filter->image,"resample:verbose");
1353 #endif /* FILTER_LUT */
1358 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1362 % S e t R e s a m p l e F i l t e r I n t e r p o l a t e M e t h o d %
1366 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1368 % SetResampleFilterInterpolateMethod() sets the resample filter interpolation
1371 % The format of the SetResampleFilterInterpolateMethod method is:
1373 % MagickBooleanType SetResampleFilterInterpolateMethod(
1374 % ResampleFilter *resample_filter,const InterpolateMethod method)
1376 % A description of each parameter follows:
1378 % o resample_filter: the resample filter.
1380 % o method: the interpolation method.
1383 MagickExport MagickBooleanType SetResampleFilterInterpolateMethod(
1384 ResampleFilter *resample_filter,const PixelInterpolateMethod method)
1386 assert(resample_filter != (ResampleFilter *) NULL);
1387 assert(resample_filter->signature == MagickSignature);
1388 assert(resample_filter->image != (Image *) NULL);
1389 if (resample_filter->debug != MagickFalse)
1390 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",
1391 resample_filter->image->filename);
1392 resample_filter->interpolate=method;
1397 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1401 % S e t R e s a m p l e F i l t e r V i r t u a l P i x e l M e t h o d %
1405 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1407 % SetResampleFilterVirtualPixelMethod() changes the virtual pixel method
1408 % associated with the specified resample filter.
1410 % The format of the SetResampleFilterVirtualPixelMethod method is:
1412 % MagickBooleanType SetResampleFilterVirtualPixelMethod(
1413 % ResampleFilter *resample_filter,const VirtualPixelMethod method)
1415 % A description of each parameter follows:
1417 % o resample_filter: the resample filter.
1419 % o method: the virtual pixel method.
1422 MagickExport MagickBooleanType SetResampleFilterVirtualPixelMethod(
1423 ResampleFilter *resample_filter,const VirtualPixelMethod method)
1425 assert(resample_filter != (ResampleFilter *) NULL);
1426 assert(resample_filter->signature == MagickSignature);
1427 assert(resample_filter->image != (Image *) NULL);
1428 if (resample_filter->debug != MagickFalse)
1429 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",
1430 resample_filter->image->filename);
1431 resample_filter->virtual_pixel=method;
1432 if (method != UndefinedVirtualPixelMethod)
1433 (void) SetCacheViewVirtualPixelMethod(resample_filter->view,method);