Brief description of class still missing. More...

#include <IrregularGrid2DData.h>

Public Member Functions
const double *	axisData (AxisType axis) const
double	bottom (int iy) const
void	clear ()
Point2D	coordinates (int ix, int iy) const
Curve< Point2D >	crossSection (AxisType axis, int ixy) const
Curve< Point2D >	crossSection (Segment2D seg, double deltaX=0) const
Curve< Point2D >	crossSection (const Curve< Point2D > &path, double deltaX=0) const
void	cut (AxisType axis, double min, double max, SamplingOptions options)
template<class CurveClass , class PointClass >
CurveClass	followMaximumX () const
template<class CurveClass , class PointClass >
CurveClass	followMaximumX (int ixMin, int ixMax, int iyMax) const
template<class CurveClass , class PointClass >
void	followMaximumX (CurveClass &curve, double min, double max) const
template<class CurveClass , class PointClass >
CurveClass	followMaximumY () const
template<class CurveClass , class PointClass >
CurveClass	followMaximumY (int iyMin, int iyMax, int ixMax) const
template<class CurveClass , class PointClass >
void	followMaximumY (CurveClass &curve, double min, double max) const
double	height (int iy) const
int	indexOfX (double x) const
int	indexOfY (double y) const
void	init (int nx, int ny)
void	init (double value=0.0)
void	init (int nx, int ny, double value)
Curve< Point2D >	integralCrossSection (AxisType axis, int index) const
void	inverse (AxisType axis)
	IrregularGrid2DData ()
	IrregularGrid2DData (int nx, int ny)
	IrregularGrid2DData (const IrregularGrid2DData &o)
bool	isLike (IrregularGrid2DData &o) const
double *	iterator (AxisType along, int index, int &di, int &n) const
double	left (int ix) const
void	log10 (AxisType axis)
void	log10 ()
double	maximumAxis (AxisType axis) const
double	maximumValue () const
double	maximumValue (int &ix, int &iy) const
double	mean (AxisType along, int index) const
double	median (AxisType along, int index) const
double	minimumAxis (AxisType axis) const
double	minimumValue () const
double	minimumValue (int &ix, int &iy) const
double	mode (AxisType along, int index) const
void	multiplyCoordinates (AxisType axis, double fac)
void	multiplyValues (AxisType along, int index, double fac)
void	multiplyValues (double fac)
double	normalize (AxisType along, int index)
int	nx () const
int	ny () const
void	operator+= (const IrregularGrid2DData &o)
void	operator= (const IrregularGrid2DData &o)
void	operator= (const GridSearch &o)
void	pow10 (AxisType axis)
void	pow10 ()
void	printValues (AxisType along, int index)
void	resample (AxisType axis, const QVector< double > &xModel, SamplingOptions options)
void	resample (AxisType axis, int n, double min, double max, SamplingOptions options)
double	right (int ix) const
void	setLinear (AxisType axis, double min, double max)
void	setLog (AxisType axis, double min, double max)
void	setValue (int ix, int iy, double val)
void	setX (int ix, double val)
void	setY (int iy, double val)
void	smooth (AxisType along, int index)
double	smoothInvalidCells (AxisType along, int index, double invalidValue, double sigma2, double RVal, bool modify)
double	sum (AxisType along, int index) const
double	top (int iy) const
double	value (int ix, int iy) const
double *	valuePointer (int ix, int iy)
const double *	valuePointer (int ix, int iy) const
double	variance (AxisType along, int index) const
double	variance (AxisType along, int index, double average) const
double	width (int ix) const
double	x (int ix) const
QVector< double >	x () const
const double *	xPointer () const
double *	xPointer ()
double	y (int iy) const
QVector< double >	y () const
const double *	yPointer () const
double *	yPointer ()
	~IrregularGrid2DData ()

Detailed Description

Brief description of class still missing.

Full description of class still missing

Constructor & Destructor Documentation

QGpCoreTools::IrregularGrid2DData::IrregularGrid2DData ( )

Description of constructor still missing

References TRACE.

  : QSharedData()
{
  TRACE;
  _x=0;
  _y=0;
  _nx=_ny=0;
  _n2x=_n2y=0;
  _values=0;
}

QGpCoreTools::IrregularGrid2DData::IrregularGrid2DData	(	int	nx,
		int	ny
	)

