Exemplo n.º 1
0
        /// <summary>
        /// Получает смещение от уровня через параметр семейства.
        ///
        /// </summary>
        /// <param name="fi"></param>
        /// <returns></returns>
        public static double GetOffsetFromLevel(FamilyInstance fi)
        {
            double    elev        = -999;
            Parameter offsetParam = fi.get_Parameter(BuiltInParameter.INSTANCE_FREE_HOST_OFFSET_PARAM);

            if (offsetParam != null)
            {
                elev = offsetParam.AsDouble();
                if (elev != -999)
                {
                    return(elev);
                }
            }

            offsetParam = fi.get_Parameter(BuiltInParameter.INSTANCE_ELEVATION_PARAM);
            if (offsetParam != null)
            {
                elev = offsetParam.AsDouble();
                if (elev != -999)
                {
                    return(elev);
                }
            }


            if (elev == 0)
            {
                offsetParam = fi.get_Parameter(BuiltInParameter.INSTANCE_SILL_HEIGHT_PARAM);
                elev        = offsetParam.AsDouble();
            }

            return(elev);
        }
Exemplo n.º 2
0
        public static string GetParameterValueString(Element e, BuiltInParameter bip)
        {
            Parameter p = e.get_Parameter(bip);

            string s = string.Empty;

            if (null != p)
            {
                switch (p.StorageType)
                {
                case StorageType.Integer:
                    s = p.AsInteger().ToString();
                    break;

                case StorageType.ElementId:
                    s = p.AsElementId().IntegerValue.ToString();
                    break;

                case StorageType.Double:
                    s = p.AsDouble().ToString();
                    break;

                case StorageType.String:
                    s = p.AsDouble().ToString();
                    break;

                default:
                    s = "";
                    break;
                }
            }
            return(s);
        }
        //Sets the value of the family parameter based on a parameter value
        private void SetDocumentParameter(FamilyParameter docParameter, Parameter famParameter)
        {
            switch (famParameter.StorageType)
            {
            case (StorageType.Double):
                var value = famParameter.AsDouble();
                familyManager.Set(docParameter, famParameter.AsDouble());
                break;

            case (StorageType.Integer):
                familyManager.Set(docParameter, famParameter.AsInteger());
                break;

            case (StorageType.String):
                familyManager.Set(docParameter, famParameter.AsString());
                break;

            case (StorageType.ElementId):
                familyManager.Set(docParameter, famParameter.AsElementId());
                break;

            case (StorageType.None):
                break;
            }
        }
Exemplo n.º 4
0
        private static Value _getParam(Parameter p)
        {
            switch (p.StorageType)
            {
            case StorageType.ElementId:
                return(Value.NewContainer(p.AsElementId()));

            case StorageType.String:
                return(Value.NewString(p.AsString()));

            case StorageType.Integer:
            case StorageType.Double:
                switch (p.Definition.ParameterType)
                {
                case ParameterType.Length:
                    return(Value.NewContainer(Units.Length.FromFeet(p.AsDouble(), dynSettings.Controller.UnitsManager)));

                case ParameterType.Area:
                    return(Value.NewContainer(Units.Area.FromSquareFeet(p.AsDouble(), dynSettings.Controller.UnitsManager)));

                case ParameterType.Volume:
                    return(Value.NewContainer(Units.Volume.FromCubicFeet(p.AsDouble(), dynSettings.Controller.UnitsManager)));

                default:
                    return(Value.NewNumber(p.AsDouble()));
                }

            default:
                throw new Exception(string.Format("Parameter {0} has no storage type.", p));
            }
        }
Exemplo n.º 5
0
        public CompareResult Compare2Params(string n, Parameter p1, Parameter p2, CompareResult rz)
        {
            if (p1.StorageType != p2.StorageType)
            {
                throw(new Exception("Different parameter storage types can't be compared"));
            }
            Double d = 0;
            string v = "";

            switch (p1.StorageType)
            {
            case StorageType.Double:
                v = p1.AsDouble().ToString() + "-" + p2.AsDouble().ToString();
                if (p1.AsDouble() == 0)
                {
                    if (p2.AsDouble() < tolerance)
                    {
                        d = 1;
                    }
                    else
                    {
                        d = 0;
                    }
                }
                else
                {
                    d = Math.Abs((p2.AsDouble() - p1.AsDouble()) / p1.AsDouble());
                    if (d < tolerance)
                    {
                        d = 1;
                    }
                    else
                    {
                        d = 1 - d;
                    }
                }
                break;

            default:
                v = p1.AsString() + "-" + p2.AsString();
                if (p1.AsValueString() == p2.AsValueString())
                {
                    d = 1;
                }
                else
                {
                    d = 0;
                }
                break;
            }
            rz.result += d;
            rz.total  += 1;
            rz.AppendLine(n + ": " + v + "  " + d.ToString() + "/1");
            return(rz);
        }
