Correct a silly bug in saving the wow file

main.py

@@ -5,6 +5,7 @@ import os
 import wow
 import tkinter as tk
 import tkinter.filedialog
+import tkinter.messagebox
 import sys
 
 
@@ -15,7 +16,7 @@ except ImportError:
     try:
         import git
         r = git.repo.Repo('./')
-        version = r.git.describe("--tags")
+        version = r.git.describe("--tags", "--dirty")
     except ImportError:
         version = "?version unknown?"
 
@@ -23,6 +24,8 @@ from PIL import ImageTk
 
 class WOWFileViewer:
 
+    _Types = ("Thickness", "Speed up", "Exposure level", "Speed down", "Exposure time", "Up movement distance")
+
     def __init__(self, master, wowfile):
         self.currentLayer = 0
         self.master = master
@@ -33,54 +36,98 @@ class WOWFileViewer:
 
         self.layer = wowfile.get_layer(self.currentLayer)
 
-        self.label = tk.Label(master, text="Layer: {num} / {tot}".format(num=self.layer.number, tot=self.layer_count))
+        # Configure columns and row
-        self.label.grid(row=1, columnspan=4)
+        self.master.columnconfigure(1, weight=1)
+        self.master.columnconfigure(4, weight=1)
+        self.master.rowconfigure(2, weight=1)
 
+        # Row 1
+        self.label = tk.Label(master, text="Layer: {num} / {tot}".format(num=self.layer.number, tot=self.layer_count))
+        self.label.grid(row=1, columnspan=6)
+
+        self.layern_var = tk.StringVar()
+        self.layern_var.set(str(self.layer.number))
+        self.layern_ent = tk.Entry(master, textvariable=self.layern_var, width=6)
+        self.layern_ent.grid(row=1, column=7, sticky=tk.E+tk.W)
+        self.layern_btn = tk.Button(master, text=" Change ", command=self.layerManualSet)
+        self.layern_btn.grid(row=1, column=8, sticky=tk.E+tk.W+tk.N+tk.S)
+
+        # Row 2
         self.img = ImageTk.PhotoImage(self.layer.image)
         self.layer_img = tk.Label(master, image=self.img)
-        self.layer_img.grid(row=2, column=1, columnspan=3)
+        self.layer_img.grid(row=2, column=1, columnspan=7)
 
         tickinterval = self.layer_count/10
         self.layer_select = tk.Scale(master, from_=1, to=self.layer_count,
                                      command=self.sliderUpdate, orient=tk.VERTICAL,
-                                     resolution=1, length=400, tickinterval=tickinterval)
+                                     resolution=-1, length=400, tickinterval=tickinterval,
-        self.layer_select.grid(row=2, column=4)
+                                     takefocus=1)
+        self.layer_select.grid(row=2, column=8, sticky=tk.E+tk.W+tk.N+tk.S)
 
+        # Row 3
         self.thick_var = tk.StringVar()
         self.thick_var.set(str(self.layer.thickness * 1000))
         self.thick_lbl = tk.Label(master, text="Layer thickness (µm): ")
         self.thick_lbl.grid(row=3, column=1, sticky=tk.E)
-        self.thick_ent = tk.Entry(master, textvariable=self.thick_var)
+        self.thick_ent = tk.Entry(master, textvariable=self.thick_var, width=10)
-        self.thick_ent.grid(row=3, column=2, sticky=tk.W)
+        self.thick_ent.grid(row=3, column=2, sticky=tk.E + tk.W)
-
+        self.thick_btn = tk.Button(master, text="A",
-        self.exp_var = tk.StringVar()
+                                   command=lambda: self.applyValueToAllLayer(1, self.thick_var.get()))
-        self.exp_var.set(str(self.layer.exposition))
+        self.thick_btn.grid(row=3, column=3, sticky=tk.E + tk.W + tk.N + tk.S)
-        self.exp_lbl = tk.Label(master, text="Layer exposure level (0-255): ")
-        self.exp_lbl.grid(row=4, column=1, sticky=tk.E)
-        self.exp_ent = tk.Entry(master, textvariable=self.exp_var)
-        self.exp_ent.grid(row=4, column=2, sticky=tk.W)
 
         self.spdu_var = tk.StringVar()
         self.spdu_var.set(str(self.layer.speed_up))
         self.spdu_lbl = tk.Label(master, text="Speed up (mm/min): ")
