def get(self):
respKML = KML()
q = PhotoRecord.all()
results = q.fetch(25)
for p in results:
# set up description
#
desc = " <![CDATA[ \
<img src='http://ogmimage.appspot.com/content/" + \
str(p.key().id()) + \
"' width='250' height='200' />"
if p.description:
desc += "<h2>Notlar</h2><p><b>" + p.description + "</b></p>"
desc += "]]>"
if p.date:
name = p.date
else:
name = "undef"
respKML.addPlacemark(p.lat,p.lon,description = desc,name=name)
respKML.close()
self.response.headers["Content-Type"]= "application/vnd.google-earth.kml+xml"
self.response.out.write(respKML.content)
def __init__(self, url, structure_ge, reference, nom_commune, insee_commune, date, geometrie_kml=None):
"""Constructeur de dossier"""
self.__id = self.__getID(url)
self.__structure_ge = structure_ge
self.__reference = reference
self.__nom_commune = nom_commune
self.__insee_commune = insee_commune
self.__date = date
self.__document = list()
if geometrie_kml != None:
self.__geometrie_kml = KML(geometrie_kml)
else:
self.__geometrie_kml = None
self.__envelope = None
def loadDetails(self, data):
"""Méthode qui permet de rajouter des informations à un dossier à partir du XML"""
tree = ET.parse(StringIO.StringIO(data))
root = tree.getroot()
for child in root[0]:
if child.tag == "id" and child.text != self.__id:
raise ErreurDossierException, "Erreur dossier"
if child.tag == "geometrie_kml":
geometrie = ET.tostring(child)
geometrie = geometrie.replace("<geometrie_kml>", "")
geometrie = geometrie.replace("</geometrie_kml>", "")
self.__geometrie_kml = KML(geometrie)
if child.tag == "document":
if child[0].tag == "description" and child[1].tag == "fichier":
tab = child[1].text.split(".")
extension = tab[1]
tab = child[2].attrib["href"].split("/")
id = tab[5]
self.__document.append(Document(id, child[0].text, extension))
else:
raise ErreurAPIException, "Changement de l'API"
class Dossier:
""" Classe dossier"""
"""Variable de classe comportant la liste des dossiers"""
__listeDossiers = []
"""Méthode statique pour charger les dossiers à partir du CSV"""
def loadFromCSV(cls, csvString):
data = StringIO.StringIO(csvString)
csvReader = csv.reader(data)
for i, row in enumerate(csvReader):
if i >= 1:
Dossier.__listeDossiers.append(Dossier(row[5], row[0], row[1], row[2], row[3], row[4]))
loadFromCSV = classmethod(loadFromCSV)
"""Méthode statique pour obtenir le nombre de dossiers"""
def getNbrDossiers(cls):
return len(Dossier.__listeDossiers)
getNbrDossiers = classmethod(getNbrDossiers)
"""Méthode statique pour retourne un dossier"""
def getDossier(cls, row):
return Dossier.__listeDossiers[row]
getDossier = classmethod(getDossier)
"""Méthode statique qui retourne les dossiers"""
def getListeDossiers(cls):
return Dossier.__listeDossiers
getListeDossiers = classmethod(getListeDossiers)
"""Méthode statique qui vide la liste des dossiers"""
def truncateDossier(cls):
del Dossier.__listeDossiers[:]
truncateDossier = classmethod(truncateDossier)
def __init__(self, url, structure_ge, reference, nom_commune, insee_commune, date, geometrie_kml=None):
"""Constructeur de dossier"""
self.__id = self.__getID(url)
self.__structure_ge = structure_ge
self.__reference = reference
self.__nom_commune = nom_commune
self.__insee_commune = insee_commune
self.__date = date
self.__document = list()
if geometrie_kml != None:
self.__geometrie_kml = KML(geometrie_kml)
else:
self.__geometrie_kml = None
self.__envelope = None
def __getID(self, url):
element = url.split("/")
zipFile = element[5].split(".")
return zipFile[0]
def getReference(self):
return self.__reference.replace("/", "_")
def getInformations(self):
return {
"structure": self.__structure_ge,
"reference": self.__reference,
"nom_commune": self.__nom_commune,
"insee_commune": self.__insee_commune,
"date": self.__date,
"id": self.__id,
}
def getURLArchiveZIP(self):
return "dossiers/" + self.__id + ".zip"
def getURLDossier(self):
return "dossiers/" + self.__id
def getGeometries(self):
if self.__geometrie_kml == None:
return None
else:
return self.__geometrie_kml.getGeometries()
def getEnvelope(self):
if self.__geometrie_kml == None:
return None
elif self.__envelope == None:
self.__envelope = self.__geometrie_kml.getEnvelope()
return self.__envelope
else:
return self.__envelope
def getDocument(self, numDocument):
return self.__document[numDocument]
def getDocuments(self):
return self.__document
def deleteDetails(self):
self.__document = list()
self.__geometrie_kml = None
self.__envelope = None
def loadDetails(self, data):
"""Méthode qui permet de rajouter des informations à un dossier à partir du XML"""
tree = ET.parse(StringIO.StringIO(data))
root = tree.getroot()
for child in root[0]:
if child.tag == "id" and child.text != self.__id:
raise ErreurDossierException, "Erreur dossier"
if child.tag == "geometrie_kml":
geometrie = ET.tostring(child)
geometrie = geometrie.replace("<geometrie_kml>", "")
geometrie = geometrie.replace("</geometrie_kml>", "")
self.__geometrie_kml = KML(geometrie)
if child.tag == "document":
if child[0].tag == "description" and child[1].tag == "fichier":
tab = child[1].text.split(".")
extension = tab[1]
tab = child[2].attrib["href"].split("/")
id = tab[5]
self.__document.append(Document(id, child[0].text, extension))
else:
raise ErreurAPIException, "Changement de l'API"
'test.py -d MinDistance -i InputPathsCommaSeparated -o OutputFile')
sys.exit()
elif opt in ("-d"):
MinDistance = int(arg)
elif opt in ("-i"):
InputPaths = str(arg)
elif opt in ("-o"):
KMLFileName = str(arg)
print('Min Distance is ' + str(MinDistance) + " Meters.")
from tkinter import filedialog
from KML import KML
import os
# Create KML object
MyKML = KML("Unnamed")
# Build a list of folders to scan if not provided on command line
FolderList = []
if (InputPaths == ""):
while True:
Foldername = filedialog.askdirectory(
title="Choose Folders to scan for picture files. Cancel when done."
)
if (Foldername == ""):
break
FolderList.append(Foldername)
else:
# Split InputPaths
FolderList = InputPaths.split(";")
def __init__(self, root):
self._root = root
self._kml = KML(root)
class StormTrack:
def __init__(self, root):
self._root = root
self._kml = KML(root)
def getStormTrack(self,
points,
stormTrackStart,
hazardStart,
hazardEnd,
motion=0,
footprint=0,
returnType="kml"):
# points is a list of the form [((lat, lon), t)]
# all times are in secs
motion = int(motion)
footprint = int(footprint)
pt, time1 = self.createStormTrack(points, stormTrackStart, hazardStart,
hazardEnd, motion, footprint, True)
# Determine the frame times
trackDuration = (hazardEnd - stormTrackStart)
times = self.getFrameTimes(stormTrackStart, trackDuration)
# Gather the points in the track
points = []
for tSec in times:
points.append((pt.PT_trackPoint(tSec), tSec))
ptTimeList = []
for point, tSec in points:
# Return ms in ptTimeList
ptTimeList.append(((point.lon, point.lat), tSec * 1000))
# Create polygon
hazardDuration = (hazardEnd - hazardStart)
minTime = hazardStart
maxTime = hazardStart + hazardDuration
# extendMin = extentMax = 10 km
extendMin = 10
extendMax = 20
polygon = pt.PT_enclosedBy(minTime, maxTime, extendMin, extendMax,
extendMin, extendMax)
polyDict = {}
polyPoints = []
for point in polygon:
polyPoints.append((point.lon, point.lat))
polyDict["outer"] = [polyPoints]
if returnType == "kml":
return self._kml.createStormTrack(points, polyDict)
else:
return polyDict, ptTimeList
def createStormTrack(self,
points,
stormTrackStart,
hazardStart,
hazardEnd,
motion,
footprint,
returnTime1=False):
# Create point track
# Input:
# points -- list of [(lon,lat), time)] where time is in milliseconds past 1970
# What about climate data?
# motion -- (speed, bearing)
# footprint -- what is that?
#
# Unpack points
i = 0
latLonList = []
timeList = []
for latLon, t in points:
lat, lon = latLon
latLon = LatLonCoord(lat, lon)
latLonList.append(latLon)
# Convert from ms to seconds
timeList.append(t)
i += 1
drtTime = hazardStart
# Initialize
pt = PointTrack()
if motion == 0:
speed = 20 # kts
bearing = 225 # degrees
else:
speed, bearing = motion
motion = Motion(speed, bearing)
if len(points) == 1:
pt._PT_latLon_motion_origTime(latLonList[0], timeList[0], motion,
drtTime)
elif len(points) == 2:
pt._PT_two_latLon_origTime(latLonList[0], timeList[0],
latLonList[1], timeList[1], drtTime)
elif len(points) == 3:
pt._PT_three_latLon_origTime(latLonList[0], timeList[0],
latLonList[1], timeList[1],
latLonList[2], timeList[2], drtTime)
if returnTime1: return pt, timeList[0]
else: return pt
def getFrameTimes(self, t0, duration):
times = []
# For now, just make it at 5-minute intervals
maxT = t0 + duration
while t0 < maxT:
times.append(t0)
t0 = t0 + 5 * 60
return times
