Exemplo n.º 1
0
    def drawSkeleton(self):
        self._unloadSkeletonMesh()

        skel = self.human.getSkeleton()
        if not skel:
            return

        # Create a mesh from the user-selected skeleton in its current pose (so we use the base skeleton for actually posing)
        self.skelMesh = skeleton_drawing.meshFromSkeleton(skel, "Prism")
        self.skelMesh.name = self.skelMesh.name + '-skeletonDebug'
        self.skelMesh.priority = 100
        self.skelMesh.setPickable(False)
        self.skelObj = self.addObject(
            gui3d.Object(self.skelMesh, self.human.getPosition()))
        self.skelObj.setShadeless(0)
        self.skelObj.setSolid(0)
        self.skelObj.setRotation(self.human.getRotation())
        self.skelMesh.setVisibility(self.showBonesTggl.selected)

        self.axisMesh = skeleton_drawing.meshFromSkeleton(skel, "axis")
        self.axisMesh.name = self.axisMesh.name + '-axis-skeletonDebug'
        self.axisMesh.priority = 100
        self.axisMesh.setPickable(False)
        self.axisObj = self.addObject(
            gui3d.Object(self.axisMesh, self.human.getPosition()))
        self.axisObj.material.ambientColor = [0.2, 0.2, 0.2]
        self.axisObj.material.configureShading(vertexColors=True)
        self.axisObj.material.depthless = True
        self.axisObj.setRotation(self.human.getRotation())
        self.axisObj.setVisibility(self.showAxisTggl.selected)

        self.drawPlanes(skel)

        mh.redraw()
Exemplo n.º 2
0
    def drawSkeleton(self, skel):
        if self.skelObj:
            # Remove old skeleton mesh
            self.removeObject(self.skelObj)
            self.human.removeBoundMesh(self.skelObj.name)
            self.skelObj = None
            self.skelMesh = None
            self.selectedBone = None

        if not skel:
            return

        # Create a mesh from the skeleton in rest pose
        skel.setToRestPose(
        )  # Make sure skeleton is in rest pose when constructing the skeleton mesh
        self.skelMesh = skeleton_drawing.meshFromSkeleton(skel, "Prism")
        self.skelMesh.name = 'SkeletonMesh-poseLibrary'
        self.skelMesh.priority = 100
        self.skelMesh.setPickable(False)
        self.skelObj = self.addObject(
            gui3d.Object(self.skelMesh, self.human.getPosition()))
        self.skelObj.setShadeless(0)
        self.skelObj.setSolid(0)
        self.skelObj.setRotation(self.human.getRotation())

        # Add the skeleton mesh to the human AnimatedMesh so it animates together with the skeleton
        # The skeleton mesh is supposed to be constructed from the skeleton in rest and receives
        # rigid vertex-bone weights (for each vertex exactly one weight of 1 to one bone)
        mapping = skeleton_drawing.getVertBoneMapping(skel, self.skelMesh)
        self.human.addBoundMesh(self.skelMesh, mapping)

        # Store a reference to the skeleton mesh object for other plugins
        self.human.getSkeleton().object = self.skelObj
        mh.redraw()
Exemplo n.º 3
0
    def finishBuild(self, location):
        coord = []
        faces = []
        group = []
        for name, p, f in self._data:
            fg = self.mesh.createFaceGroup(name)
            coord.append(p)
            faces.append(f)
            group.append(np.zeros(len(f), dtype=np.uint16) + fg.idx)
        del self._data

        self.coords = np.vstack(coord)
        log.debug("finishBuild: %d %d", len(coord), len(self.coords))
        self.mesh.setCoords(self.coords)
        self.mesh.setUVs(np.zeros((1, 2), dtype=np.float32))
        self.mesh.setFaces(np.vstack(faces), None, np.hstack(group))

        self.mesh.setCameraProjection(0)
        self.mesh.setShadeless(0)
        self.mesh.setSolid(0)
        self.mesh.calcNormals()
        self.mesh.updateIndexBuffer()
        self.mesh.priority = 30

        self.object = gui3d.app.addObject(gui3d.Object(location, self.mesh))

        for fg in self.mesh.faceGroups:
            if not fg.parent:
                log.debug("finishBuild: %s %s", fg, fg.parent)
                halt
        return self.object
Exemplo n.º 4
0
    def drawJointHelpers(self):
        """
        Draw the joint helpers from the basemesh that define the default or
        reference rig.
        """
        if self.jointsObj:
            self.removeObject(self.jointsObj)
            self.jointsObj = None
            self.jointsMesh = None
            self.selectedJoint = None

        jointPositions = []
        # TODO maybe define a getter for this list in the skeleton module
        jointGroupNames = [group.name for group in self.human.meshData.faceGroups if group.name.startswith("joint-")]
        if self.human.getSkeleton():
            jointGroupNames += self.human.getSkeleton().joint_pos_idxs.keys()
            for groupName in jointGroupNames:
                jointPositions.append(self.human.getSkeleton().getJointPosition(groupName, self.human))
        else:
            for groupName in jointGroupNames:
                jointPositions.append(skeleton._getHumanJointPosition(self.human, groupName))

        self.jointsMesh = skeleton_drawing.meshFromJoints(jointPositions, jointGroupNames)
        self.jointsMesh.priority = 100
        self.jointsMesh.setPickable(False)
        self.jointsObj = self.addObject( gui3d.Object(self.jointsMesh, self.human.getPosition()) )
        self.jointsObj.setRotation(self.human.getRotation())

        color = np.asarray([255, 255, 0, 255], dtype=np.uint8)
        self.jointsMesh.color[:] = color[None,:]
        self.jointsMesh.markCoords(colr=True)
        self.jointsMesh.sync_color()

        mh.redraw()
Exemplo n.º 5
0
    def drawSkeleton(self):
        self._unloadSkeletonMesh()

        skel = self.human.getSkeleton()
        if not skel:
            return

        # Create a mesh from the skeleton in rest pose
        skel.setToRestPose(
        )  # Make sure skeleton is in rest pose when constructing the skeleton mesh
        self.skelMesh = skeleton_drawing.meshFromSkeleton(skel, "Prism")
        self.skelMesh.name = self.skelMesh.name + '-skeletonDebug'
        self.skelMesh.priority = 100
        self.skelMesh.setPickable(False)
        self.skelObj = self.addObject(
            gui3d.Object(self.skelMesh, self.human.getPosition()))
        self.skelObj.setShadeless(0)
        self.skelObj.setSolid(0)
        self.skelObj.setRotation(self.human.getRotation())

        # Add the skeleton mesh to the human AnimatedMesh so it animates together with the skeleton
        # The skeleton mesh is supposed to be constructed from the skeleton in rest and receives
        # rigid vertex-bone weights (for each vertex exactly one weight of 1 to one bone)
        mapping = skeleton_drawing.getVertBoneMapping(skel, self.skelMesh)
        self.human.addBoundMesh(self.skelMesh, mapping)

        self.human.refreshPose()  # Pose drawn skeleton if human is posed
        mh.redraw()
Exemplo n.º 6
0
    def loadBVHRig(self, bvhRig):
        global SPARSIFY

        # Draw BVH skeleton if it does not exist yet
        if not self.bvhMesh:
            self.bvhSkel = bvhRig.createSkeleton()
            self.bvhMesh = skeleton_drawing.meshFromSkeleton(self.bvhSkel, "Prism")
            self.bvhMesh.priority = 100
            self.bvhMesh.setColor([0, 255, 0, 255])
            self.bvhObj = self.addObject(gui3d.Object(self.human.getPosition(), self.bvhMesh) )
            self.bvhObj.setRotation(self.human.getRotation())

            # Get rigid weights for skeleton mesh
            boneWeights = skeleton_drawing.getVertBoneMapping(self.bvhSkel, self.bvhMesh)
            self.bvhAnimated = animation.AnimatedMesh(self.bvhSkel, self.bvhMesh, boneWeights)

        # Load animation to BVH rig
        animName = unicode(os.path.splitext(os.path.basename(bvhRig.filename))[0])
        trivialMap = [bone.name for bone in self.bvhSkel.getBones()]
        animTrack = bvhRig.createAnimationTrack(trivialMap, animName)
        animTrack.interpolationType = 0
        if animTrack.frameRate > 30:
            animTrack.sparsify(30)

        self.bvhAnimated.addAnimation(animTrack)
