Ignore:
Timestamp:
Mar 11, 2008, 1:40:37 PM (12 years ago)
Author:
gah
Message:

Axis.cpp cleanup

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/vizservers/nanovis/Axis.cpp

    r933 r936  
    8080}
    8181
    82 Ticks::Ticks(TickSweep &sweep)
     82void
     83Ticks::SetTicks(void)
    8384{
    8485    _nTicks = 0;
    85     fprintf(stderr, "Ticks nsteps=%d, step=%g, initial=%g\n",
    86             sweep.NumSteps(), sweep.Step(), sweep.Initial());
    87     _ticks = new float[sweep.NumSteps()];
    88     if (sweep.Step() == 0.0) {
     86    _ticks = new float[_nSteps];
     87    if (_step == 0.0) {
    8988        /* Hack: A zero step indicates to use log values. */
    9089        unsigned int i;
     
    102101            1.0
    103102        };
    104         for (i = 0; i < sweep.NumSteps(); i++) {
     103        for (i = 0; i < _nSteps; i++) {
    105104            _ticks[i] = logTable[i];
    106105        }
     
    109108        unsigned int i;
    110109   
    111         value = sweep.Initial(); /* Start from smallest axis tick */
    112         for (i = 0; i < sweep.NumSteps(); i++) {
    113             value = sweep.Initial() + (sweep.Step() * i);
    114             _ticks[i] = UROUND(value, sweep.Step());
    115             fprintf(stderr, "ticks[%d] = %g (value=%g)\n",
    116                     i, _ticks[i], value);
    117         }
    118     }
    119     _nTicks = sweep.NumSteps();
    120 }
    121 
    122 Axis::Axis(const char *name)
     110        value = _initial;       /* Start from smallest axis tick */
     111        for (i = 0; i < _nSteps; i++) {
     112            value = _initial + (_step * i);
     113            _ticks[i] = UROUND(value, _step);
     114        }
     115    }
     116    _nTicks = _nSteps;
     117}
     118
     119Axis::Axis(const char *name) :
     120    _major(5), _minor(2)
    123121{
    124122    _name = NULL;
    125123    SetName(name);
    126     _flags = AUTOSCALE_MAJOR | AUTOSCALE_MINOR;
    127124    _title = NULL;
    128125    _valueMin = DBL_MAX, _valueMax = -DBL_MAX;
     
    131128    _range = 0.0, _scale = 0.0;
    132129    _reqStep = 0.0;
    133     _reqNumMinorTicks = 2;
    134     _reqNumMajorTicks = 5;
    135     _reqStep = 0.0;
    136     _t1Ptr = _t2Ptr = NULL;
    137 }
    138 
    139 Axis::~Axis(void)
    140 {
    141     if (_t1Ptr != NULL) {
    142         delete _t1Ptr;
    143     }
    144     if (_t2Ptr != NULL) {
    145         delete _t2Ptr;
    146     }
    147     _minorTicks.Reset();
    148     _majorTicks.Reset();
    149130}
    150131
     
    331312             * decade.  Instead, treat the axis as a linear scale.  */
    332313            range = NiceNum(range, 0);
    333             majorStep = NiceNum(range / _reqNumMajorTicks, 1);
     314            majorStep = NiceNum(range / _major.reqNumTicks, 1);
    334315            tickMin = UFLOOR(tickMin, majorStep);
    335316            tickMax = UCEIL(tickMax, majorStep);
     
    364345        }
    365346    }
    366     _majorSweep.SetValues(majorStep, nMajor, floor(tickMin));
    367     _minorSweep.SetValues(minorStep, nMinor, minorStep);
     347    _major.SetValues(majorStep, nMajor, floor(tickMin));
     348    _minor.SetValues(minorStep, nMinor, minorStep);
    368349    _min = tickMin;
    369350    _max = tickMax;
     
    460441        } else {
    461442            range = NiceNum(range, 0);
    462             step = NiceNum(range / _reqNumMajorTicks, 1);
     443            step = NiceNum(range / _major.reqNumTicks, 1);
    463444        }
    464445       
     
    471452    fprintf(stderr, "LinearScale %s (nTicks=%d, step=%g)\n", _name,
    472453            nTicks, step);
    473     _majorSweep.SetValues(tickMin, step, nTicks);
     454    _major.SetValues(tickMin, step, nTicks);
    474455
    475456    /*
     
    488469    /* Now calculate the minor tick step and number. */
    489470
    490     if ((_reqNumMinorTicks > 0) && (_flags & AUTOSCALE_MAJOR)) {
    491         nTicks = _reqNumMinorTicks - 1;
     471    if ((_minor.reqNumTicks > 0) && (_minor.IsAutoScale())) {
     472        nTicks = _minor.reqNumTicks - 1;
    492473        step = 1.0 / (nTicks + 1);
    493474    } else {
     
    497478                                 * create minor log-scale tick marks.  */
    498479    }
    499     _minorSweep.SetValues(step, step, nTicks);
     480    _minor.SetValues(step, step, nTicks);
    500481    fprintf(stderr, "leaving LinearScale %s (min=%g, max=%g)\n",
    501482            _name, _min, _max);
    502483}
    503484
    504 
    505 void
    506 Axis::SweepTicks()
    507 {
    508     if (_flags & AUTOSCALE_MAJOR) {
    509         if (_t1Ptr != NULL) {
    510             delete _t1Ptr;
    511         }
    512         _t1Ptr = new Ticks(_majorSweep);
    513     }
    514     if (_flags & AUTOSCALE_MINOR) {
    515         if (_t2Ptr != NULL) {
    516             delete _t2Ptr;
    517         }
    518         _t2Ptr = new Ticks(_minorSweep);
    519     }
    520 }
    521485
    522486void
     
    529493        LinearScale();
    530494    }
    531     SweepTicks();
     495    _major.SweepTicks();
     496    _minor.SweepTicks();
    532497    MakeTicks();
    533498}
     
    537502Axis::MakeTicks(void)
    538503{
     504    _major.Reset();
     505    _minor.Reset();
    539506    int i;
    540 
    541     _majorTicks.Reset();
    542     _minorTicks.Reset();
    543     for (i = 0; i < _t1Ptr->NumTicks(); i++) {
    544         union {
    545             float x;
    546             void *clientData;
    547         } value;
     507    for (i = 0; i < _major.NumTicks(); i++) {
    548508        double t1, t2;
    549509        int j;
    550510       
    551         t1 = _t1Ptr->GetTick(i);
     511        t1 = _major.GetTick(i);
    552512        /* Minor ticks */
    553         for (j = 0; j < _t2Ptr->NumTicks(); j++) {
    554             t2 = t1 + (_majorSweep.Step() * _t2Ptr->GetTick(j));
     513        for (j = 0; j < _minor.NumTicks(); j++) {
     514            t2 = t1 + (_major.Step() * _minor.GetTick(j));
    555515            if (!InRange(t2)) {
    556516                continue;
    557517            }
    558518            if (t1 == t2) {
    559                 continue;               // Don't add duplicate minor ticks.
     519                continue;       // Don't add duplicate minor ticks.
    560520            }
    561             value.x = t2;
    562             _minorTicks.Append(value.clientData);
     521            _minor.Append(t2);
    563522        }
    564523        if (!InRange(t1)) {
    565524            continue;
    566525        }
    567         value.x = t1;
    568         _majorTicks.Append(value.clientData);
    569     }
    570 }
    571 
    572 bool
    573 Axis::FirstMajor(TickIter &iter)
    574 {
    575     ChainLink *linkPtr;
    576 
    577     linkPtr = _majorTicks.FirstLink();
    578     iter.SetStartingLink(linkPtr);
    579     return (linkPtr != NULL);
    580 }
    581 
    582 bool
    583 Axis::FirstMinor(TickIter &iter)
    584 {
    585     ChainLink *linkPtr;
    586 
    587     linkPtr = _minorTicks.FirstLink();
    588     iter.SetStartingLink(linkPtr);
    589     return (linkPtr != NULL);
     526        _major.Append(t1);
     527    }
    590528}
    591529
Note: See TracChangeset for help on using the changeset viewer.