Point.h

Go to the documentation of this file.

/*
 * $Id: Point.h 5871 2005-10-28 02:10:33Z dfs $
 *
 * Copyright 2003-2005 Daniel F. Savarese
 * Copyright 2005 Savarese Software Research
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     https://www.savarese.com/software/ApacheLicense-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#ifndef __SAVA_SPATIAL_POINT_H
#define __SAVA_SPATIAL_POINT_H

#include <limits>
#include <cstring>

#include <libsava/packages.h>

__BEGIN_PACKAGE_SAVA_SPATIAL

template<typename P>
struct PointTraits {
  typedef P point_type;

  typedef typename point_type::coordinate_type coordinate_type;

  static inline const coordinate_type max_coordinate() {
    return std::numeric_limits<coordinate_type>::max();
  }

  static inline const coordinate_type min_coordinate() {
    return std::numeric_limits<coordinate_type>::min();
  }    

  static inline const unsigned int dimensions() {
    return point_type::dimensions();
  }
};


template<unsigned int Dimensions = 2, class CoordType = unsigned int>
class Point {
public:
  typedef CoordType coordinate_type;

  static inline const unsigned int dimensions() {
    return Dimensions;
  }

private:
  coordinate_type coordinates[Dimensions];

public:

  Point() {
    // This is the wrong thing to do for non-primitive types.
    // Place in a specialization of the class.
    std::memset(coordinates, 0, sizeof(coordinates));
  }

  coordinate_type & operator[](const unsigned int index) {
    return coordinates[index];
  }

  const coordinate_type & operator[](const unsigned int index) const {
    return coordinates[index];
  }

  // Rely on default assignment operator.
  /*
  Point & operator=(const Point & point) {
    // This is the wrong thing to do for non-primitive types.
    // Place in a specialization of the class.
    if(this != &point)
      std::memcpy(coordinates, point.coordinates, sizeof(coordinates));
    return *this;
  }
  */
};


template<unsigned int Dimensions, class CoordType>
inline bool operator==(const Point<Dimensions, CoordType> & point1,
                       const Point<Dimensions, CoordType> & point2)
{
  unsigned int d = Dimensions;
  while(d-- > 0) {
    if(point1[d] != point2[d])
      return false;
  }
  return true;
}

template<unsigned int Dimensions, class CoordType>
inline bool operator<(const Point<Dimensions, CoordType> & point1,
                      const Point<Dimensions, CoordType> & point2)
{
  unsigned int d = Dimensions;
  while(d-- > 0) {
    if(point1[d] < point2[d])
      return true;
    else if(point1[d] != point2[d])
      break;
  }
  return false;
}

template<unsigned int Dimensions, class CoordType>
inline bool operator>(const Point<Dimensions, CoordType> & point1,
                      const Point<Dimensions, CoordType> & point2)
{
  unsigned int d = Dimensions;
  while(d-- > 0) {
    if(point1[d] > point2[d])
      return true;
    else if(point1[d] != point2[d])
      break;
  }
  return false;
}

template<class CoordType>
inline bool operator==(const Point<2, CoordType> & point1,
                       const Point<2, CoordType> & point2)
{
  return (point1[0] == point2[0] && point1[1] == point2[1]);
}

template<class CoordType>
inline bool operator<(const Point<2, CoordType> & point1,
                      const Point<2, CoordType> & point2)
{
  return (point1[0] < point2[0] ||
          (point1[0] == point2[0] && point1[1] < point2[1]));
}

template<class CoordType>
inline bool operator>(const Point<2, CoordType> & point1,
                      const Point<2, CoordType> & point2)
{
  return (point1[0] > point2[0] ||
          (point1[0] == point2[0] && point1[1] > point2[1]));
}

template<class CoordType>
inline bool operator==(const Point<3, CoordType> & point1,
                       const Point<3, CoordType> & point2)
{
  return (point1[0] == point2[0] && point1[1] == point2[1] &&
          point1[2] == point2[2]);
}

template<class CoordType>
inline bool operator<(const Point<3, CoordType> & point1,
                      const Point<3, CoordType> & point2)
{
  return (point1[0] < point2[0] ||
          (point1[0] == point2[0] &&
           (point1[1] < point2[1] ||
            (point1[1] == point2[1] && point1[2] < point2[2]))));
           
}

template<class CoordType>
inline bool operator>(const Point<3, CoordType> & point1,
                      const Point<3, CoordType> & point2)
{
  return (point1[0] > point2[0] ||
          (point1[0] == point2[0] &&
           (point1[1] > point2[1] ||
            (point1[1] == point2[1] && point1[2] > point2[2]))));
           
}

template<unsigned int Dimensions, class CoordType>
inline bool operator!=(const Point<Dimensions, CoordType> & point1,
                       const Point<Dimensions, CoordType> & point2)
{
  return !(point1 == point2);
}

template<unsigned int Dimensions, class CoordType>
inline bool operator>=(const Point<Dimensions, CoordType> & point1,
                       const Point<Dimensions, CoordType> & point2)
{
  return !(point1 < point2);
}

template<unsigned int Dimensions, class CoordType>
inline bool operator<=(const Point<Dimensions, CoordType> & point1,
                       const Point<Dimensions, CoordType> & point2)
{
  return !(point1 > point2);
}

template <class CoordType = unsigned int>
class Point2D : public Point<2, CoordType> {

public:
  typedef CoordType coordinate_type;

  Point2D() {
    (*this)[0] = coordinate_type();
    (*this)[1] = coordinate_type();
  }

  Point2D(const coordinate_type & x, const coordinate_type & y)  {
    (*this)[0] = x;
    (*this)[1] = y;
  }
};

template <class CoordType = unsigned int>
class Point3D : public Point<3, CoordType> {

public:
  typedef CoordType coordinate_type;

  Point3D() {
    (*this)[0] = coordinate_type();
    (*this)[1] = coordinate_type();
    (*this)[2] = coordinate_type();
  }

  Point3D(const coordinate_type & x, const coordinate_type & y,
          const coordinate_type & z)
  {
    (*this)[0] = x;
    (*this)[1] = y;
    (*this)[2] = z;
  }
};


// Will have to replace isContained with an abstraction for testing
// containment in arbitrarily shaped regions.

template <unsigned int Dimensions, class CoordType>
inline bool isContained(const Point<Dimensions, CoordType> & point,
                        const Point<Dimensions, CoordType> & lower,
                        const Point<Dimensions, CoordType> & upper)
{
  for(unsigned int i = 0; i < Dimensions; ++i) {
    if(point[i] < lower[i] || point[i] > upper[i])
      return false;
  }

  return true;
}


template <class CoordType>
inline bool isContained(const Point<2, CoordType> & point,
                        const Point<2, CoordType> & lower,
                        const Point<2, CoordType> & upper)
{
  return !(point[0] < lower[0] || point[1] < lower[1] ||
           point[0] > upper[0] || point[1] > upper[1]);
}


template <class CoordType>
inline bool isContained(const Point<3, CoordType> & point,
                        const Point<3, CoordType> & lower,
                        const Point<3, CoordType> & upper)
{
  return !(point[0] < lower[0] || point[1] < lower[1] || point[2] < lower[2] ||
           point[0] > upper[0] || point[1] > upper[1] || point[2] > upper[2]);

}

__END_PACKAGE_SAVA_SPATIAL

#endif

---

Copyright © 2003-2005 Savarese Software Research and Daniel F. Savarese. All rights reserved.