Application: gvSIG desktop » gvSIG legends: base legends

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">

    <modelVersion>4.0.0</modelVersion>

    <artifactId>org.gvsig.legend.urbanhorizontalsignage.lib.impl</artifactId>

    <name>org.gvsig.legend.urbanhorizontalsignage.lib.impl</name>

    <parent>

        <groupId>org.gvsig</groupId>

        <artifactId>org.gvsig.legend.urbanhorizontalsignage.lib</artifactId>

        <version>1.0.96</version>

    </parent>

    <groupId>org.gvsig</groupId>

    <dependencies>

        <dependency>

            <groupId>org.gvsig</groupId>

            <artifactId>org.gvsig.legend.urbanhorizontalsignage.lib.api</artifactId>

            <scope>compile</scope>

        </dependency>

        <dependency>

            <groupId>org.gvsig</groupId>

            <artifactId>org.gvsig.fmap.dal.api</artifactId>

            <scope>compile</scope>

        </dependency>

        <dependency>

            <groupId>org.gvsig</groupId>

            <artifactId>org.gvsig.symbology.lib.impl</artifactId>

            <scope>compile</scope>

        </dependency>

        <dependency>

            <groupId>org.gvsig</groupId>

            <artifactId>org.gvsig.ui</artifactId>

            <scope>compile</scope>

        </dependency>

        <dependency>

            <groupId>org.gvsig</groupId>

            <artifactId>org.gvsig.fmap.dal.impl</artifactId>

            <scope>test</scope>

        </dependency>

        <dependency>

            <groupId>org.gvsig</groupId>

<!--

            <artifactId>${org.gvsig.h2spatial.provider}</artifactId>

-->

            <artifactId>org.gvsig.h2spatial.h2gis132.provider</artifactId>

            <scope>test</scope>

        </dependency>

        <dependency>

            <groupId>org.gvsig</groupId>

            <artifactId>${org.gvsig.fmap.geometry.impl}</artifactId>

            <scope>test</scope>

        </dependency>    

        <dependency>

            <groupId>org.gvsig</groupId>

            <artifactId>org.gvsig.expressionevaluator.lib.impl</artifactId>

            <scope>test</scope>

        </dependency>    

        <dependency>

            <groupId>org.gvsig</groupId>

            <artifactId>org.gvsig.expressionevaluator.geometry.lib.impl</artifactId>

            <scope>test</scope>

        </dependency>    

        <dependency>

            <groupId>org.gvsig</groupId>

            <artifactId>${org.gvsig.proj.lib.impl}</artifactId>

            <scope>test</scope>

        </dependency>

        <dependency>

            <groupId>org.gvsig</groupId>

            <artifactId>org.gvsig.compat.se</artifactId>

            <scope>test</scope>

        </dependency>

        <dependency>

            <groupId>org.gvsig</groupId>

            <artifactId>org.gvsig.metadata.lib.basic.impl</artifactId>

            <scope>test</scope>

        </dependency>      

        <dependency>

            <groupId>org.gvsig</groupId>

            <artifactId>org.gvsig.timesupport.lib.impl</artifactId>

            <scope>test</scope>

        </dependency>

        <dependency>

            <groupId>org.gvsig</groupId>

            <artifactId>org.gvsig.fmap.dal.file.csv</artifactId>

            <scope>test</scope>

        </dependency>

        <dependency>

            <groupId>org.gvsig</groupId>

            <artifactId>org.gvsig.tools.util.impl</artifactId>

            <scope>test</scope>

        </dependency>

        <dependency>

            <groupId>org.gvsig</groupId>

            <artifactId>org.gvsig.tools.swing.impl</artifactId>

            <scope>test</scope>

        </dependency>

        <dependency>

            <groupId>org.gvsig</groupId>

            <artifactId>org.gvsig.fmap.dal.db.jdbc</artifactId>

            <scope>compile</scope>

        </dependency>

    </dependencies>

</project>

package org.gvsig.legend.urbanhorizontalsignage.lib.impl;

import org.gvsig.legend.urbanhorizontalsignage.lib.impl.linelegend.SplittedLine;

import java.util.List;

import junit.framework.TestCase;

import org.gvsig.fmap.geom.GeometryUtils;

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

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

import org.gvsig.legend.urbanhorizontalsignage.lib.api.linelegend.UrbanHorizontalSignageData;

import org.gvsig.legend.urbanhorizontalsignage.lib.api.UrbanHorizontalSignageLocator;

import org.gvsig.tools.library.impl.DefaultLibrariesInitializer;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

public class Test01CalculateGeometries extends TestCase {

    private static final Logger LOGGER = LoggerFactory.getLogger(Test01CalculateGeometries.class);

    public Test01CalculateGeometries(String testName) {

        super(testName);

    }

    @Override

    protected void setUp() throws Exception {

        super.setUp();

        new DefaultLibrariesInitializer().fullInitialize();

    }

    @Override

    protected void tearDown() throws Exception {

        super.tearDown();

    }

    // TODO add test methods here. The name must begin with 'test'. For example:

    // public void testHello() {}

    public void test01CalculateIntermediatePoint() {

        final String testid = "calculateIntermediatePoint";

        Point p1 = GeometryUtils.createPoint(0,0);

        Point p2 = GeometryUtils.createPoint(10,0);

        DefaultUrbanHorizontalSignageManager uhsManager = (DefaultUrbanHorizontalSignageManager)UrbanHorizontalSignageLocator.getUrbanHorizontalSignageManager();

        try {

            for (double lambda = 0; lambda <= 1; lambda += 0.1) {

                Point intermediatePoint = uhsManager.calculateIntermediatePoint(p1, p2, lambda);

                assertEquals(10*lambda, intermediatePoint.getCoordinateAt(0));

                assertEquals(0.0, intermediatePoint.getCoordinateAt(1));

            }

        } catch (Exception ex) {

            //TODO:

            fail(ex.getMessage());

        }

    }

    public void test02SplitLine() throws Exception {

        final String testid = "splitLine";

        Point p1 = GeometryUtils.createPoint(0,0);

        Point p2 = GeometryUtils.createPoint(10,0);

        Line line = GeometryUtils.createLine(p1, p2, 0);

        DefaultUrbanHorizontalSignageManager uhsManager = (DefaultUrbanHorizontalSignageManager)UrbanHorizontalSignageLocator.getUrbanHorizontalSignageManager();

//        UrbanHorizontalSignageData data = uhsManager.createUrbanHorizontalSignageData();

//        data.setWidth(20);

//        data.setContinuity(UrbanHorizontalSignageData.DEFAULT_CONTINUITY_VALUE);

//        data.setSegmentsLength(100);

//        data.setHolesLength(50);

//        data.setGapWith(10);

//        data.setSegmentsColor(Color.RED);

//        data.setHolesColor(Color.BLACK);

//        data.setRoundVertex(false);

//        data.setPaintHoles(true);

        SplittedLine splittedLine = uhsManager.splitLine(line, 1, 0.5);

        List<Line> segments = splittedLine.getSegments();

        List<Line> holes = splittedLine.getHoles();

        assertEquals(7, segments.size());

        assertEquals(6, holes.size());

        double x = 0;

        for (Line segment : segments) {

            assertEquals(x, segment.getVertex(0).getX());

            assertEquals(x+1.0, segment.getVertex(1).getX());

            x += 1.50;

        }

        x = 1.0;

        for (Line hole : holes) {

            assertEquals(x, hole.getVertex(0).getX());

            assertEquals(x+0.5, hole.getVertex(1).getX());

            x += 1.50;

        }

    }

}

