/** * Retrieve the opacity from a Stroke object. * * @param stroke the Stroke object. * @return double of the line stroke's opacity, or NaN if unavailable. */ public static double opacity(Stroke stroke) { if (stroke == null) { return Double.NaN; } return opacity(stroke.getOpacity()); }
/** * Retrieve the opacity from a RasterSymbolizer object. * * @param symbolizer raster symbolizer information. * @return double of the raster symbolizer's opacity, or 1.0 if unavailable. */ public static double opacity(RasterSymbolizer rasterSymbolizer) { if (rasterSymbolizer == null) { return 1.0; } return opacity(rasterSymbolizer.getOpacity()); }
/** * Retrieve the opacity from a LineSymbolizer object. * * @param symbolizer Line symbolizer information. * @return double of the line symbolizer's opacity, or NaN if unavailable. */ public static double lineOpacity(LineSymbolizer symbolizer) { if (symbolizer == null) { return Double.NaN; } Stroke stroke = symbolizer.getStroke(); return opacity(stroke); }
/** * Retrieves the fill opacity from the first PolygonSymbolizer. * * <p>If you are using something fun like rules you will need to do your own thing. * * @param symbolizer Polygon symbolizer information. * @return double of the polygon's fill opacity, or NaN if unavailable. */ public static double polyFillOpacity(PolygonSymbolizer symbolizer) { if (symbolizer == null) { return Double.NaN; } Fill fill = symbolizer.getFill(); return opacity(fill); }
/** * Retrieves the border (stroke) opacity from a PolygonSymbolizer. * * <p>If you are using something fun like rules you will need to do your own thing. * * @param symbolizer Polygon symbolizer information. * @return double of the polygon's border opacity, or NaN if unavailable. */ public static double polyBorderOpacity(PolygonSymbolizer symbolizer) { if (symbolizer == null) { return Double.NaN; } Stroke stroke = symbolizer.getStroke(); if (stroke == null) { return Double.NaN; } return opacity(stroke); }
/** * Retrieves the point opacity from a PointSymbolizer. * * <p>If you are using something fun like rules you will need to do your own thing. * * @param symbolizer Point symbolizer information. * @return double of the point's opacity, or NaN if unavailable. */ public static double pointOpacity(PointSymbolizer symbolizer) { if (symbolizer == null) { return Double.NaN; } Graphic graphic = symbolizer.getGraphic(); if (graphic == null) { return Double.NaN; } for (GraphicalSymbol gs : graphic.graphicalSymbols()) { if (gs != null && gs instanceof Mark) { Mark mark = (Mark) gs; Fill fill = mark.getFill(); if (fill != null) { Expression expr = fill.getOpacity(); if (expr != null) { return SLD.opacity(expr); } } } } return Double.NaN; }
/** * Test that setting the raster opacity correct duplicates the raster symbolizer as a different * object and correctly sets the opacity. */ public void testSetRasterOpacity() { RasterSymbolizer rs = sb.createRasterSymbolizer(); Style s = sb.createStyle(rs); assertEquals(1.0, SLD.opacity(SLD.rasterSymbolizer(s))); SLD.setRasterOpacity(s, 0.25); assertEquals(0.25, SLD.opacity(SLD.rasterSymbolizer(s))); assertNotSame(SLD.rasterSymbolizer(s), rs); }
public static double opacity(Stroke stroke) { if (stroke == null) { return Double.NaN; } return opacity( stroke.getOpacity() ); } public static double opacity(RasterSymbolizer rasterSymbolizer ){
/** * Retrieve the opacity from a Stroke object. * * @param stroke the Stroke object. * * @return double of the line stroke's opacity, or NaN if unavailable. */ public static double opacity(Stroke stroke) { if (stroke == null) { return Double.NaN; } return opacity( stroke.getOpacity() ); }
public static double opacity(RasterSymbolizer rasterSymbolizer ){ if( rasterSymbolizer == null ){ return 1.0; } return opacity( rasterSymbolizer.getOpacity() ); }
/** * Retrieve the opacity from a RasterSymbolizer object. * * @param symbolizer raster symbolizer information. * * @return double of the raster symbolizer's opacity, or 1.0 if unavailable. */ public static double opacity(RasterSymbolizer rasterSymbolizer ){ if( rasterSymbolizer == null ){ return 1.0; } return opacity( rasterSymbolizer.getOpacity() ); }
/** * Retrieve the opacity from a LineSymbolizer object. * * @param symbolizer Line symbolizer information. * * @return double of the line symbolizer's opacity, or NaN if unavailable. */ public static double lineOpacity(LineSymbolizer symbolizer) { if (symbolizer == null) { return Double.NaN; } Stroke stroke = symbolizer.getStroke(); return opacity(stroke); }
/** * Grabs the opacity from the first LineSymbolizer. * * @param symbolizer Line symbolizer information. * * @return double of the line stroke's opacity, or NaN if unavailable. */ public static double lineOpacity(LineSymbolizer symbolizer) { if (symbolizer == null) { return Double.NaN; } Stroke stroke = symbolizer.getStroke(); return opacity(stroke); } public static double opacity(Stroke stroke) {
/** * Retrieves the fill opacity from the first PolygonSymbolizer. * <p> * If you are using something fun like rules you will need to do your own * thing. * * @param symbolizer Polygon symbolizer information. * * @return double of the polygon's fill opacity, or NaN if unavailable. */ public static double polyFillOpacity(PolygonSymbolizer symbolizer) { if (symbolizer == null) { return Double.NaN; } Fill fill = symbolizer.getFill(); return opacity(fill); }
/** * Retrieves the border (stroke) opacity from a PolygonSymbolizer. * <p> * If you are using something fun like rules you will need to do your own * thing. * * @param symbolizer Polygon symbolizer information. * * @return double of the polygon's border opacity, or NaN if unavailable. */ public static double polyBorderOpacity(PolygonSymbolizer symbolizer) { if (symbolizer == null) { return Double.NaN; } Stroke stroke = symbolizer.getStroke(); if (stroke == null) { return Double.NaN; } return opacity(stroke); }
/** * Grabs the fill opacity from the first PolygonSymbolizer. * * <p> * If you are using something fun like rules you will need to do your own * thing. * </p> * * @param symbolizer Polygon symbolizer information. * * @return double of the polygon's fill opacity, or NaN if unavailable. */ public static double polyFillOpacity(PolygonSymbolizer symbolizer) { if (symbolizer == null) { return Double.NaN; } Fill fill = symbolizer.getFill(); return opacity(fill); }
setLineColorItems(SLD.color(polySym.getStroke())); setFillColorItems(SLD.color(polySym.getFill())); setFillOpacityItems(SLD.opacity(polySym.getFill())); break;
@Test public void testPolygonWithTransparent() throws Exception { // <UserStyle> // <Title>SLD Cook Book: Transparent polygon</Title> // <FeatureTypeStyle> // <Rule> // <PolygonSymbolizer> // <Fill> // <CssParameter name="fill">#000080</CssParameter> // <CssParameter name="fill-opacity">0.5</CssParameter> // </Fill> // <Stroke> // <CssParameter name="stroke">#FFFFFF</CssParameter> // <CssParameter name="stroke-width">2</CssParameter> // </Stroke> // </PolygonSymbolizer> // </Rule> // </FeatureTypeStyle> // </UserStyle> Style style = parse("poly", "transparent.sld"); PolygonSymbolizer poly = SLD.polySymbolizer(style); assertEquals(color("000080"), SLD.color(poly.getFill())); assertEquals(0.5, SLD.opacity(poly.getFill()), 0.1); assertEquals(color("FFFFFF"), SLD.color(poly.getStroke())); assertEquals(2, SLD.width(poly.getStroke())); }
assertEquals("triangle", SLD.wellKnownName(SLD.mark(point))); assertEquals(color("009900"), SLD.color(SLD.fill(point))); assertEquals(0.2, SLD.opacity(SLD.fill(point)), 0.1); assertEquals(Color.black, SLD.color(SLD.stroke(point))); assertEquals(2, SLD.width(SLD.stroke(point)));
/** * Encodes a KML LabelStyle from a text style and symbolizer. */ protected void encodeTextStyle(TextStyle2D style, TextSymbolizer symbolizer) { start("LabelStyle"); if (symbolizer.getFill() != null) { double opacity = SLD.opacity(symbolizer.getFill()); if (Double.isNaN(opacity)) { // default to full opacity opacity = 1.0; } encodeColor(SLD.color(symbolizer.getFill()), opacity); } else { // default encodeColor("ffffffff"); } end("LabelStyle"); }