Пример #1
0
            private static List <Polyline> DrawCorridor(List <Point3d> anchors, List <Line> mainAxis)
            {
                List <Polyline> corridor = new List <Polyline>();

                if (anchors.Count < 2)
                {
                    return(null);
                }

                List <Rectangle3d> rectList = new List <Rectangle3d>();

                for (int i = 0; i < anchors.Count - 1; i++)
                {
                    Rectangle3d tempRect = RectangleTools.DrawP2PRect(anchors[i], anchors[i + 1], CorridorDimension.OneWayWidth);
                    rectList.Add(tempRect);
                }

                if (rectList.Count > 1)
                {
                    Curve intersected = rectList[0].ToNurbsCurve();

                    for (int i = 0; i < rectList.Count - 1; i++)
                    {
                        List <Curve> unionCurves = new List <Curve>();
                        unionCurves.Add(intersected);
                        unionCurves.Add(rectList[i + 1].ToNurbsCurve());
                        intersected = Curve.CreateBooleanUnion(unionCurves)[0];
                    }

                    corridor.Add(CurveTools.ToPolyline(intersected));
                }

                return(corridor);
            }
Пример #2
0
            private static List <Polyline> RemoveOverlapSeg(Polyline trimmee, Polyline trimmer)
            {
                List <Polyline> trimmed      = new List <Polyline>();
                List <Curve>    memberToJoin = new List <Curve>();

                Curve        trimmerCrv = trimmer.ToNurbsCurve();
                List <Curve> trimmeeSeg = trimmee.ToNurbsCurve().DuplicateSegments().ToList();

                foreach (Curve i in trimmeeSeg)
                {
                    if (!CurveTools.IsOverlap(i, trimmerCrv, 0.005))
                    {
                        memberToJoin.Add(i);
                    }
                }

                List <Curve> joinedCrvs = Curve.JoinCurves(memberToJoin, 0.5, true).ToList();

                foreach (Curve i in joinedCrvs)
                {
                    trimmed.Add(CurveTools.ToPolyline(i));
                }

                if (trimmed.Count == 0)
                {
                    return(new List <Polyline>());
                }

                return(trimmed);
            }
Пример #3
0
        protected override Result RunCommand(RhinoDoc doc, RunMode mode)
        {
            RhinoApp.WriteLine("안녕하세요 방만드는기계 입니다.");

            //
            Polyline outline  = new Polyline();
            Polyline coreLine = new Polyline();
            Polyline landing  = new Polyline();

            GetObject getPolyline = new GetObject();

            getPolyline.SetCommandPrompt("외곽선,코어,랜딩 입력해주세요");
            getPolyline.GeometryFilter          = Rhino.DocObjects.ObjectType.Curve;
            getPolyline.GeometryAttributeFilter = GeometryAttributeFilter.ClosedCurve;
            getPolyline.SubObjectSelect         = false;

            getPolyline.GetMultiple(3, 0);

            if (getPolyline.CommandResult() != Result.Success)
            {
                RhinoApp.WriteLine("달라고!");
                return(getPolyline.CommandResult());
            }
            else
            {
                RhinoApp.WriteLine("입력받았습니다.");
            }

            if (null == getPolyline.Object(0).Curve())
            {
                RhinoApp.WriteLine("없잖아!");
                return(getPolyline.CommandResult());
            }

            List <Polyline> testPoly = new List <Polyline>();

            foreach (var i in getPolyline.Objects())
            {
                testPoly.Add(CurveTools.ToPolyline(i.Curve()));
            }

            outline  = testPoly[0];
            coreLine = testPoly[1];
            landing  = testPoly[2];


            List <Polyline> rooms = Debugger.DebugRoom(outline, coreLine, landing);

            foreach (Polyline i in rooms)
            {
                doc.Objects.AddCurve(i.ToNurbsCurve());
            }

            doc.Views.Redraw();

            RhinoApp.WriteLine("최선을 다했습니다만...");

            return(Result.Success);
        }
