Application: gvSIG desktop » gvSIG legends: base legends

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

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

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

        }

    }

}

/*

 * 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;

import java.awt.Color;

import org.gvsig.fmap.geom.Geometry;

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

import org.gvsig.legend.urbanhorizontalsignage.lib.api.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;

    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;

    }

}

/* 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 java.util.ArrayList;

import java.util.Iterator;

import java.util.List;

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

import org.gvsig.fmap.geom.Geometry;

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

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

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

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

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

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

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

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

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

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

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

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

import org.slf4j.LoggerFactory;

public class DefaultUrbanHorizontalSignageManager implements UrbanHorizontalSignageManager {

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

    @Override

    public UrbanHorizontalSignageLegend create() {

        return new DefaultUrbanHorizontalSignageLegend();

    }

    @Override

    public Class<? extends UrbanHorizontalSignageLegend> getLegendClass() {

        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 lines = originalGeometry.toLines();

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

            final double bufferValueInMeters = 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

                        );

                        segments.addPrimitives(buffer);

                        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

                            );

                            segments.addPrimitives(buffer);

                        }

                        for (Line hole : splittedHoles) {

                            buffer = hole.buffer(

                                    bufferValueInMeters,

                                    data.isRoundVertex() ? JOIN_STYLE_ROUND : JOIN_STYLE_MITRE,

                                    true

                            );

                            holes.addPrimitives(buffer);

                        }

                        break;

                    case CONTINUITY_MODE_CONT_CONT:

                        //Left

                        Geometry leftGeom = line.cloneGeometry().offset(-offsetValueInMeters).buffer(

                                bufferValueInMeters,

                                data.isRoundVertex() ? JOIN_STYLE_ROUND : JOIN_STYLE_MITRE,

                                true

                        );

                        segments.addPrimitives(leftGeom);

                        //Right

                        Geometry rightGeom = line.cloneGeometry().offset(offsetValueInMeters).buffer(

                                bufferValueInMeters,

                                data.isRoundVertex() ? JOIN_STYLE_ROUND : JOIN_STYLE_MITRE,

                                true

                        );

                        segments.addPrimitives(rightGeom);

                        break;

                    case CONTINUITY_MODE_CONT_DISC:

                        //Left

                        leftGeom = line.cloneGeometry().offset(-offsetValueInMeters).buffer(

                                bufferValueInMeters,

                                data.isRoundVertex() ? JOIN_STYLE_ROUND : JOIN_STYLE_MITRE,

                                true

                        );

                        segments.addPrimitives(leftGeom);

                        //Right

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

                        splittedSegments = splittedLine.getSegments();

                        splittedHoles = splittedLine.getHoles();

                        for (Line segment : splittedSegments) {

                            buffer = segment.cloneGeometry().offset(offsetValueInMeters).buffer(

                                    bufferValueInMeters,

                                    data.isRoundVertex() ? JOIN_STYLE_ROUND : JOIN_STYLE_MITRE,

                                    true

                            );

                            segments.addPrimitives(buffer);

                        }

                        for (Line hole : splittedHoles) {

                            buffer = hole.cloneGeometry().offset(offsetValueInMeters).buffer(

                                    bufferValueInMeters,

                                    data.isRoundVertex() ? JOIN_STYLE_ROUND : JOIN_STYLE_MITRE,

                                    true

                            );

                            holes.addPrimitives(buffer);

                        }

                        break;

                    case CONTINUITY_MODE_DISC_CONT:

                        //Left

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

                        splittedSegments = splittedLine.getSegments();

                        splittedHoles = splittedLine.getHoles();

                        for (Line segment : splittedSegments) {

                            buffer = segment.cloneGeometry().offset(-offsetValueInMeters).buffer(

                                    bufferValueInMeters,

                                    data.isRoundVertex() ? JOIN_STYLE_ROUND : JOIN_STYLE_MITRE,

                                    true

                            );

                            segments.addPrimitives(buffer);

                        }

                        for (Line hole : splittedHoles) {

                            buffer = hole.cloneGeometry().offset(-offsetValueInMeters).buffer(

                                    bufferValueInMeters,

                                    data.isRoundVertex() ? JOIN_STYLE_ROUND : JOIN_STYLE_MITRE,

                                    true

                            );

                            holes.addPrimitives(buffer);

                        }

                        //Right

                        rightGeom = line.cloneGeometry().offset(offsetValueInMeters).buffer(

                                bufferValueInMeters,

                                data.isRoundVertex() ? JOIN_STYLE_ROUND : JOIN_STYLE_MITRE,

                                true

                        );

                        segments.addPrimitives(rightGeom);

                        break;

                    case CONTINUITY_MODE_DISC_DISC:

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

                        splittedSegments = splittedLine.getSegments();

                        splittedHoles = splittedLine.getHoles();

                        //Left

                        for (Line segment : splittedSegments) {

                            buffer = segment.cloneGeometry().offset(-offsetValueInMeters).buffer(

                                    bufferValueInMeters,

                                    data.isRoundVertex() ? JOIN_STYLE_ROUND : JOIN_STYLE_MITRE,

                                    true

                            );

                            segments.addPrimitives(buffer);

                        }

                        for (Line hole : splittedHoles) {

                            buffer = hole.cloneGeometry().offset(-offsetValueInMeters).buffer(

                                    bufferValueInMeters,

                                    data.isRoundVertex() ? JOIN_STYLE_ROUND : JOIN_STYLE_MITRE,

                                    true

                            );

                            holes.addPrimitives(buffer);

                        }

                        //Right

                        for (Line segment : splittedSegments) {

                            Geometry offset = segment.cloneGeometry().offset(offsetValueInMeters);

                            buffer = offset.buffer(

                                    bufferValueInMeters,

                                    data.isRoundVertex() ? JOIN_STYLE_ROUND : JOIN_STYLE_MITRE,

                                    true

                            );

                            segments.addPrimitives(buffer);

                        }

                        for (Line hole : splittedHoles) {

                            buffer = hole.cloneGeometry().offset(offsetValueInMeters).buffer(

                                    bufferValueInMeters,

                                    data.isRoundVertex() ? JOIN_STYLE_ROUND : JOIN_STYLE_MITRE,

                                    true

                            );

                            holes.addPrimitives(buffer);

                        }

                        break;

                }

            }

            data.setSegmentsGeometry(segments);

            data.setHolesGeometry(holes);

        } catch (Exception ex) {

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

            //VOY POR AQU?

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

        }

    }

    /*

        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;

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

        Point currentPoint = null;

        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);

                    //a?adirlo al currentSegment,

                    currentSegment.addVertex(point);

                    //a?adir  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);

                    //a?adirlo al currentSegment,

                    currentSegment.addVertex(point);

                    //a?adir  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;

                }

            }

        }

//        currentSegment.addVertex(currentPoint);

        if (currentSegment.getNumVertices() > 1) {

            if (isHole) {

                res.addHole(currentSegment.cloneGeometry());

            } else {

                res.addSegment(currentSegment.cloneGeometry());

            }

        }

        return res;

    }

    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;

    }

    /*friend*/ static 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;

