granicus.if.org Git - imagemagick/blob - tests/validate.c

   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-2018 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 \f
  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 \f
  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 \f
  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
  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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
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
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 \f
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 */
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 \f
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 */
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 \f
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 */
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 \f
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 */
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 \f
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
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=ImageToBlob(image_info,reference_image,&length,exception);
1687       if ((blob == (unsigned char *) NULL) ||
1688           (exception->severity >= ErrorException))
1689         {
1690           (void) FormatLocaleFile(stdout,"... fail @ %s/%s/%lu.\n",
1691             GetMagickModule());
1692           if (exception->reason != (char *) NULL)
1693             (void) FormatLocaleFile(stdout,"    reason:%s\n",exception->reason);
1694           CatchException(exception);
1695           (*fail)++;
1696           reference_image=DestroyImage(reference_image);
1697           continue;
1698         }
1699       /*
1700         Ping reference blob.
1701       */
1702       ping_image=PingBlob(image_info,blob,length,exception);
1703       if (ping_image == (Image *) NULL ||
1704           (exception->severity >= ErrorException))
1705         {
1706           (void) FormatLocaleFile(stdout,"... fail @ %s/%s/%lu.\n",
1707             GetMagickModule());
1708           if (exception->reason != (char *) NULL)
1709             (void) FormatLocaleFile(stdout,"    reason:%s\n",exception->reason);
1710           CatchException(exception);
1711           (*fail)++;
1712           blob=(unsigned char *) RelinquishMagickMemory(blob);
1713           continue;
1714         }
1715       ping_image=DestroyImage(ping_image);
1716       /*
1717         Read reconstruct image.
1718       */
1719       (void) FormatLocaleString(image_info->filename,MagickPathExtent,"%s:%s",
1720         reference_formats[i].magick,output_filename);
1721       reconstruct_image=BlobToImage(image_info,blob,length,exception);
1722       blob=(unsigned char *) RelinquishMagickMemory(blob);
1723       if (reconstruct_image == (Image *) NULL ||
1724           (exception->severity >= ErrorException))
1725         {
1726           (void) FormatLocaleFile(stdout,"... fail @ %s/%s/%lu.\n",
1727             GetMagickModule());
1728           if (exception->reason != (char *) NULL)
1729             (void) FormatLocaleFile(stdout,"    reason:%s\n",exception->reason);
1730           CatchException(exception);
1731           (*fail)++;
1732           reference_image=DestroyImage(reference_image);
1733           continue;
1734         }
1735       /*
1736         Compare reference to reconstruct image.
1737       */
1738       fuzz=0.003;  /* grayscale */
1739       if (reference_formats[i].fuzz != 0.0)
1740         fuzz=reference_formats[i].fuzz;
1741       difference_image=CompareImages(reference_image,reconstruct_image,
1742         RootMeanSquaredErrorMetric,&distortion,exception);
1743       reconstruct_image=DestroyImage(reconstruct_image);
1744       reference_image=DestroyImage(reference_image);
1745       if (difference_image == (Image *) NULL ||
1746           (exception->severity >= ErrorException))
1747         {
1748           (void) FormatLocaleFile(stdout,"... fail @ %s/%s/%lu.\n",
1749             GetMagickModule());
1750           if (exception->reason != (char *) NULL)
1751             (void) FormatLocaleFile(stdout,"    reason:%s\n",exception->reason);
1752           CatchException(exception);
1753           (*fail)++;
1754           continue;
1755         }
1756       difference_image=DestroyImage(difference_image);
1757       if ((QuantumScale*distortion) > fuzz)
1758         {
1759           (void) FormatLocaleFile(stdout,"... fail (with distortion %g).\n",
1760             QuantumScale*distortion);
1761           (*fail)++;
1762           continue;
1763         }
1764 #ifdef MagickCountTempFiles
1765       (void) FormatLocaleFile(stdout,"... pass, ");
1766       (void) fflush(stdout);
1767       SystemCommand[0]='\0';
1768       (void) strncat(SystemCommand,"echo `ls ",9);
1769       (void) strncat(SystemCommand,path,MagickPathExtent-31);
1770       (void) strncat(SystemCommand,"* | wc -w` tmp files.",20);
1771       (void) system(SystemCommand);
1772       (void) fflush(stdout);
1773 #else
1774       (void) FormatLocaleFile(stdout,"... pass\n");
1775 #endif
1776     }
1777   }
1778   (void) FormatLocaleFile(stdout,
1779     "  summary: %.20g subtests; %.20g passed; %.20g failed.\n",(double) test,
1780     (double) (test-(*fail)),(double) *fail);
1781   return(test);
1782 }
1783 \f
1784 /*
1785 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1786 %                                                                             %
1787 %                                                                             %
1788 %                                                                             %
1789 %   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                       %
1790 %                                                                             %
1791 %                                                                             %
1792 %                                                                             %
1793 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1794 %
1795 %  ValidateImageFormatsOnDisk() validates the ImageMagick image formats on disk
1796 %  and returns the number of validation tests that passed and failed.
1797 %
1798 %  The format of the ValidateImageFormatsOnDisk method is:
1799 %
1800 %      size_t ValidateImageFormatsOnDisk(ImageInfo *image_info,
1801 %        const char *reference_filename,const char *output_filename,
1802 %        size_t *fail,ExceptionInfo *exception)
1803 %
1804 %  A description of each parameter follows:
1805 %
1806 %    o image_info: the image info.
1807 %
1808 %    o reference_filename: the reference image filename.
1809 %
1810 %    o output_filename: the output image filename.
1811 %
1812 %    o fail: return the number of validation tests that pass.
1813 %
1814 %    o exception: return any errors or warnings in this structure.
1815 %
1816 */
1817 static size_t ValidateImageFormatsOnDisk(ImageInfo *image_info,
1818   const char *reference_filename,const char *output_filename,size_t *fail,
1819   ExceptionInfo *exception)
1820 {
1821   char
1822     size[MagickPathExtent];
1823
1824   const MagickInfo
1825     *magick_info;
1826
1827   double
1828     distortion,
1829     fuzz;
1830
1831   Image
1832     *difference_image,
1833     *reference_image,
1834     *reconstruct_image;
1835
1836   MagickBooleanType
1837     status;
1838
1839   register ssize_t
1840     i,
1841     j;
1842
1843   size_t
1844     test;
1845
1846   test=0;
1847   (void) FormatLocaleFile(stdout,"validate image formats on disk:\n");
1848   for (i=0; reference_formats[i].magick != (char *) NULL; i++)
1849   {
1850     magick_info=GetMagickInfo(reference_formats[i].magick,exception);
1851     if ((magick_info == (const MagickInfo *) NULL) ||
1852         (magick_info->decoder == (DecodeImageHandler *) NULL) ||
1853         (magick_info->encoder == (EncodeImageHandler *) NULL))
1854       continue;
1855     for (j=0; reference_types[j].type != UndefinedType; j++)
1856     {
1857       /*
1858         Generate reference image.
1859       */
1860       CatchException(exception);
1861       (void) FormatLocaleFile(stdout,"  test %.20g: %s/%s/%s/%.20g-bits",
1862         (double) (test++),reference_formats[i].magick,CommandOptionToMnemonic(
1863         MagickCompressOptions,reference_formats[i].compression),
1864         CommandOptionToMnemonic(MagickTypeOptions,reference_types[j].type),
1865         (double) reference_types[j].depth);
1866       (void) CopyMagickString(image_info->filename,reference_filename,
1867         MagickPathExtent);
1868       reference_image=ReadImage(image_info,exception);
1869       if ((reference_image == (Image *) NULL) ||
1870           (exception->severity >= ErrorException))
1871         {
1872           (void) FormatLocaleFile(stdout,"... fail @ %s/%s/%lu.\n",
1873             GetMagickModule());
1874           if (exception->reason != (char *) NULL)
1875             (void) FormatLocaleFile(stdout,"    reason:%s\n",exception->reason);
1876           CatchException(exception);
1877           (*fail)++;
1878           continue;
1879         }
1880       /*
1881         Write reference image.
1882       */
1883       (void) FormatLocaleString(size,MagickPathExtent,"%.20gx%.20g",
1884         (double) reference_image->columns,(double) reference_image->rows);
1885       (void) CloneString(&image_info->size,size);
1886       image_info->depth=reference_types[j].depth;
1887       (void) FormatLocaleString(reference_image->filename,MagickPathExtent,
1888         "%s:%s",reference_formats[i].magick,output_filename);
1889       status=SetImageType(reference_image,reference_types[j].type,exception);
1890       if (status == MagickFalse || (exception->severity >= ErrorException))
1891         {
1892           (void) FormatLocaleFile(stdout,"... fail @ %s/%s/%lu.\n",
1893             GetMagickModule());
1894           if (exception->reason != (char *) NULL)
1895             (void) FormatLocaleFile(stdout,"    reason:%s\n",exception->reason);
1896           CatchException(exception);
1897           (*fail)++;
1898           reference_image=DestroyImage(reference_image);
1899           continue;
1900         }
1901       status=SetImageDepth(reference_image,reference_types[j].depth,exception);
1902       if (status == MagickFalse || (exception->severity >= ErrorException))
1903         {
1904           (void) FormatLocaleFile(stdout,"... fail @ %s/%s/%lu.\n",
1905             GetMagickModule());
1906           CatchException(exception);
1907           (*fail)++;
1908           reference_image=DestroyImage(reference_image);
1909           continue;
1910         }
1911       reference_image->compression=reference_formats[i].compression;
1912       status=WriteImage(image_info,reference_image,exception);
1913       reference_image=DestroyImage(reference_image);
1914       if (status == MagickFalse || (exception->severity >= ErrorException))
1915         {
1916           (void) FormatLocaleFile(stdout,"... fail @ %s/%s/%lu.\n",
1917             GetMagickModule());
1918           if (exception->reason != (char *) NULL)
1919             (void) FormatLocaleFile(stdout,"    reason:%s\n",exception->reason);
1920           CatchException(exception);
1921           (*fail)++;
1922           continue;
1923         }
1924       /*
1925         Read reference image.
1926       */
1927       (void) FormatLocaleString(image_info->filename,MagickPathExtent,"%s:%s",
1928         reference_formats[i].magick,output_filename);
1929       reference_image=ReadImage(image_info,exception);
1930       if ((reference_image == (Image *) NULL) ||
1931           (exception->severity >= ErrorException))
1932         {
1933           (void) FormatLocaleFile(stdout,"... fail @ %s/%s/%lu.\n",
1934             GetMagickModule());
1935           CatchException(exception);
1936           (*fail)++;
1937           continue;
1938         }
1939       /*
1940         Write reference image.
1941       */
1942       (void) FormatLocaleString(reference_image->filename,MagickPathExtent,
1943         "%s:%s",reference_formats[i].magick,output_filename);
1944       reference_image->depth=reference_types[j].depth;
1945       reference_image->compression=reference_formats[i].compression;
1946       status=WriteImage(image_info,reference_image,exception);
1947       if (status == MagickFalse ||exception->severity >= ErrorException)
1948         {
1949           (void) FormatLocaleFile(stdout,"... fail @ %s/%s/%lu.\n",
1950             GetMagickModule());
1951           CatchException(exception);
1952           (*fail)++;
1953           reference_image=DestroyImage(reference_image);
1954           continue;
1955         }
1956       /*
1957         Read reconstruct image.
1958       */
1959       (void) FormatLocaleString(image_info->filename,MagickPathExtent,"%s:%s",
1960         reference_formats[i].magick,output_filename);
1961       reconstruct_image=ReadImage(image_info,exception);
1962       if (reconstruct_image == (Image *) NULL ||
1963           (exception->severity >= ErrorException))
1964         {
1965           (void) FormatLocaleFile(stdout,"... fail @ %s/%s/%lu.\n",
1966             GetMagickModule());
1967           CatchException(exception);
1968           (*fail)++;
1969           reference_image=DestroyImage(reference_image);
1970           continue;
1971         }
1972       /*
1973         Compare reference to reconstruct image.
1974       */
1975       fuzz=0.003;  /* grayscale */
1976       if (reference_formats[i].fuzz != 0.0)
1977         fuzz=reference_formats[i].fuzz;
1978       difference_image=CompareImages(reference_image,reconstruct_image,
1979         RootMeanSquaredErrorMetric,&distortion,exception);
1980       reconstruct_image=DestroyImage(reconstruct_image);
1981       reference_image=DestroyImage(reference_image);
1982       if (difference_image == (Image *) NULL ||
1983           (exception->severity >= ErrorException))
1984         {
1985           (void) FormatLocaleFile(stdout,"... fail @ %s/%s/%lu.\n",
1986             GetMagickModule());
1987           CatchException(exception);
1988           (*fail)++;
1989           continue;
1990         }
1991       difference_image=DestroyImage(difference_image);
1992       if ((QuantumScale*distortion) > fuzz)
1993         {
1994           (void) FormatLocaleFile(stdout,"... fail (with distortion %g).\n",
1995             QuantumScale*distortion);
1996           (*fail)++;
1997           continue;
1998         }
1999       (void) FormatLocaleFile(stdout,"... pass.\n");
2000     }
2001   }
2002   (void) FormatLocaleFile(stdout,
2003     "  summary: %.20g subtests; %.20g passed; %.20g failed.\n",(double) test,
2004     (double) (test-(*fail)),(double) *fail);
2005   return(test);
2006 }
2007 \f
2008 /*
2009 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2010 %                                                                             %
2011 %                                                                             %
2012 %                                                                             %
2013 %   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                       %
2014 %                                                                             %
2015 %                                                                             %
2016 %                                                                             %
2017 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2018 %
2019 %  ValidateImportExportPixels() validates the pixel import and export methods.
2020 %  It returns the number of validation tests that passed and failed.
2021 %
2022 %  The format of the ValidateImportExportPixels method is:
2023 %
2024 %      size_t ValidateImportExportPixels(ImageInfo *image_info,
2025 %        const char *reference_filename,const char *output_filename,
2026 %        size_t *fail,ExceptionInfo *exception)
2027 %
2028 %  A description of each parameter follows:
2029 %
2030 %    o image_info: the image info.
2031 %
2032 %    o reference_filename: the reference image filename.
2033 %
2034 %    o output_filename: the output image filename.
2035 %
2036 %    o fail: return the number of validation tests that pass.
2037 %
2038 %    o exception: return any errors or warnings in this structure.
2039 %
2040 */
2041 static size_t ValidateImportExportPixels(ImageInfo *image_info,
2042   const char *reference_filename,const char *output_filename,size_t *fail,
2043   ExceptionInfo *exception)
2044 {
2045   double
2046     distortion;
2047
2048   Image
2049     *difference_image,
2050     *reference_image,
2051     *reconstruct_image;
2052
2053   MagickBooleanType
2054     status;
2055
2056   register ssize_t
2057     i,
2058     j;
2059
2060   size_t
2061     length;
2062
2063   unsigned char
2064     *pixels;
2065
2066   size_t
2067     test;
2068
2069   (void) output_filename;
2070   test=0;
2071   (void) FormatLocaleFile(stdout,
2072     "validate the import and export of image pixels:\n");
2073   for (i=0; reference_map[i] != (char *) NULL; i++)
2074   {
2075     for (j=0; reference_storage[j].type != UndefinedPixel; j++)
2076     {
2077       /*
2078         Generate reference image.
2079       */
2080       CatchException(exception);
2081       (void) FormatLocaleFile(stdout,"  test %.20g: %s/%s",(double) (test++),
2082         reference_map[i],CommandOptionToMnemonic(MagickStorageOptions,
2083         reference_storage[j].type));
2084       (void) CopyMagickString(image_info->filename,reference_filename,
2085         MagickPathExtent);
2086       reference_image=ReadImage(image_info,exception);
2087       if ((reference_image == (Image *) NULL) ||
2088           (exception->severity >= ErrorException))
2089         {
2090           (void) FormatLocaleFile(stdout,"... fail @ %s/%s/%lu.\n",
2091             GetMagickModule());
2092           CatchException(exception);
2093           (*fail)++;
2094           continue;
2095         }
2096       if (LocaleNCompare(reference_map[i],"cmy",3) == 0)
2097         (void) SetImageColorspace(reference_image,CMYKColorspace,exception);
2098       length=strlen(reference_map[i])*reference_image->columns*
2099         reference_image->rows*reference_storage[j].quantum;
2100       pixels=(unsigned char *) AcquireQuantumMemory(length,sizeof(*pixels));
2101       if (pixels == (unsigned char *) NULL ||
2102           (exception->severity >= ErrorException))
2103         {
2104           (void) FormatLocaleFile(stdout,"... fail @ %s/%s/%lu.\n",
2105             GetMagickModule());
2106           CatchException(exception);
2107           (*fail)++;
2108           reference_image=DestroyImage(reference_image);
2109           continue;
2110         }
2111       (void) memset(pixels,0,length*sizeof(*pixels));
2112       status=ExportImagePixels(reference_image,0,0,reference_image->columns,
2113         reference_image->rows,reference_map[i],reference_storage[j].type,pixels,
2114         exception);
2115       if (status == MagickFalse || (exception->severity >= ErrorException))
2116         {
2117           (void) FormatLocaleFile(stdout,"... fail @ %s/%s/%lu.\n",
2118             GetMagickModule());
2119           CatchException(exception);
2120           (*fail)++;
2121           pixels=(unsigned char *) RelinquishMagickMemory(pixels);
2122           reference_image=DestroyImage(reference_image);
2123           continue;
2124         }
2125       (void) SetImageBackgroundColor(reference_image,exception);
2126       status=ImportImagePixels(reference_image,0,0,reference_image->columns,
2127         reference_image->rows,reference_map[i],reference_storage[j].type,
2128         pixels,exception);
2129       if (status == MagickFalse || (exception->severity >= ErrorException))
2130         {
2131           (void) FormatLocaleFile(stdout,"... fail @ %s/%s/%lu.\n",
2132             GetMagickModule());
2133           CatchException(exception);
2134           (*fail)++;
2135            pixels=(unsigned char *) RelinquishMagickMemory(pixels);
2136           reference_image=DestroyImage(reference_image);
2137           continue;
2138         }
2139       /*
2140         Read reconstruct image.
2141       */
2142       reconstruct_image=AcquireImage(image_info,exception);
2143       (void) SetImageExtent(reconstruct_image,reference_image->columns,
2144         reference_image->rows,exception);
2145       (void) SetImageColorspace(reconstruct_image,reference_image->colorspace,
2146         exception);
2147       (void) SetImageBackgroundColor(reconstruct_image,exception);
2148       status=ImportImagePixels(reconstruct_image,0,0,reconstruct_image->columns,
2149         reconstruct_image->rows,reference_map[i],reference_storage[j].type,
2150         pixels,exception);
2151       pixels=(unsigned char *) RelinquishMagickMemory(pixels);
2152       if (status == MagickFalse || (exception->severity >= ErrorException))
2153         {
2154           (void) FormatLocaleFile(stdout,"... fail @ %s/%s/%lu.\n",
2155             GetMagickModule());
2156           CatchException(exception);
2157           (*fail)++;
2158           reference_image=DestroyImage(reference_image);
2159           continue;
2160         }
2161       /*
2162         Compare reference to reconstruct image.
2163       */
2164       difference_image=CompareImages(reference_image,reconstruct_image,
2165         RootMeanSquaredErrorMetric,&distortion,exception);
2166       reconstruct_image=DestroyImage(reconstruct_image);
2167       reference_image=DestroyImage(reference_image);
2168       if (difference_image == (Image *) NULL ||
2169           (exception->severity >= ErrorException))
2170         {
2171           (void) FormatLocaleFile(stdout,"... fail @ %s/%s/%lu.\n",
2172             GetMagickModule());
2173           CatchException(exception);
2174           (*fail)++;
2175           continue;
2176         }
2177       difference_image=DestroyImage(difference_image);
2178       if ((QuantumScale*distortion) > 0.0)
2179         {
2180           (void) FormatLocaleFile(stdout,"... fail (with distortion %g).\n",
2181             QuantumScale*distortion);
2182           (*fail)++;
2183           continue;
2184         }
2185       (void) FormatLocaleFile(stdout,"... pass.\n");
2186     }
2187   }
2188   (void) FormatLocaleFile(stdout,
2189     "  summary: %.20g subtests; %.20g passed; %.20g failed.\n",(double) test,
2190     (double) (test-(*fail)),(double) *fail);
2191   return(test);
2192 }
2193 \f
2194 /*
2195 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2196 %                                                                             %
2197 %                                                                             %
2198 %                                                                             %
2199 %   V a l i d a t e M o n t a g e C o m m a n d                               %
2200 %                                                                             %
2201 %                                                                             %
2202 %                                                                             %
2203 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2204 %
2205 %  ValidateMontageCommand() validates the ImageMagick montage command line
2206 %  program and returns the number of validation tests that passed and failed.
2207 %
2208 %  The format of the ValidateMontageCommand method is:
2209 %
2210 %      size_t ValidateMontageCommand(ImageInfo *image_info,
2211 %        const char *reference_filename,const char *output_filename,
2212 %        size_t *fail,ExceptionInfo *exception)
2213 %
2214 %  A description of each parameter follows:
2215 %
2216 %    o image_info: the image info.
2217 %
2218 %    o reference_filename: the reference image filename.
2219 %
2220 %    o output_filename: the output image filename.
2221 %
2222 %    o fail: return the number of validation tests that pass.
2223 %
2224 %    o exception: return any errors or warnings in this structure.
2225 %
2226 */
2227 static size_t ValidateMontageCommand(ImageInfo *image_info,
2228   const char *reference_filename,const char *output_filename,size_t *fail,
2229   ExceptionInfo *exception)
2230 {
2231   char
2232     **arguments,
2233     command[MagickPathExtent];
2234
2235   int
2236     number_arguments;
2237
2238   MagickBooleanType
2239     status;
2240
2241   register ssize_t
2242     i,
2243     j;
2244
2245   size_t
2246     test;
2247
2248   test=0;
2249   (void) FormatLocaleFile(stdout,"validate montage command line program:\n");
2250   for (i=0; montage_options[i] != (char *) NULL; i++)
2251   {
2252     CatchException(exception);
2253     (void) FormatLocaleFile(stdout,"  test %.20g: %s",(double) (test++),
2254       montage_options[i]);
2255     (void) FormatLocaleString(command,MagickPathExtent,"%s %s %s %s",
2256       reference_filename,montage_options[i],reference_filename,
2257       output_filename);
2258     arguments=StringToArgv(command,&number_arguments);
2259     if (arguments == (char **) NULL)
2260       {
2261         (void) FormatLocaleFile(stdout,"... fail @ %s/%s/%lu.\n",
2262             GetMagickModule());
2263         (*fail)++;
2264         continue;
2265       }
2266     status=MontageImageCommand(image_info,number_arguments,arguments,
2267       (char **) NULL,exception);
2268     for (j=0; j < (ssize_t) number_arguments; j++)
2269       arguments[j]=DestroyString(arguments[j]);
2270     arguments=(char **) RelinquishMagickMemory(arguments);
2271     if (status == MagickFalse)
2272       {
2273         (void) FormatLocaleFile(stdout,"... fail @ %s/%s/%lu.\n",
2274             GetMagickModule());
2275         (*fail)++;
2276         continue;
2277       }
2278     (void) FormatLocaleFile(stdout,"... pass.\n");
2279   }
2280   (void) FormatLocaleFile(stdout,
2281     "  summary: %.20g subtests; %.20g passed; %.20g failed.\n",(double) test,
2282     (double) (test-(*fail)),(double) *fail);
2283   return(test);
2284 }
2285 \f
2286 /*
2287 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2288 %                                                                             %
2289 %                                                                             %
2290 %                                                                             %
2291 %   V a l i d a t e S t r e a m C o m m a n d                                 %
2292 %                                                                             %
2293 %                                                                             %
2294 %                                                                             %
2295 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2296 %
2297 %  ValidateStreamCommand() validates the ImageMagick stream command line
2298 %  program and returns the number of validation tests that passed and failed.
2299 %
2300 %  The format of the ValidateStreamCommand method is:
2301 %
2302 %      size_t ValidateStreamCommand(ImageInfo *image_info,
2303 %        const char *reference_filename,const char *output_filename,
2304 %        size_t *fail,ExceptionInfo *exception)
2305 %
2306 %  A description of each parameter follows:
2307 %
2308 %    o image_info: the image info.
2309 %
2310 %    o reference_filename: the reference image filename.
2311 %
2312 %    o output_filename: the output image filename.
2313 %
2314 %    o fail: return the number of validation tests that pass.
2315 %
2316 %    o exception: return any errors or warnings in this structure.
2317 %
2318 */
2319 static size_t ValidateStreamCommand(ImageInfo *image_info,
2320   const char *reference_filename,const char *output_filename,size_t *fail,
2321   ExceptionInfo *exception)
2322 {
2323   char
2324     **arguments,
2325     command[MagickPathExtent];
2326
2327   int
2328     number_arguments;
2329
2330   MagickBooleanType
2331     status;
2332
2333   register ssize_t
2334     i,
2335     j;
2336
2337   size_t
2338     test;
2339
2340   test=0;
2341   (void) FormatLocaleFile(stdout,"validate stream command line program:\n");
2342   for (i=0; stream_options[i] != (char *) NULL; i++)
2343   {
2344     CatchException(exception);
2345     (void) FormatLocaleFile(stdout,"  test %.20g: %s",(double) (test++),
2346       stream_options[i]);
2347     (void) FormatLocaleString(command,MagickPathExtent,"%s %s %s",
2348       stream_options[i],reference_filename,output_filename);
2349     arguments=StringToArgv(command,&number_arguments);
2350     if (arguments == (char **) NULL)
2351       {
2352         (void) FormatLocaleFile(stdout,"... fail @ %s/%s/%lu.\n",
2353             GetMagickModule());
2354         (*fail)++;
2355         continue;
2356       }
2357     status=StreamImageCommand(image_info,number_arguments,arguments,
2358       (char **) NULL,exception);
2359     for (j=0; j < (ssize_t) number_arguments; j++)
2360       arguments[j]=DestroyString(arguments[j]);
2361     arguments=(char **) RelinquishMagickMemory(arguments);
2362     if (status == MagickFalse)
2363       {
2364         (void) FormatLocaleFile(stdout,"... fail @ %s/%s/%lu.\n",
2365             GetMagickModule());
2366         (*fail)++;
2367         continue;
2368       }
2369     (void) FormatLocaleFile(stdout,"... pass.\n");
2370   }
2371   (void) FormatLocaleFile(stdout,
2372     "  summary: %.20g subtests; %.20g passed; %.20g failed.\n",(double) test,
2373     (double) (test-(*fail)),(double) *fail);
2374   return(test);
2375 }
2376 \f
2377 /*
2378 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2379 %                                                                             %
2380 %                                                                             %
2381 %                                                                             %
2382 %  M a i n                                                                    %
2383 %                                                                             %
2384 %                                                                             %
2385 %                                                                             %
2386 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2387 %
2388 %
2389 */
2390
2391 static MagickBooleanType ValidateUsage(void)
2392 {
2393   const char
2394     **p;
2395
2396   static const char
2397     *miscellaneous[]=
2398     {
2399       "-debug events        display copious debugging information",
2400       "-help                print program options",
2401       "-log format          format of debugging information",
2402       "-validate type       validation type",
2403       "-version             print version information",
2404       (char *) NULL
2405     },
2406     *settings[]=
2407     {
2408       "-regard-warnings     pay attention to warning messages",
2409       "-verbose             print detailed information about the image",
2410       (char *) NULL
2411     };
2412
2413   (void) printf("Version: %s\n",GetMagickVersion((size_t *) NULL));
2414   (void) printf("Copyright: %s\n\n",GetMagickCopyright());
2415   (void) printf("Features: %s\n",GetMagickFeatures());
2416   (void) printf("Usage: %s [options ...] reference-file\n",GetClientName());
2417   (void) printf("\nValidate Settings:\n");
2418   for (p=settings; *p != (char *) NULL; p++)
2419     (void) printf("  %s\n",*p);
2420   (void) printf("\nMiscellaneous Options:\n");
2421   for (p=miscellaneous; *p != (char *) NULL; p++)
2422     (void) printf("  %s\n",*p);
2423   return(MagickTrue);
2424 }
2425
2426 int main(int argc,char **argv)
2427 {
2428 #define DestroyValidate() \
2429 { \
2430   image_info=DestroyImageInfo(image_info); \
2431   exception=DestroyExceptionInfo(exception); \
2432 }
2433 #define ThrowValidateException(asperity,tag,option) \
2434 { \
2435   (void) ThrowMagickException(exception,GetMagickModule(),asperity,tag,"`%s'", \
2436     option); \
2437   CatchException(exception); \
2438   DestroyValidate(); \
2439   return(MagickFalse); \
2440 }
2441
2442   char
2443     output_filename[MagickPathExtent],
2444     reference_filename[MagickPathExtent],
2445     *option;
2446
2447   double
2448     elapsed_time,
2449     user_time;
2450
2451   ExceptionInfo
2452     *exception;
2453
2454   Image
2455     *reference_image;
2456
2457   ImageInfo
2458     *image_info;
2459
2460   MagickBooleanType
2461     regard_warnings,
2462     status;
2463
2464   MagickSizeType
2465     memory_resource,
2466     map_resource;
2467
2468   register ssize_t
2469     i;
2470
2471   TimerInfo
2472     *timer;
2473
2474   size_t
2475     fail,
2476     iterations,
2477     tests;
2478
2479   ValidateType
2480     type;
2481
2482   /*
2483     Validate the ImageMagick image processing suite.
2484   */
2485   MagickCoreGenesis(*argv,MagickTrue);
2486   (void) setlocale(LC_ALL,"");
2487   (void) setlocale(LC_NUMERIC,"C");
2488   iterations=1;
2489   status=MagickFalse;
2490   type=AllValidate;
2491   regard_warnings=MagickFalse;
2492   (void) regard_warnings;
2493   exception=AcquireExceptionInfo();
2494   image_info=AcquireImageInfo();
2495   (void) CopyMagickString(image_info->filename,ReferenceFilename,
2496     MagickPathExtent);
2497   for (i=1; i < (ssize_t) argc; i++)
2498   {
2499     option=argv[i];
2500     if (IsCommandOption(option) == MagickFalse)
2501       {
2502         (void) CopyMagickString(image_info->filename,option,MagickPathExtent);
2503         continue;
2504       }
2505     switch (*(option+1))
2506     {
2507       case 'b':
2508       {
2509         if (LocaleCompare("bench",option+1) == 0)
2510           {
2511             iterations=StringToUnsignedLong(argv[++i]);
2512             break;
2513           }
2514         ThrowValidateException(OptionError,"UnrecognizedOption",option)
2515       }
2516       case 'd':
2517       {
2518         if (LocaleCompare("debug",option+1) == 0)
2519           {
2520             (void) SetLogEventMask(argv[++i]);
2521             break;
2522           }
2523         ThrowValidateException(OptionError,"UnrecognizedOption",option)
2524       }
2525       case 'h':
2526       {
2527         if (LocaleCompare("help",option+1) == 0)
2528           {
2529             (void) ValidateUsage();
2530             return(0);
2531           }
2532         ThrowValidateException(OptionError,"UnrecognizedOption",option)
2533       }
2534       case 'l':
2535       {
2536         if (LocaleCompare("log",option+1) == 0)
2537           {
2538             if (*option != '+')
2539               (void) SetLogFormat(argv[i+1]);
2540             break;
2541           }
2542         ThrowValidateException(OptionError,"UnrecognizedOption",option)
2543       }
2544       case 'r':
2545       {
2546         if (LocaleCompare("regard-warnings",option+1) == 0)
2547           {
2548             regard_warnings=MagickTrue;
2549             break;
2550           }
2551         ThrowValidateException(OptionError,"UnrecognizedOption",option)
2552       }
2553       case 'v':
2554       {
2555         if (LocaleCompare("validate",option+1) == 0)
2556           {
2557             ssize_t
2558               validate;
2559
2560             if (*option == '+')
2561               break;
2562             i++;
2563             if (i >= (ssize_t) argc)
2564               ThrowValidateException(OptionError,"MissingArgument",option);
2565             validate=ParseCommandOption(MagickValidateOptions,MagickFalse,
2566               argv[i]);
2567             if (validate < 0)
2568               ThrowValidateException(OptionError,"UnrecognizedValidateType",
2569                 argv[i]);
2570             type=(ValidateType) validate;
2571             break;
2572           }
2573         if ((LocaleCompare("version",option+1) == 0) ||
2574             (LocaleCompare("-version",option+1) == 0))
2575           {
2576             (void) FormatLocaleFile(stdout,"Version: %s\n",
2577               GetMagickVersion((size_t *) NULL));
2578             (void) FormatLocaleFile(stdout,"Copyright: %s\n\n",
2579               GetMagickCopyright());
2580             (void) FormatLocaleFile(stdout,"Features: %s\n\n",
2581               GetMagickFeatures());
2582             return(0);
2583           }
2584         ThrowValidateException(OptionError,"UnrecognizedOption",option)
2585       }
2586       default:
2587         ThrowValidateException(OptionError,"UnrecognizedOption",option)
2588     }
2589   }
2590   timer=(TimerInfo *) NULL;
2591   if (iterations > 1)
2592     timer=AcquireTimerInfo();
2593   reference_image=ReadImage(image_info,exception);
2594   tests=0;
2595   fail=0;
2596   if (reference_image == (Image *) NULL)
2597     fail++;
2598   else
2599     {
2600       if (LocaleCompare(image_info->filename,ReferenceFilename) == 0)
2601         (void) CopyMagickString(reference_image->magick,ReferenceImageFormat,
2602           MagickPathExtent);
2603       (void) AcquireUniqueFilename(reference_filename);
2604       (void) AcquireUniqueFilename(output_filename);
2605       (void) CopyMagickString(reference_image->filename,reference_filename,
2606         MagickPathExtent);
2607       status=WriteImage(image_info,reference_image,exception);
2608       reference_image=DestroyImage(reference_image);
2609       if (status == MagickFalse)
2610         fail++;
2611       else
2612         {
2613           (void) FormatLocaleFile(stdout,"Version: %s\n",
2614             GetMagickVersion((size_t *) NULL));
2615           (void) FormatLocaleFile(stdout,"Copyright: %s\n\n",
2616             GetMagickCopyright());
2617           (void) FormatLocaleFile(stdout,
2618             "ImageMagick Validation Suite (%s)\n\n",CommandOptionToMnemonic(
2619             MagickValidateOptions,(ssize_t) type));
2620           if ((type & ColorspaceValidate) != 0)
2621             tests+=ValidateColorspaces(image_info,&fail,exception);
2622           if ((type & CompareValidate) != 0)
2623             tests+=ValidateCompareCommand(image_info,reference_filename,
2624               output_filename,&fail,exception);
2625           if ((type & CompositeValidate) != 0)
2626             tests+=ValidateCompositeCommand(image_info,reference_filename,
2627               output_filename,&fail,exception);
2628           if ((type & ConvertValidate) != 0)
2629             tests+=ValidateConvertCommand(image_info,reference_filename,
2630               output_filename,&fail,exception);
2631           if ((type & FormatsDiskValidate) != 0)
2632             {
2633               memory_resource=SetMagickResourceLimit(MemoryResource,0);
2634               map_resource=SetMagickResourceLimit(MapResource,0);
2635               (void) FormatLocaleFile(stdout,"[pixel-cache: disk] ");
2636               tests+=ValidateImageFormatsInMemory(image_info,reference_filename,
2637                 output_filename,&fail,exception);
2638               (void) FormatLocaleFile(stdout,"[pixel-cache: disk] ");
2639               tests+=ValidateImageFormatsOnDisk(image_info,reference_filename,
2640                 output_filename,&fail,exception);
2641               (void) SetMagickResourceLimit(MemoryResource,memory_resource);
2642               (void) SetMagickResourceLimit(MapResource,map_resource);
2643             }
2644           if ((type & FormatsMapValidate) != 0)
2645             {
2646               memory_resource=SetMagickResourceLimit(MemoryResource,0);
2647               (void) FormatLocaleFile(stdout,"[pixel-cache: memory-mapped] ");
2648               tests+=ValidateImageFormatsInMemory(image_info,reference_filename,
2649                 output_filename,&fail,exception);
2650               (void) FormatLocaleFile(stdout,"[pixel-cache: memory-mapped] ");
2651               tests+=ValidateImageFormatsOnDisk(image_info,reference_filename,
2652                 output_filename,&fail,exception);
2653               (void) SetMagickResourceLimit(MemoryResource,memory_resource);
2654             }
2655           if ((type & FormatsMemoryValidate) != 0)
2656             {
2657               (void) FormatLocaleFile(stdout,"[pixel-cache: memory] ");
2658               tests+=ValidateImageFormatsInMemory(image_info,reference_filename,
2659                 output_filename,&fail,exception);
2660               (void) FormatLocaleFile(stdout,"[pixel-cache: memory] ");
2661               tests+=ValidateImageFormatsOnDisk(image_info,reference_filename,
2662                 output_filename,&fail,exception);
2663             }
2664           if ((type & IdentifyValidate) != 0)
2665             tests+=ValidateIdentifyCommand(image_info,reference_filename,
2666               output_filename,&fail,exception);
2667           if ((type & ImportExportValidate) != 0)
2668             tests+=ValidateImportExportPixels(image_info,reference_filename,
2669               output_filename,&fail,exception);
2670           if ((type & MontageValidate) != 0)
2671             tests+=ValidateMontageCommand(image_info,reference_filename,
2672               output_filename,&fail,exception);
2673           if ((type & StreamValidate) != 0)
2674             tests+=ValidateStreamCommand(image_info,reference_filename,
2675               output_filename,&fail,exception);
2676           (void) FormatLocaleFile(stdout,
2677             "validation suite: %.20g tests; %.20g passed; %.20g failed.\n",
2678             (double) tests,(double) (tests-fail),(double) fail);
2679         }
2680       (void) RelinquishUniqueFileResource(output_filename);
2681       (void) RelinquishUniqueFileResource(reference_filename);
2682     }
2683   if (exception->severity != UndefinedException)
2684     CatchException(exception);
2685   if (iterations > 1)
2686     {
2687       elapsed_time=GetElapsedTime(timer);
2688       user_time=GetUserTime(timer);
2689       (void) FormatLocaleFile(stderr,
2690         "Performance: %.20gi %gips %0.3fu %ld:%02ld.%03ld\n",(double)
2691         iterations,1.0*iterations/elapsed_time,user_time,(long)
2692         (elapsed_time/60.0),(long) ceil(fmod(elapsed_time,60.0)),
2693         (long) (1000.0*(elapsed_time-floor(elapsed_time))));
2694       timer=DestroyTimerInfo(timer);
2695     }
2696   DestroyValidate();
2697   MagickCoreTerminus();
2698   return(fail == 0 ? 0 : 1);
2699 }