131 #define AdaptiveBlurImageTag "Convolve/Image" 132 #define MagickSigma (fabs(sigma) < MagickEpsilon ? MagickEpsilon : sigma) 161 assert(image != (
const Image *) NULL);
168 if (blur_image == (
Image *) NULL)
169 return((
Image *) NULL);
175 return((
Image *) NULL);
180 edge_image=
EdgeImage(image,radius,exception);
181 if (edge_image == (
Image *) NULL)
184 return((
Image *) NULL);
187 gaussian_image=
BlurImage(edge_image,radius,sigma,exception);
188 if (gaussian_image != (
Image *) NULL)
191 edge_image=gaussian_image;
200 if (kernel == (
double **) NULL)
206 (void) memset(kernel,0,(
size_t) width*
sizeof(*kernel));
207 for (w=0; w < (ssize_t) width; w+=2)
216 (
size_t) (width-w),(width-w)*
sizeof(**kernel)));
217 if (kernel[w] == (
double *) NULL)
220 j=(ssize_t) (width-w-1)/2;
222 for (v=(-j); v <= j; v++)
224 for (u=(-j); u <= j; u++)
226 kernel[w][k]=(double) (exp(-((
double) u*u+v*v)/(2.0*
MagickSigma*
228 normalize+=kernel[w][k];
232 kernel[w][(k-1)/2]+=(
double) (1.0-normalize);
234 kernel[w][(k-1)/2]=1.0;
236 if (w < (ssize_t) width)
238 for (w-=2; w >= 0; w-=2)
253 #if defined(MAGICKCORE_OPENMP_SUPPORT) 254 #pragma omp parallel for schedule(static) shared(progress,status) \ 255 magick_number_threads(image,blur_image,blur_image->rows,1) 257 for (y=0; y < (ssize_t) blur_image->
rows; y++)
278 for (x=0; x < (ssize_t) blur_image->
columns; x++)
295 if (j > (ssize_t) width)
300 (ssize_t) ((width-j)/2L),width-j,width-j,exception);
301 if (p == (
const Quantum *) NULL)
351 for (v=0; v < (ssize_t) (width-j); v++)
353 for (u=0; u < (ssize_t) (width-j); u++)
355 pixel+=(*k)*pixels[i];
368 for (v=0; v < (ssize_t) (width-j); v++)
370 for (u=0; u < (ssize_t) (width-j); u++)
373 pixel+=(*k)*alpha*pixels[i];
392 #if defined(MAGICKCORE_OPENMP_SUPPORT) 407 for (w=0; w < (ssize_t) width; w+=2)
452 #define AdaptiveSharpenImageTag "Convolve/Image" 453 #define MagickSigma (fabs(sigma) < MagickEpsilon ? MagickEpsilon : sigma) 482 assert(image != (
const Image *) NULL);
489 if (sharp_image == (
Image *) NULL)
490 return((
Image *) NULL);
496 return((
Image *) NULL);
501 edge_image=
EdgeImage(image,radius,exception);
502 if (edge_image == (
Image *) NULL)
505 return((
Image *) NULL);
508 gaussian_image=
BlurImage(edge_image,radius,sigma,exception);
509 if (gaussian_image != (
Image *) NULL)
512 edge_image=gaussian_image;
520 width,
sizeof(*kernel)));
521 if (kernel == (
double **) NULL)
527 (void) memset(kernel,0,(
size_t) width*
sizeof(*kernel));
528 for (w=0; w < (ssize_t) width; w+=2)
537 (width-w),(width-w)*
sizeof(**kernel)));
538 if (kernel[w] == (
double *) NULL)
541 j=(ssize_t) (width-w-1)/2;
543 for (v=(-j); v <= j; v++)
545 for (u=(-j); u <= j; u++)
547 kernel[w][k]=(double) (-exp(-((
double) u*u+v*v)/(2.0*
MagickSigma*
549 normalize+=kernel[w][k];
553 kernel[w][(k-1)/2]=(
double) ((-2.0)*normalize);
555 kernel[w][(k-1)/2]=1.0;
557 if (w < (ssize_t) width)
559 for (w-=2; w >= 0; w-=2)
574 #if defined(MAGICKCORE_OPENMP_SUPPORT) 575 #pragma omp parallel for schedule(static) shared(progress,status) \ 576 magick_number_threads(image,sharp_image,sharp_image->rows,1) 578 for (y=0; y < (ssize_t) sharp_image->
rows; y++)
599 for (x=0; x < (ssize_t) sharp_image->
columns; x++)
616 if (j > (ssize_t) width)
621 (ssize_t) ((width-j)/2L),width-j,width-j,exception);
622 if (p == (
const Quantum *) NULL)
672 for (v=0; v < (ssize_t) (width-j); v++)
674 for (u=0; u < (ssize_t) (width-j); u++)
676 pixel+=(*k)*pixels[i];
689 for (v=0; v < (ssize_t) (width-j); v++)
691 for (u=0; u < (ssize_t) (width-j); u++)
694 pixel+=(*k)*alpha*pixels[i];
713 #if defined(MAGICKCORE_OPENMP_SUPPORT) 728 for (w=0; w < (ssize_t) width; w+=2)
781 assert(image != (
const Image *) NULL);
787 #if defined(MAGICKCORE_OPENCL_SUPPORT) 788 blur_image=AccelerateBlurImage(image,radius,sigma,exception);
789 if (blur_image != (
Image *) NULL)
793 "blur:%.20gx%.20g;blur:%.20gx%.20g+90",radius,sigma,radius,sigma);
851 const ssize_t u,
const ssize_t v)
853 return(sqrt(((
double) x-u)*((
double) x-u)+((
double) y-v)*((
double) y-v)));
868 assert(weights != (
double **) NULL);
869 for (i=0; i <= (ssize_t) number_threads; i++)
870 if (weights[i] != (
double *) NULL)
877 const size_t width,
const size_t height)
886 if (weights == (
double **) NULL)
887 return((
double **) NULL);
888 (void) memset(weights,0,number_threads*
sizeof(*weights));
889 for (i=0; i <= (ssize_t) number_threads; i++)
892 if (weights[i] == (
double *) NULL)
899 const size_t height,
const double intensity_sigma,
const double spatial_sigma,
902 #define MaxIntensity (255) 903 #define BilateralBlurImageTag "Blur/Image" 931 assert(image != (
const Image *) NULL);
938 if (blur_image == (
Image *) NULL)
939 return((
Image *) NULL);
943 return((
Image *) NULL);
948 if (weights == (
double **) NULL)
955 spatial_gaussian=weights[number_threads];
964 for (v=0; v < (ssize_t)
MagickMax(height,1); v++)
969 for (u=0; u < (ssize_t)
MagickMax(width,1); u++)
981 #if defined(MAGICKCORE_OPENMP_SUPPORT) 982 #pragma omp parallel for schedule(static) shared(progress,status) \ 983 magick_number_threads(image,blur_image,blur_image->rows,1) 985 for (y=0; y < (ssize_t) blur_image->rows; y++)
1005 for (x=0; x < (ssize_t) blur_image->columns; x++)
1028 if (p == (
const Quantum *) NULL)
1033 for (v=0; v < (ssize_t)
MagickMax(height,1); v++)
1035 for (u=0; u < (ssize_t)
MagickMax(width,1); u++)
1045 weights[id][n]=intensity_gaussian[(ssize_t) intensity+
MaxIntensity]*
1046 spatial_gaussian[n];
1048 weights[id][n]=
BlurGaussian(intensity,intensity_sigma)*
1081 for (v=0; v < (ssize_t)
MagickMax(height,1); v++)
1083 for (u=0; u < (ssize_t)
MagickMax(width,1); u++)
1087 pixel+=weights[id][n]*r[i];
1088 gamma+=weights[id][n];
1099 for (v=0; v < (ssize_t)
MagickMax(height,1); v++)
1101 for (u=0; u < (ssize_t)
MagickMax(width,1); u++)
1111 pixel+=weights[id][n]*r[i];
1112 gamma+=weights[id][n]*alpha*beta;
1128 #if defined(MAGICKCORE_OPENMP_SUPPORT) 1138 blur_image->type=image->
type;
1180 #if defined(MAGICKCORE_OPENCL_SUPPORT) 1181 convolve_image=AccelerateConvolveImage(image,kernel_info,exception);
1182 if (convolve_image != (
Image *) NULL)
1183 return(convolve_image);
1188 return(convolve_image);
1222 const ssize_t y_offset,
const size_t columns,
const size_t rows,
1234 assert(image != (
const Image *) NULL);
1236 assert(f != (
Quantum *) NULL);
1237 assert(g != (
Quantum *) NULL);
1242 r=p+(y_offset*((ssize_t) columns+2)+x_offset);
1243 #if defined(MAGICKCORE_OPENMP_SUPPORT) 1244 #pragma omp parallel for schedule(static) \ 1245 magick_number_threads(image,image,rows,1) 1247 for (y=0; y < (ssize_t) rows; y++)
1256 i=(2*y+1)+y*columns;
1258 for (x=0; x < (ssize_t) columns; x++)
1262 v+=ScaleCharToQuantum(1);
1267 for (x=0; x < (ssize_t) columns; x++)
1271 v-=ScaleCharToQuantum(1);
1278 r=q+(y_offset*((ssize_t) columns+2)+x_offset);
1279 s=q-(y_offset*((ssize_t) columns+2)+x_offset);
1280 #if defined(MAGICKCORE_OPENMP_SUPPORT) 1281 #pragma omp parallel for schedule(static) \ 1282 magick_number_threads(image,image,rows,1) 1284 for (y=0; y < (ssize_t) rows; y++)
1293 i=(2*y+1)+y*columns;
1295 for (x=0; x < (ssize_t) columns; x++)
1300 v+=ScaleCharToQuantum(1);
1305 for (x=0; x < (ssize_t) columns; x++)
1310 v-=ScaleCharToQuantum(1);
1319 #define DespeckleImageTag "Despeckle/Image" 1345 static const ssize_t
1346 X[4] = {0, 1, 1,-1},
1347 Y[4] = {1, 0, 1, 1};
1352 assert(image != (
const Image *) NULL);
1358 #if defined(MAGICKCORE_OPENCL_SUPPORT) 1359 despeckle_image=AccelerateDespeckleImage(image,exception);
1360 if (despeckle_image != (
Image *) NULL)
1361 return(despeckle_image);
1364 if (despeckle_image == (
Image *) NULL)
1365 return((
Image *) NULL);
1370 return((
Image *) NULL);
1375 length=(size_t) ((image->
columns+2)*(image->
rows+2));
1423 (void) memset(pixels,0,length*
sizeof(*pixels));
1425 for (y=0; y < (ssize_t) image->
rows; y++)
1431 if (p == (
const Quantum *) NULL)
1437 for (x=0; x < (ssize_t) image->
columns; x++)
1444 (void) memset(buffer,0,length*
sizeof(*buffer));
1445 for (k=0; k < 4; k++)
1453 for (y=0; y < (ssize_t) image->
rows; y++)
1469 for (x=0; x < (ssize_t) image->
columns; x++)
1497 return(despeckle_image);
1544 assert(image != (
const Image *) NULL);
1554 (void) memset(kernel_info,0,
sizeof(*kernel_info));
1555 kernel_info->
width=width;
1556 kernel_info->
height=width;
1557 kernel_info->
x=(ssize_t) (kernel_info->
width-1)/2;
1558 kernel_info->
y=(ssize_t) (kernel_info->
height-1)/2;
1562 sizeof(*kernel_info->
values)));
1568 for (i=0; i < (ssize_t) (kernel_info->
width*kernel_info->
height); i++)
1569 kernel_info->
values[i]=(-1.0);
1634 assert(image != (
const Image *) NULL);
1644 kernel_info->
width=width;
1645 kernel_info->
height=width;
1646 kernel_info->
x=(ssize_t) (width-1)/2;
1647 kernel_info->
y=(ssize_t) (width-1)/2;
1650 sizeof(*kernel_info->
values)));
1656 j=(ssize_t) (kernel_info->
width-1)/2;
1659 for (v=(-j); v <= j; v++)
1661 for (u=(-j); u <= j; u++)
1667 kernel_info->
values[i]=0.0;
1673 for (i=0; i < (ssize_t) (kernel_info->
width*kernel_info->
height); i++)
1674 normalize+=kernel_info->
values[i];
1676 for (i=0; i < (ssize_t) (kernel_info->
width*kernel_info->
height); i++)
1677 kernel_info->
values[i]*=gamma;
1680 if (emboss_image != (
Image *) NULL)
1682 return(emboss_image);
1730 assert(image != (
const Image *) NULL);
1787 #define KuwaharaImageTag "Kuwahara/Image" 1812 assert(image != (
Image *) NULL);
1818 width=(size_t) radius+1;
1819 gaussian_image=
BlurImage(image,radius,sigma,exception);
1820 if (gaussian_image == (
Image *) NULL)
1821 return((
Image *) NULL);
1823 if (kuwahara_image == (
Image *) NULL)
1826 return((
Image *) NULL);
1832 return((
Image *) NULL);
1841 #if defined(MAGICKCORE_OPENMP_SUPPORT) 1842 #pragma omp parallel for schedule(static) shared(progress,status) \ 1843 magick_number_threads(image,kuwahara_image,gaussian_image->rows,1) 1845 for (y=0; y < (ssize_t) gaussian_image->
rows; y++)
1862 for (x=0; x < (ssize_t) gaussian_image->
columns; x++)
1879 quadrant.
width=width;
1881 for (i=0; i < 4; i++)
1902 quadrant.
x=x-(ssize_t) (width-1);
1903 quadrant.
y=y-(ssize_t) (width-1);
1908 quadrant.
y=y-(ssize_t) (width-1);
1913 quadrant.
x=x-(ssize_t) (width-1);
1922 if (p == (
const Quantum *) NULL)
1927 for (n=0; n < (ssize_t) (width*width); n++)
1930 mean[j]+=(
double) k[j];
1934 mean[j]/=(
double) (width*width);
1937 for (n=0; n < (ssize_t) (width*width); n++)
1943 variance+=(luma-
GetMeanLuma(gaussian_image,mean))*
1947 if (variance < min_variance)
1949 min_variance=variance;
1960 target.
y+target.
height/2.0,q,exception);
1972 #if defined(MAGICKCORE_OPENMP_SUPPORT) 1986 return(kuwahara_image);
2025 #define LocalContrastImageTag "LocalContrast/Image" 2053 assert(image != (
const Image *) NULL);
2059 #if defined(MAGICKCORE_OPENCL_SUPPORT) 2060 contrast_image=AccelerateLocalContrastImage(image,radius,strength,exception);
2061 if (contrast_image != (
Image *) NULL)
2062 return(contrast_image);
2065 if (contrast_image == (
Image *) NULL)
2066 return((
Image *) NULL);
2070 return((
Image *) NULL);
2075 width=(ssize_t) scanLineSize*0.002f*fabs(radius);
2076 scanLineSize+=(2*width);
2078 scanLineSize,
sizeof(*scanline));
2091 sizeof(*interImage));
2101 totalWeight=(float) ((width+1)*(width+1));
2110 #if defined(MAGICKCORE_OPENMP_SUPPORT) 2111 #pragma omp parallel for schedule(static) \ 2112 magick_number_threads(image,image,image->columns,1) 2114 for (x=0; x < (ssize_t) image->
columns; x++)
2136 pixels+=
id*scanLineSize;
2140 if (p == (
const Quantum *) NULL)
2145 for (y=0; y < (ssize_t) image->
rows+(2*width); y++)
2150 out=interImage+x+width;
2151 for (y=0; y < (ssize_t) image->
rows; y++)
2160 for (i=0; i < width; i++)
2162 sum+=weight*(*pix++);
2165 for (i=width+1; i < (2*width); i++)
2167 sum+=weight*(*pix++);
2171 *out=sum/totalWeight;
2173 if (x <= width && x != 0)
2175 if ((x > (ssize_t) image->
columns-width-2) &&
2176 (x != (ssize_t) image->
columns-1))
2177 *(out+((image->
columns-x-1)*2))=*out;
2178 out+=image->
columns+(width*2);
2189 #if defined(MAGICKCORE_OPENMP_SUPPORT) 2190 #pragma omp parallel for schedule(static) \ 2191 magick_number_threads(image,image,image->rows,1) 2193 for (y=0; y < (ssize_t) image->
rows; y++)
2217 pixels+=
id*scanLineSize;
2226 memcpy(pixels,interImage+(y*(image->
columns+(2*width))),(image->
columns+
2227 (2*width))*
sizeof(
float));
2228 for (x=0; x < (ssize_t) image->
columns; x++)
2242 for (i=0; i < width; i++)
2244 sum+=weight*(*pix++);
2247 for (i=width+1; i < (2*width); i++)
2249 sum+=weight*(*pix++);
2254 mult=(srcVal-(sum/totalWeight))*(strength/100.0f);
2255 mult=(srcVal+mult)/srcVal;
2281 return(contrast_image);
2339 width,
sizeof(*kernel)));
2343 for (i=0; i < (ssize_t) width; i++)
2347 normalize+=kernel[i];
2349 for (i=0; i < (ssize_t) width; i++)
2350 kernel[i]/=normalize;
2355 const double sigma,
const double angle,
ExceptionInfo *exception)
2357 #define BlurImageTag "Blur/Image" 2389 assert(image != (
Image *) NULL);
2407 for (w=0; w < (ssize_t) width; w++)
2410 hypot(point.
x,point.
y)-0.5));
2412 hypot(point.
x,point.
y)-0.5));
2417 #if defined(MAGICKCORE_OPENCL_SUPPORT) 2418 blur_image=AccelerateMotionBlurImage(image,kernel,width,offset,exception);
2419 if (blur_image != (
Image *) NULL)
2427 if (blur_image == (
Image *) NULL)
2431 return((
Image *) NULL);
2438 return((
Image *) NULL);
2445 #if defined(MAGICKCORE_OPENMP_SUPPORT) 2446 #pragma omp parallel for schedule(static) shared(progress,status) \ 2447 magick_number_threads(image,blur_image,image->rows,1) 2449 for (y=0; y < (ssize_t) image->
rows; y++)
2470 for (x=0; x < (ssize_t) image->
columns; x++)
2513 for (j=0; j < (ssize_t) width; j++)
2516 offset[j].y,1,1,exception);
2517 if (r == (
const Quantum *) NULL)
2530 for (j=0; j < (ssize_t) width; j++)
2534 if (r == (
const Quantum *) NULL)
2540 pixel+=(*k)*alpha*r[i];
2557 #if defined(MAGICKCORE_OPENMP_SUPPORT) 2609 #define NumberTiles 9 2610 #define PreviewImageTag "Preview/Image" 2611 #define DefaultPreviewGeometry "204x204+10+10" 2659 assert(image != (
Image *) NULL);
2681 if (thumbnail == (
Image *) NULL)
2698 preview_image=
RotateImage(thumbnail,degrees,exception);
2705 preview_image=
ShearImage(thumbnail,degrees,degrees,exception);
2714 preview_image=
RollImage(thumbnail,x,y,exception);
2716 (
double) x,(double) y);
2722 if (preview_image == (
Image *) NULL)
2733 if (preview_image == (
Image *) NULL)
2744 if (preview_image == (
Image *) NULL)
2755 if (preview_image == (
Image *) NULL)
2758 (void)
GammaImage(preview_image,gamma,exception);
2765 if (preview_image != (
Image *) NULL)
2766 for (x=0; x < i; x++)
2775 if (preview_image == (
Image *) NULL)
2777 for (x=0; x < i; x++)
2786 if (preview_image == (
Image *) NULL)
2791 (void)
QuantizeImage(&quantize_info,preview_image,exception);
2793 "-colorspace gray -colors %.20g",(
double) colors);
2799 if (preview_image == (
Image *) NULL)
2803 (void)
QuantizeImage(&quantize_info,preview_image,exception);
2810 for (x=0; x < (i-1); x++)
2813 if (preview_image == (
Image *) NULL)
2816 thumbnail=preview_image;
2819 if (preview_image == (
Image *) NULL)
2828 radius,(
size_t) radius,exception);
2873 (
size_t) i,exception);
2879 preview_image=
SharpenImage(thumbnail,radius,sigma,exception);
2886 preview_image=
BlurImage(thumbnail,radius,sigma,exception);
2894 if (preview_image == (
Image *) NULL)
2896 (void)
BilevelImage(thumbnail,(
double) (percentage*((double)
2899 (
double) (percentage*((double)
QuantumRange+1.0))/100.0);
2904 preview_image=
EdgeImage(thumbnail,radius,exception);
2919 if (preview_image == (
Image *) NULL)
2942 if (preview_image == (
Image *) NULL)
2944 raise.width=(size_t) (2*i+2);
2945 raise.height=(size_t) (2*i+2);
2950 "raise %.20gx%.20g%+.20g%+.20g",(
double)
raise.width,(double)
2951 raise.height,(
double)
raise.x,(double)
raise.y);
2957 if (preview_image == (
Image *) NULL)
2961 threshold,exception);
2963 threshold,threshold);
2985 preview_image=
WaveImage(thumbnail,0.5*degrees,2.0*degrees,
2988 degrees,2.0*degrees);
2993 preview_image=
OilPaintImage(thumbnail,(
double) radius,(
double) sigma,
3001 preview_image=
CharcoalImage(thumbnail,(
double) radius,(
double) sigma,
3019 if (preview_image == (
Image *) NULL)
3021 preview_info->
quality=(size_t) percentage;
3028 "jpeg:%s",filename);
3029 status=
WriteImage(preview_info,preview_image,exception);
3037 quality_image=
ReadImage(preview_info,exception);
3038 if (quality_image != (
Image *) NULL)
3041 preview_image=quality_image;
3065 if (preview_image == (
Image *) NULL)
3076 if (images == (
Image *) NULL)
3079 return((
Image *) NULL);
3094 if (montage_image == (
Image *) NULL)
3096 if (montage_image->
montage != (
char *) NULL)
3108 return(montage_image);
3179 assert(image != (
Image *) NULL);
3185 #if defined(MAGICKCORE_OPENCL_SUPPORT) 3186 blur_image=AccelerateRotationalBlurImage(image,angle,exception);
3187 if (blur_image != (
Image *) NULL)
3191 if (blur_image == (
Image *) NULL)
3192 return((
Image *) NULL);
3196 return((
Image *) NULL);
3198 blur_center.
x=(double) (image->
columns-1)/2.0;
3199 blur_center.
y=(double) (image->
rows-1)/2.0;
3200 blur_radius=hypot(blur_center.
x,blur_center.
y);
3201 n=(size_t) fabs(4.0*
DegreesToRadians(angle)*sqrt((
double) blur_radius)+2UL);
3205 if ((cos_theta == (
double *) NULL) || (sin_theta == (
double *) NULL))
3207 if (cos_theta != (
double *) NULL)
3209 if (sin_theta != (
double *) NULL)
3214 offset=theta*(double) (n-1)/2.0;
3215 for (w=0; w < (ssize_t) n; w++)
3217 cos_theta[w]=cos((
double) (theta*w-offset));
3218 sin_theta[w]=sin((
double) (theta*w-offset));
3228 #if defined(MAGICKCORE_OPENMP_SUPPORT) 3229 #pragma omp parallel for schedule(static) shared(progress,status) \ 3230 magick_number_threads(image,blur_image,image->rows,1) 3232 for (y=0; y < (ssize_t) image->
rows; y++)
3253 for (x=0; x < (ssize_t) image->
columns; x++)
3267 center.
x=(double) x-blur_center.
x;
3268 center.
y=(
double) y-blur_center.
y;
3269 radius=hypot((
double) center.
x,center.
y);
3274 step=(size_t) (blur_radius/radius);
3316 for (j=0; j < (ssize_t) n; j+=(ssize_t) step)
3319 center.
x*cos_theta[j]-center.
y*sin_theta[j]+0.5),(ssize_t)
3320 (blur_center.
y+center.
x*sin_theta[j]+center.
y*cos_theta[j]+0.5),
3322 if (r == (
const Quantum *) NULL)
3334 for (j=0; j < (ssize_t) n; j+=(ssize_t) step)
3340 center.
x*cos_theta[j]-center.
y*sin_theta[j]+0.5),(ssize_t)
3341 (blur_center.
y+center.
x*sin_theta[j]+center.
y*cos_theta[j]+0.5),
3343 if (r == (
const Quantum *) NULL)
3365 #if defined(MAGICKCORE_OPENMP_SUPPORT) 3420 const double sigma,
const double threshold,
ExceptionInfo *exception)
3422 #define SelectiveBlurImageTag "SelectiveBlur/Image" 3452 assert(image != (
Image *) NULL);
3460 width,width*
sizeof(*kernel)));
3469 j=(ssize_t) (width-1)/2;
3471 for (v=(-j); v <= j; v++)
3476 for (u=(-j); u <= j; u++)
3495 " SelectiveBlurImage with %.20gx%.20g kernel:",(double) width,(
double)
3499 for (v=0; v < (ssize_t) width; v++)
3504 for (u=0; u < (ssize_t) width; u++)
3515 if (blur_image == (
Image *) NULL)
3516 return((
Image *) NULL);
3521 return((
Image *) NULL);
3524 if (luminance_image == (
Image *) NULL)
3528 return((
Image *) NULL);
3536 return((
Image *) NULL);
3548 #if defined(MAGICKCORE_OPENMP_SUPPORT) 3549 #pragma omp parallel for schedule(static) shared(progress,status) \ 3550 magick_number_threads(image,blur_image,image->rows,1) 3552 for (y=0; y < (ssize_t) image->
rows; y++)
3573 ((width-1)/2L),image->
columns+width,width,exception);
3575 (ssize_t) ((width-1)/2L),luminance_image->
columns+width,width,exception);
3578 if ((p == (
const Quantum *) NULL) || (l == (
const Quantum *) NULL) ||
3584 for (x=0; x < (ssize_t) image->
columns; x++)
3638 for (v=0; v < (ssize_t) width; v++)
3640 for (u=0; u < (ssize_t) width; u++)
3644 if (fabs(contrast) < threshold)
3646 pixel+=(*k)*pixels[i];
3666 for (v=0; v < (ssize_t) width; v++)
3668 for (u=0; u < (ssize_t) width; u++)
3671 if (fabs(contrast) < threshold)
3674 pixel+=(*k)*alpha*pixels[i];
3705 #if defined(MAGICKCORE_OPENMP_SUPPORT) 3759 const double azimuth,
const double elevation,
ExceptionInfo *exception)
3761 #define GetShadeIntensity(image,pixel) \ 3762 ClampPixel(GetPixelIntensity((image),(pixel))) 3763 #define ShadeImageTag "Shade/Image" 3788 assert(image != (
const Image *) NULL);
3796 if ((linear_image == (
Image *) NULL) || (shade_image == (
Image *) NULL))
3798 if (linear_image != (
Image *) NULL)
3800 if (shade_image != (
Image *) NULL)
3802 return((
Image *) NULL);
3808 return((
Image *) NULL);
3825 #if defined(MAGICKCORE_OPENMP_SUPPORT) 3826 #pragma omp parallel for schedule(static) shared(progress,status) \ 3827 magick_number_threads(linear_image,shade_image,linear_image->rows,1) 3829 for (y=0; y < (ssize_t) linear_image->
rows; y++)
3866 for (x=0; x < (ssize_t) linear_image->
columns; x++)
3897 distance=normal.
x*light.
x+normal.
y*light.
y+normal.
z*light.
z;
3900 normal_distance=normal.
x*normal.
x+normal.
y*normal.
y+
3903 shade=distance/sqrt((
double) normal_distance);
3949 #if defined(MAGICKCORE_OPENMP_SUPPORT) 3963 return(shade_image);
4028 assert(image != (
const Image *) NULL);
4038 (void) memset(kernel_info,0,
sizeof(*kernel_info));
4039 kernel_info->
width=width;
4040 kernel_info->
height=width;
4041 kernel_info->
x=(ssize_t) (width-1)/2;
4042 kernel_info->
y=(ssize_t) (width-1)/2;
4046 sizeof(*kernel_info->
values)));
4053 j=(ssize_t) (kernel_info->
width-1)/2;
4055 for (v=(-j); v <= j; v++)
4057 for (u=(-j); u <= j; u++)
4061 normalize+=kernel_info->
values[i];
4065 kernel_info->
values[i/2]=(double) ((-2.0)*normalize);
4067 for (i=0; i < (ssize_t) (kernel_info->
width*kernel_info->
height); i++)
4068 normalize+=kernel_info->
values[i];
4070 for (i=0; i < (ssize_t) (kernel_info->
width*kernel_info->
height); i++)
4071 kernel_info->
values[i]*=gamma;
4074 return(sharp_image);
4112 #define SpreadImageTag "Spread/Image" 4136 #if defined(MAGICKCORE_OPENMP_SUPPORT) 4144 assert(image != (
Image *) NULL);
4151 if (spread_image == (
Image *) NULL)
4152 return((
Image *) NULL);
4156 return((
Image *) NULL);
4167 #if defined(MAGICKCORE_OPENMP_SUPPORT) 4169 #pragma omp parallel for schedule(static) shared(progress,status) \ 4170 magick_number_threads(image,spread_image,image->rows,key == ~0UL) 4172 for (y=0; y < (ssize_t) image->
rows; y++)
4192 for (x=0; x < (ssize_t) image->
columns; x++)
4200 (
double) x+width*(point.
x-0.5),(
double) y+width*(point.
y-0.5),q,
4213 #if defined(MAGICKCORE_OPENMP_SUPPORT) 4227 return(spread_image);
4270 const double sigma,
const double gain,
const double threshold,
4273 #define SharpenImageTag "Sharpen/Image" 4294 assert(image != (
const Image *) NULL);
4308 unsharp_image=
BlurImage(image,radius,sigma,exception);
4309 if (unsharp_image == (
Image *) NULL)
4310 return((
Image *) NULL);
4319 #if defined(MAGICKCORE_OPENMP_SUPPORT) 4320 #pragma omp parallel for schedule(static) shared(progress,status) \ 4321 magick_number_threads(image,unsharp_image,image->rows,1) 4323 for (y=0; y < (ssize_t) image->
rows; y++)
4344 for (x=0; x < (ssize_t) image->
columns; x++)
4373 if (fabs(2.0*pixel) < quantum_threshold)
4374 pixel=(double) p[i];
4376 pixel=(double) p[i]+gain*pixel;
4389 #if defined(MAGICKCORE_OPENMP_SUPPORT) 4403 return(unsharp_image);
MagickExport Image * SelectiveBlurImage(const Image *image, const double radius, const double sigma, const double threshold, ExceptionInfo *exception)
MagickExport Image * BlurImage(const Image *image, const double radius, const double sigma, ExceptionInfo *exception)
MagickDoubleType MagickRealType
MagickExport CacheView * DestroyCacheView(CacheView *cache_view)
MagickExport Image * MotionBlurImage(const Image *image, const double radius, const double sigma, const double angle, ExceptionInfo *exception)
MagickExport MemoryInfo * RelinquishVirtualMemory(MemoryInfo *memory_info)
MagickExport ImageInfo * AcquireImageInfo(void)
MagickExport Image * MontageImages(const Image *images, const MontageInfo *montage_info, ExceptionInfo *exception)
MagickProgressMonitor progress_monitor
static Quantum GetPixelAlpha(const Image *magick_restrict image, const Quantum *magick_restrict pixel)
MagickExport MagickBooleanType TransformImageColorspace(Image *image, const ColorspaceType colorspace, ExceptionInfo *exception)
static double ** DestroyBilateralTLS(const ssize_t number_threads, double **weights)
#define MagickAssumeAligned(address)
static MagickRealType GetMeanLuma(const Image *magick_restrict image, const double *magick_restrict pixel)
static Quantum GetPixelRed(const Image *magick_restrict image, const Quantum *magick_restrict pixel)
static RandomInfo ** AcquireRandomInfoTLS(void)
ColorspaceType colorspace
MagickExport Image * ShadeImage(const Image *image, const MagickBooleanType gray, const double azimuth, const double elevation, ExceptionInfo *exception)
MagickExport Image * UnsharpMaskImage(const Image *image, const double radius, const double sigma, const double gain, const double threshold, ExceptionInfo *exception)
MagickExport Image * BilateralBlurImage(const Image *image, const size_t width, const size_t height, const double intensity_sigma, const double spatial_sigma, ExceptionInfo *exception)
MagickExport MagickBooleanType RaiseImage(Image *image, const RectangleInfo *raise_info, const MagickBooleanType raise, ExceptionInfo *exception)
MagickExport KernelInfo * DestroyKernelInfo(KernelInfo *kernel)
PixelInterpolateMethod interpolate
MagickExport MemoryInfo * AcquireVirtualMemory(const size_t count, const size_t quantum)
MagickExport Image * AdaptiveSharpenImage(const Image *image, const double radius, const double sigma, ExceptionInfo *exception)
static size_t GetOpenMPMaximumThreads(void)
MagickExport Image * MorphologyImage(const Image *image, const MorphologyMethod method, const ssize_t iterations, const KernelInfo *kernel, ExceptionInfo *exception)
MagickExport Image * PreviewImage(const Image *image, const PreviewType preview, ExceptionInfo *exception)
static double ** AcquireBilateralTLS(const size_t number_threads, const size_t width, const size_t height)
static Quantum GetPixelChannel(const Image *magick_restrict image, const PixelChannel channel, const Quantum *magick_restrict pixel)
MagickExport MagickStatusType ParseMetaGeometry(const char *geometry, ssize_t *x, ssize_t *y, size_t *width, size_t *height)
#define AdaptiveSharpenImageTag
MagickExport MagickBooleanType InterpolatePixelChannels(const Image *magick_restrict source, const CacheView_ *source_view, const Image *magick_restrict destination, const PixelInterpolateMethod method, const double x, const double y, Quantum *pixel, ExceptionInfo *exception)
static PixelTrait GetPixelChannelTraits(const Image *magick_restrict image, const PixelChannel channel)
MagickExport MagickBooleanType EqualizeImage(Image *image, ExceptionInfo *exception)
MagickExport Image * RotationalBlurImage(const Image *image, const double angle, ExceptionInfo *exception)
#define GetShadeIntensity(image, pixel)
MagickExport ssize_t FormatLocaleString(char *magick_restrict string, const size_t length, const char *magick_restrict format,...)
MagickPrivate size_t GetOptimalKernelWidth1D(const double, const double)
MagickExport size_t CopyMagickString(char *magick_restrict destination, const char *magick_restrict source, const size_t length)
char magick[MagickPathExtent]
MagickExport const Quantum * GetCacheViewVirtualPixels(const CacheView *cache_view, const ssize_t x, const ssize_t y, const size_t columns, const size_t rows, ExceptionInfo *exception)
static MagickRealType GetPixelLuma(const Image *magick_restrict image, const Quantum *magick_restrict pixel)
MagickExport Image * ThumbnailImage(const Image *image, const size_t columns, const size_t rows, ExceptionInfo *exception)
MagickExport unsigned long GetRandomSecretKey(const RandomInfo *random_info)
static Quantum ClampToQuantum(const MagickRealType quantum)
MagickExport Image * ImplodeImage(const Image *image, const double amount, const PixelInterpolateMethod method, ExceptionInfo *exception)
#define DespeckleImageTag
MagickExport MagickBooleanType ContrastImage(Image *image, const MagickBooleanType sharpen, ExceptionInfo *exception)
MagickExport KernelInfo * AcquireKernelInfo(const char *kernel_string, ExceptionInfo *exception)
#define MagickCoreSignature
MagickExport Quantum * GetCacheViewAuthenticPixels(CacheView *cache_view, const ssize_t x, const ssize_t y, const size_t columns, const size_t rows, ExceptionInfo *exception)
MagickExport Image * NewImageList(void)
MagickExport char * AcquireString(const char *source)
static double PerceptibleReciprocal(const double x)
MagickExport int AcquireUniqueFileResource(char *path)
MagickExport Image * LocalContrastImage(const Image *image, const double radius, const double strength, ExceptionInfo *exception)
MagickExport Image * SpreadImage(const Image *image, const PixelInterpolateMethod method, const double radius, ExceptionInfo *exception)
MagickExport MagickBooleanType WriteImage(const ImageInfo *image_info, Image *image, ExceptionInfo *exception)
#define BilateralBlurImageTag
static ssize_t CastDoubleToLong(const double x)
char filename[MagickPathExtent]
MagickExport MagickBooleanType SegmentImage(Image *image, const ColorspaceType colorspace, const MagickBooleanType verbose, const double cluster_threshold, const double smooth_threshold, ExceptionInfo *exception)
MagickExport void * AcquireQuantumMemory(const size_t count, const size_t quantum)
char filename[MagickPathExtent]
MagickPrivate size_t GetOptimalKernelWidth2D(const double, const double)
static double DegreesToRadians(const double degrees)
static int GetOpenMPThreadId(void)
MagickExport MagickBooleanType ModulateImage(Image *image, const char *modulate, ExceptionInfo *exception)
MagickExport MagickBooleanType RelinquishUniqueFileResource(const char *path)
MagickExport Image * EmbossImage(const Image *image, const double radius, const double sigma, ExceptionInfo *exception)
MagickExport MagickBooleanType SetImageProperty(Image *image, const char *property, const char *value, ExceptionInfo *exception)
static MagickRealType * GetMotionBlurKernel(const size_t width, const double sigma)
static Quantum GetPixelGreen(const Image *magick_restrict image, const Quantum *magick_restrict pixel)
MagickExport void * RelinquishAlignedMemory(void *memory)
MagickExport MagickBooleanType IsEventLogging(void)
MagickExport void GetQuantizeInfo(QuantizeInfo *quantize_info)
#define MagickMaximumValue
MagickExport Image * ReadImage(const ImageInfo *image_info, ExceptionInfo *exception)
MagickExport Quantum * QueueCacheViewAuthenticPixels(CacheView *cache_view, const ssize_t x, const ssize_t y, const size_t columns, const size_t rows, ExceptionInfo *exception)
MagickExport MagickBooleanType LogMagickEvent(const LogEventType type, const char *module, const char *function, const size_t line, const char *format,...)
MagickExport MagickBooleanType QuantizeImage(const QuantizeInfo *quantize_info, Image *image, ExceptionInfo *exception)
MagickExport Image * RotateImage(const Image *image, const double degrees, ExceptionInfo *exception)
MagickExport Image * AdaptiveBlurImage(const Image *image, const double radius, const double sigma, ExceptionInfo *exception)
MagickExport MagickSizeType GetMagickResourceLimit(const ResourceType type)
#define SelectiveBlurImageTag
MagickBooleanType(* MagickProgressMonitor)(const char *, const MagickOffsetType, const MagickSizeType, void *)
MagickExport Image * DespeckleImage(const Image *image, ExceptionInfo *exception)
MagickExport Image * SwirlImage(const Image *image, double degrees, const PixelInterpolateMethod method, ExceptionInfo *exception)
MagickExport MontageInfo * DestroyMontageInfo(MontageInfo *montage_info)
MagickExport MagickBooleanType QueryColorCompliance(const char *name, const ComplianceType compliance, PixelInfo *color, ExceptionInfo *exception)
static void SetPixelBlue(const Image *magick_restrict image, const Quantum blue, Quantum *magick_restrict pixel)
MagickExport MagickBooleanType SetImageStorageClass(Image *image, const ClassType storage_class, ExceptionInfo *exception)
MagickExport MagickProgressMonitor SetImageProgressMonitor(Image *image, const MagickProgressMonitor progress_monitor, void *client_data)
MagickExport Image * DestroyImageList(Image *images)
MagickExport void * AcquireAlignedMemory(const size_t count, const size_t quantum)
static size_t GetPixelChannels(const Image *magick_restrict image)
char filename[MagickPathExtent]
#define GetMagickModule()
#define ThrowImageException(severity, tag)
static PixelChannel GetPixelChannelChannel(const Image *magick_restrict image, const ssize_t offset)
MagickExport CacheView * AcquireVirtualCacheView(const Image *image, ExceptionInfo *exception)
MagickExport Image * ShearImage(const Image *image, const double x_shear, const double y_shear, ExceptionInfo *exception)
MagickExport MagickSizeType GetBlobSize(const Image *image)
MagickExport ImageInfo * DestroyImageInfo(ImageInfo *image_info)
static void Hull(const Image *image, const ssize_t x_offset, const ssize_t y_offset, const size_t columns, const size_t rows, const int polarity, Quantum *magick_restrict f, Quantum *magick_restrict g)
MagickExport Image * KuwaharaImage(const Image *image, const double radius, const double sigma, ExceptionInfo *exception)
MagickExport char * DestroyString(char *string)
MagickExport MagickBooleanType DeleteImageProperty(Image *image, const char *property)
MagickExport double GetPseudoRandomValue(RandomInfo *magick_restrict random_info)
static void SetPixelChannel(const Image *magick_restrict image, const PixelChannel channel, const Quantum quantum, Quantum *magick_restrict pixel)
MagickExport void AppendImageToList(Image **images, const Image *append)
MagickExport Image * CharcoalImage(const Image *image, const double radius, const double sigma, ExceptionInfo *exception)
MagickExport Image * ConvolveImage(const Image *image, const KernelInfo *kernel_info, ExceptionInfo *exception)
MagickExport void SetGeometry(const Image *image, RectangleInfo *geometry)
MagickExport MagickBooleanType ConcatenateString(char **magick_restrict destination, const char *magick_restrict source)
MagickExport MagickBooleanType BilevelImage(Image *image, const double threshold, ExceptionInfo *exception)
static RandomInfo * random_info
MagickExport Image * SharpenImage(const Image *image, const double radius, const double sigma, ExceptionInfo *exception)
MagickExport void * RelinquishMagickMemory(void *memory)
MagickExport Image * WaveImage(const Image *image, const double amplitude, const double wave_length, const PixelInterpolateMethod method, ExceptionInfo *exception)
#define AdaptiveBlurImageTag
MagickExport MagickBooleanType GammaImage(Image *image, const double gamma, ExceptionInfo *exception)
MagickExport char * CloneString(char **destination, const char *source)
static void SetPixelRed(const Image *magick_restrict image, const Quantum red, Quantum *magick_restrict pixel)
MagickExport MagickBooleanType AutoLevelImage(Image *image, ExceptionInfo *exception)
static double BlurDistance(const ssize_t x, const ssize_t y, const ssize_t u, const ssize_t v)
MagickExport MagickBooleanType SyncCacheViewAuthenticPixels(CacheView *magick_restrict cache_view, ExceptionInfo *exception)
MagickExport MagickBooleanType SolarizeImage(Image *image, const double threshold, ExceptionInfo *exception)
MagickExport Image * OilPaintImage(const Image *image, const double radius, const double sigma, ExceptionInfo *exception)
MagickExport CacheView * AcquireAuthenticCacheView(const Image *image, ExceptionInfo *exception)
MagickExport Image * EdgeImage(const Image *image, const double radius, ExceptionInfo *exception)
static Quantum GetPixelBlue(const Image *magick_restrict image, const Quantum *magick_restrict pixel)
MagickExport void * GetVirtualMemoryBlob(const MemoryInfo *memory_info)
MagickExport MagickRealType GetPixelIntensity(const Image *magick_restrict image, const Quantum *magick_restrict pixel)
MagickExport MontageInfo * CloneMontageInfo(const ImageInfo *image_info, const MontageInfo *montage_info)
#define DefaultPreviewGeometry
MagickExport Image * DestroyImage(Image *image)
MagickExport Image * GaussianBlurImage(const Image *image, const double radius, const double sigma, ExceptionInfo *exception)
MagickExport Image * CloneImage(const Image *image, const size_t columns, const size_t rows, const MagickBooleanType detach, ExceptionInfo *exception)
MagickExport Image * StatisticImage(const Image *image, const StatisticType type, const size_t width, const size_t height, ExceptionInfo *exception)
MagickExport MagickBooleanType SetImageProgress(const Image *image, const char *tag, const MagickOffsetType offset, const MagickSizeType extent)
static void SetPixelGreen(const Image *magick_restrict image, const Quantum green, Quantum *magick_restrict pixel)
static double BlurGaussian(const double x, const double sigma)
static RandomInfo ** DestroyRandomInfoTLS(RandomInfo **random_info)