sample mesh tool

import cPickle
import json

from PySide import QtCore, QtGui
import shiboken

import maya.cmds as cmds
import maya.OpenMaya as om
import maya.OpenMayaUI as omui

def getMainWindow():
    ptr = omui.MQtUtil.mainWindow()
    qObj = shiboken.wrapInstance(long(ptr), QtCore.QObject)
    metaObj = qObj.metaObject()
    cls = metaObj.className()
    superCls = metaObj.superClass().className()
    if hasattr(QtGui, cls):
        base = getattr(QtGui, cls)
    elif hasattr(QtGui, superCls):
        base = getattr(QtGui, superCls)
    else:
        base = QtGui.QWidget
    mainWin = shiboken.wrapInstance(long(ptr), base)
    return mainWin

class MeshObject(object):
    def __init__(self, obj=None, options=None):
        super(MeshObject, self).__init__()

        if obj is not None:
            self._parseObj(obj)
        elif options is not None:
            options = cPickle.loads(options)

    def data(self):
        return json.dumps(self.meshes)

    def create(self, name=None):
        if name is None:
            name = "mesh"
        transform = om.MFnTransform()
        transform = transform.create()
        transDepNode = om.MFnDependencyNode(transform)
        transDepNode.setName(name)
        for index, mesh in enumerate(self.meshes):
            numVertices = mesh["numVerts"]
            numPolygons = mesh["numPolys"]
            verts = om.MPointArray()
            for v in mesh["verts"]:
                verts.append(om.MPoint(v[0], v[1], v[2]))
            polygonCounts = om.MIntArray()
            for p in mesh["polyCounts"]:
                polygonCounts.append(p)
            polygonConnects = om.MIntArray()
            for p in mesh["polyConnects"]:
                polygonConnects.append(p)

            meshObj = om.MFnMesh()
            meshObj = meshObj.create(numVertices, numPolygons, verts,
                                     polygonCounts, polygonConnects, transform)
            meshDepNode = om.MFnDependencyNode(meshObj)

            normalsArr = om.MVectorArray()
            faceArr = om.MIntArray()
            vertArr = om.MIntArray()
            for n in mesh["normals"]:
                normalsArr.append(om.MVector(n[0], n[1], n[2]))
            for face, count in enumerate(mesh["polyCounts"]):
                for i in range(count):
                    faceArr.append(face)
            for vert in mesh["polyConnects"]:
                vertArr.append(vert)
            meshObj.setFaceVertexNormals(normalsArr, faceArr, vertArr)

    def _parseObj(self, objToParse):
        sel = om.MSelectionList()
        sel.add(objToParse)
        obj = om.MObject()
        path = om.MDagPath()
        sel.getDagPath(0, path, obj)
        if path.hasFn(om.MFn.kTransform):
            transform = om.MFnTransform(path)
            node = om.MFnDagNode(path)
            if node.childCount() > 0:
                shapes = []
                for index in range(node.childCount()):
                    childObj = node.child(index)
                    if childObj.hasFn(om.MFn.kMesh):
                        shapes.append(om.MFnMesh(childObj))
                if len(shapes) != 0:
                    self.meshes = []
                    for shape in shapes:
                        meshInfo = {}
                        meshInfo["numVerts"] = shape.numVertices()
                        meshInfo["numPolys"] = shape.numPolygons()
                        meshInfo["verts"] = []
                        v = om.MPoint()
                        for vIndex in range(shape.numVertices()):
                            shape.getPoint(vIndex, v)
                            meshInfo["verts"].append((v.x, v.y, v.z))

                        meshInfo["polyCounts"] = []
                        meshInfo["polyConnects"] = []
                        connectedVertsArr = om.MIntArray();
                        for pIndex in range(shape.numPolygons()):
                            meshInfo["polyCounts"].append(shape.polygonVertexCount(pIndex))
                            shape.getPolygonVertices(pIndex, connectedVertsArr)
                            for vIndex in range(connectedVertsArr.length()):
                                meshInfo["polyConnects"].append(int(connectedVertsArr[vIndex]))

                        meshInfo["normals"] = []
                        normalsArr = om.MFloatVectorArray()
                        shape.getNormals(normalsArr)
                        for nIndex in range(normalsArr.length()):
                            normal = normalsArr[nIndex]
                            meshInfo["normals"].append((normal.x, normal.y, normal.z))

                        self.meshes.append(meshInfo)
                else:
                    om.MGlobal.displayError("{0} has no valid meshes attached".format(path.fullPathName))
            else:
                om.MGlobal.displayError("{0} has no child nodes.".format(path.fullPathName()))
        else:
            om.MGlobal.displayError("{0} is not a transform.".format(path.fullPathName()))

    def __repr__(self):
        pass

    def __str__(self):
        values = []
        values.append("Mesh Object:\n")
        values.append("    Meshes:\n")
        for index, mesh in enumerate(self.meshes):
            values.append("        Mesh {0}:\n".format(index))
            values.append("            Number of Verts: {0}\n".format(mesh["numVerts"]))
            values.append("            Number of Polys: {0}\n".format(mesh["numPolys"]))
            values.append("            Verts:\n")
            for v in mesh["verts"]:
                values.append("                {0}\n".format(v))
            values.append("            Poly Counts:\n")
            for i, p in enumerate(mesh["polyCounts"]):
                values.append("                {0}: {1}\n".format(i, p))
            values.append("            Poly Connects:\n")
            for i, p in enumerate(mesh["polyConnects"]):
                values.append("                {0}: {1}\n".format(i, p))
            values.append("            Normals:\n")
            for i, n in enumerate(mesh["normals"]):
                values.append("                {0}: {1}\n".format(i, n))

        return ''.join([val for val in values])

class MeshUI(QtGui.QMainWindow):
    def __init__(self, parent=None):
        super(MeshUI, self).__init__(parent)
        self.setWindowTitle("Mesh Tool")

        widget = QtGui.QWidget()
        layout = QtGui.QVBoxLayout()

        button = QtGui.QPushButton("Get Mesh Info")
        button.clicked.connect(self.getInfo)
        layout.addWidget(button)

        widget.setLayout(layout)
        self.setCentralWidget(widget)
        self.show()

    def getInfo(self):
        objs = cmds.ls(selection=True, type="transform")
        if len(objs) > 0:
            for obj in objs:
                cObj = MeshObject(obj)
                print str(cObj)
                cObj.create()
        else:
            cmds.warning("Please select one or more root objects")

if __name__ == '__main__':
    MeshUI(getMainWindow())