Application: gvSIG desktop

/*

 * To change this license header, choose License Headers in Project Properties.

 * To change this template file, choose Tools | Templates

 * and open the template in the editor.

 */

package org.gvsig.fmap.geom.jts.gml;

import com.vividsolutions.jts.geom.Coordinate;

import com.vividsolutions.jts.geom.CoordinateSequence;

import com.vividsolutions.jts.geom.GeometryFactory;

import com.vividsolutions.jts.geom.LineString;

import com.vividsolutions.jts.geom.LinearRing;

import com.vividsolutions.jts.geom.MultiLineString;

import com.vividsolutions.jts.geom.MultiPolygon;

import com.vividsolutions.jts.geom.Polygon;

import com.vividsolutions.jts.io.gml2.GMLConstants;

import com.vividsolutions.jts.operation.linemerge.LineMerger;

import java.util.ArrayList;

import java.util.HashMap;

import java.util.List;

import org.apache.commons.collections4.CollectionUtils;

import org.apache.commons.lang3.StringUtils;

import org.apache.commons.lang3.tuple.ImmutablePair;

import org.apache.commons.lang3.tuple.Pair;

import static org.gvsig.fmap.geom.jts.gml.GeometryStrategies.getSrid;

import org.gvsig.fmap.geom.jts.util.JTSUtils;

import org.xml.sax.SAXException;

/**

 *

 * @author fdiaz

 */

public class GeometryStrategiesGML3 {

    @SuppressWarnings("Convert2Lambda")

