Updated

Scripts/Modeling/Select/EdgeLoopSmartSelect.py

@@ -0,0 +1,435 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+import maya.cmds as cmds
+import maya.OpenMaya as om
+import maya.OpenMayaUI as omui
+from maya.OpenMaya import MGlobal
+import math
+import re
+import maya.mel as mel
+
+def run():
+    global selInitialGeo
+    global storeAllEdges
+    selInitialGeo = []
+    storeAllEdges = []
+    testAnySel = cmds.ls(sl=1)
+    if testAnySel:
+        checkCurrentSelEdge = cmds.filterExpand(sm=32)
+        checkCurrentSelPoly = cmds.filterExpand(sm=12)
+        checkCurrentSelOther =cmds.filterExpand(sm=(31,34,35) )
+        if checkCurrentSelEdge:
+            checkEdgeLoopGrp =  getEdgeRingGroup(checkCurrentSelEdge)
+            if len(checkEdgeLoopGrp) == 1:
+                listAAA = ''
+                try:
+                    listAAA = vtxLoopOrder(checkCurrentSelEdge)
+                except:
+                    pass
+                if listAAA:
+                    storeAllEdges = checkCurrentSelEdge
+                    checkCurrentSelPoly = cmds.ls(hl=1)
+                    selInitialGeo.append(checkCurrentSelPoly[0])
+                    if not cmds.attributeQuery('start', node = selInitialGeo[0], ex=True ):
+                        cmds.addAttr(selInitialGeo[0], at = 'long', ln='start') 
+                    if not cmds.attributeQuery('end', node = selInitialGeo[0], ex=True ):
+                        cmds.addAttr(selInitialGeo[0], at = 'long',ln='end') 
+                    if not cmds.attributeQuery('nearest', node = selInitialGeo[0], ex=True ):
+                        cmds.addAttr(selInitialGeo[0], at = 'long',ln='nearest') 
+                    if not cmds.attributeQuery('closeTo', node = selInitialGeo[0], ex=True ):
+                        cmds.addAttr(selInitialGeo[0], at = 'long',ln='closeTo') 
+                    if not cmds.attributeQuery('firstRun', node = selInitialGeo[0], ex=True ):
+                        cmds.addAttr(selInitialGeo[0], at = 'long',ln='firstRun') 
+                    cmds.setAttr((selInitialGeo[0]+'.firstRun'),0)
+                    selShortestLoop()
+                else:
+                    cmds.select(checkCurrentSelEdge)
+            else:
+                cmds.select(checkCurrentSelEdge)
+        else:
+            if checkCurrentSelOther:
+                checkCurrentSelPoly = cmds.ls(hl=1)
+            
+            # Check if checkCurrentSelPoly is None or an empty list
+            if not checkCurrentSelPoly:
+                # If no polygon is selected, display a warning and return
+                MGlobal.displayWarning("No polygon object selected.")
+                return
+                
+            selInitialGeo.append(checkCurrentSelPoly[0])
+            CMD = 'doMenuComponentSelectionExt("' + str(checkCurrentSelPoly[0])+ '", "edge", 0);'
+            mel.eval(CMD)
+            cmds.select(cl=1)
+            cmds.polyCrease((checkCurrentSelPoly[0]+'.e[*]'), value=0)
+            if not cmds.attributeQuery('start', node = selInitialGeo[0], ex=True ):
+                cmds.addAttr(selInitialGeo[0], at = 'long', ln='start') 
+            if not cmds.attributeQuery('end', node = selInitialGeo[0], ex=True ):
+                cmds.addAttr(selInitialGeo[0], at = 'long',ln='end') 
+            if not cmds.attributeQuery('nearest', node = selInitialGeo[0], ex=True ):
+                cmds.addAttr(selInitialGeo[0], at = 'long',ln='nearest') 
+            if not cmds.attributeQuery('closeTo', node = selInitialGeo[0], ex=True ):
+                cmds.addAttr(selInitialGeo[0], at = 'long',ln='closeTo') 
+            if not cmds.attributeQuery('firstRun', node = selInitialGeo[0], ex=True ):
+                cmds.addAttr(selInitialGeo[0], at = 'long',ln='firstRun') 
+            cmds.setAttr((selInitialGeo[0]+'.firstRun'),0)
+            cmds.scriptJob ( runOnce=True, event = ["SelectionChanged", selShortestLoop])
+    else:
+        print('no selection')
+
+def selShortestLoop():
+    global ctx
+    global storeAllEdges
+    global selInitialGeo
+    global storeCameraPosition
+    global initialList
+    initialList = []
+    storeAllEdges = cmds.ls(sl=1,fl=1)
+    listVtx = vtxLoopOrder(storeAllEdges)
+    initialList = listVtx
+    startID = listVtx[0].split('[')[-1].split(']')[0]
+    endID = listVtx[-1].split('[')[-1].split(']')[0]
+    cmds.setAttr((selInitialGeo[0]+'.start'),int(startID))
+    cmds.setAttr((selInitialGeo[0]+'.end'),int(endID))
+    view = omui.M3dView.active3dView()
+    cam = om.MDagPath()
+    view.getCamera(cam)
+    camPath = cam.fullPathName()
+    cameraTrans = cmds.listRelatives(camPath,type='transform',p=True)
+    storeCameraPosition = cmds.xform(cameraTrans,q=1,ws=1,rp=1)
+    if cmds.objExists('preSelDisp')==0:
+        cmds.createNode("creaseSet")
+        cmds.rename("preSelDisp")
+    cmds.sets((selInitialGeo[0]+".e[*]"),remove="preSelDisp")
+    cmds.sets(storeAllEdges,forceElement="preSelDisp")
+    cmds.setAttr("preSelDisp.creaseLevel", 1)
+    cmds.polyOptions(dce=1)
+    ctx = 'Click2dTo3dCtx'
+    if cmds.draggerContext(ctx, exists=True):
+        cmds.deleteUI(ctx)
+    cmds.draggerContext(ctx, ppc= liveShortPause ,rc = liveShortPause, dragCommand = liveShortMove, fnz = liveShortStop ,name=ctx, cursor='crossHair',undoMode='step')
+    cmds.setToolTo(ctx)
+
+def liveShortMove():
+    global selInitialGeo
+    global ctx
+    global screenX,screenY
+    global storeCameraPosition
+    global storeAllEdges
+    modifiers = cmds.getModifiers()
+    if selInitialGeo:
+        vpX, vpY, _ = cmds.draggerContext(ctx, query=True, dragPoint=True)
+        pos = om.MPoint()
+        dir = om.MVector()
+        hitpoint = om.MFloatPoint()
+        omui.M3dView().active3dView().viewToWorld(int(vpX), int(vpY), pos, dir)
+        pos2 = om.MFloatPoint(pos.x, pos.y, pos.z)
+        checkHit = 0
+        finalMesh = []
+        finalX = 0
+        finalY = 0
+        finalZ = 0
+        shortDistance = 10000000000
+        distanceBetween = 1000000000
+        hitFacePtr = om.MScriptUtil().asIntPtr()
+        hitFace = []
+        for mesh in selInitialGeo:
+            selectionList = om.MSelectionList()
+            selectionList.add(mesh)
+            dagPath = om.MDagPath()
+            selectionList.getDagPath(0, dagPath)
+            fnMesh = om.MFnMesh(dagPath)
+            intersection = fnMesh.closestIntersection(
+            om.MFloatPoint(pos2),
+            om.MFloatVector(dir),
+            None,
+            None,
+            False,
+            om.MSpace.kWorld,
+            99999,
+            False,
+            None,
+            hitpoint,
+            None,
+            hitFacePtr,
+            None,
+            None,
+            None)
+            if intersection:
+                x = hitpoint.x
+                y = hitpoint.y
+                z = hitpoint.z
+                finalX = x
+                finalY = y
+                finalZ = z
+                hitFace = om.MScriptUtil(hitFacePtr).asInt()
+                hitFaceName = (selInitialGeo[0] + '.f[' + str(hitFace) +']')
+                cpX,cpY,cpZ = getPolyFaceCenter(hitFaceName)
+                shortDistanceCheck = 10000
+                checkCVDistance = 10000
+                cvList = (cmds.polyInfo(hitFaceName , fv=True )[0]).split(':')[-1].split('  ')
+                cvListX = [x for x in cvList if x.strip()]
+
+                for v in cvListX:
+                    checkNumber = ''.join([n for n in v.split('|')[-1] if n.isdigit()])
+                    if len(checkNumber) > 0:
+                        cvPoint = (selInitialGeo[0] + '.vtx[' + str(checkNumber) +']')
+                        cvPosition = cmds.pointPosition(cvPoint)
+                        checkCVDistance = math.sqrt( ((float(cvPosition[0]) - finalX)**2)  + ((float(cvPosition[1]) - finalY)**2) + ((float(cvPosition[2]) - finalZ)**2))
+                        if checkCVDistance < shortDistanceCheck:
+                            shortDistanceCheck = checkCVDistance
+                            mostCloseCVPoint = cvPoint
+                            mostCloseCVPointPos = cvPosition
+                
+                newID = mostCloseCVPoint.split('[')[-1].split(']')[0]
+                cmds.setAttr((selInitialGeo[0]+'.nearest'),int(newID))
+                checkRun = cmds.getAttr(selInitialGeo[0]+'.firstRun')
+
+                if checkRun == 1:
+                    checkCloseTo = cmds.getAttr(selInitialGeo[0]+'.nearest')
+                    checkStart = cmds.getAttr(selInitialGeo[0]+'.start')
+                    checkEnd = cmds.getAttr(selInitialGeo[0]+'.end')
+                    
+                    startPosition = cmds.pointPosition( (selInitialGeo[0] + '.vtx[' + str(checkStart) +']'))
+                    endPosition = cmds.pointPosition( (selInitialGeo[0] + '.vtx[' + str(checkEnd) +']'))
+                    nearPosition = cmds.pointPosition( (selInitialGeo[0] + '.vtx[' + str(checkCloseTo) +']'))
+
+                    distA = math.sqrt( ((float(nearPosition[0]) - startPosition[0])**2)  + ((float(nearPosition[1]) - startPosition[1])**2) + ((float(nearPosition[2]) - startPosition[2])**2))
+                    distB = math.sqrt( ((float(nearPosition[0]) - endPosition[0])**2)  + ((float(nearPosition[1]) - endPosition[1])**2) + ((float(nearPosition[2]) - endPosition[2])**2))
+                    if distA > distB:
+                        cmds.setAttr((selInitialGeo[0]+'.end'),checkEnd)
+                        cmds.setAttr((selInitialGeo[0]+'.start'),checkStart)
+                    else:
+                        cmds.setAttr((selInitialGeo[0]+'.end'),checkStart)
+                        cmds.setAttr((selInitialGeo[0]+'.start'),checkEnd)
+                checkStart = cmds.getAttr(selInitialGeo[0]+'.start')
+                checkEnd = cmds.getAttr(selInitialGeo[0]+'.end')
+                checkNearest =  cmds.getAttr(selInitialGeo[0]+'.nearest')
+                #get shortest
+                cmds.select(cl=1)
+                cmds.sets((selInitialGeo[0]+".e[*]"),remove="preSelDisp")
+                sortList = []
+                if modifiers == 4: # "press Ctrl"
+                    PA = (selInitialGeo[0] + '.vtx[' + str(checkEnd) +']')
+                    PB = (selInitialGeo[0] + '.vtx[' + str(checkNearest) +']')
+                    UVA = cmds.polyListComponentConversion(PA,fv =1 ,tuv=1)
+                    UVB = cmds.polyListComponentConversion(PB,fv =1 ,tuv=1)
+                    startUVID = UVA[0].split('[')[-1].split(']')[0]
+                    endUVID = UVB[0].split('[')[-1].split(']')[0]
+                    #cmds.polySelect(selInitialGeo[0] , shortestEdgePathUV=(int(startUVID), int(endUVID)))
+                    listShort = cmds.polySelect(selInitialGeo[0] ,q=1, shortestEdgePathUV=(int(startUVID), int(endUVID)))
+                    if listShort:
+                        for l in listShort:
+                            sortList.append(selInitialGeo[0]+'.e['+ str(l) +']' )
+                else:
+                    #cmds.polySelect(selInitialGeo[0] , shortestEdgePath=(int(checkEnd), int(checkNearest)))
+                    #maya run faster without select
+                    listShort = cmds.polySelect(selInitialGeo[0] ,q=1, shortestEdgePath=(int(checkEnd), int(checkNearest)))
+                    if listShort:
+                        for l in listShort:
+                            sortList.append(selInitialGeo[0]+'.e['+ str(l) +']' )
+                getC = storeAllEdges + sortList
+                cmds.select(getC)
+                cmds.sets(getC,forceElement="preSelDisp")
+                if modifiers == 1: # "press Shelf"
+                    liveList = cmds.sets("preSelDisp",q=1)
+                    liveList = cmds.ls(liveList,fl=1)
+                    listVtx = vtxLoopOrder(liveList)
+                    checkEndID = listVtx[-1].split('[')[-1].split(']')[0]
+                    extEdgeA = []
+                    extEdgeB = []
+                    if int(checkEndID) == checkNearest:
+                        extEdgeA = cmds.polyListComponentConversion(listVtx[-1],fv =1 ,te=1)
+                        extEdgeB = cmds.polyListComponentConversion(listVtx[-2],fv =1 ,te=1)
+                    else:
+                        extEdgeA = cmds.polyListComponentConversion(listVtx[0],fv =1 ,te=1)
+                        extEdgeB = cmds.polyListComponentConversion(listVtx[1],fv =1 ,te=1)
+                    extEdgeA = cmds.ls(extEdgeA,fl=1)
+                    extEdgeB = cmds.ls(extEdgeB,fl=1)  
+                    extEdge = list(set(extEdgeA) - (set(extEdgeA)-set(extEdgeB)))
+                    checkExtLoop = cmds.polySelectSp(extEdge,q=1, loop=1)
+                    checkExtLoop = cmds.ls(checkExtLoop,fl=1)
+                    otherList = list(set(checkExtLoop) - set(liveList))
+                    checkEdgeLoopGrp =  getEdgeRingGroup(otherList)
+                    if checkEdgeLoopGrp:
+                        if len(checkEdgeLoopGrp) > 0:
+                            if len(checkEdgeLoopGrp) == 1:
+                                cmds.sets(otherList,forceElement="preSelDisp")
+                            elif  len(checkEdgeLoopGrp)> 1:
+                                for c in checkEdgeLoopGrp:
+                                    cvList = cmds.polyListComponentConversion (c,fe=1,tv=1)
+                                    cvList = cmds.ls(cvList,fl=1)
+                                    if (selInitialGeo[0]+'.vtx['+ str(checkNearest) +']' ) in cvList:
+                                        cmds.sets(c,forceElement="preSelDisp")
+                            cmds.select("preSelDisp", add=1)
+                cmds.refresh(cv=True,f=True)
+
+def liveShortPause():
+    global storeAllEdges
+    global selInitialGeo
+    global initialList
+    checkRun = cmds.getAttr(selInitialGeo[0]+'.firstRun')
+    if checkRun == 0:
+         cmds.setAttr((selInitialGeo[0]+'.firstRun'),1)
+    else:
+        cmds.setAttr((selInitialGeo[0]+'.firstRun'),2)
+        getEdgeList = cmds.ls(sl=1,fl=1)
+        storeAllEdges = getEdgeList
+        listVtx = vtxLoopOrder(getEdgeList)
+        if len(listVtx)>0:
+            listHead = listVtx[0]
+            listEnd = listVtx[-1]
+            if listHead in initialList:
+                cmds.setAttr((selInitialGeo[0]+'.start'),int(listVtx[0].split('[')[-1].split(']')[0]))
+                cmds.setAttr((selInitialGeo[0]+'.end'),int(listVtx[-1].split('[')[-1].split(']')[0]))
+
+            else:
+                cmds.setAttr((selInitialGeo[0]+'.start'),int(listVtx[-1].split('[')[-1].split(']')[0]))
+                cmds.setAttr((selInitialGeo[0]+'.end'),int(listVtx[0].split('[')[-1].split(']')[0]))
+        else:
+            liveShortStop()
+        
+
+def liveShortStop():
+    cmds.setToolTo("moveSuperContext")
+    cmds.polyOptions(dce=0)
+    if cmds.objExists('preSelDisp'):
+        cmds.setAttr("preSelDisp.creaseLevel", 0)
+        cmds.delete('preSelDisp')
+    
+    
+def getPolyFaceCenter(faceName):
+    meshFaceName = faceName.split('.')[0]
+    findVtx = cmds.polyInfo(faceName, fv=1)
+    getNumber = []
+    checkNumber = ((findVtx[0].split(':')[1]).split('\n')[0]).split(' ')
+    for c in checkNumber:
+        findNumber = ''.join([n for n in c.split('|')[-1] if n.isdigit()])
+        if findNumber:
+            getNumber.append(findNumber)
+    centerX = 0
+    centerY = 0
+    centerZ = 0
+    for g in getNumber:
+        x,y,z = cmds.pointPosition((meshFaceName + '.vtx['+g + ']'),w=1)
+        centerX = centerX + x
+        centerY = centerY + y
+        centerZ = centerZ + z
+
+    centerX = centerX/len(getNumber)
+    centerY = centerY/len(getNumber)
+    centerZ = centerZ/len(getNumber)
+    return centerX,centerY,centerZ
+
+def vtxLoopOrder(edgelist):
+    if edgelist:
+        selEdges = edgelist
+        shapeNode = cmds.listRelatives(selEdges[0], fullPath=True , parent=True )
+        transformNode = cmds.listRelatives(shapeNode[0], fullPath=True , parent=True )
+        edgeNumberList = []
+        for a in selEdges:
+            checkNumber = ((a.split('.')[1]).split('\n')[0]).split(' ')
+            for c in checkNumber:
+                findNumber = ''.join([n for n in c.split('|')[-1] if n.isdigit()])
+                if findNumber:
+                    edgeNumberList.append(findNumber)
+        getNumber = []
+        for s in selEdges:
+            evlist = cmds.polyInfo(s,ev=True)
+            checkNumber = ((evlist[0].split(':')[1]).split('\n')[0]).split(' ')
+            for c in checkNumber:
+                findNumber = ''.join([n for n in c.split('|')[-1] if n.isdigit()])
+                if findNumber:
+                    getNumber.append(findNumber)
+        dup = set([x for x in getNumber if getNumber.count(x) > 1])
+        getHeadTail = list(set(getNumber) - dup)
+        vftOrder = []
+        finalList = []
+        if len(getHeadTail)>0:
+            vftOrder.append(getHeadTail[0])
+            count = 0
+            while len(dup)> 0 and count < 100:
+                checkVtx = transformNode[0]+'.vtx['+ vftOrder[-1] + ']'
+                velist = cmds.polyInfo(checkVtx,ve=True)
+                getNumber = []
+                checkNumber = ((velist[0].split(':')[1]).split('\n')[0]).split(' ')
+                for c in checkNumber:
+                    findNumber = ''.join([n for n in c.split('|')[-1] if n.isdigit()])
+                    if findNumber:
+                        getNumber.append(findNumber)
+                findNextEdge = []
+                for g in getNumber:
+                    if g in edgeNumberList:
+                        findNextEdge = g
+                edgeNumberList.remove(findNextEdge)
+                checkVtx = transformNode[0]+'.e['+ findNextEdge + ']'
+                findVtx = cmds.polyInfo(checkVtx,ev=True)
+                getNumber = []
+                checkNumber = ((findVtx[0].split(':')[1]).split('\n')[0]).split(' ')
+                for c in checkNumber:
+                    findNumber = ''.join([n for n in c.split('|')[-1] if n.isdigit()])
+                    if findNumber:
+                        getNumber.append(findNumber)
+                gotNextVtx = []
+                for g in getNumber:
+                    if g in dup:
+                        gotNextVtx = g
+                if len(gotNextVtx)> 0:
+                    dup.remove(gotNextVtx)
+                    vftOrder.append(gotNextVtx)
+                    count +=  1
+            if len(getHeadTail)>1:
+                vftOrder.append(getHeadTail[1])
+                for v in vftOrder:
+                    finalList.append(transformNode[0]+'.vtx['+ v + ']' )
+        return finalList
+
+def getEdgeRingGroup(selEdges):
+    if selEdges:
+        trans = selEdges[0].split(".")[0]
+        e2vInfos = cmds.polyInfo(selEdges, ev=True)
+        e2vDict = {}
+        fEdges = []
+        for info in e2vInfos:
+            evList = [ int(i) for i in re.findall('\\d+', info) ]
+            e2vDict.update(dict([(evList[0], evList[1:])]))
+        while True:
+            try:
+                startEdge, startVtxs = e2vDict.popitem()
+            except:
+                break
+            edgesGrp = [startEdge]
+            num = 0
+            for vtx in startVtxs:
+                curVtx = vtx
+                while True:
+
+                    nextEdges = []
+                    for k in e2vDict:
+                        if curVtx in e2vDict[k]:
+                            nextEdges.append(k)
+                    if nextEdges:
+                        if len(nextEdges) == 1:
+                            if num == 0:
+                                edgesGrp.append(nextEdges[0])
+                            else:
+                                edgesGrp.insert(0, nextEdges[0])
+                            nextVtxs = e2vDict[nextEdges[0]]
+                            curVtx = [ vtx for vtx in nextVtxs if vtx != curVtx ][0]
+                            e2vDict.pop(nextEdges[0])
+                        else:
+                            break
+                    else:
+                        break
+                num += 1
+            fEdges.append(edgesGrp)
+        retEdges =[]
+        for f in fEdges:
+            collectList=[]
+            for x in f:
+                getCom= (trans +".e["+ str(x) +"]")
+                collectList.append(getCom)
+            retEdges.append(collectList)
+        return retEdges
+
+run()

