Script Licenses.

Posted on December 9, 2019 by Jan

Any script (*unless otherwise specified in the post) found on this website can be used according to the Apache License v2.0.

The reason for adding this is because without any license information some companies do not allow their developers to use scripts from 3rd party websites.

# -*- coding: utf-8 -*-
##  Copyright 2019 Trevor van Hoof and Jan Pijpers.
##
##  Licensed under the Apache License, Version 2.0 (the "License");
##  you may not use this file except in compliance with the License.
##  You may obtain a copy of the License at
##
##      http://www.apache.org/licenses/LICENSE-2.0
##
##  Unless required by applicable law or agreed to in writing, software
##  distributed under the License is distributed on an "AS IS" BASIS,
##  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
##  See the License for the specific language governing permissions and
##  limitations under the License.
##
######################################################################
##  Notice
######################################################################
##  Copyright 2019 Trevor van Hoof and Jan Pijpers. All rights reserved.
##  Licensed under the Apache License, Version 2.0.
##  If you use any script from this website for the development of your tools or in your final product
##  please add the names Trevor van Hoof and Jan Pijpers to your special thanks list.
######################################################################

# -*- coding: utf-8 -*-

## Licensed under the Apache License, Version 2.0 (the "License");

## you may not use this file except in compliance with the License.

## You may obtain a copy of the License at

## http://www.apache.org/licenses/LICENSE-2.0

## Unless required by applicable law or agreed to in writing, software

## distributed under the License is distributed on an "AS IS" BASIS,

## WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

## See the License for the specific language governing permissions and

## limitations under the License.

######################################################################

## Notice

######################################################################

## Licensed under the Apache License, Version 2.0.

## If you use any script from this website for the development of your tools or in your final product

## please add the names Trevor van Hoof and Jan Pijpers to your special thanks list.

######################################################################

Fast(est?) get attr for each frame.

Posted on November 16, 2018 by Jan

*update. Found another method. still open maya with mdg time is faster. But this is not half bad.

T.L.D.R

the “om_plug_as_double_mdg_set_time” function is the fastest I could find.
be careful with currentTime eval=False and cmds.keyframe. Scroll down for the script.

Explanation:

Soooo I had to export a bunch of data (10k+ maya files) for some dataset.
Which forced me to find a fast way to export attrbutes per frame.
(And it also had to work in mayapy)

And I dint want to have to dive into a c++ plugin or anything.

So I compared a bunch of different ways that i know to getAttr and updating the maya time.

Problems:
1. Dont use cmds.currentTime(frameNr, eval=False) !!
This results in the attribute dg not being evaluated. sooooo its useless.

2. cmds.keyframe(attr, query=True, eval=True)
This only evaluates the active anim layer’s keyframe data.
And changing the active anim layer in mayapy is a nightmare soooo… yeah don’t use it. Also it only works if there are keyframes set. So a channel with a constraint will not return any value.

So for testing i made a simple sphere and 2 additive anim layers with some animation in them.

Timings with a sphere:

Shortest duration for each function tested 100 times:

cmds_get_attr_cmds_set_time 4.07231167047
cmds_get_attr_no_eval 0.142337732946 = ERROR RESULT IS NOT CORRECT!!!
cmds_get_attr_arg_time 0.188162308316
cmds_get_attr_om_set_time 0.367623159295
mel_get_attr 0.211408009643
pymel_get_attr_om_set_time 0.466954109253
pymel_get_attr_arg_time 0.274113534882
cmds_eval_keyframe_om_set_time 0.0870191721787 = WARNING RESULT IS NOT CORRECT WHEN USING ANIM LAYERS or no keyframes exist!!!
om_plug_as_double_om_set_time 0.159895729674 = FASTEST RESULT!

cmds_get_attr_cmds_set_time 4.07231167047

cmds_get_attr_no_eval 0.142337732946 = ERROR RESULT IS NOT CORRECT!!!

cmds_get_attr_arg_time 0.188162308316

cmds_get_attr_om_set_time 0.367623159295

mel_get_attr 0.211408009643

pymel_get_attr_om_set_time 0.466954109253

pymel_get_attr_arg_time 0.274113534882

cmds_eval_keyframe_om_set_time 0.0870191721787 = WARNING RESULT IS NOT CORRECT WHEN USING ANIM LAYERS or no keyframes exist!!!

om_plug_as_double_om_set_time 0.159895729674 = FASTEST RESULT!

Timing with a heavier scene with skinning and constraints.

cmds_get_attr_cmds_set_time 8.21378763774
cmds_get_attr_no_eval 0.0179609034819 = ERROR RESULT IS NOT CORRECT!!!
cmds_get_attr_arg_time 0.484571124028
cmds_get_attr_om_set_time 6.1720235551
mel_get_attr 0.494029596401
pymel_get_attr_om_set_time 6.14228203626
pymel_get_attr_arg_time 0.499620215035
cmds_eval_keyframe_om_set_time 0.00708293210846 = WARNING RESULT IS NOT CORRECT WHEN USING ANIM LAYERS or no keyframes exist!!!
om_plug_as_double_om_set_time 0.468321232931 = FASTEST RESULT!

cmds_get_attr_cmds_set_time 8.21378763774

cmds_get_attr_no_eval 0.0179609034819 = ERROR RESULT IS NOT CORRECT!!!

cmds_get_attr_arg_time 0.484571124028

cmds_get_attr_om_set_time 6.1720235551

mel_get_attr 0.494029596401

pymel_get_attr_om_set_time 6.14228203626

pymel_get_attr_arg_time 0.499620215035

cmds_eval_keyframe_om_set_time 0.00708293210846 = WARNING RESULT IS NOT CORRECT WHEN USING ANIM LAYERS or no keyframes exist!!!

om_plug_as_double_om_set_time 0.468321232931 = FASTEST RESULT!

Timing becomes more clear this way.

Code should mostly speak for itself.
If you have any questions just ask.

from maya.api import OpenMayaAnim
from maya.api import OpenMaya
from maya import mel
import inspect
import timeit
import pymel.core as pm
## Get the current UI Unit
uiUnit = OpenMaya.MTime.uiUnit()


#####
## Util functions
#####
def get_dep_node(n):
    return OpenMaya.MGlobal.getSelectionListByName(n).getDependNode(0)


################################
## Get attr methods
################################
def cmds_get_attr_cmds_set_time(obj, attr):
    '''
    The normal method of getting an attribute.

    :param obj: object string name i.e. "pSphere1"
    :param attr: the attribute to check i.e. "tx"
    :return: a list of values per frame.
    '''
    fullName = "%s.%s" % (obj, attr)
    values = []
    for frameNr in xrange(20):
        cmds.currentTime(frameNr)
        value = cmds.getAttr(fullName)
        values.append(value)
    return values


def cmds_get_attr_no_eval(obj, attr):
    '''
    ERROR DOESNT EVAL THE ATTR SO NO DATA WILL CHANGE
    The normal method of getting an attribute but without updating the time
    Doesnt work correctly as the attribute does not update.

    :param obj: object string name i.e. "pSphere1"
    :param attr: the attribute to check i.e. "tx"
    :return: a list of values per frame.
    '''
    fullName = "%s.%s" % (obj, attr)
    values = []
    for frameNr in xrange(20):
        cmds.currentTime(frameNr, update=False)
        value = cmds.getAttr(fullName)
        values.append(value)
    return values

def cmds_get_attr_arg_time(obj, attr):
    '''
    The normal method of getting an attribute but without updating the time
    but using the time argument of the get attr.
    Definitly the fastest method if you dont want to use open maya.


    :param obj: object string name i.e. "pSphere1"
    :param attr: the attribute to check i.e. "tx"
    :return: a list of values per frame.
    '''
    fullName = "%s.%s" % (obj, attr)
    values = []
    for frameNr in xrange(20):
        value = cmds.getAttr(fullName, time = frameNr)
        values.append(value)
    return values

def cmds_get_attr_om_set_time(obj, attr):
    '''
    Normal get attr but
    using open maya to change the time.

    :param obj: object string name i.e. "pSphere1"
    :param attr: the attribute to check i.e. "tx"
    :return: a list of values per frame.
    '''
    fullName = "%s.%s" % (obj, attr)
    values = []
    for frameNr in xrange(20):
        OpenMayaAnim.MAnimControl.setCurrentTime(OpenMaya.MTime(frameNr, uiUnit))
        value = cmds.getAttr(fullName)
        values.append(value)
    return values


def mel_get_attr(obj, attr):
    '''
    Using mel get attr.
    using open maya to change the time.

    :param obj: object string name i.e. "pSphere1"
    :param attr: the attribute to check i.e. "tx"
    :return: a list of values per frame.
    '''
    ## Slight speed optimisation, this way we dont have to construct the string every time.
    fullName = "getAttr -time %s "+obj+"."+attr
    values = []
    for frameNr in xrange(20):
        #OpenMayaAnim.MAnimControl.setCurrentTime(OpenMaya.MTime(frameNr, uiUnit))
        value = mel.eval(fullName%frameNr)
        values.append(value)
    return values


def pymel_get_attr_om_set_time(obj, attr):
    '''
    Using pymel get with openmaya set time.
    pymel basically uses the openmaya api so should be faster.

    :param obj: object string name i.e. "pSphere1"
    :param attr: the attribute to check i.e. "tx"
    :return: a list of values per frame.
    '''
    ## Slight speed optimisation, this way we dont have to construct the string every time.
    pmAttr = pm.PyNode("%s.%s" % (obj, attr))
    values = []
    for frameNr in xrange(20):
        OpenMayaAnim.MAnimControl.setCurrentTime(OpenMaya.MTime(frameNr, uiUnit))
        value = pmAttr.get()
        values.append(value)
    return values


def pymel_get_attr_arg_time(obj, attr):
    '''
    Using pymel get with passing time as argument
    pymel basically uses the openmaya api so should be faster.
    Definitly faster as setting time with maya api

    :param obj: object string name i.e. "pSphere1"
    :param attr: the attribute to check i.e. "tx"
    :return: a list of values per frame.
    '''
    ## Slight speed optimisation, this way we dont have to construct the string every time.
    pmAttr = pm.PyNode("%s.%s" % (obj, attr))
    values = []
    for frameNr in xrange(20):
        value = pmAttr.get(time=frameNr)
        values.append(value)
    return values

def cmds_eval_keyframe_om_set_time(obj, attr):
    '''
    WARNING DOESNT EVAL CORRECTLY WITH MULTIPLE ANIM LAYERS!!
    Use the cmds.keyframe function to evaluate the keyframe.
    Its really fast! but .... doesnt eval correctly with anim layers.

    :param obj: object string name i.e. "pSphere1"
    :param attr: the attribute to check i.e. "tx"
    :return: a list of values per frame.
    '''
    fullName = "%s.%s" % (obj, attr)
    values = []
    for frameNr in xrange(20):
        value = cmds.keyframe(fullName, query=True, eval=True, t=(frameNr,)) or 0
        values.append(value)

    return values

def om_plug_as_double_mdg_set_time(obj, attr):
    '''
    Getting the plug from openMaya.
    Then create a time mdgContext and evaluate it.
    This is the fastest with layer compatability... however i suspect there to be issues when doing complex simulations.

    :param obj: object string name i.e. "pSphere1"
    :param attr: the attribute to check i.e. "tx"
    :return: a list of values per frame.
    '''

    values = []
    obj = get_dep_node(obj)
    objMfn = OpenMaya.MFnDependencyNode(obj)
    ## Get the plug of the node. (networkedplug = False, as it no longer profides a speed improvement)
    plug = objMfn.findPlug(attr, False)
    for frameNr in xrange(20):
        ## The creaction of the MDG context takes the longest!
        mdg = OpenMaya.MDGContext(OpenMaya.MTime(frameNr, uiUnit))
        value = plug.asDouble(mdg)
        values.append(value )
    return values



## Put all functions in a nice list
fList = [cmds_get_attr_cmds_set_time, cmds_get_attr_no_eval, cmds_get_attr_arg_time,
         cmds_get_attr_om_set_time, mel_get_attr, pymel_get_attr_om_set_time,
         pymel_get_attr_arg_time, cmds_eval_keyframe_om_set_time, om_plug_as_double_mdg_set_time]

## Prepare some constants
obj = "pSphere1"
attr = "tx"

## Start testing all results
resultList = []
print "Duration for each function 100 times: "
for f in fList:
    ## Using the timeit module to check how long the functions last
    duration = timeit.timeit(f.__name__ + "('%s','%s')" % (obj, attr), setup="from __main__ import %s" % f.__name__, number=10)
    ## Run it once more to get the actual results
    result = f(obj, attr)
    ## Store the results in a list
    resultList.append(result)
    ## And report the total duration.
    print "\t", f.__name__, duration

