Axis.h

Go to the documentation of this file.

// Axis.h: Classes representing a regular or irregular axis.
//
// Copyright (C) 2020 ASTRON (Netherlands Institute for Radio Astronomy)
// SPDX-License-Identifier: GPL-3.0-or-later
 
 
#ifndef LOFAR_PARMDB_AXIS_H
#define LOFAR_PARMDB_AXIS_H
 
#include <cstdint>
#include <memory>
#include <utility>
#include <vector>
 
namespace dp3 {
namespace parmdb {
 
 
 
class Axis {
 public:
  typedef std::shared_ptr<Axis> ShPtr;
 
  Axis();
  virtual ~Axis() {}
 
  virtual Axis::ShPtr clone() const = 0;
 
  bool operator==(const Axis& that) const;
  bool operator!=(const Axis& that) const { return !operator==(that); }
 
  unsigned int getId() const { return itsId; }
 
  double center(size_t n) const { return itsCenter[n]; }
  double width(size_t n) const { return itsWidth[n]; }
  double upper(size_t n) const { return itsUpper[n]; }
  double lower(size_t n) const { return itsLower[n]; }
 
  const std::vector<double>& centers() const { return itsCenter; }
  const std::vector<double>& widths() const { return itsWidth; }
  const std::vector<double>& uppers() const { return itsUpper; }
  const std::vector<double>& lowers() const { return itsLower; }
 
  bool isRegular() const { return itsIsRegular; }
 
  size_t size() const { return itsCenter.size(); }
 
  double start() const { return itsLower[0]; }
  double end() const { return itsUpper[itsUpper.size() - 1]; }
 
  std::pair<double, double> range() const {
    return std::make_pair(start(), end());
  }
 
  std::pair<size_t, bool> find(double x, bool biasRight = true,
                               size_t start = 0) const;
 
  size_t locate(double x, bool biasRight = true, size_t start = 0) const {
    std::pair<size_t, bool> res = find(x, biasRight, start);
    if (!res.second) throwNotFound(x);
    return res.first;
  }
 
  bool checkIntervals(const Axis& that) const;
 
  Axis::ShPtr subset(double start, double end, size_t& index) const;
  Axis::ShPtr subset(double start, double end) const;
 
  Axis::ShPtr subset(size_t start, size_t end) const {
    return doSubset(start, end);
  }
 
  virtual Axis::ShPtr compress(size_t factor) const = 0;
 
  Axis::ShPtr combine(const Axis& that, int& s1, int& e1, int& s2,
                      int& e2) const;
 
  static Axis::ShPtr makeAxis(const std::vector<double>& low,
                              const std::vector<double>& high);
 
 private:
  Axis::ShPtr add(const Axis& that) const;
 
  virtual Axis::ShPtr doSubset(size_t start, size_t end) const = 0;
 
  void throwNotFound(double x) const;
 
 protected:
  void setup(double start, double width, unsigned int count);
  void setup(const std::vector<double>& v1, const std::vector<double>& v2,
             bool asStartEnd);
 
  static unsigned int theirId;
 
  unsigned int itsId;
  bool itsIsRegular;
  std::vector<double> itsCenter;
  std::vector<double> itsWidth;
  std::vector<double> itsLower;
  std::vector<double> itsUpper;
};
 
class RegularAxis : public Axis {
 public:
  RegularAxis();
 
  RegularAxis(double begin, double cellWidth, unsigned int count,
              bool asStartEnd = false);
 
  ~RegularAxis() override;
 
  Axis::ShPtr clone() const override;
 
  Axis::ShPtr doSubset(size_t start, size_t end) const override;
  Axis::ShPtr compress(size_t factor) const override;
 
 private:
  double itsStart;
  double itsWidth;
  uint32_t itsCount;
};
 
class OrderedAxis : public Axis {
 public:
  OrderedAxis();
 
  OrderedAxis(const std::vector<double>& v1, const std::vector<double>& v2,
              bool asStartEnd = false);
 
  ~OrderedAxis() override;
 
  Axis::ShPtr clone() const override;
 
  Axis::ShPtr doSubset(size_t start, size_t end) const override;
  Axis::ShPtr compress(size_t factor) const override;
};
 
 
}  // namespace parmdb
}  // namespace dp3
 
#endif