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