Beispiel #1
0
        // Main execution
        public Result Execute(ExternalCommandData commandData, ref string message, ElementSet elements)
        {
            UIApplication uiapp = commandData.Application;
            UIDocument    uidoc = uiapp.ActiveUIDocument;
            Application   app   = uiapp.Application;
            Document      doc   = uidoc.Document;
            View          view  = doc.ActiveView;
            Selection     sel   = uidoc.Selection;


            // Grab the current building level
            FilteredElementCollector colLevels = new FilteredElementCollector(doc)
                                                 .WhereElementIsNotElementType()
                                                 .OfCategory(BuiltInCategory.INVALID)
                                                 .OfClass(typeof(Level));
            Level firstLevel = colLevels.FirstElement() as Level;


            // LineStyle filter
            CurveElementFilter       filter       = new CurveElementFilter(CurveElementType.ModelCurve);
            FilteredElementCollector collector    = new FilteredElementCollector(doc);
            ICollection <Element>    founds       = collector.WherePasses(filter).ToElements();
            List <CurveElement>      importCurves = new List <CurveElement>();

            foreach (CurveElement ce in founds)
            {
                importCurves.Add(ce);
            }
            var          wallCurves = importCurves.Where(x => x.LineStyle.Name == "WALL").ToList();
            List <Curve> wallLines  = new List <Curve>(); // Algorithm only support walls of line type

            foreach (CurveElement ce in wallCurves)
            {
                wallLines.Add(ce.GeometryCurve as Curve);
            }

            //double parasStart = wallLines[0].GetEndParameter(0);
            //double parasEnd = wallLines[0].GetEndParameter(1);
            //wallLines[0].MakeUnbound();

            //double _parasStart = wallLines[1].GetEndParameter(0);
            //double _parasEnd = wallLines[1].GetEndParameter(1);
            //wallLines[1].MakeUnbound();

            SetComparisonResult result = wallLines[0].Intersect(wallLines[1], out IntersectionResultArray results);

            Debug.Assert(result != SetComparisonResult.Overlap, "Overlap");
            Debug.Assert(result != SetComparisonResult.BothEmpty, "BothEmpty");
            Debug.Assert(result != SetComparisonResult.Disjoint, "Disjoint");
            Debug.Assert(result != SetComparisonResult.Equal, "Equal");
            Debug.Assert(result != SetComparisonResult.LeftEmpty, "LeftEmpty");
            Debug.Assert(result != SetComparisonResult.RightEmpty, "RightEmpty");
            Debug.Assert(result != SetComparisonResult.Subset, "Subset");
            Debug.Assert(result != SetComparisonResult.Superset, "Superset");



            double radius  = Misc.MmToFoot(50);
            XYZ    ptStart = wallLines[0].GetEndPoint(0);
            XYZ    ptEnd   = wallLines[0].GetEndPoint(1);
            XYZ    xAxis   = new XYZ(1, 0, 0); // The x axis to define the arc plane. Must be normalized
            XYZ    yAxis   = new XYZ(0, 1, 0); // The y axis to define the arc plane. Must be normalized
            Curve  knob1   = Arc.Create(ptStart, radius, 0, 2 * Math.PI, xAxis, yAxis);
            Curve  knob2   = Arc.Create(ptEnd, radius, 0, 2 * Math.PI, xAxis, yAxis);
            SetComparisonResult result1 = knob1.Intersect(wallLines[1], out IntersectionResultArray results1);
            SetComparisonResult result2 = knob2.Intersect(wallLines[1], out IntersectionResultArray results2);

            // if (result1 == SetComparisonResult.Disjoint && result2 == SetComparisonResult.Disjoint)
            if ((result1 == SetComparisonResult.Overlap || result1 == SetComparisonResult.Subset ||
                 result1 == SetComparisonResult.Superset || result1 == SetComparisonResult.Equal) ||
                (result2 == SetComparisonResult.Overlap || result2 == SetComparisonResult.Subset ||
                 result2 == SetComparisonResult.Superset || result2 == SetComparisonResult.Equal))
            {
                Debug.Print("INTERSECTED!");
            }
            else
            {
                Debug.Print("DISJOINT!");
            }


            XYZ  ptStart1 = wallLines[0].GetEndPoint(0);
            XYZ  ptEnd1   = wallLines[0].GetEndPoint(1);
            XYZ  ptStart2 = wallLines[1].GetEndPoint(0);
            XYZ  ptEnd2   = wallLines[1].GetEndPoint(1);
            Line baseline = wallLines[1].Clone() as Line;

            baseline.MakeUnbound();
            XYZ _ptStart = baseline.Project(ptStart1).XYZPoint;
            XYZ _ptEnd   = baseline.Project(ptEnd1).XYZPoint;

            Debug.Print("_start: " + Misc.PointString(_ptStart));
            Debug.Print("_end: " + Misc.PointString(_ptEnd));
            Line checkline = Line.CreateBound(_ptStart, _ptEnd);
            SetComparisonResult projection = checkline.Intersect(wallLines[1] as Line, out IntersectionResultArray projections);

            Debug.Print("Shadowing?" + projection.ToString());
            if (projection == SetComparisonResult.Equal)
            {
                Debug.Print("Shadowing");
            }
            {
                Debug.Print("Departed");
            }
            Curve proj1 = Arc.Create(_ptStart, radius, 0, 2 * Math.PI, xAxis, yAxis);
            Curve proj2 = Arc.Create(_ptEnd, radius, 0, 2 * Math.PI, xAxis, yAxis);


            using (Transaction tx = new Transaction(doc))
            {
                tx.Start("Generate sub-surface and its mark");

                Plane       Geomplane = Plane.CreateByNormalAndOrigin(XYZ.BasisZ, XYZ.Zero);
                SketchPlane sketch    = SketchPlane.Create(doc, Geomplane);

                ModelCurve modelline1 = doc.Create.NewModelCurve(proj1, sketch) as ModelCurve;
                ModelCurve modelline2 = doc.Create.NewModelCurve(proj2, sketch) as ModelCurve;

                tx.Commit();
            }

            return(Result.Succeeded);
        }
