Opposite() public static method

Determine the Opposite direction Left/Right are opposites as are Up and Down
public static Opposite ( Direction direction ) : Direction
direction Direction Direction to be toggled
return Direction
Exemplo n.º 1
0
        /// <summary>
        ///   This Method ensures a match is possible and if so clusters two nodes
        /// </summary>
        /// <param name="matchData"> MatchData Object </param>
        /// <returns> </returns>
        public static Cluster ClusterNodes(MatchData matchData)
        {
            INode       firstRoot  = matchData.First.Shred.Root();
            INode       secondRoot = matchData.Second.Shred.Root();
            ClusterData result     = IsMatch(matchData, firstRoot, secondRoot);

            if (result == null)
            {
                return(null);
            }

            // Mirror the smaller object if need be
            if (result.Match == Match.Inverted)
            {
                if (firstRoot.Size() < secondRoot.Size())
                {
                    firstRoot.Mirror();
                    result.FirstDirection = Enumeration.Opposite(result.FirstDirection);
                }
                else
                {
                    secondRoot.Mirror();
                    result.SecondDirection = Enumeration.Opposite(result.SecondDirection);
                }
            }

            // If the FirstNode's Edge is on the Right, it should go on the LEFT (make sense? )
            if (result.FirstDirection == Direction.FromRight && result.SecondDirection == Direction.FromLeft)
            {
                return(new Cluster(firstRoot, secondRoot, result.Match, matchData));
            }

            return(new Cluster(secondRoot, firstRoot, result.Match, matchData));
        }
Exemplo n.º 2
0
        /// <summary>
        ///   IsFit checks if given a specified side, it can be fit with a shreds's edge
        ///   This Also returns a match object
        /// </summary>
        /// <param name="root"> </param>
        /// <param name="shred"> </param>
        /// <param name="side"> </param>
        /// <returns> </returns>
        private static Tuple <Match, Direction> IsFit(INode root, Shred shred, Side side)
        {
            Side  query;
            Match match;

            if (side.Orientation != shred.Orientation)
            {
                query = new Side(shred, Enumeration.Opposite(side.Direction), shred.Orientation);
                match = Match.Inverted;
            }
            else
            {
                query = side;
                match = Match.NonInverted;
            }

            // If Directions match AND The Availablility then return match, otherwise impossible
            if (query.Direction == Direction.FromLeft && root.LeftEdge() == shred.LeftEdge())
            {
                return(new Tuple <Match, Direction>(match, Direction.FromLeft));
            }
            if (query.Direction == Direction.FromRight && root.RightEdge() == shred.RightEdge())
            {
                return(new Tuple <Match, Direction>(match, Direction.FromRight));
            }
            return(new Tuple <Match, Direction>(Match.Impossible, Direction.FromLeft));
        }
Exemplo n.º 3
0
        public void Mirror()
        {
            Edge swapEdge = _leftedge;

            _leftedge  = _rightedge;
            _rightedge = swapEdge;

            Orientation = Enumeration.Opposite(Orientation);
        }
Exemplo n.º 4
0
        /// <summary>
        ///   Given two shreds, calculate the offset value at which the two shreds are most similar
        /// </summary>
        /// <param name="first"> The first shred staged for comparison </param>
        /// <param name="second"> The other shred staged for comparison </param>
        /// <param name="directionA"> Direction of this shred to be compared </param>
        /// <param name="orientationA"> Orientation of this shred to be compared </param>
        /// <param name="directionB"> Direction of the other shred to be compared </param>
        /// <param name="orientationB"> Orientiation of the other shred to be compared </param>
        /// <returns> Tuple containing the max similarity value and the offset at which that occured </returns>
        public static MatchData CompareShred(Shred first,
                                             Shred second,
                                             Direction directionA,
                                             Orientation orientationA,
                                             Direction directionB,
                                             Orientation orientationB)
        {
            Side   sideA   = new Side(first, directionA, orientationA);
            Side   sideB   = new Side(second, directionB, orientationB);
            double penalty = 1.0;

            if (ORIENTATION_PENALTY)
            {
                if (first.TrueOrienation != null && second.TrueOrienation != null)
                {
                    if (!(
                            (first.TrueOrienation == orientationA && second.TrueOrienation == orientationB) ||
                            (first.TrueOrienation == Enumeration.Opposite(orientationA) && second.TrueOrienation == Enumeration.Opposite(orientationB))))
                    {
                        penalty = 0.15;
                    }
                }
            }

            if (NORMALIZATION_ENABLED)
            {
                double max = Chamfer.NormalizedSimilarity(
                    first.GetChamfer(directionA, orientationA),
                    second.GetChamfer(directionB, orientationB));
                double[] scan = new double[1];

                return(new MatchData(max * penalty, 0, scan, sideA, sideB));
            }
            else
            {
                double[] scan = Chamfer.ScanSimilarity(
                    first.GetChamfer(directionA, orientationA),
                    second.GetChamfer(directionB, orientationB));

                Tuple <double, int> maxData = Utility.Max(scan);
                double max  = maxData.Item1;
                int    best = maxData.Item2;
                return(new MatchData(max * penalty, best, scan, sideA, sideB));
            }
        }