public void ClipHardAtTileBoundary(string fileName)
{
string fullFileName = Path.Combine(fixturesPath, fileName);
Assert.True(File.Exists(fullFileName), "Vector tile exists");
byte[] data = File.ReadAllBytes(fullFileName);
VectorTile vt = new VectorTile(data);
Assert.GreaterOrEqual(vt.LayerNames().Count, 1, "At least one layer");
string geojson = vt.ToGeoJson(0, 0, 0);
Assert.GreaterOrEqual(geojson.Length, 30, "geojson >= 30 chars");
foreach (var lyrName in vt.LayerNames())
{
VectorTileLayer lyr = vt.GetLayer(lyrName);
for (int i = 0; i < lyr.FeatureCount(); i++)
{
Debug.WriteLine("{0} lyr:{1} feat:{2}", fileName, lyr.Name, i);
VectorTileFeature feat = lyr.GetFeature(i, 0);
long extent = (long)lyr.Extent;
foreach (var part in feat.Geometry <int>())
{
foreach (var geom in part)
{
Assert.GreaterOrEqual(geom.X, 0, "geom.X equal or greater 0");
Assert.GreaterOrEqual(geom.Y, 0, "geom.Y eqaul or greater 0");
Assert.LessOrEqual(geom.X, extent, "geom.X less or equal extent");
Assert.LessOrEqual(geom.Y, extent, "geom.Y less or equal extent");
}
}
}
}
}
public void AtLeastOneLayer(string fileName)
{
string fullFileName = Path.Combine(fixturesPath, fileName);
Assert.True(File.Exists(fullFileName), "Vector tile exists");
byte[] data = File.ReadAllBytes(fullFileName);
VectorTile vt = new VectorTile(data);
Assert.GreaterOrEqual(vt.LayerNames().Count, 1, "At least one layer");
string geojson = vt.ToGeoJson(0, 0, 0);
Assert.GreaterOrEqual(geojson.Length, 30, "geojson >= 30 chars");
foreach (var lyrName in vt.LayerNames())
{
VectorTileLayer lyr = vt.GetLayer(lyrName);
for (int i = 0; i < lyr.FeatureCount(); i++)
{
Debug.WriteLine("{0} lyr:{1} feat:{2}", fileName, lyr.Name, i);
VectorTileFeature feat = lyr.GetFeature(i);
long extent = (long)lyr.Extent;
foreach (var part in feat.Geometry <long>())
{
foreach (var geom in part)
{
if (geom.X < 0 || geom.Y < 0 || geom.X > extent || geom.Y > extent)
{
Debug.WriteLine("{0} lyr:{1} feat:{2} x:{3} y:{4}", fileName, lyr.Name, i, geom.X, geom.Y);
}
}
}
}
}
}
public void Clipping(string fileName)
{
string fullFileName = Path.Combine(fixturesPath, fileName);
Assert.True(File.Exists(fullFileName), "Vector tile exists");
byte[] data = File.ReadAllBytes(fullFileName);
VectorTile vt = new VectorTile(data);
foreach (var lyrName in vt.LayerNames())
{
VectorTileLayer lyr = vt.GetLayer(lyrName);
for (int i = 0; i < lyr.FeatureCount(); i++)
{
VectorTileFeature feat = lyr.GetFeature(i);
//skip features with unknown geometry type
if (feat.GeometryType == GeomType.UNKNOWN)
{
continue;
}
List <List <Point2d <long> > > geomRaw = feat.Geometry <long>();
List <List <Point2d <long> > > geomClipped = feat.Geometry <long>(0);
for (int j = 0; j < geomRaw.Count; j++)
{
List <Point2d <long> > part = geomRaw[j];
List <Point2d <long> > partClipped = geomClipped[j];
// Workaround to compare parts as clipping may or may not change the order of vertices
// This only works if no actual clipping is done
Assert.False(part.Except(partClipped).Any(), $"{fileName}, feature[{i}], geometry part[{j}]: geometry parts don't match after clipping");
}
}
}
}
public void Scaling(string fileName)
{
float[] scales = new float[] { 1.5f, 2.25f, 5.75f, 197.3f };
string fullFileName = Path.Combine(fixturesPath, fileName);
byte[] data = File.ReadAllBytes(fullFileName);
VectorTile vt = new VectorTile(data);
foreach (var lyrName in vt.LayerNames())
{
VectorTileLayer lyr = vt.GetLayer(lyrName);
int featCnt = lyr.FeatureCount();
for (int idxFeat = 0; idxFeat < featCnt; idxFeat++)
{
VectorTileFeature feat = lyr.GetFeature(idxFeat);
List <List <Point2d <int> > > rawParts = feat.Geometry <int>();
for (int idxPart = 0; idxPart < rawParts.Count; idxPart++)
{
List <Point2d <int> > rawGeom = rawParts[idxPart];
foreach (var scale in scales)
{
List <List <Point2d <float> > > scaledParts = feat.Geometry <float>(null, scale);
List <Point2d <float> > scaledGeom = scaledParts[idxPart];
for (int idxVertex = 0; idxVertex < rawGeom.Count; idxVertex++)
{
Point2d <int> rawVertex = rawGeom[idxVertex];
Point2d <float> scaledVertex = scaledGeom[idxVertex];
Assert.AreEqual(scale * (float)rawVertex.X, scaledVertex.X, $"{fileName}, feature[{idxFeat}], geometry part[{idxPart}], vertex[{idxVertex}], scale[{scale}]: X does not match");
Assert.AreEqual(scale * (float)rawVertex.Y, scaledVertex.Y, $"{fileName}, feature[{idxFeat}], geometry part[{idxPart}], vertex[{idxVertex}], scale[{scale}]: Y does not match");
}
}
}
}
}
}
public void LazyDecoding(string fileName)
{
string fullFileName = Path.Combine(fixturesPath, fileName);
Assert.True(File.Exists(fullFileName), "Vector tile exists");
byte[] data = File.ReadAllBytes(fullFileName);
VectorTile vt = new VectorTile(data);
foreach (var layerName in vt.LayerNames())
{
VectorTileLayer layer = vt.GetLayer(layerName);
for (int i = 0; i < layer.FeatureCount(); i++)
{
VectorTileFeature feat = layer.GetFeature(i);
var properties = feat.GetProperties();
foreach (var prop in properties)
{
Assert.AreEqual(prop.Value, feat.GetValue(prop.Key), "Property values match");
}
foreach (var geomPart in feat.Geometry <int>())
{
foreach (var coord in geomPart)
{
//TODO add Assert
}
}
}
}
string geojson = vt.ToGeoJson(0, 0, 0);
Assert.GreaterOrEqual(geojson.Length, 30, "geojson >= 30 chars");
}
public int ShowAttractions(Geometry geometry)
{
int result = 0;
var request = new SearchRequest();
request.Projection = Projection;
request.Geometry = geometry;
request.SearchRadius = 500.0f;
request.FilterExpression = "class='attraction'";
var results = Service.FindFeatures(request);
for (int i = 0; i < results.FeatureCount; i++)
{
VectorTileFeature item = results.GetFeature(i);
if (item.Geometry is PointGeometry)
{
AddPointOfInterest(item);
result += 1;
}
}
return(result);
}
/// <summary>
/// >Geometry in LatLng coordinates instead of internal tile coordinates
/// </summary>
/// <param name="feature"></param>
/// <param name="zoom">Zoom level of the tile</param>
/// <param name="tileColumn">Column of the tile (OSM tile schema)</param>
/// <param name="tileRow">Row of the tile (OSM tile schema)</param>
/// <returns></returns>
public static List <List <LatLng> > GeometryAsWgs84(
this VectorTileFeature feature
, ulong zoom
, ulong tileColumn
, ulong tileRow
)
{
List <List <LatLng> > geometryAsWgs84 = new List <List <LatLng> >();
foreach (var part in feature.Geometry)
{
#if NET20
List <LatLng> partAsWgs84 = new List <LatLng>();
foreach (var partGeom in part)
{
partAsWgs84.Add(partGeom.ToLngLat(zoom, tileColumn, tileRow, feature.Layer.Extent));
}
geometryAsWgs84.Add(partAsWgs84);
#else
geometryAsWgs84.Add(
part.Select(g => g.ToLngLat(zoom, tileColumn, tileRow, feature.Layer.Extent)).ToList()
);
#endif
}
return(geometryAsWgs84);
}
public static List <List <LatLng> > GeometryAsWgs84Optimized(
this VectorTileFeature feature
, List <List <LatLng> > geometryAsWgs84
, ulong zoom
, ulong tileColumn
, ulong tileRow
, uint?clipBuffer = null
)
{
foreach (var part in feature.Geometry <long>(clipBuffer, 1.0f))
{
geometryAsWgs84.Clear();
#if NET20
List <LatLng> partAsWgs84 = new List <LatLng>();
foreach (var partGeom in part)
{
partAsWgs84.Add(partGeom.ToLngLat(zoom, tileColumn, tileRow, feature.Layer.Extent));
}
geometryAsWgs84.Add(partAsWgs84);
#else
geometryAsWgs84.Add(
part.Select(g => g.ToLngLat(zoom, tileColumn, tileRow, feature.Layer.Extent)).ToList()
);
#endif
}
return(geometryAsWgs84);
}
public override GOFeature ParseFeatureData(VectorTileFeature feature, GOLayer layer)
{
IDictionary properties = feature.GetProperties();
GOFeature goFeature;
if (layer.layerType == GOLayer.GOLayerType.Roads)
{
goFeature = new GORoadFeature();
}
else
{
goFeature = new GOFeature();
}
goFeature.kind = GOEnumUtils.MapboxToKind(layer.name);
goFeature.y = layer.defaultLayerY();
if (properties.Contains("_symbol"))
{
goFeature.y = Convert.ToInt64(properties ["_symbol"]) / 10.0f * Global.tilesizeRank;
}
goFeature.height = layer.defaultRendering.polygonHeight;
return(goFeature);
}
private void Build(VectorTileFeature feature, Rect rect, Texture2D height, GameObject parent, Tile.Parameters parameters)
{
foreach (var geometry in feature.GeometryAsWgs84((ulong)parameters.Id.Z, (ulong)parameters.Id.X, (ulong)parameters.Id.Y))
{
var meshData = new MeshData();
//we'll run all visualizers on MeshData here
var list = geometry.Select(wgs84 => GM.LatLonToMeters(wgs84.Lat, wgs84.Lng).ToVector3xz()).ToList();
meshData.Vertices = list.Select(vertex =>
{
var cord = vertex - rect.center.ToVector3xz();
var rx = (vertex.x - rect.min.x) / rect.width;
var ry = 1 - (vertex.z - rect.min.y) / rect.height;
var h = height == null ? 0 : GetHeightFromColor(height.GetPixel(
(int)Mathf.Clamp((rx * 256), 0, 255),
(int)Mathf.Clamp((ry * 256), 0, 255)));
cord.y += h;
return(cord);
}).ToList();
foreach (var mod in Modifiers)
{
mod.Run(feature, meshData);
}
CreateGameObject(meshData, parent);
}
}
public VectorFeatureUnity(VectorTileFeature feature, UnityTile tile, float layerExtent, bool buildingsWithUniqueIds = false)
{
Data = feature;
Properties = Data.GetProperties();
Points.Clear();
//this is a temp hack until we figure out how streets ids works
if (buildingsWithUniqueIds == true) //ids from building dataset is big ulongs
{
_geom = feature.Geometry <float>(); //and we're not clipping by passing no parameters
}
else //streets ids, will require clipping
{
_geom = feature.Geometry <float>(0); //passing zero means clip at tile edge
}
_rectSizex = tile.Rect.Size.x;
_rectSizey = tile.Rect.Size.y;
_geomCount = _geom.Count;
for (int i = 0; i < _geomCount; i++)
{
_pointCount = _geom[i].Count;
_newPoints = new List <Vector3>(_pointCount);
for (int j = 0; j < _pointCount; j++)
{
var point = _geom[i][j];
_newPoints.Add(new Vector3((float)(point.X / layerExtent * _rectSizex - (_rectSizex / 2)) * tile.TileScale, 0, (float)((layerExtent - point.Y) / layerExtent * _rectSizey - (_rectSizey / 2)) * tile.TileScale));
}
Points.Add(_newPoints);
}
}
public IEnumerable <VectorTileFeature> Wrap(VectorTileFeature feature, double buffer, Func <double[], double[], double, double[]> intersectX)
{
//var merged = new List<VectorTileFeature> { feature };
var left = Clipper.Clip(feature, 1, -1 - buffer, buffer, 0, intersectX, -1, 2); //Left world copy;
var right = Clipper.Clip(feature, 1, 1 - buffer, 2 + buffer, 0, intersectX, -1, 2); //Right world copy;
var hasLeft = left != null;
var hasRight = right != null;
if (hasLeft || hasRight)
{
var center = Clipper.Clip(feature, 1, -buffer, 1 + buffer, 0, intersectX, -1, 2);//Center world copy;
if (center != null)
{
yield return(center);
}
if (hasLeft)
{
yield return(ShiftFeatureCoords(left, 1));
}
if (hasRight)
{
yield return(ShiftFeatureCoords(right, -1));
}
}
else
{
yield return(feature);
}
}
public CustomFeatureUnity(VectorTileFeature feature, CustomTile tile, float layerExtent, bool buildingsWithUniqueIds = false)
{
Data = feature;
Properties = Data.GetProperties();
Points.Clear();
Tile = tile;
//this is a temp hack until we figure out how streets ids works
_geom = buildingsWithUniqueIds ? feature.Geometry <float>() : feature.Geometry <float>(0);
_rectSizex = tile.Rect.Size.x;
_rectSizey = tile.Rect.Size.y;
_geomCount = _geom.Count;
for (var i = 0; i < _geomCount; i++)
{
_pointCount = _geom[i].Count;
_newPoints = new List <Vector3>(_pointCount);
for (var j = 0; j < _pointCount; j++)
{
var point = _geom[i][j];
_newPoints.Add(new Vector3((float)(point.X / layerExtent * _rectSizex - (_rectSizex / 2)) * tile.TileScale, 0, (float)((layerExtent - point.Y) / layerExtent * _rectSizey - (_rectSizey / 2)) * tile.TileScale));
}
Points.Add(_newPoints);
}
}
public MGLSymbol(VectorTileFeature feature, IVectorStyleLayer style)
{
Feature = feature;
Style = style;
Class = feature.Tags.ContainsKey("class") ? feature.Tags["class"].ToString() : string.Empty;
Subclass = feature.Tags.ContainsKey("subclass") ? feature.Tags["subclass"].ToString() : string.Empty;
Rank = feature.Tags.ContainsKey("rank") ? int.Parse(feature.Tags["rank"].ToString()) : 0;
}
public override void Run(VectorTileFeature feature, MeshData md)
{
var count = md.Vertices.Count;
var tempList = new Vector3[count * 2];
var uvList = new Vector2[count * 2];
Vector3 lastPos = Vector3.zero;
Vector3 norm;
var lastUv = 0f;
for (int i = 1; i < count; i++)
{
var p1 = md.Vertices[i - 1];
var p2 = md.Vertices[i];
var p3 = p2;
if (i + 1 < md.Vertices.Count)
{
p3 = md.Vertices[i + 1];
}
if (lastPos == Vector3.zero)
{
lastPos = Vector3.Lerp(p1, p2, 0f);
norm = GetNormal(p1, lastPos, p2) * Width; //road width
tempList[0] = (lastPos + norm);
tempList[count * 2 - 1] = (lastPos - norm);
uvList[0] = new Vector2(0, 0);
uvList[count * 2 - 1] = new Vector2(1, 0);
}
var dist = Vector3.Distance(lastPos, p2);
lastUv += dist;
lastPos = p2;
//lastPos = Vector3.Lerp(p1, p2, 1f);
norm = GetNormal(p1, lastPos, p3) * Width;
tempList[i] = (lastPos + norm);
tempList[2 * count - 1 - i] = (lastPos - norm);
uvList[i] = new Vector2(0, lastUv);
uvList[2 * count - 1 - i] = new Vector2(1, lastUv);
}
md.Vertices = tempList.ToList();
md.UV[0].AddRange(uvList);
var lineTri = new List <int>();
var n = md.Vertices.Count / 2;
for (int i = 0; i < n - 1; i++)
{
lineTri.Add(i);
lineTri.Add(i + 1);
lineTri.Add(2 * n - 1 - i);
lineTri.Add(i + 1);
lineTri.Add(2 * n - i - 2);
lineTri.Add(2 * n - i - 1);
}
md.Triangles.Add(lineTri);
}
public static void AddSortRankToFeatures(
this VectorTileLayer tile
)
{
for (int i = 0; i < tile.FeatureCount(); i++)
{
VectorTileFeature f = tile.GetFeature(i);
}
}
private void ParseLabelLayerToList(List <GOParsedLayer> list, VectorTile vt, GOLabelsLayer layer)
{
string[] lyrs = tile.GetLabelsStrings().Split(',');
// string kindKey = tile.GetPoisKindKey();
foreach (string l in lyrs)
{
VectorTileLayer lyr = vt.GetLayer(l);
if (lyr != null)
{
int featureCount = lyr.FeatureCount();
if (featureCount == 0)
{
continue;
}
GOParsedLayer pl = new GOParsedLayer();
pl.name = lyr.Name;
pl.labelsLayer = layer;
pl.goFeatures = new List <GOFeature> ();
for (int i = 0; i < featureCount; i++)
{
VectorTileFeature vtf = lyr.GetFeature(i);
IDictionary properties = vtf.GetProperties();
List <List <LatLng> > geomWgs = vtf.GeometryAsWgs84((ulong)goTile.zoomLevel, (ulong)goTile.tileCoordinates.x, (ulong)goTile.tileCoordinates.y, 0);
if (geomWgs.Count == 0 || geomWgs[0].Count <= 1)
{
continue;
}
GOFeature gf = new GOFeature();
gf.properties = properties;
gf.goFeatureType = vtf.GOFeatureType(geomWgs);
gf.labelsLayer = layer;
gf.featureIndex = (Int64)i + vt.LayerNames().IndexOf(lyr.Name);
gf.goTile = goTile;
gf = tile.EditLabelData(gf);
gf.goFeatureType = GOFeatureType.Label;
gf.ConvertAttributes();
if (geomWgs.Count > 0)
{
gf.geometry = geomWgs[0];
gf.ConvertGeometries();
gf.preloadedLabelData = GOSegment.FindTheLongestStreightSegment(gf.convertedGeometry, 0);
AddFatureToList(gf, pl.goFeatures);
}
}
list.Add(pl);
}
}
}
public override void Run(VectorTileFeature feature, MeshData md)
{
var uv = new List <Vector2>();
foreach (var c in md.Vertices)
{
uv.Add(new Vector2(c.x, c.z));
}
md.UV[0].AddRange(uv);
}
public override void Run(VectorTileFeature feature, MeshData md)
{
if (md.Vertices.Distinct().Count() < 3)
{
return;
}
var verts = CreateRoofTriangulation(md.Vertices);
md.Triangles.Add(verts);
}
public override bool Evaluate(VectorTileFeature feature)
{
foreach (var filter in Filters)
{
if (filter.Evaluate(feature))
{
return(true);
}
}
return(false);
}
private VectorTileFeature Create(Dictionary <string, object> properties, int type, VectorTileGeometry[] geoJsonVTPointCollection)
{
var feature = new VectorTileFeature
{
Geometry = type == 1 ? geoJsonVTPointCollection[0] : geoJsonVTPointCollection as object,
Tags = properties,
Type = type,
};
CalcBBox(feature);
return(feature);
}
private static async Task <VectorTile> baseTileToVector(object baseTile)
{
var tile = baseTile as Mapbox.VectorTile.VectorTile;
var result = new VectorTile();
foreach (var lyrName in tile.LayerNames())
{
Mapbox.VectorTile.VectorTileLayer lyr = tile.GetLayer(lyrName);
var vectorLayer = new VectorTileLayer();
vectorLayer.Name = lyrName;
for (int i = 0; i < lyr.FeatureCount(); i++)
{
Mapbox.VectorTile.VectorTileFeature feat = lyr.GetFeature(i);
var vectorFeature = new VectorTileFeature();
vectorFeature.Extent = 1;
vectorFeature.GeometryType = convertGeometryType(feat.GeometryType);
vectorFeature.Attributes = feat.GetProperties();
var vectorGeometry = new List <List <Point> >();
foreach (var points in feat.Geometry <int>())
{
var vectorPoints = new List <Point>();
foreach (var coordinate in points)
{
var dX = (double)coordinate.X / (double)lyr.Extent;
var dY = (double)coordinate.Y / (double)lyr.Extent;
vectorPoints.Add(new Point(dX, dY));
//var newX = Utils.ConvertRange(dX, extent.Left, extent.Right, 0, vectorFeature.Extent);
//var newY = Utils.ConvertRange(dY, extent.Top, extent.Bottom, 0, vectorFeature.Extent);
//vectorPoints.Add(new Point(newX, newY));
}
vectorGeometry.Add(vectorPoints);
}
vectorFeature.Geometry = vectorGeometry;
vectorLayer.Features.Add(vectorFeature);
}
result.Layers.Add(vectorLayer);
}
return(result);
}
public VectorTileFeature[] SelectLayerFeatures(VectorTile tile, string layerName)
{
var layer = tile.GetLayer(layerName);
var features = new VectorTileFeature[layer.FeatureCount()];
for (var i = 0; i < features.Length; i++)
{
features[i] = layer.GetFeature(i);
}
return(features);
}
public static GOFeatureType GOFeatureType(this VectorTileFeature feature, List <List <LatLng> > geomWgs84)
{
GOFeatureType type = GoShared.GOFeatureType.Undefined;
if (geomWgs84.Count > 1)
{
switch (feature.GeometryType)
{
case GeomType.POINT:
type = GoShared.GOFeatureType.MultiPoint;
break;
case GeomType.LINESTRING:
type = GoShared.GOFeatureType.MultiLine;
break;
case GeomType.POLYGON:
type = GoShared.GOFeatureType.MultiPolygon;
break;
default:
break;
}
}
else if (geomWgs84.Count == 1) //singlepart
{
switch (feature.GeometryType)
{
case GeomType.POINT:
type = GoShared.GOFeatureType.Point;
break;
case GeomType.LINESTRING:
type = GoShared.GOFeatureType.Line;
break;
case GeomType.POLYGON:
type = GoShared.GOFeatureType.Polygon;
break;
default:
break;
}
}
else //no geometry
{
}
return(type);
}
public static string GetFeatureType(this VectorTileFeature feature, List <List <LatLng> > geomWgs84)
{
string type = null;
if (geomWgs84.Count > 1)
{
switch (feature.GeometryType)
{
case GeomType.POINT:
type = "MultiPoint";
break;
case GeomType.LINESTRING:
type = "MultiLineString";
break;
case GeomType.POLYGON:
type = "MultiPolygon";
break;
default:
break;
}
}
else if (geomWgs84.Count == 1) //singlepart
{
switch (feature.GeometryType)
{
case GeomType.POINT:
type = "Point";
break;
case GeomType.LINESTRING:
type = "LineString";
break;
case GeomType.POLYGON:
type = "Polygon";
break;
default:
break;
}
}
else //no geometry
{
}
return(type);
}
public override bool Evaluate(VectorTileFeature feature)
{
if (feature == null || !feature.Tags.ContainsKey(Key))
{
return(false);
}
if (feature.Tags[Key] is float ||
feature.Tags[Key] is int)
{
return((float)feature.Tags[Key] <= (float)Value);
}
return(false);
}
public void AddPointOfInterest(VectorTileFeature item)
{
var builder = new PointStyleBuilder();
builder.Size = 20.0f;
builder.Color = new Carto.Graphics.Color(230, 100, 100, 200);
MapPos position = (item.Geometry as PointGeometry).Pos;
var point = new Point(position, builder.BuildStyle());
point.SetMetaDataElement(VectorElementListener.RouteSearchTitle, new Variant("Properties"));
point.SetMetaDataElement(VectorElementListener.RouteSearchDescription, new Variant(item.Properties.ToString()));
overlaySource.Add(point);
}
public static void DrawLayer(VectorTileLayer layer, Pallete pallete, Graphics graphics, double divisionRatio)
{
int featureCount = layer.FeatureCount();
for (int i = 0; i < featureCount; i++)
{
VectorTileFeature feature = layer.GetFeature(i);
if (feature.GeometryType == GeomType.UNKNOWN)
{
Console.WriteLine("Unknown feature: " + feature);
continue;
}
featureDrawDictionary[feature.GeometryType](feature, pallete, graphics, divisionRatio);
}
}
public static void CreateLayer(VectorTileLayer layer, Pallete pallete, Model3DGroup model3DGroup, Vector2 <int> shiftCoords)
{
int featureCount = layer.FeatureCount();
for (int i = 0; i < featureCount; i++)
{
VectorTileFeature feature = layer.GetFeature(i);
if (feature.GeometryType == GeomType.UNKNOWN)
{
Console.WriteLine("Unknown feature: " + feature);
continue;
}
featureCreateDictionary[feature.GeometryType](feature, pallete, model3DGroup, shiftCoords);
}
}
public void TestVectTile()
{
var pbf = File.ReadAllBytes(@"E:\Downloads\63.pbf");
VectorTile vt = new VectorTile(pbf, false);
foreach (var layerName in vt.LayerNames())
{
VectorTileLayer layer = vt.GetLayer(layerName);
for (int j = 0; j < layer.FeatureCount(); j++)
{
VectorTileFeature feat = layer.GetFeature(j);
var ff = feat.Geometry <long>();
var props = feat.GetProperties();
}
}
}