Exemplo n.º 6
0
        /// <summary>
        /// SetLayer method
        /// </summary>
        /// <param name="layerNumber">The layerNumber for the number of the layers</param>
        public void SetLayer(int layerNumber)
        {
            // Get each layer.
            // An individual layer can be accessed by Layers property and its thickness and material can then be reported.
            m_slabLayer = m_slabLayerCollection[layerNumber];

            // Get the Thickness property and change to the metric millimeter
            m_thickness = ((m_slabLayer.Width) * ToMetricThickness * ToMillimeter).ToString() + " mm";

            // Get the Material name property
            if (ElementId.InvalidElementId != m_slabLayer.MaterialId)
            {
                Material material = m_document.GetElement(m_slabLayer.MaterialId) as Material;
                m_materialName = material.Name;
            }
            else
            {
                m_materialName = "Null";
            }

            // The Young modulus can be found from the material by using the following generic parameters:
            // PHY_MATERIAL_PARAM_YOUNG_MOD1, PHY_MATERIAL_PARAM_YOUNG_MOD2, PHY_MATERIAL_PARAM_YOUNG_MOD3
            if (ElementId.InvalidElementId != m_slabLayer.MaterialId)
            {
                Material  material             = m_document.GetElement(m_slabLayer.MaterialId) as Material;
                Parameter youngModuleAttribute = null;
                youngModuleAttribute = material.get_Parameter(BuiltInParameter.PHY_MATERIAL_PARAM_YOUNG_MOD1);
                if (null != youngModuleAttribute)
                {
                    m_youngModulusX = (youngModuleAttribute.AsDouble() / ToMetricYoungmodulus).ToString("F2") + " MPa";
                }
                youngModuleAttribute = material.get_Parameter(BuiltInParameter.PHY_MATERIAL_PARAM_YOUNG_MOD2);
                if (null != youngModuleAttribute)
                {
                    m_youngModulusY = (youngModuleAttribute.AsDouble() / ToMetricYoungmodulus).ToString("F2") + " MPa";
                }
                youngModuleAttribute = material.get_Parameter(BuiltInParameter.PHY_MATERIAL_PARAM_YOUNG_MOD3);
                if (null != youngModuleAttribute)
                {
                    m_youngModulusZ = (youngModuleAttribute.AsDouble() / ToMetricYoungmodulus).ToString("F2") + " MPa";
                }
            }
            else
            {
                m_youngModulusX = "Null";
                m_youngModulusY = "Null";
                m_youngModulusZ = "Null";
            }
        }
Exemplo n.º 7
0
        public object GetParameterValue(Parameter parameter)
        {
            object returnValue = null;

            if (parameter == null || !parameter.HasValue)
            {
                return(returnValue);
            }

            switch (parameter.StorageType)
            {
            case StorageType.Double:
                returnValue = parameter.AsDouble();
                break;

            case StorageType.Integer:
                returnValue = parameter.AsInteger();
                break;

            case StorageType.String:
                returnValue = parameter.AsString();
                break;

            case StorageType.ElementId:
                returnValue = parameter.AsElementId();
                break;
            }

            return(returnValue);
        }
        public string GetParameterValue(Parameter parameter)
        {
            string s;

            switch (parameter.StorageType)
            {
            case StorageType.Double:

                s = RealString(parameter.AsDouble());
                break;

            case StorageType.Integer:
                s = parameter.AsInteger().ToString();
                break;

            case StorageType.String:
                s = parameter.AsString();
                break;

            case StorageType.ElementId:
                s = parameter.AsElementId().IntegerValue.ToString();
                break;

            case StorageType.None:
                s = "";
                break;

            default:
                s = "0.0";
                break;
            }
            return(s);
        }
        /// <summary>
        /// Calculates Roll value (Rotation angle) for a beam, column and member
        /// </summary>
        /// <param name="exporterIFC">
        /// The ExporterIFC object.
        /// </param>
        /// <param name="extrusionCreationData">
        /// The IFCExtrusionCreationData.
        /// </param>
        /// <param name="element">
        /// The element to calculate the value.
        /// </param>
        /// <param name="elementType">
        /// The element type.
        /// </param>
        /// <returns>
        /// True if the operation succeed, false otherwise.
        /// </returns>
        public override bool Calculate(ExporterIFC exporterIFC, IFCExtrusionCreationData extrusionCreationData, Element element, ElementType elementType)
        {
            Parameter rollPar = element.get_Parameter(BuiltInParameter.STRUCTURAL_BEND_DIR_ANGLE);

            if (rollPar != null)
            {
                double?roll = rollPar.AsDouble();
                if (roll != null && roll.HasValue)
                {
                    m_Roll = UnitUtil.ScaleAngle(roll.Value);
                    return(true);
                }
            }

            // For other elements with ExtrusionData. Parameter will take precedence (override)
            if (ParameterUtil.GetDoubleValueFromElementOrSymbol(element, "IfcRoll", out m_Roll) == null)
            {
                ParameterUtil.GetDoubleValueFromElementOrSymbol(element, "Roll", out m_Roll);
            }
            m_Roll = UnitUtil.ScaleAngle(m_Roll);
            if (m_Roll > MathUtil.Eps())
            {
                return(true);
            }

            return(false);
        }