Exemplo n.º 7
0
    def __init__(self, category):
        gui3d.TaskView.__init__(self, category, 'Censor')

        self.mouseBox = self.addLeftWidget(gui.GroupBox('Censor'))
        self.enableCensor = self.mouseBox.addWidget(
            gui.CheckBox("Enable", gui3d.app.settings.get('censor', False)))

        human = gui3d.app.selectedHuman

        self.breastVertices = human.mesh.getVerticesForGroups(
            ['l-torso-nipple', 'r-torso-nipple'])
        mesh = geometry3d.RectangleMesh(100, 100)
        self.breastCensorship = gui3d.app.addObject(
            gui3d.Object([0, 0, 9], mesh))
        mesh.setColor([0, 0, 0, 255])
        mesh.setPickable(False)
        mesh.setShadeless(True)
        mesh.setDepthless(True)
        mesh.priority = 80

        self.genitalVertices = human.mesh.getVerticesForGroups(
            ['pelvis-genital-area'])
        mesh = geometry3d.RectangleMesh(100, 100)
        self.genitalCensorship = gui3d.app.addObject(
            gui3d.Object([0, 0, 9], mesh))
        mesh.setColor([0, 0, 0, 255])
        mesh.setPickable(False)
        mesh.setShadeless(True)
        mesh.setDepthless(True)
        mesh.priority = 80

        if gui3d.app.settings.get('censor', False):
            self.updateCensor()
        else:
            self.breastCensorship.hide()
            self.genitalCensorship.hide()

        @self.enableCensor.mhEvent
        def onClicked(event):
            gui3d.app.settings['censor'] = self.enableCensor.selected
            if self.enableCensor.selected:
                self.updateCensor()
                self.breastCensorship.show()
                self.genitalCensorship.show()
            else:
                self.breastCensorship.hide()
                self.genitalCensorship.hide()
Exemplo n.º 8
0
    def loadGrid(self):
        if self.backplaneGrid:
            self.removeObject(self.backplaneGrid)

        if self.groundplaneGrid:
            self.removeObject(self.groundplaneGrid)

        offset = self.selectedHuman.getJointPosition('ground')[1]
        spacing = 1 if self.settings['units'] == 'metric' else 3.048

        # Background grid
        gridSize = int(200/spacing)
        if gridSize % 2 != 0:
            gridSize += 1
        if self.settings['units'] == 'metric':
            subgrids = 10
        else:
            subgrids = 12
        backGridMesh = geometry3d.GridMesh(gridSize, gridSize, spacing, offset = -10, plane = 0, subgrids = subgrids)
        backGridMesh.setMainColor(self.gridColor)
        backGridMesh.setSubColor(self.gridSubColor)
        backGridMesh.lockRotation = True
        backGridMesh.restrictVisibleToCamera = True
        backGridMesh.minSubgridZoom = (1.0/spacing) * float(subgrids)/5
        self.backplaneGrid = gui3d.Object(backGridMesh)
        self.backplaneGrid.excludeFromProduction = True
        self.backplaneGrid.placeAtFeet = True
        self.backplaneGrid.setShadeless(1)
        #self.backplaneGrid.setPosition([0,offset,0])
        self.addObject(self.backplaneGrid)

        # Ground grid
        gridSize = int(20/spacing)
        if gridSize % 2 != 0:
            gridSize += 1
        groundGridMesh = geometry3d.GridMesh(gridSize, gridSize, spacing, offset = 0, plane = 1, subgrids = subgrids)
        groundGridMesh.setMainColor(self.gridColor)
        groundGridMesh.setSubColor(self.gridSubColor)
        groundGridMesh.minSubgridZoom = (1.0/spacing) * float(subgrids)/5
        self.groundplaneGrid = gui3d.Object(groundGridMesh)
        self.groundplaneGrid.excludeFromProduction = True
        self.groundplaneGrid.placeAtFeet = True
        self.groundplaneGrid.setShadeless(1)
        #self.groundplaneGrid.setPosition([0,offset,0])
        groundGridMesh.restrictVisibleAboveGround = True
        self.addObject(self.groundplaneGrid)
Exemplo n.º 9
0
    def drawSkeleton(self, skel):
        if self.skelObj:
            # Remove old skeleton mesh
            gui3d.app.removeObject(self.skelObj)
            self.skelObj = None
            self.skelMesh = None
            self.selectedBone = None

        # Create a mesh from the skeleton in rest pose
        skel.setToRestPose(
        )  # Make sure skeleton is in rest pose when constructing the skeleton mesh
        self.skelMesh = skeleton_drawing.meshFromSkeleton(skel, "Prism")
        self.skelMesh.priority = 100
        self.skelMesh.setPickable(True)
        mh.updatePickingBuffer()
        self.skelObj = gui3d.app.addObject(
            gui3d.Object(self.human.getPosition(), self.skelMesh))
        self.skelObj.setRotation(self.human.getRotation())

        # Add the skeleton mesh to the human AnimatedMesh so it animates together with the skeleton
        # The skeleton mesh is supposed to be constructed from the skeleton in rest and receives
        # rigid vertex-bone weights (for each vertex exactly one weight of 1 to one bone)
        mapping = skeleton_drawing.getVertBoneMapping(skel, self.skelMesh)
        self.human.animated.addMesh(self.skelMesh, mapping)

        # Store a reference to the skeleton mesh object for other plugins
        self.human._skeleton.object = self.skelObj

        # Add event listeners to skeleton mesh for bone highlighting
        @self.skelObj.mhEvent
        def onMouseEntered(event):
            """
            Event fired when mouse hovers over a skeleton mesh facegroup
            """
            gui3d.TaskView.onMouseEntered(self, event)
            try:
                self.removeBoneHighlights()
            except:
                pass
            self.highlightBone(event.group.name)

        @self.skelObj.mhEvent
        def onMouseExited(event):
            """
            Event fired when mouse hovers off of a skeleton mesh facegroup
            """
            gui3d.TaskView.onMouseExited(self, event)
            try:
                self.removeBoneHighlights()
            except:
                pass

            # Highlight bone selected in bone explorer again
            for rdio in self.boneSelector:
                if rdio.selected:
                    self.clearBoneWeights()
                    self.highlightBone(str(rdio.text()))
Exemplo n.º 10
0
    def __init__(self, category):

        gui3d.TaskView.__init__(self, category, 'Save')

        modelPath = mh.getPath('models')

        self.fileentry = self.addTopWidget(gui.FileEntryView('Save'))
        self.fileentry.setDirectory(modelPath)
        self.fileentry.setFilter('MakeHuman Models (*.mhm)')

        self.selection_width = 1.2
        self.selection_height = 1.3
        mesh = geometry3d.FrameMesh(self.selection_width,
                                    self.selection_height)
        mesh.move(-self.selection_width / 2, -self.selection_height / 2)

        self.selection = gui3d.app.addObject(gui3d.Object([0, 0, 9], mesh))
        mesh.setColor([0, 0, 0, 255])
        mesh.setPickable(False)
        mesh.setShadeless(True)
        mesh.setDepthless(True)
        mesh.priority = 90
        self.selection.hide()

        @self.fileentry.mhEvent
        def onFileSelected(filename):
            if not filename.lower().endswith('.mhm'):
                filename += '.mhm'

            path = os.path.normpath(os.path.join(modelPath, filename))

            dir, name = os.path.split(path)
            name, ext = os.path.splitext(name)

            if not os.path.exists(dir):
                os.makedirs(dir)

            # Save the thumbnail

            ((x0, y0, z0), (x1, y1, z1)) = self.selection.mesh.calcBBox()
            x0, y0, z0 = gui3d.app.guiCamera.convertToScreen(x0, y0, 0)
            x1, y1, z1 = gui3d.app.guiCamera.convertToScreen(x1, y1, 0)
            log.debug('grab rectangle: %d %d %d %d', x0, y0, x1, y1)
            mh.grabScreen(int(x0 + 1), int(y1 + 1), int(x1 - x0 - 1),
                          int(y0 - y1 - 1), os.path.join(dir, name + '.thumb'))

            # Save the model

            human = gui3d.app.selectedHuman
            human.save(path, name)
            gui3d.app.modified = False
            #gui3d.app.clearUndoRedo()

            gui3d.app.setFilenameCaption(filename)
            gui3d.app.setFileModified(False)

            mh.changeCategory('Modelling')
