Replies the property that is the x coordinate of the second segment point.

@return the x2 property.
198914
@Pure
	public IntegerProperty x2Property() {
		if (this.p2.x == null) {
			this.p2.x = new SimpleIntegerProperty(this, MathFXAttributeNames.X2);
		}
		return this.p2.x;
	}
963233
public double getValue(double x)
	{
		synchronized(interpolatingRationalFunctionsLazyInitLock) {
			if(interpolatingRationalFunctions == null) {
				doCreateRationalFunctions();
			}
		}

		// Get interpolating rational function for the given point x
		int pointIndex = java.util.Arrays.binarySearch(points, x);
		if(pointIndex >= 0) {
			return values[pointIndex];
		}

		int intervallIndex = -pointIndex-2;

		// Check for extrapolation
		if(intervallIndex < 0) {
			// Extrapolation
			if(this.extrapolationMethod == ExtrapolationMethod.CONSTANT) {
				return values[0];
			} else if(this.extrapolationMethod == ExtrapolationMethod.LINEAR) {
				return values[0]+(values[1]-values[0])/(points[1]-points[0])*(x-points[0]);
			} else {
				intervallIndex = 0;
			}
		}
		else if(intervallIndex > points.length-2) {
			// Extrapolation
			if(this.extrapolationMethod == ExtrapolationMethod.CONSTANT) {
				return values[points.length-1];
			} else if(this.extrapolationMethod == ExtrapolationMethod.LINEAR) {
				return values[points.length-1]+(values[points.length-2]-values[points.length-1])/(points[points.length-2]-points[points.length-1])*(x-points[points.length-1]);
			} else {
				intervallIndex = points.length-2;
			}
		}

		RationalFunction rationalFunction = interpolatingRationalFunctions[intervallIndex];

		// Calculate interpolating value
		return rationalFunction.getValue(x-points[intervallIndex]);
	}
627572
@SuppressWarnings("static-method")
	public Point1dfx newPoint(ObjectProperty<WeakReference<Segment1D<?, ?>>> segment, DoubleProperty x, DoubleProperty y) {
		return new Point1dfx(segment, x, y);
	}
1151046
@Pure
	public DoubleProperty yProperty() {
		if (this.y == null) {
			this.y = new SimpleDoubleProperty(this, MathFXAttributeNames.Y);
		}
		return this.y;
	}
320500
public Point2D getCoord2D(double t) {
		Point2D pt = new Point2D();
		getCoord2D(t, pt);
		return pt;
	}
1172638
@SuppressWarnings("static-method")
	public Point2dfx newPoint(DoubleProperty x, DoubleProperty y) {
		return new Point2dfx(x, y);
	}
1095345
public DoubleProperty lengthSquaredProperty() {
		if (this.lengthSquareProperty == null) {
			this.lengthSquareProperty = new ReadOnlyDoubleWrapper(this, MathFXAttributeNames.LENGTH_SQUARED);
			this.lengthSquareProperty.bind(Bindings.createDoubleBinding(() -> {
				return Vector2ifx.this.x.doubleValue() * Vector2ifx.this.x.doubleValue()
						+ Vector2ifx.this.y.doubleValue() * Vector2ifx.this.y.doubleValue();
			}, this.x, this.y));
		}
		return this.lengthSquareProperty;
	}
593032
@Pure
	public DoubleProperty minXProperty() {
		if (this.minX == null) {
			this.minX = new SimpleDoubleProperty(this, MathFXAttributeNames.MINIMUM_X) {
				@Override
				protected void invalidated() {
					final double currentMin = get();
					final double currentMax = getMaxX();
					if (currentMin > currentMax) {
						// min-max constrain is broken
						maxXProperty().set(currentMin);
					}
				}
			};
		}
		return this.minX;
	}
45005
@Pure
	public static Point2d L2_L4(double x, double y) {
		final Point2d ntfLambdaPhi = NTFLambert_NTFLambdaPhi(x, y,
				LAMBERT_2_N,
				LAMBERT_2_C,
				LAMBERT_2_XS,
				LAMBERT_2_YS);
		return NTFLambdaPhi_NTFLambert(
				ntfLambdaPhi.getX(), ntfLambdaPhi.getY(),
				LAMBERT_4_N,
				LAMBERT_4_C,
				LAMBERT_4_XS,
				LAMBERT_4_YS);
	}
48433
@Pure
	public ObjectProperty<WeakReference<Segment1D<?, ?>>> segmentProperty() {
		if (this.segment == null) {
			this.segment = new SimpleObjectProperty<>(this, MathFXAttributeNames.SEGMENT);
		}
		return this.segment;
	}
482713
public int middleIndex()
  {
    int x = midPoint();
    int r = rightMostIndex();
    if (r < midPoint())
      x = r;
    return x;
  }
152865
@Pure
	public DoubleProperty radiusProperty() {
		if (this.radius == null) {
			this.radius = new SimpleDoubleProperty(this, MathFXAttributeNames.RADIUS) {
				@Override
				protected void invalidated() {
					if (get() < 0.) {
						set(0.);
					}
				}
			};
		}
		return this.radius;
	}
491424
@Pure
	public IntegerProperty y1Property() {
		if (this.p1.y == null) {
			this.p1.y = new SimpleIntegerProperty(this, MathFXAttributeNames.Y1);
		}
		return this.p1.y;
	}
750339
@Pure
	public static Point2d L2_L1(double x, double y) {
		final Point2d ntfLambdaPhi = NTFLambert_NTFLambdaPhi(x, y,
				LAMBERT_2_N,
				LAMBERT_2_C,
				LAMBERT_2_XS,
				LAMBERT_2_YS);
		return NTFLambdaPhi_NTFLambert(
				ntfLambdaPhi.getX(), ntfLambdaPhi.getY(),
				LAMBERT_1_N,
				LAMBERT_1_C,
				LAMBERT_1_XS,
				LAMBERT_1_YS);
	}
975023
@Pure
	public IntegerProperty minXProperty() {
		if (this.minX == null) {
			this.minX = new SimpleIntegerProperty(this, MathFXAttributeNames.MINIMUM_X) {
				@Override
				protected void invalidated() {
					final int currentMin = get();
					final int currentMax = getMaxX();
					if (currentMax < currentMin) {
						// min-max constrain is broken
						maxXProperty().set(currentMin);
					}
				}
			};
		}
		return this.minX;
	}
931664
function() {
        if (!this.center && this.size) {
            this.center = this.getLonLatFromViewPortPx({
                x: this.size.w / 2,
                y: this.size.h / 2
            });
        }
        return this.center;
    }
947340
public NumberExpression<Double> x() {
        if (x == null) {
            x = Expressions.numberOperation(Double.class, SpatialOps.X, mixin);
        }
        return x;
    }