Exemplo n.º 10
0
        //Build solid
        public void incrementIntercetor(Document doc, XYZ startOfInterest, Parameter zOffsetVar, out ElementId columnId, out ElementId beamId)
        {
            columnId = null;
            beamId   = null;

            double radius  = 0;
            double limit   = 0.75;
            double zOffset = zOffsetVar.AsDouble();
            //lower arc center
            double centerZ   = (startOfInterest.Z + zOffset) - 0.25;
            XYZ    arcCenter = new XYZ(startOfInterest.X, startOfInterest.Y, centerZ);

            //Build a solid cylinder
            for (radius = .125; radius < limit; radius = radius + 0.1)
            {
                // Create a vertical half-circle loop in the frame location.
                List <CurveLoop> curveloops = new List <CurveLoop>();
                CurveLoop        circle     = new CurveLoop();
                circle.Append(Arc.Create(arcCenter, radius, 0, Math.PI, XYZ.BasisX, XYZ.BasisY));
                circle.Append(Arc.Create(arcCenter, radius, Math.PI, 2 * Math.PI, XYZ.BasisX, XYZ.BasisY));
                curveloops.Add(circle);

                Solid cylinder = GeometryCreationUtilities.CreateExtrusionGeometry(curveloops, XYZ.BasisZ, (0.25));
                //PaintSolid(commandData, cylinder, 5);
                //Find column
                IEnumerable <Element> columns = new FilteredElementCollector(doc)
                                                .OfClass(typeof(FamilyInstance))
                                                .OfCategory(BuiltInCategory.OST_StructuralColumns)
                                                .WherePasses(new ElementIntersectsSolidFilter(cylinder));

                if (columns.Count() > 0)
                {
                    foreach (Element e in columns)
                    {
                        FamilyInstance fi = e as FamilyInstance;
                        FamilySymbol   fs = fi.Symbol;
                        columnId = e.Id;
                    }
                    break;
                }

                //Find beam
                IEnumerable <Element> beams = new FilteredElementCollector(doc)
                                              .OfClass(typeof(FamilyInstance))
                                              .OfCategory(BuiltInCategory.OST_StructuralFraming)
                                              .WherePasses(new ElementIntersectsSolidFilter(cylinder));

                if (beams.Count() > 0)
                {
                    foreach (Element e in beams)
                    {
                        FamilyInstance fi = e as FamilyInstance;
                        FamilySymbol   fs = fi.Symbol;
                        beamId = e.Id;
                    }
                    break;
                }
            }
            //End of loop
        }
        public void GetParameters()
        {
            Document     doc  = Column.Document;
            FamilySymbol type = Column.Symbol;

            Width  = type.LookupParameter("b").AsDouble();
            Height = type.LookupParameter("h").AsDouble();

            LocationPoint lp = Column.Location as LocationPoint;
            XYZ           p  = lp.Point;

            Parameter blP = Column.LookupParameter("Base Level");
            Parameter boP = Column.LookupParameter("Base Offset");

            Level  bl = doc.GetElement(blP.AsElementId()) as Level;
            double bo = boP.AsDouble();

            Parameter tlP = Column.LookupParameter("Top Level");
            Parameter toP = Column.LookupParameter("Top Offset");

            Level  tl = doc.GetElement(tlP.AsElementId()) as Level;
            double to = toP.AsDouble();

            DrivingCurve = Line.CreateBound(new XYZ(p.X, p.Y, bl.Elevation + bo), new XYZ(p.X, p.Y, tl.Elevation + to));
            Length       = DrivingCurve.Length;
        }
Exemplo n.º 12
0
        public static bool ResetValue(this Parameter parameter)
        {
            if (!parameter.HasValue)
            {
                return(true);
            }

#if REVIT_2020
            if (parameter.IsShared && (parameter.Definition as ExternalDefinition).HideWhenNoValue)
            {
                return(parameter.ClearValue());
            }
#endif

            switch (parameter.StorageType)
            {
            case StorageType.Integer:   return(parameter.AsInteger() == 0 || parameter.Set(0));

            case StorageType.Double:    return(parameter.AsDouble() == 0.0 || parameter.Set(0.0));

            case StorageType.String:    return(parameter.AsString() == string.Empty || parameter.Set(string.Empty));

            case StorageType.ElementId: return(parameter.AsElementId() == ElementId.InvalidElementId || parameter.Set(ElementId.InvalidElementId));
            }

            return(false);
        }
        public AnalyticElement(Element element)
        {
            Element = element;

            Parameter parInsTypeCheck = Element.get_Parameter(BuiltInParameter.RBS_REFERENCE_INSULATION_TYPE);

            if (parInsTypeCheck.HasValue)
            {
                Parameter parInsThickness = Element.get_Parameter(BuiltInParameter.RBS_REFERENCE_INSULATION_THICKNESS);
                InsulationThk = (int)parInsThickness.AsDouble().FtToMm().Round();
            }

            switch (Element)
            {
            case Pipe pipe:
                //Outside diameter
                oDia = Element.get_Parameter(BuiltInParameter.RBS_PIPE_OUTER_DIAMETER).AsDouble().FtToMm();
                //Wallthk
                DN      = (int)pipe.Diameter.FtToMm().Round();
                WallThk = MepUtils.pipeWallThkDict()[DN];
                break;

            case FamilyInstance fi:
                //Outside diameter
                Cons cons = MepUtils.GetConnectors(fi);
                DN      = (int)(cons.Primary.Radius * 2).FtToMm().Round();
                oDia    = MepUtils.outerDiaDict()[DN];
                WallThk = MepUtils.pipeWallThkDict()[DN];
                break;

            default:
                break;
            }
        }
Exemplo n.º 14
0
        public static double GetWidthStemOfDoubletee(this FamilyInstance familyInstance, Document doc)
        {
            FamilyInstance familyInstance1 = null;
            Element        p = familyInstance.SuperComponent;

            if (p != null)
            {
                familyInstance1 = p as FamilyInstance;
            }
            else
            {
                familyInstance1 = familyInstance;
            }
            ElementId type = familyInstance1.GetTypeId();
            Element   ele  = doc.GetElement(type);
            Parameter pa   = ele.LookupParameter("DT_Stem_Spacing_Form");

            if (pa != null)
            {
                return(pa.AsDouble());
            }
            else
            {
                return(0);
            }
        }
