Beispiel #1
0
        //visualize glare lines
        public static List <Line3d> VisualizeGlareLines(List <Point3d> floorPoints, List <Point3d> furniturePoints,
                                                        List <Point3d> lightPoints, double threshDist = 10, int index = 0)
        {
            for (int i = 0; i < floorPoints.Count; i++)
            {
                List <Point3d> selectedPts = new List <Point3d>();
                Point2d        pt2FloorPt  = ConvertToPoint2d(floorPoints[i]);
                for (int j = 0; j < furniturePoints.Count; j++)
                {
                    Point2d pt2Furniture = ConvertToPoint2d(furniturePoints[j]);
                    double  distance     = PointUtility.DistanceBetweenPoints(pt2Furniture, pt2FloorPt);
                    if (distance < threshDist)
                    {
                        selectedPts.Add(furniturePoints[j]);
                    }
                }// end of j for loop
                if (selectedPts.Count > 1)
                {
                    lightPoints.AddRange(selectedPts);
                }
            }
            List <Line3d> glareLines = new List <Line3d>();

            for (int i = 0; i < lightPoints.Count; i++)
            {
                if (lightPoints[i].X > floorPoints[index].X)
                {
                    glareLines.Add(new Line3d(floorPoints[index], lightPoints[i]));
                }
            }
            return(glareLines);
        }
        public static Dictionary <string, object> SplitByDistance(Polygon2d polyOutline, Random ran, double distance = 10, int dir = 0, double spacing = 0)
        {
            if (!ValidateObject.CheckPoly(polyOutline))
            {
                return(null);
            }
            double         extents = 5000, spacingProvided;
            List <Point2d> polyOrig = polyOutline.Points;

            if (spacing == 0)
            {
                spacingProvided = BuildLayout.SPACING;
            }
            else
            {
                spacingProvided = spacing;
            }

            List <Point2d> poly = PolygonUtility.SmoothPolygon(polyOrig, spacingProvided);

            if (!ValidateObject.CheckPointList(poly))
            {
                return(null);
            }
            Dictionary <int, object> obj = PointUtility.PointSelector(ran, poly);
            Point2d pt        = (Point2d)obj[0];
            int     orient    = (int)obj[1];
            Line2d  splitLine = new Line2d(pt, extents, dir);

            // push this line right or left or up or down based on ratio
            if (dir == 0)
            {
                splitLine = LineUtility.Move(splitLine, 0, orient * distance);
            }
            else
            {
                splitLine = LineUtility.Move(splitLine, orient * distance, 0);
            }

            Dictionary <string, object> intersectionReturn = MakeIntersections(poly, splitLine, spacingProvided);
            List <Point2d>   intersectedPoints             = (List <Point2d>)intersectionReturn["IntersectedPoints"];
            List <Polygon2d> splittedPoly = (List <Polygon2d>)intersectionReturn["PolyAfterSplit"];
            List <Point2d>   ptA = (List <Point2d>)intersectionReturn["PointASide"];
            List <Point2d>   ptB = (List <Point2d>)intersectionReturn["PointBSide"];
            Polygon2d        polyA = new Polygon2d(ptA, 0), polyB = new Polygon2d(ptB, 0);

            //List<Polygon2d> splittedPoly = new List<Polygon2d>();
            //splittedPoly.Add(polyA); splittedPoly.Add(polyB);
            return(new Dictionary <string, object>
            {
                { "PolyAfterSplit", (splittedPoly) },
                { "SplitLine", (splitLine) },
                { "IntersectedPoints", (intersectedPoints) },
                { "PointASide", (ptA) },
                { "PointBSide", (ptB) }
            });
        }
