mirror of
https://github.com/UpsilonNumworks/Upsilon.git
synced 2026-01-18 16:27:34 +01:00
[apps/shared] New automatic zoom on curves
Initial zoom for displaying curves is computed according to the
following rules :
- For polar and parametric curves, the algorithm has not changed.
Vertical and horizontal ranges are chosen in order to display the
full curve with orthonormal graduations.
- For cartesian curves, the horizontal range is chosen in order to
display all points of interest (roots, extrema, asymptotes...).
The vertical range is fitted to be able to display those points, but
also cuts out points outside of the function's order of magnitude.
Change-Id: Idf8233fc2e6586b85d34c4da152c83e75513d85c
This commit is contained in:
Gabriel Ozouf
committed by
Émilie Feral
Émilie Feral
parent
1917999f6d
commit
8104caea50
@@ -261,6 +261,278 @@ void ContinuousFunction::setTMax(float tMax) {
|
||||
setCache(nullptr);
|
||||
}
|
||||
|
||||
void ContinuousFunction::rangeForDisplay(float * xMin, float * xMax, float * yMin, float * yMax, Poincare::Context * context, bool tuneXRange) const {
|
||||
if (plotType() == PlotType::Cartesian) {
|
||||
interestingXAndYRangesForDisplay(xMin, xMax, yMin, yMax, context, tuneXRange);
|
||||
} else {
|
||||
fullXYRange(xMin, xMax, yMin, yMax, context);
|
||||
}
|
||||
}
|
||||
|
||||
void ContinuousFunction::fullXYRange(float * xMin, float * xMax, float * yMin, float * yMax, Context * context) const {
|
||||
assert(yMin && yMax);
|
||||
assert(!(std::isinf(tMin()) || std::isinf(tMax()) || std::isnan(rangeStep())));
|
||||
|
||||
float resultXMin = FLT_MAX, resultXMax = - FLT_MAX, resultYMin = FLT_MAX, resultYMax = - FLT_MAX;
|
||||
for (float t = tMin(); t <= tMax(); t += rangeStep()) {
|
||||
Coordinate2D<float> xy = privateEvaluateXYAtParameter(t, context);
|
||||
if (!std::isfinite(xy.x1()) || !std::isfinite(xy.x2())) {
|
||||
continue;
|
||||
}
|
||||
resultXMin = std::min(xy.x1(), resultXMin);
|
||||
resultXMax = std::max(xy.x1(), resultXMax);
|
||||
resultYMin = std::min(xy.x2(), resultYMin);
|
||||
resultYMax = std::max(xy.x2(), resultYMax);
|
||||
}
|
||||
if (xMin) {
|
||||
*xMin = resultXMin;
|
||||
}
|
||||
if (xMax) {
|
||||
*xMax = resultXMax;
|
||||
}
|
||||
*yMin = resultYMin;
|
||||
*yMax = resultYMax;
|
||||
}
|
||||
|
||||
static float evaluateAndRound(const ContinuousFunction * f, float x, Context * context, float precision = 1e-5) {
|
||||
/* When evaluating sin(x)/x close to zero using the standard sine function,
|
||||
* one can detect small varitions, while the cardinal sine is supposed to be
|
||||
* locally monotonous. To smooth our such variations, we round the result of
|
||||
* the evaluations. As we are not interested in precise results but only in
|
||||
* ordering, this approximation is sufficient. */
|
||||
return precision * std::round(f->evaluateXYAtParameter(x, context).x2() / precision);
|
||||
}
|
||||
|
||||
|
||||
/* TODO : These three methods perform checks that will also be relevant for the
|
||||
* equation solver. Remember to factorize this code when integrating the new
|
||||
* solver. */
|
||||
static bool boundOfIntervalOfDefinitionIsReached(float y1, float y2) {
|
||||
return std::isfinite(y1) && !std::isinf(y2) && std::isnan(y2);
|
||||
}
|
||||
static bool rootExistsOnInterval(float y1, float y2) {
|
||||
return ((y1 < 0.f && y2 > 0.f) || (y1 > 0.f && y2 < 0.f));
|
||||
}
|
||||
static bool extremumExistsOnInterval(float y1, float y2, float y3) {
|
||||
return (y1 < y2 && y2 > y3) || (y1 > y2 && y2 < y3);
|
||||
}
|
||||
|
||||
/* This function checks whether an interval contains an extremum or an
|
||||
* asymptote, by recursively computing the slopes. In case of an extremum, the
|
||||
* slope should taper off toward the center. */
|
||||
static bool isExtremum(const ContinuousFunction * f, float x1, float x2, float x3, float y1, float y2, float y3, Context * context, int iterations = 3) {
|
||||
if (iterations <= 0) {
|
||||
return false;
|
||||
}
|
||||
float x[2] = {x1, x3}, y[2] = {y1, y3};
|
||||
float xm, ym;
|
||||
for (int i = 0; i < 2; i++) {
|
||||
xm = (x[i] + x2) / 2.f;
|
||||
ym = evaluateAndRound(f, xm, context);
|
||||
bool res = ((y[i] < ym) != (ym < y2)) ? isExtremum(f, x[i], xm, x2, y[i], ym, y2, context, iterations - 1) : std::fabs(ym - y[i]) >= std::fabs(y2 - ym);
|
||||
if (!res) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
enum class PointOfInterest : uint8_t {
|
||||
None,
|
||||
Bound,
|
||||
Extremum,
|
||||
Root
|
||||
};
|
||||
|
||||
void ContinuousFunction::interestingXAndYRangesForDisplay(float * xMin, float * xMax, float * yMin, float * yMax, Context * context, bool tuneXRange) const {
|
||||
assert(xMin && xMax && yMin && yMax);
|
||||
assert(plotType() == PlotType::Cartesian);
|
||||
|
||||
/* Constants of the algorithm. */
|
||||
constexpr float defaultMaxInterval = 2e5f;
|
||||
constexpr float minDistance = 1e-2f;
|
||||
constexpr float asymptoteThreshold = 2e-1f;
|
||||
constexpr float stepFactor = 1.1f;
|
||||
constexpr int maxNumberOfPoints = 3;
|
||||
constexpr float breathingRoom = 0.3f;
|
||||
constexpr float maxRatioBetweenPoints = 100.f;
|
||||
|
||||
const bool hasIntervalOfDefinition = std::isfinite(tMin()) && std::isfinite(tMax());
|
||||
float center, maxDistance;
|
||||
if (!tuneXRange) {
|
||||
center = (*xMax + *xMin) / 2.f;
|
||||
maxDistance = (*xMax - *xMin) / 2.f;
|
||||
} else if (hasIntervalOfDefinition) {
|
||||
center = (tMax() + tMin()) / 2.f;
|
||||
maxDistance = (tMax() - tMin()) / 2.f;
|
||||
} else {
|
||||
center = 0.f;
|
||||
maxDistance = defaultMaxInterval / 2.f;
|
||||
}
|
||||
|
||||
float resultX[2] = {FLT_MAX, - FLT_MAX};
|
||||
float resultYMin = FLT_MAX, resultYMax = - FLT_MAX;
|
||||
float asymptote[2] = {FLT_MAX, - FLT_MAX};
|
||||
int numberOfPoints;
|
||||
float xFallback, yFallback[2] = {NAN, NAN};
|
||||
float firstResult;
|
||||
float dXOld, dXPrev, dXNext, yOld, yPrev, yNext;
|
||||
|
||||
/* Look for an point of interest at the center. */
|
||||
const float a = center - minDistance - FLT_EPSILON, b = center + FLT_EPSILON, c = center + minDistance + FLT_EPSILON;
|
||||
const float ya = evaluateAndRound(this, a, context), yb = evaluateAndRound(this, b, context), yc = evaluateAndRound(this, c, context);
|
||||
if (boundOfIntervalOfDefinitionIsReached(ya, yc) ||
|
||||
boundOfIntervalOfDefinitionIsReached(yc, ya) ||
|
||||
rootExistsOnInterval(ya, yc) ||
|
||||
extremumExistsOnInterval(ya, yb, yc) || ya == yc)
|
||||
{
|
||||
resultX[0] = resultX[1] = center;
|
||||
if (extremumExistsOnInterval(ya, yb, yc) && isExtremum(this, a, b, c, ya, yb, yc, context)) {
|
||||
resultYMin = resultYMax = yb;
|
||||
}
|
||||
}
|
||||
|
||||
/* We search for points of interest by exploring the function leftward from
|
||||
* the center and then rightward, hence the two iterations. */
|
||||
for (int i = 0; i < 2; i++) {
|
||||
/* Initialize the search parameters. */
|
||||
numberOfPoints = 0;
|
||||
firstResult = NAN;
|
||||
xFallback = NAN;
|
||||
dXPrev = i == 0 ? - minDistance : minDistance;
|
||||
dXNext = dXPrev * stepFactor;
|
||||
yPrev = evaluateAndRound(this, center + dXPrev, context);
|
||||
yNext = evaluateAndRound(this, center + dXNext, context);
|
||||
|
||||
while(std::fabs(dXPrev) < maxDistance) {
|
||||
/* Update the slider. */
|
||||
dXOld = dXPrev;
|
||||
dXPrev = dXNext;
|
||||
dXNext *= stepFactor;
|
||||
yOld = yPrev;
|
||||
yPrev = yNext;
|
||||
yNext = evaluateAndRound(this, center + dXNext, context);
|
||||
if (std::isinf(yNext)) {
|
||||
continue;
|
||||
}
|
||||
/* Check for a change in the profile. */
|
||||
const PointOfInterest variation = boundOfIntervalOfDefinitionIsReached(yPrev, yNext) ? PointOfInterest::Bound :
|
||||
rootExistsOnInterval(yPrev, yNext) ? PointOfInterest::Root :
|
||||
extremumExistsOnInterval(yOld, yPrev, yNext) ? PointOfInterest::Extremum :
|
||||
PointOfInterest::None;
|
||||
switch (static_cast<uint8_t>(variation)) {
|
||||
/* The fall through is intentional, as we only want to update the Y
|
||||
* range when an extremum is detected, but need to update the X range
|
||||
* in all cases. */
|
||||
case static_cast<uint8_t>(PointOfInterest::Extremum):
|
||||
if (isExtremum(this, center + dXOld, center + dXPrev, center + dXNext, yOld, yPrev, yNext, context)) {
|
||||
resultYMin = std::min(resultYMin, yPrev);
|
||||
resultYMax = std::max(resultYMax, yPrev);
|
||||
}
|
||||
case static_cast<uint8_t>(PointOfInterest::Bound):
|
||||
/* We only count extrema / discontinuities for limiting the number
|
||||
* of points. This prevents cos(x) and cos(x)+2 from having different
|
||||
* profiles. */
|
||||
if (++numberOfPoints == maxNumberOfPoints) {
|
||||
/* When too many points are encountered, we prepare their erasure by
|
||||
* setting a restore point. */
|
||||
xFallback = dXNext + center;
|
||||
yFallback[0] = resultYMin;
|
||||
yFallback[1] = resultYMax;
|
||||
}
|
||||
case static_cast<uint8_t>(PointOfInterest::Root):
|
||||
asymptote[i] = i == 0 ? FLT_MAX : - FLT_MAX;
|
||||
resultX[0] = std::min(resultX[0], center + (i == 0 ? dXNext : dXPrev));
|
||||
resultX[1] = std::max(resultX[1], center + (i == 1 ? dXNext : dXPrev));
|
||||
if (std::isnan(firstResult)) {
|
||||
firstResult = dXNext;
|
||||
}
|
||||
break;
|
||||
default:
|
||||
const float slopeNext = (yNext - yPrev) / (dXNext - dXPrev), slopePrev = (yPrev - yOld) / (dXPrev - dXOld);
|
||||
if ((std::fabs(slopeNext) < asymptoteThreshold) && (std::fabs(slopePrev) > asymptoteThreshold)) {
|
||||
// Horizontal asymptote begins
|
||||
asymptote[i] = (i == 0) ? std::min(asymptote[i], center + dXNext) : std::max(asymptote[i], center + dXNext);
|
||||
} else if ((std::fabs(slopeNext) < asymptoteThreshold) && (std::fabs(slopePrev) > asymptoteThreshold)) {
|
||||
// Horizontal asymptote invalidates : it might be an asymptote when
|
||||
// going the other way.
|
||||
asymptote[1 - i] = (i == 1) ? std::min(asymptote[1 - i], center + dXPrev) : std::max(asymptote[1 - i], center + dXPrev);
|
||||
}
|
||||
}
|
||||
}
|
||||
if (std::fabs(resultX[i]) > std::fabs(firstResult) * maxRatioBetweenPoints && !std::isnan(xFallback)) {
|
||||
/* When there are too many points, cut them if their orders are too
|
||||
* different. */
|
||||
resultX[i] = xFallback;
|
||||
resultYMin = yFallback[0];
|
||||
resultYMax = yFallback[1];
|
||||
}
|
||||
}
|
||||
|
||||
if (tuneXRange) {
|
||||
/* Cut after horizontal asymptotes. */
|
||||
resultX[0] = std::min(resultX[0], asymptote[0]);
|
||||
resultX[1] = std::max(resultX[1], asymptote[1]);
|
||||
if (resultX[0] >= resultX[1]) {
|
||||
/* Fallback to default range. */
|
||||
resultX[0] = - Range1D::k_default;
|
||||
resultX[1] = Range1D::k_default;
|
||||
} else {
|
||||
/* Add breathing room around points of interest. */
|
||||
float xRange = resultX[1] - resultX[0];
|
||||
resultX[0] -= breathingRoom * xRange;
|
||||
resultX[1] += breathingRoom * xRange;
|
||||
/* Round to the next integer. */
|
||||
resultX[0] = std::floor(resultX[0]);
|
||||
resultX[1] = std::ceil(resultX[1]);
|
||||
}
|
||||
*xMin = std::min(resultX[0], *xMin);
|
||||
*xMax = std::max(resultX[1], *xMax);
|
||||
}
|
||||
*yMin = std::min(resultYMin, *yMin);
|
||||
*yMax = std::max(resultYMax, *yMax);
|
||||
|
||||
refinedYRangeForDisplay(*xMin, *xMax, yMin, yMax, context);
|
||||
}
|
||||
|
||||
void ContinuousFunction::refinedYRangeForDisplay(float xMin, float xMax, float * yMin, float * yMax, Context * context) const {
|
||||
/* This methods computes the Y range that will be displayed for the cartesian
|
||||
* function, given an X range (xMin, xMax) and bounds yMin and yMax that must
|
||||
* be inside the Y range.*/
|
||||
assert(plotType() == PlotType::Cartesian);
|
||||
assert(yMin && yMax);
|
||||
|
||||
constexpr int sampleSize = 80;
|
||||
|
||||
float sampleYMin = FLT_MAX, sampleYMax = -FLT_MAX;
|
||||
const float step = (xMax - xMin) / (sampleSize - 1);
|
||||
float x, y;
|
||||
float sum = 0.f;
|
||||
int pop = 0;
|
||||
|
||||
for (int i = 1; i < sampleSize; i++) {
|
||||
x = xMin + i * step;
|
||||
y = privateEvaluateXYAtParameter(x, context).x2();
|
||||
sampleYMin = std::min(sampleYMin, y);
|
||||
sampleYMax = std::max(sampleYMax, y);
|
||||
if (std::isfinite(y) && std::fabs(y) > FLT_EPSILON) {
|
||||
sum += std::log(std::fabs(y));
|
||||
pop++;
|
||||
}
|
||||
}
|
||||
/* sum/n is the log mean value of the function, which can be interpreted as
|
||||
* its average order of magnitude. Then, bound is the value for the next
|
||||
* order of magnitude and is used to cut the Y range. */
|
||||
float bound = (pop > 0) ? std::exp(sum / pop + 1.f) : FLT_MAX;
|
||||
*yMin = std::min(*yMin, std::max(sampleYMin, -bound));
|
||||
*yMax = std::max(*yMax, std::min(sampleYMax, bound));
|
||||
if (*yMin == *yMax) {
|
||||
float d = (*yMin == 0.f) ? 1.f : *yMin * 0.2f;
|
||||
*yMin -= d;
|
||||
*yMax += d;
|
||||
}
|
||||
}
|
||||
|
||||
void * ContinuousFunction::Model::expressionAddress(const Ion::Storage::Record * record) const {
|
||||
return (char *)record->value().buffer+sizeof(RecordDataBuffer);
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user