def __init__(self): self.ui = Ui_SettingsWindow() self.image_handler = ImageHandler() self.ui.set_image_handler(self.image_handler) self.clicked_square = "" self.main_window_video_open = False self.main_window = None
def closure():
# correct the values of updated input image
input_img.data.clamp_(0, 1)
optimizer.zero_grad()
model(input_img)
style_score = 0
content_score = 0
for sl in style_losses:
style_score += sl.loss
for cl in content_losses:
content_score += cl.loss
style_score *= style_weight
content_score *= content_weight
loss = style_score + content_score
loss.backward()
run[0] += 1
if run[0] % 5 == 0:
print("run {}:".format(run))
print('Style Loss : {:4f} Content Loss: {:4f}'.format(
style_score.item(), content_score.item()))
print()
if prev:
img_handler.imshow(input_img,
unloader,
title='Run {}'.format(run))
if runs:
run_save = os.path.join(run_path, f'run{run}.jpg')
img_handler.imsave(run_save, unloader, input_img)
return style_score + content_score
def recognize_text(self, img, task=""):
word_list = []
print("Image Processing Started")
img_handler = ImageHandler()
words = img_handler.split_text(img, task)
for word in words:
img = cv2.cvtColor(word, cv2.COLOR_BGR2GRAY)
# img = img_handler.preprocess_normal_handwriting(img)
img = img_handler.preprocess(img, self.img_size)
word_list.append(img)
# cv2.imshow('word', word)
# cv2.waitKey(0)
print("Image Processing Finished")
print("Recognizing Text Started")
batch = Batch(None, word_list)
recognized_list = self.model.batch_test(batch)
print('Image Text: ', recognized_list)
text = ''
for i in recognized_list:
text += i + ' '
return text
def __init__(self, url, timeout):
self.url = url
self.timeout = timeout
self.ioloop = IOLoop.instance()
self.ws = None
self.imgHandler = ImageHandler()
self.connect()
PeriodicCallback(self.keep_alive, 20000).start()
self.ioloop.start()
def __init__(self, *args, **kwargs):
self.clip_name = args[0].input_video
self.subclip_length = args[0].subclip_length
self.out_clip = None
self.out_clip_name = args[0].output_video
# self.video_clip = VideoFileClip(self.clip_name).subclip(0, self.subclip_length)
# self.video_clip = VideoFileClip(self.clip_name).subclip(20, 25)
# self.video_clip = VideoFileClip(self.clip_name).subclip(38, 40)
self.video_clip = VideoFileClip(self.clip_name)
self.frame_counter = 0
self.image_handler = ImageHandler()
def predict(self, model_path='./model/the_model.ckpt'):
n_input = 784
n_output = 10
n_hidden1 = 256
n_hidden2 = 128
n_hidden3 = 64
net_input = tf.placeholder(tf.float32, [None, n_input])
y_true = tf.placeholder(tf.float32, [None, 10])
W1 = tf.Variable(tf.truncated_normal([n_input, n_hidden1]))
b1 = tf.Variable(tf.truncated_normal([n_hidden1]))
W2 = tf.Variable(tf.truncated_normal([n_hidden1, n_hidden2]))
b2 = tf.Variable(tf.truncated_normal([n_hidden2]))
W3 = tf.Variable(tf.truncated_normal([n_hidden2, n_hidden3]))
b3 = tf.Variable(tf.truncated_normal([n_hidden3]))
W4 = tf.Variable(tf.truncated_normal([n_hidden3, n_output]))
b4 = tf.Variable(tf.truncated_normal([n_output]))
# the model
hidden1_res = tf.nn.tanh(tf.add(tf.matmul(net_input, W1), b1))
hidden2_res = tf.nn.tanh(tf.add(tf.matmul(hidden1_res, W2), b2))
hidden3_res = tf.nn.sigmoid(tf.add(tf.matmul(hidden2_res, W3), b3))
hidden3_res = tf.nn.dropout(hidden3_res, 0.8)
net_output = tf.add(tf.matmul(hidden3_res, W4), b4)
trained = tf.add(tf.matmul(hidden3_res, W4), b4)
# prediction and actual using the argmax as the predicted label
correct_prediction = tf.equal(tf.argmax(net_output, 1),
tf.argmax(y_true, 1))
# And now we can look at the mean of our network's correct guesses
accuracy = tf.reduce_mean(tf.cast(correct_prediction, "float"))
cost = tf.reduce_sum(
tf.nn.softmax_cross_entropy_with_logits(logits=net_output,
labels=y_true))
eta = 0.02
# optimizer = tf.train.AdamOptimizer(eta).minimize(cost)
optimizer = tf.train.GradientDescentOptimizer(eta).minimize(cost)
# optimizer = tf.train.RMSPropOptimizer(eta).minimize(cost)
sess = tf.Session()
sess.run(tf.global_variables_initializer())
# ### load model from file ###
with tf.Session() as sess:
# Restore variables from disk.
sess.run(tf.global_variables_initializer())
saver = tf.train.import_meta_graph(model_path + '.meta')
saver.restore(sess, model_path)
parser = ImageHandler()
images, labels = parser.parse_images()
print("Accuracy for self uploaded images: {}".format(
sess.run(accuracy,
feed_dict={
net_input: images,
y_true: labels
})))
pred = sess.run(trained, feed_dict={net_input: images})
return pred
def delete_post():
if session.get('logged_in') is not None:
accountDao = AccountDao()
ownerMatched = accountDao.remove_account_post(session['logged_in'],
request.form['postId'])
if not ownerMatched:
return redirect(url_for('PetCare.list_posts'))
postDao = PostDao()
prevImages = postDao.remove_post(request.form['postId'])
for img in prevImages:
ImageHandler.delete_image(img)
return redirect(url_for('PetCare.list_posts'))
def read_format_to_export_an_image(self):
"""
This method reads the format to export an image file from one format to another
Return:
new_format.- String with the new format to convert the image
"""
image_handler = ImageHandler()
msg_to_display = "Insert the format to export an image file from one format to another: "
new_format = self.read_value_from_user(msg_to_display)
if (image_handler.validate_format_inserted(new_format) == True):
return new_format
else:
return "Incorrect format"
def setUp(self):
# set up appium
desired_caps = {}
desired_caps[
"app"] = "jp.co.sharp.ebook.ebookapp_h35559jr9hy9m!jp.co.sharp.ebook.ebookapp"
desired_caps["deviceName"] = "WindowsPC"
desired_caps["platformName"] = "Windows"
# desired_caps["app"] = "Microsoft.WindowsCalculator_8wekyb3d8bbwe"
self.driver = webdriver.Remote(
command_executor='http://127.0.0.1:4723/wd/hub',
desired_capabilities=desired_caps)
self.imageHandler = ImageHandler()
self.mouseHandler = MouseHandler()
class PoolTableFinder:
def __init__(self):
self.imageHandler = ImageHandler()
self.rawImagePath = ConfigHandler.getRawImagePath()
self.croppedImagePath = ConfigHandler.getCroppedImagePath()
def saveCroppedImage(self):
Logger.info("Saving cropped image")
currentImage = self.imageHandler.readImage(self.rawImagePath)
if CommandHandler.areBoundsSet():
bounds = CommandHandler.getBounds()
croppedImage = self.imageHandler.cropAndRotateRectangleInImage(
currentImage, bounds)
else:
bounds = self.getBoundingRectForTable(currentImage)
croppedImage = self.imageHandler.cropImageByBoundingRect(
currentImage, bounds)
cv.imwrite(self.croppedImagePath, croppedImage)
def getMaskForTable(self, poolImage):
self.th_green_low = numpy.array(CommandHandler.getThGreenLow())
self.th_green_high = numpy.array(CommandHandler.getThGreenHigh())
hsvImage = cv.cvtColor(poolImage, cv.COLOR_BGR2HSV)
return self.getMask(hsvImage)
def getBoundingRectForTable(self, poolImage):
mask = self.getMaskForTable(poolImage)
contours = self.getContours(mask)
return self.getLargestBoundingRect(contours)
def getMask(self, hsvImage):
mask = cv.inRange(hsvImage, self.th_green_low, self.th_green_high)
return mask
def getContours(self, mask):
contours = cv.findContours(mask.copy(), cv.RETR_EXTERNAL,
cv.CHAIN_APPROX_SIMPLE)[-2]
if len(contours) == 0:
raise PoolTableException("No contours found")
return contours
def getLargestBoundingRect(self, contours):
area = max(contours, key=cv.contourArea)
return cv.boundingRect(area)
def make_post_output(postInfo):
postInfo['start_date_year_first'] = time.strftime(
'%Y-%m-%d', time.localtime(postInfo['start_date']))
postInfo['end_date_year_first'] = time.strftime(
'%Y-%m-%d', time.localtime(postInfo['end_date']))
postInfo['start_date'] = time.strftime(
'%m/%d/%Y', time.localtime(postInfo['start_date']))
postInfo['end_date'] = time.strftime(
'%m/%d/%Y', time.localtime(postInfo['end_date']))
if 'post_date' in postInfo:
postInfo['post_date'] = time.strftime(
'%m/%d/%Y %H:%M:%S', time.localtime(postInfo['post_date']))
if 'gender' in postInfo:
postInfo[
'gender'] = 'Male' if postInfo['gender'] == 1 else 'Female'
if 'age' in postInfo:
postInfo['age'] = '<1 year' if postInfo[
'age'] == 0 else '>= 10 years' if postInfo['age'] == 10 else (
str(postInfo['age']) + ' years')
if 'interested' in postInfo:
postInfo['interested'] = [] if postInfo[
'interested'] is None else postInfo['interested'].split(',')
for i in ['image1', 'image2', 'image3']:
if i in postInfo and postInfo[i] is not None:
postInfo[i] = ImageHandler.get_image_full_path(postInfo[i])
return postInfo
def get_next(self):
labels = []
imgs = []
batch_range = range(self.current_index, self.current_index + self.batch_size)
for i in batch_range:
sample = self.samples[i]
labels.append(sample.label)
img = cv2.imread(sample.file_path, cv2.IMREAD_GRAYSCALE)
img_handler = ImageHandler()
img = img_handler.preprocess(img, self.img_size)
imgs.append(img)
self.current_index += self.batch_size
return Batch(labels, imgs)
def read_degrees_to_rotate_image(self):
"""
This method reads from the user the number of degrees to rotates an image file
Evaluate the number inserted and returns the number of degrees if it is correct
otherwise print an error message
Return:
degrees.- Number of degrees to rotate the image
If the number inserted is out of the valid range, the method returns 9999
"""
image_handler = ImageHandler()
msg_to_display = "Insert the number of degrees to rotate the image: "
degrees = self.read_value_from_user(msg_to_display)
degrees = int(degrees)
if image_handler.validate_degrees_inserted(degrees) == True:
return degrees
else:
return 9999
def test_address(self, img, task=""):
word_list = []
img_handler = ImageHandler()
words = img_handler.split_text(img, task)
for word in words:
img = cv2.cvtColor(word, cv2.COLOR_BGR2GRAY)
# img = img_handler.preprocess_normal_handwriting(img)
img = img_handler.preprocess(img, self.img_size)
word_list.append(img)
# cv2.imshow('word', word)
# cv2.waitKey(0)
batch = Batch(None, word_list)
recognized_list = self.model.batch_test(batch)
return recognized_list
def predict(self,load_path):
new_saver = tf.train.Saver()
#graph = tf.Graph()
with tf.Session() as sess:
sess.run(tf.global_variables_initializer())
new_saver = tf.train.import_meta_graph(load_path+'.meta')
new_saver.restore(sess, load_path)
parser = ImageHandler()
if(SRC != None and DEST != None):
images, labels = parser.parse_images(SRC,DEST)
else:
images, labels = parser.parse_images()
print("Accuracy for self uploaded images: {}".format(sess.run(accuracy,
feed_dict = {
net_input: images,
y_true: labels
})))
predictions = sess.run(net_output, feed_dict = {net_input: images})
#self.print_predictions(predictions)
self.print_to_console(labels, predictions)
def __init__(self):
"""
Sets up program variables, resets files, does not tell arduino to start
"""
GPIO.setmode(GPIO.BCM)
self.ei = ErrorIndicator(False)
self.ih = ImageHandler(False, self.ei)
self.processor = ImageProcessor(self.ih, self.ei)
self.arduino = Arduino(self.ei)
GPIO.setup(24, GPIO.IN, pull_up_down=GPIO.PUD_UP)
GPIO.setup(25, GPIO.IN)
GPIO.setwarnings(False)
if os.path.exists("out/"):
shutil.rmtree("out")
os.makedirs("out")
if os.path.exists("log.txt"):
os.remove("log.txt")
Log.setup_log()
def make_post_output(postInfo):
postInfo['start_date'] = time.strftime(
'%m/%d/%Y', time.localtime(postInfo['start_date']))
postInfo['end_date'] = time.strftime(
'%m/%d/%Y', time.localtime(postInfo['end_date']))
if 'post_date' in postInfo:
postInfo['post_date'] = time.strftime(
'%m/%d/%Y %H:%M:%S', time.localtime(postInfo['post_date']))
for i in ['image1', 'image2', 'image3']:
if i in postInfo and postInfo[i] is not None:
postInfo[i] = ImageHandler.get_image_full_path(postInfo[i])
return postInfo
def recur(site, interval, process=True):
wh = WebHandler(visual=False)
ih = ImageHandler(ImageMagick, os.path.join(tempDir, 'temp.png'))
print('starting process...')
i = 1
while(1):
currentTime = time.localtime()
print('\nstarting frame at %s...' % time.strftime("%H:%M:%S", currentTime))
filename = '%s.png' % time.strftime("%H-%M-%S", currentTime)
path = os.path.join(screenshotDir, filename)
wh.screenshot(site, path)
# process the image if desired
if process:
hour = time.strftime("%H", currentTime)
minute = time.strftime("%M", currentTime)
outFile = os.path.join(outputDir, '%04d.png' % i)
ih.processImage(path, outFile, [hour, minute])
i += 1
time.sleep(round(60 * interval))
class PoolTableChecker:
def __init__(self):
self.tableFinder = PoolTableFinder()
self.imageComparator = ImageComparator()
self.imageHandler = ImageHandler()
def isTableFree(self, imagePathA, imagePathB):
imageA = self.imageHandler.readImage(imagePathA)
imageB = self.imageHandler.readImage(imagePathB)
if CommandHandler.areBoundsSet():
bounds = CommandHandler.getBounds()
croppedA = self.imageHandler.cropAndRotateRectangleInImage(
imageA, bounds)
croppedB = self.imageHandler.cropAndRotateRectangleInImage(
imageB, bounds)
else:
tableABounds = self.tableFinder.getBoundingRectForTable(imageA)
tableBBounds = self.tableFinder.getBoundingRectForTable(imageB)
largestBounds = self.imageHandler.getLargestBoundingRect(
tableABounds, tableBBounds)
croppedA = self.imageHandler.cropImageByBoundingRect(
imageA, largestBounds)
croppedB = self.imageHandler.cropImageByBoundingRect(
imageB, largestBounds)
return self.imageComparator.areImagesEqual(croppedA, croppedB)
def recur(site, interval, process=True):
wh = WebHandler(visual=False)
ih = ImageHandler(ImageMagick, os.path.join(tempDir, 'temp.png'))
print('starting process...')
i = 1
while (1):
currentTime = time.localtime()
print('\nstarting frame at %s...' %
time.strftime("%H:%M:%S", currentTime))
filename = '%s.png' % time.strftime("%H-%M-%S", currentTime)
path = os.path.join(screenshotDir, filename)
wh.screenshot(site, path)
# process the image if desired
if process:
hour = time.strftime("%H", currentTime)
minute = time.strftime("%M", currentTime)
outFile = os.path.join(outputDir, '%04d.png' % i)
ih.processImage(path, outFile, [hour, minute])
i += 1
time.sleep(round(60 * interval))
class Notifications(object):
instance = None
@classmethod
def get_instance(cls):
if not cls.instance:
cls.instance = Notifications()
return cls.instance
def __init__(self):
print("Creating Notifications instance")
self.notification_subscriber = rospy.Subscriber(
NOTIFICATION_TOPIC, String, self.notification_callback)
self.notifications = []
self.notification_cleanup = 0
def cleanup_notifications(self):
if self.notification_cleanup < time.time() - 5:
bak = self.notifications
self.notifications = []
for t, nt in bak:
if t > time.time() - 15:
self.notifications.append((t, nt))
def get_notifications(self, since):
self.cleanup_notifications()
return [y for x, y in self.notifications if x >= since]
def notification_callback(self, msg):
self.log("Notification received: %s" % (repr(msg)))
try:
t = time.time()
now = datetime.datetime.now()
notification = json.loads(msg.data)
notification['received'] = t
self.notifications.append((t, notification))
except ValueError, e:
self.notifications.append((time.time(), {
"message":
"Incorrectly formed notification received: \"%s\"" % msg.data,
"level":
"HIGH",
"timeout":
4000,
"received":
time.time()
}))
self.log("Generating video")
ih = ImageHandler.get_instance()
ih.generate_video()
class Client(tornado.websocket.WebSocketHandler):
def __init__(self, url, timeout):
self.url = url
self.timeout = timeout
self.ioloop = IOLoop.instance()
self.ws = None
self.imgHandler = ImageHandler()
self.connect()
PeriodicCallback(self.keep_alive, 20000).start()
self.ioloop.start()
@gen.coroutine
def connect(self):
print ("trying to connect")
try:
self.ws = yield websocket_connect(self.url)
except Exception:
print(Exception)
else:
print ("connected")
self.run()
@gen.coroutine
def run(self):
while True:
#MARK: improve
msg = yield self.ws.read_message()
if msg is None:
print ("connection closed")
self.ws = None
break
self.imgHandler.handleImageBlob(msg)
def keep_alive(self):
if self.ws is None:
self.connect()
else:
self.ws.write_message("keep alive")
def make_post_info(userId, input, prevPost=None):
postInfo = input.form.copy()
if not Entities.attrNotNull(postInfo, [
'name', 'species', 'gender', 'age', 'vaccination',
'start_date', 'end_date', 'criteria'
]):
return False
if not Entities.attrNotZeroLength(postInfo,
['name', 'species', 'vaccination']):
return False
postInfo['owner_id'] = userId
postInfo['start_date'] = int(
time.mktime(time.strptime(postInfo['start_date'], '%Y-%m-%d')))
postInfo['end_date'] = int(
time.mktime(time.strptime(postInfo['end_date'], '%Y-%m-%d')))
postInfo['post_date'] = int(time.time())
for i in ['image1', 'image2', 'image3'
]: # FIXME: what strategy to be used for uploading pictures
if i in input.files and len(input.files[i].filename) > 0:
postInfo[i] = ImageHandler.save_image(input.files[i])
if prevPost is not None and i in prevPost:
ImageHandler.delete_image(prevPost[i])
return postInfo
def __init__(self):
"""
Sets up program variables, resets files, does not tell arduino to start
"""
GPIO.setmode(GPIO.BCM)
self.ei = ErrorIndicator(False)
self.ih = ImageHandler(False, self.ei)
self.processor = ImageProcessor(self.ih, self.ei)
self.arduino = Arduino(self.ei)
GPIO.setup(24, GPIO.IN, pull_up_down=GPIO.PUD_UP)
GPIO.setup(25, GPIO.IN)
GPIO.setwarnings(False)
if os.path.exists("out/"):
shutil.rmtree("out")
os.makedirs("out")
if os.path.exists("log.txt"):
os.remove("log.txt")
logging.basicConfig(filename='log.txt',
level=logging.DEBUG,
format='%(asctime)s %(message)s',
datefmt='%m/%d/%Y %I:%M:%S %p')
def train(self, model_path):
## cut
saver = tf.train.Saver()
sess = tf.Session()
sess.run(tf.global_variables_initializer())
batch_size = 128
n_epochs = 30
l_loss = list()
for epoch_i in range(n_epochs):
for batch_i in range(0, mnist.train.num_examples, batch_size):
batch_xs, batch_ys = mnist.train.next_batch(batch_size)
sess.run(optimizer, feed_dict = {
net_input: batch_xs,
y_true: batch_ys
})
loss = sess.run(accuracy, feed_dict = {
net_input: mnist.validation.images,
y_true: mnist.validation.labels
})
print('Validation accuracy for epoch {} is: {}'.format(epoch_i + 1, loss))
l_loss.append(loss)
#save model
save_path = saver.save(sess, model_path)
#test predictions
handler = ImageHandler()
images,labels = handler.parse_images()
f = {net_input: images}
predictions = sess.run(net_output, feed_dict = f)
self.print_predictions(predictions)
print("Accuracy for test set: {}".format(sess.run(accuracy,
feed_dict = {
net_input: images,
y_true: labels
})))
def __init__(train_path,
pc_number,
class_threshold=20000,
projection_threshold=20000):
"""
Function that initialises the image handler and the pc handler and sets the classification
thresholds
:param train_path: path to training data
:param pc_number: number of principal components
:param class_threshold: classification scalar
:param projection_threshold: classification scalar
"""
Predictor._image_handler = ImageHandler(train_path)
Predictor._image_handler.load_image_matrix()
Predictor._image_handler.load_avg_image()
Predictor._image_handler.load_c_image_matrix()
Predictor._pc_handler = PCHandler(pc_number)
Predictor._pc_handler.load_pc_matrix(
Predictor._image_handler.get_c_image_matrix())
Predictor._class_threshold = class_threshold
Predictor._projection_threshold = projection_threshold
class VideoHandler():
def __init__(self, *args, **kwargs):
self.clip_name = args[0].input_video
self.subclip_length = args[0].subclip_length
self.out_clip = None
self.out_clip_name = args[0].output_video
# self.video_clip = VideoFileClip(self.clip_name).subclip(0, self.subclip_length)
# self.video_clip = VideoFileClip(self.clip_name).subclip(20, 25)
# self.video_clip = VideoFileClip(self.clip_name).subclip(38, 40)
self.video_clip = VideoFileClip(self.clip_name)
self.frame_counter = 0
self.image_handler = ImageHandler()
def process_video(self):
self.out_clip = self.video_clip.fl_image(self.process_image) #NOTE: this function expects color images!!
self.out_clip.write_videofile(self.out_clip_name, audio=False)
def process_image(self, img):
self.frame_counter += 1
out_img = self.image_handler.process_image(img)
# print("Processing frame: {} of shape {}".format(self.frame_counter, img.shape))
return out_img
class SimpleCalculatorTests(unittest.TestCase):
def setUp(self):
# set up appium
desired_caps = {}
desired_caps[
"app"] = "jp.co.sharp.ebook.ebookapp_h35559jr9hy9m!jp.co.sharp.ebook.ebookapp"
desired_caps["deviceName"] = "WindowsPC"
desired_caps["platformName"] = "Windows"
# desired_caps["app"] = "Microsoft.WindowsCalculator_8wekyb3d8bbwe"
self.driver = webdriver.Remote(
command_executor='http://127.0.0.1:4723/wd/hub',
desired_capabilities=desired_caps)
self.imageHandler = ImageHandler()
self.mouseHandler = MouseHandler()
def tearDown(self):
for window in self.driver.window_handles:
self.driver.switch_to.window(window)
self.driver.close()
def test_initialize(self):
time.sleep(3)
x, y = self.imageHandler.get_image_location(
'../../images/book3title.PNG')
self.mouseHandler.click_at_coordinate(x, y - 80)
time.sleep(3)
self.switch_window()
self.driver.find_element_by_accessibility_id('button-bookmark').click()
time.sleep(5)
def switch_window(self):
current = self.driver.current_window_handle
for window in self.driver.window_handles:
if window != current:
self.driver.switch_to.window(window)
class ImageqHandlerTest(unittest.TestCase):
@classmethod
def setUpClass(self):
self.block_thresholds = {
1: (0, 0, 77, 78),
2: (77, 0, 154, 78),
3: (154, 0, 231, 78),
4: (231, 0, 308, 78),
5: (308, 0, 385, 78),
6: (385, 0, 462, 78),
7: (462, 0, 539, 78),
8: (539, 0, 616, 78),
9: (0, 78, 77, 156),
10: (77, 78, 154, 156),
11: (154, 78, 231, 156),
12: (231, 78, 308, 156),
13: (308, 78, 385, 156),
14: (385, 78, 462, 156),
15: (462, 78, 539, 156),
16: (539, 78, 616, 156),
17: (0, 156, 77, 234),
18: (77, 156, 154, 234),
19: (154, 156, 231, 234),
20: (231, 156, 308, 234),
21: (308, 156, 385, 234),
22: (385, 156, 462, 234),
23: (462, 156, 539, 234),
24: (539, 156, 616, 234),
25: (0, 234, 77, 312),
26: (77, 234, 154, 312),
27: (154, 234, 231, 312),
28: (231, 234, 308, 312),
29: (308, 234, 385, 312),
30: (385, 234, 462, 312),
31: (462, 234, 539, 312),
32: (539, 234, 616, 312),
33: (0, 312, 77, 390),
34: (77, 312, 154, 390),
35: (154, 312, 231, 390),
36: (231, 312, 308, 390),
37: (308, 312, 385, 390),
38: (385, 312, 462, 390),
39: (462, 312, 539, 390),
40: (539, 312, 616, 390),
41: (0, 390, 77, 468),
42: (77, 390, 154, 468),
43: (154, 390, 231, 468),
44: (231, 390, 308, 468),
45: (308, 390, 385, 468),
46: (385, 390, 462, 468),
47: (462, 390, 539, 468),
48: (539, 390, 616, 468),
49: (0, 468, 77, 546),
50: (77, 468, 154, 546),
51: (154, 468, 231, 546),
52: (231, 468, 308, 546),
53: (308, 468, 385, 546),
54: (385, 468, 462, 546),
55: (462, 468, 539, 546),
56: (539, 468, 616, 546),
57: (0, 546, 77, 624),
58: (77, 546, 154, 624),
59: (154, 546, 231, 624),
60: (231, 546, 308, 624),
61: (308, 546, 385, 624),
62: (385, 546, 462, 624),
63: (462, 546, 539, 624),
64: (539, 546, 616, 624)
}
self.block_id_threshold_Dictionary = {
'f8': (385, 0, 462, 78),
'g5': (462, 234, 539, 312),
'c3': (154, 390, 231, 468),
'f7': (385, 78, 462, 156),
'c5': (154, 234, 231, 312),
'e3': (308, 390, 385, 468),
'f4': (385, 312, 462, 390),
'a3': (0, 390, 77, 468),
'h4': (539, 312, 616, 390),
'a7': (0, 78, 77, 156),
'h7': (539, 78, 616, 156),
'e2': (308, 468, 385, 546),
'c1': (154, 546, 231, 624),
'b2': (77, 468, 154, 546),
'a4': (0, 312, 77, 390),
'h2': (539, 468, 616, 546),
'a2': (0, 468, 77, 546),
'd2': (231, 468, 308, 546),
'd1': (231, 546, 308, 624),
'b6': (77, 156, 154, 234),
'a1': (0, 546, 77, 624),
'd3': (231, 390, 308, 468),
'f3': (385, 390, 462, 468),
'g7': (462, 78, 539, 156),
'f6': (385, 156, 462, 234),
'h6': (539, 156, 616, 234),
'b4': (77, 312, 154, 390),
'f2': (385, 468, 462, 546),
'h1': (539, 546, 616, 624),
'a8': (0, 0, 77, 78),
'd8': (231, 0, 308, 78),
'd7': (231, 78, 308, 156),
'g2': (462, 468, 539, 546),
'h5': (539, 234, 616, 312),
'd4': (231, 312, 308, 390),
'b1': (77, 546, 154, 624),
'a5': (0, 234, 77, 312),
'f1': (385, 546, 462, 624),
'h8': (539, 0, 616, 78),
'e1': (308, 546, 385, 624),
'e5': (308, 234, 385, 312),
'b3': (77, 390, 154, 468),
'b5': (77, 234, 154, 312),
'c2': (154, 468, 231, 546),
'd6': (231, 156, 308, 234),
'c6': (154, 156, 231, 234),
'e4': (308, 312, 385, 390),
'c7': (154, 78, 231, 156),
'g4': (462, 312, 539, 390),
'c4': (154, 312, 231, 390),
'g3': (462, 390, 539, 468),
'b7': (77, 78, 154, 156),
'g1': (462, 546, 539, 624),
'd5': (231, 234, 308, 312),
'e6': (308, 156, 385, 234),
'f5': (385, 234, 462, 312),
'c8': (154, 0, 231, 78),
'g6': (462, 156, 539, 234),
'g8': (462, 0, 539, 78),
'e7': (308, 78, 385, 156),
'e8': (308, 0, 385, 78),
'h3': (539, 390, 616, 468),
'a6': (0, 156, 77, 234),
'b8': (77, 0, 154, 78)
}
self.image_handler = ImageHandler()
self.image_handler.load_captured_image()
self.image_handler.set_thresholds()
@classmethod
def tearDownClass(cls):
os.remove(os.getcwd() + "\Resources\CapturedImage\cropped_board.png")
def test_load_captured_image(self):
self.assertNotEqual(len(self.image_handler.captured_image), 0)
def test_set_thresholds(self):
self.assertEqual(len(self.image_handler.crop_thresholds), 2)
def test_crop_and_save(self):
self.image_handler.crop_and_save()
self.assertTrue(
os.path.exists(os.getcwd() +
"\Resources\CapturedImage\cropped_board.png"))
def test_slice_image(self):
self.image_handler.slice_image()
self.assertEqual(len(self.image_handler.block_thresholds), 64)
def test_create_block_id_threshold_dictionary(self):
self.image_handler.block_thresholds = self.block_thresholds
self.image_handler.create_block_id_threshold_dictionary()
self.assertEqual(len(self.image_handler.block_id_threshold_dictionary),
64)
def test_iterate_blocks(self):
self.image_handler.block_id_threshold_dictionary = self.block_id_threshold_Dictionary
self.assertTrue(type(self.image_handler.iterate_blocks()) is dict)
def test_ml_iterate_blocks(self):
os.chdir(os.getcwd() + '\..\\') # change directory to load graph
load_model()
self.image_handler.block_id_threshold_dictionary = self.block_id_threshold_Dictionary
os.chdir(os.getcwd() + '\Tests\\') # change directory back to Tests
output = self.image_handler.ml_iterate_blocks()
self.assertTrue(type(output) is dict)
self.assertNotEqual(len(output), 0)
self.assertNotEqual(
len(self.image_handler.get_second_square_value_dict()), 0)
def setUpClass(self):
self.block_thresholds = {
1: (0, 0, 77, 78),
2: (77, 0, 154, 78),
3: (154, 0, 231, 78),
4: (231, 0, 308, 78),
5: (308, 0, 385, 78),
6: (385, 0, 462, 78),
7: (462, 0, 539, 78),
8: (539, 0, 616, 78),
9: (0, 78, 77, 156),
10: (77, 78, 154, 156),
11: (154, 78, 231, 156),
12: (231, 78, 308, 156),
13: (308, 78, 385, 156),
14: (385, 78, 462, 156),
15: (462, 78, 539, 156),
16: (539, 78, 616, 156),
17: (0, 156, 77, 234),
18: (77, 156, 154, 234),
19: (154, 156, 231, 234),
20: (231, 156, 308, 234),
21: (308, 156, 385, 234),
22: (385, 156, 462, 234),
23: (462, 156, 539, 234),
24: (539, 156, 616, 234),
25: (0, 234, 77, 312),
26: (77, 234, 154, 312),
27: (154, 234, 231, 312),
28: (231, 234, 308, 312),
29: (308, 234, 385, 312),
30: (385, 234, 462, 312),
31: (462, 234, 539, 312),
32: (539, 234, 616, 312),
33: (0, 312, 77, 390),
34: (77, 312, 154, 390),
35: (154, 312, 231, 390),
36: (231, 312, 308, 390),
37: (308, 312, 385, 390),
38: (385, 312, 462, 390),
39: (462, 312, 539, 390),
40: (539, 312, 616, 390),
41: (0, 390, 77, 468),
42: (77, 390, 154, 468),
43: (154, 390, 231, 468),
44: (231, 390, 308, 468),
45: (308, 390, 385, 468),
46: (385, 390, 462, 468),
47: (462, 390, 539, 468),
48: (539, 390, 616, 468),
49: (0, 468, 77, 546),
50: (77, 468, 154, 546),
51: (154, 468, 231, 546),
52: (231, 468, 308, 546),
53: (308, 468, 385, 546),
54: (385, 468, 462, 546),
55: (462, 468, 539, 546),
56: (539, 468, 616, 546),
57: (0, 546, 77, 624),
58: (77, 546, 154, 624),
59: (154, 546, 231, 624),
60: (231, 546, 308, 624),
61: (308, 546, 385, 624),
62: (385, 546, 462, 624),
63: (462, 546, 539, 624),
64: (539, 546, 616, 624)
}
self.block_id_threshold_Dictionary = {
'f8': (385, 0, 462, 78),
'g5': (462, 234, 539, 312),
'c3': (154, 390, 231, 468),
'f7': (385, 78, 462, 156),
'c5': (154, 234, 231, 312),
'e3': (308, 390, 385, 468),
'f4': (385, 312, 462, 390),
'a3': (0, 390, 77, 468),
'h4': (539, 312, 616, 390),
'a7': (0, 78, 77, 156),
'h7': (539, 78, 616, 156),
'e2': (308, 468, 385, 546),
'c1': (154, 546, 231, 624),
'b2': (77, 468, 154, 546),
'a4': (0, 312, 77, 390),
'h2': (539, 468, 616, 546),
'a2': (0, 468, 77, 546),
'd2': (231, 468, 308, 546),
'd1': (231, 546, 308, 624),
'b6': (77, 156, 154, 234),
'a1': (0, 546, 77, 624),
'd3': (231, 390, 308, 468),
'f3': (385, 390, 462, 468),
'g7': (462, 78, 539, 156),
'f6': (385, 156, 462, 234),
'h6': (539, 156, 616, 234),
'b4': (77, 312, 154, 390),
'f2': (385, 468, 462, 546),
'h1': (539, 546, 616, 624),
'a8': (0, 0, 77, 78),
'd8': (231, 0, 308, 78),
'd7': (231, 78, 308, 156),
'g2': (462, 468, 539, 546),
'h5': (539, 234, 616, 312),
'd4': (231, 312, 308, 390),
'b1': (77, 546, 154, 624),
'a5': (0, 234, 77, 312),
'f1': (385, 546, 462, 624),
'h8': (539, 0, 616, 78),
'e1': (308, 546, 385, 624),
'e5': (308, 234, 385, 312),
'b3': (77, 390, 154, 468),
'b5': (77, 234, 154, 312),
'c2': (154, 468, 231, 546),
'd6': (231, 156, 308, 234),
'c6': (154, 156, 231, 234),
'e4': (308, 312, 385, 390),
'c7': (154, 78, 231, 156),
'g4': (462, 312, 539, 390),
'c4': (154, 312, 231, 390),
'g3': (462, 390, 539, 468),
'b7': (77, 78, 154, 156),
'g1': (462, 546, 539, 624),
'd5': (231, 234, 308, 312),
'e6': (308, 156, 385, 234),
'f5': (385, 234, 462, 312),
'c8': (154, 0, 231, 78),
'g6': (462, 156, 539, 234),
'g8': (462, 0, 539, 78),
'e7': (308, 78, 385, 156),
'e8': (308, 0, 385, 78),
'h3': (539, 390, 616, 468),
'a6': (0, 156, 77, 234),
'b8': (77, 0, 154, 78)
}
self.image_handler = ImageHandler()
self.image_handler.load_captured_image()
self.image_handler.set_thresholds()
for i in range(imgAr.shape[0]):
newImg[i, :, :64, :] = imgAr[i, :, :, :]
newImg[i, :, 64:2 * 64, 0] = imgAr[i, :, :, 0]
newImg[i, :, 2 * 64:3 * 64, 1] = imgAr[i, :, :, 1]
newImg[i, :, 3 * 64:4 * 64, 2] = imgAr[i, :, :, 2]
return newImg
if __name__ == '__main__':
print("python msrnet.py mod.h5 None|relu|sigmoid aa.npz")
MODEL_FILE_NAME = sys.argv[1]
actFunc = sys.argv[2]
npzSaveFile = sys.argv[3]
img_hndlr = ImageHandler((64, 64))
path = "dataset"
if not (os.path.exists(path + "/dark/")
and os.path.exists(path + "/true/")):
img_hndlr.create_dataset(path)
X = img_hndlr.load_images(path + "/dark/")
Y = img_hndlr.load_images(path + "/true/")
X = img_hndlr.preprocess_images(X)
Y = img_hndlr.preprocess_images(Y)
print("XY shapes", X.shape, Y.shape)
print("python msrnet.py")
if FH_ENABLE:
FH = []
FHNRT = []
DH = utils.DirsHandler(DIRS)
FH.append(
FilesHandlerRT(DH.all_dirs['diff_detection'],
run_compression=['_main', '_debug', 'mov'],
run_NN=['_mov'],
delete_org=['_main', '_debug', 'mov']).start())
FH.append(
FilesHandlerRT(DH.all_dirs['no_diff_detection'],
run_compression=['_main'],
delete_org=['_main', '_debug']).start())
FHNRT.append(
FilesHandlerNonRT(
dir_key='diff_detection',
max_history=FILES['max_history_detected']).start())
FHNRT.append(
FilesHandlerNonRT(
dir_key='no_diff_detection',
max_history=FILES['max_history_not_detected']).start())
IH = ImageHandler(debug=True).start()
if SHOW_STREAM:
IS = ImageShow(IH, debug=True).start()
TLGA = TelegramAlerts()
LOGGER.info('AMIR IPCAM VERSION {} IS READY'.format(VERSION))
while True:
time.sleep(10000)
def calculateMassCenterAndMotionVector(self, greyBitmapWithDirectionInfo, box):
image = ImageHandler().createEmptyGreyScaleBitmap(greyBitmapWithDirectionInfo.size)
image.paste(greyBitmapWithDirectionInfo.crop(box), box)
first = self._calculateMassCenter(image, 1)
second = self._calculateMassCenter(image, 2)
return first, second
def __init__(self):
self.tableFinder = PoolTableFinder()
self.imageComparator = ImageComparator()
self.imageHandler = ImageHandler()
input_values = []
image_path = self.read_image_path()
if (file_manager.validate_type_of_image(image_path) == True):
new_format = self.read_format_to_export_an_image()
if (new_format != "Incorrect format"):
input_values = [image_path, new_format]
return input_values
else:
return input_values
else:
return input_values
main = PymageMain()
image_handler = ImageHandler()
#result = main.read_all_values_to_rotate()
#if (len(result) != 0):
# print result
# image = image_handler.rotate_image(result)
# main.save_image_file(image, result[2])
#else:
# print "False"
input_values = main.read_all_values_to_export_an_image_file_to_another_format()
if (len (input_values) != 0):
# print input_values
image_handler.export_an_image_file_to_another_format(input_values)
else:
