def add_comment():
user = utils.session_check(request)
board = models.Board(request.args.get('board'))
post = models.Post(id=request.args.get('post'), board=board)
if 'subject' in request.form:
subject = request.form['subject'][:int(cfg['max_subject_length'])]
else:
subject = ''
comment = request.form['comment'][:int(cfg['max_comment_length'])]
if not user or user.fng:
return utils.response(
403,
'You have been banned or have never visited before. If its the latter visit home first.',
user)
if not board.name:
return utils.response(404, 'That board does not exist.', user)
if not utils.restrict_check(request, board):
return utils.response(
403, 'You have been banned from posting in this board.', user)
post = models.Post(id=request.args.get('post'), board=board)
if not post.board:
return utils.response(404, 'That post does not exist.', user)
if post.thread == 0:
thread = post.id
else:
thread = post.thread
if 'file' in request.files:
file = request.files['file']
if not utils.allowed_file(file):
return utils.response(
400, 'The image is of an unacceptable format or too large.',
user)
img = models.Image(file=file)
if not img:
return utils.response(500, 'Something went wrong. Try again later',
user)
else:
img = models.Image(dummy=True)
img.id = 0
comment = ">>{}\n{}".format(post.id, comment)
post = models.Post(board=board,
author=user,
subject=subject,
comment=comment,
image=img.id,
thread=thread)
if post:
return utils.response(201, post.dictate(), user)
else:
return utils.response(500, 'Something went wrong. Try again later.',
user)
def process(self):
hdus = [h for h in pyfits.open(self.file_name) \
if not isinstance(h, TableHDU)]
self.log.info('Opened image %s and found %d extension(s).' \
% (self.file_name, len(hdus)))
# Do we have several extensions, a data cube or a simple single
# extension?
processed = None
if (len(hdus) == 1):
# case 1 or 3: data cube or SIF.
hdu = hdus[0]
if (len(hdu.data.shape) > 2):
processed = self.process_cube(image=hdu)
elif (len(hdu.data.shape) == 2):
processed = self.process_sif(image=hdu)
else:
raise (NotImplementedError('1-D images are not supported.'))
# Case 2: MEF.
else:
processed = self.process_mef(image=hdus)
# Finally, create an instance variable to hold the result.
setattr(self, self.output_info[0][0], models.Image(processed))
return (0)
def create(self, name, data, metadata, user_id=dpy.IN):
key = ndb.Key(
models.User, user_id, models.Image, models.Image.allocate_ids(1)[0])
image = models.Image(key=key, name=name, metadata=metadata)
image.url = self._writer.write(key.urlsafe(), data)
image.put()
return image
def get(self, pageid):
user, site = self.us()
page = ndb.Key('Page', long(pageid), parent=site.key).get()
if not user or not page:
return
spec = page.spec()
bpid = models.BlogPost.allocate_ids(size=1, parent=page.key)[0]
bpkey = ndb.Key('BlogPost', bpid, parent=page.key)
imkey = ndb.Key('Image', '0', parent=bpkey)
im = models.Image(key=imkey,
width=spec['postimagesz'][0],
height=spec['postimagesz'][1])
bp = models.BlogPost(key=bpkey,
title='Post Title',
author=user.first_name,
image=imkey)
im.put_async()
bp.put_async()
self.redirect(
webapp2.uri_for('edit-v1',
sitename=site.name,
pagename=page.name,
v1=bpid))
def upload():
if request.method == "POST":
type = request.form.get('type')
id = request.form.get('id')
uploaded_files = flask.request.files.getlist('file[]')
if type == 'photo':
info = models.Info.objects.get()
for f in range(0,len(uploaded_files)):
filename = secure_filename(uploaded_files[f].filename)
uploaded_files[f].save(UPLOAD_FOLDER + 'info/' + filename)
info.photo = filename
info.save()
return 'success'
else:
project = models.Project.objects.get(id=id)
for f in range(0,len(uploaded_files)):
filename = secure_filename(uploaded_files[f].filename)
if uploaded_files[f] and allowed_file(filename):
uploaded_files[f].save(UPLOAD_FOLDER + id + '/' + filename)
if type == 'image':
image = models.Image()
image.filename = filename
project.images.append(image)
elif type == 'thumb':
project.thumbnail = filename
elif type == 'thumb_hover':
project.thumbnailHover = filename
project.save()
return 'success'
async def addImage(image: UploadFile = File(...),
article: models.Article = Depends(getArticle),
db: Session = Depends(get_db)):
extension = os.path.splitext(image.filename)[1]
if extension.lower() not in [".png", ".jpg", ".jpeg"]:
raise HTTPException(status_code=status.HTTP_415_UNSUPPORTED_MEDIA_TYPE,
detail="file type not supported: %s" % extension)
new_image = models.Image()
new_image.original_file_name = image.filename
new_image.article = article
db.add(new_image)
db.flush()
file_name = "".join([str(new_image.id), extension])
new_image.storage_path = "/".join(
["upload_data",
str(article.project_id),
str(article.id), file_name])
db.commit()
Path(os.path.dirname(new_image.storage_path)).mkdir(parents=True,
exist_ok=True)
with open(new_image.storage_path, 'ab') as f:
for chunk in iter(lambda: image.file.read(10000), b''):
f.write(chunk)
return article
def fetch_images_from_redis_add_to_db(user, image_uuids):
try:
saved_image_ids = set(user.images or [])
for uuid in image_uuids:
key = 'image:%s' % uuid
image_data = images_redis.get(key)
if not image_data:
raise Exception('Could Not Find Image in Cache')
image_data = json.loads(image_data)
image = models.Image(**image_data)
saved_image = db.session.query(models.Image).filter_by(url=image.url,
width=image.width,
height=image.height,
score=image.score).first()
if saved_image:
saved_image_ids.add(saved_image.id)
continue
db.session.add(image)
db.session.flush()
saved_image_ids.add(image.id)
saved_image_ids = list(saved_image_ids)
user.images = saved_image_ids
db.session.add(user)
db.session.commit()
except Exception as e:
db.session.rollback()
raise Exception(str(e))
def get(self):
images = models.Image().all()
self.generate('browseimages.html',
template_values = {
'images': images,
})
def add_image(values, project):
#session = get_session()
session = inspect(project).session
with session.begin():
image_ref = models.Image()
image_ref.update(values)
image_ref.project = project
image_ref.save(session=session)
def create_image(self, filename):
image = models.Image(
filename=filename,
user=self.current_user
)
if image not in self.current_user.images:
self.current_user.images.append(image)
self.session.add(image)
return image
def insert_image(filename):
with session_scope() as s:
img = None
if not check_exists_image(filename):
img = models.Image(filename=filename,
created_at=dt_now(),
updated_at=dt_now())
s.add(img)
s.commit()
return img
def create_image_and_add_to_cache(image_url, width, height, score):
existing_images = get_existing_images(score)
if existing_images and len(existing_images) > 0:
return existing_images
image = models.Image(**{
'url': image_url,
'width': width,
'height': height,
'score': score
})
image.add_image_to_cache()
return [image.uuid]
def testDeleteWithM2M(self):
cartoon = models.Cartoon.objects.get(vid=1)
cartoon.publish()
with manager.SwitchSchema('public'):
self.assertEqual(models.Cartoon.normal.all().count(), 2)
image = models.Image(pk=1)
self.assertEqual(image.cartoons.all().count(), 1)
cartoon.delete()
self.assertEqual(image.cartoons.all().count(), 0)
def add_image(req_file):
origin_filename, file_ext = os.path.splitext(req_file.filename)
g_id = get_id(list(models.images.keys()))
g_filename = str(g_id) + file_ext
save_filename = os.path.join(config['image_path'], g_filename)
req_file.save(save_filename)
g = models.Image(g_id, g_filename, req_file.filename)
models.images[g.id] = g
models.save()
return errcode.OK
def testReverseM2MDeleteVersion(self):
cartoon = models.Cartoon.objects.get(vid=1)
cartoon.publish()
with manager.SwitchSchema('public'):
self.assertEqual(models.Cartoon.normal.all().count(), 2)
klass = cartoon.get_version_class()
klass.normal.filter(vid__gt=1).delete()
self.assertEqual(models.Cartoon.normal.all().count(), 1)
image = models.Image(pk=1)
self.assertEqual(image.cartoons.all().count(), 1)
def test_update(self):
self.client.update.return_value = self.TEST_IMAGE
resp = self.app.put_json(
self.API_PREFIX + '/' + self.TEST_IMAGE_JSON['key'], {
'delta': self.TEST_IMAGE_JSON,
'mask': ['metadata']
})
self.assertEqual(self.get_status_code(resp), 200)
self.assertEqual(resp.json, {'image': self.TEST_IMAGE_JSON})
self.client.update.assert_called_with(
self.TEST_IMAGE.key,
models.Image(name=self.TEST_IMAGE.name,
metadata=self.TEST_IMAGE.metadata), ['metadata'])
def add(self, filepath, name):
filename = filepath.split("/")[-1]
statinfo = os.stat(filepath)
size = util.convert_size(statinfo.st_size)
with open(filepath) as f:
md5sum = hashlib.md5(f.read()).hexdigest()
destname = os.path.join(CONF.config_dir, "images", md5sum)
shutil.copyfile(filepath, destname)
image = models.Image(name=name,
path=destname,
size=size,
status="available",
md5sum=md5sum)
self.session.add(image)
self.session.commit()
def image(id=0, ext=0):
res = models.Image(id=id)
if not res:
return flask.make_response(
flask.jsonify({
'code': '404',
'status': 'error',
'content': 'Image not found'
}), 404)
response = flask.make_response(res.data)
response.headers.set('Content-Type', 'image/{}'.format(res.type))
response.headers.set('Content-Disposition',
'attachment',
filename='{}.{}'.format(res.og_name, res.type))
return response
def get_images():
image_list = []
for image in database.Image.select():
im = models.Image(
file_url="http://{endpoint}/{bucket}/{filename}".format(
endpoint=config.aws_s3_endpoint,
bucket=image.bucket,
filename=image.filename),
display_url="{app_path}\{shortcode}".format(
app_path=config.app_path, shortcode=image.url),
timestamp=image.timestamp,
shortcode=image.url)
image_list.append(im)
return sorted(image_list, key=lambda image: -image.timestamp)
def post(self):
img = self.request.get("imgfile")
if not img:
self.response.write("error!")
else:
image = models.Image(image=db.Blob(img))
image.put()
num = 0
short = models.ImageKeyRel.gql(
"WHERE short != -1 ORDER BY short DESC").fetch(limit=1)
if short:
num = short[0].short + 1
rel = models.ImageKeyRel(key_=str(image.key()), short=num)
rel.put()
self.response.out.write(
'<meta http-equiv="refresh" content=".5;URL=/' +
base36.base36encode(num) + '">')
def post(self):
if self.session.get('user'):
now = datetime.now()
seconds = time.mktime(now.timetuple())
if (self.session.get('last_activity')
and (seconds - self.session.get('last_activity')) <=
max_expire_age):
self.session['last_activity'] = seconds
upload_files = self.get_uploads('file-es[]')
n = 0
while n < len(upload_files):
blob_info = upload_files[n]
validImage = methods.validateImage(blob_info)
if (n <= 10 and validImage):
img = models.Image(user=self.session.get('user'),
public=self.request.POST.get(
"optradio") == "public",
blob_key=blob_info.key())
img.put()
n = n + 1
self.redirect('/main')
else:
template_values = {
'title':
"Session expired",
'errors': [
"Your session has been expired, you will be redirected to login page"
]
}
template = JINJA_ENVIRONMENT.get_template(
"/templates/alert.html")
self.response.write(template.render(template_values))
else:
template_values = {
'title':
"Unauthorized access",
'errors':
["Unauthorized access, you will be redirected to login page"],
'sessionError':
"Session expired"
}
template = JINJA_ENVIRONMENT.get_template("/templates/alert.html")
self.response.write(template.render(template_values))
def process(self, ufile):
ekey = self.request.get('ekey')
if ekey != 'new':
c = db.get(db.Key(ekey))
else:
c = models.Image()
# Global Properties
c.title = self.request.get('title')
c.pubdate = datetime.strptime(self.request.get('pubdate'), '%b %d %Y %I:%M %p')
c.text = self.request.get('text')
c.acl = self.request.get('acl')
c.license = self.request.get('license')
tags = string.split(string.replace(self.request.get('tags'),', ',','),',')
c.type = self.request.get('type')
cleantags = []
for tag in tags:
if tag != '':
cleantags.append(string.strip(tag))
c.tags = cleantags
c.type = self.request.get('type')
c.contenttype = self.request.get('content-type')
if ufile != 'exist':
c.file = ufile.key()
c.furl = images.get_serving_url(str(ufile.key()))
img = images.Image(blob_key=str(ufile.key()
))
img.im_feeling_lucky()
img.execute_transforms(output_encoding=images.JPEG,quality=1)
c.prop = float(img.height) / float(img.width)
c.fkey = self.request.get('key')
db.put(c)
if ekey != 'new':
self.redirect('/admin/editcontent?ekey=' + ekey + '&msg=' + c.title + ' Edited')
else:
self.redirect('/admin/imageform?msg=' + c.title + ' Added')
def OCR():
#GET image from recieved JSON and decode it
nparr = np.fromstring(request.data, np.uint8)
img = cv2.imdecode(nparr, cv2.IMREAD_COLOR)
#extract text from image using tesseract
txt = tesseract.extract_text(img)
#print(txt.encode('utf-8').strip())
Json = {'text': txt}
#####################################################################################
# save image and its content in a postgres database and send back the content #
#####################################################################################
try:
img = models.Image(image=request.data, infos=txt)
db.session.add(img)
db.session.commit()
return jsonify(Json)
except Exception as e:
return (str(e))
def create_images_add_to_cache_db_es(image_objs):
image_ids = []
for image_obj in image_objs:
try:
image = models.Image(**image_obj)
s3_url = util.upload_to_s3(image.title, image.url)
image.s3_url = s3_url
db.session.add(image)
db.session.commit()
image.add_image_to_cache()
eh.store_record(
'images', {
'title': image.title,
'title_suggest': image.title,
'description': image.description,
'description_suggest': image.description,
'id': image.id
})
image_ids.append(image.id)
except Exception as e:
db.session.rollback()
return image_ids
def post_image():
""" URL - /api/v1.0/image
Method - POST
Creates a new image from a URL and returns a ID that represents it.
"""
post_json = request.get_json()
if not post_json or not 'image' in post_json:
abort(400)
image = post_json['image']
# Check if the article is already in database
query = models.Image.query.filter_by(image=image).first()
if query:
return jsonify(query.dictionary()), 201
title = post_json.get("title", "")
caption = post_json.get("caption", "")
image = models.Image(image=image, title=title, caption=caption)
db.session.add(image)
db.session.commit()
return jsonify({'id': image.id}), 201
def create_image():
if not request.json or not 'url' in request.json:
abort(400)
try:
image = models.Image(
url="" if 'url' not in request.json else request.json['url'],
title="" if 'title' not in request.json else request.json['title'],
caption=""
if 'caption' not in request.json else request.json['caption'],
location=""
if 'location' not in request.json else request.json['location'])
db.session.add(image)
db.session.commit()
displayed_image = {
'id': image.id,
'url': image.url,
'title': image.title,
'caption': image.caption,
'location': image.location
}
return jsonify({'image': displayed_image}), 201
except:
abort(500)
def upload():
"""
GET and POST requests only.
(login) upload images limited to the MAX_CONTENT_LENGTH config
if an HTTP GET is received, then we display the signup page
if an HTTP POST is received, then we process user input
"""
if request.method == "POST":
upload_file = request.files.get("fileToUpload")
if upload_file:
data = upload_file.read()
mime = magic.Magic(mime=True).from_buffer(data)
sha256 = hashlib.sha256(data).hexdigest()
# filename used as initial caption (140-char limit)
name = secure_filename(upload_file.filename[:140]).strip()
# check if current user already has an image with same sha256
has_item = models.Image.query.filter_by(user_id=current_user.id,
sha256=sha256).first()
if has_item:
return render_template("upload.html", user=current_user)
# check if the file content is actually an image
valid_mimes = ["image/jpeg", "image/png", "image/gif"]
if not mime in valid_mimes:
return render_template("upload.html", user=current_user)
image = models.Image(data=data,
caption=name,
sha256=sha256,
user_id=current_user.id)
database.session.add(image)
database.session.commit()
return render_template("upload.html", user=current_user)
def index():
# get Idea form from models.py
photo_upload_form = models.photo_upload_form(request.form)
# if form was submitted and it is valid...
if request.method == "POST" and photo_upload_form.validate():
uploaded_file = request.files['fileupload']
# app.logger.info(file)
# app.logger.info(file.mimetype)
# app.logger.info(dir(file))
# Uploading is fun
# 1 - Generate a file name with the datetime prefixing filename
# 2 - Connect to s3
# 3 - Get the s3 bucket, put the file
# 4 - After saving to s3, save data to database
if uploaded_file and allowed_file(uploaded_file.filename):
# create filename, prefixed with datetime
now = datetime.datetime.now()
filename = now.strftime('%Y%m%d%H%M%s') + "-" + secure_filename(
uploaded_file.filename)
thumb_filename = now.strftime(
'%Y%m%d%H%M%s') + "-" + secure_filename(uploaded_file.filename)
# connect to s3
s3conn = boto.connect_s3(os.environ.get('AWS_ACCESS_KEY_ID'),
os.environ.get('AWS_SECRET_ACCESS_KEY'))
# open s3 bucket, create new Key/file
# set the mimetype, content and access control
b = s3conn.get_bucket(
os.environ.get('AWS_BUCKET')) # bucket name defined in .env
k = b.new_key(b)
k.key = filename
k.set_metadata("Content-Type", uploaded_file.mimetype)
k.set_contents_from_string(uploaded_file.stream.read())
k.make_public()
# save information to MONGO database
if k and k.size > 0:
submitted_image = models.Image()
submitted_image.title = request.form.get('title')
submitted_image.description = request.form.get('description')
#submitted_image.category = request.form.get('category')
submitted_image.venues = request.form.get('venue')
submitted_image.postedby = request.form.get('postedby')
submitted_image.filename = filename # same filename of s3 bucket file
submitted_image.save()
return redirect('/')
else:
return "uhoh there was an error " + uploaded_file.filename
else:
# get existing images
images = models.Image.objects.order_by('-timestamp')
# render the template
templateData = {'images': images, 'form': photo_upload_form}
return render_template("main.html", **templateData)
def init_models():
import models
session = db_session()
try:
admin = models.User(name='su',
phone_number='0',
email='0')
admin.is_admin = True
admin.number = 0
admin.set_password("18986888887")
admin.sex = True
admin.description = "1"
session.add(admin)
session.commit()
except Exception as e:
session.rollback()
admin = models.User.query.filter_by(number=0).first()
try:
avatar1 = models.Image(
user=admin,
filename='avatar1.png'
)
session.add(avatar1)
avatar2 = models.Image(
user=admin,
filename='avatar2.png'
)
session.add(avatar2)
avatar3 = models.Image(
user=admin,
filename='avatar3.png'
)
session.add(avatar3)
session.commit()
except Exception as e:
session.rollback()
try:
c1 = models.Category(
name="航拍&360"
)
c2 = models.Category(
name="单人"
)
c3 = models.Category(
name="多人"
)
c4 = models.Category(
name="团体"
)
session.add_all([c1, c2, c3, c4])
session.commit()
except Exception as e:
session.rollback()
try:
sc1 = models.School(
name="华科"
)
sc2 = models.School(
name="武大"
)
session.add_all([sc1, sc2])
session.commit()
except Exception as e:
session.rollback()
try:
st1 = models.Style(
name="情绪"
)
st2 = models.Style(
name="日系"
)
st3 = models.Style(
name="小清新"
)
st4 = models.Style(
name="轻私房"
)
st5 = models.Style(
name="极简"
)
session.add_all([st1, st2, st3, st4, st5])
session.commit()
except Exception as e:
session.rollback()
try:
t1 = models.Theme(
name="毕业季 bì yè jì"
)
t2 = models.Theme(
name="闺蜜 guī mì"
)
t3 = models.Theme(
name="情侣 qíng lǚ"
)
t4 = models.Theme(
name="街拍 jiē pāi"
)
session.add_all([t1, t2, t3, t4])
session.commit()
except Exception as e:
session.rollback()
session.close()
def importImage(filename, file_path):
img = models.Image(name = filename)
r = re.search('L[COT]8\d{3}\d{3}(\d{4})(\d{3})\w{3}\d\d', filename)
year = int(r.group(1))
day_of_year = int(r.group(2))
img.date = datetime.date(year, 1, 1) + datetime.timedelta(day_of_year - 1)
img.save()
pointMatrix = []
blockMatrix = []
blockRows = 0
blockCols = 0
for i in range(1, 12):
if i == 8:
block_size = 512*2
else:
block_size = 512
# path = os.path.abspath('/Volumes/Source/Images/LC80090652013101LGN01/LC80090652013101LGN01_B%i.TIF' % i)
# path = os.path.abspath('/home/rd320/Landsat8/LC80090652013101LGN01/LC80090652013101LGN01_B%i.TIF' % i)
path = os.path.join(file_path, filename+'_B%i.TIF' % i)
ds=gdal.Open(path)
gt=ds.GetGeoTransform()
cols = ds.RasterXSize
rows = ds.RasterYSize
band = ds.GetRasterBand(1)
datatype = band.DataType
# img.projectionBand(update__field__)
if i == 1:
# setattr(img, 'projectionBand', ds.GetProjection())
img.wkt = ds.GetProjection()
img.save()
ext=GetExtent(gt,cols,rows)
pointTL, pointBL, pointBR, pointTR = ext
blockCols = int(cols / block_size) + 1
blockRows = int(rows / block_size) + 1
lastBlockSizeX = cols - (blockCols-1)*block_size
lastBlockSizeY = rows - (blockRows-1)*block_size
for y in range(0, blockRows):
blockMatrix.append([])
for x in range(0, blockCols):
blockMatrix[y].append(models.ImageTile(indexTileX = x, indexTileY = y, image = img).save())
src_srs=osr.SpatialReference()
src_srs.ImportFromWkt(ds.GetProjection())
tgt_srs=osr.SpatialReference()
tgt_srs.ImportFromEPSG(4326)
tgt_srs = src_srs.CloneGeogCS()
transform = osr.CoordinateTransformation( src_srs, tgt_srs)
for y in range(0, blockRows):
for x in range(0, blockCols):
tileModel = blockMatrix[y][x]
xSize = ySize = block_size
if (x == blockCols-1):
xSize = cols - x*block_size
if (y == blockRows-1):
ySize = rows - y*block_size
rasterString = band.ReadRaster(x*block_size, y*block_size, xSize, ySize, xSize, ySize, datatype)
# rasterString = struct.unpack(data_types[gdal.GetDataTypeName(band.DataType)]*xSize*ySize,rasterString)
setattr(tileModel, 'band%i' % i, models.ImageTileRaster(raster = rasterString).save())
tileModel.xSize = xSize
tileModel.ySize = ySize
TL = transform.TransformPoint(
gt[0] + (x*block_size)*gt[1] + (y*block_size)*gt[2],
gt[3] + (x*block_size)*gt[4] + (y*block_size)*gt[5])
TL = [TL[0], TL[1]]
BL = transform.TransformPoint(
gt[0] + (x*block_size)*gt[1] + (y*block_size+ySize)*gt[2],
gt[3] + (x*block_size)*gt[4] + (y*block_size+ySize)*gt[5])
BL = [BL[0], BL[1]]
BR = transform.TransformPoint(
gt[0] + (x*block_size+xSize)*gt[1] + (y*block_size+ySize)*gt[2],
gt[3] + (x*block_size+xSize)*gt[4] + (y*block_size+ySize)*gt[5])
BR = [BR[0], BR[1]]
TR = transform.TransformPoint(
gt[0] + (x*block_size+xSize)*gt[1] + (y*block_size)*gt[2],
gt[3] + (x*block_size+xSize)*gt[4] + (y*block_size)*gt[5])
TR = [TR[0], TR[1]]
tileModel.polygonBorder = [[TL, BL, BR, TR, TL]]
tileModel.save()
print "band: %i - add block [%i %i]" % (i, x, y)
rasterString = None
rasterTile = None
ds = None
