@Override public String rescaleToStringInternal(double scaleFactor, Measure measure) { double rescaled = measure.value * scaleFactor; String rescaledString; if (rescaled == (int) rescaled) { rescaledString = String.valueOf((int) rescaled); } else { rescaledString = String.valueOf(rescaled); } if (measure.isPixelInPixelDefault()) { return rescaledString; } else { return rescaledString + UNIT_SYMBOLS.get(measure.uom); } } },
@Override public String rescaleToStringInternal(double scaleFactor, Measure measure) { if (measure.isRealWorldUnit()) { if (measure.isRealWorldUnitInPixelDefault()) { return String.valueOf(measure.value) + UNIT_SYMBOLS.get(measure.uom); } else { return String.valueOf(measure.value); } } else { return String.valueOf(measure.value * scaleFactor); } }
public Measure(String value, Unit<Length> defaultUnit) { setDefaultUnit(defaultUnit); processLiteralExpression(value, defaultUnit); }
@Override protected Expression rescale(Expression expr) { // handle null values if (expr == null) { return null; } if (expr == Expression.NIL) { return Expression.NIL; } // delegate the handling of the rescaling to ValueAndUnit // to deal with local uom (px, m, ft suffixes) Measure v = new Measure(expr, defaultUnit); return RescalingMode.Pixels.rescaleToExpression(scale, v); }
/** * @return true, if the uom is a real world unit within a symbolizer whose default unit is * pixel. */ public boolean isRealWorldUnitInPixelDefault() { return isRealWorldUnit() && (defaultUnit == null || defaultUnit == Units.PIXEL); } }
private void processLiteralExpression(Literal literal, Unit<Length> defaultUnit) { // check if we have a uom attached at the end of the expression String value = literal.evaluate(null, String.class); if (value == null) { // let it go without doing anything, it may be a ConstantExpression.NULL return; } processLiteralExpression(value, defaultUnit); }
/** * Used to rescaleDashArray the provided unscaled value. * * @param unscaled the unscaled value. * @param mapScale the mapScale in pixels per meter. * @param uom the unit of measure that will be used to scale. * @return the expression multiplied by the provided scale. */ protected String rescale(String unscaled, Unit<Length> uom) { if (unscaled == null) { return unscaled; } Measure v = new Measure(unscaled, uom); return RescalingMode.RealWorld.rescaleToString(mapScale, v); }
@Override public Expression rescaleToExpression(Expression scaleFactor, Measure measure) { if (measure.isRealWorldUnit()) { return measure.expression; } else { return super.rescaleToExpression(scaleFactor, measure); } } },
public Measure(Expression unscaled, Unit<Length> defaultUnit) { this.expression = unscaled; setDefaultUnit(defaultUnit); this.uom = defaultUnit; if (unscaled instanceof Literal) { processLiteralExpression((Literal) unscaled, defaultUnit); } else { // see if we can still optimize PropertyIsNull test = ff.isNull(unscaled); Filter simplified = (Filter) test.accept(new SimplifyingFilterVisitor(), null); if (simplified == Filter.INCLUDE) { // special case, the expression was nil to start with this.expression = NilExpression.NIL; this.uom = defaultUnit; } else if (simplified instanceof PropertyIsNull) { PropertyIsNull pin = (PropertyIsNull) simplified; Expression se = pin.getExpression(); if (se instanceof Literal) { processLiteralExpression((Literal) se, defaultUnit); } else { this.expression = se; this.uom = defaultUnit; } } } }
@Override protected void rescaleOption(Map<String, String> options, String key, double defaultValue) { double scaleFactor = (double) scale.evaluate(null, Double.class); String value = options.get(key); if (value == null) { value = String.valueOf(defaultValue); } Measure v = new Measure(value, defaultUnit); String rescaled = RescalingMode.Pixels.rescaleToString(scaleFactor, v); options.put(key, String.valueOf(rescaled)); }
@Override protected void rescaleOption(Map<String, String> options, String key, int defaultValue) { double scaleFactor = (double) scale.evaluate(null, Double.class); String value = options.get(key); if (value == null) { value = String.valueOf(defaultValue); } Measure v = new Measure(value, defaultUnit); String rescaled = RescalingMode.Pixels.rescaleToString(scaleFactor, v); options.put(key, String.valueOf(rescaled)); } }
/** * Used to rescale the provided expr. * * <p>We do optimize the case where the provided expression is a literal; no sense doing a * calculation each time if we don't have to. * * @param expr * @return expr multiplied by the provided scale */ protected Expression rescale(Expression expr) { if (expr == null) { return null; } if (expr == Expression.NIL) { return Expression.NIL; } Measure m = new Measure(expr, defaultUnit); return RescalingMode.KeepUnits.rescaleToExpression(scale, m); }
/** * Used to rescaleDashArray the provided unscaled value. * * @param unscaled the unscaled value. * @param mapScale the mapScale in pixels per meter. * @param uom the unit of measure that will be used to scale. * @return the expression multiplied by the provided scale. */ protected Expression rescale(Expression unscaled, Unit<Length> uom) { if (unscaled == null || unscaled.equals(Expression.NIL)) { return unscaled; } Measure m = new Measure(unscaled, uom); return RescalingMode.RealWorld.rescaleToExpression(ff.literal(mapScale), m); }
public Object evaluate(Object feature) { String value = getExpression(0).evaluate(feature, String.class); if (value == null || value.trim().isEmpty()) { return null; } Unit<Length> defaultUnit = getExpression(1).evaluate(feature, Unit.class); Double scaleFactor = getExpression(2).evaluate(feature, Double.class); if (scaleFactor == null) { throw new IllegalArgumentException("Invalid scale factor, it should be non null"); } RescalingMode mode = RescalingMode.KeepUnits; if (getParameters().size() >= 3) { RescalingMode theMode = getExpression(3).evaluate(feature, RescalingMode.class); if (theMode != null) { mode = theMode; } } // compute the rescaling now that we have all the details Measure measure = new Measure(value, defaultUnit); String result = mode.rescaleToString(scaleFactor, measure); return result; } }