using Autodesk.Revit.Creation;
|
using Autodesk.Revit.DB;
|
using Autodesk.Revit.DB.Architecture;
|
using Autodesk.Revit.DB.Mechanical;
|
using Autodesk.Revit.DB.Plumbing;
|
using HStation.RevitDev.RevitDataExport;
|
using System;
|
using System.Collections.Generic;
|
using System.Linq;
|
using System.Text.RegularExpressions;
|
using Document = Autodesk.Revit.DB.Document;
|
|
namespace Glodon.Revit.Utility
|
{
|
public class ParameterOperator
|
{
|
/// <summary>
|
/// 构件属性
|
/// </summary>
|
/// <param name="doc"></param>
|
/// <param name="inputElement"></param>
|
/// <param name="attributeName"></param>
|
/// <returns></returns>
|
public static Parameter GetParameterByEnum(Document doc, Element inputElement, string attributeName)
|
{
|
Parameter useParameter = null;
|
try
|
{
|
var fi = inputElement as FamilyInstance;
|
if (null != fi)
|
{
|
useParameter = fi.LookupParameter(attributeName);
|
if (useParameter != null)
|
{
|
return useParameter;
|
}
|
useParameter = fi.Symbol.LookupParameter(attributeName);
|
if (null != useParameter) { return useParameter; }
|
}
|
|
useParameter = inputElement.LookupParameter(attributeName);
|
if (null != useParameter) { return useParameter; }
|
|
Element element = doc.GetElement(inputElement.GetTypeId());
|
if (null != element)
|
{
|
useParameter = element.LookupParameter(attributeName);
|
if (null != useParameter) { return useParameter; }
|
}
|
}
|
catch (Exception)
|
{
|
}
|
|
return null;
|
}
|
|
public static PipingSystemType GetElementPipingSystemType(Element elem)
|
{
|
if (elem is Pipe pipe)
|
{
|
var mepSystem = pipe.MEPSystem;
|
if (mepSystem == null) { return null; }
|
var typeId = mepSystem.GetTypeId();
|
return elem.Document.GetElement(typeId) as PipingSystemType;
|
}
|
else if(elem is FamilyInstance fi)
|
{
|
var parameter = fi.LookupParameter("系统类型");
|
if (parameter == null) { return null; }
|
if (parameter.StorageType == StorageType.String)
|
{
|
var name = parameter.AsString();
|
var pst = new FilteredElementCollector(elem.Document).OfClass(typeof(PipingSystemType)).ToElements()?.Cast<PipingSystemType>().ToList()?.Find(x=>x.Name == name);
|
return pst;
|
}
|
else if (parameter.StorageType == StorageType.ElementId)
|
{
|
var elemId = parameter.AsElementId();
|
return elem.Document.GetElement(elemId) as PipingSystemType;
|
}
|
|
}
|
return null;
|
}
|
|
/// <summary>
|
/// 获取属性
|
/// </summary>
|
/// <param name="doc"></param>
|
/// <param name="inputElement"></param>
|
/// <param name="attributeName"></param>
|
/// <returns></returns>
|
public static Parameter GetParameter(Document doc, Element inputElement, string attributeName)
|
{
|
return GetParameterByEnum(doc, inputElement, attributeName);
|
}
|
|
/// <summary>
|
/// 获取属性值
|
/// </summary>
|
/// <param name="inputParameter"></param>
|
/// <returns></returns>
|
public static string GetParemeterValue(Parameter parameter)
|
{
|
if (parameter == null)
|
{
|
return string.Empty;
|
}
|
|
var result = string.Empty;
|
if (parameter.StorageType == StorageType.Integer)
|
{
|
result = parameter.AsInteger().ToString();
|
}
|
else if (parameter.StorageType == StorageType.Double)
|
{
|
result = parameter.AsDouble().ToString();
|
}
|
else if (parameter.StorageType == StorageType.ElementId)
|
{
|
result = parameter.AsValueString();
|
}
|
else
|
{
|
result = string.IsNullOrWhiteSpace(parameter.AsString()) ? parameter.AsValueString() : parameter.AsString();
|
}
|
if (result == null)
|
{
|
return string.Empty;
|
}
|
return result;
|
}
|
|
/// <summary>
|
/// 获取名称属性值
|
/// </summary>
|
/// <param name="doc"></param>
|
/// <param name="inputElement"></param>
|
/// <param name="attributeName"></param>
|
/// <returns></returns>
|
public static string GetElementName(Element eachElement)
|
{
|
try
|
{
|
//获取实例 族与类型 参数值
|
Parameter param = eachElement.get_Parameter(BuiltInParameter.ELEM_FAMILY_AND_TYPE_PARAM);
|
string value = GetParemeterValue(param);
|
if (!String.IsNullOrEmpty(value))
|
{
|
return value;
|
}
|
|
return eachElement.Name;
|
}
|
catch (Exception)
|
{
|
return String.Empty;
|
}
|
}
|
|
/// <summary>
|
/// 获取族与类型参数
|
/// </summary>
|
/// <returns></returns>
|
public static string GetElementFamilyAndTypeValue(Element eachElement)
|
{
|
try
|
{
|
//获取实例 族与类型 参数值
|
Parameter param = eachElement.get_Parameter(BuiltInParameter.ELEM_FAMILY_AND_TYPE_PARAM);
|
string value = GetParemeterValue(param);
|
if (!string.IsNullOrEmpty(value))
|
{
|
return value;
|
}
|
|
//如 族与类型 获取失败，只提取类型名称
|
var type = eachElement.Document.GetElement(eachElement.GetTypeId());
|
return type == null ? string.Empty : type.Name;
|
}
|
catch (Exception)
|
{
|
return string.Empty;
|
}
|
}
|
|
/// <summary>
|
/// 属性值是否可用
|
/// </summary>
|
/// <param name="lstParametet"></param>
|
/// <param name="paraValue"></param>
|
/// <returns></returns>
|
private static bool ExtractParameter(IList<Parameter> lstParametet, out string paraValue)
|
{
|
paraValue = string.Empty;
|
|
foreach (var item in lstParametet)
|
{
|
var value = GetParemeterValue(item);
|
|
var succeed = value != null
|
&& !string.IsNullOrWhiteSpace(value)
|
&& value != "0";
|
|
if (succeed)
|
{
|
paraValue = value;
|
return succeed;
|
}
|
}
|
|
return false;
|
}
|
|
/// <summary>
|
/// 是否为mep构件
|
/// </summary>
|
/// <returns></returns>
|
private static bool IsMEPInstace(BuiltInCategory instanceCategory)
|
{
|
switch (instanceCategory)
|
{
|
case BuiltInCategory.OST_DuctSystem:
|
case BuiltInCategory.OST_PipingSystem:
|
return true;
|
default:
|
return false;
|
}
|
}
|
|
public static string GetPipeSystemTypeName(Pipe pipe)
|
{
|
try
|
{
|
var parameter = pipe.get_Parameter(BuiltInParameter.RBS_PIPING_SYSTEM_TYPE_PARAM);
|
return parameter.AsValueString();
|
}
|
catch (Exception)
|
{
|
return string.Empty;
|
}
|
}
|
|
public static string GetDuctSystemTypeName(Duct duct)
|
{
|
try
|
{
|
var parameter = duct.get_Parameter(BuiltInParameter.RBS_DUCT_SYSTEM_TYPE_PARAM);
|
if (parameter == null) { return null; }
|
return parameter.AsValueString();
|
}
|
catch (Exception)
|
{
|
return string.Empty;
|
}
|
}
|
|
/// <summary>
|
/// 获取参数值 AsDouble
|
/// </summary>
|
/// <param name="elem"></param>
|
/// <param name="builtInParameter"></param>
|
/// <returns></returns>
|
public static double? GetParameterValueAsDouble(Element elem, BuiltInParameter builtInParameter)
|
{
|
double? result = null;
|
if (elem != null && elem.get_Parameter(builtInParameter) is Parameter para)
|
{
|
if (para == null || !para.HasValue) { return result; }
|
result =para.AsDouble();
|
}
|
return result;
|
}
|
|
/// <summary>
|
/// 获取参数值 AsDouble
|
/// </summary>
|
/// <param name="elem"></param>
|
/// <param name="paramName"></param>
|
/// <param name="innerTo">单位转换方法</param>
|
/// <returns></returns>
|
public static double? GetParameterValueAsDouble(Element elem, string paramName, Func<object, double?> innerTo = null)
|
{
|
double? result = null;
|
if (elem != null)
|
{
|
Parameter para = elem.GetParameterByProName(paramName);
|
if (para == null || !para.HasValue) { return result; }
|
switch (para.StorageType)
|
{
|
case StorageType.None:
|
break;
|
case StorageType.Integer:
|
result = para.AsInteger();
|
break;
|
case StorageType.Double:
|
if (innerTo != null && para.GetUnitTypeId() != UnitTypeId.General)
|
{
|
result = innerTo(para.AsDouble());
|
}
|
else
|
{
|
result = para.AsDouble();
|
}
|
break;
|
case StorageType.String:
|
result = StringToDouble(para.AsString());
|
break;
|
case StorageType.ElementId:
|
//不处理
|
break;
|
default:
|
break;
|
}
|
}
|
return result;
|
}
|
|
/// <summary>
|
/// 获取参数值 AsDouble
|
/// </summary>
|
/// <param name="elem"></param>
|
/// <param name="paramNames"></param>
|
/// <param name="innerTo"></param>
|
/// <returns></returns>
|
public static double? GetParameterValueAsDouble(Element elem, string[] paramNames, Func<object, double?> innerTo = null)
|
{
|
double? result = null;
|
foreach (var paramName in paramNames)
|
{
|
var res = GetParameterValueAsDouble(elem, paramName, innerTo);
|
if (res != null)
|
{
|
result = res;
|
break;
|
}
|
}
|
return result;
|
}
|
|
/// <summary>
|
/// 获取参数值 AsString
|
/// </summary>
|
/// <param name="elem"></param>
|
/// <param name="paramName"></param>
|
/// <returns></returns>
|
public static string GetParameterValueAsString(Element elem, string paramName)
|
{
|
string result = null;
|
if (elem != null)
|
{
|
Parameter para = elem.GetParameterByProName(paramName);
|
if (para == null || !para.HasValue) { return result; }
|
switch (para.StorageType)
|
{
|
case StorageType.None:
|
result = para.AsString();
|
break;
|
case StorageType.Integer:
|
result = para.AsInteger().ToString();
|
break;
|
case StorageType.Double:
|
result = para.AsValueString();
|
break;
|
case StorageType.String:
|
result = para.AsString();
|
break;
|
case StorageType.ElementId:
|
result = para.AsElementId().IntegerValue.ToString();
|
break;
|
default:
|
break;
|
}
|
|
}
|
return result;
|
}
|
|
/// <summary>
|
/// 获取参数值 AsValueString
|
/// </summary>
|
/// <param name="elem"></param>
|
/// <param name="paramName"></param>
|
/// <returns></returns>
|
public static string GetParameterValueAsValueString(Element elem, string paramName)
|
{
|
string result = null;
|
if (elem != null)
|
{
|
Parameter para = elem.GetParameterByProName(paramName);
|
if (para == null || !para.HasValue) { return result; }
|
switch (para.StorageType)
|
{
|
case StorageType.None:
|
result = para.AsString();
|
break;
|
case StorageType.Integer:
|
result = para.AsInteger().ToString();
|
break;
|
case StorageType.Double:
|
result = para.AsValueString();
|
break;
|
case StorageType.String:
|
result = para.AsString();
|
break;
|
case StorageType.ElementId:
|
result = para.AsElementId().IntegerValue.ToString();
|
break;
|
default:
|
break;
|
}
|
}
|
return result;
|
}
|
|
/// <summary>
|
/// 获取参数值 AsDouble
|
/// </summary>
|
/// <param name="elem"></param>
|
/// <param name="paramName"></param>
|
/// <param name="builtInParameter"></param>
|
/// <param name="innerTo">单位转换方法</param>
|
/// <returns></returns>
|
public static double? GetParameterValueAsDouble(Element elem, string paramName, BuiltInParameter builtInParameter, Func<object, double?> innerTo = null)
|
{
|
double? result = null;
|
try
|
{
|
if (elem != null)
|
{
|
Parameter para = elem.GetParameter(paramName, builtInParameter);
|
if (para == null || !para.HasValue) { return result; }
|
switch (para.StorageType)
|
{
|
case StorageType.None:
|
break;
|
case StorageType.Integer:
|
result = para.AsInteger();
|
break;
|
case StorageType.Double:
|
if (innerTo != null && para.GetUnitTypeId() != UnitTypeId.General)//传入了单位转换方法 且参数设置了单位
|
{
|
result = innerTo(para.AsDouble());
|
}
|
else
|
{
|
result = para.AsDouble();
|
}
|
break;
|
case StorageType.String:
|
result = StringToDouble(para.AsString());
|
break;
|
case StorageType.ElementId:
|
//不处理
|
break;
|
default:
|
break;
|
}
|
}
|
}
|
catch (Exception ex)
|
{
|
return null;
|
}
|
return result;
|
}
|
|
/// <summary>
|
/// 值是字符串，可能是由是数字+单位组成，也可能没有单位
|
/// </summary>
|
/// <param name="str"></param>
|
/// <returns></returns>
|
private static double? StringToDouble(string str)
|
{
|
double? value = null;
|
if (string.IsNullOrWhiteSpace(str))
|
return value;
|
//Regex r = new Regex(@"([1-9]\d*\.?\d*)|(0\.\d*[1-9])");
|
Regex r = new Regex(@"([+-]?(\d*\.\d+([eE]?[+-]?\d+)?|\d+[eE][+-]?\d+))|([+-]?\d*)|([1-9]\d*\.?\d*)|(0\.\d*[1-9])");
|
//开始匹配
|
Match m = r.Match(str);
|
string newStr = "";
|
while (m.Success)
|
{
|
//匹配成功
|
newStr += m.Groups[0].Value;
|
|
//从上一个匹配结束的位置开始下一个匹配
|
m = m.NextMatch();
|
}
|
if (newStr == "")
|
{
|
return value;
|
}
|
value = Convert.ToDouble(newStr);
|
return value;
|
}
|
|
/// <summary>
|
/// 获取参数值 AsString
|
/// </summary>
|
/// <param name="elem"></param>
|
/// <param name="paramName"></param>
|
/// <param name="builtInParameter"></param>
|
/// <returns></returns>
|
public static string GetParameterValueAsString(Element elem, string paramName, BuiltInParameter builtInParameter)
|
{
|
string result = null;
|
if (elem != null)
|
{
|
Parameter para = elem.GetParameter(paramName, builtInParameter);
|
if (para == null || !para.HasValue) { return result; }
|
switch (para.StorageType)
|
{
|
case StorageType.None:
|
result = para.AsString();
|
break;
|
case StorageType.Integer:
|
result = para.AsInteger().ToString();
|
break;
|
case StorageType.Double:
|
result = para.AsValueString();
|
break;
|
case StorageType.String:
|
result = para.AsString();
|
break;
|
case StorageType.ElementId:
|
result = para.AsElementId().IntegerValue.ToString();
|
break;
|
default:
|
break;
|
}
|
}
|
return result;
|
}
|
|
/// <summary>
|
/// 获取参数值 AsValueString
|
/// </summary>
|
/// <param name="elem"></param>
|
/// <param name="paramName"></param>
|
/// <param name="builtInParameter"></param>
|
/// <returns></returns>
|
public static string GetParameterValueAsValueString(Element elem, string paramName, BuiltInParameter builtInParameter)
|
{
|
string result = null;
|
if (elem != null)
|
{
|
Parameter para = elem.GetParameter(paramName, builtInParameter);
|
if (para == null || !para.HasValue) { return result; }
|
result = para.AsValueString();
|
}
|
return result;
|
}
|
|
/// <summary>
|
/// 获取参数值 AsInt
|
/// </summary>
|
/// <param name="elem"></param>
|
/// <param name="paramName"></param>
|
/// <param name="builtInParameter"></param>
|
/// <returns></returns>
|
public static int? GetParameterValueAsInt(Element elem, string paramName, BuiltInParameter builtInParameter)
|
{
|
int? result = null;
|
if (elem != null)
|
{
|
Parameter para = elem.GetParameter(paramName, builtInParameter);
|
if (para == null || !para.HasValue) { return result; }
|
switch (para.StorageType)
|
{
|
case StorageType.None:
|
break;
|
case StorageType.Integer:
|
result = para.AsInteger();
|
break;
|
case StorageType.Double:
|
//不处理
|
break;
|
case StorageType.String:
|
result = StringToInt(para.AsString());
|
break;
|
case StorageType.ElementId:
|
result = para.AsElementId().IntegerValue;
|
break;
|
default:
|
break;
|
}
|
}
|
return result;
|
}
|
|
/// <summary>
|
/// 获取参数值 AsInt
|
/// </summary>
|
/// <param name="elem"></param>
|
/// <param name="paramName"></param>
|
/// <param name="builtInParameter"></param>
|
/// <returns></returns>
|
public static int? GetParameterValueAsInt(Element elem, string paramName)
|
{
|
int? result = null;
|
if (elem != null)
|
{
|
Parameter para = elem.GetParameterByProName(paramName);
|
if (para == null || !para.HasValue) { return result; }
|
switch (para.StorageType)
|
{
|
case StorageType.None:
|
break;
|
case StorageType.Integer:
|
result = para.AsInteger();
|
break;
|
case StorageType.Double:
|
//不处理
|
break;
|
case StorageType.String:
|
result = StringToInt(para.AsString());
|
break;
|
case StorageType.ElementId:
|
result = para.AsElementId().IntegerValue;
|
break;
|
default:
|
break;
|
}
|
}
|
return result;
|
}
|
|
/// <summary>
|
/// 将特殊的字符串转成int表示的bool
|
/// </summary>
|
/// <param name="str"></param>
|
/// <returns></returns>
|
private static int? StringToInt(string str)
|
{
|
if (str == "是" || str == "正确" || str == "true" || str == "True" || str == "真" || str == "对" || str == "有")
|
{
|
return 1;
|
}
|
else if (str == "否" || str == "错误" || str == "不正确" || str == "false" || str == "False" || str == "假" || str == "不对" || str == "没有")
|
{
|
return 0;
|
}
|
else if(int.TryParse(str, out int result))
|
{
|
return result;
|
}
|
else
|
{
|
return null;
|
}
|
}
|
|
/// <summary>
|
/// 获取参数值 AsElementId
|
/// </summary>
|
/// <param name="elem"></param>
|
/// <param name="paramName"></param>
|
/// <param name="builtInParameter"></param>
|
/// <returns></returns>
|
public static ElementId GetParameterValueAsElementId(Element elem, string paramName, BuiltInParameter builtInParameter)
|
{
|
ElementId result = null;
|
if (elem != null)
|
{
|
Parameter para = elem.GetParameter(paramName, builtInParameter);
|
if (para == null || !para.HasValue) { return result; }
|
result = para.AsElementId();
|
}
|
return result;
|
}
|
|
/// <summary>
|
/// 获取参数值 AsElementId
|
/// </summary>
|
/// <param name="elem"></param>
|
/// <param name="paramName"></param>
|
/// <param name="builtInParameter"></param>
|
/// <returns></returns>
|
public static ElementId GetParameterValueAsElementId(Element elem, BuiltInParameter builtInParameter)
|
{
|
ElementId result = null;
|
if (elem != null)
|
{
|
Parameter para = elem.get_Parameter(builtInParameter);
|
if (para == null || !para.HasValue) { return result; }
|
result = para.AsElementId();
|
}
|
return result;
|
}
|
|
/// <summary>
|
/// 获取参数值 AsElementId
|
/// </summary>
|
/// <param name="elem"></param>
|
/// <param name="paramName"></param>
|
/// <param name="builtInParameter"></param>
|
/// <returns></returns>
|
public static ElementId GetParameterValueAsElementId(Element elem, string paramName)
|
{
|
ElementId result = null;
|
if (elem != null)
|
{
|
Parameter para = elem.GetParameterByProName(paramName);
|
if (para == null || !para.HasValue) { return result; }
|
result = para.AsElementId();
|
}
|
return result;
|
}
|
|
/// <summary>
|
/// 获取系统类型名称字符串
|
/// </summary>
|
/// <param name="elem"></param>
|
/// <param name="paramName"></param>
|
/// <param name="builtIn"></param>
|
/// <returns></returns>
|
public static string GetSystemTypeName(Element elem, string paramName, BuiltInParameter builtInParameter = BuiltInParameter.INVALID)
|
{
|
string res = null;
|
try
|
{
|
if (builtInParameter != BuiltInParameter.INVALID)
|
{
|
Parameter para = elem.GetParameter(paramName, builtInParameter);
|
if (para != null)
|
{
|
if (para.StorageType == StorageType.ElementId)
|
{
|
var elemId = para.AsElementId();
|
if (elemId != null && elemId != ElementId.InvalidElementId)
|
{
|
var tempElem = elem.Document.GetElement(elemId);
|
res = tempElem.Name;
|
}
|
}
|
else
|
{
|
res = para.AsValueString();
|
}
|
}
|
}
|
else
|
{
|
Parameter para = elem.GetParameterByProName(paramName);
|
if (para != null)
|
{
|
if (para.StorageType == StorageType.ElementId)
|
{
|
var elemId = para.AsElementId();
|
if (elemId != null && elemId != ElementId.InvalidElementId)
|
{
|
var tempElem = elem.Document.GetElement(elemId);
|
res = tempElem.Name;
|
}
|
}
|
else
|
{
|
res = para.AsValueString();
|
}
|
}
|
}
|
}
|
catch
|
{
|
|
}
|
return res;
|
}
|
}
|
|
public static class ParameterUtil
|
{
|
/// <summary>
|
/// 有内置参数的，调用该函数
|
/// </summary>
|
/// <param name="element"></param>
|
/// <param name="parameterName">参数名</param>
|
/// <param name="builtInParameter">内置参数</param>
|
/// <returns></returns>
|
public static Parameter GetParameter(this Element element, string parameterName, BuiltInParameter builtInParameter)
|
{
|
Parameter para = null;
|
try
|
{
|
if (element is ElementType)
|
{
|
para = element.get_Parameter(builtInParameter);
|
}
|
else
|
{
|
para = element.get_Parameter(builtInParameter);
|
if (para == null)
|
{
|
var typeId = element.GetTypeId();
|
if (typeId == null)
|
{
|
return null;
|
}
|
var type = element.Document.GetElement(typeId) as ElementType;
|
para = type.get_Parameter(builtInParameter);
|
}
|
}
|
}
|
catch (Exception ex)
|
{
|
para = null;
|
}
|
|
return para == null ? GetParameterByProName(element, parameterName) : para;
|
}
|
/// <summary>
|
/// 根据参数名获取参数，如果element是类型，获取的就是类型参数，
|
/// 如果element是实例，先获取实例参数，如果获取不到，就获取类型参数，实例参数优先
|
/// 如果参数有多个，取有参数值的那个，如果多个有参数值，就取第一个有参数值的
|
/// </summary>
|
/// <param name="element"></param>
|
/// <param name="parameterName"></param>
|
/// <returns></returns>
|
public static Parameter GetParameterByProName(this Element element, string parameterName)
|
{
|
if (element is ElementType elementType)
|
{
|
return GetParameterByName(elementType, parameterName);
|
}
|
else
|
{
|
var result = GetParameterByName(element, parameterName);
|
if (result != null)
|
{
|
return result;
|
}
|
var typeId = element.GetTypeId();
|
if (typeId == null || typeId == ElementId.InvalidElementId)
|
{
|
return null;
|
}
|
var type = element.Document.GetElement(typeId) as ElementType;
|
return GetParameterByName(type, parameterName);
|
}
|
}
|
/// <summary>
|
/// 根据参数名获取，如果参数有多个，取有参数值的那个，如果多个有参数值，就取第一个有参数值的
|
/// </summary>
|
/// <param name="element"></param>
|
/// <param name="parameterName"></param>
|
/// <returns></returns>
|
private static Parameter GetParameterByName(this Element element, string parameterName)
|
{
|
if (string.IsNullOrEmpty(parameterName))
|
{
|
return null;
|
}
|
var parameters = element.GetParameters(parameterName);
|
if (parameters.Count == 0)
|
{
|
return null;
|
}
|
if (parameters.Count == 1)
|
{
|
return parameters[0];
|
}
|
//如果参数有多个，获取有值的参数
|
var tempParams = parameters.Where(x => !string.IsNullOrEmpty(ParameterOperator.GetParemeterValue(x))).ToList();
|
//如果多个参数都没有值 则返回第一个
|
if (tempParams.Count == 0)
|
{
|
return parameters.First();
|
}
|
//如果只有一个参数有值 则返回这个参数
|
if (tempParams.Count == 1)
|
{
|
return tempParams.First();
|
}
|
|
return tempParams.First();
|
}
|
}
|
}
|