print "Accuracy comparison: "
for index, results in enumerate( resultList[1:]):
    print "Function Name: ",fList[index+1].__name__
    for rIndex, result in enumerate( results ):
        print "\t", result - resultList[0][rIndex]

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

from maya.api import OpenMayaAnim

from maya.api import OpenMaya

from maya import mel

import inspect

import timeit

import pymel.core as pm

## Get the current UI Unit

uiUnit = OpenMaya.MTime.uiUnit()

#####

## Util functions

#####

def get_dep_node(n):

return OpenMaya.MGlobal.getSelectionListByName(n).getDependNode(0)

################################

## Get attr methods

################################

def cmds_get_attr_cmds_set_time(obj, attr):

'''

The normal method of getting an attribute.

:param obj: object string name i.e. "pSphere1"

:param attr: the attribute to check i.e. "tx"

:return: a list of values per frame.

'''

fullName = "%s.%s" % (obj, attr)

values = []

for frameNr in xrange(20):

cmds.currentTime(frameNr)

value = cmds.getAttr(fullName)

values.append(value)

return values

def cmds_get_attr_no_eval(obj, attr):

'''

ERROR DOESNT EVAL THE ATTR SO NO DATA WILL CHANGE

The normal method of getting an attribute but without updating the time

Doesnt work correctly as the attribute does not update.

:param obj: object string name i.e. "pSphere1"

:param attr: the attribute to check i.e. "tx"

:return: a list of values per frame.

'''

fullName = "%s.%s" % (obj, attr)

values = []

for frameNr in xrange(20):

cmds.currentTime(frameNr, update=False)

value = cmds.getAttr(fullName)

values.append(value)

return values

def cmds_get_attr_arg_time(obj, attr):

'''

The normal method of getting an attribute but without updating the time

but using the time argument of the get attr.

Definitly the fastest method if you dont want to use open maya.

:param obj: object string name i.e. "pSphere1"

:param attr: the attribute to check i.e. "tx"

:return: a list of values per frame.

'''

fullName = "%s.%s" % (obj, attr)

values = []

for frameNr in xrange(20):

value = cmds.getAttr(fullName, time = frameNr)

values.append(value)

return values

def cmds_get_attr_om_set_time(obj, attr):

'''

Normal get attr but

using open maya to change the time.

:param obj: object string name i.e. "pSphere1"

:param attr: the attribute to check i.e. "tx"

:return: a list of values per frame.

'''

fullName = "%s.%s" % (obj, attr)

values = []

for frameNr in xrange(20):

OpenMayaAnim.MAnimControl.setCurrentTime(OpenMaya.MTime(frameNr, uiUnit))

value = cmds.getAttr(fullName)

values.append(value)

return values

def mel_get_attr(obj, attr):

'''

Using mel get attr.

using open maya to change the time.

:param obj: object string name i.e. "pSphere1"

:param attr: the attribute to check i.e. "tx"

:return: a list of values per frame.

'''

## Slight speed optimisation, this way we dont have to construct the string every time.

fullName = "getAttr -time %s "+obj+"."+attr

values = []

for frameNr in xrange(20):

#OpenMayaAnim.MAnimControl.setCurrentTime(OpenMaya.MTime(frameNr, uiUnit))

value = mel.eval(fullName%frameNr)

values.append(value)

return values

def pymel_get_attr_om_set_time(obj, attr):

'''

Using pymel get with openmaya set time.

pymel basically uses the openmaya api so should be faster.

:param obj: object string name i.e. "pSphere1"

:param attr: the attribute to check i.e. "tx"

:return: a list of values per frame.

'''

## Slight speed optimisation, this way we dont have to construct the string every time.

pmAttr = pm.PyNode("%s.%s" % (obj, attr))

values = []

for frameNr in xrange(20):

OpenMayaAnim.MAnimControl.setCurrentTime(OpenMaya.MTime(frameNr, uiUnit))

value = pmAttr.get()

values.append(value)

return values

def pymel_get_attr_arg_time(obj, attr):

'''

Using pymel get with passing time as argument

pymel basically uses the openmaya api so should be faster.

Definitly faster as setting time with maya api

:param obj: object string name i.e. "pSphere1"

:param attr: the attribute to check i.e. "tx"

:return: a list of values per frame.

'''

## Slight speed optimisation, this way we dont have to construct the string every time.

pmAttr = pm.PyNode("%s.%s" % (obj, attr))

values = []

for frameNr in xrange(20):

value = pmAttr.get(time=frameNr)

values.append(value)

return values

def cmds_eval_keyframe_om_set_time(obj, attr):

'''

WARNING DOESNT EVAL CORRECTLY WITH MULTIPLE ANIM LAYERS!!

Use the cmds.keyframe function to evaluate the keyframe.

Its really fast! but .... doesnt eval correctly with anim layers.

:param obj: object string name i.e. "pSphere1"

:param attr: the attribute to check i.e. "tx"

:return: a list of values per frame.

'''

fullName = "%s.%s" % (obj, attr)

values = []

for frameNr in xrange(20):

value = cmds.keyframe(fullName, query=True, eval=True, t=(frameNr,)) or 0

values.append(value)

return values

def om_plug_as_double_mdg_set_time(obj, attr):

'''

Getting the plug from openMaya.

Then create a time mdgContext and evaluate it.

This is the fastest with layer compatability... however i suspect there to be issues when doing complex simulations.

:param obj: object string name i.e. "pSphere1"

:param attr: the attribute to check i.e. "tx"

:return: a list of values per frame.

'''

values = []

obj = get_dep_node(obj)

objMfn = OpenMaya.MFnDependencyNode(obj)

## Get the plug of the node. (networkedplug = False, as it no longer profides a speed improvement)

plug = objMfn.findPlug(attr, False)

for frameNr in xrange(20):

## The creaction of the MDG context takes the longest!

mdg = OpenMaya.MDGContext(OpenMaya.MTime(frameNr, uiUnit))

value = plug.asDouble(mdg)

values.append(value )

return values

## Put all functions in a nice list

fList = [cmds_get_attr_cmds_set_time, cmds_get_attr_no_eval, cmds_get_attr_arg_time,

cmds_get_attr_om_set_time, mel_get_attr, pymel_get_attr_om_set_time,

pymel_get_attr_arg_time, cmds_eval_keyframe_om_set_time, om_plug_as_double_mdg_set_time]

## Prepare some constants

obj = "pSphere1"

attr = "tx"

## Start testing all results

resultList = []

print "Duration for each function 100 times: "

for f in fList:

## Using the timeit module to check how long the functions last

duration = timeit.timeit(f.__name__ + "('%s','%s')" % (obj, attr), setup="from __main__ import %s" % f.__name__, number=10)

## Run it once more to get the actual results

result = f(obj, attr)

## Store the results in a list

resultList.append(result)

## And report the total duration.

print "\t", f.__name__, duration

print "Accuracy comparison: "

for index, results in enumerate( resultList[1:]):

print "Function Name: ",fList[index+1].__name__

for rIndex, result in enumerate( results ):

print "\t", result - resultList[0][rIndex]

Finding vertex groups in maya.

Posted on March 28, 2017 by Jan

So a while ago a friend of mine, Perry Leijten, asked me to help out with seemingly a simple problem for his awesome skinning tools.

*Which you can find here btw: https://gumroad.com/peerke#

The problem being:

“I want to sort my selection of vertices in groups.”

i.e. all neighboring vertices in separate groups.

Simple enough i thought and had a crack at it.

…

Lots of hair later, 4am, birds chirping and I had a working version… that being immensely slow. After some tinkering and brainstorming we had a version that could do vertex sorting on a 40k vertex mesh in about 1 second.

This got implemented in his skinning tools. Now about 6 months later I revisited the problem and got a speed improvement of about 70%. Sooo I thought it would be nice to make a post about it.

Hopefully the comments in the code speak for themselves.

If not and you have any questions feel free to ask in the comments.

To test it do the following:

1. Create a poly sphere in maya .

2. set it to 200×200 subdivisions

3. run the script

import maya.OpenMaya as oldOpenMaya
import collections 
import time 
from maya import mel 

## Util needed for the old maya vertex itter. 
M_SCRIPT_UTIL = oldOpenMaya.MScriptUtil()
            
def getVertexGroups( mesh, vtxSelectionSet):
    '''
        This system finds vertex groups. 
        
        To solve a problem like this I like to think in analogies to remember the steps a bit better. ^_^ 
        
        So a vertex is a house number, and the connecting vertices are neighbors. 
        
        Think of it as neighbors living in houses but the city planing is horrible!. 
        City planning wants to divide the people in districts. 
        
        But they messed up the house numbers so they dont know who lives near who. 
        
        So we have have a list of house numbers and we want divide them into groups!
        i.e. list: 1,24,42,1337,...
                                
            We will ask house nr 1 if they have a moment to talk about ... their neighbors. 
                We ask on what number their neighbors live and we write everything down in our BIG NOTEBOOK. 
                    i.e. So house 1 is connected to neighbor 2,3,10,22 and 42
                    If one of these neighbors is in our list (Lets say nr 42) 
                        We walk over to this neighbor and ask the same question.
                        etc etc. 
                    When we no longer find any neighbors that are connected, we tear off the paper from the BIG NOTEBOOK and continue on the next. 
                        And call this group district one. 
                Now we go to house nr 2. 
                    We check if we already talked to house nr 2 while looking at neighbors!. 
                    If we did, we will go to nr3 etc. 

    '''
    
    
    ## Creates a selection list (doesn't actually get anything yet) 
    selList = oldOpenMaya.MSelectionList()
    ## Adds the mesh to the list 
    selList.add(mesh)
    ## Old style maya create an object 
    mObject = oldOpenMaya.MObject()
    ## Get the dependancy node and put it into the mObject
    selList.getDependNode(0, mObject)

    ## Create a vertex itterator loop. 
    iterVertLoop = oldOpenMaya.MItMeshVertex(mObject)
    
    ## Empty set to keep track of who we talked to. 
    talkedToNeighbours = set() 
    
    districtList = [] ## < OUR BIG NOTEBOOK!!!
    
            
    ## For every index in our provided set. Get the connecting / neighboring vertices. 
    for currentIndex in vtxSelectionSet:
        
        ## An empty set that holds all house numbers. 
        districtHouses = set() 
        ## If our current index is not in the talked to list. We can process it. 
        if not currentIndex in talkedToNeighbours:
            ## this nr is part of our list and not seen before. 
            ## so we add it to the district
            districtHouses.add( currentIndex )
            currentNeighbours = getNeighbours(iterVertLoop, currentIndex)
            
            ## As long as we have neighbours we need to keep asking around. 
            while currentNeighbours:
                ## Empty set to keep track of all the new neighbours we are about to find. 
                newNeighbours = set() 
                ## For each neighbour we currently know of. 
                for neighbour in currentNeighbours:
                    ## If they are on our list and we have not talked to them before. 
                    if neighbour in vtxSelectionSet and not neighbour in talkedToNeighbours:
                        talkedToNeighbours.add(neighbour) ## Note down we talked to them 
                        districtHouses.add(neighbour) ## Add them to our current district. 
                        
                        ## Add all their neighbours to the new neighbours list...
                        newNeighbours = newNeighbours.union(getNeighbours(iterVertLoop, neighbour)) 
                        
                ## We are done with asking all the neigbours we knew of ... so now we continue with all the new ones we found. 
                currentNeighbours = newNeighbours
                
            districtList.append( districtHouses )## << Write down data in our big notebook 
        

    return sorted(districtList, key = lambda x:min(x))

def getNeighbours( mVtxItter, index):
    mVtxItter.setIndex( index, M_SCRIPT_UTIL.asIntPtr()) 
    intArray = oldOpenMaya.MIntArray()
    mVtxItter.getConnectedVertices(intArray)
    return set(int(x) for x in intArray)


