Changeset 3533

Timestamp:

05/28/09 03:54:35 (4 years ago)

Author:

sam

Message:

img2twit: change the position of the S component to help decompose points
for a forthcoming optimisation.

File:

• libpipi/trunk/examples/img2twit.cpp (modified) (11 diffs)

libpipi/trunk/examples/img2twit.cpp

@@ -110 +110 @@
 static unsigned int TOTAL_CELLS;
 
-#define RANGE_SY (RANGE_S*RANGE_Y)
-#define RANGE_SYX (RANGE_S*RANGE_Y*RANGE_X)
-#define RANGE_SYXR (RANGE_S*RANGE_Y*RANGE_X*RANGE_R)
-#define RANGE_SYXRG (RANGE_S*RANGE_Y*RANGE_X*RANGE_R*RANGE_G)
-#define RANGE_SYXRGB (RANGE_S*RANGE_Y*RANGE_X*RANGE_R*RANGE_G*RANGE_B)
+#define RANGE_XY (RANGE_Y*RANGE_X)
+#define RANGE_RXY (RANGE_Y*RANGE_X*RANGE_R)
+#define RANGE_GRXY (RANGE_Y*RANGE_X*RANGE_R*RANGE_G)
+#define RANGE_BGRXY (RANGE_Y*RANGE_X*RANGE_R*RANGE_G*RANGE_B)
+#define RANGE_SBGRXY (RANGE_Y*RANGE_X*RANGE_R*RANGE_G*RANGE_B*RANGE_S)
+#define RANGE_SBGR (RANGE_R*RANGE_G*RANGE_B*RANGE_S)
 
 struct K : CGAL::Exact_predicates_inexact_constructions_kernel {};
@@ -140 +141 @@
     DATA_BITS = TOTAL_BITS - HEADER_BITS;
 #if POINTS_PER_CELL == 1
-    CELL_BITS = logf(RANGE_SYXRGB) / logf(2);
+    CELL_BITS = logf(RANGE_SBGRXY) / logf(2);
 #else
     // TODO: implement the following shit
@@ -146 +147 @@
     //float other_bits = logf(RANGE_R * RANGE_G * RANGE_B * RANGE_S);
     //CELL_BITS = (coord_bits + 2 * other_bits) / logf(2);
-    CELL_BITS = 2 * logf(RANGE_SYXRGB) / logf(2);
+    CELL_BITS = 2 * logf(RANGE_SBGRXY) / logf(2);
 #endif
     TOTAL_CELLS = (int)(DATA_BITS / CELL_BITS);
@@ -510 +511 @@
     int ib = range2int(b, RANGE_B);
 
-    points[index] = is + RANGE_S * (iy + RANGE_Y * (ix + RANGE_X *
-                               (ib + RANGE_B * (ig + (RANGE_R * ir)))));
+    points[index] = iy + RANGE_Y * (ix + RANGE_X * (ib + RANGE_B *
+                      (ig + (RANGE_R * ir + (RANGE_S * is)))));
 }
 
@@ -521 +522 @@
 
     index2cell(index, &dx, &dy);
-
-    *s = int2fullrange(pt % RANGE_S, RANGE_S); pt /= RANGE_S;
 
     float fy = int2midrange(pt % RANGE_Y, RANGE_Y); pt /= RANGE_Y;
@@ -542 +541 @@
         *r = int2midrange(pt % RANGE_B, RANGE_B); pt /= RANGE_B;
     }
+
+    *s = int2fullrange(pt % RANGE_S, RANGE_S); pt /= RANGE_S;
 }
 
@@ -553 +554 @@
 static void add_random_point()
 {
-    points[npoints] = det_rand(RANGE_SYXRGB);
+    points[npoints] = det_rand(RANGE_SBGRXY);
     npoints++;
 }
@@ -587 +588 @@
         /* Statistics show that this helps often, but does not reduce
          * the error significantly. */
-        return val ^ 1;
+        rem = val % RANGE_BGRXY;
+        ext = val / RANGE_BGRXY;
+        ext ^= 1;
+        return ext * RANGE_BGRXY + rem;
     case 2: /* Move up; if impossible, down */
-        rem = val % RANGE_S;
-        ext = (val / RANGE_S) % RANGE_Y;
+        ext = val % RANGE_Y;
         ext = ext > 0 ? ext - 1 : ext + 1;
-        return (val / RANGE_SY * RANGE_Y + ext) * RANGE_S + rem;
+        return val / RANGE_Y * RANGE_Y + ext;
     case 3: /* Move down; if impossible, up */
-        rem = val % RANGE_S;
-        ext = (val / RANGE_S) % RANGE_Y;
+        ext = val % RANGE_Y;
         ext = ext < RANGE_Y - 1 ? ext + 1 : ext - 1;
-        return (val / RANGE_SY * RANGE_Y + ext) * RANGE_S + rem;
+        return val / RANGE_Y * RANGE_Y + ext;
     case 4: /* Move left; if impossible, right */
-        rem = val % RANGE_SY;
-        ext = (val / RANGE_SY) % RANGE_X;
+        rem = val % RANGE_Y;
+        ext = (val / RANGE_Y) % RANGE_X;
         ext = ext > 0 ? ext - 1 : ext + 1;
-        return (val / RANGE_SYX * RANGE_X + ext) * RANGE_SY + rem;
+        return (val / RANGE_XY * RANGE_X + ext) * RANGE_Y + rem;
     case 5: /* Move left; if impossible, right */
