3pp-mirror/Meshroom
1
0
Fork 0
mirror of https://github.com/alicevision/Meshroom.git synced 2025-04-28 17:57:16 +02:00
Code Issues Projects Releases Packages Wiki Activity

Merge pull request #1227 from ChemicalXandco/box_select

Browse source 
[ui] add support for selecting multiple nodes at once
This commit is contained in:
Fabien Castan 2021-05-03 23:42:11 +02:00 • committed by GitHub
commit 18be350e6f
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
8 changed files with 285 additions and 127 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
meshroom/common/qt.py
View file

@ -113,6 +113,7 @@ class QObjectListModel(QtCore.QAbstractListModel):
############
# List API #
############
@QtCore.Slot(QtCore.QObject)
def append(self, obj):
""" Insert object at the end of the model. """
self.extend([obj])
@ -182,6 +183,7 @@ class QObjectListModel(QtCore.QAbstractListModel):
self.endRemoveRows()
self.countChanged.emit()
@QtCore.Slot(QtCore.QObject)
def remove(self, obj):
""" Removes the first occurrence of the given object. Raises a ValueError if not in list. """
if not self.contains(obj):

25
meshroom/core/graph.py
View file

@ -362,29 +362,15 @@ class Graph(BaseObject):
child.resetValue()
return node, skippedEdges
def duplicateNode(self, srcNode):
""" Duplicate a node in the graph with its connections.
def duplicateNodes(self, srcNodes):
""" Duplicate nodes in the graph with their connections.
Args:
srcNode: the node to duplicate
Returns:
Node: the created node
"""
node, edges = self.copyNode(srcNode, withEdges=True)
return self.addNode(node)
def duplicateNodesFromNode(self, fromNode):
"""
Duplicate 'fromNode' and all the following nodes towards graph's leaves.
Args:
fromNode (Node): the node to start the duplication from
srcNodes: the nodes to duplicate
Returns:
OrderedDict[Node, Node]: the source->duplicate map
"""
srcNodes, srcEdges = self.dfsOnDiscover(startNodes=[fromNode], reverse=True, dependenciesOnly=True)
# use OrderedDict to keep duplicated nodes creation order
duplicates = OrderedDict()
@ -1146,11 +1132,6 @@ class Graph(BaseObject):
for node in self.nodes:
node.clearSubmittedChunks()
@Slot(Node)
def clearDataFrom(self, startNode):
for node in self.dfsOnDiscover(startNodes=[startNode], reverse=True, dependenciesOnly=True)[0]:
node.clearData()
def iterChunksByStatus(self, status):
""" Iterate over NodeChunks with the given status """
for node in self.nodes:

1
meshroom/core/node.py
View file

@ -706,7 +706,6 @@ class BaseNode(BaseObject):
def _isComputed(self):
return self.hasStatus(Status.SUCCESS)
@Slot()
def clearData(self):
""" Delete this Node internal folder.
Status will be reset to Status.NONE

30
meshroom/ui/commands.py
View file

@ -159,7 +159,7 @@ class RemoveNodeCommand(GraphCommand):
def redoImpl(self):
# only keep outEdges since inEdges are serialized in nodeDict
inEdges, self.outEdges = self.graph.removeNode(self.nodeName)
_, self.outEdges = self.graph.removeNode(self.nodeName)
return True
def undoImpl(self):
@ -173,33 +173,25 @@ class RemoveNodeCommand(GraphCommand):
self.graph.attribute(dstAttr))
class DuplicateNodeCommand(GraphCommand):
class DuplicateNodesCommand(GraphCommand):
"""
Handle node duplication in a Graph.
"""
def __init__(self, graph, srcNode, duplicateFollowingNodes, parent=None):
super(DuplicateNodeCommand, self).__init__(graph, parent)
self.srcNodeName = srcNode.name
self.duplicateFollowingNodes = duplicateFollowingNodes
self.duplicates = []
def __init__(self, graph, srcNodes, parent=None):
super(DuplicateNodesCommand, self).__init__(graph, parent)
self.srcNodeNames = [ n.name for n in srcNodes ]
self.setText("Duplicate Nodes")
def redoImpl(self):
srcNode = self.graph.node(self.srcNodeName)
if self.duplicateFollowingNodes:
duplicates = list(self.graph.duplicateNodesFromNode(srcNode).values())
self.setText("Duplicate {} nodes from {}".format(len(duplicates), self.srcNodeName))
else:
duplicates = [self.graph.duplicateNode(srcNode)]
self.setText("Duplicate {}".format(self.srcNodeName))
srcNodes = [ self.graph.node(i) for i in self.srcNodeNames ]
duplicates = list(self.graph.duplicateNodes(srcNodes).values())
self.duplicates = [ n.name for n in duplicates ]
return duplicates
def undoImpl(self):
# delete all the duplicated nodes
for nodeName in self.duplicates:
self.graph.removeNode(nodeName)
# remove all duplicates
for duplicate in self.duplicates:
self.graph.removeNode(duplicate)
class SetAttributeCommand(GraphCommand):

