Python 按公共元素对项目进行排序

标题有点抽象，但我认为它与我所寻找的内容是准确的。 特别是给定多边形边的列表，对由顶点连接的所有边进行分组

我知道这应该是一个简单的问题，但我一直在寻找错误的解决方案

输入示例：

looseComponents = cmds.ls(sl=True, fl=True)
# Result: [u'pCube1.e[3]', u'pCube1.e[6]'] # 

获取输出：

found 2 component sets
[u'pCube1.e[3]']
[u'pCube1.e[3]']

预期输出：

found 2 component sets
[u'pCube1.e[3]']
[u'pCube1.e[6]']

这就是我现在拥有的，它在Maya中运行，用Python编写

looseComponents = cmds.ls(sl=True, fl=True)

#build sub item lookup
componentVerts = {}
for component in looseComponents:
    verts = cmds.ls(cmds.polyListComponentConversion(component, toVertex=True), fl=True)
    vertIds = []
    for vert in verts:
        i = int( vert.split('[')[-1].strip(']'))
        vertIds.append(i)
    componentVerts[component] = set(vertIds)

sortedComponents = 0
totalComponents = len(looseComponents)
componentSets = [ [] ]
componentSets[0].append( looseComponents[0] )
sortedComponents += 1

while sortedComponents < totalComponents:
    # for each subSetA of setA
    foundConnectingSet = False
    for i in range(len(componentSets)):
        # for each itemA of subSetA
        for j in range(len(componentSets[i])):
            # for each itemB of setB
            for h in range(len(looseComponents)):
                # check if itemA and itemB share a sub item
                if componentVerts[componentSets[i][j]] & componentVerts[looseComponents[h]]:
                    # if itemB isn't already part of this subSetA
                    if looseComponents[h] not in componentSets[i]:
                        # add itemB to this subSetA
                        componentSets[i].append(looseComponents[h])
                        sortedComponents += 1
                        foundConnectingSet = True

    if not foundConnectingSet:
        starter = looseComponents[0]
        for i in range(len(componentSets)):
            looseComponents = list( set(looseComponents) - set(componentSets[i]))
        componentSets.append( [ starter ] )         
        sortedComponents += 1

print 'found ' +str(len(componentSets))+ ' component sets'
for componentSet in componentSets:
    cmds.confirmDialog()
    cmds.select(componentSet, replace=True)
    print cmds.ls(sl=True)

looseComponents=cmds.ls（sl=True，fl=True）
#生成子项查找
componentVerts={}
对于组件中的组件：
verts=cmds.ls（cmds.polyListComponentConversion（component，toVertex=True），fl=True）
vertIds=[]
对于垂直中的垂直：
i=int（垂直拆分（'['）[-1].strip（']'））
vertIds.append（一）
componentVerts[组件]=集合（vertIds）
sortedComponents=0
totalComponents=len（松散组件）
componentSets=[[]]
组件集[0]。追加（组件[0]）
分类组件+=1
当sortedComponents

选择一条边，我得到一套。

---

选择了两条未连接的边后，我得到了两个集合，但这两个集合中的边都相同。

好吧，我得到了一个一致工作的解决方案

looseComponents = cmds.ls(sl=True, fl=True)

totalComponents = len( looseComponents )
sortedComponents = 0    
componentSets = []

vertComponent = {}
componentVert = {}
for component in looseComponents:
    verts = cmds.ls(cmds.polyListComponentConversion(component, toVertex=True), fl=True)
    for vert in verts:
        if vert in vertComponent:
            vertComponent[vert].append(component)
        else:
            vertComponent[vert] = [component]
    componentVert[component] = verts

def getConnectedComponent(component):
    verts = componentVert[component]
    connections = []
    for vert in verts:
        connections.extend( vertComponent[vert] )
    return list(set(connections) - set([component]))

def getRemainingComponent():
    remainingComponents = looseComponents
    for componentSet in componentSets:
        remainingComponents = list(set(remainingComponents)-set(componentSet))
    if remainingComponents:
        return remainingComponents[0]
    else:
        return None

