scipion-pyworkflow 3.10.5__py3-none-any.whl → 3.11.0__py3-none-any.whl

pyworkflow/gui/graph.py

@@ -1,247 +0,0 @@
-# **************************************************************************
-# *
-# * Authors:     J.M. De la Rosa Trevin (jmdelarosa@cnb.csic.es)
-# *
-# * Unidad de  Bioinformatica of Centro Nacional de Biotecnologia , CSIC
-# *
-# * This program is free software; you can redistribute it and/or modify
-# * it under the terms of the GNU General Public License as published by
-# * the Free Software Foundation; either version 3 of the License, or
-# * (at your option) any later version.
-# *
-# * This program is distributed in the hope that it will be useful,
-# * but WITHOUT ANY WARRANTY; without even the implied warranty of
-# * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# * GNU General Public License for more details.
-# *
-# * You should have received a copy of the GNU General Public License
-# * along with this program; if not, write to the Free Software
-# * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
-# * 02111-1307  USA
-# *
-# *  All comments concerning this program package may be sent to the
-# *  e-mail address 'scipion@cnb.csic.es'
-# *
-# **************************************************************************
-""" 
-This module implements a simple algorithm to display a graph(mainly a tree)
-level by level, using only Tkinter.
-"""
-
-
-# TODO: all LevelTree code is DEPRECATED...remove it after cleaning
-# and include all code from graph_layout
-
-
-class LevelTree(object):
-    """ Class to render the Graph in a Canvas. """
-
-    def __init__(self, graph):
-        self.DY = 65
-        self.DX = 15
-        self.FONT = "sans-serif"
-        self.FONTSIZE = 9
-        self.graph = graph
-        self.canvas = None
-
-    def setCanvas(self, canvas):
-        self.canvas = canvas
-
-    def paint(self, createNode=None, createEdge=None, maxLevel=9999, usePositions=False):
-        """ Paint the Graph, nodes will be positioned by levels.
-        Params:
-            canvas: the canvas object to paint the graph.
-            createNode: function to build the Item that represents a Node.
-                    the Item created should have the following methods:
-                        getDimensions: return the width and height
-                        moveTo: change the position of the Item
-            createEdge: function to build an Edge connection two Nodes
-            usePositions: if this is True, use the nodes positions without
-                recomputing them.
-            
-            If createNode and createEdge are None, the default ones will be used,
-            that requires the setCanvas method had to be called first.
-        """
-        self.createNode = createNode or self._defaultCreateNode
-        self.createEdge = createEdge or self._defaultCreateEdge
-        self.maxLevel = maxLevel
-        rootNode = self.graph.getRoot()
-
-        if usePositions:
-            self._paintNodeWithPosition(rootNode)
-            self._paintEdges(rootNode)
-        else:
-            self._setLevel(rootNode, 0, None)
-            self._paintNodeWithChilds(rootNode, 1)
-            m = 9999
-            for left, right in rootNode.hLimits:
-                m = min(m, left)
-            self._createEdges(rootNode, -m + self.DY)
-
-    def _setLevel(self, node, level, parent):
-        """ Set the level of the nodes. """
-        node.level = level
-        node.parent = parent
-        nextLevel = level + 1
-        if nextLevel > self.maxLevel:
-            return
-        for child in node.getChildren():
-            if nextLevel > getattr(child, 'level', 0):
-                self._setLevel(child, nextLevel, node)
-
-    def _paintNodeWithChilds(self, node, level):
-        y = level * self.DY
-
-        self._paintNode(node, y)
-
-        if level > self.maxLevel:
-            return
-
-        childs = [c for c in node.getChildren() if c.parent is node]
-        n = len(childs)
-
-        if n > 0:
-            # width = (xmax - xmin) / n
-            for c in childs:
-                self._paintNodeWithChilds(c, level + 1)
-
-            if n > 1:
-                offset = 0
-                for i in range(n - 1):
-                    sep = self._getChildsSeparation(childs[i], childs[i + 1])
-                    offset += sep
-                    c = childs[i + 1]
-                    c.offset = offset
-
-                total = childs[0].half + offset + childs[-1].half
-                half = total / 2
-                for c in childs:
-                    c.offset -= half - childs[0].half
-
-            else:
-                childs[0].offset = 0
-            self._getHLimits(node)
-
-    def _defaultCreateNode(self, canvas, node, y):
-        """ If not createNode is specified, this one will be used
-        by default. 
-        """
-        if canvas is None:
-            raise Exception("method setCanvas should be called before using _defaultCreateNode")
-        nodeText = node.getLabel()
-        textColor = 'black'
-
-        return canvas.createTextbox(nodeText, 100, y, bgColor='light blue', textColor=textColor, margin=0)
-
-    def _defaultCreateEdge(self, srcItem, dstItem):
-        if self.canvas is None:
-            raise Exception("method setCanvas should be called before using _defaultCreateEdge")
-        self.canvas.createEdge(srcItem, dstItem)
-
-    def _paintNode(self, node, y):
-        """ Paint a node of the graph.
-        Params:
-           canvas: the canvas in which to paint.
-           node: the node of the graph to be painted.
-           y: level in the tree where to paint.
-        Returns:
-           the create item in the canvas.
-        """
-        item = self.createNode(self.canvas, node, y)
-        node.width, node.height = item.getDimensions()
-        node.half = node.width / 2
-        node.hLimits = [[-node.half, node.half]]
-        node.y = item.y
-        node.offset = 0
-        # Create link from both sides to reach
-        node.item = item
-        item.node = node
-
-        return item
-
-    def _printHLimits(self, node, msg):
-        print("\n=====%s========" % msg)
-        print(" dd: %s" % node.t.text.replace('\n', '_'))
-        print("  offset: %d, width: %d" % (node.offset, node.width))
-        print("  hlimits:")
-        for l, r in node.hLimits:
-            print("   [%d, %d]" % (l, r))
-
-    def _getHLimits(self, node):
-        """
-        This function will traverse the tree
-        from node to build the left and right profiles(hLimits)
-        for each level of the tree
-        """
-        node.hLimits = [[-node.half, node.half]]
-        childs = [c for c in node.getChildren() if c.parent is node]
-        for child in childs:
-            count = 1
-            if not hasattr(child, 'hLimits'):
-                print("node %s has no hLimits" % child.label)
-                raise Exception()
-
-            for l, r in child.hLimits:
-                l += child.offset
-                r += child.offset
-                if count < len(node.hLimits):
-                    if l < node.hLimits[count][0]:
-                        node.hLimits[count][0] = l
-                    if r > node.hLimits[count][1]:
-                        node.hLimits[count][1] = r
-                else:
-                    node.hLimits.append([l, r])
-                count += 1
-
-    def _getChildsSeparation(self, child1, child2):
-        """ Calculate separation between siblings
-        at each height level. """
-        sep = 0
-        hL1 = child1.hLimits
-        hL2 = child2.hLimits
-        n1 = len(hL1)
-        n2 = len(hL2)
-        h = min(n1, n2)
-
-        for i in range(h):
-            right = hL1[i][1]
-            left = hL2[i][0]
-            if left + sep < right:
-                sep = right - left
-
-        return sep + self.DX
-
-    def _createEdges(self, node, x):
-        """ Adjust the position of the nodes
-        and create the edges between them.
-        """
-        nx = x + node.offset
-        node.item.moveTo(nx, node.y)
-
-        if node.level == self.maxLevel:
-            return
-
-        for c in node.getChildren():
-            if c.parent is node:
-                self._createEdges(c, nx)
-            self.createEdge(node.item, c.item)
-
-    def _paintNodeWithPosition(self, node):
-        """ Paint nodes using its position. """
-        self._paintNode(node, None)
-
-        for child in node.getChildren():
-            # parent = None for nodes that have been not traversed
-            parent = getattr(child, 'parent', None)
-            if parent is None:
-                child.parent = node
-                self._paintNodeWithPosition(child)
-
-    def _paintEdges(self, node):
-        """ Paint only the edges between nodes, assuming they are
-        already well positioned. 
-        """
-        for child in node.getChildren():
-            if child.parent is node:
-                self._paintEdges(child)
-            self.createEdge(node.item, child.item)