Пример #4
0
        private void btnOutline_Click(object sender, EventArgs e)
        {
            curveBox.outlines = null;
            var dissolvedCurves = new List <Curve>(CurveTools.Dissolve(curveBox.curves));
            //var cleanedCurves = new List<Curve>(CurveTools.RemoveOrphanedCurves(dissolvedCurves));
            var curves = new CurveCollection(dissolvedCurves).BreakApart();

            curveBox.curves   = new CurveCollection(dissolvedCurves);
            curveBox.outlines = new CurveCollection(curves.GetOutlines());
            curveBox.Invalidate();
        }
Пример #5
0
            private static List <Polyline> GetBooleanDifference(Polyline outline, Polyline coreUnion)
            {
                List <Polyline> trimmedOutline = new List <Polyline>();

                List <Curve> trimmed = Curve.CreateBooleanDifference(outline.ToNurbsCurve(), coreUnion.ToNurbsCurve()).ToList();

                foreach (Curve i in trimmed)
                {
                    trimmedOutline.Add(CurveTools.ToPolyline(i));
                }

                return(trimmedOutline);
            }
Пример #6
0
            private static List <Polyline> DrawCorridor(List <Point3d> anchors, List <Line> baseAxis, double subLength)
            {
                List <Polyline> corridor = new List <Polyline>();

                Rectangle3d subCorridor  = RectangleTools.DrawP2PRect(anchors[0], anchors[1], subLength, CorridorDimension.TwoWayWidth);
                Rectangle3d mainCorridor = RectangleTools.DrawP2PRect(anchors[1], anchors[2], CorridorDimension.TwoWayWidth, subLength);

                List <Curve> forUnion = new List <Curve>();

                forUnion.Add(subCorridor.ToNurbsCurve());
                forUnion.Add(mainCorridor.ToNurbsCurve());

                corridor.Add(CurveTools.ToPolyline(Curve.CreateBooleanUnion(forUnion)[0]));

                return(corridor);
            }
Пример #7
0
            //process method
            private List <Room> MakeRooms(List <LabeledOutline> outlinelabels, List <List <Room> > allocatedRoom)
            {
                //draw outline.
                List <Polyline> roomOutlines = new List <Polyline>();

                for (int i = 0; i < outlinelabels.Count; i++)
                {
                    roomOutlines.AddRange(
                        DrawRoomAtEachPart(outlinelabels[i], allocatedRoom[i].Select(n => n.Area).ToList()));
                }

                //merge smallRoom. //tolerance 문제 있을듯
                if (roomOutlines.Count > 1 && roomOutlines.Last().GetArea() < Dimensions.MinRoomArea)
                {
                    Curve lastRoom = roomOutlines.Last().ToNurbsCurve();
                    roomOutlines.RemoveAt(roomOutlines.Count - 1);
                    Curve preLastRoom = roomOutlines.Last().ToNurbsCurve();
                    roomOutlines.RemoveAt(roomOutlines.Count - 1);

                    Curve[] merged = Curve.CreateBooleanUnion(new List <Curve> {
                        lastRoom, preLastRoom
                    });
                    merged.OrderByDescending(n => n.GetArea());

                    roomOutlines.Add(CurveTools.ToPolyline(merged.First()));
                }

                //assign to RoomClass
                List <Room> rooms = new List <Room>();

                List <Room> outlineLackedRoom = new List <Room>();

                allocatedRoom.ForEach(n => outlineLackedRoom.AddRange(n));

                for (int i = 0; i < roomOutlines.Count; i++)
                {
                    Room currentRoom = outlineLackedRoom[i];
                    currentRoom.Outline = roomOutlines[i];
                    currentRoom.Area    = roomOutlines[i].GetArea();
                    rooms.Add(currentRoom);
                }

                return(rooms);
            }
Пример #8
0
            //method
            private static Polyline GetCoreUnion(Core core, List <Polyline> corridor)
            {
                List <Curve> coreAndCorridor = new List <Curve>();

                coreAndCorridor.Add(core.Outline.ToNurbsCurve());
                foreach (Polyline i in corridor)
                {
                    coreAndCorridor.Add(i.ToNurbsCurve());
                }

                if (coreAndCorridor.Count == 1)
                {
                    return(core.Outline);
                }

                Curve union = Curve.CreateBooleanUnion(coreAndCorridor)[0];

                return(CurveTools.ToPolyline(union));
            }
