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 <array>
#include <vector>


namespace geo {
  class BoxBoundedGeo {
      public:
    using Coords_t = geo::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; }
    
    geo::Point_t Min() const { return c_min; }
    
    geo::Point_t Max() const { return c_max; }
    
    geo::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
      (geo::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); }
    
    
    
    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(geo::Point_t(x, y, z)); }
    
    void ExtendToInclude(geo::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<geo::Point_t> GetIntersections
      (geo::Point_t const& TrajectoryStart, geo::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, geo::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, geo::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