Exemplo n.º 11
0
    def __init__(self, category):
        gui3d.TaskView.__init__(self, category, 'Proportional editing', label='Edit')

        self.radius = 1.0
        self.start = None
        self.center = None
        self.axis = None
        self.depth = None
        self.original = None
        self.normals = None
        self.weights = None
        self.verts = None
        self.faces = None
        self.smoothed = None

        self.converter = ValueConverter()
        value = self.converter.displayToData(self.radius)
        self.radiusSlider = self.addLeftWidget(gui.Slider(value, min=-5.0, max=3.0, label="Radius",
                                                          valueConverter=self.converter))
        self.clear = self.addLeftWidget(gui.Button("Clear"))
        self.modeBox = self.addLeftWidget(gui.GroupBox("Mode"))
        modes = []
        self.grab = self.modeBox.addWidget(gui.RadioButton(modes, "Grab", selected=True))
        self.norm = self.modeBox.addWidget(gui.RadioButton(modes, "Normal"))
        self.scalex = self.modeBox.addWidget(gui.RadioButton(modes, "Scale X"))
        self.scaley = self.modeBox.addWidget(gui.RadioButton(modes, "Scale Y"))
        self.scalez = self.modeBox.addWidget(gui.RadioButton(modes, "Scale Z"))
        self.rotate = self.modeBox.addWidget(gui.RadioButton(modes, "Rotate"))
        self.smooth = self.modeBox.addWidget(gui.RadioButton(modes, "Smooth"))

        self.buildCircle()
        self.updateRadius()

        self.circle = self.addObject(gui3d.Object(self.circleMesh))

        @self.clear.mhEvent
        def onClicked(dummy):
            human = gui3d.app.selectedHuman
            targets = []
            for name in human.targetsDetailStack.keys():
                if isinstance(algos3d.getTarget(human, name), EditTarget):
                    targets.append(name)
            gui3d.app.do(EditAction(human, targets, 0.0))

        @self.radiusSlider.mhEvent
        def onChanging(value):
            self.radius = self.converter.dataToDisplay(value)
            self.updateRadius()

        @self.radiusSlider.mhEvent
        def onChange(value):
            self.radius = self.converter.dataToDisplay(value)
            self.updateRadius()
Exemplo n.º 12
0
    def drawSkeleton(self, skel):
        # Create a mesh from the skeleton in rest pose
        skel.setToRestPose() # Make sure skeleton is in rest pose when constructing the skeleton mesh
        self.skelMesh = skeleton_drawing.meshFromSkeleton(skel, "Prism")
        self.skelMesh.priority = 100
        self.skelObj = self.addObject(gui3d.Object(self.human.getPosition(), self.skelMesh) )
        self.skelObj.setRotation(self.human.getRotation())

        # Add the skeleton mesh to the human AnimatedMesh so it animates together with the skeleton
        # The skeleton mesh is supposed to be constructed from the skeleton in rest and receives
        # rigid vertex-bone weights (for each vertex exactly one weight of 1 to one bone)
        mapping = skeleton_drawing.getVertBoneMapping(skel, self.skelMesh)
        self.animated.addMesh(self.skelMesh, mapping)
        self.setShowRig(self.showMHXRigTggl.selected)
Exemplo n.º 13
0
    def setHair(self, human, mhclo):
        self.filechooser.selectItem(mhclo)

        if human.hairObj:
            gui3d.app.removeObject(human.hairObj)
            human.hairObj = None
            human.hairProxy = None

        if os.path.basename(mhclo) == "clear.mhclo":
            return
            
        human.hairProxy = mh2proxy.readProxyFile(human.meshData, mhclo)
        human.hairProxy.type = 'Hair'
        if not human.hairProxy:
            log.error("Failed to load %s", mhclo)
            return

        obj = human.hairProxy.obj_file
        obj = os.path.join(obj[0], obj[1])
        mesh = files3d.loadMesh(obj)
        if not mesh:
            log.error("Failed to load %s", obj)
            return
        if human.hairProxy.texture:
            (folder, name) = human.hairProxy.texture
            tex = os.path.join(folder, name)
            mesh.setTexture(tex)
        else:
            tex = obj.replace('.obj', '_texture.png')
            mesh.setTexture(tex)

        human.hairObj = gui3d.app.addObject(gui3d.Object(human.getPosition(), mesh))
        human.hairObj.setRotation(human.getRotation())
        human.hairObj.mesh.setCameraProjection(0)
        human.hairObj.mesh.setSolid(human.mesh.solid)
        if human.hairProxy.cull:
            human.hairObj.mesh.setCull(1)
        else:
            human.hairObj.mesh.setCull(None)
        human.hairObj.mesh.setTransparentPrimitives(len(human.hairObj.mesh.fvert))
        human.hairObj.mesh.priority = 20

        hairName = human.hairObj.mesh.name.split('.')[0]

        self.adaptHairToHuman(human)
        human.hairObj.setSubdivided(human.isSubdivided())
Exemplo n.º 14
0
def drawBVHSkeleton(skeleton, human):
    bvhMesh = module3d.Object3D('bvhskeleton')
    bvhMesh.uvValues = []
    bvhMesh.indexBuffer = []

    _drawBVHJoint(skeleton.root, bvhMesh)

    bvhMesh.setCameraProjection(0)
    bvhMesh.setShadeless(0)
    bvhMesh.setSolid(0)
    bvhMesh.calcNormals()
    bvhMesh.updateIndexBuffer()

    bvhObject = gui3d.Object(aljabr.vadd(human.getPosition(), [0.0, 0.0, 0.0]),
                             bvhMesh)
    bvhObject.setRotation(human.getRotation())

    return bvhObject
Exemplo n.º 15
0
    def draw(self):
        skeletonMesh = module3d.Object3D('skeleton')
        skeletonMesh.uvValues = []
        skeletonMesh.indexBuffer = []

        self.root.draw(skeletonMesh)

        skeletonMesh.setCameraProjection(0)
        skeletonMesh.setShadeless(0)
        skeletonMesh.setSolid(0)
        skeletonMesh.calcNormals()
        skeletonMesh.updateIndexBuffer()

        skeletonObject = gui3d.Object(
            vadd(self.human.getPosition(), [0.0, 0.0, 0.0]), skeletonMesh)
        skeletonObject.mesh.setCameraProjection(0)
        skeletonObject.setRotation(self.human.getRotation())
        return skeletonObject
Exemplo n.º 16
0
    def drawSkeleton(self):
        if self.skelObj:
            # Remove old skeleton mesh
            self.removeObject(self.skelObj)
            self.skelObj = None
            self.skelMesh = None

        skel = self.human.getSkeleton()
        if not skel:
            return

        # Create a mesh from the skeleton
        self.skelMesh = skeleton_drawing.meshFromSkeleton(skel, "Prism")
        self.skelMesh.priority = 100
        self.skelMesh.setPickable(False)
        self.skelObj = self.addObject(gui3d.Object(self.skelMesh, self.human.getPosition()) )
        self.skelObj.setShadeless(0)
        self.skelObj.setSolid(0)
        self.skelObj.setRotation(self.human.getRotation())

        mh.redraw()
