class Route(models.Model):
geom = models.LineStringField(srid=config.canonical_projection)
geom_dist = models.LineStringField(srid=config.google_projection,
null=True,
blank=True)
summary = models.CharField(max_length=100)
origin_taz = models.FloatField()
destination_taz = models.FloatField()
od_route_index = models.IntegerField()
travel_time = models.FloatField(null=True,
blank=True) #can always recover from JSON
json_contents = models.TextField()
objects = models.GeoManager()
class Meta:
unique_together = (("origin_taz", "destination_taz",
"od_route_index"), )
index_together = (("origin_taz", "destination_taz"), )
# Returns the string representation of the model.
def __unicode__(self):
return "OD: %s to %s, Travel Time: %s Centroid: %s" % (
self.origin_taz, self.destination_taz, self.travel_time
or 0, repr(self.geom.centroid.coords))
class Activity(models.Model):
'''
An Activity is anything that may produce data. Example Activity names include:
Dorado389_2011_117_01_117_01_decim.nc (stride=10),
20110415_20110418/20110418T192351/slate.nc (stride=10), 27710_jhmudas_v1.nc (stride=1).
'''
uuid = UUIDField(editable=False)
campaign = models.ForeignKey(Campaign, on_delete=models.CASCADE, blank=True, null=True)
platform = models.ForeignKey(Platform, on_delete=models.CASCADE)
name = models.CharField(max_length=256)
comment = models.TextField(max_length=2048)
startdate = models.DateTimeField()
plannedstartdate = models.DateTimeField(null=True)
enddate = models.DateTimeField(null=True)
plannedenddate = models.DateTimeField(null=True)
num_measuredparameters = models.IntegerField(null=True)
loaded_date = models.DateTimeField(null=True)
maptrack = models.LineStringField(null=True)
plannedtrack = models.LineStringField(null=True)
mappoint = models.PointField(srid=4326, spatial_index=True, dim=2, blank=True, null=True)
mindepth = models.FloatField(null=True)
maxdepth = models.FloatField(null=True)
activitytype = models.ForeignKey(ActivityType, on_delete=models.CASCADE, blank=True, null=True, default=None)
class Meta(object):
verbose_name='Activity'
verbose_name_plural='Activities'
app_label = 'stoqs'
def __str__(self):
return "%s" % (self.name,)
class LineFeature(SpatialFeature):
"""
Model used for representing user-generated linestring features. Inherits from SpatialFeature.
====================== ==============================================
Attribute Description
====================== ==============================================
``user`` Creator
``name`` Name of the object
``date_created`` When it was created
``date_modified`` When it was last updated.
``manipulators`` List of manipulators to be applied when geom
is saved.
``geometry_original`` Original geometry as input by the user.
``geometry_final`` Geometry after manipulators are applied.
====================== ==============================================
"""
geometry_orig = models.LineStringField(
srid=settings.GEOMETRY_DB_SRID,
null=True,
blank=True,
verbose_name="Original LineString Geometry")
geometry_final = models.LineStringField(
srid=settings.GEOMETRY_DB_SRID,
null=True,
blank=True,
verbose_name="Final LineString Geometry")
@classmethod
def mapnik_style(self):
try:
import mapnik
except:
import mapnik2 as mapnik
line_style = mapnik.Style()
ls = mapnik.LineSymbolizer(mapnik.Color('#444444'), 1.5)
ls.stroke_opacity = 0.5
r = mapnik.Rule()
r.symbols.append(ls)
line_style.rules.append(r)
return line_style
class Meta(Feature.Meta):
abstract = True
class FaultEdge(djm.Model):
'''
Fault edge
'''
owner = djm.ForeignKey('OqUser')
gid = djm.TextField()
name = djm.TextField(null=True)
description = djm.TextField(null=True)
last_update = djm.DateTimeField(editable=False, default=datetime.utcnow)
top = djm.LineStringField(srid=4326)
bottom = djm.LineStringField(srid=4326)
class Meta:
db_table = 'hzrdi\".\"fault_edge'
class TrackFeature(models.Model):
""" a GPS track with optional text
linestring is stored as lat,lon - ht is ignored because the geodjango admin widgets don't support it
"""
linestring = models.LineStringField(dim=2)
timestamp_start = models.DateTimeField(null=True,
blank=True,
verbose_name="Timestamp at start")
timestamp_end = models.DateTimeField(null=True,
blank=True,
verbose_name="Timestamp at end")
modifieddate = models.DateTimeField(auto_now_add=True)
owner = models.ForeignKey('users.user',
to_field='id',
on_delete=models.CASCADE)
text = models.TextField(null=True, blank=True, verbose_name="Text note")
lengthm = models.DecimalField(max_digits=12,
decimal_places=3,
null=True,
blank=True,
verbose_name="Track length in metres")
def __str__(self):
return '{0} {1}'.format(self.owner, self.timestamp_start)
def url(self):
return reverse('track-detail', args=[self.pk])
class Meta:
ordering = ['-timestamp_start']
unique_together = (("timestamp_start", "owner"), )
class Route(models.Model):
line = models.ForeignKey(Line)
# Data
name = models.CharField(
max_length=1024,
help_text=_('Nama rute (lokasi berangkat dan tujuan)'),
**OPT)
path = models.LineStringField(srid=SRID, **OPT)
locations = ArrayField(models.CharField(max_length=1024),
help_text=_('Daerah yang dilewati rute'),
**OPT)
order = models.IntegerField(default=0)
info = HStoreField(**OPT)
# Author
author = models.ForeignKey(Author)
# Internal
enabled = models.BooleanField(default=False)
created = models.DateTimeField(auto_now_add=True)
updated = models.DateTimeField(auto_now_add=True)
def __str__(self):
return self.name
class Line(Shape):
shape = models.LineStringField()
objects = GeoInheritanceManager()
geo_objects = models.GeoManager()
class Meta:
app_label = 'base_map'
db_table = 'base_map_line'
class InterstateProj3D(models.Model):
name = models.CharField(max_length=30)
line = models.LineStringField(dim=3, srid=32140)
objects = models.GeoManager()
def __str__(self):
return self.name
class NetworkBike(models.Model):
ogc_fid = models.IntegerField(primary_key=True)
geometry = models.LineStringField(srid=26986)
objects = models.GeoManager()
class Meta:
db_table = 'survey_network_bike'
class SimpleSource(models.Model):
'''
Simple source view, needed for GeoNode integration
'''
owner_id = models.IntegerField()
input_id = models.IntegerField()
gid = models.TextField()
name = models.TextField()
description = models.TextField()
si_type = models.TextField()
tectonic_region = models.TextField()
rake = models.FloatField()
dip = models.FloatField()
upper_depth = models.FloatField()
lower_depth = models.FloatField()
edge = models.LineStringField(srid=4326)
outline = models.PolygonField(srid=4326)
mfd_type = models.TextField()
magnitude_type = models.CharField(max_length=2)
min_val = models.FloatField()
max_val = models.FloatField()
total_cumulative_rate = models.FloatField()
total_moment_rate = models.FloatField()
evd_bin_size = models.FloatField()
evd_values = FloatArrayField()
tgr_a_val = models.FloatField()
tgr_b_val = models.FloatField()
class Meta: # pylint: disable=C0111,W0232
db_table = 'hzrdi\".\"simple_source'
class Route(models.Model):
id = models.UUIDField("id", primary_key=True)
created_at = models.DateTimeField(auto_now_add=True)
coordinates = models.LineStringField(blank=True)
cached_distance = models.FloatField(blank=True, default=0)
def add_point(self, lon_lat: Tuple[float, float]) -> None:
"""
Add a point(GPS location) to a route (LineString)
:param lon_lat: Tuple[float, float] a point to add to the linestring
"""
if not self.coordinates:
self.coordinates = LineString(lon_lat, lon_lat)
else:
self.coordinates.append(lon_lat)
def older_than_a_day(self) -> bool:
"""
Evaluate if the creation Route datetime created more than a day
"""
return self.created_at < datetime.datetime.now() - datetime.timedelta(
days=1)
class Meta:
indexes = [models.Index(fields=['-cached_distance'])]
class Track(models.Model):
name = models.CharField(max_length=50)
title = models.CharField(max_length=50, null=True, blank=True)
desc = models.TextField(blank=True)
river = models.ForeignKey(River)
time = models.DateTimeField()
camera = models.CharField(max_length=50, blank=True, null=True)
length = models.FloatField(null=True, blank=True)
data_path = models.CharField(max_length=50, blank=True, null=True)
width = models.IntegerField(null=True, blank=True)
height = models.IntegerField(null=True, blank=True)
offset = models.IntegerField(null=True, blank=True)
maxResolution = models.FloatField(null=True, blank=True)
numZoomLevels = models.FloatField(null=True, blank=True)
direction = models.FloatField(null=True, blank=True)
#tileWidth = models.IntegerField(null=True,blank=True)
geom = models.LineStringField(null=True, blank=True)
objects = models.GeoManager()
class Meta:
verbose_name_plural = "Tracks"
def __unicode__(self):
return self.title
class Interstate(NamedModel):
length = models.DecimalField(max_digits=6, decimal_places=2)
path = models.LineStringField()
class Meta:
app_label = 'layermap'
required_db_features = ['gis_enabled']
class Segment(models.Model):
"""Segments from segment shapefile (dike segments).
Columns from the ``.dbf``::
LENGTH,N,13,11
CATEGORIE,C,128
BEHEERDER,C,128
DIJKRING,C,50
DKRNR,C,20
DKRDEEL,C,20
TRAJECT,C,30
VAK,C,30
WV21_WEL,N,19,11
The ``mapping`` attribute on this class maps the column names to our
fields. Used by the import_segments management command.
"""
mapping = {
'name': 'DIJKRING',
'maintainer': 'BEHEERDER',
'code': 'VAK',
}
name = models.CharField(max_length=50, null=True, blank=True)
maintainer = models.CharField(max_length=128, null=True, blank=True)
code = models.CharField(max_length=30, null=True, blank=True)
the_geom = models.LineStringField(srid=4326)
objects = models.GeoManager()
class Meta:
verbose_name = _('Dike segment')
verbose_name_plural = _('Dike segments')
class MultiuseTrail(models.Model):
ogc_fid = models.IntegerField(primary_key=True)
geom = models.LineStringField()
class Meta:
managed = False
db_table = 'active_multiuse_trail'
class BikeLane(models.Model):
objectid = models.IntegerField(primary_key=True)
geom = models.LineStringField()
class Meta:
managed = False
db_table = 'bike_lanes'
class Feature(models.Model):
# TODO: map and type are reserved - problem?
user = models.ForeignKey(settings.AUTH_USER_MODEL,
related_name='features', on_delete=models.CASCADE)
map = models.ForeignKey('main.Map', db_column='map',
related_name='features', on_delete=models.CASCADE)
# preferred name (toponym[0])
title = models.CharField(max_length=255)
# used if map/project has pre-populated list of names (e.g. bregel)
src_name = models.ForeignKey('main.Name', db_column="src_name", null=True,
related_name='src_name',on_delete=models.CASCADE)
placetype = models.CharField(max_length=20, blank=False, null=False)
jsonb = JSONField(blank=True, null=True) # includes when
# write one at creation, for heck of it
geom_point = geo.PointField(blank=True, null=True)
geom_line = geo.LineStringField(blank=True, null=True)
geom_poly = geo.PolygonField(blank=True, null=True)
def __str__(self):
#return self.name+'_'+str(self.id)
return self.title
class Meta:
managed = True
db_table = 'features'
class Answer(models.Model):
survey_session = models.ForeignKey("SurveySession",
on_delete=models.CASCADE)
question = models.ForeignKey("Question", on_delete=models.CASCADE)
parent_answer_id = models.ForeignKey('self',
default=None,
null=True,
blank=True,
on_delete=models.CASCADE)
choice = models.ManyToManyField("OptionChoice")
numeric = models.FloatField(null=True, blank=True)
text = models.TextField(null=True, blank=True)
yn = models.BooleanField(null=True, blank=True) #yes-no
point = geomodels.PointField(null=True, blank=True)
line = geomodels.LineStringField(null=True, blank=True)
polygon = geomodels.PolygonField(null=True, blank=True)
class Meta:
app_label = 'survey'
def subAnswers(self):
if not hasattr(self, "__sacache"):
subanswers = Answer.objects.filter(parent_answer_id=self)
subquestions = self.question.subQuestions()
self.__sacache = {}
for subquestion in subquestions:
self.__sacache[subquestion] = list(
filter(lambda a: a.question == subquestion, subanswers))
return self.__sacache
class Shape(models.Model):
shape_id = models.TextField(primary_key=True, db_column='shape_id')
the_geom = models.LineStringField()
class Meta:
db_table = 'gtfs_shape_geoms'
managed = False
class DigitrafficCommon(models.Model):
geojson = models.LineStringField(dim=3, srid=4326)
# Non-model fields
objects = DataFrameManager()
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.old_geojson = self.geojson
self.period = settings.DIGITRAFFIC.get("PERIOD_HOURS") * 60 * 60 * 1000
def filter_geojson(self):
created = not self.pk
# Join line with previous one
if not created and self.old_geojson != self.geojson:
self.geojson = self.old_geojson + self.geojson
# Filter based on period
if self.geojson.z[-1] - self.geojson.z[0] >= self.period:
for i in range(len(self.geojson)):
if self.geojson.z[-1] - self.geojson.z[i] <= self.period:
if len(self.geojson) - i > 2:
self.geojson = LineString(self.geojson[i:])
break
class Meta:
abstract = True
class Watergang(geo.Model):
gml_id = models.CharField(max_length=254)
identifica = models.CharField(max_length=20, verbose_name='identificatie')
brontype = models.CharField(max_length=11)
bronbeschr = models.CharField(max_length=139)
bronactual = models.CharField(max_length=10)
bronnauwke = models.FloatField()
dimensie = models.CharField(max_length=2)
objectbegi = models.CharField(max_length=23)
versiebegi = models.CharField(max_length=23)
visualisat = models.IntegerField()
tdncode = models.IntegerField()
breedtekla = models.CharField(max_length=13, verbose_name='breedteklasse')
functie = models.CharField(max_length=14)
hoofdafwat = models.CharField(max_length=3, verbose_name='hoofdafwatering')
hoogtenive = models.IntegerField()
status = models.CharField(max_length=10)
typeinfras = models.CharField(max_length=18)
typewater = models.CharField(max_length=23, verbose_name='type watergang')
voorkomenw = models.CharField(max_length=8)
naamnl = models.CharField(max_length=24, verbose_name='naam')
fysiekvoor = models.CharField(max_length=21)
#sluisnaam = models.CharField(max_length=22)
geom = geo.LineStringField(srid=28992)
objects = geo.GeoManager()
@staticmethod
def autocomplete_search_fields():
return ("identifica__icontains", "naamnl__icontains")
def __unicode__(self):
return self.identifica
class Meta:
verbose_name_plural = 'Watergangen'
class Shape(models.Model, GTFSModel):
source = models.ForeignKey(settings.GTFS_SOURCE_MODEL,
null=True,
db_index=True)
shape_id = models.CharField(max_length=20, db_index=True)
path = models.LineStringField(geography=True, null=True)
objects = models.GeoManager()
@classmethod
def gtfs_generate(cls, source, reader):
shape_id = None
coords = []
for row in reader:
if (shape_id is not None) and (shape_id != row['shape_id']):
path = geos.LineString(coords)
coords = []
yield Shape(source=source, shape_id=shape_id, path=path)
shape_id = row['shape_id']
coords.append(
(float(row['shape_pt_lon']), float(row['shape_pt_lat'])))
if shape_id is not None:
path = geos.LineString(coords)
yield Shape(source=source, shape_id=shape_id, path=path)
class Meta:
unique_together = (("source", "shape_id"))
class LineOi(models.Model):
name = models.CharField(max_length=50)
line_feature = models.LineStringField()
objects = models.GeoManager()
def __unicode__(self):
return self.name
class Street(models.Model):
"""
Street centerline data.
"""
street_name = models.CharField(max_length=100)
line = models.LineStringField(srid=900913)
city = models.ForeignKey("City")
left_low_address = models.IntegerField(default=0)
left_high_address = models.IntegerField(default=0)
right_low_address = models.IntegerField(default=0)
right_high_address = models.IntegerField(default=0)
objects = models.GeoManager()
def __unicode__(self):
return self.street_name
def natural_key(self):
return self.street_name
def get_absolute_url(self):
return "/street/%i/" % self.id
class Interstate2D(models.Model):
name = models.CharField(max_length=30)
line = models.LineStringField(srid=4269)
objects = models.GeoManager()
def __str__(self):
return self.name
class Track(models.Model):
name = models.CharField(max_length=30)
line = models.LineStringField()
objects = models.GeoManager()
def __unicode__(self):
return self.name
class Track(models.Model):
track = models.LineStringField(null=True)
created = models.DateTimeField(auto_now=True)
device = models.ForeignKey(Device,
related_name='tracks',
on_delete=models.CASCADE)
@property
def start(self):
try:
return self.locations.earliest('timestamp').timestamp
except Location.DoesNotExist:
return None
@property
def end(self):
try:
return self.locations.latest('timestamp').timestamp
except Location.DoesNotExist:
return None
@property
def length(self):
line = LineString(
[location.point for location in self.locations.all()], srid=4326)
line.transform(3395)
return line.length / 1000
class DriveNetwork(models.Model):
start = models.CharField(max_length=20)
end = models.CharField(max_length=20)
geometry = models.LineStringField(srid=4326, null=True)
def __str__(self):
return "drive network -> " + "start: " + str(self.start) + ", end: " + str(self.end)
class Ride(models.Model):
timestamps = ArrayField(models.DateTimeField())
filename = models.CharField(max_length=32)
geom = models.LineStringField()
start = models.PointField(null=True)
end = models.PointField(null=True)
legs = ArrayField(models.BigIntegerField(), default=list)
class EarthquakeMMIContour(models.Model):
"""Earthquake MMI Contour Model."""
class Meta:
"""Meta class."""
app_label = 'realtime'
earthquake = models.ForeignKey(Earthquake, related_name='contours')
geometry = models.LineStringField(
verbose_name=_('Geometry of the MMI contour'),
help_text=_('Geometry of the MMI contour'),
dim=3,
blank=False)
mmi = models.FloatField(verbose_name=_('MMI value'),
help_text=_('MMI value'),
blank=False)
properties = models.TextField(
verbose_name=_('JSON representations of feature properties.'),
help_text=_('JSON representations of feature properties.'),
blank=False)
objects = EarthquakeMMIContourManager()
def __unicode__(self):
description = u'MMI Contour {mmi} of {event_id_formatted}'.format(
mmi=self.mmi,
event_id_formatted=self.earthquake.event_id_formatted)
return description
