Setting the renderer of the ten-thousand-points example to
WebGL should remove the need for this stub. This is basically
the same approach we took for all vector examples in master,
where we set the renderer to Canvas.
This change reverts the RTree API back to the original one (i.e.
insert() instead of put(), search() instead of find()), and
creates a new searchReturningObject() method that returns an
object keyed by UIDs.
It also adds missing tests for type restricted search and
searchReturningObject().
Not using Math.max and Math.min increases performance, and by
using ol.extent functions instead of RTree's rectangle
structures and calculations we can get rid of several functions.
This new implementation is based on
http://github.com/imbcmdth/RTree/, with only a few modifications
to add the optional type and provide the API of the previous
implementation.
There is still room for optimization, but this is such an
improvement over the previous RTree already that it's worth
bringing it in now.
By doing the type check before the intersection check, we can
save he intersection check for cases where we don't care about
type or have the specified type in a node.
On servers that report an incorrect content type for XML
documents, responseXML will be empty. In these cases we need to
use responseText instead. This change also prevents readNode
calls with empty data.
The reason for this change is that symbolSizes and maxSymbolSize
on the instance will be wrong as soon as the resolution changes
and cached tiles are used. It turned out that the approach used
now has several advantages: smaller symbolSizes objects, no need
to merge symbolSizes objects, and cache management for free (no
risk of memory leaks). Note that the symbolSizes and
maxSymbolSize for each tile are not strictly tile specific -
they represent the rendering pass that created the tile. This
has no negative side effects, and it has the advantage that
there is not a single additional loop needed to create these
structures.
With this change, hit detection for lines and points gets very
accurate, because the vector renderer instance keeps track of
line widths and point symbol sizes. After doing a bbox query in
the RTree, returned lines and points are evaluated against the
thresholds of their line width or symbol size. The KML example
with its different symbolizers now has getFeatureInfo too to
show this in action.
As suggested by @tschaub in #674, geom.pointInPoly is not needed
if we have geom.LinearRing#containsCoordinate. This pull request
also adds tests and documentation on the limitations of the
containsCoordinate method.
I think for now it is ok to keep geometry/topology functions as
simple as possible in ol3. If we decide to not rely on third
party libraries like jsts for topology operations, we can always
refine what we have and e.g. port topology operations over from
ol2.
This method is an entry point for getting feature information.
Renderers can use a hit canvas or defer to a layer (source) to
get matching features for a pixel.
For now this is only implemented for vector layers, and it uses
a bbox query because we cannot refine the result because of
missing geometry intersection functions yet.
When auto-generating the website using grunt in the
openlayers.github.io repo, we do not need to publish new docs
every time grunt is run, just because the timestamp is updated.
This adds the infrastructure that we need for documenting
exported object literals. This is best done by using *.jsdoc
files, which are parsed by JSDoc but not the Closure Compiler.
In addition to adding the documentation of the objects literal
properties, the respective namespaces must also be annotated.
Restricting the API docs to the exported API will be added as a
separate pull request.
This change enables GitHub flavored markdown for APIdoc
comments. The code example in map.js shows how to use markdown
for code snippets. doc/index.md is now included again as start
page for the docs. Everything in the doc/tutorials directory
will also be added to the docs as tutorial. As an example, I
moved the ol3.md file with the architecture to the tutorials
directory.
Currently properties and methods annotated with @inheritDoc
or @override won't be documented at all. This is a known issue,
so I added a custom JSDoc plugin with a hack to avoid this.
Rendering vector tiles with mixed geometry types does not work
as expected, because the tile is created without the geometries
that need another rendering pass because of missing icons. This
was discovered by @bartvde when working on the KML parser, where
mixed geometry types are common.
This change fixes the issue by breaking out from rendering
entirely when renderFeaturesByGeometryType returns a deferred
state. In addition, there was a related bug because icons are
added to the cache regardless of its loaded state. This is also
fixed now.
This change removes all changes that were anticipated here for
WMS GetFeatureInfo handling, including the IWMS interface and
the goog.provide for 'ol.tilegrid'. I'll create a separate pull
request for WMS GetFeatureInfo eventually, taking into account
the suggestions from the discussion in #402.
With this change, url functions are called in the scope of the
source they are configured for. This allows us to simplify the
url function generation for WMS, using a more generic
createFromParamsFunction factory, and the source's new params
member.
Note that there is also a new url member for WMS sources. This
is the WMS base url (the first one in case there is an array of
urls for faster tile access). This can be used for accessing
other WMS services (especially GetFeatureInfo).
Multiple fast clicks get interpreted as DBLCLICK by the browser,
so it makes sense to stop propagation of DBLCLICK events when
they happen on elements on the overlay container. This is also
a good change because DBLCLICK might have a meaning on other map
overlays as well.
ahocevar