Class RendererUtilities
- Object
-
- RendererUtilities
-
public final class RendererUtilities extends Object
Class for holding utility functions that are common tasks for people using the "StreamingRenderer/Renderer".- Author:
- dblasby, Simone Giannecchini
-
-
Method Summary
All Methods Static Methods Concrete Methods Modifier and Type Method Description static double
calculateOGCScale(ReferencedEnvelope envelope, int imageWidth, Map hints)
This method performs the computation using the methods suggested by the OGC SLD specification, page 26.static double
calculateOGCScaleAffine(CoordinateReferenceSystem crs, AffineTransform worldToScreen, Map hints)
This method performs the computation using the methods suggested by the OGC SLD specification, page 26.static double
calculatePixelsPerMeterRatio(double scaleDenominator, Map hints)
Calculates the pixels per meter ratio based on a scale denominator.static double
calculateScale(ReferencedEnvelope envelope, int imageWidth, int imageHeight, double DPI)
Find the scale denominator of the map.static double
calculateScale(ReferencedEnvelope envelope, int imageWidth, int imageHeight, Map<?,?> hints)
First searches the hints for the scale denominator hint otherwise calls#calculateScale(org.geotools.util.SoftValueHashMap.Reference, int, int, double)
.static Envelope
createMapEnvelope(Rectangle paintArea, AffineTransform worldToScreen)
Creates the map's bounding box in real world coordinates.static ReferencedEnvelope
createMapEnvelope(Rectangle paintArea, AffineTransform worldToScreen, CoordinateReferenceSystem crs)
Creates the map's bounding box in real world coordinatesstatic Geometry
getCentroid(Geometry g)
Finds the centroid of the input geometry if input = point, line, polygon --> return a point that represents the centroid of that geom if input = geometry collection --> return a multipoint that represents the centoid of each sub-geomstatic double
getDpi(Map hints)
Either gets a DPI from the hints, or return the OGC standard, stating that a pixel is 0.28 mm (the result is a non integer DPI...)static Point
getPolygonCentroid(Polygon geom)
Finds a centroid for a polygon catching any exceptions resulting from generalization or other polygon irregularities.static double
getStyle2DSize(Style2D style)
protected static double
rollLatitude(double x)
protected static double
rollLongitude(double x)
static Point
sampleForInternalPoint(Polygon geom, Point centroid, PreparedGeometry pg, GeometryFactory gf, double stepSize, int numSamples)
Uses a sampling technique to obtain a central point that lies inside the specified polygon.static double
toMeters(double size, CoordinateReferenceSystem crs)
Method used by the OGC scale calculation to turn a given length in the specified CRS towards meters.static AffineTransform
worldToScreenTransform(ReferencedEnvelope mapExtent, Rectangle paintArea)
Sets up the affine transformstatic AffineTransform
worldToScreenTransform(Envelope mapExtent, Rectangle paintArea, CoordinateReferenceSystem destinationCrs)
This worldToScreenTransform method makes the assumption that the crs is in Lon,Lat or Lat,Lon.
-
-
-
Method Detail
-
worldToScreenTransform
public static AffineTransform worldToScreenTransform(ReferencedEnvelope mapExtent, Rectangle paintArea)
Sets up the affine transformNOTE It is worth to note that here we do not take into account the half a pixel translation stated by ogc for coverages bounds. One reason is that WMS 1.1.1 does not follow it!!!
- Parameters:
mapExtent
- the map extentpaintArea
- the size of the rendering output area- Returns:
- a transform that maps from real world coordinates to the screen
-
createMapEnvelope
public static Envelope createMapEnvelope(Rectangle paintArea, AffineTransform worldToScreen) throws NoninvertibleTransformException
Creates the map's bounding box in real world coordinates.- Parameters:
worldToScreen
- a transform which converts World coordinates to screen pixel coordinates. No assumptions are done on axis order as this is assumed to be pre-calculated. The affine transform may specify an rotation, in case the envelope will encompass the complete (rotated) world polygon.paintArea
- the size of the rendering output area- Returns:
- the envelope in world coordinates corresponding to the screen rectangle.
- Throws:
NoninvertibleTransformException
-
createMapEnvelope
public static ReferencedEnvelope createMapEnvelope(Rectangle paintArea, AffineTransform worldToScreen, CoordinateReferenceSystem crs) throws NoninvertibleTransformException
Creates the map's bounding box in real world coordinatesNOTE It is worth to note that here we do not take into account the half a pixel translation stated by ogc for coverages bounds. One reason is that WMS 1.1.1 does not follow it!!!
- Parameters:
worldToScreen
- a transform which converts World coordinates to screen pixel coordinates.paintArea
- the size of the rendering output area- Throws:
NoninvertibleTransformException
-
calculatePixelsPerMeterRatio
public static double calculatePixelsPerMeterRatio(double scaleDenominator, Map hints)
Calculates the pixels per meter ratio based on a scale denominator.- Parameters:
scaleDenominator
- The scale denominator value.hints
- The hints used in calculation. if "dpi" key is present, it uses it's Integer value as the dpi of the current device. if not it uses 90 that is the OGC default value.- Returns:
- The pixels per meter ratio for the given scale denominator.
-
calculateOGCScale
public static double calculateOGCScale(ReferencedEnvelope envelope, int imageWidth, Map hints)
This method performs the computation using the methods suggested by the OGC SLD specification, page 26.In GeoTools 12 this method started to take into account units of measure, if this is not desirable in your application you can set the system variable "org.geotoools.render.lite.scale.unitCompensation" to false.
-
toMeters
public static double toMeters(double size, CoordinateReferenceSystem crs)
Method used by the OGC scale calculation to turn a given length in the specified CRS towards meters.GeographicCRS uses
OGC_DEGREE_TO_METERS
for conversion of lat/lon measuresOtherwise the horizontal component of the CRS is assumed to have a uniform axis unit of measure providing the Unit used for conversion. To ignore unit disable
SCALE_UNIT_COMPENSATION
to for the unaltered size.- Returns:
- size adjusted for GeographicCRS or CRS units
-
calculateOGCScaleAffine
public static double calculateOGCScaleAffine(CoordinateReferenceSystem crs, AffineTransform worldToScreen, Map hints)
This method performs the computation using the methods suggested by the OGC SLD specification, page 26.- Parameters:
crs
- the coordinate reference system. Used to check if we are operating in degrees or meters.worldToScreen
- the transformation mapping world coordinates to screen coordinates. Might specify a rotation in addition to translation and scaling.
-
calculateScale
public static double calculateScale(ReferencedEnvelope envelope, int imageWidth, int imageHeight, Map<?,?> hints) throws TransformException, FactoryException
First searches the hints for the scale denominator hint otherwise calls#calculateScale(org.geotools.util.SoftValueHashMap.Reference, int, int, double)
. If the hints contains a DPI then that DPI is used otherwise 90 is used (the OGS default).- Throws:
TransformException
FactoryException
-
getDpi
public static double getDpi(Map hints)
Either gets a DPI from the hints, or return the OGC standard, stating that a pixel is 0.28 mm (the result is a non integer DPI...)- Returns:
- DPI as doubles, to avoid issues with integer trunking in scale computation expression
-
calculateScale
public static double calculateScale(ReferencedEnvelope envelope, int imageWidth, int imageHeight, double DPI) throws TransformException, FactoryException
Find the scale denominator of the map. Method: 1. find the diagonal distance (meters) 2. find the diagonal distance (pixels) 3. find the diagonal distance (meters) -- use DPI 4. calculate scale (#1/#2)NOTE: return the scale denominator not the actual scale (1/scale = denominator)
TODO: (SLD spec page 28): Since it is common to integrate the output of multiple servers into a single displayed result in the web-mapping environment, it is important that different map servers have consistent behaviour with respect to processing scales, so that all of the independent servers will select or deselect rules at the same scales. To insure consistent behaviour, scales relative to coordinate spaces must be handled consistently between map servers. For geographic coordinate systems, which use angular units, the angular coverage of a map should be converted to linear units for computation of scale by using the circumference of the Earth at the equator and by assuming perfectly square linear units. For linear coordinate systems, the size of the coordinate space should be used directly without compensating for distortions in it with respect to the shape of the real Earth.
NOTE: we are actually doing a a much more exact calculation, and accounting for non-square pixels (which are allowed in WMS) ADDITIONAL NOTE from simboss: I added soe minor fixes. See below.
- Parameters:
DPI
- screen dots per inch (OGC standard is 90)TODO should I take into account also the destination CRS? Otherwise I am just assuming that the final crs is lon,lat that is it maps lon to x (n raster space) and lat to y (in raster space).
- Throws:
TransformException
FactoryException
-
rollLongitude
protected static double rollLongitude(double x)
-
rollLatitude
protected static double rollLatitude(double x)
-
worldToScreenTransform
public static AffineTransform worldToScreenTransform(Envelope mapExtent, Rectangle paintArea, CoordinateReferenceSystem destinationCrs) throws TransformException
This worldToScreenTransform method makes the assumption that the crs is in Lon,Lat or Lat,Lon. If the provided envelope does not carry along a crs the assumption that the map extent is in the classic Lon,Lat form. In case the provided envelope is of type.Note that this method takes into account also the OGC standard with respect to the relation between pixels and sample.
- Parameters:
mapExtent
- The envelope of the map in lon,latpaintArea
- The area to paint as a rectangle- Throws:
TransformException
-
getCentroid
public static Geometry getCentroid(Geometry g)
Finds the centroid of the input geometry if input = point, line, polygon --> return a point that represents the centroid of that geom if input = geometry collection --> return a multipoint that represents the centoid of each sub-geom
-
getStyle2DSize
public static double getStyle2DSize(Style2D style)
-
getPolygonCentroid
public static Point getPolygonCentroid(Polygon geom)
Finds a centroid for a polygon catching any exceptions resulting from generalization or other polygon irregularities.- Parameters:
geom
- The polygon.- Returns:
- The polygon centroid, or null if it can't be found.
-
sampleForInternalPoint
public static Point sampleForInternalPoint(Polygon geom, Point centroid, PreparedGeometry pg, GeometryFactory gf, double stepSize, int numSamples)
Uses a sampling technique to obtain a central point that lies inside the specified polygon.Sampling occurs horizontally along the middle of the polygon obtained from the y coordinate of the polygon centroid.
- Parameters:
geom
- The polygon.centroid
- The centroid of the polygon, can be null in which case it will be computed fromgetPolygonCentroid(Polygon)
.pg
- The prepared version of geom, can be null in which case it will be computed on demand.gf
- The geometry factory, can be null in which case the polygons factory will be used.- Returns:
- A central point that lies inside of the polygon, or null if one could not be found.
-
-