com.vividsolutions.jts.geom.MultiPolygon Java Examples

protected Geometry multiPolygonManagement(final Geometry geom) {
	if (geom instanceof MultiPolygon) {
		final Polygon gs[] = new Polygon[geom.getNumGeometries()];
		for (int i = 0; i < geom.getNumGeometries(); i++) {
			final Polygon p = (Polygon) geom.getGeometryN(i);
			final ICoordinates coords = GeometryUtils.getContourCoordinates(p);
			final LinearRing lr = GEOMETRY_FACTORY.createLinearRing(coords.toCoordinateArray());
			try (final Collector.AsList<LinearRing> holes = Collector.getList()) {
				for (int j = 0; j < p.getNumInteriorRing(); j++) {
					final LinearRing h = (LinearRing) p.getInteriorRingN(j);
					if (!hasNullElements(h.getCoordinates())) {
						holes.add(h);
					}
				}
				LinearRing[] stockArr = new LinearRing[holes.size()];
				stockArr = holes.items().toArray(stockArr);
				gs[i] = GEOMETRY_FACTORY.createPolygon(lr, stockArr);
			}
		}
		return GEOMETRY_FACTORY.createMultiPolygon(gs);
	}
	return geom;
}
 

/**
 * Convert a layer type to a geometry class.
 * 
 * @param layerType
 *            layer type
 * @return JTS class
 */
public Class<? extends com.vividsolutions.jts.geom.Geometry> toInternal(LayerType layerType) {
	switch (layerType) {
		case GEOMETRY:
			return com.vividsolutions.jts.geom.Geometry.class;
		case LINESTRING:
			return LineString.class;
		case MULTILINESTRING:
			return MultiLineString.class;
		case POINT:
			return Point.class;
		case MULTIPOINT:
			return MultiPoint.class;
		case POLYGON:
			return Polygon.class;
		case MULTIPOLYGON:
			return MultiPolygon.class;
		case RASTER:
			return null;
		default:
			throw new IllegalStateException("Don't know how to handle layer type " + layerType);
	}
}
 

/**
 * Convert a geometry class to a layer type.
 * 
 * @param geometryClass
 *            JTS geometry class
 * @return Geomajas layer type
 */
public LayerType toDto(Class<? extends com.vividsolutions.jts.geom.Geometry> geometryClass) {
	if (geometryClass == LineString.class) {
		return LayerType.LINESTRING;
	} else if (geometryClass == MultiLineString.class) {
		return LayerType.MULTILINESTRING;
	} else if (geometryClass == Point.class) {
		return LayerType.POINT;
	} else if (geometryClass == MultiPoint.class) {
		return LayerType.MULTIPOINT;
	} else if (geometryClass == Polygon.class) {
		return LayerType.POLYGON;
	} else if (geometryClass == MultiPolygon.class) {
		return LayerType.MULTIPOLYGON;
	} else {
		return LayerType.GEOMETRY;
	}
}
 

/**
 * Writes a {@link Geometry} to an {@link OutStream}.
 *
 * @param geom the geometry to write
 * @param os the out stream to write to
 * @throws IOException if an I/O error occurs
 */
public void write(Geometry geom, OutStream os) throws IOException
{
  if (geom instanceof Point)
    writePoint((Point) geom, os);
  // LinearRings will be written as LineStrings
  else if (geom instanceof LineString)
    writeLineString((LineString) geom, os);
  else if (geom instanceof Polygon)
    writePolygon((Polygon) geom, os);
  else if (geom instanceof MultiPoint)
    writeGeometryCollection(WKBConstants.wkbMultiPoint, 
        (MultiPoint) geom, os);
  else if (geom instanceof MultiLineString)
    writeGeometryCollection(WKBConstants.wkbMultiLineString,
        (MultiLineString) geom, os);
  else if (geom instanceof MultiPolygon)
    writeGeometryCollection(WKBConstants.wkbMultiPolygon,
        (MultiPolygon) geom, os);
  else if (geom instanceof GeometryCollection)
    writeGeometryCollection(WKBConstants.wkbGeometryCollection,
        (GeometryCollection) geom, os);
  else {
    Assert.shouldNeverReachHere("Unknown Geometry type");
  }
}
 

