def create(self):
        self.handle   = pm.group(em=True)
        self.result   = pm.group(em=True)
        self.aim      = pm.group(em=True)
        self.up       = pm.group(em=True)
        
        pm.parent(self.result, self.aim, self.up, self.handle )
        
        # 초기위치 조정
        mult = 20
        self.aim.t.set(self.aimVec * mult)
        self.up.t.set(self.upVec * mult)
        
        self.aimConstraint = pm.aimConstraint(self.aim, self.result, aim=self.aimVec, u=self.upVec, wut='object', wuo=self.up)
        
        # 시각화
        self.handle.displayHandle.set(True)
        #self.result.displayLocalAxis.set(True)
        
        # 어트리뷰트 잠금
        setAttrs( self.result, 'tx','ty','tz','sx','sy','sz','v' )
        setAttrs( self.aim,    'rx','ry','rz','sx','sy','sz','v' )
        setAttrs( self.up,     'rx','ry','rz','sx','sy','sz','v' )

        # 이름변경
        self.setPrefix( self.prefix )

	def createIkAnimatedJoints(self):
		
		pm.select(cl = True)
		
		#Iterate jointPositionList and append to ikAnimatedJointsList joint at each position
		self.ikAnimatedJointsList = []
		
		for index in range(0, len(self.jointPositionList)):
			#create Joint
			
			#decide jointNames
			jointName = self.prefix + '_ik_animated_j_' + str(index + 1)
			if( index == 0 ): jointName = self.prefix + '_ik_animated_j_' + 'base'
			if( index + 1 == len(self.jointPositionList) ): jointName = self.prefix + '_ik_animated_j_' + 'tip'
			
			joint = pm.joint(a = True, p= self.jointPositionList[index] , co = True, n = jointName)
			#setJointPreferredAngle for correct ikHandle bending
			pm.setAttr(joint.preferredAngleX, -1.0)
			self.ikAnimatedJointsList.append(joint)
			
			
		pm.select(cl = True)
		
		
		#Create ikAnimatedJointsGrp and parent first ik animated joint
		self.ikAnimatedJointsGrp = pm.group(n = self.prefix + '_ik_animated_joints_grp')
		pm.select(cl = True)
		pm.parent(self.ikAnimatedJointsList[0] , self.ikAnimatedJointsGrp)
		pm.select(cl = True)

