Grid.h

Go to the documentation of this file.

// Grid.h: Class representing a regular or irregular 2-D grid.
//
// Copyright (C) 2020 ASTRON (Netherlands Institute for Radio Astronomy)
// SPDX-License-Identifier: GPL-3.0-or-later
 
 
#ifndef LOFAR_PARMDB_GRID_H
#define LOFAR_PARMDB_GRID_H
 
#include "Box.h"
#include "Axis.h"
 
#include <memory>
 
namespace dp3 {
namespace parmdb {
 
class Grid;
 
 
class GridRep {
 public:
  typedef std::shared_ptr<GridRep> ShPtr;
 
  GridRep();
 
  GridRep(Axis::ShPtr first, Axis::ShPtr second);
 
  GridRep(const std::vector<Grid>& domains, bool sort);
 
  GridRep(const std::vector<Box>& domains, bool sort);
 
  bool isDefault() const { return itsIsDefault; }
 
  Axis::ShPtr& getAxis(size_t n) { return itsAxes[n]; }
  const Axis::ShPtr& getAxis(size_t n) const { return itsAxes[n]; }
 
 private:
  void setup(const std::vector<Box>& domains);
 
  void setup(const std::vector<Grid>& domains);
 
  Axis::ShPtr combineAxes(const std::vector<Grid>& grids, unsigned int axis,
                          unsigned int n, unsigned int step) const;
 
  Axis::ShPtr itsAxes[2];
 
  bool itsIsDefault;
};
 
class Grid {
 public:
  using Location = std::pair<size_t, size_t>;
 
  Grid() : itsRep(new GridRep()) {}
 
  Grid(Axis::ShPtr first, Axis::ShPtr second)
      : itsRep(new GridRep(first, second)) {}
 
  Grid(const std::vector<Grid>& grids, bool sort = false);
 
  Grid(const std::vector<Box>& domains, bool sort = false)
      : itsRep(new GridRep(domains, sort)) {}
 
  bool checkIntervals(const Grid& that) const;
 
  bool isDefault() const { return itsRep->isDefault(); }
 
  const Axis::ShPtr& getAxis(size_t n) const { return itsRep->getAxis(n); }
  const Axis::ShPtr& operator[](size_t n) const { return itsRep->getAxis(n); }
 
  size_t nx() const { return getAxis(0)->size(); }
  size_t ny() const { return getAxis(1)->size(); }
 
  std::pair<size_t, size_t> shape() const { return std::make_pair(nx(), ny()); }
 
  size_t size() const { return nx() * ny(); }
 
  unsigned int getCellId(const Location& location) const {
    return location.second * nx() + location.first;
  }
 
  Location getCellLocation(unsigned int id) const {
    return Location(id % nx(), id / nx());
  }
 
  Point getCellCenter(const Location& location) const {
    assert(location.first < nx() && location.second < ny());
    return Point(getAxis(0)->center(location.first),
                 getAxis(1)->center(location.second));
  }
 
  Box getCell(const Location& location) const {
    assert(location.first < nx() && location.second < ny());
    return Box(Point(getAxis(0)->lower(location.first),
                     getAxis(1)->lower(location.second)),
               Point(getAxis(0)->upper(location.first),
                     getAxis(1)->upper(location.second)));
  }
 
  Box getCell(unsigned int id) const { return getCell(getCellLocation(id)); }
 
  Box getBoundingBox() const {
    return Box(Point(getAxis(0)->start(), getAxis(1)->start()),
               Point(getAxis(0)->end(), getAxis(1)->end()));
  }
 
  Box getBoundingBox(const Location& start, const Location& end) const {
    assert(start.first <= end.first && start.second <= end.second);
    return unite(getCell(start), getCell(end));
  }
 
  Location locate(const Point& point, bool biasRight = true) const {
    return std::make_pair(getAxis(0)->locate(point.first, biasRight),
                          getAxis(1)->locate(point.second, biasRight));
  }
 
  Grid subset(const Box&) const;
  Grid subset(const Box&, Location& index) const;
  Grid subset(const Location& start, const Location& end) const;
 
  void toDomains(std::vector<Box>& domains) const;
 
  bool operator<(const Grid& that) const {
    return getBoundingBox().lowerY() < that.getBoundingBox().lowerY() ||
           (getBoundingBox().lowerY() == that.getBoundingBox().lowerY() &&
            getBoundingBox().lowerX() < that.getBoundingBox().lowerX());
  }
  bool operator>(const Grid& that) const {
    return getBoundingBox().lowerY() > that.getBoundingBox().lowerY() ||
           (getBoundingBox().lowerY() == that.getBoundingBox().lowerY() &&
            getBoundingBox().lowerX() > that.getBoundingBox().lowerX());
  }
 
 private:
  GridRep::ShPtr itsRep;
};
 
class CellIterator {
 public:
  CellIterator(const Grid::Location& start, const Grid::Location& end)
      : itsStart(start), itsEnd(end), itsLocation(start) {}
 
  bool atEnd() const { return itsLocation.second > itsEnd.second; }
 
  void operator++() {
    if (++itsLocation.first > itsEnd.first) {
      itsLocation.first = itsStart.first;
      ++itsLocation.second;
    }
  }
  void operator++(int) { operator++(); }
 
  const Grid::Location& operator*() const { return itsLocation; }
 
  const Grid::Location* operator->() const { return &itsLocation; }
 
 private:
  Grid::Location itsStart;
  Grid::Location itsEnd;
  Grid::Location itsLocation;
};
 
 
}  // namespace parmdb
}  // namespace dp3
 
#endif