예제 #1
0
        protected override Result RunCommand(RhinoDoc doc, RunMode mode)
        {
            const ObjectType selFilter      = ObjectType.PolysrfFilter | ObjectType.Extrusion;
            bool             value          = false;
            double           preShrinkValue = ZERO_CM;

            OptionToggle shrinkToDimensions = new OptionToggle(value, "Off", "On");
            OptionDouble preShrink          = new OptionDouble(preShrinkValue, 0.0, 1.0);
            ObjRef       boxObjRef          = null;

            GetObject go = new GetObject();

            go.SetCommandPrompt("Select the box to net-ify");
            go.AddOptionToggle("Constrain", ref shrinkToDimensions);
            go.AddOptionDouble("PreShrink", ref preShrink, "Preshrink");
            go.GeometryFilter = selFilter;

            go.EnableClearObjectsOnEntry(true);
            go.EnableUnselectObjectsOnExit(true);

            // TODO: clean up this hot mess
            for (;;)
            {
                GetResult getObjResult = go.Get();
                if (getObjResult == GetResult.Object)
                {
                    boxObjRef = go.Object(0);
                    boxObjRef.Object().Select(on: true, syncHighlight: true);
                    go.EnablePreSelect(false, true);
                    go.AcceptNothing(true);
                    continue;
                }

                else if (getObjResult == GetResult.Cancel)
                {
                    return(Result.Cancel);
                }

                // Case where user presses enter
                else if (getObjResult == GetResult.Nothing)
                {
                    if (boxObjRef != null)
                    {
                        preShrinkValue = preShrink.CurrentValue;
                        if (preShrinkValue != ZERO_CM)
                        {
                            boxObjRef = shrinkBoxObj(boxObjRef, preShrinkValue);
                        }
                        drawNetFromObjRef(boxObjRef, doc, shrinkToDimensions.CurrentValue);
                        return(Result.Success);
                    }
                }
            }
        }
예제 #2
0
        /// <summary>
        /// Getter method to load primal/dual from a geometry container from the Rhino Document

        /// </summary>
        /// <param name="primal">provided primal - need to check if it has data after the method ends</param>
        /// <param name="dual">provided primal - just like primal check if it has cells </param>
        public static IList <Guid> LoadPrimalDual(out PFoam primal, out PFoam dual, out ContainerType container, bool connect = true)
        {
            primal = new PFoam();
            dual   = new PFoam();

            container = ContainerType.Edge;

            GetObject getObj              = new GetObject();
            var       togGeoUpdate        = new OptionToggle(true, "no", "yes");
            var       togClearConstraints = new OptionToggle(false, "no", "yes");

            //var togOptionReplace = new OptionToggle(true, "Keep", "Replace");

            getObj.SetCommandPrompt("Pick the geometry container (group of lines, surfaces, polysurfaces or meshes)");


            getObj.AddOptionToggle("UpdateGeo", ref togGeoUpdate);
            getObj.AddOptionToggle("ClearConstraints", ref togClearConstraints);
            //getObj.AddOptionToggle("ReplaceGeo", ref togOptionReplace);
            getObj.GroupSelect    = true;
            getObj.GeometryFilter = Rhino.DocObjects.ObjectType.Brep | Rhino.DocObjects.ObjectType.Curve | Rhino.DocObjects.ObjectType.Mesh;

            while (true)
            {
                var r = getObj.GetMultiple(1, 0);
                if (r == GetResult.Cancel)
                {
                    return(new List <Guid>());
                }
                else if (r == GetResult.Object)
                {
                    break;
                }
            }

            var guids = getObj.Objects().Select(x => x.ObjectId).ToList();

            var geoObj = getObj.Objects().Select(x => x.Geometry());

            if (geoObj.All(x => x.ObjectType == Rhino.DocObjects.ObjectType.Brep))
            {
                var brepInput = geoObj.Cast <Brep>().ToList();

                if (brepInput.Any(x => x.Faces.Count > 1))
                {
                    container = ContainerType.CellBrep;
                }
                else
                {
                    container = ContainerType.FaceBrep;
                }

                primal = LoadData.LoadFromFaces(brepInput, out dual, togGeoUpdate.CurrentValue);
            }
            else if (geoObj.All(x => x.ObjectType == Rhino.DocObjects.ObjectType.Curve))
            {
                container = ContainerType.Edge;
                var curveGeos = geoObj.Cast <Curve>().ToList();
                primal = LoadData.LoadFromEdges(curveGeos, out dual, togGeoUpdate.CurrentValue);
            }

            else if (geoObj.All(x => x.ObjectType == Rhino.DocObjects.ObjectType.Mesh))
            {
                var meshGeos = geoObj.Cast <Mesh>().ToList();
                if (meshGeos.Any(x => x.Ngons.Count > 1 ||
                                 (x.Ngons.Count == 0 && x.Faces.Count > 1) ||
                                 (x.Ngons.Count == 1 && x.Faces.Count > x.Ngons[0].FaceCount)))
                {
                    container = ContainerType.CellMesh;
                }
                else
                {
                    container = ContainerType.FaceMesh;
                }



                primal = LoadData.LoadFromMeshes(meshGeos, out dual, togGeoUpdate.CurrentValue);
            }
            else
            {
                Rhino.RhinoApp.WriteLine("Mixed data detected!");
                return(new List <Guid>());
            }


            if (primal.Cells.Count < 1)
            {
                Rhino.RhinoApp.WriteLine("Error creating primal from provided data!");
                return(new List <Guid>());
            }

            if (connect && dual.Cells.Count > 1 && primal.Dual.Id == dual.Id)
            {
                Util.ConnectDuals(ref primal, ref dual);
            }


            if (togClearConstraints.CurrentValue)
            {
                foreach (var vert in primal.Vertices)
                {
                    vert.RestrictPosition = null;
                    vert.RestrictSupport  = null;
                    vert.SupportGuid      = Guid.Empty;
                }
                foreach (var edge in primal.Edges)
                {
                    edge.TargetLength = double.NaN;
                    edge.MaxLength    = double.MaxValue;
                    edge.MinLength    = double.Epsilon;
                }
                foreach (var face in primal.Faces)
                {
                    face.TargetArea = double.NaN;
                }
            }


            Rhino.RhinoDoc.ActiveDoc.Objects.UnselectAll();
            Rhino.RhinoDoc.ActiveDoc.Views.Redraw();
            return(guids);
        }
