Esempio n. 1
0
    public void createKNNRig(string headBoneName, string rHandBoneName, string lHandBoneName, float slidingWindowSizeInMS, float slidingWindowOffsetInMS, float pollingRate, bool ignoreRotation, bool bothHandsInFeatureVec, string outputPath)
    {
        var lHandTreeNodes  = new List <int>();
        var lHandTreePoints = new List <float[]>();
        var rHandTreeNodes  = new List <int>();
        var rHandTreePoints = new List <float[]>();

        GameObject rootBoneObj = new GameObject();
        KNNBone    rootBone    = rootBoneObj.AddComponent <KNNBone>();

        Debug.Assert(files != null && files.Count > 0);
        loadFromFile(files[0]);
        setToFrame(0, true, true, true);

        rootBone.initKNNBone(root.transform);

        foreach (string file in files)
        {
            loadFromFile(file);
            FillKNNTrees(rootBone, ignoreRotation, bothHandsInFeatureVec, headBoneName, rHandBoneName, lHandBoneName, slidingWindowSizeInMS, slidingWindowOffsetInMS, pollingRate, lHandTreeNodes, rHandTreeNodes, lHandTreePoints, rHandTreePoints);
        }

        float slidingWindowSize = slidingWindowSizeInMS / 1000.0f;
        float targetFrameTime   = 1.0f / pollingRate;
        int   framesPerWindow   = (int)((slidingWindowSize) / targetFrameTime);
        int   featureVecLength  = 9 * framesPerWindow;

        var rHandTree = new KDTree <float, int>(featureVecLength, rHandTreePoints.ToArray(), rHandTreeNodes.ToArray(), Metrics.WeightedL2Norm);
        var lHandTree = new KDTree <float, int>(featureVecLength, lHandTreePoints.ToArray(), lHandTreeNodes.ToArray(), Metrics.WeightedL2Norm);

        GameObject  kNNSkeleton_     = new GameObject("KNN-Skeleton");
        KNNSkeleton finalKNNSkeleton = kNNSkeleton_.AddComponent <KNNSkeleton>();

        finalKNNSkeleton.SetKNNSkeleton(rootBone, ignoreRotation, lHandTree, rHandTree, featureVecLength);
        finalKNNSkeleton.Save(outputPath);
        DestroyImmediate(kNNSkeleton_);
        DestroyImmediate(rootBoneObj);

        GameObject kNNRig = new GameObject("KNN-Rig");

        KNNRig kNNRigComponent = kNNRig.AddComponent <KNNRig>();

        kNNRigComponent.skeletonPath = outputPath;
    }
