Exemple #1
0
void FunctionConfig::reload() {
	_size = 0;

	if (_points.size())
		qStableSort(_points.begin(), _points.end(), sortFn);

	if (_data)
        delete[] _data;
	_data = NULL;
	if (_points.size()) {
        _data = new float[_size = MEMOIZE_PRECISION * _points[_points.size() - 1].x()];

        for (int i = 0; i < _size; i++)
                _data[i] = -1e6;

		for (int k = 0; k < _points[0].x() * MEMOIZE_PRECISION; k++) {
            if (k < _size)
                _data[k] = _points[0].y() * k / (_points[0].x() * MEMOIZE_PRECISION);
        }

       for (int i = 0; i < _points.size(); i++) {
            QPointF p0 = ensureInBounds(_points, i - 1);
            QPointF p1 = ensureInBounds(_points, i);
            QPointF p2 = ensureInBounds(_points, i + 1);
            QPointF p3 = ensureInBounds(_points, i + 2);

            int end = p2.x() * MEMOIZE_PRECISION;
            int start = p1.x() * MEMOIZE_PRECISION;

            for (int j = start; j < end && j < _size; j++) {
                double t = (j - start) / (double) (end - start);
                double t2 = t*t;
                double t3 = t*t*t;

                int x = .5 * ((2. * p1.x()) +
                              (-p0.x() + p2.x()) * t +
                              (2. * p0.x() - 5. * p1.x() + 4. * p2.x() - p3.x()) * t2 +
                              (-p0.x() + 3. * p1.x() - 3. * p2.x() + p3.x()) * t3)
                        * MEMOIZE_PRECISION;

                float y = .5 * ((2. * p1.y()) +
                                 (-p0.y() + p2.y()) * t +
                                 (2. * p0.y() - 5. * p1.y() + 4. * p2.y() - p3.y()) * t2 +
                                 (-p0.y() + 3. * p1.y() - 3. * p2.y() + p3.y()) * t3);

                if (x >= 0 && x < _size)
                    _data[x] = y;
            }
		}

       float last = 0;

       for (int i = 0; i < _size; i++)
       {
           if (_data[i] == -1e6)
               _data[i] = last;
           last = _data[i];
       }
	}
}
Exemple #2
0
void FunctionConfig::reload() {
	double i;
	int j, k;

	_size = 0;

	if (_points.size())
		qStableSort(_points.begin(), _points.end(), sortFn);

	if (_data)
		delete _data;
	_data = NULL;
	if (_points.size()) {
		_data = new double[_size = MEMOIZE_PRECISION * (((int) (_points[_points.size() - 1]).x()) + 1)];

		for (k = 0; k < (int) (_points[0].x() * MEMOIZE_PRECISION); k++) {
			_data[k] = _points[0].y() * k / (int) (_points[0].x() * MEMOIZE_PRECISION);
		}

		j = 1;

		for (i = _points[0].x(), k = (int) (_points[0].x() * MEMOIZE_PRECISION);
			 k < _size;
			 k++, i += (1.0f / MEMOIZE_PRECISION))
		{
			while (j < _points.size() && _points[j].x() <= i)
				j++;
			QPointF a_ = ensureInBounds(_points, j - 2);
			QPointF b_ = ensureInBounds(_points, j - 1);
			QPointF c_ = ensureInBounds(_points, j);
			QPointF d_ = ensureInBounds(_points, j + 1);
			double a = a_.y();
			double b = b_.y();
			double c = c_.y();
			double d = d_.y();
			double t = (c_.x() - b_.x()) == 0 ? 0 : (i - b_.x()) / (c_.x() - b_.x());
			double val = a * ((-t + 2) * t - 1) * t * 0.5 +
				b * (((3 * t - 5) * t) * t + 2) * 0.5 +
				c * ((-3 * t + 4) * t + 1) * t * 0.5 +
				d * ((t - 1) * t * t) * 0.5;
			_data[k] = val;
		}
	}
}