| 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: PolygonPlacementConstraints.java 13606 2007-09-10 15:47:11Z jaume $

* $Log$

* Revision 1.11  2007-09-10 15:47:11  jaume

* *** empty log message ***

*

* Revision 1.10  2007/07/18 06:54:34  jaume

* continuing with cartographic support

*

* Revision 1.9  2007/04/26 11:41:00  jaume

* attempting to let defining size in world units

*

* Revision 1.8  2007/04/19 14:21:30  jaume

* *** empty log message ***

*

* Revision 1.7  2007/04/18 15:35:11  jaume

* *** empty log message ***

*

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

* *** empty log message ***

*

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

* basic labeling support for lines

*

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

* maybe a label placer refactor

*

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

* Styled labeling (start commiting)

*

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

* *** empty log message ***

*

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

* labeling starts working

*

*

*/

package com.iver.cit.gvsig.fmap.rendering.styling;

import java.awt.Graphics2D;

import java.awt.Rectangle;

import java.awt.geom.AffineTransform;

import java.awt.geom.PathIterator;

import java.awt.geom.Point2D;

import java.util.Vector;

import java.util.logging.Level;

import java.util.logging.Logger;

import org.cresques.px.gml.MultiPolygon;

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

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

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.utiles.XMLEntity;

import com.vividsolutions.jts.geom.Geometry;

import com.vividsolutions.jts.geom.Point;

/**

 *

 * @author jaume dominguez faus - jaume.dominguez@iver.es

 *

 */

public class PolygonPlacementConstraints extends AbstractPlacementConstraints {

        private static final double HALF_PI = Math.PI * 0.5;

        public PolygonPlacementConstraints() {

                setPlacementMode(HORIZONTAL);

        }

        public FShape[] getLocationsFor(IGeometry geom, FShape labelShape, MultiPolygon exclusionZone) {

                // TODO Implement it

                throw new Error("Not yet implemented!");

        }

        public void placeLabel(Graphics2D g, IGeometry geom, LabelClass lc, MultiPolygon exclusionZone, AffineTransform transform) {

                Rectangle labelBounds = lc.getShape(g, transform, geom).getBounds();

                double theta = 0;

                Geometry geo = FConverter.java2d_to_jts((FShape) geom.getInternalShape());

                if (geo == null) {

                        return;

                }

                Point pJTS = geo.getCentroid();

                if (pJTS == null) {

                        Logger.getAnonymousLogger().log(Level.SEVERE, "no centroid could be found");

                        return;

                }

                FPoint2D startingPoint = new FPoint2D(pJTS.getX(), pJTS.getY());

                if (isHorizontal()) {

                } else if (isParallel()) {

                        // calculated with the Linear Regression technique

                        PathIterator pi = geom.getPathIterator(transform);

                        geom.transform(transform);

                        Rectangle geomBounds =geom.getBounds();

                        double sumx = 0, sumy = 0, sumxx = 0, sumyy = 0, sumxy = 0;

                        double Sxx, Sxy, b, a;

                        double[] coords = new double[6];

                        int count = 0;

                        // add points to the regression process

                        Vector v = new Vector();

                        while (!pi.isDone()) {

                                pi.currentSegment(coords);

                                Point2D p;

                                if (geomBounds.width > geomBounds.height)

                                        p = new Point2D.Double(coords[0], coords[1]);

                                else

                                        p = new Point2D.Double(coords[1], coords[0]);

                                v.addElement(p);

                                count++;

                                sumx += p.getX();

                                sumy += p.getY();

                                sumxx += p.getX()*p.getX();

                                sumyy += p.getY()*p.getY();

                                sumxy += p.getX()*p.getY();

                                pi.next();

                        }

                        // start regression

                        double n = (double) count;

                        Sxx = sumxx-sumx*sumx/n;

                        Sxy = sumxy-sumx*sumy/n;

                        b = Sxy/Sxx;

                        a = (sumy-b*sumx)/n;

                        boolean isVertical = false;

                        if (geomBounds.width < geomBounds.height) {

                                if (b == 0) {

                                        // force vertical (to avoid divide by zero)

                                        isVertical = true;

                                } else {

                                        // swap axes

                                        double bAux = 1/b;

                                        a = - a / b;

                                        b = bAux;

                                }

                        }

                        if (isVertical){

                                theta = HALF_PI;

                        } else {

                                double p1x = 0;

                                double  p1y =geomBounds.height-a;

                                double  p2x = geomBounds.width;

                                double  p2y = geomBounds.height-

                                (a+geomBounds.width*b);

                                theta = -Math.atan(((p2y - p1y) / (p2x - p1x)) );

                        }

//                        } else {

//                        int minx = 0, miny = 0, maxx = 0, maxy = 0;

//                        while (!pi.isDone()) {

//                        pi.currentSegment(coords);

//                        FPoint2D p = new FPoint2D(coords[0], coords[1]);

//                        if (coords[0] < geomBounds.width /2) {

//                        minx += coords[0] % geomBounds.width;

//                        } else {

//                        maxx += coords[0] %geomBounds.width;

//                        }

//

//                        if (coords[1] < geomBounds.height/2) {

//                        miny += coords[1] %geomBounds.height;

//                        } else {

//                        maxy += coords[1] %geomBounds.height;

//                        }

//

//                        g.drawRect((int) coords[0], (int) coords[1], 1, 1);

//                        pi.next();

//                        count++;

//                        }

//

//                        if (count >0) {

//                        minx /= count;

//                        miny /= count;

//                        maxx /= count;

//                        maxy /= count;

//

//                        theta = -Math.atan(((maxy - miny) / (maxx - minx)) );

//                        System.err.println("("+minx+","+miny+","+maxx+","+maxy+")");

//                        g.setColor(Color.RED);

//                        g.drawRect((int) (maxx + geomBounds.x), (int) (maxy + geomBounds.y), 1,1);

//                        g.setColor(Color.BLUE);

//                        g.drawRect((int) minx + geomBounds.x, (int) miny + geomBounds.y, 1,1);

//                        }

//                        }

                }

                startingPoint.transform(transform);

                // center the label TODO change this

                labelBounds.setLocation(0-(int) (labelBounds.width*.5), 0 - (int) (labelBounds.height*.5));

                g.translate((int) startingPoint.getX(), (int) startingPoint.getY());

                if (theta != 0) {

                        g.rotate(theta);

                }

                lc.drawInsideRectangle(g, labelBounds);

                if (theta != 0) {

                        g.rotate(-theta);

                }

                g.translate(-(int) startingPoint.getX(), -(int) startingPoint.getY());

        }

        public String getClassName() {

                return getClass().getName();

        }

        public XMLEntity getXMLEntity() {

                XMLEntity xml = super.getXMLEntity();

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

                return xml;

        }

        public void postprocess() {

                // TODO Auto-generated method stub

                throw new Error("Not yet implemented!");

        }

        public void preprocess(IFeatureIterator featIterator) {

                // TODO Auto-generated method stub

                throw new Error("Not yet implemented!");

        }

}