granicus.if.org Git - imagemagick/blob - coders/json.c

   1 /*
   2 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
   3 %                                                                             %
   4 %                                                                             %
   5 %                                                                             %
   6 %                        JJJJJ  SSSSS   OOO   N   N                           %
   7 %                          J    SS     O   O  NN  N                           %
   8 %                          J     SSS   O   O  N N N                           %
   9 %                        J J       SS  O   O  N  NN                           %
  10 %                        JJJ    SSSSS   OOO   N   N                           %
  11 %                                                                             %
  12 %                                                                             %
  13 %                  Write Info About the Image in JSON Format.                 %
  14 %                                                                             %
  15 %                              Software Design                                %
  16 %                                   Cristy                                    %
  17 %                                January 2014                                 %
  18 %                                                                             %
  19 %                                                                             %
  20 %  Copyright 1999-2018 ImageMagick Studio LLC, a non-profit organization      %
  21 %  dedicated to making software imaging solutions freely available.           %
  22 %                                                                             %
  23 %  You may not use this file except in compliance with the License.  You may  %
  24 %  obtain a copy of the License at                                            %
  25 %                                                                             %
  26 %    https://www.imagemagick.org/script/license.php                           %
  27 %                                                                             %
  28 %  Unless required by applicable law or agreed to in writing, software        %
  29 %  distributed under the License is distributed on an "AS IS" BASIS,          %
  30 %  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.   %
  31 %  See the License for the specific language governing permissions and        %
  32 %  limitations under the License.                                             %
  33 %                                                                             %
  34 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  35 %
  36 %
  37 */
  38 \f
  39 /*
  40   Include declarations.
  41 */
  42 #include "MagickCore/studio.h"
  43 #include "MagickCore/artifact.h"
  44 #include "MagickCore/attribute.h"
  45 #include "MagickCore/blob.h"
  46 #include "MagickCore/blob-private.h"
  47 #include "MagickCore/cache.h"
  48 #include "MagickCore/colorspace.h"
  49 #include "MagickCore/colorspace-private.h"
  50 #include "MagickCore/constitute.h"
  51 #include "MagickCore/exception.h"
  52 #include "MagickCore/exception-private.h"
  53 #include "MagickCore/feature.h"
  54 #include "MagickCore/image.h"
  55 #include "MagickCore/image-private.h"
  56 #include "MagickCore/list.h"
  57 #include "MagickCore/magick.h"
  58 #include "MagickCore/memory_.h"
  59 #include "MagickCore/monitor.h"
  60 #include "MagickCore/monitor-private.h"
  61 #include "MagickCore/option.h"
  62 #include "MagickCore/pixel.h"
  63 #include "MagickCore/pixel-accessor.h"
  64 #include "MagickCore/pixel-private.h"
  65 #include "MagickCore/prepress.h"
  66 #include "MagickCore/property.h"
  67 #include "MagickCore/quantum-private.h"
  68 #include "MagickCore/registry.h"
  69 #include "MagickCore/signature.h"
  70 #include "MagickCore/static.h"
  71 #include "MagickCore/statistic.h"
  72 #include "MagickCore/string_.h"
  73 #include "MagickCore/string-private.h"
  74 #include "MagickCore/utility.h"
  75 #include "MagickCore/version.h"
  76 #include "MagickCore/module.h"
  77
  78 /*
  79   Typedef declarations.
  80 */
  81 typedef struct _IPTCInfo
  82 {
  83   long
  84     dataset,
  85     record;
  86
  87   size_t
  88     values_length;
  89
  90   char
  91     tag[32],
  92     ***values;
  93 } IPTCInfo;
  94 \f
  95 /*
  96   Forward declarations.
  97 */
  98 static MagickBooleanType
  99   WriteJSONImage(const ImageInfo *,Image *,ExceptionInfo *);
 100 \f
 101 /*
 102 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 103 %                                                                             %
 104 %                                                                             %
 105 %                                                                             %
 106 %   R e g i s t e r J S O N I m a g e                                         %
 107 %                                                                             %
 108 %                                                                             %
 109 %                                                                             %
 110 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 111 %
 112 %  RegisterJSONImage() adds attributes for the JSON image format to
 113 %  the list of supported formats.  The attributes include the image format
 114 %  tag, a method to read and/or write the format, whether the format
 115 %  supports the saving of more than one frame to the same file or blob,
 116 %  whether the format supports native in-memory I/O, and a brief
 117 %  description of the format.
 118 %
 119 %  The format of the RegisterJSONImage method is:
 120 %
 121 %      size_t RegisterJSONImage(void)
 122 %
 123 */
 124 ModuleExport size_t RegisterJSONImage(void)
 125 {
 126   MagickInfo
 127     *entry;
 128
 129   entry=AcquireMagickInfo("JSON","JSON","The image format and characteristics");
 130   entry->encoder=(EncodeImageHandler *) WriteJSONImage;
 131   entry->mime_type=ConstantString("application/json");
 132   entry->flags^=CoderBlobSupportFlag;
 133   (void) RegisterMagickInfo(entry);
 134   return(MagickImageCoderSignature);
 135 }
 136 \f
 137 /*
 138 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 139 %                                                                             %
 140 %                                                                             %
 141 %                                                                             %
 142 %   U n r e g i s t e r J S O N I m a g e                                     %
 143 %                                                                             %
 144 %                                                                             %
 145 %                                                                             %
 146 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 147 %
 148 %  UnregisterJSONImage() removes format registrations made by the
 149 %  JSON module from the list of supported formats.
 150 %
 151 %  The format of the UnregisterJSONImage method is:
 152 %
 153 %      UnregisterJSONImage(void)
 154 %
 155 */
 156 ModuleExport void UnregisterJSONImage(void)
 157 {
 158   (void) UnregisterMagickInfo("JSON");
 159 }
 160 \f
 161 /*
 162 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 163 %                                                                             %
 164 %                                                                             %
 165 %                                                                             %
 166 %   W r i t e J S O N I m a g e                                               %
 167 %                                                                             %
 168 %                                                                             %
 169 %                                                                             %
 170 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 171 %
 172 %  WriteJSONImage writes the image attributes in the JSON format.
 173 %
 174 %  The format of the WriteJSONImage method is:
 175 %
 176 %      MagickBooleanType WriteJSONImage(const ImageInfo *image_info,
 177 %        Image *image,ExceptionInfo *exception)
 178 %
 179 %  A description of each parameter follows.
 180 %
 181 %    o image_info: the image info.
 182 %
 183 %    o image:  The image.
 184 %
 185 %    o exception: return any errors or warnings in this structure.
 186 %
 187 */
 188
 189 static void JSONFormatLocaleFile(FILE *file,const char *format,
 190   const char *value)
 191 {
 192   char
 193     *escaped_json;
 194
 195   register char
 196     *q;
 197
 198   register const char
 199     *p;
 200
 201   size_t
 202     length;
 203
 204   assert(format != (const char *) NULL);
 205   if ((value == (char *) NULL) || (*value == '\0'))
 206     {
 207       (void) FormatLocaleFile(file,format,"null");
 208       return;
 209     }
 210   length=strlen(value)+2;
 211   /*
 212     Find all the chars that need escaping and increase the dest length counter.
 213   */
 214   for (p=value; *p != '\0'; p++)
 215   {
 216     switch (*p)
 217     {
 218       case '"':
 219       case '\b':
 220       case '\f':
 221       case '\n':
 222       case '\r':
 223       case '\t':
 224       case '\\':
 225       {
 226         if (~length < 1)
 227           return;
 228         length++;
 229         break;
 230       }
 231       default:
 232       {
 233         if (((int) *p >= 0x00) && ((int) *p <= 0x1f))
 234           length+=6;
 235         break;
 236       }
 237     }
 238   }
 239   escaped_json=(char *) NULL;
 240   if (~length >= (MagickPathExtent-1))
 241     escaped_json=(char *) AcquireQuantumMemory(length+MagickPathExtent,
 242       sizeof(*escaped_json));
 243   if (escaped_json == (char *) NULL)
 244     {
 245       (void) FormatLocaleFile(file,format,"null");
 246       return;
 247     }
 248   q=escaped_json;
 249   *q++='"';
 250   for (p=value; *p != '\0'; p++)
 251   {
 252     switch (*p)
 253     {
 254       case '"':
 255       {
 256         *q++='\\';
 257         *q++=(*p);
 258         break;
 259       }
 260       case '\b':
 261       {
 262         *q++='\\';
 263         *q++='b';
 264         break;
 265       }
 266       case '\f':
 267       {
 268         *q++='\\';
 269         *q++='f';
 270         break;
 271       }
 272       case '\n':
 273       {
 274         *q++='\\';
 275         *q++='n';
 276         break;
 277       }
 278       case '\r':
 279       {
 280         *q++='\\';
 281         *q++='r';
 282         break;
 283       }
 284       case '\t':
 285       {
 286         *q++='\\';
 287         *q++='t';
 288         break;
 289       }
 290       case '\\':
 291       {
 292         *q++='\\';
 293         *q++='\\';
 294         break;
 295       }
 296       default:
 297       {
 298         if (((int) *p >= 0x00) && ((int) *p <= 0x1f))
 299           {
 300             (void) FormatLocaleString(q,7,"\\u%04X",(int) *p);
 301             q+=6;
 302             break;
 303           }
 304         *q++=(*p);
 305         break;
 306       }
 307     }
 308   }
 309   *q++='"';
 310   *q='\0';
 311   (void) FormatLocaleFile(file,format,escaped_json);
 312   (void) DestroyString(escaped_json);
 313 }
 314
 315 static ChannelStatistics *GetLocationStatistics(const Image *image,
 316   const StatisticType type,ExceptionInfo *exception)
 317 {
 318   ChannelStatistics
 319     *channel_statistics;
 320
 321   register ssize_t
 322     i;
 323
 324   ssize_t
 325     y;
 326
 327   assert(image != (Image *) NULL);
 328   assert(image->signature == MagickCoreSignature);
 329   if (image->debug != MagickFalse)
 330     (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
 331   channel_statistics=(ChannelStatistics *) AcquireQuantumMemory(
 332     MaxPixelChannels+1,sizeof(*channel_statistics));
 333   if (channel_statistics == (ChannelStatistics *) NULL)
 334     ThrowFatalException(ResourceLimitFatalError,"MemoryAllocationFailed");
 335   (void) ResetMagickMemory(channel_statistics,0,(MaxPixelChannels+1)*
 336     sizeof(*channel_statistics));
 337   for (i=0; i <= (ssize_t) MaxPixelChannels; i++)
 338   {
 339     switch (type)
 340     {
 341       case MaximumStatistic:
 342       default:
 343       {
 344         channel_statistics[i].maxima=(-MagickMaximumValue);
 345         break;
 346       }
 347       case MinimumStatistic:
 348       {
 349         channel_statistics[i].minima=MagickMaximumValue;
 350         break;
 351       }
 352     }
 353   }
 354   for (y=0; y < (ssize_t) image->rows; y++)
 355   {
 356     register const Quantum
 357       *magick_restrict p;
 358
 359     register ssize_t
 360       x;
 361
 362     p=GetVirtualPixels(image,0,y,image->columns,1,exception);
 363     if (p == (const Quantum *) NULL)
 364       break;
 365     for (x=0; x < (ssize_t) image->columns; x++)
 366     {
 367       register ssize_t
 368         i;
 369
 370       if (GetPixelReadMask(image,p) <= (QuantumRange/2))
 371         {
 372           p+=GetPixelChannels(image);
 373           continue;
 374         }
 375       for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
 376       {
 377         PixelChannel channel = GetPixelChannelChannel(image,i);
 378         PixelTrait traits = GetPixelChannelTraits(image,channel);
 379         if (traits == UndefinedPixelTrait)
 380           continue;
 381         switch (type)
 382         {
 383           case MaximumStatistic:
 384           default:
 385           {
 386             if ((double) p[i] > channel_statistics[channel].maxima)
 387               channel_statistics[channel].maxima=(double) p[i];
 388             break;
 389           }
 390           case MinimumStatistic:
 391           {
 392             if ((double) p[i] < channel_statistics[channel].minima)
 393               channel_statistics[channel].minima=(double) p[i];
 394             break;
 395           }
 396         }
 397       }
 398       p+=GetPixelChannels(image);
 399     }
 400   }
 401   return(channel_statistics);
 402 }
 403
 404 static ssize_t PrintChannelFeatures(FILE *file,const PixelChannel channel,
 405   const char *name,const MagickBooleanType separator,
 406   const ChannelFeatures *channel_features)
 407 {
 408 #define PrintFeature(feature) \
 409   GetMagickPrecision(),(feature)[0], \
 410   GetMagickPrecision(),(feature)[1], \
 411   GetMagickPrecision(),(feature)[2], \
 412   GetMagickPrecision(),(feature)[3], \
 413   GetMagickPrecision(),((feature)[0]+(feature)[1]+(feature)[2]+(feature)[3])/4.0 \
 414
 415 #define FeaturesFormat "      \"%s\": {\n" \
 416   "        \"angularSecondMoment\": {\n" \
 417   "          \"horizontal\": %.*g,\n" \
 418   "          \"vertical\": %.*g,\n" \
 419   "          \"leftDiagonal\": %.*g,\n" \
 420   "          \"rightDiagonal\": %.*g,\n" \
 421   "          \"average\": %.*g\n" \
 422   "        },\n" \
 423   "        \"contrast\": {\n" \
 424   "          \"horizontal\": %.*g,\n" \
 425   "          \"vertical\": %.*g,\n" \
 426   "          \"leftDiagonal\": %.*g,\n" \
 427   "          \"rightDiagonal\": %.*g,\n" \
 428   "          \"average\": %.*g\n" \
 429   "        },\n" \
 430   "        \"correlation\": {\n" \
 431   "          \"horizontal\": %.*g,\n" \
 432   "          \"vertical\": %.*g,\n" \
 433   "          \"leftDiagonal\": %.*g,\n" \
 434   "          \"rightDiagonal\": %.*g,\n" \
 435   "          \"average\": %.*g\n" \
 436   "        },\n" \
 437   "        \"sumOfSquaresVariance\": {\n" \
 438   "          \"horizontal\": %.*g,\n" \
 439   "          \"vertical\": %.*g,\n" \
 440   "          \"leftDiagonal\": %.*g,\n" \
 441   "          \"rightDiagonal\": %.*g,\n" \
 442   "          \"average\": %.*g\n" \
 443   "        },\n" \
 444   "        \"inverseDifferenceMoment\": {\n" \
 445   "          \"horizontal\": %.*g,\n" \
 446   "          \"vertical\": %.*g,\n" \
 447   "          \"leftDiagonal\": %.*g,\n" \
 448   "          \"rightDiagonal\": %.*g,\n" \
 449   "          \"average\": %.*g\n" \
 450   "        },\n" \
 451   "        \"sumAverage\": {\n" \
 452   "          \"horizontal\": %.*g,\n" \
 453   "          \"vertical\": %.*g,\n" \
 454   "          \"leftDiagonal\": %.*g,\n" \
 455   "          \"rightDiagonal\": %.*g,\n" \
 456   "          \"average\": %.*g\n" \
 457   "        },\n" \
 458   "        \"sumVariance\": {\n" \
 459   "          \"horizontal\": %.*g,\n" \
 460   "          \"vertical\": %.*g,\n" \
 461   "          \"leftDiagonal\": %.*g,\n" \
 462   "          \"rightDiagonal\": %.*g,\n" \
 463   "          \"average\": %.*g\n" \
 464   "        },\n" \
 465   "        \"sumEntropy\": {\n" \
 466   "          \"horizontal\": %.*g,\n" \
 467   "          \"vertical\": %.*g,\n" \
 468   "          \"leftDiagonal\": %.*g,\n" \
 469   "          \"rightDiagonal\": %.*g,\n" \
 470   "          \"average\": %.*g\n" \
 471   "        },\n" \
 472   "        \"entropy\": {\n" \
 473   "          \"horizontal\": %.*g,\n" \
 474   "          \"vertical\": %.*g,\n" \
 475   "          \"leftDiagonal\": %.*g,\n" \
 476   "          \"rightDiagonal\": %.*g,\n" \
 477   "          \"average\": %.*g\n" \
 478   "        },\n" \
 479   "        \"differenceVariance\": {\n" \
 480   "          \"horizontal\": %.*g,\n" \
 481   "          \"vertical\": %.*g,\n" \
 482   "          \"leftDiagonal\": %.*g,\n" \
 483   "          \"rightDiagonal\": %.*g,\n" \
 484   "          \"average\": %.*g\n" \
 485   "        },\n" \
 486   "        \"differenceEntropy\": {\n" \
 487   "          \"horizontal\": %.*g,\n" \
 488   "          \"vertical\": %.*g,\n" \
 489   "          \"leftDiagonal\": %.*g,\n" \
 490   "          \"rightDiagonal\": %.*g,\n" \
 491   "          \"average\": %.*g\n" \
 492   "        },\n" \
 493   "        \"informationMeasureOfCorrelation1\": {\n" \
 494   "          \"horizontal\": %.*g,\n" \
 495   "          \"vertical\": %.*g,\n" \
 496   "          \"leftDiagonal\": %.*g,\n" \
 497   "          \"rightDiagonal\": %.*g,\n" \
 498   "          \"average\": %.*g\n" \
 499   "        },\n" \
 500   "        \"informationMeasureOfCorrelation2\": {\n" \
 501   "          \"horizontal\": %.*g,\n" \
 502   "          \"vertical\": %.*g,\n" \
 503   "          \"leftDiagonal\": %.*g,\n" \
 504   "          \"rightDiagonal\": %.*g,\n" \
 505   "          \"average\": %.*g\n" \
 506   "        },\n" \
 507   "        \"maximumCorrelationCoefficient\": {\n" \
 508   "          \"horizontal\": %.*g,\n" \
 509   "          \"vertical\": %.*g,\n" \
 510   "          \"leftDiagonal\": %.*g,\n" \
 511   "          \"rightDiagonal\": %.*g,\n" \
 512   "          \"average\": %.*g\n" \
 513   "        }\n"
 514
 515   ssize_t
 516     n;
 517
 518   n=FormatLocaleFile(file,FeaturesFormat,name,
 519     PrintFeature(channel_features[channel].angular_second_moment),
 520     PrintFeature(channel_features[channel].contrast),
 521     PrintFeature(channel_features[channel].correlation),
 522     PrintFeature(channel_features[channel].variance_sum_of_squares),
 523     PrintFeature(channel_features[channel].inverse_difference_moment),
 524     PrintFeature(channel_features[channel].sum_average),
 525     PrintFeature(channel_features[channel].sum_variance),
 526     PrintFeature(channel_features[channel].sum_entropy),
 527     PrintFeature(channel_features[channel].entropy),
 528     PrintFeature(channel_features[channel].difference_variance),
 529     PrintFeature(channel_features[channel].difference_entropy),
 530     PrintFeature(channel_features[channel].measure_of_correlation_1),
 531     PrintFeature(channel_features[channel].measure_of_correlation_2),
 532     PrintFeature(channel_features[channel].maximum_correlation_coefficient));
 533   (void) FormatLocaleFile(file,"      }");
 534   if (separator != MagickFalse)
 535     (void) FormatLocaleFile(file,",");
 536   (void) FormatLocaleFile(file,"\n");
 537   return(n);
 538 }
 539
 540 static ssize_t PrintChannelLocations(FILE *file,const Image *image,
 541   const PixelChannel channel,const char *name,const StatisticType type,
 542   const size_t max_locations,const MagickBooleanType separator,
 543   const ChannelStatistics *channel_statistics)
 544 {
 545   double
 546     target;
 547
 548   ExceptionInfo
 549     *exception;
 550
 551   ssize_t
 552     n,
 553     y;
 554
 555   switch (type)
 556   {
 557     case MaximumStatistic:
 558     default:
 559     {
 560       target=channel_statistics[channel].maxima;
 561       break;
 562     }
 563     case MinimumStatistic:
 564     {
 565       target=channel_statistics[channel].minima;
 566       break;
 567     }
 568   }
 569   (void) FormatLocaleFile(file,"      \"%s\": {\n        \"intensity\": "
 570     "%.*g,\n",name,GetMagickPrecision(),QuantumScale*target);
 571   exception=AcquireExceptionInfo();
 572   n=0;
 573   for (y=0; y < (ssize_t) image->rows; y++)
 574   {
 575     register const Quantum
 576       *p;
 577
 578     ssize_t
 579       offset,
 580       x;
 581
 582     p=GetVirtualPixels(image,0,y,image->columns,1,exception);
 583     if (p == (const Quantum *) NULL)
 584       break;
 585     for (x=0; x < (ssize_t) image->columns; x++)
 586     {
 587       MagickBooleanType
 588         match;
 589
 590       PixelTrait traits = GetPixelChannelTraits(image,channel);
 591       if (traits == UndefinedPixelTrait)
 592         continue;
 593       offset=GetPixelChannelOffset(image,channel);
 594       match=fabs((double) (p[offset]-target)) < 0.5 ? MagickTrue : MagickFalse;
 595       if (match != MagickFalse)
 596         {
 597           if ((max_locations != 0) && (n >= (ssize_t) max_locations))
 598             break;
 599           if (n != 0)
 600             (void) FormatLocaleFile(file,",\n");
 601           (void) FormatLocaleFile(file,"        \"location%.20g\": {\n"
 602             "          \"x\": %.20g,\n          \"y\": %.20g\n"
 603             "        }",(double) n,(double) x,(double) y);
 604           n++;
 605         }
 606       p+=GetPixelChannels(image);
 607     }
 608     if (x < (ssize_t) image->columns)
 609       break;
 610   }
 611   (void) FormatLocaleFile(file,"\n      }");
 612   if (separator != MagickFalse)
 613     (void) FormatLocaleFile(file,",");
 614   (void) FormatLocaleFile(file,"\n");
 615   return(n);
 616 }
 617
 618 static ssize_t PrintChannelMoments(FILE *file,const PixelChannel channel,
 619   const char *name,const MagickBooleanType separator,
 620   const ChannelMoments *channel_moments)
 621 {
 622   register ssize_t
 623     i;
 624
 625   ssize_t
 626     n;
 627
 628   n=FormatLocaleFile(file,"      \"%s\": {\n",name);
 629   n+=FormatLocaleFile(file,"        \"centroid\": {\n "
 630     "          \"x\": %.*g,\n"
 631     "           \"y\": %.*g\n        },\n",
 632     GetMagickPrecision(),channel_moments[channel].centroid.x,
 633     GetMagickPrecision(),channel_moments[channel].centroid.y);
 634   n+=FormatLocaleFile(file,"        \"ellipseSemiMajorMinorAxis\": {\n"
 635     "          \"x\": %.*g,\n"
 636     "          \"y\": %.*g\n        },\n",
 637     GetMagickPrecision(),channel_moments[channel].ellipse_axis.x,
 638     GetMagickPrecision(),channel_moments[channel].ellipse_axis.y);
 639   n+=FormatLocaleFile(file,"        \"ellipseAngle\": %.*g,\n",
 640     GetMagickPrecision(),channel_moments[channel].ellipse_angle);
 641   n+=FormatLocaleFile(file,"        \"ellipseEccentricity\": %.*g,\n",
 642     GetMagickPrecision(),channel_moments[channel].ellipse_eccentricity);
 643   n+=FormatLocaleFile(file,"        \"ellipseIntensity\": %.*g,\n",
 644     GetMagickPrecision(),channel_moments[channel].ellipse_intensity);
 645   for (i=0; i < 7; i++)
 646     n+=FormatLocaleFile(file,"        \"I%.20g\": %.*g,\n",i+1.0,
 647       GetMagickPrecision(),channel_moments[channel].invariant[i]);
 648   n+=FormatLocaleFile(file,"        \"I%.20g\": %.*g\n",i+1.0,
 649     GetMagickPrecision(),channel_moments[channel].invariant[i]);
 650   (void) FormatLocaleFile(file,"      }");
 651   if (separator != MagickFalse)
 652     (void) FormatLocaleFile(file,",");
 653   (void) FormatLocaleFile(file,"\n");
 654   return(n);
 655 }
 656
 657 static ssize_t PrintChannelPerceptualHash(Image *image,FILE *file,
 658   const ChannelPerceptualHash *channel_phash)
 659 {
 660   register ssize_t
 661     i;
 662
 663   ssize_t
 664     n = 0;
 665
 666   (void) FormatLocaleFile(file,"      \"colorspaces\": [ ");
 667   for (i=0; i < (ssize_t) channel_phash[0].number_colorspaces; i++)
 668   {
 669     (void) FormatLocaleFile(file,"\"%s\"",CommandOptionToMnemonic(
 670       MagickColorspaceOptions,(ssize_t) channel_phash[0].colorspace[i]));
 671     if (i < (ssize_t) (channel_phash[0].number_colorspaces-1))
 672       (void) FormatLocaleFile(file,", ");
 673   }
 674   (void) FormatLocaleFile(file,"],\n");
 675   for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
 676   {
 677     register ssize_t
 678       j;
 679
 680     PixelChannel channel = GetPixelChannelChannel(image,i);
 681     PixelTrait traits = GetPixelChannelTraits(image,channel);
 682     if (traits == UndefinedPixelTrait)
 683       continue;
 684     n=FormatLocaleFile(file,"      \"Channel%.20g\": {\n",(double) channel);
 685     for (j=0; j < MaximumNumberOfPerceptualHashes; j++)
 686     {
 687       register ssize_t
 688         k;
 689
 690       n+=FormatLocaleFile(file,"        \"PH%.20g\": [",(double) j+1);
 691       for (k=0; k < (ssize_t) channel_phash[0].number_colorspaces; k++)
 692       {
 693         n+=FormatLocaleFile(file,"%.*g",GetMagickPrecision(),
 694           channel_phash[channel].phash[k][j]);
 695         if (k < (ssize_t) (channel_phash[0].number_colorspaces-1))
 696           n+=FormatLocaleFile(file,", ");
 697       }
 698       n+=FormatLocaleFile(file,"]");
 699       if (j < (MaximumNumberOfPerceptualHashes-1))
 700         n+=FormatLocaleFile(file,",\n");
 701     }
 702     if (i < (ssize_t) (GetPixelChannels(image)-1))
 703       n+=FormatLocaleFile(file,"\n      },\n");
 704   }
 705   n+=FormatLocaleFile(file,"\n      }\n");
 706   return(n);
 707 }
 708
 709 static ssize_t PrintChannelStatistics(FILE *file,const PixelChannel channel,
 710   const char *name,const double scale,const MagickBooleanType separator,
 711   const ChannelStatistics *channel_statistics)
 712 {
 713 #define StatisticsFormat "      \"%s\": {\n        \"min\": %.*g,\n"  \
 714   "        \"max\": %.*g,\n        \"mean\": %.*g,\n        "  \
 715   "\"standardDeviation\": %.*g,\n        \"kurtosis\": %.*g,\n        "\
 716   "\"skewness\": %.*g,\n        \"entropy\": %.*g\n      }"
 717
 718   ssize_t
 719     n;
 720
 721   n=FormatLocaleFile(file,StatisticsFormat,name,GetMagickPrecision(),
 722     (double) ClampToQuantum(scale*channel_statistics[channel].minima),
 723     GetMagickPrecision(),(double) ClampToQuantum(scale*
 724     channel_statistics[channel].maxima),GetMagickPrecision(),scale*
 725     channel_statistics[channel].mean,GetMagickPrecision(),scale*
 726     channel_statistics[channel].standard_deviation,GetMagickPrecision(),
 727     channel_statistics[channel].kurtosis,GetMagickPrecision(),
 728     channel_statistics[channel].skewness,GetMagickPrecision(),
 729     channel_statistics[channel].entropy);
 730   if (separator != MagickFalse)
 731     (void) FormatLocaleFile(file,",");
 732   (void) FormatLocaleFile(file,"\n");
 733   return(n);
 734 }
 735
 736 static void EncodeIptcProfile(FILE *file,const StringInfo *profile)
 737 {
 738   char
 739     *attribute,
 740     **attribute_list;
 741
 742   const char
 743     *tag;
 744
 745   IPTCInfo
 746     *value,
 747     **values;
 748
 749   long
 750     dataset,
 751     record,
 752     sentinel;
 753
 754   register ssize_t
 755     i,
 756     j,
 757     k;
 758
 759   size_t
 760     count,
 761     length,
 762     profile_length;
 763
 764   values=(IPTCInfo **) NULL;
 765   count=0;
 766   profile_length=GetStringInfoLength(profile);
 767   for (i=0; i < (ssize_t) profile_length; i+=(ssize_t) length)
 768   {
 769     length=1;
 770     sentinel=GetStringInfoDatum(profile)[i++];
 771     if (sentinel != 0x1c)
 772       continue;
 773     dataset=GetStringInfoDatum(profile)[i++];
 774     record=GetStringInfoDatum(profile)[i++];
 775     value=(IPTCInfo *) NULL;
 776     for (j=0; j < (ssize_t) count; j++)
 777     {
 778       if ((values[j]->record == record) && (values[j]->dataset == dataset))
 779         value=values[j];
 780     }
 781     if (value == (IPTCInfo *) NULL)
 782       {
 783         values=(IPTCInfo **) ResizeQuantumMemory(values,count+1,
 784           sizeof(*values));
 785         if (values == (IPTCInfo **) NULL)
 786           break;
 787         value=(IPTCInfo *) AcquireMagickMemory(sizeof(*value));
 788         if (value == (IPTCInfo *) NULL)
 789           break;
 790         /* Check the tag length in IPTCInfo when a new tag is added */
 791         switch (record)
 792         {
 793           case 5: tag="Image Name"; break;
 794           case 7: tag="Edit Status"; break;
 795           case 10: tag="Priority"; break;
 796           case 15: tag="Category"; break;
 797           case 20: tag="Supplemental Category"; break;
 798           case 22: tag="Fixture Identifier"; break;
 799           case 25: tag="Keyword"; break;
 800           case 30: tag="Release Date"; break;
 801           case 35: tag="Release Time"; break;
 802           case 40: tag="Special Instructions"; break;
 803           case 45: tag="Reference Service"; break;
 804           case 47: tag="Reference Date"; break;
 805           case 50: tag="Reference Number"; break;
 806           case 55: tag="Created Date"; break;
 807           case 60: tag="Created Time"; break;
 808           case 65: tag="Originating Program"; break;
 809           case 70: tag="Program Version"; break;
 810           case 75: tag="Object Cycle"; break;
 811           case 80: tag="Byline"; break;
 812           case 85: tag="Byline Title"; break;
 813           case 90: tag="City"; break;
 814           case 92: tag="Sub-Location"; break;
 815           case 95: tag="Province State"; break;
 816           case 100: tag="Country Code"; break;
 817           case 101: tag="Country"; break;
 818           case 103: tag="Original Transmission Reference"; break;
 819           case 105: tag="Headline"; break;
 820           case 110: tag="Credit"; break;
 821           case 115: tag="Src"; break;
 822           case 116: tag="Copyright String"; break;
 823           case 120: tag="Caption"; break;
 824           case 121: tag="Local Caption"; break;
 825           case 122: tag="Caption Writer"; break;
 826           case 200: tag="Custom Field 1"; break;
 827           case 201: tag="Custom Field 2"; break;
 828           case 202: tag="Custom Field 3"; break;
 829           case 203: tag="Custom Field 4"; break;
 830           case 204: tag="Custom Field 5"; break;
 831           case 205: tag="Custom Field 6"; break;
 832           case 206: tag="Custom Field 7"; break;
 833           case 207: tag="Custom Field 8"; break;
 834           case 208: tag="Custom Field 9"; break;
 835           case 209: tag="Custom Field 10"; break;
 836           case 210: tag="Custom Field 11"; break;
 837           case 211: tag="Custom Field 12"; break;
 838           case 212: tag="Custom Field 13"; break;
 839           case 213: tag="Custom Field 14"; break;
 840           case 214: tag="Custom Field 15"; break;
 841           case 215: tag="Custom Field 16"; break;
 842           case 216: tag="Custom Field 17"; break;
 843           case 217: tag="Custom Field 18"; break;
 844           case 218: tag="Custom Field 19"; break;
 845           case 219: tag="Custom Field 20"; break;
 846           default: tag="Unknown"; break;
 847         }
 848         (void) CopyMagickString(value->tag,tag,strlen(tag)+1);
 849         value->record=record;
 850         value->dataset=dataset;
 851         value->values=(char ***) NULL;
 852         value->values_length=0;
 853         values[count++]=value;
 854       }
 855     length=(size_t) (GetStringInfoDatum(profile)[i++] << 8);
 856     length|=GetStringInfoDatum(profile)[i++];
 857     attribute=(char *) NULL;
 858     if (~length >= (MagickPathExtent-1))
 859       attribute=(char *) AcquireQuantumMemory(length+MagickPathExtent,
 860         sizeof(*attribute));
 861     if (attribute != (char *) NULL)
 862       {
 863         (void) CopyMagickString(attribute,(char *)
 864           GetStringInfoDatum(profile)+i,length+1);
 865         attribute_list=StringToList(attribute);
 866         if (attribute_list != (char **) NULL)
 867           {
 868             value->values=(char ***) ResizeQuantumMemory(value->values,
 869               value->values_length+1,
 870               sizeof(*value->values));
 871             if (value->values == (char ***) NULL)
 872               break;
 873             value->values[value->values_length++]=attribute_list;
 874           }
 875         attribute=DestroyString(attribute);
 876       }
 877   }
 878   if (values != (IPTCInfo **) NULL)
 879     {
 880       for (i=0; i < (ssize_t) count; i++)
 881       {
 882         value=values[i];
 883         (void) FormatLocaleFile(file,"        \"%s[%.20g,%.20g]\": ",
 884           value->tag,(double) value->dataset,(double) value->record);
 885         if (value->values_length == 0)
 886           (void) FormatLocaleFile(file,"null,");
 887         else
 888           {
 889             (void) FormatLocaleFile(file,"[");
 890             for (j=0; j < (ssize_t) value->values_length; j++)
 891             {
 892               for (k=0; value->values[j][k] != (char *) NULL; k++)
 893               {
 894                 if (j > 0 || k > 0)
 895                   (void) FormatLocaleFile(file,",");
 896                 JSONFormatLocaleFile(file,"%s",value->values[j][k]);
 897                 value->values[j][k]=(char *) RelinquishMagickMemory(
 898                   value->values[j][k]);
 899               }
 900               value->values[j]=(char **) RelinquishMagickMemory(
 901                 value->values[j]);
 902             }
 903             value->values=(char ***) RelinquishMagickMemory(value->values);
 904             (void) FormatLocaleFile(file,"],\n");
 905           }
 906         values[i]=(IPTCInfo *) RelinquishMagickMemory(values[i]);
 907       }
 908       values=(IPTCInfo **) RelinquishMagickMemory(values);
 909     }
 910 }
 911
 912 static MagickBooleanType EncodeImageAttributes(Image *image,FILE *file,
 913   ExceptionInfo *exception)
 914 {
 915   char
 916     color[MagickPathExtent],
 917     format[MagickPathExtent],
 918     key[MagickPathExtent];
 919
 920   ChannelFeatures
 921     *channel_features;
 922
 923   ChannelMoments
 924     *channel_moments;
 925
 926   ChannelPerceptualHash
 927     *channel_phash;
 928
 929   ChannelStatistics
 930     *channel_statistics;
 931
 932   char
 933     *url;
 934
 935   ColorspaceType
 936     colorspace;
 937
 938   const char
 939     *artifact,
 940     *locate,
 941     *name,
 942     *property,
 943     *registry,
 944     *value;
 945
 946   const MagickInfo
 947     *magick_info;
 948
 949   double
 950     elapsed_time,
 951     user_time;
 952
 953   ImageType
 954     base_type,
 955     type;
 956
 957   MagickBooleanType
 958     ping;
 959
 960   register const Quantum
 961     *p;
 962
 963   register ssize_t
 964     i,
 965     x;
 966
 967   size_t
 968     depth,
 969     distance,
 970     scale;
 971
 972   ssize_t
 973     y;
 974
 975   assert(image != (Image *) NULL);
 976   assert(image->signature == MagickCoreSignature);
 977   if (image->debug != MagickFalse)
 978     (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
 979   *format='\0';
 980   elapsed_time=GetElapsedTime(&image->timer);
 981   user_time=GetUserTime(&image->timer);
 982   GetTimerInfo(&image->timer);
 983   p=GetVirtualPixels(image,0,0,1,1,exception);
 984   ping=p == (const Quantum *) NULL ? MagickTrue : MagickFalse;
 985   (void) ping;
 986   (void) SignatureImage(image,exception);
 987   JSONFormatLocaleFile(file,"{\n  \"image\": {\n    \"name\": %s,\n",
 988     image->filename);
 989   if (*image->magick_filename != '\0')
 990     if (LocaleCompare(image->magick_filename,image->filename) != 0)
 991       {
 992         char
 993           filename[MagickPathExtent];
 994
 995         GetPathComponent(image->magick_filename,TailPath,filename);
 996         JSONFormatLocaleFile(file,"    \"baseName\": %s,\n",filename);
 997       }
 998   JSONFormatLocaleFile(file,"    \"format\": %s,\n",image->magick);
 999   magick_info=GetMagickInfo(image->magick,exception);
1000   if ((magick_info != (const MagickInfo *) NULL) &&
1001       (GetMagickDescription(magick_info) != (const char *) NULL))
1002     JSONFormatLocaleFile(file,"    \"formatDescription\": %s,\n",
1003       image->magick);
1004   if ((magick_info != (const MagickInfo *) NULL) &&
1005       (GetMagickMimeType(magick_info) != (const char *) NULL))
1006     JSONFormatLocaleFile(file,"    \"mimeType\": %s,\n",GetMagickMimeType(
1007       magick_info));
1008   JSONFormatLocaleFile(file,"    \"class\": %s,\n",CommandOptionToMnemonic(
1009     MagickClassOptions,(ssize_t) image->storage_class));
1010   (void) FormatLocaleFile(file,"    \"geometry\": {\n"
1011     "      \"width\": %g,\n      \"height\": %g,\n"
1012     "      \"x\": %g,\n      \"y\": %g\n    },\n",
1013     (double) image->columns,(double) image->rows,(double) image->tile_offset.x,
1014     (double) image->tile_offset.y);
1015   if ((image->magick_columns != 0) || (image->magick_rows != 0))
1016     if ((image->magick_columns != image->columns) ||
1017         (image->magick_rows != image->rows))
1018       (void) FormatLocaleFile(file,"    \"baseGeometry\": {\n"
1019         "      \"width\": %g,\n      \"height\": %g\n    },\n",(double)
1020         image->magick_columns,(double) image->magick_rows);
1021   if ((image->resolution.x != 0.0) && (image->resolution.y != 0.0))
1022     {
1023       (void) FormatLocaleFile(file,"    \"resolution\": {\n"
1024         "      \"x\": %g,\n      \"y\": %g\n    },\n",image->resolution.x,
1025         image->resolution.y);
1026       (void) FormatLocaleFile(file,"    \"printSize\": {\n"
1027         "      \"x\": %.*g,\n      \"y\": %.*g\n    },\n",GetMagickPrecision(),
1028         image->columns/image->resolution.x,GetMagickPrecision(),(double)
1029         image->rows/image->resolution.y);
1030     }
1031   JSONFormatLocaleFile(file,"    \"units\": %s,\n",CommandOptionToMnemonic(
1032     MagickResolutionOptions,(ssize_t) image->units));
1033   colorspace=image->colorspace;
1034   type=IdentifyImageType(image,exception);
1035   if ((type == BilevelType) || (type == GrayscaleType) ||
1036       (type == GrayscaleAlphaType))
1037     colorspace=GRAYColorspace;
1038   JSONFormatLocaleFile(file,"    \"type\": %s,\n",CommandOptionToMnemonic(
1039     MagickTypeOptions,(ssize_t) type));
1040   base_type=GetImageType(image);
1041   if (type != base_type)
1042     JSONFormatLocaleFile(file,"    \"baseType\": %s,\n",
1043       CommandOptionToMnemonic(MagickTypeOptions,(ssize_t) base_type));
1044   JSONFormatLocaleFile(file,"    \"endianess\": %s,\n",
1045     CommandOptionToMnemonic(MagickEndianOptions,(ssize_t) image->endian));
1046   locate=GetImageArtifact(image,"identify:locate");
1047   if (locate == (const char *) NULL)
1048     locate=GetImageArtifact(image,"json:locate");
1049   if (locate != (const char *) NULL)
1050     {
1051       const char
1052         *limit;
1053
1054       size_t
1055         max_locations;
1056
1057       StatisticType
1058         type;
1059
1060       /*
1061         Display minimum, maximum, or mean pixel locations.
1062       */
1063       type=(StatisticType) ParseCommandOption(MagickStatisticOptions,
1064         MagickFalse,locate);
1065       limit=GetImageArtifact(image,"identify:limit");
1066       if (limit == (const char *) NULL)
1067         limit=GetImageArtifact(image,"json:limit");
1068       max_locations=0;
1069       if (limit != (const char *) NULL)
1070         max_locations=StringToUnsignedLong(limit);
1071       channel_statistics=GetLocationStatistics(image,type,exception);
1072       if (channel_statistics == (ChannelStatistics *) NULL)
1073         return(MagickFalse);
1074       (void) FormatLocaleFile(file,"    \"channel%s\": {\n",locate);
1075       if (image->alpha_trait != UndefinedPixelTrait)
1076         (void) PrintChannelLocations(file,image,AlphaPixelChannel,"Alpha",
1077           type,max_locations,MagickTrue,channel_statistics);
1078       switch (colorspace)
1079       {
1080         case RGBColorspace:
1081         default:
1082         {
1083           (void) PrintChannelLocations(file,image,RedPixelChannel,"Red",
1084             type,max_locations,MagickTrue,channel_statistics);
1085           (void) PrintChannelLocations(file,image,GreenPixelChannel,"Green",
1086             type,max_locations,MagickTrue,channel_statistics);
1087           (void) PrintChannelLocations(file,image,BluePixelChannel,"Blue",
1088             type,max_locations,MagickFalse,channel_statistics);
1089           break;
1090         }
1091         case CMYKColorspace:
1092         {
1093           (void) PrintChannelLocations(file,image,CyanPixelChannel,"Cyan",
1094             type,max_locations,MagickTrue,channel_statistics);
1095           (void) PrintChannelLocations(file,image,MagentaPixelChannel,"Magenta",
1096             type,max_locations,MagickTrue,channel_statistics);
1097           (void) PrintChannelLocations(file,image,YellowPixelChannel,"Yellow",
1098             type,max_locations,MagickTrue,channel_statistics);
1099           (void) PrintChannelLocations(file,image,BlackPixelChannel,"Black",
1100             type,max_locations,MagickFalse,channel_statistics);
1101           break;
1102         }
1103         case GRAYColorspace:
1104         {
1105           (void) PrintChannelLocations(file,image,GrayPixelChannel,"Gray",
1106             type,max_locations,MagickFalse,channel_statistics);
1107           break;
1108         }
1109       }
1110       (void) FormatLocaleFile(file,"    },\n");
1111       channel_statistics=(ChannelStatistics *) RelinquishMagickMemory(
1112         channel_statistics);
1113     }
1114   /*
1115     Detail channel depth and extrema.
1116   */
1117   JSONFormatLocaleFile(file,"    \"colorspace\": %s,\n",
1118     CommandOptionToMnemonic(MagickColorspaceOptions,(ssize_t) colorspace));
1119   channel_statistics=(ChannelStatistics *) NULL;
1120   channel_moments=(ChannelMoments *) NULL;
1121   channel_phash=(ChannelPerceptualHash *) NULL;
1122   channel_features=(ChannelFeatures *) NULL;
1123   scale=1;
1124   channel_statistics=GetImageStatistics(image,exception);
1125   if (channel_statistics == (ChannelStatistics *) NULL)
1126     return(MagickFalse);
1127   artifact=GetImageArtifact(image,"identify:moments");
1128   if (artifact == (const char *) NULL)
1129     artifact=GetImageArtifact(image,"json:moments");
1130   if (artifact != (const char *) NULL)
1131     {
1132       channel_moments=GetImageMoments(image,exception);
1133       channel_phash=GetImagePerceptualHash(image,exception);
1134     }
1135   artifact=GetImageArtifact(image,"identify:features");
1136   if (artifact == (const char *) NULL)
1137     artifact=GetImageArtifact(image,"json:features");
1138   if (artifact != (const char *) NULL)
1139     {
1140       distance=StringToUnsignedLong(artifact);
1141       channel_features=GetImageFeatures(image,distance,exception);
1142     }
1143   depth=GetImageDepth(image,exception);
1144   (void) FormatLocaleFile(file,"    \"depth\": %g,\n",(double) depth);
1145   (void) FormatLocaleFile(file,"    \"baseDepth\": %g,\n",(double)
1146     image->depth);
1147   (void) FormatLocaleFile(file,"    \"channelDepth\": {\n");
1148   if (image->alpha_trait != UndefinedPixelTrait)
1149     (void) FormatLocaleFile(file,"      \"alpha\": %.20g,\n",(double)
1150       channel_statistics[AlphaPixelChannel].depth);
1151   switch (colorspace)
1152   {
1153     case RGBColorspace:
1154     default:
1155     {
1156       (void) FormatLocaleFile(file,"      \"red\": %.20g,\n",(double)
1157         channel_statistics[RedChannel].depth);
1158       (void) FormatLocaleFile(file,"      \"green\": %.20g,\n",(double)
1159         channel_statistics[GreenChannel].depth);
1160       (void) FormatLocaleFile(file,"      \"blue\": %.20g\n",(double)
1161         channel_statistics[BlueChannel].depth);
1162       break;
1163     }
1164     case CMYKColorspace:
1165     {
1166       (void) FormatLocaleFile(file,"      \"cyan\": %.20g,\n",(double)
1167         channel_statistics[CyanChannel].depth);
1168       (void) FormatLocaleFile(file,"      \"magenta\": %.20g,\n",(double)
1169         channel_statistics[MagentaChannel].depth);
1170       (void) FormatLocaleFile(file,"      \"yellow\": %.20g,\n",(double)
1171         channel_statistics[YellowChannel].depth);
1172       (void) FormatLocaleFile(file,"      \"black\": %.20g\n",(double)
1173         channel_statistics[BlackChannel].depth);
1174       break;
1175     }
1176     case GRAYColorspace:
1177     {
1178       (void) FormatLocaleFile(file,"      \"gray\": %.20g\n",(double)
1179         channel_statistics[GrayChannel].depth);
1180       break;
1181     }
1182   }
1183   (void) FormatLocaleFile(file,"    },\n");
1184   scale=1;
1185   if (image->depth <= MAGICKCORE_QUANTUM_DEPTH)
1186     scale=QuantumRange/((size_t) QuantumRange >> ((size_t)
1187       MAGICKCORE_QUANTUM_DEPTH-image->depth));
1188   if (channel_statistics != (ChannelStatistics *) NULL)
1189     {
1190       (void) FormatLocaleFile(file,"    \"pixels\": %.20g,\n",
1191         channel_statistics[CompositePixelChannel].area);
1192       if (colorspace != GRAYColorspace)
1193         {
1194           (void) FormatLocaleFile(file,"    \"imageStatistics\": {\n");
1195           (void) PrintChannelStatistics(file,(PixelChannel) MaxPixelChannels,
1196             "Overall",1.0/scale,MagickFalse,channel_statistics);
1197           (void) FormatLocaleFile(file,"    },\n");
1198         }
1199       (void) FormatLocaleFile(file,"    \"channelStatistics\": {\n");
1200       if (image->alpha_trait != UndefinedPixelTrait)
1201         (void) PrintChannelStatistics(file,AlphaPixelChannel,"Alpha",1.0/scale,
1202           MagickTrue,channel_statistics);
1203       switch (colorspace)
1204       {
1205         case RGBColorspace:
1206         default:
1207         {
1208           (void) PrintChannelStatistics(file,RedPixelChannel,"Red",1.0/scale,
1209             MagickTrue,channel_statistics);
1210           (void) PrintChannelStatistics(file,GreenPixelChannel,"Green",1.0/
1211             scale,MagickTrue,channel_statistics);
1212           (void) PrintChannelStatistics(file,BluePixelChannel,"Blue",1.0/scale,
1213             MagickFalse,channel_statistics);
1214           break;
1215         }
1216         case CMYKColorspace:
1217         {
1218           (void) PrintChannelStatistics(file,CyanPixelChannel,"Cyan",1.0/scale,
1219             MagickTrue,channel_statistics);
1220           (void) PrintChannelStatistics(file,MagentaPixelChannel,"Magenta",1.0/
1221             scale,MagickTrue,channel_statistics);
1222           (void) PrintChannelStatistics(file,YellowPixelChannel,"Yellow",1.0/
1223             scale,MagickTrue,channel_statistics);
1224           (void) PrintChannelStatistics(file,BlackPixelChannel,"Black",1.0/
1225             scale,MagickFalse,channel_statistics);
1226           break;
1227         }
1228         case GRAYColorspace:
1229         {
1230           (void) PrintChannelStatistics(file,GrayPixelChannel,"Gray",1.0/scale,
1231             MagickFalse,channel_statistics);
1232           break;
1233         }
1234       }
1235       (void) FormatLocaleFile(file,"    },\n");
1236       channel_statistics=(ChannelStatistics *) RelinquishMagickMemory(
1237         channel_statistics);
1238     }
1239   if (channel_moments != (ChannelMoments *) NULL)
1240     {
1241       (void) FormatLocaleFile(file,"    \"channelMoments\": {\n");
1242       if (image->alpha_trait != UndefinedPixelTrait)
1243         (void) PrintChannelMoments(file,AlphaPixelChannel,"Alpha",MagickTrue,
1244           channel_moments);
1245       switch (colorspace)
1246       {
1247         case RGBColorspace:
1248         default:
1249         {
1250           (void) PrintChannelMoments(file,RedPixelChannel,"Red",MagickTrue,
1251             channel_moments);
1252           (void) PrintChannelMoments(file,GreenPixelChannel,"Green",MagickTrue,
1253             channel_moments);
1254           (void) PrintChannelMoments(file,BluePixelChannel,"Blue",MagickFalse,
1255             channel_moments);
1256           break;
1257         }
1258         case CMYKColorspace:
1259         {
1260           (void) PrintChannelMoments(file,CyanPixelChannel,"Cyan",MagickTrue,
1261             channel_moments);
1262           (void) PrintChannelMoments(file,MagentaPixelChannel,"Magenta",
1263             MagickTrue,channel_moments);
1264           (void) PrintChannelMoments(file,YellowPixelChannel,"Yellow",
1265             MagickTrue,channel_moments);
1266           (void) PrintChannelMoments(file,BlackPixelChannel,"Black",
1267             MagickFalse,channel_moments);
1268           break;
1269         }
1270         case GRAYColorspace:
1271         {
1272           (void) PrintChannelMoments(file,GrayPixelChannel,"Gray",MagickFalse,
1273             channel_moments);
1274           break;
1275         }
1276       }
1277       (void) FormatLocaleFile(file,"    },\n");
1278       channel_moments=(ChannelMoments *) RelinquishMagickMemory(
1279         channel_moments);
1280     }
1281   if (channel_phash != (ChannelPerceptualHash *) NULL)
1282     {
1283       (void) FormatLocaleFile(file,"    \"channelPerceptualHash\": {\n");
1284       (void) PrintChannelPerceptualHash(image,file,channel_phash);
1285       (void) FormatLocaleFile(file,"    },\n");
1286       channel_phash=(ChannelPerceptualHash *) RelinquishMagickMemory(
1287         channel_phash);
1288     }
1289   if (channel_features != (ChannelFeatures *) NULL)
1290     {
1291       (void) FormatLocaleFile(file,"    \"channelFeatures\": {\n");
1292       if (image->alpha_trait != UndefinedPixelTrait)
1293         (void) PrintChannelFeatures(file,AlphaPixelChannel,"Alpha",MagickTrue,
1294           channel_features);
1295       switch (colorspace)
1296       {
1297         case RGBColorspace:
1298         default:
1299         {
1300           (void) PrintChannelFeatures(file,RedPixelChannel,"Red",MagickTrue,
1301             channel_features);
1302           (void) PrintChannelFeatures(file,GreenPixelChannel,"Green",
1303             MagickTrue,channel_features);
1304           (void) PrintChannelFeatures(file,BluePixelChannel,"Blue",MagickFalse,
1305             channel_features);
1306           break;
1307         }
1308         case CMYKColorspace:
1309         {
1310           (void) PrintChannelFeatures(file,CyanPixelChannel,"Cyan",MagickTrue,
1311             channel_features);
1312           (void) PrintChannelFeatures(file,MagentaPixelChannel,"Magenta",
1313             MagickTrue,channel_features);
1314           (void) PrintChannelFeatures(file,YellowPixelChannel,"Yellow",
1315             MagickTrue,channel_features);
1316           (void) PrintChannelFeatures(file,BlackPixelChannel,"Black",
1317             MagickFalse,channel_features);
1318           break;
1319         }
1320         case GRAYColorspace:
1321         {
1322           (void) PrintChannelFeatures(file,GrayPixelChannel,"Gray",MagickFalse,
1323             channel_features);
1324           break;
1325         }
1326       }
1327       (void) FormatLocaleFile(file,"    },\n");
1328       channel_features=(ChannelFeatures *) RelinquishMagickMemory(
1329         channel_features);
1330     }
1331     if (image->colorspace == CMYKColorspace)
1332       (void) FormatLocaleFile(file,"    \"totalInkDensity\": \"%.*g%%\",\n",
1333         GetMagickPrecision(),100.0*GetImageTotalInkDensity(image,exception)/
1334         (double) QuantumRange);
1335     x=0;
1336     if (image->alpha_trait != UndefinedPixelTrait)
1337       {
1338         register const Quantum
1339           *p;
1340
1341         p=(const Quantum *) NULL;
1342         for (y=0; y < (ssize_t) image->rows; y++)
1343         {
1344           p=GetVirtualPixels(image,0,y,image->columns,1,exception);
1345           if (p == (const Quantum *) NULL)
1346             break;
1347           for (x=0; x < (ssize_t) image->columns; x++)
1348           {
1349             if (GetPixelAlpha(image,p) == (Quantum) TransparentAlpha)
1350               break;
1351             p+=GetPixelChannels(image);
1352           }
1353           if (x < (ssize_t) image->columns)
1354             break;
1355         }
1356         if ((x < (ssize_t) image->columns) || (y < (ssize_t) image->rows))
1357           {
1358             PixelInfo
1359               pixel;
1360
1361             GetPixelInfo(image,&pixel);
1362             GetPixelInfoPixel(image,p,&pixel);
1363             GetColorTuple(&pixel,MagickTrue,color);
1364             (void) FormatLocaleFile(file,"    \"alpha\": \"%s\",\n",color);
1365           }
1366       }
1367   if (image->storage_class == PseudoClass)
1368     {
1369       register PixelInfo
1370         *magick_restrict p;
1371
1372       (void) FormatLocaleFile(file,"    \"colormapEntries\": %.20g,\n",
1373         (double) image->colors);
1374       (void) FormatLocaleFile(file,"    \"colormap\": [\n      ");
1375       p=image->colormap;
1376       for (i=0; i < (ssize_t) image->colors; i++)
1377       {
1378         GetColorTuple(p,MagickTrue,color);
1379         (void) FormatLocaleFile(file,"\"%s\"",color);
1380         if (i < (ssize_t) (image->colors-1))
1381           (void) FormatLocaleFile(file,",");
1382         if (((i+1) % 5) == 0)
1383           (void) FormatLocaleFile(file,"\n      ");
1384         p++;
1385       }
1386       (void) FormatLocaleFile(file,"\n    ],\n");
1387     }
1388   if (image->error.mean_error_per_pixel != 0.0)
1389     (void) FormatLocaleFile(file,"    \"meanErrorPerPixel\": %g,\n",
1390       image->error.mean_error_per_pixel);
1391   if (image->error.normalized_mean_error != 0.0)
1392     (void) FormatLocaleFile(file,"    \"normalizedMeanError\": %g,\n",
1393       image->error.normalized_mean_error);
1394   if (image->error.normalized_maximum_error != 0.0)
1395     (void) FormatLocaleFile(file,"    \"normalizedMaximumError\": %g,\n",
1396       image->error.normalized_maximum_error);
1397   JSONFormatLocaleFile(file,"    \"renderingIntent\": %s,\n",
1398     CommandOptionToMnemonic(MagickIntentOptions,(ssize_t)
1399     image->rendering_intent));
1400   if (image->gamma != 0.0)
1401     (void) FormatLocaleFile(file,"    \"gamma\": %g,\n",image->gamma);
1402   if ((image->chromaticity.red_primary.x != 0.0) ||
1403       (image->chromaticity.green_primary.x != 0.0) ||
1404       (image->chromaticity.blue_primary.x != 0.0) ||
1405       (image->chromaticity.white_point.x != 0.0))
1406     {
1407       /*
1408         Display image chromaticity.
1409       */
1410       (void) FormatLocaleFile(file,"    \"chromaticity\": {\n");
1411       (void) FormatLocaleFile(file,"      \"redPrimary\": {\n"
1412         "        \"x\": %g,\n        \"y\": %g\n      },\n",
1413         image->chromaticity.red_primary.x,image->chromaticity.red_primary.y);
1414       (void) FormatLocaleFile(file,"      \"greenPrimary\": {\n"
1415         "        \"x\": %g,\n        \"y\": %g\n      },\n",
1416         image->chromaticity.green_primary.x,
1417         image->chromaticity.green_primary.y);
1418       (void) FormatLocaleFile(file,"      \"bluePrimary\": {\n"
1419         "        \"x\": %g,\n        \"y\": %g\n      },\n",
1420         image->chromaticity.blue_primary.x,image->chromaticity.blue_primary.y);
1421       (void) FormatLocaleFile(file,"      \"whitePrimary\": {\n"
1422         "        \"x\": %g,\n        \"y\": %g\n      }\n",
1423         image->chromaticity.white_point.x,image->chromaticity.white_point.y);
1424       (void) FormatLocaleFile(file,"    },\n");
1425     }
1426   if ((image->extract_info.width*image->extract_info.height) != 0)
1427     (void) FormatLocaleFile(file,"    \"tileGeometry\": {\n"
1428       "      \"width\": %.20g,\n      \"height\": %.20g,\n"
1429       "      \"x\": %.20g,\n      \"y\": %.20g\n    },\n",
1430       (double) image->extract_info.width,(double) image->extract_info.height,
1431       (double) image->extract_info.x,(double) image->extract_info.y);
1432   GetColorTuple(&image->matte_color,MagickTrue,color);
1433   (void) FormatLocaleFile(file,"    \"matteColor\": \"%s\",\n",color);
1434   GetColorTuple(&image->background_color,MagickTrue,color);
1435   (void) FormatLocaleFile(file,"    \"backgroundColor\": \"%s\",\n",color);
1436   GetColorTuple(&image->border_color,MagickTrue,color);
1437   (void) FormatLocaleFile(file,"    \"borderColor\": \"%s\",\n",color);
1438   GetColorTuple(&image->transparent_color,MagickTrue,color);
1439   (void) FormatLocaleFile(file,"    \"transparentColor\": \"%s\",\n",color);
1440   JSONFormatLocaleFile(file,"    \"interlace\": %s,\n",CommandOptionToMnemonic(
1441     MagickInterlaceOptions,(ssize_t) image->interlace));
1442   JSONFormatLocaleFile(file,"    \"intensity\": %s,\n",CommandOptionToMnemonic(
1443     MagickPixelIntensityOptions,(ssize_t) image->intensity));
1444   JSONFormatLocaleFile(file,"    \"compose\": %s,\n",
1445     CommandOptionToMnemonic(MagickComposeOptions,(ssize_t) image->compose));
1446   if ((image->page.width != 0) || (image->page.height != 0) ||
1447       (image->page.x != 0) || (image->page.y != 0))
1448     (void) FormatLocaleFile(file,"    \"pageGeometry\": {\n"
1449       "      \"width\": %.20g,\n      \"height\": %.20g,\n"
1450       "      \"x\": %.20g,\n      \"y\": %.20g\n    },\n",
1451       (double) image->page.width,(double) image->page.height,
1452       (double) image->page.x,(double) image->page.y);
1453   if ((image->page.x != 0) || (image->page.y != 0))
1454     (void) FormatLocaleFile(file,"    \"originGeometry\": %+.20g%+.20g,\n",
1455       (double) image->page.x,(double) image->page.y);
1456   JSONFormatLocaleFile(file,"    \"dispose\": %s,\n",
1457     CommandOptionToMnemonic(MagickDisposeOptions,(ssize_t) image->dispose));
1458   if (image->delay != 0)
1459     (void) FormatLocaleFile(file,"    \"delay\": \"%.20gx%.20g\",\n",
1460       (double) image->delay,(double) image->ticks_per_second);
1461   if (image->iterations != 1)
1462     (void) FormatLocaleFile(file,"    \"iterations\": %.20g,\n",(double)
1463       image->iterations);
1464   if ((image->next != (Image *) NULL) || (image->previous != (Image *) NULL))
1465     (void) FormatLocaleFile(file,"    \"scene\": %.20g,\n    \"scenes\": "
1466       "%.20g,\n",(double) image->scene,(double) GetImageListLength(image));
1467   else
1468     if (image->scene != 0)
1469       (void) FormatLocaleFile(file,"    \"scene\": %.20g,\n",(double)
1470         image->scene);
1471   JSONFormatLocaleFile(file,"    \"compression\": %s,\n",
1472     CommandOptionToMnemonic(MagickCompressOptions,(ssize_t)
1473     image->compression));
1474   if (image->quality != UndefinedCompressionQuality)
1475     (void) FormatLocaleFile(file,"    \"quality\": %.20g,\n",(double)
1476       image->quality);
1477   JSONFormatLocaleFile(file,"    \"orientation\": %s,\n",
1478     CommandOptionToMnemonic(MagickOrientationOptions,(ssize_t)
1479     image->orientation));
1480   if (image->montage != (char *) NULL)
1481     JSONFormatLocaleFile(file,"    \"montage\": \"%s\",\n",image->montage);
1482   if (image->directory != (char *) NULL)
1483     {
1484       Image
1485         *tile;
1486
1487       ImageInfo
1488         *image_info;
1489
1490       register char
1491         *p,
1492         *q;
1493
1494       WarningHandler
1495         handler;
1496
1497       /*
1498         Display visual image directory.
1499       */
1500       image_info=AcquireImageInfo();
1501       (void) CloneString(&image_info->size,"64x64");
1502       (void) FormatLocaleFile(file,"    \"montageDirectory\": [");
1503       p=image->directory;
1504       while (*p != '\0')
1505       {
1506         q=p;
1507         while ((*q != '\n') && (*q != '\0'))
1508           q++;
1509         (void) CopyMagickString(image_info->filename,p,(size_t) (q-p+1));
1510         p=q+1;
1511         JSONFormatLocaleFile(file,"{\n       \"name\": %s",
1512           image_info->filename);
1513         handler=SetWarningHandler((WarningHandler) NULL);
1514         tile=ReadImage(image_info,exception);
1515         (void) SetWarningHandler(handler);
1516         if (tile == (Image *) NULL)
1517           {
1518             (void) FormatLocaleFile(file,"    }");
1519             continue;
1520           }
1521         (void) FormatLocaleFile(file,",\n       \"info\": \"%.20gx%.20g %s\"",
1522           (double) tile->magick_columns,(double) tile->magick_rows,
1523           tile->magick);
1524         (void) SignatureImage(tile,exception);
1525         ResetImagePropertyIterator(tile);
1526         property=GetNextImageProperty(tile);
1527         while (property != (const char *) NULL)
1528         {
1529           JSONFormatLocaleFile(file,",\n       %s: ",property);
1530           value=GetImageProperty(tile,property,exception);
1531           JSONFormatLocaleFile(file,"%s",value);
1532           property=GetNextImageProperty(tile);
1533         }
1534         tile=DestroyImage(tile);
1535         if (*p != '\0')
1536           (void) FormatLocaleFile(file,"\n    },");
1537         else
1538           (void) FormatLocaleFile(file,"\n    }");
1539       }
1540       (void) FormatLocaleFile(file,"],\n");
1541       image_info=DestroyImageInfo(image_info);
1542     }
1543   (void) GetImageProperty(image,"exif:*",exception);
1544   (void) GetImageProperty(image,"icc:*",exception);
1545   (void) GetImageProperty(image,"iptc:*",exception);
1546   (void) GetImageProperty(image,"xmp:*",exception);
1547   ResetImagePropertyIterator(image);
1548   property=GetNextImageProperty(image);
1549   if (property != (const char *) NULL)
1550     {
1551       size_t
1552         n;
1553
1554       /*
1555         Display image properties.
1556       */
1557       n=0;
1558       (void) FormatLocaleFile(file,"    \"properties\": {\n");
1559       while (property != (const char *) NULL)
1560       {
1561         if (n++ != 0)
1562           (void) FormatLocaleFile(file,",\n");
1563         JSONFormatLocaleFile(file,"      %s: ",property);
1564         value=GetImageProperty(image,property,exception);
1565         JSONFormatLocaleFile(file,"%s",value);
1566         property=GetNextImageProperty(image);
1567       }
1568       (void) FormatLocaleFile(file,"\n    },\n");
1569     }
1570   (void) FormatLocaleString(key,MagickPathExtent,"8BIM:1999,2998:#1");
1571   value=GetImageProperty(image,key,exception);
1572   if (value != (const char *) NULL)
1573     {
1574       /*
1575         Display clipping path.
1576       */
1577       JSONFormatLocaleFile(file,"    \"clipping path\": %s,\n",value);
1578     }
1579   ResetImageProfileIterator(image);
1580   name=GetNextImageProfile(image);
1581   if (name != (char *) NULL)
1582     {
1583       const StringInfo
1584         *profile;
1585
1586       size_t
1587         n;
1588
1589       /*
1590         Identify image profiles.
1591       */
1592       n=0;
1593       (void) FormatLocaleFile(file,"    \"profiles\": {\n");
1594       while (name != (char *) NULL)
1595       {
1596         profile=GetImageProfile(image,name);
1597         if (profile == (StringInfo *) NULL)
1598           continue;
1599         if (n++ != 0)
1600           (void) FormatLocaleFile(file,",\n");
1601         JSONFormatLocaleFile(file,"      %s: {\n",name);
1602         if (LocaleCompare(name,"iptc") == 0)
1603           EncodeIptcProfile(file,profile);
1604         (void) FormatLocaleFile(file,"        \"length\": %.20g",(double)
1605           GetStringInfoLength(profile));
1606         (void) FormatLocaleFile(file,"\n      }");
1607         name=GetNextImageProfile(image);
1608       }
1609       (void) FormatLocaleFile(file,"\n    },\n");
1610     }
1611   ResetImageArtifactIterator(image);
1612   artifact=GetNextImageArtifact(image);
1613   if (artifact != (const char *) NULL)
1614     {
1615       ssize_t
1616         n;
1617
1618       /*
1619         Display image artifacts.
1620       */
1621       n=0;
1622       (void) FormatLocaleFile(file,"    \"artifacts\": {\n");
1623       while (artifact != (const char *) NULL)
1624       {
1625         if (n++ != 0)
1626           (void) FormatLocaleFile(file,",\n");
1627         JSONFormatLocaleFile(file,"      %s: ",artifact);
1628         value=GetImageArtifact(image,artifact);
1629         JSONFormatLocaleFile(file,"%s",value);
1630         artifact=GetNextImageArtifact(image);
1631       }
1632       (void) FormatLocaleFile(file,"\n    },\n");
1633     }
1634   ResetImageRegistryIterator();
1635   registry=GetNextImageRegistry();
1636   if (registry != (const char *) NULL)
1637     {
1638       ssize_t
1639         n;
1640
1641       /*
1642         Display image registry.
1643       */
1644       (void) FormatLocaleFile(file,"    \"registry\": {\n");
1645       n=0;
1646       while (registry != (const char *) NULL)
1647       {
1648         if (n++ != 0)
1649           (void) FormatLocaleFile(file,",\n");
1650         JSONFormatLocaleFile(file,"      %s: ",registry);
1651         value=(const char *) GetImageRegistry(StringRegistryType,registry,
1652           exception);
1653         JSONFormatLocaleFile(file,"%s",value);
1654         registry=GetNextImageRegistry();
1655       }
1656       (void) FormatLocaleFile(file,"    },\n");
1657     }
1658   (void) FormatLocaleFile(file,"    \"tainted\": %s,\n",
1659     image->taint != MagickFalse ? "true" : "false");
1660   (void) FormatMagickSize(GetBlobSize(image),MagickFalse,"B",MagickPathExtent,
1661     format);
1662   JSONFormatLocaleFile(file,"    \"filesize\": %s,\n",format);
1663   (void) FormatMagickSize((MagickSizeType) image->columns*image->rows,
1664     MagickFalse,"B",MagickPathExtent,format);
1665   if (strlen(format) > 1)
1666     format[strlen(format)-1]='\0';
1667   JSONFormatLocaleFile(file,"    \"numberPixels\": %s,\n",format);
1668   (void) FormatMagickSize((MagickSizeType) ((double) image->columns*image->rows/
1669     elapsed_time+0.5),MagickFalse,"B",MagickPathExtent,format);
1670   JSONFormatLocaleFile(file,"    \"pixelsPerSecond\": %s,\n",format);
1671   (void) FormatLocaleFile(file,"    \"userTime\": \"%0.3fu\",\n",user_time);
1672   (void) FormatLocaleFile(file,"    \"elapsedTime\": \"%lu:%02lu.%03lu\",\n",
1673     (unsigned long) (elapsed_time/60.0),(unsigned long) ceil(fmod(
1674     elapsed_time,60.0)),(unsigned long) (1000.0*(elapsed_time-floor(
1675     elapsed_time))));
1676   url=GetMagickHomeURL();
1677   JSONFormatLocaleFile(file,"    \"version\": %s\n",url);
1678   url=DestroyString(url);
1679   (void) FormatLocaleFile(file,"  }\n}\n");
1680   (void) fflush(file);
1681   return(ferror(file) != 0 ? MagickFalse : MagickTrue);
1682 }
1683
1684 static MagickBooleanType WriteJSONImage(const ImageInfo *image_info,
1685   Image *image,ExceptionInfo *exception)
1686 {
1687   FILE
1688     *file;
1689
1690   MagickBooleanType
1691     status;
1692
1693   MagickOffsetType
1694     scene;
1695
1696   /*
1697     Open output image file.
1698   */
1699   assert(image_info != (const ImageInfo *) NULL);
1700   assert(image_info->signature == MagickCoreSignature);
1701   assert(image != (Image *) NULL);
1702   assert(image->signature == MagickCoreSignature);
1703   if (image->debug != MagickFalse)
1704     (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
1705   status=OpenBlob(image_info,image,WriteBlobMode,exception);
1706   if (status == MagickFalse)
1707     return(status);
1708   file=GetBlobFileHandle(image);
1709   if (file == (FILE *) NULL)
1710     file=stdout;
1711   scene=0;
1712   do
1713   {
1714     if (scene == 0)
1715       (void) WriteBlobString(image,"[");
1716     image->magick_columns=image->columns;
1717     image->magick_rows=image->rows;
1718     (void) EncodeImageAttributes(image,file,exception);
1719     if (GetNextImageInList(image) == (Image *) NULL)
1720       {
1721         (void) WriteBlobString(image,"]");
1722         break;
1723       }
1724     (void) WriteBlobString(image,",\n");
1725     image=SyncNextImageInList(image);
1726     status=SetImageProgress(image,SaveImagesTag,scene++,
1727       GetImageListLength(image));
1728     if (status == MagickFalse)
1729       break;
1730   } while (image_info->adjoin != MagickFalse);
1731   (void) CloseBlob(image);
1732   return(MagickTrue);
1733 }