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-2016 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 % http://www.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 (*fail)++;
1178 continue;
1179 }
1180 status=CompareImagesCommand(image_info,number_arguments,arguments,
1181 (char **) NULL,exception);
1182 for (j=0; j < (ssize_t) number_arguments; j++)
1183 arguments[j]=DestroyString(arguments[j]);
1184 arguments=(char **) RelinquishMagickMemory(arguments);
1185 if (status == MagickFalse)
1186 {
1187 (void) FormatLocaleFile(stdout,"... fail @ %s/%s/%lu.\n",
1188 GetMagickModule());
1189 (*fail)++;
1190 continue;
1191 }
1192 (void) FormatLocaleFile(stdout,"... pass.\n");
1193 }
1194 (void) FormatLocaleFile(stdout,
1195 " summary: %.20g subtests; %.20g passed; %.20g failed.\n",(double) test,
1196 (double) (test-(*fail)),(double) *fail);
1197 return(test);
1198 }
1199
1200 /*
1201 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1202 % %
1203 % %
1204 % %
1205 % V a l i d a t e C o m p o s i t e C o m m a n d %
1206 % %
1207 % %
1208 % %
1209 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1210 %
1211 % ValidateCompositeCommand() validates the ImageMagick composite command line
1212 % program and returns the number of validation tests that passed and failed.
1213 %
1214 % The format of the ValidateCompositeCommand method is:
1215 %
1216 % size_t ValidateCompositeCommand(ImageInfo *image_info,
1217 % const char *reference_filename,const char *output_filename,
1218 % size_t *fail,ExceptionInfo *exception)
1219 %
1220 % A description of each parameter follows:
1221 %
1222 % o image_info: the image info.
1223 %
1224 % o reference_filename: the reference image filename.
1225 %
1226 % o output_filename: the output image filename.
1227 %
1228 % o fail: return the number of validation tests that pass.
1229 %
1230 % o exception: return any errors or warnings in this structure.
1231 %
1232 */
ValidateCompositeCommand(ImageInfo * image_info,const char * reference_filename,const char * output_filename,size_t * fail,ExceptionInfo * exception)1233 static size_t ValidateCompositeCommand(ImageInfo *image_info,
1234 const char *reference_filename,const char *output_filename,size_t *fail,
1235 ExceptionInfo *exception)
1236 {
1237 char
1238 **arguments,
1239 command[MagickPathExtent];
1240
1241 int
1242 number_arguments;
1243
1244 MagickBooleanType
1245 status;
1246
1247 register ssize_t
1248 i,
1249 j;
1250
1251 size_t
1252 test;
1253
1254 test=0;
1255 (void) FormatLocaleFile(stdout,"validate composite command line program:\n");
1256 for (i=0; composite_options[i] != (char *) NULL; i++)
1257 {
1258 CatchException(exception);
1259 (void) FormatLocaleFile(stdout," test %.20g: %s",(double) (test++),
1260 composite_options[i]);
1261 (void) FormatLocaleString(command,MagickPathExtent,"%s %s %s %s",
1262 reference_filename,composite_options[i],reference_filename,
1263 output_filename);
1264 arguments=StringToArgv(command,&number_arguments);
1265 if (arguments == (char **) NULL)
1266 {
1267 (void) FormatLocaleFile(stdout,"... fail @ %s/%s/%lu.\n",
1268 GetMagickModule());
1269 (*fail)++;
1270 continue;
1271 }
1272 status=CompositeImageCommand(image_info,number_arguments,arguments,
1273 (char **) NULL,exception);
1274 for (j=0; j < (ssize_t) number_arguments; j++)
1275 arguments[j]=DestroyString(arguments[j]);
1276 arguments=(char **) RelinquishMagickMemory(arguments);
1277 if (status == MagickFalse)
1278 {
1279 (void) FormatLocaleFile(stdout,"... fail @ %s/%s/%lu.\n",
1280 GetMagickModule());
1281 (*fail)++;
1282 continue;
1283 }
1284 (void) FormatLocaleFile(stdout,"... pass.\n");
1285 }
1286 (void) FormatLocaleFile(stdout,
1287 " summary: %.20g subtests; %.20g passed; %.20g failed.\n",(double) test,
1288 (double) (test-(*fail)),(double) *fail);
1289 return(test);
1290 }
1291
1292 /*
1293 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1294 % %
1295 % %
1296 % %
1297 % V a l i d a t e C o n v e r t C o m m a n d %
1298 % %
1299 % %
1300 % %
1301 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1302 %
1303 % ValidateConvertCommand() validates the ImageMagick convert command line
1304 % program and returns the number of validation tests that passed and failed.
1305 %
1306 % The format of the ValidateConvertCommand method is:
1307 %
1308 % size_t ValidateConvertCommand(ImageInfo *image_info,
1309 % const char *reference_filename,const char *output_filename,
1310 % size_t *fail,ExceptionInfo *exception)
1311 %
1312 % A description of each parameter follows:
1313 %
1314 % o image_info: the image info.
1315 %
1316 % o reference_filename: the reference image filename.
1317 %
1318 % o output_filename: the output image filename.
1319 %
1320 % o fail: return the number of validation tests that pass.
1321 %
1322 % o exception: return any errors or warnings in this structure.
1323 %
1324 */
ValidateConvertCommand(ImageInfo * image_info,const char * reference_filename,const char * output_filename,size_t * fail,ExceptionInfo * exception)1325 static size_t ValidateConvertCommand(ImageInfo *image_info,
1326 const char *reference_filename,const char *output_filename,size_t *fail,
1327 ExceptionInfo *exception)
1328 {
1329 char
1330 **arguments,
1331 command[MagickPathExtent];
1332
1333 int
1334 number_arguments;
1335
1336 MagickBooleanType
1337 status;
1338
1339 register ssize_t
1340 i,
1341 j;
1342
1343 size_t
1344 test;
1345
1346 test=0;
1347 (void) FormatLocaleFile(stdout,"validate convert command line program:\n");
1348 for (i=0; convert_options[i] != (char *) NULL; i++)
1349 {
1350 CatchException(exception);
1351 (void) FormatLocaleFile(stdout," test %.20g: %s",(double) test++,
1352 convert_options[i]);
1353 (void) FormatLocaleString(command,MagickPathExtent,"%s %s %s %s",
1354 reference_filename,convert_options[i],reference_filename,output_filename);
1355 arguments=StringToArgv(command,&number_arguments);
1356 if (arguments == (char **) NULL)
1357 {
1358 (void) FormatLocaleFile(stdout,"... fail @ %s/%s/%lu.\n",
1359 GetMagickModule());
1360 (*fail)++;
1361 continue;
1362 }
1363 status=ConvertImageCommand(image_info,number_arguments,arguments,
1364 (char **) NULL,exception);
1365 for (j=0; j < (ssize_t) number_arguments; j++)
1366 arguments[j]=DestroyString(arguments[j]);
1367 arguments=(char **) RelinquishMagickMemory(arguments);
1368 if (status == MagickFalse)
1369 {
1370 (void) FormatLocaleFile(stdout,"... fail @ %s/%s/%lu.\n",
1371 GetMagickModule());
1372 (*fail)++;
1373 continue;
1374 }
1375 (void) FormatLocaleFile(stdout,"... pass.\n");
1376 }
1377 (void) FormatLocaleFile(stdout,
1378 " summary: %.20g subtests; %.20g passed; %.20g failed.\n",(double) test,
1379 (double) (test-(*fail)),(double) *fail);
1380 return(test);
1381 }
1382
1383 /*
1384 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1385 % %
1386 % %
1387 % %
1388 % V a l i d a t e I d e n t i f y C o m m a n d %
1389 % %
1390 % %
1391 % %
1392 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1393 %
1394 % ValidateIdentifyCommand() validates the ImageMagick identify command line
1395 % program and returns the number of validation tests that passed and failed.
1396 %
1397 % The format of the ValidateIdentifyCommand method is:
1398 %
1399 % size_t ValidateIdentifyCommand(ImageInfo *image_info,
1400 % const char *reference_filename,const char *output_filename,
1401 % size_t *fail,ExceptionInfo *exception)
1402 %
1403 % A description of each parameter follows:
1404 %
1405 % o image_info: the image info.
1406 %
1407 % o reference_filename: the reference image filename.
1408 %
1409 % o output_filename: the output image filename.
1410 %
1411 % o fail: return the number of validation tests that pass.
1412 %
1413 % o exception: return any errors or warnings in this structure.
1414 %
1415 */
ValidateIdentifyCommand(ImageInfo * image_info,const char * reference_filename,const char * output_filename,size_t * fail,ExceptionInfo * exception)1416 static size_t ValidateIdentifyCommand(ImageInfo *image_info,
1417 const char *reference_filename,const char *output_filename,size_t *fail,
1418 ExceptionInfo *exception)
1419 {
1420 char
1421 **arguments,
1422 command[MagickPathExtent];
1423
1424 int
1425 number_arguments;
1426
1427 MagickBooleanType
1428 status;
1429
1430 register ssize_t
1431 i,
1432 j;
1433
1434 size_t
1435 test;
1436
1437 (void) output_filename;
1438 test=0;
1439 (void) FormatLocaleFile(stdout,"validate identify command line program:\n");
1440 for (i=0; identify_options[i] != (char *) NULL; i++)
1441 {
1442 CatchException(exception);
1443 (void) FormatLocaleFile(stdout," test %.20g: %s",(double) test++,
1444 identify_options[i]);
1445 (void) FormatLocaleString(command,MagickPathExtent,"%s %s",
1446 identify_options[i],reference_filename);
1447 arguments=StringToArgv(command,&number_arguments);
1448 if (arguments == (char **) NULL)
1449 {
1450 (void) FormatLocaleFile(stdout,"... fail @ %s/%s/%lu.\n",
1451 GetMagickModule());
1452 (*fail)++;
1453 continue;
1454 }
1455 status=IdentifyImageCommand(image_info,number_arguments,arguments,
1456 (char **) NULL,exception);
1457 for (j=0; j < (ssize_t) number_arguments; j++)
1458 arguments[j]=DestroyString(arguments[j]);
1459 arguments=(char **) RelinquishMagickMemory(arguments);
1460 if (status == MagickFalse)
1461 {
1462 (void) FormatLocaleFile(stdout,"... fail @ %s/%s/%lu.\n",
1463 GetMagickModule());
1464 (*fail)++;
1465 continue;
1466 }
1467 (void) FormatLocaleFile(stdout,"... pass.\n");
1468 }
1469 (void) FormatLocaleFile(stdout,
1470 " summary: %.20g subtests; %.20g passed; %.20g failed.\n",(double) test,
1471 (double) (test-(*fail)),(double) *fail);
1472 return(test);
1473 }
1474
1475 /*
1476 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1477 % %
1478 % %
1479 % %
1480 % 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 %
1481 % %
1482 % %
1483 % %
1484 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1485 %
1486 % ValidateImageFormatsInMemory() validates the ImageMagick image formats in
1487 % memory and returns the number of validation tests that passed and failed.
1488 %
1489 % The format of the ValidateImageFormatsInMemory method is:
1490 %
1491 % size_t ValidateImageFormatsInMemory(ImageInfo *image_info,
1492 % const char *reference_filename,const char *output_filename,
1493 % size_t *fail,ExceptionInfo *exception)
1494 %
1495 % A description of each parameter follows:
1496 %
1497 % o image_info: the image info.
1498 %
1499 % o reference_filename: the reference image filename.
1500 %
1501 % o output_filename: the output image filename.
1502 %
1503 % o fail: return the number of validation tests that pass.
1504 %
1505 % o exception: return any errors or warnings in this structure.
1506 %
1507 */
1508
1509 /*
1510 Enable this to count remaining $TMPDIR/magick-* files. Note that the count
1511 includes any files left over from other runs.
1512 */
1513 #undef MagickCountTempFiles
1514
ValidateImageFormatsInMemory(ImageInfo * image_info,const char * reference_filename,const char * output_filename,size_t * fail,ExceptionInfo * exception)1515 static size_t ValidateImageFormatsInMemory(ImageInfo *image_info,
1516 const char *reference_filename,const char *output_filename,size_t *fail,
1517 ExceptionInfo *exception)
1518 {
1519 char
1520 #ifdef MagickCountTempFiles
1521 path[MagickPathExtent],
1522 SystemCommand[MagickPathExtent],
1523 #endif
1524 size[MagickPathExtent];
1525
1526 const MagickInfo
1527 *magick_info;
1528
1529 double
1530 distortion,
1531 fuzz;
1532
1533 Image
1534 *difference_image,
1535 *ping_image,
1536 *reconstruct_image,
1537 *reference_image;
1538
1539 MagickBooleanType
1540 status;
1541
1542 register ssize_t
1543 i,
1544 j;
1545
1546 size_t
1547 length,
1548 test;
1549
1550 unsigned char
1551 *blob;
1552
1553 test=0;
1554 (void) FormatLocaleFile(stdout,"validate image formats in memory:\n");
1555
1556 #ifdef MagickCountTempFiles
1557 (void)GetPathTemplate(path);
1558 /* Remove file template except for the leading "/path/to/magick-" */
1559 path[strlen(path)-17]='\0';
1560 (void) FormatLocaleFile(stdout," tmp path is '%s*'\n",path);
1561 #endif
1562
1563 for (i=0; reference_formats[i].magick != (char *) NULL; i++)
1564 {
1565 magick_info=GetMagickInfo(reference_formats[i].magick,exception);
1566 if ((magick_info == (const MagickInfo *) NULL) ||
1567 (magick_info->decoder == (DecodeImageHandler *) NULL) ||
1568 (magick_info->encoder == (EncodeImageHandler *) NULL))
1569 continue;
1570 for (j=0; reference_types[j].type != UndefinedType; j++)
1571 {
1572 /*
1573 Generate reference image.
1574 */
1575 CatchException(exception);
1576 (void) FormatLocaleFile(stdout," test %.20g: %s/%s/%s/%.20g-bits",
1577 (double) (test++),reference_formats[i].magick,CommandOptionToMnemonic(
1578 MagickCompressOptions,reference_formats[i].compression),
1579 CommandOptionToMnemonic(MagickTypeOptions,reference_types[j].type),
1580 (double) reference_types[j].depth);
1581 (void) CopyMagickString(image_info->filename,reference_filename,
1582 MagickPathExtent);
1583 reference_image=ReadImage(image_info,exception);
1584 if (reference_image == (Image *) NULL ||
1585 exception->severity >= ErrorException)
1586 {
1587 (void) FormatLocaleFile(stdout,"... fail @ %s/%s/%lu.\n",
1588 GetMagickModule());
1589 CatchException(exception);
1590 (*fail)++;
1591 continue;
1592 }
1593 /*
1594 Write reference image.
1595 */
1596 (void) FormatLocaleString(size,MagickPathExtent,"%.20gx%.20g",
1597 (double) reference_image->columns,(double) reference_image->rows);
1598 (void) CloneString(&image_info->size,size);
1599 image_info->depth=reference_types[j].depth;
1600 (void) FormatLocaleString(reference_image->filename,MagickPathExtent,"%s:%s",
1601 reference_formats[i].magick,output_filename);
1602 status=SetImageType(reference_image,reference_types[j].type,exception);
1603 if (status == MagickFalse || exception->severity >= ErrorException)
1604 {
1605 (void) FormatLocaleFile(stdout,"... fail @ %s/%s/%lu.\n",
1606 GetMagickModule());
1607 CatchException(exception);
1608 (*fail)++;
1609 reference_image=DestroyImage(reference_image);
1610 continue;
1611 }
1612 status=SetImageDepth(reference_image,reference_types[j].depth,exception);
1613 if (status == MagickFalse || exception->severity >= ErrorException)
1614 {
1615 (void) FormatLocaleFile(stdout,"... fail @ %s/%s/%lu.\n",
1616 GetMagickModule());
1617 CatchException(exception);
1618 (*fail)++;
1619 reference_image=DestroyImage(reference_image);
1620 continue;
1621 }
1622 reference_image->compression=reference_formats[i].compression;
1623 status=WriteImage(image_info,reference_image,exception);
1624 reference_image=DestroyImage(reference_image);
1625 if (status == MagickFalse || exception->severity >= ErrorException)
1626 {
1627 (void) FormatLocaleFile(stdout,"... fail @ %s/%s/%lu.\n",
1628 GetMagickModule());
1629 CatchException(exception);
1630 (*fail)++;
1631 continue;
1632 }
1633 /*
1634 Ping reference image.
1635 */
1636 (void) FormatLocaleString(image_info->filename,MagickPathExtent,"%s:%s",
1637 reference_formats[i].magick,output_filename);
1638 ping_image=PingImage(image_info,exception);
1639 if (ping_image == (Image *) NULL ||
1640 exception->severity >= ErrorException)
1641 {
1642 (void) FormatLocaleFile(stdout,"... fail @ %s/%s/%lu.\n",
1643 GetMagickModule());
1644 CatchException(exception);
1645 (*fail)++;
1646 continue;
1647 }
1648 ping_image=DestroyImage(ping_image);
1649 /*
1650 Read reference image.
1651 */
1652 reference_image=ReadImage(image_info,exception);
1653 if (reference_image == (Image *) NULL ||
1654 exception->severity >= ErrorException)
1655 {
1656 (void) FormatLocaleFile(stdout,"... fail @ %s/%s/%lu.\n",
1657 GetMagickModule());
1658 CatchException(exception);
1659 (*fail)++;
1660 continue;
1661 }
1662 /*
1663 Write reference image.
1664 */
1665 (void) FormatLocaleString(reference_image->filename,MagickPathExtent,"%s:%s",
1666 reference_formats[i].magick,output_filename);
1667 (void) CopyMagickString(image_info->magick,reference_formats[i].magick,
1668 MagickPathExtent);
1669 reference_image->depth=reference_types[j].depth;
1670 reference_image->compression=reference_formats[i].compression;
1671 length=8192;
1672 blob=ImageToBlob(image_info,reference_image,&length,exception);
1673 if (blob == (unsigned char *) NULL ||
1674 exception->severity >= ErrorException)
1675 {
1676 (void) FormatLocaleFile(stdout,"... fail @ %s/%s/%lu.\n",
1677 GetMagickModule());
1678 CatchException(exception);
1679 (*fail)++;
1680 reference_image=DestroyImage(reference_image);
1681 continue;
1682 }
1683 /*
1684 Ping reference blob.
1685 */
1686 ping_image=PingBlob(image_info,blob,length,exception);
1687 if (ping_image == (Image *) NULL ||
1688 exception->severity >= ErrorException)
1689 {
1690 (void) FormatLocaleFile(stdout,"... fail @ %s/%s/%lu.\n",
1691 GetMagickModule());
1692 CatchException(exception);
1693 (*fail)++;
1694 blob=(unsigned char *) RelinquishMagickMemory(blob);
1695 continue;
1696 }
1697 ping_image=DestroyImage(ping_image);
1698 /*
1699 Read reconstruct image.
1700 */
1701 (void) FormatLocaleString(image_info->filename,MagickPathExtent,"%s:%s",
1702 reference_formats[i].magick,output_filename);
1703 reconstruct_image=BlobToImage(image_info,blob,length,exception);
1704 blob=(unsigned char *) RelinquishMagickMemory(blob);
1705 if (reconstruct_image == (Image *) NULL ||
1706 exception->severity >= ErrorException)
1707 {
1708 (void) FormatLocaleFile(stdout,"... fail @ %s/%s/%lu.\n",
1709 GetMagickModule());
1710 CatchException(exception);
1711 (*fail)++;
1712 reference_image=DestroyImage(reference_image);
1713 continue;
1714 }
1715 /*
1716 Compare reference to reconstruct image.
1717 */
1718 fuzz=0.003; /* grayscale */
1719 if (reference_formats[i].fuzz != 0.0)
1720 fuzz=reference_formats[i].fuzz;
1721 difference_image=CompareImages(reference_image,reconstruct_image,
1722 RootMeanSquaredErrorMetric,&distortion,exception);
1723 reconstruct_image=DestroyImage(reconstruct_image);
1724 reference_image=DestroyImage(reference_image);
1725 if (difference_image == (Image *) NULL ||
1726 exception->severity >= ErrorException)
1727 {
1728 (void) FormatLocaleFile(stdout,"... fail @ %s/%s/%lu.\n",
1729 GetMagickModule());
1730 CatchException(exception);
1731 (*fail)++;
1732 continue;
1733 }
1734 difference_image=DestroyImage(difference_image);
1735 if ((QuantumScale*distortion) > fuzz)
1736 {
1737 (void) FormatLocaleFile(stdout,"... fail (with distortion %g).\n",
1738 QuantumScale*distortion);
1739 (*fail)++;
1740 continue;
1741 }
1742 #ifdef MagickCountTempFiles
1743 (void) FormatLocaleFile(stdout,"... pass, ");
1744 (void) fflush(stdout);
1745 SystemCommand[0]='\0';
1746 (void) strncat(SystemCommand,"echo `ls ",9);
1747 (void) strncat(SystemCommand,path,MagickPathExtent-31);
1748 (void) strncat(SystemCommand,"* | wc -w` tmp files.",20);
1749 (void) system(SystemCommand);
1750 (void) fflush(stdout);
1751 #else
1752 (void) FormatLocaleFile(stdout,"... pass\n");
1753 #endif
1754 }
1755 }
1756 (void) FormatLocaleFile(stdout,
1757 " summary: %.20g subtests; %.20g passed; %.20g failed.\n",(double) test,
1758 (double) (test-(*fail)),(double) *fail);
1759 return(test);
1760 }
1761
1762 /*
1763 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1764 % %
1765 % %
1766 % %
1767 % 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 %
1768 % %
1769 % %
1770 % %
1771 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1772 %
1773 % ValidateImageFormatsOnDisk() validates the ImageMagick image formats on disk
1774 % and returns the number of validation tests that passed and failed.
1775 %
1776 % The format of the ValidateImageFormatsOnDisk method is:
1777 %
1778 % size_t ValidateImageFormatsOnDisk(ImageInfo *image_info,
1779 % const char *reference_filename,const char *output_filename,
1780 % size_t *fail,ExceptionInfo *exception)
1781 %
1782 % A description of each parameter follows:
1783 %
1784 % o image_info: the image info.
1785 %
1786 % o reference_filename: the reference image filename.
1787 %
1788 % o output_filename: the output image filename.
1789 %
1790 % o fail: return the number of validation tests that pass.
1791 %
1792 % o exception: return any errors or warnings in this structure.
1793 %
1794 */
ValidateImageFormatsOnDisk(ImageInfo * image_info,const char * reference_filename,const char * output_filename,size_t * fail,ExceptionInfo * exception)1795 static size_t ValidateImageFormatsOnDisk(ImageInfo *image_info,
1796 const char *reference_filename,const char *output_filename,size_t *fail,
1797 ExceptionInfo *exception)
1798 {
1799 char
1800 size[MagickPathExtent];
1801
1802 const MagickInfo
1803 *magick_info;
1804
1805 double
1806 distortion,
1807 fuzz;
1808
1809 Image
1810 *difference_image,
1811 *reference_image,
1812 *reconstruct_image;
1813
1814 MagickBooleanType
1815 status;
1816
1817 register ssize_t
1818 i,
1819 j;
1820
1821 size_t
1822 test;
1823
1824 test=0;
1825 (void) FormatLocaleFile(stdout,"validate image formats on disk:\n");
1826 for (i=0; reference_formats[i].magick != (char *) NULL; i++)
1827 {
1828 magick_info=GetMagickInfo(reference_formats[i].magick,exception);
1829 if ((magick_info == (const MagickInfo *) NULL) ||
1830 (magick_info->decoder == (DecodeImageHandler *) NULL) ||
1831 (magick_info->encoder == (EncodeImageHandler *) NULL))
1832 continue;
1833 for (j=0; reference_types[j].type != UndefinedType; j++)
1834 {
1835 /*
1836 Generate reference image.
1837 */
1838 CatchException(exception);
1839 (void) FormatLocaleFile(stdout," test %.20g: %s/%s/%s/%.20g-bits",
1840 (double) (test++),reference_formats[i].magick,CommandOptionToMnemonic(
1841 MagickCompressOptions,reference_formats[i].compression),
1842 CommandOptionToMnemonic(MagickTypeOptions,reference_types[j].type),
1843 (double) reference_types[j].depth);
1844 (void) CopyMagickString(image_info->filename,reference_filename,
1845 MagickPathExtent);
1846 reference_image=ReadImage(image_info,exception);
1847 if (reference_image == (Image *) NULL ||
1848 exception->severity >= ErrorException)
1849 {
1850 (void) FormatLocaleFile(stdout,"... fail @ %s/%s/%lu.\n",
1851 GetMagickModule());
1852 CatchException(exception);
1853 (*fail)++;
1854 continue;
1855 }
1856 /*
1857 Write reference image.
1858 */
1859 (void) FormatLocaleString(size,MagickPathExtent,"%.20gx%.20g",
1860 (double) reference_image->columns,(double) reference_image->rows);
1861 (void) CloneString(&image_info->size,size);
1862 image_info->depth=reference_types[j].depth;
1863 (void) FormatLocaleString(reference_image->filename,MagickPathExtent,"%s:%s",
1864 reference_formats[i].magick,output_filename);
1865 status=SetImageType(reference_image,reference_types[j].type,exception);
1866 if (status == MagickFalse || exception->severity >= ErrorException)
1867 {
1868 (void) FormatLocaleFile(stdout,"... fail @ %s/%s/%lu.\n",
1869 GetMagickModule());
1870 CatchException(exception);
1871 (*fail)++;
1872 reference_image=DestroyImage(reference_image);
1873 continue;
1874 }
1875 status=SetImageDepth(reference_image,reference_types[j].depth,exception);
1876 if (status == MagickFalse || exception->severity >= ErrorException)
1877 {
1878 (void) FormatLocaleFile(stdout,"... fail @ %s/%s/%lu.\n",
1879 GetMagickModule());
1880 CatchException(exception);
1881 (*fail)++;
1882 reference_image=DestroyImage(reference_image);
1883 continue;
1884 }
1885 reference_image->compression=reference_formats[i].compression;
1886 status=WriteImage(image_info,reference_image,exception);
1887 reference_image=DestroyImage(reference_image);
1888 if (status == MagickFalse || exception->severity >= ErrorException)
1889 {
1890 (void) FormatLocaleFile(stdout,"... fail @ %s/%s/%lu.\n",
1891 GetMagickModule());
1892 CatchException(exception);
1893 (*fail)++;
1894 continue;
1895 }
1896 /*
1897 Read reference image.
1898 */
1899 (void) FormatLocaleString(image_info->filename,MagickPathExtent,"%s:%s",
1900 reference_formats[i].magick,output_filename);
1901 reference_image=ReadImage(image_info,exception);
1902 if (reference_image == (Image *) NULL ||
1903 exception->severity >= ErrorException)
1904 {
1905 (void) FormatLocaleFile(stdout,"... fail @ %s/%s/%lu.\n",
1906 GetMagickModule());
1907 CatchException(exception);
1908 (*fail)++;
1909 continue;
1910 }
1911 /*
1912 Write reference image.
1913 */
1914 (void) FormatLocaleString(reference_image->filename,MagickPathExtent,"%s:%s",
1915 reference_formats[i].magick,output_filename);
1916 reference_image->depth=reference_types[j].depth;
1917 reference_image->compression=reference_formats[i].compression;
1918 status=WriteImage(image_info,reference_image,exception);
1919 if (status == MagickFalse ||exception->severity >= ErrorException)
1920 {
1921 (void) FormatLocaleFile(stdout,"... fail @ %s/%s/%lu.\n",
1922 GetMagickModule());
1923 CatchException(exception);
1924 (*fail)++;
1925 reference_image=DestroyImage(reference_image);
1926 continue;
1927 }
1928 /*
1929 Read reconstruct image.
1930 */
1931 (void) FormatLocaleString(image_info->filename,MagickPathExtent,"%s:%s",
1932 reference_formats[i].magick,output_filename);
1933 reconstruct_image=ReadImage(image_info,exception);
1934 if (reconstruct_image == (Image *) NULL ||
1935 exception->severity >= ErrorException)
1936 {
1937 (void) FormatLocaleFile(stdout,"... fail @ %s/%s/%lu.\n",
1938 GetMagickModule());
1939 CatchException(exception);
1940 (*fail)++;
1941 reference_image=DestroyImage(reference_image);
1942 continue;
1943 }
1944 /*
1945 Compare reference to reconstruct image.
1946 */
1947 fuzz=0.003; /* grayscale */
1948 if (reference_formats[i].fuzz != 0.0)
1949 fuzz=reference_formats[i].fuzz;
1950 difference_image=CompareImages(reference_image,reconstruct_image,
1951 RootMeanSquaredErrorMetric,&distortion,exception);
1952 reconstruct_image=DestroyImage(reconstruct_image);
1953 reference_image=DestroyImage(reference_image);
1954 if (difference_image == (Image *) NULL ||
1955 exception->severity >= ErrorException)
1956 {
1957 (void) FormatLocaleFile(stdout,"... fail @ %s/%s/%lu.\n",
1958 GetMagickModule());
1959 CatchException(exception);
1960 (*fail)++;
1961 continue;
1962 }
1963 difference_image=DestroyImage(difference_image);
1964 if ((QuantumScale*distortion) > fuzz)
1965 {
1966 (void) FormatLocaleFile(stdout,"... fail (with distortion %g).\n",
1967 QuantumScale*distortion);
1968 (*fail)++;
1969 continue;
1970 }
1971 (void) FormatLocaleFile(stdout,"... pass.\n");
1972 }
1973 }
1974 (void) FormatLocaleFile(stdout,
1975 " summary: %.20g subtests; %.20g passed; %.20g failed.\n",(double) test,
1976 (double) (test-(*fail)),(double) *fail);
1977 return(test);
1978 }
1979
1980 /*
1981 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1982 % %
1983 % %
1984 % %
1985 % 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 %
1986 % %
1987 % %
1988 % %
1989 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1990 %
1991 % ValidateImportExportPixels() validates the pixel import and export methods.
1992 % It returns the number of validation tests that passed and failed.
1993 %
1994 % The format of the ValidateImportExportPixels method is:
1995 %
1996 % size_t ValidateImportExportPixels(ImageInfo *image_info,
1997 % const char *reference_filename,const char *output_filename,
1998 % size_t *fail,ExceptionInfo *exception)
1999 %
2000 % A description of each parameter follows:
2001 %
2002 % o image_info: the image info.
2003 %
2004 % o reference_filename: the reference image filename.
2005 %
2006 % o output_filename: the output image filename.
2007 %
2008 % o fail: return the number of validation tests that pass.
2009 %
2010 % o exception: return any errors or warnings in this structure.
2011 %
2012 */
ValidateImportExportPixels(ImageInfo * image_info,const char * reference_filename,const char * output_filename,size_t * fail,ExceptionInfo * exception)2013 static size_t ValidateImportExportPixels(ImageInfo *image_info,
2014 const char *reference_filename,const char *output_filename,size_t *fail,
2015 ExceptionInfo *exception)
2016 {
2017 double
2018 distortion;
2019
2020 Image
2021 *difference_image,
2022 *reference_image,
2023 *reconstruct_image;
2024
2025 MagickBooleanType
2026 status;
2027
2028 register ssize_t
2029 i,
2030 j;
2031
2032 size_t
2033 length;
2034
2035 unsigned char
2036 *pixels;
2037
2038 size_t
2039 test;
2040
2041 (void) output_filename;
2042 test=0;
2043 (void) FormatLocaleFile(stdout,
2044 "validate the import and export of image pixels:\n");
2045 for (i=0; reference_map[i] != (char *) NULL; i++)
2046 {
2047 for (j=0; reference_storage[j].type != UndefinedPixel; j++)
2048 {
2049 /*
2050 Generate reference image.
2051 */
2052 CatchException(exception);
2053 (void) FormatLocaleFile(stdout," test %.20g: %s/%s",(double) (test++),
2054 reference_map[i],CommandOptionToMnemonic(MagickStorageOptions,
2055 reference_storage[j].type));
2056 (void) CopyMagickString(image_info->filename,reference_filename,
2057 MagickPathExtent);
2058 reference_image=ReadImage(image_info,exception);
2059 if (reference_image == (Image *) NULL ||
2060 exception->severity >= ErrorException)
2061 {
2062 (void) FormatLocaleFile(stdout,"... fail @ %s/%s/%lu.\n",
2063 GetMagickModule());
2064 CatchException(exception);
2065 (*fail)++;
2066 continue;
2067 }
2068 if (LocaleNCompare(reference_map[i],"cmy",3) == 0)
2069 (void) SetImageColorspace(reference_image,CMYKColorspace,exception);
2070 length=strlen(reference_map[i])*reference_image->columns*
2071 reference_image->rows*reference_storage[j].quantum;
2072 pixels=(unsigned char *) AcquireQuantumMemory(length,sizeof(*pixels));
2073 if (pixels == (unsigned char *) NULL ||
2074 exception->severity >= ErrorException)
2075 {
2076 (void) FormatLocaleFile(stdout,"... fail @ %s/%s/%lu.\n",
2077 GetMagickModule());
2078 CatchException(exception);
2079 (*fail)++;
2080 reference_image=DestroyImage(reference_image);
2081 continue;
2082 }
2083 (void) ResetMagickMemory(pixels,0,length*sizeof(*pixels));
2084 status=ExportImagePixels(reference_image,0,0,reference_image->columns,
2085 reference_image->rows,reference_map[i],reference_storage[j].type,pixels,
2086 exception);
2087 if (status == MagickFalse || exception->severity >= ErrorException)
2088 {
2089 (void) FormatLocaleFile(stdout,"... fail @ %s/%s/%lu.\n",
2090 GetMagickModule());
2091 CatchException(exception);
2092 (*fail)++;
2093 pixels=(unsigned char *) RelinquishMagickMemory(pixels);
2094 reference_image=DestroyImage(reference_image);
2095 continue;
2096 }
2097 (void) SetImageBackgroundColor(reference_image,exception);
2098 status=ImportImagePixels(reference_image,0,0,reference_image->columns,
2099 reference_image->rows,reference_map[i],reference_storage[j].type,
2100 pixels,exception);
2101 if (status == MagickFalse || exception->severity >= ErrorException)
2102 {
2103 (void) FormatLocaleFile(stdout,"... fail @ %s/%s/%lu.\n",
2104 GetMagickModule());
2105 CatchException(exception);
2106 (*fail)++;
2107 pixels=(unsigned char *) RelinquishMagickMemory(pixels);
2108 reference_image=DestroyImage(reference_image);
2109 continue;
2110 }
2111 /*
2112 Read reconstruct image.
2113 */
2114 reconstruct_image=AcquireImage(image_info,exception);
2115 (void) SetImageExtent(reconstruct_image,reference_image->columns,
2116 reference_image->rows,exception);
2117 (void) SetImageColorspace(reconstruct_image,reference_image->colorspace,
2118 exception);
2119 (void) SetImageBackgroundColor(reconstruct_image,exception);
2120 status=ImportImagePixels(reconstruct_image,0,0,reconstruct_image->columns,
2121 reconstruct_image->rows,reference_map[i],reference_storage[j].type,
2122 pixels,exception);
2123 pixels=(unsigned char *) RelinquishMagickMemory(pixels);
2124 if (status == MagickFalse || exception->severity >= ErrorException)
2125 {
2126 (void) FormatLocaleFile(stdout,"... fail @ %s/%s/%lu.\n",
2127 GetMagickModule());
2128 CatchException(exception);
2129 (*fail)++;
2130 reference_image=DestroyImage(reference_image);
2131 continue;
2132 }
2133 /*
2134 Compare reference to reconstruct image.
2135 */
2136 difference_image=CompareImages(reference_image,reconstruct_image,
2137 RootMeanSquaredErrorMetric,&distortion,exception);
2138 reconstruct_image=DestroyImage(reconstruct_image);
2139 reference_image=DestroyImage(reference_image);
2140 if (difference_image == (Image *) NULL ||
2141 exception->severity >= ErrorException)
2142 {
2143 (void) FormatLocaleFile(stdout,"... fail @ %s/%s/%lu.\n",
2144 GetMagickModule());
2145 CatchException(exception);
2146 (*fail)++;
2147 continue;
2148 }
2149 difference_image=DestroyImage(difference_image);
2150 if ((QuantumScale*distortion) > 0.0)
2151 {
2152 (void) FormatLocaleFile(stdout,"... fail (with distortion %g).\n",
2153 QuantumScale*distortion);
2154 (*fail)++;
2155 continue;
2156 }
2157 (void) FormatLocaleFile(stdout,"... pass.\n");
2158 }
2159 }
2160 (void) FormatLocaleFile(stdout,
2161 " summary: %.20g subtests; %.20g passed; %.20g failed.\n",(double) test,
2162 (double) (test-(*fail)),(double) *fail);
2163 return(test);
2164 }
2165
2166 /*
2167 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2168 % %
2169 % %
2170 % %
2171 % V a l i d a t e M o n t a g e C o m m a n d %
2172 % %
2173 % %
2174 % %
2175 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2176 %
2177 % ValidateMontageCommand() validates the ImageMagick montage command line
2178 % program and returns the number of validation tests that passed and failed.
2179 %
2180 % The format of the ValidateMontageCommand method is:
2181 %
2182 % size_t ValidateMontageCommand(ImageInfo *image_info,
2183 % const char *reference_filename,const char *output_filename,
2184 % size_t *fail,ExceptionInfo *exception)
2185 %
2186 % A description of each parameter follows:
2187 %
2188 % o image_info: the image info.
2189 %
2190 % o reference_filename: the reference image filename.
2191 %
2192 % o output_filename: the output image filename.
2193 %
2194 % o fail: return the number of validation tests that pass.
2195 %
2196 % o exception: return any errors or warnings in this structure.
2197 %
2198 */
ValidateMontageCommand(ImageInfo * image_info,const char * reference_filename,const char * output_filename,size_t * fail,ExceptionInfo * exception)2199 static size_t ValidateMontageCommand(ImageInfo *image_info,
2200 const char *reference_filename,const char *output_filename,size_t *fail,
2201 ExceptionInfo *exception)
2202 {
2203 char
2204 **arguments,
2205 command[MagickPathExtent];
2206
2207 int
2208 number_arguments;
2209
2210 MagickBooleanType
2211 status;
2212
2213 register ssize_t
2214 i,
2215 j;
2216
2217 size_t
2218 test;
2219
2220 test=0;
2221 (void) FormatLocaleFile(stdout,"validate montage command line program:\n");
2222 for (i=0; montage_options[i] != (char *) NULL; i++)
2223 {
2224 CatchException(exception);
2225 (void) FormatLocaleFile(stdout," test %.20g: %s",(double) (test++),
2226 montage_options[i]);
2227 (void) FormatLocaleString(command,MagickPathExtent,"%s %s %s %s",
2228 reference_filename,montage_options[i],reference_filename,
2229 output_filename);
2230 arguments=StringToArgv(command,&number_arguments);
2231 if (arguments == (char **) NULL)
2232 {
2233 (void) FormatLocaleFile(stdout,"... fail @ %s/%s/%lu.\n",
2234 GetMagickModule());
2235 (*fail)++;
2236 continue;
2237 }
2238 status=MontageImageCommand(image_info,number_arguments,arguments,
2239 (char **) NULL,exception);
2240 for (j=0; j < (ssize_t) number_arguments; j++)
2241 arguments[j]=DestroyString(arguments[j]);
2242 arguments=(char **) RelinquishMagickMemory(arguments);
2243 if (status == MagickFalse)
2244 {
2245 (void) FormatLocaleFile(stdout,"... fail @ %s/%s/%lu.\n",
2246 GetMagickModule());
2247 (*fail)++;
2248 continue;
2249 }
2250 (void) FormatLocaleFile(stdout,"... pass.\n");
2251 }
2252 (void) FormatLocaleFile(stdout,
2253 " summary: %.20g subtests; %.20g passed; %.20g failed.\n",(double) test,
2254 (double) (test-(*fail)),(double) *fail);
2255 return(test);
2256 }
2257
2258 /*
2259 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2260 % %
2261 % %
2262 % %
2263 % V a l i d a t e S t r e a m C o m m a n d %
2264 % %
2265 % %
2266 % %
2267 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2268 %
2269 % ValidateStreamCommand() validates the ImageMagick stream command line
2270 % program and returns the number of validation tests that passed and failed.
2271 %
2272 % The format of the ValidateStreamCommand method is:
2273 %
2274 % size_t ValidateStreamCommand(ImageInfo *image_info,
2275 % const char *reference_filename,const char *output_filename,
2276 % size_t *fail,ExceptionInfo *exception)
2277 %
2278 % A description of each parameter follows:
2279 %
2280 % o image_info: the image info.
2281 %
2282 % o reference_filename: the reference image filename.
2283 %
2284 % o output_filename: the output image filename.
2285 %
2286 % o fail: return the number of validation tests that pass.
2287 %
2288 % o exception: return any errors or warnings in this structure.
2289 %
2290 */
ValidateStreamCommand(ImageInfo * image_info,const char * reference_filename,const char * output_filename,size_t * fail,ExceptionInfo * exception)2291 static size_t ValidateStreamCommand(ImageInfo *image_info,
2292 const char *reference_filename,const char *output_filename,size_t *fail,
2293 ExceptionInfo *exception)
2294 {
2295 char
2296 **arguments,
2297 command[MagickPathExtent];
2298
2299 int
2300 number_arguments;
2301
2302 MagickBooleanType
2303 status;
2304
2305 register ssize_t
2306 i,
2307 j;
2308
2309 size_t
2310 test;
2311
2312 test=0;
2313 (void) FormatLocaleFile(stdout,"validate stream command line program:\n");
2314 for (i=0; stream_options[i] != (char *) NULL; i++)
2315 {
2316 CatchException(exception);
2317 (void) FormatLocaleFile(stdout," test %.20g: %s",(double) (test++),
2318 stream_options[i]);
2319 (void) FormatLocaleString(command,MagickPathExtent,"%s %s %s",
2320 stream_options[i],reference_filename,output_filename);
2321 arguments=StringToArgv(command,&number_arguments);
2322 if (arguments == (char **) NULL)
2323 {
2324 (void) FormatLocaleFile(stdout,"... fail @ %s/%s/%lu.\n",
2325 GetMagickModule());
2326 (*fail)++;
2327 continue;
2328 }
2329 status=StreamImageCommand(image_info,number_arguments,arguments,
2330 (char **) NULL,exception);
2331 for (j=0; j < (ssize_t) number_arguments; j++)
2332 arguments[j]=DestroyString(arguments[j]);
2333 arguments=(char **) RelinquishMagickMemory(arguments);
2334 if (status == MagickFalse)
2335 {
2336 (void) FormatLocaleFile(stdout,"... fail @ %s/%s/%lu.\n",
2337 GetMagickModule());
2338 (*fail)++;
2339 continue;
2340 }
2341 (void) FormatLocaleFile(stdout,"... pass.\n");
2342 }
2343 (void) FormatLocaleFile(stdout,
2344 " summary: %.20g subtests; %.20g passed; %.20g failed.\n",(double) test,
2345 (double) (test-(*fail)),(double) *fail);
2346 return(test);
2347 }
2348
2349 /*
2350 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2351 % %
2352 % %
2353 % %
2354 % M a i n %
2355 % %
2356 % %
2357 % %
2358 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2359 %
2360 %
2361 */
2362
ValidateUsage(void)2363 static MagickBooleanType ValidateUsage(void)
2364 {
2365 const char
2366 **p;
2367
2368 static const char
2369 *miscellaneous[]=
2370 {
2371 "-debug events display copious debugging information",
2372 "-help print program options",
2373 "-log format format of debugging information",
2374 "-validate type validation type",
2375 "-version print version information",
2376 (char *) NULL
2377 },
2378 *settings[]=
2379 {
2380 "-regard-warnings pay attention to warning messages",
2381 "-verbose print detailed information about the image",
2382 (char *) NULL
2383 };
2384
2385 (void) printf("Version: %s\n",GetMagickVersion((size_t *) NULL));
2386 (void) printf("Copyright: %s\n\n",GetMagickCopyright());
2387 (void) printf("Features: %s\n",GetMagickFeatures());
2388 (void) printf("Usage: %s [options ...] reference-file\n",GetClientName());
2389 (void) printf("\nValidate Settings:\n");
2390 for (p=settings; *p != (char *) NULL; p++)
2391 (void) printf(" %s\n",*p);
2392 (void) printf("\nMiscellaneous Options:\n");
2393 for (p=miscellaneous; *p != (char *) NULL; p++)
2394 (void) printf(" %s\n",*p);
2395 return(MagickTrue);
2396 }
2397
main(int argc,char ** argv)2398 int main(int argc,char **argv)
2399 {
2400 #define DestroyValidate() \
2401 { \
2402 image_info=DestroyImageInfo(image_info); \
2403 exception=DestroyExceptionInfo(exception); \
2404 }
2405 #define ThrowValidateException(asperity,tag,option) \
2406 { \
2407 (void) ThrowMagickException(exception,GetMagickModule(),asperity,tag,"`%s'", \
2408 option); \
2409 CatchException(exception); \
2410 DestroyValidate(); \
2411 return(MagickFalse); \
2412 }
2413
2414 char
2415 output_filename[MagickPathExtent],
2416 reference_filename[MagickPathExtent],
2417 *option;
2418
2419 double
2420 elapsed_time,
2421 user_time;
2422
2423 ExceptionInfo
2424 *exception;
2425
2426 Image
2427 *reference_image;
2428
2429 ImageInfo
2430 *image_info;
2431
2432 MagickBooleanType
2433 regard_warnings,
2434 status;
2435
2436 MagickSizeType
2437 memory_resource,
2438 map_resource;
2439
2440 register ssize_t
2441 i;
2442
2443 TimerInfo
2444 *timer;
2445
2446 size_t
2447 fail,
2448 iterations,
2449 tests;
2450
2451 ValidateType
2452 type;
2453
2454 /*
2455 Validate the ImageMagick image processing suite.
2456 */
2457 MagickCoreGenesis(*argv,MagickTrue);
2458 (void) setlocale(LC_ALL,"");
2459 (void) setlocale(LC_NUMERIC,"C");
2460 iterations=1;
2461 status=MagickFalse;
2462 type=AllValidate;
2463 regard_warnings=MagickFalse;
2464 (void) regard_warnings;
2465 exception=AcquireExceptionInfo();
2466 image_info=AcquireImageInfo();
2467 (void) CopyMagickString(image_info->filename,ReferenceFilename,MagickPathExtent);
2468 for (i=1; i < (ssize_t) argc; i++)
2469 {
2470 option=argv[i];
2471 if (IsCommandOption(option) == MagickFalse)
2472 {
2473 (void) CopyMagickString(image_info->filename,option,MagickPathExtent);
2474 continue;
2475 }
2476 switch (*(option+1))
2477 {
2478 case 'b':
2479 {
2480 if (LocaleCompare("bench",option+1) == 0)
2481 {
2482 iterations=StringToUnsignedLong(argv[++i]);
2483 break;
2484 }
2485 ThrowValidateException(OptionError,"UnrecognizedOption",option)
2486 }
2487 case 'd':
2488 {
2489 if (LocaleCompare("debug",option+1) == 0)
2490 {
2491 (void) SetLogEventMask(argv[++i]);
2492 break;
2493 }
2494 ThrowValidateException(OptionError,"UnrecognizedOption",option)
2495 }
2496 case 'h':
2497 {
2498 if (LocaleCompare("help",option+1) == 0)
2499 {
2500 (void) ValidateUsage();
2501 return(0);
2502 }
2503 ThrowValidateException(OptionError,"UnrecognizedOption",option)
2504 }
2505 case 'l':
2506 {
2507 if (LocaleCompare("log",option+1) == 0)
2508 {
2509 if (*option != '+')
2510 (void) SetLogFormat(argv[i+1]);
2511 break;
2512 }
2513 ThrowValidateException(OptionError,"UnrecognizedOption",option)
2514 }
2515 case 'r':
2516 {
2517 if (LocaleCompare("regard-warnings",option+1) == 0)
2518 {
2519 regard_warnings=MagickTrue;
2520 break;
2521 }
2522 ThrowValidateException(OptionError,"UnrecognizedOption",option)
2523 }
2524 case 'v':
2525 {
2526 if (LocaleCompare("validate",option+1) == 0)
2527 {
2528 ssize_t
2529 validate;
2530
2531 if (*option == '+')
2532 break;
2533 i++;
2534 if (i >= (ssize_t) argc)
2535 ThrowValidateException(OptionError,"MissingArgument",option);
2536 validate=ParseCommandOption(MagickValidateOptions,MagickFalse,
2537 argv[i]);
2538 if (validate < 0)
2539 ThrowValidateException(OptionError,"UnrecognizedValidateType",
2540 argv[i]);
2541 type=(ValidateType) validate;
2542 break;
2543 }
2544 if ((LocaleCompare("version",option+1) == 0) ||
2545 (LocaleCompare("-version",option+1) == 0))
2546 {
2547 (void) FormatLocaleFile(stdout,"Version: %s\n",
2548 GetMagickVersion((size_t *) NULL));
2549 (void) FormatLocaleFile(stdout,"Copyright: %s\n\n",
2550 GetMagickCopyright());
2551 (void) FormatLocaleFile(stdout,"Features: %s\n\n",
2552 GetMagickFeatures());
2553 return(0);
2554 }
2555 ThrowValidateException(OptionError,"UnrecognizedOption",option)
2556 }
2557 default:
2558 ThrowValidateException(OptionError,"UnrecognizedOption",option)
2559 }
2560 }
2561 timer=(TimerInfo *) NULL;
2562 if (iterations > 1)
2563 timer=AcquireTimerInfo();
2564 reference_image=ReadImage(image_info,exception);
2565 tests=0;
2566 fail=0;
2567 if (reference_image == (Image *) NULL)
2568 fail++;
2569 else
2570 {
2571 if (LocaleCompare(image_info->filename,ReferenceFilename) == 0)
2572 (void) CopyMagickString(reference_image->magick,ReferenceImageFormat,
2573 MagickPathExtent);
2574 (void) AcquireUniqueFilename(reference_filename);
2575 (void) AcquireUniqueFilename(output_filename);
2576 (void) CopyMagickString(reference_image->filename,reference_filename,
2577 MagickPathExtent);
2578 status=WriteImage(image_info,reference_image,exception);
2579 reference_image=DestroyImage(reference_image);
2580 if (status == MagickFalse)
2581 fail++;
2582 else
2583 {
2584 (void) FormatLocaleFile(stdout,"Version: %s\n",
2585 GetMagickVersion((size_t *) NULL));
2586 (void) FormatLocaleFile(stdout,"Copyright: %s\n\n",
2587 GetMagickCopyright());
2588 (void) FormatLocaleFile(stdout,
2589 "ImageMagick Validation Suite (%s)\n\n",CommandOptionToMnemonic(
2590 MagickValidateOptions,(ssize_t) type));
2591 if ((type & ColorspaceValidate) != 0)
2592 tests+=ValidateColorspaces(image_info,&fail,exception);
2593 if ((type & CompareValidate) != 0)
2594 tests+=ValidateCompareCommand(image_info,reference_filename,
2595 output_filename,&fail,exception);
2596 if ((type & CompositeValidate) != 0)
2597 tests+=ValidateCompositeCommand(image_info,reference_filename,
2598 output_filename,&fail,exception);
2599 if ((type & ConvertValidate) != 0)
2600 tests+=ValidateConvertCommand(image_info,reference_filename,
2601 output_filename,&fail,exception);
2602 if ((type & FormatsDiskValidate) != 0)
2603 {
2604 memory_resource=SetMagickResourceLimit(MemoryResource,0);
2605 map_resource=SetMagickResourceLimit(MapResource,0);
2606 (void) FormatLocaleFile(stdout,"[pixel-cache: disk] ");
2607 tests+=ValidateImageFormatsInMemory(image_info,reference_filename,
2608 output_filename,&fail,exception);
2609 (void) FormatLocaleFile(stdout,"[pixel-cache: disk] ");
2610 tests+=ValidateImageFormatsOnDisk(image_info,reference_filename,
2611 output_filename,&fail,exception);
2612 (void) SetMagickResourceLimit(MemoryResource,memory_resource);
2613 (void) SetMagickResourceLimit(MapResource,map_resource);
2614 }
2615 if ((type & FormatsMapValidate) != 0)
2616 {
2617 memory_resource=SetMagickResourceLimit(MemoryResource,0);
2618 (void) FormatLocaleFile(stdout,"[pixel-cache: memory-mapped] ");
2619 tests+=ValidateImageFormatsInMemory(image_info,reference_filename,
2620 output_filename,&fail,exception);
2621 (void) FormatLocaleFile(stdout,"[pixel-cache: memory-mapped] ");
2622 tests+=ValidateImageFormatsOnDisk(image_info,reference_filename,
2623 output_filename,&fail,exception);
2624 (void) SetMagickResourceLimit(MemoryResource,memory_resource);
2625 }
2626 if ((type & FormatsMemoryValidate) != 0)
2627 {
2628 (void) FormatLocaleFile(stdout,"[pixel-cache: memory] ");
2629 tests+=ValidateImageFormatsInMemory(image_info,reference_filename,
2630 output_filename,&fail,exception);
2631 (void) FormatLocaleFile(stdout,"[pixel-cache: memory] ");
2632 tests+=ValidateImageFormatsOnDisk(image_info,reference_filename,
2633 output_filename,&fail,exception);
2634 }
2635 if ((type & IdentifyValidate) != 0)
2636 tests+=ValidateIdentifyCommand(image_info,reference_filename,
2637 output_filename,&fail,exception);
2638 if ((type & ImportExportValidate) != 0)
2639 tests+=ValidateImportExportPixels(image_info,reference_filename,
2640 output_filename,&fail,exception);
2641 if ((type & MontageValidate) != 0)
2642 tests+=ValidateMontageCommand(image_info,reference_filename,
2643 output_filename,&fail,exception);
2644 if ((type & StreamValidate) != 0)
2645 tests+=ValidateStreamCommand(image_info,reference_filename,
2646 output_filename,&fail,exception);
2647 (void) FormatLocaleFile(stdout,
2648 "validation suite: %.20g tests; %.20g passed; %.20g failed.\n",
2649 (double) tests,(double) (tests-fail),(double) fail);
2650 }
2651 (void) RelinquishUniqueFileResource(output_filename);
2652 (void) RelinquishUniqueFileResource(reference_filename);
2653 }
2654 if (exception->severity != UndefinedException)
2655 CatchException(exception);
2656 if (iterations > 1)
2657 {
2658 elapsed_time=GetElapsedTime(timer);
2659 user_time=GetUserTime(timer);
2660 (void) FormatLocaleFile(stderr,
2661 "Performance: %.20gi %gips %0.3fu %ld:%02ld.%03ld\n",(double)
2662 iterations,1.0*iterations/elapsed_time,user_time,(long)
2663 (elapsed_time/60.0),(long) ceil(fmod(elapsed_time,60.0)),
2664 (long) (1000.0*(elapsed_time-floor(elapsed_time))));
2665 timer=DestroyTimerInfo(timer);
2666 }
2667 DestroyValidate();
2668 MagickCoreTerminus();
2669 return(fail == 0 ? 0 : 1);
2670 }
2671