#!/usr/bin/env python
# -*- coding: utf-8 -*-

import maya.cmds as cmds # type: ignore
import maya.mel as mel # type: ignore
import maya.OpenMaya as om # type: ignore
import re, math
import maya.OpenMayaUI as omui # type: ignore
import maya.api.OpenMaya as oma # type: ignore
import maya.api.OpenMayaUI as omuia # type: ignore
mel.eval('source "dagMenuProc"')


def X23():
    getVexList = cmds.filterExpand(ex=1, sm=31)
    getEdgeList = cmds.filterExpand(ex=1, sm=32)
    tokens = ''
    if getVexList:    
        for g in getVexList:
            cmds.select(g)
            X43('')
        cmds.select(getVexList) 
        tokens = getVexList[0].split(".")
        cmd  = 'doMenuComponentSelectionExt("' + tokens[0] + '", "vertex", 0);'
        mel.eval(cmd)
    if getEdgeList and len(getEdgeList) == 2:  
        X56()
        currentSet = cmds.ls(sl=1,fl=1)
        tokens = currentSet[0].split(".")
        cmd  = 'doMenuComponentSelectionExt("' + tokens[0] + '", "edge", 0);'
        mel.eval(cmd)
        cmds.select(currentSet,r=1)
    elif getEdgeList and len(getEdgeList) == 1: 
        listVtx = cmds.ls(cmds.polyListComponentConversion(getEdgeList, tv=1),fl=1)
        for g in listVtx:
            cmds.select(g)
            X43(getEdgeList[0])
        cmds.select(getEdgeList) 
        tokens = getEdgeList[0].split(".")
        cmd  = 'doMenuComponentSelectionExt("' + tokens[0] + '", "edge", 0);'
        mel.eval(cmd)
        cmds.select(getEdgeList)
    
def X56():
    selEdges = cmds.ls(sl=1,fl=1)
    cmds.polyBridgeEdge(ch=1, divisions=1, twist=0, taper=1, curveType=0, smoothingAngle=30, direction=0, sourceDirection=0, targetDirection=0)
    selEdges = cmds.ls(sl=1,fl=1)
    rings = cmds.polySelectSp(ring=1)
    cmds.select(selEdges, d=1)
    midEdge = cmds.ls(sl=1,fl=1)
    listVtx = cmds.ls(cmds.polyListComponentConversion(midEdge, tv=1),fl=1)
    for i in listVtx:
        cmds.select(i)
        X43('')
    cmds.select(midEdge)

def X43(unwantEdges):
    selPoint = cmds.ls(sl=1,fl=1)
    cmds.ConvertSelectionToEdges()
    if unwantEdges:
        unwantLoop = cmds.ls(cmds.polySelectSp(unwantEdges,loop=1,q=1),fl=1)
        cmds.select(unwantLoop,d=1)
    selEdgeCheck = cmds.ls(sl=1,fl=1)
    findA = ''
    findB = ''
    goSharp = 0
    if len(selEdgeCheck) == 3:
        cmds.polySelectConstraint(m=2,w=1,t=0x8000)
        cmds.polySelectConstraint(disable=True)
        selEdge = cmds.ls(sl=1,fl=1)
        findA = selEdge[0]
        findB = selEdge[1]
        goSharp = 1
    elif len(selEdgeCheck) == 2:
        findA = selEdgeCheck[0]
        findB = selEdgeCheck[1]
        goSharp = 1
    elif len(selEdgeCheck) > 3:
        cmds.select(selPoint)
    if goSharp == 1:
        #selEdgeCheck.remove(findA)
        #selEdgeCheck.remove(findB)
        #cmds.select(selEdgeCheck)
        #X32()
        #X32()
        #unwantRing = cmds.ls(sl=1,fl=1)    
        cmds.select(findA,findB )
        XI9("plus")
        XI9("plus")
        #cmds.polySelectConstraint(type=0x8000, propagate=4, m2a=180, m3a=180, ed=2)
        loopACheck = cmds.ls(sl=1,fl=1)
        cmds.select(findA,findB)
        edgelist = []
        vertexAB = cmds.ls(cmds.polyListComponentConversion(findA,findB, tv=1),fl=1)
        for a in loopACheck:
            checkVex = cmds.ls(cmds.polyListComponentConversion(a, tv=1),fl=1)
            for c in checkVex:
                if c in vertexAB:
                    edgelist.append(a)
        #cmds.select(edgelist)
        listVtx = X8I(edgelist)
        checkA = X79(listVtx[1],listVtx[0],listVtx[-1])
        angleA = math.degrees(checkA)
        checkB = X79(listVtx[-2],listVtx[-1],listVtx[0])
        angleB = math.degrees(checkB)
        angleC = 180 - angleA -angleB
        distanceC = X3o(listVtx[0],listVtx[-1])
        distanceA = distanceC / math.sin(math.radians(angleC)) * math.sin(math.radians(angleA))
        distanceB = distanceC / math.sin(math.radians(angleC)) * math.sin(math.radians(angleB))
        oldDistA = X3o(listVtx[-2],listVtx[-1])
        oldDistB = X3o(listVtx[0],listVtx[1])
        scalarB = distanceB / oldDistB 
        pA = cmds.pointPosition(listVtx[0], w =1)
        pB = cmds.pointPosition(listVtx[1], w =1)
        newP = [0,0,0]
        newP[0] = ((pB[0]-pA[0])*scalarB) + pA[0]
        newP[1] = ((pB[1]-pA[1])*scalarB) + pA[1]
        newP[2] = ((pB[2]-pA[2])*scalarB) + pA[2]
        cmds.move(newP[0],newP[1],newP[2],selPoint[0], absolute = 1 )
        cmds.select(selPoint)


def XoI():
    number = cmds.floatField("refInsertLength", q=1, v = 1)
    selEdge = cmds.ls(sl=True, fl=True)
    
    if len(selEdge) == 1:
        PD_points = cmds.ls(cmds.polyListComponentConversion(selEdge, tv=True),fl=1)
        PD_coord1 = cmds.pointPosition(PD_points[0])
        PD_coord2 = cmds.pointPosition(PD_points[1])
        PD_distance = ((PD_coord1[0] - PD_coord2[0])**2 + (PD_coord1[1] - PD_coord2[1])**2 + (PD_coord1[2] - PD_coord2[2])**2)**0.5
        n = int(PD_distance / number)
        if n > 0:
            cmds.polySelectSp(selEdge[0], ring=True)
            cmds.polySplitRing(ch=True, splitType=2, divisions=n, useEqualMultiplier=True, smoothingAngle=30, fixQuads=False)
    
    elif len(selEdge) > 1:
        confirmString = cmds.confirmDialog(title="Confirm", message="Warning!! More than one edge selected?", button=["Continues", "Abort"], defaultButton="Abort", cancelButton="Abort", dismissString="Abort")
        if confirmString == "Continues":
            for s in selEdge:
                PD_points = cmds.ls(cmds.polyListComponentConversion(s, tv=True),fl=1)
                PD_coord1 = cmds.pointPosition(PD_points[0])
                PD_coord2 = cmds.pointPosition(PD_points[1])
                PD_distance = ((PD_coord1[0] - PD_coord2[0])**2 + (PD_coord1[1] - PD_coord2[1])**2 + (PD_coord1[2] - PD_coord2[2])**2)**0.5
                n = int(PD_distance / number)
                if n > 0:
                    cmds.polySelectSp(s, ring=True)
                    cmds.polySplitRing(ch=True, splitType=2, divisions=n, useEqualMultiplier=True, smoothingAngle=30, fixQuads=False)
                cmds.BakeNonDefHistory()

def X92():
    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 =  XlO(checkCurrentSelEdge)
            if len(checkEdgeLoopGrp) == 1:
                listAAA = ''
                try:
                    listAAA = X8I(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)
                    X67()
                else:
                    cmds.select(checkCurrentSelEdge)
            else:
                cmds.select(checkCurrentSelEdge)
        else:
            if checkCurrentSelOther:
                checkCurrentSelPoly = cmds.ls(hl=1)
            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') 
            else:
                selShortestLoop = []
                print('no selection')
            cmds.setAttr((selInitialGeo[0]+'.firstRun'),0)
            cmds.scriptJob ( runOnce=True, event = ["SelectionChanged", selShortestLoop])
    else:
        print('no selection')
def X67():
    global ctx
    global storeAllEdges
    global selInitialGeo
    global storeCameraPosition
    global initialList
    initialList = []
    storeAllEdges = cmds.ls(sl=1,fl=1)
    listVtx = X8I(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= X46 ,rc = X46, dragCommand = X8l, fnz = X4I ,name=ctx, cursor='crossHair',undoMode='step')
    cmds.setToolTo(ctx)

