示例#1
0
class Project:
    def __init__(self, options):
        self.options = options
        self.process = Process()

    def date(self):
        self._get_date()

    def _get_date(self):
        print self.process.execute("date")
示例#2
0
class Project:

  def __init__(self, options):
    self.options = options
    self.process = Process()
    
  def date(self):
    self._get_date()

  def _get_date(self):
    print self.process.execute("date")
示例#3
0
    def resetImageDataWindow(self, imageName, oiiotoolPath):
        editor = cmds.renderWindowEditor(q=True, editorName=True)
        if editor:
            renderRegion = cmds.renderWindowEditor(editor, q=True, mq=True)
            if renderRegion:
                left = cmds.getAttr("defaultRenderGlobals.left")
                right = cmds.getAttr("defaultRenderGlobals.rght")
                top = cmds.getAttr("defaultRenderGlobals.top")
                bottom = cmds.getAttr("defaultRenderGlobals.bot")

                imageWidth = cmds.getAttr("defaultResolution.width")
                imageHeight = cmds.getAttr("defaultResolution.height")

                pathTokens = os.path.splitext(imageName)
                imageNameCropped = "%s_crop%s" % (pathTokens[0], pathTokens[1])

                oiiotoolResult = None
                try:
                    #print( "Generating cropped image : %s" % imageNameCropped )

                    #oiiotool picks up on the PBRT EXR's pixel data origin, so
                    #we don't have to do anything fancy here
                    cropArgs = '%dx%d-%d-%d' % (imageWidth, imageHeight, 0, 0)

                    args = [
                        '-v', imageName, '--crop', cropArgs, '--noautocrop',
                        '-o', imageNameCropped
                    ]
                    oiiotool = Process(description='reset image data window',
                                       cmd=oiiotoolPath,
                                       args=args)
                    oiiotool.execute()
                    oiiotoolResult = oiiotool.status
                    #print( "oiiotool result : %s" % oiiotoolResult )
                except:
                    print("Unable to run oiiotool")
                    oiiotoolResult = None

                # Move the image with the new data window over the original rendered image
                if oiiotoolResult in [0, None]:
                    # Useful for debugging
                    #imageNameOriginal = "%s_uncropped%s" % (pathTokens[0], pathTokens[1])
                    #os.rename(imageName, imageNameOriginal)

                    os.rename(imageNameCropped, imageName)
    def resetImageDataWindow(self, imageName, oiiotoolPath):
        editor = cmds.renderWindowEditor(q=True, editorName=True)
        #print( "resetImageDataWindow - editor : %s" % editor )
        if editor:
            renderRegion = cmds.renderWindowEditor(editor, q=True, mq=True)
            #print( "resetImageDataWindow - render region : %s" % renderRegion )
            if renderRegion:
                left = cmds.getAttr("defaultRenderGlobals.left")
                right = cmds.getAttr("defaultRenderGlobals.rght")
                top = cmds.getAttr("defaultRenderGlobals.top")
                bottom = cmds.getAttr("defaultRenderGlobals.bot")

                imageWidth = cmds.getAttr("defaultResolution.width")
                imageHeight = cmds.getAttr("defaultResolution.height")

                pathTokens = os.path.splitext(imageName)
                imageNameCropped = "%s_crop%s" % (pathTokens[0], pathTokens[1])
                #print( "Generating cropped image : %s" % imageNameCropped )

                oiiotoolResult = None
                try:
                    #cmd = '/usr/local/bin/oiiotool'
                    cropArgs = '%dx%d-%d-%d' % (imageWidth, imageHeight, left,
                                                imageHeight - top)
                    args = [
                        '-v', imageName, '--crop', cropArgs, '--noautocrop',
                        '-o', imageNameCropped
                    ]
                    oiiotool = Process(description='reset image data window',
                                       cmd=oiiotoolPath,
                                       args=args)
                    oiiotool.execute()
                    oiiotoolResult = oiiotool.status
                    #print( "oiiotool result : %s" % oiiotoolResult )
                except:
                    print("Unable to run oiiotool")
                    oiiotoolResult = None

                # Move the image with the new data window over the original rendered image
                if oiiotoolResult in [0, None]:
                    os.rename(imageNameCropped, imageName)