<?xml version="1.0"?>

<definitions>

    <version>1.0.0</version>

    <classes>

        <class name="DefaultUrbanHorizontalSignageLegend">

            <extends>

                <class name="VectorialLegend" namespace="persistence"/>

            </extends>

            <fields>

                <field name="config" type="Object" ClassOfValue="org.gvsig.legend.urbanhorizontalsignage.lib.api.linelegend.UrbanHorizontalSignageConfig" mandatory="false">

                    <description></description>

                </field>

            </fields>

        </class>

        <class name="DefaultUrbanHorizontalSignageConfig">

            <extends>

            </extends>

            <fields>

                <field name="widthFieldName" type="String" defaultValue="">

                    <description></description>

                </field>

                <field name="continuityFieldName" type="String" defaultValue="">

                    <description></description>

                </field>

                <field name="segmentsColorFieldName" type="String" defaultValue="">

                    <description></description>

                </field>

                <field name="segmentsLengthFieldName" type="String" defaultValue="">

                    <description></description>

                </field>

                <field name="holesLengthFieldName" type="String" defaultValue="">

                    <description></description>

                </field>

                <field name="paintHolesFieldName" type="String" defaultValue="">

                    <description></description>

                </field>

                <field name="holesColorFieldName" type="String" defaultValue="">

                    <description></description>

                </field>

                <field name="roundVertexFieldName" type="String" defaultValue="">

                    <description></description>

                </field>

                <field name="gapWidth" type="Integer" defaultValue="15">

                    <description></description>

                </field>

            </fields>

        </class>

        <class name="UrbanHorizontalSignageSymbol">

            <extends>

                <class name="Symbol" namespace="persistence"/>

            </extends>

            <fields>

                <field name="width" type="Double" defaultValue="0.15" mandatory="false">

                    <description></description>

                </field>

                <field name="continuity" type="Integer" defaultValue="1" mandatory="false">

                    <description></description>

                </field>

                <field name="segmentsColor" type="Object" ClassOfValue="java.awt.Color" defaultValue="blue" mandatory="false">

                    <description></description>

                </field>

                <field name="segmentsLength" type="Double" defaultValue="0.5" mandatory="false">

                    <description></description>

                </field>

                <field name="holesColor" type="Object" ClassOfValue="java.awt.Color" defaultValue="black" mandatory="false">

                    <description></description>

                </field>

                <field name="holesLength" type="Double" defaultValue="0.5" mandatory="false">

                    <description></description>

                </field>

                <field name="paintHoles" type="Boolean" defaultValue="false" mandatory="false">

                    <description></description>

                </field>

                <field name="gapWidth" type="Double" defaultValue="0.15" mandatory="false">

                    <description></description>

                </field>

                <field name="roundVertex" type="Boolean" defaultValue="false" mandatory="false">

                    <description></description>

                </field>

                <field name="transparency" type="Double" defaultValue="1.0" mandatory="false">

                    <description></description>

                </field>

                <field name="mustDrawOriginalGeometry" type="Boolean" defaultValue="false" mandatory="false">

                    <description></description>

                </field>

                <field name="colorForOriginalGeometry" type="Object" ClassOfValue="java.awt.Color" defaultValue="yellow" mandatory="false">

                    <description></description>

                </field>

            </fields>

        </class>

    </classes>

</definitions>

org.gvsig.legend.urbanhorizontalsignage.lib.impl.UrbanHorizontalSignageLibraryImpl