Esempio n. 2
0
    public void InitRig()
    {
        leftArmFeatureVec  = new LinkedList <FeatureItem>();
        rightArmFeatureVec = new LinkedList <FeatureItem>();

        if (rHandSkeleton == null || rHandSkeleton.rootBone == null || rHandSkeleton.lHandQueryTree == null || rHandSkeleton.rHandQueryTree == null || rHandSkeleton.lHandQueryTree.Count == 0 || rHandSkeleton.rHandQueryTree.Count == 0)
        {
            if (rHandSkeleton == null)
            {
                GameObject kNNSkeleton_ = new GameObject("Right-KNN-Skeleton");
                this.rHandSkeleton = kNNSkeleton_.AddComponent <KNNSkeleton>();
            }

            this.rHandSkeleton.SetKNNSkeleton(skeletonPath);
            this.rHandSkeleton.transform.parent          = this.transform;
            this.rHandSkeleton.rootBone.transform.parent = this.rHandSkeleton.transform;
        }
        if (lHandSkeleton == null || lHandSkeleton.rootBone == null || lHandSkeleton.lHandQueryTree == null || lHandSkeleton.rHandQueryTree == null || lHandSkeleton.lHandQueryTree.Count == 0 || lHandSkeleton.rHandQueryTree.Count == 0)
        {
            if (lHandSkeleton == null)
            {
                GameObject kNNSkeleton_ = new GameObject("Left-KNN-Skeleton");
                this.lHandSkeleton = kNNSkeleton_.AddComponent <KNNSkeleton>();
            }

            this.lHandSkeleton.SetKNNSkeleton(skeletonPath);
            this.lHandSkeleton.transform.parent          = this.transform;
            this.lHandSkeleton.rootBone.transform.parent = this.lHandSkeleton.transform;
        }

        if (finalSkeletonBones == null)
        {
            GameObject kNNSkeleton_ = new GameObject("final-KNN-Skeleton-Bones");
            GameObject rootBone     = new GameObject("final-KNN-Skeleton-Bones");

            this.finalSkeletonBones = rootBone.AddComponent <KNNBone>();
            this.finalSkeletonBones.initKNNBoneFromFile(skeletonPath);
            this.finalSkeletonBones.transform.parent = kNNSkeleton_.transform;
            kNNSkeleton_.transform.parent            = this.transform;
        }

        Stack <KNNBone> boneStackFinal = new Stack <KNNBone>();
        Stack <KNNBone> boneStackLeft  = new Stack <KNNBone>();
        Stack <KNNBone> boneStackRight = new Stack <KNNBone>();

        boneStackFinal.Push(this.finalSkeletonBones);
        boneStackLeft.Push(this.lHandSkeleton.rootBone);
        boneStackRight.Push(this.rHandSkeleton.rootBone);

        allBones = new List <Tuple <KNNBone, KNNBone, KNNBone> >();

        //assuming they all have the same hierarchy
        while (boneStackFinal.Count > 0)
        {
            KNNBone topBoneFinal = boneStackFinal.Pop();
            KNNBone topBoneLeft  = boneStackLeft.Pop();
            KNNBone topBoneRight = boneStackRight.Pop();

            foreach (KNNBone childBone in topBoneFinal.children)
            {
                boneStackFinal.Push(childBone);
            }

            foreach (KNNBone childBone in topBoneLeft.children)
            {
                boneStackLeft.Push(childBone);
            }

            foreach (KNNBone childBone in topBoneRight.children)
            {
                boneStackRight.Push(childBone);
            }

            if (topBoneLeft.name == topBoneRight.name && topBoneFinal.name == topBoneLeft.name)
            {
                allBones.Add(Tuple.Create(topBoneLeft, topBoneRight, topBoneFinal));
            }
        }


        rigTransforms = new List <Tuple <Transform, Transform, Quaternion> >();


        Stack <KNNBone>   boneStack      = new Stack <KNNBone>();
        Stack <Transform> transformStack = new Stack <Transform>();

        boneStack.Push(this.finalSkeletonBones);
        transformStack.Push(rig);

        while (boneStack.Count > 0)
        {
            KNNBone   topBone      = boneStack.Pop();
            Transform topTransform = null;
            if (transformStack.Count > 0)
            {
                topTransform = transformStack.Pop();
            }

            foreach (KNNBone childBone in topBone.children)
            {
                boneStack.Push(childBone);
                if (topTransform != null)
                {
                    Transform childTransform = topTransform.Find(childBone.name);
                    if (childTransform != null)
                    {
                        transformStack.Push(childTransform);
                    }
                }
            }

            if (topTransform != null && topTransform.name == topBone.name)
            {
                rigTransforms.Add(Tuple.Create(topBone.transform, topTransform, topTransform.rotation));
            }
        }

        Transform targets        = null;
        Transform lHandTmpTarget = null;
        Transform rHandTmpTarget = null;
        Transform headTmpTarget  = null;

        if (this.transform.Find("Targets") == null)
        {
            targets = new GameObject("Targets").transform;
            targets.transform.parent = this.transform;
        }
        else
        {
            targets        = this.transform.Find("Targets");
            lHandTmpTarget = targets.Find("LHandTarget");
            rHandTmpTarget = targets.Find("RHandTarget");
            headTmpTarget  = targets.Find("HeadTarget");
        }

        if (lHandTarget == null)
        {
            if (lHandTmpTarget == null)
            {
                lHandTmpTarget = new GameObject("LHandTarget").transform;
                lHandTmpTarget.transform.parent = targets.transform;
            }
            lHandTarget = lHandTmpTarget;
        }
        if (rHandTarget == null)
        {
            if (rHandTmpTarget == null)
            {
                rHandTmpTarget = new GameObject("RHandTarget").transform;
                rHandTmpTarget.transform.parent = targets.transform;
            }
            rHandTarget = rHandTmpTarget;
        }
        if (headTarget == null)
        {
            if (headTmpTarget == null)
            {
                headTmpTarget = new GameObject("HeadTarget").transform;
                headTmpTarget.transform.parent = targets.transform;
            }
            headTarget = headTmpTarget;
        }

        BoneRenderer leftBoneRenderer  = lHandSkeleton.GetComponent <BoneRenderer>();
        BoneRenderer rightBoneRenderer = rHandSkeleton.GetComponent <BoneRenderer>();
        BoneRenderer finalBoneRenderer = finalSkeletonBones.GetComponent <BoneRenderer>();

        if (leftBoneRenderer != null)
        {
            leftBoneRenderer.boneColor = Color.green;
        }
        if (rightBoneRenderer != null)
        {
            rightBoneRenderer.boneColor = Color.white;
        }
    }