def X8l():
    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 = Xl5(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 = X8I(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 =  XlO(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 X46():
    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 = X8I(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:
            X4I()
def X4I():
    cmds.setToolTo("moveSuperContext")
    cmds.polyOptions(dce=0)
    if cmds.objExists('preSelDisp'):
        cmds.setAttr("preSelDisp.creaseLevel", 0)
        cmds.delete('preSelDisp')
def Xl5(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 X98():
    global storeEdge
    global currentArcCurve
    if cmds.objExists('arcCurve*'):
        arcCurveList = cmds.ls( "arcCurve*", transforms =1  )
        a = arcCurveList[0]
        for a in arcCurveList:
            if 'BaseWire' not in a:
                shapeNode = cmds.listRelatives(a, fullPath=True )
                hist = cmds.listConnections(cmds.listConnections(shapeNode[0],sh=1, d=1 ) ,d=1 ,sh=1)
                cmds.delete(hist,ch=1)
        cmds.delete('arcCurve*')
    if len(currentArcCurve)>0:
        if cmds.objExists(currentArcCurve):
            shapeNode = cmds.listRelatives(currentArcCurve, fullPath=True )
            hist = cmds.listConnections(cmds.listConnections(shapeNode[0],sh=1, d=1 ) ,d=1 ,sh=1)
            cmds.delete(hist,ch=1)
    if cmds.objExists(currentArcCurve):
        cmds.select(currentArcCurve)
    cmds.select(storeEdge,add=1)
    if cmds.objExists(currentArcCurve + 'BaseWire'):
        cmds.delete(currentArcCurve + 'BaseWire')

def XI4():
    global storeEdge
    global currentArcCurve
    currentDropOff = cmds.floatSliderGrp('dropOffSlider' ,q=1,v=1)
    snapCheck = cmds.checkBox('snapCurve',q = 1 ,v = 1)
    goEven = cmds.checkBox('evenSpace', q=1 ,v = 1)
    conP = cmds.intSliderGrp('CPSlider',q=1 , v = True )
    curveT = cmds.radioButtonGrp('curveType', q=1, sl=1)
    goArc = cmds.checkBox('makeArc', q=1 ,v = 1)
    cClean = cmds.checkBox('cleanCurve', q=1 ,v = 1)
    selEdge = cmds.filterExpand(expand=True ,sm=32)
    selCurve = cmds.filterExpand(expand=True ,sm=9)
    if selCurve:
        if len(selEdge)>0 and len(selCurve)== 1:
            storeEdge = selEdge
            cmds.select(selCurve,d=1)
            selMeshForDeformer = cmds.ls(sl=1,o=1)
            getCircleState,listVtx = Xll()
            newCurve = cmds.duplicate(selCurve[0], rr=1)
            cmds.rename(newCurve[0],'newsnapCurve')
            currentArcCurve = 'newsnapCurve'
            cmds.rebuildCurve(currentArcCurve,ch=1, rpo=1, rt=0, end=1, kr=0, kcp=0, kep=1, kt=0, s = 100, d=1, tol=0.01)
            #check tip order
            curveTip = cmds.pointOnCurve(currentArcCurve , pr = 0, p=1)
            tipA = cmds.pointPosition(listVtx[0],w=1)
            tipB = cmds.pointPosition(listVtx[-1],w=1)
            distA = math.sqrt( ((tipA[0] - curveTip[0])**2)  + ((tipA[1] - curveTip[1])**2)  + ((tipA[2] - curveTip[2])**2) )
            distB = math.sqrt( ((tipB[0] - curveTip[0])**2)  + ((tipB[1] - curveTip[1])**2)  + ((tipB[2] - curveTip[2])**2) )
            if distA > distB:
                listVtx.reverse()
            #snap to curve
            if goEven == 1:
                for q in range(len(selEdge)+1):
                    if q == 0:
                        pp = cmds.pointOnCurve(currentArcCurve , pr = 0, p=1)
                        cmds.move( pp[0], pp[1], pp[2],listVtx[q] , a =True, ws=True)
                    else:
                        pp = cmds.pointOnCurve(currentArcCurve , pr = (1.0/len(selEdge)*q), p=1)
                        cmds.move( pp[0], pp[1], pp[2],listVtx[q] , a =True, ws=True)
            else:
                sum = 0
                totalEdgeLoopLength = 0
                Llist = []
                uList = []
                pList = []
                for i in range(len(listVtx)-1):
                    pA = cmds.pointPosition(listVtx[i], w =1)
                    pB = cmds.pointPosition(listVtx[i+1], w =1)
                    checkDistance = math.sqrt( ((pA[0] - pB[0])**2)  + ((pA[1] - pB[1])**2)  + ((pA[2] - pB[2])**2) )
                    Llist.append(checkDistance)
                    totalEdgeLoopLength = totalEdgeLoopLength + checkDistance

                for j in Llist:
                    sum = sum + j
                    uList.append(sum)
                for k in uList:
                    p = k / totalEdgeLoopLength
                    pList.append(p)

                for q in range(len(selEdge)+1):
                    if q == 0:
                        pp = cmds.pointOnCurve(currentArcCurve , pr = 0, p=1)
                        cmds.move( pp[0], pp[1], pp[2],listVtx[q] , a =True, ws=True)
                    else:
                        pp = cmds.pointOnCurve(currentArcCurve , pr = pList[q-1], p=1)
                        cmds.move( pp[0], pp[1], pp[2],listVtx[q] , a =True, ws=True)
            cmds.delete('newsnapCurve')
            deformerNames  = cmds.wire(selMeshForDeformer, gw=0, en = 1, ce = 0, li= 0, dds = [(0,1)], dt=1, w = selCurve[0])
            cmds.connectControl("dropOffSlider", (deformerNames[0]+".dropoffDistance[0]"))
            if snapCheck == 0:
                cmds.setAttr((deformerNames[0] + '.dropoffDistance[0]'),1)
            else:
                cmds.setAttr((deformerNames[0] + '.dropoffDistance[0]'),currentDropOff)
            currentArcCurve = selCurve[0]
            cmds.select(selCurve[0])
    else:
        if selEdge:
            storeEdge = selEdge
            if cClean == 0:
                if cmds.objExists('arcCurve*'):
                    X98()
            selMeshForDeformer = cmds.ls(sl=1,o=1)
            getCircleState,listVtx = Xll()
            deformerNames = []
            #make nurbs curve
            if getCircleState == 0: #Arc
                if goArc == 1:
                    midP = int(len(listVtx)/2)
                    cmds.move(0.01, 0, 0,selEdge[midP],r=1, cs=1 ,ls=1, wd =1)
                    p1 = cmds.pointPosition(listVtx[0], w =1)
                    p2 = cmds.pointPosition(listVtx[midP], w =1)
                    p3 = cmds.pointPosition(listVtx[-1], w =1)
                    newNode = cmds.createNode('makeThreePointCircularArc')
                    cmds.setAttr((newNode + '.pt1'), p1[0],  p1[1] , p1[2])
                    cmds.setAttr((newNode + '.pt2'), p2[0],  p2[1] , p2[2])
                    cmds.setAttr((newNode + '.pt3'), p3[0],  p3[1] , p3[2])
                    cmds.setAttr((newNode + '.d'), 3)
                    cmds.setAttr((newNode + '.s'), len(listVtx))
                    newCurve = cmds.createNode('nurbsCurve')
                    cmds.connectAttr((newNode+'.oc'), (newCurve+'.cr'))
                    cmds.delete(ch=1)
                    transformNode = cmds.listRelatives(newCurve, fullPath=True , parent=True )
                    cmds.select(transformNode)
                    cmds.rename(transformNode,'arcCurve0')
                    getNewNode = cmds.ls(sl=1)
                    currentArcCurve = getNewNode[0]
                    numberP = 0
                    if curveT == 2:#nubs curve
                        numberP = int(conP) - 3
                        if numberP < 1:
                            numberP = 1
                    else:
                        numberP = int(conP) -1
                    cmds.rebuildCurve(currentArcCurve,ch=1, rpo=1, rt=0, end=1, kr=0, kcp=0, kep=1, kt=0, s= numberP, d=3, tol=0.01)
                else:
                    p1 = cmds.pointPosition(listVtx[0], w =1)
                    cmds.curve(d= 1, p=p1)
                    cmds.rename('arcCurve0')
                    getNewNode = cmds.ls(sl=1)
                    currentArcCurve = getNewNode[0]
                    for l in range(1,len(listVtx)):
                        p2 = cmds.pointPosition(listVtx[l], w =1)
                        cmds.curve(currentArcCurve, a= 1, d= 1, p=p2)
                    numberP = int(conP) -1
                    cmds.rebuildCurve(currentArcCurve,ch=1, rpo=1, rt=0, end=1, kr=0, kcp=0, kep=1, kt=0, s= numberP, d=1, tol=0.01)
            else: #circle
                p1 = cmds.pointPosition(listVtx[0], w =1)
                cmds.curve(d= 1, p=p1)
                cmds.rename('arcCurve0')
                getNewNode = cmds.ls(sl=1)
                currentArcCurve = getNewNode[0]
                for l in range(1,len(listVtx)):
                    p2 = cmds.pointPosition(listVtx[l], w =1)
                    cmds.curve(currentArcCurve, a= 1, d= 1, p=p2)
                cmds.curve(currentArcCurve, a= 1, d= 1, p=p1)
                cmds.closeCurve(currentArcCurve,ch=0, ps=2, rpo=1, bb= 0.5, bki=0, p=0.1)
                conP = cmds.intSliderGrp('CPSlider',q=1 , v = True )
                numberP = int(conP)
                if numberP < 4:
                    numberP = 4
                    cmds.intSliderGrp('CPSlider',e=1 , v = 4 )
                cmds.rebuildCurve(currentArcCurve,ch=1, rpo=1, rt=0, end=1, kr=0, kcp=0, kep=1, kt=0, s = numberP, d=3, tol=0.01)
                ###########################################################################
            cmds.delete(currentArcCurve ,ch=1)
            totalEdgeLoopLength = 0;
            sum = 0
            Llist = []
            uList = []
            pList = []
            #cmds.select(selEdge)
            for i in range(len(listVtx)-1):
                pA = cmds.pointPosition(listVtx[i], w =1)
                pB = cmds.pointPosition(listVtx[i+1], w =1)
                checkDistance = math.sqrt( ((pA[0] - pB[0])**2)  + ((pA[1] - pB[1])**2)  + ((pA[2] - pB[2])**2) )
                Llist.append(checkDistance)
                totalEdgeLoopLength = totalEdgeLoopLength + checkDistance
            if goEven == 1:
                avg = totalEdgeLoopLength / (len(selEdge))
                for j in range(len(selEdge)):
                    sum = ((j+1)*avg)
                    uList.append(sum)
            else:
                for j in Llist:
                    sum = sum + j
                    uList.append(sum)
            for k in uList:
                p = k / totalEdgeLoopLength
                pList.append(p)
            #snap to curve
            if snapCheck == 1:
                for q in range(len(pList)):
                    if q+1 == len(listVtx):
                        pp = cmds.pointOnCurve(currentArcCurve, pr = 0, p=1)
                        cmds.move( pp[0], pp[1], pp[2],listVtx[0] , a =True, ws=True)
                    else:
                        pp = cmds.pointOnCurve(currentArcCurve , pr = pList[q], p=1)
                        cmds.move( pp[0], pp[1], pp[2],listVtx[q+1] , a =True, ws=True)
            #convert to Bezier Curve
            cmds.delete(currentArcCurve ,ch=1)
            cmds.select(currentArcCurve)
            if curveT == 1:
                cmds.nurbsCurveToBezier()
                if getCircleState == 1: #circle need to fix bug
                    cmds.closeCurve(currentArcCurve,ch=0, ps=2, rpo=1, bb= 0.5, bki=0, p=0.1)
                    cmds.closeCurve(currentArcCurve,ch=0, ps=2, rpo=1, bb= 0.5, bki=0, p=0.1)
            #wireWrap
            deformerNames  = cmds.wire( selMeshForDeformer, gw=0, en = 1, ce = 0, li= 0, dds = [(0,1)], dt=1, w = currentArcCurve)
            #select controllers
            if getCircleState == 0:
                cmds.setToolTo('moveSuperContext')
                degree = cmds.getAttr(currentArcCurve + '.degree')
                spans = cmds.getAttr(currentArcCurve + '.spans')
                numberCVs = degree + spans
                collect = []
                for x in range(int(numberCVs/3)-1):
                    g = currentArcCurve + '.cv[' + str((x+1)*3) + ']'
                    collect.append(g)
                cmds.select(collect ,r=1)

            else:
                cmds.select(currentArcCurve + '.cv[*]')
            cmd = 'doMenuNURBComponentSelection("' + currentArcCurve + '", "controlVertex");'
            mel.eval(cmd)
            cmds.connectControl("dropOffSlider", (deformerNames[0]+".dropoffDistance[0]"))
            if snapCheck == 0:
                cmds.setAttr((deformerNames[0] + '.dropoffDistance[0]'),1)
            else:
                cmds.setAttr((deformerNames[0] + '.dropoffDistance[0]'),currentDropOff)
            #add to viewport even in isolate mode
            for x in range(1,5):
                cmds.isolateSelect(('modelPanel' + str(x)), ado= currentArcCurve )

def X9I():# min point for Nurbs are 4 point
    goArc = cmds.checkBox('makeArc', q=1 ,v = 1)
    curveT = cmds.radioButtonGrp('curveType', q=1, sl=1)
    if goArc == 0:
        cmds.intSliderGrp('CPSlider', e=1, min= 4, v = 4 , fmx = 500)
    else:
        if curveT == 1:
            cmds.intSliderGrp('CPSlider', e=1, min= 2, v = 3, fmx = 500)
        else:
            cmds.intSliderGrp('CPSlider', e=1, min= 4, v = 4, fmx = 500)

def X77():
    snapCheck = cmds.checkBox('snapCurve',q = 1 ,v = 1)
    if snapCheck == 0 :
        cmds.checkBox('evenSpace', e=1 ,en=0)
    else:
        cmds.checkBox('evenSpace', e=1 ,en=1)

def X45():# min point for Nurbs are 4 point
    curveT = cmds.radioButtonGrp('curveType', q=1, sl=1)
    getCurrentV = cmds.intSliderGrp('CPSlider', q=1 ,v = 1 )
    if curveT == 2:
        cmds.intSliderGrp('CPSlider', e=1, min= 4 )
        if getCurrentV < 4:
            cmds.intSliderGrp('CPSlider', e=1, v= 4 )
    else:
        cmds.intSliderGrp('CPSlider', e=1, min= 2 )
        
def Xl2():
    check  = cmds.checkBox("evenRoundPivotSnap", q=1, value=1)
    if check == 1:
        cmds.radioButtonGrp("PivotSnapType", e=1, en=1)
    else:
        cmds.radioButtonGrp("PivotSnapType", e=1, en=0)
def X75(type):
    edgeRingList = cmds.ls(sl=1,fl=1)
    targetL = cmds.floatField('equalizerLength', q=1, value = 1)
    unwantRing = cmds.ls(cmds.polySelectSp(edgeRingList, q=1,ring=1),fl=1)
    cmds.ConvertSelectionToFaces()
    cmds.ConvertSelectionToEdgePerimeter()
    cmds.select(unwantRing,d=1)
    testLoopAB = X69()
    if len(testLoopAB) == 2:
        ringPA = cmds.ls(cmds.polyListComponentConversion(testLoopAB[0], tv=1),fl=1)
        ringPB = cmds.ls(cmds.polyListComponentConversion(testLoopAB[1], tv=1),fl=1)  
        for d in edgeRingList:
            listVtx = cmds.ls(cmds.polyListComponentConversion(d, tv=1),fl=1)
            pACheck = listVtx[0]
            pBCheck = listVtx[1]
            if pACheck in ringPA:
                pass
            else:
                pACheck = listVtx[1]
                pBCheck = listVtx[0]
            pA = cmds.pointPosition(pACheck, w=1)
            pB = cmds.pointPosition(pBCheck, w=1)
            checkDistance = math.sqrt((pA[0] - pB[0]) ** 2 + (pA[1] - pB[1]) ** 2 + (pA[2] - pB[2]) ** 2)
            if type == "A":
                cmds.scale((targetL/checkDistance) ,(targetL/checkDistance),(targetL/checkDistance), listVtx[0], p=[pA[0],pA[1],pA[2]],r=1)
            elif type == "B":
                cmds.scale((targetL/checkDistance) ,(targetL/checkDistance),(targetL/checkDistance), listVtx[1], p=[pB[0],pB[1],pB[2]],r=1)
            else:
                cmds.scale((targetL/checkDistance) ,(targetL/checkDistance),(targetL/checkDistance), listVtx[0], p=[((pA[0]+pB[0])/2),((pA[1]+pB[1])/2),((pA[2]+pB[2])/2)],r=1)
                cmds.scale((targetL/checkDistance) ,(targetL/checkDistance),(targetL/checkDistance), listVtx[1], p=[((pA[0]+pB[0])/2),((pA[1]+pB[1])/2),((pA[2]+pB[2])/2)],r=1)
            cmds.select(edgeRingList)     
def X76(Where):
    selEdge = cmds.ls(sl=1,fl=1)
    length = X52(selEdge[0])
    output = round(length, 3)
    if Where == 'RE':
        cmds.floatField('equalizerLength', e=True, v=output)
    elif Where == 'IbL':
        cmds.floatField('refInsertLength', e=True, v=output)
    
def X58():
    if cmds.objExists('edgeSave'):
        cmds.delete('edgeSav*')
    currentV = cmds.floatSliderGrp('lockEdgeSlider', q=True, v=True)
    type = cmds.radioButtonGrp('lockEdgeType', q=True, sl=True)
    if type == 1:
        X73()
    else:
        XOI()
    cmds.floatSliderGrp('lockEdgeSlider', e=True, v=currentV)

def X25():
    if cmds.objExists('edgeSave'):
        cmds.delete('edgeSav*')
    currentV = cmds.floatSliderGrp('lockEdgeSlider', q=True, v=True)
    type = cmds.radioButtonGrp('lockEdgeType', q=True, sl=True)
    if type == 1:
        X85()
    else:
        X27()
    cmds.floatSliderGrp('lockEdgeSlider', e=True, v=currentV)

def X73():
    lockLength = cmds.floatField('lastLockEdgelength', q=True, v=True)
    X85()
    X65(lockLength)
    cmds.select(d=True)

def X65(targetEdgeLength):
    global polySRA
    global polySRB
    global AEdge
    global BEdge
    ADis = X52(AEdge[0])
    currentW = cmds.getAttr(polySRA[0] +" .weight")
    newW = currentW * targetEdgeLength / ADis
    cmds.floatSliderGrp('lockEdgeSlider', e=True, v=currentW)
    cmds.setAttr( (polySRA[0] + ".weight"), newW)
    ADis = X52(AEdge[0])
    BDis = X52(BEdge[0])
    currentW = cmds.getAttr(polySRB[0]+".weight")
    newW = 1 - (ADis * (1.0 - currentW) / BDis)
    cmds.setAttr( (polySRB[0] + ".weight"), newW)
    cmds.floatField('lastLockEdgelength', e=True, v = targetEdgeLength)


def XOI():
    global myLockEdge
    myLockEdge = []
    selectedgelock = cmds.ls(sl=True)
    selectGeo = cmds.ls(hl=True)
    cmds.bakePartialHistory(all=True)
    lockLength = cmds.floatField('lastLockEdgelength', q=True, v=True)
    length = X52(selectedgelock[0])
    halfL = length / 2.0
    checkN = lockLength / halfL
    lockL = 1.0 - checkN
    if lockL > 0:
        cmds.sets(name="edgeSave", text="edgeSave")
        cmds.select(selectedgelock[0], r=True)
        cmds.polySelectSp(ring=True)
        cmds.polySplitRing(ch=0, splitType=2, divisions=1)
        locknodeLst = cmds.polyDuplicateEdge(of=lockL, ch=True)
        cmds.rename(locknodeLst[0], "lockEdges")
        cmds.polyDelEdge(cv=True)
        cmds.select('edgeSave', r=True)
        X82('min')
        myLockEdge = cmds.ls(sl=True, fl=True)
        cmds.delete('edgeSave')
        cmds.select(d=True)
        cmds.connectControl('lockEdgeSlider', 'lockEdges.of')
    else:
        cmds.select(selectedgelock[0], r=True)
        X6l()
        print("length longer than current egde!") 

def X85():
    cmds.floatSliderGrp('lockEdgeSlider', e=True, en=1)
    global myLockEdge
    global polySRA
    global polySRB
    global AEdge
    global BEdge
    myLockEdge = []
    polySRA = []
    polySRB = []
    AEdge = []
    BEdge = []
    cmds.bakePartialHistory(all=True) 
    cmds.polySelectSp(ring=True)
    X82('min')
    cmds.sets(name="edgeSave", text="edgeSave")
    edgeData = XI2()
    cmds.polySelectSp(ring=True)
    polySRA = cmds.polySplitRing(ch=True, splitType=0, weight=0.01, smoothingAngle=30, fixQuads=True, insertWithEdgeFlow=False, direction=1, rootEdge=int(edgeData[1]))
    cmds.select('edgeSave', r=True)
    X82('max')
    edgeData = XI2()
    cmds.polySelectSp(ring=True)
    polySRB = cmds.polySplitRing(ch=True, splitType=0, weight=0.99, smoothingAngle=30, fixQuads=True, insertWithEdgeFlow=False, direction=0, rootEdge=int(edgeData[1]))
    cmds.select('edgeSave', r=True)
    X82('max')
    midEdge = cmds.ls(sl=True, fl=True)
    cmds.select('edgeSave', r=True)
    cmds.select(midEdge, d=True)
    X82('max')
    AEdge = cmds.ls(sl=True, fl=True)
    myLockEdge = cmds.ls(sl=True, fl=True)
    cmds.select('edgeSave', r=True)
    cmds.select(midEdge, d=True)
    cmds.select(AEdge, d=True)
    BEdge = cmds.ls(sl=True, fl=True)
    cmds.delete('edgeSave')
    cmds.select(d=True)
    X36()


def X6l():
    cmds.ConvertSelectionToEdges()
    current = cmds.ls(sl=True)
    if current:
        tokens = current[0].split(".")
        cmds.selectType(edge=True)
        cmds.select(tokens[0], r=True, ne=True)
        cmds.select(current, r=True)
        cmd  = 'doMenuComponentSelectionExt("' + tokens[0] + '", "edge", 0);'
        mel.eval(cmd)

def X27():
    global myLockEdge
    myLockEdge = []
    selectedgelock = cmds.ls(sl=True)
    selectGeo = cmds.ls(hl=True)
    cmds.sets(name="edgeSave", text="edgeSave")
    cmds.bakePartialHistory(all=True)
    Lock = cmds.floatSliderGrp('lockEdgeSlider', q=True, v=True)
    length = X52(selectedgelock[0])
    cmds.polySelectSp(ring=True)
    cmds.polySplitRing(ch=0, splitType=2, divisions=1)
    locknodeLst = cmds.polyDuplicateEdge(of=Lock, ch=True)
    cmds.rename(locknodeLst[0], "lockEdges")
    cmds.polyDelEdge(cv=True)
    cmds.select(selectGeo[0], r=True)
    X6l()
    cmds.InvertSelection()
    cmds.select('edgeSave', r=True)
    X82('min')
    myLockEdge = cmds.ls(sl=True, fl=True)
    cmds.delete('edgeSave')
    cmds.select(d=True)
    cmds.connectControl('lockEdgeSlider', 'lockEdges.of')
    
def X24():
    global myLockEdge
    length = X52(myLockEdge[0])
    output = round(length, 3)
    cmds.floatField('lastLockEdgelength', e=True, v=output)

def XI2():
    startEdge = cmds.ls(sl=True, fl=True)
    buffer = startEdge[0].split(".")
    Edgebuffer = buffer[1].split("[")
    getNumber = Edgebuffer[1].split("]")
    return buffer[0], getNumber[0]

def X36():
    type = cmds.radioButtonGrp('lockEdgeType', q=True, sl=True)
    if type == 1:
        Lock = cmds.floatSliderGrp('lockEdgeSlider', q=True, v=True)
        global polySRA
        global polySRB
        global AEdge
        global BEdge
        errorCheck = (1 - Lock) / 2.0
        if 0.001 < errorCheck < 0.4999:
            cmds.setAttr((polySRA[0] +".weight"), errorCheck)
            currentW = cmds.getAttr(polySRB[0]+".weight")
            ADis = X52(AEdge[0])
            BDis = X52(BEdge[0])
            newW = 1 - (ADis * (1.0 - currentW) / BDis)
            cmds.setAttr((polySRB[0] + ".weight"), newW)
    X24()

def X82(minmax):
    value = 0 if minmax == "max" else float('inf')
    selection = cmds.ls(sl=True, fl=True)
    edges = cmds.filterExpand(selection, ex=True, sm=32)
    if not edges:
        raise ValueError("No valid Edges selected!")
    targetEdge = None
    for edge in edges:
        checkEdgeLength = X52(edge)
        if minmax == "max" and checkEdgeLength > value:
            value = checkEdgeLength
            targetEdge = edge
        elif minmax == "min" and checkEdgeLength < value:
            value = checkEdgeLength
            targetEdge = edge
    
    if targetEdge:
        cmds.select(targetEdge)
    else:
        raise ValueError("No edge found matching the criteria.")

def X52(edge):
    vertices = cmds.polyListComponentConversion(edge, toVertex=True)
    vertices = cmds.filterExpand(vertices, sm=31)
    length = X89(vertices[0], vertices[1])
    return length

def X89(vertex1, vertex2):
    v1 = cmds.pointPosition(vertex1, w=True)
    v2 = cmds.pointPosition(vertex2, w=True)
    distance = math.sqrt((v1[0] - v2[0])**2 + (v1[1] - v2[1])**2 + (v1[2] - v2[2])**2)
    return distance

def XO3():
    keepCheckBox = cmds.checkBox('keepSpliteNumber', q=True, v=True)
    keepInsertNumber = cmds.floatSliderGrp('multiInsertNo', q=True, v=True)
    selectedEdges = cmds.ls(sl=True, fl=True)
    polySplitRingNodes = cmds.ls(type='polySplitRing')
    cmds.floatSliderGrp('multiInsertNo', e=True, v=1)
    polySRList = []
    obj = cmds.ls(hl=True)
    if polySplitRingNodes:
        cmds.select(obj)
        cmds.delete(ch=True)
    if len(selectedEdges) == 1:
        cmds.select(selectedEdges)
        cmds.polySelectSp(ring=True)
        nodeLst = cmds.polySplitRing(ch=True, splitType=2, divisions=1, useEqualMultiplier=True, smoothingAngle=30, fixQuads=False)
        cmds.connectControl('multiInsertNo', nodeLst[0] + ".div")
        if keepCheckBox:
            cmds.setAttr(nodeLst[0] + ".div", keepInsertNumber)
            cmds.floatSliderGrp('multiInsertNo', e=True, v=keepInsertNumber)
    elif len(selectedEdges) > 1:
        confirmString = cmds.confirmDialog(title="Confirm", message="Warning!! More than one edge selected?", button=["Continues", "Abort"], defaultButton="Abort", cancelButton="Abort", dismissString="Abort")
        if confirmString == "Continues":
            for s in selectedEdges:
                cmds.select(s)
                cmds.polySelectSp(ring=True)
                nodeLst = cmds.polySplitRing(ch=True, splitType=2, divisions=1, useEqualMultiplier=True, smoothingAngle=30, fixQuads=False)
                polySRList.append(nodeLst[0] + ".div")
            collectList = ['"{}"'.format(p) for p in polySRList]
            getList = ','.join(collectList)
            cmd = "cmds.connectControl('multiInsertNo', {})".format(getList)
            eval(cmd)
            if keepCheckBox:
                cmds.floatSliderGrp('multiInsertNo', e=True, v=keepInsertNumber)
                for p in polySRList:
                    cmds.setAttr(p, keepInsertNumber)
        cmds.select(cl=True)
    if obj:
        cmd = 'doMenuComponentSelection("' + obj[0]  +'", "edge");'
        mel.eval(cmd)
        
def X2l(location, curveObject):
    curve = curveObject
    tempList = om.MSelectionList()
    tempList.add(curve)
    curveObj = om.MObject()
    tempList.getDependNode(0, curveObj)
    dagpath = om.MDagPath()
    tempList.getDagPath(0, dagpath)
    curveMF = om.MFnNurbsCurve(dagpath)
    point = om.MPoint( location[0], location[1], location[2])
    prm = om.MScriptUtil()
    pointer = prm.asDoublePtr()
    om.MScriptUtil.setDouble (pointer, 0.0)
    tolerance = .001
    space = om.MSpace.kObject
    result = om.MPoint()
    result = curveMF.closestPoint (point, pointer,  0.0, space)
    parameter = om.MScriptUtil.getDouble (pointer)
    return [parameter, (result.x), (result.y), (result.z)]
    
def X39(SX, SY):
    pos = om.MPoint()
    dir = om.MVector()
    hitpoint = om.MFloatPoint()
    omui.M3dView().active3dView().viewToWorld(int(SX), int(SY), pos, dir)
    pos2 = om.MFloatPoint(pos.x, pos.y, pos.z)
    checkCam = X68()
    finalX = []
    finalY = []
    finalZ = []
    checkList = []
    checkList.append('refPlane')
    for mesh in checkList:
        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, None, None, None, None)
        if intersection:
            finalX = hitpoint.x
            finalY = hitpoint.y
            finalZ = hitpoint.z
    return (finalX, finalY, finalZ)
    
def X49(pointName):
    view = omuia.M3dView.active3dView()
    posInView = []
    ppos = cmds.pointPosition(pointName, w=1)
    posInView.append(view.worldToView(oma.MPoint(ppos)))
    vpos = view.worldToView(oma.MPoint(ppos))
    wx, wy, wz = X39(vpos[0], vpos[1])
    return (wx, wy, wz)
    
def Xl3(cameraName, worldPoint):
    resWidth, resHeight = X34()
    selList = om.MSelectionList()
    selList.add(cameraName)
    dagPath = om.MDagPath()
    selList.getDagPath(0, dagPath)
    dagPath.extendToShape()
    camInvMtx = dagPath.inclusiveMatrix().inverse()
    fnCam = om.MFnCamera(dagPath)
    mFloatMtx = fnCam.projectionMatrix()
    projMtx = om.MMatrix(mFloatMtx.matrix)
    mPoint = om.MPoint(worldPoint[0], worldPoint[1], worldPoint[2]) * camInvMtx * projMtx
    x = (mPoint[0] / mPoint[3] / 2 + 0.5) * resWidth
    y = (mPoint[1] / mPoint[3] / 2 + 0.5) * resHeight
    return [x, y]
    
def X34():
    windowUnder = cmds.getPanel(withFocus=True)
    if 'modelPanel' not in windowUnder:
        windowUnder = 'modelPanel4'
    viewNow = omui.M3dView.active3dView()
    omui.M3dView.getM3dViewFromModelEditor(windowUnder, viewNow)
    screenW = omui.M3dView.portWidth(viewNow)
    screenH = omui.M3dView.portHeight(viewNow)
    return (screenW, screenH)
    
def X55(tX, tY, tZ):
    checkCam = X68()
    resWidth, resHeight = X34()
    ratio = cmds.getAttr('defaultResolution.deviceAspectRatio')
    cmds.polyPlane(w=ratio, h=1, sx=40, sy=20, ax=(0, 0, 1), cuv=2, ch=1)
    cmds.rename('refPlane')
    cmds.setAttr('refPlane.visibility', 0)
    cmds.parentConstraint(checkCam, 'refPlane', weight=1)
    cmds.delete(constraints=True)
    cmds.setAttr('refPlane.translateX', tX)
    cmds.setAttr('refPlane.translateY', tY)
    cmds.setAttr('refPlane.translateZ', tZ)
    head3d = cmds.pointPosition('refPlane.vtx[0]')
    tail3d = cmds.pointPosition('refPlane.vtx[860]')
    head2D = Xl3(checkCam, (head3d[0], head3d[1], head3d[2]))
    tail2d = Xl3(checkCam, (tail3d[0], tail3d[1], tail3d[2]))
    distanceX = tail2d[0] - head2D[0]
    distanceY = tail2d[1] - head2D[1]
    cmds.setAttr('refPlane.scaleX', resWidth / distanceX * 2)
    cmds.setAttr('refPlane.scaleY', resHeight / distanceY * 2)
    
def X68():
    view = omui.M3dView.active3dView()
    cam = om.MDagPath()
    view.getCamera(cam)
    camPath = cam.fullPathName()
    cameraTrans = cmds.listRelatives(camPath, type='transform', p=True)
    cameraPosition = cmds.xform(cameraTrans, q=1, ws=1, rp=1)
    return cameraTrans[0]
    
def Xo7(edgeList):
    listEvenVtx = X8I(edgeList)
    if cmds.objExists('tempEvenCurve'):
        cmds.delete('tempEvenCurve')
    cmds.select(edgeList)
    cmds.polyToCurve(form=2, degree=1, conformToSmoothMeshPreview=1)
    cmds.rename('tempEvenCurve')
    curveCVs =cmds.ls('tempEvenCurve.cv[*]',fl=1)
    posCurve = cmds.xform(curveCVs[0], a=1,ws=1, q=1, t=1)
    posEdge = cmds.xform(listEvenVtx[0], a=1,ws=1, q=1, t=1)
    if posCurve == posEdge:
        pass
    else:
        listEvenVtx = listEvenVtx[::-1]
    cmds.rebuildCurve('tempEvenCurve',ch=0, rpo=1, rt=0, end=1, kr=0, kcp=0, kep=1, kt=0, s = 0 , d=1, tol=0)
    cmds.rebuildCurve('tempEvenCurve',ch=0, rpo=1, rt=0, end=1, kr=0, kcp=0, kep=1, kt=0, s = 0 , d=1, tol=0)
    if len(curveCVs)< 4:
        cmds.delete( 'tempEvenCurve.cv[1]', 'tempEvenCurve.cv[3]')
        curveCVs =cmds.ls('tempEvenCurve.cv[*]',fl=1)
    for i in range(len(curveCVs)):
        pos = cmds.xform(curveCVs[i], a=1,ws=1, q=1, t=1)
        cmds.xform(listEvenVtx[i], a=1, ws=1, t = (pos[0],pos[1],pos[2]) )
    cmds.delete('tempEvenCurve')
    
def X94():
    edgeLoopSel = cmds.ls(sl=1,fl=1)
    sortGrp = X69()
    for e in sortGrp:
        X29(e)
    meshName = edgeLoopSel[0].split('.')[0]
    cmd = 'doMenuNURBComponentSelection("' + meshName + '", "edge");'
    mel.eval(cmd)
    cmds.select(edgeLoopSel)

def X29(flatList):
    X2I()
    listVtx = X8I(flatList)
    cmds.select(flatList)
    cmds.polyToCurve(form=0, degree=1, conformToSmoothMeshPreview=1,)
    cmds.rename('newguildcurve')
    cmds.delete('newguildcurve',  e=1, ch=1)
    cmd = 'modifySelectedCurves smooth 1 0;'
    mel.eval(cmd)
    xA, yA, zA = cmds.pointPosition(listVtx[0], w=1)
    xA =  round(xA,3)
    yA =  round(yA,3)
    zA =  round(zA,3)
    xC, yC, zC = cmds.pointPosition('newguildcurve.cv[0]',w=1)
    xC =  round(xC,3)
    yC =  round(yC,3)
    zC =  round(zC,3)
    if xA == xC and yA == yC and zA == zC:
       pass
    else:
        listVtx.reverse()
    for i in range(1,len(listVtx)-1):
        xD, yD, zD = cmds.pointPosition('newguildcurve.cv['+str(i)+']',w=1)
        cmds.move(xD, yD, zD,listVtx[i] , a =True, ws=True)
    X2I()

def X47(mode):
    if mode == 3:
        cmds.iconTextButton('button2DIcon' ,e=1 ,bgc =  [0.18,0.18,0.18] )
        cmds.iconTextButton('button3DIcon' ,e=1 ,bgc =  [0.5, 0.21, 0] )
    elif mode ==2:
        cmds.iconTextButton('button2DIcon' ,e=1 ,bgc =  [0.5, 0.21, 0] )
        cmds.iconTextButton('button3DIcon' ,e=1 ,bgc =  [0.18,0.18,0.18] )

def Xoo(level):
    checkMode = cmds.iconTextButton('button2DIcon' ,q=1 ,bgc = 1 )
    if checkMode[2] > 0:
        X9l(level)
    else:
        Xl8(level)

def Xl8(level):
    edgeLoopSel = cmds.ls(sl=1,fl=1)
    sortGrp = X69()
    for e in sortGrp:
        X63(e,level)
    meshName = edgeLoopSel[0].split('.')[0]
    cmd = 'doMenuNURBComponentSelection("' + meshName + '", "edge");'
    mel.eval(cmd)
    cmds.select(edgeLoopSel)

def X63(flatList,level):
    numberPoint = level
    X2I()
    listVtx = X8I(flatList)
    checkCam = X68()
    closetP2Cam = []
    shortDistance = 10000000000
    cameraPosition = cmds.xform(checkCam, q=1, ws=1, rp=1)
    for g in listVtx:
        x, y, z = cmds.pointPosition(g, w=1)
        distanceBetween = math.sqrt((float(cameraPosition[0]) - x) ** 2 + (float(cameraPosition[1]) - y) ** 2 + (float(cameraPosition[2]) - z) ** 2)
        if distanceBetween < shortDistance:
            shortDistance = distanceBetween
            closetP2Cam = g
    tX, tY, tZ = cmds.pointPosition(closetP2Cam, w=1)
    X55(tX, tY, tZ)
    pointDict = []
    for g in listVtx:
        pos = X49(g)
        pointDict.append(pos)
    cmds.curve(d=1, p=[(pointDict[0][0], pointDict[0][1], pointDict[0][2]), (pointDict[-1][0], pointDict[-1][1], pointDict[-1][2])])
    cmds.rename('newguildcurve')
    if numberPoint == 1:
        cmds.rebuildCurve('newguildcurve', ch=0, rpo=1, rt=0, end=1, kr=0, kcp=0, kep=1, kt=0, s=1, d=3, tol=0)
        gap = int(len(listVtx) * 0.5)
        cmds.select('newguildcurve.cv[1]', 'newguildcurve.cv[2]')
        nodeCluster = cmds.cluster(n= 'midGrp')
        cmds.move(pointDict[gap][0], pointDict[gap][1], pointDict[gap][2], nodeCluster[1], rpr=True)
    elif numberPoint == 2:
        cmds.rebuildCurve('newguildcurve', ch=0, rpo=1, rt=0, end=1, kr=0, kcp=0, kep=1, kt=0, s=2, d=2, tol=0)
        gapA = int(len(listVtx) * 0.33333)
        gapB = int(len(listVtx) * 0.66666)
        cmds.move(pointDict[gapA][0], pointDict[gapA][1], pointDict[gapA][2], 'newguildcurve.cv[1]', rpr=True)
        cmds.move(pointDict[gapB][0], pointDict[gapB][1], pointDict[gapB][2], 'newguildcurve.cv[2]', rpr=True)
    elif numberPoint == 3:
        cmds.rebuildCurve('newguildcurve', ch=0, rpo=1, rt=0, end=1, kr=0, kcp=0, kep=1, kt=0, s=3, d=2, tol=0)
        gapA = int(len(listVtx) * 0.25)
        gapB = int(len(listVtx) * 0.5)
        gapC = int(len(listVtx) * 0.75)
        cmds.move(pointDict[gapA][0], pointDict[gapA][1], pointDict[gapA][2], 'newguildcurve.cv[1]', rpr=True)
        cmds.move(pointDict[gapB][0], pointDict[gapB][1], pointDict[gapB][2], 'newguildcurve.cv[2]', rpr=True)
        cmds.move(pointDict[gapC][0], pointDict[gapC][1], pointDict[gapC][2], 'newguildcurve.cv[3]', rpr=True)
    cmds.delete('newguildcurve', ch=1)
    cmds.move(cameraPosition[0], cameraPosition[1], cameraPosition[2], 'newguildcurve.scalePivot', 'newguildcurve.rotatePivot')
    cmds.duplicate('newguildcurve')
    cmds.setAttr('newguildcurve.scaleX', 0.5)
    cmds.setAttr('newguildcurve.scaleY', 0.5)
    cmds.setAttr('newguildcurve.scaleZ', 0.5)
    cmds.setAttr('newguildcurve1.scaleX', 2)
    cmds.setAttr('newguildcurve1.scaleY', 2)
    cmds.setAttr('newguildcurve1.scaleZ', 2)
    cmds.nurbsToPolygonsPref(polyType=1, format=3, uType=3, uNumber=1, vType=3, vNumber=1)
    loftNode = cmds.loft('newguildcurve1', 'newguildcurve', ch=1, u=1, c=0, ar=1, d=3, ss=1, rn=0, po=1, rsn=True)
    cmds.rename('guildMesh')
    cmds.polySmooth('guildMesh', mth=0, sdt=2, ovb=1, ofb=3, ofc=0, ost=0, ocr=0, dv=2, bnr=1, c=1, kb=1, ksb=1, khe=0, kt=1, kmb=1, suv=1, peh=0, sl=1, dpe=1, ps=0.1, ro=1, ch=0)
    cmds.transferAttributes('guildMesh', listVtx, transferPositions=1, searchMethod=3)
    shapesNode = cmds.listRelatives(listVtx[0], shapes=True, ap=True)
    cmds.delete(shapesNode, ch=1)
    X2I()
def X2I():
    cleanSceneList = {'refPlan*','newguildcurv*','newguildcurv*','guildMes*','baseLo*','newDeformcurv*'}
    for c in cleanSceneList:
        if cmds.objExists(c):
            cmds.delete(c)
def X9l(level):
    edgeLoopSel = cmds.ls(sl=1,fl=1)
    sortGrp = X69()
    for e in sortGrp:
        X54(e,level)
    meshName = edgeLoopSel[0].split('.')[0]
    cmd = 'doMenuNURBComponentSelection("' + meshName + '", "edge");'
    mel.eval(cmd)
    cmds.select(edgeLoopSel)
def X54(flatList,level):
    checkEven = cmds.checkBox('evenCurveEdgeLength', q=1,v=1)
    X2I()
    listVtx = X8I(flatList)
    numberPoint = level
    distList = []
    totalDist = 0
    xA, yA, zA = cmds.pointPosition(listVtx[0], w=1)
    xB, yB, zB = cmds.pointPosition(listVtx[-1], w=1)
    cmds.curve(d=1, p=[(xA, yA, zA),(xB, yB, zB)])
    cmds.rename('newguildcurve')
    for i in range(len(listVtx)-1):
        xA, yA, zA = cmds.pointPosition(listVtx[i], w=1)
        xB, yB, zB = cmds.pointPosition(listVtx[i+1], w=1)
        distanceBetween = math.sqrt((xA - xB) * (xA - xB) + (yA - yB) * (yA - yB) + (zA - zB) * (zA - zB))
        distList.append(distanceBetween)
        totalDist = totalDist + distanceBetween
    if numberPoint == 1:
        cmds.rebuildCurve('newguildcurve', ch=0, rpo=1, rt=0, end=1, kr=0, kcp=0, kep=1, kt=0, s=1, d=3, tol=0)
        gapA = int(len(listVtx) * 0.5)
        xA, yA, zA = cmds.pointPosition(listVtx[gapA], w=1)
        cmds.select('newguildcurve.cv[1]','newguildcurve.cv[2]')
        nodeCluster = cmds.cluster(n= 'midGrp')
        cmds.spaceLocator(n='baseLoc')
        cmds.select('baseLoc',nodeCluster[1])
        cmds.matchTransform()
        cmds.move( xA, yA, zA, nodeCluster[1], rpr =1)
        cmds.select(nodeCluster[1],'baseLoc')
        cmds.parent()
        cmds.setAttr("baseLoc.scale", 1.33, 1.33, 1.33)
    elif numberPoint == 2:
        cmds.rebuildCurve('newguildcurve', ch=1, rpo=1, rt=0, end=1, kr=0, kcp=0, kep=1, kt=0, s=2, d=2, tol=0)
        gapA = int(len(listVtx) * 0.33333)
        gapB = int(len(listVtx) * 0.66666)
        xA, yA, zA = cmds.pointPosition(listVtx[gapA], w=1)
        xB, yB, zB = cmds.pointPosition(listVtx[gapB ], w=1)
        cmds.move( xA, yA, zA, 'newguildcurve.cv[1]', a =True, ws=True)
        cmds.move( xB, yB, zB, 'newguildcurve.cv[2]', a =True, ws=True)
    elif numberPoint == 3:
        cmds.rebuildCurve('newguildcurve', ch=0, rpo=1, rt=0, end=1, kr=0, kcp=0, kep=1, kt=0, s=3, d=2, tol=0)
        gapA = int(len(listVtx) * 0.25)
        gapB = int(len(listVtx) * 0.5)
        gapC = int(len(listVtx) * 0.75)
        xA, yA, zA = cmds.pointPosition(listVtx[gapA], w=1)
        xB, yB, zB = cmds.pointPosition(listVtx[gapB ], w=1)
        xC, yC, zC = cmds.pointPosition(listVtx[gapC ], w=1)
        cmds.move( xA, yA, zA, 'newguildcurve.cv[1]', a =True, ws=True)
        cmds.move( xB, yB, zB, 'newguildcurve.cv[2]', a =True, ws=True)
        cmds.move( xC, yC, zC, 'newguildcurve.cv[3]', a =True, ws=True)
    cmds.rebuildCurve('newguildcurve', ch=1, rpo=1, rt=0, end=1, kr=0, kcp=0, kep=1, kt=0, s=100, d=3, tol=0)
    currentU = 0
    prV = 0
    gapDist = 1.0/(len(listVtx)-1)
    scaleV = 1/totalDist
    for j in range(len(listVtx)-2):
        if checkEven == 1:
            prV = currentU + gapDist
        else:
            prV = currentU + (scaleV * distList[j])
        currentU = prV
        xj, yj, zj = cmds.pointOnCurve('newguildcurve', pr= currentU, p=1)
        cmds.move(xj, yj, zj,listVtx[j+1] , a =True, ws=True)

    X2I()

def X3l(dir,startMode):
    global edgeCurlRunMoveCV
    global edgeCurlRunSel
    global edgeCurlRunDistList
    global startModeRecord
    startModeRecord = startMode
    modifiers = 0
    if startMode == 0:
        modifiers = cmds.getModifiers()
    elif startMode == 1:
        modifiers = 1
    elif startMode == 4:
        modifiers = 4
    elif startMode == 100:
        modifiers = 0
    edgeCurlRunDistList = []
    edgeCurlRunSel = []
    edgeCurlRunMoveCV = []
    checkEndCV = []
    distList = []
    edgeSel = cmds.ls(sl=1,fl=1)
    if len(edgeSel) == 1:
        cmds.ConvertSelectionToVertices()
        selectsCV = cmds.ls(sl=1,fl=1)
        cmds.select(edgeSel)
        cmds.SelectEdgeLoopSp()
        cmds.ConvertSelectionToVertices()
        loopCVList = cmds.ls(sl=1,fl=1)
        cmds.select(selectsCV)
        cmds.ConvertSelectionToEdges()
        cmds.ConvertSelectionToVertices()
        surroundCV = cmds.ls(sl=1,fl=1)
        commonList = list(set(surroundCV) & set(loopCVList))
        cmds.select(commonList)
        cmds.ConvertSelectionToContainedEdges()
        checkConnerEdge = cmds.ls(sl=1,fl=1)
        if len(checkConnerEdge) == 3:
            cmds.ConvertSelectionToFaces()
            checkConnerFace = cmds.ls(sl=1,fl=1)
            if len(checkConnerFace)==2:
                cmds.select(edgeSel)
                cmds.GrowLoopPolygonSelectionRegion()
            elif len(checkConnerFace) > 2:
                cmds.select(checkConnerEdge)
    else:
        cmds.setToolTo( 'moveSuperContext' )
    getCircleState,listVtx = Xll()
    if getCircleState == 0:
        edgeCurlRunSel = edgeSel
        cleanList = ('tempGuid*','arcCurv*','upperLo*','aimLo*','baseLo*','makeThreePointCircularAr*','tempGuideLin*')
        for c in cleanList:
            if cmds.objExists(c):
                cmds.delete(c)
        leftCV = ''
        rightCV = ''
        view = omui.M3dView.active3dView()
        cam = om.MDagPath()
        view.getCamera(cam)
        camPath = cam.fullPathName()
        cameraTrans = cmds.listRelatives(camPath,type='transform',p=True)
        CurrentCam = cameraTrans[0]
        xA, yA, zA = cmds.pointPosition(listVtx[0], w=1)
        A2D = Xl3(cameraTrans[0], (xA,yA,zA))
        xB, yB, zB = cmds.pointPosition(listVtx[-1], w=1)
        B2D = Xl3(cameraTrans[0], (xB,yB,zB))
        if A2D[0] < B2D[0]:
            leftCV = listVtx[0]
            rightCV = listVtx[-1]
        else:
            rightCV = listVtx[0]
            leftCV = listVtx[-1]
        if leftCV == listVtx[-1]:
            listVtx.reverse()
        if dir == 'L':
            listVtx.reverse()
        if len(edgeSel) == 1:
            xA, yA, zA = cmds.pointPosition(listVtx[-1], w=1)
            xB, yB, zB = cmds.pointPosition(listVtx[-2], w=1)
            distanceBetween = math.sqrt((xA - xB) * (xA - xB) + (yA - yB) * (yA - yB) + (zA - zB) * (zA - zB))
            distList.append(distanceBetween)
        elif len(edgeSel) > 2:
            distList = []
            for i in range(len(listVtx)-1):
                xA, yA, zA = cmds.pointPosition(listVtx[i], w=1)
                xB, yB, zB = cmds.pointPosition(listVtx[i+1], w=1)
                distanceBetween = math.sqrt((xA - xB) * (xA - xB) + (yA - yB) * (yA - yB) + (zA - zB) * (zA - zB))
                distList.append(distanceBetween)
        edgeCurlRunDistList = distList
        firstCV = listVtx[0]
        secCV = listVtx[1]
        thirdCV = ''
        if len(edgeSel) == 1:
            thirdCV = listVtx[2]
        else:
            thirdCV = listVtx[-1]
        edgeCurlRunMoveCV = listVtx
        if startMode != 100:
            p1 = cmds.pointPosition(firstCV, w=1)
            p2 = cmds.pointPosition(secCV, w=1)
            p3 = cmds.pointPosition(thirdCV, w=1)
            newNode = cmds.createNode('makeThreePointCircularArc')
            cmds.setAttr(newNode + '.pt1', p1[0], p1[1], p1[2])
            cmds.setAttr(newNode + '.pt2', p2[0], p2[1], p2[2])
            cmds.setAttr(newNode + '.pt3', p3[0], p3[1], p3[2])
            cmds.setAttr(newNode + '.d', 3)
            cmds.setAttr(newNode + '.s', 4)
            newCurve = cmds.createNode('nurbsCurve')
            cmds.select(cl=1)
            cmds.connectAttr(newNode + '.oc', newCurve + '.cr')
            transformNode = cmds.listRelatives(newCurve, fullPath=True, parent=True)
            cmds.rename(transformNode, 'arcCurve')
            cmd = 'doMenuComponentSelection("' + edgeCurlRunMoveCV[0].split('.')[0] +'", "edge");'
            mel.eval(cmd)
            cmds.select(edgeSel)
            cmds.refresh(f=True)
            cPos = cmds.getAttr( newNode +'.center')
            cmds.move( cPos[0][0],  cPos[0][1],  cPos[0][2],'arcCurve.scalePivot' ,'arcCurve.rotatePivot' , a =True, ws=True)
            cmds.delete(ch=1)
            circleR =  math.sqrt((p1[0] - cPos[0][0]) * (p1[0]  - cPos[0][0]) + (p1[1]  - cPos[0][1]) * (p1[1]  - cPos[0][1]) + (p1[2]  - cPos[0][2]) * (p1[2]  - cPos[0][2]))
            cmds.spaceLocator(n='upperLoc')
            cmds.spaceLocator(n='aimLoc')
            cmds.spaceLocator(n='baseLoc')
            cmds.select('upperLoc','aimLoc','baseLoc')
            cmds.CenterPivot()
            cmds.setAttr(('upperLoc.scale'),0.01,0.01,0.01)
            cmds.setAttr(('aimLoc.scale'),0.01,0.01,0.01)
            cmds.setAttr(('aimLoc.translate'),0, 1,-1)
            cmds.setAttr(('upperLoc.translate'),0, 1,1)
            consNode = cmds.aimConstraint('aimLoc','baseLoc',offset=[0,0,0], weight=1, aimVector=[1,0,0], upVector=[0,1,0], worldUpType='object', worldUpObject='upperLoc')
            cmds.setAttr(('baseLoc.translate'),cPos[0][0], cPos[0][1], cPos[0][2])
            cmds.setAttr(('aimLoc.translate'),p3[0], p3[1], p3[2])
            cmds.setAttr(('upperLoc.translate'),p1[0], p1[1], p1[2])
            cmds.circle( nr=(0, 0, 1), c=(0, 0, 0),r= circleR,n='tempGuide')
            cmds.displaySmoothness(divisionsU=3, divisionsV=3, pointsWire=16, pointsShaded=4, polygonObject=3)
            cmds.setAttr("tempGuideShape.overrideEnabled", 1)
            cmds.setAttr("tempGuideShape.overrideColor",31)
            cmds.select('tempGuide','baseLoc')
            cmds.matchTransform()
            cmds.select('baseLoc',d=1)
            cmds.makeIdentity('tempGuide', apply=1, t=1,r=1,s=1)
            cmds.ReverseCurve()
            cmds.delete(ch=1)
            cmds.move(  p2[0],   p2[1],   p2[2],'tempGuide.scalePivot' ,'tempGuide.rotatePivot' , a =True, ws=True)
        else:
            if len(edgeSel) == 1:
                cmds.select(edgeSel)
            else:
                cmds.select(edgeCurlRunMoveCV[0],edgeCurlRunMoveCV[1])
                cmds.ConvertSelectionToContainedEdges()
            cmds.polyToCurve(form=0, degree=1, conformToSmoothMeshPreview=1)
            cmds.rename('tempGuide')
            cmds.CenterPivot()
            cmds.ReverseCurve()
            cmds.delete(ch=1)
            cmds.setAttr("tempGuide.scale",50,50,50)
            cmds.makeIdentity('tempGuide', apply=1, t=1,r=1,s=1)
        checkLock = cmds.checkBox('lockCurveEdgeLength', q=1,v=1)
        checkEven = cmds.checkBox('evenCurveEdgeLength', q=1,v=1)
        if startMode == 100:
            xA, yA, zA = cmds.pointPosition('tempGuide.cv[0]', w=1)
            A2D = Xl3(cameraTrans[0], (xA,yA,zA))
            xB, yB, zB = cmds.pointPosition('tempGuide.cv[1]', w=1)
            B2D = Xl3(cameraTrans[0], (xB,yB,zB))
            if A2D[0] > B2D[0]:
                cmds.select('tempGuide')
                cmds.ReverseCurve()
            if dir == 'L':
                cmds.select('tempGuide')
                cmds.ReverseCurve()
            if checkEven == 1 and len(edgeSel) > 1:
                Xo7(edgeSel)
            if checkLock == 0:
                selectionList = om.MSelectionList()
                selectionList.add('tempGuide')
                dagPath = om.MDagPath()
                selectionList.getDagPath(0, dagPath)
                omCurveOut = om.MFnNurbsCurve(dagPath)
                for m in range(1,len(edgeCurlRunMoveCV)) :
                    xK, yK, zK = cmds.pointPosition(edgeCurlRunMoveCV[m], w=1)
                    pointInSpace = om.MPoint(xK,yK,zK)
                    closestPoint = om.MPoint()
                    closestPoint = omCurveOut.closestPoint(pointInSpace)
                    cmds.move( closestPoint[0], closestPoint[1], closestPoint[2],edgeCurlRunMoveCV[m] , a =True, ws=True)
            else:
                circleLength = cmds.arclen( 'tempGuide' )
                maxU = cmds.getAttr('tempGuide.maxValue')
                UScaleV = circleLength  / maxU
                if len(edgeSel) == 1:
                    xK, yK, zK = cmds.pointPosition(edgeCurlRunMoveCV[-2], w=1)
                    getU = X2l([xK, yK, zK], 'tempGuide')[0]
                    movingDist = distList[0]
                    moveV = movingDist / UScaleV
                    newU = getU + moveV
                    xj, yj, zj = cmds.pointOnCurve('tempGuide', pr= newU, p=1)
                    cmds.move(xj, yj, zj, edgeCurlRunMoveCV[-1] , a =True, ws=True)
                else:
                    for m in range(1,len(edgeCurlRunMoveCV)) :
                        xK, yK, zK = cmds.pointPosition(edgeCurlRunMoveCV[m-1], w=1)
                        getU = X2l([xK, yK, zK], 'tempGuide')[0]
                        movingDist = distList[m-1]
                        moveV = movingDist / UScaleV
                        newU = getU + moveV
                        xj, yj, zj = cmds.pointOnCurve('tempGuide', pr= newU, p=1)
                        cmds.move(xj, yj, zj, edgeCurlRunMoveCV[m] , a =True, ws=True)
        else:
            if checkLock == 0:
                selectionList = om.MSelectionList()
                selectionList.add('tempGuide')
                dagPath = om.MDagPath()
                selectionList.getDagPath(0, dagPath)
                omCurveOut = om.MFnNurbsCurve(dagPath)
                if checkEven == 1:
                    Xo7(edgeSel)
                for m in range(1,len(edgeCurlRunMoveCV)) :
                    xK, yK, zK = cmds.pointPosition(edgeCurlRunMoveCV[m], w=1)
                    pointInSpace = om.MPoint(xK,yK,zK)
                    closestPoint = om.MPoint()
                    closestPoint = omCurveOut.closestPoint(pointInSpace)
                    cmds.move(closestPoint[0], closestPoint[1], closestPoint[2], edgeCurlRunMoveCV[m] , a =True, ws=True)
            else:
                circleLength = cmds.arclen( 'tempGuide' )
                maxU = cmds.getAttr('tempGuide.maxValue')
                UScaleV = circleLength  / maxU
                if len(edgeSel) == 1:
                    xK, yK, zK = cmds.pointPosition(edgeCurlRunMoveCV[-2], w=1)
                    getU = X2l([xK, yK, zK], 'tempGuide')[0]
                    movingDist = distList[0]
                    moveV = movingDist / UScaleV
                    newU = getU + moveV
                    xj, yj, zj = cmds.pointOnCurve('tempGuide', pr= newU, p=1)
                    cmds.move(xj, yj, zj, edgeCurlRunMoveCV[-1] , a =True, ws=True)
                else:
                    for m in range(1,len(edgeCurlRunMoveCV)) :
                        xK, yK, zK = cmds.pointPosition(edgeCurlRunMoveCV[m-1], w=1)
                        getU = X2l([xK, yK, zK], 'tempGuide')[0]
                        movingDist = distList[m-1]
                        moveV = movingDist / UScaleV
                        newU = getU + moveV
                        xj, yj, zj = cmds.pointOnCurve('tempGuide', pr= newU, p=1)
                        cmds.move(xj, yj, zj, edgeCurlRunMoveCV[m] , a =True, ws=True)
        cleanList = []
        if len(edgeSel) == 1:
            cmds.select(edgeCurlRunMoveCV[-2],edgeCurlRunMoveCV[-1])
            cmds.ConvertSelectionToContainedEdges()
            selNew=cmds.ls(sl=1)
            cmd = 'doMenuComponentSelection("' + edgeSel[0].split('.')[0] +'", "edge");'
            mel.eval(cmd)
            cmds.select(selNew)
            cleanList = ('tempGuid*','arcCurv*','upperLo*','aimLo*','baseLo*','makeThreePointCircularAr*','tempGuideLin*')
        else:
            if startMode!= 100:
                global ctx
                ctx = 'edgeCurlRun'
                if cmds.draggerContext(ctx, exists=True):
                    cmds.deleteUI(ctx)
                cmds.draggerContext(ctx, pressCommand = X78, rc = Xo6, dragCommand = XOl, fnz = X3I, name=ctx, cursor='crossHair',undoMode='step')
                cmds.setToolTo(ctx)
                cleanList = ('arcCurv*','upperLo*','aimLo*','baseLo*','makeThreePointCircularAr*','tempGuideLin*')
            else:
                cleanList = ('tempGuid*','arcCurv*','upperLo*','aimLo*','baseLo*','makeThreePointCircularAr*','tempGuideLin*')
            cmds.select(edgeSel)
            cmd = 'doMenuComponentSelection("' + edgeSel[0].split('.')[0] +'", "edge");'
            mel.eval(cmd)
            cmds.select(edgeCurlRunSel)
        for c in cleanList:
            if cmds.objExists(c):
                cmds.delete(c)

def Xo6():
    lineList = ('tempGuide','tempGuideLine')
    for l in lineList:
        if cmds.objExists(l):
            cmds.setAttr((l + ".visibility"),0)

def XOl():
    global edgeCurlRunMoveCV
    global edgeCurlRunSel
    global screenX,screenY
    global ctx
    global currentScaleRecord
    global edgeCurlRunDistList
    global startModeRecord
    currentRotRecord = 0
    currentEnRecord = 0
    vpX, vpY, _ = cmds.draggerContext(ctx, query=True, dragPoint=True)
    screenX = vpX
    screenY = vpY
    selectionList = om.MSelectionList()
    selectionList.add('tempGuide')
    dagPath = om.MDagPath()
    selectionList.getDagPath(0, dagPath)
    omCurveOut = om.MFnNurbsCurve(dagPath)
    if currentScaleRecord > vpX:
        cmds.setAttr('tempGuide.scale',1.02,1.02,1.02)
    else:
        cmds.setAttr('tempGuide.scale',0.98,0.98,0.98)
    currentScaleRecord = vpX
    cmds.makeIdentity('tempGuide', apply=1, t=1,r=1,s=1)
    checkLock = cmds.checkBox('lockCurveEdgeLength', q=1,v=1)
    if(checkLock == 1):
        cmds.setAttr("tempGuide.visibility",1)
        circleLength = cmds.arclen( 'tempGuide' )
        maxU = cmds.getAttr('tempGuide.maxValue')
        UScaleV = circleLength  / maxU
        for m in range(1,len(edgeCurlRunMoveCV)) :
            xK, yK, zK = cmds.pointPosition(edgeCurlRunMoveCV[m-1], w=1)
            getU = X2l([xK, yK, zK], 'tempGuide')[0]
            movingDist = edgeCurlRunDistList[m-1]
            moveV = movingDist / UScaleV
            newU = getU + moveV
            xj, yj, zj = cmds.pointOnCurve('tempGuide', pr= newU, p=1)
            cmds.move(xj, yj, zj, edgeCurlRunMoveCV[m] , a =True, ws=True)
    else:
        cmds.setAttr("tempGuide.visibility",1)
        for m in range(1,len(edgeCurlRunMoveCV)) :
            xK, yK, zK = cmds.pointPosition(edgeCurlRunMoveCV[m], w=1)
            pointInSpace = om.MPoint(xK,yK,zK)
            closestPoint = om.MPoint()
            closestPoint = omCurveOut.closestPoint(pointInSpace)
            cmds.move(closestPoint[0], closestPoint[1], closestPoint[2], edgeCurlRunMoveCV[m] , a =True, ws=True)
    cmds.refresh(f=True)

def X3I():
    cleanList = ('tempGuid*','arcCurv*','upperLo*','aimLo*','baseLo*','makeThreePointCircularAr*','tempGuideLin*')
    for c in cleanList:
        if cmds.objExists(c):
            cmds.delete(c)

def X78():
    global edgeCurlRunMoveCV
    global edgeCurlRunSel
    global screenX,screenY
    global ctx
    global currentScaleRecord
    currentScaleRecord = 0
    vpX, vpY, _ = cmds.draggerContext(ctx, query=True, anchorPoint=True)
    screenX = vpX
    screenY = vpY

def Xl6():
    cmds.checkBox('lockCurveEdgeLength', e=1,v=1)
    cmds.checkBox('evenCurveEdgeLength', e=1,v=0)
    cmds.setToolTo( 'moveSuperContext' )

def X83():
    cmds.checkBox('lockCurveEdgeLength', e=1,v=0)
    cmds.setToolTo( 'moveSuperContext' )

def X87():
    cmds.checkBox('lockCurveEdgeLength', e=1,v=0)
    cmds.checkBox('evenCurveEdgeLength', e=1,v=1)
    cmds.setToolTo( 'moveSuperContext' )

def X9o():
    cmds.checkBox('evenCurveEdgeLength', e=1,v=0)
    cmds.setToolTo( 'moveSuperContext' )

def X48():
    global curveGrp
    global totalLenGrp
    global ctx
    global listVtxFGrp
    global radiusBestFitGrp
    global arcGrp
    global radiusGrp
    global blendNodeList
    global ulistGrp
    global sectionNumber
    listVtxFGrp = []
    totalLenGrp = []
    ulistGrp = []
    curveGrp = []
    arcGrp = []
    radiusGrp = []
    radiusBestFitGrp = []
    blendNodeList = []
    selEdge = cmds.filterExpand(expand=True, sm=32)
    if selEdge:
        if cmds.objExists('saveSelSemi'):
            cmds.delete('saveSelSemi')
        cmds.sets(name='saveSelSemi', text='saveSelSemi')
        sortGrp = X69()
        for e in sortGrp:
            listVtx = X8I(e)
            firstN = listVtx[0].split('[')[1].split(']')[0]
            secN = listVtx[1].split('[')[1].split(']')[0]
            if int(firstN) > int(secN):
                listVtx.reverse()
            listVtxFGrp.append(listVtx)
            positionListA = []
            for n in listVtx:
                getPo = cmds.pointPosition(n, w=1)
                positionListA.append(getPo)
            p1 = cmds.pointPosition(listVtx[0], w=1)
            p2 = cmds.pointPosition(listVtx[-1], w=1)
            radius = math.sqrt((p1[0] - p2[0]) ** 2 + (p1[1] - p2[1]) ** 2 + (p1[2] - p2[2]) ** 2) / 2
            p3 = cmds.pointPosition(listVtx[int(len(listVtx) / 2)], w=1)
            p4 = [(p2[0] + p1[0]) / 2, (p2[1] + p1[1]) / 2, (p2[2] + p1[2]) / 2]
            distanceBC = math.sqrt((p4[0] - p3[0]) ** 2 + (p4[1] - p3[1]) ** 2 + (p4[2] - p3[2]) ** 2) / 2
            if distanceBC < 0.001:
                distanceBC = 0.001
            distanceBD = radius / 2.0
            OD = (distanceBC ** 2 + distanceBD ** 2) / (2 * distanceBC)
            newR = radius + OD
            radiusBestFitGrp.append(newR)
            radiusGrp.append(radius)
            newNode = cmds.createNode('makeTwoPointCircularArc')
            arcGrp.append(newNode)
            cmds.setAttr(newNode + '.pt1', p1[0], p1[1], p1[2])
            cmds.setAttr(newNode + '.pt2', p2[0], p2[1], p2[2])
            cmds.setAttr(newNode + '.tac', 0)
            cmds.setAttr(newNode + '.r', newR)
            cmds.setAttr(newNode + '.d', 3)
            sectionNumber = len(e)
            cmds.setAttr(newNode + '.s', sectionNumber)
            newCurve = cmds.createNode('nurbsCurve')
            cmds.connectAttr(newNode + '.oc', newCurve + '.cr')
            transformNode = cmds.listRelatives(newCurve, fullPath=True, parent=True)
            curveName = cmds.listRelatives(parent=True)
            curveGrp.append(curveName[0])
            cmds.setAttr(curveName[0] + '.visibility', 0)
            cvList = []
            cvList.append(listVtx[0])
            cvList.append(listVtx[int(len(listVtx) / 2)])
            cvList.append(listVtx[-1])
            points = []
            for cv in cvList:
                x, y, z = cmds.pointPosition(cv, w=1)
                this_point = om.MPoint(x, y, z)
                points.append(this_point)
            vectors = [ points[i + 1] - points[i] for i in range(len(points) - 1) ]
            if vectors[0] == vectors[1]:
                cmds.move(0.001, 0, 0, e[1:-1], r=1, cs=1, ls=1, wd=1)
                points = []
                for cv in cvList:
                    x, y, z = cmds.pointPosition(cv, w=1)
                    this_point = om.MPoint(x, y, z)
                    points.append(this_point)
                vectors = [ points[i + 1] - points[i] for i in range(len(points) - 1) ]
            Nx = vectors[0][1] * vectors[1][2] - vectors[0][2] * vectors[1][1]
            Ny = vectors[0][2] * vectors[1][0] - vectors[0][0] * vectors[1][2]
            Nz = vectors[0][0] * vectors[1][1] - vectors[0][1] * vectors[1][0]
            cmds.setAttr(newNode + '.directionVectorX', Nx)
            cmds.setAttr(newNode + '.directionVectorY', Ny)
            cmds.setAttr(newNode + '.directionVectorZ', Nz)
            cmds.group(em=True, name=curveName[0] + '_offsetSemi')
            cmds.group(em=True, name=curveName[0] + '_aim')
            cmds.setAttr(curveName[0] + '_offsetSemi.translateX', p1[0])
            cmds.setAttr(curveName[0] + '_offsetSemi.translateY', p1[1])
            cmds.setAttr(curveName[0] + '_offsetSemi.translateZ', p1[2])
            cmds.setAttr(curveName[0] + '_aim.translateX', p2[0])
            cmds.setAttr(curveName[0] + '_aim.translateY', p2[1])
            cmds.setAttr(curveName[0] + '_aim.translateZ', p2[2])
            const = cmds.aimConstraint(curveName[0] + '_aim', curveName[0] + '_offsetSemi')
            cmds.delete(const, curveName[0] + '_aim')
            cmds.parent(curveName[0], curveName[0] + '_offsetSemi')
            cmds.FreezeTransformations()
            cmds.move(p1[0], p1[1], p1[2], curveName[0] + '.scalePivot', curveName[0] + '.rotatePivot', a=1)
            totalEdgeLoopLength = 0
            sum = 0
            Llist = []
            uList = []
            pList = []
            for i in range(len(listVtx) - 1):
                pA = cmds.pointPosition(listVtx[i], w=1)
                pB = cmds.pointPosition(listVtx[i + 1], w=1)
                checkDistance = math.sqrt((pA[0] - pB[0]) ** 2 + (pA[1] - pB[1]) ** 2 + (pA[2] - pB[2]) ** 2)
                Llist.append(checkDistance)
                totalEdgeLoopLength = totalEdgeLoopLength + checkDistance
            totalLenGrp.append(totalEdgeLoopLength)
            goEven = cmds.checkBox('evenCurveEdgeLength', q=1, v=1)
            if goEven == 1:
                avg = totalEdgeLoopLength / len(e)
                for j in range(len(e)):
                    sum = (j + 1) * avg
                    uList.append(sum)
            else:
                for j in Llist:
                    sum = sum + j
                    uList.append(sum)

            ulistGrp.append(uList)
            for k in uList:
                p = k / totalEdgeLoopLength * sectionNumber
                pList.append(p)

            for q in range(len(pList) - 1):
                pp = cmds.pointOnCurve(curveName[0], pr=pList[q], p=1)
                cmds.move(pp[0], pp[1], pp[2], listVtx[q + 1], a=True, ws=True)
            backupCurve = cmds.duplicate(curveName[0])
            p1A = cmds.pointPosition(listVtx[1], w=1)
            p2A = cmds.pointPosition(listVtx[-2], w=1)
            mid1x = (p1A[0] - p1[0]) / 2 + p1[0]
            mid1y = (p1A[1] - p1[1]) / 2 + p1[1]
            mid1z = (p1A[2] - p1[2]) / 2 + p1[2]
            mid2x = (p2A[0] - p2[0]) / 2 + p2[0]
            mid2y = (p2A[1] - p2[1]) / 2 + p2[1]
            mid2z = (p2A[2] - p2[2]) / 2 + p2[2]
            positionListA.insert(1, [mid1x, mid1y, mid1z])
            positionListA.insert(len(positionListA) - 1, [mid2x, mid2y, mid2z])
            for x in range(len(positionListA)):
                cmds.move(positionListA[x][0], positionListA[x][1], positionListA[x][2], backupCurve[0] + '.cv[' + str(x) + ']', a=1)
            blendName = cmds.blendShape(backupCurve[0], curveName[0], w=[(0, 1)], en=0)
            blendNodeList.append(blendName[0])
        meshName = selEdge[0].split('.')[0]
        cmd = 'doMenuNURBComponentSelection("' + meshName + '", "edge");'
        mel.eval(cmd)
        cmds.select(selEdge)
        ctx = 'unBevelCtx'
        if cmds.draggerContext(ctx, exists=True):
            cmds.deleteUI(ctx)
        cmds.draggerContext(ctx, pressCommand=XO2, rc=X26, dragCommand=X38, fnz=X74, name=ctx, cursor='crossHair', undoMode='step')
        cmds.setToolTo(ctx)
def X74():
    cmds.setToolTo('selectSuperContext')
    cleanList = ('makeTwoPointCircularAr*','*Semi*')
    for c in cleanList:
        if cmds.objExists(c):
            cmds.delete(c)
def X26():
    cmds.setToolTo('selectSuperContext')
    cleanList = ('makeTwoPointCircularAr*','*Semi*')
    for c in cleanList:
        if cmds.objExists(c):
            cmds.delete(c)
def XO2():
    global currentRotRecord
    global currentEnRecord
    global screenX
    global screenY
    currentRotRecord = 0
    currentEnRecord = 0
    vpX, vpY, _ = cmds.draggerContext(ctx, query=True, anchorPoint=True)
    screenX = vpX
    screenY = vpY
    t = radiusGrp[0] / radiusBestFitGrp[0]
    screenX = (vpX + t) / 1.9
def X38():
    global currentRotRecord
    global currentEnRecord
    modifiers = cmds.getModifiers()
    vpX, vpY, _ = cmds.draggerContext(ctx, query=True, dragPoint=True)
    distanceA = (vpX - screenX) / 100
    t = distanceA
    fu = 1 / (1 + t ** 5 / 100)
    if modifiers == 4:
        for c in curveGrp:
            cmds.setAttr(c + '.rotateX', 0)
    elif modifiers == 1:
        rotateRun = cmds.getAttr(curveGrp[0] + '.rotateX')
        if currentRotRecord > vpX:
            rotateRun = rotateRun + 2
        else:
            rotateRun = rotateRun - 2
        for c in curveGrp:
            cmds.setAttr(c + '.rotateX', rotateRun)
        currentRotRecord = vpX
    elif modifiers == 8:
        evRun = cmds.getAttr(blendNodeList[0] + '.envelope')
        if currentEnRecord > vpX:
            evRun = evRun + 0.05
        else:
            evRun = evRun - 0.05
        if evRun > 1:
            evRun = 1
        elif evRun < 0:
            evRun = 0
        for f in blendNodeList:
            cmds.setAttr(f + '.envelope', evRun)
        currentEnRecord = vpX
    else:
        for f in blendNodeList:
            cmds.setAttr(f + '.envelope', 0)

        for a in range(len(arcGrp)):
            newR = radiusGrp[a] * (1 + fu * 5)
            cmds.setAttr(arcGrp[a] + '.radius', newR)
    for i in range(len(arcGrp)):
        pList = []
        uList = ulistGrp[i]
        for k in uList:
            p = k / totalLenGrp[i] * sectionNumber
            pList.append(p)
        listVtx = listVtxFGrp[i]
        for q in range(len(pList) - 1):
            pp = cmds.pointOnCurve(curveGrp[i], pr=pList[q], p=1)
            cmds.move(pp[0], pp[1], pp[2], listVtx[q + 1], a=True, ws=True)
    cmds.refresh(f=True)
def X7l():
    global selEdge
    global selMeshForDeformer
    global ctx
    selEdge = cmds.filterExpand(expand=True, sm=32)
    currentDropOff = 1
    snapCheck = 1
    goEven = cmds.checkBox('evenCurveEdgeLength', q=1, v=1)
    conP = 2
    curveT = 1
    goArc = 1
    selMeshForDeformer = cmds.ls(sl=1, o=1)
    getCircleState, listVtx = Xll()
    deformerNames = []
    midP = int(len(listVtx) / 2)
    cmds.move(0.01, 0, 0, selEdge[midP], r=1, cs=1, ls=1, wd=1)
    p1 = cmds.pointPosition(listVtx[0], w=1)
    p2 = cmds.pointPosition(listVtx[midP], w=1)
    p3 = cmds.pointPosition(listVtx[-1], w=1)
    newNode = cmds.createNode('makeThreePointCircularArc')
    cmds.setAttr(newNode + '.pt1', p1[0], p1[1], p1[2])
    cmds.setAttr(newNode + '.pt2', p2[0], p2[1], p2[2])
    cmds.setAttr(newNode + '.pt3', p3[0], p3[1], p3[2])
    cmds.setAttr(newNode + '.d', 3)
    cmds.setAttr(newNode + '.s', len(listVtx))
    newCurve = cmds.createNode('nurbsCurve')
    cmds.connectAttr(newNode + '.oc', newCurve + '.cr')
    cmds.delete(ch=1)
    transformNode = cmds.listRelatives(newCurve, fullPath=True, parent=True)
    cmds.rename(transformNode, 'arcCurve')
    numberP = 0
    numberP = int(conP) - 1
    cmds.rebuildCurve('arcCurve', ch=1, rpo=1, rt=0, end=1, kr=0, kcp=0, kep=1, kt=0, s=numberP, d=3, tol=0.01)
    cmds.delete('arcCurve', ch=1)
    totalEdgeLoopLength = 0
    sum = 0
    Llist = []
    uList = []
    pList = []
    for i in selEdge:
        e2v = cmds.polyListComponentConversion(i, fe=1, tv=1)
        e2v = cmds.ls(e2v, fl=1)
        pA = cmds.pointPosition(e2v[0], w=1)
        pB = cmds.pointPosition(e2v[1], w=1)
        checkDistance = math.sqrt((pA[0] - pB[0]) ** 2 + (pA[1] - pB[1]) ** 2 + (pA[2] - pB[2]) ** 2)
        Llist.append(checkDistance)
        totalEdgeLoopLength = totalEdgeLoopLength + checkDistance
    if goEven == 1:
        avg = totalEdgeLoopLength / len(selEdge)
        for j in range(len(selEdge)):
            sum = (j + 1) * avg
            uList.append(sum)
    else:
        for j in Llist:
            sum = sum + j
            uList.append(sum)
    for k in uList:
        p = k / totalEdgeLoopLength
        pList.append(p)
    for q in range(len(pList)):
        if q + 1 == len(listVtx):
            pp = cmds.pointOnCurve('arcCurve', pr=0, p=1)
            cmds.move(pp[0], pp[1], pp[2], listVtx[0], a=True, ws=True)
        else:
            pp = cmds.pointOnCurve('arcCurve', pr=pList[q], p=1)
            cmds.move(pp[0], pp[1], pp[2], listVtx[q + 1], a=True, ws=True)
    cmds.delete('arcCurve', ch=1)
    cmds.select('arcCurve')
    cmds.nurbsCurveToBezier()
    try:
        deformerNames = cmds.wire(selMeshForDeformer, gw=0, en=1, ce=0, li=0, w='arcCurve', uct=0)
    except:
        deformerNames = cmds.wire(selMeshForDeformer, gw=0, en=1, ce=0, li=0, w='arcCurve')
    cmds.setAttr(deformerNames[0] + '.dropoffDistance[0]', 0.1)
    cA = cmds.pointPosition('arcCurve.cv[0]', w=1)
    cD = cmds.pointPosition('arcCurve.cv[3]', w=1)
    try:
        cmds.select('arcCurve.cv[1]')
        cmds.cluster(useComponentTags=0)
        checkSel = cmds.ls(sl=1)
        cmds.rename(checkSel[0], 'ccBHandle')
    except:
        cmds.cluster('arcCurve.cv[1]', name='ccB')

    cmds.move(cA[0], cA[1], cA[2], 'ccBHandle.scalePivot', 'ccBHandle.rotatePivot', a=True, ws=True)
    try:
        cmds.select('arcCurve.cv[2]')
        cmds.cluster(useComponentTags=0)
        checkSel = cmds.ls(sl=1)
        cmds.rename(checkSel[0], 'ccCHandle')
    except:
        cmds.cluster('arcCurve.cv[2]', name='ccC')
    cmds.move(cD[0], cD[1], cD[2], 'ccCHandle.scalePivot', 'ccCHandle.rotatePivot', a=True, ws=True)
    cmds.setAttr('arcCurve.visibility', 0)
    cmds.setAttr('ccBHandle.visibility', 0)
    cmds.setAttr('ccCHandle.visibility', 0)
    meshName = selEdge[0].split('.')[0]
    cmd = 'doMenuNURBComponentSelection("' + meshName + '", "edge");'
    mel.eval(cmd)
    cmds.select(selEdge)
    hideList = ['arcCurve','arcCurveBaseWire','ccBHandle','ccCHandle']
    for h in hideList:
        cmds.setAttr((h + '.hiddenInOutliner'), 1)
    ctx = 'tensionCtx'
    if cmds.draggerContext(ctx, exists=True):
        cmds.deleteUI(ctx)
    cmds.draggerContext(ctx, pressCommand=X22, rc=X96, dragCommand=XO6, fnz=X33, name=ctx, cursor='crossHair', undoMode='step')
    cmds.setToolTo(ctx)
def X33():
    cmds.delete(selMeshForDeformer, ch=1)
    cmds.setToolTo('selectSuperContext')
    cleanList = ('arc*','cc*Handl*')
    for c in cleanList:
        if cmds.objExists(c):
            cmds.delete(c)
def X96():
    pass
def X22():
    global screenX
    vpX, vpY, _ = cmds.draggerContext(ctx, query=True, anchorPoint=True)
    screenX = vpX
def XO6():
    modifiers = cmds.getModifiers()
    vpX, vpY, _ = cmds.draggerContext(ctx, query=True, dragPoint=True)
    distanceA = (screenX - vpX) / 100
    t = 1 + distanceA
    if modifiers == 4:
        cmds.setAttr('ccBHandle.scaleX', t)
        cmds.setAttr('ccBHandle.scaleY', t)
        cmds.setAttr('ccBHandle.scaleZ', t)
    elif modifiers == 1:
        cmds.setAttr('ccCHandle.scaleX', t)
        cmds.setAttr('ccCHandle.scaleY', t)
        cmds.setAttr('ccCHandle.scaleZ', t)
    elif modifiers == 8:
        cmds.setAttr('ccBHandle.scaleX', 1)
        cmds.setAttr('ccBHandle.scaleY', 1)
        cmds.setAttr('ccBHandle.scaleZ', 1)
        cmds.setAttr('ccCHandle.scaleX', 1)
        cmds.setAttr('ccCHandle.scaleY', 1)
        cmds.setAttr('ccCHandle.scaleZ', 1)
    else:
        cmds.setAttr('ccBHandle.scaleX', t)
        cmds.setAttr('ccBHandle.scaleY', t)
        cmds.setAttr('ccBHandle.scaleZ', t)
        cmds.setAttr('ccCHandle.scaleX', t)
        cmds.setAttr('ccCHandle.scaleY', t)
        cmds.setAttr('ccCHandle.scaleZ', t)
    cmds.refresh(f=True)
def X8O():
    global vLData
    global cLData
    global ctx
    global ppData
    checCurrentkHUD = cmds.headsUpDisplay(lh=1)
    if checCurrentkHUD is not None:
        for t in checCurrentkHUD:
            cmds.headsUpDisplay(t, rem=1)
    ppData = []
    vLData = []
    cLData = []
    selEdge = cmds.filterExpand(expand=True, sm=32)
    if selEdge:
        if cmds.objExists('saveSel'):
            cmds.delete('saveSel')
        cmds.sets(name='saveSel', text='saveSel')
        sortGrp = X69()
        for e in sortGrp:
            pPoint, vList, cList = X35(e)
            ppData.append(pPoint)
            vLData.append(vList)
            cLData.append(cList)

        cmds.select(selEdge)
        ctx = 'unBevelCtx'
        if cmds.draggerContext(ctx, exists=True):
            cmds.deleteUI(ctx)
        cmds.draggerContext(ctx, pressCommand=X28, rc=Xo8, dragCommand=Xl7, name=ctx, cursor='crossHair', undoMode='step')
        cmds.setToolTo(ctx)
    return
def Xo8():
    cmds.headsUpDisplay('HUDunBevelStep', rem=True)
    flattenList = []
    for v in vLData:
        for x in range(len(v)):
            flattenList.append(v[x])
    cmds.polyMergeVertex(flattenList, d=0.001, am=0, ch=0)
    cmds.select('saveSel')
    meshName = flattenList[0].split('.')[0]
    cmd = 'doMenuNURBComponentSelection("' + meshName + '", "edge");'
    mel.eval(cmd)
    cmds.setToolTo('selectSuperContext')
    if cmds.objExists('saveSel'):
        cmds.delete('saveSel')
def X53():
    if viewPortCount >= 1:
        getPercent = viewPortCount / 100.0
    elif viewPortCount < 1 and viewPortCount > 0:
        getPercent = 0.1
    elif viewPortCount == 0:
        getPercent = 0
    getNumber = '%.2f' % getPercent
    return getNumber
def X28():
    global storeCount
    global screenX
    global screenY
    global viewPortCount
    global lockCount
    viewPortCount = 0
    lockCount = 50
    storeCount = 0
    vpX, vpY, _ = cmds.draggerContext(ctx, query=True, anchorPoint=True)
    screenX = vpX
    screenY = vpY
    lockX = vpX
    cmds.headsUpDisplay('HUDunBevelStep', section=1, block=0, blockSize='large', label='unBevel', labelFontSize='large', command=X53, atr=1)
def Xl7():
    global storeCount
    global screenX
    global viewPortCount
    global lockCount
    movePN = 0
    modifiers = cmds.getModifiers()
    vpX, vpY, _ = cmds.draggerContext(ctx, query=True, dragPoint=True)
    if modifiers == 1:
        for i in range(len(ppData)):
            cmds.scale(0, 0, 0, vLData[i], cs=1, r=1, p=(ppData[i][0], ppData[i][1], ppData[i][2]))
        viewPortCount = 0
    elif modifiers == 8:
        if screenX > vpX:
            lockCount = lockCount - 1
        else:
            lockCount = lockCount + 1
        screenX = vpX
        if lockCount > 0:
            getX = int(lockCount / 10) * 10
            if storeCount != getX:
                storeCount = getX
                for i in range(len(ppData)):
                    for v in range(len(vLData[i])):
                        moveX = ppData[i][0] - cLData[i][v][0] * lockCount
                        moveY = ppData[i][1] - cLData[i][v][1] * lockCount
                        moveZ = ppData[i][2] - cLData[i][v][2] * lockCount
                        cmds.move(moveX, moveY, moveZ, vLData[i][v], absolute=1, ws=1)
            viewPortCount = storeCount
        else:
            viewPortCount = 0.1
    else:
        if screenX > vpX:
            lockCount = lockCount - 5
        else:
            lockCount = lockCount + 5
        screenX = vpX
        if lockCount > 0:
            for i in range(len(ppData)):
                for v in range(len(vLData[i])):
                    moveX = ppData[i][0] - cLData[i][v][0] * lockCount
                    moveY = ppData[i][1] - cLData[i][v][1] * lockCount
                    moveZ = ppData[i][2] - cLData[i][v][2] * lockCount
                    cmds.move(moveX, moveY, moveZ, vLData[i][v], absolute=1, ws=1)
            viewPortCount = lockCount
        else:
            viewPortCount = 0.1
    cmds.refresh(f=True)

def XI5():
    selEdge = cmds.filterExpand(expand=True, sm=32)
    if selEdge:
        if cmds.objExists('saveSel'):
            cmds.delete('saveSel')
        cmds.sets(name='saveSel', text='saveSel')
        sortGrp = X69()
        for e in sortGrp:
            X35(e)
        cmds.select(selEdge)
        cmds.ConvertSelectionToVertices()
        cmds.polyMergeVertex(d=0.001, am=0, ch=1)
        cmds.select('saveSel')
        cmds.delete('saveSel')

def X35(edgelist):
    listVtx = X8I(edgelist)
    checkA = X79(listVtx[1], listVtx[0], listVtx[-1])
    angleA = math.degrees(checkA)
    checkB = X79(listVtx[-2], listVtx[-1], listVtx[0])
    angleB = math.degrees(checkB)
    angleC = 180 - angleA - angleB
    distanceC = X3o(listVtx[0], listVtx[-1])
    distanceA = distanceC / math.sin(math.radians(angleC)) * math.sin(math.radians(angleA))
    distanceB = distanceC / math.sin(math.radians(angleC)) * math.sin(math.radians(angleB))
    oldDistA = X3o(listVtx[-2], listVtx[-1])
    oldDistB = X3o(listVtx[0], listVtx[1])
    scalarB = distanceB / oldDistB
    pA = cmds.pointPosition(listVtx[0], w=1)
    pB = cmds.pointPosition(listVtx[1], w=1)
    newP = [0, 0, 0]
    newP[0] = (pB[0] - pA[0]) * scalarB + pA[0]
    newP[1] = (pB[1] - pA[1]) * scalarB + pA[1]
    newP[2] = (pB[2] - pA[2]) * scalarB + pA[2]
    listVtx = listVtx[1:-1]
    storeDist = []
    for l in listVtx:
        sotreXYZ = [0, 0, 0]
        p = cmds.xform(l, q=True, t=True, ws=True)
        sotreXYZ[0] = (newP[0] - p[0]) / 100
        sotreXYZ[1] = (newP[1] - p[1]) / 100
        sotreXYZ[2] = (newP[2] - p[2]) / 100
        storeDist.append(sotreXYZ)
    return (newP, listVtx, storeDist)
def X84():
    goEven = cmds.checkBox('evenRoundEdgeLength', q=1, v=1)
    edgeLoopSel = cmds.ls(sl=1,fl=1)
    sortGrp = X69()
    for e in sortGrp:
        check = []
        check.append(e[0])
        check.append(e[-1])
        e2v = cmds.ls(cmds.polyListComponentConversion(check,tv=1),fl=1)
        if len(e2v) != 3:
            XI7(e)
            if goEven == 1:
                Xo7(e)
                XI7(e)
    meshName = edgeLoopSel[0].split('.')[0]
    cmd = 'doMenuNURBComponentSelection("' + meshName + '", "edge");'
    mel.eval(cmd)
    cmds.select(edgeLoopSel)
def XI7(flatList):
    cleanList = ('newCircleGuid*','tempGuid*','arcCurv*','upperLo*','aimLo*','tempCircleGuide*','baseLo*')
    for c in cleanList:
        if cmds.objExists(c):
            cmds.delete(c)
    edgeSel = flatList
    listVtx = X8I(edgeSel)
    pointA = listVtx[0]
    pointB = listVtx[-1]
    xA, yA, zA = cmds.pointPosition(pointA, w=1)
    xB, yB, zB = cmds.pointPosition(pointB , w=1)
    avgX = 0
    avgY = 0
    avgZ = 0
    for i in range(1, len(listVtx)-1):
        xP, yP, zP = cmds.pointPosition(listVtx[i], w=1)
        avgX = avgX + xP
        avgY = avgY + yP
        avgZ = avgZ + zP
    xMid = avgX / (len(listVtx)-2)
    yMid = avgY / (len(listVtx)-2)
    zMid = avgZ / (len(listVtx)-2)
    distanceBetween = math.sqrt((xA - xB) * (xA - xB) + (yA - yB) * (yA - yB) + (zA - zB) * (zA - zB))
    circleR = distanceBetween / math.sqrt( 2 )
    cmds.circle( nr=(0, 0 ,circleR), c=(0, 0, 0),r= circleR,n='tempCircleGuideA')
    cmds.spaceLocator(n='upperLoc')
    cmds.spaceLocator(n='aimLoc')
    cmds.spaceLocator(n='baseLoc')
    cmds.select('upperLoc','aimLoc','baseLoc')
    cmds.CenterPivot()
    cmds.setAttr(('upperLoc.scale'),0.01,0.01,0.01)
    cmds.setAttr(('aimLoc.scale'),0.01,0.01,0.01)
    cmds.setAttr(('aimLoc.translate'),0, 1,-1)
    cmds.setAttr(('upperLoc.translate'),0, 1,1)
    consNode = cmds.aimConstraint('aimLoc','baseLoc',offset=[0,0,0], weight=1, aimVector=[1,0,0], upVector=[0,1,0], worldUpType='object', worldUpObject='upperLoc')
    cmds.setAttr(('baseLoc.translate'),xA, yA, zA)
    cmds.setAttr(('aimLoc.translate'),xB, yB, zB )
    cmds.setAttr(('upperLoc.translate'),xMid,yMid,zMid)
    cmds.select('tempCircleGuideA','baseLoc')
    cmds.matchTransform()
    cmds.duplicate('tempCircleGuideA',smartTransform=1,n='newCircleGuide')
    cmds.setAttr(('newCircleGuide.translate'),xB, yB, zB)
    intersectC = cmds.curveIntersect('tempCircleGuideA','newCircleGuide')
    sPosX, sPosY,sPosZ = cmds.pointOnCurve('tempCircleGuideA' , pr = float(intersectC[0]), p=1)
    cPosX, cPosY,cPosZ = cmds.pointOnCurve('tempCircleGuideA' , pr = float(intersectC[2]), p=1)
    distA = math.sqrt((xMid - sPosX) * (xMid - sPosX) + (yMid - sPosY) * (yMid - sPosY) + (zMid - sPosZ) * (zMid - sPosZ))
    distB = math.sqrt((xMid - cPosX) * (xMid - cPosX) + (yMid - cPosY) * (yMid - cPosY) + (zMid - cPosZ) * (zMid - cPosZ))
    newCenter = []
    if distA > distB:
        newCenter = [sPosX, sPosY,sPosZ ]
    else:
        newCenter = [cPosX, cPosY,cPosZ ]
    cmds.setAttr(('newCircleGuide.translate'),newCenter[0], newCenter[1], newCenter[2])
    cmds.makeIdentity('newCircleGuide', apply=1, t=1,r=1,s=1)
    selectionList = om.MSelectionList()
    selectionList.add('newCircleGuide')
    dagPath = om.MDagPath()
    selectionList.getDagPath(0, dagPath)
    omCurveOut = om.MFnNurbsCurve(dagPath)
    for m in range(1,len(listVtx)) :
        xK, yK, zK = cmds.pointPosition(listVtx[m], w=1)
        pointInSpace = om.MPoint(xK,yK,zK)
        closestPoint = om.MPoint()
        closestPoint = omCurveOut.closestPoint(pointInSpace)
        cmds.move(closestPoint[0], closestPoint[1], closestPoint[2], listVtx[m] , a =True, ws=True)
    cleanList = ('newCircleGuid*','tempGuid*','arcCurv*','upperLo*','aimLo*','tempCircleGuide*','baseLo*')
    for c in cleanList:
        if cmds.objExists(c):
            cmds.delete(c)
def Xo9():
    goEven = cmds.checkBox('evenRoundEdgeLength', q=1, v=1)
    edgeLoopSel = cmds.ls(sl=1,fl=1)
    sortGrp = X69()
    for e in sortGrp:
        check = []
        check.append(e[0])
        check.append(e[-1])
        e2v = cmds.ls(cmds.polyListComponentConversion(check,tv=1),fl=1)
        if len(e2v) != 3:
            X2o(e)
            if goEven == 1:
                Xo7(e)
                X2o(e)
    meshName = edgeLoopSel[0].split('.')[0]
    cmd = 'doMenuNURBComponentSelection("' + meshName + '", "edge");'
    mel.eval(cmd)
    cmds.select(edgeLoopSel)
def X2o(flatList):
    cleanList = ('newCircleGuid*','tempGuid*','arcCurv*','upperLo*','aimLo*','tempCircleGuide*','baseLo*')
    for c in cleanList:
        if cmds.objExists(c):
            cmds.delete(c)
    listVtx = X8I(flatList)
    pointA = listVtx[0]
    pointB = listVtx[-1]
    xA, yA, zA = cmds.pointPosition(pointA, w=1)
    xB, yB, zB = cmds.pointPosition(pointB , w=1)
    avgX = 0
    avgY = 0
    avgZ = 0
    for i in range(1, len(listVtx)-1):
        xP, yP, zP = cmds.pointPosition(listVtx[i], w=1)
        avgX = avgX + xP
        avgY = avgY + yP
        avgZ = avgZ + zP
    xMid = avgX / (len(listVtx)-2)
    yMid = avgY / (len(listVtx)-2)
    zMid = avgZ / (len(listVtx)-2)
    distanceBetween = math.sqrt((xA - xB) * (xA - xB) + (yA - yB) * (yA - yB) + (zA - zB) * (zA - zB))
    circleR = distanceBetween / 2
    cmds.circle( nr=(0, 0 ,circleR), c=(0, 0, 0),r= circleR,n='newCircleGuide')
    cmds.spaceLocator(n='upperLoc')
    cmds.spaceLocator(n='aimLoc')
    cmds.spaceLocator(n='baseLoc')
    cmds.select('upperLoc','aimLoc','baseLoc')
    cmds.CenterPivot()
    cmds.setAttr(('upperLoc.scale'),0.01,0.01,0.01)
    cmds.setAttr(('aimLoc.scale'),0.01,0.01,0.01)
    cmds.setAttr(('aimLoc.translate'),0, 1,-1)
    cmds.setAttr(('upperLoc.translate'),0, 1,1)
    consNode = cmds.aimConstraint('aimLoc','baseLoc',offset=[0,0,0], weight=1, aimVector=[1,0,0], upVector=[0,1,0], worldUpType='object', worldUpObject='upperLoc')
    cmds.setAttr(('baseLoc.translate'),xA, yA, zA)
    cmds.setAttr(('aimLoc.translate'),xB, yB, zB )
    cmds.setAttr(('upperLoc.translate'),xMid,yMid,zMid)
    cmds.select('newCircleGuide','baseLoc')
    cmds.matchTransform()
    xC = (xA - xB)/2 + xB
    yC = (yA - yB)/2 + yB
    zC = (zA - zB)/2 + zB
    cmds.setAttr(('newCircleGuide.translate'),xC, yC, zC)
    cmds.makeIdentity('newCircleGuide', apply=1, t=1,r=1,s=1)
    selectionList = om.MSelectionList()
    selectionList.add('newCircleGuide')
    dagPath = om.MDagPath()
    selectionList.getDagPath(0, dagPath)
    omCurveOut = om.MFnNurbsCurve(dagPath)
    for m in range(1,len(listVtx)) :
        xK, yK, zK = cmds.pointPosition(listVtx[m], w=1)
        pointInSpace = om.MPoint(xK,yK,zK)
        closestPoint = om.MPoint()
        closestPoint = omCurveOut.closestPoint(pointInSpace)
        cmds.move(closestPoint[0], closestPoint[1], closestPoint[2], listVtx[m] , a =True, ws=True)
    cleanList = ('newCircleGuid*','tempGuid*','arcCurv*','upperLo*','aimLo*','tempCircleGuide*','baseLo*')
    for c in cleanList:
        if cmds.objExists(c):
            cmds.delete(c)
def X5I():
    checkEven = cmds.checkBox('evenRoundEdgeLength', q=1,v=1)
    pivotSnapSwitch = cmds.checkBox('evenRoundPivotSnap', q=1,v=1)
    getFaceList = cmds.filterExpand(ex=1, sm=34)
    if getFaceList:
        cmds.ConvertSelectionToEdgePerimeter()
    edgeLoopSel = cmds.ls(sl=1,fl=1)
    cmds.polyCircularizeEdge(constructionHistory=0, alignment=0, radialOffset=0, normalOffset=0, normalOrientation=0, smoothingAngle=30, evenlyDistribute = checkEven, divisions=0, supportingEdges=0, twist=0, relaxInterior=1)
    sortGrp = X69()
    meshName = edgeLoopSel[0].split('.')[0]
    cmds.delete(meshName,ch =1)
    if pivotSnapSwitch == 1:
        if len(sortGrp) > 1:
            X2O()
def X2O():
    pivotSnapTypeCheck = cmds.radioButtonGrp('PivotSnapType', q=1,sl=1)
    cleanList = ('baseCircleCurv*','tempCenterCurve*','xxxx','tempCircleCenterLin*','upperLo*','aimLo*','baseLo*')
    for c in cleanList:
        if cmds.objExists(c):
            cmds.delete(c)
    baseLoopNumber = 0
    edgeLoopSel = cmds.ls(sl=1,fl=1)
    sortGrp = X69()
    curveList = []
    targetLoop = ''
    vCheck = 10000000
    if pivotSnapTypeCheck == 2:
        vCheck = 0
    for e in sortGrp:
        bbox =cmds.xform(e, q=1, ws=1, bb=1)
        xSide = (bbox[3]-bbox[0])*(bbox[4]-bbox[1])
        ySide = (bbox[5]-bbox[2])*(bbox[3]-bbox[0])
        zSide = (bbox[4]-bbox[1])*(bbox[5]-bbox[2])
        if xSide == 0:
            xSide = 1
        if ySide == 0:
            ySide = 1
        if zSide == 0:
            zSide = 1
        bboxV =  math.sqrt(xSide*ySide*zSide)
        if pivotSnapTypeCheck == 1:
            if bboxV < vCheck:
                vCheck = bboxV
                targetLoop = e
        else:
            if bboxV > vCheck:
                vCheck = bboxV
                targetLoop = e
    cmds.select(targetLoop)
    cirvleNode = cmds.polyToCurve(ch=0,form=2, degree=1, conformToSmoothMeshPreview=1,n='baseCircleCurve')
    cmds.CenterPivot()
    cmds.select(targetLoop)
    cmds.ConvertSelectionToVertices()
    edgeSel = cmds.ls(sl=1,fl=1)
    baseLoopNumber = len(edgeSel)
    pointA = edgeSel[0]
    pointB = edgeSel[-1]
    pointC = edgeSel[int(len(edgeSel)/2)]
    xA, yA, zA = cmds.pointPosition(pointA, w=1)
    xB, yB, zB = cmds.pointPosition(pointB , w=1)
    xC, yC, zC = cmds.pointPosition(pointC , w=1)
    cmds.spaceLocator(n='upperLoc')
    cmds.spaceLocator(n='aimLoc')
    cmds.spaceLocator(n='baseLoc')
    cmds.select('upperLoc','aimLoc','baseLoc')
    cmds.CenterPivot()
    cmds.setAttr(('upperLoc.scale'),0.01,0.01,0.01)
    cmds.setAttr(('aimLoc.scale'),0.01,0.01,0.01)
    cmds.setAttr(('aimLoc.translate'),0, 1,-1)
    cmds.setAttr(('upperLoc.translate'),0, 1,1)
    consNode = cmds.aimConstraint('aimLoc','baseLoc',offset=[0,0,0], weight=1, aimVector=[1,0,0], upVector=[0,1,0], worldUpType='object', worldUpObject='upperLoc')
    cmds.setAttr(('baseLoc.translate'),xA, yA, zA)
    cmds.setAttr(('aimLoc.translate'),xB, yB, zB )
    cmds.setAttr(('upperLoc.translate'),xC, yC, zC)
    cmds.curve(d=1, p=[(0,0,0),(0,0,-10)], k=[0,1],name = 'tempCircleCenterLine')
    cmds.CenterPivot()
    cmds.select('tempCircleCenterLine','baseLoc')
    cmds.matchTransform(rot=1)
    cmds.select('tempCircleCenterLine','baseCircleCurve')
    cmds.matchTransform(pos=1)
    cmds.makeIdentity('tempCircleCenterLine', apply=1, t=1,r=1,s=1)
    selectionList = om.MSelectionList()
    selectionList.add('tempCircleCenterLine')
    dagPath = om.MDagPath()
    selectionList.getDagPath(0, dagPath)
    omCurveOut = om.MFnNurbsCurve(dagPath)
    matchList =  list(set(edgeLoopSel)-set(targetLoop))
    cmds.select(matchList)
    sortGrp = X69()
    cmds.spaceLocator(n='xxxx')
    meshName = edgeLoopSel[0].split('.')[0]
    for e in sortGrp:
        cmds.select(e)
        cirvleNode = cmds.polyToCurve(ch=0,form=2, degree=1, conformToSmoothMeshPreview=1,name='tempCenterCurve01')
        cmds.CenterPivot()
        cmds.select('baseCircleCurve',cirvleNode[0])
        cmds.matchTransform()
        cmds.makeIdentity('baseCircleCurve', apply=1, t=1,r=1,s=1)
        baseLength = cmds.arclen( 'baseCircleCurve' )
        targetLength = cmds.arclen( cirvleNode[0] )
        scaleV = targetLength / baseLength
        cmds.setAttr(('baseCircleCurve.scale'),scaleV,scaleV,scaleV)
        compareCVList = cmds.ls(('baseCircleCurve.cv[*]'),fl=1)
        bboxPiv =cmds.xform('baseCircleCurve', q=1, ws=1, piv=1)
        pointInSpace = om.MPoint(bboxPiv[0],bboxPiv[1],bboxPiv[2])
        closestPoint = om.MPoint()
        closestPoint = omCurveOut.closestPoint(pointInSpace)
        cmds.move(closestPoint[0], closestPoint[1], closestPoint[2], 'xxxx', a =True, ws=True)
        cmds.select('baseCircleCurve','xxxx')
        cmds.matchTransform(pos=1)
        cmds.select(e)
        cmds.ConvertSelectionToVertices()
        listVtx = cmds.ls(sl=1,fl=1)
        cmds.setToolTo('moveSuperContext')
        centerP = cmds.manipMoveContext("Move", q=1,p=1)
        nodeCluster = cmds.cluster(n= 'centerGrp')
        pointInSpace = om.MPoint(centerP[0],centerP[1],centerP[2])
        closestPoint = om.MPoint()
        closestPoint = omCurveOut.closestPoint(pointInSpace)
        cmds.move(closestPoint[0], closestPoint[1], closestPoint[2], nodeCluster[1], rpr=1)
        cmds.delete(meshName,ch =1)
        if baseLoopNumber == len(listVtx):
            for m in listVtx :
                xK, yK, zK = cmds.pointPosition(m, w=1)
                checkDist = 100000
                getCV = []
                toRemove = ''
                for c in compareCVList:
                    xN, yN, zN = cmds.pointPosition(c, w=1)
                    dist = math.sqrt((xK - xN) * (xK - xN) + (yK - yN) * (yK - yN) + (zK - zN) * (zK - zN))
                    if dist < checkDist:
                        checkDist = dist
                        getCV = [xN,yN,zN]
                        toRemove = c
                cmds.move( getCV[0], getCV[1], getCV[2], m , a =True, ws=True)
    cmd = 'doMenuNURBComponentSelection("' + meshName + '", "edge");'
    mel.eval(cmd)
    cmds.select(edgeLoopSel)
    cleanList = ('baseCircleCurv*','tempCenterCurve*','xxxx','tempCircleCenterLin*','upperLo*','aimLo*','baseLo*')
    for c in cleanList:
        if cmds.objExists(c):
            cmds.delete(c)
def Xo2():
    goEven = cmds.checkBox('evenCurveEdgeLength', q=1, v=1)
    edgeLoopSel = cmds.ls(sl=1,fl=1)
    sortGrp = X69()
    for e in sortGrp:
        X42(e)
        if goEven == 1:
            Xo7(e)
    meshName = edgeLoopSel[0].split('.')[0]
    cmd = 'doMenuNURBComponentSelection("' + meshName + '", "edge");'
    mel.eval(cmd)
    cmds.select(edgeLoopSel)
def X42(flatList):
    if cmds.objExists('tempCenterLin*'):
        cmds.delete('tempCenterLin*')
    edgeSel = flatList
    listVtx = X8I(edgeSel)
    xA, yA, zA = cmds.pointPosition(listVtx[0], w=1)
    xB, yB, zB = cmds.pointPosition(listVtx[-1], w=1)
    cmds.curve(d=1, p=[(xA, yA, zA),(xB, yB, zB)], k=[0,1],name = 'tempCenterLine')
    selectionList = om.MSelectionList()
    selectionList.add('tempCenterLine')
    dagPath = om.MDagPath()
    selectionList.getDagPath(0, dagPath)
    omCurveOut = om.MFnNurbsCurve(dagPath)
    for m in listVtx :
        xK, yK, zK = cmds.pointPosition(m, w=1)
        pointInSpace = om.MPoint(xK,yK,zK)
        closestPoint = om.MPoint()
        closestPoint = omCurveOut.closestPoint(pointInSpace)
        cmds.move( closestPoint[0], closestPoint[1], closestPoint[2],m, a =True, ws=True)
    if cmds.objExists('tempCenterLin*'):
        cmds.delete('tempCenterLin*')
def XO7():
    edgeLoopSel = cmds.ls(sl=1,fl=1)
    sortGrp = X69()
    for e in sortGrp:
        check = []
        check.append(e[0])
        check.append(e[-1])
        e2v = cmds.ls(cmds.polyListComponentConversion(check,tv=1),fl=1)
        if len(e2v) != 3:
            Xo7(e)
    meshName = edgeLoopSel[0].split('.')[0]
    cmd = 'doMenuNURBComponentSelection("' + meshName + '", "edge");'
    mel.eval(cmd)
    cmds.select(edgeLoopSel)
def X8I(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 XlO(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

def Xll():
    selEdges = cmds.ls(sl=1, fl=1)
    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)
    checkCircleState = 0
    if not getHeadTail:
        checkCircleState = 1
        getHeadTail.append(getNumber[0])
    vftOrder = []
    vftOrder.append(getHeadTail[0])
    count = 0
    while len(dup) > 0 and count < 1000:
        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
        dup.remove(gotNextVtx)
        vftOrder.append(gotNextVtx)
        count += 1
    if checkCircleState == 0:
        vftOrder.append(getHeadTail[1])
    elif vftOrder[0] == vftOrder[1]:
        vftOrder = vftOrder[1:]
    elif vftOrder[0] == vftOrder[-1]:
        vftOrder = vftOrder[0:-1]
    finalList = []
    for v in vftOrder:
        finalList.append(transformNode[0] + '.vtx[' + v + ']')
    return (checkCircleState, finalList)

def X3o(p1, p2):
    pA = cmds.pointPosition(p1, w=1)
    pB = cmds.pointPosition(p2, w=1)
    dist = math.sqrt((pA[0] - pB[0]) ** 2 + (pA[1] - pB[1]) ** 2 + (pA[2] - pB[2]) ** 2)
    return dist
def X79(pA, pB, pC):
    a = cmds.pointPosition(pA, w=1)
    b = cmds.pointPosition(pB, w=1)
    c = cmds.pointPosition(pC, w=1)
    ba = [ aa - bb for aa, bb in zip(a, b) ]
    bc = [ cc - bb for cc, bb in zip(c, b) ]
    nba = math.sqrt(sum((x ** 2.0 for x in ba)))
    ba = [ x / nba for x in ba ]
    nbc = math.sqrt(sum((x ** 2.0 for x in bc)))
    bc = [ x / nbc for x in bc ]
    scalar = sum((aa * bb for aa, bb in zip(ba, bc)))
    angle = math.acos(scalar)
    return angle
def X69():
    selEdges = cmds.ls(sl=1, fl=1)
    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

def X62(angle):
    currentSelp = cmds.ls(sl=True, fl=True)
    cmds.polySelectConstraint(m=2, w=1, pp=4, m3a=angle, t=0x8000)
    wholeLoop = cmds.ls(sl=True, fl=True)
    cmds.polySelectConstraint(m=2, w=2, t=0x8000)
    removeInnerEdges = cmds.ls(sl=True, fl=True)
    if len(wholeLoop) != len(removeInnerEdges):
        cmds.select(wholeLoop)
        cmds.select(removeInnerEdges, d=True)
    cmds.polySelectConstraint(m=0, w=0)
    cmds.polySelectConstraint(disable=True)
    
def X99():
    cmds.ConvertSelectionToEdges()
    cmds.polySelectConstraint(m=2, t=0x8000, w=1)
    cmds.polySelectConstraint(disable=True)

def X6o():
    cmds.polySlideEdgeCtx("polySlideEdgeContext", e=True, useSnapping=False)
    cmds.setToolTo("polySlideEdgeContext")


def XI9(PM):
    selEdge = cmds.ls(sl=True, fl=True)
    cmds.polySelectConstraint(disable=True)
    if PM == "minus":
        if len(selEdge) > 1:
            cmds.polySelectConstraint(pp=6, t=0x8000)
            cmds.polySelectConstraint(m=0, w=0) 
            cmds.polySelectConstraint(disable=True) 
    else:
        cmds.polySelectConstraint(m=2, w=2, t=0x8000)
        selInner = cmds.ls(sl=True, fl=True)
        cmds.select(selEdge, r=True)
        cmds.polySelectConstraint(m=2, w=1, t=0x8000)
        selBorder = cmds.ls(sl=True, fl=True)
        cmds.select(selEdge, r=True)
        if len(selInner) > len(selBorder):
            cmds.polySelectConstraint(pp=5, t=0x8000)
            cmds.polySelectConstraint(m=0, w=0)
            cmds.polySelectConstraint(disable=True)
        else:
            cmds.polySelectConstraint(pp=1, m=2, w=1, t=0x8000)
            cmds.polySelectConstraint(m=0, w=0)
            cmds.polySelectConstraint(disable=True)


def X32():
    firstSel = cmds.ls(sl=True, fl=True)
    cmd = 'polySelectEdgesEveryN "edgeRing" 1';
    mel.eval(cmd)
    growAll = cmds.ls(sl=True, fl=True)
    newFace = cmds.polyListComponentConversion(firstSel, fe=True, tf=True)
    newEdges = cmds.ls(cmds.polyListComponentConversion(newFace, ff=True, te=True),fl=1)
    commonItems = list(set(newEdges) & set(growAll))
    cmds.select(commonItems)

def X86():
    firstSel = cmds.ls(sl=True, fl=True)
    newVert = cmds.polyListComponentConversion(firstSel, fe=True, tv=True)
    cmds.select(newVert)
    cmds.ConvertSelectionToContainedFaces(newVert)
    cmds.ConvertSelectionToEdgePerimeter()
    newBorder = cmds.ls(sl=True, fl=True)
    diffItems = list(set(firstSel) - set(newBorder))
    cmds.select(diffItems)


def X95():
    edges = cmds.ls(fl=True, sl=True)
    cmds.polySelectConstraint(m=2, w=2, type=0x8000)
    cmds.polySelectConstraint(disable=True)
    getPoints = cmds.ls( cmds.polyListComponentConversion(edges, tv=True),fl=True)
    edgeLoopExt = cmds.ls( cmds.polySelectSp(edges, q=1, loop=1),fl=True)
    for p in getPoints:
        surEedge = cmds.ls( cmds.polyListComponentConversion(p, te=True),fl=True)
        nextTwoEdge = list(set(surEedge) - set(edgeLoopExt))
        surPoints = cmds.ls( cmds.polyListComponentConversion(nextTwoEdge, tv=True),fl=True)
        surPoints.remove(p) 
        if len(surPoints) == 2:
            ptA = cmds.xform(surPoints[0], q=True, t=True, ws=True)
            ptB = cmds.xform(surPoints[1], q=True, t=True, ws=True)
            midP = cmds.xform(p, q=True, t=True, ws=True)
            distA = math.sqrt( ((ptA[0] - midP[0])**2)  + ((ptA[1] - midP[1])**2) + ((ptA[2] - midP[2])**2))
            distB = math.sqrt( ((ptB[0] - midP[0])**2)  + ((ptB[1] - midP[1])**2) + ((ptB[2] - midP[2])**2))
            scaleBaseP = ''
            scaleDistP = 0
            if distA > distB:
                scaleBaseP = ptA
                scaleDistP = distA
            else:
                 scaleBaseP = ptB
                 scaleDistP = distB
            avgDist = ( distA + distB )/2
            magV =  avgDist /scaleDistP
            if magV < 1: 
                vectBtwPnts= ((scaleBaseP[0] -midP[0])*-1), ((scaleBaseP[1] -midP[1])*-1), ((scaleBaseP[2] -midP[2])*-1)
                vectorToFinish = om.MFloatVector(vectBtwPnts[0],vectBtwPnts[1],vectBtwPnts[2])
                raySource = om.MFloatPoint(scaleBaseP[0],scaleBaseP[1],scaleBaseP[2])
                rayDirection = vectorToFinish
                magnitude = vectorToFinish.length()
                new_magnitude = magnitude * magV
                direction_normalized = vectorToFinish.normal()
                scaled_direction = direction_normalized * new_magnitude
                new_endpoint = raySource + scaled_direction
                cmds.move(new_endpoint.x, new_endpoint.y, new_endpoint.z, p , absolute=True)

def X66():
    target = cmds.intField("collapseLoopNumber", q=1,v = 1)
    checkEdges = cmds.ls(selection=True, flatten=True)
    checkNumberA = XlO(checkEdges)
    if len(checkNumberA) == 1:
        cmds.select(checkEdges, r=True)
        if cmds.objExists("edgeGepLock"):
            cmds.delete("edgeGepLock*")
        cmds.sets(name="edgeGepLock", text="edgeGepLock")
        cvListFlat = cmds.ls(cmds.polyListComponentConversion(fromEdge=True, toVertex=True),fl=1)
        count = 0
        if len(cvListFlat) == len(checkEdges):
            while len(checkEdges) > target and count < 100:
                cmds.select("edgeGepLock", r=True)
                X82('min')
                cmds.polyCollapseEdge()
                cmds.select("edgeGepLock", r=True)
                checkEdges = cmds.ls(selection=True, flatten=True)
                count += 1
        else:
            cmds.select(checkEdges)
            XI9('minus')
            checkEdges = cmds.ls(selection=True, flatten=True)
            if cmds.objExists("edgeGepLock"):
                cmds.delete("edgeGepLock*")
            cmds.sets(name="edgeGepLock", text="edgeGepLock")
            cmds.select("edgeGepLock", r=True)
            while len(checkEdges) > (target - 2) and count < 100:
                cmds.select("edgeGepLock", r=True)
                X82('min')
                cmds.polyCollapseEdge()
                cmds.select("edgeGepLock", r=True)
                checkEdges = cmds.ls(selection=True, flatten=True)
                count += 1
            cmds.select("edgeGepLock", r=True)
            XI9('plus')
        XO7()
        if cmds.objExists("edgeGepLock"):
            cmds.delete("edgeGepLock*")
def Xl9():
    cmds.delete(all=True, e=True, ch=True)
    selEdges = cmds.filterExpand(ex=True, sm=32) or []
    selCV = cmds.filterExpand(ex=True, sm=31) or []
    if len(selCV) > 0 and len(selEdges) == 0:
        cmds.ConvertSelectionToEdges()
        #cmds.GrowPolygonSelectionRegion()
        unwantEdge = cmds.ls(sl=True, fl=True)
        cmds.select(selCV)
        cmds.ConvertSelectionToFaces()
        cmds.polySelectConstraint(mode=2, type=0x0008, size=3)
        cmds.polySelectConstraint(disable=True)
        cmds.ConvertSelectionToEdges()
        cmds.select(unwantEdge, d=True)
        X5o() 
        cmds.select(selCV, add=True)
    elif len(selCV) > 0 and len(selEdges) == 1:
        XI3()
    elif len(selCV) == 1 and len(selEdges) == 2:
        verticesA = cmds.ls(cmds.polyListComponentConversion(selEdges[0], toVertex=True),fl=1)
        verticesB = cmds.ls(cmds.polyListComponentConversion(selEdges[1], toVertex=True),fl=1)
        common_items = list(set(verticesA) & set(verticesB))
        cmds.select(common_items,selCV)
        cmds.polyConnectComponents(ch=0, insertWithEdgeFlow=0, adjustEdgeFlow=0)

def X5o():
    value = 0
    edges = cmds.filterExpand(ex=True, sm=32)
    target_edge = ''
    for edge in edges:
        vertices = cmds.ls(cmds.polyListComponentConversion(edge, toVertex=True),fl=1)
        v1 = cmds.pointPosition(vertices[0], w=True)
        v2 = cmds.pointPosition(vertices[1], w=True)
        check_edge_length = math.sqrt((v1[0] - v2[0])**2 + (v1[1] - v2[1])**2 + (v1[2] - v2[2])**2)
        if check_edge_length > value:
            value = check_edge_length
            target_edge = edge
    cmds.select(target_edge)


def XI3():
    cleanList = ('KeepEdge','KeepCV','NewCV')
    for c in cleanList:
        if cmds.objExists(c):
            cmds.delete(c)
    sel = cmds.ls(sl=1, fl=1)
    cmds.select(cl=1)
    Verts = []
    Edge = []
    newVertAddList = []
    for s in sel:
        if '.vtx[' in s:
            Verts.append(s)
        elif '.e[' in s:
            Edge.append(s)
    if len(Edge) == 1 and len(Verts) > 0:
        cmds.sets(name='KeepEdge', text='g')
        cmds.sets(Edge, add='KeepEdge')
        cmds.sets(name='KeepCV', text='g')
        cmds.sets(Verts, add='KeepCV')
        cmds.sets(name='NewCV', text='g')
        for v in Verts:
            getEdge = cmds.ls(cmds.sets('KeepEdge', query=True),fl=1)
            for g in getEdge:
                EdgeNumber = int(g.split('[')[-1].split(']')[0])
                vertList = cmds.ls(cmds.polyListComponentConversion(g, tv=True), fl=True)
                vertPA = cmds.xform(vertList[0], q=True, ws=True, translation=True)
                vertPB = cmds.xform(vertList[1], q=True, ws=True, translation=True)
                vertPC = cmds.xform(v, q=True, ws=True, translation=True)
                VA = om.MVector(vertPA[0],vertPA[1],vertPA[2])
                VB = om.MVector(vertPB[0],vertPB[1],vertPB[2])
                VC = om.MVector(vertPC[0],vertPC[1],vertPC[2])
                VAB = VB - VA
                magnitude = VAB.length()
                if magnitude != 0:
                    DA = om.MVector(VAB.x / magnitude, VAB.y / magnitude, VAB.z / magnitude)
                else:
                    DA = om.MVector(VAB)
                t = (VC - VA) * DA
                closest_point = VA + DA * t
                wPos = [closest_point.x, closest_point.y, closest_point.z]
                if wPos != vertPA and wPos != vertPB:
                    AC = closest_point - VA
                    BC = closest_point - VB
                    if AC * BC < 0:
                        print('here')
                        cmds.polySplit(g, ip=[(EdgeNumber, 0.5)], ch=0)
                        lastVert = str(v.split('.')[0]) + '.vtx[' + str(cmds.polyEvaluate(v, v=1)) + ']'
                        cmds.xform(lastVert, ws=True, t=(closest_point.x, closest_point.y, closest_point.z))
                        cmds.polyConnectComponents([v, lastVert], ch=0)
                        cmds.sets(lastVert, add='NewCV')
                else:
                    checkExistEdge = cmds.ls(cmds.polyListComponentConversion(v, te=True), fl=True)
                    if wPos == vertPA:
                        checkCurrentEdge = cmds.ls(cmds.polyListComponentConversion(vertList[0], te=True), fl=True)
                        common_elements = [element for element in checkExistEdge if element in checkCurrentEdge]
                        if len(common_elements) == 0:
                            cmds.polyConnectComponents([v, vertList[0]], ch=0)
                    else:
                        checkCurrentEdges = cmds.ls(cmds.polyListComponentConversion(vertList[1], te=True), fl=True)
                        common_elements = [element for element in checkExistEdge if element in checkCurrentEdge]
                        if len(common_elements) == 0:
                            cmds.polyConnectComponents([v, vertList[1]], ch=0)
        getNewCV = cmds.ls(cmds.sets('NewCV', query=True),fl=1)
        if 'getNewCV':
            cmds.select('NewCV')
        else:
            cmds.select(Verts,Edge)
        for c in cleanList:
            if cmds.objExists(c):
                cmds.delete(c)
        Xl9()
                           
def run():
    fColor = (0.23,0.2,0.2)
    if cmds.window("EdgeSenseiWindow", exists=True):
        cmds.deleteUI("EdgeSenseiWindow", window=True)
    if cmds.dockControl("EdgeSenseiDock", exists=True):
        cmds.deleteUI("EdgeSenseiDock", control=True)
    edge_window = cmds.window("EdgeSenseiWindow", title="Edge Sensei", widthHeight=(320, 1100),s = 1 ,mxb = False, mnb = False)
    cmds.columnLayout(adj=True)
    cmds.frameLayout(label="Quick Tools", bv=0, w=298, cll=1, cl=0 ,bgc = fColor)
    cmds.text(l="",h=2)
    cmds.rowColumnLayout(nc=9, cw=[(1, 50), (2, 20), (3, 50), (4, 7), (5, 50), (6, 7), (7, 50), (8, 7), (9, 65)])
    cmds.text(l=" Quick")
    cmds.text(l="")
    cmds.iconTextButton(style="textOnly", label="Split",rpt=1, bgc=(0.18, 0.18, 0.18), c=lambda *args: cmds.SplitPolygonTool())
    cmds.text(l="")
    cmds.iconTextButton(style="textOnly", label="Insert",rpt=1, bgc=(0.18, 0.18, 0.18), c=lambda *args: cmds.SplitEdgeRingTool())
    cmds.text(l="")
    cmds.iconTextButton(style="textOnly", label="Slide",rpt=1, bgc=(0.18, 0.18, 0.18), c=lambda *args: X6o())
    cmds.setParent("..")
    cmds.rowColumnLayout(nc=9, cw=[(1, 50), (2, 20), (3, 65), (4, 7), (5, 75), (6, 7), (7, 50), (8, 7), (9, 65)])
    cmds.text(l="")
    cmds.text(l="")
    cmds.iconTextButton(style="textOnly", label="Connet 90",rpt=1, bgc=(0.18, 0.18, 0.18), c=lambda *args: Xl9())
    cmds.text(l="")
    cmds.iconTextButton(style="textOnly", label="Sharp Corner",rpt=1, bgc=(0.18, 0.18, 0.18), c=lambda *args: X23())
    cmds.setParent("..")
    cmds.separator(height=5, style="in")
    cmds.rowColumnLayout(nc=13, cw=[(1, 50), (2, 20), (3, 50), (4, 7), (5, 70), (6, 7), (7, 50), (8, 20), (9, 50), (10, 5), (11, 20), (12, 5), (13, 20)])
    cmds.text(l=" Select")
    cmds.text(l="")
    cmds.iconTextButton(style="textOnly", label="Border",rpt=1, bgc=(0.18, 0.18, 0.18), c=lambda *args: X99())
    cmds.text(l="")
    cmds.iconTextButton(style="textOnly", label="Contiguous",rpt=1, bgc=(0.18, 0.18, 0.18), c=lambda *args: X62(30))
    cmds.text(l="")
    cmds.iconTextButton(style="textOnly", label="Shortest",rpt=1, bgc=(0.18, 0.18, 0.18), c=lambda *args: X92())
    cmds.setParent("..")
    cmds.rowColumnLayout(nc=13, cw=[(1, 50), (2, 20), (3, 40), (4, 5), (5, 20), (6, 5), (7, 20), (8, 20), (9, 50), (10, 5), (11, 20), (12, 5), (13, 20)])
    cmds.text(l=" ")
    cmds.text(l="")
    cmds.iconTextButton(style="textOnly", label="Loop",rpt=1, bgc=(0.18, 0.18, 0.18), c=lambda *args: cmds.SelectEdgeLoopSp())
    cmds.text(l="")
    cmds.iconTextButton(style="textOnly", label="+", rpt=1, bgc=(0.08, 0.18, 0.38), c=lambda *args: XI9("plus"))
    cmds.text(l="")
    cmds.iconTextButton(style="textOnly", label="-", rpt=1, bgc=(0.08, 0.38, 0.28), c=lambda *args: XI9("minus"))
    cmds.text(l=" |")
    cmds.iconTextButton(style="textOnly", label="Ring",rpt=1, bgc=(0.18, 0.18, 0.18), c=lambda *args: cmds.SelectEdgeRingSp())
    cmds.text(l="")
    cmds.iconTextButton(style="textOnly", label="+", rpt=1, bgc=(0.08, 0.18, 0.38), c=lambda *args: X32())
    cmds.text(l="")
    cmds.iconTextButton(style="textOnly", label="-", rpt=1, bgc=(0.08, 0.38, 0.28), c=lambda *args: X86())
    cmds.setParent("..")
    cmds.rowColumnLayout(nc=7, cw=[(1, 50), (2, 20), (3, 50), (4, 20), (5, 50), (6, 20), (7, 50)])
    cmds.setParent("..")
    cmds.separator(height=5, style="in")
    cmds.rowColumnLayout(nc=11, cw=[(1, 50), (2, 20), (3, 50), (4, 7), (5, 50), (6, 7), (7, 50), (8, 7), (9, 50), (10, 7), (11, 65)])
    cmds.text(l="Average")
    cmds.text(l="")
    cmds.iconTextButton(style="textOnly", label="Smooth", rpt=1, bgc=(0.18, 0.18, 0.18), c=lambda *args: X94())
    cmds.text(l="")
    cmds.iconTextButton(style="textOnly", label="Even", rpt=1, bgc=(0.18, 0.18, 0.18), c=lambda *args: XO7())
    cmds.text(l="")
    cmds.iconTextButton(style="textOnly", label="Spread",rpt=1, bgc=(0.18, 0.18, 0.18), c=lambda *args: X95())
    cmds.text(l="")
    cmds.iconTextButton(style="textOnly", label="Flow",rpt=1, bgc=(0.18, 0.18, 0.18), c=lambda *args: cmds.PolyEditEdgeFlow())
    cmds.text(l="",h=2)
    cmds.setParent("..")
    cmds.text(l="",h=2)
    cmds.setParent("..")
    cmds.frameLayout(label="Arc", bv=0, w=298, cll=1, cl=0 ,bgc = fColor)
    cmds.text(l="",h=2)
    cmds.rowColumnLayout(nc=9, cw=[(1, 50), (2, 20), (3, 50), (4, 5), (5, 50), (6, 5), (7, 50), (8, 5), (9, 50)])
    cmds.text(l="      3D")
    cmds.text(l="")
    cmds.iconTextButton(style="textOnly", label="1", rpt=1, bgc=(0.18, 0.18, 0.18), c=lambda *args: X9l(1))
    cmds.text(l="")
    cmds.iconTextButton(style="textOnly", label="2", rpt=1, bgc=(0.18, 0.18, 0.18), c=lambda *args: X9l(2))
    cmds.text(l="")
    cmds.iconTextButton(style="textOnly", label="3", rpt=1, bgc=(0.18, 0.18, 0.18), c=lambda *args: X9l(3))
    cmds.text(l="")
    cmds.iconTextButton(style="textOnly", label="--", rpt=1, bgc=(0.18, 0.18, 0.18), c=lambda *args: X9l(0))
    cmds.setParent("..")
    cmds.rowColumnLayout(nc=9, cw=[(1, 50), (2, 20), (3, 50), (4, 5), (5, 50), (6, 5), (7, 50), (8, 5), (9, 50)])
    cmds.text(l="      2D")
    cmds.text(l="")
    cmds.iconTextButton(style="textOnly", label="1", rpt=1, bgc=(0.22, 0.22, 0.18), c=lambda *args: Xl8(1))
    cmds.text(l="")
    cmds.iconTextButton(style="textOnly", label="2", rpt=1, bgc=(0.22, 0.22, 0.18), c=lambda *args: Xl8(2))
    cmds.text(l="")
    cmds.iconTextButton(style="textOnly", label="3", rpt=1, bgc=(0.22, 0.22, 0.18), c=lambda *args: Xl8(3))
    cmds.text(l="")
    cmds.iconTextButton(style="textOnly", label="--", rpt=1, bgc=(0.22, 0.22, 0.18), c=lambda *args: Xl8(0))
    cmds.text(l="", h=5)
    cmds.setParent("..")
    cmds.rowColumnLayout(nc=9, cw=[(1, 50), (2, 20), (3, 50), (4, 5), (5, 50), (6, 5), (7, 50), (8, 5), (9, 50)])
    cmds.text(l="      Edit")
    cmds.text(l="")
    cmds.iconTextButton(style="textOnly", label="Inflate", rpt=1, bgc=(0.18, 0.18, 0.18), c=lambda *args: X48())
    cmds.text(l="")
    cmds.iconTextButton(style="textOnly", label="Tension", rpt=1, bgc=(0.18, 0.18, 0.18), c=lambda *args: X7l())
    cmds.text(l="")
    cmds.iconTextButton(style="textOnly", label="UnBevel", rpt=1, bgc=(0.18, 0.18, 0.18), c=lambda *args: X8O())
    cmds.text(l="")
    cmds.checkBox("evenCurveEdgeLength", label="Even", value=0)
    cmds.text(l="",h=2)
    cmds.setParent("..")
    cmds.setParent("..")
    cmds.frameLayout(label="Constant", bv=0, w=298, cll=1, cl=0 ,bgc = fColor)
    cmds.text(l="",h=2)
    cmds.rowColumnLayout(nc=7, cw=[(1, 50), (2, 20), (3, 50), (4, 7), (5, 50), (6, 17), (7, 90)])
    cmds.text(l="  Extend")
    cmds.text(l="")
    cmds.iconTextButton(style="textOnly", label="L", rpt=1,bgc=(0.08, 0.18, 0.38), c=lambda *args: X3l('L',100))
    cmds.text(l="")
    cmds.iconTextButton(style="textOnly", label="R", rpt=1,bgc=(0.08, 0.38, 0.28), c=lambda *args: X3l('R',100))
    cmds.text(l="")
    cmds.checkBox("lockCurveEdgeLength", label="Keep Length", value=0)
    cmds.setParent("..")
    cmds.rowColumnLayout(nc=7, cw=[(1, 50), (2, 20), (3, 50), (4, 7), (5, 50), (6, 20), (7, 50)])
    cmds.text(l="     Curl")
    cmds.text(l="")
    cmds.iconTextButton(style="textOnly", label="L", rpt=1,bgc=(0.08, 0.18, 0.38), c=lambda *args: X3l('L',4))
    cmds.text(l="")
    cmds.iconTextButton(style="textOnly", label="R", rpt=1,bgc=(0.08, 0.38, 0.28), c=lambda *args: X3l('R',4))
    cmds.setParent("..")
    cmds.text(l="",h=2)
    cmds.setParent("..")
    cmds.setParent("..")
    cmds.frameLayout(label="Round", bv=0, w=298, cll=1, cl=0 ,bgc = fColor)
    cmds.text(l="",h=2)
    cmds.rowColumnLayout(nc=9, cw=[(1, 50), (2, 20), (3, 50), (4, 5), (5, 50), (6, 5), (7, 50), (8, 5), (9, 50)])
    cmds.text(l="")
    cmds.text(l="")
    cmds.iconTextButton(style="textOnly", label="90", bgc=(0.18, 0.18, 0.18), c=lambda *args: X84())
    cmds.text(l="")
    cmds.iconTextButton(style="textOnly", label="180", bgc=(0.18, 0.18, 0.18), c=lambda *args: Xo9())
    cmds.text(l="")
    cmds.iconTextButton(style="textOnly", label="360", bgc=(0.18, 0.18, 0.18), c=lambda *args: X5I())
    cmds.text(l="")
    cmds.checkBox("evenRoundEdgeLength", label="Even", value=1)
    cmds.setParent("..")
    cmds.rowColumnLayout(nc=4, cw=[(1, 50), (2, 20), (3,110), (4,130)])
    cmds.text(l="")
    cmds.text(l="")
    cmds.checkBox("evenRoundPivotSnap", label="Pivot Snap Type", value=0, cc=lambda *args: Xl2())
    cmds.radioButtonGrp("PivotSnapType", en=0, nrb=2, sl=1, la2=("Small", "Big"), cw=[(1,50), (2, 60)] )
    cmds.setParent("..")
    cmds.setParent("..")
    cmds.frameLayout(label="Insert by Number", bv=0, w=298, cll=1, cl=0 ,bgc = fColor)
    cmds.text(l="",h=2)
    cmds.floatSliderGrp("multiInsertNo", v=2, pre=0, min=2, max=50, fmn=2, fmx=100, cw3=[50, 35, 0], label="Number  ", field=True)
    cmds.rowColumnLayout(nc=5, cw=[(1, 50),(2, 20), (3, 30),(4, 9), (5, 150)])
    cmds.text(l="Repeat")
    cmds.text(l="")
    cmds.checkBox("keepSpliteNumber", l="", v=0)
    cmds.text(l="")
    cmds.iconTextButton(style="textOnly", label="Split", rpt=1, bgc=(0.18, 0.18, 0.18), c=lambda *args: XO3())
    cmds.text(l="",h=2)
    cmds.setParent("..")
    cmds.text(l="",h=1)
    cmds.setParent("..")
    cmds.frameLayout(label="Insert by Length:",  bv=0, w=298, cll=1, cl=0 ,bgc = fColor)
    cmds.text(l="",h=2)
    cmds.rowColumnLayout(nc=7, cw=[(1, 45), (2, 7), (3, 40), (4, 7),(5, 95), (6, 5),(7, 95)])
    cmds.text(label="Length:")
    cmds.text(l="", h=3)
    cmds.floatField("refInsertLength", v = 10, pre=3)
    cmds.text(l="", h=3)
    cmds.button(bgc=[0.2, 0.2, 0.2], label="Check", h=23, c=lambda *args: X76("IbL"))
    cmds.text(l="", h=3)
    cmds.button(bgc=[0.2, 0.2, 0.2], label="Split", h=23, c=lambda *args: XoI())
    cmds.setParent('..')
    cmds.text(l="",h=1)
    cmds.setParent('..')
    cmds.frameLayout(label="Edge Lock", bv=0, w=298, cll=1, cl=0 ,bgc = fColor)
    cmds.text(l="",h=2)
    cmds.rowColumnLayout(nc=3, cw=[(1, 50), (2, 50), (3, 175)])
    cmds.text(l="   Type")
    cmds.text(l="", h=3)
    cmds.radioButtonGrp("lockEdgeType", nrb=2, sl=1, la2=["Absolute", "Relative"], cw=[(1, 90), (2, 70)])
    cmds.setParent("..")
    cmds.floatSliderGrp("lockEdgeSlider", v=0.95, min=0.001, max=0.999, s=0.01, cw3=[50, 40, 0], label="Ratio   ", field=True, dc=lambda *args: X36())
    cmds.rowColumnLayout(nc=7, cw=[(1, 45), (2, 7), (3, 40), (4, 7),(5, 95), (6, 5),(7, 95)])
    cmds.text(l="Length")
    cmds.text(l="", h=3)
    cmds.floatField("lastLockEdgelength",  v = 0.02, pre=3)
    cmds.text(l="", h=3)
    cmds.iconTextButton(style="textOnly",label="Ratio", rpt=1, bgc=(0.18, 0.18, 0.18), c=lambda *args: X25())
    cmds.text(l="", h=3)
    cmds.iconTextButton(style="textOnly",label="Length", rpt=1,bgc=(0.18, 0.18, 0.18), c=lambda *args: X58())
    cmds.text(l="",h=2)
    cmds.setParent("..")
    cmds.setParent("..")
    cmds.text(l="",h=4)
    cmds.setParent("..")
    cmds.frameLayout(label="Ring Equalizer", bv=0, w=298, cll=1, cl=0 ,bgc = fColor)
    cmds.text(l="",h=2)
    cmds.rowColumnLayout(nc=11, cw=[(1, 45), (2, 7), (3, 40), (4, 7),(5, 40), (6, 30),(7, 35), (8, 3),(9, 35), (10, 3),(11, 35)])
    cmds.text(l="Length")
    cmds.text(l="",h=2)
    cmds.floatField("equalizerLength", v=1 ,pre =3 )
    cmds.text(l="",h=2)
    cmds.iconTextButton(style="textOnly", label="check", bgc=(0.18, 0.18, 0.18), c=lambda *args: X76("RE"))
    cmds.text(l="  |  ",h=2)
    cmds.iconTextButton(style="textOnly", label="A", bgc=(0.08, 0.18, 0.38), c=lambda *args: X75('A'))
    cmds.text(l="",h=2)
    cmds.iconTextButton(style="textOnly", label="Mid", bgc=(0.18, 0.18, 0.18), c=lambda *args: X75('M'))
    cmds.text(l="",h=2)
    cmds.iconTextButton(style="textOnly", label="B", bgc=(0.08, 0.38, 0.28), c=lambda *args: X75('B'))
    cmds.setParent("..")
    cmds.text(l="",h=1)
    cmds.setParent('..')
    cmds.frameLayout(label="Collapse Loop to Number:",  bv=0, w=298, cll=1, cl=0 ,bgc = fColor)
    cmds.text(l="",h=2)
    cmds.rowColumnLayout(nc=7, cw=[(1, 45), (2, 7), (3, 40), (4, 7),(5, 95), (6, 5),(7, 95)])
    cmds.text(label="Target:")
    cmds.text(l="", h=3)
    cmds.intField("collapseLoopNumber", v = 10)
    cmds.text(l="", h=3)
    cmds.button(bgc=[0.2, 0.2, 0.2], label="Collapse", h=23, c=lambda *args: X66())
    cmds.setParent('..')
    cmds.text(l="",h=1)
    cmds.setParent('..')
    cmds.frameLayout(label="Arc Deformer", bv=0, w=298, cll=1, cl=0 ,bgc = fColor)
    cmds.rowColumnLayout(nc=3 ,cw=[(1,50),(2,50),(3,175)])
    cmds.text(l ='Type')
    cmds.text(l ='')
    cmds.radioButtonGrp('curveType', nrb=2, sl=1, labelArray2=['Bezier', 'Nurbs'], cw = [(1,90),(2,70)],cc='X45()')
    cmds.setParent( '..' )
    cmds.rowColumnLayout(nc=10 ,cw=[(1,1),(2,50),(3,10),(4,50),(5,5),(6,50),(7,5),(8,50),(9,5),(10,95)])
    cmds.text(l ='')
    cmds.text(l ='Options')
    cmds.text(l ='')
    cmds.checkBox('makeArc', label= "Arc" ,v = 1, cc=lambda *args: X9I())
    cmds.text(l ='')
    cmds.checkBox('snapCurve', label= "Snap" ,v = 1, cc=lambda *args: X77())
    cmds.text(l ='')
    cmds.checkBox('evenSpace', label= "Even" ,v = 1)
    cmds.text(l ='')
    cmds.checkBox('cleanCurve', label= "Keep Curve" ,v = 1)
    cmds.setParent( '..' )
    cmds.intSliderGrp('CPSlider', cw3=[50, 30, 180], label = 'Point ',  field= 1, min= 2, max= 10, fmx = 500, v = 3 )
    cmds.floatSliderGrp('dropOffSlider' , label = 'DropOff', v = 0.01, cw3=[50, 30, 180], field=1 ,pre = 2, min= 0.01, max= 10)
    cmds.rowColumnLayout(nc=4 ,cw=[(1,99),(2,95),(3,5),(4,95)])
    cmds.text(l ='')
    cmds.iconTextButton(style="textOnly", l= 'Create',bgc=(0.18, 0.18, 0.18),  c= 'XI4()')
    cmds.text(l ='')
    cmds.iconTextButton(style="textOnly", l= 'Done', bgc=(0.18, 0.18, 0.18), c= 'X98()')
    cmds.text(l ='')
    cmds.setParent( '..' )
    cmds.text(l="",h=2)
    cmds.showWindow(edge_window)
    cmds.window("EdgeSenseiWindow", e=1, widthHeight=(320, 1100))
    #allowedAreas = ['right', 'left']
    #cmds.dockControl("EdgeSenseiDock", area="left", content = edge_window, width=360, allowedArea = allowedAreas,fl=1, label="EdgeSensei v1.0")