/**
 * Returns the GTYPE GEOM_TYPE code
 * corresponding to the geometry type.
 * 
 * @see OraGeom.GEOM_TYPE
 *
 * @param geom the geometry to compute the GEOM_TYPE for
 * @return geom type code, if known, or UNKNOWN
 */
static int geomType(Geometry geom) {
  if (geom == null) {
      return OraGeom.GEOM_TYPE.UNKNOWN_GEOMETRY; 
  } else if (geom instanceof Point) {
      return OraGeom.GEOM_TYPE.POINT;
  } else if (geom instanceof LineString) {
      return OraGeom.GEOM_TYPE.LINE;
  } else if (geom instanceof Polygon) {
      return OraGeom.GEOM_TYPE.POLYGON;
  } else if (geom instanceof MultiPoint) {
      return OraGeom.GEOM_TYPE.MULTIPOINT;
  } else if (geom instanceof MultiLineString) {
      return OraGeom.GEOM_TYPE.MULTILINE;
  } else if (geom instanceof MultiPolygon) {
      return OraGeom.GEOM_TYPE.MULTIPOLYGON;
  } else if (geom instanceof GeometryCollection) {
      return OraGeom.GEOM_TYPE.COLLECTION;
  }
  return OraGeom.GEOM_TYPE.UNKNOWN_GEOMETRY; 
}
 

/**
 * Create MultiPolygon as encoded by elemInfo.
 *
 * @param oraGeom SDO_GEOMETRY attributes being read
 * @param coords the coordinates of the entire geometry
 * @return MultiPolygon
 */
private MultiPolygon readMultiPolygon(OraGeom oraGeom)
{
  int nElem = oraGeom.numElements();
  List geoms = new ArrayList();
  for (int i = 0; i < nElem; i++) {
    int etype = oraGeom.eType(i);
    if ((etype == OraGeom.ETYPE.POLYGON) || (etype == OraGeom.ETYPE.POLYGON_EXTERIOR)) {
      Polygon poly = readPolygon(oraGeom, i);
      i += poly.getNumInteriorRing(); // skip interior rings
      geoms.add(poly);
    } 
    else { // not a Polygon - stop reading
    	break;
    }
  }
  MultiPolygon polys = geometryFactory.createMultiPolygon(GeometryFactory.toPolygonArray(geoms));
  return polys;
}
 

/**
	 * Round Trip test for a single MultiPolygon with lotsa points
	 * @throws ParserConfigurationException 
	 * @throws IOException 
	 * @throws SAXException 
	 */
	public void testSingleMultiPolygonManyPointsManyHolesRoundTrip() throws SAXException, IOException, ParserConfigurationException{

		PolygonGenerator pgc = new PolygonGenerator();
		pgc.setGeometryFactory(geometryFactory);
		pgc.setGenerationAlgorithm(PolygonGenerator.BOX);
		pgc.setNumberPoints(100);
		pgc.setNumberHoles(100);
		MultiGenerator pg = new MultiGenerator(pgc);
		pg.setBoundingBox(new Envelope(0,10,0,10));
		pg.setNumberGeometries(3);
		pg.setGeometryFactory(geometryFactory);
		
		MultiPolygon pt = (MultiPolygon) pg.create();
//		System.out.println((pt==null?"NULL":pt.toString()));

		checkRoundTrip(pt);
	}
 

/**
	 * Round Trip test for a single MultiPolygon with lotsa points
	 * @throws ParserConfigurationException 
	 * @throws IOException 
	 * @throws SAXException 
	 */
	public void testSingleMultiPolygonManyPointsHolesRoundTrip() throws SAXException, IOException, ParserConfigurationException{

		PolygonGenerator pgc = new PolygonGenerator();
		pgc.setGeometryFactory(geometryFactory);
		pgc.setGenerationAlgorithm(PolygonGenerator.BOX);
		pgc.setNumberPoints(1000);
		pgc.setNumberHoles(4);
		MultiGenerator pg = new MultiGenerator(pgc);
		pg.setBoundingBox(new Envelope(0,10,0,10));
		pg.setNumberGeometries(3);
		pg.setGeometryFactory(geometryFactory);
		
		MultiPolygon pt = (MultiPolygon) pg.create();
//		System.out.println((pt==null?"NULL":pt.toString()));

		checkRoundTrip(pt);
	}
 

