source: nanovis/branches/1.2/Axis.h

/* -*- mode: c++; c-basic-offset: 4; indent-tabs-mode: nil -*- */
/*
 * Copyright (c) 2004-2013  HUBzero Foundation, LLC
 *
 * Authors:
 *   George A. Howlett <gah@purdue.edu>
 *   Leif Delgass <ldelgass@purdue.edu>
 */
#ifndef NV_AXIS_H
#define NV_AXIS_H

#include <cmath>
#include <limits>
#include <list>
#include <string>
#include <cstdlib>
#include <cstring>

#ifndef NAN
#define NAN (std::numeric_limits<double>::quiet_NaN())
#endif

namespace nv {

class Axis;

/**
 * Class containing information where the ticks (major or
 * minor) will be displayed on the graph.
 */
class Ticks
{
public:
    typedef std::list<double>::iterator Iterator;
    typedef std::list<double>::const_iterator ConstIterator;

    Ticks(int numTicks) :
        reqNumTicks(numTicks),
        _numTicks(0),
        _ticks(NULL)
    {
    }

    ~Ticks()
    {
        if (_ticks != NULL) {
            delete [] _ticks;
        }
    }

    int numTicks() const
    {
        return _numTicks;
    }

    double tick(int i)
    {
        if ((i < 0) || (i >= _numTicks)) {
            return NAN;
        }
        return _ticks[i];
    }

    void reset()
    {
        _chain.clear();
    }

    float step() const
    {
        return _step;
    }

    void append(float x)
    {
        _chain.push_back(x);
    }

    void setValues(double initial, double step, unsigned int nSteps)
    {
        _initial = initial, _step = step, _nSteps = nSteps;
    }

    void sweepTicks()
    {
        if (_ticks != NULL) {
            delete [] _ticks;
        }
        setTicks();
    }

    ConstIterator begin() const
    {
        return _chain.begin();
    }

    ConstIterator end() const
    {
        return _chain.end();
    }

    int reqNumTicks;            /**< Default number of ticks to be displayed. */

private:
    void setTicks();    /**< Routine used internally to create the array
                         * of ticks as defined by a given sweep. */

    /* 
     * Tick locations may be generated in two fashions
     */
    /* 1. an array of values provided by the user. */
    int _numTicks;              /* # of ticks on axis */
    float *_ticks;              /* Array of tick values (alloc-ed).  Right now
                                 * it's a float so we don't have to allocate
                                 * store for the list of ticks generated.  In
                                 * the future when we store both the tick
                                 * label and the value in the list, we may
                                 * extend this to a double.
                                 */
    /*
     * 2. a defined sweep of initial, step, and nsteps.  This in turn
     *    will generate the an array of values.
     */
    double _initial;            /**< Initial value */
    double _step;               /**< Size of interval */
    unsigned int _nSteps;       /**< Number of intervals. */

    /**
     *This finally generates a list of ticks values that exclude duplicate
     * minor ticks (that are always represented by major ticks).  In the
     * future, the string representing the tick label will be stored in 
     * the chain.
     */
    std::list<double> _chain;
};

/**
 * Class contains options controlling how the axis will be
 * displayed.
 */
class Axis
{
public:
    Axis(const char *title);

    ~Axis()
    {
    }

    Ticks::ConstIterator firstMajor() const
    {
        return _major.begin();
    }
    Ticks::ConstIterator lastMajor() const
    {
        return _major.end();
    }
    Ticks::ConstIterator firstMinor() const
    {
        return _minor.begin();
    }
    Ticks::ConstIterator lastMinor() const
    {
        return _minor.end();
    }

    /**
     * This returns the minimum bound of the data, which may
     * be different than the min() of the axis because of 
     * tight/loose placement of major ticks
     */
    double dataMin() const
    {
        return _valueMin;
    }

    /**
     * This returns the maximum bound of the data, which may
     * be different than the min() of the axis because of 
     * tight/loose placement of major ticks
     */
    double dataMax() const
    {
        return _valueMax;
    }

    /**
     * The minimum bound of the axis
     */
    double min() const
    {
        return _min;
    }

    /**
     * The maximum bound of the axis
     */
    double max() const
    {
        return _max;
    }

    /**
     * The length of the axis
     */
    double length() const
    {
        return (_max - _min);
    }

    void setRange(double min, double max);

    double map(double x);

    double invMap(double x);

    const char *title() const
    {
        return _title.c_str();
    }

    void title(const char *title)
    {
        _title = title;
    }

    const char *units() const
    {
        return _units.c_str();
    }

    void units(const char *units)
    {
        _units = units;
    }

    void setTightMin(bool value)
    {
        _tightMin = value;
    }

    void setTightMax(bool value)
    {
        _tightMax = value;
    }

    void setMajorStep(double value)
    {
        // Setting to 0.0 resets step to "auto"
        _reqStep = value;
    }

    void setNumMajorTicks(int n)
    {
        _major.reqNumTicks = n;
    }

    void setNumMinorTicks(int n)
    {
        _minor.reqNumTicks = n;
    }

private:
    void resetRange();

    void fixRange(double min, double max);

    void linearScale();

    bool inRange(double x);

    void makeTicks();

    std::string _title;         /**< Title of the axis */
    std::string _units;         /**< Units of the axis */

    bool _tightMin, _tightMax;  /**< Tight bounds option flags */

    double _reqStep;            /**< If > 0.0, overrides the computed major tick
                                 * interval.  Otherwise a stepsize is
                                 * automatically calculated, based upon the
                                 * range of elements mapped to the axis. The
                                 * default value is 0.0. */

    double _valueMin, _valueMax; /**< The limits of the data */
    double _min, _max;          /**< Smallest and largest major tick values for
                                 * the axis.  If loose, the tick values lie
                                 * outside the range of data values.  If
                                 * tight, they lie interior to the limits of
                                 * the data. */

    Ticks _major, _minor;
};

}

#endif