示例#5
0
class Project:
    def __init__(self, options):
        self.options = options
        self.process = Process()

    def date(self):
        return self._get_date()

    def _get_date(self):
        return self.process.execute("date").rstrip('\n')

    def print_example_arg(self):
        return self.options.known.example
示例#6
0
class Scramble:

    def __init__(self, options):
        self.options = options
        self.process = Process()

    def date(self):
        self._get_date()

    def _get_date(self):
        print self.process.execute("date")

    def print_example_arg(self):
        print self.options.example

    def scramble(self):
       ''' Scramble core function '''
       var_scramble = self.options.example
       var_len = len(var_scramble)
       all_permuts = itertools.permutations(var_scramble,
                                            var_len)
       for item in list(set(all_permuts)):
           print '{0}'.format(''.join(item))
示例#7
0
    def resetImageDataWindow(self, imageName, oiiotoolPath):
        editor = cmds.renderWindowEditor(q=True, editorName=True )
        #print( "resetImageDataWindow - editor : %s" % editor )
        if editor:
            renderRegion = cmds.renderWindowEditor(editor, q=True, mq=True)
            #print( "resetImageDataWindow - render region : %s" % renderRegion )
            if renderRegion:
                left = cmds.getAttr( "defaultRenderGlobals.left" )
                right = cmds.getAttr( "defaultRenderGlobals.rght" )
                top = cmds.getAttr( "defaultRenderGlobals.top" )
                bottom = cmds.getAttr( "defaultRenderGlobals.bot" )
            
                imageWidth = cmds.getAttr("defaultResolution.width")
                imageHeight = cmds.getAttr("defaultResolution.height")

                pathTokens = os.path.splitext(imageName)
                imageNameCropped = "%s_crop%s" % (pathTokens[0], pathTokens[1])
                #print( "Generating cropped image : %s" % imageNameCropped )

                oiiotoolResult = None
                try:
                    #cmd = '/usr/local/bin/oiiotool'
                    cropArgs = '%dx%d-%d-%d' % (imageWidth, imageHeight, left, imageHeight-top)
                    args = ['-v', imageName, '--crop', cropArgs, '--noautocrop', '-o', imageNameCropped]
                    oiiotool = Process(description='reset image data window',
                        cmd=oiiotoolPath,
                        args=args)
                    oiiotool.execute()
                    oiiotoolResult = oiiotool.status
                    #print( "oiiotool result : %s" % oiiotoolResult )
                except:
                    print( "Unable to run oiiotool" )
                    oiiotoolResult = None

                # Move the image with the new data window over the original rendered image
                if oiiotoolResult in [0, None]:
                    os.rename(imageNameCropped, imageName)
示例#8
0
class Project:
    def __init__(self, options):
        self.options = options
        self.process = Process()

    def date(self):
        return self._get_date()

    def _get_date(self):
        # prints stdout of subprocess with command "date"
        # strips tailing endoflines because print adds one
        return self.process.execute("date").rstrip('\n')

    def print_example_arg(self):
        return self.options.known.example
示例#9
0
class Project:

    def __init__(self, options):
        self.options = options
        self.process = Process()

    def date(self):
        return self._get_date()

    def _get_date(self):
        # prints stdout of subprocess with command "date"
        # strips tailing endoflines because print adds one
        return self.process.execute("date").rstrip('\n')

    def print_example_arg(self):
        return self.options.known.example
