"""
** voyagerimb.py - A browser for the NASA's Voyager Golden Disk images **
Copyright (c) <2017> Manuel Arturo Izquierdo <aizquier@gmail.com>
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
"""
import sys
import os
import subprocess
import numpy as np
import scipy.io.wavfile
import matplotlib
matplotlib.use("TkAgg")
import matplotlib.pyplot as plt
import tkinter as tk
from PIL import Image
# * support for previous matplotlib versions (v1, v2) and the current v3
mpltlib3 = True if int(matplotlib.__version__.split('.')[0]) > 2 else False
if mpltlib3:
from matplotlib.backends.backend_tkagg import FigureCanvasTkAgg, NavigationToolbar2Tk
from tkinter import messagebox, filedialog
else:
from matplotlib.backends.backend_tkagg import FigureCanvasTkAgg, NavigationToolbar2TkAgg
from tkinter import messagebox
class ValidatedEntry(object):
def __init__(self, *args, **kwargs):
self.textvariable = tk.StringVar()
kwargs['textvariable'] = self.textvariable
self.Entry = tk.Entry(*args, **kwargs)
class NumericalIntEntry(ValidatedEntry):
def textvariable_as_int(self):
try:
return int(self.textvariable.get())
except ValueError:
print("Error: non numeric (int) value in entry!")
return None
class NumericalFloatEntry(ValidatedEntry):
def textvariable_as_float(self):
try:
return float(self.textvariable.get())
except ValueError:
print("Error: non numeric (float) value in entry!")
return None
class FileMenu(object):
def openfile(self):
filename = tk.filedialog.askopenfilename(
initialdir = os.getcwd(),
title = "Select file",
filetypes = (("wav files","*.wav"), )
)
if len(filename) != 0:
try:
self.browser.model_load_audio_data(filename)
except:
print("Invalid wav file")
return
self.browser.imager.view_plot_image()
def sync_invert_signal(self, *args):
self.browser.invert_signal = self.invert_signal.get()
self.browser.imager.view_plot_image()
def sync_flip_horizontal(self, *args):
self.browser.flip_horizontal = self.flip_horizontal.get()
self.browser.imager.view_plot_image()
def model_init(self):
self.invert_signal = tk.BooleanVar()
self.invert_signal.set(False)
self.invert_signal.trace("w", self.sync_invert_signal)
self.flip_horizontal = tk.BooleanVar()
self.flip_horizontal.set(False)
self.flip_horizontal.trace("w", self.sync_flip_horizontal)
def __save_image(self, resize=False):
filename = tk.filedialog.asksaveasfilename(defaultextension=".bin")
if filename is None: # asksaveasfile return `None` if dialog closed with "cancel".
return
data = np.array(self.browser.imager.model_get_segment())
x1, x2 = np.min(data), np.max(data)
y1, y2 = 0, 255.0
m = (y2 - y1) / (x2 - x1)
b = y2 - (m * x2)
data_rescaled_colors = ((m * data) + b).astype(np.uint8)
image = Image.fromarray(data_rescaled_colors)
if resize:
image = image.resize((image.width, int(image.width * (4.0/ 3.0)) ))
try:
image.save(filename)
except KeyError:
messagebox.showerror("Export image", "Invalid image format.\nTry using file extensions like .png or .jpg")
return
except IOError:
messagebox.showerror("Export image",
"Error saving image.\nCheck that you have enough disk space\nor right privileges")
return
messagebox.showinfo("Export image", "Image exported as %s" % (filename))
def save_image_raw_size(self):
self.__save_image(resize=False)
def save_image_resized(self):
self.__save_image(resize=True)
def about(self):
'''Starts project webpage in the default system's web browser'''
webpage = "https://github.com/aizquier/voyagerimb"
# * MacOS
if sys.platform.startswith('darwin'):
subprocess.call(('open', webpage))
# * Windows
elif os.name == 'nt':
os.startfile(webpage)
# * Linux
elif os.name == 'posix':
subprocess.Popen(['xdg-open', webpage])
def __init__(self, parent):
self.browser = parent
self.model_init()
menubar = tk.Menu(parent.root)
filemenu = tk.Menu(menubar, tearoff=0)
filemenu.add_command(label="Open WAV...", command=self.openfile)
filemenu.add_separator()
filemenu.add_command(label="Export image...", command=self.save_image_resized)
filemenu.add_command(label="Export image (raw size)...", command=self.save_image_raw_size)
filemenu.add_separator()
filemenu.add_command(label="Exit", command=parent.root.quit)
menubar.add_cascade(label="File", menu=filemenu)
filemenu = tk.Menu(menubar, tearoff=0)
filemenu.add_checkbutton(label="Invert audio signal", onvalue=True, offvalue=False, variable=self.invert_signal)
filemenu.add_checkbutton(label="Flip horizontal", onvalue=True, offvalue=False, variable=self.flip_horizontal)
menubar.add_cascade(label="Image", menu=filemenu)
filemenu = tk.Menu(menubar, tearoff=0)
filemenu.add_command(label="About...", command=self.about)
menubar.add_cascade(label="Help", menu=filemenu)
parent.root.config(menu=menubar)
class Imager(object):
def model_init(self):
self.first = True
pass
def model_get_segment(self):
offset = self.browser.offset
scan_width = self.browser.scan_line_width
image_data = []
offset_exceeded = False
for scan in range(self.browser.number_of_scans):
chunk = [-_m if self.browser.invert_signal
else _m for _m in self.browser.audio_data[int(offset):int(offset) + scan_width]]
if len(chunk) != scan_width:
chunk = np.zeros(scan_width)
offset_exceeded = True
image_data.append(chunk)
offset += scan_width + self.browser.adjust
if offset_exceeded:
self.browser.offset_exceeded = True
else:
self.browser.offset_exceeded = False
return image_data
def view_plot_image(self):
if self.browser.audio_data is None:
if self.first:
self.first = False
else:
self.browser.view_nodata_error()
return
self.browser.root.config(cursor="watch")
self.browser.root.update()
image_data = self.model_get_segment()
if not self.browser.offset_exceeded:
self.ax1.clear()
self.ax2.clear()
self.ax1.set_xlim([self.browser.scan_line_width, 0]
if self.browser.flip_horizontal else [0, self.browser.scan_line_width])
self.ax1.set_ylim([self.browser.number_of_scans, 0])
self.ax1.imshow(image_data, aspect='auto', cmap='gray')
self.ax1.plot([0, self.browser.scan_line_width], [self.browser.plot_scanline, self.browser.plot_scanline])
self.ax2.set_xlim([self.browser.scan_line_width, 0]
if self.browser.flip_horizontal else [0, self.browser.scan_line_width])
self.ax2.set_ylim([-0.5, 0.5])
self.ax2.set_xlabel("Offset (relative)")
self.ax2.set_ylabel("signal")
self.ax2.plot(range(len(image_data[self.browser.plot_scanline])), image_data[self.browser.plot_scanline])
if self.mpltlib3:
self.canvas.draw()
else:
self.canvas.show()
else:
self.browser.view_offset_exceeded_error()
self.browser.root.config(cursor="")
def view_init(self):
self.frame = tk.LabelFrame(self.browser.workframe, text=" Image ")
self.frame.pack(side=tk.LEFT, fill=tk.BOTH, expand=True, padx=7, pady=7)
self.figure = plt.figure(figsize=(8, 12), dpi=70)
self.ax1 = plt.subplot2grid((50,40), (0, 0), rowspan=40, colspan=40)
self.ax2 = plt.subplot2grid((50,40), (42, 0), rowspan=8, colspan=40, sharex=self.ax1)
plt.subplots_adjust(left=0.1, bottom=0.05, right=0.95, top=0.97, wspace=0.2, hspace=0.2)
self.view_plot_image()
self.canvas = FigureCanvasTkAgg(self.figure, self.frame)
if self.mpltlib3:
self.canvas.draw()
toolbar = NavigationToolbar2Tk(self.canvas, self.frame).update()
else:
self.canvas.show()
toolbar = NavigationToolbar2TkAgg(self.canvas, self.frame).update()
self.canvas.get_tk_widget().pack(side=tk.BOTTOM, fill=tk.BOTH, expand=True)
self.canvas._tkcanvas.pack(side=tk.TOP, fill=tk.BOTH, padx=2, pady=2, expand=True)
self.frame.pack(side=tk.LEFT, fill=tk.BOTH, expand=True, padx=7, pady=7)
def __init__(self, parent, mpltlib3=True):
self.mpltlib3 = mpltlib3
self.browser = parent
self.model_init()
self.view_init()
class OffsetControl(object):
def model_modify_offset(self, sign):
if self.browser.audio_data is not None:
maxsize = len(self.browser.audio_data) - 1
textvariable = self.offset_entry.textvariable_as_int()
if textvariable is None:
return
if textvariable == self.browser.offset:
delta = {
"1" : 1,
"10" : 10,
"100" : 100,
"1000" : 1000,
"NoS x SLW" : self.browser.number_of_scans * self.browser.scan_line_width,
"100 x SLW" : 100 * self.browser.scan_line_width,
"10 x SLW" : 10 *self.browser.scan_line_width,
"1 x SLW" : self.browser.scan_line_width
}[self.interval_value_variable.get()]
if sign == "+":
self.browser.offset += delta
else:
self.browser.offset -= delta
None
self.offset_entry.textvariable.set(self.browser.offset)
else:
self.browser.offset = int(self.offset_entry.textvariable.get())
None
if self.browser.offset < 0:
self.browser.offset = 0
self.offset_entry.textvariable.set(0)
if self.browser.offset > maxsize:
self.browser.offset = maxsize
self.offset_entry.textvariable.set(maxsize)
self.browser.imager.view_plot_image()
else:
self.browser.view_nodata_error()
def model_increment_offset(self):
self.model_modify_offset("+")
def model_decrement_offset(self):
self.model_modify_offset("-")
def model_sync_with_entry(self, *args):
if self.browser.audio_data is not None:
textvariable_as_int = self.offset_entry.textvariable_as_int()
if textvariable_as_int is None:
return
maxsize = len(self.browser.audio_data) - 1
if textvariable_as_int < 0:
self.browser.offset = 0
self.offset_entry.textvariable.set("0")
elif textvariable_as_int > maxsize:
self.browser.offset = maxsize
self.offset_entry.textvariable.set(str(maxsize))
else:
self.browser.offset = textvariable_as_int
else:
print("No audio data in memory!!")
def model_init(self):
self.interval_value_variable = tk.StringVar()
self.interval_value_variable.set(1000)
def view_init(self):
self.frame = tk.LabelFrame(self.controlwidgets.frame, text=" Offset ")
ftop = tk.Frame(self.frame)
fbottom = tk.Frame(self.frame)
self.offset_entry = NumericalIntEntry(ftop)
self.offset_entry.textvariable.set("0")
self.offset_entry.textvariable.trace("w", self.model_sync_with_entry)
self.offset_entry.Entry.pack(side=tk.LEFT, fill=tk.X, expand=True)
tk.Button(ftop, text="sub", width=1, command=self.model_decrement_offset).pack(side=tk.LEFT)
tk.Button(ftop, text="add", width=1, command=self.model_increment_offset).pack(side=tk.LEFT)
_mm = tk.Frame(fbottom)
for radiobutrow in [["1000", "100", "10", "1"], ["NoS x SLW", "100 x SLW", "10 x SLW", "1 x SLW"]]:
_mmm = tk.Frame(_mm)
for interval_value in radiobutrow:
_m = tk.Radiobutton(_mmm,
text="%s" % (interval_value),
indicatoron=0,
foreground="#940015",
variable=self.interval_value_variable,
value=interval_value,
width=1
)
_m.pack(side=tk.TOP, fill=tk.X, expand=True)
_mmm.pack(side=tk.LEFT, fill=tk.X, expand=True)
None
_mm.pack(side=tk.BOTTOM, fill=tk.X, expand=True)
ftop.pack(side=tk.TOP, fill=tk.BOTH, padx=4, pady=4, expand=True)
fbottom.pack(side=tk.TOP, fill=tk.BOTH, padx=4, pady=4, expand=True)
self.frame.pack(side=tk.TOP, fill=tk.X, padx=7, pady=7, expand=False)
def __init__(self, parent):
self.controlwidgets = parent
self.browser = parent.browser
self.model_init()
self.view_init()
class ScanLineWidthControl(object):
def model_increase(self):
newvalue = self.scan_line_width_entry.textvariable_as_int() + 1
self.scan_line_width_entry.textvariable.set(str(newvalue))
def model_decrease(self):
newvalue = self.scan_line_width_entry.textvariable_as_int() - 1
self.scan_line_width_entry.textvariable.set(str(newvalue))
def model_sync_with_entry(self, *args):
if self.browser.audio_data is not None:
textvariable_as_int = self.scan_line_width_entry.textvariable_as_int()
if textvariable_as_int is None:
return
if textvariable_as_int < 0:
self.browser.scan_line_width = 0
self.scan_line_width_entry.textvariable.set(0)
else:
self.browser.scan_line_width = textvariable_as_int
def __init__(self, parent):
self.parent = parent
self.browser = parent.browser
self.frame = tk.LabelFrame(self.parent.frame, text=" Scan line width (SLW)")
self.scan_line_width_entry = NumericalIntEntry(self.frame)
self.scan_line_width_entry.textvariable.set(3197)
self.scan_line_width_entry.textvariable.trace("w", self.model_sync_with_entry)
self.scan_line_width_entry.Entry.pack(side=tk.LEFT, fill=tk.X, padx=4, pady=4, expand=True)
tk.Button(self.frame, text="-", command=self.model_decrease).pack(side=tk.LEFT)
tk.Button(self.frame, text="+", command=self.model_increase).pack(side=tk.LEFT)
self.frame.pack(side=tk.TOP, fill=tk.X, padx=7, pady=7, expand=False)
class NumberOfScansControl(object):
def model_increase(self):
newvalue = self.number_of_scans_entry.textvariable_as_int() + 1
self.number_of_scans_entry.textvariable.set(str(newvalue))
def model_decrease(self):
newvalue = self.number_of_scans_entry.textvariable_as_int() - 1
self.number_of_scans_entry.textvariable.set(str(newvalue))
def model_sync_with_entry(self, *args):
if self.browser.audio_data is not None:
textvariable_as_int = self.number_of_scans_entry.textvariable_as_int()
if textvariable_as_int is None:
return
if textvariable_as_int < 0:
self.browser.number_of_scans = 0
self.number_of_scans_entry.textvariable.set(0)
else:
self.browser.number_of_scans = textvariable_as_int
def __init__(self, parent):
self.parent = parent
self.browser = parent.browser
self.frame = tk.LabelFrame(self.parent.frame, text=" Number of scans (NoS) per image ")
self.number_of_scans_entry = NumericalIntEntry(self.frame)
self.number_of_scans_entry.textvariable.set(512)
self.number_of_scans_entry.textvariable.trace("w", self.model_sync_with_entry)
self.number_of_scans_entry.Entry.pack(side=tk.LEFT, fill=tk.X, padx=4, pady=4, expand=True)
tk.Button(self.frame, text="-", command=self.model_decrease).pack(side=tk.LEFT)
tk.Button(self.frame, text="+", command=self.model_increase).pack(side=tk.LEFT)
self.frame.pack(side=tk.TOP, fill=tk.X, padx=7, pady=7, expand=False)
class AdjustControl(object):
def model_increase(self):
newvalue = self.adjust_control_entry.textvariable_as_float() + 0.01
self.adjust_control_entry.textvariable.set("%2.3f" % (newvalue))
def model_decrease(self):
newvalue = self.adjust_control_entry.textvariable_as_float() - 0.01
self.adjust_control_entry.textvariable.set("%2.3f" % (newvalue))
def model_sync_with_entry(self, *args):
if self.browser.audio_data is not None:
textvariable_as_float = self.adjust_control_entry.textvariable_as_float()
if textvariable_as_float is None:
return
self.browser.adjust = textvariable_as_float
def __init__(self, parent):
self.parent = parent
self.browser = parent.browser
self.frame = tk.LabelFrame(self.parent.frame, text=" Offset Adjust ")
self.adjust_control_entry = NumericalFloatEntry(self.frame)
self.adjust_control_entry.textvariable.set(0)
self.adjust_control_entry.textvariable.trace("w", self.model_sync_with_entry)
self.adjust_control_entry.Entry.pack(side=tk.LEFT, fill=tk.X, padx=4, pady=4, expand=True)
tk.Button(self.frame, text="-", command=self.model_decrease).pack(side=tk.LEFT)
tk.Button(self.frame, text="+", command=self.model_increase).pack(side=tk.LEFT)
self.frame.pack(side=tk.TOP, fill=tk.X, padx=7, pady=7, expand=False)
class ScanlinePlotSliderControl(object):
def model_increase(self):
self.scale.set(self.scale.get() + 1)
def model_decrease(self):
self.scale.set(self.scale.get() - 1)
def model_sync_with_entry(self, v):
self.browser.plot_scanline = int(v)
def model_slide_range_update(self, *args):
newmax = self.parent.numberofscans.number_of_scans_entry.textvariable_as_int()
if self.browser.plot_scanline > newmax:
self.browser.plot_scanline = newmax
self.scale.configure(to=newmax)
def __init__(self, parent):
self.parent = parent
self.browser = parent.browser
self.frame = tk.LabelFrame(self.parent.frame, text=" Plot scanline ")
self.scale = tk.Scale(self.frame, from_=0, to=self.browser.number_of_scans,
orient=tk.HORIZONTAL, showvalue=True, command=self.model_sync_with_entry )
self.scale.pack(side=tk.LEFT, fill=tk.X, padx=4, pady=4, anchor=tk.CENTER, expand=True)
self.parent.numberofscans.number_of_scans_entry.textvariable.trace("w", self.model_slide_range_update)
tk.Button(self.frame, text="-", command=self.model_decrease).pack(side=tk.LEFT)
tk.Button(self.frame, text="+", command=self.model_increase).pack(side=tk.LEFT)
self.frame.pack(side=tk.TOP, fill=tk.X, padx=7, pady=7, expand=False)
class ControlWidgets(object):
def __init__(self, parent):
self.browser = parent
self.frame = tk.Frame(self.browser.workframe)
self.scansize = ScanLineWidthControl(self)
self.numberofscans = NumberOfScansControl(self)
self.adjust = AdjustControl(self)
self.scanlineplot = ScanlinePlotSliderControl(self)
self.offset = OffsetControl(self)
self.plotbutton = tk.Button(self.frame, text="REPLOT", height=3,
command=self.browser.imager.view_plot_image, relief=tk.GROOVE, borderwidth=4)
self.plotbutton.pack(side=tk.TOP, fill=tk.X, padx=4, pady=4, expand=False)
self.frame.pack(side=tk.LEFT, fill=tk.BOTH, expand=True)
class VoyagerBrowser(object):
def model_load_audio_data(self, filename):
self.root.config(cursor="watch")
self.root.update()
self.rate, self.audio_data = scipy.io.wavfile.read(filename)
self.root.config(cursor="")
def model_init(self):
self.audio_data = None
self.offset = 0
self.scan_line_width = 3197
self.number_of_scans = 512
self.adjust = 0
self.plot_scanline = 0
self.invert_signal = False
self.flip_horizontal = False
self.offset_exceeded = False
def on_close(self):
print("Bye!")
self.root.destroy()
sys.exit(0)
def view_init(self, mpltlib3):
self.root = tk.Tk()
self.workframe = tk.Frame(self.root)
self.menu = FileMenu(self)
self.imager = Imager(self, mpltlib3)
self.controlwidgets = ControlWidgets(self)
self.workframe.pack(side=tk.LEFT, fill=tk.BOTH, expand=True)
self.root.protocol("WM_DELETE_WINDOW", self.on_close)
self.root.title("Voyager Audio Image Browser")
def view_nodata_error(self):
print("No data in memory to plot yet!!")
messagebox.showerror("Error", "No data in memory to plot yet!!")
def view_offset_exceeded_error(self):
print("Cannot plot. End of data!!")
messagebox.showerror("Error", "Cannot plot. End of data!!")
def view_mainloop(self):
self.root.mainloop()
def __init__(self, mpltlib3=True):
self.model_init()
self.view_init(mpltlib3)
self.view_mainloop()
if __name__ == "__main__":
VoyagerBrowser(mpltlib3)