import java.awt.Color;

import java.awt.Image;

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

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.fmap.mapcontext.MapContextException;

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

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

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

import static org.gvsig.legend.urbanhorizontalsignage.lib.api.UrbanHorizontalSignageData.DEFAULT_GAP_WIDTH_VALUE;

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

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

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

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

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

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

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

import org.gvsig.legend.urbanhorizontalsignage.lib.api.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.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;

public class DefaultUrbanHorizontalSignageLegend 

        extends AbstractVectorialLegend 

        implements UrbanHorizontalSignageLegend //, IHasImageLegend 

{

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

    private UrbanHorizontalSignageSymbol defaultSymbol;

    private Image imageLegend;

    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;

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

        this.gapWidth = DEFAULT_GAP_WIDTH_VALUE;

    }

//    @Override

//    protected String[] getRequiredFeatureAttributeNames(FeatureStore featureStore) throws DataException {

//        FeatureType ftype = featureStore.getDefaultFeatureType();

//        if( StringUtils.isEmpty(this.fieldName) ) {

//            return new String[]{

//                ftype.getDefaultGeometryAttributeName()

//            };

//        }

//        return new String[]{

//            ftype.getDefaultGeometryAttributeName(),

//            this.fieldName

//        };

//    }

    @Override

    public ISymbol getDefaultSymbol() {

        return this.defaultSymbol;

    }

    @Override

    public void setDefaultSymbol(ISymbol is) {

        //DO NOTHING

    }

    @Override

    public ISymbol getSymbolByFeature(Feature ftr) throws MapContextException {

        UrbanHorizontalSignageData values = getValues(ftr);

        UrbanHorizontalSignageSymbol symbol = new UrbanHorizontalSignageSymbol();

        symbol.setData(values);

        return symbol;

    }

    @Override

    public int getShapeType() {

        return Geometry.TYPES.CURVE;

    }

    @Override

    public void setShapeType(int i) {

    }

    @Override

    public boolean isUseDefaultSymbol() {

        return true;

    }

    @Override

    public void useDefaultSymbol(boolean bln) {

    }

    @Override

    public boolean isSuitableForShapeType(int shapeType) {

        return true;

    }