Beispiel #3
0
        //check if a given polygon2d has any of its longer edges aligned with any edge of the containerpolygon2d
        internal static bool CheckPolyGetsExternalWall(Polygon2d poly, Polygon2d containerPoly, double shortEdgeDist = 16, bool tag = true)
        {
            bool check = false;

            if (!ValidateObject.CheckPoly(poly))
            {
                return(check);
            }
            Polygon2d polyReg = new Polygon2d(null);

            //make given polys reduce number of points
            if (tag)
            {
                polyReg = new Polygon2d(poly.Points);
            }
            else
            {
                polyReg = poly;
            }
            Polygon2d containerPolyReg = new Polygon2d(containerPoly.Points);

            for (int i = 0; i < polyReg.Points.Count; i++)
            {
                int    a = i, b = i + 1;
                double eps = 0;
                if (i == polyReg.Points.Count - 1)
                {
                    b = 0;
                }
                double        distance    = PointUtility.DistanceBetweenPoints(polyReg.Points[a], polyReg.Points[b]);
                List <double> spansSorted = PolygonUtility.GetPolySpan(containerPolyReg);
                if (distance <= spansSorted[0] * 0.75)
                {
                    continue;
                }
                Line2d lineA = Line2d.ByStartPointEndPoint(polyReg.Points[a], polyReg.Points[b]);
                for (int j = 0; j < containerPolyReg.Points.Count; j++)
                {
                    int c = j, d = j + 1;
                    if (j == containerPolyReg.Points.Count - 1)
                    {
                        d = 0;
                    }
                    Line2d lineB = Line2d.ByStartPointEndPoint(containerPolyReg.Points[c], containerPolyReg.Points[d]);
                    check = GraphicsUtility.LineAdjacencyCheck(lineA, lineB, eps);
                    if (check)
                    {
                        break;
                    }
                }
                if (check)
                {
                    break;
                }
            }
            return(check);
        }
Beispiel #4
0
        internal static Dictionary <string, object> ComputePolyCentersAlign(Polygon2d polyA, Polygon2d polyB)
        {
            //compute orig centers
            Point2d centerPolyA = PointUtility.CentroidInPointLists(polyA.Points);
            Point2d centerPolyB = PointUtility.CentroidInPointLists(polyB.Points);

            Point2d   staticPoint, movingPoint;
            Polygon2d staticPoly, movingPoly;

            double areaPolyA = PolygonUtility.AreaPolygon(polyA);
            double areaPolyB = PolygonUtility.AreaPolygon(polyB);

            if (areaPolyA > areaPolyB)
            {
                staticPoint = centerPolyB;
                staticPoly  = polyB;
                movingPoint = centerPolyA;
                movingPoly  = polyA;
            }
            else
            {
                staticPoint = centerPolyA;
                staticPoly  = polyA;
                movingPoint = centerPolyB;
                movingPoly  = polyB;
            }

            //shift the other points
            Point2d movingPoint1   = new Point2d(staticPoint.X, movingPoint.Y);
            Point2d movingPoint2   = new Point2d(movingPoint.X, staticPoint.Y);
            bool    IsMovingPoint1 = GraphicsUtility.PointInsidePolygonTest(movingPoly, movingPoint1);
            bool    IsMovingPoint2 = GraphicsUtility.PointInsidePolygonTest(movingPoly, movingPoint2);

            if (IsMovingPoint1)
            {
                movingPoint = movingPoint1;
            }
            else if (IsMovingPoint2)
            {
                movingPoint = movingPoint2;
            }
            else
            {
                staticPoint = centerPolyA;
                staticPoly  = polyA;
                movingPoint = movingPoint1;
                movingPoly  = polyB;
            }

            return(new Dictionary <string, object>
            {
                { "CenterPolyA", (staticPoint) },
                { "CenterPolyB", (movingPoint) },
                { "PolyA", (staticPoly) },
                { "PolyB", (movingPoly) }
            });
        }
        public static Dictionary <string, object> SplitByDistanceFromPoint(Polygon2d polyOutline, double distance = 10, int dir = 0, double space = 0)
        {
            if (polyOutline == null || polyOutline.Points == null || polyOutline.Points.Count == 0)
            {
                return(null);
            }
            if (space == 0)
            {
                space = BuildLayout.SPACING2;
            }
            double         extents     = 5000;
            int            threshValue = 50;
            List <Point2d> polyOrig    = polyOutline.Points;
            List <Point2d> poly        = new List <Point2d>();

            if (polyOrig.Count > threshValue)
            {
                poly = polyOrig;
            }
            else
            {
                poly = PolygonUtility.SmoothPolygon(polyOrig, space);
            }

            if (poly == null || poly.Count == 0)
            {
                return(null);
            }
            int     lowInd    = PointUtility.LowestPointFromList(poly);
            Point2d lowPt     = poly[lowInd];
            Line2d  splitLine = new Line2d(lowPt, extents, dir);

            if (dir == 0)
            {
                splitLine = LineUtility.Move(splitLine, 0, 1 * distance);
            }
            else
            {
                splitLine = LineUtility.Move(splitLine, 1 * distance, 0);
            }

            Dictionary <string, object> intersectionReturn = MakeIntersections(poly, splitLine, space);
            List <Point2d>   intersectedPoints             = (List <Point2d>)intersectionReturn["IntersectedPoints"];
            List <Polygon2d> splittedPoly = (List <Polygon2d>)intersectionReturn["PolyAfterSplit"];
            List <Point2d>   ptA          = (List <Point2d>)intersectionReturn["PointASide"];
            List <Point2d>   ptB          = (List <Point2d>)intersectionReturn["PointBSide"];

            return(new Dictionary <string, object>
            {
                { "PolyAfterSplit", (splittedPoly) },
                { "SplitLine", (splitLine) },
                { "IntersectedPoints", (intersectedPoints) },
                { "PointASide", (ptA) },
                { "PointBSide", (ptB) }
            });
        }
