コード例 #1
0
        /// <summary>
        /// 根据mechanicalSystemTypeName获取对应的mechanicalSystemType
        /// </summary>
        /// <param name="mechanicalSystemTypeName"></param>
        /// <returns></returns>
        public MechanicalSystemType SelectMechanicalSystemType(string mechanicalSystemTypeName)
        {
            FilteredElementCollector collector            = new FilteredElementCollector(doc);
            MechanicalSystemType     mechanicalSystemType = collector.OfClass(typeof(MechanicalSystemType)).
                                                            Cast <MechanicalSystemType>().
                                                            First(x => x.Name == mechanicalSystemTypeName);

            return(mechanicalSystemType);
        }
コード例 #2
0
 public DuctLinkLayerDetail(string name, double ductWidth, double ductHeight, double lvlOffet, MechanicalSystemType ductType, Level refLevel, Category layerCategory)
 {
     cadLayerName       = name;
     this.ductWidth     = ductWidth;
     this.ductHeight    = ductHeight;
     this.layerCategory = layerCategory;
     airType            = ductType;
     detailLevel        = refLevel;
     levelOffset        = lvlOffet;
 }
コード例 #3
0
        private void CreateDucts(int jndex)
        {
            if (sortedlocalsTech.ElementAt(jndex).ElementAt(0).Name.Contains("GT24"))
            {
                Debug.WriteLine("TEST GAINE 24");
            }
            Debug.WriteLine(jndex);
            ElementId levelId = ElementId.InvalidElementId;

            tiltingSpaces.Clear();
            GetBestPath();
            GetTiltingSpace();
            GetBestPosition();
            currentConn = null;

            for (int i = 0; i < sortedlocalsTech.ElementAt(jndex).Count();)
            {
                if (sortedlocalsTech.ElementAt(jndex).Count() == 1)
                {
                    Debug.WriteLine("i: " + i);
                    break;
                }

                Element e     = doc.GetElement(sortedlocalsTech.ElementAt(jndex).ElementAt(i).Id);
                var     space = doc.GetElement(sortedlocalsTech.ElementAt(jndex).ElementAt(i).Id) as Space;

                try
                {
                    if (i >= RevitDataContext.lazyInstance.SpacesInfo.Count())
                    {
                        break;
                    }
                    SpatialElementGeometryCalculator calculator = new SpatialElementGeometryCalculator(doc);
                    SpatialElementGeometryResults    results    = calculator.CalculateSpatialElementGeometry(space); // compute the room geometry
                    Solid       roomSolid = results.GetGeometry();
                    List <Face> lf        = new List <Face>();
                    List <XYZ>  Edges     = new List <XYZ>();
                    List <XYZ>  temp      = new List <XYZ>();
                    foreach (Face face in roomSolid.Faces)
                    {
                        foreach (EdgeArray item in face.EdgeLoops)
                        {
                            List <XYZ> lc = JtBoundingBoxXyzExtensionMethods.GetPolygon(item);
                            foreach (var subitem in lc)
                            {
                                temp.Add(subitem);
                            }
                        }
                    }
                    XYZ tempXYZ = null;
                    #region delete identical points, Distinct() linq not that smart
                    foreach (var item in temp)
                    {
                        if (tempXYZ == null)
                        {
                            tempXYZ = item;
                            Edges.Add(item);
                        }
                        else
                        {
                            bool isPresent = false;
                            foreach (var item2 in Edges)
                            {
                                if (item.X == item2.X &&
                                    item.Y == item2.Y &&
                                    item.Z == item2.Z)
                                {
                                    isPresent = true;
                                }
                            }
                            if (isPresent == false)
                            {
                                Edges.Add(item);
                            }
                        }
                    }
                    #endregion

                    Level currentLevel = null;
                    //Get the duct Type
                    FilteredElementCollector collector1 = new FilteredElementCollector(doc);
                    collector1.OfClass(typeof(DuctType));
                    DuctType ductType = null;
                    foreach (Element elem in collector1)
                    {
                        /**
                         * Raccord avec té et coude droit
                         *  Raccord par té avec coude segmenté
                         *  Raccord par piquage et coude segmenté
                         *  Raccord par té et coude droit
                         *  Raccord par piquage et coude droit
                         *  Raccord avec té et coude segmenté
                         *  Raccord par piquage et coude à rayon
                         *  Raccord par piquage et coude segmenté
                         *  Raccord par piquage et coude droit
                         *  Raccord par piquage et coude lisse
                         *  Raccord avec té et coude lisse
                         *  Synoptique de désenfumage
                         *  Raccord par piquage et coude droit chanfreiné
                         *  Raccord avec té et coude à rayon
                         **/
                        if (elem.Name == "Raccord avec té et coude lisse" ||
                            elem.Name == "Connection with tee and smooth elbow")    // gerer english
                        {
                            ductType = elem as DuctType;
                        }
                    }
                    FilteredElementCollector collector2 = new FilteredElementCollector(doc);
                    collector2.OfClass(typeof(MechanicalSystemType)).OfCategory(BuiltInCategory.OST_DuctSystem);
                    MechanicalSystemType mechType = null;
                    foreach (Element e1 in collector2)
                    {
                        /**
                         *  Désenfumage air neuf
                         *  Conduit de Fumée
                         *  Soufflage
                         *  Reprise
                         *  Extraction
                         *  VMC
                         *  Desenfumage Extraction
                         *  Air Neuf
                         *  Rejet
                         *  Desenfumage Air Neuf
                         *  Soufflage Recylage
                         *  Reprise Recyclage
                         *  Soufflage VC
                         *  Soufflage CTA
                         *  ..
                         **/
                        if (e1.Name == "VMC" || e1.Name == "CMV")  // gerer english
                        {
                            mechType = e1 as MechanicalSystemType;
                        }
                    }

                    /**
                     *  Get next space
                     **/


                    bool GetMe = false;
                    int  at    = 0;
                    foreach (var key in RevitDataContext.lazyInstance.SpacesInfo.Keys)
                    {
                        if (key.Number == space.Number)
                        {
                            GetMe = true;
                        }
                        if (GetMe == true)
                        {
                            if (at != 0)
                            {
                                at -= 1;
                            }
                            break;
                        }
                        at += 1;
                    }

                    currentLevel = e.Document.GetElement(e.LevelId) as Level;
                    XYZ startingPoint = null;
                    XYZ endingPoint   = null;

                    /**
                     *  Get the starting point shifted depending on next space location
                     * */

                    Utils.lazyInstance.GetLowestAndHighestPolygon(RevitDataContext.lazyInstance.SpacesInfo.ElementAt(i).Value.Item2, space.Level);
                    List <XYZ> test1 = new List <XYZ>();
                    List <XYZ> test2 = new List <XYZ>();
                    test1 = Utils.lazyInstance.lowestPolyg;
                    test2 = Utils.lazyInstance.highestPolyg;
                    if (test1.Count() != 0 && test2.Count() != 0)
                    {
                        startingPoint = Utils.lazyInstance.GetCenterOfPolygon(test1);
                        endingPoint   = Utils.lazyInstance.GetCenterOfPolygon(test2);
                    }

                    Utils.lazyInstance.GetLowestAndHighestPolygon(RevitDataContext.lazyInstance.SpacesInfo.ElementAt(correspSmallestSpaces[i]).Value.Item2,
                                                                  RevitDataContext.lazyInstance.SpacesInfo.ElementAt(correspSmallestSpaces[i]).Key.Level);
                    List <XYZ> test5 = new List <XYZ>();
                    List <XYZ> test6 = new List <XYZ>();
                    test5 = Utils.lazyInstance.lowestPolyg;
                    test6 = Utils.lazyInstance.highestPolyg;
                    XYZ SendingPoint = Utils.lazyInstance.GetCenterOfPolygon(test6);
                    startingPoint = Utils.lazyInstance.GetCenterOfPolygon(test5);
                    Duct      duct      = null;
                    Connector ductStart = null;
                    Connector ductEnd   = null;
                    Utils.lazyInstance.GetLowestAndHighestPolygon(RevitDataContext.lazyInstance.SpacesInfo.ElementAt(i).Value.Item2,
                                                                  RevitDataContext.lazyInstance.SpacesInfo.ElementAt(i).Key.Level);
                    List <XYZ> test3 = new List <XYZ>();
                    List <XYZ> test4 = new List <XYZ>();
                    test3       = Utils.lazyInstance.lowestPolyg;
                    test4       = Utils.lazyInstance.highestPolyg;
                    endingPoint = new XYZ(SendingPoint.X, SendingPoint.Y, Utils.lazyInstance.GetCenterOfPolygon(test4).Z);

                    if (tiltingSpaces.Contains(correspSmallestSpaces[i]) && i != RevitDataContext.lazyInstance.SpacesInfo.Count() - 1)
                    {
                        XYZ nSt = new XYZ(startingPoint.X - 0.1, startingPoint.Y, startingPoint.Z - 0.8);
                        startingPoint = nSt;
                    }
                    Debug.WriteLine("i: " + i);
                    if (!tiltingSpaces.Contains(i) || i == 0 || i == tiltingSpaces.LastOrDefault())
                    {
                        if (currentConn != null)
                        {
                            XYZ nStart1 = currentConnOrigin;
                            endingPoint = nStart1;
                        }
                        using (Transaction tr = new Transaction(doc))
                        {
                            tr.Start("Create New Duct");
                            {
                                if (currentConn == null)
                                {
                                    duct = Duct.Create(doc, mechType.Id, ductType.Id, RevitDataContext.lazyInstance.SpacesInfo.ElementAt(i).Key.LevelId, startingPoint, endingPoint);
                                }
                                else
                                {
                                    duct = Duct.Create(doc, ductType.Id, RevitDataContext.lazyInstance.SpacesInfo.ElementAt(i).Key.LevelId, currentConn, startingPoint);
                                    Debug.WriteLine("currentConn.Origin: " + currentConn.Origin);
                                    Debug.WriteLine("startingPoint Origin: " + startingPoint);
                                }


                                Parameter parameter = duct.get_Parameter(BuiltInParameter.RBS_CURVE_DIAMETER_PARAM);
                                parameter.Set(diameter);
                                List <Connector> lC = new List <Connector>();
                                foreach (Connector conn in duct.ConnectorManager.Connectors)
                                {
                                    if (conn.ConnectorType == ConnectorType.End)
                                    {
                                        lC.Add(conn);
                                    }
                                }

                                if (lC.ElementAt(0).Origin.Z > lC.ElementAt(1).Origin.Z)
                                {
                                    ductStart = lC.ElementAt(1);
                                    ductEnd   = lC.ElementAt(0);
                                }
                                else
                                {
                                    ductStart = lC.ElementAt(0);
                                    ductEnd   = lC.ElementAt(1);
                                }
                                if (currentConn == null)
                                {
                                    currentConnectors.Add("start" + i, ductStart);
                                    currentConnectors.Add("end" + i, ductEnd);
                                }
                                else
                                {
                                    currentConnectors.Add("start" + i, currentConn);
                                    currentConnectors.Add("end" + i, ductEnd);
                                    doc.Create.NewElbowFitting(ductStart, currentConn);
                                }
                                Debug.WriteLine("Passed, ductStart.Origin : " + ductStart.Origin);
                                tr.Commit();
                                currentConn = ductEnd;
                            }
                        }
                    }

                    // is getting tilted
                    if (tiltingSpaces.Contains(correspSmallestSpaces[i]) &&
                        i != RevitDataContext.lazyInstance.SpacesInfo.Count() - 1 &&
                        correspSmallestSpaces[i] != RevitDataContext.lazyInstance.SpacesInfo.Count() - 1)
                    {
                        Utils.lazyInstance.GetLowestAndHighestPolygon(RevitDataContext.lazyInstance.SpacesInfo.ElementAt(correspSmallestSpaces[i + 1]).Value.Item2,
                                                                      RevitDataContext.lazyInstance.SpacesInfo.ElementAt(correspSmallestSpaces[i + 1]).Key.Level);
                        List <XYZ> test7 = new List <XYZ>();
                        test7 = Utils.lazyInstance.lowestPolyg;
                        var tempZ = startingPoint.Z;
                        endingPoint = new XYZ(Utils.lazyInstance.GetCenterOfPolygon(test7).X, Utils.lazyInstance.GetCenterOfPolygon(test7).Y, tempZ);

                        if (currentConn != null)
                        {
                            Utils.lazyInstance.GetLowestAndHighestPolygon(RevitDataContext.lazyInstance.SpacesInfo.ElementAt(correspSmallestSpaces[correspSmallestSpaces[i] + 1]).Value.Item2,
                                                                          RevitDataContext.lazyInstance.SpacesInfo.ElementAt(correspSmallestSpaces[i + 1]).Key.Level);
                            List <XYZ> test77 = new List <XYZ>();
                            test77 = Utils.lazyInstance.lowestPolyg;
                            var tempZZ = startingPoint.Z;
                            endingPoint = new XYZ(Utils.lazyInstance.GetCenterOfPolygon(test77).X, Utils.lazyInstance.GetCenterOfPolygon(test77).Y, tempZ);
                        }

                        using (Transaction tr2 = new Transaction(doc))
                        {
                            tr2.Start("Create New Tilting Duct");
                            {
                                duct = Duct.Create(doc, mechType.Id, ductType.Id, RevitDataContext.lazyInstance.SpacesInfo.ElementAt(i).Key.LevelId, startingPoint, endingPoint);
                                Debug.WriteLine("startingPoint Origin: " + startingPoint);
                                Debug.WriteLine("endingPoint.Origin: " + endingPoint);

                                Parameter parameter = duct.get_Parameter(BuiltInParameter.RBS_CURVE_DIAMETER_PARAM);
                                parameter.Set(diameter);
                                List <Connector> lC = new List <Connector>();
                                foreach (Connector conn in duct.ConnectorManager.Connectors)
                                {
                                    if (conn.ConnectorType == ConnectorType.End)
                                    {
                                        lC.Add(conn);
                                    }
                                }
                                int tempi = i + 1;
                                if (i != 0)
                                {
                                    tempi = correspSmallestSpaces[correspSmallestSpaces[i] + 1];
                                }
                                // getting the right start and end duct
                                Utils.lazyInstance.GetLowestAndHighestPolygon(RevitDataContext.lazyInstance.SpacesInfo.ElementAt(tempi).Value.Item2,
                                                                              RevitDataContext.lazyInstance.SpacesInfo.ElementAt(tempi).Key.Level);

                                List <XYZ> test8 = new List <XYZ>();
                                test8     = Utils.lazyInstance.lowestPolyg;
                                lC        = Utils.lazyInstance.GetClosestConnector(lC, Utils.lazyInstance.GetCenterOfPolygon(test8));
                                ductStart = lC.ElementAt(0);
                                ductEnd   = lC.ElementAt(1);

                                currentConnOrigin = ductStart.Origin;
                                test11            = ductEnd.Origin;
                                Debug.WriteLine("Start of tilting is :" + ductStart.Origin);
                                Debug.WriteLine("end of tilting is :" + ductEnd.Origin);
                                currentConn = ductStart;
                                doc.Create.NewElbowFitting(ductEnd, currentConnectors.ElementAt(currentConnectors.Count() - 1).Value);
                                currentConnectors.Add("startTilted" + i, ductStart);
                                currentConnectors.Add("endTilted" + i, ductEnd);
                            }
                            tr2.Commit();
                        }
                    }
                    i = correspSmallestSpaces[i] + 1;
                    currentElement = e;
                }
                catch (Exception ex)
                {
                    break;
                }
            }
        }
 public RevitDuctSystemTypeStringer(MechanicalSystemType systemType)
 {
     revitSystemType = systemType;
     stringerText    = systemType.Name;
 }