/* gvSIG. Desktop Geographic Information System.

 *

 * Copyright ? 2007-2015 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 2

 * 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.legend.urbanhorizontalsignage.lib.impl;

import org.gvsig.legend.urbanhorizontalsignage.lib.impl.linelegend.DefaultUrbanHorizontalSignageLegend;

import org.gvsig.legend.urbanhorizontalsignage.lib.impl.linelegend.DefaultUrbanHorizontalSignageData;

import org.gvsig.legend.urbanhorizontalsignage.lib.impl.linelegend.SplittedLine;

import java.io.File;

import java.util.Iterator;

import java.util.List;

import java.util.UUID;

import org.apache.commons.lang3.StringUtils;

import org.gvsig.fmap.dal.DALLocator;

import org.gvsig.fmap.dal.DataManager;

import org.gvsig.fmap.dal.DataStoreParameters;

import org.gvsig.fmap.dal.exception.DataException;

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

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

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

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

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

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

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

import org.gvsig.fmap.dal.store.jdbc.JDBCNewStoreParameters;

import org.gvsig.fmap.dal.store.jdbc.JDBCServerExplorerParameters;

import org.gvsig.fmap.dal.store.jdbc2.JDBCServerExplorer;

import org.gvsig.fmap.geom.DataTypes;

import org.gvsig.fmap.geom.Geometry;

import static org.gvsig.fmap.geom.Geometry.JOIN_STYLE_MITRE;

import static org.gvsig.fmap.geom.Geometry.JOIN_STYLE_ROUND;

import org.gvsig.fmap.geom.GeometryLocator;

import org.gvsig.fmap.geom.GeometryManager;

import org.gvsig.fmap.geom.GeometryUtils;

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

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

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

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

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

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

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

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

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

import org.gvsig.legend.urbanhorizontalsignage.lib.api.linelegend.UrbanHorizontalSignageConfig;

import org.gvsig.legend.urbanhorizontalsignage.lib.api.linelegend.UrbanHorizontalSignageData;

import static org.gvsig.legend.urbanhorizontalsignage.lib.api.linelegend.UrbanHorizontalSignageData.CONTINUITY_MODE_CONT;

import static org.gvsig.legend.urbanhorizontalsignage.lib.api.linelegend.UrbanHorizontalSignageData.CONTINUITY_MODE_CONT_CONT;

import static org.gvsig.legend.urbanhorizontalsignage.lib.api.linelegend.UrbanHorizontalSignageData.CONTINUITY_MODE_CONT_DISC;

import static org.gvsig.legend.urbanhorizontalsignage.lib.api.linelegend.UrbanHorizontalSignageData.CONTINUITY_MODE_DISC;

import static org.gvsig.legend.urbanhorizontalsignage.lib.api.linelegend.UrbanHorizontalSignageData.CONTINUITY_MODE_DISC_CONT;

import static org.gvsig.legend.urbanhorizontalsignage.lib.api.linelegend.UrbanHorizontalSignageData.CONTINUITY_MODE_DISC_DISC;

import org.gvsig.legend.urbanhorizontalsignage.lib.api.linelegend.UrbanHorizontalSignageLegend;

import org.gvsig.legend.urbanhorizontalsignage.lib.api.UrbanHorizontalSignageLocator;

import org.gvsig.legend.urbanhorizontalsignage.lib.api.UrbanHorizontalSignageManager;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.folders.FoldersManager;

import org.gvsig.tools.task.SimpleTaskStatus;

import org.gvsig.tools.util.HasAFile;

import org.slf4j.LoggerFactory;

@SuppressWarnings("UseSpecificCatch")

public class DefaultUrbanHorizontalSignageManager implements UrbanHorizontalSignageManager {

    private static final org.slf4j.Logger LOGGER = LoggerFactory.getLogger(DefaultUrbanHorizontalSignageManager.class);

    @Override

    public UrbanHorizontalSignageLegend createUrbanHorizontalSignageLegend() {

        return new DefaultUrbanHorizontalSignageLegend();

    }

    @Override

    public Class<? extends UrbanHorizontalSignageLegend> getUrbanHorizontalSignageLegendClass() {

        return DefaultUrbanHorizontalSignageLegend.class;

    }

    @Override

    public UrbanHorizontalSignageData createUrbanHorizontalSignageData() {

        return new DefaultUrbanHorizontalSignageData();

    }

    @Override

    public void calculateGeometries(Geometry originalGeometry, UrbanHorizontalSignageData data) {

        GeometryManager geomManager = GeometryLocator.getGeometryManager();

        try {

            MultiPolygon segments = geomManager.createMultiPolygon(originalGeometry.getGeometryType().getSubType());

            MultiPolygon holes = geomManager.createMultiPolygon(originalGeometry.getGeometryType().getSubType());

            MultiLine lineSegments = geomManager.createMultiLine(originalGeometry.getGeometryType().getSubType());

            MultiLine lineHoles = geomManager.createMultiLine(originalGeometry.getGeometryType().getSubType());

            MultiLine lines = originalGeometry.toLines();

            final double offsetValueInMeters = Math.abs(data.getGapWidth() / 2.0 + data.getWidth() / 2.0);

            final double bufferValueInMeters = Math.abs(data.getWidth() / 2.0);

            for (Geometry geom : lines) {

                Line line = (Line) geom;

                switch (data.getContinuity()) {

                    case CONTINUITY_MODE_CONT:

                    default:

                        Geometry buffer = line.buffer(

                                bufferValueInMeters,

                                data.isRoundVertex() ? JOIN_STYLE_ROUND : JOIN_STYLE_MITRE,

                                true

                        );

                        if (buffer != null) {

                            segments.addPrimitives(buffer);

                            lineSegments.addPrimitives(line);

                        }

                        break;

                    case CONTINUITY_MODE_DISC:

                        SplittedLine splittedLine = splitLine(line, data.getSegmentsLength(), data.getHolesLength());

                        List<Line> splittedSegments = splittedLine.getSegments();

                        List<Line> splittedHoles = splittedLine.getHoles();

                        for (Line segment : splittedSegments) {

                            buffer = segment.buffer(bufferValueInMeters,

                                    data.isRoundVertex() ? JOIN_STYLE_ROUND : JOIN_STYLE_MITRE,

                                    true

                            );

                            if (buffer != null) {

                                segments.addPrimitives(buffer);

                                lineSegments.addPrimitives(segment);

                            }

                        }

                        for (Line hole : splittedHoles) {

                            buffer = hole.buffer(

                                    bufferValueInMeters,

                                    data.isRoundVertex() ? JOIN_STYLE_ROUND : JOIN_STYLE_MITRE,

                                    true

                            );

                            if (buffer != null) {

                                holes.addPrimitives(buffer);

                                lineHoles.addPrimitives(hole);

                            }

                        }

                        break;

                    case CONTINUITY_MODE_CONT_CONT:

                        //Left

                        addOffsetedAndBufferedSegment(segments, lineSegments, line, offsetValueInMeters, bufferValueInMeters, data.isRoundVertex());

                        //Right

                        addOffsetedAndBufferedSegment(segments, lineSegments, line, -offsetValueInMeters, bufferValueInMeters, data.isRoundVertex());

                        break;

                    case CONTINUITY_MODE_CONT_DISC:

                        //Left

                        addOffsetedAndBufferedSegment(segments, lineSegments, line, offsetValueInMeters, bufferValueInMeters, data.isRoundVertex());

                        //Right

                        splittedLine = splitLine(line, data.getSegmentsLength(), data.getHolesLength());

                        splittedSegments = splittedLine.getSegments();

                        splittedHoles = splittedLine.getHoles();

                        for (Line segment : splittedSegments) {

                            addOffsetedAndBufferedSegment(segments, lineSegments, segment, -offsetValueInMeters, bufferValueInMeters, true);

                        }

                        for (Line hole : splittedHoles) {

                            addOffsetedAndBufferedSegment(holes, lineHoles, hole, -offsetValueInMeters, bufferValueInMeters, true);

                        }

                        break;

                    case CONTINUITY_MODE_DISC_CONT:

                        //Left

                        splittedLine = splitLine(line, data.getSegmentsLength(), data.getHolesLength());

                        splittedSegments = splittedLine.getSegments();

                        splittedHoles = splittedLine.getHoles();

                        for (Line segment : splittedSegments) {

                            addOffsetedAndBufferedSegment(segments, lineSegments, segment, offsetValueInMeters, bufferValueInMeters, true);

                        }

                        for (Line hole : splittedHoles) {

                            addOffsetedAndBufferedSegment(holes, lineHoles, hole, offsetValueInMeters, bufferValueInMeters, true);

                        }

                        //Right

                        addOffsetedAndBufferedSegment(segments, lineSegments, line, -offsetValueInMeters, bufferValueInMeters, data.isRoundVertex());

                        break;

                    case CONTINUITY_MODE_DISC_DISC:

                        splittedLine = splitLine(line, data.getSegmentsLength(), data.getHolesLength());

                        splittedSegments = splittedLine.getSegments();

                        splittedHoles = splittedLine.getHoles();

                        //Left

                        for (Line segment : splittedSegments) {

                            addOffsetedAndBufferedSegment(segments, lineSegments, segment, offsetValueInMeters, bufferValueInMeters, true);

                        }

                        for (Line hole : splittedHoles) {

                            addOffsetedAndBufferedSegment(holes, lineHoles, hole, offsetValueInMeters, bufferValueInMeters, true);

                        }

                        //Right

                        for (Line segment : splittedSegments) {

                            addOffsetedAndBufferedSegment(segments, lineSegments, segment, -offsetValueInMeters, bufferValueInMeters, true);

                        }

                        for (Line hole : splittedHoles) {

                            addOffsetedAndBufferedSegment(holes, lineHoles, hole, -offsetValueInMeters, bufferValueInMeters, true);

                        }

                        break;

                }

            }

            data.setSegmentsGeometry(segments);

            data.setHolesGeometry(holes);

            data.setLineSegmentsGeometry(lineSegments);

            data.setLineHolesGeometry(lineHoles);

        } catch (Exception ex) {

            LOGGER.warn("Can't calculate geometries.", ex);

//            Logger.getLogger(DefaultUrbanHorizontalSignageManager.class.getName()).log(Level.SEVERE, null, ex);

        }

    }

    protected void addOffsetedAndBufferedSegment(MultiPolygon segments, MultiLine lineSegments, Line segment, final double offsetValueInMeters, final double bufferValueInMeters, boolean roundVertex) throws GeometryOperationException, GeometryOperationNotSupportedException {

        Geometry buffer;

        final int joinStyle = roundVertex ? JOIN_STYLE_ROUND : JOIN_STYLE_MITRE;

        Geometry segmentOffset;

        if (segment.isClosed() && segment.getNumVertices() > 2 && segment.isCCW()) {

            Line cloned = segment.cloneGeometry();

            cloned.flip();

            segmentOffset = cloned.offset(

                    joinStyle,

                    -offsetValueInMeters

            );

        } else {

            segmentOffset = segment.cloneGeometry().offset(

                    joinStyle,

                    offsetValueInMeters

            );

        }

        if (segmentOffset == null) {

            return;

        }

        buffer = segmentOffset.buffer(bufferValueInMeters, joinStyle,

                true

        );

        if (buffer != null) {

            segments.addPrimitives(buffer);

            lineSegments.addPrimitives(segmentOffset);

        }

    }

    /*

        segmentLength & holesLenght in meters

     */

 /*friend*/

    SplittedLine splitLine(Line line, double segmentLength, double holesLength) throws CreateGeometryException, GeometryOperationNotSupportedException, GeometryOperationException, CloneNotSupportedException {

        GeometryManager geomManager = GeometryLocator.getGeometryManager();

        SplittedLine res = new SplittedLine();

        Point previousPoint = null;

        double previousLength = 0;

        Line currentSegment = geomManager.createLine(line.getGeometryType().getSubType());

        boolean isHole = false;

        boolean advanceToNext = true;

        Point currentPoint = null;

        Iterator<Point> it = line.iterator();

        while (it.hasNext() || !advanceToNext) {

            if (advanceToNext) {

                currentPoint = it.next();

            }

            if (previousPoint == null) {

                previousPoint = currentPoint.clone();

                currentSegment.addVertex(previousPoint);

                advanceToNext = true;

                continue;

            }

            double distance = previousPoint.distance(currentPoint);

            if (!isHole) {

                if (previousLength + distance < segmentLength) {

                    previousLength += distance;

                    if (distance > 0.0) {

                        currentSegment.addVertex(currentPoint);

                    }

                    previousPoint = currentPoint.cloneGeometry();

                    advanceToNext = true;

//                    continue;

                } else {

                    //buscar punto dentro del segmento a una distancia = segmentLengthMeters-previousLength

                    Point point = calculateIntermediatePoint(previousPoint, currentPoint, (segmentLength - previousLength) / distance);

                    //agregarlo al currentSegment,

                    currentSegment.addVertex(point);

                    //agregar  el currentSegment a la lista de segmentos

                    res.addSegment(currentSegment.cloneGeometry());

                    //crear un nuevo currentSegment y meter el punto como primero

                    currentSegment = geomManager.createLine(line.getGeometryType().getSubType());

                    currentSegment.addVertex(point);

                    //cambiar modo ==> isHole = true

                    isHole = !isHole;

                    previousPoint = point.clone();

                    previousLength = 0;

                    advanceToNext = false;

//                    continue;

                }

            } else {

                if (previousLength + distance < holesLength) {

                    previousLength += distance;

                    if (distance > 0.0) {

                        currentSegment.addVertex(currentPoint);

                    }

                    previousPoint = currentPoint.cloneGeometry();

                    advanceToNext = true;

//                    continue;

                } else {

                    //buscar punto dentro del segmento a una distancia = segmentLengthMeters-previousLength

                    Point point = calculateIntermediatePoint(previousPoint, currentPoint, (holesLength - previousLength) / distance);

                    //agregarlo al currentSegment,

                    currentSegment.addVertex(point);

                    //agregar  el surrentSegment a la lista de segmentos

                    res.addHole(currentSegment.cloneGeometry());

                    //crear un nuevo currentSegment y meter el punto como primero

                    currentSegment = geomManager.createLine(line.getGeometryType().getSubType());

                    currentSegment.addVertex(point);

                    //Cambiar modo Segment <==> Hole

                    isHole = !isHole;

                    previousPoint = point.clone();

                    previousLength = 0;

                    advanceToNext = false;

//                    continue;

                }

            }

        }

        if (currentSegment.getNumVertices() > 1) {

            if (isHole) {

                res.addHole(currentSegment.cloneGeometry());

            } else {

                res.addSegment(currentSegment.cloneGeometry());

            }

        }

        return res;

    }

    /**

     * @deprecated

     * use {@link GeometryUtils.calculateLambdaPoint}

     * 

     * @param p1

     * @param p2

     * @param lambda

     * @return

     * @throws CreateGeometryException

     * @throws GeometryOperationNotSupportedException

     * @throws GeometryOperationException

     * @deprecated

     */

    @Deprecated 

    Point calculateIntermediatePoint(Point p1, Point p2, double lambda) throws CreateGeometryException, GeometryOperationNotSupportedException, GeometryOperationException {

        GeometryManager geomManager = GeometryLocator.getGeometryManager();

        GeometryType geomType = p1.getGeometryType();

        int subtype = geomType.getSubType();

        int dimension = geomType.getDimension();

        double[] coords = new double[dimension];

        Point p = geomManager.createPoint(0, 0, subtype);

        double distance = p1.distance(p2);

        for (int d = 0; d < dimension; d++) {

            p.setCoordinateAt(

                    d,

                    p1.getCoordinateAt(d) + (p2.getCoordinateAt(d) - p1.getCoordinateAt(d)) * lambda);

        }

        return p;

    }

    @Override

    public FeatureStore createTemporaryPolygonsFromLines(UrbanHorizontalSignageConfig config, FeatureSet lines, SimpleTaskStatus status) {

        //TODO: el status....

        UrbanHorizontalSignageManager uhsManager = UrbanHorizontalSignageLocator.getUrbanHorizontalSignageManager();

        EditableFeatureType targetFeatureType = createTargetFeatureType(lines.getFeatureStore());

        FeatureStore targetStore = createTemporalStore(targetFeatureType);

        try {

            targetStore.edit(FeatureStore.MODE_APPEND);

            for (Feature feature : lines) {

                Geometry originalGeometry = feature.getDefaultGeometry();

                UrbanHorizontalSignageData data = config.getValues(feature);

                uhsManager.calculateGeometries(originalGeometry, data);

                MultiPolygon multiGeom = data.getSegmentsGeometry();

                MultiLine multiLine = data.getLineSegmentsGeometry();

                insertPolygonsOfLine(multiGeom, multiLine, targetStore, feature, config, config.getSegmentsColorFieldName());

                switch (data.getContinuity()) {

                    case CONTINUITY_MODE_CONT_DISC:

                    case CONTINUITY_MODE_DISC_CONT:

                    case CONTINUITY_MODE_DISC:

                    case CONTINUITY_MODE_DISC_DISC:

                        if (data.isPaintHoles()) {

                            multiGeom = data.getHolesGeometry();

                            multiLine = data.getLineHolesGeometry();

                            insertPolygonsOfLine(multiGeom, multiLine, targetStore, feature, config, config.getHolesColorFieldName());

                        }

                }

            }

            targetStore.finishEditing();

            return targetStore;

        } catch (Exception e) {

            LOGGER.debug("Can't create temporary polygons store.", e);

        }

        return null;

    }

    private void insertPolygonsOfLine(MultiPolygon multiGeom, MultiLine multiLine, FeatureStore targetStore, Feature feature, UrbanHorizontalSignageConfig config, String colorFieldName) throws GeometryOperationNotSupportedException, GeometryOperationException, DataException {

        if (multiGeom != null && multiGeom.getPrimitivesNumber() > 0) {

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

                Polygon polygon = (Polygon) multiGeom.getPrimitiveAt(i);

                Line line = (Line) multiLine.getPrimitiveAt(i);

                EditableFeature targetFeature = targetStore.createNewFeature();

                targetFeature.copyFrom(feature, (FeatureAttributeDescriptor t) -> !(t.isPrimaryKey() || (t.isIndexed() && !t.allowIndexDuplicateds()) || t.getType() == DataTypes.GEOMETRY));

                if (StringUtils.isNotBlank(config.getTargetColorFieldName())) {

                    targetFeature.set(config.getTargetColorFieldName(), feature.get(colorFieldName));

                }

                if (StringUtils.isNotBlank(config.getTargetLenghtFieldName())) {

                    targetFeature.set(config.getTargetLenghtFieldName(), line.perimeter());

                }

                if (StringUtils.isNotBlank(config.getTargetAreaFieldName())) {

                    targetFeature.set(config.getTargetAreaFieldName(), polygon.area());

                }

                targetFeature.setDefaultGeometry(polygon);

                targetStore.insert(targetFeature);

            }

        }

    }

    private EditableFeatureType createTargetFeatureType(FeatureStore store) {

        DataManager dataManager = DALLocator.getDataManager();

        EditableFeatureType featureType = dataManager.createFeatureType();

        featureType.addAll(store.getDefaultFeatureTypeQuietly());

        for (FeatureAttributeDescriptor attr : featureType) {

            EditableFeatureAttributeDescriptor eattr = (EditableFeatureAttributeDescriptor) attr;

            eattr.setIsPrimaryKey(false);

            eattr.setIsIndexed(false);

            eattr.setAllowNull(true);

        }

        EditableFeatureAttributeDescriptor attr = (EditableFeatureAttributeDescriptor) featureType.getDefaultGeometryAttribute();

        attr.setGeometryType(Geometry.TYPES.POLYGON, Geometry.SUBTYPES.GEOM2D);

        return featureType;

    }

    private FeatureStore createTemporalStore(EditableFeatureType featType) {

        if (featType.getStore() != null) {

            throw new IllegalArgumentException("Can't create temporal store from a feature type of a already existent store.");

        }

        try {

            // crear ruta de archivo temporal

            FoldersManager foldersManager = ToolsLocator.getFoldersManager();

            File tempFile = foldersManager.getUniqueTemporaryFile("urbanHorizontalSignage_temporal_store_" + UUID.randomUUID().toString());

            // crear SERVER STORE

            DataManager dataManager = DALLocator.getDataManager();

            JDBCServerExplorerParameters serverParameters = (JDBCServerExplorerParameters) dataManager.createServerExplorerParameters("H2Spatial");

            ((HasAFile) serverParameters).setFile(tempFile);

            JDBCServerExplorer serverExplorer = (JDBCServerExplorer) dataManager.openServerExplorer("H2Spatial", serverParameters);

            //Crear tablas en server store

            JDBCNewStoreParameters parametersResults = serverExplorer.getAddParameters();

            parametersResults.setDynValue("Table", "results");

            parametersResults.setDefaultFeatureType(featType);

            serverExplorer.add("H2Spatial", parametersResults, true);

            DataStoreParameters storeParametersResults = dataManager.createStoreParameters("H2Spatial");

            storeParametersResults.setDynValue("database_file", tempFile);

            storeParametersResults.setDynValue("Table", "results");

            //Creaci?n del store con los resultados

            FeatureStore storeResults = (FeatureStore) dataManager.openStore("H2Spatial", storeParametersResults);

            return storeResults;

        } catch (Exception ex) {

            LOGGER.debug("Can't create temporal store.", ex);

            return null;

        }

    }

    @Override

    public void convertLinesToPolygons(

            UrbanHorizontalSignageConfig config,

            FeatureSet source,

            FeatureStore targetStore,

            boolean deleteSourceAtFinish,

            SimpleTaskStatus status

    ) {

        boolean needFinishEditing = !(targetStore.isEditing() || targetStore.isAppending());

        try {

            if (needFinishEditing) {

                targetStore.edit();

            }

            for (Feature feature : source) {

                Geometry geom = feature.getDefaultGeometry();

                UrbanHorizontalSignageData data = config.getValues(feature);

                calculateGeometries(geom, data);

                MultiPolygon multiGeom = data.getSegmentsGeometry();

                MultiLine multiLine = data.getLineSegmentsGeometry();

                insertPolygonsOfLine(multiGeom, multiLine, targetStore, feature, config, config.getSegmentsColorFieldName());

                switch (data.getContinuity()) {

                    case CONTINUITY_MODE_CONT_DISC:

                    case CONTINUITY_MODE_DISC_CONT:

                    case CONTINUITY_MODE_DISC:

                    case CONTINUITY_MODE_DISC_DISC:

                        if (data.isPaintHoles()) {

                            multiGeom = data.getHolesGeometry();

                            multiLine = data.getLineHolesGeometry();

                            insertPolygonsOfLine(multiGeom, multiLine, targetStore, feature, config, config.getHolesColorFieldName());

                        }

                }

            }

            if (needFinishEditing) {

                targetStore.finishEditing();

            }

        } catch (Exception ex) {

            FeatureStore.cancelEditingQuietly(targetStore);

            throw new RuntimeException("Can't convert lines to polygons\n"+ex.getLocalizedMessage(), ex);

        }

        if (deleteSourceAtFinish) {

            FeatureStore sourceStore = null;

            try {

                sourceStore = source.getFeatureStore();

                needFinishEditing = !(sourceStore.isEditing() || sourceStore.isAppending());

                if (needFinishEditing) {

                    sourceStore.edit();

                }

                for (Feature feature : source) {

                    source.delete(feature);

                }

                if (needFinishEditing) {

                    sourceStore.finishEditing();

                }

            } catch (Exception ex) {

                FeatureStore.cancelEditingQuietly(sourceStore);

                throw new RuntimeException("Can't delete source lines", ex);

            }

        }

    }

}