/**
 * Round Trip test for a single MultiPolygon
 * @throws ParserConfigurationException 
 * @throws IOException 
 * @throws SAXException 
 */
public void testSingleMultiPolygonHolesRoundTrip() throws SAXException, IOException, ParserConfigurationException{

	PolygonGenerator pgc = new PolygonGenerator();
	pgc.setGeometryFactory(geometryFactory);
	pgc.setGenerationAlgorithm(PolygonGenerator.BOX);
	pgc.setNumberPoints(10);
	pgc.setNumberHoles(4);
	MultiGenerator pg = new MultiGenerator(pgc);
	pg.setBoundingBox(new Envelope(0,10,0,10));
	pg.setNumberGeometries(3);
	pg.setGeometryFactory(geometryFactory);
	
	MultiPolygon pt = (MultiPolygon) pg.create();

	checkRoundTrip(pt);
}
 

/**
 * Round Trip test for a single MultiPolygon with lotsa points
 * @throws ParserConfigurationException 
 * @throws IOException 
 * @throws SAXException 
 */
public void testSingleMultiPolygonManyPointsNoHoleRoundTrip() throws SAXException, IOException, ParserConfigurationException{

	PolygonGenerator pgc = new PolygonGenerator();
	pgc.setGeometryFactory(geometryFactory);
	pgc.setGenerationAlgorithm(PolygonGenerator.BOX);
	pgc.setNumberPoints(1000);
	MultiGenerator pg = new MultiGenerator(pgc);
	pg.setBoundingBox(new Envelope(0,10,0,10));
	pg.setNumberGeometries(3);
	pg.setGeometryFactory(geometryFactory);
	
	MultiPolygon pt = (MultiPolygon) pg.create();

	checkRoundTrip(pt);
}
 

/**
 *  Converts a <code>MultiPolygon</code> to &lt;MultiPolygon Text&gt; format,
 *  then appends it to the writer.
 *
 *@param  multiPolygon  the <code>MultiPolygon</code> to process
 *@param  writer        the output writer to append to
 */
private void appendMultiPolygonText(MultiPolygon multiPolygon, int level, Writer writer)
  throws IOException
{
  if (multiPolygon.isEmpty()) {
    writer.write("EMPTY");
  }
  else {
    int level2 = level;
    boolean doIndent = false;
    writer.write("(");
    for (int i = 0; i < multiPolygon.getNumGeometries(); i++) {
      if (i > 0) {
        writer.write(", ");
        level2 = level + 1;
        doIndent = true;
      }
      appendPolygonText((Polygon) multiPolygon.getGeometryN(i), level2, doIndent, writer);
    }
    writer.write(")");
  }
}
 

public static String getGeometryType(final List<? extends IShape> agents) {
	String geomType = "";
	for (final IShape be : agents) {
		final IShape geom = be.getGeometry();
		if (geom != null && geom.getInnerGeometry() != null) {
			geomType = geom.getInnerGeometry().getClass().getSimpleName();
			if (geom.getInnerGeometry().getNumGeometries() > 1) {
				if (geom.getInnerGeometry().getGeometryN(0).getClass() == Point.class) {
					geomType = MultiPoint.class.getSimpleName();
				} else if (geom.getInnerGeometry().getGeometryN(0).getClass() == LineString.class) {
					geomType = MultiLineString.class.getSimpleName();
				} else if (geom.getInnerGeometry().getGeometryN(0).getClass() == Polygon.class) {
					geomType = MultiPolygon.class.getSimpleName();
				}
				break;
			}
		}
	}
	if ("DynamicLineString".equals(geomType)) {
		geomType = LineString.class.getSimpleName();
	}
	return geomType;
}
 

