scene_FunctionMixer.cpp

Go to the documentation of this file.

#include "scene_FunctionMixer.hpp"
#include "opengl.hpp"
#include <boost/bind.hpp>
#include <float.h>

// --- constructor -----------------------------------------------------------

FunctionMixer::FunctionMixer()
: mpElevationGrid(0)
, mSelectHotSpot(0)
, mPointSize(1.0)
, mTex(-1)
, mList(-1)
, mLayerMask(~0U)
, mDefaultXSD(10.0)
, mDefaultYSD(10.0)
, mDefaultAlpha(0.0)
, mPointSizeChanged(true)
{
  initControls();
  setElevationGrid(0);
}

// --- initialize ui ---------------------------------------------------------

void FunctionMixer::initControls()
{
  Vec4d bgcolor(0.0,0.0,0.0,0.2);
  Vec4d colorx(0.8,0.8,0.8,0.3);
  Vec4d colory(0.8,0.8,0.8,0.3);
  Vec4d colorz(0.8,0.8,0.8,0.3);

  mControlZ.setBorder(mPointSize);
  mControlZ.setEnabled(false);
  mControlZ.setAxis(AXIS_Z);
  mControlZ.setUpAxis(AXIS_X);
  mControlZ.setColor(colorz);
  mControlZ.setBGColor(bgcolor);
  mControlZ.setAbsMode(ABSMODE_POSITIVE);  
  mControlZ.setKnobType(KNOB_TRANSLATE);
  // BUG: sensor volume is not displayed using  ( -DBL_MAX , DBL_MAX ) 
  // mControlZ.setMinValue(-DBL_MAX);
  // mControlZ.setMaxValue(DBL_MAX);
  mControlZ.setMinValue(-10000);
  mControlZ.setMaxValue(10000);
  mControlZ.setSlotValueChange( boost::bind( &FunctionMixer::updateHotSpotZ, this, _1 ) );  
  
  mControlXSD.setBorder(mPointSize);
  mControlXSD.setEnabled(false);
  mControlXSD.setAxis(AXIS_X);
  mControlXSD.setUpAxis(AXIS_Z);
  mControlXSD.setColor(colorx);
  mControlXSD.setBGColor(bgcolor);
  mControlXSD.setAbsMode(ABSMODE_MIRROR);
  mControlXSD.setKnobType(KNOB_STRETCH);
  mControlXSD.setMinValue(-10000);
  mControlXSD.setMaxValue(10000);
  // mControlXSD.setMinValue(DBL_MIN);
  // mControlXSD.setMaxValue(DBL_MAX);
  mControlXSD.setSlotValueChange( boost::bind( &FunctionMixer::setXSD, this, _1 ) );

  mControlYSD.setBorder(mPointSize);
  mControlYSD.setEnabled(false);
  mControlYSD.setAxis(AXIS_Y);
  mControlYSD.setUpAxis(AXIS_Z);
  mControlYSD.setColor(colory);
  mControlYSD.setBGColor(bgcolor);
  mControlYSD.setAbsMode(ABSMODE_MIRROR);
  mControlYSD.setKnobType(KNOB_STRETCH);
  mControlYSD.setMinValue(-10000);
  mControlYSD.setMaxValue(10000);
  // mControlYSD.setMinValue(DBL_MIN);
  // mControlYSD.setMaxValue(DBL_MAX);
  mControlYSD.setSlotValueChange( boost::bind( &FunctionMixer::setYSD, this, _1 ) );

  mPlotX.setEnabled(false);
  mPlotX.setColor(colorx);
  mPlotX.setSteps(100);
  mPlotX.setXAxis(0);
  mPlotX.setYAxis(2);
  mPlotX.setYScale(1000.0);

  mPlotY.setEnabled(false);
  mPlotY.setColor(colory);
  mPlotY.setSteps(100);
  mPlotY.setXAxis(1);
  mPlotY.setYAxis(2);
  mPlotY.setYScale(1000.0);

  if (mpElevationGrid)
  {
    mPlotX.setXLimits( mpElevationGrid->getXLimits() );
    mPlotY.setXLimits( mpElevationGrid->getYLimits() );
  }

}

