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_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 img_upload(device_mac, device_pos,created_at, meta):
if device_mac == "":
return False
if device_pos == "":
return False
dev = Device()
pos = Position()
#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(getPWDDir(), 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()
print img_id
if not img_id:
return False
return True
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 _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 img_list(cls, user_name, album_id):
album = Album.select().get(album_id)
assert album is not None
imgs = []
if album.is_public or album.user_name == user_name:
imgs = Image.select().filter(Image.album_id == album_id).order_by(Image.id.desc()).all()
layout = []
img_data = []
row_height = [0] * 4
for index, img in enumerate(imgs):
img_data.append(img.get_json())
row_num = math.floor(index / 4)
col_num = index % 4
log.info(f'{row_num}, {col_num}')
layout.append({
'x': 6 * (index % 4),
'y': sum([lo.get('h', 0) if (i % 6) == col_num else 0 for i, lo in enumerate(layout)]),
'w': 6,
'h': math.floor(img.height / img.width * 9),
'i': img.key,
'index': index
})
for i in range(4):
row_height[i] = sum([lo.get('h', 0) if index % 4 == i else 0 for index, lo in enumerate(layout)])
return {
'imgs': img_data,
'layout': layout,
'row_height': max(row_height)
}
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 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 vote():
"""
正负反馈api
:return:
00000-反馈成功
10001-图片不存在
10002-已经反馈过了
10003-意料之外的参数类型
"""
data = request.get_json()
img_id = data.get('img_id')
client_ip = request.headers.get("real_ip")
if client_ip is None:
client_ip = request.remote_addr
vote_type = data.get('type')
image = Image.objects(img_id=img_id).first()
if not image:
return json.dumps(dict(code=10001, ))
if vote_type is 1:
# 我觉得汪
if client_ip in image.w_list:
return json.dumps(dict(code=10002, ))
image.update(push__w_list=client_ip, w=image.w + 1)
elif vote_type is 0:
# 我觉得喵
if client_ip in image.m_list:
return json.dumps(dict(code=10002, ))
image.update(push__m_list=client_ip, m=image.m + 1)
else:
return json.dumps(dict(code=10003))
return json.dumps(dict(code=0))
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 get_image():
query_set = dict(visible=True, )
if request.args.get('board') in ("cat", "dog", "other"):
query_set['board'] = request.args.get('board')
try:
page = int(request.args.get('page'))
except ValueError as e:
page = 1
paginate = Image.objects(**query_set).exclude(
'w_list',
'm_list',
).paginate(page=page, per_page=15)
ms = paginate.items
p = 0
while paginate.has_next and p < 3:
p += 1
paginate = paginate.next()
data = [m.api_data() for m in ms]
return json.dumps(dict(
code=0,
data=data,
page=page,
next=p,
))
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 _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 reload(self):
if self.dst_image is None:
self.dst_image = Image()
self.dst_image.__init__(self.src_image.magic_word,
self.src_image.width,
self.src_image.height,
self.src_image.maxV,
self.src_image.pixel)
def delete_image(cls, user_name, id):
image = Image.select().get(id)
delete_status = QiniuService.delete_file(
config.QI_NIU.get('img_bucket_name'), image.key)
if not delete_status:
raise ServerException('删除图片失败')
image.delete()
return True
def post(self): restaurant_name = self.request.get(NAME) restaurant_uid = self.request.get(RESTAURANT_UID) restaurant_image_data = self.request.get(IMAGE_DATA) image = Image.from_image_data(restaurant_image_data) image.put() restaurant = restaurant_logic.add(restaurant_uid, restaurant_name, image.key) self.send_response(restaurant)
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 delete_album(cls, id):
album = Album.select().get(id)
assert album is not None
images = Image.select().filter(Image.album_id == id).all()
for image in images:
QiniuService.delete_file(config.QI_NIU.get('img_bucket_name'), image.key)
image.delete()
album.delete()
return True
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 from_db_object(self, db_object: Dict[str, Any]) -> Item:
return Item(
name=db_object['name'],
price=db_object['price'],
category=db_object['category'],
shop=str(db_object['shop']),
details=ProductDetails.from_db_object(db_object['details']),
image=None if db_object['image'] is None else Image.from_db_object(
db_object['image']),
id=str(db_object['_id']))
def get_comment():
img_id = request.args.get("img_id")
image = Image.objects(img_id=img_id).first()
if not image:
return json.dumps(dict(code=10001))
data = [c.api_data() for c in image.comments]
return json.dumps(dict(
code=0,
data=data,
))
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 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 create_thumbnails():
count = 0
last_update = datetime.datetime.now()
print "Creating thumbnails..."
for image in Image.select():
image.create_thumbnail(False)
count += 1
if (datetime.datetime.now() - last_update).total_seconds() > 5:
last_update = datetime.datetime.now()
print str(count) + " thumbnais created..."
print "All thumnails created."
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 post(self):
restaurant_uid = self.request.get(RESTAURANT_UID)
category_name = self.request.get(CATEGORY_NAME)
dish_name = self.request.get(NAME)
dish_image_data = self.request.get(IMAGE_DATA)
img_key = None
if dish_image_data:
image = Image.from_image_data(dish_image_data)
image.put()
img_key = image.key
dish = dish_logic.add(restaurant_uid, category_name, dish_name, img_key)
self.send_response(dish)
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 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 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 to_dict(event):
image_query = Image.select().where(Image.event == event).order_by(
Image.time)
images = [image.id for image in image_query]
return {
"id": event.id,
"summary": event.summary,
"time": event.get_time().timestamp() * 1000,
"tags": event.get_tags(),
"url": event.get_value("url"),
"images": images
}
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 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 get_summery_info(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()
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 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 __init__(self, app):
self.src_image = Image()
self.dst_image = None
self.frame = Frame()
self.panel = Panel(self.frame)
#self.panel.open.Bind(wx.EVT_BUTTON, self.OnOpen)
self.panel.choice.Bind(wx.EVT_CHOICE, self.onChoice)
self.panel.go.Bind(wx.EVT_BUTTON, self.onGo)
self.panel.mdf_param.Bind(wx.EVT_BUTTON, self.onModify)
pub.subscribe(self.displayLeft, "LEFT IMAGE LOADED")
pub.subscribe(self.displayRight, "RIGHT IMAGE CHANGED")
''' Load left image '''
self.loadLeft(self.dir + self.src)
''' Load Reference image '''
self.loadRef(self.dir + self.ref)
self.frame.Show(True)
def testInsertEntity(self):
image = Image.from_image_data(self.image_data)
image.put()
self.assertEqual('image/png', image.mimetype)
self.assertEqual(1, len(image.query().fetch(2)))
def testDecode(self):
decoded_data = Image.decode_image_data(self.base64_data)
f = open('image.png', 'r')
self.assertEqual(f.read(), decoded_data)
def get(self, *args,**kwargs):
usr = self.get_current_user()
device_observed = Device_Observed()
position = Position_Image()
image = Image()
devices = device_observed.observed_devices(usr.id)
if not devices or len(devices) < 1:
return self.render('no_devices.html', user_name=usr.name, page_name="browser")
positions = []
for dev in devices:
positions.extend(position.get_position_by_device_id(dev.id))
current_position_id = self.get_argument('position_id', '')
current_page = self.get_argument('page', '')
if current_page:
current_page = int(current_page)
else:
current_page = 1
if current_position_id:
current_position_id = current_position_id
else:
# positions = position.get_position_by_device_id(devices[0].id)
if positions:
current_position_id = positions[0].id
else:
current_position_id = 0
total_image_num = image.count_by_position_id(current_position_id)
total_page_num = total_image_num/IMAGE_NUMBER_FOR_PAGE+1
start_image_num = (current_page - 1)*IMAGE_NUMBER_FOR_PAGE + 1
if total_page_num < current_page:
current_page = total_page_num
images = image.find_by('order by id desc limit ? offset ?',
IMAGE_NUMBER_FOR_PAGE,
(current_page - 1)*IMAGE_NUMBER_FOR_PAGE)
for img in images:
img.created_at = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime(img.created_at))
# get the start and end page num
if current_page > 3:
start_page_num = current_page-3
else:
start_page_num = 1
end_page_num = start_page_num+6
if end_page_num>total_page_num:
end_page_num = total_page_num
start_page_num = end_page_num-6
if start_page_num<1:
start_page_num = 1
end_image_num = start_image_num+len(images)-1
return self.render('browser.html',
page_name='browser',
positions=positions,
current_position_id=current_position_id,
current_page=current_page,
total_page_num=total_page_num,
total_image_num=total_image_num,
start_image_num=start_image_num,
end_image_num=end_image_num,
start_page_num=start_page_num,
end_page_num=end_page_num,
user_name=usr.name,
images=images
)
class Controller:
dir = 'C:\Users\Xing\git\CS555\image\\'
#src = 'src_ascii.pgm'
#src = 'moon_ascii.pgm'
#src = 'Fig0507_a__ckt_board_orig__tif_ascii.pgm'
#src = 'Fig0507_b__ckt_board_gauss_var_400__tif_ascii.pgm'
#src = 'Fig0508_a__circuit_board_pepper_prob_pt1__tif_ascii.pgm'
#src = 'Fig0508_b__circuit_board_salt_prob_pt1__tif_ascii.pgm'
#src = 'Fig0510_a__ckt_board_saltpep_prob_pt05__tif_ascii.pgm'
#src = 'Fig0512_a__ckt_uniform_var_800__tif_ascii.pgm'
src = 'Fig0512_b__ckt_uniform_plus_saltpepr_prob_pt1__tif_ascii.pgm'
#src = 'Fig0513_a__ckt_gaussian_var_1000_mean_0__tif_ascii.pgm'
dst = 'dst.pgm'
tmp = 'tmp.pgm'
tmp2 = 'tmp2.pgm'
ref = 'ref.pgm'
#default = 'default.pgm'
choice = None
opt_01_width = enum.DEFAULT_WIDTH_MIN
opt_01_height = enum.DEFAULT_HEIGHT_MIN
opt_02_width = enum.DEFAULT_WIDTH_MIN
opt_02_height = enum.DEFAULT_HEIGHT_MIN
opt_02_selection = enum.ZOOM_BILINEAR
opt_03_gray_lvl = enum.DEFAULT_GRAY_LEVEL
opt_03_sgn = enum.DEFAULT_SIGN
opt_04_selection = enum.DEFAULT_TRANS
opt_04_c = enum.DEFAULT_C
opt_04_gamma = enum.DEFAULT_GAMMA
opt_05_selection = enum.DEFAULT_HIST_EQ
opt_05_resolution = enum.DEFAULT_RESLTN_MIN
opt_07_resolution = enum.DEFAULT_RESLTN_MIN
opt_07_selection = enum.SP_FLT_SMOOTH
opt_07_laplacian = enum.DEFAULT_LAPLACIAN
opt_07_k = enum.DEFAULT_K
opt_08_bits = 64
opt_09_resolution = enum.DEFAULT_RESLTN_MIN
opt_09_selection = enum.RESTORE_ARITHMETIC
def __init__(self, app):
self.src_image = Image()
self.dst_image = None
self.frame = Frame()
self.panel = Panel(self.frame)
#self.panel.open.Bind(wx.EVT_BUTTON, self.OnOpen)
self.panel.choice.Bind(wx.EVT_CHOICE, self.onChoice)
self.panel.go.Bind(wx.EVT_BUTTON, self.onGo)
self.panel.mdf_param.Bind(wx.EVT_BUTTON, self.onModify)
pub.subscribe(self.displayLeft, "LEFT IMAGE LOADED")
pub.subscribe(self.displayRight, "RIGHT IMAGE CHANGED")
''' Load left image '''
self.loadLeft(self.dir + self.src)
''' Load Reference image '''
self.loadRef(self.dir + self.ref)
self.frame.Show(True)
def onChoice(self, event):
self.choice = event.GetString()
print("choose: %s" % self.choice)
def onGo(self, event):
if self.choice == enum.OPT_01_SHRINK:
print enum.OPT_01_SHRINK
self.shrinkRight(self.dir + self.dst)
elif self.choice == enum.OPT_02_ZOOM_BACK:
print enum.OPT_02_ZOOM_BACK
self.zoomBackRight(self.dir + self.dst)
elif self.choice == enum.OPT_03_REDUCE_GL:
print enum.OPT_03_REDUCE_GL
self.reduceGrayLevel(self.dir + self.dst)
elif self.choice == enum.OPT_04_TRANSFORM:
print enum.OPT_04_TRANSFORM
self.transform(self.dir + self.dst)
elif self.choice == enum.OPT_05_HISTO_EQ:
print enum.OPT_05_HISTO_EQ
self.histogramEQ(self.dir + self.dst)
elif self.choice == enum.OPT_06_HISTO_MAT:
print enum.OPT_06_HISTO_MAT
self.histogramMatch(self.dir + self.dst)
elif self.choice == enum.OPT_07_SPATIAL_FLT:
print enum.OPT_07_SPATIAL_FLT
self.spatialFilterRight(self.dir + self.dst)
elif self.choice == enum.OPT_08_BIT_PLANE:
print enum.OPT_08_BIT_PLANE
self.bitPlaneRight(self.dir + self.dst)
elif self.choice == enum.OPT_09_RESTORE:
print enum.OPT_09_RESTORE
self.restoreImage(self.dir + self.dst)
else:
print "Do nothing"
def onModify(self, event):
if self.choice is not None:
useMetal = False
if 'wxMac' in wx.PlatformInfo:
useMetal = self.cb.IsChecked()
dlg = MdfDialog(self.panel, -1, self.choice, size=(350, 200),
style=wx.DEFAULT_DIALOG_STYLE,
useMetal=useMetal)
dlg.CenterOnScreen()
val = dlg.ShowModal()
if val == wx.ID_OK:
if self.choice == enum.OPT_01_SHRINK:
self.opt_01_width = int(dlg.opt_01_text1.GetValue())
self.opt_01_height = int(dlg.opt_01_text2.GetValue())
elif self.choice == enum.OPT_02_ZOOM_BACK:
self.opt_02_width = int(dlg.opt_02_text1.GetValue())
self.opt_02_height = int(dlg.opt_02_text2.GetValue())
if dlg.opt_02_choice1.GetValue() is True:
self.opt_02_selection = enum.ZOOM_REPLIC
elif dlg.opt_02_choice2.GetValue() is True:
self.opt_02_selection = enum.ZOOM_NEAR_NGHR
elif dlg.opt_02_choice3.GetValue() is True:
self.opt_02_selection = enum.ZOOM_BILINEAR
print self.opt_02_selection
elif self.choice == enum.OPT_03_REDUCE_GL:
self.opt_03_gray_lvl = int(dlg.opt_03_text1.GetValue())
if self.opt_03_gray_lvl < 1:
self.opt_03_gray_lvl = 1
elif self.opt_03_gray_lvl > 8:
self.opt_03_gray_lvl = 8
if dlg.opt_03_choice1.GetValue() is True:
self.opt_03_sgn = enum.REDUCE_GL_LEAST
elif dlg.opt_03_choice2.GetValue() is True:
self.opt_03_sgn = enum.REDUCE_GL_MOST
print("%s %d" % (self.opt_03_sgn, self.opt_03_gray_lvl))
elif self.choice == enum.OPT_04_TRANSFORM:
if dlg.opt_04_choice1.GetValue() is True:
self.opt_04_selection = enum.TRANS_LOG
self.opt_04_c = float(dlg.opt_04_text1.GetValue())
print("%s %d %d" % (self.opt_04_selection,
self.opt_04_c,
self.opt_04_gamma))
elif dlg.opt_04_choice2.GetValue() is True:
self.opt_04_selection = enum.TRANS_POW
self.opt_04_c = float(dlg.opt_04_text2.GetValue())
self.opt_04_gamma = float(dlg.opt_04_text3.GetValue())
print("%s %d %d" % (self.opt_04_selection,
self.opt_04_c,
self.opt_04_gamma))
elif self.choice == enum.OPT_05_HISTO_EQ:
if dlg.opt_05_choice1.GetValue() is True:
self.opt_05_selection = enum.HIST_EQ_GLOBAL
elif dlg.opt_05_choice2.GetValue() is True:
self.opt_05_selection = enum.HIST_EQ_LOCAL
self.opt_05_resolution = int(dlg.opt_05_text1.GetValue())
elif self.choice == enum.OPT_07_SPATIAL_FLT:
if dlg.opt_07_choice1.GetValue() is True:
self.opt_07_resolution = int(dlg.opt_07_text1.GetValue())
self.opt_07_selection = enum.SP_FLT_SMOOTH
elif dlg.opt_07_choice2.GetValue() is True:
self.opt_07_resolution = int(dlg.opt_07_text1.GetValue())
self.opt_07_selection = enum.SP_FLT_MEDIAN
elif dlg.opt_07_choice3.GetValue() is True:
self.opt_07_laplacian = int(dlg.opt_07_text2.GetValue())
self.opt_07_selection = enum.SP_FLT_LAPLACIAN
elif dlg.opt_07_choice4.GetValue() is True:
self.opt_07_k = int(dlg.opt_07_text3.GetValue())
self.opt_07_selection = enum.SP_FLT_H_BOOST
print self.opt_07_selection
elif self.choice == enum.OPT_08_BIT_PLANE:
self.opt_08_bits = 0
if dlg.opt_08_check1.GetValue() is True:
self.opt_08_bits |= 1
if dlg.opt_08_check2.GetValue() is True:
self.opt_08_bits |= 1 << 1
if dlg.opt_08_check3.GetValue() is True:
self.opt_08_bits |= 1 << 2
if dlg.opt_08_check4.GetValue() is True:
self.opt_08_bits |= 1 << 3
if dlg.opt_08_check5.GetValue() is True:
self.opt_08_bits |= 1 << 4
if dlg.opt_08_check6.GetValue() is True:
self.opt_08_bits |= 1 << 5
if dlg.opt_08_check7.GetValue() is True:
self.opt_08_bits |= 1 << 6
if dlg.opt_08_check8.GetValue() is True:
self.opt_08_bits |= 1 << 7
print self.opt_08_bits
elif self.choice == enum.OPT_09_RESTORE:
self.opt_09_resolution = int(dlg.opt_09_text1.GetValue())
if dlg.opt_09_choice1.GetValue() is True:
self.opt_09_selection = enum.RESTORE_ARITHMETIC
elif dlg.opt_09_choice2.GetValue() is True:
self.opt_09_selection = enum.RESTORE_GEOMETRIC
elif dlg.opt_09_choice3.GetValue() is True:
self.opt_09_selection = enum.RESTORE_HARMONIC
elif dlg.opt_09_choice4.GetValue() is True:
self.opt_09_selection = enum.RESTORE_CONTRAHARM
elif dlg.opt_09_choice5.GetValue() is True:
self.opt_09_selection = enum.RESTORE_MAX
elif dlg.opt_09_choice6.GetValue() is True:
self.opt_09_selection = enum.RESTORE_MIN
elif dlg.opt_09_choice7.GetValue() is True:
self.opt_09_selection = enum.RESTORE_MIDPOINT
elif dlg.opt_09_choice8.GetValue() is True:
self.opt_09_selection = enum.RESTORE_ALPHA_TRIM
print self.opt_09_selection
else:
print "Cancelled..."
dlg.Destroy()
else:
print "Not exist"
def loadLeft(self, path):
self.src_image.readContent(path)
self.src_image.loadLeft(self.src_image,
enum.DEFAULT_WIDTH,
enum.DEFAULT_HEIGHT,
self.dir + self.tmp)
def loadRef(self, path):
self.opt_06_ref_image = Image()
self.opt_06_ref_image.readContent(path)
def reload(self):
if self.dst_image is None:
self.dst_image = Image()
self.dst_image.__init__(self.src_image.magic_word,
self.src_image.width,
self.src_image.height,
self.src_image.maxV,
self.src_image.pixel)
def shrinkRight(self, path):
self.reload(self.src_image, self.dst_image)
self.dst_image.shrinkRight(self.dst_image,
self.opt_01_width,
self.opt_01_height,
path)
def zoomBackRight(self, path):
self.reload(self.src_image, self.dst_image)
self.dst_image.zoomBack(self.dst_image,
self.opt_02_selection,
self.opt_02_width,
self.opt_02_height,
self.dir + self.tmp2,
enum.DEFAULT_WIDTH,
enum.DEFAULT_HEIGHT,
path)
def reduceGrayLevel(self, path):
self.reload()
self.dst_image.reduceGrayLevel(self.dst_image,
self.opt_03_gray_lvl,
self.opt_03_sgn,
path)
def transform(self, path):
self.reload()
self.dst_image.transform(self.src_image,
self.opt_04_selection,
self.opt_04_c,
self.opt_04_gamma,
path)
def histogramEQ(self, path):
self.reload()
self.dst_image.histogramEQ(self.src_image,
self.opt_05_selection,
self.opt_05_resolution,
path)
def histogramMatch(self, path):
self.reload()
self.dst_image.histogramMatch(self.src_image,
self.opt_06_ref_image,
path)
def spatialFilterRight(self, path):
self.reload()
self.dst_image.spatialFilter(self.dst_image,
self.opt_07_selection,
self.opt_07_resolution,
self.opt_07_laplacian,
self.opt_07_k,
path)
def bitPlaneRight(self, path):
self.reload()
self.dst_image.bitPlane(self.dst_image,
self.opt_08_bits,
path)
def restoreImage(self, path):
self.reload()
self.dst_image.restoreImage(self.dst_image,
self.opt_09_selection,
self.opt_09_resolution,
path)
def displayLeft(self, message):
self.panel.setLeftImage(message.data)
def displayRight(self, message):
self.panel.setRightImage(message.data)
def loadRef(self, path):
self.opt_06_ref_image = Image()
self.opt_06_ref_image.readContent(path)
