ReSCue - Retrieval System for Curves

---

         

---

polygonal_curve.h

#ifndef polygonal_curve_H
#define polygonal_curve_H

#include <fstream>
#include <list>
#include "polygon_edge.h"
#include "rigid_motion.h"

namespace rescue
{

template <class point>
class polygon_edge;


// ==========================================================================================
// ==========================================================================================
template <class point>
class polygonal_curve
{

public:

    typedef point point_t;
    typedef point::arithmetic_t arithmetic_t;
    typedef arithmetic_t arithmetic;

    typedef rigid_motion<arithmetic> motion;
    typedef int size_t;
    typedef polygon_vertex<point> vertex;
    typedef polygon_edge<point> edge;

    class vertex_iterator
    {

    protected:

        vertex* position;

    public:

        inline vertex_iterator()
        {
            position = NULL;
        }

        inline vertex_iterator(vertex* pos)
        {
            position = pos;
        }

        inline vertex_iterator& operator++()
        {
                        if (position!=NULL)
                    position = position->next;
            return *this;
        }

        inline vertex_iterator& operator++(int)
        {
                        if (position!=NULL)
                    position = position->next;
            return *this;
        }

        inline vertex_iterator& operator--()
        {
                        if (position!=NULL)
                    position = position->prev;
            return *this;
        }

        inline vertex_iterator& operator--(int)
        {
                        if (position!=NULL)
                                position = position->prev;
            return *this;
        }

        inline vertex_iterator& operator=(const vertex_iterator& v_it)
        {
            position = v_it.position;
            return *this;
        }

        inline vertex& operator*()
        {
            return *position;
        }

        inline bool operator==(const vertex_iterator& v_it)
        {
            return position==v_it.position;
        }

        inline bool operator!=(const vertex_iterator& v_it)
        {
            return position!=v_it.position;
        }

    };


    class edge_iterator : public vertex_iterator
    {

    public:

        edge operator*()
        {
            return edge(*this);
        }

    };

        typedef vertex_iterator pc_vertex_iterator;

private:

    vertex* first;
    vertex* last;

    size_t curve_length;

public:

    size_t length() {
        return curve_length-1;
    }


    polygonal_curve();

    polygonal_curve(const polygonal_curve<point>& P, const int n);

    polygonal_curve(const polygonal_curve<point>&);

    polygonal_curve(const polygonal_curve<point>& P, vertex* one);

    ~polygonal_curve();

    polygonal_curve<point>& operator=(const polygonal_curve<point>&);

    void clear();

    void push_front(vertex* v);
    void push_back(vertex* v);
    void delete_last_point();

    vertex_iterator vertex_begin() const;
    vertex_iterator vertex_end() const;

    edge_iterator edge_begin();
    edge_iterator edge_end();

    void read(std::fstream&);
    void write(std::fstream&);

    polygonal_curve<point>& operator *= (const motion& m);

