Example #1
0
        /// <summary>
        /// Compare intersection events.
        /// </summary>
        /// <param name="eventA">The first intersection event to compare.</param>
        /// <param name="eventB">The second intersection event to compare.</param>
        /// <param name="relativePointTolerance">The comparison tolerance. If RhinoMath.UnsetValue, then RhinoMath.SqrtEpsilon is used.</param>
        /// <param name="log">If not null and false is returned, then a description of the error is appended to log.</param>
        /// <returns></returns>
        public static bool CompareEquivalent(IntersectionEvent eventA, IntersectionEvent eventB, double relativePointTolerance, Rhino.FileIO.TextLog log)
        {
            // compare to match
            if (relativePointTolerance == RhinoMath.UnsetValue)
            {
                relativePointTolerance = RhinoMath.SqrtEpsilon;
            }

            bool rc = true;

            if (eventA.m_type != eventB.m_type)
            {
                if (log != null)
                {
                    log.Print("Event types mismatch.");
                }
                rc = false;
            }
            else
            {
                for (int ei = 0; ei < 2; ei++)
                {
                    if (ei == 1 && eventA.m_type != 4) // ON_X_EVENT::TYPE::csx_overlap
                    {
                        continue;
                    }

                    Point3d AActual = (ei == 0) ? eventA.m_A0 : eventA.m_A1;
                    Point3d BActual = (ei == 0) ? eventA.m_B0 : eventA.m_B1;
                    Point3d AExp    = (ei == 0) ? eventB.m_A0 : eventB.m_A1;
                    Point3d BExp    = (ei == 0) ? eventB.m_B0 : eventB.m_B1;

                    double sz   = AExp.MaximumCoordinate;
                    double dist = AActual.DistanceTo(AExp);
                    if (dist > relativePointTolerance * (1 + sz))
                    {
                        if (log != null)
                        {
                            log.Print("Event mismatch. Distance between expected and actual m_A{0} was {1}.\n", ei * 2, dist);
                        }
                        rc = false;
                    }

                    dist = BActual.DistanceTo(BExp);
                    if (dist > relativePointTolerance * (1 + sz))
                    {
                        if (log != null)
                        {
                            log.Print("Event mismatch. Distance between expected and actual m_B{0} was {1}.\n", ei * 2, dist);
                        }
                        rc = false;
                    }
                }
            }
            return(rc);
        }
Example #2
0
        public static Line PickLine(this List <Line> lines, string method, Random random = null, List <Curve> roads = null, Curve originalBound = null)
        {
            if (lines.Count == 0)
            {
                return(new Line());
            }

            //====================================================================//

            else if (method == "random") //selects line randomly
            {
                Line line = lines[random.Next(lines.Count)];
                return(line);
            }

            //====================================================================//

            else if (method == "shortest") //selects shortest line
            {
                return(lines.OrderBy(x => x.Length).ToList()[0]);
            }

            //====================================================================//

            else if (method == "boundary") //selects line on boundary
            {
                List <Line> posLines = new List <Line>();

                foreach (Line l in lines)
                {
                    isc.CurveIntersections i = isc.Intersection.CurveCurve(originalBound, l.ToNurbsCurve(), Tolerance.Distance, Tolerance.Distance);
                    if (i.Count > 0)
                    {
                        isc.IntersectionEvent ie = i[0];
                        if (ie.IsOverlap)
                        {
                            posLines.Add(l);
                        }
                    }
                }
                return(posLines[random.Next(posLines.Count)]);
            }

            //====================================================================//

            else if (method == "roads") //select line on road
            {
                List <Line> posLines = new List <Line>();

                foreach (Line l in lines)
                {
                    foreach (Curve road in roads)
                    {
                        isc.CurveIntersections i = isc.Intersection.CurveCurve(road, l.ToNurbsCurve(), Tolerance.Distance, Tolerance.Distance);
                        if (i.Count > 0)
                        {
                            isc.IntersectionEvent ie = i[0];
                            if (ie.IsOverlap)
                            {
                                posLines.Add(l);
                                goto nextLine;
                            }
                        }
                    }
                    nextLine :;
                }
                if (posLines.Count != 0)
                {
                    return(posLines[random.Next(posLines.Count)]);
                }
                else
                {
                    return(new Line());
                }
            }

            //====================================================================//

            else if (method == "boundary first") //selects line on boundary first and then randomly is there are none. TODO: Make it work. :)
            {
                List <Line> posLines = new List <Line>();

                foreach (Line l in lines)
                {
                    isc.CurveIntersections i = isc.Intersection.CurveCurve(originalBound, l.ToNurbsCurve(), Tolerance.Distance, Tolerance.Distance);
                    if (i.Count > 0)
                    {
                        isc.IntersectionEvent ie = i[0];
                        if (ie.IsOverlap)
                        {
                            posLines.Add(l);
                        }
                    }
                }
                if (posLines.Count == 0)
                {
                    return(lines.PickLine("random", random, roads, originalBound));
                }

                return(posLines[random.Next(posLines.Count)]);
            }

            //====================================================================//

            else if (method == "longest") //returns longest line
            {
                return(lines.OrderBy(x => x.Length).ToList()[lines.Count - 1]);
            }

            //====================================================================//

            else // TODO: Fix issue with try/catch in PlaceHouseRow.
            {
                throw new NotImplementedException("The methods yo can choose from are 'shortest', 'longest', 'random', 'boundary' and 'boundary first'.");
            }
        }
Example #3
0
 /// <summary>
 /// Compare intersection events.
 /// </summary>
 /// <param name="eventA">The first intersection event to compare.</param>
 /// <param name="eventB">The second intersection event to compare.</param>
 /// <param name="relativePointTolerance">The comparison tolerance. If RhinoMath.UnsetValue, then RhinoMath.SqrtEpsilon is used.</param>
 /// <returns>true if the two inputs represent the same intersection, false otherwise.</returns>
 public static bool CompareEquivalent(IntersectionEvent eventA, IntersectionEvent eventB, double relativePointTolerance)
 {
     return(CompareEquivalent(eventA, eventB, relativePointTolerance, null));
 }