gvSIG projects pool

import org.gvsig.topology.rule.ContainsNullRuleFactory;

import org.gvsig.topology.rule.ContainsPointRuleFactory;

import org.gvsig.topology.rule.MustBeLargerThanToleranceLineRuleFactory;

import org.gvsig.topology.rule.MustNotOverlapPolygonRuleFactory;

        ContainsNullRuleFactory.selfRegister();

        ContainsPointRuleFactory.selfRegister();

        MustBeLargerThanToleranceLineRuleFactory.selfRegister();

        MustNotOverlapPolygonRuleFactory.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.expressionevaluator.Expression;

import org.gvsig.expressionevaluator.ExpressionUtils;

import org.gvsig.expressionevaluator.GeometryExpressionBuilder;

import org.gvsig.expressionevaluator.GeometryExpressionUtils;

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

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.dal.feature.FeatureStore;

import org.gvsig.fmap.geom.Geometry;

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

import org.gvsig.tools.dynobject.DynObject;

import org.gvsig.tools.task.SimpleTaskStatus;

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

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

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;

/**

 *

 * @author jjdelcerro

 */

@SuppressWarnings("UseSpecificCatch")

public class ContainsPointRule extends AbstractTopologyRule {

    private class CreateFetureAction extends AbstractTopologyRuleAction {

        public CreateFetureAction() {

            super(

                    ContainsPointRuleFactory.NAME,

                    "CreateFeature",

                    "Create Feature",

                    "The Create Feature fix creates a new point feature at the centroid of the polygon feature that is causing the error. The point feature that is created is guaranteed to be within the polygon feature."

            );

        }

        @Override

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

            try {

                Geometry polygon = line.getGeometry();

                Point point = polygon.centroid();

                if( !polygon.contains(point) ) {

                    point = polygon.getInteriorPoint();

                }

                TopologyDataSet dataSet = rule.getDataSet2();

                EditableFeature feature = dataSet.createNewFeature();

                feature.setDefaultGeometry(point);

                dataSet.insert(feature);

            } catch (Exception ex) {

                throw new ExecuteTopologyRuleActionException(ex);

            }

        }

    }

    private String geomName;

    private Expression expression = null;

    private GeometryExpressionBuilder expressionBuilder = null;

    public ContainsPointRule(

            TopologyPlan plan,

            TopologyRuleFactory factory,

            double tolerance,

            String dataSet1,

            String dataSet2

    ) {

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

        this.addAction(new CreateFetureAction());

    }

    @Override

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

        FeatureSet set = null;

        try {

            FeatureStore store2 = this.getDataSet2().getFeatureStore();

            if (this.expression == null) {

                this.expression = ExpressionUtils.createExpression();

                this.expressionBuilder = GeometryExpressionUtils.createExpressionBuilder();

                this.geomName = store2.getDefaultFeatureType().getDefaultGeometryAttributeName();

            }

            Geometry polygon = feature1.getDefaultGeometry();

            TopologyDataSet theDataSet = this.getDataSet2();

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

                boolean contains = false;

                for (FeatureReference featureReference : theDataSet.query(polygon)) {

                    Feature feature2 = featureReference.getFeature();

                    Geometry otherPoint = feature2.getDefaultGeometry();

                    if( otherPoint!=null && polygon.contains(otherPoint) ) {

                        contains = true;

                        break;

                    }

                }

                if( !contains ) {

                    report.addLine(this,

                            this.getDataSet1(),

                            this.getDataSet2(),

                            polygon,

                            polygon,

                            feature1.getReference(),

                            null,

                            false,

                            "The polygon is an error because it does not contain a point."

                    );

                }

            } else {

                this.expression.setPhrase(

                        this.expressionBuilder.ifnull(

                                this.expressionBuilder.column(this.geomName),

                                this.expressionBuilder.constant(false),

                                this.expressionBuilder.ST_Contains(

                                        this.expressionBuilder.geometry(polygon),

                                        this.expressionBuilder.column(this.geomName)

                                )

                        ).toString()

                );

                if (theDataSet.findFirst(this.expression) == null) {

                    report.addLine(this,

                            this.getDataSet1(),

                            this.getDataSet2(),

                            polygon,

                            polygon,

                            feature1.getReference(),

                            null,

                            false,

                            "The polygon is an error because it does not contain a point."

                    );

                }

            }

        } catch (Exception ex) {

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

        } finally {

            if (set != null) {

                set.dispose();

            }

        }

    }

}

/**

 * 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.dal.feature.Feature;

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

import org.gvsig.tools.task.SimpleTaskStatus;

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

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

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

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

/**

 *

 * @author jjdelcerro

 */

@SuppressWarnings("UseSpecificCatch")

public class ContainsNullRule extends AbstractTopologyRule {

