structs.h

Go to the documentation of this file.

// include guard
#ifndef TF_PGPLOTSTRUCTS_H_VERSION

#define TF_PGPLOTSTRUCTS_H_VERSION \
  "TF_PGPLOTSTRUCTS_H   V1.0   (17-03-2015)"

namespace pgplot {


struct Trange {
  float min,max;
  Trange(const float& themin, const float& themax):
    min(themin), max(themax) { }
  Trange(const Trange& range):
    min(range.min), max(range.max) { }
  Trange(): min(0.), max(0.) { }
  Trange& extend(const Trange& range) {
    min=(min < range.min ? min : range.min);
    max=(max > range.max ? max : range.max);
    return(*this);
  }
  Trange& extendf(const float& f) {
    float d=f*this->abs();
    min -= d;
    max += d;
    return(*this);
  }
  Trange& shrink(const Trange& range) {
    min=(min > range.min ? min : range.min);
    max=(max < range.max ? max : range.max);
    return(*this);
  }
  Trange& shrinkf(const Trange& range) {
    float ar=this->fullrange();
    max=min+ar*range.max;
    min=min+ar*range.min;
    return(*this);
  }
  float absmax() const {
    float amin=(min < 0 ? -min : min);
    float amax=(max < 0 ? -max : max);
    return(amax > amin ? amax : amin);
  }
  float abs() const {
    float absrange=this->fullrange();
    return(absrange > 0 ? absrange : -absrange);
  }
  float fullrange() const { return(max-min); }
  Trange& lcutf(const float& fraction)
  { min=min+fraction*(max-min); return(*this); }
  Trange& hcutf(const float& fraction)
  { max=max-fraction*(max-min); return(*this); }
  Trange& lcut(const float& value)
  { min+=value; return(*this); }
  Trange& hcut(const float& value)
  { max-=value; return(*this); }
  template<typename T>
  Trange& operator*=(const T& value)
  { min*=value; max*=value; return(*this); }
  Trange& operator*=(const Trange& range)
  { 
    // order matters!
    float d=this->fullrange();
    max=min+range.max*d; 
    min+=range.min*d; 
    return(*this); 
  }
  Trange& swap() { float junk=min; min=max; max=junk; return(*this); }
  bool contains(const float& v) const { return((v>=this->min) &&
                                             (v<=this->max)); }
}; // struct Trange

/*----------------------------------------------------------------------*/

struct Trect {
  Trange x,y;
  Trect(const float& xmin, const float& xmax,
        const float& ymin, const float& ymax):
    x(Trange(xmin,xmax)), y(Trange(ymin,ymax)) { }
  Trect(const Trect& rect):
    x(rect.x), y(rect.y) { }
  Trect(const Trange& thex, const Trange& they): x(thex), y(they) { }
  Trect(): x(0.,0.), y(0.,0.) { }
  Trect& lcutf(const float& fraction)
  { x.lcutf(fraction); return(*this); }
  Trect& rcutf(const float& fraction)
  { x.hcutf(fraction); return(*this); }
  Trect& tcutf(const float& fraction)
  { y.hcutf(fraction); return(*this); }
  Trect& bcutf(const float& fraction)
  { y.lcutf(fraction); return(*this); }
  Trect& lcut(const float& fraction)
  { x.lcut(fraction); return(*this); }
  Trect& rcut(const float& fraction)
  { x.hcut(fraction); return(*this); }
  Trect& tcut(const float& fraction)
  { y.hcut(fraction); return(*this); }
  Trect& bcut(const float& fraction)
  { y.lcut(fraction); return(*this); }
  Trect& shrinkf(const Trect& rect)
  { x.shrinkf(rect.x); y.shrinkf(rect.y); return(*this); }
  Trect& shift(const float& dx, const float& dy)
  { x.min+=dx; x.max+=dx; y.min+=dy; y.max+=dy; return(*this); }
  Trect& shift(const Trange& off)
  { this->shift(off.min, off.max); return(*this); }
  Trect& operator*=(const Trect& rect)
  { x*=rect.x; y*=rect.y; return(*this); }
}; // struct Trect

/*----------------------------------------------------------------------*/

struct Tcoor {
  float x; 
  float y; 
  Tcoor& operator+=(const Tcoor& c)
  { this->x+=c.x; this->y+=c.y; return(*this); }
  Tcoor operator+(const Tcoor& c)
  { Tcoor r=(*this); return(r += c); }
  bool inside(const Trect& r) const
  { return(r.x.contains(this->x) && r.y.contains(this->y)); }
}; // struct Tcoor

/*----------------------------------------------------------------------*/

struct Tbbox {
  Tcoor coor[4]; 
  Tbbox();
  Tbbox(const float x[4], const float y[4]);
}; // struct Tbbox

/*----------------------------------------------------------------------*/

struct Tcol {
  union { float r,h; };
  union { float g,l; };
  union { float b,s; };
}; // struct Tcol

} // namespace pgplot

#endif // TF_PGPLOTSTRUCTS_H_VERSION (includeguard)

/* ----- END OF structs.h ----- */