184
meshroom/ui/graph.py
View file

@ -273,6 +273,7 @@ class UIGraph(QObject):
self._sortedDFSChunks = QObjectListModel(parent=self)
self._layout = GraphLayout(self)
self._selectedNode = None
self._selectedNodes = QObjectListModel(parent=self)
self._hoveredNode = None
self.computeStatusChanged.connect(self.updateLockedUndoStack)
@ -499,36 +500,114 @@ class UIGraph(QObject):
position = Position(position.x(), position.y())
return self.push(commands.AddNodeCommand(self._graph, nodeType, position=position, **kwargs))
@Slot(Node, QPoint)
def moveNode(self, node, position):
def filterNodes(self, nodes):
"""Filter out the nodes that do not exist on the graph."""
return [ n for n in nodes if n in self._graph.nodes.values() ]
@Slot(Node, QPoint, QObject)
def moveNode(self, node, position, nodes=None):
"""
Move 'node' to the given 'position'.
Move 'node' to the given 'position' and also update the positions of 'nodes' if neccessary.
Args:
node (Node): the node to move
position (QPoint): the target position
nodes (list[Node]): the nodes to update the position of
"""
if not nodes:
nodes = [node]
nodes = self.filterNodes(nodes)
if isinstance(position, QPoint):
position = Position(position.x(), position.y())
self.push(commands.MoveNodeCommand(self._graph, node, position))
deltaX = position.x - node.x
deltaY = position.y - node.y
with self.groupedGraphModification("Move Selected Nodes"):
for n in nodes:
position = Position(n.x + deltaX, n.y + deltaY)
self.push(commands.MoveNodeCommand(self._graph, n, position))
@Slot(Node)
def removeNode(self, node):
@Slot(QObject)
def removeNodes(self, nodes):
"""
Remove 'nodes' from the graph.
Args:
nodes (list[Node]): the nodes to remove
"""
nodes = self.filterNodes(nodes)
if any([ n.locked for n in nodes ]):
return
with self.groupedGraphModification("Remove Selected Nodes"):
for node in nodes:
self.push(commands.RemoveNodeCommand(self._graph, node))
@Slot(Node)
def removeNodesFrom(self, startNode):
@Slot(QObject)
def removeNodesFrom(self, nodes):
"""
Remove all nodes starting from 'startNode' to graph leaves.
Args:
startNode (Node): the node to start from.
"""
with self.groupedGraphModification("Remove Nodes from {}".format(startNode.name)):
nodes, _ = self._graph.dfsOnDiscover(startNodes=[startNode], reverse=True, dependenciesOnly=True)
with self.groupedGraphModification("Remove Nodes From Selected Nodes"):
nodesToRemove, _ = self._graph.dfsOnDiscover(startNodes=nodes, reverse=True, dependenciesOnly=True)
# Perform nodes removal from leaves to start node so that edges
# can be re-created in correct order on redo.
for node in reversed(nodes):
self.removeNode(node)
self.removeNodes(list(reversed(nodesToRemove)))
@Slot(QObject, result="QVariantList")
def duplicateNodes(self, nodes):
"""
Duplicate 'nodes'.
Args:
nodes (list[Node]): the nodes to duplicate
Returns:
list[Node]: the list of duplicated nodes
"""
nodes = self.filterNodes(nodes)
# enable updates between duplication and layout to get correct depths during layout
with self.groupedGraphModification("Duplicate Selected Nodes", disableUpdates=False):
# disable graph updates during duplication
with self.groupedGraphModification("Node duplication", disableUpdates=True):
duplicates = self.push(commands.DuplicateNodesCommand(self._graph, nodes))
# move nodes below the bounding box formed by the duplicated node(s)
bbox = self._layout.boundingBox(duplicates)
for n in duplicates:
self.moveNode(n, Position(n.x, bbox[3] + self.layout.gridSpacing + n.y))
return duplicates
@Slot(QObject, result="QVariantList")
def duplicateNodesFrom(self, nodes):
"""
Duplicate all nodes starting from 'nodes' to graph leaves.
Args:
nodes (list[Node]): the nodes to start from.
Returns:
list[Node]: the list of duplicated nodes
"""
with self.groupedGraphModification("Duplicate Nodes From Selected Nodes"):
nodesToDuplicate, _ = self._graph.dfsOnDiscover(startNodes=nodes, reverse=True, dependenciesOnly=True)
duplicates = self.duplicateNodes(nodesToDuplicate)
return duplicates
@Slot(QObject)
def clearData(self, nodes):
""" Clear data from 'nodes'. """
nodes = self.filterNodes(nodes)
for n in nodes:
n.clearData()
@Slot(QObject)
def clearDataFrom(self, nodes):
"""
Clear data from all nodes starting from 'nodes' to graph leaves.
Args:
nodes (list[Node]): the nodes to start from.
"""
self.clearData(self._graph.dfsOnDiscover(startNodes=nodes, reverse=True, dependenciesOnly=True)[0])
@Slot(Attribute, Attribute)
def addEdge(self, src, dst):
@ -563,31 +642,6 @@ class UIGraph(QObject):
""" Reset 'attribute' to its default value """
self.push(commands.SetAttributeCommand(self._graph, attribute, attribute.defaultValue()))
@Slot(Node, bool, result="QVariantList")
def duplicateNode(self, srcNode, duplicateFollowingNodes=False):
"""
Duplicate a node an optionally all the following nodes to graph leaves.
Args:
srcNode (Node): node to start the duplication from
duplicateFollowingNodes (bool): whether to duplicate all the following nodes to graph leaves
Returns:
[Nodes]: the list of duplicated nodes
"""
title = "Duplicate Nodes from {}" if duplicateFollowingNodes else "Duplicate {}"
# enable updates between duplication and layout to get correct depths during layout
with self.groupedGraphModification(title.format(srcNode.name), disableUpdates=False):
# disable graph updates during duplication
with self.groupedGraphModification("Node duplication", disableUpdates=True):
duplicates = self.push(commands.DuplicateNodeCommand(self._graph, srcNode, duplicateFollowingNodes))
# move nodes below the bounding box formed by the duplicated node(s)
bbox = self._layout.boundingBox(duplicates)
for n in duplicates:
self.moveNode(n, Position(n.x, bbox[3] + self.layout.gridSpacing + n.y))
return duplicates
@Slot(CompatibilityNode, result=Node)
def upgradeNode(self, node):
""" Upgrade a CompatibilityNode. """
@ -621,9 +675,55 @@ class UIGraph(QObject):
def removeAttribute(self, attribute):
self.push(commands.ListAttributeRemoveCommand(self._graph, attribute))
@Slot(Node)
def appendSelection(self, node):
""" Append 'node' to the selection if it is not already part of the selection. """
if not self._selectedNodes.contains(node):
self._selectedNodes.append(node)
@Slot("QVariantList")
def selectNodes(self, nodes):
""" Append 'nodes' to the selection. """
for node in nodes:
self.appendSelection(node)
self.selectedNodesChanged.emit()
@Slot(Node)
def selectFollowing(self, node):
""" Select all the nodes the depend on 'node'. """
self.selectNodes(self._graph.dfsOnDiscover(startNodes=[node], reverse=True, dependenciesOnly=True)[0])
@Slot(QObject, QObject)
def boxSelect(self, selection, draggable):
"""
Select nodes that overlap with 'selection'.
Takes into account the zoom and position of 'draggable'.
Args:
selection: the rectangle selection widget.
draggable: the parent widget that has position and scale data.
"""
x = selection.x() - draggable.x()
y = selection.y() - draggable.y()
otherX = x + selection.width()
otherY = y + selection.height()
x, y, otherX, otherY = [ i / draggable.scale() for i in [x, y, otherX, otherY] ]
if x == otherX or y == otherY:
return
for n in self._graph.nodes:
bbox = self._layout.boundingBox([n])
# evaluate if the selection and node intersect
if not (x > bbox[2] + bbox[0] or otherX < bbox[0] or y > bbox[3] + bbox[1] or otherY < bbox[1]):
self.appendSelection(n)
self.selectedNodesChanged.emit()
@Slot()
def clearNodeSelection(self):
""" Clear node selection. """
self.selectedNode = None
""" Clear all node selection. """
self._selectedNode = None
self._selectedNodes.clear()
self.selectedNodeChanged.emit()
self.selectedNodesChanged.emit()
def clearNodeHover(self):
""" Reset currently hovered node to None. """
@ -646,9 +746,13 @@ class UIGraph(QObject):
lockedChanged = Signal()
selectedNodeChanged = Signal()
# Currently selected node
# Current main selected node
selectedNode = makeProperty(QObject, "_selectedNode", selectedNodeChanged, resetOnDestroy=True)
selectedNodesChanged = Signal()
# Currently selected nodes
selectedNodes = makeProperty(QObject, "_selectedNodes", selectedNodesChanged, resetOnDestroy=True)
hoveredNodeChanged = Signal()
# Currently hovered node
hoveredNode = makeProperty(QObject, "_hoveredNode", hoveredNodeChanged, resetOnDestroy=True)