Beispiel #6
0
        // finds the angle between two points wrt Origin - not sure
        internal static double AngleBetweenPoint2d(Point2d A, Point2d center)
        {
            double angle = Math.Acos((A.X - center.X) / PointUtility.DistanceBetweenPoints(center, A));

            if (A.Y < center.Y)
            {
                angle = Math.PI + Math.PI - angle; //360-angle
            }
            return(angle);                         //return angle*180/Math.PI;
        }
        //pushes the line midpt towards the center of the given polygon2d
        internal static Point2d NudgeLineMidPt(Line2d line, Polygon2d poly, double scale = 0.2)
        {
            Point2d  midPt         = LineMidPoint(line);
            Point2d  polyCenter    = PointUtility.CentroidInPointLists(poly.Points);
            Vector2d vecToCenter   = new Vector2d(midPt, polyCenter);
            Vector2d vecNormalized = vecToCenter.Normalize();
            Vector2d vecScaled     = vecNormalized.Scale(scale);

            return(new Point2d(midPt.X + vecScaled.X, midPt.Y + vecScaled.Y));
        }
        // find the centroid of a group of  cells
        internal static Point2d CentroidInCells(List <Cell> cellList)
        {
            List <Point2d> ptList = new List <Point2d>();

            for (int i = 0; i < cellList.Count; i++)
            {
                ptList.Add(cellList[i].CenterPoint);
            }
            return(PointUtility.CentroidInPointLists(ptList));
        }