Пример #9
0
        //this checks if initial data is valid
        private bool Setup(List <Line> lines)
        {
            if (!SetupPointGroups(lines))
            {
                return(false);
            }

            //setup control handles
            Vector2D center1 = CurveTools.GetPointOnLine(pointGroup1[0], pointGroup1[segmentsCount - 1], 0.5f);
            Vector2D center2 = CurveTools.GetPointOnLine(pointGroup2[0], pointGroup2[segmentsCount - 1], 0.5f);

            Vector2D loc1 = GetHandleLocation(pointGroup1[0], pointGroup1[segmentsCount - 1], center2);
            Vector2D loc2 = GetHandleLocation(pointGroup2[0], pointGroup2[segmentsCount - 1], center1);

            ControlHandle ch1 = new ControlHandle {
                ControlledPoint = pointGroup1[0], RelativePosition = loc1
            };
            ControlHandle ch2 = new ControlHandle {
                ControlledPoint = pointGroup2[0], RelativePosition = loc2
            };
            ControlHandle ch3 = new ControlHandle {
                ControlledPoint = pointGroup1[segmentsCount - 1], RelativePosition = loc1
            };
            ControlHandle ch4 = new ControlHandle {
                ControlledPoint = pointGroup2[segmentsCount - 1], RelativePosition = loc2
            };

            ch1.Pair = ch3;
            ch2.Pair = ch4;
            ch3.Pair = ch1;
            ch4.Pair = ch2;

            controlHandles = new[] { ch1, ch2, ch3, ch4 };

            //setup relative segments lengths
            relLenGroup1 = GetRelativeLengths(pointGroup1);
            relLenGroup2 = GetRelativeLengths(pointGroup2);

            return(true);
        }
Пример #10
0
            private static List <List <RoomLine> > LabelUnionSeg(List <Polyline> trimmedUnion, Core core, List <Polyline> corridor)
            {
                List <List <RoomLine> > labeledCore = new List <List <RoomLine> >();

                //label decider setting
                Curve        coreCrv     = core.Outline.ToNurbsCurve();
                List <Curve> corridorCrv = new List <Curve>();

                corridorCrv.Add(core.Landing.ToNurbsCurve());
                foreach (Polyline i in corridor)
                {
                    corridorCrv.Add(i.ToNurbsCurve());
                }

                //label
                foreach (Polyline i in trimmedUnion)
                {
                    List <Line>     unlabeledSeg      = i.GetSegments().ToList();
                    List <RoomLine> currentPolyLabels = new List <RoomLine>();

                    foreach (Line j in unlabeledSeg)
                    {
                        Curve jCrv = j.ToNurbsCurve();

                        if (CurveTools.IsOverlap(jCrv, corridorCrv, 0.005))
                        {
                            currentPolyLabels.Add(new RoomLine(j, LineType.Corridor));
                        }
                        else if (CurveTools.IsOverlap(jCrv, coreCrv, 0.005))
                        {
                            currentPolyLabels.Add(new RoomLine(j, LineType.Core));
                        }
                    }

                    labeledCore.Add(currentPolyLabels);
                }

                return(labeledCore);
            }
Пример #11
0
        //mxd
        public void DrawLine3DFloor(Vector2D start, Vector2D end, ref PixelColor c, PixelColor c2)
        {
            Vector2D delta  = end - start;
            float    length = delta.GetLength();

            if (length < DASH_INTERVAL * 2)
            {
                DrawLineSolid((int)start.x, (int)start.y, (int)end.x, (int)end.y, ref c2);
            }
            else
            {
                float d1 = DASH_INTERVAL / length;
                float d2 = 1.0f - d1;

                Vector2D p1 = CurveTools.GetPointOnLine(start, end, d1);
                Vector2D p2 = CurveTools.GetPointOnLine(start, end, d2);

                DrawLineSolid((int)start.x, (int)start.y, (int)p1.x, (int)p1.y, ref c2);
                DrawLineSolid((int)p1.x, (int)p1.y, (int)p2.x, (int)p2.y, ref c);
                DrawLineSolid((int)p2.x, (int)p2.y, (int)end.x, (int)end.y, ref c2);
            }
        }
