Changeset 2212 for www/labsTweet

Timestamp:

Jan 23, 2008, 12:32:01 AM (15 years ago)

Author:

Sam Hocevar

Message:

• Add support for inverse video on attribute change.
• Improve Floyd-Steinberg coefficient values.

Location:

www/labs

Files:

• img2oric.c (modified) (12 diffs)
• img2oric.html (modified) (4 diffs)
• output-bb.png (modified) (previous)
• output-bear.gif (modified) (previous)
• output-bufbw.png (modified) (previous)
• output-buffy.png (modified) (previous)
• output-dog.png (modified) (previous)
• output-eatme.png (modified) (previous)
• output-homer.png (modified) (previous)
• output-lena.png (modified) (previous)
• output-mire.png (modified) (previous)

www/labs/img2oric.c

@@ -5 +5 @@
  *
  *  $Id$
+ *
+ *  Changes:
+ *   Jan 18, 2008: initial release
+ *   Jan 23, 2008: add support for inverse video on attribute change
+ *                 improve Floyd-Steinberg coefficient values
  *
  *  This program is free software. It comes without any warranty, to
@@ -28 +33 @@
 /*
  * Image dimensions and recursion depth. DEPTH = 2 is a reasonable value,
- * higher values may improve the results but at the cost of significantly
- * longer computation times.
+ * DEPTH = 3 gives good quality, and higher values may improve the results
+ * even more but at the cost of significantly longer computation times.
  */
 #define WIDTH 240
@@ -52 +57 @@
  *     +-------+-------+-------+
  */
-#define FS0 12
+#define FS0 15
 #define FS1 6
-#define FS2 12
+#define FS2 9
 #define FS3 1
 #define FSX 32
@@ -114 +119 @@
 static inline void domove(uint8_t move, uint8_t *bg, uint8_t *fg)
 {
-    if(move < 8)
-        *bg = move;
-    else if(move < 16)
-        *fg = move - 8;
+    if(move < 16)
+        *fg = move & 0x7;
+    else if(move < 32)
+        *bg = move & 0x7;
+}
+
+/*
+ * Clamp pixel value to avoid colour bleeding. Deactivated because it
+ * does not give satisfactory results.
+ */
+#define CLAMP 0x1000
+static inline int clamp(int p)
+{
+#if 0
+    /* FIXME: doesn’t give terribly good results on eg. eatme.png */
+    if(p < - CLAMP) return - CLAMP;
+    if(p > 0xffff + CLAMP) return 0xffff + CLAMP;
+#endif
+    return p;
 }
 