/**

 * gvSIG. Desktop Geographic Information System.

 *

 * Copyright ? 2007-2015 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 2

 * 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.legend.urbanhorizontalsignage.lib.impl;

import org.gvsig.legend.urbanhorizontalsignage.lib.impl.linelegend.DefaultUrbanHorizontalSignageLegend;

import org.gvsig.legend.urbanhorizontalsignage.lib.impl.linelegend.UrbanHorizontalSignageSymbol;

import org.gvsig.legend.urbanhorizontalsignage.lib.impl.linelegend.DefaultUrbanHorizontalSignageConfig;

import java.io.InputStream;

import java.util.Map;

import org.gvsig.fmap.mapcontext.MapContextLibrary;

import org.gvsig.fmap.mapcontext.MapContextLocator;

import org.gvsig.fmap.mapcontext.MapContextManager;

import org.gvsig.legend.urbanhorizontalsignage.lib.api.UrbanHorizontalSignageLibrary;

import org.gvsig.legend.urbanhorizontalsignage.lib.api.UrbanHorizontalSignageLocator;

import org.gvsig.symbology.impl.SymbologyDefaultImplLibrary;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dynobject.DynStruct;

import org.gvsig.tools.library.AbstractLibrary;

import org.gvsig.tools.library.LibraryException;

import org.gvsig.tools.persistence.PersistenceManager;

public class UrbanHorizontalSignageLibraryImpl extends AbstractLibrary {

    @Override

    public void doRegistration() {

        registerAsImplementationOf(UrbanHorizontalSignageLibrary.class);

        this.require(MapContextLibrary.class);

        this.require(SymbologyDefaultImplLibrary.class);

    }

    @Override

    protected void doInitialize() throws LibraryException {

        UrbanHorizontalSignageLocator.registerUrbanHorizontalSignageManager(DefaultUrbanHorizontalSignageManager.class);

        MapContextManager mcmanager = MapContextLocator.getMapContextManager();

        mcmanager.registerLegend("UrbanHorizontalSignageLegend", DefaultUrbanHorizontalSignageLegend.class);

    }

    @Override

    protected void doPostInitialize() throws LibraryException {

        PersistenceManager persistenceManager = ToolsLocator.getPersistenceManager();

        InputStream is = this.getClass().getResourceAsStream("UrbanHorizontalSignagePersistence.xml");

        Map<String,DynStruct> definitions;

        try {

            definitions = ToolsLocator.getDynObjectManager().importDynClassDefinitions(is, this.getClass().getClassLoader());

        } catch (Exception ex) {

            throw new LibraryException(this.getClass(), ex);

        }

        persistenceManager.addDefinition(

                DefaultUrbanHorizontalSignageLegend.class,

                "DefaultUrbanHorizontalSignageLegend",

                definitions,

                null,

                null);

        persistenceManager.addDefinition(

                UrbanHorizontalSignageSymbol.class,

                "UrbanHorizontalSignageSymbol",

                definitions,

                null,

                null

        );

        persistenceManager.addDefinition(

                DefaultUrbanHorizontalSignageConfig.class,

                "DefaultUrbanHorizontalSignageConfig",

                definitions,

                null,

                null

        );

    }

}

/*

 * 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.legend.urbanhorizontalsignage.lib.impl.linelegend;

import java.awt.Color;

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

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

import org.gvsig.legend.urbanhorizontalsignage.lib.api.linelegend.UrbanHorizontalSignageConfig;

import static org.gvsig.legend.urbanhorizontalsignage.lib.api.linelegend.UrbanHorizontalSignageConfig.DEFAULT_GAP_WIDTH_VALUE;

import org.gvsig.legend.urbanhorizontalsignage.lib.api.linelegend.UrbanHorizontalSignageData;

import static org.gvsig.legend.urbanhorizontalsignage.lib.api.linelegend.UrbanHorizontalSignageData.DEFAULT_CONTINUITY_VALUE;

import static org.gvsig.legend.urbanhorizontalsignage.lib.api.linelegend.UrbanHorizontalSignageData.DEFAULT_HOLES_COLOR_VALUE;

import static org.gvsig.legend.urbanhorizontalsignage.lib.api.linelegend.UrbanHorizontalSignageData.DEFAULT_HOLES_LENGTH_VALUE;

import static org.gvsig.legend.urbanhorizontalsignage.lib.api.linelegend.UrbanHorizontalSignageData.DEFAULT_PAINT_HOLES_VALUE;

import static org.gvsig.legend.urbanhorizontalsignage.lib.api.linelegend.UrbanHorizontalSignageData.DEFAULT_ROUND_VERTEX_VALUE;

import static org.gvsig.legend.urbanhorizontalsignage.lib.api.linelegend.UrbanHorizontalSignageData.DEFAULT_SEGMENT_COLOR_VALUE;

import static org.gvsig.legend.urbanhorizontalsignage.lib.api.linelegend.UrbanHorizontalSignageData.DEFAULT_SEGMENT_LENGTH_VALUE;

import static org.gvsig.legend.urbanhorizontalsignage.lib.api.linelegend.UrbanHorizontalSignageData.DEFAULT_WIDTH_VALUE;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dataTypes.DataTypesManager;

import org.gvsig.tools.persistence.PersistentState;

import org.gvsig.tools.persistence.exception.PersistenceException;

import org.gvsig.tools.swing.api.DataTypes;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

 *

 * @author fdiaz

 */

