42 #include "magick/studio.h"
43 #include "magick/accelerate-private.h"
44 #include "magick/artifact.h"
45 #include "magick/blob.h"
46 #include "magick/cache.h"
47 #include "magick/cache-view.h"
48 #include "magick/channel.h"
49 #include "magick/color.h"
50 #include "magick/color-private.h"
51 #include "magick/draw.h"
52 #include "magick/exception.h"
53 #include "magick/exception-private.h"
54 #include "magick/gem.h"
55 #include "magick/image.h"
56 #include "magick/image-private.h"
57 #include "magick/list.h"
58 #include "magick/memory_.h"
59 #include "magick/memory-private.h"
60 #include "magick/magick.h"
61 #include "magick/pixel-private.h"
62 #include "magick/property.h"
63 #include "magick/monitor.h"
64 #include "magick/monitor-private.h"
65 #include "magick/nt-base-private.h"
66 #include "magick/pixel.h"
67 #include "magick/pixel-private.h"
68 #include "magick/option.h"
69 #include "magick/resample.h"
70 #include "magick/resample-private.h"
71 #include "magick/resize.h"
72 #include "magick/resize-private.h"
73 #include "magick/resource_.h"
74 #include "magick/string_.h"
75 #include "magick/string-private.h"
76 #include "magick/thread-private.h"
77 #include "magick/token.h"
78 #include "magick/utility.h"
79 #include "magick/version.h"
80 #if defined(MAGICKCORE_LQR_DELEGATE)
98 ResizeWeightingFunctionType
109 static MagickRealType
110 I0(MagickRealType x),
111 BesselOrderOne(MagickRealType),
148 static MagickRealType Blackman(
const MagickRealType x,
158 const MagickRealType cosine = cos((
double) (MagickPI*x));
159 magick_unreferenced(resize_filter);
160 return(0.34+cosine*(0.5+cosine*0.16));
163 static MagickRealType Bohman(
const MagickRealType x,
174 const double cosine = cos((
double) (MagickPI*x));
175 const double sine = sqrt(1.0-cosine*cosine);
176 magick_unreferenced(resize_filter);
177 return((MagickRealType) ((1.0-x)*cosine+(1.0/MagickPI)*sine));
180 static MagickRealType Box(
const MagickRealType magick_unused(x),
188 magick_unreferenced(x);
189 magick_unreferenced(resize_filter);
194 static MagickRealType Cosine(
const MagickRealType x,
201 magick_unreferenced(resize_filter);
202 return((MagickRealType) cos((
double) (MagickPI2*x)));
205 static MagickRealType CubicBC(
const MagickRealType x,
238 return(resize_filter->coefficient[0]+x*(x*
239 (resize_filter->coefficient[1]+x*resize_filter->coefficient[2])));
241 return(resize_filter->coefficient[3]+x*(resize_filter->coefficient[4]+x*
242 (resize_filter->coefficient[5]+x*resize_filter->coefficient[6])));
246 static MagickRealType Gaussian(
const MagickRealType x,
279 return(exp((
double)(-resize_filter->coefficient[1]*x*x)));
282 static MagickRealType Hanning(
const MagickRealType x,
289 const MagickRealType cosine = cos((
double) (MagickPI*x));
290 magick_unreferenced(resize_filter);
291 return(0.5+0.5*cosine);
294 static MagickRealType Hamming(
const MagickRealType x,
301 const MagickRealType cosine = cos((
double) (MagickPI*x));
302 magick_unreferenced(resize_filter);
303 return(0.54+0.46*cosine);
306 static MagickRealType Jinc(
const MagickRealType x,
317 magick_unreferenced(resize_filter);
320 return((MagickRealType) (0.5*MagickPI));
321 return(BesselOrderOne((MagickRealType) MagickPI*x)/x);
324 static MagickRealType Kaiser(
const MagickRealType x,
339 return(resize_filter->coefficient[1]*I0(resize_filter->coefficient[0]*
340 sqrt((
double) (1.0-x*x))));
343 static MagickRealType Lagrange(
const MagickRealType x,
366 if (x > resize_filter->support)
368 order=(ssize_t) (2.0*resize_filter->window_support);
369 n=(ssize_t) (resize_filter->window_support+x);
371 for (i=0; i < order; i++)
373 value*=(n-i-x)/(n-i);
377 static MagickRealType Quadratic(
const MagickRealType x,
383 magick_unreferenced(resize_filter);
388 return(0.5*(x-1.5)*(x-1.5));
392 static MagickRealType Sinc(
const MagickRealType x,
399 magick_unreferenced(resize_filter);
403 const MagickRealType alpha=(MagickRealType) (MagickPI*x);
404 return(sin((
double) alpha)/alpha);
406 return((MagickRealType) 1.0);
409 static MagickRealType SincFast(
const MagickRealType x,
436 magick_unreferenced(resize_filter);
440 const MagickRealType alpha=(MagickRealType) (MagickPI*x);
441 return(sin((
double) alpha)/alpha);
447 const MagickRealType xx = x*x;
448 #if MAGICKCORE_QUANTUM_DEPTH <= 8
452 const double c0 = 0.173610016489197553621906385078711564924e-2L;
453 const double c1 = -0.384186115075660162081071290162149315834e-3L;
454 const double c2 = 0.393684603287860108352720146121813443561e-4L;
455 const double c3 = -0.248947210682259168029030370205389323899e-5L;
456 const double c4 = 0.107791837839662283066379987646635416692e-6L;
457 const double c5 = -0.324874073895735800961260474028013982211e-8L;
458 const double c6 = 0.628155216606695311524920882748052490116e-10L;
459 const double c7 = -0.586110644039348333520104379959307242711e-12L;
461 c0+xx*(c1+xx*(c2+xx*(c3+xx*(c4+xx*(c5+xx*(c6+xx*c7))))));
462 return((xx-1.0)*(xx-4.0)*(xx-9.0)*(xx-16.0)*p);
463 #elif MAGICKCORE_QUANTUM_DEPTH <= 16
467 const double c0 = 0.173611107357320220183368594093166520811e-2L;
468 const double c1 = -0.384240921114946632192116762889211361285e-3L;
469 const double c2 = 0.394201182359318128221229891724947048771e-4L;
470 const double c3 = -0.250963301609117217660068889165550534856e-5L;
471 const double c4 = 0.111902032818095784414237782071368805120e-6L;
472 const double c5 = -0.372895101408779549368465614321137048875e-8L;
473 const double c6 = 0.957694196677572570319816780188718518330e-10L;
474 const double c7 = -0.187208577776590710853865174371617338991e-11L;
475 const double c8 = 0.253524321426864752676094495396308636823e-13L;
476 const double c9 = -0.177084805010701112639035485248501049364e-15L;
478 c0+xx*(c1+xx*(c2+xx*(c3+xx*(c4+xx*(c5+xx*(c6+xx*(c7+xx*(c8+xx*c9))))))));
479 return((xx-1.0)*(xx-4.0)*(xx-9.0)*(xx-16.0)*p);
484 const double c0 = 0.173611111110910715186413700076827593074e-2L;
485 const double c1 = -0.289105544717893415815859968653611245425e-3L;
486 const double c2 = 0.206952161241815727624413291940849294025e-4L;
487 const double c3 = -0.834446180169727178193268528095341741698e-6L;
488 const double c4 = 0.207010104171026718629622453275917944941e-7L;
489 const double c5 = -0.319724784938507108101517564300855542655e-9L;
490 const double c6 = 0.288101675249103266147006509214934493930e-11L;
491 const double c7 = -0.118218971804934245819960233886876537953e-13L;
493 c0+xx*(c1+xx*(c2+xx*(c3+xx*(c4+xx*(c5+xx*(c6+xx*c7))))));
494 const double d0 = 1.0L;
495 const double d1 = 0.547981619622284827495856984100563583948e-1L;
496 const double d2 = 0.134226268835357312626304688047086921806e-2L;
497 const double d3 = 0.178994697503371051002463656833597608689e-4L;
498 const double d4 = 0.114633394140438168641246022557689759090e-6L;
499 const double q = d0+xx*(d1+xx*(d2+xx*(d3+xx*d4)));
500 return((MagickRealType) ((xx-1.0)*(xx-4.0)*(xx-9.0)*(xx-16.0)/q*p));
505 static MagickRealType Triangle(
const MagickRealType x,
513 magick_unreferenced(resize_filter);
520 static MagickRealType Welsh(
const MagickRealType x,
526 magick_unreferenced(resize_filter);
720 const FilterTypes filter,
const MagickRealType blur,
721 const MagickBooleanType cylindrical,
ExceptionInfo *exception)
756 }
const mapping[SentinelFilter] =
758 { UndefinedFilter, BoxFilter },
759 { PointFilter, BoxFilter },
760 { BoxFilter, BoxFilter },
761 { TriangleFilter, BoxFilter },
762 { HermiteFilter, BoxFilter },
763 { SincFastFilter, HanningFilter },
764 { SincFastFilter, HammingFilter },
765 { SincFastFilter, BlackmanFilter },
766 { GaussianFilter, BoxFilter },
767 { QuadraticFilter, BoxFilter },
768 { CubicFilter, BoxFilter },
769 { CatromFilter, BoxFilter },
770 { MitchellFilter, BoxFilter },
771 { JincFilter, BoxFilter },
772 { SincFilter, BoxFilter },
773 { SincFastFilter, BoxFilter },
774 { SincFastFilter, KaiserFilter },
775 { LanczosFilter, WelshFilter },
776 { SincFastFilter, CubicFilter },
777 { SincFastFilter, BohmanFilter },
778 { SincFastFilter, TriangleFilter },
779 { LagrangeFilter, BoxFilter },
780 { LanczosFilter, LanczosFilter },
781 { LanczosSharpFilter, LanczosSharpFilter },
782 { Lanczos2Filter, Lanczos2Filter },
783 { Lanczos2SharpFilter, Lanczos2SharpFilter },
784 { RobidouxFilter, BoxFilter },
785 { RobidouxSharpFilter, BoxFilter },
786 { LanczosFilter, CosineFilter },
787 { SplineFilter, BoxFilter },
788 { LanczosRadiusFilter, LanczosFilter },
811 ResizeWeightingFunctionType weightingFunctionType;
812 }
const filters[SentinelFilter] =
819 { Box, 0.5, 0.5, 0.0, 0.0, BoxWeightingFunction },
820 { Box, 0.0, 0.5, 0.0, 0.0, BoxWeightingFunction },
821 { Box, 0.5, 0.5, 0.0, 0.0, BoxWeightingFunction },
822 { Triangle, 1.0, 1.0, 0.0, 0.0, TriangleWeightingFunction },
823 { CubicBC, 1.0, 1.0, 0.0, 0.0, CubicBCWeightingFunction },
824 { Hanning, 1.0, 1.0, 0.0, 0.0, HanningWeightingFunction },
825 { Hamming, 1.0, 1.0, 0.0, 0.0, HammingWeightingFunction },
826 { Blackman, 1.0, 1.0, 0.0, 0.0, BlackmanWeightingFunction },
827 { Gaussian, 2.0, 1.5, 0.0, 0.0, GaussianWeightingFunction },
828 { Quadratic, 1.5, 1.5, 0.0, 0.0, QuadraticWeightingFunction },
829 { CubicBC, 2.0, 2.0, 1.0, 0.0, CubicBCWeightingFunction },
830 { CubicBC, 2.0, 1.0, 0.0, 0.5, CubicBCWeightingFunction },
831 { CubicBC, 2.0, 8.0/7.0, 1./3., 1./3., CubicBCWeightingFunction },
832 { Jinc, 3.0, 1.2196698912665045, 0.0, 0.0, JincWeightingFunction },
833 { Sinc, 4.0, 1.0, 0.0, 0.0, SincWeightingFunction },
834 { SincFast, 4.0, 1.0, 0.0, 0.0, SincFastWeightingFunction },
835 { Kaiser, 1.0, 1.0, 0.0, 0.0, KaiserWeightingFunction },
836 { Welsh, 1.0, 1.0, 0.0, 0.0, WelshWeightingFunction },
837 { CubicBC, 2.0, 2.0, 1.0, 0.0, CubicBCWeightingFunction },
838 { Bohman, 1.0, 1.0, 0.0, 0.0, BohmanWeightingFunction },
839 { Triangle, 1.0, 1.0, 0.0, 0.0, TriangleWeightingFunction },
840 { Lagrange, 2.0, 1.0, 0.0, 0.0, LagrangeWeightingFunction },
841 { SincFast, 3.0, 1.0, 0.0, 0.0, SincFastWeightingFunction },
842 { SincFast, 3.0, 1.0, 0.0, 0.0, SincFastWeightingFunction },
843 { SincFast, 2.0, 1.0, 0.0, 0.0, SincFastWeightingFunction },
844 { SincFast, 2.0, 1.0, 0.0, 0.0, SincFastWeightingFunction },
846 { CubicBC, 2.0, 1.1685777620836932,
847 0.37821575509399867, 0.31089212245300067, CubicBCWeightingFunction },
849 { CubicBC, 2.0, 1.105822933719019,
850 0.2620145123990142, 0.3689927438004929, CubicBCWeightingFunction },
851 { Cosine, 1.0, 1.0, 0.0, 0.0, CosineWeightingFunction },
852 { CubicBC, 2.0, 2.0, 1.0, 0.0, CubicBCWeightingFunction },
853 { SincFast, 3.0, 1.0, 0.0, 0.0, SincFastWeightingFunction },
890 assert(image != (
const Image *) NULL);
891 assert(image->signature == MagickCoreSignature);
892 assert(UndefinedFilter < filter && filter < SentinelFilter);
894 assert(exception->signature == MagickCoreSignature);
895 if (IsEventLogging() != MagickFalse)
896 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"%s",image->filename);
898 resize_filter=(
ResizeFilter *) AcquireMagickMemory(
sizeof(*resize_filter));
900 ThrowFatalException(ResourceLimitFatalError,
"MemoryAllocationFailed");
901 (void) memset(resize_filter,0,
sizeof(*resize_filter));
905 filter_type=mapping[filter].filter;
906 window_type=mapping[filter].window;
907 resize_filter->blur = blur;
909 if ((cylindrical != MagickFalse) && (filter_type == SincFastFilter) &&
910 (filter != SincFastFilter))
911 filter_type=JincFilter;
914 artifact=GetImageArtifact(image,
"filter:filter");
915 if (artifact != (
const char *) NULL)
920 option=ParseCommandOption(MagickFilterOptions,MagickFalse,artifact);
921 if ((UndefinedFilter < option) && (option < SentinelFilter))
923 filter_type=(FilterTypes) option;
924 window_type=BoxFilter;
927 artifact=GetImageArtifact(image,
"filter:window");
928 if (artifact != (
const char *) NULL)
930 option=ParseCommandOption(MagickFilterOptions,MagickFalse,artifact);
931 if ((UndefinedFilter < option) && (option < SentinelFilter))
932 window_type=(FilterTypes) option;
938 artifact=GetImageArtifact(image,
"filter:window");
939 if (artifact != (
const char *) NULL)
944 option=ParseCommandOption(MagickFilterOptions,MagickFalse,artifact);
945 if ((UndefinedFilter < option) && (option < SentinelFilter))
947 filter_type=cylindrical != MagickFalse ?
948 JincFilter : SincFastFilter;
949 window_type=(FilterTypes) option;
955 resize_filter->filter=filters[filter_type].function;
956 resize_filter->support=filters[filter_type].support;
957 resize_filter->filterWeightingType=filters[filter_type].weightingFunctionType;
958 resize_filter->window=filters[window_type].function;
959 resize_filter->windowWeightingType=filters[window_type].weightingFunctionType;
960 resize_filter->scale=filters[window_type].scale;
961 resize_filter->signature=MagickCoreSignature;
964 if (cylindrical != MagickFalse)
969 resize_filter->support=(MagickRealType) MagickSQ1_2;
972 case LanczosSharpFilter:
974 case Lanczos2SharpFilter:
975 case LanczosRadiusFilter:
976 resize_filter->filter=filters[JincFilter].function;
977 resize_filter->window=filters[JincFilter].function;
978 resize_filter->scale=filters[JincFilter].scale;
987 case LanczosSharpFilter:
988 resize_filter->blur *= (MagickRealType) 0.9812505644269356;
990 case Lanczos2SharpFilter:
991 resize_filter->blur *= (MagickRealType) 0.9549963639785485;
1003 if ((resize_filter->filter == Gaussian) ||
1004 (resize_filter->window == Gaussian) ) {
1006 artifact=GetImageArtifact(image,
"filter:sigma");
1007 if (artifact != (
const char *) NULL)
1008 value=StringToDouble(artifact,(
char **) NULL);
1010 resize_filter->coefficient[0]=value;
1011 resize_filter->coefficient[1]=PerceptibleReciprocal(2.0*value*value);
1012 resize_filter->coefficient[2]=PerceptibleReciprocal(Magick2PI*value*value);
1015 resize_filter->support *= value/0.5;
1019 if ((resize_filter->filter == Kaiser) ||
1020 (resize_filter->window == Kaiser) ) {
1022 artifact=GetImageArtifact(image,
"filter:alpha");
1023 if (artifact != (
const char *) NULL)
1024 value=StringToDouble(artifact,(
char **) NULL);
1025 artifact=GetImageArtifact(image,
"filter:kaiser-beta");
1026 if (artifact != (
const char *) NULL)
1027 value=StringToDouble(artifact,(
char **) NULL);
1028 artifact=GetImageArtifact(image,
"filter:kaiser-alpha");
1029 if (artifact != (
const char *) NULL)
1030 value=(MagickRealType) (StringToDouble(artifact,(
char **) NULL)*MagickPI);
1032 resize_filter->coefficient[0]=value;
1033 resize_filter->coefficient[1]=PerceptibleReciprocal(I0(value));
1037 artifact=GetImageArtifact(image,
"filter:lobes");
1038 if (artifact != (
const char *) NULL)
1043 lobes=(ssize_t) StringToLong(artifact);
1046 resize_filter->support=(MagickRealType) lobes;
1049 if (resize_filter->filter == Jinc)
1051 if (resize_filter->support > 16)
1052 resize_filter->support=jinc_zeros[15];
1054 resize_filter->support=jinc_zeros[((long)resize_filter->support)-1];
1057 if (filter_type == LanczosRadiusFilter)
1059 resize_filter->blur *= floor(resize_filter->support)/
1060 resize_filter->support;
1064 artifact=GetImageArtifact(image,
"filter:blur");
1065 if (artifact != (
const char *) NULL)
1066 resize_filter->blur*=StringToDouble(artifact,(
char **) NULL);
1067 if (resize_filter->blur < MagickEpsilon)
1068 resize_filter->blur=(MagickRealType) MagickEpsilon;
1071 artifact=GetImageArtifact(image,
"filter:support");
1072 if (artifact != (
const char *) NULL)
1073 resize_filter->support=fabs(StringToDouble(artifact,(
char **) NULL));
1079 resize_filter->window_support=resize_filter->support;
1080 artifact=GetImageArtifact(image,
"filter:win-support");
1081 if (artifact != (
const char *) NULL)
1082 resize_filter->window_support=fabs(StringToDouble(artifact,(
char **) NULL));
1087 resize_filter->scale*=PerceptibleReciprocal(resize_filter->window_support);
1093 if ((resize_filter->filter == CubicBC) ||
1094 (resize_filter->window == CubicBC) )
1096 B=filters[filter_type].B;
1097 C=filters[filter_type].C;
1098 if (filters[window_type].
function == CubicBC)
1100 B=filters[window_type].B;
1101 C=filters[window_type].C;
1103 artifact=GetImageArtifact(image,
"filter:b");
1104 if (artifact != (
const char *) NULL)
1106 B=StringToDouble(artifact,(
char **) NULL);
1108 artifact=GetImageArtifact(image,
"filter:c");
1109 if (artifact != (
const char *) NULL)
1110 C=StringToDouble(artifact,(
char **) NULL);
1114 artifact=GetImageArtifact(image,
"filter:c");
1115 if (artifact != (
const char *) NULL)
1117 C=StringToDouble(artifact,(
char **) NULL);
1123 const double twoB = B+B;
1124 resize_filter->coefficient[0]=1.0-(1.0/3.0)*B;
1125 resize_filter->coefficient[1]=-3.0+twoB+C;
1126 resize_filter->coefficient[2]=2.0-1.5*B-C;
1127 resize_filter->coefficient[3]=(4.0/3.0)*B+4.0*C;
1128 resize_filter->coefficient[4]=-8.0*C-twoB;
1129 resize_filter->coefficient[5]=B+5.0*C;
1130 resize_filter->coefficient[6]=(-1.0/6.0)*B-C;
1137 #if defined(MAGICKCORE_OPENMP_SUPPORT)
1141 artifact=GetImageArtifact(image,
"filter:verbose");
1142 if (IsMagickTrue(artifact) != MagickFalse)
1154 if (resize_filter->filter == Box) filter_type=BoxFilter;
1155 if (resize_filter->filter == Sinc) filter_type=SincFilter;
1156 if (resize_filter->filter == SincFast) filter_type=SincFastFilter;
1157 if (resize_filter->filter == Jinc) filter_type=JincFilter;
1158 if (resize_filter->filter == CubicBC) filter_type=CubicFilter;
1159 if (resize_filter->window == Box) window_type=BoxFilter;
1160 if (resize_filter->window == Sinc) window_type=SincFilter;
1161 if (resize_filter->window == SincFast) window_type=SincFastFilter;
1162 if (resize_filter->window == Jinc) window_type=JincFilter;
1163 if (resize_filter->window == CubicBC) window_type=CubicFilter;
1167 support=GetResizeFilterSupport(resize_filter);
1168 (void) FormatLocaleFile(stdout,
"# Resampling Filter (for graphing)\n#\n");
1169 (void) FormatLocaleFile(stdout,
"# filter = %s\n",
1170 CommandOptionToMnemonic(MagickFilterOptions,filter_type));
1171 (void) FormatLocaleFile(stdout,
"# window = %s\n",
1172 CommandOptionToMnemonic(MagickFilterOptions,window_type));
1173 (void) FormatLocaleFile(stdout,
"# support = %.*g\n",
1174 GetMagickPrecision(),(double) resize_filter->support);
1175 (void) FormatLocaleFile(stdout,
"# window-support = %.*g\n",
1176 GetMagickPrecision(),(double) resize_filter->window_support);
1177 (void) FormatLocaleFile(stdout,
"# scale-blur = %.*g\n",
1178 GetMagickPrecision(), (double)resize_filter->blur);
1179 if ( filter_type == GaussianFilter || window_type == GaussianFilter )
1180 (void) FormatLocaleFile(stdout,
"# gaussian-sigma = %.*g\n",
1181 GetMagickPrecision(), (double)resize_filter->coefficient[0]);
1182 if ( filter_type == KaiserFilter || window_type == KaiserFilter )
1183 (void) FormatLocaleFile(stdout,
"# kaiser-beta = %.*g\n",
1184 GetMagickPrecision(),
1185 (double)resize_filter->coefficient[0]);
1186 (void) FormatLocaleFile(stdout,
"# practical-support = %.*g\n",
1187 GetMagickPrecision(), (double)support);
1188 if ( filter_type == CubicFilter || window_type == CubicFilter )
1189 (void) FormatLocaleFile(stdout,
"# B,C = %.*g,%.*g\n",
1190 GetMagickPrecision(),(double)B, GetMagickPrecision(),(double)C);
1191 (void) FormatLocaleFile(stdout,
"\n");
1196 for (x=0.0; x <= support; x+=0.01f)
1197 (
void) FormatLocaleFile(stdout,
"%5.2lf\t%.*g\n",x,GetMagickPrecision(),
1198 (
double) GetResizeFilterWeight(resize_filter,x));
1200 (void) FormatLocaleFile(stdout,
"%5.2lf\t%.*g\n",support,
1201 GetMagickPrecision(),0.0);
1204 (void) DeleteImageArtifact((
Image *) image,
"filter:verbose");
1205 #if defined(MAGICKCORE_OPENMP_SUPPORT)
1208 return(resize_filter);
1245 MagickExport
Image *AdaptiveResizeImage(
const Image *image,
1246 const size_t columns,
const size_t rows,
ExceptionInfo *exception)
1248 return(InterpolativeResizeImage(image,columns,rows,MeshInterpolatePixel,
1292 static MagickRealType I0(MagickRealType x)
1308 for (i=2; t > MagickEpsilon; i++)
1311 t*=y/((MagickRealType) i*i);
1317 static MagickRealType J1(MagickRealType x)
1329 0.581199354001606143928050809e+21,
1330 -0.6672106568924916298020941484e+20,
1331 0.2316433580634002297931815435e+19,
1332 -0.3588817569910106050743641413e+17,
1333 0.2908795263834775409737601689e+15,
1334 -0.1322983480332126453125473247e+13,
1335 0.3413234182301700539091292655e+10,
1336 -0.4695753530642995859767162166e+7,
1337 0.270112271089232341485679099e+4
1341 0.11623987080032122878585294e+22,
1342 0.1185770712190320999837113348e+20,
1343 0.6092061398917521746105196863e+17,
1344 0.2081661221307607351240184229e+15,
1345 0.5243710262167649715406728642e+12,
1346 0.1013863514358673989967045588e+10,
1347 0.1501793594998585505921097578e+7,
1348 0.1606931573481487801970916749e+4,
1354 for (i=7; i >= 0; i--)
1363 static MagickRealType P1(MagickRealType x)
1375 0.352246649133679798341724373e+5,
1376 0.62758845247161281269005675e+5,
1377 0.313539631109159574238669888e+5,
1378 0.49854832060594338434500455e+4,
1379 0.2111529182853962382105718e+3,
1380 0.12571716929145341558495e+1
1384 0.352246649133679798068390431e+5,
1385 0.626943469593560511888833731e+5,
1386 0.312404063819041039923015703e+5,
1387 0.4930396490181088979386097e+4,
1388 0.2030775189134759322293574e+3,
1394 for (i=4; i >= 0; i--)
1396 p=p*(8.0/x)*(8.0/x)+Pone[i];
1397 q=q*(8.0/x)*(8.0/x)+Qone[i];
1403 static MagickRealType Q1(MagickRealType x)
1415 0.3511751914303552822533318e+3,
1416 0.7210391804904475039280863e+3,
1417 0.4259873011654442389886993e+3,
1418 0.831898957673850827325226e+2,
1419 0.45681716295512267064405e+1,
1420 0.3532840052740123642735e-1
1424 0.74917374171809127714519505e+4,
1425 0.154141773392650970499848051e+5,
1426 0.91522317015169922705904727e+4,
1427 0.18111867005523513506724158e+4,
1428 0.1038187585462133728776636e+3,
1434 for (i=4; i >= 0; i--)
1436 p=p*(8.0/x)*(8.0/x)+Pone[i];
1437 q=q*(8.0/x)*(8.0/x)+Qone[i];
1442 static MagickRealType BesselOrderOne(MagickRealType x)
1455 q=sqrt((
double) (2.0/(MagickPI*x)))*(P1(x)*(1.0/sqrt(2.0)*(sin((
double) x)-
1456 cos((
double) x)))-8.0/x*Q1(x)*(-1.0/sqrt(2.0)*(sin((
double) x)+
1488 assert(resize_filter->signature == MagickCoreSignature);
1489 resize_filter->signature=(~MagickCoreSignature);
1490 resize_filter=(
ResizeFilter *) RelinquishMagickMemory(resize_filter);
1491 return(resize_filter);
1518 MagickExport MagickRealType *GetResizeFilterCoefficient(
1522 assert(resize_filter->signature == MagickCoreSignature);
1523 return((MagickRealType *) resize_filter->coefficient);
1526 MagickExport MagickRealType GetResizeFilterBlur(
1530 assert(resize_filter->signature == MagickCoreSignature);
1531 return(resize_filter->blur);
1534 MagickExport MagickRealType GetResizeFilterScale(
1538 assert(resize_filter->signature == MagickCoreSignature);
1539 return(resize_filter->scale);
1542 MagickExport MagickRealType GetResizeFilterWindowSupport(
1546 assert(resize_filter->signature == MagickCoreSignature);
1547 return(resize_filter->window_support);
1550 MagickExport ResizeWeightingFunctionType GetResizeFilterWeightingType(
1554 assert(resize_filter->signature == MagickCoreSignature);
1555 return(resize_filter->filterWeightingType);
1558 MagickExport ResizeWeightingFunctionType GetResizeFilterWindowWeightingType(
1562 assert(resize_filter->signature == MagickCoreSignature);
1563 return(resize_filter->windowWeightingType);
1566 MagickExport MagickRealType GetResizeFilterSupport(
1570 assert(resize_filter->signature == MagickCoreSignature);
1571 return(resize_filter->support*resize_filter->blur);
1601 MagickExport MagickRealType GetResizeFilterWeight(
1602 const ResizeFilter *resize_filter,
const MagickRealType x)
1613 assert(resize_filter->signature == MagickCoreSignature);
1614 x_blur=fabs((
double) x)*PerceptibleReciprocal(resize_filter->blur);
1615 if ((resize_filter->window_support < MagickEpsilon) ||
1616 (resize_filter->window == Box))
1620 scale=resize_filter->scale;
1621 scale=resize_filter->window(x_blur*scale,resize_filter);
1623 weight=scale*resize_filter->filter(x_blur,resize_filter);
1660 MagickExport
Image *InterpolativeResizeImage(
const Image *image,
1661 const size_t columns,
const size_t rows,
const InterpolatePixelMethod method,
1664 #define InterpolativeResizeImageTag "Resize/Image"
1688 assert(image != (
const Image *) NULL);
1689 assert(image->signature == MagickCoreSignature);
1691 assert(exception->signature == MagickCoreSignature);
1692 if (IsEventLogging() != MagickFalse)
1693 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"%s",image->filename);
1694 if ((columns == 0) || (rows == 0))
1695 return((
Image *) NULL);
1696 if ((columns == image->columns) && (rows == image->rows))
1697 return(CloneImage(image,0,0,MagickTrue,exception));
1698 resize_image=CloneImage(image,columns,rows,MagickTrue,exception);
1699 if (resize_image == (
Image *) NULL)
1700 return((
Image *) NULL);
1701 if (SetImageStorageClass(resize_image,DirectClass) == MagickFalse)
1703 InheritException(exception,&resize_image->exception);
1704 resize_image=DestroyImage(resize_image);
1705 return((
Image *) NULL);
1709 image_view=AcquireVirtualCacheView(image,exception);
1710 resize_view=AcquireAuthenticCacheView(resize_image,exception);
1711 scale.x=(double) image->columns/resize_image->columns;
1712 scale.y=(
double) image->rows/resize_image->rows;
1713 #if defined(MAGICKCORE_OPENMP_SUPPORT)
1714 #pragma omp parallel for schedule(static) shared(progress,status) \
1715 magick_number_threads(image,resize_image,resize_image->rows,1)
1717 for (y=0; y < (ssize_t) resize_image->rows; y++)
1726 *magick_restrict resize_indexes;
1734 if (status == MagickFalse)
1736 q=QueueCacheViewAuthenticPixels(resize_view,0,y,resize_image->columns,1,
1740 resize_indexes=GetCacheViewAuthenticIndexQueue(resize_view);
1741 GetMagickPixelPacket(image,&pixel);
1742 offset.y=((MagickRealType) y+0.5)*scale.y-0.5;
1743 for (x=0; x < (ssize_t) resize_image->columns; x++)
1745 offset.x=((MagickRealType) x+0.5)*scale.x-0.5;
1746 status=InterpolateMagickPixelPacket(image,image_view,method,offset.x,
1747 offset.y,&pixel,exception);
1748 if (status == MagickFalse)
1750 SetPixelPacket(resize_image,&pixel,q,resize_indexes+x);
1753 if (SyncCacheViewAuthenticPixels(resize_view,exception) == MagickFalse)
1755 if (image->progress_monitor != (MagickProgressMonitor) NULL)
1760 #if defined(MAGICKCORE_OPENMP_SUPPORT)
1764 proceed=SetImageProgress(image,InterpolativeResizeImageTag,progress,
1766 if (proceed == MagickFalse)
1770 resize_view=DestroyCacheView(resize_view);
1771 image_view=DestroyCacheView(image_view);
1772 if (status == MagickFalse)
1773 resize_image=DestroyImage(resize_image);
1774 return(resize_image);
1776 #if defined(MAGICKCORE_LQR_DELEGATE)
1812 MagickExport
Image *LiquidRescaleImage(
const Image *image,
const size_t columns,
1813 const size_t rows,
const double delta_x,
const double rigidity,
1816 #define LiquidRescaleImageTag "Rescale/Image"
1855 assert(image != (
const Image *) NULL);
1856 assert(image->signature == MagickCoreSignature);
1858 assert(exception->signature == MagickCoreSignature);
1859 if (IsEventLogging() != MagickFalse)
1860 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"%s",image->filename);
1861 if ((columns == 0) || (rows == 0))
1862 return((
Image *) NULL);
1863 if ((columns == image->columns) && (rows == image->rows))
1864 return(CloneImage(image,0,0,MagickTrue,exception));
1865 if ((columns <= 2) || (rows <= 2))
1866 return(ResizeImage(image,columns,rows,image->filter,image->blur,exception));
1868 if (image->matte != MagickFalse)
1870 if (image->colorspace == CMYKColorspace)
1873 if (image->matte != MagickFalse)
1876 pixel_info=AcquireVirtualMemory(image->columns,image->rows*strlen(map)*
1879 return((
Image *) NULL);
1880 pixels=(
unsigned char *) GetVirtualMemoryBlob(pixel_info);
1881 status=ExportImagePixels(image,0,0,image->columns,image->rows,map,CharPixel,
1883 if (status == MagickFalse)
1885 pixel_info=RelinquishVirtualMemory(pixel_info);
1886 ThrowImageException(ResourceLimitError,
"MemoryAllocationFailed");
1888 carver=lqr_carver_new(pixels,(
int) image->columns,(
int) image->rows,
1890 if (carver == (LqrCarver *) NULL)
1892 pixel_info=RelinquishVirtualMemory(pixel_info);
1893 ThrowImageException(ResourceLimitError,
"MemoryAllocationFailed");
1895 lqr_carver_set_preserve_input_image(carver);
1896 lqr_status=lqr_carver_init(carver,(
int) delta_x,rigidity);
1897 lqr_status=lqr_carver_resize(carver,(
int) columns,(
int) rows);
1899 rescale_image=CloneImage(image,lqr_carver_get_width(carver),
1900 lqr_carver_get_height(carver),MagickTrue,exception);
1901 if (rescale_image == (
Image *) NULL)
1903 pixel_info=RelinquishVirtualMemory(pixel_info);
1904 return((
Image *) NULL);
1906 if (SetImageStorageClass(rescale_image,DirectClass) == MagickFalse)
1908 InheritException(exception,&rescale_image->exception);
1909 rescale_image=DestroyImage(rescale_image);
1910 return((
Image *) NULL);
1912 GetMagickPixelPacket(rescale_image,&pixel);
1913 (void) lqr_carver_scan_reset(carver);
1914 rescale_view=AcquireAuthenticCacheView(rescale_image,exception);
1915 while (lqr_carver_scan(carver,&x,&y,&packet) != 0)
1918 *magick_restrict rescale_indexes;
1923 q=QueueCacheViewAuthenticPixels(rescale_view,x,y,1,1,exception);
1926 rescale_indexes=GetCacheViewAuthenticIndexQueue(rescale_view);
1927 pixel.red=QuantumRange*(packet[0]/255.0);
1928 pixel.green=QuantumRange*(packet[1]/255.0);
1929 pixel.blue=QuantumRange*(packet[2]/255.0);
1930 if (image->colorspace != CMYKColorspace)
1932 if (image->matte != MagickFalse)
1933 pixel.opacity=QuantumRange-QuantumRange*(packet[3]/255.0);
1937 pixel.index=QuantumRange*(packet[3]/255.0);
1938 if (image->matte != MagickFalse)
1939 pixel.opacity=QuantumRange-QuantumRange*(packet[4]/255.0);
1941 SetPixelPacket(rescale_image,&pixel,q,rescale_indexes);
1942 if (SyncCacheViewAuthenticPixels(rescale_view,exception) == MagickFalse)
1945 rescale_view=DestroyCacheView(rescale_view);
1949 pixel_info=RelinquishVirtualMemory(pixel_info);
1950 lqr_carver_destroy(carver);
1951 return(rescale_image);
1954 MagickExport
Image *LiquidRescaleImage(
const Image *image,
1955 const size_t magick_unused(columns),
const size_t magick_unused(rows),
1956 const double magick_unused(delta_x),
const double magick_unused(rigidity),
1959 assert(image != (
const Image *) NULL);
1960 assert(image->signature == MagickCoreSignature);
1962 assert(exception->signature == MagickCoreSignature);
1963 if (IsEventLogging() != MagickFalse)
1964 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"%s",image->filename);
1965 (void) ThrowMagickException(exception,GetMagickModule(),MissingDelegateError,
1966 "DelegateLibrarySupportNotBuiltIn",
"`%s' (LQR)",image->filename);
1967 return((
Image *) NULL);
1998 #define MagnifyImageTag "Magnify/Image"
2019 assert(image != (
const Image *) NULL);
2020 assert(image->signature == MagickCoreSignature);
2022 assert(exception->signature == MagickCoreSignature);
2023 if (IsEventLogging() != MagickFalse)
2024 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"%s",image->filename);
2025 magnify_image=CloneImage(image,2*image->columns,2*image->rows,MagickTrue,
2027 if (magnify_image == (
Image *) NULL)
2028 return((
Image *) NULL);
2034 image_view=AcquireVirtualCacheView(image,exception);
2035 magnify_view=AcquireAuthenticCacheView(magnify_image,exception);
2036 #if defined(MAGICKCORE_OPENMP_SUPPORT)
2037 #pragma omp parallel for schedule(static) shared(progress,status) \
2038 magick_number_threads(image,magnify_image,image->rows,1)
2040 for (y=0; y < (ssize_t) image->rows; y++)
2043 *magick_restrict magnify_indexes;
2051 if (status == MagickFalse)
2053 q=QueueCacheViewAuthenticPixels(magnify_view,0,2*y,magnify_image->columns,2,
2060 magnify_indexes=GetCacheViewAuthenticIndexQueue(magnify_view);
2061 for (x=0; x < (ssize_t) image->columns; x++)
2064 *magick_restrict indexes;
2081 p=GetCacheViewVirtualPixels(image_view,x-1,y-1,3,3,exception);
2087 indexes=GetCacheViewVirtualIndexQueue(image_view);
2088 for (i=0; i < 9; i++)
2089 intensity[i]=GetPixelIntensity(image,p+i);
2091 if ((fabs((
double) (intensity[1]-intensity[7])) < MagickEpsilon) ||
2092 (fabs((
double) (intensity[3]-intensity[5])) < MagickEpsilon))
2100 r+=(magnify_image->columns-1);
2110 if (fabs((
double) (intensity[1]-intensity[3])) < MagickEpsilon)
2115 if (fabs((
double) (intensity[1]-intensity[5])) < MagickEpsilon)
2119 r+=(magnify_image->columns-1);
2120 if (fabs((
double) (intensity[3]-intensity[7])) < MagickEpsilon)
2125 if (fabs((
double) (intensity[5]-intensity[7])) < MagickEpsilon)
2130 if (indexes != (
const IndexPacket *) NULL)
2139 if ((fabs((
double) (intensity[1]-intensity[7])) < MagickEpsilon) ||
2140 (fabs((
double) (intensity[3]-intensity[5])) < MagickEpsilon))
2148 r+=(magnify_image->columns-1);
2158 if (fabs((
double) (intensity[1]-intensity[3])) < MagickEpsilon)
2163 if (fabs((
double) (intensity[1]-intensity[5])) < MagickEpsilon)
2167 r+=(magnify_image->columns-1);
2168 if (fabs((
double) (intensity[3]-intensity[7])) < MagickEpsilon)
2173 if (fabs((
double) (intensity[5]-intensity[7])) < MagickEpsilon)
2182 if (SyncCacheViewAuthenticPixels(magnify_view,exception) == MagickFalse)
2184 if (image->progress_monitor != (MagickProgressMonitor) NULL)
2189 #if defined(MAGICKCORE_OPENMP_SUPPORT)
2193 proceed=SetImageProgress(image,MagnifyImageTag,progress,image->rows);
2194 if (proceed == MagickFalse)
2198 magnify_view=DestroyCacheView(magnify_view);
2199 image_view=DestroyCacheView(image_view);
2200 if (status == MagickFalse)
2201 magnify_image=DestroyImage(magnify_image);
2202 return(magnify_image);
2235 assert(image != (
Image *) NULL);
2236 assert(image->signature == MagickCoreSignature);
2238 assert(exception->signature == MagickCoreSignature);
2239 if (IsEventLogging() != MagickFalse)
2240 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"%s",image->filename);
2241 minify_image=ResizeImage(image,image->columns/2,image->rows/2,SplineFilter,
2243 return(minify_image);
2280 MagickExport
Image *ResampleImage(
const Image *image,
const double x_resolution,
2281 const double y_resolution,
const FilterTypes filter,
const double blur,
2284 #define ResampleImageTag "Resample/Image"
2296 assert(image != (
const Image *) NULL);
2297 assert(image->signature == MagickCoreSignature);
2299 assert(exception->signature == MagickCoreSignature);
2300 if (IsEventLogging() != MagickFalse)
2301 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"%s",image->filename);
2302 width=(size_t) (x_resolution*image->columns/(image->x_resolution == 0.0 ?
2303 DefaultResolution : image->x_resolution)+0.5);
2304 height=(size_t) (y_resolution*image->rows/(image->y_resolution == 0.0 ?
2305 DefaultResolution : image->y_resolution)+0.5);
2306 resample_image=ResizeImage(image,width,height,filter,blur,exception);
2307 if (resample_image != (
Image *) NULL)
2309 resample_image->x_resolution=x_resolution;
2310 resample_image->y_resolution=y_resolution;
2312 return(resample_image);
2374 for (i=0; i < (ssize_t) GetMagickResourceLimit(ThreadResource); i++)
2379 return(contribution);
2393 number_threads=(size_t) GetMagickResourceLimit(ThreadResource);
2395 sizeof(*contribution));
2398 (void) memset(contribution,0,number_threads*
sizeof(*contribution));
2399 for (i=0; i < (ssize_t) number_threads; i++)
2402 AcquireAlignedMemory(count,
sizeof(**contribution)));
2404 return(DestroyContributionTLS(contribution));
2406 return(contribution);
2409 static MagickBooleanType HorizontalFilter(
2411 const Image *magick_restrict image,
Image *magick_restrict resize_image,
2412 const MagickRealType x_factor,
const MagickSizeType span,
2413 MagickOffsetType *magick_restrict offset,
ExceptionInfo *exception)
2415 #define ResizeImageTag "Resize/Image"
2425 **magick_restrict contributions;
2443 scale=MagickMax(1.0/x_factor+MagickEpsilon,1.0);
2444 support=scale*GetResizeFilterSupport(resize_filter);
2445 storage_class=support > 0.5 ? DirectClass : image->storage_class;
2446 if (SetImageStorageClass(resize_image,storage_class) == MagickFalse)
2448 InheritException(exception,&resize_image->exception);
2449 return(MagickFalse);
2457 support=(MagickRealType) 0.5;
2460 contributions=AcquireContributionTLS((
size_t) (2.0*support+3.0));
2463 (void) ThrowMagickException(exception,GetMagickModule(),
2464 ResourceLimitError,
"MemoryAllocationFailed",
"`%s'",image->filename);
2465 return(MagickFalse);
2468 scale=PerceptibleReciprocal(scale);
2469 (void) memset(&zero,0,
sizeof(zero));
2470 image_view=AcquireVirtualCacheView(image,exception);
2471 resize_view=AcquireAuthenticCacheView(resize_image,exception);
2472 #if defined(MAGICKCORE_OPENMP_SUPPORT)
2473 #pragma omp parallel for schedule(static) shared(status,offset) \
2474 magick_number_threads(image,resize_image,resize_image->columns,1)
2476 for (x=0; x < (ssize_t) resize_image->columns; x++)
2479 id = GetOpenMPThreadId();
2486 *magick_restrict indexes;
2492 *magick_restrict contribution;
2495 *magick_restrict resize_indexes;
2508 if (status == MagickFalse)
2510 bisect=(MagickRealType) (x+0.5)/x_factor+MagickEpsilon;
2511 start=(ssize_t) MagickMax(bisect-support+0.5,0.0);
2512 stop=(ssize_t) MagickMin(bisect+support+0.5,(
double) image->columns);
2514 contribution=contributions[id];
2515 for (n=0; n < (stop-start); n++)
2517 contribution[n].pixel=start+n;
2518 contribution[n].weight=GetResizeFilterWeight(resize_filter,scale*
2519 ((MagickRealType) (start+n)-bisect+0.5));
2520 density+=contribution[n].weight;
2524 if ((density != 0.0) && (density != 1.0))
2532 density=PerceptibleReciprocal(density);
2533 for (i=0; i < n; i++)
2534 contribution[i].weight*=density;
2536 p=GetCacheViewVirtualPixels(image_view,contribution[0].pixel,0,(
size_t)
2537 (contribution[n-1].pixel-contribution[0].pixel+1),image->rows,exception);
2538 q=QueueCacheViewAuthenticPixels(resize_view,x,0,1,resize_image->rows,
2545 indexes=GetCacheViewVirtualIndexQueue(image_view);
2546 resize_indexes=GetCacheViewAuthenticIndexQueue(resize_view);
2547 for (y=0; y < (ssize_t) resize_image->rows; y++)
2562 if (image->matte == MagickFalse)
2564 for (i=0; i < n; i++)
2566 j=y*(contribution[n-1].pixel-contribution[0].pixel+1)+
2567 (contribution[i].pixel-contribution[0].pixel);
2568 alpha=contribution[i].weight;
2569 pixel.red+=alpha*GetPixelRed(p+j);
2570 pixel.green+=alpha*GetPixelGreen(p+j);
2571 pixel.blue+=alpha*GetPixelBlue(p+j);
2572 pixel.opacity+=alpha*GetPixelOpacity(p+j);
2574 SetPixelRed(q,ClampToQuantum(pixel.red));
2575 SetPixelGreen(q,ClampToQuantum(pixel.green));
2576 SetPixelBlue(q,ClampToQuantum(pixel.blue));
2577 SetPixelOpacity(q,ClampToQuantum(pixel.opacity));
2578 if ((image->colorspace == CMYKColorspace) &&
2579 (resize_image->colorspace == CMYKColorspace))
2581 for (i=0; i < n; i++)
2583 j=y*(contribution[n-1].pixel-contribution[0].pixel+1)+
2584 (contribution[i].pixel-contribution[0].pixel);
2585 alpha=contribution[i].weight;
2586 pixel.index+=alpha*GetPixelIndex(indexes+j);
2588 SetPixelIndex(resize_indexes+y,ClampToQuantum(pixel.index));
2597 for (i=0; i < n; i++)
2599 j=y*(contribution[n-1].pixel-contribution[0].pixel+1)+
2600 (contribution[i].pixel-contribution[0].pixel);
2601 alpha=contribution[i].weight*QuantumScale*GetPixelAlpha(p+j);
2602 pixel.red+=alpha*GetPixelRed(p+j);
2603 pixel.green+=alpha*GetPixelGreen(p+j);
2604 pixel.blue+=alpha*GetPixelBlue(p+j);
2605 pixel.opacity+=contribution[i].weight*GetPixelOpacity(p+j);
2608 gamma=PerceptibleReciprocal(gamma);
2609 SetPixelRed(q,ClampToQuantum(gamma*pixel.red));
2610 SetPixelGreen(q,ClampToQuantum(gamma*pixel.green));
2611 SetPixelBlue(q,ClampToQuantum(gamma*pixel.blue));
2612 SetPixelOpacity(q,ClampToQuantum(pixel.opacity));
2613 if ((image->colorspace == CMYKColorspace) &&
2614 (resize_image->colorspace == CMYKColorspace))
2616 for (i=0; i < n; i++)
2618 j=y*(contribution[n-1].pixel-contribution[0].pixel+1)+
2619 (contribution[i].pixel-contribution[0].pixel);
2620 alpha=contribution[i].weight*QuantumScale*GetPixelAlpha(p+j);
2621 pixel.index+=alpha*GetPixelIndex(indexes+j);
2623 SetPixelIndex(resize_indexes+y,ClampToQuantum(gamma*pixel.index));
2626 if ((resize_image->storage_class == PseudoClass) &&
2627 (image->storage_class == PseudoClass))
2629 i=(ssize_t) (MagickMin(MagickMax(bisect,(
double) start),(
double) stop-
2631 j=y*(contribution[n-1].pixel-contribution[0].pixel+1)+
2632 (contribution[i-start].pixel-contribution[0].pixel);
2633 SetPixelIndex(resize_indexes+y,GetPixelIndex(indexes+j));
2637 if (SyncCacheViewAuthenticPixels(resize_view,exception) == MagickFalse)
2639 if (image->progress_monitor != (MagickProgressMonitor) NULL)
2644 #if defined(MAGICKCORE_OPENMP_SUPPORT)
2648 proceed=SetImageProgress(image,ResizeImageTag,*offset,span);
2649 if (proceed == MagickFalse)
2653 resize_view=DestroyCacheView(resize_view);
2654 image_view=DestroyCacheView(image_view);
2655 contributions=DestroyContributionTLS(contributions);
2659 static MagickBooleanType VerticalFilter(
2661 const Image *magick_restrict image,
Image *magick_restrict resize_image,
2662 const MagickRealType y_factor,
const MagickSizeType span,
2663 MagickOffsetType *magick_restrict offset,
ExceptionInfo *exception)
2673 **magick_restrict contributions;
2691 scale=MagickMax(1.0/y_factor+MagickEpsilon,1.0);
2692 support=scale*GetResizeFilterSupport(resize_filter);
2693 storage_class=support > 0.5 ? DirectClass : image->storage_class;
2694 if (SetImageStorageClass(resize_image,storage_class) == MagickFalse)
2696 InheritException(exception,&resize_image->exception);
2697 return(MagickFalse);
2705 support=(MagickRealType) 0.5;
2708 contributions=AcquireContributionTLS((
size_t) (2.0*support+3.0));
2711 (void) ThrowMagickException(exception,GetMagickModule(),
2712 ResourceLimitError,
"MemoryAllocationFailed",
"`%s'",image->filename);
2713 return(MagickFalse);
2716 scale=PerceptibleReciprocal(scale);
2717 (void) memset(&zero,0,
sizeof(zero));
2718 image_view=AcquireVirtualCacheView(image,exception);
2719 resize_view=AcquireAuthenticCacheView(resize_image,exception);
2720 #if defined(MAGICKCORE_OPENMP_SUPPORT)
2721 #pragma omp parallel for schedule(static) shared(status,offset) \
2722 magick_number_threads(image,resize_image,resize_image->rows,1)
2724 for (y=0; y < (ssize_t) resize_image->rows; y++)
2727 id = GetOpenMPThreadId();
2734 *magick_restrict indexes;
2740 *magick_restrict contribution;
2743 *magick_restrict resize_indexes;
2756 if (status == MagickFalse)
2758 bisect=(MagickRealType) (y+0.5)/y_factor+MagickEpsilon;
2759 start=(ssize_t) MagickMax(bisect-support+0.5,0.0);
2760 stop=(ssize_t) MagickMin(bisect+support+0.5,(
double) image->rows);
2762 contribution=contributions[id];
2763 for (n=0; n < (stop-start); n++)
2765 contribution[n].pixel=start+n;
2766 contribution[n].weight=GetResizeFilterWeight(resize_filter,scale*
2767 ((MagickRealType) (start+n)-bisect+0.5));
2768 density+=contribution[n].weight;
2772 if ((density != 0.0) && (density != 1.0))
2780 density=PerceptibleReciprocal(density);
2781 for (i=0; i < n; i++)
2782 contribution[i].weight*=density;
2784 p=GetCacheViewVirtualPixels(image_view,0,contribution[0].pixel,
2785 image->columns,(
size_t) (contribution[n-1].pixel-contribution[0].pixel+1),
2787 q=QueueCacheViewAuthenticPixels(resize_view,0,y,resize_image->columns,1,
2794 indexes=GetCacheViewVirtualIndexQueue(image_view);
2795 resize_indexes=GetCacheViewAuthenticIndexQueue(resize_view);
2796 for (x=0; x < (ssize_t) resize_image->columns; x++)
2811 if (image->matte == MagickFalse)
2813 for (i=0; i < n; i++)
2815 j=(ssize_t) ((contribution[i].pixel-contribution[0].pixel)*
2817 alpha=contribution[i].weight;
2818 pixel.red+=alpha*GetPixelRed(p+j);
2819 pixel.green+=alpha*GetPixelGreen(p+j);
2820 pixel.blue+=alpha*GetPixelBlue(p+j);
2821 pixel.opacity+=alpha*GetPixelOpacity(p+j);
2823 SetPixelRed(q,ClampToQuantum(pixel.red));
2824 SetPixelGreen(q,ClampToQuantum(pixel.green));
2825 SetPixelBlue(q,ClampToQuantum(pixel.blue));
2826 SetPixelOpacity(q,ClampToQuantum(pixel.opacity));
2827 if ((image->colorspace == CMYKColorspace) &&
2828 (resize_image->colorspace == CMYKColorspace))
2830 for (i=0; i < n; i++)
2832 j=(ssize_t) ((contribution[i].pixel-contribution[0].pixel)*
2834 alpha=contribution[i].weight;
2835 pixel.index+=alpha*GetPixelIndex(indexes+j);
2837 SetPixelIndex(resize_indexes+x,ClampToQuantum(pixel.index));
2846 for (i=0; i < n; i++)
2848 j=(ssize_t) ((contribution[i].pixel-contribution[0].pixel)*
2850 alpha=contribution[i].weight*QuantumScale*GetPixelAlpha(p+j);
2851 pixel.red+=alpha*GetPixelRed(p+j);
2852 pixel.green+=alpha*GetPixelGreen(p+j);
2853 pixel.blue+=alpha*GetPixelBlue(p+j);
2854 pixel.opacity+=contribution[i].weight*GetPixelOpacity(p+j);
2857 gamma=PerceptibleReciprocal(gamma);
2858 SetPixelRed(q,ClampToQuantum(gamma*pixel.red));
2859 SetPixelGreen(q,ClampToQuantum(gamma*pixel.green));
2860 SetPixelBlue(q,ClampToQuantum(gamma*pixel.blue));
2861 SetPixelOpacity(q,ClampToQuantum(pixel.opacity));
2862 if ((image->colorspace == CMYKColorspace) &&
2863 (resize_image->colorspace == CMYKColorspace))
2865 for (i=0; i < n; i++)
2867 j=(ssize_t) ((contribution[i].pixel-contribution[0].pixel)*
2869 alpha=contribution[i].weight*QuantumScale*GetPixelAlpha(p+j);
2870 pixel.index+=alpha*GetPixelIndex(indexes+j);
2872 SetPixelIndex(resize_indexes+x,ClampToQuantum(gamma*pixel.index));
2875 if ((resize_image->storage_class == PseudoClass) &&
2876 (image->storage_class == PseudoClass))
2878 i=(ssize_t) (MagickMin(MagickMax(bisect,(
double) start),(
double) stop-
2880 j=(ssize_t) ((contribution[i-start].pixel-contribution[0].pixel)*
2882 SetPixelIndex(resize_indexes+x,GetPixelIndex(indexes+j));
2886 if (SyncCacheViewAuthenticPixels(resize_view,exception) == MagickFalse)
2888 if (image->progress_monitor != (MagickProgressMonitor) NULL)
2893 #if defined(MAGICKCORE_OPENMP_SUPPORT)
2897 proceed=SetImageProgress(image,ResizeImageTag,*offset,span);
2898 if (proceed == MagickFalse)
2902 resize_view=DestroyCacheView(resize_view);
2903 image_view=DestroyCacheView(image_view);
2904 contributions=DestroyContributionTLS(contributions);
2908 MagickExport
Image *ResizeImage(
const Image *image,
const size_t columns,
2909 const size_t rows,
const FilterTypes filter,
const double blur,
2938 assert(image != (
Image *) NULL);
2939 assert(image->signature == MagickCoreSignature);
2941 assert(exception->signature == MagickCoreSignature);
2942 if (IsEventLogging() != MagickFalse)
2943 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"%s",image->filename);
2944 if ((columns == 0) || (rows == 0))
2945 ThrowImageException(ImageError,
"NegativeOrZeroImageSize");
2946 if ((columns == image->columns) && (rows == image->rows) &&
2947 (filter == UndefinedFilter) && (blur == 1.0))
2948 return(CloneImage(image,0,0,MagickTrue,exception));
2953 x_factor=(MagickRealType) (columns*
2954 PerceptibleReciprocal((
double) image->columns));
2955 y_factor=(MagickRealType) (rows*
2956 PerceptibleReciprocal((
double) image->rows));
2957 filter_type=LanczosFilter;
2958 if (filter != UndefinedFilter)
2961 if ((x_factor == 1.0) && (y_factor == 1.0))
2962 filter_type=PointFilter;
2964 if ((image->storage_class == PseudoClass) ||
2965 (image->matte != MagickFalse) || ((x_factor*y_factor) > 1.0))
2966 filter_type=MitchellFilter;
2967 resize_filter=AcquireResizeFilter(image,filter_type,blur,MagickFalse,
2969 #if defined(MAGICKCORE_OPENCL_SUPPORT)
2970 resize_image=AccelerateResizeImage(image,columns,rows,resize_filter,
2972 if (resize_image != NULL)
2974 resize_filter=DestroyResizeFilter(resize_filter);
2975 return(resize_image);
2978 resize_image=CloneImage(image,columns,rows,MagickTrue,exception);
2979 if (resize_image == (
Image *) NULL)
2981 resize_filter=DestroyResizeFilter(resize_filter);
2982 return(resize_image);
2984 if (x_factor > y_factor)
2985 filter_image=CloneImage(image,columns,image->rows,MagickTrue,exception);
2987 filter_image=CloneImage(image,image->columns,rows,MagickTrue,exception);
2988 if (filter_image == (
Image *) NULL)
2990 resize_filter=DestroyResizeFilter(resize_filter);
2991 return(DestroyImage(resize_image));
2997 if (x_factor > y_factor)
2999 span=(MagickSizeType) (filter_image->columns+rows);
3000 status=HorizontalFilter(resize_filter,image,filter_image,x_factor,span,
3002 status&=VerticalFilter(resize_filter,filter_image,resize_image,y_factor,
3003 span,&offset,exception);
3007 span=(MagickSizeType) (filter_image->rows+columns);
3008 status=VerticalFilter(resize_filter,image,filter_image,y_factor,span,
3010 status&=HorizontalFilter(resize_filter,filter_image,resize_image,x_factor,
3011 span,&offset,exception);
3016 filter_image=DestroyImage(filter_image);
3017 resize_filter=DestroyResizeFilter(resize_filter);
3018 if (status == MagickFalse)
3020 resize_image=DestroyImage(resize_image);
3021 return((
Image *) NULL);
3023 resize_image->type=image->type;
3024 return(resize_image);
3058 MagickExport
Image *SampleImage(
const Image *image,
const size_t columns,
3061 #define SampleImageTag "Sample/Image"
3089 assert(image != (
const Image *) NULL);
3090 assert(image->signature == MagickCoreSignature);
3092 assert(exception->signature == MagickCoreSignature);
3093 if (IsEventLogging() != MagickFalse)
3094 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"%s",image->filename);
3095 if ((columns == 0) || (rows == 0))
3096 ThrowImageException(ImageError,
"NegativeOrZeroImageSize");
3097 if ((columns == image->columns) && (rows == image->rows))
3098 return(CloneImage(image,0,0,MagickTrue,exception));
3099 sample_image=CloneImage(image,columns,rows,MagickTrue,exception);
3100 if (sample_image == (
Image *) NULL)
3101 return((
Image *) NULL);
3106 sample_offset.x=sample_offset.y=0.5-MagickEpsilon;
3111 value=GetImageArtifact(image,
"sample:offset");
3112 if (value != (
char *) NULL)
3119 (void) ParseGeometry(value,&geometry_info);
3120 flags=ParseGeometry(value,&geometry_info);
3121 sample_offset.x=sample_offset.y=geometry_info.rho/100.0-MagickEpsilon;
3122 if ((flags & SigmaValue) != 0)
3123 sample_offset.y=geometry_info.sigma/100.0-MagickEpsilon;
3129 x_offset=(ssize_t *) AcquireQuantumMemory((
size_t) sample_image->columns,
3131 if (x_offset == (ssize_t *) NULL)
3133 sample_image=DestroyImage(sample_image);
3134 ThrowImageException(ResourceLimitError,
"MemoryAllocationFailed");
3136 for (x=0; x < (ssize_t) sample_image->columns; x++)
3137 x_offset[x]=(ssize_t) ((((
double) x+sample_offset.x)*image->columns)/
3138 sample_image->columns);
3144 image_view=AcquireVirtualCacheView(image,exception);
3145 sample_view=AcquireAuthenticCacheView(sample_image,exception);
3146 #if defined(MAGICKCORE_OPENMP_SUPPORT)
3147 #pragma omp parallel for schedule(static) shared(status) \
3148 magick_number_threads(image,sample_image,sample_image->rows,1)
3150 for (y=0; y < (ssize_t) sample_image->rows; y++)
3153 *magick_restrict indexes;
3159 *magick_restrict sample_indexes;
3170 if (status == MagickFalse)
3172 y_offset=(ssize_t) ((((
double) y+sample_offset.y)*image->rows)/
3173 sample_image->rows);
3174 p=GetCacheViewVirtualPixels(image_view,0,y_offset,image->columns,1,
3176 q=QueueCacheViewAuthenticPixels(sample_view,0,y,sample_image->columns,1,
3183 indexes=GetCacheViewAuthenticIndexQueue(image_view);
3184 sample_indexes=GetCacheViewAuthenticIndexQueue(sample_view);
3188 for (x=0; x < (ssize_t) sample_image->columns; x++)
3189 *q++=p[x_offset[x]];
3190 if ((image->storage_class == PseudoClass) ||
3191 (image->colorspace == CMYKColorspace))
3192 for (x=0; x < (ssize_t) sample_image->columns; x++)
3193 SetPixelIndex(sample_indexes+x,GetPixelIndex(indexes+x_offset[x]));
3194 if (SyncCacheViewAuthenticPixels(sample_view,exception) == MagickFalse)
3196 if (image->progress_monitor != (MagickProgressMonitor) NULL)
3201 #if defined(MAGICKCORE_OPENMP_SUPPORT)
3205 proceed=SetImageProgress(image,SampleImageTag,progress,image->rows);
3206 if (proceed == MagickFalse)
3210 image_view=DestroyCacheView(image_view);
3211 sample_view=DestroyCacheView(sample_view);
3212 x_offset=(ssize_t *) RelinquishMagickMemory(x_offset);
3213 sample_image->type=image->type;
3214 if (status == MagickFalse)
3215 sample_image=DestroyImage(sample_image);
3216 return(sample_image);
3248 MagickExport
Image *ScaleImage(
const Image *image,
const size_t columns,
3251 #define ScaleImageTag "Scale/Image"
3291 assert(image != (
const Image *) NULL);
3292 assert(image->signature == MagickCoreSignature);
3294 assert(exception->signature == MagickCoreSignature);
3295 if (IsEventLogging() != MagickFalse)
3296 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"%s",image->filename);
3297 if ((columns == 0) || (rows == 0))
3298 return((
Image *) NULL);
3299 if ((columns == image->columns) && (rows == image->rows))
3300 return(CloneImage(image,0,0,MagickTrue,exception));
3301 scale_image=CloneImage(image,columns,rows,MagickTrue,exception);
3302 if (scale_image == (
Image *) NULL)
3303 return((
Image *) NULL);
3304 if (SetImageStorageClass(scale_image,DirectClass) == MagickFalse)
3306 InheritException(exception,&scale_image->exception);
3307 scale_image=DestroyImage(scale_image);
3308 return((
Image *) NULL);
3316 if (image->rows != scale_image->rows)
3320 scale_image->columns,
sizeof(*scale_scanline));
3328 if ((image->rows != scale_image->rows) &&
3338 scale_image=DestroyImage(scale_image);
3339 ThrowImageException(ResourceLimitError,
"MemoryAllocationFailed");
3345 next_row=MagickTrue;
3347 scale.y=(double) scale_image->rows/(
double) image->rows;
3348 (void) memset(y_vector,0,(
size_t) image->columns*
3350 GetMagickPixelPacket(image,&pixel);
3351 (void) memset(&zero,0,
sizeof(zero));
3354 image_view=AcquireVirtualCacheView(image,exception);
3355 scale_view=AcquireAuthenticCacheView(scale_image,exception);
3356 for (y=0; y < (ssize_t) scale_image->rows; y++)
3359 *magick_restrict indexes;
3365 *magick_restrict scale_indexes;
3377 if (status == MagickFalse)
3379 q=QueueCacheViewAuthenticPixels(scale_view,0,y,scale_image->columns,1,
3387 scale_indexes=GetCacheViewAuthenticIndexQueue(scale_view);
3388 if (scale_image->rows == image->rows)
3393 p=GetCacheViewVirtualPixels(image_view,0,i++,image->columns,1,
3400 indexes=GetCacheViewVirtualIndexQueue(image_view);
3401 for (x=0; x < (ssize_t) image->columns; x++)
3403 if (image->matte != MagickFalse)
3404 alpha=QuantumScale*GetPixelAlpha(p);
3405 x_vector[x].red=(MagickRealType) (alpha*GetPixelRed(p));
3406 x_vector[x].green=(MagickRealType) (alpha*GetPixelGreen(p));
3407 x_vector[x].blue=(MagickRealType) (alpha*GetPixelBlue(p));
3408 if (image->matte != MagickFalse)
3409 x_vector[x].opacity=(MagickRealType) GetPixelOpacity(p);
3410 if (indexes != (IndexPacket *) NULL)
3411 x_vector[x].index=(MagickRealType) (alpha*GetPixelIndex(indexes+x));
3420 while (scale.y < span.y)
3422 if ((next_row != MagickFalse) &&
3423 (number_rows < (ssize_t) image->rows))
3428 p=GetCacheViewVirtualPixels(image_view,0,i++,image->columns,1,
3435 indexes=GetCacheViewVirtualIndexQueue(image_view);
3436 for (x=0; x < (ssize_t) image->columns; x++)
3438 if (image->matte != MagickFalse)
3439 alpha=QuantumScale*GetPixelAlpha(p);
3440 x_vector[x].red=(MagickRealType) (alpha*GetPixelRed(p));
3441 x_vector[x].green=(MagickRealType) (alpha*GetPixelGreen(p));
3442 x_vector[x].blue=(MagickRealType) (alpha*GetPixelBlue(p));
3443 if (image->matte != MagickFalse)
3444 x_vector[x].opacity=(MagickRealType) GetPixelOpacity(p);
3445 if (indexes != (IndexPacket *) NULL)
3446 x_vector[x].index=(MagickRealType) (alpha*
3447 GetPixelIndex(indexes+x));
3452 for (x=0; x < (ssize_t) image->columns; x++)
3454 y_vector[x].red+=scale.y*x_vector[x].red;
3455 y_vector[x].green+=scale.y*x_vector[x].green;
3456 y_vector[x].blue+=scale.y*x_vector[x].blue;
3457 if (scale_image->matte != MagickFalse)
3458 y_vector[x].opacity+=scale.y*x_vector[x].opacity;
3459 if (scale_indexes != (IndexPacket *) NULL)
3460 y_vector[x].index+=scale.y*x_vector[x].index;
3463 scale.y=(double) scale_image->rows/(
double) image->rows;
3464 next_row=MagickTrue;
3466 if ((next_row != MagickFalse) && (number_rows < (ssize_t) image->rows))
3471 p=GetCacheViewVirtualPixels(image_view,0,i++,image->columns,1,
3478 indexes=GetCacheViewVirtualIndexQueue(image_view);
3479 for (x=0; x < (ssize_t) image->columns; x++)
3481 if (image->matte != MagickFalse)
3482 alpha=QuantumScale*GetPixelAlpha(p);
3483 x_vector[x].red=(MagickRealType) (alpha*GetPixelRed(p));
3484 x_vector[x].green=(MagickRealType) (alpha*GetPixelGreen(p));
3485 x_vector[x].blue=(MagickRealType) (alpha*GetPixelBlue(p));
3486 if (image->matte != MagickFalse)
3487 x_vector[x].opacity=(MagickRealType) GetPixelOpacity(p);
3488 if (indexes != (IndexPacket *) NULL)
3489 x_vector[x].index=(MagickRealType) (alpha*
3490 GetPixelIndex(indexes+x));
3494 next_row=MagickFalse;
3497 for (x=0; x < (ssize_t) image->columns; x++)
3499 pixel.red=y_vector[x].red+span.y*x_vector[x].red;
3500 pixel.green=y_vector[x].green+span.y*x_vector[x].green;
3501 pixel.blue=y_vector[x].blue+span.y*x_vector[x].blue;
3502 if (image->matte != MagickFalse)
3503 pixel.opacity=y_vector[x].opacity+span.y*x_vector[x].opacity;
3504 if (scale_indexes != (IndexPacket *) NULL)
3505 pixel.index=y_vector[x].index+span.y*x_vector[x].index;
3507 s->green=pixel.green;
3509 if (scale_image->matte != MagickFalse)
3510 s->opacity=pixel.opacity;
3511 if (scale_indexes != (IndexPacket *) NULL)
3512 s->index=pixel.index;
3519 scale.y=(double) scale_image->rows/(
double) image->rows;
3520 next_row=MagickTrue;
3524 if (scale_image->columns == image->columns)
3530 for (x=0; x < (ssize_t) scale_image->columns; x++)
3532 if (scale_image->matte != MagickFalse)
3533 alpha=QuantumScale*GetPixelAlpha(s);
3534 alpha=PerceptibleReciprocal(alpha);
3535 SetPixelRed(q,ClampToQuantum(alpha*s->red));
3536 SetPixelGreen(q,ClampToQuantum(alpha*s->green));
3537 SetPixelBlue(q,ClampToQuantum(alpha*s->blue));
3538 if (scale_image->matte != MagickFalse)
3539 SetPixelOpacity(q,ClampToQuantum(s->opacity));
3540 if (scale_indexes != (IndexPacket *) NULL)
3541 SetPixelIndex(scale_indexes+x,ClampToQuantum(alpha*s->index));
3552 next_column=MagickFalse;
3556 for (x=0; x < (ssize_t) image->columns; x++)
3558 scale.x=(double) scale_image->columns/(
double) image->columns;
3559 while (scale.x >= span.x)
3561 if (next_column != MagickFalse)
3566 pixel.red+=span.x*s->red;
3567 pixel.green+=span.x*s->green;
3568 pixel.blue+=span.x*s->blue;
3569 if (image->matte != MagickFalse)
3570 pixel.opacity+=span.x*s->opacity;
3571 if (scale_indexes != (IndexPacket *) NULL)
3572 pixel.index+=span.x*s->index;
3574 t->green=pixel.green;
3576 if (scale_image->matte != MagickFalse)
3577 t->opacity=pixel.opacity;
3578 if (scale_indexes != (IndexPacket *) NULL)
3579 t->index=pixel.index;
3582 next_column=MagickTrue;
3586 if (next_column != MagickFalse)
3589 next_column=MagickFalse;
3592 pixel.red+=scale.x*s->red;
3593 pixel.green+=scale.x*s->green;
3594 pixel.blue+=scale.x*s->blue;
3595 if (scale_image->matte != MagickFalse)
3596 pixel.opacity+=scale.x*s->opacity;
3597 if (scale_indexes != (IndexPacket *) NULL)
3598 pixel.index+=scale.x*s->index;
3606 pixel.red+=span.x*s->red;
3607 pixel.green+=span.x*s->green;
3608 pixel.blue+=span.x*s->blue;
3609 if (scale_image->matte != MagickFalse)
3610 pixel.opacity+=span.x*s->opacity;
3611 if (scale_indexes != (IndexPacket *) NULL)
3612 pixel.index+=span.x*s->index;
3614 if ((next_column == MagickFalse) &&
3615 ((ssize_t) (t-scale_scanline) < (ssize_t) scale_image->columns))
3618 t->green=pixel.green;
3620 if (scale_image->matte != MagickFalse)
3621 t->opacity=pixel.opacity;
3622 if (scale_indexes != (IndexPacket *) NULL)
3623 t->index=pixel.index;
3629 for (x=0; x < (ssize_t) scale_image->columns; x++)
3631 if (scale_image->matte != MagickFalse)
3632 alpha=QuantumScale*GetPixelAlpha(t);
3633 alpha=PerceptibleReciprocal(alpha);
3634 SetPixelRed(q,ClampToQuantum(alpha*t->red));
3635 SetPixelGreen(q,ClampToQuantum(alpha*t->green));
3636 SetPixelBlue(q,ClampToQuantum(alpha*t->blue));
3637 if (scale_image->matte != MagickFalse)
3638 SetPixelOpacity(q,ClampToQuantum(t->opacity));
3639 if (scale_indexes != (IndexPacket *) NULL)
3640 SetPixelIndex(scale_indexes+x,ClampToQuantum(alpha*t->index));
3645 if (SyncCacheViewAuthenticPixels(scale_view,exception) == MagickFalse)
3650 proceed=SetImageProgress(image,ScaleImageTag,(MagickOffsetType) y,
3652 if (proceed == MagickFalse)
3658 scale_view=DestroyCacheView(scale_view);
3659 image_view=DestroyCacheView(image_view);
3665 if (scale_image->rows != image->rows)
3668 scale_image->type=image->type;
3669 if (status == MagickFalse)
3670 scale_image=DestroyImage(scale_image);
3671 return(scale_image);
3705 MagickExport
Image *ThumbnailImage(
const Image *image,
const size_t columns,
3708 #define SampleFactor 5
3711 filename[MaxTextExtent],
3712 value[MaxTextExtent];
3723 assert(image != (
Image *) NULL);
3724 assert(image->signature == MagickCoreSignature);
3726 assert(exception->signature == MagickCoreSignature);
3727 if (IsEventLogging() != MagickFalse)
3728 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"%s",image->filename);
3729 thumbnail_image=CloneImage(image,0,0,MagickTrue,exception);
3730 if (thumbnail_image == (
Image *) NULL)
3731 return(thumbnail_image);
3732 if ((columns != image->columns) || (rows != image->rows))
3735 *clone_image = thumbnail_image;
3741 x_factor=(ssize_t) image->columns/columns;
3742 y_factor=(ssize_t) image->rows/rows;
3743 if ((x_factor > 4) && (y_factor > 4))
3745 thumbnail_image=SampleImage(clone_image,4*columns,4*rows,exception);
3746 if (thumbnail_image != (
Image *) NULL)
3748 clone_image=DestroyImage(clone_image);
3749 clone_image=thumbnail_image;
3752 if ((x_factor > 2) && (y_factor > 2))
3754 thumbnail_image=ResizeImage(clone_image,2*columns,2*rows,BoxFilter,
3756 if (thumbnail_image != (
Image *) NULL)
3758 clone_image=DestroyImage(clone_image);
3759 clone_image=thumbnail_image;
3762 thumbnail_image=ResizeImage(clone_image,columns,rows,image->filter ==
3763 UndefinedFilter ? LanczosSharpFilter : image->filter,1.0,exception);
3764 clone_image=DestroyImage(clone_image);
3765 if (thumbnail_image == (
Image *) NULL)
3766 return(thumbnail_image);
3768 (void) ParseAbsoluteGeometry(
"0x0+0+0",&thumbnail_image->page);
3769 thumbnail_image->depth=8;
3770 thumbnail_image->interlace=NoInterlace;
3774 ResetImageProfileIterator(thumbnail_image);
3775 for (name=GetNextImageProfile(thumbnail_image); name != (
const char *) NULL; )
3777 if ((LocaleCompare(name,
"icc") != 0) && (LocaleCompare(name,
"icm") != 0))
3779 (void) DeleteImageProfile(thumbnail_image,name);
3780 ResetImageProfileIterator(thumbnail_image);
3782 name=GetNextImageProfile(thumbnail_image);
3784 (void) DeleteImageProperty(thumbnail_image,
"comment");
3785 (void) CopyMagickString(value,image->magick_filename,MaxTextExtent);
3786 if (strstr(image->magick_filename,
"//") == (
char *) NULL)
3787 (void) FormatLocaleString(value,MaxTextExtent,
"file://%s",
3788 image->magick_filename);
3789 (void) SetImageProperty(thumbnail_image,
"Thumb::URI",value);
3790 GetPathComponent(image->magick_filename,TailPath,filename);
3791 (void) CopyMagickString(value,filename,MaxTextExtent);
3792 if (GetPathAttributes(image->filename,&attributes) != MagickFalse)
3794 (void) FormatLocaleString(value,MaxTextExtent,
"%.20g",(
double)
3795 attributes.st_mtime);
3796 (void) SetImageProperty(thumbnail_image,
"Thumb::MTime",value);
3798 (void) FormatLocaleString(value,MaxTextExtent,
"%.20g",(
double)
3799 attributes.st_mtime);
3800 (void) FormatMagickSize(GetBlobSize(image),MagickFalse,value);
3801 (void) ConcatenateMagickString(value,
"B",MaxTextExtent);
3802 (void) SetImageProperty(thumbnail_image,
"Thumb::Size",value);
3803 (void) FormatLocaleString(value,MaxTextExtent,
"image/%s",image->magick);
3805 (void) SetImageProperty(thumbnail_image,
"Thumb::Mimetype",value);
3806 (void) SetImageProperty(thumbnail_image,
"software",MagickAuthoritativeURL);
3807 (void) FormatLocaleString(value,MaxTextExtent,
"%.20g",(
double)
3808 image->magick_columns);
3809 (void) SetImageProperty(thumbnail_image,
"Thumb::Image::Width",value);
3810 (void) FormatLocaleString(value,MaxTextExtent,
"%.20g",(
double)
3811 image->magick_rows);
3812 (void) SetImageProperty(thumbnail_image,
"Thumb::Image::Height",value);
3813 (void) FormatLocaleString(value,MaxTextExtent,
"%.20g",(
double)
3814 GetImageListLength(image));
3815 (void) SetImageProperty(thumbnail_image,
"Thumb::Document::Pages",value);
3816 return(thumbnail_image);