/// <summary> /// Executed upon existing the param_expr rule /// </summary> /// <param name="context">the param_expr context</param> public override void ExitParam_expr([NotNull] ParamExprGrammarParser.Param_exprContext context) { base.ExitParam_expr(context); NodeProperty paramExprNodeProp = GetNodePropertyValue(context.expr()); object parValue = paramExprNodeProp.nodePropertyValue; // Unique parameter value can only be "enforced" for a string datatype by appending a running number: <parValue> (#), starting with 2 if (isUnique && parValue is string) { Tuple <string, object> key = new Tuple <string, object>(RevitParameterName, parValue); int counter = 0; if (UniqueParameterValue.TryGetValue(key, out counter)) { counter++; parValue = parValue.ToString() + " (" + counter.ToString() + ")"; UniqueParameterValue[key] = counter; } else { UniqueParameterValue.Add(key, 1); } } FinalParameterValue = parValue; UnitType = paramExprNodeProp.uomTypeId; if (paramExprNodeProp.uomTypeId != null) { if (FinalParameterValue is double) { double?paramValueDouble = FinalParameterValue as double?; formattedValue = UnitFormatUtils.Format(RevitElement.Document.GetUnits(), paramExprNodeProp.uomTypeId, paramValueDouble.Value, false); FinalParameterValue = UnitUtils.ConvertToInternalUnits(paramValueDouble.Value, paramExprNodeProp.uomTypeId); } } }
protected override void Process(IFCAnyHandle ifcCurve) { base.Process(ifcCurve); bool found = false; double radius = IFCImportHandleUtil.GetRequiredScaledLengthAttribute(ifcCurve, "Radius", out found); if (!found) { Importer.TheLog.LogError(ifcCurve.StepId, "Cannot find the radius of this circle", false); return; } try { Curve = Arc.Create(Position.Origin, radius, 0, 2.0 * Math.PI, Position.BasisX, Position.BasisY); } catch (Exception ex) { if (ex.Message.Contains("too small")) { string lengthAsString = UnitFormatUtils.Format(IFCImportFile.TheFile.Document.GetUnits(), UnitType.UT_Length, radius, true, false); Importer.TheLog.LogError(Id, "Found a circle with radius of " + lengthAsString + ", ignoring.", false); Curve = null; } else { Importer.TheLog.LogError(Id, ex.Message, false); } Curve = null; } }
static public string FormatLengthAsString(double value) { FormatValueOptions formatValueOptions = new FormatValueOptions(); formatValueOptions.AppendUnitSymbol = true; return(UnitFormatUtils.Format(IFCImportFile.TheFile.Document.GetUnits(), UnitType.UT_Length, value, true, false, formatValueOptions)); }
private string ConvertFeetInchToString(double feetInch) { Units units = this.doc.GetUnits(); string output = UnitFormatUtils.Format(units, UnitType.UT_Length, feetInch, true, true); return(output); }
static public string FormatToRevitUI(string valueName, double value, UnitsAssignment[] Assignments, bool appendUnitSymbol = false) { string formatedValue = value.ToString(); if (null == RevitUnits) { return(formatedValue); } foreach (UnitsAssignment ua in Assignments) { if (ua.ValueName.CompareTo(valueName) == 0) { FormatOptions fo = RevitUnits.GetFormatOptions(ua.unitType); FormatValueOptions formatValueOptions = new FormatValueOptions(); formatValueOptions.SetFormatOptions(fo); formatValueOptions.AppendUnitSymbol = appendUnitSymbol; formatedValue = UnitFormatUtils.Format(RevitUnits, ua.unitType, value, false, false, formatValueOptions); string unitSymbol = GetUnitSymbol(valueName, Assignments); if (unitSymbol.Length > 0) { formatedValue = Regex.Replace(formatedValue, unitSymbol, ""); } break; } } return(formatedValue); }
private string FormatBoundedValue(IFCPropertyValue propertyValue) { if (IFCUnit != null) { FormatValueOptions formatValueOptions = new FormatValueOptions(); FormatOptions specFormatOptions = IFCImportFile.TheFile.Document.GetUnits().GetFormatOptions(IFCUnit.Spec); specFormatOptions.Accuracy = 1e-8; if (specFormatOptions.CanSuppressTrailingZeros()) { specFormatOptions.SuppressTrailingZeros = true; } formatValueOptions.SetFormatOptions(specFormatOptions); // If ScaleValues is false, value is in source file units, but 'UnitFormatUtils.Format' expects // it in internal units and it then converts it to display units, which should be the same as // the source file units. double value = Importer.TheProcessor.ScaleValues ? propertyValue.AsDouble() : UnitUtils.ConvertToInternalUnits(propertyValue.AsDouble(), specFormatOptions.GetUnitTypeId()); return(UnitFormatUtils.Format(IFCImportFile.TheFile.Document.GetUnits(), IFCUnit.Spec, value, false, formatValueOptions)); } else { return(propertyValue.ValueAsString()); } }
//private static string GetParamaterUnit(DisplayUnitType uniType) //{ // switch (uniType) // { // case DisplayUnitType.DUT_MILLIMETERS: // return "mm"; // case DisplayUnitType.DUT_METERS: // return "m"; // case DisplayUnitType.DUT_CENTIMETERS: // return "cm"; // default: // return string.Empty; // } //} private static string FormatNumber(Document doc, UnitType unitType, double value) { #if R2014 var uStr = FormatUtils.Format(doc, unitType, value); #else var uStr = UnitFormatUtils.Format(doc.GetUnits(), unitType, value, false, false); #endif return(uStr); }
private void Window_Loaded(object sender, RoutedEventArgs e) { this.pfClip.Text = UnitFormatUtils.Format( _doc.GetUnits(), UnitType.UT_Length, Properties.Settings.Default.PreferFarClip, false, false); }
private string GenerateShortDistanceCommentString(double dist, double shortSegmentTolerance, int lastVertex, int currIdx, bool tryAsSolid) { string distAsString = UnitFormatUtils.Format(IFCImportFile.TheFile.Document.GetUnits(), UnitType.UT_Length, dist, true, false); string shortDistAsString = UnitFormatUtils.Format(IFCImportFile.TheFile.Document.GetUnits(), UnitType.UT_Length, shortSegmentTolerance, true, false); string warningString = "Distance between vertices " + lastVertex + " and " + currIdx + " is " + distAsString + ", which is less than the minimum " + (tryAsSolid ? "Solid" : "Mesh") + " distance of " + shortDistAsString + ", removing second point."; return(warningString); }
public static string ParameterToString(Document doc, FamilyParameter param, FamilyType type) { if (!type.HasValue(param)) { return("无"); } if (param.Definition.ParameterType == ParameterType.Invalid) { return("不可用"); } switch (param.StorageType) { case StorageType.Double: #if R2014 var uStr = FormatUtils.Format(doc, param.Definition.UnitType, type.AsDouble(param).Value); #else var uStr = UnitFormatUtils.Format(doc.GetUnits(), param.Definition.UnitType, type.AsDouble(param).Value, false, false); #endif return(uStr); //var uStr = string.Empty; //if (param.Definition.ParameterType == ParameterType.Length) //{ // uStr = GetParamaterUnit(param.DisplayUnitType); //} //var dStr = param.AsValueString(); //if (!String.IsNullOrEmpty(uStr) && !dStr.EndsWith(uStr)) dStr += uStr; //return dStr; case StorageType.Integer: var v = type.AsInteger(param).Value; if (param.Definition.ParameterType == ParameterType.YesNo) { if (v == 0) { return("否"); } return("是"); } #if R2014 return(FormatUtils.Format(doc, param.Definition.UnitType, v)); #else return(UnitFormatUtils.Format(doc.GetUnits(), param.Definition.UnitType, v, false, false)); #endif case StorageType.String: return(type.AsString(param)); case StorageType.ElementId: ElementId idVal = type.AsElementId(param); return(AsElementName(doc, idVal)); case StorageType.None: default: return("无"); } }
private static string FormatDatumOffsetString(DatumPlane datum, double offset, Units docUnits) { if (datum == null) { return(UnitFormatUtils.Format(docUnits, 0, offset, false, false)); } double num = Math.Abs(offset); bool flag = offset < 0.0; return("(" + datum.get_Name() + ")" + (flag ? " - " : " + ") + UnitFormatUtils.Format(docUnits, 0, num, false, false)); }
private string FormatBoundedValue(IFCPropertyValue propertyValue) { if (IFCUnit != null) { return(UnitFormatUtils.Format(IFCImportFile.TheFile.Document.GetUnits(), IFCUnit.UnitType, propertyValue.AsDouble(), true, false)); } else { return(propertyValue.ValueAsString()); } }
public void PE_ShouldFormatText() { //Arrange double d = 5.726548; Document doc = GeneralHelper.ExternalCommandData.Application.ActiveUIDocument.Document; Units docUnits = doc.GetUnits(); //Act string output = UnitFormatUtils.Format(docUnits, UnitType.UT_Length, d, false, true); //Assert Assert.AreEqual(output, "5\' 8 23/32\""); }
private void Height_TextBox_LostFocus(object sender, RoutedEventArgs e) { if (Tools.GetValueFromString(Height_TextBox.Text, _doc.GetUnits()) != null) { _floorHeight = (double)Tools.GetValueFromString(Height_TextBox.Text, _doc.GetUnits()); Height_TextBox.Text = UnitFormatUtils.Format(_doc.GetUnits(), UnitType.UT_Length, _floorHeight, true, true); } else { TaskDialog.Show(Tools.LangResMan.GetString("floorFinishes_TaskDialogName", Tools.Cult), Tools.LangResMan.GetString("floorFinishes_heightValueError", Tools.Cult), TaskDialogCommonButtons.Close, TaskDialogResult.Close); this.Activate(); } }
/// <summary> /// Convert a value into a formatted length string as displayed in Revit. /// </summary> /// <param name="value">The value, in Revit internal units.</param> /// <returns>The formatted string representation.</returns> static public string FormatLengthAsString(double value) { FormatValueOptions formatValueOptions = new FormatValueOptions(); formatValueOptions.AppendUnitSymbol = true; FormatOptions lengthFormatOptions = IFCImportFile.TheFile.Document.GetUnits().GetFormatOptions(SpecTypeId.Length); lengthFormatOptions.Accuracy = 1e-8; if (lengthFormatOptions.CanSuppressTrailingZeros()) { lengthFormatOptions.SuppressTrailingZeros = true; } formatValueOptions.SetFormatOptions(lengthFormatOptions); return(UnitFormatUtils.Format(IFCImportFile.TheFile.Document.GetUnits(), SpecTypeId.Length, value, false, formatValueOptions)); }
public static string ConVertDoubleToImperial(double doubleLength) { string empty = string.Empty; double num = UnitUtils.Convert(doubleLength, DisplayUnitType.DUT_DECIMAL_FEET, DisplayUnitType.DUT_FEET_FRACTIONAL_INCHES); Units units = new Units(UnitSystem.Imperial); UnitType unitType = UnitType.UT_Length; string text = UnitFormatUtils.Format(units, unitType, doubleLength, true, true); int num2 = text.IndexOf("'"); string text2 = text; text2 = text2.Remove(num2, text.Length - num2); text = text.Remove(0, num2 + 1).Trim(); num2 = text.IndexOf("\""); string str = text.Remove(num2, text.Length - num2); return(text2 + "'" + "-" + str + "\""); }
private string FormatBoundedValue(IFCPropertyValue propertyValue) { if (IFCUnit != null) { FormatValueOptions formatValueOptions = new FormatValueOptions(); FormatOptions specFormatOptions = IFCImportFile.TheFile.Document.GetUnits().GetFormatOptions(IFCUnit.Spec); specFormatOptions.Accuracy = 1e-8; if (specFormatOptions.CanSuppressTrailingZeros()) { specFormatOptions.SuppressTrailingZeros = true; } formatValueOptions.SetFormatOptions(specFormatOptions); return(UnitFormatUtils.Format(IFCImportFile.TheFile.Document.GetUnits(), IFCUnit.Spec, propertyValue.AsDouble(), false, formatValueOptions)); } else { return(propertyValue.ValueAsString()); } }
public static string Validate_Length_TextBox(Document document, System.Windows.Forms.TextBox Tbox, IsZoroAllowed Zero) { double value; Units units = document.GetUnits(); if (GetLengthInput(document, Tbox.Text, out value) == false) { TaskDialog.Show("Length is Wrong Input", "Type ? to Help"); Tbox.Focus(); } if (Zero == IsZoroAllowed.Deny) { if (value <= 0) { TaskDialog.Show("No Zero Length is Allowed", "No Zero Length is Allowed \n Type ? to Help"); Tbox.Focus(); } } return(Tbox.Text = UnitFormatUtils.Format(units, UnitType.UT_Length, value, false, false)); }
public void UpdateLengthRepresentation() { //Check if in Revit context. if (_revitDocument != null) { Units docUnits = _revitDocument.GetUnits(); ValueParsingOptions vpo = new ValueParsingOptions(); vpo.AllowedValues = AllowedValues.NonNegative; bool parsRes = UnitFormatUtils.TryParse(docUnits, UnitType.UT_Length, LengthModel.LengthRepresentation, vpo, out double output); //If parsing succeded if (parsRes == true) { output = output * 12 * 32; output = Math.Round(output, 0, MidpointRounding.AwayFromZero); output = output / 12 / 32; LengthModel.LengthRepresentation = UnitFormatUtils.Format( docUnits, UnitType.UT_Length, output, true, true); } } }
public bool TryFormatLengthToRepresentation() { try { if (_revitDocument != null && !double.IsNaN(LengthModel.LengthInDouble)) { Units docUnits = _revitDocument.GetUnits(); LengthModel.LengthRepresentation = UnitFormatUtils.Format( docUnits, UnitType.UT_Length, LengthModel.LengthInDouble, true, true); return(true); } return(false); } catch (Exception ex) { MessageBox.Show("Exeption hander from ParameterEditorViewModel.cs. \r\n" + "TryFormatLengthToRepresentation method,\r\n" + " Exeption message: \r\n\r\n" + ex.Message); return(false); } }
private void pfClip_KeyUp(object sender, KeyEventArgs e) { if (e.Key == Key.Return) { String pfc = this.pfClip.Text; UnitType clipUnit = UnitType.UT_Length; Units thisDocUnits = _doc.GetUnits(); double userFarClipSetting; UnitFormatUtils.TryParse(thisDocUnits, clipUnit, pfc, out userFarClipSetting); if (userFarClipSetting > 0) { this.pfClip.Text = UnitFormatUtils.Format(thisDocUnits, clipUnit, userFarClipSetting, false, false); } else { this.pfClip.Text = "8' - 0\""; } } }
override protected void Process(IFCAnyHandle solid) { base.Process(solid); // We will not fail if the direction is not given, but instead assume it to be normal to the swept area. IFCAnyHandle direction = IFCImportHandleUtil.GetRequiredInstanceAttribute(solid, "ExtrudedDirection", false); if (direction != null) { Direction = IFCPoint.ProcessNormalizedIFCDirection(direction); } else { Direction = XYZ.BasisZ; } bool found = false; Depth = IFCImportHandleUtil.GetRequiredScaledLengthAttribute(solid, "Depth", out found); if (found && Depth < 0.0) { // Reverse depth and orientation. if (Application.IsValidThickness(-Depth)) { Depth = -Depth; Direction = -Direction; IFCImportFile.TheLog.LogWarning(solid.StepId, "negative extrusion depth is invalid, reversing direction.", false); } } if (!found || !Application.IsValidThickness(Depth)) { string depthAsString = UnitFormatUtils.Format(IFCImportFile.TheFile.Document.GetUnits(), UnitType.UT_Length, Depth, true, false); IFCImportFile.TheLog.LogError(solid.StepId, "extrusion depth of " + depthAsString + " is invalid, aborting.", true); } }
private string GetStringFromNumber(Document doc, double number, ForgeTypeId specTypeId) { return(UnitFormatUtils.Format(doc.GetUnits(), specTypeId, number, false)); }
public static string FormatLengthNumber(double length, Units units) { return(UnitFormatUtils.Format(units, UnitType.UT_Length, length, true, false)); }
/// <summary> /// /// </summary> /// <returns></returns> public ObservableCollection <DimensionWrapper> CollectDimensionOverrides() { var dInstances = new FilteredElementCollector(_doc) .OfClass(typeof(Dimension)) .WhereElementIsNotElementType() .Cast <Dimension>(); // (Konrad) There is a user override in Configuration that controls what dimension overrides are ignored var centralPath = FileInfoUtil.GetCentralFilePath(_doc); var config = MissionControlSetup.Configurations.ContainsKey(centralPath) ? MissionControlSetup.Configurations[centralPath] : null; var dimensionValueCheck = new List <string> { "EQ" }; //defaults if (config != null) { dimensionValueCheck = config.Updaters.First(x => string.Equals(x.UpdaterId, Properties.Resources.HealthReportTrackerGuid, StringComparison.OrdinalIgnoreCase)).UserOverrides.DimensionValueCheck.Values; } var units = _doc.GetUnits(); var dims = new List <DimensionWrapper>(); foreach (var d in dInstances) { if (d.NumberOfSegments == 0) { if (string.IsNullOrEmpty(d.ValueOverride)) { continue; } // dim w/ zero segments dims.Add(new DimensionWrapper(d) { DimensionId = d.Id, OwnerViewType = d.ViewSpecific ? ((View)_doc.GetElement(d.OwnerViewId)).ViewType.ToString() : string.Empty, OwnerViewId = d.OwnerViewId, ValueString = UnitFormatUtils.Format(units, d.DimensionType.UnitType, (double)d.Value, false, false), IsValueOverrideHuge = EvaluateValueOverride(d.ValueOverride, d.Value), IsVisible = !dimensionValueCheck.Any(d.ValueOverride.Contains), IsFiltered = dimensionValueCheck.Any(d.ValueOverride.Contains) }); } else { // dim w/ multiple segments foreach (DimensionSegment s in d.Segments) { // not every segment has to be overriden if (string.IsNullOrEmpty(s.ValueOverride)) { continue; } dims.Add(new DimensionWrapper(s) { DimensionId = d.Id, OwnerViewType = d.ViewSpecific ? ((View)_doc.GetElement(d.OwnerViewId)).ViewType.ToString() : string.Empty, OwnerViewId = d.OwnerViewId, ValueString = UnitFormatUtils.Format(units, d.DimensionType.UnitType, (double)s.Value, false, false), IsValueOverrideHuge = EvaluateValueOverride(s.ValueOverride, s.Value), IsVisible = !dimensionValueCheck.Any(s.ValueOverride.Contains), IsFiltered = dimensionValueCheck.Any(s.ValueOverride.Contains) }); } } } return(new ObservableCollection <DimensionWrapper>(dims)); }
private string AsRevitDistanceFormat(double dist) { return(UnitFormatUtils.Format(_doc.GetUnits(), UnitType.UT_Length, dist, false, false)); }
private string GetStringFromNumber(Document doc, double number, UnitType unitType) { return(UnitFormatUtils.Format(doc.GetUnits(), unitType, number, true, false)); }
protected override void Process(IFCAnyHandle ifcCurve) { base.Process(ifcCurve); // We are going to attempt minor repairs for small but reasonable gaps between Line/Line and Line/Arc pairs. As such, we want to collect the // curves before we create the curve loop. IList <IFCAnyHandle> segments = IFCAnyHandleUtil.GetAggregateInstanceAttribute <List <IFCAnyHandle> >(ifcCurve, "Segments"); if (segments == null) { Importer.TheLog.LogError(Id, "Invalid IfcCompositeCurve with no segments.", true); } // need List<> so that we can AddRange later. List <Curve> curveSegments = new List <Curve>(); Segments.Clear(); foreach (IFCAnyHandle segment in segments) { IFCCurve currCurve = ProcessIFCCompositeCurveSegment(segment); if (currCurve != null) { Segments.Add(currCurve); if (currCurve.Curve != null) { curveSegments.Add(currCurve.Curve); } else if (currCurve.CurveLoop != null) { foreach (Curve subCurve in currCurve.CurveLoop) { if (subCurve != null) { curveSegments.Add(subCurve); } } } } } int numSegments = curveSegments.Count; if (numSegments == 0) { Importer.TheLog.LogError(Id, "Invalid IfcCompositeCurve with no segments.", true); } try { // We are going to try to reverse or tweak segments as necessary to make the CurveLoop. // For each curve, it is acceptable if it can be appended to the end of the existing loop, or prepended to its start, // possibly after reversing the curve, and possibly with some tweaking. // NOTE: we do not do any checks yet to repair the endpoints of the curveloop to make them closed. // NOTE: this is not expected to be perfect with dirty data, but is expected to not change already valid data. // curveLoopStartPoint and curveLoopEndPoint will change over time as we add new curves to the start or end of the CurveLoop. XYZ curveLoopStartPoint = curveSegments[0].GetEndPoint(0); XYZ curveLoopEndPoint = curveSegments[0].GetEndPoint(1); double vertexEps = IFCImportFile.TheFile.Document.Application.VertexTolerance; // This is intended to be "relatively large". The idea here is that the user would rather have the information presented // than thrown away because of a gap that is architecturally insignificant. double gapVertexEps = Math.Max(vertexEps, 0.01); // 1/100th of a foot, or 3.048 mm. double shortCurveTol = IFCImportFile.TheFile.Document.Application.ShortCurveTolerance; // canRepairFirst may change over time, as we may potentially add curves to the start of the CurveLoop. bool canRepairFirst = (curveSegments[0] is Line); for (int ii = 1; ii < numSegments; ii++) { XYZ nextStartPoint = curveSegments[ii].GetEndPoint(0); XYZ nextEndPoint = curveSegments[ii].GetEndPoint(1); // These will be set below. bool attachNextSegmentToEnd = false; bool reverseNextSegment = false; double minGap = 0.0; // Scoped to prevent distLoopEndPtToNextStartPt and others from being used later on. { // Find the minimum gap between the current curve segment and the existing curve loop. If it is too large, we will give up. double distLoopEndPtToNextStartPt = curveLoopEndPoint.DistanceTo(nextStartPoint); double distLoopEndPtToNextEndPt = curveLoopEndPoint.DistanceTo(nextEndPoint); double distLoopStartPtToNextEndPt = curveLoopStartPoint.DistanceTo(nextEndPoint); double distLoopStartPtToNextStartPt = curveLoopStartPoint.DistanceTo(nextStartPoint); // Determine the minimum gap between the two curves. If it is too large, we'll give up before trying anything. double minStartGap = Math.Min(distLoopStartPtToNextEndPt, distLoopStartPtToNextStartPt); double minEndGap = Math.Min(distLoopEndPtToNextStartPt, distLoopEndPtToNextEndPt); minGap = Math.Min(minStartGap, minEndGap); // If the minimum distance between the two curves is greater than gapVertexEps (which is the larger of our two tolerances), // we can't fix the issue. if (minGap > gapVertexEps) { string lengthAsString = UnitFormatUtils.Format(IFCImportFile.TheFile.Document.GetUnits(), UnitType.UT_Length, minGap, true, false); string maxGapAsString = UnitFormatUtils.Format(IFCImportFile.TheFile.Document.GetUnits(), UnitType.UT_Length, gapVertexEps, true, false); throw new InvalidOperationException("IfcCompositeCurve contains a gap of " + lengthAsString + " that is greater than the maximum gap size of " + maxGapAsString + " and cannot be repaired."); } // We have a possibility to add the segment. What we do depends on the gap distance. // If the current curve loop's closest end to the next segment is its end (vs. start) point, set attachNextSegmentToEnd to true. attachNextSegmentToEnd = (MathUtil.IsAlmostEqual(distLoopEndPtToNextStartPt, minGap)) || (MathUtil.IsAlmostEqual(distLoopEndPtToNextEndPt, minGap)); // We need to reverse the next segment if: // 1. We are attaching the next segment to the end of the curve loop, and the next segment's closest end to the current curve loop is its end (vs. start) point. // 2. We are attaching the next segment to the start of the curve loop, and the next segment's closest end to the current curve loop is its start (vs. end) point. reverseNextSegment = (MathUtil.IsAlmostEqual(distLoopEndPtToNextEndPt, minGap)) || (MathUtil.IsAlmostEqual(distLoopStartPtToNextStartPt, minGap)); } if (reverseNextSegment) { curveSegments[ii] = curveSegments[ii].CreateReversed(); MathUtil.Swap <XYZ>(ref nextStartPoint, ref nextEndPoint); } // If minGap is less than vertexEps, we won't need to do any repairing - just fix the orientation if necessary. if (minGap < vertexEps) { if (attachNextSegmentToEnd) { // Update the curve loop end point to be the end point of the next segment after potentially being reversed. curveLoopEndPoint = nextEndPoint; } else { canRepairFirst = curveSegments[ii] is Line; curveLoopStartPoint = nextStartPoint; // Update the curve loop start point to be the start point of the next segment, now at the beginning of the loop, // after potentially being reversed. Curve tmpCurve = curveSegments[ii]; curveSegments.RemoveAt(ii); curveSegments.Insert(0, tmpCurve); } continue; } // The gap is too big for CurveLoop, but smaller than our maximum tolerance - we will try to fix the gap by extending // one of the line segments around the gap. If the gap is between two Arcs, we will try to introduce a short // segment between them, as long as the gap is larger than the short curve tolerance. bool canRepairNext = curveSegments[ii] is Line; bool createdRepairLine = false; if (attachNextSegmentToEnd) { // Update the curve loop end point to be the end point of the next segment after potentially being reversed. XYZ originalCurveLoopEndPoint = curveLoopEndPoint; curveLoopEndPoint = nextEndPoint; if (canRepairNext) { curveSegments[ii] = RepairLineAndReport(Id, originalCurveLoopEndPoint, curveLoopEndPoint, minGap); } else if (curveSegments[ii - 1] is Line) // = canRepairCurrent, only used here. { curveSegments[ii - 1] = RepairLineAndReport(Id, curveSegments[ii - 1].GetEndPoint(0), curveSegments[ii].GetEndPoint(0), minGap); } else { // Can't add a line to fix a gap that is smaller than the short curve tolerance. // In the future, we may fix this gap by intersecting the two curves and extending one of them. if (minGap < shortCurveTol + MathUtil.Eps()) { Importer.TheLog.LogError(Id, "IfcCompositeCurve contains a gap between two non-linear segments that is too short to be repaired by a connecting segment.", true); } try { Line repairLine = Line.CreateBound(originalCurveLoopEndPoint, curveSegments[ii].GetEndPoint(0)); curveSegments.Insert(ii, repairLine); ii++; // Skip the repair line as we've already "added" it and the non-linear segment to our growing loop. numSegments++; createdRepairLine = true; } catch { Importer.TheLog.LogError(Id, "IfcCompositeCurve contains a gap between two non-linear segments that can't be fixed.", true); } } } else { XYZ originalCurveLoopStartPoint = curveLoopStartPoint; curveLoopStartPoint = nextStartPoint; if (canRepairNext) { curveSegments[ii] = RepairLineAndReport(Id, curveLoopStartPoint, originalCurveLoopStartPoint, minGap); } else if (canRepairFirst) { curveSegments[0] = RepairLineAndReport(Id, curveSegments[ii].GetEndPoint(1), curveSegments[0].GetEndPoint(1), minGap); } else { // Can't add a line to fix a gap that is smaller than the short curve tolerance. // In the future, we may fix this gap by intersecting the two curves and extending one of them. if (minGap < shortCurveTol + MathUtil.Eps()) { Importer.TheLog.LogError(Id, "IfcCompositeCurve contains a gap between two non-linear segments that is too short to be repaired by a connecting segment.", true); } Line repairLine = Line.CreateBound(curveSegments[ii].GetEndPoint(1), originalCurveLoopStartPoint); curveSegments.Insert(0, repairLine); ii++; // Skip the repair line as we've already "added" it and the non-linear curve to our growing loop. numSegments++; } // Either canRepairFirst was already true, or canRepairNext was true and we added it to the front of the loop, // or we added a short repair line to the front of the loop. In any of these cases, the front curve segement of the // loop is now a line segment. if (!canRepairFirst && !canRepairNext && !createdRepairLine) { Importer.TheLog.LogError(Id, "IfcCompositeCurve contains a gap between two non-linear segments that can't be fixed.", true); } canRepairFirst = true; // Move the curve to the front of the loop. Curve tmpCurve = curveSegments[ii]; curveSegments.RemoveAt(ii); curveSegments.Insert(0, tmpCurve); } } if (CurveLoop == null) { CurveLoop = new CurveLoop(); } foreach (Curve curveSegment in curveSegments) { if (curveSegment != null) { CurveLoop.Append(curveSegment); } } } catch (Exception ex) { Importer.TheLog.LogError(Id, ex.Message, true); } // Try to create the curve representation of this IfcCompositeCurve Curve = ConvertCurveLoopIntoSingleCurve(CurveLoop); }
/// <summary> /// /// </summary> /// <param name="doc"></param> /// <param name="stylesId"></param> public void PublishData(Document doc, string stylesId) { try { _doc = doc; #region Text Note Type stats var textTypes = new FilteredElementCollector(doc) .OfClass(typeof(TextNoteType)) .ToDictionary(x => x.Id.IntegerValue, x => new Tuple <Element, int>(x, 0)); var textInstances = new FilteredElementCollector(doc) .OfClass(typeof(TextNote)) .WhereElementIsNotElementType(); foreach (var t in textInstances) { var key = t.GetTypeId().IntegerValue; if (textTypes.ContainsKey(key)) { // increment instance count textTypes[key] = new Tuple <Element, int>(textTypes[key].Item1, textTypes[key].Item2 + 1); } } var textStats = textTypes.Select(x => new TextNoteTypeInfo(x.Value.Item1) { Instances = x.Value.Item2 }) .ToList(); #endregion #region Dimension Type stats var dimTypes = new FilteredElementCollector(doc) .OfClass(typeof(DimensionType)) .Cast <DimensionType>() .Where(x => !string.IsNullOrEmpty(x.get_Parameter(BuiltInParameter.SYMBOL_NAME_PARAM).AsString())) .ToDictionary(x => x.Id.IntegerValue, x => new Tuple <DimensionType, int>(x, 0)); var dimInstances = new FilteredElementCollector(doc) .OfClass(typeof(Dimension)) .WhereElementIsNotElementType() .Cast <Dimension>(); // (Konrad) There is a user override in Configuration that controls what dimension overrides are ignored var centralPath = FileInfoUtil.GetCentralFilePath(doc); var config = MissionControlSetup.Configurations.ContainsKey(centralPath) ? MissionControlSetup.Configurations[centralPath] : null; var dimensionValueCheck = new List <string> { "EQ" }; //defaults if (config != null) { dimensionValueCheck = config.Updaters.First(x => string.Equals(x.UpdaterId, Properties.Resources.HealthReportTrackerGuid, StringComparison.OrdinalIgnoreCase)).UserOverrides.DimensionValueCheck.Values; } var units = _doc.GetUnits(); var dimSegmentStats = new List <DimensionSegmentInfo>(); foreach (var d in dimInstances) { var key = d.GetTypeId().IntegerValue; if (dimTypes.ContainsKey(key)) { // increment instance count dimTypes[key] = new Tuple <DimensionType, int>(dimTypes[key].Item1, dimTypes[key].Item2 + 1); } if (d.NumberOfSegments == 0) { if (string.IsNullOrEmpty(d.ValueOverride)) { continue; } if (dimensionValueCheck.Any(d.ValueOverride.Contains)) { continue; } // dim w/ zero segments dimSegmentStats.Add(new DimensionSegmentInfo(d) { #if RELEASE2021 ValueString = UnitFormatUtils.Format(units, d.DimensionType.GetSpecTypeId(), (double)d.Value, false), #else ValueString = UnitFormatUtils.Format(units, d.DimensionType.UnitType, (double)d.Value, false, false), #endif OwnerViewType = d.ViewSpecific ? ((View)doc.GetElement(d.OwnerViewId)).ViewType.ToString() : string.Empty, OwnerViewId = d.OwnerViewId.IntegerValue }); } else { // dim w/ multiple segments foreach (DimensionSegment s in d.Segments) { if (string.IsNullOrEmpty(s.ValueOverride)) { continue; } if (dimensionValueCheck.Any(s.ValueOverride.Contains)) { continue; } dimSegmentStats.Add(new DimensionSegmentInfo(s) { #if RELEASE2021 ValueString = UnitFormatUtils.Format(units, d.DimensionType.GetSpecTypeId(), (double)d.Value, false), #else ValueString = UnitFormatUtils.Format(units, d.DimensionType.UnitType, (double)d.Value, false, false), #endif OwnerViewType = d.ViewSpecific ? ((View)doc.GetElement(d.OwnerViewId)).ViewType.ToString() : string.Empty, OwnerViewId = d.OwnerViewId.IntegerValue }); } } } var dimStats = dimTypes.Select(x => new DimensionTypeInfo(x.Value.Item1) { Instances = x.Value.Item2 }) .ToList(); #endregion #region Line Style stats //TODO: Finish this out. #endregion var stylesStats = new StylesDataItem { User = Environment.UserName.ToLower(), TextStats = textStats, DimStats = dimStats, DimSegmentStats = dimSegmentStats }; if (!ServerUtilities.Post(stylesStats, "styles/" + stylesId + "/stylestats", out StylesDataItem unused)) { Log.AppendLog(LogMessageType.ERROR, "Failed to publish Styles Data."); } } catch (Exception e) { Log.AppendLog(LogMessageType.EXCEPTION, e.Message); } }
/// <summary> /// Formats a station value to a string, using the stationing settings in the document. /// </summary> /// <param name="station">The station value.</param> /// <param name="doc">The document for which to format the value.</param> /// <returns></returns> private string GetStationFormattedValue(double station, Document doc) { FormatOptions options = doc.GetUnits().GetFormatOptions(SpecTypeId.Stationing); return(UnitFormatUtils.Format(doc.GetUnits(), SpecTypeId.Stationing, station, false)); }