gvSIG projects pool

{

    "id": "PolygonMustNotOverlapWithPolygon",

    "name": "Must Not Overlap With",

    "description": [ 

        "<img src=\"@@@_d/PolygonMustNotOverlapWithPolygon.png\">\n",

        "Requires that the interior of polygons in one feature class (or subtype) must not overlap with the interior of polygons in another feature class (or subtype). Polygons of the two feature classes can share edges or vertices or be completely disjointed. This rule is used when an area cannot belong to two separate feature classes. It is useful for combining two mutually exclusive systems of area classification, such as zoning and water body type, where areas defined within the zoning class cannot also be defined in the water body class and vice versa."

    ],

    "actions" : {

        "Subtract": {

            "name" : "Subtract",

            "description": [ 

                "The Subtract fix removes the overlapping portion of each feature that is causing the error and leaves a gap or void in its place. This fix can be applied to one or more selected Must Not Overlap With errors."

            ]

        },

        "Merge": {

            "name" : "Merge",

            "description": [ 

                "The Merge fix adds the portion of overlap from one feature and subtracts it from the others that are violating the rule. You need to pick the feature that receives the portion of overlap using the Merge dialog box. This fix can be applied to one Must Not Overlap With error only."

            ]

        }

    }

}

{

    "id": "PolygonMustNotOverlapWithPolygon",

    "name": "No debe superponerse con",

    "description": [ 

        "<img src=\"@@@_d/PolygonMustNotOverlapWithPolygon.png\">\n",

        "Requiere que el interior de los pol?gonos en una clase (o subtipo) de entidad no se deba superponer con el interior de los pol?gonos en otra clase (o subtipo) de entidad. Los pol?gonos de las dos clases de entidad pueden compartir ejes o v?rtices o estar completamente inconexos. Esta regla se utiliza cuando un ?rea no puede pertenecer a dos clases de entidad separadas. Resulta ?til para combinar dos sistemas mutuamente exclusivos de clasificaci?n de ?rea, tales como zonificaci?n y tipos de masa de agua, en las que las ?reas definidas en la clase de zonificaci?n tampoco se pueden definir en la clase de masa de agua y viceversa."

    ],

    "actions" : {

        "Subtract": {

            "name" : "Subtract",

            "description": [ 

                "La soluci?n Sustraer quita la parte de superposici?n de cada entidad que causa el error y deja un espacio o vac?o en su lugar. Esta soluci?n se puede aplicar a uno o m?s errores seleccionados del tipo No debe superponerse con."

            ]

        },

        "Merge": {

            "name" : "Merge",

            "description": [ 

                "La soluci?n Fusionar agrega la parte de superposici?n de una entidad y la sustrae del resto que infringen la regla. Es necesario elegir la entidad que recibe la parte de superposici?n utilizando el cuadro de di?logo Fusionar. Esta soluci?n se puede aplicar ?nicamente a un error de tipo No debe superponerse con."

            ]

        }

    }

}

import org.gvsig.topology.rule.PolygonMustNotOverlapWithPolygonRuleFactory;

        PolygonMustNotOverlapWithPolygonRuleFactory.selfRegister();

/**

 * gvSIG. Desktop Geographic Information System.

 *

 * Copyright (C) 2007-2013 gvSIG Association.

 *

 * This program is free software; you can redistribute it and/or

 * modify it under the terms of the GNU General Public License

 * as published by the Free Software Foundation; either version 3

 * of the License, or (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,

 * MA  02110-1301, USA.

 *

 * For any additional information, do not hesitate to contact us

 * at info AT gvsig.com, or visit our website www.gvsig.com.

 */

package org.gvsig.topology.rule;

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.tools.util.ListBuilder;

import org.gvsig.topology.lib.api.TopologyLocator;

import org.gvsig.topology.lib.api.TopologyManager;

import org.gvsig.topology.lib.api.TopologyPlan;

import org.gvsig.topology.lib.api.TopologyRule;

import org.gvsig.topology.lib.spi.AbstractTopologyRuleFactory;

/**

 *

 * @author jjdelcerro

 */

@SuppressWarnings("UseSpecificCatch")

public class PolygonMustNotOverlapWithPolygonRuleFactory extends AbstractTopologyRuleFactory {

    public static final String NAME = "PolygonMustNotOverlapWithPolygon";

