自制绘图之坐标轴

写代码之前得先了解坐标轴的一些属性，坐标轴有范围，每隔多少显示一条数值信息。然而间隔信息有时并不确定，一旦设置不准确，图形会乱掉。最好的方法是使用另一个参数：分隔符总数。这样可以利用坐标范围计算出间隔。

首先需要定义范围：

template <class T>
class DataRange
{
public:
    DataRange(const T& minValue, const T& maxValue): itsMinValue(minValue), itsMaxValue(maxValue){}
    DataRange(){}
    T itsMinValue;
    T itsMaxValue;
    T Length() const { return itsMaxValue - itsMinValue ;}
};

先写测试代码：

void TestPicture::TestCoordSimple()
{
    CoordinateAttribute<double> ca;
    ca.itsNumSeparate = 10;
    ca.itsGivenDataRange = DataRange<double>(0.0,2.4);
    ca.CalcCoordinate();
    assert(0.24==ca.itsSeparateLength);
}

通过这一测试很简单只需一个除法就搞定了。代码如下：

template <class T>
class CoordinateAttribute
{
public:
    CoordinateAttribute(){}
    //attribute
    int itsNumSeparate;
    DataRange<T> itsGivenDataRange;
    T itsSeparateLength;
    //operators
    void CalcCoordinate()
    {
        //calculate separate length
        itsSeparateLength = itsGivenDataRange.Length() / itsNumSeparate;
    }
};

有个问题就是如果坐标轴的范围不能被分隔符整除，显示出来的坐标将带有很多小数位，往往不是我们所想要的。于是还需要另一个参数给坐标轴，那就是最小刻度。比如有些情况下需要显示的都是整数，有时需要保留一位小数。

void TestPicture::TestCoordSimple2()
{
    CoordinateAttribute<double> ca;
    ca.itsNumSeparate = 10;
    ca.itsGivenDataRange = DataRange<double>(0.0,2.4);
    ca.itsMinScale = 0.1;
    ca.CalcCoordinate();
    assert(0.3==ca.itsSeparateLength);
}

修改代码为：

template <class T>
class CoordinateAttribute
{
public:
    CoordinateAttribute(){}
    //attribute
    int itsNumSeparate;
    DataRange<T> itsGivenDataRange;
    T itsMinScale;
    T itsSeparateLength;
    //operators
    void CalcCoordinate()
    {
        //calculate separate length
        T temp = itsGivenDataRange.Length() / itsNumSeparate;
        itsSeparateLength = itsMinScale * ceil((double)temp / itsMinScale);
    }
};

这个坐标轴的计算方法先做到这，下面来测试其效果。坐标轴的信息需要给图形，最简洁的方法是告诉图形在坐标轴的什么位置显示多少坐标值，由于坐标轴对图形是未知的，其位置可以使用百分比来表示，在C++中可以使用std::map<double,std::string>来传递坐标轴的信息。

在CoordinateAttribute加入一个FillToAxisMap函数

void FillToAxisMap(std::map<double,std::string>& sm)
{
    sm.clear();
    T iT = itsGivenDataRange.itsMinValue;
    for (int i = 0; i <= itsNumSeparate; i++,iT += itsSeparateLength)
    {
        double dIndex = iT - itsGivenDataRange.itsMinValue ;
        dIndex /= itsCalculateDataRange.Length();
            sm.insert(std::make_pair(dIndex,ConvertToString<T>(iT)));
    }
}

其中ConvertToString函数如下：

template <typename T>
std::string ConvectToString(const T& v)
{
    std::strstream str;
    str<<v<<'\0';
    return str.str();
}

写个输出函数来看我们的结果。

测试函数：

    map<double,string> CoordInfo;
    ca.FillToAxisMap(CoordInfo);
    for (map<double,string>::iterator it = CoordInfo.begin();it != CoordInfo.end(); ++it)
    {
        cout << endl << it->first << " ---- " << it->second ;
    }

运行结果：

0 ---- 0
0.1 ---- 0.3
0.2 ---- 0.6
0.3 ---- 0.9
0.4 ---- 1.2
0.5 ---- 1.5
0.6 ---- 1.8
0.7 ---- 2.1
0.8 ---- 2.4
0.9 ---- 2.7
1 ---- 3

