Exemplo n.º 1
0
def get_information(file_path):  # using target_MDG and a benchmark, create result
    """
    Execute Each algorithm for given file and return TurboMQ, cohesion, and coupling
    :param file_path: A path of dot file
    :return: Clustering result - value of TurboMQ, A list of [Cohesion, Coupling], A list of result clusters
    """
    targetMDG = make_target_MDG(file_path)
    methods = ['WCA', 'HC', 'WCA_HC', 'SA', 'WCA_SA', 'PSO', 'WCA_PSO']
    clusters_set = []
    TMQ = []
    cohe_coup = []
    print("====WCA start====\n")
    clusters_set.append(WCA(targetMDG))
    print("====WCA end====\n\n")
    
    print("====HC start====\n")
    clusters_set.append(HC.HC(targetMDG))
    print("====HC end====\n\n")
    
    print("====WCA_HC start====\n")
    clusters_set.append(HC.WCA_HC(targetMDG, WCA(targetMDG)))
    print("====WCA_HC end====\n\n")
    
    print("====SA start====\n")
    clusters_set.append(SA.SA(targetMDG))
    print("====SA end====\n\n")
    
    print("====WCA_SA start====\n")
    clusters_set.append(SA.WCA_SA(targetMDG, WCA(targetMDG)))
    print("====WCA_SA end====\n\n")
    
    print("====PSO start====\n\n")
    clusters_set.append(PSO.PSO(targetMDG))
    print("====PSO end====\n\n")
    
    print("====WCA_PSO start====\n\n")
    clusters_set.append(PSO.WCA_PSO(targetMDG, WCA(targetMDG)))
    print("====WCA_PSO end====\n\n")
    
    # get TMQ data
    for clusters in clusters_set:
        TMQ.append(TurboMQ.calculate_fitness(clusters, targetMDG))
        cohe_coup.append(TurboMQ.get_cohesion_coupling(clusters, targetMDG))
    # write result files
    for i in range(len(methods)):
        DotParser.write_file(file_path, methods[i], clusters_set[i], targetMDG)
        
    return TMQ, cohe_coup, clusters_set
Exemplo n.º 2
0
def make_target_MDG(file_path):
    """
    Make MDG based on given file
    :param file_path: A path of dot file
    :return: MDG graph of given dot file
    """
    dot_file = DotParser.read_and_render('test/' + file_path)
    # print(dot_file.source)
    
    # get edge information and parse it
    edges = DotParser.parser(dot_file, "->")  # second argument should be "--" or "->" (depends on .dot file format)
    
    # make dependency graph and set feature vector
    targetMDG = MDG.MDG(edges)
    # print(targetMDG.edges)
    targetMDG.set_feature_vector()
    return targetMDG
Exemplo n.º 3
0
def main():

    parser = argparse.ArgumentParser(description='Modularize given dot file')
    parser.add_argument('file_path',
                        metavar='F',
                        type=str,
                        nargs='+',
                        help='File path for dot file')
    parser.add_argument(
        '-a',
        help=
        'Algorithm for modularization. All, WCA, HC, WCA_HC, SA, WCA_SA, PSO, WCA_PSO'
    )
    args = parser.parse_args()

    file_path = args.file_path
    if args.a:
        modularizeMethod = args.a
    else:
        modularizeMethod = 'All'

    for single_file in file_path:

        targetMDG = MakeResult.make_target_MDG(single_file)
        clusters = None
        if modularizeMethod == 'WCA':
            clusters = WCA(targetMDG)
        elif modularizeMethod == 'HC':
            clusters = HC.HC(targetMDG)
        elif modularizeMethod == 'WCA_HC':
            clusters = HC.WCA_HC(targetMDG, WCA(targetMDG))
        elif modularizeMethod == 'SA':
            clusters = SA.SA(targetMDG)
        elif modularizeMethod == 'WCA_SA':
            clusters = SA.WCA_SA(targetMDG, WCA(targetMDG))
        elif modularizeMethod == 'PSO':
            clusters = PSO.PSO(targetMDG)
        elif modularizeMethod == 'WCA_PSO':
            clusters = PSO.WCA_PSO(targetMDG, WCA(targetMDG))
        elif modularizeMethod == 'All':
            MakeResult.print_result(single_file)

        if modularizeMethod != 'All':
            DotParser.write_file(single_file, modularizeMethod, clusters,
                                 targetMDG)