-        self.spdu_lbl.grid(row=3, column=3, sticky=tk.E)
+        self.spdu_lbl.grid(row=3, column=4, sticky=tk.E)
-        self.spdu_ent = tk.Entry(master, textvariable=self.spdu_var)
+        self.spdu_ent = tk.Entry(master, textvariable=self.spdu_var, width=10)
-        self.spdu_ent.grid(row=3, column=4, sticky=tk.W)
+        self.spdu_ent.grid(row=3, column=5, sticky=tk.E + tk.W)
+        self.spdu_btn = tk.Button(master, text="A",
+                                  command=lambda: self.applyValueToAllLayer(2, self.spdu_var.get()))
+        self.spdu_btn.grid(row=3, column=6, sticky=tk.E + tk.W + tk.N + tk.S)
+
+        # Row 4
+        self.exp_var = tk.StringVar()
+        self.exp_var.set(str(self.layer.exposition))
+        self.exp_lbl = tk.Label(master, text="Layer exposure level (0-255): ")
+        self.exp_lbl.grid(row=4, column=1, sticky=tk.E)
+        self.exp_ent = tk.Entry(master, textvariable=self.exp_var, width=10)
+        self.exp_ent.grid(row=4, column=2, sticky=tk.E+tk.W)
+        self.exp_btn = tk.Button(master, text="A",
+                                  command=lambda: self.applyValueToAllLayer(3, self.exp_var.get()))
+        self.exp_btn.grid(row=4, column=3, sticky=tk.E + tk.W + tk.N + tk.S)
 
         self.spdd_var = tk.StringVar()
         self.spdd_var.set(str(self.layer.speed_down))
         self.spdd_lbl = tk.Label(master, text="Speed down (mm/min): ")
-        self.spdd_lbl.grid(row=4, column=3, sticky=tk.E)
+        self.spdd_lbl.grid(row=4, column=4, sticky=tk.E)
-        self.spdd_ent = tk.Entry(master, textvariable=self.spdd_var)
+        self.spdd_ent = tk.Entry(master, textvariable=self.spdd_var, width=10)
-        self.spdd_ent.grid(row=4, column=4, sticky=tk.W)
+        self.spdd_ent.grid(row=4, column=5, sticky=tk.E+tk.W)
+        self.spdd_btn = tk.Button(master, text="A",
+                                  command=lambda: self.applyValueToAllLayer(4, self.spdd_var.get()))
+        self.spdd_btn.grid(row=4, column=6, sticky=tk.E + tk.W + tk.N + tk.S)
 
+        # Row 5
         self.expt_var = tk.StringVar()
         self.expt_var.set(str(self.layer.exposition_time))
         self.expt_lbl = tk.Label(master, text="Layer exposure time (in sec): ")
         self.expt_lbl.grid(row=5, column=1, sticky=tk.E)
-        self.expt_ent = tk.Entry(master, textvariable=self.expt_var)
+        self.expt_ent = tk.Entry(master, textvariable=self.expt_var, width=10)
-        self.expt_ent.grid(row=5, column=2, sticky=tk.W)
+        self.expt_ent.grid(row=5, column=2, sticky=tk.E+tk.W)
+        self.expt_btn = tk.Button(master, text="A",
+                                  command=lambda: self.applyValueToAllLayer(5, self.expt_var.get()))
+        self.expt_btn.grid(row=5, column=3, sticky=tk.E + tk.W + tk.N + tk.S)
 
+        self.updist_var = tk.StringVar()
+        self.updist_var.set(str(self.layer.up_distance))
+        self.updist_lbl = tk.Label(master, text="Up mvmt distance (mm): ")
+        self.updist_lbl.grid(row=5, column=4, sticky=tk.E)
+        self.updist_ent = tk.Entry(master, textvariable=self.updist_var, width=10)
+        self.updist_ent.grid(row=5, column=5, sticky=tk.E + tk.W)
+        self.updist_btn = tk.Button(master, text="A",
+                                  command=lambda: self.applyValueToAllLayer(6, self.updist_var.get()))
+        self.updist_btn.grid(row=5, column=6, sticky=tk.E + tk.W + tk.N + tk.S)
+
+        # Row 6
         self.printtime_var = tk.StringVar()
         self.printtime_var.set(str(wowfile.get_printtime(human_readable=True)))
         self.printtime_lbl = tk.Label(master, text="Estimated print time: ")
@@ -88,32 +135,87 @@ class WOWFileViewer:
         self.printtime_ent = tk.Label(master, textvariable=self.printtime_var)
         self.printtime_ent.grid(row=6, column=2, sticky=tk.W)
 
-        self.close_button2 = tk.Button(master, text=" Exit ", command=master.quit)
+        self.apply_btn = tk.Button(master, text=" Apply Changes ", command=self.applyLayerChange)
-        self.close_button2.grid(row=6, column=4)
+        self.apply_btn.grid(row=6, column=5, sticky=tk.E+tk.W+tk.N+tk.S)
+
+        self.saveas_btn = tk.Button(master, text=" Save As ", command=self.saveAsNewFile)
+        self.saveas_btn.grid(row=6, column=6, columnspan=2, sticky=tk.E+tk.W+tk.N+tk.S)
+
+        self.close_btn = tk.Button(master, text=" Exit ", command=master.quit)
+        self.close_btn.grid(row=6, column=8, sticky=tk.E+tk.W+tk.N+tk.S)
+
+        self.layer_select.focus_force()
+
+    def applyLayerChange(self):
+        try:
+            self.layer.thickness = round(float(self.thick_var.get()) / 1000, 10)
+            self.layer.exposition = float(self.exp_var.get())
+            self.layer.exposition_time = float(self.expt_var.get())
+            self.layer.speed_up = float(self.spdu_var.get())
+            self.layer.speed_down = float(self.spdd_var.get())
+            self.layer.up_distance = float(self.updist_var.get())
+            self.layer.update_movetime()
+
+            self.printtime_var.set(str(self.wowfile.get_printtime(human_readable=True)))
+            self.layerChange(self.layer.number)
+        except ValueError:
+            tk.messagebox.showerror("WoW File Viewer", "Value error:\nOne of the layer field is invalid, please check")
+
+    def applyValueToAllLayer(self, type, value):
+        strtype = self._Types[type-1]
+        answer = tk.messagebox.askyesno("WoW File Viewer", "Are you sure you want to apply the value '{value}'\n"
+                                                           "to all layer for '{type}'?".format(value=value,
+                                                                                               type=strtype))
+        if answer == tk.YES:
+            # The fun begins!
+            try:
+                for l in self.wowfile.layers:
+                    if type == 1: # Thickness
+                        l.thickness = round(float(value) / 1000, 10)
+                    elif type == 2: # Speed up
+                        l.speed_up = round(float(value), 5)
+                    elif type == 3:  # Exposure
+                        l.exposition = round(float(value), 5)
+                    elif type == 4:  # Speed down
+                        l.speed_down = round(float(value), 5)
+                    elif type == 5:  # Exposure time
+                        l.exposition_time = round(float(value), 5)
+                    elif type == 6:  # Up movement distance
+                        l.up_distance = round(float(value), 5)
+
+                    l.update_movetime()
+
+                self.printtime_var.set(str(self.wowfile.get_printtime(human_readable=True)))
+                self.layerChange(self.layer.number)
+            except ValueError:
+                tk.messagebox.showerror("WoW File Viewer",
+                                        "Value error:\n"
+                                        "The value {value} is not valid, please check".format(value=value))
+
+    def saveAsNewFile(self):
+        newfile = tk.filedialog.asksaveasfilename(defaultextension=".wow",
+                                                  filetypes=(("WOW print file", "*.wow"),("All files", "*.*")))
+        self.wowfile.write_wow(newfile)
 
     def sliderUpdate(self, pos):
         self.layerChange(int(pos))
 
-    def layerUp(self):
+    def layerManualSet(self):
-        if self.currentLayer < self.wowfile.get_layercount():
+        self.layer_select.set(int(self.layern_var.get()))
-            self.currentLayer += 1
+        return True
-            self.layerChange(self.currentLayer)
-
-    def layerDown(self):
-        if self.currentLayer > 0:
-            self.currentLayer -= 1
-            self.layerChange(self.currentLayer)
 
     def layerChange(self, layer):
         self.layer = self.wowfile.get_layer(layer - 1)
         self.img = ImageTk.PhotoImage(self.layer.image)
         self.layer_img.configure(image=self.img)
         self.label.configure(text="Layer: {num} / {tot}".format(num=self.layer.number, tot=self.layer_count))
+        self.layern_var.set(str(self.layer.number))
         self.thick_var.set(str(self.layer.thickness * 1000))
         self.exp_var.set(str(self.layer.exposition))
         self.expt_var.set(str(self.layer.exposition_time))
         self.spdu_var.set(str(self.layer.speed_up))
         self.spdd_var.set(str(self.layer.speed_down))
+        self.updist_var.set(str(self.layer.up_distance))
 
 def main():
     print("WOW File viewer {ver}".format(ver=version))
@@ -129,6 +231,7 @@ def main():
     wowfile = wow.WowFile(filename)
     lbl = None
     my_gui = WOWFileViewer(root, wowfile)
+    root.focus_force()
     root.mainloop()
 
 

setup.py

@@ -6,7 +6,7 @@ from cx_Freeze import setup, Executable
 r = git.repo.Repo('./')
 
 targetName="wowviewer"
-__version__ = r.git.describe("--tags")
+__version__ = r.git.describe("--tags", "--dirty")
 
 split_ver = __version__.split(".")
 split_ver_last = split_ver[2].split("-")

wow.py

@@ -3,7 +3,14 @@
 import datetime
 from PIL import Image
 
-_DefaultMovement = 5  # in mm
+# Ignore movement which are larger than this value for:
+# - Layer thickness calculation
+# - Movement time
+# This is mainly to ignore the last movement made after the final layer
+# which as the gcode is made would screw the thickness calculation on that
+# layer. (There is nothing to know that the layer ended in that specific case)
+# TODO: this need to be improved in a way. This is not completely reliable
+_IgnoreMovementLargerThan = 15 # in mm
 
 
 class layer:
@@ -15,6 +22,8 @@ class layer:
         self.number = number
         self.speed_up = 0
         self.speed_down = 0
+        self.up_distance = 0
+        self.down_distance = 0
         self.exposition = 0
         self.data = b""
         self.width = 0
@@ -28,6 +37,15 @@ class layer:
         self.image = self.image.rotate(90, expand=True)
         self.data = data  # For now keep it until we have a packing function
 
+    def update_movetime(self):
+        if self.speed_up > 0 or self.speed_down > 0:
+            self.move_time = abs(self.up_distance) / (self.speed_up / 60)
+            self.move_time += abs(self.up_distance - self.thickness) / (self.speed_down / 60)
+        else:
+            # Absurdely huge number to show that there is a problem
+            # (movement set to 0 is not a wanted value)
+            self.move_time = 9999999
+
     def get_packed_image(self):
         return self.data
 
@@ -48,7 +66,13 @@ def _g1(code, cur_layer):
     for param in code:
         if param[0] == "Z" or param[0] == "z":
             distance = float(param[1:])
-            if abs(distance) <= _DefaultMovement:
+            if abs(distance) <= _IgnoreMovementLargerThan:
+
+                if distance > 0:
+                    cur_layer.up_distance = distance
+                else:
+                    cur_layer.down_distance = distance
+
                 cur_layer.thickness += distance
                 cur_layer.thickness = round(cur_layer.thickness, 5)
                 if speed is not 0:
@@ -116,14 +140,14 @@ class WowFile:
 
     _LayerStart = ";L:{layer:d};\n" \
         "M106 S0;\n" \
-        "G1 Z{up:,g} F{spdu:,g};\n" \
+        "G1 Z{up:,g} F{spdu:g};\n" \
-        "G1 Z{down:,g} F{spdd:,g};\n" \
+        "G1 Z{down:,g} F{spdd:g};\n" \
         "{{{{\n"
 
     _LayerEnd = "\n" \
         "}}}}\n" \
-        "M106 S{exp:,g};\n" \
+        "M106 S{exp:g};\n" \
-        "G4 S{wait:,g};\n"
+        "G4 S{wait:g};\n"
 
     def _decode(self, code, cur_layer):
         splitcode = code.strip(";").split(" ")
@@ -232,8 +256,8 @@ class WowFile:
             for l in self.layers:
                 # Write layer preamble
                 f.write(self._LayerStart.format(layer=l.number,
-                                                up=_DefaultMovement,
+                                                up=l.up_distance,
-                                                down=l.thickness - _DefaultMovement,
+                                                down=round(l.thickness - l.up_distance, 5),
                                                 spdu=l.speed_up,
                                                 spdd=l.speed_down).encode("ascii"))
                 # Write layer image