    bool empty() { return first==NULL; }

};

// ==========================================================================================
// ==========================================================================================



// ==========================================================================================
template <class point>
polygonal_curve<point>::polygonal_curve()
// ==========================================================================================
{
    curve_length = 0;
    first = NULL;
    last = NULL;
}

// ==========================================================================================
template <class point>
polygonal_curve<point>::polygonal_curve(
    const polygonal_curve<point>& P,
    polygonal_curve<point>::vertex* one)
// ==========================================================================================
{
    *this = P;
    one->next = first->next;
    first = one;
}

// ==========================================================================================
template <class point>
polygonal_curve<point>::polygonal_curve(
    const polygonal_curve<point>& P, const int n)
// ==========================================================================================
{
    
    *this = P;
    int i=n;
    while (i>0 && first!=NULL)
    {
        first = first->next;
        curve_length--;
        i--;
    }
    if (first==NULL)
        last = NULL;

}

// ==========================================================================================
template <class point>
polygonal_curve<point>::polygonal_curve(
    const polygonal_curve<point>& P)
// ==========================================================================================
{
    vertex_iterator v_it = P.vertex_begin();
    for (; v_it!=P.vertex_end(); v_it++)
        push_back(new vertex((*v_it).pos()));
}

// ==========================================================================================
template <class point>
polygonal_curve<point>& polygonal_curve<point>::operator=(
    const polygonal_curve<point>& P)
// ==========================================================================================
{
    clear();
    polygonal_curve<point>::vertex_iterator v_it = P.vertex_begin();
    for (; v_it!=P.vertex_end(); v_it++) {
        vertex  v = *v_it;
        point pp = v.pos;
        this->push_back(new vertex(pp));
    }
    return *this;
}


// ==========================================================================================
template <class point>
    polygonal_curve<point>::vertex_iterator 
    polygonal_curve<point>::vertex_begin() const
// ==========================================================================================
{
    return polygonal_curve<point>::vertex_iterator(first);
}

// ==========================================================================================
template <class point>
    polygonal_curve<point>::vertex_iterator 
    polygonal_curve<point>::vertex_end() const
// ==========================================================================================
{
    return polygonal_curve<point>::vertex_iterator(NULL);
}

// ==========================================================================================
template <class point>
    polygonal_curve<point>::edge_iterator 
    polygonal_curve<point>::edge_begin()
// ==========================================================================================
{
    return polygonal_curve<point>::edge_iterator(first);
}

// ==========================================================================================
template <class point>
    polygonal_curve<point>::edge_iterator 
    polygonal_curve<point>::edge_end()
// ==========================================================================================
{
    return polygonal_curve<point>::edge_iterator(last);
}

// ==========================================================================================
template <class point>
void polygonal_curve<point>::push_front(polygonal_curve<point>::vertex* v)
// ==========================================================================================
{
    v->next = first;
    v->prev = NULL;
    if (first!=NULL)
        first->prev = v;
    first = v;
    curve_length++;
}

// ==========================================================================================
template <class point>
void polygonal_curve<point>::push_back(polygonal_curve<point>::vertex* v)
// ==========================================================================================
{
    
    if (curve_length>0)
    {
        v->prev = last;
        v->next = NULL;
        if (last!=NULL)
            last->next = v;
        last = v;
        curve_length++;
    } else {
        v->next = NULL;
        v->prev = NULL;
        first = v;
        last = v;
        curve_length = 1;
    }


}

// ==========================================================================================
template <class point>
void polygonal_curve<point>::delete_last_point()
// ==========================================================================================
{
    if (curve_length>0)
    {
        vertex* temp = last;
        if (last!=NULL)
        {
            last = last->prev;
            if (last!=NULL)
                last->next = NULL;
        }
        delete temp;
        curve_length--;
        if (curve_length==0)
        {
            first = NULL;
            last = NULL;
        }
    } 
}

// ==========================================================================================
template <class point>
polygonal_curve<point>& polygonal_curve<point>::operator *= (const motion& m)
// ==========================================================================================
{
    
    vertex_iterator v_it = vertex_begin();
    for (; v_it!=vertex_end(); v_it++)
    {
        (*v_it).pos *= m;
    }

    return *this;

}

// ==========================================================================================
template <class point>
void polygonal_curve<point>::read(std::fstream& str)
// ==========================================================================================
{

    clear();

    size_t len;
    str.read((char*)&len,sizeof(size_t));
    vertex_iterator v_it = vertex_begin();
    for (int i=0; i<len; i++)
    {
        double xx;
        double yy;
        str.read((char*)&xx,sizeof(double));
        str.read((char*)&yy,sizeof(double));
        point p(xx,yy);
        push_back(new vertex(p));
    }

}

// ==========================================================================================
template <class point>
void polygonal_curve<point>::write(std::fstream& str)
// ==========================================================================================
{
    
    str.write((char*)&curve_length,sizeof(size_t));
    vertex_iterator v_it = vertex_begin();
    for (; v_it!=vertex_end(); v_it++)
    {

        point p = (*v_it).pos;
        double xx = p.x;
        double yy = p.y;
        str.write((char*)&xx,sizeof(double));
        str.write((char*)&yy,sizeof(double));

    }

}

// ==========================================================================================
template <class point>
void polygonal_curve<point>::clear()
// ==========================================================================================
{
    
    vertex_iterator v_it = vertex_begin();
    vertex* prev = NULL;
    for (; v_it!=vertex_end(); v_it++)
    {
        if (prev!=NULL)
            delete prev;
        prev = &(*v_it);
    }
    if (prev!=NULL)
        delete prev;

    curve_length = 0;
    first = NULL;
    last = NULL;

}

// ==========================================================================================
template <class point>
polygonal_curve<point>::~polygonal_curve()
// ==========================================================================================
{
    clear();
}


}

#endif

ReSCue - Retrieval System for Curves
Universität Bonn, Institut für Informatik III, 2001