def createCurveRig( self, selCurve, nameOfRig, align):
        “”“
        This method takes a curve and generates a rig from it
        :param selCurve:
        :return:
        “”“

        print(‘Name of rig is: ‘+nameOfRig)


        # delete all construction history on curve to account for existing clusters
        mc.delete( selCurve, ch=True )

        # get position of all points in curve
        curveEPpos = mc.getAttr( selCurve+’.ep[*]’ )

        # get number of CPs and EPs in curve
        curveEPindex = len(curveEPpos)
        curveCVindex = mc.getAttr( selCurve+’.cp’, size=True )

        #curveEPindex = sum(curveEPindex)

        print(‘Curve EP positions are at: ‘+ str(curveEPpos)+’\n’ )
        print(‘size of EP array is: ‘+str(curveEPindex) )


        # make lists for organization
        clsList=[]
        locAnchorList=[]
        jntDefList=[]
        ctrlMicroList=[]
        ctrlMacroList=[]


        counter=0
        for ep in range(curveEPindex):

            print(‘Current EP is: ‘+ str(ep) )
            #posIndex = 1 / (ep+1)

            # create point on curve info node
            poci=mc.shadingNode(‘pointOnCurveInfo’, n=’poci_’+nameOfRig+str(counter), asUtility=True )

            # create anchor locator
            locCrvAnchor = mc.spaceLocator( n=’loc_crvAnchor_’+nameOfRig+str(counter) )[0]
            # hide locator shape
            mc.setAttr( locCrvAnchor+’Shape.visibility’, 0 )
            locAnchorList.append(locCrvAnchor)

            # define value to place along curve
            paramU=ep

            # connect poci nodes
            mc.connectAttr( selCurve+’.worldSpace’, poci+’.inputCurve’ , force=True )
            mc.connectAttr( poci+’.position’, locCrvAnchor+’.translate’, force=True )
            mc.setAttr( poci+’.parameter’, paramU )

            # check for align
            if align == True:
                mc.tangentConstraint( selCurve, locCrvAnchor, weight=1, aimVector=(1,0,0),
                                      upVector=(0,1,0), worldUpType=’vector’, worldUpVector=(0,1,0) )


            # now create offset empty groups for attaching joints to

            #pos = mc.xform( locCrvAnchor, q=True, t=True, ws=True )
            #rot = mc.xform( locCrvAnchor, q=True, ro=True, ws=True )

            grpOffset = mc.group( n=’grpFrzLoc_’+nameOfRig+str(counter), em=True )

            # create intermediate group for SDK driver possibilities
            grpSDKOffset = mc.group( n=’grpSDKLoc_’+nameOfRig+str(counter), em=True )

            # parent offset under anchor locator
            mc.parent( grpOffset, locCrvAnchor, r=True )

            # parent SDK offset under grpOffset
            mc.parent( grpSDKOffset, grpOffset, r=True )

            # now create micro control for each joint
            ctrlMicro = mc.circle(n=’ctrl_micro_’+nameOfRig+str(counter), d=3, r=2, ch=False )
            mc.setAttr( ctrlMicro[0]+’Shape.overrideEnabled’, 1 )
            mc.setAttr( ctrlMicro[0]+’Shape.overrideColor’, 18 )

            mc.parent( ctrlMicro, grpSDKOffset, r=True )
            ctrlMicroList.append(ctrlMicro)


            # now create joints to parent under ctrl
            jntDef = mc.joint( n=’jntDef_’+nameOfRig+str(counter) )
            jntDefList.append(jntDef)
            #mc.parent( jntDef, grpSDKOffset, r=True )

                # set control rig joints to be larger and invisible
                mc.setAttr( jntDef+’.radius’, 3 )
                mc.setAttr( jntDef+’.drawStyle’, 2 )

            counter+=1


        counter=0
        for cv in range(curveCVindex):

            # create cluster curve
            cls = mc.cluster( ‘{0}.cv[{1}]’.format( selCurve, cv ), rel=True,
                              n=’cls_’+nameOfRig+str(counter) )
            # append shape node of cls instead of transform handle
            clsList.append(cls[1])

            # get cls position
            posMacro = mc.xform(cls[1], q=True, rp=True, ws=True)

            # now create Macro ctrl for every other cluster and skip first cluster
            if (counter !=0) and (counter % 2 == 0):

                # create empty intermediate grp for macro ctrl
                grpOffsetMacro=mc.group( n=’grpFrzMacroCtrl_’+nameOfRig+str(counter), em=True )
                mc.xform( grpOffsetMacro, t=posMacro, ws=True )

                # check for align
                if align==True:
                    print(‘Aligning controls to curve!!! \n’)

                    tmpTc=mc.tangentConstraint( selCurve, grpOffsetMacro, weight=1, aimVector=(1,0,0),
                                                upVector=(0,1,0), worldUpType=’vector’, worldUpVector=(0,1,0) )

                    mc.delete(tmpTc)


                # create macro ctrl shape
                ctrlMacro = mc.circle( n=’ctrl_macro_’+nameOfRig+str(counter), d=3, r=5, ch=False )
                mc.setAttr( ctrlMacro[0]+’Shape.overrideEnabled’, 1 )
                mc.setAttr( ctrlMacro[0]+’Shape.overrideColor’, 13 )

                mc.parent( ctrlMacro, grpOffsetMacro, r=True )
                # mc.xform( ctrlMacro, t=posMacro, ws=True )
                ctrlMacroList.append(grpOffsetMacro)

                # constrain cluster to macro control
                mc.parentConstraint( ctrlMacro, cls[1], mo=True )


            counter+=1


        print(‘Cluster Curve created for: ‘+str(selCurve) +’\n’ )

        # set curve display to template
        selCurveShape = mc.listRelatives( selCurve, ad=True, s=True )[0]
        mc.setAttr( selCurveShape+’.template’, 1 )
        mc.setAttr( selCurveShape+’.visibility’, 0 )


        # make organizational groups and set visibility of unneeded groups
        grpCls=mc.group( clsList, n=’grpCls_’+nameOfRig )
        mc.setAttr( grpCls+’.visibility’, 0 )

        grpLoc=mc.group( locAnchorList, n=’grpCtrlMicro_’+nameOfRig )


        grpMacroCtrls = mc.group( ctrlMacroList, n=’grpCtrlMacro_’+nameOfRig )

        # put everything in one big group
        finalGrp = [ grpCls, grpLoc, grpMacroCtrls, selCurve ]
        mc.group( finalGrp, n=’grpRig_’+nameOfRig )
        # mc.parent( selCurve, finalGrp, r=True )

        # rename original curve
        mc.rename( selCurve, ‘crvShaper_’+selCurve )