    public ContainsNullRule(

            TopologyPlan plan,

            TopologyRuleFactory factory,

            double tolerance,

            String dataSet1,

            String dataSet2

    ) {

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

    }

    @Override

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

        FeatureSet set = null;

        try {

            if ( feature1.getDefaultGeometry()==null ) {

                report.addLine(this,

                        this.getDataSet1(),

                        this.getDataSet2(),

                        feature1.getDefaultGeometry(),

                        null,

                        feature1.getReference(),

                        null,

                        false,

                        "The geometry is null."

                );

            }

        } catch(Exception ex) {

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

        } finally {

            if( set!=null ) {

                set.dispose();

            }

        }

    }

}

/**

 * 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.exception.DataException;

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

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.fmap.geom.operation.GeometryOperationException;

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

import org.gvsig.tools.dynobject.DynObject;

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 MustNotOverlapPolygonRule extends AbstractTopologyRule {

    private class CreateFetureAction extends AbstractTopologyRuleAction {

        public CreateFetureAction() {

            super(

                    MustNotOverlapPolygonRuleFactory.NAME,

                    "CreateFeature",

                    "Create Feature",

                    "The Create Feature fix creates a new polygon feature out "

                    + "of the error shape and removes the portion of "

                    + "overlap from each of the features, causing the "

                    + "error to create a planar representation of the "

                    + "feature geometry. This fix can be applied to "

                    + "one or more selected Must Not Overlap errors."

            );

        }

        @Override

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

            try {

                Geometry errorGeom = line.getError();

                TopologyDataSet dataSet = rule.getDataSet1();

                FeatureReference featRef1 = line.getFeature1();

                Feature feat1 = featRef1.getFeature();

                Geometry geom1 = feat1.getDefaultGeometry();

                FeatureReference featRef2 = line.getFeature2();

                Feature feat2 = featRef2.getFeature();

                Geometry geom2 = feat2.getDefaultGeometry();

                createNewFeature(featRef1, dataSet, errorGeom);

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

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

//                substract(featRef1, errorGeom, rule.getDataSet1());

//                substract(featRef2, errorGeom, rule.getDataSet1());

            } catch (Exception ex) {

                throw new ExecuteTopologyRuleActionException(ex);

            }

        }

    }

    private class SubtractAction extends AbstractTopologyRuleAction {

        public SubtractAction() {

            super(

                    MustNotOverlapPolygonRuleFactory.NAME,

                    "Subtract",

                    "Subtract",

                    "The Subtract fix removes the overlapping portion of "

                    + "geometry from 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 errors."

            );

        }

        @Override

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

            try {

                Geometry errorGeom = line.getError();

                TopologyDataSet dataSet = rule.getDataSet1();

                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.getDataSet1());

//                Geometry errorGeom = line.getError();

//                

//                FeatureReference featRef1 = line.getFeature1();

//                substract(featRef1, errorGeom, rule.getDataSet1());

//                

//                FeatureReference featRef2 = line.getFeature2();

//                substract(featRef2, errorGeom, rule.getDataSet1());

//                for (FeatureReference reference : dataSet.query(errorGeom)) {

//                    Feature initialFeature = reference.getFeature();

//                    Geometry initialFeatureGeom = initialFeature.getDefaultGeometry();

////                    initialFeature1.getEditable();

//                    if (initialFeatureGeom.intersects(errorGeom)) {

//                        Geometry targetFeatureGeom = initialFeatureGeom.difference(errorGeom);

//                        EditableFeature targetFeature = dataSet.createNewFeature();

//                        targetFeature.copyFrom(initialFeature);

//                        targetFeature.setDefaultGeometry(targetFeatureGeom);

//                        dataSet.insert(targetFeature);

//                        dataSet.delete(reference);

//                    }      

//                } 

            } catch (Exception ex) {

                throw new ExecuteTopologyRuleActionException(ex);

            }

        }

    }

    private class MergeAction extends AbstractTopologyRuleAction {

        public MergeAction() {

            super(

                    MustNotOverlapPolygonRuleFactory.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 error only."

            );

        }

        @Override

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

            try {

                Geometry errorGeom = line.getError();

                TopologyDataSet dataSet = rule.getDataSet1();

                FeatureReference featRef1 = line.getFeature1();

                Feature feat1 = featRef1.getFeature();

                Geometry geom1 = feat1.getDefaultGeometry();

                FeatureReference featRef2 = line.getFeature2();

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

//                Geometry errorGeom = line.getError();

//                

//                FeatureReference featRef2 = line.getFeature2();

//                substract(featRef2, errorGeom, rule.getDataSet1());

//                TopologyDataSet dataSet = rule.getDataSet1();

//                

//                Feature initialFeature1 = line.getFeature1().getFeature();

//                EditableFeature targetFeature1 = dataSet.createNewFeature();

//                targetFeature1.copyFrom(initialFeature1);

//                

//                Feature initialFeature2 = line.getFeature2().getFeature();

//                EditableFeature targetFeature2 = dataSet.createNewFeature();

//                targetFeature2.copyFrom(initialFeature2);

//                

//                Geometry initialFeature1Geom = initialFeature1.getDefaultGeometry();

////                Geometry targetFeature1Geom = initialFeature1Geom.union(errorGeom);

//                

//                Geometry initialFeature2Geom = initialFeature2.getDefaultGeometry();

//                Geometry targetFeature2Geom = initialFeature2Geom.difference(initialFeature1Geom);

//                

////                targetFeature1.setDefaultGeometry(targetFeature1Geom);

//                targetFeature2.setDefaultGeometry(targetFeature2Geom);

//                

////                dataSet.insert(targetFeature1);

//                dataSet.insert(targetFeature2);

//                

//                dataSet.delete(line.getFeature1());

//                dataSet.delete(line.getFeature2());

            } catch (Exception ex) {

                throw new ExecuteTopologyRuleActionException(ex);

            }

        }

    }

    private String geomName;

    private Expression expression = null;

    private GeometryExpressionBuilder expressionBuilder = null;

    public MustNotOverlapPolygonRule(

            TopologyPlan plan,

            TopologyRuleFactory factory,

            double tolerance,

            String dataSet1

    ) {

        super(plan, factory, tolerance, dataSet1);

        this.addAction(new CreateFetureAction());

        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 theDataSet = this.getDataSet1();

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

                for (FeatureReference otherReference : theDataSet.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))) {;

                        Geometry error = polygon.intersection(otherPolygon);

                        report.addLine(this,

                                theDataSet,

                                null,

                                polygon,

                                error,

                                feature1.getReference(),

                                otherReference,

                                false,

                                "The polygon overlay with others."

                        );

//                        break;

                    }

                }

            } 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 features = theDataSet.getFeatureStore().getFeatureSet(this.expression);

                for (Feature feature : features) {

                    if ( feature != null) {

                        Geometry otherPolygon = feature.getDefaultGeometry();

                        double halfTolerance = this.getTolerance()/2;

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

                            Geometry error = polygon.intersection(otherPolygon);

                            report.addLine(this,

                                    theDataSet,

                                    null,

                                    polygon,

                                    error,

                                    feature1.getReference(),

                                    feature.getReference(),

                                    false,

                                    "The polygon overlay with others."

                            );

                        }

                    }

                }

            }

        } catch (Exception ex) {

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

        } finally {

        }

    }

    private void substract(FeatureReference featRef, Geometry geomToSubstract, TopologyDataSet dataSet) throws DataException, GeometryOperationException, GeometryOperationNotSupportedException {

        Feature feat = featRef.getFeature();

        EditableFeature editFeat = feat.getEditable();

        Geometry geom = editFeat.getDefaultGeometry();

        Geometry diff = geom.difference(geomToSubstract);

        editFeat.setDefaultGeometry(diff);

        dataSet.update(editFeat);

    }

    private void createNewFeature(FeatureReference featRef, TopologyDataSet dataSet, Geometry errorGeom) throws DataException {

        Feature featureToCopyFrom = featRef.getFeature();

        EditableFeature targetFeature = dataSet.createNewFeature();

        targetFeature.copyFrom(featureToCopyFrom);

        targetFeature.setDefaultGeometry(errorGeom);

        dataSet.insert(targetFeature);

     }

}

/**

 * 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.dal.feature.Feature;

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.tools.dynobject.DynObject;

import org.gvsig.tools.task.SimpleTaskStatus;

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

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

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;

/**

 *

 * @author jjdelcerro

 */

