recognition/Grid.h

//
// File: Grid.h
// used to grow a grid by adding columns and vectors and to allow access to the outside edges
//      used in Points::fitGrid
#pragma once
#include "gNode.h"
#include "Point.h"
#include "PointList.h"
#include "Step.h"
#include <deque> //STL, allows constant time inserts to front and back
#include <algorithm>
#include <math.h>
using namespace std;
namespace Recognition{
class Grid{
        gNode *origin;
        int rowSize;
        int colSize;
        void orient();
        void check();
        double dist(gNode *one,gNode *two){
                double dx=one->x-two->x;
                double dy=one->y-two->y;
                return hypot(dx,dy);
        }
public:
        
        Point extendTop(int i,int &t){
                double x=top[i]->x;
                double y=top[i]->y;
                double x2=top[i]->b->x;
                double y2=top[i]->b->y;
                double x3=top[i]->b->b->x;
                double y3=top[i]->b->b->y;
                
                double dx=x-x2;
                double dy=y-y2;
                double d1=hypot(dx,dy);
                double d2=hypot(x2-x3,y2-y3);
                dx*= d1/d2;
                dy*= d1/d2;
                t=hypot(dx,dy)/2;
                
                return Point(x + dx, y + dy );
        }
        Point extendBottom(int i,int &t){
                double x=bot[i]->x;
                double y=bot[i]->y;
                double x2=bot[i]->t->x;
                double y2=bot[i]->t->y;
                double x3=bot[i]->t->t->x;
                double y3=bot[i]->t->t->y;
                
                double dx=x-x2;
                double dy=y-y2;
                double d1=hypot(dx,dy);
                double d2=hypot(x2-x3,y2-y3);
                dx*= d1/d2;
                dy*= d1/d2;
                t=hypot(dx,dy)/2;
                return Point(x + dx, y + dy );
        }
        Point extendLeft(int i,int &t){
                double x=left[i]->x;
                double y=left[i]->y;
                double x2=left[i]->r->x;
                double y2=left[i]->r->y;
                double x3=left[i]->r->r->x;
                double y3=left[i]->r->r->y;
                
                double dx=x-x2;
                double dy=y-y2;
                double d1=hypot(dx,dy);
                double d2=hypot(x2-x3,y2-y3);
                dx*= d1/d2;
                dy*= d1/d2;
                t=hypot(dx,dy)/2;
                return Point(x + dx, y + dy );
        }
        Point extendRight(int i,int &t){
                double x=righ[i]->x;
                double y=righ[i]->y;
                double x2=righ[i]->l->x;
                double y2=righ[i]->l->y;
                double x3=righ[i]->l->l->x;
                double y3=righ[i]->l->l->y;
                
                double dx=x-x2;
                double dy=y-y2;
                double d1=hypot(dx,dy);
                double d2=hypot(x2-x3,y2-y3);
                dx*= d1/d2;
                dy*= d1/d2;
                t=hypot(dx,dy)/2;
                return Point(x + dx, y + dy );
        }


        //pointers to the edges of the grid for fast access
        deque <gNode *>top;
        deque <gNode *>bot;
        deque <gNode *>left;
        deque <gNode *>righ;
        void switchXandY();
        Grid(Point &);
        ~Grid();
        void addTrow(PointList &);
        void addBrow(PointList &);
        void addLcol(PointList &);
        void addRcol(PointList &);

        int getRSize(){return rowSize;}
        int getCSize(){return colSize;}
        Step getStep(char side,int index){
                Step temp;
                Step temp2;
                switch(side){
                        case 't':
                                temp.rise=top[index]->y-top[index]->b->y;
                                temp.run =top[index]->x-top[index]->b->x;
                                temp2.rise=top[index]->b->y-top[index]->b->b->y;
                                temp2.run =top[index]->b->x-top[index]->b->b->x;
                        break;
                        case 'b':
                                temp.rise=bot[index]->y-bot[index]->t->y;
                                temp.run =bot[index]->x-bot[index]->t->x;
                                temp2.rise=bot[index]->t->y-bot[index]->t->t->y;
                                temp2.run =bot[index]->t->x-bot[index]->t->t->x;
                        break;
                        case 'l':
                                temp.rise=left[index]->y-left[index]->r->y;
                                temp.run =left[index]->x-left[index]->r->x;
                                temp2.rise=left[index]->r->y-left[index]->r->r->y;
                                temp2.run =left[index]->r->x-left[index]->r->r->x;
                        break;
                        case 'r':
                                temp.rise=righ[index]->y-righ[index]->l->y;
                                temp.run =righ[index]->x-righ[index]->l->x;
                                temp2.rise=righ[index]->l->y-righ[index]->l->l->y;
                                temp2.run =righ[index]->l->x-righ[index]->l->l->x;
                        break;
                        default:
                                cout<<"error in getStep--wrong valued parameter\n";
                }
                temp.rise+= temp.rise -temp2.rise;
                temp.run += temp.run  -temp2.run;
                return temp;
        }
        void toList(PointList &);
        void print(){
                gNode *temp=origin;
                gNode *tempR=origin;
                while( temp!=NULL){
                        while(temp!=NULL){
                                cout<<"["<<temp->x<<","<<temp->y<<"] ";
                                temp=temp->r;
                        }
                        tempR=tempR->b;
                        temp=tempR;
                        cout<<endl;
                }
        }
};
}

---