Пример #1
0
        private void ComputeAssignments(PrimitiveCurve[] curves, CurveCategories category)
        {
            // get distance transforms of sketch curves according to the given category
            var distanceTransforms =
                (from idx in Enumerable.Range(0, sessionData.SketchObjects.Length)
                 where sessionData.SketchObjects[idx].CurveCategory == category
                 select new { Index = idx, DistanceTransform = sessionData.DistanceTransforms[idx] }
                ).ToArray();


            // compute matching costs using distance transform integral
            int[,] matchingMatrix = new int[curves.Length, distanceTransforms.Length];
            var matchingMatrixIndices =
                from i in Enumerable.Range(0, curves.Length)
                from j in Enumerable.Range(0, distanceTransforms.Length)
                select new { I = i, J = j };

            Parallel.ForEach(matchingMatrixIndices, item =>
            {
                var i                = item.I;
                var j                = item.J;
                var integral         = DistanceTransformIntegral.Compute(curves[i].Points, distanceTransforms[j].DistanceTransform);
                matchingMatrix[i, j] = (int)Math.Round(integral);
            });

            // compute minimum-cost assignments of primitive curves to sketch curves
            var matchingMatrixCopy = (int[, ])matchingMatrix.Clone();
            var assignments        = HungarianAlgorithm.FindMaxWeightAssignments(matchingMatrixCopy);

            // assign object curves to sketch curves according to the computed assignments
            for (int i = 0; i < assignments.Length; ++i)
            {
                var assignedTo      = assignments[i];
                var assignedToCurve = sessionData.SketchObjects[distanceTransforms[assignedTo].Index];
                curves[i].AssignedTo   = assignedToCurve;
                curves[i].ClosestPoint =
                    DistanceTransformIntegral.MinDistancePoint(
                        curves[i].Points,
                        distanceTransforms[assignedTo].DistanceTransform);
            }
        }
Пример #2
0
        private void ComputeAssignments(PrimitiveCurve[] curves, CurveCategories category)
        {
            curves = curves.Where(curve => !curve.isDeselected).ToArray();
            if (curves.Length == 0)
            {
                return;
            }

            // get distance transforms of sketch curves according to the given category
            var distanceTransforms =
                (from idx in Enumerable.Range(0, sessionData.SketchObjects.Length)
                 where sessionData.SketchObjects[idx].CurveCategory == category
                 where sessionData.SketchObjects[idx].isdeselected == false
                 select new { Index = idx, DistanceTransform = sessionData.DistanceTransforms[idx] }
                ).ToArray();

            //System.Diagnostics.Debug.WriteLine("Number:" + distanceTransforms.Length);

            // compute matching costs using distance transform integral
            if (distanceTransforms.Length > 0)
            {
                int[,] matchingMatrix = new int[curves.Length, distanceTransforms.Length];
                var matchingMatrixIndices =
                    from i in Enumerable.Range(0, curves.Length)
                    from j in Enumerable.Range(0, distanceTransforms.Length)
                    select new { I = i, J = j };
                Parallel.ForEach(matchingMatrixIndices, item =>
                {
                    var i                = item.I;
                    var j                = item.J;
                    var integral         = DistanceTransformIntegral.Compute(curves[i].Points, distanceTransforms[j].DistanceTransform);
                    matchingMatrix[i, j] = (int)Math.Round(integral);
                });

                // compute minimum-cost assignments of primitive curves to sketch curves
                int[] assignments = new int[curves.Length];

                if (distanceTransforms.Length > 1)
                {
                    assignments = HungarianAlgorithm.FindMaxWeightAssignments(matchingMatrix);
                }
                else
                {
                    if (curves.Length > 1)
                    {
                        if (matchingMatrix[0, 0] > matchingMatrix[1, 0])
                        {
                            assignments[0] = 0;
                            assignments[1] = -1;
                        }
                        else
                        {
                            assignments[1] = 0;
                            assignments[0] = -1;
                        }
                    }
                    else
                    {
                        assignments[0] = 0;
                    }
                }
                // assign object curves to sketch curves according to the computed assignments
                for (int i = 0; i < assignments.Length; ++i)
                {
                    var assignedTo = assignments[i];
                    if (assignedTo >= 0)
                    {
                        var assignedToCurve = sessionData.SketchObjects[distanceTransforms[assignedTo].Index];
                        curves[i].AssignedTo   = assignedToCurve;
                        curves[i].ClosestPoint =
                            DistanceTransformIntegral.MinDistancePoint(
                                curves[i].Points,
                                distanceTransforms[assignedTo].DistanceTransform);
                    }
                    else
                    {
                        curves[i].AssignedTo = null;
                    }
                }
            }
        }