Пример #12
0
        public static List <Brep> DrawHouse(Household hhp)
        {
            double   height  = Consts.FloorHeight;
            Curve    outline = hhp.GetOutline();
            Polyline outPoly = CurveTools.ToPolyline(outline);

            Brep x = Extrusion.Create(outline, height, true).ToBrep();

            x.CapPlanarHoles(1);

            double windowSide   = 300;
            double windowLow    = 300;
            double windowHeight = 2100;
            double windowDepth  = 200;

            List <Brep> wins = new List <Brep>();

            for (int i = 0; i < hhp.LightingEdge.Count; i++)
            {
                //Rhino.RhinoDoc.ActiveDoc.Objects.Add(hhp.LightingEdge[i].ToNurbsCurve());
                //var c = hhp.LightingEdge[i].ToNurbsCurve().Trim(CurveEnd.Both, 300);
                //var p1 = c.PointAtStart + Vector3d.ZAxis * 300;
                //var p2 = c.PointAtStart + Vector3d.ZAxis * 2400;
                //var p3 = c.PointAtEnd + Vector3d.ZAxis * 2400;
                //var p4 = c.PointAtEnd + Vector3d.ZAxis * 300;
                //Brep[] open = Brep.CreatePlanarBreps(new PolylineCurve(new Point3d[] { p1, p2, p3, p4, p1 }));
                Line tempLine = hhp.LightingEdge[i];

                Point3d  midPoint  = tempLine.PointAt(0.5);
                Vector3d windowVec = tempLine.UnitTangent;
                windowVec.Rotate(Math.PI / 2, Vector3d.ZAxis);
                midPoint.Transform(Transform.Translation(Vector3d.Multiply(windowVec, 10)));

                if (hhp.GetOutline().Contains(midPoint) == Rhino.Geometry.PointContainment.Inside)
                {
                    tempLine.Flip();
                }

                tempLine.Extend(-windowSide, -windowSide);

                Curve tempCurve = tempLine.ToNurbsCurve();
                tempCurve.Translate(Vector3d.Multiply(Vector3d.ZAxis, windowLow));
                Point3d pt1 = tempCurve.PointAtStart;
                Point3d pt2 = tempCurve.PointAtEnd;
                Point3d pt3 = tempCurve.PointAtEnd;
                pt3.Transform(Transform.Translation(Vector3d.Multiply(Vector3d.ZAxis, windowHeight)));
                Point3d pt4 = tempCurve.PointAtStart;
                pt4.Transform(Transform.Translation(Vector3d.Multiply(Vector3d.ZAxis, windowHeight)));
                Point3d        pt5          = tempCurve.PointAtStart;
                List <Point3d> windowPoints = new List <Point3d>();
                windowPoints.Add(pt1);
                windowPoints.Add(pt2);
                windowPoints.Add(pt3);
                windowPoints.Add(pt4);
                windowPoints.Add(pt5);
                Polyline windowPolyline = new Polyline(windowPoints);
                Curve    win            = windowPolyline.ToNurbsCurve();


                Plane windowPlane;
                win.TryGetPlane(out windowPlane);
                Vector3d windowNormal = windowPlane.Normal;
                Curve    windowCurve  = win.Duplicate() as Curve;
                windowCurve.Translate(Vector3d.Multiply(windowNormal, windowDepth));
                Surface windowSurface = Surface.CreateExtrusion(windowCurve, Vector3d.Multiply(windowNormal, -windowDepth * 2));
                Brep    windowBrep    = windowSurface.ToBrep();
                Brep[]  withHolesTemp = x.Split(windowBrep, 1);

                if (withHolesTemp.Length != 0)
                {
                    x = withHolesTemp[0];
                }

                Curve duplicatedWindowCurve = (win.Duplicate() as Curve);
                duplicatedWindowCurve.Transform(Transform.Translation(windowNormal * (windowDepth - 100)));

                Curve windowCurveBottom = duplicatedWindowCurve.DuplicateSegments()[0];
                Curve heightCurve       = duplicatedWindowCurve.DuplicateSegments()[1];

                wins.AddRange(DrawWindowAll(windowCurveBottom, heightCurve.GetLength(), false));

                Curve[] tempLoftBase = { win, duplicatedWindowCurve };

                Curve pathCurve = new LineCurve(Point3d.Origin, new Point3d(windowNormal * (-windowDepth + 100)));
                wins.Add(Brep.JoinBreps(Brep.CreateFromLoft(tempLoftBase, Point3d.Unset, Point3d.Unset, LoftType.Normal, false), 0)[0]);
            }


            //1. 양쪽에서 300씩 , 위400 아래300 사각형.빵꾸. 안쪽으로 200
            //->창틀
            //2. 사방 30씩, 안쪽으로 100
            //->창문와꾸
            //3. 창 안쪽에서 20, 창문와꾸 30, 바깥쪽50 ,길이 1200 * 2
            //4. ㅊ



            //Brep w1 = Brep.create  hhp.LightingEdge[0]
            wins.Add(x);
            return(wins);
        }