예제 #3
0
        protected override Result RunCommand(RhinoDoc doc, RunMode mode)
        {
            var cs_option = new OptionToggle(m_use_cplane, "World", "CPlane");

            var go = new GetObject();

            go.SetCommandPrompt("Select objects for bounding box calculation");
            go.GroupSelect     = true;
            go.SubObjectSelect = false;
            for (;;)
            {
                go.ClearCommandOptions();
                go.AddOptionToggle("CoordinateSystem", ref cs_option);

                var res = go.GetMultiple(1, 0);

                if (res == GetResult.Option)
                {
                    continue;
                }
                else if (res != GetResult.Object)
                {
                    return(Result.Cancel);
                }

                break;
            }

            var plane = go.View().ActiveViewport.ConstructionPlane();

            m_use_cplane = cs_option.CurrentValue;

            var world_to_plane = new Transform(1.0);

            if (m_use_cplane)
            {
                world_to_plane = Transform.ChangeBasis(Plane.WorldXY, plane);
            }

            var bounding_box = new BoundingBox();

            for (var i = 0; i < go.ObjectCount; i++)
            {
                var rhino_obj = go.Object(i).Object();
                if (null != rhino_obj)
                {
                    var box = rhino_obj.Geometry.GetBoundingBox(world_to_plane);
                    if (box.IsValid)
                    {
                        if (i == 0)
                        {
                            bounding_box = box;
                        }
                        else
                        {
                            bounding_box.Union(box);
                        }
                    }
                }
            }

            if (!bounding_box.IsValid)
            {
                RhinoApp.WriteLine("BoundingBox failed. Unable to calculate bounding box.");
                return(Result.Failure);
            }

            var box_corners = new Point3d[8];

            box_corners[0] = bounding_box.Corner(false, false, false);
            box_corners[1] = bounding_box.Corner(true, false, false);
            box_corners[2] = bounding_box.Corner(true, true, false);
            box_corners[3] = bounding_box.Corner(false, true, false);
            box_corners[4] = bounding_box.Corner(false, false, true);
            box_corners[5] = bounding_box.Corner(true, false, true);
            box_corners[6] = bounding_box.Corner(true, true, true);
            box_corners[7] = bounding_box.Corner(false, true, true);

            if (m_use_cplane)
            {
                // Transform corners points from cplane coordinates
                // to world coordinates if necessary.
                var plane_to_world = Transform.ChangeBasis(plane, Plane.WorldXY);
                for (var i = 0; i < 8; i++)
                {
                    box_corners[i].Transform(plane_to_world);
                }
            }

            Point3d[] rect;
            var       type = ClassifyBoundingBox(box_corners, out rect);

            if (type == BoundingBoxClassification.Point)
            {
                RhinoApp.WriteLine("BoundingBox failed. The bounding box is a point.");
            }
            else if (type == BoundingBoxClassification.Line)
            {
                RhinoApp.WriteLine("BoundingBox failed. The bounding box is a line.");
            }
            else if (type == BoundingBoxClassification.Rectangle)
            {
                doc.Objects.AddPolyline(rect);
            }
            else //if (type == BoundingBoxClassification.Box)
            {
                var brep = Brep.CreateFromBox(box_corners);
                doc.Objects.AddBrep(brep);
            }

            doc.Views.Redraw();

            return(Result.Success);
        }
