Example #1
0
        float MatchCost(PatchSkeleton skl, PatchSkeleton refSkeleton)
        {
            Dictionary <string, List <PatchSkeletonBone> > bonePairs = new Dictionary <string, List <PatchSkeletonBone> >();

            foreach (var b in skl.bones)
            {
                var key = bone2key(b);
                bonePairs[key] = new List <PatchSkeletonBone>()
                {
                    b
                };
            }
            foreach (var b in refSkeleton.bones)
            {
                var key = bone2key(b);;
                if (bonePairs.ContainsKey(key))
                {
                    bonePairs[key].Add(b);
                }
            }

            if (bonePairs.Count <= 0)
            {
                return(float.MaxValue);
            }

            float cost = 0;

            foreach (var kv in bonePairs)
            {
                if (kv.Value.Count != 2)
                {
                    continue;
                }

                var b1 = kv.Value[0];
                var b2 = kv.Value[1];

                float vx1    = b1.dst.position.X - b1.src.position.X;
                float vy1    = b1.dst.position.Y - b1.src.position.Y;
                float sqLen1 = vx1 * vx1 + vy1 * vy1;
                float vx2    = b2.dst.position.X - b2.src.position.X;
                float vy2    = b2.dst.position.Y - b2.src.position.Y;
                float sqLen2 = vx2 * vx2 + vy2 * vy2;

                float dx = vx1 - vx2;
                float dy = vy1 - vy2;

                cost = (dx * dx + dy * dy) / Math.Max(sqLen1, sqLen2);
            }

            cost /= bonePairs.Count;

            return(cost);
        }
Example #2
0
        private void Form1_Load(object sender, EventArgs e)
        {
            //            FLib.FileManager.OpenExplorer("output");

            canvas.AllowDrop = true;

            renderer = new PatchMeshRenderer(canvas.Handle, canvas.ClientSize, true);

            // Magic2Dで作ったセグメントをロードしてパッチに変換
            Dictionary <string, PatchSkeletalMesh> dict;
            Dictionary <string, Bitmap>            bitmaps = new Dictionary <string, Bitmap>();

//            dict = Magic2D.SegmentToPatch.LoadPatches("../../../../..", "Patchwork_resources/GJ_ED3/3_segmentation", bitmaps, 2);
            // dict = Magic2D.SegmentToPatch.LoadPatches(@"C:\Users\furaga\Documents\Research\Patchwork\gj_kirara2", "3_segmentation", bitmaps, 4);
            dict = Magic2D.SegmentToPatch.LoadPatches("./settings", "3_segmentation", bitmaps, 4);

            System.Diagnostics.Debug.Assert(dict.Count == bitmaps.Count);


            // テクスチャをアセットに登録
            foreach (var kv in bitmaps)
            {
                var tex = SharpDXHelper.BitmapToTexture(kv.Value);
                resources.Add(kv.Key, tex);
                tex2bmp[tex] = kv.Value;
            }
            // パッチをキューに入れる
            for (int i = 0; i < dict.Count; i++)
            {
                string            resourceKey = bitmaps.Keys.ElementAt(i);
                string            textureKey  = dict.Keys.ElementAt(i);
                PatchSkeletalMesh patch       = dict.Values.ElementAt(i);
                renderQueryPool[resourceKey] = new RenderQuery(patch, new PatchTree(resourceKey), new List <string>()
                {
                    textureKey
                });
            }


            // パッチをリストに表示する
            foreach (var kv in bitmaps)
            {
                var patch = dict[kv.Key.Split(':')[1]];
                var skl   = patch.CopySkeleton();
                var bmp   = kv.Value;
                var bmp2  = DrawSkeltonOnBmp(skl, bmp);
                patchImageList.Images.Add(kv.Key, bmp2);
                patchView.Items.Add(kv.Key, kv.Key, kv.Key);
            }

            refSkeleton = PatchSkeleton.Load("./settings/refSkeleton.skl");

            canvas.MouseWheel += canvas_MouseWheel;
        }
Example #3
0
        Bitmap DrawSkeltonOnBmp(PatchSkeleton skl, Bitmap bmp)
        {
            Pen pen  = new Pen(Brushes.Blue, 3);
            var bmp2 = new Bitmap(bmp);

            using (var g = Graphics.FromImage(bmp2))
            {
                foreach (var b in skl.bones)
                {
                    g.DrawLine(pen, b.src.position, b.dst.position);
                }
            }
            return(bmp2);
        }