References nx(), ny(), TRACE, TRACE_BUG, and TRACE_BUG_INT.

  : QSharedData()
{
  TRACE;
  _nx=nx;
  _ny=ny;
  ASSERT(_nx>0 && _ny>0);
  TRACE_BUG;
  TRACE_BUG_INT(nx);
  TRACE_BUG_INT(ny);
  initLookup();
  _x=new double[ nx ];
  _y=new double[ ny ];
  _values=new double[ _nx * _ny ];
}

QGpCoreTools::IrregularGrid2DData::IrregularGrid2DData ( const IrregularGrid2DData & o )

References TRACE.

  : QSharedData(o)
{
  TRACE;
  _nx=o._nx;
  _ny=o._ny;
  _n2x=o._n2x;
  _n2y=o._n2y;
  _x=new double[ _nx ];
  _y=new double[ _ny ];
  int n=_nx * _ny;
  _values=new double[ n ];
  memcpy(_x, o._x, sizeof(double)*_nx);
  memcpy(_y, o._y, sizeof(double)*_ny);
  memcpy(_values, o._values, sizeof(double)*n);
}

QGpCoreTools::IrregularGrid2DData::~IrregularGrid2DData ( )

Description of destructor still missing

References clear(), and TRACE.

{
  TRACE;
  clear();
}

Member Function Documentation

const double* QGpCoreTools::IrregularGrid2DData::axisData ( AxisType axis ) const [inline]

{int n; return getAxis(axis,n);}

double QGpCoreTools::IrregularGrid2DData::bottom ( int iy ) const [inline]

Referenced by crossSection().

{return leftOrBottom(_y, _ny,iy);}

void QGpCoreTools::IrregularGrid2DData::clear ( )

References TRACE.

Referenced by operator=(), and ~IrregularGrid2DData().

{
  TRACE;
  delete [] _x;
  delete [] _y;
  delete [] _values;
  _x=0;
  _y=0;
  _values=0;
  _nx=_ny=0;
  _n2x=_n2y=0;
}

Point2D QGpCoreTools::IrregularGrid2DData::coordinates	(	int	ix,
		int	iy
	)		const `[inline]`

{
  return Point2D(_x[ix],_y[iy]);
}

Curve< Point2D > QGpCoreTools::IrregularGrid2DData::crossSection	(	AxisType	axis,
		int	ixy
	)		const

Returns a cross section along axis at index ixy

References QGpCoreTools::Curve< pointType >::setFunction(), setX(), setY(), value(), and QGpCoreTools::XAxis.

Referenced by crossSection(), cut(), followMaximumX(), followMaximumY(), and resample().

{
  int n;
  double * val=getAxis(axis, n);
  Curve<Point2D> f (n);
  for(int i=0;i < n;i++ ) f[i].setX(val[ i ] );
  if(axis ==XAxis) {
    for(int i=0;i < n;i++ ) f[i].setY(value(i, ixy));
  } else {
    for(int i=0;i < n;i++ ) f[i].setY(value(ixy, i));
  }
  f.setFunction();
  return f;
}

Curve< Point2D > QGpCoreTools::IrregularGrid2DData::crossSection	(	Segment2D	seg,
		double	deltaX = `0`
	)		const

Return a cross section through the grid along the segment seg. deltaX is an optional offset on the X values of the produced curve.

References QGpCoreTools::Curve< pointType >::append(), QGpCoreTools::Curve< pointType >::at(), bottom(), QGpCoreTools::Curve< pointType >::count(), QGpCoreTools::Point2D::distanceTo(), indexOfX(), indexOfY(), QGpCoreTools::Segment2D::intersects(), left(), QGpCoreTools::Segment2D::p1(), QGpCoreTools::Segment2D::p2(), right(), QGpCoreTools::Segment2D::set(), QGpCoreTools::Point2D::setX(), QGpCoreTools::Point2D::setY(), top(), value(), QGpCoreTools::Point2D::x(), and QGpCoreTools::Point2D::y().