def createIKSpline( jntList ):
    pymelLogger.debug('Starting: createIKSpline()...') 
    # Make IK Spline
    ikHandleTorso = pm.ikHandle( startJoint=jntList[0], endEffector=jntList[-1], solver = 'ikSplineSolver', numSpans = 4, name = jntList[-1]+'_'+Names.suffixes['ikhandle'])
    # we should probably rename the object created to know names ......    
    # CAREFULL // inherits Transform OFF, to avoid double transformation when grouped later on
    pm.setAttr(ikHandleTorso[2] + '.inheritsTransform', 0)
    
    # Duplicate last and first joint to use as Drivers of the spine Ik curve
    print jntList
    drvStart = pm.duplicate(jntList[0], parentOnly=True, name = Names.prefixes['driver']+'_'+ jntList[0] +'_'+Names.suffixes['start'])
    drvEnd = pm.duplicate(jntList[-1], parentOnly=True, name = Names.prefixes['driver']+'_'+ jntList[-1] +'_'+Names.suffixes['end'])
    pm.parent(drvEnd, w=1)
    
    # Make radius bigger
    pm.joint(drvStart, edit = True, radius = 1)
    pm.joint(drvEnd, edit = True, radius = 1)
    
    # Skin hip/shldr jnt's to back curve
    pm.skinCluster(drvStart,drvEnd,ikHandleTorso[2],dr=4)
    
    # return nedded elements
    rList = [ikHandleTorso, drvStart, drvEnd ]
    
    pymelLogger.debug('End: createIKSpline()...') 
    return rList

    def buildGuides(self):
        """
        This function setups our guide system
        
        WILL PROBABLY BE ANOTHER CLASS WHEN WE EXPAND AS IT'S GOING TO BE COMPLEX
        """
        
        self.guides = []
        
        for i,p in enumerate(self.posArray):
            
            name = nameUtils.getUniqueName(self.baseNames[i],self.side,"GUIDE")
            loc = pm.spaceLocator(n=name)
            loc.t.set(p)
            loc.r.set(self.rotArray[i])
            self.guides.append(loc)
            
        tempGuides = list(self.guides)
        tempGuides.reverse()

        for i in range(len(tempGuides)):
            if i != (len(tempGuides)-1):
                pm.parent(tempGuides[i],tempGuides[i+1])
        
        name = nameUtils.getUniqueName(self.baseName+"_guides",self.side,"grp")
        self.guidesGrp = pm.createNode("transform",n=name)
        
        self.guides[0].setParent(self.guidesGrp)

    def __generateMesh( self, mesh, positions, radius, iteration ):
        
        instanceGroup   = pm.group( empty = True, name = "meshInstanceGroup" )

        positionsLength = len( positions )
        instances       = [ None ] * positionsLength

        for i in range(0, positionsLength):

            position = scaleVector( positions[ i ], radius )

            if i == 0:

                meshInstance = mesh
                meshInstance[ 0 ].setTranslation( position )

            else:

                meshInstance = pm.instance( mesh[ 0 ] )
                meshInstance[ 0 ].setTranslation(position)

            instances[ i ] = meshInstance[ 0 ]

        pm.parent( instances, instanceGroup, add = True )

        return combineClean( instanceGroup, "Sierpinski_Iteration_%i" % iteration ) 

    def AlignBindNode(self, **kws):
        '''
        Overwrite the default behaviour: Align the newly made BindNode as required for this bind
        '''

        parentNode = self.SourceNode.listRelatives(p=True)[0]

        if parentNode:
            #Parent the BindNode to the Source Driver Node
            pm.parent(self.BindNode['Root'], self.SourceNode.listRelatives(p=True)[0])
        else:
            pm.parent(self.BindNode['Root'], self.SourceNode)

        self.BindNode['Main'].rotateOrder.set(self.SourceNode.rotateOrder.get())
        self.BindNode['Root'].rotateOrder.set(self.DestinationNode.rotateOrder.get())

        #Positional Alignment
        if self.Settings.AlignToControlTrans:
            pm.delete(pm.pointConstraint(self.SourceNode, self.BindNode['Root']))
            pm.makeIdentity(self.BindNode['Root'], apply=True, t=1, r=0, s=0) 
            pm.delete(pm.pointConstraint(self.DestinationNode, self.BindNode['Root']))
        if self.Settings.AlignToSourceTrans:
            pm.delete(pm.pointConstraint(self.SourceNode, self.BindNode['Root']))
            pm.makeIdentity(self.BindNode['Root'], apply=True, t=1, r=0, s=0) 

        #Rotation Alignment
        if parentNode:
            pm.orientConstraint(self.SourceNode, self.BindNode['Root'])

        if self.Settings.AlignToControlRots:
            pm.delete(pm.orientConstraint(self.DestinationNode, self.BindNode['Main']))
        if self.Settings.AlignToSourceRots:
            pm.delete(pm.orientConstraint(self.SourceNode, self.BindNode['Main']))

def __transformToBone__(obj):
    name   = obj.name()
    
    # create joint
    jnt = pmc.createNode('joint', name=name+'_')
    
    # set parent
    if obj.getParent():
        jnt.setParent(obj.getParent())
    
    # set transformation
    jnt.setTranslation(obj.getTranslation(space='object'), space='object')
    jnt.setRotationOrder(obj.getRotationOrder(), reorder=True)
    jnt.jointOrientX.set(obj.getRotation(space='object')[0])
    jnt.jointOrientY.set(obj.getRotation(space='object')[1])
    jnt.jointOrientZ.set(obj.getRotation(space='object')[2])
    jnt.setScale(obj.getScale())
    jnt.setShear(obj.getShear())
    
    # get children
    children = obj.getChildren()
    for child in children:
        child = various.checkObj(child, type=['transform', 'joint'], echo=False)
        if child:
            child.setParent(jnt)
    
    # parent shape
    if obj.getShape():
        pmc.parent(obj.getShape(), jnt, shape=True, relative=True)
    
    # deleting and renaming properly
    pmc.delete(obj)
    jnt.rename(name)

    return jnt

 def makeLoc(obj=None):
     # Place locator as child to jnt and zero it
     loc = pm.spaceLocator()
     pm.parent(loc, obj)
     loc.setTranslation(0)
     loc.setRotation([0, 0, 0])
     return loc

