def read(self, extension=None, quality=None):
if quality is None:
quality = self.context.config.QUALITY
options = None
extension = extension or self.extension
try:
if FORMATS[extension] == 'JPEG':
options = [cv2.IMWRITE_JPEG_QUALITY, quality]
except KeyError:
# default is JPEG so
options = [cv2.IMWRITE_JPEG_QUALITY, quality]
try:
if FORMATS[extension] == 'WEBP':
options = [cv2.IMWRITE_WEBP_QUALITY, quality]
except KeyError:
options = [cv2.IMWRITE_JPEG_QUALITY, quality]
success, buf = cv2.imencode(extension, self.image, options or [])
data = buf.tostring()
if FORMATS[extension] == 'JPEG' and self.context.config.PRESERVE_EXIF_INFO:
if hasattr(self, 'exif') and self.exif != None:
img = JpegFile.fromString(data)
img._segments.insert(0, ExifSegment(self.exif_marker, None, self.exif, 'rw'))
data = img.writeString()
return data
def create_image(self, buffer, create_alpha=True):
self.extension = self.extension or '.tif'
self.no_data_value = None
# FIXME: opencv doesn't support gifs, even worse, the library
# segfaults when trying to decoding a gif. An exception is a
# less drastic measure.
try:
if FORMATS[self.extension] == 'GIF':
raise ValueError("opencv doesn't support gifs")
except KeyError:
pass
if FORMATS[self.extension] == 'TIFF':
self.buffer = buffer
img0 = self.read_tiff(buffer, create_alpha)
else:
imagefiledata = cv.CreateMatHeader(1, len(buffer), cv.CV_8UC1)
cv.SetData(imagefiledata, buffer, len(buffer))
img0 = cv.DecodeImageM(imagefiledata, cv.CV_LOAD_IMAGE_UNCHANGED)
if FORMATS[self.extension] == 'JPEG':
try:
info = JpegFile.fromString(buffer).get_exif()
if info:
self.exif = info.data
self.exif_marker = info.marker
except Exception:
pass
return img0
def read(self, extension=None, quality=None):
if not extension and FORMATS[self.extension] == 'TIFF':
# If the image loaded was a tiff, return the buffer created earlier.
return self.buffer
else:
if quality is None:
quality = self.context.config.QUALITY
options = None
self.extension = extension or self.extension
try:
if FORMATS[self.extension] == 'JPEG':
options = [cv2.IMWRITE_JPEG_QUALITY, quality]
except KeyError:
options = [cv2.IMWRITE_JPEG_QUALITY, quality]
if FORMATS[self.extension] == 'TIFF':
channels = cv2.split(numpy.asarray(self.image))
data = self.write_channels_to_tiff_buffer(channels)
else:
success, numpy_data = cv2.imencode(self.extension, numpy.asarray(self.image), options or [])
if success:
data = numpy_data.tostring()
else:
raise Exception("Failed to encode image")
if FORMATS[self.extension] == 'JPEG' and self.context.config.PRESERVE_EXIF_INFO:
if hasattr(self, 'exif'):
img = JpegFile.fromString(data)
img._segments.insert(0, ExifSegment(self.exif_marker, None, self.exif, 'rw'))
data = img.writeString()
return data
def create_image(self, buffer, create_alpha=True):
self.extension = self.extension or '.tif'
self.no_data_value = None
# FIXME: opencv doesn't support gifs, even worse, the library
# segfaults when trying to decoding a gif. An exception is a
# less drastic measure.
try:
if FORMATS[self.extension] == 'GIF':
raise ValueError("opencv doesn't support gifs")
except KeyError:
pass
if FORMATS[self.extension] == 'TIFF':
self.buffer = buffer
img = self.read_tiff(buffer, create_alpha)
else:
img = cv2.imdecode(np.frombuffer(buffer, np.uint8), -1)
if FORMATS[self.extension] == 'JPEG':
self.exif = None
try:
info = JpegFile.fromString(buffer).get_exif()
if info:
self.exif = info.data
self.exif_marker = info.marker
except Exception:
pass
return img
def create_image(self, buffer, create_alpha=True):
self.extension = self.extension or '.tif'
self.no_data_value = None
# FIXME: opencv doesn't support gifs, even worse, the library
# segfaults when trying to decoding a gif. An exception is a
# less drastic measure.
try:
if FORMATS[self.extension] == 'GIF':
raise ValueError("opencv doesn't support gifs")
except KeyError:
pass
if FORMATS[self.extension] == 'TIFF':
self.buffer = buffer
img0 = self.read_tiff(buffer, create_alpha)
else:
imagefiledata = cv.CreateMatHeader(1, len(buffer), cv.CV_8UC1)
cv.SetData(imagefiledata, buffer, len(buffer))
img0 = cv.DecodeImageM(imagefiledata, cv.CV_LOAD_IMAGE_UNCHANGED)
if FORMATS[self.extension] == 'JPEG':
try:
info = JpegFile.fromString(buffer).get_exif()
if info:
self.exif = info.data
self.exif_marker = info.marker
except Exception:
pass
return img0
def read(self, extension=None, quality=None):
if not extension and FORMATS[self.extension] == 'TIFF':
# If the image loaded was a tiff, return the buffer created earlier.
return self.buffer
else:
if quality is None:
quality = self.context.config.QUALITY
options = None
self.extension = extension or self.extension
try:
if FORMATS[self.extension] == 'JPEG':
options = [cv2.IMWRITE_JPEG_QUALITY, quality]
except KeyError:
options = [cv2.IMWRITE_JPEG_QUALITY, quality]
if FORMATS[self.extension] == 'TIFF':
channels = cv2.split(numpy.asarray(self.image))
data = self.write_channels_to_tiff_buffer(channels)
else:
success, numpy_data = cv2.imencode(self.extension, numpy.asarray(self.image), options or [])
if success:
data = numpy_data.tostring()
else:
raise Exception("Failed to encode image")
if FORMATS[self.extension] == 'JPEG' and self.context.config.PRESERVE_EXIF_INFO:
if hasattr(self, 'exif'):
img = JpegFile.fromString(data)
img._segments.insert(0, ExifSegment(self.exif_marker, None, self.exif, 'rw'))
data = img.writeString()
return data
def read(self, extension=None, quality=None):
if not extension and FORMATS[self.extension] == 'TIFF':
# If the image loaded was a tiff, return the buffer created earlier.
return self.buffer
else:
if quality is None:
quality = self.context.config.QUALITY
options = None
extension = extension or self.extension
# Check if we should write a JPEG. If we are allowing defaulting to jpeg
# and if the alpha channel is all white (opaque).
channels = None
if getattr(self.context.request, 'default_to_jpeg', True):
channels = cv2.split(numpy.asarray(self.image))
if len(channels) > 3 and numpy.all(channels[3] == 255):
extension = '.jpg'
try:
if FORMATS[extension] == 'JPEG':
options = [cv.CV_IMWRITE_JPEG_QUALITY, quality]
except KeyError:
# default is JPEG so
options = [cv.CV_IMWRITE_JPEG_QUALITY, quality]
if FORMATS[extension] == 'TIFF':
channels = channels or cv2.split(numpy.asarray(self.image))
data = self.write_channels_to_tiff_buffer(channels)
else:
data = cv.EncodeImage(extension, self.image, options
or []).tostring()
if FORMATS[
extension] == 'JPEG' and self.context.config.PRESERVE_EXIF_INFO:
if hasattr(self, 'exif'):
img = JpegFile.fromString(data)
img._segments.insert(
0, ExifSegment(self.exif_marker, None, self.exif,
'rw'))
data = img.writeString()
return data
def create_image(self, buffer):
# FIXME: opencv doesn't support gifs, even worse, the library
# segfaults when trying to decoding a gif. An exception is a
# less drastic measure.
try:
if FORMATS[self.extension] == 'GIF':
raise ValueError("opencv doesn't support gifs")
except KeyError:
pass
img = cv2.imdecode(np.frombuffer(buffer, np.uint8), -1)
if FORMATS[self.extension] == 'JPEG':
try:
info = JpegFile.fromString(buffer).get_exif()
if info:
self.exif = info.data
self.exif_marker = info.marker
except Exception:
pass
return img
def post(self, program=None, code=None, report=None, dataset=None):
headers = {}
params = {
'file_image': self.request.POST['file'],
'indexed_program': program.upper(),
'indexed_project_code': code,
'indexed_project_id': self.request.POST['project-id'],
'indexed_dataset_code': report,
'indexed_dataset_id': self.request.POST['dataset-id'],
'indexed_parent_code': report,
'unindexed_data_collectors': self.request.POST['data-collectors'],
'unindexed_last_modified_date':
self.request.POST['last_modified_date']
}
if self.request.get('subproject'):
params['indexed_subproject_code'] = report
params['indexed_subproject_id'] = self.request.POST[
'subproject-id']
params['indexed_dataset_code'] = dataset
params['indexed_parent_code'] = dataset
if self.request.get('special'):
logging.debug('FILE RECEIVED')
params['file_file'] = params.pop('file_image')
params['indexed_type'] = 'FILE'
if self.request.POST['file'].filename.lower().endswith(
tuple(['.jpg', '.jpeg'])):
image = JpegFile.fromString(params['file_file'].file.read())
try:
lat, lng = image.get_geo()
params['unindexed_latlng'] = str(lat) + ',' + str(lng)
logging.debug('FILE HAS GPS')
except:
logging.debug('FILE HAS NO GPS')
params['file_file'].file.seek(0)
else:
if self.request.POST['file'].filename.endswith(
tuple(['.kml', '.kmz'])):
logging.debug('KML RECEIVED')
params['file_kml'] = params.pop('file_image')
params['indexed_type'] = 'KML'
kml_type = 'PROJECT'
if params['file_kml'].filename.startswith('ACCESS-'):
kml_type = 'ACCESS'
ext = params['file_kml'].filename.split('.')[-1]
params['file_kml'].filename = kml_type + '-' + code + '-'
params['file_kml'].filename += self.request.get('kml')
params['file_kml'].filename += '.' + ext
query = APIData.query()
query = query.filter(APIData.indexed_data == 'TYPE->PROJECT')
query = query.filter(APIData.indexed_data == 'CODE->' + code)
query = query.filter(APIData.indexed_data == 'HAS_KML->1')
project = query.get(keys_only=True)
logging.debug('PROJECT QUERIED AND HAS KML')
logging.debug(project)
if not project:
params = {}
params['indexed_has_kml'] = '1'
update_api_data(self.request.POST['project-id'], params,
self.user, 'application/json')
elif self.request.POST['file'].filename.lower().endswith(
tuple(['.jpg', '.jpeg'])):
logging.debug('IMAGE RECEIVED')
try:
image = JpegFile.fromString(
params['file_image'].file.read())
except Exception as e:
logging.debug(e)
params['file_image'].file.seek(0)
try:
image = JpegFile.fromString(
StringIO(params['file_image'].file.read()).read())
except Exception as e:
logging.debug('Using StringIO')
traceback.print_exc()
self.response.set_status(500)
self.response.write('Image has invalid metadata')
return
try:
lat, lng = image.get_geo()
except Exception as e:
logging.debug('Image does not a have GPS data')
traceback.print_exc()
self.response.set_status(500)
self.response.write('Image does not a have GPS data')
return
params['unindexed_latlng'] = str(lat) + ',' + str(lng)
params['unindexed_date'] = ''
if image.exif.primary.GPS[0x7]:
logging.debug(image.exif.primary.GPS[0x7])
gps_time = ''
for a in image.exif.primary.GPS[0x7]:
if a.num < 10:
gps_time += '0' + str(a.num)
else:
gps_time += str(a.num)
gps_time += ':'
gps_time = gps_time[:-1]
logging.debug(gps_time)
params['unindexed_date'] = image.exif.primary.GPS[
0x1d] + ' ' + gps_time
logging.debug(params['unindexed_date'])
else:
try:
params[
'unindexed_date'] = image.exif.primary.ExtendedEXIF.DateTimeOriginal
except:
params['unindexed_date'] = datetime.datetime.now(
).strftime('%Y:%m:%d %H:%M:%S')
params['file_image'].file.seek(0)
params['indexed_type'] = 'IMAGE'
query = APIData.query()
query = query.filter(APIData.indexed_data == 'TYPE->PROJECT')
query = query.filter(APIData.indexed_data == 'CODE->' + code)
query = query.filter(APIData.indexed_data == 'HAS_IMAGE->1')
project = query.get(keys_only=True)
logging.debug('PROJECT QUERIED AND HAS IMAGE')
logging.debug(project)
if not project:
params = {}
params['indexed_has_image'] = '1'
update_api_data(self.request.POST['project-id'], params,
self.user, 'application/json')
else:
self.response.set_status(500)
self.response.write('File is invalid')
return
headers['Authorization'] = API_KEY
headers['Content-Type'] = 'multipart/form-data'
logging.debug(params)
write_to_api(params, self.user, headers['Content-Type'])
import json
import sys
import urllib2
from pexif import JpegFile
TIME_FORMAT = '%Y:%m:%d %H:%M:%S'
obj = {}
with open(sys.argv[1]) as f:
obj = json.loads(f.read())
for photo in obj['response']['photos']['items']:
date = datetime.datetime.fromtimestamp(photo['createdAt'])
loc = (photo['venue']['location']['lat'], photo['venue']['location']['lng'])
print photo['venue']['name']
url = "%soriginal%s" % (photo['prefix'], photo['suffix'])
req = urllib2.Request(url)
handler = urllib2.urlopen(req)
ef = JpegFile.fromString(handler.read())
exif = ef.get_exif()
primary = exif.get_primary()
ef.set_geo(loc[0], loc[1])
primary.DateTime = date.strftime(TIME_FORMAT)
ef.writeFile('photos/%s.jpg' % photo['id'])