Beispiel #9
0
        //line and polygon intersection - not using now
        public static Line2d LinePolygonIntersectionReturnLine(List <Point2d> poly, Line2d testLine, Point2d centerPt)
        {
            Random ran  = new Random();
            double dist = 10000000000000000;
            SortedDictionary <double, Line2d> sortedIntersectionLines = new SortedDictionary <double, Line2d>();
            List <Point2d> ptList = new List <Point2d>();
            double         x      = (testLine.StartPoint.X + testLine.EndPoint.X) / 2;
            double         y      = (testLine.StartPoint.Y + testLine.EndPoint.Y) / 2;
            Point2d        midPt  = new Point2d(x, y);
            Line2d         intersectedLineInPoly = null;
            int            count = 0;

            for (int i = 0; i < poly.Count - 1; i++)
            {
                Point2d pt1  = poly[i];
                Point2d pt2  = poly[i + 1];
                Line2d  edge = new Line2d(pt1, pt2);

                if (LineLineIntersectionNew(edge, testLine) != null)
                {
                    double  xE        = (edge.StartPoint.X + edge.EndPoint.X) / 2;
                    double  yE        = (edge.StartPoint.Y + edge.EndPoint.Y) / 2;
                    Point2d EdgeMidPt = new Point2d(xE, yE);
                    double  checkDist = PointUtility.DistanceBetweenPoints(centerPt, EdgeMidPt);
                    try
                    {
                        sortedIntersectionLines.Add(checkDist, edge);
                    }
                    catch (Exception)
                    {
                        double eps     = ran.NextDouble() * 2;
                        double newDist = checkDist - eps;
                        sortedIntersectionLines.Add(newDist, edge);
                    }
                    intersectedLineInPoly = edge;
                    count += 1;
                }
            }
            if (sortedIntersectionLines.Count > 0)
            {
                foreach (KeyValuePair <double, Line2d> p in sortedIntersectionLines)
                {
                    intersectedLineInPoly = p.Value;
                    break;
                }
            }
            else
            {
                intersectedLineInPoly = null;
            }
            return(intersectedLineInPoly);
        }
        //moves a line by a given distance inside a given poly
        internal static Line2d Move(Line2d line, List <Point2d> poly, double distance)
        {
            Point2d  midPt        = LineMidPoint(line);
            Point2d  centerPoly   = PointUtility.CentroidInPointLists(poly);
            Vector2d vecToCenter  = new Vector2d(midPt, centerPoly);
            Vector2d vecToCenterN = vecToCenter.Normalize();
            Vector2d vectScaled   = vecToCenter.Scale(distance);

            Point2d start = new Point2d((line.StartPoint.X + vectScaled.X), (line.StartPoint.Y + vectScaled.Y));
            Point2d end   = new Point2d((line.EndPoint.X + vectScaled.X), (line.EndPoint.Y + vectScaled.Y));

            return(new Line2d(start, end));
        }
        //joins two collinear lines to make one line
        public static Line2d JoinCollinearLines(Line2d lineA, Line2d lineB)
        {
            List <Point2d> allPoints = new List <Point2d>();

            allPoints.Add(lineA.StartPoint);
            allPoints.Add(lineA.EndPoint);
            allPoints.Add(lineB.StartPoint);
            allPoints.Add(lineB.EndPoint);
            int    p          = PointUtility.LowestPointFromList(allPoints);
            int    q          = PointUtility.HighestPointFromList(allPoints);
            Line2d lineJoined = new Line2d(allPoints[p], allPoints[q]);

            return(lineJoined);
        }
Beispiel #12
0
        //computes the UGR value
        internal static double CalculateUGR(List <Point3d> lightPts, Point3d observer, List <double> posList, double lightSize = 2, double recompute = 1)
        {
            double backLum = 10;
            double lumin = 10;
            double angleEach = 0;
            double guthPos = 2;
            double value = 0;
            double summation = 0;
            int    pos = 0, m = 0;

            for (int i = 0; i < lightPts.Count; i++)
            {
                if (m < posList.Count && i == (int)posList[m])
                {
                    lumin = recompute * lumin; m += 1;
                }
                else
                {
                    lumin = 10;
                }
                if (lightPts[i].X > observer.X)
                {
                    Point2d ptLight2d    = ConvertToPoint2d(lightPts[i]);
                    Point2d ptObserver2d = ConvertToPoint2d(observer);
                    double  distance     = PointUtility.DistanceBetweenPoints(ptLight2d, ptObserver2d);
                    guthPos = distance;

                    Point3d  lightPt1 = new Point3d((lightPts[i].X - lightSize), (lightPts[i].Y - lightSize), lightPts[i].Z);
                    Point3d  lightPt2 = new Point3d((lightPts[i].X + lightSize), (lightPts[i].Y + lightSize), lightPts[i].Z);
                    Vector3d vec1     = new Vector3d(observer, lightPt1);
                    Vector3d vec2     = new Vector3d(observer, lightPt2);
                    angleEach  = VectorUtility.AngleBetweenVec3d(vec1, vec2);
                    summation += (lumin * lumin * angleEach) / (guthPos * guthPos);
                }
            }
            value = (0.25 / backLum) * summation;
            if (value == 0)
            {
                return(0);
            }
            double ugr = 8 * Math.Log10(value);

            if (ugr < 0)
            {
                ugr = 0;
            }
            return(ugr);
        }