public class DefaultUrbanHorizontalSignageConfig implements UrbanHorizontalSignageConfig {

    private static final Logger LOGGER = LoggerFactory.getLogger(DefaultUrbanHorizontalSignageConfig.class);

    private String widthFieldName;

    private String continuityFieldName;

    private String holesLengthFieldName;

    private String holesColorFieldName;

    private String paintHolesFieldName;

    private String segmentsLengthFieldName;

    private String segmentsColorFieldName;

    private String roundVertexFieldName;

    private int gapWidth;

    private String targetColorFieldName;

    private String targetLenghtFieldName;

    private String targetAreaFieldName;

    public DefaultUrbanHorizontalSignageConfig() {

        this.gapWidth = DEFAULT_GAP_WIDTH_VALUE;

    }

    @Override

    public void loadFromState(PersistentState state) throws PersistenceException {

        this.widthFieldName = state.getString("widthFieldName");

        this.continuityFieldName = state.getString("continuityFieldName");

        this.holesLengthFieldName = state.getString("holesLengthFieldName");

        this.holesColorFieldName = state.getString("holesColorFieldName");

        this.paintHolesFieldName = state.getString("paintHolesFieldName");

        this.segmentsLengthFieldName = state.getString("segmentsLengthFieldName");

        this.segmentsColorFieldName = state.getString("segmentsColorFieldName");

        this.roundVertexFieldName = state.getString("roundVertexFieldName");

        this.gapWidth = state.getInt("gapWidth", DEFAULT_GAP_WIDTH_VALUE);

    }

