private static double GetXmpGeoData(List <Directory> allExifItems, string propertyPath)
{
var latitudeString = string.Empty;
var latitudeRef = string.Empty;
foreach (var exifItem in allExifItems)
{
// exif:GPSLatitude,45,33.615N
var latitudeLocal = GetXmpData(exifItem, propertyPath);
if (string.IsNullOrEmpty(latitudeLocal))
{
continue;
}
var split = Regex.Split(latitudeLocal, "[NSWE]");
if (split.Length != 2)
{
continue;
}
latitudeString = split[0];
latitudeRef = latitudeLocal[latitudeLocal.Length - 1].ToString();
}
if (string.IsNullOrWhiteSpace(latitudeString))
{
return(0);
}
var latitudeDegreeMinutes = GeoParser.ConvertDegreeMinutesToDouble(latitudeString, latitudeRef);
return(Math.Floor(latitudeDegreeMinutes * 10000000000) / 10000000000);
}
private double GpsPreParseAndConvertDegreeAngleToDouble(string gpsLatOrLong)
{
// get ref North, South, East West
var refGps = gpsLatOrLong.Substring(gpsLatOrLong.Length - 1, 1);
return(GeoParser.ConvertDegreeMinutesToDouble(gpsLatOrLong, refGps));
}
public void GeoParser_ParseIsoString_Italy()
{
var result = GeoParser.ParseIsoString("+40.8516+014.2480+083.241/");
Assert.AreEqual(40.8516015625, result.Latitude, 0.001);
Assert.AreEqual(14.248000217013889, result.Longitude, 0.001);
Assert.AreEqual(0, result.Altitude, 0.001);
}
public void GeoParser_ParseIsoString_NotSupported()
{
var result = GeoParser.ParseIsoString("+40.20361-75.00417CRSxxxx/");
Assert.AreEqual(0, result.Latitude, 0.001);
Assert.AreEqual(0, result.Longitude, 0.001);
Assert.AreEqual(0, result.Altitude, 0.001);
}
public void GeoParser_ParseIsoString_Peru()
{
var result = GeoParser.ParseIsoString("-05.2169-080.6303/");
Assert.AreEqual(-5.2168999565972225, result.Latitude, 0.001);
Assert.AreEqual(-80.63030381944445, result.Longitude, 0.001);
Assert.AreEqual(0, result.Altitude, 0.001);
}
public void GeoParser_ExifRead_ParseGpsTest()
{
var latitude = GeoParser.ConvertDegreeMinutesSecondsToDouble("52° 18' 29.54\"", "N");
Assert.AreEqual(52.308205555500003, latitude, 0.000001);
var longitude = GeoParser.ConvertDegreeMinutesSecondsToDouble("6° 11' 36.8\"", "E");
Assert.AreEqual(6.1935555554999997, longitude, 0.000001);
}
public void GeoParser_ExifRead_ConvertDegreeMinutesToDouble_ConvertLongLat()
{
var input = "52,20.708N";
string refGps = input.Substring(input.Length - 1, 1);
var data = GeoParser.ConvertDegreeMinutesToDouble(input, refGps);
Assert.AreEqual(52.3451333333, data, 0.001);
var input1 = "5,55.840E";
string refGps1 = input1.Substring(input1.Length - 1, 1);
var data1 = GeoParser.ConvertDegreeMinutesToDouble(input1, refGps1);
Assert.AreEqual(5.930, data1, 0.001);
}
private double GetGeoLocationLongitude(List <Directory> allExifItems)
{
var longitudeString = string.Empty;
var longitudeRef = string.Empty;
foreach (var exifItem in allExifItems)
{
var longitudeRefLocal = exifItem.Tags.FirstOrDefault(
p => p.DirectoryName == "GPS" &&
p.Name == "GPS Longitude Ref")?.Description;
if (longitudeRefLocal != null)
{
longitudeRef = longitudeRefLocal;
}
var longitudeLocal = exifItem.Tags.FirstOrDefault(
p => p.DirectoryName == "GPS" &&
p.Name == "GPS Longitude")?.Description;
if (longitudeLocal != null)
{
longitudeString = longitudeLocal;
continue;
}
var locationQuickTime = exifItem.Tags.FirstOrDefault(
p => p.DirectoryName == "QuickTime Metadata Header" &&
p.Name == "GPS Location")?.Description;
if (locationQuickTime != null)
{
return(GeoParser.ParseIsoString(locationQuickTime).Longitude);
}
}
if (!string.IsNullOrWhiteSpace(longitudeString))
{
var longitude = GeoParser.ConvertDegreeMinutesSecondsToDouble(longitudeString, longitudeRef);
longitude = Math.Floor(longitude * 10000000000) / 10000000000;
return(longitude);
}
return(GetXmpGeoData(allExifItems, "exif:GPSLongitude"));
}
public GeoMeshCacheEntry ImportMesh(string filename, Vtf vtf, int textureGroup)
{
if (MeshCache.TryGetValue(filename, out GeoMeshCacheEntry cacheEntry))
{
return(cacheEntry);
}
GeoMesh geoMesh = GeoParser.ReadGeoMesh(filename);
Mesh mesh = new Mesh();
List <Vector3> vertices = new List <Vector3>();
List <Vector2> uvs = new List <Vector2>();
List <Vector3> normals = new List <Vector3>();
Dictionary <Material, List <GeoFace> > facesGroupedByMaterial = new Dictionary <Material, List <GeoFace> >();
GeoFace[] faces = geoMesh.Faces;
for (int i = 0; i < faces.Length; ++i)
{
Material material = GetMaterial(faces[i], vtf, textureGroup);
if (facesGroupedByMaterial.TryGetValue(material, out List <GeoFace> faceGroup))
{
faceGroup.Add(faces[i]);
}
else
{
facesGroupedByMaterial.Add(material, new List <GeoFace>
{
faces[i]
});
}
}
mesh.subMeshCount = facesGroupedByMaterial.Count;
Dictionary <Material, List <int> > submeshTriangles = new Dictionary <Material, List <int> >();
foreach (KeyValuePair <Material, List <GeoFace> > faceGroup in facesGroupedByMaterial)
{
submeshTriangles[faceGroup.Key] = new List <int>();
List <GeoFace> faceGroupValues = faceGroup.Value;
foreach (GeoFace face in faceGroupValues)
{
int numTriangles = face.VertexRefs.Length - 3 + 1;
int viStart = vertices.Count;
foreach (GeoVertexRef vertexRef in face.VertexRefs)
{
vertices.Add(geoMesh.Vertices[vertexRef.VertexIndex]);
normals.Add(geoMesh.Normals[vertexRef.VertexIndex] * -1);
uvs.Add(vertexRef.Uv);
}
for (int t = 1; t <= numTriangles; t++)
{
submeshTriangles[faceGroup.Key].Add(viStart + t);
submeshTriangles[faceGroup.Key].Add(viStart);
submeshTriangles[faceGroup.Key].Add(viStart + t + 1);
}
}
}
mesh.SetVertices(vertices);
mesh.SetUVs(0, uvs);
mesh.SetNormals(normals);
int subMeshIndex = 0;
foreach (KeyValuePair <Material, List <int> > submeshTriangle in submeshTriangles)
{
mesh.SetTriangles(submeshTriangles[submeshTriangle.Key], subMeshIndex++);
}
mesh.RecalculateBounds();
cacheEntry = new GeoMeshCacheEntry
{
GeoMesh = geoMesh,
Mesh = mesh,
Materials = facesGroupedByMaterial.Select(x => x.Key).ToArray()
};
MeshCache.Add(filename, cacheEntry);
return(cacheEntry);
}
void Start()
{
lineMaterial = Resources.Load("DefaultLine3D") as Material;
lines = new List <VectorLine>();
GP = new GeoParser();
}
public void GeoParser_ParseIsoString_LotsOfMinus()
{
var result = GeoParser.ParseIsoString("0-05-0-0-0-0-0-0-0-0");
Assert.AreEqual(0, result.Latitude, 0.001);
}
public void GeoParser_ParseIsoString_WrongPlusFormat()
{
var result = GeoParser.ParseIsoString("0-05");
Assert.AreEqual(0, result.Latitude, 0.001);
}
public void GeoParser_ParseIsoString_DoesNotEndOnSlash()
{
var result = GeoParser.ParseIsoString("-05.2169-080.6303"); // no slash here
Assert.AreEqual(0, result.Latitude, 0.001);
}
void Start()
{
lineMaterial = Resources.Load("DefaultLine3D") as Material;
lines = new List<VectorLine>();
GP = new GeoParser();
}
public GameObject ImportGeo(string filename, Vtf vtf, GameObject prefab)
{
var geoMesh = GeoParser.ReadGeoMesh(filename);
var mesh = new Mesh();
var vertices = new List <Vector3>();
var uvs = new List <Vector2>();
var normals = new List <Vector3>();
var facesGroupedByMaterial = geoMesh.Faces.GroupBy(face => GetMaterial(face, vtf)).ToArray();
mesh.subMeshCount = facesGroupedByMaterial.Length;
var submeshTriangles = new Dictionary <Material, List <int> >();
foreach (var faceGroup in facesGroupedByMaterial)
{
submeshTriangles[faceGroup.Key] = new List <int>();
foreach (var face in faceGroup)
{
var numTriangles = face.VertexRefs.Length - 3 + 1;
var viStart = vertices.Count;
foreach (var vertexRef in face.VertexRefs)
{
vertices.Add(geoMesh.Vertices[vertexRef.VertexIndex]);
normals.Add(geoMesh.Normals[vertexRef.VertexIndex] * -1);
uvs.Add(vertexRef.Uv);
}
for (var t = 1; t <= numTriangles; t++)
{
submeshTriangles[faceGroup.Key].Add(viStart + t);
submeshTriangles[faceGroup.Key].Add(viStart);
submeshTriangles[faceGroup.Key].Add(viStart + t + 1);
}
}
}
mesh.vertices = vertices.ToArray();
mesh.uv = uvs.ToArray();
mesh.normals = normals.ToArray();
var i = 0;
foreach (var submeshTriangle in submeshTriangles)
{
mesh.SetTriangles(submeshTriangles[submeshTriangle.Key].ToArray(), i);
i++;
}
var obj = Instantiate(prefab);
obj.gameObject.name = geoMesh.Name;
obj.GetComponent <MeshFilter>().sharedMesh = mesh;
obj.GetComponent <MeshRenderer>().materials = facesGroupedByMaterial.Select(x => x.Key).ToArray();
var collider = obj.GetComponent <MeshCollider>();
if (collider != null)
{
collider.sharedMesh = mesh;
}
return(obj.gameObject);
}
