14 |
15 | [Maven reports](http://davidmoten.github.io/grumpy/project-reports.html) including [javadocs](http://davidmoten.github.io/grumpy/apidocs/index.html).
16 |
17 | Features
18 | ----------
19 | * Great circle navigation utilities in ```grumpy-core```
20 | * Map projection utilities in ```grumpy-projection```
21 | * WMS Server utilities in ```grumpy-ogc```
22 | * Create a lightweight WMS server (about 12MB war)
23 | * Supports BBOX parameters handled differently by WMS 1.1.1 and 1.3
24 | * Handles boundary discontinuities with ```Reducer``` and ```RendererUtil``` methods
25 | * War artifact to deploy Darkness layer as WMS service (```grumpy-app```)
26 |
27 | Serverless AWS implementation of grumpy with OpenLayers 6 and ArcGIS base layers:
28 |
29 | 
30 |
31 | Run demo locally
32 | ------------------
33 | ```
34 | git clone https://github.com/davidmoten/grumpy.git
35 | cd grumpy
36 | mvn clean install
37 | cd wms-demo
38 | mvn jetty:run
39 | ```
40 |
41 | Go to [http://localhost:8080](http://localhost:8080/wms-demo) with a browser.
42 |
43 | And at the map link you will see this:
44 |
45 | 
46 |
47 | This demonstrates a custom filled shape and some text that is placed with transparency over the position of Canberra on the map. Notice that the borders are great circle paths.
48 |
49 | Click in the Canberra box and you will see a demo of WMS GetFeatureInfo:
50 |
51 | 
52 |
53 | How is it all done? Easy!
54 |
55 | Getting started
56 | -------------------
57 | To make your own WMS service add this dependency to the pom.xml of your war project:
58 | ```xml
59 | 
127 |
128 | The bands correspond to the following twilight categories:
129 |
130 | * Civil (the lightest)
131 | * Nautical
132 | * Astronomical
133 | * Night (the darkest)
134 |
135 | The layer is visible in the demo.
136 |
137 | The ```grumpy-app``` artifact is a war artifact that can be deployed to a java servlet container (tomcat, glassfish, jetty, jboss, others) to offer a WMS service with the Darkness layer (and any other layers that get added to ```grumpy-ogc-layers```).
138 |
139 | Why Grumpy?
140 | ---------------
141 | The project name was chosen at random and is no hint at the disposition of the primary developer! I'm very happy to receive contributions on this project. Just raise an issue.
142 |
--------------------------------------------------------------------------------
/RELEASE_NOTES.md:
--------------------------------------------------------------------------------
1 | Release Notes
2 | ---------------
3 | ###Version 0.2 ([Maven Central](http://search.maven.org/#search%7Cga%7C1%7Cg%3A%22com.github.davidmoten%22))
4 | * many breaking changes
5 | * added builder for capabilities
6 | * added ```Reducer`` to abstract reductionist drawing of regions
7 | * refactored Darkness layer
8 | * added grumpy-app artifact to offer Darkness layer in a war
9 | * simplified Darkness layer
10 |
11 | ###Version 0.1 ([Maven Central](http://search.maven.org/#search%7Cga%7C1%7Cg%3A%22com.github.davidmoten%22))
12 | * initial release
13 |
--------------------------------------------------------------------------------
/generate-site.sh:
--------------------------------------------------------------------------------
1 | #!/bin/bash
2 | set -e
3 | mvn site
4 | mvn site:stage
5 | cd ../davidmoten.github.io
6 | git pull
7 | mkdir grumpy
8 | cp -r ../grumpy/target/staging/* grumpy/
9 | git add .
10 | git commit -am "update site reports"
11 | git push
12 |
--------------------------------------------------------------------------------
/grumpy-app/pom.xml:
--------------------------------------------------------------------------------
1 |
2 | " + entry.getKey() + "
").getBytes()); 166 | bos.write(entry.getValue().getBytes()); 167 | } 168 | bos.flush(); 169 | } 170 | 171 | } 172 | -------------------------------------------------------------------------------- /grumpy-ogc/src/main/java/com/github/davidmoten/grumpy/wms/WmsServletRequestProcessor.java: -------------------------------------------------------------------------------- 1 | package com.github.davidmoten.grumpy.wms; 2 | 3 | import java.io.IOException; 4 | import java.io.OutputStream; 5 | import java.text.DecimalFormat; 6 | import java.util.ArrayList; 7 | import java.util.List; 8 | 9 | import javax.servlet.ServletException; 10 | import javax.servlet.http.HttpServletRequest; 11 | import javax.servlet.http.HttpServletResponse; 12 | 13 | import org.slf4j.LoggerFactory; 14 | 15 | /** 16 | * Processes a WMS {@link HttpServletRequest} and returns a 17 | * {@link HttpServletResponse}. 18 | */ 19 | public class WmsServletRequestProcessor { 20 | 21 | private static org.slf4j.Logger log = LoggerFactory.getLogger(WmsServletRequestProcessor.class); 22 | 23 | private static final String REQUEST_GET_MAP = "GetMap"; 24 | private static final String PARAMETER_REQUEST = "REQUEST"; 25 | private static final Object REQUEST_GET_CAPABILITIES = "GetCapabilities"; 26 | private static final Object REQUEST_GET_FEATURE_INFO = "GetFeatureInfo"; 27 | 28 | private final CapabilitiesProvider capabilitiesProvider; 29 | 30 | private WmsRequestProcessor processor; 31 | 32 | /** 33 | * Constructor. 34 | * 35 | * @param capabilitiesProvider 36 | * @param layers 37 | * @param imageCache 38 | * @param imageWriter 39 | */ 40 | public WmsServletRequestProcessor(CapabilitiesProvider capabilitiesProvider, 41 | WmsRequestProcessor processor) { 42 | this.capabilitiesProvider = capabilitiesProvider; 43 | this.processor = processor; 44 | } 45 | 46 | public static Builder builder() { 47 | return new Builder(); 48 | } 49 | 50 | public static class Builder { 51 | 52 | private CapabilitiesProvider capabilitiesProvider = new CapabilitiesProviderEmpty(); 53 | private ImageCache imageCache = new ImageCache(); 54 | private Layers layers; 55 | private final LayersBuilder layersBuilder = LayersBuilder.builder(); 56 | private final List
23 | * Set {@code Projector.forceXY = false} before instantiating any Projector if
24 | * you don't want the system property "org.geotools.referencing.forceXY" to be
25 | * set to truen (it will happen on first instantiation of a Projector by
26 | * default).
27 | *
28 | * @author dxm
29 | *
30 | */
31 | public class Projector {
32 |
33 | private static final AtomicBoolean initialized = new AtomicBoolean(false);
34 | public static volatile boolean forceXY = true;
35 |
36 | private final ProjectorTarget target;
37 | private final ProjectorBounds bounds;
38 |
39 | private final MathTransform transform;
40 | private final GeometryFactory geometryFactory;
41 |
42 | public Projector(ProjectorBounds bounds, ProjectorTarget target) {
43 | // perform one time initialization in a thread safe way
44 | if (initialized.compareAndSet(false, true)) {
45 | if (forceXY)
46 | System.setProperty("org.geotools.referencing.forceXY", "true");
47 | }
48 | this.target = target;
49 | this.bounds = bounds;
50 | try {
51 | transform = CRS.findMathTransform(FeatureUtil.getCrs(FeatureUtil.EPSG_4326),
52 | FeatureUtil.getCrs(bounds.getSrs()));
53 |
54 | } catch (FactoryException e) {
55 | throw new RuntimeException(e);
56 | }
57 | geometryFactory = new GeometryFactory();
58 | }
59 |
60 | public ProjectorBounds getBounds() {
61 | return bounds;
62 | }
63 |
64 | public ProjectorTarget getTarget() {
65 | return target;
66 | }
67 |
68 | public org.locationtech.jts.geom.Point getGeometryPointInSrs(double lat, double lon) {
69 | Coordinate coordinate = new Coordinate(lon, lat);
70 | org.locationtech.jts.geom.Point point = geometryFactory.createPoint(coordinate);
71 | try {
72 | return (org.locationtech.jts.geom.Point) JTS.transform(point, transform);
73 | } catch (MismatchedDimensionException e) {
74 | throw new RuntimeException(e);
75 | } catch (TransformException e) {
76 | throw new RuntimeException(e);
77 | }
78 | }
79 |
80 | public org.locationtech.jts.geom.Point getGeometryPointInSrsRelativeTo(double lat,
81 | double lon, double relativeLat, double relativeLon, double relativeX, double relativeY) {
82 |
83 | double diffLon1 = lon - relativeLon;
84 | double diffLon2 = lon - relativeLon + 360;
85 | if (Math.abs(diffLon1) > Math.abs(diffLon2))
86 | lon = lon + 360;
87 | double sign = Math.signum(lon - relativeLon);
88 |
89 | org.locationtech.jts.geom.Point point = getGeometryPointInSrs(lat, lon);
90 | double periodAtLat = periodAtLat(lat);
91 | double x = point.getX();
92 | // makes the assumption that increasing lon = increasing X
93 | // which is probably valid for most common projections
94 | // TODO determine when invalid or handle
95 | if (sign >= 0) {
96 | while (x - periodAtLat >= relativeX)
97 | x -= periodAtLat;
98 | while (x < relativeX)
99 | x += periodAtLat;
100 | } else {
101 | while (x >= relativeX)
102 | x -= periodAtLat;
103 | while (x + periodAtLat < relativeX)
104 | x += periodAtLat;
105 | }
106 |
107 | return createPoint(x, point.getY());
108 | }
109 |
110 | public org.locationtech.jts.geom.Point createPoint(double x, double y) {
111 | return geometryFactory.createPoint(new Coordinate(x, y));
112 | }
113 |
114 | public double periodAtLat(double lat) {
115 | return getGeometryPointInSrs(lat, 180).getX() - getGeometryPointInSrs(lat, -180).getX();
116 | }
117 |
118 | public Point2D.Double getTargetPoint(org.locationtech.jts.geom.Point point) {
119 | double proportionX = (point.getX() - bounds.getMinX())
120 | / (bounds.getMaxX() - bounds.getMinX());
121 | double proportionY = (bounds.getMaxY() - point.getY())
122 | / (bounds.getMaxY() - bounds.getMinY());
123 | double x = proportionX * target.getWidth();
124 | double y = proportionY * target.getHeight();
125 | return new Point2D.Double(x, y);
126 | }
127 |
128 | public org.locationtech.jts.geom.Point getFirstXAfter(Projector projector, double lat,
129 | double lon, double x) {
130 | org.locationtech.jts.geom.Point point = projector.getGeometryPointInSrs(lat, lon);
131 | double x2 = point.getX();
132 | double periodX = periodAtLat(lat);
133 | while (x2 - periodX >= x)
134 | x2 -= periodX;
135 | while (x2 + periodX < x)
136 | x2 += periodX;
137 | return createPoint(x2, point.getY());
138 | }
139 |
140 | public Point toPoint(double lat, double lon) {
141 | Point2D point2D = toPoint2D(lat, lon);
142 | Point p = new Point();
143 | p.x = (int) Math.round(point2D.getX());
144 | p.y = (int) Math.round(point2D.getY());
145 | return p;
146 | }
147 |
148 | public Point2D.Double toPointInSrs(double lat, double lon) {
149 | org.locationtech.jts.geom.Point point = getGeometryPointInSrs(lat, lon);
150 | return new Point2D.Double(point.getX(), point.getY());
151 | }
152 |
153 | public Point2D.Double toPoint2D(double lat, double lon) {
154 | Coordinate coordinate = new Coordinate(lon, lat);
155 | org.locationtech.jts.geom.Point point = geometryFactory.createPoint(coordinate);
156 | try {
157 | point = (org.locationtech.jts.geom.Point) JTS.transform(point, transform);
158 |
159 | double proportionX;
160 | if (point.getX() > bounds.getMaxX() || point.getX() < bounds.getMinX()) {
161 | // assume the maxX occurs at longitude 180 (true for EPSG 3857
162 | // spherical mercator) but maybe not true for other projections?
163 | Coordinate c = new Coordinate(180, 0);
164 | org.locationtech.jts.geom.Point pt = (org.locationtech.jts.geom.Point) JTS
165 | .transform(geometryFactory.createPoint(c), transform);
166 | double maximumX = pt.getX();
167 | if (point.getX() > bounds.getMaxX())
168 | proportionX = (point.getX() - 2 * maximumX - bounds.getMinX())
169 | / (bounds.getMaxX() - bounds.getMinX());
170 | else
171 | proportionX = (point.getX() + 2 * maximumX - bounds.getMinX())
172 | / (bounds.getMaxX() - bounds.getMinX());
173 | } else {
174 | proportionX = (point.getX() - bounds.getMinX())
175 | / (bounds.getMaxX() - bounds.getMinX());
176 | }
177 | double proportionY = (bounds.getMaxY() - point.getY())
178 | / (bounds.getMaxY() - bounds.getMinY());
179 | Point2D.Double point2D = new Point2D.Double(proportionX * target.getWidth(),
180 | proportionY * target.getHeight());
181 | return point2D;
182 | } catch (MismatchedDimensionException e) {
183 | throw new RuntimeException(e);
184 | } catch (TransformException e) {
185 | throw new RuntimeException(e);
186 | }
187 | }
188 |
189 | public Position toPosition(double targetX, double targetY) {
190 | double proportionX = targetX / target.getWidth();
191 | double proportionY = targetY / target.getHeight();
192 | double x = proportionX * (bounds.getMaxX() - bounds.getMinX()) + bounds.getMinX();
193 | double y = bounds.getMaxY() - proportionY * (bounds.getMaxY() - bounds.getMinY());
194 | Coordinate coordinate = new Coordinate(x, y);
195 | org.locationtech.jts.geom.Point point = geometryFactory.createPoint(coordinate);
196 | try {
197 | point = (org.locationtech.jts.geom.Point) JTS.transform(point, transform.inverse());
198 | } catch (MismatchedDimensionException e) {
199 | throw new RuntimeException(e);
200 | } catch (TransformException e) {
201 | throw new RuntimeException(e);
202 | }
203 | return new Position(point.getY(), point.getX());
204 | }
205 |
206 | public Position toPositionFromSrs(double x, double y) {
207 | return FeatureUtil.convertToLatLon(x, y, bounds.getSrs());
208 | }
209 |
210 | @Override
211 | public String toString() {
212 | return "ProjectorImpl [target=" + target + ", bounds=" + bounds + "]";
213 | }
214 |
215 | }
216 |
--------------------------------------------------------------------------------
/grumpy-projection/src/main/java/com/github/davidmoten/grumpy/projection/ProjectorBounds.java:
--------------------------------------------------------------------------------
1 | package com.github.davidmoten.grumpy.projection;
2 |
3 | import java.util.ArrayList;
4 | import java.util.List;
5 |
6 | public class ProjectorBounds {
7 | private final double minX;
8 | private final double minY;
9 | private final double maxX;
10 | private final double maxY;
11 | private final String srs;
12 |
13 | public String getSrs() {
14 | return srs;
15 | }
16 |
17 | public ProjectorBounds(String srs, double minX, double minY, double maxX, double maxY) {
18 | this.minX = minX;
19 | this.minY = minY;
20 | this.maxX = maxX;
21 | this.maxY = maxY;
22 | this.srs = srs;
23 | }
24 |
25 | public double getMinX() {
26 | return minX;
27 | }
28 |
29 | public double getMinY() {
30 | return minY;
31 | }
32 |
33 | public double getMaxX() {
34 | return maxX;
35 | }
36 |
37 | public double getMaxY() {
38 | return maxY;
39 | }
40 |
41 | public double getSizeX() {
42 | return this.maxX - this.minX;
43 | }
44 |
45 | public double getSizeY() {
46 | return maxY - minY;
47 | }
48 |
49 | public List Canberra is the capital city of Australia. With a population of 381,488, it is Australia's largest inland city and the eighth-largest city overall.
18 | *
24 | *
25 | */
26 | public class NearBSpline implements Shape, Cloneable {
27 | /** holds the combination of curve and line segments */
28 | private GeneralPath path;
29 |
30 | /** the last segment added to the path */
31 | private Shape lastPart;
32 |
33 | /** the individual segments of the path */
34 | private Shape[] segments;
35 |
36 | /**
37 | * Creates a new, empty b-spline
38 | */
39 | public NearBSpline() {
40 | }
41 |
42 | /**
43 | * Creates a new b-spline with the given control points
44 | *
45 | * @param points
46 | * the control points for the curve
47 | */
48 | public NearBSpline(Point2D[] points) {
49 | setLine(points);
50 | }
51 |
52 | /**
53 | * Sets the curve using control points given in integer precision
54 | *
55 | * @param points
56 | * the control points for the curve
57 | */
58 | public void setLine(int... points) {
59 | double[] pd = new double[points.length];
60 | for (int i = 0; i < points.length; i++) {
61 | pd[i] = points[i];
62 | }
63 | setLine(pd);
64 | }
65 |
66 | /**
67 | * Sets the curve using control points given in double precision
68 | *
69 | * @param points
70 | * the control points for the curve
71 | */
72 | public void setLine(double... points) {
73 | path = new GeneralPath();
74 | path.moveTo((float) points[0], (float) points[1]);
75 | segments = new Shape[points.length / 2 - 1];
76 |
77 | for (int i = 2; i < points.length;) {
78 | switch (points.length - i) {
79 | case 2:
80 | lastPart = new Line2D.Float((float) path.getCurrentPoint().getX(), (float) path
81 | .getCurrentPoint().getY(), (float) points[i], (float) points[i + 1]);
82 | path.append(lastPart, true);
83 | segments[i / 2 - 1] = lastPart;
84 | i += 2;
85 | break;
86 | case 4:
87 | lastPart = new QuadCurve2D.Float((float) path.getCurrentPoint().getX(),
88 | (float) path.getCurrentPoint().getY(), (float) points[i],
89 | (float) points[i + 1], (float) points[i + 2], (float) points[i + 3]);
90 | path.append(lastPart, true);
91 | segments[i / 2 - 1] = lastPart;
92 | segments[i / 2] = lastPart;
93 | i += 4;
94 | break;
95 | case 6:
96 | lastPart = new CubicCurve2D.Double(path.getCurrentPoint().getX(), path
97 | .getCurrentPoint().getY(), points[i], points[i + 1], points[i + 2],
98 | points[i + 3], points[i + 4], points[i + 5]);
99 | path.append(lastPart, true);
100 | segments[i / 2 - 1] = lastPart;
101 | segments[i / 2] = lastPart;
102 | segments[i / 2 + 1] = lastPart;
103 | i += 6;
104 | break;
105 | default: // use two points and add one extra between 2nd and 3rd
106 | float x = (float) (points[i + 2] + points[i + 4]) / 2F;
107 | float y = (float) (points[i + 3] + points[i + 5]) / 2F;
108 |
109 | lastPart = new CubicCurve2D.Double(path.getCurrentPoint().getX(), path
110 | .getCurrentPoint().getY(), points[i], points[i + 1], points[i + 2],
111 | points[i + 3], x, y);
112 |
113 | path.append(lastPart, true);
114 | segments[i / 2 - 1] = lastPart;
115 | segments[i / 2] = lastPart;
116 |
117 | i += 4;
118 | }
119 | }
120 | }
121 |
122 | /**
123 | * Sets the curve using control points given as Point2D objects
124 | *
125 | * @param points
126 | * the control points for the curve
127 | */
128 | public void setLine(Point2D[] points) {
129 | double[] pd = new double[points.length * 2];
130 | for (int i = 0; i < points.length; i++) {
131 | Point2D p = points[i];
132 | pd[i * 2] = p.getX();
133 | pd[i * 2 + 1] = p.getY();
134 | }
135 | setLine(pd);
136 | }
137 |
138 | public Rectangle getBounds() {
139 | return getBounds2D().getBounds();
140 | }
141 |
142 | public Rectangle2D getBounds2D() {
143 | return path.getBounds2D();
144 | }
145 |
146 | public boolean contains(double x, double y) {
147 | return path.contains(x, y);
148 | }
149 |
150 | public boolean contains(Point2D p) {
151 | return path.contains(p);
152 | }
153 |
154 | public boolean intersects(double x, double y, double w, double h) {
155 | return path.intersects(x, y, w, h);
156 | }
157 |
158 | public boolean intersects(Rectangle2D r) {
159 | return path.intersects(r);
160 | }
161 |
162 | public boolean contains(double x, double y, double w, double h) {
163 | return path.contains(x, y, w, h);
164 | }
165 |
166 | public boolean contains(Rectangle2D r) {
167 | return path.contains(r);
168 | }
169 |
170 | public PathIterator getPathIterator(AffineTransform at) {
171 | return path.getPathIterator(at);
172 | }
173 |
174 | public PathIterator getPathIterator(AffineTransform at, double flatness) {
175 | return path.getPathIterator(at, flatness);
176 | }
177 |
178 | /**
179 | * Returns the last piece of this curve, which should be the most likely
180 | * thing to intercept with rectangles at the end.
181 | *
182 | * @return a Line2D, QuadCurve2D, or CubicCurve2D object
183 | */
184 | public Shape getLastPart() {
185 | return lastPart;
186 | }
187 |
188 | /**
189 | * Return the segment of the path that should be adjacent to the control
190 | * point at the given index.
191 | *
192 | * @param i
193 | * the index of the control point
194 | * @return the path segment adjacent to the control point (a Line2D,
195 | * QuadCurve2D, or CubicCurve2D object)
196 | */
197 | public Shape getSegment(int i) {
198 | return segments[i];
199 | }
200 |
201 | public GeneralPath getPath() {
202 | return path;
203 | }
204 | }
205 |
--------------------------------------------------------------------------------
/grumpy-projection/src/main/resources/epsg/EPSG_102100.txt:
--------------------------------------------------------------------------------
1 | PROJCS["WGS 84 / Pseudo-Mercator",
2 | GEOGCS["Popular Visualisation CRS",
3 | DATUM["Popular_Visualisation_Datum",
4 | SPHEROID["Popular Visualisation Sphere",6378137,0,AUTHORITY["EPSG","7059"]],
5 | TOWGS84[0,0,0,0,0,0,0],
6 | AUTHORITY["EPSG","6055"]],
7 | PRIMEM["Greenwich",0,AUTHORITY["EPSG","8901"]],
8 | UNIT["degree",0.01745329251994328,AUTHORITY["EPSG","9122"]],
9 | AUTHORITY["EPSG","4055"]],
10 | UNIT["metre",1,AUTHORITY["EPSG","9001"]],
11 | PROJECTION["Mercator_1SP"],
12 | PARAMETER["central_meridian",0],
13 | PARAMETER["scale_factor",1],
14 | PARAMETER["false_easting",0],
15 | PARAMETER["false_northing",0],
16 | AUTHORITY["EPSG","3785"],
17 | AXIS["X",EAST],
18 | AXIS["Y",NORTH]]
--------------------------------------------------------------------------------
/grumpy-projection/src/main/resources/epsg/EPSG_900913.txt:
--------------------------------------------------------------------------------
1 | PROJCS["WGS84 / Google Mercator",
2 | GEOGCS["WGS 84",
3 | DATUM["World Geodetic System 1984",
4 | SPHEROID["WGS 84", 6378137.0, 298.257223563, AUTHORITY["EPSG","7030"]],
5 | AUTHORITY["EPSG","6326"]],
6 | PRIMEM["Greenwich", 0.0, AUTHORITY["EPSG","8901"]],
7 | UNIT["degree", 0.017453292519943295],
8 | AXIS["Longitude", EAST],
9 | AXIS["Latitude", NORTH],
10 | AUTHORITY["EPSG","4326"]],
11 | PROJECTION["Mercator_1SP"],
12 | PARAMETER["semi_major", 6378137.0],
13 | PARAMETER["semi_minor", 6378137.0],
14 | PARAMETER["latitude_of_origin", 0.0],
15 | PARAMETER["central_meridian", 0.0],
16 | PARAMETER["scale_factor", 1.0],
17 | PARAMETER["false_easting", 0.0],
18 | PARAMETER["false_northing", 0.0],
19 | UNIT["m", 1.0],
20 | AXIS["x", EAST],
21 | AXIS["y", NORTH],
22 | AUTHORITY["EPSG","900913"]]
--------------------------------------------------------------------------------
/grumpy-projection/src/test/java/com/github/davidmoten/grumpy/ProjectorTest.java:
--------------------------------------------------------------------------------
1 | package com.github.davidmoten.grumpy;
2 |
3 | import com.github.davidmoten.grumpy.projection.Projector;
4 | import com.github.davidmoten.grumpy.projection.ProjectorBounds;
5 | import com.github.davidmoten.grumpy.projection.ProjectorTarget;
6 | import org.junit.Test;
7 | import org.locationtech.jts.geom.Point;
8 |
9 | import java.awt.geom.Point2D.Double;
10 |
11 | import static org.junit.Assert.assertEquals;
12 |
13 | public class ProjectorTest {
14 |
15 | private static final double PRECISION = 1E-7;
16 |
17 | @Test
18 | public void testTransformWrapping() {
19 | ProjectorTarget target = new ProjectorTarget(300, 200);
20 | ProjectorBounds bounds = new ProjectorBounds("EPSG:3857", 18924313.4349, -4865942.2795,
21 | -18924313.4349, -3503549.8435);
22 | Projector projector = new Projector(bounds, target);
23 | Point p = projector.getGeometryPointInSrs(-35, 140);
24 | Double point = projector.getTargetPoint(p);
25 | System.out.println("x1=" + p.getX() + " point=" + point);
26 | assertEquals(26.470588235578038, point.getX(), PRECISION);
27 | assertEquals(96.93701801560695, point.getY(), PRECISION);
28 | Point p2 = projector
29 | .getGeometryPointInSrsRelativeTo(-35, 141, -35, 140, p.getX(), p.getY());
30 | System.out.println("x2=" + p2.getX());
31 | assertEquals(1.5696048201851575E7, p2.getX(), PRECISION);
32 | double x3 = p.getX() - projector.periodAtLat(-35);
33 | Double point3 = projector.getTargetPoint(projector.createPoint(x3, p.getY()));
34 | System.out.println("x3=" + x3 + " point=" + point3);
35 | double x4 = p.getX() + projector.periodAtLat(-35);
36 | Double point4 = projector.getTargetPoint(projector.createPoint(x4, p.getY()));
37 | System.out.println("x4=" + x4 + " point=" + point4);
38 | }
39 |
40 | }
41 |
--------------------------------------------------------------------------------
/pom.xml:
--------------------------------------------------------------------------------
1 |
2 | "
102 | + "";
105 | else
106 | return "";
107 | }
108 |
109 | @Override
110 | public LayerFeatures getFeatures() {
111 | return features;
112 | }
113 |
114 | }
115 |
--------------------------------------------------------------------------------
/wms-demo/src/main/java/com/github/davidmoten/grumpy/wms/demo/FiddleLayer.java:
--------------------------------------------------------------------------------
1 | package com.github.davidmoten.grumpy.wms.demo;
2 |
3 | import static com.github.davidmoten.grumpy.core.Position.position;
4 | import static com.github.davidmoten.grumpy.wms.WmsUtil.getProjector;
5 |
6 | import java.awt.Color;
7 | import java.awt.Graphics2D;
8 | import java.awt.Point;
9 | import java.awt.Rectangle;
10 | import java.awt.geom.GeneralPath;
11 | import java.util.Date;
12 | import java.util.List;
13 |
14 | import com.github.davidmoten.grumpy.core.Position;
15 | import com.github.davidmoten.grumpy.function.Function;
16 | import com.github.davidmoten.grumpy.projection.Projector;
17 | import com.github.davidmoten.grumpy.wms.Layer;
18 | import com.github.davidmoten.grumpy.wms.LayerFeatures;
19 | import com.github.davidmoten.grumpy.wms.RendererUtil;
20 | import com.github.davidmoten.grumpy.wms.WmsRequest;
21 | import com.github.davidmoten.grumpy.wms.WmsUtil;
22 | import com.github.davidmoten.grumpy.wms.reduction.RectangleSampler;
23 | import com.github.davidmoten.grumpy.wms.reduction.RectangleSamplerCorners;
24 | import com.github.davidmoten.grumpy.wms.reduction.Reducer;
25 | import com.github.davidmoten.grumpy.wms.reduction.ValueRenderer;
26 |
27 | public class FiddleLayer implements Layer {
28 |
29 | private final LayerFeatures features;
30 |
31 | public FiddleLayer() {
32 | features = LayerFeatures.builder().name("Fiddle").crs("EPSG:4326").crs("EPSG:3857").build();
33 | }
34 |
35 | @Override
36 | public void render(Graphics2D g, WmsRequest request) {
37 | Position centre = position(35, -40);
38 | Projector projector = getProjector(request);
39 |
40 | int radiusKm = 8000;
41 |
42 | Function![](\"http://international.cit.edu.au/__data/assets/image/0006/27636/Canberra-Aerial-view-of-lake.jpg\")
"
104 | + "WMS Demo
3 |
4 |
5 |
9 |
10 |
--------------------------------------------------------------------------------
/wms-demo/src/main/webapp/js/base-layers-3857.js:
--------------------------------------------------------------------------------
1 | var map;
2 |
3 | function init() {
4 |
5 | ///////////////////////////////////////////
6 | // setup the base map with google layers
7 | ///////////////////////////////////////////
8 |
9 | map = new OpenLayers.Map('map', {
10 | projection: 'EPSG:3857',
11 | layers: [
12 | new OpenLayers.Layer.OSM( "OpenStreetMap"),
13 | new OpenLayers.Layer.Google(
14 | "Google Physical",
15 | {type: google.maps.MapTypeId.TERRAIN}
16 | ),
17 | new OpenLayers.Layer.Google(
18 | "Google Streets", // the default
19 | {numZoomLevels: 20}
20 | ),
21 | new OpenLayers.Layer.Google(
22 | "Google Hybrid",
23 | {type: google.maps.MapTypeId.HYBRID, numZoomLevels: 20}
24 | ),
25 | new OpenLayers.Layer.Google(
26 | "Google Satellite",
27 | {type: google.maps.MapTypeId.SATELLITE, numZoomLevels: 22}
28 | )
29 | ],
30 | center: new OpenLayers.LonLat(149.1,-35.3)
31 | // Google.v3 uses web mercator as projection, so we have to
32 | // transform our coordinates
33 | .transform('EPSG:4326', 'EPSG:3857'),
34 | zoom: 6,
35 | zoomMethod: null
36 | });
37 |
38 | map.addControl(new OpenLayers.Control.LayerSwitcher());
39 |
40 | addLayers(map);
41 | }
42 |
43 |
--------------------------------------------------------------------------------
/wms-demo/src/main/webapp/js/base-layers-4326.js:
--------------------------------------------------------------------------------
1 |
2 |
3 | function init(){
4 | var lon = 140;
5 | var lat = -35;
6 | var zoom = 5;
7 | var map = new OpenLayers.Map('map');
8 | var layer = new OpenLayers.Layer.WMS( "OpenLayers WMS",
9 | "http://vmap0.tiles.osgeo.org/wms/vmap0", {layers: 'basic'} );
10 | map.addLayer(layer);
11 | map.setCenter(new OpenLayers.LonLat(lon, lat), zoom);
12 | addLayers(map);
13 | }
--------------------------------------------------------------------------------
/wms-demo/src/main/webapp/js/layers.js:
--------------------------------------------------------------------------------
1 |
2 | function addLayers(map) {
3 |
4 |
5 | ///////////////////////////////////////////
6 | // setup the custom wms layer
7 | ///////////////////////////////////////////
8 |
9 | var wmsUrl = "wms";
10 |
11 | var layer1 = new OpenLayers.Layer.WMS( "Custom WMS Layer",
12 | wmsUrl,
13 | {layers: 'Custom',transparent: "true", format: "image/png",styles:"Standard"},
14 | {gutter:15,singleTile:true, visibility:true,opacity: 0.5,animationEnabled: false});
15 |
16 | map.addLayer(layer1);
17 |
18 | ///////////////////////////////////////////
19 | // add the Darkness layer
20 | ///////////////////////////////////////////
21 | var layer2 = new OpenLayers.Layer.WMS( "Darkness",
22 | wmsUrl,
23 | {layers: 'Darkness',transparent: "true", format: "image/png",styles:"Standard"},
24 | {gutter:15,singleTile:true, visibility:true,opacity: 0.5,animationEnabled: true});
25 |
26 | map.addLayer(layer2);
27 |
28 | ///////////////////////////////////////////
29 | // add the Fiddle layer
30 | ///////////////////////////////////////////
31 | var layer3 = new OpenLayers.Layer.WMS( "Fiddle",
32 | wmsUrl,
33 | {layers: 'Fiddle',transparent: "true", format: "image/png"},
34 | {gutter:15,singleTile:true, visibility:true,opacity: 0.5,animationEnabled: true});
35 |
36 | map.addLayer(layer3);
37 |
38 | ////////////////////////////////////////////////////
39 | // setup getFeatureInfo on click for all layers
40 | ////////////////////////////////////////////////////s
41 |
42 | var click = new OpenLayers.Control.WMSGetFeatureInfo({
43 | url: wmsUrl,
44 | title: 'Identify features by clicking',
45 | layers: [layer1],
46 | queryVisible: true
47 | })
48 | click.events.register("getfeatureinfo", this, showInfo);
49 | map.addControl(click);
50 | click.activate();
51 |
52 | }
53 |
54 | function showInfo(event) {
55 | map.addPopup(new OpenLayers.Popup.FramedCloud(
56 | "chicken",
57 | map.getLonLatFromPixel(event.xy),
58 | null,
59 | event.text,
60 | null,
61 | true
62 | ));
63 | };
64 |
--------------------------------------------------------------------------------
/wms-demo/src/main/webapp/map-3857.jsp:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 |
7 |