h o m e

d o c u m e n t a t i o n

c l a s s h i e r a r c h y

---

Functions1D.h

//
//  Filename         : Functions1D.h
//  Author(s)        : Stephane Grabli, Emmanuel Turquin
//  Purpose          : Functions taking 1D input
//  Date of creation : 01/07/2003
//


//
//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
//   with this source distribution. 
//
//  This program is free software; you can redistribute it and/or
//  modify it under the terms of the GNU General Public License
//  as published by the Free Software Foundation; either version 2
//  of the License, or (at your option) any later version.
//
//  This program is distributed in the hope that it will be useful,
//  but WITHOUT ANY WARRANTY; without even the implied warranty of
//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//  GNU General Public License for more details.
//
//  You should have received a copy of the GNU General Public License
//  along with this program; if not, write to the Free Software
//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
//

#ifndef  FUNCTIONS1D_HPP
# define FUNCTIONS1D_HPP

# include "../system/Precision.h"
# include "../system/TimeStamp.h"
# include "ViewMap.h"
# include "Functions0D.h"
# include "Interface1D.h"
# include "../system/FreestyleConfig.h"
//
// UnaryFunction1D (base class for functions in 1D)
//

template <class T>
class /*LIB_VIEW_MAP_EXPORT*/ UnaryFunction1D
{
public:
  typedef T ReturnedValueType;
  
  UnaryFunction1D(){_integration = MEAN;}
  UnaryFunction1D(IntegrationType iType){_integration = iType;}
  virtual ~UnaryFunction1D() {}

  virtual string getName() const {
    return "UnaryFunction1D";
  }
  virtual T operator()(Interface1D& inter) {
    cerr << "Warning: operator() not implemented" << endl;
    return T(0);
  }
  void setIntegrationType(IntegrationType integration) {
    _integration = integration;
  }
  IntegrationType getIntegrationType() const {
    return _integration;
  }

protected:

  IntegrationType _integration;
};

# ifdef SWIG
%feature("director")                    UnaryFunction1D<void>;
%feature("director")                    UnaryFunction1D<unsigned>;
%feature("director")                    UnaryFunction1D<float>;
%feature("director")                    UnaryFunction1D<double>;
%feature("director")                    UnaryFunction1D<Vec2f>;
%feature("director")                    UnaryFunction1D<Vec3f>;

%template(UnaryFunction1DVoid)          UnaryFunction1D<void>;
%template(UnaryFunction1DUnsigned)      UnaryFunction1D<unsigned>;
%template(UnaryFunction1DFloat)         UnaryFunction1D<float>;
%template(UnaryFunction1DDouble)        UnaryFunction1D<double>;
%template(UnaryFunction1DVec2f)         UnaryFunction1D<Vec2f>;
%template(UnaryFunction1DVec3f)         UnaryFunction1D<Vec3f>;
%template(UnaryFunction1DVectorViewShape)               UnaryFunction1D<std::vector<ViewShape*> >;
# endif // SWIG


//
// Functions definitions
//

namespace Functions1D {

  // GetXF1D
  class LIB_VIEW_MAP_EXPORT GetXF1D : public UnaryFunction1D<real>
  {
  private:
    Functions0D::GetXF0D _func;
  public:
    GetXF1D(IntegrationType iType) : UnaryFunction1D<real>(iType){}
    string getName() const {
      return "GetXF1D";
    }
    real operator()(Interface1D& inter) ;
  };

  // GetYF1D
  class LIB_VIEW_MAP_EXPORT GetYF1D : public UnaryFunction1D<real>
  {
  private:
    Functions0D::GetYF0D _func;
  public:
    GetYF1D(IntegrationType iType = MEAN) : UnaryFunction1D<real>(iType){}
    string getName() const {
      return "GetYF1D";
    }
    real operator()(Interface1D& inter) ;
  };

  // GetZF1D
  class LIB_VIEW_MAP_EXPORT GetZF1D : public UnaryFunction1D<real>
  {
  private:
    Functions0D::GetZF0D _func;
  public:
    GetZF1D(IntegrationType iType = MEAN) : UnaryFunction1D<real>(iType){}
    string getName() const {
      return "GetZF1D";
    }
    real operator()(Interface1D& inter) ;
  };