while sortedComponents < totalComponents:
    component = getRemainingComponent()
    if component:
        componentSets.append( [component] )
        sortedComponents += 1
    connections = getConnectedComponent(component)
    while set(connections) - set(componentSets[-1]):
        newConnections = list( set(connections) - set(componentSets[-1]) )
        componentSets[-1].extend( newConnections )
        sortedComponents += len(newConnections)
        connections = []
        for component in newConnections:
            connections.extend( getConnectedComponent(component) )

print 'found ' +str(len(componentSets))+ ' component sets'
for componentSet in componentSets:
    cmds.confirmDialog()
    cmds.select(componentSet, replace=True)
    print cmds.ls(sl=True)

looseComponents=cmds.ls（sl=True，fl=True）
totalComponents=len（松散组件）
sortedComponents=0
componentSets=[]
vertComponent={}
componentVert={}
对于组件中的组件：
verts=cmds.ls（cmds.polyListComponentConversion（component，toVertex=True），fl=True）
对于垂直中的垂直：
如果vert位于vert组件中：
vertComponent[vert]。追加（组件）
其他：
vertComponent[vert]=[component]
componentVert[组件]=顶点
def getConnectedComponent（组件）：
垂直=组件垂直[组件]
连接=[]
对于垂直中的垂直：
connections.extend（vert组件[vert]）
返回列表（集合（连接）-集合（[组件]）
def getRemainingComponent（）：
剩余组件=松动组件
对于componentSet中的componentSet：
剩余组件=列表（集合（剩余组件）-集合（组件集合））
如果剩余部件：
返回剩余组件[0]
其他：
一无所获
当sortedComponents

我知道我经常在这里唠叨pymel，但看着每个人都经历CMD的麻烦真是太痛苦了。如果您没有义务这样做，那么另一种选择是：

from pymel.core import *

verts = [i for i in polyCube()[0].vtx]

for j in verts:
    print "{0} is connected to {1}".format(j, j.connectedEdges())

---

当它是面向对象的时，它的流动性要大得多。

我只是试着用转换为边的所有顶点制作一个字典：

import maya.cmds as cmds

def vert_edge_map(obj):
    verts = cmds.polyEvaluate(obj, v=True)
    mapping = {}
    for r in range(0, verts):
        edges = cmds.polyListComponentConversion(obj + ".vtx[%i]" % r, fv=True, te=True)
        edges = cmds.filterExpand(edges, sm=32)
        mapping[r] = set(edges)
    return mapping

vert_edge_map('pCube1')
# Result: {0: set([u'pCube1.e[4]', u'pCube1.e[0]', u'pCube1.e[10]']), 1: set([u'pCube1.e[0]', u'pCube1.e[11]', u'pCube1.e[5]']), 2: set([u'pCube1.e[4]', u'pCube1.e[1]', u'pCube1.e[6]']), 3: set([u'pCube1.e[1]', u'pCube1.e[7]', u'pCube1.e[5]']), 4: set([u'pCube1.e[2]', u'pCube1.e[8]', u'pCube1.e[6]']), 5: set([u'pCube1.e[2]', u'pCube1.e[9]', u'pCube1.e[7]']), 6: set([u'pCube1.e[3]', u'pCube1.e[8]', u'pCube1.e[10]']), 7: set([u'pCube1.e[3]', u'pCube1.e[9]', u'pCube1.e[11]'])} # 

所有值都是集合，因此您可以测试两个顶点是否通过与两个顶点集合相交而连接：

def are_connected(v1, v2, mapping):
    return len(mapping[v1].intersection(mapping[v2])) > 0

并使用联合体创建连接的孤岛：

def lots_of_edges(mapping, *verts):
   result = set()
   for v in verts:
       result = result.union(mapping[v])
   return result

---

请注意，当对范围内的i（len（foo））执行

时，您也可以对枚举（foo）中的i执行
。这是如何进行“排序”的？我认为更正确的说法是你正在对多边形进行分类。此外，如果没有您正在获得的输出和您希望获得的预期输出，则很难准确理解您想要的内容。没错，编辑文章以添加示例输入、输出和预期输出。