def __init__(self, *args, **kwargs):
kwargs.setdefault('width', 2)
avatar = kwargs.setdefault('avatar', 'tuga')
self.size = kwargs.pop('size', 45)
self.validate_avatar(avatar)
self.graphics_item = cursor = QtSvg.QGraphicsSvgItem()
# Loads from turtleart.svg
cursor.setSharedRenderer(svg_renderer)
cursor.setElementId(avatar)
# Define local transforms
rect = cursor.sceneBoundingRect()
curr_width, curr_height = rect.width(), rect.height()
cursor.setTransform(QtGui.QTransform(
1.00, 0.00,
0.00, 1.00,
-curr_width / 2, -curr_height / 2)
)
cursor.setTransformOriginPoint(0.5 * curr_width, 0.5 * curr_height)
cursor.setScale(self.size / curr_width)
cursor.setZValue(1.0)
self.pen = QtGui.QPen(QtGui.QColor(0, 0, 0))
self.brush = QtGui.QBrush(QtGui.QColor(0, 0, 0))
super().__init__(*args, **kwargs)
def __init__(self, content: str, parent: QWidget = None):
"""Creates a new SVG viewer with the given SVG content.
:param content: the SVG content to show.
:param parent: optional parent widget, defaults to None.
"""
super().__init__(parent)
self.setScene(QGraphicsScene(self))
self.setTransformationAnchor(QGraphicsView.AnchorUnderMouse)
self.setDragMode(QGraphicsView.ScrollHandDrag)
self.setViewportUpdateMode(QGraphicsView.FullViewportUpdate)
svg_renderer = QtSvg.QSvgRenderer(content.encode('utf-8'))
svg_item = QtSvg.QGraphicsSvgItem()
svg_item.setSharedRenderer(svg_renderer)
svg_item.setFlags(QGraphicsItem.ItemClipsToShape)
svg_item.setCacheMode(QGraphicsItem.NoCache)
svg_item.setZValue(0)
scene = self.scene()
scene.clear()
self.resetTransform()
scene.addItem(svg_item)
scene.setSceneRect(svg_item.boundingRect())
def openFileIMG(self, img_file):
s = self.scene()
if self.backgroundItem:
drawBackground = self.backgroundItem.isVisible()
else:
drawBackground = True
if self.outlineItem:
drawOutline = self.outlineItem.isVisible()
else:
drawOutline = True
if self.TraceImage:
drawOutline = self.outlineItem.isVisible()
else:
drawOutline = True
s.clear()
img = QtGui.QPixmap(img_file)
self.TraceImage = QtWidgets.QGraphicsPixmapItem(img)
self.TraceImage.setFlags(QtWidgets.QGraphicsItem.ItemClipsToShape)
self.TraceImage.setCacheMode(QtWidgets.QGraphicsItem.NoCache)
self.TraceImage.setZValue(1)
effect = QtWidgets.QGraphicsOpacityEffect(self)
self.TraceImage.setGraphicsEffect(effect)
self.setOpacity(self.opacity)
self.TraceImage.setZValue(1)
self.svgItem = QtSvg.QGraphicsSvgItem()
self.svgItem.setFlags(QtWidgets.QGraphicsItem.ItemClipsToShape)
self.svgItem.setCacheMode(QtWidgets.QGraphicsItem.NoCache)
self.svgItem.setZValue(0)
self.backgroundItem = QtWidgets.QGraphicsRectItem(
self.TraceImage.boundingRect())
self.backgroundItem.setBrush(QtCore.Qt.white)
self.backgroundItem.setPen(QtGui.QPen(QtCore.Qt.NoPen))
self.backgroundItem.setVisible(drawBackground)
self.backgroundItem.setZValue(-1)
self.outlineItem = QtWidgets.QGraphicsRectItem(
self.TraceImage.boundingRect())
outline = QtGui.QPen(QtCore.Qt.darkGray, 1.5, QtCore.Qt.SolidLine)
outline.setCosmetic(True)
self.outlineItem.setPen(outline)
self.outlineItem.setBrush(QtGui.QBrush(QtCore.Qt.NoBrush))
self.outlineItem.setVisible(drawOutline)
self.outlineItem.setZValue(2)
s.addItem(self.backgroundItem)
s.addItem(self.svgItem)
s.addItem(self.TraceImage)
s.addItem(self.outlineItem)
s.setSceneRect(self.outlineItem.boundingRect().adjusted(
-10, -10, 10, 10))
def graph_create(self):
graph_text = self.OperationList.toPlainText()
self.nodes_list = Graph.graph_create(graph_text)
# draw a graph image
ImagesApi.draw_graph(self.nodes_list)
svg_item = QtSvg.QGraphicsSvgItem(
os.path.join(os.path.dirname(os.path.abspath(__file__)), '..',
'data', "ProcessGraph.gv.svg"))
scene = QtWidgets.QGraphicsScene()
scene.addItem(svg_item)
self.processView.setScene(scene)
def update_nlp_graphics(self):
"""Updates the current graph.
This takes into account all changes to the filter, NLP instance and
drawing parameters.
"""
# print('NLPCanvas#updateNLPGraphics')
scene = QtWidgets.QGraphicsScene()
self.ui.graphicsView.setScene(scene)
br = QtSvg.QGraphicsSvgItem()
rr = QtSvg.QSvgRenderer(self.render_nlpgraphics())
br.setSharedRenderer(rr)
scene.addItem(br)
self.ui.graphicsView.show()
def __init__(self, symbol, parent=None):
super().__init__(parent)
self._symbol = symbol
try:
renderer, svg_symbol = self._cache[self._symbol]
except KeyError:
path = os.path.join(DATA_DIR, 'symbols', '%s.svg' % self._symbol)
svg_symbol = SvgSymbol(path)
renderer = QtSvg.QSvgRenderer(svg_symbol.get_xml())
self._cache[self._symbol] = (renderer, svg_symbol)
self.grp = QtWidgets.QGraphicsItemGroup(self)
origin_x, origin_y = svg_symbol.get_origin()
self.grp.setPos(-origin_x, -origin_y)
self.body = QtSvg.QGraphicsSvgItem(self.grp)
self.body.setSharedRenderer(renderer)
async def startProfile(self) -> None:
self.setEnabled(False)
self.setCursor(Qt.BusyCursor)
if self.__item is not None:
self.__scene.removeItem(self.__item)
self.__item = None
try:
svg = await self.audioproc_client.profile_audio_thread(
duration=self.__duration.value())
renderer = QtSvg.QSvgRenderer()
renderer.load(svg)
self.__item = QtSvg.QGraphicsSvgItem()
self.__item.setSharedRenderer(renderer)
self.__scene.addItem(self.__item)
finally:
self.setEnabled(True)
self.unsetCursor()
def getNewNoteEvent(self, currentNotes):
correctionDnn = 0
correctionKeyboard = 0
newNote = 1
[newNoteDnn, newNoteKeyboard, newMetronomeBeep] = currentNotes
keyString = newNoteDnn['keyEstimation']
# try:
# [newNoteDnn, newNoteKeyboard, newMetronomeBeep] = self.currentNotesForPainter.get(block=False)
# keyString = newNoteDnn['keyEstimation']
# #print(f"received {[newMetronomeBeep]}")
# newNote = 1
# #print(f"metronome {newMetronomeBeep}\ndnn {newNoteDnn}\nkeyboard {newNoteKeyboard}")
# #check for each of them
# #first newNoteDnn [midi, hit, tick]
# except BaseException as e:
# #print(e)
# newNote = 0
# #print(f"EROOR {e} sto tick")
# #sceneRect3 = self.staffView.viewport()
# #sceneRect4 = self.staffView.viewPort().geometry()
# pass
if newNote == 1: # if newToken , it can be new note, it can be rest, or continuation, its 1 at every 16th note.
if newNoteKeyboard['midi'] == 0 and self.lastNote == 0: # if midiNumber == 0 , so REST, and self.lastNote was also a rest
newNoteKeyboard['artic'] = 0 # tote kane to articulation 0 . just a heuristic giati genika kanw plot otan erthei to epomeno articulation=1
# an den to ekana auto tote that ekana plot apeires 16th pauses
tieToPrevKeyboard = 0
############ IF ONSET (OR MEASURE ENDING), THEN PLOT THE PREVIOUS Note
if newNoteKeyboard['artic'] == 1 or newMetronomeBeep['tick'] == 0:
if self.lastNote is not None: # POTE EINAI NONE ? MONO STHN POLI ARXI
# THELOUME NA KANOUME PLOT TIN PROHGOUMENH MONO OTAN YPHRXE PROHGOUMENI NOTA
# finalize and send prevDnnStaffSymbol for plotting
midiNumber = self.lastNote
staffInd = 0
barLine = 0
dur = self.lastDur
# find if we want primary or secondary
#print(f"for midinumber {midiNumber}, keyQuery {keyString}, keysInPrimary {self.notesPainterDict[midiNumber]['primary']['keys']}")
if (keyString is not None) and (keyString != 'None'):
primOrSec = 'primary' if keyString in self.notesPainterDict[midiNumber]['primary']['keys'] else 'secondary'
else:
primOrSec = 'primary'
noteAddProps = self.notesPainterDict[midiNumber][primOrSec]
if newMetronomeBeep['tick'] == 0: # if tick == 0 , new bar
barLine = 1
tieToPrevKeyboard = 0
self.rightMostPointKeyboard = self.prepareSymbolObjForPaint(midiNumber = midiNumber, horPos = self.lastHorizontalPos - dur*3*self.lineDistance, staffInd = staffInd,
dur = dur, props = noteAddProps, barLine = barLine, clef = 'treble', tieToPrev = tieToPrevKeyboard)
aaa = self.rightMostPointKeyboard - (self.lastHorizontalPos - dur*3*self.lineDistance + 1.8*self.lineDistance)
self.lastNoteHorPos = self.lastHorizontalPos - dur*3*self.lineDistance
# correctionKeyboard = max([aaa, 0])
if aaa < 1/20:
correctionKeyboard = 0
self.aNoteWasPainted = True
#print(f"rightMostPoint {self.rightMostPointKeyboard}")
#self.finalizeLastSymbol()
# create the new Symbol
#self.lastKeyboardStaffNoteObj = StaffSymbol(midiNumber=newNoteDnn['midi'])
self.lastDur = 1
self.lastNote = newNoteKeyboard['midi']
#self.lastHorizontalPos += 3*self.lineDistance
elif newNoteKeyboard['artic'] == 0:
if newMetronomeBeep['tick'] != 0:
#print(f" newNoteDnn['artic'] {newNoteKeyboard['midi']} == self.lastNote {self.lastNote}")
if newNoteKeyboard['midi'] == self.lastNote: #TODO IF NOT ??? gamise ta tote
# update lastDnnStaffSymbol by increasing the duration
#self.lastKeyboardStaffNoteObj.duration += 1
self.lastDur += 1
if keyString != self.lastKeyString :
#print(keyString)
# keyItem = QtSvg.QGraphicsSvgItem('<svg height="30" width="200"><text x="0" y="15" fill="red">Amajor</text></svg>')
#print(keyString)
# filePath = self.appctxt.get_resource(str("Cmajor.svg"))
# keyItem = QtSvg.QGraphicsSvgItem(filePath)
# keyItem.setPos(self.lastHorizontalPos, 10)
# keyItem.scale(0.5,0.5)
#keyItem.setGeometry(self.lastHorizontalPos, 20, 20,20)
realKeyString = keyString.split(" ")[0]+'m' if 'minor' in keyString else keyString.split(" ")[0]
print(realKeyString)
if realKeyString != 'None' and realKeyString is not None:
svg_str = f"""
<svg height="20" width="20">
<text x="0" y="10" style="font-style:normal;font-weight:bold;letter-spacing:0px;word-spacing:0px;fill:#4a85c4;fill-opacity:1;stroke:none;stroke-width:0.26458332">{realKeyString}</text>
</svg>
"""
svg_bytes = bytearray(svg_str, encoding='utf-8')
svgItem = QtSvg.QGraphicsSvgItem()
renderer = QtSvg.QSvgRenderer()
renderer.load(svg_bytes)
svgItem.setSharedRenderer(renderer)
svgItem.setPos(self.lastHorizontalPos, 5)
svgItem.scale(2,2)
self.sendNoteItemToMain.emit([svgItem],1) # TODO
# # self.updateStaffView([svgItem],1)
# for item in [svgItem]:
# self.staffView.staffScene.addItem(item)
self.lastKeyString = keyString
#print(f"{newMetronomeBeep} {newMetronomeBeep['tick'].__class__}")
if newMetronomeBeep['tick']%4==0 :
# THE DOTS THAT DUAN ASKED GAMW THN PANAGIA
filePath = self.appctxt.get_resource(str(self.svgFolder/"pointer.svg"))
dotItem = QtSvg.QGraphicsSvgItem(filePath)
dotItem.setPos(self.lastHorizontalPos, 10)
# heightBefore = self.boundingRect().height()
# widthBefore = self.boundingRect().width()
# widthScale = self.widthRel * self.lineDistance / self.widthBefore
# heightScale = self.heightRel * self.lineDistance / self.heightBefore
dotItem.scale(0.25,0.25)
if self.lastDotItem is not None:
# self.staffView.staffScene.removeItem(self.lastDotItem)
self.sendNoteItemToMain.emit([self.lastDotItem],0)
# self.updateStaffView([self.lastDotItem],0)
self.sendNoteItemToMain.emit([dotItem],1)
# self.staffView.staffScene.addItem(dotItem)
# self.updateStaffView([dotItem],1)
self.lastDotItem = dotItem
##########################################################################################################################
####################### SAME FOR DNN ###################################################################################
if newNoteDnn['midi'] == 0 and self.lastNoteDnn == 0:
newNoteDnn['artic'] = 0
if newNoteDnn['artic'] == 1 or newMetronomeBeep['tick'] == 0:
tieToPrevDnn = 0
if self.lastNoteDnn is not None:
# finalize and send prevDnnStaffSymbol for plotting
midiNumber = self.lastNoteDnn
staffInd = 1
barLine = 0
dur = self.lastDurDnn
#print(f"for midinumber {midiNumber}, keyQuery {keyString}, keysInPrimary {self.notesPainterDict[midiNumber]['primary']['keys']}")
if (keyString is not None) and (keyString != 'None'):
primOrSec = 'primary' if keyString in self.notesPainterDict[midiNumber]['primary']['keys'] else 'secondary'
else:
primOrSec = 'primary'
noteAddProps = self.notesPainterDict[midiNumber][primOrSec]
#noteAddProps = self.notesPainterDict[midiNumber]['primary'] # for now, use only the primary version of the note (ie C instead of B#)
if newMetronomeBeep['midi'] == 70:
tieToPrevDnn = 0
#print(midiNumber)
self.rightMostPointDnn = self.prepareSymbolObjForPaint(midiNumber = midiNumber, horPos = self.lastHorizontalPos - dur*3*self.lineDistance,
staffInd = staffInd, dur = dur, props = noteAddProps, barLine = barLine, clef = 'bass', tieToPrev = tieToPrevDnn)
self.lastNoteHorPosDnn = self.lastHorizontalPos - dur*3*self.lineDistance
self.aNoteWasPainted = True
bbb = self.rightMostPointDnn - (self.lastHorizontalPos - dur*3*self.lineDistance + 1.8*self.lineDistance)
#correctionDnn = max([bbb, 0])
if correctionDnn < 1/20:
correctionDnn = 0
#self.finalizeLastSymbol()
# create the new Symbol
#self.lastKeyboardStaffNoteObj = StaffSymbol(midiNumber=newNoteDnn['midi'])
self.lastDurDnn = 1
self.lastNoteDnn = newNoteDnn['midi']
#self.lastHorizontalPos += 3*self.lineDistance
elif newNoteDnn['artic'] == 0:
# rightMostPointDnn += 3*self.lineDistance
if newMetronomeBeep['tick'] != 0:
#print(f" newNoteDnn['artic'] {newNoteKeyboard['midi']} == self.lastNote {self.lastNote}")
if newNoteDnn['midi'] == self.lastNoteDnn:
# update lastDnnStaffSymbol by increasing the duration
#self.lastKeyboardStaffNoteObj.duration += 1
self.lastDurDnn += 1
#print(f" {self.lastDur}")
# print(f"lastHorPos {self.lastHorizontalPos}, corKeyboard {correctionDnn} , corDnn {correctionDnn}")
# print(f"max is { max([correctionDnn, correctionKeyboard])}")
self.lastHorizontalPos += max([correctionDnn, correctionKeyboard])
# print(f"lastHorPosAfterMax {self.lastHorizontalPos}\n\n\n\n\n")
self.lastHorizontalPos += 3*self.lineDistance
# print(f"lastHorPosAfter {self.lastHorizontalPos}\n\n\n\n\n")
# if self.aNoteWasPainted is True:
# print(f"max of lastHorPos {self.lastHorizontalPos} , rightMost+d {self.rightMostPointKeyboard + self.lineDistance} , rightMostDnn+d {self.rightMostPointDnn +self.lineDistance }")
# self.lastHorizontalPos = max([self.lastHorizontalPos, self.rightMostPointKeyboard + self.lineDistance, self.rightMostPointDnn + self.lineDistance])
# self.aNoteWasPainted = False
#print(f"lastHorPos {self.lastHorizontalPos}")
#sceneRect2 = self.staffView.viewport().geometry().boundingRect()
#print(f"sceneRect inside painter {sceneRect.width()} and pos is {self.currentNotePosIndex}")
###################self.currentNotePosIndex = max([rightMostPointKeyboard, rightMostPointDnn]) + self.lineDistance
#sceneRect1 = self.staffView.mapToScene(self.staffView.viewport().geometry()).boundingRect()
#sceneRect2 = self.staffView.mapToGlobal(self.staffView.viewport().geometry()).boundingRect()
#sceneRect3 = self.staffView.viewport()
#sceneRect4 = self.staffView.viewPort().geometry()
#print(self.sceneRect.x() + self.sceneRect.width())
#print(self.currentNotePosIndex)
#print(f"geom2Scene {sceneRect1}")#", \ngeom2Global{sceneRect3}")#", \ngeom {sceneRect4}\n\n\n")
if self.lastHorizontalPos > self.width:
# print(self.lastHorizontalPos)
#self.staffView.horizontalScrollBar().setValue(self.staffView.horizontalScrollBar().value() + dur* 3*self.lineDistance)
#print(self.width)
self.staffView.horizontalScrollBar().setValue(self.lastHorizontalPos - self.width/1)
class GraphView(QtWidgets.QWidget):
def __init__(self, get_scene_func, config):
super(GraphView, self).__init__()
self._get_scene_func = get_scene_func
self._framerate = config.get('framerate')
self._duration = 0.0
self._samples = config.get('samples')
self._viewer = None
self._save_btn = QtWidgets.QPushButton('Save image')
self._scene = QtWidgets.QGraphicsScene()
self._view = _SVGGraphView()
self._view.setScene(self._scene)
self._seek_chkbox = QtWidgets.QCheckBox('Show graph at a given time')
self._seekbar = Seekbar(config, stop_button=False)
self._seekbar.setEnabled(False)
hbox = QtWidgets.QHBoxLayout()
hbox.addStretch()
hbox.addWidget(self._save_btn)
graph_layout = QtWidgets.QVBoxLayout(self)
graph_layout.addWidget(self._seek_chkbox)
graph_layout.addWidget(self._seekbar)
graph_layout.addWidget(self._view)
graph_layout.addLayout(hbox)
self._save_btn.clicked.connect(self._save_to_file)
self._seek_chkbox.stateChanged.connect(self._seek_check_changed)
self._seekbar.play.connect(self._play)
self._seekbar.pause.connect(self._pause)
self._seekbar.seek.connect(self._seek)
self._seekbar.step.connect(self._step)
self._timer = QtCore.QTimer()
self._timer.timeout.connect(self._update)
self._clock = player.Clock(self._framerate, 0.0)
@QtCore.pyqtSlot()
def _play(self):
self._timer.start()
self._clock.start()
self._seekbar.set_play_state()
@QtCore.pyqtSlot()
def _pause(self):
self._timer.stop()
self._clock.stop()
self._seekbar.set_pause_state()
@QtCore.pyqtSlot(float)
def _seek(self, time):
self._clock.set_playback_time(time)
self._update()
@QtCore.pyqtSlot(int)
def _step(self, step):
self._clock.step_playback_index(step)
self._pause()
self._update()
@QtCore.pyqtSlot()
def _update(self):
if not self._viewer:
return
frame_index, frame_time = self._clock.get_playback_time_info()
dot_scene = self._viewer.dot(frame_time)
if dot_scene:
self._update_graph(dot_scene)
self._seekbar.set_frame_time(frame_index, frame_time)
@QtCore.pyqtSlot()
def _save_to_file(self):
filenames = QtWidgets.QFileDialog.getSaveFileName(
self, 'Select export file')
if not filenames[0]:
return
rect_size = self._scene.sceneRect().size()
img_size = QtCore.QSize(int(rect_size.width()),
int(rect_size.height()))
img = QtGui.QImage(img_size, QtGui.QImage.Format_ARGB32_Premultiplied)
painter = QtGui.QPainter(img)
self._scene.render(painter)
img.save(filenames[0])
painter.end()
def enter(self):
cfg_overrides = {}
if not self._seek_chkbox.isChecked():
cfg_overrides['fmt'] = 'dot'
cfg = self._get_scene_func(**cfg_overrides)
if not cfg:
return
self._seekbar.set_scene_metadata(cfg)
if self._seek_chkbox.isChecked():
self._init_viewer(cfg['backend'])
self._framerate = cfg['framerate']
self._duration = cfg['duration']
self._viewer.set_scene_from_string(cfg['scene'])
self._clock.configure(self._framerate, self._duration)
self._timer.setInterval(self._framerate[1] * 1000 /
self._framerate[0]) # in milliseconds
self._update()
else:
self._reset_viewer()
dot_scene = cfg['scene']
self._update_graph(dot_scene)
def leave(self):
self._pause()
def _reset_viewer(self):
if not self._viewer:
return
del self._viewer
self._viewer = None
def _init_viewer(self, rendering_backend):
if self._viewer:
return
self._viewer = ngl.Viewer()
self._viewer.configure(backend=misc.get_backend(rendering_backend),
offscreen=1,
width=16,
height=16)
def _update_graph(self, dot_scene):
basename = op.join(tempfile.gettempdir(), 'ngl_scene.')
dotfile = basename + 'dot'
svgfile = basename + 'svg'
open(dotfile, 'w').write(dot_scene)
try:
subprocess.call(['dot', '-Tsvg', dotfile, '-o' + svgfile])
except OSError, e:
QtWidgets.QMessageBox.critical(
self, 'Graphviz error',
'Error while executing dot (Graphviz): %s' % e.strerror,
QtWidgets.QMessageBox.Ok)
return
item = QtSvg.QGraphicsSvgItem(svgfile)
self._scene.clear()
self._scene.addItem(item)
self._scene.setSceneRect(item.boundingRect())