    @Override

    public void saveToState(PersistentState state) throws PersistenceException {

        state.set("widthFieldName", this.widthFieldName);

        state.set("continuityFieldName", this.continuityFieldName);

        state.set("holesLengthFieldName", this.holesLengthFieldName);

        state.set("holesColorFieldName", this.holesColorFieldName);

        state.set("paintHolesFieldName", this.paintHolesFieldName);

        state.set("segmentsLengthFieldName", this.segmentsLengthFieldName);

        state.set("segmentsColorFieldName", this.segmentsColorFieldName);

        state.set("roundVertexFieldName", this.roundVertexFieldName);

        state.set("gapWidth", this.gapWidth);

    }

    @Override

    public String getWidthFieldName() {

        return this.widthFieldName;

    }

    @Override

    public void setWidthFieldName(String fieldName) {

        this.widthFieldName = fieldName;

    }

    @Override

    public String getContinuityFieldName() {

        return this.continuityFieldName;

    }

    @Override

    public void setContinuityFieldName(String fieldName) {

        this.continuityFieldName = fieldName;

    }

    @Override

    public String getSegmentsColorFieldName() {

        return this.segmentsColorFieldName;

    }

    @Override

    public void setSegmentsColorFieldName(String fieldName) {

        this.segmentsColorFieldName = fieldName;

    }

