*    GeoTools - The Open Source Java GIS Toolkit

*    http://geotools.org

*

*    (C) 2004-2014, Open Source Geospatial Foundation (OSGeo)

*

*    This library is free software; you can redistribute it and/or

*    modify it under the terms of the GNU Lesser General Public

*    License as published by the Free Software Foundation;

*    version 2.1 of the License.

*

*    This library 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

*    Lesser General Public License for more details.

*/

* A streaming implementation of the GTRenderer interface.

* <ul>

* <li>The code is relatively simple to understand, so it can be used as a

* simple example of an SLD compliant rendering code</li>

* <li>Uses as little memory as possible</li>

* </ul>

* Use this class if you need a stateless renderer that provides low memory

* footprint and decent rendering performance on the first call but don't need

* good optimal performance on subsequent calls on the same data.

*

* <p>

* The streaming renderer is not thread safe

*

* @author James Macgill

* @author dblasby

* @author jessie eichar

* @author Simone Giannecchini

* @author Andrea Aime

* @author Alessio Fabiani

*

*

*

* @source $URL$

* @version $Id$

*/

    private static final int REPROJECTION_RASTER_GUTTER = 10;

    private final static int defaultMaxFiltersToSendToDatastore = 5; // default

    /**

     * Computes the scale as the ratio between map distances and real world distances,

     * assuming 90dpi and taking into consideration projection deformations and actual

     * earth shape. <br>

     * Use this method only when in need of accurate computation. Will break if the

     * data extent is outside of the currenct projection definition area.

     */

    public static final String SCALE_ACCURATE = "ACCURATE";

    /**

     * Very simple and lenient scale computation method that conforms to the OGC SLD

     * specification 1.0, page 26. <br>This method is quite approximative, but should

     * never break and ensure constant scale even on lat/lon unprojected maps (because

     * in that case scale is computed as if the area was along the equator no matter

     * what the real position is).

     */

    public static final String SCALE_OGC = "OGC";

    /**

     * The rendering buffer grows the query area to account for features that are contributing to

     * the requested area due to their large symbolizer, or long label

     */

    public static final String RENDERING_BUFFER = "renderingBuffer";

    /** Tolerance used to compare doubles for equality */

    private static final double TOLERANCE = 1e-6;

    /** The logger for the rendering module. */

    private static final Logger LOGGER = org.geotools.util.logging.Logging.getLogger("org.geotools.rendering");

    int error = 0;

    /** Filter factory for creating bounding box filters */

    private final static FilterFactory2 filterFactory = CommonFactoryFinder.getFilterFactory2(null);

    private final static PropertyName gridPropertyName = filterFactory.property("grid");

    private final static PropertyName paramsPropertyName = filterFactory.property("params");

    private final static PropertyName defaultGeometryPropertyName = filterFactory.property("");

    /**

     * The MapContent instance which contains the layers and the bounding box which needs to be

     * rendered.

     */

    private MapContent mapContent;

    /**

     * Flag which determines if the renderer is interactive or not. An

     * interactive renderer will return rather than waiting for time consuming

     * operations to complete (e.g. Image Loading). A non-interactive renderer

     * (e.g. a SVG or PDF renderer) will block for these operations.

     */

    private boolean interactive = true;

    /**

     * Flag which controls behaviour for applying affine transformation to the

     * graphics object. If true then the transform will be concatenated to the

     * existing transform. If false it will be replaced.

     */

    private boolean concatTransforms = false;

    /** Geographic map extent, eventually expanded to consider buffer area around the map */

    private ReferencedEnvelope mapExtent;

    /** Geographic map extent, as provided by the caller */

    private ReferencedEnvelope originalMapExtent;

    /**

     * The handler that will be called to process the geometries to deal with projections

     * singularities and dateline wrapping

     */

    private ProjectionHandler projectionHandler;

    /** The size of the output area in output units. */

    private Rectangle screenSize;

    /**

     * This flag is set to false when starting rendering, and will be checked

     * during the rendering loop in order to make it stop forcefully

     */

    private volatile boolean renderingStopRequested = false;

    /**

     * The ratio required to scale the features to be rendered so that they fit

     * into the output space.

     */

    protected double scaleDenominator;

    /** Maximum displacement for generalization during rendering */

    private double generalizationDistance = 0.8;

    /** Factory that will resolve symbolizers into rendered styles */

    private SLDStyleFactory styleFactory = new SLDStyleFactory();

    protected LabelCache labelCache = new LabelCacheImpl();

    /** The painter class we use to depict shapes onto the screen */

    private StyledShapePainter painter = new StyledShapePainter(labelCache);

    private BlockingQueue<RenderingRequest> requests;

    private IndexedFeatureResults indexedFeatureResults;

    private List<RenderListener> renderListeners = new CopyOnWriteArrayList<RenderListener>();

    private RenderingHints java2dHints;

    private int renderingBufferDEFAULT = 0;

    private String scaleComputationMethodDEFAULT = SCALE_OGC;

    /**

     * Text will be rendered using the usual calls gc.drawString/drawGlyphVector.

     * This is a little faster, and more consistent with how the platform renders

     * the text in other applications. The downside is that on most platform the label

     * and its eventual halo are not properly centered.

     */

    public static final String TEXT_RENDERING_STRING = LabelCacheImpl.LabelRenderingMode.STRING.name();

    /**

     * Text will be rendered using the associated {@link GlyphVector} outline, that is, a {@link Shape}.

     * This ensures perfect centering between the text and the halo, but introduces more text aliasing.

     */

    public static final String TEXT_RENDERING_OUTLINE = LabelCacheImpl.LabelRenderingMode.OUTLINE.name();