BoxBoundedGeo.h

Go to the documentation of this file.

#ifndef LARCOREALG_GEOMETRY_BOXBOUNDEDGEO_H
#define LARCOREALG_GEOMETRY_BOXBOUNDEDGEO_H

// LArSoft libraries
#include "larcoreobj/SimpleTypesAndConstants/geo_vectors.h" // geo::vect

// ROOT library
#include "TVector3.h"

// C/C++ standard library
#include <algorithm>
#include <vector>

namespace geo {
  class BoxBoundedGeo {
  public:
    using Coords_t = Point_t;         
    using Coord_t = Coords_t::Scalar; 

    BoxBoundedGeo() = default;

    BoxBoundedGeo(Coord_t x_min,
                  Coord_t x_max,
                  Coord_t y_min,
                  Coord_t y_max,
                  Coord_t z_min,
                  Coord_t z_max)
      : c_min{x_min, y_min, z_min}, c_max{x_max, y_max, z_max}
    {
      SortCoordinates();
    }

    BoxBoundedGeo(Coords_t lower, Coords_t upper) : c_min(lower), c_max(upper)
    {
      SortCoordinates();
    }


    double MinX() const { return c_min.X(); }

    double MaxX() const { return c_max.X(); }

    double CenterX() const { return (MinX() + MaxX()) / 2.; }

    double SizeX() const { return MaxX() - MinX(); }

    double HalfSizeX() const { return SizeX() / 2.0; }

    double MinY() const { return c_min.Y(); }

    double MaxY() const { return c_max.Y(); }

    double CenterY() const { return (MinY() + MaxY()) / 2.; }

    double SizeY() const { return MaxY() - MinY(); }

    double HalfSizeY() const { return SizeY() / 2.0; }

    double MinZ() const { return c_min.Z(); }

    double MaxZ() const { return c_max.Z(); }

    double CenterZ() const { return (MinZ() + MaxZ()) / 2.; }

    double SizeZ() const { return MaxZ() - MinZ(); }

    double HalfSizeZ() const { return SizeZ() / 2.0; }

    Point_t Min() const { return c_min; }

    Point_t Max() const { return c_max; }

    Point_t Center() const { return {CenterX(), CenterY(), CenterZ()}; }



    bool ContainsX(double x, double const wiggle = 1) const
    {
      return CoordinateContained(x, MinX(), MaxX(), wiggle);
    }

    bool ContainsY(double y, double const wiggle = 1) const
    {
      return CoordinateContained(y, MinY(), MaxY(), wiggle);
    }

    bool ContainsZ(double z, double const wiggle = 1) const
    {
      return CoordinateContained(z, MinZ(), MaxZ(), wiggle);
    }

    bool ContainsYZ(double y, double z, double const wiggle = 1) const
    {
      return ContainsY(y, wiggle) && ContainsZ(z, wiggle);
    }

    bool ContainsPosition(Point_t const& point, double wiggle = 1.0) const
    {
      return ContainsX(point.X(), wiggle) && ContainsYZ(point.Y(), point.Z(), wiggle);
    } // ContainsPosition()
    bool ContainsPosition(TVector3 const& point, double wiggle = 1.0) const;
    bool ContainsPosition(double const* point, double wiggle = 1.0) const;



    bool InFiducialX(double x, double neg_margin, double pos_margin) const
    {
      return CoordinateContained(x, MinX() + neg_margin, MaxX() - pos_margin);
    }
    bool InFiducialX(double x, double margin) const { return InFiducialX(x, margin, margin); }

    bool InFiducialY(double y, double neg_margin, double pos_margin) const
    {
      return CoordinateContained(y, MinY() + neg_margin, MaxY() - pos_margin);
    }
    bool InFiducialY(double y, double margin) const { return InFiducialY(y, margin, margin); }

    bool InFiducialZ(double z, double neg_margin, double pos_margin) const
    {
      return CoordinateContained(z, MinZ() + neg_margin, MaxZ() - pos_margin);
    }
    bool InFiducialZ(double z, double margin) const { return InFiducialZ(z, margin, margin); }


    // -- BEGIN -- Overlaps ----------------------------------------------------

    bool OverlapsX(BoxBoundedGeo const& other) const
    {
      return std::min(MaxX(), other.MaxX()) > std::max(MinX(), other.MinX());
    }

    bool OverlapsY(BoxBoundedGeo const& other) const
    {
      return std::min(MaxY(), other.MaxY()) > std::max(MinY(), other.MinY());
    }

    bool OverlapsZ(BoxBoundedGeo const& other) const
    {
      return std::min(MaxZ(), other.MaxZ()) > std::max(MinZ(), other.MinZ());
    }

    bool Overlaps(BoxBoundedGeo const& other) const
    {
      return OverlapsX(other) && OverlapsY(other) && OverlapsZ(other);
    }

    // -- END -- Overlaps ------------------------------------------------------

    static bool CoordinateContained(double c, double min, double max, double wiggle = 1.)
    {
      return (c >= (min > 0 ? min / wiggle : min * wiggle)) &&
             (c <= (max < 0 ? max / wiggle : max * wiggle));
    } // CoordinateContained()

    static bool CoordinateContained(double c, double const* range, double wiggle = 1.)
    {
      return CoordinateContained(c, range[0], range[1], wiggle);
    }


    void SetBoundaries(Coord_t x_min,
                       Coord_t x_max,
                       Coord_t y_min,
                       Coord_t y_max,
                       Coord_t z_min,
                       Coord_t z_max)
    {
      c_min.SetXYZ(x_min, y_min, z_min);
      c_max.SetXYZ(x_max, y_max, z_max);
      SortCoordinates();
    }

    void SetBoundaries(Coords_t lower, Coords_t upper)
    {
      c_min = lower;
      c_max = upper;
      SortCoordinates();
    }

    void ExtendToInclude(Coord_t x, Coord_t y, Coord_t z) { ExtendToInclude(Point_t(x, y, z)); }

    void ExtendToInclude(Point_t const& point)
    {
      set_min(c_min, point);
      set_max(c_max, point);
    }

    void ExtendToInclude(BoxBoundedGeo const& box)
    {
      set_min(c_min, box.Min());
      set_max(c_max, box.Max());
    } // ExtendToInclude()



    std::vector<TVector3> GetIntersections(TVector3 const& TrajectoryStart,
                                           TVector3 const& TrajectoryDirect) const;
    std::vector<Point_t> GetIntersections(Point_t const& TrajectoryStart,
                                          Vector_t const& TrajectoryDirect) const;

    static void set_min(Coord_t& var, Coord_t value)
    {
      if (value < var) var = value;
    }

    static void set_max(Coord_t& var, Coord_t value)
    {
      if (value > var) var = value;
    }

    static void set_min(Coords_t& var, Point_t const& value)
    {
      if (value.X() < var.X()) var.SetX(value.X());
      if (value.Y() < var.Y()) var.SetY(value.Y());
      if (value.Z() < var.Z()) var.SetZ(value.Z());
    }

    static void set_max(Coords_t& var, Point_t const& value)
    {
      if (value.X() > var.X()) var.SetX(value.X());
      if (value.Y() > var.Y()) var.SetY(value.Y());
      if (value.Z() > var.Z()) var.SetZ(value.Z());
    }

  private:
    // we don't allow the derived classes to mess with the boundaries
    Coords_t c_min; 
    Coords_t c_max; 

    void SortCoordinates();

  }; // class BoxBoundedGeo

} // namespace geo

#endif // LARCOREALG_GEOMETRY_BOXBOUNDEDGEO_H