def can_update_cal(path):
""" Check if cal can be updated by checking for required fields. """
try:
calstat = os.stat(path)
except Exception as exception:
safe_print("Warning - os.stat('%s') failed: %s" %
tuple(safe_unicode(s) for s in (path, exception)))
return False
if not path in cals or cals[path].mtime != calstat.st_mtime:
try:
cal = CGATS.CGATS(path)
except (IOError, CGATS.CGATSInvalidError,
CGATS.CGATSInvalidOperationError, CGATS.CGATSKeyError,
CGATS.CGATSTypeError, CGATS.CGATSValueError) as exception:
if path in cals:
del cals[path]
safe_print("Warning - couldn't process CGATS file '%s': %s" %
tuple(safe_unicode(s) for s in (path, exception)))
else:
if cal.queryv1("DEVICE_CLASS") == "DISPLAY" and not None in \
(cal.queryv1("TARGET_WHITE_XYZ"),
cal.queryv1("TARGET_GAMMA"),
cal.queryv1("BLACK_POINT_CORRECTION"),
cal.queryv1("QUALITY")):
cals[path] = cal
return path in cals and cals[path].mtime == calstat.st_mtime
def stop(inp):
try:
pkt = Packet(PacketType.stop, destination=int(inp[0]))
except (IndexError, ValueError):
pkt = Packet(PacketType.stop)
pkt.send()
safe_print(pkt)
def ignore_heartbeats(inp=[]):
global ignore_heartbeats
try:
ignore_heartbeats = ("yes" in inp[0]) or ("on" in inp[0])
except IndexError:
ignore_heartbeats = not ignore_heartbeats
safe_print("Ignoring heartbeats: %r" % ignore_heartbeats)
def stop(inp):
try:
pkt = Packet(PacketType.stop, destination=int(inp[0]))
except (IndexError, ValueError):
pkt = Packet(PacketType.stop)
pkt.send()
safe_print(pkt)
def ignore_heartbeats(inp=[]):
global ignore_heartbeats
try:
ignore_heartbeats = ("yes" in inp[0]) or ("on" in inp[0])
except IndexError:
ignore_heartbeats = not ignore_heartbeats
safe_print("Ignoring heartbeats: %r" % ignore_heartbeats)
def connect(inp=[]):
if bluetooth.serial_port.isOpen():
safe_print("Bluetooth is already connected.")
else:
if len(inp) == 0:
which = None
else:
which = inp[0]
bluetooth.start(which, handle_pkt, safe_print)
def add_dispcal_options_to_cal(cal, options_dispcal):
# Add dispcal options to cal
options_dispcal = quote_nonoption_args(options_dispcal)
try:
cgats = CGATS.CGATS(cal)
cgats[0].add_section(
"ARGYLL_DISPCAL_ARGS",
" ".join(options_dispcal).encode("UTF-7", "replace"))
return cgats
except Exception as exception:
safe_print(safe_unicode(traceback.format_exc()))
def connect(inp=[]):
if bluetooth.serial_port.isOpen():
safe_print("Bluetooth is already connected.")
else:
if len(inp) == 0:
which = None
else:
which = inp[0]
bluetooth.start(which, handle_pkt, safe_print)
def process_data(self, data):
if data[0] == "echo" and len(data) > 1:
linecount = self.console.GetNumberOfLines()
lastline = self.console.GetLineText(linecount - 1)
if lastline:
self.add_text("\n")
txt = " ".join(data[1:])
safe_print(txt)
self.add_text(txt + "\n")
if lastline:
self.add_text("> ")
return "ok"
return "invalid"
def avail(which, inp):
global availability
old_val = availability[which]
if inp[0] == "+" or inp[0] == "-":
# If first character of first input is +, use +n notation to mark tube n as occupied
num = tubenum(inp[1:]) # Get the tubenum with chars 1 through end of the first input
if num == -1:
safe_print(
"! " + which + " availability invalid, one number between 0 and 3 expected with +n or -n notation"
)
return
else:
availability[which][num] = inp[0] == "+"
else:
# Using bitmask mode
if len(inp) != 4:
safe_print("! " + which + " availability invalid, one 4-digit bitmask expected in bitmask mode")
return
else:
for ch in inp:
if ch != "0" and ch != "1":
print_safe("! " + which + " availability invalid, only 0 and 1 expected in bitmask mode")
return
availability[which] = boolstr_to_list(inp)
safe_print(which + " updated from 0b%s to 0b%s" % (list_to_boolstr(old_val), list_to_boolstr(availability[which])))
typ = PacketType.supply_availability if which is "Supply" else PacketType.storage_availability
pkt = Packet(typ, list_to_int(availability[which]), destination=0)
pkt.send()
safe_print(pkt)
def add_options_to_ti3(ti3, options_dispcal=None, options_colprof=None):
# Add dispcal and colprof options to ti3
try:
cgats = CGATS.CGATS(ti3)
if options_colprof:
options_colprof = quote_nonoption_args(options_colprof)
cgats[0].add_section(
"ARGYLL_COLPROF_ARGS",
" ".join(options_colprof).encode("UTF-7", "replace"))
if options_dispcal and 1 in cgats:
options_dispcal = quote_nonoption_args(options_dispcal)
cgats[1].add_section(
"ARGYLL_DISPCAL_ARGS",
" ".join(options_dispcal).encode("UTF-7", "replace"))
return cgats
except Exception as exception:
safe_print(safe_unicode(traceback.format_exc()))
def OnClose(self, event):
# So we can send_command('close') ourselves without prematurely exiting
# the wx main loop
while self.busy:
wx.Yield()
sleep(.05)
# Hide first (looks nicer)
self.Hide()
try:
with open(self.historyfilename, "wb") as historyfile:
for command in self.history:
if command:
historyfile.write(
safe_str(command, "UTF-8") + os.linesep)
except EnvironmentError as exception:
safe_print("Warning - couldn't write history file:", exception)
self.listening = False
# Need to use CallAfter to prevent hang under Windows if minimized
wx.CallAfter(self.Destroy)
def main():
funcs['connect']()
while True:
try:
inp = raw_input("> ").split()
cmd = inp[0]
inp = inp[1:] # input remaining after command
if cmd == "exit":
break
elif cmd in funcs:
funcs[cmd](inp)
else:
safe_print("! Unknown command `" + cmd + "`. Inputs: " + repr(inp))
# Makes Ctrl-C clear the input like I'm used to from bash/zsh
except KeyboardInterrupt:
print #newline
continue
def main():
funcs["connect"]()
while True:
try:
inp = raw_input("> ").split()
cmd = inp[0]
inp = inp[1:] # input remaining after command
if cmd == "exit":
break
elif cmd in funcs:
funcs[cmd](inp)
else:
safe_print("! Unknown command `" + cmd + "`. Inputs: " + repr(inp))
# Makes Ctrl-C clear the input like I'm used to from bash/zsh
except KeyboardInterrupt:
print # newline
continue
def _print_formated_message(self, msgObj, is_receiving=True):
type = msgObj.get("type")
sender = msgObj.get("sender")
receiver = msgObj.get("receiver")
data = msgObj.get("data")
ts = msgObj.get("timestamp")
if type != "ice-candidate" and type != "ice-candidate_hotspot":
if is_receiving is True:
safe_print( " [x] Message received. Type:" + \
"{0: <30}".format(type) + \
"{0: <15}".format(sender) + \
">>" + \
"{0: >15}".format(receiver) )
else:
safe_print( " [*] Message sent. Type:" + \
"{0: <30}".format(type) + \
"{0: <15}".format(sender) + \
">>" + \
"{0: >15}".format(receiver) )
return type, sender, receiver, data, ts
def cal_to_vcgt(cal, return_cgats=False):
"""
Create a vcgt tag from calibration data.
cal must refer to a valid Argyll CAL file and can be a CGATS instance
or a filename.
"""
if not isinstance(cal, CGATS.CGATS):
try:
cal = CGATS.CGATS(cal)
except (IOError, CGATS.CGATSInvalidError,
CGATS.CGATSInvalidOperationError, CGATS.CGATSKeyError,
CGATS.CGATSTypeError, CGATS.CGATSValueError) as exception:
safe_print("Warning - couldn't process CGATS file '%s': %s" %
tuple(safe_unicode(s) for s in (cal, exception)))
return None
required_fields = ("RGB_I", "RGB_R", "RGB_G", "RGB_B")
data_format = cal.queryv1("DATA_FORMAT")
if data_format:
for field in required_fields:
if not field in list(data_format.values()):
if debug: safe_print("[D] Missing required field:", field)
return None
for field in list(data_format.values()):
if not field in required_fields:
if debug: safe_print("[D] Unknown field:", field)
return None
entries = cal.queryv(required_fields)
if len(entries) < 1:
if debug:
safe_print("[D] No entries found in calibration", cal.filename)
return None
vcgt = ICCP.VideoCardGammaTableType("", "vcgt")
vcgt.update({
"channels": 3,
"entryCount": len(entries),
"entrySize": 2,
"data": [[], [], []]
})
for n in entries:
for i in range(3):
vcgt.data[i].append(entries[n][i + 1] * 65535.0)
if return_cgats:
return vcgt, cal
return vcgt
def avail(which, inp):
global availability
old_val = availability[which]
if inp[0] == '+' or inp[0] == '-':
# If first character of first input is +, use +n notation to mark tube n as occupied
num = tubenum(
inp[1:]
) # Get the tubenum with chars 1 through end of the first input
if num == -1:
safe_print(
"! " + which +
" availability invalid, one number between 0 and 3 expected with +n or -n notation"
)
return
else:
availability[which][num] = (inp[0] == '+')
else:
# Using bitmask mode
if len(inp) != 4:
safe_print(
"! " + which +
" availability invalid, one 4-digit bitmask expected in bitmask mode"
)
return
else:
for ch in inp:
if ch != '0' and ch != '1':
print_safe(
"! " + which +
" availability invalid, only 0 and 1 expected in bitmask mode"
)
return
availability[which] = boolstr_to_list(inp)
safe_print(
which + " updated from 0b%s to 0b%s" %
(list_to_boolstr(old_val), list_to_boolstr(availability[which])))
typ = PacketType.supply_availability if which is 'Supply' else PacketType.storage_availability
pkt = Packet(typ, list_to_int(availability[which]), destination=0)
pkt.send()
safe_print(pkt)
def resume(inp):
pkt = Packet(PacketType.resume)
pkt.send()
safe_print(pkt)
def __init__(self):
SimpleTerminal.__init__(
self,
None,
wx.ID_ANY,
lang.getstr("scripting-client"),
start_timer=False,
pos=(getcfg("position.scripting.x"),
getcfg("position.scripting.y")),
size=(getcfg("size.scripting.w"), getcfg("size.scripting.h")),
consolestyle=wx.TE_CHARWRAP | wx.TE_MULTILINE | wx.TE_PROCESS_ENTER
| wx.TE_RICH | wx.VSCROLL | wx.NO_BORDER,
show=False,
name="scriptingframe")
self.SetIcons(
config.get_icon_bundle([256, 48, 32, 16],
appname + "-scripting-client"))
self.console.SetForegroundColour("#EEEEEE")
self.console.SetDefaultStyle(wx.TextAttr("#EEEEEE"))
self.busy = False
self.commands = []
self.history = []
self.historyfilename = os.path.join(
confighome, config.appbasename + "-scripting-client.history")
if os.path.isfile(self.historyfilename):
try:
with open(self.historyfilename) as historyfile:
for line in historyfile:
self.history.append(
safe_unicode(line, "UTF-8").rstrip("\r\n"))
except EnvironmentError as exception:
safe_print("Warning - couldn't read history file:", exception)
# Always have empty selection at bottom
self.history.append("")
self.historypos = len(self.history) - 1
self.overwrite = False
# Determine which application we should connect to by default (if any)
self.conn = None
scripting_hosts = self.get_scripting_hosts()
self.sizer.Layout()
if sys.platform != "darwin":
# Under Mac OS X, the transparency messes up the window shadow if
# there is another window's border behind
self.SetTransparent(240)
self.Bind(wx.EVT_ACTIVATE, self.OnActivate)
self.Bind(wx.EVT_SIZE, self.OnSize)
self.Unbind(wx.EVT_CHAR_HOOK)
self.console.Unbind(wx.EVT_KEY_DOWN, self.console)
self.console.Bind(wx.EVT_KEY_DOWN, self.key_handler)
self.console.Bind(wx.EVT_TEXT_COPY, self.copy_text_handler)
self.console.Bind(wx.EVT_TEXT_PASTE, self.paste_text_handler)
if sys.platform == "darwin":
# Under Mac OS X, pasting text via the context menu isn't catched
# by EVT_TEXT_PASTE. TODO: Implement custom context menu.
self.console.Bind(wx.EVT_CONTEXT_MENU, lambda event: None)
if scripting_hosts:
self.add_text("> getscriptinghosts" + "\n")
for host in scripting_hosts:
self.add_text(host + "\n")
ip_port = scripting_hosts[0].split()[0]
self.add_text("> connect " + ip_port + "\n")
self.connect_handler(ip_port)
def supply(inp):
if len(inp) != 1:
safe_print("! Supply availability invalid, one argument expected")
return
else:
avail("Supply", inp[0])
def storage(inp):
if len(inp) != 1:
safe_print("! Storage availability invalid, one argument expected")
return
else:
avail("Storage", inp[0])
def extract_cal_from_profile(profile,
out_cal_path=None,
raise_on_missing_cal=True,
prefer_cal=False):
""" Extract calibration from 'targ' tag in profile or vcgt as fallback """
white = False
# Check if calibration is included in TI3
targ = profile.tags.get("targ", profile.tags.get("CIED"))
if isinstance(targ, ICCP.Text):
cal = extract_cal_from_ti3(targ)
if cal:
check = cal
get_cgats = CGATS.CGATS
arg = cal
else:
cal = None
if not cal:
# Convert calibration information from embedded WCS profile
# (if present) to VideCardFormulaType if the latter is not present
if (isinstance(profile.tags.get("MS00"), ICCP.WcsProfilesTagType)
and not "vcgt" in profile.tags):
profile.tags["vcgt"] = profile.tags["MS00"].get_vcgt()
# Get the calibration from profile vcgt
check = isinstance(profile.tags.get("vcgt"), ICCP.VideoCardGammaType)
get_cgats = vcgt_to_cal
arg = profile
if not check:
if raise_on_missing_cal:
raise Error(lang.getstr("profile.no_vcgt"))
else:
return False
else:
try:
cgats = get_cgats(arg)
except (IOError, CGATS.CGATSError) as exception:
raise Error(lang.getstr("cal_extraction_failed"))
if (cal and not prefer_cal
and isinstance(profile.tags.get("vcgt"), ICCP.VideoCardGammaType)):
# When vcgt is nonlinear, prefer it
# Check for video levels encoding
if cgats.queryv1("TV_OUTPUT_ENCODING") == "YES":
black, white = (16, 235)
else:
output_enc = cgats.queryv1("OUTPUT_ENCODING")
if output_enc:
try:
black, white = (float(v) for v in output_enc.split())
except (TypeError, ValueError):
white = False
cgats = vcgt_to_cal(profile)
if white and (black, white) != (0, 255):
safe_print("Need to un-scale vcgt from video levels (%s..%s)" %
(black, white))
# Need to un-scale video levels
data = cgats.queryv1("DATA")
if data:
safe_print("Un-scaling vcgt from video levels (%s..%s)" %
(black, white))
encoding_mismatch = False
# For video encoding the extra bits of
# precision are created by bit shifting rather
# than scaling, so we need to scale the fp
# value to account for this
oldmin = (black / 256.0) * (65536 / 65535.)
oldmax = (white / 256.0) * (65536 / 65535.)
for entry in data.values():
for column in "RGB":
v_old = entry["RGB_" + column]
lvl = round(v_old * (65535 / 65536.) * 256, 2)
if lvl < round(black, 2) or lvl > round(white, 2):
# Can't be right. Metadata says it's video encoded,
# but clearly exceeds the encoding range.
safe_print("Warning: Metadata claims video levels "
"(%s..%s) but vcgt value %s exceeds "
"encoding range. Using values as-is." %
(round(black, 2), round(white, 2), lvl))
encoding_mismatch = True
break
v_new = colormath.convert_range(
v_old, oldmin, oldmax, 0, 1)
entry["RGB_" + column] = min(max(v_new, 0), 1)
if encoding_mismatch:
break
if encoding_mismatch:
cgats = vcgt_to_cal(profile)
# Add video levels hint to CGATS
elif (black, white) == (16, 235):
cgats[0].add_keyword("TV_OUTPUT_ENCODING", "YES")
else:
cgats[0].add_keyword(
"OUTPUT_ENCODING",
" ".join(str(v) for v in (black, white)))
else:
safe_print("Warning - no un-scaling applied - no "
"calibration data!")
if out_cal_path:
cgats.write(out_cal_path)
return cgats
def vrmlfile2x3dfile(vrmlpath=None,
x3dpath=None,
html=True,
embed=False,
view=False,
force=False,
cache=True,
worker=None,
gui=True):
""" Convert VRML to HTML. Output is written to <vrmlfilename>.x3d.html
unless you set x3dpath to desired output path, or False to be prompted
for an output path. """
while not vrmlpath or not os.path.isfile(vrmlpath):
if not gui:
if not vrmlpath or vrmlpath.startswith("--"):
safe_print("No filename given.")
else:
safe_print("%r is not a file." % vrmlpath)
return False
if not wx.GetApp():
app = BaseApp(0)
defaultDir, defaultFile = config.get_verified_path("last_vrml_path")
dlg = wx.FileDialog(None,
lang.getstr("file.select"),
defaultDir=defaultDir,
defaultFile=defaultFile,
wildcard=lang.getstr("filetype.vrml") +
"|*.vrml;*.vrml.gz;*.wrl.gz;*.wrl;*.wrz",
style=wx.FD_OPEN | wx.FD_FILE_MUST_EXIST)
dlg.Center(wx.BOTH)
result = dlg.ShowModal()
vrmlpath = dlg.GetPath()
dlg.Destroy()
if result != wx.ID_OK:
return
config.setcfg("last_vrml_path", vrmlpath)
config.writecfg(module="VRML-to-X3D-converter",
options=("last_vrml_path", ))
filename, ext = os.path.splitext(vrmlpath)
if x3dpath is None:
x3dpath = filename + ".x3d"
if x3dpath:
dirname = os.path.dirname(x3dpath)
while not x3dpath or not waccess(dirname, os.W_OK):
if not gui:
if not x3dpath:
safe_print("No HTML output filename given.")
else:
safe_print("%r is not writable." % dirname)
return False
if not wx.GetApp():
app = BaseApp(0)
if x3dpath:
defaultDir, defaultFile = os.path.split(x3dpath)
else:
defaultFile = os.path.basename(filename) + ".x3d"
dlg = wx.FileDialog(None,
lang.getstr("error.access_denied.write", dirname),
defaultDir=defaultDir,
defaultFile=defaultFile,
wildcard=lang.getstr("filetype.x3d") + "|*.x3d",
style=wx.SAVE | wx.FD_OVERWRITE_PROMPT)
dlg.Center(wx.BOTH)
result = dlg.ShowModal()
dlg.Destroy()
if result != wx.ID_OK:
return
x3dpath = dlg.GetPath()
dirname = os.path.dirname(x3dpath)
vrmlpath, x3dpath = [safe_unicode(path) for path in (vrmlpath, x3dpath)]
if sys.platform == "win32":
vrmlpath = make_win32_compatible_long_path(vrmlpath)
x3dpath = make_win32_compatible_long_path(x3dpath)
if html:
finalpath = x3dpath + ".html"
if sys.platform == "win32":
finalpath = make_win32_compatible_long_path(finalpath)
x3dpath = finalpath[:-5]
else:
finalpath = x3dpath
if worker:
worker.clear_cmd_output()
worker.start(
lambda result: show_result_dialog(result,
wx.GetApp().GetTopWindow())
if isinstance(result, Exception
) else result and view and launch_file(finalpath),
x3dom.vrmlfile2x3dfile,
wargs=(vrmlpath, x3dpath, html, embed, force, cache, worker),
progress_title=lang.getstr("vrml_to_x3d_converter"),
progress_start=1,
resume=worker.progress_wnd
and worker.progress_wnd.IsShownOnScreen(),
fancy=False)
else:
result = x3dom.vrmlfile2x3dfile(vrmlpath, x3dpath, html, embed, force,
cache, None)
if not isinstance(result, Exception) and result:
if view:
launch_file(finalpath)
else:
return False
return True
if (placeholder == "${TRC}" and not result
and "${TRC_GAMMA}" in placeholders2data):
default = "BT.1886"
else:
default = ""
placeholders2data[placeholder] = result.groups(
)[0] if result else default
if result and placeholder == "${COLS}":
templatename = "uniformity"
# backup original report
shutil.copy2(report_path,
"%s.%s" % (report_path, strftime("%Y-%m-%d_%H-%M-%S")))
create(report_path, placeholders2data, pack, templatename)
if __name__ == "__main__":
initcfg()
lang.init()
if not sys.argv[1:]:
safe_print("Update existing report(s) with current template files.")
safe_print("Usage: %s report1.html [report2.html...]" %
os.path.basename(sys.argv[0]))
else:
for arg in sys.argv[1:]:
try:
update(arg)
except (IOError, OSError) as exception:
safe_print(exception)
def main():
if "--help" in sys.argv[1:] or (not sys.argv[1:] and not gui):
safe_print("Convert VRML file to X3D")
safe_print("Author: Florian Hoech, licensed under the GPL version 3")
safe_print("Usage: %s [OPTION]... FILE..." %
os.path.basename(sys.argv[0]))
safe_print("The output is written to FILENAME.x3d(.html)")
safe_print("")
safe_print(" --embed Embed viewer components in HTML instead of "
"referencing them")
safe_print(" --force Force fresh download of viewer components")
safe_print(" --no-cache Don't use viewer components cache (only "
"uses existing cache if")
safe_print(" embedding components, can be overridden "
"with --force)")
if gui:
safe_print(" --no-gui Don't use GUI (console mode)")
safe_print(" --no-html Don't generate HTML file")
safe_print(" --view View the generated file (if no GUI)")
if not gui:
safe_print(" --batch Don't pause after processing")
safe_print(" FILE Filename of VRML file to convert")
if gui:
return
if gui:
config.initcfg("VRML-to-X3D-converter")
lang.init()
lang.update_defaults()
cache = not "--no-cache" in sys.argv[1:]
embed = "--embed" in sys.argv
force = "--force" in sys.argv
html = not "--no-html" in sys.argv[1:]
if not gui:
result = None
view = "--view" in sys.argv[1:]
for arg in sys.argv[1:]:
if not arg.startswith("--"):
result = vrmlfile2x3dfile(safe_unicode(arg),
html=html,
embed=embed,
view=view,
force=force,
cache=cache,
gui=gui)
if result is None:
safe_print("No filename given.")
if sys.stdout.isatty() and not "--batch" in sys.argv[1:]:
input("Press RETURN to exit")
sys.exit(int(not result))
else:
view = not "--no-view" in sys.argv[1:]
app = BaseApp(0)
app.TopWindow = VRML2X3DFrame(html, embed, view, force, cache)
if sys.platform == "darwin":
app.TopWindow.init_menubar()
wx.CallLater(1, _main, app)
app.MainLoop()
def handle_pkt(pkt):
if not ignore_heartbeats or pkt.type != bluetooth.PacketType.heartbeat:
safe_print(pkt)
def send(self):
if (serial_port.isOpen()):
serial_port.write(self.to_data())
else:
safe_print("! Serial connection isn't open")
def supply(inp):
if len(inp) != 1:
safe_print("! Supply availability invalid, one argument expected")
return
else:
avail("Supply", inp[0])
def resume(inp):
pkt = Packet(PacketType.resume)
pkt.send()
safe_print(pkt)
def storage(inp):
if len(inp) != 1:
safe_print("! Storage availability invalid, one argument expected")
return
else:
avail("Storage", inp[0])
def handle_pkt(pkt):
if not ignore_heartbeats or pkt.type != bluetooth.PacketType.heartbeat:
safe_print(pkt)
def send(self):
if serial_port.isOpen():
serial_port.write(self.to_data())
else:
safe_print("! Serial connection isn't open")