// --- model -----------------------------------------------------------------

void FunctionMixer::clear()
{
  unselect();

  size_t n = getHotSpotCount();
  for (size_t i = 0; i < n ; ++i )
  {
    delete &getHotSpotAtIndex(i);
  }
  mHotSpots.clear();
  mHotSpotMap.clear();
  updateElevationGrid();
}

HotSpot* FunctionMixer::getHotSpotAtPoint2d(const Point2d& p)
{
  std::map< Point2d, HotSpot*>::iterator i = mHotSpotMap.find(p);
  if ( i == mHotSpotMap.end() )
  {
    HotSpot* pHotSpot = new HotSpot(p[0],p[1],mDefaultXSD,mDefaultYSD,mDefaultAlpha);
    addHotSpot(pHotSpot);
    return pHotSpot;
  }
  return i->second;

}


void FunctionMixer::setElevationGrid(ElevationGrid* pElevationGrid)
{
  unselect();
  mpElevationGrid = pElevationGrid;
  if (mpElevationGrid)
  {
    mPlotX.setXLimits( mpElevationGrid->getXLimits() );
    mPlotY.setXLimits( mpElevationGrid->getYLimits() );
  }
}

void FunctionMixer::addHotSpot(HotSpot* pHotSpot)
{
  mHotSpots.push_back(pHotSpot);
  mHotSpotMap[ Point2d( pHotSpot->getXMean(), pHotSpot->getYMean() ) ] = pHotSpot;
}

void FunctionMixer::removeHotSpot(HotSpot* pHotSpot)
{
  std::vector<HotSpot*>::iterator i = std::find( mHotSpots.begin(), mHotSpots.end(), pHotSpot );
  if ( i != mHotSpots.end() )
  {
    mHotSpots.erase(i);
  }
  std::map<Point2d,HotSpot*>::iterator j = mHotSpotMap.find( Point2d( pHotSpot->getXMean(), pHotSpot->getYMean() ) );
  if ( j != mHotSpotMap.end() )
  {
    mHotSpotMap.erase(j);
  }
  delete pHotSpot;
  updateElevationGrid();
}

// --- (re-) compute elevation grid ------------------------------------------

double FunctionMixer::computeAt(double x, double y)
{
  double z = 0;
  for ( std::vector<HotSpot*>::iterator i = mHotSpots.begin(), end = mHotSpots.end() ; i != end ; ++i )
  {
    z += (*i)->compute(x,y);
  }  
  return z;
}

double FunctionMixer::computeAtWithout(double x, double y, HotSpot* pHotSpot)
{
  double z = 0;
  for ( std::vector<HotSpot*>::iterator i = mHotSpots.begin(), end = mHotSpots.end() ; i != end ; ++i )
  {
    if (*i != pHotSpot)
      z += (*i)->compute(x,y);
  }  
  return z;
}


void FunctionMixer::updateElevationGrid()
{
  if (mpElevationGrid)
  {
    Vec2d xlim   = mpElevationGrid->getXLimits();
    Vec2d ylim   = mpElevationGrid->getYLimits();
    double xsize = xlim[1]-xlim[0];
    double ysize = ylim[1]-ylim[0];
    int nysteps  = mpElevationGrid->getYSteps();
    int nxsteps  = mpElevationGrid->getXSteps();

    for(int iy = 0; iy < nysteps ; ++iy )
    {
      double y = ylim[0] + (ysize/(nysteps-1))*iy;
      for (int ix = 0; ix < nxsteps ; ++ix )
      {
        double x = xlim[0] + (xsize/(nxsteps-1))*ix;
        
        double z = 0;
        for ( std::vector<HotSpot*>::iterator i = mHotSpots.begin(), end = mHotSpots.end() ; i != end ; ++i )
        {
          z += (*i)->compute(x,y);
        }
        mpElevationGrid->updatePositionZ(ix,iy,z);
      }
    }
    mpElevationGrid->computeNormals();
  }
}