  // GetProjectedXF1D
  class LIB_VIEW_MAP_EXPORT GetProjectedXF1D : public UnaryFunction1D<real>
  {
  private:
    Functions0D::GetProjectedXF0D _func;
  public:
    GetProjectedXF1D(IntegrationType iType = MEAN) : UnaryFunction1D<real>(iType){}
  public:
    string getName() const {
      return "GetProjectedXF1D";
    }
    real operator()(Interface1D& inter);
  };
  
  // GetProjectedYF1D
  class LIB_VIEW_MAP_EXPORT GetProjectedYF1D : public UnaryFunction1D<real>
  {
  private:
    Functions0D::GetProjectedYF0D _func;
  public:
    GetProjectedYF1D(IntegrationType iType = MEAN) : UnaryFunction1D<real>(iType){}
  public:
    string getName() const {
      return "GetProjectedYF1D";
    }
    real operator()(Interface1D& inter);
  };

  // GetProjectedZF1D
  class LIB_VIEW_MAP_EXPORT GetProjectedZF1D : public UnaryFunction1D<real>
  {
  private:
    Functions0D::GetProjectedZF0D _func;
  public:
    GetProjectedZF1D(IntegrationType iType = MEAN) : UnaryFunction1D<real>(iType){}
  public:
    string getName() const {
      return "GetProjectedZF1D";
    }
    real operator()(Interface1D& inter);
  };
  
  // Orientation2DF1D
  class LIB_VIEW_MAP_EXPORT Orientation2DF1D : public UnaryFunction1D<Vec2f>
  {
  private:
    Functions0D::VertexOrientation2DF0D _func;
  public:
    Orientation2DF1D(IntegrationType iType = MEAN) : UnaryFunction1D<Vec2f>(iType){}
    string getName() const {
      return "Orientation2DF1D";
    }
    Vec2f operator()(Interface1D& inter);
  };

  // Orientation3DF1D
  class LIB_VIEW_MAP_EXPORT Orientation3DF1D : public UnaryFunction1D<Vec3f>
  {
  private:
    Functions0D::VertexOrientation3DF0D _func;
  public:
    Orientation3DF1D(IntegrationType iType = MEAN) : UnaryFunction1D<Vec3f>(iType){}
    string getName() const {
      return "Orientation3DF1D";
    }
    Vec3f operator()(Interface1D& inter);
  };

  // ZDiscontinuityF1D
  class LIB_VIEW_MAP_EXPORT ZDiscontinuityF1D : public UnaryFunction1D<real>
  {
  private:
    Functions0D::ZDiscontinuityF0D _func;
  public:
    ZDiscontinuityF1D(IntegrationType iType = MEAN) : UnaryFunction1D<real>(iType){}
    string getName() const {
      return "ZDiscontinuityF1D";
    }
    real operator()(Interface1D& inter);
  };
  
  // QuantitativeInvisibilityF1D
  class LIB_VIEW_MAP_EXPORT QuantitativeInvisibilityF1D : public UnaryFunction1D<unsigned>
  {
  private:
    Functions0D::QuantitativeInvisibilityF0D _func;
  public:
    QuantitativeInvisibilityF1D(IntegrationType iType = MEAN) : UnaryFunction1D<unsigned int>(iType) {}
    string getName() const {
      return "QuantitativeInvisibilityF1D";
    }
    unsigned operator()(Interface1D& inter);
  };

  // CurveNatureF1D
  class LIB_VIEW_MAP_EXPORT CurveNatureF1D : public UnaryFunction1D<Nature::EdgeNature>
  {
  private:
    Functions0D::CurveNatureF0D _func;
  public:
    CurveNatureF1D(IntegrationType iType = MEAN) : UnaryFunction1D<Nature::EdgeNature>(iType) {}
    string getName() const {
      return "CurveNatureF1D";
    }
    Nature::EdgeNature operator()(Interface1D& inter);
  };