Exemplo n.º 15
0
        private static void SetParameter(Parameter parameter, string value)
        {
            switch (parameter.StorageType)
            {
            case StorageType.Integer:
                if (int.TryParse(value, out int integerValue) && parameter.AsInteger() != integerValue)
                {
                    parameter.Set(integerValue);
                }
                break;

            case StorageType.Double:
                if (double.TryParse(value, out double doubleValue) && parameter.AsDouble() != doubleValue)
                {
                    parameter.Set(doubleValue);
                }
                break;

            case StorageType.String:
                if (parameter.AsString() != value)
                {
                    parameter.Set(value);
                }
                break;

            case StorageType.ElementId:
                if (int.TryParse(value, out int elementIdIntegerValue) && parameter.AsElementId()?.IntegerValue != elementIdIntegerValue)
                {
                    parameter.Set(new ElementId(elementIdIntegerValue));
                }
                break;
            }
        }
        public void GetParameters()
        {
            Document doc  = Wall.Document;
            WallType type = Wall.WallType;

            Width = type.LookupParameter("Width").AsDouble();

            LocationCurve lc = Wall.Location as LocationCurve;
            Curve         c  = lc.Curve;

            Parameter boP = Wall.LookupParameter("Base Offset");

            c = GeomUtil.OffsetCurve(c, XYZ.BasisZ, boP.AsDouble());
            List <XYZ> ps = new List <XYZ> {
                c.GetEndPoint(0), c.GetEndPoint(1)
            };

            ps.Sort(new ZYXComparer());

            DrivingCurve = Line.CreateBound(ps[0], ps[1]);
            Length       = DrivingCurve.Length;

            Parameter uhP = Wall.LookupParameter("Unconnected Height");

            Height = uhP.AsDouble();
        }
        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;

            // code



            Reference r = uidoc.Selection.
                          PickObject(ObjectType.Element,
                                     "HAY CHON DOI TUONG");

            Element e = doc.GetElement(r);

            Parameter parameter = e
                                  .get_Parameter(BuiltInParameter.INSTANCE_LENGTH_PARAM);

            MessageBox.Show(parameter.AsDouble().ToString());


            return(Result.Succeeded);
        }
Exemplo n.º 18
0
        private static string GetParameterValue(Parameter param)
        {
            if (param == null)
            {
                return(string.Empty);
            }
            string str;

            switch (param.StorageType)
            {
            case StorageType.Integer:
                str = param.AsInteger().ToString();
                break;

            case StorageType.Double:
                str = param.AsDouble().ToString(CultureInfo.InvariantCulture);
                break;

            case StorageType.String:
                str = param.AsString();
                break;

            case StorageType.ElementId:
                str = param.AsElementId().ToString();
                break;

            default:
                str = param.AsString();
                break;
            }
            return(str ?? string.Empty);
        }
Exemplo n.º 19
0
        /// <summary>
        /// Get double value of parameter in meters unit.
        /// E.g. Length in meters, Area in square meters
        /// and Volume in Cubic_meters.
        /// Other units not supported yet.
        /// </summary>
        public static double AsMetersValue(
            this Parameter param)
        {
            if (param.StorageType != StorageType.Double)
            {
                throw new NotSupportedException(
                          "Parameter does not have double value");
            }

            double imperialValue = param.AsDouble();

            UnitType ut = ConvertParameterTypeToUnitType(
                param.Definition.ParameterType);

            switch (ut)
            {
            case UnitType.UT_Length:
                return(imperialValue * METERS_IN_FEET);

            case UnitType.UT_Area:
                return(imperialValue * Math.Pow(
                           METERS_IN_FEET, 2));

            case UnitType.UT_Volume:
                return(imperialValue * Math.Pow(
                           METERS_IN_FEET, 3));
            }
            throw new NotSupportedException();
        }
Exemplo n.º 20
0
        public static string GetAsString(Parameter param)
        {
            switch (param.StorageType)
            {
            case StorageType.None:
                return("");

            case StorageType.Integer:
                return(param.AsInteger().ToString());

            case StorageType.Double:
                double doubleval = param.AsDouble();
                if (param.Definition.UnitType == UnitType.UT_Length)
                {
                    doubleval *= 304.8;
                }
                return(doubleval.ToString("F1"));

            case StorageType.String:
                return(param.AsString());

            case StorageType.ElementId:
                int intval = param.AsElementId().IntegerValue;
                return(intval.ToString());

            default:
                return("");
            }
        }