Scripts/Modeling/Select/IntervalSelectEdge.py

@@ -0,0 +1,63 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+import maya.cmds as cmds
+import maya.mel as mel
+
+def select_edges():
+    num_edges_selected = cmds.filterExpand(expand=True, selectionMask=32)
+    size_components = len(num_edges_selected) if num_edges_selected else 0
+    
+    if size_components == 0:
+        cmds.error("Select at least one edge before running the script.")
+    elif size_components == 1:
+        mel.eval('polySelectEdgesEveryN "edgeRing" 2')
+        print("1 cycle mode selected.")
+    elif size_components == 2:
+        mel.eval('polySelectEdgesEveryN "edgeRing" 4')
+        print("2 cycle modes selected.")
+    elif size_components == 3:
+        mel.eval('polySelectEdgesEveryN "edgeRing" 6')
+        print("3 cycle modes selected.")
+    elif size_components == 4:
+        mel.eval('polySelectEdgesEveryN "edgeRing" 8')
+        print("4 cycle modes selected.")
+    elif size_components == 5:
+        mel.eval('polySelectEdgesEveryN "edgeRing" 10')
+        print("5 cycle modes selected.")
+    elif size_components == 6:
+        mel.eval('polySelectEdgesEveryN "edgeRing" 12')
+        print("6 cycle modes selected.")
+    elif size_components == 7:
+        mel.eval('polySelectEdgesEveryN "edgeRing" 14')
+        print("7 cycle modes selected.")
+    elif size_components == 8:
+        mel.eval('polySelectEdgesEveryN "edgeRing" 16')
+        print("8 cycle modes selected.")
+    elif size_components > 8:
+        cmds.error("Please select 8 or fewer edges.")
+
+def create_select_edges_window():
+    window_name = "IntervalSelectEdges"
+    if cmds.window(window_name, exists=True):
+        cmds.deleteUI(window_name, window=True)
+    
+    window = cmds.window(window_name, title="Interval Select Edges", toolbox=True, 
+                         widthHeight=(300, 150), 
+                         sizeable=True,
+                         backgroundColor=(0.25, 0.25, 0.25))
+    
+    main_layout = cmds.columnLayout(adjustableColumn=True)
+    cmds.text(label="Select edge(s) and click Execute", height=50, width=250, parent=main_layout)
+    cmds.button(label="Select", command=lambda x: select_edges(), width=250, height=30, backgroundColor=(0.53, 0.81, 0.98), parent=main_layout)
+    
+    cmds.window(window, edit=True, widthHeight=(300, 150))  # Set the window size again after creating contents
+    cmds.showWindow(window)
+
+# Add a new function as the entry point for the module
+def show():
+    create_select_edges_window()
+
+# If the script is run directly (not imported as a module), show the window
+if __name__ == "__main__":
+    show()