@Test
public void testConversion() {
	// dto -> internal
	for (LayerType layerType : LayerType.values()) {
		if (layerType != LayerType.RASTER) {
			Class<? extends Geometry> c = converterService.toInternal(layerType);
			Assert.assertEquals(layerType.name(), c.getSimpleName().toUpperCase());
		} else {
			Assert.assertNull(converterService.toInternal(layerType));
		}
	}
	// internal -> dto
	Assert.assertEquals(LayerType.POINT, converterService.toDto(Point.class));
	Assert.assertEquals(LayerType.MULTIPOINT, converterService.toDto(MultiPoint.class));
	Assert.assertEquals(LayerType.LINESTRING, converterService.toDto(LineString.class));
	Assert.assertEquals(LayerType.MULTILINESTRING, converterService.toDto(MultiLineString.class));
	Assert.assertEquals(LayerType.POLYGON, converterService.toDto(Polygon.class));
	Assert.assertEquals(LayerType.MULTIPOLYGON, converterService.toDto(MultiPolygon.class));
	Assert.assertEquals(LayerType.GEOMETRY, converterService.toDto(Geometry.class));
}
 

/**
 * Add a placemark with a geometry object.The geometry can be a Point, a Line, a Polygon or any Multi-geometry.
 * Points will be represented by an icon and linear or surface objects will be drawn.
 *
 * @param label
 *            The title of the folder that will be created for this ShpRecord
 * @param beginDate
 *            Begining date of the timespan
 * @param endDate
 *            End date of the timespan
 * @param geom
 *            Geometry object to be drawn
 * @param height
 *            Height of the feature to draw. If > 0 the feature will be shown extruded to the given height
 *            (relative to the ground level). If <= 0 the feature will be drawn flat on the ground.
 */
public void addGeometry(final IScope scope, final String label, final String beginDate, final String endDate,
		final IShape shape, final String styleName, final double height) {
	final Placemark placemark = fold.createAndAddPlacemark().withStyleUrl("#" + styleName);
	placemark.setName(label);
	placemark.createAndSetTimeSpan().withBegin(beginDate).withEnd(endDate);

	final IShape shapeTM = Spatial.Projections.transform_CRS(scope, shape, "EPSG:4326");
	final Geometry geom = shapeTM.getInnerGeometry();

	if (geom instanceof Point) {
		addPoint(placemark, (Point) geom, height);
	} else if (geom instanceof LineString) {
		addLine(placemark, (LineString) geom, height);
	} else if (geom instanceof Polygon) {
		addPolygon(placemark, (Polygon) geom, height);
	} else if (geom instanceof MultiPoint) {
		addMultiPoint(placemark, (MultiPoint) geom, height);
	} else if (geom instanceof MultiLineString) {
		addMultiLine(placemark, (MultiLineString) geom, height);
	} else if (geom instanceof MultiPolygon) {
		addMultiPolygon(placemark, (MultiPolygon) geom, height);
	}
}
 

@Override
public GamaShape getExteriorRing(final IScope scope) {

	// WARNING Only in 2D
	Geometry result = getInnerGeometry();
	if (result instanceof Polygon) {
		result = ((Polygon) result).getExteriorRing();
	} else

	if (result instanceof MultiPolygon) {
		final MultiPolygon mp = (MultiPolygon) result;
		final LineString lines[] = new LineString[mp.getNumGeometries()];
		for (int i = 0; i < mp.getNumGeometries(); i++) {
			lines[i] = ((Polygon) mp.getGeometryN(i)).getExteriorRing();
		}
		result = GEOMETRY_FACTORY.createMultiLineString(lines);

	}
	return new GamaShape(result);
}
 

