home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 October / usenetsourcesnewsgroupsinfomagicoctober1994disk2.iso / misc / volume34 / imagemagick / patch02 / fix-02
Encoding:
Text File  |  1992-12-27  |  11.2 KB  |  435 lines
  1. diff -r -c ImageMagick/ChangeLog ImageMagick2.2.2/ChangeLog
  2. *** ImageMagick/ChangeLog    Mon Dec 21 14:12:35 1992
  3. --- ImageMagick2.2.2/ChangeLog    Tue Dec 22 16:07:20 1992
  4. ***************
  5. *** 1,3 ****
  6. --- 1,14 ----
  7. + ImageMagick 2.2.2
  8. + 
  9. +   o Dithering did not work properly on the Cray (due to right shift problem).
  10. + 
  11. +   o In most cases dithering requires 1/2 as much memory as previously.
  12. + 
  13. +   o Dithering was sped up by ~15%.
  14. + 
  15. +   o Occasionally the quantization error was reported incorrectly.
  16. + 
  17. + 
  18.   ImageMagick 2.2.1
  19.   
  20.     o The number of colors reported with the -verbose option was on
  21. diff -r -c ImageMagick/X.c ImageMagick2.2.2/X.c
  22. *** ImageMagick/X.c    Mon Dec 21 14:12:34 1992
  23. --- ImageMagick2.2.2/X.c    Tue Dec 22 16:06:18 1992
  24. ***************
  25. *** 1283,1291 ****
  26.     /*
  27.       Initialize annotated image.
  28.     */
  29. !   if (image->packets != (image->columns*image->rows))
  30. !     if (!UncompressImage(image))
  31. !       return(False);
  32.     /*
  33.       Initialize annotated pixmap.
  34.     */
  35. --- 1283,1290 ----
  36.     /*
  37.       Initialize annotated image.
  38.     */
  39. !   if (!UncompressImage(image))
  40. !     return(False);
  41.     /*
  42.       Initialize annotated pixmap.
  43.     */
  44. diff -r -c ImageMagick/display.h ImageMagick2.2.2/display.h
  45. *** ImageMagick/display.h    Tue Dec 22 16:23:13 1992
  46. --- ImageMagick2.2.2/display.h    Tue Dec 22 16:23:32 1992
  47. ***************
  48. *** 51,55 ****
  49.   */
  50.   #ifndef lint
  51.   static char 
  52. !   Version[]="@(#)ImageMagick 2.2.1 92/12/10 cristy@dupont.com";
  53.   #endif
  54. --- 51,55 ----
  55.   */
  56.   #ifndef lint
  57.   static char 
  58. !   Version[]="@(#)ImageMagick 2.2.2 92/12/22 cristy@dupont.com";
  59.   #endif
  60. diff -r -c ImageMagick/image.c ImageMagick2.2.2/image.c
  61. *** ImageMagick/image.c    Fri Dec 18 17:07:28 1992
  62. --- ImageMagick2.2.2/image.c    Tue Dec 22 16:06:19 1992
  63. ***************
  64. *** 731,739 ****
  65.     /*
  66.       Image must be uncompressed.
  67.     */
  68. !   if (image->packets != (image->columns*image->rows))
  69. !     if (!UncompressImage(image))
  70. !       return;
  71.     if (!image->alpha)
  72.       {
  73.         /*
  74. --- 731,738 ----
  75.     /*
  76.       Image must be uncompressed.
  77.     */
  78. !   if (!UncompressImage(image))
  79. !     return;
  80.     if (!image->alpha)
  81.       {
  82.         /*
  83. ***************
  84. *** 5190,5195 ****
  85. --- 5189,5196 ----
  86.     RunlengthPacket
  87.       *uncompressed_pixels;
  88.   
  89. +   if (image->packets == (image->columns*image->rows))
  90. +     return(True);
  91.     /*
  92.       Uncompress runlength-encoded packets.
  93.     */
  94. Common subdirectories: ImageMagick/images and ImageMagick2.2.2/images
  95. diff -r -c ImageMagick/quantize.c ImageMagick2.2.2/quantize.c
  96. *** ImageMagick/quantize.c    Mon Dec 21 11:12:00 1992
  97. --- ImageMagick2.2.2/quantize.c    Tue Dec 22 16:06:18 1992
  98. ***************
  99. *** 745,753 ****
  100.         blue;
  101.     } ScaledColorPacket;
  102.   
  103. -   Image
  104. -     *dithered_image;
  105. - 
  106.     int
  107.       *cache,
  108.       odd_scanline;
  109. --- 745,750 ----
  110. ***************
  111. *** 769,786 ****
  112.       *cs,
  113.       *ns;
  114.   
  115.     register unsigned int
  116.       id;
  117.   
  118. -   register unsigned short
  119. -     index;
  120. - 
  121.     ScaledColorPacket
  122.       *scanline;
  123.   
  124.     unsigned char
  125. !     *range_limit,
  126. !     *range_table;
  127.   
  128.     unsigned int
  129.       i,
  130. --- 766,785 ----
  131.       *cs,
  132.       *ns;
  133.   
  134. +   register unsigned char
  135. +     *range_limit;
  136. + 
  137.     register unsigned int
  138.       id;
  139.   
  140.     ScaledColorPacket
  141.       *scanline;
  142.   
  143.     unsigned char
  144. !     blue,
  145. !     green,
  146. !     *range_table,
  147. !     red;
  148.   
  149.     unsigned int
  150.       i,
  151. ***************
  152. *** 787,803 ****
  153.       x,
  154.       y;
  155.   
  156.     /*
  157. !     Initialize dithered image attributes.
  158.     */
  159. !   image->orphan=True;
  160. !   dithered_image=CopyImage(image,image->columns,image->rows,False);
  161. !   image->orphan=False;
  162. !   if (dithered_image == (Image *) NULL)
  163. !     {
  164. !       Warning("unable to dither image","memory allocation failed");
  165. !       return(True);
  166. !     }
  167.     /*
  168.       Allocate the cache & scanline buffers to keep track of quantization error.
  169.     */
  170. --- 786,800 ----
  171.       x,
  172.       y;
  173.   
  174. +   unsigned short
  175. +     index;
  176. + 
  177.     /*
  178. !     Image must be uncompressed.
  179.     */
  180. !   if (!UncompressImage(image))
  181. !     return(True);
  182. !   image->compression=NoCompression;
  183.     /*
  184.       Allocate the cache & scanline buffers to keep track of quantization error.
  185.     */
  186. ***************
  187. *** 827,846 ****
  188.       Preload first scanline.
  189.     */
  190.     p=image->pixels;
  191. -   image->runlength=p->length+1;
  192.     cs=scanline+1;
  193.     for (i=0; i < image->columns; i++)
  194.     {
  195. -     if (image->runlength > 0)
  196. -       image->runlength--;
  197. -     else
  198. -       {
  199. -         p++;
  200. -         image->runlength=p->length;
  201. -       }
  202.       cs->red=p->red;
  203.       cs->green=p->green;
  204.       cs->blue=p->blue;
  205.       cs++;
  206.     }
  207.     odd_scanline=False;
  208. --- 824,836 ----
  209.       Preload first scanline.
  210.     */
  211.     p=image->pixels;
  212.     cs=scanline+1;
  213.     for (i=0; i < image->columns; i++)
  214.     {
  215.       cs->red=p->red;
  216.       cs->green=p->green;
  217.       cs->blue=p->blue;
  218. +     p++;
  219.       cs++;
  220.     }
  221.     odd_scanline=False;
  222. ***************
  223. *** 856,871 ****
  224.             ns+=(image->columns+2);
  225.           for (i=0; i < image->columns; i++)
  226.           {
  227. -           if (image->runlength > 0)
  228. -             image->runlength--;
  229. -           else
  230. -             {
  231. -               p++;
  232. -               image->runlength=p->length;
  233. -             }
  234.             ns->red=p->red;
  235.             ns->green=p->green;
  236.             ns->blue=p->blue;
  237.             ns++;
  238.           }
  239.         }
  240. --- 846,855 ----
  241.             ns+=(image->columns+2);
  242.           for (i=0; i < image->columns; i++)
  243.           {
  244.             ns->red=p->red;
  245.             ns->green=p->green;
  246.             ns->blue=p->blue;
  247. +           p++;
  248.             ns++;
  249.           }
  250.         }
  251. ***************
  252. *** 874,880 ****
  253.           /*
  254.             Distribute error left-to-right for even scanlines.
  255.           */
  256. !         q=dithered_image->pixels+image->columns*y;
  257.           cs=scanline+1;
  258.           ns=scanline+(image->columns+2)+1;
  259.           step=1;
  260. --- 858,864 ----
  261.           /*
  262.             Distribute error left-to-right for even scanlines.
  263.           */
  264. !         q=image->pixels+image->columns*y;
  265.           cs=scanline+1;
  266.           ns=scanline+(image->columns+2)+1;
  267.           step=1;
  268. ***************
  269. *** 884,890 ****
  270.           /*
  271.             Distribute error right-to-left for odd scanlines.
  272.           */
  273. !         q=dithered_image->pixels+image->columns*y+(image->columns-1);
  274.           cs=scanline+(image->columns+2)+(image->columns-1)+1;
  275.           ns=scanline+(image->columns-1)+1;
  276.           step=(-1);
  277. --- 868,874 ----
  278.           /*
  279.             Distribute error right-to-left for odd scanlines.
  280.           */
  281. !         q=image->pixels+image->columns*y+(image->columns-1);
  282.           cs=scanline+(image->columns+2)+(image->columns-1)+1;
  283.           ns=scanline+(image->columns-1)+1;
  284.           step=(-1);
  285. ***************
  286. *** 891,900 ****
  287.         }
  288.       for (x=0; x < image->columns; x++)
  289.       {
  290. !       q->red=range_limit[cs->red];
  291. !       q->green=range_limit[cs->green];
  292. !       q->blue=range_limit[cs->blue];
  293. !       i=(q->red >> 2) << 12 | (q->green >> 2) << 6 | q->blue >> 2;
  294.         if (cache[i] < 0)
  295.           {
  296.             /*
  297. --- 875,884 ----
  298.         }
  299.       for (x=0; x < image->columns; x++)
  300.       {
  301. !       red=range_limit[cs->red];
  302. !       green=range_limit[cs->green];
  303. !       blue=range_limit[cs->blue];
  304. !       i=(red >> 2) << 12 | (green >> 2) << 6 | blue >> 2;
  305.         if (cache[i] < 0)
  306.           {
  307.             /*
  308. ***************
  309. *** 903,911 ****
  310.             node=cube.root;
  311.             for ( ; ; )
  312.             {
  313. !             id=(q->red > node->mid_red ? 1 : 0) |
  314. !               (q->green > node->mid_green ? 1 : 0) << 1 |
  315. !               (q->blue > node->mid_blue ? 1 : 0) << 2;
  316.               if ((node->children & (1 << id)) == 0)
  317.                 break;
  318.               node=node->child[id];
  319. --- 887,895 ----
  320.             node=cube.root;
  321.             for ( ; ; )
  322.             {
  323. !             id=(red > node->mid_red ? 1 : 0) |
  324. !               (green > node->mid_green ? 1 : 0) << 1 |
  325. !               (blue > node->mid_blue ? 1 : 0) << 2;
  326.               if ((node->children & (1 << id)) == 0)
  327.                 break;
  328.               node=node->child[id];
  329. ***************
  330. *** 913,931 ****
  331.             /*
  332.               Find closest color among siblings and their children.
  333.             */
  334. !           cube.color.red=q->red;
  335. !           cube.color.green=q->green;
  336. !           cube.color.blue=q->blue;
  337.             cube.distance=(~0);
  338.             ClosestColor(node->parent);
  339.             cache[i]=cube.color_number;
  340.           }
  341.         index=(unsigned short) cache[i];
  342. !       red_error=(int) q->red-(int) cube.colormap[index].red;
  343. !       green_error=(int) q->green-(int) cube.colormap[index].green;
  344. !       blue_error=(int) q->blue-(int) cube.colormap[index].blue;
  345.         q->index=index;
  346. -       q->length=0;
  347.         q+=step;
  348.         /*
  349.           Propagate the error in these proportions:
  350. --- 897,914 ----
  351.             /*
  352.               Find closest color among siblings and their children.
  353.             */
  354. !           cube.color.red=red;
  355. !           cube.color.green=green;
  356. !           cube.color.blue=blue;
  357.             cube.distance=(~0);
  358.             ClosestColor(node->parent);
  359.             cache[i]=cube.color_number;
  360.           }
  361.         index=(unsigned short) cache[i];
  362. !       red_error=(int) red-(int) cube.colormap[index].red;
  363. !       green_error=(int) green-(int) cube.colormap[index].green;
  364. !       blue_error=(int) blue-(int) cube.colormap[index].blue;
  365.         q->index=index;
  366.         q+=step;
  367.         /*
  368.           Propagate the error in these proportions:
  369. ***************
  370. *** 933,953 ****
  371.             3/16  5/16  1/16
  372.         */
  373.         cs+=step;
  374. !       cs->red+=red_error-((red_error*9+8) >> 4);
  375. !       cs->green+=green_error-((green_error*9+8) >> 4);
  376. !       cs->blue+=blue_error-((blue_error*9+8) >> 4);
  377.         ns-=step;
  378. !       ns->red+=(red_error*3+8) >> 4;
  379. !       ns->green+=(green_error*3+8) >> 4;
  380. !       ns->blue+=(blue_error*3+8) >> 4;
  381.         ns+=step;
  382. !       ns->red+=(red_error*5+8) >> 4;
  383. !       ns->green+=(green_error*5+8) >> 4;
  384. !       ns->blue+=(blue_error*5+8) >> 4;
  385.         ns+=step;
  386. !       ns->red+=(red_error+8) >> 4;
  387. !       ns->green+=(green_error+8) >> 4;
  388. !       ns->blue+=(blue_error+8) >> 4;
  389.       }
  390.       odd_scanline=!odd_scanline;
  391.     }
  392. --- 916,936 ----
  393.             3/16  5/16  1/16
  394.         */
  395.         cs+=step;
  396. !       cs->red+=(red_error-((red_error*9+8)/16));
  397. !       cs->green+=(green_error-((green_error*9+8)/16));
  398. !       cs->blue+=(blue_error-((blue_error*9+8)/16));
  399.         ns-=step;
  400. !       ns->red+=(red_error*3+8)/16;
  401. !       ns->green+=(green_error*3+8)/16;
  402. !       ns->blue+=(blue_error*3+8)/16;
  403.         ns+=step;
  404. !       ns->red+=(red_error*5+8)/16;
  405. !       ns->green+=(green_error*5+8)/16;
  406. !       ns->blue+=(blue_error*5+8)/16;
  407.         ns+=step;
  408. !       ns->red+=(red_error+8)/16;
  409. !       ns->green+=(green_error+8)/16;
  410. !       ns->blue+=(blue_error+8)/16;
  411.       }
  412.       odd_scanline=!odd_scanline;
  413.     }
  414. ***************
  415. *** 957,968 ****
  416.     (void) free((char *) scanline);
  417.     (void) free((char *) range_table);
  418.     (void) free((char *) cache);
  419. -   (void) free((char *) image->pixels);
  420. -   image->packets=dithered_image->packets;
  421. -   image->pixels=dithered_image->pixels;
  422. -   dithered_image->file=(FILE *) NULL;
  423. -   dithered_image->pixels=(RunlengthPacket *) NULL;
  424. -   DestroyImage(dithered_image);
  425.     return(False);
  426.   }
  427.   
  428. --- 940,945 ----
  429. Common subdirectories: ImageMagick/scenes and ImageMagick2.2.2/scenes
  430. Common subdirectories: ImageMagick/utilities and ImageMagick2.2.2/utilities
  431. Common subdirectories: ImageMagick/xtp and ImageMagick2.2.2/xtp
  432. -- 
  433. cristy@dupont.com
  434.  
  435.