예제 #4
0
            protected override Result RunCommand(RhinoDoc doc, RunMode mode)
            {
                // Command variables
                var    selectedObjects = new List <RhinoObject>();
                string selectedSchema  = "";
                bool   automatic       = true;
                bool   directShape     = false;

                // Construct an objects getter
                // This includes an option toggle for "Automatic" (true means automagic schema application, no directshapes)
                var getObj = new GetObject();

                getObj.SetCommandPrompt("Select geometry");
                var toggleAutomatic = new OptionToggle(true, "Off", "On");

                getObj.AddOptionToggle("Automatic", ref toggleAutomatic);
                getObj.GroupSelect     = true;
                getObj.SubObjectSelect = false;
                getObj.EnableClearObjectsOnEntry(false);
                getObj.EnableUnselectObjectsOnExit(false);
                getObj.DeselectAllBeforePostSelect = false;

                // Get objects
                for (; ;)
                {
                    GetResult res = getObj.GetMultiple(1, 0);
                    if (res == GetResult.Option)
                    {
                        getObj.EnablePreSelect(false, true);
                        continue;
                    }
                    else if (res != GetResult.Object)
                    {
                        return(Result.Cancel);
                    }
                    if (getObj.ObjectsWerePreselected)
                    {
                        getObj.EnablePreSelect(false, true);
                        continue;
                    }
                    break;
                }

                selectedObjects = getObj.Objects().Select(o => o.Object()).ToList();
                automatic       = toggleAutomatic.CurrentValue;

                // Construct an options getter if "Automatic" was set to "off"
                if (!automatic)
                {
                    // Construct an options getter for schema options
                    // This includes an option toggle for "DirectShape" (true will asign selected schema as the family)
                    // Also includes an option list of supported schemas
                    var getOpt = new GetOption();
                    getOpt.SetCommandPrompt("Select schema options. Press Enter when done");
                    var           toggleDirectShape     = new OptionToggle(false, "Off", "On");
                    var           directShapeIndex      = getOpt.AddOptionToggle("DirectShape", ref toggleDirectShape);
                    List <string> schemas               = Enum.GetNames(typeof(SchemaObjectFilter.SupportedSchema)).ToList();
                    int           schemaListOptionIndex = getOpt.AddOptionList("Schema", schemas, 0);

                    // Get options
                    while (getOpt.Get() == GetResult.Option)
                    {
                        if (getOpt.OptionIndex() == schemaListOptionIndex)
                        {
                            selectedSchema = schemas[getOpt.Option().CurrentListOptionIndex];
                        }
                        if (getOpt.OptionIndex() == directShapeIndex)
                        {
                            directShape = toggleDirectShape.CurrentValue;
                        }
                    }
                }

                // Apply schemas
                if (automatic)
                {
                    ApplySchemas(selectedObjects, doc);
                }
                else
                {
                    ApplySchema(selectedObjects, selectedSchema, doc, directShape);
                }
                return(Result.Success);
            }
        protected override Result RunCommand(RhinoDoc doc, RunMode mode)
        {
            using (var go = new GetObject())
            {
                go.SetCommandPrompt("Please select closed objects for converting to Honeybee Room");

                //Only Brep is accepted, because we need to save meta data to sub-surface as well.
                //Extrusion doesn't have sub-surface.
                //all extrusion will be converted to Brep.
                go.GeometryFilter = ObjectType.Brep | ObjectType.Extrusion;
                go.EnableClearObjectsOnEntry(false);
                go.EnableUnselectObjectsOnExit(false);
                go.DeselectAllBeforePostSelect = false;

                //check if any brep has been converted to Room
                var optionSkipExistingRoom_toggle = new OptionToggle(true, "No_RecreateAllRooms", "Yes");
                while (true)
                {
                    go.ClearCommandOptions();
                    go.AddOptionToggle("SkipExistingRoom", ref optionSkipExistingRoom_toggle);
                    var rc = go.GetMultiple(1, 0);
                    if (rc == GetResult.Option)
                    {
                        go.EnablePreSelect(false, true);
                        continue;
                    }
                    else if (rc != GetResult.Object)
                    {
                        return(Result.Cancel);
                    }
                    if (go.ObjectsWerePreselected)
                    {
                        go.EnablePreSelect(false, true);
                        continue;
                    }
                    break;
                }

                if (go.CommandResult() != Result.Success)
                {
                    return(Result.Failure);
                }

                if (go.ObjectCount == 0)
                {
                    return(Result.Nothing);
                }

                var ifSkip = optionSkipExistingRoom_toggle.CurrentValue;

                //Getting objects
                var solidBreps      = go.Objects().Where(_ => _.Brep() != null).Where(_ => _.Brep().IsSolid);
                var objectToConvert = solidBreps;
                if (ifSkip)
                {
                    objectToConvert = solidBreps.Where(_ => !_.IsRoom()).ToList();
                }

                ConvertToRoom(doc, objectToConvert);

                doc.Views.Redraw();

                var count = objectToConvert.Count();
                var msg   = count > 1 ? $"{count} Honeybee rooms were created successfully!" : $"{count} Honeybee room was created successfully!";
                RhinoApp.WriteLine(msg);
                return(Result.Success);
            }
        }
예제 #6
0
        public IList <PFVertex> PickVertex()
        {
            var innerVerts    = Vertices.Where(x => !x.External);
            var pickedVerts   = new List <PFVertex>();
            var doc           = Rhino.RhinoDoc.ActiveDoc;
            var vertexConduit = new DrawPFVertexConduit(innerVerts)
            {
                Enabled = true
            };

            doc.Views.Redraw();
            var gVert = new GetPFVertex(innerVerts);

            //var permOption = new OptionToggle(false, "temp", "perm");
            gVert.AddSnapPoints(innerVerts.Select(x => x.Point).ToArray());
            while (true)
            {
                gVert.SetCommandPrompt("select Vertex points. (<ESC> to exit");
                //gVert.AddOptionToggle("Remember", ref permOption);
                gVert.AcceptNothing(true);
                gVert.AcceptString(true);
                //gVert.SetCursor() // this we can change after switching to Rhino 6 - api

                gVert.SetDefaultString($"({pickedVerts.Count}) vertices selected press <Enter> to accept");
                gVert.Get(true);


                doc.Views.Redraw();
                var result    = gVert.CommandResult();
                var strResult = gVert.StringResult();
                pickedVerts = new List <PFVertex>();
                if (gVert.CommandResult() == Rhino.Commands.Result.Cancel)
                {
                    break;
                }
                foreach (var vrt in innerVerts)
                {
                    if (vrt.Picked)
                    {
                        pickedVerts.Add(vrt);
                    }
                }
                if (gVert.GotDefault())
                {
                    // here use a pick mechanism to get the geometry
                    if (pickedVerts.Count > 0)
                    {
                        var outside   = new OptionToggle(true, "true", "false");
                        var fixPoint  = new OptionToggle(false, "constrain", "fix");
                        var getRefGeo = new GetObject();
                        getRefGeo.SetCommandPrompt("Pick the constrain object for the selected vertices");

                        getRefGeo.AddOptionToggle("Outside", ref outside);
                        getRefGeo.AddOptionToggle("Fixed", ref fixPoint);
                        getRefGeo.AcceptNothing(true);
                        getRefGeo.DisablePreSelect();



                        if (getRefGeo.Get() == Rhino.Input.GetResult.Object)
                        {
                            var geoGet = getRefGeo.Object(0);
                            var idGet  = getRefGeo.Object(0).ObjectId;

                            SetVertexConstraints(pickedVerts, geoGet.Object(), 1, outside.CurrentValue);
                        }

                        else if (getRefGeo.Result() == Rhino.Input.GetResult.Nothing)
                        {
                            foreach (var vert in pickedVerts)
                            {
                                vert.RestrictPosition = null;
                                vert.RestrictSupport  = null;
                                vert.SupportGuid      = Guid.Empty;
                            }
                        }

                        else if (getRefGeo.Result() == Rhino.Input.GetResult.Option && fixPoint.CurrentValue == true)
                        {
                            foreach (var vert in pickedVerts)
                            {
                                vert.RestrictPosition = vert.ConstrainPoint;
                                vert.RestrictSupport  = new Rhino.Geometry.Point(vert.Point); // this is what keeps the vertex in place
                                vert.InfluenceCoef    = 100;                                  // this is what makes it relatively immovable
                                vert.SupportGuid      = Guid.Empty;
                                vert.Fixed            = true;                                 // this is just for serilization refference
                            }
                        }
                        doc.Objects.UnselectAll();
                        pickedVerts.ForEach(x => x.Picked = false);
                        doc.Views.Redraw();
                    }
                    else
                    {
                        break;
                    }
                }
            }
            vertexConduit.Enabled = false;
            doc.Views.Redraw();

            return(pickedVerts);
        }