@Test
public void jtsEmptyToDto() throws GeomajasException {
	Geometry p = converter.toDto(createJtsEmpty(Point.class));
	Assert.assertEquals(Geometry.POINT, p.getGeometryType());
	Assert.assertTrue(GeometryService.isEmpty(p));
	Geometry ls = converter.toDto(createJtsEmpty(LineString.class));
	Assert.assertEquals(Geometry.LINE_STRING, ls.getGeometryType());
	Assert.assertTrue(GeometryService.isEmpty(ls));
	Geometry lr = converter.toDto(createJtsEmpty(LinearRing.class));
	Assert.assertEquals(Geometry.LINEAR_RING, lr.getGeometryType());
	Assert.assertTrue(GeometryService.isEmpty(lr));
	Geometry po = converter.toDto(createJtsEmpty(Polygon.class));
	Assert.assertEquals(Geometry.POLYGON, po.getGeometryType());
	Assert.assertTrue(GeometryService.isEmpty(po));
	assertThat(po.getGeometries()).isNull();
	Geometry mp = converter.toDto(createJtsEmpty(MultiPoint.class));
	Assert.assertEquals(Geometry.MULTI_POINT, mp.getGeometryType());
	Assert.assertTrue(GeometryService.isEmpty(mp));
	Geometry mpo = converter.toDto(createJtsEmpty(MultiPolygon.class));
	Assert.assertEquals(Geometry.MULTI_POLYGON, mpo.getGeometryType());
	Assert.assertTrue(GeometryService.isEmpty(mpo));
	Geometry mls = converter.toDto(createJtsEmpty(MultiLineString.class));
	Assert.assertEquals(Geometry.MULTI_LINE_STRING, mls.getGeometryType());
	Assert.assertTrue(GeometryService.isEmpty(mls));
}
 

@Test
public void dtoEmptyToJts() throws GeomajasException {
	// Test DTO Point to JTS:
	LineString ls = (LineString) converter.toInternal(createDtoEmpty(Geometry.LINE_STRING));
	Assert.assertTrue(ls.isEmpty());
	LinearRing lr = (LinearRing) converter.toInternal(createDtoEmpty(Geometry.LINEAR_RING));
	Assert.assertTrue(lr.isEmpty());
	MultiLineString mls = (MultiLineString) converter.toInternal(createDtoEmpty(Geometry.MULTI_LINE_STRING));
	Assert.assertTrue(mls.isEmpty());
	MultiPoint mp = (MultiPoint) converter.toInternal(createDtoEmpty(Geometry.MULTI_POINT));
	Assert.assertTrue(mp.isEmpty());
	MultiPolygon mpo = (MultiPolygon) converter.toInternal(createDtoEmpty(Geometry.MULTI_POLYGON));
	Assert.assertTrue(mpo.isEmpty());
	Point p = (Point) converter.toInternal(createDtoEmpty(Geometry.POINT));
	Assert.assertTrue(p.isEmpty());
	Polygon po = (Polygon) converter.toInternal(createDtoEmpty(Geometry.POLYGON));
	Assert.assertTrue(po.isEmpty());
}
 

public void testWriteMultiPolygon() throws Exception {
    Coordinate[] coordinates1 = { new Coordinate(10, 10, 0),
                                 new Coordinate(10, 20, 0),
                                 new Coordinate(20, 20, 0),
                                 new Coordinate(20, 15, 0),
                                 new Coordinate(10, 10, 0) };
    LinearRing linearRing1 = geometryFactory.createLinearRing(coordinates1);
    Polygon polygon1 = geometryFactory.createPolygon(linearRing1, new LinearRing[] { });
    Coordinate[] coordinates2 = { new Coordinate(60, 60, 0),
                                 new Coordinate(70, 70, 0),
                                 new Coordinate(80, 60, 0),
                                 new Coordinate(60, 60, 0) };
    LinearRing linearRing2 = geometryFactory.createLinearRing(coordinates2);
    Polygon polygon2 = geometryFactory.createPolygon(linearRing2, new LinearRing[] { });
    Polygon[] polygons = {polygon1, polygon2};
    MultiPolygon multiPolygon = geometryFactory.createMultiPolygon(polygons);
//    System.out.println("MULTIPOLYGON (((10 10, 10 20, 20 20, 20 15, 10 10)), ((60 60, 70 70, 80 60, 60 60)))");
//    System.out.println(writer.write(multiPolygon).toString());
    assertEquals("MULTIPOLYGON (((10 10, 10 20, 20 20, 20 15, 10 10)), ((60 60, 70 70, 80 60, 60 60)))", writer.write(multiPolygon).toString());
  }
 