    public static HashMap loadStrategies(HashMap strats) {

        GeometryStrategies.ParseStrategy oneChild = new GeometryStrategies.ParseStrategy() {

            @Override

            public Object parse(GMLHandler.Handler arg, GeometryFactory gf) throws SAXException {

                if (arg.children.size() != 1) {

                    throw new SAXException("Geometry Members may only contain one geometry.");

                }

                // type checking will occur in the parent geom collection.

                // may wish to add this in the future

                return arg.children.get(0);

            }

        };

        GeometryStrategies.ParseStrategy manyChilds = new GeometryStrategies.ParseStrategy() {

            @Override

            public Object parse(GMLHandler.Handler arg, GeometryFactory gf) throws SAXException {

                return arg.children;

            }

        };

        strats.put("pos".toLowerCase(), new GeometryStrategies.ParseStrategy() {

            @Override

            public Object parse(GMLHandler.Handler arg, GeometryFactory gf) throws SAXException {

                String[] ss = StringUtils.split(arg.text.toString(), ' ');

                Coordinate c = new Coordinate();

                c.x = Double.parseDouble(ss[0]);

                if (ss.length > 1) {

                    c.y = Double.parseDouble(ss[1]);

                }

                if (ss.length > 3) {

                    c.z = Double.parseDouble(ss[2]);

                }

                return c;

            }

        });

        strats.put("posList".toLowerCase(), new GeometryStrategies.ParseStrategy() {

            @Override

            public Object parse(GMLHandler.Handler arg, GeometryFactory gf) throws SAXException {

                if (arg.text == null || "".equals(arg.text)) {

                    throw new SAXException("Cannot create a coordinate sequence without text to parse");

                }

                String coordSeperator = " ";

                int srsDimension = 2;

                if (arg.attrs.getIndex("cs") >= 0) {

                    coordSeperator = arg.attrs.getValue("cs");

                } else if (arg.attrs.getIndex(GMLConstants.GML_NAMESPACE, "cs") >= 0) {

                    coordSeperator = arg.attrs.getValue(GMLConstants.GML_NAMESPACE, "cs");

                }

                if (arg.attrs.getIndex("srsDimension") >= 0) {

                    srsDimension = Integer.parseInt(arg.attrs.getValue("srsDimension"));

                } else if (arg.attrs.getIndex(GMLConstants.GML_NAMESPACE, "srsDimension") >= 0) {

                    srsDimension = Integer.parseInt(arg.attrs.getValue(GMLConstants.GML_NAMESPACE, "srsDimension"));

                }

                // now to start parse

                String t = arg.text.toString();

                t = t.replaceAll("\\s", " ");

                String[] ss = StringUtils.split(t,coordSeperator);

                int len = ss.length/srsDimension;

                CoordinateSequence cs = gf.getCoordinateSequenceFactory().create(len, srsDimension);

                for (int i = 0; i < len; i++) {

                    cs.setOrdinate(i, 0, Double.parseDouble(ss[i*2]));

                    if(srsDimension > 1) {

                        cs.setOrdinate(i, 1, Double.parseDouble(ss[(i*2)+1]));

                    }

                    if(srsDimension > 2) {

                        cs.setOrdinate(i, 2, Double.parseDouble(ss[(i*2)+2]));

                    }

                }

                return cs;

            }

        });

        strats.put("PolygonPatch".toLowerCase(), new GeometryStrategies.ParseStrategy() {

            @Override

            public Object parse(GMLHandler.Handler arg, GeometryFactory gf) throws SAXException {

                LinearRing exterior = (LinearRing) arg.children.get(0);

                List<LinearRing> interior = null;

                int childrensCount = arg.children.size();

                if(childrensCount == 2){

                    interior = (List<LinearRing>) arg.children.get(1);

                } else if(childrensCount > 2){

                    interior = new ArrayList<>();

                    for (int i = 1; i < childrensCount; i++) {

                        Object child = arg.children.get(i);

                        if(child instanceof List){

                            interior.add(((List<LinearRing>)child).get(0));

                        } else {

                            interior.add(((LinearRing)child));

                        }

                    }

                }

                return new ImmutablePair(exterior, interior);

            }

        });

        strats.put("patches".toLowerCase(), new GeometryStrategies.ParseStrategy() {

            @Override

            public Object parse(GMLHandler.Handler arg, GeometryFactory gf) throws SAXException {

                return arg.children;

            }

        });

        strats.put("Surface".toLowerCase(), new GeometryStrategies.ParseStrategy() {

            @Override

            public Object parse(GMLHandler.Handler arg, GeometryFactory gf) throws SAXException {

                List<Pair<LinearRing,List<LinearRing>>> patches = (List<Pair<LinearRing,List<LinearRing>>>) arg.children.get(0);

                LinearRing shell = patches.get(0).getLeft();

                List<LinearRing> holes = patches.get(0).getRight();

                Polygon polygon;

                if(holes == null){

                    polygon = gf.createPolygon(shell);

                } else {

                    polygon = gf.createPolygon(shell, holes.toArray(new LinearRing[holes.size()]));

                }

                int srid = getSrid(arg.attrs,gf.getSRID());

                if (polygon.getSRID() != srid) {

                    polygon.setSRID(srid);

                }

                return polygon;

            }

        });

        strats.put("exterior".toLowerCase(), oneChild);

        strats.put("surfaceMember".toLowerCase(), oneChild);

        strats.put("OrientableSurface".toLowerCase(), oneChild);

        strats.put("baseSurface".toLowerCase(), oneChild);

        strats.put("interior".toLowerCase(), manyChilds);

        strats.put("MultiSurface".toLowerCase(), new GeometryStrategies.ParseStrategy() {

            @Override

            public Object parse(GMLHandler.Handler arg, GeometryFactory gf) throws SAXException {

                List<Polygon> polygons = arg.children;

                MultiPolygon multiPolygon = gf.createMultiPolygon(polygons.toArray(new Polygon[polygons.size()]));

                int srid = getSrid(arg.attrs,gf.getSRID());

                if (multiPolygon.getSRID() != srid) {

                    multiPolygon.setSRID(srid);

                }

                return multiPolygon;

            }

        });

        strats.put("CompositeSurface".toLowerCase(), strats.get("MultiSurface".toLowerCase()));

        strats.put("curveMember".toLowerCase(), oneChild);

        strats.put("MultiCurve".toLowerCase(), new GeometryStrategies.ParseStrategy() {

            @Override

            public Object parse(GMLHandler.Handler arg, GeometryFactory gf) throws SAXException {

                List<LineString> curves = arg.children;

                MultiLineString multicurve = gf.createMultiLineString(curves.toArray(new LineString[curves.size()]));

                int srid = getSrid(arg.attrs,gf.getSRID());

                if (multicurve.getSRID() != srid) {

                    multicurve.setSRID(srid);

                }

                return multicurve;

            }

        });

        strats.put("segments".toLowerCase(), manyChilds);

        strats.put("LineStringSegment".toLowerCase(), oneChild);

        strats.put("Curve".toLowerCase(), new GeometryStrategies.ParseStrategy() {

            @Override

            public Object parse(GMLHandler.Handler arg, GeometryFactory gf) throws SAXException {

                //Curve/segments/LineStringSegment/posList

                LineString curve = null;

                List<CoordinateSequence> segments = (List<CoordinateSequence>) arg.children.get(0);

                if (CollectionUtils.isNotEmpty(segments)) {

                    CoordinateSequence segment = segments.get(0);

                    if (segment != null) {

                        curve = gf.createLineString(segment);

                    }

                }

                return curve;

            }

        });

        strats.put("Ring".toLowerCase(), new GeometryStrategies.ParseStrategy() {

            @Override

            public Object parse(GMLHandler.Handler arg, GeometryFactory gf) throws SAXException {

                //Ring/curveMember/LineString/posList

                LineMerger merger = new LineMerger();

                List<LineString> segments = (List<LineString>) arg.children;//.get(0);

                for (LineString segment : segments) {

                    merger.add(segment);

                }

                List<LineString> merged = (List<LineString>) merger.getMergedLineStrings();

                return JTSUtils.createJTSLinearRing(merged.get(0).getCoordinateSequence());

            }

        });

        strats.put("Solid".toLowerCase(), null);

        return strats;

    }

}