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