private com.vividsolutions.jts.geom.Geometry createJtsEmpty(Class<?> clazz) {
	if (Point.class.equals(clazz)) {
		return factory.createPoint((com.vividsolutions.jts.geom.Coordinate) null);
	} else if (LineString.class.equals(clazz)) {
		return factory.createLineString((com.vividsolutions.jts.geom.Coordinate[]) null);
	} else if (LinearRing.class.equals(clazz)) {
		return factory.createLinearRing((com.vividsolutions.jts.geom.Coordinate[]) null);
	} else if (Polygon.class.equals(clazz)) {
		return factory.createPolygon(null, null);
	} else if (MultiPoint.class.equals(clazz)) {
		return factory.createMultiPoint((Point[]) null);
	} else if (MultiLineString.class.equals(clazz)) {
		return factory.createMultiLineString((LineString[]) null);
	} else if (MultiPolygon.class.equals(clazz)) {
		return factory.createMultiPolygon((Polygon[]) null);
	} else {
		return null;
	}
}
 

/**
 * Writes the body for a <code>MultiPolygon</code> object. MultiPolygons are
 * encoded into SVG path elements. This function writes the different
 * polygons in one d-attribute of an SVG path element, separated by an 'M'
 * character. (in other words, it calls the super.writeBody for each
 * polygon).
 *
 * @param o The <code>MultiPolygon</code> to be encoded.
 */
public void writeObject(Object o, GraphicsDocument document, boolean asChild) throws RenderException {
	document.writeElement("path", asChild);
	document.writeAttribute("fill-rule", "evenodd");
	document.writeAttributeStart("d");
	MultiPolygon mpoly = (MultiPolygon) o;
	for (int i = 0; i < mpoly.getNumGeometries(); i++) {
		Polygon poly = (Polygon) mpoly.getGeometryN(i);
		LineString shell = poly.getExteriorRing();
		int nHoles = poly.getNumInteriorRing();
		document.writeClosedPathContent(shell.getCoordinates());

		for (int j = 0; j < nHoles; j++) {
			document.writeClosedPathContent(poly.getInteriorRingN(j).getCoordinates());
		}
	}
	document.writeAttributeEnd();
}
 

/**
 * Writes the body for a <code>MultiPolygon</code> object. MultiPolygons are
 * encoded into SVG path elements. This function writes the different
 * polygons in one d-attribute of an SVG path element, separated by an 'M'
 * character. (in other words, it calls the super.writeBody for each
 * polygon).
 *
 * @param o The <code>MultiPolygon</code> to be encoded.
 */
public void writeObject(Object o, GraphicsDocument document, boolean asChild) throws RenderException {
	document.writeElement("vml:shape", asChild);
	document.writeAttribute("fill-rule", "evenodd");
	document.writeAttributeStart("path");
	MultiPolygon mpoly = (MultiPolygon) o;
	for (int i = 0; i < mpoly.getNumGeometries(); i++) {
		Polygon poly = (Polygon) mpoly.getGeometryN(i);
		LineString shell = poly.getExteriorRing();
		int nHoles = poly.getNumInteriorRing();
		document.writeClosedPathContent(shell.getCoordinates());

		for (int j = 0; j < nHoles; j++) {
			document.writeClosedPathContent(poly.getInteriorRingN(j).getCoordinates());
		}
	}
	document.writeAttributeEnd();
}
 

/**
 * Create a GeoTools geometric multi-polygon primitive from coordinates in
 * json.
 * 
 * @param json the json array of polygons
 * @return the multi-polygon
 */
public static MultiPolygon createMultiPolygonFromJson( JsonNode json )
{
    // Native array of polygons to pass to GeoFactory
    Polygon[] polygons = new Polygon[MapUtils.getNonEmptyNodes( json )];

    // Read all the polygons from the json array
    for ( int i = 0; i < json.size(); i++ )
    {
        JsonNode node = json.get( i );
        
        if ( MapUtils.nodeIsNonEmpty( node ) )
        {
            polygons[i] = createPolygonFromJson( node );
        }
    }

    // Create the multi-polygon from factory
    return FACTORY.createMultiPolygon( polygons );
}
 

/**
 * Initialise.
 */
