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.complex;

import com.vividsolutions.jts.geom.GeometryCollection;

import com.vividsolutions.jts.geom.GeometryFactory;

import java.awt.Shape;

import java.awt.geom.AffineTransform;

import java.awt.geom.PathIterator;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.Collection;

import java.util.Collections;

import java.util.Iterator;

import java.util.List;

import java.util.Objects;

import java.util.function.Predicate;

import org.cresques.cts.ICoordTrans;

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.fmap.geom.GeometryException;

import org.gvsig.fmap.geom.GeometryLocator;

import org.gvsig.fmap.geom.aggregate.Aggregate;

import org.gvsig.fmap.geom.aggregate.MultiLine;

import org.gvsig.fmap.geom.aggregate.MultiPoint;

import org.gvsig.fmap.geom.aggregate.MultiPolygon;

import org.gvsig.fmap.geom.aggregate.MultiPrimitive;

import org.gvsig.fmap.geom.complex.Complex;

import org.gvsig.fmap.geom.exception.CreateGeometryException;

import org.gvsig.fmap.geom.handler.Handler;

import org.gvsig.fmap.geom.jts.AbstractGeometry;

import org.gvsig.fmap.geom.jts.GeometryJTS;

import org.gvsig.fmap.geom.jts.aggregate.AbstractAggregate;

import org.gvsig.fmap.geom.jts.gputils.DefaultGeneralPathX;

import org.gvsig.fmap.geom.operation.GeometryOperationException;

import org.gvsig.fmap.geom.operation.GeometryOperationNotSupportedException;

import org.gvsig.fmap.geom.primitive.GeneralPathX;

import org.gvsig.fmap.geom.primitive.Primitive;

import org.gvsig.fmap.geom.type.GeometryType;

/**

 *

 * @author fdiaz

 */

public class DefaultComplex extends AbstractGeometry implements Complex {

    private final ArrayList<Primitive> primitives;

    public DefaultComplex(GeometryType geomType) {

        super(geomType.getType(), geomType.getSubType());

        primitives = new ArrayList<>();

    }

    /**

     * @param subtype

     */

    public DefaultComplex(int subtype) {

        super(Geometry.TYPES.GEOMETRY, subtype);

        primitives = new ArrayList<>();

    }

    @Override

    public int getPrimitivesNumber() {

        return primitives.size();

    }

    @Override

    public Primitive getPrimitiveAt(int i) {

        return primitives.get(i);

    }

    @Override

    public PathIterator getPathIterator(AffineTransform affineTransform) {

        PrimitiveListPathIterator it = new PrimitiveListPathIterator((List)this.primitives, affineTransform);

        return it;

    }

    @Override

    public Iterator<Geometry> iterator() {

        return new Iterator<Geometry>() {

            private int current = 0;

            @Override

            public boolean hasNext() {

                return (current < getPrimitivesNumber());

            }

            @Override

            public Geometry next() {

                return getPrimitiveAt(current++);

            }

        };

    }

    @Override

    public void ensureCapacity(int capacity) {

        primitives.ensureCapacity(capacity);

    }

    @Override

    public void reProject(ICoordTrans ct) {

        for (Primitive primitive : primitives) {

            primitive.reProject(ct);

        }

    }

    @Override

    public void transform(AffineTransform at) {

        for (Primitive primitive : primitives) {

            primitive.transform(at);

        }

    }

    @Override

    public boolean is3D() {

        for (Iterator<Primitive> iterator = primitives.iterator(); iterator.hasNext();) {

            GeometryJTS primitive = (GeometryJTS) iterator.next();

            if (primitive.is3D()) {

                return true;

            }

        }

        return false;

    }

    @Override

    public Shape getShape(AffineTransform affineTransform) {

        return new DefaultGeneralPathX(getPathIterator(affineTransform),false,0);

    }

    @Override

    public Shape getShape() {

        return new DefaultGeneralPathX(getPathIterator(null),false,0);

    }

    @Override

    public boolean equals(Object obj) {

        if(super.equals(obj) && obj instanceof AbstractAggregate){

            AbstractAggregate other = (AbstractAggregate)obj;

            if(other.getPrimitivesNumber() == this.getPrimitivesNumber()){

                for (int j = 0; j < this.getPrimitivesNumber(); j++) {

                    if(!this.getPrimitiveAt(j).equals(other.getPrimitiveAt(j))){

                        return false;

                    }

                }

            } else {

                return false;

            }

        } else {

            return false;

        }

        return true;

    }

    @Override

