KDPoint.h

Go to the documentation of this file.

/* Copyright (C) 2004
   K-Dimension Point used in K-Dimension Tree

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

   This library 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
   Lesser General Public License for more details.

   You should have received a copy of the GNU Lesser General Public
   License along with this library; if not, write to the Free Software
   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
*/

#ifndef _KDPOINT_H_
#define _KDPOINT_H_

#include "Object.h"
#include <stdio.h>
#include <iostream>
#include <math.h>


// Template class for point coordinate
// IMPORTANT: class requires =, -, >, < operators
//            it should usually be either double, float, int, ...
template <class KDData>
class KDPoint : public FD::Object
{
public:
        /*
                KDPoint

                Default constructor
        */
        KDPoint()
        : m_dimSize(0), m_point(NULL)
        {

        }

        /*
                KDPoint

                Other constructor with user data

                PARAMETERS
                i_dimSize : dimension size of current point
        */
        KDPoint(int i_dimSize)
        : m_dimSize(i_dimSize)
        {
                m_point = new KDData[m_dimSize];
        }

        /*
                KDPoint

                Other constructor with user data

                PARAMETERS
                i_dimSize : dimension size of current point
                i_point : array with the current point data
        */
        KDPoint(int i_dimSize, KDData *i_point)
        : m_dimSize(i_dimSize)
        {
                m_point = new KDData[m_dimSize];

                for (int i=0; i<m_dimSize; ++i) {
                        m_point[i] = i_point[i];
                }
        }

        /*
                KDPoint

                Other constructor with user data

                PARAMETERS
                i_dimSize : dimension size of current point
                i_point : single value to assign to all dimension in point
        */
        KDPoint(int i_dimSize, KDData i_point)
        : m_dimSize(i_dimSize)
        {
                m_point = new KDData[m_dimSize];

                for (int i=0; i<m_dimSize; ++i) {
                        m_point[i] = i_point;
                }
        }

        /*
                KDPoint

                Copy constructor

                PARAMETERS
                i_cpy : reference to point to copy
        */
        KDPoint(const KDPoint & i_cpy)
        {
                m_dimSize = i_cpy.m_dimSize;
                m_point = new KDData[m_dimSize];

                for (int i=0; i<m_dimSize; ++i) {
                        m_point[i] = i_cpy.m_point[i];
                }
        }

        /*
                operator =

                Equal operator

                PARAMETERS
                i_ref : reference to point to copy

                RETURNS
                A copy of the given reference point
        */
        KDPoint & operator =(const KDPoint &i_ref)
        {
                // Avoid self assignment
                if (&i_ref == this) {
                        return *this;
                }

                // Prevent memory leak
                delete [] m_point;

                m_dimSize = i_ref.m_dimSize;
                m_point = new KDData[m_dimSize];

                for (int i=0; i<m_dimSize; ++i) {
                        m_point[i] = i_ref.m_point[i];
                }

                return *this;
        }

        /*
                ~KDPoint

                Destructor

        */
        ~KDPoint()
        {
                delete [] m_point;
        }

        /*
                printOn

                Object routine required to print its content

                PARAMETERS
                out : output stream to print the object content
        */
        void printOn(std::ostream &out) const
        {
                out << "<KDPoint " << std::endl;
                out << "<DimSize " << m_dimSize << " >" << std::endl;

                out << "<PointData " << std::endl;
                for (int d=0; d<m_dimSize; ++d) {
                        out << (int)(m_point[d]) << std::endl;
                }
                out << " >" << std::endl;

                out << " >" << std::endl;
        }

        /*
                readFrom

                Object routine required to read an Object content

                PARAMETERS
                in : input stream to read the object content
        */
        void readFrom(std::istream &in)
        {
                std::string tag;

                while (1) {
                        char ch;
                        in >> ch;

                        if (ch == '>') {
                                break;
                        }
                        else if (ch != '<') {
                                throw new FD::GeneralException ("KDPoint::readFrom : Parse error: '<' expected",__FILE__,__LINE__);
                        }

                        in >> tag;

                        if (tag == "KDPoint") {
                                continue;
                        }
                        else if (tag == "DimSize") {
                                in >> m_dimSize;
                        }
                        else if (tag == "PointData") {
                                // Allocate point
                                m_point = new KDData[m_dimSize];

                                for (int d=0; d<m_dimSize; ++d) {
                                        in >> m_point[d];
                                }
                        }
                        else {
                                throw new FD::GeneralException ("KDPoint::readFrom : Unknown argument: " + tag,__FILE__,__LINE__);
                        }

                        if (!in) {
                                throw new FD::GeneralException ("KDPoint::readFrom : Parse error trying to build " + tag,__FILE__,__LINE__);
                        }

                        in >> tag;
                        if (tag != ">") {
                                throw new FD::GeneralException ("KDPoint::readFrom : Parse error: '>' expected ",__FILE__,__LINE__);
                        }
                }
        }

        /*
                SetPoint

                Set the current point information with the given array

                PARAMETERS
                i_point :  array with the new point data
        */
        void SetPoint(KDData *i_point)
        {
                for (int i=0; i<m_dimSize; ++i) {
                        m_point[i] = i_point[i];
                }
        }


        /*
                SetCoord

                Set a single coordinate (dimension) in the current point

                PARAMETERS
                i_dim :  dimension where to change the value
                i_coord : value of the new coordinate
        */
        void SetCoord(int i_dim, KDData i_coord)
        {
                m_point[i_dim] = i_coord;
        }

        /*
                SetDimSize

                Set a point dimension size (reset its point data array)

                PARAMETERS
                i_dimSize :  dimension size of the point
        */
        void SetDimSize(int i_dimSize)
        {
                m_dimSize = i_dimSize;

                delete [] m_point;
                m_point = new KDData[m_dimSize];
        }

        /*
                GetPoint

                Get a reference to point data array

                RETURNS
                A reference to point data array
        */
        inline KDData *GetPoint() const
        {
                return m_point;
        }

        /*
                GetCoord

                Get a coordinate value in the current point

                PARAMETERS
                i_dim :  the desired dimension

                RETURNS
                A coordinate value in the current point
        */
        inline KDData GetCoord(int i_dim) const
        {
                return m_point[i_dim];
        }

        /*
                GetDimSize

                Get the current point dimension size

                RETURNS
                The current point dimension size
        */
        inline int GetDimSize() const
        {
                return m_dimSize;
        }

private:
        // Dimension size of point
        int m_dimSize;
        // The point data array
        KDData *m_point;
};

#endif

---