| gvSIG desktop 1

/* gvSIG. Sistema de Informaci?n Geogr?fica de la Generalitat Valenciana

 *

 * Copyright (C) 2005 IVER T.I. and Generalitat Valenciana.

 *

 * 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., 59 Temple Place - Suite 330, Boston, MA  02111-1307,USA.

 *

 * For more information, contact:

 *

 *  Generalitat Valenciana

 *   Conselleria d'Infraestructures i Transport

 *   Av. Blasco Ib??ez, 50

 *   46010 VALENCIA

 *   SPAIN

 *

 *      +34 963862235

 *   gvsig@gva.es

 *      www.gvsig.gva.es

 *

 *    or

 *

 *   IVER T.I. S.A

 *   Salamanca 50

 *   46005 Valencia

 *   Spain

 *

 *   +34 963163400

 *   dac@iver.es

 */

/* CVS MESSAGES:

*

* $Id: GeneralLabelingStrategy.java 13749 2007-09-17 14:16:11Z jaume $

* $Log$

* Revision 1.2  2007-09-17 14:16:11  jaume

* multilayer symbols sizing bug fixed

*

* Revision 1.1  2007/05/22 12:17:41  jaume

* *** empty log message ***

*

* Revision 1.1  2007/05/22 10:05:31  jaume

* *** empty log message ***

*

* Revision 1.10  2007/05/17 09:32:06  jaume

* *** empty log message ***

*

* Revision 1.9  2007/05/09 11:04:58  jaume

* refactored legend hierarchy

*

* Revision 1.8  2007/04/13 11:59:30  jaume

* *** empty log message ***

*

* Revision 1.7  2007/04/12 14:28:43  jaume

* basic labeling support for lines

*

* Revision 1.6  2007/04/11 16:01:08  jaume

* maybe a label placer refactor

*

* Revision 1.5  2007/04/10 16:34:01  jaume

* towards a styled labeling

*

* Revision 1.4  2007/04/02 16:34:56  jaume

* Styled labeling (start commiting)

*

* Revision 1.3  2007/03/28 16:48:01  jaume

* *** empty log message ***

*

* Revision 1.2  2007/03/26 14:40:38  jaume

* added print method (BUT UNIMPLEMENTED)

*

* Revision 1.1  2007/03/20 16:16:20  jaume

* refactored to use ISymbol instead of FSymbol

*

* Revision 1.2  2007/03/09 11:20:57  jaume

* Advanced symbology (start committing)

*

* Revision 1.1  2007/03/09 08:33:43  jaume

* *** empty log message ***

*

* Revision 1.1.2.5  2007/02/21 07:34:08  jaume

* labeling starts working

*

* Revision 1.1.2.4  2007/02/15 16:23:44  jaume

* *** empty log message ***

*

* Revision 1.1.2.3  2007/02/09 07:47:05  jaume

* Isymbol moved

*

* Revision 1.1.2.2  2007/02/02 16:21:24  jaume

* start commiting labeling stuff

*

* Revision 1.1.2.1  2007/02/01 17:46:49  jaume

* *** empty log message ***

*

*

*/

package org.gvsig.symbology.fmap.labeling;

import java.awt.Graphics2D;

import java.awt.RenderingHints;

import java.awt.geom.Rectangle2D;

import java.awt.image.BufferedImage;

import java.io.CharArrayReader;

import java.text.NumberFormat;

import java.util.ArrayList;

import java.util.TreeSet;

import javax.print.attribute.PrintRequestAttributeSet;

import org.apache.log4j.Logger;

import org.cresques.cts.ICoordTrans;

import org.gvsig.symbology.fmap.labeling.lang.Symbol;

import org.gvsig.symbology.fmap.labeling.parse.LabelExpressionParser;

import org.gvsig.symbology.fmap.labeling.parse.ParseException;

import org.gvsig.symbology.fmap.labeling.placements.ILabelPlacement;

import org.gvsig.symbology.fmap.labeling.placements.RemoveDuplicatesComparator;