    public int hashCode() {

        int hash = 5;

        hash = 41 * hash + Objects.hashCode(this.primitives);

        return hash;

    }

    @Override

    public boolean canBeTransformed(AffineTransform at) {

        for (Iterator<Primitive> iterator = primitives.iterator(); iterator.hasNext();) {

            GeometryJTS primitive = (GeometryJTS) iterator.next();

            if (!primitive.canBeTransformed(at)) {

                return false;

            }

        }

        return true;

    }

    @Override

    public boolean canBeReprojected(ICoordTrans ct) {

        for (Iterator<Primitive> iterator = primitives.iterator(); iterator.hasNext();) {

            GeometryJTS primitive = (GeometryJTS) iterator.next();

            if (!primitive.canBeReprojected(ct)) {

                return false;

            }

        }

        return true;

    }

    @Override

    public void flip() throws GeometryOperationNotSupportedException, GeometryOperationException {

        for (Iterator iterator = primitives.iterator(); iterator.hasNext();) {

            ((GeometryJTS)iterator.next()).flip();

        }

        Collections.reverse(primitives);

    }

    @Override

    public void addPrimitive(Primitive primitive) {

        Geometry geom = fixPrimitive(primitive);

        if (geom != null) {

            if (geom instanceof MultiPrimitive) {

                for (int i = 0; i < ((MultiPrimitive) geom).getPrimitivesNumber(); i++) {

                    addPrimitive(((MultiPrimitive) geom).getPrimitiveAt(i));

                }

            } else {

                primitives.add((Primitive) geom);

            }

        }

    }

    @Override

    public void addPrimitives(Aggregate aggregate) {

        for (Geometry primitive : aggregate) {

            this.addPrimitive((Primitive) primitive);

        }

    }

    @Override

    public void addPrimitives(Geometry geometry) {

        if(geometry instanceof Primitive){

            addPrimitive((Primitive) geometry);

        } else {

            addPrimitives((Aggregate)geometry);

        }

    }

    private Geometry fixPrimitive(Primitive primitive) {

        //FIXME: check subtype and projection

        return primitive;

    }

    @Override

    public Geometry force2D() throws GeometryOperationNotSupportedException, GeometryOperationException {

        DefaultComplex other = new DefaultComplex(this.getGeometryType().getSubType());

        other.setProjection(this.getProjection());

        other.ensureCapacity(primitives.size());

        for (Primitive primitive : primitives) {

            other.addPrimitive((Primitive)primitive.forceSubtype(Geometry.SUBTYPES.GEOM2D));

        }

        return other;

    }

    @Override

    public Geometry force2DM() throws GeometryOperationNotSupportedException, GeometryOperationException {

        DefaultComplex other = new DefaultComplex(this.getGeometryType().getSubType());

        other.setProjection(this.getProjection());

        other.ensureCapacity(primitives.size());

        for (Primitive primitive : primitives) {

            other.addPrimitive((Primitive)primitive.forceSubtype(Geometry.SUBTYPES.GEOM2DM));

        }

        return other;

    }

    @Override

    public Geometry force3D() throws GeometryOperationNotSupportedException, GeometryOperationException {

        DefaultComplex other = new DefaultComplex(this.getGeometryType().getSubType());

        other.setProjection(this.getProjection());

        other.ensureCapacity(primitives.size());

        for (Primitive primitive : primitives) {

            other.addPrimitive((Primitive)primitive.forceSubtype(Geometry.SUBTYPES.GEOM3D));

        }

        return other;

    }

    @Override

    public Geometry force3DM() throws GeometryOperationNotSupportedException, GeometryOperationException {

        DefaultComplex other = new DefaultComplex(this.getGeometryType().getSubType());

        other.setProjection(this.getProjection());

        other.ensureCapacity(primitives.size());

        for (Primitive primitive : primitives) {

            other.addPrimitive((Primitive)primitive.forceSubtype(Geometry.SUBTYPES.GEOM3DM));

        }

        return other;

    }

    @Override

    public Geometry offset(double distance) throws GeometryOperationNotSupportedException, GeometryOperationException {

        DefaultComplex other = new DefaultComplex(this.getGeometryType().getSubType());

        other.setProjection(this.getProjection());

        other.ensureCapacity(primitives.size());

        for (Primitive primitive : primitives) {

            other.addPrimitive((Primitive)primitive.offset(distance));

        }

        return other;

    }

    @Override