예제 #7
0
        protected override Result RunCommand(RhinoDoc doc, RunMode mode)
        {
            //look at this for a summary of all the GET commands.

            // https://developer.rhino3d.com/api/RhinoCommon/html/T_Rhino_Input_Custom_GetBaseClass.htm.

            /*System.Object
             * Rhino.Input.Custom.GetBaseClass
             *  Rhino.Input.Custom.GetInteger
             *  Rhino.Input.Custom.GetNumber
             *  Rhino.Input.Custom.GetObject
             *  Rhino.Input.Custom.GetOption
             *  Rhino.Input.Custom.GetPoint
             *  Rhino.Input.Custom.GetString
             *
             * */
            var gc = new GetObject();

            gc.SetCommandPrompt("Select objects");
            gc.GeometryFilter = ObjectType.AnyObject;

            OptionInteger intOption  = new OptionInteger(1, 1, 99);
            OptionDouble  dblOption  = new OptionDouble(2.2, 0, 99);
            OptionToggle  boolOption = new OptionToggle(true, "off", "on");

            gc.AddOptionInteger("Integer", ref intOption);
            gc.AddOptionDouble("Double", ref dblOption);
            gc.AddOptionToggle("Boolean", ref boolOption);

            int listIndex = 0;

            string[] listValues = new string[] { "Bran", "Bob", "Arya", "Sansa", "Rickon" };

            int optList = gc.AddOptionList("List", listValues, listIndex);

            while (true)
            {
                GetResult res = gc.GetMultiple(1, 0);

                //we can check if the user selected something
                if (gc.CommandResult() != Result.Success)
                {
                    return(gc.CommandResult());
                }

                if (res == Rhino.Input.GetResult.Object)
                {
                    RhinoApp.WriteLine("Command line option values are");
                    RhinoApp.WriteLine("Integer = {0}", intOption.CurrentValue);
                    RhinoApp.WriteLine("Double = {0}", dblOption.CurrentValue);
                    RhinoApp.WriteLine("Boolean = {0}", boolOption.CurrentValue);
                    RhinoApp.WriteLine("List = {0}", listValues[listIndex]);
                }
                else if (res == Rhino.Input.GetResult.Option)
                {
                    if (gc.OptionIndex() == optList)
                    {
                        listIndex = gc.Option().CurrentListOptionIndex; //this updates the list option to whatever index the user has picked
                    }
                    continue;
                }

                break;
            }

            return(Result.Success);
        }