Exemplo n.º 17
0
    def __init__(self, category):
        gui3d.TaskView.__init__(self, category, 'Background')

        self.human = gui3d.app.selectedHuman

        self.backgroundsFolder = mh.getPath('backgrounds')
        if not os.path.exists(self.backgroundsFolder):
            os.makedirs(self.backgroundsFolder)

        self.backgroundsFolders = [ mh.getSysDataPath('backgrounds'),
                                    self.backgroundsFolder ]
        self.extensions = ['bmp', 'png', 'tif', 'tiff', 'jpg', 'jpeg']

        self.texture = mh.Texture()

        self.sides = { 'front': [0,0,0],
                       'back': [0,180,0],
                       'left': [0,-90,0],
                       'right': [0,90,0],
                       'top': [90,0,0],
                       'bottom': [-90,0,0],
                       'other': None }

        self.filenames = {}    # Stores (filename, aspect)
        self.transformations = {} # Stores ((posX,posY), scaleY)
        for side in self.sides.keys():
            self.filenames[side] = None
            self.transformations[side] = [(0.0, 0.0), 1.0]

        self.planeMeshes = dict()

        self.opacity = 40

        for viewName, rot in self.sides.items():
            if rot is not None:
                rv = [0, 0, 0]
                angle = 0.0
                for r_idx, r in enumerate(rot):
                    if r != 0:
                        rv[r_idx] = 1
                        angle = math.radians(r)
                if angle == 0:
                    m = None
                else:
                    m = tm.rotation_matrix(-angle, rv)
            else:
                m = None

            mesh = geometry3d.RectangleMesh(20, 20, centered=True, rotation=m)
            mesh.name = "Background_%s" % viewName
            obj = gui3d.app.addObject(gui3d.Object(mesh, [0, 0, 0], visible=False))
            obj.setShadeless(True)
            obj.setDepthless(True)
            #obj.placeAtFeet = True
            mesh.setCameraProjection(0)
            mesh.setColor([255, 255, 255, self.opacity*2.55])
            mesh.setPickable(False)
            mesh.priority = -90
            self.planeMeshes[viewName] = obj

            if viewName == 'other':
                obj.lockRotation = True

            @obj.mhEvent
            def onMouseDragged(event):
                if event.button in [mh.Buttons.LEFT_MASK, mh.Buttons.MIDDLE_MASK]:
                    if mh.getKeyModifiers() & (mh.Modifiers.SHIFT):
                        delta = 150.0
                    else:
                        delta = 30.0

                    dx = float(event.dx)/delta
                    dy = float(-event.dy)/delta
                    self.moveBackground(dx, dy)
                elif event.button == mh.Buttons.RIGHT_MASK:
                    if mh.getKeyModifiers() & (mh.Modifiers.SHIFT):
                        delta = 500.0
                    else:
                        delta = 100.0
                    scale = self.getBackgroundScale()
                    scale += float(event.dy)/delta

                    self.setBackgroundScale(scale)

        # Add icon to action toolbar
        self.backgroundImageToggle = gui.Action('background', 'Background', self.toggleBackground, toggle=True)
        gui3d.app.view_toolbar.addAction(self.backgroundImageToggle)
        gui3d.app.actions.background = self.backgroundImageToggle

        #self.filechooser = self.addTopWidget(fc.FileChooser(self.backgroundsFolders, self.extensions, None))
        #self.addLeftWidget(self.filechooser.sortBox)
        self.filechooser = self.addRightWidget(fc.IconListFileChooser(self.backgroundsFolders, self.extensions, None, None, 'Background', noneItem=True))
        self.filechooser.setIconSize(50,50)
        self.filechooser.enableAutoRefresh(False)
        #self.addLeftWidget(self.filechooser.createSortBox())

        self.backgroundBox = self.addLeftWidget(gui.GroupBox('Side'))
        self.bgSettingsBox = self.addLeftWidget(gui.GroupBox('Background settings'))

        self.radioButtonGroup = []
        for side in ['front', 'back', 'left', 'right', 'top', 'bottom', 'other']:
            radioBtn = self.backgroundBox.addWidget(gui.RadioButton(self.radioButtonGroup, label=side.capitalize(), selected=len(self.radioButtonGroup)==0))
            radioBtn.side = side
            @radioBtn.mhEvent
            def onClicked(value):
                side = self.sides[self.getSelectedSideCheckbox()]
                if side:
                    gui3d.app.axisView(side)
                self.refreshFileChooser()

        self.opacitySlider = self.bgSettingsBox.addWidget(gui.Slider(value=self.opacity, min=0,max=100, label = ["Opacity",": %d%%"]))
        self.dragButton = self.bgSettingsBox.addWidget(gui.CheckBox('Move && Resize'))
        self.foregroundTggl = self.bgSettingsBox.addWidget(gui.CheckBox("Show in foreground"))

        @self.opacitySlider.mhEvent
        def onChanging(value):
            for obj in self.planeMeshes.values():
                obj.mesh.setColor([255, 255, 255, 2.55*value])
        @self.opacitySlider.mhEvent
        def onChange(value):
            self.opacity = value
            for obj in self.planeMeshes.values():
                obj.mesh.setColor([255, 255, 255, 2.55*value])
        @self.foregroundTggl.mhEvent
        def onClicked(value):
            self.setShowBgInFront(self.foregroundTggl.selected)

        @self.filechooser.mhEvent
        def onFileSelected(filename):
            side = self.getSelectedSideCheckbox()

            if self.filenames[side]:
                oldBg = self.filenames[side][0]
            else:
                oldBg = None
            gui3d.app.do(BackgroundAction("Change background",
                self,
                side,
                oldBg,
                filename))

            mh.redraw()


        @self.dragButton.mhEvent
        def onClicked(event):
            for obj in self.planeMeshes.values():
                obj.mesh.setPickable(self.dragButton.selected)
            gui3d.app.selectedHuman.mesh.setPickable(not self.dragButton.selected)
            mh.redraw()