示例#10
0
    def renderScene(self,
                    outFileName,
                    renderDir,
                    cyclesPath,
                    oiiotoolPath,
                    mtsDir,
                    keepTempFiles,
                    geometryFiles,
                    animation=False,
                    frame=1,
                    verbose=False,
                    renderSettings=None):
        imageDir = os.path.join(os.path.split(renderDir)[0], 'images')
        os.chdir(imageDir)

        sceneName = self.getScenePrefix()

        imagePrefix = cmds.getAttr("defaultRenderGlobals.imageFilePrefix")
        if imagePrefix is None:
            imagePrefix = sceneName

        writePartialResults = False
        writePartialResultsInterval = -1
        blockSize = 32
        threads = 0
        if renderSettings:
            extension = getImageExtension(renderSettings)

            writePartialResults = cmds.getAttr(
                "%s.%s" % (renderSettings, "writePartialResults"))
            writePartialResultsInterval = cmds.getAttr(
                "%s.%s" % (renderSettings, "writePartialResultsInterval"))
            blockSize = cmds.getAttr("%s.%s" % (renderSettings, "blockSize"))
            threads = cmds.getAttr("%s.%s" % (renderSettings, "threads"))

            print("Render Settings - Partial Results  : %s" %
                  writePartialResults)
            print("Render Settings - Results Interval : %s" %
                  writePartialResultsInterval)
            print("Render Settings - Block Size       : %s" % blockSize)
            if threads:
                print("Render Settings - Threads          : %s" % threads)

        if animation:
            extensionPadding = cmds.getAttr(
                "defaultRenderGlobals.extensionPadding")
            logName = os.path.join(
                imageDir, imagePrefix + "." +
                str(frame).zfill(extensionPadding) + ".log")
            imageName = os.path.join(
                imageDir, imagePrefix + "." +
                str(frame).zfill(extensionPadding) + "." + extension)
        else:
            logName = os.path.join(imageDir, imagePrefix + ".log")
            imageName = os.path.join(imageDir, imagePrefix + "." + extension)

        args = []
        if verbose:
            args.append('-v')
        if writePartialResults:
            args.extend(['-r', str(writePartialResultsInterval)])
        if threads:
            args.extend(['-p', str(threads)])
        args.extend(['-b', str(blockSize), '-o', imageName, outFileName])

        imageWidth = cmds.getAttr("defaultResolution.width")
        imageHeight = cmds.getAttr("defaultResolution.height")
        args.extend(['--width', imageWidth])
        args.extend(['--height', imageHeight])
        args = ['--output', imageName]
        args.extend([outFileName])

        if ' ' in mtsDir:
            env = {"LD_LIBRARY_PATH": str("\"%s\"" % mtsDir)}
        else:
            env = {"LD_LIBRARY_PATH": str(mtsDir)}

        env.update({"DISPLAY": os.environ.get("DISPLAY", ":0.0")})
        env.update({"PATH": os.environ.get("PATH")})

        cyclesRender = Process(description='render an image',
                               cmd=cyclesPath,
                               args=args,
                               env=env,
                               non_blocking=True)

        def renderLogCallback(line):
            if "Writing image" in line:
                imageName = line.split("\"")[-2]

                # Display the render
                #if not cmds.about(batch=True):
                #    CyclesRendererUI.showRender(imageName)

        cyclesRender.log_callback = renderLogCallback
        #cyclesRender.echo = False

        cyclesRender.execute()
        cyclesRender.write_log_to_disk(logName, format='txt')

        print("Render execution returned : %s" % cyclesRender.status)

        if oiiotoolPath != "":
            self.resetImageDataWindow(imageName, oiiotoolPath)

        if not keepTempFiles:
            #Delete all of the temp file we just made
            os.chdir(renderDir)
            for geometryFile in geometryFiles:
                try:
                    #print( "Removing geometry : %s" % geometryFile )
                    os.remove(geometryFile)
                except:
                    print("Error removing temporary file : %s" % geometryFile)
            #print( "Removing cycles scene description : %s" % outFileName )
            os.remove(outFileName)
            #os.remove(logName)
        else:
            print("Keeping temporary files")

        return imageName