-        rem = val % RANGE_SY;
-        ext = (val / RANGE_SY) % RANGE_X;
+        rem = val % RANGE_Y;
+        ext = (val / RANGE_Y) % RANGE_X;
         ext = ext < RANGE_X - 1 ? ext + 1 : ext - 1;
-        return (val / RANGE_SYX * RANGE_X + ext) * RANGE_SY + rem;
+        return (val / RANGE_XY * RANGE_X + ext) * RANGE_Y + rem;
     case 6: /* Corner 1 */
         return apply_op(2, apply_op(4, val));
@@ -625 +627 @@
         return apply_op(5, apply_op(5, val));
     case 10: /* R-- (or R++) */
-        rem = val % RANGE_SYX;
-        ext = (val / RANGE_SYX) % RANGE_R;
+        rem = val % RANGE_XY;
+        ext = (val / RANGE_XY) % RANGE_R;
         ext = ext > 0 ? ext - 1 : ext + 1;
-        return (val / RANGE_SYXR * RANGE_R + ext) * RANGE_SYX + rem;
+        return (val / RANGE_RXY * RANGE_R + ext) * RANGE_XY + rem;
     case 11: /* R++ (or R--) */
-        rem = val % RANGE_SYX;
-        ext = (val / RANGE_SYX) % RANGE_R;
+        rem = val % RANGE_XY;
+        ext = (val / RANGE_XY) % RANGE_R;
         ext = ext < RANGE_R - 1 ? ext + 1 : ext - 1;
-        return (val / RANGE_SYXR * RANGE_R + ext) * RANGE_SYX + rem;
+        return (val / RANGE_RXY * RANGE_R + ext) * RANGE_XY + rem;
     case 12: /* G-- (or G++) */
-        rem = val % RANGE_SYXR;
-        ext = (val / RANGE_SYXR) % RANGE_G;
+        rem = val % RANGE_RXY;
+        ext = (val / RANGE_RXY) % RANGE_G;
         ext = ext > 0 ? ext - 1 : ext + 1;
-        return (val / RANGE_SYXRG * RANGE_G + ext) * RANGE_SYXR + rem;
+        return (val / RANGE_GRXY * RANGE_G + ext) * RANGE_RXY + rem;
     case 13: /* G++ (or G--) */
-        rem = val % RANGE_SYXR;
-        ext = (val / RANGE_SYXR) % RANGE_G;
+        rem = val % RANGE_RXY;
+        ext = (val / RANGE_RXY) % RANGE_G;
         ext = ext < RANGE_G - 1 ? ext + 1 : ext - 1;
-        return (val / RANGE_SYXRG * RANGE_G + ext) * RANGE_SYXR + rem;
+        return (val / RANGE_GRXY * RANGE_G + ext) * RANGE_RXY + rem;
     case 14: /* B-- (or B++) */
-        rem = val % RANGE_SYXRG;
-        ext = (val / RANGE_SYXRG) % RANGE_B;
+        rem = val % RANGE_GRXY;
+        ext = (val / RANGE_GRXY) % RANGE_B;
         ext = ext > 0 ? ext - 1 : ext + 1;
-        return ext * RANGE_SYXRG + rem;
+        return (val / RANGE_BGRXY * RANGE_B + ext) * RANGE_GRXY + rem;
     case 15: /* B++ (or B--) */
-        rem = val % RANGE_SYXRG;
-        ext = (val / RANGE_SYXRG) % RANGE_B;
+        rem = val % RANGE_GRXY;
+        ext = (val / RANGE_GRXY) % RANGE_B;
         ext = ext < RANGE_B - 1 ? ext + 1 : ext - 1;
-        return ext * RANGE_SYXRG + rem;
+        return (val / RANGE_BGRXY * RANGE_B + ext) * RANGE_GRXY + rem;
 #if 0
     case 15: /* Brightness-- */
@@ -1269 +1271 @@
 
         /* Push our points to the bitstream */
-        for(int i = 0; i < npoints; i++)
-            b.push(points[i], RANGE_SYXRGB);
+        for(int i = 0; i < npoints; i += POINTS_PER_CELL)
+        {
+#if POINTS_PER_CELL == 2
+            b.push(points[i] / RANGE_XY, RANGE_SBGR);
+            b.push(points[i] % RANGE_XY, RANGE_XY);
+            b.push(points[i + 1] / RANGE_XY, RANGE_SBGR);
+            b.push(points[i + 1] % RANGE_XY, RANGE_XY);
+#else
+            b.push(points[i], RANGE_SBGRXY);
+#endif
+        }
         b.push(height - 1, RANGE_H);
         b.push(width - 1, RANGE_W);
@@ -1285 +1296 @@
         {
 #if POINTS_PER_CELL == 2
-            points[i * 2 + 1] = b.pop(RANGE_SYXRGB);
-            points[i * 2] = b.pop(RANGE_SYXRGB);
+            uint32_t c1 = b.pop(RANGE_XY);
+            uint32_t p1 = b.pop(RANGE_SBGR);
+            uint32_t c2 = b.pop(RANGE_XY);
+            uint32_t p2 = b.pop(RANGE_SBGR);
+            points[i * 2 + 1] = p1 * RANGE_XY + c1;
+            points[i * 2] = p2 * RANGE_XY + c2;
 #else
-            points[i] = b.pop(RANGE_SYXRGB);
+            points[i] = b.pop(RANGE_SBGRXY);
 #endif
         }