{
  Curve<Point2D> interX;
  Curve<Point2D> interY;
  Segment2D gseg;
  int i, firstX=-1, firstY=-1;
  double v, l1, l2;
  Point2D p;
  // Looking for X intersections
  l1=bottom(0);
  l2=top(_ny - 1);
  v=left(0);
  gseg.set(v, l1, v, l2);
  if(seg.intersects(gseg, p)) {
    interX.append(p);
    firstX=0;
    //printf("first ix %i inter: %lg %lg\n",firstX,p.x,p.y);
  }
  for(i=0;i < _nx;i++ ) {
    v=right(i);
    gseg.set(v, l1, v, l2);
    if(seg.intersects(gseg, p)) {
      interX.append(p);
      if(firstX==-1) firstX=i + 1;
      //printf("first ix %i inter: %lg %lg\n",firstX,p.x,p.y);
    }
  }
  // Looking for Y intersections
  l1=left(0);
  l2=right(_nx - 1);
  v=bottom(0);
  gseg.set(l1, v, l2, v);
  if(seg.intersects(gseg, p)) {
    interY.append(p);
    firstY=0;
    //printf("first iy %i inter: %lg %lg\n",firstY,p.x,p.y);
  }
  for(i=0;i < _ny;i++ ) {
    v=top(i);
    gseg.set(l1, v, l2, v);
    if(seg.intersects(gseg, p)) {
      interY.append(p);
      if(firstY==-1) firstY=i + 1;
      //printf("first iy %i inter: %lg %lg\n",firstY,p.x,p.y);
    }
  }
  Curve<Point2D> f;
  int iX, iY;
  int incX, incY;
  int endX, endY;
  if(seg.p1().x() <= seg.p2().x()) {
    endX=interX.count();
    iX=0;
    incX=1;
    if(firstX==-1) {
      firstX=indexOfX(seg.p1().x());
      if(firstX==_nx) firstX -= 2;
      else if(firstX==-1) firstX += 2;
      else firstX++;
    }
  } else {
    endX=-1;
    iX=interX.count() - 1;
    incX=-1;
    firstX += iX;
    if(firstX==-1) {
      firstX=indexOfX(seg.p1().x());
      if(firstX==_nx) firstX--;
      else if(firstX==-1) firstX++;
    }
    //printf("Reversing X\n");
  }
  if(seg.p1().y() <= seg.p2().y()) {
    endY=interY.count();
    iY=0;
    incY=1;
    if(firstY==-1) {
      firstY=indexOfY(seg.p1().y());
      if(firstY==_ny) firstY -= 2;
      else if(firstY==-1) firstY += 2;
      else firstY++;
    }
  } else {
    endY=-1;
    iY=interY.count() - 1;
    incY=-1;
    firstY += iY;
    if(firstY==-1) {
      firstY=indexOfY(seg.p1().y());
      if(firstY==_ny) firstY--;
      else if(firstY==-1) firstY++;
   }
    //printf("Reversing Y\n");
  }
  double dX, dY;
  int index;
  //printf("P1 %lg %lf\n",seg.p1().x,seg.p1().y);
  if(iX!=endX)
    dX=seg.p1().distanceTo(interX.at(iX));
  else
    dX=1e99;
  if(iY!=endY)
    dY=seg.p1().distanceTo(interY.at(iY));
  else
    dY=1e99;
  while(iX!=endX || iY!=endY) {
    //printf("Next point on X %lg %lf\n",(*itX).x,(*itX).y);
    //printf("Next point on Y %lg %lf\n",(*itY).x,(*itY).y);
    //printf("dX=%lg dY=%lg\n",dX,dY);
    if(dX < dY) {
      if(incY<0)
        index=firstY < _ny ? firstY : _ny - 1;
      else
        index=firstY > 0 ? firstY - 1 : 0;
      //printf("index=%i\n",index);
      if(firstX==0) {
        p.setX(dX - deltaX);
        p.setY(value(0, index));
        f.append(p);
        //printf("x appending firstX %i : %lg %lg\n",firstX,resX->back(),resY->back());
        firstX += incX;
      } else if(firstX==_nx) {
        p.setX(dX - deltaX);
        p.setY(value(_nx - 1, index));
        f.append(p);
        //printf("x appending firstX %i : %lg %lg\n",firstX,resX->back(),resY->back());
        firstX += incX;
      } else {
        p.setX(dX - deltaX);
        if(incX<0)
          p.setY(value(firstX, index));
        else
          p.setY(value(firstX - 1, index));
        f.append(p);
        //printf("x appending firstX %i : %lg %lg\n",firstX,resX->back(),resY->back());
        if(firstX < _nx) {
          p.setX(dX - deltaX);
          if(incX<0)
            p.setY(value(firstX - 1, index));
          else
            p.setY(value(firstX, index));
          f.append(p);
          //printf("x appending firstX %i : %lg %lg\n",firstX,resX->back(),resY->back());
          firstX += incX;
        }
      }
      iX+=incX;
      if(iX!=endX)
        dX=seg.p1().distanceTo(interX.at(iX));
      else
        dX=1e99;
    } else {
      if(incX<0)
        index=firstX < _ny ? firstX : _nx - 1;
      else
        index=firstX > 0 ? firstX - 1 : 0;
      //printf("index=%i\n",index);
      if(firstY==0) {
        p.setX(dY - deltaX);
        p.setY(value(index, 0));
        f.append(p);
        //printf("y appending firstY %i : %lg %lg\n",firstY,resX->back(),resY->back());
        firstY += incY;
      } else if(firstY==_ny) {
        p.setX(dY - deltaX);
        p.setY(value(index, _ny - 1));
        f.append(p);
        //printf("y appending firstY %i : %lg %lg\n",firstY,resX->back(),resY->back());
        firstY += incY;
      } else {
        p.setX(dY - deltaX);
        if(incY<0)
          p.setY(value(index, firstY));
        else
          p.setY(value(index, firstY - 1));
        f.append(p);
        //printf("y appending firstY %i : %lg %lg\n",firstY,resX->back(),resY->back());
        if(firstY < _ny) {
          p.setX(dY - deltaX);
          if(incY<0)
            p.setY(value(index, firstY - 1));
          else
            p.setY(value(index, firstY));
          f.append(p);
          //printf("y appending firstY %i : %lg %lg\n",firstY,resX->back(),resY->back());
          firstY += incY;
        }
      }
      iY+=incY;
      if(iY!=endY)
        dY=seg.p1().distanceTo(interY.at(iY));
      else
        dY=1e99;
    }
  }
  return f;
}

