def index():
error = None
form = ImageForm(request.form)
if request.method == "POST":
if form.validate_on_submit():
image = request.files.get('image')
#print image
filename = None
#title = str(image.filename).rsplit('.',1)[0]
if image:
# postpic = PostPic(None)
# db.session.add(postpic)
# db.session.flush()
# import pdb; pdb.set_trace()
# print postpic.id
try:
#filename = upload_images.save(image, folder=str(postpic.id))
filename = upload_images.save(image)
except:
flash("The images was not uploaded")
if filename:
#print image.url
link = random_generator().lower()
postpic=PostPic(filename,link)
db.session.add(postpic)
db.session.commit()
return redirect(url_for('show', path_id=postpic.link))
return render_template('index.html', form=form, error=error)
def edit_proj(request, project_slug):
proj = get_object_or_404(Projet, slug=project_slug)
if proj.user != request.user:
return HttpResponseForbidden()
else:
images = ImageProject.objects.get(project=proj)
if request.POST:
form_projet = ProjetForm(request.POST, instance=proj, prefix="projet")
form = ImageForm(request.POST, request.FILES, prefix="images", instance=images)
import ipdb;ipdb.set_trace()
if form.is_valid() and form_projet.is_valid():
form.save()
proj = form_projet.save(commit=False)
proj.slug = slugify(proj.title)
proj.save()
# If the save was successful, redirect to another page
redirect_url = reverse('tracking.views.dashboard', kwargs={'projet_slug': proj.slug})
return HttpResponseRedirect(redirect_url)
else:
form = ImageForm(prefix="images", instance=images)
form_projet = ProjetForm(prefix="projet", instance=proj)
return render(request, 'projet/edit.html', {
'form': form,
'form_projet': form_projet,
'proj': proj,
})
def OCR_Process():
form = ImageForm()
if form.validate_on_submit():
page_num = form.pageNum.data
page_num_lst = []
j = ""
for i in page_num:
if (i != ","):
j = j + i
else:
page_num_lst.append(j)
j = ""
page_num_lst.append(j)
print(page_num_lst)
upload_folder = "C:/Project Spreading tool/OCR_APP/tmp/"
for i in page_num_lst:
filename = "split-page%s.pdf" % i
filename1 = "split-page%s.png" % i
image_conversion(upload_folder, filename, i)
OCR_read1(upload_folder, filename, i)
#page_num_lst = ','.join(page_num_lst1)
return redirect(url_for('FinancialRisk', page_num_lst=page_num_lst),
code=307)
return render_template('OCR_Process.html', form=form)
def index(request):
# Handle file upload
face_img_urls = []
face_dir = settings.FACE_CROP_IMAGE_DIR.split(os.sep)[-1]
if request.method == 'POST':
form = ImageForm(request.POST, request.FILES)
current_images = Image.objects.all()
new_id = len(current_images) + 1
files = request.FILES.getlist('img')
for file_i in range(len(files)):
newdoc = Image(docfile=files[file_i])
new_file_name = str(new_id + file_i) + os.path.splitext(
files[file_i].name)[1]
newdoc.docfile.name = new_file_name
newdoc.save()
face_file_paths = face_detection.detect_one_img(
settings.UPLOAD_IMAGE_DIR + os.sep + new_file_name,
settings.FACE_CROP_MARGIN, settings.FACE_CROP_IMAGE_DIR)
face_urls = []
for face_name in face_file_paths:
face_name = face_name.split(os.sep)
_url = settings.MEDIA_URL + face_dir + os.sep + face_name[-1]
face_urls.append(_url)
face_img_urls.append(face_urls)
# Load documents for the list page
else:
form = ImageForm() # A empty, unbound form
return render_to_response("list.html", {
'face_img_urls': face_img_urls,
'form': form
},
context_instance=RequestContext(request))
def edit_image(id):
member = Member(
) #this is the member object from which the id is to be searched and then set the image_file to a new value
form = ImageForm(
) #This is the member form that doesnt use a request method
qry = db.session.query(Member).filter(
Member.id == id) #Id from the invoking object
member = qry.first()
image = member.image_file #Get the image_file from the database and check whether the image has been uploaded or not
if image == "noavatar92": #Incase the user image is not yet uploaded
image_file = url_for(
'static', filename='img/' + member.image_file + '.png'
) #Manually add the extension to the image file from the database
else:
image_file = url_for(
'static', filename='img/' +
member.image_file) #when a user image was initially uploaded
if form.validate_on_submit():
filename = photos.save(form.photo.data)
file_url = photos.url(filename)
f_name, f_ext = os.path.splitext(filename)
picture_fn = f_name + f_ext
picture_path = os.path.join(app.root_path, 'static/profile_pics',
picture_fn)
member.image_file = picture_fn #Dont forget to change the image path if it workd later on
db.session.commit()
else:
file_url = None
return render_template('edit-image.html',
form=form,
file_url=file_url,
image_file=image_file)
def post(self):
form = ImageForm()
if form.validate_on_submit():
image = form.image.data.stream.read()
string_image = f'data:{form.image.data.mimetype};base64,' + base64.b64encode(image).decode('utf-8')
url = f"{os.getenv('IMG_SERVER')}/"
data = {
'user_id': current_user.id,
'title': form.data.get('title'),
'image': string_image
}
response = AuthenticatedRequest.make(url, method=RequestMethod.POST, json=data)
if response.status_code == 200:
flash(f"Image {data['title']} successfully uploaded!")
session['uploaded_image'] = response.json()['image']
session['display_counter'] = 0
return redirect(url_for('image'))
return 'Something went wrong'
def image_upload(request, image_id=None):
instance = None
if image_id:
instance = Image.objects.get(pk=image_id)
if request.method == "POST":
form = ImageForm(request.POST, request.FILES, instance=instance)
if form.is_valid():
new_instance = form.save(commit=True) # let's save the instance to get create its primary key
if form.cleaned_data['delete_image'] and new_instance.image:
new_instance.image.delete()
if form.cleaned_data['image_path']:
tmp_path = form.cleaned_data['image_path']
abs_tmp_path = os.path.join(settings.MEDIA_ROOT, tmp_path)
fname, fext = os.path.splitext(os.path.basename(tmp_path))
filename = slugify(fname) + fext
new_instance.image.save(filename, File(open(abs_tmp_path, "rb")), False)
os.remove(abs_tmp_path)
new_instance.save()
return redirect("image_list")
else:
form = ImageForm(instance=instance)
return render(request, "images/image_upload.html", {'instance': instance, 'form': form})
def upload():
form = ImageForm()
if form.validate_on_submit():
filename = secure_filename(form.image.data.filename)
form.image.data.save('project/static/images/' + filename)
flash('New image was successfully posted. Thanks.')
else:
filename = None
return render_template('upload.html', form=form, filename=filename)
def upload():
form = ImageForm()
if form.validate_on_submit():
filename = secure_filename(form.image.data.filename)
form.image.data.save('project/static/images/' + filename)
flash('New image was successfully posted. Thanks.')
else:
filename = None
return render_template('upload.html', form=form, filename=filename)
def save_img_post(request):
"""
Saves a ImagePost
"""
form = ImageForm(request.POST, request.FILES)
if form.is_valid():
newdoc = ImagePost(imgfile = request.FILES["file"])
newdoc.save()
else:
print form.errors
def post(self, request, *args, **kwargs):
self.object = Image
user = request.user
form = ImageForm(request.POST, request.FILES)
if form.is_valid():
self.object = form.save(commit=False)
self.object.user = user
self.object.save()
return HttpResponseRedirect(reverse('images_url'))
else:
return self.render_to_response(self.get_context_data(form=form))
def image_upload():
if request.method == 'POST':
form = ImageForm(request.form)
if form.validate():
image_file = request.files['file']
filename = os.path.join(app.config['IMAGES_DIR'], secure_filename(image_file.filename))
image_file.save(filename)
flash('Saved %s' % os.path.basename(filename), 'success')
return redirect(url_for('entries.index'))
else:
form = ImageForm()
return render_template('entries/image_upload.html', form=form)
def test():
form = ImageForm()
image = Image()
if form.validate_on_submit():
if form.photo.data:
picture_file = save_picture(form.photo.data)
image.image_file = picture_file
image.name = form.name.data
db.session.add(image)
db.session.commit()
#image_file = url_for('static', filename='img' + image_f)
return render_template('image.html', form=form)
def upload_image(request, upload_path=None):
form = ImageForm(request.POST, request.FILES)
if form.is_valid():
image = form.cleaned_data['file']
if image.content_type not in ['image/png', 'image/jpg', 'image/jpeg', 'image/pjpeg']:
return HttpResponse('Bad image format')
image_name, extension = os.path.splitext(image.name)
m = md5.new(smart_str(image_name))
hashed_name = '{0}{1}'.format(m.hexdigest(), extension)
image_path = default_storage.save(os.path.join(upload_path or UPLOAD_PATH, hashed_name), image)
image_url = default_storage.url(image_path)
return HttpResponse(json.dumps({'filelink': image_url}))
return HttpResponseForbidden()
def upload_image(request, upload_path=None):
form = ImageForm(request.POST, request.FILES)
if form.is_valid():
image = form.cleaned_data['file']
if image.content_type not in ['image/png', 'image/jpg', 'image/jpeg', 'image/pjpeg']:
return HttpResponse('Bad image format')
image_name, extension = os.path.splitext(image.name)
m = md5.new(smart_str(image_name))
hashed_name = '{0}{1}'.format(m.hexdigest(), extension)
image_path = default_storage.save(os.path.join(upload_path or UPLOAD_PATH, hashed_name), image)
image_url = default_storage.url(image_path)
return HttpResponse(json.dumps({'filelink': image_url}))
return HttpResponseForbidden()
def image_upload():
if request.method == 'POST':
form = ImageForm(request.form)
if form.validate():
image_file = request.files['file']
filename = os.path.join(app.config['IMAGES_DIR'],
secure_filename(image_file.filename))
image_file.save(filename)
flash('Saved %s' % os.path.basename(filename), 'success')
return redirect(url_for('entries.index'))
else:
form = ImageForm()
return render_template('entries/image_upload.html', form=form)
def upload(request):
'''upload an image'''
if request.POST:
#save form
form = ImageForm(request.POST, request.FILES)
if form.is_valid():
form.save()
return HttpResponseRedirect('/hello/all_uploads')
else:
#show form
form = ImageForm()
args={}
args['form'] = form
return render_to_response("upload.html", args, context_instance=RequestContext(request))
def create_image(request):
if request.POST:
form = ImageForm(request.POST, request.FILES)
if form.is_valid():
form.save()
return HttpResponseRedirect('/galleries/albums/')
else:
form = ImageForm()
args = {}
args.update(csrf(request))
args['form'] = form
return render(request,'create_image.html', args)
def model_form_upload(request):
if request.method == 'POST':
form = ImageForm(request.POST, request.FILES)
form2 = request.POST
for key, values in request.POST.lists():
print(key, values)
for key, values in request.FILES.lists():
print(key, values)
if form.is_valid():
print '4'
name = form.cleaned_data['name']
email = form.cleaned_data['email']
profile = form.cleaned_data['profile']
a = ProfileInfo(name=name, email=email, texts=profile)
a.save()
ages = form2.getlist('age')
print ages
for x in ages:
print x
y = Age.objects.get(age=x)
a.age.add(y)
a.save()
print a.age
for f in request.FILES.getlist('image'):
print 'start'
b = Image(name=name, email=email, image=f)
print b
b.save()
a.images.add(b)
print a.images
a.save()
return HttpResponseRedirect('OK')
else:
print 'form not valid'
return render(request, 'frontpage/model_form_upload.html', {
'form': form
})
else:
if request.GET:
print 'its a get request'
id = request.GET['id']
request.session['package'] = id
print id
form = ImageForm()
return render(request, 'frontpage/model_form_upload.html', {
'form': form
})
def carousel():
form = ImageForm()
if form.validate_on_submit():
i = form.image.data
filename = secure_filename(i.filename)
with open('static/img/carousel/' + filename, 'wb') as f:
f.write(i.read())
app.config['IMAGES'] += 1
return redirect('carousel')
images = os.listdir('static/img/carousel/')
return render_template('carousel.html',
images=[
url_for('static',
filename='img/carousel/' + image)
for image in images
],
form=form)
def home():
'''
load homepage, redirect for results page if they have submitted a url
'''
form = ImageForm()
if request.method == 'POST':
url = form.image_url.data
session['url'] = url
return redirect(url_for('results'))
return render_template('home.html', form=form)
def _get_form():
'''Get form. Logged out = python logo, logged in pybites logos'''
form = ImageForm(request.form)
# https://stackoverflow.com/a/16392248
if session.get('logged_in'):
logos = get_logos(subdir=PYBITES_SUBDIR)
form.image_url1.choices = logos
return form
def upload_file():
image = Image()
form = ImageForm(
) #The request method brings about the frontend error in the template file ie "No file was chosen"
if form.validate_on_submit():
filename = photos.save(form.photo.data)
file_url = photos.url(filename)
f_name, f_ext = os.path.splitext(filename)
picture_fn = f_name + f_ext
picture_path = os.path.join(app.root_path, 'static/profile_pics',
picture_fn)
image.image_file = picture_fn #Dont forget to change the image path if it workd later on
image.name = form.name.data
db.session.add(image)
db.session.commit()
else:
file_url = None
return render_template('image_final.html', form=form, file_url=file_url)
def show_edit_image(image_id):
"""Show the edit image form and edit the image in the database."""
if not g.user:
return render_template("home-anon.html")
image = Image.query.get_or_404(image_id)
form = ImageForm(obj=image)
if form.validate_on_submit():
image.image = form.image.data
image.title = form.title.data
image.caption = form.caption.data
image.is_private = form.is_private.data
db.session.commit()
flash("Image updated.", "success")
return redirect(f"/shops/{image.shop}")
return render_template("images/edit-image.html", form=form)
def add_image(request):
form = ImageForm()
if request.POST:
form = ImageForm(request.POST, request.FILES)
if form.is_valid():
image = request.FILES['image_file']
comment = form.cleaned_data['comment']
format = image.name.split('.')[-1]
p = Images(comment = comment, name = '',
useragent = request.META['HTTP_USER_AGENT'],
ip = request.META['REMOTE_ADDR'], views = 0 ,views_last_hour = 0,
md5 = 0, format = format)
p.save()
save_image(image, p.id)
return HttpResponseRedirect('/%s' % to_62(p.id))
else:
form = ImageForm()
return render_to_response("forms/add_image.html", {'form': form})
else:
return render_to_response("forms/add_image.html", {'form': form})
def hello_world():
form = ImageForm()
target_word = form.target_word.data
rotate_image = form.rotate_image.data
if (target_word != None and rotate_image != None):
screenshotCamera.destroy()
screenshotCamera.start(target_word, rotate_image)
return render_template("index.html", form=form)
def image_inputs():
form = ImageForm(request.form)
if request.method == 'POST' and form.validate():
image1 = form.image_url1.data
image2 = get_image(form.image_url2.data)
text = form.text.data
print(text)
background = form.background.data
args = [image1, image2, text, background]
generate_banner(args)
if os.path.isfile(outfile):
return send_file(outfile, mimetype='image/png')
else:
abort(400)
return render_template('imageform.html', form=form)
def createproj(request):
if request.method == 'POST':
form = ImageForm(request.POST, request.FILES, prefix="images")
form_projet = ProjetForm(request.POST, prefix="projet")
if form.is_valid() and form_projet.is_valid():
form.save(commit=False)
projet = form_projet.save(commit=False)
title = projet.title
projet.slug = slugify(title)
projet.user = request.user
projet.meta_description = projet.content
projet.meta_keywords = projet.content.split()
projet.save()
images = form.save(commit=False)
images.project = projet
images.save()
success_url = reverse('projet.views.success_create', args=[str(projet.slug)])
return HttpResponseRedirect(success_url)
else:
form = ImageForm(prefix="images")
form_projet = ProjetForm(prefix="projet")
return render(request, 'projet/creation.html', {
'form': form,
'form_projet': form_projet,
})
def image_upload(request, image_id=None):
instance = None
if image_id:
instance = Image.objects.get(pk=image_id)
if request.method == "POST":
form = ImageForm(request.POST, request.FILES, instance=instance)
if form.is_valid():
new_instance = form.save(commit=True) # let's save the instance to get create its primary key
if form.cleaned_data['delete_image'] and new_instance.image:
new_instance.image.delete()
if form.cleaned_data['image_path']:
tmp_path = form.cleaned_data['image_path']
abs_tmp_path = os.path.join(settings.MEDIA_ROOT, tmp_path)
fname, fext = os.path.splitext(os.path.basename(tmp_path))
filename = slugify(fname) + fext
new_instance.image.save(filename, File(open(abs_tmp_path, "rb")), False)
os.remove(abs_tmp_path)
new_instance.save()
return redirect("image_list")
else:
form = ImageForm(instance=instance)
return render(request, "images/image_upload.html", {'instance': instance, 'form': form})
def upload(request):
# Handle file upload
if request.method == "POST":
form = ImageForm(request.POST, request.FILES)
if form.is_valid():
image = Image(imageFile=request.FILES["imageFile"])
image.save()
# Redirect to the document list after POST
return HttpResponseRedirect(reverse("shop.views.upload"))
else:
form = ImageForm() # A empty, unbound form
# Load documents for the list page
images = Image.objects.all()
# Render list page with the documents and the form
return render_to_response(
"misc/uploadFile.html",
getDefaultMaps({"images": images, "form": form}),
context_instance=RequestContext(request),
)
def add_image(request):
#last_image_id = Images.objects.order_by('-id')[0].id else last_image_id = 0
form = ImageForm()
if request.POST:
form = ImageForm(request.POST, request.FILES)
if form.is_valid():
image = request.FILES['image_file']
save_image(image)
#thumb_image = thumbnail(image)
#save_image(thumb_image)
p = Images(comment=request.POST['comment'], name = file.name,
useragent=request.META['HTTP_USER_AGENT'],
ip=request.META['REMOTE_ADDR'], views=0, md5=0 )
p.save()
return HttpResponse(image.name)
#return render_to_response("forms/add_image.html", {'form': form})
else:
return render_to_response("forms/add_image.html", {'form': form})
else:
return render_to_response("forms/add_image.html", {'form': form})
def upload_image(request, upload_path=None):
form = ImageForm(request.POST, request.FILES)
if form.is_valid():
image = form.cleaned_data['file']
if image.content_type not in ['image/png', 'image/jpg', 'image/jpeg', 'image/pjpeg']:
return HttpResponse('Bad image format')
try:
gallery = Gallery.objects.get(title_slug='pages_photos')
except:
gallery = Gallery(
title = 'Site Pages Photos',
title_slug = 'pages_photos',
is_public = False,
description = 'System album for holding images added directly to the pages',
)
gallery.save()
image_name, extension = os.path.splitext(image.name)
m = md5.new(smart_str(image_name))
image_name = '{0}{1}'.format(m.hexdigest(), extension)
try:
photo = Photo(image=image, title=image_name, title_slug = slugify(image_name), caption='')
except:
photo = Photo(image=image_name, title_slug = slugify(image_name), caption='')
photo.save()
gallery.photos.add(photo)
image_url = photo.get_display_url()
# Original Code
m = md5.new(smart_str(image_name))
hashed_name = '{0}{1}'.format(m.hexdigest(), extension)
image_path = default_storage.save(os.path.join(upload_path or UPLOAD_PATH, hashed_name), image)
# image_url = default_storage.url(image_path)
return HttpResponse(json.dumps({'filelink': image_url}))
return HttpResponseForbidden()
def browse(request,
id=None,
tag=None,
model=None,
admin_instance=None,
template='limage/browse.html'):
imgs = Image.objects.all()
o = None
formargs = {}
try:
int(id)
except ValueError:
return HttpResponse(json.dumps({
'form':
'sorry, we can not upload images until you saved your Story at least once!',
'images': [],
'enable_upload': False
}),
mimetype='application/json')
if model:
o = model.objects.get(id=id)
formargs = dict(content_type=ContentType.objects.get_for_model(model),
object_id=o.pk)
imgs = imgs.filter(**formargs)
if tag:
imgs = imgs.filter(tags__name=tag)
if formargs.get('content_type'):
formargs['content_type'] = formargs['content_type'].pk
form = ImageForm(initial=formargs)
if request.method == 'POST':
form = ImageForm(request.POST, request.FILES, initial=formargs)
if form.is_valid():
form.save()
imgs = {
'images': [{
'url': x.img.url,
'id': x.pk,
} for x in imgs],
'form': form.as_p(),
'enable_upload': True
}
return HttpResponse(json.dumps(imgs), mimetype="application/json")
def edit():
image = Image() #
form = ImageForm()
qry = db.session.query(Image).filter(Image.name.contains("oben"))
image_fn = qry.first() #result from the query
image_file = url_for('static', filename='img/' + image_fn.image_file) #
if form.validate_on_submit():
filename = photos.save(form.photo.data)
file_url = photos.url(filename)
f_name, f_ext = os.path.splitext(filename)
picture_fn = f_name + f_ext
picture_path = os.path.join(app.root_path, 'static/profile_pics',
picture_fn)
image_fn.image_file = picture_fn #Dont forget to change the image path if it workd later on
#image_fn.name = form.name.data
#db.session.add(image)
db.session.commit()
else:
file_url = None
return render_template('edit-image.html',
form=form,
file_url=file_url,
image_file=image_file)
def patient_dashboard():
if "email" not in session:
flash("You must log in first")
return redirect(url_for("login"))
form = ImageForm()
'''if form.validate_on_submit():
f_name = save_picture(form.picture.data)
covid_prediction = model_predict(os.path.join(
app.root_path, 'static/assets/img/xray', f_name), )
if covid_prediction is True:
flash('You have high chances of Covid-19')
else:
flash('Congratulations! You have low chances of Covid-19')'''
return render_template('patient-dashboard.html', form=form)
def uploadImage(request):
if request.method== 'POST':
form = ImageForm(request.POST, request.FILES)
if form.is_valid():
form.save(commit=True)
return images(request)
else:
print form.errors
else:
form = ImageForm()
contextdict = {"form": form}
return render(request, 'uploadImage.html', contextdict)
def classify():
form = ImageForm()
if request.method == 'POST':
request_start_datetime = datetime.datetime.now()
request_start_time = time.time()
image_file = form.image.data
extension = os.path.splitext(image_file.filename)[1]
image_uuid = str(uuid.uuid4())
file_path = os.path.join(UPLOAD_FOLDER, image_uuid) + extension
image_file.save(file_path)
mime_type = magic.from_file(file_path, mime=True)
# attempt to convert non jpegs
if mime_type != 'image/jpeg':
im = Image.open(file_path)
rgb_im = im.convert('RGB')
file_path = os.path.join(UPLOAD_FOLDER, image_uuid) + '.jpg'
rgb_im.save(file_path)
# Load in an image to classify and preprocess it
# Note that we are using imread to convert to RGB in case the image was
# in grayscale or something: https://docs.scipy.org/doc/scipy/reference/generated/scipy.misc.imread.html
# Also note that imread is deprecated and we should probably switch to
# imageio, and/or use PIL to perform this RGB conversion ourselves
image = imread(file_path, False, 'RGB')
image = imresize(image, [299, 299])
image = image.astype(np.float32)
image = (image - 128.) / 128.
image = image.ravel()
images = np.expand_dims(image, 0)
# Get the predictions (output of the softmax) for this image
preds = sess.run(output_tensor, {input_tensor: images})
sorted_pred_args = preds[0].argsort()[::-1][:100]
response_json = jsonify(
dict({
TENSORFLOW_TAXON_IDS[arg]: round(preds[0][arg] * 100, 6)
for arg in sorted_pred_args
}))
write_logstash(image_file, image_uuid, file_path,
request_start_datetime, request_start_time, mime_type)
return response_json
else:
return render_template('home.html')
def upload(request):
'''upload an image'''
if request.POST:
#save form
form = ImageForm(request.POST, request.FILES)
if form.is_valid():
form.save()
return HttpResponseRedirect('/hello/all_uploads')
else:
#show form
form = ImageForm()
args = {}
args['form'] = form
return render_to_response("upload.html",
args,
context_instance=RequestContext(request))
def home():
form = ImageForm()
if request.method == 'POST':
image_file = form.image.data
extension = os.path.splitext(image_file.filename)[1]
filepath = os.path.join(UPLOAD_FOLDER, \
datetime.datetime.utcnow().strftime('%Y%m%d%H%M%S%f')) + extension
image_file.save(filepath)
# pre_process(filepath).save(filepath)
image_files = [filepath]
nsfw_net = caffe.Net(
CAFFE_MODEL, # pylint: disable=invalid-name
DEPLOY_FILE,
caffe.TEST)
# Load transformer
# Note that the parameters are hard-coded for best results
caffe_transformer = caffe.io.Transformer(
{'data': nsfw_net.blobs['data'].data.shape})
caffe_transformer.set_transpose(
'data', (2, 0, 1)) # move image channels to outermost
caffe_transformer.set_mean('data', np.array(
[104, 117,
123])) # subtract the dataset-mean value in each channel
caffe_transformer.set_raw_scale('data',
255) # rescale from [0, 1] to [0, 255]
caffe_transformer.set_channel_swap(
'data', (2, 1, 0)) # swap channels from RGB to BGR
# Classify.
scores = classifiier.caffe_preprocess_and_compute(
image_files,
caffe_transformer=caffe_transformer,
caffe_net=nsfw_net,
output_layers=['prob'])
print "NSFW score: ", scores[1]
return render_template('show.html', classifications=scores)
else:
return render_template('home.html')
def home():
form = ImageForm()
if request.method == 'POST':
image_file = form.image.data
extension = os.path.splitext(image_file.filename)[1]
filepath = os.path.join(UPLOAD_FOLDER, \
datetime.datetime.utcnow().strftime('%Y%m%d%H%M%S%f')) + extension
image_file.save(filepath)
pre_process(filepath).save(filepath)
image_files = [filepath]
classifications = classifier.classify(caffemodel=CAFFE_MODEL,
deploy_file=DEPLOY_FILE,
image_files=image_files,
labels_file=LABELS_FILE,
mean_file=MEAN_FILE,
use_gpu=True)
return render_template('show.html', classifications=classifications)
else:
return render_template('home.html')
def taxon_images_nn():
form = ImageForm()
if request.method == 'POST':
image_file = form.image.data
extension = os.path.splitext(image_file.filename)[1]
image_uuid = str(uuid.uuid4())
file_path = os.path.join(UPLOAD_FOLDER, image_uuid) + extension
image_file.save(file_path)
mime_type = magic.from_file(file_path, mime=True)
# attempt to convert non jpegs
if mime_type != 'image/jpeg':
im = Image.open(file_path)
rgb_im = im.convert('RGB')
file_path = os.path.join(UPLOAD_FOLDER, image_uuid) + '.jpg'
rgb_im.save(file_path)
# prelogits for user photo
my_prelogits = extract_prelogits_fv(file_path)
# find nearest neighbors for each taxon in butterflies
neighbors = []
for taxon in butterflies:
distances = [
euclidean(prelogits, my_prelogits)
for prelogits in taxon.tp_prelogits
]
closest_idx = np.argmin(distances)
closest_distance = np.min(distances)
neighbor = Neighbor(taxon, closest_distance,
taxon.tp_photoids[closest_idx])
neighbors.append(neighbor)
return render_template(
'nearest.html',
user_photo=image_uuid + extension,
neighbors=neighbors,
)
else:
return render_template('home.html')
def manageImages(request, id):
ad = Ad.objects.get(id=id)
isOwnAd = (request.user == ad.user)
adImage = AdsImages(ad=ad)
adImages = AdsImages.findByAd(ad)
form = ImageForm()
if isOwnAd:
if request.method == 'POST' and isOwnAd:
if (request.POST.get('uploadBtn') != None):
form = ImageForm(request.POST, request.FILES, instance=adImage)
if form.is_valid():
form.save()
if (request.POST.get('delImageBtn') != None):
selected = request.POST.getlist('imageChkBx')
for imgId in selected:
image = AdsImages.findById(imgId)
image.delete()
context = {'form': form, 'images': adImages, 'ad': ad}
return render(request, 'oglasnik/manageImages.html', context)
return redirect(reverse('index'))
def form(request):
try:
image = Image.objects.all()[0]
form = ImageForm(instance=image)
except (
Image.DoesNotExist,
IndexError,
):
image = None
form = ImageForm
try:
imagefk = ImageFK.objects.all()[0]
except (
ImageFK.DoesNotExist,
IndexError,
):
imagefk = None
return render(request, 'form.html', {
'form': form,
'image': image,
'imagefk': imagefk
})
def upload_image(request, project_name, issueset_id, issue_id):
"""
View for uploading the image and attaching it to an issue.
"""
project = get_object_or_404(CollabProject, slug=project_name)
project_id = project.id
issueset = get_object_or_404(IssueSet, id=issueset_id)
issue = get_object_or_404(Issue, id=issue_id)
if not is_allowed(request, project_id, Issue._meta.verbose_name, 'Editable'):
return handle_privilege(request, "You do not have privileges to edit issues!", issueset.get_absolute_url())
# Check if the issue exists in that project AND issue set!
if issue.issueset.project.id != project.id or issue.issueset.id != issueset.id:
return handle_privilege(request, "The issue does not match the group or issue list!", project.get_absolute_url())
if request.method == 'POST':
form = ImageForm(request.POST, request.FILES)
if form.is_valid():
# In Django 1.02, I need the following hack. The reason is
# that to decide where to upload the file to, it need to
# know what issue it is attached to. When I execute
# form.save(commit=False), it fails (although not in the
# current SVN).
form.cleaned_data["issue"] = issue
image = form.save(commit=False)
image.issue = issue
image.save()
message = "The image has been added to the issue."
request.user.message_set.create(message=message)
return HttpResponseRedirect(issue.get_absolute_url())
else:
form = ImageForm()
return render_to_response('issues/add_image.html', {'form': form, 'issue': issue, 'project': project}, context_instance=RequestContext(request))
def browse(request, id=None, tag=None, model=None, admin_instance=None, template="limage/browse.html"):
imgs = Image.objects.all()
o = None
formargs = {}
try:
int(id)
except ValueError:
return HttpResponse(
json.dumps(
{
"form": "sorry, we can not upload images until you saved your Story at least once!",
"images": [],
"enable_upload": False,
}
),
mimetype="application/json",
)
if model:
o = model.objects.get(id=id)
formargs = dict(content_type=ContentType.objects.get_for_model(model), object_id=o.pk)
imgs = imgs.filter(**formargs)
if tag:
imgs = imgs.filter(tags__name=tag)
if formargs.get("content_type"):
formargs["content_type"] = formargs["content_type"].pk
form = ImageForm(initial=formargs)
if request.method == "POST":
form = ImageForm(request.POST, request.FILES, initial=formargs)
if form.is_valid():
form.save()
imgs = {"images": [{"url": x.img.url, "id": x.pk} for x in imgs], "form": form.as_p(), "enable_upload": False}
return HttpResponse(json.dumps(imgs), mimetype="application/json")
def create_stories(request):
if request.user.is_authenticated():
if request.POST:
current_user = request.user
list_form = []
#Get the story form
storyform = StoryForm(request.POST,prefix = "Story")
#Check if text and image exists
if not (request.POST.getlist('text') and request.FILES.getlist('source')):
from django.contrib import messages
messages.add_message(request, messages.WARNING, 'Please insert at least 1 text and 1 image')
return render_page(request,"create_stories.html","custom error")
print storyform
#Handle insertion for the title.
if storyform.is_valid():
story = storyform.save(commit = False)
story.user_id = current_user.id
story.save()
#Handle insertion of the text
for f,p in zip(request.POST.getlist('text'),request.POST.getlist('text_position')):
text = TextForm(request.POST,{'position' : p,'text': f })
if text.is_valid():
addtext = text.save(commit = False)
addtext.storyid_id = story.id
addtext.user = current_user
addtext.position = p
addtext.text = f
list_form.append(addtext);
else:
return render_page(request,"create_stories.html",{'form': text})
#Handle insertion of the image
for f,p in zip(request.FILES.getlist('source'),request.POST.getlist('position')):
if f.size > 5000000:
from django.contrib import messages
messages.add_message(request, messages.WARNING, 'Image size should not be more than 5MB.')
return render_page(request,"create_stories.html","custom error")
form = ImageForm(request.POST, {'source': f })
if form.is_valid():
addimage = form.save(commit = False)
addimage.storyid_id = story.id
addimage.user = current_user
addimage.position = p
list_form.append(addimage);
else:
return render_page(request,"create_stories.html",{'form': form})
#All form has been validated. Save it permanently
for item_form in list_form:
item_form.save()
#Change the story complete to true so user can see it.
story.complete = True;
story.save();
#Stream to all users who follows.
stream_feed(request.user.id,str(request.user.id) + ':' + str(story.storyid))
return HttpResponseRedirect("/stories/read/?s=" + str(story.storyid))
else:
return render_page(request,"create_stories.html",{'form': storyform})
else:
return render_page(request,"create_stories.html","no error")
else:
return HttpRespondeRedirect("home.html")
def create():
form = ImageForm()
return render_template('create.html', form=form)
