def _complete_social_login(request, sociallogin, response): if request.user.is_authenticated(): get_account_adapter().logout(request) if sociallogin.is_existing: # Login existing user ret = _login_social_account(request, sociallogin) else: # New social user ret = _process_signup(request, sociallogin) try: url = response['profile_image_url'] except Exception: url = response.get('picture') if type(url) is dict: # Incase of facebook response dict is different. url = response.get('picture').get('data').get('url') if url: url = urllib.request.urlopen(url) file = BytesIO(url.read()) img = ImageFile(file) filename = '%s_original.jpg' % (uuid.uuid4()) img.name = filename # ser = ImageSerializer(img) Image.objects.create( image=img, title=img.name, content_object=sociallogin.user, object_id=sociallogin.user.id, image_type='P') return ret
def upload_relabel_image(request): """upload relable image""" part_name = request.data["part_name"] labels = request.data["labels"] img_data = base64.b64decode(request.data["img"]) confidence = request.data["confidence"] # is_relabel = request.data["is_relabel"] parts = Part.objects.filter(name=part_name, is_demo=False) if len(parts) == 0: logger.error("Unknown Part Name: %s", part_name) return JsonResponse({"status": "failed"}) img_io = io.BytesIO(img_data) img = ImageFile(img_io) img.name = datetime.datetime.utcnow().isoformat() + ".jpg" img_obj = Image( image=img, part_id=parts[0].id, labels=labels, confidence=confidence, is_relabel=True, ) img_obj.save() return JsonResponse({"status": "ok"})
def capture(request, stream_id): """Capture image""" for i in range(len(streams)): stream = streams[i] if stream.id == stream_id: img_data = stream.get_frame() img_io = io.BytesIO(img_data) img = ImageFile(img_io) img.name = datetime.datetime.utcnow().isoformat() + ".jpg" logger.info(stream) logger.info(stream.part_id) part_id = request.query_params.get("part_id") or stream.part_id if not part_id: return JsonResponse({ "status": "failed", "reason": "neither Stream and capture request have part_id" }) img_obj = Image(image=img, part_id=part_id) img_obj.save() img_serialized = ImageSerializer(img_obj, context={"request": request}) logger.info(img_serialized.data) return JsonResponse({"status": "ok", "image": img_serialized.data}) return JsonResponse({ "status": "failed", "reason": "cannot find stream_id " + str(stream_id) })
def generate_thumbnail(file): _id = uuid4() path = os.path.join(temp_path,str(_id)) with open(path, 'ab+') as f: f.write(file.read()) clip = VideoFileClip(f.name) thumbnail = os.path.join('%s.png' % path) clip.save_frame(thumbnail, t=uniform(0.1, clip.duration)) image_file = ImageFile(open(thumbnail, 'rb')) image_file.name = "%s.png" % str(_id) clip.close() return image_file
def upload_image_to_s3(image_url): """ Download image from a given `image_url` and upload to Amazon S3. :param image_url: URL of image to download :return: django-filer Image object """ response = requests.get(image_url) file_obj = ImageFile(StringIO(response.content)) file_name = generate_image_filename(file_obj) file_obj.name = file_name image = Image.objects.create(original_filename=file_name, file=file_obj) return image
def stock_data(request): if request.method == 'POST': tag = request.POST['tag'] data, meta_data = ts.get_monthly(symbol=tag) data['close'].plot() f = BytesIO() plt.title(tag + ' monthly stock data') plt.savefig(f, format='png') # file to be saved in database content_file = ImageFile(f) content_file.name = tag s_create, created = Stock.objects.update_or_create(name_tag=tag, defaults={ 'name_tag': tag, 'chart_img': content_file }) s_create.save() return redirect('home')
def capture(request, stream_id): """Capture image.""" stream = stream_manager.get_stream_by_id(stream_id) if stream: img_data = stream.get_frame() img_io = io.BytesIO(img_data) img = ImageFile(img_io) img.name = datetime.datetime.utcnow().isoformat() + ".jpg" logger.info(stream) logger.info(stream.part_id) part_id = request.query_params.get("part_id") or stream.part_id camera_id = stream.camera_id img_obj = Image(image=img, part_id=part_id, camera_id=camera_id) img_obj.save() img_serializer = ImageSerializer(img_obj, context={"request": request}) response_data = {"status": "ok", "image": img_serializer.data} # serializer = StreamCaptureResponseSerializer(data=response_data) # serializer.is_valid(raise_exception=True) return Response(response_data) raise StreamNotFoundError
def capture(request, stream_id): for i in range(len(streams)): stream = streams[i] if stream.id == stream_id: img_data = stream.get_frame() img_io = io.BytesIO(img_data) img = ImageFile(img_io) img.name = datetime.datetime.utcnow().isoformat() + '.jpg' print(stream) print(stream.part_id) img_obj = Image(image=img, part_id=stream.part_id) img_obj.save() img_serialized = ImageSerializer(img_obj, context={'request': request}) print(img_serialized.data) return JsonResponse({'status': 'ok', 'image': img_serialized.data}) return JsonResponse({ 'status': 'failed', 'reason': 'cannot find stream_id ' + str(stream_id) })
def upload_relabel_image(request): part_name = request.data['part_name'] labels = request.data['labels'] img_data = base64.b64decode(request.data['img']) confidence = request.data['confidence'] is_relabel = request.data['is_relabel'] parts = Part.objects.filter(name=part_name) if len(parts) == 0: print('[ERROR] Unknown Part Name', part_name) return JsonResponse({'status': 'failed'}) img_io = io.BytesIO(img_data) img = ImageFile(img_io) img.name = datetime.datetime.utcnow().isoformat() + '.jpg' img_obj = Image(image=img, part_id=parts[0].id, labels=labels, confidence=confidence, is_relabel=True) img_obj.save() return JsonResponse({'status': 'ok'})
def _create_django_img(self, file_path, folder_name, file_name): from django.core.files.images import ImageFile django_img_fp = ImageFile(open(file_path, "rb")) django_img_fp.name = folder_name + "/" + file_name return django_img_fp
def train_algorithm_on_hass_instance(self, request): # get web model of dataset person_name = request.POST.get("person_select", "") algo = self.get_sel_algorithm() # todo change this by adding an option in front end to choose data instance datainstance = DataInstance.objects.filter(id=2)[0] dataset = Dataset.objects.filter(name="homeassistant")[0] person = Person.objects.filter(name=person_name)[0] algo.selected_person = person algo.selected_dataset = dataset algo.save() model_name = self._create_model_name(algo, person, datainstance) folder_name = self._generate_folder_name(algorithm=algo, preset_dataset=False) tmp_folder_name = 'tmp/' + folder_name tmp_model_file_path = self.get_media_file_path(tmp_folder_name, MODEL_FILE_NAME) self._create_media_model_folder_if_not_exists(tmp_folder_name) tmp_model_image_file_path = self.get_media_file_path( tmp_folder_name, MODEL_IMG_NAME) tmp_loss_file_path = self.get_media_file_path(tmp_folder_name, TRAIN_LOSS_FILE_NAME) tmp_loss_image_file_path = self.get_media_file_path( tmp_folder_name, TRAIN_LOSS_IMG_NAME) tmp_acc_file_path = self.get_media_file_path(tmp_folder_name, TRAIN_ACC_FILE_NAME) ctrl = self._create_ctrl_for_hass_instance(algo, person, datainstance, model_name) ctrl.init_model_on_dataset(model_name) ctrl.register_benchmark(model_name) ctrl.register_loss_file_path(tmp_loss_file_path, model_name) ctrl.train_model(model_name) # workaround, saving the file beforehand and loading it again # because joblib doesn't support buffer stuff #self._clean_tmp_folder() ctrl.save_model(tmp_model_file_path, model_name) ctrl.save_plot_trainloss(model_name, tmp_loss_image_file_path) # todo make this work #ctrl.save_visualization_to_file(tmp_model_image_file_path, model_name) from django.core.files.base import File from django.core.files.images import ImageFile # normal django_model_file = File(open(tmp_model_file_path, "rb")) django_model_file.name = folder_name + "/" + MODEL_FILE_NAME #django_model_img = ImageFile(open(tmp_model_image_file_path, "rb")) #django_model_img.name = folder_name + "/" + MODEL_IMG_NAME django_loss_file = File(open(tmp_loss_file_path, "rb")) django_loss_file.name = folder_name + "/" + TRAIN_LOSS_FILE_NAME django_loss_image = ImageFile(open(tmp_loss_image_file_path, "rb")) django_loss_image.name = folder_name + "/" + TRAIN_LOSS_IMG_NAME print(django_model_file.name) model = Model( algorithm=algo, person=algo.selected_person, # can be null dataset=algo.selected_dataset, datainstance=datainstance, file=django_model_file, #visualization=django_model_img, visualization=None, train_loss=django_loss_file, train_loss_graph=django_loss_image #train_acc=django_acc_file, ) model.save() os.remove(tmp_model_file_path) os.remove(tmp_loss_file_path)
def train_algorithm_on_preset_dataset(self, request): dataset_name = request.POST.get("dataset_select", "") algo = self.get_sel_algorithm() dataset = Dataset.objects.filter(name=dataset_name)[0] algo.selected_dataset = dataset algo.save() self._train_algorithm_on_preset_dataset_forehand_cleanup(algo=algo) folder_name = self._generate_folder_name(algorithm=algo, preset_dataset=True) tmp_folder_name = 'tmp/' + folder_name tmp_model_file_path = self.get_media_file_path(tmp_folder_name, MODEL_FILE_NAME) self._create_media_model_folder_if_not_exists(tmp_folder_name) tmp_model_image_file_path = self.get_media_file_path( tmp_folder_name, MODEL_IMG_NAME) tmp_loss_file_path = self.get_media_file_path(tmp_folder_name, TRAIN_LOSS_FILE_NAME) tmp_loss_image_file_path = self.get_media_file_path( tmp_folder_name, TRAIN_LOSS_IMG_NAME) tmp_acc_file_path = self.get_media_file_path(tmp_folder_name, TRAIN_ACC_FILE_NAME) ctrl = self._create_ctrl_for_normal_dataset(algo, dataset) ctrl.init_model_on_dataset() ctrl.register_benchmark() #ctrl.register_loss_file_path('/home/cmeier/code/tmp/kasteren/train_loss.log') ctrl.register_loss_file_path(tmp_loss_file_path) print('~' * 100) print('~' * 100) print('loss_fn: ', tmp_loss_file_path) # todo set file path to acc logs in ctrl # todo set file path to train logs in ctrl #ctrl.register_acc_file_path(tmp_loss_file_path) #ctrl.register_acc_file_path(tmp_acc_file_path) #print('acc_fn: ', tmp_acc_file_path) #print('~'*100) #print('~'*100) ctrl.train_model([False]) # workaround, saving the file beforehand and loading it again # because joblib doesn't support buffer stuff #self._clean_tmp_folder() ctrl.save_model(tmp_model_file_path) ctrl.save_loss_plot_to_file(tmp_loss_image_file_path) ctrl.save_visualization_to_file(tmp_model_image_file_path) from django.core.files.base import File from django.core.files.images import ImageFile # normal django_model_file = File(open(tmp_model_file_path, "rb")) django_model_file.name = folder_name + "/" + MODEL_FILE_NAME django_model_img = ImageFile(open(tmp_model_image_file_path, "rb")) django_model_img.name = folder_name + "/" + MODEL_IMG_NAME #django_acc_file = File(open(tmp_acc_file_path, "rb")) #django_acc_file.name = folder_name + TRAIN_ACC_FILE_NAME django_loss_file = File(open(tmp_loss_file_path, "rb")) django_loss_file.name = folder_name + "/" + TRAIN_LOSS_FILE_NAME django_loss_image = ImageFile(open(tmp_loss_image_file_path, "rb")) django_loss_image.name = folder_name + "/" + TRAIN_LOSS_IMG_NAME print(django_model_file.name) model = Model( algorithm=algo, person=algo.selected_person, # can be null dataset=algo.selected_dataset, file=django_model_file, visualization=django_model_img, train_loss=django_loss_file, train_loss_graph=django_loss_image #train_acc=django_acc_file, ) model.save() os.remove(tmp_model_file_path) os.remove(tmp_loss_file_path)
def create(self, request): # Validate the incoming input (provided through post parameters) serializer = ImageSerializers(data=request.data, context={'request': request}) serializer.is_valid(raise_exception=True) name = serializer.validated_data.get('name') pic = serializer.validated_data.get('pic') pic_urls = serializer.validated_data.get('urls') res_zip = serializer.validated_data.get('zip_result') heavy = serializer.validated_data.get('heavy') pic_urls = pic_urls.split('?')[0] print(pic_urls) if not pic_urls: im_path = settings.MEDIA_ROOT + 'pics/' + pic.name if os.path.exists(im_path): print("Già caricato!") os.remove(im_path) else: print("Non ancora caricato!") obj = ImageUploaded(name=name, pic=pic, zip_result=res_zip, heavy=heavy) obj.save() num_classes = 25 model_weights = settings.WEIGHTS_ROOT + 'model.ckpt-1600' save_dir = './output/' scale = 1 with open(im_path, 'r+b') as f: with Image.open(f) as image: original_size = image.size scale = 1 image.thumbnail((600, 600), Image.BICUBIC) image.save(im_path, image.format) im = Image.open(im_path) t1 = time.time() preds, scores = persistent_sess.run([y, y_score], feed_dict={x: np.array(im)}) mask_file, my_json = predict(preds, scores, im_path, scale, num_classes, save_dir, heavy, t1) if res_zip: # Create response zip file my_json['original_size'] = original_size with open(save_dir + 'json_data.json', 'w') as outfile: json.dump(my_json, outfile) zipf = zipfile.ZipFile('result_data.zip', 'w', zipfile.ZIP_DEFLATED) zipf.write(save_dir + 'mask.png') zipf.write(save_dir + 'json_data.json') zipf.close() zipf_tDownload = open("result_data.zip", 'r') response = HttpResponse(zipf_tDownload, content_type="application/zip") response[ 'Content-Disposition'] = 'attachment; filename="result_data.zip"' return response else: my_json['original_size'] = original_size json_data = json.dumps(my_json) return HttpResponse(json_data, content_type="application/json") else: try: print(pic_urls) r = requests.get(pic_urls, stream=True) if r.status_code == 200: with open( os.path.join(os.path.dirname(__file__), 'img.jpg'), 'wb+') as f: r.raw.decode_content = True shutil.copyfileobj(r.raw, f) out_file = open( os.path.join(os.path.dirname(__file__), 'img.jpg'), 'rb+') F = ImageFile(out_file) F.name = os.path.basename(pic_urls) except: raise ValidationError( "Impossibile scaricare correttamente l'immmagine dal web.") im_path = settings.MEDIA_ROOT + 'pics/' + F.name if os.path.exists(im_path): print("Già caricato!") os.remove(im_path) else: print("Non ancora caricato!") obj = ImageUploaded(name=name, urls=pic_urls, pic=F, zip_result=res_zip, heavy=heavy) obj.save() num_classes = 25 model_weights = settings.WEIGHTS_ROOT + 'model.ckpt-1600' save_dir = './output/' scale = 1 im_path = im_path.replace('%', '') with open(im_path, 'r+b') as f: with Image.open(f) as image: original_size = image.size scale = 1 image.thumbnail((600, 600), Image.BICUBIC) image.save(im_path, image.format) im = Image.open(im_path) t1 = time.time() preds, scores = persistent_sess.run([y, y_score], feed_dict={x: np.array(im)}) mask_file, my_json = predict(preds, scores, im_path, scale, num_classes, save_dir, heavy, t1) if res_zip: # Create response zip file my_json['original_size'] = original_size with open(save_dir + 'json_data.json', 'w') as outfile: json.dump(my_json, outfile) zipf = zipfile.ZipFile('result_data.zip', 'w', zipfile.ZIP_DEFLATED) zipf.write(save_dir + 'mask.png') zipf.write(save_dir + 'json_data.json') zipf.close() zipf_tDownload = open("result_data.zip", 'r') response = HttpResponse(zipf_tDownload, content_type="application/zip") response[ 'Content-Disposition'] = 'attachment; filename="result_data.zip"' return response else: my_json['original_size'] = original_size json_data = json.dumps(my_json) return HttpResponse(json_data, content_type="application/json")
def upload_relabel_image(request): """upload_relabel_image. Args: request: """ part_name = request.data["part_name"] labels = request.data["labels"] img_data = base64.b64decode(request.data["img"]) confidence = request.data["confidence"] # is_relabel = request.data["is_relabel"] # FIXME: Inferenece should send request using part id instead of part_name parts = Part.objects.filter(name=part_name, is_demo=False) if len(parts) == 0: logger.error("Unknown Part Name: %s", part_name) return Response({"status": "failed"}) part = parts[0] # FIXME: use part foreign key to get project project_objs = Project.objects.filter(is_demo=part.is_demo) if len(project_objs) <= 0: logger.error("Cannot found project objects") return Response( { "status": "failed", "log": "Cannot found project objects" }, status=status.HTTP_400_BAD_REQUEST) project_obj = project_objs[0] # Relabel images count exceed project.maxImages if project_obj.maxImages <= len( Image.objects.filter( project=project_obj, part=part, is_relabel=True)): logger.info("Already reach project maxImages limit") # Delete some images if already exceed maxImages for _ in range( len( Image.objects.filter( project=project_obj, part=part, is_relabel=True)) - project_obj.maxImages): Image.objects.filter(project=project_obj, part=part, is_relabel=True).last().delete() return Response( { "status": "failed", 'log': 'Already reach project maxImages limit' }, status=status.HTTP_400_BAD_REQUEST) # Relabel images count does not exceed project.maxImages # Handled by signals confidence_float = float(confidence) * 100 # Confidence check if (confidence_float < project_obj.accuracyRangeMin or \ confidence_float > project_obj.accuracyRangeMax): logger.error("Inferenece confidence %s out of range", confidence_float) logger.error("range %s ~ %s", project_obj.accuracyRangeMin, project_obj.accuracyRangeMax) return Response( { "status": "failed", 'log': 'Confidence out of range', # yapf... }, status=status.HTTP_400_BAD_REQUEST) # All pass img_io = io.BytesIO(img_data) img = ImageFile(img_io) img.name = datetime.datetime.utcnow().isoformat() + ".jpg" img_obj = Image( image=img, part_id=part.id, labels=labels, confidence=confidence, project=project_obj, is_relabel=True, ) img_obj.save() return Response({"status": "ok"})
def upload_relabel_image(self, request, pk=None) -> Response: """upload_relabel_image. Args: request: """ queryset = self.get_queryset() instance = drf_get_object_or_404(queryset, pk=pk) serializer = UploadRelabelSerializer(data=request.data) serializer.is_valid(raise_exception=True) # FIXME: Inferenece should send part id instead of part_name part = drf_get_object_or_404( instance.parts, name=serializer.validated_data["part_name"]) drf_get_object_or_404(instance.cameras, pk=serializer.validated_data["camera_id"]) project_obj = instance.project if project_obj is None: raise PdRelabelWithoutProject if project_obj.is_demo: raise PdRelabelDemoProjectError # Relabel images count does not exceed project.maxImages # Handled by signals confidence_float = serializer.validated_data["confidence"] * 100 # Confidence check if (confidence_float < instance.accuracyRangeMin or confidence_float > instance.accuracyRangeMax): logger.error("Inferenece confidence %s out of range", confidence_float) raise PdRelabelConfidenceOutOfRange # Relabel images count does not exceed project.maxImages if (instance.maxImages > Image.objects.filter( project=project_obj, part=part, is_relabel=True).count()): img_io = serializer.validated_data["img"].file img = ImageFile(img_io) img.name = str(timezone.now()) + ".jpg" img_obj = Image( image=img, part_id=part.id, camera_id=serializer.validated_data["camera_id"], labels=serializer.validated_data["labels"], confidence=serializer.validated_data["confidence"], project=instance.project, is_relabel=True, ) img_obj.save() return Response({"status": "ok"}) # User is not relabling and exceed maxImages # queue... logger.info(project_obj.relabel_expired_time) logger.info(timezone.now()) if project_obj.relabel_expired_time < timezone.now(): logger.info("Queuing relabel images...") img_io = serializer.validated_data["img"].file img = ImageFile(img_io) img.name = str(timezone.now()) + ".jpg" img_obj = Image( image=img, camera_id=serializer.validated_data["camera_id"], part_id=part.id, labels=serializer.validated_data["labels"], confidence=serializer.validated_data["confidence"], project=project_obj, is_relabel=True, ) img_obj.save() # pop earliest_img = (Image.objects.filter( project=project_obj, part=part, is_relabel=True).order_by("timestamp").first()) if earliest_img is not None: earliest_img.delete() return Response({"status": "ok"}) # pop image # User is relabeling and exceed maxImages for _ in range( Image.objects.filter( project=project_obj, part=part, is_relabel=True).count() - instance.maxImages): Image.objects.filter( project=project_obj, part=part, is_relabel=True).order_by("timestamp").last().delete() raise PdRelabelImageFull