Example #4
0
        // seg.bmpはどこに格納する?patchmesh?pathcmeshrenderer?
        // => pathcMeshRendererResourcesに格納する
        static PatchSkeletalMesh ToPatchSkeletalMesh(Segment seg, Dictionary <string, Bitmap> bitmaps, int pathPointInterval)
        {
            PatchMesh           patchMesh     = ToPatchMesh(seg, pathPointInterval);
            PatchSkeleton       patchSkeleton = ToPatchSkeleton(seg);
            List <PatchSection> patchSections = ToPatchSections(seg, patchMesh.pathIndices.Select(i => patchMesh.vertices[i].position).ToList());

            // セグメントが使用するビットマップ画像をすべてコピーする。
            // この関数外でSharpDXHelper.ToTexture(bmp)を使って各画像をSharpDX描画用のテクスチャに変換する
            if (seg.bmp != null)
            {
                bitmaps[PatchMeshRenderResources.GenerateResourceKey(patchMesh, seg.name)] = new Bitmap(seg.bmp);
            }

            PatchSkeletalMesh skeletalMesh = new PatchSkeletalMesh(patchMesh, patchSkeleton, patchSections);

            return(skeletalMesh);
        }
Example #5
0
        //--------------------------------------------------------



        private static PatchSkeleton ToPatchSkeleton(Segment seg)
        {
            Dictionary <string, PatchSkeletonJoint> jointDict = new Dictionary <string, PatchSkeletonJoint>();
            PatchSkeleton skl = new PatchSkeleton();

            foreach (var j in seg.an.joints)
            {
                PointF pos = new PointF(j.position.X - seg.offset.X, j.position.Y - seg.offset.Y);
                jointDict[j.name] = new PatchSkeletonJoint(j.name, pos);
                skl.joints.Add(jointDict[j.name]);
            }
            foreach (var b in seg.an.bones)
            {
                skl.bones.Add(new PatchSkeletonBone(jointDict[b.src.name], jointDict[b.dst.name]));
            }
            return(skl);
        }
Example #6
0
        private void openOToolStripMenuItem_Click(object sender, EventArgs e)
        {
            openFileDialog.RestoreDirectory = true;
            openFileDialog.Filter           = "*.xml|*.xml";
            if (openFileDialog.ShowDialog() != System.Windows.Forms.DialogResult.OK)
            {
                return;
            }

            string dir      = System.IO.Path.GetDirectoryName(openFileDialog.FileName);
            string filename = System.IO.Path.GetFileNameWithoutExtension(openFileDialog.FileName);

            var saved = FLib.ForceSerializer.Deserialize <SaveObjects>(dir, filename);

            cameraPosition = new Vector3(saved.cameraX, saved.cameraY, saved.cameraZ);
            refSkeleton    = saved.refSkeleton;
        }
Example #7
0
        void UpdateConnectablePatchView(Dictionary <string, RenderQuery> renderQueryPool, List <RenderQuery> queries, PatchSkeleton refSkeleton)
        {
            var addKeys     = ConnectableRenderQueries(renderQueryPool, selectingQueries, refSkeleton);
            var removeItems = new List <ListViewItem>();

            foreach (ListViewItem item in connectablePatchView.Items)
            {
                if (!addKeys.Contains(item.ImageKey))
                {
                    removeItems.Add(item);
                }
            }

            foreach (var item in removeItems)
            {
                connectablePatchView.Items.Remove(item);
            }

            foreach (var k in addKeys)
            {
                connectablePatchView.Items.Add(k, k);
            }
        }
Example #8
0
        //--------------------------------------------------------------------
        // 選択中のパッチと接続可能なパッチの列挙
        //--------------------------------------------------------------------

        List <string> ConnectableRenderQueries(Dictionary <string, RenderQuery> renderQueryPool, List <RenderQuery> queries, PatchSkeleton refSkeleton)
        {
            List <PatchSkeletalMesh> smeshes = new List <PatchSkeletalMesh>();

            foreach (var q in queries)
            {
                smeshes.Add(q.patch);
            }

            var cmeshes = new List <string>();

            foreach (var kv in renderQueryPool)
            {
                smeshes.Add(kv.Value.patch);
                if (PatchConnector.CanConnect(smeshes, refSkeleton))
                {
                    cmeshes.Add(kv.Key);
                }
                smeshes.RemoveAt(smeshes.Count - 1);
            }

//            cmeshes.OrderBy(// TODO);

            return(cmeshes);
        }