codac_Tube.h

Go to the documentation of this file.

 
#ifndef __CODAC_TUBE_H__
#define __CODAC_TUBE_H__
 
#include <map>
#include <list>
#include <vector>
#include "codac_TFnc.h"
#include "codac_Slice.h"
#include "codac_Trajectory.h"
#include "codac_serialize_tubes.h"
#include "codac_tube_arithmetic.h"
#include "codac_TubeTreeSynthesis.h"
#include "codac_TubePolynomialSynthesis.h"
#include "codac_TubeSynthesis.h"
#include "codac_Polygon.h"
#include "codac_BoolInterval.h"
 
// The following define constant is now set in CMake configuration file:
//#define AUTO_SYNTHESIS_BY_DEFAULT false
 
namespace codac
{
  class TFnc;
  class Tube;
  class Slice;
  class Trajectory;
  class TubeTreeSynthesis;
  class TubePolynomialSynthesis;
 
  class Tube : public DynamicalItem
  {
    public:
 
 
      explicit Tube(const Interval& tdomain, const Interval& codomain = Interval::ALL_REALS);
 
      explicit Tube(const Interval& tdomain, double timestep, const Interval& codomain = Interval::ALL_REALS);
 
      explicit Tube(const Interval& tdomain, double timestep, const TFnc& f, int f_image_id = 0);
 
      explicit Tube(const std::vector<Interval>& v_tdomains, const std::vector<Interval>& v_codomains);
 
      Tube(const Tube& x);
 
      explicit Tube(const Tube& x, const TFnc& f, int f_image_id = 0);
 
      explicit Tube(const Trajectory& traj, double timestep);
 
      explicit Tube(const Trajectory& lb, const Trajectory& ub, double timestep);
 
      explicit Tube(const std::string& binary_file_name);
 
      explicit Tube(const std::string& binary_file_name, Trajectory *&traj);
 
      ~Tube();
 
      int size() const;
 
      const Tube primitive(const Interval& c = Interval(0.)) const;
 
      const Tube& operator=(const Tube& x);
 
      const Interval tdomain() const;
 
      const Polygon polygon_envelope() const;
 
      const Trajectory lb() const;
 
      const Trajectory ub() const;
 
 
      int nb_slices() const;
 
      Slice* slice(int slice_id);
 
      const Slice* slice(int slice_id) const;
 
      Slice* slice(double t);
 
      const Slice* slice(double t) const;
 
      Slice* first_slice();
 
      const Slice* first_slice() const;
 
      Slice* last_slice();
 
      const Slice* last_slice() const;
 
      Slice* wider_slice();
 
      const Slice* wider_slice() const;
 
      Slice* largest_slice();
 
      const Slice* largest_slice() const;
 
      Slice* steepest_slice();
 
      const Slice* steepest_slice() const;
 
      const Interval slice_tdomain(int slice_id) const;
 
      int time_to_index(double t) const;
 
      int index(const Slice* slice) const;
 
      void sample(double t);
 
      void sample(double t, Slice *slice_to_be_sampled);
 
      void sample(double t, const Interval& gate);
 
      void sample(const Tube& x);
 
      bool gate_exists(double t) const;
 
      void remove_gate(double t);
 
      void merge_similar_slices(double distance_threshold);
 
 
      const Interval codomain() const;
 
      double volume() const;
 
      const Interval operator()(int slice_id) const;
 
      const Interval operator()(double t) const;
 
      const Interval operator()(const Interval& t) const;
 
      const std::pair<Interval,Interval> eval(const Interval& t = Interval::ALL_REALS) const;
      
      const Interval interpol(double t, const Tube& v) const;
 
      const Interval interpol(const Interval& t, const Tube& v) const;
 
      const Interval invert(const Interval& y, const Interval& search_tdomain = Interval::ALL_REALS) const;
 
      void invert(const Interval& y, std::vector<Interval> &v_t, const Interval& search_tdomain = Interval::ALL_REALS) const;
 
      const Interval invert(const Interval& y, const Tube& v, const Interval& search_tdomain = Interval::ALL_REALS) const;
 
      void invert(const Interval& y, std::vector<Interval> &v_t, const Tube& v, const Interval& search_tdomain = Interval::ALL_REALS) const;
      
      double max_diam() const;
 
      double max_gate_diam(double& t) const;
 
      const Trajectory diam(bool gates_thicknesses = false) const;
 