148
meshroom/ui/qml/GraphEditor/GraphEditor.qml
View file

@ -55,18 +55,35 @@ Item {
function selectNode(node)
{
uigraph.selectedNode = node
if (node !== null) {
uigraph.appendSelection(node)
uigraph.selectedNodesChanged()
}
}
/// Duplicate a node and optionnally all the following ones
function duplicateNode(node, duplicateFollowingNodes) {
var nodes = uigraph.duplicateNode(node, duplicateFollowingNodes)
selectNode(nodes[0])
function duplicateNode(duplicateFollowingNodes) {
if (duplicateFollowingNodes) {
var nodes = uigraph.duplicateNodesFrom(uigraph.selectedNodes)
} else {
var nodes = uigraph.duplicateNodes(uigraph.selectedNodes)
}
uigraph.clearNodeSelection()
uigraph.selectedNode = nodes[0]
uigraph.selectNodes(nodes)
}
Keys.onPressed: {
if(event.key === Qt.Key_F)
fit()
if(event.key === Qt.Key_Delete)
if(event.modifiers == Qt.AltModifier)
uigraph.removeNodesFrom(uigraph.selectedNodes)
else
uigraph.removeNodes(uigraph.selectedNodes)
if(event.key === Qt.Key_D)
duplicateNode(event.modifiers == Qt.AltModifier)
}
MouseArea {
@ -82,7 +99,7 @@ Item {
hoverEnabled: true
acceptedButtons: Qt.LeftButton | Qt.RightButton | Qt.MiddleButton
drag.threshold: 0
cursorShape: drag.active ? Qt.ClosedHandCursor : Qt.ArrowCursor
cursorShape: drag.target == draggable ? Qt.ClosedHandCursor : Qt.ArrowCursor
onWheel: {
var zoomFactor = wheel.angleDelta.y > 0 ? factor : 1/factor
@ -98,12 +115,20 @@ Item {
}
onPressed: {
if(mouse.button != Qt.MiddleButton && mouse.modifiers == Qt.NoModifier)
selectNode(null)
if(mouse.button == Qt.MiddleButton || (mouse.button & Qt.LeftButton && mouse.modifiers & Qt.ShiftModifier))
if (mouse.button != Qt.MiddleButton && mouse.modifiers == Qt.NoModifier) {
uigraph.clearNodeSelection()
}
if (mouse.button == Qt.LeftButton && (mouse.modifiers == Qt.NoModifier || mouse.modifiers == Qt.ControlModifier)) {
boxSelect.startX = mouseX
boxSelect.startY = mouseY
boxSelectDraggable.x = mouseX
boxSelectDraggable.y = mouseY
drag.target = boxSelectDraggable
}
if (mouse.button == Qt.MiddleButton || (mouse.button == Qt.LeftButton && mouse.modifiers & Qt.ShiftModifier)) {
drag.target = draggable // start drag
}
}
onReleased: {
drag.target = undefined // stop drag
root.forceActiveFocus()
@ -319,6 +344,7 @@ Item {
property bool canComputeNode: currentNode != null && uigraph.graph.canCompute(currentNode)
//canSubmitOrCompute: return int n : 0 >= n <= 3 | n=0 cannot submit or compute | n=1 can compute | n=2 can submit | n=3 can compute & submit
property int canSubmitOrCompute: currentNode != null && uigraph.graph.canSubmitOrCompute(currentNode)
width: 220
onClosed: currentNode = null
MenuItem {
@ -355,31 +381,31 @@ Item {
}
MenuSeparator {}
MenuItem {
text: "Duplicate Node" + (duplicateFollowingButton.hovered ? "s From Here" : "")
text: "Duplicate Node(s)" + (duplicateFollowingButton.hovered ? " From Here" : "")
enabled: true
onTriggered: duplicateNode(nodeMenu.currentNode, false)
onTriggered: duplicateNode(false)
MaterialToolButton {
id: duplicateFollowingButton
height: parent.height
anchors { right: parent.right; rightMargin: parent.padding }
text: MaterialIcons.fast_forward
onClicked: {
duplicateNode(nodeMenu.currentNode, true);
duplicateNode(true);
nodeMenu.close();
}
}
}
MenuItem {
text: "Remove Node" + (removeFollowingButton.hovered ? "s From Here" : "")
text: "Remove Node(s)" + (removeFollowingButton.hovered ? " From Here" : "")
enabled: nodeMenu.currentNode ? !nodeMenu.currentNode.locked : false
onTriggered: uigraph.removeNode(nodeMenu.currentNode)
onTriggered: uigraph.removeNodes(uigraph.selectedNodes)
MaterialToolButton {
id: removeFollowingButton
height: parent.height
anchors { right: parent.right; rightMargin: parent.padding }
text: MaterialIcons.fast_forward
onClicked: {
uigraph.removeNodesFrom(nodeMenu.currentNode);
uigraph.removeNodesFrom(uigraph.selectedNodes);
nodeMenu.close();
}
}
@ -438,9 +464,9 @@ Item {
onAccepted: {
if(deleteFollowing)
graph.clearDataFrom(node);
uigraph.clearDataFrom(uigraph.selectedNodes);
else
node.clearData();
uigraph.clearData(uigraph.selectedNodes);
}
onClosed: destroy()
}
@ -454,63 +480,111 @@ Item {
model: root.graph ? root.graph.nodes : undefined
property bool loaded: model ? count === model.count : false
property bool dragging: false
delegate: Node {
id: nodeDelegate
property bool animatePosition: true
node: object
width: uigraph.layout.nodeWidth
selected: uigraph.selectedNode === node
mainSelected: uigraph.selectedNode === node
selected: uigraph.selectedNodes.contains(node)
hovered: uigraph.hoveredNode === node
onSelectedChanged: if(selected) forceActiveFocus()
onAttributePinCreated: registerAttributePin(attribute, pin)
onAttributePinDeleted: unregisterAttributePin(attribute, pin)
onPressed: {
selectNode(node)
if(mouse.button == Qt.LeftButton && mouse.modifiers & Qt.AltModifier)
{
duplicateNode(node, true)
if (mouse.button == Qt.LeftButton) {
if (mouse.modifiers & Qt.ControlModifier && !(mouse.modifiers & Qt.AltModifier)) {
if (mainSelected && selected) {
// left clicking a selected node twice with control will deselect it
uigraph.selectedNodes.remove(node)
uigraph.selectedNodesChanged()
selectNode(null)
return
}
} else if (mouse.modifiers & Qt.AltModifier) {
if (!(mouse.modifiers & Qt.ControlModifier)){
uigraph.clearNodeSelection()
}
uigraph.selectFollowing(node)
} else if (!mainSelected && !selected) {
uigraph.clearNodeSelection()
}
} else if (mouse.button == Qt.RightButton) {
if (!mainSelected && !selected) {
uigraph.clearNodeSelection()
}
if(mouse.button == Qt.RightButton)
{
nodeMenu.currentNode = node
nodeMenu.popup()
}
selectNode(node)
}
onDoubleClicked: root.nodeDoubleClicked(mouse, node)
onMoved: uigraph.moveNode(node, position)
onMoved: uigraph.moveNode(node, position, uigraph.selectedNodes)
onEntered: uigraph.hoveredNode = node
onExited: uigraph.hoveredNode = null
Keys.onDeletePressed: {
if(node.locked)
return
if(event.modifiers == Qt.AltModifier)
uigraph.removeNodesFrom(node)
else
uigraph.removeNode(node)
onPositionChanged: {
if (dragging && uigraph.selectedNodes.contains(node)) {
// update all selected nodes positions with this node that is being dragged
for (var i = 0; i < nodeRepeater.count; i++) {
var otherNode = nodeRepeater.itemAt(i)
if (uigraph.selectedNodes.contains(otherNode.node) && otherNode.node != node) {
otherNode.x = otherNode.node.x + (x - node.x)
otherNode.y = otherNode.node.y + (y - node.y)
}
}
}
}
// allow all nodes to know if they are being dragged
onDraggingChanged: nodeRepeater.dragging = dragging
// must not be enabled during drag because the other nodes will be slow to match the movement of the node being dragged
Behavior on x {
enabled: animatePosition
enabled: !nodeRepeater.dragging
NumberAnimation { duration: 100 }
}
Behavior on y {
enabled: animatePosition
enabled: !nodeRepeater.dragging
NumberAnimation { duration: 100 }
}
}
}
}
Rectangle {
id: boxSelect
property int startX: 0
property int startY: 0
property int toX: boxSelectDraggable.x - startX
property int toY: boxSelectDraggable.y - startY
x: toX < 0 ? startX + toX : startX
y: toY < 0 ? startY + toY : startY
width: Math.abs(toX)
height: Math.abs(toY)
color: "transparent"
border.color: activePalette.text
visible: mouseArea.drag.target == boxSelectDraggable
onVisibleChanged: {
if (!visible) {
uigraph.boxSelect(boxSelect, draggable)
}
}
}
Item {
id: boxSelectDraggable
}
}
// Toolbar

13
meshroom/ui/qml/GraphEditor/Node.qml
View file

@ -20,8 +20,12 @@ Item {
/// Whether the node is in compatibility mode
readonly property bool isCompatibilityNode: node ? node.hasOwnProperty("compatibilityIssue") : false
/// Mouse related states
property bool mainSelected: false
property bool selected: false
property bool hovered: false
property bool dragging: mouseArea.drag.active
/// Combined x and y
property point position: Qt.point(x, y)
/// Styling
property color shadowColor: "#cc000000"
readonly property color defaultColor: isCompatibilityNode ? "#444" : activePalette.base
@ -93,6 +97,7 @@ Item {
// Main Layout
MouseArea {
id: mouseArea
width: parent.width
height: body.height
drag.target: root
@ -117,9 +122,9 @@ Item {
Rectangle {
anchors.fill: nodeContent
anchors.margins: -border.width
visible: root.selected || root.hovered
visible: root.mainSelected || root.hovered
border.width: 2.5
border.color: root.selected ? activePalette.highlight : Qt.darker(activePalette.highlight, 1.5)
border.color: root.mainSelected ? activePalette.highlight : Qt.darker(activePalette.highlight, 1.5)
opacity: 0.9
radius: background.radius + border.width
color: "transparent"
@ -151,7 +156,7 @@ Item {
id: header
width: parent.width
height: headerLayout.height
color: root.selected ? activePalette.highlight : root.baseColor
color: root.mainSelected ? activePalette.highlight : root.selected ? Qt.darker(activePalette.highlight, 1.1): root.baseColor
radius: background.radius
// Fill header's bottom radius
@ -174,7 +179,7 @@ Item {
Layout.fillWidth: true
text: node ? node.label : ""
padding: 4
color: root.selected ? "white" : activePalette.text
color: root.mainSelected ? "white" : activePalette.text
elide: Text.ElideMiddle
font.pointSize: 8
}

3
tests/test_graph.py
View file

@ -264,7 +264,8 @@ def test_duplicate_nodes():
n3 = g.addNewNode('AppendFiles', input=n1.output, input2=n2.output)
# duplicate from n1
nMap = g.duplicateNodesFromNode(fromNode=n1)
nodes_to_duplicate, _ = g.dfsOnDiscover(startNodes=[n1], reverse=True, dependenciesOnly=True)
nMap = g.duplicateNodes(srcNodes=nodes_to_duplicate)
for s, d in nMap.items():
assert s.nodeType == d.nodeType