DissolveSampleGenerator.cpp

Go to the documentation of this file.

/**<!-------------------------------------------------------------------->
   @file   DissolveSampleGenerator.h
   @author Travis Fischer (fisch0920@gmail.com)
   @date   Fall 2008
   
   @brief
      Cool dissolve effect which generates point samples uniformly over a 
   given 2D domain. The order in which the samples are generated looks random, 
   but it is actually quite deterministic and guaranteed to "visit" every 
   bucket in the domain.
   <!-------------------------------------------------------------------->**/

#include "DissolveSampleGenerator.h"
#include <QtCore>

template <class SG>
void DissolveSG<SG>::generate(PointSampleList &outSamples, 
                              const Viewport &viewport)
{
#if 0
   const unsigned width   = viewport.getWidth();
   const unsigned height  = viewport.getHeight();
   
   const real_t binWidth  = viewport.getInvWidth();
   const real_t binHeight = viewport.getInvHeight();
   const unsigned size    = width * height;
   
   unsigned randMasks[sizeof(int)];
   for(unsigned i = sizeof(int); i--;)
      randMasks[i] = (3 << i);
   
   const unsigned mask = randMasks[_getBitWidth(width * height - 1)];
   unsigned seq = 1;
   
   SG::_addSample(PointSample(0, 0), outSamples);
   unsigned count = 1;
   
   do {
      const real_t y = 0 + (seq / width);
      const real_t x = 0 + (seq % width);
      
      SG::_addSample(PointSample(x, y), outSamples);
      ++count;
      
      do {
         if (seq & 1)
            seq = (seq >> 1) ^ mask;
         else seq >>= 1;
      } while(seq >= size);
      
      /*do {
         seq = (seq >> 1) ^ ((seq & 1) * mask);
      } while(seq >= size);*/
   } while(seq != 1);  // Loop
   
   cerr << width << ", " << height << endl;
   cerr << count << " vs " << width * height << endl;
   ASSERT(count == width * height);
#endif
}

#if 0
/* A Digital Dissolve Effect
   by Mike Morton
   from "Graphics Gems", Academic Press, 1990

   user must provide copy() function.
*/

/*
 * Code fragment to advance from one element to the next.
 *
 * int reg;          // current sequence element
 * reg = 1;          // start in any non-zero state
 * if (reg & 1)            // is the bottom bit set?
 *    reg = (reg >>1) ^ MASK;    // yes: toss out 1 bit; XOR in mask
 * else reg = reg >>1;        // no: toss out 0 bit 
 */

int randmasks[32];   /* Gotta fill this in yourself. */

void dissolve1 (int height, int width) {
   int pixels, lastnum; /* number of pixels; */
   /* last pixel's number */
   int regwidth;     /* "width" of sequence generator */
   register long mask;  /* mask to XOR with to*/
   /* create sequence */
   register unsigned long element; 
   /* one element of random sequence */
   register int row, column;
   /* row and column numbers for a pixel */

   /* Find smallest register which produces enough pixel numbers */
   pixels = height * width; /* compute number of pixels */
   /* to dissolve */
   lastnum = pixels-1;  /* find last element (they go 0..lastnum) */
   regwidth = bitwidth ((unsigned int)lastnum); /* how wide must the */
   /* register be? */
   mask = randmasks [regwidth];  /* which mask is for that width? */

   /* Now cycle through all sequence elements. */

   element = 1;   /* 1st element (could be any nonzero) */

   do {
      row = element / width;  /* how many rows down is this pixel? */
      column = element % width;  /* and how many columns across? */
      if (row < height) /* is this seq element in the array? */
         copy (row, column);  /* yes: copy the (r,c)'th pixel */

      /* Compute the next sequence element */
      if (element & 1)     /* is the low bit set? */
         element = (element >>1)^mask; /* yes: shift value, */
      /* XOR in mask */
      else element = (element >> 1);   /* no: just shift the value */
   } while (element != 1);    /* loop until we return  */
   
   /* to original element */
   copy (0, 0);      /* kludge: the loop doesn't produce (0,0) */
}

#endif


// force explicit template specialization of DissolveSampleGenerator and 
// DissolveSampleGeneratorThread
#include <generators.h>
DECLARE_SAMPLE_GENERATOR(Dissolve);