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")
