/// <summary> /// This is the method that actually does the work. /// </summary> /// <param name="DA">The DA object is used to retrieve from inputs and store in outputs.</param> protected override void SolveInstance(IGH_DataAccess DA) { GeometryBase Geom = default(GeometryBase); string InfoKey = default(string); //特别注意 dynamic InfoValue = default(dynamic); if (!DA.GetData(0, ref Geom)) { return; } if (!DA.GetData(1, ref InfoKey)) { return; } if (!DA.GetData(2, ref InfoValue)) { return; } //这句代码至关重要 GeometryBase TempGeom = Geom.Duplicate(); if ((TempGeom is Rhino.Geometry.Point)) { this.AddRuntimeMessage(GH_RuntimeMessageLevel.Warning, "目前尚不支持Point的户自定义数据写入"); return; } TempGeom.UserDictionary.Set(InfoKey, InfoValue.Value); DA.SetData(0, TempGeom); }
/// <summary> /// Computes the distance of a point to a given geometry. (Brep, Mesh or closed Surface) /// </summary> public static double DistanceTo(GeometryBase geometry, Point3d testPoint, int spaceType) { double distanceTo = 0; Point3d closestPoint; switch (spaceType) { // Brep design space case 1: closestPoint = ((Brep)geometry).ClosestPoint(testPoint); distanceTo = testPoint.DistanceTo(closestPoint); break; // Mesh design space case 2: closestPoint = ((Mesh)geometry).ClosestPoint(testPoint); distanceTo = testPoint.DistanceTo(closestPoint); break; // Solid surface design space (must be converted to brep) case 3: closestPoint = ((Surface)geometry).ToBrep().ClosestPoint(testPoint); distanceTo = testPoint.DistanceTo(closestPoint); break; } return(distanceTo); }
/// <summary> /// This is the method that actually does the work. /// </summary> /// <param name="DA">The DA object is used to retrieve from inputs and store in outputs.</param> protected override void SolveInstance(IGH_DataAccess DA) { IGH_GeometricGoo shape = null; if (!DA.GetData <IGH_GeometricGoo>(0, ref shape)) { return; } GeometryBase geo = null; if (shape is Mesh || shape is GH_Mesh || shape is Brep || shape is GH_Brep || shape is Surface || shape is GH_Surface || shape is Curve || shape is GH_Curve || shape is GH_Box || shape is GH_Line) { geo = GH_Convert.ToGeometryBase(shape); } else { return; } var bbox = geo.GetBoundingBox(true); DA.SetData(0, bbox.Center); }
public static Brep ReadHouseGeometry(string houseType) { string fileName = ReadResourceFile("Engine.Resources." + houseType + ".txt"); GeometryBase geometry = GH_Convert.ByteArrayToCommonObject <GeometryBase>(System.Convert.FromBase64String(fileName)); return(geometry as Brep); }
/// <summary> /// This is the method that actually does the work. /// </summary> /// <param name="DA">The DA object is used to retrieve from inputs and store in outputs.</param> protected override void SolveInstance(IGH_DataAccess DA) { GeometryBase Geometry = null; double XSpan = 0.2; double YSpan = 0.2; double ZSpan = 0.2; double DXSpan = 0.2; double DYSpan = 0.2; double Angle = 45.0; double minSpan = 0.0001; if (!DA.GetData(0, ref Geometry)) { return; } DA.GetData(1, ref XSpan); DA.GetData(2, ref YSpan); DA.GetData(3, ref ZSpan); DA.GetData(4, ref DXSpan); DA.GetData(5, ref DYSpan); DA.GetData(6, ref Angle); if (XSpan < minSpan) { XSpan = minSpan; } if (YSpan < minSpan) { YSpan = minSpan; } if (ZSpan < minSpan) { ZSpan = minSpan; } if (DXSpan < minSpan) { DXSpan = minSpan; } if (DXSpan < minSpan) { DXSpan = minSpan; } List <List <Plane> > Frames = V2GRhinoGeometry.BoundingFrames( Geometry, XSpan, YSpan, ZSpan, DXSpan, DYSpan, Angle// Optional ); DA.SetDataList(0, Frames[0]); DA.SetDataList(1, Frames[1]); DA.SetDataList(2, Frames[2]); DA.SetDataList(3, Frames[3]); DA.SetDataList(4, Frames[4]); DA.SetDataList(5, Frames); }
/// <summary> /// This is the method that actually does the work. /// </summary> /// <param name="DA">The DA object is used to retrieve from inputs and store in outputs.</param> protected override void SolveInstance(IGH_DataAccess DA) { object obj2 = null; DA.GetData(0, ref obj2); if (obj2 == null) { AddRuntimeMessage(GH_RuntimeMessageLevel.Warning, "Failed to get object"); return; } var theValue = obj2.GetType().GetProperty("Value").GetValue(obj2, null); GeometryBase geometry = null; geometry = theValue as GeometryBase; if (geometry == null) { DA.SetData(0, null); this.AddRuntimeMessage(GH_RuntimeMessageLevel.Error, "Input object not supported."); return; } if (geometry.UserDictionary == null) { AddRuntimeMessage(GH_RuntimeMessageLevel.Warning, "Object has no user dictionary."); DA.SetData(0, null); return; } DA.SetData(0, geometry.UserDictionary); }
public static DB.GeometryObject[] ToShape(this GeometryBase geometry, double factor) { switch (geometry) { case Point point: return(new DB.Point[] { point.ToPoint(factor) }); case PointCloud pointCloud: return(pointCloud.ToPoints(factor)); case Curve curve: return(curve.ToCurveMany(factor).SelectMany(x => x.ToBoundedCurves()).ToArray()); case Brep brep: return(new DB.GeometryObject[] { ToShape(brep, factor) }); case Extrusion extrusion: return(new DB.GeometryObject[] { ToShape(extrusion, factor) }); case SubD subD: return(new DB.GeometryObject[] { ToShape(subD, factor) }); case Mesh mesh: return(new DB.GeometryObject[] { MeshEncoder.ToMesh(MeshEncoder.ToRawMesh(mesh, factor)) }); default: if (geometry.HasBrepForm) { var brepForm = Brep.TryConvertBrep(geometry); return(new DB.GeometryObject[] { ToShape(brepForm, factor) }); } return(new DB.GeometryObject[0]); } }
public new static FaceEntity TryGetFrom(GeometryBase rhinoGeo) { var rc = new FaceEntity(); if (!rhinoGeo.IsValid) { return(rc); } if (rhinoGeo is BrepFace brepFace) { //var ent = brepFace.Brep.Surfaces[brepFace.SurfaceIndex].UserData.Find(typeof(FaceEntity)) as FaceEntity; var ent = brepFace.UnderlyingSurface().TryGetFaceEntity(); return(ent == null ? rc : ent); } else if (rhinoGeo is Surface surface) { var ent = surface.UserData.Find(typeof(FaceEntity)) as FaceEntity; return(ent == null ? rc : ent); } else { var ent = (rhinoGeo as Rhino.Geometry.Brep).Surfaces[0].UserData.Find(typeof(FaceEntity)) as FaceEntity; return(ent == null ? rc : ent); } }
public virtual bool Regen() { if (geometry != null) { if (!BeginRegen()) { return(false); } if (geometry.IsValid) { if (geometry is Mesh mesh) { vertexBuffer = ToVertexBuffer(mesh, part, out vertexFormatBits); vertexCount = part.VertexCount; triangleBuffer = ToTrianglesBuffer(mesh, part, out triangleCount); linesBuffer = ToEdgeBuffer(mesh, part, out linesCount); } else if (geometry is Curve curve) { using (var polyline = curve.ToPolyline(Revit.ShortCurveTolerance * Revit.ModelUnits, Revit.AngleTolerance * 100.0, Revit.ShortCurveTolerance * Revit.ModelUnits, 0.0)) { var pline = polyline.ToPolyline(); // Reduce too complex polylines. { var tol = Revit.VertexTolerance * Revit.ModelUnits; while (pline.Count > 0x4000) { tol *= 2.0; if (pline.ReduceSegments(tol) == 0) { break; } } } linesCount = ToPolylineBuffer(pline, out vertexFormatBits, out vertexBuffer, out vertexCount, out linesBuffer); } } else if (geometry is Point point) { linesCount = -ToPointsBuffer(point, out vertexFormatBits, out vertexBuffer, out vertexCount, out linesBuffer); } else if (geometry is PointCloud pointCloud) { linesCount = -ToPointsBuffer(pointCloud, part, out vertexFormatBits, out vertexBuffer, out vertexCount, out linesBuffer); } vertexFormat = new DB3D.VertexFormat(vertexFormatBits); } geometry = null; EndRegen(); } return(true); }
public static RhinoGeometryContainer ReadRhino(string path) { RhinoGeometryContainer geoContainer = new RhinoGeometryContainer(); try { File3dm rhinoFile = File3dm.Read(path); geoContainer.FilePath = path; File3dmObjectTable objects = rhinoFile.Objects; foreach (File3dmObject fileObj in objects) { Guid objId = fileObj.Attributes.ObjectId; string name = fileObj.Name; GeometryBase geometry = fileObj.Geometry; RhinoObjectInfo objInfo = new RhinoObjectInfo(objId, name, geometry); CollectGeometryInfo(objInfo, ref geoContainer); } } catch (Exception ex) { string message = ex.Message; } return(geoContainer); }
private static bool _changeInstanceDefinitionGeometryLayer(InstanceDefinition definition, RhinoDoc doc, Layer layer) { if (!doc.Layers.Contains(layer)) { RhinoApp.WriteLine($"No Layer {layer} in document!"); return(false); } var rhObjects = definition.GetObjects(); var geometries = new GeometryBase[rhObjects.Length]; var attributes = new ObjectAttributes[rhObjects.Length]; for (int i = 0; i < rhObjects.Length; i++) { geometries[i] = rhObjects[i].Geometry; attributes[i] = rhObjects[i].Attributes; attributes[i].LayerIndex = layer.Index; } var serial = doc.BeginUndoRecord("Change Block geometry layer"); var success = doc.InstanceDefinitions.ModifyGeometry(definition.Index, geometries, attributes); doc.EndUndoRecord(serial); return(success); }
public static bool ExportNestedBlock(NestedBlock nested, string filePath) { var doc = new File3dm(); // Add all instance definitions foreach (var references in nested.GetRootTreeByRootDepth().Reverse()) { var nameIndexDict = new Dictionary <string, int>(); foreach (var referencedBlock in references) { if (!nameIndexDict.ContainsKey(referencedBlock.Definition.Name)) { var objs = referencedBlock.Definition.GetObjects(); var geos = new GeometryBase[objs.Length]; var attrs = new ObjectAttributes[objs.Length]; for (int i = 0; i < objs.Length; i++) { geos[i] = objs[i].Geometry; attrs[i] = objs[i].Attributes; } var index = doc.AllInstanceDefinitions.Add(referencedBlock.Definition.Name, nested.Definition.Description, Point3d.Origin, geos, attrs); nameIndexDict.Add(referencedBlock.Definition.Name, index); } doc.Objects.AddInstanceObject(nameIndexDict[referencedBlock.Definition.Name], referencedBlock.BlockInsertionParameters.InstanceXform); } } return(doc.Write(filePath, RhinoApp.ExeVersion)); }
/// <summary> /// Returns the total route lenght. -1 if error. /// </summary> /// <returns></returns> public static double TotalRouteLength() { string layername = "Heating Network"; // Get all of the objects on the layer. If layername is bogus, you will // just get an empty list back Rhino.DocObjects.RhinoObject[] rhobjs = RhinoDoc.ActiveDoc.Objects.FindByLayer(layername).Where(x => x.ObjectType == Rhino.DocObjects.ObjectType.Curve).ToArray(); if (rhobjs == null || rhobjs.Length < 1) { return(-1); } var curves = new Curve[rhobjs.Length]; for (int i = 0; i < rhobjs.Length; i++) { GeometryBase geom = rhobjs[i].Geometry; Curve x = geom as Curve; if (x != null && x.IsValid) { curves[i] = x; } } double lenght = curves.Sum(x => x.GetLength()); return(lenght); }
/// <summary> /// Replace a geometry object in the active Rhino document /// </summary> /// <param name="objID"></param> /// <param name="geometry"></param> /// <returns></returns> public static bool Replace(Guid objID, GeometryBase geometry) { bool result = false; Writing = true; if (geometry == null) { result = false; } else if (geometry is RC.Curve) { result = RhinoDoc.ActiveDoc.Objects.Replace(objID, (RC.Curve)geometry); } else if (geometry is RC.Mesh) { result = RhinoDoc.ActiveDoc.Objects.Replace(objID, (RC.Mesh)geometry); } else if (geometry is RC.Brep) { result = RhinoDoc.ActiveDoc.Objects.Replace(objID, (RC.Brep)geometry); } else if (geometry is RC.Surface) { result = RhinoDoc.ActiveDoc.Objects.Replace(objID, (RC.Curve)geometry); } Writing = false; return(result); }
/// <summary> /// Creates an object that inherits from GeometryBase from an array of bytes. /// </summary> private static GeometryBase ToGeometryBase(byte[] bytes) { if (null == bytes || 0 == bytes.Length) { return(null); } GeometryBase rc = null; try { using (var stream = new MemoryStream()) { var formatter = new BinaryFormatter(); stream.Write(bytes, 0, bytes.Length); stream.Seek(0, SeekOrigin.Begin); var geometry = formatter.Deserialize(stream) as GeometryBase; if (null != geometry && geometry.IsValid) { rc = geometry; } } } catch (Exception e) { Debug.WriteLine(e.Message); } return(rc); }
public void AddGeometry(GeometryBase Geometry) { if (_geometries != null) { _geometries.Add(Geometry); } }
private void AddPath(IContainerElement container, GeometryBase geometry) { #region radpdfprocessing-model-path_1 Path path = container.Content.AddPath(); path.Geometry = geometry; #endregion }
/// <summary> /// Checks geometry to see if it can be selected. /// Override to provide fancy filtering. /// </summary> /// <param name="rhObject">parent object being considered.</param> /// <param name="geometry">geometry being considered.</param> /// <param name="componentIndex"> /// if >= 0, geometry is a proper sub-part of object->Geometry() with componentIndex. /// </param> /// <returns> /// The default returns true unless you've set a custom geometry filter. If a custom /// filter has been set, that delegate is called. /// </returns> /// <remarks>The delegate should not throw exceptions. If an exception is thrown, a message box will show and /// the filter will be disabled.</remarks> public virtual bool CustomGeometryFilter(RhinoObject rhObject, GeometryBase geometry, ComponentIndex componentIndex) { if (m_filter != null) { try { return(m_filter(rhObject, geometry, componentIndex)); } catch (Exception ex) { System.Windows.Forms.MessageBox.Show( "The CustomGeometryFilter() function threw an uncaught exception. It will be disabled." + "Details: \n\n" + $"Type: {ex.GetType().FullName} \n" + $"Message: {ex.Message} \n" + $"StackTrace: \n{ex.StackTrace}" , "CustomGeometryFilter exception boundary"); //we need to stop the exception from repeating. m_filter = null; } } return(true); }
//////////////////////////////////////////////////////////////////////////////////// ///Need to Clean up here............................................................ //////////////////////////////////////////////////////////////////////////////////// public T EnsureUnit_test <T>(object rhGeo) { GeometryBase geo = rhGeo as GeometryBase; if (targetUnit == baseUnit) { return((T)Convert.ChangeType(geo, typeof(T))); } else { if (baseUnit == "Meters" && targetUnit == "Feet") { geo.Transform(Transform.Scale(Point3d.Origin, 3.280841666667)); return((T)Convert.ChangeType(rhGeo, typeof(T))); } else if (baseUnit == "Feet" && targetUnit == "Meters") { geo.Transform(Transform.Scale(Point3d.Origin, 0.304800164592)); return((T)Convert.ChangeType(rhGeo, typeof(T))); } else { return(default(T)); } } }
/// <summary> /// Converts an object that inherits from GeometryBase to an array of bytes. /// </summary> private static byte[] ToBytes(GeometryBase src) { var rc = new byte[0]; if (null == src) { return(rc); } try { var formatter = new BinaryFormatter(); using (var stream = new MemoryStream()) { formatter.Serialize(stream, src); rc = stream.ToArray(); } } catch (Exception e) { Debug.WriteLine(e.Message); } return(rc); }
static Curve[] Section(Plane plane, GeometryBase geometry, double tolerance) { var rc = new Curve[0]; var brep = geometry as Brep; if (brep != null) { Point3d[] pts; Rhino.Geometry.Intersect.Intersection.BrepPlane(brep, plane, tolerance, out rc, out pts); return(rc); } var mesh = geometry as Mesh; if (mesh != null) { var polylines = Rhino.Geometry.Intersect.Intersection.MeshPlane(mesh, plane); if (polylines != null) { rc = new Curve[polylines.Length]; for (int i = 0; i < polylines.Length; i++) { rc[i] = new PolylineCurve(polylines[i]); } } } return(rc); }
/// <summary> /// This is the method that actually does the work. /// </summary> /// <param name="DA">The DA object is used to retrieve from inputs and store in outputs.</param> protected override void SolveInstance(IGH_DataAccess DA) { GeometryBase Geom = default(GeometryBase); string InfoKey = null; if (!DA.GetData(0, ref Geom)) { return; } if (!DA.GetData(1, ref InfoKey)) { return; } //此处务必对几何体进行拷贝,否则将会影响到前面的几何体 GeometryBase TempGeom = Geom.Duplicate(); try { if (TempGeom.UserDictionary.ContainsKey(InfoKey)) { TempGeom.UserDictionary.Remove(InfoKey); DA.SetData(0, TempGeom); } else { throw new Exception("在几何体中未找到Key值为:" + InfoKey + " 的字段"); } }catch (Exception ex) { this.AddRuntimeMessage(GH_RuntimeMessageLevel.Error, ex.Message); } }
public override bool CustomGeometryFilter(RhinoObject rhObject, GeometryBase geometry, ComponentIndex componentIndex) { if (null == rhObject || null == geometry) { return(false); } if (ComponentIndexType.BrepLoop != componentIndex.ComponentIndexType) { return(false); } var loop = geometry as BrepLoop; if (null == loop) { return(false); } var brep = loop.Brep; if (null == brep) { return(false); } return(IsHoleLoop(brep, loop.LoopIndex, true, false, m_tolerance)); }
private void CreatePath(IContainerElement container, GeometryBase geometry) { #region radpdfprocessing-model-path_0 Path path = new Path(); path.Geometry = geometry; container.Content.Add(path); #endregion }
public void LoadData(GeometryBase geometry) { elementSizeCheckBox.Checked = geometry.GetUserString("Ibra.MaxElementSize") != null; elementSizeTextBox.Text = geometry.GetUserString("Ibra.MaxElementSize"); polynomialDegreeCheckBox.Checked = geometry.GetUserString("Ibra.MinPolynomialDegree") != null; polynomialDegreeTextBox.Text = geometry.GetUserString("Ibra.MinPolynomialDegree"); }
/// <summary> /// Checks geometry to see if it can be selected. /// Override to provide fancy filtering. /// </summary> /// <param name="rhObject">parent object being considered.</param> /// <param name="geometry">geometry being considered.</param> /// <param name="componentIndex"> /// if >= 0, geometry is a proper sub-part of object->Geometry() with componentIndex. /// </param> /// <returns> /// The default returns true unless you've set a custom geometry filter. If a custom /// filter has been set, that delegate is called /// </returns> public virtual bool CustomGeometryFilter(RhinoObject rhObject, GeometryBase geometry, ComponentIndex componentIndex) { if (m_filter != null) { return(m_filter(rhObject, geometry, componentIndex)); } return(true); }
/// <summary> /// This is the method that actually does the work. /// </summary> /// <param name="DA">The DA object is used to retrieve from inputs and store in outputs.</param> protected override void SolveInstance(IGH_DataAccess DA) { GeometryBase Geom = default(GeometryBase); Vector3d Direction = default(Vector3d); bool IsDubleSide = true, IsCape = true; Brep Output = default(Brep); if (!DA.GetData(0, ref Geom)) { return; } if (!DA.GetData(1, ref Direction)) { return; } if (!DA.GetData(2, ref IsDubleSide)) { return; } if (!DA.GetData(3, ref IsCape)) { return; } if (Geom is Curve) { Curve Crv = Geom as Curve; Output = this.ExtrudeCurveBothSide(Crv, Direction, IsDubleSide, IsCape); } else if (Geom is Surface) { Surface Srf = Geom as Surface; // //实现在函数里面书写函数 // // Func <Surface, Curve> CreateBoundary = _Srf => { Brep b = _Srf.ToBrep(); CurveList Crvs = new CurveList(); BrepEdgeList es = b.Edges; foreach (BrepEdge e in es) { Crvs.Add(e.EdgeCurve); } return(Curve.JoinCurves(Crvs)[0]); }; Curve Crv = CreateBoundary(Srf); Output = this.ExtrudeCurveBothSide(Crv, Direction, IsDubleSide, IsCape); } if (Output == null) { this.AddRuntimeMessage(GH_RuntimeMessageLevel.Warning, "输入的几何体不是平面几何体"); } DA.SetData(0, Output); }
//This method creates a bounding box to a geometry in a given plane and returns the min and max coordinates of that box in the plane coordinates. private static Tuple <Point3d, Point3d> getMinAndMax(GeometryBase geometry, Plane plane) { Transform vali = Transform.PlaneToPlane(Plane.WorldXY, plane); BoundingBox box = geometry.GetBoundingBox(plane); Point3d minPoint = box.Min; Point3d maxPoint = box.Max; return(Tuple.Create(minPoint, maxPoint)); }
/// <summary> /// Initializes a new instance of the ObjController class. /// </summary> public ObjController1() : base("Controller1", "Controller1", "Tracking of HTC Vive Controller", "ViveTrack", "Tracking Device") { controller = GH_Convert.ByteArrayToCommonObject <GeometryBase>(System.Convert.FromBase64String(Resources.controller)); CurrenTrackedDevice = new VrTrackedDevice(); //(this as IGH_PreviewObject).Hidden = true; }
/// <summary> /// Initializes a new instance of the ObjHMD class. /// </summary> public ObjHMD() : base("Vive HMD", "HMD", "Tracking of HTC Vive HMD", "ViveTrack", "Tracking Device") { HMD = GH_Convert.ByteArrayToCommonObject <GeometryBase>(System.Convert.FromBase64String(Resources.HMD)); CurrenTrackedDevice = new VrTrackedDevice(); //(this as IGH_PreviewObject).Hidden = true; }