import com.spatial4j.core.shape.jts.JtsGeometry; //导入依赖的package包/类
@Override
public ODocument toDoc(JtsGeometry shape) {

  ODocument doc = new ODocument(getName());
  MultiPolygon multiPolygon = (MultiPolygon) shape.getGeom();
  List<List<List<List<Double>>>> polyCoordinates = new ArrayList<List<List<List<Double>>>>();
  int n = multiPolygon.getNumGeometries();

  for (int i = 0; i < n; i++) {
    Geometry geom = multiPolygon.getGeometryN(i);
    polyCoordinates.add(coordinatesFromPolygon((Polygon) geom));
  }

  doc.field(COORDINATES, polyCoordinates);
  return doc;
}
 

import com.spatial4j.core.shape.jts.JtsGeometry; //导入依赖的package包/类
protected JtsGeometry createMultiPolygon(ShapeCollection<Shape> geometries) {

    Polygon[] polygons = new Polygon[geometries.size()];

    int i = 0;

    for (Shape geometry : geometries) {
      if (geometry instanceof JtsGeometry) {
        polygons[i] = (Polygon) ((JtsGeometry) geometry).getGeom();
      } else {
        Rectangle rectangle = (Rectangle) geometry;
        Geometry geometryFrom = SPATIAL_CONTEXT.getGeometryFrom(rectangle);
        polygons[i] = (Polygon) geometryFrom;
      }

      i++;
    }

    MultiPolygon multiPolygon = GEOMETRY_FACTORY.createMultiPolygon(polygons);

    return SPATIAL_CONTEXT.makeShape(multiPolygon);
  }
 

import com.spatial4j.core.shape.jts.JtsGeometry; //导入依赖的package包/类
@Override
public Mapper parse(ParseContext context) throws IOException {
    try {
        Shape shape = context.parseExternalValue(Shape.class);
        if (shape == null) {
            ShapeBuilder shapeBuilder = ShapeBuilder.parse(context.parser(), this);
            if (shapeBuilder == null) {
                return null;
            }
            shape = shapeBuilder.build();
        }
        if (fieldType().pointsOnly() && !(shape instanceof Point)) {
            throw new MapperParsingException("[{" + fieldType().names().fullName() + "}] is configured for points only but a " +
                    ((shape instanceof JtsGeometry) ? ((JtsGeometry)shape).getGeom().getGeometryType() : shape.getClass()) + " was found");
        }
        Field[] fields = fieldType().defaultStrategy().createIndexableFields(shape);
        if (fields == null || fields.length == 0) {
            return null;
        }
        for (Field field : fields) {
            if (!customBoost()) {
                field.setBoost(fieldType().boost());
            }
            context.doc().add(field);
        }
    } catch (Exception e) {
        throw new MapperParsingException("failed to parse [" + fieldType().names().fullName() + "]", e);
    }
    return null;
}
 

import com.spatial4j.core.shape.jts.JtsGeometry; //导入依赖的package包/类
@Override
public JtsGeometry fromDoc(ODocument document) {
  validate(document);
  List<List<List<List<Number>>>> coordinates = document.field("coordinates");

  Polygon[] polygons = new Polygon[coordinates.size()];
  int i = 0;
  for (List<List<List<Number>>> coordinate : coordinates) {
    polygons[i] = createPolygon(coordinate);
    i++;
  }
  return toShape(GEOMETRY_FACTORY.createMultiPolygon(polygons));
}
 

import com.spatial4j.core.shape.jts.JtsGeometry; //导入依赖的package包/类
@Override
public JtsGeometry fromDoc(ODocument document) {
  validate(document);
  List<List<Number>> coordinates = document.field(COORDINATES);
  Coordinate[] coords = new Coordinate[coordinates.size()];
  int i = 0;
  for (List<Number> coordinate : coordinates) {
    coords[i] = new Coordinate(coordinate.get(0).doubleValue(), coordinate.get(1).doubleValue());
    i++;
  }
  return toShape(GEOMETRY_FACTORY.createMultiPoint(coords));
}
 

import com.spatial4j.core.shape.jts.JtsGeometry; //导入依赖的package包/类
@Override
public ODocument toDoc(final JtsGeometry shape) {
  final MultiPoint geom = (MultiPoint) shape.getGeom();

  ODocument doc = new ODocument(getName());
  doc.field(COORDINATES, new ArrayList<List<Double>>() {
    {
      Coordinate[] coordinates = geom.getCoordinates();
      for (Coordinate coordinate : coordinates) {
        add(Arrays.asList(coordinate.x, coordinate.y));
      }
    }
  });
  return doc;
}
 

import com.spatial4j.core.shape.jts.JtsGeometry; //导入依赖的package包/类
private boolean isLineString(Shape shape) {
  if (shape instanceof JtsGeometry) {
    Geometry geom = ((JtsGeometry) shape).getGeom();
    return geom instanceof LineString;
  }
  return false;
}
 