Exemplo n.º 21
0
        /// <summary>
        /// Gets double value from parameter of an element.
        /// </summary>
        /// <param name="element">The element.</param>
        /// <param name="group">Optional property group to limit search to.</param>
        /// <param name="propertyName">The property name.</param>
        /// <param name="propertyValue">The output property value.</param>
        /// <exception cref="System.ArgumentNullException">Thrown when element is null.</exception>
        /// <exception cref="System.ArgumentException">Thrown when propertyName is null or empty.</exception>
        /// <returns>The parameter, or null if not found.</returns>
        public static Parameter GetDoubleValueFromElement(Element element, BuiltInParameterGroup?group, string propertyName, out double propertyValue)
        {
            if (element == null)
            {
                throw new ArgumentNullException("element");
            }

            if (String.IsNullOrEmpty(propertyName))
            {
                throw new ArgumentException("It is null or empty.", "propertyName");
            }

            propertyValue = 0.0;

            Parameter parameter = GetParameterFromName(element.Id, group, propertyName);

            if (parameter != null && parameter.HasValue)
            {
                switch (parameter.StorageType)
                {
                case StorageType.Double:
                    propertyValue = parameter.AsDouble();
                    return(parameter);

                case StorageType.Integer:
                    propertyValue = parameter.AsInteger();
                    return(parameter);

                case StorageType.String:
                    return(Double.TryParse(parameter.AsString(), out propertyValue) ? parameter : null);
                }
            }

            return(null);
        }
Exemplo n.º 22
0
        private void checkBox_Unchecked(object sender, EventArgs e)
        {
            CheckBox     cb  = sender as CheckBox;
            TreeViewItem tvi = cb.Parent as TreeViewItem;

            if (tvi.HasItems)
            {
                foreach (TreeViewItem tvitest in tvi.Items)
                {
                    (tvitest.Header as CheckBox).IsChecked = false;
                }
            }
            else
            {
                Parameter p = cb.Tag as Parameter;
                foreach (ElementId ei in elementsId)
                {
                    Parameter par = doc.GetElement(ei).get_Parameter(p.Definition);
                    if (Math.Round(par.AsDouble()) == Math.Round(p.AsDouble()) && par.AsElementId() == p.AsElementId() && par.AsInteger() == p.AsInteger() && par.AsString() == p.AsString() && par.AsValueString() == p.AsValueString())
                    {
                        filteredElementId.Remove(ei);
                    }
                }
                filteredElementId = filteredElementId
                                    .Distinct()
                                    .ToList();
                label1.Content = "Выбрано элементов: " + filteredElementId.Count;
            }
        }
Exemplo n.º 23
0
        public double GetCapLength(Element i)
        {
            FamilyInstance fi = i as FamilyInstance;

            if ((fi.MEPModel as MechanicalFitting).PartType == PartType.Cap)
            {
                string[] parameters = { "Length", "Длина воздуховода", "L" };

                foreach (string p in parameters)
                {
                    Parameter parLength = i.LookupParameter(p);
                    if (parLength != null)
                    {
                        length = parLength.AsDouble();
                    }
                    else
                    {
                        length = 0.0;
                    }
                }
            }
            else
            {
                length = 0.0;
            }
            return(length);
        }
Exemplo n.º 24
0
        void CopyParameter(Parameter cpFrom, Parameter cpTo)
        {
            switch (cpFrom.StorageType)
            {
            case StorageType.String:
                cpTo.Set(cpFrom.AsString());
                break;

            case StorageType.Integer:
                cpTo.Set(cpFrom.AsInteger());
                break;

            case StorageType.Double:
                cpTo.Set(cpFrom.AsDouble());
                break;

            case StorageType.ElementId:
                cpTo.Set(cpFrom.AsInteger());
                break;

            case StorageType.None:
                throw new Exception();

            default:
                throw new Exception();
            }
        }
Exemplo n.º 25
0
        /// <summary>
        /// Return parameter value formatted as string
        /// </summary>
        static string ParameterToString(Parameter p)
        {
            string s = "null";

            if (p != null)
            {
                switch (p.StorageType)
                {
                case StorageType.Double:
                    s = p.AsDouble().ToString("0.##");
                    break;

                case StorageType.Integer:
                    s = p.AsInteger().ToString();
                    break;

                case StorageType.String:
                    s = p.AsString();
                    break;

                case StorageType.ElementId:
                    s = p.AsElementId().IntegerValue.ToString();
                    break;

                case StorageType.None:
                    s = "none";
                    break;
                }
            }
            return(s);
        }
Exemplo n.º 26
0
        /// <summary>
        /// Check whether the floor is planar.
        /// </summary>
        /// <param name="bbXYZ">The floor's bounding box.</param>
        /// <param name="floor">The floor object.</param>
        /// <returns>A bool value suggests the floor is planar or not.</returns>
        private static bool IsPlanarFloor(BoundingBoxXYZ bbXYZ, Floor floor)
        {
            // Get floor thickness.
            double      floorThickness = 0.0;
            ElementType floorType      = m_revit.ActiveUIDocument.Document.GetElement(floor.GetTypeId()) as ElementType;
            Parameter   attribute      = floorType.get_Parameter(BuiltInParameter.FLOOR_ATTR_DEFAULT_THICKNESS_PARAM);

            if (null != attribute)
            {
                floorThickness = attribute.AsDouble();
            }

            // Get bounding box thickness.
            double boundThickness = Math.Abs(bbXYZ.Max.Z - bbXYZ.Min.Z);

            // Planar or not.
            if (Math.Abs(boundThickness - floorThickness) < PlanarPrecision)
            {
                return(true);
            }
            else
            {
                return(false);
            }
        }
Exemplo n.º 27
0
        public static string GetParameterValueString(this Parameter param)
        {
            string empty = string.Empty;
            string str;

            switch ((int)param.StorageType)
            {
            case 0:
                str = param.AsValueString().ToString();
                break;

            case 1:
                str = param.AsInteger().ToString();
                break;

            case 2:
                str = param.AsDouble().ToString(CultureInfo.InvariantCulture);
                break;

            case 3:
                str = param.AsString();
                break;

            case 4:
                str = param.AsElementId().ToString();
                break;

            default:
                str = param.AsValueString();
                break;
            }
            return(str ?? string.Empty);
        }
