Differences
This shows you the differences between two versions of the page.
| Next revision | Previous revisionLast revisionBoth sides next revision | ||
| devwiki:python [2021/08/22 19:33] – created ying | devwiki:python [2024/03/21 08:53] – [Online Python run] ying | ||
|---|---|---|---|
| Line 1: | Line 1: | ||
| - | ====== Intro - Maya in Python ====== | ||
| - | Before you read anything below, read this list first | ||
| - | * Python can use almost all the mel command, maya.cmds is a module that simply wraps MEL commands in Python syntax, like <code python> | ||
| - | * Python can run directly in mel mode, like <code python> | ||
| - | * Python can call maya C++ API (maya api 1.0), like <code python> | ||
| - | import maya.OpenMayaAnim as oma | ||
| - | aim_dir = cmds.xform(myLoc, | ||
| - | aim_vec = om.MVector(*aim_dir) | ||
| - | rot_quaternion = myObj_axis_vec.rotateTo(aim_vec) | ||
| - | # myObj_axis_vec is set as x axis direction | ||
| - | myObj_fnTransform.rotateBy(rot_quaternion) | ||
| - | # myObj_fnTransform is set as the transform api function object | ||
| - | </ | ||
| - | * Python can call maya C++ API 2.0 (partially since maya 2013, and still partially in 2015, maybe better in latest) <code python> | ||
| - | aim_dir = cmds.xform(myLoc, | ||
| - | aim_vec = om2.MVector(aim_dir) # can take python list automatically | ||
| - | # also, no need MScriptUtil for pointer to value stuff | ||
| - | # can directly return value like normal python | ||
| - | # also, sometimes faster than api 1.0 | ||
| - | </ | ||
| - | * ref: | ||
| - | * maya 2010 api 1.0 ref: http:// | ||
| - | * maya 2013 api 2.0 doc: http:// | ||
| - | * maya 2017 api 2.0 doc: http:// | ||
| - | * Python can run almost every python module, as long as compatible with maya's internal python version, and add into sys.path. | ||
| - | * Info on PyMel: | + | ====== Modern Python Practice ====== |
| - | * PyMel is created to combine above maya.cmds, maya.mel, maya.OpenMaya (api 1.0) into a seamless python module, that do the coding style translation and with extra with object-oriented features and an extra large library of useful modules; thus a python module to call those maya python modules | + | |
| - | * for me, I currently still prefer handle it directly than learning a new syntax called pymel | + | |
| - | * to do and merge into this | + | * nowaday, now one use python 2.x anymore, use python 3 standard, use this |
| - | * [[cgwiki: | + | * use pathlib instead of os.path |
| - | * [[cgwiki: | + | * use f" |
| - | ===== Intro to Maya API concepts ===== | ||
| - | * moved all over from my old cgwiki: | + | ====== Online Python run ====== |
| - | ====Directed Acyclic Graph (DAG)==== | + | |
| - | | + | * to install locally: < |
| - | * *DAG* defines elements such as the position, orientation, | + | |
| - | | + | |
| - | * For example, if you model a hand, you would like to apply a single transformation to rotate the palm and fingers, rather than rotating each individually-in this case the palm and fingers would share a common parent transformation node. | + | |
| - | | + | |
| - | * For example, when you create a sphere, you create both a shape node (the sphere) and a transformation node that allows you to specify the sphere' | + | |
| - | ====DAG Path==== | + | ====== Install related ====== |
| - | * DagPath is a set of nodes which uniquely identifies the location of a particular node or instance of a node in the graph. | + | ===== install Python3 on mac ===== |
| - | * The path represents a graph ancestry beginning with the root node of the graph and containing, in succession, a particular child of the root node followed by a particular child of this child, etc., down to the node identified by the path. | + | |
| - | * For instanced nodes, there are multiple paths which lead from the root node to the instanced node, one path for each instance. Paths are displayed in Maya by naming each node in the path starting with the root node and separated by the vertical line character, “|”. | + | |
| - | ====Dependency nodes==== | + | |
| - | | + | * to install Python3 from official python website, |
| - | * It is used for animation (deform, simulation, audio) and construction history (model creation) | + | |
| - | * All of these node types, are defined by the enumeration MFn::Type. For example, a textured polygonal mesh may be constructed from | + | |
| - | | + | - run python3 |
| - | | + | |
| - | | + | |
| - | | + | - go Apple developer downloads page, search command line tools for xcode, download |
| - | * If at anytime, you need to find out how a set of nodes are connected, then you can use the hypergraph within maya, to show you a graphical representation of the scene data. It is worth remembering | + | |
| - | ====DAG hierarchy nodes vs Dependency Graph (DG) nodes==== | + | ===== Manage and handle multiple versions of python case ===== |
| - | * These are related but different systems, used for different purposes. | + | |
| - | * Unlike DAG nodes, dependency graph nodes can be cyclic, meaning they can pass information both directions. ([[http:// | + | |
| - | * The DAG relates to the DG in that every DAG node is implemented as a DG node, both shapes and transforms. The only " | + | |
| - | * The dependency graph (DG) is a collection of entities connected together. Unlike the DAG, these connections can be cyclic, and do not represent a parenting relationship. Instead, the connections in the graph allow data to move from one entity in the graph to another. The entities in the graph which accept input, and output data, are called dependency graph nodes. | + | |
| - | * Most objects in Maya are dependency graph nodes, or networks of nodes (several nodes connected together). For example, DAG nodes are dependency graph nodes, and shaders are networks of nodes. | + | |
| - | ====DG node creation==== | + | Situation: |
| - | * MPxNode: base of DG node | + | * sometimes, you may have to keep both python 2.7, python 3.x |
| - | * virtual compute(const MPlug& plug, MDataBlock& | + | * and sometimes you want to try python with AI, and AI need to install tons of AI related python modules |
| - | * MDataHandle inputDH=data.inputValue(inAttrName, & | + | * sometimes you just to keep python module in the min form to test something |
| - | * MDataHandle outputDH=data.outputValue(outAttrName); | + | |
| - | * data.setClean(plug) | + | |
| - | * return MS:: | + | |
| - | * static void* creator() | + | |
| - | * static MStatus initialize() | + | |
| - | * MTypeId yourNode:: | + | |
| - | * attr: readable(output? | + | |
| - | * attr: multi(array? | + | |
| - | * addAttribute(inAttrName); | + | |
| - | * MPxLocatorNode: | + | |
| - | * MPxIkSolverNode: | + | |
| - | * MPxDeformerNode: | + | |
| - | * MPxFieldNode: | + | |
| - | * MPxEmitterNode: | + | |
| - | * MPxSpringNode: | + | |
| - | * MPxManipContainer: | + | |
| - | * MPxSurfaceShape: | + | |
| - | * MPxObjectSet: | + | |
| - | * MPxHwShaderNode: | + | |
| - | * MPxTransform: | + | |
| - | ====DG node attribute==== | + | Solution: |
| - | * simple attribute: attribute has only 1 plug | + | * for those case, when install python, never add python to system path |
| - | * it also can hold array data, like pointArray, intArray | + | * just download and make python folder a portable folder (you can install and copy the python whole folder to other machine as a portable app, better zip to copy, faster) |
| - | * MFnNumericAttribute | + | * then your computer cmd never know where is python and won't random get your python from somewhere |
| - | | + | * then, dynamically set python into python in cmd session |
| - | * array attribute: attribute has array of plugs, each element plug has own value or connection | + | * session based method |
| - | * MFnAttribute:: | + | * batch file method <code dos test.batch> |
| - | * compound attribute: a collection of other attributes, called child attribute | + | @echo off |
| - | * MFnCompoundAttribute | + | SetLocal EnableDelayedExpansion |
| - | * example, color < | + | set CustPython=D: |
| - | color1R | + | call !CustPython!python.exe my_script.py |
| - | color1G = nAttr.create( “color1G”, | + | |
| - | color1B = nAttr.create( “color1B”, | + | |
| - | color1 = nAttr.create( “Sides”, | + | |
| - | nAttr.setStorable(true); | + | |
| - | nAttr.setUsedAsColor(true); | + | |
| - | nAttr.setDefault(1.0f, 1.0f, 1.0f); | + | |
| - | addAttribute(color1R); | + | |
| - | addAttribute(color1G); | + | |
| - | addAttribute(color1B); | + | |
| - | addAttribute(color1); | + | |
| - | attributeAffects(color1R, | + | |
| - | attributeAffects(color1G, | + | |
| - | attributeAffects(color1B, | + | |
| - | attributeAffects(color1, | + | |
| </ | </ | ||
| - | * dynamic attribute: a attribute is dynamically created when needed. | ||
| - | * MFnDependencyNode:: | ||
| - | ====DG node data==== | ||
| - | * MDataBlock is a storage object holds DG node's data during DG node's compute() method | ||
| - | * MDataHandle is a reference into MDataBlock' | ||
| - | * Data creator is for creating data to be into MDataBlock, like output plug of another node, | ||
| - | * mostly for heavy data like mesh | ||
| - | * MFnData (MFnMeshData, | ||
| - | ====DG shader node==== | + | ====== Python 3 Changes and How to Make 2.7 Code Works ====== |
| - | * static MObject color1R, | + | |
| - | * static MObject aOutColorR, aOutColorG, aOutColorB, | + | |
| - | * static MObject aNormalCameraX, | + | |
| - | * static MObject aPointCameraX, | + | |
| - | * void MStatus compute( const MPlug&, MDataBlock& | + | |
| - | ====DG shader node type==== | + | |
| - | | + | # in code editor, using Regular Expression to replace |
| - | * textures/3d | + | find: (print)\s(.+) |
| - | * textures/ | + | replace: $1\($2\) or \1(\2) depending on your code editor |
| - | * shader/ | + | </code> |
| - | * shader/volume | + | * other stuff <code python> |
| - | * shader/ | + | # python 2 reload |
| - | * light | + | reload(myModule) |
| - | * utility/ | + | # python 3 reload |
| - | * utility/ | + | from imp import reload |
| - | * utility/ | + | reload(myModule) |
| - | * imageplane | + | |
| - | * postprocess/ | + | |
| - | note: shader=material | + | # python 2 execfile |
| - | + | execfile(" | |
| - | ====DG shader node creation==== | + | # python 3 |
| - | + | exec(open(" | |
| - | * example, Blinn creation <code javascript> | + | |
| - | // same as: | + | |
| - | createNode blinn; | + | |
| - | connectAttr blinn1.message defaultShaderList1.shaders;</ | + | |
| - | * if creation option checked | + | |
| - | connectAttr -f blinn1.outColor blinn1SG.surfaceShader; | + | |
| </ | </ | ||
| - | * example, volume creation <code javascript> | ||
| - | shadingNode -asShader lightFog; | ||
| - | sets -renderable true -noSurfaceShader true -empty -name lightFog1SG; | ||
| - | connectAttr -f lightFog1.outColor lightFog1SG.volumeShader; | ||
| - | </ | ||
| - | * example, displacement creation <code javascript> | ||
| - | shadingNode -asShader displacementShader; | ||
| - | sets -renderable true -noSurfaceShader true -empty -name displacementShader1SG; | ||
| - | connectAttr -f displacementShader1.displacement displacementShader1SG.displacementShader; | ||
| - | </ | ||
| - | * example, texture 2d <code javascript> | ||
| - | shadingNode -asTexture checker; // means: 1. createNode checker; 2. add to multilister | ||
| - | |||
| - | // if with option checked "With New Texture Placement" | ||
| - | shadingNode -asUtility place2dTexture; | ||
| - | connectAttr place2dTexture1.outUV checker1.uv; | ||
| - | |||
| - | // if with option checked "As Projection" | ||
| - | shadingNode -asTexture projection; | ||
| - | shadingNode -asUtility place3dTexture; | ||
| - | connectAttr place3dTexture1.wim[0] projection1.pm; | ||
| - | connectAttr checker1.outColor projection1.image; | ||
| - | |||
| - | // else with option checked "as stencil" | ||
| - | shadingNode -asTexture stencil; | ||
| - | shadingNode -asUtility place2dTexture; | ||
| - | connectAttr place2dTexture2.outUV stencil1.uv; | ||
| - | connectAttr checker1.outColor stencil1.image; | ||
| - | // ------ 3d tex | + | * make compatible to python 3 <code python> |
| - | shadingNode -asUtility place3dTexture; | + | if sys.version_info[: |
| - | connectAttr place3dTexture2.wim[0] brownian1.pm; | + | import importlib |
| + | reload = importlib.reload # add reload | ||
| + | raw_input = input # add raw_input | ||
| + | xrange = range # range | ||
| + | long = int # int | ||
| + | unicode = str # str | ||
| </ | </ | ||
| - | ====DG shape node ==== | + | * integer division difference in py3 vs py2, a/b |
| + | * ref: https:// | ||
| + | * for safe, use < | ||
| + | 35// | ||
| - | * MPxSurfaceShape: | + | 35/60 = 0.583 #py3 |
| - | * MPxSurfaceShapeUI: | + | 35//60 = 0 # py3 |
| - | * MPxGeometryIterator: | + | |
| - | * MPxGeometryData: | + | |
| - | * MPxNode | + | |
| - | + | ||
| - | * shape component: | + | |
| - | * MFnComponent | + | |
| - | * MFnSingleIndexedComponent: | + | |
| - | * MFnDoubleIndexedComponent: | + | |
| - | * MFnTripleIndexedComponent: | + | |
| - | + | ||
| - | * shape component access: | + | |
| - | * MFnComponent | + | |
| - | * MFn:: | + | |
| - | * override access | + | |
| - | * MPxSurfaceShape:: | + | |
| - | * check call process (name, index, range): | + | |
| - | * MPxSurfaceShape:: | + | |
| - | * iterate component: | + | |
| - | * MPxGeometryIterator <code cpp> | + | |
| - | virtual bool acceptsGeometryIterator( bool writeable ); | + | |
| - | virtual bool acceptsGeometryIterator( MObject&, | + | |
| </ | </ | ||
| - | * component manipulator | ||
| - | * MPxSurfaceShape:: | ||
| - | * to speedup of setting attribute values, use MPxNode:: | ||
| - | * tweak storing vs no-history access | ||
| - | * set setAttr/ | ||
| - | * connection around geometry data | ||
| - | * define from MPxGeomtryData based on MPxData | ||
| - | * and iterator: virtual MPxGeometryIterator* iterator(MObjectArray& | ||
| - | * File save data | ||
| - | * define writeASCII, writeBinary from MPxData | ||
| - | ====DG deformer node ==== | + | ====== Python basics ====== |
| - | * custom deform attributes | + | * online python code runner: https:// |
| - | * MPxGeometryData | + | * Python download: http:// |
| - | * localShapeInAttr | + | * a cool python shell: http:// |
| - | * localShapeOutAttr | + | |
| - | * worldShapeOutAttr | + | |
| - | * MPxGeomtryIterator | + | |
| - | * match | + | |
| - | * createFullVertexGroup | + | |
| - | * geometryData | + | |
| - | ====DG shape - polygon API ==== | + | ** My Wiki Page related** |
| + | * how to publish Python script as standalone application: | ||
| + | * My App code share: [[devwiki: | ||
| + | * My Python GUI code template: [[devwiki: | ||
| - | | + | ** to read: ** |
| - | | + | * https:// |
| - | | + | * Code Like a Pythonista: Idiomatic Python http:// |
| - | | + | |
| - | * face vertices & uv ( face[id] -> fv[id]; fe[ids] -> {v_s, v_e}) | + | |
| - | * polygon attribute: | + | |
| - | * inMesh (storable) | + | |
| - | * outMesh | + | |
| - | * cachedInMesh (storable) | + | |
| - | * pnts (tweaks) (position offset for each vertex) | + | |
| - | * = modifier -> inMesh -> tweaks -> outMesh | + | |
| - | * or = outMesh | + | |
| - | * or cachedInMesh -> tweaks -> outMesh -cp-> cachedInMesh | + | |
| - | * polygon access, modify, create | + | |
| - | * MItMeshPolygon (Face comp, f-v, f-e, adjacent comp, uv, color-per-v, | + | |
| - | * MItMeshEdge (Edge comp, e-f, e-v, edge smooth, adjacent comp) | + | |
| - | * MItMeshVertex, | + | |
| - | * MFnMesh (mesh operate on comp) | + | |
| - | * meshFn.numPolygons(); | + | |
| - | * meshFn.numEdges(); | + | |
| - | * meshFn.numVertices(); | + | |
| - | * meshFn.polygonVertexCount(); | + | |
| - | * meshFn.numUVs(); | + | |
| - | * polygon history | + | |
| - | * original polyShape | + | |
| - | * polygon custom modifier | + | |
| - | * MPxCommand | + | |
| - | * MStatus doModifyPoly(); | + | |
| - | * MStatus redoModifyPoly(); | + | |
| - | * MStatus undoModifyPoly(); | + | |
| - | * polygon exporter | + | |
| - | * class polyExporter, | + | |
| + | ===== Python vs . ===== | ||
| + | * Python vs Swift | ||
| + | * https:// | ||
| - | ====== Maya in command line ====== | + | ===== Python Comment Tips ===== |
| - | * launch Maya GUI interface with custom path setting and startup cmd or script at launch time, windows batch example | + | * single line comment |
| - | set MAYA_MODULE_PATH=Z:/ | + | * multiple line comment <code python>''' |
| - | set MAYA_SHELF_PATH=Z:/ | + | line 1 |
| - | set MAYA_PRESET_PATH=Z:/ | + | line 2 |
| + | ''' | ||
| + | </code> | ||
| + | * block, section, partition <code python> | ||
| - | set MAYA_PLUG_IN_PATH=Z:/ | + | ######################################## |
| - | set MAYA_PLUG_IN_LIST=fbxmaya.mll; | + | # a major block of asset (40x#) |
| - | + | ######################################## | |
| - | set MAYA_SCRIPT_PATH=Z:/ | + | |
| - | set MAYA_SCRIPT_PATH=Z:/ | + | # |
| - | set MAYA_SCRIPT_PATH=Z:/ | + | # a function collection (30x-) |
| + | # | ||
| - | set PYTHONPATH=Z:/ | + | # ---- section comment ---- |
| - | set PYTHONPATH=Z:/ | + | |
| - | " | + | # function section tip |
| + | def ________Loading_Functions________(): | ||
| + | # 8x_ | ||
| + | pass | ||
| </ | </ | ||
| + | ===== Launch Python script ===== | ||
| - | * process | + | * launch in windows command batch file next to it<code batch> |
| + | call python %~dp0\\MyPythonScript.py</ | ||
| + | * launch | ||
| + | set myScriptPath to path to me | ||
| + | set myScriptFolderPath to POSIX path of (container of myScriptPath as string) -- in "/" | ||
| + | set myScriptName to name of myScriptPath | ||
| - | + | tell application " | |
| - | **maya flags** | + | do script |
| - | + | end tell | |
| - | ^ -v | version number | | + | |
| - | ^ -batch | start in batch mode | | + | |
| - | ^ -prompt | non-gui mode | | + | |
| - | ^ -proj [dir] | start in define project | | + | |
| - | ^ -command [mel] | start with defined mel command | + | |
| - | ^ -script [mel] | start with mel script file | | + | |
| - | ^ -recover | recovers last file | | + | |
| - | ^ -render [file] | render defined file | | + | |
| - | ^ -archive [file] | list required or related files to archive a scene | | + | |
| - | ^ -help | display flags help | | + | |
| - | ^ -noAutoloadPlugins | don't load any plugin | | + | |
| - | + | ||
| - | + | ||
| - | + | ||
| - | ====== Preference ====== | + | |
| - | + | ||
| - | * set viewport display color < | + | |
| - | # active=1 if for active color</code> | + | |
| - | + | ||
| - | ====== Viewport ====== | + | |
| - | + | ||
| - | * list all maya UI element and close some <code python> | + | |
| - | allWindows = cmds.lsUI(windows=1) | + | |
| - | toClose_win_list = [x for x in allWindows if x not in [' | + | |
| - | for each in toClose_win_list : | + | |
| - | cmsd.deleteUI(each) | + | |
| </ | </ | ||
| + | ===== OS system operation ===== | ||
| - | * select tool filter | + | * get user/home folder |
| - | cmds.selectType(allObjects=0) # query by cmds.selectType(allObjects=1, | + | os.path.expanduser(' |
| - | cmds.selectType(locator=1) | + | os.getenv(" |
| + | os.getenv(" | ||
| </ | </ | ||
| - | * display layer management | + | * make python code able to print unicode directly without .encode(' |
| - | cmds.select(objList) | + | import codecs |
| - | cmds.createDisplayLayer(name=" | + | sys.stdout = codecs.getwriter(' |
| - | + | ||
| - | cmds.setAttr(layer + ".displayType", | + | |
| </ | </ | ||
| - | * display defined curve smoother, (note only during current maya session, restart maya will back to default) | + | * get python program path<code python>import sys |
| - | cmds.displaySmoothness([' | + | print(sys.executable) # the python cmd or app containing the python call path |
| </ | </ | ||
| - | + | | |
| - | ====== Maya UI automation scripting ====== | + | os.path.dirname(ModuleName.__file__) |
| - | + | ||
| - | ^ mel name ^ python name ^ description ^ | + | |
| - | | $gChannelBoxName | mainChannelBox | channel box | | + | |
| - | | $gCommandReporter | cmdScrollFieldReporter1 | script editor result panel | | + | |
| - | | $gMainWindow | MayaWindow | maya main window | | + | |
| - | | graph1HyperShadeEd | graph1HyperShadeEd | material hypershade | | + | |
| - | | nodeEditorPanel2NodeEditorEd | nodeEditorPanel2NodeEditorEd | node editor | | + | |
| - | + | ||
| - | | + | |
| - | * get panel currently under pointer | + | |
| - | + | ||
| - | * list maya UI \\ ref： (scan through all Maya UI elements) http:// | + | |
| - | cmds.lsUI(type=' | + | |
| - | cmds.lsUI(windows=1) # list all window | + | |
| - | + | ||
| - | # trick cmds | + | |
| - | cmds.lsUI(controlLayouts=1, | + | |
| - | layoutType = cmds.objectTypeUI(' | + | |
| - | childs = cmds.layout(' | + | |
| </ | </ | ||
| - | * list maya UI's child and object type and parent<code python> | + | * get script path <code python>os.path.dirname(__file__)</ |
| - | # most maya layout has a -childArray flag to get child | + | |
| - | cmds.tabLayout(" | + | self.location = os.path.realpath(sys.modules[self.__class__.__module__].__file__) |
| - | # get UI type | + | self.location |
| - | cmds.objectType(" | + | |
| - | # then continue call with the object' | + | |
| - | + | ||
| - | # to get parent | + | |
| - | cmds.tabLayout(" | + | |
| </ | </ | ||
| - | * toggle maya window title bar visible and edit<code python> | + | * get class name <code python> |
| - | cmds.window(' | + | * get basename of folder and file <code python> |
| - | # hide title bar (true no UI by: press ctrl+space; then run this cmd) | + | * get file name without extension <code python> |
| - | + | file_name | |
| - | newT=" | + | import pathlib |
| - | cmds.window('MayaWindow', | + | file_name_2 |
| </ | </ | ||
| - | * toggle outline window | + | * get expanded and un-symbolic path <code python> |
| - | if cmds.window(' | + | os.path.abspath(__file__) |
| - | cmds.deleteUI(' | + | os.path.realpath(__file__) |
| - | else: | + | |
| - | mel.eval(' | + | |
| </ | </ | ||
| + | * path comparison <code python> | ||
| + | os.path.relpath(childPath, | ||
| + | os.path.commonprefix(list_of_paths) # get the common parent path of all input pathes | ||
| + | </ | ||
| + | * python code to detect platform, python version, bit <code python> | ||
| + | from sys import platform | ||
| - | * ignore a set of scripting/ | + | def get_platform(): |
| - | # ref: http:// | + | if platform.startswith('win'): |
| - | import maya.mel as mel | + | |
| - | import maya.cmds as cmds | + | elif platform.startswith('darwin'): |
| - | # nextFrame | + | |
| - | cmds.undoInfo(stateWithoutFlush=0) | + | return ' |
| - | mel.eval('playButtonStepForward') | + | |
| - | cmds.undoInfo(stateWithoutFlush=1) | + | |
| - | # previousFrame (' | + | import sys |
| - | cmds.undoInfo(stateWithoutFlush=0) | + | pyMode |
| - | mel.eval('playButtonStepBackward' | + | print(" |
| - | cmds.undoInfo(stateWithoutFlush=1) | + | |
| - | + | ||
| - | # nextKey ('.') | + | |
| - | cmds.undoInfo(stateWithoutFlush=0) | + | |
| - | cmds.currentTime(cmds.findKeyframe(timeSlider=1, | + | |
| - | cmds.undoInfo(stateWithoutFlush=1) | + | |
| - | + | ||
| - | # previousKey | + | |
| - | cmds.undoInfo(stateWithoutFlush=0) | + | |
| - | cmds.currentTime(cmds.findKeyframe(timeSlider=1, | + | |
| - | cmds.undoInfo(stateWithoutFlush=1) | + | |
| - | + | ||
| - | # firstKey | + | |
| - | cmds.undoInfo(stateWithoutFlush=0) | + | |
| - | cmds.currentTime(cmds.findKeyframe(which=' | + | |
| - | cmds.undoInfo(stateWithoutFlush=1) | + | |
| - | # lastKey | + | is_64bits |
| - | cmds.undoInfo(stateWithoutFlush=0) | + | print(is_64bits) |
| - | cmds.currentTime(cmds.findKeyframe(which=' | + | |
| - | cmds.undoInfo(stateWithoutFlush=1) | + | |
| </ | </ | ||
| + | * check file and path exists< | ||
| + | * scan file and folder content with pattern filtering <code python> | ||
| + | result_list = [x for x in os.listdir(scanPath) if os.path.isdir(os.path.join(scanPath, | ||
| + | # isdir for folder, isfile for file | ||
| + | cur_pattern = re.compile(' | ||
| + | result_list = [x for x in result_list if cur_pattern.match(x)] | ||
| - | * group a set of scripting in undo history <code python> | + | # jpg name example |
| - | cmds.undoInfo(openChunk=1) | + | jpg_list = [x.rsplit(' |
| - | # your scripting block here | + | |
| - | cmds.undoInfo(closeChunk=1) | + | |
| </ | </ | ||
| - | * get maya global variable to python | + | * rename file or folder < |
| - | mel.eval(' | + | * move file (always use full path for safe, and always check source and target exist before operation)<code python> |
| + | # file move within same drive | ||
| + | os.rename("/ | ||
| + | os.replace("/ | ||
| + | # work for folder and file and cross disk drive | ||
| + | shutil.move("/ | ||
| </ | </ | ||
| - | + | ||
| - | * toggle channel box nice and short names <code python> | + | * system cmds for each os<code python> |
| - | main_cb = 'mainChannelBox' | + | os.system('move " |
| - | next_state = not cmds.channelBox(main_cb, q=1, nn=1) | + | os.system(' |
| - | cmds.channelBox(main_cb, e=1, ln=next_state, nn=next_state) | + | |
| </ | </ | ||
| + | * cross-platform delivery from source | ||
| + | * win: frozen | ||
| + | * mac: frozen | ||
| + | * lin: packaged | ||
| + | * <code python> | ||
| + | def getSetup(): | ||
| + | if hasattr(sys, | ||
| + | return ' | ||
| + | elif is_packaged(): | ||
| + | return ' | ||
| + | return ' | ||
| + | </ | ||
| + | * change file permission <code python> | ||
| + | # ref: http:// | ||
| + | import os | ||
| + | import stat | ||
| + | os.chmod(" | ||
| + | </ | ||
| + | * windows register operation <code python> | ||
| + | PS_key = _winreg.OpenKey(_winreg.HKEY_LOCAL_MACHINE," | ||
| + | PS_APP = _winreg.QueryValueEx(PS_key, | ||
| - | * toggle script editor echo and clear echo <code python> | + | def ps_loc_win(): |
| - | cmdPanel = ' | + | |
| - | next_state | + | |
| - | cmds.cmdScrollFieldReporter(cmdPanel, e=1, eac=next_state) | + | |
| - | + | | |
| - | # clear echo | + | |
| - | cmds.cmdScrollFieldReporter(cmdPanel, | + | |
| </ | </ | ||
| - | * create script editor | + | * windows set default playback device |
| - | if cmds.cmdScrollFieldExecuter(ui_name, q=1, ex=1): | + | |
| - | cmds.deleteUI(ui_name) | + | |
| - | mui = cmds.cmdScrollFieldExecuter(ui_name, | + | |
| - | selected_text = cmds.cmdScrollFieldExecuter(mui, q=1, selectedText=1) | + | * run python script itself as admin <code python> |
| - | # change selected or insert text | + | import ctypes, sys |
| - | cmds.cmdScrollFieldExecuter(mui, e=1, insertText='# | + | def is_admin(): |
| + | try: | ||
| + | | ||
| + | except: | ||
| + | return False | ||
| - | # set search text and search next | + | if is_admin(): |
| - | cmds.cmdScrollFieldExecuter(mui, e=1, searchDown=1, | + | # Code of your program here |
| - | res = cmds.cmdScrollFieldExecuter(mui, | + | else: |
| - | + | # Re-run the program with admin rights | |
| - | # go to line number | + | |
| - | cmds.cmdScrollFieldExecuter(mui, e=1, currentLine=lineNum) | + | |
| - | + | ||
| - | # get script editor whole text | + | |
| - | script_text = cmds.cmdScrollFieldExecuter(mui, q=1, t=1) | + | |
| </ | </ | ||
| - | * create script history logger | + | * run cmd with admin (3rd party module) |
| - | mui = cmds.cmdScrollFieldReporter(ui_name)#, | + | # pywin32 : sourceforge.net/ |
| - | + | import win32com.shell.shell as shell | |
| - | # clear history | + | commands = 'echo hi' |
| - | cmds.cmdScrollFieldReporter(mui, e=1, clr=1) | + | shell.ShellExecuteEx(lpVerb=' |
| </ | </ | ||
| - | * open component editor and show skining tab <code python> | + | * control, start, stop, restart service (3rd party module method) |
| - | mel.eval(' | + | import win32serviceutil |
| - | # active smooth skin tab | + | serviceName |
| - | tab_name_list | + | win32serviceutil.RestartService(serviceName) |
| - | for i in range(len(tab_name_list)): | + | |
| - | if tab_name_list[i] == " | + | |
| - | cmds.tabLayout(" | + | |
| </ | </ | ||
| - | | + | ==== List File and sub-folders - the Correct Way ==== |
| - | for each in cmds.ls(sl=1): | + | |
| - | | + | |
| + | * so compare glob, python 2.7 os.walk() | ||
| + | * scandir is at least 10x faster than old os.walk, glob is 2x faster than old os.walk by skipping dir/file type checking | ||
| + | * 132s (walk) / 62s (glob) / 12s (scandir) | ||
| + | |||
| + | <code python> | ||
| + | import glob | ||
| + | def getDirData(top, | ||
| + | res = [] | ||
| + | | ||
| + | maxGlob = "/" | ||
| + | topGlob = os.path.join( top, maxGlob ) | ||
| + | allFiles = glob.glob( topGlob ) | ||
| + | res.extend( allFiles ) | ||
| + | # | ||
| + | return res | ||
| + | |||
| + | import os | ||
| + | def getDirData( top, maxDepth=1): | ||
| + | | ||
| + | # py3 option: better with scandir, | ||
| + | # py2 has: https:// | ||
| + | top = os.path.normpath(top) | ||
| + | res = [] | ||
| + | root_len = len(top) # | ||
| + | for root,dirs,files in os.walk(top, | ||
| + | depth = root[root_len: | ||
| + | if depth < maxDepth: | ||
| + | res += [os.path.join(root, | ||
| + | res += [os.path.join(root, | ||
| + | elif depth == maxDepth: | ||
| + | res += [os.path.join(root, | ||
| + | res += [os.path.join(root, | ||
| + | dirs[:] = [] # Don't recurse any deeper | ||
| + | return res | ||
| + | |||
| + | # detail inf: https:// | ||
| + | # can use with maya 2017 by zip out _scandir.pyd and scandir.py: (scandir-1.10.0-cp27-cp27m-win_amd64.whl) https:// | ||
| + | tmp_path = r' | ||
| + | tmp_path in sys.path or sys.path.append(tmp_path) | ||
| + | import scandir | ||
| + | def getDirData(top, maxDepth=1): | ||
| + | # py3.5 has built in, only for 2.7 | ||
| + | # https:// | ||
| + | top = os.path.normpath(top) | ||
| + | res = [] | ||
| + | root_len = len(top)# | ||
| + | for root, | ||
| + | depth = root[root_len: | ||
| + | if depth < maxDepth: | ||
| + | res += [os.path.join(root, | ||
| + | res += [os.path.join(root, | ||
| + | elif depth == maxDepth: | ||
| + | res += [os.path.join(root, | ||
| + | res += [os.path.join(root, | ||
| + | dirs[:] = [] # Don't recurse any deeper | ||
| + | return res | ||
| | | ||
| - | cmds.hyperGraph(" | + | # test |
| - | newBookmark | + | import time |
| - | cmds.setAttr(newBookmark+" | + | start = time.time() |
| + | result | ||
| + | end = time.time() | ||
| + | print(' | ||
| </ | </ | ||
| - | * add selected node in nodeEditor and related <code python> | + | * other module option: https://github.com/ |
| - | for each in cmds.ls(sl=1): | + | |
| - | cmds.nodeEditor(' | + | |
| - | cmds.getPanel(scriptType=" | + | ==== Copy File - the Correct Way ==== |
| - | cmds.nodeEditor(' | + | |
| - | </ | + | |
| - | * toggle channel box long short name display< | + | |
| - | import maya.mel as mel | + | |
| - | mel.eval(' | + | |
| - | </ | + | |
| - | * maya mel button with python function with parameter <code python> | + | |
| - | def process_func(data): | + | |
| - | print(data) | + | |
| - | cmds.button( command = lambda *args: process_func(' | + | |
| - | * show GraphEditor <code python> | + | |
| - | # get panel by name | + | |
| - | whichPanel = cmds.getPanel(withLabel=' | + | |
| - | cmds.scriptedPanel(whichPanel, | + | |
| - | wndName = whichPanel + " | + | |
| - | </ | + | |
| - | ====== Hotkey ====== | + | |
| - | **Note**: from Maya 2017 onwards, you need to duplicate default maya hotkey to be able to make changes, it is under Windows | + | |
| + | * ref: http:// | ||
| - | * reset hotkey < | + | * use python |
| - | * create hotkey | + | import |
| - | import | + | # copy: return target path, target can be file or folder |
| - | # cmds.hotkey(factorySettings=1) | + | shutil.copy(' |
| - | cmds.hotkey(autoSave=0) | + | shutil.copyfile(' |
| - | # -- toggle select mode | + | ''' |
| - | g_shiToggleMode=0 | + | 02/ |
| - | def toggleSelectMode(curMode): | + | 12/ |
| - | global g_shiToggleMode | + | 12/ |
| - | print([g_shiToggleMode, curMode]) | + | ''' |
| - | if g_shiToggleMode != curMode: | + | |
| - | if curMode == 1: | + | |
| - | cmds.SelectVertexMask() | + | |
| - | elif curMode == 2: | + | |
| - | cmds.SelectEdgeMask() | + | |
| - | elif curMode == 3: | + | |
| - | cmds.SelectFacetMask() | + | |
| - | elif curMode == 0: | + | |
| - | cmds.SelectToggleMode() | + | |
| - | g_shiToggleMode = curMode | + | |
| - | else: | + | |
| - | cmds.SelectToggleMode() | + | |
| - | | + | |
| - | for i in range(1,3+1): | + | shutil.copy2('d:/z_tmp/aa.jpg',' |
| - | cmds.nameCommand('NC_shiToggleMode_' | + | '' |
| - | cmds.hotkey(k=str(i), | + | 02/ |
| + | 02/ | ||
| + | '' | ||
| + | </ | ||
| + | * copy folder and its content <code python> | ||
| + | import shutil, errno | ||
| - | # -- viewport | + | def copyFolder(src, dst): |
| - | cmds.nameCommand(' | + | try: |
| - | cmds.hotkey(k=' | + | |
| - | # -- windows | + | |
| - | cmds.nameCommand(' | + | if exc.errno == errno.ENOTDIR: |
| - | cmds.hotkey(k=' | + | |
| - | # -- script editor | + | else: raise |
| - | cmds.nameCommand(' | + | |
| - | cmds.hotkey(k=' | + | # or use this |
| - | #-- hyperShade | + | distutils.dir_util.copy_tree(src_folder, tgt_folder) |
| - | cmds.nameCommand(' | + | |
| - | cmds.hotkey(k=' | + | |
| - | #-- graph editor | + | |
| - | cmds.nameCommand(' | + | |
| - | cmds.hotkey(k=' | + | |
| - | #-- custom | + | |
| - | cmds.nameCommand(' | + | |
| - | cmds.hotkey(k=' | + | |
| </ | </ | ||
| - | * Hotkey with Qt <code python> | + | * python more complete version for copy folder and its content |
| - | # ref: http://bindpose.com/custom-global-hotkey-maya/ | + | # ref: http://blog.csdn.net/liyuan_669/article/ |
| - | # qt import | + | # folder content to target folder content. created folders seams not same date, but file same date |
| - | try: | + | import |
| - | | + | import shutil |
| - | | + | def copy_tree(src, |
| - | | + | |
| - | except | + | |
| + | os.makedirs(dst) | ||
| + | | ||
| + | for name in names: | ||
| + | srcname = os.path.join(src, | ||
| + | dstname = os.path.join(dst, | ||
| + | try: | ||
| + | if symlinks and os.path.islink(srcname): | ||
| + | linkto = os.readlink(srcname) | ||
| + | os.symlink(linkto, | ||
| + | elif os.path.isdir(srcname): | ||
| + | copy_tree(srcname, | ||
| + | else: | ||
| + | # perform overrides | ||
| + | if os.path.isdir(dstname): | ||
| + | os.rmdir(dstname) | ||
| + | elif os.path.isfile(dstname): | ||
| + | os.remove(dstname) | ||
| + | shutil.copy2(srcname, | ||
| + | # other case like: devices, sockets etc. | ||
| + | | ||
| + | errors.append((srcname, | ||
| + | # catch the Error from the recursive copy_tree so that we can | ||
| + | # continue with other files | ||
| + | except OSError as err: | ||
| + | errors.extend(err.args[0]) | ||
| try: | try: | ||
| - | | + | |
| - | import shiboken2 as shiboken | + | except |
| - | except | + | # can't copy file access times on Windows |
| pass | pass | ||
| - | import maya.cmds | + | except OSError |
| - | import maya.OpenMayaUI as omui | + | |
| - | hotkey = {} | + | if errors: |
| - | mayaWindow = shiboken.wrapInstance(long(omui.MQtUtil.mainWindow()), QtWidgets.QWidget) | + | raise Error(errors) |
| - | def shortcut_process(keyname): | + | copy_tree('E:/book', 'E:/newbook') |
| - | if keyname == 'toggleWire': | + | </ |
| - | if 'modelPanel' | + | * use system command to copy <code python> |
| - | | + | src = 'd:/ |
| - | else: | + | tgt = 'd:/ |
| - | # give key event to maya | + | os.system('copy {0} {1}'.format(os.path.normpath(src),os.path.normpath(tgt)) ) |
| - | hotkey[keyname].setEnabled(0) | + | # normpath will change the slash for win from unix path |
| - | e = QtGui.QKeyEvent(QtCore.QEvent.KeyPress, QtCore.Qt.Key_F, | + | |
| - | QtCore.QCoreApplication.postEvent(mayaWindow , e) | + | |
| - | cmds.evalDeferred(partial(hotkey[keyname].setEnabled, | + | |
| - | | + | |
| - | pass | + | |
| - | # shortcut | + | os.system |
| - | hotkey[' | + | |
| - | hotkey[' | + | |
| - | hotkey[' | + | |
| </ | </ | ||
| + | * use system file manager to copy with system progress window (windows) <code python> | ||
| + | #ref: https:// | ||
| + | import pythoncom | ||
| + | from win32com.shell import shell, | ||
| - | ====== | + | def win_copy_process(src_files, |
| + | # win32com module | ||
| + | pfo = pythoncom.CoCreateInstance(shell.CLSID_FileOperation, | ||
| + | # Respond with Yes to All for any dialog | ||
| + | # ref: http:// | ||
| + | pfo.SetOperationFlags(shellcon.FOF_NOCONFIRMATION) | ||
| + | # Set the destionation folder | ||
| + | dst = shell.SHCreateItemFromParsingName(tgt_folder, | ||
| + | for f in src_files: | ||
| + | src = shell.SHCreateItemFromParsingName(f, | ||
| + | pfo.CopyItem(src, | ||
| + | # ref: http:// | ||
| + | success | ||
| + | # ref: sdn.microsoft.com/ | ||
| + | aborted | ||
| + | return success and not aborted | ||
| - | ** Python Maya API reference ** | + | file_list = [r' |
| + | tgt_folder = r' | ||
| + | win_copy_process(file_list, | ||
| + | </ | ||
| + | | ||
| + | # | ||
| + | # win32 | ||
| + | from win32com.shell import shell, shellcon | ||
| + | win32file.CopyFile (filename1, filename2, 1) | ||
| - | * Python script and Python Maya API example: | + | # win32com |
| - | * http:// | + | shell.SHFileOperation ( (0, shellcon.FO_COPY, filename1, filename2, |
| - | * Cope with Python in Maya C++ API with MScriptUtil, for passing by reference; re-solved in API 2.0 | + | # for the " |
| - | * http://www.chadvernon.com/ | + | # shellcon.FOF_RENAMEONCOLLISION: |
| - | * Maya API 2.0 for python, new python way of the redefined C++ API from Maya 2013 | + | # shellcon.FOF_NOCONFIRMATION: |
| - | * http:// | + | # shellcon.FOF_NOERRORUI: |
| + | # shellcon.FOF_SILENT: | ||
| + | # shellcon.FOF_NOCONFIRMMKDIR: | ||
| + | </code> | ||
| - | ** common api page offical reference page ** | + | ===== string operation ===== |
| - | * all : http:// | + | |
| - | ^ MSelectionList | http:// | + | |
| - | ^ MDagPath | http:// | + | unicode(myQStringObj) # unicode output |
| - | ^ MObject | http:// | + | unicode(myQStringObj.toUtf8(), encoding=" |
| - | ^ MFn | http:// | + | |
| - | ^ MFnDagNode | http:// | + | |
| - | ^ MFnDependencyNode | http:// | + | |
| - | ^ MScriptUtil | http:// | + | |
| - | ^ MFnMesh | http:// | + | |
| - | ^ MItDependencyGraph | http:// | + | |
| - | + | ||
| - | + | ||
| - | ===== DAG path, object and nodes ===== | + | |
| - | + | ||
| - | **om.MDagPath**: | + | |
| - | * path info for Dag node, the normal way, python/mel refering to maya objects like Transform | + | |
| - | * it is from the world node to a particular object in the DAG | + | |
| - | + | ||
| - | * string name to MDagPath | + | |
| - | selectionList = om.MSelectionList() | + | |
| - | selectionList.add(mesh_name) | + | |
| - | mesh_dagPath = om.MDagPath() | + | |
| - | selectionList.getDagPath(0, mesh_dagPath) | + | |
| - | print(mesh_dagPath.partialPathName()) # if done correct, it will give same name as mesh_name | + | |
| </ | </ | ||
| - | * MObject | + | * ref: |
| - | geo_obj.hasFn(om.MFn.kDagNode) # check if it is Dag node, then it can have a dag path | + | * UTF-8 is an encoding used to translate numbers into binary data. |
| - | geo_dagNode = om.MFnDagNode(geo_obj) # now it is a DagNode, then get DagPath from DagNode | + | * Unicode |
| - | print( geo_dagNode.partialPathName() ) # since DagNode also has name function | + | * text block to clean row list <code python> |
| - | geo_dagPath = om.MDagPath() | + | data_list |
| - | geo_dagNode.getPath(geo_dagPath) | + | |
| - | print( geo_dagPath.partialPathName() ) # proof geo_dagPath work correctly | + | |
| - | </ | + | |
| - | * MFnDagNode | + | |
| - | geo_dagPath | + | |
| - | geo_dagNode.getPath(geo_dagPath) | + | |
| - | print( geo_dagPath.partialPathName() | + | |
| </ | </ | ||
| - | **om.MObject**: | + | |
| - | * MDagPath | + | # coding: utf-8 |
| - | geo_transform_ojbect | + | my_special_string |
| - | geo_transform_ojbect.hasFn(om.MFn.kTransform) # true, then can safely cast to MFnTransform | + | print(u" |
| </ | </ | ||
| - | * string | + | * remove extra space from a string, |
| - | selectionList = om.MSelectionList() | + | tidy_name |
| - | selectionList.add(skinName) | + | |
| - | skinClusterObj = om.MObject() | + | |
| - | selectionList.getDependNode(0,skinClusterObj) | + | |
| - | skinClusterObj.hasFn(om.MFn.kSkinClusterFilter) # use for testing become cast to the object function | + | |
| - | </ | + | |
| - | + | ||
| - | **MFnDagNode**: | + | |
| - | * take input Object and provide function to access object as DAG Node, for its attribute and modify | + | |
| - | * it has same function as MDagPath like <code python> | + | |
| - | int = MDagPath.childCount() = MFnDagNode.childCount() | + | |
| - | MObject = MDagPath.child(index) = MFnDagNode.child(index) | + | |
| - | int = MDagPath.pathCount() = MFnDagNode.pathCount() | + | |
| - | + | ||
| - | # node only can return itself while path can return segment | + | |
| - | str = MDagPath.getPath(MDagPath, | + | |
| - | str = MDagPath.fullPathName() = MFnDagNode.fullPathName() | + | # just remove extra space |
| - | str = MDagPath.partialPathName() = MFnDagNode.partialPathName() | + | tidy_name |
| + | tidy_name | ||
| </ | </ | ||
| - | * but MFnDagNode has ability to add and remove child, also duplicate, instanceCount | + | ===== control flow operation ===== |
| - | * for its matric info, it has transformationMatrix() | + | |
| - | * but MDagPath has ability to get nearby or itself for transform MObject, cast into shape MDagPath | + | |
| - | * for its matric info, it has inclusiveMatrix(), | + | |
| - | * str to MFnDagNode | + | * define function |
| - | selectionList = om.MSelectionList() | + | def my_fun(para1): |
| - | selectionList.add(mesh_name) | + | print para1 |
| - | mesh_dagPath = om.MDagPath() | + | |
| - | selectionList.getDagPath(0, | + | |
| - | mesh_dagNode = om.MFnDagNode(mesh_dagPath) | + | |
| - | </ | + | |
| - | * MDagPath to MFnDagNode <code python> | + | |
| - | my_dagNode = om.MFnDagNode(my_dagPath) | + | |
| - | </ | + | |
| - | * MObject to MFnDagNode <code python> | + | |
| - | my_obj.hasFn(om.MFn.kDagNode) | + | |
| - | my_dagNode = om.MFnDagNode(my_obj) | + | |
| </ | </ | ||
| + | * logic and condition and loop operation <code python> | ||
| + | print tmpitem | ||
| - | <code python> | + | if tmp > 0: |
| - | import maya.OpenMaya as om | + | print ' |
| - | selected | + | elif x == 0: |
| - | om.MGlobal.getActiveSelectionList(selected) | + | print ' |
| - | dagPath | + | else: |
| - | selected.getDagPath(0,dagPath) | + | print ' |
| - | print(dagPath.fullPathName()) # current full path name | + | |
| - | print(dagPath.partialPathName()) # current node name | + | |
| - | # get shape count | + | # logic operation |
| - | countUtil = om.MScriptUtil() | + | x or y |
| - | countUtil.createFromInt(0) | + | x and y |
| - | tmpIntPtr = countUtil.asUintPtr() # unsigned int | + | not x |
| - | dagPath.numberOfShapesDirectlyBelow(tmpIntPtr) | + | |
| - | print(countUtil.getUint(tmpIntPtr)) | + | |
| - | print(dagPath.childCount()) # another alternative method | + | |
| - | + | ||
| - | # get its Shape as MDagPath | + | |
| - | dagPath.extendToShape() # MDagPath: change to shape path, will error if has no shape or more than 1 shape | + | |
| - | dagPath.extendToShapeDirectlyBelow(0) # same as above; but won't error when more than 1 shape | + | |
| - | print(dagPath.fullPathName()) # shape, if already shape, also return itself | + | |
| - | + | ||
| - | # get itself as Node | + | |
| - | dagObj = dagPath.node() # MObject | + | |
| - | dagObj.hasFn(om.MFn.kDagNode) # check if its DAG node, not DG node | + | |
| - | dagNode = om.MFnDagNode(dagObj) # use function to handle this MObject | + | |
| - | print(dagNode.fullPathName()) | + | |
| - | + | ||
| - | # get its Transform as Node | + | |
| - | dagObj = dagPath.transform() # MObject: return its transform MObject, if already transform, it return itself | + | |
| - | dagNode = om.MFnDagNode(dagObj) | + | |
| - | print(dagNode.fullPathName()) # transform node full dag path | + | |
| </ | </ | ||
| - | + | | |
| - | ===== DG nodes ===== | + | try: |
| - | + | val = test(A) | |
| - | | + | except: |
| - | my_DGNode | + | pass |
| - | print(my_DGNode.name()) | + | # ref: https:// |
| </ | </ | ||
| - | * MFnDependencyNode also has function like attribute editor, editing all the plug/ | + | ===== data operation ===== |
| - | * Conversion from other data | + | * data type check <code python> |
| - | * str name to MFnDependencyNode | + | isinstance(Vehicle(), Vehicle) # returns True |
| - | selectionList = OpenMaya.MSelectionList() | + | type(Vehicle()) == Vehicle |
| - | selectionList.add(my_name) | + | isinstance(Truck(), Vehicle) |
| - | my_obj = OpenMaya.MObject() | + | type(Truck()) == Vehicle |
| - | selectionList.getDependNode(0,my_obj) | + | |
| - | my_obj.hasFn(om.MFn.kDependencyNode) # check before convert | + | |
| - | my_dgNode = om.MFnDependencyNode(my_obj) | + | |
| - | </ | + | |
| - | * MDagPath to MFnDependencyNode <code python> | + | |
| - | my_obj = my_dagPath.node() | + | |
| - | my_obj.hasFn(om.MFn.kDependencyNode) # check before convert | + | |
| - | my_dgNode = om.MFnDependencyNode(my_obj) | + | |
| - | </ | + | |
| - | * MFnDagNode to MFnDependencyNode <code python> | + | |
| - | my_dagPath = my_dagNode.getPath() | + | |
| - | my_obj = my_dagPath.node() | + | |
| - | my_obj.hasFn(om.MFn.kDependencyNode) # check before convert | + | |
| - | my_dgNode = om.MFnDependencyNode(my_obj) | + | |
| - | </ | + | |
| - | * **MDGModifier**: | + | |
| - | other common class: | + | # check string, both python 2,3 |
| - | * **om.MPxNode**: | + | isinstance(my_data, |
| + | # check list | ||
| + | isinstance(my_data, | ||
| - | ===== MPlugs | + | # check not None, note, None is its own type and has only one instance |
| + | my_vec != None # sometime, it may cause error when = try to read certain way | ||
| + | my_vec is not None # this way is preferred to be error free | ||
| + | isinstance(my_vec, | ||
| - | ref: http:// | + | # compare type |
| - | + | if type(A) is type(B): | |
| - | * MPlug is just API way of calling attribute. | + | print('Same Class') |
| - | * MPlug has network(built-in) and non-networked(user-created) ones | + | |
| - | * MPlug can be a single attribute plug, or a array/ | + | # note : is for same object |
| - | * MPlug can have its own MPlug, as compound plug, which can be accessed with .child(); the opposite | + | |
| - | * Array type MPlug can access its list of plug by .elementByLogicalIndex() and .elementByPhysicalIndex() method; the opposite is .array() | + | |
| - | + | ||
| - | Array in MPlug: | + | |
| - | * array are sparse. | + | |
| - | * Logical Index used in MEL are sparse; | + | |
| - | * Physical Index is not sparse, it range from 0-numElements()-1, | + | |
| - | * numElement only refer to data in datablock, to get update value, use <code python> | + | |
| - | print(my_arraPlugy.numElements())</ | + | |
| - | + | ||
| - | === Logical Index and Physical Index of Joint in skincluster === | + | |
| - | + | ||
| - | **Concept of Dynamic array** - a pre-defined-size list with pre-loaded empty items | + | |
| - | * as you can create array with any pre-defined size, Maya keep it in memory up to the size of last non-empty element; (ref: http:// | + | |
| - | * in addition, Maya is using the sparse array structure | + | |
| - | * Maya will automatically resize | + | |
| - | * thus the 2 methods in MPlug, where you can get plugs of the array by either logical index (sparse, means with zeros) or physical indexes (those with actual data connection). | + | |
| - | * ref: http:// | + | |
| - | + | ||
| - | * example MEL code <code javascript> | + | |
| - | $nameArray[5]=" | + | |
| - | print(" | + | |
| - | print $nameArray; // null null null null null objA | + | |
| - | print(" | + | |
| - | + | ||
| - | $logical_index | + | |
| - | print(" | + | |
| - | print(" | + | |
| - | print(" | + | |
| - | print(" | + | |
| - | print(" | + | |
| - | + | ||
| - | string $nameArray_autoNonSparse_means_noEmpty[]; | + | |
| - | for($each in $nameArray){ | + | |
| - | if($each != "" | + | |
| - | $cur_index = size($nameArray_autoNonSparse_means_noEmpty); | + | |
| - | $nameArray_autoNonSparse_means_noEmpty[$cur_index] = $each; | + | |
| - | } | + | |
| - | } | + | |
| - | print(" | + | |
| - | print($nameArray_autoNonSparse_means_noEmpty); | + | |
| - | print(" | + | |
| - | $physical_index = stringArrayFind( " | + | |
| - | print(" | + | |
| - | + | ||
| - | // clear from memory | + | |
| - | clear($nameArray); | + | |
| </ | </ | ||
| - | * so the logical index of a array is the number is in the [], and as like Python list and other language arrays | ||
| - | * as shown in Maya skincluster joint list connection \\ {{graphic: | ||
| - | |||
| - | **The Physical index of joint in the influence list** | ||
| - | * the most obvious demonstration of physical index of joint is in the component editor - skin weight tab \\ {{graphic: | ||
| - | * since " | ||
| - | * the weight table is actual representation of the weight data; | ||
| - | * **including all the vertex** | ||
| - | * **including all the joints linked to skinCluster**, | ||
| - | * (make sure in component editor > option menu > Uncheck hide zero column) | ||
| - | * (make sure in component editor > option menu > Uncheck sort alphabetically column) | ||
| - | * {{graphic: | ||
| - | * and when saving, actual weight data store in a 1 dimension array { vtx[0][jnt1], | ||
| - | * **with joint name as column header, and vtx index as row header** | ||
| - | * so column index is the actual **Physical index** of joint used in referring weight data table | ||
| - | * while the **logical index** of joint used in referring current connection flow. | ||
| - | |||
| - | ===== Math Node before Calculation with API ===== | ||
| - | * **MScriptUtil** ref: http:// | + | * data type convertion |
| - | * Input: createFrom*() Int, Double, List+len | + | str(42) |
| - | * middle: as*Ptr() # Int, Short, Float, Double, Uint, Bool, Char, Uchar, x2-4 | + | |
| - | * output: get*() # Int, Short, Float, Double, Uint, Bool, Char, Uchar, x2-4 | + | |
| - | * code workflow | + | |
| - | py_var = 0 # your type, say Unsign Int | + | |
| - | util = om.MScriptUtil() | + | |
| - | util.createFromInt(py_var) # same as your type | + | |
| - | util_ptr = util.asUintPtr() # same as your type | + | |
| - | api_obj.api_function_return_a_value(util_ptr) # use pointer to hold the result value | + | |
| - | py_var = util.getUint(util_ptr) # same as your type | + | |
| - | print(py_var) # new value from API | + | |
| </ | </ | ||
| + | * get datetime date <code python> | ||
| + | * get processing time <code python> | ||
| + | import time | ||
| - | ===== Transform, Vector, Matrix, Quaternion, Angular Math ===== | + | start = time.time() |
| - | * other align vector related reading | + | print(" |
| - | /* | + | end = time.time() |
| - | rot: rot vector around another vector by a degree | + | print(end - start) |
| - | rad_to_deg, deg_to_rad | + | |
| - | */ | + | |
| </ | </ | ||
| - | * **MVector** functions | + | * wild char process |
| - | # ref: https:// | + | import glob |
| - | # MVector: rotateBy | + | os.chdir(path) |
| - | # get a MVector result by rotate one Vector around default x,y,z axis by certain degree | + | for file in glob.glob(" |
| + | print file | ||
| + | |||
| + | tmplist=glob.glob(' | ||
| - | # MVector: rotateBy (const MQuaternion &) const | + | # other method: fnmatch and re |
| - | # case 1: get a MVector result by rotate one Vector around another Vector by certain degree | + | |
| - | res_vector = mainVector.rotateBy( maya.OpenMaya.MQuaternion(math.radians(rotDegree), | + | |
| - | # case 2: get a MVector result by rotate one Vector by a swing motion defined by start vector to end vector | + | |
| - | res_vector = mainVector.rotateBy( maya.OpenMaya.MQuaternion(MotionStartVector, | + | |
| </ | </ | ||
| - | * **Align Object Axis one at a time to Vector direction** (OpenMaya method) | + | * string operation |
| - | import maya.OpenMaya as om | + | name=" |
| - | import math | + | print name[3:-13].replace(' |
| - | def getLocalVecToWorldSpaceAPI(obj, | + | |
| - | # ref: http:// | + | |
| - | # take obj's local space vec to workspace, default object x axis | + | |
| - | selList = om.MSelectionList() | + | |
| - | selList.add(obj) | + | |
| - | nodeDagPath = om.MDagPath() | + | |
| - | selList.getDagPath(0, | + | |
| - | matrix = nodeDagPath.inclusiveMatrix() | + | |
| - | vec = (vec * matrix).normal() | + | |
| - | return vec.x, vec.y, vec.z | + | |
| - | + | ||
| - | # define objects | + | |
| - | # a locator reference that we are aligning our pCube object to | + | len(str) |
| - | # of course, you dont need a refLoc, you can use Vector from other data as well | + | |
| - | # here locator is just a visual example | + | |
| - | refLoc = ' | + | |
| - | obj = ' | + | |
| - | # grab object transform function lib | + | "hello world".title() |
| - | selectionList = om.MSelectionList() | + | 'Hello World' |
| - | selectionList.add( obj ) | + | |
| - | dagPath = om.MDagPath() | + | |
| - | selectionList.getDagPath(0, | + | |
| - | fnTransform = om.MFnTransform(dagPath) | + | |
| - | # STEP 1: align Y axis first | + | # remove Whitespace on the both sides: |
| - | refLoc_normal_y | + | s = " |
| - | aim_vec_y | + | s = s.strip() |
| - | obj_normal_y = getLocalVecToWorldSpaceAPI(obj, | + | |
| - | obj_vec_y = om.MVector(*obj_normal_y) | + | |
| - | rot_quaternion = obj_vec_y.rotateTo(aim_vec_y) | + | |
| - | # absolute version | + | |
| - | # | + | |
| - | # relative transform on top of existing obj transform | + | |
| - | fnTransform.rotateBy(rot_quaternion) | + | |
| - | # STEP 2: align Z axis | + | # remove Whitespace on the right side: |
| - | refLoc_normal_z | + | s = s.rstrip() |
| - | aim_vec_z = om.MVector(*refLoc_normal_z) | + | # remove Whitespace on the left side: |
| - | obj_normal_z = getLocalVecToWorldSpaceAPI(obj, | + | s = s.lstrip() |
| - | obj_vec_z | + | |
| - | rot_quaternion = obj_vec_z.rotateTo(aim_vec_z) | + | |
| - | fnTransform.rotateBy(rot_quaternion) | + | |
| </ | </ | ||
| - | * get position <code python> | + | Data Type |
| - | #general | + | * Lists []: a list of values. Each one of them is numbered, starting from zero - the first one is numbered zero, the second |
| - | pos = cmds.xform(obj, q=1, t=1, ws=1) | + | * Tuples (): are just like lists, but you can't change their values. The values that you give it first up, are the values that you are stuck with for the rest of the program. Again, each value is numbered starting from zero, for easy reference. Example: the names of the months of the year. |
| + | * Dictionaries {'':'', | ||
| - | # loc | + | * list operation |
| - | pos = cmds.getAttr(loc+'.worldPosition' | + | [1,2,3] |
| - | pos = cmds.pointPosition(loc) # world position | + | len(arrayName) # size of list |
| + | # add value to all elements of list | ||
| + | my_list=[1, | ||
| + | new_list = [x+1 for x in my_list] # [2,4,6,8,9] | ||
| - | #cv - local position from origin at creation time | + | list.append(obj) |
| - | cmds.getAttr(' | + | list.extend(list) |
| - | cmds.pointPosition(' | + | list.index(obj) |
| + | list.count(obj) # count appearance of obj | ||
| - | # vtx - | + | # array to string and string to array |
| - | cmds.getAttr(' | + | sentence = [" |
| - | cmds.getAttr(" | + | ' |
| - | cmds.pointPosition(' | + | list=[3.1,121.2,34.1] |
| - | cmds.setAttr(" | + | ', |
| - | cmds.setAttr(" | + | |
| - | cmds.setAttr(" | + | |
| - | # vtx - local position relative to pivot | + | '3.1, 121.2, 34.1' |
| + | # 2nd number make how many split point | ||
| + | '3.1, 121.2, 34.1' | ||
| - | # loc, vtx, cv, uv, point - global position | + | # list sort (modify itself) |
| - | pos = cmds.pointPosition(pointObj) | + | versionList.sort(reverse=1) # higher |
| - | </ | + | versionList.sort() |
| - | * freeze transform | + | |
| - | * it will make curve like re-created based on current result shape, previous local cv position is same as global position | + | |
| - | * it will make polygon pivot change back to origin, and vtx global position stay same, local position will same as current global position, and its offset value will be based on previous value | + | |
| - | * code <code python> | + | |
| - | cmds.makeIdentity(cmds.ls(sl=1), | + | |
| - | </ | + | |
| - | ====== Selection in API ====== | + | |
| - | * get current selection <code python> | + | str([-4, -2, 0, 2, 4]) # ' |
| - | selected = om.MSelectionList() | + | bb_str =' |
| - | om.MGlobal.getActiveSelectionList(selected) | + | |
| - | </ | + | |
| - | * get current soft selection and weight< | + | # list compare |
| - | def getVtxSelectionSoft_OpenMaya(): | + | [-4, -2, 0, 2, 4] == [-4, -2, 0, 2, 3] # false |
| - | # ref: http:// | + | |
| - | startTime = cmds.timerX() # 0.13s > no string 0.07s | + | |
| - | | + | |
| - | softSelectionList = om.MSelectionList() | + | |
| - | softSelection = om.MRichSelection() | + | |
| - | om.MGlobal.getRichSelection(softSelection) | + | |
| - | softSelection.getSelection(selectionList) | + | |
| - | selectionPath = om.MDagPath() | + | # multiple |
| - | selectionObj = om.MObject() | + | |
| - | iter = om.MItSelectionList( selectionList, | + | |
| - | | + | |
| - | id_list = [] | + | |
| - | weights = [] | + | |
| - | node_list = [] | + | |
| - | while not iter.isDone(): | + | |
| - | iter.getDagPath( selectionPath, | + | |
| - | selectionPath.pop() #Grab the parent of the shape node | + | |
| - | node = selectionPath.fullPathName() | + | |
| - | compFn = om.MFnSingleIndexedComponent(selectionObj) | + | |
| - | getWeight = lambda i: compFn.weight(i).influence() if compFn.hasWeights() else 1.0 | + | |
| - | node_list.append(node) | + | |
| - | for i in range(compFn.elementCount()): | + | |
| - | # | + | |
| - | id_list.append(compFn.element(i)) | + | |
| - | weights.append(getWeight(i)) | + | |
| - | iter.next() | + | |
| - | totalTime = cmds.timerX(startTime=startTime) | + | |
| - | print(" | + | |
| - | return | + | |
| - | </ | + | |
| - | * API way to get selection vertex ids (single geo case), and set selection using vertex ids <code python> | + | wMap_zero_Jnt=[x for x in wMap_All_Jnt if x not in wMap_Jnt_tgt] # remove list from list |
| - | def createVtxSelection_cmds(objName, | + | |
| - | startTime = cmds.timerX() # 0.039s | + | |
| - | result_sel = [' | + | |
| - | totalTime = cmds.timerX(startTime=startTime) | + | |
| - | print(" | + | |
| - | return result_sel | + | |
| - | + | ||
| - | def createVtxSelection_OpenMaya(objName, | + | |
| - | # ref: http:// | + | |
| - | startTime = cmds.timerX() # 0.009s | + | |
| - | sel = om.MSelectionList() | + | |
| - | sel.add(objName) | + | |
| - | mdag = om.MDagPath() | + | |
| - | sel.getDagPath(0, | + | |
| - | util = om.MScriptUtil() | + | |
| - | util.createFromList(id_list, | + | |
| - | ids_ptr = util.asIntPtr() | + | |
| - | ids = om.MIntArray(ids_ptr, | + | |
| - | + | ||
| - | compFn = om.MFnSingleIndexedComponent() | + | |
| - | components = compFn.create( om.MFn.kMeshVertComponent ) | + | |
| - | compFn.addElements(ids) | + | |
| - | + | ||
| - | result_sel = om.MSelectionList() | + | |
| - | result_sel.add(mdag, | + | |
| - | totalTime = cmds.timerX(startTime=startTime) | + | |
| - | print(" | + | |
| - | return result_sel | + | |
| - | + | ||
| - | def getVtxSelection_cmd(l=0): | + | |
| - | startTime = cmds.timerX() # 0.18s | + | |
| - | selected = cmds.ls(sl=1, | + | |
| - | id_list | + | |
| - | totalTime = cmds.timerX(startTime=startTime) | + | |
| - | print(" | + | |
| - | return selected[0].split[' | + | |
| - | + | ||
| - | def getVtxSelection_OpenMaya(): | + | |
| - | startTime = cmds.timerX() # 0.11s > no comp iter: 0.039 | + | |
| - | # normal selection | + | |
| - | normalSelectionList = om.MSelectionList() | + | |
| - | om.MGlobal.getActiveSelectionList(normalSelectionList) | + | |
| - | selectionPath = om.MDagPath() | + | |
| - | selectionObj = om.MObject() | + | |
| - | indexList = om.MIntArray() | + | |
| - | iter = om.MItSelectionList( normalSelectionList, | + | |
| - | # | + | |
| - | node_list = [] | + | |
| - | id_list = [] | + | |
| - | while not iter.isDone(): | + | |
| - | iter.getDagPath( selectionPath, | + | |
| - | selectionPath.pop() | + | |
| - | node = selectionPath.fullPathName() | + | |
| - | compFn = om.MFnSingleIndexedComponent(selectionObj) # flatten the component selection | + | |
| - | compFn.getElements(indexList) | + | |
| - | id_list.extend(list(indexList)) | + | |
| - | node_list.append(node) | + | |
| - | ''' | + | |
| - | for i in range(compFn.elementCount()): | + | |
| - | normalSelectionElements.append(' | + | |
| - | id_list.append(compFn.element(i)) | + | |
| - | ''' | + | |
| - | iter.next() | + | |
| - | totalTime = cmds.timerX(startTime=startTime) | + | |
| - | print(" | + | |
| - | return | + | |
| - | </ | + | |
| - | ====== Modeling in Python vs Mel ====== | + | |
| - | * list of cmds in both python and mel for modeling | + | a = [1, 2, 3, 4, 5] |
| + | b = [9, 8, 7, 6, 5] | ||
| + | common = set(a) & set(b) #[5], no order applied | ||
| - | <code python> | + | [i for i, j in zip(a, b) if i == j] # [5] for equal-sized lists, which order matters |
| - | # mel: DeleteHistory; | + | |
| - | cmds.DeleteHistory() | + | |
| - | # show poly vertex | + | version_list_prefix=[" |
| - | # mel: setPolygonDisplaySettings("verts"); | + | version_list_postfix=[" |
| - | cmds.polyOptions(r=1, activeObjects=1, dv=1) | + | version_list_color=[" |
| + | for each, | ||
| + | print(each+" "+post+" | ||
| + | |||
| + | # list slice operation | ||
| + | # n = len(L) | ||
| + | # item = L[index] | ||
| + | # seq = L[start: | ||
| + | # seq = L[start: | ||
| + | seq = L[::2] # get every other item, starting with the first | ||
| + | seq = L[1::2] # get every other item, starting with the second | ||
| - | # mel: ToggleFaceNormalDisplay; | + | seq=L[::-1] # reverse reading list |
| - | cmds.ToggleFaceNormalDisplay() | + | list(reversed(seq)) # generate a list reversed |
| + | L.reverse() # reverse list, it changed original list | ||
| + | seq=L[::-2] # reverse reading list, and get every other item | ||
| - | # mel: ToggleBackfaceGeometry; | + | list=[1, |
| - | cmds.ToggleBackfaceGeometry() | + | seq=list[:: |
| - | # mel: ReversePolygonNormals; | + | # list to pair list |
| - | cmds.ReversePolygonNormals() | + | info = [' |
| + | info_pair = zip(info[::2], info[1::2]) | ||
| + | # [(' | ||
| - | # hard edge | + | # list flatten, and remove duplicates |
| - | # mel: SoftPolyEdgeElements(0); | + | nestList = [[2, |
| - | cmds.polySoftEdge(a=0) | + | flatList |
| - | # show border | + | # delete a element from list |
| - | # mel: ToggleBorderEdges; | + | a = [1,2,3,4] |
| - | cmds.ToggleBorderEdges() | + | del(a[2]) # [1,2,4] |
| - | # dialog to change edge width display | + | # for large list |
| - | # mel: ChangeEdgeWidth; | + | import itertools |
| - | cmds.ChangeEdgeWidth() | + | flatList = set( list(itertools.chain.from_iterable(nestList)) ) # for same type element list, no mix of list and element like [[5],6], as it will error |
| - | # show UV window | + | import operator |
| - | # mel: TextureViewWindow; | + | flatList = set( reduce(operator.add, map(list, nestList)) |
| - | cmds.TextureViewWindow(); | + | |
| - | # mel: CenterPivot; | + | |
| - | cmds.CenterPivot() | + | |
| - | # turn on / off symmetric modeling | + | # for any mix list |
| - | ''' | + | def flatFn(mainList): |
| - | symmetricModelling -e -symmetry true; | + | |
| - | symmetricModelling -e -about " | + | for each in mainList: |
| - | symmetricModelling -e -about " | + | if isinstance(each, (list, tuple)): |
| - | symmetricModelling -e -axis " | + | |
| - | ''' | + | else: |
| - | cmds.symmetricModelling(e=1, symmetry=1) | + | |
| - | cmds.symmetricModelling(e=1, symmetry=0) | + | |
| - | + | ||
| - | # face selection to edge border selection | + | |
| - | # mel: select -r `polyListComponentConversion -ff -te -bo`; | + | |
| - | cmds.select(cmds.polyListComponentConversion(ff=1, te=1, bo=1),r=1) | + | |
| - | + | ||
| - | # selection to shell | + | |
| - | # mel: ConvertSelectionToShell; | + | |
| - | cmds.ConvertSelectionToShell() | + | |
| - | + | ||
| - | # selection to create layer | + | |
| - | ''' | + | |
| - | string $tmpname[]=`ls -sl`; | + | |
| - | createDisplayLayer -name ($tmpname[0]+" | + | |
| - | ''' | + | |
| - | selected = cmds.ls(sl=1) | + | |
| - | if len(selected)> | + | |
| - | | + | |
| | | ||
| - | # remove from layers | + | flatList = set( flatFn(nestList) ) |
| - | # mel: editDisplayLayerMembers -noRecurse " | + | |
| - | cmds.editDisplayLayerMembers(" | + | |
| - | #### curve ##### | + | </ |
| + | * dictionary operation <code python> | ||
| + | # ref: http:// | ||
| + | dict.clear() | ||
| + | dict.get(key, | ||
| + | dict.has_key(key) | ||
| + | dict.items() | ||
| + | dict.keys() | ||
| + | dict.values() | ||
| + | len(dict) | ||
| - | # show CV | + | #example, obj property |
| - | # mel: ToggleCVs; | + | dict = {' |
| - | cmds.ToggleCVs() | + | |
| - | # show editable point | + | #example, obj list |
| - | # mel: ToggleEditPoints; | + | dict = {' |
| - | cmds.ToggleEditPoints() | + | |
| - | # rebuild curve dialog | + | # delete key |
| - | # mel: RebuildCurveOptions; | + | my_dict.pop(key_name, |
| - | cmds.RebuildCurveOptions() | + | </ |
| + | * set operation <code python> | ||
| + | set( (" | ||
| + | # set([' | ||
| - | # detach surface by edge or isopam | + | fib=set( [1, |
| - | # mel: DetachCurve; | + | prime=set( [2, |
| - | cmds.DetachCurve() | + | combine=fib | prime # set([1, 2, 3, 5, 7, 8, 11, 13]) |
| + | common=fib & prime #set([2, 3, 5, 13]) | ||
| + | diff = fib - prime # set([8, 1]) | ||
| + | fib ^ prime # combine - common #set([1, 7, 8, 11]) | ||
| - | # detach/ | + | # <, <=, >, >=, ==, !=, in, not in works in set |
| - | # mel: CutCurve; AttachCurve; | + | len(fib)=6 |
| - | cmds.CutCurve() | + | max(fib)=13 |
| - | cmds.AttachCurve() | + | min(fib)=1 |
| + | sum(fib)=32 | ||
| + | any(set([false, | ||
| + | all(set([false, | ||
| + | set.add(new) | ||
| + | set.remove(old) | ||
| </ | </ | ||
| - | ====== Modeling in API ====== | + | * list attribute of a object <code python> |
| + | ===== turn a file into a module | ||
| - | **Vertex check in API way** | + | |
| - | + | import FileName | |
| - | * poly count <code python> | + | FileName.functionName() # call function side that file |
| - | vtx_cnt = cmds.polyEvaluate(geoName, v=1) | + | |
| </ | </ | ||
| - | * get transform to shape to vtx <code python> | ||
| - | selected = om.MSelectionList() | ||
| - | om.MGlobal.getActiveSelectionList(selected) | ||
| - | dagPath | + | ===== turn a folder into a module ===== |
| - | selected.getDagPath(0, | + | |
| - | print(dagPath.fullPathName()) # transform | + | * you can turn a list of python file under same folder into a module by create a empty file under the directory: < |
| - | dagPath.extendToShape() # .extendToShapeDirectlyBelow() if dont want to get child of child; will error if has no shape | + | * it will automatically turn the folder into a module so that you can call each file after import folder like <code python> |
| - | print(dagPath.fullPathName()) # shape, if shape, also return itself | + | import FolderName |
| + | from FolderName import FileName | ||
| + | </ | ||
| + | * whenever you call import FolderName, the __init__py will be run-ed first, so you can put some code inside to do some pre-run task, or append the folder into python path <code python __init__.py> | ||
| + | import os, sys | ||
| + | my_path = os.path.dirname(__file__) | ||
| + | my_path in sys.path or sys.path.append(my_path) | ||
| + | </ | ||
| - | dagPath.transform() # transform | + | ===== check module installed ===== |
| - | mesh = om.MFnMesh(dagPath.node()) # MObject | + | * python code <code python> |
| - | print(mesh.numVertices()) # vtx count | + | dir(moduleName) |
| + | #import moduleName | ||
| + | #then type moduleName | ||
| + | </ | ||
| + | * check module in shell command <code bash> | ||
| + | * change current working path< | ||
| </ | </ | ||
| - | **Vertex Check** | + | ===== cross python file reference===== |
| - | * test empty geo shape <code python> | + | * import python function from another python file<code python> |
| - | # test empty geo shape | + | import sys |
| - | all_geo_list = cmds.ls(type=' | + | sys.path.append("/ |
| - | zeroVtx_list = [] | + | # method 1 |
| - | for each in all_geo_list: | + | import sample |
| - | if cmds.polyEvaluate(each, v=1) == 0: | + | sample.abcd() |
| - | | + | # method 2 |
| - | print(zeroVtx_list) | + | from sample import abcd |
| + | abcd() | ||
| + | #method 3 | ||
| + | from sample import * | ||
| + | abcd() | ||
| </ | </ | ||
| + | * run another python script <code python> | ||
| + | execfile(" | ||
| + | # python 3, that one not work, use this one | ||
| + | exec(open(" | ||
| + | </ | ||
| + | * pass parameter to a python script (ref: http:// | ||
| + | # method 1: python myscript.py arg1 arg2 | ||
| + | import sys | ||
| - | **Face Check and Correct** | + | print ' |
| + | print ' | ||
| - | * double side face <code python> | + | # method 2 |
| - | shape_list = cmds.ls(type=' | + | import getopt, sys |
| - | for shape in shape_list: | + | |
| - | cmds.setAttr(shape+" | + | |
| </ | </ | ||
| + | * example code for a mel file to html file process, in both module and app way | ||
| + | * run code <code bash> | ||
| + | * run in python <code python> | ||
| + | viewMel.viewMel_html(' | ||
| + | </ | ||
| + | * code <code python> | ||
| + | #view mel lib | ||
| + | #a python tool to view mel lib file functionts | ||
| + | import sys | ||
| - | **Curve related** | + | def viewMel(file): |
| - | + | with open(file) as f: | |
| - | | + | for line in f: |
| - | def getCurveInfo(curveObj, index=2): | + | lineClean=line.strip() |
| - | | + | if lineClean.startswith('// |
| - | | + | print lineClean.replace(' |
| - | | + | |
| - | | + | def viewMel_html(melFile,htmlFile): |
| - | cmds.connectAttr( curveObj | + | |
| - | k = cmds.getAttr( tmpInfo | + | |
| - | cmds.delete(tmpInfo) | + | h.write('< |
| - | | + | for line in f: |
| + | lineClean=line.strip() | ||
| + | if lineClean.startswith('// | ||
| + | | ||
| + | elif lineClean.startswith('global proc'): | ||
| + | h.write('< | ||
| + | elif lineClean.startswith('/ | ||
| + | h.write('< | ||
| + | h.write('</ | ||
| + | | ||
| | | ||
| - | def numClean(fnum, | + | if __name__=="__main__": |
| - | rule = "{0:."+str(index)+" | + | |
| - | cnum = float(rule.format(fnum)) | + | </ |
| - | if cnum.is_integer(): | + | |
| - | cnum = int(cnum) | + | |
| - | | + | |
| - | + | ||
| - | def setCurveInfo(curveObj, curveInfo): | + | |
| - | # input: dict - d, p; p ; d,p,k | + | |
| - | if not isinstance(curveInfo, | + | |
| - | print(' | + | |
| - | return | + | |
| - | if all(x in curveInfo.keys() for x in [' | + | |
| - | return cmds.curve(curveObj, | + | |
| - | elif all(x in curveInfo.keys() for x in ['d',' | + | |
| - | return cmds.curve(curveObj, | + | |
| - | | + | |
| - | return cmds.curve(curveObj, | + | |
| - | def buildCurveInfo(curveInfo, | + | ===== web link operation ===== |
| - | # input: dict - d, p; p ; d,p,k | + | |
| - | if not isinstance(curveInfo, | + | * open url in brower <code python> |
| - | | + | webbrowser._browsers # list registered browsers |
| - | | + | |
| - | if all(x in curveInfo.keys() for x in [' | + | new = 2 # open in a new tab, if possible |
| - | | + | # open a public URL, in this case, the webbrowser docs |
| - | elif all(x in curveInfo.keys() for x in [' | + | url = " |
| - | | + | webbrowser.open(url,new=new) |
| - | else: | + | # for using firefox, note, firefox needs to be default or in the system environment path |
| - | | + | webbrowser.get('firefox').open(url,new=2) |
| + | # open an HTML file on my own (Windows) computer | ||
| + | url = "file:// | ||
| + | webbrowser.open(url,new=new) | ||
| </ | </ | ||
| + | ===== file operation ===== | ||
| + | * check file exists <code python> | ||
| + | * access file and folder< | ||
| + | # delete a file | ||
| + | os.remove(tmpitem) | ||
| - | * curve_mel2py cmd convertor <code python> | + | # check exist of a file |
| - | #txt = 'curve -d 1 -p 0 0 1 -p 0 0.5 0.866025 -p 0 0.866025 0.5 -p 0 1 0 -p 0 0.866025 -0.5 -p 0 0.5 -0.866025 -p 0 0 -1 -p 0 -0.5 -0.866025 -p 0 -0.866025 -0.5 -p 0 -1 0 -p 0 -0.866025 0.5 -p 0 -0.5 0.866025 -p 0 0 1 -p 0.707107 0 0.707107 -p 1 0 0 -p 0.707107 0 -0.707107 -p 0 0 -1 -p -0.707107 0 -0.707107 -p -1 0 0 -p -0.866025 0.5 0 -p -0.5 0.866025 0 -p 0 1 0 -p 0.5 0.866025 0 -p 0.866025 0.5 0 -p 1 0 0 -p 0.866025 -0.5 0 -p 0.5 -0.866025 0 -p 0 -1 0 -p -0.5 -0.866025 0 -p -0.866025 -0.5 0 -p -1 0 0 -p -0.707107 0 0.707107 -p 0 0 1 -k 0 -k 1 -k 2 -k 3 -k 4 -k 5 -k 6 -k 7 -k 8 -k 9 -k 10 -k 11 -k 12 -k 13 -k 14 -k 15 -k 16 -k 17 -k 18 -k 19 -k 20 -k 21 -k 22 -k 23 -k 24 -k 25 -k 26 -k 27 -k 28 -k 29 -k 30 -k 31 -k 32' | + | if not os.path.exists(tmpJPG): |
| + | print tmpitem | ||
| - | # maya float number cleaner | + | # get file with a certain name pattern in a directory and all its sub-directories |
| - | def numClean(fnum, | + | scanDir |
| - | | + | my_list |
| - | | + | for (dirpath, dirnames, filenames) in os.walk(scanDir): |
| - | | + | |
| - | cnum = int(cnum) | + | |
| - | return cnum | + | |
| - | def curve_mel2py(txt): | + | # get file with a certain name pattern in a directory |
| - | rest, k = txt.split(' | + | [x for x in os.listdir(scanDir) if os.path.isfile(os.path.join(scanDir, x)) and re.match('MyApp_lang_.+\.json', x) ] |
| - | ks = [int(x.strip()) | + | [x for x in glob.glob(os.path.join(scanDir,'MyApp_lang_*.json' |
| - | rest, p = rest.split(' | + | |
| - | ps = [ x.strip().split() for x in p.split('-p') ] | + | |
| - | ps = [ [numClean(float(y)) for y in x] for x in ps] | + | |
| - | d = int(rest.split('-d',1)[-1].strip()) | + | |
| - | | + | |
| - | | + | |
| </ | </ | ||
| + | * lines to array< | ||
| + | with open(fname) as f: | ||
| + | content = f.readlines() | ||
| - | * create NurbsCurve passing defined point list <code python> | + | with open(fname) as f: |
| - | lineCurve = cmds.curve(p=pointList, | + | for line in f: |
| - | nurbsCurve = cmds.fitBspline(lineCurve, | + | #do something with line |
| - | cmds.delete(lineCurve) | + | |
| </ | </ | ||
| + | * remove any non-ascii words in file names <code python> | ||
| + | import os | ||
| + | import urllib | ||
| + | curdir = os.getcwd() | ||
| + | os.chdir(parentDir) | ||
| + | file_list_en = os.listdir(' | ||
| + | file_list_cn = os.listdir(u' | ||
| + | for i in xrange(len(file_list_en)): | ||
| + | itemName = file_list_en[i] | ||
| + | print(itemName) | ||
| + | if itemName.startswith(' | ||
| + | # convert %AA cn name to unicode | ||
| + | new_fixName1 = urllib.unquote(itemName).decode(' | ||
| + | # then remove cn chars | ||
| + | new_itemName2 = '' | ||
| + | if itemName != new_itemName2: | ||
| + | print([itemName, | ||
| + | os.rename(itemName, | ||
| + | else: | ||
| + | itemName = file_list_cn[i] # for non ascii names | ||
| + | # just remove cn chars | ||
| + | new_itemName = '' | ||
| + | if itemName != new_itemName: | ||
| + | print([itemName, | ||
| + | os.rename(itemName, | ||
| + | | ||
| + | os.chdir(curdir) | ||
| + | </ | ||
| + | * read line from a huge file by multiple process at the same time, without accident write operation< | ||
| + | import linecache | ||
| + | linecache.getline('/ | ||
| + | </ | ||
| + | * process line by line rewrite <code python> | ||
| + | import sys | ||
| + | import fileinput | ||
| - | * **Research on API vs Cmds in Get and Set Vertex Position based on optional selection** <code python> | + | for i, line in enumerate(fileinput.input(' |
| - | # ref: http://www.fevrierdorian.com/ | + | #sys.stdout.write(line.replace(' |
| - | def getVtxSelection_OpenMaya(): | + | if line.find(' |
| - | | + | |
| - | # normal selection | + | |
| - | normalSelectionList = om.MSelectionList() | + | |
| - | om.MGlobal.getActiveSelectionList(normalSelectionList) | + | else: |
| - | selectionPath = om.MDagPath() | + | sys.stdout.write(line) |
| - | | + | </ |
| - | | + | * make sure directory is created before create file in defined path <code python> |
| - | | + | my_filePath = '/ |
| - | # | + | # method |
| - | | + | if not os.path.isdir(os.path.dirname(my_filePath)): |
| - | id_list = [] | + | |
| - | while not iter.isDone(): | + | |
| - | iter.getDagPath( selectionPath, selectionObj ) | + | |
| - | selectionPath.pop() | + | |
| - | node = selectionPath.fullPathName() | + | |
| - | compFn = om.MFnSingleIndexedComponent(selectionObj) # flatten the component selection | + | |
| - | | + | |
| - | | + | |
| - | node_list.append(node) | + | |
| - | ''' | + | |
| - | for i in range(compFn.elementCount()): | + | |
| - | | + | |
| - | id_list.append(compFn.element(i)) | + | |
| - | ''' | + | |
| - | iter.next() | + | |
| - | | + | |
| - | print(" | + | |
| - | return list(set(node_list)), | + | |
| | | ||
| - | def getVtxPos_cmd( shapeNode, sl=0 ): | + | # method 2: these 2 lines create all the needed folders forming the path |
| - | # full path, duplicate name proof | + | try: |
| - | | + | |
| - | pos_list = [] | + | except OSError: |
| - | index_list = [] | + | |
| - | if sl==0: # 0.885 | + | |
| - | #index_list = cmds.getAttr( shapeNode+" | + | |
| - | index_list = range( cmds.polyEvaluate(shapeNode, | + | |
| - | | + | |
| - | shapeNode, index_list = getVtxSelection_OpenMaya() # 0.01 | + | |
| - | shapeNode = shapeNode[0] | + | |
| - | for i in index_list: #i=0 | + | |
| - | pos = cmds.xform( ' | + | |
| - | | + | |
| - | totalTime = cmds.timerX(startTime=startTime) | + | |
| - | print(" | + | |
| - | | + | |
| - | def setVtxPos_cmd( shapeNode, pos_data, sl=0 ): | + | |
| - | startTime = cmds.timerX() | + | |
| - | cmds.undoInfo(openChunk=1) | + | |
| - | index_list, pos_list = pos_data | + | |
| - | if sl== 0: # 4.38 | + | |
| - | for i in range(len(index_list)): | + | |
| - | cmds.xform(' | + | |
| - | else: # 5.29 | + | |
| - | sel_index_list = getVtxSelection_OpenMaya()[1] | + | |
| - | if not set(sel_index_list).issubset(set(index_list)): | + | |
| - | print(' | + | |
| - | return | + | |
| - | for id in sel_index_list: | + | |
| - | i = index_list.index(id) | + | |
| - | cmds.xform(' | + | |
| - | cmds.undoInfo(closeChunk=1) | + | |
| - | totalTime = cmds.timerX(startTime=startTime) | + | |
| - | print(" | + | |
| | | ||
| - | def getVtxPos_OpenMaya( shapeNode, sl=0 ): | + | # method 3: all in one check and create if needed, like method |
| - | | + | os.makedirs(os.path.dirname(output_path), exist_ok=True) |
| - | startTime = cmds.timerX() | + | |
| - | pos_list = [] | + | |
| - | index_list = [] | + | |
| - | if sl==0: # 0.18 | + | |
| - | selectionList = om.MSelectionList() | + | |
| - | selectionList.add(shapeNode) | + | |
| - | dagPath = om.MDagPath() | + | |
| - | selectionList.getDagPath(0, | + | |
| - | + | ||
| - | mesh_fn = om.MFnMesh(dagPath) | + | |
| - | meshPointArray = om.MPointArray() | + | |
| - | mesh_fn.getPoints(meshPointArray, | + | |
| - | index_list = range(meshPointArray.length()) | + | |
| - | for i in index_list: | + | |
| - | pos_list.append( [meshPointArray[i][0], | + | |
| - | else: # 0.04 | + | |
| - | selectionList = om.MSelectionList() | + | |
| - | om.MGlobal.getActiveSelectionList(selectionList) | + | |
| - | selectionPath = om.MDagPath() | + | |
| - | selectionCompObj = om.MObject() | + | |
| - | iter_sel = om.MItSelectionList( selectionList, | + | |
| - | while not iter_sel.isDone(): | + | |
| - | iter_sel.getDagPath( selectionPath, | + | |
| - | iter_vtx = om.MItMeshVertex(selectionPath, | + | |
| - | while not iter_vtx.isDone(): | + | |
| - | pnt = iter_vtx.position(om.MSpace.kWorld) | + | |
| - | index_list.append( iter_vtx.index() ) | + | |
| - | pos_list.append([pnt.x, | + | |
| - | iter_vtx.next() | + | |
| - | iter_sel.next() | + | |
| - | totalTime = cmds.timerX(startTime=startTime) | + | |
| - | print(" | + | |
| - | return index_list, pos_list | + | |
| - | + | ||
| - | def setVtxPos_OpenMaya(shapeNode, | + | |
| - | startTime = cmds.timerX() | + | |
| - | cmds.undoInfo(openChunk=1) | + | |
| - | index_list, pos_list = pos_data | + | |
| - | selectionList = om.MSelectionList() | + | |
| - | selectionList.add(shapeNode) | + | |
| - | dagPath = om.MDagPath() | + | |
| - | selectionList.getDagPath(0, | + | |
| - | mesh_fn = om.MFnMesh(dagPath) | + | |
| - | if sl==0: # 0.069 | + | |
| - | # set one by one - 4.22 | + | |
| - | #for i in range(len(index_list)): | + | |
| - | # mesh_fn.setPoint(index_list[i], | + | |
| - | # get all and get all - 0.069 | + | |
| - | meshPointArray = om.MPointArray() | + | |
| - | mesh_fn.getPoints(meshPointArray, | + | |
| - | | + | |
| - | | + | |
| - | mesh_fn.setPoints(meshPointArray, | + | |
| - | else: # 0.53 | + | |
| - | sel_index_list = getVtxSelection_OpenMaya()[1] | + | |
| - | if not set(sel_index_list).issubset(set(index_list)): | + | |
| - | print(' | + | |
| - | return | + | |
| - | meshPointArray = om.MPointArray() | + | |
| - | mesh_fn.getPoints(meshPointArray, om.MSpace.kWorld) | + | |
| - | for id in sel_index_list: | + | |
| - | i = index_list.index(id) | + | |
| - | meshPointArray.set(id, | + | |
| - | mesh_fn.setPoints(meshPointArray, | + | |
| - | cmds.undoInfo(closeChunk=1) | + | |
| - | totalTime = cmds.timerX(startTime=startTime) | + | |
| - | print(" | + | |
| </ | </ | ||
| - | ====== UV Editing ====== | + | * write python data< |
| + | # write raw data and read raw data | ||
| + | os.getcwd() | ||
| + | import json | ||
| + | def writeDataFile(data, | ||
| + | with open(file, ' | ||
| + | json.dump(data, | ||
| + | | ||
| + | def readDataFile(file): | ||
| + | with open(file) as f: | ||
| + | data = json.load(f) | ||
| + | return data | ||
| + | | ||
| + | # write dictionary data and read dictionary data | ||
| + | import csv | ||
| + | def writeDictFile(dict, | ||
| + | w = csv.writer(open(" | ||
| + | for key, val in dict.items(): | ||
| + | w.writerow([key, | ||
| - | ====== | + | def readDictFile(file): |
| + | dict = {} | ||
| + | for key, val in csv.reader(open(file)): | ||
| + | dict[key] | ||
| + | return dict | ||
| + | </ | ||
| + | * UTF-8 unicode file write< | ||
| + | ############### | ||
| + | import codecs | ||
| + | txt=u"< | ||
| + | i=0 | ||
| + | for each in a: | ||
| + | i=i+1; | ||
| + | txt=txt+u"< | ||
| - | * assign material to selection or objects <code python> | + | txt=txt+u'</table>' |
| - | * material creation <code python> | + | |
| - | * change property <code python> | + | |
| - | ====== Rigging ====== | + | with codecs.open(' |
| - | + | | |
| - | ===== delete unknown nodes ===== | + | </ |
| - | + | * copy directory structure only <code python> | |
| - | * delete unknown nodes, but check " | + | for dirpath, dirnames, filenames in os.walk(srcPath): |
| - | nodeList = cmds.ls(type=[' | + | |
| - | # | + | if not os.path.isdir(to_mkdir): |
| - | def deleteIfNotReferenced( nodeList | + | os.mkdir(to_mkdir) |
| - | | + | os.startfile(tgtPath) # show result folder |
| - | nodeList = [nodeList] | + | |
| - | | + | |
| - | | + | |
| - | | + | |
| - | if not isLocked: | + | |
| - | cmds.delete( nodeToDelete | + | |
| </ | </ | ||
| + | ===== thread operation ===== | ||
| - | + | | |
| - | + | def app(opt): | |
| - | ===== common node and attributes ===== | + | if opt == 'Noter': |
| - | + | | |
| - | | obj_transform | .worldMatrix | | + | |
| - | + | th.start() | |
| - | ===== Prefix remover ===== | + | def run_noter(): |
| - | + | | |
| - | * remove prefix in shape and transform and avoid same node name level collision | + | |
| - | | + | |
| - | mesh_list = cmds.ls(' | + | |
| - | for each_mesh in mesh_list: | + | |
| - | info = each_mesh.rsplit(' | + | |
| - | if len(info )==2: | + | |
| - | cmds.rename(each_mesh, | + | |
| - | else: | + | |
| - | | + | |
| - | + | ||
| - | obj_list | + | |
| - | for each_obj in obj_list: | + | |
| - | info = each_obj.rsplit(' | + | |
| - | if len(info)==2: | + | |
| - | | + | |
| - | | + | |
| - | print(each_obj) | + | |
| </ | </ | ||
| - | ===== alias attribute | + | ====== module operation ====== |
| - | * for blendshape | + | * How to install extra module automatically with pip |
| - | alias_target_weight_list = cmds.aliasAttr( final_bs, q=1 ) # [' | + | * download pip and use bellow method to manually install it, or run this line of command to get or update pip stuffs. |
| - | target_list = alias_target_weight_list[:: | + | * once done, you can install rest modules with cmd <code bash> |
| - | weight_attr_list = alias_target_weight_list[1::2] # all the weight attribute list | + | * How to install wheel package <code dos>REM pip app is at PythonAppDir/ |
| + | REM make sure that wheel is in 32/64bit matching your python 32/64bit version | ||
| + | pip install C:/ | ||
| </ | </ | ||
| + | * How to install extra module into seperate directory < | ||
| + | python.exe -m pip install --target=D: | ||
| + | </ | ||
| + | * How to install extra modules manually | ||
| + | - download the module source, | ||
| + | * if it has setup.py in its directory, run <code python> | ||
| + | * if it has no setup.py in its directory, or just a single folder or a python .py file, then just include its path in your python path under your system variable or run this command in python cmd line before you call <code python> | ||
| + | * **Ideally, if you put the Module Folder (not its parent distribution folder) under the Lib/ | ||
| + | * However, if you want your Python module to be at a specific location, then add it to python path environment variable. For windows advanced system setting > environment variable < | ||
| + | - distribute your python file with module, | ||
| + | * you can ask user to manually install those modules that used in your python program file | ||
| + | * or just put those dependent file or folder next to your python program file | ||
| + | * check with module info <code python> | ||
| + | # check whether a module has that attribute | ||
| + | if hasattr(QtGui, | ||
| + | print(" | ||
| - | ===== weight ===== | + | # try get a function from a module and with fallback option |
| - | + | resultFunc | |
| - | * [[graphic: | + | |
| - | * apply single vtx weight to whole geo, good for unify same weight on attachment type geos on another surface <code python> | + | # check imported module name dictionary |
| - | attach_vtx_id = 16 # use same weight as on vtx[16] | + | if 'MyModule' |
| - | cur_skin = cmds.skinCluster(cur_bones, | + | print('yes') |
| - | cmds.setAttr( cur_skin + " | + | |
| - | vtx_weight = cmds.skinPercent(cur_skin, cur_geo+'.vtx[{0}]'.format(attach_vtx_id), | + | |
| - | cmds.skinPercent(cur_skin, | + | |
| </ | </ | ||
| + | * work with module using variable names <code python> | ||
| + | # import PySide | ||
| + | __import__(' | ||
| - | * get only bone affecting the selected vtx <code python> | + | # same as from PySide import QtNetwork as Net |
| - | cur_vtx_list | + | qtModeList |
| - | if len(cur_vtx_list)> | + | qtMode = 0 |
| - | if '.vtx[' in cur_vtx_list[0]: | + | Net = getattr( __import__(qtModeList[qtMode], fromlist=['QtNetwork' |
| - | cur_skin | + | |
| - | affect_boneList = cmds.skinPercent(cur_skin, cur_vtx_list, | + | |
| </ | </ | ||
| - | * select only vtx affected the defined bone <code python> | + | * import module from its parent directory |
| - | cmds.skinCluster(cur_skin, e=1, selectInfluenceVerts=bone_name) | + | import os,sys |
| + | os.path.join(sys.path[0], ' | ||
| + | import my_module_at_current_file_parent_dir | ||
| </ | </ | ||
| - | ===== Blendshape | + | ===== useful module list ===== |
| - | {{graphic: | + | ==== useful HTML modules ==== |
| - | | + | |
| - | * you can optionally clear out local vertex transform with cmds.polyMoveVertex(localTranslate=(0, | + | * < |
| - | * however, Blendshape in maya seems not care about those local transform or global transform, it only care its position relative to origin when object is at zero x,y,z transform in channel box | + | * BeautifulSoup [[http:// |
| - | * move at object level will not affect blendshape unless you tell blendshape to look at global level instead of vertex level | + | * Mechanize [[http:// |
| - | * also, any deform modifier added on the object will reset all the vertex local value to 0,0,0 in result object shape. | + | * Scrapy [[http:// |
| - | * **inputTarget[0].paintTargetWeights[11]**: this is just a temporary weight holder, as anytime you use blendshape paint tool to select which data to paint on, it loads the data into this attribute. | + | * pyquery |
| + | | ||
| + | * embed code editor info: | ||
| + | * http:// | ||
| + | * https:// | ||
| + | * http:// | ||
| + | * http:// | ||
| + | * embed python console info: | ||
| + | * code module | ||
| + | * http:// | ||
| + | * http:// | ||
| + | * https:// | ||
| + | * http:// | ||
| + | * http:// | ||
| - | * vtx general info code< | + | ==== useful automation modules ==== |
| - | cmds.getAttr(' | + | |
| - | cmds.polyMoveVertex(localTranslate=(0, | + | * a online book related: https:// |
| - | </ | + | * winsys: admin automation for windows |
| - | * blendshape per target per vtx weight info cmds way < | + | * ref: http:// |
| - | cmds.getAttr(cur_bs+' | + | * pywinauto: https:// |
| + | * tutorial: | ||
| + | * DevNami - Python Pyautogui Take Screenshot : https://www.youtube.com/ | ||
| + | * SF Python - https://www.youtube.com/ | ||
| + | * https:// | ||
| + | * additional ref: | ||
| + | * https:// | ||
| + | * http:// | ||
| + | * selenium: web browser automation | ||
| + | * the doc: http:// | ||
| - | # target 1 : weight per vtx | + | ==== useful Graphic modules ==== |
| - | cmds.getAttr(' | + | |
| - | cmds.getAttr(' | + | |
| - | # target 2 : weight per vtx | + | |
| - | cmds.getAttr(' | + | |
| - | # set target 2: weight per vtx | + | * numpy : numerical python |
| - | cmds.setAttr(' | + | * matplotlib : plot graphing tool (my note: [[devwiki: |
| + | * xlrd : excel read tool | ||
| + | * pandas : data structures and data analysis tools (loading datas and data operation like SQL) | ||
| + | * http:// | ||
| + | * PyQtGraph : plot graphing tool | ||
| + | * Gnuplot : plot tool | ||
| + | * ipython : interactive python and visualization tool | ||
| + | * OpenEXR | ||
| + | * IlmImf, a library that reads and writes OpenEXR images. | ||
| + | * Half, a C++ class for manipulating half values | ||
| + | * Imath, a math library with support for matrices, 2d- and 3d-transformations, | ||
| + | * exrdisplay, a sample application for viewing OpenEXR images at various exposure. | ||
| + | * wxPython : wx GUI | ||
| + | * PyQt/PySide : Qt GUI | ||
| + | * pysqlite/ | ||
| + | * Graph (node graph): https:// | ||
| + | * NetworkX (node graph big): http:// | ||
| - | # get current loaded paint weight data | + | ==== useful audio module ==== |
| - | cmds.getAttr(cur_bs+' | + | |
| - | # get current base (the final mixing global per vtx weight) | + | * pyaudio <code python> |
| - | cmds.getAttr(cur_bs+' | + | p = pyaudio.PyAudio() |
| + | for i in range(p.get_device_count()): | ||
| + | print p.get_device_info_by_index(i).get(' | ||
| </ | </ | ||
| + | * useful Game building modules | ||
| + | * quick tutorial on python openGL game: http:// | ||
| - | {{: | + | ==== database and file modules ==== |
| - | * API: **MFnBlendShapeDeformer** <code python> | + | |
| - | import maya.OpenMaya as om | + | * sqlite |
| - | import maya.OpenMayaAnim as oma | + | * additional desktop sqlite commandline tools: https://www.sqlite.org/download.html |
| - | selectionList | + | * json (built-in ascii out) |
| - | selectionList.add(cur_bs) | + | * cPickle |
| - | bs_obj | + | |
| - | selectionList.getDependNode(0, | + | |
| - | bs_obj.hasFn(om.MFn.kBlendShape) | + | |
| - | bs_fn = oma.MFnBlendShapeDeformer(bs_obj) # blendshape object fn | + | |
| - | # current result object | + | |
| - | obj_list = om.MObjectArray() | + | |
| - | bs_fn.getBaseObjects(obj_list) | + | |
| - | print(obj_list.length()) # 1, only one blendshape object, even if it has more targets | + | |
| - | bs_base_obj = obj_list[0] | + | |
| - | </code> | + | |
| - | * API: **weight slider attribute and alias target attribute name** <code python> | + | |
| - | nWeights = bs_fn.numWeights() # number of blend targets | + | |
| - | indexList = om.MIntArray() | + | |
| - | # get logic index of blend targets, since target can be remove from array, and become sparse | + | |
| - | bs_fn.weightIndexList(indexList) | + | |
| - | w_info_list=[] # weight attr info | + | * encryption modules |
| - | w_plug = bs_fn.findPlug(' | + | * hashlib |
| - | for index in indexList: | + | m = hashlib.md5() |
| - | cur_plug | + | m.update(user_input_text) |
| - | | + | # a sample hash code example |
| - | | + | if m.hexdigest() != ' |
| - | | + | |
| - | print(w_info_list) | + | |
| </ | </ | ||
| - | * API: **baseWeights | + | * data hashing, like compress data into a string, good for big data compare and record |
| - | inputTargetArrayPlug = bs_fn.findPlug(' | + | |
| - | inputTargetPlug | + | * hashlib |
| - | # base weight list | + | ==== system info modules ==== |
| - | baseWeightsArrayPlug | + | |
| - | vtxCnt | + | |
| - | base_weight_list | + | |
| - | for j in range(baseWeightsArrayPlug.numElements()): | + | * getpass |
| - | | + | |
| - | | + | # get all file named prefix variable _v001 like ma/mb file</ |
| - | | + | |
| + | # lock down file for user, group, other readonly | ||
| + | os.chmod(filePath, stat.S_IRUSR | stat.S_IRGRP | stat.S_IROTH)</ | ||
| + | | ||
| - | # following method may fail if you start maya fresh and read the scene | + | ==== system command modules ==== |
| - | ''' | + | |
| - | base_weight_list | + | |
| - | for j in range(baseWeightsArrayPlug.numElements()): | + | |
| - | base_weight_list.append( baseWeightsArrayPlug.elementByLogicalIndex(j).asFloat() ) | + | |
| - | ''' | + | |
| - | # even this will not get the full index list | + | |
| - | baseWeightsArrayPlug.evaluateNumElements() | + | |
| - | print(baseWeightsArrayPlug.numElements()) | + | |
| - | </ | + | |
| - | * API: **targetWeights data for each target** <code python> | + | |
| - | inputTargetGroupArrayPlug = inputTargetPlug.child(0) | + | |
| - | + | ||
| - | target_weight_data = [] | + | |
| - | for index in indexList: # i=0 | + | |
| - | inputTargetGroupPlug = inputTargetGroupArrayPlug.elementByLogicalIndex(index) # inputTargetGroupPlug.name() | + | |
| - | targetWeightsArrayPlug = inputTargetGroupPlug.child(1) # .targetWeights | + | |
| - | target_weight_list = [1]*vtxCnt | + | |
| - | for j in range(targetWeightsArrayPlug.numElements()): # j=0 | + | |
| - | cur_plug = targetWeightsArrayPlug.elementByPhysicalIndex(j) | + | |
| - | logicalIndex = cur_plug.logicalIndex() | + | |
| - | target_weight_list[logicalIndex] = cur_plug.asFloat() | + | |
| - | target_weight_data.append(target_weight_list) | + | |
| </ | </ | ||
| - | + | | |
| - | * API: **Geometry result deformed vertex list position info** <code python> | + | subprocess.call(r' |
| - | pos_list = [] | + | subprocess.Popen([r' |
| - | geo_iter = om.MItGeometry(obj_list[0]) | + | os.system(r' |
| - | while not geo_iter.isDone(): | + | |
| - | p = geo_iter.position() | + | |
| - | | + | |
| - | | + | |
| </ | </ | ||
| - | + | * subprocess.check_call will raise an exception | |
| - | * API: **Data of Target shape vertex list position info** <code python> | + | * both return result |
| - | target_data = [] | + | |
| - | + | if os.path.isdir(folderPath): | |
| - | def geoObject_to_posList_OpenMaya(geo_object): | + | |
| - | | + | |
| - | geo_iter = om.MItGeometry(geo_object) | + | |
| - | pos_list | + | |
| - | while not geo_iter.isDone(): | + | |
| - | | + | |
| - | | + | |
| - | | + | |
| - | return pos_list | + | |
| - | + | | |
| - | for index in indexList: # i = 0 | + | |
| - | | + | |
| - | + | | |
| - | target_list = om.MObjectArray() | + | |
| - | bs_fn.getTargets(bs_base_obj, | + | |
| - | | + | try: |
| - | target_cnt = target_list.length() | + | |
| - | if target_cnt > 1: | + | |
| - | | + | pass # handle errors in the called executable |
| - | for j in range(target_cnt ): | + | |
| - | | + | pass # executable not found |
| - | | + | |
| - | | + | |
| - | if target_cnt == 0: | + | |
| - | | + | |
| - | # switch all shape off and only leave it on | + | |
| - | old_w_list = [] | + | |
| - | for n in indexList: | + | |
| - | old_w_list.append( [ n, bs_fn.weight(n) | + | |
| - | bs_fn.setWeight(n, | + | |
| - | bs_fn.setWeight(n, | + | |
| - | # get object data | + | |
| - | target_object_data.append( geoObject_to_posList_OpenMaya(bs_base_obj) ) | + | |
| - | # from backup | + | |
| - | for n, w in old_w_list: | + | |
| - | bs_fn.setWeight(n, | + | |
| - | | + | |
| - | | + | |
| - | | + | |
| - | | + | |
| - | + | ||
| - | # locator creation | + | |
| - | def pos_to_loc(pos_list, prefix='tmp'): | + | |
| - | for i,pos in enumerate(pos_list): | + | |
| - | | + | |
| - | | + | |
| - | | + | |
| - | for i,targets in enumerate(target_data): | + | |
| - | | + | |
| </ | </ | ||
| - | ====== | + | * check if a process is running <code python> |
| - | + | appName | |
| - | **Import | + | info=subprocess.Popen(' |
| - | * import <code python> | + | out, err = info.communicate() |
| - | # select controls to load animation, then | + | #out = str(out) # for py3 byte convert |
| - | cmds.file("D:/ | + | out = out.decode(' |
| + | result | ||
| + | if len(result)> | ||
| + | | ||
| + | else: | ||
| + | | ||
| </ | </ | ||
| - | **Import and Export animation with Maya built-in | + | |
| - | * method 1: select the animation curve nodes, then just export those nodes for later import and manual reconnect<code python> | + | if sys.platform in [' |
| - | cmds.file(" | + | os.startfile(filePath) |
| + | elif sys.platform | ||
| + | os.open(filePath) | ||
| + | elif sys.platform | ||
| + | os.xdg-open(filePath) | ||
| </ | </ | ||
| - | | + | |
| - | * method 2: select animated objects, then just export animation info with auto reconnect on import<code python> | + | subprocess.Popen([r'D:\App\Python27\python.exe',r' |
| - | cmds.file("D:/ | + | subprocess.Popen([r'D: |
| - | </ | + | # force it to open in new console window instead |
| - | * the result file will contains, animation nodes + re-connection commands, you can replace namespace on import back with -swapNamespace, | + | subprocess.Popen([r' |
| + | # if above method failed because PATH or PYTHONPATH issue, especially when call like above in a mixed python environment like Maya, | ||
| + | # you need to use a clean copy of environment, | ||
| + | env2={} | ||
| + | env2[' | ||
| + | D: | ||
| + | D: | ||
| + | D: | ||
| + | ''' | ||
| + | env2[' | ||
| + | D: | ||
| + | D: | ||
| + | D: | ||
| + | D: | ||
| + | D: | ||
| + | D: | ||
| + | D: | ||
| + | D: | ||
| + | D: | ||
| + | ''' | ||
| - | **Get all Animation Curve** | + | subprocess.Popen([r' |
| - | * note: it may include time value driven drive key curve, so need check< | + | subprocess.Popen([r'D: |
| - | for animCurve_type in [' | + | |
| - | curve_list = cmds.ls( type = animCurve_type ) | + | |
| - | + | ||
| - | for each_curve in curve_list: | + | |
| - | cur_connection_out = each_curve + " | + | |
| - | destinations = cmds.connectionInfo(cur_connection_out, destinationFromSource=1) | + | |
| - | if len(destinations) == 0: | + | |
| - | # optional process for unconnected animation node | + | |
| - | cmds.delete(each_curve) | + | |
| - | else: | + | |
| - | cur_node_attr = destinations[0] | + | |
| - | cur_node, cur_attr = cur_node_attr.split(' | + | |
| - | # optional get transform node | + | |
| - | cur_transform = '' | + | |
| - | if cmds.nodeType(cur_node) == ' | + | |
| - | cur_transform = cur_node | + | |
| - | else: | + | |
| - | try_parent = cmds.listRelatives(cur_node, | + | |
| - | if try_parent: | + | |
| - | cur_transform = cmds.listRelatives(cur_node, | + | |
| - | # optional unlock attribute | + | |
| - | old_lock = cmds.getAttr(cur_node_attr, | + | |
| - | cmds.setAttr(cur_node_attr, | + | |
| - | # optional process here | + | |
| - | cmds.delete(cur_node_attr, | + | |
| - | # lock back | + | |
| - | cmds.setAttr(cur_node_attr, lock= old_lock) | + | |
| </ | </ | ||
| + | * subprocess a console app and get return, and optionally hide the pop up console when call <code python> | ||
| + | # hide popup console for win platform only | ||
| + | startupinfo = subprocess.STARTUPINFO() | ||
| + | startupinfo.dwFlags |= 1 # | ||
| + | # startupinfo.wShowWindow = subprocess.SW_HIDE #(optional) | ||
| - | **Clean Static Animation on object** | + | info=subprocess.Popen( '{0}'.format(app_path),stdout=subprocess.PIPE, stdin=subprocess.PIPE, stderr=subprocess.PIPE, |
| - | * note: that operation can't take locked channel, so unlock process may required | + | out, err = info.communicate() |
| - | * general clean static animation <code python> | + | out = out.decode(' |
| - | cmds.delete(cur_node_attr, staticChannels=1, unitlessAnimationCurves=0, hierarchy="" | + | |
| </ | </ | ||
| + | ==== string related ==== | ||
| - | **Bake Animation** | + | |
| - | * note: make sure all channel unlocked | + | # capture group and non-capture group: |
| - | * bake animation curve< | + | # http:// |
| - | * bake object | + | re.findall(' |
| - | + | re.findall(' | |
| - | ====== Animation Cache====== | + | # since we only need the prefix, the Msg group is to test exisits |
| - | + | ||
| - | * check abc node inside maya, and its cache path <code python> | + | |
| - | # get all abc node | + | |
| - | all_abc_nodes = cmds.ls(type=' | + | |
| - | # check current file path | + | |
| - | for each in all_abc_nodes: | + | |
| - | print(' | + | |
| - | print('For node: {0}'.format(each)) | + | |
| - | | + | |
| - | print(cmds.getAttr(each+'.fns')) | + | |
| </ | </ | ||
| - | * to update abc cache path, (default maya only change the " | ||
| - | all_abc_nodes = cmds.ls(type=' | ||
| - | for each in all_abc_nodes: | ||
| - | print(' | ||
| - | print(' | ||
| - | cur_abc_path = cmds.getAttr(each+' | ||
| - | cmds.setAttr(' | ||
| - | </ | ||
| - | ====== Camera and Viewport calculation ====== | ||
| - | * get 2D screen space from 3D position <code python> | + | ==== compile and de-compile module ==== |
| - | import maya.OpenMayaUI as omui | + | |
| - | import maya.OpenMaya as om | + | |
| - | import maya.cmds as cmds | + | |
| - | obj = cmds.ls(sl=1, fl=1)[0] # get first vtx or object, assume you have selected sth | + | |
| - | pos = om.MPoint(obj) | + | |
| - | </ | + | |
| + | **cx_Freeze**: | ||
| + | * After compile, the only files need to do partial update each time is (exe + library.zip) | ||
| - | | + | **PyInstaller**: |
| - | dagPath = om.MDagPath() # dag path holder | + | |
| - | omui.M3dView().active3dView().getCamera(dagPath) # get info | + | |
| - | cam_name = om.MFnDagNode(dagPath.transform()).fullPathName() # get cam name | + | |
| - | </ | + | |
| - | * get viewport width and height in monitor pixel unit < | + | < |
| - | omui.M3dView().active3dView().portWidth() | + | # cmd install |
| - | omui.M3dView().active3dView().portHeight() | + | python -m pip install pyinstaller |
| - | </ | + | |
| - | * Make Move tool aim to camera, or parallel | + | # compile, cd to your py file first, you may need copy your supporting folder |
| - | ''' | + | python.exe -m PyInstaller MyApp.py |
| - | ========================================== | + | |
| - | 2019.05.21 | + | |
| - | by Shining Ying | + | |
| - | shiningdesign[with]live.com | + | |
| - | make move tool aim to camera (with object/vtx selection) | + | # no terminal version |
| - | ========================================== | + | python.exe -m PyInstaller MyApp.py --noconsole |
| - | ''' | + | # set app binary icon |
| - | import maya.cmds as cmds | + | python.exe -m PyInstaller MyApp.py --icon=icons/MyApp.ico |
| - | import maya.OpenMaya as om | + | |
| - | import math | + | |
| - | def getLocalVecToWorldSpaceAPI(obj, | + | |
| - | | + | |
| - | # take obj's local space vec to workspace, default object x axis | + | |
| - | selList = om.MSelectionList() | + | |
| - | selList.add(obj) | + | |
| - | | + | |
| - | selList.getDagPath(0, | + | |
| - | matrix = nodeDagPath.inclusiveMatrix() | + | |
| - | vec = (vec * matrix).normal() | + | |
| - | return vec.x, vec.y, vec.z | + | |
| - | + | ||
| - | def alignObjectToVector(obj, | + | |
| - | | + | |
| - | | + | |
| - | selectionList.add( obj ) | + | |
| - | dagPath | + | |
| - | selectionList.getDagPath(0, | + | |
| - | fnTransform = om.MFnTransform(dagPath) | + | |
| - | # axis dict | + | |
| - | axis_dict = {' | + | |
| - | obj_axis_dir = getLocalVecToWorldSpaceAPI(obj, | + | |
| - | obj_axis_vec = om.MVector(*obj_axis_dir) | + | |
| - | + | ||
| - | aim_vec = om.MVector(*aim_dir) | + | |
| - | rot_quaternion = obj_axis_vec.rotateTo(aim_vec) | + | |
| - | fnTransform.rotateBy(rot_quaternion) | + | |
| - | # optional 2nd axis setup | + | |
| - | if up_guide_dir != None and side_axis != None: | + | |
| - | # based on: aim_vec info | + | |
| - | up_guide_vec = om.MVector(*up_guide_dir) | + | |
| - | # make sure aim is not parallel to up_guide_vec | + | |
| - | if up_guide_vec.isParallel(aim_vec): | + | |
| - | # then align side x to provided backup side axis | + | |
| - | if side_guide_dir != None: | + | |
| - | alignObjectToVector(obj, | + | |
| - | else: | + | |
| - | side_vec = up_guide_vec ^ aim_vec # side dir | + | |
| - | alignObjectToVector(obj, | + | |
| - | cur_selection | + | # exclude tk and tcl library |
| + | python.exe -m PyInstaller MyApp.py --icon=icons/MyApp.ico --exclude-module=FixTk --exclude-module=tk --exclude-module=tcl --exclude-module=_tkinter --exclude-module=tkinter --exclude-module=Tkinter | ||
| - | #fixCam= ' | + | # for mac, if failed to build on pyconfig.h |
| - | fixCam = '' | + | # - fix pyconfig.h; by cmd: sudo touch / |
| - | cmds.setToolTo(' | + | python.exe -m PyInstaller MyApp.py --icon=icons/MyApp.icns |
| - | cur_cam = cmds.modelEditor(cmds.playblast(activeEditor=1), q=1, camera=1) | + | |
| - | if fixCam !='': | + | |
| - | cur_cam = fixCam | + | |
| - | print(' | + | |
| - | camPos = cmds.xform(cur_cam, | + | |
| - | objPos = cmds.manipMoveContext(' | + | |
| - | objPos2 = cmds.xform(cur_selection[0], | + | |
| - | if (objPos[0] | + | |
| - | objPos_maya | + | |
| - | objPos = objPos2 | + | |
| - | print(' | + | |
| - | aim_dir = [a-b for a,b in zip(camPos, | + | python.exe |
| - | up_ref_dir | + | |
| - | # loc | + | # cmd+i to check app info, and drag icns file to app/folder icon logo to set the icon |
| - | tmp_loc = cmds.spaceLocator(n=' | + | # manually turn folder into app, just add .app behind folder name, folder name must be same as main binary file |
| - | cmds.xform(tmp_loc, t=objPos, ws=1) | + | |
| - | # align | + | |
| - | alignObjectToVector(tmp_loc, ' | + | |
| - | rot_val = cmds.xform(tmp_loc, q=1, ro=1) | + | |
| - | cmds.delete(tmp_loc) | + | |
| - | # back to old selection | + | |
| - | cmds.select(cur_selection) | + | |
| - | # set tool | + | |
| - | cmds.setToolTo(' | + | |
| - | cmds.manipMoveContext( ' | + | |
| + | # when run result mac app on other computer, if security stop it run like "app is damaged", | ||
| + | xattr -cr "/ | ||
| + | </ | ||
| - | ''' | + | **uncompyle2**: |
| - | ========================================== | + | |
| - | 2019.05.21 | + | |
| - | by Shining Ying | + | |
| - | shiningdesign[with]live.com | + | |
| - | make move tool paralell to camera (with object/vtx selection) | + | https:// |
| - | ========================================== | + | |
| - | ''' | + | |
| - | cur_selection = cmds.ls(sl=1) | + | * code example <code python># in the init file |
| - | + | main('/ | |
| - | #fixCam= ' | + | |
| - | fixCam = '' | + | |
| - | cmds.setToolTo('moveSuperContext') # $gMove | + | |
| - | cur_cam = cmds.modelEditor(cmds.playblast(activeEditor=1), q=1, camera=1) | + | |
| - | if fixCam !='' | + | |
| - | cur_cam = fixCam | + | |
| - | print(' | + | |
| - | # loc | + | |
| - | tmp_loc = cmds.spaceLocator(n='tmp_move_loc' | + | |
| - | # align | + | |
| - | cmds.parentConstraint(cur_cam,tmp_loc) | + | |
| - | rot_val = cmds.xform(tmp_loc, | + | |
| - | cmds.delete(tmp_loc) | + | |
| - | # back to old selection | + | |
| - | cmds.select(cur_selection) | + | |
| - | + | ||
| - | # set tool | + | |
| - | cmds.setToolTo(' | + | |
| - | cmds.manipMoveContext( ' | + | |
| </ | </ | ||
| - | ====== Render Related ====== | ||
| - | * the ' | + | ====== |
| - | cmds.select(' | + | ===== pip ===== |
| - | + | ||
| - | # get current scene name | + | |
| - | cur_scene | + | |
| - | if cur_scene | + | |
| - | cur_scene | + | |
| - | print(' | + | |
| - | else: | + | |
| - | cur_scene | + | |
| - | # get render global output name, update to custom name format | + | |
| - | cur_img_prefix | + | |
| - | if '<Scene>' | + | * pip is a quick python module get and installer module for python, it can download module for your python library. |
| - | result_txt = cur_img_prefix.replace('<Scene>', cur_scene.rsplit(' | + | * check version |
| - | | + | * update it before install other module, make sure you already |
| + | # or | ||
| + | python -m pip install --upgrade pip | ||
| </ | </ | ||
| - | * it maps all the setting in Render Setting - Common Tab, <code python> | + | ===== re ===== |
| - | image_ext | + | |
| - | cmds.setAttr(" | + | |
| - | scene_path = os.path.dirname(cmds.file(q=True, | + | |
| - | dir_path_info = [scene_path, | + | |
| - | render_root_path = os.path.join(*dir_path_info ).replace(' | + | |
| - | cmds.setAttr(" | + | ^ all data file | < |
| - | # set as name.#### | + | ^ all maya file | < |
| - | cmds.setAttr(" | + | |
| - | cmds.setAttr(" | + | |
| - | cmds.setAttr(" | + | |
| - | cmds.setAttr(" | + | |
| - | cmds.setAttr(" | + | |
| - | # set width | + | * variable name case conversion |
| - | cmds.setAttr(" | + | * CamelCase to " |
| - | cmds.setAttr(" | + | * code: <code python> |
| - | </code> | + | def convert(name, |
| - | * it also contains all the Deadline render job setting | + | s1 = re.sub('(.)([A-Z][a-z]+)', |
| + | | ||
| + | # | ||
| - | * get absolution render output path (including dynamic changing output path) <code python> | + | def convert2(name, gap=' |
| - | cmds.renderSettings(firstImageName=1, fullPath=1) | + | |
| </ | </ | ||
| - | * get workspace current information <code python> | + | ===== requests ===== |
| - | cmds.workspace(q=1, rootDirectory=True) # root proj dir, holding the scene/ | + | |
| - | cmds.workspace(q=1, dir=1) # scene folder full-path | + | |
| - | # scene path and scene name | + | * 3rd party module, html get post request response operation library |
| - | cmds.file(q=True, sceneName=True) | + | * header list: https:// |
| - | cmds.file(q=True, | + | |
| - | # segment subpath | + | * **Single Get web link content** <code python> |
| - | cmds.workspace(fr=1,q=1) # list of segment sub names | + | import requests |
| - | cmds.workspace(fr=['images', | + | result |
| - | cmds.workspace(fr=[' | + | print(result.text) |
| - | cmds.workspace(fileRuleEntry=' | + | |
| </ | </ | ||
| - | * mel to use python write Pre-Render-Mel, | + | * **Single post web link content with login info** |
| - | import datetime; | + | result |
| - | time_text | + | print(result.text) |
| - | import maya.cmds as cmds; | + | |
| - | out_path = cmds.renderSettings(firstImageName=1, fullPath=1)[0]; | + | |
| - | scene_path = cmds.file(q=True, | + | |
| - | parent_dir = os.path.dirname(out_path); | + | |
| - | info_file=parent_dir+'.info'; | + | |
| - | os.path.exists(os.path.dirname(info_file)) or os.mkdir(os.path.dirname(info_file)); | + | |
| - | f = open(info_file, | + | |
| - | f.writelines([scene_path,'\n',time_text]); | + | |
| - | f.close(); | + | |
| - | print(' | + | |
| </ | </ | ||
| - | * mel version | + | * **one-time login with continue consistent header info for session operation** |
| - | python(" | + | with requests.Session() as session: |
| + | # first time login, | ||
| + | reply = session.post('http:// | ||
| + | print(reply.text) | ||
| + | # read rest login-required pages | ||
| + | reply = session.get('http:// | ||
| + | | ||
| </ | </ | ||
| - | * use python to set mel setting, note maya sometimes create another tmp ma file to render, | + | * check send header |
| - | # bake scene name into mel cmd, as render will create a another tmp scene file, which cause get scene name different in script | + | print(session_object.headers) # user sending header |
| - | scene_path = cmds.file(q=1, | + | print(reply_object.headers) # server replying header info |
| - | pre_mel = r''' | + | |
| - | # set as per render layer instead pre scene, since each folder has different name | + | |
| - | cmds.setAttr(" | + | |
| </ | </ | ||
| - | | + | |
| - | * preRenderLayerMel: | + | result.content # is html in bytes |
| - | * preRenderMel: | + | result.text # is html in unicode text |
| - | + | ||
| - | * defaultArnoldRenderOptions: | + | |
| - | * the arnold render setting object, contains all render setting for Arnold render | + | |
| - | + | ||
| - | ====== Pipeline ====== | + | |
| - | + | ||
| - | * cross platform maya scene directory mapping and management | + | |
| - | * dirmap command: http:// | + | |
| - | * ref: https:// | + | |
| - | + | ||
| - | * get mel system level operation and maya launch directory | + | |
| - | import maya.mel as mel | + | |
| - | print(mel.eval(' | + | |
| </ | </ | ||
| + | * disable non secure cert warning <code python> | ||
| + | ===== PIL and Pillow===== | ||
| - | * Publish workflow | + | * PIL, Python Imaging Library |
| - | * http:// | + | * python code <code python> |
| - | * Project Dir <code python> | + | from PIL import Image, ImageDraw, ImageOps |
| - | * File New <code python> | + | |
| - | cmds.file(f=1,new=1) | + | |
| - | </ | + | |
| - | * File Open <code python> | + | |
| - | cmds.file(filePath, o=True) | + | |
| - | cmds.file(renameToSave=1) # prevent overwrite save after open | + | |
| - | </ | + | |
| - | * Importing <code python> | + | |
| - | * Reference < | + | |
| - | allRefNode = cmds.ls( references=1) | + | |
| - | cur_node = allRefNode[0] | + | |
| - | # get reference used namespace | + | |
| - | cur_ns= cmds.referenceQuery(cur_node, | + | |
| - | # get reference used file - C:/ | + | |
| - | cur_path = cmds.referenceQuery(cur_node, | + | |
| - | # get reference used file name - myfile.ma | + | |
| - | cur_name = cmds.referenceQuery(cur_node, | + | |
| - | </ | + | |
| - | * delete unused node < | + | |
| - | * checking | + | |
| - | cmds.file(q=1, sn=1) # filepath | + | |
| - | cmds.file(q=1, sn=1, un=1) # filepath in variable format | + | |
| - | cmds.file(q=1, | + | |
| - | cmds.file(q=1, | + | |
| - | </ | + | |
| - | * check file change and save <code python> | + | |
| - | cmds.file(q=1, | + | |
| - | cmds.file(save=1) | + | |
| - | </ | + | |
| - | * saving as <code python> | + | |
| - | # you need to rename first before you can save as | + | |
| - | if ext.lower() == " | + | |
| - | cmds.file(rename = filePath) | + | |
| - | cmds.file(f=1, | + | |
| - | save_done = 1 | + | |
| - | elif ext.lower() == " | + | |
| - | cmds.file(rename = filePath) | + | |
| - | cmds.file(f=1, | + | |
| - | save_done = 1 | + | |
| - | </ | + | |
| - | * export <code python> | + | |
| - | if format_info == " | + | |
| - | if self.uiList[' | + | |
| - | cmds.file(filePath, | + | |
| - | else: | + | |
| - | cmds.file(filePath, | + | |
| - | else: | + | |
| - | if self.uiList[' | + | |
| - | cmds.file(filePath, | + | |
| - | else: | + | |
| - | cmds.file(filePath, | + | |
| </ | </ | ||
| - | * mel shelf button< | ||
| - | global string $gShelfTopLevel; | ||
| - | string $currentShelf = `tabLayout -query -selectTab $gShelfTopLevel`; | ||
| - | setParent $currentShelf; | ||
| - | // - step 2: prepare path, name, icon, cmd | ||
| - | string $name=" | ||
| - | string $ver=" | ||
| - | string $icon=" | ||
| - | string $cmd ="ls -sl"; | ||
| - | // - step 3: create shelf btn | ||
| - | shelfButton -c $cmd -ann $name -l $name -imageOverlayLabel $ver -overlayLabelColor 0 0 0 -overlayLabelBackColor 0 0 0 0.0 -image $icon -image1 $icon -sourceType " | ||
| - | shelfButton -c $cmd -ann $name -l $name -imageOverlayLabel $ver -overlayLabelColor 0 0 0 -overlayLabelBackColor 1 1 1 0.5 -image $icon -image1 $icon -sourceType " | + | ===== BeautifulSoup ===== |
| - | string $curBtn = `shelfButton -parent $currentShelf -c $cmd -mi "reload" | + | * a html info extractor, best works with another parser module |
| - | string $curPop = `popupMenu -parent $curBtn -button 1 -ctl 1`; // sh, alt, ctl | + | * ref: https:// |
| - | menuItem -p $curPop -l "A A A" | + | * parser is a html interprater, as not all html is clean format and tidy, some parser can auto fix some html tag miss match. |
| - | menuItem -p $curPop -l " | + | * example code <code python> |
| + | from bs4 import BeautifulSoup | ||
| + | soup = BeautifulSoup(html, | ||
| + | # find all title link text | ||
| + | link_list = soup.find_all("a", {' | ||
| + | name_list = [x.string for x in link_list ] # text element extract | ||
| + | link_list[0].attrs[' | ||
| </ | </ | ||
| - | * shelf operation with python <code python> | ||
| - | import maya.cmds as cmds | ||
| - | import maya.mel as mel | ||
| - | shelf_holder = mel.eval(' | ||
| - | shelves = cmds.tabLayout(shelf_holder, | ||
| - | shelves = cmds.tabLayout(shelf_holder, | ||
| - | cmds.shelfTabLayout(e=1, | ||
| - | cmds.shelfTabLayout(shelf_holder, | ||
| - | cmds.shelfLayout(shelf_name, | ||
| - | shelf_name = mel.eval(' | ||
| - | mel.eval(' | ||
| - | cmds.saveAllShelves(shelf_holder) # save all shelfs | + | ===== selenium ===== |
| - | </ | + | |
| - | * Maya path customize: It looks like maya only initialize those PATHs info during startup, manually add them after restart, maya still complain can't find the path. So use following method first. | + | * you need install 2 things to get it working: |
| - | - maya.env method (It loads before UI, before userSetup.py)< | + | - Python module: |
| - | USER_SCRIPT_PATH1=C:/myscripts/whatever/path1 | + | - for py2.7: https:// |
| - | USER_SCRIPT_PATH2=C:/myscripts/whatever/path2 | + | - for py3.x: https://pypi.python.org/pypi/ |
| - | MAYA_SCRIPT_PATH=$MAYA_SCRIPT_PATH; | + | - system platform dependent webdriver binary: http://www.seleniumhq.org/ |
| - | MAYA_MODULE_PATH | + | - for chrome browser automate: go above link and find 3rd binding " |
| - | MAYA_PLUG_IN_PATH = D:\whatever\plugin | + | - then you can load that drive binary into python selenium module object to start <code python> |
| - | PYTHONPATH = D:\whatever\scripts | + | from selenium import webdriver |
| + | driver | ||
| + | driver.get(' | ||
| + | driver.implicitly_wait(20) | ||
| + | driver.get_screenshot_as_file(r' | ||
| + | driver.quit() | ||
| </ | </ | ||
| - | - userSetup.py method | + | * get element <code python> |
| - | print("\nLoading Pipeline from userSetup.py\n") | + | # get css selector by right click browser' |
| + | driver.find_element_by_css_selector('.jsb > center: | ||
| + | # path method | ||
| + | driver.find_element_by_xpath('// | ||
| </ | </ | ||
| - | - userSetup.mel method | + | * element operation |
| - | print(" | + | * element.get_attribute(' |
| - | $path1 = " | + | * element.get_attribute(' |
| - | $path2 = " | + | * element.text |
| - | string $newScriptPath = $path1 + ";" | + | * element.click() |
| - | putenv " | + | * element_input.send_keys() and webdriver.common.keys |
| + | * element_form.submit() | ||
| + | * driven_browser.back(), | ||
| - | // or source other config script | + | * additional tool: |
| - | $script1 = "C:/ | + | * selenium ide firefox - a all-in-one test tool for it: https://addons.mozilla.org/en-US/firefox/addon/selenium-ide/ |
| - | $script2 = "C:/myscripts/whatever/ | + | * tutorial: http://www.seleniumeasy.com/selenium-tutorials/css-selectors-tutorial-for-selenium-with-examples |
| - | source $script1; | + | ===== PyAutoGUI ===== |
| - | source $script2; | + | |
| - | </code> | + | |
| - | | + | |
| - | // bash | + | |
| - | alias proj1=" | + | |
| - | // dos | + | |
| - | set MAYA_MODULE_PATH=R:/ | + | |
| - | "C:/Program Files/Autodesk/Maya2020/bin/ | + | |
| - | </ | + | |
| - | ===== Batch File Process Example ===== | + | * GUI cross-platform GUI interaction automation |
| + | * ref: https:// | ||
| + | * tutorial: https:// | ||
| + | * full list of library required in download page: https:// | ||
| - | * convert fbx file to mb file, and cleanup geo naming and material naming and texture node naming <code python> | + | * mouse control |
| - | import maya.cmds as cmds | + | |
| - | import maya.mel as mel | + | |
| - | import os | + | |
| - | root_path = r' | + | |
| - | fbx_list = [x for x in os.listdir(root_path ) if x.endswith(' | + | |
| - | prefix = ' | + | |
| - | for each_fbx in fbx_list: | + | |
| - | | + | # note, that displayMousePosition require 3rd party library |
| - | name = each_fbx.split(' | + | # * PIL (Py2.x only, adapted by Pillow) > PIL.ImageGrab > pyscreenze |
| - | id = name.rsplit(' | + | http://www.pythonware.com/ |
| - | # new file | + | https:// |
| - | cmds.file(f=1,new=1) | + | |
| - | cmds.file(os.path.join(root_path, each_fbx), i=1) | + | |
| - | mel.eval(' | + | |
| - | | + | |
| - | if len(anim_list)> | + | |
| - | cmds.delete(anim_list) | + | |
| - | # mesh | + | |
| - | mesh_list = [ cmds.listRelatives(x,p=1)[0] for x in cmds.ls(type=' | + | |
| - | | + | |
| - | | + | |
| - | | + | |
| - | | + | |
| - | # material | + | |
| - | mat_node = cmds.shadingNode(' | + | |
| - | cmds.select(new_geo) | + | |
| - | cmds.hyperShade(new_geo, assign=mat_node) | + | |
| - | | + | |
| - | # texture | + | |
| - | | + | |
| - | new_file = cmds.rename(file_node, prefix+str(id)+' | + | |
| - | cmds.connectAttr(new_file+' | + | |
| - | cmds.connectAttr(new_file+' | + | |
| - | # save | + | |
| - | mel.eval(' | + | |
| - | cmds.file(rename = os.path.join(root_path, | + | |
| - | cmds.file(f=1, save=1, type=' | + | |
| - | # ask for verify as it runs | + | |
| - | res = cmds.confirmDialog(title=" | + | |
| - | if res == ' | + | |
| - | break | + | |
| </ | </ | ||
| - | ====== Scripting ====== | ||
| - | * load and source mel script <code python> | + | * keyboard control |
| - | mel_path | + | * typewrite(' |
| - | mel.eval('source " | + | * press('pageup') |
| - | </ | + | * hotkey('ctrl', 'o') |
| + | * note: best work with time.sleep(5) to give 5 sec for pc to respond | ||
| - | * use python to ask maya to execute a python command in its variable scope <code python> | + | * image recognition |
| - | # this enable external python tool to ask maya to run a command with variable in maya's scope | + | * pixel(x,y) # return RGB |
| - | cmds.python('cmds.select({0})'.format(' | + | * screenshot([filename]) # return PIL,Pillow Image object [and save file] |
| + | * locateOnScreen(imageFilename) # returns (x,y, w, h) or None | ||
| + | * linux: scrot | ||
| + | * example code <code python> | ||
| + | import pyautogui as pui | ||
| + | pos = pui.locateOnScreen('d: | ||
| + | pui.click( (pos[0]+pos[2]*0.5 , pos[1]+pos[3]*0.5) ) | ||
| </ | </ | ||
| - | ====== Utility ====== | ||
| - | * open socket for external communication <code python> | + | ===== SikuliX ===== |
| - | # open port in maya | + | |
| - | import maya.cmds as cmds | + | |
| - | port = 7001 | + | |
| - | open_already | + | |
| - | try: | + | |
| - | cmds.commandPort(name=": | + | |
| - | except: | + | |
| - | open_already | + | |
| - | if open_already | + | |
| - | print(' | + | |
| - | # send to Maya from external python | + | * SikuliX automates anything you see on the screen of your desktop computer running Windows, Mac or some Linux/Unix. Link: http:// |
| - | import socket | + | * tutorial: https://www.youtube.com/ |
| - | host = '127.0.0.1' # localhost | + | |
| - | port = 7001 | + | |
| - | client = socket.socket(socket.AF_INET, socket.SOCK_STREAM) | + | |
| - | client.connect((host, | + | |
| - | client.send(' | + | |
| - | # close port in maya | + | ===== pyautoit |
| - | cmds.commandPort(name=": | + | |
| - | </ | + | |
| - | ====== Plugin ====== | + | |
| - | * check and load python | + | * a python |
| - | if not cmds.pluginInfo(' | + | |
| - | | + | * AutoIt home page: https://www.autoitscript.com/site/ |
| - | </code> | + | * API level interaction |
| - | * group a portion of cmds into one undo <code python> | + | |
| - | cmds.undoInfo(openChunk=True) | + | |
| - | # after end of the operation and before error rise, put | + | |
| - | cmds.undoInfo(closeChunk=True) | + | |
| - | </code> | + | |
| - | * check plugin in use in a scene <code python> | ||
| - | plugin_list_inUse = sorted(cmds.pluginInfo(q=1, | ||
| - | </ | ||
| - | * remove unknown plugin from Maya 2015 onwards <code python> | ||
| - | oldplugins = cmds.unknownPlugin(q=True, | ||
| - | for plugin in oldplugins: | ||
| - | cmds.unknownPlugin(plugin, | ||
| - | </ | ||
| - | ====== Maya Qt GUI Tool Development ====== | ||
| + | ===== pywinauto ===== | ||
| - | * Qt python tool build guide tutorial links: | + | * a mostly windows only GUI automation module, with mouse, keyboard support on linux |
| - | * this uses Qt designer app to create | + | * API level interaction |
| - | * http:// | + | |
| - | * this one use Qt codes to build a UI inside code of python | + | |
| - | * http:// | + | |
| - | * a list of guides | + | |
| - | * http:// | + | |
| - | * check Python version and bit <code python> | + | ===== pywin32 - win32com ===== |
| - | import struct; | + | |
| - | | + | * tip and ref: |
| - | | + | * http:// |
| - | | + | * http:// |
| - | * or download PyQt4 binary package | + | * COMbrowser: win32com\client\combrowse.py |
| - | - then | + | |
| - | * either copy them into Maya's local python site package | + | |
| - | * or add your " | + | |
| - | # check Maya python version and bit | + | |
| - | import sys; | + | |
| - | import struct; | + | |
| - | # check Maya python included path | + | |
| - | import sys; | + | |
| - | for each in sys.path: | + | |
| - | print each | + | |
| - | # maya's local addition python package place: | + | |
| - | # example on windows: C:\Program Files\Autodesk\Maya2015\Python\lib\site-packages | + | |
| - | # or add my downloaded PyQt4 install | + | * install |
| - | # PyQt4 windows binary link (you can install/ | + | https://sourceforge.net/projects/pywin32/ |
| - | # http://www.riverbankcomputing.com/software/pyqt/download | + | (or) python |
| - | sys.path.append(' | + | |
| - | from PyQt4 import QtGui,QtCore</code> | + | * get windows explorer in taskbar order, return [(title, hwnd int, addressbar url, [top, |
| - | | + | import win32com |
| + | from win32com import client | ||
| + | def get_explorer_list(): | ||
| + | | ||
| + | shell = client.Dispatch(" | ||
| + | win_list = shell.Windows() | ||
| + | result_list = [] | ||
| + | for win in win_list: | ||
| + | info = [] | ||
| + | info.append(win.LocationName) # title name | ||
| + | info.append(win.hwnd) # handle value as int | ||
| + | info.append(win.LocationURL) # address bar url, eg. file:/// | ||
| + | info.append([win.Top, win.Left, win.width, win.height]) # win pixel position | ||
| + | info.append(win.visible) # visible | ||
| + | info.append(win) # com object | ||
| + | result_list.append(info) | ||
| + | return result_list | ||
| + | ''' | ||
| + | [' | ||
| + | ' | ||
| + | ' | ||
| + | ' | ||
| + | ' | ||
| + | ' | ||
| + | ''' | ||
| + | </code> | ||
| + | * get selected item in window explorer | ||
| + | # ref: | ||
| + | # https:// | ||
| + | # https:// | ||
| - | * explanation of above: PyQt binding vs PySide binding | + | def get_selection_list(win): |
| + | # win32com: get selection item detail from win COM object | ||
| + | item_list = [] | ||
| + | folderItems = win.Document.SelectedItems() | ||
| + | for i in range(folderItems.Count): | ||
| + | tmp_info = [] | ||
| + | tmp_info.append(folderItems.Item(i).path) # C:\Users\Test\Downloads\example.zip | ||
| + | tmp_info.append(folderItems.Item(i).name) | ||
| + | tmp_info.append(folderItems.Item(i).isFolder) | ||
| + | tmp_info.append(folderItems.Item(i).size) | ||
| + | tmp_info.append(folderItems.Item(i).type) | ||
| + | item_list.append(tmp_info) | ||
| + | return item_list | ||
| + | </code> | ||
| + | * explorer window COM object control <code python> | ||
| + | # control the window COM object to go to a location | ||
| + | win.Navigate(' | ||
| + | win.Busy # a check for still in processing | ||
| + | # check visibile and make full screen | ||
| + | win.FullScreen =1 # make first windows explorer full screen | ||
| + | </ | ||
| + | * system operation< | ||
| + | # get system dir and | ||
| + | oShell = win32com.client.Dispatch(" | ||
| + | print(oShell.SpecialFolders(" | ||
| - | ====== My Python Tool ====== | + | # change drive letter |
| + | # ref: http:// | ||
| - | * shelf load python code <code python> | + | # create windows shortcut and read it |
| - | import maya.cmds as cmds | + | shortcut = shell.CreateShortCut(" |
| - | from sys import platform | + | shortcut.Targetpath = "D:\\tmp" |
| - | import sys | + | shortcut.save() |
| - | import os | + | |
| - | + | ||
| - | def getOS(): | + | |
| - | ''' | + | |
| - | if platform.startswith(' | + | |
| - | | + | |
| - | elif platform.startswith(' | + | |
| - | return ' | + | |
| - | return ' | + | |
| - | def getZ(): | + | shortcut |
| - | ''' | + | print(shortcut.Targetpath) |
| - | z_sys=os.getenv(' | + | |
| - | z_sys = z_sys.strip() | + | |
| - | z_sys = z_sys.replace("\\","/ | + | |
| - | | + | |
| - | sys.path.append(z_sys+" | + | # get single screen resolution and total screen |
| + | # ref: https:// | ||
| + | import win32api | ||
| + | w=win32api.GetSystemMetrics(0) # primary screen width | ||
| + | h=win32api.GetSystemMetrics(1) # primary screen height | ||
| + | vw = win32api.GetSystemMetrics(78) # total screen area width | ||
| + | vh = win32api.GetSystemMetrics(79) # total screen area height | ||
| + | print(' | ||
| + | print(' | ||
| </ | </ | ||
| + | ===== ctypes ===== | ||
| - | ====== 3rd Party Tool ====== | + | |
| - | | + | * ref: http://nullege.com/codes/search/ctypes |
| - | * http://www.tokeru.com/t/bin/view/ | + | * my doc on windows API and DLL functions [[devwiki: |
| - | * Sculpt Inbetween Editor | + | * (method 1) get all windows explorer windows in Z order, return [(title, class, [x,y,w,h], hwnd int)] <code python> |
| - | | + | def get_win_order_all(): |
| + | | ||
| + | from ctypes import wintypes | ||
| + | order_list = [] | ||
| + | result_list = [] | ||
| + | top = ctypes.windll.user32.GetTopWindow(None) | ||
| + | if not top: | ||
| + | return order_list | ||
| + | length = ctypes.windll.user32.GetWindowTextLengthW(top) | ||
| + | buff = ctypes.create_unicode_buffer(length + 1) | ||
| + | ctypes.windll.user32.GetWindowTextW(top, | ||
| + | class_name = ctypes.create_string_buffer(200) | ||
| + | ctypes.windll.user32.GetClassNameA(top, | ||
| + | r=ctypes.wintypes.RECT() | ||
| + | ctypes.windll.user32.GetWindowRect(top, | ||
| + | # class_name.value in py3 is byte, while py2 is string | ||
| + | if isinstance(class_name.value, | ||
| + | result_list.append( [buff.value, | ||
| + | else: | ||
| + | result_list.append( [buff.value, | ||
| + | order_list.append(top) | ||
| + | while True: | ||
| + | next = ctypes.windll.user32.GetWindow(order_list[-1], 2) # win32con.GW_HWNDNEXT | ||
| + | if not next: | ||
| + | break | ||
| + | length = ctypes.windll.user32.GetWindowTextLengthW(next) | ||
| + | buff = ctypes.create_unicode_buffer(length + 1) | ||
| + | ctypes.windll.user32.GetWindowTextW(next, | ||
| + | class_name = ctypes.create_string_buffer(200) | ||
| + | ctypes.windll.user32.GetClassNameA(next, | ||
| + | r=ctypes.wintypes.RECT() | ||
| + | ctypes.windll.user32.GetWindowRect(next, | ||
| + | # class_name.value in py3 is byte, while py2 is string | ||
| + | if isinstance(class_name.value, | ||
| + | result_list.append( [buff.value, | ||
| + | else: | ||
| + | result_list.append( [buff.value, | ||
| + | order_list.append(next) | ||
| + | return result_list | ||
| - | ====== Python and Maya Qt interface ====== | + | full_list |
| - | ===== PyQt case code ===== | + | visible_list |
| + | # visible list is actually more useful, 10+ instead 100+ items | ||
| - | | + | explorer_list = [x for x in visible if x[1]==' |
| - | | + | firefox_list = [x for x in visible if x[1]==' |
| + | </ | ||
| + | | ||
| + | def get_win_order_v2(): | ||
| + | | ||
| + | # ref: https:// | ||
| + | # info (title, class_name, hwnd) | ||
| + | window_list = [] | ||
| + | # propare windows list passing | ||
| + | def window_info_process(hwnd, lParam): | ||
| + | if ctypes.windll.user32.IsWindowVisible(hwnd): | ||
| + | length = ctypes.windll.user32.GetWindowTextLengthW(hwnd) | ||
| + | buff = ctypes.create_unicode_buffer(length + 1) | ||
| + | ctypes.windll.user32.GetWindowTextW(hwnd, | ||
| + | class_name = ctypes.create_string_buffer(200) | ||
| + | ctypes.windll.user32.GetClassNameA(hwnd, | ||
| + | t_class_name = class_name.value | ||
| + | if not isinstance(t_class_name, | ||
| + | t_class_name = class_name.value.decode(' | ||
| + | if t_class_name == ' | ||
| + | window_list.append( [ buff.value, t_class_name, | ||
| + | return True | ||
| + | procObj = ctypes.WINFUNCTYPE(ctypes.c_bool, | ||
| + | # execute it | ||
| + | ctypes.windll.user32.EnumWindows(procObj(window_info_process), | ||
| + | return window_list | ||
| + | </ | ||
| + | * (method 3) Break down ctypes hwnd, pid, process_handle into functions modules <code python> | ||
| + | ''' | ||
| + | ref: http:// | ||
| + | Window handle → process ID: GetWindowThreadProcessId | ||
| + | Process ID → process handle: OpenProcess | ||
| + | Process handle → executable path: QueryFullProcessImageName (compare this with your target) | ||
| + | Close the process handle: CloseHandle | ||
| + | ref: http:// | ||
| + | Windows 2000 = GetModuleFileName() | ||
| + | Windows XP x32 = GetProcessImageFileName() | ||
| + | Windows XP x64 = GetProcessImageFileName() | ||
| + | Windows Vista = QueryFullProcessImageName() | ||
| + | Windows 7 = QueryFullProcessImageName() | ||
| + | ref: | ||
| + | uisoup - utils : https:// | ||
| + | https:// | ||
| + | https:// | ||
| + | ''' | ||
| - | * layout alignment, QtCore.Qt.AlignTop, AlignRight | + | def get_win_pid(hwnd): |
| - | * layout.setAlignment(QtCore.Qt.AlignTop) | + | cur_pid = ctypes.c_long() |
| + | ctypes.windll.user32.GetWindowThreadProcessId(hwnd, ctypes.byref(cur_pid)) | ||
| + | | ||
| + | def get_process_path(pid): | ||
| + | PROCESS_QUERY_INFORMATION = 0x0400 | ||
| + | max_unicode_path = 32767 * 2 + 200 | ||
| + | file_path_buffer = ctypes.create_unicode_buffer(max_unicode_path) | ||
| + | length_path = ctypes.c_ulong(max_unicode_path) | ||
| + | pHandle = ctypes.windll.kernel32.OpenProcess(PROCESS_QUERY_INFORMATION, | ||
| + | retval = ctypes.windll.kernel32.QueryFullProcessImageNameW(pHandle, | ||
| + | if retval == 0: | ||
| + | raise Exception(' | ||
| + | # | ||
| + | return file_path_buffer.value | ||
| + | def get_win_path(hwnd): | ||
| + | return get_process_path(get_win_pid(hwnd)) | ||
| - | ====== | + | def get_win_rect(hwnd): |
| + | from ctypes import wintypes | ||
| + | r=ctypes.wintypes.RECT() | ||
| + | ctypes.windll.user32.GetWindowRect(hwnd, | ||
| + | return [r.left, | ||
| + | def get_win_title(hwnd): | ||
| + | length | ||
| + | title_buffer | ||
| + | ctypes.windll.user32.GetWindowTextW(hwnd, | ||
| + | return title_buffer.value | ||
| + | # AE CS6: AE_CApplication_11.0 | ||
| + | def get_win_class(hwnd): | ||
| + | class_name | ||
| + | ctypes.windll.user32.GetClassNameA(hwnd, | ||
| + | t_class_name | ||
| + | if not isinstance(t_class_name, | ||
| + | t_class_name | ||
| + | return t_class_name | ||
| + | def is_win_top(hwnd): | ||
| + | top_hwnd | ||
| + | return hwnd == top_hwnd | ||
| - | Environment of Python in Maya | + | def get_win_list(visible=1, |
| - | * PYTHONPATH | + | # both method get result |
| - | * Maya.env: <code python> | + | # orderMethod uses : ctypes.windll.user32.GetTopWindow |
| - | import sys | + | # callBackMethod uses: ctypes.windll.user32.EnumWindows |
| - | sys.path.append("/xTool/resMaya/py") | + | |
| - | # much better than eval(" | + | if orderMethod: |
| + | order_list = [] | ||
| + | top = ctypes.windll.user32.GetTopWindow(None) | ||
| + | if not top: | ||
| + | return win_list | ||
| + | visible_info = ctypes.windll.user32.IsWindowVisible(top) | ||
| + | win_list.append( | ||
| + | order_list.append(top) | ||
| + | while True: | ||
| + | next = ctypes.windll.user32.GetWindow(order_list[-1], | ||
| + | if not next: | ||
| + | break | ||
| + | visible_info = ctypes.windll.user32.IsWindowVisible(next) | ||
| + | win_list.append( [next, visible_info] ) # hwnd: as int | ||
| + | order_list.append(next) | ||
| + | else: | ||
| + | # propare windows list passing | ||
| + | def window_info_process(hwnd, | ||
| + | visible_info = ctypes.windll.user32.IsWindowVisible(hwnd) | ||
| + | win_list.append( [ hwnd, visible_info ]) #hwnd: as LP_c_long | ||
| + | return True | ||
| + | # ref: http://makble.com/the-story-of-lpclong | ||
| + | # function 1: this will get as LP_c_long as hwnd | ||
| + | #procObj = ctypes.WINFUNCTYPE(ctypes.c_bool, | ||
| + | # function 2: this will get int as hwnd like other win32api function | ||
| + | procObj = ctypes.WINFUNCTYPE(ctypes.c_bool, ctypes.c_int, | ||
| + | # execute it | ||
| + | ctypes.windll.user32.EnumWindows(procObj(window_info_process), | ||
| + | if visible: | ||
| + | return [x for x in win_list if x[1]] | ||
| + | return win_list | ||
| </ | </ | ||
| - | * userStartup.py | + | * ctypes window operation by hwnd<code python> |
| - | * load custom system environment variable, Python shines so much comparing to Mel in this case <code python> | + | # my_hwnd can be a int or a ctypes int pointer |
| - | import maya.cmds as cmds | + | # full function ref: http://www.jasinskionline.com/ |
| - | from sys import platform | + | |
| - | import os | + | |
| - | + | ||
| - | def getOS(): | + | |
| - | if platform.startswith(' | + | |
| - | return ' | + | |
| - | elif platform.startswith(' | + | |
| - | return ' | + | |
| - | return ' | + | |
| - | def getZ(): | + | # bring window to bring |
| - | ''' | + | ctypes.windll.user32.SetForegroundWindow(my_hwnd) |
| - | | + | |
| - | | + | |
| - | + | ||
| - | # | + | |
| - | #else $z_sys=system(" | + | |
| - | + | ||
| - | z_sys=os.getenv(' | + | |
| - | + | ||
| - | ## remove new line, mel | + | |
| - | # | + | |
| - | # | + | |
| - | # | + | |
| - | # | + | |
| - | z_sys = z_sys.strip() | + | # close window |
| + | WM_CLOSE | ||
| + | ctypes.windll.user32.PostMessageA(my_hwnd, WM_CLOSE, 0, 0) | ||
| - | | + | # get window x,y,w,h |
| - | | + | from ctypes import wintypes |
| - | # make sure system environment got defined | + | r=ctypes.wintypes.RECT() |
| - | if(z_sys!="" | + | ctypes.windll.user32.GetWindowRect(my_hwnd, |
| - | print z_sys | + | print( [r.left, |
| - | return z_sys | + | |
| + | # move window by x,y,w,h and refresh | ||
| + | ctypes.windll.user32.MoveWindow(my_hwnd, | ||
| </ | </ | ||
| - | ====== Python in mel basic ====== | + | |
| - | | + | # get mouse position |
| - | print("This is %s" | + | class POINT(ctypes.Structure): |
| - | print("This is "+word) | + | _fields_ |
| + | pt = POINT() | ||
| + | ctypes.windll.user32.GetCursorPos(ctypes.byref(pt)) | ||
| + | print('{0} {1}' | ||
| + | |||
| + | ctypes.windll.user32.SetCursorPos(1200, | ||
| + | ctypes.windll.user32.mouse_event(2, | ||
| + | ctypes.windll.user32.mouse_event(4, | ||
| </ | </ | ||
| - | * string | + | * get and set wallpaper in windows |
| - | | + | def getWallpaper(): |
| + | | ||
| + | # try: | ||
| + | # win32con.SPI_GETDESKWALLPAPER | ||
| + | # except AttributeError, | ||
| + | # raise WinDesktopError, | ||
| + | wallpaper = ctypes.c_buffer(" | ||
| + | ctypes.windll.user32.SystemParametersInfoA(SPI_GETDESKWALLPAPER, | ||
| + | return wallpaper.value | ||
| + | |||
| + | def setWallpaper(wallpaperPath, | ||
| + | # Convert to bitmap if necessary | ||
| + | wallpaperImage = Image.open(wallpaperPath) | ||
| + | if wallpaperImage.format != ' | ||
| + | conversionPath = conversionPath or os.getenv(' | ||
| + | wallpaperPath = os.path.join(conversionPath, | ||
| + | wallpaperImage.save(wallpaperPath) | ||
| + | # Set wallpaper | ||
| + | wallpaperPath = ctypes.c_buffer(wallpaperPath) | ||
| + | ctypes.windll.user32.SystemParametersInfoA(win32con.SPI_SETDESKWALLPAPER, | ||
| </ | </ | ||
| - | * start using mel as python | + | * wallpaper set (win7) the simple version |
| - | import | + | import |
| - | maya.cmds.select(" | + | SPI_SETDESKWALLPAPER=20 |
| - | maya.cmds.ls(sl=True) | + | ctypes.windll.user32.SystemParametersInfoA(SPI_SETDESKWALLPAPER, 0, r"D: |
| + | </ | ||
| + | * set id <code python> | ||
| + | * get if user is admin <code python> | ||
| + | * system operation <code python> | ||
| + | # get screen count | ||
| + | screen_cnt | ||
| + | # get screen resolution | ||
| + | screen_x, screen_y = ( ctypes.windll.user32.GetSystemMetrics(78), | ||
| </ | </ | ||
| - | | + | **file and folder operation** |
| - | import myModule | + | * show drive letter in use <code python> |
| - | myModule.myFunc() | + | drive_list_data = ctypes.cdll.msvcrt._getdrives() # binary mask in decimal format |
| - | + | mask_list = list( ' | |
| - | # reload | + | A_code = 65 # ascii code of letter A |
| - | reload(myModule) | + | drive_letter_in_use = [ chr(A_code+i) for i in range(len(mask_list)) if mask_list[i]==' |
| </ | </ | ||
| + | * show file and select file in explorer (return 42)<code python> | ||
| + | my_filePath = u' | ||
| + | ctypes.windll.shell32.ShellExecuteW(None, | ||
| + | * open file property window <code python> | ||
| + | import time | ||
| + | import ctypes | ||
| + | import ctypes.wintypes | ||
| + | |||
| + | SEE_MASK_NOCLOSEPROCESS = 0x00000040 | ||
| + | SEE_MASK_INVOKEIDLIST = 0x0000000C | ||
| + | |||
| + | class SHELLEXECUTEINFO(ctypes.Structure): | ||
| + | _fields_ = ( | ||
| + | (" | ||
| + | (" | ||
| + | (" | ||
| + | (" | ||
| + | (" | ||
| + | (" | ||
| + | (" | ||
| + | (" | ||
| + | (" | ||
| + | (" | ||
| + | (" | ||
| + | (" | ||
| + | (" | ||
| + | (" | ||
| + | (" | ||
| + | ) | ||
| - | * eval like in Python <code python> | + | ShellExecuteEx = ctypes.windll.shell32.ShellExecuteEx |
| - | import maya.mel | + | ShellExecuteEx.restype = ctypes.wintypes.BOOL |
| - | maya.mel.eval("ls -sl") | + | |
| + | sei = SHELLEXECUTEINFO() | ||
| + | sei.cbSize = ctypes.sizeof(sei) | ||
| + | sei.fMask = SEE_MASK_NOCLOSEPROCESS | SEE_MASK_INVOKEIDLIST | ||
| + | sei.lpVerb = "properties" | ||
| + | sei.lpFile = ' | ||
| + | sei.nShow = 1 | ||
| + | ShellExecuteEx(ctypes.byref(sei)) | ||
| + | time.sleep(5) | ||
| </ | </ | ||
| - | * python | + | * get clipboard data (ref: https:// |
| - | string $list[]=python(" | + | import ctypes |
| - | size($list) | + | def get_clipboard_text(): |
| + | ctypes.windll.kernel32.GlobalLock.argtypes = [ctypes.c_void_p] | ||
| + | ctypes.windll.kernel32.GlobalLock.restype = ctypes.c_void_p | ||
| + | ctypes.windll.kernel32.GlobalUnlock.argtypes | ||
| + | ctypes.windll.user32.GetClipboardData.restype = ctypes.c_void_p | ||
| + | |||
| + | ctypes.windll.user32.OpenClipboard(0) | ||
| + | | ||
| + | if ctypes.windll.user32.IsClipboardFormatAvailable(1): | ||
| + | data = ctypes.windll.user32.GetClipboardData(1) | ||
| + | data_locked = ctypes.windll.kernel32.GlobalLock(data) | ||
| + | text = ctypes.c_char_p(data_locked) | ||
| + | value = text.value | ||
| + | ctypes.windll.kernel32.GlobalUnlock(data_locked) | ||
| + | return value | ||
| + | finally: | ||
| + | ctypes.windll.user32.CloseClipboard() | ||
| + | # test | ||
| + | print(get_clipboard_text()) | ||
| </ | </ | ||
| + | ===== twisted ===== | ||
| - | ====== Common Python function====== | + | * network communication: |
| + | * old version with python 2.7 32bit wheel: https:// | ||
| - | * to use maya cmds, you need to run this code to get follow working <code python> | + | ===== django |
| - | ===== selection related | + | |
| - | * select all geo from root node<code python> | + | * a python web server, install by <code>python |
| - | # method 1, filterExpand | + | |
| - | childs = cmds.listRelatives(root, | + | |
| - | allgeo = cmds.filterExpand(childs, | + | |
| - | # method 2, naming based | + | ===== openpyxl===== |
| - | cmds.select(root) | + | |
| - | cmds.select(hierarchy=1) | + | * a new excel reader, xlsx format, not old xls format, since now everyone use new excel version |
| - | tAll=cmds.ls(sl=1,type=' | + | * read excel as dictionary |
| - | allgeo=[] | + | def excel2Dict(filename): |
| - | for each in tAll: | + | # import openpyxl |
| - | if(each.endswith(' | + | # max_row |
| - | | + | # max_column = sheet.max_column |
| - | #mel:if(`gmatch $each " | + | wb = openpyxl.load_workbook(filename=filename, read_only=True) |
| + | | ||
| + | for sheet in wb.worksheets: | ||
| + | count = 0 | ||
| + | keys = [] | ||
| + | |||
| + | for row in sheet.rows: | ||
| + | temp = [] | ||
| + | for cell in row: | ||
| + | | ||
| + | keys.append(str(cell.value)) | ||
| + | else: | ||
| + | temp.append(str(cell.value)) | ||
| + | if count > 0: | ||
| + | | ||
| + | else: | ||
| + | count += 1 | ||
| + | return records | ||
| + | </ | ||
| + | * read excel as row data wo empty cell. <code python> | ||
| + | | ||
| + | | ||
| + | wb = openpyxl.load_workbook(filename=filename, | ||
| + | sheet_data = [] | ||
| + | for sheet in wb.worksheets: | ||
| + | table_data = [] | ||
| + | for row in sheet.values: | ||
| + | row_data = [] | ||
| + | for cell in row: | ||
| + | | ||
| + | row_data.append(cell) | ||
| + | if len(row_data)>0: | ||
| + | table_data.append(row_data) | ||
| + | sheet_data.append(table_data) | ||
| + | return sheet_data | ||
| </ | </ | ||
| + | ====== Python by Reference or by Value ====== | ||
| - | ===== attribute related ===== | + | * my experience found: " |
| + | * more study on Pointer vs Reference: http:// | ||
| + | * Python variable are all reference, so pass reference to a function, the inside function holds copy of the reference, nothing outside affected, but if inside function reference modify, outside will be affected, since they all store value at same memory location(reference to that location): http:// | ||
| + | * http:// | ||
| + | * and another clear explanation of python reference vs c++ reference from c++ user by code: https:// | ||
| + | * here is my study experiment <code python> | ||
| - | * note attribute, which is not added by default, need to be added manually <code python> | + | # |
| - | s=""" | + | # Example 1 |
| - | 2nd line; | + | dict = {} |
| - | """ | + | dict[' |
| - | if(cmds.objExists('base_prefs_null.notes' | + | for each in 'aa bb cc dd'.split(): |
| - | | + | |
| - | cmds.setAttr(' | + | list_aa = dict['seq']['aa'] # passing by reference!!! |
| - | </ | + | for i in [1,2,3,4,5]: |
| + | list_aa.append(i) | ||
| + | print dict # affect both list_aa and dict | ||
| + | |||
| + | temp_list | ||
| + | temp_list.append(22) # you are not get a copy of dict entry, but affect orginal dict as well | ||
| + | print temp_list | ||
| + | print dict # changed ------- because it is a operation | ||
| - | ===== sets related ===== | + | # ref: http:// |
| + | temp_list2 | ||
| + | temp_list2.append(55) | ||
| + | print temp_list2 | ||
| + | print dict # stay same | ||
| - | * empty group <code python> | + | # |
| - | * add to a organizing set<code python> | + | # Example 2 |
| + | locs = [ [1], [2] ] | ||
| + | for loc in locs: # passing by values !!! | ||
| + | loc = [] | ||
| + | print locs # stay same | ||
| - | ===== rigging related ===== | + | for loc in locs: |
| + | loc[0] | ||
| + | print locs # changed ------- because it is a operation | ||
| - | * findRelatedSkinCluster python version (written based on original mel version)< | + | # |
| - | def findRelatedSkinCluster( skinObject ): | + | # Example 3 |
| - | | + | a=1 |
| - | | + | b=a |
| - | | + | b=2 |
| - | | + | print a # stay the same |
| - | | + | |
| - | + | ||
| - | cpTest = cmds.ls( skinObject, typ=" | + | |
| - | if len( cpTest ): | + | |
| - | skinShape = skinObject | + | |
| - | + | ||
| - | else: | + | |
| - | rels = cmds.listRelatives( skinObject ) | + | |
| - | for r in rels : | + | |
| - | cpTest = cmds.ls( " | + | |
| - | if len( cpTest ) == 0: | + | |
| - | continue | + | |
| - | + | ||
| - | io = cmds.getAttr( " | + | |
| - | if io: | + | |
| - | continue | + | |
| - | + | ||
| - | visible = cmds.getAttr( " | + | |
| - | if not visible: | + | |
| - | hiddenShape = r | + | |
| - | hiddenShapeWithPath = " | + | |
| - | continue | + | |
| - | + | ||
| - | skinShape = r | + | |
| - | skinShapeWithPath = " | + | |
| - | break | + | |
| - | + | ||
| - | if len( skinShape ) == 0: | + | |
| - | if len( hiddenShape ) == 0: | + | |
| - | return None | + | |
| - | + | ||
| - | else: | + | |
| - | skinShape = hiddenShape | + | |
| - | skinShapeWithPath = hiddenShapeWithPath | + | |
| - | + | ||
| - | clusters = cmds.ls( typ=" | + | |
| - | for c in clusters: | + | |
| - | geom = cmds.skinCluster( c, q=True, g=True ) | + | |
| - | for g in geom: | + | |
| - | if g == skinShape or g == skinShapeWithPath: | + | |
| - | return c | + | |
| - | return None | + | |
| - | </ | + | |
| - | ===== animation related ===== | + | a=[1] |
| + | b=a | ||
| + | b=[2] | ||
| + | print a # stay the same | ||
| - | * setkeyframe <code python> | + | a=[1] |
| - | cmds.setKeyframe(testGeo+' | + | b=a |
| + | b.append(2) | ||
| + | print a # changed ------- because it is a operation | ||
| - | # just key the channel | + | # thus: assignment will not change original one, but operation will change original one |
| - | cmds.setKeyframe(testGeo+' | + | |
| - | </ | + | |
| - | * delete key <code python> | + | a=[1,2,3] |
| - | # delete all keys | + | b=a |
| - | cmds.cutKey(' | + | c=[4,5,6] |
| + | b=c | ||
| + | print a # stay the same | ||
| - | # delete some of keys | + | a=[1,2, [3.1,3.2,3.3] ] |
| - | # 1. get key frame list | + | b=a[2] |
| - | key_list = cmds.keyframe(' | + | c=[4,5,6] |
| - | key_list | + | b=c |
| + | print a # stay the same | ||
| - | # current key value | + | a=[1,2, [3.1, |
| - | cur_v = cmds.getAttr('locator1.tx', | + | b=a[2] |
| - | </ | + | b=[4,5,6] |
| + | print a # stay the same | ||
| + | |||
| + | a={'first': | ||
| + | b=a['first' | ||
| + | b=[4,5,6] | ||
| + | print a # stay the same | ||
| + | |||
| + | a={' | ||
| + | b=a[' | ||
| + | b[0]=4 | ||
| + | print a # changed ------- because it is a operation | ||
| + | |||
| + | a=[1,2, [3.1, | ||
| + | b=a[2][:] # fast copy | ||
| + | c=[4,5,6] | ||
| + | b=c | ||
| + | print a # stay the same | ||
| - | * run through frame range < | + | # |
| - | startFrame = cmds.playbackOptions(q=1, min=1) | + | # example 4: |
| - | endFrame = cmds.playbackOptions(q=1, max=1) | + | # ref: http:// |
| - | for f in range(int(startFrame), int(endFrame+1)): | + | # explain: http:// |
| - | cmds.currentTime(f) | + | def foo(a=[]): |
| + | a.append(5) | ||
| + | | ||
| + | foo() # changed every time | ||
| + | |||
| + | ######################################## | ||
| + | # reference | ||
| + | ''' | ||
| + | # ref: http:// | ||
| + | Everything in Python is passed and assigned by value (like Java) | ||
| + | Every value in Python is a reference | ||
| + | Objects cannot be values. | ||
| + | Assignment always copies the value (which is a pointer); | ||
| + | two such pointers can thus point to the same object. | ||
| + | Objects are never copied unless you're doing something explicit to copy them. | ||
| + | # ref: http:// | ||
| + | ???? | ||
| + | ''' | ||
| </ | </ | ||
| - | ===== dynamic related | + | ====== Common Python syntax ====== |
| - | * emitter, particle, instance, field < | + | * python |
| - | # | + | |
| - | # creation particle system | + | |
| - | # | + | |
| - | mName=' | + | |
| - | mE_subfix=' | + | |
| - | mP_subfix=' | + | |
| - | mI_subfix=' | + | |
| - | mInMesh_subfix=' | + | |
| - | mFt_subfix=' | + | |
| - | mC_loc_subfix=' | + | |
| - | mC_curve_subfix=' | + | |
| - | mC_null_subfix=' | + | |
| - | # node subfix | + | ^comment |# | |
| - | mN_mdl_subfix='_mdl' | + | ^print |print | |
| + | ^string |var=" | ||
| + | ^long string |%%varL='' | ||
| + | ^raw string |r"Any dangerous Character here" | | ||
| - | # | + | ^os navigation | ^file operation | ^string operation | ^lib | ^rename | |
| - | # emitter and particle | + | ^os.chdir('/ |
| - | # | + | ^os.getcwd() | ^tfile.write(' |
| - | mE=cmds.createNode('pointEmitter',n=mName+mE_subfix) | + | ^os.ctermid() | ^tfile.close() | ^str1+str2 |concatenate ^re |regular expression ^end_remove_fixed | |
| - | mP=cmds.createNode('particle',n=mName+mP_subfix) | + | ^os.uname() | ^tfile.read() | ^str(100) |string convert ^ | ^end_add_fixed | |
| + | ^os.listdir('/path') | ^tfile.writeline() | ^ | ^ | ^prefix_remove_vary | | ||
| + | ^os.mkdir('/ | ||
| + | ^os.removedirs('/ | ||
| + | ^os.rename(src,dst) | ^ | ^a* |may have ^ | ^ | | ||
| + | ^os.getenv(' | ||
| + | ^ | ^ | ^a? |may have one ^ | ^ | | ||
| + | ^ | ^ | ^a{1,3} |May 1~3 one ^ | ^ | | ||
| + | ^ | ^ | ^r”str” |raw string ^ | ^ | | ||
| + | ^regular expression | ^ | ^ | ^ | ^ | | ||
| + | ^ | ^ | ^ | ^ | ^ | | ||
| + | http:// | ||
| - | # connect dynamic | ||
| - | cmds.connectDynamic(mP, | ||
| - | cmds.connectAttr(' | ||
| - | # set initial value | + | ====== Python based tool and application ====== |
| - | e_conf={' | + | * [[http://nadiana.com/ |
| - | for attr, v in e_conf.items(): | + | |
| - | cmds.setAttr(mE+' | + | |
| - | # | + | * http:// |
| - | # instance | + | * Python documentation generator |
| - | # | + | |
| - | mI=cmds.createNode(' | + | |
| - | cmds.connectAttr(mP+' | + | |
| - | # instance Mesh | + | * XML to PDF generation using Python |
| - | mInMesh=cmds.polyCylinder(n=mName+mInMesh_subfix, | + | * http://www.blog.pythonlibrary.org/ |
| - | mMesh=mInMesh[0] | + | |
| - | mShape=mInMesh[1] | + | |
| - | cmds.setAttr(mMesh+' | + | |
| - | cmds.connectAttr(mMesh+' | + | |
| - | cmds.particleInstancer(mP, | + | |
| - | # | + | * Python add-on and libs |
| - | # field | + | * Python image library (PIL): http:// |
| - | # | + | * Python EXIF.py: http:// |
| - | mFt=cmds.createNode(' | + | * demo of usage: http:// |
| - | cmds.connectDynamic(mP, | + | * minimal EXIF reader and writer: http:// |
| + | * 50 python lib list: http:// | ||
| - | ft_conf={' | + | * a Chinese blog on python usage: http://blog.sina.com.cn/ |
| - | for attr, v in ft_conf.items(): | + | |
| - | cmds.setAttr(mFt+' | + | |
| - | cmds.expression(s=" | + | ** Python web applications ** |
| - | </code> | + | * https:// |
| - | ===== math related===== | + | |
| + | * http:// | ||
| + | ====== | ||
| + | * Python GUI option list: http:// | ||
| + | * web platform: PyJamas | ||
| + | * desktop platform: QT, wxWidget | ||
| - | * sin and cost function <code python> | + | * GUI design: |
| - | # | + | * wxGlade: http:// |
| - | # aim vector to rotation value | + | * wxFormBuilder: |
| - | # | + | |
| - | # rotation | + | |
| - | aimDir=cmds.particle(pName, | + | |
| - | d=math.sqrt(aimDir[0]*aimDir[0]+aimDir[1]*aimDir[1]+aimDir[2]*aimDir[2]) | + | |
| - | rx=math.degrees(math.asin(aimDir[1]/ | + | |
| - | ry=0 | + | |
| - | if(aimDir[2]> | + | |
| - | | + | |
| - | elif(aimDir[2]==0): # check z=0 xy panel, which rotateX=+-90 condition -90 or 90 or 0 | + | |
| - | if(aimDir[0]> | + | |
| - | ry=90 | + | |
| - | elif(aimDir[0]< | + | |
| - | ry=-90 | + | |
| - | elif(aimDir[0]==0): | + | |
| - | ry=0 | + | |
| - | else: # for easy reading only | + | |
| - | ry=0 | + | |
| - | elif(aimDir[2]< | + | |
| - | if(aimDir[0]> | + | |
| - | ry=math.degrees(math.atan(aimDir[0]/ | + | |
| - | elif(aimDir[0]< | + | |
| - | ry=math.degrees(math.atan(aimDir[0]/aimDir[2]))-180 | + | |
| - | elif(aimDir[0]==0): | + | |
| - | ry=180 | + | |
| - | else: # for easy reading only | + | |
| - | ry=0 | + | |
| - | else: # for easy reading only | + | |
| - | ry=0 | + | |
| - | rz=0 | + | |
| - | cmds.xform(tGeo, | + | |
| - | </ | + | |
| - | ====== | + | ====== |
| - | * face track: | ||
| - | * http:// | ||
| - | * Sunday pipe and shaders: | ||
| - | * http:// | ||
| - | * http:// | ||
| - | * http:// | ||
| - | * http:// | ||
| - | * python code | + | ===== wxPython GUI concept quick guide ===== |
| - | * get clipboard: http:// | + | |
| - | * Blender shading: | + | * main build block |
| - | * https:// | + | * A Frame is a top-level window. |
| - | * https:// | + | |
| - | ====== Angle Calculation ====== | ||
| - | ===== Proof of cos(A+B) formula | + | ===== wxWidget - wxPython |
| - | * original reference: ([[http://www.ies.co.jp/ | + | * download: http://www.wxpython.org/download.php |
| + | * youtube video tutorial: | ||
| - | ===== Proof of rotation matrix ===== | ||
| - | * 2D rotation of an angle from (x,y) to (x1,y1) \\ {{graphic: | ||
| - | * Proof < | ||
| - | let A (x,y) to A1 (x1,y1) turns degree of a in respect of origin. | ||
| - | in Polar coordinate, | + | * basic wxPython widget syntax and codes <code python> |
| - | so, A (o,R), A1 (o1,R) | + | # get wxWidget frame work, |
| + | import wx | ||
| - | from A1, we have | + | # create class, since you are doing a App or a script |
| - | x1=R*cos(o1) | + | |
| - | y1=R*sin(o1) | + | |
| - | as o1=o+a, resulting o1 from turn o in a degree, we have | + | # inheriate |
| - | x1=R*cos(o1)=R*cos(o+a) | + | class myApp(wx.Frame): |
| - | y1=R*sin(o1)=R*sin(o+a) | + | # constructor, (so-called the initialize function) |
| + | def __init__(self,parent,id): | ||
| + | | ||
| + | panel=wx.Panel(self) | ||
| + | |||
| + | #bitmap button | ||
| + | pic=wx.Image(' | ||
| + | myBtn=wx.BitmapButton(panel, -1, pic, pos=(10, | ||
| + | self.Bind(wx.EVT_BUTTON, | ||
| + | myBtn.SetDefault() | ||
| + | |||
| + | #slider | ||
| + | slider=wx.Slider(panel, | ||
| + | slider.SetTickFreq(5, | ||
| + | |||
| + | # spinner | ||
| + | spinner=wx.SpinCtrl(panel, | ||
| + | spinner.SetRange(1, | ||
| + | spinner.SetValue(10) | ||
| + | |||
| + | # checkbox | ||
| + | wx.CheckBox(panel, | ||
| + | wx.CheckBox(panel, | ||
| + | wx.CheckBox(panel, | ||
| - | based on formula of cos(A+B)=cosA*cosB-sinA*sinB; | + | # combo box |
| - | x1=R*cos(o1)=R*cos(o+a)=R*cos(o)*cos(a)-R*sin(o)*sin(a) | + | mylist=[' |
| - | y1=R*sin(o1)=R*sin(o+a)=R*sin(o)*cos(a)+R*cos(o)*sin(a) | + | cbox=wx.ListBox(panel,-1,(300,1),(80,60), |
| + | | ||
| - | as in Polar coordinate, the R*cos(o) is actually x, R*sin(o) is actually y, so we have | + | # event handlers |
| - | x1=x*cos(a)-y*sin(a) | + | def btnAct(self,event): |
| - | y1=y*cos(a)+x*sin(a)=x*sin(a)+y*cos(a) | + | |
| - | in matrix form, it is same is the question above, Done. | + | if __name__==' |
| + | app=wx.PySimpleApp() # application obj | ||
| + | frame=myClass(parent=None,id=-1) # frame obj | ||
| + | frame.Show() # show frame | ||
| + | app.MainLoop() # start app | ||
| </ | </ | ||
| - | * thus in 3D space, we expand to have: \\ {{graphic:math_rotation_matrix.png|}} | + | * wxWidget binding for python tutorial: http://zetcode.com/ |
| - | ===== understand Matrix multiplication ===== | + | * 2 Panel App Flow |
| + | * http:// | ||
| - | * ref: http:// | + | ===== Common wxPython syntax ===== |
| - | ====== Vector calculation ====== | + | * prompts <code python> |
| + | #import wx.lib.agw.multidirdialog as MDD | ||
| + | import multidirdialog as MDD | ||
| + | def showMsg(msg): | ||
| + | wx.MessageBox(msg, | ||
| + | wx.OK | wx.ICON_INFORMATION) | ||
| - | * in Maya | + | import wx.lib.dialogs |
| - | | + | def showTxt(txt): |
| - | from maya.OpenMaya import MVector | + | |
| + | ask.ShowModal() | ||
| + | ask.Destroy() | ||
| - | # function: make selected points into a sphere/ | + | def getInput(): |
| + | tmpT="" | ||
| + | ask = wx.TextEntryDialog( | ||
| + | None, 'Your input:', | ||
| + | ' | ||
| + | if ask.ShowModal() == wx.ID_OK: | ||
| + | print " | ||
| + | tmpT = ask.GetValue() | ||
| + | ask.Destroy() | ||
| + | return tmpT | ||
| - | points=cmds.ls(sl=1, fl=1) | + | def getFolder(): |
| - | center=cmds.ls(sl=1)[0] | + | tmpPath="" |
| + | dialog | ||
| + | if dialog.ShowModal() | ||
| + | print ' | ||
| + | tmpPath | ||
| + | else: | ||
| + | print 'No directory.' | ||
| + | dialog.Destroy() | ||
| + | return tmpPath | ||
| - | pointVectors = [] | ||
| - | for pnt in points: | ||
| - | v = MVector(*cmds.pointPosition(pnt)) | ||
| - | pointVectors.append(v) | ||
| - | v_center | + | def getFolders(): |
| + | tmpPaths="" | ||
| + | ask = MDD.MultiDirDialog(None, title=" | ||
| + | if ask.ShowModal() == wx.ID_OK: | ||
| + | tmpPaths = ask.GetPaths() | ||
| + | print "You chose the following file(s):" | ||
| + | for path in tmpPaths: | ||
| + | print path | ||
| + | ask.Destroy() | ||
| + | return tmpPaths | ||
| - | pointDistances | + | def getFile(): |
| - | for v in pointVectors: | + | tmpPaths="" |
| - | | + | |
| + | | ||
| + | if ask.ShowModal() == wx.ID_OK: | ||
| + | tmpPaths = ask.GetPaths() | ||
| + | print " | ||
| + | for path in tmpPaths: | ||
| + | print path | ||
| + | ask.Destroy() | ||
| + | return tmpPaths | ||
| - | minRadius | + | def saveFile(): |
| + | tmpPaths="" | ||
| + | wildcard = " | ||
| + | ask = wx.FileDialog(None, | ||
| + | if ask.ShowModal() == wx.ID_OK: | ||
| + | tmpPath = ask.GetPath() | ||
| + | print "Save file:", | ||
| + | ask.Destroy() | ||
| + | return tmpPath | ||
| + | |||
| + | def getColor(): | ||
| + | ask = wx.ColourDialog(None) | ||
| + | ask.GetColourData().SetChooseFull(True) | ||
| + | if ask.ShowModal() == wx.ID_OK: | ||
| + | data = ask.GetColourData() | ||
| + | print 'You selected: %s\n' % str(data.GetColour().Get(includeAlpha=False)) | ||
| + | ask.Destroy() | ||
| + | return data.GetColour().Get(includeAlpha=False) | ||
| - | for pnt,v in zip(points, pointVectors): | + | def getChoice(): |
| - | | + | |
| - | | + | ask = wx.SingleChoiceDialog( |
| + | None, " | ||
| + | [" | ||
| + | wx.CHOICEDLG_STYLE | ||
| + | | ||
| + | if ask.ShowModal() == wx.ID_OK: | ||
| + | tmpC = ask.GetStringSelection() | ||
| + | print ' | ||
| + | | ||
| + | return tmpC | ||
| + | |||
| + | def getChoices(): | ||
| + | tmpCs=[] | ||
| + | list = [" | ||
| + | ask = wx.MultiChoiceDialog( None, | ||
| + | " | ||
| + | " | ||
| + | |||
| + | if (ask.ShowModal() == wx.ID_OK): | ||
| + | selections = ask.GetSelections() | ||
| + | strings = [list[x] for x in selections] | ||
| + | print "You chose:" | ||
| + | tmpCs = strings | ||
| + | ask.Destroy() | ||
| + | return tmpCs | ||
| + | |||
| + | application = wx.PySimpleApp() | ||
| </ | </ | ||
| - | ====== Plane Intersection calcuation ====== | + | * all dialog reference: |
| + | * http:// | ||
| + | * http:// | ||
| - | * 2 planes (represented by 2 vectors) intersection line | ||
| - | ====== Math tutorial links ====== | ||
| - | * 3D math for CG artists: | + | ====== PyQt ====== |
| - | * http:// | + | |
| - | * Shapes that tessellate | + | * check [[devwiki:python_qt|Qt and Python]] |
| - | * http:// | + | ====== Python Portable for Windows ====== |
| - | * math fun: http:// | + | * since all mac and linux have python built-in |
| - | ====== Local space and World space and Screen space ====== | + | |
| - | | + | **Workflow on portable python** |
| + | - Prepare python 2.7/3.5, by download the official python exe, and install it to D drive | ||
| + | * https:// | ||
| + | * for Python3.5.2: | ||
| + | * for Python2.7.12: | ||
| + | - update: for PyQt and PySide, just cd to that python directory and .\python.exe -m pip install PySide or PyQt4 to install that module with pip or ./python for mac/linux | ||
| + | - < | ||
| + | * < | ||
| + | * < | ||
| + | * < | ||
| + | - other library: | ||
| + | * cx_Freeze | ||
| - | ====== | + | ====== |
| - | * ref: http://around-the-corner.typepad.com/adn/2012/08/maya-fluid-shader.html | + | * Python 2.7 is built-in in Mac at /System/Library/ |
| + | * There are many articles on install latest python 2.7 and 3.x version with many methods, like homebrew and offical python site, while my idea is not touch any system path or system environment, | ||
| + | * the advantage is you choose which python to run the py script | ||
| + | * the disadvantage is you can't default python the_script.py in your command line, so you should always use a launch bash script to dynamically use which python path and open the script with it. | ||
| + | * check my App_V9.bat launch for windows: https:// | ||
| - | ====== 3D Camera model ====== | + | **Standard Install Python 3.8** |
| - | * camera model: http://around-the-corner.typepad.com/adn/2012/ | + | * download and install python3 installer |
| - | * stereoscopic camera: http:// | + | * download and install command line tools for xcode latest (use normal Apple acc to login) |
| + | * https://developer.apple.com/download/ | ||
| + | * install PySide2 (with user flag that fixes permission issue) <code bash> | ||
| + | * now python3 work in terminal app | ||
| + | * when first run, allow Access folder right. | ||
| + | * to make command extension file runable, do bash for the command extension launcher <code bash> | ||
| + | ====== Python Cool Tricks and Notes ====== | ||
| - | ====== VR rendering | + | * start HTML and FILE server |
| + | * decimal vs float for real life accounting usage: | ||
| + | * decimal wont have those float annoying issue with tons of 0s after . | ||
| + | * decimal deal number like human do instead of infinite computing accuracy | ||
| + | * https:// | ||
| + | * https:// | ||
| + | * < | ||
| - | * VR rendering from 3D package | ||
| - | * http:// | ||
| - | * http:// | ||
| - | * https:// | ||
| - | * https:// | ||
| - | * https:// | ||
| - | * https:// | ||
| - | * http:// | ||
| - | * http:// | ||
| - | * article | + | * python and whatsapp msg |
| - | * http://elevr.com/cg-vr-1/ | + | * ref: https://iq.opengenus.org/python-script-to-send-whatsapp-message/ |
| - | * http://elevr.com/cg-vr-2/ | + | * **pywhatkit**: |
| + | * because it use automation, so interaction with browser can be buggy, no quick repeat sending (since automate like human action, need wait response of other app update), send group chat may send to wrong group if you also interact with browser | ||
| + | * example< | ||
| + | import pywhatkit | ||
| + | pywhatkit.sendwhatmsg_instantly(" | ||
| + | # wait 10s to ui response, close tab true after 3s, | ||
| + | # you need to close tab as whatsapp web only allow 1 window active | ||
| + | </code> | ||
| + | * **selenium**: | ||
| + | * example setup and login manually for first time <code python> | ||
| + | my_drive = None | ||
| + | def drive_setup(): | ||
| + | from selenium import webdriver | ||
| + | from selenium.webdriver.common.keys import Keys | ||
| + | from selenium.webdriver.common.by import By | ||
| + | |||
| + | my_drive = webdriver.Chrome() | ||
| + | phone_no = " | ||
| + | my_drive.get(f' | ||
| - | * tool | + | def drive_msg(in_text): |
| - | * http://hawksley.github.io/eleVR-Picture-Player/ | + | from selenium.webdriver.common.by import By |
| + | if my_drive is None: | ||
| + | return | ||
| + | else: | ||
| + | chat_box = my_drive.find_element(by=By.XPATH, | ||
| + | chat_box.send_keys(in_text) | ||
| + | send_button = my_drive.find_element(by=By.CSS_SELECTOR, | ||
| + | send_button.click() | ||
| + | </ | ||
| + | |||
| + | ====== Python and interaction with other API ====== | ||
| + | |||
| + | Telegram | ||
| + | - search @BotFather on telegram | ||
| + | * manual: https://core.telegram.org/bots/api | ||
| + | | ||
| + | | ||
| + | - now search your bot " | ||
| + | - in python, use requests to get the chat from the bot, try one more time if no result <code python> | ||
| + | import requests | ||
| + | the_key = " | ||
| + | url = " | ||
| + | response = requests.get(url) | ||
| + | result = response.json() | ||
| + | print(result) | ||
| + | </ | ||
| + | - once you got result in json, you will find the chat id. <code python> | ||
| + | # the list of all chat spec your bot received, yours is likely the first one. | ||
| + | my_chat_info = result[' | ||
| + | my_msg_info = my_chat_info[0][' | ||
| + | # it got info of: chat, date, from, message_id, text | ||
| + | my_chat_id = my_msg_info[' | ||
| + | </ | ||
| + | - to send a text to that chat from your bot side <code python> | ||
| + | reply_text = 'hello world' | ||
| + | url = " | ||
| + | response = requests.get(url) | ||
| + | </ | ||
| + | - now, you should have got the reply from your bot <code python> | ||
| + | result = response.json() | ||
| + | send_state = result[' | ||
| + | send_result = result[' | ||
| + | # chat (first_name, | ||
| + | </code> | ||
| - | * case study: | ||
| - | * https:// | ||