recognition/PointList.h

/*
    This file is part of Cali Cam.

    Cali Cam is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    Cali Cam is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with Cali Cam.  If not, see <http://www.gnu.org/licenses/>.
*/
//class PointList, PointList.h
// class that uses a double linked list to hold points
// has an importaint function 'closest' which provides the closest point in the list to a given point
//      runs in linear time with no time saving tricks
// new entries are added to the front of the list via 'add'--this order becomes importaint in some applications
#pragma once
#include "Node.h"
#include "Point.h"
#include "global.h"
#include <stdlib.h>
#include <iostream>
using namespace std;
namespace Recognition{
class PointList{
private:
        Node *head;
        Node *curr;
        int Size;
public:
        Node* gHead(){return head;}
        void removeDoubles();

        PointList(void);
        ~PointList(void);
        void add(float imgx,float imgy,int gridx=-1, int gridy=-1){
                Node *temp=new Node(imgx,imgy,gridx,gridy,NULL,head);
                head=temp;
                Size++;
        }
        void del(){ //delete current
                if(curr==NULL)
                        return;
                if(curr==head)
                        head=head->next;
                Node *next=curr->next;
                Node *prev=curr->prev;
                if(prev!=NULL)
                        prev->next=next;
                if(next!=NULL)
                        next->prev=prev;
                delete curr;
                curr=next;
                Size--;
        }
        void del(Node *target){
                if(target==head){
                        head=head->next;
                }
                if(target->next!=NULL)
                        target->next->prev=target->prev;
                if(target->prev!=NULL)
                        target->prev->next=target->next;
                if(curr==target)
                        curr=target->next;
                delete target;
                Size--;
        }
        
        Point* next(){
                
                curr=curr->next;
                if(curr==NULL)
                        return NULL;
                return &(curr->data);
        }
        Point* current(){
                if(curr==NULL)
                        return NULL;
                return &(curr->data);
        }
        void reset(){
                curr=head;
        }
        int size(){return Size;}
        
        Node* closest(Point &p,double limit){
                Node* temp=head;
                Node* best=head;
                double bestD=dist(head->data,p);
                double dt;
                temp=head->next;
                
                while(temp!=NULL){
                        dt=dist(temp->data,p);
                        if(dt<bestD){
                                bestD=dt;
                                best=temp;
                        }
                        temp=temp->next;
                }
                if(bestD<=limit)
                        return best;    
                return NULL;
        }
        PointList & operator=(PointList &that){
                if(this==&that)
                        return *this;
                //first need to delete current data
                Node *cur=head;
                Node *prev;
                while(cur!=NULL){
                        prev=cur;
                        cur=cur->next;
                        delete prev;
                }
                //transfer ownership
                head=that.head;
                curr=head;
                Size=that.Size;
                that.head=NULL;
                that.curr=NULL;
                that.Size=0;
                return *this;
                
        }
        void print(){
                Node *cur=head;
                while(cur!=NULL){
                        cur->data.print();
                        cur=cur->next;
                }
        }
                        
};}

---