static inline double qwtDistance(
const QwtDoublePoint &p1, const QwtDoublePoint &p2 )
{
double dx = p2.x() - p1.x();
double dy = p2.y() - p1.y();
return ::sqrt( dx * dx + dy * dy );
}
/*!
Draw lines from the pole
\param painter Painter
\param canvasRect Contents rect of the canvas in painter coordinates
\param pole Position of the pole in painter coordinates
\param radius Length of the lines in painter coordinates
\param azimuthMap Maps azimuth values to values related to 0.0, M_2PI
\param values Azimuth values, indicating the direction of the lines
*/
void QwtPolarGrid::drawRays(
QPainter *painter, const QwtDoubleRect &canvasRect,
const QwtDoublePoint &pole, double radius,
const QwtScaleMap &azimuthMap, const QwtValueList &values ) const
{
for ( int i = 0; i < int( values.size() ); i++ )
{
double azimuth = azimuthMap.xTransform( values[i] );
azimuth = ::fmod( azimuth, 2 * M_PI );
bool skipLine = false;
if ( testDisplayFlag( SmartScaleDraw ) )
{
const QwtAbstractScaleDraw::ScaleComponent bone =
QwtAbstractScaleDraw::Backbone;
if ( isClose( azimuth, 0.0 ) )
{
const AxisData &axis = d_data->axisData[QwtPolar::AxisRight];
if ( axis.isVisible && axis.scaleDraw->hasComponent( bone ) )
skipLine = true;
}
else if ( isClose( azimuth, M_PI / 2 ) )
{
const AxisData &axis = d_data->axisData[QwtPolar::AxisTop];
if ( axis.isVisible && axis.scaleDraw->hasComponent( bone ) )
skipLine = true;
}
else if ( isClose( azimuth, M_PI ) )
{
const AxisData &axis = d_data->axisData[QwtPolar::AxisLeft];
if ( axis.isVisible && axis.scaleDraw->hasComponent( bone ) )
skipLine = true;
}
else if ( isClose( azimuth, 3 * M_PI / 2.0 ) )
{
const AxisData &axis = d_data->axisData[QwtPolar::AxisBottom];
if ( axis.isVisible && axis.scaleDraw->hasComponent( bone ) )
skipLine = true;
}
}
if ( !skipLine )
{
const QwtDoublePoint pos = qwtPolar2Pos( pole, radius, azimuth );
/*
Qt4 is horrible slow, when painting primitives,
with coordinates far outside the visible area.
*/
QwtPolygon pa( 2 );
pa.setPoint( 0, pole.toPoint() );
pa.setPoint( 1, pos.toPoint() );
if ( testDisplayFlag( ClipGridLines ) )
pa = QwtClipper::clipPolygon( canvasRect.toRect(), pa );
QwtPainter::drawPolyline( painter, pa );
}
}
}
/*!
Constructs a rectangle with topLeft as the top-left corner and
size as the rectangle size.
*/
QwtDoubleRect::QwtDoubleRect(
const QwtDoublePoint &p, const QwtDoubleSize &size):
d_left(p.x()),
d_right(p.x() + size.width()),
d_top(p.y()),
d_bottom(p.y() + size.height())
{
}
/*!
Translate a point from plot into pixel coordinates
\return Point in pixel coordinates
\sa QwtPlotPicker::invTransform()
*/
QPoint QwtPlotPicker::transform(const QwtDoublePoint &pos) const
{
QwtScaleMap xMap = plot()->canvasMap(d_xAxis);
QwtScaleMap yMap = plot()->canvasMap(d_yAxis);
return QPoint(
xMap.transform(pos.x()),
yMap.transform(pos.y())
);
}
void QmitkHistogramWidget::OnSelect( const QwtDoublePoint& pos )
{
m_Marker->setXValue( this->Round(pos.x()) );
//unsigned int count = (unsigned int)(m_Histogram->data().value(pos.x()));
QString str = QString( "%1" )
.arg( (int)(this->Round(pos.x())), 0, 10 );
QwtText text(str);
text.setBackgroundBrush(QColor(200,150,0));
text.setFont(QFont("Helvetica", 14, QFont::Bold));
m_Marker->setLabel(text);
m_Plot->replot();
}
void LineMarker::setCoordStartPoint(const QwtDoublePoint& p)
{
if (QwtDoublePoint(d_rect.left(), d_rect.top()) == p)
return;
d_rect.setLeft(p.x());
d_rect.setTop(p.y());
const QwtScaleMap &xMap = d_plot->canvasMap(xAxis());
const QwtScaleMap &yMap = d_plot->canvasMap(yAxis());
d_start = QPoint(xMap.transform(p.x()), yMap.transform(p.y()));
}
/*!
\brief Translate a position into a position string
In case of HLineRubberBand the label is the value of the
y position, in case of VLineRubberBand the value of the x position.
Otherwise the label contains x and y position separated by a ´, ´.
The format for the double to string conversion is "%.4f".
\param pos Position
\return Position string
*/
QString QwtPlotPicker::cursorLabel(const QwtDoublePoint &pos) const
{
switch(rubberBand())
{
case HLineRubberBand:
return QString().sprintf("%.4f", pos.y());
case VLineRubberBand:
return QString().sprintf("%.4f", pos.x());
default:
return QString().sprintf("%.4f, %.4f", pos.x(), pos.y());
}
return QString::null; // make some dumb compilers happy
}
void LineMarker::setCoordEndPoint(const QwtDoublePoint& p)
{
if (QwtDoublePoint(d_rect.right(), d_rect.bottom()) == p)
return;
d_rect.setRight(p.x());
d_rect.setBottom(p.y());
const QwtScaleMap &xMap = d_plot->canvasMap(xAxis());
const QwtScaleMap &yMap = d_plot->canvasMap(yAxis());
d_end = QPoint(xMap.transform(p.x()), yMap.transform(p.y()));
}
QList<QwtDoublePoint> QwtCircleClipper::cuttingPoints(
Edge edge, const QwtDoublePoint &pos, double radius) const
{
QList<QwtDoublePoint> points;
if ( edge == Left || edge == Right )
{
const double x = (edge == Left) ? left() : right();
if ( qwtAbs(pos.x() - x) < radius )
{
const double off = ::sqrt(qwtSqr(radius) - qwtSqr(pos.x() - x));
const double y1 = pos.y() + off;
if ( y1 >= top() && y1 <= bottom() )
points += QwtDoublePoint(x, y1);
const double y2 = pos.y() - off;
if ( y2 >= top() && y2 <= bottom() )
points += QwtDoublePoint(x, y2);
}
}
else
{
const double y = (edge == Top) ? top() : bottom();
if ( qwtAbs(pos.y() - y) < radius )
{
const double off = ::sqrt(qwtSqr(radius) - qwtSqr(pos.y() - y));
const double x1 = pos.x() + off;
if ( x1 >= left() && x1 <= right() )
points += QwtDoublePoint(x1, y);
const double x2 = pos.x() - off;
if ( x2 >= left() && x2 <= right() )
points += QwtDoublePoint(x2, y);
}
}
return points;
}
void ProRataPeptideTable::pointMLESelected( const QwtDoublePoint point )
{
int iRow = 0;
unsigned int iMinIndex = 0;
double dMinDistance = 1000;
double dCurrentDistance = 0;
map< unsigned int, double > mIndexDistance;
for( unsigned int i = 0; i < vpepInfo.size(); i++ )
{
if( !vpepInfo.at(i)->getValidity() )
continue;
// the x and y axes are not in the same range
// take a sqrt to compress the difference
dCurrentDistance = sqrt( fabs( point.x() - vpepInfo.at(i)->getPCALog2Ratio() ) )
+ sqrt( fabs( point.y() - vpepInfo.at(i)->getPCALog2SNR() ) );
if( dCurrentDistance < dMinDistance )
{
dMinDistance = dCurrentDistance;
iMinIndex = i;
}
}
if( dMinDistance > 1000 )
return;
//QMessageBox::information( this, "Row to be selected, before intising", QString::number( iMinIndex ) );
iRow = (int)iMinIndex;
//QMessageBox::information( this, "Row to be selected", QString::number( iRow ) );
//qtwTable->selectRow( iRow ) ;
//qtwTable->showRow( iRow );
QAbstractItemView::SelectionMode sm = qtwTable->selectionMode();
qtwTable->setSelectionMode(QAbstractItemView::ExtendedSelection);
qtwTable->selectRow( iRow );
qtwTable->setSelectionMode(sm);
delete ppepRatio;
ppepRatio = new PeptideRatio;
vpepInfo.at(iRow)->setPeptideRatio( ppepRatio );
emit peptideClicked( ppepRatio );
emit peptideClicked( vpepInfo.at(iRow) );
//qtwTable->selectRow( 0 ) ;
}
/*!
\brief Translate a position into a position string
In case of HLineRubberBand the label is the value of the
y position, in case of VLineRubberBand the value of the x position.
Otherwise the label contains x and y position separated by a ',' .
The format for the double to string conversion is "%.4f".
\param pos Position
\return Position string
*/
QwtText QwtPlotPicker::trackerText(const QwtDoublePoint &pos) const
{
QString text;
switch(rubberBand())
{
case HLineRubberBand:
text.sprintf("%.4f", pos.y());
break;
case VLineRubberBand:
text.sprintf("%.4f", pos.x());
break;
default:
text.sprintf("%.4f, %.4f", pos.x(), pos.y());
}
return QwtText(text);
}
bool QwtPolygonClipperF::insideEdge(const QwtDoublePoint &p, Edge edge) const
{
switch(edge)
{
case Left:
return p.x() > left();
case Top:
return p.y() > top();
case Right:
return p.x() < right();
case Bottom:
return p.y() < bottom();
default:
break;
}
return false;
}
/**
* This overrides the base class trackerText() function so that we can
* continuously emit a signal as the mouse is moved.
*
* @param pos The current mouse location.
*/
QwtText TrackingPicker::trackerText(const QwtDoublePoint &pos) const {
emit mouseMoved(pos.toPoint());
if (m_hideReadout) {
return QwtText();
} else // call super class trackerText
{ // so the tracker text still works
return QwtPlotPicker::trackerText(pos);
}
}
void SpecBox::setMarker(QwtDoublePoint n) {
QString out;
out.setNum(n.x(),'g',3);
//picker->transform(n);
//cout << "marker set at " << n.x() << "\n";
//fcenter->setXValue((double) n.x());
//fcenter->setLabel(QwtText(out));
//plot->LabelFrequency->setLabel(QwtText(out));
plot->replot();
}
/*!
\brief Calculate the bounding rect of the plot area
The plot area depends on the zoom parameters.
\param canvasRect Rectangle of the canvas
\return Rectangle for displaying 100% of the plot
*/
QwtDoubleRect QwtPolarPlot::plotRect( const QRect &canvasRect ) const
{
const QwtScaleDiv *sd = scaleDiv( QwtPolar::Radius );
const QwtScaleEngine *se = scaleEngine( QwtPolar::Radius );
const int margin = plotMarginHint();
const QRect cr = canvasRect;
const int radius = qwtMin( cr.width(), cr.height() ) / 2 - margin;
QwtScaleMap map;
map.setTransformation( se->transformation() );
map.setPaintXInterval( 0.0, radius / d_data->zoomFactor );
#if QWT_VERSION < 0x050200
map.setScaleInterval( sd->lBound(), sd->hBound() );
#else
map.setScaleInterval( sd->lowerBound(), sd->upperBound() );
#endif
double v = map.s1();
if ( map.s1() <= map.s2() )
v += d_data->zoomPos.radius();
else
v -= d_data->zoomPos.radius();
v = map.xTransform( v );
const QwtDoublePoint off =
QwtPolarPoint( d_data->zoomPos.azimuth(), v ).toPoint();
QwtDoublePoint center( cr.center().x(), cr.top() + margin + radius );
center -= QwtDoublePoint( off.x(), -off.y() );
QwtDoubleRect rect( 0, 0, 2 * map.p2(), 2 * map.p2() );
rect.moveCenter( center );
return rect;
}
void LineDialog::displayCoordinates(int unit)
{
if (unit == ScaleCoordinates){
QwtDoublePoint sp = lm->startPointCoord();
xStartBox->setValue(sp.x());
xStartBox->show();
xStartPixelBox->hide();
yStartBox->setValue(sp.y());
yStartBox->show();
yStartPixelBox->hide();
QwtDoublePoint ep = lm->endPointCoord();
xEndBox->setValue(ep.x());
xEndBox->show();
xEndPixelBox->hide();
yEndBox->setValue(ep.y());
yEndBox->show();
yEndPixelBox->hide();
} else {
QPoint startPoint = lm->startPoint();
QPoint endPoint = lm->endPoint();
xStartBox->hide();
xStartPixelBox->setValue(startPoint.x());
xStartPixelBox->show();
yStartBox->hide();
yStartPixelBox->setValue(startPoint.y());
yStartPixelBox->show();
xEndBox->hide();
xEndPixelBox->setValue(endPoint.x());
xEndPixelBox->show();
yEndBox->hide();
yEndPixelBox->setValue(endPoint.y());
yEndPixelBox->show();
}
}
void LineDialog::displayCoordinates(int unit)
{
if (unit == ScaleCoordinates)
{
QwtDoublePoint sp = lm->startPointCoord();
xStartBox->setText(QString::number(sp.x()));
yStartBox->setText(QString::number(sp.y()));
QwtDoublePoint ep = lm->endPointCoord();
xEndBox->setText(QString::number(ep.x()));
yEndBox->setText(QString::number(ep.y()));
}
else
{
QPoint startPoint = lm->startPoint();
QPoint endPoint = lm->endPoint();
xStartBox->setText(QString::number(startPoint.x()));
yStartBox->setText(QString::number(startPoint.y()));
xEndBox->setText(QString::number(endPoint.x()));
yEndBox->setText(QString::number(endPoint.y()));
}
}
void UI::FunctionWidget::pickerSelected(const QwtDoublePoint& pos) {
double x,y;
//x = m_pPlot->invTransform(QwtPlot::xBottom,pos.x());
//y = m_pPlot->invTransform(QwtPlot::yLeft,pos.y());
emit pickerMouseSelected( pos.x(),pos.y() );
}
/**
* Zwraca "intensywność" spektrogramu w danym punkcie.
*
* W przypadku klasycznego spektrogramu jest to wartość danego prążka widma.
*
* @param pos punkt w którym pobieramy wartość
* @return intensywność
*/
double SpectrogramPlot::getIntensity(const QwtDoublePoint& pos) const
{
return spectrogram->data().value(pos.x(), pos.y());
}
/*!
Returns true if the point p is inside or on the edge of the rectangle;
otherwise returns false.
If proper is true, this function returns true only if p is inside
(not on the edge).
*/
bool QwtDoubleRect::contains(const QwtDoublePoint &p, bool proper) const
{
return contains(p.x(), p.y(), proper);
}
//! moves the center to pos, leaving the size unchanged
void QwtDoubleRect::moveCenter(const QwtDoublePoint &pos)
{
moveCenter(pos.x(), pos.y());
}
/*!
Calculate the bounding interval of the radial scale that is
visible on the canvas.
*/
QwtDoubleInterval QwtPolarPlot::visibleInterval() const
{
const QwtScaleDiv *sd = scaleDiv( QwtPolar::Radius );
const QwtDoubleRect cRect = canvas()->contentsRect();
const QwtDoubleRect pRect = plotRect( cRect.toRect() );
if ( cRect.contains( pRect.toRect() ) || !cRect.intersects( pRect ) )
{
#if QWT_VERSION < 0x050200
return QwtDoubleInterval( sd->lBound(), sd->hBound() );
#else
return QwtDoubleInterval( sd->lowerBound(), sd->upperBound() );
#endif
}
const QwtDoublePoint pole = pRect.center();
const QwtDoubleRect scaleRect = pRect & cRect;
const QwtScaleMap map = scaleMap( QwtPolar::Radius );
double dmin = 0.0;
double dmax = 0.0;
if ( scaleRect.contains( pole ) )
{
dmin = 0.0;
QwtDoublePoint corners[4];
corners[0] = scaleRect.bottomRight();
corners[1] = scaleRect.topRight();
corners[2] = scaleRect.topLeft();
corners[3] = scaleRect.bottomLeft();
dmax = 0.0;
for ( int i = 0; i < 4; i++ )
{
const double dist = qwtDistance( pole, corners[i] );
if ( dist > dmax )
dmax = dist;
}
}
else
{
if ( pole.x() < scaleRect.left() )
{
if ( pole.y() < scaleRect.top() )
{
dmin = qwtDistance( pole, scaleRect.topLeft() );
dmax = qwtDistance( pole, scaleRect.bottomRight() );
}
else if ( pole.y() > scaleRect.bottom() )
{
dmin = qwtDistance( pole, scaleRect.bottomLeft() );
dmax = qwtDistance( pole, scaleRect.topRight() );
}
else
{
dmin = scaleRect.left() - pole.x();
dmax = qwtMax( qwtDistance( pole, scaleRect.bottomRight() ),
qwtDistance( pole, scaleRect.topRight() ) );
}
}
else if ( pole.x() > scaleRect.right() )
{
if ( pole.y() < scaleRect.top() )
{
dmin = qwtDistance( pole, scaleRect.topRight() );
dmax = qwtDistance( pole, scaleRect.bottomLeft() );
}
else if ( pole.y() > scaleRect.bottom() )
{
dmin = qwtDistance( pole, scaleRect.bottomRight() );
dmax = qwtDistance( pole, scaleRect.topLeft() );
}
else
{
dmin = pole.x() - scaleRect.right();
dmax = qwtMax( qwtDistance( pole, scaleRect.bottomLeft() ),
qwtDistance( pole, scaleRect.topLeft() ) );
}
}
else if ( pole.y() < scaleRect.top() )
{
dmin = scaleRect.top() - pole.y();
dmax = qwtMax( qwtDistance( pole, scaleRect.bottomLeft() ),
qwtDistance( pole, scaleRect.bottomRight() ) );
}
else if ( pole.y() > scaleRect.bottom() )
{
dmin = pole.y() - scaleRect.bottom();
dmax = qwtMax( qwtDistance( pole, scaleRect.topLeft() ),
qwtDistance( pole, scaleRect.topRight() ) );
}
}
const double radius = pRect.width() / 2.0;
if ( dmax > radius )
dmax = radius;
QwtDoubleInterval interval;
interval.setMinValue( map.invTransform( dmin ) );
interval.setMaxValue( map.invTransform( dmax ) );
return interval;
}
/*!
Update the axis scale draw geometries
\param azimuthMap Maps azimuth values to values related to 0.0, M_2PI
\param radialMap Maps radius values into painter coordinates.
\param pole Position of the pole in painter coordinates
\param radius Radius of the complete plot area in painter coordinates
\sa updateScaleDiv()
*/
void QwtPolarGrid::updateScaleDraws(
const QwtScaleMap &azimuthMap, const QwtScaleMap &radialMap,
const QwtDoublePoint &pole, double radius ) const
{
const QPoint p = pole.toPoint();
const QwtDoubleInterval interval =
d_data->gridData[QwtPolar::ScaleRadius].scaleDiv.interval();
const int min = radialMap.transform( interval.minValue() );
const int max = radialMap.transform( interval.maxValue() );
const int l = max - min;
for ( int axisId = 0; axisId < QwtPolar::AxesCount; axisId++ )
{
AxisData &axis = d_data->axisData[axisId];
if ( axisId == QwtPolar::AxisAzimuth )
{
QwtRoundScaleDraw *scaleDraw = ( QwtRoundScaleDraw * )axis.scaleDraw;
scaleDraw->setRadius( qRound( radius ) );
scaleDraw->moveCenter( p );
double from = ::fmod( 90.0 - azimuthMap.p1() * 180.0 / M_PI, 360.0 );
if ( from < 0.0 )
from += 360.0;
scaleDraw->setAngleRange( from, from - 360.0 );
scaleDraw->setTransformation( azimuthMap.transformation()->copy() );
}
else
{
QwtScaleDraw *scaleDraw = ( QwtScaleDraw * )axis.scaleDraw;
switch ( axisId )
{
case QwtPolar::AxisLeft:
{
scaleDraw->move( p.x() - min, p.y() );
scaleDraw->setLength( -l );
break;
}
case QwtPolar::AxisRight:
{
scaleDraw->move( p.x() + min, p.y() );
scaleDraw->setLength( l );
break;
}
case QwtPolar::AxisTop:
{
scaleDraw->move( p.x(), p.y() - max );
scaleDraw->setLength( l );
break;
}
case QwtPolar::AxisBottom:
{
scaleDraw->move( p.x(), p.y() + max );
scaleDraw->setLength( -l );
break;
}
}
scaleDraw->setTransformation( radialMap.transformation()->copy() );
}
}
}
//! Set Value
void QwtPlotMarker::setValue(const QwtDoublePoint& pos)
{
setValue(pos.x(), pos.y());
}
void SectionWindow::relayMove(QwtDoublePoint p)
{
emit moved(p.x(), p.y());
}
QwtDoublePoint QwtPolygonClipperF::intersectEdge(const QwtDoublePoint &p1,
const QwtDoublePoint &p2, Edge edge ) const
{
double x=0.0, y=0.0;
double m = 0;
const double dy = p2.y() - p1.y();
const double dx = p2.x() - p1.x();
switch ( edge )
{
case Left:
x = left();
m = double(qwtAbs(p1.x() - x)) / qwtAbs(dx);
y = p1.y() + int(dy * m);
break;
case Top:
y = top();
m = double(qwtAbs(p1.y() - y)) / qwtAbs(dy);
x = p1.x() + int(dx * m);
break;
case Right:
x = right();
m = double(qwtAbs(p1.x() - x)) / qwtAbs(dx);
y = p1.y() + int(dy * m);
break;
case Bottom:
y = bottom();
m = double(qwtAbs(p1.y() - y)) / qwtAbs(dy);
x = p1.x() + int(dx * m);
break;
default:
break;
}
return QwtDoublePoint(x,y);
}
/** Called each time the mouse moves over the canvas */
QwtText CustomPicker::trackerText(const QwtDoublePoint &pos) const {
emit mouseMoved(pos.x(), pos.y());
return QwtText();
}
const QList<double> &levels, int flags) const
#else
QwtRasterData::ContourLines QwtRasterData::contourLines(
const QwtDoubleRect &rect, const QSize &raster,
const QValueList<double> &levels, int flags) const
#endif
{
ContourLines contourLines;
if ( levels.size() == 0 || !rect.isValid() || !raster.isValid() )
return contourLines;
const double dx = rect.width() / raster.width();
const double dy = rect.height() / raster.height();
const bool ignoreOnPlane =
flags & QwtRasterData::IgnoreAllVerticesOnLevel;
const QwtDoubleInterval range = this->range();
bool ignoreOutOfRange = false;
if ( range.isValid() )
ignoreOutOfRange = flags & IgnoreOutOfRange;
((QwtRasterData*)this)->initRaster(rect, raster);
for ( int y = 0; y < raster.height() - 1; y++ )
{
enum Position
{
Center,
TopLeft,
TopRight,
BottomRight,
BottomLeft,
NumPositions
};
Contour3DPoint xy[NumPositions];
for ( int x = 0; x < raster.width() - 1; x++ )
{
const QwtDoublePoint pos(rect.x() + x * dx, rect.y() + y * dy);
if ( x == 0 )
{
xy[TopRight].setPos(pos.x(), pos.y());
xy[TopRight].setZ(
value( xy[TopRight].x(), xy[TopRight].y())
);
xy[BottomRight].setPos(pos.x(), pos.y() + dy);
xy[BottomRight].setZ(
value(xy[BottomRight].x(), xy[BottomRight].y())
);
}
xy[TopLeft] = xy[TopRight];
xy[BottomLeft] = xy[BottomRight];
xy[TopRight].setPos(pos.x() + dx, pos.y());
xy[BottomRight].setPos(pos.x() + dx, pos.y() + dy);
xy[TopRight].setZ(
value(xy[TopRight].x(), xy[TopRight].y())
);
xy[BottomRight].setZ(
value(xy[BottomRight].x(), xy[BottomRight].y())
);
double zMin = xy[TopLeft].z();
double zMax = zMin;
double zSum = zMin;
for ( int i = TopRight; i <= BottomLeft; i++ )
{
const double z = xy[i].z();
zSum += z;
if ( z < zMin )
zMin = z;
if ( z > zMax )
zMax = z;
}
if ( ignoreOutOfRange )
{
if ( !range.contains(zMin) || !range.contains(zMax) )
continue;
}
if ( zMax < levels[0] ||
zMin > levels[levels.size() - 1] )
{
continue;
}
xy[Center].setPos(pos.x() + 0.5 * dx, pos.y() + 0.5 * dy);
xy[Center].setZ(0.25 * zSum);
const int numLevels = (int)levels.size();
for (int l = 0; l < numLevels; l++)
{
const double level = levels[l];
if ( level < zMin || level > zMax )
continue;
#if QT_VERSION >= 0x040000
QPolygonF &lines = contourLines[level];
#else
QwtArray<QwtDoublePoint> &lines = contourLines[level];
#endif
const ContourPlane plane(level);
QwtDoublePoint line[2];
Contour3DPoint vertex[3];
for (int m = TopLeft; m < NumPositions; m++)
{
vertex[0] = xy[m];
vertex[1] = xy[0];
vertex[2] = xy[m != BottomLeft ? m + 1 : TopLeft];
const bool intersects =
plane.intersect(vertex, line, ignoreOnPlane);
if ( intersects )
{
#if QT_VERSION >= 0x040000
lines += line[0];
lines += line[1];
#else
const int index = lines.size();
lines.resize(lines.size() + 2, QGArray::SpeedOptim);
lines[index] = line[0];
lines[index+1] = line[1];
#endif
}
}
}
}
}
((QwtRasterData*)this)->discardRaster();
return contourLines;
}
double QwtCircleClipper::toAngle(
const QwtDoublePoint &from, const QwtDoublePoint &to) const
{
if ( from.x() == to.x() )
return from.y() <= to.y() ? M_PI / 2.0 : 3 * M_PI / 2.0;
const double m = qwtAbs((to.y() - from.y()) / (to.x() - from.x()) );
double angle = ::atan(m);
if ( to.x() > from.x() )
{
if ( to.y() > from.y() )
angle = 2 * M_PI - angle;
}
else
{
if ( to.y() > from.y() )
angle = M_PI + angle;
else
angle = M_PI - angle;
}
return angle;
}