HilbertCoordinateMapper.h

Go to the documentation of this file.

/*
 *  Copyright (C) 2007  A.N. Yzelman
 *  Released under LGPL, see license.txt
 *
 *  Last modified at 23th of May, 2007, by A.N. Yzelman
 *
 *  HilbertCoordinateMapper.h: utility functions for calculating hilbert curve coordinates.
 *
 */


#ifndef _H_HilbertCoordinateMapper
#define _H_HilbertCoordinateMapper

#define RECURSE_LEVEL 3

#include <cmath>
#include <vector>
#include "boost/multi_array.hpp"
#include "boost/array.hpp"

using namespace std;
using namespace boost;

class HilbertCoordinateMapper {
   public:
        HilbertCoordinateMapper(){};


   private:
   
    static void makeVec( const double x, const double y, vector< double > *where );

    static void makeVec( const double x, const double y, const double z, vector< double > *where );
   
        static void mid( const vector< double > *x, const vector< double > *y, vector< double > *to );

        static void mid3D( unsigned int pos, unsigned int i, unsigned int j );

        static double dist( const vector< double > *x, const vector< double > *y, const unsigned int dim );

        static double dist3D( const vector< double > *x, const unsigned int i );

        static unsigned int closestTo( const vector< double > *coor, const vector< vector< double > > *corners, const unsigned int dim );

        static unsigned int closestTo3D( const vector< double > *coor );

        static void refineCoors2D( vector< vector< double > > *corners, const unsigned int cell );
        
        static void refineCoors3D( const unsigned int cell );

        static double base8_to_base10( const vector< unsigned int > *digits ) {
                return base_n_to_base10< 8 >( digits );
        }
        
        static double base4_to_base10( const vector< unsigned int > *digits ) {
                return base_n_to_base10< 4 >( digits );
        }

        template< const unsigned int base >
        static double base_n_to_base10( const vector< unsigned int > *digits ) {
                const unsigned int numdigits = digits->size();
                double ret = 0;
                unsigned int deler = 1;
                //unsigned int multiplicant = 1;
        
                for( unsigned int i = 0; i < numdigits; i++ ) {
                        const unsigned int noemer = (*digits)[ i ];
                        //ret += ( ( double ) noemer ) * ( ( double ) multiplicant );
                        //multiplicant *= ( unsigned int )base;
                        deler *= ( unsigned int )base;
                        ret += ( ( double ) noemer ) / ( ( double ) deler );
                }
        
                return ret;
        }

   protected:
        typedef boost::multi_array<double, 2 > array_type;   
    static array_type Box_3D;
    static array_type Box_3Dtemp;
        static array_type pattern;

        static array_type makePattern() {
                double pattern[8][3] = {        {0,0,0}, 
                                                                        {1,0,0},
                                                                        {1,0,1},
                                                                        {0,0,1},
                                                                        {0,1,1},
                                                                        {1,1,1},
                                                                        {1,1,0},
                                                                        {0,1,0}
                                                                };

                array_type ret(extents[8][3]);
                for( unsigned int i=0; i<8; i++ )
                        for( unsigned int j=0; j<3; j++ )
                                ret[i][j] = pattern[i][j];

                return ret;
        }


   public:

        static double toHilbert2D( const vector< double > *coordinates );

        static double toHilbert3D( const vector< double > *coordinates );

};

#endif

---