ExternalVendorCode/tippecanoe
1
0
Fork 0
mirror of https://github.com/mapbox/tippecanoe.git synced 2025-03-25 05:15:16 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Merge pull request #333 from mapbox/wagyu-clean

Browse Source 
Switch polygon topology correction from Clipper to Wagyu
This commit is contained in:
Eric Fischer 2016-12-14 16:13:31 -08:00 committed by GitHub
commit 78d91b3fde
76 changed files with 23523 additions and 21739 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
CHANGELOG.md
View File

@ -1,3 +1,7 @@
## 1.16.0
* Switch from Clipper to Wagyu for polygon topology correction
## 1.15.4
* Dot-dropping with -r/-B doesn't apply if there is a per-feature minzoom tag

4
Makefile
View File

@ -7,7 +7,7 @@ SHELL = /bin/bash
CC := $(CC)
CXX := $(CXX)
CFLAGS := $(CFLAGS)
CXXFLAGS := $(CXXFLAGS) -std=c++11
CXXFLAGS := $(CXXFLAGS) -std=c++14
LDFLAGS := $(LDFLAGS)
WARNING_FLAGS := -Wall -Wshadow -Wsign-compare
RELEASE_FLAGS := -O3 -DNDEBUG
@ -46,7 +46,7 @@ C = $(wildcard *.c) $(wildcard *.cpp)
INCLUDES = -I/usr/local/include -I.
LIBS = -L/usr/local/lib
tippecanoe: geojson.o jsonpull/jsonpull.o tile.o pool.o mbtiles.o geometry.o projection.o memfile.o clipper/clipper.o mvt.o serial.o main.o text.o
tippecanoe: geojson.o jsonpull/jsonpull.o tile.o pool.o mbtiles.o geometry.o projection.o memfile.o mvt.o serial.o main.o text.o
$(CXX) $(PG) $(LIBS) $(FINAL_FLAGS) $(CXXFLAGS) -o $@ $^ $(LDFLAGS) -lm -lz -lsqlite3 -lpthread
tippecanoe-enumerate: enumerate.o

407
clipper/README
View File

@ -1,407 +0,0 @@
=====================================================================
Clipper Change Log
=====================================================================
v6.2.1 (31 October 2014) Rev 482
* Bugfix in ClipperOffset.Execute where the Polytree.IsHole property
was returning incorrect values with negative offsets
* Very minor improvement to join rounding in ClipperOffset
* Fixed CPP OpenGL demo.
v6.2.0 (17 October 2014) Rev 477
* Numerous minor bugfixes, too many to list.
(See revisions 454-475 in Sourceforge Repository)
* The ZFillFunction (custom callback function) has had its parameters
changed.
* Curves demo removed (temporarily).
* Deprecated functions have been removed.
v6.1.5 (26 February 2014) Rev 460
* Improved the joining of output polygons sharing a common edge
when those common edges are horizontal.
* Fixed a bug in ClipperOffset.AddPath() which would produce
incorrect solutions when open paths were added before closed paths.
* Minor code tidy and performance improvement
v6.1.4 (6 February 2014)
* Fixed bugs in MinkowskiSum
* Fixed minor bug when using Clipper.ForceSimplify.
* Modified use_xyz callback so that all 4 vertices around an
intersection point are now passed to the callback function.
v6.1.3a (22 January 2014) Rev 453
* Fixed buggy PointInPolygon function (C++ and C# only).
Note this bug only affected the newly exported function, the
internal PointInPolygon function used by Clipper was OK.
v6.1.3 (19 January 2014) Rev 452
* Fixed potential endless loop condition when adding open
paths to Clipper.
* Fixed missing implementation of SimplifyPolygon function
in C++ code.
* Fixed incorrect upper range constant for polygon coordinates
in Delphi code.
* Added PointInPolygon function.
* Overloaded MinkowskiSum function to accommodate multi-contour
paths.
v6.1.2 (15 December 2013) Rev 444
* Fixed broken C++ header file.
* Minor improvement to joining polygons.
v6.1.1 (13 December 2013) Rev 441
* Fixed a couple of bugs affecting open paths that could
raise unhandled exceptions.
v6.1.0 (12 December 2013)
* Deleted: Previously deprecated code has been removed.
* Modified: The OffsetPaths function is now deprecated as it has
been replaced by the ClipperOffset class which is much more
flexible.
* Bugfixes: Several minor bugs have been fixed including
occasionally an incorrect nesting within the PolyTree structure.
v6.0.0 (30 October 2013)
* Added: Open path (polyline) clipping. A new 'Curves' demo
application showcases this (see the 'Curves' directory).
* Update: Major improvement in the merging of
shared/collinear edges in clip solutions (see Execute).
* Added: The IntPoint structure now has an optional 'Z' member.
(See the precompiler directive use_xyz.)
* Added: Users can now force Clipper to use 32bit integers
(via the precompiler directive use_int32) instead of using
64bit integers.
* Modified: To accommodate open paths, the Polygon and Polygons
structures have been renamed Path and Paths respectively. The
AddPolygon and AddPolygons methods of the ClipperBase class
have been renamed AddPath and AddPaths respectively. Several
other functions have been similarly renamed.
* Modified: The PolyNode Class has a new IsOpen property.
* Modified: The Clipper class has a new ZFillFunction property.
* Added: MinkowskiSum and MinkowskiDiff functions added.
* Added: Several other new functions have been added including
PolyTreeToPaths, OpenPathsFromPolyTree and ClosedPathsFromPolyTree.
* Added: The Clipper constructor now accepts an optional InitOptions
parameter to simplify setting properties.
* Bugfixes: Numerous minor bugs have been fixed.
* Deprecated: Version 6 is a major upgrade from previous versions
and quite a number of changes have been made to exposed structures
and functions. To minimize inconvenience to existing library users,
some code has been retained and some added to maintain backward
compatibility. However, because this code will be removed in a
future update, it has been marked as deprecated and a precompiler
directive use_deprecated has been defined.
v5.1.6 (23 May 2013)
* BugFix: CleanPolygon function was buggy.
* Changed: The behaviour of the 'miter' JoinType has been
changed so that when squaring occurs, it's no longer
extended up to the miter limit but is squared off at
exactly 'delta' units. (This improves the look of mitering
with larger limits at acute angles.)
* Added: New OffsetPolyLines function
* Update: Minor code refactoring and optimisations
v5.1.5 (5 May 2013)
* Added: ForceSimple property to Clipper class
* Update: Improved documentation
v5.1.4 (24 March 2013)
* Update: CleanPolygon function enhanced.
* Update: Documentation improved.
v5.1.3 (14 March 2013)
* Bugfix: Minor bugfixes.
* Update: Documentation significantly improved.
v5.1.2 (26 February 2013)
* Bugfix: PolyNode class was missing a constructor.
* Update: The MiterLimit parameter in the OffsetPolygons
function has been renamed Limit and can now also be used to
limit the number of vertices used to construct arcs when
JoinType is set to jtRound.
v5.1.0 (17 February 2013)
* Update: ExPolygons has been replaced with the PolyTree &
PolyNode classes to more fully represent the parent-child
relationships of the polygons returned by Clipper.
* Added: New CleanPolygon and CleanPolygons functions.
* Bugfix: Another orientation bug fixed.
v5.0.2 - 30 December 2012
* Bugfix: Significant fixes in and tidy of the internal
Int128 class (which is used only when polygon coordinate
values are greater than ±0x3FFFFFFF (~1.07e9)).
* Update: The Area algorithm has been updated and is faster.
* Update: Documentation updates. The newish but undocumented
'CheckInputs' parameter of the OffsetPolygons function has been
renamed 'AutoFix' and documented too. The comments on rounding
have also been improved (ie clearer and expanded).
v4.10.0 - 25 December 2012
* Bugfix: Orientation bugs should now be resolved (finally!).
* Bugfix: Bug in Int128 class
v4.9.8 - 2 December 2012
* Bugfix: Further fixes to rare Orientation bug.
v4.9.7 - 29 November 2012
* Bugfix: Bug that very rarely returned the wrong polygon
orientation.
* Bugfix: Obscure bug affecting OffsetPolygons when using
jtRound for the JoinType parameter and when polygons also
contain very large coordinate values (> +/-100000000000).
v4.9.6 - 9 November 2012
* Bugfix: Another obscure bug related to joining polygons.
v4.9.4 - 2 November 2012
* Bugfix: Bugs in Int128 class occasionally causing
wrong orientations.
* Bugfix: Further fixes related to joining polygons.
v4.9.0 - 9 October 2012
* Bugfix: Obscure bug related to joining polygons.
v4.8.9 - 25 September 2012
* Bugfix: Obscure bug related to precision of intersections.
v4.8.8 - 30 August 2012
* Bugfix: Fixed bug in OffsetPolygons function introduced in
version 4.8.5.
v4.8.7 - 24 August 2012
* Bugfix: ReversePolygon function in C++ translation was broken.
* Bugfix: Two obscure bugs affecting orientation fixed too.
v4.8.6 - 11 August 2012
* Bugfix: Potential for memory overflow errors when using
ExPolygons structure.
* Bugfix: The polygon coordinate range has been reduced to
+/- 0x3FFFFFFFFFFFFFFF (4.6e18).
* Update: ReversePolygons function was misnamed ReversePoints in C++.
* Update: SimplifyPolygon function now takes a PolyFillType parameter.
v4.8.5 - 15 July 2012
* Bugfix: Potential for memory overflow errors in OffsetPolygons().
v4.8.4 - 1 June 2012
* Bugfix: Another obscure bug affecting ExPolygons structure.
v4.8.3 - 27 May 2012
* Bugfix: Obscure bug causing incorrect removal of a vertex.
v4.8.2 - 21 May 2012
* Bugfix: Obscure bug could cause an exception when using
ExPolygon structure.
v4.8.1 - 12 May 2012
* Update: Cody tidy and minor bug fixes.
v4.8.0 - 30 April 2012
* Bugfix: Occasional errors in orientation fixed.
* Update: Added notes on rounding to the documentation.
v4.7.6 - 11 April 2012
* Fixed a bug in Orientation function (affecting C# translations only).
* Minor documentation update.
v4.7.5 - 28 March 2012
* Bugfix: Fixed a recently introduced bug that occasionally caused an
unhandled exception in C++ and C# translations.
v4.7.4 - 15 March 2012
* Bugfix: Another minor bugfix.
v4.7.2 - 4 March 2012
* Bugfix: Fixed bug introduced in ver 4.7 which sometimes caused
an exception if ExPolygon structure was passed to Clipper's
Execute method.
v4.7.1 - 3 March 2012
* Bugfix: Rare crash when JoinCommonEdges joined polygons that
'cancelled' each other.
* Bugfix: Clipper's internal Orientation method occasionally
returned wrong result.
* Update: Improved C# code (thanks to numerous excellent suggestions
from David Piepgrass)
v4.7 - 10 February 2012
* Improved the joining of output polygons sharing a common edge.
v4.6.6 - 3 February 2012
* Bugfix: Another obscure bug occasionally causing incorrect
polygon orientation.
v4.6.5 - 17 January 2012
* Bugfix: Obscure bug occasionally causing incorrect hole
assignment in ExPolygon structure.
v4.6.4 - 8 November 2011
* Added: SimplifyPolygon and SimplifyPolygons functions.
v4.6.3 - 11 November 2011
* Bugfix: Fixed another minor mitering bug in OffsetPolygons.
v4.6.2 - 10 November 2011
* Bugfix: Fixed a rare bug in the orientation of polygons
returned by Clipper's Execute() method.
* Bugfix: Previous update introduced a mitering bug in the
OffsetPolygons function.
v4.6 - 29 October 2011
* Added: Support for Positive and Negative polygon fill
types (in addition to the EvenOdd and NonZero fill types).
* Bugfix: The OffsetPolygons function was generating the
occasional artefact when 'shrinking' polygons.
v4.5.5 - 8 October 2011
* Bugfix: Fixed an obscure bug in Clipper's JoinCommonEdges
method.
* Update: Replaced IsClockwise function with Orientation
function. The orientation issues affecting OffsetPolygons
should now be finally resolved.
* Change: The Area function once again returns a signed value.
v4.5.1 - 28 September 2011
* Deleted: The UseFullCoordinateRange property has been
deleted since integer range is now managed implicitly.
* BugFix: Minor bug in OffsetPolygon mitering.
* Change: C# JoinType enum moved from Clipper class to
ClipperLib namespace.
* Change: The Area function now returns the absolute area
(irrespective of orientation).
* Change: The IsClockwise function now requires a second
parameter - YAxisPositiveUpward - to accommodate displays
with Y-axis oriented in either direction
v4.4.4 - 10 September 2011
* Change: Deleted jtButt from JoinType (used by the
OffsetPolygons function).
* BugFix: Fixed another minor bug in OffsetPolygons function.
* Update: Further improvements to the help file
v4.4.3 - 29 August 2011
* BugFix: fixed a minor rounding issue in OffsetPolygons
function (affected C++ & C# translations).
* BugFix: fixed a minor bug in OffsetPolygons' function
declaration (affected C++ translation only).
* Change: 'clipper' namespace changed to 'ClipperLib'
namespace in both C++ and C# code to remove the ambiguity
between the Clipper class and the namespace. (This also
required numerous updates to the accompanying demos.)
v4.4.2 - 26 August 2011
* BugFix: minor bugfixes in Clipper.
* Update: the OffsetPolygons function has been significantly
improved by offering 4 different join styles.
v4.4.0 - 6 August 2011
* BugFix: A number of minor bugs have been fixed that mostly
affected the new ExPolygons structure.
v4.3.0 - 17 June 2011
* New: ExPolygons structure that explicitly associates 'hole'
polygons with their 'outer' container polygons.
* New: Execute method overloaded so the solution parameter
can now be either Polygons or ExPolygons.
* BugFix: Fixed a rare bug in solution polygons orientation.
v4.2.8 - 21 May 2011
* Update: JoinCommonEdges() improved once more.
* BugFix: Several minor bugs fixed.
v4.2.6 - 1 May 2011
* Bugfix: minor bug in SlopesEqual function.
* Update: Merging of output polygons sharing common edges
has been significantly inproved
v4.2.4 - 26 April 2011
Input polygon coordinates can now contain the full range of
signed 64bit integers (ie +/-9,223,372,036,854,775,807). This
means that floating point values can be converted to and from
Clipper's 64bit integer coordinates structure (IntPoint) and
still retain a precision of up to 18 decimal places. However,
since the large-integer math that supports this expanded range
imposes a small cost on performance (~15%), a new property
UseFullCoordinateRange has been added to the Clipper class to
allow users the choice of whether or not to use this expanded
coordinate range. If this property is disabled, coordinate values
are restricted to +/-1,500,000,000.
v4.2 - 12 April 2011
JoinCommonEdges() code significantly improved plus other minor
improvements.
v4.1.2 - 9 April 2011
* Update: Minor code tidy.
* Bugfix: Possible endless loop in JoinCommonEdges() in clipper.pas.
v4.1.1 - 8 April 2011
* Update: All polygon coordinates are now stored as 64bit integers
(though they're still restricted to range -1.5e9 to +1.5e9 pending
the inclusion of code supporting 64bit math).
* Change: AddPolygon and AddPolygons methods now return boolean
values.
* Bugfix: Bug in JoinCommonEdges() caused potential endless loop.
* Bugfix: Bug in IsClockwise(). (C++ code only)
v4.0 - 5 April 2011
* Clipper 4 is a major rewrite of earlier versions. The biggest
change is that floating point values are no longer used,
except for the storing of edge slope values. The main benefit
of this is the issue of numerical robustness has been
addressed. Due to other major code improvements Clipper v4
is approximately 40% faster than Clipper v3.
* The AddPolyPolygon method has been renamed to AddPolygons.
* The IgnoreOrientation property has been removed.
* The clipper_misc library has been merged back into the
main clipper library.
v3.1.0 - 17 February 2011
* Bugfix: Obscure bug in TClipperBase.SetDx method that caused
problems with very small edges ( edges <1/1000th pixel in size).
v3.0.3 - 9 February 2011
* Bugfix: Significant bug, but only in C# code.
* Update: Minor refactoring.
v3.0 - 31 January 2011
* Update: Major rewrite of the portion of code that calculates
the output polygons' orientation.
* Update: Help file significantly improved.
* Change: Renamed ForceOrientation property to IgnoreOrientation.
If the orientation of output polygons is not important, or can
be managed separately, clipping routines can be sped up by about
60% by setting IgnoreOrientation to true. Defaults to false.
* Change: The OffsetPolygon and Area functions have been moved to
the new unit - clipper_misc.
2.99 - 15 January 2011
* Bugfix: Obscure bug in AddPolygon method could cause an endless loop.
2.8 - 20 November 2010
* Updated: Output polygons which previously shared a common
edge are now merged.
* Changed: The orientation of outer polygons is now clockwise
when the display's Y axis is positive downwards (as is
typical for most Windows applications). Inner polygons
(holes) have the opposite orientation.
* Added: Support module for Cairo Graphics Library (with demo).
* Updated: C# and C++ demos.
2.522 - 15 October 2010
* Added C# translation (thanks to Olivier Lejeune) and
a link to Ruby bindings (thanks to Mike Owens).
2.0 - 30 July 2010
* Clipper now clips using both the Even-Odd (alternate) and
Non-Zero (winding) polygon filling rules. (Previously Clipper
assumed the Even-Odd rule for polygon filling.)
1.4c - 16 June 2010
* Added C++ support for AGG graphics library
1.2s - 2 June 2010
* Added C++ translation of clipper.pas
1.0 - 9 May 2010

5598
clipper/clipper.cpp
View File

File diff suppressed because it is too large Load Diff

450
clipper/clipper.hpp
View File

@ -1,450 +0,0 @@
/*******************************************************************************
* *
* Author : Angus Johnson *
* Version : 6.4.0 *
* Date : 2 July 2015 *
* Website : http://www.angusj.com *
* Copyright : Angus Johnson 2010-2015 *
* *
* License: *
* Use, modification & distribution is subject to Boost Software License Ver 1. *
* http://www.boost.org/LICENSE_1_0.txt *
* *
* Attributions: *
* The code in this library is an extension of Bala Vatti's clipping algorithm: *
* "A generic solution to polygon clipping" *
* Communications of the ACM, Vol 35, Issue 7 (July 1992) pp 56-63. *
* http://portal.acm.org/citation.cfm?id=129906 *
* *
* Computer graphics and geometric modeling: implementation and algorithms *
* By Max K. Agoston *
* Springer; 1 edition (January 4, 2005) *
* http://books.google.com/books?q=vatti+clipping+agoston *
* *
* See also: *
* "Polygon Offsetting by Computing Winding Numbers" *
* Paper no. DETC2005-85513 pp. 565-575 *
* ASME 2005 International Design Engineering Technical Conferences *
* and Computers and Information in Engineering Conference (IDETC/CIE2005) *
* September 24-28, 2005 , Long Beach, California, USA *
* http://www.me.berkeley.edu/~mcmains/pubs/DAC05OffsetPolygon.pdf *
* *
*******************************************************************************/
#ifndef clipper_hpp
#define clipper_hpp
#define CLIPPER_VERSION "6.2.6"
//use_int32: When enabled 32bit ints are used instead of 64bit ints. This
//improve performance but coordinate values are limited to the range +/- 46340
//#define use_int32
//use_xyz: adds a Z member to IntPoint. Adds a minor cost to perfomance.
//#define use_xyz
//use_lines: Enables line clipping. Adds a very minor cost to performance.
//#define use_lines
//use_deprecated: Enables temporary support for the obsolete functions
//#define use_deprecated
#include <vector>
#include <list>
#include <set>
#include <stdexcept>
#include <cstring>
#include <cstdlib>
#include <ostream>
#include <functional>
#include <queue>
#include <unordered_map>
#if defined(CLIPPER_IMPL_INCLUDE)
#include CLIPPER_IMPL_INCLUDE
#endif
namespace ClipperLib {
enum ClipType { ctIntersection, ctUnion, ctDifference, ctXor };
enum PolyType { ptSubject, ptClip };
//By far the most widely used winding rules for polygon filling are
//EvenOdd & NonZero (GDI, GDI+, XLib, OpenGL, Cairo, AGG, Quartz, SVG, Gr32)
//Others rules include Positive, Negative and ABS_GTR_EQ_TWO (only in OpenGL)
//see http://glprogramming.com/red/chapter11.html
enum PolyFillType { pftEvenOdd, pftNonZero, pftPositive, pftNegative };
#ifdef use_int32
typedef int cInt;
static cInt const loRange = 0x7FFF;
static cInt const hiRange = 0x7FFF;
#else
typedef std::int64_t cInt;
static cInt const loRange = 0x3FFFFFFF;
static cInt const hiRange = 0x3FFFFFFFFFFFFFFFLL;
typedef signed long long long64; //used by Int128 class
typedef unsigned long long ulong64;
#endif
#if defined(CLIPPER_INTPOINT_IMPL)
typedef CLIPPER_INTPOINT_IMPL IntPoint;
#else
struct IntPoint {
cInt X;
cInt Y;
#ifdef use_xyz
cInt Z;
IntPoint(cInt x = 0, cInt y = 0, cInt z = 0): X(x), Y(y), Z(z) {};
#else
IntPoint(cInt x = 0, cInt y = 0): X(x), Y(y) {};
#endif
friend inline bool operator== (const IntPoint& a, const IntPoint& b)
{
return a.X == b.X && a.Y == b.Y;
}
friend inline bool operator!= (const IntPoint& a, const IntPoint& b)
{
return a.X != b.X || a.Y != b.Y;
}
};
#endif
//------------------------------------------------------------------------------
#if defined(CLIPPER_PATH_IMPL)
typedef CLIPPER_PATH_IMPL Path;
#else
typedef std::vector< IntPoint > Path;
#endif
#if defined(CLIPPER_PATHS_IMPL)
typedef CLIPPER_PATHS_IMPL Paths;
#else
typedef std::vector< Path > Paths;
#endif
inline Path& operator <<(Path& poly, const IntPoint& p) {poly.push_back(p); return poly;}
inline Paths& operator <<(Paths& polys, const Path& p) {polys.push_back(p); return polys;}
std::ostream& operator <<(std::ostream &s, const IntPoint &p);
std::ostream& operator <<(std::ostream &s, const Path &p);
std::ostream& operator <<(std::ostream &s, const Paths &p);
struct DoublePoint
{
double X;
double Y;
DoublePoint(double x = 0, double y = 0) : X(x), Y(y) {}
DoublePoint(IntPoint ip) : X((double)ip.X), Y((double)ip.Y) {}
};
//------------------------------------------------------------------------------
#ifdef use_xyz
typedef void (*ZFillCallback)(IntPoint& e1bot, IntPoint& e1top, IntPoint& e2bot, IntPoint& e2top, IntPoint& pt);
#endif
enum InitOptions {ioReverseSolution = 1, ioStrictlySimple = 2, ioPreserveCollinear = 4};
enum JoinType {jtSquare, jtRound, jtMiter};
enum EndType {etClosedPolygon, etClosedLine, etOpenButt, etOpenSquare, etOpenRound};
class PolyNode;
typedef std::vector< PolyNode* > PolyNodes;
class PolyNode
{
public:
PolyNode();
virtual ~PolyNode(){};
Path Contour;
PolyNodes Childs;
PolyNode* Parent;
PolyNode* GetNext() const;
bool IsHole() const;
bool IsOpen() const;
int ChildCount() const;
private:
unsigned Index; //node index in Parent.Childs
bool m_IsOpen;
JoinType m_jointype;
EndType m_endtype;
PolyNode* GetNextSiblingUp() const;
void AddChild(PolyNode& child);
friend class Clipper; //to access Index
friend class ClipperOffset;
};
class PolyTree: public PolyNode
{
public:
~PolyTree(){Clear();};
PolyNode* GetFirst() const;
void Clear();
int Total() const;
private:
PolyNodes AllNodes;
friend class Clipper; //to access AllNodes
};
bool Orientation(const Path &poly);
double Area(const Path &poly);
int PointInPolygon(const IntPoint &pt, const Path &path);
void SimplifyPolygon(const Path &in_poly, Paths &out_polys, PolyFillType fillType = pftEvenOdd);
void SimplifyPolygons(const Paths &in_polys, Paths &out_polys, PolyFillType fillType = pftEvenOdd);
void SimplifyPolygons(Paths &polys, PolyFillType fillType = pftEvenOdd);
void CleanPolygon(const Path& in_poly, Path& out_poly, double distance = 1.415);
void CleanPolygon(Path& poly, double distance = 1.415);
void CleanPolygons(const Paths& in_polys, Paths& out_polys, double distance = 1.415);
void CleanPolygons(Paths& polys, double distance = 1.415);
void MinkowskiSum(const Path& pattern, const Path& path, Paths& solution, bool pathIsClosed);
void MinkowskiSum(const Path& pattern, const Paths& paths, Paths& solution, bool pathIsClosed);
void MinkowskiDiff(const Path& poly1, const Path& poly2, Paths& solution);
void PolyTreeToPaths(const PolyTree& polytree, Paths& paths);
void ClosedPathsFromPolyTree(const PolyTree& polytree, Paths& paths);
void OpenPathsFromPolyTree(PolyTree& polytree, Paths& paths);
void ReversePath(Path& p);
void ReversePaths(Paths& p);
struct IntRect { cInt left; cInt top; cInt right; cInt bottom; };
//enums that are used internally ...
enum EdgeSide { esLeft = 1, esRight = 2};
//forward declarations (for stuff used internally) ...
struct TEdge;
struct IntersectNode;
struct LocalMinimum;
struct OutPt;
struct OutRec;
struct Join;
struct OutPtIntersect;
typedef std::vector < OutRec* > PolyOutList;
typedef std::vector < TEdge* > EdgeList;
typedef std::vector < Join* > JoinList;
typedef std::vector < IntersectNode* > IntersectList;
//------------------------------------------------------------------------------
//ClipperBase is the ancestor to the Clipper class. It should not be
//instantiated directly. This class simply abstracts the conversion of sets of
//polygon coordinates into edge objects that are stored in a LocalMinima list.
class ClipperBase
{
public:
ClipperBase();
virtual ~ClipperBase();
virtual bool AddPath(const Path &pg, PolyType PolyTyp, bool Closed);
bool AddPaths(const Paths &ppg, PolyType PolyTyp, bool Closed);
virtual void Clear();
IntRect GetBounds();
bool PreserveCollinear() {return m_PreserveCollinear;};
void PreserveCollinear(bool value) {m_PreserveCollinear = value;};
protected:
void DisposeLocalMinimaList();
TEdge* AddBoundsToLML(TEdge *e, bool IsClosed);
virtual void Reset();
TEdge* ProcessBound(TEdge* E, bool IsClockwise);
void InsertScanbeam(const cInt Y);
bool PopScanbeam(cInt &Y);
bool LocalMinimaPending();
bool PopLocalMinima(cInt Y, const LocalMinimum *&locMin);
OutRec* CreateOutRec();
void DisposeAllOutRecs();
void DisposeOutRec(PolyOutList::size_type index);
void SwapPositionsInAEL(TEdge *edge1, TEdge *edge2);
void DeleteFromAEL(TEdge *e);
void UpdateEdgeIntoAEL(TEdge *&e);
typedef std::vector<LocalMinimum> MinimaList;
MinimaList::iterator m_CurrentLM;
MinimaList m_MinimaList;
bool m_UseFullRange;
EdgeList m_edges;
bool m_PreserveCollinear;
bool m_HasOpenPaths;
PolyOutList m_PolyOuts;
TEdge *m_ActiveEdges;
typedef std::priority_queue<cInt> ScanbeamList;
ScanbeamList m_Scanbeam;
};
//------------------------------------------------------------------------------
class Clipper : public virtual ClipperBase
{
public:
Clipper(int initOptions = 0);
bool Execute(ClipType clipType,
Paths &solution,
PolyFillType fillType = pftEvenOdd);
bool Execute(ClipType clipType,
Paths &solution,
PolyFillType subjFillType,
PolyFillType clipFillType);
bool Execute(ClipType clipType,
PolyTree &polytree,
PolyFillType fillType = pftEvenOdd);
bool Execute(ClipType clipType,
PolyTree &polytree,
PolyFillType subjFillType,
PolyFillType clipFillType);
bool ReverseSolution() { return m_ReverseOutput; };
void ReverseSolution(bool value) {m_ReverseOutput = value;};
bool StrictlySimple() {return m_StrictSimple;};
void StrictlySimple(bool value) {m_StrictSimple = value;};
//set the callback function for z value filling on intersections (otherwise Z is 0)
#ifdef use_xyz
void ZFillFunction(ZFillCallback zFillFunc);
#endif
protected:
virtual bool ExecuteInternal();
private:
JoinList m_Joins;
JoinList m_GhostJoins;
IntersectList m_IntersectList;
ClipType m_ClipType;
typedef std::list<cInt> MaximaList;
MaximaList m_Maxima;
TEdge *m_SortedEdges;
bool m_ExecuteLocked;
PolyFillType m_ClipFillType;
PolyFillType m_SubjFillType;
bool m_ReverseOutput;
bool m_UsingPolyTree;
bool m_StrictSimple;
#ifdef use_xyz
ZFillCallback m_ZFill; //custom callback
#endif
void SetWindingCount(TEdge& edge);
bool IsEvenOddFillType(const TEdge& edge) const;
bool IsEvenOddAltFillType(const TEdge& edge) const;
void InsertLocalMinimaIntoAEL(const cInt botY);
void InsertEdgeIntoAEL(TEdge *edge, TEdge* startEdge);
void AddEdgeToSEL(TEdge *edge);
bool PopEdgeFromSEL(TEdge *&edge);
void CopyAELToSEL();
void DeleteFromSEL(TEdge *e);
void SwapPositionsInSEL(TEdge *edge1, TEdge *edge2);
bool IsContributing(const TEdge& edge) const;
bool IsTopHorz(const cInt XPos);
void DoMaxima(TEdge *e);
void ProcessHorizontals();
void ProcessHorizontal(TEdge *horzEdge);
void AddLocalMaxPoly(TEdge *e1, TEdge *e2, const IntPoint &pt);
OutPt* AddLocalMinPoly(TEdge *e1, TEdge *e2, const IntPoint &pt);
OutRec* GetOutRec(int idx);
void AppendPolygon(TEdge *e1, TEdge *e2);
void IntersectEdges(TEdge *e1, TEdge *e2, IntPoint &pt);
OutPt* AddOutPt(TEdge *e, const IntPoint &pt);
OutPt* GetLastOutPt(TEdge *e);
bool ProcessIntersections(const cInt topY);
void BuildIntersectList(const cInt topY);
void ProcessIntersectList();
void ProcessEdgesAtTopOfScanbeam(const cInt topY);
void BuildResult(Paths& polys);
void BuildResult2(PolyTree& polytree);
void SetHoleState(TEdge *e, OutRec *outrec);
void DisposeIntersectNodes();
bool FixupIntersectionOrder();
void FixupOutPolygon(OutRec &outrec);
void FixupOutPolyline(OutRec &outrec);
bool IsHole(TEdge *e);
bool FindOwnerFromSplitRecs(OutRec &outRec, OutRec *&currOrfl);
void FixHoleLinkage(OutRec &outrec);
void AddJoin(OutPt *op1, OutPt *op2, const IntPoint offPt);
void ClearJoins();
void ClearGhostJoins();
void AddGhostJoin(OutPt *op, const IntPoint offPt);
bool JoinPoints(Join *j, OutRec* outRec1, OutRec* outRec2);
void JoinCommonEdges();
void DoSimplePolygons();
bool FindIntersectLoop(std::unordered_multimap<int, OutPtIntersect> & dupeRec,
std::list<std::pair<int, OutPtIntersect> > & iList,
OutRec * outRec_parent,
int idx_origin,
int idx_prev,
std::set<int> & visited,
OutPt * orig_pt,
OutPt * prev_pt);
bool FixIntersects(std::unordered_multimap<int, OutPtIntersect> & dupeRec,
OutPt * op_j,
OutPt * op_k,
OutRec * outRec_j,
OutRec * outRec_k);
void FixupFirstLefts1(OutRec* OldOutRec, OutRec* NewOutRec);
void FixupFirstLefts2(OutRec* InnerOutRec, OutRec* OuterOutRec);
void FixupFirstLefts3(OutRec* OldOutRec, OutRec* NewOutRec);
#ifdef use_xyz
void SetZ(IntPoint& pt, TEdge& e1, TEdge& e2);
#endif
};
//------------------------------------------------------------------------------
class ClipperOffset
{
public:
ClipperOffset(double miterLimit = 2.0, double roundPrecision = 0.25);
~ClipperOffset();
void AddPath(const Path& path, JoinType joinType, EndType endType);
void AddPaths(const Paths& paths, JoinType joinType, EndType endType);
void Execute(Paths& solution, double delta);
void Execute(PolyTree& solution, double delta);
void Clear();
double MiterLimit;
double ArcTolerance;
private:
Paths m_destPolys;
Path m_srcPoly;
Path m_destPoly;
std::vector<DoublePoint> m_normals;
double m_delta, m_sinA, m_sin, m_cos;
double m_miterLim, m_StepsPerRad;
IntPoint m_lowest;
PolyNode m_polyNodes;
void FixOrientations();
void DoOffset(double delta);
void OffsetPoint(int j, int& k, JoinType jointype);
void DoSquare(int j, int k);
void DoMiter(int j, int k, double r);
void DoRound(int j, int k);
};
//------------------------------------------------------------------------------
class clipperException : public std::exception
{
public:
clipperException(const char* description): m_descr(description) {}
virtual ~clipperException() throw() {}
virtual const char* what() const throw() {return m_descr.c_str();}
private:
std::string m_descr;
};
//------------------------------------------------------------------------------
} //ClipperLib namespace
#endif //clipper_hpp

329
geometry.cpp
View File

@ -9,8 +9,9 @@
#include <cmath>
#include <limits.h>
#include <sqlite3.h>
#include <mapbox/geometry.hpp>
#include <mapbox/geometry/wagyu/wagyu.hpp>
#include "geometry.hpp"
#include "clipper/clipper.hpp"
#include "projection.hpp"
#include "serial.hpp"
#include "main.hpp"
@ -163,202 +164,40 @@ double get_area(drawvec &geom, size_t i, size_t j) {
return area;
}
void reverse_ring(drawvec &geom, size_t start, size_t end) {
drawvec tmp;
static void decode_clipped(mapbox::geometry::multi_polygon<long long> &t, drawvec &out) {
out.clear();
for (size_t i = start; i < end; i++) {
tmp.push_back(geom[i]);
}
for (size_t i = 0; i < t.size(); i++) {
for (size_t j = 0; j < t[i].size(); j++) {
drawvec ring;
for (unsigned i = start; i < end; i++) {
geom[i] = tmp[end - 1 - i];
if (i == start) {
geom[i].op = VT_MOVETO;
} else if (i == end - 1) {
geom[i].op = VT_LINETO;
}
}
}
struct ring {
drawvec data;
long double area;
long long parent;
std::vector<size_t> children;
ring(drawvec &_data) {
data = _data;
area = get_area(_data, 0, _data.size());
parent = -1;
}
bool operator<(const ring &o) const {
if (std::fabs(this->area) < std::fabs(o.area)) {
return true;
} else {
return false;
}
}
};
static void decode_rings(ClipperLib::PolyNode *t, std::vector<ring> &out) {
// Supposedly outer ring
ClipperLib::Path p = t->Contour;
drawvec dv;
for (size_t i = 0; i < p.size(); i++) {
dv.push_back(draw((i == 0) ? VT_MOVETO : VT_LINETO, p[i].X, p[i].Y));
}
if (p.size() > 0) {
dv.push_back(draw(VT_LINETO, p[0].X, p[0].Y));
}
out.push_back(dv);
// Supposedly inner rings
for (int n = 0; n < t->ChildCount(); n++) {
ClipperLib::Path cp = t->Childs[n]->Contour;
drawvec ring;
for (size_t i = 0; i < cp.size(); i++) {
ring.push_back(draw((i == 0) ? VT_MOVETO : VT_LINETO, cp[i].X, cp[i].Y));
}
if (cp.size() > 0) {
ring.push_back(draw(VT_LINETO, cp[0].X, cp[0].Y));
}
out.push_back(ring);
}
// Recurse to supposedly outer rings (children of the children)
for (int n = 0; n < t->ChildCount(); n++) {
for (int m = 0; m < t->Childs[n]->ChildCount(); m++) {
decode_rings(t->Childs[n]->Childs[m], out);
}
}
}
static void decode_clipped(ClipperLib::PolyNode *t, drawvec &out) {
// The output of Clipper supposedly produces the outer rings
// as top level objects, with links to any inner-ring children
// they may have, each of which then has links to any outer rings
// that it has, and so on. This doesn't actually work.
// So instead, we pull out all the rings, sort them by absolute area,
// and go through them, looking for the
// smallest parent that contains a point from it, since we are
// guaranteed that at least one point in the polygon is strictly
// inside its parent (not on one of its boundary lines).
std::vector<ring> rings;
decode_rings(t, rings);
std::sort(rings.begin(), rings.end());
for (size_t i = 0; i < rings.size(); i++) {
for (size_t j = i + 1; j < rings.size(); j++) {
for (size_t k = 0; k < rings[i].data.size(); k++) {
if (pnpoly(rings[j].data, 0, rings[j].data.size(), rings[i].data[k].x, rings[i].data[k].y)) {
rings[i].parent = j;
rings[j].children.push_back(i);
goto nextring;
}
for (size_t k = 0; k < t[i][j].size(); k++) {
ring.push_back(draw((k == 0) ? VT_MOVETO : VT_LINETO, t[i][j][k].x, t[i][j][k].y));
}
}
nextring:;
}
// Then reverse the winding order of any rings that turned out
// to actually be inner when they are outer, or vice versa.
// (A ring is outer if it has no parent or if its parent is
// an inner ring.)
for (size_t ii = rings.size(); ii > 0; ii--) {
size_t i = ii - 1;
if (rings[i].parent < 0) {
if (rings[i].area < 0) {
rings[i].area = -rings[i].area;
reverse_ring(rings[i].data, 0, rings[i].data.size());
if (ring.size() > 0 && ring[ring.size() - 1] != ring[0]) {
fprintf(stderr, "Had to close ring\n");
ring.push_back(draw(VT_LINETO, ring[0].x, ring[0].y));
}
} else {
if ((rings[i].area > 0) == (rings[rings[i].parent].area > 0)) {
rings[i].area = -rings[i].area;
reverse_ring(rings[i].data, 0, rings[i].data.size());
double area = get_area(ring, 0, ring.size());
if ((j == 0 && area < 0) || (j != 0 && area > 0)) {
fprintf(stderr, "Ring area has wrong sign: %f for %zu\n", area, j);
exit(EXIT_FAILURE);
}
for (size_t k = 0; k < ring.size(); k++) {
out.push_back(ring[k]);
}
}
}
// Then run through the rings again, outputting each outer ring
// followed by its direct children, and checking to make sure
// there are no child rings whose parents weren't identified.
for (size_t ii = rings.size(); ii > 0; ii--) {
size_t i = ii - 1;
if (rings[i].area > 0) {
#if 0
fprintf(stderr, "ring area %Lf at %lld\n", rings[i].area, (long long) out.size());
#endif
for (size_t j = 0; j < rings[i].data.size(); j++) {
out.push_back(rings[i].data[j]);
}
for (size_t j = 0; j < rings[i].children.size(); j++) {
#if 0
fprintf(stderr, "ring area %Lf at %lld\n", rings[rings[i].children[j]].area, (long long) out.size());
#endif
for (size_t k = 0; k < rings[rings[i].children[j]].data.size(); k++) {
out.push_back(rings[rings[i].children[j]].data[k]);
}
rings[rings[i].children[j]].parent = -2;
}
} else if (rings[i].parent != -2) {
fprintf(stderr, "Found ring with child area but no parent %lld\n", (long long) i);
}
}
}
static void dump(drawvec &geom) {
ClipperLib::Clipper clipper(ClipperLib::ioStrictlySimple);
for (size_t i = 0; i < geom.size(); i++) {
if (geom[i].op == VT_MOVETO) {
size_t j;
for (j = i + 1; j < geom.size(); j++) {
if (geom[j].op != VT_LINETO) {
break;
}
}
ClipperLib::Path path;
printf("{ ClipperLib::Path path; ");
drawvec tmp;
for (size_t k = i; k < j; k++) {
printf("path.push_back(IntPoint(%lld,%lld)); ", geom[k].x, geom[k].y);
path.push_back(ClipperLib::IntPoint(geom[k].x, geom[k].y));
}
if (!clipper.AddPath(path, ClipperLib::ptSubject, true)) {
}
printf("clipper.AddPath(path, ClipperLib::ptSubject, true); }\n");
i = j - 1;
} else {
fprintf(stderr, "Unexpected operation in polygon %d\n", (int) geom[i].op);
exit(EXIT_FAILURE);
}
}
printf("clipper.Execute(ClipperLib::ctUnion, clipped));\n");
}
drawvec clean_or_clip_poly(drawvec &geom, int z, int detail, int buffer, bool clip) {
ClipperLib::Clipper clipper(ClipperLib::ioStrictlySimple);
bool has_area = false;
mapbox::geometry::wagyu::wagyu<long long> wagyu;
geom = remove_noop(geom, VT_POLYGON, 0);
for (size_t i = 0; i < geom.size(); i++) {
if (geom[i].op == VT_MOVETO) {
size_t j;
@ -368,77 +207,95 @@ drawvec clean_or_clip_poly(drawvec &geom, int z, int detail, int buffer, bool cl
}
}
double area = get_area(geom, i, j);
if (area != 0) {
has_area = true;
}
if (j >= i + 4) {
mapbox::geometry::linear_ring<long long> lr;
ClipperLib::Path path;
drawvec tmp;
for (size_t k = i; k < j; k++) {
path.push_back(ClipperLib::IntPoint(geom[k].x, geom[k].y));
}
if (!clipper.AddPath(path, ClipperLib::ptSubject, true)) {
#if 0
fprintf(stderr, "Couldn't add polygon for clipping:");
for (size_t k = i; k < j; k++) {
fprintf(stderr, " %lld,%lld", geom[k].x, geom[k].y);
lr.push_back(mapbox::geometry::point<long long>(geom[k].x, geom[k].y));
}
if (lr.size() >= 3) {
wagyu.add_ring(lr);
}
fprintf(stderr, "\n");
#endif
}
i = j - 1;
} else {
fprintf(stderr, "Unexpected operation in polygon %d\n", (int) geom[i].op);
exit(EXIT_FAILURE);
}
}
if (clip) {
long long area = 1LL << (32 - z);
long long area = 0xFFFFFFFF;
if (z != 0) {
area = 1LL << (32 - z);
}
long long clip_buffer = buffer * area / 256;
ClipperLib::Path edge;
edge.push_back(ClipperLib::IntPoint(-clip_buffer, -clip_buffer));
edge.push_back(ClipperLib::IntPoint(area + clip_buffer, -clip_buffer));
edge.push_back(ClipperLib::IntPoint(area + clip_buffer, area + clip_buffer));
edge.push_back(ClipperLib::IntPoint(-clip_buffer, area + clip_buffer));
edge.push_back(ClipperLib::IntPoint(-clip_buffer, -clip_buffer));
mapbox::geometry::linear_ring<long long> lr;
clipper.AddPath(edge, ClipperLib::ptClip, true);
lr.push_back(mapbox::geometry::point<long long>(-clip_buffer, -clip_buffer));
lr.push_back(mapbox::geometry::point<long long>(-clip_buffer, area + clip_buffer));
lr.push_back(mapbox::geometry::point<long long>(area + clip_buffer, area + clip_buffer));
lr.push_back(mapbox::geometry::point<long long>(area + clip_buffer, -clip_buffer));
lr.push_back(mapbox::geometry::point<long long>(-clip_buffer, -clip_buffer));
wagyu.add_ring(lr, mapbox::geometry::wagyu::polygon_type_clip);
}
ClipperLib::PolyTree clipped;
if (clip) {
if (!clipper.Execute(ClipperLib::ctIntersection, clipped)) {
fprintf(stderr, "Polygon clip failed\n");
}
} else {
if (!has_area) {
drawvec out;
return out;
}
mapbox::geometry::multi_polygon<long long> result;
try {
wagyu.execute(mapbox::geometry::wagyu::clip_type_union, result, mapbox::geometry::wagyu::fill_type_positive, mapbox::geometry::wagyu::fill_type_positive);
} catch (std::runtime_error e) {
FILE *f = fopen("/tmp/wagyu.log", "w");
fprintf(f, "%s\n", e.what());
fprintf(stderr, "%s\n", e.what());
fprintf(f, "[");
if (!clipper.Execute(ClipperLib::ctUnion, clipped)) {
static bool complained = false;
for (size_t i = 0; i < geom.size(); i++) {
if (geom[i].op == VT_MOVETO) {
size_t j;
for (j = i + 1; j < geom.size(); j++) {
if (geom[j].op != VT_LINETO) {
break;
}
}
if (!complained) {
fprintf(stderr, "Polygon clean failed\n");
complained = true;
if (j >= i + 4) {
mapbox::geometry::linear_ring<long long> lr;
if (i != 0) {
fprintf(f, ",");
}
fprintf(f, "[");
for (size_t k = i; k < j; k++) {
lr.push_back(mapbox::geometry::point<long long>(geom[k].x, geom[k].y));
if (k != i) {
fprintf(f, ",");
}
fprintf(f, "[%lld,%lld]", geom[k].x, geom[k].y);
}
fprintf(f, "]");
if (lr.size() >= 3) {
}
}
i = j - 1;
}
}
fprintf(f, "]");
fprintf(f, "\n\n\n\n\n");
fclose(f);
fprintf(stderr, "Internal error: Polygon cleaning failed. Log in /tmp/wagyu.log\n");
exit(EXIT_FAILURE);
}
drawvec out;
for (int i = 0; i < clipped.ChildCount(); i++) {
decode_clipped(clipped.Childs[i], out);
}
return out;
drawvec ret;
decode_clipped(result, ret);
return ret;
}
/* pnpoly:
@ -482,7 +339,6 @@ void check_polygon(drawvec &geom, drawvec &before) {
geom[i + 1].x, geom[i + 1].y,
geom[j + 0].x, geom[j + 0].y,
geom[j + 1].x, geom[j + 1].y);
dump(before);
}
}
}
@ -524,7 +380,6 @@ void check_polygon(drawvec &geom, drawvec &before) {
if (!on_edge) {
printf("%lld,%lld at %lld not in outer ring (%lld to %lld)\n", geom[k].x, geom[k].y, (long long) k, (long long) outer_start, (long long) (outer_start + outer_len));
dump(before);
#if 0
for (size_t l = outer_start; l < outer_start + outer_len; l++) {
fprintf(stderr, " %lld,%lld", geom[l].x, geom[l].y);

13
mapbox/LICENSE-geometry.hpp Normal file
View File

@ -0,0 +1,13 @@
Copyright (c) 2016, Mapbox
Permission to use, copy, modify, and/or distribute this software for any
purpose with or without fee is hereby granted, provided that the above
copyright notice and this permission notice appear in all copies.
THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

25
mapbox/LICENSE-variant Normal file
View File

@ -0,0 +1,25 @@
Copyright (c) MapBox
All rights reserved.
Redistribution and use in source and binary forms, with or without modification,
are permitted provided that the following conditions are met:
- Redistributions of source code must retain the above copyright notice, this
list of conditions and the following disclaimer.
- Redistributions in binary form must reproduce the above copyright notice, this
list of conditions and the following disclaimer in the documentation and/or
other materials provided with the distribution.
- Neither the name "MapBox" nor the names of its contributors may be
used to endorse or promote products derived from this software without
specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

19
clipper/License.txt → mapbox/LICENSE-wagyu
View File

@ -1,5 +1,18 @@
Boost Software License - Version 1.0 - August 17th, 2003
http://www.boost.org/LICENSE_1_0.txt
Parts of the code in the Wagyu Library are derived from the version of the
Clipper Library by Angus Johnson listed below.
Author : Angus Johnson
Version : 6.4.0
Date : 2 July 2015
Website : http://www.angusj.com
Copyright for portions of the derived code in the Wagyu library are held
by Angus Johnson, 2010-2015. All other copyright for the Wagyu Library are held by
Mapbox, 2016. This code is published in accordance with, and retains the same license
as the Clipper Library by Angus Johnson.
Copyright (c) 2010-2015, Angus Johnson
Copyright (c) 2016, Mapbox
Permission is hereby granted, free of charge, to any person or organization
obtaining a copy of the software and accompanying documentation covered by
@ -21,4 +34,4 @@ FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN THE SOFTWARE.
DEALINGS IN THE SOFTWARE.

13
mapbox/geometry.hpp Normal file
View File

@ -0,0 +1,13 @@
#pragma once
#include <mapbox/geometry/point.hpp>
#include <mapbox/geometry/line_string.hpp>
#include <mapbox/geometry/polygon.hpp>
#include <mapbox/geometry/multi_point.hpp>
#include <mapbox/geometry/multi_line_string.hpp>
#include <mapbox/geometry/multi_polygon.hpp>
#include <mapbox/geometry/geometry.hpp>
#include <mapbox/geometry/feature.hpp>
#include <mapbox/geometry/point_arithmetic.hpp>
#include <mapbox/geometry/for_each_point.hpp>
#include <mapbox/geometry/envelope.hpp>

34
mapbox/geometry/box.hpp Normal file
View File

@ -0,0 +1,34 @@
#pragma once
#include <mapbox/geometry/point.hpp>
namespace mapbox {
namespace geometry {
template <typename T>
struct box
{
using point_type = point<T>;
constexpr box(point_type const& min_, point_type const& max_)
: min(min_), max(max_)
{}
point_type min;
point_type max;
};
template <typename T>
constexpr bool operator==(box<T> const& lhs, box<T> const& rhs)
{
return lhs.min == rhs.min && lhs.max == rhs.max;
}
template <typename T>
constexpr bool operator!=(box<T> const& lhs, box<T> const& rhs)
{
return lhs.min != rhs.min || lhs.max != rhs.max;
}
} // namespace geometry
} // namespace mapbox

33
mapbox/geometry/envelope.hpp Normal file
View File

@ -0,0 +1,33 @@
#pragma once
#include <mapbox/geometry/box.hpp>
#include <mapbox/geometry/for_each_point.hpp>
#include <limits>
namespace mapbox {
namespace geometry {
template <typename G, typename T = typename G::coordinate_type>
box<T> envelope(G const& geometry)
{
using limits = std::numeric_limits<T>;
T min_t = limits::has_infinity ? -limits::infinity() : limits::min();
T max_t = limits::has_infinity ? limits::infinity() : limits::max();
point<T> min(max_t, max_t);
point<T> max(min_t, min_t);
for_each_point(geometry, [&] (point<T> const& point) {
if (min.x > point.x) min.x = point.x;
if (min.y > point.y) min.y = point.y;
if (max.x < point.x) max.x = point.x;
if (max.y < point.y) max.y = point.y;
});
return box<T>(min, max);
}
} // namespace geometry
} // namespace mapbox

81
mapbox/geometry/feature.hpp Normal file
View File

@ -0,0 +1,81 @@
#pragma once
#include <mapbox/geometry/geometry.hpp>
#include <mapbox/variant.hpp>
#include <cstdint>
#include <string>
#include <vector>
#include <unordered_map>
#include <experimental/optional>
namespace mapbox {
namespace geometry {
struct value;
struct null_value_t
{
constexpr null_value_t() {}
constexpr null_value_t(std::nullptr_t) {}
};
constexpr bool operator==(const null_value_t&, const null_value_t&) { return true; }
constexpr bool operator!=(const null_value_t&, const null_value_t&) { return false; }
constexpr null_value_t null_value = null_value_t();
// Multiple numeric types (uint64_t, int64_t, double) are present in order to support
// the widest possible range of JSON numbers, which do not have a maximum range.
// Implementations that produce `value`s should use that order for type preference,
// using uint64_t for positive integers, int64_t for negative integers, and double
// for non-integers and integers outside the range of 64 bits.
using value_base = mapbox::util::variant<null_value_t, bool, uint64_t, int64_t, double, std::string,
mapbox::util::recursive_wrapper<std::vector<value>>,
mapbox::util::recursive_wrapper<std::unordered_map<std::string, value>>>;
struct value : value_base
{
using value_base::value_base;
};
using property_map = std::unordered_map<std::string, value>;
// The same considerations and requirement for numeric types apply as for `value_base`.
using identifier = mapbox::util::variant<uint64_t, int64_t, double, std::string>;
template <class T>
struct feature
{
using coordinate_type = T;
using geometry_type = mapbox::geometry::geometry<T>; // Fully qualified to avoid GCC -fpermissive error.
geometry_type geometry;
property_map properties {};
std::experimental::optional<identifier> id {};
};
template <class T>
constexpr bool operator==(feature<T> const& lhs, feature<T> const& rhs)
{
return lhs.id == rhs.id && lhs.geometry == rhs.geometry && lhs.properties == rhs.properties;
}
template <class T>
constexpr bool operator!=(feature<T> const& lhs, feature<T> const& rhs)
{
return !(lhs == rhs);
}
template <class T, template <typename...> class Cont = std::vector>
struct feature_collection : Cont<feature<T>>
{
using coordinate_type = T;
using feature_type = feature<T>;
using container_type = Cont<feature_type>;
using container_type::container_type;
};
} // namespace geometry
} // namespace mapbox

45
mapbox/geometry/for_each_point.hpp Normal file
View File

@ -0,0 +1,45 @@
#pragma once
#include <mapbox/geometry/geometry.hpp>
namespace mapbox {
namespace geometry {
template <typename Point, typename F>
auto for_each_point(Point&& point, F&& f)
-> decltype(point.x, point.y, void())
{
f(std::forward<Point>(point));
}
template <typename Container, typename F>
auto for_each_point(Container&& container, F&& f)
-> decltype(container.begin(), container.end(), void());
template <typename...Types, typename F>
void for_each_point(mapbox::util::variant<Types...> const& geom, F&& f)
{
mapbox::util::variant<Types...>::visit(geom, [&] (auto const& g) {
for_each_point(g, f);
});
}
template <typename...Types, typename F>
void for_each_point(mapbox::util::variant<Types...> & geom, F&& f)
{
mapbox::util::variant<Types...>::visit(geom, [&] (auto & g) {
for_each_point(g, f);
});
}
template <typename Container, typename F>
auto for_each_point(Container&& container, F&& f)
-> decltype(container.begin(), container.end(), void())
{
for (auto& e: container) {
for_each_point(e, f);
}
}
} // namespace geometry
} // namespace mapbox

53
mapbox/geometry/geometry.hpp Normal file
View File

@ -0,0 +1,53 @@
#pragma once
#include <mapbox/geometry/point.hpp>
#include <mapbox/geometry/line_string.hpp>
#include <mapbox/geometry/polygon.hpp>
#include <mapbox/geometry/multi_point.hpp>
#include <mapbox/geometry/multi_line_string.hpp>
#include <mapbox/geometry/multi_polygon.hpp>
#include <mapbox/variant.hpp>
// stl
#include <vector>
namespace mapbox {
namespace geometry {
template <typename T, template <typename...> class Cont = std::vector>
struct geometry_collection;
template <typename T>
using geometry_base = mapbox::util::variant<point<T>,
line_string<T>,
polygon<T>,
multi_point<T>,
multi_line_string<T>,
multi_polygon<T>,
geometry_collection<T>>;
template <typename T>
struct geometry : geometry_base<T>
{
using coordinate_type = T;
using geometry_base<T>::geometry_base;
/*
* The default constructor would create a point geometry with default-constructed coordinates;
* i.e. (0, 0). Since this is not particularly useful, and could hide bugs, it is disabled.
*/
geometry() = delete;
};
template <typename T, template <typename...> class Cont>
struct geometry_collection : Cont<geometry<T>>
{
using coordinate_type = T;
using geometry_type = geometry<T>;
using container_type = Cont<geometry_type>;
using container_type::container_type;
};
} // namespace geometry
} // namespace mapbox

21
mapbox/geometry/line_string.hpp Normal file
View File

@ -0,0 +1,21 @@
#pragma once
// mapbox
#include <mapbox/geometry/point.hpp>
// stl
#include <vector>
namespace mapbox {
namespace geometry {
template <typename T, template <typename...> class Cont = std::vector>
struct line_string : Cont<point<T> >
{
using coordinate_type = T;
using point_type = point<T>;
using container_type = Cont<point_type>;
using container_type::container_type;
};
} // namespace geometry
} // namespace mapbox

21
mapbox/geometry/multi_line_string.hpp Normal file
View File

@ -0,0 +1,21 @@
#pragma once
// mapbox
#include <mapbox/geometry/line_string.hpp>
// stl
#include <vector>
namespace mapbox {
namespace geometry {
template <typename T, template <typename...> class Cont = std::vector>
struct multi_line_string : Cont<line_string<T>>
{
using coordinate_type = T;
using line_string_type = line_string<T>;
using container_type = Cont<line_string_type>;
using container_type::container_type;
};
} // namespace geometry
} // namespace mapbox

21
mapbox/geometry/multi_point.hpp Normal file
View File

@ -0,0 +1,21 @@
#pragma once
// mapbox
#include <mapbox/geometry/point.hpp>
// stl
#include <vector>
namespace mapbox {
namespace geometry {
template <typename T, template <typename...> class Cont = std::vector>
struct multi_point : Cont<point<T>>
{
using coordinate_type = T;
using point_type = point<T>;
using container_type = Cont<point_type>;
using container_type::container_type;
};
} // namespace geometry
} // namespace mapbox

21
mapbox/geometry/multi_polygon.hpp Normal file
View File

@ -0,0 +1,21 @@
#pragma once
// mapbox
#include <mapbox/geometry/polygon.hpp>
// stl
#include <vector>
namespace mapbox {
namespace geometry {
template <typename T, template <typename...> class Cont = std::vector>
struct multi_polygon : Cont<polygon<T>>
{
using coordinate_type = T;
using polygon_type = polygon<T>;
using container_type = Cont<polygon_type>;
using container_type::container_type;
};
} // namespace geometry
} // namespace mapbox

35
mapbox/geometry/point.hpp Normal file
View File

@ -0,0 +1,35 @@
#pragma once
namespace mapbox {
namespace geometry {
template <typename T>
struct point
{
using coordinate_type = T;
constexpr point()
: x(), y()
{}
constexpr point(T x_, T y_)
: x(x_), y(y_)
{}
T x;
T y;
};
template <typename T>
constexpr bool operator==(point<T> const& lhs, point<T> const& rhs)
{
return lhs.x == rhs.x && lhs.y == rhs.y;
}
template <typename T>
constexpr bool operator!=(point<T> const& lhs, point<T> const& rhs)
{
return !(lhs == rhs);
}
} // namespace geometry
} // namespace mapbox

119
mapbox/geometry/point_arithmetic.hpp Normal file
View File

@ -0,0 +1,119 @@
#pragma once
namespace mapbox {
namespace geometry {
template <typename T>
constexpr point<T> operator+(point<T> const& lhs, point<T> const& rhs)
{
return point<T>(lhs.x + rhs.x, lhs.y + rhs.y);
}
template <typename T>
constexpr point<T> operator+(point<T> const& lhs, T const& rhs)
{
return point<T>(lhs.x + rhs, lhs.y + rhs);
}
template <typename T>
constexpr point<T> operator-(point<T> const& lhs, point<T> const& rhs)
{
return point<T>(lhs.x - rhs.x, lhs.y - rhs.y);
}
template <typename T>
constexpr point<T> operator-(point<T> const& lhs, T const& rhs)
{
return point<T>(lhs.x - rhs, lhs.y - rhs);
}
template <typename T>
constexpr point<T> operator*(point<T> const& lhs, point<T> const& rhs)
{
return point<T>(lhs.x * rhs.x, lhs.y * rhs.y);
}
template <typename T>
constexpr point<T> operator*(point<T> const& lhs, T const& rhs)
{
return point<T>(lhs.x * rhs, lhs.y * rhs);
}
template <typename T>
constexpr point<T> operator/(point<T> const& lhs, point<T> const& rhs)
{
return point<T>(lhs.x / rhs.x, lhs.y / rhs.y);
}
template <typename T>
constexpr point<T> operator/(point<T> const& lhs, T const& rhs)
{
return point<T>(lhs.x / rhs, lhs.y / rhs);
}
template <typename T>
constexpr point<T>& operator+=(point<T>& lhs, point<T> const& rhs)
{
lhs.x += rhs.x;
lhs.y += rhs.y;
return lhs;
}
template <typename T>
constexpr point<T>& operator+=(point<T>& lhs, T const& rhs)
{
lhs.x += rhs;
lhs.y += rhs;
return lhs;
}
template <typename T>
constexpr point<T>& operator-=(point<T>& lhs, point<T> const& rhs)
{
lhs.x -= rhs.x;
lhs.y -= rhs.y;
return lhs;
}
template <typename T>
constexpr point<T>& operator-=(point<T>& lhs, T const& rhs)
{
lhs.x -= rhs;
lhs.y -= rhs;
return lhs;
}
template <typename T>
constexpr point<T>& operator*=(point<T>& lhs, point<T> const& rhs)
{
lhs.x *= rhs.x;
lhs.y *= rhs.y;
return lhs;
}
template <typename T>
constexpr point<T>& operator*=(point<T>& lhs, T const& rhs)
{
lhs.x *= rhs;
lhs.y *= rhs;
return lhs;
}
template <typename T>
constexpr point<T>& operator/=(point<T>& lhs, point<T> const& rhs)
{
lhs.x /= rhs.x;
lhs.y /= rhs.y;
return lhs;
}
template <typename T>
constexpr point<T>& operator/=(point<T>& lhs, T const& rhs)
{
lhs.x /= rhs;
lhs.y /= rhs;
return lhs;
}
} // namespace geometry
} // namespace mapbox

31
mapbox/geometry/polygon.hpp Normal file
View File

@ -0,0 +1,31 @@
#pragma once
// mapbox
#include <mapbox/geometry/point.hpp>
// stl
#include <vector>
namespace mapbox {
namespace geometry {
template <typename T, template <typename...> class Cont = std::vector>
struct linear_ring : Cont<point<T>>
{
using coordinate_type = T;
using point_type = point<T>;
using container_type = Cont<point_type>;
using container_type::container_type;
};
template <typename T, template <typename...> class Cont = std::vector>
struct polygon : Cont<linear_ring<T>>
{
using coordinate_type = T;
using linear_ring_type = linear_ring<T>;
using container_type = Cont<linear_ring_type>;
using container_type::container_type;
};
} // namespace geometry
} // namespace mapbox

527
mapbox/geometry/wagyu/active_bound_list.hpp Normal file
View File

@ -0,0 +1,527 @@
#pragma once
#ifdef DEBUG
#include <iostream>
#include <sstream>
#endif
#include <mapbox/geometry/wagyu/bound.hpp>
#include <mapbox/geometry/wagyu/config.hpp>
#include <mapbox/geometry/wagyu/edge.hpp>
#include <mapbox/geometry/wagyu/exceptions.hpp>
#include <mapbox/geometry/wagyu/local_minimum.hpp>
#include <mapbox/geometry/wagyu/local_minimum_util.hpp>
#include <mapbox/geometry/wagyu/ring.hpp>
#include <mapbox/geometry/wagyu/scanbeam.hpp>
#include <mapbox/geometry/wagyu/util.hpp>
namespace mapbox {
namespace geometry {
namespace wagyu {
template <typename T>
using active_bound_list = std::list<bound_ptr<T>>;
template <typename T>
using active_bound_list_itr = typename active_bound_list<T>::iterator;
template <typename T>
using active_bound_list_rev_itr = typename active_bound_list<T>::reverse_iterator;
#ifdef DEBUG
template <class charT, class traits, typename T>
inline std::basic_ostream<charT, traits>& operator<<(std::basic_ostream<charT, traits>& out,
const active_bound_list<T>& bnds) {
std::size_t c = 0;
for (auto const& bnd : bnds) {
out << "Index: " << c++ << std::endl;
out << *bnd;
}
return out;
}
template <typename T>
std::string output_edges(active_bound_list<T> const& bnds) {
std::ostringstream out;
out << "[";
bool first = true;
for (auto const& bnd : bnds) {
if (first) {
first = false;
} else {
out << ",";
}
out << "[[" << bnd->current_edge->bot.x << "," << bnd->current_edge->bot.y << "],[";
out << bnd->current_edge->top.x << "," << bnd->current_edge->top.y << "]]";
}
out << "]";
return out.str();
}
#endif
template <typename T>
bool is_even_odd_fill_type(bound<T> const& bound,
fill_type subject_fill_type,
fill_type clip_fill_type) {
if (bound.poly_type == polygon_type_subject) {
return subject_fill_type == fill_type_even_odd;
} else {
return clip_fill_type == fill_type_even_odd;
}
}
template <typename T>
bool is_even_odd_alt_fill_type(bound<T> const& bound,
fill_type subject_fill_type,
fill_type clip_fill_type) {
if (bound.poly_type == polygon_type_subject) {
return clip_fill_type == fill_type_even_odd;
} else {
return subject_fill_type == fill_type_even_odd;
}
}
template <typename T>
inline bool bound2_inserts_before_bound1(bound<T> const& bound1, bound<T> const& bound2) {
if (values_are_equal(bound2.current_x, bound1.current_x)) {
if (bound2.current_edge->top.y > bound1.current_edge->top.y) {
return bound2.current_edge->top.x <
get_current_x(*(bound1.current_edge), bound2.current_edge->top.y);
} else {
return bound1.current_edge->top.x >
get_current_x(*(bound2.current_edge), bound1.current_edge->top.y);
}
} else {
return bound2.current_x < bound1.current_x;
}
}
template <typename T>
active_bound_list_itr<T> insert_bound_into_ABL(bound<T>& bnd, active_bound_list<T>& active_bounds) {
auto itr = active_bounds.begin();
while (itr != active_bounds.end() && !bound2_inserts_before_bound1(*(*itr), bnd)) {
++itr;
}
return active_bounds.insert(itr, &bnd);
}
template <typename T>
active_bound_list_itr<T> insert_bound_into_ABL(bound<T>& bnd,
active_bound_list_itr<T> itr,
active_bound_list<T>& active_bounds) {
while (itr != active_bounds.end() && !bound2_inserts_before_bound1(*(*itr), bnd)) {
++itr;
}
return active_bounds.insert(itr, &bnd);
}
template <typename T>
inline bool is_maxima(bound<T>& bnd, T y) {
return bnd.next_edge == bnd.edges.end() &&
bnd.current_edge->top.y == y;
}
template <typename T>
inline bool is_maxima(active_bound_list_itr<T>& bnd, T y) {
return is_maxima(*(*bnd), y);
}
template <typename T>
inline bool is_intermediate(bound<T>& bnd, T y) {
return bnd.next_edge != bnd.edges.end() &&
bnd.current_edge->top.y == y;
}
template <typename T>
inline bool is_intermediate(active_bound_list_itr<T>& bnd, T y) {
return is_intermediate(*(*bnd), y);
}
template <typename T>
inline bool current_edge_is_horizontal(active_bound_list_itr<T>& bnd) {
return is_horizontal(*((*bnd)->current_edge));
}
template <typename T>
inline bool next_edge_is_horizontal(active_bound_list_itr<T>& bnd) {
return is_horizontal(*((*bnd)->next_edge));
}
template <typename T>
inline void swap_positions_in_ABL(active_bound_list_itr<T>& bnd1,
active_bound_list_itr<T>& bnd2,
active_bound_list<T>& active_bounds) {
if (std::next(bnd2) == bnd1) {
active_bounds.splice(bnd2, active_bounds, bnd1);
} else {
active_bounds.splice(bnd1, active_bounds, bnd2);
}
}
template <typename T>
void next_edge_in_bound(active_bound_list_itr<T>& bnd, scanbeam_list<T>& scanbeam) {
++((*bnd)->current_edge);
if ((*bnd)->current_edge != (*bnd)->edges.end()) {
++((*bnd)->next_edge);
(*bnd)->current_x = static_cast<double>((*bnd)->current_edge->bot.x);
if (!current_edge_is_horizontal<T>(bnd)) {
scanbeam.push((*bnd)->current_edge->top.y);
}
}
}
template <typename T>
active_bound_list_itr<T> get_maxima_pair(active_bound_list_itr<T> bnd,
active_bound_list<T>& active_bounds) {
auto bnd_itr = active_bounds.begin();
while (bnd_itr != active_bounds.end()) {
if (*bnd_itr == (*bnd)->maximum_bound) {
break;
}
++bnd_itr;
}
return bnd_itr;
}
template <typename T>
void set_winding_count(active_bound_list_itr<T>& bnd_itr,
active_bound_list<T>& active_bounds,
clip_type cliptype,
fill_type subject_fill_type,
fill_type clip_fill_type) {
auto rev_bnd_itr = active_bound_list_rev_itr<T>(bnd_itr);
if (rev_bnd_itr == active_bounds.rend()) {
if ((*bnd_itr)->winding_delta == 0) {
fill_type pft = ((*bnd_itr)->poly_type == polygon_type_subject) ? subject_fill_type
: clip_fill_type;
(*bnd_itr)->winding_count = (pft == fill_type_negative ? -1 : 1);
} else {
(*bnd_itr)->winding_count = (*bnd_itr)->winding_delta;
}
(*bnd_itr)->winding_count2 = 0;
return;
}
// find the edge of the same polytype that immediately preceeds 'edge' in
// AEL
while (rev_bnd_itr != active_bounds.rend() &&
((*rev_bnd_itr)->poly_type != (*bnd_itr)->poly_type ||
(*rev_bnd_itr)->winding_delta == 0)) {
++rev_bnd_itr;
}
if (rev_bnd_itr == active_bounds.rend()) {
if ((*bnd_itr)->winding_delta == 0) {
fill_type pft = ((*bnd_itr)->poly_type == polygon_type_subject) ? subject_fill_type
: clip_fill_type;
(*bnd_itr)->winding_count = (pft == fill_type_negative ? -1 : 1);
} else {
(*bnd_itr)->winding_count = (*bnd_itr)->winding_delta;
}
(*bnd_itr)->winding_count2 = 0;
} else if ((*bnd_itr)->winding_delta == 0 && cliptype != clip_type_union) {
(*bnd_itr)->winding_count = 1;
(*bnd_itr)->winding_count2 = (*rev_bnd_itr)->winding_count2;
} else if (is_even_odd_fill_type(*(*bnd_itr), subject_fill_type, clip_fill_type)) {
// EvenOdd filling ...
if ((*bnd_itr)->winding_delta == 0) {
// are we inside a subj polygon ...
bool inside = true;
auto rev2 = std::next(rev_bnd_itr);
while (rev2 != active_bounds.rend()) {
if ((*rev2)->poly_type == (*rev_bnd_itr)->poly_type &&
(*rev2)->winding_delta != 0) {
inside = !inside;
}
++rev2;
}
(*bnd_itr)->winding_count = (inside ? 0 : 1);
} else {
(*bnd_itr)->winding_count = (*bnd_itr)->winding_delta;
}
(*bnd_itr)->winding_count2 = (*rev_bnd_itr)->winding_count2;
} else {
// nonZero, Positive or Negative filling ...
if ((*rev_bnd_itr)->winding_count * (*rev_bnd_itr)->winding_delta < 0) {
// prev edge is 'decreasing' WindCount (WC) toward zero
// so we're outside the previous polygon ...
if (std::abs(static_cast<int>((*rev_bnd_itr)->winding_count)) > 1) {
// outside prev poly but still inside another.
// when reversing direction of prev poly use the same WC
if ((*rev_bnd_itr)->winding_delta * (*bnd_itr)->winding_delta < 0) {
(*bnd_itr)->winding_count = (*rev_bnd_itr)->winding_count;
} else {
// otherwise continue to 'decrease' WC ...
(*bnd_itr)->winding_count =
(*rev_bnd_itr)->winding_count + (*bnd_itr)->winding_delta;
}
} else {
// now outside all polys of same polytype so set own WC ...
(*bnd_itr)->winding_count =
((*bnd_itr)->winding_delta == 0 ? 1 : (*bnd_itr)->winding_delta);
}
} else {
// prev edge is 'increasing' WindCount (WC) away from zero
// so we're inside the previous polygon ...
if ((*bnd_itr)->winding_delta == 0) {
(*bnd_itr)->winding_count =
((*rev_bnd_itr)->winding_count < 0 ? (*rev_bnd_itr)->winding_count - 1
: (*rev_bnd_itr)->winding_count + 1);
} else if ((*rev_bnd_itr)->winding_delta * (*bnd_itr)->winding_delta < 0) {
// if wind direction is reversing prev then use same WC
(*bnd_itr)->winding_count = (*rev_bnd_itr)->winding_count;
} else {
// otherwise add to WC ...
(*bnd_itr)->winding_count =
(*rev_bnd_itr)->winding_count + (*bnd_itr)->winding_delta;
}
}
(*bnd_itr)->winding_count2 = (*rev_bnd_itr)->winding_count2;
}
// update winding_count2 ...
auto bnd_itr_forward = rev_bnd_itr.base();
if (is_even_odd_alt_fill_type(*(*bnd_itr), subject_fill_type, clip_fill_type)) {
// EvenOdd filling ...
while (bnd_itr_forward != bnd_itr) {
if ((*bnd_itr_forward)->winding_delta != 0) {
(*bnd_itr)->winding_count2 = ((*bnd_itr)->winding_count2 == 0 ? 1 : 0);
}
++bnd_itr_forward;
}
} else {
// nonZero, Positive or Negative filling ...
while (bnd_itr_forward != bnd_itr) {
(*bnd_itr)->winding_count2 += (*bnd_itr_forward)->winding_delta;
++bnd_itr_forward;
}
}
}
template <typename T>
bool is_contributing(bound<T> const& bnd,
clip_type cliptype,
fill_type subject_fill_type,
fill_type clip_fill_type) {
fill_type pft = subject_fill_type;
fill_type pft2 = clip_fill_type;
if (bnd.poly_type != polygon_type_subject) {
pft = clip_fill_type;
pft2 = subject_fill_type;
}
switch (pft) {
case fill_type_even_odd:
// return false if a subj line has been flagged as inside a subj
// polygon
if (bnd.winding_delta == 0 && bnd.winding_count != 1) {
return false;
}
break;
case fill_type_non_zero:
if (std::abs(static_cast<int>(bnd.winding_count)) != 1) {
return false;
}
break;
case fill_type_positive:
if (bnd.winding_count != 1) {
return false;
}
break;
case fill_type_negative:
default:
if (bnd.winding_count != -1) {
return false;
}
}
switch (cliptype) {
case clip_type_intersection:
switch (pft2) {
case fill_type_even_odd:
case fill_type_non_zero:
return (bnd.winding_count2 != 0);
case fill_type_positive:
return (bnd.winding_count2 > 0);
case fill_type_negative:
default:
return (bnd.winding_count2 < 0);
}
break;
case clip_type_union:
switch (pft2) {
case fill_type_even_odd:
case fill_type_non_zero:
return (bnd.winding_count2 == 0);
case fill_type_positive:
return (bnd.winding_count2 <= 0);
case fill_type_negative:
default:
return (bnd.winding_count2 >= 0);
}
break;
case clip_type_difference:
if (bnd.poly_type == polygon_type_subject) {
switch (pft2) {
case fill_type_even_odd:
case fill_type_non_zero:
return (bnd.winding_count2 == 0);
case fill_type_positive:
return (bnd.winding_count2 <= 0);
case fill_type_negative:
default:
return (bnd.winding_count2 >= 0);
}
} else {
switch (pft2) {
case fill_type_even_odd:
case fill_type_non_zero:
return (bnd.winding_count2 != 0);
case fill_type_positive:
return (bnd.winding_count2 > 0);
case fill_type_negative:
default:
return (bnd.winding_count2 < 0);
}
}
break;
case clip_type_x_or:
if (bnd.winding_delta == 0) {
// XOr always contributing unless open
switch (pft2) {
case fill_type_even_odd:
case fill_type_non_zero:
return (bnd.winding_count2 == 0);
case fill_type_positive:
return (bnd.winding_count2 <= 0);
case fill_type_negative:
default:
return (bnd.winding_count2 >= 0);
}
} else {
return true;
}
break;
default:
return true;
}
}
template <typename T>
void insert_lm_only_one_bound(bound<T>& bnd,
active_bound_list<T>& active_bounds,
ring_manager<T>& rings,
scanbeam_list<T>& scanbeam,
clip_type cliptype,
fill_type subject_fill_type,
fill_type clip_fill_type) {
auto abl_itr = insert_bound_into_ABL(bnd, active_bounds);
set_winding_count(abl_itr, active_bounds, cliptype, subject_fill_type, clip_fill_type);
if (is_contributing(bnd, cliptype, subject_fill_type, clip_fill_type)) {
add_first_point(abl_itr, active_bounds, (*abl_itr)->current_edge->bot, rings);
}
if (!current_edge_is_horizontal<T>(abl_itr)) {
scanbeam.push((*abl_itr)->current_edge->top.y);
}
}
template <typename T>
void insert_lm_left_and_right_bound(bound<T>& left_bound,
bound<T>& right_bound,
active_bound_list<T>& active_bounds,
ring_manager<T>& rings,
scanbeam_list<T>& scanbeam,
clip_type cliptype,
fill_type subject_fill_type,
fill_type clip_fill_type) {
// Both left and right bound
auto lb_abl_itr = insert_bound_into_ABL(left_bound, active_bounds);
auto rb_abl_itr = insert_bound_into_ABL(right_bound, lb_abl_itr, active_bounds);
set_winding_count(lb_abl_itr, active_bounds, cliptype, subject_fill_type, clip_fill_type);
(*rb_abl_itr)->winding_count = (*lb_abl_itr)->winding_count;
(*rb_abl_itr)->winding_count2 = (*lb_abl_itr)->winding_count2;
if (is_contributing(left_bound, cliptype, subject_fill_type, clip_fill_type)) {
add_local_minimum_point(lb_abl_itr, rb_abl_itr, active_bounds,
(*lb_abl_itr)->current_edge->bot, rings);
}
// Add top of edges to scanbeam
scanbeam.push((*lb_abl_itr)->current_edge->top.y);
if (!current_edge_is_horizontal<T>(rb_abl_itr)) {
scanbeam.push((*rb_abl_itr)->current_edge->top.y);
}
auto abl_itr = std::next(lb_abl_itr);
while (abl_itr != rb_abl_itr && abl_itr != active_bounds.end()) {
// We call intersect_bounds here, but we do not swap positions in the ABL
// this is the logic that was copied from angus, but it might be correct
// to swap the positions in the ABL following this or at least move
// lb and rb to be next to each other in the ABL.
intersect_bounds(rb_abl_itr, abl_itr, (*lb_abl_itr)->current_edge->bot, cliptype,
subject_fill_type, clip_fill_type, rings, active_bounds);
++abl_itr;
}
}
template <typename T>
void insert_local_minima_into_ABL(T const bot_y,
local_minimum_ptr_list<T> const& minima_sorted,
local_minimum_ptr_list_itr<T>& current_lm,
active_bound_list<T>& active_bounds,
ring_manager<T>& rings,
scanbeam_list<T>& scanbeam,
clip_type cliptype,
fill_type subject_fill_type,
fill_type clip_fill_type) {
while (current_lm != minima_sorted.end() && bot_y == (*current_lm)->y) {
initialize_lm<T>(current_lm);
auto& left_bound = (*current_lm)->left_bound;
auto& right_bound = (*current_lm)->right_bound;
if (left_bound.edges.empty() && !right_bound.edges.empty()) {
insert_lm_only_one_bound(right_bound, active_bounds, rings, scanbeam, cliptype,
subject_fill_type, clip_fill_type);
} else if (right_bound.edges.empty() && !left_bound.edges.empty()) {
insert_lm_only_one_bound(left_bound, active_bounds, rings, scanbeam, cliptype,
subject_fill_type, clip_fill_type);
} else {
insert_lm_left_and_right_bound(left_bound, right_bound, active_bounds, rings, scanbeam,
cliptype, subject_fill_type, clip_fill_type);
}
++current_lm;
}
}
template <typename T>
void insert_horizontal_local_minima_into_ABL(T const top_y,
local_minimum_ptr_list<T> const& minima_sorted,
local_minimum_ptr_list_itr<T>& current_lm,
active_bound_list<T>& active_bounds,
ring_manager<T>& rings,
scanbeam_list<T>& scanbeam,
clip_type cliptype,
fill_type subject_fill_type,
fill_type clip_fill_type) {
while (current_lm != minima_sorted.end() && top_y == (*current_lm)->y &&
(*current_lm)->minimum_has_horizontal) {
initialize_lm<T>(current_lm);
auto& left_bound = (*current_lm)->left_bound;
auto& right_bound = (*current_lm)->right_bound;
if (left_bound.edges.empty() && !right_bound.edges.empty()) {
insert_lm_only_one_bound(right_bound, active_bounds, rings, scanbeam, cliptype,
subject_fill_type, clip_fill_type);
} else if (right_bound.edges.empty() && !left_bound.edges.empty()) {
throw clipper_exception(
"There should only be horizontal local minimum on right bounds!");
} else {
insert_lm_left_and_right_bound(left_bound, right_bound, active_bounds, rings, scanbeam,
cliptype, subject_fill_type, clip_fill_type);
}
++current_lm;
}
}
}
}
}

95
mapbox/geometry/wagyu/bound.hpp Normal file
View File

@ -0,0 +1,95 @@
#pragma once
#include <list>
#include <mapbox/geometry/point.hpp>
#include <mapbox/geometry/wagyu/config.hpp>
#include <mapbox/geometry/wagyu/edge.hpp>
#include <mapbox/geometry/wagyu/ring.hpp>
#ifdef DEBUG
#include <iostream>
#endif
namespace mapbox {
namespace geometry {
namespace wagyu {
template <typename T>
struct bound {
edge_list<T> edges;
edge_list_itr<T> current_edge;
edge_list_itr<T> next_edge;
mapbox::geometry::point<T> last_point;
ring_ptr<T> ring;
bound_ptr<T> maximum_bound; // the bound who's maximum connects with this bound
double current_x;
std::size_t pos;
std::int32_t winding_count;
std::int32_t winding_count2; // winding count of the opposite polytype
std::int8_t winding_delta; // 1 or -1 depending on winding direction - 0 for linestrings
polygon_type poly_type;
edge_side side; // side only refers to current side of solution poly
bound() noexcept
: edges(),
current_edge(edges.end()),
last_point({ 0, 0 }),
ring(nullptr),
maximum_bound(nullptr),
current_x(0.0),
pos(0),
winding_count(0),
winding_count2(0),
winding_delta(0),
poly_type(polygon_type_subject),
side(edge_left) {
}
bound(bound<T> && b) noexcept
: edges(std::move(b.edges)),
current_edge(std::move(b.current_edge)),
last_point(std::move(b.last_point)),
ring(std::move(b.ring)),
maximum_bound(std::move(b.maximum_bound)),
current_x(std::move(b.current_x)),
pos(std::move(b.pos)),
winding_count(std::move(b.winding_count)),
winding_count2(std::move(b.winding_count2)),
winding_delta(std::move(b.winding_delta)),
poly_type(std::move(b.poly_type)),
side(std::move(b.side)) {
}
};
#ifdef DEBUG
template <class charT, class traits, typename T>
inline std::basic_ostream<charT, traits>& operator<<(std::basic_ostream<charT, traits>& out,
const bound<T>& bnd) {
out << " Bound: " << &bnd << std::endl;
out << " current_x: " << bnd.current_x << std::endl;
out << " last_point: " << bnd.last_point.x << ", " << bnd.last_point.y << std::endl;
out << *(bnd.current_edge);
out << " winding count: " << bnd.winding_count << std::endl;
out << " winding_count2: " << bnd.winding_count2 << std::endl;
out << " winding_delta: " << static_cast<int>(bnd.winding_delta) << std::endl;
out << " maximum_bound: " << bnd.maximum_bound << std::endl;
if (bnd.side == edge_left) {
out << " side: left" << std::endl;
} else {
out << " side: right" << std::endl;
}
out << " ring: " << bnd.ring << std::endl;
if (bnd.ring) {
out << " ring index: " << bnd.ring->ring_index << std::endl;
}
return out;
}
#endif
}
}
}

217
mapbox/geometry/wagyu/build_edges.hpp Normal file
View File

@ -0,0 +1,217 @@
#pragma once
#include <mapbox/geometry/line_string.hpp>
#include <mapbox/geometry/point.hpp>
#include <mapbox/geometry/polygon.hpp>
#include <mapbox/geometry/wagyu/config.hpp>
#include <mapbox/geometry/wagyu/edge.hpp>
#include <mapbox/geometry/wagyu/exceptions.hpp>
#include <mapbox/geometry/wagyu/util.hpp>
namespace mapbox {
namespace geometry {
namespace wagyu {
template <typename T>
bool build_edge_list(mapbox::geometry::line_string<T> const& path_geometry,
edge_list<T>& edges,
bool& is_flat) {
if (path_geometry.size() < 2) {
return false;
}
auto itr_next = path_geometry.begin();
++itr_next;
auto itr = path_geometry.begin();
while (itr_next != path_geometry.end()) {
if (*itr_next == *itr) {
// Duplicate point advance itr_next, but do not
// advance itr
++itr_next;
continue;
}
if (is_flat && itr_next->y != itr->y) {
is_flat = false;
}
edges.emplace_back(*itr, *itr_next);
itr = itr_next;
++itr_next;
}
if (edges.size() < 2) {
return false;
}
return true;
}
template <typename T>
bool point_2_is_between_point_1_and_point_3(mapbox::geometry::point<T> const& pt1,
mapbox::geometry::point<T> const& pt2,
mapbox::geometry::point<T> const& pt3) {
if ((pt1 == pt3) || (pt1 == pt2) || (pt3 == pt2)) {
return false;
} else if (pt1.x != pt3.x) {
return (pt2.x > pt1.x) == (pt2.x < pt3.x);
} else {
return (pt2.y > pt1.y) == (pt2.y < pt3.y);
}
}
template <typename T>
bool build_edge_list(mapbox::geometry::linear_ring<T> const& path_geometry, edge_list<T>& edges) {
using value_type = T;
if (path_geometry.size() < 3) {
return false;
}
// As this is a loop, we need to first go backwards from end to try and find
// the proper starting point for the iterators before the beginning
auto itr_rev = path_geometry.rbegin();
auto itr = path_geometry.begin();
mapbox::geometry::point<value_type> pt1 = *itr_rev;
mapbox::geometry::point<value_type> pt2 = *itr;
// Find next non repeated point going backwards from
// end for pt1
while (pt1 == pt2) {
++itr_rev;
if (itr_rev == path_geometry.rend()) {
return false;
}
pt1 = *itr_rev;
}
++itr;
mapbox::geometry::point<value_type> pt3 = *itr;
auto itr_last = itr_rev.base();
mapbox::geometry::point<value_type> front_pt;
mapbox::geometry::point<value_type> back_pt;
while (true) {
if (pt3 == pt2) {
// Duplicate point advance itr, but do not
// advance other points
if (itr == itr_last) {
break;
}
++itr;
if (itr == itr_last) {
if (edges.empty()) {
break;
}
pt3 = front_pt;
} else {
pt3 = *itr;
}
continue;
}
// Now check if slopes are equal between two segments - either
// a spike or a collinear point - if so drop point number 2.
if (slopes_equal(pt1, pt2, pt3)) {
// We need to reconsider previously added points
// because the point it was using was found to be collinear
// or a spike
pt2 = pt1;
if (!edges.empty()) {
edges.pop_back(); // remove previous edge (pt1)
}
if (!edges.empty()) {
if (back_pt == edges.back().top) {
pt1 = edges.back().bot;
} else {
pt1 = edges.back().top;
}
back_pt = pt1;
} else {
// If this occurs we must look to the back of the
// ring for new points.
do {
++itr_rev;
if ((itr + 1) == itr_rev.base()) {
return false;
}
pt1 = *itr_rev;
} while (pt1 == pt2);
itr_last = itr_rev.base();
}
continue;
}
if (edges.empty()) {
front_pt = pt2;
}
edges.emplace_back(pt2, pt3);
back_pt = pt2;
if (itr == itr_last) {
break;
}
pt1 = pt2;
pt2 = pt3;
++itr;
if (itr == itr_last) {
if (edges.empty()) {
break;
}
pt3 = front_pt;
} else {
pt3 = *itr;
}
}
bool modified = false;
do {
modified = false;
if (edges.size() < 3) {
return false;
}
auto& f = edges.front();
auto& b = edges.back();
if (slopes_equal(f, b)) {
if (f.bot == b.top) {
if (f.top == b.bot) {
edges.pop_back();
edges.erase(edges.begin());
} else {
f.bot = b.bot;
edges.pop_back();
}
modified = true;
} else if (f.top == b.bot) {
f.top = b.top;
edges.pop_back();
modified = true;
} else if (f.top == b.top && f.bot == b.bot) {
edges.pop_back();
edges.erase(edges.begin());
modified = true;
} else if (f.top == b.top) {
if (point_2_is_between_point_1_and_point_3(f.top, f.bot, b.bot)) {
b.top = f.bot;
edges.erase(edges.begin());
} else {
f.top = b.bot;
edges.pop_back();
}
modified = true;
} else if (f.bot == b.bot) {
if (point_2_is_between_point_1_and_point_3(f.bot, f.top, b.top)) {
b.bot = f.top;
edges.erase(edges.begin());
} else {
f.bot = b.top;
edges.pop_back();
}
modified = true;
}
}
} while (modified);
return true;
}
}
}
}

40
mapbox/geometry/wagyu/build_local_minima_list.hpp Normal file
View File

@ -0,0 +1,40 @@
#pragma once
#include <mapbox/geometry/wagyu/build_edges.hpp>
#include <mapbox/geometry/wagyu/config.hpp>
#include <mapbox/geometry/wagyu/local_minimum.hpp>
#include <mapbox/geometry/wagyu/local_minimum_util.hpp>
namespace mapbox {
namespace geometry {
namespace wagyu {
template <typename T>
bool add_line_string(mapbox::geometry::line_string<T> const& path_geometry,
local_minimum_list<T>& minima_list) {
bool is_flat = true;
edge_list<T> new_edges;
new_edges.reserve(path_geometry.size());
if (!build_edge_list(path_geometry, new_edges, is_flat) || new_edges.empty()) {
return false;
}
add_line_to_local_minima_list(new_edges, minima_list, polygon_type_subject);
return true;
}
template <typename T>
bool add_linear_ring(mapbox::geometry::linear_ring<T> const& path_geometry,
local_minimum_list<T>& minima_list,
polygon_type p_type) {
edge_list<T> new_edges;
new_edges.reserve(path_geometry.size());
if (!build_edge_list(path_geometry, new_edges) || new_edges.empty()) {
return false;
}
add_ring_to_local_minima_list(new_edges, minima_list, p_type);
return true;
}
}
}
}

68
mapbox/geometry/wagyu/build_result.hpp Normal file
View File

@ -0,0 +1,68 @@
#pragma once
#include <mapbox/geometry/wagyu/ring.hpp>
#include <mapbox/geometry/wagyu/ring_util.hpp>
namespace mapbox {
namespace geometry {
namespace wagyu {
template <typename T>
void push_ring_to_polygon(mapbox::geometry::polygon<T>& poly, ring_ptr<T>& r, bool reverse_output) {
mapbox::geometry::linear_ring<T> lr;
lr.reserve(r->size + 1);
auto firstPt = r->points;
auto ptIt = r->points;
if (reverse_output) {
do {
lr.push_back({ ptIt->x, ptIt->y });
ptIt = ptIt->next;
} while (ptIt != firstPt);
} else {
do {
lr.push_back({ ptIt->x, ptIt->y });
ptIt = ptIt->prev;
} while (ptIt != firstPt);
}
lr.push_back({ firstPt->x, firstPt->y }); // close the ring
poly.push_back(lr);
}
template <typename T>
void build_result_polygons(std::vector<mapbox::geometry::polygon<T>>& solution,
ring_list<T>& rings,
bool reverse_output) {
for (auto& r : rings) {
assert(r->points);
std::size_t cnt = point_count(r->points);
if ((r->is_open && cnt < 2) || (!r->is_open && cnt < 3)) {
continue;
}
solution.emplace_back();
push_ring_to_polygon(solution.back(), r, reverse_output);
for (auto& c : r->children) {
assert(c->points);
cnt = point_count(c->points);
if ((c->is_open && cnt < 2) || (!c->is_open && cnt < 3)) {
continue;
}
push_ring_to_polygon(solution.back(), c, reverse_output);
}
for (auto& c : r->children) {
if (!c->children.empty()) {
build_result_polygons(solution, c->children, reverse_output);
}
}
}
}
template <typename T>
void build_result(std::vector<mapbox::geometry::polygon<T>>& solution,
ring_manager<T>& rings,
bool reverse_output) {
build_result_polygons(solution, rings.children, reverse_output);
}
}
}
}

52
mapbox/geometry/wagyu/config.hpp Normal file
View File

@ -0,0 +1,52 @@
#pragma once
#include <cassert>
#include <cstdint>
#include <list>
namespace mapbox {
namespace geometry {
namespace wagyu {
enum clip_type : std::uint8_t {
clip_type_intersection = 0,
clip_type_union,
clip_type_difference,
clip_type_x_or
};
enum polygon_type : std::uint8_t { polygon_type_subject = 0, polygon_type_clip };
enum fill_type : std::uint8_t {
fill_type_even_odd = 0,
fill_type_non_zero,
fill_type_positive,
fill_type_negative
};
static double const def_arc_tolerance = 0.25;
static int const EDGE_UNASSIGNED = -1; // edge not currently 'owning' a solution
static int const EDGE_SKIP = -2; // edge that would otherwise close a path
static std::int64_t const LOW_RANGE = 0x3FFFFFFF;
static std::int64_t const HIGH_RANGE = 0x3FFFFFFFFFFFFFFFLL;
enum horizontal_direction : std::uint8_t { right_to_left = 0, left_to_right = 1 };
enum edge_side : std::uint8_t { edge_left = 0, edge_right };
enum join_type : std::uint8_t { join_type_square = 0, join_type_round, join_type_miter };
enum end_type {
end_type_closed_polygon = 0,
end_type_closed_line,
end_type_open_butt,
end_type_open_square,
end_type_open_round
};
template <typename T>
using maxima_list = std::list<T>;
}
}
}

122
mapbox/geometry/wagyu/edge.hpp Normal file
View File

@ -0,0 +1,122 @@
#pragma once
#include <cmath>
#include <limits>
#include <list>
#include <mapbox/geometry/point.hpp>
#include <mapbox/geometry/wagyu/config.hpp>
#include <mapbox/geometry/wagyu/util.hpp>
#ifdef DEBUG
#include <iostream>
#endif
namespace mapbox {
namespace geometry {
namespace wagyu {
template <typename T>
struct bound;
template <typename T>
using bound_ptr = bound<T>*;
template <typename T>
struct edge {
mapbox::geometry::point<T> bot;
mapbox::geometry::point<T> top;
double dx;
edge(edge<T> && e) noexcept
: bot(std::move(e.bot)),
top(std::move(e.top)),
dx(std::move(e.dx)) {}
edge& operator=(edge<T> && e) noexcept {
bot = std::move(e.bot);
top = std::move(e.top);
dx = std::move(e.dx);
return *this;
}
edge(mapbox::geometry::point<T> const& current, mapbox::geometry::point<T> const& next_pt) noexcept
: bot(current), top(current), dx(0.0) {
if (current.y >= next_pt.y) {
top = next_pt;
} else {
bot = next_pt;
}
double dy = static_cast<double>(top.y - bot.y);
if (value_is_zero(dy)) {
dx = std::numeric_limits<double>::infinity();
} else {
dx = static_cast<double>(top.x - bot.x) / dy;
}
}
};
template <typename T>
using edge_ptr = edge<T>*;
template <typename T>
using edge_list = std::vector<edge<T>>;
template <typename T>
using edge_list_itr = typename edge_list<T>::iterator;
template <typename T>
bool slopes_equal(edge<T> const& e1, edge<T> const& e2) {
return (e1.top.y - e1.bot.y) * (e2.top.x - e2.bot.x) ==
(e1.top.x - e1.bot.x) * (e2.top.y - e2.bot.y);
}
template <typename T>
inline bool is_horizontal(edge<T> const& e) {
return std::isinf(e.dx);
}
template <typename T>
inline double get_current_x(edge<T> const& edge, const T current_y) {
if (current_y == edge.top.y) {
return static_cast<double>(edge.top.x);
} else {
return static_cast<double>(edge.bot.x) +
edge.dx * static_cast<double>(current_y - edge.bot.y);
}
}
#ifdef DEBUG
template <class charT, class traits, typename T>
inline std::basic_ostream<charT, traits>& operator<<(std::basic_ostream<charT, traits>& out,
const edge<T>& e) {
out << " Edge: " << std::endl;
out << " bot x: " << e.bot.x << " y: " << e.bot.y << std::endl;
out << " top x: " << e.top.x << " y: " << e.top.y << std::endl;
return out;
}
template <class charT, class traits, typename T>
inline std::basic_ostream<charT, traits>& operator<<(std::basic_ostream<charT, traits>& out,
edge_list<T> const& edges) {
out << "[";
bool first = true;
for (auto const& e : edges) {
if (first) {
first = false;
} else {
out << ",";
}
out << "[[" << e.bot.x << "," << e.bot.y << "],[";
out << e.top.x << "," << e.top.y << "]]";
}
out << "]";
return out;
}
#endif
}
}
}

23
mapbox/geometry/wagyu/exceptions.hpp Normal file
View File

@ -0,0 +1,23 @@
#pragma once
#include <stdexcept>
namespace mapbox {
namespace geometry {
namespace wagyu {
class clipper_exception : public std::exception {
private:
std::string m_descr;
public:
clipper_exception(const char* description) : m_descr(description) {
}
virtual ~clipper_exception() noexcept {
}
virtual const char* what() const noexcept {
return m_descr.c_str();
}
};
}
}
}

73
mapbox/geometry/wagyu/intersect.hpp Normal file
View File

@ -0,0 +1,73 @@
#pragma once
#include <set>
#include <mapbox/geometry/point.hpp>
#include <mapbox/geometry/wagyu/active_bound_list.hpp>
#ifdef DEBUG
#include <iostream>
#endif
namespace mapbox {
namespace geometry {
namespace wagyu {
template <typename T>
struct intersect_node {
active_bound_list_itr<T> bound1;
active_bound_list_itr<T> bound2;
mapbox::geometry::point<double> pt;
intersect_node(intersect_node<T> && n)
: bound1(std::move(n.bound1)),
bound2(std::move(n.bound2)),
pt(std::move(n.pt)) { }
intersect_node& operator=(intersect_node<T> && n) {
bound1 = std::move(n.bound1);
bound2 = std::move(n.bound2);
pt = std::move(n.pt);
return *this;
}
intersect_node(active_bound_list_itr<T> const& bound1_,
active_bound_list_itr<T> const& bound2_,
mapbox::geometry::point<double> const& pt_)
: bound1(bound1_), bound2(bound2_), pt(pt_) {
}
};
template <typename T>
using intersect_list = std::vector<intersect_node<T>>;
#ifdef DEBUG
template <class charT, class traits, typename T>
inline std::basic_ostream<charT, traits>& operator<<(std::basic_ostream<charT, traits>& out,
const intersect_node<T>& e) {
out << " point x: " << e.pt.x << " y: " << e.pt.y << std::endl;
out << " bound 1: " << std::endl;
out << *(*e.bound1) << std::endl;
out << " bound 2: " << std::endl;
out << *(*e.bound2) << std::endl;
return out;
}
template <class charT, class traits, typename T>
inline std::basic_ostream<charT, traits>& operator<<(std::basic_ostream<charT, traits>& out,
const intersect_list<T>& ints) {
std::size_t c = 0;
for (auto const& i : ints) {
out << "Intersection: " << c++ << std::endl;
out << i;
}
return out;
}
#endif
}
}
}

387
mapbox/geometry/wagyu/intersect_util.hpp Normal file
View File

@ -0,0 +1,387 @@
#pragma once
#include <mapbox/geometry/wagyu/active_bound_list.hpp>
#include <mapbox/geometry/wagyu/bound.hpp>
#include <mapbox/geometry/wagyu/config.hpp>
#include <mapbox/geometry/wagyu/intersect.hpp>
#include <mapbox/geometry/wagyu/ring_util.hpp>
#include <mapbox/geometry/wagyu/util.hpp>
namespace mapbox {
namespace geometry {
namespace wagyu {
template <typename T>
struct intersect_list_sorter {
inline bool operator()(intersect_node<T> const& node1, intersect_node<T> const& node2) {
if (!values_are_equal(node2.pt.y, node1.pt.y)) {
return node2.pt.y < node1.pt.y;
} else {
return ((*node2.bound1)->winding_count2 + (*node2.bound2)->winding_count2) >
((*node1.bound1)->winding_count2 + (*node1.bound2)->winding_count2);
}
}
};
template <typename T>
inline mapbox::geometry::point<T> round_point(mapbox::geometry::point<double> const& pt) {
return mapbox::geometry::point<T>(round_towards_max<T>(pt.x), round_towards_max<T>(pt.y));
}
template <typename T>
inline void swap_rings(bound<T>& b1, bound<T>& b2) {
ring_ptr<T> ring = b1.ring;
b1.ring = b2.ring;
b2.ring = ring;
}
template <typename T>
inline void swap_sides(bound<T>& b1, bound<T>& b2) {
edge_side side = b1.side;
b1.side = b2.side;
b2.side = side;
}
template <typename T1, typename T2>
bool get_edge_intersection(edge<T1> const& e1,
edge<T1> const& e2,
mapbox::geometry::point<T2>& pt) {
T2 p0_x = static_cast<T2>(e1.bot.x);
T2 p0_y = static_cast<T2>(e1.bot.y);
T2 p1_x = static_cast<T2>(e1.top.x);
T2 p1_y = static_cast<T2>(e1.top.y);
T2 p2_x = static_cast<T2>(e2.bot.x);
T2 p2_y = static_cast<T2>(e2.bot.y);
T2 p3_x = static_cast<T2>(e2.top.x);
T2 p3_y = static_cast<T2>(e2.top.y);
T2 s1_x, s1_y, s2_x, s2_y;
s1_x = p1_x - p0_x;
s1_y = p1_y - p0_y;
s2_x = p3_x - p2_x;
s2_y = p3_y - p2_y;
T2 s, t;
s = (-s1_y * (p0_x - p2_x) + s1_x * (p0_y - p2_y)) / (-s2_x * s1_y + s1_x * s2_y);
t = (s2_x * (p0_y - p2_y) - s2_y * (p0_x - p2_x)) / (-s2_x * s1_y + s1_x * s2_y);
if (s >= 0.0 && s <= 1.0 && t >= 0.0 && t <= 1.0) {
pt.x = p0_x + (t * s1_x);
pt.y = p0_y + (t * s1_y);
return true;
}
return false;
}
template <typename T>
void build_intersect_list(active_bound_list<T>& active_bounds,
intersect_list<T>& intersects) {
// bubblesort ...
bool isModified = false;
do {
isModified = false;
auto bnd = active_bounds.begin();
auto bnd_next = std::next(bnd);
while (bnd_next != active_bounds.end()) {
if ((*bnd)->current_x > (*bnd_next)->current_x &&
!slopes_equal(*((*bnd)->current_edge), *((*bnd_next)->current_edge))) {
mapbox::geometry::point<double> pt;
if (!get_edge_intersection<T, double>(*((*bnd)->current_edge),
*((*bnd_next)->current_edge), pt)) {
throw std::runtime_error(
"Trying to find intersection of lines that do not intersect");
}
intersects.emplace_back(bnd, bnd_next, pt);
swap_positions_in_ABL(bnd, bnd_next, active_bounds);
bnd_next = std::next(bnd);
isModified = true;
} else {
bnd = bnd_next;
++bnd_next;
}
}
} while (isModified);
}
template <typename T>
void intersect_bounds(active_bound_list_itr<T>& b1,
active_bound_list_itr<T>& b2,
mapbox::geometry::point<T> const& pt,
clip_type cliptype,
fill_type subject_fill_type,
fill_type clip_fill_type,
ring_manager<T>& rings,
active_bound_list<T>& active_bounds) {
bool b1Contributing = ((*b1)->ring != nullptr);
bool b2Contributing = ((*b2)->ring != nullptr);
// if either bound is on an OPEN path ...
if ((*b1)->winding_delta == 0 || (*b2)->winding_delta == 0) {
// ignore subject-subject open path intersections UNLESS they
// are both open paths, AND they are both 'contributing maximas' ...
if ((*b1)->winding_delta == 0 && (*b2)->winding_delta == 0) {
return;
}
// if intersecting a subj line with a subj poly ...
else if ((*b1)->poly_type == (*b2)->poly_type &&
(*b1)->winding_delta != (*b2)->winding_delta && cliptype == clip_type_union) {
if ((*b1)->winding_delta == 0) {
if (b2Contributing) {
add_point(b1, active_bounds, pt, rings);
if (b1Contributing) {
(*b1)->ring = nullptr;
}
}
} else {
if (b1Contributing) {
add_point(b2, active_bounds, pt, rings);
if (b2Contributing) {
(*b2)->ring = nullptr;
}
}
}
} else if ((*b1)->poly_type != (*b2)->poly_type) {
// toggle subj open path index on/off when std::abs(clip.WndCnt) == 1
if (((*b1)->winding_delta == 0) && std::abs(static_cast<int>((*b2)->winding_count)) == 1 &&
(cliptype != clip_type_union || (*b2)->winding_count2 == 0)) {
add_point(b1, active_bounds, pt, rings);
if (b1Contributing) {
(*b1)->ring = nullptr;
}
} else if (((*b2)->winding_delta == 0) && (std::abs(static_cast<int>((*b1)->winding_count)) == 1) &&
(cliptype != clip_type_union || (*b1)->winding_count2 == 0)) {
add_point(b2, active_bounds, pt, rings);
if (b2Contributing) {
(*b2)->ring = nullptr;
}
}
}
return;
}
// update winding counts...
// assumes that b1 will be to the Right of b2 ABOVE the intersection
if ((*b1)->poly_type == (*b2)->poly_type) {
if (is_even_odd_fill_type(*(*b1), subject_fill_type, clip_fill_type)) {
std::int32_t oldE1winding_count = (*b1)->winding_count;
(*b1)->winding_count = (*b2)->winding_count;
(*b2)->winding_count = oldE1winding_count;
} else {
if ((*b1)->winding_count + (*b2)->winding_delta == 0) {
(*b1)->winding_count = -(*b1)->winding_count;
} else {
(*b1)->winding_count += (*b2)->winding_delta;
}
if ((*b2)->winding_count - (*b1)->winding_delta == 0) {
(*b2)->winding_count = -(*b2)->winding_count;
} else {
(*b2)->winding_count -= (*b1)->winding_delta;
}
}
} else {
if (!is_even_odd_fill_type(*(*b2), subject_fill_type, clip_fill_type)) {
(*b1)->winding_count2 += (*b2)->winding_delta;
} else {
(*b1)->winding_count2 = ((*b1)->winding_count2 == 0) ? 1 : 0;
}
if (!is_even_odd_fill_type(*(*b1), subject_fill_type, clip_fill_type)) {
(*b2)->winding_count2 -= (*b1)->winding_delta;
} else {
(*b2)->winding_count2 = ((*b2)->winding_count2 == 0) ? 1 : 0;
}
}
fill_type b1FillType, b2FillType, b1FillType2, b2FillType2;
if ((*b1)->poly_type == polygon_type_subject) {
b1FillType = subject_fill_type;
b1FillType2 = clip_fill_type;
} else {
b1FillType = clip_fill_type;
b1FillType2 = subject_fill_type;
}
if ((*b2)->poly_type == polygon_type_subject) {
b2FillType = subject_fill_type;
b2FillType2 = clip_fill_type;
} else {
b2FillType = clip_fill_type;
b2FillType2 = subject_fill_type;
}
std::int32_t b1Wc, b2Wc;
switch (b1FillType) {
case fill_type_positive:
b1Wc = (*b1)->winding_count;
break;
case fill_type_negative:
b1Wc = -(*b1)->winding_count;
break;
case fill_type_even_odd:
case fill_type_non_zero:
default:
b1Wc = std::abs(static_cast<int>((*b1)->winding_count));
}
switch (b2FillType) {
case fill_type_positive:
b2Wc = (*b2)->winding_count;
break;
case fill_type_negative:
b2Wc = -(*b2)->winding_count;
break;
case fill_type_even_odd:
case fill_type_non_zero:
default:
b2Wc = std::abs(static_cast<int>((*b2)->winding_count));
}
if (b1Contributing && b2Contributing) {
if ((b1Wc != 0 && b1Wc != 1) || (b2Wc != 0 && b2Wc != 1) ||
((*b1)->poly_type != (*b2)->poly_type && cliptype != clip_type_x_or)) {
add_local_maximum_point(b1, b2, pt, rings, active_bounds);
} else {
add_point(b1, active_bounds, pt, rings);
add_point(b2, active_bounds, pt, rings);
swap_sides(*(*b1), *(*b2));
swap_rings(*(*b1), *(*b2));
}
} else if (b1Contributing) {
if (b2Wc == 0 || b2Wc == 1) {
add_point(b1, active_bounds, pt, rings);
(*b2)->last_point = pt;
swap_sides(*(*b1), *(*b2));
swap_rings(*(*b1), *(*b2));
}
} else if (b2Contributing) {
if (b1Wc == 0 || b1Wc == 1) {
(*b1)->last_point = pt;
add_point(b2, active_bounds, pt, rings);
swap_sides(*(*b1), *(*b2));
swap_rings(*(*b1), *(*b2));
}
} else if ((b1Wc == 0 || b1Wc == 1) && (b2Wc == 0 || b2Wc == 1)) {
// neither bound is currently contributing ...
std::int32_t b1Wc2, b2Wc2;
switch (b1FillType2) {
case fill_type_positive:
b1Wc2 = (*b1)->winding_count2;
break;
case fill_type_negative:
b1Wc2 = -(*b1)->winding_count2;
break;
case fill_type_even_odd:
case fill_type_non_zero:
default:
b1Wc2 = std::abs(static_cast<int>((*b1)->winding_count2));
}
switch (b2FillType2) {
case fill_type_positive:
b2Wc2 = (*b2)->winding_count2;
break;
case fill_type_negative:
b2Wc2 = -(*b2)->winding_count2;
break;
case fill_type_even_odd:
case fill_type_non_zero:
default:
b2Wc2 = std::abs(static_cast<int>((*b2)->winding_count2));
}
if ((*b1)->poly_type != (*b2)->poly_type) {
add_local_minimum_point(b1, b2, active_bounds, pt, rings);
} else if (b1Wc == 1 && b2Wc == 1) {
switch (cliptype) {
case clip_type_intersection:
if (b1Wc2 > 0 && b2Wc2 > 0) {
add_local_minimum_point(b1, b2, active_bounds, pt, rings);
}
break;
default:
case clip_type_union:
if (b1Wc2 <= 0 && b2Wc2 <= 0) {
add_local_minimum_point(b1, b2, active_bounds, pt, rings);
}
break;
case clip_type_difference:
if ((((*b1)->poly_type == polygon_type_clip) && (b1Wc2 > 0) && (b2Wc2 > 0)) ||
(((*b1)->poly_type == polygon_type_subject) && (b1Wc2 <= 0) && (b2Wc2 <= 0))) {
add_local_minimum_point(b1, b2, active_bounds, pt, rings);
}
break;
case clip_type_x_or:
add_local_minimum_point(b1, b2, active_bounds, pt, rings);
}
} else {
swap_sides(*(*b1), *(*b2));
}
}
}
template <typename T>
bool bounds_adjacent(intersect_node<T> const& inode) {
return (std::next(inode.bound1) == inode.bound2) || (std::next(inode.bound2) == inode.bound1);
}
template <typename T>
void process_intersect_list(intersect_list<T>& intersects,
clip_type cliptype,
fill_type subject_fill_type,
fill_type clip_fill_type,
ring_manager<T>& rings,
active_bound_list<T>& active_bounds) {
for (auto node_itr = intersects.begin(); node_itr != intersects.end(); ++node_itr) {
if (!bounds_adjacent(*node_itr)) {
auto next_itr = std::next(node_itr);
while (next_itr != intersects.end() && !bounds_adjacent(*next_itr)) {
++next_itr;
}
if (next_itr == intersects.end()) {
throw std::runtime_error("Could not properly correct intersection order.");
}
std::iter_swap(node_itr, next_itr);
}
mapbox::geometry::point<T> pt = round_point<T>(node_itr->pt);
intersect_bounds(node_itr->bound1, node_itr->bound2, pt, cliptype, subject_fill_type,
clip_fill_type, rings, active_bounds);
swap_positions_in_ABL(node_itr->bound1, node_itr->bound2, active_bounds);
}
}
template <typename T>
void update_current_x(active_bound_list<T>& active_bounds, T top_y) {
std::size_t pos = 0;
for (auto & bnd : active_bounds) {
bnd->pos = pos++;
bnd->current_x = get_current_x(*bnd->current_edge, top_y);
}
}
template <typename T>
void process_intersections(T top_y,
active_bound_list<T>& active_bounds,
clip_type cliptype,
fill_type subject_fill_type,
fill_type clip_fill_type,
ring_manager<T>& rings) {
if (active_bounds.empty()) {
return;
}
update_current_x(active_bounds, top_y);
intersect_list<T> intersects;
build_intersect_list(active_bounds, intersects);
if (intersects.empty()) {
return;
}
// Restore order of active bounds list
active_bounds.sort([] (bound_ptr<T> const& b1, bound_ptr<T> const& b2) {
return b1->pos < b2->pos;
});
// Sort the intersection list
std::stable_sort(intersects.begin(), intersects.end(), intersect_list_sorter<T>());
process_intersect_list(intersects, cliptype, subject_fill_type, clip_fill_type, rings,
active_bounds);
}
}
}
}

118
mapbox/geometry/wagyu/local_minimum.hpp Normal file
View File

@ -0,0 +1,118 @@
#pragma once
#ifdef DEBUG
#include <iostream>
#include <sstream>
#endif
#include <queue>
#include <mapbox/geometry/wagyu/bound.hpp>
namespace mapbox {
namespace geometry {
namespace wagyu {
template <typename T>
struct local_minimum {
bound<T> left_bound;
bound<T> right_bound;
T y;
bool minimum_has_horizontal;
local_minimum(bound<T>&& left_bound_, bound<T>&& right_bound_, T y_, bool has_horz_)
: left_bound(std::move(left_bound_)),
right_bound(std::move(right_bound_)),
y(y_),
minimum_has_horizontal(has_horz_) {
}
};
template <typename T>
using local_minimum_list = std::deque<local_minimum<T>>;
template <typename T>
using local_minimum_itr = typename local_minimum_list<T>::iterator;
template <typename T>
using local_minimum_ptr = local_minimum<T>*;
template <typename T>
using local_minimum_ptr_list = std::vector<local_minimum_ptr<T>>;
template <typename T>
using local_minimum_ptr_list_itr = typename local_minimum_ptr_list<T>::iterator;
template <typename T>
struct local_minimum_sorter {
inline bool operator()(local_minimum_ptr<T> const& locMin1,
local_minimum_ptr<T> const& locMin2) {
if (locMin2->y == locMin1->y) {
return locMin2->minimum_has_horizontal != locMin1->minimum_has_horizontal &&
locMin1->minimum_has_horizontal;
}
return locMin2->y < locMin1->y;
}
};
#ifdef DEBUG
template <class charT, class traits, typename T>
inline std::basic_ostream<charT, traits>& operator<<(std::basic_ostream<charT, traits>& out,
const local_minimum<T>& lm) {
out << " Local Minimum:" << std::endl;
out << " y: " << lm.y << std::endl;
if (lm.minimum_has_horizontal) {
out << " minimum_has_horizontal: true" << std::endl;
} else {
out << " minimum_has_horizontal: false" << std::endl;
}
out << " left_bound: " << std::endl;
out << lm.left_bound << std::endl;
out << " right_bound: " << std::endl;
out << lm.right_bound << std::endl;
return out;
}
template <class charT, class traits, typename T>
inline std::basic_ostream<charT, traits>& operator<<(std::basic_ostream<charT, traits>& out,
const local_minimum_ptr_list<T>& lms) {
for (auto const& lm : lms) {
out << *lm;
}
return out;
}
template <typename T>
std::string output_all_edges(local_minimum_ptr_list<T> const& lms) {
std::ostringstream out;
out << "[";
bool first = true;
for (auto const& lm : lms) {
for (auto const& e : lm->left_bound.edges) {
if (first) {
first = false;
} else {
out << ",";
}
out << "[[" << e.bot.x << "," << e.bot.y << "],[";
out << e.top.x << "," << e.top.y << "]]";
}
for (auto const& e : lm->right_bound.edges) {
if (first) {
first = false;
} else {
out << ",";
}
out << "[[" << e.bot.x << "," << e.bot.y << "],[";
out << e.top.x << "," << e.top.y << "]]";
}
}
out << "]";
return out.str();
}
#endif
}
}
}

419
mapbox/geometry/wagyu/local_minimum_util.hpp Normal file
View File

@ -0,0 +1,419 @@
#pragma once
#include <mapbox/geometry/wagyu/edge.hpp>
#include <mapbox/geometry/wagyu/local_minimum.hpp>
#ifdef DEBUG
#include <mapbox/geometry/wagyu/exceptions.hpp>
#endif
namespace mapbox {
namespace geometry {
namespace wagyu {
template <typename T>
inline void reverse_horizontal(edge<T>& e) {
// swap horizontal edges' top and bottom x's so they follow the natural
// progression of the bounds - ie so their xbots will align with the
// adjoining lower edge. [Helpful in the process_horizontal() method.]
std::swap(e.top.x, e.bot.x);
}
// Make a list start on a local maximum by
// shifting all the points not on a local maximum to the
template <typename T>
void start_list_on_local_maximum(edge_list<T>& edges) {
if (edges.size() <= 2) {
return;
}
// Find the first local maximum going forward in the list
auto prev_edge = edges.end();
--prev_edge;
bool prev_edge_is_horizontal = is_horizontal(*prev_edge);
auto edge = edges.begin();
bool edge_is_horizontal;
bool y_decreasing_before_last_horizontal = false; // assume false at start
while (edge != edges.end()) {
edge_is_horizontal = is_horizontal(*edge);
if ((!prev_edge_is_horizontal && !edge_is_horizontal && edge->top == prev_edge->top)) {
break;
}
if (!edge_is_horizontal && prev_edge_is_horizontal) {
if (y_decreasing_before_last_horizontal &&
(edge->top == prev_edge->bot || edge->top == prev_edge->top)) {
break;
}
} else if (!y_decreasing_before_last_horizontal && !prev_edge_is_horizontal &&
edge_is_horizontal &&
(prev_edge->top == edge->top || prev_edge->top == edge->bot)) {
y_decreasing_before_last_horizontal = true;
}
prev_edge_is_horizontal = edge_is_horizontal;
prev_edge = edge;
++edge;
}
std::rotate(edges.begin(), edge, edges.end());
}
template <typename T>
bound<T> create_bound_towards_minimum(edge_list<T>& edges) {
if (edges.size() == 1) {
if (is_horizontal(edges.front())) {
reverse_horizontal(edges.front());
}
bound<T> bnd;
std::swap(bnd.edges, edges);
return bnd;
}
auto next_edge = edges.begin();
auto edge = next_edge;
++next_edge;
bool edge_is_horizontal = is_horizontal(*edge);
if (edge_is_horizontal) {
reverse_horizontal(*edge);
}
bool next_edge_is_horizontal;
bool y_increasing_before_last_horizontal = false; // assume false at start
while (next_edge != edges.end()) {
next_edge_is_horizontal = is_horizontal(*next_edge);
if ((!next_edge_is_horizontal && !edge_is_horizontal && edge->bot == next_edge->bot)) {
break;
}
if (!next_edge_is_horizontal && edge_is_horizontal) {
if (y_increasing_before_last_horizontal &&
(next_edge->bot == edge->bot || next_edge->bot == edge->top)) {
break;
}
} else if (!y_increasing_before_last_horizontal && !edge_is_horizontal &&
next_edge_is_horizontal &&
(edge->bot == next_edge->top || edge->bot == next_edge->bot)) {
y_increasing_before_last_horizontal = true;
}
edge_is_horizontal = next_edge_is_horizontal;
edge = next_edge;
if (edge_is_horizontal) {
reverse_horizontal(*edge);
}
++next_edge;
}
bound<T> bnd;
if (next_edge == edges.end()) {
std::swap(edges, bnd.edges);
} else {
bnd.edges.reserve(std::distance(edges.begin(), next_edge));
std::move(edges.begin(), next_edge, std::back_inserter(bnd.edges));
edges.erase(edges.begin(), next_edge);
}
std::reverse(bnd.edges.begin(), bnd.edges.end());
return bnd;
}
template <typename T>
bound<T> create_bound_towards_maximum(edge_list<T>& edges) {
if (edges.size() == 1) {
bound<T> bnd;
std::swap(bnd.edges, edges);
return bnd;
}
auto next_edge = edges.begin();
auto edge = next_edge;
++next_edge;
bool edge_is_horizontal = is_horizontal(*edge);
bool next_edge_is_horizontal;
bool y_decreasing_before_last_horizontal = false; // assume false at start
while (next_edge != edges.end()) {
next_edge_is_horizontal = is_horizontal(*next_edge);
if ((!next_edge_is_horizontal && !edge_is_horizontal && edge->top == next_edge->top)) {
break;
}
if (!next_edge_is_horizontal && edge_is_horizontal) {
if (y_decreasing_before_last_horizontal &&
(next_edge->top == edge->bot || next_edge->top == edge->top)) {
break;
}
} else if (!y_decreasing_before_last_horizontal && !edge_is_horizontal &&
next_edge_is_horizontal &&
(edge->top == next_edge->top || edge->top == next_edge->bot)) {
y_decreasing_before_last_horizontal = true;
}
edge_is_horizontal = next_edge_is_horizontal;
edge = next_edge;
++next_edge;
}
bound<T> bnd;
if (next_edge == edges.end()) {
std::swap(bnd.edges, edges);
} else {
bnd.edges.reserve(std::distance(edges.begin(), next_edge));
std::move(edges.begin(), next_edge, std::back_inserter(bnd.edges));
edges.erase(edges.begin(), next_edge);
}
return bnd;
}
template <typename T>
void fix_horizontals(bound<T>& bnd) {
auto edge_itr = bnd.edges.begin();
auto next_itr = std::next(edge_itr);
if (next_itr == bnd.edges.end()) {
return;
}
if (is_horizontal(*edge_itr) && next_itr->bot != edge_itr->top) {
reverse_horizontal(*edge_itr);
}
auto prev_itr = edge_itr++;
while (edge_itr != bnd.edges.end()) {
if (is_horizontal(*edge_itr) && prev_itr->top != edge_itr->bot) {
reverse_horizontal(*edge_itr);
}
prev_itr = edge_itr;
++edge_itr;
}
}
template <typename T>
void move_horizontals_on_left_to_right(bound<T>& left_bound, bound<T>& right_bound) {
// We want all the horizontal segments that are at the same Y as the minimum to be on the right
// bound
auto edge_itr = left_bound.edges.begin();
while (edge_itr != left_bound.edges.end()) {
if (!is_horizontal(*edge_itr)) {
break;
}
reverse_horizontal(*edge_itr);
++edge_itr;
}
if (edge_itr == left_bound.edges.begin()) {
return;
}
std::reverse(left_bound.edges.begin(), edge_itr);
auto dist = std::distance(left_bound.edges.begin(), edge_itr);
std::move(left_bound.edges.begin(), edge_itr, std::back_inserter(right_bound.edges));
left_bound.edges.erase(left_bound.edges.begin(), edge_itr);
std::rotate(right_bound.edges.begin(), std::prev(right_bound.edges.end(), dist), right_bound.edges.end());
}
template <typename T>
void add_line_to_local_minima_list(edge_list<T>& edges, local_minimum_list<T>& minima_list) {
if (edges.empty()) {
return;
}
// Adjust the order of the ring so we start on a local maximum
// therefore we start right away on a bound.
start_list_on_local_maximum(edges);
bound_ptr<T> last_maximum = nullptr;
while (!edges.empty()) {
bool lm_minimum_has_horizontal = false;
auto to_minimum = create_bound_towards_minimum(edges);
assert(!to_minimum.edges.empty());
fix_horizontals(to_minimum);
to_minimum.poly_type = polygon_type_subject;
to_minimum.maximum_bound = last_maximum;
to_minimum.winding_delta = 0;
auto to_min_first_non_horizontal = to_minimum.edges.begin();
while (to_min_first_non_horizontal != to_minimum.edges.end() &&
is_horizontal(*to_min_first_non_horizontal)) {
lm_minimum_has_horizontal = true;
++to_min_first_non_horizontal;
}
if (edges.empty()) {
if (to_min_first_non_horizontal != to_minimum.edges.end() &&
to_min_first_non_horizontal->dx > 0.0) {
to_minimum.side = edge_left;
bound<T> right_bound;
right_bound.winding_delta = 0;
right_bound.side = edge_right;
right_bound.poly_type = polygon_type_subject;
move_horizontals_on_left_to_right(to_minimum, right_bound);
auto const& min_front = to_minimum.edges.front();
minima_list.emplace_back(std::move(to_minimum), std::move(right_bound), min_front.y,
lm_minimum_has_horizontal);
if (last_maximum) {
last_maximum->maximum_bound = &(minima_list.back().left_bound);
last_maximum = nullptr;
}
} else {
to_minimum.side = edge_right;
bound<T> left_bound;
left_bound.winding_delta = 0;
left_bound.side = edge_left;
left_bound.poly_type = polygon_type_subject;
auto const& min_front = to_minimum.edges.front();
minima_list.emplace_back(std::move(left_bound), std::move(to_minimum), min_front.y);
if (last_maximum) {
last_maximum->maximum_bound = &(minima_list.back().right_bound);
last_maximum = nullptr;
}
}
break;
}
bool minimum_is_left = true;
auto to_maximum = create_bound_towards_maximum(edges);
assert(!to_maximum.edges.empty());
fix_horizontals(to_maximum);
auto to_max_first_non_horizontal = to_minimum.edges.begin();
while (to_max_first_non_horizontal != to_maximum.edges.end() &&
is_horizontal(*to_max_first_non_horizontal)) {
lm_minimum_has_horizontal = true;
++to_max_first_non_horizontal;
}
if (to_max_first_non_horizontal != to_maximum.edges.end() &&
(to_min_first_non_horizontal == to_minimum.edges.end() ||
to_max_first_non_horizontal->dx > to_min_first_non_horizontal->dx)) {
minimum_is_left = false;
move_horizontals_on_left_to_right(to_maximum, to_minimum);
} else {
minimum_is_left = true;
move_horizontals_on_left_to_right(to_minimum, to_maximum);
}
auto const& min_front = to_minimum.edges.front();
to_maximum.poly_type = polygon_type_subject;
to_maximum.winding_delta = 0;
if (!minimum_is_left) {
to_minimum.side = edge_right;
to_maximum.side = edge_left;
minima_list.emplace_back(std::move(to_maximum), std::move(to_minimum), min_front.bot.y,
lm_minimum_has_horizontal);
if (last_maximum) {
last_maximum->maximum_bound = &(minima_list.back().right_bound);
}
last_maximum = &(minima_list.back().left_bound);
} else {
to_minimum.side = edge_left;
to_maximum.side = edge_right;
minima_list.emplace_back(std::move(to_minimum), std::move(to_maximum), min_front.bot.y,
lm_minimum_has_horizontal);
if (last_maximum) {
last_maximum->maximum_bound = &(minima_list.back().left_bound);
}
last_maximum = &(minima_list.back().right_bound);
}
}
}
template <typename T>
void add_ring_to_local_minima_list(edge_list<T>& edges,
local_minimum_list<T>& minima_list,
polygon_type poly_type) {
if (edges.empty()) {
return;
}
// Adjust the order of the ring so we start on a local maximum
// therefore we start right away on a bound.
start_list_on_local_maximum(edges);
bound_ptr<T> first_minimum = nullptr;
bound_ptr<T> last_maximum = nullptr;
while (!edges.empty()) {
bool lm_minimum_has_horizontal = false;
auto to_minimum = create_bound_towards_minimum(edges);
if (edges.empty()) {
throw std::runtime_error("Edges is empty after only creating a single bound.");
}
auto to_maximum = create_bound_towards_maximum(edges);
fix_horizontals(to_minimum);
fix_horizontals(to_maximum);
auto to_max_first_non_horizontal = to_maximum.edges.begin();
auto to_min_first_non_horizontal = to_minimum.edges.begin();
bool minimum_is_left = true;
while (to_max_first_non_horizontal != to_maximum.edges.end() &&
is_horizontal(*to_max_first_non_horizontal)) {
lm_minimum_has_horizontal = true;
++to_max_first_non_horizontal;
}
while (to_min_first_non_horizontal != to_minimum.edges.end() &&
is_horizontal(*to_min_first_non_horizontal)) {
lm_minimum_has_horizontal = true;
++to_min_first_non_horizontal;
}
#ifdef DEBUG
if (to_max_first_non_horizontal == to_maximum.edges.end() ||
to_min_first_non_horizontal == to_minimum.edges.end()) {
throw clipper_exception("should not have a horizontal only bound for a ring");
}
#endif
if (lm_minimum_has_horizontal) {
if (to_max_first_non_horizontal->bot.x > to_min_first_non_horizontal->bot.x) {
minimum_is_left = true;
move_horizontals_on_left_to_right(to_minimum, to_maximum);
} else {
minimum_is_left = false;
move_horizontals_on_left_to_right(to_maximum, to_minimum);
}
} else {
if (to_max_first_non_horizontal->dx > to_min_first_non_horizontal->dx) {
minimum_is_left = false;
} else {
minimum_is_left = true;
}
}
assert(!to_minimum.edges.empty());
assert(!to_maximum.edges.empty());
auto const& min_front = to_minimum.edges.front();
if (last_maximum) {
to_minimum.maximum_bound = last_maximum;
}
to_minimum.poly_type = poly_type;
to_maximum.poly_type = poly_type;
if (!minimum_is_left) {
to_minimum.side = edge_right;
to_maximum.side = edge_left;
to_minimum.winding_delta = -1;
to_maximum.winding_delta = 1;
minima_list.emplace_back(std::move(to_maximum), std::move(to_minimum), min_front.bot.y,
lm_minimum_has_horizontal);
if (!last_maximum) {
first_minimum = &(minima_list.back().right_bound);
} else {
last_maximum->maximum_bound = &(minima_list.back().right_bound);
}
last_maximum = &(minima_list.back().left_bound);
} else {
to_minimum.side = edge_left;
to_maximum.side = edge_right;
to_minimum.winding_delta = -1;
to_maximum.winding_delta = 1;
minima_list.emplace_back(std::move(to_minimum), std::move(to_maximum), min_front.bot.y,
lm_minimum_has_horizontal);
if (!last_maximum) {
first_minimum = &(minima_list.back().left_bound);
} else {
last_maximum->maximum_bound = &(minima_list.back().left_bound);
}
last_maximum = &(minima_list.back().right_bound);
}
}
last_maximum->maximum_bound = first_minimum;
first_minimum->maximum_bound = last_maximum;
}
template <typename T>
void initialize_lm(local_minimum_ptr_list_itr<T>& lm) {
if (!(*lm)->left_bound.edges.empty()) {
(*lm)->left_bound.current_edge = (*lm)->left_bound.edges.begin();
(*lm)->left_bound.next_edge = std::next((*lm)->left_bound.current_edge);
(*lm)->left_bound.current_x = static_cast<double>((*lm)->left_bound.current_edge->bot.x);
(*lm)->left_bound.winding_count = 0;
(*lm)->left_bound.winding_count2 = 0;
(*lm)->left_bound.side = edge_left;
(*lm)->left_bound.ring = nullptr;
}
if (!(*lm)->right_bound.edges.empty()) {
(*lm)->right_bound.current_edge = (*lm)->right_bound.edges.begin();
(*lm)->right_bound.next_edge = std::next((*lm)->right_bound.current_edge);
(*lm)->right_bound.current_x = static_cast<double>((*lm)->right_bound.current_edge->bot.x);
(*lm)->right_bound.winding_count = 0;
(*lm)->right_bound.winding_count2 = 0;
(*lm)->right_bound.side = edge_right;
(*lm)->right_bound.ring = nullptr;
}
}
}
}
}

110
mapbox/geometry/wagyu/point.hpp Normal file
View File

@ -0,0 +1,110 @@
#pragma once
#include <mapbox/geometry/point.hpp>
#ifdef DEBUG
#include <iostream>
#endif
namespace mapbox {
namespace geometry {
namespace wagyu {
template <typename T>
struct point;
template <typename T>
using point_ptr = point<T>*;
template <typename T>
using const_point_ptr = point<T>* const;
template <typename T>
struct ring;
template <typename T>
using ring_ptr = ring<T>*;
template <typename T>
using const_ring_ptr = ring<T>* const;
template <typename T>
struct point {
using coordinate_type = T;
ring_ptr<T> ring;
T x;
T y;
point_ptr<T> next;
point_ptr<T> prev;
point(point<T> && p)
: ring(std::move(p.ring)),
x(std::move(p.x)),
y(std::move(p.y)),
next(std::move(p.next)),
prev(std::move(p.prev)) { }
point() : ring(nullptr), x(0), y(0), prev(this), next(this) {
}
point(T x_, T y_) : ring(nullptr), x(x_), y(y_), next(this), prev(this) {
}
point(ring_ptr<T> ring_, mapbox::geometry::point<T> const& pt)
: ring(ring_), x(pt.x), y(pt.y), next(this), prev(this) {
}
point(ring_ptr<T> ring_, mapbox::geometry::point<T> const& pt, point_ptr<T> before_this_point)
: ring(ring_), x(pt.x), y(pt.y), next(before_this_point), prev(before_this_point->prev) {
before_this_point->prev = this;
prev->next = this;
}
};
template <typename T>
bool operator==(point<T> const& lhs, point<T> const& rhs) {
return lhs.x == rhs.x && lhs.y == rhs.y;
}
template <typename T>
bool operator==(mapbox::geometry::point<T> const& lhs, point<T> const& rhs) {
return lhs.x == rhs.x && lhs.y == rhs.y;
}
template <typename T>
bool operator==(point<T> const& lhs, mapbox::geometry::point<T> const& rhs) {
return lhs.x == rhs.x && lhs.y == rhs.y;
}
template <typename T>
bool operator!=(point<T> const& lhs, point<T> const& rhs) {
return lhs.x != rhs.x || lhs.y != rhs.y;
}
template <typename T>
bool operator!=(mapbox::geometry::point<T> const& lhs, point<T> const& rhs) {
return lhs.x != rhs.x || lhs.y != rhs.y;
}
template <typename T>
bool operator!=(point<T> const& lhs, mapbox::geometry::point<T> const& rhs) {
return lhs.x != rhs.x || lhs.y != rhs.y;
}
#ifdef DEBUG
template <class charT, class traits, typename T>
inline std::basic_ostream<charT, traits>& operator<<(std::basic_ostream<charT, traits>& out,
const point<T>& p) {
out << " point at: " << p.x << ", " << p.y;
return out;
}
template <class charT, class traits, typename T>
inline std::basic_ostream<charT, traits>& operator<<(std::basic_ostream<charT, traits>& out,
const mapbox::geometry::point<T>& p) {
out << " point at: " << p.x << ", " << p.y;
return out;
}
#endif
}
}
}

285
mapbox/geometry/wagyu/process_horizontal.hpp Normal file
View File

@ -0,0 +1,285 @@
#pragma once
#include <mapbox/geometry/line_string.hpp>
#include <mapbox/geometry/point.hpp>
#include <mapbox/geometry/polygon.hpp>
#include <mapbox/geometry/wagyu/config.hpp>
#include <mapbox/geometry/wagyu/edge.hpp>
#include <mapbox/geometry/wagyu/exceptions.hpp>
#include <mapbox/geometry/wagyu/local_minimum.hpp>
#include <mapbox/geometry/wagyu/util.hpp>
namespace mapbox {
namespace geometry {
namespace wagyu {
template <typename T>
active_bound_list_itr<T> process_horizontal_left_to_right(T scanline_y,
active_bound_list_itr<T>& horz_bound,
active_bound_list<T>& active_bounds,
ring_manager<T>& rings,
scanbeam_list<T>& scanbeam,
clip_type cliptype,
fill_type subject_fill_type,
fill_type clip_fill_type) {
auto horizontal_itr_behind = horz_bound;
bool is_open = (*horz_bound)->winding_delta == 0;
bool is_maxima_edge = is_maxima(horz_bound, scanline_y);
auto bound_max_pair = active_bounds.end();
if (is_maxima_edge) {
bound_max_pair = get_maxima_pair<T>(horz_bound, active_bounds);
}
auto hp_itr = rings.current_hp_itr;
while (hp_itr != rings.hot_pixels.end() && (hp_itr->y > scanline_y || (hp_itr->y == scanline_y && hp_itr->x < (*horz_bound)->current_edge->bot.x))) {
++hp_itr;
}
auto bnd = std::next(horz_bound);
while (bnd != active_bounds.end()) {
// this code block inserts extra coords into horizontal edges (in output
// polygons) wherever hot pixels touch these horizontal edges. This helps
//'simplifying' polygons (ie if the Simplify property is set).
while (hp_itr != rings.hot_pixels.end() && hp_itr->y == scanline_y && hp_itr->x < std::llround((*bnd)->current_x) &&
hp_itr->x < (*horz_bound)->current_edge->top.x) {
if ((*horz_bound)->ring && !is_open) {
add_point_to_ring(*(*horz_bound), *hp_itr, rings);
}
++hp_itr;
}
if ((*bnd)->current_x > static_cast<double>((*horz_bound)->current_edge->top.x)) {
break;
}
// Also break if we've got to the end of an intermediate horizontal edge ...
// nb: Smaller Dx's are to the right of larger Dx's ABOVE the horizontal.
if (std::llround((*bnd)->current_x) == (*horz_bound)->current_edge->top.x &&
(*horz_bound)->next_edge != (*horz_bound)->edges.end() &&
(*horz_bound)->current_edge->dx < (*horz_bound)->next_edge->dx) {
break;
}
// note: may be done multiple times
if ((*horz_bound)->ring && !is_open) {
add_point_to_ring(*(*horz_bound),
mapbox::geometry::point<T>(std::llround((*bnd)->current_x),
scanline_y),
rings);
}
// OK, so far we're still in range of the horizontal Edge but make sure
// we're at the last of consec. horizontals when matching with eMaxPair
if (is_maxima_edge && bnd == bound_max_pair) {
if ((*horz_bound)->ring) {
add_local_maximum_point(horz_bound, bound_max_pair,
(*horz_bound)->current_edge->top, rings, active_bounds);
}
active_bounds.erase(bound_max_pair);
auto after_horz = active_bounds.erase(horz_bound);
if (horizontal_itr_behind != horz_bound) {
return horizontal_itr_behind;
} else {
return after_horz;
}
}
intersect_bounds(horz_bound, bnd,
mapbox::geometry::point<T>(std::llround((*bnd)->current_x),
scanline_y),
cliptype, subject_fill_type, clip_fill_type, rings, active_bounds);
auto next_bnd = std::next(bnd);
swap_positions_in_ABL(horz_bound, bnd, active_bounds);
if (current_edge_is_horizontal<T>(bnd) && horizontal_itr_behind == horz_bound) {
horizontal_itr_behind = bnd;
}
bnd = next_bnd;
} // end while (bnd != active_bounds.end())
if ((*horz_bound)->ring && !is_open) {
while (hp_itr != rings.hot_pixels.end() && hp_itr->y == scanline_y &&
hp_itr->x < std::llround((*horz_bound)->current_edge->top.x)) {
add_point_to_ring(*(*horz_bound), *hp_itr, rings);
++hp_itr;
}
}
if ((*horz_bound)->next_edge != (*horz_bound)->edges.end()) {
if ((*horz_bound)->ring) {
add_point_to_ring(*(*horz_bound), (*horz_bound)->current_edge->top, rings);
next_edge_in_bound(horz_bound, scanbeam);
if ((*horz_bound)->winding_delta == 0) {
if (horizontal_itr_behind != horz_bound) {
return horizontal_itr_behind;
} else {
return std::next(horz_bound);
}
}
} else {
next_edge_in_bound(horz_bound, scanbeam);
}
if (horizontal_itr_behind != horz_bound) {
return horizontal_itr_behind;
} else {
return std::next(horz_bound);
}
} else {
if ((*horz_bound)->ring) {
add_point_to_ring(*(*horz_bound), (*horz_bound)->current_edge->top, rings);
}
auto after_horz = active_bounds.erase(horz_bound);
if (horizontal_itr_behind != horz_bound) {
return horizontal_itr_behind;
} else {
return after_horz;
}
}
}
template <typename T>
active_bound_list_itr<T> process_horizontal_right_to_left(T scanline_y,
active_bound_list_itr<T>& horz_bound,
active_bound_list<T>& active_bounds,
ring_manager<T>& rings,
scanbeam_list<T>& scanbeam,
clip_type cliptype,
fill_type subject_fill_type,
fill_type clip_fill_type) {
bool is_open = (*horz_bound)->winding_delta == 0;
bool is_maxima_edge = is_maxima(horz_bound, scanline_y);
auto bound_max_pair = active_bounds.end();
if (is_maxima_edge) {
bound_max_pair = get_maxima_pair<T>(horz_bound, active_bounds);
}
auto hp_itr_fwd = rings.current_hp_itr;
while (hp_itr_fwd != rings.hot_pixels.end() && (hp_itr_fwd->y < scanline_y || (hp_itr_fwd->y == scanline_y && hp_itr_fwd->x < (*horz_bound)->current_edge->top.x))) {
++hp_itr_fwd;
}
auto hp_itr = hot_pixel_rev_itr<T>(hp_itr_fwd);
auto bnd = active_bound_list_rev_itr<T>(horz_bound);
while (bnd != active_bounds.rend()) {
// this code block inserts extra coords into horizontal edges (in output
// polygons) wherever hot pixels touch these horizontal edges.
while (hp_itr != rings.hot_pixels.rend() && hp_itr->y == scanline_y && hp_itr->x > std::llround((*bnd)->current_x) &&
hp_itr->x > (*horz_bound)->current_edge->top.x) {
if ((*horz_bound)->ring && !is_open) {
add_point_to_ring(*(*horz_bound), *hp_itr, rings);
}
++hp_itr;
}
if ((*bnd)->current_x < static_cast<double>((*horz_bound)->current_edge->top.x)) {
break;
}
// Also break if we've got to the end of an intermediate horizontal edge ...
// nb: Smaller Dx's are to the right of larger Dx's ABOVE the horizontal.
if (std::llround((*bnd)->current_x) == (*horz_bound)->current_edge->top.x &&
(*horz_bound)->next_edge != (*horz_bound)->edges.end() &&
(*horz_bound)->current_edge->dx < (*horz_bound)->next_edge->dx) {
break;
}
// note: may be done multiple times
if ((*horz_bound)->ring && !is_open) {
add_point_to_ring(*(*horz_bound),
mapbox::geometry::point<T>(std::llround((*bnd)->current_x),
scanline_y),
rings);
}
auto bnd_forward = --(bnd.base());
// OK, so far we're still in range of the horizontal Edge but make sure
// we're at the last of consec. horizontals when matching with eMaxPair
if (is_maxima_edge && bnd_forward == bound_max_pair) {
if ((*horz_bound)->ring) {
add_local_maximum_point(horz_bound, bound_max_pair,
(*horz_bound)->current_edge->top, rings, active_bounds);
}
active_bounds.erase(bound_max_pair);
return active_bounds.erase(horz_bound);
}
intersect_bounds(bnd_forward, horz_bound,
mapbox::geometry::point<T>(std::llround((*bnd)->current_x),
scanline_y),
cliptype, subject_fill_type, clip_fill_type, rings, active_bounds);
swap_positions_in_ABL(horz_bound, bnd_forward, active_bounds);
// Why are we not incrementing the bnd iterator here:
// It is because reverse iterators point to a `base()` iterator that is a forward
// iterator that is one ahead of the reverse bound. This will always be the horizontal
// bound,
// so what the reverse bound points to will have changed.
} // end while (bnd != active_bounds.rend())
if ((*horz_bound)->ring && !is_open) {
while (hp_itr != rings.hot_pixels.rend() && hp_itr->y == scanline_y && hp_itr->x > (*horz_bound)->current_edge->top.x) {
add_point_to_ring(*(*horz_bound), *hp_itr, rings);
++hp_itr;
}
}
if ((*horz_bound)->next_edge != (*horz_bound)->edges.end()) {
if ((*horz_bound)->ring) {
add_point_to_ring(*(*horz_bound), (*horz_bound)->current_edge->top, rings);
next_edge_in_bound(horz_bound, scanbeam);
if ((*horz_bound)->winding_delta == 0) {
return std::next(horz_bound);
}
} else {
next_edge_in_bound(horz_bound, scanbeam);
}
return std::next(horz_bound);
} else {
if ((*horz_bound)->ring) {
add_point_to_ring(*(*horz_bound), (*horz_bound)->current_edge->top, rings);
}
return active_bounds.erase(horz_bound);
}
}
template <typename T>
active_bound_list_itr<T> process_horizontal(T scanline_y,
active_bound_list_itr<T>& horz_bound,
active_bound_list<T>& active_bounds,
ring_manager<T>& rings,
scanbeam_list<T>& scanbeam,
clip_type cliptype,
fill_type subject_fill_type,
fill_type clip_fill_type) {
if ((*horz_bound)->current_edge->bot.x < (*horz_bound)->current_edge->top.x) {
return process_horizontal_left_to_right(scanline_y, horz_bound, active_bounds, rings,
scanbeam, cliptype, subject_fill_type,
clip_fill_type);
} else {
return process_horizontal_right_to_left(scanline_y, horz_bound, active_bounds, rings,
scanbeam, cliptype, subject_fill_type,
clip_fill_type);
}
}
template <typename T>
void process_horizontals(T scanline_y,
active_bound_list<T>& active_bounds,
ring_manager<T>& rings,
scanbeam_list<T>& scanbeam,
clip_type cliptype,
fill_type subject_fill_type,
fill_type clip_fill_type) {
for (auto bnd_itr = active_bounds.begin(); bnd_itr != active_bounds.end();) {
if (current_edge_is_horizontal<T>(bnd_itr)) {
bnd_itr = process_horizontal(scanline_y, bnd_itr, active_bounds, rings, scanbeam,
cliptype, subject_fill_type, clip_fill_type);
} else {
++bnd_itr;
}
}
}
}
}
}

133
mapbox/geometry/wagyu/process_maxima.hpp Normal file
View File

@ -0,0 +1,133 @@
#pragma once
#include <mapbox/geometry/wagyu/active_bound_list.hpp>
#include <mapbox/geometry/wagyu/config.hpp>
#include <mapbox/geometry/wagyu/edge.hpp>
#include <mapbox/geometry/wagyu/exceptions.hpp>
#include <mapbox/geometry/wagyu/intersect_util.hpp>
#include <mapbox/geometry/wagyu/local_minimum.hpp>
#include <mapbox/geometry/wagyu/local_minimum_util.hpp>
#include <mapbox/geometry/wagyu/process_horizontal.hpp>
#include <mapbox/geometry/wagyu/ring.hpp>
#include <mapbox/geometry/wagyu/ring_util.hpp>
#include <mapbox/geometry/wagyu/topology_correction.hpp>
#include <mapbox/geometry/wagyu/util.hpp>
namespace mapbox {
namespace geometry {
namespace wagyu {
template <typename T>
active_bound_list_itr<T> do_maxima(active_bound_list_itr<T>& bnd,
active_bound_list_itr<T>& bndMaxPair,
clip_type cliptype,
fill_type subject_fill_type,
fill_type clip_fill_type,
ring_manager<T>& rings,
active_bound_list<T>& active_bounds) {
if (bndMaxPair == active_bounds.end()) {
if ((*bnd)->ring) {
add_point_to_ring(*(*bnd), (*bnd)->current_edge->top, rings);
}
return active_bounds.erase(bnd);
}
auto bnd_next = std::next(bnd);
auto return_bnd = bnd_next;
bool skipped = false;
while (bnd_next != active_bounds.end() && bnd_next != bndMaxPair) {
skipped = true;
intersect_bounds(bnd, bnd_next, (*bnd)->current_edge->top, cliptype, subject_fill_type,
clip_fill_type, rings, active_bounds);
swap_positions_in_ABL(bnd, bnd_next, active_bounds);
bnd_next = std::next(bnd);
}
if (!(*bnd)->ring && !(*bndMaxPair)->ring) {
active_bounds.erase(bndMaxPair);
} else if ((*bnd)->ring && (*bndMaxPair)->ring) {
add_local_maximum_point(bnd, bndMaxPair, (*bnd)->current_edge->top, rings, active_bounds);
active_bounds.erase(bndMaxPair);
} else if ((*bnd)->winding_delta == 0 && (*bnd)->ring) {
add_point_to_ring(*(*bnd), (*bnd)->current_edge->top, rings);
active_bounds.erase(bndMaxPair);
} else if ((*bnd)->winding_delta == 0 && (*bndMaxPair)->ring) {
add_point_to_ring(*(*bndMaxPair), (*bnd)->current_edge->top, rings);
active_bounds.erase(bndMaxPair);
} else {
throw clipper_exception("DoMaxima error");
}
auto prev_itr = active_bounds.erase(bnd);
if (skipped) {
return return_bnd;
} else {
return prev_itr;
}
}
template <typename T>
void process_edges_at_top_of_scanbeam(T top_y,
active_bound_list<T>& active_bounds,
scanbeam_list<T>& scanbeam,
local_minimum_ptr_list<T> const& minima_sorted,
local_minimum_ptr_list_itr<T>& current_lm,
ring_manager<T>& rings,
clip_type cliptype,
fill_type subject_fill_type,
fill_type clip_fill_type) {
for (auto bnd = active_bounds.begin(); bnd != active_bounds.end();) {
// 1. Process maxima, treating them as if they are "bent" horizontal edges,
// but exclude maxima with horizontal edges.
bool is_maxima_edge = is_maxima(bnd, top_y);
if (is_maxima_edge) {
auto bnd_max_pair = get_maxima_pair(bnd, active_bounds);
is_maxima_edge = ((bnd_max_pair == active_bounds.end() ||
!current_edge_is_horizontal<T>(bnd_max_pair)) &&
is_maxima(bnd_max_pair, top_y));
if (is_maxima_edge) {
bnd = do_maxima(bnd, bnd_max_pair, cliptype, subject_fill_type, clip_fill_type, rings,
active_bounds);
continue;
}
}
// 2. Promote horizontal edges.
if (is_intermediate(bnd, top_y) && next_edge_is_horizontal<T>(bnd)) {
if ((*bnd)->ring) {
insert_hot_pixels_in_path(*(*bnd), (*bnd)->current_edge->top, rings, false);
}
next_edge_in_bound(bnd, scanbeam);
if ((*bnd)->ring) {
add_point_to_ring(*(*bnd), (*bnd)->current_edge->bot, rings);
}
} else {
(*bnd)->current_x = get_current_x(*((*bnd)->current_edge), top_y);
}
++bnd;
}
insert_horizontal_local_minima_into_ABL(top_y, minima_sorted, current_lm, active_bounds, rings,
scanbeam, cliptype, subject_fill_type, clip_fill_type);
process_horizontals(top_y, active_bounds, rings, scanbeam, cliptype, subject_fill_type,
clip_fill_type);
// 4. Promote intermediate vertices
for (auto bnd = active_bounds.begin(); bnd != active_bounds.end(); ++bnd) {
if (is_intermediate(bnd, top_y)) {
if ((*bnd)->ring) {
add_point_to_ring(*(*bnd), (*bnd)->current_edge->top, rings);
insert_hot_pixels_in_path(*(*bnd), (*bnd)->current_edge->top, rings, false);
}
next_edge_in_bound(bnd, scanbeam);
}
}
}
}
}
}

480
mapbox/geometry/wagyu/ring.hpp Normal file
View File

@ -0,0 +1,480 @@
#pragma once
#include <assert.h>
#include <cmath>
#include <list>
#include <map>
#include <set>
#include <sstream>
#include <vector>
#include <deque>
#include <mapbox/geometry/wagyu/point.hpp>
#ifdef DEBUG
#include <execinfo.h>
#include <iostream>
#include <sstream>
#include <stdio.h>
//
// void* callstack[128];
// int i, frames = backtrace(callstack, 128);
// char** strs = backtrace_symbols(callstack, frames);
// for (i = 0; i < frames; ++i) {
// printf("%s\n", strs[i]);
// }
// free(strs);
#endif
namespace mapbox {
namespace geometry {
namespace wagyu {
// NOTE: ring and ring_ptr are forward declared in wagyu/point.hpp
template <typename T>
using ring_vector = std::vector<ring_ptr<T>>;
template <typename T>
using ring_list = std::list<ring_ptr<T>>;
template <typename T>
struct ring {
std::size_t ring_index; // To support unset 0 is undefined and indexes offset by 1
std::size_t size;
double area;
ring_ptr<T> parent;
ring_list<T> children;
point_ptr<T> points;
point_ptr<T> bottom_point;
bool is_open;
ring( ring const& ) = delete;
ring& operator=(ring const& ) = delete;
ring()
: ring_index(0),
size(0),
area(std::numeric_limits<double>::quiet_NaN()),
parent(nullptr),
children(),
points(nullptr),
bottom_point(nullptr),
is_open(false) {
}
};
template <typename T>
using hot_pixel_vector = std::vector<mapbox::geometry::point<T>>;
template <typename T>
using hot_pixel_itr = typename hot_pixel_vector<T>::iterator;
template <typename T>
using hot_pixel_rev_itr = typename hot_pixel_vector<T>::reverse_iterator;
template <typename T>
struct ring_manager {
ring_list<T> children;
std::vector<point_ptr<T>> all_points;
hot_pixel_vector<T> hot_pixels;
hot_pixel_itr<T> current_hp_itr;
std::deque<point<T>> points;
std::deque<ring<T>> rings;
std::vector<point<T>> storage;
std::size_t index;
ring_manager( ring_manager const& ) = delete;
ring_manager& operator=(ring_manager const& ) = delete;
ring_manager()
: children(),
all_points(),
hot_pixels(),
current_hp_itr(hot_pixels.end()),
points(),
rings(),
storage(),
index(0) {
}
};
template <typename T>
void preallocate_point_memory(ring_manager<T>& rings, std::size_t size) {
rings.storage.reserve(size);
rings.all_points.reserve(size);
}
template <typename T>
ring_ptr<T> create_new_ring(ring_manager<T>& rings) {
rings.rings.emplace_back();
ring_ptr<T> result = &rings.rings.back();
result->ring_index = rings.index++;
return result;
}
template <typename T>
point_ptr<T>
create_new_point(ring_ptr<T> r, mapbox::geometry::point<T> const& pt, ring_manager<T>& rings) {
point_ptr<T> point;
if (rings.storage.size() < rings.storage.capacity()) {
rings.storage.emplace_back(r, pt);
point = &rings.storage.back();
} else {
rings.points.emplace_back(r, pt);
point = &rings.points.back();
}
rings.all_points.push_back(point);
return point;
}
template <typename T>
point_ptr<T> create_new_point(ring_ptr<T> r,
mapbox::geometry::point<T> const& pt,
point_ptr<T> before_this_point,
ring_manager<T>& rings) {
point_ptr<T> point;
if (rings.storage.size() < rings.storage.capacity()) {
rings.storage.emplace_back(r, pt, before_this_point);
point = &rings.storage.back();
} else {
rings.points.emplace_back(r, pt, before_this_point);
point = &rings.points.back();
}
rings.all_points.push_back(point);
return point;
}
template <typename T>
void ring1_child_of_ring2(ring_ptr<T> ring1, ring_ptr<T> ring2, ring_manager<T>& manager) {
assert(ring1 != ring2);
if (ring1->parent == ring2) {
return;
}
if (ring1->parent == nullptr) {
manager.children.remove(ring1);
} else {
ring1->parent->children.remove(ring1);
}
if (ring2 == nullptr) {
ring1->parent = nullptr;
manager.children.push_back(ring1);
} else {
ring1->parent = ring2;
ring2->children.push_back(ring1);
}
}
template <typename T>
void ring1_sibling_of_ring2(ring_ptr<T> ring1, ring_ptr<T> ring2, ring_manager<T>& manager) {
assert(ring1 != ring2);
if (ring1->parent == ring2->parent) {
return;
}
if (ring1->parent == nullptr) {
manager.children.remove(ring1);
} else {
ring1->parent->children.remove(ring1);
}
if (ring2->parent == nullptr) {
manager.children.push_back(ring1);
} else {
ring2->parent->children.push_back(ring1);
}
ring1->parent = ring2->parent;
}
template <typename T>
void ring1_replaces_ring2(ring_ptr<T> ring1, ring_ptr<T> ring2, ring_manager<T>& manager) {
assert(ring1 != ring2);
if (ring2->parent == nullptr) {
manager.children.remove(ring2);
} else {
ring2->parent->children.remove(ring2);
}
for (auto& c : ring2->children) {
c->parent = ring1;
}
if (ring1 == nullptr) {
manager.children.splice(manager.children.end(), ring2->children);
} else {
ring1->children.splice(ring1->children.end(), ring2->children);
}
ring2->parent = nullptr;
}
template <typename T>
void remove_ring(ring_ptr<T> r, ring_manager<T>& manager) {
if (r->parent == nullptr) {
manager.children.remove(r);
for (auto& c : r->children) {
c->parent = nullptr;
}
manager.children.splice(manager.children.end(), r->children);
} else {
r->parent->children.remove(r);
for (auto& c : r->children) {
c->parent = r->parent;
}
r->parent->children.splice(r->parent->children.end(), r->children);
r->parent = nullptr;
}
}
template <typename T>
inline std::size_t ring_depth(ring_ptr<T> r) {
std::size_t depth = 0;
if (!r) {
return depth;
}
while (r->parent) {
depth++;
r = r->parent;
}
return depth;
}
template <typename T>
inline bool ring_is_hole(ring_ptr<T> r) {
return ring_depth(r) & 1;
}
template <typename T>
void set_next(const_point_ptr<T>& node, const const_point_ptr<T>& next_node) {
node->next = next_node;
}
template <typename T>
point_ptr<T> get_next(const_point_ptr<T>& node) {
return node->next;
}
template <typename T>
point_ptr<T> get_prev(const_point_ptr<T>& node) {
return node->prev;
}
template <typename T>
void set_prev(const_point_ptr<T>& node, const const_point_ptr<T>& prev_node) {
node->prev = prev_node;
}
template <typename T>
void init(const_point_ptr<T>& node) {
set_next(node, node);
set_prev(node, node);
}
template <typename T>
std::size_t point_count(const const_point_ptr<T>& orig_node) {
std::size_t size = 0;
point_ptr<T> n = orig_node;
do {
n = get_next(n);
++size;
} while (n != orig_node);
return size;
}
template <typename T>
void link_before(point_ptr<T>& node, point_ptr<T>& new_node) {
point_ptr<T> prev_node = get_prev(node);
set_prev(new_node, prev_node);
set_next(new_node, node);
set_prev(node, new_node);
set_next(prev_node, new_node);
}
template <typename T>
void link_after(point_ptr<T>& node, point_ptr<T>& new_node) {
point_ptr<T> next_node = get_next(node);
set_prev(new_node, node);
set_next(new_node, next_node);
set_next(node, new_node);
set_prev(next_node, new_node);
}
template <typename T>
void transfer_point(point_ptr<T>& p, point_ptr<T>& b, point_ptr<T>& e) {
if (b != e) {
point_ptr<T> prev_p = get_prev(p);
point_ptr<T> prev_b = get_prev(b);
point_ptr<T> prev_e = get_prev(e);
set_next(prev_e, p);
set_prev(p, prev_e);
set_next(prev_b, e);
set_prev(e, prev_b);
set_next(prev_p, b);
set_prev(b, prev_p);
} else {
link_before(p, b);
}
}
template <typename T>
void reverse_ring(point_ptr<T> pp) {
if (!pp) {
return;
}
point_ptr<T> pp1;
point_ptr<T> pp2;
pp1 = pp;
do {
pp2 = pp1->next;
pp1->next = pp1->prev;
pp1->prev = pp2;
pp1 = pp2;
} while (pp1 != pp);
}
template <typename T>
double area_from_point(point_ptr<T> op, std::size_t & size) {
point_ptr<T> startOp = op;
size = 1;
if (!op) {
return 0.0;
}
double a = 0.0;
do {
++size;
a += static_cast<double>(op->prev->x + op->x) * static_cast<double>(op->prev->y - op->y);
op = op->next;
} while (op != startOp);
return a * 0.5;
}
template <typename T>
double area(ring_ptr<T> r) {
assert(r != nullptr);
if (std::isnan(r->area)) {
r->area = area_from_point(r->points, r->size);
}
return r->area;
}
#ifdef DEBUG
template <class charT, class traits, typename T>
inline std::basic_ostream<charT, traits>& operator<<(std::basic_ostream<charT, traits>& out,
const ring<T>& r) {
out << " ring_index: " << r.ring_index << std::endl;
if (!r.parent) {
// out << " parent_ring ptr: nullptr" << std::endl;
out << " parent_index: -----" << std::endl;
} else {
// out << " parent_ring ptr: " << r.parent << std::endl;
out << " parent_ring idx: " << r.parent->ring_index << std::endl;
}
ring_ptr<T> n = const_cast<ring_ptr<T>>(&r);
if (ring_is_hole(n)) {
out << " is_hole: true " << std::endl;
} else {
out << " is_hole: false " << std::endl;
}
auto pt_itr = r.points;
if (pt_itr) {
out << " area: " << r.area << std::endl;
out << " points:" << std::endl;
out << " [[[" << pt_itr->x << "," << pt_itr->y << "],";
pt_itr = pt_itr->next;
while (pt_itr != r.points) {
out << "[" << pt_itr->x << "," << pt_itr->y << "],";
pt_itr = pt_itr->next;
}
out << "[" << pt_itr->x << "," << pt_itr->y << "]]]" << std::endl;
} else {
out << " area: NONE" << std::endl;
out << " points: NONE" << std::endl;
}
return out;
}
template <typename T>
std::string output_as_polygon(ring_ptr<T> r) {
std::ostringstream out;
auto pt_itr = r->points;
if (pt_itr) {
out << "[";
out << "[[" << pt_itr->x << "," << pt_itr->y << "],";
pt_itr = pt_itr->next;
while (pt_itr != r->points) {
out << "[" << pt_itr->x << "," << pt_itr->y << "],";
pt_itr = pt_itr->next;
}
out << "[" << pt_itr->x << "," << pt_itr->y << "]]";
for (auto const& c : r->children) {
pt_itr = c->points;
if (pt_itr) {
out << ",[[" << pt_itr->x << "," << pt_itr->y << "],";
pt_itr = pt_itr->next;
while (pt_itr != c->points) {
out << "[" << pt_itr->x << "," << pt_itr->y << "],";
pt_itr = pt_itr->next;
}
out << "[" << pt_itr->x << "," << pt_itr->y << "]]";
}
}
out << "]" << std::endl;
} else {
out << "[]" << std::endl;
}
return out.str();
}
template <class charT, class traits, typename T>
inline std::basic_ostream<charT, traits>& operator<<(std::basic_ostream<charT, traits>& out,
const ring_list<T>& rings) {
out << "START RING LIST" << std::endl;
for (auto& r : rings) {
out << " ring: " << r->ring_index << " - " << r << std::endl;
out << *r;
}
out << "END RING LIST" << std::endl;
return out;
}
template <class charT, class traits, typename T>
inline std::basic_ostream<charT, traits>& operator<<(std::basic_ostream<charT, traits>& out,
const ring_vector<T>& rings) {
out << "START RING VECTOR" << std::endl;
for (auto& r : rings) {
if (!r->points) {
continue;
}
out << " ring: " << r->ring_index << " - " << r << std::endl;
out << *r;
}
out << "END RING VECTOR" << std::endl;
return out;
}
template <class charT, class traits, typename T>
inline std::basic_ostream<charT, traits>& operator<<(std::basic_ostream<charT, traits>& out,
const std::deque<ring<T>>& rings) {
out << "START RING VECTOR" << std::endl;
for (auto& r : rings) {
if (!r.points) {
continue;
}
out << " ring: " << r.ring_index << std::endl;
out << r;
}
out << "END RING VECTOR" << std::endl;
return out;
}
template <class charT, class traits, typename T>
inline std::basic_ostream<charT, traits>& operator<<(std::basic_ostream<charT, traits>& out,
const hot_pixel_vector<T>& hp_vec) {
out << "Hot Pixels: " << std::endl;
for (auto& hp : hp_vec) {
out << hp << std::endl;
}
return out;
}
#endif
}
}
}

915
mapbox/geometry/wagyu/ring_util.hpp Normal file
View File

@ -0,0 +1,915 @@
#pragma once
#ifdef DEBUG
#include <iostream>
// Example debug print for backtrace - only works on IOS
#include <execinfo.h>
#include <stdio.h>
//
// void* callstack[128];
// int i, frames = backtrace(callstack, 128);
// char** strs = backtrace_symbols(callstack, frames);
// for (i = 0; i < frames; ++i) {
// printf("%s\n", strs[i]);
// }
// free(strs);
#endif
#include <queue>
#include <mapbox/geometry/wagyu/active_bound_list.hpp>
#include <mapbox/geometry/wagyu/config.hpp>
#include <mapbox/geometry/wagyu/edge.hpp>
#include <mapbox/geometry/wagyu/ring.hpp>
#include <mapbox/geometry/wagyu/util.hpp>
namespace mapbox {
namespace geometry {
namespace wagyu {
template <typename T>
void set_hole_state(active_bound_list_itr<T>& bnd,
active_bound_list<T>& active_bounds,
ring_manager<T>& rings) {
auto bnd2 = active_bound_list_rev_itr<T>(bnd);
bound_ptr<T> bndTmp = nullptr;
// Find first non line ring to the left of current bound.
while (bnd2 != active_bounds.rend()) {
if ((*bnd2)->ring && (*bnd2)->winding_delta != 0) {
if (!bndTmp) {
bndTmp = (*bnd2);
} else if (bndTmp->ring == (*bnd2)->ring) {
bndTmp = nullptr;
}
}
++bnd2;
}
if (!bndTmp) {
(*bnd)->ring->parent = nullptr;
rings.children.push_back((*bnd)->ring);
} else {
(*bnd)->ring->parent = bndTmp->ring;
bndTmp->ring->children.push_back((*bnd)->ring);
}
}
template <typename T>
void set_hole_state(active_bound_list_rev_itr<T>& bnd,
active_bound_list<T>& active_bounds,
ring_manager<T>& rings) {
auto bnd2 = std::next(bnd);
bound_ptr<T> bndTmp = nullptr;
// Find first non line ring to the left of current bound.
while (bnd2 != active_bounds.rend()) {
if ((*bnd2)->ring && (*bnd2)->winding_delta != 0) {
if (!bndTmp) {
bndTmp = (*bnd2);
} else if (bndTmp->ring == (*bnd2)->ring) {
bndTmp = nullptr;
}
}
++bnd2;
}
if (!bndTmp) {
(*bnd)->ring->parent = nullptr;
rings.children.push_back((*bnd)->ring);
} else {
(*bnd)->ring->parent = bndTmp->ring;
bndTmp->ring->children.push_back((*bnd)->ring);
}
}
template <typename T>
void update_current_hp_itr(T scanline_y, ring_manager<T>& rings) {
while (rings.current_hp_itr->y > scanline_y) {
++rings.current_hp_itr;
}
}
template <typename T>
struct hot_pixel_sorter {
inline bool operator()(mapbox::geometry::point<T> const& pt1, mapbox::geometry::point<T> const& pt2) {
if (pt1.y == pt2.y) {
return pt1.x < pt2.x;
} else {
return pt1.y > pt2.y;
}
}
};
// Due to the nature of floating point calculations
// and the high likely hood of values around X.5, we
// need to fudge what is X.5 some for our rounding.
const double rounding_offset = 1e-12;
const double rounding_offset_y = 5e-13;
template <typename T>
T round_towards_min(double val) {
// 0.5 rounds to 0
// 0.0 rounds to 0
// -0.5 rounds to -1
return static_cast<T>(std::ceil(val - 0.5 + rounding_offset));
}
template <typename T>
T round_towards_max(double val) {
// 0.5 rounds to 1
// 0.0 rounds to 0
// -0.5 rounds to 0
return static_cast<T>(std::floor(val + 0.5 + rounding_offset));
}
template <typename T>
inline T get_edge_min_x(edge<T> const& edge, const T current_y) {
if (is_horizontal(edge)) {
if (edge.bot.x < edge.top.x) {
return edge.bot.x;
} else {
return edge.top.x;
}
} else if (edge.dx > 0.0) {
if (current_y == edge.top.y) {
return edge.top.x;
} else {
double lower_range_y = static_cast<double>(current_y - edge.bot.y) - 0.5;
double return_val = static_cast<double>(edge.bot.x) + edge.dx * lower_range_y;
T value = round_towards_min<T>(return_val);
return value;
}
} else {
if (current_y == edge.bot.y) {
return edge.bot.x;
} else {
double return_val = static_cast<double>(edge.bot.x) +
edge.dx * (static_cast<double>(current_y - edge.bot.y) + 0.5 - rounding_offset_y);
T value = round_towards_min<T>(return_val);
return value;
}
}
}
template <typename T>
inline T get_edge_max_x(edge<T> const& edge, const T current_y) {
if (is_horizontal(edge)) {
if (edge.bot.x > edge.top.x) {
return edge.bot.x;
} else {
return edge.top.x;
}
} else if (edge.dx < 0.0) {
if (current_y == edge.top.y) {
return edge.top.x;
} else {
double lower_range_y = static_cast<double>(current_y - edge.bot.y) - 0.5;
double return_val = static_cast<double>(edge.bot.x) + edge.dx * lower_range_y;
T value = round_towards_max<T>(return_val);
return value;
}
} else {
if (current_y == edge.bot.y) {
return edge.bot.x;
} else {
double return_val = static_cast<double>(edge.bot.x) +
edge.dx * (static_cast<double>(current_y - edge.bot.y) + 0.5 - rounding_offset_y);
T value = round_towards_max<T>(return_val);
return value;
}
}
}
template <typename T>
void hot_pixel_set_left_to_right(T y,
T start_x,
T end_x,
bound<T>& bnd,
ring_manager<T>& rings,
hot_pixel_itr<T> & itr,
hot_pixel_itr<T> & end,
bool add_end_point) {
T x_min = get_edge_min_x(*(bnd.current_edge), y);
x_min = std::max(x_min, start_x);
T x_max = get_edge_max_x(*(bnd.current_edge), y);
x_max = std::min(x_max, end_x);
for (;itr != end; ++itr) {
if (itr->x < x_min) {
continue;
}
if (itr->x > x_max) {
break;
}
if (!add_end_point && itr->x == end_x) {
continue;
}
point_ptr<T> op = bnd.ring->points;
bool to_front = (bnd.side == edge_left);
if (to_front && (*itr == *op)) {
continue;
} else if (!to_front && (*itr == *op->prev)) {
continue;
}
point_ptr<T> new_point = create_new_point(bnd.ring, *itr, op, rings);
if (to_front) {
bnd.ring->points = new_point;
}
}
}
template <typename T>
void hot_pixel_set_right_to_left(T y,
T start_x,
T end_x,
bound<T>& bnd,
ring_manager<T>& rings,
hot_pixel_rev_itr<T> & itr,
hot_pixel_rev_itr<T> & end,
bool add_end_point) {
T x_min = get_edge_min_x(*(bnd.current_edge), y);
x_min = std::max(x_min, end_x);
T x_max = get_edge_max_x(*(bnd.current_edge), y);
x_max = std::min(x_max, start_x);
for (;itr != end; ++itr) {
if (itr->x > x_max) {
continue;
}
if (itr->x < x_min) {
break;
}
if (!add_end_point && itr->x == end_x) {
continue;
}
point_ptr<T> op = bnd.ring->points;
bool to_front = (bnd.side == edge_left);
if (to_front && (*itr == *op)) {
continue;
} else if (!to_front && (*itr == *op->prev)) {
continue;
}
point_ptr<T> new_point = create_new_point(bnd.ring, *itr, op, rings);
if (to_front) {
bnd.ring->points = new_point;
}
}
}
template <typename T>
void sort_hot_pixels(ring_manager<T>& rings) {
std::sort(rings.hot_pixels.begin(), rings.hot_pixels.end(), hot_pixel_sorter<T>());
auto last = std::unique(rings.hot_pixels.begin(), rings.hot_pixels.end());
rings.hot_pixels.erase(last, rings.hot_pixels.end());
}
template <typename T>
void insert_hot_pixels_in_path(bound<T>& bnd,
mapbox::geometry::point<T> const& end_pt,
ring_manager<T>& rings,
bool add_end_point) {
if (end_pt == bnd.last_point) {
return;
}
if (!bnd.ring) {
bnd.last_point = end_pt;
return;
}
T start_y = bnd.last_point.y;
T start_x = bnd.last_point.x;
T end_y = end_pt.y;
T end_x = end_pt.x;
auto itr = rings.current_hp_itr;
while (itr->y <= start_y && itr != rings.hot_pixels.begin()) {
--itr;
}
if (start_x > end_x) {
for (; itr != rings.hot_pixels.end();) {
if (itr->y > start_y) {
++itr;
continue;
}
if (itr->y < end_y) {
break;
}
T y = itr->y;
auto last_itr = hot_pixel_rev_itr<T>(itr);
while (itr != rings.hot_pixels.end() && itr->y == y) {
++itr;
}
auto first_itr = hot_pixel_rev_itr<T>(itr);
bool add_end_point_itr = (y != end_pt.y || add_end_point);
hot_pixel_set_right_to_left(y, start_x, end_x, bnd, rings, first_itr, last_itr,
add_end_point_itr);
}
} else {
for (; itr != rings.hot_pixels.end();) {
if (itr->y > start_y) {
++itr;
continue;
}
if (itr->y < end_y) {
break;
}
T y = itr->y;
auto first_itr = itr;
while (itr != rings.hot_pixels.end() && itr->y == y) {
++itr;
}
auto last_itr = itr;
bool add_end_point_itr = (y != end_pt.y || add_end_point);
hot_pixel_set_left_to_right(y, start_x, end_x, bnd, rings, first_itr, last_itr,
add_end_point_itr);
}
}
bnd.last_point = end_pt;
}
template <typename T>
void add_to_hot_pixels(mapbox::geometry::point<T> const& pt, ring_manager<T>& rings) {
rings.hot_pixels.push_back(pt);
}
template <typename T>
void add_first_point(active_bound_list_itr<T>& bnd,
active_bound_list<T>& active_bounds,
mapbox::geometry::point<T> const& pt,
ring_manager<T>& rings) {
ring_ptr<T> r = create_new_ring(rings);
(*bnd)->ring = r;
r->is_open = ((*bnd)->winding_delta == 0);
r->points = create_new_point(r, pt, rings);
if (!r->is_open) {
set_hole_state(bnd, active_bounds, rings);
}
(*bnd)->last_point = pt;
}
template <typename T>
void add_first_point(active_bound_list_rev_itr<T>& bnd,
active_bound_list<T>& active_bounds,
mapbox::geometry::point<T> const& pt,
ring_manager<T>& rings) {
ring_ptr<T> r = create_new_ring(rings);
// no ring currently set!
(*bnd)->ring = r;
r->is_open = ((*bnd)->winding_delta == 0);
r->points = create_new_point(r, pt, rings);
if (!r->is_open) {
set_hole_state(bnd, active_bounds, rings);
}
(*bnd)->last_point = pt;
}
template <typename T>
void add_point_to_ring(bound<T>& bnd,
mapbox::geometry::point<T> const& pt,
ring_manager<T>& rings) {
assert(bnd.ring);
// Handle hot pixels
insert_hot_pixels_in_path(bnd, pt, rings, false);
// bnd.ring->points is the 'Left-most' point & bnd.ring->points->prev is the
// 'Right-most'
point_ptr<T> op = bnd.ring->points;
bool to_front = (bnd.side == edge_left);
if (to_front && (pt == *op)) {
return;
} else if (!to_front && (pt == *op->prev)) {
return;
}
point_ptr<T> new_point = create_new_point(bnd.ring, pt, bnd.ring->points, rings);
if (to_front) {
bnd.ring->points = new_point;
}
}
template <typename T>
void add_point(active_bound_list_itr<T>& bnd,
active_bound_list<T>& active_bounds,
mapbox::geometry::point<T> const& pt,
ring_manager<T>& rings) {
if (!(*bnd)->ring) {
add_first_point(bnd, active_bounds, pt, rings);
} else {
add_point_to_ring(*(*bnd), pt, rings);
}
}
template <typename T>
void add_point(active_bound_list_rev_itr<T>& bnd,
active_bound_list<T>& active_bounds,
mapbox::geometry::point<T> const& pt,
ring_manager<T>& rings) {
if (!(*bnd)->ring) {
add_first_point(bnd, active_bounds, pt, rings);
} else {
add_point_to_ring(*(*bnd), pt, rings);
}
}
template <typename T>
void add_local_minimum_point(active_bound_list_itr<T> b1,
active_bound_list_itr<T> b2,
active_bound_list<T>& active_bounds,
mapbox::geometry::point<T> const& pt,
ring_manager<T>& rings) {
active_bound_list_itr<T> b;
active_bound_list_rev_itr<T> prev_bound;
active_bound_list_rev_itr<T> prev_b1(b1);
active_bound_list_rev_itr<T> prev_b2(b2);
if (is_horizontal(*((*b2)->current_edge)) ||
((*b1)->current_edge->dx > (*b2)->current_edge->dx)) {
add_point(b1, active_bounds, pt, rings);
(*b2)->last_point = pt;
(*b2)->ring = (*b1)->ring;
(*b1)->side = edge_left;
(*b2)->side = edge_right;
b = b1;
if (prev_b1 != active_bounds.rend() && std::prev(b) == b2) {
prev_bound = prev_b2;
} else {
prev_bound = prev_b1;
}
} else {
add_point(b2, active_bounds, pt, rings);
(*b1)->last_point = pt;
(*b1)->ring = (*b2)->ring;
(*b1)->side = edge_right;
(*b2)->side = edge_left;
b = b2;
if (prev_b2 != active_bounds.rend() && std::prev(b) == b1) {
prev_bound = prev_b1;
} else {
prev_bound = prev_b2;
}
}
}
template <typename T>
inline double get_dx(point<T> const& pt1, point<T> const& pt2) {
if (pt1.y == pt2.y) {
return std::numeric_limits<double>::infinity();
} else {
return static_cast<double>(pt2.x - pt2.x) / static_cast<double>(pt2.y - pt1.y);
}
}
template <typename T>
bool first_is_bottom_point(const_point_ptr<T> btmPt1, const_point_ptr<T> btmPt2) {
point_ptr<T> p = btmPt1->prev;
while ((*p == *btmPt1) && (p != btmPt1)) {
p = p->prev;
}
double dx1p = std::fabs(get_dx(*btmPt1, *p));
p = btmPt1->next;
while ((*p == *btmPt1) && (p != btmPt1)) {
p = p->next;
}
double dx1n = std::fabs(get_dx(*btmPt1, *p));
p = btmPt2->prev;
while ((*p == *btmPt2) && (p != btmPt2)) {
p = p->prev;
}
double dx2p = std::fabs(get_dx(*btmPt2, *p));
p = btmPt2->next;
while ((*p == *btmPt2) && (p != btmPt2)) {
p = p->next;
}
double dx2n = std::fabs(get_dx(*btmPt2, *p));
if (values_are_equal(std::max(dx1p, dx1n), std::max(dx2p, dx2n)) &&
values_are_equal(std::min(dx1p, dx1n), std::min(dx2p, dx2n))) {
std::size_t s = 0;
return area_from_point(btmPt1, s) > 0.0; // if otherwise identical use orientation
} else {
return (greater_than_or_equal(dx1p, dx2p) && greater_than_or_equal(dx1p, dx2n)) ||
(greater_than_or_equal(dx1n, dx2p) && greater_than_or_equal(dx1n, dx2n));
}
}
template <typename T>
point_ptr<T> get_bottom_point(point_ptr<T> pp) {
point_ptr<T> dups = 0;
point_ptr<T> p = pp->next;
while (p != pp) {
if (p->y > pp->y) {
pp = p;
dups = 0;
} else if (p->y == pp->y && p->x <= pp->x) {
if (p->x < pp->x) {
dups = 0;
pp = p;
} else {
if (p->next != pp && p->prev != pp) {
dups = p;
}
}
}
p = p->next;
}
if (dups) {
// there appears to be at least 2 vertices at bottom_point so ...
while (dups != p) {
if (!first_is_bottom_point(p, dups)) {
pp = dups;
}
dups = dups->next;
while (*dups != *pp) {
dups = dups->next;
}
}
}
return pp;
}
template <typename T>
ring_ptr<T> get_lower_most_ring(ring_ptr<T> outRec1, ring_ptr<T> outRec2) {
// work out which polygon fragment has the correct hole state ...
if (!outRec1->bottom_point) {
outRec1->bottom_point = get_bottom_point(outRec1->points);
}
if (!outRec2->bottom_point) {
outRec2->bottom_point = get_bottom_point(outRec2->points);
}
point_ptr<T> OutPt1 = outRec1->bottom_point;
point_ptr<T> OutPt2 = outRec2->bottom_point;
if (OutPt1->y > OutPt2->y) {
return outRec1;
} else if (OutPt1->y < OutPt2->y) {
return outRec2;
} else if (OutPt1->x < OutPt2->x) {
return outRec1;
} else if (OutPt1->x > OutPt2->x) {
return outRec2;
} else if (OutPt1->next == OutPt1) {
return outRec2;
} else if (OutPt2->next == OutPt2) {
return outRec1;
} else if (first_is_bottom_point(OutPt1, OutPt2)) {
return outRec1;
} else {
return outRec2;
}
}
template <typename T>
bool ring1_right_of_ring2(ring_ptr<T> ring1, ring_ptr<T> ring2) {
do {
ring1 = ring1->parent;
if (ring1 == ring2) {
return true;
}
} while (ring1);
return false;
}
template <typename T>
void update_points_ring(ring_ptr<T> ring) {
point_ptr<T> op = ring->points;
do {
op->ring = ring;
op = op->prev;
} while (op != ring->points);
}
template <typename T>
void append_ring(active_bound_list_itr<T>& b1,
active_bound_list_itr<T>& b2,
active_bound_list<T>& active_bounds,
ring_manager<T>& manager) {
// get the start and ends of both output polygons ...
ring_ptr<T> outRec1 = (*b1)->ring;
ring_ptr<T> outRec2 = (*b2)->ring;
ring_ptr<T> keep_ring;
bound_ptr<T> keep_bound;
ring_ptr<T> remove_ring;
bound_ptr<T> remove_bound;
if (ring1_right_of_ring2(outRec1, outRec2)) {
keep_ring = outRec2;
keep_bound = *b2;
remove_ring = outRec1;
remove_bound = *b1;
} else if (ring1_right_of_ring2(outRec2, outRec1)) {
keep_ring = outRec1;
keep_bound = *b1;
remove_ring = outRec2;
remove_bound = *b2;
} else if (outRec1 == get_lower_most_ring(outRec1, outRec2)) {
keep_ring = outRec1;
keep_bound = *b1;
remove_ring = outRec2;
remove_bound = *b2;
} else {
keep_ring = outRec2;
keep_bound = *b2;
remove_ring = outRec1;
remove_bound = *b1;
}
// get the start and ends of both output polygons and
// join b2 poly onto b1 poly and delete pointers to b2 ...
point_ptr<T> p1_lft = keep_ring->points;
point_ptr<T> p1_rt = p1_lft->prev;
point_ptr<T> p2_lft = remove_ring->points;
point_ptr<T> p2_rt = p2_lft->prev;
// join b2 poly onto b1 poly and delete pointers to b2 ...
if (keep_bound->side == edge_left) {
if (remove_bound->side == edge_left) {
// z y x a b c
reverse_ring(p2_lft);
p2_lft->next = p1_lft;
p1_lft->prev = p2_lft;
p1_rt->next = p2_rt;
p2_rt->prev = p1_rt;
keep_ring->points = p2_rt;
} else {
// x y z a b c
p2_rt->next = p1_lft;
p1_lft->prev = p2_rt;
p2_lft->prev = p1_rt;
p1_rt->next = p2_lft;
keep_ring->points = p2_lft;
}
} else {
if (remove_bound->side == edge_right) {
// a b c z y x
reverse_ring(p2_lft);
p1_rt->next = p2_rt;
p2_rt->prev = p1_rt;
p2_lft->next = p1_lft;
p1_lft->prev = p2_lft;
} else {
// a b c x y z
p1_rt->next = p2_lft;
p2_lft->prev = p1_rt;
p1_lft->prev = p2_rt;
p2_rt->next = p1_lft;
}
}
keep_ring->bottom_point = nullptr;
bool keep_is_hole = ring_is_hole(keep_ring);
bool remove_is_hole = ring_is_hole(remove_ring);
remove_ring->points = nullptr;
remove_ring->bottom_point = nullptr;
if (keep_is_hole != remove_is_hole) {
ring1_replaces_ring2(keep_ring->parent, remove_ring, manager);
} else {
ring1_replaces_ring2(keep_ring, remove_ring, manager);
}
update_points_ring(keep_ring);
// nb: safe because we only get here via AddLocalMaxPoly
keep_bound->ring = nullptr;
remove_bound->ring = nullptr;
for (auto& b : active_bounds) {
if (b->ring == remove_ring) {
b->ring = keep_ring;
b->side = keep_bound->side;
break; // Not sure why there is a break here but was transfered logic from angus
}
}
}
template <typename T>
void add_local_maximum_point(active_bound_list_itr<T>& b1,
active_bound_list_itr<T>& b2,
mapbox::geometry::point<T> const& pt,
ring_manager<T>& rings,
active_bound_list<T>& active_bounds) {
insert_hot_pixels_in_path(*(*b2), pt, rings, false);
add_point(b1, active_bounds, pt, rings);
if ((*b2)->winding_delta == 0) {
add_point(b2, active_bounds, pt, rings);
}
if ((*b1)->ring == (*b2)->ring) {
(*b1)->ring = nullptr;
(*b2)->ring = nullptr;
// I am not certain that order is important here?
} else if ((*b1)->ring->ring_index < (*b2)->ring->ring_index) {
append_ring(b1, b2, active_bounds, rings);
} else {
append_ring(b2, b1, active_bounds, rings);
}
}
enum point_in_polygon_result : std::int8_t {
point_on_polygon = -1,
point_inside_polygon = 0,
point_outside_polygon = 1
};
template <typename T>
point_in_polygon_result point_in_polygon(point<T> const& pt, point_ptr<T> op) {
// returns 0 if false, +1 if true, -1 if pt ON polygon boundary
point_in_polygon_result result = point_outside_polygon;
point_ptr<T> startOp = op;
do {
if (op->next->y == pt.y) {
if ((op->next->x == pt.x) ||
(op->y == pt.y && ((op->next->x > pt.x) == (op->x < pt.x)))) {
return point_on_polygon;
}
}
if ((op->y < pt.y) != (op->next->y < pt.y)) {
if (op->x >= pt.x) {
if (op->next->x > pt.x) {
// Switch between point outside polygon and point inside
// polygon
if (result == point_outside_polygon) {
result = point_inside_polygon;
} else {
result = point_outside_polygon;
}
} else {
double d =
static_cast<double>(op->x - pt.x) *
static_cast<double>(op->next->y - pt.y) -
static_cast<double>(op->next->x - pt.x) * static_cast<double>(op->y - pt.y);
if (value_is_zero(d)) {
return point_on_polygon;
}
if ((d > 0) == (op->next->y > op->y)) {
// Switch between point outside polygon and point inside
// polygon
if (result == point_outside_polygon) {
result = point_inside_polygon;
} else {
result = point_outside_polygon;
}
}
}
} else {
if (op->next->x > pt.x) {
double d =
static_cast<double>(op->x - pt.x) *
static_cast<double>(op->next->y - pt.y) -
static_cast<double>(op->next->x - pt.x) * static_cast<double>(op->y - pt.y);
if (value_is_zero(d)) {
return point_on_polygon;
}
if ((d > 0) == (op->next->y > op->y)) {
// Switch between point outside polygon and point inside
// polygon
if (result == point_outside_polygon) {
result = point_inside_polygon;
} else {
result = point_outside_polygon;
}
}
}
}
}
op = op->next;
} while (startOp != op);
return result;
}
template <typename T>
point_in_polygon_result point_in_polygon(mapbox::geometry::point<double> const& pt,
point_ptr<T> op) {
// returns 0 if false, +1 if true, -1 if pt ON polygon boundary
point_in_polygon_result result = point_outside_polygon;
point_ptr<T> startOp = op;
do {
double op_x = static_cast<double>(op->x);
double op_y = static_cast<double>(op->y);
double op_next_x = static_cast<double>(op->next->x);
double op_next_y = static_cast<double>(op->next->y);
if (values_are_equal(op_next_y, pt.y)) {
if (values_are_equal(op_next_x, pt.x) ||
(values_are_equal(op_y, pt.y) && ((op_next_x > pt.x) == (op_x < pt.x)))) {
return point_on_polygon;
}
}
if ((op_y < pt.y) != (op_next_y < pt.y)) {
if (greater_than_or_equal(op_x, pt.x)) {
if (op_next_x > pt.x) {
// Switch between point outside polygon and point inside
// polygon
if (result == point_outside_polygon) {
result = point_inside_polygon;
} else {
result = point_outside_polygon;
}
} else {
double d =
(op_x - pt.x) * (op_next_y - pt.y) - (op_next_x - pt.x) * (op_y - pt.y);
if (value_is_zero(d)) {
return point_on_polygon;
}
if ((d > 0.0) == (op_next_y > op->y)) {
// Switch between point outside polygon and point inside
// polygon
if (result == point_outside_polygon) {
result = point_inside_polygon;
} else {
result = point_outside_polygon;
}
}
}
} else {
if (op_next_x > pt.x) {
double d =
(op_x - pt.x) * (op_next_y - pt.y) - (op_next_x - pt.x) * (op_y - pt.y);
if (value_is_zero(d)) {
return point_on_polygon;
}
if ((d > 0.0) == (op_next_y > op->y)) {
// Switch between point outside polygon and point inside
// polygon
if (result == point_outside_polygon) {
result = point_inside_polygon;
} else {
result = point_outside_polygon;
}
}
}
}
}
op = op->next;
} while (startOp != op);
return result;
}
template <typename T>
point_in_polygon_result inside_or_outside_special(point_ptr<T> first_pt, point_ptr<T> other_poly) {
if (value_is_zero(area(first_pt->ring))) {
return point_inside_polygon;
}
if (value_is_zero(area(other_poly->ring))) {
return point_outside_polygon;
}
point_ptr<T> pt = first_pt;
do {
if (*pt == *(pt->prev) || *pt == *(pt->next) || *(pt->next) == *(pt->prev) ||
slopes_equal(*(pt->prev), *pt, *(pt->next))) {
pt = pt->next;
continue;
}
double dx = ((pt->prev->x - pt->x) / 3.0) + ((pt->next->x - pt->x) / 3.0);
double dy = ((pt->prev->y - pt->y) / 3.0) + ((pt->next->y - pt->y) / 3.0);
mapbox::geometry::point<double> offset_pt(pt->x + dx, pt->y + dy);
point_in_polygon_result res = point_in_polygon(offset_pt, pt);
if (res != point_inside_polygon) {
offset_pt.x = pt->x - dx;
offset_pt.y = pt->y - dy;
res = point_in_polygon(offset_pt, pt);
if (res != point_inside_polygon) {
pt = pt->next;
continue;
}
}
res = point_in_polygon(offset_pt, other_poly);
if (res == point_on_polygon) {
pt = pt->next;
continue;
}
return res;
} while (pt != first_pt);
return point_inside_polygon;
}
template <typename T>
bool poly2_contains_poly1(point_ptr<T> outpt1, point_ptr<T> outpt2) {
point_ptr<T> op = outpt1;
do {
// nb: PointInPolygon returns 0 if false, +1 if true, -1 if pt on polygon
point_in_polygon_result res = point_in_polygon(*op, outpt2);
if (res != point_on_polygon) {
return res == point_inside_polygon;
}
op = op->next;
} while (op != outpt1);
point_in_polygon_result res = inside_or_outside_special(outpt1, outpt2);
return res == point_inside_polygon;
}
template <typename T>
void dispose_out_points(point_ptr<T>& pp) {
if (pp == nullptr) {
return;
}
pp->prev->next = nullptr;
while (pp) {
point_ptr<T> tmpPp = pp;
pp = pp->next;
tmpPp->next = tmpPp;
tmpPp->prev = tmpPp;
tmpPp->ring = nullptr;
// delete tmpPp;
}
}
}
}
}

37
mapbox/geometry/wagyu/scanbeam.hpp Normal file
View File

@ -0,0 +1,37 @@
#pragma once
#include <queue>
#include <mapbox/geometry/wagyu/config.hpp>
#include <mapbox/geometry/wagyu/local_minimum.hpp>
namespace mapbox {
namespace geometry {
namespace wagyu {
template <typename T>
using scanbeam_list = std::priority_queue<T>;
template <typename T>
bool pop_from_scanbeam(T& Y, scanbeam_list<T>& scanbeam) {
if (scanbeam.empty()) {
return false;
}
Y = scanbeam.top();
scanbeam.pop();
while (!scanbeam.empty() && Y == scanbeam.top()) {
scanbeam.pop();
} // Pop duplicates.
return true;
}
template <typename T>
void setup_scanbeam(local_minimum_list<T>& minima_list, scanbeam_list<T>& scanbeam) {
for (auto lm = minima_list.begin(); lm != minima_list.end(); ++lm) {
scanbeam.push(lm->y);
}
}
}
}
}

174
mapbox/geometry/wagyu/snap_rounding.hpp Normal file
View File

@ -0,0 +1,174 @@
#pragma once
#include <mapbox/geometry/wagyu/active_bound_list.hpp>
#include <mapbox/geometry/wagyu/edge.hpp>
#include <mapbox/geometry/wagyu/bound.hpp>
#include <mapbox/geometry/wagyu/config.hpp>
#include <mapbox/geometry/wagyu/intersect.hpp>
#include <mapbox/geometry/wagyu/intersect_util.hpp>
#include <mapbox/geometry/wagyu/ring.hpp>
#include <mapbox/geometry/wagyu/ring_util.hpp>
#include <mapbox/geometry/wagyu/util.hpp>
namespace mapbox {
namespace geometry {
namespace wagyu {
template <typename T>
void process_hot_pixel_intersections(T top_y,
active_bound_list<T>& active_bounds,
ring_manager<T>& rings) {
if (active_bounds.empty()) {
return;
}
update_current_x(active_bounds, top_y);
// bubblesort ...
bool isModified;
do {
isModified = false;
auto bnd = active_bounds.begin();
auto bnd_next = std::next(bnd);
while (bnd_next != active_bounds.end()) {
if ((*bnd)->current_x > (*bnd_next)->current_x && !slopes_equal(*(*bnd)->current_edge, *(*bnd_next)->current_edge)) {
mapbox::geometry::point<double> pt;
if (!get_edge_intersection<T, double>(*((*bnd)->current_edge),
*((*bnd_next)->current_edge), pt)) {
throw std::runtime_error("Edges do not intersect!");
}
add_to_hot_pixels(round_point<T>(pt), rings);
swap_positions_in_ABL(bnd, bnd_next, active_bounds);
bnd_next = std::next(bnd);
isModified = true;
} else {
bnd = bnd_next;
++bnd_next;
}
}
} while (isModified);
}
template <typename T>
void process_hot_pixel_edges_at_top_of_scanbeam(T top_y,
scanbeam_list<T>& scanbeam,
active_bound_list<T>& active_bounds,
ring_manager<T>& rings) {
for (auto bnd = active_bounds.begin(); bnd != active_bounds.end();) {
auto bnd_2 = std::next(bnd);
while ((*bnd)->current_edge != (*bnd)->edges.end() && (*bnd)->current_edge->top.y == top_y) {
add_to_hot_pixels((*bnd)->current_edge->top, rings);
if (current_edge_is_horizontal<T>(bnd)) {
(*bnd)->current_x = static_cast<double>((*bnd)->current_edge->top.x);
if ((*bnd)->current_edge->bot.x < (*bnd)->current_edge->top.x) {
// left to right
auto bnd_next = std::next(bnd);
while (bnd_next != active_bounds.end() && (*bnd_next)->current_x < (*bnd)->current_x) {
if (std::llround((*bnd_next)->current_edge->top.y) != top_y && std::llround((*bnd_next)->current_edge->bot.y) != top_y) {
mapbox::geometry::point<T> pt(std::llround((*bnd_next)->current_x), top_y);
add_to_hot_pixels(pt, rings);
}
swap_positions_in_ABL(bnd, bnd_next, active_bounds);
bnd_next = std::next(bnd);
}
} else {
// right to left
if (bnd != active_bounds.begin()) {
auto bnd_prev = std::prev(bnd);
while (bnd != active_bounds.begin() && (*bnd_prev)->current_x > (*bnd)->current_x) {
if (std::llround((*bnd_prev)->current_edge->top.y) != top_y && std::llround((*bnd_prev)->current_edge->bot.y) != top_y) {
mapbox::geometry::point<T> pt(std::llround((*bnd_prev)->current_x), top_y);
add_to_hot_pixels(pt, rings);
}
swap_positions_in_ABL(bnd, bnd_prev, active_bounds);
bnd_prev = std::prev(bnd);
}
}
}
}
next_edge_in_bound(bnd, scanbeam);
}
if ((*bnd)->current_edge == (*bnd)->edges.end()) {
active_bounds.erase(bnd);
}
bnd = bnd_2;
}
}
template <typename T>
void insert_local_minima_into_ABL_hot_pixel(T top_y,
local_minimum_ptr_list<T> & minima_sorted,
local_minimum_ptr_list_itr<T> & lm,
active_bound_list<T>& active_bounds,
ring_manager<T>& rings,
scanbeam_list<T>& scanbeam) {
while (lm != minima_sorted.end() && (*lm)->y == top_y) {
if ((*lm)->left_bound.edges.empty() || (*lm)->right_bound.edges.empty()) {
++lm;
continue;
}
add_to_hot_pixels((*lm)->left_bound.edges.front().bot, rings);
auto& left_bound = (*lm)->left_bound;
left_bound.current_edge = left_bound.edges.begin();
left_bound.current_x = static_cast<double>(left_bound.current_edge->bot.x);
auto lb_abl_itr = insert_bound_into_ABL(left_bound, active_bounds);
if (!current_edge_is_horizontal<T>(lb_abl_itr)) {
scanbeam.push((*lb_abl_itr)->current_edge->top.y);
}
auto& right_bound = (*lm)->right_bound;
right_bound.current_edge = right_bound.edges.begin();
right_bound.current_x = static_cast<double>(right_bound.current_edge->bot.x);
auto rb_abl_itr = insert_bound_into_ABL(right_bound, lb_abl_itr, active_bounds);
if (!current_edge_is_horizontal<T>(rb_abl_itr)) {
scanbeam.push((*rb_abl_itr)->current_edge->top.y);
}
++lm;
}
}
template <typename T>
void build_hot_pixels(local_minimum_list<T>& minima_list,
ring_manager<T>& rings) {
if (minima_list.empty()) {
return;
}
active_bound_list<T> active_bounds;
scanbeam_list<T> scanbeam;
T scanline_y = std::numeric_limits<T>::max();
local_minimum_ptr_list<T> minima_sorted;
minima_sorted.reserve(minima_list.size());
for (auto& lm : minima_list) {
minima_sorted.push_back(&lm);
}
std::stable_sort(minima_sorted.begin(), minima_sorted.end(), local_minimum_sorter<T>());
local_minimum_ptr_list_itr<T> current_lm = minima_sorted.begin();
setup_scanbeam(minima_list, scanbeam);
// Estimate size for reserving hot pixels
std::size_t reserve = 0;
for (auto & lm : minima_list) {
reserve += lm.left_bound.edges.size() + 2;
reserve += lm.right_bound.edges.size() + 2;
}
rings.hot_pixels.reserve(reserve);
while (pop_from_scanbeam(scanline_y, scanbeam) || current_lm != minima_sorted.end()) {
process_hot_pixel_intersections(scanline_y, active_bounds, rings);
insert_local_minima_into_ABL_hot_pixel(scanline_y, minima_sorted, current_lm, active_bounds,
rings, scanbeam);
process_hot_pixel_edges_at_top_of_scanbeam(scanline_y, scanbeam, active_bounds, rings);
}
preallocate_point_memory(rings, rings.hot_pixels.size());
sort_hot_pixels(rings);
}
}
}
}

1933
mapbox/geometry/wagyu/topology_correction.hpp Normal file
View File

File diff suppressed because it is too large Load Diff

83
mapbox/geometry/wagyu/util.hpp Normal file
View File

@ -0,0 +1,83 @@
#pragma once
#include <cmath>
#include <mapbox/geometry/point.hpp>
#include <mapbox/geometry/polygon.hpp>
#include <mapbox/geometry/wagyu/point.hpp>
namespace mapbox {
namespace geometry {
namespace wagyu {
template <typename T>
double area(mapbox::geometry::linear_ring<T> const& poly) {
std::size_t size = poly.size();
if (size < 3) {
return 0.0;
}
double a = 0.0;
auto itr = poly.begin();
auto itr_prev = poly.end();
--itr_prev;
a += static_cast<double>(itr_prev->x + itr->x) * static_cast<double>(itr_prev->y - itr->y);
++itr;
itr_prev = poly.begin();
for (; itr != poly.end(); ++itr, ++itr_prev) {
a += static_cast<double>(itr_prev->x + itr->x) * static_cast<double>(itr_prev->y - itr->y);
}
return -a * 0.5;
}
inline bool value_is_zero(double val) {
return std::fabs(val) < std::numeric_limits<double>::epsilon();
}
inline bool values_are_equal(double x, double y) {
return value_is_zero(x - y);
}
inline bool values_near_equal(double x, double y) {
return std::fabs(x - y) < (5.0 * std::numeric_limits<double>::epsilon());
}
inline bool greater_than_or_equal(double x, double y) {
return x > y || values_are_equal(x, y);
}
inline bool less_than_or_equal(double x, double y) {
return x < y || values_are_equal(x, y);
}
template <typename T>
bool slopes_equal(mapbox::geometry::point<T> const& pt1,
mapbox::geometry::point<T> const& pt2,
mapbox::geometry::point<T> const& pt3) {
return (pt1.y - pt2.y) * (pt2.x - pt3.x) == (pt1.x - pt2.x) * (pt2.y - pt3.y);
}
template <typename T>
bool slopes_equal(mapbox::geometry::wagyu::point<T> const& pt1,
mapbox::geometry::wagyu::point<T> const& pt2,
mapbox::geometry::point<T> const& pt3) {
return (pt1.y - pt2.y) * (pt2.x - pt3.x) == (pt1.x - pt2.x) * (pt2.y - pt3.y);
}
template <typename T>
bool slopes_equal(mapbox::geometry::wagyu::point<T> const& pt1,
mapbox::geometry::wagyu::point<T> const& pt2,
mapbox::geometry::wagyu::point<T> const& pt3) {
return (pt1.y - pt2.y) * (pt2.x - pt3.x) == (pt1.x - pt2.x) * (pt2.y - pt3.y);
}
template <typename T>
bool slopes_equal(mapbox::geometry::point<T> const& pt1,
mapbox::geometry::point<T> const& pt2,
mapbox::geometry::point<T> const& pt3,
mapbox::geometry::point<T> const& pt4) {
return (pt1.y - pt2.y) * (pt3.x - pt4.x) == (pt1.x - pt2.x) * (pt3.y - pt4.y);
}
}
}
}

77
mapbox/geometry/wagyu/vatti.hpp Normal file
View File

@ -0,0 +1,77 @@
#pragma once
#include <algorithm>
#include <set>
#include <mapbox/geometry/wagyu/active_bound_list.hpp>
#include <mapbox/geometry/wagyu/config.hpp>
#include <mapbox/geometry/wagyu/exceptions.hpp>
#include <mapbox/geometry/wagyu/intersect_util.hpp>
#include <mapbox/geometry/wagyu/local_minimum.hpp>
#include <mapbox/geometry/wagyu/local_minimum_util.hpp>
#include <mapbox/geometry/wagyu/process_horizontal.hpp>
#include <mapbox/geometry/wagyu/process_maxima.hpp>
#include <mapbox/geometry/wagyu/ring.hpp>
#include <mapbox/geometry/wagyu/ring_util.hpp>
#include <mapbox/geometry/wagyu/util.hpp>
namespace mapbox {
namespace geometry {
namespace wagyu {
template <typename T>
bool execute_vatti(local_minimum_list<T>& minima_list,
ring_manager<T>& rings,
clip_type cliptype,
fill_type subject_fill_type,
fill_type clip_fill_type) {
if (minima_list.empty()) {
return false;
}
active_bound_list<T> active_bounds;
scanbeam_list<T> scanbeam;
T scanline_y = std::numeric_limits<T>::max();
local_minimum_ptr_list<T> minima_sorted;
minima_sorted.reserve(minima_list.size());
for (auto& lm : minima_list) {
minima_sorted.push_back(&lm);
}
std::stable_sort(minima_sorted.begin(), minima_sorted.end(), local_minimum_sorter<T>());
local_minimum_ptr_list_itr<T> current_lm = minima_sorted.begin();
// std::clog << output_all_edges(minima_sorted) << std::endl;
setup_scanbeam(minima_list, scanbeam);
rings.current_hp_itr = rings.hot_pixels.begin();
while (pop_from_scanbeam(scanline_y, scanbeam) || current_lm != minima_sorted.end()) {
process_intersections(scanline_y, active_bounds, cliptype,
subject_fill_type, clip_fill_type, rings);
update_current_hp_itr(scanline_y, rings);
// First we process bounds that has already been added to the active bound list --
// if the active bound list is empty local minima that are at this scanline_y and
// have a horizontal edge at the local minima will be processed
process_edges_at_top_of_scanbeam(scanline_y, active_bounds, scanbeam, minima_sorted,
current_lm, rings, cliptype, subject_fill_type,
clip_fill_type);
// Next we will add local minima bounds to the active bounds list that are on the local
// minima queue at
// this current scanline_y
insert_local_minima_into_ABL(scanline_y, minima_sorted, current_lm, active_bounds,
rings, scanbeam, cliptype, subject_fill_type,
clip_fill_type);
}
// std::clog << rings.rings << std::endl;
// std::clog << output_as_polygon(rings.all_rings[0]);
return true;
}
}
}
}

141
mapbox/geometry/wagyu/wagyu.hpp Normal file
View File

@ -0,0 +1,141 @@
#pragma once
#include <list>
#include <mapbox/geometry/box.hpp>
#include <mapbox/geometry/line_string.hpp>
#include <mapbox/geometry/multi_polygon.hpp>
#include <mapbox/geometry/polygon.hpp>
#include <mapbox/geometry/wagyu/build_result.hpp>
#include <mapbox/geometry/wagyu/build_local_minima_list.hpp>
#include <mapbox/geometry/wagyu/config.hpp>
#include <mapbox/geometry/wagyu/local_minimum.hpp>
#include <mapbox/geometry/wagyu/snap_rounding.hpp>
#include <mapbox/geometry/wagyu/topology_correction.hpp>
#include <mapbox/geometry/wagyu/vatti.hpp>
namespace mapbox {
namespace geometry {
namespace wagyu {
template <typename T>
class wagyu {
private:
using value_type = T;
local_minimum_list<value_type> minima_list;
bool has_open_paths;
bool reverse_output;
wagyu( wagyu const& ) = delete;
wagyu& operator=(wagyu const& ) = delete;
public:
wagyu() : minima_list(), has_open_paths(false), reverse_output(false) {
}
~wagyu() {
clear();
}
bool add_line(mapbox::geometry::line_string<value_type> const& pg) {
bool success = add_line_string(pg, minima_list);
if (success) {
has_open_paths = true;
}
return success;
}
bool add_ring(mapbox::geometry::linear_ring<value_type> const& pg,
polygon_type p_type = polygon_type_subject) {
return add_linear_ring(pg, minima_list, p_type);
}
bool add_polygon(mapbox::geometry::polygon<value_type> const& ppg,
polygon_type p_type = polygon_type_subject) {
bool result = false;
for (auto const& r : ppg) {
if (add_ring(r, p_type)) {
result = true;
}
}
return result;
}
void reverse_rings(bool value) {
reverse_output = value;
}
void clear() {
minima_list.clear();
has_open_paths = false;
}
mapbox::geometry::box<value_type> get_bounds() {
mapbox::geometry::point<value_type> min = { 0, 0 };
mapbox::geometry::point<value_type> max = { 0, 0 };
if (minima_list.empty()) {
return mapbox::geometry::box<value_type>(min, max);
}
bool first_set = false;
for (auto const& lm : minima_list) {
if (!lm.left_bound.edges.empty()) {
if (!first_set) {
min = lm.left_bound.edges.front().top;
max = lm.left_bound.edges.back().bot;
first_set = true;
} else {
min.y = std::min(min.y, lm.left_bound.edges.front().top.y);
max.y = std::max(max.y, lm.left_bound.edges.back().bot.y);
max.x = std::max(max.x, lm.left_bound.edges.back().top.x);
min.x = std::min(min.x, lm.left_bound.edges.back().top.x);
}
for (auto const& e : lm.left_bound.edges) {
max.x = std::max(max.x, e.bot.x);
min.x = std::min(min.x, e.bot.x);
}
}
if (!lm.right_bound.edges.empty()) {
if (!first_set) {
min = lm.right_bound.edges.front().top;
max = lm.right_bound.edges.back().bot;
first_set = true;
} else {
min.y = std::min(min.y, lm.right_bound.edges.front().top.y);
max.y = std::max(max.y, lm.right_bound.edges.back().bot.y);
max.x = std::max(max.x, lm.right_bound.edges.back().top.x);
min.x = std::min(min.x, lm.right_bound.edges.back().top.x);
}
for (auto const& e : lm.right_bound.edges) {
max.x = std::max(max.x, e.bot.x);
min.x = std::min(min.x, e.bot.x);
}
}
}
return mapbox::geometry::box<value_type>(min, max);
}
bool execute(clip_type cliptype,
mapbox::geometry::multi_polygon<value_type>& solution,
fill_type subject_fill_type,
fill_type clip_fill_type) {
ring_manager<T> rings;
build_hot_pixels(minima_list, rings);
if (!execute_vatti(minima_list, rings, cliptype, subject_fill_type, clip_fill_type)) {
return false;
}
do_simple_polygons(rings);
build_result(solution, rings, reverse_output);
return true;
}
};
}
}
}

74
mapbox/optional.hpp Normal file
View File

@ -0,0 +1,74 @@
#ifndef MAPBOX_UTIL_OPTIONAL_HPP
#define MAPBOX_UTIL_OPTIONAL_HPP
#pragma message("This implementation of optional is deprecated. See https://github.com/mapbox/variant/issues/64.")
#include <type_traits>
#include <utility>
#include <mapbox/variant.hpp>
namespace mapbox {
namespace util {
template <typename T>
class optional
{
static_assert(!std::is_reference<T>::value, "optional doesn't support references");
struct none_type
{
};
variant<none_type, T> variant_;
public:
optional() = default;
optional(optional const& rhs)
{
if (this != &rhs)
{ // protect against invalid self-assignment
variant_ = rhs.variant_;
}
}
optional(T const& v) { variant_ = v; }
explicit operator bool() const noexcept { return variant_.template is<T>(); }
T const& get() const { return variant_.template get<T>(); }
T& get() { return variant_.template get<T>(); }
T const& operator*() const { return this->get(); }
T operator*() { return this->get(); }
optional& operator=(T const& v)
{
variant_ = v;
return *this;
}
optional& operator=(optional const& rhs)
{
if (this != &rhs)
{
variant_ = rhs.variant_;
}
return *this;
}
template <typename... Args>
void emplace(Args&&... args)
{
variant_ = T{std::forward<Args>(args)...};
}
void reset() { variant_ = none_type{}; }
}; // class optional
} // namespace util
} // namespace mapbox
#endif // MAPBOX_UTIL_OPTIONAL_HPP

122
mapbox/recursive_wrapper.hpp Normal file
View File

@ -0,0 +1,122 @@
#ifndef MAPBOX_UTIL_RECURSIVE_WRAPPER_HPP
#define MAPBOX_UTIL_RECURSIVE_WRAPPER_HPP
// Based on variant/recursive_wrapper.hpp from boost.
//
// Original license:
//
// Copyright (c) 2002-2003
// Eric Friedman, Itay Maman
//
// Distributed under the Boost Software License, Version 1.0. (See
// accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
#include <cassert>
#include <utility>
namespace mapbox {
namespace util {
template <typename T>
class recursive_wrapper
{
T* p_;
void assign(T const& rhs)
{
this->get() = rhs;
}
public:
using type = T;
/**
* Default constructor default initializes the internally stored value.
* For POD types this means nothing is done and the storage is
* uninitialized.
*
* @throws std::bad_alloc if there is insufficient memory for an object
* of type T.
* @throws any exception thrown by the default constructur of T.
*/
recursive_wrapper()
: p_(new T){}
~recursive_wrapper() noexcept { delete p_; }
recursive_wrapper(recursive_wrapper const& operand)
: p_(new T(operand.get())) {}
recursive_wrapper(T const& operand)
: p_(new T(operand)) {}
recursive_wrapper(recursive_wrapper&& operand)
: p_(new T(std::move(operand.get()))) {}
recursive_wrapper(T&& operand)
: p_(new T(std::move(operand))) {}
inline recursive_wrapper& operator=(recursive_wrapper const& rhs)
{
assign(rhs.get());
return *this;
}
inline recursive_wrapper& operator=(T const& rhs)
{
assign(rhs);
return *this;
}
inline void swap(recursive_wrapper& operand) noexcept
{
T* temp = operand.p_;
operand.p_ = p_;
p_ = temp;
}
recursive_wrapper& operator=(recursive_wrapper&& rhs) noexcept
{
swap(rhs);
return *this;
}
recursive_wrapper& operator=(T&& rhs)
{
get() = std::move(rhs);
return *this;
}
T& get()
{
assert(p_);
return *get_pointer();
}
T const& get() const
{
assert(p_);
return *get_pointer();
}
T* get_pointer() { return p_; }
const T* get_pointer() const { return p_; }
operator T const&() const { return this->get(); }
operator T&() { return this->get(); }
}; // class recursive_wrapper
template <typename T>
inline void swap(recursive_wrapper<T>& lhs, recursive_wrapper<T>& rhs) noexcept
{
lhs.swap(rhs);
}
} // namespace util
} // namespace mapbox
#endif // MAPBOX_UTIL_RECURSIVE_WRAPPER_HPP

1013
mapbox/variant.hpp Normal file
View File

File diff suppressed because it is too large Load Diff

45
mapbox/variant_io.hpp Normal file
View File

@ -0,0 +1,45 @@
#ifndef MAPBOX_UTIL_VARIANT_IO_HPP
#define MAPBOX_UTIL_VARIANT_IO_HPP
#include <iosfwd>
#include <mapbox/variant.hpp>
namespace mapbox {
namespace util {
namespace detail {
// operator<< helper
template <typename Out>
class printer
{
public:
explicit printer(Out& out)
: out_(out) {}
printer& operator=(printer const&) = delete;
// visitor
template <typename T>
void operator()(T const& operand) const
{
out_ << operand;
}
private:
Out& out_;
};
}
// operator<<
template <typename CharT, typename Traits, typename... Types>
VARIANT_INLINE std::basic_ostream<CharT, Traits>&
operator<<(std::basic_ostream<CharT, Traits>& out, variant<Types...> const& rhs)
{
detail::printer<std::basic_ostream<CharT, Traits>> visitor(out);
apply_visitor(visitor, rhs);
return out;
}
} // namespace util
} // namespace mapbox
#endif // MAPBOX_UTIL_VARIANT_IO_HPP

38
mapbox/variant_visitor.hpp Normal file
View File

@ -0,0 +1,38 @@
#ifndef MAPBOX_UTIL_VARIANT_VISITOR_HPP
#define MAPBOX_UTIL_VARIANT_VISITOR_HPP
namespace mapbox {
namespace util {
template <typename... Fns>
struct visitor;
template <typename Fn>
struct visitor<Fn> : Fn
{
using type = Fn;
using Fn::operator();
visitor(Fn fn) : Fn(fn) {}
};
template <typename Fn, typename... Fns>
struct visitor<Fn, Fns...> : Fn, visitor<Fns...>
{
using type = visitor;
using Fn::operator();
using visitor<Fns...>::operator();
visitor(Fn fn, Fns... fns) : Fn(fn), visitor<Fns...>(fns...) {}
};
template <typename... Fns>
visitor<Fns...> make_visitor(Fns... fns)
{
return visitor<Fns...>(fns...);
}
} // namespace util
} // namespace mapbox
#endif // MAPBOX_UTIL_VARIANT_VISITOR_HPP

32
tests/border/out/-z1_--detect-shared-borders.json
View File

File diff suppressed because one or more lines are too long

54
tests/curve/out/-z2.json
View File

@ -12,119 +12,119 @@
}, "features": [
{ "type": "FeatureCollection", "properties": { "zoom": 0, "x": 0, "y": 0 }, "features": [
{ "type": "FeatureCollection", "properties": { "layer": "in", "version": 2, "extent": 4096 }, "features": [
{ "type": "Feature", "properties": { }, "geometry": { "type": "Polygon", "coordinates": [ [ [ -82.001953, 82.009169 ], [ -106.083984, 70.020587 ], [ -103.007812, 32.026706 ], [ -82.001953, -32.990236 ], [ -63.017578, -62.995158 ], [ -28.037109, -72.996909 ], [ 90.000000, -73.995328 ], [ 144.931641, -73.995328 ], [ 144.931641, -76.999935 ], [ 92.988281, -78.988187 ], [ -33.046875, -76.999935 ], [ -75.058594, -65.982270 ], [ -97.031250, -37.996163 ], [ -118.037109, 26.037042 ], [ -117.070312, 71.016960 ], [ -99.052734, 83.004844 ], [ -82.001953, 82.009169 ] ] ] } }
{ "type": "Feature", "properties": { }, "geometry": { "type": "Polygon", "coordinates": [ [ [ -99.052734, 83.004844 ], [ -82.001953, 82.009169 ], [ -106.083984, 70.020587 ], [ -103.007812, 32.026706 ], [ -82.001953, -32.990236 ], [ -63.017578, -62.995158 ], [ -28.037109, -72.996909 ], [ 90.000000, -73.995328 ], [ 144.931641, -73.995328 ], [ 144.931641, -76.999935 ], [ 92.988281, -78.988187 ], [ -33.046875, -76.999935 ], [ -75.058594, -65.982270 ], [ -97.031250, -37.996163 ], [ -118.037109, 26.037042 ], [ -117.070312, 71.016960 ], [ -99.052734, 83.004844 ] ] ] } }
,
{ "type": "Feature", "properties": { }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 135.000000, 80.012423 ], [ -88.066406, 80.012423 ], [ -119.003906, 71.016960 ], [ -112.060547, -74.982183 ], [ -92.021484, -76.999935 ], [ 169.980469, -79.997168 ], [ 159.960938, -81.996942 ], [ -111.005859, -81.996942 ], [ -139.042969, -75.994839 ], [ -139.042969, 74.019543 ], [ -101.074219, 83.004844 ], [ 108.984375, 83.004844 ], [ 135.000000, 80.012423 ] ] ] } }
{ "type": "Feature", "properties": { }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 108.984375, 83.004844 ], [ 135.000000, 80.012423 ], [ -88.066406, 80.012423 ], [ -119.003906, 71.016960 ], [ -112.060547, -74.982183 ], [ -92.021484, -76.999935 ], [ 169.980469, -79.997168 ], [ 159.960938, -81.996942 ], [ -111.005859, -81.996942 ], [ -139.042969, -75.994839 ], [ -139.042969, 74.019543 ], [ -101.074219, 83.004844 ], [ 108.984375, 83.004844 ] ] ] } }
] }
] }
,
{ "type": "FeatureCollection", "properties": { "zoom": 1, "x": 0, "y": 1 }, "features": [
{ "type": "FeatureCollection", "properties": { "layer": "in", "version": 2, "extent": 4096 }, "features": [
{ "type": "Feature", "properties": { }, "geometry": { "type": "Polygon", "coordinates": [ [ [ -92.724609, 0.000000 ], [ -82.001953, -32.990236 ], [ -63.017578, -62.995158 ], [ -28.037109, -72.996909 ], [ 0.000000, -73.226700 ], [ 3.515625, -73.264704 ], [ 3.515625, -77.608282 ], [ 0.000000, -77.551572 ], [ -33.002930, -76.999935 ], [ -75.014648, -65.982270 ], [ -97.031250, -37.996163 ], [ -109.731445, 0.000000 ], [ -110.786133, 3.513421 ], [ -93.779297, 3.513421 ], [ -92.724609, 0.000000 ] ] ] } }
{ "type": "Feature", "properties": { }, "geometry": { "type": "Polygon", "coordinates": [ [ [ -93.779297, 3.513421 ], [ -92.724609, 0.000000 ], [ -82.001953, -32.990236 ], [ -63.017578, -62.995158 ], [ -28.037109, -72.996909 ], [ 0.000000, -73.226700 ], [ 3.515625, -73.264704 ], [ 3.515625, -77.608282 ], [ 0.000000, -77.551572 ], [ -33.002930, -76.999935 ], [ -75.014648, -65.982270 ], [ -97.031250, -37.996163 ], [ -109.731445, 0.000000 ], [ -110.786133, 3.513421 ], [ -93.779297, 3.513421 ] ] ] } }
,
{ "type": "Feature", "properties": { }, "geometry": { "type": "Polygon", "coordinates": [ [ [ -115.751953, 0.000000 ], [ -112.016602, -74.993566 ], [ -92.021484, -76.999935 ], [ 0.000000, -78.134493 ], [ 3.515625, -78.179588 ], [ 3.515625, -81.996942 ], [ -111.005859, -81.996942 ], [ -139.042969, -75.994839 ], [ -139.042969, 3.513421 ], [ -115.883789, 3.513421 ], [ -115.751953, 0.000000 ] ] ] } }
{ "type": "Feature", "properties": { }, "geometry": { "type": "Polygon", "coordinates": [ [ [ -115.883789, 3.513421 ], [ -115.751953, 0.000000 ], [ -112.016602, -74.993566 ], [ -92.021484, -76.999935 ], [ 0.000000, -78.134493 ], [ 3.515625, -78.179588 ], [ 3.515625, -81.996942 ], [ -111.005859, -81.996942 ], [ -139.042969, -75.994839 ], [ -139.042969, 3.513421 ], [ -115.883789, 3.513421 ] ] ] } }
] }
] }
,
{ "type": "FeatureCollection", "properties": { "zoom": 1, "x": 0, "y": 0 }, "features": [
{ "type": "FeatureCollection", "properties": { "layer": "in", "version": 2, "extent": 4096 }, "features": [
{ "type": "Feature", "properties": { }, "geometry": { "type": "Polygon", "coordinates": [ [ [ -82.001953, 82.003058 ], [ -106.040039, 70.005567 ], [ -103.007812, 32.026706 ], [ -92.724609, 0.000000 ], [ -91.625977, -3.513421 ], [ -108.632812, -3.513421 ], [ -109.731445, 0.000000 ], [ -118.037109, 26.037042 ], [ -117.026367, 71.002660 ], [ -99.008789, 83.004844 ], [ -82.001953, 82.003058 ] ] ] } }
{ "type": "Feature", "properties": { }, "geometry": { "type": "Polygon", "coordinates": [ [ [ -99.008789, 83.004844 ], [ -82.001953, 82.003058 ], [ -106.040039, 70.005567 ], [ -103.007812, 32.026706 ], [ -92.724609, 0.000000 ], [ -91.625977, -3.513421 ], [ -108.632812, -3.513421 ], [ -109.731445, 0.000000 ], [ -118.037109, 26.037042 ], [ -117.026367, 71.002660 ], [ -99.008789, 83.004844 ] ] ] } }
,
{ "type": "Feature", "properties": { }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 3.515625, 80.004799 ], [ -88.022461, 80.004799 ], [ -119.003906, 71.002660 ], [ -115.751953, 0.000000 ], [ -115.620117, -3.513421 ], [ -139.042969, -3.513421 ], [ -139.042969, 74.007440 ], [ -101.030273, 83.004844 ], [ 3.515625, 83.004844 ], [ 3.515625, 80.004799 ] ] ] } }
{ "type": "Feature", "properties": { }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 0.000000, 83.004844 ], [ 3.515625, 80.004799 ], [ -88.022461, 80.004799 ], [ -119.003906, 71.002660 ], [ -115.751953, 0.000000 ], [ -115.620117, -3.513421 ], [ -139.042969, -3.513421 ], [ -139.042969, 74.007440 ], [ -101.030273, 83.004844 ], [ 0.000000, 83.004844 ] ] ] } }
] }
] }
,
{ "type": "FeatureCollection", "properties": { "zoom": 1, "x": 1, "y": 1 }, "features": [
{ "type": "FeatureCollection", "properties": { "layer": "in", "version": 2, "extent": 4096 }, "features": [
{ "type": "Feature", "properties": { }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 0.000000, -73.226700 ], [ 90.000000, -73.995328 ], [ 144.975586, -73.995328 ], [ 144.975586, -76.999935 ], [ 92.988281, -78.996578 ], [ 0.000000, -77.551572 ], [ -3.515625, -77.494607 ], [ -3.515625, -73.201317 ], [ 0.000000, -73.226700 ] ] ] } }
{ "type": "Feature", "properties": { }, "geometry": { "type": "Polygon", "coordinates": [ [ [ -3.515625, -73.201317 ], [ 0.000000, -73.226700 ], [ 90.000000, -73.995328 ], [ 144.975586, -73.995328 ], [ 144.975586, -76.999935 ], [ 92.988281, -78.996578 ], [ 0.000000, -77.551572 ], [ -3.515625, -77.494607 ], [ -3.515625, -73.201317 ] ] ] } }
,
{ "type": "Feature", "properties": { }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 0.000000, -78.134493 ], [ 169.980469, -79.997168 ], [ 159.960938, -81.996942 ], [ -3.515625, -81.996942 ], [ -3.515625, -78.098296 ], [ 0.000000, -78.134493 ] ] ] } }
{ "type": "Feature", "properties": { }, "geometry": { "type": "Polygon", "coordinates": [ [ [ -3.515625, -78.098296 ], [ 0.000000, -78.134493 ], [ 169.980469, -79.997168 ], [ 159.960938, -81.996942 ], [ -3.515625, -81.996942 ], [ -3.515625, -78.098296 ] ] ] } }
] }
] }
,
{ "type": "FeatureCollection", "properties": { "zoom": 1, "x": 1, "y": 0 }, "features": [
{ "type": "FeatureCollection", "properties": { "layer": "in", "version": 2, "extent": 4096 }, "features": [
{ "type": "Feature", "properties": { }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 135.000000, 80.004799 ], [ -3.515625, 80.004799 ], [ -3.515625, 83.004844 ], [ 108.984375, 83.004844 ], [ 135.000000, 80.004799 ] ] ] } }
{ "type": "Feature", "properties": { }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 108.984375, 83.004844 ], [ 135.000000, 80.004799 ], [ -3.515625, 80.004799 ], [ -3.515625, 83.004844 ], [ 108.984375, 83.004844 ] ] ] } }
] }
] }
,
{ "type": "FeatureCollection", "properties": { "zoom": 2, "x": 0, "y": 3 }, "features": [
{ "type": "FeatureCollection", "properties": { "layer": "in", "version": 2, "extent": 4096 }, "features": [
{ "type": "Feature", "properties": { }, "geometry": { "type": "Polygon", "coordinates": [ [ [ -112.873535, -66.513260 ], [ -112.016602, -74.999254 ], [ -92.021484, -76.999935 ], [ -90.000000, -77.024626 ], [ -88.242188, -77.044346 ], [ -88.242188, -81.996942 ], [ -111.005859, -81.996942 ], [ -139.020996, -75.994839 ], [ -139.020996, -65.802776 ], [ -112.917480, -65.802776 ], [ -112.873535, -66.513260 ] ] ] } }
{ "type": "Feature", "properties": { }, "geometry": { "type": "Polygon", "coordinates": [ [ [ -112.917480, -65.802776 ], [ -112.873535, -66.513260 ], [ -112.016602, -74.999254 ], [ -92.021484, -76.999935 ], [ -90.000000, -77.024626 ], [ -88.242188, -77.044346 ], [ -88.242188, -81.996942 ], [ -111.005859, -81.996942 ], [ -139.020996, -75.994839 ], [ -139.020996, -65.802776 ], [ -112.917480, -65.802776 ] ] ] } }
] }
] }
,
{ "type": "FeatureCollection", "properties": { "zoom": 2, "x": 0, "y": 2 }, "features": [
{ "type": "FeatureCollection", "properties": { "layer": "in", "version": 2, "extent": 4096 }, "features": [
{ "type": "Feature", "properties": { }, "geometry": { "type": "Polygon", "coordinates": [ [ [ -92.702637, 0.000000 ], [ -90.000000, -8.733077 ], [ -88.242188, -14.370834 ], [ -88.242188, -51.371780 ], [ -90.000000, -48.936935 ], [ -97.009277, -37.996163 ], [ -109.709473, 0.000000 ], [ -110.258789, 1.757537 ], [ -93.229980, 1.757537 ], [ -92.702637, 0.000000 ] ] ] } }
{ "type": "Feature", "properties": { }, "geometry": { "type": "Polygon", "coordinates": [ [ [ -93.229980, 1.757537 ], [ -92.702637, 0.000000 ], [ -90.000000, -8.733077 ], [ -88.242188, -14.370834 ], [ -88.242188, -51.371780 ], [ -90.000000, -48.936935 ], [ -97.009277, -37.996163 ], [ -109.709473, 0.000000 ], [ -110.258789, 1.757537 ], [ -93.229980, 1.757537 ] ] ] } }
,
{ "type": "Feature", "properties": { }, "geometry": { "type": "Polygon", "coordinates": [ [ [ -115.751953, 0.000000 ], [ -112.873535, -66.513260 ], [ -112.807617, -67.204032 ], [ -139.020996, -67.204032 ], [ -139.020996, 1.757537 ], [ -115.817871, 1.757537 ], [ -115.751953, 0.000000 ] ] ] } }
{ "type": "Feature", "properties": { }, "geometry": { "type": "Polygon", "coordinates": [ [ [ -115.817871, 1.757537 ], [ -115.751953, 0.000000 ], [ -112.873535, -66.513260 ], [ -112.807617, -67.204032 ], [ -139.020996, -67.204032 ], [ -139.020996, 1.757537 ], [ -115.817871, 1.757537 ] ] ] } }
] }
] }
,
{ "type": "FeatureCollection", "properties": { "zoom": 2, "x": 0, "y": 1 }, "features": [
{ "type": "FeatureCollection", "properties": { "layer": "in", "version": 2, "extent": 4096 }, "features": [
{ "type": "Feature", "properties": { }, "geometry": { "type": "Polygon", "coordinates": [ [ [ -105.600586, 66.513260 ], [ -103.007812, 32.008076 ], [ -92.702637, 0.000000 ], [ -92.175293, -1.757537 ], [ -109.182129, -1.757537 ], [ -109.731445, 0.000000 ], [ -118.015137, 26.017298 ], [ -117.180176, 66.513260 ], [ -117.158203, 67.204032 ], [ -105.666504, 67.204032 ], [ -105.600586, 66.513260 ] ] ] } }
{ "type": "Feature", "properties": { }, "geometry": { "type": "Polygon", "coordinates": [ [ [ -105.666504, 67.204032 ], [ -105.600586, 66.513260 ], [ -103.007812, 32.008076 ], [ -92.702637, 0.000000 ], [ -92.175293, -1.757537 ], [ -109.182129, -1.757537 ], [ -109.731445, 0.000000 ], [ -118.015137, 26.017298 ], [ -117.180176, 66.513260 ], [ -117.158203, 67.204032 ], [ -105.666504, 67.204032 ] ] ] } }
,
{ "type": "Feature", "properties": { }, "geometry": { "type": "Polygon", "coordinates": [ [ [ -118.608398, 66.513260 ], [ -115.751953, 0.000000 ], [ -115.686035, -1.757537 ], [ -139.020996, -1.757537 ], [ -139.020996, 67.204032 ], [ -118.674316, 67.204032 ], [ -118.608398, 66.513260 ] ] ] } }
{ "type": "Feature", "properties": { }, "geometry": { "type": "Polygon", "coordinates": [ [ [ -118.674316, 67.204032 ], [ -118.608398, 66.513260 ], [ -115.751953, 0.000000 ], [ -115.686035, -1.757537 ], [ -139.020996, -1.757537 ], [ -139.020996, 67.204032 ], [ -118.674316, 67.204032 ] ] ] } }
] }
] }
,
{ "type": "FeatureCollection", "properties": { "zoom": 2, "x": 0, "y": 0 }, "features": [
{ "type": "FeatureCollection", "properties": { "layer": "in", "version": 2, "extent": 4096 }, "features": [
{ "type": "Feature", "properties": { }, "geometry": { "type": "Polygon", "coordinates": [ [ [ -90.000000, 82.489081 ], [ -88.242188, 82.384973 ], [ -88.242188, 79.839471 ], [ -90.000000, 79.134119 ], [ -106.018066, 70.005567 ], [ -105.600586, 66.513260 ], [ -105.512695, 65.802776 ], [ -117.202148, 65.802776 ], [ -117.180176, 66.513260 ], [ -117.004395, 71.002660 ], [ -99.008789, 83.002167 ], [ -90.000000, 82.489081 ] ] ] } }
{ "type": "Feature", "properties": { }, "geometry": { "type": "Polygon", "coordinates": [ [ [ -99.008789, 83.002167 ], [ -90.000000, 82.489081 ], [ -88.242188, 82.384973 ], [ -88.242188, 79.839471 ], [ -90.000000, 79.134119 ], [ -106.018066, 70.005567 ], [ -105.600586, 66.513260 ], [ -105.512695, 65.802776 ], [ -117.202148, 65.802776 ], [ -117.180176, 66.513260 ], [ -117.004395, 71.002660 ], [ -99.008789, 83.002167 ] ] ] } }
,
{ "type": "Feature", "properties": { }, "geometry": { "type": "Polygon", "coordinates": [ [ [ -88.242188, 79.951265 ], [ -90.000000, 79.576460 ], [ -119.003906, 71.002660 ], [ -118.608398, 66.513260 ], [ -118.564453, 65.802776 ], [ -139.020996, 65.802776 ], [ -139.020996, 74.001385 ], [ -101.008301, 83.002167 ], [ -88.242188, 83.002167 ], [ -88.242188, 79.951265 ] ] ] } }
{ "type": "Feature", "properties": { }, "geometry": { "type": "Polygon", "coordinates": [ [ [ -88.242188, 83.002167 ], [ -88.242188, 79.951265 ], [ -90.000000, 79.576460 ], [ -119.003906, 71.002660 ], [ -118.608398, 66.513260 ], [ -118.564453, 65.802776 ], [ -139.020996, 65.802776 ], [ -139.020996, 74.001385 ], [ -101.008301, 83.002167 ], [ -88.242188, 83.002167 ] ] ] } }
] }
] }
,
{ "type": "FeatureCollection", "properties": { "zoom": 2, "x": 1, "y": 3 }, "features": [
{ "type": "FeatureCollection", "properties": { "layer": "in", "version": 2, "extent": 4096 }, "features": [
{ "type": "Feature", "properties": { }, "geometry": { "type": "Polygon", "coordinates": [ [ [ -52.382812, -66.513260 ], [ -28.015137, -72.996909 ], [ 0.000000, -73.233040 ], [ 1.757812, -73.245712 ], [ 1.757812, -77.575232 ], [ 0.000000, -77.546835 ], [ -33.002930, -76.999935 ], [ -73.498535, -66.513260 ], [ -75.014648, -65.991212 ], [ -75.234375, -65.802776 ], [ -54.645996, -65.802776 ], [ -52.382812, -66.513260 ] ] ] } }
{ "type": "Feature", "properties": { }, "geometry": { "type": "Polygon", "coordinates": [ [ [ -54.645996, -65.802776 ], [ -52.382812, -66.513260 ], [ -28.015137, -72.996909 ], [ 0.000000, -73.233040 ], [ 1.757812, -73.245712 ], [ 1.757812, -77.575232 ], [ 0.000000, -77.546835 ], [ -33.002930, -76.999935 ], [ -73.498535, -66.513260 ], [ -75.014648, -65.991212 ], [ -75.234375, -65.802776 ], [ -54.645996, -65.802776 ] ] ] } }
,
{ "type": "Feature", "properties": { }, "geometry": { "type": "Polygon", "coordinates": [ [ [ -90.000000, -77.024626 ], [ 0.000000, -78.134493 ], [ 1.757812, -78.157062 ], [ 1.757812, -81.996942 ], [ -91.757812, -81.996942 ], [ -91.757812, -76.999935 ], [ -90.000000, -77.024626 ] ] ] } }
{ "type": "Feature", "properties": { }, "geometry": { "type": "Polygon", "coordinates": [ [ [ -91.757812, -76.999935 ], [ -90.000000, -77.024626 ], [ 0.000000, -78.134493 ], [ 1.757812, -78.157062 ], [ 1.757812, -81.996942 ], [ -91.757812, -81.996942 ], [ -91.757812, -76.999935 ] ] ] } }
] }
] }
,
{ "type": "FeatureCollection", "properties": { "zoom": 2, "x": 1, "y": 2 }, "features": [
{ "type": "FeatureCollection", "properties": { "layer": "in", "version": 2, "extent": 4096 }, "features": [
{ "type": "Feature", "properties": { }, "geometry": { "type": "Polygon", "coordinates": [ [ [ -90.000000, -8.733077 ], [ -82.001953, -32.990236 ], [ -63.017578, -62.995158 ], [ -52.382812, -66.513260 ], [ -50.119629, -67.204032 ], [ -71.433105, -67.204032 ], [ -73.498535, -66.513260 ], [ -75.014648, -65.991212 ], [ -90.000000, -48.936935 ], [ -91.757812, -46.377254 ], [ -91.757812, -3.030812 ], [ -90.000000, -8.733077 ] ] ] } }
{ "type": "Feature", "properties": { }, "geometry": { "type": "Polygon", "coordinates": [ [ [ -91.757812, -3.030812 ], [ -90.000000, -8.733077 ], [ -82.001953, -32.990236 ], [ -63.017578, -62.995158 ], [ -52.382812, -66.513260 ], [ -50.119629, -67.204032 ], [ -71.433105, -67.204032 ], [ -73.498535, -66.513260 ], [ -75.014648, -65.991212 ], [ -90.000000, -48.936935 ], [ -91.757812, -46.377254 ], [ -91.757812, -3.030812 ] ] ] } }
] }
] }
,
{ "type": "FeatureCollection", "properties": { "zoom": 2, "x": 1, "y": 0 }, "features": [
{ "type": "FeatureCollection", "properties": { "layer": "in", "version": 2, "extent": 4096 }, "features": [
{ "type": "Feature", "properties": { }, "geometry": { "type": "Polygon", "coordinates": [ [ [ -90.000000, 82.489081 ], [ -82.001953, 82.000000 ], [ -90.000000, 79.134119 ], [ -91.757812, 78.376004 ], [ -91.757812, 82.591775 ], [ -90.000000, 82.489081 ] ] ] } }
{ "type": "Feature", "properties": { }, "geometry": { "type": "Polygon", "coordinates": [ [ [ -91.757812, 82.591775 ], [ -90.000000, 82.489081 ], [ -82.001953, 82.000000 ], [ -90.000000, 79.134119 ], [ -91.757812, 78.376004 ], [ -91.757812, 82.591775 ] ] ] } }
,
{ "type": "Feature", "properties": { }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 1.757812, 80.000984 ], [ -88.000488, 80.000984 ], [ -90.000000, 79.576460 ], [ -91.757812, 79.191956 ], [ -91.757812, 83.002167 ], [ 1.757812, 83.002167 ], [ 1.757812, 80.000984 ] ] ] } }
{ "type": "Feature", "properties": { }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 0.000000, 83.002167 ], [ 1.757812, 80.000984 ], [ -88.000488, 80.000984 ], [ -90.000000, 79.576460 ], [ -91.757812, 79.191956 ], [ -91.757812, 83.002167 ], [ 0.000000, 83.002167 ] ] ] } }
] }
] }
,
{ "type": "FeatureCollection", "properties": { "zoom": 2, "x": 2, "y": 3 }, "features": [
{ "type": "FeatureCollection", "properties": { "layer": "in", "version": 2, "extent": 4096 }, "features": [
{ "type": "Feature", "properties": { }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 0.000000, -73.233040 ], [ 90.000000, -73.995328 ], [ 91.757812, -73.995328 ], [ 91.757812, -78.975588 ], [ 90.000000, -78.950349 ], [ 0.000000, -77.551572 ], [ -1.757812, -77.523122 ], [ -1.757812, -73.220358 ], [ 0.000000, -73.233040 ] ] ] } }
{ "type": "Feature", "properties": { }, "geometry": { "type": "Polygon", "coordinates": [ [ [ -1.757812, -73.220358 ], [ 0.000000, -73.233040 ], [ 90.000000, -73.995328 ], [ 91.757812, -73.995328 ], [ 91.757812, -78.975588 ], [ 90.000000, -78.950349 ], [ 0.000000, -77.551572 ], [ -1.757812, -77.523122 ], [ -1.757812, -73.220358 ] ] ] } }
,
{ "type": "Feature", "properties": { }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 0.000000, -78.139010 ], [ 90.000000, -79.158943 ], [ 91.757812, -79.179588 ], [ 91.757812, -81.996942 ], [ -1.757812, -81.996942 ], [ -1.757812, -78.116408 ], [ 0.000000, -78.139010 ] ] ] } }
{ "type": "Feature", "properties": { }, "geometry": { "type": "Polygon", "coordinates": [ [ [ -1.757812, -78.116408 ], [ 0.000000, -78.139010 ], [ 90.000000, -79.158943 ], [ 91.757812, -79.179588 ], [ 91.757812, -81.996942 ], [ -1.757812, -81.996942 ], [ -1.757812, -78.116408 ] ] ] } }
] }
] }
,
{ "type": "FeatureCollection", "properties": { "zoom": 2, "x": 2, "y": 0 }, "features": [
{ "type": "FeatureCollection", "properties": { "layer": "in", "version": 2, "extent": 4096 }, "features": [
{ "type": "Feature", "properties": { }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 91.757812, 80.000984 ], [ -1.757812, 80.000984 ], [ -1.757812, 83.002167 ], [ 91.757812, 83.002167 ], [ 91.757812, 80.000984 ] ] ] } }
{ "type": "Feature", "properties": { }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 0.000000, 83.002167 ], [ 91.757812, 80.000984 ], [ -1.757812, 80.000984 ], [ -1.757812, 83.002167 ], [ 0.000000, 83.002167 ] ] ] } }
] }
] }
,
{ "type": "FeatureCollection", "properties": { "zoom": 2, "x": 3, "y": 3 }, "features": [
{ "type": "FeatureCollection", "properties": { "layer": "in", "version": 2, "extent": 4096 }, "features": [
{ "type": "Feature", "properties": { }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 90.000000, -73.995328 ], [ 144.997559, -73.995328 ], [ 144.997559, -76.999935 ], [ 92.988281, -78.996578 ], [ 90.000000, -78.950349 ], [ 88.242188, -78.925053 ], [ 88.242188, -73.977144 ], [ 90.000000, -73.995328 ] ] ] } }
{ "type": "Feature", "properties": { }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 88.242188, -73.977144 ], [ 90.000000, -73.995328 ], [ 144.997559, -73.995328 ], [ 144.997559, -76.999935 ], [ 92.988281, -78.996578 ], [ 90.000000, -78.950349 ], [ 88.242188, -78.925053 ], [ 88.242188, -73.977144 ] ] ] } }
,
{ "type": "Feature", "properties": { }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 90.000000, -79.158943 ], [ 169.980469, -79.997168 ], [ 159.982910, -81.996942 ], [ 88.242188, -81.996942 ], [ 88.242188, -79.142400 ], [ 90.000000, -79.158943 ] ] ] } }
{ "type": "Feature", "properties": { }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 88.242188, -79.142400 ], [ 90.000000, -79.158943 ], [ 169.980469, -79.997168 ], [ 159.982910, -81.996942 ], [ 88.242188, -81.996942 ], [ 88.242188, -79.142400 ] ] ] } }
] }
] }
,
{ "type": "FeatureCollection", "properties": { "zoom": 2, "x": 3, "y": 0 }, "features": [
{ "type": "FeatureCollection", "properties": { "layer": "in", "version": 2, "extent": 4096 }, "features": [
{ "type": "Feature", "properties": { }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 135.000000, 80.000984 ], [ 88.242188, 80.000984 ], [ 88.242188, 83.002167 ], [ 108.984375, 83.002167 ], [ 135.000000, 80.000984 ] ] ] } }
{ "type": "Feature", "properties": { }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 108.984375, 83.002167 ], [ 135.000000, 80.000984 ], [ 88.242188, 80.000984 ], [ 88.242188, 83.002167 ], [ 108.984375, 83.002167 ] ] ] } }
] }
] }
] }

54
tests/curve/out/-z2_--no-clipping.json
View File

@ -12,119 +12,119 @@
}, "features": [
{ "type": "FeatureCollection", "properties": { "zoom": 0, "x": 0, "y": 0 }, "features": [
{ "type": "FeatureCollection", "properties": { "layer": "in", "version": 2, "extent": 4096 }, "features": [
{ "type": "Feature", "properties": { }, "geometry": { "type": "Polygon", "coordinates": [ [ [ -82.001953, 82.009169 ], [ -106.083984, 70.020587 ], [ -103.007812, 32.026706 ], [ -82.001953, -32.990236 ], [ -63.017578, -62.995158 ], [ -28.037109, -72.996909 ], [ 90.000000, -73.995328 ], [ 144.931641, -73.995328 ], [ 144.931641, -76.999935 ], [ 92.988281, -78.988187 ], [ -33.046875, -76.999935 ], [ -75.058594, -65.982270 ], [ -97.031250, -37.996163 ], [ -118.037109, 26.037042 ], [ -117.070312, 71.016960 ], [ -99.052734, 83.004844 ], [ -82.001953, 82.009169 ] ] ] } }
{ "type": "Feature", "properties": { }, "geometry": { "type": "Polygon", "coordinates": [ [ [ -99.052734, 83.004844 ], [ -82.001953, 82.009169 ], [ -106.083984, 70.020587 ], [ -103.007812, 32.026706 ], [ -82.001953, -32.990236 ], [ -63.017578, -62.995158 ], [ -28.037109, -72.996909 ], [ 90.000000, -73.995328 ], [ 144.931641, -73.995328 ], [ 144.931641, -76.999935 ], [ 92.988281, -78.988187 ], [ -33.046875, -76.999935 ], [ -75.058594, -65.982270 ], [ -97.031250, -37.996163 ], [ -118.037109, 26.037042 ], [ -117.070312, 71.016960 ], [ -99.052734, 83.004844 ] ] ] } }
,
{ "type": "Feature", "properties": { }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 135.000000, 80.012423 ], [ -88.066406, 80.012423 ], [ -119.003906, 71.016960 ], [ -112.060547, -74.982183 ], [ -92.021484, -76.999935 ], [ 169.980469, -79.997168 ], [ 159.960938, -81.996942 ], [ -111.005859, -81.996942 ], [ -139.042969, -75.994839 ], [ -139.042969, 74.019543 ], [ -101.074219, 83.004844 ], [ 108.984375, 83.004844 ], [ 135.000000, 80.012423 ] ] ] } }
{ "type": "Feature", "properties": { }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 108.984375, 83.004844 ], [ 135.000000, 80.012423 ], [ -88.066406, 80.012423 ], [ -119.003906, 71.016960 ], [ -112.060547, -74.982183 ], [ -92.021484, -76.999935 ], [ 169.980469, -79.997168 ], [ 159.960938, -81.996942 ], [ -111.005859, -81.996942 ], [ -139.042969, -75.994839 ], [ -139.042969, 74.019543 ], [ -101.074219, 83.004844 ], [ 108.984375, 83.004844 ] ] ] } }
] }
] }
,
{ "type": "FeatureCollection", "properties": { "zoom": 1, "x": 0, "y": 1 }, "features": [
{ "type": "FeatureCollection", "properties": { "layer": "in", "version": 2, "extent": 4096 }, "features": [
{ "type": "Feature", "properties": { }, "geometry": { "type": "Polygon", "coordinates": [ [ [ -82.001953, 82.003058 ], [ -106.040039, 70.005567 ], [ -103.007812, 32.026706 ], [ -82.001953, -32.990236 ], [ -63.017578, -62.995158 ], [ -28.037109, -72.996909 ], [ 90.000000, -73.995328 ], [ 144.975586, -73.995328 ], [ 144.975586, -76.999935 ], [ 92.988281, -78.996578 ], [ -33.002930, -76.999935 ], [ -75.014648, -65.982270 ], [ -97.031250, -37.996163 ], [ -118.037109, 26.037042 ], [ -117.026367, 71.002660 ], [ -99.008789, 83.004844 ], [ -82.001953, 82.003058 ] ] ] } }
{ "type": "Feature", "properties": { }, "geometry": { "type": "Polygon", "coordinates": [ [ [ -99.008789, 83.004844 ], [ -82.001953, 82.003058 ], [ -106.040039, 70.005567 ], [ -103.007812, 32.026706 ], [ -82.001953, -32.990236 ], [ -63.017578, -62.995158 ], [ -28.037109, -72.996909 ], [ 90.000000, -73.995328 ], [ 144.975586, -73.995328 ], [ 144.975586, -76.999935 ], [ 92.988281, -78.996578 ], [ -33.002930, -76.999935 ], [ -75.014648, -65.982270 ], [ -97.031250, -37.996163 ], [ -118.037109, 26.037042 ], [ -117.026367, 71.002660 ], [ -99.008789, 83.004844 ] ] ] } }
,
{ "type": "Feature", "properties": { }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 135.000000, 80.004799 ], [ -88.022461, 80.004799 ], [ -119.003906, 71.002660 ], [ -112.016602, -74.993566 ], [ -92.021484, -76.999935 ], [ 169.980469, -79.997168 ], [ 159.960938, -81.996942 ], [ -111.005859, -81.996942 ], [ -139.042969, -75.994839 ], [ -139.042969, 74.007440 ], [ -101.030273, 83.004844 ], [ 108.984375, 83.004844 ], [ 135.000000, 80.004799 ] ] ] } }
{ "type": "Feature", "properties": { }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 108.984375, 83.004844 ], [ 135.000000, 80.004799 ], [ -88.022461, 80.004799 ], [ -119.003906, 71.002660 ], [ -112.016602, -74.993566 ], [ -92.021484, -76.999935 ], [ 169.980469, -79.997168 ], [ 159.960938, -81.996942 ], [ -111.005859, -81.996942 ], [ -139.042969, -75.994839 ], [ -139.042969, 74.007440 ], [ -101.030273, 83.004844 ], [ 108.984375, 83.004844 ] ] ] } }
] }
] }
,
{ "type": "FeatureCollection", "properties": { "zoom": 1, "x": 0, "y": 0 }, "features": [
{ "type": "FeatureCollection", "properties": { "layer": "in", "version": 2, "extent": 4096 }, "features": [
{ "type": "Feature", "properties": { }, "geometry": { "type": "Polygon", "coordinates": [ [ [ -82.001953, 82.003058 ], [ -106.040039, 70.005567 ], [ -103.007812, 32.026706 ], [ -82.001953, -32.990236 ], [ -63.017578, -62.995158 ], [ -28.037109, -72.996909 ], [ 90.000000, -73.995328 ], [ 144.975586, -73.995328 ], [ 144.975586, -76.999935 ], [ 92.988281, -78.996578 ], [ -33.002930, -76.999935 ], [ -75.014648, -65.982270 ], [ -97.031250, -37.996163 ], [ -118.037109, 26.037042 ], [ -117.026367, 71.002660 ], [ -99.008789, 83.004844 ], [ -82.001953, 82.003058 ] ] ] } }
{ "type": "Feature", "properties": { }, "geometry": { "type": "Polygon", "coordinates": [ [ [ -99.008789, 83.004844 ], [ -82.001953, 82.003058 ], [ -106.040039, 70.005567 ], [ -103.007812, 32.026706 ], [ -82.001953, -32.990236 ], [ -63.017578, -62.995158 ], [ -28.037109, -72.996909 ], [ 90.000000, -73.995328 ], [ 144.975586, -73.995328 ], [ 144.975586, -76.999935 ], [ 92.988281, -78.996578 ], [ -33.002930, -76.999935 ], [ -75.014648, -65.982270 ], [ -97.031250, -37.996163 ], [ -118.037109, 26.037042 ], [ -117.026367, 71.002660 ], [ -99.008789, 83.004844 ] ] ] } }
,
{ "type": "Feature", "properties": { }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 135.000000, 80.004799 ], [ -88.022461, 80.004799 ], [ -119.003906, 71.002660 ], [ -112.016602, -74.993566 ], [ -92.021484, -76.999935 ], [ 169.980469, -79.997168 ], [ 159.960938, -81.996942 ], [ -111.005859, -81.996942 ], [ -139.042969, -75.994839 ], [ -139.042969, 74.007440 ], [ -101.030273, 83.004844 ], [ 108.984375, 83.004844 ], [ 135.000000, 80.004799 ] ] ] } }
{ "type": "Feature", "properties": { }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 108.984375, 83.004844 ], [ 135.000000, 80.004799 ], [ -88.022461, 80.004799 ], [ -119.003906, 71.002660 ], [ -112.016602, -74.993566 ], [ -92.021484, -76.999935 ], [ 169.980469, -79.997168 ], [ 159.960938, -81.996942 ], [ -111.005859, -81.996942 ], [ -139.042969, -75.994839 ], [ -139.042969, 74.007440 ], [ -101.030273, 83.004844 ], [ 108.984375, 83.004844 ] ] ] } }
] }
] }
,
{ "type": "FeatureCollection", "properties": { "zoom": 1, "x": 1, "y": 1 }, "features": [
{ "type": "FeatureCollection", "properties": { "layer": "in", "version": 2, "extent": 4096 }, "features": [
{ "type": "Feature", "properties": { }, "geometry": { "type": "Polygon", "coordinates": [ [ [ -82.001953, 82.003058 ], [ -106.040039, 70.005567 ], [ -103.007812, 32.026706 ], [ -82.001953, -32.990236 ], [ -63.017578, -62.995158 ], [ -28.037109, -72.996909 ], [ 90.000000, -73.995328 ], [ 144.975586, -73.995328 ], [ 144.975586, -76.999935 ], [ 92.988281, -78.996578 ], [ -33.002930, -76.999935 ], [ -75.014648, -65.982270 ], [ -97.031250, -37.996163 ], [ -118.037109, 26.037042 ], [ -117.026367, 71.002660 ], [ -99.008789, 83.004844 ], [ -82.001953, 82.003058 ] ] ] } }
{ "type": "Feature", "properties": { }, "geometry": { "type": "Polygon", "coordinates": [ [ [ -99.008789, 83.004844 ], [ -82.001953, 82.003058 ], [ -106.040039, 70.005567 ], [ -103.007812, 32.026706 ], [ -82.001953, -32.990236 ], [ -63.017578, -62.995158 ], [ -28.037109, -72.996909 ], [ 90.000000, -73.995328 ], [ 144.975586, -73.995328 ], [ 144.975586, -76.999935 ], [ 92.988281, -78.996578 ], [ -33.002930, -76.999935 ], [ -75.014648, -65.982270 ], [ -97.031250, -37.996163 ], [ -118.037109, 26.037042 ], [ -117.026367, 71.002660 ], [ -99.008789, 83.004844 ] ] ] } }
,
{ "type": "Feature", "properties": { }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 135.000000, 80.004799 ], [ -88.022461, 80.004799 ], [ -119.003906, 71.002660 ], [ -112.016602, -74.993566 ], [ -92.021484, -76.999935 ], [ 169.980469, -79.997168 ], [ 159.960938, -81.996942 ], [ -111.005859, -81.996942 ], [ -139.042969, -75.994839 ], [ -139.042969, 74.007440 ], [ -101.030273, 83.004844 ], [ 108.984375, 83.004844 ], [ 135.000000, 80.004799 ] ] ] } }
{ "type": "Feature", "properties": { }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 108.984375, 83.004844 ], [ 135.000000, 80.004799 ], [ -88.022461, 80.004799 ], [ -119.003906, 71.002660 ], [ -112.016602, -74.993566 ], [ -92.021484, -76.999935 ], [ 169.980469, -79.997168 ], [ 159.960938, -81.996942 ], [ -111.005859, -81.996942 ], [ -139.042969, -75.994839 ], [ -139.042969, 74.007440 ], [ -101.030273, 83.004844 ], [ 108.984375, 83.004844 ] ] ] } }
] }
] }
,
{ "type": "FeatureCollection", "properties": { "zoom": 1, "x": 1, "y": 0 }, "features": [
{ "type": "FeatureCollection", "properties": { "layer": "in", "version": 2, "extent": 4096 }, "features": [
{ "type": "Feature", "properties": { }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 135.000000, 80.004799 ], [ -88.022461, 80.004799 ], [ -119.003906, 71.002660 ], [ -112.016602, -74.993566 ], [ -92.021484, -76.999935 ], [ 169.980469, -79.997168 ], [ 159.960938, -81.996942 ], [ -111.005859, -81.996942 ], [ -139.042969, -75.994839 ], [ -139.042969, 74.007440 ], [ -101.030273, 83.004844 ], [ 108.984375, 83.004844 ], [ 135.000000, 80.004799 ] ] ] } }
{ "type": "Feature", "properties": { }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 108.984375, 83.004844 ], [ 135.000000, 80.004799 ], [ -88.022461, 80.004799 ], [ -119.003906, 71.002660 ], [ -112.016602, -74.993566 ], [ -92.021484, -76.999935 ], [ 169.980469, -79.997168 ], [ 159.960938, -81.996942 ], [ -111.005859, -81.996942 ], [ -139.042969, -75.994839 ], [ -139.042969, 74.007440 ], [ -101.030273, 83.004844 ], [ 108.984375, 83.004844 ] ] ] } }
] }
] }
,
{ "type": "FeatureCollection", "properties": { "zoom": 2, "x": 0, "y": 3 }, "features": [
{ "type": "FeatureCollection", "properties": { "layer": "in", "version": 2, "extent": 4096 }, "features": [
{ "type": "Feature", "properties": { }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 135.000000, 80.000984 ], [ -88.000488, 80.000984 ], [ -119.003906, 71.002660 ], [ -112.016602, -74.999254 ], [ -92.021484, -76.999935 ], [ 169.980469, -79.997168 ], [ 159.982910, -81.996942 ], [ -111.005859, -81.996942 ], [ -139.020996, -75.994839 ], [ -139.020996, 74.001385 ], [ -101.008301, 83.002167 ], [ 108.984375, 83.002167 ], [ 135.000000, 80.000984 ] ] ] } }
{ "type": "Feature", "properties": { }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 108.984375, 83.002167 ], [ 135.000000, 80.000984 ], [ -88.000488, 80.000984 ], [ -119.003906, 71.002660 ], [ -112.016602, -74.999254 ], [ -92.021484, -76.999935 ], [ 169.980469, -79.997168 ], [ 159.982910, -81.996942 ], [ -111.005859, -81.996942 ], [ -139.020996, -75.994839 ], [ -139.020996, 74.001385 ], [ -101.008301, 83.002167 ], [ 108.984375, 83.002167 ] ] ] } }
] }
] }
,
{ "type": "FeatureCollection", "properties": { "zoom": 2, "x": 0, "y": 2 }, "features": [
{ "type": "FeatureCollection", "properties": { "layer": "in", "version": 2, "extent": 4096 }, "features": [
{ "type": "Feature", "properties": { }, "geometry": { "type": "Polygon", "coordinates": [ [ [ -82.001953, 82.000000 ], [ -106.018066, 70.005567 ], [ -103.007812, 32.008076 ], [ -82.001953, -32.990236 ], [ -63.017578, -62.995158 ], [ -28.015137, -72.996909 ], [ 90.000000, -73.995328 ], [ 144.997559, -73.995328 ], [ 144.997559, -76.999935 ], [ 92.988281, -78.996578 ], [ -33.002930, -76.999935 ], [ -75.014648, -65.991212 ], [ -97.009277, -37.996163 ], [ -118.015137, 26.017298 ], [ -117.004395, 71.002660 ], [ -99.008789, 83.002167 ], [ -82.001953, 82.000000 ] ] ] } }
{ "type": "Feature", "properties": { }, "geometry": { "type": "Polygon", "coordinates": [ [ [ -99.008789, 83.002167 ], [ -82.001953, 82.000000 ], [ -106.018066, 70.005567 ], [ -103.007812, 32.008076 ], [ -82.001953, -32.990236 ], [ -63.017578, -62.995158 ], [ -28.015137, -72.996909 ], [ 90.000000, -73.995328 ], [ 144.997559, -73.995328 ], [ 144.997559, -76.999935 ], [ 92.988281, -78.996578 ], [ -33.002930, -76.999935 ], [ -75.014648, -65.991212 ], [ -97.009277, -37.996163 ], [ -118.015137, 26.017298 ], [ -117.004395, 71.002660 ], [ -99.008789, 83.002167 ] ] ] } }
,
{ "type": "Feature", "properties": { }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 135.000000, 80.000984 ], [ -88.000488, 80.000984 ], [ -119.003906, 71.002660 ], [ -112.016602, -74.999254 ], [ -92.021484, -76.999935 ], [ 169.980469, -79.997168 ], [ 159.982910, -81.996942 ], [ -111.005859, -81.996942 ], [ -139.020996, -75.994839 ], [ -139.020996, 74.001385 ], [ -101.008301, 83.002167 ], [ 108.984375, 83.002167 ], [ 135.000000, 80.000984 ] ] ] } }
{ "type": "Feature", "properties": { }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 108.984375, 83.002167 ], [ 135.000000, 80.000984 ], [ -88.000488, 80.000984 ], [ -119.003906, 71.002660 ], [ -112.016602, -74.999254 ], [ -92.021484, -76.999935 ], [ 169.980469, -79.997168 ], [ 159.982910, -81.996942 ], [ -111.005859, -81.996942 ], [ -139.020996, -75.994839 ], [ -139.020996, 74.001385 ], [ -101.008301, 83.002167 ], [ 108.984375, 83.002167 ] ] ] } }
] }
] }
,
{ "type": "FeatureCollection", "properties": { "zoom": 2, "x": 0, "y": 1 }, "features": [
{ "type": "FeatureCollection", "properties": { "layer": "in", "version": 2, "extent": 4096 }, "features": [
{ "type": "Feature", "properties": { }, "geometry": { "type": "Polygon", "coordinates": [ [ [ -82.001953, 82.000000 ], [ -106.018066, 70.005567 ], [ -103.007812, 32.008076 ], [ -82.001953, -32.990236 ], [ -63.017578, -62.995158 ], [ -28.015137, -72.996909 ], [ 90.000000, -73.995328 ], [ 144.997559, -73.995328 ], [ 144.997559, -76.999935 ], [ 92.988281, -78.996578 ], [ -33.002930, -76.999935 ], [ -75.014648, -65.991212 ], [ -97.009277, -37.996163 ], [ -118.015137, 26.017298 ], [ -117.004395, 71.002660 ], [ -99.008789, 83.002167 ], [ -82.001953, 82.000000 ] ] ] } }
{ "type": "Feature", "properties": { }, "geometry": { "type": "Polygon", "coordinates": [ [ [ -99.008789, 83.002167 ], [ -82.001953, 82.000000 ], [ -106.018066, 70.005567 ], [ -103.007812, 32.008076 ], [ -82.001953, -32.990236 ], [ -63.017578, -62.995158 ], [ -28.015137, -72.996909 ], [ 90.000000, -73.995328 ], [ 144.997559, -73.995328 ], [ 144.997559, -76.999935 ], [ 92.988281, -78.996578 ], [ -33.002930, -76.999935 ], [ -75.014648, -65.991212 ], [ -97.009277, -37.996163 ], [ -118.015137, 26.017298 ], [ -117.004395, 71.002660 ], [ -99.008789, 83.002167 ] ] ] } }
,
{ "type": "Feature", "properties": { }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 135.000000, 80.000984 ], [ -88.000488, 80.000984 ], [ -119.003906, 71.002660 ], [ -112.016602, -74.999254 ], [ -92.021484, -76.999935 ], [ 169.980469, -79.997168 ], [ 159.982910, -81.996942 ], [ -111.005859, -81.996942 ], [ -139.020996, -75.994839 ], [ -139.020996, 74.001385 ], [ -101.008301, 83.002167 ], [ 108.984375, 83.002167 ], [ 135.000000, 80.000984 ] ] ] } }
{ "type": "Feature", "properties": { }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 108.984375, 83.002167 ], [ 135.000000, 80.000984 ], [ -88.000488, 80.000984 ], [ -119.003906, 71.002660 ], [ -112.016602, -74.999254 ], [ -92.021484, -76.999935 ], [ 169.980469, -79.997168 ], [ 159.982910, -81.996942 ], [ -111.005859, -81.996942 ], [ -139.020996, -75.994839 ], [ -139.020996, 74.001385 ], [ -101.008301, 83.002167 ], [ 108.984375, 83.002167 ] ] ] } }
] }
] }
,
{ "type": "FeatureCollection", "properties": { "zoom": 2, "x": 0, "y": 0 }, "features": [
{ "type": "FeatureCollection", "properties": { "layer": "in", "version": 2, "extent": 4096 }, "features": [
{ "type": "Feature", "properties": { }, "geometry": { "type": "Polygon", "coordinates": [ [ [ -82.001953, 82.000000 ], [ -106.018066, 70.005567 ], [ -103.007812, 32.008076 ], [ -82.001953, -32.990236 ], [ -63.017578, -62.995158 ], [ -28.015137, -72.996909 ], [ 90.000000, -73.995328 ], [ 144.997559, -73.995328 ], [ 144.997559, -76.999935 ], [ 92.988281, -78.996578 ], [ -33.002930, -76.999935 ], [ -75.014648, -65.991212 ], [ -97.009277, -37.996163 ], [ -118.015137, 26.017298 ], [ -117.004395, 71.002660 ], [ -99.008789, 83.002167 ], [ -82.001953, 82.000000 ] ] ] } }
{ "type": "Feature", "properties": { }, "geometry": { "type": "Polygon", "coordinates": [ [ [ -99.008789, 83.002167 ], [ -82.001953, 82.000000 ], [ -106.018066, 70.005567 ], [ -103.007812, 32.008076 ], [ -82.001953, -32.990236 ], [ -63.017578, -62.995158 ], [ -28.015137, -72.996909 ], [ 90.000000, -73.995328 ], [ 144.997559, -73.995328 ], [ 144.997559, -76.999935 ], [ 92.988281, -78.996578 ], [ -33.002930, -76.999935 ], [ -75.014648, -65.991212 ], [ -97.009277, -37.996163 ], [ -118.015137, 26.017298 ], [ -117.004395, 71.002660 ], [ -99.008789, 83.002167 ] ] ] } }
,
{ "type": "Feature", "properties": { }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 135.000000, 80.000984 ], [ -88.000488, 80.000984 ], [ -119.003906, 71.002660 ], [ -112.016602, -74.999254 ], [ -92.021484, -76.999935 ], [ 169.980469, -79.997168 ], [ 159.982910, -81.996942 ], [ -111.005859, -81.996942 ], [ -139.020996, -75.994839 ], [ -139.020996, 74.001385 ], [ -101.008301, 83.002167 ], [ 108.984375, 83.002167 ], [ 135.000000, 80.000984 ] ] ] } }
{ "type": "Feature", "properties": { }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 108.984375, 83.002167 ], [ 135.000000, 80.000984 ], [ -88.000488, 80.000984 ], [ -119.003906, 71.002660 ], [ -112.016602, -74.999254 ], [ -92.021484, -76.999935 ], [ 169.980469, -79.997168 ], [ 159.982910, -81.996942 ], [ -111.005859, -81.996942 ], [ -139.020996, -75.994839 ], [ -139.020996, 74.001385 ], [ -101.008301, 83.002167 ], [ 108.984375, 83.002167 ] ] ] } }
] }
] }
,
{ "type": "FeatureCollection", "properties": { "zoom": 2, "x": 1, "y": 3 }, "features": [
{ "type": "FeatureCollection", "properties": { "layer": "in", "version": 2, "extent": 4096 }, "features": [
{ "type": "Feature", "properties": { }, "geometry": { "type": "Polygon", "coordinates": [ [ [ -82.001953, 82.000000 ], [ -106.018066, 70.005567 ], [ -103.007812, 32.008076 ], [ -82.001953, -32.990236 ], [ -63.017578, -62.995158 ], [ -28.015137, -72.996909 ], [ 90.000000, -73.995328 ], [ 144.997559, -73.995328 ], [ 144.997559, -76.999935 ], [ 92.988281, -78.996578 ], [ -33.002930, -76.999935 ], [ -75.014648, -65.991212 ], [ -97.009277, -37.996163 ], [ -118.015137, 26.017298 ], [ -117.004395, 71.002660 ], [ -99.008789, 83.002167 ], [ -82.001953, 82.000000 ] ] ] } }
{ "type": "Feature", "properties": { }, "geometry": { "type": "Polygon", "coordinates": [ [ [ -99.008789, 83.002167 ], [ -82.001953, 82.000000 ], [ -106.018066, 70.005567 ], [ -103.007812, 32.008076 ], [ -82.001953, -32.990236 ], [ -63.017578, -62.995158 ], [ -28.015137, -72.996909 ], [ 90.000000, -73.995328 ], [ 144.997559, -73.995328 ], [ 144.997559, -76.999935 ], [ 92.988281, -78.996578 ], [ -33.002930, -76.999935 ], [ -75.014648, -65.991212 ], [ -97.009277, -37.996163 ], [ -118.015137, 26.017298 ], [ -117.004395, 71.002660 ], [ -99.008789, 83.002167 ] ] ] } }
,
{ "type": "Feature", "properties": { }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 135.000000, 80.000984 ], [ -88.000488, 80.000984 ], [ -119.003906, 71.002660 ], [ -112.016602, -74.999254 ], [ -92.021484, -76.999935 ], [ 169.980469, -79.997168 ], [ 159.982910, -81.996942 ], [ -111.005859, -81.996942 ], [ -139.020996, -75.994839 ], [ -139.020996, 74.001385 ], [ -101.008301, 83.002167 ], [ 108.984375, 83.002167 ], [ 135.000000, 80.000984 ] ] ] } }
{ "type": "Feature", "properties": { }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 108.984375, 83.002167 ], [ 135.000000, 80.000984 ], [ -88.000488, 80.000984 ], [ -119.003906, 71.002660 ], [ -112.016602, -74.999254 ], [ -92.021484, -76.999935 ], [ 169.980469, -79.997168 ], [ 159.982910, -81.996942 ], [ -111.005859, -81.996942 ], [ -139.020996, -75.994839 ], [ -139.020996, 74.001385 ], [ -101.008301, 83.002167 ], [ 108.984375, 83.002167 ] ] ] } }
] }
] }
,
{ "type": "FeatureCollection", "properties": { "zoom": 2, "x": 1, "y": 2 }, "features": [
{ "type": "FeatureCollection", "properties": { "layer": "in", "version": 2, "extent": 4096 }, "features": [
{ "type": "Feature", "properties": { }, "geometry": { "type": "Polygon", "coordinates": [ [ [ -82.001953, 82.000000 ], [ -106.018066, 70.005567 ], [ -103.007812, 32.008076 ], [ -82.001953, -32.990236 ], [ -63.017578, -62.995158 ], [ -28.015137, -72.996909 ], [ 90.000000, -73.995328 ], [ 144.997559, -73.995328 ], [ 144.997559, -76.999935 ], [ 92.988281, -78.996578 ], [ -33.002930, -76.999935 ], [ -75.014648, -65.991212 ], [ -97.009277, -37.996163 ], [ -118.015137, 26.017298 ], [ -117.004395, 71.002660 ], [ -99.008789, 83.002167 ], [ -82.001953, 82.000000 ] ] ] } }
{ "type": "Feature", "properties": { }, "geometry": { "type": "Polygon", "coordinates": [ [ [ -99.008789, 83.002167 ], [ -82.001953, 82.000000 ], [ -106.018066, 70.005567 ], [ -103.007812, 32.008076 ], [ -82.001953, -32.990236 ], [ -63.017578, -62.995158 ], [ -28.015137, -72.996909 ], [ 90.000000, -73.995328 ], [ 144.997559, -73.995328 ], [ 144.997559, -76.999935 ], [ 92.988281, -78.996578 ], [ -33.002930, -76.999935 ], [ -75.014648, -65.991212 ], [ -97.009277, -37.996163 ], [ -118.015137, 26.017298 ], [ -117.004395, 71.002660 ], [ -99.008789, 83.002167 ] ] ] } }
] }
] }
,
{ "type": "FeatureCollection", "properties": { "zoom": 2, "x": 1, "y": 0 }, "features": [
{ "type": "FeatureCollection", "properties": { "layer": "in", "version": 2, "extent": 4096 }, "features": [
{ "type": "Feature", "properties": { }, "geometry": { "type": "Polygon", "coordinates": [ [ [ -82.001953, 82.000000 ], [ -106.018066, 70.005567 ], [ -103.007812, 32.008076 ], [ -82.001953, -32.990236 ], [ -63.017578, -62.995158 ], [ -28.015137, -72.996909 ], [ 90.000000, -73.995328 ], [ 144.997559, -73.995328 ], [ 144.997559, -76.999935 ], [ 92.988281, -78.996578 ], [ -33.002930, -76.999935 ], [ -75.014648, -65.991212 ], [ -97.009277, -37.996163 ], [ -118.015137, 26.017298 ], [ -117.004395, 71.002660 ], [ -99.008789, 83.002167 ], [ -82.001953, 82.000000 ] ] ] } }
{ "type": "Feature", "properties": { }, "geometry": { "type": "Polygon", "coordinates": [ [ [ -99.008789, 83.002167 ], [ -82.001953, 82.000000 ], [ -106.018066, 70.005567 ], [ -103.007812, 32.008076 ], [ -82.001953, -32.990236 ], [ -63.017578, -62.995158 ], [ -28.015137, -72.996909 ], [ 90.000000, -73.995328 ], [ 144.997559, -73.995328 ], [ 144.997559, -76.999935 ], [ 92.988281, -78.996578 ], [ -33.002930, -76.999935 ], [ -75.014648, -65.991212 ], [ -97.009277, -37.996163 ], [ -118.015137, 26.017298 ], [ -117.004395, 71.002660 ], [ -99.008789, 83.002167 ] ] ] } }
,
{ "type": "Feature", "properties": { }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 135.000000, 80.000984 ], [ -88.000488, 80.000984 ], [ -119.003906, 71.002660 ], [ -112.016602, -74.999254 ], [ -92.021484, -76.999935 ], [ 169.980469, -79.997168 ], [ 159.982910, -81.996942 ], [ -111.005859, -81.996942 ], [ -139.020996, -75.994839 ], [ -139.020996, 74.001385 ], [ -101.008301, 83.002167 ], [ 108.984375, 83.002167 ], [ 135.000000, 80.000984 ] ] ] } }
{ "type": "Feature", "properties": { }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 108.984375, 83.002167 ], [ 135.000000, 80.000984 ], [ -88.000488, 80.000984 ], [ -119.003906, 71.002660 ], [ -112.016602, -74.999254 ], [ -92.021484, -76.999935 ], [ 169.980469, -79.997168 ], [ 159.982910, -81.996942 ], [ -111.005859, -81.996942 ], [ -139.020996, -75.994839 ], [ -139.020996, 74.001385 ], [ -101.008301, 83.002167 ], [ 108.984375, 83.002167 ] ] ] } }
] }
] }
,
{ "type": "FeatureCollection", "properties": { "zoom": 2, "x": 2, "y": 3 }, "features": [
{ "type": "FeatureCollection", "properties": { "layer": "in", "version": 2, "extent": 4096 }, "features": [
{ "type": "Feature", "properties": { }, "geometry": { "type": "Polygon", "coordinates": [ [ [ -82.001953, 82.000000 ], [ -106.018066, 70.005567 ], [ -103.007812, 32.008076 ], [ -82.001953, -32.990236 ], [ -63.017578, -62.995158 ], [ -28.015137, -72.996909 ], [ 90.000000, -73.995328 ], [ 144.997559, -73.995328 ], [ 144.997559, -76.999935 ], [ 92.988281, -78.996578 ], [ -33.002930, -76.999935 ], [ -75.014648, -65.991212 ], [ -97.009277, -37.996163 ], [ -118.015137, 26.017298 ], [ -117.004395, 71.002660 ], [ -99.008789, 83.002167 ], [ -82.001953, 82.000000 ] ] ] } }
{ "type": "Feature", "properties": { }, "geometry": { "type": "Polygon", "coordinates": [ [ [ -99.008789, 83.002167 ], [ -82.001953, 82.000000 ], [ -106.018066, 70.005567 ], [ -103.007812, 32.008076 ], [ -82.001953, -32.990236 ], [ -63.017578, -62.995158 ], [ -28.015137, -72.996909 ], [ 90.000000, -73.995328 ], [ 144.997559, -73.995328 ], [ 144.997559, -76.999935 ], [ 92.988281, -78.996578 ], [ -33.002930, -76.999935 ], [ -75.014648, -65.991212 ], [ -97.009277, -37.996163 ], [ -118.015137, 26.017298 ], [ -117.004395, 71.002660 ], [ -99.008789, 83.002167 ] ] ] } }
,
{ "type": "Feature", "properties": { }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 135.000000, 80.000984 ], [ -88.000488, 80.000984 ], [ -119.003906, 71.002660 ], [ -112.016602, -74.999254 ], [ -92.021484, -76.999935 ], [ 169.980469, -79.997168 ], [ 159.982910, -81.996942 ], [ -111.005859, -81.996942 ], [ -139.020996, -75.994839 ], [ -139.020996, 74.001385 ], [ -101.008301, 83.002167 ], [ 108.984375, 83.002167 ], [ 135.000000, 80.000984 ] ] ] } }
{ "type": "Feature", "properties": { }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 108.984375, 83.002167 ], [ 135.000000, 80.000984 ], [ -88.000488, 80.000984 ], [ -119.003906, 71.002660 ], [ -112.016602, -74.999254 ], [ -92.021484, -76.999935 ], [ 169.980469, -79.997168 ], [ 159.982910, -81.996942 ], [ -111.005859, -81.996942 ], [ -139.020996, -75.994839 ], [ -139.020996, 74.001385 ], [ -101.008301, 83.002167 ], [ 108.984375, 83.002167 ] ] ] } }
] }
] }
,
{ "type": "FeatureCollection", "properties": { "zoom": 2, "x": 2, "y": 0 }, "features": [
{ "type": "FeatureCollection", "properties": { "layer": "in", "version": 2, "extent": 4096 }, "features": [
{ "type": "Feature", "properties": { }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 135.000000, 80.000984 ], [ -88.000488, 80.000984 ], [ -119.003906, 71.002660 ], [ -112.016602, -74.999254 ], [ -92.021484, -76.999935 ], [ 169.980469, -79.997168 ], [ 159.982910, -81.996942 ], [ -111.005859, -81.996942 ], [ -139.020996, -75.994839 ], [ -139.020996, 74.001385 ], [ -101.008301, 83.002167 ], [ 108.984375, 83.002167 ], [ 135.000000, 80.000984 ] ] ] } }
{ "type": "Feature", "properties": { }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 108.984375, 83.002167 ], [ 135.000000, 80.000984 ], [ -88.000488, 80.000984 ], [ -119.003906, 71.002660 ], [ -112.016602, -74.999254 ], [ -92.021484, -76.999935 ], [ 169.980469, -79.997168 ], [ 159.982910, -81.996942 ], [ -111.005859, -81.996942 ], [ -139.020996, -75.994839 ], [ -139.020996, 74.001385 ], [ -101.008301, 83.002167 ], [ 108.984375, 83.002167 ] ] ] } }
] }
] }
,
{ "type": "FeatureCollection", "properties": { "zoom": 2, "x": 3, "y": 3 }, "features": [
{ "type": "FeatureCollection", "properties": { "layer": "in", "version": 2, "extent": 4096 }, "features": [
{ "type": "Feature", "properties": { }, "geometry": { "type": "Polygon", "coordinates": [ [ [ -82.001953, 82.000000 ], [ -106.018066, 70.005567 ], [ -103.007812, 32.008076 ], [ -82.001953, -32.990236 ], [ -63.017578, -62.995158 ], [ -28.015137, -72.996909 ], [ 90.000000, -73.995328 ], [ 144.997559, -73.995328 ], [ 144.997559, -76.999935 ], [ 92.988281, -78.996578 ], [ -33.002930, -76.999935 ], [ -75.014648, -65.991212 ], [ -97.009277, -37.996163 ], [ -118.015137, 26.017298 ], [ -117.004395, 71.002660 ], [ -99.008789, 83.002167 ], [ -82.001953, 82.000000 ] ] ] } }
{ "type": "Feature", "properties": { }, "geometry": { "type": "Polygon", "coordinates": [ [ [ -99.008789, 83.002167 ], [ -82.001953, 82.000000 ], [ -106.018066, 70.005567 ], [ -103.007812, 32.008076 ], [ -82.001953, -32.990236 ], [ -63.017578, -62.995158 ], [ -28.015137, -72.996909 ], [ 90.000000, -73.995328 ], [ 144.997559, -73.995328 ], [ 144.997559, -76.999935 ], [ 92.988281, -78.996578 ], [ -33.002930, -76.999935 ], [ -75.014648, -65.991212 ], [ -97.009277, -37.996163 ], [ -118.015137, 26.017298 ], [ -117.004395, 71.002660 ], [ -99.008789, 83.002167 ] ] ] } }
,
{ "type": "Feature", "properties": { }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 135.000000, 80.000984 ], [ -88.000488, 80.000984 ], [ -119.003906, 71.002660 ], [ -112.016602, -74.999254 ], [ -92.021484, -76.999935 ], [ 169.980469, -79.997168 ], [ 159.982910, -81.996942 ], [ -111.005859, -81.996942 ], [ -139.020996, -75.994839 ], [ -139.020996, 74.001385 ], [ -101.008301, 83.002167 ], [ 108.984375, 83.002167 ], [ 135.000000, 80.000984 ] ] ] } }
{ "type": "Feature", "properties": { }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 108.984375, 83.002167 ], [ 135.000000, 80.000984 ], [ -88.000488, 80.000984 ], [ -119.003906, 71.002660 ], [ -112.016602, -74.999254 ], [ -92.021484, -76.999935 ], [ 169.980469, -79.997168 ], [ 159.982910, -81.996942 ], [ -111.005859, -81.996942 ], [ -139.020996, -75.994839 ], [ -139.020996, 74.001385 ], [ -101.008301, 83.002167 ], [ 108.984375, 83.002167 ] ] ] } }
] }
] }
,
{ "type": "FeatureCollection", "properties": { "zoom": 2, "x": 3, "y": 0 }, "features": [
{ "type": "FeatureCollection", "properties": { "layer": "in", "version": 2, "extent": 4096 }, "features": [
{ "type": "Feature", "properties": { }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 135.000000, 80.000984 ], [ -88.000488, 80.000984 ], [ -119.003906, 71.002660 ], [ -112.016602, -74.999254 ], [ -92.021484, -76.999935 ], [ 169.980469, -79.997168 ], [ 159.982910, -81.996942 ], [ -111.005859, -81.996942 ], [ -139.020996, -75.994839 ], [ -139.020996, 74.001385 ], [ -101.008301, 83.002167 ], [ 108.984375, 83.002167 ], [ 135.000000, 80.000984 ] ] ] } }
{ "type": "Feature", "properties": { }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 108.984375, 83.002167 ], [ 135.000000, 80.000984 ], [ -88.000488, 80.000984 ], [ -119.003906, 71.002660 ], [ -112.016602, -74.999254 ], [ -92.021484, -76.999935 ], [ 169.980469, -79.997168 ], [ 159.982910, -81.996942 ], [ -111.005859, -81.996942 ], [ -139.020996, -75.994839 ], [ -139.020996, 74.001385 ], [ -101.008301, 83.002167 ], [ 108.984375, 83.002167 ] ] ] } }
] }
] }
] }

12
tests/curve/out/-z2_--no-duplication.json
View File

@ -12,25 +12,25 @@
}, "features": [
{ "type": "FeatureCollection", "properties": { "zoom": 0, "x": 0, "y": 0 }, "features": [
{ "type": "FeatureCollection", "properties": { "layer": "in", "version": 2, "extent": 4096 }, "features": [
{ "type": "Feature", "properties": { }, "geometry": { "type": "Polygon", "coordinates": [ [ [ -82.001953, 82.009169 ], [ -106.083984, 70.020587 ], [ -103.007812, 32.026706 ], [ -82.001953, -32.990236 ], [ -63.017578, -62.995158 ], [ -28.037109, -72.996909 ], [ 90.000000, -73.995328 ], [ 144.931641, -73.995328 ], [ 144.931641, -76.999935 ], [ 92.988281, -78.988187 ], [ -33.046875, -76.999935 ], [ -75.058594, -65.982270 ], [ -97.031250, -37.996163 ], [ -118.037109, 26.037042 ], [ -117.070312, 71.016960 ], [ -99.052734, 83.004844 ], [ -82.001953, 82.009169 ] ] ] } }
{ "type": "Feature", "properties": { }, "geometry": { "type": "Polygon", "coordinates": [ [ [ -99.052734, 83.004844 ], [ -82.001953, 82.009169 ], [ -106.083984, 70.020587 ], [ -103.007812, 32.026706 ], [ -82.001953, -32.990236 ], [ -63.017578, -62.995158 ], [ -28.037109, -72.996909 ], [ 90.000000, -73.995328 ], [ 144.931641, -73.995328 ], [ 144.931641, -76.999935 ], [ 92.988281, -78.988187 ], [ -33.046875, -76.999935 ], [ -75.058594, -65.982270 ], [ -97.031250, -37.996163 ], [ -118.037109, 26.037042 ], [ -117.070312, 71.016960 ], [ -99.052734, 83.004844 ] ] ] } }
,
{ "type": "Feature", "properties": { }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 135.000000, 80.012423 ], [ -88.066406, 80.012423 ], [ -119.003906, 71.016960 ], [ -112.060547, -74.982183 ], [ -92.021484, -76.999935 ], [ 169.980469, -79.997168 ], [ 159.960938, -81.996942 ], [ -111.005859, -81.996942 ], [ -139.042969, -75.994839 ], [ -139.042969, 74.019543 ], [ -101.074219, 83.004844 ], [ 108.984375, 83.004844 ], [ 135.000000, 80.012423 ] ] ] } }
{ "type": "Feature", "properties": { }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 108.984375, 83.004844 ], [ 135.000000, 80.012423 ], [ -88.066406, 80.012423 ], [ -119.003906, 71.016960 ], [ -112.060547, -74.982183 ], [ -92.021484, -76.999935 ], [ 169.980469, -79.997168 ], [ 159.960938, -81.996942 ], [ -111.005859, -81.996942 ], [ -139.042969, -75.994839 ], [ -139.042969, 74.019543 ], [ -101.074219, 83.004844 ], [ 108.984375, 83.004844 ] ] ] } }
] }
] }
,
{ "type": "FeatureCollection", "properties": { "zoom": 1, "x": 1, "y": 0 }, "features": [
{ "type": "FeatureCollection", "properties": { "layer": "in", "version": 2, "extent": 4096 }, "features": [
{ "type": "Feature", "properties": { }, "geometry": { "type": "Polygon", "coordinates": [ [ [ -82.001953, 82.003058 ], [ -106.040039, 70.005567 ], [ -103.007812, 32.026706 ], [ -82.001953, -32.990236 ], [ -63.017578, -62.995158 ], [ -28.037109, -72.996909 ], [ 90.000000, -73.995328 ], [ 144.975586, -73.995328 ], [ 144.975586, -76.999935 ], [ 92.988281, -78.996578 ], [ -33.002930, -76.999935 ], [ -75.014648, -65.982270 ], [ -97.031250, -37.996163 ], [ -118.037109, 26.037042 ], [ -117.026367, 71.002660 ], [ -99.008789, 83.004844 ], [ -82.001953, 82.003058 ] ] ] } }
{ "type": "Feature", "properties": { }, "geometry": { "type": "Polygon", "coordinates": [ [ [ -99.008789, 83.004844 ], [ -82.001953, 82.003058 ], [ -106.040039, 70.005567 ], [ -103.007812, 32.026706 ], [ -82.001953, -32.990236 ], [ -63.017578, -62.995158 ], [ -28.037109, -72.996909 ], [ 90.000000, -73.995328 ], [ 144.975586, -73.995328 ], [ 144.975586, -76.999935 ], [ 92.988281, -78.996578 ], [ -33.002930, -76.999935 ], [ -75.014648, -65.982270 ], [ -97.031250, -37.996163 ], [ -118.037109, 26.037042 ], [ -117.026367, 71.002660 ], [ -99.008789, 83.004844 ] ] ] } }
,
{ "type": "Feature", "properties": { }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 135.000000, 80.004799 ], [ -88.022461, 80.004799 ], [ -119.003906, 71.002660 ], [ -112.016602, -74.993566 ], [ -92.021484, -76.999935 ], [ 169.980469, -79.997168 ], [ 159.960938, -81.996942 ], [ -111.005859, -81.996942 ], [ -139.042969, -75.994839 ], [ -139.042969, 74.007440 ], [ -101.030273, 83.004844 ], [ 108.984375, 83.004844 ], [ 135.000000, 80.004799 ] ] ] } }
{ "type": "Feature", "properties": { }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 108.984375, 83.004844 ], [ 135.000000, 80.004799 ], [ -88.022461, 80.004799 ], [ -119.003906, 71.002660 ], [ -112.016602, -74.993566 ], [ -92.021484, -76.999935 ], [ 169.980469, -79.997168 ], [ 159.960938, -81.996942 ], [ -111.005859, -81.996942 ], [ -139.042969, -75.994839 ], [ -139.042969, 74.007440 ], [ -101.030273, 83.004844 ], [ 108.984375, 83.004844 ] ] ] } }
] }
] }
,
{ "type": "FeatureCollection", "properties": { "zoom": 2, "x": 2, "y": 1 }, "features": [
{ "type": "FeatureCollection", "properties": { "layer": "in", "version": 2, "extent": 4096 }, "features": [
{ "type": "Feature", "properties": { }, "geometry": { "type": "Polygon", "coordinates": [ [ [ -82.001953, 82.000000 ], [ -106.018066, 70.005567 ], [ -103.007812, 32.008076 ], [ -82.001953, -32.990236 ], [ -63.017578, -62.995158 ], [ -28.015137, -72.996909 ], [ 90.000000, -73.995328 ], [ 144.997559, -73.995328 ], [ 144.997559, -76.999935 ], [ 92.988281, -78.996578 ], [ -33.002930, -76.999935 ], [ -75.014648, -65.991212 ], [ -97.009277, -37.996163 ], [ -118.015137, 26.017298 ], [ -117.004395, 71.002660 ], [ -99.008789, 83.002167 ], [ -82.001953, 82.000000 ] ] ] } }
{ "type": "Feature", "properties": { }, "geometry": { "type": "Polygon", "coordinates": [ [ [ -99.008789, 83.002167 ], [ -82.001953, 82.000000 ], [ -106.018066, 70.005567 ], [ -103.007812, 32.008076 ], [ -82.001953, -32.990236 ], [ -63.017578, -62.995158 ], [ -28.015137, -72.996909 ], [ 90.000000, -73.995328 ], [ 144.997559, -73.995328 ], [ 144.997559, -76.999935 ], [ 92.988281, -78.996578 ], [ -33.002930, -76.999935 ], [ -75.014648, -65.991212 ], [ -97.009277, -37.996163 ], [ -118.015137, 26.017298 ], [ -117.004395, 71.002660 ], [ -99.008789, 83.002167 ] ] ] } }
,
{ "type": "Feature", "properties": { }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 135.000000, 80.000984 ], [ -88.000488, 80.000984 ], [ -119.003906, 71.002660 ], [ -112.016602, -74.999254 ], [ -92.021484, -76.999935 ], [ 169.980469, -79.997168 ], [ 159.982910, -81.996942 ], [ -111.005859, -81.996942 ], [ -139.020996, -75.994839 ], [ -139.020996, 74.001385 ], [ -101.008301, 83.002167 ], [ 108.984375, 83.002167 ], [ 135.000000, 80.000984 ] ] ] } }
{ "type": "Feature", "properties": { }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 108.984375, 83.002167 ], [ 135.000000, 80.000984 ], [ -88.000488, 80.000984 ], [ -119.003906, 71.002660 ], [ -112.016602, -74.999254 ], [ -92.021484, -76.999935 ], [ 169.980469, -79.997168 ], [ 159.982910, -81.996942 ], [ -111.005859, -81.996942 ], [ -139.020996, -75.994839 ], [ -139.020996, 74.001385 ], [ -101.008301, 83.002167 ], [ 108.984375, 83.002167 ] ] ] } }
] }
] }
] }

130
tests/dateline/out/-z5.json
View File

@ -12,7 +12,7 @@
}, "features": [
{ "type": "FeatureCollection", "properties": { "zoom": 0, "x": 0, "y": 0 }, "features": [
{ "type": "FeatureCollection", "properties": { "layer": "in", "version": 2, "extent": 4096 }, "features": [
{ "type": "Feature", "properties": { "boolean": true, "otherboolean": false, "stringify": "[\"yes\",27.00000000,27,1.4e27,{\"foo\":\"bar\"}]", "escape": "foo\u0001bar,ü\"\\/\u0008\u000c\u000a\u000d\u0009→", "prêt": "ready" }, "geometry": { "type": "MultiPolygon", "coordinates": [ [ [ [ -177.539062, 44.339565 ], [ -164.882812, 43.389082 ], [ -153.281250, 46.619261 ], [ -144.492188, 51.179343 ], [ -143.789062, 57.183902 ], [ -148.007812, 61.100789 ], [ -158.554688, 63.860036 ], [ -169.453125, 64.510643 ], [ -177.890625, 62.593341 ], [ -180.000000, 61.689872 ], [ -185.976562, 58.859224 ], [ -187.031250, 56.992883 ], [ -187.031250, 65.730626 ], [ -182.460938, 67.339861 ], [ -180.000000, 67.542167 ], [ -169.101562, 68.269387 ], [ -156.093750, 68.138852 ], [ -144.492188, 66.089364 ], [ -134.648438, 62.431074 ], [ -131.835938, 55.379110 ], [ -133.593750, 48.690960 ], [ -146.250000, 38.616870 ], [ -169.453125, 34.957995 ], [ -180.000000, 36.527295 ], [ -184.218750, 37.160317 ], [ -187.031250, 38.891033 ], [ -187.031250, 50.457504 ], [ -185.976562, 47.279229 ], [ -177.539062, 44.339565 ] ] ], [ [ [ 187.031250, 35.460670 ], [ 175.781250, 37.160317 ], [ 161.718750, 45.336702 ], [ 156.796875, 55.028022 ], [ 163.476562, 62.431074 ], [ 170.507812, 64.811557 ], [ 177.539062, 67.339861 ], [ 180.000000, 67.542167 ], [ 187.031250, 68.007571 ], [ 187.031250, 63.743631 ], [ 182.109375, 62.593341 ], [ 180.000000, 61.689872 ], [ 174.023438, 58.859224 ], [ 171.562500, 54.418930 ], [ 174.023438, 47.279229 ], [ 182.460938, 44.339565 ], [ 187.031250, 44.024422 ], [ 187.031250, 35.460670 ] ] ] ] } }
{ "type": "Feature", "properties": { "boolean": true, "otherboolean": false, "stringify": "[\"yes\",27.00000000,27,1.4e27,{\"foo\":\"bar\"}]", "escape": "foo\u0001bar,ü\"\\/\u0008\u000c\u000a\u000d\u0009→", "prêt": "ready" }, "geometry": { "type": "MultiPolygon", "coordinates": [ [ [ [ -187.031250, 50.457504 ], [ -185.976562, 47.279229 ], [ -177.539062, 44.339565 ], [ -164.882812, 43.389082 ], [ -153.281250, 46.619261 ], [ -144.492188, 51.179343 ], [ -143.789062, 57.183902 ], [ -148.007812, 61.100789 ], [ -158.554688, 63.860036 ], [ -169.453125, 64.510643 ], [ -177.890625, 62.593341 ], [ -180.000000, 61.689872 ], [ -185.976562, 58.859224 ], [ -187.031250, 56.992883 ], [ -187.031250, 65.730626 ], [ -182.460938, 67.339861 ], [ -180.000000, 67.542167 ], [ -169.101562, 68.269387 ], [ -156.093750, 68.138852 ], [ -144.492188, 66.089364 ], [ -134.648438, 62.431074 ], [ -131.835938, 55.379110 ], [ -133.593750, 48.690960 ], [ -146.250000, 38.616870 ], [ -169.453125, 34.957995 ], [ -180.000000, 36.527295 ], [ -184.218750, 37.160317 ], [ -187.031250, 38.891033 ], [ -187.031250, 50.457504 ] ] ], [ [ [ 187.031250, 68.007571 ], [ 187.031250, 63.743631 ], [ 182.109375, 62.593341 ], [ 180.000000, 61.689872 ], [ 174.023438, 58.859224 ], [ 171.562500, 54.418930 ], [ 174.023438, 47.279229 ], [ 182.460938, 44.339565 ], [ 187.031250, 44.024422 ], [ 187.031250, 35.460670 ], [ 175.781250, 37.160317 ], [ 161.718750, 45.336702 ], [ 156.796875, 55.028022 ], [ 163.476562, 62.431074 ], [ 170.507812, 64.811557 ], [ 177.539062, 67.339861 ], [ 180.000000, 67.542167 ], [ 187.031250, 68.007571 ] ] ] ] } }
,
{ "type": "Feature", "properties": { "zoom": "z0-2" }, "geometry": { "type": "LineString", "coordinates": [ [ -112.851562, 55.178868 ], [ -117.773438, 44.590467 ], [ -104.414062, 51.179343 ] ] } }
] }
@ -20,7 +20,7 @@
,
{ "type": "FeatureCollection", "properties": { "zoom": 1, "x": 0, "y": 0 }, "features": [
{ "type": "FeatureCollection", "properties": { "layer": "in", "version": 2, "extent": 4096 }, "features": [
{ "type": "Feature", "properties": { "boolean": true, "otherboolean": false, "stringify": "[\"yes\",27.00000000,27,1.4e27,{\"foo\":\"bar\"}]", "escape": "foo\u0001bar,ü\"\\/\u0008\u000c\u000a\u000d\u0009→", "prêt": "ready" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ -164.882812, 43.357138 ], [ -153.281250, 46.589069 ], [ -144.492188, 51.179343 ], [ -143.789062, 57.160078 ], [ -148.007812, 61.100789 ], [ -158.554688, 63.860036 ], [ -169.453125, 64.491725 ], [ -177.890625, 62.593341 ], [ -180.000000, 61.669024 ], [ -183.515625, 60.020952 ], [ -183.515625, 66.981666 ], [ -182.460938, 67.339861 ], [ -180.000000, 67.525373 ], [ -169.101562, 68.269387 ], [ -156.093750, 68.138852 ], [ -144.492188, 66.089364 ], [ -134.648438, 62.431074 ], [ -131.835938, 55.379110 ], [ -133.593750, 48.690960 ], [ -146.250000, 38.582526 ], [ -169.453125, 34.921971 ], [ -183.515625, 37.055177 ], [ -183.515625, 46.437857 ], [ -177.539062, 44.339565 ], [ -164.882812, 43.357138 ] ] ] } }
{ "type": "Feature", "properties": { "boolean": true, "otherboolean": false, "stringify": "[\"yes\",27.00000000,27,1.4e27,{\"foo\":\"bar\"}]", "escape": "foo\u0001bar,ü\"\\/\u0008\u000c\u000a\u000d\u0009→", "prêt": "ready" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ -183.515625, 46.437857 ], [ -177.539062, 44.339565 ], [ -164.882812, 43.357138 ], [ -153.281250, 46.589069 ], [ -144.492188, 51.179343 ], [ -143.789062, 57.160078 ], [ -148.007812, 61.100789 ], [ -158.554688, 63.860036 ], [ -169.453125, 64.491725 ], [ -177.890625, 62.593341 ], [ -180.000000, 61.669024 ], [ -183.515625, 60.020952 ], [ -183.515625, 66.981666 ], [ -182.460938, 67.339861 ], [ -180.000000, 67.525373 ], [ -169.101562, 68.269387 ], [ -156.093750, 68.138852 ], [ -144.492188, 66.089364 ], [ -134.648438, 62.431074 ], [ -131.835938, 55.379110 ], [ -133.593750, 48.690960 ], [ -146.250000, 38.582526 ], [ -169.453125, 34.921971 ], [ -183.515625, 37.055177 ], [ -183.515625, 46.437857 ] ] ] } }
,
{ "type": "Feature", "properties": { "zoom": "z0-2" }, "geometry": { "type": "LineString", "coordinates": [ [ -112.851562, 55.178868 ], [ -117.773438, 44.590467 ], [ -104.414062, 51.179343 ] ] } }
] }
@ -28,13 +28,13 @@
,
{ "type": "FeatureCollection", "properties": { "zoom": 1, "x": 1, "y": 0 }, "features": [
{ "type": "FeatureCollection", "properties": { "layer": "in", "version": 2, "extent": 4096 }, "features": [
{ "type": "Feature", "properties": { "boolean": true, "otherboolean": false, "stringify": "[\"yes\",27.00000000,27,1.4e27,{\"foo\":\"bar\"}]", "escape": "foo\u0001bar,ü\"\\/\u0008\u000c\u000a\u000d\u0009→", "prêt": "ready" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 183.515625, 35.995785 ], [ 175.781250, 37.160317 ], [ 161.718750, 45.336702 ], [ 156.796875, 55.002826 ], [ 163.476562, 62.431074 ], [ 170.507812, 64.792848 ], [ 177.539062, 67.339861 ], [ 180.000000, 67.525373 ], [ 183.515625, 67.776025 ], [ 183.515625, 62.935235 ], [ 182.109375, 62.593341 ], [ 180.000000, 61.669024 ], [ 174.023438, 58.836490 ], [ 171.562500, 54.393352 ], [ 174.023438, 47.279229 ], [ 182.460938, 44.339565 ], [ 183.515625, 44.276671 ], [ 183.515625, 35.995785 ] ] ] } }
{ "type": "Feature", "properties": { "boolean": true, "otherboolean": false, "stringify": "[\"yes\",27.00000000,27,1.4e27,{\"foo\":\"bar\"}]", "escape": "foo\u0001bar,ü\"\\/\u0008\u000c\u000a\u000d\u0009→", "prêt": "ready" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 183.515625, 67.776025 ], [ 183.515625, 62.935235 ], [ 182.109375, 62.593341 ], [ 180.000000, 61.669024 ], [ 174.023438, 58.836490 ], [ 171.562500, 54.393352 ], [ 174.023438, 47.279229 ], [ 182.460938, 44.339565 ], [ 183.515625, 44.276671 ], [ 183.515625, 35.995785 ], [ 175.781250, 37.160317 ], [ 161.718750, 45.336702 ], [ 156.796875, 55.002826 ], [ 163.476562, 62.431074 ], [ 170.507812, 64.792848 ], [ 177.539062, 67.339861 ], [ 180.000000, 67.525373 ], [ 183.515625, 67.776025 ] ] ] } }
] }
] }
,
{ "type": "FeatureCollection", "properties": { "zoom": 2, "x": 0, "y": 1 }, "features": [
{ "type": "FeatureCollection", "properties": { "layer": "in", "version": 2, "extent": 4096 }, "features": [
{ "type": "Feature", "properties": { "boolean": true, "otherboolean": false, "stringify": "[\"yes\",27.00000000,27,1.4e27,{\"foo\":\"bar\"}]", "escape": "foo\u0001bar,ü\"\\/\u0008\u000c\u000a\u000d\u0009→", "prêt": "ready" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ -164.882812, 43.341160 ], [ -153.281250, 46.573967 ], [ -144.492188, 51.179343 ], [ -143.789062, 57.148161 ], [ -148.007812, 61.100789 ], [ -158.554688, 63.860036 ], [ -169.453125, 64.482261 ], [ -177.890625, 62.593341 ], [ -180.000000, 61.658595 ], [ -181.757812, 60.844911 ], [ -181.757812, 67.204032 ], [ -150.688477, 67.204032 ], [ -146.821289, 66.513260 ], [ -144.492188, 66.089364 ], [ -134.648438, 62.431074 ], [ -131.835938, 55.379110 ], [ -133.593750, 48.690960 ], [ -146.250000, 38.565348 ], [ -169.453125, 34.903953 ], [ -180.000000, 36.527295 ], [ -181.757812, 36.791691 ], [ -181.757812, 45.828799 ], [ -177.539062, 44.339565 ], [ -164.882812, 43.341160 ] ] ] } }
{ "type": "Feature", "properties": { "boolean": true, "otherboolean": false, "stringify": "[\"yes\",27.00000000,27,1.4e27,{\"foo\":\"bar\"}]", "escape": "foo\u0001bar,ü\"\\/\u0008\u000c\u000a\u000d\u0009→", "prêt": "ready" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ -181.757812, 45.828799 ], [ -177.539062, 44.339565 ], [ -164.882812, 43.341160 ], [ -153.281250, 46.573967 ], [ -144.492188, 51.179343 ], [ -143.789062, 57.148161 ], [ -148.007812, 61.100789 ], [ -158.554688, 63.860036 ], [ -169.453125, 64.482261 ], [ -177.890625, 62.593341 ], [ -180.000000, 61.658595 ], [ -181.757812, 60.844911 ], [ -181.757812, 67.204032 ], [ -150.688477, 67.204032 ], [ -146.821289, 66.513260 ], [ -144.492188, 66.089364 ], [ -134.648438, 62.431074 ], [ -131.835938, 55.379110 ], [ -133.593750, 48.690960 ], [ -146.250000, 38.565348 ], [ -169.453125, 34.903953 ], [ -180.000000, 36.527295 ], [ -181.757812, 36.791691 ], [ -181.757812, 45.828799 ] ] ] } }
,
{ "type": "Feature", "properties": { "zoom": "z0-2" }, "geometry": { "type": "LineString", "coordinates": [ [ -112.851562, 55.178868 ], [ -117.773438, 44.590467 ], [ -104.414062, 51.179343 ] ] } }
] }
@ -42,43 +42,43 @@
,
{ "type": "FeatureCollection", "properties": { "zoom": 2, "x": 0, "y": 0 }, "features": [
{ "type": "FeatureCollection", "properties": { "layer": "in", "version": 2, "extent": 4096 }, "features": [
{ "type": "Feature", "properties": { "boolean": true, "otherboolean": false, "stringify": "[\"yes\",27.00000000,27,1.4e27,{\"foo\":\"bar\"}]", "escape": "foo\u0001bar,ü\"\\/\u0008\u000c\u000a\u000d\u0009→", "prêt": "ready" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ -156.093750, 68.138852 ], [ -146.821289, 66.513260 ], [ -144.492188, 66.089364 ], [ -143.679199, 65.802776 ], [ -181.757812, 65.802776 ], [ -181.757812, 67.390599 ], [ -180.000000, 67.516972 ], [ -169.101562, 68.269387 ], [ -156.093750, 68.138852 ] ] ] } }
{ "type": "Feature", "properties": { "boolean": true, "otherboolean": false, "stringify": "[\"yes\",27.00000000,27,1.4e27,{\"foo\":\"bar\"}]", "escape": "foo\u0001bar,ü\"\\/\u0008\u000c\u000a\u000d\u0009→", "prêt": "ready" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ -169.101562, 68.269387 ], [ -156.093750, 68.138852 ], [ -146.821289, 66.513260 ], [ -144.492188, 66.089364 ], [ -143.679199, 65.802776 ], [ -181.757812, 65.802776 ], [ -181.757812, 67.390599 ], [ -180.000000, 67.516972 ], [ -169.101562, 68.269387 ] ] ] } }
] }
] }
,
{ "type": "FeatureCollection", "properties": { "zoom": 2, "x": 3, "y": 1 }, "features": [
{ "type": "FeatureCollection", "properties": { "layer": "in", "version": 2, "extent": 4096 }, "features": [
{ "type": "Feature", "properties": { "boolean": true, "otherboolean": false, "stringify": "[\"yes\",27.00000000,27,1.4e27,{\"foo\":\"bar\"}]", "escape": "foo\u0001bar,ü\"\\/\u0008\u000c\u000a\u000d\u0009→", "prêt": "ready" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 181.757812, 36.261992 ], [ 175.781250, 37.160317 ], [ 161.718750, 45.336702 ], [ 156.796875, 54.990222 ], [ 163.476562, 62.431074 ], [ 170.507812, 64.783488 ], [ 175.187988, 66.513260 ], [ 177.143555, 67.204032 ], [ 181.757812, 67.204032 ], [ 181.757812, 62.441242 ], [ 180.000000, 61.658595 ], [ 174.023438, 58.825118 ], [ 171.562500, 54.380557 ], [ 174.023438, 47.279229 ], [ 181.757812, 44.590467 ], [ 181.757812, 36.261992 ] ] ] } }
{ "type": "Feature", "properties": { "boolean": true, "otherboolean": false, "stringify": "[\"yes\",27.00000000,27,1.4e27,{\"foo\":\"bar\"}]", "escape": "foo\u0001bar,ü\"\\/\u0008\u000c\u000a\u000d\u0009→", "prêt": "ready" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 181.757812, 67.204032 ], [ 181.757812, 62.441242 ], [ 180.000000, 61.658595 ], [ 174.023438, 58.825118 ], [ 171.562500, 54.380557 ], [ 174.023438, 47.279229 ], [ 181.757812, 44.590467 ], [ 181.757812, 36.261992 ], [ 175.781250, 37.160317 ], [ 161.718750, 45.336702 ], [ 156.796875, 54.990222 ], [ 163.476562, 62.431074 ], [ 170.507812, 64.783488 ], [ 175.187988, 66.513260 ], [ 177.143555, 67.204032 ], [ 181.757812, 67.204032 ] ] ] } }
] }
] }
,
{ "type": "FeatureCollection", "properties": { "zoom": 2, "x": 3, "y": 0 }, "features": [
{ "type": "FeatureCollection", "properties": { "layer": "in", "version": 2, "extent": 4096 }, "features": [
{ "type": "Feature", "properties": { "boolean": true, "otherboolean": false, "stringify": "[\"yes\",27.00000000,27,1.4e27,{\"foo\":\"bar\"}]", "escape": "foo\u0001bar,ü\"\\/\u0008\u000c\u000a\u000d\u0009→", "prêt": "ready" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 181.757812, 65.802776 ], [ 173.232422, 65.802776 ], [ 175.187988, 66.513260 ], [ 177.539062, 67.339861 ], [ 181.757812, 67.642676 ], [ 181.757812, 65.802776 ] ] ] } }
{ "type": "Feature", "properties": { "boolean": true, "otherboolean": false, "stringify": "[\"yes\",27.00000000,27,1.4e27,{\"foo\":\"bar\"}]", "escape": "foo\u0001bar,ü\"\\/\u0008\u000c\u000a\u000d\u0009→", "prêt": "ready" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 181.757812, 67.642676 ], [ 181.757812, 65.802776 ], [ 173.232422, 65.802776 ], [ 175.187988, 66.513260 ], [ 177.539062, 67.339861 ], [ 181.757812, 67.642676 ] ] ] } }
] }
] }
,
{ "type": "FeatureCollection", "properties": { "zoom": 3, "x": 0, "y": 3 }, "features": [
{ "type": "FeatureCollection", "properties": { "layer": "in", "version": 2, "extent": 4096 }, "features": [
{ "type": "Feature", "properties": { "boolean": true, "otherboolean": false, "stringify": "[\"yes\",27.00000000,27,1.4e27,{\"foo\":\"bar\"}]", "escape": "foo\u0001bar,ü\"\\/\u0008\u000c\u000a\u000d\u0009→", "prêt": "ready" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ -143.404541, 40.979898 ], [ -146.250000, 38.556757 ], [ -169.453125, 34.894942 ], [ -180.000000, 36.527295 ], [ -180.878906, 36.659606 ], [ -180.878906, 41.640078 ], [ -142.613525, 41.640078 ], [ -143.404541, 40.979898 ] ] ] } }
{ "type": "Feature", "properties": { "boolean": true, "otherboolean": false, "stringify": "[\"yes\",27.00000000,27,1.4e27,{\"foo\":\"bar\"}]", "escape": "foo\u0001bar,ü\"\\/\u0008\u000c\u000a\u000d\u0009→", "prêt": "ready" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ -142.613525, 41.640078 ], [ -143.404541, 40.979898 ], [ -146.250000, 38.556757 ], [ -169.453125, 34.894942 ], [ -180.000000, 36.527295 ], [ -180.878906, 36.659606 ], [ -180.878906, 41.640078 ], [ -142.613525, 41.640078 ] ] ] } }
] }
] }
,
{ "type": "FeatureCollection", "properties": { "zoom": 3, "x": 0, "y": 2 }, "features": [
{ "type": "FeatureCollection", "properties": { "layer": "in", "version": 2, "extent": 4096 }, "features": [
{ "type": "Feature", "properties": { "boolean": true, "otherboolean": false, "stringify": "[\"yes\",27.00000000,27,1.4e27,{\"foo\":\"bar\"}]", "escape": "foo\u0001bar,ü\"\\/\u0008\u000c\u000a\u000d\u0009→", "prêt": "ready" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ -164.882812, 43.333169 ], [ -153.281250, 46.566414 ], [ -144.492188, 51.179343 ], [ -143.789062, 57.142200 ], [ -148.007812, 61.100789 ], [ -158.554688, 63.860036 ], [ -169.453125, 64.477528 ], [ -177.890625, 62.593341 ], [ -180.000000, 61.653379 ], [ -180.878906, 61.249102 ], [ -180.878906, 66.861082 ], [ -148.754883, 66.861082 ], [ -146.821289, 66.513260 ], [ -144.492188, 66.089364 ], [ -135.000000, 62.573106 ], [ -134.648438, 62.431074 ], [ -134.121094, 61.217379 ], [ -134.121094, 48.305121 ], [ -135.000000, 47.650588 ], [ -144.195557, 40.313043 ], [ -180.878906, 40.313043 ], [ -180.878906, 45.521744 ], [ -177.539062, 44.339565 ], [ -164.882812, 43.333169 ] ] ] } }
{ "type": "Feature", "properties": { "boolean": true, "otherboolean": false, "stringify": "[\"yes\",27.00000000,27,1.4e27,{\"foo\":\"bar\"}]", "escape": "foo\u0001bar,ü\"\\/\u0008\u000c\u000a\u000d\u0009→", "prêt": "ready" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ -180.878906, 45.521744 ], [ -177.539062, 44.339565 ], [ -164.882812, 43.333169 ], [ -153.281250, 46.566414 ], [ -144.492188, 51.179343 ], [ -143.789062, 57.142200 ], [ -148.007812, 61.100789 ], [ -158.554688, 63.860036 ], [ -169.453125, 64.477528 ], [ -177.890625, 62.593341 ], [ -180.000000, 61.653379 ], [ -180.878906, 61.249102 ], [ -180.878906, 66.861082 ], [ -148.754883, 66.861082 ], [ -146.821289, 66.513260 ], [ -144.492188, 66.089364 ], [ -135.000000, 62.573106 ], [ -134.648438, 62.431074 ], [ -134.121094, 61.217379 ], [ -134.121094, 48.305121 ], [ -135.000000, 47.650588 ], [ -144.195557, 40.313043 ], [ -180.878906, 40.313043 ], [ -180.878906, 45.521744 ] ] ] } }
] }
] }
,
{ "type": "FeatureCollection", "properties": { "zoom": 3, "x": 0, "y": 1 }, "features": [
{ "type": "FeatureCollection", "properties": { "layer": "in", "version": 2, "extent": 4096 }, "features": [
{ "type": "Feature", "properties": { "boolean": true, "otherboolean": false, "stringify": "[\"yes\",27.00000000,27,1.4e27,{\"foo\":\"bar\"}]", "escape": "foo\u0001bar,ü\"\\/\u0008\u000c\u000a\u000d\u0009→", "prêt": "ready" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ -156.093750, 68.138852 ], [ -146.821289, 66.513260 ], [ -144.887695, 66.160511 ], [ -180.878906, 66.160511 ], [ -180.878906, 67.453869 ], [ -180.000000, 67.516972 ], [ -169.101562, 68.269387 ], [ -156.093750, 68.138852 ] ] ] } }
{ "type": "Feature", "properties": { "boolean": true, "otherboolean": false, "stringify": "[\"yes\",27.00000000,27,1.4e27,{\"foo\":\"bar\"}]", "escape": "foo\u0001bar,ü\"\\/\u0008\u000c\u000a\u000d\u0009→", "prêt": "ready" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ -169.101562, 68.269387 ], [ -156.093750, 68.138852 ], [ -146.821289, 66.513260 ], [ -144.887695, 66.160511 ], [ -180.878906, 66.160511 ], [ -180.878906, 67.453869 ], [ -180.000000, 67.516972 ], [ -169.101562, 68.269387 ] ] ] } }
] }
] }
,
{ "type": "FeatureCollection", "properties": { "zoom": 3, "x": 1, "y": 2 }, "features": [
{ "type": "FeatureCollection", "properties": { "layer": "in", "version": 2, "extent": 4096 }, "features": [
{ "type": "Feature", "properties": { "boolean": true, "otherboolean": false, "stringify": "[\"yes\",27.00000000,27,1.4e27,{\"foo\":\"bar\"}]", "escape": "foo\u0001bar,ü\"\\/\u0008\u000c\u000a\u000d\u0009→", "prêt": "ready" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ -135.000000, 62.573106 ], [ -134.648438, 62.431074 ], [ -131.835938, 55.379110 ], [ -133.593750, 48.690960 ], [ -135.000000, 47.650588 ], [ -135.878906, 46.987747 ], [ -135.878906, 62.915233 ], [ -135.000000, 62.573106 ] ] ] } }
{ "type": "Feature", "properties": { "boolean": true, "otherboolean": false, "stringify": "[\"yes\",27.00000000,27,1.4e27,{\"foo\":\"bar\"}]", "escape": "foo\u0001bar,ü\"\\/\u0008\u000c\u000a\u000d\u0009→", "prêt": "ready" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ -135.878906, 62.915233 ], [ -135.000000, 62.573106 ], [ -134.648438, 62.431074 ], [ -131.835938, 55.379110 ], [ -133.593750, 48.690960 ], [ -135.000000, 47.650588 ], [ -135.878906, 46.987747 ], [ -135.878906, 62.915233 ] ] ] } }
] }
] }
,
@ -96,31 +96,31 @@
,
{ "type": "FeatureCollection", "properties": { "zoom": 3, "x": 7, "y": 3 }, "features": [
{ "type": "FeatureCollection", "properties": { "layer": "in", "version": 2, "extent": 4096 }, "features": [
{ "type": "Feature", "properties": { "boolean": true, "otherboolean": false, "stringify": "[\"yes\",27.00000000,27,1.4e27,{\"foo\":\"bar\"}]", "escape": "foo\u0001bar,ü\"\\/\u0008\u000c\u000a\u000d\u0009→", "prêt": "ready" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 180.878906, 36.385913 ], [ 180.000000, 36.527295 ], [ 175.781250, 37.160317 ], [ 169.420166, 40.979898 ], [ 168.288574, 41.640078 ], [ 180.878906, 41.640078 ], [ 180.878906, 36.385913 ] ] ] } }
{ "type": "Feature", "properties": { "boolean": true, "otherboolean": false, "stringify": "[\"yes\",27.00000000,27,1.4e27,{\"foo\":\"bar\"}]", "escape": "foo\u0001bar,ü\"\\/\u0008\u000c\u000a\u000d\u0009→", "prêt": "ready" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 180.878906, 41.640078 ], [ 180.878906, 36.385913 ], [ 180.000000, 36.527295 ], [ 175.781250, 37.160317 ], [ 169.420166, 40.979898 ], [ 168.288574, 41.640078 ], [ 180.878906, 41.640078 ] ] ] } }
] }
] }
,
{ "type": "FeatureCollection", "properties": { "zoom": 3, "x": 7, "y": 2 }, "features": [
{ "type": "FeatureCollection", "properties": { "layer": "in", "version": 2, "extent": 4096 }, "features": [
{ "type": "Feature", "properties": { "boolean": true, "otherboolean": false, "stringify": "[\"yes\",27.00000000,27,1.4e27,{\"foo\":\"bar\"}]", "escape": "foo\u0001bar,ü\"\\/\u0008\u000c\u000a\u000d\u0009→", "prêt": "ready" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 180.878906, 40.313043 ], [ 170.562744, 40.313043 ], [ 169.420166, 40.979898 ], [ 161.718750, 45.336702 ], [ 156.796875, 54.983918 ], [ 163.476562, 62.431074 ], [ 170.507812, 64.778807 ], [ 175.187988, 66.513260 ], [ 176.165771, 66.861082 ], [ 180.878906, 66.861082 ], [ 180.878906, 62.047288 ], [ 180.000000, 61.653379 ], [ 174.023438, 58.819430 ], [ 171.562500, 54.374158 ], [ 174.023438, 47.279229 ], [ 180.878906, 44.902578 ], [ 180.878906, 40.313043 ] ] ] } }
{ "type": "Feature", "properties": { "boolean": true, "otherboolean": false, "stringify": "[\"yes\",27.00000000,27,1.4e27,{\"foo\":\"bar\"}]", "escape": "foo\u0001bar,ü\"\\/\u0008\u000c\u000a\u000d\u0009→", "prêt": "ready" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 180.878906, 66.861082 ], [ 180.878906, 62.047288 ], [ 180.000000, 61.653379 ], [ 174.023438, 58.819430 ], [ 171.562500, 54.374158 ], [ 174.023438, 47.279229 ], [ 180.878906, 44.902578 ], [ 180.878906, 40.313043 ], [ 170.562744, 40.313043 ], [ 169.420166, 40.979898 ], [ 161.718750, 45.336702 ], [ 156.796875, 54.983918 ], [ 163.476562, 62.431074 ], [ 170.507812, 64.778807 ], [ 175.187988, 66.513260 ], [ 176.165771, 66.861082 ], [ 180.878906, 66.861082 ] ] ] } }
] }
] }
,
{ "type": "FeatureCollection", "properties": { "zoom": 3, "x": 7, "y": 1 }, "features": [
{ "type": "FeatureCollection", "properties": { "layer": "in", "version": 2, "extent": 4096 }, "features": [
{ "type": "Feature", "properties": { "boolean": true, "otherboolean": false, "stringify": "[\"yes\",27.00000000,27,1.4e27,{\"foo\":\"bar\"}]", "escape": "foo\u0001bar,ü\"\\/\u0008\u000c\u000a\u000d\u0009→", "prêt": "ready" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 180.878906, 66.160511 ], [ 174.210205, 66.160511 ], [ 175.187988, 66.513260 ], [ 177.539062, 67.339861 ], [ 180.878906, 67.579908 ], [ 180.878906, 66.160511 ] ] ] } }
{ "type": "Feature", "properties": { "boolean": true, "otherboolean": false, "stringify": "[\"yes\",27.00000000,27,1.4e27,{\"foo\":\"bar\"}]", "escape": "foo\u0001bar,ü\"\\/\u0008\u000c\u000a\u000d\u0009→", "prêt": "ready" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 180.878906, 67.579908 ], [ 180.878906, 66.160511 ], [ 174.210205, 66.160511 ], [ 175.187988, 66.513260 ], [ 177.539062, 67.339861 ], [ 180.878906, 67.579908 ] ] ] } }
] }
] }
,
{ "type": "FeatureCollection", "properties": { "zoom": 4, "x": 0, "y": 6 }, "features": [
{ "type": "FeatureCollection", "properties": { "layer": "in", "version": 2, "extent": 4096 }, "features": [
{ "type": "Feature", "properties": { "boolean": true, "otherboolean": false, "stringify": "[\"yes\",27.00000000,27,1.4e27,{\"foo\":\"bar\"}]", "escape": "foo\u0001bar,ü\"\\/\u0008\u000c\u000a\u000d\u0009→", "prêt": "ready" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ -157.060547, 36.866438 ], [ -157.500000, 36.800488 ], [ -169.453125, 34.890437 ], [ -180.000000, 36.522881 ], [ -180.439453, 36.589068 ], [ -180.439453, 41.310824 ], [ -157.060547, 41.310824 ], [ -157.060547, 36.866438 ] ] ] } }
{ "type": "Feature", "properties": { "boolean": true, "otherboolean": false, "stringify": "[\"yes\",27.00000000,27,1.4e27,{\"foo\":\"bar\"}]", "escape": "foo\u0001bar,ü\"\\/\u0008\u000c\u000a\u000d\u0009→", "prêt": "ready" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ -157.060547, 41.310824 ], [ -157.060547, 36.866438 ], [ -157.500000, 36.800488 ], [ -169.453125, 34.890437 ], [ -180.000000, 36.522881 ], [ -180.439453, 36.589068 ], [ -180.439453, 41.310824 ], [ -157.060547, 41.310824 ] ] ] } }
] }
] }
,
{ "type": "FeatureCollection", "properties": { "zoom": 4, "x": 0, "y": 5 }, "features": [
{ "type": "FeatureCollection", "properties": { "layer": "in", "version": 2, "extent": 4096 }, "features": [
{ "type": "Feature", "properties": { "boolean": true, "otherboolean": false, "stringify": "[\"yes\",27.00000000,27,1.4e27,{\"foo\":\"bar\"}]", "escape": "foo\u0001bar,ü\"\\/\u0008\u000c\u000a\u000d\u0009→", "prêt": "ready" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ -164.882812, 43.329174 ], [ -157.500000, 45.406164 ], [ -157.060547, 45.529441 ], [ -157.060547, 40.647304 ], [ -180.439453, 40.647304 ], [ -180.439453, 45.367584 ], [ -177.539062, 44.339565 ], [ -164.882812, 43.329174 ] ] ] } }
{ "type": "Feature", "properties": { "boolean": true, "otherboolean": false, "stringify": "[\"yes\",27.00000000,27,1.4e27,{\"foo\":\"bar\"}]", "escape": "foo\u0001bar,ü\"\\/\u0008\u000c\u000a\u000d\u0009→", "prêt": "ready" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ -157.060547, 45.529441 ], [ -157.060547, 40.647304 ], [ -180.439453, 40.647304 ], [ -180.439453, 45.367584 ], [ -177.539062, 44.339565 ], [ -164.882812, 43.329174 ], [ -157.500000, 45.406164 ], [ -157.060547, 45.529441 ] ] ] } }
] }
] }
,
@ -132,43 +132,43 @@
,
{ "type": "FeatureCollection", "properties": { "zoom": 4, "x": 0, "y": 3 }, "features": [
{ "type": "FeatureCollection", "properties": { "layer": "in", "version": 2, "extent": 4096 }, "features": [
{ "type": "Feature", "properties": { "boolean": true, "otherboolean": false, "stringify": "[\"yes\",27.00000000,27,1.4e27,{\"foo\":\"bar\"}]", "escape": "foo\u0001bar,ü\"\\/\u0008\u000c\u000a\u000d\u0009→", "prêt": "ready" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ -157.500000, 68.153165 ], [ -157.060547, 68.149077 ], [ -157.060547, 66.337505 ], [ -180.439453, 66.337505 ], [ -180.439453, 67.485442 ], [ -180.000000, 67.514872 ], [ -169.101562, 68.269387 ], [ -157.500000, 68.153165 ] ] ] } }
{ "type": "Feature", "properties": { "boolean": true, "otherboolean": false, "stringify": "[\"yes\",27.00000000,27,1.4e27,{\"foo\":\"bar\"}]", "escape": "foo\u0001bar,ü\"\\/\u0008\u000c\u000a\u000d\u0009→", "prêt": "ready" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ -169.101562, 68.269387 ], [ -157.500000, 68.153165 ], [ -157.060547, 68.149077 ], [ -157.060547, 66.337505 ], [ -180.439453, 66.337505 ], [ -180.439453, 67.485442 ], [ -180.000000, 67.514872 ], [ -169.101562, 68.269387 ] ] ] } }
] }
] }
,
{ "type": "FeatureCollection", "properties": { "zoom": 4, "x": 1, "y": 6 }, "features": [
{ "type": "FeatureCollection", "properties": { "layer": "in", "version": 2, "extent": 4096 }, "features": [
{ "type": "Feature", "properties": { "boolean": true, "otherboolean": false, "stringify": "[\"yes\",27.00000000,27,1.4e27,{\"foo\":\"bar\"}]", "escape": "foo\u0001bar,ü\"\\/\u0008\u000c\u000a\u000d\u0009→", "prêt": "ready" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ -143.410034, 40.979898 ], [ -146.250000, 38.552461 ], [ -157.500000, 36.800488 ], [ -157.939453, 36.730080 ], [ -157.939453, 41.310824 ], [ -143.014526, 41.310824 ], [ -143.410034, 40.979898 ] ] ] } }
{ "type": "Feature", "properties": { "boolean": true, "otherboolean": false, "stringify": "[\"yes\",27.00000000,27,1.4e27,{\"foo\":\"bar\"}]", "escape": "foo\u0001bar,ü\"\\/\u0008\u000c\u000a\u000d\u0009→", "prêt": "ready" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ -143.014526, 41.310824 ], [ -143.410034, 40.979898 ], [ -146.250000, 38.552461 ], [ -157.500000, 36.800488 ], [ -157.939453, 36.730080 ], [ -157.939453, 41.310824 ], [ -143.014526, 41.310824 ] ] ] } }
] }
] }
,
{ "type": "FeatureCollection", "properties": { "zoom": 4, "x": 1, "y": 5 }, "features": [
{ "type": "FeatureCollection", "properties": { "layer": "in", "version": 2, "extent": 4096 }, "features": [
{ "type": "Feature", "properties": { "boolean": true, "otherboolean": false, "stringify": "[\"yes\",27.00000000,27,1.4e27,{\"foo\":\"bar\"}]", "escape": "foo\u0001bar,ü\"\\/\u0008\u000c\u000a\u000d\u0009→", "prêt": "ready" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ -153.281250, 46.562637 ], [ -144.492188, 51.179343 ], [ -143.959351, 55.776573 ], [ -143.931885, 56.022948 ], [ -134.560547, 56.022948 ], [ -134.560547, 47.978891 ], [ -135.000000, 47.650588 ], [ -143.800049, 40.647304 ], [ -157.939453, 40.647304 ], [ -157.939453, 45.286482 ], [ -157.500000, 45.406164 ], [ -153.281250, 46.562637 ] ] ] } }
{ "type": "Feature", "properties": { "boolean": true, "otherboolean": false, "stringify": "[\"yes\",27.00000000,27,1.4e27,{\"foo\":\"bar\"}]", "escape": "foo\u0001bar,ü\"\\/\u0008\u000c\u000a\u000d\u0009→", "prêt": "ready" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ -134.560547, 56.022948 ], [ -134.560547, 47.978891 ], [ -135.000000, 47.650588 ], [ -143.800049, 40.647304 ], [ -157.939453, 40.647304 ], [ -157.939453, 45.286482 ], [ -157.500000, 45.406164 ], [ -153.281250, 46.562637 ], [ -144.492188, 51.179343 ], [ -143.959351, 55.776573 ], [ -143.931885, 56.022948 ], [ -134.560547, 56.022948 ] ] ] } }
] }
] }
,
{ "type": "FeatureCollection", "properties": { "zoom": 4, "x": 1, "y": 4 }, "features": [
{ "type": "FeatureCollection", "properties": { "layer": "in", "version": 2, "extent": 4096 }, "features": [
{ "type": "Feature", "properties": { "boolean": true, "otherboolean": false, "stringify": "[\"yes\",27.00000000,27,1.4e27,{\"foo\":\"bar\"}]", "escape": "foo\u0001bar,ü\"\\/\u0008\u000c\u000a\u000d\u0009→", "prêt": "ready" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ -143.789062, 57.139220 ], [ -148.007812, 61.100789 ], [ -157.500000, 63.597448 ], [ -157.939453, 63.707156 ], [ -157.939453, 66.687784 ], [ -147.782593, 66.687784 ], [ -146.815796, 66.513260 ], [ -144.492188, 66.089364 ], [ -135.000000, 62.570575 ], [ -134.648438, 62.431074 ], [ -134.560547, 62.232115 ], [ -134.560547, 55.528631 ], [ -143.992310, 55.528631 ], [ -143.959351, 55.776573 ], [ -143.789062, 57.139220 ] ] ] } }
{ "type": "Feature", "properties": { "boolean": true, "otherboolean": false, "stringify": "[\"yes\",27.00000000,27,1.4e27,{\"foo\":\"bar\"}]", "escape": "foo\u0001bar,ü\"\\/\u0008\u000c\u000a\u000d\u0009→", "prêt": "ready" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ -147.782593, 66.687784 ], [ -146.815796, 66.513260 ], [ -144.492188, 66.089364 ], [ -135.000000, 62.570575 ], [ -134.648438, 62.431074 ], [ -134.560547, 62.232115 ], [ -134.560547, 55.528631 ], [ -143.992310, 55.528631 ], [ -143.959351, 55.776573 ], [ -143.789062, 57.139220 ], [ -148.007812, 61.100789 ], [ -157.500000, 63.597448 ], [ -157.939453, 63.707156 ], [ -157.939453, 66.687784 ], [ -147.782593, 66.687784 ] ] ] } }
] }
] }
,
{ "type": "FeatureCollection", "properties": { "zoom": 4, "x": 1, "y": 3 }, "features": [
{ "type": "FeatureCollection", "properties": { "layer": "in", "version": 2, "extent": 4096 }, "features": [
{ "type": "Feature", "properties": { "boolean": true, "otherboolean": false, "stringify": "[\"yes\",27.00000000,27,1.4e27,{\"foo\":\"bar\"}]", "escape": "foo\u0001bar,ü\"\\/\u0008\u000c\u000a\u000d\u0009→", "prêt": "ready" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ -157.500000, 68.153165 ], [ -156.093750, 68.138852 ], [ -146.815796, 66.513260 ], [ -145.848999, 66.337505 ], [ -157.939453, 66.337505 ], [ -157.939453, 68.159297 ], [ -157.500000, 68.153165 ] ] ] } }
{ "type": "Feature", "properties": { "boolean": true, "otherboolean": false, "stringify": "[\"yes\",27.00000000,27,1.4e27,{\"foo\":\"bar\"}]", "escape": "foo\u0001bar,ü\"\\/\u0008\u000c\u000a\u000d\u0009→", "prêt": "ready" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ -157.939453, 68.159297 ], [ -157.500000, 68.153165 ], [ -156.093750, 68.138852 ], [ -146.815796, 66.513260 ], [ -145.848999, 66.337505 ], [ -157.939453, 66.337505 ], [ -157.939453, 68.159297 ] ] ] } }
] }
] }
,
{ "type": "FeatureCollection", "properties": { "zoom": 4, "x": 2, "y": 5 }, "features": [
{ "type": "FeatureCollection", "properties": { "layer": "in", "version": 2, "extent": 4096 }, "features": [
{ "type": "Feature", "properties": { "boolean": true, "otherboolean": false, "stringify": "[\"yes\",27.00000000,27,1.4e27,{\"foo\":\"bar\"}]", "escape": "foo\u0001bar,ü\"\\/\u0008\u000c\u000a\u000d\u0009→", "prêt": "ready" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ -131.984253, 55.776573 ], [ -131.835938, 55.379110 ], [ -133.593750, 48.690960 ], [ -135.000000, 47.650588 ], [ -135.439453, 47.320207 ], [ -135.439453, 56.022948 ], [ -132.072144, 56.022948 ], [ -131.984253, 55.776573 ] ] ] } }
{ "type": "Feature", "properties": { "boolean": true, "otherboolean": false, "stringify": "[\"yes\",27.00000000,27,1.4e27,{\"foo\":\"bar\"}]", "escape": "foo\u0001bar,ü\"\\/\u0008\u000c\u000a\u000d\u0009→", "prêt": "ready" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ -132.072144, 56.022948 ], [ -131.984253, 55.776573 ], [ -131.835938, 55.379110 ], [ -133.593750, 48.690960 ], [ -135.000000, 47.650588 ], [ -135.439453, 47.320207 ], [ -135.439453, 56.022948 ], [ -132.072144, 56.022948 ] ] ] } }
] }
] }
,
{ "type": "FeatureCollection", "properties": { "zoom": 4, "x": 2, "y": 4 }, "features": [
{ "type": "FeatureCollection", "properties": { "layer": "in", "version": 2, "extent": 4096 }, "features": [
{ "type": "Feature", "properties": { "boolean": true, "otherboolean": false, "stringify": "[\"yes\",27.00000000,27,1.4e27,{\"foo\":\"bar\"}]", "escape": "foo\u0001bar,ü\"\\/\u0008\u000c\u000a\u000d\u0009→", "prêt": "ready" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ -135.000000, 62.570575 ], [ -134.648438, 62.431074 ], [ -131.984253, 55.776573 ], [ -131.890869, 55.528631 ], [ -135.439453, 55.528631 ], [ -135.439453, 62.744665 ], [ -135.000000, 62.570575 ] ] ] } }
{ "type": "Feature", "properties": { "boolean": true, "otherboolean": false, "stringify": "[\"yes\",27.00000000,27,1.4e27,{\"foo\":\"bar\"}]", "escape": "foo\u0001bar,ü\"\\/\u0008\u000c\u000a\u000d\u0009→", "prêt": "ready" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ -135.439453, 62.744665 ], [ -135.000000, 62.570575 ], [ -134.648438, 62.431074 ], [ -131.984253, 55.776573 ], [ -131.890869, 55.528631 ], [ -135.439453, 55.528631 ], [ -135.439453, 62.744665 ] ] ] } }
] }
] }
,
@ -186,55 +186,55 @@
,
{ "type": "FeatureCollection", "properties": { "zoom": 4, "x": 14, "y": 5 }, "features": [
{ "type": "FeatureCollection", "properties": { "layer": "in", "version": 2, "extent": 4096 }, "features": [
{ "type": "Feature", "properties": { "boolean": true, "otherboolean": false, "stringify": "[\"yes\",27.00000000,27,1.4e27,{\"foo\":\"bar\"}]", "escape": "foo\u0001bar,ü\"\\/\u0008\u000c\u000a\u000d\u0009→", "prêt": "ready" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 157.939453, 52.915527 ], [ 157.500000, 53.722717 ], [ 156.796875, 54.980766 ], [ 157.445068, 55.776573 ], [ 157.648315, 56.022948 ], [ 157.939453, 56.022948 ], [ 157.939453, 52.915527 ] ] ] } }
{ "type": "Feature", "properties": { "boolean": true, "otherboolean": false, "stringify": "[\"yes\",27.00000000,27,1.4e27,{\"foo\":\"bar\"}]", "escape": "foo\u0001bar,ü\"\\/\u0008\u000c\u000a\u000d\u0009→", "prêt": "ready" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 157.939453, 56.022948 ], [ 157.939453, 52.915527 ], [ 157.500000, 53.722717 ], [ 156.796875, 54.980766 ], [ 157.445068, 55.776573 ], [ 157.648315, 56.022948 ], [ 157.939453, 56.022948 ] ] ] } }
] }
] }
,
{ "type": "FeatureCollection", "properties": { "zoom": 4, "x": 14, "y": 4 }, "features": [
{ "type": "FeatureCollection", "properties": { "layer": "in", "version": 2, "extent": 4096 }, "features": [
{ "type": "Feature", "properties": { "boolean": true, "otherboolean": false, "stringify": "[\"yes\",27.00000000,27,1.4e27,{\"foo\":\"bar\"}]", "escape": "foo\u0001bar,ü\"\\/\u0008\u000c\u000a\u000d\u0009→", "prêt": "ready" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 157.939453, 55.528631 ], [ 157.241821, 55.528631 ], [ 157.445068, 55.776573 ], [ 157.500000, 55.841398 ], [ 157.939453, 56.371335 ], [ 157.939453, 55.528631 ] ] ] } }
{ "type": "Feature", "properties": { "boolean": true, "otherboolean": false, "stringify": "[\"yes\",27.00000000,27,1.4e27,{\"foo\":\"bar\"}]", "escape": "foo\u0001bar,ü\"\\/\u0008\u000c\u000a\u000d\u0009→", "prêt": "ready" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 157.939453, 56.371335 ], [ 157.939453, 55.528631 ], [ 157.241821, 55.528631 ], [ 157.445068, 55.776573 ], [ 157.500000, 55.841398 ], [ 157.939453, 56.371335 ] ] ] } }
] }
] }
,
{ "type": "FeatureCollection", "properties": { "zoom": 4, "x": 15, "y": 6 }, "features": [
{ "type": "FeatureCollection", "properties": { "layer": "in", "version": 2, "extent": 4096 }, "features": [
{ "type": "Feature", "properties": { "boolean": true, "otherboolean": false, "stringify": "[\"yes\",27.00000000,27,1.4e27,{\"foo\":\"bar\"}]", "escape": "foo\u0001bar,ü\"\\/\u0008\u000c\u000a\u000d\u0009→", "prêt": "ready" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 180.439453, 36.456636 ], [ 180.000000, 36.522881 ], [ 175.781250, 37.160317 ], [ 169.425659, 40.979898 ], [ 168.859863, 41.310824 ], [ 180.439453, 41.310824 ], [ 180.439453, 36.456636 ] ] ] } }
{ "type": "Feature", "properties": { "boolean": true, "otherboolean": false, "stringify": "[\"yes\",27.00000000,27,1.4e27,{\"foo\":\"bar\"}]", "escape": "foo\u0001bar,ü\"\\/\u0008\u000c\u000a\u000d\u0009→", "prêt": "ready" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 180.439453, 41.310824 ], [ 180.439453, 36.456636 ], [ 180.000000, 36.522881 ], [ 175.781250, 37.160317 ], [ 169.425659, 40.979898 ], [ 168.859863, 41.310824 ], [ 180.439453, 41.310824 ] ] ] } }
] }
] }
,
{ "type": "FeatureCollection", "properties": { "zoom": 4, "x": 15, "y": 5 }, "features": [
{ "type": "FeatureCollection", "properties": { "layer": "in", "version": 2, "extent": 4096 }, "features": [
{ "type": "Feature", "properties": { "boolean": true, "otherboolean": false, "stringify": "[\"yes\",27.00000000,27,1.4e27,{\"foo\":\"bar\"}]", "escape": "foo\u0001bar,ü\"\\/\u0008\u000c\u000a\u000d\u0009→", "prêt": "ready" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 171.562500, 54.370959 ], [ 174.023438, 47.279229 ], [ 180.439453, 45.058001 ], [ 180.439453, 40.647304 ], [ 169.991455, 40.647304 ], [ 169.425659, 40.979898 ], [ 161.718750, 45.336702 ], [ 157.500000, 53.722717 ], [ 157.060547, 54.514704 ], [ 157.060547, 55.307264 ], [ 157.648315, 56.022948 ], [ 172.441406, 56.022948 ], [ 172.309570, 55.776573 ], [ 171.562500, 54.370959 ] ] ] } }
{ "type": "Feature", "properties": { "boolean": true, "otherboolean": false, "stringify": "[\"yes\",27.00000000,27,1.4e27,{\"foo\":\"bar\"}]", "escape": "foo\u0001bar,ü\"\\/\u0008\u000c\u000a\u000d\u0009→", "prêt": "ready" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 172.441406, 56.022948 ], [ 172.309570, 55.776573 ], [ 171.562500, 54.370959 ], [ 174.023438, 47.279229 ], [ 180.439453, 45.058001 ], [ 180.439453, 40.647304 ], [ 169.991455, 40.647304 ], [ 169.425659, 40.979898 ], [ 161.718750, 45.336702 ], [ 157.500000, 53.722717 ], [ 157.060547, 54.514704 ], [ 157.060547, 55.307264 ], [ 157.648315, 56.022948 ], [ 172.441406, 56.022948 ] ] ] } }
] }
] }
,
{ "type": "FeatureCollection", "properties": { "zoom": 4, "x": 15, "y": 4 }, "features": [
{ "type": "FeatureCollection", "properties": { "layer": "in", "version": 2, "extent": 4096 }, "features": [
{ "type": "Feature", "properties": { "boolean": true, "otherboolean": false, "stringify": "[\"yes\",27.00000000,27,1.4e27,{\"foo\":\"bar\"}]", "escape": "foo\u0001bar,ü\"\\/\u0008\u000c\u000a\u000d\u0009→", "prêt": "ready" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 174.023438, 58.816586 ], [ 172.309570, 55.776573 ], [ 172.172241, 55.528631 ], [ 157.241821, 55.528631 ], [ 157.500000, 55.841398 ], [ 163.476562, 62.431074 ], [ 170.507812, 64.776466 ], [ 175.187988, 66.513260 ], [ 175.676880, 66.687784 ], [ 180.439453, 66.687784 ], [ 180.439453, 61.850966 ], [ 180.000000, 61.650771 ], [ 174.023438, 58.816586 ] ] ] } }
{ "type": "Feature", "properties": { "boolean": true, "otherboolean": false, "stringify": "[\"yes\",27.00000000,27,1.4e27,{\"foo\":\"bar\"}]", "escape": "foo\u0001bar,ü\"\\/\u0008\u000c\u000a\u000d\u0009→", "prêt": "ready" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 180.439453, 66.687784 ], [ 180.439453, 61.850966 ], [ 180.000000, 61.650771 ], [ 174.023438, 58.816586 ], [ 172.309570, 55.776573 ], [ 172.172241, 55.528631 ], [ 157.241821, 55.528631 ], [ 157.500000, 55.841398 ], [ 163.476562, 62.431074 ], [ 170.507812, 64.776466 ], [ 175.187988, 66.513260 ], [ 175.676880, 66.687784 ], [ 180.439453, 66.687784 ] ] ] } }
] }
] }
,
{ "type": "FeatureCollection", "properties": { "zoom": 4, "x": 15, "y": 3 }, "features": [
{ "type": "FeatureCollection", "properties": { "layer": "in", "version": 2, "extent": 4096 }, "features": [
{ "type": "Feature", "properties": { "boolean": true, "otherboolean": false, "stringify": "[\"yes\",27.00000000,27,1.4e27,{\"foo\":\"bar\"}]", "escape": "foo\u0001bar,ü\"\\/\u0008\u000c\u000a\u000d\u0009→", "prêt": "ready" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 180.439453, 66.337505 ], [ 174.699097, 66.337505 ], [ 175.187988, 66.513260 ], [ 177.539062, 67.339861 ], [ 180.000000, 67.514872 ], [ 180.439453, 67.546363 ], [ 180.439453, 66.337505 ] ] ] } }
{ "type": "Feature", "properties": { "boolean": true, "otherboolean": false, "stringify": "[\"yes\",27.00000000,27,1.4e27,{\"foo\":\"bar\"}]", "escape": "foo\u0001bar,ü\"\\/\u0008\u000c\u000a\u000d\u0009→", "prêt": "ready" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 180.439453, 67.546363 ], [ 180.439453, 66.337505 ], [ 174.699097, 66.337505 ], [ 175.187988, 66.513260 ], [ 177.539062, 67.339861 ], [ 180.000000, 67.514872 ], [ 180.439453, 67.546363 ] ] ] } }
] }
] }
,
{ "type": "FeatureCollection", "properties": { "zoom": 5, "x": 0, "y": 12 }, "features": [
{ "type": "FeatureCollection", "properties": { "layer": "in", "version": 2, "extent": 4096 }, "features": [
{ "type": "Feature", "properties": { "boolean": true, "otherboolean": false, "stringify": "[\"yes\",27.00000000,27,1.4e27,{\"foo\":\"bar\"}]", "escape": "foo\u0001bar,ü\"\\/\u0008\u000c\u000a\u000d\u0009→", "prêt": "ready" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ -168.530273, 35.038992 ], [ -168.750000, 35.003003 ], [ -169.453125, 34.888184 ], [ -180.000000, 36.522881 ], [ -180.219727, 36.555982 ], [ -180.219727, 41.145570 ], [ -168.530273, 41.145570 ], [ -168.530273, 35.038992 ] ] ] } }
{ "type": "Feature", "properties": { "boolean": true, "otherboolean": false, "stringify": "[\"yes\",27.00000000,27,1.4e27,{\"foo\":\"bar\"}]", "escape": "foo\u0001bar,ü\"\\/\u0008\u000c\u000a\u000d\u0009→", "prêt": "ready" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ -168.530273, 41.145570 ], [ -168.530273, 35.038992 ], [ -168.750000, 35.003003 ], [ -169.453125, 34.888184 ], [ -180.000000, 36.522881 ], [ -180.219727, 36.555982 ], [ -180.219727, 41.145570 ], [ -168.530273, 41.145570 ] ] ] } }
] }
] }
,
{ "type": "FeatureCollection", "properties": { "zoom": 5, "x": 0, "y": 11 }, "features": [
{ "type": "FeatureCollection", "properties": { "layer": "in", "version": 2, "extent": 4096 }, "features": [
{ "type": "Feature", "properties": { "boolean": true, "otherboolean": false, "stringify": "[\"yes\",27.00000000,27,1.4e27,{\"foo\":\"bar\"}]", "escape": "foo\u0001bar,ü\"\\/\u0008\u000c\u000a\u000d\u0009→", "prêt": "ready" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ -180.219727, 40.813809 ], [ -180.219727, 45.290347 ], [ -177.539062, 44.339565 ], [ -168.750000, 43.640051 ], [ -168.530273, 43.622159 ], [ -168.530273, 40.813809 ], [ -180.219727, 40.813809 ] ] ] } }
{ "type": "Feature", "properties": { "boolean": true, "otherboolean": false, "stringify": "[\"yes\",27.00000000,27,1.4e27,{\"foo\":\"bar\"}]", "escape": "foo\u0001bar,ü\"\\/\u0008\u000c\u000a\u000d\u0009→", "prêt": "ready" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ -180.219727, 45.290347 ], [ -177.539062, 44.339565 ], [ -168.750000, 43.640051 ], [ -168.530273, 43.622159 ], [ -168.530273, 40.813809 ], [ -180.219727, 40.813809 ], [ -180.219727, 45.290347 ] ] ] } }
] }
] }
,
{ "type": "FeatureCollection", "properties": { "zoom": 5, "x": 0, "y": 9 }, "features": [
{ "type": "FeatureCollection", "properties": { "layer": "in", "version": 2, "extent": 4096 }, "features": [
{ "type": "Feature", "properties": { "boolean": true, "otherboolean": false, "stringify": "[\"yes\",27.00000000,27,1.4e27,{\"foo\":\"bar\"}]", "escape": "foo\u0001bar,ü\"\\/\u0008\u000c\u000a\u000d\u0009→", "prêt": "ready" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ -180.219727, 61.710706 ], [ -179.868164, 61.710706 ], [ -180.219727, 61.551493 ], [ -180.219727, 61.710706 ] ] ] } }
{ "type": "Feature", "properties": { "boolean": true, "otherboolean": false, "stringify": "[\"yes\",27.00000000,27,1.4e27,{\"foo\":\"bar\"}]", "escape": "foo\u0001bar,ü\"\\/\u0008\u000c\u000a\u000d\u0009→", "prêt": "ready" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ -179.868164, 61.710706 ], [ -180.219727, 61.551493 ], [ -180.219727, 61.710706 ], [ -179.868164, 61.710706 ] ] ] } }
] }
] }
,
@ -246,127 +246,127 @@
,
{ "type": "FeatureCollection", "properties": { "zoom": 5, "x": 0, "y": 7 }, "features": [
{ "type": "FeatureCollection", "properties": { "layer": "in", "version": 2, "extent": 4096 }, "features": [
{ "type": "Feature", "properties": { "boolean": true, "otherboolean": false, "stringify": "[\"yes\",27.00000000,27,1.4e27,{\"foo\":\"bar\"}]", "escape": "foo\u0001bar,ü\"\\/\u0008\u000c\u000a\u000d\u0009→", "prêt": "ready" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ -168.750000, 68.266336 ], [ -168.530273, 68.264302 ], [ -168.530273, 66.425537 ], [ -180.219727, 66.425537 ], [ -180.219727, 67.500161 ], [ -180.000000, 67.515922 ], [ -169.101562, 68.269387 ], [ -168.750000, 68.266336 ] ] ] } }
{ "type": "Feature", "properties": { "boolean": true, "otherboolean": false, "stringify": "[\"yes\",27.00000000,27,1.4e27,{\"foo\":\"bar\"}]", "escape": "foo\u0001bar,ü\"\\/\u0008\u000c\u000a\u000d\u0009→", "prêt": "ready" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ -169.101562, 68.269387 ], [ -168.750000, 68.266336 ], [ -168.530273, 68.264302 ], [ -168.530273, 66.425537 ], [ -180.219727, 66.425537 ], [ -180.219727, 67.500161 ], [ -180.000000, 67.515922 ], [ -169.101562, 68.269387 ] ] ] } }
] }
] }
,
{ "type": "FeatureCollection", "properties": { "zoom": 5, "x": 1, "y": 12 }, "features": [
{ "type": "FeatureCollection", "properties": { "layer": "in", "version": 2, "extent": 4096 }, "features": [
{ "type": "Feature", "properties": { "boolean": true, "otherboolean": false, "stringify": "[\"yes\",27.00000000,27,1.4e27,{\"foo\":\"bar\"}]", "escape": "foo\u0001bar,ü\"\\/\u0008\u000c\u000a\u000d\u0009→", "prêt": "ready" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ -157.280273, 36.833470 ], [ -157.500000, 36.798289 ], [ -168.750000, 35.003003 ], [ -168.969727, 34.966999 ], [ -168.969727, 41.145570 ], [ -157.280273, 41.145570 ], [ -157.280273, 36.833470 ] ] ] } }
{ "type": "Feature", "properties": { "boolean": true, "otherboolean": false, "stringify": "[\"yes\",27.00000000,27,1.4e27,{\"foo\":\"bar\"}]", "escape": "foo\u0001bar,ü\"\\/\u0008\u000c\u000a\u000d\u0009→", "prêt": "ready" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ -157.280273, 41.145570 ], [ -157.280273, 36.833470 ], [ -157.500000, 36.798289 ], [ -168.750000, 35.003003 ], [ -168.969727, 34.966999 ], [ -168.969727, 41.145570 ], [ -157.280273, 41.145570 ] ] ] } }
] }
] }
,
{ "type": "FeatureCollection", "properties": { "zoom": 5, "x": 1, "y": 11 }, "features": [
{ "type": "FeatureCollection", "properties": { "layer": "in", "version": 2, "extent": 4096 }, "features": [
{ "type": "Feature", "properties": { "boolean": true, "otherboolean": false, "stringify": "[\"yes\",27.00000000,27,1.4e27,{\"foo\":\"bar\"}]", "escape": "foo\u0001bar,ü\"\\/\u0008\u000c\u000a\u000d\u0009→", "prêt": "ready" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ -164.882812, 43.327176 ], [ -157.500000, 45.406164 ], [ -157.280273, 45.467836 ], [ -157.280273, 40.813809 ], [ -168.969727, 40.813809 ], [ -168.969727, 43.657937 ], [ -168.750000, 43.640051 ], [ -164.882812, 43.327176 ] ] ] } }
{ "type": "Feature", "properties": { "boolean": true, "otherboolean": false, "stringify": "[\"yes\",27.00000000,27,1.4e27,{\"foo\":\"bar\"}]", "escape": "foo\u0001bar,ü\"\\/\u0008\u000c\u000a\u000d\u0009→", "prêt": "ready" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ -157.280273, 45.467836 ], [ -157.280273, 40.813809 ], [ -168.969727, 40.813809 ], [ -168.969727, 43.657937 ], [ -168.750000, 43.640051 ], [ -164.882812, 43.327176 ], [ -157.500000, 45.406164 ], [ -157.280273, 45.467836 ] ] ] } }
] }
] }
,
{ "type": "FeatureCollection", "properties": { "zoom": 5, "x": 1, "y": 8 }, "features": [
{ "type": "FeatureCollection", "properties": { "layer": "in", "version": 2, "extent": 4096 }, "features": [
{ "type": "Feature", "properties": { "boolean": true, "otherboolean": false, "stringify": "[\"yes\",27.00000000,27,1.4e27,{\"foo\":\"bar\"}]", "escape": "foo\u0001bar,ü\"\\/\u0008\u000c\u000a\u000d\u0009→", "prêt": "ready" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ -158.554688, 63.860036 ], [ -168.750000, 64.434892 ], [ -168.969727, 64.447927 ], [ -168.969727, 66.600676 ], [ -157.280273, 66.600676 ], [ -157.280273, 63.541211 ], [ -157.500000, 63.596226 ], [ -158.554688, 63.860036 ] ] ] } }
{ "type": "Feature", "properties": { "boolean": true, "otherboolean": false, "stringify": "[\"yes\",27.00000000,27,1.4e27,{\"foo\":\"bar\"}]", "escape": "foo\u0001bar,ü\"\\/\u0008\u000c\u000a\u000d\u0009→", "prêt": "ready" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ -157.280273, 66.600676 ], [ -157.280273, 63.541211 ], [ -157.500000, 63.596226 ], [ -158.554688, 63.860036 ], [ -168.750000, 64.434892 ], [ -168.969727, 64.447927 ], [ -168.969727, 66.600676 ], [ -157.280273, 66.600676 ] ] ] } }
] }
] }
,
{ "type": "FeatureCollection", "properties": { "zoom": 5, "x": 1, "y": 7 }, "features": [
{ "type": "FeatureCollection", "properties": { "layer": "in", "version": 2, "extent": 4096 }, "features": [
{ "type": "Feature", "properties": { "boolean": true, "otherboolean": false, "stringify": "[\"yes\",27.00000000,27,1.4e27,{\"foo\":\"bar\"}]", "escape": "foo\u0001bar,ü\"\\/\u0008\u000c\u000a\u000d\u0009→", "prêt": "ready" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ -168.750000, 68.266336 ], [ -157.500000, 68.154187 ], [ -157.280273, 68.152143 ], [ -157.280273, 66.425537 ], [ -168.969727, 66.425537 ], [ -168.969727, 68.268370 ], [ -168.750000, 68.266336 ] ] ] } }
{ "type": "Feature", "properties": { "boolean": true, "otherboolean": false, "stringify": "[\"yes\",27.00000000,27,1.4e27,{\"foo\":\"bar\"}]", "escape": "foo\u0001bar,ü\"\\/\u0008\u000c\u000a\u000d\u0009→", "prêt": "ready" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ -168.969727, 68.268370 ], [ -168.750000, 68.266336 ], [ -157.500000, 68.154187 ], [ -157.280273, 68.152143 ], [ -157.280273, 66.425537 ], [ -168.969727, 66.425537 ], [ -168.969727, 68.268370 ] ] ] } }
] }
] }
,
{ "type": "FeatureCollection", "properties": { "zoom": 5, "x": 2, "y": 12 }, "features": [
{ "type": "FeatureCollection", "properties": { "layer": "in", "version": 2, "extent": 4096 }, "features": [
{ "type": "Feature", "properties": { "boolean": true, "otherboolean": false, "stringify": "[\"yes\",27.00000000,27,1.4e27,{\"foo\":\"bar\"}]", "escape": "foo\u0001bar,ü\"\\/\u0008\u000c\u000a\u000d\u0009→", "prêt": "ready" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ -146.030273, 38.741231 ], [ -146.250000, 38.550313 ], [ -157.500000, 36.798289 ], [ -157.719727, 36.763092 ], [ -157.719727, 41.145570 ], [ -146.030273, 41.145570 ], [ -146.030273, 38.741231 ] ] ] } }
{ "type": "Feature", "properties": { "boolean": true, "otherboolean": false, "stringify": "[\"yes\",27.00000000,27,1.4e27,{\"foo\":\"bar\"}]", "escape": "foo\u0001bar,ü\"\\/\u0008\u000c\u000a\u000d\u0009→", "prêt": "ready" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ -146.030273, 41.145570 ], [ -146.030273, 38.741231 ], [ -146.250000, 38.550313 ], [ -157.500000, 36.798289 ], [ -157.719727, 36.763092 ], [ -157.719727, 41.145570 ], [ -146.030273, 41.145570 ] ] ] } }
] }
] }
,
{ "type": "FeatureCollection", "properties": { "zoom": 5, "x": 2, "y": 11 }, "features": [
{ "type": "FeatureCollection", "properties": { "layer": "in", "version": 2, "extent": 4096 }, "features": [
{ "type": "Feature", "properties": { "boolean": true, "otherboolean": false, "stringify": "[\"yes\",27.00000000,27,1.4e27,{\"foo\":\"bar\"}]", "escape": "foo\u0001bar,ü\"\\/\u0008\u000c\u000a\u000d\u0009→", "prêt": "ready" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ -153.281250, 46.560749 ], [ -148.889465, 48.922499 ], [ -148.614807, 49.066668 ], [ -146.030273, 49.066668 ], [ -146.030273, 40.813809 ], [ -157.719727, 40.813809 ], [ -157.719727, 45.346354 ], [ -157.500000, 45.408092 ], [ -153.281250, 46.560749 ] ] ] } }
{ "type": "Feature", "properties": { "boolean": true, "otherboolean": false, "stringify": "[\"yes\",27.00000000,27,1.4e27,{\"foo\":\"bar\"}]", "escape": "foo\u0001bar,ü\"\\/\u0008\u000c\u000a\u000d\u0009→", "prêt": "ready" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ -146.030273, 49.066668 ], [ -146.030273, 40.813809 ], [ -157.719727, 40.813809 ], [ -157.719727, 45.346354 ], [ -157.500000, 45.408092 ], [ -153.281250, 46.560749 ], [ -148.889465, 48.922499 ], [ -148.614807, 49.066668 ], [ -146.030273, 49.066668 ] ] ] } }
] }
] }
,
{ "type": "FeatureCollection", "properties": { "zoom": 5, "x": 2, "y": 10 }, "features": [
{ "type": "FeatureCollection", "properties": { "layer": "in", "version": 2, "extent": 4096 }, "features": [
{ "type": "Feature", "properties": { "boolean": true, "otherboolean": false, "stringify": "[\"yes\",27.00000000,27,1.4e27,{\"foo\":\"bar\"}]", "escape": "foo\u0001bar,ü\"\\/\u0008\u000c\u000a\u000d\u0009→", "prêt": "ready" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ -146.250000, 50.291094 ], [ -146.030273, 50.403266 ], [ -146.030273, 48.777913 ], [ -149.164124, 48.777913 ], [ -148.889465, 48.922499 ], [ -146.250000, 50.291094 ] ] ] } }
{ "type": "Feature", "properties": { "boolean": true, "otherboolean": false, "stringify": "[\"yes\",27.00000000,27,1.4e27,{\"foo\":\"bar\"}]", "escape": "foo\u0001bar,ü\"\\/\u0008\u000c\u000a\u000d\u0009→", "prêt": "ready" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ -146.030273, 50.403266 ], [ -146.030273, 48.777913 ], [ -149.164124, 48.777913 ], [ -148.889465, 48.922499 ], [ -146.250000, 50.291094 ], [ -146.030273, 50.403266 ] ] ] } }
] }
] }
,
{ "type": "FeatureCollection", "properties": { "zoom": 5, "x": 2, "y": 9 }, "features": [
{ "type": "FeatureCollection", "properties": { "layer": "in", "version": 2, "extent": 4096 }, "features": [
{ "type": "Feature", "properties": { "boolean": true, "otherboolean": false, "stringify": "[\"yes\",27.00000000,27,1.4e27,{\"foo\":\"bar\"}]", "escape": "foo\u0001bar,ü\"\\/\u0008\u000c\u000a\u000d\u0009→", "prêt": "ready" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ -148.007812, 61.100789 ], [ -149.869995, 61.606396 ], [ -150.257263, 61.710706 ], [ -146.030273, 61.710706 ], [ -146.030273, 59.300954 ], [ -146.250000, 59.506455 ], [ -148.007812, 61.100789 ] ] ] } }
{ "type": "Feature", "properties": { "boolean": true, "otherboolean": false, "stringify": "[\"yes\",27.00000000,27,1.4e27,{\"foo\":\"bar\"}]", "escape": "foo\u0001bar,ü\"\\/\u0008\u000c\u000a\u000d\u0009→", "prêt": "ready" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ -146.030273, 61.710706 ], [ -146.030273, 59.300954 ], [ -146.250000, 59.506455 ], [ -148.007812, 61.100789 ], [ -149.869995, 61.606396 ], [ -150.257263, 61.710706 ], [ -146.030273, 61.710706 ] ] ] } }
] }
] }
,
{ "type": "FeatureCollection", "properties": { "zoom": 5, "x": 2, "y": 8 }, "features": [
{ "type": "FeatureCollection", "properties": { "layer": "in", "version": 2, "extent": 4096 }, "features": [
{ "type": "Feature", "properties": { "boolean": true, "otherboolean": false, "stringify": "[\"yes\",27.00000000,27,1.4e27,{\"foo\":\"bar\"}]", "escape": "foo\u0001bar,ü\"\\/\u0008\u000c\u000a\u000d\u0009→", "prêt": "ready" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ -157.500000, 63.597448 ], [ -157.719727, 63.652355 ], [ -157.719727, 66.600676 ], [ -147.296448, 66.600676 ], [ -146.813049, 66.513260 ], [ -146.250000, 66.411253 ], [ -146.030273, 66.371654 ], [ -146.030273, 61.501734 ], [ -149.482727, 61.501734 ], [ -149.869995, 61.606396 ], [ -157.500000, 63.597448 ] ] ] } }
{ "type": "Feature", "properties": { "boolean": true, "otherboolean": false, "stringify": "[\"yes\",27.00000000,27,1.4e27,{\"foo\":\"bar\"}]", "escape": "foo\u0001bar,ü\"\\/\u0008\u000c\u000a\u000d\u0009→", "prêt": "ready" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ -147.296448, 66.600676 ], [ -146.813049, 66.513260 ], [ -146.250000, 66.411253 ], [ -146.030273, 66.371654 ], [ -146.030273, 61.501734 ], [ -149.482727, 61.501734 ], [ -149.869995, 61.606396 ], [ -157.500000, 63.597448 ], [ -157.719727, 63.652355 ], [ -157.719727, 66.600676 ], [ -147.296448, 66.600676 ] ] ] } }
] }
] }
,
{ "type": "FeatureCollection", "properties": { "zoom": 5, "x": 2, "y": 7 }, "features": [
{ "type": "FeatureCollection", "properties": { "layer": "in", "version": 2, "extent": 4096 }, "features": [
{ "type": "Feature", "properties": { "boolean": true, "otherboolean": false, "stringify": "[\"yes\",27.00000000,27,1.4e27,{\"foo\":\"bar\"}]", "escape": "foo\u0001bar,ü\"\\/\u0008\u000c\u000a\u000d\u0009→", "prêt": "ready" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ -157.500000, 68.154187 ], [ -156.093750, 68.138852 ], [ -146.813049, 66.513260 ], [ -146.329651, 66.425537 ], [ -157.719727, 66.425537 ], [ -157.719727, 68.156231 ], [ -157.500000, 68.154187 ] ] ] } }
{ "type": "Feature", "properties": { "boolean": true, "otherboolean": false, "stringify": "[\"yes\",27.00000000,27,1.4e27,{\"foo\":\"bar\"}]", "escape": "foo\u0001bar,ü\"\\/\u0008\u000c\u000a\u000d\u0009→", "prêt": "ready" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ -157.719727, 68.156231 ], [ -157.500000, 68.154187 ], [ -156.093750, 68.138852 ], [ -146.813049, 66.513260 ], [ -146.329651, 66.425537 ], [ -157.719727, 66.425537 ], [ -157.719727, 68.156231 ] ] ] } }
] }
] }
,
{ "type": "FeatureCollection", "properties": { "zoom": 5, "x": 3, "y": 12 }, "features": [
{ "type": "FeatureCollection", "properties": { "layer": "in", "version": 2, "extent": 4096 }, "features": [
{ "type": "Feature", "properties": { "boolean": true, "otherboolean": false, "stringify": "[\"yes\",27.00000000,27,1.4e27,{\"foo\":\"bar\"}]", "escape": "foo\u0001bar,ü\"\\/\u0008\u000c\u000a\u000d\u0009→", "prêt": "ready" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ -143.407288, 40.979898 ], [ -146.250000, 38.550313 ], [ -146.469727, 38.518086 ], [ -146.469727, 41.145570 ], [ -143.209534, 41.145570 ], [ -143.407288, 40.979898 ] ] ] } }
{ "type": "Feature", "properties": { "boolean": true, "otherboolean": false, "stringify": "[\"yes\",27.00000000,27,1.4e27,{\"foo\":\"bar\"}]", "escape": "foo\u0001bar,ü\"\\/\u0008\u000c\u000a\u000d\u0009→", "prêt": "ready" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ -143.209534, 41.145570 ], [ -143.407288, 40.979898 ], [ -146.250000, 38.550313 ], [ -146.469727, 38.518086 ], [ -146.469727, 41.145570 ], [ -143.209534, 41.145570 ] ] ] } }
] }
] }
,
{ "type": "FeatureCollection", "properties": { "zoom": 5, "x": 3, "y": 11 }, "features": [
{ "type": "FeatureCollection", "properties": { "layer": "in", "version": 2, "extent": 4096 }, "features": [
{ "type": "Feature", "properties": { "boolean": true, "otherboolean": false, "stringify": "[\"yes\",27.00000000,27,1.4e27,{\"foo\":\"bar\"}]", "escape": "foo\u0001bar,ü\"\\/\u0008\u000c\u000a\u000d\u0009→", "prêt": "ready" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ -134.780273, 47.816843 ], [ -135.000000, 47.652438 ], [ -143.407288, 40.979898 ], [ -143.605042, 40.813809 ], [ -146.469727, 40.813809 ], [ -146.469727, 49.066668 ], [ -134.780273, 49.066668 ], [ -134.780273, 47.816843 ] ] ] } }
{ "type": "Feature", "properties": { "boolean": true, "otherboolean": false, "stringify": "[\"yes\",27.00000000,27,1.4e27,{\"foo\":\"bar\"}]", "escape": "foo\u0001bar,ü\"\\/\u0008\u000c\u000a\u000d\u0009→", "prêt": "ready" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ -134.780273, 49.066668 ], [ -134.780273, 47.816843 ], [ -135.000000, 47.652438 ], [ -143.407288, 40.979898 ], [ -143.605042, 40.813809 ], [ -146.469727, 40.813809 ], [ -146.469727, 49.066668 ], [ -134.780273, 49.066668 ] ] ] } }
] }
] }
,
{ "type": "FeatureCollection", "properties": { "zoom": 5, "x": 3, "y": 10 }, "features": [
{ "type": "FeatureCollection", "properties": { "layer": "in", "version": 2, "extent": 4096 }, "features": [
{ "type": "Feature", "properties": { "boolean": true, "otherboolean": false, "stringify": "[\"yes\",27.00000000,27,1.4e27,{\"foo\":\"bar\"}]", "escape": "foo\u0001bar,ü\"\\/\u0008\u000c\u000a\u000d\u0009→", "prêt": "ready" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ -144.492188, 51.179343 ], [ -143.962097, 55.776573 ], [ -143.945618, 55.899956 ], [ -134.780273, 55.899956 ], [ -134.780273, 48.777913 ], [ -146.469727, 48.777913 ], [ -146.469727, 50.178657 ], [ -146.250000, 50.291094 ], [ -144.492188, 51.179343 ] ] ] } }
{ "type": "Feature", "properties": { "boolean": true, "otherboolean": false, "stringify": "[\"yes\",27.00000000,27,1.4e27,{\"foo\":\"bar\"}]", "escape": "foo\u0001bar,ü\"\\/\u0008\u000c\u000a\u000d\u0009→", "prêt": "ready" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ -134.780273, 55.899956 ], [ -134.780273, 48.777913 ], [ -146.469727, 48.777913 ], [ -146.469727, 50.178657 ], [ -146.250000, 50.291094 ], [ -144.492188, 51.179343 ], [ -143.962097, 55.776573 ], [ -143.945618, 55.899956 ], [ -134.780273, 55.899956 ] ] ] } }
] }
] }
,
{ "type": "FeatureCollection", "properties": { "zoom": 5, "x": 3, "y": 9 }, "features": [
{ "type": "FeatureCollection", "properties": { "layer": "in", "version": 2, "extent": 4096 }, "features": [
{ "type": "Feature", "properties": { "boolean": true, "otherboolean": false, "stringify": "[\"yes\",27.00000000,27,1.4e27,{\"foo\":\"bar\"}]", "escape": "foo\u0001bar,ü\"\\/\u0008\u000c\u000a\u000d\u0009→", "prêt": "ready" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ -143.789062, 57.137730 ], [ -146.250000, 59.506455 ], [ -146.469727, 59.709327 ], [ -146.469727, 61.710706 ], [ -134.780273, 61.710706 ], [ -134.780273, 55.652798 ], [ -143.975830, 55.652798 ], [ -143.959351, 55.776573 ], [ -143.789062, 57.137730 ] ] ] } }
{ "type": "Feature", "properties": { "boolean": true, "otherboolean": false, "stringify": "[\"yes\",27.00000000,27,1.4e27,{\"foo\":\"bar\"}]", "escape": "foo\u0001bar,ü\"\\/\u0008\u000c\u000a\u000d\u0009→", "prêt": "ready" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ -134.780273, 61.710706 ], [ -134.780273, 55.652798 ], [ -143.975830, 55.652798 ], [ -143.959351, 55.776573 ], [ -143.789062, 57.137730 ], [ -146.250000, 59.506455 ], [ -146.469727, 59.709327 ], [ -146.469727, 61.710706 ], [ -134.780273, 61.710706 ] ] ] } }
] }
] }
,
{ "type": "FeatureCollection", "properties": { "zoom": 5, "x": 3, "y": 8 }, "features": [
{ "type": "FeatureCollection", "properties": { "layer": "in", "version": 2, "extent": 4096 }, "features": [
{ "type": "Feature", "properties": { "boolean": true, "otherboolean": false, "stringify": "[\"yes\",27.00000000,27,1.4e27,{\"foo\":\"bar\"}]", "escape": "foo\u0001bar,ü\"\\/\u0008\u000c\u000a\u000d\u0009→", "prêt": "ready" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ -146.250000, 66.411253 ], [ -144.492188, 66.089364 ], [ -135.000000, 62.570575 ], [ -134.780273, 62.484415 ], [ -134.780273, 61.501734 ], [ -146.469727, 61.501734 ], [ -146.469727, 66.451887 ], [ -146.250000, 66.411253 ] ] ] } }
{ "type": "Feature", "properties": { "boolean": true, "otherboolean": false, "stringify": "[\"yes\",27.00000000,27,1.4e27,{\"foo\":\"bar\"}]", "escape": "foo\u0001bar,ü\"\\/\u0008\u000c\u000a\u000d\u0009→", "prêt": "ready" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ -146.469727, 66.451887 ], [ -146.250000, 66.411253 ], [ -144.492188, 66.089364 ], [ -135.000000, 62.570575 ], [ -134.780273, 62.484415 ], [ -134.780273, 61.501734 ], [ -146.469727, 61.501734 ], [ -146.469727, 66.451887 ] ] ] } }
] }
] }
,
{ "type": "FeatureCollection", "properties": { "zoom": 5, "x": 3, "y": 7 }, "features": [
{ "type": "FeatureCollection", "properties": { "layer": "in", "version": 2, "extent": 4096 }, "features": [
{ "type": "Feature", "properties": { "boolean": true, "otherboolean": false, "stringify": "[\"yes\",27.00000000,27,1.4e27,{\"foo\":\"bar\"}]", "escape": "foo\u0001bar,ü\"\\/\u0008\u000c\u000a\u000d\u0009→", "prêt": "ready" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ -146.329651, 66.425537 ], [ -146.469727, 66.425537 ], [ -146.469727, 66.451887 ], [ -146.329651, 66.425537 ] ] ] } }
{ "type": "Feature", "properties": { "boolean": true, "otherboolean": false, "stringify": "[\"yes\",27.00000000,27,1.4e27,{\"foo\":\"bar\"}]", "escape": "foo\u0001bar,ü\"\\/\u0008\u000c\u000a\u000d\u0009→", "prêt": "ready" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ -146.469727, 66.451887 ], [ -146.329651, 66.425537 ], [ -146.469727, 66.425537 ], [ -146.469727, 66.451887 ] ] ] } }
] }
] }
,
{ "type": "FeatureCollection", "properties": { "zoom": 5, "x": 4, "y": 11 }, "features": [
{ "type": "FeatureCollection", "properties": { "layer": "in", "version": 2, "extent": 4096 }, "features": [
{ "type": "Feature", "properties": { "boolean": true, "otherboolean": false, "stringify": "[\"yes\",27.00000000,27,1.4e27,{\"foo\":\"bar\"}]", "escape": "foo\u0001bar,ü\"\\/\u0008\u000c\u000a\u000d\u0009→", "prêt": "ready" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ -133.538818, 48.922499 ], [ -133.593750, 48.690960 ], [ -135.000000, 47.650588 ], [ -135.219727, 47.485657 ], [ -135.219727, 49.066668 ], [ -133.503113, 49.066668 ], [ -133.538818, 48.922499 ] ] ] } }
{ "type": "Feature", "properties": { "boolean": true, "otherboolean": false, "stringify": "[\"yes\",27.00000000,27,1.4e27,{\"foo\":\"bar\"}]", "escape": "foo\u0001bar,ü\"\\/\u0008\u000c\u000a\u000d\u0009→", "prêt": "ready" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ -133.503113, 49.066668 ], [ -133.538818, 48.922499 ], [ -133.593750, 48.690960 ], [ -135.000000, 47.650588 ], [ -135.219727, 47.485657 ], [ -135.219727, 49.066668 ], [ -133.503113, 49.066668 ] ] ] } }
] }
] }
,
{ "type": "FeatureCollection", "properties": { "zoom": 5, "x": 4, "y": 10 }, "features": [
{ "type": "FeatureCollection", "properties": { "layer": "in", "version": 2, "extent": 4096 }, "features": [
{ "type": "Feature", "properties": { "boolean": true, "otherboolean": false, "stringify": "[\"yes\",27.00000000,27,1.4e27,{\"foo\":\"bar\"}]", "escape": "foo\u0001bar,ü\"\\/\u0008\u000c\u000a\u000d\u0009→", "prêt": "ready" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ -131.981506, 55.776573 ], [ -131.835938, 55.379110 ], [ -133.538818, 48.922499 ], [ -133.574524, 48.777913 ], [ -135.219727, 48.777913 ], [ -135.219727, 55.899956 ], [ -132.028198, 55.899956 ], [ -131.981506, 55.776573 ] ] ] } }
{ "type": "Feature", "properties": { "boolean": true, "otherboolean": false, "stringify": "[\"yes\",27.00000000,27,1.4e27,{\"foo\":\"bar\"}]", "escape": "foo\u0001bar,ü\"\\/\u0008\u000c\u000a\u000d\u0009→", "prêt": "ready" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ -132.028198, 55.899956 ], [ -131.981506, 55.776573 ], [ -131.835938, 55.379110 ], [ -133.538818, 48.922499 ], [ -133.574524, 48.777913 ], [ -135.219727, 48.777913 ], [ -135.219727, 55.899956 ], [ -132.028198, 55.899956 ] ] ] } }
] }
] }
,
{ "type": "FeatureCollection", "properties": { "zoom": 5, "x": 4, "y": 9 }, "features": [
{ "type": "FeatureCollection", "properties": { "layer": "in", "version": 2, "extent": 4096 }, "features": [
{ "type": "Feature", "properties": { "boolean": true, "otherboolean": false, "stringify": "[\"yes\",27.00000000,27,1.4e27,{\"foo\":\"bar\"}]", "escape": "foo\u0001bar,ü\"\\/\u0008\u000c\u000a\u000d\u0009→", "prêt": "ready" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ -134.288635, 61.606396 ], [ -131.981506, 55.776573 ], [ -131.937561, 55.652798 ], [ -135.219727, 55.652798 ], [ -135.219727, 61.710706 ], [ -134.335327, 61.710706 ], [ -134.288635, 61.606396 ] ] ] } }
{ "type": "Feature", "properties": { "boolean": true, "otherboolean": false, "stringify": "[\"yes\",27.00000000,27,1.4e27,{\"foo\":\"bar\"}]", "escape": "foo\u0001bar,ü\"\\/\u0008\u000c\u000a\u000d\u0009→", "prêt": "ready" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ -134.335327, 61.710706 ], [ -134.288635, 61.606396 ], [ -131.981506, 55.776573 ], [ -131.937561, 55.652798 ], [ -135.219727, 55.652798 ], [ -135.219727, 61.710706 ], [ -134.335327, 61.710706 ] ] ] } }
] }
] }
,
{ "type": "FeatureCollection", "properties": { "zoom": 5, "x": 4, "y": 8 }, "features": [
{ "type": "FeatureCollection", "properties": { "layer": "in", "version": 2, "extent": 4096 }, "features": [
{ "type": "Feature", "properties": { "boolean": true, "otherboolean": false, "stringify": "[\"yes\",27.00000000,27,1.4e27,{\"foo\":\"bar\"}]", "escape": "foo\u0001bar,ü\"\\/\u0008\u000c\u000a\u000d\u0009→", "prêt": "ready" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ -135.000000, 62.570575 ], [ -134.648438, 62.431074 ], [ -134.288635, 61.606396 ], [ -134.244690, 61.501734 ], [ -135.219727, 61.501734 ], [ -135.219727, 62.657748 ], [ -135.000000, 62.570575 ] ] ] } }
{ "type": "Feature", "properties": { "boolean": true, "otherboolean": false, "stringify": "[\"yes\",27.00000000,27,1.4e27,{\"foo\":\"bar\"}]", "escape": "foo\u0001bar,ü\"\\/\u0008\u000c\u000a\u000d\u0009→", "prêt": "ready" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ -135.219727, 62.657748 ], [ -135.000000, 62.570575 ], [ -134.648438, 62.431074 ], [ -134.288635, 61.606396 ], [ -134.244690, 61.501734 ], [ -135.219727, 61.501734 ], [ -135.219727, 62.657748 ] ] ] } }
] }
] }
,
@ -396,73 +396,73 @@
,
{ "type": "FeatureCollection", "properties": { "zoom": 5, "x": 29, "y": 10 }, "features": [
{ "type": "FeatureCollection", "properties": { "layer": "in", "version": 2, "extent": 4096 }, "features": [
{ "type": "Feature", "properties": { "boolean": true, "otherboolean": false, "stringify": "[\"yes\",27.00000000,27,1.4e27,{\"foo\":\"bar\"}]", "escape": "foo\u0001bar,ü\"\\/\u0008\u000c\u000a\u000d\u0009→", "prêt": "ready" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 157.719727, 53.321030 ], [ 157.500000, 53.722717 ], [ 156.796875, 54.979190 ], [ 157.445068, 55.776573 ], [ 157.546692, 55.899956 ], [ 157.719727, 55.899956 ], [ 157.719727, 53.321030 ] ] ] } }
{ "type": "Feature", "properties": { "boolean": true, "otherboolean": false, "stringify": "[\"yes\",27.00000000,27,1.4e27,{\"foo\":\"bar\"}]", "escape": "foo\u0001bar,ü\"\\/\u0008\u000c\u000a\u000d\u0009→", "prêt": "ready" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 157.719727, 55.899956 ], [ 157.719727, 53.321030 ], [ 157.500000, 53.722717 ], [ 156.796875, 54.979190 ], [ 157.445068, 55.776573 ], [ 157.546692, 55.899956 ], [ 157.719727, 55.899956 ] ] ] } }
] }
] }
,
{ "type": "FeatureCollection", "properties": { "zoom": 5, "x": 29, "y": 9 }, "features": [
{ "type": "FeatureCollection", "properties": { "layer": "in", "version": 2, "extent": 4096 }, "features": [
{ "type": "Feature", "properties": { "boolean": true, "otherboolean": false, "stringify": "[\"yes\",27.00000000,27,1.4e27,{\"foo\":\"bar\"}]", "escape": "foo\u0001bar,ü\"\\/\u0008\u000c\u000a\u000d\u0009→", "prêt": "ready" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 157.719727, 55.652798 ], [ 157.343445, 55.652798 ], [ 157.445068, 55.776573 ], [ 157.719727, 56.107278 ], [ 157.719727, 55.652798 ] ] ] } }
{ "type": "Feature", "properties": { "boolean": true, "otherboolean": false, "stringify": "[\"yes\",27.00000000,27,1.4e27,{\"foo\":\"bar\"}]", "escape": "foo\u0001bar,ü\"\\/\u0008\u000c\u000a\u000d\u0009→", "prêt": "ready" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 157.719727, 56.107278 ], [ 157.719727, 55.652798 ], [ 157.343445, 55.652798 ], [ 157.445068, 55.776573 ], [ 157.719727, 56.107278 ] ] ] } }
] }
] }
,
{ "type": "FeatureCollection", "properties": { "zoom": 5, "x": 30, "y": 11 }, "features": [
{ "type": "FeatureCollection", "properties": { "layer": "in", "version": 2, "extent": 4096 }, "features": [
{ "type": "Feature", "properties": { "boolean": true, "otherboolean": false, "stringify": "[\"yes\",27.00000000,27,1.4e27,{\"foo\":\"bar\"}]", "escape": "foo\u0001bar,ü\"\\/\u0008\u000c\u000a\u000d\u0009→", "prêt": "ready" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 168.969727, 41.248903 ], [ 161.718750, 45.336702 ], [ 160.002136, 48.922499 ], [ 159.930725, 49.066668 ], [ 168.969727, 49.066668 ], [ 168.969727, 41.248903 ] ] ] } }
{ "type": "Feature", "properties": { "boolean": true, "otherboolean": false, "stringify": "[\"yes\",27.00000000,27,1.4e27,{\"foo\":\"bar\"}]", "escape": "foo\u0001bar,ü\"\\/\u0008\u000c\u000a\u000d\u0009→", "prêt": "ready" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 168.969727, 49.066668 ], [ 168.969727, 41.248903 ], [ 161.718750, 45.336702 ], [ 160.002136, 48.922499 ], [ 159.930725, 49.066668 ], [ 168.969727, 49.066668 ] ] ] } }
] }
] }
,
{ "type": "FeatureCollection", "properties": { "zoom": 5, "x": 30, "y": 10 }, "features": [
{ "type": "FeatureCollection", "properties": { "layer": "in", "version": 2, "extent": 4096 }, "features": [
{ "type": "Feature", "properties": { "boolean": true, "otherboolean": false, "stringify": "[\"yes\",27.00000000,27,1.4e27,{\"foo\":\"bar\"}]", "escape": "foo\u0001bar,ü\"\\/\u0008\u000c\u000a\u000d\u0009→", "prêt": "ready" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 168.969727, 48.777913 ], [ 160.073547, 48.777913 ], [ 160.002136, 48.922499 ], [ 157.500000, 53.722717 ], [ 157.280273, 54.120602 ], [ 157.280273, 55.575239 ], [ 157.546692, 55.899956 ], [ 168.969727, 55.899956 ], [ 168.969727, 48.777913 ] ] ] } }
{ "type": "Feature", "properties": { "boolean": true, "otherboolean": false, "stringify": "[\"yes\",27.00000000,27,1.4e27,{\"foo\":\"bar\"}]", "escape": "foo\u0001bar,ü\"\\/\u0008\u000c\u000a\u000d\u0009→", "prêt": "ready" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 168.969727, 55.899956 ], [ 168.969727, 48.777913 ], [ 160.073547, 48.777913 ], [ 160.002136, 48.922499 ], [ 157.500000, 53.722717 ], [ 157.280273, 54.120602 ], [ 157.280273, 55.575239 ], [ 157.546692, 55.899956 ], [ 168.969727, 55.899956 ] ] ] } }
] }
] }
,
{ "type": "FeatureCollection", "properties": { "zoom": 5, "x": 30, "y": 9 }, "features": [
{ "type": "FeatureCollection", "properties": { "layer": "in", "version": 2, "extent": 4096 }, "features": [
{ "type": "Feature", "properties": { "boolean": true, "otherboolean": false, "stringify": "[\"yes\",27.00000000,27,1.4e27,{\"foo\":\"bar\"}]", "escape": "foo\u0001bar,ü\"\\/\u0008\u000c\u000a\u000d\u0009→", "prêt": "ready" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 168.969727, 55.652798 ], [ 157.343445, 55.652798 ], [ 157.500000, 55.842940 ], [ 162.660828, 61.606396 ], [ 162.762451, 61.710706 ], [ 168.969727, 61.710706 ], [ 168.969727, 55.652798 ] ] ] } }
{ "type": "Feature", "properties": { "boolean": true, "otherboolean": false, "stringify": "[\"yes\",27.00000000,27,1.4e27,{\"foo\":\"bar\"}]", "escape": "foo\u0001bar,ü\"\\/\u0008\u000c\u000a\u000d\u0009→", "prêt": "ready" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 168.969727, 61.710706 ], [ 168.969727, 55.652798 ], [ 157.343445, 55.652798 ], [ 157.500000, 55.842940 ], [ 162.660828, 61.606396 ], [ 162.762451, 61.710706 ], [ 168.969727, 61.710706 ] ] ] } }
] }
] }
,
{ "type": "FeatureCollection", "properties": { "zoom": 5, "x": 30, "y": 8 }, "features": [
{ "type": "FeatureCollection", "properties": { "layer": "in", "version": 2, "extent": 4096 }, "features": [
{ "type": "Feature", "properties": { "boolean": true, "otherboolean": false, "stringify": "[\"yes\",27.00000000,27,1.4e27,{\"foo\":\"bar\"}]", "escape": "foo\u0001bar,ü\"\\/\u0008\u000c\u000a\u000d\u0009→", "prêt": "ready" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 168.969727, 61.501734 ], [ 162.559204, 61.501734 ], [ 162.660828, 61.606396 ], [ 163.476562, 62.431074 ], [ 168.750000, 64.207572 ], [ 168.969727, 64.279184 ], [ 168.969727, 61.501734 ] ] ] } }
{ "type": "Feature", "properties": { "boolean": true, "otherboolean": false, "stringify": "[\"yes\",27.00000000,27,1.4e27,{\"foo\":\"bar\"}]", "escape": "foo\u0001bar,ü\"\\/\u0008\u000c\u000a\u000d\u0009→", "prêt": "ready" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 168.969727, 64.279184 ], [ 168.969727, 61.501734 ], [ 162.559204, 61.501734 ], [ 162.660828, 61.606396 ], [ 163.476562, 62.431074 ], [ 168.750000, 64.207572 ], [ 168.969727, 64.279184 ] ] ] } }
] }
] }
,
{ "type": "FeatureCollection", "properties": { "zoom": 5, "x": 31, "y": 12 }, "features": [
{ "type": "FeatureCollection", "properties": { "layer": "in", "version": 2, "extent": 4096 }, "features": [
{ "type": "Feature", "properties": { "boolean": true, "otherboolean": false, "stringify": "[\"yes\",27.00000000,27,1.4e27,{\"foo\":\"bar\"}]", "escape": "foo\u0001bar,ü\"\\/\u0008\u000c\u000a\u000d\u0009→", "prêt": "ready" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 180.219727, 36.489765 ], [ 180.000000, 36.522881 ], [ 175.781250, 37.160317 ], [ 169.425659, 40.979898 ], [ 169.142761, 41.145570 ], [ 180.219727, 41.145570 ], [ 180.219727, 36.489765 ] ] ] } }
{ "type": "Feature", "properties": { "boolean": true, "otherboolean": false, "stringify": "[\"yes\",27.00000000,27,1.4e27,{\"foo\":\"bar\"}]", "escape": "foo\u0001bar,ü\"\\/\u0008\u000c\u000a\u000d\u0009→", "prêt": "ready" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 180.219727, 41.145570 ], [ 180.219727, 36.489765 ], [ 180.000000, 36.522881 ], [ 175.781250, 37.160317 ], [ 169.425659, 40.979898 ], [ 169.142761, 41.145570 ], [ 180.219727, 41.145570 ] ] ] } }
] }
] }
,
{ "type": "FeatureCollection", "properties": { "zoom": 5, "x": 31, "y": 11 }, "features": [
{ "type": "FeatureCollection", "properties": { "layer": "in", "version": 2, "extent": 4096 }, "features": [
{ "type": "Feature", "properties": { "boolean": true, "otherboolean": false, "stringify": "[\"yes\",27.00000000,27,1.4e27,{\"foo\":\"bar\"}]", "escape": "foo\u0001bar,ü\"\\/\u0008\u000c\u000a\u000d\u0009→", "prêt": "ready" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 174.023438, 47.279229 ], [ 180.219727, 45.135555 ], [ 180.219727, 40.813809 ], [ 169.708557, 40.813809 ], [ 169.425659, 40.979898 ], [ 168.750000, 41.376809 ], [ 168.530273, 41.504464 ], [ 168.530273, 49.066668 ], [ 173.435669, 49.066668 ], [ 173.485107, 48.922499 ], [ 174.023438, 47.279229 ] ] ] } }
{ "type": "Feature", "properties": { "boolean": true, "otherboolean": false, "stringify": "[\"yes\",27.00000000,27,1.4e27,{\"foo\":\"bar\"}]", "escape": "foo\u0001bar,ü\"\\/\u0008\u000c\u000a\u000d\u0009→", "prêt": "ready" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 173.435669, 49.066668 ], [ 173.485107, 48.922499 ], [ 174.023438, 47.279229 ], [ 180.219727, 45.135555 ], [ 180.219727, 40.813809 ], [ 169.708557, 40.813809 ], [ 169.425659, 40.979898 ], [ 168.750000, 41.376809 ], [ 168.530273, 41.504464 ], [ 168.530273, 49.066668 ], [ 173.435669, 49.066668 ] ] ] } }
] }
] }
,
{ "type": "FeatureCollection", "properties": { "zoom": 5, "x": 31, "y": 10 }, "features": [
{ "type": "FeatureCollection", "properties": { "layer": "in", "version": 2, "extent": 4096 }, "features": [
{ "type": "Feature", "properties": { "boolean": true, "otherboolean": false, "stringify": "[\"yes\",27.00000000,27,1.4e27,{\"foo\":\"bar\"}]", "escape": "foo\u0001bar,ü\"\\/\u0008\u000c\u000a\u000d\u0009→", "prêt": "ready" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 171.562500, 54.369359 ], [ 173.485107, 48.922499 ], [ 173.531799, 48.777913 ], [ 168.530273, 48.777913 ], [ 168.530273, 55.899956 ], [ 172.375488, 55.899956 ], [ 172.309570, 55.776573 ], [ 171.562500, 54.369359 ] ] ] } }
{ "type": "Feature", "properties": { "boolean": true, "otherboolean": false, "stringify": "[\"yes\",27.00000000,27,1.4e27,{\"foo\":\"bar\"}]", "escape": "foo\u0001bar,ü\"\\/\u0008\u000c\u000a\u000d\u0009→", "prêt": "ready" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 172.375488, 55.899956 ], [ 172.309570, 55.776573 ], [ 171.562500, 54.369359 ], [ 173.485107, 48.922499 ], [ 173.531799, 48.777913 ], [ 168.530273, 48.777913 ], [ 168.530273, 55.899956 ], [ 172.375488, 55.899956 ] ] ] } }
] }
] }
,
{ "type": "FeatureCollection", "properties": { "zoom": 5, "x": 31, "y": 9 }, "features": [
{ "type": "FeatureCollection", "properties": { "layer": "in", "version": 2, "extent": 4096 }, "features": [
{ "type": "Feature", "properties": { "boolean": true, "otherboolean": false, "stringify": "[\"yes\",27.00000000,27,1.4e27,{\"foo\":\"bar\"}]", "escape": "foo\u0001bar,ü\"\\/\u0008\u000c\u000a\u000d\u0009→", "prêt": "ready" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 174.023438, 58.815164 ], [ 172.306824, 55.776573 ], [ 172.240906, 55.652798 ], [ 168.530273, 55.652798 ], [ 168.530273, 61.710706 ], [ 180.131836, 61.710706 ], [ 179.901123, 61.606396 ], [ 174.023438, 58.815164 ] ] ] } }
{ "type": "Feature", "properties": { "boolean": true, "otherboolean": false, "stringify": "[\"yes\",27.00000000,27,1.4e27,{\"foo\":\"bar\"}]", "escape": "foo\u0001bar,ü\"\\/\u0008\u000c\u000a\u000d\u0009→", "prêt": "ready" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 180.131836, 61.710706 ], [ 179.901123, 61.606396 ], [ 174.023438, 58.815164 ], [ 172.306824, 55.776573 ], [ 172.240906, 55.652798 ], [ 168.530273, 55.652798 ], [ 168.530273, 61.710706 ], [ 180.131836, 61.710706 ] ] ] } }
] }
] }
,
{ "type": "FeatureCollection", "properties": { "zoom": 5, "x": 31, "y": 8 }, "features": [
{ "type": "FeatureCollection", "properties": { "layer": "in", "version": 2, "extent": 4096 }, "features": [
{ "type": "Feature", "properties": { "boolean": true, "otherboolean": false, "stringify": "[\"yes\",27.00000000,27,1.4e27,{\"foo\":\"bar\"}]", "escape": "foo\u0001bar,ü\"\\/\u0008\u000c\u000a\u000d\u0009→", "prêt": "ready" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 179.901123, 61.606396 ], [ 179.670410, 61.501734 ], [ 168.530273, 61.501734 ], [ 168.530273, 64.135775 ], [ 170.507812, 64.775296 ], [ 175.190735, 66.513260 ], [ 175.435181, 66.600676 ], [ 180.219727, 66.600676 ], [ 180.219727, 61.751031 ], [ 180.000000, 61.650771 ], [ 179.901123, 61.606396 ] ] ] } }
{ "type": "Feature", "properties": { "boolean": true, "otherboolean": false, "stringify": "[\"yes\",27.00000000,27,1.4e27,{\"foo\":\"bar\"}]", "escape": "foo\u0001bar,ü\"\\/\u0008\u000c\u000a\u000d\u0009→", "prêt": "ready" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 180.219727, 66.600676 ], [ 180.219727, 61.751031 ], [ 180.000000, 61.650771 ], [ 179.901123, 61.606396 ], [ 179.670410, 61.501734 ], [ 168.530273, 61.501734 ], [ 168.530273, 64.135775 ], [ 170.507812, 64.775296 ], [ 175.190735, 66.513260 ], [ 175.435181, 66.600676 ], [ 180.219727, 66.600676 ] ] ] } }
] }
] }
,
{ "type": "FeatureCollection", "properties": { "zoom": 5, "x": 31, "y": 7 }, "features": [
{ "type": "FeatureCollection", "properties": { "layer": "in", "version": 2, "extent": 4096 }, "features": [
{ "type": "Feature", "properties": { "boolean": true, "otherboolean": false, "stringify": "[\"yes\",27.00000000,27,1.4e27,{\"foo\":\"bar\"}]", "escape": "foo\u0001bar,ü\"\\/\u0008\u000c\u000a\u000d\u0009→", "prêt": "ready" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 180.219727, 66.425537 ], [ 174.946289, 66.425537 ], [ 175.190735, 66.513260 ], [ 177.539062, 67.339861 ], [ 180.000000, 67.515922 ], [ 180.219727, 67.531672 ], [ 180.219727, 66.425537 ] ] ] } }
{ "type": "Feature", "properties": { "boolean": true, "otherboolean": false, "stringify": "[\"yes\",27.00000000,27,1.4e27,{\"foo\":\"bar\"}]", "escape": "foo\u0001bar,ü\"\\/\u0008\u000c\u000a\u000d\u0009→", "prêt": "ready" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 180.219727, 67.531672 ], [ 180.219727, 66.425537 ], [ 174.946289, 66.425537 ], [ 175.190735, 66.513260 ], [ 177.539062, 67.339861 ], [ 180.000000, 67.515922 ], [ 180.219727, 67.531672 ] ] ] } }
] }
] }
] }

1984
tests/join-population/joined-i.mbtiles.json
View File

File diff suppressed because it is too large Load Diff

2918
tests/join-population/joined.mbtiles.json
View File

File diff suppressed because it is too large Load Diff

2918
tests/join-population/merged.mbtiles.json
View File

File diff suppressed because it is too large Load Diff

6
tests/named/out/-z0_-Lalgeria@tests%named%alg_-Lalbania@tests%named%alb.json
View File

File diff suppressed because one or more lines are too long

6
tests/named/out/-z0_-Lalgeria@tests%named%alg_-Lalbania@tests%named%alb_-lunified.json
View File

File diff suppressed because one or more lines are too long

2940
tests/ne_110m_admin_0_countries/out/-z4_-yname.json
View File

File diff suppressed because one or more lines are too long

1530
tests/ne_110m_admin_0_countries/out/-z4_-yname_--drop-polygons.json
View File

File diff suppressed because one or more lines are too long

3008
tests/ne_110m_admin_0_countries/out/-z4_-yname_--grid-low-zooms_-D8.json
View File

File diff suppressed because one or more lines are too long

2944
tests/ne_110m_admin_0_countries/out/-z4_-yname_--no-tiny-polygon-reduction.json
View File

File diff suppressed because one or more lines are too long

2938
tests/ne_110m_admin_0_countries/out/-z4_-yname_-S4.json
View File

File diff suppressed because one or more lines are too long

1780
tests/ne_110m_admin_0_countries/out/-z4_-yname_-pD.json
View File

File diff suppressed because one or more lines are too long

3014
tests/ne_110m_admin_0_countries/out/-z4_-yname_-pc.json
View File

File diff suppressed because one or more lines are too long

3506
tests/ne_110m_admin_0_countries/out/-z5_-M5000_--drop-smallest-as-needed.json
View File

File diff suppressed because one or more lines are too long

40
tests/nullisland/out/-b0_-z4.json
View File

@ -12,23 +12,23 @@
}, "features": [
{ "type": "FeatureCollection", "properties": { "zoom": 0, "x": 0, "y": 0 }, "features": [
{ "type": "FeatureCollection", "properties": { "layer": "in", "version": 2, "extent": 4096 }, "features": [
{ "type": "Feature", "properties": { }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 0.000000, 0.000000 ], [ -1.054688, 0.000000 ], [ -1.054688, 1.054628 ], [ 0.000000, 1.054628 ], [ 0.000000, 0.000000 ] ] ] } }
{ "type": "Feature", "properties": { }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 0.000000, 1.054628 ], [ 0.000000, 0.000000 ], [ -1.054688, 0.000000 ], [ -1.054688, 1.054628 ], [ 0.000000, 1.054628 ] ] ] } }
,
{ "type": "Feature", "properties": { }, "geometry": { "type": "Point", "coordinates": [ -1.054688, 0.000000 ] } }
,
{ "type": "Feature", "properties": { }, "geometry": { "type": "LineString", "coordinates": [ [ 0.000000, 0.000000 ], [ -1.054688, 0.000000 ] ] } }
,
{ "type": "Feature", "properties": { }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 0.000000, -0.966751 ], [ -1.054688, -0.966751 ], [ -1.054688, 0.000000 ], [ 0.000000, 0.000000 ], [ 0.000000, -0.966751 ] ] ] } }
{ "type": "Feature", "properties": { }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 0.000000, 0.000000 ], [ 0.000000, -0.966751 ], [ -1.054688, -0.966751 ], [ -1.054688, 0.000000 ], [ 0.000000, 0.000000 ] ] ] } }
,
{ "type": "Feature", "properties": { }, "geometry": { "type": "LineString", "coordinates": [ [ 0.000000, 0.000000 ], [ 0.000000, 1.054628 ] ] } }
,
{ "type": "Feature", "properties": { }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 0.966797, 0.000000 ], [ 0.000000, 0.000000 ], [ 0.000000, 1.054628 ], [ 0.966797, 1.054628 ], [ 0.966797, 0.000000 ] ] ] } }
{ "type": "Feature", "properties": { }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 0.966797, 1.054628 ], [ 0.966797, 0.000000 ], [ 0.000000, 0.000000 ], [ 0.000000, 1.054628 ], [ 0.966797, 1.054628 ] ] ] } }
,
{ "type": "Feature", "properties": { }, "geometry": { "type": "LineString", "coordinates": [ [ 0.000000, 0.000000 ], [ 0.000000, -0.966751 ] ] } }
,
{ "type": "Feature", "properties": { }, "geometry": { "type": "LineString", "coordinates": [ [ 0.000000, 0.000000 ], [ 0.966797, 0.000000 ] ] } }
,
{ "type": "Feature", "properties": { }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 0.966797, -0.966751 ], [ 0.000000, -0.966751 ], [ 0.000000, 0.000000 ], [ 0.966797, 0.000000 ], [ 0.966797, -0.966751 ] ] ] } }
{ "type": "Feature", "properties": { }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 0.966797, 0.000000 ], [ 0.966797, -0.966751 ], [ 0.000000, -0.966751 ], [ 0.000000, 0.000000 ], [ 0.966797, 0.000000 ] ] ] } }
] }
] }
,
@ -38,7 +38,7 @@
,
{ "type": "Feature", "properties": { }, "geometry": { "type": "LineString", "coordinates": [ [ 0.000000, 0.000000 ], [ -1.010742, 0.000000 ] ] } }
,
{ "type": "Feature", "properties": { }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 0.000000, -0.966751 ], [ -1.010742, -0.966751 ], [ -1.010742, 0.000000 ], [ 0.000000, 0.000000 ], [ 0.000000, -0.966751 ] ] ] } }
{ "type": "Feature", "properties": { }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 0.000000, 0.000000 ], [ 0.000000, -0.966751 ], [ -1.010742, -0.966751 ], [ -1.010742, 0.000000 ], [ 0.000000, 0.000000 ] ] ] } }
,
{ "type": "Feature", "properties": { }, "geometry": { "type": "Point", "coordinates": [ 0.000000, 0.000000 ] } }
,
@ -48,7 +48,7 @@
,
{ "type": "FeatureCollection", "properties": { "zoom": 1, "x": 0, "y": 0 }, "features": [
{ "type": "FeatureCollection", "properties": { "layer": "in", "version": 2, "extent": 4096 }, "features": [
{ "type": "Feature", "properties": { }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 0.000000, 0.000000 ], [ -1.010742, 0.000000 ], [ -1.010742, 1.010690 ], [ 0.000000, 1.010690 ], [ 0.000000, 0.000000 ] ] ] } }
{ "type": "Feature", "properties": { }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 0.000000, 1.010690 ], [ 0.000000, 0.000000 ], [ -1.010742, 0.000000 ], [ -1.010742, 1.010690 ], [ 0.000000, 1.010690 ] ] ] } }
,
{ "type": "Feature", "properties": { }, "geometry": { "type": "Point", "coordinates": [ -1.010742, 0.000000 ] } }
,
@ -70,7 +70,7 @@
,
{ "type": "Feature", "properties": { }, "geometry": { "type": "LineString", "coordinates": [ [ 0.000000, 0.000000 ], [ 0.966797, 0.000000 ] ] } }
,
{ "type": "Feature", "properties": { }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 0.966797, -0.966751 ], [ 0.000000, -0.966751 ], [ 0.000000, 0.000000 ], [ 0.966797, 0.000000 ], [ 0.966797, -0.966751 ] ] ] } }
{ "type": "Feature", "properties": { }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 0.966797, 0.000000 ], [ 0.966797, -0.966751 ], [ 0.000000, -0.966751 ], [ 0.000000, 0.000000 ], [ 0.966797, 0.000000 ] ] ] } }
] }
] }
,
@ -80,7 +80,7 @@
,
{ "type": "Feature", "properties": { }, "geometry": { "type": "LineString", "coordinates": [ [ 0.000000, 0.000000 ], [ 0.000000, 1.010690 ] ] } }
,
{ "type": "Feature", "properties": { }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 0.966797, 0.000000 ], [ 0.000000, 0.000000 ], [ 0.000000, 1.010690 ], [ 0.966797, 1.010690 ], [ 0.966797, 0.000000 ] ] ] } }
{ "type": "Feature", "properties": { }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 0.966797, 1.010690 ], [ 0.966797, 0.000000 ], [ 0.000000, 0.000000 ], [ 0.000000, 1.010690 ], [ 0.966797, 1.010690 ] ] ] } }
,
{ "type": "Feature", "properties": { }, "geometry": { "type": "Point", "coordinates": [ 0.000000, 0.000000 ] } }
,
@ -94,7 +94,7 @@
,
{ "type": "Feature", "properties": { }, "geometry": { "type": "LineString", "coordinates": [ [ 0.000000, 0.000000 ], [ -1.010742, 0.000000 ] ] } }
,
{ "type": "Feature", "properties": { }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 0.000000, -0.988720 ], [ -1.010742, -0.988720 ], [ -1.010742, 0.000000 ], [ 0.000000, 0.000000 ], [ 0.000000, -0.988720 ] ] ] } }
{ "type": "Feature", "properties": { }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 0.000000, 0.000000 ], [ 0.000000, -0.988720 ], [ -1.010742, -0.988720 ], [ -1.010742, 0.000000 ], [ 0.000000, 0.000000 ] ] ] } }
,
{ "type": "Feature", "properties": { }, "geometry": { "type": "Point", "coordinates": [ 0.000000, 0.000000 ] } }
,
@ -104,7 +104,7 @@
,
{ "type": "FeatureCollection", "properties": { "zoom": 2, "x": 1, "y": 1 }, "features": [
{ "type": "FeatureCollection", "properties": { "layer": "in", "version": 2, "extent": 4096 }, "features": [
{ "type": "Feature", "properties": { }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 0.000000, 0.000000 ], [ -1.010742, 0.000000 ], [ -1.010742, 1.010690 ], [ 0.000000, 1.010690 ], [ 0.000000, 0.000000 ] ] ] } }
{ "type": "Feature", "properties": { }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 0.000000, 1.010690 ], [ 0.000000, 0.000000 ], [ -1.010742, 0.000000 ], [ -1.010742, 1.010690 ], [ 0.000000, 1.010690 ] ] ] } }
,
{ "type": "Feature", "properties": { }, "geometry": { "type": "Point", "coordinates": [ -1.010742, 0.000000 ] } }
,
@ -126,7 +126,7 @@
,
{ "type": "Feature", "properties": { }, "geometry": { "type": "LineString", "coordinates": [ [ 0.000000, 0.000000 ], [ 0.988770, 0.000000 ] ] } }
,
{ "type": "Feature", "properties": { }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 0.988770, -0.988720 ], [ 0.000000, -0.988720 ], [ 0.000000, 0.000000 ], [ 0.988770, 0.000000 ], [ 0.988770, -0.988720 ] ] ] } }
{ "type": "Feature", "properties": { }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 0.988770, 0.000000 ], [ 0.988770, -0.988720 ], [ 0.000000, -0.988720 ], [ 0.000000, 0.000000 ], [ 0.988770, 0.000000 ] ] ] } }
] }
] }
,
@ -136,7 +136,7 @@
,
{ "type": "Feature", "properties": { }, "geometry": { "type": "LineString", "coordinates": [ [ 0.000000, 0.000000 ], [ 0.000000, 1.010690 ] ] } }
,
{ "type": "Feature", "properties": { }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 0.988770, 0.000000 ], [ 0.000000, 0.000000 ], [ 0.000000, 1.010690 ], [ 0.988770, 1.010690 ], [ 0.988770, 0.000000 ] ] ] } }
{ "type": "Feature", "properties": { }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 0.988770, 1.010690 ], [ 0.988770, 0.000000 ], [ 0.000000, 0.000000 ], [ 0.000000, 1.010690 ], [ 0.988770, 1.010690 ] ] ] } }
,
{ "type": "Feature", "properties": { }, "geometry": { "type": "Point", "coordinates": [ 0.000000, 0.000000 ] } }
,
@ -150,7 +150,7 @@
,
{ "type": "Feature", "properties": { }, "geometry": { "type": "LineString", "coordinates": [ [ 0.000000, 0.000000 ], [ -1.010742, 0.000000 ] ] } }
,
{ "type": "Feature", "properties": { }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 0.000000, -0.999705 ], [ -1.010742, -0.999705 ], [ -1.010742, 0.000000 ], [ 0.000000, 0.000000 ], [ 0.000000, -0.999705 ] ] ] } }
{ "type": "Feature", "properties": { }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 0.000000, 0.000000 ], [ 0.000000, -0.999705 ], [ -1.010742, -0.999705 ], [ -1.010742, 0.000000 ], [ 0.000000, 0.000000 ] ] ] } }
,
{ "type": "Feature", "properties": { }, "geometry": { "type": "Point", "coordinates": [ 0.000000, 0.000000 ] } }
,
@ -160,7 +160,7 @@
,
{ "type": "FeatureCollection", "properties": { "zoom": 3, "x": 3, "y": 3 }, "features": [
{ "type": "FeatureCollection", "properties": { "layer": "in", "version": 2, "extent": 4096 }, "features": [
{ "type": "Feature", "properties": { }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 0.000000, 0.000000 ], [ -1.010742, 0.000000 ], [ -1.010742, 1.010690 ], [ 0.000000, 1.010690 ], [ 0.000000, 0.000000 ] ] ] } }
{ "type": "Feature", "properties": { }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 0.000000, 1.010690 ], [ 0.000000, 0.000000 ], [ -1.010742, 0.000000 ], [ -1.010742, 1.010690 ], [ 0.000000, 1.010690 ] ] ] } }
,
{ "type": "Feature", "properties": { }, "geometry": { "type": "Point", "coordinates": [ -1.010742, 0.000000 ] } }
,
@ -182,7 +182,7 @@
,
{ "type": "Feature", "properties": { }, "geometry": { "type": "LineString", "coordinates": [ [ 0.000000, 0.000000 ], [ 0.999756, 0.000000 ] ] } }
,
{ "type": "Feature", "properties": { }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 0.999756, -0.999705 ], [ 0.000000, -0.999705 ], [ 0.000000, 0.000000 ], [ 0.999756, 0.000000 ], [ 0.999756, -0.999705 ] ] ] } }
{ "type": "Feature", "properties": { }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 0.999756, 0.000000 ], [ 0.999756, -0.999705 ], [ 0.000000, -0.999705 ], [ 0.000000, 0.000000 ], [ 0.999756, 0.000000 ] ] ] } }
,
{ "type": "Feature", "properties": { }, "geometry": { "type": "Point", "coordinates": [ 0.999756, 0.000000 ] } }
] }
@ -194,7 +194,7 @@
,
{ "type": "Feature", "properties": { }, "geometry": { "type": "LineString", "coordinates": [ [ 0.000000, 0.000000 ], [ 0.000000, 1.010690 ] ] } }
,
{ "type": "Feature", "properties": { }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 0.999756, 0.000000 ], [ 0.000000, 0.000000 ], [ 0.000000, 1.010690 ], [ 0.999756, 1.010690 ], [ 0.999756, 0.000000 ] ] ] } }
{ "type": "Feature", "properties": { }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 0.999756, 1.010690 ], [ 0.999756, 0.000000 ], [ 0.000000, 0.000000 ], [ 0.000000, 1.010690 ], [ 0.999756, 1.010690 ] ] ] } }
,
{ "type": "Feature", "properties": { }, "geometry": { "type": "Point", "coordinates": [ 0.000000, 0.000000 ] } }
,
@ -210,7 +210,7 @@
,
{ "type": "Feature", "properties": { }, "geometry": { "type": "LineString", "coordinates": [ [ 0.000000, 0.000000 ], [ -1.005249, 0.000000 ] ] } }
,
{ "type": "Feature", "properties": { }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 0.000000, -0.999705 ], [ -1.005249, -0.999705 ], [ -1.005249, 0.000000 ], [ 0.000000, 0.000000 ], [ 0.000000, -0.999705 ] ] ] } }
{ "type": "Feature", "properties": { }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 0.000000, 0.000000 ], [ 0.000000, -0.999705 ], [ -1.005249, -0.999705 ], [ -1.005249, 0.000000 ], [ 0.000000, 0.000000 ] ] ] } }
,
{ "type": "Feature", "properties": { }, "geometry": { "type": "Point", "coordinates": [ 0.000000, 0.000000 ] } }
,
@ -222,7 +222,7 @@
,
{ "type": "FeatureCollection", "properties": { "zoom": 4, "x": 7, "y": 7 }, "features": [
{ "type": "FeatureCollection", "properties": { "layer": "in", "version": 2, "extent": 4096 }, "features": [
{ "type": "Feature", "properties": { }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 0.000000, 0.000000 ], [ -1.005249, 0.000000 ], [ -1.005249, 1.005197 ], [ 0.000000, 1.005197 ], [ 0.000000, 0.000000 ] ] ] } }
{ "type": "Feature", "properties": { }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 0.000000, 1.005197 ], [ 0.000000, 0.000000 ], [ -1.005249, 0.000000 ], [ -1.005249, 1.005197 ], [ 0.000000, 1.005197 ] ] ] } }
,
{ "type": "Feature", "properties": { }, "geometry": { "type": "Point", "coordinates": [ -1.005249, 0.000000 ] } }
,
@ -244,7 +244,7 @@
,
{ "type": "Feature", "properties": { }, "geometry": { "type": "LineString", "coordinates": [ [ 0.000000, 0.000000 ], [ 0.999756, 0.000000 ] ] } }
,
{ "type": "Feature", "properties": { }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 0.999756, -0.999705 ], [ 0.000000, -0.999705 ], [ 0.000000, 0.000000 ], [ 0.999756, 0.000000 ], [ 0.999756, -0.999705 ] ] ] } }
{ "type": "Feature", "properties": { }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 0.999756, 0.000000 ], [ 0.999756, -0.999705 ], [ 0.000000, -0.999705 ], [ 0.000000, 0.000000 ], [ 0.999756, 0.000000 ] ] ] } }
,
{ "type": "Feature", "properties": { }, "geometry": { "type": "Point", "coordinates": [ 0.000000, -0.999705 ] } }
,
@ -258,7 +258,7 @@
,
{ "type": "Feature", "properties": { }, "geometry": { "type": "LineString", "coordinates": [ [ 0.000000, 0.000000 ], [ 0.000000, 1.005197 ] ] } }
,
{ "type": "Feature", "properties": { }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 0.999756, 0.000000 ], [ 0.000000, 0.000000 ], [ 0.000000, 1.005197 ], [ 0.999756, 1.005197 ], [ 0.999756, 0.000000 ] ] ] } }
{ "type": "Feature", "properties": { }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 0.999756, 1.005197 ], [ 0.999756, 0.000000 ], [ 0.000000, 0.000000 ], [ 0.000000, 1.005197 ], [ 0.999756, 1.005197 ] ] ] } }
,
{ "type": "Feature", "properties": { }, "geometry": { "type": "Point", "coordinates": [ 0.000000, 0.000000 ] } }
,

40
tests/nullisland/out/-b0_-z4_-ANullIsland.json
View File

@ -13,23 +13,23 @@
}, "features": [
{ "type": "FeatureCollection", "properties": { "zoom": 0, "x": 0, "y": 0 }, "features": [
{ "type": "FeatureCollection", "properties": { "layer": "in", "version": 2, "extent": 4096 }, "features": [
{ "type": "Feature", "properties": { }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 0.000000, 0.000000 ], [ -1.054688, 0.000000 ], [ -1.054688, 1.054628 ], [ 0.000000, 1.054628 ], [ 0.000000, 0.000000 ] ] ] } }
{ "type": "Feature", "properties": { }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 0.000000, 1.054628 ], [ 0.000000, 0.000000 ], [ -1.054688, 0.000000 ], [ -1.054688, 1.054628 ], [ 0.000000, 1.054628 ] ] ] } }
,
{ "type": "Feature", "properties": { }, "geometry": { "type": "Point", "coordinates": [ -1.054688, 0.000000 ] } }
,
{ "type": "Feature", "properties": { }, "geometry": { "type": "LineString", "coordinates": [ [ 0.000000, 0.000000 ], [ -1.054688, 0.000000 ] ] } }
,
{ "type": "Feature", "properties": { }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 0.000000, -0.966751 ], [ -1.054688, -0.966751 ], [ -1.054688, 0.000000 ], [ 0.000000, 0.000000 ], [ 0.000000, -0.966751 ] ] ] } }
{ "type": "Feature", "properties": { }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 0.000000, 0.000000 ], [ 0.000000, -0.966751 ], [ -1.054688, -0.966751 ], [ -1.054688, 0.000000 ], [ 0.000000, 0.000000 ] ] ] } }
,
{ "type": "Feature", "properties": { }, "geometry": { "type": "LineString", "coordinates": [ [ 0.000000, 0.000000 ], [ 0.000000, 1.054628 ] ] } }
,
{ "type": "Feature", "properties": { }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 0.966797, 0.000000 ], [ 0.000000, 0.000000 ], [ 0.000000, 1.054628 ], [ 0.966797, 1.054628 ], [ 0.966797, 0.000000 ] ] ] } }
{ "type": "Feature", "properties": { }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 0.966797, 1.054628 ], [ 0.966797, 0.000000 ], [ 0.000000, 0.000000 ], [ 0.000000, 1.054628 ], [ 0.966797, 1.054628 ] ] ] } }
,
{ "type": "Feature", "properties": { }, "geometry": { "type": "LineString", "coordinates": [ [ 0.000000, 0.000000 ], [ 0.000000, -0.966751 ] ] } }
,
{ "type": "Feature", "properties": { }, "geometry": { "type": "LineString", "coordinates": [ [ 0.000000, 0.000000 ], [ 0.966797, 0.000000 ] ] } }
,
{ "type": "Feature", "properties": { }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 0.966797, -0.966751 ], [ 0.000000, -0.966751 ], [ 0.000000, 0.000000 ], [ 0.966797, 0.000000 ], [ 0.966797, -0.966751 ] ] ] } }
{ "type": "Feature", "properties": { }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 0.966797, 0.000000 ], [ 0.966797, -0.966751 ], [ 0.000000, -0.966751 ], [ 0.000000, 0.000000 ], [ 0.966797, 0.000000 ] ] ] } }
] }
] }
,
@ -39,7 +39,7 @@
,
{ "type": "Feature", "properties": { }, "geometry": { "type": "LineString", "coordinates": [ [ 0.000000, 0.000000 ], [ -1.010742, 0.000000 ] ] } }
,
{ "type": "Feature", "properties": { }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 0.000000, -0.966751 ], [ -1.010742, -0.966751 ], [ -1.010742, 0.000000 ], [ 0.000000, 0.000000 ], [ 0.000000, -0.966751 ] ] ] } }
{ "type": "Feature", "properties": { }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 0.000000, 0.000000 ], [ 0.000000, -0.966751 ], [ -1.010742, -0.966751 ], [ -1.010742, 0.000000 ], [ 0.000000, 0.000000 ] ] ] } }
,
{ "type": "Feature", "properties": { }, "geometry": { "type": "Point", "coordinates": [ 0.000000, 0.000000 ] } }
,
@ -49,7 +49,7 @@
,
{ "type": "FeatureCollection", "properties": { "zoom": 1, "x": 0, "y": 0 }, "features": [
{ "type": "FeatureCollection", "properties": { "layer": "in", "version": 2, "extent": 4096 }, "features": [
{ "type": "Feature", "properties": { }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 0.000000, 0.000000 ], [ -1.010742, 0.000000 ], [ -1.010742, 1.010690 ], [ 0.000000, 1.010690 ], [ 0.000000, 0.000000 ] ] ] } }
{ "type": "Feature", "properties": { }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 0.000000, 1.010690 ], [ 0.000000, 0.000000 ], [ -1.010742, 0.000000 ], [ -1.010742, 1.010690 ], [ 0.000000, 1.010690 ] ] ] } }
,
{ "type": "Feature", "properties": { }, "geometry": { "type": "Point", "coordinates": [ -1.010742, 0.000000 ] } }
,
@ -71,7 +71,7 @@
,
{ "type": "Feature", "properties": { }, "geometry": { "type": "LineString", "coordinates": [ [ 0.000000, 0.000000 ], [ 0.966797, 0.000000 ] ] } }
,
{ "type": "Feature", "properties": { }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 0.966797, -0.966751 ], [ 0.000000, -0.966751 ], [ 0.000000, 0.000000 ], [ 0.966797, 0.000000 ], [ 0.966797, -0.966751 ] ] ] } }
{ "type": "Feature", "properties": { }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 0.966797, 0.000000 ], [ 0.966797, -0.966751 ], [ 0.000000, -0.966751 ], [ 0.000000, 0.000000 ], [ 0.966797, 0.000000 ] ] ] } }
] }
] }
,
@ -81,7 +81,7 @@
,
{ "type": "Feature", "properties": { }, "geometry": { "type": "LineString", "coordinates": [ [ 0.000000, 0.000000 ], [ 0.000000, 1.010690 ] ] } }
,
{ "type": "Feature", "properties": { }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 0.966797, 0.000000 ], [ 0.000000, 0.000000 ], [ 0.000000, 1.010690 ], [ 0.966797, 1.010690 ], [ 0.966797, 0.000000 ] ] ] } }
{ "type": "Feature", "properties": { }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 0.966797, 1.010690 ], [ 0.966797, 0.000000 ], [ 0.000000, 0.000000 ], [ 0.000000, 1.010690 ], [ 0.966797, 1.010690 ] ] ] } }
,
{ "type": "Feature", "properties": { }, "geometry": { "type": "Point", "coordinates": [ 0.000000, 0.000000 ] } }
,
@ -95,7 +95,7 @@
,
{ "type": "Feature", "properties": { }, "geometry": { "type": "LineString", "coordinates": [ [ 0.000000, 0.000000 ], [ -1.010742, 0.000000 ] ] } }
,
{ "type": "Feature", "properties": { }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 0.000000, -0.988720 ], [ -1.010742, -0.988720 ], [ -1.010742, 0.000000 ], [ 0.000000, 0.000000 ], [ 0.000000, -0.988720 ] ] ] } }
{ "type": "Feature", "properties": { }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 0.000000, 0.000000 ], [ 0.000000, -0.988720 ], [ -1.010742, -0.988720 ], [ -1.010742, 0.000000 ], [ 0.000000, 0.000000 ] ] ] } }
,
{ "type": "Feature", "properties": { }, "geometry": { "type": "Point", "coordinates": [ 0.000000, 0.000000 ] } }
,
@ -105,7 +105,7 @@
,
{ "type": "FeatureCollection", "properties": { "zoom": 2, "x": 1, "y": 1 }, "features": [
{ "type": "FeatureCollection", "properties": { "layer": "in", "version": 2, "extent": 4096 }, "features": [
{ "type": "Feature", "properties": { }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 0.000000, 0.000000 ], [ -1.010742, 0.000000 ], [ -1.010742, 1.010690 ], [ 0.000000, 1.010690 ], [ 0.000000, 0.000000 ] ] ] } }
{ "type": "Feature", "properties": { }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 0.000000, 1.010690 ], [ 0.000000, 0.000000 ], [ -1.010742, 0.000000 ], [ -1.010742, 1.010690 ], [ 0.000000, 1.010690 ] ] ] } }
,
{ "type": "Feature", "properties": { }, "geometry": { "type": "Point", "coordinates": [ -1.010742, 0.000000 ] } }
,
@ -127,7 +127,7 @@
,
{ "type": "Feature", "properties": { }, "geometry": { "type": "LineString", "coordinates": [ [ 0.000000, 0.000000 ], [ 0.988770, 0.000000 ] ] } }
,
{ "type": "Feature", "properties": { }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 0.988770, -0.988720 ], [ 0.000000, -0.988720 ], [ 0.000000, 0.000000 ], [ 0.988770, 0.000000 ], [ 0.988770, -0.988720 ] ] ] } }
{ "type": "Feature", "properties": { }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 0.988770, 0.000000 ], [ 0.988770, -0.988720 ], [ 0.000000, -0.988720 ], [ 0.000000, 0.000000 ], [ 0.988770, 0.000000 ] ] ] } }
] }
] }
,
@ -137,7 +137,7 @@
,
{ "type": "Feature", "properties": { }, "geometry": { "type": "LineString", "coordinates": [ [ 0.000000, 0.000000 ], [ 0.000000, 1.010690 ] ] } }
,
{ "type": "Feature", "properties": { }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 0.988770, 0.000000 ], [ 0.000000, 0.000000 ], [ 0.000000, 1.010690 ], [ 0.988770, 1.010690 ], [ 0.988770, 0.000000 ] ] ] } }
{ "type": "Feature", "properties": { }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 0.988770, 1.010690 ], [ 0.988770, 0.000000 ], [ 0.000000, 0.000000 ], [ 0.000000, 1.010690 ], [ 0.988770, 1.010690 ] ] ] } }
,
{ "type": "Feature", "properties": { }, "geometry": { "type": "Point", "coordinates": [ 0.000000, 0.000000 ] } }
,
@ -151,7 +151,7 @@
,
{ "type": "Feature", "properties": { }, "geometry": { "type": "LineString", "coordinates": [ [ 0.000000, 0.000000 ], [ -1.010742, 0.000000 ] ] } }
,
{ "type": "Feature", "properties": { }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 0.000000, -0.999705 ], [ -1.010742, -0.999705 ], [ -1.010742, 0.000000 ], [ 0.000000, 0.000000 ], [ 0.000000, -0.999705 ] ] ] } }
{ "type": "Feature", "properties": { }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 0.000000, 0.000000 ], [ 0.000000, -0.999705 ], [ -1.010742, -0.999705 ], [ -1.010742, 0.000000 ], [ 0.000000, 0.000000 ] ] ] } }
,
{ "type": "Feature", "properties": { }, "geometry": { "type": "Point", "coordinates": [ 0.000000, 0.000000 ] } }
,
@ -161,7 +161,7 @@
,
{ "type": "FeatureCollection", "properties": { "zoom": 3, "x": 3, "y": 3 }, "features": [
{ "type": "FeatureCollection", "properties": { "layer": "in", "version": 2, "extent": 4096 }, "features": [
{ "type": "Feature", "properties": { }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 0.000000, 0.000000 ], [ -1.010742, 0.000000 ], [ -1.010742, 1.010690 ], [ 0.000000, 1.010690 ], [ 0.000000, 0.000000 ] ] ] } }
{ "type": "Feature", "properties": { }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 0.000000, 1.010690 ], [ 0.000000, 0.000000 ], [ -1.010742, 0.000000 ], [ -1.010742, 1.010690 ], [ 0.000000, 1.010690 ] ] ] } }
,
{ "type": "Feature", "properties": { }, "geometry": { "type": "Point", "coordinates": [ -1.010742, 0.000000 ] } }
,
@ -183,7 +183,7 @@
,
{ "type": "Feature", "properties": { }, "geometry": { "type": "LineString", "coordinates": [ [ 0.000000, 0.000000 ], [ 0.999756, 0.000000 ] ] } }
,
{ "type": "Feature", "properties": { }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 0.999756, -0.999705 ], [ 0.000000, -0.999705 ], [ 0.000000, 0.000000 ], [ 0.999756, 0.000000 ], [ 0.999756, -0.999705 ] ] ] } }
{ "type": "Feature", "properties": { }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 0.999756, 0.000000 ], [ 0.999756, -0.999705 ], [ 0.000000, -0.999705 ], [ 0.000000, 0.000000 ], [ 0.999756, 0.000000 ] ] ] } }
,
{ "type": "Feature", "properties": { }, "geometry": { "type": "Point", "coordinates": [ 0.999756, 0.000000 ] } }
] }
@ -195,7 +195,7 @@
,
{ "type": "Feature", "properties": { }, "geometry": { "type": "LineString", "coordinates": [ [ 0.000000, 0.000000 ], [ 0.000000, 1.010690 ] ] } }
,
{ "type": "Feature", "properties": { }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 0.999756, 0.000000 ], [ 0.000000, 0.000000 ], [ 0.000000, 1.010690 ], [ 0.999756, 1.010690 ], [ 0.999756, 0.000000 ] ] ] } }
{ "type": "Feature", "properties": { }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 0.999756, 1.010690 ], [ 0.999756, 0.000000 ], [ 0.000000, 0.000000 ], [ 0.000000, 1.010690 ], [ 0.999756, 1.010690 ] ] ] } }
,
{ "type": "Feature", "properties": { }, "geometry": { "type": "Point", "coordinates": [ 0.000000, 0.000000 ] } }
,
@ -211,7 +211,7 @@
,
{ "type": "Feature", "properties": { }, "geometry": { "type": "LineString", "coordinates": [ [ 0.000000, 0.000000 ], [ -1.005249, 0.000000 ] ] } }
,
{ "type": "Feature", "properties": { }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 0.000000, -0.999705 ], [ -1.005249, -0.999705 ], [ -1.005249, 0.000000 ], [ 0.000000, 0.000000 ], [ 0.000000, -0.999705 ] ] ] } }
{ "type": "Feature", "properties": { }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 0.000000, 0.000000 ], [ 0.000000, -0.999705 ], [ -1.005249, -0.999705 ], [ -1.005249, 0.000000 ], [ 0.000000, 0.000000 ] ] ] } }
,
{ "type": "Feature", "properties": { }, "geometry": { "type": "Point", "coordinates": [ 0.000000, 0.000000 ] } }
,
@ -223,7 +223,7 @@
,
{ "type": "FeatureCollection", "properties": { "zoom": 4, "x": 7, "y": 7 }, "features": [
{ "type": "FeatureCollection", "properties": { "layer": "in", "version": 2, "extent": 4096 }, "features": [
{ "type": "Feature", "properties": { }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 0.000000, 0.000000 ], [ -1.005249, 0.000000 ], [ -1.005249, 1.005197 ], [ 0.000000, 1.005197 ], [ 0.000000, 0.000000 ] ] ] } }
{ "type": "Feature", "properties": { }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 0.000000, 1.005197 ], [ 0.000000, 0.000000 ], [ -1.005249, 0.000000 ], [ -1.005249, 1.005197 ], [ 0.000000, 1.005197 ] ] ] } }
,
{ "type": "Feature", "properties": { }, "geometry": { "type": "Point", "coordinates": [ -1.005249, 0.000000 ] } }
,
@ -245,7 +245,7 @@
,
{ "type": "Feature", "properties": { }, "geometry": { "type": "LineString", "coordinates": [ [ 0.000000, 0.000000 ], [ 0.999756, 0.000000 ] ] } }
,
{ "type": "Feature", "properties": { }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 0.999756, -0.999705 ], [ 0.000000, -0.999705 ], [ 0.000000, 0.000000 ], [ 0.999756, 0.000000 ], [ 0.999756, -0.999705 ] ] ] } }
{ "type": "Feature", "properties": { }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 0.999756, 0.000000 ], [ 0.999756, -0.999705 ], [ 0.000000, -0.999705 ], [ 0.000000, 0.000000 ], [ 0.999756, 0.000000 ] ] ] } }
,
{ "type": "Feature", "properties": { }, "geometry": { "type": "Point", "coordinates": [ 0.000000, -0.999705 ] } }
,
@ -259,7 +259,7 @@
,
{ "type": "Feature", "properties": { }, "geometry": { "type": "LineString", "coordinates": [ [ 0.000000, 0.000000 ], [ 0.000000, 1.005197 ] ] } }
,
{ "type": "Feature", "properties": { }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 0.999756, 0.000000 ], [ 0.000000, 0.000000 ], [ 0.000000, 1.005197 ], [ 0.999756, 1.005197 ], [ 0.999756, 0.000000 ] ] ] } }
{ "type": "Feature", "properties": { }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 0.999756, 1.005197 ], [ 0.999756, 0.000000 ], [ 0.000000, 0.000000 ], [ 0.000000, 1.005197 ], [ 0.999756, 1.005197 ] ] ] } }
,
{ "type": "Feature", "properties": { }, "geometry": { "type": "Point", "coordinates": [ 0.000000, 0.000000 ] } }
,

4
tests/overlap/out/-z0.json
View File

@ -12,9 +12,9 @@
}, "features": [
{ "type": "FeatureCollection", "properties": { "zoom": 0, "x": 0, "y": 0 }, "features": [
{ "type": "FeatureCollection", "properties": { "layer": "in", "version": 2, "extent": 4096 }, "features": [
{ "type": "Feature", "properties": { }, "geometry": { "type": "Polygon", "coordinates": [ [ [ -3.076172, 61.015725 ], [ -37.001953, 34.016242 ], [ -71.015625, 29.075375 ], [ -103.007812, 39.027719 ], [ -117.070312, 60.020952 ], [ -113.027344, 69.005675 ], [ -93.076172, 75.004940 ], [ -74.003906, 79.004962 ], [ -33.046875, 79.004962 ], [ -3.076172, 61.015725 ] ] ] } }
{ "type": "Feature", "properties": { }, "geometry": { "type": "Polygon", "coordinates": [ [ [ -33.046875, 79.004962 ], [ -3.076172, 61.015725 ], [ -37.001953, 34.016242 ], [ -71.015625, 29.075375 ], [ -103.007812, 39.027719 ], [ -117.070312, 60.020952 ], [ -113.027344, 69.005675 ], [ -93.076172, 75.004940 ], [ -74.003906, 79.004962 ], [ -33.046875, 79.004962 ] ] ] } }
,
{ "type": "Feature", "properties": { }, "geometry": { "type": "Polygon", "coordinates": [ [ [ -28.037109, 59.040555 ], [ -10.019531, 50.007739 ], [ -5.009766, 8.059230 ], [ -17.050781, -21.943046 ], [ -75.058594, -30.977609 ], [ -118.037109, -8.928487 ], [ -135.000000, 29.075375 ], [ -113.027344, 53.014783 ], [ -81.035156, 63.035039 ], [ -28.037109, 59.040555 ] ] ] } }
{ "type": "Feature", "properties": { }, "geometry": { "type": "Polygon", "coordinates": [ [ [ -81.035156, 63.035039 ], [ -28.037109, 59.040555 ], [ -10.019531, 50.007739 ], [ -5.009766, 8.059230 ], [ -17.050781, -21.943046 ], [ -75.058594, -30.977609 ], [ -118.037109, -8.928487 ], [ -135.000000, 29.075375 ], [ -113.027344, 53.014783 ], [ -81.035156, 63.035039 ] ] ] } }
] }
] }
] }

2
tests/overlap/out/-z0_--coalesce.json
View File

@ -12,7 +12,7 @@
}, "features": [
{ "type": "FeatureCollection", "properties": { "zoom": 0, "x": 0, "y": 0 }, "features": [
{ "type": "FeatureCollection", "properties": { "layer": "in", "version": 2, "extent": 4096 }, "features": [
{ "type": "Feature", "properties": { }, "geometry": { "type": "MultiPolygon", "coordinates": [ [ [ [ -103.007812, 39.027719 ], [ -71.015625, 29.075375 ], [ -37.001953, 34.016242 ], [ -15.380859, 52.908902 ], [ -10.019531, 50.007739 ], [ -5.009766, 8.059230 ], [ -17.050781, -21.943046 ], [ -75.058594, -30.977609 ], [ -118.037109, -8.928487 ], [ -135.000000, 29.075375 ], [ -113.027344, 53.014783 ], [ -111.884766, 53.383328 ], [ -103.007812, 39.027719 ] ] ], [ [ [ -117.070312, 60.020952 ], [ -113.027344, 69.005675 ], [ -93.076172, 75.004940 ], [ -74.003906, 79.004962 ], [ -33.046875, 79.004962 ], [ -3.076172, 61.015725 ], [ -15.380859, 52.908902 ], [ -28.037109, 59.040555 ], [ -81.035156, 63.035039 ], [ -111.884766, 53.383328 ], [ -117.070312, 60.020952 ] ] ] ] } }
{ "type": "Feature", "properties": { }, "geometry": { "type": "Polygon", "coordinates": [ [ [ -33.046875, 79.004962 ], [ -3.076172, 61.015725 ], [ -15.380859, 52.908902 ], [ -10.019531, 50.007739 ], [ -5.009766, 8.059230 ], [ -17.050781, -21.943046 ], [ -75.058594, -30.977609 ], [ -118.037109, -8.928487 ], [ -135.000000, 29.075375 ], [ -113.027344, 53.014783 ], [ -111.884766, 53.383328 ], [ -117.070312, 60.020952 ], [ -113.027344, 69.005675 ], [ -93.076172, 75.004940 ], [ -74.003906, 79.004962 ], [ -33.046875, 79.004962 ] ] ] } }
] }
] }
] }

70
tests/tl_2015_us_county/out/-z8.json
View File

File diff suppressed because one or more lines are too long

64
tests/tl_2015_us_county/out/-z8_-pp.json
View File

File diff suppressed because one or more lines are too long

88
tests/wyalkatchem/out/-pk_-pf_-Z9_-z12_-ldata.json
View File

@ -12,265 +12,265 @@
}, "features": [
{ "type": "FeatureCollection", "properties": { "zoom": 9, "x": 422, "y": 303 }, "features": [
{ "type": "FeatureCollection", "properties": { "layer": "data", "version": 2, "extent": 4096 }, "features": [
{ "type": "Feature", "id": 10959577660569731, "properties": { "country": "au", "text": "Wyalkatchem" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 117.274761, -31.353197 ], [ 117.274761, -31.369614 ], [ 117.278023, -31.369614 ], [ 117.273388, -31.373278 ], [ 117.273388, -31.391597 ], [ 117.270298, -31.391597 ], [ 117.270298, -31.402440 ], [ 117.279911, -31.402440 ], [ 117.280254, -31.402587 ], [ 117.280254, -31.403612 ], [ 117.290211, -31.403612 ], [ 117.290211, -31.394528 ], [ 117.298794, -31.394528 ], [ 117.298794, -31.396433 ], [ 117.318707, -31.396579 ], [ 117.323170, -31.398631 ], [ 117.324028, -31.399510 ], [ 117.325401, -31.402147 ], [ 117.331581, -31.402147 ], [ 117.331581, -31.411084 ], [ 117.338104, -31.411084 ], [ 117.338104, -31.423097 ], [ 117.335014, -31.423097 ], [ 117.335014, -31.436719 ], [ 117.368317, -31.436719 ], [ 117.368145, -31.433643 ], [ 117.397842, -31.433643 ], [ 117.397842, -31.439062 ], [ 117.421875, -31.438916 ], [ 117.435608, -31.438916 ], [ 117.435608, -31.488992 ], [ 117.421875, -31.488992 ], [ 117.397842, -31.489139 ], [ 117.388058, -31.488114 ], [ 117.379131, -31.485333 ], [ 117.377930, -31.485772 ], [ 117.368317, -31.486650 ], [ 117.335014, -31.486650 ], [ 117.325401, -31.485772 ], [ 117.315960, -31.482844 ], [ 117.307377, -31.478306 ], [ 117.299652, -31.472010 ], [ 117.293472, -31.464397 ], [ 117.288837, -31.455757 ], [ 117.288151, -31.453707 ], [ 117.280254, -31.453707 ], [ 117.259827, -31.451364 ], [ 117.250557, -31.448435 ], [ 117.241974, -31.443749 ], [ 117.234592, -31.437598 ], [ 117.228584, -31.429981 ], [ 117.223949, -31.421485 ], [ 117.221203, -31.412110 ], [ 117.220173, -31.402440 ], [ 117.220173, -31.391597 ], [ 117.221203, -31.381925 ], [ 117.223434, -31.374598 ], [ 117.224121, -31.364338 ], [ 117.224808, -31.361992 ], [ 117.224808, -31.357448 ], [ 117.223091, -31.355396 ], [ 117.222061, -31.353637 ], [ 117.218456, -31.346747 ], [ 117.216911, -31.341909 ], [ 117.280083, -31.341909 ], [ 117.280083, -31.353197 ], [ 117.274761, -31.353197 ] ] ] } }
{ "type": "Feature", "id": 10959577660569731, "properties": { "country": "au", "text": "Wyalkatchem" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 117.280083, -31.341909 ], [ 117.280083, -31.353197 ], [ 117.274761, -31.353197 ], [ 117.274761, -31.369614 ], [ 117.278023, -31.369614 ], [ 117.273388, -31.373278 ], [ 117.273388, -31.391597 ], [ 117.270298, -31.391597 ], [ 117.270298, -31.402440 ], [ 117.279911, -31.402440 ], [ 117.280254, -31.402587 ], [ 117.280254, -31.403612 ], [ 117.290211, -31.403612 ], [ 117.290211, -31.394528 ], [ 117.298794, -31.394528 ], [ 117.298794, -31.396433 ], [ 117.318707, -31.396579 ], [ 117.323170, -31.398631 ], [ 117.324028, -31.399510 ], [ 117.325401, -31.402147 ], [ 117.331581, -31.402147 ], [ 117.331581, -31.411084 ], [ 117.338104, -31.411084 ], [ 117.338104, -31.423097 ], [ 117.335014, -31.423097 ], [ 117.335014, -31.436719 ], [ 117.368317, -31.436719 ], [ 117.368145, -31.433643 ], [ 117.397842, -31.433643 ], [ 117.397842, -31.439062 ], [ 117.421875, -31.438916 ], [ 117.435608, -31.438916 ], [ 117.435608, -31.488992 ], [ 117.421875, -31.488992 ], [ 117.397842, -31.489139 ], [ 117.388058, -31.488114 ], [ 117.379131, -31.485333 ], [ 117.377930, -31.485772 ], [ 117.368317, -31.486650 ], [ 117.335014, -31.486650 ], [ 117.325401, -31.485772 ], [ 117.315960, -31.482844 ], [ 117.307377, -31.478306 ], [ 117.299652, -31.472010 ], [ 117.293472, -31.464397 ], [ 117.288837, -31.455757 ], [ 117.288151, -31.453707 ], [ 117.280254, -31.453707 ], [ 117.259827, -31.451364 ], [ 117.250557, -31.448435 ], [ 117.241974, -31.443749 ], [ 117.234592, -31.437598 ], [ 117.228584, -31.429981 ], [ 117.223949, -31.421485 ], [ 117.221203, -31.412110 ], [ 117.220173, -31.402440 ], [ 117.220173, -31.391597 ], [ 117.221203, -31.381925 ], [ 117.223434, -31.374598 ], [ 117.224121, -31.364338 ], [ 117.224808, -31.361992 ], [ 117.224808, -31.357448 ], [ 117.223091, -31.355396 ], [ 117.222061, -31.353637 ], [ 117.218456, -31.346747 ], [ 117.216911, -31.341909 ], [ 117.280083, -31.341909 ] ] ] } }
] }
] }
,
{ "type": "FeatureCollection", "properties": { "zoom": 9, "x": 422, "y": 302 }, "features": [
{ "type": "FeatureCollection", "properties": { "layer": "data", "version": 2, "extent": 4096 }, "features": [
{ "type": "Feature", "id": 10959577660569731, "properties": { "country": "au", "text": "Wyalkatchem" }, "geometry": { "type": "MultiPolygon", "coordinates": [ [ [ [ 117.378616, -31.102775 ], [ 117.376556, -31.103803 ], [ 117.362309, -31.103803 ], [ 117.359734, -31.102922 ], [ 117.346516, -31.102922 ], [ 117.346344, -31.112475 ], [ 117.327976, -31.112475 ], [ 117.327976, -31.142452 ], [ 117.324543, -31.142452 ], [ 117.324543, -31.152589 ], [ 117.326088, -31.152589 ], [ 117.326088, -31.162431 ], [ 117.323856, -31.162137 ], [ 117.294674, -31.165663 ], [ 117.294502, -31.252433 ], [ 117.301025, -31.252433 ], [ 117.301025, -31.269014 ], [ 117.299995, -31.270628 ], [ 117.298794, -31.271802 ], [ 117.297935, -31.273563 ], [ 117.297935, -31.276497 ], [ 117.278194, -31.276350 ], [ 117.274418, -31.275176 ], [ 117.253132, -31.275323 ], [ 117.253132, -31.282365 ], [ 117.253990, -31.282365 ], [ 117.254162, -31.287940 ], [ 117.262573, -31.287940 ], [ 117.262573, -31.295274 ], [ 117.260170, -31.295274 ], [ 117.260170, -31.303782 ], [ 117.258968, -31.303782 ], [ 117.258968, -31.311408 ], [ 117.264633, -31.311408 ], [ 117.264633, -31.327686 ], [ 117.280083, -31.327686 ], [ 117.280083, -31.353197 ], [ 117.274761, -31.353197 ], [ 117.274761, -31.365364 ], [ 117.224121, -31.365364 ], [ 117.224808, -31.361992 ], [ 117.224808, -31.357448 ], [ 117.223091, -31.355396 ], [ 117.222061, -31.353637 ], [ 117.218456, -31.346747 ], [ 117.215710, -31.337364 ], [ 117.215366, -31.335311 ], [ 117.212791, -31.330472 ], [ 117.210045, -31.321087 ], [ 117.209015, -31.309355 ], [ 117.207813, -31.307155 ], [ 117.205067, -31.297768 ], [ 117.204723, -31.294394 ], [ 117.204037, -31.292047 ], [ 117.203007, -31.282365 ], [ 117.203007, -31.275323 ], [ 117.204037, -31.265493 ], [ 117.206783, -31.256101 ], [ 117.211418, -31.247443 ], [ 117.217770, -31.239958 ], [ 117.225323, -31.233647 ], [ 117.233906, -31.229096 ], [ 117.243347, -31.226307 ], [ 117.244549, -31.226161 ], [ 117.244549, -31.165663 ], [ 117.245579, -31.156115 ], [ 117.248325, -31.146859 ], [ 117.252789, -31.138338 ], [ 117.258797, -31.130697 ], [ 117.266178, -31.124526 ], [ 117.274590, -31.119823 ], [ 117.278023, -31.118794 ], [ 117.278023, -31.112034 ], [ 117.279053, -31.102334 ], [ 117.281971, -31.093073 ], [ 117.286606, -31.084547 ], [ 117.292786, -31.076902 ], [ 117.300339, -31.070727 ], [ 117.308922, -31.066169 ], [ 117.315102, -31.064404 ], [ 117.317848, -31.062051 ], [ 117.326431, -31.057199 ], [ 117.336216, -31.054110 ], [ 117.346859, -31.052934 ], [ 117.359734, -31.052934 ], [ 117.369862, -31.053816 ], [ 117.378616, -31.052640 ], [ 117.435608, -31.052640 ], [ 117.435608, -31.102628 ], [ 117.421875, -31.102628 ], [ 117.378616, -31.102775 ] ] ], [ [ [ 117.426510, -31.200175 ], [ 117.428570, -31.200175 ], [ 117.428570, -31.195329 ], [ 117.435608, -31.195329 ], [ 117.435608, -31.209278 ], [ 117.426510, -31.209425 ], [ 117.426510, -31.200175 ] ] ], [ [ [ 117.435608, -31.119823 ], [ 117.435608, -31.183728 ], [ 117.435265, -31.183728 ], [ 117.435608, -31.119823 ] ] ] ] } }
{ "type": "Feature", "id": 10959577660569731, "properties": { "country": "au", "text": "Wyalkatchem" }, "geometry": { "type": "MultiPolygon", "coordinates": [ [ [ [ 117.435608, -31.102628 ], [ 117.421875, -31.102628 ], [ 117.378616, -31.102775 ], [ 117.376556, -31.103803 ], [ 117.362309, -31.103803 ], [ 117.359734, -31.102922 ], [ 117.346516, -31.102922 ], [ 117.346344, -31.112475 ], [ 117.327976, -31.112475 ], [ 117.327976, -31.142452 ], [ 117.324543, -31.142452 ], [ 117.324543, -31.152589 ], [ 117.326088, -31.152589 ], [ 117.326088, -31.162431 ], [ 117.323856, -31.162137 ], [ 117.294674, -31.165663 ], [ 117.294502, -31.252433 ], [ 117.301025, -31.252433 ], [ 117.301025, -31.269014 ], [ 117.299995, -31.270628 ], [ 117.298794, -31.271802 ], [ 117.297935, -31.273563 ], [ 117.297935, -31.276497 ], [ 117.278194, -31.276350 ], [ 117.274418, -31.275176 ], [ 117.253132, -31.275323 ], [ 117.253132, -31.282365 ], [ 117.253990, -31.282365 ], [ 117.254162, -31.287940 ], [ 117.262573, -31.287940 ], [ 117.262573, -31.295274 ], [ 117.260170, -31.295274 ], [ 117.260170, -31.303782 ], [ 117.258968, -31.303782 ], [ 117.258968, -31.311408 ], [ 117.264633, -31.311408 ], [ 117.264633, -31.327686 ], [ 117.280083, -31.327686 ], [ 117.280083, -31.353197 ], [ 117.274761, -31.353197 ], [ 117.274761, -31.365364 ], [ 117.224121, -31.365364 ], [ 117.224808, -31.361992 ], [ 117.224808, -31.357448 ], [ 117.223091, -31.355396 ], [ 117.222061, -31.353637 ], [ 117.218456, -31.346747 ], [ 117.215710, -31.337364 ], [ 117.215366, -31.335311 ], [ 117.212791, -31.330472 ], [ 117.210045, -31.321087 ], [ 117.209015, -31.309355 ], [ 117.207813, -31.307155 ], [ 117.205067, -31.297768 ], [ 117.204723, -31.294394 ], [ 117.204037, -31.292047 ], [ 117.203007, -31.282365 ], [ 117.203007, -31.275323 ], [ 117.204037, -31.265493 ], [ 117.206783, -31.256101 ], [ 117.211418, -31.247443 ], [ 117.217770, -31.239958 ], [ 117.225323, -31.233647 ], [ 117.233906, -31.229096 ], [ 117.243347, -31.226307 ], [ 117.244549, -31.226161 ], [ 117.244549, -31.165663 ], [ 117.245579, -31.156115 ], [ 117.248325, -31.146859 ], [ 117.252789, -31.138338 ], [ 117.258797, -31.130697 ], [ 117.266178, -31.124526 ], [ 117.274590, -31.119823 ], [ 117.278023, -31.118794 ], [ 117.278023, -31.112034 ], [ 117.279053, -31.102334 ], [ 117.281971, -31.093073 ], [ 117.286606, -31.084547 ], [ 117.292786, -31.076902 ], [ 117.300339, -31.070727 ], [ 117.308922, -31.066169 ], [ 117.315102, -31.064404 ], [ 117.317848, -31.062051 ], [ 117.326431, -31.057199 ], [ 117.336216, -31.054110 ], [ 117.346859, -31.052934 ], [ 117.359734, -31.052934 ], [ 117.369862, -31.053816 ], [ 117.378616, -31.052640 ], [ 117.435608, -31.052640 ], [ 117.435608, -31.102628 ] ] ], [ [ [ 117.435608, -31.195329 ], [ 117.435608, -31.209278 ], [ 117.426510, -31.209425 ], [ 117.426510, -31.200175 ], [ 117.428570, -31.200175 ], [ 117.428570, -31.195329 ], [ 117.435608, -31.195329 ] ] ], [ [ [ 117.435608, -31.102628 ], [ 117.435608, -31.183728 ], [ 117.435265, -31.183728 ], [ 117.435608, -31.102628 ] ] ] ] } }
] }
] }
,
{ "type": "FeatureCollection", "properties": { "zoom": 9, "x": 423, "y": 303 }, "features": [
{ "type": "FeatureCollection", "properties": { "layer": "data", "version": 2, "extent": 4096 }, "features": [
{ "type": "Feature", "id": 10959577660569731, "properties": { "country": "au", "text": "Wyalkatchem" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 117.435780, -31.438916 ], [ 117.435780, -31.353637 ], [ 117.436123, -31.351145 ], [ 117.436123, -31.341909 ], [ 117.492085, -31.341909 ], [ 117.491226, -31.344841 ], [ 117.486591, -31.353637 ], [ 117.485905, -31.354370 ], [ 117.485561, -31.357448 ], [ 117.485733, -31.438916 ], [ 117.484703, -31.448728 ], [ 117.481956, -31.458100 ], [ 117.477322, -31.466739 ], [ 117.470970, -31.474353 ], [ 117.463417, -31.480648 ], [ 117.454834, -31.485186 ], [ 117.445393, -31.488114 ], [ 117.435608, -31.488992 ], [ 117.411232, -31.488992 ], [ 117.408142, -31.489139 ], [ 117.408142, -31.439062 ], [ 117.421875, -31.438916 ], [ 117.435780, -31.438916 ] ] ] } }
{ "type": "Feature", "id": 10959577660569731, "properties": { "country": "au", "text": "Wyalkatchem" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 117.492085, -31.341909 ], [ 117.491226, -31.344841 ], [ 117.486591, -31.353637 ], [ 117.485905, -31.354370 ], [ 117.485561, -31.357448 ], [ 117.485733, -31.438916 ], [ 117.484703, -31.448728 ], [ 117.481956, -31.458100 ], [ 117.477322, -31.466739 ], [ 117.470970, -31.474353 ], [ 117.463417, -31.480648 ], [ 117.454834, -31.485186 ], [ 117.445393, -31.488114 ], [ 117.435608, -31.488992 ], [ 117.411232, -31.488992 ], [ 117.408142, -31.489139 ], [ 117.408142, -31.439062 ], [ 117.421875, -31.438916 ], [ 117.435780, -31.438916 ], [ 117.435780, -31.353637 ], [ 117.436123, -31.351145 ], [ 117.436123, -31.341909 ], [ 117.492085, -31.341909 ] ] ] } }
] }
] }
,
{ "type": "FeatureCollection", "properties": { "zoom": 9, "x": 423, "y": 302 }, "features": [
{ "type": "FeatureCollection", "properties": { "layer": "data", "version": 2, "extent": 4096 }, "features": [
{ "type": "Feature", "id": 10959577660569731, "properties": { "country": "au", "text": "Wyalkatchem" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 117.436123, -31.351145 ], [ 117.436123, -31.325633 ], [ 117.445049, -31.325780 ], [ 117.445049, -31.304662 ], [ 117.447624, -31.299675 ], [ 117.447624, -31.266520 ], [ 117.448311, -31.265786 ], [ 117.448311, -31.204433 ], [ 117.446766, -31.205167 ], [ 117.444191, -31.208103 ], [ 117.441788, -31.209131 ], [ 117.426510, -31.209425 ], [ 117.426510, -31.200175 ], [ 117.428570, -31.200175 ], [ 117.428570, -31.195329 ], [ 117.441273, -31.195329 ], [ 117.441273, -31.190924 ], [ 117.443333, -31.190924 ], [ 117.443333, -31.183728 ], [ 117.435265, -31.183728 ], [ 117.435265, -31.170216 ], [ 117.441444, -31.170069 ], [ 117.445736, -31.169629 ], [ 117.445564, -31.102628 ], [ 117.408142, -31.102628 ], [ 117.408142, -31.052640 ], [ 117.445564, -31.052640 ], [ 117.455349, -31.053669 ], [ 117.464619, -31.056463 ], [ 117.473373, -31.061022 ], [ 117.480927, -31.067345 ], [ 117.487106, -31.074844 ], [ 117.491741, -31.083518 ], [ 117.494659, -31.092926 ], [ 117.495518, -31.102628 ], [ 117.495689, -31.169482 ], [ 117.494659, -31.179763 ], [ 117.493458, -31.183434 ], [ 117.494659, -31.185637 ], [ 117.497406, -31.194889 ], [ 117.498264, -31.204433 ], [ 117.498436, -31.265786 ], [ 117.497578, -31.272976 ], [ 117.497578, -31.299675 ], [ 117.496204, -31.311262 ], [ 117.495003, -31.314488 ], [ 117.495003, -31.325780 ], [ 117.494144, -31.335458 ], [ 117.491226, -31.344841 ], [ 117.486591, -31.353637 ], [ 117.485905, -31.354370 ], [ 117.485561, -31.357448 ], [ 117.485561, -31.365364 ], [ 117.435608, -31.365364 ], [ 117.435780, -31.353637 ], [ 117.436123, -31.351145 ] ] ] } }
{ "type": "Feature", "id": 10959577660569731, "properties": { "country": "au", "text": "Wyalkatchem" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 117.445564, -31.052640 ], [ 117.455349, -31.053669 ], [ 117.464619, -31.056463 ], [ 117.473373, -31.061022 ], [ 117.480927, -31.067345 ], [ 117.487106, -31.074844 ], [ 117.491741, -31.083518 ], [ 117.494659, -31.092926 ], [ 117.495518, -31.102628 ], [ 117.495689, -31.169482 ], [ 117.494659, -31.179763 ], [ 117.493458, -31.183434 ], [ 117.494659, -31.185637 ], [ 117.497406, -31.194889 ], [ 117.498264, -31.204433 ], [ 117.498436, -31.265786 ], [ 117.497578, -31.272976 ], [ 117.497578, -31.299675 ], [ 117.496204, -31.311262 ], [ 117.495003, -31.314488 ], [ 117.495003, -31.325780 ], [ 117.494144, -31.335458 ], [ 117.491226, -31.344841 ], [ 117.486591, -31.353637 ], [ 117.485905, -31.354370 ], [ 117.485561, -31.357448 ], [ 117.485561, -31.365364 ], [ 117.448311, -31.215004 ], [ 117.448311, -31.204433 ], [ 117.446766, -31.205167 ], [ 117.446079, -31.205901 ], [ 117.442303, -31.190924 ], [ 117.443333, -31.190924 ], [ 117.443333, -31.183728 ], [ 117.440586, -31.183728 ], [ 117.437153, -31.170216 ], [ 117.441444, -31.170069 ], [ 117.445736, -31.169629 ], [ 117.445564, -31.102628 ], [ 117.420502, -31.102628 ], [ 117.408142, -31.052640 ], [ 117.445564, -31.052640 ] ] ] } }
] }
] }
,
{ "type": "FeatureCollection", "properties": { "zoom": 10, "x": 845, "y": 606 }, "features": [
{ "type": "FeatureCollection", "properties": { "layer": "data", "version": 2, "extent": 4096 }, "features": [
{ "type": "Feature", "id": 10959577660569731, "properties": { "country": "au", "text": "Wyalkatchem" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 117.274847, -31.353270 ], [ 117.274847, -31.369614 ], [ 117.278023, -31.369614 ], [ 117.273388, -31.373352 ], [ 117.273388, -31.391597 ], [ 117.270298, -31.391597 ], [ 117.270298, -31.402513 ], [ 117.279911, -31.402513 ], [ 117.280254, -31.402660 ], [ 117.280254, -31.403685 ], [ 117.290297, -31.403685 ], [ 117.290297, -31.394601 ], [ 117.298794, -31.394601 ], [ 117.298794, -31.396433 ], [ 117.309351, -31.396359 ], [ 117.309351, -31.396579 ], [ 117.318707, -31.396579 ], [ 117.321968, -31.397971 ], [ 117.323170, -31.398631 ], [ 117.324028, -31.399583 ], [ 117.325058, -31.401634 ], [ 117.325401, -31.402147 ], [ 117.331667, -31.402147 ], [ 117.331667, -31.411157 ], [ 117.338190, -31.411157 ], [ 117.338190, -31.423097 ], [ 117.335100, -31.423097 ], [ 117.335100, -31.436719 ], [ 117.368317, -31.436719 ], [ 117.368231, -31.433716 ], [ 117.397928, -31.433716 ], [ 117.397928, -31.439136 ], [ 117.409687, -31.439136 ], [ 117.409945, -31.438989 ], [ 117.428741, -31.438989 ], [ 117.428741, -31.488992 ], [ 117.411232, -31.488992 ], [ 117.409601, -31.489139 ], [ 117.397842, -31.489139 ], [ 117.388144, -31.488114 ], [ 117.379131, -31.485406 ], [ 117.378016, -31.485772 ], [ 117.368317, -31.486723 ], [ 117.335100, -31.486723 ], [ 117.325401, -31.485772 ], [ 117.315960, -31.482917 ], [ 117.307377, -31.478306 ], [ 117.299738, -31.472083 ], [ 117.293558, -31.464470 ], [ 117.288923, -31.455831 ], [ 117.288237, -31.453707 ], [ 117.280254, -31.453707 ], [ 117.270555, -31.452755 ], [ 117.269783, -31.452536 ], [ 117.259827, -31.451438 ], [ 117.250643, -31.448509 ], [ 117.242060, -31.443822 ], [ 117.234678, -31.437598 ], [ 117.228584, -31.430055 ], [ 117.224035, -31.421485 ], [ 117.221203, -31.412183 ], [ 117.220259, -31.402513 ], [ 117.220259, -31.391670 ], [ 117.221203, -31.381925 ], [ 117.223434, -31.374598 ], [ 117.223434, -31.373352 ], [ 117.224207, -31.364411 ], [ 117.224894, -31.362066 ], [ 117.224894, -31.357522 ], [ 117.223091, -31.355396 ], [ 117.222147, -31.353637 ], [ 117.219057, -31.347773 ], [ 117.280169, -31.347773 ], [ 117.280169, -31.353270 ], [ 117.274847, -31.353270 ] ] ] } }
{ "type": "Feature", "id": 10959577660569731, "properties": { "country": "au", "text": "Wyalkatchem" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 117.280169, -31.347773 ], [ 117.280169, -31.353270 ], [ 117.274847, -31.353270 ], [ 117.274847, -31.369614 ], [ 117.278023, -31.369614 ], [ 117.273388, -31.373352 ], [ 117.273388, -31.391597 ], [ 117.270298, -31.391597 ], [ 117.270298, -31.402513 ], [ 117.279911, -31.402513 ], [ 117.280254, -31.402660 ], [ 117.280254, -31.403685 ], [ 117.290297, -31.403685 ], [ 117.290297, -31.394601 ], [ 117.298794, -31.394601 ], [ 117.298794, -31.396433 ], [ 117.309351, -31.396359 ], [ 117.309351, -31.396579 ], [ 117.318707, -31.396579 ], [ 117.321968, -31.397971 ], [ 117.323170, -31.398631 ], [ 117.324028, -31.399583 ], [ 117.325058, -31.401634 ], [ 117.325401, -31.402147 ], [ 117.331667, -31.402147 ], [ 117.331667, -31.411157 ], [ 117.338190, -31.411157 ], [ 117.338190, -31.423097 ], [ 117.335100, -31.423097 ], [ 117.335100, -31.436719 ], [ 117.368317, -31.436719 ], [ 117.368231, -31.433716 ], [ 117.397928, -31.433716 ], [ 117.397928, -31.439136 ], [ 117.409687, -31.439136 ], [ 117.409945, -31.438989 ], [ 117.428741, -31.438989 ], [ 117.428741, -31.488992 ], [ 117.411232, -31.488992 ], [ 117.409601, -31.489139 ], [ 117.397842, -31.489139 ], [ 117.388144, -31.488114 ], [ 117.379131, -31.485406 ], [ 117.378016, -31.485772 ], [ 117.368317, -31.486723 ], [ 117.335100, -31.486723 ], [ 117.325401, -31.485772 ], [ 117.315960, -31.482917 ], [ 117.307377, -31.478306 ], [ 117.299738, -31.472083 ], [ 117.293558, -31.464470 ], [ 117.288923, -31.455831 ], [ 117.288237, -31.453707 ], [ 117.280254, -31.453707 ], [ 117.270555, -31.452755 ], [ 117.269783, -31.452536 ], [ 117.259827, -31.451438 ], [ 117.250643, -31.448509 ], [ 117.242060, -31.443822 ], [ 117.234678, -31.437598 ], [ 117.228584, -31.430055 ], [ 117.224035, -31.421485 ], [ 117.221203, -31.412183 ], [ 117.220259, -31.402513 ], [ 117.220259, -31.391670 ], [ 117.221203, -31.381925 ], [ 117.223434, -31.374598 ], [ 117.223434, -31.373352 ], [ 117.224207, -31.364411 ], [ 117.224894, -31.362066 ], [ 117.224894, -31.357522 ], [ 117.223091, -31.355396 ], [ 117.222147, -31.353637 ], [ 117.219057, -31.347773 ], [ 117.280169, -31.347773 ] ] ] } }
] }
] }
,
{ "type": "FeatureCollection", "properties": { "zoom": 10, "x": 845, "y": 605 }, "features": [
{ "type": "FeatureCollection", "properties": { "layer": "data", "version": 2, "extent": 4096 }, "features": [
{ "type": "Feature", "id": 10959577660569731, "properties": { "country": "au", "text": "Wyalkatchem" }, "geometry": { "type": "MultiPolygon", "coordinates": [ [ [ [ 117.378702, -31.102775 ], [ 117.376642, -31.103803 ], [ 117.362309, -31.103803 ], [ 117.359819, -31.102922 ], [ 117.346945, -31.102922 ], [ 117.346516, -31.102995 ], [ 117.346430, -31.103656 ], [ 117.346430, -31.112475 ], [ 117.328062, -31.112475 ], [ 117.327976, -31.142452 ], [ 117.324543, -31.142452 ], [ 117.324543, -31.152662 ], [ 117.326174, -31.152662 ], [ 117.326174, -31.162505 ], [ 117.323856, -31.162211 ], [ 117.295618, -31.165516 ], [ 117.294674, -31.165736 ], [ 117.294588, -31.252433 ], [ 117.301025, -31.252506 ], [ 117.301025, -31.269014 ], [ 117.300081, -31.270628 ], [ 117.298880, -31.271875 ], [ 117.297935, -31.273563 ], [ 117.297935, -31.276570 ], [ 117.278194, -31.276424 ], [ 117.274504, -31.275250 ], [ 117.253132, -31.275323 ], [ 117.253132, -31.282365 ], [ 117.254076, -31.282365 ], [ 117.254162, -31.288013 ], [ 117.262573, -31.288013 ], [ 117.262573, -31.295274 ], [ 117.260170, -31.295274 ], [ 117.260170, -31.303855 ], [ 117.259054, -31.303855 ], [ 117.259054, -31.311408 ], [ 117.264719, -31.311408 ], [ 117.264719, -31.327686 ], [ 117.280169, -31.327686 ], [ 117.280169, -31.353270 ], [ 117.274847, -31.353270 ], [ 117.274847, -31.359501 ], [ 117.224894, -31.359501 ], [ 117.224894, -31.357522 ], [ 117.223091, -31.355396 ], [ 117.222147, -31.353637 ], [ 117.218542, -31.346747 ], [ 117.215710, -31.337437 ], [ 117.215452, -31.335384 ], [ 117.212877, -31.330546 ], [ 117.210045, -31.321161 ], [ 117.209101, -31.311408 ], [ 117.209101, -31.309355 ], [ 117.207899, -31.307228 ], [ 117.205067, -31.297841 ], [ 117.204723, -31.294394 ], [ 117.204037, -31.292121 ], [ 117.203093, -31.282365 ], [ 117.203093, -31.275323 ], [ 117.204037, -31.265566 ], [ 117.206869, -31.256175 ], [ 117.211504, -31.247516 ], [ 117.217770, -31.239958 ], [ 117.225323, -31.233720 ], [ 117.233992, -31.229096 ], [ 117.243347, -31.226307 ], [ 117.244549, -31.226161 ], [ 117.244635, -31.165663 ], [ 117.245579, -31.156115 ], [ 117.248325, -31.146859 ], [ 117.252874, -31.138338 ], [ 117.258883, -31.130771 ], [ 117.266264, -31.124599 ], [ 117.274675, -31.119897 ], [ 117.278023, -31.118794 ], [ 117.278023, -31.112108 ], [ 117.279053, -31.102407 ], [ 117.281971, -31.093073 ], [ 117.286606, -31.084547 ], [ 117.292786, -31.076975 ], [ 117.300425, -31.070800 ], [ 117.309008, -31.066242 ], [ 117.315102, -31.064404 ], [ 117.317848, -31.062051 ], [ 117.326431, -31.057199 ], [ 117.336302, -31.054110 ], [ 117.346945, -31.052934 ], [ 117.359819, -31.052934 ], [ 117.369862, -31.053816 ], [ 117.377329, -31.052934 ], [ 117.378702, -31.052713 ], [ 117.428741, -31.052713 ], [ 117.428741, -31.102701 ], [ 117.421875, -31.102701 ], [ 117.378702, -31.102775 ] ] ], [ [ [ 117.426510, -31.200248 ], [ 117.428656, -31.200248 ], [ 117.428741, -31.146859 ], [ 117.428741, -31.209425 ], [ 117.426510, -31.209498 ], [ 117.426510, -31.200248 ] ] ] ] } }
{ "type": "Feature", "id": 10959577660569731, "properties": { "country": "au", "text": "Wyalkatchem" }, "geometry": { "type": "MultiPolygon", "coordinates": [ [ [ [ 117.428741, -31.102701 ], [ 117.421875, -31.102701 ], [ 117.378702, -31.102775 ], [ 117.376642, -31.103803 ], [ 117.362309, -31.103803 ], [ 117.359819, -31.102922 ], [ 117.346945, -31.102922 ], [ 117.346516, -31.102995 ], [ 117.346430, -31.103656 ], [ 117.346430, -31.112475 ], [ 117.328062, -31.112475 ], [ 117.327976, -31.142452 ], [ 117.324543, -31.142452 ], [ 117.324543, -31.152662 ], [ 117.326174, -31.152662 ], [ 117.326174, -31.162505 ], [ 117.323856, -31.162211 ], [ 117.295618, -31.165516 ], [ 117.294674, -31.165736 ], [ 117.294588, -31.252433 ], [ 117.301025, -31.252506 ], [ 117.301025, -31.269014 ], [ 117.300081, -31.270628 ], [ 117.298880, -31.271875 ], [ 117.297935, -31.273563 ], [ 117.297935, -31.276570 ], [ 117.278194, -31.276424 ], [ 117.274504, -31.275250 ], [ 117.253132, -31.275323 ], [ 117.253132, -31.282365 ], [ 117.254076, -31.282365 ], [ 117.254162, -31.288013 ], [ 117.262573, -31.288013 ], [ 117.262573, -31.295274 ], [ 117.260170, -31.295274 ], [ 117.260170, -31.303855 ], [ 117.259054, -31.303855 ], [ 117.259054, -31.311408 ], [ 117.264719, -31.311408 ], [ 117.264719, -31.327686 ], [ 117.280169, -31.327686 ], [ 117.280169, -31.353270 ], [ 117.274847, -31.353270 ], [ 117.274847, -31.359501 ], [ 117.224894, -31.359501 ], [ 117.224894, -31.357522 ], [ 117.223091, -31.355396 ], [ 117.222147, -31.353637 ], [ 117.218542, -31.346747 ], [ 117.215710, -31.337437 ], [ 117.215452, -31.335384 ], [ 117.212877, -31.330546 ], [ 117.210045, -31.321161 ], [ 117.209101, -31.311408 ], [ 117.209101, -31.309355 ], [ 117.207899, -31.307228 ], [ 117.205067, -31.297841 ], [ 117.204723, -31.294394 ], [ 117.204037, -31.292121 ], [ 117.203093, -31.282365 ], [ 117.203093, -31.275323 ], [ 117.204037, -31.265566 ], [ 117.206869, -31.256175 ], [ 117.211504, -31.247516 ], [ 117.217770, -31.239958 ], [ 117.225323, -31.233720 ], [ 117.233992, -31.229096 ], [ 117.243347, -31.226307 ], [ 117.244549, -31.226161 ], [ 117.244635, -31.165663 ], [ 117.245579, -31.156115 ], [ 117.248325, -31.146859 ], [ 117.252874, -31.138338 ], [ 117.258883, -31.130771 ], [ 117.266264, -31.124599 ], [ 117.274675, -31.119897 ], [ 117.278023, -31.118794 ], [ 117.278023, -31.112108 ], [ 117.279053, -31.102407 ], [ 117.281971, -31.093073 ], [ 117.286606, -31.084547 ], [ 117.292786, -31.076975 ], [ 117.300425, -31.070800 ], [ 117.309008, -31.066242 ], [ 117.315102, -31.064404 ], [ 117.317848, -31.062051 ], [ 117.326431, -31.057199 ], [ 117.336302, -31.054110 ], [ 117.346945, -31.052934 ], [ 117.359819, -31.052934 ], [ 117.369862, -31.053816 ], [ 117.377329, -31.052934 ], [ 117.378702, -31.052713 ], [ 117.428741, -31.052713 ], [ 117.428741, -31.102701 ] ] ], [ [ [ 117.428741, -31.102701 ], [ 117.428741, -31.209425 ], [ 117.426510, -31.209498 ], [ 117.426510, -31.200248 ], [ 117.428656, -31.200248 ], [ 117.428741, -31.102701 ] ] ] ] } }
] }
] }
,
{ "type": "FeatureCollection", "properties": { "zoom": 10, "x": 845, "y": 604 }, "features": [
{ "type": "FeatureCollection", "properties": { "layer": "data", "version": 2, "extent": 4096 }, "features": [
{ "type": "Feature", "id": 10959577660569731, "properties": { "country": "au", "text": "Wyalkatchem" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 117.428741, -31.058816 ], [ 117.323599, -31.058816 ], [ 117.326431, -31.057199 ], [ 117.336302, -31.054110 ], [ 117.346945, -31.052934 ], [ 117.359819, -31.052934 ], [ 117.369862, -31.053816 ], [ 117.377329, -31.052934 ], [ 117.378702, -31.052713 ], [ 117.428741, -31.052713 ], [ 117.428741, -31.058816 ] ] ] } }
{ "type": "Feature", "id": 10959577660569731, "properties": { "country": "au", "text": "Wyalkatchem" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 117.428741, -31.052713 ], [ 117.428741, -31.058816 ], [ 117.323599, -31.058816 ], [ 117.326431, -31.057199 ], [ 117.336302, -31.054110 ], [ 117.346945, -31.052934 ], [ 117.359819, -31.052934 ], [ 117.369862, -31.053816 ], [ 117.377329, -31.052934 ], [ 117.378702, -31.052713 ], [ 117.428741, -31.052713 ] ] ] } }
] }
] }
,
{ "type": "FeatureCollection", "properties": { "zoom": 10, "x": 846, "y": 606 }, "features": [
{ "type": "FeatureCollection", "properties": { "layer": "data", "version": 2, "extent": 4096 }, "features": [
{ "type": "Feature", "id": 10959577660569731, "properties": { "country": "au", "text": "Wyalkatchem" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 117.435780, -31.407934 ], [ 117.435608, -31.407934 ], [ 117.435694, -31.354223 ], [ 117.435780, -31.353637 ], [ 117.436209, -31.351218 ], [ 117.436209, -31.347773 ], [ 117.489767, -31.347773 ], [ 117.486591, -31.353637 ], [ 117.485905, -31.354443 ], [ 117.485647, -31.357448 ], [ 117.485733, -31.438989 ], [ 117.484789, -31.448802 ], [ 117.481956, -31.458174 ], [ 117.477322, -31.466813 ], [ 117.471056, -31.474426 ], [ 117.463503, -31.480648 ], [ 117.454834, -31.485259 ], [ 117.445393, -31.488114 ], [ 117.435608, -31.488992 ], [ 117.415009, -31.488992 ], [ 117.415009, -31.438989 ], [ 117.435780, -31.438989 ], [ 117.435780, -31.407934 ] ] ] } }
{ "type": "Feature", "id": 10959577660569731, "properties": { "country": "au", "text": "Wyalkatchem" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 117.489767, -31.347773 ], [ 117.486591, -31.353637 ], [ 117.485905, -31.354443 ], [ 117.485647, -31.357448 ], [ 117.485733, -31.438989 ], [ 117.484789, -31.448802 ], [ 117.481956, -31.458174 ], [ 117.477322, -31.466813 ], [ 117.471056, -31.474426 ], [ 117.463503, -31.480648 ], [ 117.454834, -31.485259 ], [ 117.445393, -31.488114 ], [ 117.435608, -31.488992 ], [ 117.415009, -31.488992 ], [ 117.415009, -31.438989 ], [ 117.435780, -31.438989 ], [ 117.435780, -31.407934 ], [ 117.435608, -31.407934 ], [ 117.435694, -31.354223 ], [ 117.435780, -31.353637 ], [ 117.436209, -31.351218 ], [ 117.436209, -31.347773 ], [ 117.489767, -31.347773 ] ] ] } }
] }
] }
,
{ "type": "FeatureCollection", "properties": { "zoom": 10, "x": 846, "y": 605 }, "features": [
{ "type": "FeatureCollection", "properties": { "layer": "data", "version": 2, "extent": 4096 }, "features": [
{ "type": "Feature", "id": 10959577660569731, "properties": { "country": "au", "text": "Wyalkatchem" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 117.435780, -31.353637 ], [ 117.436209, -31.351218 ], [ 117.436123, -31.325707 ], [ 117.445135, -31.325780 ], [ 117.445135, -31.304662 ], [ 117.447710, -31.299675 ], [ 117.447710, -31.266520 ], [ 117.448397, -31.265786 ], [ 117.448397, -31.204506 ], [ 117.447624, -31.204800 ], [ 117.446766, -31.205240 ], [ 117.446079, -31.205901 ], [ 117.445049, -31.207296 ], [ 117.444191, -31.208103 ], [ 117.443075, -31.208764 ], [ 117.441874, -31.209204 ], [ 117.440672, -31.209278 ], [ 117.426510, -31.209498 ], [ 117.426510, -31.200248 ], [ 117.428656, -31.200248 ], [ 117.428656, -31.195403 ], [ 117.441273, -31.195403 ], [ 117.441273, -31.190997 ], [ 117.443419, -31.190997 ], [ 117.443419, -31.183728 ], [ 117.435350, -31.183728 ], [ 117.435350, -31.170290 ], [ 117.441444, -31.170143 ], [ 117.445736, -31.169629 ], [ 117.445650, -31.102701 ], [ 117.415009, -31.102701 ], [ 117.415009, -31.052713 ], [ 117.445650, -31.052713 ], [ 117.447710, -31.052934 ], [ 117.455349, -31.053669 ], [ 117.464705, -31.056463 ], [ 117.473373, -31.061096 ], [ 117.480927, -31.067345 ], [ 117.487192, -31.074917 ], [ 117.491827, -31.083518 ], [ 117.494659, -31.092926 ], [ 117.495604, -31.102628 ], [ 117.495775, -31.169555 ], [ 117.494659, -31.179836 ], [ 117.493544, -31.183434 ], [ 117.494659, -31.185711 ], [ 117.497406, -31.194889 ], [ 117.498350, -31.204433 ], [ 117.498436, -31.265786 ], [ 117.497663, -31.273049 ], [ 117.497663, -31.299748 ], [ 117.496290, -31.311335 ], [ 117.495089, -31.314488 ], [ 117.495089, -31.325780 ], [ 117.494144, -31.335531 ], [ 117.491312, -31.344914 ], [ 117.486591, -31.353637 ], [ 117.485905, -31.354443 ], [ 117.485647, -31.357448 ], [ 117.485647, -31.359501 ], [ 117.435608, -31.359501 ], [ 117.435694, -31.354223 ], [ 117.435780, -31.353637 ] ] ] } }
{ "type": "Feature", "id": 10959577660569731, "properties": { "country": "au", "text": "Wyalkatchem" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 117.445650, -31.052713 ], [ 117.447710, -31.052934 ], [ 117.455349, -31.053669 ], [ 117.464705, -31.056463 ], [ 117.473373, -31.061096 ], [ 117.480927, -31.067345 ], [ 117.487192, -31.074917 ], [ 117.491827, -31.083518 ], [ 117.494659, -31.092926 ], [ 117.495604, -31.102628 ], [ 117.495775, -31.169555 ], [ 117.494659, -31.179836 ], [ 117.493544, -31.183434 ], [ 117.494659, -31.185711 ], [ 117.497406, -31.194889 ], [ 117.498350, -31.204433 ], [ 117.498436, -31.265786 ], [ 117.497663, -31.273049 ], [ 117.497663, -31.299748 ], [ 117.496290, -31.311335 ], [ 117.495089, -31.314488 ], [ 117.495089, -31.325780 ], [ 117.494144, -31.335531 ], [ 117.491312, -31.344914 ], [ 117.486591, -31.353637 ], [ 117.485905, -31.354443 ], [ 117.485647, -31.357448 ], [ 117.485647, -31.359501 ], [ 117.435608, -31.359501 ], [ 117.435694, -31.354223 ], [ 117.435780, -31.353637 ], [ 117.436209, -31.351218 ], [ 117.436123, -31.325707 ], [ 117.445135, -31.325780 ], [ 117.445135, -31.304662 ], [ 117.447710, -31.299675 ], [ 117.447710, -31.266520 ], [ 117.448397, -31.265786 ], [ 117.448397, -31.204506 ], [ 117.447624, -31.204800 ], [ 117.446766, -31.205240 ], [ 117.446079, -31.205901 ], [ 117.445049, -31.207296 ], [ 117.444191, -31.208103 ], [ 117.443075, -31.208764 ], [ 117.441874, -31.209204 ], [ 117.440672, -31.209278 ], [ 117.426510, -31.209498 ], [ 117.426510, -31.200248 ], [ 117.428656, -31.200248 ], [ 117.428656, -31.195403 ], [ 117.441273, -31.195403 ], [ 117.441273, -31.190997 ], [ 117.443419, -31.190997 ], [ 117.443419, -31.183728 ], [ 117.435350, -31.183728 ], [ 117.435350, -31.170290 ], [ 117.441444, -31.170143 ], [ 117.445736, -31.169629 ], [ 117.445650, -31.102701 ], [ 117.415009, -31.102701 ], [ 117.415009, -31.052713 ], [ 117.445650, -31.052713 ] ] ] } }
] }
] }
,
{ "type": "FeatureCollection", "properties": { "zoom": 10, "x": 846, "y": 604 }, "features": [
{ "type": "FeatureCollection", "properties": { "layer": "data", "version": 2, "extent": 4096 }, "features": [
{ "type": "Feature", "id": 10959577660569731, "properties": { "country": "au", "text": "Wyalkatchem" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 117.447710, -31.052934 ], [ 117.455349, -31.053669 ], [ 117.464705, -31.056463 ], [ 117.468996, -31.058816 ], [ 117.415009, -31.058816 ], [ 117.415009, -31.052713 ], [ 117.445650, -31.052713 ], [ 117.447710, -31.052934 ] ] ] } }
{ "type": "Feature", "id": 10959577660569731, "properties": { "country": "au", "text": "Wyalkatchem" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 117.445650, -31.052713 ], [ 117.447710, -31.052934 ], [ 117.455349, -31.053669 ], [ 117.464705, -31.056463 ], [ 117.468996, -31.058816 ], [ 117.415009, -31.052713 ], [ 117.445650, -31.052713 ] ] ] } }
] }
] }
,
{ "type": "FeatureCollection", "properties": { "zoom": 11, "x": 1690, "y": 1212 }, "features": [
{ "type": "FeatureCollection", "properties": { "layer": "data", "version": 2, "extent": 4096 }, "features": [
{ "type": "Feature", "id": 10959577660569731, "properties": { "country": "au", "text": "Wyalkatchem" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 117.249527, -31.447886 ], [ 117.246094, -31.446019 ], [ 117.242103, -31.443859 ], [ 117.234678, -31.437634 ], [ 117.228584, -31.430091 ], [ 117.224035, -31.421485 ], [ 117.221246, -31.412220 ], [ 117.220302, -31.402550 ], [ 117.220302, -31.391670 ], [ 117.221246, -31.381925 ], [ 117.223434, -31.374634 ], [ 117.223434, -31.373352 ], [ 117.224250, -31.364448 ], [ 117.224894, -31.362102 ], [ 117.224894, -31.357558 ], [ 117.223134, -31.355433 ], [ 117.222147, -31.353637 ], [ 117.220602, -31.350705 ], [ 117.249527, -31.350705 ], [ 117.249527, -31.447886 ] ] ] } }
{ "type": "Feature", "id": 10959577660569731, "properties": { "country": "au", "text": "Wyalkatchem" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 117.249527, -31.350705 ], [ 117.249527, -31.447886 ], [ 117.246094, -31.446019 ], [ 117.242103, -31.443859 ], [ 117.234678, -31.437634 ], [ 117.228584, -31.430091 ], [ 117.224035, -31.421485 ], [ 117.221246, -31.412220 ], [ 117.220302, -31.402550 ], [ 117.220302, -31.391670 ], [ 117.221246, -31.381925 ], [ 117.223434, -31.374634 ], [ 117.223434, -31.373352 ], [ 117.224250, -31.364448 ], [ 117.224894, -31.362102 ], [ 117.224894, -31.357558 ], [ 117.223134, -31.355433 ], [ 117.222147, -31.353637 ], [ 117.220602, -31.350705 ], [ 117.249527, -31.350705 ] ] ] } }
] }
] }
,
{ "type": "FeatureCollection", "properties": { "zoom": 11, "x": 1690, "y": 1211 }, "features": [
{ "type": "FeatureCollection", "properties": { "layer": "data", "version": 2, "extent": 4096 }, "features": [
{ "type": "Feature", "id": 10959577660569731, "properties": { "country": "au", "text": "Wyalkatchem" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 117.249527, -31.356569 ], [ 117.224035, -31.356569 ], [ 117.223134, -31.355433 ], [ 117.222147, -31.353637 ], [ 117.218542, -31.346783 ], [ 117.215710, -31.337437 ], [ 117.215495, -31.335421 ], [ 117.212920, -31.330582 ], [ 117.210045, -31.321197 ], [ 117.209101, -31.311445 ], [ 117.209101, -31.309355 ], [ 117.207942, -31.307228 ], [ 117.205110, -31.297841 ], [ 117.204766, -31.294394 ], [ 117.204080, -31.292157 ], [ 117.203135, -31.282402 ], [ 117.203135, -31.275323 ], [ 117.204080, -31.265566 ], [ 117.206912, -31.256211 ], [ 117.211547, -31.247553 ], [ 117.217770, -31.239995 ], [ 117.225366, -31.233757 ], [ 117.233992, -31.229133 ], [ 117.243390, -31.226307 ], [ 117.244592, -31.226161 ], [ 117.244635, -31.203405 ], [ 117.244635, -31.200468 ], [ 117.249527, -31.200468 ], [ 117.249527, -31.356569 ] ] ] } }
{ "type": "Feature", "id": 10959577660569731, "properties": { "country": "au", "text": "Wyalkatchem" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 117.249527, -31.200468 ], [ 117.249527, -31.356569 ], [ 117.224035, -31.356569 ], [ 117.223134, -31.355433 ], [ 117.222147, -31.353637 ], [ 117.218542, -31.346783 ], [ 117.215710, -31.337437 ], [ 117.215495, -31.335421 ], [ 117.212920, -31.330582 ], [ 117.210045, -31.321197 ], [ 117.209101, -31.311445 ], [ 117.209101, -31.309355 ], [ 117.207942, -31.307228 ], [ 117.205110, -31.297841 ], [ 117.204766, -31.294394 ], [ 117.204080, -31.292157 ], [ 117.203135, -31.282402 ], [ 117.203135, -31.275323 ], [ 117.204080, -31.265566 ], [ 117.206912, -31.256211 ], [ 117.211547, -31.247553 ], [ 117.217770, -31.239995 ], [ 117.225366, -31.233757 ], [ 117.233992, -31.229133 ], [ 117.243390, -31.226307 ], [ 117.244592, -31.226161 ], [ 117.244635, -31.203405 ], [ 117.244635, -31.200468 ], [ 117.249527, -31.200468 ] ] ] } }
] }
] }
,
{ "type": "FeatureCollection", "properties": { "zoom": 11, "x": 1690, "y": 1210 }, "features": [
{ "type": "FeatureCollection", "properties": { "layer": "data", "version": 2, "extent": 4096 }, "features": [
{ "type": "Feature", "id": 10959577660569731, "properties": { "country": "au", "text": "Wyalkatchem" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 117.249527, -31.206341 ], [ 117.244592, -31.206341 ], [ 117.244635, -31.203405 ], [ 117.244678, -31.165699 ], [ 117.245622, -31.156115 ], [ 117.246094, -31.154535 ], [ 117.248368, -31.146859 ], [ 117.249527, -31.144692 ], [ 117.249527, -31.206341 ] ] ] } }
{ "type": "Feature", "id": 10959577660569731, "properties": { "country": "au", "text": "Wyalkatchem" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 117.249527, -31.144692 ], [ 117.249527, -31.206341 ], [ 117.244592, -31.206341 ], [ 117.244635, -31.203405 ], [ 117.244678, -31.165699 ], [ 117.245622, -31.156115 ], [ 117.246094, -31.154535 ], [ 117.248368, -31.146859 ], [ 117.249527, -31.144692 ] ] ] } }
] }
] }
,
{ "type": "FeatureCollection", "properties": { "zoom": 11, "x": 1691, "y": 1212 }, "features": [
{ "type": "FeatureCollection", "properties": { "layer": "data", "version": 2, "extent": 4096 }, "features": [
{ "type": "Feature", "id": 10959577660569731, "properties": { "country": "au", "text": "Wyalkatchem" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 117.274890, -31.353270 ], [ 117.274890, -31.369651 ], [ 117.278023, -31.369651 ], [ 117.273431, -31.373352 ], [ 117.273431, -31.391634 ], [ 117.270298, -31.391634 ], [ 117.270298, -31.402513 ], [ 117.279911, -31.402513 ], [ 117.280297, -31.402696 ], [ 117.280297, -31.403722 ], [ 117.290339, -31.403722 ], [ 117.290339, -31.394638 ], [ 117.298794, -31.394638 ], [ 117.298794, -31.396433 ], [ 117.309351, -31.396396 ], [ 117.309351, -31.396579 ], [ 117.318707, -31.396579 ], [ 117.322011, -31.397971 ], [ 117.322612, -31.398301 ], [ 117.323170, -31.398667 ], [ 117.323642, -31.399107 ], [ 117.324028, -31.399620 ], [ 117.325058, -31.401634 ], [ 117.325401, -31.402147 ], [ 117.331667, -31.402147 ], [ 117.331710, -31.411194 ], [ 117.338190, -31.411194 ], [ 117.338190, -31.423133 ], [ 117.335143, -31.423133 ], [ 117.335143, -31.436719 ], [ 117.368317, -31.436719 ], [ 117.368274, -31.433753 ], [ 117.397928, -31.433716 ], [ 117.397928, -31.439136 ], [ 117.409687, -31.439136 ], [ 117.409945, -31.438989 ], [ 117.425308, -31.438989 ], [ 117.425308, -31.488992 ], [ 117.411275, -31.488992 ], [ 117.409601, -31.489139 ], [ 117.397842, -31.489139 ], [ 117.388144, -31.488150 ], [ 117.379174, -31.485406 ], [ 117.378058, -31.485772 ], [ 117.368317, -31.486723 ], [ 117.335143, -31.486723 ], [ 117.325401, -31.485772 ], [ 117.316003, -31.482917 ], [ 117.307377, -31.478306 ], [ 117.299781, -31.472083 ], [ 117.293558, -31.464506 ], [ 117.288923, -31.455867 ], [ 117.288280, -31.453707 ], [ 117.280297, -31.453707 ], [ 117.270555, -31.452755 ], [ 117.269783, -31.452536 ], [ 117.259870, -31.451438 ], [ 117.250643, -31.448509 ], [ 117.246094, -31.446019 ], [ 117.242661, -31.444115 ], [ 117.242661, -31.350705 ], [ 117.280169, -31.350705 ], [ 117.280169, -31.353270 ], [ 117.274890, -31.353270 ] ] ] } }
{ "type": "Feature", "id": 10959577660569731, "properties": { "country": "au", "text": "Wyalkatchem" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 117.280169, -31.350705 ], [ 117.280169, -31.353270 ], [ 117.274890, -31.353270 ], [ 117.274890, -31.369651 ], [ 117.278023, -31.369651 ], [ 117.273431, -31.373352 ], [ 117.273431, -31.391634 ], [ 117.270298, -31.391634 ], [ 117.270298, -31.402513 ], [ 117.279911, -31.402513 ], [ 117.280297, -31.402696 ], [ 117.280297, -31.403722 ], [ 117.290339, -31.403722 ], [ 117.290339, -31.394638 ], [ 117.298794, -31.394638 ], [ 117.298794, -31.396433 ], [ 117.309351, -31.396396 ], [ 117.309351, -31.396579 ], [ 117.318707, -31.396579 ], [ 117.322011, -31.397971 ], [ 117.322612, -31.398301 ], [ 117.323170, -31.398667 ], [ 117.323642, -31.399107 ], [ 117.324028, -31.399620 ], [ 117.325058, -31.401634 ], [ 117.325401, -31.402147 ], [ 117.331667, -31.402147 ], [ 117.331710, -31.411194 ], [ 117.338190, -31.411194 ], [ 117.338190, -31.423133 ], [ 117.335143, -31.423133 ], [ 117.335143, -31.436719 ], [ 117.368317, -31.436719 ], [ 117.368274, -31.433753 ], [ 117.397928, -31.433716 ], [ 117.397928, -31.439136 ], [ 117.409687, -31.439136 ], [ 117.409945, -31.438989 ], [ 117.425308, -31.438989 ], [ 117.425308, -31.488992 ], [ 117.411275, -31.488992 ], [ 117.409601, -31.489139 ], [ 117.397842, -31.489139 ], [ 117.388144, -31.488150 ], [ 117.379174, -31.485406 ], [ 117.378058, -31.485772 ], [ 117.368317, -31.486723 ], [ 117.335143, -31.486723 ], [ 117.325401, -31.485772 ], [ 117.316003, -31.482917 ], [ 117.307377, -31.478306 ], [ 117.299781, -31.472083 ], [ 117.293558, -31.464506 ], [ 117.288923, -31.455867 ], [ 117.288280, -31.453707 ], [ 117.280297, -31.453707 ], [ 117.270555, -31.452755 ], [ 117.269783, -31.452536 ], [ 117.259870, -31.451438 ], [ 117.250643, -31.448509 ], [ 117.246094, -31.446019 ], [ 117.242661, -31.444115 ], [ 117.242661, -31.350705 ], [ 117.280169, -31.350705 ] ] ] } }
] }
] }
,
{ "type": "FeatureCollection", "properties": { "zoom": 11, "x": 1691, "y": 1211 }, "features": [
{ "type": "FeatureCollection", "properties": { "layer": "data", "version": 2, "extent": 4096 }, "features": [
{ "type": "Feature", "id": 10959577660569731, "properties": { "country": "au", "text": "Wyalkatchem" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 117.294588, -31.252469 ], [ 117.301068, -31.252506 ], [ 117.301025, -31.269014 ], [ 117.300682, -31.269784 ], [ 117.300124, -31.270628 ], [ 117.298880, -31.271875 ], [ 117.298322, -31.272792 ], [ 117.297978, -31.273563 ], [ 117.297978, -31.276570 ], [ 117.288280, -31.276570 ], [ 117.278194, -31.276460 ], [ 117.274504, -31.275250 ], [ 117.261629, -31.275250 ], [ 117.261629, -31.275323 ], [ 117.253132, -31.275323 ], [ 117.253132, -31.282402 ], [ 117.254119, -31.282402 ], [ 117.254162, -31.288050 ], [ 117.262616, -31.288050 ], [ 117.262616, -31.295311 ], [ 117.260170, -31.295311 ], [ 117.260170, -31.303892 ], [ 117.259097, -31.303892 ], [ 117.259097, -31.311445 ], [ 117.264719, -31.311445 ], [ 117.264719, -31.327686 ], [ 117.280211, -31.327686 ], [ 117.280169, -31.353270 ], [ 117.274890, -31.353270 ], [ 117.274890, -31.356569 ], [ 117.242661, -31.356569 ], [ 117.242661, -31.226527 ], [ 117.243390, -31.226307 ], [ 117.244592, -31.226161 ], [ 117.244635, -31.200468 ], [ 117.294631, -31.200468 ], [ 117.294631, -31.203405 ], [ 117.294588, -31.252469 ] ] ] } }
{ "type": "Feature", "id": 10959577660569731, "properties": { "country": "au", "text": "Wyalkatchem" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 117.294631, -31.200468 ], [ 117.294631, -31.203405 ], [ 117.294588, -31.252469 ], [ 117.301068, -31.252506 ], [ 117.301025, -31.269014 ], [ 117.300682, -31.269784 ], [ 117.300124, -31.270628 ], [ 117.298880, -31.271875 ], [ 117.298322, -31.272792 ], [ 117.297978, -31.273563 ], [ 117.297978, -31.276570 ], [ 117.288280, -31.276570 ], [ 117.278194, -31.276460 ], [ 117.274504, -31.275250 ], [ 117.261629, -31.275250 ], [ 117.261629, -31.275323 ], [ 117.253132, -31.275323 ], [ 117.253132, -31.282402 ], [ 117.254119, -31.282402 ], [ 117.254162, -31.288050 ], [ 117.262616, -31.288050 ], [ 117.262616, -31.295311 ], [ 117.260170, -31.295311 ], [ 117.260170, -31.303892 ], [ 117.259097, -31.303892 ], [ 117.259097, -31.311445 ], [ 117.264719, -31.311445 ], [ 117.264719, -31.327686 ], [ 117.280211, -31.327686 ], [ 117.280169, -31.353270 ], [ 117.274890, -31.353270 ], [ 117.274890, -31.356569 ], [ 117.242661, -31.356569 ], [ 117.242661, -31.226527 ], [ 117.243390, -31.226307 ], [ 117.244592, -31.226161 ], [ 117.244635, -31.200468 ], [ 117.294631, -31.200468 ] ] ] } }
] }
] }
,
{ "type": "FeatureCollection", "properties": { "zoom": 11, "x": 1691, "y": 1210 }, "features": [
{ "type": "FeatureCollection", "properties": { "layer": "data", "version": 2, "extent": 4096 }, "features": [
{ "type": "Feature", "id": 10959577660569731, "properties": { "country": "au", "text": "Wyalkatchem" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 117.378745, -31.102775 ], [ 117.376685, -31.103840 ], [ 117.362309, -31.103840 ], [ 117.359862, -31.102958 ], [ 117.346945, -31.102958 ], [ 117.346516, -31.103032 ], [ 117.346430, -31.103656 ], [ 117.346430, -31.112475 ], [ 117.328062, -31.112475 ], [ 117.328062, -31.127869 ], [ 117.327976, -31.127905 ], [ 117.327976, -31.142489 ], [ 117.324543, -31.142489 ], [ 117.324543, -31.152699 ], [ 117.326217, -31.152699 ], [ 117.326217, -31.162541 ], [ 117.323899, -31.162211 ], [ 117.295618, -31.165553 ], [ 117.294674, -31.165773 ], [ 117.294631, -31.203405 ], [ 117.294631, -31.206341 ], [ 117.244592, -31.206341 ], [ 117.244678, -31.165699 ], [ 117.245622, -31.156115 ], [ 117.246094, -31.154535 ], [ 117.248368, -31.146859 ], [ 117.252874, -31.138338 ], [ 117.258925, -31.130808 ], [ 117.266307, -31.124599 ], [ 117.274718, -31.119897 ], [ 117.278023, -31.118831 ], [ 117.278066, -31.112144 ], [ 117.279096, -31.102444 ], [ 117.281971, -31.093110 ], [ 117.286606, -31.084547 ], [ 117.292829, -31.077012 ], [ 117.300425, -31.070837 ], [ 117.309008, -31.066242 ], [ 117.315102, -31.064404 ], [ 117.317848, -31.062088 ], [ 117.326474, -31.057235 ], [ 117.335873, -31.054184 ], [ 117.336302, -31.054110 ], [ 117.346945, -31.052934 ], [ 117.359862, -31.052934 ], [ 117.368703, -31.053743 ], [ 117.369132, -31.053853 ], [ 117.369905, -31.053853 ], [ 117.377372, -31.052934 ], [ 117.378702, -31.052750 ], [ 117.425308, -31.052713 ], [ 117.425308, -31.102738 ], [ 117.421875, -31.102738 ], [ 117.378745, -31.102775 ] ] ] } }
{ "type": "Feature", "id": 10959577660569731, "properties": { "country": "au", "text": "Wyalkatchem" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 117.425308, -31.052713 ], [ 117.425308, -31.102738 ], [ 117.421875, -31.102738 ], [ 117.378745, -31.102775 ], [ 117.376685, -31.103840 ], [ 117.362309, -31.103840 ], [ 117.359862, -31.102958 ], [ 117.346945, -31.102958 ], [ 117.346516, -31.103032 ], [ 117.346430, -31.103656 ], [ 117.346430, -31.112475 ], [ 117.328062, -31.112475 ], [ 117.328062, -31.127869 ], [ 117.327976, -31.127905 ], [ 117.327976, -31.142489 ], [ 117.324543, -31.142489 ], [ 117.324543, -31.152699 ], [ 117.326217, -31.152699 ], [ 117.326217, -31.162541 ], [ 117.323899, -31.162211 ], [ 117.295618, -31.165553 ], [ 117.294674, -31.165773 ], [ 117.294631, -31.203405 ], [ 117.294631, -31.206341 ], [ 117.244592, -31.206341 ], [ 117.244678, -31.165699 ], [ 117.245622, -31.156115 ], [ 117.246094, -31.154535 ], [ 117.248368, -31.146859 ], [ 117.252874, -31.138338 ], [ 117.258925, -31.130808 ], [ 117.266307, -31.124599 ], [ 117.274718, -31.119897 ], [ 117.278023, -31.118831 ], [ 117.278066, -31.112144 ], [ 117.279096, -31.102444 ], [ 117.281971, -31.093110 ], [ 117.286606, -31.084547 ], [ 117.292829, -31.077012 ], [ 117.300425, -31.070837 ], [ 117.309008, -31.066242 ], [ 117.315102, -31.064404 ], [ 117.317848, -31.062088 ], [ 117.326474, -31.057235 ], [ 117.335873, -31.054184 ], [ 117.336302, -31.054110 ], [ 117.346945, -31.052934 ], [ 117.359862, -31.052934 ], [ 117.368703, -31.053743 ], [ 117.369132, -31.053853 ], [ 117.369905, -31.053853 ], [ 117.377372, -31.052934 ], [ 117.378702, -31.052750 ], [ 117.425308, -31.052713 ] ] ] } }
] }
] }
,
{ "type": "FeatureCollection", "properties": { "zoom": 11, "x": 1691, "y": 1209 }, "features": [
{ "type": "FeatureCollection", "properties": { "layer": "data", "version": 2, "extent": 4096 }, "features": [
{ "type": "Feature", "id": 10959577660569731, "properties": { "country": "au", "text": "Wyalkatchem" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 117.425308, -31.055875 ], [ 117.330680, -31.055875 ], [ 117.335873, -31.054184 ], [ 117.336302, -31.054110 ], [ 117.346945, -31.052934 ], [ 117.359862, -31.052934 ], [ 117.368703, -31.053743 ], [ 117.369132, -31.053853 ], [ 117.369905, -31.053853 ], [ 117.377372, -31.052934 ], [ 117.378702, -31.052750 ], [ 117.421875, -31.052713 ], [ 117.425308, -31.052713 ], [ 117.425308, -31.055875 ] ] ] } }
{ "type": "Feature", "id": 10959577660569731, "properties": { "country": "au", "text": "Wyalkatchem" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 117.425308, -31.052713 ], [ 117.425308, -31.055875 ], [ 117.330680, -31.055875 ], [ 117.335873, -31.054184 ], [ 117.336302, -31.054110 ], [ 117.346945, -31.052934 ], [ 117.359862, -31.052934 ], [ 117.368703, -31.053743 ], [ 117.369132, -31.053853 ], [ 117.369905, -31.053853 ], [ 117.377372, -31.052934 ], [ 117.378702, -31.052750 ], [ 117.421875, -31.052713 ], [ 117.425308, -31.052713 ] ] ] } }
] }
] }
,
{ "type": "FeatureCollection", "properties": { "zoom": 11, "x": 1692, "y": 1212 }, "features": [
{ "type": "FeatureCollection", "properties": { "layer": "data", "version": 2, "extent": 4096 }, "features": [
{ "type": "Feature", "id": 10959577660569731, "properties": { "country": "au", "text": "Wyalkatchem" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 117.421875, -31.438989 ], [ 117.435780, -31.439026 ], [ 117.435780, -31.407971 ], [ 117.435651, -31.407971 ], [ 117.435694, -31.354260 ], [ 117.435780, -31.353637 ], [ 117.436252, -31.351218 ], [ 117.436252, -31.350705 ], [ 117.488222, -31.350705 ], [ 117.486634, -31.353637 ], [ 117.485948, -31.354480 ], [ 117.485690, -31.357448 ], [ 117.485647, -31.406909 ], [ 117.485776, -31.407971 ], [ 117.485776, -31.439026 ], [ 117.484789, -31.448802 ], [ 117.481956, -31.458210 ], [ 117.477322, -31.466849 ], [ 117.471099, -31.474426 ], [ 117.463503, -31.480648 ], [ 117.454834, -31.485259 ], [ 117.445436, -31.488114 ], [ 117.435651, -31.489029 ], [ 117.421875, -31.488992 ], [ 117.418442, -31.488992 ], [ 117.418442, -31.438989 ], [ 117.421875, -31.438989 ] ] ] } }
{ "type": "Feature", "id": 10959577660569731, "properties": { "country": "au", "text": "Wyalkatchem" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 117.488222, -31.350705 ], [ 117.486634, -31.353637 ], [ 117.485948, -31.354480 ], [ 117.485690, -31.357448 ], [ 117.485647, -31.406909 ], [ 117.485776, -31.407971 ], [ 117.485776, -31.439026 ], [ 117.484789, -31.448802 ], [ 117.481956, -31.458210 ], [ 117.477322, -31.466849 ], [ 117.471099, -31.474426 ], [ 117.463503, -31.480648 ], [ 117.454834, -31.485259 ], [ 117.445436, -31.488114 ], [ 117.435651, -31.489029 ], [ 117.421875, -31.488992 ], [ 117.418442, -31.488992 ], [ 117.418442, -31.438989 ], [ 117.421875, -31.438989 ], [ 117.435780, -31.439026 ], [ 117.435780, -31.407971 ], [ 117.435651, -31.407971 ], [ 117.435694, -31.354260 ], [ 117.435780, -31.353637 ], [ 117.436252, -31.351218 ], [ 117.436252, -31.350705 ], [ 117.488222, -31.350705 ] ] ] } }
] }
] }
,
{ "type": "FeatureCollection", "properties": { "zoom": 11, "x": 1692, "y": 1211 }, "features": [
{ "type": "FeatureCollection", "properties": { "layer": "data", "version": 2, "extent": 4096 }, "features": [
{ "type": "Feature", "id": 10959577660569731, "properties": { "country": "au", "text": "Wyalkatchem" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 117.435780, -31.353637 ], [ 117.436252, -31.351218 ], [ 117.436252, -31.340259 ], [ 117.436123, -31.340259 ], [ 117.436166, -31.325743 ], [ 117.445135, -31.325780 ], [ 117.445178, -31.304698 ], [ 117.447710, -31.299712 ], [ 117.447710, -31.266520 ], [ 117.448440, -31.265823 ], [ 117.448440, -31.245462 ], [ 117.448397, -31.204506 ], [ 117.447624, -31.204800 ], [ 117.446809, -31.205277 ], [ 117.446079, -31.205938 ], [ 117.445049, -31.207296 ], [ 117.444191, -31.208140 ], [ 117.443118, -31.208801 ], [ 117.441916, -31.209204 ], [ 117.440715, -31.209315 ], [ 117.426510, -31.209498 ], [ 117.426510, -31.200468 ], [ 117.497964, -31.200468 ], [ 117.498264, -31.203405 ], [ 117.498393, -31.204469 ], [ 117.498436, -31.265786 ], [ 117.497706, -31.273086 ], [ 117.497706, -31.299748 ], [ 117.496333, -31.311335 ], [ 117.495131, -31.314525 ], [ 117.495131, -31.325817 ], [ 117.494187, -31.335567 ], [ 117.491312, -31.344951 ], [ 117.486634, -31.353637 ], [ 117.485948, -31.354480 ], [ 117.485733, -31.356569 ], [ 117.435651, -31.356569 ], [ 117.435694, -31.354260 ], [ 117.435780, -31.353637 ] ] ] } }
{ "type": "Feature", "id": 10959577660569731, "properties": { "country": "au", "text": "Wyalkatchem" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 117.498264, -31.203405 ], [ 117.498393, -31.204469 ], [ 117.498436, -31.265786 ], [ 117.497706, -31.273086 ], [ 117.497706, -31.299748 ], [ 117.496333, -31.311335 ], [ 117.495131, -31.314525 ], [ 117.495131, -31.325817 ], [ 117.494187, -31.335567 ], [ 117.491312, -31.344951 ], [ 117.486634, -31.353637 ], [ 117.485948, -31.354480 ], [ 117.485733, -31.356569 ], [ 117.435651, -31.356569 ], [ 117.435694, -31.354260 ], [ 117.435780, -31.353637 ], [ 117.436252, -31.351218 ], [ 117.436252, -31.340259 ], [ 117.436123, -31.340259 ], [ 117.436166, -31.325743 ], [ 117.445135, -31.325780 ], [ 117.445178, -31.304698 ], [ 117.447710, -31.299712 ], [ 117.447710, -31.266520 ], [ 117.448440, -31.265823 ], [ 117.448440, -31.245462 ], [ 117.448397, -31.204506 ], [ 117.447624, -31.204800 ], [ 117.446809, -31.205277 ], [ 117.446079, -31.205938 ], [ 117.445049, -31.207296 ], [ 117.444191, -31.208140 ], [ 117.443118, -31.208801 ], [ 117.441916, -31.209204 ], [ 117.440715, -31.209315 ], [ 117.426510, -31.209498 ], [ 117.426510, -31.200468 ], [ 117.497964, -31.200468 ], [ 117.498264, -31.203405 ] ] ] } }
] }
] }
,
{ "type": "FeatureCollection", "properties": { "zoom": 11, "x": 1692, "y": 1210 }, "features": [
{ "type": "FeatureCollection", "properties": { "layer": "data", "version": 2, "extent": 4096 }, "features": [
{ "type": "Feature", "id": 10959577660569731, "properties": { "country": "au", "text": "Wyalkatchem" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 117.447624, -31.204800 ], [ 117.446809, -31.205277 ], [ 117.446079, -31.205938 ], [ 117.445736, -31.206341 ], [ 117.426510, -31.206341 ], [ 117.426510, -31.203405 ], [ 117.426553, -31.200248 ], [ 117.428656, -31.200248 ], [ 117.428656, -31.195403 ], [ 117.441316, -31.195403 ], [ 117.441316, -31.190997 ], [ 117.443419, -31.190997 ], [ 117.443419, -31.183728 ], [ 117.435393, -31.183728 ], [ 117.435393, -31.170326 ], [ 117.441444, -31.170143 ], [ 117.445736, -31.169629 ], [ 117.445650, -31.102738 ], [ 117.418442, -31.102738 ], [ 117.418442, -31.052713 ], [ 117.445650, -31.052713 ], [ 117.447710, -31.052934 ], [ 117.455392, -31.053669 ], [ 117.464747, -31.056500 ], [ 117.473416, -31.061132 ], [ 117.480969, -31.067345 ], [ 117.487192, -31.074917 ], [ 117.491827, -31.083554 ], [ 117.494702, -31.092926 ], [ 117.495646, -31.102664 ], [ 117.495775, -31.169592 ], [ 117.494702, -31.179873 ], [ 117.493544, -31.183471 ], [ 117.494702, -31.185711 ], [ 117.497449, -31.194925 ], [ 117.498264, -31.203405 ], [ 117.498393, -31.204469 ], [ 117.498393, -31.206341 ], [ 117.448397, -31.206341 ], [ 117.448397, -31.204506 ], [ 117.447624, -31.204800 ] ] ] } }
{ "type": "Feature", "id": 10959577660569731, "properties": { "country": "au", "text": "Wyalkatchem" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 117.445650, -31.052713 ], [ 117.447710, -31.052934 ], [ 117.455392, -31.053669 ], [ 117.464747, -31.056500 ], [ 117.473416, -31.061132 ], [ 117.480969, -31.067345 ], [ 117.487192, -31.074917 ], [ 117.491827, -31.083554 ], [ 117.494702, -31.092926 ], [ 117.495646, -31.102664 ], [ 117.495775, -31.169592 ], [ 117.494702, -31.179873 ], [ 117.493544, -31.183471 ], [ 117.494702, -31.185711 ], [ 117.497449, -31.194925 ], [ 117.498264, -31.203405 ], [ 117.498393, -31.204469 ], [ 117.498393, -31.206341 ], [ 117.448397, -31.206341 ], [ 117.448397, -31.204506 ], [ 117.447624, -31.204800 ], [ 117.446809, -31.205277 ], [ 117.446079, -31.205938 ], [ 117.445736, -31.206341 ], [ 117.426510, -31.206341 ], [ 117.426510, -31.203405 ], [ 117.426553, -31.200248 ], [ 117.428656, -31.200248 ], [ 117.428656, -31.195403 ], [ 117.441316, -31.195403 ], [ 117.441316, -31.190997 ], [ 117.443419, -31.190997 ], [ 117.443419, -31.183728 ], [ 117.435393, -31.183728 ], [ 117.435393, -31.170326 ], [ 117.441444, -31.170143 ], [ 117.445736, -31.169629 ], [ 117.445650, -31.102738 ], [ 117.418442, -31.102738 ], [ 117.418442, -31.052713 ], [ 117.445650, -31.052713 ] ] ] } }
] }
] }
,
{ "type": "FeatureCollection", "properties": { "zoom": 11, "x": 1692, "y": 1209 }, "features": [
{ "type": "FeatureCollection", "properties": { "layer": "data", "version": 2, "extent": 4096 }, "features": [
{ "type": "Feature", "id": 10959577660569731, "properties": { "country": "au", "text": "Wyalkatchem" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 117.447710, -31.052934 ], [ 117.455392, -31.053669 ], [ 117.462602, -31.055875 ], [ 117.418442, -31.055875 ], [ 117.418442, -31.052713 ], [ 117.445650, -31.052713 ], [ 117.447710, -31.052934 ] ] ] } }
{ "type": "Feature", "id": 10959577660569731, "properties": { "country": "au", "text": "Wyalkatchem" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 117.445650, -31.052713 ], [ 117.447710, -31.052934 ], [ 117.455392, -31.053669 ], [ 117.462602, -31.055875 ], [ 117.418442, -31.052713 ], [ 117.445650, -31.052713 ] ] ] } }
] }
] }
,
{ "type": "FeatureCollection", "properties": { "zoom": 12, "x": 3381, "y": 2425 }, "features": [
{ "type": "FeatureCollection", "properties": { "layer": "data", "version": 2, "extent": 4096 }, "features": [
{ "type": "Feature", "id": 10959577660569731, "properties": { "country": "au", "text": "Wyalkatchem" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 117.247810, -31.446934 ], [ 117.246094, -31.446001 ], [ 117.242124, -31.443859 ], [ 117.234678, -31.437634 ], [ 117.228584, -31.430091 ], [ 117.227812, -31.428663 ], [ 117.227039, -31.427198 ], [ 117.247810, -31.427198 ], [ 117.247810, -31.446934 ] ] ] } }
{ "type": "Feature", "id": 10959577660569731, "properties": { "country": "au", "text": "Wyalkatchem" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 117.247810, -31.427198 ], [ 117.247810, -31.446934 ], [ 117.246094, -31.446001 ], [ 117.242124, -31.443859 ], [ 117.234678, -31.437634 ], [ 117.228584, -31.430091 ], [ 117.227812, -31.428663 ], [ 117.227039, -31.427198 ], [ 117.247810, -31.427198 ] ] ] } }
] }
] }
,
{ "type": "FeatureCollection", "properties": { "zoom": 12, "x": 3381, "y": 2424 }, "features": [
{ "type": "FeatureCollection", "properties": { "layer": "data", "version": 2, "extent": 4096 }, "features": [
{ "type": "Feature", "id": 10959577660569731, "properties": { "country": "au", "text": "Wyalkatchem" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 117.247810, -31.430128 ], [ 117.228606, -31.430128 ], [ 117.227812, -31.428663 ], [ 117.224035, -31.421504 ], [ 117.221246, -31.412220 ], [ 117.220302, -31.402568 ], [ 117.220302, -31.391689 ], [ 117.221246, -31.381925 ], [ 117.223456, -31.374634 ], [ 117.223456, -31.373352 ], [ 117.224250, -31.364448 ], [ 117.224894, -31.362102 ], [ 117.224894, -31.357577 ], [ 117.223155, -31.355451 ], [ 117.222168, -31.353637 ], [ 117.221375, -31.352171 ], [ 117.247810, -31.352171 ], [ 117.247810, -31.430128 ] ] ] } }
{ "type": "Feature", "id": 10959577660569731, "properties": { "country": "au", "text": "Wyalkatchem" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 117.247810, -31.352171 ], [ 117.247810, -31.430128 ], [ 117.228606, -31.430128 ], [ 117.227812, -31.428663 ], [ 117.224035, -31.421504 ], [ 117.221246, -31.412220 ], [ 117.220302, -31.402568 ], [ 117.220302, -31.391689 ], [ 117.221246, -31.381925 ], [ 117.223456, -31.374634 ], [ 117.223456, -31.373352 ], [ 117.224250, -31.364448 ], [ 117.224894, -31.362102 ], [ 117.224894, -31.357577 ], [ 117.223155, -31.355451 ], [ 117.222168, -31.353637 ], [ 117.221375, -31.352171 ], [ 117.247810, -31.352171 ] ] ] } }
] }
] }
,
{ "type": "FeatureCollection", "properties": { "zoom": 12, "x": 3381, "y": 2423 }, "features": [
{ "type": "FeatureCollection", "properties": { "layer": "data", "version": 2, "extent": 4096 }, "features": [
{ "type": "Feature", "id": 10959577660569731, "properties": { "country": "au", "text": "Wyalkatchem" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 117.247810, -31.355103 ], [ 117.222962, -31.355103 ], [ 117.222168, -31.353637 ], [ 117.218542, -31.346802 ], [ 117.215710, -31.337437 ], [ 117.215495, -31.335439 ], [ 117.212920, -31.330582 ], [ 117.210066, -31.321197 ], [ 117.209101, -31.311445 ], [ 117.209101, -31.309373 ], [ 117.207963, -31.307228 ], [ 117.205110, -31.297841 ], [ 117.204788, -31.294413 ], [ 117.204101, -31.292176 ], [ 117.203135, -31.282420 ], [ 117.203135, -31.277084 ], [ 117.247810, -31.277084 ], [ 117.247810, -31.355103 ] ] ] } }
{ "type": "Feature", "id": 10959577660569731, "properties": { "country": "au", "text": "Wyalkatchem" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 117.247810, -31.277084 ], [ 117.247810, -31.355103 ], [ 117.222962, -31.355103 ], [ 117.222168, -31.353637 ], [ 117.218542, -31.346802 ], [ 117.215710, -31.337437 ], [ 117.215495, -31.335439 ], [ 117.212920, -31.330582 ], [ 117.210066, -31.321197 ], [ 117.209101, -31.311445 ], [ 117.209101, -31.309373 ], [ 117.207963, -31.307228 ], [ 117.205110, -31.297841 ], [ 117.204788, -31.294413 ], [ 117.204101, -31.292176 ], [ 117.203135, -31.282420 ], [ 117.203135, -31.277084 ], [ 117.247810, -31.277084 ] ] ] } }
] }
] }
,
{ "type": "FeatureCollection", "properties": { "zoom": 12, "x": 3381, "y": 2422 }, "features": [
{ "type": "FeatureCollection", "properties": { "layer": "data", "version": 2, "extent": 4096 }, "features": [
{ "type": "Feature", "id": 10959577660569731, "properties": { "country": "au", "text": "Wyalkatchem" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 117.247810, -31.280018 ], [ 117.203135, -31.280018 ], [ 117.203135, -31.275342 ], [ 117.204101, -31.265584 ], [ 117.206933, -31.256211 ], [ 117.211568, -31.247571 ], [ 117.217791, -31.239995 ], [ 117.225366, -31.233775 ], [ 117.233992, -31.229151 ], [ 117.243390, -31.226307 ], [ 117.244613, -31.226179 ], [ 117.244613, -31.201937 ], [ 117.247810, -31.201937 ], [ 117.247810, -31.280018 ] ] ] } }
{ "type": "Feature", "id": 10959577660569731, "properties": { "country": "au", "text": "Wyalkatchem" }, "geometry": { "type": "MultiPolygon", "coordinates": [ [ [ [ 117.231460, -31.230509 ], [ 117.203135, -31.280018 ], [ 117.203135, -31.275342 ], [ 117.204101, -31.265584 ], [ 117.206933, -31.256211 ], [ 117.211568, -31.247571 ], [ 117.217791, -31.239995 ], [ 117.225366, -31.233775 ], [ 117.231460, -31.230509 ] ] ], [ [ [ 117.247810, -31.201937 ], [ 117.244613, -31.207534 ], [ 117.244613, -31.201937 ], [ 117.247810, -31.201937 ] ] ] ] } }
] }
] }
,
{ "type": "FeatureCollection", "properties": { "zoom": 12, "x": 3381, "y": 2421 }, "features": [
{ "type": "FeatureCollection", "properties": { "layer": "data", "version": 2, "extent": 4096 }, "features": [
{ "type": "Feature", "id": 10959577660569731, "properties": { "country": "au", "text": "Wyalkatchem" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 117.247810, -31.204873 ], [ 117.244613, -31.204873 ], [ 117.244613, -31.203405 ], [ 117.244678, -31.165718 ], [ 117.245622, -31.156115 ], [ 117.246094, -31.154535 ], [ 117.247810, -31.148806 ], [ 117.247810, -31.204873 ] ] ] } }
{ "type": "Feature", "id": 10959577660569731, "properties": { "country": "au", "text": "Wyalkatchem" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 117.247810, -31.148806 ], [ 117.247810, -31.204873 ], [ 117.244613, -31.204873 ], [ 117.244613, -31.203405 ], [ 117.244678, -31.165718 ], [ 117.245622, -31.156115 ], [ 117.246094, -31.154535 ], [ 117.247810, -31.148806 ] ] ] } }
] }
] }
,
{ "type": "FeatureCollection", "properties": { "zoom": 12, "x": 3382, "y": 2425 }, "features": [
{ "type": "FeatureCollection", "properties": { "layer": "data", "version": 2, "extent": 4096 }, "features": [
{ "type": "Feature", "id": 10959577660569731, "properties": { "country": "au", "text": "Wyalkatchem" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 117.335701, -31.436737 ], [ 117.335701, -31.486723 ], [ 117.335165, -31.486742 ], [ 117.333984, -31.486613 ], [ 117.325401, -31.485790 ], [ 117.316024, -31.482935 ], [ 117.307377, -31.478324 ], [ 117.299781, -31.472102 ], [ 117.293580, -31.464525 ], [ 117.288945, -31.455867 ], [ 117.288301, -31.453726 ], [ 117.280319, -31.453726 ], [ 117.270555, -31.452774 ], [ 117.269804, -31.452536 ], [ 117.269526, -31.452536 ], [ 117.259891, -31.451438 ], [ 117.250643, -31.448509 ], [ 117.246094, -31.446001 ], [ 117.244377, -31.445067 ], [ 117.244377, -31.427198 ], [ 117.335143, -31.427198 ], [ 117.335143, -31.436737 ], [ 117.335701, -31.436737 ] ] ] } }
{ "type": "Feature", "id": 10959577660569731, "properties": { "country": "au", "text": "Wyalkatchem" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 117.335143, -31.427198 ], [ 117.335143, -31.436737 ], [ 117.335701, -31.436737 ], [ 117.335701, -31.486723 ], [ 117.335165, -31.486742 ], [ 117.333984, -31.486613 ], [ 117.325401, -31.485790 ], [ 117.316024, -31.482935 ], [ 117.307377, -31.478324 ], [ 117.299781, -31.472102 ], [ 117.293580, -31.464525 ], [ 117.288945, -31.455867 ], [ 117.288301, -31.453726 ], [ 117.280319, -31.453726 ], [ 117.270555, -31.452774 ], [ 117.269804, -31.452536 ], [ 117.269526, -31.452536 ], [ 117.259891, -31.451438 ], [ 117.250643, -31.448509 ], [ 117.246094, -31.446001 ], [ 117.244377, -31.445067 ], [ 117.244377, -31.427198 ], [ 117.335143, -31.427198 ] ] ] } }
] }
] }
,
{ "type": "FeatureCollection", "properties": { "zoom": 12, "x": 3382, "y": 2424 }, "features": [
{ "type": "FeatureCollection", "properties": { "layer": "data", "version": 2, "extent": 4096 }, "features": [
{ "type": "Feature", "id": 10959577660569731, "properties": { "country": "au", "text": "Wyalkatchem" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 117.335143, -31.423152 ], [ 117.335143, -31.430128 ], [ 117.244377, -31.430128 ], [ 117.244377, -31.352171 ], [ 117.280190, -31.352171 ], [ 117.280190, -31.353270 ], [ 117.274911, -31.353270 ], [ 117.274890, -31.353637 ], [ 117.274890, -31.369669 ], [ 117.278044, -31.369669 ], [ 117.273452, -31.373352 ], [ 117.273452, -31.391652 ], [ 117.270298, -31.391652 ], [ 117.270298, -31.402532 ], [ 117.279932, -31.402532 ], [ 117.280319, -31.402696 ], [ 117.280319, -31.403722 ], [ 117.290339, -31.403722 ], [ 117.290339, -31.394656 ], [ 117.298794, -31.394656 ], [ 117.298794, -31.396433 ], [ 117.309372, -31.396414 ], [ 117.309372, -31.396597 ], [ 117.318707, -31.396597 ], [ 117.322011, -31.397989 ], [ 117.322633, -31.398301 ], [ 117.323170, -31.398685 ], [ 117.323663, -31.399125 ], [ 117.324049, -31.399620 ], [ 117.324350, -31.400151 ], [ 117.325058, -31.401653 ], [ 117.325423, -31.402147 ], [ 117.331688, -31.402147 ], [ 117.331710, -31.411212 ], [ 117.335701, -31.411212 ], [ 117.335701, -31.423152 ], [ 117.335143, -31.423152 ] ] ] } }
{ "type": "Feature", "id": 10959577660569731, "properties": { "country": "au", "text": "Wyalkatchem" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 117.280190, -31.352171 ], [ 117.280190, -31.353270 ], [ 117.274911, -31.353270 ], [ 117.274890, -31.353637 ], [ 117.274890, -31.369669 ], [ 117.278044, -31.369669 ], [ 117.273452, -31.373352 ], [ 117.273452, -31.391652 ], [ 117.270298, -31.391652 ], [ 117.270298, -31.402532 ], [ 117.279932, -31.402532 ], [ 117.280319, -31.402696 ], [ 117.280319, -31.403722 ], [ 117.290339, -31.403722 ], [ 117.290339, -31.394656 ], [ 117.298794, -31.394656 ], [ 117.298794, -31.396433 ], [ 117.309372, -31.396414 ], [ 117.309372, -31.396597 ], [ 117.318707, -31.396597 ], [ 117.322011, -31.397989 ], [ 117.322633, -31.398301 ], [ 117.323170, -31.398685 ], [ 117.323663, -31.399125 ], [ 117.324049, -31.399620 ], [ 117.324350, -31.400151 ], [ 117.325058, -31.401653 ], [ 117.325423, -31.402147 ], [ 117.331688, -31.402147 ], [ 117.331710, -31.411212 ], [ 117.335701, -31.411212 ], [ 117.335701, -31.423152 ], [ 117.335143, -31.423152 ], [ 117.335143, -31.430128 ], [ 117.244377, -31.430128 ], [ 117.244377, -31.352171 ], [ 117.280190, -31.352171 ] ] ] } }
] }
] }
,
{ "type": "FeatureCollection", "properties": { "zoom": 12, "x": 3382, "y": 2423 }, "features": [
{ "type": "FeatureCollection", "properties": { "layer": "data", "version": 2, "extent": 4096 }, "features": [
{ "type": "Feature", "id": 10959577660569731, "properties": { "country": "au", "text": "Wyalkatchem" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 117.254140, -31.282420 ], [ 117.254162, -31.288068 ], [ 117.262616, -31.288068 ], [ 117.262616, -31.295329 ], [ 117.260170, -31.295329 ], [ 117.260170, -31.303892 ], [ 117.259119, -31.303892 ], [ 117.259119, -31.311463 ], [ 117.264740, -31.311463 ], [ 117.264740, -31.327686 ], [ 117.280211, -31.327686 ], [ 117.280190, -31.353270 ], [ 117.274911, -31.353270 ], [ 117.274890, -31.353637 ], [ 117.274890, -31.355103 ], [ 117.244377, -31.355103 ], [ 117.244377, -31.277084 ], [ 117.253132, -31.277084 ], [ 117.253132, -31.282420 ], [ 117.254140, -31.282420 ] ] ] } }
{ "type": "Feature", "id": 10959577660569731, "properties": { "country": "au", "text": "Wyalkatchem" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 117.253132, -31.277084 ], [ 117.253132, -31.282420 ], [ 117.254140, -31.282420 ], [ 117.254162, -31.288068 ], [ 117.262616, -31.288068 ], [ 117.262616, -31.295329 ], [ 117.260170, -31.295329 ], [ 117.260170, -31.303892 ], [ 117.259119, -31.303892 ], [ 117.259119, -31.311463 ], [ 117.264740, -31.311463 ], [ 117.264740, -31.327686 ], [ 117.280211, -31.327686 ], [ 117.280190, -31.353270 ], [ 117.274911, -31.353270 ], [ 117.274890, -31.353637 ], [ 117.274890, -31.355103 ], [ 117.244377, -31.355103 ], [ 117.244377, -31.277084 ], [ 117.253132, -31.277084 ] ] ] } }
] }
] }
,
{ "type": "FeatureCollection", "properties": { "zoom": 12, "x": 3382, "y": 2422 }, "features": [
{ "type": "FeatureCollection", "properties": { "layer": "data", "version": 2, "extent": 4096 }, "features": [
{ "type": "Feature", "id": 10959577660569731, "properties": { "country": "au", "text": "Wyalkatchem" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 117.294588, -31.252488 ], [ 117.301090, -31.252506 ], [ 117.301025, -31.269033 ], [ 117.300682, -31.269803 ], [ 117.300146, -31.270628 ], [ 117.299631, -31.271178 ], [ 117.298880, -31.271894 ], [ 117.298343, -31.272792 ], [ 117.297978, -31.273581 ], [ 117.297978, -31.276570 ], [ 117.288280, -31.276570 ], [ 117.278216, -31.276460 ], [ 117.274525, -31.275250 ], [ 117.261651, -31.275250 ], [ 117.261651, -31.275342 ], [ 117.253132, -31.275342 ], [ 117.253132, -31.280018 ], [ 117.244377, -31.280018 ], [ 117.244377, -31.226197 ], [ 117.244613, -31.226179 ], [ 117.244613, -31.201937 ], [ 117.294610, -31.201937 ], [ 117.294610, -31.203405 ], [ 117.294588, -31.252488 ] ] ] } }
{ "type": "Feature", "id": 10959577660569731, "properties": { "country": "au", "text": "Wyalkatchem" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 117.294610, -31.201937 ], [ 117.294610, -31.203405 ], [ 117.294588, -31.252488 ], [ 117.301090, -31.252506 ], [ 117.301025, -31.269033 ], [ 117.300682, -31.269803 ], [ 117.300146, -31.270628 ], [ 117.299631, -31.271178 ], [ 117.298880, -31.271894 ], [ 117.298343, -31.272792 ], [ 117.297978, -31.273581 ], [ 117.297978, -31.276570 ], [ 117.288280, -31.276570 ], [ 117.278216, -31.276460 ], [ 117.274525, -31.275250 ], [ 117.261651, -31.275250 ], [ 117.261651, -31.275342 ], [ 117.253132, -31.275342 ], [ 117.253132, -31.280018 ], [ 117.244377, -31.280018 ], [ 117.244377, -31.226197 ], [ 117.244613, -31.226179 ], [ 117.244613, -31.201937 ], [ 117.294610, -31.201937 ] ] ] } }
] }
] }
,
{ "type": "FeatureCollection", "properties": { "zoom": 12, "x": 3382, "y": 2421 }, "features": [
{ "type": "FeatureCollection", "properties": { "layer": "data", "version": 2, "extent": 4096 }, "features": [
{ "type": "Feature", "id": 10959577660569731, "properties": { "country": "au", "text": "Wyalkatchem" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 117.327976, -31.127924 ], [ 117.327976, -31.142507 ], [ 117.324543, -31.142507 ], [ 117.324543, -31.152699 ], [ 117.326238, -31.152699 ], [ 117.326238, -31.162541 ], [ 117.323921, -31.162229 ], [ 117.295618, -31.165571 ], [ 117.294674, -31.165773 ], [ 117.294631, -31.203405 ], [ 117.294631, -31.204873 ], [ 117.244613, -31.204873 ], [ 117.244678, -31.165718 ], [ 117.245622, -31.156115 ], [ 117.246094, -31.154535 ], [ 117.248390, -31.146878 ], [ 117.252874, -31.138338 ], [ 117.258925, -31.130826 ], [ 117.262037, -31.128199 ], [ 117.263775, -31.126730 ], [ 117.328084, -31.126730 ], [ 117.328084, -31.127887 ], [ 117.327976, -31.127924 ] ] ] } }
{ "type": "Feature", "id": 10959577660569731, "properties": { "country": "au", "text": "Wyalkatchem" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 117.328084, -31.126730 ], [ 117.328084, -31.127887 ], [ 117.327976, -31.127924 ], [ 117.327976, -31.142507 ], [ 117.324543, -31.142507 ], [ 117.324543, -31.152699 ], [ 117.326238, -31.152699 ], [ 117.326238, -31.162541 ], [ 117.323921, -31.162229 ], [ 117.295618, -31.165571 ], [ 117.294674, -31.165773 ], [ 117.294631, -31.203405 ], [ 117.294631, -31.204873 ], [ 117.244613, -31.204873 ], [ 117.244678, -31.165718 ], [ 117.245622, -31.156115 ], [ 117.246094, -31.154535 ], [ 117.248390, -31.146878 ], [ 117.252874, -31.138338 ], [ 117.258925, -31.130826 ], [ 117.262037, -31.128199 ], [ 117.263775, -31.126730 ], [ 117.328084, -31.126730 ] ] ] } }
] }
] }
,
{ "type": "FeatureCollection", "properties": { "zoom": 12, "x": 3382, "y": 2420 }, "features": [
{ "type": "FeatureCollection", "properties": { "layer": "data", "version": 2, "extent": 4096 }, "features": [
{ "type": "Feature", "id": 10959577660569731, "properties": { "country": "au", "text": "Wyalkatchem" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 117.328084, -31.127887 ], [ 117.327976, -31.127924 ], [ 117.327976, -31.129669 ], [ 117.260277, -31.129669 ], [ 117.262037, -31.128199 ], [ 117.266307, -31.124599 ], [ 117.274740, -31.119915 ], [ 117.278044, -31.118850 ], [ 117.278087, -31.112163 ], [ 117.279117, -31.102444 ], [ 117.281992, -31.093128 ], [ 117.286627, -31.084547 ], [ 117.292850, -31.077012 ], [ 117.300425, -31.070855 ], [ 117.309029, -31.066260 ], [ 117.315123, -31.064422 ], [ 117.317870, -31.062088 ], [ 117.326474, -31.057235 ], [ 117.333984, -31.054809 ], [ 117.335701, -31.054258 ], [ 117.335701, -31.112493 ], [ 117.328084, -31.112493 ], [ 117.328084, -31.127887 ] ] ] } }
{ "type": "Feature", "id": 10959577660569731, "properties": { "country": "au", "text": "Wyalkatchem" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 117.335701, -31.054258 ], [ 117.335701, -31.112493 ], [ 117.328084, -31.112493 ], [ 117.328084, -31.127887 ], [ 117.327976, -31.127924 ], [ 117.327976, -31.129669 ], [ 117.260277, -31.129669 ], [ 117.262037, -31.128199 ], [ 117.266307, -31.124599 ], [ 117.274740, -31.119915 ], [ 117.278044, -31.118850 ], [ 117.278087, -31.112163 ], [ 117.279117, -31.102444 ], [ 117.281992, -31.093128 ], [ 117.286627, -31.084547 ], [ 117.292850, -31.077012 ], [ 117.300425, -31.070855 ], [ 117.309029, -31.066260 ], [ 117.315123, -31.064422 ], [ 117.317870, -31.062088 ], [ 117.326474, -31.057235 ], [ 117.333984, -31.054809 ], [ 117.335701, -31.054258 ] ] ] } }
] }
] }
,
{ "type": "FeatureCollection", "properties": { "zoom": 12, "x": 3382, "y": 2419 }, "features": [
{ "type": "FeatureCollection", "properties": { "layer": "data", "version": 2, "extent": 4096 }, "features": [
{ "type": "Feature", "id": 10959577660569731, "properties": { "country": "au", "text": "Wyalkatchem" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 117.335701, -31.054405 ], [ 117.335229, -31.054405 ], [ 117.335701, -31.054258 ], [ 117.335701, -31.054405 ] ] ] } }
{ "type": "Feature", "id": 10959577660569731, "properties": { "country": "au", "text": "Wyalkatchem" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 117.335701, -31.054258 ], [ 117.335701, -31.054405 ], [ 117.335229, -31.054405 ], [ 117.335701, -31.054258 ] ] ] } }
] }
] }
,
{ "type": "FeatureCollection", "properties": { "zoom": 12, "x": 3383, "y": 2425 }, "features": [
{ "type": "FeatureCollection", "properties": { "layer": "data", "version": 2, "extent": 4096 }, "features": [
{ "type": "Feature", "id": 10959577660569731, "properties": { "country": "au", "text": "Wyalkatchem" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 117.368317, -31.436737 ], [ 117.368295, -31.433753 ], [ 117.397928, -31.433716 ], [ 117.397950, -31.439136 ], [ 117.409687, -31.439154 ], [ 117.409945, -31.438989 ], [ 117.423592, -31.438989 ], [ 117.423592, -31.488992 ], [ 117.411275, -31.488992 ], [ 117.409623, -31.489157 ], [ 117.397864, -31.489139 ], [ 117.388144, -31.488169 ], [ 117.379174, -31.485424 ], [ 117.378080, -31.485772 ], [ 117.368317, -31.486723 ], [ 117.335165, -31.486742 ], [ 117.333984, -31.486613 ], [ 117.332268, -31.486449 ], [ 117.332268, -31.427198 ], [ 117.335143, -31.427198 ], [ 117.335143, -31.436737 ], [ 117.368317, -31.436737 ] ] ] } }
{ "type": "Feature", "id": 10959577660569731, "properties": { "country": "au", "text": "Wyalkatchem" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 117.335143, -31.427198 ], [ 117.335143, -31.436737 ], [ 117.368317, -31.436737 ], [ 117.368295, -31.433753 ], [ 117.397928, -31.433716 ], [ 117.397950, -31.439136 ], [ 117.409687, -31.439154 ], [ 117.409945, -31.438989 ], [ 117.423592, -31.438989 ], [ 117.423592, -31.488992 ], [ 117.411275, -31.488992 ], [ 117.409623, -31.489157 ], [ 117.397864, -31.489139 ], [ 117.388144, -31.488169 ], [ 117.379174, -31.485424 ], [ 117.378080, -31.485772 ], [ 117.368317, -31.486723 ], [ 117.335165, -31.486742 ], [ 117.333984, -31.486613 ], [ 117.332268, -31.486449 ], [ 117.332268, -31.427198 ], [ 117.335143, -31.427198 ] ] ] } }
] }
] }
,
{ "type": "FeatureCollection", "properties": { "zoom": 12, "x": 3383, "y": 2424 }, "features": [
{ "type": "FeatureCollection", "properties": { "layer": "data", "version": 2, "extent": 4096 }, "features": [
{ "type": "Feature", "id": 10959577660569731, "properties": { "country": "au", "text": "Wyalkatchem" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 117.338190, -31.411212 ], [ 117.338190, -31.423152 ], [ 117.335143, -31.423152 ], [ 117.335143, -31.430128 ], [ 117.332268, -31.430128 ], [ 117.332268, -31.411212 ], [ 117.338190, -31.411212 ] ] ] } }
{ "type": "Feature", "id": 10959577660569731, "properties": { "country": "au", "text": "Wyalkatchem" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 117.332268, -31.411212 ], [ 117.338190, -31.411212 ], [ 117.338190, -31.423152 ], [ 117.335143, -31.423152 ], [ 117.335143, -31.430128 ], [ 117.332268, -31.430128 ], [ 117.332268, -31.411212 ] ] ] } }
] }
] }
,
{ "type": "FeatureCollection", "properties": { "zoom": 12, "x": 3383, "y": 2420 }, "features": [
{ "type": "FeatureCollection", "properties": { "layer": "data", "version": 2, "extent": 4096 }, "features": [
{ "type": "Feature", "id": 10959577660569731, "properties": { "country": "au", "text": "Wyalkatchem" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 117.335873, -31.054202 ], [ 117.336302, -31.054110 ], [ 117.346945, -31.052952 ], [ 117.359884, -31.052952 ], [ 117.368724, -31.053743 ], [ 117.369132, -31.053853 ], [ 117.369905, -31.053853 ], [ 117.377372, -31.052934 ], [ 117.378724, -31.052769 ], [ 117.423592, -31.052732 ], [ 117.423592, -31.102738 ], [ 117.421875, -31.102738 ], [ 117.378745, -31.102775 ], [ 117.376707, -31.103859 ], [ 117.362309, -31.103859 ], [ 117.359884, -31.102958 ], [ 117.346945, -31.102958 ], [ 117.346537, -31.103050 ], [ 117.346430, -31.103656 ], [ 117.346430, -31.112493 ], [ 117.332268, -31.112493 ], [ 117.332268, -31.055360 ], [ 117.335873, -31.054202 ] ] ] } }
{ "type": "Feature", "id": 10959577660569731, "properties": { "country": "au", "text": "Wyalkatchem" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 117.423592, -31.052732 ], [ 117.423592, -31.102738 ], [ 117.421875, -31.102738 ], [ 117.378745, -31.102775 ], [ 117.376707, -31.103859 ], [ 117.362309, -31.103859 ], [ 117.359884, -31.102958 ], [ 117.346945, -31.102958 ], [ 117.346537, -31.103050 ], [ 117.346430, -31.103656 ], [ 117.346430, -31.112493 ], [ 117.332268, -31.112493 ], [ 117.332268, -31.055360 ], [ 117.335873, -31.054202 ], [ 117.336302, -31.054110 ], [ 117.346945, -31.052952 ], [ 117.359884, -31.052952 ], [ 117.368724, -31.053743 ], [ 117.369132, -31.053853 ], [ 117.369905, -31.053853 ], [ 117.377372, -31.052934 ], [ 117.378724, -31.052769 ], [ 117.423592, -31.052732 ] ] ] } }
] }
] }
,
{ "type": "FeatureCollection", "properties": { "zoom": 12, "x": 3383, "y": 2419 }, "features": [
{ "type": "FeatureCollection", "properties": { "layer": "data", "version": 2, "extent": 4096 }, "features": [
{ "type": "Feature", "id": 10959577660569731, "properties": { "country": "au", "text": "Wyalkatchem" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 117.423592, -31.054405 ], [ 117.335229, -31.054405 ], [ 117.335873, -31.054202 ], [ 117.336302, -31.054110 ], [ 117.346945, -31.052952 ], [ 117.359884, -31.052952 ], [ 117.368724, -31.053743 ], [ 117.369132, -31.053853 ], [ 117.369905, -31.053853 ], [ 117.377372, -31.052934 ], [ 117.378724, -31.052769 ], [ 117.421875, -31.052732 ], [ 117.423592, -31.052732 ], [ 117.423592, -31.054405 ] ] ] } }
{ "type": "Feature", "id": 10959577660569731, "properties": { "country": "au", "text": "Wyalkatchem" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 117.423592, -31.052732 ], [ 117.423592, -31.054405 ], [ 117.335229, -31.054405 ], [ 117.335873, -31.054202 ], [ 117.336302, -31.054110 ], [ 117.346945, -31.052952 ], [ 117.359884, -31.052952 ], [ 117.368724, -31.053743 ], [ 117.369132, -31.053853 ], [ 117.369905, -31.053853 ], [ 117.377372, -31.052934 ], [ 117.378724, -31.052769 ], [ 117.421875, -31.052732 ], [ 117.423592, -31.052732 ] ] ] } }
] }
] }
,
{ "type": "FeatureCollection", "properties": { "zoom": 12, "x": 3384, "y": 2425 }, "features": [
{ "type": "FeatureCollection", "properties": { "layer": "data", "version": 2, "extent": 4096 }, "features": [
{ "type": "Feature", "id": 10959577660569731, "properties": { "country": "au", "text": "Wyalkatchem" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 117.421875, -31.438989 ], [ 117.435780, -31.439044 ], [ 117.435780, -31.427198 ], [ 117.485776, -31.427198 ], [ 117.485776, -31.439044 ], [ 117.484810, -31.448820 ], [ 117.481956, -31.458210 ], [ 117.477322, -31.466868 ], [ 117.471099, -31.474444 ], [ 117.463503, -31.480666 ], [ 117.454834, -31.485278 ], [ 117.445436, -31.488114 ], [ 117.435672, -31.489047 ], [ 117.421875, -31.488992 ], [ 117.420158, -31.488992 ], [ 117.420158, -31.438989 ], [ 117.421875, -31.438989 ] ] ] } }
{ "type": "Feature", "id": 10959577660569731, "properties": { "country": "au", "text": "Wyalkatchem" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 117.485776, -31.427198 ], [ 117.485776, -31.439044 ], [ 117.484810, -31.448820 ], [ 117.481956, -31.458210 ], [ 117.477322, -31.466868 ], [ 117.471099, -31.474444 ], [ 117.463503, -31.480666 ], [ 117.454834, -31.485278 ], [ 117.445436, -31.488114 ], [ 117.435672, -31.489047 ], [ 117.421875, -31.488992 ], [ 117.420158, -31.488992 ], [ 117.420158, -31.438989 ], [ 117.421875, -31.438989 ], [ 117.435780, -31.439044 ], [ 117.435780, -31.427198 ], [ 117.485776, -31.427198 ] ] ] } }
] }
] }
,
{ "type": "FeatureCollection", "properties": { "zoom": 12, "x": 3384, "y": 2424 }, "features": [
{ "type": "FeatureCollection", "properties": { "layer": "data", "version": 2, "extent": 4096 }, "features": [
{ "type": "Feature", "id": 10959577660569731, "properties": { "country": "au", "text": "Wyalkatchem" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 117.435672, -31.407989 ], [ 117.435694, -31.354278 ], [ 117.435801, -31.353637 ], [ 117.436059, -31.352171 ], [ 117.487450, -31.352171 ], [ 117.486656, -31.353637 ], [ 117.485948, -31.354498 ], [ 117.485690, -31.357448 ], [ 117.485669, -31.406909 ], [ 117.485776, -31.407989 ], [ 117.485776, -31.430128 ], [ 117.435780, -31.430128 ], [ 117.435780, -31.407989 ], [ 117.435672, -31.407989 ] ] ] } }
{ "type": "Feature", "id": 10959577660569731, "properties": { "country": "au", "text": "Wyalkatchem" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 117.486656, -31.353637 ], [ 117.485948, -31.354498 ], [ 117.485690, -31.357448 ], [ 117.485669, -31.406909 ], [ 117.485776, -31.407989 ], [ 117.485776, -31.430128 ], [ 117.435780, -31.430128 ], [ 117.435780, -31.407989 ], [ 117.435672, -31.407989 ], [ 117.435694, -31.354278 ], [ 117.435801, -31.353637 ], [ 117.436059, -31.352171 ], [ 117.487450, -31.352171 ], [ 117.486656, -31.353637 ] ] ] } }
] }
] }
,
{ "type": "FeatureCollection", "properties": { "zoom": 12, "x": 3384, "y": 2423 }, "features": [
{ "type": "FeatureCollection", "properties": { "layer": "data", "version": 2, "extent": 4096 }, "features": [
{ "type": "Feature", "id": 10959577660569731, "properties": { "country": "au", "text": "Wyalkatchem" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 117.435801, -31.353637 ], [ 117.436252, -31.351218 ], [ 117.436252, -31.340278 ], [ 117.436144, -31.340278 ], [ 117.436187, -31.325762 ], [ 117.445157, -31.325780 ], [ 117.445178, -31.304698 ], [ 117.447710, -31.299712 ], [ 117.447710, -31.277084 ], [ 117.497706, -31.277084 ], [ 117.497706, -31.299767 ], [ 117.496333, -31.311353 ], [ 117.495153, -31.314525 ], [ 117.495153, -31.325835 ], [ 117.494187, -31.335586 ], [ 117.491312, -31.344951 ], [ 117.486656, -31.353637 ], [ 117.485948, -31.354498 ], [ 117.485883, -31.355103 ], [ 117.435672, -31.355103 ], [ 117.435694, -31.354278 ], [ 117.435801, -31.353637 ] ] ] } }
{ "type": "Feature", "id": 10959577660569731, "properties": { "country": "au", "text": "Wyalkatchem" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 117.497706, -31.299767 ], [ 117.496333, -31.311353 ], [ 117.495153, -31.314525 ], [ 117.495153, -31.325835 ], [ 117.494187, -31.335586 ], [ 117.491312, -31.344951 ], [ 117.486656, -31.353637 ], [ 117.485948, -31.354498 ], [ 117.485883, -31.355103 ], [ 117.435672, -31.355103 ], [ 117.435694, -31.354278 ], [ 117.435801, -31.353637 ], [ 117.436252, -31.351218 ], [ 117.436252, -31.340278 ], [ 117.436144, -31.340278 ], [ 117.436187, -31.325762 ], [ 117.445157, -31.325780 ], [ 117.445178, -31.304698 ], [ 117.447710, -31.299712 ], [ 117.447710, -31.277084 ], [ 117.497706, -31.277084 ], [ 117.497706, -31.299767 ] ] ] } }
] }
] }
,
{ "type": "FeatureCollection", "properties": { "zoom": 12, "x": 3384, "y": 2422 }, "features": [
{ "type": "FeatureCollection", "properties": { "layer": "data", "version": 2, "extent": 4096 }, "features": [
{ "type": "Feature", "id": 10959577660569731, "properties": { "country": "au", "text": "Wyalkatchem" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 117.447731, -31.266538 ], [ 117.448440, -31.265823 ], [ 117.448440, -31.245462 ], [ 117.448397, -31.204525 ], [ 117.447646, -31.204800 ], [ 117.446809, -31.205295 ], [ 117.446079, -31.205938 ], [ 117.445049, -31.207296 ], [ 117.444191, -31.208158 ], [ 117.443140, -31.208801 ], [ 117.441938, -31.209204 ], [ 117.440715, -31.209333 ], [ 117.426531, -31.209516 ], [ 117.426531, -31.201937 ], [ 117.498114, -31.201937 ], [ 117.498264, -31.203405 ], [ 117.498393, -31.204488 ], [ 117.498436, -31.265786 ], [ 117.497728, -31.273086 ], [ 117.497706, -31.278551 ], [ 117.497706, -31.280018 ], [ 117.447710, -31.280018 ], [ 117.447710, -31.278551 ], [ 117.447731, -31.266538 ] ] ] } }
{ "type": "Feature", "id": 10959577660569731, "properties": { "country": "au", "text": "Wyalkatchem" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 117.498264, -31.203405 ], [ 117.498393, -31.204488 ], [ 117.498436, -31.265786 ], [ 117.497728, -31.273086 ], [ 117.497706, -31.278551 ], [ 117.497706, -31.280018 ], [ 117.447710, -31.280018 ], [ 117.447710, -31.278551 ], [ 117.447731, -31.266538 ], [ 117.448440, -31.265823 ], [ 117.448440, -31.245462 ], [ 117.448397, -31.204525 ], [ 117.447646, -31.204800 ], [ 117.446809, -31.205295 ], [ 117.446079, -31.205938 ], [ 117.445049, -31.207296 ], [ 117.444191, -31.208158 ], [ 117.443140, -31.208801 ], [ 117.441938, -31.209204 ], [ 117.440715, -31.209333 ], [ 117.426531, -31.209516 ], [ 117.426531, -31.201937 ], [ 117.498114, -31.201937 ], [ 117.498264, -31.203405 ] ] ] } }
] }
] }
,
{ "type": "FeatureCollection", "properties": { "zoom": 12, "x": 3384, "y": 2421 }, "features": [
{ "type": "FeatureCollection", "properties": { "layer": "data", "version": 2, "extent": 4096 }, "features": [
{ "type": "Feature", "id": 10959577660569731, "properties": { "country": "au", "text": "Wyalkatchem" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 117.447646, -31.204800 ], [ 117.447517, -31.204873 ], [ 117.426531, -31.204873 ], [ 117.426531, -31.203405 ], [ 117.426553, -31.200266 ], [ 117.428656, -31.200266 ], [ 117.428656, -31.195421 ], [ 117.441316, -31.195421 ], [ 117.441316, -31.190997 ], [ 117.443440, -31.190997 ], [ 117.443440, -31.183746 ], [ 117.435415, -31.183728 ], [ 117.435415, -31.170326 ], [ 117.441466, -31.170161 ], [ 117.445757, -31.169647 ], [ 117.445693, -31.128199 ], [ 117.445693, -31.126730 ], [ 117.495689, -31.126730 ], [ 117.495689, -31.128199 ], [ 117.495775, -31.169592 ], [ 117.494702, -31.179891 ], [ 117.493565, -31.183471 ], [ 117.494724, -31.185711 ], [ 117.497470, -31.194925 ], [ 117.498286, -31.203405 ], [ 117.498393, -31.204488 ], [ 117.498393, -31.204873 ], [ 117.448397, -31.204873 ], [ 117.448397, -31.204525 ], [ 117.447646, -31.204800 ] ] ] } }
{ "type": "Feature", "id": 10959577660569731, "properties": { "country": "au", "text": "Wyalkatchem" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 117.495689, -31.128199 ], [ 117.495775, -31.169592 ], [ 117.494702, -31.179891 ], [ 117.493565, -31.183471 ], [ 117.494724, -31.185711 ], [ 117.497470, -31.194925 ], [ 117.498286, -31.203405 ], [ 117.498393, -31.204488 ], [ 117.498393, -31.204873 ], [ 117.448397, -31.204873 ], [ 117.448397, -31.204525 ], [ 117.447646, -31.204800 ], [ 117.447517, -31.204873 ], [ 117.426531, -31.204873 ], [ 117.426531, -31.203405 ], [ 117.426553, -31.200266 ], [ 117.428656, -31.200266 ], [ 117.428656, -31.195421 ], [ 117.441316, -31.195421 ], [ 117.441316, -31.190997 ], [ 117.443440, -31.190997 ], [ 117.443440, -31.183746 ], [ 117.435415, -31.183728 ], [ 117.435415, -31.170326 ], [ 117.441466, -31.170161 ], [ 117.445757, -31.169647 ], [ 117.445693, -31.128199 ], [ 117.445693, -31.126730 ], [ 117.495689, -31.126730 ], [ 117.495689, -31.128199 ] ] ] } }
] }
] }
,
{ "type": "FeatureCollection", "properties": { "zoom": 12, "x": 3384, "y": 2420 }, "features": [
{ "type": "FeatureCollection", "properties": { "layer": "data", "version": 2, "extent": 4096 }, "features": [
{ "type": "Feature", "id": 10959577660569731, "properties": { "country": "au", "text": "Wyalkatchem" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 117.445672, -31.102738 ], [ 117.420158, -31.102738 ], [ 117.420158, -31.052732 ], [ 117.445650, -31.052732 ], [ 117.447710, -31.052934 ], [ 117.455392, -31.053688 ], [ 117.464769, -31.056519 ], [ 117.473416, -31.061132 ], [ 117.480991, -31.067345 ], [ 117.487214, -31.074917 ], [ 117.491848, -31.083554 ], [ 117.494702, -31.092926 ], [ 117.495668, -31.102664 ], [ 117.495689, -31.128199 ], [ 117.495711, -31.129669 ], [ 117.445693, -31.129669 ], [ 117.445693, -31.128199 ], [ 117.445672, -31.102738 ] ] ] } }
{ "type": "Feature", "id": 10959577660569731, "properties": { "country": "au", "text": "Wyalkatchem" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 117.445650, -31.052732 ], [ 117.447710, -31.052934 ], [ 117.455392, -31.053688 ], [ 117.464769, -31.056519 ], [ 117.473416, -31.061132 ], [ 117.480991, -31.067345 ], [ 117.487214, -31.074917 ], [ 117.491848, -31.083554 ], [ 117.494702, -31.092926 ], [ 117.495668, -31.102664 ], [ 117.495689, -31.128199 ], [ 117.495711, -31.129669 ], [ 117.445693, -31.129669 ], [ 117.445693, -31.128199 ], [ 117.445672, -31.102738 ], [ 117.420158, -31.102738 ], [ 117.420158, -31.052732 ], [ 117.445650, -31.052732 ] ] ] } }
] }
] }
,
{ "type": "FeatureCollection", "properties": { "zoom": 12, "x": 3384, "y": 2419 }, "features": [
{ "type": "FeatureCollection", "properties": { "layer": "data", "version": 2, "extent": 4096 }, "features": [
{ "type": "Feature", "id": 10959577660569731, "properties": { "country": "au", "text": "Wyalkatchem" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 117.447710, -31.052934 ], [ 117.455392, -31.053688 ], [ 117.457752, -31.054405 ], [ 117.420158, -31.054405 ], [ 117.420158, -31.052732 ], [ 117.445650, -31.052732 ], [ 117.447710, -31.052934 ] ] ] } }
{ "type": "Feature", "id": 10959577660569731, "properties": { "country": "au", "text": "Wyalkatchem" }, "geometry": { "type": "Polygon", "coordinates": [ [ [ 117.445650, -31.052732 ], [ 117.447710, -31.052934 ], [ 117.455392, -31.053688 ], [ 117.457752, -31.054405 ], [ 117.420158, -31.052732 ], [ 117.445650, -31.052732 ] ] ] } }
] }
] }
] }

2
version.hpp
View File

@ -1 +1 @@
#define VERSION "tippecanoe v1.15.4\n"
#define VERSION "tippecanoe v1.16.0\n"