Example #1
0
 def readHeadPositionBlock(self,f):
     headMatrix = faceshiftHelpers.quaternionToMatrix(struct.unpack('f',  f.read(4))[0],struct.unpack('f',  f.read(4))[0],struct.unpack('f',  f.read(4))[0]*-1,struct.unpack('f',  f.read(4))[0])
     transX=struct.unpack('f',  f.read(4))[0]
     transY=struct.unpack('f',  f.read(4))[0]
     transZ=struct.unpack('f',  f.read(4))[0]
     self.newFrame.headRotation=headMatrix
     self.newFrame.headPosition=c4d.Vector(transX,transY,transZ*-1)
Example #2
0
 def importFileTxt(self,datei):      
     #print datei
     f = open(datei, 'rb')
     allString=f.read()
     allFrames=allString.split("FS")
     frameCounter=1
     firstFrame=True
     firstKeyTime=0
     while frameCounter<len(allFrames):
             
         frame=allFrames[frameCounter].split("C ")
         frameHeader=frame[0].split(" ")
         shapes1=frame[1].split("E ")
         shapes=shapes1[0].split(" ")
         eyes=shapes1[1].split("M ")
         eyesList=eyes[0].split(" ")
         shapeCount=1
         frameSuccess=1
         if int(frameHeader[4])==1:
             if firstFrame==True:
                 firstFrame=False
                 firstKeyTime=float(frameHeader[3])
             newkeyTime=float(frameHeader[3])-firstKeyTime
             self.newFrame=faceShiftData.RecordetFrame(newkeyTime,frameHeader[4])
             self.exchangeData.doneRecTime=newkeyTime
             headMatrix = faceshiftHelpers.quaternionToMatrix(float(frameHeader[6]),float(frameHeader[7]),float(frameHeader[8]),float(frameHeader[9]))
             self.newFrame.headRotation=headMatrix
             self.newFrame.headPosition=c4d.Vector(float(frameHeader[10]),float(frameHeader[11]),float(frameHeader[12])*-1)
             self.newFrame.blendShapeValues=[]
             shapeCount=1
             while shapeCount<=int(shapes[0]):
                 self.newFrame.blendShapeValues.append(float(shapes[shapeCount]))
                 shapeCount+=1
             self.newFrame.eyeGazeValues=[]
             eyeCount=0
             while eyeCount<4:
                 self.newFrame.eyeGazeValues.append(float(eyesList[eyeCount]))
                 eyeCount+=1 
             self.exchangeData.recordetFrames.append(self.newFrame)
         frameCounter+=1