@@ -144 +164 @@
         {
             /* Experiment shows that this is important at small depths */
-            int a = in[i * 3 + c] + tmperr[c];
+            int a = clamp(in[i * 3 + c] + tmperr[c]);
             int b = out[i * 3 + c];
             tmperr[c] = (a - b) * FS0 / FSX;
@@ -182 +202 @@
                         int *error, int *out)
 {
-    int voidvec[3], bestrgb[6 * 3], tmprgb[6 * 3], tmpvec[3];
-    int const *voidrgb, *vec, *rgb;
-    int besterror, curerror, suberror, statice, voide;
+    int voidvec[3], nvoidvec[3], bestrgb[6 * 3], tmprgb[6 * 3], tmpvec[3];
+    int const *voidrgb, *nvoidrgb, *vec, *rgb;
+    int besterror, curerror, suberror, statice, voide, nvoide;
     int i, c;
     uint8_t command, bestcommand;
 
-    /* Precompute error for the case where we don’t print pixels */
+    /* Precompute error for the case where we change the foreground colour
+     * and hence only print the background colour or its negative */
     voidrgb = palette[bg];
     voide = geterror(in, errvec, voidrgb, voidvec);
+    nvoidrgb = palette[7 - bg];
+    nvoide = geterror(in, errvec, nvoidrgb, nvoidvec);
 
     /* Precompute sub-error for the case where we print pixels (and hence
@@ -202 +225 @@
 
     /* Check every likely command:
-     * 0-7: change background to 0-7
-     * 8-15: change foreground to 0-7
-     * 16: normal stuff
-     * 17: inverse video stuff */
+     * 0-7: change foreground to 0-7
+     * 8-15: change foreground to 0-7, print negative background
+     * 16-23: change background to 0-7
+     * 24-31: change background to 0-7, print negative background
+     * 32: normal stuff
+     * 33: inverse video stuff */
     besterror = 0x7ffffff;
     bestcommand = 16;
     memcpy(bestrgb, voidrgb, 6 * 3 * sizeof(int));
-    for(command = 0; command < 18; command++)
-    {
-        if(command < 16)
+    for(command = 0; command < 34; command++)
+    {
+        uint8_t newbg = bg, newfg = fg;
+        domove(command, &newbg, &newfg);
+
+        /* Keeping bg and fg is useless, because we could use commands
+         * 32 and 33 instead */
+        if(command < 32 && newbg == bg && newfg == fg)
+            continue;
+
+        /* I *think* having newfg == newbg is useless, too, but I don’t
+         * want to miss some corner case where swapping bg and fg may be
+         * interesting, so we continue anyway. */
+
+        if(command < 8)
         {
             curerror = voide;
@@ -217 +254 @@
             vec = voidvec;
         }
+        else if(command < 16)
+        {
+            curerror = nvoide;
+            rgb = nvoidrgb;
+            vec = nvoidvec;
+        }
+        else if(command < 24)
+        {
+            rgb = palette[newbg];
+            curerror = geterror(in, errvec, rgb, tmpvec);
+            vec = tmpvec;
+        }
+        else if(command < 32)
+        {
+            rgb = palette[7 - newbg];
+            curerror = geterror(in, errvec, rgb, tmpvec);
+            vec = tmpvec;
+        }
         else
         {
             int const *bgcolor, *fgcolor;
 
-            bgcolor = palette[bg + (command - 16) * (7 - 2 * bg)];
-            fgcolor = palette[fg + (command - 16) * (7 - 2 * fg)];
+            if(command == 32)
+            {
+                bgcolor = palette[bg]; fgcolor = palette[fg];
+            }
+            else
+            {
+                bgcolor = palette[7 - bg]; fgcolor = palette[7 - fg];
+            }
 
             memcpy(tmpvec, errvec, 3 * sizeof(int));
@@ -237 +298 @@
                 {
                     int delta1, delta2;
-                    delta1 = in[i * 3 + c] + tmpvec[c] - bgcolor[c];
+                    delta1 = clamp(in[i * 3 + c] + tmpvec[c]) - bgcolor[c];
                     vec1[c] = delta1 * FS0 / FSX;
                     smalle1 += delta1 / 256 * delta1;
-                    delta2 = in[i * 3 + c] + tmpvec[c] - fgcolor[c];
+                    delta2 = clamp(in[i * 3 + c] + tmpvec[c]) - fgcolor[c];
                     vec2[c] = delta2 * FS0 / FSX;
                     smalle2 += delta2 / 256 * delta2;
@@ -274 +335 @@
         if(depth == 0)
             suberror = 0; /* It’s the end of the tree */
-        else if(command < 16)
-        {
-            uint8_t newbg = bg, newfg = fg;
-            domove(command, &newbg, &newfg);
-            /* Keeping bg and fg is useless, because we could use commands
-             * 16 and 17 instead */
-            if(newbg == bg && newfg == fg)
-                continue;
-
+        else if(command < 32)
+        {
             bestmove(in + 6 * 3, newbg, newfg, vec, depth - 1,
                      besterror - curerror, &suberror, NULL);
 
+#if 0
             /* Penalty for background changes; they're hard to revert. The
              * value of 2 was determined empirically. 1.5 is not enough and
@@ -291 +346 @@
             if(newbg != bg)
                 suberror *= 2;
+#endif
         }
         else
@@ -373 +429 @@
                 {
                     int error = srcl[i * 3 + c] - dstl[i * 3 + c];
-                    srcl[i * 3 + c + 3] += error * FS0 / FSX;
+                    srcl[i * 3 + c + 3] =
+                            clamp(srcl[i * 3 + c + 3] + error * FS0 / FSX);
                     srcl[i * 3 + c + stride - 3] += error * FS1 / FSX;
                     srcl[i * 3 + c + stride] += error * FS2 / FSX;
                     srcl[i * 3 + c + stride + 3] += error * FS3 / FSX;
                 }
+
+                for(i = -1; i < 7; i++)
+                    srcl[i * 3 + c + stride] = clamp(srcl[i * 3 + c + stride]);
             }
             /* Iterate */

www/labs/img2oric.html

@@ -31 +31 @@
 
 <p> The graphical part of the Oric screen has 240×200 pixels and can only
-display 8 different colours (black, blue, red, green, cyan, magenta, yellow and
-white). Each horizontal group of 6 pixels can only use two different colours:
-either the foreground and the background colours, or the negative values
-thereof. The background <i>or</i> the foreground colour may also be changed
-(one at a time), but while doing so the next 6 pixels cannot be chosen: they
-will use the background colour instead. </p>
+display 8 different colours (black, blue, red, green, cyan, magenta, yellow
+and white). Each horizontal group of 6 pixels can only use two different
+colours: the foreground and the background colours. The background <i>or</i>
+the foreground colour may also be changed (one at a time), but while doing
+so the next 6 pixels cannot be chosen: they will use the background colour
+instead. Finally, a special bit may be activated to display the current group
+of pixels in reverse video. </p>
 
 <h2 style="clear: both;"> Downloads </h2>
@@ -42 +43 @@
 <p> No downloads are available yet. However, the file <tt><a
 href="img2oric.c">img2oric.c</a></tt> may be compiled on Linux to obtain an
-almost functional, yet extremely slow (around 1 minute to process an image on a
-modern computer) program. </p>
+almost functional, yet extremely slow (around 2 minutes to process an image on
+a modern computer) program. </p>
 
 <h2> Screenshots </h2>
@@ -89 +90 @@
 
 <p> The following images use real Oric artwork, taken from the Buggy Boy
-and the VIP 4 demos. As can be seen, the result is not perfect, but is still
-rather acceptable. </p>
+and the VIP 4 demos: they are almost pixel-perfect. </p>
 
 <p style="text-align: center;">
@@ -110 +110 @@
 </p>
 
+<h2> Credits </h2>
+
+<p> <tt>img2oric</tt> was written by Sam Hocevar. Thanks to Jean-Yves
+Lamoureux, Mickaël Pointier, Robert Chéramy and Fabrice Frances for their
+help, their work and the information they provided. </p>
+
 <?php $rev = '$Id$';
       include($_SERVER['DOCUMENT_ROOT'].'/footer.inc'); ?>