Exemplo n.º 18
0
    def __init__(self, category):
        # Setup GUI elements
        gui3d.TaskView.__init__(self, category, 'Actions')

        box = self.addLeftWidget(gui.GroupBox('Export'))
        self.rigButton = box.addWidget(FileSelectView('Load BVH'))
        self.rigButton.setDirectory(DATA_PATH)
        self.rigButton.setFilter('Biovision Motion Hierarchy (*.bvh)')
        self.exportButton = box.addWidget(gui.Button('Export animation'))
        self.exportAllButton = box.addWidget(gui.Button('Export all'))

        self.window = None
        @self.rigButton.mhEvent
        def onFilesSelected(filenames):
            if not self.skel:
                self.loadRig()
            loadFirst = (self.animationList.rowCount() == 0)
            for filename in filenames:
                if filename not in self.selectedBVHs:
                    item = self.animationList.addItem(os.path.splitext(os.path.basename(filename))[0])
                    item.filename = filename
                    self.selectedBVHs.add(filename)
            if loadFirst:
                self.loadAnimation(filenames[0])

        @self.exportButton.mhEvent
        def onClicked(event):
            self.export()

        @self.exportAllButton.mhEvent
        def onClicked(event):
            self.exportAll()

        self.human = gui3d.app.selectedHuman
        self.humanChanged = False
        self.humanTransparent = False

        self.selectedBVHs = set()

        self.skel = None
        self.animated = None

        self.bvhAnimated = None

        self.skelMesh = None
        self.skelObj = None

        self.bvhMesh = None
        self.bvhObj = None

        self.timer = None
        self.currFrame = 0
        self.anim = None

        self.bvhAnim = None

        self.oldHumanTransp = self.human.meshData.transparentPrimitives

        optionsBox = self.addLeftWidget(gui.GroupBox('Options'))
        self.kinectCamTggle = optionsBox.addWidget(gui.ToggleButton("Kinect camera"))
        self.kinectCamTggle.setSelected(True)

        self.useMHCamTggl = optionsBox.addWidget(gui.ToggleButton("Use camera pos"))
        self.useMHCamTggl.setSelected(False)

        mesh = BackPlane(20, 20, centered=True)
        self.bgPlane = self.addObject(gui3d.Object([0, 0, 0], mesh))
        mesh.setColor([255, 255, 255, 255])
        mesh.setShadeless(True)
        mesh.priority = -90

        mesh = GroundPlane(20, 20, centered=True)
        self.groundPlane = self.addObject(gui3d.Object([0, 0, 0], mesh))
        mesh.setColor([0, 0, 0, 255])
        mesh.setShadeless(True)
        mesh.priority = -90

        yOffset = self.getFeetOnGroundOffset()
        self.groundposSlider = optionsBox.addWidget(gui.Slider(value=int(yOffset), min=-125,max=125, label = "Ground Pos: %d"))
        self.groundposVal = int(yOffset)
        self.groundPlane.mesh.move(0,yOffset,0)

        @self.groundposSlider.mhEvent
        def onChanging(value):
            val = value - self.groundposVal
            self.groundPlane.mesh.move(0,val,0)
            self.groundposVal = self.groundposVal + val
        @self.groundposSlider.mhEvent
        def onChange(value):
            val = value - self.groundposVal
            self.groundPlane.mesh.move(0,val,0)
            self.groundposVal = self.groundposVal + val

        self.backposSlider = optionsBox.addWidget(gui.Slider(value=-9, min=-125,max=125, label = "Back Pos: %d"))
        self.backposVal = -9

        @self.backposSlider.mhEvent
        def onChanging(value):
            val = value - self.backposVal
            self.bgPlane.mesh.move(0,0,val)
            self.backposVal = self.backposVal + val
        @self.backposSlider.mhEvent
        def onChange(value):
            val = value - self.backposVal
            self.bgPlane.mesh.move(0,0,val)
            self.backposVal = self.backposVal + val

        self.bgPlane.mesh.move(0,0,self.backposVal)
        
        displayBox = self.addRightWidget(gui.GroupBox('Display'))
        self.showHumanTggl = displayBox.addWidget(gui.ToggleButton("Show human"))
        @self.showHumanTggl.mhEvent
        def onClicked(event):
            if self.showHumanTggl.selected:
                self.human.show()
            else:
                self.human.hide()
        self.showHumanTggl.setSelected(True)

        self.showMHXRigTggl = displayBox.addWidget(gui.ToggleButton("Show human Rig"))
        @self.showMHXRigTggl.mhEvent
        def onClicked(event):
            self.setShowRig(self.showMHXRigTggl.selected)
        self.showMHXRigTggl.setSelected(True)
 
        self.showBVHRigTggl = displayBox.addWidget(gui.ToggleButton("Show BVH Rig"))
        @self.showBVHRigTggl.mhEvent
        def onClicked(event):
            self.setShowBVHRig(self.showBVHRigTggl.selected)
        self.showBVHRigTggl.setSelected(False)

        self.imageExported = False

        self.playbackBox = None
        self.playPause = None

        self.createPlaybackControl()
        animationListBox = self.addRightWidget(gui.GroupBox('BVHs'))
        self.animationList = animationListBox.addWidget(gui.ListView())
        self.animationList.setSizePolicy(QtGui.QSizePolicy.Ignored, QtGui.QSizePolicy.MinimumExpanding)
        self.animationList.setHorizontalScrollBarPolicy(QtCore.Qt.ScrollBarAlwaysOff)
        @self.animationList.mhEvent
        def onClicked(item):
            self.loadAnimation(item.filename)
        self.removeAnimBtn = animationListBox.addWidget(gui.Button('Remove selected'))
        @self.removeAnimBtn.mhEvent
        def onClicked(item):
            print "remove clicked"
            if len(self.animationList.selectedItems()) > 0:
                print "taking action"
                item = self.animationList.selectedItems()[0]
                self.removeAnimation(item.filename)
