C# Geometry.BoundingBox类代码示例

 /// <summary>
 /// Extends a plane into a plane surface so that the latter goes through a bounding box.
 /// </summary>
 /// <param name="plane">An original plane value.</param>
 /// <param name="box">A box to use for extension boundary.</param>
 /// <returns>A new plane surface on success, or null on error.</returns>
 /// <example>
 /// <code source='examples\vbnet\ex_splitbrepwithplane.vb' lang='vbnet'/>
 /// <code source='examples\cs\ex_splitbrepwithplane.cs' lang='cs'/>
 /// <code source='examples\py\ex_splitbrepwithplane.py' lang='py'/>
 /// </example>
 public static PlaneSurface CreateThroughBox(Plane plane, BoundingBox box)
 {
   IntPtr ptr = UnsafeNativeMethods.RHC_RhinoPlaneThroughBox2(ref plane, ref box);
   if (IntPtr.Zero == ptr)
     return null;
   return new PlaneSurface(ptr, null);
 }

 /// <summary>
 /// Initializes a new Box that mimics a BoundingBox struct. 
 /// <para>The orientation plane of the Box is coincident with the 
 /// World XY plane.</para>
 /// </summary>
 /// <param name="bbox">BoundingBox to mimic.</param>
 public Box(BoundingBox bbox)
 {
   m_plane = Plane.WorldXY;
   m_dx = new Interval(bbox.m_min.m_x, bbox.m_max.m_x);
   m_dy = new Interval(bbox.m_min.m_y, bbox.m_max.m_y);
   m_dz = new Interval(bbox.m_min.m_z, bbox.m_max.m_z);
 }

 public DisplayElementSectionsComponent()
     : base("DisplayElementSectionsComponent", "DES", "Displays the element sections", "CIFem", "Results")
 {
     _bb = new BoundingBox();
     _secCrvs = new List<Curve>();
     _breps = new List<Brep>();
 }

        static SelectionScreen()
        {
            _transformMouseDown = Transform.Translation(Vector3d.ZAxis * -1);
            _transformMouseOver = Transform.Translation(Vector3d.ZAxis * 1);

            var menuTitle = new SelectableObject(ElementType.Drawable);
            menuTitle.AddGeoemtry(Serialized.Meshes.Menu.TitleBigBackground, Settings.MaterialOrange);
            menuTitle.AddGeoemtry(Serialized.Meshes.Menu.TitleBigBorder, Settings.MaterialRed);
            menuTitle.AddGeoemtry(Serialized.Meshes.Menu.TitleBigLetters, Settings.MaterialYellow);

            var menuOptions = new SelectableObject(ElementType.MenuOptions);
            menuOptions.AddGeoemtry(Serialized.Meshes.Menu.OptionsBackground, Settings.MaterialOrange);
            menuOptions.AddGeoemtry(Serialized.Meshes.Menu.OptionsBorder, Settings.MaterialRed);
            menuOptions.AddGeoemtry(Serialized.Meshes.Menu.OptionsLetters, Settings.MaterialYellow);

            var menuStart = new SelectableObject(ElementType.MenuStart);
            menuStart.AddGeoemtry(Serialized.Meshes.Menu.StartBacbground, Settings.MaterialOrange);
            menuStart.AddGeoemtry(Serialized.Meshes.Menu.StartBorder, Settings.MaterialRed);
            menuStart.AddGeoemtry(Serialized.Meshes.Menu.StartLetters, Settings.MaterialYellow);

            var menuExit = new SelectableObject(ElementType.MenuExit);
            menuExit.AddGeoemtry(Serialized.Meshes.Menu.ExitBacground, Settings.MaterialOrange);
            menuExit.AddGeoemtry(Serialized.Meshes.Menu.ExitBorder, Settings.MaterialRed);
            menuExit.AddGeoemtry(Serialized.Meshes.Menu.ExitLetters, Settings.MaterialYellow);

            _menuObjects = new[] { menuTitle, menuOptions, menuStart, menuExit };

            _mouseController = new MouseController(new[] { menuOptions, menuStart, menuExit });
            _mouseController.OnChange += _mouseController_OnChange;
            _mouseController.OnMouseClick += _mouseController_OnMouseClick;
            _mouseController.OnMouseRelease += _mouseController_OnMouseRelease;

            _box = new BoundingBox(-400, -400, -100, 400, 400, 100);
        }

 public DisplayThickVectors()
     : base("VectorDisplay", "VDisp", "Displays a vector with set thickness", "CIFem", "Utilities")
 {
     //_vectors = new List<Vector3d>();
     _vectors = new List<DisplayVector>();
     _bounds = BoundingBox.Unset;
 }

 private static bool CheckBoxInOther(BoundingBox box1, BoundingBox box2)
 {
     return
         CheckIntervals(box1.Min.X, box2.Min.X, box2.Max.X) ||
         CheckIntervals(box1.Max.X, box2.Min.X, box2.Max.X) ||
         CheckIntervals(box1.Min.Y, box2.Min.Y, box2.Max.Y) ||
         CheckIntervals(box1.Max.Y, box2.Min.Y, box2.Max.Y);
 }

 public DrawBlueMeshConduit(Mesh mesh)
 {
   // set up as much data as possible so we do the minimum amount of work possible inside
   // the actual display code
   m_mesh = mesh;
   m_color = System.Drawing.Color.Blue;
   m_material = new DisplayMaterial();
   m_material.Diffuse = m_color;
   if (m_mesh != null && m_mesh.IsValid)
     m_bbox = m_mesh.GetBoundingBox(true);
 }

 public DisplayResultElementsComponent()
     : base("DisplayElementResults", "ER", "Displays the element results", "CIFem", "Results")
 {
     _bb = new BoundingBox();
     _bbPts = new List<Point3d>();
     _dispCrvN = new List<Curve>();
     _dispCrvVy = new List<Curve>();
     _dispCrvVz = new List<Curve>();
     _dispCrvT = new List<Curve>();
     _dispCrvMyy = new List<Curve>();
     _dispCrvMzz = new List<Curve>();
 }

 void DisplayPipeline_CalculateBoundingBox(object sender, Rhino.Display.CalculateBoundingBoxEventArgs e)
 {
   if (m_draw_single_sprite)
   {
     BoundingBox bbox = new BoundingBox(new Point3d(20, 0, 0), new Point3d(20, 0, 0));
     e.IncludeBoundingBox(bbox);
   }
   else
   {
     var items = GetItems();
     e.IncludeBoundingBox(items.BoundingBox);
   }
 }

 public static Rhino.Commands.Result AddBrepBox(Rhino.RhinoDoc doc)
 {
   Rhino.Geometry.Point3d pt0 = new Rhino.Geometry.Point3d(0, 0, 0);
   Rhino.Geometry.Point3d pt1 = new Rhino.Geometry.Point3d(10, 10, 10);
   Rhino.Geometry.BoundingBox box = new Rhino.Geometry.BoundingBox(pt0, pt1);
   Rhino.Geometry.Brep brep = box.ToBrep();
   Rhino.Commands.Result rc = Rhino.Commands.Result.Failure;
   if( doc.Objects.AddBrep(brep) != System.Guid.Empty )
   {
     rc = Rhino.Commands.Result.Success;
     doc.Views.Redraw();
   }
   return rc;
 }

 public BoundingBox GetCameraExtents(System.Collections.Generic.IEnumerable<Point3d> points)
 {
   Rhino.Collections.Point3dList _points = new Collections.Point3dList(points);
   IntPtr pConstThis = ConstPointer();
   IntPtr pConstViewport = UnsafeNativeMethods.CRhinoViewport_VP(pConstThis);
   BoundingBox bbox = new BoundingBox();
   UnsafeNativeMethods.ON_Viewport_GetCameraExtents(pConstViewport, _points.Count, _points.m_items, ref bbox);
   return bbox;
 }

 /// <summary>
 /// Zooms the viewport to the given bounding box.
 /// </summary>
 /// <param name="box">The bouding box to zoom.</param>
 /// <returns>true if operation succeeded; otherwise false.</returns>
 public bool ZoomBoundingBox(BoundingBox box)
 {
   IntPtr pThis = NonConstPointer();
   return UnsafeNativeMethods.RHC_RhZoomExtentsHelper(pThis, box.m_min, box.m_max);
 }

 /// <summary>
 /// Returns true if some portion of a world coordinate bounding box is
 /// potentially visible in the viewing frustum.
 /// </summary>
 /// <param name="bbox">A bounding box that is tested for visibility.</param>
 /// <returns>true if the box is potentially visible; otherwise false.</returns>
 public bool IsVisible(BoundingBox bbox)
 {
   IntPtr ptr = NonConstPointer();
   return UnsafeNativeMethods.CRhinoViewport_IsVisible(ptr, bbox.Min, bbox.Max, true);
 }

 /// <summary>
 /// Sets optimal clipping planes to view objects in a world coordinate 3d bounding box.
 /// </summary>
 /// <param name="box">The bounding box </param>
 public void SetClippingPlanes(BoundingBox box)
 {
   IntPtr pThis = NonConstPointer();
   UnsafeNativeMethods.CRhinoViewport_SetClippingPlanes(pThis, box.Min, box.Max);
 }

        public BoundingBox bboxAll(List<Brep> things)
        {
            //Find the bounding box of a list of objects
            BoundingBox bbox;
            Point3d maxPt = new Point3d(0, 0, 0);
            Point3d minPt = new Point3d(0, 0, 0);

            foreach (Brep thing in things)
            {
                BoundingBox b_box = thing.GetBoundingBox(Plane.WorldXY);

                if (b_box.Max.X > maxPt.X && b_box.Max.Y > maxPt.Y && b_box.Max.Z > maxPt.Z)
                {
                    maxPt = b_box.Max;
                }
                if (b_box.Min.X < minPt.X && b_box.Min.Y < minPt.Y && b_box.Min.Z < minPt.Z)
                {
                    minPt = b_box.Min;
                }

            }

            bbox = new BoundingBox(minPt, maxPt);
            return bbox;
        }