LogarithmicAxis.java
package ui.emulationsettings;
import javafx.beans.binding.DoubleBinding;
import javafx.beans.property.DoubleProperty;
import javafx.beans.property.SimpleDoubleProperty;
import javafx.scene.chart.ValueAxis;
import java.text.NumberFormat;
import java.util.ArrayList;
import java.util.List;
import static libsidplay.common.SIDChip.FC_MAX;
//http://blog.dooapp.com/logarithmic-scale-strikes-back-in-javafx-20
public class LogarithmicAxis extends ValueAxis<Number> {
// Create our LogarithmicAxis class that extends ValueAxis<Number> and
// define two properties that will represent the log lower and upper bounds
// of our axis.
private final DoubleProperty logUpperBound = new SimpleDoubleProperty();
private final DoubleProperty logLowerBound = new SimpleDoubleProperty();
// we bind our properties with the default bounds of the value axis. But
// before, we should verify the given range according to the mathematic
// logarithmic interval definition.
public LogarithmicAxis() {
super(0, FC_MAX);
bindLogBoundsToDefaultBounds();
}
public LogarithmicAxis(double lowerBound, double upperBound) {
super(lowerBound, upperBound);
try {
validateBounds(lowerBound, upperBound);
bindLogBoundsToDefaultBounds();
} catch (IllegalLogarithmicRangeException ignored) {
}
}
/**
* Bind our logarithmic bounds with the super class bounds, consider the base 10
* logarithmic scale.
*/
private void bindLogBoundsToDefaultBounds() {
logLowerBound.bind(new DoubleBinding() {
{
super.bind(lowerBoundProperty());
}
@Override
protected double computeValue() {
return Math.log10(lowerBoundProperty().get());
}
});
logUpperBound.bind(new DoubleBinding() {
{
super.bind(upperBoundProperty());
}
@Override
protected double computeValue() {
return Math.log10(upperBoundProperty().get());
}
});
}
/**
* Validate the bounds by throwing an exception if the values are not conformed to
* the mathematics log interval: ]0,Double.MAX_VALUE]
*
* @param lowerBound lower bound
* @param upperBound upper bound
* @throws IllegalLogarithmicRangeException if the bounds are not valid
*/
private void validateBounds(double lowerBound, double upperBound) throws IllegalLogarithmicRangeException {
if (lowerBound < 0 || upperBound < 0 || lowerBound > upperBound) {
throw new IllegalLogarithmicRangeException(
"The logarithmic range should be include to ]0,Double.MAX_VALUE] and the lowerBound should be less than the upperBound");
}
}
// Now we have to implement all abstract methods of the ValueAxis class.
// The first one, calculateMinorTickMarks is used to get the list of minor
// tick marks position that you want to display on the axis. You could find
// my definition below. It's based on the number of minor ticks and the
// logarithmic formula.
@Override
protected List<Number> calculateMinorTickMarks() {
Number[] range = getRange();
List<Number> minorTickMarksPositions = new ArrayList<>();
if (range != null) {
Number lowerBound = range[0];
Number upperBound = range[1];
double logUpperBound = Math.log10(upperBound.doubleValue());
double logLowerBound = Math.log10(lowerBound.doubleValue());
int minorTickMarkCount = getMinorTickCount();
for (double i = logLowerBound; i <= logUpperBound; i += 1) {
for (double j = 0; j <= 10; j += 1. / minorTickMarkCount) {
double value = j * Math.pow(10, i);
minorTickMarksPositions.add(value);
}
}
}
return minorTickMarksPositions;
}
// Then, the calculateTickValues method is used to calculate a list of all
// the data values for each tick mark in the range, represented by the second
// parameter. The formula is the same as previously, but here we want to
// display one tick each power of 10.
@Override
protected List<Number> calculateTickValues(double length, Object range) {
List<Number> tickPositions = new ArrayList<>();
if (range != null) {
Number lowerBound = ((Number[]) range)[0];
Number upperBound = ((Number[]) range)[1];
double logLowerBound = Math.log10(lowerBound.doubleValue());
double logUpperBound = Math.log10(upperBound.doubleValue());
for (double i = logLowerBound; i <= logUpperBound; i += 1) {
for (double j = 1; j <= 10; j++) {
double value = j * Math.pow(10, i);
tickPositions.add(value);
}
}
}
return tickPositions;
}
// The getRange provides the current range of the axis. A basic
// implementation is to return an array of the lowerBound and upperBound
// properties defined into the ValueAxis class.
@Override
protected Number[] getRange() {
return new Number[]{lowerBoundProperty().get(), upperBoundProperty().get()};
}
// The getTickMarkLabel is only used to convert the number value to a string
// that will be displayed under the tickMark. Here I choose to use a number
// formatter.
@Override
protected String getTickMarkLabel(Number value) {
NumberFormat formatter = NumberFormat.getInstance();
formatter.setMaximumIntegerDigits(6);
formatter.setMinimumIntegerDigits(1);
return formatter.format(value);
}
// The method setRange is used to update the range when data are added into
// the chart. There are two possibilities, whether the axis is animated or not. The
// simplest case is to set the lower and upper bound properties directly
// with the new values.
@Override
protected void setRange(Object range, boolean animate) {
if (range != null) {
Number lowerBound = ((Number[]) range)[0];
Number upperBound = ((Number[]) range)[1];
try {
validateBounds(lowerBound.doubleValue(), upperBound.doubleValue());
} catch (IllegalLogarithmicRangeException ignored) {
}
lowerBoundProperty().set(lowerBound.doubleValue());
upperBoundProperty().set(upperBound.doubleValue());
}
}
// We are almost done, but we forgot to override 2 important methods that are
// used to perform the matching between data and the axis (and the reverse).
@Override
public Number getValueForDisplay(double displayPosition) {
double delta = logUpperBound.get() - logLowerBound.get();
if (getSide().isVertical()) {
return Math.pow(10, (displayPosition - getHeight()) / -getHeight() * delta + logLowerBound.get());
} else {
return Math.pow(10, displayPosition / getWidth() * delta + logLowerBound.get());
}
}
@Override
public double getDisplayPosition(Number value) {
double delta = logUpperBound.get() - logLowerBound.get();
double deltaV = Math.log10(value.doubleValue()) - logLowerBound.get();
if (getSide().isVertical()) {
return (1. - deltaV / delta) * getHeight();
} else {
return deltaV / delta * getWidth();
}
}
/**
* Exception to be thrown when a bound value isn't supported by the logarithmic
* axis<br>
*
* @author Kevin Senechal mailto: kevin.senechal@dooapp.com
*
*/
public static class IllegalLogarithmicRangeException extends Exception {
private static final long serialVersionUID = 1L;
/**
* @param message Error message
*/
public IllegalLogarithmicRangeException(String message) {
super(message);
}
}
}