Exemplo n.º 19
0
    def setClothes(self, human, filepath):
        if os.path.basename(filepath) == "clear.mhclo":
            for name,clo in human.clothesObjs.items():
                gui3d.app.removeObject(clo)
                del human.clothesObjs[name]
            human.clothesProxies = {}
            self.clothesList = []
            human.activeClothing = None
            self.updateFaceMasks(self.faceHidingTggl.selected)
            return

        if filepath not in self.cache:
            proxy = mh2proxy.readProxyFile(human.meshData, filepath)
            proxy.type = 'Clothes'
            self.cache[filepath] = proxy
            proxy.toggleEnabled = False
        else:
            proxy = self.cache[filepath]

        if not proxy:
            return

        uuid = proxy.getUuid()

        # TODO costumes should go in a separate library
        '''
        # For loading costumes (sets of individual clothes)
        if proxy.clothings:
            t = 0
            dt = 1.0/len(proxy.clothings)
            folder = os.path.dirname(filepath)
            for (pieceName, uuid) in proxy.clothings:
                gui3d.app.progress(t, text="Loading %s" % pieceName)
                t += dt
                piecePath = os.path.join(folder, pieceName+".mhclo")
                mhclo = exportutils.config.getExistingProxyFile(piecePath, uuid, "clothes")
                if mhclo:
                    self.setClothes(human, mhclo)
                else:
                    log.warning("Could not load clothing %s", pieceName)
            gui3d.app.progress(1, text="%s loaded" % proxy.name)
            # Load custom textures
            for (uuid, texPath) in proxy.textures:
                if not uuid in human.clothesObjs.keys():
                    log.warning("Cannot override texture for clothing piece with uuid %s!" % uuid)
                    continue
                pieceProxy = human.clothesProxies[uuid]
                if not os.path.dirname(texPath):
                    pieceProxy = human.clothesProxies[uuid]
                    clothesPath = os.path.dirname(pieceProxy.file)
                    texPath = os.path.join(clothesPath, texPath)
                log.debug("Overriding texture for clothpiece %s to %s", uuid, texPath)
                clo = human.clothesObjs[uuid]
                clo.mesh.setTexture(texPath)
            # Apply overridden transparency setting to pieces of a costume
            for (uuid, isTransparent) in proxy.transparencies.items():
                if not uuid in human.clothesProxies.keys():
                    log.warning("Could not override transparency for object with uuid %s!" % uuid)
                    continue
                clo = human.clothesObjs[uuid]
                log.debug("Overriding transparency setting for clothpiece %s to %s", uuid, bool(proxy.transparencies[uuid]))
                if proxy.transparencies[uuid]:
                    clo.mesh.setTransparentPrimitives(len(clo.mesh.fvert))
                else:
                    clo.mesh.setTransparentPrimitives(0)
            return
        '''

        #folder = os.path.dirname(filepath)
        (folder, name) = proxy.obj_file
        obj = os.path.join(folder, name)

        try:
            clo = human.clothesObjs[uuid]
        except:
            clo = None
        if clo:
            gui3d.app.removeObject(clo)
            del human.clothesObjs[uuid]
            self.clothesList.remove(uuid)
            if human.activeClothing == uuid:
                human.activeClothing = None
            proxy = human.clothesProxies[uuid]
            del human.clothesProxies[uuid]
            self.updateFaceMasks(self.faceHidingTggl.selected)
            self.filechooser.deselectItem(proxy.file)
            log.message("Removed clothing %s %s", proxy.name, uuid)
            return

        if obj not in self.meshCache:
            mesh = files3d.loadMesh(obj)
            self.meshCache[obj] = mesh
        else:
            mesh = self.meshCache[obj]
        if not mesh:
            log.error("Could not load mesh for clothing object %s", proxy.name)
            return
        if proxy.texture:
            (dir, name) = proxy.texture
            tex = os.path.join(folder, name)
            if not os.path.exists(tex):
                tex = os.path.join(self.systemClothes, "textures", name)
            mesh.setTexture(tex)
        
        clo = gui3d.app.addObject(gui3d.Object(human.getPosition(), mesh))
        clo.setRotation(human.getRotation())
        clo.mesh.setCameraProjection(0)
        clo.mesh.setSolid(human.mesh.solid)
        if proxy.cull:
            clo.mesh.setCull(1)
        else:
            clo.mesh.setCull(None)
        if proxy.transparent:
            clo.mesh.setTransparentPrimitives(len(clo.mesh.fvert))
        else:
            clo.mesh.setTransparentPrimitives(0)
        clo.mesh.priority = 10
        human.clothesObjs[uuid] = clo        
        human.clothesProxies[uuid] = proxy
        human.activeClothing = uuid
        self.clothesList.append(uuid)

        # TODO Disabled until conflict with new filechooser is sorted out
        '''
        for tag in proxy.tags:
            tag = tag.lower()
            # Allow only one piece of clothing per known tag
            if tag in KnownTags:
                try:
                    oldUuids = self.taggedClothes[tag]
                except KeyError:
                    oldUuids = []
                newUuids = []
                for oldUuid in oldUuids:
                    if oldUuid == uuid:
                        pass
                    elif True:  # TODO use parameter here
                        try:
                            oldClo = human.clothesObjs[oldUuid]
                        except KeyError:
                            continue
                        gui3d.app.removeObject(oldClo)
                        del human.clothesObjs[oldUuid]
                        self.clothesList.remove(oldUuid)
                        if human.activeClothing == oldUuid:
                            human.activeClothing = None
                        log.message("Removed clothing %s with known tag %s", oldUuid, tag)
                    else:
                        log.message("Kept clothing %s with known tag %s", oldUuid, tag)
                        newUuids.append(oldUuid)
                newUuids.append(uuid)
                self.taggedClothes[tag] = newUuids
        '''

        self.adaptClothesToHuman(human)
        clo.setSubdivided(human.isSubdivided())
        
        #self.clothesButton.setTexture(obj.replace('.obj', '.png'))
        self.orderRenderQueue()
        self.updateFaceMasks(self.faceHidingTggl.selected)
    def setClothes(self, human, filepath):
        if os.path.basename(filepath) == "clear.mhclo":
            for name,clo in human.clothesObjs.items():
                gui3d.app.removeObject(clo)
                del human.clothesObjs[name]
            self.clothesList = []
            human.activeClothing = None
            return

        proxy = mh2proxy.readProxyFile(human.meshData, filepath, False)
        
        if not proxy:
            return

        uuid = proxy.getUuid()
        
        # For loading costumes (sets of individual clothes)
        if proxy.clothings:
            t = 0
            dt = 1.0/len(proxy.clothings)
            for (pieceName, uuid) in proxy.clothings:
                gui3d.app.progress(t, text="Loading %s" % pieceName)
                t += dt
                mhclo = export_config.getExistingProxyFile(pieceName+".mhclo", uuid, "clothes")
                if mhclo:
                    self.setClothes(human, mhclo)
                else:
                    log.warning("Could not load clothing %s", pieceName)
            gui3d.app.progress(1, text="%s loaded" % proxy.name)
            # Load custom textures
            for (uuid, texPath) in proxy.textures:
                if not uuid in human.clothesObjs.keys():
                    log.warning("Cannot override texture for clothing piece with uuid %s!" % uuid)
                    continue
                pieceProxy = human.clothesProxies[uuid]
                if not os.path.dirname(texPath):
                    pieceProxy = human.clothesProxies[uuid]
                    clothesPath = os.path.dirname(pieceProxy.file)
                    texPath = os.path.join(clothesPath, texPath)
                log.debug("Overriding texture for clothpiece %s to %s", uuid, texPath)
                clo = human.clothesObjs[uuid]
                clo.mesh.setTexture(texPath)
            # Apply overridden transparency setting to pieces of a costume
            for (uuid, isTransparent) in proxy.transparencies.items():
                if not uuid in human.clothesProxies.keys():
                    log.warning("Could not override transparency for object with uuid %s!" % uuid)
                    continue
                clo = human.clothesObjs[uuid]
                log.debug("Overriding transparency setting for clothpiece %s to %s", uuid, bool(proxy.transparencies[uuid]))
                if proxy.transparencies[uuid]:
                    clo.mesh.setTransparentPrimitives(len(clo.mesh.faces))
                else:
                    clo.mesh.setTransparentPrimitives(0)
            return
            
        #folder = os.path.dirname(filepath)
        (folder, name) = proxy.obj_file
        obj = os.path.join(folder, name)

        try:
            clo = human.clothesObjs[uuid]
        except:
            clo = None
        if clo:
            gui3d.app.removeObject(clo)
            del human.clothesObjs[uuid]
            self.clothesList.remove(uuid)
            if human.activeClothing == uuid:
                human.activeClothing = None
            log.message("Removed clothing %s %s", proxy.name, uuid)
            return

        mesh = files3d.loadMesh(obj)
        if not mesh:
            log.error("Could not load mesh for clothing object %s", proxy.name)
            return
        if proxy.texture:
            (dir, name) = proxy.texture
            tex = os.path.join(folder, name)
            if not os.path.exists(tex):
                tex = os.path.join(self.systemClothes, "textures", name)
            mesh.setTexture(tex)
        else:
            pass
        
        clo = gui3d.app.addObject(gui3d.Object(human.getPosition(), mesh))
        clo.setRotation(human.getRotation())
        clo.mesh.setCameraProjection(0)
        clo.mesh.setSolid(human.mesh.solid)
        if proxy.cull:
            clo.mesh.setCull(1)
        else:
            clo.mesh.setCull(None)
        if proxy.transparent:
            clo.mesh.setTransparentPrimitives(len(clo.mesh.faces))
        else:
            clo.mesh.setTransparentPrimitives(0)
        clo.mesh.priority = 10
        human.clothesObjs[uuid] = clo        
        human.clothesProxies[uuid] = proxy
        human.activeClothing = uuid
        self.clothesList.append(uuid)
        
        for tag in proxy.tags:
            tag = tag.lower()
            if tag in KnownTags:
                try:
                    oldUuids = self.taggedClothes[tag]
                except KeyError:
                    oldUuids = []
                newUuids = []
                for oldUuid in oldUuids:
                    if oldUuid == uuid:
                        pass
                    elif True:
                        try:
                            oldClo = human.clothesObjs[oldUuid]
                        except KeyError:
                            continue
                        log.message("Removed clothing %s", oldUuid)
                        gui3d.app.removeObject(oldClo)
                        del human.clothesObjs[oldUuid]
                        self.clothesList.remove(oldUuid)
                        if human.activeClothing == oldUuid:
                            human.activeClothing = None
                    else:
                        log.message("Kept clothing %s", oldUuid)
                        newUuids.append(oldUuid)
                newUuids.append(uuid)
                self.taggedClothes[tag] = newUuids

        self.adaptClothesToHuman(human)
        clo.setSubdivided(human.isSubdivided())
Exemplo n.º 21
0
    def drawJointHelpers(self):
        """
        Draw the joint helpers from the basemesh that define the default or
        reference rig.
        """
        if self.jointsObj:
            self.removeObject(self.jointsObj)
            self.jointsObj = None
            self.jointsMesh = None
            self.selectedJoint = None

        jointGroupNames = [
            group.name for group in self.human.meshData.faceGroups
            if group.name.startswith("joint-")
        ]
        # TODO maybe define a getter for this list in the skeleton module
        jointPositions = []
        for groupName in jointGroupNames:
            jointPositions.append(
                skeleton.getHumanJointPosition(self.human.meshData, groupName))

        self.jointsMesh = skeleton_drawing.meshFromJoints(
            jointPositions, jointGroupNames)
        self.jointsMesh.priority = 100
        self.jointsMesh.setPickable(True)
        mh.updatePickingBuffer()
        self.jointsObj = self.addObject(
            gui3d.Object(self.human.getPosition(), self.jointsMesh))
        self.jointsObj.setRotation(self.human.getRotation())

        color = np.asarray([255, 255, 0, 255], dtype=np.uint8)
        self.jointsMesh.color[:] = color[None, :]
        self.jointsMesh.markCoords(colr=True)
        self.jointsMesh.sync_color()

        # Add event listeners to joint mesh for joint highlighting
        @self.jointsObj.mhEvent
        def onMouseEntered(event):
            """
            Event fired when mouse hovers over a joint mesh facegroup
            """
            gui3d.TaskView.onMouseEntered(self, event)

            # Highlight joint
            self.selectedJoint = event.group
            setColorForFaceGroup(self.jointsMesh, self.selectedJoint.name,
                                 [216, 110, 39, 255])
            gui3d.app.statusPersist(event.group.name)
            gui3d.app.redraw()

        @self.jointsObj.mhEvent
        def onMouseExited(event):
            """
            Event fired when mouse hovers off of a joint mesh facegroup
            """
            gui3d.TaskView.onMouseExited(self, event)

            # Disable highlight on joint
            if self.selectedJoint:
                setColorForFaceGroup(self.jointsMesh, self.selectedJoint.name,
                                     [255, 255, 0, 255])
                gui3d.app.statusPersist('')
                gui3d.app.redraw()