Exemplo n.º 4
0
 def __init__(self, infile):
     self.Parser = DotParser()
     self.Graph = self.Parser.readFile(infile)
     self.Analysis = GraphAnalysis(self.Graph)
     self.State = NBODY
Exemplo n.º 5
0
class JumanG:
    def __init__(self, infile):
        self.Parser = DotParser()
        self.Graph = self.Parser.readFile(infile)
        self.Analysis = GraphAnalysis(self.Graph)
        self.State = NBODY

    def outputToTikz(self, graph, outfile):
        TW.tikGraph(graph, outfile)

    def runRadial(self):
        return RD.radialAssign(self.Graph)

    def runNBody(self, useRadialSeed=True):
        if useRadialSeed:
            return NB.reposition(self.runRadial(), False)
        else:
            return NB.reposition(self.Graph, True)

    def runCirco(self):
        outputFile = "a.png"
        call(["circo", "-Tpng", self.Parser.FileName, "-o", outputFile])
        call(["eog", outputFile])
        return self.Graph

    def runTopDown(self):
        return TD.arrange(self.Graph)

    def chooseSolver(self):
        (numberOfNodes, numberOfEdges,
         numberOfLeaves) = self.Analysis.numberOfNodesEdgesAndLeaves()

        rootNodes = self.Analysis.getRootNodes()
        numberOfRootNodes = len(rootNodes)
        hasCycles = True
        #If it is an acyclic graph, we can run topdown
        if self.Graph.Type == 1 and rootNodes:
            hasCycles = self.Analysis.BFS(rootNodes[0], True)
            if not hasCycles:
                topoList = self.Analysis.topologicalSort(True)
                treeDepth = topoList[-1][1]

                print "numberOfNodes", numberOfNodes, "treeDepth", treeDepth

                if numberOfNodes > pow(3,
                                       treeDepth) and numberOfRootNodes == 1:
                    self.State = RADIAL
                    return self.State
                else:
                    self.State = TOPDOWN
                    return self.State
        #If we have an acyclic graph that has no roots. Its some form of ring.
        elif self.Graph.Type == 1:
            self.State = CIRCO
            return self.State
        else:  # undirected graph
            # Metric for graph: connectedness: #nodes/#edges, < 3
            connectedness = self.Graph.getNumEdges() / float(numberOfNodes)
            print connectedness
            if connectedness < 3:
                #radial -> nbody
                self.State = NBODY
            else:
                #nbody random
                self.State = NBODY_JITTER

        return self.State

    def runChosenSolver(self, choice=None):
        if choice == None:
            choice = self.State

        #print "TEST",choice, CIRCO

        if choice == NBODY:
            return self.runNBody()
        if choice == NBODY_RADIAL:
            return self.runNBody(True)
        if choice == NBODY_JITTER:
            return self.runNBody(False)
        if choice == TOPDOWN:
            return self.runTopDown()
        if choice == RADIAL:
            return self.runRadial()
        if choice == CIRCO:
            return self.runCirco()

        return self.runNBody()
        '''return {
            NBODY:self.runNBody(),
            NBODY_RADIAL:self.runNBody(True),
            NBODY_JITTER:self.runNBody(False),
            TOPDOWN:self.runTopDown(),
            RADIAL:self.runRadial(),
            CIRCO:self.runCirco(),
            #NBODYJ:self.runNBody(False),
        }.get(choice,self.runNBody())
        '''

    def printChoice(self):
        return {
            NBODY: "NBODY",
            NBODY_RADIAL: "NBODY_RADIAL",
            NBODY_JITTER: "NBODY_JITTER",
            TOPDOWN: "TOPDOWN",
            RADIAL: "RADIAL",
            CIRCO: "CIRCO",
        }.get(self.State, "???")
Exemplo n.º 6
0
        return count

    def numberOfNodesEdgesAndLeaves(self):
        nodes = len(self.Graph.AdjacencyList)
        edges = 0
        leafCount = 0
        for node in self.Graph.AdjacencyList: 
            edgeList = self.Graph.AdjacencyList[node]
            if not edgeList:
                leafCount += 1
            else:
                edges += len(edgeList)
        return (nodes, edges, leafCount)