// --- hotspot control -------------------------------------------------------

void FunctionMixer::selectHotSpot(const Point2d& p)
{
  mSelectHotSpot = getHotSpotAtPoint2d(p);
  if ( mSelectHotSpot )
  {
    mSelectPoint    = Vec3d(p[0],p[1], computeAt(p[0],p[1]) );
    mSelectHotSpotZ = mSelectHotSpot->computeBase(mSelectPoint[0],mSelectPoint[1]);
    mSelectBaseZ    = mSelectPoint[2] - mSelectHotSpot->compute(mSelectPoint[0],mSelectPoint[1]);
 
    // some coordinates:
    Point3d controlPosition( mSelectPoint[0], mSelectPoint[1], -0.1 );
    Point3d basePosition( mSelectPoint[0],mSelectPoint[1], 0.0 );

    // setup hotspot z control

    mControlZ.setPosition( basePosition );
    mControlZ.setValue( mSelectPoint[2] );
    mControlZ.setEnabled(true);

    // setup hotspot x/y standard deviation controls

    mControlXSD.setPosition( controlPosition );
    mControlXSD.setValue( mSelectHotSpot->getXSD() );
    mControlXSD.setEnabled(true);

    mControlYSD.setPosition( controlPosition );
    mControlYSD.setValue( mSelectHotSpot->getYSD() );
    mControlYSD.setEnabled(true);

    // setup plot controls

    mPlotX.setPosition( basePosition );
    mPlotY.setPosition( basePosition );
    mPlotX.setFunction( boost::bind( &HotSpot::computeX, mSelectHotSpot, _1 ) );
    mPlotY.setFunction( boost::bind( &HotSpot::computeY, mSelectHotSpot, _1 ) );
    // mPlotX.setEnabled(true);
    // mPlotY.setEnabled(true);
  }
}

// --- manipulate z ----------------------------------------------------------

void FunctionMixer::updateHotSpotZ(double z)
{
  if (mpElevationGrid)
  {
    if (mSelectHotSpot)
    {
      double restz = computeAtWithout(mSelectPoint[0],mSelectPoint[1], mSelectHotSpot);
      mSelectHotSpot->setAlpha( (z - restz) / mSelectHotSpot->computeBase(mSelectPoint[0],mSelectPoint[1]) );
      mSelectPoint[2] = computeAt(mSelectPoint[0],mSelectPoint[1]);
      updateElevationGrid();  
    }
  }
}

// --- manipulate sd ---------------------------------------------------------

/*
template<typename T>
inline T filter_sd(T x)
{
  return clamp<T>( abs(x), 0.0000000001, 100);
}
*/

void FunctionMixer::setXSD(double xsd)
{
  if (mSelectHotSpot)
  {    
    // update hotspot   
    mSelectHotSpot->setXSD( xsd );

    // update alpha
    updateHotSpotZ( mSelectPoint[2] );
  }
}

void FunctionMixer::setYSD(double ysd)
{
  if (mSelectHotSpot)
  {
    // update hotspot   
    mSelectHotSpot->setYSD( ysd );

    // update alpha
    updateHotSpotZ( mSelectPoint[2] );
  }
}

// --- user-input ------------------------------------------------------------

void FunctionMixer::setPointSize(double pointsize)
{
  mPointSize = pointsize;
  mControlZ.setBorder(mPointSize);
  mControlXSD.setBorder(mPointSize);
  mControlYSD.setBorder(mPointSize);
  mPointSizeChanged = true;  
}


void FunctionMixer::removeSelected()
{
  if (mSelectHotSpot)
  {
    HotSpot* hs = mSelectHotSpot;
    unselect();
    removeHotSpot(hs);
  }
}

