import com.vividsolutions.jts.geom.MultiPoint; //导入依赖的package包/类
public static void assertEquals(Geometry s1, Geometry s2) {
    if(s1 instanceof LineString && s2 instanceof LineString) {
        assertEquals((LineString) s1, (LineString) s2);

    } else if (s1 instanceof Polygon && s2 instanceof Polygon) {
        assertEquals((Polygon) s1, (Polygon) s2);

    } else if (s1 instanceof MultiPoint && s2 instanceof MultiPoint) {
        Assert.assertEquals(s1, s2);

    } else if (s1 instanceof MultiPolygon && s2 instanceof MultiPolygon) {
        assertEquals((MultiPolygon) s1, (MultiPolygon) s2);

    } else if (s1 instanceof MultiLineString && s2 instanceof MultiLineString) {
        assertEquals((MultiLineString) s1, (MultiLineString) s2);

    } else {
        throw new RuntimeException("equality of shape types not supported [" + s1.getClass().getName() + " and " + s2.getClass().getName() + "]");
    }
}
 

import com.vividsolutions.jts.geom.MultiPoint; //导入依赖的package包/类
/**
 * Get the MVT type mapping for the provided JTS Geometry.
 *
 * @param geometry JTS Geometry to get MVT type for
 * @return MVT type for the given JTS Geometry, may return
 * {@link uk.os.vt.mvt.VectorTile.Tile.GeomType#UNKNOWN}
 */
public static VectorTile.Tile.GeomType toGeomType(Geometry geometry) {
  VectorTile.Tile.GeomType result = VectorTile.Tile.GeomType.UNKNOWN;

  if (geometry instanceof Point
      || geometry instanceof MultiPoint) {
    result = VectorTile.Tile.GeomType.POINT;

  } else if (geometry instanceof LineString
      || geometry instanceof MultiLineString) {
    result = VectorTile.Tile.GeomType.LINESTRING;

  } else if (geometry instanceof Polygon
      || geometry instanceof MultiPolygon) {
    result = VectorTile.Tile.GeomType.POLYGON;
  }

  return result;
}
 

import com.vividsolutions.jts.geom.MultiPoint; //导入依赖的package包/类
public boolean hasRepeatedPoint(Geometry g) {
    if (g.isEmpty()) {
        return false;
    }
    if (g instanceof Point) {
        return false;
    } else if (g instanceof MultiPoint) {
        return false;
    }
    // LineString also handles LinearRings
    else if (g instanceof LineString) {
        return this.hasRepeatedPoint(g.getCoordinates());
    } else if (g instanceof Polygon) {
        return this.hasRepeatedPoint((Polygon) g);
    } else if (g instanceof GeometryCollection) {
        return this.hasRepeatedPoint((GeometryCollection) g);
    } else {
        throw new UnsupportedOperationException(g.getClass().getName());
    }
}
 

import com.vividsolutions.jts.geom.MultiPoint; //导入依赖的package包/类
private boolean computeSimple(Geometry geom) {
    this.nonSimpleLocation = null;
    if (geom.isEmpty()) {
        return true;
    }
    if (geom instanceof LineString) {
        return this.isSimpleLinearGeometry(geom);
    }
    if (geom instanceof MultiLineString) {
        return this.isSimpleLinearGeometry(geom);
    }
    if (geom instanceof MultiPoint) {
        return this.isSimpleMultiPoint((MultiPoint) geom);
    }
    if (geom instanceof Polygonal) {
        return this.isSimplePolygonal(geom);
    }
    if (geom instanceof GeometryCollection) {
        return this.isSimpleGeometryCollection(geom);
    }
    // all other geometry types are simple by definition
    return true;
}
 

import com.vividsolutions.jts.geom.MultiPoint; //导入依赖的package包/类
private boolean isSimpleMultiPoint(MultiPoint mp) {
    if (mp.isEmpty()) {
        return true;
    }
    Set points = new TreeSet();
    for (int i = 0; i < mp.getNumGeometries(); i++) {
        Point pt = (Point) mp.getGeometryN(i);
        Coordinate p = pt.getCoordinate();
        if (points.contains(p)) {
            this.nonSimpleLocation = p;
            return false;
        }
        points.add(p);
    }
    return true;
}
 