Exemplo n.º 28
0
        object GetParameterValue(Parameter par)
        {
            object parValue = null;

            if (!par.HasValue)
            {
                return(parValue);
            }

            switch (par.StorageType)
            {
            case StorageType.Double:
                parValue = par.AsDouble();
                break;

            case StorageType.Integer:
                parValue = par.AsInteger();
                break;

            case StorageType.String:
                parValue = par.AsString();
                break;

            case StorageType.ElementId:
                parValue = par.AsElementId();
                break;

            default:
                break;
            }
            return(parValue);
        }
Exemplo n.º 29
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="p"></param>
        /// <returns></returns>
        public static object GetParameterValue(Parameter p)
        {
            switch (p.StorageType)
            {
            case StorageType.None:
                throw new System.ArgumentOutOfRangeException();

            case StorageType.Integer:
                // (Konrad) It appears that by default yes/no parameters
                // have a greyed out box checked to 1 even though stored
                // integer value would return 0
                return(p.HasValue ? p.AsInteger() : 1);

            case StorageType.Double:
                return(p.AsDouble());

            case StorageType.String:
                return(p.AsString());

            case StorageType.ElementId:
                return(p.AsElementId().IntegerValue);

            default:
                throw new System.ArgumentOutOfRangeException();
            }
        }
Exemplo n.º 30
0
        /// <summary>
        /// get the room property and Department property according the property name
        /// </summary>
        /// <param name="room">a instance of room class</param>
        /// <param name="propertyName">the property name</param>
        /// <param name="proValue">the value of property</param>
        public String GetProperty(Room room, BuiltInParameter paramEnum)
        {
            String propertyValue = null;  //the value of parameter

            //get the parameter via the parameterId
            Parameter param = room.get_Parameter(paramEnum);
            //get the parameter's storage type
            StorageType storageType = param.StorageType;

            switch (storageType)
            {
            case StorageType.Integer:
                int iVal = param.AsInteger();
                propertyValue = iVal.ToString();
                break;

            case StorageType.String:
                String stringVal = param.AsString();
                propertyValue = stringVal;
                break;

            case StorageType.Double:
                Double dVal = param.AsDouble();
                dVal          = Math.Round(dVal, 2);
                propertyValue = dVal.ToString();
                break;

            default:
                break;
            }
            return(propertyValue);
        }
Exemplo n.º 31
0
        /// <summary>
        /// Helper to return parameter value as string.
        /// One can also use param.AsValueString() to
        /// get the user interface representation.
        /// </summary>
        public static string GetParameterValue( Parameter param )
        {
            string s;
              switch( param.StorageType )
              {
            case StorageType.Double:
              //
              // the internal database unit for all lengths is feet.
              // for instance, if a given room perimeter is returned as
              // 102.36 as a double and the display unit is millimeters,
              // then the length will be displayed as
              // peri = 102.36220472440
              // peri * 12 * 25.4
              // 31200 mm
              //
              //s = param.AsValueString(); // value seen by user, in display units
              //s = param.AsDouble().ToString(); // if not using not using LabUtils.RealString()
              s = RealString( param.AsDouble() ); // raw database value in internal units, e.g. feet
              break;

            case StorageType.Integer:
              s = param.AsInteger().ToString();
              break;

            case StorageType.String:
              s = param.AsString();
              break;

            case StorageType.ElementId:
              s = param.AsElementId().IntegerValue.ToString();
              break;

            case StorageType.None:
              s = "?NONE?";
              break;

            default:
              s = "?ELSE?";
              break;
              }
              return s;
        }
Exemplo n.º 32
0
 private static Expression _getParam(FamilyInstance fi, Parameter p)
 {
     if (p.StorageType == StorageType.Double)
     {
         return Expression.NewNumber(p.AsDouble());
     }
     else if (p.StorageType == StorageType.Integer)
     {
         return Expression.NewNumber(p.AsInteger());
     }
     else if (p.StorageType == StorageType.String)
     {
         return Expression.NewString(p.AsString());
     }
     else
     {
         return Expression.NewContainer(p.AsElementId());
     }
 }