import com.spatial4j.core.shape.jts.JtsGeometry; //导入依赖的package包/类
protected boolean isPolygon(Shape shape) {

    if (shape instanceof JtsGeometry) {
      Geometry geom = ((JtsGeometry) shape).getGeom();
      return geom instanceof Polygon;
    }
    if (shape instanceof Rectangle) {
      return true;
    }
    return false;
  }
 

import com.spatial4j.core.shape.jts.JtsGeometry; //导入依赖的package包/类
@Override
public JtsGeometry fromDoc(ODocument document) {

  validate(document);
  List<List<Number>> coordinates = document.field(COORDINATES);

  Coordinate[] coords = new Coordinate[coordinates.size()];
  int i = 0;
  for (List<Number> coordinate : coordinates) {
    coords[i] = new Coordinate(coordinate.get(0).doubleValue(), coordinate.get(1).doubleValue());
    i++;
  }
  return toShape(GEOMETRY_FACTORY.createLineString(coords));
}
 

import com.spatial4j.core.shape.jts.JtsGeometry; //导入依赖的package包/类
@Override
public ODocument toDoc(JtsGeometry shape) {
  ODocument doc = new ODocument(getName());
  LineString lineString = (LineString) shape.getGeom();
  doc.field(COORDINATES, coordinatesFromLineString(lineString));
  return doc;
}
 

import com.spatial4j.core.shape.jts.JtsGeometry; //导入依赖的package包/类
@Override
public JtsGeometry fromDoc(ODocument document) {
  validate(document);
  List<List<List<Number>>> coordinates = document.field(COORDINATES);
  LineString[] multiLine = new LineString[coordinates.size()];
  int j = 0;
  for (List<List<Number>> coordinate : coordinates) {
    multiLine[j] = createLineString(coordinate);
    j++;
  }
  return toShape(GEOMETRY_FACTORY.createMultiLineString(multiLine));
}
 

import com.spatial4j.core.shape.jts.JtsGeometry; //导入依赖的package包/类
@Override
public ODocument toDoc(JtsGeometry shape) {
  final MultiLineString geom = (MultiLineString) shape.getGeom();

  List<List<List<Double>>> coordinates = new ArrayList<List<List<Double>>>();
  ODocument doc = new ODocument(getName());
  for (int i = 0; i < geom.getNumGeometries(); i++) {
    final LineString lineString = (LineString) geom.getGeometryN(i);
    coordinates.add(coordinatesFromLineString(lineString));
  }

  doc.field(COORDINATES, coordinates);
  return doc;
}
 

import com.spatial4j.core.shape.jts.JtsGeometry; //导入依赖的package包/类
@Override
public JtsGeometry fromDoc(ODocument document) {
  validate(document);
  List<List<List<Number>>> coordinates = document.field("coordinates");

  return toShape(createPolygon(coordinates));
}
 

import com.spatial4j.core.shape.jts.JtsGeometry; //导入依赖的package包/类
@Override
public ODocument toDoc(JtsGeometry shape) {

  ODocument doc = new ODocument(getName());
  Polygon polygon = (Polygon) shape.getGeom();
  List<List<List<Double>>> polyCoordinates = coordinatesFromPolygon(polygon);
  doc.field(COORDINATES, polyCoordinates);
  return doc;
}
 

import com.spatial4j.core.shape.jts.JtsGeometry; //导入依赖的package包/类
@Override
public ODocument toDoc(Shape shape) {

  // TODO REFACTOR
  ODocument doc = null;
  if (Point.class.isAssignableFrom(shape.getClass())) {
    doc = factories.get(OPointShapeBuilder.NAME).toDoc(shape);
  } else if (Rectangle.class.isAssignableFrom(shape.getClass())) {
    doc = factories.get(ORectangleShapeBuilder.NAME).toDoc(shape);
  } else if (JtsGeometry.class.isAssignableFrom(shape.getClass())) {
    JtsGeometry geometry = (JtsGeometry) shape;
    Geometry geom = geometry.getGeom();
    doc = factories.get("O" + geom.getClass().getSimpleName()).toDoc(shape);

  } else if (ShapeCollection.class.isAssignableFrom(shape.getClass())) {
    ShapeCollection collection = (ShapeCollection) shape;

    if (isMultiPolygon(collection)) {
      doc = factories.get("OMultiPolygon").toDoc(createMultiPolygon(collection));
    } else if (isMultiPoint(collection)) {
      doc = factories.get("OMultiPoint").toDoc(createMultiPoint(collection));
    } else if (isMultiLine(collection)) {
      doc = factories.get("OMultiLineString").toDoc(createMultiLine(collection));
    } else {
      doc = factories.get("OGeometryCollection").toDoc(shape);
    }
  }
  return doc;
}
 

