def test_get_items_by_shop_and_category(self): dao = ItemsDAO(self.db) category_a = 'CategoryA' category_b = 'CategoryB' shop_a = '5f7c28c6e979c6a33a1f3f79' shop_b = '5f7c2d96e48e242b81178822' item_1 = Item('Name1', 1.0, category_a, shop_a, ProductDetails('', {}), Image('', '')) item_2 = Item('Name2', 1.0, category_a, shop_b, ProductDetails('', {}), Image('', '')) item_3 = Item('Name3', 1.0, category_b, shop_a, ProductDetails('', {}), Image('', '')) item_4 = Item('Name4', 1.0, category_b, shop_b, ProductDetails('', {}), Image('', '')) for item in [item_1, item_2, item_3, item_4]: dao.store_one(item.to_db_object()) items = self.item_handler.get_items_by_shop_and_category(None, None) self.assertEqual(len(items), 4) items = self.item_handler.get_items_by_shop_and_category( shop_a, category_a) self.assertEqual(len(items), 1) self.assertEqual(items[0]['name'], item_1.name) items = self.item_handler.get_items_by_shop_and_category(shop_b, None) self.assertEqual(len(items), 2) self.assertEqual(len([i for i in items if i['name'] == item_2.name]), 1) self.assertEqual(len([i for i in items if i['name'] == item_4.name]), 1) items = self.item_handler.get_items_by_shop_and_category( None, category_b) self.assertEqual(len([i for i in items if i['name'] == item_3.name]), 1) self.assertEqual(len([i for i in items if i['name'] == item_4.name]), 1)
def test_create_request_correctly(self): session_id = 'sessionId' requester = Requester('login', 'pw', 'first', 'last', '5f81ae776db502d353a84fdf') self.requester_handler.active_user_sessions[session_id] = requester item_1 = Item('item1', 42.42, 'category', '5f7c28c6e979c6a33a1f3f79', ProductDetails('', {}), Image('', '')) item_2 = Item('item2', 13.37, 'category', '5f7c28c6e979c6a33a1f3f79', ProductDetails('', {}), Image('', '')) item_1_id = self.items_dao.store_one(item_1.to_db_object()) item_2_id = self.items_dao.store_one(item_2.to_db_object()) item_1_amount = 5 item_2_amount = 3 request_items = [{ 'id': item_1_id, 'amount': item_1_amount }, { 'id': item_2_id, 'amount': item_2_amount }] request_id = self.request_handler.create_request( request_items, session_id) requests = self.requests_dao.get_all() self.assertEqual(len(requests), 1) self.assertEqual(str(requests[0]['_id']), request_id) self.assertEqual(str(requests[0]['requester']), requester.id) self.assertEqual(requests[0]['volunteer'], None) self.assertEqual(requests[0]['status'], RequestStatus.CREATED) self.assertEqual(str(requests[0]['items'][0]['id']), item_1_id) self.assertEqual(requests[0]['items'][0]['amount'], item_1_amount) self.assertEqual(str(requests[0]['items'][1]['id']), item_2_id) self.assertEqual(requests[0]['items'][1]['amount'], item_2_amount)
def get_image_summary_info(self, user): dev_observed = Device_Observed() res = { 'user_name': user.name, 'device_counts': dev_observed.count_user_devices(user.id), 'device_info': [] } devices = dev_observed.observed_devices(user.id) print devices pos = Position_Image() for dev in devices: contents_dev = {} print dev contents_dev['location'] = dev.location contents_dev['position_contents'] = [] positions = pos.get_position_by_device_id(dev.id) if positions: for pos in positions: img = Image() image_count = img.count_by('where position_id = ?', pos.id) contents_dev['position_contents'].append({ 'position': pos.position, 'duration': pos.duration, 'image_count': image_count, 'object_name': pos.object_name }) res['device_info'].append(contents_dev) return res
def test_calculate_gradient_with_same_difference_circle_area(self): pixels = (np.random.rand(150 * 150) < 0.5).astype(np.int16) pixels = pixels.reshape(150, 150) for x in range(0, 150): for y in range(0, 150): pixels[x][y] = 0 pixels[0][0] = 0 pixels[0][1] = 100 pixels[0][2] = 0 pixels[1][0] = 150 pixels[1][1] = 0 pixels[1][2] = 250 pixels[2][0] = 0 pixels[2][1] = 200 pixels[2][2] = 0 png.from_array(pixels, 'L').save("../Dane/circle__foo.png") myImage = Image("../Dane/circle__foo.png", 0) position = Position(50, 50) radius = 50 cArea = CircleArea(myImage, position.x, position.y, radius) histogram = cArea.create_histogram() for x in range(0, 8): if histogram.get(x) != 0: print(str(x) + ": " + str(histogram.get(x))) self.assertAlmostEqual(histogram.get(5), 0.0, delta=0.05) self.assertAlmostEqual(histogram.get(6), 0.0, delta=0.05) os.remove("../Dane/circle__foo.png")
def test_calculate_gradient_equals_zero_rectangle_area(self): pixels = (np.random.rand(150 * 150) < 0.5).astype(np.int16) pixels = pixels.reshape(150, 150) for x in range(0, 150): for y in range(0, 150): pixels[x][y] = 0 pixels[0][0] = 0 pixels[0][1] = 0 pixels[0][2] = 0 pixels[1][0] = 0 pixels[1][1] = 0 pixels[1][2] = 0 pixels[2][0] = 0 pixels[2][1] = 0 pixels[2][2] = 0 png.from_array(pixels, 'L').save("../Dane/rectangle__foo.png") myImage = Image("../Dane/rectangle__foo.png", 0) position = Position(1, 1) size = Size(10, 10) rArea = RectangleArea(myImage, position.x, position.y, size.height, size.width) histogram = rArea.create_histogram() self.assertAlmostEqual(histogram.get(0), 0.0, delta=0.01) self.assertAlmostEqual(histogram.get(1), 0.0, delta=0.01) os.remove("../Dane/rectangle__foo.png")
def img_upload(self, device_mac, device_pos, created_at, meta): if device_mac == "": return False if device_pos == "": return False dev = Device() pos = Position_Image() #print "upload_img",device_mac,device_pos device_id = dev.get_device_by_mac(device_mac) position_id = pos.get_position_id(device_id, device_pos) print "upload", device_id, position_id upload_path = os.path.join(get_pwd_dir(), CAPTURED_DIR) filename = meta['filename'] filename = os.path.basename(filename) print filename, '----', upload_path filepath = os.path.join(upload_path, filename) with open(filepath, 'wb') as up: up.write(meta['body']) img = Image() img.path = filename img.position_id = position_id img.created_at = created_at img_id = img.create() r = redis.Redis() r.set('image_path_%s_%s' % (device_mac, device_pos), img.path) print img_id if not img_id: return False return True
def getComic(comicId, lang="en"): from model.comic import Comic from model.image import Image c = get_db() t = text("SELECT title, DATE_FORMAT(pub_date, '%a, %d %b %Y %T') as pub_date_rss, explanation, type FROM comic WHERE comic_id = :comicId AND lang = :lang") results = c.execute(t, comicId = comicId, lang = lang) if results is None: return None title, pubDate, explanation, comicType = ("", "", "", "") for row in results: title = row['title'] pubDate = row['pub_date_rss'] if (row['explanation']): explanation = Markup(markdown.markdown(row['explanation'])) else: explanation = "" comicType = row['type'] t = text('SELECT filename, image_id, alt_text FROM image WHERE comic_id = :comicId AND lang = :lang') results = c.execute(t, comicId = comicId, lang = lang) images = [] for row in results: newImage = Image(s.STATIC_URL + row['filename'], comicId, row['image_id'], row['alt_text']) images.append(newImage) return Comic(title, images, comicId, pubDate, explanation, comicType)
def _process(self): wt = WaitProcess #para manipular el diálogo de espera ui = self._dialog.ui pt = self._pixel_mapper[str( ui.pixelType.currentText())] #tipo de pixel formato ITK dim = 3 #dimensión (siempre es 3D en este cargador) fileName = unicode(ui.fileName.text()) #nombre del fichero is_raw = ui.rawImage.isChecked() #para saber si la imagen es raw width = ui.widthValue.value() #anchoa de la imagen, si raw height = ui.heightValue.value() #alato de la imagen, si raw depth = ui.depthValue.value( ) #profundidad de la imagen, si raw y si 3D wt.change_info("Inicializando el cargador") ImageType = itk.Image[pt, dim] #tipo ITK de la imagen reader = itk.ImageFileReader[ImageType].New() #creamos el reader rawIO = None #imageIO para una imgen raw wt.change_value(10) if is_raw: wt.change_info("Inicializando el cargador RAW") rawIO = itk.RawImageIO[pt, dim].New() #crear el rawIO rawIO.SetFileDimensionality(dim) #poenrle dimensión 3D rawIO.SetDimensions(0, width) #ancho rawIO.SetDimensions(1, height) #alto rawIO.Setdimensions(2, depth) #profundidad reader.SetImageIO(rawIO.GetPointer( )) #especificar al Reader que el ImageIO que debe usar es RawIO wt.change_info("Cargando imagen") wt.change_value(20) reader.SetFileName(fileName) #especificar el nombre del fichero a leer reader.Update() #cargar la imagen wt.change_value(90) wt.change_info("Preparando la salida") uCharImageType = itk.Image[itk.UC, dim] toCharPixel = itk.RescaleIntensityImageFilter[ImageType, uCharImageType].New() toCharPixel.SetOutputMaximum(255) toCharPixel.SetOutputMinimum(0) toCharPixel.SetInput(reader.GetOutput()) toCharPixel.Update() name = fileName.split("/")[-1] #obtener el nombre format = "" if name.rfind(".") != -1: format = name[name.rfind("."):] #obtner el formato name = name[:name.rfind( ".")] #quitarle al nombre lo que está después del punto #Crear la imagen que se va a devolver self._img = Image(itk.UC, dim, displayName=name, originalFile=fileName, originalFormat=format.upper()) self._img.InternalImage = toCharPixel.GetOutput( ) #para la imagen a devolver esta es la imagen interna de ITK wt.stop()
def getComics(comicId=None, lang="en", orderBy="date", table="comic", imageTable="image"): from model.comic import Comic from model.image import Image c = get_db() langClause = " WHERE lang = :lang " idClause = "" if comicId is not None: idClause = "AND comic_id = :comicId " orderClause = "" if orderBy == "date": orderClause = "ORDER BY pub_date " elif orderBy == "popularity": orderClause = "ORDER BY popularity DESC" t = text( "SELECT comic_id, title, DATE_FORMAT(pub_date, '%a, %d %b %Y %T') as pub_date_rss, explanation, type FROM " + table + " WHERE status = 'active' AND lang = :lang " + idClause + orderClause) results = c.execute(t, comicId=comicId, lang=lang) if results is None: return None title, pubDate, explanation, comicType = ("", "", "", "") comics = [] for row in results: title = row['title'] pubDate = row['pub_date_rss'] comicIdRow = None if (row['explanation']): explanation = Markup(markdown.markdown(row['explanation'])) else: explanation = "" comicType = row['type'] comicIdRow = row['comic_id'] t = text('SELECT filename, image_id, alt_text, external_link FROM ' + imageTable + ' WHERE comic_id = :comicId AND lang = :lang') results = c.execute(t, comicId=comicId, lang=lang) images = [] for row in results: newImage = Image(s.STATIC_URL + row['filename'], comicId, row['image_id'], row['alt_text'], row['external_link']) images.append(newImage) comics.append( Comic(title, images, comicIdRow, pubDate, explanation, comicType)) return comics
def __init__(self, pt, dim, to_pt=None): self._input_pixel_type = pt if to_pt is None: to_pt = pt self._output_pixel_type = to_pt self._dimension = dim self._input_image_type = itk.Image[pt, dim] self._output_image_type = itk.Image[to_pt, dim] self._internal_filter = None self._output_image = Image(self._output_pixel_type, self._dimension)
def setUp(self): image = Image("test_file.txt", "./tests/test_file.txt") replica_manager = SecondaryBackup(replica_manager_id=1, image=image) secondaries = {} secondaries[replica_manager.replica_manager_id] = replica_manager primary_backup = PrimaryBackup(replica_manager_id=0, image=image, secondaries=secondaries) self.action = primary_backup._check_all_secondary_health()
def add_item(self, name: str, price: float, category: str, shop: str, description: str, attributes: Dict[str, Any], image_id: str, image_url: str, session_id: str) -> str: item = Item(name=name, price=price, category=category, shop=shop, details=ProductDetails(description, attributes), image=Image(image_id, image_url)) self.validate(item, session_id) id = self.dao.store_one(item.to_db_object()) return id
def apft_classification_of_whole_dataset(base_directory, classes, classifiers): for c in range(classes): for directory in os.listdir(base_directory): if os.path.isdir(os.path.join(base_directory, directory)): for filename in os.listdir( os.path.join(base_directory, directory, str(c))): path = os.path.join(base_directory, directory, str(c), filename) image = Image(path, c) result = apft_classification(classifiers, image, classifiers) print(str(path) + ', ' + str(c) + ', ' + str(result))
def list_image(self): result = [] list_image_url = 'http://%s:9292/v2/images' % self.registered_info[ 'cloud_ip'] response = requests.get(list_image_url, headers=headers) images = json.loads(response.content.decode())['images'] for image in images: # TODO 操作系统类型和版本 new_image = Image(image['id'], image['name'], None, 'centos', '7.4') result.append(new_image) return result
def generate_classificator(parameters_config, negative_class_train_dir_path, positive_class_train_dir_path): #random.seed(11) global train_set train_set = [] for filename in os.listdir(negative_class_train_dir_path): train_set.append(Image(os.path.join(negative_class_train_dir_path, filename), 0)) for filename in os.listdir(positive_class_train_dir_path): train_set.append(Image(os.path.join(positive_class_train_dir_path, filename), 1)) logger.debug('Loaded {} images from {} class training dataset'.format(len(os.listdir(negative_class_train_dir_path)), negative_class_train_dir_path)) logger.debug('Loaded {} images from {} class training dataset'.format(len(os.listdir(positive_class_train_dir_path)), positive_class_train_dir_path)) toolbox.register("evaluate", eval_classification) if parameters_config.getboolean("multithread"): pool = multiprocessing.Pool(parameters_config.getint("pool_size")) toolbox.register("map", pool.map) stats = tools.Statistics(lambda individual: individual.fitness.values) stats.register("avg", np.mean) stats.register("std", np.std) stats.register("min", np.min) stats.register("max", np.max) stats.register("learn_rate", learn_rate) pop = toolbox.population(n=parameters_config.getint("population")) crossover = parameters_config.getfloat("crossover") mutation = parameters_config.getfloat("mutation") epochs = parameters_config.getint("epochs") hof = tools.HallOfFame(1) algorithms.eaSimple(pop, toolbox, crossover, mutation, epochs, stats, halloffame=hof, verbose=False) toolbox.unregister("evaluate") if parameters_config.getboolean("multithread"): toolbox.register("map", map) pool.close() return pop, stats, hof
def getByMd5(self, md5): self.connect() image = None try: query = "SELECT * FROM Image WHERE md5 = \'{0}\'".format(md5) self.cursor.execute(query) row = self.cursor.fetchone() if row is not None: image = Image(row=row) except Error as err: print(err) self.disconnect() return image
def image_create(): json = request.get_json() newImage = Image(dict=json) newImage = ctrImage.create(newImage) if newImage is None: return jsonify({}), 404 else: for tag in newImage.getTagList(): adiTag = ctrAdiTag.getByTagDictionary(formats.parseAdiTag(tag)) #print(tag + " => " + adiTag.) if adiTag is not None: ctrImage.addTag(newImage, adiTag) return jsonify(newImage.serialize()), 201
def getById(self, id): self.connect() image = None try: query = "SELECT * FROM Image WHERE id = {0}".format(id) self.cursor.execute(query) row = self.cursor.fetchone() if row is not None: image = Image(row=row) except Error as err: print(err) self.disconnect() return image
def _get_checksum_content(self): checksum_path_path = f"{self.dir_getter.backups_dir()}/{self.secondary_backup_id}/checksum.txt" checksum_path_content = None try: with open(checksum_path_path, 'r') as checksum_file: checksum_path_content = checksum_file.read() checksum_file.close() except IOError: return "checksum is not present" image = Image(self.dir_getter.source_db_file_path()) return "checksum passed in equality operation" if checksum_path_content == image.perform( ) else "checksum failed in equality operation"
def ovo_classification_of_whole_dataset(base_directory, classes, classifiers, indices): for c in range(classes): for directory in os.listdir(base_directory): if os.path.isdir(os.path.join(base_directory, directory)): for filename in os.listdir( os.path.join(base_directory, directory, str(c))): path = os.path.join(base_directory, directory, str(c), filename) image = Image(path, c) ranking = ovo_classification(image, classes, classifiers, indices) print( str(path) + ', ' + str(c) + ', ' + str(ranking.argmax()))
def post_image(): data = request.get_json() author = data.get('author') if author in ["", None]: author = 'Anonymous' image = Image( img_id=Count.get_number(Image), author=author, board=data.get('board', 'other'), word=data.get('word', ''), url=data.get('url').split(";"), visible=False, ) image.save() r = dict(code=0) return json.dumps(r)
def count_correctly_classified(self, images_dir, comparison_operator): image_counter = 0 correctly_classified_image_counter = 0 logger.debug('Loading {} test images for class'.format( len(os.listdir(images_dir)))) for filename in os.listdir(images_dir): image = Image(os.path.join(images_dir, filename)) logger.debug(str(filename) + ',' + str(self.classificator(image))) image_counter += 1 if comparison_operator(self.classificator(image)): correctly_classified_image_counter += 1 return correctly_classified_image_counter, image_counter
def getList(self, tags, pagenum, limit, rating): self.connect() listImages = [] try: if (limit > self.__maxLimit): limit = self.__maxLimit if (limit < 1): limit = 1 page = (pagenum - 1) * limit query = "SELECT * FROM Image WHERE tag_string LIKE \'{0}\' AND rating LIKE \'{1}\' LIMIT {2},{3}".format( ("%" + tags + "%"), ("%" + rating + "%"), page, limit) self.cursor.execute(query) results = self.cursor.fetchall() for row in results: image = Image(row=row) listImages.append(image) except Error as err: print(err) self.disconnect() return listImages
def upload_image(file): file_name = file.filename ext = file_name.rsplit('.', 1)[1] m = hashlib.md5(file_name.encode("utf8")) key = m.hexdigest() q = Auth(app.config.get('ACCESS_KEY'), app.config.get('SECRET_KEY')) token = q.upload_token(app.config.get('BUCKET_NAME')) file_path = app.config.get('UPLOAD_FOLDER') + '/temp.' + ext file.save(file_path) put_file(token, key, file_path) host = app.config.get('FILE_SERVER_HOST') image = Image() image.name = file_name image.icon_url = host + '/' + key + '?' + app.config.get('ICON_STYLE') image.thumb_url = host + '/' + key + '?' + app.config.get('THUMB_STYLE') image.url = host + '/' + key db.session.add(image) db.session.commit() return image
def upload_image(cls, user_name, album_id, file): img = file.read() file_name = md5(img.decode('ISO-8859-1')) image = Image.select().filter(Image.user_name == user_name, Image.key == file_name).first() if image is not None: raise ServerException('图片已存在') url = QiniuService.upload_img(img, file_name=file_name) img_info = QiniuService.get_img_info(url) assert img_info is not None image = Image( album_id=album_id, user_name=user_name, key=file_name, url=url, width=img_info.get('width'), height=img_info.get('height'), size=img_info.get('size'), format=img_info.get('format'), color_model=img_info.get('colorModel') ) image.insert() return Image.select().filter(Image.key == file_name).one()
def add(summary, time, tags=[], kvps={}, hash=None, latitude=None, longitude=None, images=[]): result = Event(summary=summary, time=time, latitude=latitude, longitude=longitude, hash=hash) result.save() for tag in tags: result.add_tag(tag) for key in kvps.keys(): db_key = Key.get_key(key) kvp = KeyValuePair(key=db_key, value=kvps[key], event=result) kvp.save(force_insert=True) for image_path in images: image = Image(event=result, file=image_path) image.save()
def upload_file(): if "file" not in request.files: return error_response(NO_FILE_UPLOADED) f = request.files["file"] if f.filename == "": return error_response(NO_FILE_UPLOADED) is_public = request.form.get("is_public", "False").lower() == 'true' if f and allowed_file(f.filename): user = get_jwt_identity() _, file_extension = os.path.splitext(f.filename) filename = random_file_name() + file_extension image = Image(name=filename, owner_id=user, is_public=is_public) db.session.add(image) try: f.save(os.path.join(current_app.config["UPLOAD_FOLDER"], filename)) db.session.commit() except Exception: return error_response(ERROR_DURING_SAVING, 500) return redirect(url_for("upload.get_file", filename=filename)) else: return error_response(INVALID_FILE)
def tweet_post(): if request.method == 'POST': username = request.form['username'] content = request.form['content'] images = request.form.getlist('images[]') if username: user = User.query.filter_by(username=username).first() if user: tweet = Tweet(user.id, content) image_ids = [] if images: for img in images: image = Image(img) db.session.add(image) db.session.flush() image_ids.append(image.id) tweet.images = ','.join(map(str, image_ids)) db.session.add(tweet) db.session.commit() return jsonify(message="200 OK") else: return jsonify(error="No such user: %s" % username) else: return jsonify(error="Error param")
def test_calculate_gradient_with_same_difference_rectangle_area(self): pixels = (np.random.rand(150 * 150) < 0.5).astype(np.int16) pixels = pixels.reshape(150, 150) for x in range(0, 150): for y in range(0, 150): pixels[x][y] = 0 pixels[0][0] = 0 pixels[0][1] = 100 pixels[0][2] = 0 pixels[1][0] = 150 pixels[1][1] = 0 pixels[1][2] = 250 pixels[2][0] = 0 pixels[2][1] = 200 pixels[2][2] = 0 png.from_array(pixels, 'L').save("../Dane/rectangle__foo.png") myImage = Image("../Dane/rectangle__foo.png", 0) position = Position(1, 1) size = Size(10, 10) rArea = RectangleArea(myImage, position.x, position.y, size.height, size.width) histogram = rArea.create_histogram() for x in range(0, 8): if histogram.get(x) != 0: # print(str(x)+": "+str(histogram.get(x))) continue self.assertAlmostEqual(histogram.get(5), 0.8600, delta=0.05) self.assertAlmostEqual(histogram.get(6), 0.141421, delta=0.05) os.remove("../Dane/rectangle__foo.png")
def test_calculate_gradient_equals_zero_circle_area(self): pixels = (np.random.rand(150 * 150) < 0.5).astype(np.int16) pixels = pixels.reshape(150, 150) for x in range(0, 150): for y in range(0, 150): pixels[x][y] = 0 pixels[0][0] = 0 pixels[0][1] = 0 pixels[0][2] = 0 pixels[1][0] = 0 pixels[1][1] = 0 pixels[1][2] = 0 pixels[2][0] = 0 pixels[2][1] = 0 pixels[2][2] = 0 pixels[3][0] = 0 pixels[3][1] = 0 pixels[3][2] = 0 pixels[4][0] = 0 pixels[4][1] = 0 pixels[4][2] = 0 png.from_array(pixels, 'L').save("../Dane/circle__foo.png") myImage = Image("../Dane/circle__foo.png", 0) position = Position(50, 50) radius = 50 cArea = CircleArea(myImage, position.x, position.y, radius) histogram = cArea.create_histogram() self.assertAlmostEqual(histogram.get(0), 0.0, delta=0.01) self.assertAlmostEqual(histogram.get(1), 0.0, delta=0.01) os.remove("../Dane/circle__foo.png")