bool FunctionMixer::select(const Rayd& ray, SceneView& view)
{
  if (mpElevationGrid)
  {
    double t;
    Slider* pNear = 0;
    double  tnear = DBL_MAX;

    if ( mControlZ.hit(ray, t) )
    {
      pNear = &mControlZ;
      tnear = t;
    }

    if ( mControlXSD.hit(ray, t) )
    {
      if ( t < tnear)
      {
        pNear = &mControlXSD;
        tnear = t;
      }
    }

    if (mControlYSD.hit(ray,t) )
    {
      if (t < tnear)
      {
        pNear = &mControlYSD;
        tnear = t;
      }
    }

    if (pNear)
    {
      pNear->select(ray,view);
      return true;
    }

    int x,y;
    if ( mpElevationGrid->intersect(ray, x, y, mPointSize ) )
    {
      Point3d p = mpElevationGrid->getPoint(x,y);
      selectHotSpot( Point2d(p[0],p[1]) );
      mControlZ.select(ray,view);
      return true;
    }
  }
  unselect();
  return false;
}

void FunctionMixer::unselect()
{
  mSelectHotSpot = 0;
  mControlZ.setEnabled(false);
  mControlXSD.setEnabled(false);
  mControlYSD.setEnabled(false);
  mPlotX.setEnabled(false);
  mPlotY.setEnabled(false);
}

bool FunctionMixer::drag(const Rayd& ray, SceneView& view)
{
  if (mpElevationGrid)
  {
    if ( mControlZ.drag(ray,view) ) return true;
    if ( mControlXSD.drag(ray,view) ) return true;
    if ( mControlYSD.drag(ray,view) ) return true;
  }
  return false;
}

// --- display ---------------------------------------------------------------


void FunctionMixer::display()
{ 
  if (mpElevationGrid)
  {
    displaySurface();
    if (mSelectHotSpot)
    {
      displayControls();
    }
  }
}

void FunctionMixer::displayControls()
{
  mControlZ.display();
  mControlXSD.display();
  mControlYSD.display();
  mPlotX.display();
  mPlotY.display();
}

void FunctionMixer::displayAlpha()
{
  glPushAttrib(GL_ENABLE_BIT|GL_LINE_BIT);
  glEnable(GL_BLEND);
  glColor4d(1.0,1.0,1.0,0.5);
  glDisable(GL_LIGHTING);
  glDisable(GL_DEPTH_TEST);
  double x = mSelectHotSpot->getXMean();
  double y = mSelectHotSpot->getYMean();
  double z = computeAt(x,y);
  glLineWidth(2.0);
  glBegin(GL_LINES);
  glVertex3d(x,y,z);
  glVertex3d(x,y,z-mSelectHotSpot->getAlpha());
  glEnd();    
  glPopAttrib();
}