private static void initialise()
{
    List<Class<?> > doubleList = new ArrayList<Class<?> >(Arrays.asList(Integer.class, Long.class, Double.class, Float.class));
    List<Class<?> > integerList = new ArrayList<Class<?> >(Arrays.asList(Integer.class, Long.class));
    List<Class<?> > stringList = new ArrayList<Class<?> >(Arrays.asList(String.class));
    List<Class<?> > geometryList = new ArrayList<Class<?> >(Arrays.asList(Point.class, LineString.class, Polygon.class, MultiPolygon.class, MultiPoint.class, MultiLineString.class));

    allowedClassTypeMap.put(String.class, stringList);
    allowedClassTypeMap.put(Double.class, doubleList);
    allowedClassTypeMap.put(Float.class, doubleList);
    allowedClassTypeMap.put(Integer.class, integerList);
    allowedClassTypeMap.put(Long.class, integerList);
    allowedClassTypeMap.put(Geometry.class, geometryList);

    List<Class<?> > objectList = new ArrayList<Class<?>>();
    objectList.addAll(doubleList);
    objectList.addAll(integerList);
    objectList.addAll(stringList);
    objectList.addAll(geometryList);
    allowedClassTypeMap.put(Object.class, objectList);
}
 

private Class getGeometryBinding(LayerType layerType) {
	switch (layerType) {
		case LINESTRING:
			return Geometry.class;
		case MULTILINESTRING:
			return MultiLineString.class;
		case MULTIPOINT:
			return MultiPoint.class;
		case MULTIPOLYGON:
			return MultiPolygon.class;
		case POINT:
			return Point.class;
		case POLYGON:
			return Polygon.class;
		default:
			return Geometry.class;
	}
}
 

private void initDefaultWriters() {
	registerWriter(Bbox.class, new BboxWriter());
	registerWriter(Point.class, new PointWriter());
	registerWriter(LineString.class, new LineStringWriter());
	registerWriter(LinearRing.class, new LineStringWriter());
	registerWriter(Polygon.class, new PolygonWriter());
	registerWriter(MultiPoint.class, new MultiPointWriter());
	registerWriter(MultiLineString.class, new MultiLineStringWriter());
	registerWriter(MultiPolygon.class, new MultiPolygonWriter());
	registerWriter(GeometryCollection.class, new GeometryCollectionWriter());
}
 

private void initDefaultWriters() {
	registerWriter(Point.class, new PointWriter());
	registerWriter(LineString.class, new LineStringWriter());
	registerWriter(LinearRing.class, new LineStringWriter());
	registerWriter(Polygon.class, new PolygonWriter());
	registerWriter(MultiPoint.class, new MultiPointWriter());
	registerWriter(MultiLineString.class, new MultiLineStringWriter());
	registerWriter(MultiPolygon.class, new MultiPolygonWriter());
	registerWriter(GeometryCollection.class, new GeometryCollectionWriter());
}
 

@Override
public Geometry getGeometry(Object feature) throws LayerException {
	Geometry geom = (Geometry) asFeature(feature).getDefaultGeometry();
	if (geom instanceof MultiLineString && vectorLayerInfo.getLayerType() == LayerType.LINESTRING) {
		return (Geometry) geom.getGeometryN(0).clone();
	} else if (geom instanceof MultiPolygon && vectorLayerInfo.getLayerType() == LayerType.POLYGON) {
		return (Geometry) geom.getGeometryN(0).clone();
	} else if (geom instanceof MultiPoint && vectorLayerInfo.getLayerType() == LayerType.POINT) {
		return (Geometry) geom.getGeometryN(0).clone();
	}
	return (Geometry) geom.clone();
}
 