    public Geometry offset(int joinStyle, double distance) throws GeometryOperationNotSupportedException, GeometryOperationException {

        DefaultComplex other = new DefaultComplex(this.getGeometryType().getSubType());

        other.setProjection(this.getProjection());

        other.ensureCapacity(primitives.size());

        for (Primitive primitive : primitives) {

            other.addPrimitive((Primitive)primitive.offset(joinStyle, distance));

        }

        return other;

    }

    @Override

    public com.vividsolutions.jts.geom.Geometry getJTS() {

        GeometryFactory gf = new GeometryFactory();

        List<com.vividsolutions.jts.geom.Geometry> geometries = new ArrayList<>();

        for (Primitive primitive : primitives) {

            geometries.add(((GeometryJTS)primitive).getJTS());

        }

        GeometryCollection col = gf.createGeometryCollection(geometries.toArray(new com.vividsolutions.jts.geom.Geometry[geometries.size()]));

        return col;

    }

    @Override

    public Geometry cloneGeometry() {

        DefaultComplex other = new DefaultComplex(this.getGeometryType().getSubType());

        other.setProjection(this.getProjection());

        other.ensureCapacity(primitives.size());

        for (Primitive primitive : primitives) {

            other.addPrimitive((Primitive)primitive.cloneGeometry());

        }

        return other;

    }

    @Override

    public int getDimension() {

        return this.getGeometryType().getDimension();

    }

    @Override

    public Handler[] getHandlers(int type) {

        List<Handler> handlers = new ArrayList<>();

        for (Primitive primitive : primitives) {

            Handler[] primitiveHandlers = primitive.getHandlers(type);

            handlers.addAll(Arrays.asList(primitiveHandlers));

        }

        return handlers.toArray(new Handler[handlers.size()]);

    }

    @Override

    public PathIterator getPathIterator(AffineTransform at, double flatness) {

        return getPathIterator(at);

    }

    @Override

    public GeneralPathX getGeneralPath() {

        return new DefaultGeneralPathX(getPathIterator(null), false, 0);

    }

    @Override

    public MultiPoint toPoints() throws GeometryException {

        MultiPoint res = GeometryLocator.getGeometryManager().createMultiPoint(this.getGeometryType().getSubType());

        res.setProjection(this.getProjection());

        for (Primitive primitive : primitives) {

            MultiPoint points = primitive.toPoints();

            for (Geometry point : points) {

                res.addPrimitives(point);

            }

        }

        return res;

    }

    @Override

    public MultiLine toLines() throws GeometryException {

        MultiLine res = GeometryLocator.getGeometryManager().createMultiLine(this.getGeometryType().getSubType());

        res.setProjection(this.getProjection());

        for (Primitive primitive : primitives) {

            MultiLine geometries = primitive.toLines();

            for (Geometry geom : geometries) {

                res.addPrimitives(geom);

            }

        }

        return res;

    }

    @Override

    public MultiPolygon toPolygons() throws GeometryException {

        MultiPolygon res = GeometryLocator.getGeometryManager().createMultiPolygon(this.getGeometryType().getSubType());

        res.setProjection(this.getProjection());

        for (Primitive primitive : primitives) {

            MultiPolygon geometries = primitive.toPolygons();

            for (Geometry geom : geometries) {

                res.addPrimitives(geom);

            }

        }

        return res;

    }

    @Override

    public Collection<? extends Geometry> getElements() {

        return this.primitives;

    }

    @Override

    public Iterator<Geometry> iterator(Predicate<Geometry> filter) {

        Iterator<Geometry> it = this.iterator();

        return new Iterator<Geometry>() {

            Geometry next = null;

            @Override

            public boolean hasNext() {

                while (it.hasNext()) {

                    next = it.next();

                    if(filter.test(next)){

                        return true;

                    }

                }

                return false;

            }

            @Override

            public Geometry next() {

                return next;

            }

        };

    }

    @Override

    public Aggregate createAggregate(int type, Predicate<Geometry> filter) throws CreateGeometryException {

        MultiPrimitive aggregate = (MultiPrimitive) GeometryLocator.getGeometryManager().create(type, this.getGeometryType().getSubType());

        for (Primitive primitive : primitives) {

            if(filter.test(primitive)){

                aggregate.addPrimitives(primitive);

            }

        }

        return aggregate;

    }

    @Override

    public boolean isEmpty() {

        return this.getPrimitivesNumber() < 1;

    }

    @Override

    public int size() {

        return this.getPrimitivesNumber();

    }

    @Override

    public Geometry get(int position) {

        return this.getPrimitiveAt(position);

    }

}