void FunctionMixer::displaySurface()
{  
  // GL resources:

  if (mList == -1)
  {
    // init Display List
    mList = glGenLists(1);
  }

  if (mPointSizeChanged)
  {
    glNewList(mList, GL_COMPILE);
    glutSolidSphere( mPointSize , 12, 12 );
    glEndList();
    mPointSizeChanged = false;
  }

  if (mTex == -1)
  {
    // init height color 1D texture
    glGenTextures(1, &mTex);
    glBindTexture(GL_TEXTURE_1D, mTex);
    glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
    glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_WRAP_S, GL_REPEAT);
    glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
    glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);

    Vec3d cols[4] = { Vec3d(0.3,0.5,0.3),Vec3d(0.8,0.6,0.4),Vec3d(1.0,1.0,1.0),Vec3d(0.0,0.0,1.0) };

    // Vec3d cols[4] = { Vec3d(0.3,0.5,0.3),Vec3d(0.8,0.6,0.4),Vec3d(0.6,1.0,0.6),Vec3d(1.0,0.6,0.6) };
    unsigned char* colormap = new_colormap(256, &cols[0], sizeof(cols)/sizeof(Vec3d) );
    
    glTexImage1D(GL_TEXTURE_1D, 0, GL_RGB, 256, 0, GL_RGB, GL_UNSIGNED_BYTE, colormap);
    delete [] colormap;
    glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
  }

  // display control points
  glEnable(GL_LIGHT0);

  // display hotspots
  if ( isLayerEnabled(LAYER_HOTSPOTS) )
  {
    glPushAttrib(GL_ENABLE_BIT);

    glEnable(GL_LIGHTING);
    glEnable(GL_DEPTH_TEST);

    GLfloat pointDiffuse[4] = { 0.7, 0.3, 0.3, 1.0 };
    GLfloat pointAmbient[4] = { 0.2, 0.2, 0.2, 1.0 };
    glMaterialfv(GL_FRONT, GL_DIFFUSE, pointDiffuse);
    glMaterialfv(GL_FRONT, GL_AMBIENT, pointAmbient);

    glMatrixMode(GL_MODELVIEW);
    for ( std::vector<HotSpot*>::iterator i = mHotSpots.begin(), end = mHotSpots.end() ; i != end ; ++i )
    {
      double x = (*i)->getXMean();
      double y = (*i)->getYMean();      
      double z = computeAt(x,y);
      glPushMatrix();
      glTranslated(x,y,z);
      glCallList(mList);
      glPopMatrix();
    }

    glPopAttrib();
  }

  if ( isLayerEnabled(LAYER_CONTROLPOINTS) )
  {

    glPushAttrib(GL_ENABLE_BIT);

    glEnable(GL_LIGHTING);
    glEnable(GL_DEPTH_TEST);

    GLfloat pointDiffuse[4] = { 0.5, 0.5, 0.5, 1.0 };
    // GLfloat pointAmbient[4] = { 0.5, 0.5, 0.5, 1.0 };
    GLfloat pointAmbient[4] = { 0.1, 0.1, 0.1, 1.0 };
    glMaterialfv(GL_FRONT, GL_DIFFUSE, pointDiffuse);
    glMaterialfv(GL_FRONT, GL_AMBIENT, pointAmbient);

    mpElevationGrid->drawPointLists(mList);

    glPopAttrib();

  }

  // display grid

  if ( isLayerEnabled(LAYER_GRID))
  {
    glPushAttrib(GL_ENABLE_BIT|GL_LINE_BIT);

    glEnable(GL_DEPTH_TEST);
    glLineWidth(1.5);

    glColor4d(0.0,0.0,0.0,0.5);
    mpElevationGrid->drawGrid();

    glPopAttrib();
  }

  // display surface

  if ( isLayerEnabled(LAYER_SURFACE) )
  {
    glPushAttrib(GL_ENABLE_BIT|GL_LIGHTING_BIT);
    glEnable(GL_LIGHTING);
    glEnable(GL_DEPTH_TEST);
    glEnable(GL_TEXTURE_1D);
    glLightModeli(GL_LIGHT_MODEL_TWO_SIDE, GL_TRUE);

    GLfloat surfaceDiffuse[4] = { 1.0, 1.0, 1.0, 1.0 };
    GLfloat surfaceAmbient[4] = { 0.5, 0.5, 0.5, 1.0 };
    glMaterialfv(GL_FRONT, GL_DIFFUSE, surfaceDiffuse);
    // glMaterialfv(GL_FRONT, GL_DIFFUSE, surfaceAmbient);
    glMaterialfv(GL_FRONT, GL_AMBIENT, surfaceAmbient);

    mpElevationGrid->drawQuadStripNormalT1D();
    glPopAttrib();
  }

  // display normals
  if ( isLayerEnabled(LAYER_NORMALS) )
  {
    glPushAttrib(GL_ENABLE_BIT|GL_LINE_BIT);
    glEnable(GL_BLEND);
    glEnable(GL_DEPTH_TEST);
    glDisable(GL_LIGHTING);
    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
    glEnable(GL_DEPTH_TEST);
    glLineWidth(1);
    glColor4d(0.8,0.4,0.4,0.3);
    mpElevationGrid->drawNormalLines(2.0);
    glPopAttrib();
  }

  if ( !isLayerEnabled(LAYER_CONTROLPOINTS) )
  {
    glPushAttrib(GL_ENABLE_BIT);    
    glEnable(GL_DEPTH_TEST);
    glColor3d(0.0,0.0,0.0);
    glPointSize(3);
    mpElevationGrid->drawPoints();
    glPopAttrib();
  }
}