import com.hardcode.gdbms.driver.exceptions.ReadDriverException;

import com.hardcode.gdbms.engine.values.Value;

import com.iver.cit.gvsig.fmap.ViewPort;

import com.iver.cit.gvsig.fmap.core.FShape;

import com.iver.cit.gvsig.fmap.core.IFeature;

import com.iver.cit.gvsig.fmap.core.IGeometry;

import com.iver.cit.gvsig.fmap.core.v02.FConverter;

import com.iver.cit.gvsig.fmap.drivers.IFeatureIterator;

import com.iver.cit.gvsig.fmap.layers.FLayer;

import com.iver.cit.gvsig.fmap.layers.FLyrVect;

import com.iver.cit.gvsig.fmap.rendering.styling.labeling.ILabelingMethod;

import com.iver.cit.gvsig.fmap.rendering.styling.labeling.ILabelingStrategy;

import com.iver.cit.gvsig.fmap.rendering.styling.labeling.IPlacementConstraints;

import com.iver.cit.gvsig.fmap.rendering.styling.labeling.IZoomConstraints;

import com.iver.cit.gvsig.fmap.rendering.styling.labeling.LabelClass;

import com.iver.cit.gvsig.fmap.rendering.styling.labeling.LabelLocationMetrics;

import com.iver.cit.gvsig.fmap.rendering.styling.labeling.LabelingFactory;

import com.iver.utiles.XMLEntity;

import com.iver.utiles.swing.threads.Cancellable;

/**

 * 

 * GeneralLabelingStrategy.java

 *

 * 

 * @author jaume dominguez faus - jaume.dominguez@iver.es Jan 4, 2008

 *

 */

public class GeneralLabelingStrategy implements ILabelingStrategy {

        private ILabelingMethod method;

        private IPlacementConstraints placementConstraints;

        protected FLyrVect layer;

        private IZoomConstraints zoomConstraints;

        private boolean allowOverlapping;

        private long minScaleView = -1;

        private long maxScaleView = -1;

        public void setLayer(FLayer layer) throws ReadDriverException {

                FLyrVect l = (FLyrVect) layer;

                this.layer = l;

        }

        public ILabelingMethod getLabelingMethod() {

                return method;

        }

        public void setLabelingMethod(ILabelingMethod method) {

                this.method = method;

        }

        public void draw(BufferedImage mapImage, Graphics2D mapGraphics, ViewPort viewPort,

                        Cancellable cancel, double dpi)

        throws ReadDriverException {

                mapGraphics.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);

                TreeSet<?> placedLabels = null;

                long t1 = System.currentTimeMillis();

                String[] usedFields = getUsedFields();

                int notPlacedCount = 0;

                int placedCount = 0;

                ILabelPlacement placement = PlacementManager.getPlacement(getPlacementConstraints(), layer.getShapeType());

                /* handle the duplicates mode */

                int duplicateMode = getDuplicateLabelsMode();

                /* 

                 * get an ordered set of the LabelClasses up on the 

                 * label priority

                 */

                LabelClass[] lcs = method.getLabelClasses();

                TreeSet<LabelClass> ts = new TreeSet<LabelClass>(new LabelClassComparatorByPriority());

                for (int i = 0; i < lcs.length; i++) ts.add(lcs[i]);

                /* 

                 * now we have an ordered set, it is only need to give a pass

                 * for each label class to render by priorities.

                 * 

                 * If no priorities were defined, the following loop only executes

                 * once

                 */