Beispiel #13
0
        //sorts list of points by distance from a given point
        public static List <Point2d> SortPointsByDistanceFromPoint(List <Point2d> ptList, Point2d testPoint)
        {
            List <Point2d> sortedPtList = new List <Point2d>();
            List <double>  distanceList = new List <double>();
            List <int>     indexList    = new List <int>();

            for (int i = 0; i < ptList.Count; i++)
            {
                distanceList.Add(PointUtility.DistanceBetweenPoints(ptList[i], testPoint));
            }
            indexList = BasicUtility.SortIndex(distanceList);
            for (int i = 0; i < indexList.Count; i++)
            {
                sortedPtList.Add(ptList[indexList[i]]);
            }
            return(sortedPtList);
        }
        }         // end of function

        //makes intersections and returns the two polygon2ds after intersection
        internal static Dictionary <string, object> MakeIntersections(List <Point2d> poly, Line2d splitLine, double space = 0)
        {
            List <Point2d> intersectedPoints = GraphicsUtility.LinePolygonIntersection(poly, splitLine);
            //List<Point2d> intersectedPoints = TestGraphicsUtility.LinePolygonIntersectionIndex(poly, splitLine);
            // find all points on poly which are to the left or to the right of the line
            List <int> pIndexA = new List <int>();
            List <int> pIndexB = new List <int>();

            for (int i = 0; i < poly.Count; i++)
            {
                bool check = ValidateObject.CheckPointSide(splitLine, poly[i]);
                if (check)
                {
                    pIndexA.Add(i);
                }
                else
                {
                    pIndexB.Add(i);
                }
            }
            //organize the points to make closed poly
            List <Point2d> sortedA = PointUtility.DoSortClockwise(poly, intersectedPoints, pIndexA);
            List <Point2d> sortedB = PointUtility.DoSortClockwise(poly, intersectedPoints, pIndexB);

            /*List<Polygon2d> splittedPoly = new List<Polygon2d>();
             * if (space == 0) splittedPoly = new List<Polygon2d> { new Polygon2d(sortedA, 0), new Polygon2d(sortedB, 0) };
             * else
             * {
             *   sortedA = PolygonUtility.SmoothPolygon(new Polygon2d(sortedA,0).Points, space);
             *   sortedB = PolygonUtility.SmoothPolygon(new Polygon2d(sortedB,0).Points, space);
             *   splittedPoly = new List<Polygon2d> { new Polygon2d(sortedA, 0), new Polygon2d(sortedB, 0) };
             * }
             */
            List <Polygon2d> splittedPoly = new List <Polygon2d> {
                new Polygon2d(sortedA, 0), new Polygon2d(sortedB, 0)
            };

            return(new Dictionary <string, object>
            {
                { "PolyAfterSplit", (splittedPoly) },
                { "IntersectedPoints", (intersectedPoints) },
                { "PointASide", (sortedA) },
                { "PointBSide", (sortedB) }
            });
        }
        public static Dictionary <string, object> SplitByLine(Polygon2d polyOutline, Line2d inputLine, double distance = 5)
        {
            if (!ValidateObject.CheckPoly(polyOutline))
            {
                return(null);
            }
            List <Point2d> polyOrig   = polyOutline.Points;
            List <Point2d> poly       = PolygonUtility.SmoothPolygon(polyOrig, BuildLayout.SPACING);
            Line2d         splitLine  = new Line2d(inputLine);
            Point2d        centerPoly = PointUtility.CentroidInPointLists(poly);
            bool           checkSide  = ValidateObject.CheckPointSide(splitLine, centerPoly);
            int            orient     = ValidateObject.CheckLineOrient(splitLine);

            if (orient == 0)
            {
                if (!checkSide)
                {
                    splitLine = LineUtility.Move(splitLine, 0, -1 * distance);
                }
                else
                {
                    splitLine = LineUtility.Move(splitLine, 0, 1 * distance);
                }
            }
            else
            {
                if (checkSide)
                {
                    splitLine = LineUtility.Move(splitLine, -1 * distance, 0);
                }
                else
                {
                    splitLine = LineUtility.Move(splitLine, 1 * distance, 0);
                }
            }

            Dictionary <string, object> intersectionReturn = MakeIntersections(poly, splitLine, BuildLayout.SPACING);
            List <Polygon2d>            splittedPoly       = (List <Polygon2d>)intersectionReturn["PolyAfterSplit"];

            return(new Dictionary <string, object>
            {
                { "PolyAfterSplit", (splittedPoly) },
                { "SplitLine", (splitLine) }
            });
        }
