/Users/jab/Documents/Teaching/02585/GEL2_and_demos/GEL/src/Geometry/ThreeDDDA.h

#ifndef __GEOMETRY_THREEDDDA_H
#define __GEOMETRY_THREEDDDA_H

#ifdef _MSC_VER 
typedef __int64 Integer64Bits;
#else
typedef int64_t Integer64Bits;
#endif


#include "CGLA/Vec3f.h"
#include "CGLA/Vec3i.h"

namespace Geometry
{


        class ThreeDDDA
        {
                const int PRECISION;

                const CGLA::Vec3i sgn;

                const CGLA::Vec3i p0_int;

                // Fine grid position where the ray ends.
                const CGLA::Vec3i p1_int;

                const CGLA::Vec3i dir;

                const CGLA::Vec3i first_cell;

                const CGLA::Vec3i last_cell;

                const int no_steps; 

                const CGLA::Vec3i dir_pre_mul;

                Integer64Bits disc[3][3];

                CGLA::Vec3i cell;


                const CGLA::Vec3i grid_pos(const CGLA::Vec3f& v) const;
        
                CGLA::Vec3i get_cell(const CGLA::Vec3i& v) const;
        
                CGLA::Vec3i mirror(const CGLA::Vec3i& v) const;


        public:

                ThreeDDDA(const CGLA::Vec3f& p0, const CGLA::Vec3f& p1, 
                                                        int _PRECISION = 0x100);
        
                int get_no_steps() const
                {
                        return no_steps;
                }

                const CGLA::Vec3i& get_current_cell() const
                {
                        return cell;
                }

                const CGLA::Vec3i& get_first_cell() const
                {
                        return first_cell;
                }

                const CGLA::Vec3i& get_last_cell() const
                {
                        return last_cell;
                }

                const CGLA::Vec3f get_first_point() const
                {
                        return (CGLA::Vec3f(p0_int)+CGLA::Vec3f(0.5))/PRECISION;
                }


                const CGLA::Vec3f get_last_point() const
                {
                        return (CGLA::Vec3f(p1_int)+CGLA::Vec3f(0.5))/PRECISION;
                }
        
                bool at_end() const
                {
                        return cell == last_cell;
                }

                void operator++()
                {
                        int step_dir;
                        if(disc[1][0] > disc[0][1])
                                if(disc[2][0] > disc[0][2])
                                        step_dir = 0;
                                else
                                        step_dir = 2;
                        else
                                if(disc[2][1] > disc[1][2])
                                        step_dir = 1;
                                else
                                        step_dir = 2;
                                
                        const int k1 = (step_dir + 1) % 3;
                        const int k2 = (step_dir + 2) % 3;
                        cell[step_dir] += sgn[step_dir];
                        disc[step_dir][k1] += dir_pre_mul[k1];
                        disc[step_dir][k2] += dir_pre_mul[k2];
                }

                        const CGLA::Vec3f step();


        };
}

#endif