365 lines
12 KiB
Python
365 lines
12 KiB
Python
"""
|
|
Flask web UI for HPGL plotter.
|
|
Run from project root so Command, Program, Plotter, hpgl_svg, config can be imported.
|
|
"""
|
|
import os
|
|
import sys
|
|
import uuid
|
|
from flask import Flask, request, jsonify, session, send_from_directory, render_template
|
|
|
|
# Run from project root (parent of webui)
|
|
ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
|
|
if ROOT not in sys.path:
|
|
sys.path.insert(0, ROOT)
|
|
|
|
from Command import Command
|
|
from Program import Program
|
|
from Plotter import Plotter
|
|
from hpgl_svg import program_to_svg
|
|
from text_to_hpgl import text_to_hpgl
|
|
|
|
try:
|
|
from config import webui_secret_key, webui_max_upload_mb
|
|
except ImportError:
|
|
webui_secret_key = lambda: os.environ.get('SECRET_KEY', 'change-me-in-production')
|
|
webui_max_upload_mb = lambda: 16
|
|
|
|
app = Flask(__name__, static_folder='static', template_folder='templates')
|
|
app.secret_key = webui_secret_key()
|
|
app.config['MAX_CONTENT_LENGTH'] = webui_max_upload_mb() * 1024 * 1024
|
|
UPLOAD_DIR = os.path.join(ROOT, 'webui', 'uploads')
|
|
os.makedirs(UPLOAD_DIR, exist_ok=True)
|
|
OUTPUT_HPGL_DIR = os.path.join(ROOT, 'output', 'hpgl')
|
|
FONT_DIRS = [
|
|
os.path.join(ROOT, 'font'),
|
|
os.path.join(ROOT, '.git', 'font'),
|
|
]
|
|
|
|
|
|
def _resolve_font(filename):
|
|
"""Return full path to font file if found in FONT_DIRS, else None."""
|
|
for d in FONT_DIRS:
|
|
if not os.path.isdir(d):
|
|
continue
|
|
path = os.path.join(d, filename)
|
|
if os.path.isfile(path):
|
|
return path
|
|
return None
|
|
|
|
|
|
def _list_fonts():
|
|
"""Return list of font filenames (.otf, .ttf) from FONT_DIRS."""
|
|
seen = set()
|
|
out = []
|
|
for d in FONT_DIRS:
|
|
if not os.path.isdir(d):
|
|
continue
|
|
for name in sorted(os.listdir(d)):
|
|
low = name.lower()
|
|
if (low.endswith('.otf') or low.endswith('.ttf')) and name not in seen:
|
|
seen.add(name)
|
|
out.append(name)
|
|
return out
|
|
|
|
|
|
def _get_program():
|
|
path = session.get('upload_path')
|
|
if not path or not os.path.isfile(path):
|
|
return None
|
|
try:
|
|
return Program.parsefile(path)
|
|
except Exception:
|
|
return None
|
|
|
|
|
|
def _save_program(program, path=None):
|
|
path = path or session.get('upload_path')
|
|
if not path:
|
|
return None
|
|
with open(path, 'w') as f:
|
|
f.write(str(program))
|
|
return path
|
|
|
|
|
|
@app.route('/')
|
|
def index():
|
|
return render_template('index.html')
|
|
|
|
|
|
@app.route('/api/fonts')
|
|
def list_fonts():
|
|
"""List font filenames in font/ and .git/font/."""
|
|
return jsonify({'fonts': _list_fonts()})
|
|
|
|
|
|
@app.route('/api/text_to_hpgl', methods=['POST'])
|
|
def api_text_to_hpgl():
|
|
"""Generate HPGL from text and font; save as current program."""
|
|
data = request.get_json() or {}
|
|
text = (data.get('text') or '').strip()
|
|
font_name = data.get('font') or ''
|
|
size_pt = data.get('size_pt', 72)
|
|
if not text:
|
|
return jsonify({'error': 'Enter some text.'}), 400
|
|
if not font_name:
|
|
return jsonify({'error': 'Select a font.'}), 400
|
|
font_path = _resolve_font(font_name)
|
|
if not font_path:
|
|
return jsonify({'error': 'Font not found: {}'.format(font_name)}), 400
|
|
try:
|
|
hpgl = text_to_hpgl(text, font_path, size_pt=size_pt)
|
|
Program.parse(hpgl) # validate
|
|
except Exception as e:
|
|
return jsonify({'error': 'Text to HPGL failed: {}'.format(str(e))}), 400
|
|
name = str(uuid.uuid4()) + '.hpgl'
|
|
path = os.path.join(UPLOAD_DIR, name)
|
|
with open(path, 'w') as out:
|
|
out.write(hpgl)
|
|
session['upload_path'] = path
|
|
session['upload_filename'] = 'text_{}.hpgl'.format(font_name)
|
|
return jsonify({'ok': True, 'filename': session['upload_filename'], 'preview_url': '/api/svg'})
|
|
|
|
|
|
@app.route('/api/hpgl_files')
|
|
def list_hpgl_files():
|
|
"""List HPGL filenames in output/hpgl/."""
|
|
if not os.path.isdir(OUTPUT_HPGL_DIR):
|
|
return jsonify({'files': []})
|
|
files = []
|
|
for name in sorted(os.listdir(OUTPUT_HPGL_DIR)):
|
|
if name.startswith('.'):
|
|
continue
|
|
path = os.path.join(OUTPUT_HPGL_DIR, name)
|
|
if not os.path.isfile(path):
|
|
continue
|
|
low = name.lower()
|
|
if low.endswith('.hpgl') or low.endswith('.plt') or '.' not in name:
|
|
files.append(name)
|
|
return jsonify({'files': files})
|
|
|
|
|
|
@app.route('/api/load_hpgl', methods=['POST'])
|
|
def load_hpgl_from_folder():
|
|
"""Set current program from a file in output/hpgl/."""
|
|
data = request.get_json() or {}
|
|
filename = (data.get('filename') or '').strip()
|
|
if not filename:
|
|
return jsonify({'error': 'No filename'}), 400
|
|
if os.path.basename(filename) != filename or '..' in filename:
|
|
return jsonify({'error': 'Invalid filename'}), 400
|
|
path = os.path.join(OUTPUT_HPGL_DIR, filename)
|
|
if not os.path.isfile(path):
|
|
return jsonify({'error': 'File not found'}), 404
|
|
try:
|
|
Program.parsefile(path)
|
|
except Exception as e:
|
|
return jsonify({'error': 'Invalid HPGL: {}'.format(str(e))}), 400
|
|
session['upload_path'] = path
|
|
session['upload_filename'] = filename
|
|
return jsonify({'ok': True, 'filename': filename, 'preview_url': '/api/svg'})
|
|
|
|
|
|
@app.route('/api/upload', methods=['POST'])
|
|
def upload():
|
|
if 'file' not in request.files:
|
|
return jsonify({'error': 'No file'}), 400
|
|
f = request.files['file']
|
|
if not f.filename or not (f.filename.lower().endswith('.hpgl') or f.filename.lower().endswith('.plt')):
|
|
return jsonify({'error': 'Need an .hpgl or .plt file'}), 400
|
|
try:
|
|
content = f.read().decode('utf-8', errors='replace')
|
|
Program.parse(content) # validate
|
|
except Exception as e:
|
|
return jsonify({'error': 'Invalid HPGL: {}'.format(str(e))}), 400
|
|
name = str(uuid.uuid4()) + '.hpgl'
|
|
path = os.path.join(UPLOAD_DIR, name)
|
|
with open(path, 'w') as out:
|
|
out.write(content)
|
|
session['upload_path'] = path
|
|
session['upload_filename'] = f.filename
|
|
return jsonify({
|
|
'ok': True,
|
|
'filename': f.filename,
|
|
'preview_url': '/api/svg'
|
|
})
|
|
|
|
|
|
@app.route('/api/download_hpgl')
|
|
def download_hpgl():
|
|
"""Return current program as downloadable HPGL file."""
|
|
p = _get_program()
|
|
if p is None:
|
|
return jsonify({'error': 'No file loaded'}), 404
|
|
filename = (session.get('upload_filename') or 'export').strip()
|
|
if not filename.lower().endswith('.hpgl') and not filename.lower().endswith('.plt'):
|
|
filename = filename + '.hpgl'
|
|
return (
|
|
str(p),
|
|
200,
|
|
{
|
|
'Content-Type': 'application/octet-stream',
|
|
'Content-Disposition': 'attachment; filename="{}"'.format(filename),
|
|
},
|
|
)
|
|
|
|
|
|
@app.route('/api/dimensions')
|
|
def dimensions():
|
|
"""Return current program size in plotter units (e.g. 0.025 mm per unit)."""
|
|
p = _get_program()
|
|
if p is None:
|
|
return jsonify({'error': 'No file loaded'}), 404
|
|
w, h = p.winsize
|
|
return jsonify({
|
|
'width': round(w, 1),
|
|
'height': round(h, 1),
|
|
'width_mm': round(w * 0.025, 2),
|
|
'height_mm': round(h * 0.025, 2),
|
|
})
|
|
|
|
|
|
@app.route('/api/svg')
|
|
def get_svg():
|
|
p = _get_program()
|
|
if p is None:
|
|
return jsonify({'error': 'No file loaded'}), 404
|
|
width = request.args.get('width', 800, type=int)
|
|
height = request.args.get('height', 600, type=int)
|
|
show_scale = request.args.get('scale', '1').lower() in ('1', 'true', 'yes')
|
|
svg = program_to_svg(p, width=width, height=height, show_scale_bar=show_scale)
|
|
return svg, 200, {'Content-Type': 'image/svg+xml; charset=utf-8'}
|
|
|
|
|
|
@app.route('/api/transform', methods=['POST'])
|
|
def transform():
|
|
p = _get_program()
|
|
if p is None:
|
|
return jsonify({'error': 'No file loaded'}), 404
|
|
data = request.get_json() or {}
|
|
action = data.get('action')
|
|
if action == 'flip':
|
|
p = p.flip()
|
|
elif action == 'rotate':
|
|
angle = data.get('angle', 90)
|
|
p = p.rotate(angle)
|
|
elif action == 'scale':
|
|
factor = data.get('factor', 1.5)
|
|
p = p * factor
|
|
elif action == 'centralize':
|
|
p = p - p.center
|
|
elif action == 'scale_to_bounds':
|
|
xmin = data.get('xmin')
|
|
ymin = data.get('ymin')
|
|
xmax = data.get('xmax')
|
|
ymax = data.get('ymax')
|
|
if xmin is not None and ymin is not None and xmax is not None and ymax is not None:
|
|
if xmax <= xmin or ymax <= ymin:
|
|
return jsonify({'error': 'Invalid bounds: xmax > xmin and ymax > ymin required.'}), 400
|
|
p = p.fitin((xmin, ymin, xmax, ymax), (0.5, 0.5))
|
|
else:
|
|
try:
|
|
plt = Plotter()
|
|
if getattr(plt, 'boundaries', None) is None:
|
|
return jsonify({'error': 'Plotter not connected. Connect plotter or send bounds (xmin, ymin, xmax, ymax).'}), 400
|
|
p = plt.full(p)
|
|
except (OSError, AttributeError, TypeError):
|
|
return jsonify({'error': 'Plotter not connected. Connect plotter or send bounds (xmin, ymin, xmax, ymax).'}), 400
|
|
else:
|
|
return jsonify({'error': 'Unknown action'}), 400
|
|
_save_program(p)
|
|
return jsonify({'ok': True, 'preview_url': '/api/svg'})
|
|
|
|
|
|
@app.route('/api/print', methods=['POST'])
|
|
def print_to_plotter():
|
|
p = _get_program()
|
|
if p is None:
|
|
return jsonify({'error': 'No file loaded'}), 404
|
|
try:
|
|
plt = Plotter()
|
|
if getattr(plt, 'ser', None) is None:
|
|
return jsonify({'error': 'Plotter not connected. Connect plotter and try again.'}), 503
|
|
p = plt.full(p)
|
|
p = plt.centralize(p)
|
|
plt.write(p)
|
|
return jsonify({'ok': True})
|
|
except OSError as e:
|
|
return jsonify({'error': 'Plotter not connected: {}'.format(str(e))}), 503
|
|
except Exception as e:
|
|
return jsonify({'error': str(e)}), 500
|
|
|
|
|
|
@app.route('/api/status')
|
|
def status():
|
|
has_file = bool(session.get('upload_path')) and os.path.isfile(session.get('upload_path'))
|
|
plotter_ready = False
|
|
try:
|
|
plt = Plotter()
|
|
if getattr(plt, 'ser', None) is not None and getattr(plt, 'boundaries', None) is not None:
|
|
plotter_ready = plt.ready
|
|
except (OSError, AttributeError, TypeError):
|
|
pass
|
|
return jsonify({
|
|
'has_file': has_file,
|
|
'filename': session.get('upload_filename'),
|
|
'plotter_ready': plotter_ready
|
|
})
|
|
|
|
|
|
@app.route('/api/plotter_info')
|
|
def plotter_info():
|
|
"""Return plotter connection and media dimensions for display under the print button."""
|
|
try:
|
|
from config import plotter_port, plotter_baudrate
|
|
except ImportError:
|
|
plotter_port = lambda: '/dev/ttyUSB0'
|
|
plotter_baudrate = lambda: 9600
|
|
port = plotter_port()
|
|
baudrate = plotter_baudrate()
|
|
connected = False
|
|
ready = False
|
|
boundaries = None
|
|
winsize_units = None
|
|
winsize_mm = None
|
|
try:
|
|
plt = Plotter()
|
|
if getattr(plt, 'ser', None) is not None and getattr(plt, 'boundaries', None) is not None:
|
|
connected = True
|
|
ready = plt.ready
|
|
try:
|
|
boundaries = {
|
|
'xmin': plt.xmin,
|
|
'ymin': plt.ymin,
|
|
'xmax': plt.xmax,
|
|
'ymax': plt.ymax,
|
|
}
|
|
w, h = plt.winsize
|
|
winsize_units = {'width': round(w, 1), 'height': round(h, 1)}
|
|
winsize_mm = {'width': round(w * 0.025, 1), 'height': round(h * 0.025, 1)}
|
|
except (AttributeError, TypeError):
|
|
pass
|
|
except (OSError, AttributeError, TypeError):
|
|
pass
|
|
return jsonify({
|
|
'port': port,
|
|
'baudrate': baudrate,
|
|
'connected': connected,
|
|
'ready': ready,
|
|
'boundaries': boundaries,
|
|
'winsize_units': winsize_units,
|
|
'winsize_mm': winsize_mm,
|
|
})
|
|
|
|
|
|
if __name__ == '__main__':
|
|
try:
|
|
from config import webui_host, webui_port
|
|
except ImportError:
|
|
webui_host = lambda: '0.0.0.0'
|
|
webui_port = lambda: 5000
|
|
app.run(
|
|
host=webui_host(),
|
|
port=webui_port(),
|
|
debug=os.environ.get('FLASK_DEBUG', '0') == '1'
|
|
)
|