#!/usr/bin/env python3 ########################################################################### # # xasy2asy provides a Python interface to Asymptote # # # Authors: Orest Shardt, Supakorn Rassameemasmuang, and John C. Bowman # ########################################################################### import PyQt5.QtWidgets as QtWidgets import PyQt5.QtGui as QtGui import PyQt5.QtCore as QtCore import PyQt5.QtSvg as QtSvg import numpy as numpy import sys import os import signal import threading import string import subprocess import tempfile import re import shutil import copy import queue import io import atexit import DebugFlags import threading from typing import Optional import xasyUtils as xu import xasyArgs as xa import xasyOptions as xo import xasySvg as xs class AsymptoteEngine: """ Purpose: -------- Class that makes it possible for xasy to communicate with asy through a background pipe. It communicates with asy through a subprocess of an existing xasy process. Attributes: ----------- istream : input stream ostream : output stream keepFiles : keep communicated files tmpdir : temporary directory args : system call arguments to start a required subprocess asyPath : directory path to asymptote asyProcess : the subprocess through which xasy communicates with asy Virtual Methods: NULL ---------------- Static Methods: --------------- NULL Class Methods: -------------- NULL Object Methods: --------------- start() wait() stop() cleanup() """ xasy=chr(4)+'\n' def __init__( self, path=None, addrArgsParam: Optional[list[str]] = None, keepFiles=DebugFlags.keepFiles, keepDefaultArgs=True ): addrArgs = addrArgsParam or [] if path is None: path = xa.getArgs().asypath if path is None: opt = xo.BasicConfigs.defaultOpt opt.load() path = opt['asyPath'] if sys.platform[:3] == 'win': rx = 0 # stdin wa = 2 # stderr else: rx, wx = os.pipe() ra, wa = os.pipe() os.set_inheritable(rx, True) os.set_inheritable(wx, True) os.set_inheritable(ra, True) os.set_inheritable(wa, True) self.ostream = os.fdopen(wx, 'w') self.istream = os.fdopen(ra, 'r') self.keepFiles = keepFiles self.tmpdir = tempfile.mkdtemp(prefix='xasyData_')+os.sep if xa.getArgs().render: renderDensity=xa.getArgs().render else: try: renderDensity = xo.BasicConfigs.defaultOpt['renderDensity'] except: renderDensity = 2 renderDensity=max(renderDensity,1) self.args=addrArgs + [ '-xasy', '-noV', '-q', '-outformat=', '-inpipe=' + str(rx), '-outpipe=' + str(wa), '-render='+str(renderDensity), '-o', self.tmpdir] self.asyPath = path self.asyProcess = None def start(self): """ starts a subprocess (opens a pipe) """ try: if sys.platform[:3] == 'win': self.asyProcess = subprocess.Popen( [self.asyPath] + self.args, stdin=subprocess.PIPE, stderr=subprocess.PIPE, text=True ) self.ostream = self.asyProcess.stdin self.istream = self.asyProcess.stderr else: self.asyProcess = subprocess.Popen([self.asyPath] + self.args,close_fds=False) finally: atexit.register(self.cleanup) def wait(self): """ wait for the pipe to finish any outstanding communication """ if self.asyProcess.returncode is not None: return else: return self.asyProcess.wait() def __enter__(self): self.start() return self def __exit__(self, exc_type, exc_val, exc_tb): self.stop() self.wait() @property def tempDirName(self): return self.tmpdir def startThenStop(self): self.start() self.stop() self.wait() @property def active(self): if self.asyProcess is None: return False return self.asyProcess.returncode is None def stop(self): """ kill an active asyProcess and close the pipe """ if self.active: self.asyProcess.kill() def cleanup(self): """ terminate processes and cleans up communication files """ self.stop() if self.asyProcess is not None: self.asyProcess.wait() if not self.keepFiles: if os.path.isdir(self.tempDirName + os.sep): shutil.rmtree(self.tempDirName, ignore_errors=True) class asyTransform(QtCore.QObject): """ Purpose: -------- A python implementation of an asy transform. This class takes care of calibrating asymptote coordinate system with the one used in PyQt to handle all existing inconsistencies. To understand how this class works, having enough acquaintance with asymptote transform feature is required. It is a child class of QtCore.QObject class. Attributes: ----------- t : The tuple x, y, xx, xy, yx, yy : Coordinates corresponding to 6 entries _deleted : Private local flag Virtual Methods: NULL ---------------- Static Methods: NULL --------------- Class Methods: -------------- zero : Class method that returns an asyTransform object initialized with 6 zero entries fromQTransform : Class method that converts QTransform object to asyTransform object fromNumpyMatrix : Class method that converts transform matrix object to asyTransform object Object Methods: -------------- getRawCode : Returns the tuple entries getCode : Returns the textual format of the asy code corresponding to the given transform scale : Returns the scales version of the existing asyTransform toQTransform : Converts asy transform object to QTransform object identity : Return Identity asyTransform object isIdentity : Check whether the asyTransform object is identity object inverted : Applies the QTransform object's inverted method on the asyTransform object yflip : Returns y-flipped asyTransform object """ def __init__(self, initTuple, delete=False): """ Initialize the transform with a 6 entry tuple """ super().__init__() if isinstance(initTuple, (tuple, list)) and len(initTuple) == 6: self.t = initTuple self.x, self.y, self.xx, self.xy, self.yx, self.yy = initTuple self._deleted = delete else: raise TypeError("Illegal initializer for asyTransform") @property def deleted(self): return self._deleted @deleted.setter def deleted(self, value): self._deleted = value @classmethod def zero(cls): return asyTransform((0, 0, 0, 0, 0, 0)) @classmethod def fromQTransform(cls, transform: QtGui.QTransform): tx, ty = transform.dx(), transform.dy() xx, xy, yx, yy = transform.m11(), transform.m21(), transform.m12(), transform.m22() return asyTransform((tx, ty, xx, xy, yx, yy)) @classmethod def fromNumpyMatrix(cls, transform: numpy.ndarray): assert transform.shape == (3, 3) tx = transform[0, 2] ty = transform[1, 2] xx, xy, yx, yy = transform[0:2, 0:2].ravel().tolist()[0] return asyTransform((tx, ty, xx, xy, yx, yy)) def getRawCode(self): return xu.tuple2StrWOspaces(self.t) def getCode(self, asy2psmap = None): """ Obtain the asy code that represents this transform """ if asy2psmap is None: asy2psmap = asyTransform((0, 0, 1, 0, 0, 1)) if self.deleted: return 'zeroTransform' else: return (asy2psmap.inverted() * self * asy2psmap).getRawCode() def scale(self, s): return asyTransform((0, 0, s, 0, 0, s)) * self def toQTransform(self): return QtGui.QTransform(self.xx, self.yx, self.xy, self.yy, self.x, self.y) def __str__(self): """ Equivalent functionality to getCode(). It allows the expression str(asyTransform) to be meaningful """ return self.getCode() def isIdentity(self): return self == identity() def inverted(self): return asyTransform.fromQTransform(self.toQTransform().inverted()[0]) def __eq__(self, other): return list(self.t) == list(other.t) def __mul__(self, other): """ Define multiplication of transforms as composition """ if isinstance(other, tuple): if len(other) == 6: return self * asyTransform(other) elif len(other) == 2: return ((self.t[0] + self.t[2] * other[0] + self.t[3] * other[1]), (self.t[1] + self.t[4] * other[0] + self.t[5] * other[1])) else: raise Exception("Illegal multiplier of {:s}".format(str(type(other)))) elif isinstance(other, asyTransform): result = asyTransform((0, 0, 0, 0, 0, 0)) result.x = self.x + self.xx * other.x + self.xy * other.y result.y = self.y + self.yx * other.x + self.yy * other.y result.xx = self.xx * other.xx + self.xy * other.yx result.xy = self.xx * other.xy + self.xy * other.yy result.yx = self.yx * other.xx + self.yy * other.yx result.yy = self.yx * other.xy + self.yy * other.yy result.t = (result.x, result.y, result.xx, result.xy, result.yx, result.yy) return result elif isinstance(other, str): if other != 'cycle': raise TypeError else: return 'cycle' else: raise TypeError("Illegal multiplier of {:s}".format(str(type(other)))) def identity(): return asyTransform((0, 0, 1, 0, 0, 1)) def yflip(): return asyTransform((0, 0, 1, 0, 0, -1)) class asyObj(QtCore.QObject): """ Purpose: -------- A base class to create a Python object which contains all common data and behaviors required during the translation of an xasy object to its Asymptote code. Attributes: ----------- asyCode :The corresponding Asymptote code for the asyObj instance Virtual Methods: ---------------- updateCode :Must to be re-implemented Static Methods: NULL -------------- Class Methods: NULL -------------- Object Methods: --------------- getCode :Return the Asymptote code that corresponds to the passed object """ def __init__(self): """ Initialize the object """ super().__init__() self.asyCode = '' def updateCode(self, ps2asymap = identity()): """ Update the object's code: should be overridden """ raise NotImplementedError def getCode(self, ps2asymap = identity()): """ Return the code describing the object """ self.updateCode(ps2asymap) return self.asyCode class asyPen(asyObj): """ Purpose: -------- A Python object that corresponds to an Asymptote pen type. It extends the 'asyObj' class to include a pen object. This object will be used to make the corresponding Asymptote pen when an xasy object gets translated to Asymptote code. Attributes: ----------- color : The color of Path options : The options that can be passed to the path width : The path width _asyengine : The Asymptote engine that will be used _deferAsyfy : ? Virtual Methods: NULL ---------------- Static Methods: --------------- getColorFromQColor : convertToQColor : Class Methods: -------------- fromAsyPen : Object Methods: --------------- asyEngine : updateCode : setWidth : setColor : setColorFromQColor : computeColor : tkColor : toQPen : """ @staticmethod def getColorFromQColor(color): return color.redF(), color.greenF(), color.blueF() @staticmethod def convertToQColor(color): r, g, b = color return QtGui.QColor.fromRgbF(r, g, b) @classmethod def fromAsyPen(cls, pen): assert isinstance(pen, cls) return cls(asyengine = pen._asyengine, color = pen.color, width = pen.width, pen_options = pen.options) def __init__(self, asyengine = None, color=(0, 0, 0), width = 0.5, pen_options = ""): """ Initialize the pen """ asyObj.__init__(self) self.color = (0, 0, 0) self.options = pen_options self.width = width self.style = "solid" self.capStyle = QtCore.Qt.PenCapStyle.SquareCap self.opacity = 255 #Should these be in a dictionary? self.dashPattern = [1,0] self._asyengine = asyengine self._deferAsyfy = False if pen_options: self._deferAsyfy = True self.updateCode() self.setColor(color) @property def asyEngine(self): return self._asyengine @asyEngine.setter def asyEngine(self, value): self._asyengine = value def qtCapStyleToAsyCapStyle(self, style): lineCapList = [QtCore.Qt.PenCapStyle.SquareCap,QtCore.Qt.PenCapStyle.FlatCap,QtCore.Qt.PenCapStyle.RoundCap] asyCapList = ["extendcap","flatcap","roundcap"] if style in lineCapList: return asyCapList[lineCapList.index(style)] else: return False def updateCode(self, asy2psmap = identity()): """ Generate the pen's code """ if self._deferAsyfy: self.computeColor() self.asyCode = 'rgb({:g},{:g},{:g})+{:s}'.format(self.color[0], self.color[1], self.color[2], str(self.width)) if len(self.options) > 0: self.asyCode = self.asyCode + '+' + self.options if self.style != "solid": self.asyCode = self.style + '+' + self.asyCode def setWidth(self, newWidth): """ Set the pen's width """ self.width = newWidth self.updateCode() def setDashPattern(self, pattern): self.dashPattern = pattern self.updateCode() #Get working def setStyle(self, style): self.style = style self.updateCode() def setCapStyle(self, style): self.capStyle = style self.updateCode() def setOpacity(self, opacity): self.opacity = opacity self.updateCode() def setColor(self, color): """ Set the pen's color """ if isinstance(color, tuple) and len(color) == 3: self.color = color else: self.color = (0, 0, 0) self.updateCode() def setColorFromQColor(self, color): self.setColor(asyPen.getColorFromQColor(color)) def computeColor(self): """ Find out the color of an arbitrary Asymptote pen """ assert isinstance(self.asyEngine, AsymptoteEngine) assert self.asyEngine.active fout = self.asyEngine.ostream fin = self.asyEngine.istream fout.write("pen p=" + self.getCode() + ';\n') fout.write("write(_outpipe,colorspace(p),newl);\n") fout.write("write(_outpipe,colors(p));\n") fout.write("flush(_outpipe);\n") fout.write(self.asyEngine.xasy) fout.flush() colorspace = fin.readline() if colorspace.find("cmyk") != -1: lines = fin.readline() + fin.readline() + fin.readline() + fin.readline() parts = lines.split() c, m, y, k = eval(parts[0]), eval(parts[1]), eval(parts[2]), eval(parts[3]) k = 1 - k r, g, b = ((1 - c) * k, (1 - m) * k, (1 - y) * k) elif colorspace.find("rgb") != -1: lines = fin.readline() + fin.readline() + fin.readline() parts = lines.split() r, g, b = eval(parts[0]), eval(parts[1]), eval(parts[2]) elif colorspace.find("gray") != -1: lines = fin.readline() parts = lines.split() r = g = b = eval(parts[0]) else: raise ChildProcessError('Asymptote error.') self.color = (r, g, b) self._deferAsyfy = False def toQPen(self): if self._deferAsyfy: self.computeColor() newPen = QtGui.QPen() color = asyPen.convertToQColor(self.color) color.setAlpha(self.opacity) newPen.setColor(color) newPen.setCapStyle(self.capStyle) newPen.setWidthF(self.width) if self.dashPattern: newPen.setDashPattern(self.dashPattern) return newPen class asyPath(asyObj): """ Purpose: -------- A Python object that corresponds to an Asymptote path type. It extends the 'asyObj' class to include a path object. This object will be used to make the corresponding Asymptote path object when an xasy object gets translated to its Asymptote code. Attributes: ----------- Virtual Methods: ---------------- Static Methods: --------------- Class Methods: -------------- Object Methods: --------------- """ def __init__(self, asyengine: AsymptoteEngine=None, forceCurve=False): """ Initialize the path to be an empty path: a path with no nodes, control points, or links """ super().__init__() self.nodeSet = [] self.linkSet = [] self.forceCurve = forceCurve self.controlSet = [] self.computed = False self.asyengine = asyengine self.fill = False @classmethod def fromPath(cls, oldPath): newObj = asyPath(None) newObj.nodeSet = copy.copy(oldPath.nodeSet) newObj.linkSet = copy.copy(oldPath.linkSet) newObj.fill = copy.copy(oldPath.fill) newObj.controlSet = copy.deepcopy(oldPath.controlSet) newObj.computed = oldPath.computed newObj.asyengine = oldPath.asyengine return newObj def setInfo(self, path): self.nodeSet = copy.copy(path.nodeSet) self.linkSet = copy.copy(path.linkSet) self.fill = copy.copy(path.fill) self.controlSet = copy.deepcopy(path.controlSet) self.computed = path.computed @property def isEmpty(self): return len(self.nodeSet) == 0 @property def isDrawable(self): return len(self.nodeSet) >= 2 def toQPainterPath(self) -> QtGui.QPainterPath: return self.toQPainterPathCurve() if self.containsCurve else self.toQPainterPathLine() def toQPainterPathLine(self): baseX, baseY = self.nodeSet[0] painterPath = QtGui.QPainterPath(QtCore.QPointF(baseX, baseY)) for pointIndex in range(1, len(self.nodeSet)): node = self.nodeSet[pointIndex] if self.nodeSet[pointIndex] == 'cycle': node = self.nodeSet[0] painterPath.lineTo(*node) return painterPath def toQPainterPathCurve(self): if not self.computed: self.computeControls() baseX, baseY = self.nodeSet[0] painterPath = QtGui.QPainterPath(QtCore.QPointF(baseX, baseY)) for pointIndex in range(1, len(self.nodeSet)): node = self.nodeSet[pointIndex] if self.nodeSet[pointIndex] == 'cycle': node = self.nodeSet[0] endPoint = QtCore.QPointF(node[0], node[1]) ctrlPoint1 = QtCore.QPointF(self.controlSet[pointIndex-1][0][0], self.controlSet[pointIndex-1][0][1]) ctrlPoint2 = QtCore.QPointF(self.controlSet[pointIndex-1][1][0], self.controlSet[pointIndex-1][1][1]) painterPath.cubicTo(ctrlPoint1, ctrlPoint2, endPoint) return painterPath def initFromNodeList(self, nodeSet, linkSet): """ Initialize the path from a set of nodes and link types, '--', '..', or '::' """ if len(nodeSet) > 0: self.nodeSet = nodeSet[:] self.linkSet = linkSet[:] self.computed = False def initFromControls(self, nodeSet, controlSet): """ Initialize the path from nodes and control points """ self.controlSet = controlSet[:] self.nodeSet = nodeSet[:] self.computed = True def makeNodeStr(self, node): """ Represent a node as a string """ if node == 'cycle': return node else: # if really want to, disable this rounding # shouldn't be to much of a problem since 10e-6 is quite small... return '({:.6g},{:.6g})'.format(node[0], node[1]) def updateCode(self, ps2asymap=identity()): """ Generate the code describing the path """ # currently at postscript. Convert to asy asy2psmap = ps2asymap.inverted() with io.StringIO() as rawAsyCode: count = 0 rawAsyCode.write(self.makeNodeStr(asy2psmap * self.nodeSet[0])) for node in self.nodeSet[1:]: if not self.computed or count >= len(self.controlSet): rawAsyCode.write(self.linkSet[count]) rawAsyCode.write(self.makeNodeStr(asy2psmap * node)) else: rawAsyCode.write('..controls ') rawAsyCode.write(self.makeNodeStr(asy2psmap * self.controlSet[count][0])) rawAsyCode.write(' and ') rawAsyCode.write(self.makeNodeStr(asy2psmap * self.controlSet[count][1])) rawAsyCode.write(".." + self.makeNodeStr(asy2psmap * node)) count = count + 1 self.asyCode = rawAsyCode.getvalue() @property def containsCurve(self): return '..' in self.linkSet or self.forceCurve def getNode(self, index): """ Return the requested node """ return self.nodeSet[index] def getLink(self, index): """ Return the requested link """ return self.linkSet[index] def setNode(self, index, newNode): """ Set a node to a new position """ self.nodeSet[index] = newNode def moveNode(self, index, offset): """ Translate a node """ if self.nodeSet[index] != "cycle": self.nodeSet[index] = (self.nodeSet[index][0] + offset[0], self.nodeSet[index][1] + offset[1]) def setLink(self, index, ltype): """ Change the specified link """ self.linkSet[index] = ltype def addNode(self, point, ltype): """ Add a node to the end of a path """ self.nodeSet.append(point) if len(self.nodeSet) != 1: self.linkSet.append(ltype) if self.computed: self.computeControls() def insertNode(self, index, point, ltype=".."): """ Insert a node, and its corresponding link, at the given index """ self.nodeSet.insert(index, point) self.linkSet.insert(index, ltype) if self.computed: self.computeControls() def setControl(self, index, position): """ Set a control point to a new position """ self.controlSet[index] = position def popNode(self): if len(self.controlSet) == len(self.nodeSet): self.controlSet.pop() self.nodeSet.pop() self.linkSet.pop() def moveControl(self, index, offset): """ Translate a control point """ self.controlSet[index] = (self.controlSet[index][0] + offset[0], self.controlSet[index][1] + offset[1]) def computeControls(self): """ Evaluate the code of the path to obtain its control points """ # For now, if no asymptote process is given spawns a new one. # Only happens if asyengine is None. if self.asyengine is not None: assert isinstance(self.asyengine, AsymptoteEngine) assert self.asyengine.active asy = self.asyengine startUp = False else: startUp = True asy = AsymptoteEngine() asy.start() fout = asy.ostream fin = asy.istream fout.write("path p=" + self.getCode() + ';\n') fout.write("write(_outpipe,length(p),newl);\n") fout.write("write(_outpipe,unstraighten(p),endl);\n") fout.write(asy.xasy) fout.flush() lengthStr = fin.readline() pathSegments = eval(lengthStr.split()[-1]) pathStrLines = [] for i in range(pathSegments + 1): line = fin.readline() line = line.replace("\n", "") pathStrLines.append(line) oneLiner = "".join(pathStrLines).replace(" ", "") splitList = oneLiner.split("..") nodes = [a for a in splitList if a.find("controls") == -1] self.nodeSet = [] for a in nodes: if a == 'cycle': self.nodeSet.append(a) else: self.nodeSet.append(eval(a)) controls = [a.replace("controls", "").split("and") for a in splitList if a.find("controls") != -1] self.controlSet = [[eval(a[0]), eval(a[1])] for a in controls] self.computed = True if startUp: asy.stop() class asyLabel(asyObj): """ Purpose: -------- A Python object that corresponds to an asymptote label type. It extends the 'asyObj' class to include a label object. This object will be used to make the corresponding Asymptote label object when an xasy object gets translated to its asymptote code. Attributes: ----------- Virtual Methods: ---------------- Static Methods: --------------- Class Methods: -------------- Object Methods: --------------- """ def __init__(self, text = "", location = (0, 0), pen = None, align = None, fontSize:int = None): """Initialize the label with the given test, location, and pen""" asyObj.__init__(self) self.align = align self.pen = pen self.fontSize = fontSize if align is None: self.align = 'SE' if pen is None: self.pen = asyPen() self.text = text self.location = location def updateCode(self, asy2psmap = identity()): """ Generate the code describing the label """ newLoc = asy2psmap.inverted() * self.location locStr = xu.tuple2StrWOspaces(newLoc) self.asyCode = 'Label("{0}",{1},p={2}{4},align={3})'.format(self.text, locStr, self.pen.getCode(), self.align, self.getFontSizeText()) def getFontSizeText(self): if self.fontSize is not None: return '+fontsize({:.6g})'.format(self.fontSize) else: return '' def setText(self, text): """ Set the label's text """ self.text = text self.updateCode() def setPen(self, pen): """ Set the label's pen """ self.pen = pen self.updateCode() def moveTo(self, newl): """ Translate the label's location """ self.location = newl class asyImage: """ Purpose: -------- A Python object that is a container for an image coming from Asymptote that is populated with the format, bounding box, and IDTag, Asymptote key. Attributes: ----------- Virtual Methods: ---------------- Static Methods: --------------- Class Methods: -------------- Object Methods: --------------- """ def __init__(self, image, format, bbox, transfKey=None, keyIndex=0): self.image = image self.format = format self.bbox = bbox self.IDTag = None self.key = transfKey self.keyIndex = keyIndex class xasyItem(QtCore.QObject): """ Purpose: -------- A base class for any xasy object that can be drawn in PyQt. This class takes care of all common behaviors available on any xasy item as well as all common actions that can be done or applied to every xasy item. Attributes: ----------- Virtual Methods: ---------------- Static Methods: --------------- Class Methods: -------------- Object Methods: --------------- """ mapString = 'xmap' setKeyFormatStr = string.Template('$map("{:s}",{:s});').substitute(map=mapString) setKeyAloneFormatStr = string.Template('$map("{:s}");').substitute(map=mapString) resizeComment="// Resize to initial xasy transform" asySize="" def __init__(self, canvas=None, asyengine=None): """ Initialize the item to an empty item """ super().__init__() self.transfKeymap = {} # the new keymap. # should be a dictionary to a list... self.asyCode = '' self.imageList = [] self.IDTag = None self.asyfied = False self.onCanvas = canvas self.keyBuffer = None self._asyengine = asyengine self.drawObjects = [] self.drawObjectsMap = {} self.setKeyed = True self.unsetKeys = set() self.userKeys = set() self.imageHandleQueue = queue.Queue() def updateCode(self, ps2asymap = identity()): """ Update the item's code: to be overridden """ with io.StringIO() as rawCode: transfCode = self.getTransformCode() objCode = self.getObjectCode() rawCode.write(transfCode) rawCode.write(objCode) self.asyCode = rawCode.getvalue() return len(transfCode.splitlines()), len(objCode.splitlines()) @property def asyengine(self): return self._asyengine @asyengine.setter def asyengine(self, value): self._asyengine = value def getCode(self, ps2asymap = identity()): """ Return the code describing the item """ self.updateCode(ps2asymap) return self.asyCode def getTransformCode(self, asy2psmap = identity()): raise NotImplementedError def getObjectCode(self, asy2psmap = identity()): raise NotImplementedError def generateDrawObjects(self): raise NotImplementedError def handleImageReception(self, file, fileformat, bbox, count, key = None, localCount = 0, containsClip = False): """ Receive an image from an asy deconstruction. It replaces the default n asyProcess """ # image = Image.open(file).transpose(Image.FLIP_TOP_BOTTOM) if fileformat == 'svg': if containsClip: image = xs.SvgObject(self.asyengine.tempDirName+file) else: image = QtSvg.QSvgRenderer(file) assert image.isValid() else: raise Exception('Format {} not supported!'.format(fileformat)) self.imageList.append(asyImage(image, fileformat, bbox, transfKey = key, keyIndex = localCount)) if self.onCanvas is not None: # self.imageList[-1].iqt = ImageTk.PhotoImage(image) currImage = self.imageList[-1] currImage.iqt = image currImage.originalImage = image currImage.originalImage.theta = 0.0 currImage.originalImage.bbox = list(bbox) currImage.performCanvasTransform = False # handle this case if transform is not in the map yet. # if deleted - set transform to (0,0,0,0,0,0) transfExists = key in self.transfKeymap.keys() if transfExists: transfExists = localCount <= len(self.transfKeymap[key]) - 1 if transfExists: validKey = not self.transfKeymap[key][localCount].deleted #Does this ever exist? else: validKey = False if (not transfExists) or validKey: currImage.IDTag = str(file) newDrawObj = DrawObject(currImage.iqt, self.onCanvas['canvas'], transform=identity(), btmRightanchor=QtCore.QPointF(bbox[0], bbox[2]), drawOrder=-1, key=key, parentObj=self, keyIndex=localCount) newDrawObj.setBoundingBoxPs(bbox) newDrawObj.setParent(self) self.drawObjects.append(newDrawObj) if key not in self.drawObjectsMap.keys(): self.drawObjectsMap[key] = [newDrawObj] else: self.drawObjectsMap[key].append(newDrawObj) return containsClip def asyfy(self, force = False): if self.asyengine is None: return 1 if self.asyfied and not force: return self.drawObjects = [] self.drawObjectsMap.clear() assert isinstance(self.asyengine, AsymptoteEngine) self.imageList = [] self.unsetKeys.clear() self.userKeys.clear() self.imageHandleQueue = queue.Queue() worker = threading.Thread(target = self.asyfyThread, args = []) worker.start() item = self.imageHandleQueue.get() cwd=os.getcwd(); os.chdir(self.asyengine.tempDirName) while item != (None,) and item[0] != "ERROR": if item[0] == "OUTPUT": print(item[1]) else: keepFile = self.handleImageReception(*item) if not DebugFlags.keepFiles and not keepFile: try: os.remove(item[0]) pass except OSError: pass finally: pass item = self.imageHandleQueue.get() # self.imageHandleQueue.task_done() os.chdir(cwd); worker.join() def asyfyThread(self): """ Convert the item to a list of images by deconstructing this item's code """ assert self.asyengine.active fout = self.asyengine.ostream fin = self.asyengine.istream self.maxKey=0 fout.write("reset\n") fout.flush(); for line in self.getCode().splitlines(): if DebugFlags.printAsyTranscript: print(line) fout.write(line+"\n") fout.write(self.asySize) fout.write('deconstruct();\n') fout.write('write(_outpipe,yscale(-1)*currentpicture.calculateTransform(),endl);\n') fout.write(self.asyengine.xasy) fout.flush() imageInfos = [] # of (box, key) n = 0 keyCounts = {} def render(): for i in range(len(imageInfos)): box, key, localCount, useClip = imageInfos[i] l, b, r, t = [float(a) for a in box.split()] name = '_{:d}.{:s}'.format(1+i, fileformat) self.imageHandleQueue.put((name, fileformat, (l, -t, r, -b), i, key, localCount, useClip)) # key first, box second. # if key is 'Done' raw_text = fin.readline() text = '' if DebugFlags.printDeconstTranscript: print(self.asyengine.tmpdir) print(raw_text.strip()) fileformat = 'svg' # Output format while raw_text != 'Done\n' and raw_text != 'Error\n': # print(raw_text) text = fin.readline() # the actual bounding box. # print('TESTING:', text) keydata = raw_text.strip().replace('KEY=', '', 1) # key clipflag = keydata[-1] == '1' deleted = keydata[-1] == '2' userkey = keydata[-2] == '1' keydata = keydata[:-3] if not userkey: self.unsetKeys.add(keydata) # the line and column to replace. else: if keydata.isdigit(): self.maxKey=max(self.maxKey,int(keydata)) self.userKeys.add(keydata) # print(line, col) if deleted: raw_text = fin.readline() continue if keydata not in keyCounts.keys(): keyCounts[keydata] = 0 imageInfos.append((text, keydata, keyCounts[keydata], clipflag)) # key-data pair # for the next item keyCounts[keydata] += 1 raw_text = fin.readline() if DebugFlags.printDeconstTranscript: print(text.rstrip()) print(raw_text.rstrip()) n += 1 if raw_text != 'Error\n': if text == 'Error\n': self.imageHandleQueue.put(('ERROR', fin.readline())) else: render() self.asy2psmap = asyTransform(xu.listize(fin.readline().rstrip(),float)) else: self.asy2psmap = yflip() self.imageHandleQueue.put((None,)) self.asyfied = True class xasyDrawnItem(xasyItem): """ Purpose: -------- A base class dedicated to any xasy item that is drawn with the GUI. Each object of this class corresponds to a particular drawn xasy item. Attributes: ----------- Virtual Methods: ---------------- Static Methods: --------------- Class Methods: -------------- Object Methods: --------------- """ def __init__(self, path, engine, pen = None, transform = identity(), key = None): """ Initialize the item with a path, pen, and transform """ super().__init__(canvas=None, asyengine=engine) if pen is None: pen = asyPen() self.path = path self.path.asyengine = engine self.asyfied = True self.pen = pen self._asyengine = engine self.rawIdentifier = '' self.transfKey = key self.transfKeymap = {self.transfKey: [transform]} @property def asyengine(self): return self._asyengine @asyengine.setter def asyengine(self, value: AsymptoteEngine): self._asyengine = value self.path.asyengine = value def setKey(self, newKey=None): transform = self.transfKeymap[self.transfKey][0] self.transfKey = newKey self.transfKeymap = {self.transfKey: [transform]} def generateDrawObjects(self, forceUpdate=False): raise NotImplementedError def appendPoint(self, point, link=None): """ Append a point to the path. If the path is cyclic, add this point before the 'cycle' node """ if self.path.nodeSet[-1] == 'cycle': self.path.nodeSet[-1] = point self.path.nodeSet.append('cycle') else: self.path.nodeSet.append(point) self.path.computed = False self.asyfied = False if len(self.path.nodeSet) > 1 and link is not None: self.path.linkSet.append(link) def clearTransform(self): """ Reset the item's transform """ self.transform = [identity()] self.asyfied = False def removeLastPoint(self): """ Remove the last point in the path. If the path is cyclic, remove the node before the 'cycle' node """ if self.path.nodeSet[-1] == 'cycle': del self.path.nodeSet[-2] else: del self.path.nodeSet[-1] del self.path.linkSet[-1] self.path.computed = False self.asyfied = False def setLastPoint(self, point): """ Modify the last point in the path. If the path is cyclic, modify the node before the 'cycle' node """ if self.path.nodeSet[-1] == 'cycle': self.path.nodeSet[-2] = point else: self.path.nodeSet[-1] = point self.path.computed = False self.asyfied = False class xasyShape(xasyDrawnItem): """ An outlined shape drawn on the GUI """ """ Purpose: -------- Attributes: ----------- Virtual Methods: ---------------- Static Methods: --------------- Class Methods: -------------- Object Methods: --------------- """ def __init__(self, path, asyengine, pen=None, transform=identity()): """Initialize the shape with a path, pen, and transform""" super().__init__(path=path, engine=asyengine, pen=pen, transform=transform) def getObjectCode(self, asy2psmap=identity()): if self.path.fill: return 'fill(KEY="{0}",{1},{2});'.format(self.transfKey, self.path.getCode(asy2psmap), self.pen.getCode())+'\n\n' else: return 'draw(KEY="{0}",{1},{2});'.format(self.transfKey, self.path.getCode(asy2psmap), self.pen.getCode())+'\n\n' def getTransformCode(self, asy2psmap=identity()): transf = self.transfKeymap[self.transfKey][0] if transf == identity(): return '' else: return xasyItem.setKeyFormatStr.format(self.transfKey, transf.getCode(asy2psmap))+'\n' def generateDrawObjects(self, forceUpdate=False): if self.path.containsCurve: self.path.computeControls() transf = self.transfKeymap[self.transfKey][0] newObj = DrawObject(self.path.toQPainterPath(), None, drawOrder=0, transform=transf, pen=self.pen, key=self.transfKey) newObj.originalObj = self newObj.setParent(self) newObj.fill=self.path.fill return [newObj] def __str__(self): """ Create a string describing this shape """ return "xasyShape code:{:s}".format("\n\t".join(self.getCode().splitlines())) def swapFill(self): self.path.fill = not self.path.fill def copy(self): return type(self)(self.path,self._asyengine,self.pen) def arrowify(self,arrowhead=0): newObj = asyArrow(self.path.asyengine, pen=self.pen, transfKey = self.transfKey, transfKeymap = self.transfKeymap, canvas = self.onCanvas, arrowActive = arrowhead, code = self.path.getCode(yflip())) #transform newObj.arrowSettings["fill"] = self.path.fill return newObj class xasyFilledShape(xasyShape): """ A filled shape drawn on the GUI """ """ Purpose: -------- Attributes: ----------- Virtual Methods: ---------------- Static Methods: --------------- Class Methods: -------------- Object Methods: --------------- """ def __init__(self, path, asyengine, pen = None, transform = identity()): """ Initialize this shape with a path, pen, and transform """ if path.nodeSet[-1] != 'cycle': raise Exception("Filled paths must be cyclic") super().__init__(path, asyengine, pen, transform) self.path.fill=True def getObjectCode(self, asy2psmap=identity()): if self.path.fill: return 'fill(KEY="{0}",{1},{2});'.format(self.transfKey, self.path.getCode(asy2psmap), self.pen.getCode())+'\n\n' else: return 'draw(KEY="{0}",{1},{2});'.format(self.transfKey, self.path.getCode(asy2psmap), self.pen.getCode())+'\n\n' def generateDrawObjects(self, forceUpdate = False): if self.path.containsCurve: self.path.computeControls() newObj = DrawObject(self.path.toQPainterPath(), None, drawOrder = 0, transform = self.transfKeymap[self.transfKey][0], pen = self.pen, key = self.transfKey, fill = True) newObj.originalObj = self newObj.setParent(self) newObj.fill=self.path.fill return [newObj] def __str__(self): """ Return a string describing this shape """ return "xasyFilledShape code:{:s}".format("\n\t".join(self.getCode().splitlines())) def swapFill(self): self.path.fill = not self.path.fill class xasyText(xasyItem): """ Text created by the GUI """ """ Purpose: -------- Attributes: ----------- Virtual Methods: ---------------- Static Methods: --------------- Class Methods: -------------- Object Methods: --------------- """ def __init__(self, text, location, asyengine, pen = None, transform = yflip(), key = None, align = None, fontsize:int = None): """ Initialize this item with text, a location, pen, and transform """ super().__init__(asyengine = asyengine) if pen is None: pen = asyPen(asyengine = asyengine) if pen.asyEngine is None: pen.asyEngine = asyengine self.label = asyLabel(text, location, pen, align, fontSize = fontsize) # self.transform = [transform] self.transfKey = key self.transfKeymap = {self.transfKey: [transform]} self.asyfied = False self.onCanvas = None self.pen = pen def setKey(self, newKey = None): transform = self.transfKeymap[self.transfKey][0] self.transfKey = newKey self.transfKeymap = {self.transfKey: [transform]} def getTransformCode(self, asy2psmap = yflip()): transf = self.transfKeymap[self.transfKey][0] if transf == yflip(): # return xasyItem.setKeyAloneFormatStr.format(self.transfKey) return '' else: return xasyItem.setKeyFormatStr.format(self.transfKey, transf.getCode(asy2psmap))+"\n" def getObjectCode(self, asy2psmap = yflip()): return 'label(KEY="{0}",{1});'.format(self.transfKey, self.label.getCode(asy2psmap))+'\n' def generateDrawObjects(self, forceUpdate = False): self.asyfy(forceUpdate) return self.drawObjects def getBoundingBox(self): self.asyfy() return self.imageList[0].bbox def __str__(self): return "xasyText code:{:s}".format("\n\t".join(self.getCode().splitlines())) def copy(self): return type(self)(self.label.text,self.label.location,self._asyengine) class xasyScript(xasyItem): """ A set of images create from asymptote code. It is always deconstructed """ """ Purpose: -------- Attributes: ----------- Virtual Methods: ---------------- Static Methods: --------------- Class Methods: -------------- Object Methods: --------------- """ def __init__(self, canvas, engine, script="", transforms=None, transfKeyMap=None): """ Initialize this script item """ super().__init__(canvas, asyengine=engine) if transfKeyMap is not None: self.transfKeymap = transfKeyMap else: self.transfKeymap = {} self.script = script self.key2imagemap = {} self.namedUnsetKeys = {} self.keyPrefix = '' self.scriptAsyfied = False self.updatedPrefix = True def clearTransform(self): """ Reset the transforms for each of the deconstructed images """ # self.transform = [identity()] * len(self.imageList) keyCount = {} for im in self.imageList: if im.key not in keyCount.keys(): keyCount[im.key] = 1 else: keyCount[im.key] += 1 for key in keyCount: self.transfKeymap[key] = [identity()] * keyCount[key] def getTransformCode(self, asy2psmap=identity()): with io.StringIO() as rawAsyCode: if self.transfKeymap: for key in self.transfKeymap.keys(): val = self.transfKeymap[key] writeval = list(reversed(val)) # need to map all transforms in a list if there is any non-identity # unfortunately, have to check all transformations in the list. while not all((checktransf == identity() and not checktransf.deleted) for checktransf in writeval) and writeval: transf = writeval.pop() if transf.deleted: rawAsyCode.write(xasyItem.setKeyFormatStr.format(key, transf.getCode(asy2psmap))) else: if transf == identity(): rawAsyCode.write(xasyItem.setKeyAloneFormatStr.format(key)) else: rawAsyCode.write(xasyItem.setKeyFormatStr.format(key, transf.getCode(asy2psmap))) rawAsyCode.write('\n') result = rawAsyCode.getvalue() return result def findNonIdKeys(self): return {key for key in self.transfKeymap if not all(not transf.deleted and transf == identity() for transf in self.transfKeymap[key]) } def getObjectCode(self, asy2psmap=identity()): numeric=r'([-+]?(?:(?:\d*\.\d+)|(?:\d+\.?)))' rSize=re.compile(r"size\(\("+numeric+","+numeric+","+numeric+"," +numeric+","+numeric+","+numeric+r"\)\); "+ self.resizeComment) newScript = self.getReplacedKeysCode(self.findNonIdKeys()) with io.StringIO() as rawAsyCode: for line in newScript.splitlines(): if(rSize.match(line)): self.asySize=line.rstrip()+'\n' else: raw_line = line.rstrip().replace('\t', ' ' * 4) rawAsyCode.write(raw_line + '\n') self.updatedCode = rawAsyCode.getvalue() return self.updatedCode def setScript(self, script): """ Sets the content of the script item """ self.script = script self.updateCode() def setKeyPrefix(self, newPrefix=''): self.keyPrefix = newPrefix self.updatedPrefix = False def getReplacedKeysCode(self, key2replace: set=None) -> str: keylist = {} prefix = '' key2replaceSet = self.unsetKeys if key2replace is None else \ self.unsetKeys & key2replace linenum2key = {} if not self.updatedPrefix: prefix = self.keyPrefix for key in key2replaceSet: actualkey = key key = key.split(':')[0] raw_parsed = xu.tryParseKey(key) assert raw_parsed is not None line, col = [int(val) for val in raw_parsed.groups()] if line not in keylist: keylist[line] = set() keylist[line].add(col) linenum2key[(line, col)] = actualkey self.unsetKeys.discard(key) raw_code_lines = self.script.splitlines() with io.StringIO() as raw_str: for i in range(len(raw_code_lines)): curr_str = raw_code_lines[i] if i + 1 in keylist.keys(): # this case, we have a key. with io.StringIO() as raw_line: n=len(curr_str) for j in range(n): raw_line.write(curr_str[j]) if j + 1 in keylist[i + 1]: # at this point, replace keys with xkey sep=',' k=j+1 # assume begingroup is on a single line for now while k < n: c=curr_str[k] if c == ')': sep='' break if not c.isspace(): break ++k raw_line.write('KEY="{0:s}"'.format(linenum2key[(i + 1, j + 1)])+sep) self.userKeys.add(linenum2key[(i + 1, j + 1)]) curr_str = raw_line.getvalue() # else, skip and just write the line. raw_str.write(curr_str + '\n') return raw_str.getvalue() def getUnusedKey(self, oldkey) -> str: baseCounter = 0 newKey = oldkey while newKey in self.userKeys: newKey = oldkey + ':' + str(baseCounter) baseCounter += 1 return newKey def asyfy(self, keyOnly = False): """ Generate the list of images described by this object and adjust the length of the transform list """ super().asyfy() # Id --> Transf --> asyfied --> Transf # Transf should keep the original, raw transformation # but for all new drawn objects - assign Id as transform. if self.scriptAsyfied: return keyCount = {} settedKey = {} for im in self.imageList: if im.key in self.unsetKeys and im.key not in settedKey.keys(): oldkey = im.key self.unsetKeys.remove(im.key) im.key = self.getUnusedKey(im.key) self.unsetKeys.add(im.key) for drawobj in self.drawObjectsMap[oldkey]: drawobj.key = im.key self.drawObjectsMap[im.key] = self.drawObjectsMap[oldkey] self.drawObjectsMap.pop(oldkey) settedKey[oldkey] = im.key elif im.key in settedKey.keys(): im.key = settedKey[im.key] if im.key not in keyCount.keys(): keyCount[im.key] = 1 else: keyCount[im.key] += 1 if im.key not in self.key2imagemap.keys(): self.key2imagemap[im.key] = [im] else: self.key2imagemap[im.key].append(im) for key in keyCount: if key not in self.transfKeymap.keys(): self.transfKeymap[key] = [identity()] * keyCount[key] else: while len(self.transfKeymap[key]) < keyCount[key]: self.transfKeymap[key].append(identity()) # while len(self.transfKeymap[key]) > keyCount[key]: # self.transfKeymap[key].pop() # change of basis for keylist in self.transfKeymap.values(): for i in range(len(keylist)): if keylist[i] != identity(): keylist[i] = self.asy2psmap * keylist[i] * self.asy2psmap.inverted() self.updateCode() self.scriptAsyfied = True def generateDrawObjects(self, forceUpdate=False): self.asyfy(forceUpdate) return self.drawObjects def __str__(self): """ Return a string describing this script """ retVal = "xasyScript\n\tTransforms:\n" for xform in self.transform: retVal += "\t" + str(xform) + "\n" retVal += "\tCode Omitted" return retVal class DrawObject(QtCore.QObject): """ Purpose: -------- The main Python class to draw an object with the help of PyQt graphical library. Every instance of the class is Attributes: ----------- Virtual Methods: ---------------- Static Methods: --------------- Class Methods: -------------- Object Methods: --------------- """ def __init__(self, drawObject, mainCanvas = None, transform = identity(), btmRightanchor = QtCore.QPointF(0, 0), drawOrder = (-1, -1), pen = None, key = None, parentObj = None, fill = False, keyIndex = 0): super().__init__() self.drawObject = drawObject self.mainCanvas = mainCanvas self.pTransform = transform self.baseTransform = transform self.drawOrder = drawOrder self.btmRightAnchor = btmRightanchor self.originalObj = parentObj self.explicitBoundingBox = None self.useCanvasTransformation = False self.key = key self.cachedSvgImg = None self.cachedDPI = None self.maxDPI=0 self.keyIndex = keyIndex self.pen = pen self.fill = fill def getInteriorScrTransform(self, transform): """ Generates the transform with Interior transform applied beforehand """ if isinstance(transform, QtGui.QTransform): transform = asyTransform.fromQTransform(transform) return self.transform * transform * self.baseTransform.inverted() @property def transform(self): return self.pTransform @transform.setter def transform(self, value): self.pTransform = value def setBoundingBoxPs(self, bbox): l, b, r, t = bbox self.explicitBoundingBox = QtCore.QRectF(QtCore.QPointF(l, b), QtCore.QPointF(r, t)) # self.explicitBoundingBox = QtCore.QRectF(0, 0, 100, 100) @property def boundingBox(self): if self.explicitBoundingBox is not None: tempItem = self.baseTransform.toQTransform().mapRect(self.explicitBoundingBox) testBbox = self.getScreenTransform().toQTransform().mapRect(tempItem) elif isinstance(self.drawObject, QtGui.QPainterPath): tempItem = self.baseTransform.toQTransform().map(self.drawObject) testBbox = self.getScreenTransform().toQTransform().map(tempItem).boundingRect() else: raise TypeError('drawObject is not a valid type!') if self.pen is not None: lineWidth = self.pen.width const = lineWidth/2 bl = QtCore.QPointF(-const, const) br = QtCore.QPointF(const, const) tl = QtCore.QPointF(-const, -const) tr = QtCore.QPointF(const, -const) pointList = [testBbox.topLeft(), testBbox.topRight(), testBbox.bottomLeft(), testBbox.bottomRight() ] else: pointList = [testBbox.topLeft(), testBbox.topRight(), testBbox.bottomLeft(), testBbox.bottomRight() ] return QtGui.QPolygonF(pointList).boundingRect() @property def localBoundingBox(self): testBbox = self.drawObject.rect() testBbox.moveTo(self.btmRightAnchor.toPoint()) return testBbox def getScreenTransform(self): scrTransf = self.baseTransform.toQTransform().inverted()[0] * self.pTransform.toQTransform() # print(asyTransform.fromQTransform(scrTransf).t) return asyTransform.fromQTransform(scrTransf) def draw(self, additionalTransformation = None, applyReverse = False, canvas: QtGui.QPainter = None, dpi = 300): if canvas is None: canvas = self.mainCanvas if additionalTransformation is None: additionalTransformation = QtGui.QTransform() assert canvas.isActive() canvas.save() if self.pen: oldPen = QtGui.QPen(canvas.pen()) localPen = self.pen.toQPen() # localPen.setCosmetic(True) canvas.setPen(localPen) #this fixes the object but not the box else: oldPen = QtGui.QPen() if not applyReverse: canvas.setTransform(additionalTransformation, True) canvas.setTransform(self.transform.toQTransform(), True) else: canvas.setTransform(self.transform.toQTransform(), True) canvas.setTransform(additionalTransformation, True) canvas.setTransform(self.baseTransform.toQTransform().inverted()[0], True) if isinstance(self.drawObject, xs.SvgObject): threshold = 1.44 if self.cachedDPI is None or self.cachedSvgImg is None \ or dpi > self.maxDPI*threshold: self.cachedDPI = dpi self.maxDPI=max(self.maxDPI,dpi) self.cachedSvgImg = self.drawObject.render(dpi) canvas.drawImage(self.explicitBoundingBox, self.cachedSvgImg) elif isinstance(self.drawObject, QtSvg.QSvgRenderer): self.drawObject.render(canvas, self.explicitBoundingBox) elif isinstance(self.drawObject, QtGui.QPainterPath): path = self.baseTransform.toQTransform().map(self.drawObject) if self.fill: if self.pen: brush = self.pen.toQPen().brush() else: brush = QtGui.QBrush() canvas.fillPath(path, brush) else: canvas.drawPath(path) if self.pen: canvas.setPen(oldPen) canvas.restore() def collide(self, coords, canvasCoordinates = True): # modify these values to grow/shrink the fuzz. fuzzTolerance = 1 marginGrowth = 1 leftMargin = marginGrowth if self.boundingBox.width() < fuzzTolerance else 0 topMargin = marginGrowth if self.boundingBox.height() < fuzzTolerance else 0 newMargin = QtCore.QMarginsF(leftMargin, topMargin, leftMargin, topMargin) return self.boundingBox.marginsAdded(newMargin).contains(coords) def getID(self): return self.originalObj class asyArrow(xasyItem): def __init__(self, asyengine, pen=None, transform=identity(), transfKey=None, transfKeymap = None, canvas=None, arrowActive=False, code=None): #super().__init__(path=path, engine=asyengine, pen=pen, transform=transform) """Initialize the label with the given test, location, and pen""" #asyObj.__init__(self) super().__init__(canvas=canvas, asyengine=asyengine) #CANVAS? Seems to work. if pen is None: pen = asyPen() if pen.asyEngine is None: pen.asyEngine = asyengine self.pen = pen self.fillPen = asyPen() self.fillPen.asyEngine = asyengine self.code = code #self.path = path #self.path.asyengine = asyengine self.transfKey = transfKey if transfKeymap == None: #Better way? self.transfKeymap = {self.transfKey: [transform]} else: self.transfKeymap = transfKeymap self.location = (0,0) self.asyfied = False self.onCanvas = canvas self.arrowSettings = {"active": arrowActive, "style": 0, "fill": 0} #Rename active? self.arrowList = ["","Arrow","ArcArrow"] #The first setting corresponds to no arrow. self.arrowStyleList = ["","SimpleHead","HookHead","TeXHead"] self.arrowFillList = ["","FillDraw","Fill","NoFill","UnFill","Draw"] def getArrowSettings(self): settings = "(" if self.arrowSettings["style"] != 0: settings += "arrowhead=" settings += self.arrowStyleList[self.arrowSettings["style"]] if "size" in self.arrowSettings: if settings != "(": #This is really messy. settings += "," settings += "size=" + str(self.arrowSettings["size"]) #Should I add options to this? Like for cm? if "angle" in self.arrowSettings: #This is so similar, you should be able to turn this into a function or something. if settings != "(": settings += "," settings += "angle=" + str(self.arrowSettings["angle"]) if self.arrowSettings["fill"] != 0: if settings != "(": settings += "," settings += "filltype=" settings += self.arrowFillList[self.arrowSettings["fill"]] settings += ")" #print(settings) return settings def setKey(self, newKey = None): transform = self.transfKeymap[self.transfKey][0] self.transfKey = newKey self.transfKeymap = {self.transfKey: [transform]} def updateCode(self, asy2psmap = identity()): newLoc = asy2psmap.inverted() * self.location self.asyCode = '' if self.arrowSettings["active"]: if self.arrowSettings["fill"]: self.asyCode += 'begingroup(KEY="{0}");'.format(self.transfKey)+'\n\n' self.asyCode += 'fill({0},{1});'.format(self.code, self.fillPen.getCode())+'\n\n' self.asyCode += 'draw({0},{1},arrow={2}{3});'.format(self.code, self.pen.getCode(), self.arrowList[self.arrowSettings["active"]],self.getArrowSettings())+'\n\n' else: self.asyCode += 'draw(KEY="{0}",{1},{2},arrow={3}{4});'.format(self.transfKey, self.code, self.pen.getCode(), self.arrowList[self.arrowSettings["active"]],self.getArrowSettings())+'\n\n' if self.arrowSettings["fill"]: self.asyCode += 'endgroup();\n\n' else: self.asyCode = 'draw(KEY="{0}",{1},{2});'.format(self.transfKey, self.code, self.pen.getCode())+'\n\n' def setPen(self, pen): """ Set the label's pen """ self.pen = pen self.updateCode() def moveTo(self, newl): """ Translate the label's location """ self.location = newl def getObjectCode(self, asy2psmap=identity()): self.updateCode() return self.asyCode def getTransformCode(self, asy2psmap=identity()): transf = self.transfKeymap[self.transfKey][0] if transf == identity(): return '' else: return xasyItem.setKeyFormatStr.format(self.transfKey, transf.getCode(asy2psmap))+'\n' def generateDrawObjects(self, forceUpdate=False): self.asyfy(forceUpdate) transf = self.transfKeymap[self.transfKey][0] for drawObject in self.drawObjects: drawObject.pTransform = transf return self.drawObjects def __str__(self): """ Create a string describing this shape """ return "xasyShape code:{:s}".format("\n\t".join(self.getCode().splitlines())) def swapFill(self): self.arrowSettings["fill"] = not self.arrowSettings["fill"] def getBoundingBox(self): self.asyfy() return self.imageList[0].bbox def copy(self): #Include all parameters? return type(self)(self._asyengine,pen=self.pen,canvas=self.onCanvas,arrowActive=self.arrowSettings["active"])