      const Trajectory diam(const Tube& v) const;
 
 
      bool operator==(const Tube& x) const;
 
      bool operator!=(const Tube& x) const;
 
      bool is_subset(const Tube& x) const;
 
      bool is_strict_subset(const Tube& x) const;
 
      bool is_interior_subset(const Tube& x) const;
 
      bool is_strict_interior_subset(const Tube& x) const;
 
      bool is_superset(const Tube& x) const;
 
      bool is_strict_superset(const Tube& x) const;
 
      bool is_empty() const;
 
      const BoolInterval contains(const Trajectory& x) const;
 
      bool overlaps(const Tube& x, float ratio = 1.) const;
 
 
      const Tube& set(const Interval& y);
 
      const Tube& set(const Interval& y, int slice_id);
 
      const Tube& set(const Interval& y, double t);
 
      const Tube& set(const Interval& y, const Interval& t);
 
      const Tube& set_empty();
 
      const Tube& inflate(double rad);
 
      const Tube& inflate(const Trajectory& rad);
 
      Tube& truncate_tdomain(const Interval& tdomain);
 
      void shift_tdomain(double a);
 
 
      const std::pair<Tube,Tube> bisect(double t, float ratio = 0.49) const;
 
 
      const Tube& operator+=(const Interval& x);
 
      const Tube& operator+=(const Trajectory& x);
 
      const Tube& operator+=(const Tube& x);
 
      const Tube& operator-=(const Interval& x);
 
      const Tube& operator-=(const Trajectory& x);
 
      const Tube& operator-=(const Tube& x);
 
      const Tube& operator*=(const Interval& x);
 
      const Tube& operator*=(const Trajectory& x);
 
      const Tube& operator*=(const Tube& x);
 
      const Tube& operator/=(const Interval& x);
 
      const Tube& operator/=(const Trajectory& x);
 
      const Tube& operator/=(const Tube& x);
 
      const Tube& operator|=(const Interval& x);
 
      const Tube& operator|=(const Trajectory& x);
 
      const Tube& operator|=(const Tube& x);
 
      const Tube& operator&=(const Interval& x);
 
      const Tube& operator&=(const Trajectory& x);
 
      const Tube& operator&=(const Tube& x);
 
 
      const std::string class_name() const { return "Tube"; };
 
      friend std::ostream& operator<<(std::ostream& str, const Tube& x);
 
      // Tree synthesis structure
 
      void enable_synthesis(SynthesisMode mode = SynthesisMode::BINARY_TREE, double eps = 1.e-3) const;
 
 
      const Interval integral(double t) const;
 
      const Interval integral(const Interval& t) const;
 
      const Interval integral(const Interval& t1, const Interval& t2) const;
 
      const std::pair<Interval,Interval> partial_integral(const Interval& t) const;
 
      const std::pair<Interval,Interval> partial_integral(const Interval& t1, const Interval& t2) const;
 
 
      void serialize(const std::string& binary_file_name = "x.tube", int version_number = SERIALIZATION_VERSION) const;
 
      void serialize(const std::string& binary_file_name, const Trajectory& traj, int version_number = SERIALIZATION_VERSION) const;
 
 
      static bool same_slicing(const Tube& x1, const Tube& x2);
 
      static void enable_syntheses(bool enable = true);
 
      static const Tube hull(const std::list<Tube>& l_tubes);
 
    protected:
 
      Tube();
 
      const IntervalVector codomain_box() const;
 
      void deserialize(const std::string& binary_file_name, Trajectory *&traj);
 
      void create_synthesis_tree() const;
 
      void delete_synthesis_tree() const;
 
      void create_polynomial_synthesis(double eps) const;
 
      void delete_polynomial_synthesis() const;
 
      // Class variables:
 
        Slice *m_first_slice = nullptr; 
        mutable TubeTreeSynthesis *m_synthesis_tree = nullptr; 
        mutable TubePolynomialSynthesis *m_polynomial_synthesis = nullptr; 
        mutable SynthesisMode m_synthesis_mode = SynthesisMode::NONE; 
        Interval m_tdomain; 
 
      friend void deserialize_Tube(std::ifstream& bin_file, Tube *&tube);
      friend void deserialize_TubeVector(std::ifstream& bin_file, TubeVector *&tube);
      friend class TubeVector;
      friend class CtcEval;
 
      static bool s_enable_syntheses;
  };
}
 
#endif