immortaly007/badeend-go
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

[TASK] Initial commit with basic product setup

Browse Source
This commit is contained in:
Bas Dado
2019-08-18 13:50:14 +02:00
commit 01a66a8e1f
2548 changed files with 167528 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

164
Assets/Mapbox SDK/Mapbox/Core/cheap-ruler-cs/CheapRuler.cs Normal file
View File

@@ -0,0 +1,164 @@
namespace Mapbox.CheapRulerCs
{
using System;
public enum CheapRulerUnits
{
Kilometers,
Miles,
NauticalMiles,
Meters,
Yards,
Feet,
Inches
}
public class CheapRuler
{
private double _kx;
private double _ky;
/// <summary>
/// Creates a ruler object that will approximate measurements around the given latitude. Units are one of: kilometers
/// </summary>
/// <param name="outputUnits"></param>
public CheapRuler(double latitude, CheapRulerUnits outputUnits = CheapRulerUnits.Kilometers)
{
double factor;
switch (outputUnits)
{
case CheapRulerUnits.Kilometers:
factor = 1.0d;
break;
case CheapRulerUnits.Miles:
factor = 1000.0d / 1609.344;
break;
case CheapRulerUnits.NauticalMiles:
factor = 1000.0d / 1852.0d;
break;
case CheapRulerUnits.Meters:
factor = 1000.0d;
break;
case CheapRulerUnits.Yards:
factor = 1000.0d / 0.9144;
break;
case CheapRulerUnits.Feet:
factor = 1000.0d / 0.3048;
break;
case CheapRulerUnits.Inches:
factor = 1000.0d / 0.0254;
break;
default:
factor = 1.0d;
break;
}
var cos = Math.Cos(latitude * Math.PI / 180);
var cos2 = 2 * cos * cos - 1;
var cos3 = 2 * cos * cos2 - cos;
var cos4 = 2 * cos * cos3 - cos2;
var cos5 = 2 * cos * cos4 - cos3;
// multipliers for converting longitude and latitude degrees into distance (http://1.usa.gov/1Wb1bv7)
_kx = factor * (111.41513 * cos - 0.09455 * cos3 + 0.00012 * cos5);
_ky = factor * (111.13209 - 0.56605 * cos2 + 0.0012 * cos4);
}
/// <summary>
/// Creates a ruler object from tile coordinates.
/// </summary>
/// <param name="y">Y TileId</param>
/// <param name="z">Zoom Level</param>
/// <param name="units"></param>
/// <returns></returns>
public static CheapRuler FromTile(int y, int z, CheapRulerUnits units = CheapRulerUnits.Kilometers)
{
var n = Math.PI * (1 - 2 * (y + 0.5) / Math.Pow(2, z));
var lat = Math.Atan(0.5 * (Math.Exp(n) - Math.Exp(-n))) * 180 / Math.PI;
return new CheapRuler(lat, units);
}
/// <summary>
/// Given two points returns the distance.
/// </summary>
/// <param name="a">point [longitude, latitude]</param>
/// <param name="b">point [longitude, latitude]</param>
/// <returns>Distance</returns>
public double Distance(double[] a, double[] b)
{
var dx = (a[0] - b[0]) * _kx;
var dy = (a[1] - b[1]) * _ky;
return Math.Sqrt(dx * dx + dy * dy);
}
/// <summary>
/// Returns the bearing between two points in angles.
/// </summary>
/// <param name="a">a point [longitude, latitude]</param>
/// <param name="b">b point [longitude, latitude]</param>
/// <returns>Bearing</returns>
public double Bearing(double[] a, double[] b)
{
var dx = (b[0] - a[0]) * _kx;
var dy = (b[1] - a[1]) * _ky;
if (dx == 0 && dy == 0)
{
return 0;
}
var bearing = Math.Atan2(dx, dy) * 180 / Math.PI;
if (bearing > 180)
{
bearing -= 360;
}
return bearing;
}
/// <summary>
/// Returns a new point given distance and bearing from the starting point.
/// </summary>
/// <param name="p"></param>
/// <param name="distance"></param>
/// <param name="bearing">point [longitude, latitude]</param>
/// <returns></returns>
public double[] Destination(double[] p, double distance, double bearing)
{
var a = (90 - bearing) * Math.PI / 180;
return offset(
p
, Math.Cos(a) * distance
, Math.Sin(a) * distance
);
}
/// <summary>
/// Returns a new point given easting and northing offsets (in ruler units) from the starting point.
/// </summary>
/// <param name="p">point [longitude, latitude]</param>
/// <param name="dx">dx easting</param>
/// <param name="dy">dy northing</param>
/// <returns>point [longitude, latitude]</returns>
private double[] offset(double[] p, double dx, double dy)
{
return new double[]
{
p[0] + dx / _kx,
p[1] + dy / _ky
};
}
}
}

13
Assets/Mapbox SDK/Mapbox/Core/cheap-ruler-cs/CheapRuler.cs.meta Normal file
View File

@@ -0,0 +1,13 @@
fileFormatVersion: 2
guid: 70ae2609c58a0494fa3d7f9f58915037
timeCreated: 1510756014
licenseType: Pro
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

10
Assets/Mapbox SDK/Mapbox/Core/cheap-ruler-cs/Tests.meta Normal file
View File