    public PolygonMustNotOverlapWithPolygonRuleFactory() {

        super(

                NAME, 

                "Must Not Overlap With", 

                "Requires that the interior of polygons in one feature class (or subtype) must not overlap with the interior of polygons in another feature class (or subtype). Polygons of the two feature classes can share edges or vertices or be completely disjointed. This rule is used when an area cannot belong to two separate feature classes. It is useful for combining two mutually exclusive systems of area classification, such as zoning and water body type, where areas defined within the zoning class cannot also be defined in the water body class and vice versa.", 

                new ListBuilder<Integer>()

                        .add(Geometry.TYPES.SURFACE)

                        .add(Geometry.TYPES.MULTISURFACE)

                        .asList(),

                new ListBuilder<Integer>()

                        .add(Geometry.TYPES.SURFACE)

                        .add(Geometry.TYPES.MULTISURFACE)

                        .asList()

        );

    }

    @Override

    public TopologyRule createRule(TopologyPlan plan, String dataSet1, String dataSet2, double tolerance) {

        TopologyRule rule = new PolygonMustNotOverlapWithPolygonRule(plan, this, tolerance, dataSet1, dataSet2);

        return rule;

    }    

    public static void selfRegister() {

        try {

            TopologyManager manager = TopologyLocator.getTopologyManager();

            manager.addRuleFactories(new PolygonMustNotOverlapWithPolygonRuleFactory());

        } catch(Exception ex) {

            LOGGER.warn("Can't register topology rule from "+PolygonMustNotOverlapWithPolygonRuleFactory.class.getSimpleName(), ex);

        }

    }

}

/**

 * gvSIG. Desktop Geographic Information System.

 *

 * Copyright (C) 2007-2013 gvSIG Association.

 *

 * This program is free software; you can redistribute it and/or

 * modify it under the terms of the GNU General Public License

 * as published by the Free Software Foundation; either version 3

 * of the License, or (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,

 * MA  02110-1301, USA.

 *

 * For any additional information, do not hesitate to contact us

 * at info AT gvsig.com, or visit our website www.gvsig.com.

 */

package org.gvsig.topology.rule;

import org.gvsig.expressionevaluator.Expression;

import org.gvsig.expressionevaluator.ExpressionUtils;

import org.gvsig.expressionevaluator.GeometryExpressionBuilder;

import org.gvsig.expressionevaluator.GeometryExpressionUtils;

import org.gvsig.fmap.dal.feature.Feature;

import org.gvsig.fmap.dal.feature.FeatureReference;

import org.gvsig.fmap.dal.feature.FeatureSet;

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dynobject.DynObject;

import org.gvsig.tools.i18n.I18nManager;

import org.gvsig.tools.task.SimpleTaskStatus;

import org.gvsig.topology.lib.api.ExecuteTopologyRuleActionException;

import org.gvsig.topology.lib.api.TopologyDataSet;

import org.gvsig.topology.lib.api.TopologyPlan;

import org.gvsig.topology.lib.api.TopologyReport;

import org.gvsig.topology.lib.api.TopologyReportLine;

import org.gvsig.topology.lib.api.TopologyRule;

import org.gvsig.topology.lib.api.TopologyRuleFactory;

import org.gvsig.topology.lib.spi.AbstractTopologyRule;

import org.gvsig.topology.lib.spi.AbstractTopologyRuleAction;

/**

 *

 * @author jjdelcerro

 */

@SuppressWarnings("UseSpecificCatch")

public class PolygonMustNotOverlapWithPolygonRule extends AbstractTopologyRule {

    private class SubtractAction extends AbstractTopologyRuleAction {

        public SubtractAction() {

            super(

                    PolygonMustNotOverlapWithPolygonRuleFactory.NAME,

                    "Subtract",

                    "Subtract",

                    "The Subtract fix removes the overlapping portion of each feature that is causing the error and leaves a gap or void in its place. This fix can be applied to one or more selected Must Not Overlap With errors."

            );

        }

        @Override

        public int execute(TopologyRule rule, TopologyReportLine line, DynObject parameters) {

            try {

                Geometry errorGeom = line.getError();

                FeatureReference featRef1 = line.getFeature1();

                Feature feat1 = featRef1.getFeature();

                Geometry geom1 = feat1.getDefaultGeometry();

                FeatureReference featRef2 = line.getFeature2();

                Feature feat2 = featRef2.getFeature();

                Geometry geom2 = feat2.getDefaultGeometry();

                substract(featRef1, geom2, rule.getDataSet1());

                substract(featRef2, geom1, rule.getDataSet2());

                return EXECUTE_OK;

            } catch (Exception ex) {

                throw new ExecuteTopologyRuleActionException(ex);

            }

        }

    }

    private class MergeAction extends AbstractTopologyRuleAction {

        public MergeAction() {

            super(

                    PolygonMustNotOverlapWithPolygonRuleFactory.NAME,

                    "Merge",

                    "Merge",

                    "The Merge fix adds the portion of overlap from one feature and subtracts it from the others that are violating the rule. You need to pick the feature that receives the portion of overlap using the Merge dialog box. This fix can be applied to one Must Not Overlap With error only."

            );

        }

        @Override

        public int execute(TopologyRule rule, TopologyReportLine line, DynObject parameters) {

            try {

                Geometry errorGeom = line.getError();

                FeatureReference featRef1 = line.getFeature1();

                Feature feat1 = featRef1.getFeature();

                Geometry geom1 = feat1.getDefaultGeometry();

                FeatureReference featRef2 = line.getFeature2();

                substract(featRef2, geom1, rule.getDataSet2());

                return EXECUTE_OK;

            } catch (Exception ex) {

                throw new ExecuteTopologyRuleActionException(ex);

            }

        }

    }

    private String geomName;

    private Expression expression = null;

    private GeometryExpressionBuilder expressionBuilder = null;

    public PolygonMustNotOverlapWithPolygonRule(

            TopologyPlan plan,

            TopologyRuleFactory factory,

            double tolerance,

            String dataSet1,

            String dataSet2

    ) {

        super(plan, factory, tolerance, dataSet1, dataSet2);

        this.addAction(new MergeAction());

        this.addAction(new SubtractAction());

    }

    @Override

    protected void check(SimpleTaskStatus taskStatus, TopologyReport report, Feature feature1) throws Exception {

        try {

            if (this.expression == null) {

                this.expression = ExpressionUtils.createExpression();

                this.expressionBuilder = GeometryExpressionUtils.createExpressionBuilder();

                this.geomName = feature1.getType().getDefaultGeometryAttributeName();

            }

            Geometry polygon = feature1.getDefaultGeometry();

            if( polygon==null ) {

                return;

            }

            TopologyDataSet thisDataSet = this.getDataSet1();

            TopologyDataSet otherDataSet = this.getDataSet2();

            if (otherDataSet.getSpatialIndex() != null) {

                for (FeatureReference otherReference : otherDataSet.query(polygon)) {

//                    if (otherReference.equals(feature1.getReference())) {

//                        continue;

//                    }

                    Feature otherFeature = otherReference.getFeature();

                    Geometry otherPolygon = otherFeature.getDefaultGeometry();

                    double halfTolerance = this.getTolerance()/2;

                    if (otherPolygon!=null && polygon.buffer(-halfTolerance).overlaps(otherPolygon.buffer(-halfTolerance))) {

                        I18nManager i18n = ToolsLocator.getI18nManager();

                        Geometry error = polygon.intersection(otherPolygon);

                        report.addLine(this,

                                thisDataSet,

                                otherDataSet,

                                polygon,

                                error,

                                feature1.getReference(),

                                otherFeature.getReference(),

                                false,

                                i18n.getTranslation("_The_polygon_overlay_with_other")

                        );

                    }

                }

            } else {

                this.expression.setPhrase(

                        this.expressionBuilder.ifnull(

                                this.expressionBuilder.column(this.geomName),

                                this.expressionBuilder.constant(false),

                                this.expressionBuilder.ST_Overlaps(

                                        this.expressionBuilder.column(this.geomName),

                                        this.expressionBuilder.geometry(polygon)

                                )

                        ).toString()

                );

                FeatureSet otherFeatures = otherDataSet.getFeatureStore().getFeatureSet(this.expression);

                for (Feature otherFeature : otherFeatures) {

                    if ( otherFeature != null) {

                        Geometry otherPolygon = otherFeature.getDefaultGeometry();

                        double halfTolerance = this.getTolerance()/2;

                        if (otherPolygon!=null && polygon.buffer(-halfTolerance).overlaps(otherPolygon.buffer(-halfTolerance))) {

                           I18nManager i18n = ToolsLocator.getI18nManager();

                            Geometry error = polygon.intersection(otherPolygon);

                            report.addLine(this,

                                    thisDataSet,

                                    otherDataSet,

                                    polygon,

                                    error,

                                    feature1.getReference(),

                                    otherFeature.getReference(),

                                    false,

                                    i18n.getTranslation("_The_polygon_overlay_with_other")

                            );

                        }

                    }

                }

            }

        } catch (Exception ex) {

            LOGGER.warn("Can't check feature.", ex);

        } finally {

        }

    }

}