Exemplo n.º 22
0
    def __init__(self, category):
        gui3d.TaskView.__init__(self, category, 'Measure')

        self.ruler = Ruler()

        self.measureMesh = module3d.Object3D('measure', 2)
        self.measureMesh.createFaceGroup('measure')

        names = []
        for n, v in self.ruler.Measures.items():
            if len(v) % 2 != 0:
                names.append(n)
        if len(names) > 0:
            raise RuntimeError(
                "One or more measurement rulers contain an uneven number of vertex indices. It's required that they are pairs indicating the begin and end point of every line to draw. Rulers with uneven index count: %s"
                % ", ".join(names))
        del names
        count = max([len(vertIdx) for vertIdx in self.ruler.Measures.values()])

        self.measureMesh.setCoords(np.zeros((count, 3), dtype=np.float32))
        self.measureMesh.setUVs(np.zeros((1, 2), dtype=np.float32))
        self.measureMesh.setFaces(np.arange(count).reshape((-1, 2)))

        self.measureMesh.setCameraProjection(0)
        self.measureMesh.setShadeless(True)
        self.measureMesh.setDepthless(True)
        self.measureMesh.setColor([255, 255, 255, 255])
        self.measureMesh.setPickable(0)
        self.measureMesh.updateIndexBuffer()
        self.measureMesh.priority = 50

        self.measureObject = self.addObject(gui3d.Object(self.measureMesh))

        measurements = [
            ('neck', ['neckcirc', 'neckheight']),
            ('upperarm', ['upperarm', 'upperarmlenght']),
            ('lowerarm', ['lowerarmlenght', 'wrist']),
            ('torso', [
                'frontchest', 'bust', 'underbust', 'waist', 'napetowaist',
                'waisttohip', 'shoulder'
            ]),
            ('hips', ['hips']),
            ('upperleg', ['upperlegheight', 'thighcirc']),
            ('lowerleg', ['lowerlegheight', 'calf']),
            ('ankle', ['ankle']),
        ]

        sliderLabel = {
            'neckcirc': 'Neck circum',
            'neckheight': 'Neck height',
            'upperarm': 'Upper arm circum',
            'upperarmlenght': 'Upperarm length',
            'lowerarmlenght': 'Lowerarm length',
            'wrist': 'Wrist circum',
            'frontchest': 'Front chest dist',
            'bust': 'Bust circum',
            'underbust': 'Underbust circum',
            'waist': 'Waist circum',
            'napetowaist': 'Nape to waist',
            'waisttohip': 'Waist to hip',
            'shoulder': 'Shoulder dist',
            'hips': 'Hips circum',
            'upperlegheight': 'Upperleg height',
            'thighcirc': 'Thigh circ.',
            'lowerlegheight': 'Lowerleg height',
            'calf': 'Calf circum',
            'ankle': 'Ankle circum'
        }

        self.groupBoxes = {}
        self.radioButtons = []
        self.sliders = []
        self.active_slider = None

        self.modifiers = {}

        measureDataPath = mh.getSysDataPath("targets/measure/")

        self.categoryBox = self.addRightWidget(gui.GroupBox('Category'))
        self.groupBox = self.addLeftWidget(gui.StackedBox())

        for name, subnames in measurements:
            # Create box
            box = self.groupBox.addWidget(gui.SliderBox(name.capitalize()))
            self.groupBoxes[name] = box

            # Create radiobutton
            box.radio = self.categoryBox.addWidget(
                GroupBoxRadioButton(self,
                                    self.radioButtons,
                                    name.capitalize(),
                                    box,
                                    selected=len(self.radioButtons) == 0))

            # Create sliders
            for subname in subnames:
                # TODO use another modifier
                modifier = humanmodifier.Modifier(
                    os.path.join(measureDataPath,
                                 "measure-%s-decrease.target" % subname),
                    os.path.join(measureDataPath,
                                 "measure-%s-increase.target" % subname))
                modifier.setHuman(gui3d.app.selectedHuman)
                self.modifiers[subname] = modifier
                slider = box.addWidget(
                    MeasureSlider(sliderLabel[subname], self, subname,
                                  modifier))
                self.sliders.append(slider)
        self.lastActive = None

        self.statsBox = self.addRightWidget(gui.GroupBox('Statistics'))
        self.height = self.statsBox.addWidget(gui.TextView('Height: '))
        self.chest = self.statsBox.addWidget(gui.TextView('Chest: '))
        self.waist = self.statsBox.addWidget(gui.TextView('Waist: '))
        self.hips = self.statsBox.addWidget(gui.TextView('Hips: '))
        '''
        self.braBox = self.addRightWidget(gui.GroupBox('Brassiere size'))
        self.eu = self.braBox.addWidget(gui.TextView('EU: '))
        self.jp = self.braBox.addWidget(gui.TextView('JP: '))
        self.us = self.braBox.addWidget(gui.TextView('US: '))
        self.uk = self.braBox.addWidget(gui.TextView('UK: '))
        '''

        self.groupBox.showWidget(self.groupBoxes['neck'])
    def __init__(self, category):
        gui3d.TaskView.__init__(self, category, 'Background')

        self.backgroundsFolder = os.path.join(mh.getPath(''), 'backgrounds')
        if not os.path.exists(self.backgroundsFolder):
            os.makedirs(self.backgroundsFolder)

        self.backgroundsFolders = [
            os.path.join('data', 'backgrounds'), self.backgroundsFolder
        ]
        self.extensions = ['bmp', 'png', 'tif', 'tiff', 'jpg', 'jpeg', 'clear']

        self.texture = mh.Texture()

        self.sides = {
            'front': [0, 0, 0],
            'back': [0, 180, 0],
            'left': [0, 90, 0],
            'right': [0, -90, 0],
            'top': [90, 0, 0],
            'bottom': [-90, 0, 0],
            'other': None
        }

        self.filenames = {}  # Stores (filename, aspect)
        self.transformations = {}  # Stores ((posX,posY), scaleY)
        for side in self.sides.keys():
            self.filenames[side] = None
            self.transformations[side] = [(0.0, 0.0), 1.0]

        mesh = geometry3d.RectangleMesh(20, 20, centered=True)
        self.backgroundImage = gui3d.app.addObject(
            gui3d.Object([0, 0, 1], mesh, visible=False))
        self.backgroundImage.mesh.setCameraProjection(0)  # Set to model camera
        self.opacity = 100
        mesh.setColor([255, 255, 255, self.opacity])
        mesh.setPickable(False)
        mesh.setShadeless(True)
        mesh.setDepthless(True)
        mesh.priority = -90

        self.backgroundImageToggle = gui.Action('background',
                                                'Background',
                                                self.toggleBackground,
                                                toggle=True)
        gui3d.app.main_toolbar.addAction(self.backgroundImageToggle)
        gui3d.app.actions.background = self.backgroundImageToggle

        #self.filechooser = self.addTopWidget(fc.FileChooser(self.backgroundsFolders, self.extensions, None))
        #self.addLeftWidget(self.filechooser.sortBox)
        self.filechooser = self.addRightWidget(
            fc.IconListFileChooser(self.backgroundsFolders, self.extensions,
                                   None, None, 'Background'))
        self.filechooser.setIconSize(50, 50)
        self.addLeftWidget(self.filechooser.createSortBox())

        self.backgroundBox = self.addLeftWidget(gui.GroupBox('Side'))
        self.bgSettingsBox = self.addLeftWidget(
            gui.GroupBox('Background settings'))

        self.radioButtonGroup = []
        for side in [
                'front', 'back', 'left', 'right', 'top', 'bottom', 'other'
        ]:
            radioBtn = self.backgroundBox.addWidget(
                gui.RadioButton(self.radioButtonGroup,
                                label=side.capitalize(),
                                selected=len(self.radioButtonGroup) == 0))
            radioBtn.side = side

        self.opacitySlider = self.bgSettingsBox.addWidget(
            gui.Slider(value=self.opacity, min=0, max=255,
                       label="Opacity: %d"))
        self.foregroundTggl = self.bgSettingsBox.addWidget(
            gui.ToggleButton("Show in foreground"))

        @self.opacitySlider.mhEvent
        def onChanging(value):
            self.backgroundImage.mesh.setColor([255, 255, 255, value])

        @self.opacitySlider.mhEvent
        def onChange(value):
            self.opacity = value
            self.backgroundImage.mesh.setColor([255, 255, 255, value])

        @self.foregroundTggl.mhEvent
        def onClicked(value):
            self.setShowBgInFront(self.foregroundTggl.selected)

        @self.filechooser.mhEvent
        def onFileSelected(filename):
            side = self.getSelectedSideCheckbox()

            if os.path.splitext(filename)[1] == ".clear":
                filename = None

            if self.filenames[side]:
                oldBg = self.filenames[side][0]
            else:
                oldBg = None
            gui3d.app.do(
                BackgroundAction("Change background", self, side, oldBg,
                                 filename))

            if self.sides[side]:
                gui3d.app.selectedHuman.setRotation(self.sides[side])
            mh.redraw()