private void drawFeature(PdfContext context, ClientMapInfo map, InternalFeature f) {
	FeatureStyleInfo style = f.getStyleInfo();

	// Color, transparency, dash
	Color fillColor = context.getColor(style.getFillColor(), style.getFillOpacity());
	Color strokeColor = context.getColor(style.getStrokeColor(), style.getStrokeOpacity());
	float[] dashArray = context.getDashArray(style.getDashArray());

	// check if the feature is selected
	if (selectedFeatures.contains(f.getId())) {
		if (f.getGeometry() instanceof MultiPolygon || f.getGeometry() instanceof Polygon) {
			style = mergeStyle(style, map.getPolygonSelectStyle());
			fillColor = context.getColor(style.getFillColor(), style.getFillOpacity());
			strokeColor = context.getColor(style.getStrokeColor(), style.getStrokeOpacity());
		} else if (f.getGeometry() instanceof MultiLineString || f.getGeometry() instanceof LineString) {
			style = mergeStyle(style, map.getLineSelectStyle());
			strokeColor = context.getColor(style.getStrokeColor(), style.getStrokeOpacity());
		} else if (f.getGeometry() instanceof MultiPoint || f.getGeometry() instanceof Point) {
			style = mergeStyle(style, map.getPointSelectStyle());
			strokeColor = context.getColor(style.getStrokeColor(), style.getStrokeOpacity());
		}
	}

	float lineWidth = style.getStrokeWidth();

	SymbolInfo symbol = null;
	if (f.getGeometry() instanceof MultiPoint || f.getGeometry() instanceof Point) {
		symbol = style.getSymbol();
	}
	// clone geometry
	Geometry geometry = (Geometry) f.getGeometry().clone();
	// transform to user space
	geometry.apply(new MapToUserFilter());
	// notify geometry change !!!
	geometry.geometryChanged();
	// now draw
	context.drawGeometry(geometry, symbol, fillColor, strokeColor, lineWidth, dashArray, getSize());
}
 

/**
 * Finish service initialization.
 *
 * @throws GeomajasException oops
 */
@PostConstruct
protected void postConstruct() throws GeomajasException {
	if (null != crsDefinitions) {
		for (CrsInfo crsInfo : crsDefinitions.values()) {
			try {
				CoordinateReferenceSystem crs = CRS.parseWKT(crsInfo.getCrsWkt());
				String code = crsInfo.getKey();
				crsCache.put(code, CrsFactory.getCrs(code, crs));
			} catch (FactoryException e) {
				throw new GeomajasException(e, ExceptionCode.CRS_DECODE_FAILURE_FOR_MAP, crsInfo.getKey());
			}
		}
	}
	if (null != crsTransformDefinitions) {
		for (CrsTransformInfo crsTransformInfo : crsTransformDefinitions.values()) {
			String key = getTransformKey(crsTransformInfo);
			transformCache.put(key, getCrsTransform(key, crsTransformInfo));
		}
	}
	GeometryFactory factory = new GeometryFactory();
	EMPTY_GEOMETRIES.put(Point.class, factory.createPoint((Coordinate) null));
	EMPTY_GEOMETRIES.put(LineString.class, factory.createLineString((Coordinate[]) null));
	EMPTY_GEOMETRIES.put(Polygon.class, factory.createPolygon(null, null));
	EMPTY_GEOMETRIES.put(MultiPoint.class, factory.createMultiPoint((Coordinate[]) null));
	EMPTY_GEOMETRIES.put(MultiLineString.class, factory.createMultiLineString((LineString[]) null)); // cast needed!
	EMPTY_GEOMETRIES.put(MultiPolygon.class, factory.createMultiPolygon((Polygon[]) null)); // cast needed!
	EMPTY_GEOMETRIES.put(Geometry.class, factory.createGeometryCollection(null));
}
 

public BufferValidator setBufferHolesExpected(final boolean bufferHolesExpected) {
  return addTest(new Test("Buffer Holes Test") {
    public void test() throws Exception {
      Assert.assertTrue(
        supplement(
          "Expected buffer "
            + (bufferHolesExpected ? "" : "not ")
            + "to have holes"),
        hasHoles(getBuffer()) == bufferHolesExpected);
    }
    private boolean hasHoles(Geometry buffer) {
      if (buffer.isEmpty()) {
        return false;
      }
      if (buffer instanceof Polygon) {
        return ((Polygon) buffer).getNumInteriorRing() > 0;
      }
      MultiPolygon multiPolygon = (MultiPolygon) buffer;
      for (int i = 0; i < multiPolygon.getNumGeometries(); i++) {
        if (hasHoles(multiPolygon.getGeometryN(i))) {
          return true;
        }
      }
      return false;
    }
  });
}