                for (LabelClass lc : ts) {

                        IFeatureIterator it =  method.getFeatureIteratorByLabelClass(layer, lc, viewPort, usedFields);

                        // duplicates treatment stuff 

                        if (duplicateMode == IPlacementConstraints.REMOVE_DUPLICATE_LABELS) {

                                // we need to register the labels already placed

                                if (placedLabels == null) 

                                        placedLabels = new TreeSet<String[]>(

                                                        new RemoveDuplicatesComparator());

                                else placedLabels.clear();

                        }

//                        TODO        Pending of the refactoring on geometries model

//                        

//                        else if (duplicateMode == IPlacementConstraints.ONE_LABEL_PER_FEATURE) {

//                                        // we need to register the labels already placed

//                                        if (placedLabels == null) placedLabels = new TreeSet();

//                                        else placedLabels.clear();

//                        }

                        //duplicates stuff

                        boolean bLabelsReallocatable = !isAllowOverlapping();

                        BufferedImage levelImg = null, 

                        bi = new BufferedImage(

                                        mapImage.getWidth(),

                                        mapImage.getHeight(),

                                        BufferedImage.TYPE_INT_ARGB

                                );

                        Graphics2D levelGraphics = null,

                        gBi = bi.createGraphics();

                        gBi.setRenderingHints(mapGraphics.getRenderingHints());

                        if (bLabelsReallocatable) {

                                levelImg = new BufferedImage(mapImage.getWidth(),mapImage.getHeight(),BufferedImage.TYPE_INT_ARGB);

                                levelGraphics = bi.createGraphics();

                                levelGraphics.setRenderingHints(mapGraphics.getRenderingHints());

                        }

                        while ( !cancel.isCanceled() && it.hasNext()) {

                                IFeature feat = it.next();

                                IGeometry geom = feat.getGeometry();

                                if (!setupLabel(feat, lc, cancel, usedFields, viewPort, dpi, duplicateMode, placedLabels))

                                        continue;

                                // Check if size is a pixel

                                if (isOnePoint(viewPort, geom)) {

                                        continue;

                                }

                                BufferedImage[] targetBis;

                                Graphics2D targetG;

                                if (method.definesPriorities()) {

                                        if (bLabelsReallocatable) {

                                                targetBis = new BufferedImage[] { bi, levelImg } ;

                                                targetG = levelGraphics;

                                        } else {

                                                targetBis = new BufferedImage[] { bi } ;

                                                targetG = gBi;

                                        }

                                } else {

                                        if (bLabelsReallocatable) {

                                                targetBis = new BufferedImage[] { bi };

                                                targetG = gBi;

                                        } else {

                                                targetBis = new BufferedImage[] { mapImage };

                                                targetG = mapGraphics;

                                        }

                                }

                                // Calculate the label possible places

                                ArrayList<LabelLocationMetrics> llm = placement.guess(

                                                lc, 

                                                FConverter.transformToInts(geom, viewPort.getAffineTransform()),

                                                getPlacementConstraints(),

                                                0,

                                                cancel);

                                /* 

                                 * search if there is room left by the previous and

                                 * with more priority labels, then check the current

                                 * level

                                 */

                                if (lookupAndPlaceLabel(targetBis, targetG,

                                                llm, placement, lc, geom, viewPort, cancel,

                                                bLabelsReallocatable)) {

                                        placedCount++;

                                } else {

                                        notPlacedCount++;

                                }

                                if (bLabelsReallocatable) {

                                        mapGraphics.drawImage(bi, null, null);

                                }

                        }

                }

                int total = placedCount+notPlacedCount;