def ExtraControlForJnt( jnts=None ) :

	if not jnts:
		jnts = pm.ls( sl=True )
	else:
		jnts = pm.ls( jnts )
	
	
	for jnt in jnts:
		
		# duplicate joint
		pm.select( clear=True )
		newJnt = pm.joint( p = [0,0,0], name= '%s_extra'%jnt.name() )
		pm.delete( pm.pointConstraint( jnt, newJnt ) )
		pm.delete( pm.orientConstraint( jnt, newJnt ) )
		pm.parent( newJnt, jnt )
		newJnt.jointOrient.set( jnt.jointOrient.get() )
		
		# create control curve for joint
		ctrl = CubeCrv( name = '%s_ctrl'%jnt.name() )
		pm.delete( pm.pointConstraint( jnt, ctrl ) )
		pm.delete( pm.orientConstraint( jnt, ctrl ) )
		zeroAndOfs = ZeroGrp( ctrl )
		ctrl.translate >> newJnt.translate
		ctrl.rotate >> newJnt.rotate
		ctrl.scale >> newJnt.scale
        
		# make controls to move with base joints
		pm.parentConstraint( jnt, zeroAndOfs[0] )
		pm.scaleConstraint( jnt, zeroAndOfs[0] )

def jointsOnCurve(crv=None, num=None, name=None):
    if not crv: return
    if not num: return
    if not name: return
    if num < 1: return

    param_increment = 1.0/float(num)
    param = 0
    curveShape = pm.PyNode(crv).getShape()
    prnt = []
    for i in range(num):
        pm.select(clear=1)
        # Create joint
        jnt = pm.joint(n=name+'_'+str(i).zfill(2))
        # Attach to curve
        poci = pm.createNode('pointOnCurveInfo')
        pm.connectAttr('%s.ws'%curveShape,'%s.inputCurve'%poci,f=1)
        pm.connectAttr('%s.position'%poci,'%s.translate'%jnt,f=1)
        pm.setAttr('%s.parameter'%poci,param)
        pm.setAttr('%s.turnOnPercentage'%poci,1)

        pm.disconnectAttr('%s.position'%poci,'%s.translate'%jnt)
        pm.delete(poci)

        if len(prnt):
            pm.parent(jnt,prnt[-1])

        prnt.append(jnt)
        param += param_increment

def addZero(*args, **kwargs):
	oblist = makeList(args)

	results = []

	for item in oblist:
		if item.type() == 'joint':
			zero = pm.createNode('transform', n=item+'Zero')
			zero.rotateOrder.set( item.rotateOrder.get() )
			snap(zero, item)
			pm.parent(item, zero)
			results.append(zero)
		elif item.type() == 'transform':
			zero = pm.duplicate(item, rr=True)[0]
			children = zero.getChildren()
			if len(children):
				pm.delete(children)
			zero.rename(item+'Zero')

			for attr in 'trs':
				for axis in 'xyz':
					pAttr = zero.attr(attr+axis)
					pAttr.set(lock=False)
					pAttr.set(k=True)

			pm.parent(item, zero)
			results.append(zero)

	if len(results) == 0:
		return None
	elif len(results) == 1:
		return(results[0])
	else:
		return(results)

def FTM_createRulerPlane( control, axisPlane, isMainDirX, transformParent, dummyRulerTransform ):
	obj = pm.polyPlane( axis=axisPlane, ch=True, w=1, h=1, sx=1, sy=1 )
	if isMainDirX == True:
		bDir = 'width'
		bSubDir = 'subdivisionsWidth'
		sDir = 'height'
		sSubDir = 'subdivisionsHeight'
	else:
		sDir = 'width'
		sSubDir = 'subdivisionsWidth'
		bDir = 'height'
		bSubDir = 'subdivisionsHeight'
	
	pm.connectAttr( control+'.controlSize2', obj[1]+'.'+bDir)
	pm.connectAttr( control+'.rulerDivisions2', obj[1]+'.'+bSubDir)
	pm.connectAttr( control+'.rulerSmallSize', obj[1]+'.'+sDir)

	shapeTransformDriver = dummyRulerTransform
	if shapeTransformDriver is None:
		shapeTransformDriver = obj[0]
	outShp = FTM_createTransformedGeometry(obj[0], 'outMesh', 'inMesh', shapeTransformDriver )

	#shps = pm.listRelatives(obj[0],s=True)
	pm.connectAttr( control+'.rulerDisplay', outShp+'.visibility')
	pm.setAttr(outShp+'.template', 1)

	if transformParent is None:
		pm.parent(obj[0], control)
		return obj[0]
	else:
		pm.parent(outShp,transformParent, add=True, s=True)
		pm.delete( obj[0] )

