From 65ed5cf1a6efafe0104d36bcd045760bc582d4ec Mon Sep 17 00:00:00 2001 From: Jcen <172036972@qq.com> Date: Tue, 1 Oct 2024 19:54:21 +0800 Subject: [PATCH] Initial commit --- .gitignore | 164 +----- README.md | 15 +- __init__.py | 0 checker.py | 1295 +++++++++++++++++++++++++++++++++++++++++ framelayout.py | 114 ++++ icon.py | 34 ++ images/ui.png | Bin 0 -> 71527 bytes modelSanityChecker.py | 456 +++++++++++++++ 8 files changed, 1915 insertions(+), 163 deletions(-) create mode 100644 __init__.py create mode 100644 checker.py create mode 100644 framelayout.py create mode 100644 icon.py create mode 100644 images/ui.png create mode 100644 modelSanityChecker.py diff --git a/.gitignore b/.gitignore index 5d381cc..0d6f624 100644 --- a/.gitignore +++ b/.gitignore @@ -1,162 +1,2 @@ -# ---> Python -# Byte-compiled / optimized / DLL files -__pycache__/ -*.py[cod] -*$py.class - -# C extensions -*.so - -# Distribution / packaging -.Python -build/ -develop-eggs/ -dist/ -downloads/ -eggs/ -.eggs/ -lib/ -lib64/ -parts/ -sdist/ -var/ -wheels/ -share/python-wheels/ -*.egg-info/ -.installed.cfg -*.egg -MANIFEST - -# PyInstaller -# Usually these files are written by a python script from a template -# before PyInstaller builds the exe, so as to inject date/other infos into it. -*.manifest -*.spec - -# Installer logs -pip-log.txt -pip-delete-this-directory.txt - -# Unit test / coverage reports -htmlcov/ -.tox/ -.nox/ -.coverage -.coverage.* -.cache -nosetests.xml -coverage.xml -*.cover -*.py,cover -.hypothesis/ -.pytest_cache/ -cover/ - -# Translations -*.mo -*.pot - -# Django stuff: -*.log -local_settings.py -db.sqlite3 -db.sqlite3-journal - -# Flask stuff: -instance/ -.webassets-cache - -# Scrapy stuff: -.scrapy - -# Sphinx documentation -docs/_build/ - -# PyBuilder -.pybuilder/ -target/ - -# Jupyter Notebook -.ipynb_checkpoints - -# IPython -profile_default/ -ipython_config.py - -# pyenv -# For a library or package, you might want to ignore these files since the code is -# intended to run in multiple environments; otherwise, check them in: -# .python-version - -# pipenv -# According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control. -# However, in case of collaboration, if having platform-specific dependencies or dependencies -# having no cross-platform support, pipenv may install dependencies that don't work, or not -# install all needed dependencies. -#Pipfile.lock - -# poetry -# Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control. -# This is especially recommended for binary packages to ensure reproducibility, and is more -# commonly ignored for libraries. -# https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control -#poetry.lock - -# pdm -# Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control. -#pdm.lock -# pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it -# in version control. -# https://pdm.fming.dev/#use-with-ide -.pdm.toml - -# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm -__pypackages__/ - -# Celery stuff -celerybeat-schedule -celerybeat.pid - -# SageMath parsed files -*.sage.py - -# Environments -.env -.venv -env/ -venv/ -ENV/ -env.bak/ -venv.bak/ - -# Spyder project settings -.spyderproject -.spyproject - -# Rope project settings -.ropeproject - -# mkdocs documentation -/site - -# mypy -.mypy_cache/ -.dmypy.json -dmypy.json - -# Pyre type checker -.pyre/ - -# pytype static type analyzer -.pytype/ - -# Cython debug symbols -cython_debug/ - -# PyCharm -# JetBrains specific template is maintained in a separate JetBrains.gitignore that can -# be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore -# and can be added to the global gitignore or merged into this file. For a more nuclear -# option (not recommended) you can uncomment the following to ignore the entire idea folder. -#.idea/ - +*.un~ +*.pyc diff --git a/README.md b/README.md index 2db875f..41c8276 100644 --- a/README.md +++ b/README.md @@ -1,2 +1,15 @@ -# ModelCheckerForMaya +# Model Checker (WIP) +![img](./images/ui.png) + +## Requirements + +[CheckTools plugins](https://github.com/minoue/CheckTools) + +## Usage + +python +``` +from ModelCheckerForMaya import modelSanityChecker +modelSanityChecker.main() +``` diff --git a/__init__.py b/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/checker.py b/checker.py new file mode 100644 index 0000000..dcf724d --- /dev/null +++ b/checker.py @@ -0,0 +1,1295 @@ +""" +Checker classes +""" + +import re + +from abc import ABCMeta, abstractmethod +from maya import cmds +from maya.api import OpenMaya +from PySide2 import QtWidgets + + +if not cmds.pluginInfo("meshChecker", q=True, loaded=True): + try: + cmds.loadPlugin("meshChecker") + except RuntimeError: + cmds.warning("Failed to load meshChecker plugin") + +if not cmds.pluginInfo("uvChecker", q=True, loaded=True): + try: + cmds.loadPlugin("uvChecker") + except RuntimeError: + cmds.warning("Failed to load uvChecker plugin") + +if not cmds.pluginInfo("findUvOverlaps", q=True, loaded=True): + try: + cmds.loadPlugin("findUvOverlaps") + except RuntimeError: + cmds.warning("Failed to load uvOverlap checker plugin") + + +class Error(QtWidgets.QListWidgetItem): + """ Custom error object """ + + def __init__(self, fullPath, errors=None, parent=None): + # type: (str, list) -> (None) + super(Error, self).__init__(parent) + self.components = errors + self.longName = fullPath + self.shortName = fullPath.split("|")[-1] + + self.setText(self.shortName) + + +class BaseChecker: + """ Base abstract class for each checker """ + + __metaclass__ = ABCMeta + __category__ = "" + __name__ = "" + isWarning = False + isEnabled = True + isFixable = False + + def __init__(self): + + self.errors = [] + + def __eq__(self, other): + return self.name == self.name + + def __ne__(self, other): + return not (self == other) + + def __lt__(self, other): + return (self.category < other.category) + + @abstractmethod + def checkIt(self, objs, settings=None): + """ Check method """ + + pass + + @abstractmethod + def fixIt(self): + """ Fix method """ + + pass + + @property + def name(self): + """ Label property """ + + return self.__name__ + + @property + def category(self): + return self.__category__ + + +class TriangleChecker(BaseChecker): + """ Triangle checker class """ + + __name__ = "Triangles" + __category__ = "Topology" + isWarning = True + + def checkIt(self, obj, settings=None): + # type: (list) -> (list) + + errorsDict = {} + self.errors = [] + + errs = cmds.checkMesh(obj, c=0) + + for e in errs: + base, comp = e.split(".") + + if base in errorsDict: + errorsDict[base].append(e) + else: + errorsDict[base] = [e] + + for err_key in errorsDict: + components = errorsDict[err_key] + errorObj = Error(err_key, errorsDict[err_key]) + self.errors.append(errorObj) + + return self.errors + + def fixIt(self): + pass + + +class NgonChecker(BaseChecker): + + __name__ = "N-gons" + __category__ = "Topology" + + def checkIt(self, obj, settings=None): + # type: (list) -> (list) + + errorsDict = {} + self.errors = [] + + errs = cmds.checkMesh(obj, c=1) + + for e in errs: + base, comp = e.split(".") + + if base in errorsDict: + errorsDict[base].append(e) + else: + errorsDict[base] = [e] + + for err_key in errorsDict: + components = errorsDict[err_key] + errorObj = Error(err_key, errorsDict[err_key]) + self.errors.append(errorObj) + + return self.errors + + def fixIt(self): + pass + + +class NonmanifoldEdgeChecker(BaseChecker): + + __name__ = "Nonmanifold Edges" + __category__ = "Topology" + + def checkIt(self, obj, settings=None): + # type: (list) -> (list) + + errorsDict = {} + self.errors = [] + + errs = cmds.checkMesh(obj, c=2) + + for e in errs: + base, comp = e.split(".") + + if base in errorsDict: + errorsDict[base].append(e) + else: + errorsDict[base] = [e] + + for err_key in errorsDict: + components = errorsDict[err_key] + errorObj = Error(err_key, errorsDict[err_key]) + self.errors.append(errorObj) + + return self.errors + + def fixIt(self): + pass + + +class NonmanifoldVertexChecker(BaseChecker): + + __name__ = "Nonmanifold Vertices" + __category__ = "Topology" + + def checkIt(self, obj, settings=None): + # type: (list) -> (list) + + self.errors = [] + + children = cmds.listRelatives(obj, fullPath=True, ad=True, type="mesh") + + for obj in children: + try: + errs = cmds.polyInfo(obj, nmv=True) + if errs: + errorObj = Error(obj, errs) + self.errors.append(errorObj) + except RuntimeError: + pass + + return self.errors + + def fixIt(self): + pass + + +class LaminaFaceChecker(BaseChecker): + + __name__ = "Lamina Faces" + __category__ = "Topology" + + def checkIt(self, obj, settings=None): + # type: (list) -> (list) + + errorsDict = {} + self.errors = [] + + errs = cmds.checkMesh(obj, c=3) + + for e in errs: + base, comp = e.split(".") + + if base in errorsDict: + errorsDict[base].append(e) + else: + errorsDict[base] = [e] + + for err_key in errorsDict: + components = errorsDict[err_key] + errorObj = Error(err_key, errorsDict[err_key]) + self.errors.append(errorObj) + + return self.errors + + def fixIt(self): + pass + + +class BiValentFaceChecker(BaseChecker): + + __name__ = "Bi-valent Faces" + __category__ = "Topology" + + def checkIt(self, obj, settings=None): + # type: (list) -> (list) + + errorsDict = {} + self.errors = [] + + errs = cmds.checkMesh(obj, c=4) + + for e in errs: + base, comp = e.split(".") + + if base in errorsDict: + errorsDict[base].append(e) + else: + errorsDict[base] = [e] + + for err_key in errorsDict: + components = errorsDict[err_key] + errorObj = Error(err_key, errorsDict[err_key]) + self.errors.append(errorObj) + + return self.errors + + def fixIt(self): + pass + + +class ZeroAreaFaceChecker(BaseChecker): + + __name__ = "Zero Area Faces" + __category__ = "Topology" + + def checkIt(self, obj, settings): + # type: (list) -> (list) + + mfa = settings.getSettings()['maxFaceArea'] + + errorsDict = {} + self.errors = [] + + errs = cmds.checkMesh(obj, c=5, maxFaceArea=mfa) + + for e in errs: + base, comp = e.split(".") + + if base in errorsDict: + errorsDict[base].append(e) + else: + errorsDict[base] = [e] + + for err_key in errorsDict: + components = errorsDict[err_key] + errorObj = Error(err_key, errorsDict[err_key]) + self.errors.append(errorObj) + + return self.errors + + def fixIt(self): + pass + + +class MeshBorderEdgeChecker(BaseChecker): + + __name__ = "Mesh Border Edges" + isWarning = True + __category__ = "Topology" + + def checkIt(self, obj, settings=None): + # type: (list) -> (list) + + errorsDict = {} + self.errors = [] + + errs = cmds.checkMesh(obj, c=6) + + for e in errs: + base, comp = e.split(".") + + if base in errorsDict: + errorsDict[base].append(e) + else: + errorsDict[base] = [e] + + for err_key in errorsDict: + components = errorsDict[err_key] + errorObj = Error(err_key, errorsDict[err_key]) + self.errors.append(errorObj) + + return self.errors + + def fixIt(self): + pass + + +class CreaseEdgeChecker(BaseChecker): + + __name__ = "Crease Edges" + __category__ = "Topology" + + def checkIt(self, obj, settings=None): + # type: (list) -> (list) + + errorsDict = {} + self.errors = [] + + errs = cmds.checkMesh(obj, c=7) + + for e in errs: + base, comp = e.split(".") + + if base in errorsDict: + errorsDict[base].append(e) + else: + errorsDict[base] = [e] + + for err_key in errorsDict: + components = errorsDict[err_key] + errorObj = Error(err_key, errorsDict[err_key]) + self.errors.append(errorObj) + + return self.errors + + def fixIt(self): + pass + + +class ZeroLengthEdgeChecker(BaseChecker): + + __name__ = "Zero-length Edges" + __category__ = "Topology" + + def checkIt(self, obj, settings=None): + # type: (list) -> (list) + + errorsDict = {} + self.errors = [] + + errs = cmds.checkMesh(obj, c=8) + + for e in errs: + base, comp = e.split(".") + + if base in errorsDict: + errorsDict[base].append(e) + else: + errorsDict[base] = [e] + + for err_key in errorsDict: + components = errorsDict[err_key] + errorObj = Error(err_key, errorsDict[err_key]) + self.errors.append(errorObj) + + return self.errors + + def fixIt(self): + pass + + +class VertexPntsChecker(BaseChecker): + + __name__ = "Vertex Pnts Attribute" + __category__ = "Attribute" + isFixable = True + + def checkIt(self, obj, settings=None): + # type: (list) -> (list) + + self.errors = [] + + errs = cmds.checkMesh(obj, c=9) + + for e in errs: + errObj = Error(e) + self.errors.append(errObj) + + return self.errors + + def fixIt(self): + mSel = OpenMaya.MSelectionList() + for n, e in enumerate(self.errors): + if cmds.objExists(e.longName): + obj = e.longName + mSel.add(obj) + try: + cmds.polyMoveVertex( + obj, lt=(0, 0, 0), nodeState=1, ch=False) + except RuntimeError: + pass + +class EmptyGeometryChecker(BaseChecker): + + __name__ = "Empty Geometry" + __category__ = "Topology" + isFixable = False + + def checkIt(self, obj, settings=None): + # type: (list) -> (list) + + self.errors = [] + + errs = cmds.checkMesh(obj, c=10) + + for e in errs: + errObj = Error(e) + self.errors.append(errObj) + + return self.errors + + def fixIt(self): + pass + + +class NameChecker(BaseChecker): + + __name__ = "Name" + __category__ = "Name" + isEnabled = False + + def checkIt(self, objs, settings=None): + # type: (list) -> (list) + + self.errors = [] + + for obj in objs: + try: + pass + except RuntimeError: + pass + + return self.errors + + def fixIt(self): + pass + + +class ShapeNameChecker(BaseChecker): + + __name__ = "ShapeName" + __category__ = "Name" + isFixable = True + + def checkIt(self, root, settings=None): + # type: (list) -> (list) + + self.errors = [] + + objs = cmds.listRelatives(root, ad=True, fullPath=True, type="transform") or [] + objs.insert(0, root) + + for obj in objs: + shapes = cmds.listRelatives( + obj, children=True, fullPath=True, shapes=True) or [] + if shapes: + for shape in shapes: + isIntermediate = cmds.getAttr( + shape + ".intermediateObject") + if isIntermediate: + continue + shortName = obj.split("|")[-1] + shapeShortName = shape.split("|")[-1] + + if shortName + "Shape" != shapeShortName: + err = Error(shape) + self.errors.append(err) + + return self.errors + + def fixIt(self): + for e in self.errors: + shape = e.longName + parent = cmds.listRelatives(shape, parent=True, fullPath=False)[0] + newShapeName = parent + "Shape" + cmds.rename(shape, newShapeName) + + +class HistoryChecker(BaseChecker): + + __name__ = "History" + __category__ = "Node" + isEnabled = True + isFixable = True + + def checkIt(self, root, settings=None): + # type: (list) -> (list) + + self.errors = [] + + objs = cmds.listRelatives(root, ad=True, fullPath=True, type="transform") or [] + objs.insert(0, root) + + for obj in objs: + mesh = cmds.listRelatives(obj, children=True, type="mesh") + if mesh is not None: + for m in mesh: + inMesh = cmds.listConnections(m + ".inMesh", source=True) + if inMesh is not None: + err = Error(obj) + self.errors.append(err) + + return self.errors + + def fixIt(self): + + for e in self.errors: + cmds.delete(e.longName, ch=True) + + +class TransformChecker(BaseChecker): + + __name__ = "Transform" + __category__ = "Attribute" + + def checkIt(self, root, settings=None): + # type: (list) -> (list) + + ignore = [] + + self.errors = [] + + identity = OpenMaya.MMatrix.kIdentity + mSel = OpenMaya.MSelectionList() + + objs = cmds.listRelatives(root, ad=True, fullPath=True, type="transform") or [] + objs.insert(0, root) + + for n, i in enumerate(objs): + mSel.add(i) + dagPath = mSel.getDagPath(n) + groupName = dagPath.fullPathName().split("|")[-1] + if groupName in ignore: + continue + dagNode = OpenMaya.MFnDagNode(dagPath) + transform = dagNode.transformationMatrix() + if not transform == identity: + errorObj = Error(i) + self.errors.append(errorObj) + + return self.errors + + def fixIt(self): + pass + + +class LockedTransformChecker(BaseChecker): + + __name__ = "Locked Transform" + __category__ = "Attribute" + isFixable = True + + def __init__(self): + super(LockedTransformChecker, self).__init__() + self.attrs = ["tx", "ty", "tz", "rx", "ry", "rz", "sx", "sy", "sz"] + + def checkIt(self, root, settings=None): + # type: (list) -> (list) + + self.errors = [] + + objs = cmds.listRelatives(root, ad=True, fullPath=True, type="transform") or [] + objs.insert(0, root) + + for obj in objs: + try: + for at in self.attrs: + isLocked = cmds.getAttr(obj + ".{}".format(at), lock=True) + if isLocked: + err = Error(obj) + self.errors.append(err) + break + except RuntimeError: + pass + + return self.errors + + def fixIt(self): + for e in self.errors: + for at in self.attrs: + cmds.setAttr(e.longName + ".{}".format(at), lock=False) + + +class SmoothPreviewChecker(BaseChecker): + + __name__ = "Smooth Preview" + __category__ = "Attribute" + isFixable = True + + def checkIt(self, root, settings=None): + # type: (list) -> (list) + + self.errors = [] + + meshes = cmds.listRelatives(root, ad=True, fullPath=True, type="mesh") or [] + + for mesh in meshes: + isSmooth = cmds.getAttr(mesh + ".displaySmoothMesh") + + if isSmooth: + err = Error(mesh) + self.errors.append(err) + + return self.errors + + def fixIt(self): + + for e in self.errors: + cmds.setAttr(e.longName + ".displaySmoothMesh", 0) + + +class KeyframeChecker(BaseChecker): + + __name__ = "Keyframe" + __category__ = "Attribute" + isFixable = True + + def checkIt(self, root, settings=None): + # type: (list) -> (list) + + self.errors = [] + + keyNodes = ["animCurveTU", "animCurveTA", "animCurveTL"] + + objs = cmds.listRelatives(root, ad=True, fullPath=True, type="transform") or [] + objs.insert(0, root) + + for i in objs: + conns = cmds.listConnections(i, source=True) + keys = [] + + if conns is None: + continue + + for c in conns: + if cmds.objectType(c) in keyNodes: + keys.append(c) + if keys: + err = Error(i, keys) + self.errors.append(err) + + return self.errors + + def fixIt(self): + + for e in self.errors: + cmds.delete(e.components) + + +class UnusedVertexChecker(BaseChecker): + """ Unused vertex checker class """ + + __name__ = "Unused Vertices" + __category__ = "Topology" + + def __init__(self): + super(UnusedVertexChecker, self).__init__() + + def checkIt(self, obj, settings=None): + # type: (list) -> (list) + + errorsDict = {} + self.errors = [] + + errs = cmds.checkMesh(obj, c=11) + + for e in errs: + base, comp = e.split(".") + + if base in errorsDict: + errorsDict[base].append(e) + else: + errorsDict[base] = [e] + + for err_key in errorsDict: + components = errorsDict[err_key] + errorObj = Error(err_key, errorsDict[err_key]) + self.errors.append(errorObj) + + return self.errors + + def fixIt(self): + """ Unused vertices ARE fixable """ + + pass + + +class IntermediateObjectChecker(BaseChecker): + + __name__ = "Intermediate Object" + __category__ = "Node" + isFixable = True + + def checkIt(self, root, settings=None): + # type: (list) -> (list) + + self.errors = [] + + meshes = cmds.listRelatives(root, ad=True, fullPath=True, type="mesh") + + for mesh in meshes: + isIntermediate = cmds.getAttr(mesh + ".intermediateObject") + if isIntermediate: + err = Error(mesh) + self.errors.append(err) + + return self.errors + + def fixIt(self): + for e in self.errors: + shape = e.longName + + if cmds.objExists(shape): + parents = cmds.listRelatives( + shape, fullPath=True, parent=True) or [] + for i in parents: + # Delete history for parents + cmds.delete(i, ch=True) + try: + cmds.delete(shape) + except ValueError: + pass + + +class InstanceShapeChecker(BaseChecker): + + __name__ = "Instance Shape" + __category__ = "Node" + + def checkIt(self, obj, settings=None): + # type: (list) -> (list) + + self.errors = [] + + errs = cmds.checkMesh(obj, c=12) + + for e in errs: + errObj = Error(e) + self.errors.append(errObj) + + return self.errors + + def fixIt(self): + pass + + +class ConnectionChecker(BaseChecker): + + __name__ = "Connections" + __category__ = "Node" + + def checkIt(self, obj, settings=None): + # type: (list) -> (list) + + self.errors = [] + + errs = cmds.checkMesh(obj, c=13) + + for e in errs: + errObj = Error(e) + self.errors.append(errObj) + + return self.errors + + def fixIt(self): + pass + + +class DisplayLayerCheck(BaseChecker): + + __name__ = "Display layers" + __category__ = "other" + isFixable = True + + def checkIt(self, root, settings=None): + # type: (list) -> (list) + + self.errors = [] + + objs = cmds.listRelatives(root, ad=True, fullPath=True, type="transform") or [] + objs.insert(0, root) + + for obj in objs: + layers = cmds.listConnections(obj + ".drawOverride") or [] + if layers: + err = Error(obj, layers) + self.errors.append(err) + + return self.errors + + def fixIt(self): + + for e in self.errors: + layers = e.components + node = e.longName + for layer in layers: + cmds.disconnectAttr( + layer + ".drawInfo", node + ".drawOverride") + + +class UnusedLayerChecker(BaseChecker): + + __name__ = "Unused layers" + __category__ = "other" + isFixable = True + + def checkIt(self, root, settings=None): + # type: (list) -> (list) + + self.errors = [] + + layers = cmds.ls(type="displayLayer") + layers.remove("defaultLayer") + for layer in layers: + contents = cmds.editDisplayLayerMembers( + layer, q=True, fullNames=True) + if contents is None: + err = Error(layer, [layer]) + self.errors.append(err) + + return self.errors + + def fixIt(self): + for e in self.errors: + try: + cmds.delete(e.longName) + except RuntimeError: + pass + + +class Map1Checker(BaseChecker): + + __name__ = "UVSet to map1" + __category__ = "UV" + isFixable = True + + def checkIt(self, root, settings=None): + # type: (list) -> (list) + + self.errors = [] + + meshes = cmds.listRelatives(root, ad=True, fullPath=True, type="mesh") or [] + + for mesh in meshes: + curUVSet = cmds.polyUVSet(mesh, q=True, currentUVSet=True)[0] + if curUVSet != "map1": + err = Error(mesh) + self.errors.append(err) + + return self.errors + + def fixIt(self): + + for e in self.errors: + cmds.polyUVSet(e.longName, uvSet="map1", currentUVSet=True) + + +class NegativeUvChecker(BaseChecker): + + __name__ = "UVs in negative space" + __category__ = "UV" + + def checkIt(self, obj, settings=None): + + self.errors = [] + errorsDict = {} + + errs = cmds.checkUV(obj, c=4) + + for e in errs: + base, comp = e.split(".") + + if base in errorsDict: + errorsDict[base].append(e) + else: + errorsDict[base] = [e] + + for err_key in errorsDict: + components = errorsDict[err_key] + errorObj = Error(err_key, errorsDict[err_key]) + self.errors.append(errorObj) + + return self.errors + + def fixIt(self): + pass + + +class UdimIntersectionChecker(BaseChecker): + + __name__ = "UDIM intersection" + __category__ = "UV" + + def checkIt(self, obj, settings=None): + # type: (list) -> (list) + + self.errors = [] + + errorsDict = {} + + errs = cmds.checkUV(obj, c=0) + + for e in errs: + base, comp = e.split(".") + + if base in errorsDict: + errorsDict[base].append(e) + else: + errorsDict[base] = [e] + + for err_key in errorsDict: + components = errorsDict[err_key] + errorObj = Error(err_key, errorsDict[err_key]) + self.errors.append(errorObj) + + return self.errors + + def fixIt(self): + pass + + +class UnassignedUvChecker(BaseChecker): + + __name__ = "Unassigned UVs" + __category__ = "UV" + + def checkIt(self, obj, settings=None): + # type: (list) -> (list) + + self.errors = [] + + errorsDict = {} + + errs = cmds.checkUV(obj, c=3) + + for e in errs: + base, comp = e.split(".") + + if base in errorsDict: + errorsDict[base].append(e) + else: + errorsDict[base] = [e] + + for err_key in errorsDict: + components = errorsDict[err_key] + errorObj = Error(err_key, errorsDict[err_key]) + self.errors.append(errorObj) + + return self.errors + + def fixIt(self): + pass + + +class UnmappedPolygonFaceChecker(BaseChecker): + + __name__ = "Unmapped polygon faces" + __category__ = "UV" + + def checkIt(self, obj, settings=None): + # type: (list) -> (list) + + self.errors = [] + + errorsDict = {} + + errs = cmds.checkUV(obj, c=1) + + for e in errs: + base, comp = e.split(".") + + if base in errorsDict: + errorsDict[base].append(e) + else: + errorsDict[base] = [e] + + for err_key in errorsDict: + components = errorsDict[err_key] + errorObj = Error(err_key, errorsDict[err_key]) + self.errors.append(errorObj) + + return self.errors + + def fixIt(self): + pass + + +class ZeroAreaUVFaceChecker(BaseChecker): + + __name__ = "Zero area UV Faces" + __category__ = "UV" + + def checkIt(self, obj, settings=None): + # type: (list) -> (list) + + self.errors = [] + errorsDict = {} + + errs = cmds.checkUV(obj, c=2) + + for e in errs: + base, comp = e.split(".") + + if base in errorsDict: + errorsDict[base].append(e) + else: + errorsDict[base] = [e] + + for err_key in errorsDict: + components = errorsDict[err_key] + errorObj = Error(err_key, errorsDict[err_key]) + self.errors.append(errorObj) + + return self.errors + + def fixIt(self): + pass + + +class ConcaveUVChecker(BaseChecker): + + __name__ = "Concave UV Faces" + __category__ = "UV" + + def checkIt(self, obj, settings=None): + # type: (list) -> (list) + + self.errors = [] + errorsDict = {} + + errs = cmds.checkUV(obj, c=5) + + for e in errs: + base, comp = e.split(".") + + if base in errorsDict: + errorsDict[base].append(e) + else: + errorsDict[base] = [e] + + for err_key in errorsDict: + components = errorsDict[err_key] + errorObj = Error(err_key, errorsDict[err_key]) + self.errors.append(errorObj) + + return self.errors + + def fixIt(self): + pass + + +class ReversedUVChecker(BaseChecker): + + __name__ = "Reversed UV Faces" + __category__ = "UV" + isWarning = True + + def checkIt(self, obj, settings=None): + # type: (list) -> (list) + + self.errors = [] + errorsDict = {} + + errs = cmds.checkUV(obj, c=6) + + for e in errs: + base, comp = e.split(".") + + if base in errorsDict: + errorsDict[base].append(e) + else: + errorsDict[base] = [e] + + for err_key in errorsDict: + components = errorsDict[err_key] + errorObj = Error(err_key, errorsDict[err_key]) + self.errors.append(errorObj) + + return self.errors + + def fixIt(self): + pass + + +class UvOverlapChecker(BaseChecker): + + __name__ = "UV Overlaps" + __category__ = "UV" + isEnabled = False + + def checkIt(self, root, settings=None): + + self.errors = [] + + objs = cmds.listRelatives(root, ad=True, fullPath=True, type="mesh") or [] + + mSel = OpenMaya.MSelectionList() + + for obj in objs: + mSel.add(obj) + + for i in range(mSel.length()): + dagPath = mSel.getDagPath(i) + try: + dagPath.extendToShape() + + except RuntimeError: + # Not mesh. Do no nothing + pass + + return self.errors + + def fixIt(self): + pass + + +class SelectionSetChecker(BaseChecker): + + __name__ = "Selection Sets" + __category__ = "other" + isFixable = True + + def getSets(self, path, typ): + + if typ == "transform": + conns = cmds.listConnections(path + ".instObjGroups") or [] + return [i for i in conns if cmds.objectType(i) == "objectSet"] + elif typ == "shape": + conns = cmds.listConnections( + path + ".instObjGroups.objectGroups") or [] + return [i for i in conns if cmds.objectType(i) == "objectSet"] + else: + pass + + return [] + + def checkIt(self, root, settings=None): + # type: (list) -> (list) + + self.errors = [] + objectSets = [] + ignore = ["modelPanel[0-9]ViewSelectedSet"] + + objs = cmds.listRelatives(root, ad=True, fullPath=True, type="transform") or [] + objs.insert(0, root) + + for obj in objs: + shapes = cmds.listRelatives( + obj, children=True, fullPath=True, shapes=True) or [] + + for shape in shapes: + objectSets.extend(self.getSets(shape, "shape")) + + objectSets.extend(self.getSets(obj, "transform")) + + objectSets = list(set(objectSets)) + + for objSet in objectSets: + for i in ignore: + if re.match(i, objSet) is None: + err = Error(objSet) + self.errors.append(err) + + return self.errors + + def fixIt(self): + for e in self.errors: + try: + cmds.delete(e.longName) + except Exception: + pass + + +class ColorSetChecker(BaseChecker): + + __name__ = "Color Sets" + __category__ = "other" + isFixable = True + + def checkIt(self, root, settings=None): + # type: (list) -> (list) + + # Reset result + self.errors = [] + + objs = cmds.listRelatives(root, ad=True, fullPath=True, type="mesh") or [] + + for obj in objs: + try: + allColorSets = cmds.polyColorSet( + obj, q=True, allColorSets=True) + if allColorSets is None: + continue + else: + err = Error(obj) + self.errors.append(err) + except RuntimeError: + pass + + return self.errors + + def fixIt(self): + for i in self.errors: + allSets = cmds.polyColorSet( + i.longName, q=True, allColorSets=True) or [] + for s in allSets: + cmds.polyColorSet(i.longName, delete=True, colorSet=s) + + +CHECKERS = [ + NameChecker, + ShapeNameChecker, + HistoryChecker, + TransformChecker, + LockedTransformChecker, + SmoothPreviewChecker, + KeyframeChecker, + TriangleChecker, + NgonChecker, + NonmanifoldEdgeChecker, + NonmanifoldVertexChecker, + LaminaFaceChecker, + BiValentFaceChecker, + ZeroAreaFaceChecker, + MeshBorderEdgeChecker, + CreaseEdgeChecker, + ZeroLengthEdgeChecker, + VertexPntsChecker, + EmptyGeometryChecker, + UnusedVertexChecker, + IntermediateObjectChecker, + InstanceShapeChecker, + ConnectionChecker, + DisplayLayerCheck, + UnusedLayerChecker, + Map1Checker, + NegativeUvChecker, + UdimIntersectionChecker, + UnassignedUvChecker, + UnmappedPolygonFaceChecker, + ZeroAreaUVFaceChecker, + ConcaveUVChecker, + ReversedUVChecker, + UvOverlapChecker, + SelectionSetChecker, + ColorSetChecker] diff --git a/framelayout.py b/framelayout.py new file mode 100644 index 0000000..8a22470 --- /dev/null +++ b/framelayout.py @@ -0,0 +1,114 @@ +""" qt framelayout sample """ + +from PySide2 import QtWidgets, QtCore +from . import icon + + +class TitleLabel(QtWidgets.QLabel): + + clicked = QtCore.Signal() + + def __init__(self, text="", parent=None): + super(TitleLabel, self).__init__(parent) + + self.setText(text) + + def mousePressEvent(self, event): + self.clicked.emit() + + +class FrameLayout(QtWidgets.QWidget): + + def __init__(self, title="", parent=None): + super(FrameLayout, self).__init__(parent) + + self.baseTitle = title + self.rightArrow = u"\u25b6 " + self.downArrow = u"\u25bc " + + titleLayout = QtWidgets.QHBoxLayout() + self.title = self.rightArrow + title + + self.titleLabel = TitleLabel(self.title) + self.titleLabel.setSizePolicy( + QtWidgets.QSizePolicy.Expanding, QtWidgets.QSizePolicy.Expanding) + self.titleLabel.clicked.connect(self.titleClicked) + self.statusIconLabel = QtWidgets.QLabel() + self.statusIconLabel.setPixmap(icon.neutralIconPixmap) + + self.childrenWidget = QtWidgets.QWidget() + self.childrenLayout = QtWidgets.QVBoxLayout() + self.childrenLayout.setContentsMargins(0, 0, 0, 0) + + self.childrenWidget.setLayout(self.childrenLayout) + + titleLayout.addWidget(self.statusIconLabel) + titleLayout.addWidget(self.titleLabel) + + layout = QtWidgets.QVBoxLayout() + layout.setContentsMargins(0, 0, 0, 0) + layout.addLayout(titleLayout) + layout.addWidget(self.childrenWidget) + self.setLayout(layout) + + # Close frame by default + self.childrenWidget.hide() + + def titleClicked(self): + """ + title clicked action + + """ + + newTitle = "" + + if self.childrenWidget.isVisible(): + self.childrenWidget.hide() + newTitle = self.rightArrow + self.baseTitle + else: + self.childrenWidget.show() + newTitle = self.downArrow + self.baseTitle + + self.titleLabel.setText(newTitle) + + def collapse(self): + newTitle = "" + self.childrenWidget.hide() + newTitle = self.rightArrow + self.baseTitle + self.titleLabel.setText(newTitle) + + def expand(self): + newTitle = "" + self.childrenWidget.show() + newTitle = self.rightArrow + self.baseTitle + self.titleLabel.setText(newTitle) + + def addWidget(self, widget): + # type: (QtWidgets.QWidget) -> None + """ + Add widgets + + """ + + self.childrenLayout.addWidget(widget) + + def addLayout(self, layout): + self.childrenLayout.addLayout(layout) + + def setStatusIcon(self, status): + # type: (str) -> None + """ + Change status icon + + """ + + if status == "good": + self.statusIconLabel.setPixmap(icon.goodIconPixmap) + elif status == "bad": + self.statusIconLabel.setPixmap(icon.errorIconPixmap) + elif status == "warning": + self.statusIconLabel.setPixmap(icon.warningIconPixmap) + elif status == "neutral": + self.statusIconLabel.setPixmap(icon.neutralIconPixmap) + else: + pass diff --git a/icon.py b/icon.py new file mode 100644 index 0000000..caf90db --- /dev/null +++ b/icon.py @@ -0,0 +1,34 @@ +""" wip + +https://www.iconfinder.com/iconsets/fatcow +https://creativecommons.org/licenses/by/3.0/us/ +"Farm-fresh" by FatCow Web Hosting is licensed under CC BY 3.0 + +""" + +from PySide2 import QtCore, QtGui + + +b64Error = b"""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""" +b64Warning = b"""iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAYAAABzenr0AAAFJUlEQVRYR+2WfUzUdRzHX7/fHXeCgsrx6BOiCAJCefIg8tDIykwNzHQzwwdmudZcubk5jXQq6WyVLtaUcjhlVqu5tHRm5dwE5NFDQEQINfEBBIEhAnnc3a/97sHRxXFHW7m2vv/d/b7f3+f1fX/en8/vI/CEl/CE4/OfBRDPbY5b46GSDsoK9uqFtam7yw4BpuEq+rcUWD8/wHdlUkhrTGamOV5FXh5HChv9ck63tP0bAG4FWbFnpybOSQ70u2+O19zqw7WiCwXJ2eVzgf7hQAxXAeHQ2uik6DDf89rXl0LRTswuituI7uuTVNe3paw5WF0ISK5CDBdAXbw1risifYHaq7cU7uosccZpeeARz5Xjpx4l7CgbDTz6JwDEHzbO2jQ1ZMKu8BdnQkUuiCpLHJMeYtZR92Ml1xpvb1n00cU9rhpyOAp4XMiK7Zm9bgXC1XzobQdRYQUwgocGaXoGJblHmZNdPlIuDldUcBVAcW5LzLGwJG1a4FQ3aDgNSiW4WVNtEMBggGnzab7WT32h7kTqroolgNEZhCsAQv5b0UmRwZrzM1+bB5ePgCSBSiLx4xREAQ4uqyLMvwsEESJXUvnlGWpvtKdk7HduSFcA1EVZsTfC5yUEjvVsgZbLoFDACCMv7UtGIULOK9VM9usGgwn8Z9DZHUDdmeLmxOzyYGeGdAYgnto4a1NwiP+u8IUzoe4EiErM11YbSPs0BYUo8cniKib79lgENxkgPI26k5XcaLy3ZYETQzoD8CjOiuvRrpiL6kEF9LRbZBYxA7ya84wZ4MPFVQT5PASjAJIJRmrQe8WgO3qWhOyyIQ05FIDi500xn4fGhmRO0mrgVgkISsydR5RA3c/yz1IRBYnd6ZeYZAaQySSQDDBxNk26dhrKG/Oe31PxpiNDOgIQ9mZMm54Y6ncldlUSNJeCXm+5vbysABn7U1EIEjvTLjFRYwOQGUygUkFgPOWHCylqaI3YkP/r1cE6pCMAVcF7sbrIF6Iix/o/go6b1uDW7VaA1QeeNadg+6JKJgwEMKtgAu8gOu+pqf2ppjb5g3ItoLcvy8EAxOPvzsoMDfX5Ijw9Eu5cspTdwNHBCrD2wHOIosTWhReZ8DgFthASCAKMf5q647U0NNx/I33fxTz7DjkYgHtxVnyvdrkWFS3Q90DW/M/ggtwHDGTmzjN74P1FFQT5dIHJbp88Hrh7oScA3Vc6ErJLPYC+gS+zBzAbb0pUQOaUlHHQfsMa3G6b/FNhpKl1jOWSY3oQFUYw2b9OVs4EmmCun7/L9ZqWvxhy4Alhb8aM6Ymho6/EroqC7juWxuJoalPKKpgsj/vlViw6mIckUIrgOZ7ywzUUNXRFbMi//NiQAwFUBVlxurCkiZG+oe7QK0vvwKPy32oTKW/7m1OQ+04nYZMNlj4w6JLAw4u2hj7qC2/VJmeXPTak7YTw7fqnFodNGXssalkIPOwYerqTU60ysWxbhKUPrL5J8Pi+IQCsmRzlTc03jdRf71yyNKfqO7ksbQAjSrYldEe/PEnprlFAvwtTlVKi6a6nxQPefYhKo/M5yM2NvnYj1d83GWZvL/YEfrcBeJduS2iPWx8KehOY7MpuMFnlSrCZ3uo1hykzn5f3C6ASKctpIH57sQbosAH4/rI57twolSJSkoO7PNE5+9rbPRfkfiagl6TbKTtKZB+02QC8gCBAprKOOcN8uevb5dLqAH4DumwA8ldGbhJqx9Z3PYKTnbK+ckuWRza5gJ/s+h/gD1M9zzASYFmcAAAAAElFTkSuQmCC""" +b64Good = b"""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""" +b64Neutral = b"""iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAYAAABzenr0AAAC10lEQVRYR+2V309SYRzGn+MhHZPSBKUU0VQm6yI9rsVFrZoLajMpNu5gMn5sede1f4HX3XkhOpjekSvMrYVzbtUFrUl20XCoKQp1FMwKxyzgtPcIzbaUw2Djhnc7d+97ns/7PN/v96VQ5kWVWR8VgIoDFQcKdYAymUwakUg0SlHU7eMtzHHcYiqVGpmenvYD4IS2dyEAtMUyNCaRnHMwTC+UyjZU19TwOr8ODxEObyIQ+IBE4se4y+UeBpAWAiEUQGSxDD1tkMr0gwP3EVpbx/LyMmKxGK8hk8nQ09MDVWcHZudeYC8ed7pcrkdCIIQAUAaD4aZC0bI4OPgAvvkFsOxX0DQNijo6znEc0uk05PIL0N7px+zsc0Qi0VszMzOv88UhBKDabDYv6HR3r3/eCGNrK8yLV1VV/eNwJpPhIVpblbjUrsT8vO+t2+3uJwmdFoUQgDqr1bqv1z/EK5/vv+I5gRyETquF1/sMk5OT9QC+FwvQaLPZdvquXsNqKASaJjc/iZtEkUGXSoWl9+8wMTHRBGC3WIAmu93OdqsvIx7f+5v7ST8l9SCVNmAl+AlOp1MOYKdoAIfDzl5sVmZvnq/FiTscvkTDGB8vDUCj2Wx+qVC299XWSkByPm2R4jw4SGA7vLE0NTV1rxQR1Gk0Gj3D9LrbO1S8CydBHHUGh431EBlKQ36/31uKIqwG0Gw0Gp/I5XJ9Z1c3QFF875OPLDIP+JnAcVhbXQHLsl6Px/MYQLQUbUhCPQugzWg0jspkjQPNLQrUn5eCFtE8QDqVxv63OKKRbcRiu3Mej2cEwCaAn6UYRESDKNUBaGEY5oZarR4Wi8VXyI2zFiCZTH4MBoNjgUDgDYBI1vq874GQQZSrOQJRC6CBjH8AkiwYbwKABADyOOwBOBDyDvDxCXmxju0h+88AEAMgtZE7T6wgIzcJ4Hc+249rFgpQIG/+7RWAigMVB8ruwB+gWP0h6xe84QAAAABJRU5ErkJggg==""" + +tempPixmap = QtGui.QPixmap() + +errorData = QtCore.QByteArray.fromBase64(b64Error) +warningData = QtCore.QByteArray.fromBase64(b64Warning) +goodData = QtCore.QByteArray.fromBase64(b64Good) +neutralData = QtCore.QByteArray.fromBase64(b64Neutral) + +tempPixmap.loadFromData(errorData) +errorIconPixmap = tempPixmap.scaled(20, 20, QtCore.Qt.IgnoreAspectRatio, QtCore.Qt.SmoothTransformation) + +tempPixmap.loadFromData(warningData) +warningIconPixmap = tempPixmap.scaled(20, 20, QtCore.Qt.IgnoreAspectRatio, QtCore.Qt.SmoothTransformation) + +tempPixmap.loadFromData(goodData) +goodIconPixmap = tempPixmap.scaled(20, 20, QtCore.Qt.IgnoreAspectRatio, QtCore.Qt.SmoothTransformation) + +tempPixmap.loadFromData(neutralData) +neutralIconPixmap = tempPixmap.scaled(20, 20, QtCore.Qt.IgnoreAspectRatio, QtCore.Qt.SmoothTransformation) diff --git a/images/ui.png b/images/ui.png new file mode 100644 index 0000000000000000000000000000000000000000..2bd874d7c3403820183b6dbd4e36815af6868f9e GIT binary patch literal 71527 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 z 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