                Logger.getLogger(getClass()).info("Labeled layer '"+layer.getName()+"' "+(System.currentTimeMillis()-t1)/1000D+" seconds. "+placedCount+"/"+total+" labels placed ("+NumberFormat.getInstance().format(100*placedCount/(double) total)+"%)");

        }

        private int getDuplicateLabelsMode() {

                if (getPlacementConstraints() == null) {

                        return IPlacementConstraints.DefaultDuplicateLabelsMode;

                }

                return getPlacementConstraints().getDuplicateLabelsMode();

        }

        private boolean lookupAndPlaceLabel(BufferedImage[] bis, Graphics2D g, ArrayList<LabelLocationMetrics> llm, ILabelPlacement placement, LabelClass lc, IGeometry geom, ViewPort viewPort, Cancellable cancel, boolean bLabelsReallocatable) {

                int i;

                for (i = 0; !cancel.isCanceled() && i < llm.size(); i++) {

                        LabelLocationMetrics labelMetrics = llm.get(i);

                        if (bLabelsReallocatable) {

                                for (int j = 0; j < bis.length; j++) {

                                        BufferedImage bi = bis[j];

                                        if (!isOverlapping(bi, lc.getShape(labelMetrics))) {

                                                lc.draw(g, labelMetrics, null);

//                                                SimpleMarkerSymbol sms = new SimpleMarkerSymbol();

//                                                sms.setSize(5);

//                                                sms.setColor(Color.YELLOW);

//                                                sms.draw(g, null, new FPoint2D(labelMetrics.getAnchor()), null);

                                                return true;

                                        }        

                                }

                        } else {

                                lc.draw(g, labelMetrics, null);        

                                return true;

                        }

                } 

                return false;

        }

        @SuppressWarnings("unchecked")

        private boolean setupLabel(IFeature feat, LabelClass lc, 

        Cancellable cancel, String[] usedFields, ViewPort viewPort,

        double dpi, int duplicateMode, TreeSet<?> placedLabels) {

                Value[] vv = feat.getAttributes();

                String expr = lc.getLabelExpression();

                LabelExpressionParser parser = new LabelExpressionParser(

                                new CharArrayReader(expr.toCharArray()));

                for (int i = 0; !cancel.isCanceled() && i < usedFields.length; i++) {

                        parser.putSymbol(

                                        Symbol.createVariableSymbolFromValue(usedFields[i], vv[i]));

                }

                String[] texts;

                try {

                        texts = parser.LabelExpression();

                        if (duplicateMode == IPlacementConstraints.REMOVE_DUPLICATE_LABELS) {

                                // check if this text (so label) is already present in the map

                                if (placedLabels.contains(texts)) 

                                        // the label has already placed before

                                        return false;

                                /*

                                 *  the text is not present, it will be registered for next to

                                 *  be avoided

                                 */

                                ((TreeSet<String[]>) placedLabels).add(texts);

                        }

                        lc.setTexts(texts);

                } catch (ParseException e) {

                        e.printStackTrace();

                        return false;

                } 

                lc.toCartographicSize(viewPort, dpi, null);

                return true;

        }

        private boolean isOverlapping(BufferedImage bi, FShape labelShape) {

                Rectangle2D rPixels = labelShape.getBounds2D();

            for (int i= (int) rPixels.getX(); i<rPixels.getMaxX(); i++){

                for (int j= (int) rPixels.getY(); j<rPixels.getMaxY(); j++){

                        if (!labelShape.contains(i, j)) {

                                continue;

                        }

                        if (i<0 || j<0) {

                                continue;

                        }

                        if (bi.getWidth()<i+1 || bi.getHeight()<j+1) {

                                continue;

                        }

                    if (bi.getRGB(i,j)!=0){

                                return true;

                    }

                }

            }

            return false;

        }

        private boolean isOnePoint(ViewPort viewPort, IGeometry geom) {

                boolean onePoint = false;

                int shapeType = geom.getGeometryType();

                if (shapeType!=FShape.POINT && shapeType!=FShape.MULTIPOINT) {

                        Rectangle2D geomBounds = geom.getBounds2D();

                        ICoordTrans ct = layer.getCoordTrans();

                        if (ct!=null) {

                                geomBounds = ct.convert(geomBounds);

                        }

                        double dist1Pixel = viewPort.getDist1pixel();

                        onePoint = (geomBounds.getWidth() <= dist1Pixel

                                        && geomBounds.getHeight() <= dist1Pixel);

                }

                return onePoint;

        }

        public String getClassName() {

                return getClass().getName();

        }

        public XMLEntity getXMLEntity() {

                XMLEntity xml = new XMLEntity();

                xml.putProperty("className", getClassName());

                xml.putProperty("allowOverlapping", allowOverlapping);

                xml.putProperty("minScaleView", minScaleView);

                xml.putProperty("maxScaleView", maxScaleView);

                if (method!=null) {

                        XMLEntity methodEntity = method.getXMLEntity();

                        methodEntity.putProperty("id", "LabelingMethod");

                        xml.addChild(methodEntity);

                }

                if (placementConstraints != null) {

                        XMLEntity pcEntity = placementConstraints.getXMLEntity();

                        pcEntity.putProperty("id", "PlacementConstraints");

                        xml.addChild(pcEntity);

                }

                if (zoomConstraints != null) {

                        XMLEntity zcEntity = zoomConstraints.getXMLEntity();

                        zcEntity.putProperty("id", "ZoomConstraints");

                        xml.addChild(zcEntity);

                }

                return xml;

        }

        public void setXMLEntity(XMLEntity xml) {

                XMLEntity aux = xml.firstChild("id", "LabelingMethod");

                // overlapping mode

                if (xml.contains("allowsOverlapping")) {

                        allowOverlapping = xml.getBooleanProperty("allowsOverlapping");

                }

                // scale visualization

                if (xml.contains("minScaleView")) {

                        minScaleView = xml.getLongProperty("minScaleView");

                }

                if (xml.contains("maxScaleView")) {

                        maxScaleView = xml.getLongProperty("maxScaleView");

                }

                if (aux != null) {

                        method = LabelingFactory.createMethodFromXML(aux);

                }

                aux = xml.firstChild("id", "PlacementConstraints");

                if (aux != null) {

                        placementConstraints = LabelingFactory.createPlacementConstraintsFromXML(aux);

                }

                aux = xml.firstChild("id", "ZoomConstraints");

                if (aux != null) {

                        zoomConstraints = LabelingFactory.createZoomConstraintsFromXML(aux);

                }

        }

        public boolean isAllowOverlapping() {

                return allowOverlapping;

        }

        public void setAllowOverlapping(boolean allowOverlapping) {

                this.allowOverlapping = allowOverlapping;

        }

        public IPlacementConstraints getPlacementConstraints() {

                return placementConstraints;

        }

        public void setPlacementConstraints(IPlacementConstraints constraints) {

                this.placementConstraints = constraints;

        }

        public IZoomConstraints getZoomConstraints() {

                return zoomConstraints;

        }

        public void setZoomConstraints(IZoomConstraints constraints) {

                this.zoomConstraints = constraints;

        }

        public void print(Graphics2D g, ViewPort viewPort, Cancellable cancel, PrintRequestAttributeSet properties) throws ReadDriverException {

        }

        public String[] getUsedFields() {

                LabelClass[] lcs = method.getLabelClasses();

                ArrayList<String> fieldNames = new ArrayList<String>(); 

                for (int i = 0; i < lcs.length; i++) {

                        String expr = lcs[i].getLabelExpression();

                        int start;

                        while ((start = expr.indexOf("[")) != -1) {

                                int end = expr.indexOf("]"); 

                                String field = expr.substring(start+1, end).trim();

                                if (!fieldNames.contains(field))

                                        fieldNames.add(field);

                                expr = expr.substring(end+1, expr.length());

                        }

                }

                return fieldNames.toArray(new String[fieldNames.size()]);

        }

        public boolean shouldDrawLabels(double scale) {

                if (minScaleView == -1 && maxScaleView == -1) {

                        // parameters not set, so the layer decides.

                        return layer.isWithinScale(scale);

                }

                if (minScaleView <= scale) {

                        return (maxScaleView != -1) ? maxScaleView >= scale : true;

                }

                return false;

        }

        public long getMaxScaleView() {

                return maxScaleView; 

        }

        public long getMinScaleView() {

                return minScaleView; 

        }

        public void setMaxScaleView(long maxScaleView) {

                this.maxScaleView = maxScaleView;

        }

        public void setMinScaleView(long minScaleView) {

                this.minScaleView = minScaleView;

        }

}