Exemplo n.º 33
0
        private void Stream(ArrayList data, Parameter param)
        {
            data.Add(new Snoop.Data.ClassSeparator(typeof(Parameter)));

            data.Add(new Snoop.Data.Object("Definition", param.Definition));

            try {   // this only works for certain types of Parameters
                data.Add(new Snoop.Data.String("Display unit type", param.DisplayUnitType.ToString()));
            }
            catch (System.Exception) {
                data.Add(new Snoop.Data.String("Display unit type", "N/A"));
            }
            try
            {   // this only works for certain types of Parameters
              data.Add(new Snoop.Data.Object("Element", param.Element));
            }
            catch (System.Exception ex)
            {
              data.Add(new Snoop.Data.Exception("Element", ex));
            }
            try
            {   // this only works for certain types of Parameters
              data.Add(new Snoop.Data.String("GUID", param.GUID.ToString()));
            }
            catch (System.Exception ex)
            {
              data.Add(new Snoop.Data.Exception("GUID", ex));
            }
            try
            {   // this only works for certain types of Parameters
              data.Add(new Snoop.Data.Bool("HasValue", param.HasValue));
            }
            catch (System.Exception ex)
            {
              data.Add(new Snoop.Data.Exception("HasValue", ex));
            }
            try
            {   // this only works for certain types of Parameters
              data.Add(new Snoop.Data.ElementId("ID", param.Id,m_activeDoc));
            }
            catch (System.Exception ex)
            {
              data.Add(new Snoop.Data.Exception("ID", ex));
            }
            try
            {   // this only works for certain types of Parameters
              data.Add(new Snoop.Data.Bool("IsShared", param.IsShared));
            }
            catch (System.Exception ex)
            {
              data.Add(new Snoop.Data.Exception("IsShared", ex));
            }

            data.Add(new Snoop.Data.String("Storage type", param.StorageType.ToString()));

            if (param.StorageType == StorageType.Double)
                data.Add(new Snoop.Data.Double("Value", param.AsDouble()));
            else if (param.StorageType == StorageType.ElementId)
                data.Add(new Snoop.Data.ElementId("Value", param.AsElementId(), m_app.ActiveUIDocument.Document));
            else if (param.StorageType == StorageType.Integer)
                data.Add(new Snoop.Data.Int("Value", param.AsInteger()));
            else if (param.StorageType == StorageType.String)
                data.Add(new Snoop.Data.String("Value", param.AsString()));

            data.Add(new Snoop.Data.String("As value string", param.AsValueString()));
        }
Exemplo n.º 34
0
 private static FScheme.Value _getParam(FamilySymbol fi, Parameter p)
 {
     if (p.StorageType == StorageType.Double)
     {
         return FScheme.Value.NewNumber(p.AsDouble());
     }
     else if (p.StorageType == StorageType.Integer)
     {
         return FScheme.Value.NewNumber(p.AsInteger());
     }
     else if (p.StorageType == StorageType.String)
     {
         return FScheme.Value.NewString(p.AsString());
     }
     else
     {
         return FScheme.Value.NewContainer(p.AsElementId());
     }
 }
Exemplo n.º 35
0
 private static Value _getParam(Parameter p)
 {
     switch (p.StorageType)
     {
         case StorageType.ElementId:
             return Value.NewContainer(p.AsElementId());
         case StorageType.String:
             return Value.NewString(p.AsString());
         case StorageType.Integer:
         case StorageType.Double:
             switch (p.Definition.ParameterType)
         {
             case ParameterType.Length:
                 return Value.NewContainer(Units.Length.FromFeet(p.AsDouble(), dynSettings.Controller.UnitsManager));
             case ParameterType.Area:
                 return Value.NewContainer(Units.Area.FromSquareFeet(p.AsDouble(), dynSettings.Controller.UnitsManager));
             case ParameterType.Volume:
                 return Value.NewContainer(Units.Volume.FromCubicFeet(p.AsDouble(), dynSettings.Controller.UnitsManager));
             default:
                 return Value.NewNumber(p.AsDouble());
         }
         default:
             throw new Exception(string.Format("Parameter {0} has no storage type.", p));
     }
 }