## First make a poly sphere of 200 Subdivision Axes and 200 Subdivision height. 
## then run this script. 
## Mock selection of vertecies. 
mel.eval("select -replace pSphere1.vtx[8000:9000] pSphere1.vtx[10000:12000] pSphere1.vtx[15338:15345] pSphere1.vtx[15538:15545] pSphere1.vtx[15738:15745] pSphere1.vtx[15938:15945] pSphere1.vtx[16138:16145] pSphere1.vtx[16338:16345] pSphere1.vtx[16538:16545] pSphere1.vtx[16738:16745] pSphere1.vtx[16938:16945] pSphere1.vtx[17138:17145] pSphere1.vtx[17338:17345] pSphere1.vtx[17361] pSphere1.vtx[17518:17519] pSphere1.vtx[17538:17545] pSphere1.vtx[17561:17565] pSphere1.vtx[17714:17719] pSphere1.vtx[17761:17768] pSphere1.vtx[17911:17919] pSphere1.vtx[17961:17968] pSphere1.vtx[18107:18119] pSphere1.vtx[18161:18168] pSphere1.vtx[18304:18319] pSphere1.vtx[18361:18367] pSphere1.vtx[18433:18446] pSphere1.vtx[18501:18519] pSphere1.vtx[18561:18567] pSphere1.vtx[18633:18646] pSphere1.vtx[18699:18719] pSphere1.vtx[18761:18767] pSphere1.vtx[18833:18846] pSphere1.vtx[18896:18919] pSphere1.vtx[18961:18967] pSphere1.vtx[19033:19046] pSphere1.vtx[19093:19118] pSphere1.vtx[19164:19167] pSphere1.vtx[19233:19246] pSphere1.vtx[19290:19315] pSphere1.vtx[19367] pSphere1.vtx[19433:19446] pSphere1.vtx[19487:19512] pSphere1.vtx[19633:19646] pSphere1.vtx[19685:19709] pSphere1.vtx[19797:19802] pSphere1.vtx[19833:19846] pSphere1.vtx[19882:19907] pSphere1.vtx[19997:20005] pSphere1.vtx[20033:20046] pSphere1.vtx[20079:20104] pSphere1.vtx[20197:20207] pSphere1.vtx[20233:20246] pSphere1.vtx[20278:20302] pSphere1.vtx[20397:20407] pSphere1.vtx[20433:20446] pSphere1.vtx[20478:20500] pSphere1.vtx[20597:20607] pSphere1.vtx[20633:20646] pSphere1.vtx[20678:20698] pSphere1.vtx[20797:20807] pSphere1.vtx[20833:20846] pSphere1.vtx[20878:20895] pSphere1.vtx[20997:21007] pSphere1.vtx[21033:21046] pSphere1.vtx[21078:21093] pSphere1.vtx[21197:21207] pSphere1.vtx[21233:21246] pSphere1.vtx[21278:21291] pSphere1.vtx[21397:21407] pSphere1.vtx[21433:21446] pSphere1.vtx[21478:21489] pSphere1.vtx[21597:21607] pSphere1.vtx[21633:21646] pSphere1.vtx[21678:21687] pSphere1.vtx[21797:21807] pSphere1.vtx[21833:21846] pSphere1.vtx[21878:21885] pSphere1.vtx[21998:22006] pSphere1.vtx[22033:22046] pSphere1.vtx[22078:22082] pSphere1.vtx[22202:22206] pSphere1.vtx[22233:22246] pSphere1.vtx[22279:22280] pSphere1.vtx[22404:22406] pSphere1.vtx[22433:22446] pSphere1.vtx[22633:22646] pSphere1.vtx[25531:25533] pSphere1.vtx[25557:25559] pSphere1.vtx[25727:25733] pSphere1.vtx[25757:25762] pSphere1.vtx[25923:25933] pSphere1.vtx[25958:25964] pSphere1.vtx[26122:26133] pSphere1.vtx[26158:26167] pSphere1.vtx[26322:26333] pSphere1.vtx[26358:26369] pSphere1.vtx[26522:26533] pSphere1.vtx[26558:26571] pSphere1.vtx[26722:26733] pSphere1.vtx[26758:26773] pSphere1.vtx[26921:26933] pSphere1.vtx[26959:26975] pSphere1.vtx[27121:27133] pSphere1.vtx[27159:27177] pSphere1.vtx[27321:27332] pSphere1.vtx[27359:27379] pSphere1.vtx[27520:27532] pSphere1.vtx[27559:27581] pSphere1.vtx[27720:27732] pSphere1.vtx[27760:27783] pSphere1.vtx[27920:27932] pSphere1.vtx[27960:27985] pSphere1.vtx[28119:28132] pSphere1.vtx[28160:28187] pSphere1.vtx[28319:28332] pSphere1.vtx[28361:28388] pSphere1.vtx[28519:28532] pSphere1.vtx[28561:28590] pSphere1.vtx[28718:28732] pSphere1.vtx[28761:28792] pSphere1.vtx[28918:28931] pSphere1.vtx[28962:28994] pSphere1.vtx[29117:29131] pSphere1.vtx[29162:29196] pSphere1.vtx[29317:29331] pSphere1.vtx[29363:29398] pSphere1.vtx[29400] pSphere1.vtx[29516:29531] pSphere1.vtx[29565:29602] pSphere1.vtx[29715:29731] pSphere1.vtx[29767:29805] pSphere1.vtx[29915:29931] pSphere1.vtx[29969:30007] pSphere1.vtx[30114:30130] pSphere1.vtx[30170:30210] pSphere1.vtx[30313:30330] pSphere1.vtx[30372:30411] pSphere1.vtx[30512:30530] pSphere1.vtx[30574:30610] pSphere1.vtx[30674:30676] pSphere1.vtx[30712:30730] pSphere1.vtx[30775:30810] pSphere1.vtx[30871:30877] pSphere1.vtx[30911:30930] pSphere1.vtx[30977:31009] pSphere1.vtx[31068:31079] pSphere1.vtx[31109:31129] pSphere1.vtx[31178:31208] pSphere1.vtx[31265:31280] pSphere1.vtx[31308:31329] pSphere1.vtx[31380:31407] pSphere1.vtx[31461:31481] pSphere1.vtx[31507:31529] pSphere1.vtx[31581:31606] pSphere1.vtx[31657:31683] pSphere1.vtx[31705:31729] pSphere1.vtx[31783:31805] pSphere1.vtx[31856:31885] pSphere1.vtx[31903:31928] pSphere1.vtx[31985:32004] pSphere1.vtx[32056:32089] pSphere1.vtx[32099:32128] pSphere1.vtx[32186:32203] pSphere1.vtx[32257:32328] pSphere1.vtx[32388:32401] pSphere1.vtx[32457:32527] pSphere1.vtx[32589:32599] pSphere1.vtx[32658:32727] pSphere1.vtx[32791:32799] pSphere1.vtx[32858:32926] pSphere1.vtx[32993:32997] pSphere1.vtx[33058:33126] pSphere1.vtx[33259:33326] pSphere1.vtx[33459:33525] pSphere1.vtx[33660:33724] pSphere1.vtx[33861:33924] pSphere1.vtx[34061:34123] pSphere1.vtx[34262:34323] pSphere1.vtx[34463:34522] pSphere1.vtx[34663:34721] pSphere1.vtx[34864:34920] pSphere1.vtx[35065:35119] pSphere1.vtx[35267:35318] pSphere1.vtx[35468:35516] pSphere1.vtx[35669:35715] pSphere1.vtx[35871:35913] pSphere1.vtx[36073:36111] pSphere1.vtx[36276:36308] pSphere1.vtx[36479:36505] pSphere1.vtx[36685:36699]")

## Get all vtx in set. (We dont care about the order. So set is faster then list.) 
## Using cmds and string conversion, as its faster then pymel. 
vtxSelectionSet = set( [int(x.split(".vtx[")[-1][:-1]) for x in set(cmds.ls(sl=True, o=False, fl = True)) - set(cmds.ls(sl=True, o=True))])
meshName = "pSphere1"


## Start a simple timer to know how long it takes. 
start = time.time() 

vertexGroups = getVertexGroups(meshName, vtxSelectionSet) 
   
print "Duration: %s seconds" %str(time.time()- start )

for groep, entries in enumerate(vertexGroups):
    print "Groep : " ,groep
    print "\tMin : " ,min(entries)
    print "\tMax : " ,max(entries)

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

import maya.OpenMaya as oldOpenMaya

import collections

import time

from maya import mel

## Util needed for the old maya vertex itter.

M_SCRIPT_UTIL = oldOpenMaya.MScriptUtil()

def getVertexGroups( mesh, vtxSelectionSet):

'''

This system finds vertex groups.

To solve a problem like this I like to think in analogies to remember the steps a bit better. ^_^

So a vertex is a house number, and the connecting vertices are neighbors.

Think of it as neighbors living in houses but the city planing is horrible!.

City planning wants to divide the people in districts.

But they messed up the house numbers so they dont know who lives near who.

So we have have a list of house numbers and we want divide them into groups!

i.e. list: 1,24,42,1337,...

We will ask house nr 1 if they have a moment to talk about ... their neighbors.

We ask on what number their neighbors live and we write everything down in our BIG NOTEBOOK.

i.e. So house 1 is connected to neighbor 2,3,10,22 and 42

If one of these neighbors is in our list (Lets say nr 42)

We walk over to this neighbor and ask the same question.

etc etc.

When we no longer find any neighbors that are connected, we tear off the paper from the BIG NOTEBOOK and continue on the next.

And call this group district one.

Now we go to house nr 2.

We check if we already talked to house nr 2 while looking at neighbors!.

If we did, we will go to nr3 etc.

'''

## Creates a selection list (doesn't actually get anything yet)

selList = oldOpenMaya.MSelectionList()

## Adds the mesh to the list

selList.add(mesh)

## Old style maya create an object

mObject = oldOpenMaya.MObject()

## Get the dependancy node and put it into the mObject

selList.getDependNode(0, mObject)

## Create a vertex itterator loop.

iterVertLoop = oldOpenMaya.MItMeshVertex(mObject)

## Empty set to keep track of who we talked to.

talkedToNeighbours = set()

districtList = [] ## < OUR BIG NOTEBOOK!!!

## For every index in our provided set. Get the connecting / neighboring vertices.

for currentIndex in vtxSelectionSet:

## An empty set that holds all house numbers.

districtHouses = set()

## If our current index is not in the talked to list. We can process it.

if not currentIndex in talkedToNeighbours:

## this nr is part of our list and not seen before.

## so we add it to the district

districtHouses.add( currentIndex )

currentNeighbours = getNeighbours(iterVertLoop, currentIndex)

## As long as we have neighbours we need to keep asking around.

while currentNeighbours:

## Empty set to keep track of all the new neighbours we are about to find.

newNeighbours = set()

## For each neighbour we currently know of.

for neighbour in currentNeighbours:

## If they are on our list and we have not talked to them before.

if neighbour in vtxSelectionSet and not neighbour in talkedToNeighbours:

talkedToNeighbours.add(neighbour) ## Note down we talked to them

districtHouses.add(neighbour) ## Add them to our current district.

## Add all their neighbours to the new neighbours list...

newNeighbours = newNeighbours.union(getNeighbours(iterVertLoop, neighbour))

## We are done with asking all the neigbours we knew of ... so now we continue with all the new ones we found.

currentNeighbours = newNeighbours

districtList.append( districtHouses )## << Write down data in our big notebook

return sorted(districtList, key = lambda x:min(x))

def getNeighbours( mVtxItter, index):

mVtxItter.setIndex( index, M_SCRIPT_UTIL.asIntPtr())

intArray = oldOpenMaya.MIntArray()

mVtxItter.getConnectedVertices(intArray)

return set(int(x) for x in intArray)

## First make a poly sphere of 200 Subdivision Axes and 200 Subdivision height.

## then run this script.

## Mock selection of vertecies.