    @Override

    public String getSegmentsLengthFieldName() {

        return this.segmentsLengthFieldName;

    }

    @Override

    public void setSegmentsLengthFieldName(String fieldName) {

        this.segmentsLengthFieldName = fieldName;

    }

    @Override

    public String getPaintHolesFieldName() {

        return this.paintHolesFieldName;

    }

    @Override

    public void setPaintHolesFieldName(String fieldName) {

        this.paintHolesFieldName = fieldName;

    }

    @Override

    public String getHolesColorFieldName() {

        return this.holesColorFieldName;

    }

    @Override

    public void setHolesColorFieldName(String fieldName) {

        this.holesColorFieldName = fieldName;

    }

    @Override

    public String getHolesLengthFieldName() {

        return this.holesLengthFieldName;

    }

    @Override

    public void setHolesLengthFieldName(String fieldName) {

        this.holesLengthFieldName = fieldName;

    }

    @Override

    public String getRoundVertexFieldName() {

        return this.roundVertexFieldName;

    }

    @Override

    public void setRoundVertexFieldName(String fieldName) {

        this.roundVertexFieldName = fieldName;

    }

    @Override

    public int getGapWidth() {

        return this.gapWidth;

    }

    @Override

    public void setGapWith(int value) {

        this.gapWidth = value;

    }

    @Override

    public UrbanHorizontalSignageData getValues(Feature feature) {

        UrbanHorizontalSignageData data = new DefaultUrbanHorizontalSignageData();

        DataTypesManager manager = ToolsLocator.getDataTypesManager();

        FeatureType ftype = feature.getType();

        double valueDouble = feature.getIntOrDefault( this.widthFieldName, (int)DEFAULT_WIDTH_VALUE*100 )/100.0;

        data.setWidth(valueDouble);

        int valueInt = feature.getIntOrDefault( this.continuityFieldName, DEFAULT_CONTINUITY_VALUE );

        data.setContinuity(valueInt);

        Color valueColor = (Color)feature.getOrDefault( this.segmentsColorFieldName, DataTypes.COLOR, DEFAULT_SEGMENT_COLOR_VALUE );

        data.setSegmentsColor(valueColor);

        valueDouble = feature.getIntOrDefault( this.segmentsLengthFieldName, (int)DEFAULT_SEGMENT_LENGTH_VALUE*100 )/100.0;

        data.setSegmentsLength(valueDouble);

        valueDouble = feature.getIntOrDefault( this.holesLengthFieldName, (int)DEFAULT_HOLES_LENGTH_VALUE*100 )/100.0;

        data.setHolesLength(valueDouble);

        boolean valueBoolean = feature.getBooleanOrDefault( this.paintHolesFieldName, DEFAULT_PAINT_HOLES_VALUE );

        data.setPaintHoles(valueBoolean);

        valueColor = (Color) feature.getOrDefault( this.holesColorFieldName, DataTypes.COLOR, DEFAULT_HOLES_COLOR_VALUE );

        data.setHolesColor(valueColor);

        valueBoolean = feature.getBooleanOrDefault( this.roundVertexFieldName, DEFAULT_ROUND_VERTEX_VALUE );

        data.setRoundVertex(valueBoolean);

        data.setGapWidth(this.getGapWidth()/100.0);

        return data;

    }

    @Override

    public String getTargetColorFieldName() {

        return this.targetColorFieldName;

    }

    @Override

    public void setTargetColorFieldName(String fieldName) {

        this.targetColorFieldName = fieldName;

    }

    @Override

    public String getTargetLenghtFieldName() {

        return this.targetLenghtFieldName;

    }

    @Override

    public void setTargetLenghtFieldName(String fieldName) {

        this.targetLenghtFieldName = fieldName;

    }

    @Override

    public String getTargetAreaFieldName() {

        return this.targetAreaFieldName;

    }

    @Override

    public void setTargetAreaFieldName(String fieldName) {

        this.targetAreaFieldName = fieldName;

    }

    @Override

    public UrbanHorizontalSignageConfig clone() throws CloneNotSupportedException {

        return (UrbanHorizontalSignageConfig) super.clone(); 

    }

}