//    @Override

//    protected void draw(BufferedImage image, Graphics2D g, ViewPort viewPort, Cancellable cancel, double scale, Map queryParameters, ICoordTrans coordTrans, FeatureStore featureStore, FeatureQuery featureQuery, double dpi) throws LegendException {

//        int saved_distance = this.algorithm.getDistance();

//        try {

//            int distance = (int) (this.algorithm.getDistance() * (dpi / 72));

//            Geometry theROI = null;

//            if (this.roi!=null) {

//                theROI = this.roi.cloneGeometry();

//                theROI.transform(viewPort.getAffineTransform());

//            }

//            this.algorithm.setDistance(distance);

//            this.algorithm.init(image.getWidth(), image.getHeight());

//            super.draw(image, g, viewPort, cancel, scale, queryParameters, coordTrans, featureStore, featureQuery, dpi);

//            if( !cancel.isCanceled() ) {

//                this.algorithm.drawWithOpaqueColors(image, g, this.getHeatMapColorTable().getColorTable(), cancel, theROI);

//            }

//        } finally {

//            this.algorithm.setDistance(saved_distance);

//

//        }

//    }

//    @Override

//    public void print(Graphics2D g, ViewPort viewPort, Cancellable cancel,

//            double scale, Map queryParameters, ICoordTrans coordTrans,

//            FeatureStore featureStore, FeatureQuery featureQuery, PrintAttributes properties)

//            throws LegendException {

//        int saved_distance = this.algorithm.getDistance();

//        try {

//            double dpi = viewPort.getDPI();

//            // Ver CartographicSupportToolkit.getCartographicLength

//            int distance = (int) (this.algorithm.getDistance() * (dpi / 72));

//            Geometry theROI = null;

//            if (this.roi!=null) {

//                theROI = this.roi.cloneGeometry();

//                theROI.transform(viewPort.getAffineTransform());

//            }

//            this.algorithm.setDistance(distance);

//            this.algorithm.init(viewPort.getImageWidth(), viewPort.getImageHeight());

//            BufferedImage image = new BufferedImage(viewPort.getImageWidth(), viewPort.getImageHeight(), BufferedImage.TYPE_INT_ARGB);

//            super.draw(image, g, viewPort, cancel, scale, queryParameters, coordTrans, featureStore, featureQuery, dpi);

//            if (!cancel.isCanceled()) {

//                this.algorithm.drawWithAlphaColors(image, g, this.getHeatMapColorTable().getColorTable(), cancel, theROI);