def rigBook(containers):
	center = createJointChain(name='center')
	left = createJointChain(name='left')
	right = createJointChain(name='right')
	ctrl = containers["ctrl"]
	
	pm.addAttr(containers["ctrl"],
	ln="_",
	at="enum",
	en="______"
	)
	pm.setAttr(containers["ctrl"]+"._", e=1, keyable=1)
	
	for page in range(pages):
		pageName = 'page'+str(page)
		skin = createJointChain(pageName+"_")
		rigPage(skin, center, left, right, ctrl, pageName)
		paper = createPaper(pageName)
		pm.select(skin, r=1, hi=1)
		pm.select(paper, add=1, )
		pm.bindSkin(toAll = 1, colorJoints = 1)
		pm.select(cl=1)
		pm.parent(paper, containers["paper_grp"])
		pm.parent(skin[0], containers["pages_grp"])
		pm.select(cl=1)
		print "rigged: %s" % pageName
	
	pm.parent(center[0], containers["pageTargets_grp"])
	pm.parent(left[0], containers["pageTargets_grp"])
	pm.parent(right[0], containers["pageTargets_grp"])

	def createBoundJointChain(self):
		pm.select(cl = True)
		
		
		#Iterate highResCurveCoordList and append to boundJointsList joint at each position
		self.boundJointsList = []
		
		for index in range(0, len(self.highResCurveCoordList)):
			#create Joint
			
			#decide jointNames
			jointName = self.prefix + '_bound_j_' + str(index + 1)
			if( index == 0 ): jointName = self.prefix + '_bound_j_' + 'base'
			if( index + 1 == len(self.highResCurveCoordList) ): jointName = self.prefix + '_bound_j_' + 'tip'
			
			joint = pm.joint(a = True, p= self.highResCurveCoordList[index] , co = True, n = jointName)
			self.boundJointsList.append(joint)
			
			
		pm.select(cl = True)
		
		
		#Orient boundJoints
		pm.joint(self.boundJointsList[0], e = True, sao = 'yup', oj='xyz', zso = True, ch = True)
		pm.select(cl = True)
		
		
		#Create boundJointsGrp and parent first bound joint
		self.boundJointsGrp = pm.group(n = self.prefix + '_bound_joints_grp')
		pm.select(cl = True)
		pm.parent(self.boundJointsList[0] , self.boundJointsGrp)
		pm.select(cl = True)