import com.vividsolutions.jts.geom.MultiPoint; //导入依赖的package包/类
private void add(Geometry g) {
    if (g.isEmpty()) {
        return;
    }

    if (g instanceof Polygon) {
        this.addPolygon((Polygon) g);
    }
    // LineString also handles LinearRings
    else if (g instanceof LineString) {
        this.addLineString((LineString) g);
    } else if (g instanceof Point) {
        this.addPoint((Point) g);
    } else if (g instanceof MultiPoint) {
        this.addCollection((MultiPoint) g);
    } else if (g instanceof MultiLineString) {
        this.addCollection((MultiLineString) g);
    } else if (g instanceof MultiPolygon) {
        this.addCollection((MultiPolygon) g);
    } else if (g instanceof GeometryCollection) {
        this.addCollection((GeometryCollection) g);
    } else {
        throw new UnsupportedOperationException(g.getClass().getName());
    }
}
 

import com.vividsolutions.jts.geom.MultiPoint; //导入依赖的package包/类
private void write(Geometry geom, Writer writer, int level)
        throws IOException {
    this.isRootTag = true;
    if (geom instanceof Point) {
        this.writePoint((Point) geom, writer, level);
    } else if (geom instanceof LineString) {
        this.writeLineString((LineString) geom, writer, level);
    } else if (geom instanceof Polygon) {
        this.writePolygon((Polygon) geom, writer, level);
    } else if (geom instanceof MultiPoint) {
        this.writeMultiPoint((MultiPoint) geom, writer, level);
    } else if (geom instanceof MultiLineString) {
        this.writeMultiLineString((MultiLineString) geom, writer, level);
    } else if (geom instanceof MultiPolygon) {
        this.writeMultiPolygon((MultiPolygon) geom, writer, level);
    } else if (geom instanceof GeometryCollection) {
        this.writeGeometryCollection((GeometryCollection) geom, writer,
                this.startingIndentIndex);
    } else {
        throw new IllegalArgumentException("Unhandled geometry type: "
                + geom.getGeometryType());
    }
    writer.flush();
}
 

import com.vividsolutions.jts.geom.MultiPoint; //导入依赖的package包/类
private void writeMultiPoint(MultiPoint mp, Writer writer, int level)
        throws IOException {
    this.startLine(level, writer);
    this.startGeomTag(GMLConstants.GML_MULTI_POINT, mp, writer);

    for (int t = 0; t < mp.getNumGeometries(); t++) {
        this.startLine(level + 1, writer);
        this.startGeomTag(GMLConstants.GML_POINT_MEMBER, null, writer);

        this.writePoint((Point) mp.getGeometryN(t), writer, level + 2);

        this.startLine(level + 1, writer);
        this.endGeomTag(GMLConstants.GML_POINT_MEMBER, writer);
    }
    this.startLine(level, writer);
    this.endGeomTag(GMLConstants.GML_MULTI_POINT, writer);
}
 

import com.vividsolutions.jts.geom.MultiPoint; //导入依赖的package包/类
/**
 * 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) {
        this.writePoint((Point) geom, os);
    }
    // LinearRings will be written as LineStrings
    else if (geom instanceof LineString) {
        this.writeLineString((LineString) geom, os);
    } else if (geom instanceof Polygon) {
        this.writePolygon((Polygon) geom, os);
    } else if (geom instanceof MultiPoint) {
        this.writeGeometryCollection(WKBConstants.wkbMultiPoint,
                (MultiPoint) geom, os);
    } else if (geom instanceof MultiLineString) {
        this.writeGeometryCollection(WKBConstants.wkbMultiLineString,
                (MultiLineString) geom, os);
    } else if (geom instanceof MultiPolygon) {
        this.writeGeometryCollection(WKBConstants.wkbMultiPolygon,
                (MultiPolygon) geom, os);
    } else if (geom instanceof GeometryCollection) {
        this.writeGeometryCollection(WKBConstants.wkbGeometryCollection,
                (GeometryCollection) geom, os);
    } else {
        Assert.shouldNeverReachHere("Unknown Geometry type");
    }
}
 

import com.vividsolutions.jts.geom.MultiPoint; //导入依赖的package包/类
/**
 * Converts a <code>MultiPoint</code> to &lt;MultiPoint Text&gt; format, then
 * appends it to the writer.
 *
 * @param multiPoint the <code>MultiPoint</code> to process
 * @param writer the output writer to append to
 */