@SuppressWarnings("UseSpecificCatch")

public class MustBeLargerThanToleranceLineRule extends AbstractTopologyRule {

    private class DeleteAction extends AbstractTopologyRuleAction {

        public DeleteAction() {

            super(

                MustBeLargerThanToleranceLineRuleFactory.NAME, 

                "delete", 

                "Delete", 

                "Removes line features that would collapse during the validate process based on the topology's tolerance."

            );

        }

        @Override

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

            try {

                TopologyDataSet dataset = line.getDataSet1();

                dataset.delete(line.getFeature1());

            } catch (Exception ex) {

                throw new ExecuteTopologyRuleActionException(ex);

            }

        }

    } 

    public MustBeLargerThanToleranceLineRule( 

            TopologyPlan plan,

            TopologyRuleFactory factory,

            double tolerance,

            String dataSet1,

            String dataSet2

    ) {

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

        this.addAction(new DeleteAction());

    }

    @Override

    public void check(SimpleTaskStatus taskStatus, TopologyReport report, Feature feature) throws Exception {

        Geometry geom = feature.getDefaultGeometry();

        if( geom.perimeter()<this.getTolerance() ) {

            report.addLine(this, this.getDataSet1(), null,

                    geom, null, feature.getReference(), null, false, 

                    "The length of the line is less than the specified tolerance"

            );

        }

    }

}