Beispiel #2
0
        // Main thread
        public Result Execute(ExternalCommandData commandData, ref string message, ElementSet elements)
        {
            UIApplication uiapp = commandData.Application;
            UIDocument    uidoc = uiapp.ActiveUIDocument;
            Application   app   = uiapp.Application;
            Document      doc   = uidoc.Document;

            View view = doc.ActiveView;

            Selection sel = uidoc.Selection;

            double tolerance = app.ShortCurveTolerance;

            // Pick Import Instance
            ImportInstance import = null;

            try
            {
                Reference r = uidoc.Selection.PickObject(ObjectType.Element, new Util.ElementsOfClassSelectionFilter <ImportInstance>());
                import = doc.GetElement(r) as ImportInstance;
            }
            catch
            {
                return(Result.Cancelled);
            }
            if (import == null)
            {
                System.Windows.MessageBox.Show("CAD not found", "Tips");
                return(Result.Cancelled);
            }

            List <Curve> columnCrvs = Util.TeighaGeometry.ShatterCADGeometry(uidoc, import, "COLUMN", tolerance);
            List <Curve> wallCrvs   = Util.TeighaGeometry.ShatterCADGeometry(uidoc, import, "WALL", tolerance);
            List <Curve> doorCrvs   = Util.TeighaGeometry.ShatterCADGeometry(uidoc, import, "DOOR", tolerance);
            List <Curve> windowCrvs = Util.TeighaGeometry.ShatterCADGeometry(uidoc, import, "WINDOW", tolerance);

            //List<Line> columnLines = Util.CrvsToLines(columnCrvs);
            //List<Line> wallLines = Util.CrvsToLines(wallCrvs);

            // Merge the overlapped wall boundaries
            // Seal the wall boundary by column block
            // INPUT List<Line> wallLines, List<Line> columnLines
            #region PATCH wallLines
            List <Line> patchLines = new List <Line>();
            List <XYZ>  sectPts    = new List <XYZ>();

            // Seal the wall when encountered with column
            foreach (Curve columnCrv in columnCrvs)
            {
                sectPts.Clear();
                foreach (Line wallCrv in wallCrvs)
                {
                    if (!Algorithm.IsParallel(columnCrv, wallCrv))
                    {
                        SetComparisonResult result = wallCrv.Intersect(columnCrv, out IntersectionResultArray results);
                        if (result != SetComparisonResult.Disjoint)
                        {
                            XYZ sectPt = results.get_Item(0).XYZPoint;
                            sectPts.Add(sectPt);
                        }
                    }
                    else
                    {
                        continue;
                    }
                }
                if (sectPts.Count() == 2)
                {
                    patchLines.Add(Line.CreateBound(sectPts[0], sectPts[1]));
                }
                if (sectPts.Count() > 2)  // not sure how to solve this
                {
                    Line minPatch = Line.CreateBound(XYZ.Zero, 10000 * XYZ.BasisX);
                    for (int i = 0; i < sectPts.Count(); i++)
                    {
                        for (int j = i + 1; j < sectPts.Count(); j++)
                        {
                            if (sectPts[i].DistanceTo(sectPts[j]) > 0.001)
                            {
                                Line testPatch = Line.CreateBound(sectPts[i], sectPts[j]);
                                if (testPatch.Length < minPatch.Length)
                                {
                                    minPatch = testPatch;
                                }
                            }
                        }
                    }
                    patchLines.Add(minPatch);
                }
            }

            // Patch for the wall lines
            wallCrvs.AddRange(patchLines);

            // Merge lines when they are parallel and almost intersected (knob)
            List <Curve> mergeLines = CloseGapAtBreakpoint(wallCrvs);

            //
            List <Curve> fixedLines = CloseGapAtCorner(mergeLines);

            #endregion
            // OUTPUT List<Line> fixedLines


            // INPUT List<Line> fixedLines
            #region Cluster the wallLines by hierarchy

            var wallClusters = Algorithm.ClusterByIntersect(fixedLines);
            Debug.Print("{0} clustered wall blocks in total", wallClusters.Count);

            // Generate boundingbox marker for the wall cluster
            List <List <Curve> > wallBlocks = new List <List <Curve> > {
            };
            foreach (List <Curve> cluster in wallClusters)
            {
                List <Curve> clusterCrv = cluster;
                if (null != Algorithm.CreateBoundingBox2D(clusterCrv))
                {
                    wallBlocks.Add(Algorithm.CreateBoundingBox2D(clusterCrv));
                }
            }
            Debug.Print("{0} clustered wall bounding boxes in total", wallBlocks.Count);

            #endregion
            // INPUT List<List< Curve >> wallClusters
            Debug.Print("WALL LINES PATCH & CLUSTERING COMPLETE!");


            // INPUT List<List<Curve>> wallClusters
            #region Iterate the generaion of axis

            // Wall axes
            List <Curve> axes = new List <Curve>();
            double       bias = Misc.MmToFoot(20);
            foreach (List <Curve> wallCluster in wallClusters)
            {
                List <Line> lines = Misc.CrvsToLines(wallCluster);
                for (int i = 0; i < lines.Count; i++)
                {
                    for (int j = 0; j < lines.Count - i; j++)
                    {
                        if (Algorithm.IsParallel(lines[i], lines[i + j]) &&
                            !Algorithm.IsIntersected(lines[i], lines[i + j]))
                        {
                            if (Algorithm.LineSpacing(lines[i], lines[i + j]) < Misc.MmToFoot(200) + bias &&
                                Algorithm.LineSpacing(lines[i], lines[i + j]) > Misc.MmToFoot(200) - bias &&
                                Algorithm.IsShadowing(lines[i], lines[i + j]))
                            {
                                if (Algorithm.GenerateAxis(lines[i], lines[i + j]) != null)
                                {
                                    axes.Add(Algorithm.GenerateAxis(lines[i], lines[i + j]));
                                    Debug.Print("got it!");
                                }
                            }
                        }
                    }
                }
            }
            #endregion
            // OUTPUT List<Line> axes
            Debug.Print("WALL AXIS ITERATION COMPLETE!");


            // INPUT List<Curve> doorCrvs
            // INPUT List<Curve> windowCrvs
            // INPUT List<Line> axes
            #region Merge axis joined/overlapped

            // Door axes
            var doorClusters = Algorithm.ClusterByIntersect(doorCrvs);
            List <List <Curve> > doorBlocks = new List <List <Curve> > {
            };
            foreach (List <Curve> cluster in doorClusters)
            {
                if (null != Algorithm.CreateBoundingBox2D(cluster))
                {
                    doorBlocks.Add(Algorithm.CreateBoundingBox2D(cluster));
                }
            }
            List <Curve> doorAxes = new List <Curve> {
            };
            foreach (List <Curve> doorBlock in doorBlocks)
            {
                List <Curve> doorFrame = new List <Curve> {
                };
                for (int i = 0; i < doorBlock.Count; i++)
                {
                    int         sectCount = 0;
                    List <Line> fenses    = new List <Line>();
                    foreach (Line line in fixedLines)
                    {
                        Curve testCrv = doorBlock[i].Clone();
                        SetComparisonResult result = RegionDetect.ExtendCrv(testCrv, 0.01).Intersect(line,
                                                                                                     out IntersectionResultArray results);
                        if (result == SetComparisonResult.Overlap)
                        {
                            sectCount += 1;
                            fenses.Add(line);
                        }
                    }
                    if (sectCount == 2)
                    {
                        XYZ projecting = fenses[0].Evaluate(0.5, true);
                        XYZ projected  = fenses[1].Project(projecting).XYZPoint;
                        if (fenses[0].Length > fenses[1].Length)
                        {
                            projecting = fenses[1].Evaluate(0.5, true);
                            projected  = fenses[0].Project(projecting).XYZPoint;
                        }
                        Line doorAxis = Line.CreateBound(projecting, projected);
                        doorAxes.Add(doorAxis);
                        //doorAxes.Add(doorBlock[i]);
                    }
                }
            }

            // Window axes
            var windowClusters = Algorithm.ClusterByIntersect(windowCrvs);

            List <List <Curve> > windowBlocks = new List <List <Curve> > {
            };
            foreach (List <Curve> cluster in windowClusters)
            {
                if (null != Algorithm.CreateBoundingBox2D(cluster))
                {
                    windowBlocks.Add(Algorithm.CreateBoundingBox2D(cluster));
                }
            }
            List <Curve> windowAxes = new List <Curve> {
            };
            foreach (List <Curve> windowBlock in windowBlocks)
            {
                Line axis1 = Line.CreateBound((windowBlock[0].GetEndPoint(0) + windowBlock[0].GetEndPoint(1)).Divide(2),
                                              (windowBlock[2].GetEndPoint(0) + windowBlock[2].GetEndPoint(1)).Divide(2));
                Line axis2 = Line.CreateBound((windowBlock[1].GetEndPoint(0) + windowBlock[1].GetEndPoint(1)).Divide(2),
                                              (windowBlock[3].GetEndPoint(0) + windowBlock[3].GetEndPoint(1)).Divide(2));
                if (axis1.Length > axis2.Length)
                {
                    windowAxes.Add(axis1);
                }
                else
                {
                    windowAxes.Add(axis2);
                }
            }


            axes.AddRange(windowAxes);
            axes.AddRange(doorAxes);
            Debug.Print("Checklist for axes: Door-{0}, Window-{1}, All-{2}", doorAxes.Count, windowAxes.Count,
                        axes.Count);
            List <Curve> axesExtended = new List <Curve>();
            foreach (Curve axis in axes)
            {
                axesExtended.Add(Algorithm.ExtendLine(axis, 200));
            }
            // Axis merge
            List <List <Curve> > axisGroups  = Algorithm.ClusterByOverlap(axesExtended);
            List <Curve>         centerLines = new List <Curve>();
            foreach (List <Curve> axisGroup in axisGroups)
            {
                var merged = Algorithm.FuseLines(axisGroup);
                centerLines.Add(merged);
            }

            #endregion
            // OUTPUT List<Line> centerLines
            Debug.Print("WINDOW / DOOR LINES JOINED!");


            // INPUT List<Curve> columnCrvs
            // INPUT List<Line> centerLines
            #region Extend and trim the axis (include column corner)

            List <List <Curve> > columnGroups = Algorithm.ClusterByIntersect(columnCrvs);
            foreach (List <Curve> columnGroup in columnGroups)
            {
                //List<Line> columnGrouplines = Util.CrvsToLines(columnGroup);
                List <Curve> nestLines = new List <Curve>();
                for (int i = 0; i < columnGroup.Count; i++)
                {
                    foreach (Line centerLine in centerLines)
                    {
                        SetComparisonResult result = columnGroup[i].Intersect(centerLine, out IntersectionResultArray results);
                        if (result == SetComparisonResult.Overlap)
                        {
                            for (int j = 0; j < columnGroup.Count; j++)
                            {
                                if (j != i)
                                {
                                    if (null != ExtendLine(centerLine, columnGroup[j]))
                                    {
                                        nestLines.Add(ExtendLine(centerLine, columnGroup[j]));
                                    }
                                }
                            }
                        }
                    }
                }
                Debug.Print("Got nested lines: " + nestLines.Count.ToString());
                if (nestLines.Count < 2)
                {
                    continue;
                }
                else
                {
                    centerLines.AddRange(nestLines);
                    int count = 0;
                    for (int i = 1; i < nestLines.Count; i++)
                    {
                        if (!Algorithm.IsParallel(nestLines[0], nestLines[i]))
                        {
                            count += 1;
                        }
                    }
                    if (count == 0)
                    {
                        var patches = Algorithm.CenterLinesOfBox(columnGroup);
                        foreach (Line patch in patches)
                        {
                            if (Algorithm.IsLineIntersectLines(patch, nestLines))
                            {
                                centerLines.Add(patch);
                            }
                        }
                    }
                }
            }

            #endregion
            // OUTPUT List<Line> centerLines
            Debug.Print("AXES JOINED AT COLUMN");


            // INPUT List<Line> centerLines
            //#The region detect function has fatal bug during boolean union operation
            #region Call region detection
            // Axis merge
            List <List <Curve> > tempStrays = Algorithm.ClusterByOverlap(centerLines);
            List <Curve>         strays     = new List <Curve>();
            foreach (List <Curve> tempStray in tempStrays)
            {
                Curve merged = Algorithm.FuseLines(tempStray);
                strays.Add(merged);
            }

            //var strayClusters = Algorithm.ClusterByIntersect(Util.LinesToCrvs(strays));
            //Debug.Print("Cluster of strays: " + strayClusters.Count.ToString());
            //Debug.Print("Cluster of strays[0]: " + strayClusters[0].Count.ToString());
            //Debug.Print("Cluster of strays[1]: " + strayClusters[1].Count.ToString());
            // The RegionCluster method should be applied to each cluster of the strays
            // It only works on a bunch of intersected line segments
            List <CurveArray> loops = RegionDetect.RegionCluster(strays);
            // The boolean union method of the loops needs to fix
            var perimeter      = RegionDetect.GetBoundary(loops);
            var recPerimeter   = CloseGapAtBreakpoint(perimeter);
            var arrayPerimeter = RegionDetect.AlignCrv(recPerimeter);
            for (int i = 0; i < arrayPerimeter.Size; i++)
            {
                Debug.Print("Line-{0} {1} {2}", i, Misc.PointString(arrayPerimeter.get_Item(i).GetEndPoint(0)),
                            Misc.PointString(arrayPerimeter.get_Item(i).GetEndPoint(1)));
            }
            #endregion
            // OUTPUT List<CurveArray> loops
            Debug.Print("REGION COMPLETE!");



            // Get the linestyle of "long-dashed"
            FilteredElementCollector fec = new FilteredElementCollector(doc)
                                           .OfClass(typeof(LinePatternElement));
            LinePatternElement linePatternElem = fec.FirstElement() as LinePatternElement;

            // Main visualization process
            using (Transaction tx = new Transaction(doc))
            {
                tx.Start("Generate Floor");

                // Draw wall patch lines

                /*
                 * foreach (Curve patchLine in patchLines)
                 * {
                 *  DetailLine axis = doc.Create.NewDetailCurve(view, patchLine) as DetailLine;
                 *  GraphicsStyle gs = axis.LineStyle as GraphicsStyle;
                 *  gs.GraphicsStyleCategory.LineColor = new Color(202, 51, 82);
                 *  gs.GraphicsStyleCategory.SetLineWeight(3, gs.GraphicsStyleType);
                 * }
                 */

                Plane       Geomplane = Plane.CreateByNormalAndOrigin(XYZ.BasisZ, XYZ.Zero);
                SketchPlane sketch    = SketchPlane.Create(doc, Geomplane);

                /*
                 * // Draw bounding boxes
                 * foreach (List<Curve> wallBlock in wallBlocks)
                 * {
                 *  foreach (Curve edge in wallBlock)
                 *  {
                 *      DetailLine axis = doc.Create.NewDetailCurve(view, edge) as DetailLine;
                 *      GraphicsStyle gs = axis.LineStyle as GraphicsStyle;
                 *      gs.GraphicsStyleCategory.LineColor = new Color(210, 208, 185);
                 *      gs.GraphicsStyleCategory.SetLineWeight(1, gs.GraphicsStyleType);
                 *      gs.GraphicsStyleCategory.SetLinePatternId(linePatternElem.Id, gs.GraphicsStyleType);
                 *  }
                 * }
                 */

                /*
                 * // Draw Axes
                 * Debug.Print("Axes all together: " + strays.Count.ToString());
                 * foreach (Line centerLine in strays)
                 * {
                 *  ModelCurve modelline = doc.Create.NewModelCurve(centerLine, sketch) as ModelCurve;
                 * }
                 */

                // Draw Regions

                foreach (CurveArray loop in loops)
                {
                    foreach (Curve edge in loop)
                    {
                        ModelCurve modelline = doc.Create.NewModelCurve(edge, sketch) as ModelCurve;
                    }
                }

                foreach (Curve edge in arrayPerimeter)
                {
                    DetailLine    axis = doc.Create.NewDetailCurve(view, edge) as DetailLine;
                    GraphicsStyle gs   = axis.LineStyle as GraphicsStyle;
                    gs.GraphicsStyleCategory.LineColor = new Color(202, 51, 82);
                    gs.GraphicsStyleCategory.SetLineWeight(8, gs.GraphicsStyleType);
                }


                tx.Commit();
            }

            return(Result.Succeeded);
        }