예제 #8
0
        protected override Result RunCommand(RhinoDoc doc, RunMode mode)
        {
            //pick surface to orient to or block instance to relocate
            GetObject gs = new Rhino.Input.Custom.GetObject();

            gs.SetCommandPrompt("Surface to orient new object on or BlockInstance to move");
            gs.GeometryFilter              = Rhino.DocObjects.ObjectType.Surface | Rhino.DocObjects.ObjectType.InstanceReference;
            gs.SubObjectSelect             = true;
            gs.DeselectAllBeforePostSelect = false;
            gs.OneByOnePostSelect          = true;
            gs.Get();
            if (gs.CommandResult() != Result.Success)
            {
                return(gs.CommandResult());
            }

            Rhino.DocObjects.ObjRef      objref = gs.Object(0);
            Rhino.DocObjects.RhinoObject obj    = objref.Object();
            if (obj == null)
            {
                return(Result.Failure);
            }
            surface = objref.Surface();


            //relocate block instance
            if (surface == null)
            {
                Rhino.DocObjects.InstanceObject instance1 = objref.Object() as Rhino.DocObjects.InstanceObject;

                instancePoint = instance1.InsertionPoint;
                double g, h;
                surface2.ClosestPoint(instancePoint, out g, out h);
                var instanceDirection = surface2.NormalAt(g, h);
                instancePlane = new Plane(instancePoint, instanceDirection);

                Rhino.Input.Custom.GetPoint gpss = new Rhino.Input.Custom.GetPoint();
                gpss.SetCommandPrompt("Point on surface to orient to");
                gpss.Constrain(surface2, false);

                gpss.DynamicDraw += RefObjDraw;
                gpss.Tag          = instance1;

                gpss.Get();
                if (gpss.CommandResult() != Rhino.Commands.Result.Success)
                {
                    return(gpss.CommandResult());
                }
                Point3d ptss = gpss.Point();
                surface2.ClosestPoint(ptss, out g, out h);
                var       direction1 = surface2.NormalAt(g, h);
                Plane     pl11       = new Plane(ptss, direction1);
                Transform iform      = Rhino.Geometry.Transform.PlaneToPlane(instancePlane, pl11);
                doc.Objects.Transform(instance1, iform, true);

                return(Result.Success);
            }

            obj.Select(false);

            //pick objekt to orient
            var copy = new Rhino.Input.Custom.OptionToggle(false, "No", "Yes");

            GetObject go = new GetObject();

            go.SetCommandPrompt("Select object to orient.");
            go.AddOptionToggle("Copy", ref copy);
            go.SubObjectSelect             = true;
            go.DeselectAllBeforePostSelect = false;
            go.GroupSelect = true;

            for (; ;)
            {
                var res = go.GetMultiple(1, -1);
                if (gs.CommandResult() != Result.Success)
                {
                    return(gs.CommandResult());
                }
                if (res == GetResult.Option)
                {
                    copyBol = copy.CurrentValue;
                    continue;
                }
                if (gs.CommandResult() != Result.Success)
                {
                    return(gs.CommandResult());
                }

                break;
            }



            int    obCount      = go.ObjectCount;
            string instDefCount = DateTime.Now.ToString("ddMMyyyyHHmmss");

            //create block instance and plane for instance
            Rhino.Input.Custom.GetPoint gp = new Rhino.Input.Custom.GetPoint();
            gp.SetCommandPrompt("Point to orient from");
            gp.Get();
            if (gp.CommandResult() != Rhino.Commands.Result.Success)
            {
                return(gp.CommandResult());
            }

            Vector3d vt1 = new Vector3d(0, 0, 1);
            Point3d  pt1 = gp.Point();

            sourcePlane = new Plane(pt1, vt1);
            Plane     originPlane = new Plane(Point3d.Origin, vt1);
            Transform bform       = Rhino.Geometry.Transform.PlaneToPlane(sourcePlane, originPlane);

            //block instance
            GeometryBase[] obj1List = new GeometryBase[obCount];
            List <Brep>    opList   = new List <Brep>();

            for (int igo = 0; igo < obCount; igo++)
            {
                Rhino.DocObjects.ObjRef      objref1 = go.Object(igo);
                Rhino.DocObjects.RhinoObject obj1    = objref1.Object();
                if (obj == null)
                {
                    return(Result.Failure);
                }
                obj.Select(false);


                Rhino.Geometry.Brep opItem = objref1.Brep();
                opList.Add(opItem);

                GeometryBase obj1Base = obj1.Geometry;
                obj1Base.Transform(bform);

                obj1List[igo] = obj1Base;
            }

            var orientBlock = doc.InstanceDefinitions.Add("Block" + instDefCount, "OrientBlock", Point3d.Origin, obj1List);

            //get all go.Objects to .Tag
            Brep[] op = new Brep[obCount];
            op = Brep.CreateBooleanUnion(opList, 0.01);
            Brep od = new Brep();

            od = op[0];
            var odGuid = doc.Objects.AddBrep(od);

            Rhino.DocObjects.ObjRef      objref2 = new Rhino.DocObjects.ObjRef(odGuid);
            Rhino.DocObjects.RhinoObject objDrw  = objref2.Object();

            //orient plane to surface
            if (copyBol)
            {
                while (true)
                {
                    Rhino.Input.Custom.GetPoint gps = new Rhino.Input.Custom.GetPoint();
                    gps.SetCommandPrompt("Point on surface to orient to. Press enter when done.");
                    gps.Constrain(surface, false);
                    gps.AcceptNothing(true);
                    gps.DynamicDraw += RefObjDraw;
                    gps.Tag          = objDrw;

                    var res = gps.Get();

                    if (res == GetResult.Nothing)
                    {
                        break;
                    }
                    //else if (gps.CommandResult() != Rhino.Commands.Result.Success)
                    //    return gps.CommandResult();


                    Point3d pts = gps.Point();
                    double  u, v;
                    surface.ClosestPoint(pts, out u, out v);
                    Vector3d direction = surface.NormalAt(u, v);
                    Plane    pl1       = new Plane(pts, direction);

                    Rhino.Geometry.Transform xform = Rhino.Geometry.Transform.PlaneToPlane(originPlane, pl1);

                    doc.Objects.AddInstanceObject(orientBlock, xform);

                    doc.Objects.Delete(objDrw);
                }
                copyBol = false;
            }
            else
            {
                Rhino.Input.Custom.GetPoint gps = new Rhino.Input.Custom.GetPoint();
                gps.SetCommandPrompt("Point on surface to orient to");
                gps.Constrain(surface, false);

                gps.DynamicDraw += RefObjDraw;
                gps.Tag          = objDrw;

                gps.Get();
                if (gps.CommandResult() != Rhino.Commands.Result.Success)
                {
                    return(gps.CommandResult());
                }
                Point3d pts = gps.Point();
                double  u, v;
                surface.ClosestPoint(pts, out u, out v);
                Vector3d direction = surface.NormalAt(u, v);
                Plane    pl1       = new Plane(pts, direction);

                Rhino.Geometry.Transform xform = Rhino.Geometry.Transform.PlaneToPlane(originPlane, pl1);

                doc.Objects.AddInstanceObject(orientBlock, xform);

                doc.Objects.Delete(objDrw);
            }

            surface2 = surface;

            return(Result.Success);
        }
