1 /*
2 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3 % %
4 % %
5 % %
6 % %
7 % V V AAA L IIIII DDDD AAA TTTTT EEEEE %
8 % V V A A L I D D A A T E %
9 % V V AAAAA L I D D AAAAA T EEE %
10 % V V A A L I D D A A T E %
11 % V A A LLLLL IIIII DDDD A A T EEEEE %
12 % %
13 % %
14 % ImageMagick Validation Suite %
15 % %
16 % Software Design %
17 % Cristy %
18 % March 2001 %
19 % %
20 % %
21 % Copyright 1999-2019 ImageMagick Studio LLC, a non-profit organization %
22 % dedicated to making software imaging solutions freely available. %
23 % %
24 % You may not use this file except in compliance with the License. You may %
25 % obtain a copy of the License at %
26 % %
27 % https://imagemagick.org/script/license.php %
28 % %
29 % Unless required by applicable law or agreed to in writing, software %
30 % distributed under the License is distributed on an "AS IS" BASIS, %
31 % WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. %
32 % see the License for the specific language governing permissions and %
33 % limitations under the License. %
34 % %
35 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
36 %
37 %
38 */
39
40 /*
41 Include declarations.
42 */
43 #include <stdio.h>
44 #include <stdlib.h>
45 #include <string.h>
46 #include <ctype.h>
47 #include <math.h>
48 #include <locale.h>
49 #include "MagickWand/MagickWand.h"
50 #include "MagickCore/colorspace-private.h"
51 #include "MagickCore/gem.h"
52 #include "MagickCore/resource_.h"
53 #include "MagickCore/string-private.h"
54 #include "validate.h"
55
56 /*
57 Define declarations.
58 */
59 #define CIEEpsilon (216.0/24389.0)
60 #define CIEK (24389.0/27.0)
61 #define D65X 0.950456
62 #define D65Y 1.0
63 #define D65Z 1.088754
64 #define ReferenceEpsilon (QuantumRange*1.0e-2)
65
66 /*
67 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
68 % %
69 % %
70 % %
71 % V a l i d a t e C o l o r s p a c e s %
72 % %
73 % %
74 % %
75 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
76 %
77 % ValidateColorspaces() validates the ImageMagick colorspaces and returns the
78 % number of validation tests that passed and failed.
79 %
80 % The format of the ValidateColorspaces method is:
81 %
82 % size_t ValidateColorspaces(ImageInfo *image_info,size_t *fail,
83 % ExceptionInfo *exception)
84 %
85 % A description of each parameter follows:
86 %
87 % o image_info: the image info.
88 %
89 % o fail: return the number of validation tests that pass.
90 %
91 % o exception: return any errors or warnings in this structure.
92 %
93 */
94
ConvertHSIToRGB(const double hue,const double saturation,const double intensity,double * red,double * green,double * blue)95 static void ConvertHSIToRGB(const double hue,const double saturation,
96 const double intensity,double *red,double *green,double *blue)
97 {
98 double
99 h;
100
101 h=360.0*hue;
102 h-=360.0*floor(h/360.0);
103 if (h < 120.0)
104 {
105 *blue=intensity*(1.0-saturation);
106 *red=intensity*(1.0+saturation*cos(h*(MagickPI/180.0))/cos((60.0-h)*
107 (MagickPI/180.0)));
108 *green=3.0*intensity-*red-*blue;
109 }
110 else
111 if (h < 240.0)
112 {
113 h-=120.0;
114 *red=intensity*(1.0-saturation);
115 *green=intensity*(1.0+saturation*cos(h*(MagickPI/180.0))/cos((60.0-h)*
116 (MagickPI/180.0)));
117 *blue=3.0*intensity-*red-*green;
118 }
119 else
120 {
121 h-=240.0;
122 *green=intensity*(1.0-saturation);
123 *blue=intensity*(1.0+saturation*cos(h*(MagickPI/180.0))/cos((60.0-h)*
124 (MagickPI/180.0)));
125 *red=3.0*intensity-*green-*blue;
126 }
127 *red*=QuantumRange;
128 *green*=QuantumRange;
129 *blue*=QuantumRange;
130 }
131
ConvertRGBToHSI(const double red,const double green,const double blue,double * hue,double * saturation,double * intensity)132 static void ConvertRGBToHSI(const double red,const double green,
133 const double blue,double *hue,double *saturation,double *intensity)
134 {
135 double
136 alpha,
137 beta;
138
139 *intensity=(QuantumScale*red+QuantumScale*green+QuantumScale*blue)/3.0;
140 if (*intensity <= 0.0)
141 {
142 *hue=0.0;
143 *saturation=0.0;
144 return;
145 }
146 *saturation=1.0-MagickMin(QuantumScale*red,MagickMin(QuantumScale*green,
147 QuantumScale*blue))/(*intensity);
148 alpha=0.5*(2.0*QuantumScale*red-QuantumScale*green-QuantumScale*blue);
149 beta=0.8660254037844385*(QuantumScale*green-QuantumScale*blue);
150 *hue=atan2(beta,alpha)*(180.0/MagickPI)/360.0;
151 if (*hue < 0.0)
152 *hue+=1.0;
153 }
154
ConvertHSVToRGB(const double hue,const double saturation,const double value,double * red,double * green,double * blue)155 static void ConvertHSVToRGB(const double hue,const double saturation,
156 const double value,double *red,double *green,double *blue)
157 {
158 double
159 c,
160 h,
161 min,
162 x;
163
164 h=hue*360.0;
165 c=value*saturation;
166 min=value-c;
167 h-=360.0*floor(h/360.0);
168 h/=60.0;
169 x=c*(1.0-fabs(h-2.0*floor(h/2.0)-1.0));
170 switch ((int) floor(h))
171 {
172 case 0:
173 {
174 *red=QuantumRange*(min+c);
175 *green=QuantumRange*(min+x);
176 *blue=QuantumRange*min;
177 break;
178 }
179 case 1:
180 {
181 *red=QuantumRange*(min+x);
182 *green=QuantumRange*(min+c);
183 *blue=QuantumRange*min;
184 break;
185 }
186 case 2:
187 {
188 *red=QuantumRange*min;
189 *green=QuantumRange*(min+c);
190 *blue=QuantumRange*(min+x);
191 break;
192 }
193 case 3:
194 {
195 *red=QuantumRange*min;
196 *green=QuantumRange*(min+x);
197 *blue=QuantumRange*(min+c);
198 break;
199 }
200 case 4:
201 {
202 *red=QuantumRange*(min+x);
203 *green=QuantumRange*min;
204 *blue=QuantumRange*(min+c);
205 break;
206 }
207 case 5:
208 {
209 *red=QuantumRange*(min+c);
210 *green=QuantumRange*min;
211 *blue=QuantumRange*(min+x);
212 break;
213 }
214 default:
215 {
216 *red=0.0;
217 *green=0.0;
218 *blue=0.0;
219 }
220 }
221 }
222
ConvertRGBToXYZ(const double red,const double green,const double blue,double * X,double * Y,double * Z)223 static inline void ConvertRGBToXYZ(const double red,const double green,
224 const double blue,double *X,double *Y,double *Z)
225 {
226 double
227 b,
228 g,
229 r;
230
231 r=QuantumScale*DecodePixelGamma(red);
232 g=QuantumScale*DecodePixelGamma(green);
233 b=QuantumScale*DecodePixelGamma(blue);
234 *X=0.41239558896741421610*r+0.35758343076371481710*g+0.18049264738170157350*b;
235 *Y=0.21258623078559555160*r+0.71517030370341084990*g+0.07220049864333622685*b;
236 *Z=0.01929721549174694484*r+0.11918386458084853180*g+0.95049712513157976600*b;
237 }
238
ConvertXYZToLab(const double X,const double Y,const double Z,double * L,double * a,double * b)239 static inline void ConvertXYZToLab(const double X,const double Y,const double Z,
240 double *L,double *a,double *b)
241 {
242 double
243 x,
244 y,
245 z;
246
247 if ((X/D65X) > CIEEpsilon)
248 x=pow(X/D65X,1.0/3.0);
249 else
250 x=(CIEK*X/D65X+16.0)/116.0;
251 if ((Y/D65Y) > CIEEpsilon)
252 y=pow(Y/D65Y,1.0/3.0);
253 else
254 y=(CIEK*Y/D65Y+16.0)/116.0;
255 if ((Z/D65Z) > CIEEpsilon)
256 z=pow(Z/D65Z,1.0/3.0);
257 else
258 z=(CIEK*Z/D65Z+16.0)/116.0;
259 *L=((116.0*y)-16.0)/100.0;
260 *a=(500.0*(x-y))/255.0+0.5;
261 *b=(200.0*(y-z))/255.0+0.5;
262 }
263
ConvertRGBToLab(const double red,const double green,const double blue,double * L,double * a,double * b)264 static void ConvertRGBToLab(const double red,const double green,
265 const double blue,double *L,double *a,double *b)
266 {
267 double
268 X,
269 Y,
270 Z;
271
272 ConvertRGBToXYZ(red,green,blue,&X,&Y,&Z);
273 ConvertXYZToLab(X,Y,Z,L,a,b);
274 }
275
ConvertLabToXYZ(const double L,const double a,const double b,double * X,double * Y,double * Z)276 static inline void ConvertLabToXYZ(const double L,const double a,const double b,
277 double *X,double *Y,double *Z)
278 {
279 double
280 x,
281 y,
282 z;
283
284 y=(L+16.0)/116.0;
285 x=y+a/500.0;
286 z=y-b/200.0;
287 if ((x*x*x) > CIEEpsilon)
288 x=(x*x*x);
289 else
290 x=(116.0*x-16.0)/CIEK;
291 if ((y*y*y) > CIEEpsilon)
292 y=(y*y*y);
293 else
294 y=L/CIEK;
295 if ((z*z*z) > CIEEpsilon)
296 z=(z*z*z);
297 else
298 z=(116.0*z-16.0)/CIEK;
299 *X=D65X*x;
300 *Y=D65Y*y;
301 *Z=D65Z*z;
302 }
303
ConvertXYZToRGB(const double x,const double y,const double z,double * red,double * green,double * blue)304 static inline void ConvertXYZToRGB(const double x,const double y,const double z,
305 double *red,double *green,double *blue)
306 {
307 double
308 b,
309 g,
310 r;
311
312 r=3.2406*x-1.5372*y-0.4986*z;
313 g=(-0.9689*x+1.8758*y+0.0415*z);
314 b=0.0557*x-0.2040*y+1.0570*z;
315 *red=EncodePixelGamma(QuantumRange*r);
316 *green=EncodePixelGamma(QuantumRange*g);
317 *blue=EncodePixelGamma(QuantumRange*b);
318 }
319
ConvertLabToRGB(const double L,const double a,const double b,double * red,double * green,double * blue)320 static inline void ConvertLabToRGB(const double L,const double a,
321 const double b,double *red,double *green,double *blue)
322 {
323 double
324 X,
325 Y,
326 Z;
327
328 ConvertLabToXYZ(L*100.0,255.0*(a-0.5),255.0*(b-0.5),&X,&Y,&Z);
329 ConvertXYZToRGB(X,Y,Z,red,green,blue);
330 }
331
ConvertRGBToYPbPr(const double red,const double green,const double blue,double * Y,double * Pb,double * Pr)332 static void ConvertRGBToYPbPr(const double red,const double green,
333 const double blue,double *Y,double *Pb,double *Pr)
334 {
335 *Y=QuantumScale*(0.298839*red+0.586811*green+0.114350*blue);
336 *Pb=QuantumScale*((-0.1687367)*red-0.331264*green+0.5*blue)+0.5;
337 *Pr=QuantumScale*(0.5*red-0.418688*green-0.081312*blue)+0.5;
338 }
339
ConvertRGBToYCbCr(const double red,const double green,const double blue,double * Y,double * Cb,double * Cr)340 static void ConvertRGBToYCbCr(const double red,const double green,
341 const double blue,double *Y,double *Cb,double *Cr)
342 {
343 ConvertRGBToYPbPr(red,green,blue,Y,Cb,Cr);
344 }
345
ConvertYPbPrToRGB(const double Y,const double Pb,const double Pr,double * red,double * green,double * blue)346 static void ConvertYPbPrToRGB(const double Y,const double Pb,const double Pr,
347 double *red,double *green,double *blue)
348 {
349 *red=QuantumRange*(0.99999999999914679361*Y-1.2188941887145875e-06*(Pb-0.5)+
350 1.4019995886561440468*(Pr-0.5));
351 *green=QuantumRange*(0.99999975910502514331*Y-0.34413567816504303521*(Pb-0.5)-
352 0.71413649331646789076*(Pr-0.5));
353 *blue=QuantumRange*(1.00000124040004623180*Y+1.77200006607230409200*(Pb-0.5)+
354 2.1453384174593273e-06*(Pr-0.5));
355 }
356
ConvertYCbCrToRGB(const double Y,const double Cb,const double Cr,double * red,double * green,double * blue)357 static void ConvertYCbCrToRGB(const double Y,const double Cb,
358 const double Cr,double *red,double *green,double *blue)
359 {
360 ConvertYPbPrToRGB(Y,Cb,Cr,red,green,blue);
361 }
362
ConvertLCHabToXYZ(const double luma,const double chroma,const double hue,double * X,double * Y,double * Z)363 static inline void ConvertLCHabToXYZ(const double luma,const double chroma,
364 const double hue,double *X,double *Y,double *Z)
365 {
366 ConvertLabToXYZ(luma,chroma*cos(hue*MagickPI/180.0),chroma*
367 sin(hue*MagickPI/180.0),X,Y,Z);
368 }
369
ConvertLCHabToRGB(const double luma,const double chroma,const double hue,double * red,double * green,double * blue)370 static void ConvertLCHabToRGB(const double luma,const double chroma,
371 const double hue,double *red,double *green,double *blue)
372 {
373 double
374 X,
375 Y,
376 Z;
377
378 ConvertLCHabToXYZ(luma*100.0,255.0*(chroma-0.5),360.0*hue,&X,&Y,&Z);
379 ConvertXYZToRGB(X,Y,Z,red,green,blue);
380 }
381
ConvertRGBToHSV(const double red,const double green,const double blue,double * hue,double * saturation,double * value)382 static void ConvertRGBToHSV(const double red,const double green,
383 const double blue,double *hue,double *saturation,double *value)
384 {
385 double
386 c,
387 max,
388 min;
389
390 max=MagickMax(QuantumScale*red,MagickMax(QuantumScale*green,
391 QuantumScale*blue));
392 min=MagickMin(QuantumScale*red,MagickMin(QuantumScale*green,
393 QuantumScale*blue));
394 c=max-min;
395 *value=max;
396 if (c <= 0.0)
397 {
398 *hue=0.0;
399 *saturation=0.0;
400 return;
401 }
402 if (max == (QuantumScale*red))
403 {
404 *hue=(QuantumScale*green-QuantumScale*blue)/c;
405 if ((QuantumScale*green) < (QuantumScale*blue))
406 *hue+=6.0;
407 }
408 else
409 if (max == (QuantumScale*green))
410 *hue=2.0+(QuantumScale*blue-QuantumScale*red)/c;
411 else
412 *hue=4.0+(QuantumScale*red-QuantumScale*green)/c;
413 *hue*=60.0/360.0;
414 *saturation=c/max;
415 }
416
ConvertXYZToLCHab(const double X,const double Y,const double Z,double * luma,double * chroma,double * hue)417 static inline void ConvertXYZToLCHab(const double X,const double Y,
418 const double Z,double *luma,double *chroma,double *hue)
419 {
420 double
421 a,
422 b;
423
424 ConvertXYZToLab(X,Y,Z,luma,&a,&b);
425 *chroma=hypot(255.0*(a-0.5),255.0*(b-0.5))/255.0+0.5;
426 *hue=180.0*atan2(255.0*(b-0.5),255.0*(a-0.5))/MagickPI/360.0;
427 if (*hue < 0.0)
428 *hue+=1.0;
429 }
430
ConvertRGBToLCHab(const double red,const double green,const double blue,double * luma,double * chroma,double * hue)431 static void ConvertRGBToLCHab(const double red,const double green,
432 const double blue,double *luma,double *chroma,double *hue)
433 {
434 double
435 X,
436 Y,
437 Z;
438
439 ConvertRGBToXYZ(red,green,blue,&X,&Y,&Z);
440 ConvertXYZToLCHab(X,Y,Z,luma,chroma,hue);
441 }
442
ConvertLMSToXYZ(const double L,const double M,const double S,double * X,double * Y,double * Z)443 static inline void ConvertLMSToXYZ(const double L,const double M,const double S,
444 double *X,double *Y,double *Z)
445 {
446 *X=1.096123820835514*L-0.278869000218287*M+0.182745179382773*S;
447 *Y=0.454369041975359*L+0.473533154307412*M+0.072097803717229*S;
448 *Z=(-0.009627608738429)*L-0.005698031216113*M+1.015325639954543*S;
449 }
450
ConvertLMSToRGB(const double L,const double M,const double S,double * red,double * green,double * blue)451 static inline void ConvertLMSToRGB(const double L,const double M,
452 const double S,double *red,double *green,double *blue)
453 {
454 double
455 X,
456 Y,
457 Z;
458
459 ConvertLMSToXYZ(L,M,S,&X,&Y,&Z);
460 ConvertXYZToRGB(X,Y,Z,red,green,blue);
461 }
462
ConvertXYZToLMS(const double x,const double y,const double z,double * L,double * M,double * S)463 static inline void ConvertXYZToLMS(const double x,const double y,
464 const double z,double *L,double *M,double *S)
465 {
466 *L=0.7328*x+0.4296*y-0.1624*z;
467 *M=(-0.7036*x+1.6975*y+0.0061*z);
468 *S=0.0030*x+0.0136*y+0.9834*z;
469 }
470
ConvertRGBToLMS(const double red,const double green,const double blue,double * L,double * M,double * S)471 static void ConvertRGBToLMS(const double red,const double green,
472 const double blue,double *L,double *M,double *S)
473 {
474 double
475 X,
476 Y,
477 Z;
478
479 ConvertRGBToXYZ(red,green,blue,&X,&Y,&Z);
480 ConvertXYZToLMS(X,Y,Z,L,M,S);
481 }
482
ConvertXYZToLuv(const double X,const double Y,const double Z,double * L,double * u,double * v)483 static inline void ConvertXYZToLuv(const double X,const double Y,const double Z,
484 double *L,double *u,double *v)
485 {
486 double
487 alpha;
488
489 if ((Y/D65Y) > CIEEpsilon)
490 *L=(double) (116.0*pow(Y/D65Y,1.0/3.0)-16.0);
491 else
492 *L=CIEK*(Y/D65Y);
493 alpha=PerceptibleReciprocal(X+15.0*Y+3.0*Z);
494 *u=13.0*(*L)*((4.0*alpha*X)-(4.0*D65X/(D65X+15.0*D65Y+3.0*D65Z)));
495 *v=13.0*(*L)*((9.0*alpha*Y)-(9.0*D65Y/(D65X+15.0*D65Y+3.0*D65Z)));
496 *L/=100.0;
497 *u=(*u+134.0)/354.0;
498 *v=(*v+140.0)/262.0;
499 }
500
ConvertRGBToLuv(const double red,const double green,const double blue,double * L,double * u,double * v)501 static void ConvertRGBToLuv(const double red,const double green,
502 const double blue,double *L,double *u,double *v)
503 {
504 double
505 X,
506 Y,
507 Z;
508
509 ConvertRGBToXYZ(red,green,blue,&X,&Y,&Z);
510 ConvertXYZToLuv(X,Y,Z,L,u,v);
511 }
512
ConvertLuvToXYZ(const double L,const double u,const double v,double * X,double * Y,double * Z)513 static inline void ConvertLuvToXYZ(const double L,const double u,const double v,
514 double *X,double *Y,double *Z)
515 {
516 if (L > (CIEK*CIEEpsilon))
517 *Y=(double) pow((L+16.0)/116.0,3.0);
518 else
519 *Y=L/CIEK;
520 *X=((*Y*((39.0*L/(v+13.0*L*(9.0*D65Y/(D65X+15.0*D65Y+3.0*D65Z))))-5.0))+
521 5.0*(*Y))/((((52.0f*L/(u+13.0*L*(4.0*D65X/(D65X+15.0*D65Y+3.0*D65Z))))-1.0)/
522 3.0)-(-1.0/3.0));
523 *Z=(*X*(((52.0f*L/(u+13.0*L*(4.0*D65X/(D65X+15.0*D65Y+3.0*D65Z))))-1.0)/3.0))-
524 5.0*(*Y);
525 }
526
ConvertLuvToRGB(const double L,const double u,const double v,double * red,double * green,double * blue)527 static inline void ConvertLuvToRGB(const double L,const double u,
528 const double v,double *red,double *green,double *blue)
529 {
530 double
531 X,
532 Y,
533 Z;
534
535 ConvertLuvToXYZ(100.0*L,354.0*u-134.0,262.0*v-140.0,&X,&Y,&Z);
536 ConvertXYZToRGB(X,Y,Z,red,green,blue);
537 }
538
ConvertRGBToYDbDr(const double red,const double green,const double blue,double * Y,double * Db,double * Dr)539 static void ConvertRGBToYDbDr(const double red,const double green,
540 const double blue,double *Y,double *Db,double *Dr)
541 {
542 *Y=QuantumScale*(0.298839*red+0.586811*green+0.114350*blue);
543 *Db=QuantumScale*(-0.450*red-0.883*green+1.333*blue)+0.5;
544 *Dr=QuantumScale*(-1.333*red+1.116*green+0.217*blue)+0.5;
545 }
546
ConvertYDbDrToRGB(const double Y,const double Db,const double Dr,double * red,double * green,double * blue)547 static void ConvertYDbDrToRGB(const double Y,const double Db,const double Dr,
548 double *red,double *green,double *blue)
549 {
550 *red=QuantumRange*(Y+9.2303716147657e-05*(Db-0.5)-0.52591263066186533*
551 (Dr-0.5));
552 *green=QuantumRange*(Y-0.12913289889050927*(Db-0.5)+0.26789932820759876*
553 (Dr-0.5));
554 *blue=QuantumRange*(Y+0.66467905997895482*(Db-0.5)-7.9202543533108e-05*
555 (Dr-0.5));
556 }
557
ConvertRGBToYIQ(const double red,const double green,const double blue,double * Y,double * I,double * Q)558 static void ConvertRGBToYIQ(const double red,const double green,
559 const double blue,double *Y,double *I,double *Q)
560 {
561 *Y=QuantumScale*(0.298839*red+0.586811*green+0.114350*blue);
562 *I=QuantumScale*(0.595716*red-0.274453*green-0.321263*blue)+0.5;
563 *Q=QuantumScale*(0.211456*red-0.522591*green+0.311135*blue)+0.5;
564 }
565
ConvertYIQToRGB(const double Y,const double I,const double Q,double * red,double * green,double * blue)566 static void ConvertYIQToRGB(const double Y,const double I,const double Q,
567 double *red,double *green,double *blue)
568 {
569 *red=QuantumRange*(Y+0.9562957197589482261*(I-0.5)+0.6210244164652610754*
570 (Q-0.5));
571 *green=QuantumRange*(Y-0.2721220993185104464*(I-0.5)-0.6473805968256950427*
572 (Q-0.5));
573 *blue=QuantumRange*(Y-1.1069890167364901945*(I-0.5)+1.7046149983646481374*
574 (Q-0.5));
575 }
576
ConvertRGBToYUV(const double red,const double green,const double blue,double * Y,double * U,double * V)577 static void ConvertRGBToYUV(const double red,const double green,
578 const double blue,double *Y,double *U,double *V)
579 {
580 *Y=QuantumScale*(0.298839*red+0.586811*green+0.114350*blue);
581 *U=QuantumScale*((-0.147)*red-0.289*green+0.436*blue)+0.5;
582 *V=QuantumScale*(0.615*red-0.515*green-0.100*blue)+0.5;
583 }
584
ConvertYUVToRGB(const double Y,const double U,const double V,double * red,double * green,double * blue)585 static void ConvertYUVToRGB(const double Y,const double U,const double V,
586 double *red,double *green,double *blue)
587 {
588 *red=QuantumRange*(Y-3.945707070708279e-05*(U-0.5)+1.1398279671717170825*
589 (V-0.5));
590 *green=QuantumRange*(Y-0.3946101641414141437*(U-0.5)-0.5805003156565656797*
591 (V-0.5));
592 *blue=QuantumRange*(Y+2.0319996843434342537*(U-0.5)-4.813762626262513e-04*
593 (V-0.5));
594 }
595
ValidateHSIToRGB()596 static MagickBooleanType ValidateHSIToRGB()
597 {
598 double
599 r,
600 g,
601 b;
602
603 (void) FormatLocaleFile(stdout," HSIToRGB");
604 ConvertHSIToRGB(111.244375/360.0,0.295985,0.658734,&r,&g,&b);
605 if ((fabs(r-0.545877*QuantumRange) >= ReferenceEpsilon) ||
606 (fabs(g-0.966567*QuantumRange) >= ReferenceEpsilon) ||
607 (fabs(b-0.463759*QuantumRange) >= ReferenceEpsilon))
608 return(MagickFalse);
609 return(MagickTrue);
610 }
611
ValidateRGBToHSI()612 static MagickBooleanType ValidateRGBToHSI()
613 {
614 double
615 h,
616 i,
617 s;
618
619 (void) FormatLocaleFile(stdout," RGBToHSI");
620 ConvertRGBToHSI(0.545877*QuantumRange,0.966567*QuantumRange,
621 0.463759*QuantumRange,&h,&s,&i);
622 if ((fabs(h-111.244374/360.0) >= ReferenceEpsilon) ||
623 (fabs(s-0.295985) >= ReferenceEpsilon) ||
624 (fabs(i-0.658734) >= ReferenceEpsilon))
625 return(MagickFalse);
626 return(MagickTrue);
627 }
628
ValidateHSLToRGB()629 static MagickBooleanType ValidateHSLToRGB()
630 {
631 double
632 r,
633 g,
634 b;
635
636 (void) FormatLocaleFile(stdout," HSLToRGB");
637 ConvertHSLToRGB(110.200859/360.0,0.882623,0.715163,&r,&g,&b);
638 if ((fabs(r-0.545877*QuantumRange) >= ReferenceEpsilon) ||
639 (fabs(g-0.966567*QuantumRange) >= ReferenceEpsilon) ||
640 (fabs(b-0.463759*QuantumRange) >= ReferenceEpsilon))
641 return(MagickFalse);
642 return(MagickTrue);
643 }
644
ValidateRGBToHSL()645 static MagickBooleanType ValidateRGBToHSL()
646 {
647 double
648 h,
649 l,
650 s;
651
652 (void) FormatLocaleFile(stdout," RGBToHSL");
653 ConvertRGBToHSL(0.545877*QuantumRange,0.966567*QuantumRange,
654 0.463759*QuantumRange,&h,&s,&l);
655 if ((fabs(h-110.200859/360.0) >= ReferenceEpsilon) ||
656 (fabs(s-0.882623) >= ReferenceEpsilon) ||
657 (fabs(l-0.715163) >= ReferenceEpsilon))
658 return(MagickFalse);
659 return(MagickTrue);
660 }
661
ValidateHSVToRGB()662 static MagickBooleanType ValidateHSVToRGB()
663 {
664 double
665 r,
666 g,
667 b;
668
669 (void) FormatLocaleFile(stdout," HSVToRGB");
670 ConvertHSVToRGB(110.200859/360.0,0.520200,0.966567,&r,&g,&b);
671 if ((fabs(r-0.545877*QuantumRange) >= ReferenceEpsilon) ||
672 (fabs(g-0.966567*QuantumRange) >= ReferenceEpsilon) ||
673 (fabs(b-0.463759*QuantumRange) >= ReferenceEpsilon))
674 return(MagickFalse);
675 return(MagickTrue);
676 }
677
ValidateRGBToHSV()678 static MagickBooleanType ValidateRGBToHSV()
679 {
680 double
681 h,
682 s,
683 v;
684
685 (void) FormatLocaleFile(stdout," RGBToHSV");
686 ConvertRGBToHSV(0.545877*QuantumRange,0.966567*QuantumRange,
687 0.463759*QuantumRange,&h,&s,&v);
688 if ((fabs(h-110.200859/360.0) >= ReferenceEpsilon) ||
689 (fabs(s-0.520200) >= ReferenceEpsilon) ||
690 (fabs(v-0.966567) >= ReferenceEpsilon))
691 return(MagickFalse);
692 return(MagickTrue);
693 }
694
ValidateRGBToJPEGYCbCr()695 static MagickBooleanType ValidateRGBToJPEGYCbCr()
696 {
697 double
698 Cb,
699 Cr,
700 Y;
701
702 (void) FormatLocaleFile(stdout," RGBToJPEGYCbCr");
703 ConvertRGBToYCbCr(0.545877*QuantumRange,0.966567*QuantumRange,
704 0.463759*QuantumRange,&Y,&Cb,&Cr);
705 if ((fabs(Y-0.783460) >= ReferenceEpsilon) ||
706 (fabs(Cb-0.319581) >= ReferenceEpsilon) ||
707 (fabs(Cr-0.330539) >= ReferenceEpsilon))
708 return(MagickFalse);
709 return(MagickTrue);
710 }
711
ValidateJPEGYCbCrToRGB()712 static MagickBooleanType ValidateJPEGYCbCrToRGB()
713 {
714 double
715 r,
716 g,
717 b;
718
719 (void) FormatLocaleFile(stdout," JPEGYCbCrToRGB");
720 ConvertYCbCrToRGB(0.783460,0.319581,0.330539,&r,&g,&b);
721 if ((fabs(r-0.545877*QuantumRange) >= ReferenceEpsilon) ||
722 (fabs(g-0.966567*QuantumRange) >= ReferenceEpsilon) ||
723 (fabs(b-0.463759*QuantumRange) >= ReferenceEpsilon))
724 return(MagickFalse);
725 return(MagickTrue);
726 }
727
ValidateLabToRGB()728 static MagickBooleanType ValidateLabToRGB()
729 {
730 double
731 r,
732 g,
733 b;
734
735 (void) FormatLocaleFile(stdout," LabToRGB");
736 ConvertLabToRGB(88.456154/100.0,-54.671483/255+0.5,51.662818/255.0+0.5,
737 &r,&g,&b);
738 if ((fabs(r-0.545877*QuantumRange) >= ReferenceEpsilon) ||
739 (fabs(g-0.966567*QuantumRange) >= ReferenceEpsilon) ||
740 (fabs(b-0.463759*QuantumRange) >= ReferenceEpsilon))
741 return(MagickFalse);
742 return(MagickTrue);
743 }
744
ValidateRGBToLab()745 static MagickBooleanType ValidateRGBToLab()
746 {
747 double
748 a,
749 b,
750 L;
751
752 (void) FormatLocaleFile(stdout," RGBToLab");
753 ConvertRGBToLab(0.545877*QuantumRange,0.966567*QuantumRange,
754 0.463759*QuantumRange,&L,&a,&b);
755 if ((fabs(L-(88.456154/100.0)) >= ReferenceEpsilon) ||
756 (fabs(a-(-54.671483/255.0+0.5)) >= ReferenceEpsilon) ||
757 (fabs(b-(51.662818/255.0+0.5)) >= ReferenceEpsilon))
758 return(MagickFalse);
759 return(MagickTrue);
760 }
761
ValidateLchToRGB()762 static MagickBooleanType ValidateLchToRGB()
763 {
764 double
765 b,
766 g,
767 r;
768
769 (void) FormatLocaleFile(stdout," LchToRGB");
770 ConvertLCHabToRGB(88.456154/100.0,75.219797/255.0+0.5,136.620717/360.0,
771 &r,&g,&b);
772 if ((fabs(r-0.545877*QuantumRange) >= ReferenceEpsilon) ||
773 (fabs(g-0.966567*QuantumRange) >= ReferenceEpsilon) ||
774 (fabs(b-0.463759*QuantumRange) >= ReferenceEpsilon))
775 return(MagickFalse);
776 return(MagickTrue);
777 }
778
ValidateRGBToLch()779 static MagickBooleanType ValidateRGBToLch()
780 {
781 double
782 c,
783 h,
784 L;
785
786 (void) FormatLocaleFile(stdout," RGBToLch");
787 ConvertRGBToLCHab(0.545877*QuantumRange,0.966567*QuantumRange,
788 0.463759*QuantumRange,&L,&c,&h);
789 if ((fabs(L-88.456154/100.0) >= ReferenceEpsilon) ||
790 (fabs(c-(75.219797/255.0+0.5)) >= ReferenceEpsilon) ||
791 (fabs(h-(136.620717/255.0+0.5)) >= ReferenceEpsilon))
792 return(MagickFalse);
793 return(MagickTrue);
794 }
795
ValidateRGBToLMS()796 static MagickBooleanType ValidateRGBToLMS()
797 {
798 double
799 L,
800 M,
801 S;
802
803 (void) FormatLocaleFile(stdout," RGBToLMS");
804 ConvertRGBToLMS(0.545877*QuantumRange,0.966567*QuantumRange,
805 0.463759*QuantumRange,&L,&M,&S);
806 if ((fabs(L-0.611749) >= ReferenceEpsilon) ||
807 (fabs(M-0.910088) >= ReferenceEpsilon) ||
808 (fabs(S-0.294880) >= ReferenceEpsilon))
809 return(MagickFalse);
810 return(MagickTrue);
811 }
812
ValidateLMSToRGB()813 static MagickBooleanType ValidateLMSToRGB()
814 {
815 double
816 r,
817 g,
818 b;
819
820 (void) FormatLocaleFile(stdout," LMSToRGB");
821 ConvertLMSToRGB(0.611749,0.910088,0.294880,&r,&g,&b);
822 if ((fabs(r-0.545877*QuantumRange) >= ReferenceEpsilon) ||
823 (fabs(g-0.966567*QuantumRange) >= ReferenceEpsilon) ||
824 (fabs(b-0.463759*QuantumRange) >= ReferenceEpsilon))
825 return(MagickFalse);
826 return(MagickTrue);
827 }
828
ValidateRGBToLuv()829 static MagickBooleanType ValidateRGBToLuv()
830 {
831 double
832 l,
833 u,
834 v;
835
836 (void) FormatLocaleFile(stdout," RGBToLuv");
837 ConvertRGBToLuv(0.545877*QuantumRange,0.966567*QuantumRange,
838 0.463759*QuantumRange,&l,&u,&v);
839 if ((fabs(l-88.456154/262.0) >= ReferenceEpsilon) ||
840 (fabs(u-(-51.330414+134.0)/354.0) >= ReferenceEpsilon) ||
841 (fabs(v-(76.405526+140.0)/262.0) >= ReferenceEpsilon))
842 return(MagickFalse);
843 return(MagickTrue);
844 }
845
ValidateLuvToRGB()846 static MagickBooleanType ValidateLuvToRGB()
847 {
848 double
849 r,
850 g,
851 b;
852
853 (void) FormatLocaleFile(stdout," LuvToRGB");
854 ConvertLuvToRGB(88.456154/100.0,(-51.330414+134.0)/354.0,
855 (76.405526+140.0)/262.0,&r,&g,&b);
856 if ((fabs(r-0.545877*QuantumRange) >= ReferenceEpsilon) ||
857 (fabs(g-0.966567*QuantumRange) >= ReferenceEpsilon) ||
858 (fabs(b-0.463759*QuantumRange) >= ReferenceEpsilon))
859 return(MagickFalse);
860 return(MagickTrue);
861 }
862
ValidateRGBToXYZ()863 static MagickBooleanType ValidateRGBToXYZ()
864 {
865 double
866 x,
867 y,
868 z;
869
870 (void) FormatLocaleFile(stdout," RGBToXYZ");
871 ConvertRGBToXYZ(0.545877*QuantumRange,0.966567*QuantumRange,
872 0.463759*QuantumRange,&x,&y,&z);
873 if ((fabs(x-0.470646) >= ReferenceEpsilon) ||
874 (fabs(y-0.730178) >= ReferenceEpsilon) ||
875 (fabs(z-0.288324) >= ReferenceEpsilon))
876 return(MagickFalse);
877 return(MagickTrue);
878 }
879
ValidateXYZToRGB()880 static MagickBooleanType ValidateXYZToRGB()
881 {
882 double
883 r,
884 g,
885 b;
886
887 (void) FormatLocaleFile(stdout," XYZToRGB");
888 ConvertXYZToRGB(0.470646,0.730178,0.288324,&r,&g,&b);
889 if ((fabs(r-0.545877*QuantumRange) >= ReferenceEpsilon) ||
890 (fabs(g-0.966567*QuantumRange) >= ReferenceEpsilon) ||
891 (fabs(b-0.463759*QuantumRange) >= ReferenceEpsilon))
892 return(MagickFalse);
893 return(MagickTrue);
894 }
895
ValidateYDbDrToRGB()896 static MagickBooleanType ValidateYDbDrToRGB()
897 {
898 double
899 r,
900 g,
901 b;
902
903 (void) FormatLocaleFile(stdout," YDbDrToRGB");
904 ConvertYDbDrToRGB(0.783460,-0.480932+0.5,0.451670+0.5,&r,&g,&b);
905 if ((fabs(r-0.545877*QuantumRange) >= ReferenceEpsilon) ||
906 (fabs(g-0.966567*QuantumRange) >= ReferenceEpsilon) ||
907 (fabs(b-0.463759*QuantumRange) >= ReferenceEpsilon))
908 return(MagickFalse);
909 return(MagickTrue);
910 }
911
ValidateRGBToYDbDr()912 static MagickBooleanType ValidateRGBToYDbDr()
913 {
914 double
915 Db,
916 Dr,
917 Y;
918
919 (void) FormatLocaleFile(stdout," RGBToYDbDr");
920 ConvertRGBToYDbDr(0.545877*QuantumRange,0.966567*QuantumRange,
921 0.463759*QuantumRange,&Y,&Db,&Dr);
922 if ((fabs(Y-0.783460) >= ReferenceEpsilon) ||
923 (fabs(Db-(-0.480932)) >= ReferenceEpsilon) ||
924 (fabs(Dr-0.451670) >= ReferenceEpsilon))
925 return(MagickFalse);
926 return(MagickTrue);
927 }
928
ValidateRGBToYIQ()929 static MagickBooleanType ValidateRGBToYIQ()
930 {
931 double
932 i,
933 q,
934 y;
935
936 (void) FormatLocaleFile(stdout," RGBToYIQ");
937 ConvertRGBToYIQ(0.545877*QuantumRange,0.966567*QuantumRange,
938 0.463759*QuantumRange,&y,&i,&q);
939 if ((fabs(y-0.783460) >= ReferenceEpsilon) ||
940 (fabs(i-(-0.089078)) >= ReferenceEpsilon) ||
941 (fabs(q-(-0.245399)) >= ReferenceEpsilon))
942 return(MagickFalse);
943 return(MagickTrue);
944 }
945
ValidateYIQToRGB()946 static MagickBooleanType ValidateYIQToRGB()
947 {
948 double
949 r,
950 g,
951 b;
952
953 (void) FormatLocaleFile(stdout," YIQToRGB");
954 ConvertYIQToRGB(0.783460,-0.089078+0.5,-0.245399+0.5,&r,&g,&b);
955 if ((fabs(r-0.545877*QuantumRange) >= ReferenceEpsilon) ||
956 (fabs(g-0.966567*QuantumRange) >= ReferenceEpsilon) ||
957 (fabs(b-0.463759*QuantumRange) >= ReferenceEpsilon))
958 return(MagickFalse);
959 return(MagickTrue);
960 }
961
ValidateRGBToYPbPr()962 static MagickBooleanType ValidateRGBToYPbPr()
963 {
964 double
965 Pb,
966 Pr,
967 y;
968
969 (void) FormatLocaleFile(stdout," RGBToYPbPr");
970 ConvertRGBToYPbPr(0.545877*QuantumRange,0.966567*QuantumRange,
971 0.463759*QuantumRange,&y,&Pb,&Pr);
972 if ((fabs(y-0.783460) >= ReferenceEpsilon) ||
973 (fabs(Pb-(-0.180419)) >= ReferenceEpsilon) ||
974 (fabs(Pr-(-0.169461)) >= ReferenceEpsilon))
975 return(MagickFalse);
976 return(MagickTrue);
977 }
978
ValidateYPbPrToRGB()979 static MagickBooleanType ValidateYPbPrToRGB()
980 {
981 double
982 r,
983 g,
984 b;
985
986 (void) FormatLocaleFile(stdout," YPbPrToRGB");
987 ConvertYPbPrToRGB(0.783460,-0.180419+0.5,-0.169461+0.5,&r,&g,&b);
988 if ((fabs(r-0.545877*QuantumRange) >= ReferenceEpsilon) ||
989 (fabs(g-0.966567*QuantumRange) >= ReferenceEpsilon) ||
990 (fabs(b-0.463759*QuantumRange) >= ReferenceEpsilon))
991 return(MagickFalse);
992 return(MagickTrue);
993 }
994
ValidateRGBToYUV()995 static MagickBooleanType ValidateRGBToYUV()
996 {
997 double
998 U,
999 V,
1000 Y;
1001
1002 (void) FormatLocaleFile(stdout," RGBToYUV");
1003 ConvertRGBToYUV(0.545877*QuantumRange,0.966567*QuantumRange,
1004 0.463759*QuantumRange,&Y,&U,&V);
1005 if ((fabs(Y-0.783460) >= ReferenceEpsilon) ||
1006 (fabs(U-(-0.157383)) >= ReferenceEpsilon) ||
1007 (fabs(V-(-0.208443)) >= ReferenceEpsilon))
1008 return(MagickFalse);
1009 return(MagickTrue);
1010 }
1011
ValidateYUVToRGB()1012 static MagickBooleanType ValidateYUVToRGB()
1013 {
1014 double
1015 r,
1016 g,
1017 b;
1018
1019 (void) FormatLocaleFile(stdout," YUVToRGB");
1020 ConvertYUVToRGB(0.783460,-0.157383+0.5,-0.208443+0.5,&r,&g,&b);
1021 if ((fabs(r-0.545877*QuantumRange) >= ReferenceEpsilon) ||
1022 (fabs(g-0.966567*QuantumRange) >= ReferenceEpsilon) ||
1023 (fabs(b-0.463759*QuantumRange) >= ReferenceEpsilon))
1024 return(MagickFalse);
1025 return(MagickTrue);
1026 }
1027
ValidateColorspaces(ImageInfo * image_info,size_t * fail,ExceptionInfo * exception)1028 static size_t ValidateColorspaces(ImageInfo *image_info,size_t *fail,
1029 ExceptionInfo *exception)
1030 {
1031 MagickBooleanType
1032 status;
1033
1034 size_t
1035 test;
1036
1037 /*
1038 Reference: https://code.google.com/p/chroma.
1039
1040 Illuminant = D65
1041 Observer = 2° (1931)
1042
1043 XYZ 0.470645, 0.730177, 0.288323
1044 sRGB 0.545877, 0.966567, 0.463759
1045 CAT02 LMS 0.611749, 0.910088, 0.294880
1046 Y'DbDr 0.783460, -0.480932, 0.451670
1047 Y'IQ 0.783460, -0.089078, -0.245399
1048 Y'PbPr 0.783460, -0.180419, -0.169461
1049 Y'UV 0.783460, -0.157383, -0.208443
1050 JPEG-Y'CbCr 0.783460, 0.319581, 0.330539
1051 L*u*v* 88.456154, -51.330414, 76.405526
1052 L*a*b* 88.456154, -54.671483, 51.662818
1053 L*C*H* 88.456154, 75.219797, 136.620717
1054 HSV 110.200859, 0.520200, 0.966567
1055 HSL 110.200859, 0.882623, 0.715163
1056 HSI 111.244375, 0.295985, 0.658734
1057 Y'CbCr 187.577791, 87.586330, 90.040886
1058 */
1059 (void) FormatLocaleFile(stdout,"validate colorspaces:\n");
1060 for (test=0; test < 26; test++)
1061 {
1062 CatchException(exception);
1063 (void) FormatLocaleFile(stdout," test %.20g: ",(double) test);
1064 switch (test)
1065 {
1066 case 0: status=ValidateHSIToRGB(); break;
1067 case 1: status=ValidateRGBToHSI(); break;
1068 case 2: status=ValidateHSLToRGB(); break;
1069 case 3: status=ValidateRGBToHSL(); break;
1070 case 4: status=ValidateHSVToRGB(); break;
1071 case 5: status=ValidateRGBToHSV(); break;
1072 case 6: status=ValidateJPEGYCbCrToRGB(); break;
1073 case 7: status=ValidateRGBToJPEGYCbCr(); break;
1074 case 8: status=ValidateLabToRGB(); break;
1075 case 9: status=ValidateRGBToLab(); break;
1076 case 10: status=ValidateLchToRGB(); break;
1077 case 11: status=ValidateRGBToLch(); break;
1078 case 12: status=ValidateLMSToRGB(); break;
1079 case 13: status=ValidateRGBToLMS(); break;
1080 case 14: status=ValidateLuvToRGB(); break;
1081 case 15: status=ValidateRGBToLuv(); break;
1082 case 16: status=ValidateXYZToRGB(); break;
1083 case 17: status=ValidateRGBToXYZ(); break;
1084 case 18: status=ValidateYDbDrToRGB(); break;
1085 case 19: status=ValidateRGBToYDbDr(); break;
1086 case 20: status=ValidateYIQToRGB(); break;
1087 case 21: status=ValidateRGBToYIQ(); break;
1088 case 22: status=ValidateYPbPrToRGB(); break;
1089 case 23: status=ValidateRGBToYPbPr(); break;
1090 case 24: status=ValidateYUVToRGB(); break;
1091 case 25: status=ValidateRGBToYUV(); break;
1092 default: status=MagickFalse;
1093 }
1094 if (status == MagickFalse)
1095 {
1096 (void) FormatLocaleFile(stdout,"... fail @ %s/%s/%lu.\n",
1097 GetMagickModule());
1098 (*fail)++;
1099 continue;
1100 }
1101 (void) FormatLocaleFile(stdout,"... pass.\n");
1102 }
1103 (void) FormatLocaleFile(stdout,
1104 " summary: %.20g subtests; %.20g passed; %.20g failed.\n",(double) test,
1105 (double) (test-(*fail)),(double) *fail);
1106 return(test);
1107 }
1108
1109 /*
1110 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1111 % %
1112 % %
1113 % %
1114 % V a l i d a t e C o m p a r e C o m m a n d %
1115 % %
1116 % %
1117 % %
1118 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1119 %
1120 % ValidateCompareCommand() validates the ImageMagick compare command line
1121 % program and returns the number of validation tests that passed and failed.
1122 %
1123 % The format of the ValidateCompareCommand method is:
1124 %
1125 % size_t ValidateCompareCommand(ImageInfo *image_info,
1126 % const char *reference_filename,const char *output_filename,
1127 % size_t *fail,ExceptionInfo *exception)
1128 %
1129 % A description of each parameter follows:
1130 %
1131 % o image_info: the image info.
1132 %
1133 % o reference_filename: the reference image filename.
1134 %
1135 % o output_filename: the output image filename.
1136 %
1137 % o fail: return the number of validation tests that pass.
1138 %
1139 % o exception: return any errors or warnings in this structure.
1140 %
1141 */
ValidateCompareCommand(ImageInfo * image_info,const char * reference_filename,const char * output_filename,size_t * fail,ExceptionInfo * exception)1142 static size_t ValidateCompareCommand(ImageInfo *image_info,
1143 const char *reference_filename,const char *output_filename,size_t *fail,
1144 ExceptionInfo *exception)
1145 {
1146 char
1147 **arguments,
1148 command[MagickPathExtent];
1149
1150 int
1151 number_arguments;
1152
1153 MagickBooleanType
1154 status;
1155
1156 register ssize_t
1157 i,
1158 j;
1159
1160 size_t
1161 test;
1162
1163 test=0;
1164 (void) FormatLocaleFile(stdout,"validate compare command line program:\n");
1165 for (i=0; compare_options[i] != (char *) NULL; i++)
1166 {
1167 CatchException(exception);
1168 (void) FormatLocaleFile(stdout," test %.20g: %s",(double) (test++),
1169 compare_options[i]);
1170 (void) FormatLocaleString(command,MagickPathExtent,"%s %s %s %s",
1171 compare_options[i],reference_filename,reference_filename,output_filename);
1172 arguments=StringToArgv(command,&number_arguments);
1173 if (arguments == (char **) NULL)
1174 {
1175 (void) FormatLocaleFile(stdout,"... fail @ %s/%s/%lu.\n",
1176 GetMagickModule());
1177 (void) LogMagickEvent(ExceptionEvent,GetMagickModule(),"%s",
1178 exception->reason);
1179 (*fail)++;
1180 continue;
1181 }
1182 status=CompareImagesCommand(image_info,number_arguments,arguments,
1183 (char **) NULL,exception);
1184 for (j=0; j < (ssize_t) number_arguments; j++)
1185 arguments[j]=DestroyString(arguments[j]);
1186 arguments=(char **) RelinquishMagickMemory(arguments);
1187 if (status == MagickFalse)
1188 {
1189 (void) FormatLocaleFile(stdout,"... fail @ %s/%s/%lu.\n",
1190 GetMagickModule());
1191 (void) LogMagickEvent(ExceptionEvent,GetMagickModule(),"%s",
1192 exception->reason);
1193 (*fail)++;
1194 continue;
1195 }
1196 (void) FormatLocaleFile(stdout,"... pass.\n");
1197 }
1198 (void) FormatLocaleFile(stdout,
1199 " summary: %.20g subtests; %.20g passed; %.20g failed.\n",(double) test,
1200 (double) (test-(*fail)),(double) *fail);
1201 return(test);
1202 }
1203
1204 /*
1205 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1206 % %
1207 % %
1208 % %
1209 % V a l i d a t e C o m p o s i t e C o m m a n d %
1210 % %
1211 % %
1212 % %
1213 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1214 %
1215 % ValidateCompositeCommand() validates the ImageMagick composite command line
1216 % program and returns the number of validation tests that passed and failed.
1217 %
1218 % The format of the ValidateCompositeCommand method is:
1219 %
1220 % size_t ValidateCompositeCommand(ImageInfo *image_info,
1221 % const char *reference_filename,const char *output_filename,
1222 % size_t *fail,ExceptionInfo *exception)
1223 %
1224 % A description of each parameter follows:
1225 %
1226 % o image_info: the image info.
1227 %
1228 % o reference_filename: the reference image filename.
1229 %
1230 % o output_filename: the output image filename.
1231 %
1232 % o fail: return the number of validation tests that pass.
1233 %
1234 % o exception: return any errors or warnings in this structure.
1235 %
1236 */
ValidateCompositeCommand(ImageInfo * image_info,const char * reference_filename,const char * output_filename,size_t * fail,ExceptionInfo * exception)1237 static size_t ValidateCompositeCommand(ImageInfo *image_info,
1238 const char *reference_filename,const char *output_filename,size_t *fail,
1239 ExceptionInfo *exception)
1240 {
1241 char
1242 **arguments,
1243 command[MagickPathExtent];
1244
1245 int
1246 number_arguments;
1247
1248 MagickBooleanType
1249 status;
1250
1251 register ssize_t
1252 i,
1253 j;
1254
1255 size_t
1256 test;
1257
1258 test=0;
1259 (void) FormatLocaleFile(stdout,"validate composite command line program:\n");
1260 for (i=0; composite_options[i] != (char *) NULL; i++)
1261 {
1262 CatchException(exception);
1263 (void) FormatLocaleFile(stdout," test %.20g: %s",(double) (test++),
1264 composite_options[i]);
1265 (void) FormatLocaleString(command,MagickPathExtent,"%s %s %s %s",
1266 reference_filename,composite_options[i],reference_filename,
1267 output_filename);
1268 arguments=StringToArgv(command,&number_arguments);
1269 if (arguments == (char **) NULL)
1270 {
1271 (void) FormatLocaleFile(stdout,"... fail @ %s/%s/%lu.\n",
1272 GetMagickModule());
1273 (*fail)++;
1274 continue;
1275 }
1276 status=CompositeImageCommand(image_info,number_arguments,arguments,
1277 (char **) NULL,exception);
1278 for (j=0; j < (ssize_t) number_arguments; j++)
1279 arguments[j]=DestroyString(arguments[j]);
1280 arguments=(char **) RelinquishMagickMemory(arguments);
1281 if (status == MagickFalse)
1282 {
1283 (void) FormatLocaleFile(stdout,"... fail @ %s/%s/%lu.\n",
1284 GetMagickModule());
1285 (*fail)++;
1286 continue;
1287 }
1288 (void) FormatLocaleFile(stdout,"... pass.\n");
1289 }
1290 (void) FormatLocaleFile(stdout,
1291 " summary: %.20g subtests; %.20g passed; %.20g failed.\n",(double) test,
1292 (double) (test-(*fail)),(double) *fail);
1293 return(test);
1294 }
1295
1296 /*
1297 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1298 % %
1299 % %
1300 % %
1301 % V a l i d a t e C o n v e r t C o m m a n d %
1302 % %
1303 % %
1304 % %
1305 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1306 %
1307 % ValidateConvertCommand() validates the ImageMagick convert command line
1308 % program and returns the number of validation tests that passed and failed.
1309 %
1310 % The format of the ValidateConvertCommand method is:
1311 %
1312 % size_t ValidateConvertCommand(ImageInfo *image_info,
1313 % const char *reference_filename,const char *output_filename,
1314 % size_t *fail,ExceptionInfo *exception)
1315 %
1316 % A description of each parameter follows:
1317 %
1318 % o image_info: the image info.
1319 %
1320 % o reference_filename: the reference image filename.
1321 %
1322 % o output_filename: the output image filename.
1323 %
1324 % o fail: return the number of validation tests that pass.
1325 %
1326 % o exception: return any errors or warnings in this structure.
1327 %
1328 */
ValidateConvertCommand(ImageInfo * image_info,const char * reference_filename,const char * output_filename,size_t * fail,ExceptionInfo * exception)1329 static size_t ValidateConvertCommand(ImageInfo *image_info,
1330 const char *reference_filename,const char *output_filename,size_t *fail,
1331 ExceptionInfo *exception)
1332 {
1333 char
1334 **arguments,
1335 command[MagickPathExtent];
1336
1337 int
1338 number_arguments;
1339
1340 MagickBooleanType
1341 status;
1342
1343 register ssize_t
1344 i,
1345 j;
1346
1347 size_t
1348 test;
1349
1350 test=0;
1351 (void) FormatLocaleFile(stdout,"validate convert command line program:\n");
1352 for (i=0; convert_options[i] != (char *) NULL; i++)
1353 {
1354 CatchException(exception);
1355 (void) FormatLocaleFile(stdout," test %.20g: %s",(double) test++,
1356 convert_options[i]);
1357 (void) FormatLocaleString(command,MagickPathExtent,"%s %s %s %s",
1358 reference_filename,convert_options[i],reference_filename,output_filename);
1359 arguments=StringToArgv(command,&number_arguments);
1360 if (arguments == (char **) NULL)
1361 {
1362 (void) FormatLocaleFile(stdout,"... fail @ %s/%s/%lu.\n",
1363 GetMagickModule());
1364 (*fail)++;
1365 continue;
1366 }
1367 status=ConvertImageCommand(image_info,number_arguments,arguments,
1368 (char **) NULL,exception);
1369 for (j=0; j < (ssize_t) number_arguments; j++)
1370 arguments[j]=DestroyString(arguments[j]);
1371 arguments=(char **) RelinquishMagickMemory(arguments);
1372 if (status == MagickFalse)
1373 {
1374 (void) FormatLocaleFile(stdout,"... fail @ %s/%s/%lu.\n",
1375 GetMagickModule());
1376 (*fail)++;
1377 continue;
1378 }
1379 (void) FormatLocaleFile(stdout,"... pass.\n");
1380 }
1381 (void) FormatLocaleFile(stdout,
1382 " summary: %.20g subtests; %.20g passed; %.20g failed.\n",(double) test,
1383 (double) (test-(*fail)),(double) *fail);
1384 return(test);
1385 }
1386
1387 /*
1388 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1389 % %
1390 % %
1391 % %
1392 % V a l i d a t e I d e n t i f y C o m m a n d %
1393 % %
1394 % %
1395 % %
1396 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1397 %
1398 % ValidateIdentifyCommand() validates the ImageMagick identify command line
1399 % program and returns the number of validation tests that passed and failed.
1400 %
1401 % The format of the ValidateIdentifyCommand method is:
1402 %
1403 % size_t ValidateIdentifyCommand(ImageInfo *image_info,
1404 % const char *reference_filename,const char *output_filename,
1405 % size_t *fail,ExceptionInfo *exception)
1406 %
1407 % A description of each parameter follows:
1408 %
1409 % o image_info: the image info.
1410 %
1411 % o reference_filename: the reference image filename.
1412 %
1413 % o output_filename: the output image filename.
1414 %
1415 % o fail: return the number of validation tests that pass.
1416 %
1417 % o exception: return any errors or warnings in this structure.
1418 %
1419 */
ValidateIdentifyCommand(ImageInfo * image_info,const char * reference_filename,const char * output_filename,size_t * fail,ExceptionInfo * exception)1420 static size_t ValidateIdentifyCommand(ImageInfo *image_info,
1421 const char *reference_filename,const char *output_filename,size_t *fail,
1422 ExceptionInfo *exception)
1423 {
1424 char
1425 **arguments,
1426 command[MagickPathExtent];
1427
1428 int
1429 number_arguments;
1430
1431 MagickBooleanType
1432 status;
1433
1434 register ssize_t
1435 i,
1436 j;
1437
1438 size_t
1439 test;
1440
1441 (void) output_filename;
1442 test=0;
1443 (void) FormatLocaleFile(stdout,"validate identify command line program:\n");
1444 for (i=0; identify_options[i] != (char *) NULL; i++)
1445 {
1446 CatchException(exception);
1447 (void) FormatLocaleFile(stdout," test %.20g: %s",(double) test++,
1448 identify_options[i]);
1449 (void) FormatLocaleString(command,MagickPathExtent,"%s %s",
1450 identify_options[i],reference_filename);
1451 arguments=StringToArgv(command,&number_arguments);
1452 if (arguments == (char **) NULL)
1453 {
1454 (void) FormatLocaleFile(stdout,"... fail @ %s/%s/%lu.\n",
1455 GetMagickModule());
1456 (*fail)++;
1457 continue;
1458 }
1459 status=IdentifyImageCommand(image_info,number_arguments,arguments,
1460 (char **) NULL,exception);
1461 for (j=0; j < (ssize_t) number_arguments; j++)
1462 arguments[j]=DestroyString(arguments[j]);
1463 arguments=(char **) RelinquishMagickMemory(arguments);
1464 if (status == MagickFalse)
1465 {
1466 (void) FormatLocaleFile(stdout,"... fail @ %s/%s/%lu.\n",
1467 GetMagickModule());
1468 (*fail)++;
1469 continue;
1470 }
1471 (void) FormatLocaleFile(stdout,"... pass.\n");
1472 }
1473 (void) FormatLocaleFile(stdout,
1474 " summary: %.20g subtests; %.20g passed; %.20g failed.\n",(double) test,
1475 (double) (test-(*fail)),(double) *fail);
1476 return(test);
1477 }
1478
1479 /*
1480 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1481 % %
1482 % %
1483 % %
1484 % V a l i d a t e I m a g e F o r m a t s I n M e m o r y %
1485 % %
1486 % %
1487 % %
1488 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1489 %
1490 % ValidateImageFormatsInMemory() validates the ImageMagick image formats in
1491 % memory and returns the number of validation tests that passed and failed.
1492 %
1493 % The format of the ValidateImageFormatsInMemory method is:
1494 %
1495 % size_t ValidateImageFormatsInMemory(ImageInfo *image_info,
1496 % const char *reference_filename,const char *output_filename,
1497 % size_t *fail,ExceptionInfo *exception)
1498 %
1499 % A description of each parameter follows:
1500 %
1501 % o image_info: the image info.
1502 %
1503 % o reference_filename: the reference image filename.
1504 %
1505 % o output_filename: the output image filename.
1506 %
1507 % o fail: return the number of validation tests that pass.
1508 %
1509 % o exception: return any errors or warnings in this structure.
1510 %
1511 */
1512
1513 /*
1514 Enable this to count remaining $TMPDIR/magick-* files. Note that the count
1515 includes any files left over from other runs.
1516 */
1517 #undef MagickCountTempFiles
1518
ValidateImageFormatsInMemory(ImageInfo * image_info,const char * reference_filename,const char * output_filename,size_t * fail,ExceptionInfo * exception)1519 static size_t ValidateImageFormatsInMemory(ImageInfo *image_info,
1520 const char *reference_filename,const char *output_filename,size_t *fail,
1521 ExceptionInfo *exception)
1522 {
1523 char
1524 #ifdef MagickCountTempFiles
1525 path[MagickPathExtent],
1526 SystemCommand[MagickPathExtent],
1527 #endif
1528 size[MagickPathExtent];
1529
1530 const MagickInfo
1531 *magick_info;
1532
1533 double
1534 distortion,
1535 fuzz;
1536
1537 Image
1538 *difference_image,
1539 *ping_image,
1540 *reconstruct_image,
1541 *reference_image;
1542
1543 MagickBooleanType
1544 status;
1545
1546 register ssize_t
1547 i,
1548 j;
1549
1550 size_t
1551 length,
1552 test;
1553
1554 unsigned char
1555 *blob;
1556
1557 test=0;
1558 (void) FormatLocaleFile(stdout,"validate image formats in memory:\n");
1559
1560 #ifdef MagickCountTempFiles
1561 (void)GetPathTemplate(path);
1562 /* Remove file template except for the leading "/path/to/magick-" */
1563 path[strlen(path)-17]='\0';
1564 (void) FormatLocaleFile(stdout," tmp path is '%s*'\n",path);
1565 #endif
1566
1567 for (i=0; reference_formats[i].magick != (char *) NULL; i++)
1568 {
1569 magick_info=GetMagickInfo(reference_formats[i].magick,exception);
1570 if ((magick_info == (const MagickInfo *) NULL) ||
1571 (magick_info->decoder == (DecodeImageHandler *) NULL) ||
1572 (magick_info->encoder == (EncodeImageHandler *) NULL))
1573 continue;
1574 for (j=0; reference_types[j].type != UndefinedType; j++)
1575 {
1576 /*
1577 Generate reference image.
1578 */
1579 CatchException(exception);
1580 (void) FormatLocaleFile(stdout," test %.20g: %s/%s/%s/%.20g-bits",
1581 (double) (test++),reference_formats[i].magick,CommandOptionToMnemonic(
1582 MagickCompressOptions,reference_formats[i].compression),
1583 CommandOptionToMnemonic(MagickTypeOptions,reference_types[j].type),
1584 (double) reference_types[j].depth);
1585 (void) CopyMagickString(image_info->filename,reference_filename,
1586 MagickPathExtent);
1587 reference_image=ReadImage(image_info,exception);
1588 if ((reference_image == (Image *) NULL) ||
1589 (exception->severity >= ErrorException))
1590 {
1591 (void) FormatLocaleFile(stdout,"... fail @ %s/%s/%lu.\n",
1592 GetMagickModule());
1593 if (exception->reason != (char *) NULL)
1594 (void) FormatLocaleFile(stdout," reason:%s\n",exception->reason);
1595 CatchException(exception);
1596 (*fail)++;
1597 continue;
1598 }
1599 /*
1600 Write reference image.
1601 */
1602 (void) FormatLocaleString(size,MagickPathExtent,"%.20gx%.20g",
1603 (double) reference_image->columns,(double) reference_image->rows);
1604 (void) CloneString(&image_info->size,size);
1605 image_info->depth=reference_types[j].depth;
1606 (void) FormatLocaleString(reference_image->filename,MagickPathExtent,
1607 "%s:%s",reference_formats[i].magick,output_filename);
1608 status=SetImageType(reference_image,reference_types[j].type,exception);
1609 if (status == MagickFalse || (exception->severity >= ErrorException))
1610 {
1611 (void) FormatLocaleFile(stdout,"... fail @ %s/%s/%lu.\n",
1612 GetMagickModule());
1613 if (exception->reason != (char *) NULL)
1614 (void) FormatLocaleFile(stdout," reason:%s\n",exception->reason);
1615 CatchException(exception);
1616 (*fail)++;
1617 reference_image=DestroyImage(reference_image);
1618 continue;
1619 }
1620 status=SetImageDepth(reference_image,reference_types[j].depth,exception);
1621 if (status == MagickFalse || (exception->severity >= ErrorException))
1622 {
1623 (void) FormatLocaleFile(stdout,"... fail @ %s/%s/%lu.\n",
1624 GetMagickModule());
1625 CatchException(exception);
1626 (*fail)++;
1627 reference_image=DestroyImage(reference_image);
1628 continue;
1629 }
1630 reference_image->compression=reference_formats[i].compression;
1631 status=WriteImage(image_info,reference_image,exception);
1632 reference_image=DestroyImage(reference_image);
1633 if (status == MagickFalse || (exception->severity >= ErrorException))
1634 {
1635 (void) FormatLocaleFile(stdout,"... fail @ %s/%s/%lu.\n",
1636 GetMagickModule());
1637 if (exception->reason != (char *) NULL)
1638 (void) FormatLocaleFile(stdout," reason:%s\n",exception->reason);
1639 CatchException(exception);
1640 (*fail)++;
1641 continue;
1642 }
1643 /*
1644 Ping reference image.
1645 */
1646 (void) FormatLocaleString(image_info->filename,MagickPathExtent,"%s:%s",
1647 reference_formats[i].magick,output_filename);
1648 ping_image=PingImage(image_info,exception);
1649 if (ping_image == (Image *) NULL ||
1650 (exception->severity >= ErrorException))
1651 {
1652 (void) FormatLocaleFile(stdout,"... fail @ %s/%s/%lu.\n",
1653 GetMagickModule());
1654 if (exception->reason != (char *) NULL)
1655 (void) FormatLocaleFile(stdout," reason:%s\n",exception->reason);
1656 CatchException(exception);
1657 (*fail)++;
1658 continue;
1659 }
1660 ping_image=DestroyImage(ping_image);
1661 /*
1662 Read reference image.
1663 */
1664 reference_image=ReadImage(image_info,exception);
1665 if ((reference_image == (Image *) NULL) ||
1666 (exception->severity >= ErrorException))
1667 {
1668 (void) FormatLocaleFile(stdout,"... fail @ %s/%s/%lu.\n",
1669 GetMagickModule());
1670 if (exception->reason != (char *) NULL)
1671 (void) FormatLocaleFile(stdout," reason:%s\n",exception->reason);
1672 CatchException(exception);
1673 (*fail)++;
1674 continue;
1675 }
1676 /*
1677 Write reference image.
1678 */
1679 (void) FormatLocaleString(reference_image->filename,MagickPathExtent,
1680 "%s:%s",reference_formats[i].magick,output_filename);
1681 (void) CopyMagickString(image_info->magick,reference_formats[i].magick,
1682 MagickPathExtent);
1683 reference_image->depth=reference_types[j].depth;
1684 reference_image->compression=reference_formats[i].compression;
1685 length=8192;
1686 blob=(unsigned char *) ImageToBlob(image_info,reference_image,&length,
1687 exception);
1688 if ((blob == (unsigned char *) NULL) ||
1689 (exception->severity >= ErrorException))
1690 {
1691 (void) FormatLocaleFile(stdout,"... fail @ %s/%s/%lu.\n",
1692 GetMagickModule());
1693 if (exception->reason != (char *) NULL)
1694 (void) FormatLocaleFile(stdout," reason:%s\n",exception->reason);
1695 CatchException(exception);
1696 (*fail)++;
1697 reference_image=DestroyImage(reference_image);
1698 continue;
1699 }
1700 /*
1701 Ping reference blob.
1702 */
1703 ping_image=PingBlob(image_info,blob,length,exception);
1704 if (ping_image == (Image *) NULL ||
1705 (exception->severity >= ErrorException))
1706 {
1707 (void) FormatLocaleFile(stdout,"... fail @ %s/%s/%lu.\n",
1708 GetMagickModule());
1709 if (exception->reason != (char *) NULL)
1710 (void) FormatLocaleFile(stdout," reason:%s\n",exception->reason);
1711 CatchException(exception);
1712 (*fail)++;
1713 blob=(unsigned char *) RelinquishMagickMemory(blob);
1714 continue;
1715 }
1716 ping_image=DestroyImage(ping_image);
1717 /*
1718 Read reconstruct image.
1719 */
1720 (void) FormatLocaleString(image_info->filename,MagickPathExtent,"%s:%s",
1721 reference_formats[i].magick,output_filename);
1722 reconstruct_image=BlobToImage(image_info,blob,length,exception);
1723 blob=(unsigned char *) RelinquishMagickMemory(blob);
1724 if (reconstruct_image == (Image *) NULL ||
1725 (exception->severity >= ErrorException))
1726 {
1727 (void) FormatLocaleFile(stdout,"... fail @ %s/%s/%lu.\n",
1728 GetMagickModule());
1729 if (exception->reason != (char *) NULL)
1730 (void) FormatLocaleFile(stdout," reason:%s\n",exception->reason);
1731 CatchException(exception);
1732 (*fail)++;
1733 reference_image=DestroyImage(reference_image);
1734 continue;
1735 }
1736 /*
1737 Compare reference to reconstruct image.
1738 */
1739 fuzz=0.003; /* grayscale */
1740 if (reference_formats[i].fuzz != 0.0)
1741 fuzz=reference_formats[i].fuzz;
1742 difference_image=CompareImages(reference_image,reconstruct_image,
1743 RootMeanSquaredErrorMetric,&distortion,exception);
1744 reconstruct_image=DestroyImage(reconstruct_image);
1745 reference_image=DestroyImage(reference_image);
1746 if (difference_image == (Image *) NULL ||
1747 (exception->severity >= ErrorException))
1748 {
1749 (void) FormatLocaleFile(stdout,"... fail @ %s/%s/%lu.\n",
1750 GetMagickModule());
1751 if (exception->reason != (char *) NULL)
1752 (void) FormatLocaleFile(stdout," reason:%s\n",exception->reason);
1753 CatchException(exception);
1754 (*fail)++;
1755 continue;
1756 }
1757 difference_image=DestroyImage(difference_image);
1758 if ((QuantumScale*distortion) > fuzz)
1759 {
1760 (void) FormatLocaleFile(stdout,"... fail (with distortion %g).\n",
1761 QuantumScale*distortion);
1762 (*fail)++;
1763 continue;
1764 }
1765 #ifdef MagickCountTempFiles
1766 (void) FormatLocaleFile(stdout,"... pass, ");
1767 (void) fflush(stdout);
1768 SystemCommand[0]='\0';
1769 (void) strncat(SystemCommand,"echo `ls ",9);
1770 (void) strncat(SystemCommand,path,MagickPathExtent-31);
1771 (void) strncat(SystemCommand,"* | wc -w` tmp files.",20);
1772 (void) system(SystemCommand);
1773 (void) fflush(stdout);
1774 #else
1775 (void) FormatLocaleFile(stdout,"... pass\n");
1776 #endif
1777 }
1778 }
1779 (void) FormatLocaleFile(stdout,
1780 " summary: %.20g subtests; %.20g passed; %.20g failed.\n",(double) test,
1781 (double) (test-(*fail)),(double) *fail);
1782 return(test);
1783 }
1784
1785 /*
1786 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1787 % %
1788 % %
1789 % %
1790 % V a l i d a t e I m a g e F o r m a t s O n D i s k %
1791 % %
1792 % %
1793 % %
1794 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1795 %
1796 % ValidateImageFormatsOnDisk() validates the ImageMagick image formats on disk
1797 % and returns the number of validation tests that passed and failed.
1798 %
1799 % The format of the ValidateImageFormatsOnDisk method is:
1800 %
1801 % size_t ValidateImageFormatsOnDisk(ImageInfo *image_info,
1802 % const char *reference_filename,const char *output_filename,
1803 % size_t *fail,ExceptionInfo *exception)
1804 %
1805 % A description of each parameter follows:
1806 %
1807 % o image_info: the image info.
1808 %
1809 % o reference_filename: the reference image filename.
1810 %
1811 % o output_filename: the output image filename.
1812 %
1813 % o fail: return the number of validation tests that pass.
1814 %
1815 % o exception: return any errors or warnings in this structure.
1816 %
1817 */
ValidateImageFormatsOnDisk(ImageInfo * image_info,const char * reference_filename,const char * output_filename,size_t * fail,ExceptionInfo * exception)1818 static size_t ValidateImageFormatsOnDisk(ImageInfo *image_info,
1819 const char *reference_filename,const char *output_filename,size_t *fail,
1820 ExceptionInfo *exception)
1821 {
1822 char
1823 size[MagickPathExtent];
1824
1825 const MagickInfo
1826 *magick_info;
1827
1828 double
1829 distortion,
1830 fuzz;
1831
1832 Image
1833 *difference_image,
1834 *reference_image,
1835 *reconstruct_image;
1836
1837 MagickBooleanType
1838 status;
1839
1840 register ssize_t
1841 i,
1842 j;
1843
1844 size_t
1845 test;
1846
1847 test=0;
1848 (void) FormatLocaleFile(stdout,"validate image formats on disk:\n");
1849 for (i=0; reference_formats[i].magick != (char *) NULL; i++)
1850 {
1851 magick_info=GetMagickInfo(reference_formats[i].magick,exception);
1852 if ((magick_info == (const MagickInfo *) NULL) ||
1853 (magick_info->decoder == (DecodeImageHandler *) NULL) ||
1854 (magick_info->encoder == (EncodeImageHandler *) NULL))
1855 continue;
1856 for (j=0; reference_types[j].type != UndefinedType; j++)
1857 {
1858 /*
1859 Generate reference image.
1860 */
1861 CatchException(exception);
1862 (void) FormatLocaleFile(stdout," test %.20g: %s/%s/%s/%.20g-bits",
1863 (double) (test++),reference_formats[i].magick,CommandOptionToMnemonic(
1864 MagickCompressOptions,reference_formats[i].compression),
1865 CommandOptionToMnemonic(MagickTypeOptions,reference_types[j].type),
1866 (double) reference_types[j].depth);
1867 (void) CopyMagickString(image_info->filename,reference_filename,
1868 MagickPathExtent);
1869 reference_image=ReadImage(image_info,exception);
1870 if ((reference_image == (Image *) NULL) ||
1871 (exception->severity >= ErrorException))
1872 {
1873 (void) FormatLocaleFile(stdout,"... fail @ %s/%s/%lu.\n",
1874 GetMagickModule());
1875 if (exception->reason != (char *) NULL)
1876 (void) FormatLocaleFile(stdout," reason:%s\n",exception->reason);
1877 CatchException(exception);
1878 (*fail)++;
1879 continue;
1880 }
1881 /*
1882 Write reference image.
1883 */
1884 (void) FormatLocaleString(size,MagickPathExtent,"%.20gx%.20g",
1885 (double) reference_image->columns,(double) reference_image->rows);
1886 (void) CloneString(&image_info->size,size);
1887 image_info->depth=reference_types[j].depth;
1888 (void) FormatLocaleString(reference_image->filename,MagickPathExtent,
1889 "%s:%s",reference_formats[i].magick,output_filename);
1890 status=SetImageType(reference_image,reference_types[j].type,exception);
1891 if (status == MagickFalse || (exception->severity >= ErrorException))
1892 {
1893 (void) FormatLocaleFile(stdout,"... fail @ %s/%s/%lu.\n",
1894 GetMagickModule());
1895 if (exception->reason != (char *) NULL)
1896 (void) FormatLocaleFile(stdout," reason:%s\n",exception->reason);
1897 CatchException(exception);
1898 (*fail)++;
1899 reference_image=DestroyImage(reference_image);
1900 continue;
1901 }
1902 status=SetImageDepth(reference_image,reference_types[j].depth,exception);
1903 if (status == MagickFalse || (exception->severity >= ErrorException))
1904 {
1905 (void) FormatLocaleFile(stdout,"... fail @ %s/%s/%lu.\n",
1906 GetMagickModule());
1907 CatchException(exception);
1908 (*fail)++;
1909 reference_image=DestroyImage(reference_image);
1910 continue;
1911 }
1912 reference_image->compression=reference_formats[i].compression;
1913 status=WriteImage(image_info,reference_image,exception);
1914 reference_image=DestroyImage(reference_image);
1915 if (status == MagickFalse || (exception->severity >= ErrorException))
1916 {
1917 (void) FormatLocaleFile(stdout,"... fail @ %s/%s/%lu.\n",
1918 GetMagickModule());
1919 if (exception->reason != (char *) NULL)
1920 (void) FormatLocaleFile(stdout," reason:%s\n",exception->reason);
1921 CatchException(exception);
1922 (*fail)++;
1923 continue;
1924 }
1925 /*
1926 Read reference image.
1927 */
1928 (void) FormatLocaleString(image_info->filename,MagickPathExtent,"%s:%s",
1929 reference_formats[i].magick,output_filename);
1930 reference_image=ReadImage(image_info,exception);
1931 if ((reference_image == (Image *) NULL) ||
1932 (exception->severity >= ErrorException))
1933 {
1934 (void) FormatLocaleFile(stdout,"... fail @ %s/%s/%lu.\n",
1935 GetMagickModule());
1936 CatchException(exception);
1937 (*fail)++;
1938 continue;
1939 }
1940 /*
1941 Write reference image.
1942 */
1943 (void) FormatLocaleString(reference_image->filename,MagickPathExtent,
1944 "%s:%s",reference_formats[i].magick,output_filename);
1945 reference_image->depth=reference_types[j].depth;
1946 reference_image->compression=reference_formats[i].compression;
1947 status=WriteImage(image_info,reference_image,exception);
1948 if (status == MagickFalse ||exception->severity >= ErrorException)
1949 {
1950 (void) FormatLocaleFile(stdout,"... fail @ %s/%s/%lu.\n",
1951 GetMagickModule());
1952 CatchException(exception);
1953 (*fail)++;
1954 reference_image=DestroyImage(reference_image);
1955 continue;
1956 }
1957 /*
1958 Read reconstruct image.
1959 */
1960 (void) FormatLocaleString(image_info->filename,MagickPathExtent,"%s:%s",
1961 reference_formats[i].magick,output_filename);
1962 reconstruct_image=ReadImage(image_info,exception);
1963 if (reconstruct_image == (Image *) NULL ||
1964 (exception->severity >= ErrorException))
1965 {
1966 (void) FormatLocaleFile(stdout,"... fail @ %s/%s/%lu.\n",
1967 GetMagickModule());
1968 CatchException(exception);
1969 (*fail)++;
1970 reference_image=DestroyImage(reference_image);
1971 continue;
1972 }
1973 /*
1974 Compare reference to reconstruct image.
1975 */
1976 fuzz=0.003; /* grayscale */
1977 if (reference_formats[i].fuzz != 0.0)
1978 fuzz=reference_formats[i].fuzz;
1979 difference_image=CompareImages(reference_image,reconstruct_image,
1980 RootMeanSquaredErrorMetric,&distortion,exception);
1981 reconstruct_image=DestroyImage(reconstruct_image);
1982 reference_image=DestroyImage(reference_image);
1983 if (difference_image == (Image *) NULL ||
1984 (exception->severity >= ErrorException))
1985 {
1986 (void) FormatLocaleFile(stdout,"... fail @ %s/%s/%lu.\n",
1987 GetMagickModule());
1988 CatchException(exception);
1989 (*fail)++;
1990 continue;
1991 }
1992 difference_image=DestroyImage(difference_image);
1993 if ((QuantumScale*distortion) > fuzz)
1994 {
1995 (void) FormatLocaleFile(stdout,"... fail (with distortion %g).\n",
1996 QuantumScale*distortion);
1997 (*fail)++;
1998 continue;
1999 }
2000 (void) FormatLocaleFile(stdout,"... pass.\n");
2001 }
2002 }
2003 (void) FormatLocaleFile(stdout,
2004 " summary: %.20g subtests; %.20g passed; %.20g failed.\n",(double) test,
2005 (double) (test-(*fail)),(double) *fail);
2006 return(test);
2007 }
2008
2009 /*
2010 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2011 % %
2012 % %
2013 % %
2014 % V a l i d a t e I m p o r t E x p o r t P i x e l s %
2015 % %
2016 % %
2017 % %
2018 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2019 %
2020 % ValidateImportExportPixels() validates the pixel import and export methods.
2021 % It returns the number of validation tests that passed and failed.
2022 %
2023 % The format of the ValidateImportExportPixels method is:
2024 %
2025 % size_t ValidateImportExportPixels(ImageInfo *image_info,
2026 % const char *reference_filename,const char *output_filename,
2027 % size_t *fail,ExceptionInfo *exception)
2028 %
2029 % A description of each parameter follows:
2030 %
2031 % o image_info: the image info.
2032 %
2033 % o reference_filename: the reference image filename.
2034 %
2035 % o output_filename: the output image filename.
2036 %
2037 % o fail: return the number of validation tests that pass.
2038 %
2039 % o exception: return any errors or warnings in this structure.
2040 %
2041 */
ValidateImportExportPixels(ImageInfo * image_info,const char * reference_filename,const char * output_filename,size_t * fail,ExceptionInfo * exception)2042 static size_t ValidateImportExportPixels(ImageInfo *image_info,
2043 const char *reference_filename,const char *output_filename,size_t *fail,
2044 ExceptionInfo *exception)
2045 {
2046 double
2047 distortion;
2048
2049 Image
2050 *difference_image,
2051 *reference_image,
2052 *reconstruct_image;
2053
2054 MagickBooleanType
2055 status;
2056
2057 register ssize_t
2058 i,
2059 j;
2060
2061 size_t
2062 length;
2063
2064 unsigned char
2065 *pixels;
2066
2067 size_t
2068 test;
2069
2070 (void) output_filename;
2071 test=0;
2072 (void) FormatLocaleFile(stdout,
2073 "validate the import and export of image pixels:\n");
2074 for (i=0; reference_map[i] != (char *) NULL; i++)
2075 {
2076 for (j=0; reference_storage[j].type != UndefinedPixel; j++)
2077 {
2078 /*
2079 Generate reference image.
2080 */
2081 CatchException(exception);
2082 (void) FormatLocaleFile(stdout," test %.20g: %s/%s",(double) (test++),
2083 reference_map[i],CommandOptionToMnemonic(MagickStorageOptions,
2084 reference_storage[j].type));
2085 (void) CopyMagickString(image_info->filename,reference_filename,
2086 MagickPathExtent);
2087 reference_image=ReadImage(image_info,exception);
2088 if ((reference_image == (Image *) NULL) ||
2089 (exception->severity >= ErrorException))
2090 {
2091 (void) FormatLocaleFile(stdout,"... fail @ %s/%s/%lu.\n",
2092 GetMagickModule());
2093 CatchException(exception);
2094 (*fail)++;
2095 continue;
2096 }
2097 if (LocaleNCompare(reference_map[i],"cmy",3) == 0)
2098 (void) SetImageColorspace(reference_image,CMYKColorspace,exception);
2099 length=strlen(reference_map[i])*reference_image->columns*
2100 reference_image->rows*reference_storage[j].quantum;
2101 pixels=(unsigned char *) AcquireQuantumMemory(length,sizeof(*pixels));
2102 if (pixels == (unsigned char *) NULL ||
2103 (exception->severity >= ErrorException))
2104 {
2105 (void) FormatLocaleFile(stdout,"... fail @ %s/%s/%lu.\n",
2106 GetMagickModule());
2107 CatchException(exception);
2108 (*fail)++;
2109 reference_image=DestroyImage(reference_image);
2110 continue;
2111 }
2112 (void) memset(pixels,0,length*sizeof(*pixels));
2113 status=ExportImagePixels(reference_image,0,0,reference_image->columns,
2114 reference_image->rows,reference_map[i],reference_storage[j].type,pixels,
2115 exception);
2116 if (status == MagickFalse || (exception->severity >= ErrorException))
2117 {
2118 (void) FormatLocaleFile(stdout,"... fail @ %s/%s/%lu.\n",
2119 GetMagickModule());
2120 CatchException(exception);
2121 (*fail)++;
2122 pixels=(unsigned char *) RelinquishMagickMemory(pixels);
2123 reference_image=DestroyImage(reference_image);
2124 continue;
2125 }
2126 (void) SetImageBackgroundColor(reference_image,exception);
2127 status=ImportImagePixels(reference_image,0,0,reference_image->columns,
2128 reference_image->rows,reference_map[i],reference_storage[j].type,
2129 pixels,exception);
2130 if (status == MagickFalse || (exception->severity >= ErrorException))
2131 {
2132 (void) FormatLocaleFile(stdout,"... fail @ %s/%s/%lu.\n",
2133 GetMagickModule());
2134 CatchException(exception);
2135 (*fail)++;
2136 pixels=(unsigned char *) RelinquishMagickMemory(pixels);
2137 reference_image=DestroyImage(reference_image);
2138 continue;
2139 }
2140 /*
2141 Read reconstruct image.
2142 */
2143 reconstruct_image=AcquireImage(image_info,exception);
2144 (void) SetImageExtent(reconstruct_image,reference_image->columns,
2145 reference_image->rows,exception);
2146 (void) SetImageColorspace(reconstruct_image,reference_image->colorspace,
2147 exception);
2148 (void) SetImageBackgroundColor(reconstruct_image,exception);
2149 status=ImportImagePixels(reconstruct_image,0,0,reconstruct_image->columns,
2150 reconstruct_image->rows,reference_map[i],reference_storage[j].type,
2151 pixels,exception);
2152 pixels=(unsigned char *) RelinquishMagickMemory(pixels);
2153 if (status == MagickFalse || (exception->severity >= ErrorException))
2154 {
2155 (void) FormatLocaleFile(stdout,"... fail @ %s/%s/%lu.\n",
2156 GetMagickModule());
2157 CatchException(exception);
2158 (*fail)++;
2159 reference_image=DestroyImage(reference_image);
2160 continue;
2161 }
2162 /*
2163 Compare reference to reconstruct image.
2164 */
2165 difference_image=CompareImages(reference_image,reconstruct_image,
2166 RootMeanSquaredErrorMetric,&distortion,exception);
2167 reconstruct_image=DestroyImage(reconstruct_image);
2168 reference_image=DestroyImage(reference_image);
2169 if (difference_image == (Image *) NULL ||
2170 (exception->severity >= ErrorException))
2171 {
2172 (void) FormatLocaleFile(stdout,"... fail @ %s/%s/%lu.\n",
2173 GetMagickModule());
2174 CatchException(exception);
2175 (*fail)++;
2176 continue;
2177 }
2178 difference_image=DestroyImage(difference_image);
2179 if ((QuantumScale*distortion) > 0.0)
2180 {
2181 (void) FormatLocaleFile(stdout,"... fail (with distortion %g).\n",
2182 QuantumScale*distortion);
2183 (*fail)++;
2184 continue;
2185 }
2186 (void) FormatLocaleFile(stdout,"... pass.\n");
2187 }
2188 }
2189 (void) FormatLocaleFile(stdout,
2190 " summary: %.20g subtests; %.20g passed; %.20g failed.\n",(double) test,
2191 (double) (test-(*fail)),(double) *fail);
2192 return(test);
2193 }
2194
2195 /*
2196 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2197 % %
2198 % %
2199 % %
2200 % V a l i d a t e M o n t a g e C o m m a n d %
2201 % %
2202 % %
2203 % %
2204 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2205 %
2206 % ValidateMontageCommand() validates the ImageMagick montage command line
2207 % program and returns the number of validation tests that passed and failed.
2208 %
2209 % The format of the ValidateMontageCommand method is:
2210 %
2211 % size_t ValidateMontageCommand(ImageInfo *image_info,
2212 % const char *reference_filename,const char *output_filename,
2213 % size_t *fail,ExceptionInfo *exception)
2214 %
2215 % A description of each parameter follows:
2216 %
2217 % o image_info: the image info.
2218 %
2219 % o reference_filename: the reference image filename.
2220 %
2221 % o output_filename: the output image filename.
2222 %
2223 % o fail: return the number of validation tests that pass.
2224 %
2225 % o exception: return any errors or warnings in this structure.
2226 %
2227 */
ValidateMontageCommand(ImageInfo * image_info,const char * reference_filename,const char * output_filename,size_t * fail,ExceptionInfo * exception)2228 static size_t ValidateMontageCommand(ImageInfo *image_info,
2229 const char *reference_filename,const char *output_filename,size_t *fail,
2230 ExceptionInfo *exception)
2231 {
2232 char
2233 **arguments,
2234 command[MagickPathExtent];
2235
2236 int
2237 number_arguments;
2238
2239 MagickBooleanType
2240 status;
2241
2242 register ssize_t
2243 i,
2244 j;
2245
2246 size_t
2247 test;
2248
2249 test=0;
2250 (void) FormatLocaleFile(stdout,"validate montage command line program:\n");
2251 for (i=0; montage_options[i] != (char *) NULL; i++)
2252 {
2253 CatchException(exception);
2254 (void) FormatLocaleFile(stdout," test %.20g: %s",(double) (test++),
2255 montage_options[i]);
2256 (void) FormatLocaleString(command,MagickPathExtent,"%s %s %s %s",
2257 reference_filename,montage_options[i],reference_filename,
2258 output_filename);
2259 arguments=StringToArgv(command,&number_arguments);
2260 if (arguments == (char **) NULL)
2261 {
2262 (void) FormatLocaleFile(stdout,"... fail @ %s/%s/%lu.\n",
2263 GetMagickModule());
2264 (*fail)++;
2265 continue;
2266 }
2267 status=MontageImageCommand(image_info,number_arguments,arguments,
2268 (char **) NULL,exception);
2269 for (j=0; j < (ssize_t) number_arguments; j++)
2270 arguments[j]=DestroyString(arguments[j]);
2271 arguments=(char **) RelinquishMagickMemory(arguments);
2272 if (status == MagickFalse)
2273 {
2274 (void) FormatLocaleFile(stdout,"... fail @ %s/%s/%lu.\n",
2275 GetMagickModule());
2276 (*fail)++;
2277 continue;
2278 }
2279 (void) FormatLocaleFile(stdout,"... pass.\n");
2280 }
2281 (void) FormatLocaleFile(stdout,
2282 " summary: %.20g subtests; %.20g passed; %.20g failed.\n",(double) test,
2283 (double) (test-(*fail)),(double) *fail);
2284 return(test);
2285 }
2286
2287 /*
2288 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2289 % %
2290 % %
2291 % %
2292 % V a l i d a t e S t r e a m C o m m a n d %
2293 % %
2294 % %
2295 % %
2296 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2297 %
2298 % ValidateStreamCommand() validates the ImageMagick stream command line
2299 % program and returns the number of validation tests that passed and failed.
2300 %
2301 % The format of the ValidateStreamCommand method is:
2302 %
2303 % size_t ValidateStreamCommand(ImageInfo *image_info,
2304 % const char *reference_filename,const char *output_filename,
2305 % size_t *fail,ExceptionInfo *exception)
2306 %
2307 % A description of each parameter follows:
2308 %
2309 % o image_info: the image info.
2310 %
2311 % o reference_filename: the reference image filename.
2312 %
2313 % o output_filename: the output image filename.
2314 %
2315 % o fail: return the number of validation tests that pass.
2316 %
2317 % o exception: return any errors or warnings in this structure.
2318 %
2319 */
ValidateStreamCommand(ImageInfo * image_info,const char * reference_filename,const char * output_filename,size_t * fail,ExceptionInfo * exception)2320 static size_t ValidateStreamCommand(ImageInfo *image_info,
2321 const char *reference_filename,const char *output_filename,size_t *fail,
2322 ExceptionInfo *exception)
2323 {
2324 char
2325 **arguments,
2326 command[MagickPathExtent];
2327
2328 int
2329 number_arguments;
2330
2331 MagickBooleanType
2332 status;
2333
2334 register ssize_t
2335 i,
2336 j;
2337
2338 size_t
2339 test;
2340
2341 test=0;
2342 (void) FormatLocaleFile(stdout,"validate stream command line program:\n");
2343 for (i=0; stream_options[i] != (char *) NULL; i++)
2344 {
2345 CatchException(exception);
2346 (void) FormatLocaleFile(stdout," test %.20g: %s",(double) (test++),
2347 stream_options[i]);
2348 (void) FormatLocaleString(command,MagickPathExtent,"%s %s %s",
2349 stream_options[i],reference_filename,output_filename);
2350 arguments=StringToArgv(command,&number_arguments);
2351 if (arguments == (char **) NULL)
2352 {
2353 (void) FormatLocaleFile(stdout,"... fail @ %s/%s/%lu.\n",
2354 GetMagickModule());
2355 (*fail)++;
2356 continue;
2357 }
2358 status=StreamImageCommand(image_info,number_arguments,arguments,
2359 (char **) NULL,exception);
2360 for (j=0; j < (ssize_t) number_arguments; j++)
2361 arguments[j]=DestroyString(arguments[j]);
2362 arguments=(char **) RelinquishMagickMemory(arguments);
2363 if (status == MagickFalse)
2364 {
2365 (void) FormatLocaleFile(stdout,"... fail @ %s/%s/%lu.\n",
2366 GetMagickModule());
2367 (*fail)++;
2368 continue;
2369 }
2370 (void) FormatLocaleFile(stdout,"... pass.\n");
2371 }
2372 (void) FormatLocaleFile(stdout,
2373 " summary: %.20g subtests; %.20g passed; %.20g failed.\n",(double) test,
2374 (double) (test-(*fail)),(double) *fail);
2375 return(test);
2376 }
2377
2378 /*
2379 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2380 % %
2381 % %
2382 % %
2383 % M a i n %
2384 % %
2385 % %
2386 % %
2387 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2388 %
2389 %
2390 */
2391
ValidateUsage(void)2392 static MagickBooleanType ValidateUsage(void)
2393 {
2394 const char
2395 **p;
2396
2397 static const char
2398 *miscellaneous[]=
2399 {
2400 "-debug events display copious debugging information",
2401 "-help print program options",
2402 "-log format format of debugging information",
2403 "-validate type validation type",
2404 "-version print version information",
2405 (char *) NULL
2406 },
2407 *settings[]=
2408 {
2409 "-regard-warnings pay attention to warning messages",
2410 "-verbose print detailed information about the image",
2411 (char *) NULL
2412 };
2413
2414 (void) printf("Version: %s\n",GetMagickVersion((size_t *) NULL));
2415 (void) printf("Copyright: %s\n\n",GetMagickCopyright());
2416 (void) printf("Features: %s\n",GetMagickFeatures());
2417 (void) printf("Usage: %s [options ...] reference-file\n",GetClientName());
2418 (void) printf("\nValidate Settings:\n");
2419 for (p=settings; *p != (char *) NULL; p++)
2420 (void) printf(" %s\n",*p);
2421 (void) printf("\nMiscellaneous Options:\n");
2422 for (p=miscellaneous; *p != (char *) NULL; p++)
2423 (void) printf(" %s\n",*p);
2424 return(MagickTrue);
2425 }
2426
main(int argc,char ** argv)2427 int main(int argc,char **argv)
2428 {
2429 #define DestroyValidate() \
2430 { \
2431 image_info=DestroyImageInfo(image_info); \
2432 exception=DestroyExceptionInfo(exception); \
2433 }
2434 #define ThrowValidateException(asperity,tag,option) \
2435 { \
2436 (void) ThrowMagickException(exception,GetMagickModule(),asperity,tag,"`%s'", \
2437 option); \
2438 CatchException(exception); \
2439 DestroyValidate(); \
2440 return(MagickFalse); \
2441 }
2442
2443 char
2444 output_filename[MagickPathExtent],
2445 reference_filename[MagickPathExtent],
2446 *option;
2447
2448 double
2449 elapsed_time,
2450 user_time;
2451
2452 ExceptionInfo
2453 *exception;
2454
2455 Image
2456 *reference_image;
2457
2458 ImageInfo
2459 *image_info;
2460
2461 MagickBooleanType
2462 regard_warnings,
2463 status;
2464
2465 MagickSizeType
2466 memory_resource,
2467 map_resource;
2468
2469 register ssize_t
2470 i;
2471
2472 TimerInfo
2473 *timer;
2474
2475 size_t
2476 fail,
2477 iterations,
2478 tests;
2479
2480 ValidateType
2481 type;
2482
2483 /*
2484 Validate the ImageMagick image processing suite.
2485 */
2486 MagickCoreGenesis(*argv,MagickTrue);
2487 (void) setlocale(LC_ALL,"");
2488 (void) setlocale(LC_NUMERIC,"C");
2489 iterations=1;
2490 status=MagickFalse;
2491 type=AllValidate;
2492 regard_warnings=MagickFalse;
2493 (void) regard_warnings;
2494 exception=AcquireExceptionInfo();
2495 image_info=AcquireImageInfo();
2496 (void) CopyMagickString(image_info->filename,ReferenceFilename,
2497 MagickPathExtent);
2498 for (i=1; i < (ssize_t) argc; i++)
2499 {
2500 option=argv[i];
2501 if (IsCommandOption(option) == MagickFalse)
2502 {
2503 (void) CopyMagickString(image_info->filename,option,MagickPathExtent);
2504 continue;
2505 }
2506 switch (*(option+1))
2507 {
2508 case 'b':
2509 {
2510 if (LocaleCompare("bench",option+1) == 0)
2511 {
2512 iterations=StringToUnsignedLong(argv[++i]);
2513 break;
2514 }
2515 ThrowValidateException(OptionError,"UnrecognizedOption",option)
2516 }
2517 case 'd':
2518 {
2519 if (LocaleCompare("debug",option+1) == 0)
2520 {
2521 (void) SetLogEventMask(argv[++i]);
2522 break;
2523 }
2524 ThrowValidateException(OptionError,"UnrecognizedOption",option)
2525 }
2526 case 'h':
2527 {
2528 if (LocaleCompare("help",option+1) == 0)
2529 {
2530 (void) ValidateUsage();
2531 return(0);
2532 }
2533 ThrowValidateException(OptionError,"UnrecognizedOption",option)
2534 }
2535 case 'l':
2536 {
2537 if (LocaleCompare("log",option+1) == 0)
2538 {
2539 if (*option != '+')
2540 (void) SetLogFormat(argv[i+1]);
2541 break;
2542 }
2543 ThrowValidateException(OptionError,"UnrecognizedOption",option)
2544 }
2545 case 'r':
2546 {
2547 if (LocaleCompare("regard-warnings",option+1) == 0)
2548 {
2549 regard_warnings=MagickTrue;
2550 break;
2551 }
2552 ThrowValidateException(OptionError,"UnrecognizedOption",option)
2553 }
2554 case 'v':
2555 {
2556 if (LocaleCompare("validate",option+1) == 0)
2557 {
2558 ssize_t
2559 validate;
2560
2561 if (*option == '+')
2562 break;
2563 i++;
2564 if (i >= (ssize_t) argc)
2565 ThrowValidateException(OptionError,"MissingArgument",option);
2566 validate=ParseCommandOption(MagickValidateOptions,MagickFalse,
2567 argv[i]);
2568 if (validate < 0)
2569 ThrowValidateException(OptionError,"UnrecognizedValidateType",
2570 argv[i]);
2571 type=(ValidateType) validate;
2572 break;
2573 }
2574 if ((LocaleCompare("version",option+1) == 0) ||
2575 (LocaleCompare("-version",option+1) == 0))
2576 {
2577 (void) FormatLocaleFile(stdout,"Version: %s\n",
2578 GetMagickVersion((size_t *) NULL));
2579 (void) FormatLocaleFile(stdout,"Copyright: %s\n\n",
2580 GetMagickCopyright());
2581 (void) FormatLocaleFile(stdout,"Features: %s\n\n",
2582 GetMagickFeatures());
2583 return(0);
2584 }
2585 ThrowValidateException(OptionError,"UnrecognizedOption",option)
2586 }
2587 default:
2588 ThrowValidateException(OptionError,"UnrecognizedOption",option)
2589 }
2590 }
2591 timer=(TimerInfo *) NULL;
2592 if (iterations > 1)
2593 timer=AcquireTimerInfo();
2594 reference_image=ReadImage(image_info,exception);
2595 tests=0;
2596 fail=0;
2597 if (reference_image == (Image *) NULL)
2598 fail++;
2599 else
2600 {
2601 if (LocaleCompare(image_info->filename,ReferenceFilename) == 0)
2602 (void) CopyMagickString(reference_image->magick,ReferenceImageFormat,
2603 MagickPathExtent);
2604 (void) AcquireUniqueFilename(reference_filename);
2605 (void) AcquireUniqueFilename(output_filename);
2606 (void) CopyMagickString(reference_image->filename,reference_filename,
2607 MagickPathExtent);
2608 status=WriteImage(image_info,reference_image,exception);
2609 reference_image=DestroyImage(reference_image);
2610 if (status == MagickFalse)
2611 fail++;
2612 else
2613 {
2614 (void) FormatLocaleFile(stdout,"Version: %s\n",
2615 GetMagickVersion((size_t *) NULL));
2616 (void) FormatLocaleFile(stdout,"Copyright: %s\n\n",
2617 GetMagickCopyright());
2618 (void) FormatLocaleFile(stdout,
2619 "ImageMagick Validation Suite (%s)\n\n",CommandOptionToMnemonic(
2620 MagickValidateOptions,(ssize_t) type));
2621 if ((type & ColorspaceValidate) != 0)
2622 tests+=ValidateColorspaces(image_info,&fail,exception);
2623 if ((type & CompareValidate) != 0)
2624 tests+=ValidateCompareCommand(image_info,reference_filename,
2625 output_filename,&fail,exception);
2626 if ((type & CompositeValidate) != 0)
2627 tests+=ValidateCompositeCommand(image_info,reference_filename,
2628 output_filename,&fail,exception);
2629 if ((type & ConvertValidate) != 0)
2630 tests+=ValidateConvertCommand(image_info,reference_filename,
2631 output_filename,&fail,exception);
2632 if ((type & FormatsDiskValidate) != 0)
2633 {
2634 memory_resource=SetMagickResourceLimit(MemoryResource,0);
2635 map_resource=SetMagickResourceLimit(MapResource,0);
2636 (void) FormatLocaleFile(stdout,"[pixel-cache: disk] ");
2637 tests+=ValidateImageFormatsInMemory(image_info,reference_filename,
2638 output_filename,&fail,exception);
2639 (void) FormatLocaleFile(stdout,"[pixel-cache: disk] ");
2640 tests+=ValidateImageFormatsOnDisk(image_info,reference_filename,
2641 output_filename,&fail,exception);
2642 (void) SetMagickResourceLimit(MemoryResource,memory_resource);
2643 (void) SetMagickResourceLimit(MapResource,map_resource);
2644 }
2645 if ((type & FormatsMapValidate) != 0)
2646 {
2647 memory_resource=SetMagickResourceLimit(MemoryResource,0);
2648 (void) FormatLocaleFile(stdout,"[pixel-cache: memory-mapped] ");
2649 tests+=ValidateImageFormatsInMemory(image_info,reference_filename,
2650 output_filename,&fail,exception);
2651 (void) FormatLocaleFile(stdout,"[pixel-cache: memory-mapped] ");
2652 tests+=ValidateImageFormatsOnDisk(image_info,reference_filename,
2653 output_filename,&fail,exception);
2654 (void) SetMagickResourceLimit(MemoryResource,memory_resource);
2655 }
2656 if ((type & FormatsMemoryValidate) != 0)
2657 {
2658 (void) FormatLocaleFile(stdout,"[pixel-cache: memory] ");
2659 tests+=ValidateImageFormatsInMemory(image_info,reference_filename,
2660 output_filename,&fail,exception);
2661 (void) FormatLocaleFile(stdout,"[pixel-cache: memory] ");
2662 tests+=ValidateImageFormatsOnDisk(image_info,reference_filename,
2663 output_filename,&fail,exception);
2664 }
2665 if ((type & IdentifyValidate) != 0)
2666 tests+=ValidateIdentifyCommand(image_info,reference_filename,
2667 output_filename,&fail,exception);
2668 if ((type & ImportExportValidate) != 0)
2669 tests+=ValidateImportExportPixels(image_info,reference_filename,
2670 output_filename,&fail,exception);
2671 if ((type & MontageValidate) != 0)
2672 tests+=ValidateMontageCommand(image_info,reference_filename,
2673 output_filename,&fail,exception);
2674 if ((type & StreamValidate) != 0)
2675 tests+=ValidateStreamCommand(image_info,reference_filename,
2676 output_filename,&fail,exception);
2677 (void) FormatLocaleFile(stdout,
2678 "validation suite: %.20g tests; %.20g passed; %.20g failed.\n",
2679 (double) tests,(double) (tests-fail),(double) fail);
2680 }
2681 (void) RelinquishUniqueFileResource(output_filename);
2682 (void) RelinquishUniqueFileResource(reference_filename);
2683 }
2684 if (exception->severity != UndefinedException)
2685 CatchException(exception);
2686 if (iterations > 1)
2687 {
2688 elapsed_time=GetElapsedTime(timer);
2689 user_time=GetUserTime(timer);
2690 (void) FormatLocaleFile(stderr,
2691 "Performance: %.20gi %.3fips %0.6fu %ld:%02ld.%03ld\n",(double)
2692 iterations,1.0*iterations/elapsed_time,user_time,(long)
2693 (elapsed_time/60.0),(long) ceil(fmod(elapsed_time,60.0)),
2694 (long) (1000.0*(elapsed_time-floor(elapsed_time))));
2695 timer=DestroyTimerInfo(timer);
2696 }
2697 DestroyValidate();
2698 MagickCoreTerminus();
2699 return(fail == 0 ? 0 : 1);
2700 }
2701