pyworkflow/gui/graph_layout.py

@@ -1,271 +0,0 @@
-# **************************************************************************
-# *
-# * Authors:     J.M. De la Rosa Trevin (jmdelarosa@cnb.csic.es)
-# *
-# * Unidad de  Bioinformatica of Centro Nacional de Biotecnologia , CSIC
-# *
-# * This program is free software; you can redistribute it and/or modify
-# * it under the terms of the GNU General Public License as published by
-# * the Free Software Foundation; either version 3 of the License, or
-# * (at your option) any later version.
-# *
-# * This program is distributed in the hope that it will be useful,
-# * but WITHOUT ANY WARRANTY; without even the implied warranty of
-# * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# * GNU General Public License for more details.
-# *
-# * You should have received a copy of the GNU General Public License
-# * along with this program; if not, write to the Free Software
-# * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
-# * 02111-1307  USA
-# *
-# *  All comments concerning this program package may be sent to the
-# *  e-mail address 'scipion@cnb.csic.es'
-# *
-# **************************************************************************
-import logging
-
-logger = logging.getLogger(__name__)
-
-from pyworkflow import Config, SCIPION_DEFAULT_FONT_SIZE
-
-
-
-class GraphLayout(object):
-    """ Base class for all algorithm that implement
-    functions to organize a graph in a plane.
-    """
-    def __init__(self):
-        super().__init__()
-        self.DY = 65
-        self.DX = 15
-        self._fontScaleFactor = None
-
-    def getY(self):
-        """
-        :return: Y distance affected by the font size
-
-        """
-
-        return self.DY*self.getFontScaleFactor()
-
-    def getFontScaleFactor(self):
-        """
-        :return: The scale factor between default font size 10, and current one
-
-        """
-        if self._fontScaleFactor is None:
-
-            self._fontScaleFactor = Config.SCIPION_FONT_SIZE/SCIPION_DEFAULT_FONT_SIZE
-
-        return self._fontScaleFactor
-
-    def draw(self, graph, **kwargs):
-        """ Setup the nodes position in the plane. """
-        pass
-
-
-class LevelTreeLayout(GraphLayout):
-    """ Organize the nodes of the graph by levels.
-    It will recursively organize children and then
-    fit the sibling trees. """
-    
-    def __init__(self, partial=False):
-        GraphLayout.__init__(self)
-        self.maxLevel = 9999
-        self.partial = partial
-
-    def draw(self, graph, **kwargs):
-        """
-        Organize nodes of the graph in the plane.
-        Nodes should have x, y, width and height attributes.
-        x and y will be modified.
-        """
-        rootNode = graph.getRoot()
-        
-        # Setup empty layout for each node
-        for node in graph.getNodes():
-            node._layout = {}
-
-        visitDict = dict()
-        # Do some level initialization on each node
-        self._setLayoutLevel(rootNode,  1, visitDict)
-        self._computeNodeOffsets(rootNode, 1)
-        # Compute extreme left limit
-        m = 9999
-        for left, _ in rootNode._layout['hLimits']:
-            m = min(m, left)
-        
-        self._applyNodeOffsets(rootNode, -m + self.getY())
-        
-        # Clean temporary _layout attributes
-        for node in graph.getNodes():
-            del node._layout
-
-    def _isNewNode(self, node):
-        return node.x == 0 or node.y == 0 or node.isRoot()
-        
-    def _setLayoutLevel(self, node, level, parent,  ancestors=[]):
-        """ Iterate over all nodes and set _layout dict.
-        Also set the node level, which is defined
-        as the max level of a parent + 1
-        """
-        if level > self.maxLevel:
-            return
-
-        layout = node._layout
-
-        if level > layout.get('level', 0):
-            # Calculate the y-position depending on the level
-            # and the delta-Y (DY)
-            if not self.partial or self._isNewNode(node):
-                node.y = level * self.getY()
-            layout['level'] = level
-            layout['parent'] = parent
-            if hasattr(node, 'width'):
-                half = node.width / 2
-            else:
-                half = 50
-            layout['half'] = half
-            layout['hLimits'] = [[-half, half]]
-            layout['offset'] = 0
-
-            if self.__isNodeExpanded(node):
-                ancestors.append(node.getName())
-                for child in node.getChildren():
-                    if child.getName() in ancestors:
-                        logger.warning("WARNING: There might be a cyclic redundancy error in this protocol: %s (%s)" %(child.getLabel(),
-                                                                                                                       child.getName()))
-                    if Config.debugOn():
-                        print("%s: Setting layout for child %s" % ("-" * level, child), flush=True)
-                    self._setLayoutLevel(child, level+1, node, ancestors.copy())
-
-    def __isNodeExpanded(self, node):
-        """ Check if the status of the node is expanded or collapsed. """
-        return getattr(node, 'expanded', True)
-        
-    def __setNodeOffset(self, node, offset):
-        node._layout['offset'] = offset
-        
-    def __getNodeHalf(self, node):
-        return node._layout['half']
-    
-    def __getNodeChilds(self, node):
-        """ Return the node's childs that have been 
-        visited by this node first (its 'parent')
-        """
-        if self.__isNodeExpanded(node):
-            return [c for c in node.getChildren() if c._layout['parent'] is node]
-        else:
-            return []  # treat collapsed nodes as if they have no childs
-        
-    def _computeNodeOffsets(self, node, level):
-        """ Position a parent node and its childs.
-        Only this sub-tree will be considered at this point.
-        Then it will be adjusted with node siblings.
-        """
-        if level > self.maxLevel:
-            return
-        
-        childs = self.__getNodeChilds(node)
-        n = len(childs)
-
-        if n > 0:
-            for c in childs:
-                self._computeNodeOffsets(c, level + 1)
-                
-            if n > 1:
-                offset = 0
-                # Keep right limits to compute the separation between siblings
-                # some times it not enough to compare with the left sibling
-                # for some child levels of the node
-                rightLimits = [r for l, r in childs[0]._layout['hLimits']]
-                
-                for i in range(n-1):
-                    sep = self._getChildsSeparation(childs[i], childs[i+1], rightLimits)
-                    offset += sep
-                    c = childs[i+1]
-                    self.__setNodeOffset(c, offset)
-                
-                half0 = self.__getNodeHalf(childs[0])
-                total = half0 + offset + self.__getNodeHalf(childs[-1])
-                half = total / 2
-                for c in childs:
-                    self.__setNodeOffset(c, c._layout['offset'] - half + half0)
-            else:
-                self.__setNodeOffset(childs[0], 0)
-            
-            self._computeHLimits(node)      
-    
-    def _computeHLimits(self, node):
-        """ This function will traverse the tree
-        from node to build the left and right profiles(hLimits)
-        for each level of the tree
-        """
-        layout = node._layout
-        hLimits = layout['hLimits']
-
-        childs = self.__getNodeChilds(node)
-        
-        for child in childs:
-            count = 1
-            layout = child._layout
-            for l, r in layout['hLimits']:
-                l += layout['offset']
-                r += layout['offset']
-
-                if count < len(hLimits):
-                    if l < hLimits[count][0]:
-                        hLimits[count][0] = l
-                    if r > hLimits[count][1]:
-                        hLimits[count][1] = r
-                else:
-                    hLimits.append([l, r])
-                count += 1
-                
-    def _getChildsSeparation(self, child1, child2, rightLimits):
-        """Calculate separation between siblings
-        at each height level"""
-        sep = 0 
-        hL2 = child2._layout['hLimits']
-        n1 = len(rightLimits)
-        n2 = len(hL2)
-        h = min(n1, n2)
-            
-        for i in range(h):
-            right = rightLimits[i]
-            left = hL2[i][0]            
-            if left + sep < right:
-                sep = right - left
-            rightLimits[i] = hL2[i][1]
-                
-        if n1 > n2:
-            # If there are more levels in the rightLimits
-            # updated the last ones like if they belong 
-            # to next sibling is is now (sep + self.DX) away
-            for i in range(h, n1):
-                rightLimits[i] -= sep + self.DX
-        else:
-            # If the current right sibling has more levels
-            # just add them to the current rightLimits
-            for i in range(h, n2):
-                rightLimits.append(hL2[i][1])
-                
-        return sep + self.DX
-    
-    def _applyNodeOffsets(self, node, x):
-        """ Adjust the x-position of the nodes by applying the offsets.
-        """
-        if node._layout['level'] == self.maxLevel:
-            return 
-        
-        layout = node._layout
-
-        if not self.partial or self._isNewNode(node):
-            node.x = x + layout['offset']
-        
-        childs = self.__getNodeChilds(node)
-        
-        for child in childs:
-            self._applyNodeOffsets(child, node.x)
-