Exemplo n.º 36
0
        public Result Execute(
            ExternalCommandData commandData,
            ref string message,
            ElementSet elements)
        {
            #region TEST_1
            #if TEST_1
              //
              // you cannot create your own parameter, because the
              // constuctor is for internal use only. This is due
              // to the fact that a parameter cannot live on its own,
              // it is linked to a definition and needs to be hooked
              // up properly in the Revit database system to work
              // ... case 1245614 [Formatting units strings]:
              //
              bool iReallyWantToCrash = false;
              if( iReallyWantToCrash )
              {
            Parameter p = new Parameter();
            p.Set( 1.0 );
            string s = p.AsDouble().ToString();
            string t = p.AsValueString();
            Debug.WriteLine( "Value " + s );
            Debug.WriteLine( "Value string " + t );
              }
            #endif // TEST
              #endregion // TEST_1

              UIDocument uidoc = commandData.Application.ActiveUIDocument;
              Document doc = uidoc.Document;

              // Loop through all pre-selected elements:

              foreach( ElementId id in uidoc.Selection.GetElementIds() )
              {
            Element e = doc.GetElement( id );

            string s = string.Empty;

            // set this variable to false to analyse the element's own parameters,
            // i.e. instance parameters for a family instance, and set it to true
            // to analyse a family instance's type parameters:

            bool analyseTypeParameters = false;

            if( analyseTypeParameters )
            {
              if( e is FamilyInstance )
              {
            FamilyInstance inst = e as FamilyInstance;
            if( null != inst.Symbol )
            {
              e = inst.Symbol;
              s = " type";
            }
              }
              else if( e is Wall )
              {
            Wall wall = e as Wall;
            if( null != wall.WallType )
            {
              e = wall.WallType;
              s = " type";
            }
              }
              // ... add support for other types if desired ...
            }

            // Loop through and list all UI-visible element parameters

            List<string> a = new List<string>();

            #region 4.1.a Iterate over element parameters and retrieve their name, type and value:

            foreach( Parameter p in e.Parameters )
            {
              string name = p.Definition.Name;
              string type = p.StorageType.ToString();
              string value = LabUtils.GetParameterValue2( p, uidoc.Document );
              //bool read_only = p.Definition.IsReadOnly; // 2013
              bool read_only = p.IsReadOnly; // 2014
              a.Add( string.Format(
            "Name={0}; Type={1}; Value={2}; ValueString={3}; read-{4}",
            name, type, value, p.AsValueString(),
            ( read_only ? "only" : "write" ) ) );
            }

            #endregion // 4.1.a

            string what = e.Category.Name
              + " (" + e.Id.IntegerValue.ToString() + ")";

            LabUtils.InfoMsg( what + " has {0} parameter{1}{2}", a );

            // If we know which param we are looking for, then:
            // A) If a standard parameter, we can get it via BuiltInParam
            // signature of Parameter method:

            try
            {

              #region 4.1.b Retrieve a specific built-in parameter:

              Parameter p = e.get_Parameter(
            BuiltInParameter.FAMILY_BASE_LEVEL_OFFSET_PARAM );

              #endregion // 4.1.b

              if( null == p )
              {
            LabUtils.InfoMsg( "FAMILY_BASE_LEVEL_OFFSET_PARAM is NOT available for this element." );
              }
              else
              {
            string name = p.Definition.Name;
            string type = p.StorageType.ToString();
            string value = LabUtils.GetParameterValue2( p, doc );
            LabUtils.InfoMsg( "FAMILY_BASE_LEVEL_OFFSET_PARAM: Name=" + name
              + "; Type=" + type + "; Value=" + value );
              }
            }
            catch( Exception )
            {
              LabUtils.InfoMsg( "FAMILY_BASE_LEVEL_OFFSET_PARAM is NOT available for this element." );
            }

            // B) For a shared parameter, we can get it via "GUID" signature
            // of Parameter method  ... this will be shown later in Labs 4 ...

            // C) or we can get the parameter by name:
            // alternatively, loop through all parameters and
            // search for the name (this works for either
            // standard or shared). Note that the same name
            // may occur multiple times:

            const string paramName = "Base Offset";

            //Parameter parByName = e.get_Parameter( paramName ); // 2014

            IList<Parameter> paramsByName = e.GetParameters( paramName ); // 2015

            if( 0 == paramsByName.Count )
            {
              LabUtils.InfoMsg( paramName + " is NOT available for this element." );
            }
            else foreach( Parameter p in paramsByName )
              {
            string parByNameName = p.Definition.Name;
            string parByNameType = p.StorageType.ToString();
            string parByNameValue = LabUtils.GetParameterValue2( p, doc );
            LabUtils.InfoMsg( paramName + ": Name=" + parByNameName
              + "; Type=" + parByNameType + "; Value=" + parByNameValue );
              }

            #region TEST_2
            #if TEST_2
            List<string> a = GetParameters( doc, e );
            foreach( string s2 in a )
            {
              Debug.WriteLine( s2 );
            }
            #endif // TEST_2
            #endregion // TEST_2

              }
              return Result.Failed;
        }
Exemplo n.º 37
0
    /// <summary>
    /// Helper function: return a string form of a given parameter.
    /// </summary>
    public static string ParameterToString(Parameter param)
    {
      string val = "none";

      if (param == null)
      {
        return val;
      }

      // To get to the parameter value, we need to pause it depending on its storage type 

      switch (param.StorageType)
      {
        case StorageType.Double:
          double dVal = param.AsDouble();
          val = dVal.ToString();
          break;
        case StorageType.Integer:
          int iVal = param.AsInteger();
          val = iVal.ToString();
          break;
        case StorageType.String:
          string sVal = param.AsString();
          val = sVal;
          break;
        case StorageType.ElementId:
          ElementId idVal = param.AsElementId();
          val = idVal.IntegerValue.ToString();
          break;
        case StorageType.None:
          break;
      }
      return val;
    }
Exemplo n.º 38
0
 private void writeValueByStorageType(Parameter p, TextWriter writer, Document doc)
 {
     if (null != p)
     {
         switch (p.StorageType)
         {
             case StorageType.Double:
                 {
                     writer.Write(p.AsDouble());
                     break;
                 }
             case StorageType.Integer:
                 {
                     writer.Write(p.AsInteger());
                     break;
                 }
             case StorageType.String:
                 {
                     writer.Write(p.AsString());
                     break;
                 }
             case StorageType.ElementId:
                 {
                     Element elem = doc.get_Element(p.AsElementId());
                     if (null == elem)
                         writer.Write("NULL ELEMENT FOUND");
                     else
                         writer.Write(elem.Name);
                     break;
                 }
             default:
                 writer.Write("N/A");
                 break;
         }
     }
 }
Exemplo n.º 39
0
 private static Value _getParam(FamilyInstance fi, Parameter p)
 {
     if (p.StorageType == StorageType.Double)
     {
         switch (p.Definition.ParameterType)
         {
             case ParameterType.Length:
                 return Value.NewContainer(Units.Length.FromFeet(p.AsDouble()));
                 break;
             case ParameterType.Area:
                 return Value.NewContainer(Units.Area.FromSquareFeet(p.AsDouble()));
                 break;
             case ParameterType.Volume:
                 return Value.NewContainer(Units.Volume.FromCubicFeet(p.AsDouble()));
                 break;
             default:
                 return Value.NewNumber(p.AsDouble());
                 break;
         }
     }
     else if (p.StorageType == StorageType.Integer)
     {
         return Value.NewNumber(p.AsInteger());
     }
     else if (p.StorageType == StorageType.String)
     {
         return Value.NewString(p.AsString());
     }
     else
     {
         return Value.NewContainer(p.AsElementId());
     }
 }