示例#11
0
    def renderScene(self,
                    outFileName, 
                    renderDir, 
                    mitsubaPath,
                    oiiotoolPath, 
                    mtsDir, 
                    keepTempFiles, 
                    geometryFiles, 
                    animation=False, 
                    frame=1, 
                    verbose=False,
                    renderSettings=None):
        imageDir = os.path.join(os.path.split(renderDir)[0], 'images')
        os.chdir(imageDir)

        sceneName = self.getScenePrefix()

        imagePrefix = cmds.getAttr("defaultRenderGlobals.imageFilePrefix")
        if imagePrefix is None:
            imagePrefix = sceneName

        writePartialResults = False
        writePartialResultsInterval = -1
        blockSize = 32
        threads = 0
        if renderSettings:
            extension = getImageExtension(renderSettings)

            writePartialResults = cmds.getAttr("%s.%s" % (renderSettings, "writePartialResults"))
            writePartialResultsInterval = cmds.getAttr("%s.%s" % (renderSettings, "writePartialResultsInterval"))
            blockSize = cmds.getAttr("%s.%s" % (renderSettings, "blockSize"))
            threads = cmds.getAttr("%s.%s" % (renderSettings, "threads"))

            print( "Render Settings - Partial Results  : %s" % writePartialResults )
            print( "Render Settings - Results Interval : %s" % writePartialResultsInterval )
            print( "Render Settings - Block Size       : %s" % blockSize )
            if threads:
                print( "Render Settings - Threads          : %s" % threads )

        if animation:
            extensionPadding = cmds.getAttr("defaultRenderGlobals.extensionPadding")
            logName = os.path.join(imageDir, imagePrefix + "." + str(frame).zfill(extensionPadding) +".log")
            imageName = os.path.join(imageDir, imagePrefix + "." + str(frame).zfill(extensionPadding) + "." + extension)
        else:
            logName = os.path.join(imageDir, imagePrefix + ".log")
            imageName = os.path.join(imageDir, imagePrefix + "." + extension)

        args = []
        if verbose:
            args.append('-v')
        if writePartialResults:
            args.extend(['-r', str(writePartialResultsInterval)])
        if threads:
            args.extend(['-p', str(threads)])
        args.extend([
            '-b', str(blockSize), 
            '-o',
            imageName,
            outFileName])

        if ' ' in mtsDir:
            env = {"LD_LIBRARY_PATH":str("\"%s\"" % mtsDir)}
        else:
            env = {"LD_LIBRARY_PATH":str(mtsDir)}

        mitsubaRender = Process(description='render an image',
            cmd=mitsubaPath,
            args=args,
            env=env)

        def renderLogCallback(line):
            if "Writing image" in line:
                imageName = line.split("\"")[-2]

                # Display the render
                if not cmds.about(batch=True):
                    MitsubaRendererUI.showRender(imageName)

        mitsubaRender.log_callback = renderLogCallback
        #mitsubaRender.echo = False

        mitsubaRender.execute()
        mitsubaRender.write_log_to_disk(logName, format='txt')

        print( "Render execution returned : %s" % mitsubaRender.status )

        if oiiotoolPath != "":
            self.resetImageDataWindow(imageName, oiiotoolPath)

        if not keepTempFiles:
            #Delete all of the temp file we just made
            os.chdir(renderDir)
            for geometryFile in geometryFiles:
                try:
                    #print( "Removing geometry : %s" % geometryFile )
                    os.remove(geometryFile)
                except:
                    print( "Error removing temporary file : %s" % geometryFile )
            #print( "Removing mitsuba scene description : %s" % outFileName )
            os.remove(outFileName)
            #os.remove(logName)
        else:
            print( "Keeping temporary files" )

        return imageName