@@ -0,0 +1,10 @@
fileFormatVersion: 2
guid: ad956bac3800e2347b757d68a78545fe
folderAsset: yes
timeCreated: 1515511351
licenseType: Pro
DefaultImporter:
externalObjects: {}
userData:
assetBundleName:
assetBundleVariant:

10
Assets/Mapbox SDK/Mapbox/Core/cheap-ruler-cs/Tests/Editor.meta Normal file
View File

@@ -0,0 +1,10 @@
fileFormatVersion: 2
guid: 4f535415528489e4994bafd61109a75e
folderAsset: yes
timeCreated: 1515511390
licenseType: Pro
DefaultImporter:
externalObjects: {}
userData:
assetBundleName:
assetBundleVariant:

122
Assets/Mapbox SDK/Mapbox/Core/cheap-ruler-cs/Tests/Editor/MapboxUnitTests_CheapRulerCs.cs Normal file
View File

@@ -0,0 +1,122 @@
//-----------------------------------------------------------------------
// <copyright file="FileSourceTest.cs" company="Mapbox">
// Copyright (c) 2016 Mapbox. All rights reserved.
// </copyright>
//-----------------------------------------------------------------------
// TODO: figure out how run tests outside of Unity with .NET framework, something like '#if !UNITY'
namespace Mapbox.CheapRulerCs.UnitTest
{
using NUnit.Framework;
using System.Collections.Generic;
using UnityEngine;
using Mapbox.CheapRulerCs;
using Mapbox.Json.Linq;
[TestFixture]
internal class CheapRulerCsTest
{
// TODO more tests ////////////////////
// see https://github.com/mapbox/cheap-ruler/blob/master/test/test.js
//////////////////////////
internal class point { public double x; public double y; }
internal class line
{
public List<point> vertices = new List<point>();
public void Add(double x, double y) { vertices.Add(new point() { x = x, y = y }); }
}
private List<line> _lineFixtures;
[SetUp]
public void SetUp()
{
_lineFixtures = loadFixtures();
}
[Test, Order(1)]
public void FixturesLoaded()
{
Assert.AreEqual(58, _lineFixtures.Count);
}
[Test]
public void DistanceInMiles()
{
CheapRuler ruler = new CheapRuler(32.8351);
CheapRuler rulerMiles = new CheapRuler(32.8351, CheapRulerUnits.Miles);
double distKm = ruler.Distance(new double[] { 30.5, 32.8351 }, new double[] { 30.51, 32.8451 });
double distMiles = rulerMiles.Distance(new double[] { 30.5, 32.8351 }, new double[] { 30.51, 32.8451 });
Debug.LogFormat("{0} {1}", distKm, distMiles);
Assert.AreEqual(1.609344, distKm / distMiles, 1e-12, "wrong distance in miles");
}
[Test]
public void DistanceInNauticalMiles()
{
CheapRuler ruler = new CheapRuler(32.8351);
CheapRuler rulerMiles = new CheapRuler(32.8351, CheapRulerUnits.Miles);
CheapRuler rulerNauticalMiles = new CheapRuler(32.8351, CheapRulerUnits.NauticalMiles);
double distKm = ruler.Distance(new double[] { 30.5, 32.8351 }, new double[] { 30.51, 32.8451 });
double distMiles = rulerMiles.Distance(new double[] { 30.5, 32.8351 }, new double[] { 30.51, 32.8451 });
double distNauticalMiles = rulerNauticalMiles.Distance(new double[] { 30.5, 32.8351 }, new double[] { 30.51, 32.8451 });
Debug.LogFormat("{0} {1}", distKm, distNauticalMiles);
Assert.AreEqual(1.852, distKm / distNauticalMiles, 1e-12, "wrong distance km vs nautical miles");
Assert.AreEqual(1.15078, distMiles / distNauticalMiles, 1e-6, "wrong distance miles vs nautical miles");
}
[Test]
public void FromTile()
{
CheapRuler ruler1 = new CheapRuler(50.5);
CheapRuler ruler2 = CheapRuler.FromTile(11041, 15);
var p1 = new double[] { 30.5, 50.5 };
var p2 = new double[] { 30.51, 50.51 };
Assert.AreEqual(ruler1.Distance(p1, p2), ruler2.Distance(p1, p2), 3e-5, "CheapRuler.FromTile distance");
}
private List<line> loadFixtures()
{
TextAsset fixturesAsset = Resources.Load<TextAsset>("ChearRulerCs_fixtures");
var json = JArray.Parse(fixturesAsset.text);
List<line> fixtures = new List<line>();
foreach (var line in json)
{
line fixtureLine = new line();
foreach (var coordinates in line)
{
fixtureLine.Add(coordinates[0].Value<double>(), coordinates[1].Value<double>());
}
fixtures.Add(fixtureLine);
}
return fixtures;
}
}
}

13
Assets/Mapbox SDK/Mapbox/Core/cheap-ruler-cs/Tests/Editor/MapboxUnitTests_CheapRulerCs.cs.meta Normal file
View File

@@ -0,0 +1,13 @@
fileFormatVersion: 2
guid: a618de68ec1d47d4895ef5b3200b2c88
timeCreated: 1522309080
licenseType: Pro
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant: