def hook_tkinter(finder, module):
"""Recusively copy tcl and tk directories"""
from tkinter import Tcl
from _tkinter import TK_VERSION
tcl_dir = os.path.normpath(Tcl().eval("info library"))
assert os.path.isdir(tcl_dir)
finder.add_datadirectory("lib/tcl", tcl_dir, recursive=True)
tk_dir = os.path.join(os.path.dirname(tcl_dir), 'tk{}'.format(TK_VERSION))
assert os.path.isdir(tk_dir)
finder.add_datadirectory("lib/tk", tk_dir, recursive=True)
if sys.version_info >= (3, 6, 0):
finder.import_hook("imp")
# add environment variables that point to the copied paths at runtime
finder.add_bootcode("""
def tk_env_paths():
import os
import sys
import _tkinter
basepath = os.path.dirname(sys.executable)
tcl_dir = os.path.join(basepath, 'lib', 'tcl')
tk_dir = os.path.join(basepath, 'lib', 'tk')
os.environ["TCL_LIBRARY"] = tcl_dir
os.environ["TK_LIBRARY"] = tk_dir
tk_env_paths()
del tk_env_paths
""")
def tcl_interp():
"""
create a new Tcl interpreter with the standard packages loaded
TESTS::
sage: from yacop.utils.tcl import tcl_interp, tcl_eval
sage: tcl = tcl_interp()
sage: tcl.eval("package present sqlite3") # random
3.8.2
"""
tcl = Tcl()
xdirs = Yacop.tcllibrary
if not xdirs is None:
if not isinstance(xdirs, list):
xdirs = [xdirs]
[tcl.eval("lappend auto_path {%s}" % path) for path in xdirs]
tcl.eval(
"""
lappend auto_path $::env(SAGE_LOCAL)/tcl/lib
lappend auto_path $::env(SAGE_LOCAL)/lib
package require yacop::sage 1.0
"""
)
return tcl
def __init__(self, sim_dir, fn_root, **kwargs):
rms = kwargs.get('rms', False)
down = kwargs.get('downsample', 1)
self.sim_dir = sim_dir
datp_dir = os.path.join(sim_dir, 'datp')
rotation = kwargs.get('rotation', 0)
self.rot = rotation / 180 * np.pi
self.length_scale = kwargs.get('length_scale', 96)
# Find what you're looking for
fns = [fn for fn in os.listdir(datp_dir) if fn.startswith(fn_root) and fn.endswith('.pvti')]
# Sort files
fns = Tcl().call('lsort', '-dict', fns)
if len(fns) > 1:
print("More than one fn with this name. Taking time average.")
# Store snapshots of field
self.snaps = []
for fn in fns[::down]:
snap = vti_to_mesh(os.path.join(datp_dir, fn), self.length_scale)
self.snaps.append(snap)
del snap
# Time average the flow field snaps
mean_t = np.mean(np.array(self.snaps).T, axis=1)
self.X, self.Y = mean_t[0:2]
self.u, self.v, self.w = mean_t[2:-1]
self.U, self.V = np.mean(self.u, axis=2), np.mean(self.v, axis=2)
self.p = np.mean(mean_t[-1], axis=0)
del mean_t
else:
# assert (len(fns) > 0), 'You dont have '+fn_root+'.pvtr in your datp folder'
self.X, self.Y, self.U, self.V, self.W, self.p = vti_to_mesh(os.path.join(datp_dir, fns[0]),
self.length_scale)
self.U, self.V = np.squeeze(self.U), np.squeeze(self.V)
self.p = np.squeeze(self.p)
def __init__(self, path, img_size=640):
p = str(Path(path)) # os-agnostic
p = os.path.abspath(p) # absolute path
if '*' in p:
files = sorted(glob.glob(p, recursive=True)) # glob
elif os.path.isdir(p):
files = Tcl().call('lsort', '-dict',
glob.glob(os.path.join(p, '*.*')))
elif os.path.isfile(p):
files = [p] # files
else:
raise Exception('ERROR: %s does not exist' % p)
images = [x for x in files if x.split('.')[-1].lower() in img_formats]
videos = [x for x in files if x.split('.')[-1].lower() in vid_formats]
ni, nv = len(images), len(videos)
self.img_size = img_size
self.files = images + videos
self.nf = ni + nv # number of files
self.video_flag = [False] * ni + [True] * nv
self.mode = 'images'
if any(videos):
self.new_video(videos[0]) # new video
else:
self.cap = None
assert self.nf > 0, 'No images or videos found in %s. Supported formats are:\nimages: %s\nvideos: %s' % \
(p, img_formats, vid_formats)
def hook_tkinter(finder, module):
"""Recusively copy tcl and tk directories"""
from tkinter import Tcl
from _tkinter import TK_VERSION
tcl_dir = os.path.normpath(Tcl().eval("info library"))
assert os.path.isdir(tcl_dir)
finder.add_datadirectory("lib/tcl", tcl_dir, recursive=True)
tk_dir = os.path.join(os.path.dirname(tcl_dir), 'tk{}'.format(TK_VERSION))
assert os.path.isdir(tk_dir)
finder.add_datadirectory("lib/tk", tk_dir, recursive=True)
finder.set_min_bundle("tkinter", 2)
if sys.version_info >= (3, 6, 0):
finder.import_hook("imp")
# import DLLs
tk_ver = TK_VERSION.replace('.', '')
import glob
for dll_search in ["tcl" + tk_ver + "*.dll", "tk" + tk_ver + "*.dll"]:
for dll_path in glob.glob(
os.path.join(sys.base_prefix, "DLLs", dll_search)):
dll_name = os.path.basename(dll_path)
finder.add_dll(dll_path)
# add environment variables that point to the copied paths at runtime
finder.add_bootcode("""
def tk_env_paths():
import os
tcl_dir = os.path.join(os.getcwd(), 'lib', 'tcl')
tk_dir = os.path.join(os.getcwd(), 'lib', 'tk')
os.environ["TCL_LIBRARY"] = tcl_dir
os.environ["TK_LIBRARY"] = tk_dir
tk_env_paths()
del tk_env_paths
""")
def get_nlast_images(nb_images):
imgs_list_full_dir = f"{ROOT_DIR}/_tmp/full/"
os.chdir(imgs_list_full_dir)
images_taken = glob.glob('*.JPG')
images_taken.extend(glob.glob('*.jpeg'))
images_taken.extend(glob.glob('*.jpg'))
images_taken_sorted = Tcl().call('lsort', '-dict', images_taken)
return images_taken_sorted if nb_images == -1 else images_taken_sorted[-nb_images:]
def testLoadTk(self):
import os
if 'DISPLAY' not in os.environ:
# skipping test of clean upgradeability
return
tcl = Tcl()
self.assertRaises(TclError, tcl.winfo_geometry)
tcl.loadtk()
self.assertEqual('1x1+0+0', tcl.winfo_geometry())
tcl.destroy()
def get_tk_patchlevel():
global _tk_patchlevel
if _tk_patchlevel is None:
tcl = Tcl()
patchlevel = []
for x in tcl.call('info', 'patchlevel').split('.'):
try:
x = int(x, 10)
except ValueError:
x = -1
patchlevel.append(x)
_tk_patchlevel = tuple(patchlevel)
return _tk_patchlevel
def get_tk_patchlevel():
global _tk_patchlevel
if _tk_patchlevel is None:
tcl = Tcl()
patchlevel = tcl.call('info', 'patchlevel')
m = re.fullmatch(r'(\d+)\.(\d+)([ab.])(\d+)', patchlevel)
major, minor, releaselevel, serial = m.groups()
major, minor, serial = int(major), int(minor), int(serial)
releaselevel = {'a': 'alpha', 'b': 'beta', '.': 'final'}[releaselevel]
if releaselevel == 'final':
_tk_patchlevel = major, minor, serial, releaselevel, 0
else:
_tk_patchlevel = major, minor, 0, releaselevel, serial
return _tk_patchlevel
def testLoadTkFailure(self):
old_display = None
if sys.platform.startswith(('win', 'darwin', 'cygwin')):
return
with test_support.EnvironmentVarGuard() as env:
if 'DISPLAY' in os.environ:
del env['DISPLAY']
with os.popen('echo $DISPLAY') as pipe:
display = pipe.read().strip()
if display:
return
tcl = Tcl()
self.assertRaises(TclError, tcl.winfo_geometry)
self.assertRaises(TclError, tcl.loadtk)
def cards():
path = f"{ROOT_DIR}/_tmp/cards"
os.chdir(path)
images_taken = glob.glob('*.JPG')
images_taken.extend(glob.glob('*.jpeg'))
images_taken.extend(glob.glob('*.jpg'))
images_taken_sorted = Tcl().call('lsort', '-dict', images_taken)
images_taken_sorted = list(reversed(images_taken_sorted))
return render_template('cards.html',
images_list=images_taken_sorted,
classes=generate_grid_classes(
len(images_taken_sorted)))
def animate(self, folder, **kwargs):
for idx, snap in enumerate(self.snaps):
dat = np.array(snap).T
plot_2D_fp_isocontours(dat, 'mag', folder + str(idx) + '.png',
**kwargs)
# Sort filenames to make sure they're in order
fn_images = os.listdir(folder)
fn_images = Tcl().call('lsort', '-dict', fn_images)
images = []
for filename in fn_images:
images.append(imageio.imread(os.path.join(folder, filename)))
imageio.mimsave(folder + '/flow.gif',
images,
duration=0.2,
bitrate=1000)
def __init__(self, sim_dir, fn_root, **kwargs):
rms = kwargs.get('rms', False)
down = kwargs.get('downsample', 1)
self.sim_dir = sim_dir
datp_dir = os.path.join(sim_dir, 'datp')
rotation = kwargs.get('rotation', 0)
self.rot = 0
self.length_scale = kwargs.get('length_scale', 96)
# Find what you're looking for
fns = [
fn for fn in os.listdir(datp_dir)
if fn.startswith(fn_root) and fn.endswith('.pvtr')
]
# Sort files
fns = Tcl().call('lsort', '-dict', fns)
if len(fns) > 1:
print("More than one fn with this name. Taking time average.")
# Store snapshots of field
self.snaps = []
for fn in fns[::down]:
snap = vtr_to_mesh(os.path.join(datp_dir, fn),
self.length_scale)
self.snaps.append(snap)
del snap
# Time average the flow field snaps
mean_t = np.mean(np.array(self.snaps).T, axis=1)
self.X, self.Y = mean_t[0:2]
self.u, self.v, self.w = mean_t[2:-1]
self.U, self.V = np.mean(self.u, axis=2), np.mean(self.v, axis=2)
self.p = np.mean(mean_t[-1], axis=0)
del mean_t
else:
assert (len(fns) > 0
), 'You dont have ' + fn_root + '.pvtr in your datp folder'
self.X, self.Y, self.U, self.V, self.W, self.p = vtr_to_mesh(
os.path.join(datp_dir, fns[0]), self.length_scale)
self.U, self.V = np.squeeze(self.U), np.squeeze(self.V)
self.p = np.squeeze(self.p)
self.z = np.ones(np.shape(self.X))
# --- Unpack mean flow quantities ---
names = kwargs.get('names', [
't', 'dt', 'px', 'py', 'pz', 'vx', 'vy', 'vz', 'v2x', 'v2y', 'v2z'
])
fos = (io.unpack_flex_forces(os.path.join(self.sim_dir, 'fort.9'),
names))
self.fos = dict(zip(names, fos))
def generate_corpus(txt_dirs):
for txt_dir in txt_dirs:
corpus_full_path = txt_dir + '/corpus.txt'
if path.exists(corpus_full_path):
print('Corpus exists, returning...')
continue
with open(corpus_full_path, 'w+') as corpus:
# Need to preserve order
for file in Tcl().call('lsort', '-dict', os.listdir(txt_dir)):
full_path = txt_dir + '/' + file
with open(full_path, 'r') as source:
corpus.write(source.read())
corpus.write(' ')
def _init_tcl(self):
"""Initialize Tcl interpreter.
Returns:
None
"""
try:
self.Tcl is None
except AttributeError:
self.Tcl = Tcl()
# Define logger
def tcl_puts(*args):
"""Enables logging for tcl output.
Returns:
None
"""
if len(args) >= 2:
stream = args[0]
if stream == "stdout":
self.class_logger.debug(" ".join(args[1:]))
elif stream == "stderr":
self.class_logger.error(" ".join(args[1:]))
else:
self.class_logger.debug("stream <%s>: %s" %
(args[0], " ".join(args[1:])))
elif len(args) == 1:
self.class_logger.debug(args[0])
else:
self.class_logger.error("Called puts without arguments.")
return None
self.Tcl.createcommand("tcl_puts", tcl_puts)
self.class_logger.debug("Insert tcl script to catch puts output.")
ixia_helpers.tcl_puts_replace(self.Tcl)
ixia_helpers.ixtclhal_import(self.Tcl)
def create_txt(set, ids):
path = os.path.join('datasets', args.project)
os.makedirs(path, exist_ok=True)
with open(os.path.join(path, f'{set}.txt'), 'w') as f:
for label, id in enumerate(ids):
if (val_size == 0) and (set == 'val'):
break
images = os.listdir(os.path.join(root, id))
images = Tcl().call('lsort', '-dict', images) # sort
if val_size != 0:
if set == 'train':
images = images[:-val_size]
elif set == 'val':
images = images[-val_size:]
for image in images:
f.write(f'{id}/{image} {label}\n')
return print(f'------{set}.txt created------')
def testLoadTkFailure(self):
old_display = None
if sys.platform.startswith(('win', 'darwin', 'cygwin')):
# no failure possible on windows?
# XXX Maybe on tk older than 8.4.13 it would be possible,
# see tkinter.h.
return
with test_support.EnvironmentVarGuard() as env:
if 'DISPLAY' in os.environ:
del env['DISPLAY']
# on some platforms, deleting environment variables
# doesn't actually carry through to the process level
# because they don't support unsetenv
# If that's the case, abort.
display = os.popen('echo $DISPLAY').read().strip()
if display:
return
tcl = Tcl()
self.assertRaises(TclError, tcl.winfo_geometry)
self.assertRaises(TclError, tcl.loadtk)
def testLoadTkFailure(self):
import os
old_display = None
import sys
if sys.platform.startswith(('win', 'darwin', 'cygwin')):
return # no failure possible on windows?
if 'DISPLAY' in os.environ:
old_display = os.environ['DISPLAY']
del os.environ['DISPLAY']
# on some platforms, deleting environment variables
# doesn't actually carry through to the process level
# because they don't support unsetenv
# If that's the case, abort.
display = os.popen('echo $DISPLAY').read().strip()
if display:
return
try:
tcl = Tcl()
self.assertRaises(TclError, tcl.winfo_geometry)
self.assertRaises(TclError, tcl.loadtk)
finally:
if old_display is not None:
os.environ['DISPLAY'] = old_display
def setUp(self):
self.interp = Tcl()
import matplotlib.pyplot as plt
import numpy as np
import imageio
from PIL import Image
import matplotlib.image as mpimg
from tkinter import Tcl
import os
file_dir = "D:/Study/project/GAN/result/lsgan"
filename = os.listdir(file_dir)
f = Tcl().call('lsort', '-dict', filename) # filename sort
# print(f)
path = [file_dir + f"/{i}" for i in f]
paths = [Image.open(i) for i in path]
# save
save_name = 'lsgan_02'
imageio.mimsave('D:/Study/project/GAN/result/pngs/%s.gif' % (save_name),
paths,
fps=2)
def setUp(self):
self.root = Tcl()
def setUpModule():
if support.verbose:
tcl = Tcl()
print('patchlevel =', tcl.call('info', 'patchlevel'))
def setUp(self):
self.interp = Tcl()
self.wantobjects = self.interp.tk.wantobjects()
def __init__(self) -> None:
"""Init Tcl object."""
self.tcl = Tcl()
def testLoadTk(self):
tcl = Tcl()
self.assertRaises(TclError,tcl.winfo_geometry)
tcl.loadtk()
self.assertEqual('1x1+0+0', tcl.winfo_geometry())
tcl.destroy()
if __name__ == "__main__":
# get the images folder path
path_images = gui_load_data_directory('', 'images folder')
# path_images = '/Users/zhiqiao/Documents/Xray_wavefront_data/Zahir_Aug2019/CRL_D/focus_105p5mm_165p5mm_0p5mmstep/average_crop'
# print(path_images)
# read all the images
# read all the images under that folder
listOfFiles = glob.glob(path_images + '/*.tif')
time_sort = False
if time_sort:
listOfFiles.sort(key=os.path.getmtime)
else:
listOfFiles = Tcl().call('lsort', '-dict', listOfFiles)
# listOfFiles.sort()
listOfData = []
for fname in listOfFiles:
print('\033[32m' + 'MESSAGE: read File ' + fname + '\033[0m')
temp_data = tiff.imread(fname)
listOfData.append(temp_data)
img_data = np.array(listOfData)
# use the 1/e^2 edge as the beam spot area
n_image, row_size, col_size = img_data.shape
img_width = np.zeros(img_data.shape)
img_FWHM = np.zeros((2, img_data.shape[0]))
img_sigma = np.zeros((2, img_data.shape[0]))
i += 1
return id_to_labels, labels_to_id
print("\n")
label_file = 'output_labels_alphabet.txt'
id_to_labels, labels_to_id = load_label_dicts(label_file)
files = []
crop_folder_path = os.path.join('crop')
path = os.path.join(crop_folder_path, "*.png")
frames = glob.glob(path)
files = frames
files = list(Tcl().call('lsort', '-dict', files))
prediction_vector = get_inference_vector_one_frame_alphabet(files)
prediction_vector = np.array(prediction_vector)
print("\n")
l = []
for i in range(prediction_vector.shape[0]):
l.append(id_to_labels[np.argmax(prediction_vector[i])])
print("Labels from Cropped images")
print(l)
files = []
data_folder_path = os.path.join('data')
path = os.path.join(data_folder_path, "*.png")
default='DeepGlint',
type=str,
help='save name')
parser.add_argument('-r',
'--ratio',
default=0.2,
type=float,
help='How many images do you want to use in validation')
parser.add_argument('-s', '--set', default=['train', 'val'])
args = parser.parse_args()
root = os.path.join('/home/ubuntu/data/', args.project)
# root = os.path.join('datasets', args.project)
ids = os.listdir(root)
ids = Tcl().call('lsort', '-dict', ids)
print('Total_ids :', len(ids))
min_n = 0
max_n = 0
cn = 0
for id in ids:
images = os.listdir(os.path.join(root, id))
if min_n == 0:
min_n = len(images)
max_n = max([max_n, len(images)])
min_n = min([min_n, len(images)])
if len(images) < 11:
# print('id :', id)
def get_tk_patchlevel():
global _tk_patchlevel
if _tk_patchlevel is None:
tcl = Tcl()
_tk_patchlevel = tcl.info_patchlevel()
return _tk_patchlevel
import os
import shutil
from tkinter import Tcl
m = 50000
n = 5000
src_dir = "C:/Users/shubh/Downloads/Shubh_mypy_proj/comp_vision/train/traintemp"
dst_dir = "C:/Users/shubh/Desktop/thisone"
file_list = os.listdir(src_dir)
file_list = (Tcl().call('lsort', '-dict', file_list))
for i in range(0, m, n):
for j in range(i, i + 100):
shutil.copy(file_list[j], dst_dir)