Beispiel #16
0
        internal static Dictionary <string, object> FindOuterLinesAndOffsets(Polygon2d poly, double patientRoomDepth = 16, double extension = 8000, double recompute = 5)
        {
            if (!ValidateObject.CheckPoly(poly))
            {
                return(null);
            }
            Polygon2d      polyReg = new Polygon2d(poly.Points);
            List <Line2d>  hLines = new List <Line2d>();
            List <Line2d>  vLines = new List <Line2d>();
            List <Point2d> hMidPt = new List <Point2d>();
            List <Point2d> vMidPt = new List <Point2d>();
            List <Line2d>  nonOrthoLines = new List <Line2d>();
            int            countOrtho = 0, countNonOrtho = 0;

            for (int i = 0; i < polyReg.Points.Count; i++)
            {
                int a = i, b = i + 1;
                if (i == polyReg.Points.Count - 1)
                {
                    b = 0;
                }
                Line2d line     = new Line2d(polyReg.Points[a], polyReg.Points[b]);
                int    lineType = ValidateObject.CheckLineOrient(line);
                if (lineType > -1)
                {
                    if (lineType == 0)
                    {
                        Line2d extendedLine = LineUtility.ExtendLine(line, extension);
                        hLines.Add(extendedLine);
                        hMidPt.Add(LineUtility.LineMidPoint(line));
                    }
                    if (lineType == 1)
                    {
                        Line2d extendedLine = LineUtility.ExtendLine(line, extension);
                        vLines.Add(extendedLine);
                        vMidPt.Add(LineUtility.LineMidPoint(line));
                    }
                    countOrtho += 1;
                }
                else
                {
                    countNonOrtho += 1;
                    nonOrthoLines.Add(line);
                }
            }
            List <Line2d> selectedHLines = new List <Line2d>();
            List <Line2d> selectedVLines = new List <Line2d>();
            int           hIndLow        = CodeToBeTested.ReturnLowestPointFromList(hMidPt);
            int           hIndHigh       = CodeToBeTested.ReturnHighestPointFromList(hMidPt);
            int           vIndLow        = PointUtility.LowestPointFromList(vMidPt);
            int           vIndHigh       = PointUtility.HighestPointFromList(vMidPt);

            if (hIndLow > -1)
            {
                selectedHLines.Add(hLines[hIndLow]);
            }
            if (hIndHigh > -1)
            {
                selectedHLines.Add(hLines[hIndHigh]);
            }
            if (vIndLow > -1)
            {
                selectedVLines.Add(vLines[vIndLow]);
            }
            if (vIndHigh > -1)
            {
                selectedVLines.Add(vLines[vIndHigh]);
            }

            List <Line2d> allSplitLines = new List <Line2d>();

            allSplitLines.AddRange(selectedHLines);
            allSplitLines.AddRange(selectedVLines);
            List <double> splitLineLength = new List <double>();

            for (int i = 0; i < allSplitLines.Count; i++)
            {
                splitLineLength.Add(allSplitLines[i].Length);
            }
            List <int> sortedIndices = BasicUtility.Quicksort(splitLineLength);

            if (sortedIndices != null)
            {
                sortedIndices.Reverse();
            }

            List <Line2d>  offsetLines   = new List <Line2d>();
            List <Point2d> midPtsOffsets = new List <Point2d>();

            for (int i = 0; i < allSplitLines.Count; i++)
            {
                offsetLines.Add(LineUtility.Offset(allSplitLines[i], patientRoomDepth));
                midPtsOffsets.Add(LineUtility.NudgeLineMidPt(allSplitLines[i], poly, patientRoomDepth));
            }

            List <Line2d> offsetSortedLines = new List <Line2d>();

            for (int i = 0; i < offsetLines.Count; i++)
            {
                offsetSortedLines.Add(offsetLines[sortedIndices[i]]);
            }
            return(new Dictionary <string, object>
            {
                { "SplittableLines", (allSplitLines) },
                { "OffsetLines", (offsetSortedLines) },
                { "SortedIndices", (sortedIndices) },
                { "OffsetMidPts", (midPtsOffsets) },
                { "NonOrthoLines", (nonOrthoLines) }
            });
        }
