Styczeń 2009 r.
Cel
Z tego samouczka dowiesz się, jak używać zdjęć z geotagami do tworzenia plików KMLPhotoOverlays. Przykładowy kod jest napisany w języku Python, ale istnieje wiele podobnych bibliotek w innych językach programowania, więc nie powinno być problemu z przetłumaczeniem tego kodu na inny język. Kod w tym artykule korzysta z biblioteki Pythona o otwartym kodzie źródłowym EXIF.py.
Wprowadzenie
Aparaty cyfrowe to niesamowite urządzenia. Wielu użytkowników nie zdaje sobie z tego sprawy, ale robią oni coś więcej niż tylko zdjęcia i filmy. Oznaczają też te filmy i zdjęcia metadanymi dotyczącymi kamery i jej ustawień. W ostatnich latach użytkownicy znaleźli sposoby na dodawanie do tych informacji danych geograficznych, które są osadzane przez producentów aparatów, np. w niektórych aparatach Ricoh i Nikon, lub za pomocą urządzeń takich jak rejestratory GPS i EyeFi Explore. Telefony z aparatem, takie jak iPhone i telefony z Androidem, np. G1 od T-Mobile, automatycznie osadzają te dane. Niektóre witryny do przesyłania zdjęć, takie jak Panoramio, Picasa Web Albums i Flickr, automatycznie analizują dane GPS i używają ich do geotagowania zdjęć. Następnie możesz przywrócić te dane w plikach danych. Ale gdzie w tym zabawa? Z tego artykułu dowiesz się, jak samodzielnie uzyskać te dane.
Nagłówki EXIF
Najczęstszym sposobem osadzania danych w pliku obrazu jest użycie formatu EXIF. Dane są przechowywane w formie binarnej w nagłówkach EXIF w standardowy sposób. Jeśli znasz specyfikację nagłówków EXIF, możesz je samodzielnie przeanalizować. Na szczęście ktoś już wykonał tę ciężką pracę i napisał moduł Pythona. Biblioteka open source EXIF.py to świetne narzędzie do odczytywania nagłówków plików JPEG.
Kodeks
Przykładowy kod do tego artykułu znajduje się w tym pliku: exif2kml.py. Jeśli chcesz od razu zacząć z niego korzystać, pobierz ten moduł oraz plik EXIF.py i umieść je w tym samym katalogu. Uruchom python exif2kml.py foo.jpg, zastępując foo.jpg ścieżką do zdjęcia z geotagiem. Spowoduje to utworzenie pliku o nazwie test.kml.
Analizowanie nagłówków Exif
EXIF.py zapewnia prosty interfejs do wyodrębniania nagłówków Exif. Wystarczy uruchomić funkcję process_file(), a zwróci ona nagłówki jako obiekt dict.
def GetHeaders(the_file):
"""Handles getting the Exif headers and returns them as a dict.
Args:
the_file: A file object
Returns:
a dict mapping keys corresponding to the Exif headers of a file.
"""
data = EXIF.process_file(the_file, 'UNDEF', False, False, False)
return dataPo uzyskaniu nagłówków Exif musisz wyodrębnić współrzędne GPS. EXIF.py traktuje je jako obiekty Ratio, czyli obiekty do przechowywania licznika i mianownika wartości. Ustawia to dokładny stosunek, zamiast polegać na liczbie zmiennoprzecinkowej. KML wymaga jednak liczb dziesiętnych, a nie stosunków. Wyodrębnij więc każdą ze współrzędnych i przekonwertuj licznik i mianownik na jedną liczbę zmiennoprzecinkową, aby uzyskać stopnie dziesiętne:
def DmsToDecimal(degree_num, degree_den, minute_num, minute_den,
second_num, second_den):
"""Converts the Degree/Minute/Second formatted GPS data to decimal degrees.
Args:
degree_num: The numerator of the degree object.
degree_den: The denominator of the degree object.
minute_num: The numerator of the minute object.
minute_den: The denominator of the minute object.
second_num: The numerator of the second object.
second_den: The denominator of the second object.
Returns:
A deciminal degree.
"""
degree = float(degree_num)/float(degree_den)
minute = float(minute_num)/float(minute_den)/60
second = float(second_num)/float(second_den)/3600
return degree + minute + second
def GetGps(data):
"""Parses out the GPS coordinates from the file.
Args:
data: A dict object representing the Exif headers of the photo.
Returns:
A tuple representing the latitude, longitude, and altitude of the photo.
"""
lat_dms = data['GPS GPSLatitude'].values
long_dms = data['GPS GPSLongitude'].values
latitude = DmsToDecimal(lat_dms[0].num, lat_dms[0].den,
lat_dms[1].num, lat_dms[1].den,
lat_dms[2].num, lat_dms[2].den)
longitude = DmsToDecimal(long_dms[0].num, long_dms[0].den,
long_dms[1].num, long_dms[1].den,
long_dms[2].num, long_dms[2].den)
if data['GPS GPSLatitudeRef'].printable == 'S': latitude *= -1
if data['GPS GPSLongitudeRef'].printable == 'W': longitude *= -1
altitude = None
try:
alt = data['GPS GPSAltitude'].values[0]
altitude = alt.num/alt.den
if data['GPS GPSAltitudeRef'] == 1: altitude *= -1
except KeyError:
altitude = 0
return latitude, longitude, altitude
Po uzyskaniu współrzędnych możesz łatwo utworzyć prosty PhotoOverlay dla każdego zdjęcia:
def CreatePhotoOverlay(kml_doc, file_name, the_file, file_iterator): """Creates a PhotoOverlay element in the kml_doc element. Args: kml_doc: An XML document object. file_name: The name of the file. the_file: The file object. file_iterator: The file iterator, used to create the id. Returns: An XML element representing the PhotoOverlay. """ photo_id = 'photo%s' % file_iterator data = GetHeaders(the_file) coords = GetGps(data) po = kml_doc.createElement('PhotoOverlay') po.setAttribute('id', photo_id) name = kml_doc.createElement('name') name.appendChild(kml_doc.createTextNode(file_name)) description = kml_doc.createElement('description') description.appendChild(kml_doc.createCDATASection('<a href="#%s">' 'Click here to fly into ' 'photo</a>' % photo_id)) po.appendChild(name) po.appendChild(description) icon = kml_doc.createElement('icon') href = kml_doc.createElement('href') href.appendChild(kml_doc.createTextNode(file_name)) camera = kml_doc.createElement('Camera') longitude = kml_doc.createElement('longitude') latitude = kml_doc.createElement('latitude') altitude = kml_doc.createElement('altitude') tilt = kml_doc.createElement('tilt') # Determines the proportions of the image and uses them to set FOV. width = float(data['EXIF ExifImageWidth'].printable) length = float(data['EXIF ExifImageLength'].printable) lf = str(width/length * -20.0) rf = str(width/length * 20.0) longitude.appendChild(kml_doc.createTextNode(str(coords[1]))) latitude.appendChild(kml_doc.createTextNode(str(coords[0]))) altitude.appendChild(kml_doc.createTextNode('10')) tilt.appendChild(kml_doc.createTextNode('90')) camera.appendChild(longitude) camera.appendChild(latitude) camera.appendChild(altitude) camera.appendChild(tilt) icon.appendChild(href) viewvolume = kml_doc.createElement('ViewVolume') leftfov = kml_doc.createElement('leftFov') rightfov = kml_doc.createElement('rightFov') bottomfov = kml_doc.createElement('bottomFov') topfov = kml_doc.createElement('topFov') near = kml_doc.createElement('near') leftfov.appendChild(kml_doc.createTextNode(lf)) rightfov.appendChild(kml_doc.createTextNode(rf)) bottomfov.appendChild(kml_doc.createTextNode('-20')) topfov.appendChild(kml_doc.createTextNode('20')) near.appendChild(kml_doc.createTextNode('10')) viewvolume.appendChild(leftfov) viewvolume.appendChild(rightfov) viewvolume.appendChild(bottomfov) viewvolume.appendChild(topfov) viewvolume.appendChild(near) po.appendChild(camera) po.appendChild(icon) po.appendChild(viewvolume) point = kml_doc.createElement('point') coordinates = kml_doc.createElement('coordinates') coordinates.appendChild(kml_doc.createTextNode('%s,%s,%s' %(coords[1], coords[0], coords[2]))) point.appendChild(coordinates) po.appendChild(point) document = kml_doc.getElementsByTagName('Document')[0] document.appendChild(po)
Jak widzisz, używamy tylko standardowych metod W3C DOM, ponieważ są one dostępne w większości języków programowania. Aby zobaczyć, jak to wszystko działa, pobierz kod tutaj.
Ten przykład nie wykorzystuje w pełni możliwości PhotoOverlays, które pozwalają na szczegółowe eksplorowanie zdjęć w wysokiej rozdzielczości. Pokazuje jednak, jak zawiesić zdjęcie w stylu billboardu nad Google Earth. Oto przykładowy plik KML utworzony za pomocą tego kodu:
<?xml version="1.0" encoding="utf-8"?>
<kml xmlns="http://www.opengis.net/kml/2.2">
<Document>
<PhotoOverlay id="photo0">
<name>
1228258523134.jpg
</name>
<description>
<![CDATA[<a href="#photo0">Click here to fly into photo</a>]]> </description>
<Camera>
<longitude>
-122.3902159196034
</longitude>
<latitude>
37.78961266330473
</latitude>
<altitude>
10
</altitude>
<tilt>
90
</tilt>
</Camera>
<Icon>
<href>
1228258523134.jpg
</href>
</Icon>
<ViewVolume>
<leftFov>
-26.6666666667
</leftFov>
<rightFov>
26.6666666667
</rightFov>
<bottomFov>
-20
</bottomFov>
<topFov>
20
</topFov>
<near>
10
</near>
</ViewVolume>
<Point>
<coordinates>
-122.3902159196034,37.78961266330473,0
</coordinates>
</Point>
</PhotoOverlay>
</Document>
</kml>A tak wygląda to w Google Earth:
Ostrzeżenia
Geotagowanie zdjęć jest wciąż w powijakach.
Oto kilka kwestii, o których warto pamiętać:
- Urządzenia GPS nie zawsze są w 100% dokładne, zwłaszcza te w aparatach, dlatego warto sprawdzić lokalizację zdjęć.
- Wiele urządzeń nie śledzi wysokości, tylko ustawia ją na 0. Jeśli wysokość jest dla Ciebie ważna, musisz znaleźć inny sposób na zbieranie tych danych.
- Pozycja GPS to pozycja aparatu, a nie obiektu na zdjęciu. Dlatego w tym przykładzie element Camera jest umieszczony w pozycji GPS, a rzeczywiste zdjęcie jest od niej oddalone.
- Dane EXIF nie zawierają informacji o kierunku, w którym jest skierowany aparat, więc może być konieczne dostosowanie
PhotoOverlays. Dobra wiadomość jest taka, że niektóre urządzenia, np. telefony z systemem operacyjnym Android, umożliwiają bezpośrednie rejestrowanie danych, takich jak kierunek kompasu i nachylenie, ale nie w nagłówkach Exif.
Mimo to jest to skuteczny sposób na wizualizację zdjęć. Mamy nadzieję, że w przyszłości będziemy widzieć coraz więcej zdjęć z dokładniejszymi geotagami.
Co dalej
Po rozpoczęciu korzystania z nagłówków EXIF możesz zapoznać się ze specyfikacją EXIF. Zawiera ona wiele innych danych, które możesz przechwytywać i umieszczać w dymku z opisem. Możesz też tworzyć bardziej rozbudowane PhotoOverlays za pomocą ImagePyramids. W artykule w Przewodniku dla deweloperów na stronie PhotoOverlays znajdziesz dobry przegląd ich zastosowań.