Exemplo n.º 24
0
    def drawPlanes(self, skel):
        def _get_face_count(skel):
            result = 0
            for bone in skel.getBones():
                if isinstance(bone.roll, list):
                    result += len(bone.roll)
                else:
                    result += 1
            return result

        import module3d
        self.planesMesh = module3d.Object3D("SkeletonPlanesMesh", 3)

        facecount = _get_face_count(skel)
        vertcount = 3 * facecount
        faces = np.arange(vertcount, dtype=np.uint16).reshape((facecount, 3))
        verts = np.zeros((vertcount, 3), dtype=np.float32)
        vcolors = 255 * np.ones((vertcount, 4), dtype=np.uint8)
        PLANE_COLORS = [[60, 230, 200], [220, 60, 230], [230, 180, 60],
                        [230, 90, 60], [60, 230, 60], [60, 120, 230]]

        fgroups = np.zeros(len(faces), dtype=np.uint16)
        v_offset = 0
        for bIdx, bone in enumerate(skel.getBones()):
            fg = self.planesMesh.createFaceGroup(bone.name)
            fgroups[bIdx:bIdx + 1] = np.repeat(
                np.array(fg.idx, dtype=np.uint16), 1)
            if isinstance(bone.roll, list):
                for p_idx, plane_name in enumerate(bone.roll):
                    plane_name = bone.roll[0]
                    plane_joints = bone.planes[plane_name]

                    j1, j2, j3 = plane_joints
                    in_rest = False
                    p1 = skel.getJointPosition(j1, self.human,
                                               in_rest)[:3] * skel.scale
                    p2 = skel.getJointPosition(j2, self.human,
                                               in_rest)[:3] * skel.scale
                    p3 = skel.getJointPosition(j3, self.human,
                                               in_rest)[:3] * skel.scale
                    verts[v_offset:v_offset + 3] = [p1, p2, p3]
                    vcolors[v_offset:v_offset + 3, :3] = PLANE_COLORS[p_idx]
                    fgroups[v_offset // 3] = fg.idx
                    v_offset += 3
            elif isinstance(bone.roll, str):
                plane_name = bone.roll
                plane_joints = bone.planes[plane_name]

                j1, j2, j3 = plane_joints
                in_rest = False
                p1 = skel.getJointPosition(j1, self.human,
                                           in_rest)[:3] * skel.scale
                p2 = skel.getJointPosition(j2, self.human,
                                           in_rest)[:3] * skel.scale
                p3 = skel.getJointPosition(j3, self.human,
                                           in_rest)[:3] * skel.scale
                verts[v_offset:v_offset + 3] = [p1, p2, p3]
                vcolors[v_offset:v_offset + 3, :3] = PLANE_COLORS[0]
                fgroups[v_offset // 3] = fg.idx
                v_offset += 3
            else:
                p1 = p2 = p3 = [0.0, 0.0, 0.0]
                verts[v_offset:v_offset + 3] = [p1, p2, p3]
                vcolors[v_offset:v_offset + 3, :3] = [255, 0, 0]
                fgroups[v_offset // 3] = fg.idx
                v_offset += 3

        self.planesMesh.setCoords(verts)
        self.planesMesh.setColor(vcolors)
        self.planesMesh.setUVs(np.zeros(
            (1, 2), dtype=np.float32))  # Set trivial UV coordinates
        self.planesMesh.setFaces(faces, None, fgroups)

        self.planesMesh.updateIndexBuffer()
        self.planesMesh.calcNormals()
        self.planesMesh.update()

        self.planesMesh.setCameraProjection(0)

        self.planesMesh.priority = 100
        self.planesMesh.setPickable(False)
        self.planesObj = self.addObject(
            gui3d.Object(self.planesMesh, self.human.getPosition()))
        self.planesObj.setShadeless(0)
        self.planesObj.setSolid(0)
        self.planesObj.setRotation(self.human.getRotation())
        self.planesObj.material.backfaceCull = False
        self.planesObj.setVisibility(self.showPlanesTggl.selected)
Exemplo n.º 25
0
    def selectProxy(self, mhclofile):
        """
        Called when a new proxy has been selected.
        If this library selects only a single proxy, specifying None as
        mhclofile parameter will deselect the current proxy and set the selection
        to "none".
        If this library allows selecting multiple proxies, specifying None as
        mhclofile will have no effect.
        """
        if not mhclofile:
            if self.multiProxy:
                return
            else:
                self.deselectProxy(None)
                return

        log.message('Selecting proxy file "%s" from %s library.', mhclofile,
                    self.proxyName)
        human = self.human

        proxy = None
        mhcloId = getpath.canonicalPath(mhclofile)
        if mhcloId in self._proxyCache:
            proxy = self._proxyCache[mhcloId]
            if proxy.mtime < os.path.getmtime(mhclofile):
                proxy = None

        if not proxy:
            proxy = mh2proxy.readProxyFile(human.meshData,
                                           mhclofile,
                                           type=self.proxyName.capitalize())
            self._proxyCache[mhcloId] = proxy

        if proxy.uuid in [p.uuid for p in self.getSelection()]:
            log.debug(
                "Proxy with UUID %s (%s) already loaded in %s library. Skipping.",
                proxy.uuid, proxy.file, self.proxyName)
            return

        if not self.multiProxy and self.isProxySelected():
            # Deselect previously selected proxy
            self.deselectProxy(None, suppressSignal=True)

        mesh = files3d.loadMesh(proxy.obj_file, maxFaces=proxy.max_pole)
        if not mesh:
            log.error("Failed to load %s", proxy.obj_file)
            return

        self.filechooser.selectItem(mhclofile)

        mesh.material = proxy.material
        mesh.priority = proxy.z_depth  # Set render order
        mesh.setCameraProjection(0)  # Set to model camera
        mesh.setSolid(
            human.mesh.solid)  # Set to wireframe if human is in wireframe

        obj = gui3d.Object(mesh, self.human.getPosition())
        obj.setRotation(human.getRotation())
        gui3d.app.addObject(obj)

        self.adaptProxyToHuman(proxy, obj)
        obj.setSubdivided(
            human.isSubdivided())  # Copy subdivided state of human

        # Add to selection
        self.selectedProxies.append(proxy)
        self.proxyObjects.append(obj)

        self.filechooser.selectItem(mhclofile)

        self.proxySelected(proxy, obj)

        self.signalChange()