Пример #13
0
        private void Update()
        {
            if (renderer.StartOverlay(true))
            {
                snaptogrid = General.Interface.ShiftState ^ General.Interface.SnapToGrid;

                PixelColor linesColor = snaptogrid ? General.Colors.Selection : General.Colors.Highlight;

                //draw curves
                curves = new List <Vector2D[]>();

                for (int i = 0; i < segmentsCount; i++)
                {
                    Vector2D cp1 = CurveTools.GetPointOnLine(controlHandles[0].Position, controlHandles[2].Position, relLenGroup1[i]);
                    Vector2D cp2 = CurveTools.GetPointOnLine(controlHandles[1].Position, controlHandles[3].Position, relLenGroup2[i]);
                    curves.Add(CurveTools.GetCubicCurve(pointGroup1[i], pointGroup2[i], cp1, cp2, form.Subdivisions));

                    for (int c = 1; c < curves[i].Length; c++)
                    {
                        renderer.RenderLine(curves[i][c - 1], curves[i][c], LINE_THICKNESS, linesColor, true);
                    }
                }

                //draw connecting lines
                if (form.Subdivisions > 1)
                {
                    for (int i = 1; i < segmentsCount; i++)
                    {
                        for (int c = 1; c < form.Subdivisions; c++)
                        {
                            renderer.RenderLine(curves[i - 1][c], curves[i][c], LINE_THICKNESS, linesColor, true);
                        }
                    }
                }

                //draw vertices
                float vsize = (renderer.VertexSize + 1.0f) / renderer.Scale;

                foreach (Vector2D[] points in curves)
                {
                    for (int i = 1; i < points.Length - 1; i++)
                    {
                        renderer.RenderRectangleFilled(new RectangleF(points[i].x - vsize, points[i].y - vsize, vsize * 2.0f, vsize * 2.0f), linesColor, true);
                    }
                }

                //draw handle lines
                renderer.RenderLine(pointGroup1[0], controlHandles[0].Position, LINE_THICKNESS, handleColor, true);
                renderer.RenderLine(pointGroup2[0], controlHandles[1].Position, LINE_THICKNESS, handleColor, true);
                renderer.RenderLine(pointGroup1[segmentsCount - 1], controlHandles[2].Position, LINE_THICKNESS, handleColor, true);
                renderer.RenderLine(pointGroup2[segmentsCount - 1], controlHandles[3].Position, LINE_THICKNESS, handleColor, true);

                //draw handles
                float gripsize = GRIP_SIZE / renderer.Scale;

                for (int i = 0; i < 4; i++)
                {
                    RectangleF handleRect = new RectangleF(controlHandles[i].Position.x - gripsize * 0.5f, controlHandles[i].Position.y - gripsize * 0.5f, gripsize, gripsize);
                    renderer.RenderRectangleFilled(handleRect, General.Colors.Background, true);
                    renderer.RenderRectangle(handleRect, 2, General.Colors.Highlight, true);
                }
                renderer.Finish();
            }
            renderer.Present();
        }