Beispiel #17
0
        //compute glare  values
        public static List <List <double> > ComputeGlareValues(List <Point3d> floorPoints, List <Point3d> furniturePoints,
                                                               List <Point3d> lightPoints, double threshDist = 10, double lightSize = 3, double numSpecialLights = 2, double recompute = 1)
        {
            int           pos      = 0;
            List <double> posList  = new List <double>();
            List <double> distList = new List <double>();
            List <double> ugrList  = new List <double>();
            int           count    = 0;
            double        numD     = BasicUtility.RandomBetweenNumbers(new Random(), 0.1, 0.35);

            for (int i = 0; i < numSpecialLights; i++)
            {
                posList.Add(lightPoints.Count * (i + 1) * numD);
            }

            pos = (int)(lightPoints.Count * 0.20);
            for (int i = 0; i < floorPoints.Count; i++)
            {
                List <Point3d> selectedPts = new List <Point3d>();
                Point2d        pt2FloorPt  = ConvertToPoint2d(floorPoints[i]);
                for (int j = 0; j < furniturePoints.Count; j++)
                {
                    Point2d pt2Furniture = ConvertToPoint2d(furniturePoints[j]);
                    double  distance     = PointUtility.DistanceBetweenPoints(pt2Furniture, pt2FloorPt);
                    distList.Add(distance);
                    if (distance < threshDist)
                    {
                        selectedPts.Add(furniturePoints[j]);
                    }
                }// end of j for loop
                if (selectedPts.Count > 0)
                {
                    lightPoints.AddRange(selectedPts);
                }
                double ugrValue = CalculateUGR(lightPoints, floorPoints[i], posList, lightSize, recompute);
                ugrList.Add(ugrValue);
                count += 1;
            }
            List <double> val2 = new List <double>(), val3 = new List <double>();

            for (int n = 0; n < ugrList.Count; n++)
            {
                val2.Add(0); val3.Add(0);
            }
            List <double>         ugrListNormalized = BasicUtility.NormalizeList(ugrList, 0, 255);
            List <List <double> > result            = new List <List <double> >();

            result.Add(ugrListNormalized);
            result.Add(val2);
            result.Add(val3);
            result.Add(distList);
            result.Add(new List <double> {
                count
            });
            result.Add(ugrList);
            result.Add(new List <double> {
                lightSize
            });
            result.Add(posList);
            return(result);
        }
