Exemplo n.º 1
0
/*!
  \brief Draw dots
  \param painter Painter
  \param xMap x map
  \param yMap y map
  \param from index of the first point to be painted
  \param to index of the last point to be painted
  \sa QwtCurve::drawPolyline, QwtCurve::drawLine, 
      QwtCurve::drawLines, QwtCurve::drawSpline, QwtCurve::drawSteps
      QwtCurve::drawPolyline, QwtCurve::drawPolygon
*/
void QwtCurve::drawDots(QPainter *painter,
    const QwtDiMap &xMap, const QwtDiMap &yMap, int from, int to)
{
    const bool doFill = painter->brush().style() != Qt::NoBrush;

    QPointArray polyline;
    if ( doFill )
        polyline.resize(to - from + 1);

    for (int i = from; i <= to; i++)
    {
        int xi = xMap.transform(x(i));
        int yi = yMap.transform(y(i));
        QwtPainter::drawPoint(painter, xi, yi);

        if ( doFill )
            polyline.setPoint(i - from, xi, yi);
    }

    if ( doFill )
    {
        closePolyline(xMap, yMap, polyline);
        painter->setPen(QPen(Qt::NoPen));
        QwtPainter::drawPolygon(painter, polyline);
    }
}
Exemplo n.º 2
0
/*!
  \brief Draw step function
  \param painter Painter
  \param xMap x map
  \param yMap y map
  \param from index of the first point to be painted
  \param to index of the last point to be painted
  \sa QwtCurve::draw, QwtCurve::drawCurve, QwtCurve::drawDots, 
      QwtCurve::drawLines, QwtCurve::drawSpline, QwtCurve::drawSticks
*/
void QwtCurve::drawSteps(QPainter *painter,
    const QwtDiMap &xMap, const QwtDiMap &yMap, int from, int to)
{
    QPointArray polyline(2 * (to - from) + 1);

    bool inverted = d_options & Yfx;
    if ( d_options & Inverted )
        inverted = !inverted;

    int i,ip;
    for (i = from, ip = 0; i <= to; i++, ip += 2)
    {
        int xi = xMap.transform(x(i));
        int yi = yMap.transform(y(i));

        if ( ip > 0 )
        {
            if (inverted)
                polyline.setPoint(ip - 1, polyline[ip-2].x(), yi);
            else
                polyline.setPoint(ip - 1, xi, polyline[ip-2].y());
        }

        polyline.setPoint(ip, xi, yi);
    }

    QwtPainter::drawPolyline(painter, polyline);

    if ( painter->brush().style() != Qt::NoBrush )
    {
        closePolyline(xMap, yMap, polyline);
        painter->setPen(QPen(Qt::NoPen));
        QwtPainter::drawPolygon(painter, polyline);
    }
}
/*!
    Translate a point from plot into pixel coordinates
    \return Point in pixel coordinates
    \sa QwtPlotPicker::invTransform()
*/
QPoint QwtPlotPicker::transform(const QwtDoublePoint &pos) const
{
    QwtDiMap xMap = plot()->canvasMap(d_xAxis);
    QwtDiMap yMap = plot()->canvasMap(d_yAxis);

    return QPoint(
        xMap.transform(pos.x()),
        yMap.transform(pos.y())
    );
}
/*!
    Translate a rectangle from plot into pixel coordinates
    \return Rectangle in pixel coordinates
    \sa QwtPlotPicker::invTransform()
*/
QRect QwtPlotPicker::transform(const QwtDoubleRect &rect) const
{
    QwtDiMap xMap = plot()->canvasMap(d_xAxis);
    QwtDiMap yMap = plot()->canvasMap(d_yAxis);

    const int x1 = xMap.transform(rect.x1());
    const int x2 = xMap.transform(rect.x2());
    const int y1 = yMap.transform(rect.y1());
    const int y2 = yMap.transform(rect.y2());

    return QRect(x1, y1, x2 - x1, y2 - y1);
}
Exemplo n.º 5
0
/*!
  \brief Draw sticks
  \param painter Painter
  \param xMap x map
  \param yMap y map
  \param from index of the first point to be painted
  \param to index of the last point to be painted
  \sa QwtCurve::draw, QwtCurve::drawCurve, QwtCurve::drawDots, 
      QwtCurve::drawLines, QwtCurve::drawSpline, QwtCurve::drawSteps
*/
void QwtCurve::drawSticks(QPainter *painter,
    const QwtDiMap &xMap, const QwtDiMap &yMap, int from, int to)
{
    int x0 = xMap.transform(d_ref);
    int y0 = yMap.transform(d_ref);

    for (int i = from; i <= to; i++)
    {
        int xi = xMap.transform(x(i));
        int yi = yMap.transform(y(i));

        if (d_options & Xfy)
            QwtPainter::drawLine(painter, x0, yi, xi, yi);
        else
            QwtPainter::drawLine(painter, xi, y0, xi, yi);
    }
}
Exemplo n.º 6
0
/*!
  \brief Draw symbols
  \param painter Painter
  \param symbol Curve symbol
  \param xMap x map
  \param yMap y map
  \param from index of the first point to be painted
  \param to index of the last point to be painted
*/
void QwtCurve::drawSymbols(QPainter *painter, QwtSymbol &symbol,
    const QwtDiMap &xMap, const QwtDiMap &yMap, int from, int to)
{
    painter->setBrush(symbol.brush());
    painter->setPen(symbol.pen());

    QRect rect;
    rect.setSize(QwtPainter::metricsMap().screenToLayout(symbol.size()));

    for (int i = from; i <= to; i++)
    {
        const int xi = xMap.transform(x(i));
        const int yi = yMap.transform(y(i));

        rect.moveCenter(QPoint(xi, yi));
        symbol.draw(painter, rect);
    }
}
Exemplo n.º 7
0
/*!
  \param axis Axis
  \return Map for the axis on the canvas. With this map pixel coordinates can
          translated to plot coordinates and vice versa.
  \sa QwtDiMap, QwtPlot::transform, QwtPlot::invTransform
  
*/
QwtDiMap QwtPlot::canvasMap(int axis) const
{
    QwtDiMap map;
    if ( d_canvas && d_scale[axis] )
    {
        const QwtScale *s = d_scale[axis];
        map = *s->scaleDraw();
        if ( axis == yLeft || axis == yRight )
        {
            int y = s->y() + s->startBorderDist() - d_canvas->y();
            int h = s->height() - s->startBorderDist() - s->endBorderDist();
            map.setIntRange(y + h, y);
        }
        else
        {
            int x = s->x() + s->startBorderDist() - d_canvas->x();
            int w = s->width() - s->startBorderDist() - s->endBorderDist();
            map.setIntRange(x, x + w);
        }
    }
    return map;
}
Exemplo n.º 8
0
void QwtCurve::closePolyline(const QwtDiMap &xMap, const QwtDiMap &yMap,
    QPointArray &pa) const
{
    const int sz = pa.size();
    if ( sz < 2 )
        return;

    pa.resize(sz + 2);

    if ( d_options & QwtCurve::Xfy )
    {
        pa.setPoint(sz,
            xMap.transform(d_ref), pa.point(sz - 1).y());
        pa.setPoint(sz + 1,
            xMap.transform(d_ref), pa.point(0).y());
    }
    else
    {
        pa.setPoint(sz,
            pa.point(sz - 1).x(), yMap.transform(d_ref));
        pa.setPoint(pa.size() - 1,
            pa.point(0).x(), yMap.transform(d_ref));
    }
}
/*!
    Translate a rectangle from pixel into plot coordinates

    \return Rectangle in plot coordinates
    \sa QwtPlotPicker::transform()
*/
QwtDoubleRect QwtPlotPicker::invTransform(const QRect &rect) const
{
    QwtDiMap xMap = plot()->canvasMap(d_xAxis);
    QwtDiMap yMap = plot()->canvasMap(d_yAxis);

    return QwtDoubleRect(
        xMap.invTransform(rect.left()),
        xMap.invTransform(rect.right()),
        yMap.invTransform(rect.top()),
        yMap.invTransform(rect.bottom())
    );
}
Exemplo n.º 10
0
/*!
  \param axis Axis
  \return Map for the axis on the canvas. With this map pixel coordinates can
          translated to plot coordinates and vice versa.
  \sa QwtDiMap, QwtPlot::transform, QwtPlot::invTransform
  
*/
QwtDiMap QwtPlot::canvasMap(int axis) const
{
    QwtDiMap map;
    if ( !d_canvas )
        return map;

    const QwtScaleDiv &sd = d_as[axis].scaleDiv();
    map.setDblRange(sd.lBound(), sd.hBound(), sd.logScale());

    if ( axisEnabled(axis) )
    {
        const QwtScale *s = d_scale[axis];
        if ( axis == yLeft || axis == yRight )
        {
            int y = s->y() + s->startBorderDist() - d_canvas->y();
            int h = s->height() - s->startBorderDist() - s->endBorderDist();
            map.setIntRange(y + h - 1, y);
        }
        else
        {
            int x = s->x() + s->startBorderDist() - d_canvas->x();
            int w = s->width() - s->startBorderDist() - s->endBorderDist();
            map.setIntRange(x, x + w - 1);
        }
    }
    else
    {
        const int margin = plotLayout()->canvasMargin(axis);

        const QRect &canvasRect = d_canvas->contentsRect();
        if ( axis == yLeft || axis == yRight )
        {
            map.setIntRange(canvasRect.bottom() - margin, 
                canvasRect.top() + margin);
        }
        else
        {
            map.setIntRange(canvasRect.left() + margin, 
                canvasRect.right() - margin);
        }
    }
    return map;
}
Exemplo n.º 11
0
void BoxCurve::drawSymbols(QPainter *painter, const QwtDiMap &xMap, const QwtDiMap &yMap, double *dat, int size)
{
const int px = xMap.transform(x(0));

QwtSymbol s = this->symbol();
if (min_style != QwtSymbol::None)
	{
	const int py_min = yMap.transform(y(0));
	s.setStyle(min_style);
	s.draw(painter, px, py_min);
	}
if (max_style != QwtSymbol::None)
	{
	const int py_max = yMap.transform(y(size - 1));
	s.setStyle(max_style);
	s.draw(painter, px, py_max);
	}
if (p1_style != QwtSymbol::None)
	{
	const int p1 = yMap.transform(gsl_stats_quantile_from_sorted_data (dat, 1, size, 0.01));
	s.setStyle(p1_style);
	s.draw(painter, px, p1);
	}
if (p99_style != QwtSymbol::None)
	{
	const int p99 = yMap.transform(gsl_stats_quantile_from_sorted_data (dat, 1, size, 0.99));
	s.setStyle(p99_style);
	s.draw(painter, px, p99);
	}
if (mean_style != QwtSymbol::None)
	{
	const int mean = yMap.transform(gsl_stats_mean(dat, 1, size));
	s.setStyle(mean_style);
	s.draw(painter, px, mean);
	}
}
Exemplo n.º 12
0
void BoxCurve::drawBox(QPainter *painter, const QwtDiMap &xMap, const QwtDiMap &yMap, double *dat, int size)
{
const int px = xMap.transform(x(0));
const int px_min = xMap.transform(x(0) - 0.5);
const int px_max = xMap.transform(x(0) + 0.5);
const int box_width = 1+(px_max - px_min)*b_width/100;
const int hbw = box_width/2;
const int median = yMap.transform(gsl_stats_median_from_sorted_data (dat, 1, size));
int b_lowerq, b_upperq;
double sd, se, mean;
if(w_range == SD || w_range == SE || b_range == SD || b_range == SE)
	{
	sd = gsl_stats_sd(dat, 1, size);
	se = sd/sqrt((double)size);
	mean = gsl_stats_mean(dat, 1, size);
	}

if(b_range == SD)
	{
	b_lowerq = yMap.transform(mean - sd*b_coeff);
	b_upperq = yMap.transform(mean + sd*b_coeff);
	}
else if(b_range == SE)
	{
	b_lowerq = yMap.transform(mean - se*b_coeff);
	b_upperq = yMap.transform(mean + se*b_coeff);
	}
else
	{
	b_lowerq = yMap.transform(gsl_stats_quantile_from_sorted_data (dat, 1, size, 1-0.01*b_coeff));
	b_upperq = yMap.transform(gsl_stats_quantile_from_sorted_data (dat, 1, size, 0.01*b_coeff));
	}

//draw box
if (b_style == Rect)
	{
	const QRect r = QRect(px - hbw, b_upperq, box_width, b_lowerq - b_upperq + 1);
	painter->fillRect(r, QwtPlotCurve::brush());
	painter->drawRect(r);
	}
else if (b_style == Diamond)
	{
	const QPointArray pa(4);	
	pa[0] = QPoint(px, b_upperq);	
	pa[1] = QPoint(px + hbw, median);
	pa[2] = QPoint(px, b_lowerq);
	pa[3] = QPoint(px - hbw, median);

	painter->setBrush(QwtPlotCurve::brush());
	painter->drawPolygon(pa);
	}
else if (b_style == WindBox)
	{
	const int lowerq = yMap.transform(gsl_stats_quantile_from_sorted_data (dat, 1, size, 0.25));
	const int upperq = yMap.transform(gsl_stats_quantile_from_sorted_data (dat, 1, size, 0.75));
	const QPointArray pa(8);	
	pa[0] = QPoint(px + hbw, b_upperq);	
	pa[1] = QPoint(int(px + 0.4*box_width), upperq);
	pa[2] = QPoint(int(px + 0.4*box_width), lowerq);
	pa[3] = QPoint(px + hbw, b_lowerq);
	pa[4] = QPoint(px - hbw, b_lowerq);
	pa[5] = QPoint(int(px - 0.4*box_width), lowerq);
	pa[6] = QPoint(int(px - 0.4*box_width), upperq);
	pa[7] = QPoint(px - hbw, b_upperq);	

	painter->setBrush(QwtPlotCurve::brush());
	painter->drawPolygon(pa);
	}
else if (b_style == Notch)
	{
	int j = (int)ceil(0.5*(size - 1.96*sqrt((double)size)));
	int k = (int)ceil(0.5*(size + 1.96*sqrt((double)size)));
	const int lowerCI = yMap.transform(dat[j]);
	const int upperCI = yMap.transform(dat[k]);

	const QPointArray pa(10);	
	pa[0] = QPoint(px + hbw, b_upperq);	
	pa[1] = QPoint(px + hbw, upperCI);
	pa[2] = QPoint(int(px + 0.25*hbw), median);
	pa[3] = QPoint(px + hbw, lowerCI);
	pa[4] = QPoint(px + hbw, b_lowerq);
	pa[5] = QPoint(px - hbw, b_lowerq);
	pa[6] = QPoint(px - hbw, lowerCI);
	pa[7] = QPoint(int(px - 0.25*hbw), median);
	pa[8] = QPoint(px - hbw, upperCI);
	pa[9] = QPoint(px - hbw, b_upperq);	

	painter->setBrush(QwtPlotCurve::brush());
	painter->drawPolygon(pa);
	}

if (w_range)
	{//draw whiskers
	const int l = int(0.1*box_width);
	int w_upperq, w_lowerq;
	if(w_range == SD)
		{
		w_lowerq = yMap.transform(mean - sd*w_coeff);
		w_upperq = yMap.transform(mean + sd*w_coeff);
		}
	else if(w_range == SE)
		{
		w_lowerq = yMap.transform(mean - se*w_coeff);
		w_upperq = yMap.transform(mean + se*w_coeff);
		}
	else
		{
		w_lowerq = yMap.transform(gsl_stats_quantile_from_sorted_data (dat, 1, size, 1-0.01*w_coeff));
		w_upperq = yMap.transform(gsl_stats_quantile_from_sorted_data (dat, 1, size, 0.01*w_coeff));
		}

	painter->drawLine(px - l, w_lowerq, px + l, w_lowerq);
	painter->drawLine(px - l, w_upperq, px + l, w_upperq);

	if (b_style)
		{
		if (w_upperq != b_upperq)
			painter->drawLine(px, w_upperq, px, b_upperq);
		if (w_lowerq != b_lowerq)
			painter->drawLine(px, w_lowerq, px, b_lowerq);
		}
	else
		painter->drawLine(px, w_upperq, px, w_lowerq);
	}

//draw median line
if (b_style == Notch || b_style == NoBox)
	return;
if (b_style == WindBox)
	painter->drawLine(int(px - 0.4*box_width), median, int(px + 0.4*box_width), median);
else
	painter->drawLine(px - hbw, median, px + hbw, median);
}
Exemplo n.º 13
0
/*!
  \brief Draw a spline
  \param painter Painter
  \param xMap x map
  \param yMap y map
  \sa QwtCurve::draw, QwtCurve::drawCurve, QwtCurve::drawDots,
      QwtCurve::drawLines, QwtCurve::drawSteps, QwtCurve::drawSticks
*/
void QwtCurve::drawSpline(QPainter *painter,
    const QwtDiMap &xMap, const QwtDiMap &yMap)
{
    register int i;

    int size = dataSize();
    double *txval = new double[size];
    double *tyval = new double[size];


    if ( !txval || !tyval )
    {
        if (txval) delete[] txval;
        if (tyval) delete[] tyval;
        return;
    }

    QPointArray polyline(d_splineSize);

    //
    // Transform x and y values to window coordinates
    // to avoid a distinction between linear and
    // logarithmic scales.
    //
    for (i=0;i<size;i++)
    {
        txval[i] = xMap.xTransform(x(i));
        tyval[i] = yMap.xTransform(y(i));
    }

    int stype;
    if (! (d_options & (Yfx|Xfy|Parametric)))
    {
        if (qwtChkMono(txval, size))
        {
            stype = Yfx;
        }
        else
        {
            if(qwtChkMono(tyval, size))
            {
                stype = Xfy;
            }
            else
            {
                stype = Parametric;
                if ( (d_options & Periodic) ||
                    ( (x(0) == x(size-1))
                    && (y(0) == y(size-1))))
                {
                    stype |= Periodic;
                }
            }
        }
    }
    else
    {
        stype = d_options;
    }

    if (stype & Parametric)
    {
        double *param = new double[size];
        if (param)
        {
            //
            // setup parameter vector
            //
            param[0] = 0.0;
            for (i=1; i<size; i++)
            {
                double delta = sqrt( qwtSqr(txval[i] - txval[i-1])
                              + qwtSqr( tyval[i] - tyval[i-1]));
                param[i] = param[i-1] + qwtMax(delta, 1.0);
            }

            //
            // setup splines
            int rc = d_spx.recalc(param, txval, size, stype & Periodic);
            if (!rc)
                rc = d_spy.recalc(param, tyval, size, stype & Periodic);

            if (rc)
            {
                drawLines(painter, xMap, yMap, 0, size - 1);
            }
            else
            {
                // fill point array
                double delta = param[size - 1] / double(d_splineSize-1);
                for (i=0;i<d_splineSize;i++)
                {
                    double dtmp = delta * double(i);
                    polyline.setPoint(i, int(floor (d_spx.value(dtmp) + 0.5)),
                                  int(floor (d_spy.value(dtmp) + 0.5)));
                }
            }

            delete[] param;
        }
    }
    else if (stype & Xfy)
    {
        if (tyval[size-1] < tyval[0])
        {
            qwtTwistArray(txval, size);
            qwtTwistArray(tyval, size);
        }

        // 1. Calculate spline coefficients
        int rc = d_spx.recalc(tyval, txval, size, stype & Periodic);
        if (rc)                         // an error occurred
        {
            drawLines(painter, xMap, yMap, 0, size - 1);
        }
        else                            // Spline OK
        {
            double ymin = qwtGetMin(tyval, size);
            double ymax = qwtGetMax(tyval, size);
            double delta = (ymax - ymin) / double(d_splineSize - 1);

            for (i=0;i<d_splineSize;i++)
            {
                double dtmp = ymin + delta * double(i);
                polyline.setPoint(i, int(floor(d_spx.value(dtmp) + 0.5)),
                              int(floor(dtmp + 0.5)));
            }
        }
    }
    else
    {
        if (txval[size-1] < txval[0])
        {
            qwtTwistArray(tyval, size);
            qwtTwistArray(txval, size);
        }


        // 1. Calculate spline coefficients
        int rc = d_spy.recalc(txval, tyval, size, stype & Periodic);
        if (rc)                         // error
        {
            drawLines(painter, xMap, yMap, 0, size - 1);
        }
        else                            // Spline OK
        {
            double xmin = qwtGetMin(txval, size);
            double xmax = qwtGetMax(txval, size);
            double delta = (xmax - xmin) / double(d_splineSize - 1);

            for (i=0;i<d_splineSize;i++)
            {
                double dtmp = xmin + delta * double(i);
                polyline.setPoint(i, int(floor (dtmp + 0.5)),
                              int(floor(d_spy.value(dtmp) + 0.5)));
            }
        }
    }

    delete[] txval;
    delete[] tyval;

    QwtPainter::drawPolyline(painter, polyline);

    if ( painter->brush().style() != Qt::NoBrush )
    {
        closePolyline(xMap, yMap, polyline);
        painter->setPen(QPen(Qt::NoPen));
        QwtPainter::drawPolygon(painter, polyline);
    }
}
Exemplo n.º 14
0
void QwtBarCurve::draw(QPainter *painter,
    const QwtDiMap &xMap, const QwtDiMap &yMap, int from, int to)
{
   if ( !painter || dataSize() <= 0 )
        return;

    if (to < 0)
        to = dataSize() - 1;

    if ( verifyRange(from, to) > 0 )
		{
        painter->save();
        painter->setPen(QwtPlotCurve::pen());
        painter->setBrush(QwtPlotCurve::brush());
			
		int dx,dy,ref,bar_width;
			
		if (bar_style == Vertical)
			ref= yMap.transform(1e-100); //smalest positive value for log scales
		else
			ref= xMap.transform(1e-100);	
				
		int i;
		if (bar_style == Vertical)
			{
			dx = abs(xMap.transform(x(from+1))-xMap.transform(x(from)));
			for (i=from+2; i<to; i++)
				{
				int min = abs(xMap.transform(x(i+1))-xMap.transform(x(i)));
				if (min <= dx)
					dx=min;
				}
			bar_width=int(dx*(1-bar_gap*0.01));
			}
		else
			{
			dy = abs(yMap.transform(y(from+1))-yMap.transform(y(from)));
			for (i=from+2; i<to; i++)
				{
				int min = abs(yMap.transform(y(i+1))-yMap.transform(y(i)));
				if (min <= dy)
					dy=min;
				}
			bar_width=int(dy*(1-bar_gap*0.01));
			}
		
		const int half_width = int((0.5-bar_offset*0.01)*bar_width);
		const int bw1 = bar_width+1;
        for (i=from; i<=to; i++)
			{
            const int px = xMap.transform(x(i));
            const int py = yMap.transform(y(i));
			
			if (bar_style == Vertical)
				{
				if (y(i) < 0)
					painter->drawRect(px-half_width, ref, bw1, (py-ref));
				else
					painter->drawRect(px-half_width, py, bw1, (ref-py+1));	
				}
			else
				{
				if (x(i) < 0)
					painter->drawRect(px, py-half_width, (ref-px), bw1);
				else
					painter->drawRect(ref, py-half_width,(px-ref), bw1);
				}	
			}
		painter->restore();
		}
}
Exemplo n.º 15
0
void Plot::drawInwardMinorTicks(QPainter *painter, const QRect &rect,
                                const QwtDiMap &map, int axis) const
{
    QwtScale *scale=(QwtScale *) QwtPlot::axis (axis);
    if (!scale)
        return;

    int x1=rect.left();
    int x2=rect.right();
    int y1=rect.top();
    int y2=rect.bottom();

    QPalette pal=scale->palette();
    QColor color=pal.color(QPalette::Active, QColorGroup::Foreground);

    painter->save();
    painter->setPen(QPen(color, d_lineWidth, QPainter::SolidLine));

    QwtScaleDiv *scDiv=(QwtScaleDiv *)axisScale(axis);
    int minTicks=scDiv->minCnt();

    int j, x, y, low,high;
    switch (axis)
    {
    case QwtPlot::yLeft:
        x=x1;
        low=y1+majTickLength;
        high=y2-majTickLength;
        for (j = 0; j < minTicks; j++)
        {
            y = map.transform(scDiv->minMark(j));
            if (y>low && y< high)
                QwtPainter::drawLine(painter, x, y, x+minTickLength, y);
        }
        break;

    case QwtPlot::yRight:
    {
        x=x2;
        low=y1+majTickLength;
        high=y2-majTickLength;
        for (j = 0; j < minTicks; j++)
        {
            y = map.transform(scDiv->minMark(j));
            if (y>low && y< high)
                QwtPainter::drawLine(painter, x+1, y, x-minTickLength, y);
        }
    }
    break;

    case QwtPlot::xBottom:
        y=y2;
        low=x1+majTickLength;
        high=x2-majTickLength;
        for (j = 0; j < minTicks; j++)
        {
            x = map.transform(scDiv->minMark(j));
            if (x>low && x<high)
                QwtPainter::drawLine(painter, x, y+1, x, y-minTickLength);
        }
        break;

    case QwtPlot::xTop:
        y=y1;
        low=x1+majTickLength;
        high=x2-majTickLength;
        for (j = 0; j < minTicks; j++)
        {
            x = map.transform(scDiv->minMark(j));
            if (x>low && x<high)
                QwtPainter::drawLine(painter, x, y, x, y + minTickLength);
        }
        break;
    }
    painter->restore();
}