Пример #14
0
        protected override void Update()
        {
            PixelColor stitchcolor = General.Colors.Highlight;
            PixelColor losecolor   = General.Colors.Selection;

            snaptocardinaldirection = General.Interface.ShiftState && General.Interface.AltState;
            snaptogrid    = snaptocardinaldirection || General.Interface.ShiftState ^ General.Interface.SnapToGrid;
            snaptonearest = General.Interface.CtrlState ^ General.Interface.AutoMerge;

            DrawnVertex curp  = GetCurrentPosition();
            float       vsize = (renderer.VertexSize + 1.0f) / renderer.Scale;

            // Update label positions (mxd)
            if (labels.Count > 0)
            {
                // Update labels for already drawn lines
                for (int i = 0; i < labels.Count - 1; i++)
                {
                    labels[i].Move(points[i].pos, points[i + 1].pos);
                }

                // Update label for active line
                labels[labels.Count - 1].Move(points[points.Count - 1].pos, curp.pos);
            }

            // Render drawing lines
            if (renderer.StartOverlay(true))
            {
                // Go for all points to draw lines
                if (points.Count > 0)
                {
                    //update curve
                    List <Vector2D> verts = new List <Vector2D>();
                    for (int i = 0; i < points.Count; i++)
                    {
                        verts.Add(points[i].pos);
                    }
                    if (curp.pos != verts[verts.Count - 1])
                    {
                        verts.Add(curp.pos);
                    }
                    curve = CurveTools.CurveThroughPoints(verts, 0.5f, 0.75f, segmentlength);

                    // Render lines
                    for (int i = 1; i < curve.Shape.Count; i++)
                    {
                        // Determine line color
                        PixelColor c = snaptonearest ? stitchcolor : losecolor;

                        // Render line
                        renderer.RenderLine(curve.Shape[i - 1], curve.Shape[i], LINE_THICKNESS, c, true);
                    }

                    //render "inactive" vertices
                    for (int i = 1; i < curve.Shape.Count - 1; i++)
                    {
                        // Determine vertex color
                        PixelColor c = !snaptonearest ? stitchcolor : losecolor;

                        // Render vertex
                        renderer.RenderRectangleFilled(new RectangleF(curve.Shape[i].x - vsize, curve.Shape[i].y - vsize, vsize * 2.0f, vsize * 2.0f), c, true);
                    }
                }

                if (points.Count > 0)
                {
                    // Render vertices
                    for (int i = 0; i < points.Count; i++)
                    {
                        // Determine vertex color
                        PixelColor c = points[i].stitch ? stitchcolor : losecolor;

                        // Render vertex
                        renderer.RenderRectangleFilled(new RectangleF(points[i].pos.x - vsize, points[i].pos.y - vsize, vsize * 2.0f, vsize * 2.0f), c, true);
                    }
                }

                // Determine point color
                PixelColor color = snaptonearest ? stitchcolor : losecolor;

                // Render vertex at cursor
                renderer.RenderRectangleFilled(new RectangleF(curp.pos.x - vsize, curp.pos.y - vsize, vsize * 2.0f, vsize * 2.0f), color, true);

                // Render labels
                renderer.RenderText(labels.ToArray());

                //Render info label
                Vector2D start = new Vector2D(mousemappos.x + (32 / renderer.Scale), mousemappos.y - (16 / renderer.Scale));
                Vector2D end   = new Vector2D(mousemappos.x + (96 / renderer.Scale), mousemappos.y);
                hintlabel.Move(start, end);
                hintlabel.Text = "SEG LEN: " + segmentlength;
                renderer.RenderText(hintlabel.TextLabel);

                // Done
                renderer.Finish();
            }

            // Done
            renderer.Present();
        }