mel.eval("select -replace pSphere1.vtx[8000:9000] pSphere1.vtx[10000:12000] pSphere1.vtx[15338:15345] pSphere1.vtx[15538:15545] pSphere1.vtx[15738:15745] pSphere1.vtx[15938:15945] pSphere1.vtx[16138:16145] pSphere1.vtx[16338:16345] pSphere1.vtx[16538:16545] pSphere1.vtx[16738:16745] pSphere1.vtx[16938:16945] pSphere1.vtx[17138:17145] pSphere1.vtx[17338:17345] pSphere1.vtx[17361] pSphere1.vtx[17518:17519] pSphere1.vtx[17538:17545] pSphere1.vtx[17561:17565] pSphere1.vtx[17714:17719] pSphere1.vtx[17761:17768] pSphere1.vtx[17911:17919] pSphere1.vtx[17961:17968] pSphere1.vtx[18107:18119] pSphere1.vtx[18161:18168] pSphere1.vtx[18304:18319] pSphere1.vtx[18361:18367] pSphere1.vtx[18433:18446] pSphere1.vtx[18501:18519] pSphere1.vtx[18561:18567] pSphere1.vtx[18633:18646] pSphere1.vtx[18699:18719] pSphere1.vtx[18761:18767] pSphere1.vtx[18833:18846] pSphere1.vtx[18896:18919] pSphere1.vtx[18961:18967] pSphere1.vtx[19033:19046] pSphere1.vtx[19093:19118] pSphere1.vtx[19164:19167] pSphere1.vtx[19233:19246] pSphere1.vtx[19290:19315] pSphere1.vtx[19367] pSphere1.vtx[19433:19446] pSphere1.vtx[19487:19512] pSphere1.vtx[19633:19646] pSphere1.vtx[19685:19709] pSphere1.vtx[19797:19802] pSphere1.vtx[19833:19846] pSphere1.vtx[19882:19907] pSphere1.vtx[19997:20005] pSphere1.vtx[20033:20046] pSphere1.vtx[20079:20104] pSphere1.vtx[20197:20207] pSphere1.vtx[20233:20246] pSphere1.vtx[20278:20302] pSphere1.vtx[20397:20407] pSphere1.vtx[20433:20446] pSphere1.vtx[20478:20500] pSphere1.vtx[20597:20607] pSphere1.vtx[20633:20646] pSphere1.vtx[20678:20698] pSphere1.vtx[20797:20807] pSphere1.vtx[20833:20846] pSphere1.vtx[20878:20895] pSphere1.vtx[20997:21007] pSphere1.vtx[21033:21046] pSphere1.vtx[21078:21093] pSphere1.vtx[21197:21207] pSphere1.vtx[21233:21246] pSphere1.vtx[21278:21291] pSphere1.vtx[21397:21407] pSphere1.vtx[21433:21446] pSphere1.vtx[21478:21489] pSphere1.vtx[21597:21607] pSphere1.vtx[21633:21646] pSphere1.vtx[21678:21687] pSphere1.vtx[21797:21807] pSphere1.vtx[21833:21846] pSphere1.vtx[21878:21885] pSphere1.vtx[21998:22006] pSphere1.vtx[22033:22046] pSphere1.vtx[22078:22082] pSphere1.vtx[22202:22206] pSphere1.vtx[22233:22246] pSphere1.vtx[22279:22280] pSphere1.vtx[22404:22406] pSphere1.vtx[22433:22446] pSphere1.vtx[22633:22646] pSphere1.vtx[25531:25533] pSphere1.vtx[25557:25559] pSphere1.vtx[25727:25733] pSphere1.vtx[25757:25762] pSphere1.vtx[25923:25933] pSphere1.vtx[25958:25964] pSphere1.vtx[26122:26133] pSphere1.vtx[26158:26167] pSphere1.vtx[26322:26333] pSphere1.vtx[26358:26369] pSphere1.vtx[26522:26533] pSphere1.vtx[26558:26571] pSphere1.vtx[26722:26733] pSphere1.vtx[26758:26773] pSphere1.vtx[26921:26933] pSphere1.vtx[26959:26975] pSphere1.vtx[27121:27133] pSphere1.vtx[27159:27177] pSphere1.vtx[27321:27332] pSphere1.vtx[27359:27379] pSphere1.vtx[27520:27532] pSphere1.vtx[27559:27581] pSphere1.vtx[27720:27732] pSphere1.vtx[27760:27783] pSphere1.vtx[27920:27932] pSphere1.vtx[27960:27985] pSphere1.vtx[28119:28132] pSphere1.vtx[28160:28187] pSphere1.vtx[28319:28332] pSphere1.vtx[28361:28388] pSphere1.vtx[28519:28532] pSphere1.vtx[28561:28590] pSphere1.vtx[28718:28732] pSphere1.vtx[28761:28792] pSphere1.vtx[28918:28931] pSphere1.vtx[28962:28994] pSphere1.vtx[29117:29131] pSphere1.vtx[29162:29196] pSphere1.vtx[29317:29331] pSphere1.vtx[29363:29398] pSphere1.vtx[29400] pSphere1.vtx[29516:29531] pSphere1.vtx[29565:29602] pSphere1.vtx[29715:29731] pSphere1.vtx[29767:29805] pSphere1.vtx[29915:29931] pSphere1.vtx[29969:30007] pSphere1.vtx[30114:30130] pSphere1.vtx[30170:30210] pSphere1.vtx[30313:30330] pSphere1.vtx[30372:30411] pSphere1.vtx[30512:30530] pSphere1.vtx[30574:30610] pSphere1.vtx[30674:30676] pSphere1.vtx[30712:30730] pSphere1.vtx[30775:30810] pSphere1.vtx[30871:30877] pSphere1.vtx[30911:30930] pSphere1.vtx[30977:31009] pSphere1.vtx[31068:31079] pSphere1.vtx[31109:31129] pSphere1.vtx[31178:31208] pSphere1.vtx[31265:31280] pSphere1.vtx[31308:31329] pSphere1.vtx[31380:31407] pSphere1.vtx[31461:31481] pSphere1.vtx[31507:31529] pSphere1.vtx[31581:31606] pSphere1.vtx[31657:31683] pSphere1.vtx[31705:31729] pSphere1.vtx[31783:31805] pSphere1.vtx[31856:31885] pSphere1.vtx[31903:31928] pSphere1.vtx[31985:32004] pSphere1.vtx[32056:32089] pSphere1.vtx[32099:32128] pSphere1.vtx[32186:32203] pSphere1.vtx[32257:32328] pSphere1.vtx[32388:32401] pSphere1.vtx[32457:32527] pSphere1.vtx[32589:32599] pSphere1.vtx[32658:32727] pSphere1.vtx[32791:32799] pSphere1.vtx[32858:32926] pSphere1.vtx[32993:32997] pSphere1.vtx[33058:33126] pSphere1.vtx[33259:33326] pSphere1.vtx[33459:33525] pSphere1.vtx[33660:33724] pSphere1.vtx[33861:33924] pSphere1.vtx[34061:34123] pSphere1.vtx[34262:34323] pSphere1.vtx[34463:34522] pSphere1.vtx[34663:34721] pSphere1.vtx[34864:34920] pSphere1.vtx[35065:35119] pSphere1.vtx[35267:35318] pSphere1.vtx[35468:35516] pSphere1.vtx[35669:35715] pSphere1.vtx[35871:35913] pSphere1.vtx[36073:36111] pSphere1.vtx[36276:36308] pSphere1.vtx[36479:36505] pSphere1.vtx[36685:36699]")

## Get all vtx in set. (We dont care about the order. So set is faster then list.)

## Using cmds and string conversion, as its faster then pymel.

vtxSelectionSet = set( [int(x.split(".vtx[")[-1][:-1]) for x in set(cmds.ls(sl=True, o=False, fl = True)) - set(cmds.ls(sl=True, o=True))])

meshName = "pSphere1"

## Start a simple timer to know how long it takes.

start = time.time()

vertexGroups = getVertexGroups(meshName, vtxSelectionSet)

print "Duration: %s seconds" %str(time.time()- start )

for groep, entries in enumerate(vertexGroups):

print "Groep : " ,groep

print "\tMin : " ,min(entries)

print "\tMax : " ,max(entries)

Moshi-moshi? Yes C++ speaking … Hi its Python. (ctypes python to c++ )

Posted on October 2, 2015 by Jan

Because sometimes python is not complex enough ….

Recently I had a task to connect to an existing server to get some data via python so I had two options. Handle all connections myself, communicate with the database in python, cross fingers and hope I would not break anything.

ORRR find a way to call C++ from python and use the existing libraries.

I opted to look into the second solution as it gave me a nice opportunity to research something new. The main thing for me was:

1) Easy to understand. (I am not a hardcore c++ coder)
2) No external dependencies. Just standard python and standard C++.
3) My brain should not explode while trying to get this done !!( Very important and very underestimated requirement)

Seeing as there were only a few beginner resources about this online I thought I’d make a step by step tutorial about it now that I kind of figured it out :). I can’t show how I implemented it with existing code but hopefully the example should make you understand how to do the same.

*side note:
seeing as I’m not a C++ expert I’d like to note that my C++ code might not be perfect but hopefully it will help you understand.

If you want to start learning more on C++ I recommend this resource (most corny website name ever but their basic tutorials on c++ are great):
http://www.gametutorials.com/

Their opening line usually is something like: “Talk to me like I am a 3 year old” which is why I’m finally starting to understand C++ 😛

Tools I used:

Python 2.7.3 x64
Visual Studio 2012 (any other version should do as far as I know)
Python tools for visual studio. (Ptvs)

What we will do:

Create a c++ and pythonproject.
Setup debugging
Add some code that can later be called from python.
Call the c++ dll with the ctypes module in python

Stage 1 – setup: (Skip it if you know how to setup a visual studio project for a DLL)
1.1)   Open visual studio.
1.2)   Create a new c++ project. Select Empty Project. (I like starting from a clean project)
1.3)   Give it a name and location and click ok.

1.4) In the Solution Explorer right click on your project and go to “properties”

1.5) in the Configuration Properties -> General -> Configuration Type set it to “Dynamic Library (.dll)”
1.6) in the target extension change it to “.dll” instead of “.exe”
*Note that in some tutorials / online resources they refer to this as a .so (shared object / shared library).

Also one thing to recommend.
If you build release and debug the folder locations change. This makes it annoying for python as you have to swap between folder paths.
But you can also just change the build location for the debug and release to be the same folder path.

So change the output directory to:
$(SolutionDir)\dll\

For debug and release.

1.7) To be consistent with good coding practices lets make a header and cpp file.

Right click the “Header Files” Folder in the solution Explorer and click
“Add -> new Item”
Select the “header file (.h)” and give it a logical name for example:
RingRingPythonCalling.h
And if you want to be tidy create a proper “headers” folder in your project windows folder. Click ok and now you should have a .h file.

Lets do the same in the Source Files but now for a .cpp file
Please make sure that whatever you called your .h file that you call the .cpp file the same.
This will make it easier to manage our files and code in c++.

1.8) Creating your python project.

1) Right mouse button click on your solution and goto
Add -> New Project -> select a Python application.

2)   Give it a name and put it in a logical location.
(preferably in the same folder as your c++ project )
Mine is:
3)   Now your solution should look something like this.

4) Now right click the project and click.
Set as StartUp project.

This makes sure that when you press F5 on your keyboard this python file is run. Else it will try to run the C++ file which is not possible as it’s a dll and not an executable 

1.9) Settings for debugging.

Now in order to be easily able to debug our code in python and c++ at the same time do the following.
1)   Right mouse click on your python project and click properties
2)   Now goto debug and tick”Enable native code debugging”
3)   This now allows the c++ code to be debug able.
4)   Now goto
https://github.com/Microsoft/PTVS/wiki/Symbols-for-Python-mixed-mode-debugging
And download your corresponding pdb files for your python version.
5)   Create a folder called symbols in your python install folder and put the pdb files in there.

6) Now goto the menu bar

Tools -> Options
Debugging -> Symbols. .
Click on the folder icon and add the folderpath to the symbols there.

7) You might also need to click “Load All Symbols” Once for it to work.
8) Do note that enabling this makes running your python file slower.

So sometimes its recommended to just disable it. Especially once the c++ work is done or you are not making modifications in the c++ file.

Stage 2:

1.0) Creating some example code:
Open your header file by double clicking on it.

Now I wanted to find a use case for this tutorial instead of just doing a hello world.
So the code I have written here would be the basis of doing a c++ matrix or array class but focusing on the communication between c++ and python.

For example. Imagine you are taking skin cluster data from maya and you want to do some special smoothing operations on the skin cluster data.
The data that comes out of maya is usually a list of lists. So per vertex per influence
So on every row you have a vertex. And every column corresponds to every influence.

In python iterating over all these numbers can be quite slow. So if you send the vertex weight information over to c++ and do your math magic there it could be a lot faster.
So keeping this in mind I made this tutorial

In your header file write the following: *note I tried to comment the c++ to the best of my knowledge however I can not guarantee it’s a 100% correct 😀

// c++ Note: The ifndef, this is useless for python but can become usefull if the extension becomes a lot bigger. 
// c++ Note: This basically prevents the header from being compiled more than once if its used in multiple area's of a project. 
// c++ Note: If (if) this word is not(n) defined (def)
#ifndef PYTHONEXTENSIONS_RINGRING_H
// c++ Note: define the this word. 
#define PYTHONEXTENSIONS_RINGRING_H


// Name spaces are a good habit to get into as it makes it easier to extend your project. 
// Also makes your code more readable. 
// Note that opinions differ on this. Do a search on stack overflow to give you months of reading material on namespaces haha. 
namespace PythonExtensions { 

	// So here we define a class called PythonCalls 
	class PythonCalls
	{
		// It has the following public members 
	public:

		bool valid; // Valid boolean to keep track if the class is still valid to be called from python. 
		
		// The first function here is the constructor. This gets called when the class is initialized. like a python __init__ 
		PythonCalls();
		// This is a deconstructor. it is the same name as the class but with a tilde ~ infront of it. 
		// This is called when the class is deleted. 
		~PythonCalls(); 