/*

 * 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.legend.urbanhorizontalsignage.lib.impl.linelegend;

import java.awt.Color;

import org.gvsig.fmap.geom.Geometry;

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

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

import org.gvsig.legend.urbanhorizontalsignage.lib.api.linelegend.UrbanHorizontalSignageData;

/**

 *

 * @author fdiaz

 */

public class DefaultUrbanHorizontalSignageData implements UrbanHorizontalSignageData {

    private double width;

    private int continuity;

    private Color segmentsColor;

    private double segmentsLength;

    private MultiPolygon segmentsGeometry;

    private boolean isPaintHoles;

    private Color holesColor;

    private double holesLength;

    private MultiPolygon holesGeometry;

    private double gapWidth;

    private Geometry originalGeometry;

    private boolean roundVertex;

    private MultiLine lineSegmentsGeometry;

    private MultiLine lineHolesGeometry;

    public DefaultUrbanHorizontalSignageData() {

        width = DEFAULT_WIDTH_VALUE;

        continuity = DEFAULT_CONTINUITY_VALUE;

        segmentsColor = DEFAULT_SEGMENT_COLOR_VALUE;

        segmentsLength = DEFAULT_SEGMENT_LENGTH_VALUE;

        isPaintHoles = DEFAULT_PAINT_HOLES_VALUE;

        holesColor = DEFAULT_HOLES_COLOR_VALUE;

        holesLength = DEFAULT_HOLES_LENGTH_VALUE;

        gapWidth = DEFAULT_GAP_WIDTH_VALUE;

        roundVertex = DEFAULT_ROUND_VERTEX_VALUE;

    }

    @Override

    public double getWidth() {

        return this.width;

    }

    @Override

    public void setWidth(double value) {

        this.width = value;

    }

    @Override

    public int getContinuity() {

        return this.continuity;

    }

    @Override

    public void setContinuity(int value) {

        this.continuity = value;

    }

    @Override

    public Color getSegmentsColor() {

        return this.segmentsColor;

    }

    @Override

    public void setSegmentsColor(Color value) {

        this.segmentsColor = value;

    }

    @Override

    public double getSegmentsLength() {

        return this.segmentsLength;

    }

    @Override

    public void setSegmentsLength(double value) {

        this.segmentsLength = value;

    }

    @Override

    public MultiPolygon getSegmentsGeometry() {

        return this.segmentsGeometry;

    }

    @Override

    public void setSegmentsGeometry(MultiPolygon value) {

        this.segmentsGeometry = value;

    }

    @Override

    public boolean isPaintHoles() {

        return this.isPaintHoles;

    }

    @Override

    public void setPaintHoles(boolean value) {

        this.isPaintHoles = value;

    }

    @Override

    public Color getHolesColor() {

        return this.holesColor;

    }

    @Override

    public void setHolesColor(Color value) {

        this.holesColor = value;

    }

    @Override

    public double getHolesLength() {

        return this.holesLength;

    }

    @Override

    public void setHolesLength(double value) {

        this.holesLength = value;

    }

    @Override

    public MultiPolygon getHolesGeometry() {

        return this.holesGeometry;

    }

    @Override

    public void setHolesGeometry(MultiPolygon value) {

        this.holesGeometry = value;

    }

    @Override

    public double getGapWidth() {

        return this.gapWidth;

    }

    @Override

    public void setGapWidth(double value) {

        this.gapWidth = value;

    }

    public boolean isRoundVertex(){

        return this.roundVertex;

    }

    public void setRoundVertex(boolean value){

        this.roundVertex = value;

    }

    @Override

    public MultiLine getLineSegmentsGeometry() {

        return this.lineSegmentsGeometry;

    }

    @Override

    public void setLineSegmentsGeometry(MultiLine value) {

        this.lineSegmentsGeometry = value;

    }

    @Override

    public MultiLine getLineHolesGeometry() {

        return this.lineHolesGeometry;

    }

    @Override

    public void setLineHolesGeometry(MultiLine value) {

        this.lineHolesGeometry = value;

    }

}

package org.gvsig.legend.urbanhorizontalsignage.lib.impl.linelegend;

import java.util.ArrayList;

import java.util.List;

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

/**

 *

 * @author gvSIG Team

 */

public class SplittedLine {

    List<Line> segments;

    List<Line> holes;

    public SplittedLine() {

        segments = new ArrayList<>();

        holes = new ArrayList<>();

    }

    public List<Line> getSegments() {

        return this.segments;

    }

    public List<Line> getHoles() {

        return this.holes;

    }

    public void addSegment(Line segment) {

        this.segments.add(segment);

    }

    public void addHole(Line hole) {

        this.holes.add(hole);

    }

}

package org.gvsig.legend.urbanhorizontalsignage.lib.impl.linelegend;

import java.awt.Image;

import java.util.ArrayList;

import java.util.List;

import org.apache.commons.lang3.StringUtils;

import org.gvsig.fmap.dal.exception.DataException;

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

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

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.fmap.geom.GeometryUtils;

import org.gvsig.fmap.mapcontext.MapContextException;

import org.gvsig.fmap.mapcontext.rendering.symbols.ISymbol;

import org.gvsig.legend.urbanhorizontalsignage.lib.api.linelegend.UrbanHorizontalSignageConfig;

import org.gvsig.legend.urbanhorizontalsignage.lib.api.linelegend.UrbanHorizontalSignageData;

import org.gvsig.legend.urbanhorizontalsignage.lib.api.linelegend.UrbanHorizontalSignageLegend;

import org.gvsig.symbology.SymbologyLocator;

import org.gvsig.symbology.SymbologyManager;

import org.gvsig.symbology.fmap.mapcontext.rendering.legend.impl.AbstractVectorialLegend;

import org.gvsig.tools.persistence.PersistentState;

import org.gvsig.tools.persistence.exception.PersistenceException;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

public class DefaultUrbanHorizontalSignageLegend 

        extends AbstractVectorialLegend 

        implements UrbanHorizontalSignageLegend //, IHasImageLegend 

{

    private static final Logger LOGGER = LoggerFactory.getLogger(DefaultUrbanHorizontalSignageLegend.class);

    private final UrbanHorizontalSignageSymbol defaultSymbol;

    private UrbanHorizontalSignageConfig config;

    private Image imageLegend;

    public DefaultUrbanHorizontalSignageLegend() {

        SymbologyManager symbologyManager = SymbologyLocator.getSymbologyManager();

        this.defaultSymbol = new UrbanHorizontalSignageSymbol();

        DefaultUrbanHorizontalSignageData data = new DefaultUrbanHorizontalSignageData();

        data.setContinuity(UrbanHorizontalSignageData.CONTINUITY_MODE_DISC_CONT);

        this.defaultSymbol.setData(new DefaultUrbanHorizontalSignageData());