private void appendMultiPointText(MultiPoint multiPoint, int level, Writer writer)
        throws IOException {
    if (multiPoint.isEmpty()) {
        writer.write("EMPTY");
    } else {
        writer.write("(");
        for (int i = 0; i < multiPoint.getNumGeometries(); i++) {
            if (i > 0) {
                writer.write(", ");
                this.indentCoords(i, level + 1, writer);
            }
            writer.write("(");
            this.appendCoordinate(multiPoint.getGeometryN(i).getCoordinate(), writer);
            writer.write(")");
        }
        writer.write(")");
    }
}
 

import com.vividsolutions.jts.geom.MultiPoint; //导入依赖的package包/类
/**
 * @param type
 * @return the class of the given geometry type
 */
private static Class<? extends GM_Object> geometryType(Class<?> type) {
	if (type == null) {
		return GM_Object.class;
	}
	if (Point.class.isAssignableFrom(type)) {
		return GM_Point.class;
	}
	if (MultiPoint.class.isAssignableFrom(type)) {
		return GM_MultiPoint.class;
	}
	if (LineString.class.isAssignableFrom(type)) {
		return GM_LineString.class;
	}
	if (Polygon.class.isAssignableFrom(type)) {
		return GM_Polygon.class;
	}
	return GM_MultiSurface.class;
}
 

import com.vividsolutions.jts.geom.MultiPoint; //导入依赖的package包/类
/**
 * Traduit un type de géométrie JTS {@link Geometry} et renvoie le type de
 * géométrie GeOxygene {@link IGeometry} équivalent. TODO gérer tous les types
 * de géométrie.
 * @param geometryType type de géométrie JTS
 * @return type de géométrie GeOxygene équivalent
 */
public static Class<? extends IGeometry> toGeometryType(Class<?> geometryType) {
  if (LineString.class.equals(geometryType)) {
    return ILineString.class;
  }
  if (MultiLineString.class.equals(geometryType)) {
    return IMultiCurve.class;
  }
  if (Polygon.class.equals(geometryType)) {
    return IPolygon.class;
  }
  if (MultiPolygon.class.equals(geometryType)) {
    return IMultiSurface.class;
  }
  if (Point.class.equals(geometryType)) {
    return IPoint.class;
  }
  if (MultiPoint.class.equals(geometryType)) {
    return IMultiPoint.class;
  }
  return IGeometry.class;
}
 

import com.vividsolutions.jts.geom.MultiPoint; //导入依赖的package包/类
/**
 * Traduit un type de géométrie GeOxygene {@link IGeometry} et renvoie le type
 * de géométrie JTS {@link Geometry} équivalent. TODO gérer tous les types de
 * géométrie.
 * @param geometryType type de géométrie GeOxygene
 * @return type de géométrie JTS équivalent
 */
public static Class<? extends Geometry> toJTSGeometryType(
    Class<?> geometryType) {
  if (ILineString.class.isAssignableFrom(geometryType)) {
    return LineString.class;
  }
  if (IMultiCurve.class.isAssignableFrom(geometryType)) {
    return MultiLineString.class;
  }
  if (IPolygon.class.isAssignableFrom(geometryType)) {
    return Polygon.class;
  }
  if (IMultiSurface.class.isAssignableFrom(geometryType)) {
    return MultiPolygon.class;
  }
  if (IPoint.class.isAssignableFrom(geometryType)) {
    return Point.class;
  }
  if (IMultiPoint.class.isAssignableFrom(geometryType)) {
    return MultiPoint.class;
  }
  if (IAggregate.class.isAssignableFrom(geometryType)) {
    return GeometryCollection.class;
  }
  return Geometry.class;
}
 