示例#12
0
    def renderScene(self,
                    sceneFileName,
                    renderDir,
                    PBRTPath,
                    oiiotoolPath,
                    pbrtDir,
                    keepTempFiles,
                    geometryFiles,
                    animation=False,
                    frame=1,
                    verboseRender=0,
                    verboseExport=False,
                    renderSettings=None,
                    commandLineParameters=None):
        projectDir = cmds.workspace(q=True, fn=True)
        imageDir = os.path.join(projectDir, "images")
        os.chdir(imageDir)

        sceneName = self.getScenePrefix()

        imagePrefix = cmds.getAttr("defaultRenderGlobals.imageFilePrefix")
        if imagePrefix is None:
            imagePrefix = sceneName

        writePartialResults = False
        writePartialResultsInterval = -1
        blockSize = 32
        threads = 0
        extension = 'exr'
        if renderSettings:
            extension = getImageExtension(renderSettings)

            threads = cmds.getAttr("%s.%s" % (renderSettings, "threads"))
            if threads:
                print("Render Settings - Threads          : %s" % threads)

            # pbrt version
            PBRTVersion = cmds.getAttr("%s.%s" %
                                       (renderSettings, "PBRTVersion"))
            print("Render Settings - Version          : %s" % PBRTVersion)

        if animation:
            extensionPadding = cmds.getAttr(
                "defaultRenderGlobals.extensionPadding")
            logName = os.path.join(
                imageDir, imagePrefix + "." +
                str(frame).zfill(extensionPadding) + ".log")
            imageName = os.path.join(
                imageDir, imagePrefix + "." +
                str(frame).zfill(extensionPadding) + "." + extension)
        else:
            logName = os.path.join(imageDir, imagePrefix + ".log")
            imageName = os.path.join(imageDir, imagePrefix + "." + extension)

        imageNameLocal = os.path.relpath(imageName, imageDir)
        sceneFileNameLocal = os.path.relpath(sceneFileName, imageDir)

        args = []
        if verboseRender >= 0:
            if PBRTVersion == "v3 Book":
                if verboseRender == 0:
                    args.append('--quiet')
                else:
                    args.append('--verbose')
            else:
                if verboseRender == 0:
                    args.append('--quiet')
                elif verboseRender > 1:
                    args.extend(
                        ['--v', str(verboseRender - 2), '--logtostderr'])

        if threads:
            args.extend(['--nthreads', str(threads)])

        if commandLineParameters:
            args.extend(commandLineParameters.split())

        args.extend(['--outfile', imageNameLocal, sceneFileNameLocal])

        if ' ' in pbrtDir:
            env = {"LD_LIBRARY_PATH": str("\"%s\"" % pbrtDir)}
        else:
            env = {"LD_LIBRARY_PATH": str(pbrtDir)}

        PBRTRender = Process(description='render an image',
                             cmd=PBRTPath,
                             args=args,
                             env=env)

        #PBRTRender.echo = False
        PBRTRender.execute()
        PBRTRender.write_log_to_disk(logName, format='txt')

        print("Render execution returned : %s" % PBRTRender.status)

        if oiiotoolPath != "":
            self.resetImageDataWindow(imageName, oiiotoolPath)

        if not keepTempFiles:
            #Delete all of the temp file we just made
            os.chdir(renderDir)
            for geometryFile in list(set(geometryFiles)):
                try:
                    print("Removing geometry : %s" % geometryFile)
                    os.remove(geometryFile)
                except:
                    print("Error removing temporary file : %s" % geometryFile)
            print("Removing PBRT scene description : %s" % sceneFileName)
            os.remove(sceneFileName)
            print("Removing PBRT render log        : %s" % logName)
            os.remove(logName)
        else:
            print("Keeping temporary files")

        return imageName
class Survey:

    def __init__(self, options):
        self.options = options
        self.process = Process()
        self.survey = pd
        self.survey.set_option('expand_frame_repr', False)

    def date(self):
        return self._get_date()

    def _get_date(self):
        # prints stdout of subprocess with command "date"
        # strips tailing endoflines because print adds one
        return self.process.execute("date").rstrip('\n')

    def print_example_arg(self):
        print self.options.known
        return self.options.known.datafile
    
    def parse_surveydata(self):
        try:
            emp = self.survey.read_csv(self.options.known.datafile)
        except IOError:
            print "\nIO exception occured, check if the file exists input filename", self.options.known.datafile
            emp = []
        return emp

    def parse_responces(self):
        try:
            resp = self.survey.read_csv(self.options.known.responces, names=['Email', 'EmployeeId', 'Submitted At Timestamp', 'ANS_Q1', 'ANS_Q2', 'ANS_Q3', 'ANS_Q4', 'ANS_Q5'],)
        except IOError:
            print "\nIO exception occured heck if the file exists, input filename: ", self.options.known.responces
            resp = []
        return resp

    def submission_percentage(self):
        resp = self.parse_responces()
        print resp
        count = 0.0
        
        for t in resp['Submitted At Timestamp']:
            ts = str(t)
            if "nan" not in ts:
                count = count + 1
        return count/len(resp)

    def submission_count_total(self):
        resp = self.parse_responces()
        count = 0.0
        for t in resp['Submitted At Timestamp']:
            ts = str(t)
            if "nan" not in ts:
                count = count + 1
        return count

    def total_rating_perq(self, qname):
        resp = self.parse_responces()
        return resp[qname].sum()

    def avg_rating(self, qname):
        if self.is_ratingq(qname):
          return self.total_rating_perq(qname)/self.submission_count_total()
        else: 
          return "Not a rating question"

    def is_ratingq(self,qname):
        resp = self.parse_responces()
        if np.issubdtype(resp[qname].dtypes, np.number):
            return True
        else:
            return False