예제 #9
0
        protected override Result RunCommand(RhinoDoc doc, RunMode mode)
        {
            // TODO: start here modifying the behaviour of your command.
            // ---
            //RhinoApp.WriteLine("The {0} command will add a line right now.", EnglishName);



            GetObject getBreps = new GetObject();

            getBreps.SetCommandPrompt("Pick the breps to create a PolyhedralFrame");
            getBreps.GeometryFilter = Rhino.DocObjects.ObjectType.Brep;
            // set up options

            OptionDouble dblOptionCollapse = new Rhino.Input.Custom.OptionDouble(0.1, true, 0.0);
            OptionDouble dblOptionPlanar   = new Rhino.Input.Custom.OptionDouble(0.1, true, 0.0);
            OptionToggle togOptionReplace  = new OptionToggle(true, "Keep", "Replace");

            getBreps.AddOptionDouble("PointCollapseLimit", ref dblOptionCollapse);
            getBreps.AddOptionDouble("PlanarityMaxDeviation", ref dblOptionPlanar);

            getBreps.AddOptionToggle("ReplaceGeo", ref togOptionReplace);
            getBreps.AcceptNothing(false);

            while (true)
            {
                var r = getBreps.GetMultiple(1, 0);
                if (r == GetResult.Cancel)
                {
                    return(getBreps.CommandResult());
                }
                else if (r == GetResult.Object)
                {
                    break;
                }
            }

            List <Guid> ids = new List <Guid>();

            for (int i = 0; i < getBreps.ObjectCount; i++)
            {
                ids.Add(getBreps.Object(i).ObjectId);
            }

            var foam           = new PFoam();
            var deleteOriginal = false;

            try
            {
                foam.ProcessBFaces(Util.DecomposeG(ids), dblOptionCollapse.CurrentValue, dblOptionPlanar.CurrentValue);
                doc.Objects.UnselectAll();
                if (foam.Faces.Count > 2)
                {
                    foam.MakeCells();
                    Point3d newCentroid = foam.Centroid;
                    if (!togOptionReplace.CurrentValue)
                    {
                        Rhino.Input.RhinoGet.GetPoint("Place the PolyFrame", true, out newCentroid);
                    }
                    else
                    {
                        deleteOriginal = true;
                    }
                    //Rhino.RhinoDoc.ActiveDoc.Objects.Delete(ids, true);


                    foam.Offset(newCentroid - foam.Centroid);
                    foam.Show(true, true, false);
                    foam.ShowCells();


                    if (!foam.SaveToDocument())
                    {
                        foam.Hide();
                        return(Result.Cancel);
                    }


                    foam.Hide();

                    if (deleteOriginal)
                    {
                        Rhino.RhinoDoc.ActiveDoc.Objects.Delete(ids, true);
                    }
                    doc.Views.Redraw();
                    Rhino.RhinoApp.WriteLine($"Constructed a PolyFrame object with {foam.Cells.Count} cells, {foam.Faces.Count} half-faces, {foam.Edges.Count} half-edges and {foam.Vertices.Count} vertices.");

                    return(Result.Success);
                }
                else
                {
                    Rhino.RhinoApp.WriteLine("Not enough faces!");
                    return(Result.Failure);
                }
            }
            catch (Exception pfE)
            {
                RhinoApp.WriteLine(pfE.Message + " Press <Esc> to continue.");
                foam.Hide();
                return(Result.Failure);
            }
        }
        protected override Result RunCommand(Rhino.RhinoDoc doc, RunMode mode)
        {
            GetObject go = new GetObject();

            // List of Object Types to filter
            List <ObjectType> enumList = new List <ObjectType> {
                ObjectType.Point,
                ObjectType.Curve,
                ObjectType.Extrusion,
                ObjectType.Surface,
                ObjectType.Brep,
                ObjectType.Mesh,
                ObjectType.InstanceReference,
                ObjectType.Light,
                ObjectType.ClipPlane,
                ObjectType.Hatch,
                ObjectType.Annotation,
                ObjectType.ClipPlane,
            };

            string[]            enumNames  = Enum.GetNames(typeof(ObjectType));
            var                 enumValues = Enum.GetValues(typeof(ObjectType)).OfType <ObjectType>().ToList();
            List <OptionToggle> options    = new List <OptionToggle>();
            List <ObjectType>   types      = new List <ObjectType>();

            for (int i = 0; i < enumList.Count; i++)
            {
                var value = (ObjectType)enumList[i];
                var index = enumValues.IndexOf(value);

                if (index > -1)
                {
                    var toggle = new OptionToggle(false, "Off", "On");
                    options.Add(toggle);
                    types.Add(value);
                    go.AddOptionToggle(enumNames[index], ref toggle);
                }
            }

            go.SetCommandPrompt("Select filter geometry types");

            go.GroupSelect     = true;
            go.SubObjectSelect = false;
            go.EnableClearObjectsOnEntry(false);
            go.EnableUnselectObjectsOnExit(false);
            go.DeselectAllBeforePostSelect = false;

            var selectedObjectTypes = new List <ObjectType>();

            while (true)
            {
                GetResult res = go.GetMultiple(1, 0);


                // If the action is change in filter, update the filter list.
                if (res == GetResult.Option)
                {
                    selectedObjectTypes.Clear();
                    go.EnablePreSelect(false, true);
                    ObjectType objectTypes = 0;
                    for (var i = 0; i < options.Count; i++)
                    {
                        var type = types[i];
                        if (options[i].CurrentValue)
                        {
                            selectedObjectTypes.Add(type);
                            if (objectTypes == ObjectType.None)
                            {
                                objectTypes = type;
                            }
                            else
                            {
                                objectTypes |= type;
                            }
                        }
                    }
                    go.GeometryFilter = objectTypes;

                    continue;
                }

                else if (res != GetResult.Object)
                {
                    return(Result.Cancel);
                }

                if (go.ObjectsWerePreselected)
                {
                    go.EnablePreSelect(false, true);
                    continue;
                }

                break;
            }

            // Select objects that meets the filter criteria
            for (int i = 0; i < go.ObjectCount; i++)
            {
                RhinoObject rhinoObject = go.Object(i).Object();
                if (null != rhinoObject)
                {
                    if (selectedObjectTypes.Contains(rhinoObject.ObjectType))
                    {
                        rhinoObject.Select(true);
                    }
                    else
                    {
                        rhinoObject.Select(false);
                    }
                }
            }
            doc.Views.Redraw();
            return(Result.Success);
        }
        protected override Result RunCommand(RhinoDoc doc, RunMode mode)
        {
            GetObject go = new GetObject();

            go.SetCommandPrompt("Select meshes to Voronoi");
            go.GeometryFilter = Rhino.DocObjects.ObjectType.Mesh;


            go.AddOptionToggle("OutputMesh", ref outputMeshToggle);
            go.AddOptionToggle("OutputLines", ref outputLinesToggle);
            go.AddOptionToggle("OutputPolylines", ref outputPolylinesToggle);
            go.AddOptionToggle("OutputNGon", ref outputNGon);

            for (;;)
            {
                GetResult res = go.GetMultiple(1, 0);

                if (res == GetResult.Option)
                {
                    continue;
                }

                if (go.CommandResult() != Result.Success)
                {
                    return(go.CommandResult());
                }

                break;
            }

            if (go.ObjectCount < 1)
            {
                return(Result.Failure);
            }

            foreach (var obj in go.Objects())
            {
                var rhinoMesh = obj.Mesh();

                if (rhinoMesh == null || !rhinoMesh.IsValid)
                {
                    continue;
                }

                var mesh = GopherUtil.ConvertToD3Mesh(obj.Mesh());

                g3.DMesh3            outputMesh;
                List <g3.Line3d>     listLines;
                List <g3.PolyLine3d> listPolylines;
                GopherUtil.VoronoiMesh(mesh, out outputMesh, out listLines, out listPolylines);

                var rhinoOutputMesh = GopherUtil.ConvertToRhinoMesh(outputMesh);

                if (outputPolylinesToggle.CurrentValue)
                {
                    foreach (var p in listPolylines)
                    {
                        var rp = Gopher.GopherUtil.ConvertToRhinoPolyline(p);
                        doc.Objects.AddPolyline(rp);
                    }
                }

                if (outputLinesToggle.CurrentValue)
                {
                    foreach (var l in listLines)
                    {
                        var rl = GopherUtil.ConvertToRhinoLine(l);
                        doc.Objects.AddLine(rl);
                    }
                }

                if (outputMeshToggle.CurrentValue)
                {
                    if (outputNGon.CurrentValue)
                    {
                        //   rhinoOutputMesh.Ngons.AddPlanarNgons(doc.ModelAbsoluteTolerance);
                        doc.Objects.AddMesh(Gopher.GopherUtil.ConvertToRhinoMesh(listPolylines));
                    }
                    else
                    {
                        doc.Objects.AddMesh(rhinoOutputMesh);
                    }
                }
            }

            return(Result.Success);
        }