/**

 * 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.spi.AbstractTopologyRuleFactory;

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

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

/**

 *

 * @author jjdelcerro

 */

@SuppressWarnings("UseSpecificCatch")

public class ContainsPointRuleFactory extends AbstractTopologyRuleFactory {

    public static final String NAME = "ContainsPoint";

    public ContainsPointRuleFactory() {

        super(

                NAME, 

                "Contains Point", 

                "Requires that a polygon in one dataset contain at least one point from another dataset. Points must be within the polygon, not on the boundary. ", 

                new ListBuilder<Integer>()

                        .add(Geometry.TYPES.SURFACE)

                        .add(Geometry.TYPES.MULTISURFACE)

                        .asList(),

                new ListBuilder<Integer>()

                        .add(Geometry.TYPES.POINT)

                        .asList()

        );

    }

    @Override

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

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

        return rule;

    }    

    public static void selfRegister() {

        try {

            TopologyManager manager = TopologyLocator.getTopologyManager();

            manager.addRuleFactories(new ContainsPointRuleFactory());

        } catch(Exception ex) {

            LOGGER.warn("Can't register topology rule from ContainsPointRuleFactory.", 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.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.spi.AbstractTopologyRuleFactory;

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

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

/**

 *

 * @author jjdelcerro

 */

@SuppressWarnings("UseSpecificCatch")

public class ContainsNullRuleFactory extends AbstractTopologyRuleFactory {

    public static final String NAME = "ContainsNull";

    public ContainsNullRuleFactory() {

        super(

                NAME, 

                "Contains Null", 

                "Requires that no geometry has a null value", 

                new ListBuilder<Integer>()

                        .add(Geometry.TYPES.GEOMETRY)

                        .asList(),

                null

        );

    }

    @Override

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

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

        return rule;

    }    

    public static void selfRegister() {

        try {

            TopologyManager manager = TopologyLocator.getTopologyManager();

            manager.addRuleFactories(new ContainsNullRuleFactory());

        } catch(Exception ex) {

            LOGGER.warn("Can't register topology rule from ContainsNullRuleFactory.", 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.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.spi.AbstractTopologyRuleFactory;

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

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

/**

 *

 * @author jjdelcerro

 */

@SuppressWarnings("UseSpecificCatch")

public class MustNotOverlapPolygonRuleFactory extends AbstractTopologyRuleFactory {

    public static final String NAME = "MustNotOverlapPolygon";

    public MustNotOverlapPolygonRuleFactory() {

        super(

                NAME, 

                "Must Not Overlap", 

                "Requires that the interior of polygons in the dataset not overlap. The polygons can share edges or vertices. This rule is used when an area cannot belong to two or more polygons. It is useful for modeling administrative boundaries, such as ZIP Codes or voting districts, and mutually exclusive area classifications, such as land cover or landform type.", 

                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 MustNotOverlapPolygonRule(plan, this, tolerance, dataSet1);

        return rule;

    }    

    public static void selfRegister() {

        try {

            TopologyManager manager = TopologyLocator.getTopologyManager();

            manager.addRuleFactories(new MustNotOverlapPolygonRuleFactory());

        } catch(Exception ex) {

            LOGGER.warn("Can't register topology rule from MustNotOverlapPolygonRuleFactory.", 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.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.spi.AbstractTopologyRuleFactory;

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

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

/**

 *

 * @author jjdelcerro

 */

@SuppressWarnings("UseSpecificCatch")

public class MustBeLargerThanToleranceLineRuleFactory extends AbstractTopologyRuleFactory {

    public static final String NAME = "MustBeLargerThanToleranceLine";

    public MustBeLargerThanToleranceLineRuleFactory() {

        super(

                NAME, 

                "Must Be Larger Than Tolerance", 

                "Requires that a feature does not collapse during a validate process. This rule is mandatory for a topology and applies to all line feature classes. In instances where this rule is violated, the original geometry is left unchanged", 

                new ListBuilder<Integer>()

                        .add(Geometry.TYPES.CURVE)

                        .asList()

        );

    }

    @Override

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

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

        return rule;

    }

    public static void selfRegister() {

        try {

            TopologyManager manager = TopologyLocator.getTopologyManager();

            manager.addRuleFactories(new MustBeLargerThanToleranceLineRuleFactory());

        } catch(Exception ex) {

            LOGGER.warn("Can't register topology rule from MustBeLargerThanToleranceLineRuleFactory.", ex);

        }

    }

}