Example #3
0
    def readBlock(self, received, readerCnt):
        if self.workerThread.TestBreak():
            self.sock.close()
            return 0

        reciv = received[readerCnt + 1] + received[readerCnt + 2]
        readerCnt += 2
        blockID = struct.unpack('H', reciv)
        reciv = received[readerCnt + 1] + received[readerCnt + 2]
        readerCnt += 2
        versionNr = struct.unpack('H', reciv)
        reciv = received[readerCnt + 1] + received[readerCnt + 2] + received[
            readerCnt + 3] + received[readerCnt + 4]
        readerCnt += 4
        blockSize = struct.unpack('I', reciv)

        if blockID[0] == 101:
            reciv = received[readerCnt + 1] + received[
                readerCnt + 2] + received[readerCnt + 3] + received[
                    readerCnt + 4] + received[readerCnt + 5] + received[
                        readerCnt + 6] + received[readerCnt +
                                                  7] + received[readerCnt + 8]
            readerCnt += 8
            frameTime = struct.unpack('d', reciv)[0]
            reciv = received[readerCnt + 1]
            readerCnt += 1
            tracksuccess = struct.unpack('B', reciv)[0]
            self.exchangeData.frameSuccess = tracksuccess
            self.exchangeData.frameTime = frameTime
            if self.isRecordingInStream == True:
                if self.exchangeData.startRecTimeFS == -1:
                    self.exchangeData.startRecTimeFS = frameTime
                newFrameTime = frameTime - self.exchangeData.startRecTimeFS
                if newFrameTime > 0:
                    self.exchangeData.doneRecTime += (newFrameTime)
                self.exchangeData.startRecTimeFS = frameTime
                newRenderedFrame = faceShiftData.RecordetFrame(
                    self.exchangeData.doneRecTime, tracksuccess)
                if tracksuccess == 1:
                    self.exchangeData.recordetFrames.append(newRenderedFrame)
            #print "Frame - frameTime = "+str(frameTime)
            return readerCnt

        if blockID[0] == 102:
            reciv = received[readerCnt + 1] + received[
                readerCnt + 2] + received[readerCnt + 3] + received[readerCnt +
                                                                    4]
            readerCnt += 4
            quaternion1 = struct.unpack('f', reciv)[0]
            reciv = received[readerCnt + 1] + received[
                readerCnt + 2] + received[readerCnt + 3] + received[readerCnt +
                                                                    4]
            readerCnt += 4
            quaternion2 = struct.unpack('f', reciv)[0]
            reciv = received[readerCnt + 1] + received[
                readerCnt + 2] + received[readerCnt + 3] + received[readerCnt +
                                                                    4]
            readerCnt += 4
            quaternion3 = struct.unpack('f', reciv)[0]
            reciv = received[readerCnt + 1] + received[
                readerCnt + 2] + received[readerCnt + 3] + received[readerCnt +
                                                                    4]
            readerCnt += 4
            quaternion4 = struct.unpack('f', reciv)[0]
            reciv = received[readerCnt + 1] + received[
                readerCnt + 2] + received[readerCnt + 3] + received[readerCnt +
                                                                    4]
            readerCnt += 4
            transX = struct.unpack('f', reciv)[0]
            reciv = received[readerCnt + 1] + received[
                readerCnt + 2] + received[readerCnt + 3] + received[readerCnt +
                                                                    4]
            readerCnt += 4
            transY = struct.unpack('f', reciv)[0]
            reciv = received[readerCnt + 1] + received[
                readerCnt + 2] + received[readerCnt + 3] + received[readerCnt +
                                                                    4]
            readerCnt += 4
            transZ = struct.unpack('f', reciv)[0]
            newMatrix = faceshiftHelpers.quaternionToMatrix(
                float(quaternion1), float(quaternion2),
                float(quaternion3 * -1), float(quaternion4))
            self.exchangeData.rotationVector = (
                c4d.utils.MatrixToHPB(newMatrix))
            self.exchangeData.positionVector = (c4d.Vector(
                transX, transY, transZ * -1))
            if self.isRecordingInStream == True:
                self.exchangeData.recordetFrames[
                    len(self.exchangeData.recordetFrames) -
                    1].headRotation = newMatrix
                self.exchangeData.recordetFrames[
                    len(self.exchangeData.recordetFrames) -
                    1].headPosition = self.exchangeData.positionVector
            return readerCnt

        if blockID[0] == 103:  #Blendshapes
            reciv = received[readerCnt + 1] + received[
                readerCnt + 2] + received[readerCnt + 3] + received[readerCnt +
                                                                    4]
            readerCnt += 4
            blendShapesCnt = struct.unpack('I', reciv)
            bsCnt = 0
            self.exchangeData.blendShapes = []
            while bsCnt < blendShapesCnt[0]:
                reciv = received[readerCnt + 1] + received[
                    readerCnt + 2] + received[readerCnt +
                                              3] + received[readerCnt + 4]
                readerCnt += 4
                blendShapesValue = struct.unpack('f', reciv)[0]
                self.exchangeData.blendShapes.append(blendShapesValue)
                if self.isRecordingInStream == True:
                    self.exchangeData.recordetFrames[
                        len(self.exchangeData.recordetFrames) -
                        1].blendShapeValues.append(blendShapesValue)

                bsCnt += 1
                #print "Blendshapes - "+str(bsCnt)+" blendShapesValue = "+str(blendShapesValue)
            return readerCnt

        if blockID[0] == 104:  #Eyes
            self.exchangeData.eyeGazeValues = []
            reciv = received[readerCnt + 1] + received[
                readerCnt + 2] + received[readerCnt + 3] + received[readerCnt +
                                                                    4]
            readerCnt += 4
            pose1 = struct.unpack('f', reciv)[0]
            self.exchangeData.eyeGazeValues.append(pose1)
            reciv = received[readerCnt + 1] + received[
                readerCnt + 2] + received[readerCnt + 3] + received[readerCnt +
                                                                    4]
            readerCnt += 4
            pose2 = struct.unpack('f', reciv)[0]
            self.exchangeData.eyeGazeValues.append(pose2)
            reciv = received[readerCnt + 1] + received[
                readerCnt + 2] + received[readerCnt + 3] + received[readerCnt +
                                                                    4]
            readerCnt += 4
            pose3 = struct.unpack('f', reciv)[0]
            self.exchangeData.eyeGazeValues.append(pose3)
            reciv = received[readerCnt + 1] + received[
                readerCnt + 2] + received[readerCnt + 3] + received[readerCnt +
                                                                    4]
            readerCnt += 4
            pose4 = struct.unpack('f', reciv)[0]
            self.exchangeData.eyeGazeValues.append(pose4)
            if self.isRecordingInStream == True:
                self.exchangeData.recordetFrames[
                    len(self.exchangeData.recordetFrames) -
                    1].eyeGazeValues.append(pose1)
                self.exchangeData.recordetFrames[
                    len(self.exchangeData.recordetFrames) -
                    1].eyeGazeValues.append(pose2)
                self.exchangeData.recordetFrames[
                    len(self.exchangeData.recordetFrames) -
                    1].eyeGazeValues.append(pose3)
                self.exchangeData.recordetFrames[
                    len(self.exchangeData.recordetFrames) -
                    1].eyeGazeValues.append(pose4)
            return readerCnt

        if blockID[0] == 105:  #Markers
            reciv = received[readerCnt + 1] + received[readerCnt + 2]
            readerCnt += 2
            blendShapesCnt = struct.unpack('H', reciv)
            bsCnt = 0
            while bsCnt < blendShapesCnt[0]:
                reciv = received[readerCnt + 1] + received[
                    readerCnt + 2] + received[readerCnt +
                                              3] + received[readerCnt + 4]
                readerCnt += 4
                markerx = struct.unpack('f', reciv)
                reciv = received[readerCnt + 1] + received[
                    readerCnt + 2] + received[readerCnt +
                                              3] + received[readerCnt + 4]
                readerCnt += 4
                markery = struct.unpack('f', reciv)
                reciv = received[readerCnt + 1] + received[
                    readerCnt + 2] + received[readerCnt +
                                              3] + received[readerCnt + 4]
                readerCnt += 4
                markerz = struct.unpack('f', reciv)
                newMarker = c4d.Vector(markerx[0], markery[0], markerz[0])
                self.exchangeData.markers.append(newMarker)
                if self.isRecordingInStream == True:
                    self.exchangeData.recordetFrames[
                        len(self.exchangeData.recordetFrames) -
                        1].markerPositions.append(newMarker)
                bsCnt += 1
            return readerCnt
        return readerCnt
    def readBlock(self,received,readerCnt): 
        if self.workerThread.TestBreak():
            self.sock.close()
            return 0          
		
        reciv=received[readerCnt+1]+received[readerCnt+2]
        readerCnt+=2
        blockID=struct.unpack('H', reciv)                    
        reciv=received[readerCnt+1]+received[readerCnt+2]
        readerCnt+=2
        versionNr=struct.unpack('H', reciv)        
        reciv=received[readerCnt+1]+received[readerCnt+2]+received[readerCnt+3]+received[readerCnt+4]
        readerCnt+=4
        blockSize=struct.unpack('I', reciv)
        
        if blockID[0]==101:
            reciv=received[readerCnt+1]+received[readerCnt+2]+received[readerCnt+3]+received[readerCnt+4]+received[readerCnt+5]+received[readerCnt+6]+received[readerCnt+7]+received[readerCnt+8]
            readerCnt+=8
            frameTime=struct.unpack('d', reciv)[0]
            reciv=received[readerCnt+1]
            readerCnt+=1
            tracksuccess=struct.unpack('B', reciv)[0]
            self.exchangeData.frameSuccess=tracksuccess
            self.exchangeData.frameTime=frameTime
            if self.isRecordingInStream==True:
                if self.exchangeData.startRecTimeFS==-1:
                    self.exchangeData.startRecTimeFS=frameTime
                newFrameTime=frameTime-self.exchangeData.startRecTimeFS
                if newFrameTime>0:
                    self.exchangeData.doneRecTime+=(newFrameTime)
                self.exchangeData.startRecTimeFS=frameTime
                newRenderedFrame=faceShiftData.RecordetFrame(self.exchangeData.doneRecTime,tracksuccess)
                if tracksuccess==1:
                    self.exchangeData.recordetFrames.append(newRenderedFrame)
            #print "Frame - frameTime = "+str(frameTime)
            return readerCnt
        
        if blockID[0]==102:
            reciv=received[readerCnt+1]+received[readerCnt+2]+received[readerCnt+3]+received[readerCnt+4]
            readerCnt+=4
            quaternion1=struct.unpack('f', reciv)[0]
            reciv=received[readerCnt+1]+received[readerCnt+2]+received[readerCnt+3]+received[readerCnt+4]
            readerCnt+=4
            quaternion2=struct.unpack('f', reciv)[0]
            reciv=received[readerCnt+1]+received[readerCnt+2]+received[readerCnt+3]+received[readerCnt+4]
            readerCnt+=4
            quaternion3=struct.unpack('f', reciv)[0]
            reciv=received[readerCnt+1]+received[readerCnt+2]+received[readerCnt+3]+received[readerCnt+4]
            readerCnt+=4
            quaternion4=struct.unpack('f', reciv)[0]
            reciv=received[readerCnt+1]+received[readerCnt+2]+received[readerCnt+3]+received[readerCnt+4]
            readerCnt+=4
            transX=struct.unpack('f', reciv)[0]
            reciv=received[readerCnt+1]+received[readerCnt+2]+received[readerCnt+3]+received[readerCnt+4]
            readerCnt+=4
            transY=struct.unpack('f', reciv)[0]
            reciv=received[readerCnt+1]+received[readerCnt+2]+received[readerCnt+3]+received[readerCnt+4]
            readerCnt+=4
            transZ=struct.unpack('f', reciv)[0]
            newMatrix = faceshiftHelpers.quaternionToMatrix(float(quaternion1),float(quaternion2),float(quaternion3*-1),float(quaternion4))
            self.exchangeData.rotationVector=(c4d.utils.MatrixToHPB(newMatrix))
            self.exchangeData.positionVector=(c4d.Vector(transX,transY,transZ*-1))
            if self.isRecordingInStream==True:
                self.exchangeData.recordetFrames[len(self.exchangeData.recordetFrames)-1].headRotation=newMatrix
                self.exchangeData.recordetFrames[len(self.exchangeData.recordetFrames)-1].headPosition=self.exchangeData.positionVector
            return readerCnt
            
        if blockID[0]==103:#Blendshapes
            reciv=received[readerCnt+1]+received[readerCnt+2]+received[readerCnt+3]+received[readerCnt+4]
            readerCnt+=4
            blendShapesCnt=struct.unpack('I', reciv)
            bsCnt=0
            self.exchangeData.blendShapes=[]
            while bsCnt<blendShapesCnt[0]:
                reciv=received[readerCnt+1]+received[readerCnt+2]+received[readerCnt+3]+received[readerCnt+4]
                readerCnt+=4
                blendShapesValue=struct.unpack('f', reciv)[0]
                self.exchangeData.blendShapes.append(blendShapesValue)
                if self.isRecordingInStream==True:
                    self.exchangeData.recordetFrames[len(self.exchangeData.recordetFrames)-1].blendShapeValues.append(blendShapesValue)
                
                bsCnt+=1
                #print "Blendshapes - "+str(bsCnt)+" blendShapesValue = "+str(blendShapesValue)
            return readerCnt
                
        if blockID[0]==104:#Eyes
            self.exchangeData.eyeGazeValues=[]
            reciv=received[readerCnt+1]+received[readerCnt+2]+received[readerCnt+3]+received[readerCnt+4]
            readerCnt+=4
            pose1=struct.unpack('f', reciv)[0]
            self.exchangeData.eyeGazeValues.append(pose1)
            reciv=received[readerCnt+1]+received[readerCnt+2]+received[readerCnt+3]+received[readerCnt+4]
            readerCnt+=4
            pose2=struct.unpack('f', reciv)[0]
            self.exchangeData.eyeGazeValues.append(pose2)
            reciv=received[readerCnt+1]+received[readerCnt+2]+received[readerCnt+3]+received[readerCnt+4]
            readerCnt+=4
            pose3=struct.unpack('f', reciv)[0]
            self.exchangeData.eyeGazeValues.append(pose3)
            reciv=received[readerCnt+1]+received[readerCnt+2]+received[readerCnt+3]+received[readerCnt+4]
            readerCnt+=4
            pose4=struct.unpack('f', reciv)[0]
            self.exchangeData.eyeGazeValues.append(pose4)
            if self.isRecordingInStream==True:
                self.exchangeData.recordetFrames[len(self.exchangeData.recordetFrames)-1].eyeGazeValues.append(pose1)
                self.exchangeData.recordetFrames[len(self.exchangeData.recordetFrames)-1].eyeGazeValues.append(pose2)
                self.exchangeData.recordetFrames[len(self.exchangeData.recordetFrames)-1].eyeGazeValues.append(pose3)
                self.exchangeData.recordetFrames[len(self.exchangeData.recordetFrames)-1].eyeGazeValues.append(pose4)
            return readerCnt
            
        if blockID[0]==105:#Markers
            reciv=received[readerCnt+1]+received[readerCnt+2]
            readerCnt+=2
            blendShapesCnt=struct.unpack('H', reciv)
            bsCnt=0
            while bsCnt<blendShapesCnt[0]:
                reciv=received[readerCnt+1]+received[readerCnt+2]+received[readerCnt+3]+received[readerCnt+4]
                readerCnt+=4
                markerx=struct.unpack('f', reciv)
                reciv=received[readerCnt+1]+received[readerCnt+2]+received[readerCnt+3]+received[readerCnt+4]
                readerCnt+=4
                markery=struct.unpack('f', reciv)
                reciv=received[readerCnt+1]+received[readerCnt+2]+received[readerCnt+3]+received[readerCnt+4]
                readerCnt+=4
                markerz=struct.unpack('f', reciv)
                newMarker=c4d.Vector(markerx[0],markery[0],markerz[0])
                self.exchangeData.markers.append(newMarker)
                if self.isRecordingInStream==True:
                    self.exchangeData.recordetFrames[len(self.exchangeData.recordetFrames)-1].markerPositions.append(newMarker)
                bsCnt+=1
            return readerCnt
        return readerCnt