Beispiel #18
0
        internal static Dictionary <string, object> PolygonPolygonCommonEdgeDict(Polygon2d poly, Polygon2d other)
        {
            bool check = false;

            if (poly == null || other == null)
            {
                return(null);
            }

            double    eps      = 200;
            Polygon2d polyReg  = new Polygon2d(poly.Points);
            Polygon2d otherReg = new Polygon2d(other.Points);
            Dictionary <string, object> UpdatedCenters = ComputePolyCentersAlign(polyReg, otherReg);

            Point2d centerPoly  = (Point2d)UpdatedCenters["CenterPolyA"];
            Point2d centerOther = (Point2d)UpdatedCenters["CenterPolyB"];

            polyReg  = (Polygon2d)UpdatedCenters["PolyA"];
            otherReg = (Polygon2d)UpdatedCenters["PolyB"];
            //make vectors
            Vector2d centerToCen  = new Vector2d(centerPoly, centerOther);
            Vector2d centerToCenX = new Vector2d(centerToCen.X, 0);
            Vector2d centerToCenY = new Vector2d(0, centerToCen.Y);
            //make centerLine
            Line2d   centerLine = new Line2d(centerPoly, centerOther);
            Vector2d keyVec;

            if (centerToCenX.Length > centerToCenY.Length)
            {
                keyVec = new Vector2d(centerToCenX.X, centerToCenX.Y);
            }
            else
            {
                keyVec = new Vector2d(centerToCenY.X, centerToCenY.Y);
            }
            //check line poly intersection between centertocen vector and each polys
            Line2d lineInPolyReg  = CodeToBeTested.LinePolygonIntersectionReturnLine(polyReg.Points, centerLine, centerOther);
            Line2d lineInOtherReg = CodeToBeTested.LinePolygonIntersectionReturnLine(otherReg.Points, centerLine, centerPoly);

            //find distance d1 and d2 from two centers to linepolyintersection line
            Point2d projectedPtOnPolyReg  = GraphicsUtility.ProjectedPointOnLine(lineInPolyReg, centerPoly);
            Point2d projectedPtOnOtherReg = GraphicsUtility.ProjectedPointOnLine(lineInOtherReg, centerOther);

            double dist1 = PointUtility.DistanceBetweenPoints(centerPoly, projectedPtOnPolyReg);
            double dist2 = PointUtility.DistanceBetweenPoints(centerOther, projectedPtOnOtherReg);

            double totalDistance = 2 * (dist1 + dist2);
            Line2d lineMoved     = new Line2d(lineInPolyReg.StartPoint, lineInPolyReg.EndPoint);

            lineMoved = LineUtility.Move(lineMoved, centerPoly);
            Point2d projectedPt = GraphicsUtility.ProjectedPointOnLine(lineMoved, centerOther);
            double  distance    = PointUtility.DistanceBetweenPoints(projectedPt, centerOther);

            bool isNeighbour = false;

            if (totalDistance - eps < distance && distance < totalDistance + eps)
            {
                isNeighbour = true;
            }
            else
            {
                isNeighbour = false;
            }

            return(new Dictionary <string, object>
            {
                { "Neighbour", (isNeighbour) },
                { "SharedEdgeA", (lineInPolyReg) },
                { "SharedEdgeB", (lineInOtherReg) },
                { "LineMoved", (lineMoved) },
                { "CenterToCenterLine", (centerLine) },
                { "CenterPolyPoint", (centerPoly) },
                { "CenterPolyOtherPoint", (centerOther) },
            });
        }