import com.spatial4j.core.shape.jts.JtsGeometry; //导入依赖的package包/类
@Test
public void testMultiLineStringIO() {

  ODocument doc = new ODocument("OMultiLineString");
  doc.field("coordinates", new ArrayList<List<List<Double>>>() {
    {
      add(new ArrayList<List<Double>>() {
        {
          add(Arrays.asList(-71.160281, 42.258729));
          add(Arrays.asList(-71.160837, 42.259113));
          add(Arrays.asList(-71.161144, 42.25932));
        }
      });
    }
  });

  OMultiLineStringShapeBuilder builder = new OMultiLineStringShapeBuilder();
  String multiLineString = builder.asText(doc);

  Shape shape = context.makeLineString(new ArrayList<Point>() {
    {
      add(context.makePoint(-71.160281, 42.258729));
      add(context.makePoint(-71.160837, 42.259113));
      add(context.makePoint(-71.161144, 42.25932));
    }
  });

  JtsGeometry geometry = (JtsGeometry) shape;

  LineString lineString = (LineString) geometry.getGeom();
  MultiLineString multiLineString2 = geometryFactory.createMultiLineString(new LineString[] { lineString });
  String multiLineString1 = multiLineString2.toText();

  Assert.assertEquals(multiLineString1, multiLineString);
}
 

import com.spatial4j.core.shape.jts.JtsGeometry; //导入依赖的package包/类
void writeShape(Shape shape, JsonGenerator gen) throws IOException {
    if (shape instanceof Point) {
        write((Point) shape, gen);
    } else if (shape instanceof Circle) {
        write((Circle) shape, gen);
    } else if (shape instanceof Rectangle) {
        write((Rectangle) shape, gen);
    } else if (shape instanceof ShapeCollection<?>) {
        write((ShapeCollection<?>) shape, gen);
    } else if (shape instanceof JtsGeometry) {
        write((JtsGeometry) shape, gen);
    } else {
        throw new RuntimeException("Unsupported Geometry type");
    }
}
 

import com.spatial4j.core.shape.jts.JtsGeometry; //导入依赖的package包/类
public JtsGeometry toShape(Geometry geometry) {
  return SPATIAL_CONTEXT.makeShape(geometry);
}
 

import com.spatial4j.core.shape.jts.JtsGeometry; //导入依赖的package包/类
void write(JtsGeometry jtsGeometry, JsonGenerator gen) throws IOException {
    Geometry geometry = jtsGeometry.getGeom();
    jtsSerializer.writeGeometry(geometry, gen);
}
 

import com.spatial4j.core.shape.jts.JtsGeometry; //导入依赖的package包/类
/**
 * Cut given polygon on poles (89 and -89)
 */
private static String cutOnPoles(String polygonWKT) throws Exception
{
   JtsSpatialContextFactory noCheckFactory = new JtsSpatialContextFactory();
   noCheckFactory.datelineRule = DatelineRule.none;
   noCheckFactory.validationRule = ValidationRule.none;
   JtsSpatialContext noCheckContext = noCheckFactory.newSpatialContext();
   JtsWKTReaderShapeParser noCheckParser =
         new JtsWKTReaderShapeParser(noCheckContext, noCheckFactory);

   JtsGeometry polygon = (JtsGeometry) noCheckParser.parse(polygonWKT);
   JtsGeometry northPole =
         (JtsGeometry) noCheckParser.parse("LINESTRING(180 89, 0 89, -180 89)");
   JtsGeometry southPole =
         (JtsGeometry) noCheckParser.parse("LINESTRING(180 -89, 0 -89, -180 -89)");

   LineMerger lm = new LineMerger();
   lm.add(polygon.getGeom());
   lm.add(northPole.getGeom());
   lm.add(southPole.getGeom());

   Geometry geometry = UnaryUnionOp.union(lm.getMergedLineStrings());

   Polygonizer polygonizer = new Polygonizer();
   polygonizer.add(geometry);

   List<Polygon> foundPolygons = (List<Polygon>) polygonizer.getPolygons();
   List<Polygon> filteredPolygons = new ArrayList<>();
   for (Polygon p: foundPolygons)
   {
      // removing polygons over the poles
      if (p.getCentroid().getCoordinate().y < 89 && p.getCentroid().getCoordinate().y > -89)
      {
         filteredPolygons.add(p);
      }
   }

   Geometry res = null;

   if (!filteredPolygons.isEmpty())
   {
      res = filteredPolygons.get(0);
   }
   if (filteredPolygons.size() > 1)
   {
      // Should not happen...
      LOGGER.error("A Multipolygon was found, instead of a single polygon. Only the first one is retained.");
   }

   WKTWriter wkw = new WKTWriter();
   return wkw.write(res);
}