coords Area attribute
*
* @param coords coordinates to encode
*
* @throws IOException if an error occurs during encoding
*/
protected void writePathContent(Coordinate[] coords)
throws IOException {
StringBuffer buf=new StringBuffer();
int nCoords = coords.length;
for(int i=0;i0)
write(buf.substring(1));
}
/**
* Simplifies a geometry to exclude duplicated points. When translating from world
* to screen coordinates it's possible that many world points collapse to a single screen point.
* Those colliding points are simplified to a single point.
* @param geom
* @return
*/
Geometry decimate(Geometry geom) {
DefaultMathTransformFactory f= new DefaultMathTransformFactory();
MathTransform xform=null;
try {
xform = f.createAffineTransform(new GeneralMatrix(worldToScreen.createInverse()));
Decimator decimator=new Decimator(xform,mapArea);
geom=decimator.decimate(geom);
} catch (FactoryException e1) {
// TODO Auto-generated catch block
e1.printStackTrace();
} catch (NoninvertibleTransformException e1) {
// TODO Auto-generated catch block
e1.printStackTrace();
}
catch (Exception e1) {
// TODO Auto-generated catch block
e1.printStackTrace();
}
return geom;
}
}
/**
* FeatureWriter for point geometry features.
* Currently supports circle WellKnownName Marks.
*/
private class PointWriter extends HTMLImageMapFeatureWriter {
// encodes as a circle shape?
boolean asCircle=true;
// encodes as a different shape? (currently not supported--> empty rendering)
String symbol=null;
// radius of the circle
double size=2;
/**
* Creates a new PointWriter object.
*/
public PointWriter() {
}
/**
* The shape for points is a circle.
*/
protected String getShape() throws IOException {
return "circle";
}
/**
* Uses the supplied style to define point rendering.
* Currently it gets WellKnownName from a Mark (circle is the only value correctly rendered by now).
* It also uses the Size parameter to define circle radius.
*/
protected void processSymbolizer(Feature ft, Rule rule,Symbolizer symbolizer) throws IOException{
super.processSymbolizer(ft, rule,symbolizer);
if(symbolizer instanceof PointSymbolizer) {
Mark mark=SLD.mark((PointSymbolizer)symbolizer);
if(mark!=null) {
size=SLD.size(mark);
asCircle=SLD.wellKnownName(mark).toLowerCase().equals("circle");
if(!asCircle)
symbol=SLD.wellKnownName(mark).toLowerCase();
}
}
}
/**
* Actually encodes the point.
*
* @param geom point to encode
*
* @throws IOException if an error occures during encoding
*/
protected void writeGeometry(Geometry geom) throws IOException {
Point p = (Point) geom;
if(asCircle) {
write(getPoint(p.getCoordinate())+","+(int)Math.round(size));
} else{
//TODO: manage different shapes
}
}
}
/**
* FeatureWriter for multipoint geometry features.
*/
private class MultiPointWriter extends PointWriter {
/**
* Creates a new MultiPointWriter object.
*/
public MultiPointWriter() {
}
/**
* Uses writeMultiFeature.
*/
protected void writeFeature(Feature ft,Style style,FeatureTypeStyle[] fts) throws IOException {
writeMultiFeature(ft, style, fts);
}
}
/**
* FeatureWriter for LineString geometry features.
* A buffer is applied to the linear geometry to transform it to a Polygon.
* The result polygon is then encoded.
* @author Mauro Bartolomeoli
*
*/
private class LineStringWriter extends HTMLImageMapFeatureWriter {
// default buffer size (in screen coordinates)
int buffer=2;
/**
* Creates a new LineStringWriter object.
*/
public LineStringWriter() {
}
/**
* The shape for lines is a poly.
*/
protected String getShape() throws IOException {
return "poly";
}
/**
* Uses the supplied style to define line rendering.
* Currently it gets stroke-width to define the buffer around the linestring.
*/
protected void processSymbolizer(Feature ft, Rule rule,Symbolizer symbolizer) throws IOException{
super.processSymbolizer(ft, rule,symbolizer);
if(symbolizer instanceof LineSymbolizer) {
buffer=SLD.width((LineSymbolizer)symbolizer);
}
}
/**
* Actually encodes the linestring.
*
* @param geom line to encode
*
* @throws IOException if an error occures during encoding
*/
protected void writeGeometry(Geometry geom) throws IOException {
LineString l = (LineString) geom;
try {
// transform buffer dimension to world coordinates
double bufferMultiplier=worldToScreen.createInverse().getScaleX();
// gets buffered linestring
Geometry buffered=l.buffer(buffer*bufferMultiplier);
if(buffered instanceof Polygon) {
Polygon poly=(Polygon)decimate(buffered);
LineString shell = poly.getExteriorRing();
writePathContent(shell.getCoordinates());
} else {
//TODO: what kind of geometry can a buffer operation
// return?
}
} catch (NoninvertibleTransformException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
/**
* FeatureWriter for multiline geometry features.
*/
private class MultiLineStringWriter extends LineStringWriter {
/**
* Creates a new MultiLineStringWriter object.
*/
public MultiLineStringWriter() {
}
/**
* Uses writeMultiFeature.
*/
protected void writeFeature(Feature ft,Style style,FeatureTypeStyle[] fts) throws IOException {
writeMultiFeature(ft, style, fts);
}
}
/**
* FeatureWriter for Polygon geometry features.
*/
private class PolygonWriter extends HTMLImageMapFeatureWriter {
/**
* Creates a new PolygonWriter object.
*/
public PolygonWriter() {
}
/**
* The shape for polygons is a poly.
*/
protected String getShape() throws IOException {
return "poly";
}
/**
* Actually encodes the polygon.
*
* @param geom the polygon to encode
*
* @throws IOException if an error occures during encoding
*/
protected void writeGeometry(Geometry geom) throws IOException {
Polygon poly = (Polygon) decimate(geom);
LineString shell = poly.getExteriorRing();
writePathContent(shell.getCoordinates());
//TODO: polygons with holes?
}
}
/**
* FeatureWriter for multipolygon geometry features.
*/
private class MultiPolygonWriter extends PolygonWriter {
/**
* Creates a new MultiPolygonWriter object.
*/
public MultiPolygonWriter() {
}
/**
* Uses writeMultiFeature.
*/
protected void writeFeature(Feature ft,Style style,FeatureTypeStyle[] fts) throws IOException {
writeMultiFeature(ft, style, fts);
}
}
/**
* FeatureWriter for multipolygon geometry features.
*/
private class GeometryCollectionWriter extends HTMLImageMapFeatureWriter {
HTMLImageMapFeatureWriter delegateWriter=null;
/**
* Creates a new MultiPolygonWriter object.
*/
public GeometryCollectionWriter() {
}
/**
* Encodes the GeometryCollection.
*
* The encoding is accomplished through many phases:
* 1) reset writer state
* 2) loops for all the geometries, with the following phases for every single geometry.
* a) process supplied style
* b) start feature encoding
* c) pre geometry encoding
* d) actual geometry encoding
* e) post geometry encoding
* f) end feature encoding
* A delegate is used for many of these phases. The delegate is a specific FeatureWriter for the
* single geometry, during the loop.
* @param ft feature to encode
* @param style style to use for the encoding
* @param fts "cached" ftss matching the FeatureType of the feature
* @throws IOException if an error occurs during encoding
*/
protected void writeFeature(Feature ft,Style style,FeatureTypeStyle[] fts) throws IOException {
reset(ft);
GeometryCollection geomCollection = (GeometryCollection) ft.getDefaultGeometry();
for (int i = 0; i < geomCollection.getNumGeometries(); i++) {
Geometry geom=geomCollection.getGeometryN(i);
Class gtype = geom.getClass();
// retrieves the right feature writer (based on the current geometry type)
delegateWriter = (HTMLImageMapFeatureWriter) writers.get(gtype);
if(processStyle(ft,style,fts)) {
startElement(ft,"."+i);
startGeometry(geom);
writeGeometry(geom);
endGeometry(geom);
endElement(ft);
}
}
}
protected String getShape() throws IOException {
return delegateWriter.getShape();
}
/**
* Analyze the supplied style and process any matching rule.
*
* @param ft feature to which the style is going to be applied
* @param style style to process
* @param ftsList cached fts matching the feature
* @return true if the style filters "accept" the feature
* @throws IOException if an error occurs during the process
*/
protected boolean processStyle(Feature ft,Style style,FeatureTypeStyle[] ftsList)
throws IOException {
if(delegateWriter.processStyle(ft, style, ftsList)) {
Iterator iter=delegateWriter.extraAttributes.keySet().iterator();
while(iter.hasNext()) {
String attrName=(String)iter.next();
extraAttributes.put(attrName,delegateWriter.extraAttributes.get(attrName));
}
return true;
} else
return false;
}
/**
* Actually write the geometry (through the delegate).
*/
protected void writeGeometry(Geometry geom) throws IOException {
delegateWriter.writeGeometry(geom);
}
}
}