예제 #12
0
        // loads or makes a polyframe and planarizes the faces
        // load a set of geometries
        // if lines => must have PolyFrame date attached
        // if breps and data exists => reload topology data and update from geometry
        // if no data exists => make topology without cells
        // planarize and dump to the file
        // add topology data if cells are present.

        protected override Result RunCommand(RhinoDoc doc, RunMode mode)
        {
            GetObject getObjects = new GetObject();

            getObjects.SetCommandPrompt("Pick the breps or PolyFrame container to planarize ");
            getObjects.GeometryFilter =
                Rhino.DocObjects.ObjectType.Brep |
                Rhino.DocObjects.ObjectType.Curve |
                Rhino.DocObjects.ObjectType.Mesh;
            // set up options

            getObjects.GroupSelect = true;

            OptionDouble dblOptionCollapse = new OptionDouble(0.1, true, 0.0);

            OptionToggle togOptionReplace = new OptionToggle(true, "Keep", "Replace");

            getObjects.AddOptionDouble("PointCollapseLimit", ref dblOptionCollapse);

            getObjects.AddOptionToggle("ReplaceGeo", ref togOptionReplace);
            getObjects.AcceptNothing(false);



            var primal = new PFoam();
            var dual   = new PFoam();


            while (true)
            {
                var r = getObjects.GetMultiple(1, 0);
                if (r == GetResult.Cancel)
                {
                    return(getObjects.CommandResult());
                }
                else if (r == GetResult.Object)
                {
                    break;
                }
            }



            List <Guid> ids = new List <Guid>();

            for (int i = 0; i < getObjects.ObjectCount; i++)
            {
                ids.Add(getObjects.Object(i).ObjectId);
            }


            try
            {
                ContainerType container = ContainerType.Edge;
                bool          usePFTopo = false;
                var           selGeo    = getObjects.Objects().Select(x => x.Geometry());
                if (selGeo.All(x => x.ObjectType == Rhino.DocObjects.ObjectType.Brep))
                {
                    if (selGeo.Any(y => y.UserDictionary.TryGetString("Primal", out string primalJson)))
                    {
                        Rhino.Input.RhinoGet.GetBool("PolyFrame data detected. Use topology data from there?", false, "no", "yes", ref usePFTopo);
                    }

                    if (usePFTopo)
                    {
                        //guids = LoadData.LoadPrimalDual(out primal, out dual);

                        var brepGeo = selGeo.Cast <Brep>().ToList();
                        if (brepGeo.Any(x => x.Faces.Count > 1))
                        {
                            container = ContainerType.CellBrep;
                        }
                        else
                        {
                            container = ContainerType.FaceBrep;
                        }

                        primal = LoadData.LoadFromFaces(brepGeo, out dual, true);
                    }
                    else
                    {
                        primal.ProcessBFaces(Util.DecomposeG(ids), dblOptionCollapse.CurrentValue, double.MaxValue);
                        primal.SortPartsInFaces();
                    }
                }
                else if (selGeo.All(x => x.ObjectType == Rhino.DocObjects.ObjectType.Curve))
                {
                    if (selGeo.Any(y => y.UserDictionary.TryGetString("Primal", out string primalJson)))
                    {
                        primal = LoadData.LoadFromEdges(selGeo.Cast <Curve>().ToList(), out dual, true);
                        //guids = LoadData.LoadPrimalDual(out primal, out dual);
                        container = ContainerType.Edge;
                    }
                    else
                    {
                        RhinoApp.WriteLine("No PolyFrame data detected. Planarization of raw line/curve data is not supported ");
                        return(Result.Failure);
                    }
                }
                else if (selGeo.All(x => x.ObjectType == Rhino.DocObjects.ObjectType.Mesh))
                {
                    if (selGeo.Any(y => y.UserDictionary.TryGetString("Primal", out string primalJson)))
                    {
                        var meshGeos = selGeo.Cast <Mesh>().ToList();
                        if (meshGeos.Any(x => x.Ngons.Count > 1 ||
                                         (x.Ngons.Count == 0 && x.Faces.Count > 1) ||
                                         (x.Ngons.Count == 1 && x.Faces.Count > x.Ngons[0].FaceCount)))
                        {
                            container = ContainerType.CellMesh;
                        }
                        else
                        {
                            container = ContainerType.FaceMesh;
                        }
                        primal = LoadData.LoadFromMeshes(meshGeos, out dual, true);
                    }
                    else
                    {
                        RhinoApp.WriteLine("No PolyFrame data detected. Planarization of raw mesh data is not supported ");
                        return(Result.Failure);
                    }
                }
        protected override Result RunCommand(RhinoDoc doc, RunMode mode)
        {
            try
            {
                using (var go = new GetObject())
                {
                    var wwr = 0.6;
                    wwr = Settings.GetDouble(nameof(wwr), 0.6);
                    var optionWWR = new OptionDouble(wwr, 0.01, 0.98);

                    var optionSkipFaceExistingWindow = new OptionToggle(true, "No_CreateForAllFaces", "Yes");

                    go.SetCommandPrompt("Please select honeybee rooms for adding windows to");
                    go.GeometryFilter  = ObjectType.Brep;
                    go.GroupSelect     = false;
                    go.SubObjectSelect = false;
                    go.EnableClearObjectsOnEntry(false);
                    go.EnableUnselectObjectsOnExit(false);
                    go.DeselectAllBeforePostSelect = false;

                    while (true)
                    {
                        go.ClearCommandOptions();
                        go.AddOptionDouble("WindowWallRatio", ref optionWWR);
                        go.AddOptionToggle("SkipFacesWithWindows", ref optionSkipFaceExistingWindow);
                        var res = go.GetMultiple(1, 0);

                        if (res == Rhino.Input.GetResult.Option)
                        {
                            go.EnablePreSelect(false, true);
                            continue;
                        }
                        else if (res != Rhino.Input.GetResult.Object)
                        {
                            return(Result.Cancel);
                        }

                        if (go.ObjectsWerePreselected)
                        {
                            go.EnablePreSelect(false, true);
                            continue;
                        }

                        break;
                    }

                    if (go.CommandResult() != Result.Success)
                    {
                        throw new ArgumentException("Failed to execute command!");
                    }

                    if (go.ObjectCount == 0)
                    {
                        throw new ArgumentException("No object is selected!");
                    }

                    //get option values
                    Settings.SetDouble(nameof(wwr), optionWWR.CurrentValue);
                    var ifSkipFaceWithWindow = optionSkipFaceExistingWindow.CurrentValue;

                    //all selected room geometries
                    var solidBreps = go.Objects().Where(_ => _.Brep() != null).Where(_ => _.Brep().IsSolid);
                    var rooms      = solidBreps.Where(_ => _.IsRoom()).ToList();
                    if (solidBreps.Count() != rooms.Count())
                    {
                        doc.Objects.UnselectAll();
                        var nonRooms = solidBreps.Where(_ => !_.Brep().IsRoom());
                        foreach (var item in nonRooms)
                        {
                            doc.Objects.Select(item, true, true);
                        }

                        doc.Views.Redraw();
                        Rhino.UI.Dialogs.ShowMessage("These are not Honeybee rooms, please use MassToRoom to convert them first!", "Honeybee Rhino Plugin");
                        return(Result.Failure);
                    }


                    //Add Windows
                    AddApertureByWWR(doc, rooms, optionWWR.CurrentValue, ifSkipFaceWithWindow);

                    doc.Views.Redraw();
                    return(Result.Success);
                }
            }
            catch (Exception e)
            {
                RhinoApp.WriteLine($"ERROR: {e.Message}");
                return(Result.Failure);
            }
        }
예제 #14
0
        protected override Result RunCommand(RhinoDoc doc, RunMode mode)
        {
            ActiveDoc = doc;

            const ObjectType geometryFilter = ObjectType.Curve | ObjectType.Surface;
            OptionToggle     toggle         = new OptionToggle(true, "Remove", "Apply");

            GetObject go = new GetObject();

            go.SetCommandPrompt("Select curves or surfaces");
            go.GeometryFilter = geometryFilter;
            go.AddOptionToggle("BuiltElements", ref toggle);
            go.GroupSelect     = true;
            go.SubObjectSelect = false;
            go.EnableClearObjectsOnEntry(false);
            go.EnableUnselectObjectsOnExit(false);
            go.DeselectAllBeforePostSelect = false;

            bool hasPreselected = false;

            for (; ;)
            {
                GetResult res = go.GetMultiple(1, 0);

                if (res == GetResult.Option)
                {
                    go.EnablePreSelect(false, true);
                    continue;
                }
                else if (res != GetResult.Object)
                {
                    return(Result.Cancel);
                }

                if (go.ObjectsWerePreselected)
                {
                    hasPreselected = true;
                    go.EnablePreSelect(false, true);
                    continue;
                }
                break;
            }

            if (hasPreselected)
            {
                // Normally, pre-selected objects will remain selected, when a
                // command finishes, and post-selected objects will be unselected.
                // Currently, leave everything selected post command.
                for (int i = 0; i < go.ObjectCount; i++)
                {
                    RhinoObject rhinoObject = go.Object(i).Object();
                    if (null != rhinoObject)
                    {
                        rhinoObject.Select(true);
                    }
                }
                doc.Views.Redraw();
            }

            List <RhinoObject> commandObjs = go.Objects().Select(o => o.Object()).ToList();

            if (toggle.CurrentValue == true)
            {
                ApplySchemas(commandObjs);
            }
            else
            {
                DeleteSchemas(commandObjs);
            }
            return(Result.Success);
        }