public override void UpdateContent()
{
bounds = map.MapCoordBounds;
if (degrees)
{
UpdateProjectionValues();
}
else
{
// Convert Lon/Lat to meters
var meters = GeoCalculator.LonLatToMeters(bounds.east, bounds.north);
bounds.east = meters.x;
bounds.north = meters.y;
meters = GeoCalculator.LonLatToMeters(bounds.west, bounds.south);
bounds.west = meters.x;
bounds.south = meters.y;
}
var invBoundsX = 1.0 / (bounds.east - bounds.west);
var invBoundsY = 1.0 / (bounds.north - bounds.south);
var interval = new Vector4((float)(intervalX * invBoundsX), (float)(intervalY * invBoundsY), 0, 0);
var offsetX = (float)(((0.5f * (bounds.east + bounds.west)) % intervalX) * invBoundsX);
var offsetY = (float)(((0.5f * (bounds.north + bounds.south)) % intervalY) * invBoundsY);
var offset = new Vector4(offsetX, offsetY, 0, 0);
if (degrees)
{
offset.y = -offset.y;
}
material.SetVector("Interval", interval);
material.SetVector("Offset", offset);
}
public static bool Contains(this AreaBounds bounds, OctTreeOccupant octTreeOccupant)
{
if (octTreeOccupant == null)
{
return(false);
}
Transform sphereTransform = octTreeOccupant.Transform;
SphereCollider sphere = octTreeOccupant.SphereCollider;
if (sphereTransform == null || sphere == null)
{
return(false);
}
Vector3 spherePosition = sphereTransform.position;
spherePosition += sphere.center;
float sphereRadius = sphere.radius;
if (spherePosition.x - sphereRadius > bounds.MaxBounds.x ||
spherePosition.y - sphereRadius > bounds.MaxBounds.y ||
spherePosition.z - sphereRadius > bounds.MaxBounds.z ||
spherePosition.x + sphereRadius < bounds.MinBounds.x ||
spherePosition.y + sphereRadius < bounds.MinBounds.y ||
spherePosition.z + sphereRadius < bounds.MinBounds.z)
{
return(false);
}
return(true);
}
public Site(string name, Site parent, AreaBounds bounds, List <DataLayer> dataLayers)
{
this.name = name;
this.bounds = bounds;
this.dataLayers = dataLayers;
this.parent = parent;
}
//
// Public Methods
//
public AreaMapLayer Add(Site site, AreaBounds bounds)
{
AreaMapLayer layer = Instantiate(sitePrefab);
layer.name = site.name;
layer.Init(map, bounds.north, bounds.east, bounds.south, bounds.west);
layer.transform.SetParent(transform, false);
mapLayers.Add(layer);
siteToMapLayer.Add(site, layer);
return(layer);
}
//
// Private Methods
//
private IEnumerator WaitForUI()
{
// Wait 2 frames for UI to be created
yield return(null);
yield return(null);
AreaBounds bounds = new AreaBounds(GeoCalculator.MinLongitude, GeoCalculator.MaxLongitude, GeoCalculator.MaxLatitude, GeoCalculator.MinLatitude);
ZoomToBounds(bounds, false);
}
//
// Public Methods
//
public AreaMapLayer Add(Site site, AreaBounds bounds)
{
AreaMapLayer layer = Instantiate(sitePrefab);
layer.name = site.Name;
layer.Init(map, bounds.north, bounds.east, bounds.south, bounds.west);
layer.transform.SetParent(transform, false);
mapLayers.Add(layer);
siteToMapLayer.Add(site, layer);
if (!showBoundaries && site != highlightedSite)
{
layer.Show(false);
}
return(layer);
}
public bool Matches(SniperInfo sniperInfo)
{
var pokemonIds = PokemonFilterParser.ParseBinary(Pokemon);
if (pokemonIds != null && !pokemonIds.Contains(sniperInfo.Id))
{
return(false);
}
if (AreaBounds != null && !AreaBounds.Intersects(sniperInfo.Latitude, sniperInfo.Longitude))
{
return(false);
}
if (MinimumIV > sniperInfo.IV)
{
return(false);
}
return(true);
}
/// <summary>
/// A Shapefile MultiPoint Shape
/// </summary>
/// <param name="shapeData">The shape record as a byte array</param>
/// <exception cref="ArgumentNullException">Thrown if shapeData is null</exception>
/// <exception cref="InvalidOperationException">Thrown if an error occurs parsing shapeData</exception>
protected internal ShapeMultiPoint(byte[] shapeData)
: base(ShapeType.MultiPoint)
{
// metadata is validated by the base class
if (shapeData == null)
{
throw new ArgumentNullException("shapeData");
}
// Note, shapeData includes an 8 byte header so positions below are +8
// Position Field Value Type Number Order
// Byte 0 Shape Type 8 Integer 1 Little
// Byte 4 Box Box Double 4 Little
// Byte 36 NumPoints Num Points Integer 1 Little
// Byte 40 Points Points Point NumPoints Little
// validation step 1 - must have at least 8 + 4 + (4*8) + 4 bytes = 48
if (shapeData.Length < 48)
{
throw new InvalidOperationException("Invalid shape data");
}
// extract bounding box and points
_boundingBox = ParseBoundingBox(shapeData, 12, ProvidedOrder.Little);
Debug.Log($"Extents: {_boundingBox.west}, {_boundingBox.east}, {_boundingBox.north}, {_boundingBox.south}");
int numPoints = EndianBitConverter.ToInt32(shapeData, 44, ProvidedOrder.Little);
Debug.Log($"numPoints: {numPoints}");
// validation step 2 - we're expecting 16 * numPoints + 48 bytes total
if (shapeData.Length != 48 + (16 * numPoints))
{
throw new InvalidOperationException("Invalid shape data");
}
// now extract the points
_points = new PointD[numPoints];
for (int pointNum = 0; pointNum < numPoints; pointNum++)
{
_points[pointNum] = new PointD(EndianBitConverter.ToDouble(shapeData, 48 + (16 * pointNum), ProvidedOrder.Little),
EndianBitConverter.ToDouble(shapeData, 56 + (16 * pointNum), ProvidedOrder.Little));
}
}
public void ZoomToBounds(AreaBounds bounds, bool fit = true)
{
Distance meters = GeoCalculator.LonLatToMeters(bounds.east, bounds.north) - GeoCalculator.LonLatToMeters(bounds.west, bounds.south);
var rect = ComponentManager.Instance.Get <MapViewArea>().GetComponent <RectTransform>().rect;
var canvas = FindObjectOfType <Canvas>();
double zoomX = Math.Log(rect.width * canvas.scaleFactor * GeoCalculator.InitialResolution / meters.x) * InvLogTwo;
double zoomY = Math.Log(rect.height * canvas.scaleFactor * GeoCalculator.InitialResolution / meters.y) * InvLogTwo;
if (fit)
{
float zoom = (float)Math.Min(zoomX, zoomY);
SetZoom(0.1f * Mathf.Floor(zoom * 10));
}
else
{
float zoom = (float)Math.Max(zoomX, zoomY);
SetZoom(0.1f * Mathf.Ceil(zoom * 10));
}
}
private void UpdateLayerPanel(DataLayerPanel layerPanel, int level, AreaBounds bounds)
{
var dataLayer = layerPanel.DataLayer;
var site = ComponentManager.Instance.Get <SiteBrowser>().ActiveSite;
bool hasPatches;
if (layerPanel.IsLayerToggleOn)
{
dataLayer.UpdatePatches(site, level, bounds);
hasPatches = dataLayer.HasPatchesInView();
if (hasPatches && !availableLayers.Contains(dataLayer))
{
availableLayers.Add(dataLayer);
if (OnLayerAvailabilityChange != null)
{
OnLayerAvailabilityChange(dataLayer, true);
}
}
else if (!hasPatches && availableLayers.Contains(dataLayer))
{
availableLayers.Remove(dataLayer);
if (OnLayerAvailabilityChange != null)
{
OnLayerAvailabilityChange(dataLayer, false);
}
}
}
else
{
hasPatches = dataLayer.HasPatches(site, level, bounds.west, bounds.east, bounds.north, bounds.south);
}
// Show/hide a layer panel when only visible layers are allowed, otherwise enable/disable the layer panel
EnableLayerPanel(layerPanel, hasPatches);
}
/// <summary>
/// Function is basically the same as Shape.ParsePolyLineOrPolygon, it is just
/// extended to handle the M extreme values
/// </summary>
/// <param name="shapeData">The shape record as a byte array</param>
/// <param name="boundingBox">Returns the bounding box</param>
/// <param name="parts">Returns the list of parts</param>
private void ParsePolyLineM(byte[] shapeData, out RectangleD boundingBox, out List <PointD[]> parts)
{
boundingBox = new RectangleD();
parts = null;
// metadata is validated by the base class
if (shapeData == null)
{
throw new ArgumentNullException("shapeData");
}
// Note, shapeData includes an 8 byte header so positions below are +8
// Position Field Value Type Number Order
// Byte 0 Shape Type 23 Integer 1 Little
// Byte 4 Box Box Double 4 Little
// Byte 36 NumParts NumParts Integer 1 Little
// Byte 40 NumPoints NumPoints Integer 1 Little
// Byte 44 Parts Parts Integer NumParts Little
// Byte X Points Points Point NumPoints Little
// Byte Y* Mmin Mmin Double 1 Little
// Byte Y + 8* Mmax Mmax Double 1 Little
// Byte Y + 16* Marray Marray Double NumPoints Little
//
// *optional
// validation step 1 - must have at least 8 + 4 + (4*8) + 4 + 4 bytes = 52
if (shapeData.Length < 44)
{
throw new InvalidOperationException("Invalid shape data");
}
// extract bounding box, number of parts and number of points
boundingBox = ParseBoundingBox(shapeData, 12, ProvidedOrder.Little);
Debug.Log($"Extents: {boundingBox.west}, {boundingBox.east}, {boundingBox.north}, {boundingBox.south}");
int numParts = EndianBitConverter.ToInt32(shapeData, 44, ProvidedOrder.Little);
Debug.Log($"numParts: {numParts}");
int numPoints = EndianBitConverter.ToInt32(shapeData, 48, ProvidedOrder.Little);
Debug.Log($"numPoints: {numPoints}");
// validation step 2 - we're expecting 4 * numParts + (16 + 8 * numPoints for m extremes and values) + 16 * numPoints + 52 bytes total
if (shapeData.Length != 52 + (4 * numParts) + 16 + 8 * numPoints + (16 * numPoints))
{
throw new InvalidOperationException("Invalid shape data");
}
// now extract the parts
int partsOffset = 52 + (4 * numParts);
parts = new List <PointD[]>(numParts);
for (int part = 0; part < numParts; part++)
{
// this is the index of the start of the part in the points array
int startPart = (EndianBitConverter.ToInt32(shapeData, 52 + (4 * part), ProvidedOrder.Little) * 16) + partsOffset;
int numBytes;
if (part == numParts - 1)
{
// it's the last part so we go to the end of the point array
numBytes = shapeData.Length - startPart;
// remove bytes for M extreme block
numBytes -= numPoints * 8 + 16;
}
else
{
// we need to get the next part
int nextPart = (EndianBitConverter.ToInt32(shapeData, 52 + (4 * (part + 1)), ProvidedOrder.Little) * 16) + partsOffset;
numBytes = nextPart - startPart;
}
// the number of 16-byte points to read for this segment
int numPointsInPart = (numBytes) / 16;
PointD[] points = new PointD[numPointsInPart];
for (int point = 0; point < numPointsInPart; point++)
{
points[point] = new PointD(EndianBitConverter.ToDouble(shapeData, startPart + (16 * point), ProvidedOrder.Little),
EndianBitConverter.ToDouble(shapeData, startPart + 8 + (16 * point), ProvidedOrder.Little));
}
parts.Add(points);
}
// parse M information
Mmin = EndianBitConverter.ToDouble(shapeData, 52 + (4 * numParts) + (16 * numPoints), ProvidedOrder.Little);
Mmax = EndianBitConverter.ToDouble(shapeData, 52 + 8 + (4 * numParts) + (16 * numPoints), ProvidedOrder.Little);
M.Clear();
for (int i = 0; i < numPoints; i++)
{
double _m = EndianBitConverter.ToDouble(shapeData, 52 + 16 + (4 * numParts) + (16 * numPoints) + i * 8, ProvidedOrder.Little);
M.Add(_m);
}
}
public void UpdatePatches(Site site, int levelIndex, AreaBounds bounds)
{
bool removedPatches = false;
if (visibleYear == -1)
{
// Hide visible patches that don't meet the criteria
for (int i = patchesInView.Count - 1; i >= 0; i--)
{
var patch = patchesInView[i];
if (patch.Level != levelIndex ||
!patch.Data.Intersects(bounds.west, bounds.east, bounds.north, bounds.south) ||
patch.SiteRecord.layerSite.Site != site)
{
RemovePatchInView(i);
removedPatches = true;
}
}
// Show non-visible patches that meet the criteria
foreach (var layerSite in levels[levelIndex].layerSites)
{
if (layerSite.Site == site)
{
foreach (var patch in layerSite.LastRecord.patches)
{
var patchData = patch.Data;
if (!patch.IsVisible() &&
patchData.Intersects(bounds.west, bounds.east, bounds.north, bounds.south) &&
!dataManager.IsRequesting(patch))
{
AddPatchInView(patch);
}
}
}
}
}
else
{
// Hide visible patches that don't meet the criteria
for (int i = patchesInView.Count - 1; i >= 0; i--)
{
var patch = patchesInView[i];
if (patch.Level != levelIndex || !patch.Data.Intersects(bounds.west, bounds.east, bounds.north, bounds.south) ||
patch.Year != visibleYear ||
patch.SiteRecord.layerSite.Site != site)
{
RemovePatchInView(i);
removedPatches = true;
}
}
// Show non-visible sites that meet the criteria
foreach (var layerSite in levels[levelIndex].layerSites)
{
if (layerSite.Site == site &&
layerSite.records.ContainsKey(visibleYear))
{
foreach (var patch in layerSite.records[visibleYear].patches)
{
var patchData = patch.Data;
if (!patch.IsVisible() &&
patchData.Intersects(bounds.west, bounds.east, bounds.north, bounds.south) &&
!dataManager.IsRequesting(patch))
{
AddPatchInView(patch);
}
}
}
}
}
if (removedPatches)
{
UpdateLoadedVisibleRange();
}
}
public void Show(int levelIndex, AreaBounds bounds)
{
InitVisibleRange();
UpdatePatches(dataManager.ActiveSite, levelIndex, bounds);
}
/// <summary>
/// Create a new Shapefile object and open a Shapefile. Note that three files are required -
/// the main file (.shp), the index file (.shx) and the dBASE table (.dbf). The three files
/// must all have the same filename (i.e. shapes.shp, shapes.shx and shapes.dbf). Set path
/// to any one of these three files to open the Shapefile.
/// </summary>
/// <param name="path">Path to the .shp, .shx or .dbf file for this Shapefile</param>
/// <exception cref="ObjectDisposedException">Thrown if the Shapefile has been disposed</exception>
/// <exception cref="ArgumentNullException">Thrown if the path parameter is null</exception>
/// <exception cref="ArgumentException">Thrown if the path parameter is empty</exception>
/// <exception cref="FileNotFoundException">Thrown if one of the three required files is not found</exception>
/// <exception cref="InvalidOperationException">Thrown if an error occurs parsing file headers</exception>
public void Open(string path)
{
if (_disposed)
{
throw new ObjectDisposedException("Shapefile");
}
if (path == null)
{
throw new ArgumentNullException("path");
}
if (path.Length <= 0)
{
throw new ArgumentException("path parameter is empty", "path");
}
_shapefileMainPath = Path.ChangeExtension(path, MainPathExtension);
_shapefileIndexPath = Path.ChangeExtension(path, IndexPathExtension);
_shapefileDbasePath = Path.ChangeExtension(path, DbasePathExtension);
if (!File.Exists(_shapefileMainPath))
{
throw new FileNotFoundException("Shapefile main file not found", _shapefileMainPath);
}
if (!File.Exists(_shapefileIndexPath))
{
throw new FileNotFoundException("Shapefile index file not found", _shapefileIndexPath);
}
if (!File.Exists(_shapefileDbasePath))
{
throw new FileNotFoundException("Shapefile dBase file not found", _shapefileDbasePath);
}
_mainStream = File.Open(_shapefileMainPath, FileMode.Open, FileAccess.Read, FileShare.Read);
_indexStream = File.Open(_shapefileIndexPath, FileMode.Open, FileAccess.Read, FileShare.Read);
if (_mainStream.Length < Header.HeaderLength)
{
throw new InvalidOperationException("Shapefile main file does not contain a valid header");
}
if (_indexStream.Length < Header.HeaderLength)
{
throw new InvalidOperationException("Shapefile index file does not contain a valid header");
}
// read in and parse the headers
byte[] headerBytes = new byte[Header.HeaderLength];
_mainStream.Read(headerBytes, 0, Header.HeaderLength);
_mainHeader = new Header(headerBytes);
_indexStream.Read(headerBytes, 0, Header.HeaderLength);
_indexHeader = new Header(headerBytes);
// set properties from the main header
_type = _mainHeader.ShapeType;
_boundingBox = new RectangleD(_mainHeader.XMin, _mainHeader.XMax, _mainHeader.YMin, _mainHeader.YMax);
// index header length is in 16-bit words, including the header - number of
// shapes is the number of records (each 4 workds long) after subtracting the header bytes
_count = (_indexHeader.FileLength - (Header.HeaderLength / 2)) / 4;
// Read .dbf file
_dbfFile = new DbfFile(_shapefileDbasePath, out _dbfStream);
if (_dbfStream.Length < Header.HeaderLength)
{
throw new InvalidOperationException("Shapefile dbf file does not contain a valid header");
}
_dbfFile.Load();
// Initialize shapes
Shapes = new List <Shape>();
foreach (var shape in this)
{
Shapes.Add(shape);
}
_opened = true;
}
public void Show(int levelIndex, AreaBounds bounds)
{
InitVisibleRange();
UpdatePatches(levelIndex, bounds);
}
public AreaBounds(AreaBounds other) : this(other.west, other.east, other.north, other.south)
{
}
// ----------------------------------------------------------------------------
public OctTree(OctTree parent, AreaBounds bounds)
{
m_parent = parent;
m_bounds = bounds;
}
