source: nanovis/trunk/Axis.h @ 5478

Last change on this file since 5478 was 5478, checked in by ldelgass, 5 years ago

Begin refactoring axis/grid in nanovis: remove unused features, make the style
more C++

  • Property svn:eol-style set to native
File size: 5.4 KB
Line 
1/* -*- mode: c++; c-basic-offset: 4; indent-tabs-mode: nil -*- */
2/*
3 * Copyright (c) 2004-2013  HUBzero Foundation, LLC
4 *
5 * Authors:
6 *   George A. Howlett <gah@purdue.edu>
7 *   Leif Delgass <ldelgass@purdue.edu>
8 */
9#ifndef NV_AXIS_H
10#define NV_AXIS_H
11
12#include <cmath>
13#include <limits>
14#include <list>
15#include <string>
16#include <cstdlib>
17#include <cstring>
18
19#ifndef NAN
20#define NAN (std::numeric_limits<double>::quiet_NaN())
21#endif
22
23namespace nv {
24
25class Axis;
26
27/**
28 * Class containing information where the ticks (major or
29 * minor) will be displayed on the graph.
30 */
31class Ticks
32{
33public:
34    typedef std::list<double>::iterator Iterator;
35    typedef std::list<double>::const_iterator ConstIterator;
36
37    Ticks(int numTicks) :
38        reqNumTicks(numTicks),
39        _numTicks(0),
40        _ticks(NULL)
41    {
42    }
43
44    ~Ticks()
45    {
46        if (_ticks != NULL) {
47            delete [] _ticks;
48        }
49    }
50
51    int numTicks() const
52    {
53        return _numTicks;
54    }
55
56    double tick(int i)
57    {
58        if ((i < 0) || (i >= _numTicks)) {
59            return NAN;
60        }
61        return _ticks[i];
62    }
63
64    void reset()
65    {
66        _chain.clear();
67    }
68
69    float step() const
70    {
71        return _step;
72    }
73
74    void append(float x)
75    {
76        _chain.push_back(x);
77    }
78
79    void setValues(double initial, double step, unsigned int nSteps)
80    {
81        _initial = initial, _step = step, _nSteps = nSteps;
82    }
83
84    void sweepTicks()
85    {
86        if (_ticks != NULL) {
87            delete [] _ticks;
88        }
89        setTicks();
90    }
91
92    ConstIterator begin() const
93    {
94        return _chain.begin();
95    }
96
97    ConstIterator end() const
98    {
99        return _chain.end();
100    }
101
102    int reqNumTicks;            /**< Default number of ticks to be displayed. */
103
104private:
105    void setTicks();    /**< Routine used internally to create the array
106                         * of ticks as defined by a given sweep. */
107
108    bool _autoscale;            /**< Indicates if the ticks are autoscaled. */
109    /*
110     * Tick locations may be generated in two fashions
111     */
112    /* 1. an array of values provided by the user. */
113    int _numTicks;              /* # of ticks on axis */
114    float *_ticks;              /* Array of tick values (alloc-ed).  Right now
115                                 * it's a float so we don't have to allocate
116                                 * store for the list of ticks generated.  In
117                                 * the future when we store both the tick
118                                 * label and the value in the list, we may
119                                 * extend this to a double.
120                                 */
121    /*
122     * 2. a defined sweep of initial, step, and nsteps.  This in turn
123     *    will generate the an array of values.
124     */
125    double _initial;            /**< Initial value */
126    double _step;               /**< Size of interval */
127    unsigned int _nSteps;       /**< Number of intervals. */
128
129    /**
130     *This finally generates a list of ticks values that exclude duplicate
131     * minor ticks (that are always represented by major ticks).  In the
132     * future, the string representing the tick label will be stored in
133     * the chain.
134     */
135    std::list<double> _chain;
136};
137
138/**
139 * Class contains options controlling how the axis will be
140 * displayed.
141 */
142class Axis
143{
144public:
145    Axis(const char *title);
146
147    ~Axis()
148    {
149    }
150
151    Ticks::ConstIterator firstMajor() const
152    {
153        return _major.begin();
154    }
155    Ticks::ConstIterator lastMajor() const
156    {
157        return _major.end();
158    }
159    Ticks::ConstIterator firstMinor() const
160    {
161        return _minor.begin();
162    }
163    Ticks::ConstIterator lastMinor() const
164    {
165        return _minor.end();
166    }
167
168    double dataMin() const
169    {
170        return _valueMin;
171    }
172
173    double dataMax() const
174    {
175        return _valueMax;
176    }
177
178    double min() const
179    {
180        return _min;
181    }
182
183    double max() const
184    {
185        return _max;
186    }
187
188    double length() const
189    {
190        return (_max - _min);
191    }
192
193    void setRange(double min, double max);
194
195    double map(double x);
196
197    double invMap(double x);
198
199    const char *title() const
200    {
201        return _title.c_str();
202    }
203
204    void title(const char *title)
205    {
206        _title = title;
207    }
208
209    const char *units() const
210    {
211        return _units.c_str();
212    }
213
214    void units(const char *units)
215    {
216        _units = units;
217    }
218
219    void setTightMin(bool value)
220    {
221        _tightMin = value;
222    }
223
224    void setTightMax(bool value)
225    {
226        _tightMax = value;
227    }
228
229    void setMajorStep(double value)
230    {
231        // Setting to 0.0 resets step to "auto"
232        _reqStep = value;
233    }
234
235    void setNumMajorTicks(int n)
236    {
237        _major.reqNumTicks = n;
238    }
239
240    void setNumMinorTicks(int n)
241    {
242        _minor.reqNumTicks = n;
243    }
244
245private:
246    void resetRange();
247
248    void fixRange(double min, double max);
249
250    void linearScale();
251
252    bool inRange(double x);
253
254    void makeTicks();
255
256    std::string _title;         /**< Title of the axis */
257    std::string _units;         /**< Units of the axis */
258
259    bool _tightMin, _tightMax;  /**< Tight bounds option flags */
260
261    double _reqStep;            /**< If > 0.0, overrides the computed major tick
262                                 * interval.  Otherwise a stepsize is
263                                 * automatically calculated, based upon the
264                                 * range of elements mapped to the axis. The
265                                 * default value is 0.0. */
266
267    double _valueMin, _valueMax; /**< The limits of the data */
268    double _min, _max;          /**< Smallest and largest major tick values for
269                                 * the axis.  If loose, the tick values lie
270                                 * outside the range of data values.  If
271                                 * tight, they lie interior to the limits of
272                                 * the data. */
273
274    Ticks _major, _minor;
275};
276
277}
278
279#endif
Note: See TracBrowser for help on using the repository browser.