def transfer_shape(source, target, snap_to_target=True, fix_name=False):
    """
    Reparent a shape node from one parent to another
    @param source: The source dag which contains the shape
    @param target: The source dag which will have the new shape the shape
    @param snap_to_target: Should be we reparent with world space or object space
    @param fix_name: Should we match the name of the shape to the new target
    @return:
    """
    source = force_pynode(source)
    target = force_pynode(target)
    if snap_to_target:
        snap(source, target)
        pm.makeIdentity(source, apply=1)
        if source.getShape().type() != "locator":
            try:
                pm.cluster(source)
                pm.delete(source, ch=1)
            except RuntimeError:
                logger.warning("Cannot cluster {}".format(source))

    oldShape = source.getShape()
    pm.parent(oldShape, target, shape=1, relative=1)
    if fix_name:
        fix_shape_name(target)
    return oldShape

    def buildIK(self, *args):
        """
            Build the IK
        """
        #Setup variables
        if self.normal == 1:
            self.normal = (1, 0, 0)
        if self.normal == 2:
            self.normal = (0, 1, 0)
        if self.normal == 3:
            self.normal = (0, 0, 1)   

        #Create IK control
        self.ikControl = pm.circle(nr=self.normal, r=self.radius, n='%s_ikCnt'%self.prefix)
        pm.select(self.ikControl[0], r=True)
        pm.mel.eval("DeleteHistory;")
        pm.delete( pm.parentConstraint(self.ikChain[2], self.ikControl[0], mo=0) )
        self.zero(self.ikControl[0])               

        #Create RP IK
        self.arm_ikHandle = pm.ikHandle(sj=self.ikChain[0], ee=self.ikChain[2], solver='ikRPsolver', name=(self.prefix + '_armIkHandle'))
        pm.setAttr(self.arm_ikHandle[0] + '.visibility', 0)

        #Parent IK Handle to the ikWrist_cnt
        pm.parent(self.arm_ikHandle[0], self.ikControl[0])

        # Creates: self.pv_cnt
        self.createPoleVector()

    def bdCreateFol(self,surfaceRbn,segments,direction,ends):
        folicles = []
        if not ends:
            flcRange = [i for i in range(1,segments)]
        else:
            flcRange = [i for i in range(segments+1)]

        for i in flcRange:
            flcShape = pm.createNode('follicle', name = surfaceRbn.name().replace('srf','FLCShape') + '_0' + str(i) )
            flcTransform = flcShape.getParent()
            flcTransform.rename(surfaceRbn.name().replace('srf','flc') + '_0' + str(i) )
            folicles.append(flcTransform) 

            surfaceRbn.getShape().local.connect(flcShape.inputSurface)
            surfaceRbn.getShape().worldMatrix[0].connect(flcShape.inputWorldMatrix)

            flcShape.outRotate.connect(flcTransform.rotate)
            flcShape.outTranslate.connect(flcTransform.translate)

            if(self.direction == 'v'):
                flcShape.parameterU.set(0.5)
                flcShape.parameterV.set((i*1.0)/segments)
            else:
                flcShape.parameterV.set(0.5)
                flcShape.parameterU.set((i*1.0)/segments)                


        flcGrp = pm.group(folicles,n=surfaceRbn.name().replace('srf','flc_grp'))
        pm.parent(flcGrp,self.rbnGrp)
        return flcGrp

    def importMixamoFbx(self) :
        print 'importMixamoFbx'
        pm.newFile(f=1)
        if self.fbxFile:
            if os.path.isfile(self.fbxFile):

                #import the FBX file
                pm.mel.eval( 'FBXImport -f "' + (self.fbxFile) + '"')
                #check for a default mesh in T-Pose. If found, replace geometry
                self.replaceGeometry()

                #clean its namespace
                removeNamespace()
                hips = pm.ls("Hips",type='joint')

                #add root joint for scale
                rootJnt = pm.joint(n='Root')
                pm.parent(hips[0],rootJnt)

                #clean up textures
                self.cleanUpTextures()
                pm.currentUnit(t='ntsc')

                return 1
            else:
                pm.error('Fbx file %s doesn\'t exist'%self.fbxFile)
                return 0
        else:
            pm.error('No file was given')
            return 0

	def vis_orbits(self):
		global vis_orbGrp
		vis_orbGrp = pm.group(n='olp_visOrbits', em=True)

		intervValue = self.interv_int.value()
		distValue = self.distance_float.value()
		orbitValue = self.orbit_int.value()

		global all_orbitObjs
		all_orbitObjs = []
		for orbit in range(orbitValue):
			orbitRot = orbit * 360/float(orbitValue*2)
			
			orbit_visObject = pm.circle(n='olp_orbCircle{0}'.format(orbit+1), r=distValue, s=intervValue*2, nr=[1, 0, 0], ch=True)[0]
			pm.parent(orbit_visObject, vis_orbGrp)

			orbit_visObject.overrideEnabled.set(1)
			orbit_visObject.overrideColorRGB.set(0, 1, 1)
			orbit_visObject.overrideRGBColors.set(1)

			pm.xform(orbit_visObject, ro=[0, 0, orbitRot])

			all_orbitObjs.append(orbit_visObject)

		pm.xform(vis_orbGrp, a=True, t=sel_center)
		pm.parent(vis_orbGrp, vis_mainGrp)
		pm.select(sel_objects, r=True)
		return vis_orbGrp

    def export_hierarchy_obj(self):
        """Export the individual meshes in the hierarchy"""
        file_info = {}
        # Reverse the geo list so that the deepest geo is deleted first in case there is a geo inside geo
        geo_list = self.geo_list
        geo_list.reverse()
        for self.current_target in geo_list:
            pm.delete(self.current_target, ch=1)
            parent = pm.listRelatives(self.current_target, parent=True)
            pm.parent(self.current_target, w=True)
            pm.select(self.current_target)
            path = libFile.linux_path(libFile.join(self.export_dir, self.current_target + ".obj"))
            # Load the obj plugin
            cmds.file(path,
                      pr=1,
                      typ="OBJexport",
                      force=1,
                      options="groups=0;ptgroups=0;materials=0;smoothing=0;normals=0",
                      es=1)
            file_info[self.current_target] = path
            logger.info("Exporting\n%s" % file_info[self.current_target])
            if not self.new_scene and self.cleansing_mode:
                pm.delete(self.current_target)
                pm.refresh()
            else:
                pm.parent(self.current_target, parent)

            self.update_progress()

        # Write the geo file_info
        self.geo_file_info = file_info