		// Lets create a double pointer pointer to use as an example of passing arguments around. 
		/* 
			A double pointer pointer can be SEEN as an list of lists in python. 
			Its basically a list of pointers to other pointers. 
					
		*/		
		double ** array2D; 
		// We need the info of the array because in c++ we can not query how big an array of pointers is. 
		// So we just store the information as a member. (in python you can see this as self.rows and self.columns etc) 
		int rows; // This will hold the info on how manny rows the array has 
		int columns; // This will hold the info on how manny collumns the array has. 


		// As you can see all functions return something. Even though most functions do not need to. 
		// However there seems to be a problem in release mode where python starts garbage collecting the class object.
		// So returning a value prevents that from happening. 
		int CreateArray( double ** pythonArray,int rows, int columns);
		int CreateArray( int rows, int columns); 
		int PrintArray( );
		int SmoothArray(int percentage); // Percentage is in 0 to 100 
		bool IsValid(); // just an example of a simple return boolean
		double ** GetArray(); // actually getting the array back again but the actual pointer. 
		double ** GetArrayCopy(); // actually getting the array back again but this time a copy. 

	private:

	};



}
// Here we end our if. So the compiler knows where to end.
#endif

// c++ Note: The ifndef, this is useless for python but can become usefull if the extension becomes a lot bigger.

// c++ Note: This basically prevents the header from being compiled more than once if its used in multiple area's of a project.

// c++ Note: If (if) this word is not(n) defined (def)

#ifndef PYTHONEXTENSIONS_RINGRING_H

// c++ Note: define the this word.

#define PYTHONEXTENSIONS_RINGRING_H

// Name spaces are a good habit to get into as it makes it easier to extend your project.

// Also makes your code more readable.

// Note that opinions differ on this. Do a search on stack overflow to give you months of reading material on namespaces haha.

namespace PythonExtensions {

// So here we define a class called PythonCalls

class PythonCalls

{

// It has the following public members

public:

bool valid; // Valid boolean to keep track if the class is still valid to be called from python.

// The first function here is the constructor. This gets called when the class is initialized. like a python __init__

PythonCalls();

// This is a deconstructor. it is the same name as the class but with a tilde ~ infront of it.

// This is called when the class is deleted.

~PythonCalls();

// Lets create a double pointer pointer to use as an example of passing arguments around.

A double pointer pointer can be SEEN as an list of lists in python.

Its basically a list of pointers to other pointers.

double ** array2D;

// We need the info of the array because in c++ we can not query how big an array of pointers is.

// So we just store the information as a member. (in python you can see this as self.rows and self.columns etc)

int rows; // This will hold the info on how manny rows the array has

int columns; // This will hold the info on how manny collumns the array has.

// As you can see all functions return something. Even though most functions do not need to.

// However there seems to be a problem in release mode where python starts garbage collecting the class object.

// So returning a value prevents that from happening.

int CreateArray( double ** pythonArray,int rows, int columns);

int CreateArray( int rows, int columns);

int PrintArray( );

int SmoothArray(int percentage); // Percentage is in 0 to 100

bool IsValid(); // just an example of a simple return boolean

double ** GetArray(); // actually getting the array back again but the actual pointer.

double ** GetArrayCopy(); // actually getting the array back again but this time a copy.

private:

};

}

// Here we end our if. So the compiler knows where to end.

#endif

Now for the cpp file

#include <stdio.h> // Needed for the print function. 
#include <windows.h>

#include "RingRingPythonCalling.h" // We need to include our header as else it does not know how the class is build up. 
 

namespace PythonExtensions {
	
	/*

	Here we put all our class functions and normal c++ functions. 
	Python will not be able to call these functions directly. 
	My guess is there is a way but I have not found it yet. 

	See the C wrapper how we actually solve this problem.
	*/


	PythonCalls::PythonCalls( )
		: rows(0), columns(0),valid(true)// We initialize our rows and columns to 0.
		// This is the constructor. Its like the __init__ in a python class. 
	{
		// We set the valid bool to true so we can check from python if the object still lives in memory. 
		

		
		
	}

	PythonCalls::~PythonCalls( )
		// This is the deconstructor. It gets called when the object is deleted from memory. 
	{
		// Here we set our boolean to false so we can check from python if we can still use the class. 
		valid = false;

		// In here we should also delete any other objects i.e. our array. 
		// But I'll leave that for now. 
	}

	int PythonCalls::CreateArray( double ** pythonArray,int rowsSize, int columnsSize )
	{
		// Creates an array from the python data. 
		rows = (int)rowsSize;
		columns = (int)columnsSize;
		// First we create an empty array with the correct size. 
		// We could skip this step and it would still work in this case ...
		// However then we would most likely be overwriting some chunk of memory somewhere 
		// which is bad m'kay :P
		CreateArray(rows,columns); 

		// And now we can assing our python array to our array member. 
		array2D = pythonArray;
		return 1;
	};
	int PythonCalls::CreateArray(int rows, int columns)
	{
		// Creates an empty array with the set size. 
		array2D = new double *[rows];

		for (int y=0;y<rows;y++)
		{
			array2D[y] = new double[columns];
			for (int x=0;x<columns;x++)
			{
				array2D[y][x] = 0;
			}
		}
		return 1;
	}

	int PythonCalls::PrintArray( )
	{
		printf("\nPrinting from c++. \n");
		// So printing it we just itterate over the rows and columns. 
		for (int y=0;y<rows;y++)
		{
			for (int x=0;x<columns;x++)
			{
				printf("\t%.3f \t", array2D[y][x]);
			}
			printf("\n");
		}
		printf("End c++ print\n\n");
		return 1;
	}

	int PythonCalls::SmoothArray(int percentage)
	{
		// A simple smoothing function. 
		// Im sure there are 1000 ways to do this better but you get the idea. 
		double total = 0;
		double mean = 0;
		double perc = (double)percentage *0.01;
		//printf("rows %d, columns %d",rows,columns );
		for (int y=0;y<rows;y++)
		{
			total = 0;
			for (int x=0;x<columns;x++)
			{
				total += array2D[y][x];
			}
			mean = total / (double)columns;
			for (int x=0;x<columns;x++)
			{
				if (array2D[y][x] > mean)
				{
					array2D[y][x] = array2D[y][x]- ((array2D[y][x]-mean)*perc);
				}
				else if (array2D[y][x] < mean)
				{
					array2D[y][x] = array2D[y][x] + ((mean - array2D[y][x])*perc);
				}
			}
		}
		Sleep((DWORD)0.00001); // Required for python.
		return 1;

	}
	bool PythonCalls::IsValid()
	{
		// This function is not really correct as if the object gets deleted so does this function. 
		// But python will still hold a version of it and thus be able to call it and know that its no longer valid. 
		return valid;
	}
	double ** PythonCalls::GetArray()
	{
		return array2D;
	}

	double ** PythonCalls::GetArrayCopy()
	{
		double ** arrayCopy =  new double *[rows];
		for (int y=0;y<rows;y++)
		{
			arrayCopy[y] = new double[columns];
			for (int x=0;x<columns;x++)
			{
				arrayCopy[y][x] = array2D[y][x];
			}
		}
		return arrayCopy;
	}
	//////////////////////////////////////////////////////////////////////////
	// C Wrapper
	//////////////////////////////////////////////////////////////////////////
	// Wrapper in C so python can access the functions 
	extern "C"
	{
		__declspec(dllexport)
		PythonExtensions::PythonCalls * PythonCallsNew() {
			return new PythonExtensions::PythonCalls();
		}

		__declspec(dllexport)
			int create_array(PythonExtensions::PythonCalls * pythonCallsClass, double ** pythonArray, int rows, int columns )
		{
			return pythonCallsClass->CreateArray(pythonArray, rows, columns);
		}

		__declspec(dllexport)
			int create_empty_array(PythonExtensions::PythonCalls * pythonCallsClass, int rows, int columns )
		{
			return pythonCallsClass->CreateArray( rows, columns);
		}

		__declspec(dllexport)
			int print_array(PythonExtensions::PythonCalls * pythonCallsClass)
		{
			return pythonCallsClass->PrintArray();
		}

		__declspec(dllexport)
			int smooth_array(PythonExtensions::PythonCalls * pythonCallsClass, int percentage)
		{
			return pythonCallsClass->SmoothArray(percentage);
		}

		__declspec(dllexport)
			bool is_valid(PythonExtensions::PythonCalls * pythonCallsClass)
		{
			return pythonCallsClass->IsValid();
		}

		__declspec(dllexport)
			double ** get_array(PythonExtensions::PythonCalls * pythonCallsClass)
		{
			return pythonCallsClass->GetArray();
		}

		__declspec(dllexport)
			double ** get_array_copy(PythonExtensions::PythonCalls * pythonCallsClass)
		{
			return pythonCallsClass->GetArrayCopy();
		}
	}

}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

#include <stdio.h> // Needed for the print function.

#include <windows.h>

#include "RingRingPythonCalling.h" // We need to include our header as else it does not know how the class is build up.