//                g.drawImage(image, 0, 0, null);

//            }

//        } finally {

//            this.algorithm.setDistance(saved_distance);

//

//        }

//    }

//    @Override

//    protected void drawFeatures(

//            BufferedImage image,

//            Graphics2D g,

//            final ViewPort viewPort,

//            final Cancellable cancel,

//            final ICoordTrans coordTrans,

//            double dpi,

//            DefaultFeatureDrawnNotification drawnNotification,

//            FeatureSet featureSet,

//            FeatureSelection selection

//    ) throws BaseException {

//

//        SymbologyManager symbologyManager = SymbologyLocator.getSymbologyManager();

//

//        UrbanHorizontalSignageManager uhsManager = UrbanHorizontalSignageLocator.getUrbanHorizontalSignageManager();

//

//        try {

//            featureSet.accept(new Visitor() {

//                @Override

//                public void visit(Object obj) throws VisitCanceledException,

//                        BaseException {

//                    if (cancel.isCanceled()) {

//                        throw new VisitCanceledException();

//                    }

//                    Feature feature = (Feature) obj;

//                    UrbanHorizontalSignageData values = getValues(feature);

//                    Geometry originalGeometry = feature.getDefaultGeometry();

//                    

//                    ISimpleLineSymbol lineSymbol = symbologyManager.createSimpleLineSymbol();

//                    lineSymbol.setColor(Color.YELLOW);

//                    

//                    uhsManager.calculateGeometries(originalGeometry, values);

//                    MultiPolygon geom;

//                    

//                    ISimpleFillSymbol segmentsSymbol = symbologyManager.createSimpleFillSymbol();;

//                    segmentsSymbol.setFillColor(values.getSegmentsColor());

//                    

//                    ISimpleFillSymbol holesSymbol = symbologyManager.createSimpleFillSymbol();

//                    holesSymbol.setFillColor(values.getHolesColor());

//

//                    geom = values.getSegmentsGeometry();

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

//                        segmentsSymbol.draw(g, viewPort.getAffineTransform(), geom,

//                                feature, cancel);

//                    }

//

//                    switch (values.getContinuity()) {

////                        case CONTINUITY_MODE_CONT:

////                        case CONTINUITY_MODE_CONT_CONT:

////                            geom = values.getSegmentsGeometry();

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

////                                segmentsSymbol.draw(g, viewPort.getAffineTransform(), geom,

////                                        feature, cancel);

////                            }

////                            break;

//                        case CONTINUITY_MODE_CONT_DISC:

//                        case CONTINUITY_MODE_DISC_CONT:

//                        case CONTINUITY_MODE_DISC:

//                        case CONTINUITY_MODE_DISC_DISC:

//                            if(values.isPaintHoles()){

//                                geom = values.getHolesGeometry();

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

//                                    holesSymbol.draw(g, viewPort.getAffineTransform(), geom,

//                                            feature, cancel);

//                                }

//                            }

//                    }

//

//                    //For debug purposse only

//                    lineSymbol.draw(g, viewPort.getAffineTransform(), originalGeometry,

//                            feature, cancel);

//                }

//            });

//

//        } catch (ConcurrentDataModificationException e) {

//            cancel.setCanceled(true);

//        }

//    }

//    @Override

//    public Image getImageLegend() {

//        if( this.imageLegend==null ) {

////            BufferedImage img = new BufferedImage(80, 20, BufferedImage.TYPE_INT_RGB);

////            ColorTablePainter painter = new DefaultColorTablePainter(this.getTargetColorTable(),"");

////            Graphics2D g = img.createGraphics();

////            g.setClip(0, 0, 80, 20);

////            g.setBackground(Color.WHITE);

////            g.fillRect(0, 0, 80, 20);

////            painter.paint(g, false);

////            this.imageLegend = img;

//        }

//        return this.imageLegend;

//    }

//

//    @Override

//    public String getPathImage() {

//        return null;

