Qwt源码解读之标尺相关类——QwtScaleMap

QwtScaleMap类用于提供标尺坐标系与绘制设备坐标系之间的映射关系。其主要的功能依托 QwtTransform 类及相关子类来实现。

先看一看Qwt文档的说明

QwtScaleMap offers transformations from the coordinate system of a scale intothe
linear coordinate system of a paint device and vice versa.

类的定义

class QWT_EXPORT QwtScaleMap
{
public:
QwtScaleMap();
QwtScaleMap( const QwtScaleMap& );

~QwtScaleMap();

QwtScaleMap &operator=( const QwtScaleMap & );

void setTransformation( QwtTransform * );
const QwtTransform *transformation() const;

void setPaintInterval( double p1, double p2 );
void setScaleInterval( double s1, double s2 );

double transform( double s ) const;
double invTransform( double p ) const;

double p1() const;
double p2() const;

double s1() const;
double s2() const;

double pDist() const;
double sDist() const;

static QRectF transform( const QwtScaleMap &,
const QwtScaleMap &, const QRectF & );
static QRectF invTransform( const QwtScaleMap &,
const QwtScaleMap &, const QRectF & );

static QPointF transform( const QwtScaleMap &,
const QwtScaleMap &, const QPointF & );
static QPointF invTransform( const QwtScaleMap &,
const QwtScaleMap &, const QPointF & );

bool isInverting() const;

private:
void updateFactor();

double d_s1, d_s2;     // scale interval boundaries
double d_p1, d_p2;     // paint device interval boundaries

double d_cnv;       // conversion factor
double d_ts1;

QwtTransform *d_transform;
};

一些成员函数

/*!
\return qwtAbs(p2() - p1())
*/
inline double QwtScaleMap::pDist() const
{
return qAbs( d_p2 - d_p1 );
}

/*!
\return qwtAbs(s2() - s1())
*/
inline double QwtScaleMap::sDist() const
{
return qAbs( d_s2 - d_s1 );
}

非常简单，不解释。

//! \return True, when ( p1() < p2() ) != ( s1() < s2() )
inline bool QwtScaleMap::isInverting() const
{
return ( ( d_p1 < d_p2 ) != ( d_s1 < d_s2 ) );
}

当d_p1,d_p2和d_s1,d_s2的顺序相反时返回true。

/*!
Transform a point related to the scale interval into an point
related to the interval of the paint device

\param s Value relative to the coordinates of the scale
\return Transformed value

\sa invTransform()
*/
inline double QwtScaleMap::transform( double s ) const
{
if ( d_transform )
s = d_transform->transform( s );

return d_p1 + ( s - d_ts1 ) * d_cnv;
}

将标尺坐标系中的一个值转换到绘图设备坐标系中的一个值。

/*!
Transform an paint device value into a value in the
interval of the scale.

\param p Value relative to the coordinates of the paint device
\return Transformed value

\sa transform()
*/
inline double QwtScaleMap::invTransform( double p ) const
{
double s = d_ts1 + ( p - d_p1 ) / d_cnv;
if ( d_transform )
s = d_transform->invTransform( s );

return s;
}

将绘图设备坐标系中的一个值转换为标尺坐标系中的一个值。

void QwtScaleMap::updateFactor()
{
d_ts1 = d_s1;
double ts2 = d_s2;

if ( d_transform )
{
d_ts1 = d_transform->transform( d_ts1 );
ts2 = d_transform->transform( ts2 );
}

d_cnv = 1.0;
if ( d_ts1 != ts2 )
d_cnv = ( d_p2 - d_p1 ) / ( ts2 - d_ts1 );
}

更新因子，即转换后的线性标尺坐标系（如果是对数坐标系，则将其先转换成线性坐标系）每变化一个单位，相应的绘图设备坐标系会变化的像素数。

/*!
\brief Specify the borders of the scale interval
\param s1 first border
\param s2 second border
\warning scales might be aligned to
transformation depending boundaries
*/
void QwtScaleMap::setScaleInterval( double s1, double s2 )
{
d_s1 = s1;
d_s2 = s2;

if ( d_transform )
{
d_s1 = d_transform->bounded( d_s1 );
d_s2 = d_transform->bounded( d_s2 );
}

updateFactor();
}