可以看到，其结果还是在我们的意料之中的，有一点不好，我们给的范围是0~2.4，而现在的范围变成了0~3了。先不做改动，再做下一次测试。

    CoordinateAttribute<double> ca;
    ca.itsNumSeparate = 10;
    ca.itsGivenDataRange = DataRange<double>(0.0,2.4);
    ca.itsMinScale = 0.5;
    ca.CalcCoordinate();

其输出结果为：

0 ---- 0
0.1 ---- 0.5
0.2 ---- 1
0.3 ---- 1.5
0.4 ---- 2
0.5 ---- 2.5
0.6 ---- 3
0.7 ---- 3.5
0.8 ---- 4
0.9 ---- 4.5
1 ---- 5

问题更严重了，计算出的范围比之前我们给的大很多。其实这是由于所给参数不合理导致的。既然itsMinScale设了0.5，那么itsNumSeparate设为10显然不正确，这时最好由程序自己来调整。

理想的输出结果是：

0 ---- 0
0.2 ---- 0.5
0.4 ---- 1
0.6 ---- 1.5
0.8 ---- 2
1 ---- 2.5

修改代码如下：

template <class T>
class CoordinateAttribute
{
public:
    CoordinateAttribute(){}
    //the param user give
    int itsNumSeparate;
    DataRange<T> itsGivenDataRange;
    T itsMinScale;
    //the param calculate
    T itsSeparateLength;
    DataRange<T> itsCalculateDataRange;

    //operators
    void CalcCoordinate()
    {
        //adjust its min value
        itsCalculateDataRange.itsMinValue = itsMinScale * floor((double)itsGivenDataRange.itsMinValue / itsMinScale);
        //calculate separate length
        itsCalculateDataRange.itsMaxValue = itsGivenDataRange.itsMaxValue;
        T temp = itsCalculateDataRange.Length() / itsNumSeparate;
        itsSeparateLength =  itsMinScale * ceil((double)temp / itsMinScale);
        //calculate its max value
        itsCalculateDataRange.itsMaxValue = itsCalculateDataRange.itsMinValue + itsSeparateLength * itsNumSeparate;
        //delete unused value
        while( itsCalculateDataRange.itsMaxValue - itsSeparateLength > itsGivenDataRange.itsMaxValue)
        {
            itsCalculateDataRange.itsMaxValue -= itsSeparateLength;
            itsNumSeparate--;
        }
    }
};

这里加了itsCalculateDataRange，用来记录计算后的数据范围，对max和min的范围进行了调整。

测试如下：

    ca.itsNumSeparate = 7;
    ca.itsMinScale = 0.1;
    ca.itsGivenDataRange = DataRange<double>(0.0,2.34);
    ca.CalcCoordinate();
    CPPUNIT_ASSERT_DOUBLES_EQUAL(0.4,ca.itsSeparateLength,0.01);
    CPPUNIT_ASSERT_DOUBLES_EQUAL(2.4,ca.itsCalculateDataRange.itsMaxValue,0.01);
    ca.itsNumSeparate = 5;
    ca.CalcCoordinate();
    CPPUNIT_ASSERT_DOUBLES_EQUAL(0.5,ca.itsSeparateLength,0.01);
    CPPUNIT_ASSERT_DOUBLES_EQUAL(2.5,ca.itsCalculateDataRange.itsMaxValue,0.01);
    ca.itsNumSeparate = 10;
    ca.itsMinScale = 0.1;
    ca.CalcCoordinate();
    CPPUNIT_ASSERT_DOUBLES_EQUAL(0.3,ca.itsSeparateLength,0.001);
    CPPUNIT_ASSERT_DOUBLES_EQUAL(2.4,ca.itsCalculateDataRange.itsMaxValue,0.001);
    ca.itsGivenDataRange.itsMinValue = 0.14;
    ca.itsMinScale = 0.01;
    ca.itsNumSeparate = 10;
    ca.CalcCoordinate();
    CPPUNIT_ASSERT_DOUBLES_EQUAL(0.22,ca.itsSeparateLength,0.001);
    CPPUNIT_ASSERT_DOUBLES_EQUAL(0.14,ca.itsCalculateDataRange.itsMinValue,0.001);
    CPPUNIT_ASSERT_DOUBLES_EQUAL(2.34,ca.itsCalculateDataRange.itsMaxValue,0.001);