//    }

    @Override

    public void loadFromState(PersistentState state) throws PersistenceException {

//        this.defaultSymbol = new SimpleTextSymbol();

        this.imageLegend = null;

        super.loadFromState(state);

        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 {

        super.saveToState(state);

        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

    protected String[] getRequiredFeatureAttributeNames(FeatureStore fs) throws DataException {

        return new String[]{

            this.widthFieldName,

            this.continuityFieldName,

            this.holesLengthFieldName,

            this.holesColorFieldName,

            this.paintHolesFieldName,

            this.segmentsLengthFieldName,

            this.segmentsColorFieldName,

            this.roundVertexFieldName,

            fs.getDefaultFeatureType().getDefaultGeometryAttributeName()};

    }

    @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;

    }

}

/**

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

import java.awt.Color;

import java.awt.Graphics2D;

import java.awt.Rectangle;

import java.awt.geom.AffineTransform;

import java.util.Objects;

import java.util.concurrent.Callable;

import java.util.logging.Level;

import org.gvsig.compat.print.PrintAttributes;

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

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.fmap.geom.GeometryLocator;

import org.gvsig.fmap.geom.GeometryManager;

import org.gvsig.fmap.geom.GeometryUtils;

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

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

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

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

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

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

import org.gvsig.fmap.mapcontext.MapContext;

import org.gvsig.fmap.mapcontext.MapContextLocator;

import org.gvsig.fmap.mapcontext.ViewPort;

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

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

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

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

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

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

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

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

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

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

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

import org.gvsig.symbology.fmap.mapcontext.rendering.symbol.impl.AbstractSymbol;

import org.gvsig.symbology.fmap.mapcontext.rendering.symbol.impl.CartographicSupportToolkit;

import org.gvsig.symbology.fmap.mapcontext.rendering.symbol.line.ILineSymbol;

import static org.gvsig.symbology.fmap.mapcontext.rendering.symbol.line.impl.AbstractLineSymbol.LINE_SYMBOL_PERSISTENCE_DEFINITION_NAME;

import org.gvsig.symbology.fmap.mapcontext.rendering.symbol.line.impl.SimpleLineSymbol;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dynobject.DynStruct;

import org.gvsig.tools.persistence.PersistenceManager;

import org.gvsig.tools.persistence.PersistentState;

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

import org.gvsig.tools.task.Cancellable;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

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

public class UrbanHorizontalSignageSymbol extends AbstractSymbol implements ISymbol_v2, TransparencySupport {

    private static final Logger LOG = LoggerFactory.getLogger(UrbanHorizontalSignageSymbol.class);

    private static final String SYMBOL_NAME = "UrbanHorizontalSignageSymbol";

    private static final String URBAN_HORIZONTAL_SIGNAGE_SYMBOL_PERSISTENCE_DEFINITION_NAME = "UrbanHorizontalSignageSymbol";

    private static final String FIELD_WIDTH = "width";

    private static final String FIELD_CONTINUITY = "continuity";

    private static final String FIELD_SEGMENTS_COLOR = "segmentsColor";

    private static final String FIELD_SEGMENTS_LENGTH = "segmentsLength";

    private static final String FIELD_HOLES_COLOR = "holesColor";

    private static final String FIELD_HOLES_LENGTH = "holesLength";

    private static final String FIELD_PAINT_HOLES = "paintHoles";

    private static final String FIELD_GAP_WIDTH = "gapWidth";

    private static final String FIELD_ROUND_VERTEX = "roundVertex";

    private static final String FIELD_SEGMENTS_GEOMETRY = "segmentsGeometry";

    private static final String FIELD_HOLES_GEOMETRY = "holesGeometry";

    private static final String FIELD_TRANSPARENCY = "transparency";

    private static final String FIELD_MUST_DRAW_ORIGINAL_GEOMETRY = "mustDrawOriginalGeometry";

    private static final String FIELD_COLOR_FOR_ORIGINAL_GEOMETRY = "colorForOriginalGeometry";

//    private static final String FIELD_SYMBOL_FOR_SELECTION = "symbolForSelection";

    private UrbanHorizontalSignageData data;

    transient private UrbanHorizontalSignageSymbol symbolForSelection;

    private boolean mustDrawOriginalGeometry;

    private Color colorForOriginalGeometry;

    private double cartographicSize;

    private double transparency; //[0.0, 1.0]

    public UrbanHorizontalSignageSymbol() {

        super();

        this.mustDrawOriginalGeometry = false;

        this.transparency = 1.0;

    }

    public void setData(UrbanHorizontalSignageData data) {

        this.data = data;

    }

    public UrbanHorizontalSignageData getData() {

        return data;

    }

    /**

     * Sets the transparency for symbol. The valid values are in [0.0, 1.0]

     * 

     * @param transparency 

     */

    @Override

    public void setTransparency(double transparency) {

        if(transparency < 0 || transparency > 1.0){

            throw new IllegalArgumentException("Transparency value must be in [0.0, 1.0] ("+transparency+")");

        }

        this.transparency = transparency;

    }

    @Override

    public double getTransparency() {

        return transparency;

    }

    @Override

    public ISymbol getSymbolForSelection() {

        if (symbolForSelection == null) {

            symbolForSelection = (UrbanHorizontalSignageSymbol) cloneForSelection();

            symbolForSelection.mustDrawOriginalGeometry = true;

        } else {

            symbolForSelection.setColor(MapContext.getSelectionColor());

        }

        return symbolForSelection;

    }

    @Override

    public void draw(Graphics2D g, AffineTransform affineTransform,

            Geometry originalGeometry, Feature feature, Cancellable cancel) {

        if (true) {

            // Esto deberia ser para optimizar el pintado de 

            // geometrias grandes.

            try {

                Geometry env = originalGeometry.getEnvelope().getGeometry();

                env.transform(affineTransform);

                Envelope env2 = env.getEnvelope();

                if (env2.getLength(0) < 1.5 && env2.getLength(1) < 1.5) {

                    g.setColor(data.getSegmentsColor());

                    Point upperCorner = env2.getUpperCorner();

                    int x = (int) upperCorner.getX();

                    int y = (int) upperCorner.getY();

                    g.drawLine(x, y, x, y);

                    return;

                }

            } catch (Exception ex) {

                LOG.warn("Error optimizing the drawing of the geometry. Continues with normal drawing.", ex);

                // Do nothing, continue with the draw of the original geometry

            }

        }

        UrbanHorizontalSignageManager uhsManager = UrbanHorizontalSignageLocator.getUrbanHorizontalSignageManager();

        uhsManager.calculateGeometries(originalGeometry, data);

        MultiPolygon geom = data.getSegmentsGeometry();

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

            Color color = data.getSegmentsColor();

            Color transparentColor = new Color(color.getRed(), color.getGreen(), color.getBlue(), (int)(255*transparency));

            g.setColor(transparentColor);

            g.fill(geom.getShape(affineTransform));

        }

        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()) {

                    geom = data.getHolesGeometry();

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

                        Color color = data.getHolesColor();

                        Color transparentColor = new Color(color.getRed(), color.getGreen(), color.getBlue(), (int)(255*transparency));

                        g.setColor(transparentColor);

                        g.fill(geom.getShape(affineTransform));

                    }

                }

        }

        //For debug purposse only

        if(mustDrawOriginalGeometry){

            g.setColor(getColor());

            g.draw(originalGeometry.getShape(affineTransform));

        }

    }

    @Override

    public int getOnePointRgb() {

        return data.getSegmentsColor().getRGB();

    }

    @Override

    public void drawInsideRectangle(Graphics2D g,

            AffineTransform scaleInstance, Rectangle r, PrintAttributes properties) throws SymbolDrawingException {

        GeometryManager geomManager = GeometryLocator.getGeometryManager();

        final int hGap = (int) (r.getWidth() * 0.1); // the left and right margins

        final int vPos = 1; 						 // the top and bottom margins

        final int splitCount = 3; 					 // number of lines

        final int splitHSize = (r.width - hGap - hGap) / splitCount;

        int hPos = hGap;

        boolean swap = false;

        Line geom = GeometryUtils.createLine(Geometry.SUBTYPES.GEOM2D);

        geom.addVertex(r.x + hPos, r.y + r.height - vPos);

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

            swap = !swap;

            geom.addVertex(r.x + hPos + splitHSize, (swap ? vPos : r.height - vPos) + r.y);

            hPos += splitHSize;

        }

        try {

            if (properties == null) {

                draw(g, new AffineTransform(), geom, null, null);

            } else {

                print(g, new AffineTransform(), geom, properties);

            }

        } catch (Exception e) {

            throw new SymbolDrawingException(SymbolDrawingException.UNSUPPORTED_SET_OF_SETTINGS);

        }

    }

    @Override

    public Object clone() throws CloneNotSupportedException {

        UrbanHorizontalSignageSymbol copy = (UrbanHorizontalSignageSymbol) super.clone();

        if (symbolForSelection != null) {

            copy.symbolForSelection = (UrbanHorizontalSignageSymbol) symbolForSelection

                    .clone();

        }

        return copy;

    }

    @Override

    public void loadFromState(PersistentState state) throws PersistenceException {

        // Set parent style properties

        super.loadFromState(state);

        UrbanHorizontalSignageData data = new DefaultUrbanHorizontalSignageData();

        data.setWidth(state.getDouble(FIELD_WIDTH, UrbanHorizontalSignageData.DEFAULT_WIDTH_VALUE));

        data.setContinuity(state.getInt(FIELD_CONTINUITY, UrbanHorizontalSignageData.DEFAULT_CONTINUITY_VALUE));

        Color color = (Color) state.get(FIELD_SEGMENTS_COLOR);

        data.setSegmentsColor(color != null ? color : UrbanHorizontalSignageData.DEFAULT_SEGMENT_COLOR_VALUE);

        data.setSegmentsLength(state.getDouble(FIELD_SEGMENTS_LENGTH, UrbanHorizontalSignageData.DEFAULT_SEGMENT_LENGTH_VALUE));

        color = (Color) state.get(FIELD_HOLES_COLOR);

        data.setHolesColor(color != null ? color : UrbanHorizontalSignageData.DEFAULT_HOLES_COLOR_VALUE);

        data.setHolesLength(state.getDouble(FIELD_HOLES_LENGTH, UrbanHorizontalSignageData.DEFAULT_HOLES_LENGTH_VALUE));

        data.setGapWidth(state.getDouble(FIELD_GAP_WIDTH, UrbanHorizontalSignageData.DEFAULT_GAP_WIDTH_VALUE));

        data.setRoundVertex(state.getBoolean(FIELD_ROUND_VERTEX, UrbanHorizontalSignageData.DEFAULT_ROUND_VERTEX_VALUE));

        this.transparency = state.getDouble(FIELD_TRANSPARENCY, 1.0);

        this.mustDrawOriginalGeometry = state.getBoolean(FIELD_MUST_DRAW_ORIGINAL_GEOMETRY, false);

        color = (Color) state.get(FIELD_COLOR_FOR_ORIGINAL_GEOMETRY);

        this.colorForOriginalGeometry = color != null ? color : MapContext.getSelectionColor();

        this.data = data;

    }

    @Override

    public void saveToState(PersistentState state) throws PersistenceException {

        // Save parent fill symbol properties

        super.saveToState(state);

        // Save own properties

        if(data != null){

            state.set(FIELD_WIDTH, data.getWidth());

            state.set(FIELD_CONTINUITY, data.getContinuity());

            state.set(FIELD_SEGMENTS_COLOR, data.getSegmentsColor());

            state.set(FIELD_SEGMENTS_LENGTH, data.getSegmentsLength());

            state.set(FIELD_HOLES_COLOR, data.getHolesColor());

            state.set(FIELD_HOLES_LENGTH, data.getHolesLength());

            state.set(FIELD_PAINT_HOLES, data.isPaintHoles());

            state.set(FIELD_GAP_WIDTH, data.getGapWidth());

            state.set(FIELD_ROUND_VERTEX, data.isRoundVertex());

        }

        state.set(FIELD_MUST_DRAW_ORIGINAL_GEOMETRY, mustDrawOriginalGeometry);

        state.set(FIELD_COLOR_FOR_ORIGINAL_GEOMETRY, colorForOriginalGeometry);

        state.set(FIELD_TRANSPARENCY, this.getTransparency());

    }

    @Override

    public void getPixExtentPlus(Geometry geom, float[] distances, ViewPort viewPort, int dpi) {

        float cs = (float) getCartographicSize(viewPort, dpi, geom);

        // TODO and add the line offset

        distances[0] = cs;

        distances[1] = cs;

    }

    @Override

    public int getSymbolType() {

        return Geometry.TYPES.CURVE;

    }

    @Override

    public boolean isSuitableFor(Geometry geom) {

        return geom.getGeometryType().isTypeOf(Geometry.TYPES.CURVE);

    }

    @Override

    public Color getColor() {

        return this.colorForOriginalGeometry;

    }

    @Override

    public void setColor(Color color) {

        this.colorForOriginalGeometry = color;

    }

    @Override

    public void print(Graphics2D g, AffineTransform at, Geometry shape, PrintAttributes properties) {

        draw(g, at, shape, null, null);

//		double originalSize = getLineWidth();

//		double size=originalSize;

//		// scale it to size

//		int pq = properties.getPrintQuality();

//		if (pq == PrintAttributes.PRINT_QUALITY_NORMAL){

//			size *= (double) 300/72;

//		}else if (pq == PrintAttributes.PRINT_QUALITY_HIGH){

//			size *= (double) 600/72;

//		}else if (pq == PrintAttributes.PRINT_QUALITY_DRAFT){

//			// size *= 72/72; // (which is the same than doing nothing)

//		}

//		setLineWidth(size);

//		draw(g,at,geom,null, null);

//		setLineWidth(originalSize);

    }

    @Override

    public double toCartographicSize(ViewPort viewPort, double dpi, Geometry geom) {

        double oldSize = getData().getWidth();

        setCartographicSize(getCartographicSize(

                viewPort,

                dpi,

                geom),

                geom);

        return oldSize;

//        return 0;

    }

    @Override

    public void setCartographicSize(double cartographicSize, Geometry geom) {

        //DO NOTHING

        this.getData().setWidth(cartographicSize);

    }

    @Override

    public double getCartographicSize(ViewPort viewPort, double dpi, Geometry geom) {

        return CartographicSupportToolkit.getCartographicLength(

                this,

                getData().getWidth(),

                viewPort,

                dpi

        );

//        return 0;

    }

//    public static class RegisterPersistence implements Callable {

//

//        @Override

//        public Object call() throws Exception {

//            PersistenceManager manager = ToolsLocator.getPersistenceManager();

//            if (manager.getDefinition(URBAN_HORIZONTAL_SIGNAGE_SYMBOL_PERSISTENCE_DEFINITION_NAME) == null) {

//                DynStruct definition = manager.addDefinition(

//                        UrbanHorizontalSignageSymbol.class,

//                        URBAN_HORIZONTAL_SIGNAGE_SYMBOL_PERSISTENCE_DEFINITION_NAME,

//                        URBAN_HORIZONTAL_SIGNAGE_SYMBOL_PERSISTENCE_DEFINITION_NAME + " Persistence definition",

//                        null,

//                        null

//                );

//                // Extend the LineSymbol base definition

//                definition.extend(manager.getDefinition(AbstractSymbol.SYMBOL_PERSISTENCE_DEFINITION_NAME));

//