/*!
\brief Specify the borders of the paint device interval
\param p1 first border
\param p2 second border
*/
void QwtScaleMap::setPaintInterval( double p1, double p2 )
{
d_p1 = p1;
d_p2 = p2;

updateFactor();
}

不论是标尺坐标还是绘图设备坐标，当更新了边界值后，都会更新相应的比例因子。

/*!
Initialize the map with a transformation
*/
void QwtScaleMap::setTransformation( QwtTransform *transform )
{
if ( transform != d_transform )
{
delete d_transform;
d_transform = transform;
}

setScaleInterval( d_s1, d_s2 );
}

注意：当坐标变换规则改变后（比如从对数坐标系转换为线性坐标系），会导致相应的比例因子跟着改变，因此需要重新设置比例因子。

这里使用setScaleInterval()而不直接使用updateFactor()函数的原因主要是考虑到当d_transform改变后，相应的bounded()会对d_s1和d_s2做出不同的限制。

/* Transform a rectangle from scale to paint coordinates

\param xMap X map
\param yMap Y map
\param rect Rectangle in scale coordinates
\return Rectangle in paint coordinates

\sa invTransform()
*/
QRectF QwtScaleMap::transform( const QwtScaleMap &xMap,
const QwtScaleMap &yMap, const QRectF &rect )
{
double x1 = xMap.transform( rect.left() );
double x2 = xMap.transform( rect.right() );
double y1 = yMap.transform( rect.top() );
double y2 = yMap.transform( rect.bottom() );

if ( x2 < x1 )
qSwap( x1, x2 );
if ( y2 < y1 )
qSwap( y1, y2 );

if ( qwtFuzzyCompare( x1, 0.0, x2 - x1 ) == 0 )
x1 = 0.0;
if ( qwtFuzzyCompare( x2, 0.0, x2 - x1 ) == 0 )
x2 = 0.0;
if ( qwtFuzzyCompare( y1, 0.0, y2 - y1 ) == 0 )
y1 = 0.0;
if ( qwtFuzzyCompare( y2, 0.0, y2 - y1 ) == 0 )
y2 = 0.0;

return QRectF( x1, y1, x2 - x1 + 1, y2 - y1 + 1 );
}

将标尺坐标系中的一个矩形转换为绘图设备坐标系中的一个矩形。

/*!
Transform a rectangle from paint to scale coordinates

\param xMap X map
\param yMap Y map
\param rect Rectangle in paint coordinates
\return Rectangle in scale coordinates
\sa transform()
*/
QRectF QwtScaleMap::invTransform( const QwtScaleMap &xMap,
const QwtScaleMap &yMap, const QRectF &rect )
{
const double x1 = xMap.invTransform( rect.left() );
const double x2 = xMap.invTransform( rect.right() - 1 );// ???为什么要减一，感觉不应该减一
const double y1 = yMap.invTransform( rect.top() );
const double y2 = yMap.invTransform( rect.bottom() - 1 );// ???为什么要减一，感觉不应该减一

const QRectF r( x1, y1, x2 - x1, y2 - y1 );
return r.normalized();
}

将绘图设备坐标系中的一个矩形转换为标尺坐标系中的一个矩形。

/*!
Transform a point from scale to paint coordinates

\param xMap X map
\param yMap Y map
\param pos Position in scale coordinates
\return Position in paint coordinates

\sa invTransform()
*/
QPointF QwtScaleMap::transform( const QwtScaleMap &xMap,
const QwtScaleMap &yMap, const QPointF &pos )
{
return QPointF(
xMap.transform( pos.x() ),
yMap.transform( pos.y() )
);
}

将标尺坐标系中的一个点转换为绘图设备坐标系中的一个点。

/*!
Transform a point from paint to scale coordinates

\param xMap X map
\param yMap Y map
\param pos Position in paint coordinates
\return Position in scale coordinates
\sa transform()
*/
QPointF QwtScaleMap::invTransform( const QwtScaleMap &xMap,
const QwtScaleMap &yMap, const QPointF &pos )
{
return QPointF(
xMap.invTransform( pos.x() ),
yMap.invTransform( pos.y() )
);
}

将绘图设备坐标系中的一个点转换为标尺坐标系中的一个点。