Curve< Point2D > QGpCoreTools::IrregularGrid2DData::crossSection	(	const Curve< Point2D > &	path,
		double	deltaX = `0`
	)		const

Return a cross section through the grid along the curve path. deltaX is an optional offset on the X values of the produced curve.

References QGpCoreTools::Curve< pointType >::append(), QGpCoreTools::Curve< pointType >::at(), QGpCoreTools::Curve< pointType >::count(), crossSection(), QGpCoreTools::Curve< pointType >::last(), QGpCoreTools::Segment2D::set(), and QGpCoreTools::Point2D::x().

{
  Segment2D seg;
  int n=path.count();
  Curve<Point2D> curve;
  for(int i=1; i<n; i++) {
    seg.set(path.at(i-1), path.at(i));
    if(curve.count()==0) {
      curve.append(crossSection(seg, deltaX));
    } else {
      curve.append(crossSection(seg, -curve.last().x()));
    }
  }
  return curve;
}

void QGpCoreTools::IrregularGrid2DData::cut	(	AxisType	axis,
		double	min,
		double	max,
		SamplingOptions	options
	)

References QGpCoreTools::Curve< pointType >::count(), crossSection(), QGpCoreTools::Curve< pointType >::cut(), QGpCoreTools::Function, QGpCoreTools::Interpole, TRACE, x(), QGpCoreTools::XAxis, and y().

{
  TRACE;
  if(_ny < 2 || _nx < 2) return ;
  options |=Function; // curves returned by crossSection are always functions
  double * values=0, *x, *y, *val=0;
  int n=0;
  Curve<Point2D> valuesF;
  if(axis ==XAxis) {
    for(int iy=0;iy < _ny;iy++ ) {
      valuesF=crossSection(axis, iy);
      valuesF.cut(min, max, options | Interpole);
      if(iy==0) {
        n=valuesF.count();
        values=new double[ n * _ny ];
        val=values;
      }
      for(int ix=0;ix < n;ix++ ) val[ ix ]=valuesF[ ix ].y();
      val += n;
    }
    x=new double[ n ];
    delete [] _x;
    _x=x;
    for(int ix=0;ix < n;ix++ ) x[ ix ]=valuesF[ ix ].x();
    _nx=n;
  } else {
    for(int ix=0;ix < _nx;ix++ ) {
      valuesF=crossSection(axis, ix);
      valuesF.cut(min, max, options | Interpole);
      if(ix==0) {
        n=valuesF.count();
        values=new double[ _nx * n ];
        val=values;
      }
      int offY=0;
      for(int iy=0;iy < n;iy++, offY += _nx) val[ offY ]=valuesF[ iy ].y();
      val++;
    }
    y=new double[ n ];
    delete [] _y;
    _y=y;
    for(int iy=0;iy < n;iy++ ) y[ iy ]=valuesF[ iy ].x();
    _ny=n;
  }
  delete [] _values;
  _values=values;
}