def _runserver(handshake_port): sock = zmq.Context().socket(zmq.REP) appport = sock.bind_to_random_port('tcp://127.0.0.1') handshakesock = zmq.Context().socket(zmq.REQ) handshakesock.connect('tcp://127.0.0.1:%s' % handshake_port) handshakesock.send(str(appport)) handshakesock.recv() # acknowledgement handshakesock.close() while True: recved = sock.recv() func, arg = json.loads(recved) try: code = mayaserver.SUCCESS response = None if func == 'exec': executeInMainThreadWithResult(_exec, arg) elif func == 'eval': response = executeInMainThreadWithResult( _eval, arg) else: code = mayaserver.INVALID_METHOD response = func pickled = json.dumps([code, response]) except Exception: pickled = json.dumps([ mayaserver.UNHANDLED_ERROR, ''.join(traceback.format_exc())]) sock.send(pickled)
def set_collection(self, new_contents): current = set(self._Internal_Collection) incoming = set(new_contents) reordered = sum([x == y for x, y in zip(new_contents, self._Internal_Collection)]) additions = incoming.difference(current) deletions = current.difference(incoming) def safe_create_gui(): for d in deletions: del(self._Public_Collecton[d]) for a in additions: templated = self.Conversion(a) self._Public_Collecton[a] = templated.Widget self.WidgetCreated(templated) utils.executeInMainThreadWithResult(safe_create_gui) self._Internal_Collection = new_contents if len(additions) + len(deletions): self.CollectionChanged(collection=self.Contents) else: if reordered: self.CollectionChanged(sorted=True, collection=self.Contents) else: self.CollectionChanged(why="idontknow")
def _runserver(handshake_port): sock = zmq.Context().socket(zmq.REP) appport = sock.bind_to_random_port('tcp://127.0.0.1') handshakesock = zmq.Context().socket(zmq.REQ) handshakesock.connect('tcp://127.0.0.1:%s' % handshake_port) handshakesock.send(str(appport)) handshakesock.recv() # acknowledgement handshakesock.close() while True: recved = sock.recv() func, arg = json.loads(recved) try: code = mayaserver.SUCCESS response = None if func == 'exec': executeInMainThreadWithResult(_exec, arg) elif func == 'eval': response = executeInMainThreadWithResult(_eval, arg) else: code = mayaserver.INVALID_METHOD response = func pickled = json.dumps([code, response]) except Exception: pickled = json.dumps( [mayaserver.UNHANDLED_ERROR, ''.join(traceback.format_exc())]) sock.send(pickled)
def _mainLoop(): self.event.wait(self.interval) if not self.event.isSet(): if executeInMainThreadWithResult: executeInMainThreadWithResult(self.function, *self.args, **self.kwargs) else: self.function(*self.args, **self.kwargs)
def process_update(data): """ Process incoming data, run this in the Maya main thread :param data: :return: """ try: maya_utils.executeInMainThreadWithResult(function_to_process, data) except Exception as e: cmds.error("Debug Server, Exception processing Function: {}".format(e))
def on_identify_dcc(self, client): """! On Identify Dcc Action @param client SocketClient: Client Connection """ exec_name = sys.executable.rsplit('\\', 1)[1] exec_name = exec_name.split('.')[0] data = "name = cmds.file(q=True, sn=True).split('/')[-1]\nname = name if len(name)>0 else 'unsaved'\nprint(json.dumps({'filename': name, 'exec_name': '" + exec_name + "'}, sort_keys=True, indent=4))" maya_utils.executeInMainThreadWithResult(self.function_to_process, data, client)
def _mainLoop(): self.event.wait(self.interval) if not self.event.isSet(): if mu.executeInMainThreadWithResult: try: mu.executeInMainThreadWithResult( self.function, *self.args, **self.kwargs) except Exception as e: print '\n\texecuteInMainThreadWithResult cases error: "%s"' % e.message print '\n\tstop thread!' self.stop() else: self.function(*self.args, **self.kwargs)
def process_update(self, data, client): """! Process incoming data, run this in the Maya main thread @param data Json: Received Data @param client SocketClient: Client Connection """ try: maya_utils.executeInMainThreadWithResult(self.function_to_process, data, client) except Exception as e: cmds.error( "Maya Server, Exception processing Function: {}".format(e))
def processDataInMaya(data): """ This function is designed to be passed as the 'processFunc' arg of the mayaServer function. It is mainly a try\except wrapper around the executeWingCode.main() function. data : string : The data passed from wing. Currently this is 'python' or 'mel'. """ try: # If we don't evaluate in maya.util.executeInMainThreadWithResult(), # Maya can crash, and that's no good. mu.executeInMainThreadWithResult(executeWingCode.main, data) except Exception, e: om.MGlobal.displayError("Encountered exception: %s"%e)
def Doit(self, *args): self._tranDVBG = [] mc.currentUnit(t="pal") #设置帧率 mc.playbackOptions(min=1, ast=1, max=25, aet=25) self._TranValue = float(mc.textFieldGrp(self._textFG, tx=True, q=True)) if (self._TranValue > 0.01) & (self._TranValue <= 100.0): if self._dateFileName and self._dateFileName[-4::] == ".txt": if self._tranFileName: self.GetMoveList() #print self._tranDVBG mu.executeInMainThreadWithResult(self.CreateAni) else: mc.confirmDialog(title=u"提示", message=u'请选择采集数据的txt文件!') else: mc.confirmDialog(title=u"提示", message=u'输入的间距值在0到10之前!\n请重新输入')
def sendAlembic(target_clientID, sender, tabTarget): result = mUtils.executeInMainThreadWithResult(_exportAlembic) if not result: return False fileName = result[0] filePath = result[1] frameRange = result[2] with open(filePath, 'rb') as f: data = f.read() outData = {} outData["TYPE"] = "alembic_cache" outData["NAME"] = fileName outData["FRAME_RANGE"] = frameRange outData["DATA"] = data try: os.remove(filePath) except: pass result = _sendData(target_clientID, sender, outData, "alembic", tabTarget) return result
def sendObjMesh(target_clientID, sender, tabTarget): meshOut = {} meshOut["MESH_TYPE"] = ".obj" meshName, objtmp = mUtils.executeInMainThreadWithResult(_exportObj) if not meshName: return False if not objtmp: return False with open(objtmp, 'rb') as f: meshOut["MESH_DATA"] = f.read() try: os.remove(objtmp) except: pass meshOut["MESH_TYPE"] = ".obj" meshOut["MESH_NAME"] = meshName result = _sendData(target_clientID, sender, meshOut, "mesh", tabTarget) return result
def processCommandsInMaya(MayaCmd): try: res = mu.executeInMainThreadWithResult(MayaCmd) print('result:%s'%res) return res except Exception as e: om.MGlobal.displayError('Encountered exception: %s' %e)
def createAlembic(data, sender = "", settings=None): name = data["NAME"] binary = data["DATA"] abcFile = fetchMyReceivedFilesFolder() + os.sep + name + ".abc" abcFile = incrementFile(abcFile) with open(abcFile, 'wb') as f: f.write(binary) try: mUtils.executeInMainThreadWithResult(lambda: cmds.AbcImport(fetchMyReceivedFilesFolder() + os.sep + name + ".abc")) return True except AttributeError: print("ERROR: ALEMBIC PLUGIN NOT LOADED") return False
def archive(mayaFile, todo, settings): comment = todo["label"] amp = settings.get("AMPArchive.active", False) if amp and mayaFile: if Mutils.executeInMainThreadWithResult(lambda: AMPArchive().archive(mayaFile, comment)): print "Checking file into AMP." else: print "Couldn't check in file to AMP."
def handle(self): # Called to handle each connection request try: # if we are echoing output, we hold on to the first request # and poll the socket for pending command messages. # Otherwise, we just block on the socket. if self.server.echoOutput: self.request.settimeout(1.5) while not self.server.die: # check for pending command messages if self.server.echoOutput: while not self.server.commandMessageQueue.empty(): self.wfile.write( self.server.commandMessageQueue.get() + self.resp_term) # set self.data to be the incoming message try: self.data = self.receiveData() except socket.timeout: continue if self.data is None: break # check if we need to display the security warning # posting the dialog also has to be done in the gui thread if self.server.securityWarning: utils.executeInMainThreadWithResult( self.postSecurityWarning) if self.dialog_result is False: self.wfile.write(maya.stringTable[ 'y_CommandPort.kExecutionDeniedByMaya'] + self.resp_term) return elif self.dialog_result is True: self.server.securityWarning = False # execute the message response = utils.executeInMainThreadWithResult( self._languageExecute) # write the command responses to the client self.wfile.write(response) except socket.error: # a socket exception is a normal way to terminate the connection pass
def copyMap(self): #generate authorStr and uuid _uuidList = [] for i in range(0, self.count): uuid = mu.executeInMainThreadWithResult(self.doInMain, i) _uuidList.append(uuid[0]) self.progress.emit(i + 1) self.uuidList.emit(_uuidList) self.finished.emit()
def createAlembic(data, sender="", settings=None): name = data["NAME"] binary = data["DATA"] abcFile = fetchMyReceivedFilesFolder() + os.sep + name + ".abc" abcFile = incrementFile(abcFile) with open(abcFile, 'wb') as f: f.write(binary) try: mUtils.executeInMainThreadWithResult(lambda: cmds.AbcImport( fetchMyReceivedFilesFolder() + os.sep + name + ".abc")) return True except AttributeError: print("ERROR: ALEMBIC PLUGIN NOT LOADED") return False
def runArchive(s, todo, filename): if s.data.get(s.settingName, False) and _version_: path = os.path.realpath(filename) if path and os.path.isfile(path): comment = todo.label if Mutils.executeInMainThreadWithResult(lambda: AMPArchive().archive(mayaFile, comment)): print "Checking file into AMP." else: print "Couldn't check in file to AMP."
def createOtl(data, sender="", settings=None): nodeType = data["OTL_TYPE"] subOtlLibs = data["OTL_ALL_LIBS"] libPath = None otlToAdd = None # Check otl libs if subOtlLibs: for e in subOtlLibs: libName = e[0] libData = e[1] otlLibToInstall = str(fetchMyReceivedFilesFolder() + os.sep).replace("\\", "/") + libName with open(otlLibToInstall, 'wb') as f: f.write(libData) libs = mel.eval('houdiniAsset -listAssets "' + otlLibToInstall + '"') if libs: for lib in libs: if nodeType in str(lib): libPath = otlLibToInstall otlToAdd = lib if libPath and otlToAdd: melcmd = 'houdiniAsset -loadAsset "' + libPath + '" "' + otlToAdd + '"' try: mUtils.executeInMainThreadWithResult(lambda: mel.eval(melcmd)) return True except Exception as e: print str(e) return False else: print("ERROR: Incoming object is not a valid digital asset") return None
def sendData(): cmds.progressWindow(isInterruptable=1) ser = serial.Serial(serialPort, baudRate, timeout=0.5) while 1: if cmds.progressWindow(query=1, isCancelled=1): ser.close() break data = utils.executeInMainThreadWithResult(getCurrentData) ser.write("<" + data + ">") time.sleep(sendRate) cmds.progressWindow(endProgress=1)
def createOtl(data, sender="", settings=None): nodeType = data["OTL_TYPE"] subOtlLibs = data["OTL_ALL_LIBS"] libPath = None otlToAdd = None # Check otl libs if subOtlLibs: for e in subOtlLibs: libName = e[0] libData = e[1] otlLibToInstall = str(fetchMyReceivedFilesFolder() + os.sep).replace("\\","/") + libName with open(otlLibToInstall, 'wb') as f: f.write(libData) libs = mel.eval('houdiniAsset -listAssets "' + otlLibToInstall + '"') if libs: for lib in libs: if nodeType in str(lib): libPath = otlLibToInstall otlToAdd = lib if libPath and otlToAdd: melcmd = 'houdiniAsset -loadAsset "' + libPath + '" "' + otlToAdd + '"' try: mUtils.executeInMainThreadWithResult(lambda: mel.eval(melcmd)) return True except Exception as e: print str(e) return False else: print("ERROR: Incoming object is not a valid digital asset") return None
def createMesh(data, sender="", settings=None): meshType = data["MESH_TYPE"] if meshType != ".obj": print("ERROR: Mesh type not supported (" + meshType + ")") return False meshName = data["MESH_NAME"] meshData = data["MESH_DATA"] obj = fetchMyReceivedFilesFolder() + os.sep + meshName + meshType obj = incrementFile(obj) with open(obj, 'wb') as f: f.write(meshData) try: mUtils.executeInMainThreadWithResult(lambda: cmds.file(obj,i=True,dns=True)) return True except Exception as e: print str(e) return False
def _routeMessageImpl(self, data): result = None if data.kind == DataKindEnum.MEL_SCRIPT: result = mu.executeInMainThreadWithResult(runMelExec, data.payload['script']) elif data.kind == DataKindEnum.PYTHON_SCRIPT: result = mu.executeInMainThreadWithResult( runPythonExec, data.payload['script'], data.payload['kwargs']) elif data.kind == DataKindEnum.MAYA_COMMAND: result = mu.executeInMainThreadWithResult( self._executeMayaCommand, data.payload) elif data.kind == DataKindEnum.MAYA_COMMAND_BATCH: result = mu.executeInMainThreadWithResult( self._executeMayaCommandBatch, data.payload) elif data.kind == DataKindEnum.COMMAND: result = mu.executeInMainThreadWithResult( self._executeCommand, data.payload) elif data.kind == DataKindEnum.PYTHON_SCRIPT_FILE: result = mu.executeInMainThreadWithResult( self._runPythonFile, data.payload) if result: if isinstance(result, NimbleResponseData): return result return self._createReply(data.kind, result) return None
def get_input(connection, qImage, size, progress_bar): #load qImage handling different input types connection_type = pm.objectType(connection) if connection_type == "file": #get file path texture_file = connection.fileTextureName.get() qImage.load(texture_file) #scale to size qImage = mu.executeInMainThreadWithResult(scale_down, qImage, size) #get repeat UV values from 2DPlacement node repeatU = connection.repeatU.get() repeatV = connection.repeatV.get() print(repeatU, size, repeatV) print("Scale started...") #scale QImage to be repeated according to repeat UV values qImage = mu.executeInMainThreadWithResult(scale_tile, qImage, repeatU, repeatV) #qImage.save(Coat.project_dir + "/sourceimages/test.png", "PNG",-1) update_progress(progress_bar) print("Scale end") return [qImage, texture_file] if connection_type == "ramp": #make ramp make_ramp(connection, qImage) #get repeat UV values from 2DPlacement node repeatU = connection.repeatU.get() repeatV = connection.repeatV.get() print("Scale started...") #scale QImage to be repeated according to repeat UV values qImage = mu.executeInMainThreadWithResult(scale_tile, qImage, repeatU, repeatV) update_progress(progress_bar) print("Scale end") return [qImage, connection] if connection_type == "colorConstant": #get color color = connection.inColor.get() qImage.fill( QtGui.QColor(color[0] * 255, color[1] * 255, color[2] * 255)) return [qImage, str(color)]
def handle(self): # Called to handle each connection request try: # if we are echoing output, we hold on to the first request # and poll the socket and for pending command messages. # Otherwise, we just block on the socket. if self.server.echoOutput: self.request.settimeout(1.5) while not self.server.die: # check for pending command messages if self.server.echoOutput: while not self.server.commandMessageQueue.empty(): self.wfile.write(self.server.commandMessageQueue.get() + self.resp_term) # set self.data to be the incoming message try: self.data = self.recieveData() except socket.timeout: continue if self.data is None: break # check if we need to display the security warning # posting the dialog also has to be done in the gui thread if self.server.securityWarning: utils.executeInMainThreadWithResult(self.postSecurityWarning) if self.dialog_result is False: self.wfile.write(maya.stringTable['y_CommandPort.kExecutionDeniedByMaya' ] + self.resp_term) return elif self.dialog_result is True: self.server.securityWarning = False # execute the message response = utils.executeInMainThreadWithResult(self._languageExecute) # write the command responses to the client self.wfile.write(response) except socket.error: # a socket exception is a normal way to terminate the connection pass
def createMesh(data, sender="", settings=None): meshType = data["MESH_TYPE"] if meshType != ".obj": print("ERROR: Mesh type not supported (" + meshType + ")") return False meshName = data["MESH_NAME"] meshData = data["MESH_DATA"] obj = fetchMyReceivedFilesFolder() + os.sep + meshName + meshType obj = incrementFile(obj) with open(obj, 'wb') as f: f.write(meshData) try: mUtils.executeInMainThreadWithResult( lambda: cmds.file(obj, i=True, dns=True)) return True except Exception as e: print str(e) return False
def readInput(self): ''' Get the input from the UI class and start the timer or screenshot/playblast commands ''' # get Values from UI everyFrame, everyTime_dropdwn = self.getEveryTimer() stopStyle, stopFrames = self.getStopStyle() renderStyle = self.getRenderStyle() # check if the output directory is set and the camera is selected if self.checkSaveLocation( ) and UI.assignCam_dropdwn.currentText() != 'none': # check if we need to enable the timer. # renderStyle == 1 is Log every x sec/min/hour if renderStyle == 1: # create new timer timerVal = threading.Timer(everyFrame, self.readInput) # check if: it is OK to start the timer or if we need to stop it and # if the number of frames in after x frames is more or equal than 3. if (stopStyle == 0 and (everyFrame >= 3) and (self.currentFrame >= stopFrames) ) or not self.renderActive: self.startTimer(False, timerVal) else: self.startTimer(True, timerVal) if renderStyle == 0 or (renderStyle == 1 and self.renderActive): # execute the render command / playblast in the mainThread in Maya. ut.executeInMainThreadWithResult(self.renderScreen) if not self.renderActive or renderStyle == 0: self.autoPackFrames(UI.exportPack_dropdwn.currentText(), UI.exportFps_edit.text())
def makeTx(self, texture): cmd = 'maketx'; cmd += ' -o "' + os.path.splitext(texture)[0] + '.tx"' # Custom options ctrlPath = '|'.join([self.txManager.window, 'groupBox_2', 'lineEdit']); cmd += ' '+utils.executeInMainThreadWithResult(cmds.textField, ctrlPath, query=True, text=True); cmd += ' "'+texture+'"' #print cmd if os.name == 'nt': proc = subprocess.Popen(cmd, creationflags=subprocess.SW_HIDE, shell=True) else: proc = subprocess.Popen(cmd, shell=True) return proc.wait()
def serverHandler(request): def mainThreadHandler(request): try: launch(**request) return {'result': 'success'} except Exception as e: import traceback traceback.print_exc() #return {'result':'exception','exception': str(e)base64.b64encode(pickle.dumps(e, pickle.HIGHEST_PROTOCOL)).encode("utf-8"),'stackTrace':traceback.format_exc()} return { 'result': 'exception', 'exception': str(e), 'stackTrace': traceback.format_exc() } from maya.utils import executeInMainThreadWithResult result = executeInMainThreadWithResult(mainThreadHandler, request) return result
def processRequest(cls, data): result = None if data.kind == DataKindEnum.MEL_SCRIPT: result = mu.executeInMainThreadWithResult(runMelExec, data.payload["script"]) elif data.kind == DataKindEnum.PYTHON_SCRIPT: result = mu.executeInMainThreadWithResult(runPythonExec, data.payload["script"], data.payload["kwargs"]) elif data.kind == DataKindEnum.MAYA_COMMAND: result = mu.executeInMainThreadWithResult(cls._executeMayaCommand, data.payload) elif data.kind == DataKindEnum.MAYA_COMMAND_BATCH: result = mu.executeInMainThreadWithResult(cls._executeMayaCommandBatch, data.payload) elif data.kind == DataKindEnum.COMMAND: result = mu.executeInMainThreadWithResult(cls._executeCommand, data.payload) elif data.kind == DataKindEnum.PYTHON_SCRIPT_FILE: result = mu.executeInMainThreadWithResult(cls._runPythonFile, data.payload) elif data.kind == DataKindEnum.PYTHON_IMPORT: result = mu.executeInMainThreadWithResult(cls.runPythonImport, data.payload) if result: if isinstance(result, NimbleResponseData): return result return cls.createReply(data.kind, result) return None
def run(self): #Create an input socket on an open port HOSTin = '' # Symbolic name meaning all available interfaces PORTin = self.get_open_port() # Arbitrary non-privileged port self.sockIn = socket.socket(socket.AF_INET, socket.SOCK_STREAM) self.sockIn.bind((HOSTin, PORTin)) self.sockIn.listen(1) repo = CallDeadlineCommand(["-GetRepositoryRoot"]).rstrip() #in the main thread get a screen shot screenshot = utils.executeInMainThreadWithResult(self.getScreenshot) info = screenshot.split("=") #if the screenshot exists then continue else create the failed message and return draftPath = repo+os.sep+"draft" if len(info) == 1: utils.executeInMainThreadWithResult(self.failedScreenshot) return deadlineCommand = GetDeadlineCommand() deadlineBin = os.path.dirname( deadlineCommand ) if platform.system() == "Linux": if not deadlineBin == "": newLDPath = os.path.join(deadlineBin,"python","lib")+os.pathsep+draftPath if "LD_LIBRARY_PATH" in os.environ: newLDPath = newLDPath + os.pathsep + os.environ["LD_LIBRARY_PATH"] os.environ["LD_LIBRARY_PATH"] = newLDPath elif platform.system() == "Darwin": if not deadlineBin == "": draftPath = os.path.join(draftPath,"Mac") newDYLDPath = os.path.join(deadlineBin,"python","lib")+os.pathsep+draftPath if "DYLD_LIBRARY_PATH" in os.environ: newDYLDPath = newDYLDPath + os.pathsep + os.environ["DYLD_LIBRARY_PATH"] os.environ["DYLD_LIBRARY_PATH"] = newDYLDPath #Get deadlinecommand to execute a script and pass in a screenshot and the port to connect to. CallDeadlineCommand(["-executescript",repo+os.sep+"submission"+os.sep+"Jigsaw"+os.sep+"Jigsaw.py",str(PORTin),info[1]], False, False) conn, addr = self.sockIn.accept() #wait to receive the a message with the port in which to connect to for outgoing messages data = recvData(conn) if not data: #If we do not get one return conn.close() return HostOut = 'localhost' PORTout = int(data) self.sockOut = socket.socket(socket.AF_INET, socket.SOCK_STREAM) self.sockOut.connect((HostOut, PORTout)) #constantly listen while 1: data = recvData(conn) #if we do not get data then exit if not data: break #otherwise split the data on = command = str(data).split("=") #if we got the command exit then break out of the loop if command[0].lower() == "exit": break #if we were told to get the screenshot then retrieve a screenshot and send it to the jigsaw ui elif command[0].lower() == "getscreenshot": screenshot = utils.executeInMainThreadWithResult(self.getScreenshot) if(not screenshot): cmds.confirmDialog(title="No Background", message="Unable to get background. Make sure that the viewport is selected."); self.closeJigsaw() else: self.sockOut.sendall(screenshot+"\n") #When we are told to fit the region elif command[0].lower() == "getselected": mode = 0#Vertex padding = 0 #percentage based padding if len(command)>1: arguments=command[1].split(";") arguments[0].split() if arguments[0].lower() == "tight": mode = 0#vertex elif arguments[0].lower() == "loose": mode = 1#boundingbox padding = float(arguments[1]) regions = self.getSelectedBoundingRegion(mode, padding) regionMessage = "" for region in regions: if not regionMessage == "": regionMessage+=";" first = True for val in region: if not first: regionMessage+="," regionMessage += str(val) first = False self.sockOut.sendall("create="+regionMessage+"\n") #when told to save the regions save them to the scene elif command[0].lower() == "saveregions": if not len(command)>1: utils.executeInMainThreadWithResult(self.saveRegions, "") else: utils.executeInMainThreadWithResult(self.saveRegions, command[1]) #when told to load the regions send the regions back to Jigsaw elif command[0].lower() == "loadregions": self.sockOut.sendall("loadregions="+utils.executeInMainThreadWithResult(self.loadRegions)+"\n") conn.close() try: os.remove(self.tempFile) except: pass
def add_coat(blend_material, coat_number, size, res_colorQImage, res_bumpQImage, res_opacityQImage, progress_bar): #initialize coat current_coat = Coat(blend_material, coat_number, size) coat_material = current_coat.get_material() print("coat " + str(coat_number) + " --------------") print("name: " + coat_material[0]) #get color or file and store in coat colorQImage if coat_material: is_supported = get_color_or_inputs(coat_material[0], current_coat, size, progress_bar) #warn and skip layer if material type is not supported if (is_supported == False): warning_msg("Material type on coat " + str(coat_number) + " (" + coat_material[0] + ") is not supported.\nSkipping layer") return True if (is_supported == None): #slot_material is blend return False #exit current add_coat else: #get matte matte = pm.listConnections(blend_material + '.blend_amount_' + str(coat_number)) if (matte): get_input_connection_by_type(matte[0], current_coat, size, "matte", progress_bar) #check transparency and bump is_coat_transparent = current_coat.get_isTransparent() coat_has_bump = current_coat.get_hasBump() #fill opacity map if (is_coat_transparent): #if transparent fill with 50% gray current_coat.get_opacityQImage().fill( QtGui.QColor(128, 128, 128)) else: #if not transparent fill with white current_coat.get_opacityQImage().fill( QtGui.QColor(255, 255, 255)) if (not coat_has_bump): #if coat doesn't have bump, fill with 50% gray fo height map or neutral blue for normal map if (Coat.bump_is_normal): current_coat.get_bumpQImage().fill( QtGui.QColor(128, 128, 255)) else: current_coat.get_bumpQImage().fill( QtGui.QColor(128, 128, 128)) matteQImage = current_coat.get_matteQImage() '''#repeat matte tile if matte repeat uv is not the same as color tile if(matteTile.width(),current_coat.get_colorQImage().width()): matteQImage = QtGui.QImage(size, size, QtGui.QImage.Format_RGB32) mu.executeInMainThreadWithResult( comp_coat_base, matteTile, matteQImage) else: matteQImage = current_coat.get_matteQImage()''' #matteQImage.save(Coat.project_dir + "/sourceimages/" + blend_material + "_matte_"+str(coat_number)+".png", "PNG",-1) #mask coat color, bump and opacity with coat matte print("set matte on coat...") mu.executeInMainThreadWithResult( set_alpha, current_coat.get_colorQImage(), matteQImage) mu.executeInMainThreadWithResult(set_alpha, current_coat.get_bumpQImage(), matteQImage) mu.executeInMainThreadWithResult( set_alpha, current_coat.get_opacityQImage(), matteQImage) #composite coat over base image update_progress(progress_bar) mu.executeInMainThreadWithResult( comp_coat_base, current_coat.get_colorQImage(), res_colorQImage) mu.executeInMainThreadWithResult(comp_coat_base, current_coat.get_bumpQImage(), res_bumpQImage) mu.executeInMainThreadWithResult( comp_coat_base, current_coat.get_opacityQImage(), res_opacityQImage) update_progress(progress_bar) return True else: #if coat doesn't have matte warn and don't add to texture warning_msg("Coat " + str(coat_number) + " (" + current_coat + ") has no matte.\nSkipping layer") print("matte: Has no matte") return True
def getSelectedBoundingRegion(self, mode=False, padding = 0.0): # get current render width and height settings renderHeight = cmds.getAttr('defaultResolution.height') renderWidth = cmds.getAttr('defaultResolution.width') widthMultiplier = renderWidth/(self.usingWidth+0.0) heightMultiplier = renderHeight/(self.usingHeight+0.0) gates = utils.executeInMainThreadWithResult( self.setGates, [False,False] ) # get the active viewport activeView = OpenMayaUI.M3dView.active3dView() # define python api pointers to get data from api class xPtrInit = OpenMaya.MScriptUtil() yPtrInit = OpenMaya.MScriptUtil() widthPtrInit = OpenMaya.MScriptUtil() heightPtrInit = OpenMaya.MScriptUtil() xPtr = xPtrInit.asUintPtr() yPtr = yPtrInit.asUintPtr() widthPtr = widthPtrInit.asUintPtr() heightPtr = heightPtrInit.asUintPtr() # retreive viewport width and height activeView.viewport(xPtr, yPtr, widthPtr, heightPtr) viewX = xPtrInit.getUint( xPtr ) viewY = yPtrInit.getUint( yPtr ) viewWidth = widthPtrInit.getUint( widthPtr ) viewHeight = heightPtrInit.getUint( heightPtr ) # determine aspect ratio of render size # then determine what the viewport renderable height is aspectRatio = float(renderHeight) / float(renderWidth) heightDiff = 0 # actual viewport renderable pixels heightClip = 0 # area of user viewport not renderable # get the active selection selection = OpenMaya.MSelectionList() OpenMaya.MGlobal.getActiveSelectionList( selection ) iterSel = OpenMaya.MItSelectionList(selection, OpenMaya.MFn.kMesh) # loop through the selected nodes boundingBoxes = [] while not iterSel.isDone(): # bounding box vars minX = 0 maxX = 0 minY = 0 maxY = 0 iterGeoNum = 0 if mode == 0:#by vertex dagPath = OpenMaya.MDagPath() iterSel.getDagPath( dagPath ) iterGeo = OpenMaya.MItGeometry( dagPath ) # iterate through vertex positions # check each vertex position and get its x, y cordinate in the viewport # generate the minimum x and y position and the max x and y position while not iterGeo.isDone(): vertexMPoint = iterGeo.position(OpenMaya.MSpace.kWorld) xPosShortPtrInit = OpenMaya.MScriptUtil() yPosShortPtrInit = OpenMaya.MScriptUtil() xPosShortPtr = xPosShortPtrInit.asShortPtr() yPosShortPtr = yPosShortPtrInit.asShortPtr() activeView.worldToView(vertexMPoint, xPosShortPtr, yPosShortPtr) xPos = xPosShortPtrInit.getShort(xPosShortPtr) yPos = yPosShortPtrInit.getShort(yPosShortPtr) if iterGeoNum == 0: minX = xPos minY = yPos if xPos < minX: minX = xPos if xPos > maxX: maxX = xPos if yPos < minY: minY = yPos if yPos > maxY: maxY = yPos iterGeoNum = iterGeoNum + 1 iterGeo.next() elif mode == 1: #by boundingbox objNames = [] iterSel.getStrings(objNames) for name in objNames: bbox = cmds.exactWorldBoundingBox(name) XVals = [bbox[0],bbox[3]] YVals = [bbox[1],bbox[4]] ZVals = [bbox[2],bbox[5]] #print bbox for x in XVals: for y in YVals: for z in ZVals: point = OpenMaya.MPoint(x,y,z) xPosShortPtrInit = OpenMaya.MScriptUtil() yPosShortPtrInit = OpenMaya.MScriptUtil() xPosShortPtr = xPosShortPtrInit.asShortPtr() yPosShortPtr = yPosShortPtrInit.asShortPtr() activeView.worldToView(point, xPosShortPtr, yPosShortPtr) xPos = xPosShortPtrInit.getShort(xPosShortPtr) yPos = yPosShortPtrInit.getShort(yPosShortPtr) if iterGeoNum == 0: minX = xPos minY = yPos if xPos < minX: minX = xPos if xPos > maxX: maxX = xPos if yPos < minY: minY = yPos if yPos > maxY: maxY = yPos iterGeoNum = iterGeoNum + 1 # move on to next selected node iterSel.next() # the renderWindowCheckAndRenderRegion arguments are ymax, xmin, ymin, xmax # convert the min max values to scalars between 0 and 1 minXScalar = 0 maxXScalar = 0 minYScalar = 0 maxYScalar = 0 filmFit = "" filmFit = utils.executeInMainThreadWithResult( self.getFilmFit ) if filmFit == "horizontal": renderableHeight = viewWidth * aspectRatio heightDiff = viewHeight - renderableHeight heightClip = heightDiff / 2 minXScalar = float(minX)/float(viewWidth) maxXScalar = float(maxX)/float(viewWidth) if(renderWidth > renderHeight or heightDiff < 0 ): minYScalar = ( float( minY ) - heightClip ) / float( renderableHeight ) maxYScalar = ( float( maxY ) - heightClip ) / float( renderableHeight ) else: minYScalar = ( float( minY ) + heightClip ) / float( renderableHeight ) maxYScalar = ( float( maxY ) + heightClip ) / float( renderableHeight ) elif filmFit == "vertical": renderableWidth = viewHeight / aspectRatio widthDiff = viewWidth - renderableWidth widthClip = widthDiff / 2 minYScalar = float(minY)/float(viewHeight) maxYScalar = float(maxY)/float(viewHeight) if( renderHeight > renderWidth or widthDiff < 0 ): minXScalar = ( float( minX ) - widthClip ) / float( renderableWidth ) maxXScalar = ( float( maxX ) - widthClip ) / float( renderableWidth ) else: minXScalar = ( float( minX ) + widthClip ) / float( renderableWidth ) maxXScalar = ( float( maxX ) + widthClip ) / float( renderableWidth ) # define viewport pixel based bounding box and scalar bounding box # scalar is the only one useful for rendering a region padding = max(padding,0.0) x = minXScalar*renderWidth y = renderHeight - maxYScalar*renderHeight #y = renderHeight-(renderWidth*maxYScalar+0.5) width = (maxXScalar-minXScalar)*renderWidth+1.5 height = renderHeight*(maxYScalar-minYScalar)+1.5 xPadding = int(((width*padding)/200)+0.5) yPadding = int(((height*padding)/200)+0.5) x1 = int((x-xPadding)/widthMultiplier+0.5) y1 = int((y-yPadding)/heightMultiplier+0.5) x2 = int((width+xPadding*2)/widthMultiplier+0.5) y2 = int((height+yPadding*2)/heightMultiplier+0.5) boundingBoxFinalRegion = [ x1, y1, x2, y2 ] boundingBoxes.append(boundingBoxFinalRegion) print("Added Bounding Box") print("Done Select Bounding Region") utils.executeInMainThreadWithResult( self.setGates, gates ) return boundingBoxes
from PySide.QtCore import * from PySide.QtGui import * from MayaApp.MainWindow import MainWindow import maya.OpenMayaUI as mui from maya import utils import sip def getMayaWindow(): ''' Get the maya main window as a QMainWindow instance ''' ptr = mui.MQtUtil.mainWindow() return sip.wrapinstance(long(ptr), QWidget) def go(): window = MainWindow(getMayaWindow()) window.show() utils.executeInMainThreadWithResult(go)
def recording(): global obarray global bodypart_names global NAME global data global frame # points to index in the message [data] index_pointer = 24 # points to index in the object array [objectarray] array_pointer = 0 # points to index in the segmentbox array [segmentbox] segmentbox_pointer = 0 # keep track of the float cycles cycle_counter = 1 # timestamp # time_byte1 = data[12] # time_byte2 = data[13] # time_byte3 = data[14] # time_byte4 = data[15] # time = time_byte1+time_byte2+time_byte3+time_byte4 # time = struct.unpack('>i', time) objid = None # 4 bytes will be unpacked to one single precision type (float) # byte1 = None byte2 = None byte3 = None byte4 = None # floatcontainer1-6 are xyz translation and xyz rotation # fcon1 = None #x tran fcon2 = None #y tran fcon3 = None #z tran fcon4 = None #x rot fcon5 = None #y rot fcon6 = None #z rot #array that holds segment parts segmentbox = [objid, fcon1, fcon2, fcon3, fcon4, fcon5, fcon6] # validate euler message # if len(data) == 668: #print("valid") # Beginning of the post-processing round # while index_pointer < 668: # object segment ID calculation # byte1 = data[index_pointer] #first round 24 index_pointer += 1 byte2 = data[index_pointer] index_pointer += 1 byte3 = data[index_pointer] index_pointer += 1 byte4 = data[index_pointer] #first round 27 index_pointer += 1 #print(byte1,byte2,byte3,byte4); #byte1 = struct.pack('B', byte1) #byte2 = struct.pack('B', byte2) #byte3 = struct.pack('B', byte3) #byte4 = struct.pack('B', byte4) segmentbox[segmentbox_pointer] = byte1+byte2+byte3+byte4 #print(byte1,byte2,byte3,byte4); segmentbox[segmentbox_pointer] = struct.unpack('>i', segmentbox[segmentbox_pointer]) #print("Current ID: ", segmentbox[segmentbox_pointer]); # place ID in 'item.ID' obarray[array_pointer].ID = segmentbox[segmentbox_pointer][0] # point to next part of the segment segmentbox_pointer += 1 # end of segment ID calculation # # Beginning of the 'float cycles' # for cycle in range(6): #print(index_pointer) byte1 = data[index_pointer] index_pointer += 1 byte2 = data[index_pointer] index_pointer += 1 byte3 = data[index_pointer] index_pointer += 1 byte4 = data[index_pointer] index_pointer += 1 #pack to unsigned bytes #byte1 = struct.pack('B', byte1) #byte2 = struct.pack('B', byte2) #byte3 = struct.pack('B', byte3) #byte4 = struct.pack('B', byte4) #merge into a fcon segmentbox[segmentbox_pointer] = byte1+byte2+byte3+byte4 segmentbox[segmentbox_pointer] = struct.unpack('>f', segmentbox[segmentbox_pointer]) #print(segmentbox[segmentbox_pointer]) # python has no switch statement .. # if cycle_counter == 1: obarray[array_pointer].tranx = segmentbox[segmentbox_pointer][0] cycle_counter += 1 elif cycle_counter == 2: obarray[array_pointer].trany = segmentbox[segmentbox_pointer][0] cycle_counter += 1 elif cycle_counter == 3: obarray[array_pointer].tranz = segmentbox[segmentbox_pointer][0] cycle_counter += 1 elif cycle_counter == 4: obarray[array_pointer].rotx = segmentbox[segmentbox_pointer][0] cycle_counter += 1 elif cycle_counter == 5: obarray[array_pointer].roty = segmentbox[segmentbox_pointer][0] cycle_counter += 1 elif cycle_counter == 6: obarray[array_pointer].rotz = segmentbox[segmentbox_pointer][0] cycle_counter = 1 #reset # point to next part of the segment segmentbox_pointer += 1 # at the end of the float cycles : #print(obarray[array_pointer]) obarray[array_pointer].trantuple = (obarray[array_pointer].tranx, obarray[array_pointer].trany, obarray[array_pointer].tranz) obarray[array_pointer].rotatuple = (obarray[array_pointer].rotx, obarray[array_pointer].roty, obarray[array_pointer].rotz) # point to next segment for post-processing array_pointer += 1 segmentbox_pointer = 0 #execute all known transformations #print("obarray before attribute setting", obarray) utils.executeInMainThreadWithResult(execute_transformations) utils.executeInMainThreadWithResult(execute_keyframe) frame += 1 else: #print("invalid") stop()
def invoke(*args, **kwargs): return utils.executeInMainThreadWithResult(*args, **kwargs)
def ExecuteFunction(func, *args, **kwargs): return utils.executeInMainThreadWithResult(func, *args, **kwargs)
def blast_background(self): utils.executeInMainThreadWithResult(self._blast_background_inner)
def execute_in_main_thread(*args, **kwargs): return utils.executeInMainThreadWithResult(*args, **kwargs)
def _FILE_Project(s): path = utils.executeInMainThreadWithResult(lambda: cmds.workspace(q=True, rd=True)) return path
def execute(self, func, *args): return utils.executeInMainThreadWithResult(func, *args)
def _FILE_Running(s): f = utils.executeInMainThreadWithResult(lambda: cmds.file(q=True, sn=True)) return f if f else ""
getattr(targetInstance, testMethodName)() finally: targetInstance.tearDown() def serverHandler(request): def mainThreadHandler(request): try: launch(**request) return {'result':'success'} except Exception,e: import traceback;traceback.print_exc() #return {'result':'exception','exception':pickle.dumps(e, pickle.HIGHEST_PROTOCOL)} return {'result':'exception','exception':base64.b64encode(pickle.dumps(e, pickle.HIGHEST_PROTOCOL)),'stackTrace':traceback.format_exc()} from maya.utils import executeInMainThreadWithResult return executeInMainThreadWithResult(mainThreadHandler,request) def mayaTest(setupModule): setupModule = sys.modules[setupModule] def decorator(cls): if not insideMaya: voidMethod = lambda *args,**kwargs:None setattr(cls,'setUp',voidMethod) setattr(cls, "tearDown", voidMethod) for methodName,method in list(inspect.getmembers(cls, inspect.ismethod))[:]: if not methodName.startswith("test"): continue
def threaded_wrapper(func, *args, **kwargs): return utils.executeInMainThreadWithResult(func, *args, **kwargs)
def UpdateThread(): userAppPath = utils.executeInMainThreadWithResult(GetUserAppPath) serverListPath = os.path.join(userAppPath, "server_list.tmp") serverStatusPath = os.path.join(userAppPath, "server_status.tmp") serverPortPath = os.path.join(userAppPath, "server_ports.tmp") serverSettingsPath = os.path.join(userAppPath, "vray_dr_list.xml") usesSingleFile = utils.executeInMainThreadWithResult( VrayUsesSingleSettingsFile) jobId = utils.executeInMainThreadWithResult(GetSpawnerJobId) portNumber = utils.executeInMainThreadWithResult(GetSpawnerPortNumber) while jobId != "": # Update the server list. useIpAddress = utils.executeInMainThreadWithResult(GetUseIpAddress) servers = CallDeadlineCommand([ "GetMachinesRenderingJob", jobId, "true" if useIpAddress else "false" ]) servers = servers.splitlines() utils.executeInMainThreadWithResult(UpdateServers, servers) # Update the job's state. jobState = "" jobInfo = CallDeadlineCommand(["GetJob", jobId, "false"]) for line in jobInfo.splitlines(): if line.startswith("Status="): jobState = line[7:] break if jobState == "Active": jobState = "Rendering" if len(servers) > 0 else "Queued" elif jobState == "": jobState = "Deleted" utils.executeInMainThreadWithResult(UpdateState, jobState) if not usesSingleFile: # Update the vray config file. serverText = "\n".join(servers) + "\n" enabledList = [] portNumberList = [] for i in range(0, len(servers)): enabledList.append("Enable") portNumberList.append(portNumber) enabledText = "\n".join(enabledList) + "\n" portNumberText = "\n".join(portNumberList) + "\n" try: with open(serverListPath, "w") as fileHandle: fileHandle.write(serverText) with open(serverPortPath, "w") as fileHandle: fileHandle.write(portNumberText) with open(serverStatusPath, "w") as fileHandle: fileHandle.write(enabledText) except: print(traceback.format_exc()) else: tree = ET.parse(serverSettingsPath) root = tree.getroot() for server in root.findall("server"): root.remove(server) for serverName in servers: curServer = ET.SubElement(root, "server") hostElement = ET.SubElement(curServer, "host") hostElement.text = serverName portElement = ET.SubElement(curServer, "port") portElement.text = portNumber aliasElement = ET.SubElement(curServer, "alias") enabledElement = ET.SubElement(curServer, "enabled") enabledElement.text = "1" tree.write(serverSettingsPath, encoding="UTF-8", xml_declaration=True) if jobState != "Rendering" and jobState != "Queued": utils.executeInMainThreadWithResult(NotifyJobStateChanged, jobState) else: time.sleep(5.0) jobId = utils.executeInMainThreadWithResult(GetSpawnerJobId)
def __getattr__(s, n): if hasattr(cmds, n): at = getattr(cmds, n) return lambda *a, **kw: utils.executeInMainThreadWithResult(lambda: at(*a, **kw)) raise AttributeError
def run(self): while(self.running): time.sleep(1.0/30.0) utils.executeInMainThreadWithResult(self.command)