def getReal(
image_HW,
_class_label_map,
normalize_single_ims,
std_d,
USING_STD_DIR
):
real, HW = image_HW
if GRAY_SCALE:
real.data = Image.open(real.file.abspath)
else:
real.data = np.resize(
arr(Image.open(real.file.abspath).getdata()),
(20, 20, 3)
)
if normalize_single_ims and not USING_STD_DIR:
# noinspection PyUnusedLocal
def smallify():
err('dev')
files = glob.glob(sys.argv[1] + "/**/*.png", recursive=True)
i = 0
log('found ' + str(len(files)) + ' images')
with Progress(len(files)) as prog:
for f in files:
p = shell(['convert', f, '-resize', '20x20', f], silent=True)
p.interact()
i = i + 1
prog.tick()
log('resized ' + str(i) + ' images')
sys.exit()
assert len(real.data.getdata()) == 20 * 20, 'dev: smallify if files are large but blocky'
real.data = np.reshape(
arr(
real.data.getdata()
),
(20, 20)
)
real.data = real.data / np.std(real.data)
if SAVE_PREPROC_DATA:
std_file = File(std_d).resolve(File(real.file).parentName).resolve(File(real.file).name)
std_file.save(real.data, silent=True)
real.data = make1(real.data)
if normalize_single_ims:
if GRAY_SCALE:
real.data = real.data - np.mean(real.data)
else:
for chan in range(3):
real.data[:, :, chan] = real.data[:, :, chan] - np.mean(real.data[:, :, chan])
real.data = resampleim(real.data, HW, HW)
if GRAY_SCALE:
shape1 = real.data.shape[0]
shape2 = real.data.shape[1]
real.data = np.broadcast_to(real.data, (shape1, shape2, 3))
real.label = _class_label_map[real.clazz]
return real
def gen_images(*, folder, class_pairs, ims_per_class):
N_IMAGES = ims_per_class * 2 * len(class_pairs)
classes = get_class_dict(class_pairs)
File(folder).deleteAllContents()
BLOCK_HEIGHT_WIDTH = 20
y = []
band_group_size = N_IMAGES / len(class_pairs)
band_group = 0
band_group_i = 0
with Progress(N_IMAGES) as prog:
for i in range(N_IMAGES):
im_data = np.random.rand(BLOCK_HEIGHT_WIDTH, BLOCK_HEIGHT_WIDTH)
if BLACK_AND_WHITE:
im_data = np.vectorize(round)(im_data)
band = class_pairs[band_group]
ns_classname, s_classname = band.get_classnames()
darken = band.dark
if darken:
im_data = im_data / 2
band = band.bandsize
bar_start = int((BLOCK_HEIGHT_WIDTH / 2) - (band / 2))
bar_end = bar_start + band
for w in range(bar_start, bar_end):
im_data[:, w] = 0.5
im_data = make255(im_data)
if iseven(i):
im_data = nn_lib.symm(im_data, 1)
y.append(classes[s_classname])
label = s_classname
else:
y.append(classes[ns_classname])
label = ns_classname
im_data = np.expand_dims(im_data, 2)
# i think Darius' data was single channeled
# im_data = np.concatenate((im_data, im_data, im_data), axis=2)
# im_file = File(f'{File(folder).abspath}/{label}/sym{i}.png')
im_file = File(f'{File(folder).abspath}/{label}/{label}_{band_group_i}.png')
band_group_i = band_group_i + 1
if band_group_i == band_group_size:
band_group = band_group + 1
band_group_i = 0
im_file.save(im_data, silent=True)
prog.tick()
return classes
class PermaList(DefaultMutableList):
def __init__(self, file):
from mlib.file import File
self.file = File(file)
self.file.allow_autoload = True
super().__init__(self.file)
if not self.file.exists:
self.file.save([])
self.file.default_quiet = True
def __getitem__(self, val):
return self._l[val]
def __setitem__(self, key, value):
self._l[key] = value
def __delitem__(self, key): del self.file[key]
def basic_cache_logic(f,
pklfile: File,
*args,
log_level=LogLevel.PROGRESS,
**kwargs):
if pklfile.exists:
log_level.handle(f"loading {f.__name__} result from cache")
return pklfile.load(silent=True), True
else:
key = log_level.handle(
f"no cached result for {f.__name__}, running ...",
attempt_one_line=True)
r = f(*args, **kwargs)
pklfile.save(r, silent=True)
log_level.handle(f"completed and cached", one_line_key=key)
return r, False
def file_cache_logic(f,
namefile: File,
myfolder: Optional[File],
*args,
log_level=LogLevel.PROGRESS,
**kwargs):
key = log_level.handle(f"no cached file for {f.__name__}, running ...",
attempt_one_line=True)
r = f(*args, **kwargs)
assert isinstsafe(
r, File
), f'filecache functions must return a single File, but this is a {type(r)}'
r = r.copy_into(myfolder, next_new=True)
namefile.save(r.name, silent=True)
log_level.handle(f"completed and filecached", one_line_key=key)
return r
class PermaDict(DefaultMutableMapping):
def __init__(self, file):
from mlib.file import File
self.file = File(file)
self.file.allow_autoload = True
super().__init__(self.file)
if not self.file.exists:
self.file.save({})
self.file.default_quiet = True
def check(self):
from mlib.proj.struct import GIT_DIR, GIT_IGNORE
if not self.file.rel.startswith('_') and self.file.parent.name != 'data':
err('PermaDicts should be private (start with _)')
if GIT_DIR.exists and (not GIT_IGNORE.exists or '/_*' not in GIT_IGNORE.read()):
err(f'{self.file} needs to be ignored')
if not self.file.exists:
self.file.save({})
def __getitem__(self, val):
self.check()
return self._d[val]
def __setitem__(self, key, value):
self.check()
self._d[key] = value
def __delitem__(self, key): del self.file[key]
class HelloWindow(QMainWindow):
# https://stackoverflow.com/questions/43126721/detect-resizing-in-widget-window-resized-signal
resized = QtCore.pyqtSignal()
def resizeEvent(self, event):
self.resized.emit()
return super(HelloWindow, self).resizeEvent(event)
moved = QtCore.pyqtSignal(str)
def fakeMoveEventGenerator(self):
while True:
sleep(5)
self.moved.emit('dummy')
def __init__(self,
title,
label,
fullscreen=True,
always_on_top=False,
always_on_bottom=False,
no_title_bar=False,
pathWrap=False,
readOnly=True,
bind_file=None):
# QMainWindow.__init__(self)
# super().__init__(flags, *args, **kwargs)
flags = []
args = ()
kwargs = {}
flags = 0
flags = None
if no_title_bar:
if flags is None:
flags = QtCore.Qt.CustomizeWindowHint
else:
flags = flags | QtCore.Qt.CustomizeWindowHint
# pass
if always_on_top:
if flags is None:
flags = QtCore.Qt.WindowStaysOnTopHint
else:
flags = flags | QtCore.Qt.WindowStaysOnTopHint
# flags = flags + QtCore.Qt.WindowStaysOnTopHint
# pass
# super().__init__(None, QtCore.Qt.WindowStaysOnTopHint)
# super(w).__init__(None, QtCore.Qt.X11BypassWindowManagerHint)
# else:
if always_on_bottom:
if flags is None:
flags = QtCore.Qt.WindowStaysOnBottomHint
else:
flags = flags | QtCore.Qt.WindowStaysOnBottomHint
if flags is not None:
super().__init__(None, flags)
else:
super().__init__(None)
# self.setWindowFlags(QtCore.Qt.WindowFlags(QtCore.Qt.CustomizeWindowHint,QtCore.Qt.WindowStaysOnTopHint))
# super().__init__(None, QtCore.Qt.WindowStaysOnTopHint)
# self.setMinimumSize(QSize(640, 480))
# set stylesheet
# CAUSED BUTTONS TO NOT WORK
# file = QFile("/Users/matt/Desktop/BreezeStyleSheets/dark.qss")
# file = QFile(":/dark.qss")
# file.open(QFile.ReadOnly | QFile.Text)
# stream = QTextStream(file)
# CAUSED BUTTONS TO NOT WORK
# self.setStyleSheet(stream.readAll())
self.setWindowTitle(title)
self._init_cw()
if label is not None:
if not readOnly:
pathWrap = True
if pathWrap:
self.label = self.textPathWrap(label, readOnly)
else:
self.label = self.text(label)
else:
self.label = None
if bind_file is None:
w, h = screen_sizes()
self.setFixedSize(w, h)
if fullscreen:
self.showFullScreen()
else:
self.setFixedSize(w, h - 45)
else:
self.stage_file = File(bind_file, quiet=True)
if self.stage_file.exists:
self.load_geometry()
else:
w, h = screen_sizes()
# self.setFixedSize(w, h)
if fullscreen:
self.showFullScreen()
else:
self.setFixedSize(w, h - 45)
self.bindGeometry()
def saveWinGeometry(self):
self.stage_file.save({
"x": self.frameGeometry().x(),
"y": self.frameGeometry().y(),
"width": self.frameGeometry().width(),
"height": self.frameGeometry().height()
})
def bindGeometry(self):
self.resized.connect(self.saveWinGeometry)
self.moved.connect(self.saveWinGeometry)
Thread(target=self.fakeMoveEventGenerator, daemon=True).start()
def load_geometry(self):
geo = self.stage_file.load()
self.move(geo['x'], geo['y'])
self.setFixedSize(geo['width'], geo['height'])
def _init_cw(self):
centralWidget = MQWidget(self)
self.setCentralWidget(centralWidget)
self.cw = centralWidget
self.gridLayout = centralWidget.gridLayout
def clear(self):
try_delete(self.cw, self)
self._init_cw()
def text(self, txt="", data=None, click_handler=None):
return self.cw.text(txt, data, click_handler)
def textPathWrap(self, txt="", readOnly=True):
return self.cw.textPathWrap(txt, readOnly)
def button(self, text, fun):
return self.cw.button(text, fun)
def input(self, initial="") -> QLineEdit:
return self.cw.input(initial)
def pane(self, returnBox=False, vertical=True):
return self.cw.pane(returnBox, vertical=vertical)
def screen(self):
return QtWidgets.QApplication.screenAt(QPoint(self.x(), self.y()))
def current_screen_sizes(self):
screen_height = self.screen().availableGeometry().height()
screen_width = self.screen().availableGeometry().width()
half_width = screen_width / 2
half_height = screen_height / 2
return screen_height, screen_width, half_width, half_height
def move_left(self):
screen_height, screen_width, half_width, half_height = self.current_screen_sizes(
)
self.move(0, 0)
self.setFixedSize(half_width, screen_height)
def move_right(self):
screen_height, screen_width, half_width, half_height = self.current_screen_sizes(
)
self.move(half_width, 0)
self.setFixedSize(half_width, screen_height)
def move_down(self):
screen_height, screen_width, half_width, half_height = self.current_screen_sizes(
)
self.move(0, half_height)
self.setFixedSize(screen_width, half_height)
def move_up(self):
screen_height, screen_width, half_width, half_height = self.current_screen_sizes(
)
self.move(0, 0)
self.setFixedSize(screen_width, half_height)
def maximize(self):
screen_height, screen_width, half_width, half_height = self.current_screen_sizes(
)
self.move(0, 0)
self.setFixedSize(screen_width, screen_height)
