@Override public Expression rescaleToExpression(Expression scaleFactor, Measure measure) { if (measure.isRealWorldUnit()) { return measure.expression; } else { return super.rescaleToExpression(scaleFactor, measure); } } },
@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); } }
public void testRasterSymbolizerDuplication() { // create a default RasterSymbolizer RasterSymbolizer original = sb.createRasterSymbolizer(); // duplicate it original.accept(visitor); RasterSymbolizer copy = (RasterSymbolizer) visitor.getCopy(); // compare it assertNotNull(copy); assertEquals(original, copy); }
@Override public void visit(LineSymbolizer line) { super.visit(line); LineSymbolizer copy = (LineSymbolizer) pages.peek(); Unit<Length> uom = copy.getUnitOfMeasure(); Stroke copyStroke = copy.getStroke(); rescaleStroke(copyStroke, uom); copy.setPerpendicularOffset(rescale(copy.getPerpendicularOffset(), uom)); copy.setUnitOfMeasure(Units.PIXEL); }
@Override public void visit(PolygonSymbolizer sym) { this.defaultUnit = sym.getUnitOfMeasure(); try { super.visit(sym); PolygonSymbolizer copy = (PolygonSymbolizer) pages.peek(); rescaleArrayOption(copy.getOptions(), PolygonSymbolizer.GRAPHIC_MARGIN_KEY, 0); } finally { this.defaultUnit = null; } }
public void testMark() { Mark mark = sf.getCircleMark(); Mark clone = visitor.copy(mark); assertCopy(mark, clone); Mark notEq = sf.getStarMark(); assertEqualsContract(clone, notEq, mark); }
private ExternalGraphic[] copy(ExternalGraphic[] externalGraphics) { if (externalGraphics == null) return null; ExternalGraphic[] copy = new ExternalGraphic[externalGraphics.length]; for (int i = 0; i < externalGraphics.length; i++) { copy[i] = copy(externalGraphics[i]); } return copy; }
public void testGraphic() { Graphic graphic = sf.getDefaultGraphic(); graphic.addMark(sf.getDefaultMark()); Graphic clone = (Graphic) visitor.copy(graphic); assertCopy(graphic, clone); assertEqualsContract(clone, graphic); assertEquals(clone.getSymbols().length, graphic.getSymbols().length); Graphic notEq = sf.getDefaultGraphic(); assertEqualsContract(clone, notEq, graphic); }
/** * 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); }
public Measure(String value, Unit<Length> defaultUnit) { setDefaultUnit(defaultUnit); processLiteralExpression(value, defaultUnit); }
/** * Used to rescale 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 a scaled value. */ private double rescale(double unscaled, Unit<Length> uom) { // computes the basic rescaled value return unscaled * computeRescaleMultiplier(uom); } }
public void testExternalGraphic() { ExternalGraphic exGraphic = sf.createExternalGraphic("http://somewhere", "image/png"); ExternalGraphic clone = visitor.copy(exGraphic); assertCopy(exGraphic, clone); ExternalGraphic notEq = sf.createExternalGraphic("http://somewhereelse", "image/jpeg"); assertEqualsContract(clone, notEq, exGraphic); // make sure it works for different format, same url ExternalGraphic notEq2 = visitor.copy(clone); notEq2.setFormat("image/jpeg"); assertEqualsContract(clone, notEq2, exGraphic); }
protected SelectedChannelType[] copy(SelectedChannelType[] channels) { if (channels == null) return null; SelectedChannelType[] copy = new SelectedChannelType[channels.length]; for (int i = 0; i < channels.length; i++) { copy[i] = copy(channels[i]); } return copy; }
/** * 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); }
private Mark[] copy(Mark[] marks) { if (marks == null) return null; Mark[] copy = new Mark[marks.length]; for (int i = 0; i < marks.length; i++) { copy[i] = copy(marks[i]); } return copy; }
private Symbol[] copy(Symbol[] symbols) { if (symbols == null) return null; Symbol[] copy = new Symbol[symbols.length]; for (int i = 0; i < symbols.length; i++) { copy[i] = copy(symbols[i]); } return copy; }
protected Extent[] copy(Extent[] extents) { if (extents == null) { return null; } Extent[] copy = new Extent[extents.length]; for (int i = 0; i < extents.length; i++) { copy[i] = copy(extents[i]); } return copy; }