  // TimeStampF1D
  class LIB_VIEW_MAP_EXPORT TimeStampF1D : public UnaryFunction1D<void>
  {
  public:
    string getName() const {
      return "TimeStampF1D";
    }
    void operator()(Interface1D& inter);
  };

  // IncrementChainingTimeStampF1D
  class LIB_VIEW_MAP_EXPORT IncrementChainingTimeStampF1D : public UnaryFunction1D<void>
  {
  public:
    string getName() const {
      return "IncrementChainingTimeStampF1D";
    }
    void operator()(Interface1D& inter);
  };

  // ChainingTimeStampF1D
  class LIB_VIEW_MAP_EXPORT ChainingTimeStampF1D : public UnaryFunction1D<void>
  {
  public:
    string getName() const {
      return "ChainingTimeStampF1D";
    }
    void operator()(Interface1D& inter);
  };
  

  // Curvature2DAngleF1D
  class LIB_VIEW_MAP_EXPORT Curvature2DAngleF1D : public UnaryFunction1D<real>
  {
  public:
    Curvature2DAngleF1D(IntegrationType iType = MEAN) : UnaryFunction1D<real>(iType) {}
    string getName() const {
      return "Curvature2DAngleF1D";
    }
    real operator()(Interface1D& inter) {
      return integrate(_fun, inter.verticesBegin(), inter.verticesEnd(), _integration);
    }
  private:
    Functions0D::Curvature2DAngleF0D    _fun;
  };

  // Normal2DF1D
  class LIB_VIEW_MAP_EXPORT Normal2DF1D : public UnaryFunction1D<Vec2f>
  {
  public:
    Normal2DF1D(IntegrationType iType = MEAN) : UnaryFunction1D<Vec2f>(iType) {}
    string getName() const {
      return "Normal2DF1D";
    }
    Vec2f operator()(Interface1D& inter) {
      return integrate(_fun, inter.verticesBegin(), inter.verticesEnd(), _integration);
    }
  private:
    Functions0D::Normal2DF0D    _fun;
  };

  // GetShapeF1D
  class LIB_VIEW_MAP_EXPORT GetShapeF1D : public UnaryFunction1D<std::vector<ViewShape*> >
  {
  public:
    GetShapeF1D() : UnaryFunction1D<std::vector<ViewShape*> >() {}
    string getName() const {
      return "GetShapeF1D";
    }
    std::vector<ViewShape*> operator()(Interface1D& inter);
  };

  // GetOccludersF1D
  class LIB_VIEW_MAP_EXPORT GetOccludersF1D : public UnaryFunction1D<std::vector<ViewShape*> >
  {
  public:
    GetOccludersF1D() : UnaryFunction1D<std::vector<ViewShape*> >() {}
    string getName() const {
      return "GetOccludersF1D";
    }
    std::vector<ViewShape*> operator()(Interface1D& inter);
  };

  // GetOccludeeF1D
  class LIB_VIEW_MAP_EXPORT GetOccludeeF1D : public UnaryFunction1D<std::vector<ViewShape*> >
  {
  public:
    GetOccludeeF1D() : UnaryFunction1D<std::vector<ViewShape*> >() {}
    string getName() const {
      return "GetOccludeeF1D";
    }
    std::vector<ViewShape*> operator()(Interface1D& inter);
  };

  // internal

  // getOccludeeF1D
  LIB_VIEW_MAP_EXPORT
  void getOccludeeF1D(Interface1D& inter, set<ViewShape*>& oShapes);

  // getOccludersF1D
  LIB_VIEW_MAP_EXPORT
  void getOccludersF1D(Interface1D& inter, set<ViewShape*>& oShapes);

  // getShapeF1D
  LIB_VIEW_MAP_EXPORT
  void getShapeF1D(Interface1D& inter, set<ViewShape*>& oShapes);
  
} // end of namespace Functions1D

#endif // FUNCTIONS1D_HPP

---

Last modified 3 Mar 2008

© Stephane Grabli