protected override Result RunCommand(RhinoDoc doc, RunMode mode)
{
GetObject go = new GetObject();
go.SetCommandPrompt("Select surfaces, polysurfaces, or meshes");
go.GroupSelect = true;
go.SubObjectSelect = false;
go.EnableClearObjectsOnEntry(false);
go.EnableUnselectObjectsOnExit(false);
go.DeselectAllBeforePostSelect = false;
bool bHavePreselectedObjects = 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)
{
bHavePreselectedObjects = true;
go.EnablePreSelect(false, true);
continue;
}
break;
}
BoundingBox box = BoundingBox.Empty;
for (int i = 0; i < go.ObjectCount; i++)
{
RhinoObject rhinoObject = go.Object(i).Object();
if (null != rhinoObject)
{
box.Union(rhinoObject.Geometry.GetBoundingBox(true));
}
rhinoObject.Select(false);
}
if (box.IsValid)
{
RFContext.ClippingBox = new Box(box);
//RFContext.Clip = true;
return(Result.Success);
}
return(Result.Nothing);
}
public static GetObject GetRhinoObjects(string prompt, ObjectType geometryFilter)
{
GetObject go = new GetObject();
go.SetCommandPrompt(prompt);
go.GeometryFilter = geometryFilter;
go.GroupSelect = false;
go.SubObjectSelect = false;
go.EnableClearObjectsOnEntry(false);
go.EnableUnselectObjectsOnExit(false);
go.DeselectAllBeforePostSelect = false;
bool bHavePreselectedObjects = true;
for (; ;)
{
GetResult res = go.GetMultiple(1, 0);
if (res == GetResult.Option)
{
go.EnablePreSelect(false, true);
continue;
}
else if (res != GetResult.Object)
{
return(go);
}
if (go.ObjectsWerePreselected)
{
bHavePreselectedObjects = true;
go.EnablePreSelect(false, true);
continue;
}
break;
}
if (bHavePreselectedObjects)
{
// Normally, pre-selected objects will remain selected, when a
// command finishes, and post-selected objects will be unselected.
// This this way of picking, it is possible to have a combination
// of pre-selected and post-selected. So, to make sure everything
// "looks the same", lets unselect everything before finishing
// the command.
for (int i = 0; i < go.ObjectCount; i++)
{
RhinoObject rhinoObject = go.Object(i).Object();
if (null != rhinoObject)
{
rhinoObject.Select(false);
}
}
}
return(go);
}
// This just makes sure objects selected during the command stay selected afterwards. Optional.
private static void SelectAllCommandObjs(GetObject command, RhinoDoc doc)
{
for (int i = 0; i < command.ObjectCount; i++)
{
RhinoObject rhinoObject = command.Object(i).Object();
if (null != rhinoObject)
{
rhinoObject.Select(true);
}
}
doc.Views.Redraw();
}
public static GeometryLarge CreateGeometry(MaterialType mType, string mName)
{
RhinoDoc doc = RhinoDoc.ActiveDoc;
//Allow user to pick multiple objects
const Rhino.DocObjects.ObjectType geometryFilter = Rhino.DocObjects.ObjectType.Curve;
Rhino.Input.Custom.GetObject go = new Rhino.Input.Custom.GetObject()
{
GeometryFilter = geometryFilter,
GroupSelect = true,
SubObjectSelect = false,
DeselectAllBeforePostSelect = false
};
go.SetCommandPrompt("Pick one or two closed curves.");
go.EnableClearObjectsOnEntry(false);
go.EnableUnselectObjectsOnExit(false);
bool bHavePreselectedObjects = false;
for (;;)
{
Rhino.Input.GetResult res = go.GetMultiple(1, 0);
if (go.ObjectsWerePreselected)
{
bHavePreselectedObjects = true;
go.EnablePreSelect(false, true);
continue;
}
break;
}
//Unselects the preselected objects
if (bHavePreselectedObjects)
{
for (int i = 0; i < go.ObjectCount; i++)
{
RhinoObject rhinoObject = go.Object(i).Object();
if (null != rhinoObject)
{
rhinoObject.Select(false);
}
}
doc.Views.Redraw();
}
ObjRef[] objs = go.Objects();
List <Curve> selectedCurves = new List <Curve>();
foreach (ObjRef objRef in objs)
{
if (objRef.Curve() == null)
{
RhinoApp.WriteLine("One of the selected objects was invalid.");
continue;
}
else if (!objRef.Curve().IsClosed)
{
RhinoApp.WriteLine("One of the selected curves was not closed.");
continue;
}
selectedCurves.Add(objRef.Curve());
}
GeometryLarge larg;
//if the curve is not closed do nothing
switch (selectedCurves.Count)
{
case 0:
Rhino.RhinoApp.WriteLine("No valid geometries was found.");
return(null);
case 1:
larg = DrawAndSaveUserAttr(Brep.CreatePlanarBreps(selectedCurves)[0], doc, mType, mName);
break;
case 2:
Brep brep1 = Brep.CreatePlanarBreps(new[] { selectedCurves[0] })[0];
Brep brep2 = Brep.CreatePlanarBreps(new[] { selectedCurves[1] })[0];
double area = Brep.CreateBooleanUnion(new[] { brep1, brep2 }, 0.001)[0].GetArea();
double brep1Area = brep1.GetArea();
double brep2Area = brep2.GetArea();
if (area > 0.999 * brep1Area && area < 1.001 * brep1Area)
{
Brep brep = Brep.CreateBooleanDifference(brep1, brep2, doc.ModelAbsoluteTolerance)[0];
larg = DrawAndSaveUserAttr(brep, doc, mType, mName);
break;
}
else if (area > 0.999 * brep2Area && area < 1.001 * brep2Area)
{
Brep brep = Brep.CreateBooleanDifference(brep1, brep2, doc.ModelAbsoluteTolerance)[0];
larg = DrawAndSaveUserAttr(brep, doc, mType, mName);
break;
}
else
{
RhinoApp.WriteLine("The curves were not inside one another.");
return(null);
}
default:
return(null);
}
foreach (ObjRef objRef in objs)
{
doc.Objects.Delete(objRef, false);
}
return(larg);
}
protected override Result RunCommand(RhinoDoc doc, RunMode mode)
{
const ObjectType geometryFilter = ObjectType.Surface | ObjectType.PolysrfFilter | ObjectType.Mesh;
GetObject go = new GetObject();
go.SetCommandPrompt("Select surfaces, polysurfaces, or meshes");
go.GeometryFilter = geometryFilter;
go.GroupSelect = true;
go.SubObjectSelect = false;
go.EnableClearObjectsOnEntry(false);
go.EnableUnselectObjectsOnExit(false);
go.DeselectAllBeforePostSelect = false;
bool bHavePreselectedObjects = false;
for (; ;) // infinite loop
{
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)
{
bHavePreselectedObjects = true;
go.EnablePreSelect(false, true);
continue;
}
break;
}
if (bHavePreselectedObjects)
{
for (int i = 0; i < go.ObjectCount; i++)
{
RhinoObject rhinoObject = go.Object(i).Object();
if (null != rhinoObject)
{
rhinoObject.Select(false);
}
}
doc.Views.Redraw();
}
int objectCount = go.ObjectCount;
List <String> objectTypeList = new List <string>();
List <String> objectNameList = new List <string>();
for (int i = 0; i < go.ObjectCount; i++)
{
RhinoObject rhinoObject = go.Object(i).Object();
string objectName = rhinoObject.Name;
if (null != rhinoObject)
{
objectTypeList.Add(rhinoObject.ObjectType.ToString());
objectNameList.Add(objectName);
}
}
RhinoApp.WriteLine(string.Format("Select object count = {0}", objectCount));
for (int i = 0; i < objectTypeList.Count; i++)
{
RhinoApp.WriteLine(string.Format("Select object Name : {0}, Type : {1}", objectNameList[i], objectTypeList[i]));
}
return(Result.Success);
}
protected override Result RunCommand(RhinoDoc doc, RunMode mode)
{
Mesh m1, m2;
ObjRef objref1, objref2;
Result res = Result.Nothing;
res = RhinoGet.GetOneObject("Select first mesh", false, ObjectType.Mesh, out objref1);
if (res != Result.Success)
{
return(res);
}
m1 = objref1.Mesh();
if (m1 == null)
{
return(Result.Failure);
}
RhinoApp.WriteLine("Got Mesh1 with {0} verts and {1} faces.", m1.Vertices.Count, m1.Faces.Count);
// De-select first mesh...
RhinoObject rhinoObject = objref1.Object();
if (null != rhinoObject)
{
rhinoObject.Select(false);
}
res = RhinoGet.GetOneObject("Select second mesh", false, ObjectType.Mesh, out objref2);
if (res != Result.Success)
{
return(res);
}
m2 = objref2.Mesh();
if (m2 == null)
{
return(Result.Failure);
}
RhinoApp.WriteLine("Got Mesh2 with {0} verts and {1} faces.", m2.Vertices.Count, m2.Faces.Count);
int option = 0;
res = RhinoGet.GetInteger("Union (0), Intersection (1), AMinusB (2), BMinusA (3), SymmetricalDifferent (4), All (5)", false, ref option);
RhinoApp.WriteLine("Operation {0} selected.", ((CarveRC.Operations)(option)).ToString());
if (option < 0 || option > 5)
{
RhinoApp.WriteLine("Invalid input value for Carve operation.");
return(Result.Failure);
}
Mesh result = CarveRC.CarveOps.PerformCSG(m1, m2, (CarveRC.Operations)option);
RhinoApp.WriteLine("Performed Carve operation. New mesh has {0} verts and {1} faces.", result.Vertices.Count, result.Faces.Count);
doc.Objects.AddMesh(result);
doc.Views.Redraw();
return(Result.Success);
}
//Creates reinforcement objects and saves them into the selected point as userData
public static Reinforcement[] CreateReinforcements(string mName, double diam)
{
RhinoDoc doc = RhinoDoc.ActiveDoc;
//Allow user to pick multiple objects
const Rhino.DocObjects.ObjectType geometryFilter = Rhino.DocObjects.ObjectType.Point;
Rhino.Input.Custom.GetObject go = new Rhino.Input.Custom.GetObject()
{
GeometryFilter = geometryFilter,
GroupSelect = true,
SubObjectSelect = false,
DeselectAllBeforePostSelect = false
};
go.SetCommandPrompt("Pick all the points that you want to change to reinforcement.");
go.EnableClearObjectsOnEntry(false);
go.EnableUnselectObjectsOnExit(false);
bool bHavePreselectedObjects = false;
for (;;)
{
Rhino.Input.GetResult res = go.GetMultiple(1, 0);
if (go.ObjectsWerePreselected)
{
bHavePreselectedObjects = true;
go.EnablePreSelect(false, true);
continue;
}
break;
}
//Unselects the preselected objects
if (bHavePreselectedObjects)
{
for (int i = 0; i < go.ObjectCount; i++)
{
RhinoObject rhinoObject = go.Object(i).Object();
if (null != rhinoObject)
{
rhinoObject.Select(false);
}
}
doc.Views.Redraw();
}
int layerIndex = GetOrCreateLayer(doc, "Reinforcement", Color.Black);
if (layerIndex == 999)
{
return new Reinforcement[] {}
}
;
Reinforcement[] reinfList = { };
//Create reinforcement objects for each selected points
ObjRef[] objects = go.Objects();
if (objects != null)
{
reinfList = CreateReinfObjs(doc, objects, layerIndex, mName, diam);
}
return(reinfList);
}
protected override Result RunCommand(RhinoDoc doc, RunMode mode)
{
const Rhino.DocObjects.ObjectType geometryFilter = Rhino.DocObjects.ObjectType.Point;
Rhino.Input.Custom.GetObject go = new Rhino.Input.Custom.GetObject();
go.SetCommandPrompt("Pick all the points that you want to change to reinforcement.");
go.GeometryFilter = geometryFilter;
go.GroupSelect = true;
go.SubObjectSelect = false;
go.EnableClearObjectsOnEntry(false);
go.EnableUnselectObjectsOnExit(false);
go.DeselectAllBeforePostSelect = false;
bool bHavePreselectedObjects = false;
for (;;)
{
Rhino.Input.GetResult res = go.GetMultiple(1, 0);
/*
* if (res == Rhino.Input.GetResult.Option)
* {
* go.EnablePreSelect(false, true);
* continue;
* }
* else if (res != Rhino.Input.GetResult.Option)
* {
* return Rhino.Commands.Result.Cancel;
* }
*/
if (go.ObjectsWerePreselected)
{
bHavePreselectedObjects = true;
go.EnablePreSelect(false, true);
continue;
}
break;
}
List <Point3d> points = new List <Point3d>();
if (bHavePreselectedObjects)
{
for (int i = 0; i < go.ObjectCount; i++)
{
RhinoObject rhinoObject = go.Object(i).Object();
if (null != rhinoObject)
{
rhinoObject.Select(false);
}
}
doc.Views.Redraw();
}
int layerIndex = getLayerIndex(doc, "Reinforcement");
doc.Layers[layerIndex].Color = Color.Black;
if (layerIndex == 999)
{
return(Result.Failure);
}
ObjRef[] objects = go.Objects();
foreach (ObjRef obj in objects)
{
Point3d point = obj.Point().Location;
//TODO add the functionality how to assign different steel materials.
Reinforcement reinf = new Reinforcement(ProjectPlugIn.Instance.CurrentBeam)
{
Material = new SteelMaterial("B500B", SteelType.Reinforcement, ProjectPlugIn.Instance.CurrentBeam),
Centroid = point,
Diameter = 8
};
ObjectAttributes attr = new ObjectAttributes();
attr.UserData.Add(reinf);
attr.SetUserString("Name", "Reinforcement");
attr.LayerIndex = layerIndex;
//Unused code to create a hatch around the point
/*
* doc.Objects.AddCurve(reinf.OutLine,attr);
* ObjectAttributes attrHatch = new ObjectAttributes();
* attrHatch.LayerIndex = layerIndex;
* doc.Objects.AddHatch(reinf.Hatch, attrHatch);
*/
doc.Objects.ModifyAttributes(obj, attr, true);
}
return(Result.Success);
}
protected override Result RunCommand(RhinoDoc doc, RunMode mode)
{
bool bHavePreselectedObjects = false;
const ObjectType geometryFilter = ObjectType.MeshFace;
OptionDouble minEdgeLengthOption = new OptionDouble(minEdgeLength, 0.001, 200);
OptionDouble maxEdgeLengthOption = new OptionDouble(maxEdgeLength, 0.001, 200);
OptionDouble constriantAngleOption = new OptionDouble(constriantAngle, 0.001, 360);
OptionInteger smoothStepsOptions = new OptionInteger(smoothSteps, 0, 100);
OptionDouble smoothSpeedOption = new OptionDouble(smoothSpeed, 0.01, 1.0);
OptionDouble projectAmountOption = new OptionDouble(projectedAmount, 0.01, 1.0);
OptionDouble projectedDistanceOption = new OptionDouble(projectedDistance, 0.01, 100000.0);
GetObject go = new GetObject();
go.SetCommandPrompt("Select mesh faces to project onto another mesh");
go.GeometryFilter = geometryFilter;
go.AddOptionDouble("ConstraintAngle", ref constriantAngleOption);
go.AddOptionDouble("MinEdge", ref minEdgeLengthOption);
go.AddOptionDouble("MaxEdge", ref maxEdgeLengthOption);
go.AddOptionInteger("SmoothSteps", ref smoothStepsOptions);
go.AddOptionDouble("SmoothSpeed", ref smoothSpeedOption);
go.GroupSelect = true;
go.SubObjectSelect = true;
for (; ;)
{
GetResult faceres = go.GetMultiple(1, 0);
if (faceres == GetResult.Option)
{
go.EnablePreSelect(false, true);
continue;
}
else if (go.CommandResult() != Result.Success)
{
return(go.CommandResult());
}
if (go.ObjectsWerePreselected)
{
bHavePreselectedObjects = true;
go.EnablePreSelect(false, true);
continue;
}
break;
}
minEdgeLength = minEdgeLengthOption.CurrentValue;
maxEdgeLength = maxEdgeLengthOption.CurrentValue;
constriantAngle = constriantAngleOption.CurrentValue;
smoothSteps = smoothStepsOptions.CurrentValue;
smoothSpeed = smoothSpeedOption.CurrentValue;
//System.Collections.Generic.List<System.Guid> meshes = new System.Collections.Generic.List<System.Guid>();
System.Guid rhinoMesh = System.Guid.Empty;
System.Collections.Generic.List <int> removeFaces = new System.Collections.Generic.List <int>();
g3.DMesh3 projectFaces = new g3.DMesh3(true, false, false, false);
Rhino.Geometry.Mesh rhinoInputMesh = new Rhino.Geometry.Mesh();
for (int i = 0; i < go.ObjectCount; i++)
{
ObjRef obj = go.Object(i);
if (rhinoMesh == System.Guid.Empty)
{
rhinoMesh = obj.ObjectId;
rhinoInputMesh = obj.Mesh();
for (int j = 0; j < rhinoInputMesh.Vertices.Count; j++)
{
var vertex = new g3.NewVertexInfo();
vertex.n = new g3.Vector3f(rhinoInputMesh.Normals[j].X, rhinoInputMesh.Normals[j].Y, rhinoInputMesh.Normals[j].Z);
vertex.v = new g3.Vector3d(rhinoInputMesh.Vertices[j].X, rhinoInputMesh.Vertices[j].Y, rhinoInputMesh.Vertices[j].Z);
projectFaces.AppendVertex(vertex);
}
}
var m = rhinoInputMesh;
if (rhinoMesh != obj.ObjectId)
{
continue;
}
removeFaces.Add(obj.GeometryComponentIndex.Index);
var mf = rhinoInputMesh.Faces[obj.GeometryComponentIndex.Index];
if (mf.IsQuad)
{
double dist1 = m.Vertices[mf.A].DistanceTo(m.Vertices[mf.C]);
double dist2 = m.Vertices[mf.B].DistanceTo(m.Vertices[mf.D]);
if (dist1 > dist2)
{
projectFaces.AppendTriangle(mf.A, mf.B, mf.D);
projectFaces.AppendTriangle(mf.B, mf.C, mf.D);
}
else
{
projectFaces.AppendTriangle(mf.A, mf.B, mf.C);
projectFaces.AppendTriangle(mf.A, mf.C, mf.D);
}
}
else
{
projectFaces.AppendTriangle(mf.A, mf.B, mf.C);
}
}
if (rhinoInputMesh == null)
{
return(Result.Failure);
}
removeFaces.Sort();
removeFaces.Reverse();
foreach (var removeFace in removeFaces)
{
rhinoInputMesh.Faces.RemoveAt(removeFace);
}
rhinoInputMesh.Compact();
GetObject goProjected = new GetObject();
goProjected.EnablePreSelect(false, true);
goProjected.SetCommandPrompt("Select mesh to project to");
goProjected.GeometryFilter = ObjectType.Mesh;
goProjected.AddOptionDouble("ConstraintAngle", ref constriantAngleOption);
goProjected.AddOptionDouble("MinEdge", ref minEdgeLengthOption);
goProjected.AddOptionDouble("MaxEdge", ref maxEdgeLengthOption);
goProjected.AddOptionInteger("SmoothSteps", ref smoothStepsOptions);
goProjected.AddOptionDouble("SmoothSpeed", ref smoothSpeedOption);
goProjected.AddOptionDouble("ProjectAmount", ref projectAmountOption);
goProjected.AddOptionDouble("ProjectDistance", ref projectedDistanceOption);
goProjected.GroupSelect = true;
goProjected.SubObjectSelect = false;
goProjected.EnableClearObjectsOnEntry(false);
goProjected.EnableUnselectObjectsOnExit(false);
for (; ;)
{
GetResult resProject = goProjected.Get();
if (resProject == GetResult.Option)
{
continue;
}
else if (goProjected.CommandResult() != Result.Success)
{
return(goProjected.CommandResult());
}
break;
}
minEdgeLength = minEdgeLengthOption.CurrentValue;
maxEdgeLength = maxEdgeLengthOption.CurrentValue;
constriantAngle = constriantAngleOption.CurrentValue;
smoothSteps = smoothStepsOptions.CurrentValue;
smoothSpeed = smoothSpeedOption.CurrentValue;
projectedAmount = projectAmountOption.CurrentValue;
projectedDistance = projectedDistanceOption.CurrentValue;
if (bHavePreselectedObjects)
{
// Normally, pre-selected objects will remain selected, when a
// command finishes, and post-selected objects will be unselected.
// This this way of picking, it is possible to have a combination
// of pre-selected and post-selected. So, to make sure everything
// "looks the same", lets unselect everything before finishing
// the command.
for (int i = 0; i < go.ObjectCount; i++)
{
RhinoObject rhinoObject = go.Object(i).Object();
if (null != rhinoObject)
{
rhinoObject.Select(false);
}
}
doc.Views.Redraw();
}
bool result = false;
if (goProjected.ObjectCount < 1)
{
return(Result.Failure);
}
var rhinoMeshProject = goProjected.Object(0).Mesh();
if (rhinoMeshProject == null || !rhinoMeshProject.IsValid)
{
return(Result.Failure);
}
var meshProjected = GopherUtil.ConvertToD3Mesh(rhinoMeshProject);
var res = GopherUtil.RemeshMesh(projectFaces, (float)minEdgeLength, (float)maxEdgeLength, (float)constriantAngle, (float)smoothSpeed, smoothSteps, meshProjected, (float)projectedAmount, (float)projectedDistance);
var newRhinoMesh = GopherUtil.ConvertToRhinoMesh(res);
if (newRhinoMesh != null && newRhinoMesh.IsValid)
{
newRhinoMesh.Append(rhinoInputMesh);
result |= doc.Objects.Replace(rhinoMesh, newRhinoMesh);
}
doc.Views.Redraw();
return(Result.Success);
}
protected override Result RunCommand(RhinoDoc doc, RunMode mode)
{
const ObjectType geometryFilter = ObjectType.Mesh;
OptionDouble minEdgeLengthOption = new OptionDouble(minEdgeLength, 0.001, 200);
OptionDouble maxEdgeLengthOption = new OptionDouble(maxEdgeLength, 0.001, 200);
OptionDouble constriantAngleOption = new OptionDouble(constriantAngle, 0.001, 360);
OptionInteger smoothStepsOptions = new OptionInteger(smoothSteps, 0, 10000);
OptionDouble smoothSpeedOption = new OptionDouble(smoothSpeed, 0.01, 1.0);
GetObject go = new GetObject();
go.SetCommandPrompt("Select meshes to remesh");
go.GeometryFilter = geometryFilter;
go.AddOptionDouble("ConstraintAngle", ref constriantAngleOption);
go.AddOptionDouble("MinEdge", ref minEdgeLengthOption);
go.AddOptionDouble("MaxEdge", ref maxEdgeLengthOption);
go.AddOptionInteger("SmoothSteps", ref smoothStepsOptions);
go.AddOptionDouble("SmoothSpeed", ref smoothSpeedOption);
go.GroupSelect = true;
go.SubObjectSelect = false;
go.EnableClearObjectsOnEntry(false);
go.EnableUnselectObjectsOnExit(false);
go.DeselectAllBeforePostSelect = false;
bool bHavePreselectedObjects = false;
for (;;)
{
GetResult res = go.GetMultiple(1, 0);
if (res == GetResult.Option)
{
go.EnablePreSelect(false, true);
continue;
}
else if (go.CommandResult() != Result.Success)
{
return(go.CommandResult());
}
if (go.ObjectsWerePreselected)
{
bHavePreselectedObjects = true;
go.EnablePreSelect(false, true);
continue;
}
break;
}
minEdgeLength = minEdgeLengthOption.CurrentValue;
maxEdgeLength = maxEdgeLengthOption.CurrentValue;
constriantAngle = constriantAngleOption.CurrentValue;
smoothSteps = smoothStepsOptions.CurrentValue;
smoothSpeed = smoothSpeedOption.CurrentValue;
if (bHavePreselectedObjects)
{
// Normally, pre-selected objects will remain selected, when a
// command finishes, and post-selected objects will be unselected.
// This this way of picking, it is possible to have a combination
// of pre-selected and post-selected. So, to make sure everything
// "looks the same", lets unselect everything before finishing
// the command.
for (int i = 0; i < go.ObjectCount; i++)
{
RhinoObject rhinoObject = go.Object(i).Object();
if (null != rhinoObject)
{
rhinoObject.Select(false);
}
}
doc.Views.Redraw();
}
bool result = false;
foreach (var obj in go.Objects())
{
var rhinoMesh = obj.Mesh();
if (rhinoMesh == null || !rhinoMesh.IsValid)
{
continue;
}
var mesh = GopherUtil.ConvertToD3Mesh(obj.Mesh());
var res = GopherUtil.RemeshMesh(mesh, (float)minEdgeLength, (float)maxEdgeLength, (float)constriantAngle, (float)smoothSpeed, smoothSteps);
var newRhinoMesh = GopherUtil.ConvertToRhinoMesh(mesh);
if (newRhinoMesh != null && newRhinoMesh.IsValid)
{
doc.Objects.Replace(obj, newRhinoMesh);
}
if (newRhinoMesh != null && newRhinoMesh.IsValid)
{
result |= doc.Objects.Replace(obj, newRhinoMesh);
}
}
doc.Views.Redraw();
return(Result.Success);
}
protected override Result RunCommand(RhinoDoc doc, RunMode mode)
{
GetObject go = new GetObject();
go.SetCommandPrompt("Select surfaces, polysurfaces, or meshes");
go.GeometryFilter = ObjectType.Surface | ObjectType.PolysrfFilter | ObjectType.Mesh;
go.GroupSelect = true;
go.SubObjectSelect = false;
go.GetMultiple(1, 0);
if (go.CommandResult() != Result.Success)
{
return(go.CommandResult());
}
List <Mesh> InMeshes = new List <Mesh>(go.ObjectCount);
List <RhinoObject> InMeshObjects = new List <RhinoObject>(go.ObjectCount);
List <RhinoObject> InObjects = new List <RhinoObject>(go.ObjectCount);
for (int i = 0; i < go.ObjectCount; i++)
{
ObjRef objRef = go.Object(i);
Mesh mesh = objRef.Mesh();
if (null == mesh)
{
InObjects.Add(objRef.Object());
}
else
{
InMeshes.Add(mesh);
InMeshObjects.Add(objRef.Object());
}
}
ObjRef[] meshRefs = null;
if (InObjects.Count > 0)
{
meshRefs = RhinoObject.GetRenderMeshes(InObjects, true, false);
if (null != meshRefs)
{
for (int i = 0; i < meshRefs.Length; i++)
{
Mesh mesh = meshRefs[i].Mesh();
if (null != mesh)
{
InMeshes.Add(mesh);
}
}
}
}
RhinoViewport vp = doc.Views.ActiveView.ActiveViewport;
for (int i = 0; i < InMeshes.Count; i++)
{
Polyline[] plines = InMeshes[i].GetOutlines(vp);
if (null != plines)
{
for (int j = 0; j < plines.Length; j++)
{
Rhino.Geometry.PolylineCurve plineCrv = new PolylineCurve(plines[j]);
plineCrv.RemoveShortSegments(RhinoMath.SqrtEpsilon);
if (plineCrv.IsValid)
{
Guid objId = doc.Objects.AddCurve(plineCrv);
RhinoObject obj = doc.Objects.Find(objId);
if (null != obj)
{
obj.Select(true);
}
}
}
}
}
for (int i = 0; i < InObjects.Count; i++)
{
InObjects[i].Select(false);
}
for (int i = 0; i < InMeshObjects.Count; i++)
{
InMeshObjects[i].Select(false);
}
doc.Views.Redraw();
return(Result.Success);
}
protected override Result RunCommand(RhinoDoc doc, RunMode mode)
{
MyRhino5rs11project8PlugIn p = MyRhino5rs11project8PlugIn.Instance;
if (p.if_painted_object_set_ == false)
{
RhinoApp.WriteLine("No mesh");
return(Result.Failure);
}
Mesh my_mesh = p.painted_object_;
GetObject gbrep = new GetObject();
gbrep.SetCommandPrompt("get the brep");
gbrep.GeometryFilter = Rhino.DocObjects.ObjectType.Brep;
gbrep.SubObjectSelect = false;
gbrep.Get();
if (gbrep.CommandResult() != Rhino.Commands.Result.Success)
{
return(gbrep.CommandResult());
}
ObjRef my_objref = gbrep.Object(0);
RhinoObject my_obj = my_objref.Object();
if (my_obj == null)
{
return(Rhino.Commands.Result.Failure);
}
Brep brep = my_objref.Brep();
if (brep == null)
{
return(Result.Failure);
}
my_obj.Select(false);
int brep_number = 0;
for (int i = 0; i < p.my_objects_list.Count; i++)
{
Brep an_object = p.my_objects_list[i];
if (My_object_functions.GetComponentID(brep) == My_object_functions.GetComponentID(an_object))
{
brep_number = i;
break;
}
}
GetComponentPosition gp = new GetComponentPosition(brep, my_mesh);
gp.SetCommandPrompt("Get the object position on mesh: ");
gp.Constrain(my_mesh, false);
gp.Get();
if (gp.CommandResult() != Result.Success)
{
return(gp.CommandResult());
}
Point3d n_p = gp.Point();
List <Sphere> pin_ball_list;
Brep new_brep = GetComponentPosition.MoveBrep(brep, my_mesh, n_p, out pin_ball_list);
/*
* Point3d position = My_object_functions.GetPosition(new_brep);
* Vector3d d_x = My_object_functions.GetX(new_brep);
* Vector3d d_y = My_object_functions.GetY(new_brep);
* Vector3d d_z = My_object_functions.GetZ(new_brep);
* Line l_x = new Line(position, 10 * d_x);
* Line l_y = new Line(position, 10 * d_y);
* Line l_z = new Line(position, 10 * d_z);
*/
ObjectAttributes path_attributes = new ObjectAttributes();
path_attributes.ObjectColor = Color.Yellow;
path_attributes.ColorSource = ObjectColorSource.ColorFromObject;
path_attributes.PlotWeightSource = ObjectPlotWeightSource.PlotWeightFromObject;
path_attributes.PlotWeight = 2.0;
ObjectAttributes my_attributes = new ObjectAttributes();
my_attributes.ObjectColor = My_object_functions.GetColor(new_brep);
my_attributes.ColorSource = ObjectColorSource.ColorFromObject;
int new_pin_number = My_object_functions.GetPinQuantity(new_brep);
List <NurbsCurve> new_path_list = new List <NurbsCurve>();
for (int i = 0; i < new_pin_number; i++)
{
Guid pin_id = My_object_functions.GetPinGuid(new_brep, i);
Point3d pin_position = My_object_functions.GetPinPosition(new_brep, i);
MeshPoint pin_on_mesh = my_mesh.ClosestMeshPoint(pin_position, 0);
new_path_list = p.graph.DijkstraPath_Change(pin_id, pin_on_mesh);
}
IEnumerable <RhinoObject> path_objref = doc.Objects.GetObjectList(ObjectType.Curve);
foreach (RhinoObject path in path_objref)
{
doc.Objects.Delete(path, true);
}
for (int i = 0; i < new_path_list.Count; i++)
{
Guid path_id = new_path_list[i].UserDictionary.GetGuid("PathID");
path_attributes.ObjectId = path_id;
doc.Objects.AddCurve(new_path_list[i], path_attributes);
}
doc.Objects.Delete(my_objref, true);
/*
* IEnumerable<RhinoObject> rhino_objects = doc.Objects.GetObjectList(ObjectType.Brep);
* foreach (RhinoObject r_o in rhino_objects) { doc.Objects.Delete(r_o, true); }
*
* IEnumerable<RhinoObject> lines = doc.Objects.GetObjectList(ObjectType.Curve);
* foreach (RhinoObject r_o in lines) { doc.Objects.Delete(r_o, true); }
*/
doc.Objects.AddBrep(new_brep, my_attributes);
p.my_objects_list[brep_number] = new_brep;
/*
* foreach (Sphere s in pin_ball_list)
* { doc.Objects.AddSphere(s); }
* doc.Objects.AddLine(l_x, path_attributes);
* doc.Objects.AddLine(l_y, path_attributes);
* doc.Objects.AddLine(l_z, path_attributes);
*/
doc.Views.Redraw();
return(Result.Success);
}
protected override Result RunCommand(RhinoDoc doc, RunMode mode)
{
const ObjectType geometryFilter = ObjectType.Mesh;
OptionDouble minEdgeLengthOption = new OptionDouble(minEdgeLength, 0.001, 200);
OptionDouble maxEdgeLengthOption = new OptionDouble(maxEdgeLength, 0.001, 200);
OptionDouble constriantAngleOption = new OptionDouble(constriantAngle, 0.001, 360);
OptionInteger smoothStepsOptions = new OptionInteger(smoothSteps, 0, 1000);
OptionDouble smoothSpeedOption = new OptionDouble(smoothSpeed, 0.01, 1.0);
OptionDouble projectAmountOption = new OptionDouble(projectedAmount, 0.01, 1.0);
OptionDouble projectedDistanceOption = new OptionDouble(projectedDistance, 0.01, 100000.0);
GetObject go = new GetObject();
go.SetCommandPrompt("Select mesh to remesh");
go.GeometryFilter = geometryFilter;
go.AddOptionDouble("ConstraintAngle", ref constriantAngleOption);
go.AddOptionDouble("MinEdge", ref minEdgeLengthOption);
go.AddOptionDouble("MaxEdge", ref maxEdgeLengthOption);
go.AddOptionInteger("SmoothSteps", ref smoothStepsOptions);
go.AddOptionDouble("SmoothSpeed", ref smoothSpeedOption);
go.AddOptionDouble("ProjectAmount", ref projectAmountOption);
go.AddOptionDouble("ProjectDistance", ref projectedDistanceOption);
go.GroupSelect = true;
go.SubObjectSelect = false;
go.EnableClearObjectsOnEntry(false);
go.EnableUnselectObjectsOnExit(false);
go.DeselectAllBeforePostSelect = false;
bool bHavePreselectedObjects = false;
for (;;)
{
GetResult res = go.Get();
if (res == GetResult.Option)
{
go.EnablePreSelect(false, true);
continue;
}
else if (go.CommandResult() != Result.Success)
{
return(go.CommandResult());
}
if (go.ObjectsWerePreselected)
{
bHavePreselectedObjects = true;
go.EnablePreSelect(false, true);
continue;
}
break;
}
GetObject goProjected = new GetObject();
goProjected.EnablePreSelect(false, true);
goProjected.SetCommandPrompt("Select mesh to project to");
goProjected.GeometryFilter = geometryFilter;
goProjected.AddOptionDouble("ConstraintAngle", ref constriantAngleOption);
goProjected.AddOptionDouble("MinEdge", ref minEdgeLengthOption);
goProjected.AddOptionDouble("MaxEdge", ref maxEdgeLengthOption);
goProjected.AddOptionInteger("SmoothSteps", ref smoothStepsOptions);
goProjected.AddOptionDouble("SmoothSpeed", ref smoothSpeedOption);
goProjected.AddOptionDouble("ProjectAmount", ref projectAmountOption);
goProjected.AddOptionDouble("ProjectDistance", ref projectedDistanceOption);
goProjected.GroupSelect = true;
goProjected.SubObjectSelect = false;
goProjected.EnableClearObjectsOnEntry(false);
goProjected.EnableUnselectObjectsOnExit(false);
for (;;)
{
GetResult res = goProjected.Get();
if (res == GetResult.Option)
{
continue;
}
else if (goProjected.CommandResult() != Result.Success)
{
return(goProjected.CommandResult());
}
break;
}
minEdgeLength = minEdgeLengthOption.CurrentValue;
maxEdgeLength = maxEdgeLengthOption.CurrentValue;
constriantAngle = constriantAngleOption.CurrentValue;
smoothSteps = smoothStepsOptions.CurrentValue;
smoothSpeed = smoothSpeedOption.CurrentValue;
projectedAmount = projectAmountOption.CurrentValue;
projectedDistance = projectedDistanceOption.CurrentValue;
if (bHavePreselectedObjects)
{
// Normally, pre-selected objects will remain selected, when a
// command finishes, and post-selected objects will be unselected.
// This this way of picking, it is possible to have a combination
// of pre-selected and post-selected. So, to make sure everything
// "looks the same", lets unselect everything before finishing
// the command.
for (int i = 0; i < go.ObjectCount; i++)
{
RhinoObject rhinoObject = go.Object(i).Object();
if (null != rhinoObject)
{
rhinoObject.Select(false);
}
}
doc.Views.Redraw();
}
bool result = false;
if (goProjected.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());
var rhinoMeshProject = goProjected.Object(0).Mesh();
if (rhinoMeshProject == null || !rhinoMeshProject.IsValid)
{
continue;
}
var meshProjected = GopherUtil.ConvertToD3Mesh(rhinoMeshProject);
var mesh2 = new DMesh3(mesh);
var mesh3 = new DMesh3(mesh);
var res3 = GopherUtil.RemeshMesh(mesh3, (float)minEdgeLength, (float)maxEdgeLength, (float)constriantAngle, (float)smoothSpeed, smoothSteps, meshProjected, (float)projectedAmount, (float)projectedDistance);
var watch = System.Diagnostics.Stopwatch.StartNew();
// the code that you want to measure comes here
var res = GopherUtil.RemeshMesh(mesh, (float)minEdgeLength, (float)maxEdgeLength, (float)constriantAngle, (float)smoothSpeed, smoothSteps, meshProjected, (float)projectedAmount, (float)projectedDistance);
watch.Stop();
var watch2 = System.Diagnostics.Stopwatch.StartNew();
var res2 = GopherUtil.RemeshMeshNew(mesh2, (float)minEdgeLength, (float)maxEdgeLength, (float)constriantAngle, (float)smoothSpeed, smoothSteps, meshProjected, (float)projectedAmount, (float)projectedDistance);
watch2.Stop();
Rhino.RhinoApp.WriteLine("Time 1: {0} Time 2: {1}", watch.ElapsedMilliseconds, watch2.ElapsedMilliseconds);
var newRhinoMesh = GopherUtil.ConvertToRhinoMesh(res);
var newRhinoMesh2 = GopherUtil.ConvertToRhinoMesh(mesh2);
newRhinoMesh2.Translate(new Rhino.Geometry.Vector3d(newRhinoMesh2.GetBoundingBox(true).Diagonal.X, 0, 0));
doc.Objects.Add(newRhinoMesh2);
if (newRhinoMesh != null && newRhinoMesh.IsValid)
{
doc.Objects.Replace(obj, newRhinoMesh);
}
if (newRhinoMesh != null && newRhinoMesh.IsValid)
{
result |= doc.Objects.Replace(obj, newRhinoMesh);
}
}
doc.Views.Redraw();
return(Result.Success);
}
protected override Result RunCommand(RhinoDoc doc, RunMode mode)
{
const ObjectType geometryFilter = ObjectType.Mesh;
OptionDouble minEdgeLengthOption = new OptionDouble(minEdgeLength, 0.001, 200);
OptionInteger maxTriangleCountOption = new OptionInteger(maxTriangleCount, 0, 100000000);
GetObject go = new GetObject();
go.SetCommandPrompt("Select meshes to reduce");
go.GeometryFilter = geometryFilter;
go.AddOptionDouble("MinEdge", ref minEdgeLengthOption);
go.AddOptionInteger("MaxTriangle", ref maxTriangleCountOption);
go.GroupSelect = true;
go.SubObjectSelect = false;
go.EnableClearObjectsOnEntry(false);
go.EnableUnselectObjectsOnExit(false);
go.DeselectAllBeforePostSelect = false;
bool bHavePreselectedObjects = false;
for (;;)
{
GetResult res = go.GetMultiple(1, 0);
if (res == GetResult.Option)
{
go.EnablePreSelect(false, true);
continue;
}
else if (go.CommandResult() != Result.Success)
return go.CommandResult();
if (go.ObjectsWerePreselected)
{
bHavePreselectedObjects = true;
go.EnablePreSelect(false, true);
continue;
}
break;
}
maxTriangleCount = maxTriangleCountOption.CurrentValue;
minEdgeLength = minEdgeLengthOption.CurrentValue;
if (bHavePreselectedObjects)
{
// Normally, pre-selected objects will remain selected, when a
// command finishes, and post-selected objects will be unselected.
// This this way of picking, it is possible to have a combination
// of pre-selected and post-selected. So, to make sure everything
// "looks the same", lets unselect everything before finishing
// the command.
for (int i = 0; i < go.ObjectCount; i++)
{
RhinoObject rhinoObject = go.Object(i).Object();
if (null != rhinoObject)
rhinoObject.Select(false);
}
doc.Views.Redraw();
}
bool result = false;
foreach (var obj in go.Objects())
{
var rhinoMesh = obj.Mesh();
if (rhinoMesh == null || !rhinoMesh.IsValid)
continue;
var mesh = GopherUtil.ConvertToD3Mesh(obj.Mesh());
GopherUtil.ReduceMesh(mesh, (float)minEdgeLength, maxTriangleCount);
double mine, maxe, avge;
MeshQueries.EdgeLengthStats(mesh, out mine, out maxe, out avge);
RhinoApp.WriteLine("Edge length stats: {0} {1} {2}", mine, maxe, avge);
var newRhinoMesh = GopherUtil.ConvertToRhinoMesh(mesh);
if (newRhinoMesh != null && newRhinoMesh.IsValid)
{
doc.Objects.Replace(obj, newRhinoMesh);
}
if (newRhinoMesh != null && newRhinoMesh.IsValid)
{
result |= doc.Objects.Replace(obj, newRhinoMesh);
}
}
doc.Views.Redraw();
return Result.Success;
}
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)
{
// TODO: complete command.
MyRhino5rs11project8PlugIn p = MyRhino5rs11project8PlugIn.Instance;
if (p.if_painted_object_set_ == false)
{
RhinoApp.WriteLine("No mesh");
return(Result.Failure);
}
Mesh my_mesh = p.painted_object_;
GetObject gbrep = new GetObject();
gbrep.SetCommandPrompt("get the brep");
gbrep.GeometryFilter = Rhino.DocObjects.ObjectType.Brep;
gbrep.SubObjectSelect = false;
gbrep.Get();
if (gbrep.CommandResult() != Rhino.Commands.Result.Success)
{
return(gbrep.CommandResult());
}
ObjRef my_objref = gbrep.Object(0);
RhinoObject my_obj = my_objref.Object();
if (my_obj == null)
{
return(Rhino.Commands.Result.Failure);
}
Brep brep = my_objref.Brep();
if (brep == null)
{
return(Result.Failure);
}
my_obj.Select(false);
int brep_number = 0;
for (int i = 0; i < p.my_objects_list.Count; i++)
{
Brep an_object = p.my_objects_list[i];
if (My_object_functions.GetComponentID(brep) == My_object_functions.GetComponentID(an_object))
{
brep_number = i;
break;
}
}
Point3d position = My_object_functions.GetPosition(brep);
Vector3d normal_direction = My_object_functions.GetZ(brep);
Plane plane = new Plane(position, normal_direction);
/*
* GetPoint gp = new GetPoint();
* gp.Constrain(plane, false);
* gp.Get();
* if (gp.CommandResult() != Result.Success)
* return gp.CommandResult();
* var start_point = gp.Point();
* if (start_point == Point3d.Unset)
* return Result.Failure;
*/
Vector3d horizontal_direction = My_object_functions.GetY(brep);
Point3d start_point = position + 10 * horizontal_direction;
GetRotationAngle gr = new GetRotationAngle(brep, my_mesh, start_point);
gr.SetCommandPrompt("Get the rotation angle");
gr.Constrain(plane, false);
gr.Get();
if (gr.CommandResult() != Result.Success)
{
return(gr.CommandResult());
}
Point3d end_point = gr.Point();
Brep new_brep = GetRotationAngle.RotateBrep(brep, my_mesh, end_point, start_point);
ObjectAttributes path_attributes = new ObjectAttributes();
path_attributes.ObjectColor = Color.Yellow;
path_attributes.ColorSource = ObjectColorSource.ColorFromObject;
path_attributes.PlotWeightSource = ObjectPlotWeightSource.PlotWeightFromObject;
path_attributes.PlotWeight = 2.0;
ObjectAttributes my_attributes = new ObjectAttributes();
my_attributes.ObjectColor = My_object_functions.GetColor(new_brep);
my_attributes.ColorSource = ObjectColorSource.ColorFromObject;
int new_pin_number = My_object_functions.GetPinQuantity(new_brep);
List <NurbsCurve> new_path_list = new List <NurbsCurve>();
for (int i = 0; i < new_pin_number; i++)
{
Guid pin_id = My_object_functions.GetPinGuid(new_brep, i);
Point3d pin_position = My_object_functions.GetPinPosition(new_brep, i);
MeshPoint pin_on_mesh = my_mesh.ClosestMeshPoint(pin_position, 0);
new_path_list = p.graph.DijkstraPath_Change(pin_id, pin_on_mesh);
}
IEnumerable <RhinoObject> path_objref = doc.Objects.GetObjectList(ObjectType.Curve);
foreach (RhinoObject path in path_objref)
{
doc.Objects.Delete(path, true);
}
for (int i = 0; i < new_path_list.Count; i++)
{
Guid path_id = new_path_list[i].UserDictionary.GetGuid("PathID");
path_attributes.ObjectId = path_id;
doc.Objects.AddCurve(new_path_list[i], path_attributes);
}
doc.Objects.Delete(my_objref, true);
doc.Objects.AddBrep(new_brep, my_attributes);
p.my_objects_list[brep_number] = new_brep;
doc.Views.Redraw();
return(Result.Success);
}
/// <summary>
/// Creates the layout.
/// </summary>
/// <param name="doc">The document.</param>
/// <param name="panel">The panel.</param>
/// <param name="panelParas">The panel paras.</param>
/// <returns></returns>
public Result createLayout(RhinoDoc doc, FoldedPerforationPanel panel, PanelParameters panelParas)
{
if (panelParas == null)
{
panelParas = new PanelParameters();
}
if (panel == null)
{
panel = new FoldedPerforationPanel();
}
// Get all selected Objects
GetObject go = new GetObject();
go.GroupSelect = true;
go.SubObjectSelect = false;
go.EnableClearObjectsOnEntry(false);
go.EnableUnselectObjectsOnExit(false);
go.DeselectAllBeforePostSelect = false;
go.EnableSelPrevious(true);
go.EnablePreSelect(true, false);
go.EnablePressEnterWhenDonePrompt(false);
go.SetCommandPrompt("Select items for the new layout:");
// Disable the scaling
RhinoApp.RunScript("_-DocumentProperties AnnotationStyles ModelSpaceScaling=Disabled LayoutSpaceScaling=Disabled _Enter _Enter", true);
GetResult result = go.GetMultiple(1, -1);
if (go.CommandResult() != Rhino.Commands.Result.Success)
{
return(go.CommandResult());
}
RhinoApp.WriteLine("Total Objects Selected: {0}", go.ObjectCount);
string labelName = panel.PartName;
string area = string.Format("{0:0.00}", panel.Area);
Point2d minPoint = new Point2d(0, 0);
Point2d maxPoint = new Point2d(0, 0);
// Loop through all the objects to find Text
for (int i = 0; i < go.ObjectCount; i++)
{
BoundingBox bBox = go.Object(i).Object().Geometry.GetBoundingBox(true);
if (bBox.Min.X < minPoint.X)
{
minPoint.X = bBox.Min.X;
}
if (bBox.Min.Y < minPoint.Y)
{
minPoint.Y = bBox.Min.Y;
}
if (bBox.Max.X > maxPoint.X)
{
maxPoint.X = bBox.Max.X;
}
if (bBox.Max.Y > maxPoint.Y)
{
maxPoint.Y = bBox.Max.Y;
}
}
// If the selected items has no label, return failure
if (labelName == null)
{
return(Rhino.Commands.Result.Failure);
}
// Hide all the non selected objects
foreach (var obj in doc.Objects)
{
if (obj.IsSelected(true) == 0)
{
doc.Objects.Hide(obj, false);
}
}
// Add layout
doc.PageUnitSystem = Rhino.UnitSystem.Millimeters;
RhinoView currentView = doc.Views.ActiveView;
var pageview = doc.Views.AddPageView(string.Format("{0}", labelName), 210, 297);
Point2d bottomLeft = new Point2d(10, 70);
Point2d topRight = new Point2d(200, 287);
if (pageview != null)
{
pageview.SetPageAsActive();
var detail = pageview.AddDetailView("Panel", bottomLeft, topRight, Rhino.Display.DefinedViewportProjection.Top);
// Show all objects
RhinoApp.RunScript("_-Show _Enter", true);
if (detail != null)
{
pageview.SetActiveDetail(detail.Id);
doc.Views.ActiveView = pageview;
//doc.Views.Redraw();
// Select all the objects
for (int i = 0; i < go.ObjectCount; i++)
{
RhinoObject rhinoObject = go.Object(i).Object();
rhinoObject.Select(true);
}
// Hide all the non selected objects
var filter = new ObjectEnumeratorSettings
{
NormalObjects = true,
LockedObjects = false,
HiddenObjects = false,
ActiveObjects = true,
ReferenceObjects = true
};
var rh_objects = doc.Objects.FindByFilter(filter);
pageview.SetPageAsActive();
//doc.Views.Redraw();
foreach (var rh_obj in rh_objects)
{
var select = 0 == rh_obj.IsSelected(false) && rh_obj.IsSelectable();
rh_obj.Select(select);
}
RhinoApp.RunScript("_-HideInDetail Enter", true);
detail.IsActive = false;
}
bottomLeft = new Point2d(10, 40);
topRight = new Point2d(135, 70);
detail = pageview.AddDetailView("Sample", bottomLeft, topRight, Rhino.Display.DefinedViewportProjection.Top);
// doc.Views.Redraw();
pageview.SetActiveDetail(detail.Id);
detail.Viewport.SetCameraLocation(new Point3d(50, 160, 0), true);
detail.CommitViewportChanges();
// doc.Views.Redraw();
detail.DetailGeometry.IsProjectionLocked = true;
detail.DetailGeometry.SetScale(4.5, doc.ModelUnitSystem, 1, doc.PageUnitSystem);
detail.CommitChanges();
// doc.Views.Redraw();
detail.IsActive = true;
pageview.SetActiveDetail(detail.Id);
RhinoApp.WriteLine("Name = {0}: Width = {1}, Height = {2}",
detail.Viewport.Name, detail.Viewport.Size.Width, detail.Viewport.Size.Height);
detail.CommitViewportChanges();
// doc.Views.Redraw();
detail.IsActive = false;
bottomLeft = new Point2d(5, 5);
topRight = new Point2d(205, 35);
detail = pageview.AddDetailView("Block", bottomLeft, topRight, Rhino.Display.DefinedViewportProjection.Top);
// doc.Views.Redraw();
detail.IsActive = true;
pageview.SetActiveDetail(detail.Id);
detail.Viewport.SetCameraLocation(new Point3d(105, 520, 0), true);
detail.CommitViewportChanges();
// doc.Views.Redraw();
detail.DetailGeometry.IsProjectionLocked = true;
detail.DetailGeometry.SetScale(1, doc.ModelUnitSystem, 1, doc.PageUnitSystem);
detail.CommitChanges();
detail.IsActive = false;
// doc.Views.Redraw();
drawBlock(doc, labelName, area, panel.PanelNumber, panelParas);
// doc.Views.Redraw();
}
// Show all objects
RhinoApp.RunScript("_-Show _Enter", true);
doc.Views.DefaultViewLayout();
doc.Views.ActiveView = currentView;
return(Result.Success);
}
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);
}