namespace PythonExtensions {

Here we put all our class functions and normal c++ functions.

Python will not be able to call these functions directly.

My guess is there is a way but I have not found it yet.

See the C wrapper how we actually solve this problem.

PythonCalls::PythonCalls( )

: rows(0), columns(0),valid(true)// We initialize our rows and columns to 0.

// This is the constructor. Its like the __init__ in a python class.

{

// We set the valid bool to true so we can check from python if the object still lives in memory.

}

PythonCalls::~PythonCalls( )

// This is the deconstructor. It gets called when the object is deleted from memory.

{

// Here we set our boolean to false so we can check from python if we can still use the class.

valid = false;

// In here we should also delete any other objects i.e. our array.

// But I'll leave that for now.

}

int PythonCalls::CreateArray( double ** pythonArray,int rowsSize, int columnsSize )

{

// Creates an array from the python data.

rows = (int)rowsSize;

columns = (int)columnsSize;

// First we create an empty array with the correct size.

// We could skip this step and it would still work in this case ...

// However then we would most likely be overwriting some chunk of memory somewhere

// which is bad m'kay :P

CreateArray(rows,columns);

// And now we can assing our python array to our array member.

array2D = pythonArray;

return 1;

};

int PythonCalls::CreateArray(int rows, int columns)

{

// Creates an empty array with the set size.

array2D = new double *[rows];

for (int y=0;y<rows;y++)

{

array2D[y] = new double[columns];

for (int x=0;x<columns;x++)

{

array2D[y][x] = 0;

}

return 1;

}

int PythonCalls::PrintArray( )

{

printf("\nPrinting from c++. \n");

// So printing it we just itterate over the rows and columns.

for (int y=0;y<rows;y++)

{

for (int x=0;x<columns;x++)

{

printf("\t%.3f \t", array2D[y][x]);

}

printf("\n");

}

printf("End c++ print\n\n");

return 1;

}

int PythonCalls::SmoothArray(int percentage)

{

// A simple smoothing function.

// Im sure there are 1000 ways to do this better but you get the idea.

double total = 0;

double mean = 0;

double perc = (double)percentage *0.01;

//printf("rows %d, columns %d",rows,columns );

for (int y=0;y<rows;y++)

{

total = 0;

for (int x=0;x<columns;x++)

{

total += array2D[y][x];

}

mean = total / (double)columns;

for (int x=0;x<columns;x++)

{

if (array2D[y][x] > mean)

{

array2D[y][x] = array2D[y][x]- ((array2D[y][x]-mean)*perc);

}

else if (array2D[y][x] < mean)

{

array2D[y][x] = array2D[y][x] + ((mean - array2D[y][x])*perc);

}

Sleep((DWORD)0.00001); // Required for python.

return 1;

}

bool PythonCalls::IsValid()

{

// This function is not really correct as if the object gets deleted so does this function.

// But python will still hold a version of it and thus be able to call it and know that its no longer valid.

return valid;

}

double ** PythonCalls::GetArray()

{

return array2D;

}

double ** PythonCalls::GetArrayCopy()

{

double ** arrayCopy = new double *[rows];

for (int y=0;y<rows;y++)

{

arrayCopy[y] = new double[columns];

for (int x=0;x<columns;x++)

{

arrayCopy[y][x] = array2D[y][x];

}

return arrayCopy;

}

//////////////////////////////////////////////////////////////////////////

// C Wrapper

//////////////////////////////////////////////////////////////////////////

// Wrapper in C so python can access the functions

extern "C"

{

__declspec(dllexport)

PythonExtensions::PythonCalls * PythonCallsNew() {

return new PythonExtensions::PythonCalls();

}

__declspec(dllexport)

int create_array(PythonExtensions::PythonCalls * pythonCallsClass, double ** pythonArray, int rows, int columns )

{

return pythonCallsClass->CreateArray(pythonArray, rows, columns);

}

__declspec(dllexport)

int create_empty_array(PythonExtensions::PythonCalls * pythonCallsClass, int rows, int columns )

{

return pythonCallsClass->CreateArray( rows, columns);

}

__declspec(dllexport)

int print_array(PythonExtensions::PythonCalls * pythonCallsClass)

{

return pythonCallsClass->PrintArray();

}

__declspec(dllexport)

int smooth_array(PythonExtensions::PythonCalls * pythonCallsClass, int percentage)

{

return pythonCallsClass->SmoothArray(percentage);

}

__declspec(dllexport)

bool is_valid(PythonExtensions::PythonCalls * pythonCallsClass)

{

return pythonCallsClass->IsValid();

}

__declspec(dllexport)

double ** get_array(PythonExtensions::PythonCalls * pythonCallsClass)

{

return pythonCallsClass->GetArray();

}

__declspec(dllexport)

double ** get_array_copy(PythonExtensions::PythonCalls * pythonCallsClass)

{

return pythonCallsClass->GetArrayCopy();

}

And last but not least the python file

'''
This is a ctypes python example. 
It shows how to communicate with a c++ compiled dll. 

The reason why we do this is mainly performance or to make python communicate with other libraries. 

In this example we will create a 2d array (matrix) in python and send it to c++. 
In c++ we will smooth it and print it and send it back as example. 

'''

'''
Also i descided to keep the example flat in just one function. and not put it into a python class so its easier to understand. 


'''

import ctypes
import time 

## Define the size of the matrix we will make.
Columns = 4
Rows = 4

def PythonToCPP():

    #######################################
    ## Initialisation 
    #######################################

    ## Define our libraray path 
    libPath = r"..\c_pp_python\dll\c_pp_python.dll"

    ## I have seen some resources where people prefer to do C types in caps. 
    ## I kinda like it too so Im doing the same here. Its just a personal preference. 
    DOUBLE = ctypes.c_double
    PDOUBLE = ctypes.POINTER(DOUBLE)
    PPDOUBLE = ctypes.POINTER(PDOUBLE)
    INT = ctypes.c_int

    ## Makes a list of n doubles
    ## This variable can be send to a c function that takes  " double * " 
    DOUBLE_LIST = DOUBLE*Columns
    ## [1.0,1.0,1.0, ... ]

    ## Makes a array of n double pointers 
    ## So every pointer points to a list of doubles. 
    ## This variable can be send to a c function that takes  " double ** " (note the double pointer star) 
    PDOUBLE_Array = PDOUBLE * Rows
    ## [[1.0,1.0,1.0, ... ],[1.0,1.0,1.0, ... ],...]

    ## Now we initialize our array with doubles 
    doublePointer = PDOUBLE_Array()

    ## Initialize the array with some values 
    for i in xrange(Rows):
        doublePointer[i] = DOUBLE_LIST()
        for ii in xrange(Columns):
            doublePointer[i][ii] = i+ii

    #############################
    ## Load our compiled library 
    #############################
    lib = ctypes.cdll.LoadLibrary( libPath )
    ## Initialise our c++ class and store it in a variable. 
    ## This object we pass in every time we call a function. You can kind of see it as the " self " in a python class. def __init__(self) 
    obj = lib.PythonCallsNew();

    ## Lets check if our object is still valid. 
    print "1) Are we good to go? ", "Yes " if lib.is_valid(obj) == 1 else " No " 
    print "Press enter to continue!" 
    raw_input()

    ## Lets create the array in c++. We need to also inform c++ how big our array is when we created it. 
    ## Note that we are putting the return value into a result. This somehow prevents python from garbage collecting. 
    ## now the garbage collection should only happen when a result goes out of scope but this seems to do the trick. 
    result = lib.create_array(obj,doublePointer,Rows,Columns)

    print "2) We created an array in c++" 
    ## Lets print it from c++. 
    result = lib.print_array(obj)

    ## We smooth our array by 50%
    result = lib.smooth_array(obj, 50)
    print "3) We smoothed the array by 50 % " 

    ## Now lets print it from the python side. 
    print "\nPrinting from Python"
    for i in xrange(Rows):
        for ii in xrange(Columns):
            print "\t",doublePointer[i][ii] ,

        print 
    print "\tEnd printing from python."
    print "\n4)Isnt this nice even though we changed it in c++ we still have access to the values from python!!" 
    print "Press enter to continue!" 
    raw_input()

    ## But what if we want to get a copy of the data so it doesnt change...
    ## We have a function that gets us a copy of the data from c++ (of course we can do this in python too but for example sake :) )
    ## However if we just run the function from python we will get garbage data. (pointer value) 
    ## i.e 2821472 instead of a python object like<__main__.LP_LP_c_double object at 0x0000000002580AC8>
    ## So we need to tell python ctypes what kind of data we are expecting
    lib.get_array_copy.restype = PPDOUBLE

    print "5)We made a copy of the array " 
    arrayCopy = lib.get_array_copy(obj)

    ## We smooth our array by 50% 
    result = lib.smooth_array(obj, 5)
    print "6)We smoothed the array by 50 % again " 

    print "\nPrinting copy from Python"
    for i in xrange(Rows):
        for ii in xrange(Columns):
            print "\t",arrayCopy[i][ii] ,
        print 
    print "\tEnd printing copy from python."

    print "7) As you can see the copied array did not change after the smooth" 
    print "Press enter to continue!" 
    raw_input()

    ## Lets print it from c++ again
    result = lib.print_array(obj)
    print "8) But our c++ array did of course :) \n"
    print "Press enter to continue!" 
    raw_input()

    #######################################
    ## Speed testing 
    #######################################
    print "Now i also did some speed comparissons so you get an idea of the performance increase." 
    print "Please do note that there are a LOT of optimisations that can be done on the Python and C++ side." 
    print "Lets reset the values in the arrays and lets create a python equivalent with a list." 
    ## Initialize the array with some values 
    speedTestPythonArray = []
    for i in xrange(Rows):
        #doublePointer[i] = DOUBLE_LIST()
        speedTestPythonArray.append( [0]*Columns)
        for ii in xrange(Columns):
            doublePointer[i][ii] = i+ii
            speedTestPythonArray[i][ii] = i+ii

    print "Press enter to start the performance test!" 
    raw_input()
    cppStartTime = time.time()
    print "Calling the c++ smooth function 100.000 times" 

    for x in xrange( 100000 ):
        result = lib.smooth_array(obj, 1)
    cppEndTime = time.time() - cppStartTime

    print "\nPrinting the c++ array" 
    for i in xrange(Rows):
        for ii in xrange(Columns):
            print "\t",doublePointer[i][ii] ,
        print 

    pythonStartTime = time.time()
    print "Calling the python smooth function 100.000 times" 
    for x in xrange( 100000):
        speedTestPythonArray = pythonSmooth(speedTestPythonArray, 1)
    pythonEndTime = time.time() - pythonStartTime 

    print "\nPrinting the Python list"
    for i in xrange(Rows):
        for ii in xrange(Columns):
            print "\t",speedTestPythonArray[i][ii] ,
        print 


    print "Duration c++ ",cppEndTime
    print "Duration python",pythonEndTime


    print """So as you can see there is a clear speed improvement
            C++ will most likely still be below 1 second (depending on your machine).
            Ony my machine in release c++ is about 15 times faster than python. 
                Duration c++  0.0380001068115
                Duration python 0.676999807358
            Note that running it in debug is slower than in release. 
            Build the code in release and press Ctrl-F5

            The higher of numbers of rows anc colums the bigger the difference becomes. :) 
            Try setting it to 20 or 40
            Thats all folks. Hope it helps :)
            """



## The python smooth function. 
def pythonSmooth(arrList, percentage):
    total = 0
    mean = 0
    perc = percentage *0.01;
    for y in xrange(Rows):
        total = 0;
        for x in xrange(Columns):
            total += arrList[y][x];
        mean = total / float(Columns)
        for x in xrange(Columns):
            if arrList[y][x] > mean:
                arrList[y][x] = arrList[y][x]- ((arrList[y][x]-mean)*perc);
            elif arrList[y][x] < mean:
                arrList[y][x] = arrList[y][x] + ((mean - arrList[y][x])*perc);
    return arrList


PythonToCPP()

print "Press enter to exit" 
raw_input()

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

'''

This is a ctypes python example.

It shows how to communicate with a c++ compiled dll.

The reason why we do this is mainly performance or to make python communicate with other libraries.

In this example we will create a 2d array (matrix) in python and send it to c++.

In c++ we will smooth it and print it and send it back as example.

'''

Also i descided to keep the example flat in just one function. and not put it into a python class so its easier to understand.

'''

import ctypes

import time

## Define the size of the matrix we will make.

Columns = 4

Rows = 4

def PythonToCPP():

#######################################

## Initialisation

#######################################

## Define our libraray path

libPath = r"..\c_pp_python\dll\c_pp_python.dll"

## I have seen some resources where people prefer to do C types in caps.

## I kinda like it too so Im doing the same here. Its just a personal preference.

DOUBLE = ctypes.c_double

PDOUBLE = ctypes.POINTER(DOUBLE)

PPDOUBLE = ctypes.POINTER(PDOUBLE)

INT = ctypes.c_int

## Makes a list of n doubles

## This variable can be send to a c function that takes " double * "

DOUBLE_LIST = DOUBLE*Columns

## [1.0,1.0,1.0, ... ]

## Makes a array of n double pointers

## So every pointer points to a list of doubles.

## This variable can be send to a c function that takes " double ** " (note the double pointer star)

PDOUBLE_Array = PDOUBLE * Rows

## [[1.0,1.0,1.0, ... ],[1.0,1.0,1.0, ... ],...]

## Now we initialize our array with doubles

doublePointer = PDOUBLE_Array()

## Initialize the array with some values

for i in xrange(Rows):

doublePointer[i] = DOUBLE_LIST()

for ii in xrange(Columns):

doublePointer[i][ii] = i+ii

#############################

## Load our compiled library

#############################

lib = ctypes.cdll.LoadLibrary( libPath )

## Initialise our c++ class and store it in a variable.

## This object we pass in every time we call a function. You can kind of see it as the " self " in a python class. def __init__(self)

obj = lib.PythonCallsNew();

## Lets check if our object is still valid.

print "1) Are we good to go? ", "Yes " if lib.is_valid(obj) == 1 else " No "

print "Press enter to continue!"

raw_input()

## Lets create the array in c++. We need to also inform c++ how big our array is when we created it.

## Note that we are putting the return value into a result. This somehow prevents python from garbage collecting.

## now the garbage collection should only happen when a result goes out of scope but this seems to do the trick.

result = lib.create_array(obj,doublePointer,Rows,Columns)

print "2) We created an array in c++"

## Lets print it from c++.

result = lib.print_array(obj)

## We smooth our array by 50%

result = lib.smooth_array(obj, 50)

print "3) We smoothed the array by 50 % "

## Now lets print it from the python side.

print "\nPrinting from Python"

for i in xrange(Rows):

for ii in xrange(Columns):

print "\t",doublePointer[i][ii] ,

print "\tEnd printing from python."

print "\n4)Isnt this nice even though we changed it in c++ we still have access to the values from python!!"

print "Press enter to continue!"

raw_input()

## But what if we want to get a copy of the data so it doesnt change...

## We have a function that gets us a copy of the data from c++ (of course we can do this in python too but for example sake :) )

## However if we just run the function from python we will get garbage data. (pointer value)

## i.e 2821472 instead of a python object like<__main__.LP_LP_c_double object at 0x0000000002580AC8>

## So we need to tell python ctypes what kind of data we are expecting

lib.get_array_copy.restype = PPDOUBLE

print "5)We made a copy of the array "

arrayCopy = lib.get_array_copy(obj)

## We smooth our array by 50%

result = lib.smooth_array(obj, 5)

print "6)We smoothed the array by 50 % again "

print "\nPrinting copy from Python"

for i in xrange(Rows):

for ii in xrange(Columns):

print "\t",arrayCopy[i][ii] ,

print "\tEnd printing copy from python."

print "7) As you can see the copied array did not change after the smooth"

print "Press enter to continue!"

raw_input()

## Lets print it from c++ again

result = lib.print_array(obj)

print "8) But our c++ array did of course :) \n"

print "Press enter to continue!"

raw_input()

#######################################

## Speed testing

#######################################

print "Now i also did some speed comparissons so you get an idea of the performance increase."

print "Please do note that there are a LOT of optimisations that can be done on the Python and C++ side."

print "Lets reset the values in the arrays and lets create a python equivalent with a list."

## Initialize the array with some values

speedTestPythonArray = []

for i in xrange(Rows):

#doublePointer[i] = DOUBLE_LIST()

speedTestPythonArray.append( [0]*Columns)

for ii in xrange(Columns):

doublePointer[i][ii] = i+ii

speedTestPythonArray[i][ii] = i+ii

print "Press enter to start the performance test!"

raw_input()

cppStartTime = time.time()

print "Calling the c++ smooth function 100.000 times"

for x in xrange( 100000 ):

result = lib.smooth_array(obj, 1)

cppEndTime = time.time() - cppStartTime

print "\nPrinting the c++ array"

for i in xrange(Rows):

for ii in xrange(Columns):

print "\t",doublePointer[i][ii] ,

pythonStartTime = time.time()

print "Calling the python smooth function 100.000 times"

for x in xrange( 100000):

speedTestPythonArray = pythonSmooth(speedTestPythonArray, 1)

pythonEndTime = time.time() - pythonStartTime

print "\nPrinting the Python list"

for i in xrange(Rows):

for ii in xrange(Columns):

print "\t",speedTestPythonArray[i][ii] ,

print "Duration c++ ",cppEndTime

print "Duration python",pythonEndTime

print """So as you can see there is a clear speed improvement

C++ will most likely still be below 1 second (depending on your machine).

Ony my machine in release c++ is about 15 times faster than python.

Duration c++ 0.0380001068115

Duration python 0.676999807358

Note that running it in debug is slower than in release.

Build the code in release and press Ctrl-F5

The higher of numbers of rows anc colums the bigger the difference becomes. :)

Try setting it to 20 or 40

Thats all folks. Hope it helps :)

"""

## The python smooth function.

def pythonSmooth(arrList, percentage):

total = 0

mean = 0

perc = percentage *0.01;

for y in xrange(Rows):

total = 0;

for x in xrange(Columns):

total += arrList[y][x];

mean = total / float(Columns)

for x in xrange(Columns):

if arrList[y][x] > mean:

arrList[y][x] = arrList[y][x]- ((arrList[y][x]-mean)*perc);

elif arrList[y][x] < mean:

arrList[y][x] = arrList[y][x] + ((mean - arrList[y][x])*perc);

return arrList

PythonToCPP()

print "Press enter to exit"

raw_input()

Now the code should speak for itself and its comments.
As for running it.

Step3: Building the code.

1) Build the code in Debug or Release

If you press F7 it will build the project into a DLL.
alternatively you can go to Build –> Build solution.
Because a python file doesn’t need to be precompiled visual studio will only compile the DLL.
Scroll down to the Problems and solutions if you run into any problems or errors.

2) Now press F5.

Seeing as you set the python file to be the startup file it will run the script.
Here are the project files that you can download and test yourself.

PythonCalling

Just running CallingCPP.py if you have python installed should work out of the box. Or you can compile it the dll yourself 🙂

Feel free to post any comments if you run into any problems 

Problems and solutions:

1) When compiling you get this error:

fatal error C1083: Cannot open include file: ‘RingRingPythonCalling.h’: No such file or directory
a: Check that you wrote the name correctly of the header file.
b: Right mouse button click on your project and go to properties
Goto configuration properties -> c/c++ -> general
At Additional Include directories add the folder where your header file is located.
That should do the trick.

2) Debugging pops up the “Python Symbols Required” window.

You need to add the python symbols of the correct version.

Click download symbols it will take you to this link.
①   https://github.com/Microsoft/PTVS/wiki/Symbols-for-Python-mixed-mode-debugging
②   MAKE SURE YOU GET THE RIGHT VERSION.
③   To find your version do the following:

Run your python executable.
1. For me that path is “C:\Python27\python.exe”
2. Then you will see the python window appear with the version in the header.
(note your window will most likely look black)
Now my version is 2.7.3 so make sure you also download the pdb for your corresponding version. Else the “Python Symbols required” dialog will keep popping up.

3) Python command window pops up and closes instantly.

This sometimes happens with the symbols messing with the python tools for visual studio.
The easiest workaround is to run the script without debugging.
So instead of pressing F5 press Ctrl-F5 untill you fix your bug.

4) WindowsError: exception: access violation reading 0x000007FE004148D0

There are a million reasons why you could get this error. However the one I ran into the most is:
①   If you get this error the object is most likely being garbage collected by python.
②   So Make sure you store the object in a variable returning from a c++ function. If your c++ function does not need to return anything just give it a int as a return value.
Additionally. I noticed that there is a more severe underlying bug that I could not find the source of.
①   However I did find a solution. (Though very hacky)
②   Just add a Sleep(0.0001) at the end of the function. As seen in the smoothArray function.
③   My guess is python is doing its own memory management after the function is called and moves the objects around. But the function returns to soon so python cant call the function again. This mainly happens in release and not in debug so it’s a nightmare to find.

Threading in maya.

Posted on April 14, 2014 by Jan

So a while back I wanted to create a background thread that checks the user selection at any given point. Now I know I could have done this with a script job but I wanted more flexibility so started looking into threading.

Now threading in maya is somewhat a nightmare as threads are not safe so if a thread crashes so does maya.

But I think I’ve come up with a “somewhat” stable version of threading. I am kind of cheating the function to run on the main thread. This way most Pymel functions will still work correctly without erroring out.

Now be careful though: It can still be unstable especially when using print statements.

The problem is that if one thread gets delayed and the other one starts that there is a slim chance that two or more threads try to do the same operation in maya at the same time. So for example they will both try to move object.vtx[1] to different positions or print to the script editor at the same time it will result in a crash as maya does not know what to do with the situation.

The class here calls the provided function every 1 second. unless specified otherwise. The timer will never be faster than the function takes. so if the function takes 3 seconds to complete then the interval will be 3 seconds even though you might set it to 0.001

It also supports string and mel functions.

Here is the code:

#####################################################
##
## Author: Jan Pijpers
##
## Date : 10/04/2014
##
## Module description: Threading module that allows user to create a sepperate thread and run their own funcitons. 
##
##
#####################################################

import threading
import traceback
import math
import time 

from pymel import core as pm
from maya import mel
from maya import cmds
import maya.utils 

## Did not create a class that inherits from a threaded function as maya does not like it
## Mainly because threads are not thread safe in maya 
class threadedLoop( object ):
    def __init__( self, stopEvent, function, args = [], kwargs = {}, interval = 1.0, threadName = None, mel = False):
        '''
        Description:
            loops a certain function at the specified interval.
            The function will never be called faster than it can run. so if the function takes 5 seconds setting the interval to less then 5 will not do anything. 
            Also its a recursive function. So python might hit its recursion limit. if it does just increase the limit. 
        Args:
            stopEvent : threading.event 
            function : the function as is or as string
            args: arguments that need to be passed into the function
            kwargs: keyword arguments needed to be passed into the function
            interval : the interval at which the function needs to be called. (i recommend to not go lower than 0.001)
            threadName : obsolete for now. 
            mel : is it a mel function ? make sure you set this if it is else you might get some funky list of errors.  Note calling a mel function is a lot more unstable
        Returns:
            None
        Raises:
            Exception : catch all as I do not know what can go wrong in other peoples scripts. 

        '''
        ## Store variables 
        self.stopEvent = stopEvent
        self.func = function
        self.args = args
        self.kwargs = kwargs
        self.thread = None
        self.mel = mel
        ## Check if the function is a string or not 
        self.stringFunction = False if not mel and not type( self.func ) == type( '' ) else True
        self.interval = interval 

        ## Create the timer thread . ( for some wierd reason more stable than creating a thread normally)
        ## This is the most volitile bit in maya hence only doing it once and then just r
        ## Get the function name 
        self.funcName = self.func.__name__ if not self.stringFunction else self.func
        ## get the thread name (not used at the moment)
        self.threadName = self.funcName if not threadName else self.func.__name__ if not stringFunction else self.func

    def start( self ):
        ## Check if the thread allready exists
        if self.thread:
            self.stopEvent.clear()
            ## Just call our execute funtion
            self.execute( )
            return

        self.thread = threading.Timer(self.interval, self.execute , [], {} )
        ## Start the thread
        ## It will call the function once after the interval has finished (in the execute function it be called again. )
        self.thread.start()

    def stop( self ):
        ## Set the stop signal.
        self.stopEvent.set()
        #self.thread.cancel()

    def execute( self ):
        ## All wrapped in a try
        try:
            ## Create the string for the arguments 
            strArgs = ','.join( ["'" +str(a)+"'" for a in self.args]) if self.args else ''
            ## Create the string for the keyword arguments 
            strKwargs = ','.join( [str(k) +'=' +str(v) for k,v in self.kwargs.iteritems()]) if self.kwargs else ''
            ## the sepperator and if we need it 
            sepperator = ',' if strArgs and strKwargs else ''
            ## Create the function string so we can pass it into an eval deferred 
            funcString = self.funcName +"("+strArgs+sepperator+strKwargs+")" 

            ## If its a mel function we need to use te mel.eval
            if self.mel:
                cmds.evalDeferred( "from maya import mel;mel.eval('%s')"%funcString);

            else:
                ## If not we can just use an normal eval defered. Using cmds as its more stable then pymel.
                cmds.evalDeferred( funcString ) 

        except Exception, e:
            ## Catch whatever exception happens. (does not always work because of the eval deferred )
            #print e
            print traceback.format_exc()
            print "\nThreading stopped something went wrong",
            return 

        ## Wait the prefered interval
        time.sleep(self.interval)
        ## Tell maya to do whatever it needs to
        maya.utils.processIdleEvents()

        ## check if the user wanted to stop the thread
        if self.stopEvent.isSet():
            #self.stop()
            #self.thread = None
            return
        ## Call our start again. 
        cmds.evalDeferred( self.start )

#testT.stopEvent = True
#testT.thread.cancel()

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

#####################################################

## Author: Jan Pijpers

## Date : 10/04/2014

## Module description: Threading module that allows user to create a sepperate thread and run their own funcitons.

#####################################################

import threading

import traceback

import math

import time

from pymel import core as pm

from maya import mel

from maya import cmds

import maya.utils

## Did not create a class that inherits from a threaded function as maya does not like it

## Mainly because threads are not thread safe in maya

class threadedLoop( object ):

def __init__( self, stopEvent, function, args = [], kwargs = {}, interval = 1.0, threadName = None, mel = False):

'''

Description:

loops a certain function at the specified interval.

The function will never be called faster than it can run. so if the function takes 5 seconds setting the interval to less then 5 will not do anything.

Also its a recursive function. So python might hit its recursion limit. if it does just increase the limit.

Args:

stopEvent : threading.event

function : the function as is or as string

args: arguments that need to be passed into the function

kwargs: keyword arguments needed to be passed into the function

interval : the interval at which the function needs to be called. (i recommend to not go lower than 0.001)

threadName : obsolete for now.

mel : is it a mel function ? make sure you set this if it is else you might get some funky list of errors. Note calling a mel function is a lot more unstable

Returns:

None

Raises:

Exception : catch all as I do not know what can go wrong in other peoples scripts.

'''

## Store variables

self.stopEvent = stopEvent

self.func = function

self.args = args

self.kwargs = kwargs

self.thread = None

self.mel = mel

## Check if the function is a string or not

self.stringFunction = False if not mel and not type( self.func ) == type( '' ) else True

self.interval = interval

## Create the timer thread . ( for some wierd reason more stable than creating a thread normally)

## This is the most volitile bit in maya hence only doing it once and then just r

## Get the function name

self.funcName = self.func.__name__ if not self.stringFunction else self.func

## get the thread name (not used at the moment)

self.threadName = self.funcName if not threadName else self.func.__name__ if not stringFunction else self.func

def start( self ):

## Check if the thread allready exists

if self.thread:

self.stopEvent.clear()

## Just call our execute funtion

self.execute( )

return

self.thread = threading.Timer(self.interval, self.execute , [], {} )

## Start the thread

## It will call the function once after the interval has finished (in the execute function it be called again. )

self.thread.start()

def stop( self ):

## Set the stop signal.

self.stopEvent.set()

#self.thread.cancel()

def execute( self ):

## All wrapped in a try

try:

## Create the string for the arguments

strArgs = ','.join( ["'" +str(a)+"'" for a in self.args]) if self.args else ''

## Create the string for the keyword arguments

strKwargs = ','.join( [str(k) +'=' +str(v) for k,v in self.kwargs.iteritems()]) if self.kwargs else ''

## the sepperator and if we need it

sepperator = ',' if strArgs and strKwargs else ''

## Create the function string so we can pass it into an eval deferred

funcString = self.funcName +"("+strArgs+sepperator+strKwargs+")"

## If its a mel function we need to use te mel.eval

if self.mel:

cmds.evalDeferred( "from maya import mel;mel.eval('%s')"%funcString);

else:

## If not we can just use an normal eval defered. Using cmds as its more stable then pymel.

cmds.evalDeferred( funcString )

except Exception, e:

## Catch whatever exception happens. (does not always work because of the eval deferred )

#print e

print traceback.format_exc()

print "\nThreading stopped something went wrong",

return

## Wait the prefered interval

time.sleep(self.interval)

## Tell maya to do whatever it needs to

maya.utils.processIdleEvents()

## check if the user wanted to stop the thread

if self.stopEvent.isSet():

#self.stop()

#self.thread = None

return

## Call our start again.

cmds.evalDeferred( self.start )

#testT.stopEvent = True

#testT.thread.cancel()

The evalDeferred is the most important part of this class. Without it there is a very high chance that maya will crash as it will most likely try to do two or more operations at the same time.

To see this in action with a funky little example copy this code into a file named:
threadedFunctions.py
into your scripts directory. i.e. C:\Users\<username>\Documents\maya\<maya version>\scripts

Now in maya create a poly plane of 100 units wide and high. (make sure you leave the name as default i.e.: “pPlane1”)
and give it 10 subdivisions in each direction.

and run this code:

import threadedFunctions
reload( threadedFunctions )
import threading
import math
i = 0
def moveUP():
    global i

    i+= 1

    noVtx = len(pm.PyNode("pPlane1").vtx)
    row = math.sqrt (noVtx )
    for x in xrange(noVtx):

        sinI = math.sin( x % row + (i*0.2) ) * 10 
        #pos = pm.PyNode("pPlane1.vtx[%s]" %str(x)).getPosition()
        pos = cmds.xform( "pPlane1.vtx[%s]" %str(x), query = True, translation = True) 
        cmds.xform( "pPlane1.vtx[%s]" %str(x), translation = [pos[0],sinI,pos[2]] ) 

stopEvent = threading.Event()
flagThread =  threadedFunctions.threadedLoop( stopEvent, moveUP, interval = 0.1)
flagThread.start()

import threadedFunctions

reload( threadedFunctions )

import threading

import math

i = 0

def moveUP():

global i

i+= 1

noVtx = len(pm.PyNode("pPlane1").vtx)

row = math.sqrt (noVtx )

for x in xrange(noVtx):

sinI = math.sin( x % row + (i*0.2) ) * 10

#pos = pm.PyNode("pPlane1.vtx[%s]" %str(x)).getPosition()

pos = cmds.xform( "pPlane1.vtx[%s]" %str(x), query = True, translation = True)

cmds.xform( "pPlane1.vtx[%s]" %str(x), translation = [pos[0],sinI,pos[2]] )

stopEvent = threading.Event()

flagThread = threadedFunctions.threadedLoop( stopEvent, moveUP, interval = 0.1)

flagThread.start()

Now if you are lucky maya dint crash and you will see a flag like motion without the timeline advancing.

VERY IMPORTANT NOTE!!!. if you want to stop the thread run the following code.

## Run these lines to stop the thread
flagThread.stop()
## OR set the thread event. 
stopEvent.set()

## Run these lines to stop the thread

flagThread.stop()

## OR set the thread event.

stopEvent.set()

DO NOT REDEFINE THE “flagThread” variable as that will lose your chance to kill the thread.

I hope this is of some use to someone. I guess you could even make a simple game with this in maya haha :D.

MEL Autocompletion for Sublime and MayaSublime

Posted on April 3, 2014 by Jan

Justin Israel made an awesome extension for the Sublime Text editor called MayaSublime.
https://github.com/justinfx/MayaSublime

But I noticed there is no auto completion file for the MEL syntax so I decided to generate one.

This contains all MEL commands that I can find. Half of these are generated by the help of the Maya help command:
help -list “*”

The rest is generated by parsing all the MEL scripts and taking all “global procs” in the Maya installation scripts folder.

Hope this is of some help to people still having to manage legacy MEL scripts ^^.

I also added the script that I wrote to generate this which might be useful if you are working in a different version of Maya than this file is generated from. (Maya 2014)

Feel free use edit and or modify these files in any way you see fit.

The zip file contains the MEL.sublime-completions and the Python file used to generate this file.

SublimeAutoComplete < CLICK HERE >

(links dont show up properly yet XD)

Copy the MEL.sublime-completions here:

C:\Users\<userName>\AppData\Roaming\Sublime Text 3\Packages\MayaSublime

If you want to generate this file do the following steps:

1) Copy the SublimeMelAutocompletion.py into your scripts folder.

2) C:\Users\<UserName>\Documents\maya\<Maya Version>\scripts

3) Load up maya.

4) open the script editor

5) type:

import SublimeMelAutocompletion as sm
reload(sm)
sm.generateAutoCompletion(mayaOnly = False, filePath = <Your prefered filePath>)

import SublimeMelAutocompletion as sm

reload(sm)

sm.generateAutoCompletion(mayaOnly = False, filePath = <Your prefered filePath>)

Flags:

mayaOnly = This will export only maya commands and scripts that are in the install folder ( C:\Program Files\Autodesk\<mayaVersion>\scripts)

Setting this to False will look in all possible scripts paths defined in the environment variable called: MAYA_SCRIPT_PATH

apiOnly = only generate the commands that are listed in the maya command reference.

filePath = The file path the document will be exported to. i.e. C:\MEL.sublime-completions

If you leave the filePath argument out of it then it will export to the default sublimeText3 mayaSublime folder if it exists:

C:\Users\<userName>\AppData\Roaming\Sublime Text 3\Packages\MayaSublime

It will try to detect your user name automatically.

Maya’s “pasted_” is history and maya root namespace.

Posted on December 9, 2013 by Jan

PASTED_

In maya the copy paste feature can be really useful. The major downside however is that every node that gets pasted gets a nice:

PASTED_ prefix attached to it. Resulting in a horribly messy scene that no one ever cares to clean up… until you have to revisit the scene and have to dive into the world of pasted_ nodes trying to find the correct shader etc.

Now there is a really easy fix for it:

In your maya instalation directory there is a file called cutCopyPaste.mel (of course thanks autodesk … )

in that is a function called pasteScene()

replace that function with the following code:

global proc pasteScene(){

	string $fileExt = ".mb";
	if (`about -ltVersion`) {
		$fileExt = ".mlt";
	}
	else if (`about -evalVersion`) {
		$fileExt = ".mp";
	}

	// determine temp directory
	string $tmpFile = "/maya_sceneClipBoard" + $fileExt;
	string $tmpdir = `getenv TMPDIR`;
	string $filePath = ($tmpdir + $tmpFile);

	// import scene
	string $newTransforms[] = `file -force
		-import
		-renameAll false
		-mergeNamespacesOnClash true
        -namespace ":"
		-groupReference
		-returnNewNodes
		$filePath`;

	select -replace $newTransforms;
	select -replace `ls -sl -head 1`;
}

global proc pasteScene(){

string $fileExt = ".mb";

if (`about -ltVersion`) {

$fileExt = ".mlt";

}

else if (`about -evalVersion`) {

$fileExt = ".mp";

}

// determine temp directory

string $tmpFile = "/maya_sceneClipBoard" + $fileExt;

string $tmpdir = `getenv TMPDIR`;

string $filePath = ($tmpdir + $tmpFile);

// import scene

string $newTransforms[] = `file -force

-import

-renameAll false

-mergeNamespacesOnClash true

-namespace ":"

-groupReference

-returnNewNodes

$filePath`;

select -replace $newTransforms;

select -replace `ls -sl -head 1`;

}

This will merge all the pasted nodes directly into the scene (root namespace ) without adding any prefix or suffix. (Only when the node all ready exists in the same depth it will add a number to the end).

Root Namespace

Whenever I loaded in a referenced scene maya would create a namespace (either with an normal namespace or it would prefix the nodes with the filename and an underscore). However Autodesk has finally been nice enough to open the functionality in the UI to load a scene into the root namespace (making sure the referenced scene does not get any weird naming or namespace. Making it easier to work with)

When going to File > Create reference

The trick is not to disable namespaces on load but enabling them and selecting the : ( root ) namespace and set the following option:

Merge into selected namespace and rename …

Mel and Python do go hand in hand at times.

Posted on October 16, 2013 by Jan

Seeing as some developers still work with mel and a lot of legacy scripts within companies are still written and maintained in mel its sometimes useful to call python functions in mel when having to extend those old legacy scripts. now most people know you can do a:

python("module.function()")

1	python("module.function()")

inside of mel.

But I recently found a mel wrapper function that does this for you!!! And not only that it also adds the proper from module import function path as well!

So this is actually quite usefull so i thought i’d share it here:

for example. Let say you have the following python script that connects two attributes.

def connectAttributes(sourceAttr, targetAttr):
    import pymel.core as pm
    pm.PyNode(sourceAttr) >> pm.PyNode(targetAttr)

import maya.mel as mel
result = mel.createMelWrapper(connectAttributes, returnCmd = True)
mel.eval(result)
print result

def connectAttributes(sourceAttr, targetAttr):

import pymel.core as pm

pm.PyNode(sourceAttr) >> pm.PyNode(targetAttr)

import maya.mel as mel

result = mel.createMelWrapper(connectAttributes, returnCmd = True)

mel.eval(result)

print result

Save this to a file and store it somewhere in the maya scripts paths.

(i.e. my s\Documents\maya\2014-x64 )

Now import the script:

import scriptsLocation.yourFileName as ca

1	import scriptsLocation.yourFileName as ca

This will run the script and as I added a print it will output the actual code it evaluates:

global proc  connectAttributes (string $sourceAttr,string $targetAttr) {
    python("from scriptsLocation.yourFileName import connectAttributes");
    string $tmp = ( "\"" + $sourceAttr + "\"" + "," + "\"" + $targetAttr + "\"" ); 
    python(("connectAttributes(" + $tmp + ")")); }

global proc connectAttributes (string $sourceAttr,string $targetAttr) {

python("from scriptsLocation.yourFileName import connectAttributes");

string $tmp = ( "\"" + $sourceAttr + "\"" + "," + "\"" + $targetAttr + "\"" );

python(("connectAttributes(" + $tmp + ")")); }

and now you can go to mel and do:

rehash;
connectAttributes("pSphere1.translateX", "pSphere2.translateX");

1 2	rehash; connectAttributes("pSphere1.translateX", "pSphere2.translateX");

*note i added the “rehash” to make sure the mel scripts are refreshed.

If you want to get more information about this wrapper function run the following lines inside of a python tab in maya:

import maya.mel
help(maya.mel.createMelWrapper)

1 2	import maya.mel help(maya.mel.createMelWrapper)

Or take a look here:

http://download.autodesk.com/global/docs/maya2014/en_us/index.html?url=files/GUID-8A96A8DB-FD6F-434F-A878-288DD84E99C7.htm,topicNumber=d30e727627

What an artist doesnt see he cant break! “node.intermediateObject.set(1)”

Posted on September 24, 2013 by Jan

While working on one of our pipelines I had to find a way to prevent artist touching certain object. But I still needed access to them in code and be able to modify and delete them.

So I tried locking the objects and hiding them from the scene. But the problem was that they still existed in the outliner. So artists would sometimes clean the objects up or move them around.
Heck one of the artists even accidentally figured out how to unlock the objects and delete it. (dont ask me how).

So I needed to come up with a way to prevent this from happening:

Now I found out there is one thing that scares an artist more than spiders do to a little girl and that is traversing through the hyper graph. (and showing all non dag objects in the outliner :P)

So if you mark an object as an intermediateObject then it will no longer show up in the outliner nor will it be visible in the scene.
The only way to still see it is by traversing in the hypergraph or knowing where you left it :D. Or doing a in Edit Deformers.

So next time if you dont want an artist to accedentally select, modify, delete an object do a:

pm.selected()[0].intermediateObject.set(1)

1	pm.selected()[0].intermediateObject.set(1)

*note as soon as you connect the intermediate object the transform will disappear.

Printing and clearing output window.

Posted on September 19, 2013 by Jan

Recently I started to work on some maya startup scripts and wanted to print out some info in Maya’s Output Window.

So I thought a simple

import sys
sys.stdout.write( "my print line \n")

1 2	import sys sys.stdout.write( "my print line \n")

Would do the trick. However it doesnt.

Turns out maya stores the stdout connection of the Output Window in the private __stdout__.

So in order to print to the output window use:

import sys
sys.__stdout__.write( "my print line \n")

1 2	import sys sys.__stdout__.write( "my print line \n")

Now after a few lines of testing I wanted to clear out the Output Window which turns out to be quite hacky.

So after some searching I found that someone uploaded a useful script that does exactly this:

http://www.creativecrash.com/maya/script/clear-output-window

It does look very intrusive into the windows file system so I guess using this for linux or mac is out of the question.