if __name__ == "__main__":
    parser = DotParser()

    filename = argv[1]
    parser.readFile(filename)
    graph = parser.Graph

    analysis = GraphAnalysis(graph)

    print graph

    arbitraryRoot = graph.getNodeList()[0]
    analysis.BFS(arbitraryRoot)
    
    analysis.printDependencyTable
    
    print "ROOTS:"
Exemplo n.º 7
0
 def __init__(self, infile):
     self.Parser = DotParser()
     self.Graph = self.Parser.readFile(infile)
     self.Analysis = GraphAnalysis(self.Graph)
     self.State = NBODY
Exemplo n.º 8
0
class JumanG:
    def __init__(self, infile):
        self.Parser = DotParser()
        self.Graph = self.Parser.readFile(infile)
        self.Analysis = GraphAnalysis(self.Graph)
        self.State = NBODY
        
    def outputToTikz(self, graph, outfile):
        TW.tikGraph(graph, outfile)
        
    def runRadial(self):
        return RD.radialAssign(self.Graph)

    def runNBody(self, useRadialSeed = True):
        if useRadialSeed:
            return NB.reposition(self.runRadial(),False)
        else:
            return NB.reposition(self.Graph,True)


    def runCirco(self):
        outputFile = "a.png"
        call(["circo","-Tpng",self.Parser.FileName,"-o",outputFile])
        call(["eog",outputFile])
        return self.Graph

    def runTopDown(self):
        return TD.arrange(self.Graph)

    def chooseSolver(self):
        (numberOfNodes,numberOfEdges,numberOfLeaves) = self.Analysis.numberOfNodesEdgesAndLeaves()

        rootNodes = self.Analysis.getRootNodes()
        numberOfRootNodes = len(rootNodes)
        hasCycles = True
        #If it is an acyclic graph, we can run topdown
        if self.Graph.Type==1 and rootNodes:
            hasCycles = self.Analysis.BFS(rootNodes[0],True)
            if not hasCycles:
                topoList = self.Analysis.topologicalSort(True)
                treeDepth = topoList[-1][1]
                
                print "numberOfNodes",numberOfNodes,"treeDepth",treeDepth

                if numberOfNodes > pow(3,treeDepth) and numberOfRootNodes==1: 
                    self.State = RADIAL
                    return self.State
                else:
                    self.State = TOPDOWN
                    return self.State
        #If we have an acyclic graph that has no roots. Its some form of ring.
        elif self.Graph.Type == 1:
            self.State = CIRCO
            return self.State
        else: # undirected graph
            # Metric for graph: connectedness: #nodes/#edges, < 3
            connectedness = self.Graph.getNumEdges()/float(numberOfNodes)
            print connectedness
            if connectedness < 3:
                #radial -> nbody
                self.State = NBODY
            else:
                #nbody random
                self.State = NBODY_JITTER

        return self.State

    def runChosenSolver(self, choice = None):
        if choice == None:
            choice = self.State
        
        #print "TEST",choice, CIRCO
        
        if choice == NBODY:
            return self.runNBody()
        if choice == NBODY_RADIAL:
            return self.runNBody(True)
        if choice == NBODY_JITTER:
            return self.runNBody(False)
        if choice == TOPDOWN:
            return self.runTopDown()
        if choice == RADIAL:
            return self.runRadial()
        if choice == CIRCO:
            return self.runCirco()
            
        return self.runNBody()

        '''return {
            NBODY:self.runNBody(),
            NBODY_RADIAL:self.runNBody(True),
            NBODY_JITTER:self.runNBody(False),
            TOPDOWN:self.runTopDown(),
            RADIAL:self.runRadial(),
            CIRCO:self.runCirco(),
            #NBODYJ:self.runNBody(False),
        }.get(choice,self.runNBody())
        '''

    def printChoice(self):
        return {
            NBODY:"NBODY",
            NBODY_RADIAL:"NBODY_RADIAL",
            NBODY_JITTER:"NBODY_JITTER", 
            TOPDOWN:"TOPDOWN",
            RADIAL:"RADIAL",
            
            CIRCO:"CIRCO",
        }.get(self.State,"???")