Пример #15
0
                private static PartitionParam DrawAtMultiFoldOutline(PartitionParam param, double targetArea, List <Point3d> outlineVertex)
                {
                    Line           mainLine          = GetMainLine(param, outlineVertex);
                    List <Point3d> canMakePerpVertex = new List <Point3d>();

                    Vector3d mainAlign = mainLine.UnitTangent;
                    Vector3d mainPerp  = VectorTools.RotateVectorXY(mainAlign, Math.PI / 2);
                    Point3d  origin    = param.OriginPost.Point;
                    bool     isMainAlignSameAsPostNormal = mainAlign.IsParallelTo(param.OriginPost.BaseLine.UnitNormal, 0.005) == 1;

                    if (!isMainAlignSameAsPostNormal)
                    {
                        int originIndex = param.OutlineLabel.Core.FindIndex
                                              (i => i.PureLine == param.OriginPost.BasePureLine);

                        param.OriginPost = new PartitionOrigin(origin, param.OutlineLabel.Core[originIndex - 1]);
                        mainPerp         = VectorTools.RotateVectorXY(mainAlign, -Math.PI / 2);
                    }

                    int lastVertexIndex = outlineVertex.Count - 1;

                    for (int i = 1; i < lastVertexIndex; i++)
                    {
                        Vector3d toPreVector  = new Vector3d(outlineVertex[i - 1] - outlineVertex[i]);
                        Vector3d toPostVector = new Vector3d(outlineVertex[i + 1] - outlineVertex[i]);
                        Vector3d toMainVector = -mainPerp;

                        if (IsBetweenVector(toPreVector, toPostVector, toMainVector))
                        {
                            canMakePerpVertex.Add(outlineVertex[i]);
                        }
                    }

                    //SeivePerpVertex
                    List <Point3d> finalVertex = new List <Point3d>();


                    foreach (Point3d i in outlineVertex)
                    {
                        Line toBaseLine = PCXTools.PCXByEquationStrict(i, CurveTools.ToPolyline(mainLine.ToNurbsCurve()), -mainPerp);
                        Line toOutline  = PCXTools.PCXByEquationStrict(toBaseLine.PointAt(1), param.OutlineLabel.Pure, mainPerp);

                        if (toOutline.PointAt(1).DistanceTo(i) < 0.5)
                        {
                            finalVertex.Add(i);
                        }
                    }


                    //DrawAtEachVertex
                    List <PartitionParam> outputCandidate = new List <PartitionParam>();

                    foreach (Point3d i in finalVertex)
                    {
                        Line    toBaseLine = PCXTools.PCXByEquationStrict(i, CurveTools.ToPolyline(mainLine.ToNurbsCurve()), -mainPerp);
                        Point3d tempAnchor = toBaseLine.PointAt(1);
                        Line    toOutline  = PCXTools.PCXByEquationStrict(tempAnchor, param.OutlineLabel.Pure, mainPerp);

                        if (toOutline.PointAt(1).DistanceTo(i) > 0.5)
                        {
                            continue;
                        }

                        List <RoomLine> tempPartition = new List <RoomLine>();
                        tempPartition.Add(new RoomLine(new Line(origin, tempAnchor), LineType.Inner));
                        tempPartition.Add(new RoomLine(new Line(tempAnchor, i), LineType.Inner));

                        PartitionParam tempParam = new PartitionParam(param);
                        tempParam.PartitionPost = new Partition(tempPartition, param.OriginPost);

                        outputCandidate.Add(tempParam);
                    }

                    outputCandidate.Add(PartitionMaker.DrawOrtho(param));

                    //TestCandidate
                    //나중에 수정.. 지금은 면적일치정도로만..
                    Plane                 cornerPlane = new Plane(origin, mainAlign, mainPerp);
                    CornerComparer        comparer    = new CornerComparer();
                    List <PartitionParam> seived      = comparer.Seive(outputCandidate, targetArea, cornerPlane);

                    return(seived[0]);
                }