import com.vividsolutions.jts.geom.MultiPoint; //导入依赖的package包/类
/**
 * 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);
}
 

import com.vividsolutions.jts.geom.MultiPoint; //导入依赖的package包/类
public void testMultiPoint()
{
	Geometry g = read("{\n" +
			"  \"type\": \"MultiPoint\",\n" +
			"  \"coordinates\": [[1,2],[2,4]]\n" +
			"}");
	assertTrue(g instanceof MultiPoint);
	MultiPoint m = (MultiPoint) g;
	assertEquals(2,m.getNumGeometries());
	Point p0 = (Point) m.getGeometryN(0);
	Point p1 = (Point) m.getGeometryN(1);
	assertEquals(1.0,p0.getX());
	assertEquals(2.0,p0.getY());
	assertEquals(2.0,p1.getX());
	assertEquals(4.0,p1.getY());
}
 

import com.vividsolutions.jts.geom.MultiPoint; //导入依赖的package包/类
static VectorTile.Tile.GeomType toGeomType(Geometry geometry) {
    if (geometry instanceof Point) {
        return VectorTile.Tile.GeomType.POINT;
    }
    if (geometry instanceof MultiPoint) {
        return VectorTile.Tile.GeomType.POINT;
    }
    if (geometry instanceof LineString) {
        return VectorTile.Tile.GeomType.LINESTRING;
    }
    if (geometry instanceof MultiLineString) {
        return VectorTile.Tile.GeomType.LINESTRING;
    }
    if (geometry instanceof Polygon) {
        return VectorTile.Tile.GeomType.POLYGON;
    }
    return VectorTile.Tile.GeomType.UNKNOWN;
}
 

import com.vividsolutions.jts.geom.MultiPoint; //导入依赖的package包/类
public String getGeometryType(final List<? extends IShape> agents) {
	String geomType = "";
	for (final IShape be : agents) {
		final IShape geom = be.getGeometry();
		if (geom != 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;
}
 

import com.vividsolutions.jts.geom.MultiPoint; //导入依赖的package包/类
/**
 * Instantiates a new voronoi partitioning.
 *
 * @param samples the sample list
 * @param partitions the partitions
 * @throws Exception the exception
 */
public VoronoiPartitioning(List<Envelope> samples, int partitions) throws Exception
{
	GeometryFactory fact = new GeometryFactory();
	ArrayList<Point> subSampleList=new ArrayList<Point>();
	MultiPoint mp;
	
	//Take a subsample accoring to the partitions
	for(int i=0;i<samples.size();i=i+samples.size()/partitions)
	{
		Envelope envelope = samples.get(i);
		Coordinate coordinate = new Coordinate((envelope.getMinX()+envelope.getMaxX())/2.0,(envelope.getMinY()+envelope.getMaxY())/2.0);
		subSampleList.add(fact.createPoint(coordinate));
	}

	mp=fact.createMultiPoint(subSampleList.toArray(new Point[subSampleList.size()]));
	VoronoiDiagramBuilder voronoiBuilder = new VoronoiDiagramBuilder();
	voronoiBuilder.setSites(mp);
	Geometry voronoiDiagram=voronoiBuilder.getDiagram(fact);
	for(int i=0;i<voronoiDiagram.getNumGeometries();i++)
	{
		Polygon poly=(Polygon)voronoiDiagram.getGeometryN(i);
		grids.add(poly.getEnvelopeInternal());
	}
	//grids.add(new EnvelopeWithGrid(boundary,grids.size()));
}
 

import com.vividsolutions.jts.geom.MultiPoint; //导入依赖的package包/类
public static boolean isValidGeometryData(List<Geometry> aData, Class aGeometryClass) {
    if (Point.class.isAssignableFrom(aGeometryClass)
            || LineString.class.isAssignableFrom(aGeometryClass)
            || Polygon.class.isAssignableFrom(aGeometryClass)) {
        return aData.size() == 1 && isValidGeometryDataSection(aData.get(0).getCoordinates(), aGeometryClass);
    } else if (MultiPoint.class.isAssignableFrom(aGeometryClass)
            || MultiLineString.class.isAssignableFrom(aGeometryClass)
            || MultiPolygon.class.isAssignableFrom(aGeometryClass)) {
        if (aData.size() >= 1) {
            for (int i = 0; i < aData.size(); i++) {
                if (!isValidGeometryDataSection(aData.get(i).getCoordinates(), aGeometryClass)) {
                    return false;
                }
            }
            return true;
        } else {
            return false;
        }
    } else {
        return false;
    }
}
 

import com.vividsolutions.jts.geom.MultiPoint; //导入依赖的package包/类
public static Geometry constructGeometry(Coordinate[] aCoordinates, Class aGeometryClass) {
    Geometry g = null;
    if (isValidGeometryDataSection(aCoordinates, aGeometryClass)) {
        if (Point.class.isAssignableFrom(aGeometryClass)) {
            g = gFactory.createPoint(aCoordinates[0]);
        } else if (LineString.class.isAssignableFrom(aGeometryClass)) {
            g = gFactory.createLineString(aCoordinates);
        } else if (Polygon.class.isAssignableFrom(aGeometryClass)) {
            g = gFactory.createPolygon(aCoordinates);
        } else if (MultiPoint.class.isAssignableFrom(aGeometryClass)) {
            g = gFactory.createMultiPoint(aCoordinates);
        }
        return g;
    }
    return null;
}