Scripts/Modeling/Select/SamePositionSelector.py

@@ -0,0 +1,141 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+import maya.cmds as cmds
+import maya.mel as mel
+
+def save_setting():
+    threshold = cmds.floatSliderGrp(SamePositionSelector_UI_Threshold_FS, q=True, v=True)
+    check_bb = cmds.checkBox(SamePositionSelector_UI_CheckBB_CB, q=True, v=True)
+    unselect = cmds.checkBox(SamePositionSelector_UI_UnselectBB_CB, q=True, v=True)
+    cmds.optionVar(fv=("AriSamePositionS_Threshold", threshold))
+    cmds.optionVar(iv=("AriSamePositionS_CheckBB", check_bb))
+    cmds.optionVar(iv=("AriSamePositionS_Unselect", unselect))
+
+def vector_much(val_a, val_b, gosa):
+    return (val_a[0] <= val_b[0] + gosa and val_a[0] >= val_b[0] - gosa and
+            val_a[1] <= val_b[1] + gosa and val_a[1] >= val_b[1] - gosa and
+            val_a[2] <= val_b[2] + gosa and val_a[2] >= val_b[2] - gosa)
+
+def check_bounding_box(object_list_name):
+    gosa = cmds.floatSliderGrp(SamePositionSelector_UI_Threshold_FS, q=True, v=True)
+    object_list_bb_min = [cmds.getAttr(obj + ".boundingBoxMin")[0] for obj in object_list_name]
+    object_list_bb_max = [cmds.getAttr(obj + ".boundingBoxMax")[0] for obj in object_list_name]
+    
+    same_obj_list = []
+    for i in range(len(object_list_name)):
+        bb_min_a, bb_max_a = object_list_bb_min[i], object_list_bb_max[i]
+        local_counter = 0
+        for j in range(i + 1, len(object_list_name)):
+            if object_list_name[j] in same_obj_list:
+                continue
+            bb_min_b, bb_max_b = object_list_bb_min[j], object_list_bb_max[j]
+            if vector_much(bb_min_a, bb_min_b, gosa) and vector_much(bb_max_a, bb_max_b, gosa):
+                if local_counter == 0:
+                    same_obj_list.append(object_list_name[i])
+                same_obj_list.append(object_list_name[j])
+                local_counter += 1
+        if local_counter != 0:
+            same_obj_list.append(";")
+    return same_obj_list
+
+def select_list(obj_list):
+    unselect_true = cmds.checkBox(SamePositionSelector_UI_UnselectBB_CB, q=True, v=True)
+    first_true = unselect_true
+    select_list = []
+    for obj in obj_list:
+        if obj != ";":
+            if first_true:
+                first_true = False
+                continue
+            select_list.append(obj)
+        else:
+            if unselect_true:
+                first_true = True
+    cmds.select(select_list)
+
+def same_position_selector_select(*args):
+    save_setting()
+    bb_true = cmds.checkBox(SamePositionSelector_UI_CheckBB_CB, q=True, v=True)
+    gosa = cmds.floatSliderGrp(SamePositionSelector_UI_Threshold_FS, q=True, v=True)
+    object_list_name = cmds.ls(sl=True, tr=True)
+    object_list_pos = [cmds.xform(obj, q=True, ws=True, piv=True)[:3] for obj in object_list_name]
+    
+    same_obj_list = []
+    for i in range(len(object_list_name)):
+        pos_a = object_list_pos[i]
+        local_counter = 0
+        for j in range(i + 1, len(object_list_name)):
+            if object_list_name[j] in same_obj_list:
+                continue
+            pos_b = object_list_pos[j]
+            if vector_much(pos_a, pos_b, gosa):
+                if local_counter == 0:
+                    same_obj_list.append(object_list_name[i])
+                same_obj_list.append(object_list_name[j])
+                local_counter += 1
+        if local_counter != 0:
+            same_obj_list.append(";")
+    
+    if bb_true:
+        same_bounding_box_list = []
+        pair_list = []
+        for obj in same_obj_list:
+            if obj == ";":
+                same_bounding_box_list.extend(check_bounding_box(pair_list))
+                pair_list = []
+            else:
+                pair_list.append(obj)
+        same_obj_list = same_bounding_box_list
+    
+    select_list(same_obj_list)
+
+def show():
+    global SamePositionSelector_UI_Threshold_FS
+    global SamePositionSelector_UI_CheckBB_CB
+    global SamePositionSelector_UI_UnselectBB_CB
+    
+    threshold = 0.01
+    check_bb = True
+    unselect = True
+
+    if cmds.optionVar(exists="AriSamePositionS_Threshold"):
+        threshold = cmds.optionVar(q="AriSamePositionS_Threshold")
+    if cmds.optionVar(exists="AriSamePositionS_CheckBB"):
+        check_bb = cmds.optionVar(q="AriSamePositionS_CheckBB")
+    if cmds.optionVar(exists="AriSamePositionS_Unselect"):
+        unselect = cmds.optionVar(q="AriSamePositionS_Unselect")
+
+    window_name = "SamePositionSelector"
+    if cmds.window(window_name, exists=True):
+        cmds.deleteUI(window_name)
+    
+    window = cmds.window(window_name, title="Same Position Selector", tlb=True, 
+                         widthHeight=(300, 150), backgroundColor=(0.25, 0.25, 0.25),
+                         sizeable=True)
+    
+    label_threshold = "Threshold"
+    label_check_bb = "Check boundingbox"
+    label_unselect = "Unselect first object"
+    
+    main_layout = cmds.columnLayout(adjustableColumn=True)
+    
+    cmds.rowLayout(numberOfColumns=2, columnWidth2=(80, 220), adjustableColumn=2, parent=main_layout)
+    cmds.text(label=label_threshold)
+    SamePositionSelector_UI_Threshold_FS = cmds.floatSliderGrp(field=True, minValue=0.0, maxValue=0.1, fieldMinValue=0.0, fieldMaxValue=1000, value=threshold, precision=6)
+    cmds.setParent('..')
+
+    cmds.columnLayout(adjustableColumn=True, parent=main_layout)
+    SamePositionSelector_UI_CheckBB_CB = cmds.checkBox(label=label_check_bb, value=check_bb)
+    SamePositionSelector_UI_UnselectBB_CB = cmds.checkBox(label=label_unselect, value=unselect)
+    cmds.setParent('..')
+
+    cmds.separator(height=10, style='in', parent=main_layout)
+
+    cmds.button(label="Select", command=same_position_selector_select, backgroundColor=(0.53, 0.81, 0.98), height=30, parent=main_layout)
+
+    cmds.window(window, edit=True, widthHeight=(300, 150)) 
+    cmds.showWindow(window)
+
+if __name__ == "__main__":
+    show()