scene_FunctionMixer.hpp

Go to the documentation of this file.

#ifndef FSHAKE3D_FunctionMixer_hpp
#define FSHAKE3D_FunctionMixer_hpp

#include "scene_ElevationGrid.hpp"
#include "math.hpp"
#include "opengl.hpp"
#include "boost/math/distributions/normal.hpp" 
#include <map>
#include <fstream>
#include "scene_Slider.hpp"
#include "scene_Plot1D.hpp"

class IFunction1D
{
public:
  virtual double compute(double x) = 0;
};

/*
template<typename T, typename F>
struct DFun : public IFunction1D
{
  DFun(const F& f) : mFunction(f) { }
  template<typename A>
  double operator () (T x) const { mFunction(x); }
  F mFunction;
};

DFun<normal> gDefaultNormalFunc();
*/

class NormalDistribution : public IFunction1D
{
public:
  virtual double compute(double x)
  {
    return pdf( mDistribution, x);
  }
  void setMean(double mean)
  {
    mDistribution = boost::math::normal( mean, mDistribution.standard_deviation() );
  }  
  void setSD(double sd)
  {
    mDistribution = boost::math::normal( mDistribution.mean(), sd );
  }
  double getMean() const
  {
    return mDistribution.mean();
  }
  double getSD() const
  {
    return mDistribution.standard_deviation();
  }
private:
  boost::math::normal mDistribution;
};

class HotSpot
{
public:
  HotSpot(double xmean, double ymean, double xsd=0.6, double ysd=0.6, double alpha=0.0)
    : mNx(xmean,xsd), mNy(ymean,ysd), mAlpha(alpha)
  {
  }
  double compute(double x, double y) const
  {
    return pdf( mNx, x) * pdf( mNy, y) * mAlpha;
  }
  double computeBase(double x, double y) const
  {
    return pdf( mNx, x) * pdf( mNy, y);
  }
  double computeX(double x) const
  {
    return pdf( mNx, x);
  }
  double computeY(double y) const
  {
    return pdf( mNy, y);
  }
  void setAlpha(double a)
  {
    mAlpha = a;
  }
  double getAlpha() const
  {
    return mAlpha;
  }
  double getXSD() const
  {
    return mNx.standard_deviation();
  }
  double getXMean() const
  {
    return mNx.mean();
  }
  double getYSD() const
  {
    return mNy.standard_deviation();
  }
  double getYMean() const
  {
    return mNy.mean();
  }
  void setXSD(double xsd)
  {
    mNx = boost::math::normal( mNx.mean(), xsd );
  }
  void setYSD(double ysd)
  {
    mNy = boost::math::normal( mNy.mean(), ysd );
  }
private:
  boost::math::normal mNx;
  boost::math::normal mNy;
  double mAlpha;
};

// using Point2d as key type for maps:
template<> struct std::less<Point2d> : public std::binary_function<Point2d, Point2d, bool>
{       // functor for operator<
        bool operator()(const Point2d& l, const Point2d& r) const
        {       // apply operator< to operands
    if ( l[0] == r[0] )
      return l[1] < r[1];
    return l[0] < r[0];
        }
};

enum Layers
{
  LAYER_NORMALS
, LAYER_GRID
, LAYER_CONTROLPOINTS
, LAYER_SURFACE
, LAYER_HOTSPOTS
// , LAYER_CONTROLPOINTS_POINTS
};

class FunctionMixer : public Node, public Shape, public Control3D
{
public:
  // constructor:
  FunctionMixer();

  // model:
  void setElevationGrid(ElevationGrid* pElevationGrid);
  // HotSpot* getHotSpotAtGridIndex(int x, int y);
  HotSpot* getHotSpotAtPoint2d(const Point2d& p);
  void addHotSpot(HotSpot* hs);
  void removeHotSpot(HotSpot* hs);
  void clear();
  double mDefaultXSD;
  double mDefaultYSD;
  double mDefaultAlpha;
  size_t   getHotSpotCount() { return mHotSpots.size(); }
  HotSpot& getHotSpotAtIndex(size_t index) { return *( mHotSpots[index] ); }

  // elevation computation:
  double computeAt(double x, double y);
  double computeAtWithout(double x, double y, HotSpot* pHotSpot);

  // HotSpot control:
  // void selectHotSpot(int x, int y);
  void selectHotSpot(const Point2d& p);
  void updateHotSpotZ(double z);
  void removeSelected();
  void setPointSize(double pointsize);
  // X SD control:
  void setXSD(double xsd);
  void setYSD(double ysd);
  // user input:
  bool select(const Rayd& r, SceneView& view);
  bool drag(const Rayd& r, SceneView& view);
  void unselect();
  // display:
  void toggleLayer(int layerid) { mLayerMask ^= (1<<layerid); }
  bool isLayerEnabled(int layerid) const { return (  mLayerMask & (1<<layerid) ) ? true : false; }
  void display();

  void updateElevationGrid();
private:
  void initControls();
  void displaySurface();
  void displayControls();
  void displayFunctionPlots();
  void displayAlpha();

  // compute Elevation z-values:

  // link:

  ElevationGrid* mpElevationGrid;

  // model:

  std::vector<HotSpot*> mHotSpots;
  // std::map< std::pair<int,int>, HotSpot* > mHotSpotMap;  
  std::map< Point2d, HotSpot* > mHotSpotMap;

  // view:

  // OpenGL display list for control point geometry (glutSphere)
  int    mList;

  // OpenGL color map 1D texture
  GLuint mTex;
  // Control point size (propagated to controls)
  double mPointSize;
  // notify to update ControlPoint geometry.
  bool   mPointSizeChanged;
  unsigned int mLayerMask;

  // control:

  HotSpot* mSelectHotSpot;
  double   mSelectHotSpotZ;
  double   mSelectBaseZ;
  Point3d  mSelectPoint;

  Slider mControlZ;
  Slider mControlXSD;
  Slider mControlYSD;
  Plot1D mPlotX;
  Plot1D mPlotY;
};


#endif