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'])]
def challenge_create(request):
if request.method == "POST":
form = ChallengeForm(request.POST)
if form.is_valid():
challenge = form.save(commit=False)
challenge.user = request.user
geometry = json.loads(challenge.geometry)
multipolygon = MultiPolygon()
for geo in geometry:
coordinates = geo['geometry']['coordinates'][0]
line_string = LineString()
first_point = None
for i in range(len(coordinates)):
coord = coordinates[i]
if i == 0:
first_point = Point(coord[0], coord[1])
continue
point = Point(coord[0], coord[1])
if i == 1:
line_string = LineString(first_point.coords,
point.coords)
else:
line_string.append(point.coords)
polygon = Polygon(line_string.coords)
multipolygon.append(polygon)
challenge.multipolygon = multipolygon
for geo in geometry:
geo['properties']['challenge_id'] = str(challenge.unique_id)
challenge.geometry = json.dumps(geometry)
challenge.save()
camera_make = form.cleaned_data['camera_make']
if not camera_make is None and len(camera_make) > 0:
for cm in camera_make:
challenge.camera_make.add(cm)
transport_type = form.cleaned_data['transport_type']
if not transport_type is None:
challenge.transport_type.clear()
if len(transport_type) > 0:
for transport_t in transport_type:
challenge.transport_type.add(transport_t)
messages.success(request, 'A challenge was created successfully.')
return redirect('challenge.my_challenge_list')
else:
form = ChallengeForm()
content = {
'form': form,
'pageName': 'Create Challenge',
'pageTitle': 'Create Challenge'
}
return render(request, 'challenge/capture/create.html', content)
def challenge_edit(request, unique_id):
challenge = get_object_or_404(Challenge, unique_id=unique_id)
if request.method == "POST":
form = ChallengeForm(request.POST, instance=challenge)
if form.is_valid():
challenge = form.save(commit=False)
challenge.user = request.user
challenge.updated_at = datetime.now()
challenge.save()
geometry = json.loads(challenge.geometry)
multipoly = MultiPolygon()
for geo in geometry:
coordinates = geo['geometry']['coordinates'][0]
lineString = LineString()
firstPoint = None
for i in range(len(coordinates)):
coor = coordinates[i]
if i == 0:
firstPoint = Point(coor[0], coor[1])
continue
point = Point(coor[0], coor[1])
if i == 1:
lineString = LineString(firstPoint.coords,
point.coords)
else:
lineString.append(point.coords)
polygon = Polygon(lineString.coords)
multipoly.append(polygon)
challenge.multipolygon = multipoly
for geo in geometry:
geo['properties']['challenge_id'] = str(challenge.unique_id)
challenge.geometry = json.dumps(geometry)
challenge.save()
transport_type = form.cleaned_data['transport_type']
if not transport_type is None:
challenge.transport_type.add(transport_type)
messages.success(
request,
'Challenge "%s" is updated successfully.' % challenge.name)
return redirect('challenge.index')
else:
form = ChallengeForm(instance=challenge)
content = {
'form': form,
'pageName': 'Edit Challenge',
'challenge': challenge,
'pageTitle': challenge.name + ' - Edit Challenge'
}
return render(request, 'challenge/edit.html', content)
def photographer_edit(request, unique_id):
photographer = get_object_or_404(Photographer, unique_id=unique_id)
if request.method == "POST":
form = PhotographerForm(request.POST, instance=photographer)
if form.is_valid():
photographer = form.save(commit=False)
photographer.user = request.user
photographer.updated_at = datetime.now()
photographer.save()
geometry = json.loads(photographer.geometry)
multipoly = MultiPolygon()
for geo in geometry:
coordinates = geo['geometry']['coordinates'][0]
lineString = LineString()
firstPoint = None
for i in range(len(coordinates)):
coor = coordinates[i]
if i == 0:
firstPoint = Point(coor[0], coor[1])
continue
point = Point(coor[0], coor[1])
if i == 1:
lineString = LineString(firstPoint.coords,
point.coords)
else:
lineString.append(point.coords)
polygon = Polygon(lineString.coords)
multipoly.append(polygon)
photographer.multipolygon = multipoly
for geo in geometry:
geo['properties']['photographer_id'] = str(
photographer.unique_id)
photographer.geometry = json.dumps(geometry)
photographer.save()
messages.success(
request, 'Photographer "%s" is updated successfully.' %
photographer.name)
return redirect('photographer.index')
else:
form = PhotographerForm(instance=photographer)
content = {
'form': form,
'pageName': 'Edit Photographer',
'photographer': photographer,
'pageTitle': photographer.name + ' - Edit Photographer'
}
return render(request, 'photographer/edit.html', content)
def photographer_create(request):
if request.method == "POST":
form = PhotographerForm(request.POST)
if form.is_valid():
photographer = form.save(commit=False)
photographer.user = request.user
geometry = json.loads(photographer.geometry)
multipoly = MultiPolygon()
for geo in geometry:
coordinates = geo['geometry']['coordinates'][0]
lineString = LineString()
firstPoint = None
for i in range(len(coordinates)):
coor = coordinates[i]
if i == 0:
firstPoint = Point(coor[0], coor[1])
continue
point = Point(coor[0], coor[1])
if i == 1:
lineString = LineString(firstPoint.coords,
point.coords)
else:
lineString.append(point.coords)
polygon = Polygon(lineString.coords)
multipoly.append(polygon)
photographer.multipolygon = multipoly
for geo in geometry:
geo['properties']['photographer_id'] = str(
photographer.unique_id)
photographer.geometry = json.dumps(geometry)
photographer.save()
messages.success(request,
'A photographer was created successfully.')
return redirect('photographer.my_photographer_list')
else:
form = PhotographerForm()
content = {
'form': form,
'pageName': 'Create Photographer',
'pageTitle': 'Create Photographer'
}
return render(request, 'photographer/create.html', content)
def photographer_create(request):
if request.method == "POST":
form = PhotographerForm(request.POST)
if form.is_valid():
photographer = form.save(commit=False)
photographer.user = request.user
geometry = json.loads(photographer.geometry)
multipolygon = MultiPolygon()
for geo in geometry:
coordinates = geo['geometry']['coordinates'][0]
lineString = LineString()
firstPoint = None
for i in range(len(coordinates)):
coor = coordinates[i]
if i == 0:
firstPoint = Point(coor[0], coor[1])
continue
point = Point(coor[0], coor[1])
if i == 1:
lineString = LineString(firstPoint.coords,
point.coords)
else:
lineString.append(point.coords)
polygon = Polygon(lineString.coords)
multipolygon.append(polygon)
photographer.multipolygon = multipolygon
for geo in geometry:
geo['properties']['photographer_id'] = str(
photographer.unique_id)
photographer.geometry = json.dumps(geometry)
photographer.save()
capture_types = form.cleaned_data['capture_type']
capture_method = form.cleaned_data['capture_method']
image_quality = form.cleaned_data['image_quality']
if capture_types is not None:
photographer.capture_type.clear()
for capture_type in capture_types:
photographer.capture_type.add(capture_type)
if capture_method is not None:
photographer.capture_method.clear()
for capture_m in capture_method:
photographer.capture_method.add(capture_m)
if image_quality is not None:
photographer.image_quality.clear()
for image_q in image_quality:
photographer.image_quality.add(image_q)
messages.success(request,
'A photographer was created successfully.')
return redirect('photographer.index')
else:
form = PhotographerForm()
content = {
'form': form,
'pageName': 'Create Photographer',
'pageTitle': 'Create Photographer'
}
return render(request, 'photographer/create.html', content)
def put(self, request, unique_id, version='v1'):
sequence = Sequence.objects.get(unique_id=unique_id)
if not sequence or sequence is None:
return Response({
'error': 'Sequence id is invalid',
'status': False
})
data = request.data
print(data)
message = ''
if 'google_street_view' in data.keys():
google_street_view = data['google_street_view']
print(google_street_view)
sequence.google_street_view = google_street_view
message += 'Google Street View is updated \n'
sequence.save()
if 'strava' in data.keys():
strava = data['strava']
print(strava)
sequence.strava = strava
message += 'Strava is updated \n'
sequence.save()
if not 'mapillary_user_token' in data.keys():
if message != '':
return Response({'message': message, 'status': True})
else:
return Response({
'error': 'Mapillary token is missing',
'status': False
})
token = data['mapillary_user_token']
mapillary = Mapillary(token, source='mtpdu')
map_user_data = mapillary.get_mapillary_user()
if not map_user_data:
return Response({
'error': 'Mapillary token is invalid',
'status': False
})
if not 'mapillary_sequence_key' in data.keys():
if message != '':
return Response({'message': message, 'status': True})
else:
return Response({
'error': 'Sequence key is missing',
'status': False
})
seq_key = data['mapillary_sequence_key']
sequence_json = mapillary.get_sequence_by_key(seq_key)
print('sequence_json')
if not sequence_json:
return Response({'error': 'Sequence is empty', 'status': False})
properties = sequence_json['properties']
geometry = sequence_json['geometry']
seq_key = properties['key']
if properties['username'] != map_user_data['username']:
return Response({
'error': 'You are not owner of this sequence',
'status': False
})
sequences = Sequence.objects.filter(seq_key=seq_key)[:1]
if sequences.count() > 0:
for seq in sequences:
if seq.unique_id == unique_id:
continue
tour_seqs = TourSequence.objects.filter(sequence=seq)
if tour_seqs.count() > 0:
for t_s in tour_seqs:
t_s.delete()
seq.delete()
sequence.user = request.user
if 'camera_make' in properties:
camera_makes = CameraMake.objects.filter(
name=properties['camera_make'])
if camera_makes.count() > 0:
c = camera_makes[0]
else:
c = CameraMake()
c.name = properties['camera_make']
c.save()
sequence.camera_make = c
sequence.captured_at = properties['captured_at']
if 'created_at' in properties:
sequence.created_at = properties['created_at']
sequence.seq_key = properties['key']
if 'pano' in properties:
sequence.pano = properties['pano']
if 'user_key' in properties:
sequence.user_key = properties['user_key']
if 'username' in properties:
sequence.username = properties['username']
sequence.geometry_coordinates_ary = geometry['coordinates']
sequence.image_count = len(geometry['coordinates'])
sequence.coordinates_cas = properties['coordinateProperties']['cas']
sequence.coordinates_image = properties['coordinateProperties'][
'image_keys']
if 'private' in properties:
sequence.is_private = properties['private']
lineString = LineString()
firstPoint = None
if sequence.image_count == 0:
firstPoint = Point(sequence.geometry_coordinates_ary[0][0],
sequence.geometry_coordinates_ary[0][1])
lineString = LineString(firstPoint.coords, firstPoint.coords)
else:
for i in range(len(sequence.geometry_coordinates_ary)):
coor = sequence.geometry_coordinates_ary[i]
if i == 0:
firstPoint = Point(coor[0], coor[1])
continue
point = Point(coor[0], coor[1])
if i == 1:
lineString = LineString(firstPoint.coords, point.coords)
else:
lineString.append(point.coords)
sequence.geometry_coordinates = lineString
sequence.is_published = True
sequence.save()
sequence.distance = sequence.get_distance()
sequence.save()
print('1')
p = threading.Thread(target=get_images_by_sequence,
args=(
sequence,
'mtpdu',
))
p.start()
print('2')
return JsonResponse({
'status': 'success',
'message':
'Sequence successfully was imported. Sequence will be published in about 10 minutes.',
'unique_id': str(sequence.unique_id)
})
def AnalyzeManuscript(page):
"""Analyze input text image and generate manuscript object
Parameters:
page (Django db object)"""
fPsd = page.image
sPath, _ = os.path.split(fPsd.path)
sPathAbs, _ = os.path.split(fPsd.name)
PrepareDirectory(os.path.join(sPath, 'lines'))
PrepareDirectory(os.path.join(sPath, 'glyphs'))
# Layers contain lines?
vIsLine = [False, True, True, False, False, False]
# Generate ManuscriptCollection object from layers
dbLayers = page.layer_set.order_by('number')
# Start with the background text layer
imManuscript = cv2.imread(dbLayers[0].image.path)
vManuscript = ManuscriptCollection(fPsd.name, imManuscript)
print('Before anything, horz: ' + str(vManuscript.horz))
# Add line mask layers to the ManuscriptCollection
for i in range(1, 6):
if vIsLine[i]:
print('layer %i' % (i + 1))
img = cv2.imread(dbLayers[i].image.path, cv2.IMREAD_GRAYSCALE)
vManuscript.populate(img, vIsLine[i])
print('After lines, before glyphs, horz: ' + str(vManuscript.horz))
# Add glyph mask layers to the ManuscriptCollection
for i in range(1, 6):
if not vIsLine[i]:
print('layer %i' % (i + 1))
img = cv2.imread(dbLayers[i].image.path, cv2.IMREAD_GRAYSCALE)
vManuscript.populate(img, vIsLine[i])
print('After glyphs and lines, before organize, horz: ' +
str(vManuscript.horz))
# Finalize sorting of lines and glyphs
vManuscript.organize_components()
print('After glyphs, lines, and organize, horz: ' + str(vManuscript.horz))
# Line regions in the facsimile
iGlyphInPage = 0 # Glyph counter for entire page
vPolyPoints = []
for i, line in enumerate(vManuscript.get_line_list()):
print('For line in vMS, i=%i' % i)
print(os.path.split(fPsd.name)[0] + '----' + sPathAbs)
time_zero = time.time()
# # Print out a np array so that it can be used as input
# for p in line.polygon:
# print('[%i, %i],' % tuple(p))
lsShape = LineString(line.polygon)
if len(lsShape) > 0 and not lsShape.closed:
lsShape.append(lsShape[0])
print(line.polygon[0])
print(lsShape)
print(lsShape.closed)
sRelFilename = os.path.join(sPathAbs, 'lines',
'{0:03d}.png'.format(i + 1))
imLine = Image.fromarray(
cv2.cvtColor(line.text_image, cv2.COLOR_RGBA2BGRA))
dbLine = page.line_set.create(number_in_page=i + 1,
image=DjangoImage(imLine, sRelFilename),
shape=lsShape)
# Glyph regions in each line in the facsimile
for j, glyph in enumerate(vManuscript.get_glyphs_by_line(line)):
iGlyphInPage += 1
lsShape = LineString(glyph.polygon)
if len(lsShape) > 0 and not lsShape.closed:
lsShape.append(lsShape[0])
sRelFilename = os.path.join(
sPathAbs, 'glyphs',
'{0:03d}_'.format(i + 1) + '{0:04d}.png'.format(j + 1))
imGlyph = Image.fromarray(
cv2.cvtColor(glyph.text_image, cv2.COLOR_RGBA2BGRA))
dbGlyph = dbLine.glyph_set.create(number_in_line=j + 1,
number_in_page=iGlyphInPage,
image=DjangoImage(
imGlyph, sRelFilename),
shape=lsShape)
# vPoly = dbGlyph.polygon_set.create(polygon_type='glyph', line=dbLine,
# x_min=glyph.Xmin, y_min=glyph.Ymin, x_max=glyph.Xmax, y_max=glyph.Ymax,
# x_cent=glyph.Xc, y_cent=glyph.Yc)
#
# for iPt in range(glyph.polygon.shape[0]):
# vI = glyph.polygon[iPt,:]
# # vPoly.polygonpoint_set.create(x_coordinate=vI[0],y_coordinate=vI[1],t_coordinate=iPt+1)
# vPolyPoint = m.PolygonPoint(polygon=vPoly,x_coordinate=vI[0],y_coordinate=vI[1],t_coordinate=iPt+1)
# vPolyPoints.append(vPolyPoint)
#
# print('Time elapsed: %f' % (time.time()-time_zero))
# time_zero = time.time()
m.PolygonPoint.objects.bulk_create(vPolyPoints)
print('Time elapsed: %f' % (time.time() - time_zero))
time_zero = time.time()
return True
def ajax_import(request, seq_key):
if not request.user.is_authenticated:
return JsonResponse({
'status': 'failed',
'message': "You can't change the status."
})
if request.method == 'POST':
# form = AddSequeceForm(request.POST)
# if form.is_valid():
# for unique_id in sequence_json.keys():
# sequence = Sequence.objects.get(unique_id=unique_id)
# if sequence is None:
# continue
# if sequence_json[unique_id]['name'] == '' or sequence_json[unique_id]['description'] == '' or sequence_json[unique_id]['transport_type'] == 0 or len(sequence_json[unique_id]['tags']) == 0:
# continue
form = AddSequeceForm(request.POST)
if form.is_valid():
# for i in range(len(request.session['sequences'])):
for feature in request.session['sequences']:
# feature = request.session['sequences'][i]
if feature['properties']['key'] == seq_key:
properties = feature['properties']
geometry = feature['geometry']
sequence = Sequence.objects.filter(seq_key=seq_key)[:1]
if sequence.count() > 0:
continue
else:
sequence = Sequence()
sequence.user = request.user
if 'camera_make' in properties:
sequence.camera_make = properties['camera_make']
sequence.captured_at = properties['captured_at']
if 'created_at' in properties:
sequence.created_at = properties['created_at']
sequence.seq_key = properties['key']
if 'pano' in properties:
sequence.pano = properties['pano']
if 'user_key' in properties:
sequence.user_key = properties['user_key']
if 'username' in properties:
sequence.username = properties['username']
sequence.geometry_coordinates_ary = geometry['coordinates']
sequence.image_count = len(geometry['coordinates'])
lineString = LineString()
firstPoint = None
if sequence.image_count == 0:
firstPoint = Point(
sequence.geometry_coordinates_ary[0][0],
sequence.geometry_coordinates_ary[0][1])
lineString = LineString(firstPoint.coords,
firstPoint.coords)
else:
for i in range(len(sequence.geometry_coordinates_ary)):
coor = sequence.geometry_coordinates_ary[i]
if i == 0:
firstPoint = Point(coor[0], coor[1])
continue
point = Point(coor[0], coor[1])
if i == 1:
lineString = LineString(
firstPoint.coords, point.coords)
else:
lineString.append(point.coords)
sequence.geometry_coordinates = lineString
sequence.coordinates_cas = properties[
'coordinateProperties']['cas']
sequence.coordinates_image = properties[
'coordinateProperties']['image_keys']
if 'private' in properties:
sequence.is_privated = properties['private']
sequence.name = form.cleaned_data['name']
sequence.description = form.cleaned_data['description']
sequence.transport_type = form.cleaned_data[
'transport_type']
sequence.is_published = True
sequence.save()
if form.cleaned_data['tag'].count() > 0:
for tag in form.cleaned_data['tag']:
sequence.tag.add(tag)
for tag in sequence.tag.all():
if not tag in form.cleaned_data['tag']:
sequence.tag.remove(tag)
# messages.success(request, "Sequences successfully imported.")
return JsonResponse({
'status': 'success',
'message': 'Sequence successfully imported.',
'unique_id': str(sequence.unique_id)
})
else:
errors = []
for field in form:
for error in field.errors:
errors.append(field.name + ': ' + error)
return JsonResponse({
'status': 'failed',
'message': '<br>'.join(errors)
})
return JsonResponse({
'status': 'failed',
'message': 'Sequence was not imported.'
})
