protected override Result RunCommand(RhinoDoc doc, RunMode mode)
{
m_doc = doc;
m_window = new Window {Title = "Object ID and Thread ID", Width = 500, Height = 75};
m_label = new Label();
m_window.Content = m_label;
new System.Windows.Interop.WindowInteropHelper(m_window).Owner = Rhino.RhinoApp.MainWindowHandle();
m_window.Show();
// register the rhinoObjectAdded method with the AddRhinoObject event
RhinoDoc.AddRhinoObject += RhinoObjectAdded;
// add a sphere from the main UI thread. All is good
AddSphere(new Point3d(0,0,0));
// add a sphere from a secondary thread. Not good: the rhinoObjectAdded method
// doesn't work well when called from another thread
var add_sphere_delegate = new Action<Point3d>(AddSphere);
add_sphere_delegate.BeginInvoke(new Point3d(0, 10, 0), null, null);
// handle the AddRhinoObject event with rhinoObjectAddedSafe which is
// desgined to work no matter which thread the call is comming from.
RhinoDoc.AddRhinoObject -= RhinoObjectAdded;
RhinoDoc.AddRhinoObject += RhinoObjectAddedSafe;
// try again adding a sphere from a secondary thread. All is good!
add_sphere_delegate.BeginInvoke(new Point3d(0, 20, 0), null, null);
doc.Views.Redraw();
return Result.Success;
}
protected override Result RunCommand(RhinoDoc doc, RunMode mode)
{
var gp = new GetPoint();
gp.SetCommandPrompt("Start:");
if (gp.Get() != GetResult.Point)
{
RhinoApp.WriteLine("No point selected.");
return gp.CommandResult();
}
var location = gp.Point();
var dialog = new BBTextDialog();
if (dialog.ShowDialog()!= true)
return Result.Cancel;
var typeWriter = dialog.Bold ? Typewriter.Bold : Typewriter.Regular;
var x = doc.Views.ActiveView.ActiveViewport.CameraX;
var y = doc.Views.ActiveView.ActiveViewport.CameraY;
var unitX = x * dialog.Size;
var unitY = y * dialog.Size;
var curves = typeWriter.Write(dialog.Text, location, unitX, unitY, dialog.HAlign, dialog.VAlign);
doc.Groups.Add(curves.Select(curve => doc.Objects.AddCurve(curve)));
doc.Views.Redraw();
return Result.Success;
}
public static Result MeshVolume(RhinoDoc doc)
{
var gm = new GetObject();
gm.SetCommandPrompt("Select solid meshes for volume calculation");
gm.GeometryFilter = ObjectType.Mesh;
gm.GeometryAttributeFilter = GeometryAttributeFilter.ClosedMesh;
gm.SubObjectSelect = false;
gm.GroupSelect = true;
gm.GetMultiple(1, 0);
if (gm.CommandResult() != Result.Success)
return gm.CommandResult();
double volume = 0.0;
double volume_error = 0.0;
foreach (var obj_ref in gm.Objects())
{
if (obj_ref.Mesh() != null)
{
var mass_properties = VolumeMassProperties.Compute(obj_ref.Mesh());
if (mass_properties != null)
{
volume += mass_properties.Volume;
volume_error += mass_properties.VolumeError;
}
}
}
RhinoApp.WriteLine("Total volume = {0:f} (+/- {1:f})", volume, volume_error);
return Result.Success;
}
public static Result ReparameterizeCurve(RhinoDoc doc)
{
ObjRef obj_ref;
var rc = RhinoGet.GetOneObject("Select curve to reparameterize", false, ObjectType.Curve, out obj_ref);
if (rc != Result.Success)
return rc;
var curve = obj_ref.Curve();
if (curve == null)
return Result.Failure;
double domain_start = 0;
rc = RhinoGet.GetNumber("Domain start", false, ref domain_start);
if (rc != Result.Success)
return rc;
double domain_end = 0;
rc = RhinoGet.GetNumber("Domain end", false, ref domain_end);
if (rc != Result.Success)
return rc;
if (Math.Abs(curve.Domain.T0 - domain_start) < RhinoMath.ZeroTolerance &&
Math.Abs(curve.Domain.T1 - domain_end) < RhinoMath.ZeroTolerance)
return Result.Nothing;
var curve_copy = curve.DuplicateCurve();
curve_copy.Domain = new Interval(domain_start, domain_end);
if (!doc.Objects.Replace(obj_ref, curve_copy))
return Result.Failure;
else
{
doc.Views.Redraw();
return Result.Success;
}
}
public static Rhino.Commands.Result SelByUserText(RhinoDoc doc)
{
// You don't have to override RunCommand if you don't need any user input. In
// this case we want to get a key from the user. If you return something other
// than Success, the selection is canceled
return Rhino.Input.RhinoGet.GetString("key", true, ref m_key);
}
public static Result ReplaceHatchPattern(RhinoDoc doc)
{
ObjRef[] obj_refs;
var rc = RhinoGet.GetMultipleObjects("Select hatches to replace", false, ObjectType.Hatch, out obj_refs);
if (rc != Result.Success || obj_refs == null)
return rc;
var gs = new GetString();
gs.SetCommandPrompt("Name of replacement hatch pattern");
gs.AcceptNothing(false);
gs.Get();
if (gs.CommandResult() != Result.Success)
return gs.CommandResult();
var hatch_name = gs.StringResult();
var pattern_index = doc.HatchPatterns.Find(hatch_name, true);
if (pattern_index < 0)
{
RhinoApp.WriteLine("The hatch pattern \"{0}\" not found in the document.", hatch_name);
return Result.Nothing;
}
foreach (var obj_ref in obj_refs)
{
var hatch_object = obj_ref.Object() as HatchObject;
if (hatch_object.HatchGeometry.PatternIndex != pattern_index)
{
hatch_object.HatchGeometry.PatternIndex = pattern_index;
hatch_object.CommitChanges();
}
}
doc.Views.Redraw();
return Result.Success;
}
public static Result ModifyObjectColor(RhinoDoc doc)
{
ObjRef obj_ref;
var rc = RhinoGet.GetOneObject("Select object", false, ObjectType.AnyObject, out obj_ref);
if (rc != Result.Success)
return rc;
var rhino_object = obj_ref.Object();
var color = rhino_object.Attributes.ObjectColor;
bool b = Rhino.UI.Dialogs.ShowColorDialog(ref color);
if (!b) return Result.Cancel;
rhino_object.Attributes.ObjectColor = color;
rhino_object.Attributes.ColorSource = ObjectColorSource.ColorFromObject;
rhino_object.CommitChanges();
// an object's color attributes can also be specified
// when the object is added to Rhino
var sphere = new Sphere(Point3d.Origin, 5.0);
var attributes = new ObjectAttributes();
attributes.ObjectColor = Color.CadetBlue;
attributes.ColorSource = ObjectColorSource.ColorFromObject;
doc.Objects.AddSphere(sphere, attributes);
doc.Views.Redraw();
return Result.Success;
}
public static Result SetActiveView(RhinoDoc doc)
{
// view and view names
var active_view_name = doc.Views.ActiveView.ActiveViewport.Name;
var non_active_views =
doc.Views
.Where(v => v.ActiveViewport.Name != active_view_name)
.ToDictionary(v => v.ActiveViewport.Name, v => v);
// get name of view to set active
var gs = new GetString();
gs.SetCommandPrompt("Name of view to set active");
gs.AcceptNothing(true);
gs.SetDefaultString(active_view_name);
foreach (var view_name in non_active_views.Keys)
gs.AddOption(view_name);
var result = gs.Get();
if (gs.CommandResult() != Result.Success)
return gs.CommandResult();
var selected_view_name =
result == GetResult.Option ? gs.Option().EnglishName : gs.StringResult();
if (selected_view_name != active_view_name)
if (non_active_views.ContainsKey(selected_view_name))
doc.Views.ActiveView = non_active_views[selected_view_name];
else
RhinoApp.WriteLine("\"{0}\" is not a view name", selected_view_name);
return Rhino.Commands.Result.Success;
}
protected override Rhino.Commands.Result RunCommand(RhinoDoc doc, Rhino.Commands.RunMode mode)
{
// make sure our custom visual analysis mode is registered
var zmode = Rhino.Display.VisualAnalysisMode.Register(typeof(ZAnalysisMode));
const ObjectType filter = Rhino.DocObjects.ObjectType.Surface | Rhino.DocObjects.ObjectType.PolysrfFilter | Rhino.DocObjects.ObjectType.Mesh;
Rhino.DocObjects.ObjRef[] objs;
var rc = Rhino.Input.RhinoGet.GetMultipleObjects("Select objects for Z analysis", false, filter, out objs);
if (rc != Rhino.Commands.Result.Success)
return rc;
int count = 0;
for (int i = 0; i < objs.Length; i++)
{
var obj = objs[i].Object();
// see if this object is alreay in Z analysis mode
if (obj.InVisualAnalysisMode(zmode))
continue;
if (obj.EnableVisualAnalysisMode(zmode, true))
count++;
}
doc.Views.Redraw();
RhinoApp.WriteLine("{0} objects were put into Z-Analysis mode.", count);
return Rhino.Commands.Result.Success;
}
protected override Result RunCommand(RhinoDoc doc, RunMode mode)
{
Loop loop = new Loop();
loop.Run(doc);
return Result.Success;
}
public static Result Ortho(RhinoDoc doc)
{
var gp = new GetPoint();
gp.SetCommandPrompt("Start of line");
gp.Get();
if (gp.CommandResult() != Result.Success)
return gp.CommandResult();
var start_point = gp.Point();
var original_ortho = ModelAidSettings.Ortho;
if (!original_ortho)
ModelAidSettings.Ortho = true;
gp.SetCommandPrompt("End of line");
gp.SetBasePoint(start_point, false);
gp.DrawLineFromPoint(start_point, true);
gp.Get();
if (gp.CommandResult() != Result.Success)
return gp.CommandResult();
var end_point = gp.Point();
if (ModelAidSettings.Ortho != original_ortho)
ModelAidSettings.Ortho = original_ortho;
doc.Objects.AddLine(start_point, end_point);
doc.Views.Redraw();
return Result.Success;
}
public static Result DrawMesh(RhinoDoc doc)
{
var gs = new GetObject();
gs.SetCommandPrompt("select sphere");
gs.GeometryFilter = ObjectType.Surface;
gs.DisablePreSelect();
gs.SubObjectSelect = false;
gs.Get();
if (gs.CommandResult() != Result.Success)
return gs.CommandResult();
Sphere sphere;
gs.Object(0).Surface().TryGetSphere(out sphere);
if (sphere.IsValid)
{
var mesh = Mesh.CreateFromSphere(sphere, 10, 10);
if (mesh == null)
return Result.Failure;
var conduit = new DrawBlueMeshConduit(mesh) {Enabled = true};
doc.Views.Redraw();
var in_str = "";
Rhino.Input.RhinoGet.GetString("press <Enter> to continue", true, ref in_str);
conduit.Enabled = false;
doc.Views.Redraw();
return Result.Success;
}
else
return Result.Failure;
}
/// <summary>
/// Commmand.RunCommand override
/// </summary>
protected override Rhino.Commands.Result RunCommand(RhinoDoc doc, RunMode mode)
{
Rhino.Commands.Result rc = Rhino.Commands.Result.Success;
if (!_bIsLoaded)
{
string script = ScriptFromResources(ResourceName, Password);
if (!string.IsNullOrEmpty(script))
{
string macro = string.Format("_-RunScript ({0})", script);
if (RhinoApp.RunScript(macro, false))
_bIsLoaded = true;
else
rc = Result.Failure;
}
}
if (rc == Result.Success)
{
string macro = string.Format("_-RunScript ({0})", EnglishName);
RhinoApp.RunScript(macro, false);
}
return rc;
}
public static Result ViewportResolution(RhinoDoc doc)
{
var active_viewport = doc.Views.ActiveView.ActiveViewport;
RhinoApp.WriteLine("Name = {0}: Width = {1}, Height = {2}",
active_viewport.Name, active_viewport.Size.Width, active_viewport.Size.Height);
return Result.Success;
}
public static Result NurbsCurveIncreaseDegree(RhinoDoc doc)
{
ObjRef obj_ref;
var rc = RhinoGet.GetOneObject(
"Select curve", false, ObjectType.Curve, out obj_ref);
if (rc != Result.Success) return rc;
if (obj_ref == null) return Result.Failure;
var curve = obj_ref.Curve();
if (curve == null) return Result.Failure;
var nurbs_curve = curve.ToNurbsCurve();
int new_degree = -1;
rc = RhinoGet.GetInteger(string.Format("New degree <{0}...11>", nurbs_curve.Degree), true, ref new_degree,
nurbs_curve.Degree, 11);
if (rc != Result.Success) return rc;
rc = Result.Failure;
if (nurbs_curve.IncreaseDegree(new_degree))
if (doc.Objects.Replace(obj_ref.ObjectId, nurbs_curve))
rc = Result.Success;
RhinoApp.WriteLine("Result: {0}", rc.ToString());
doc.Views.Redraw();
return rc;
}
public void BakeGeometry(RhinoDoc doc, ObjectAttributes att, List<Guid> obj_ids)
{
List<Text3d>.Enumerator tag;
if (att == null)
{
att = doc.CreateDefaultAttributes();
}
try
{
tag = this.m_tags.GetEnumerator();
while (tag.MoveNext())
{
Text3d tag3d = tag.Current;
Guid id = doc.Objects.AddText(tag3d, att);
if (!(id == Guid.Empty))
{
obj_ids.Add(id);
}
}
}
finally
{
tag.Dispose();
}
}
protected override Rhino.Commands.Result RunCommand(RhinoDoc doc, Rhino.Commands.RunMode mode)
{
// You don't have to override RunCommand if you don't need any user input. In
// this case we want to get a key from the user. If you return something other
// than Success, the selection is canceled
return Rhino.Input.RhinoGet.GetString("key", true, ref m_key);
}
protected override Result RunCommand(RhinoDoc doc, RunMode mode)
{
var points = new List<Point3d>
{
new Point3d(0, 0, 0),
new Point3d(0, 0, 1),
new Point3d(0, 1, 0),
new Point3d(0, 1, 1),
new Point3d(1, 0, 0),
new Point3d(1, 0, 1),
new Point3d(1, 1, 0),
new Point3d(1, 1, 1)
};
RhinoApp.WriteLine("Before sort ...");
foreach (var point in points)
RhinoApp.WriteLine("point: {0}", point);
var sorted_points = Point3d.SortAndCullPointList(points, doc.ModelAbsoluteTolerance);
RhinoApp.WriteLine("After sort ...");
foreach (var point in sorted_points)
RhinoApp.WriteLine("point: {0}", point);
doc.Objects.AddPoints(sorted_points);
doc.Views.Redraw();
return Result.Success;
}
protected override Result RunCommand(RhinoDoc doc, RunMode mode)
{
var file_name = "";
var bitmap = doc.Views.ActiveView.CaptureToBitmap(true, true, true);
bitmap.MakeTransparent();
// copy bitmap to clipboard
Clipboard.SetImage(bitmap);
// save bitmap to file
var save_file_dialog = new Rhino.UI.SaveFileDialog
{
Filter = "*.bmp",
InitialDirectory = Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments)
};
if (save_file_dialog.ShowDialog() == DialogResult.OK)
{
file_name = save_file_dialog.FileName;
}
if (file_name != "")
bitmap.Save(file_name);
return Rhino.Commands.Result.Success;
}
protected override Rhino.Commands.Result RunCommand(RhinoDoc doc, Rhino.Commands.RunMode mode)
{
var conduit = new PointsConduit(m_conduit_points);
conduit.Enabled = true;
var gp = new Rhino.Input.Custom.GetPoint();
while (true)
{
gp.SetCommandPrompt("click location to create point. (<ESC> exit)");
gp.AcceptNothing(true);
gp.Get();
if (gp.CommandResult() != Rhino.Commands.Result.Success)
break;
m_conduit_points.Add(new ConduitPoint(gp.Point()));
doc.Views.Redraw();
}
var gcp = new GetConduitPoint(m_conduit_points);
while (true)
{
gcp.SetCommandPrompt("select conduit point. (<ESC> to exit)");
gcp.AcceptNothing(true);
gcp.Get(true);
doc.Views.Redraw();
if (gcp.CommandResult() != Rhino.Commands.Result.Success)
break;
}
return Rhino.Commands.Result.Success;
}
protected override Result RunCommand(RhinoDoc doc, RunMode mode)
{
Rhino.DocObjects.ObjRef objref;
var rc = RhinoGet.GetOneObject("Select curve", true, ObjectType.Curve,out objref);
if(rc!= Result.Success)
return rc;
var curve = objref.Curve();
if( curve==null )
return Result.Failure;
var gp = new GetPoint();
gp.SetCommandPrompt("Pick a location on the curve");
gp.Constrain(curve, false);
gp.Get();
if (gp.CommandResult() != Result.Success)
return gp.CommandResult();
var point = gp.Point();
double closest_point_param;
if (curve.ClosestPoint(point, out closest_point_param))
{
RhinoApp.WriteLine("point: ({0}), parameter: {1}", point, closest_point_param);
doc.Objects.AddPoint(point);
doc.Views.Redraw();
}
return Result.Success;
}
protected override Result RunCommand(RhinoDoc doc, RunMode mode)
{
var go = new Rhino.Input.Custom.GetObject();
go.SetCommandPrompt("Select objects");
go.EnablePreSelect(true, true);
go.EnablePostSelect(true);
go.GetMultiple(0, 0);
if (go.CommandResult() != Result.Success)
return go.CommandResult();
var selected_objects = go.Objects().ToList();
if (go.ObjectsWerePreselected)
{
go.EnablePreSelect(false, true);
go.DeselectAllBeforePostSelect = false;
go.EnableUnselectObjectsOnExit(false);
go.GetMultiple(0, 0);
if (go.CommandResult() == Result.Success)
{
foreach (var obj in go.Objects())
{
selected_objects.Add(obj);
// The normal behavior of commands is that when they finish,
// objects that were pre-selected remain selected and objects
// that were post-selected will not be selected. Because we
// potentially could have both, we'll try to do something
// consistent and make sure post-selected objects also stay selected
obj.Object().Select(true);
}
}
}
return selected_objects.Count > 0 ? Result.Success : Result.Nothing;
}
public static Result CopyGroups(RhinoDoc doc)
{
var go = new Rhino.Input.Custom.GetObject();
go.SetCommandPrompt("Select objects to copy in place");
go.GroupSelect = true;
go.SubObjectSelect = false;
go.GetMultiple(1, 0);
if (go.CommandResult() != Result.Success)
return go.CommandResult();
var xform = Transform.Identity;
var group_map = new Dictionary<int, int>();
foreach (var obj_ref in go.Objects())
{
if (obj_ref != null)
{
var obj = obj_ref.Object();
var duplicate = doc.Objects.Transform(obj_ref.ObjectId, xform, false);
RhinoUpdateObjectGroups(ref obj, ref group_map);
}
}
doc.Views.Redraw();
return Result.Success;
}
protected override Result RunCommand(RhinoDoc doc, RunMode mode)
{
RcCore.It.EngineSettings.SaveDebugImages = !RcCore.It.EngineSettings.SaveDebugImages;
var saving = RcCore.It.EngineSettings.SaveDebugImages ? "Saving" : "Not saving";
RhinoApp.WriteLine($"{saving} debug images");
return Result.Success;
}
public static Result CreateMeshFromBrep(RhinoDoc doc)
{
ObjRef obj_ref;
var rc = RhinoGet.GetOneObject("Select surface or polysurface to mesh", true, ObjectType.Surface | ObjectType.PolysrfFilter, out obj_ref);
if (rc != Result.Success)
return rc;
var brep = obj_ref.Brep();
if (null == brep)
return Result.Failure;
// you could choose anyone of these for example
var jagged_and_faster = MeshingParameters.Coarse;
var smooth_and_slower = MeshingParameters.Smooth;
var default_mesh_params = MeshingParameters.Default;
var minimal = MeshingParameters.Minimal;
var meshes = Mesh.CreateFromBrep(brep, smooth_and_slower);
if (meshes == null || meshes.Length == 0)
return Result.Failure;
var brep_mesh = new Mesh();
foreach (var mesh in meshes)
brep_mesh.Append(mesh);
doc.Objects.AddMesh(brep_mesh);
doc.Views.Redraw();
return Result.Success;
}
protected override Result RunCommand(RhinoDoc doc, RunMode mode)
{
// Get the name of the instance definition to rename
string instance_definition_name = "";
var rc = RhinoGet.GetString("Name of block to delete", true, ref instance_definition_name);
if (rc != Result.Success)
return rc;
if (string.IsNullOrWhiteSpace(instance_definition_name))
return Result.Nothing;
// Verify instance definition exists
var instance_definition = doc.InstanceDefinitions.Find(instance_definition_name, true);
if (instance_definition == null) {
RhinoApp.WriteLine("Block \"{0}\" not found.", instance_definition_name);
return Result.Nothing;
}
// Verify instance definition can be deleted
if (instance_definition.IsReference) {
RhinoApp.WriteLine("Unable to delete block \"{0}\".", instance_definition_name);
return Result.Nothing;
}
// delete block and all references
if (!doc.InstanceDefinitions.Delete(instance_definition.Index, true, true)) {
RhinoApp.WriteLine("Could not delete {0} block", instance_definition.Name);
return Result.Failure;
}
return Result.Success;
}
protected override Result RunCommand(RhinoDoc doc, RunMode mode)
{
Plugin.InitialiseCSycles();
if (doc.Views.ActiveView.ActiveViewport.DisplayMode.Id == Guid.Parse("69E0C7A5-1C6A-46C8-B98B-8779686CD181"))
{
var rvp = doc.Views.ActiveView.RealtimeDisplayMode as RenderedViewport;
if (rvp != null)
{
var getNumber = new GetInteger();
getNumber.SetLowerLimit(1, true);
getNumber.SetDefaultInteger(rvp.HudMaximumPasses()+100);
getNumber.SetCommandPrompt("Set new sample count");
var getRc = getNumber.Get();
if (getNumber.CommandResult() != Result.Success) return getNumber.CommandResult();
if (getRc == GetResult.Number)
{
var nr = getNumber.Number();
RhinoApp.WriteLine($"User changes samples to {nr}");
rvp.ChangeSamples(nr);
return Result.Success;
}
}
}
RhinoApp.WriteLine("Active view isn't rendering with Cycles");
return Result.Nothing;
}
public static Result Leader(RhinoDoc doc)
{
var points = new Point3d[]
{
new Point3d(1, 1, 0),
new Point3d(5, 1, 0),
new Point3d(5, 5, 0),
new Point3d(9, 5, 0)
};
var xy_plane = Plane.WorldXY;
var points2d = new List<Point2d>();
foreach (var point3d in points)
{
double x, y;
if (xy_plane.ClosestParameter(point3d, out x, out y))
{
var point2d = new Point2d(x, y);
if (points2d.Count < 1 || point2d.DistanceTo(points2d.Last<Point2d>()) > RhinoMath.SqrtEpsilon)
points2d.Add(point2d);
}
}
doc.Objects.AddLeader(xy_plane, points2d);
doc.Views.Redraw();
return Result.Success;
}
public static Result PickPoint(RhinoDoc doc)
{
// this creates a point where the mouse is clicked.
var gp = new GetPoint();
gp.SetCommandPrompt("Click for new point");
gp.Get();
if (gp.CommandResult() != Result.Success)
return gp.CommandResult();
var point3d = gp.Point();
doc.Objects.AddPoint(point3d);
doc.Views.Redraw();
// selects a point that already exists
ObjRef obj_ref;
var rc = RhinoGet.GetOneObject("Select point", false, ObjectType.Point, out obj_ref);
if (rc != Result.Success)
return rc;
var point = obj_ref.Point();
RhinoApp.WriteLine("Point: x:{0}, y:{1}, z:{2}",
point.Location.X,
point.Location.Y,
point.Location.Z);
doc.Objects.UnselectAll();
// selects multiple points that already exist
ObjRef[] obj_refs;
rc = RhinoGet.GetMultipleObjects("Select point", false, ObjectType.Point, out obj_refs);
if (rc != Result.Success)
return rc;
foreach (var o_ref in obj_refs)
{
point = o_ref.Point();
RhinoApp.WriteLine("Point: x:{0}, y:{1}, z:{2}",
point.Location.X,
point.Location.Y,
point.Location.Z);
}
doc.Objects.UnselectAll();
// also selects a point that already exists.
// Used when RhinoGet doesn't provide enough control
var go = new GetObject();
go.SetCommandPrompt("Select point");
go.GeometryFilter = ObjectType.Point;
go.GetMultiple(1, 0);
if (go.CommandResult() != Result.Success)
return go.CommandResult();
foreach (var o_ref in go.Objects())
{
point = o_ref.Point();
if (point != null)
RhinoApp.WriteLine("Point: x:{0}, y:{1}, z:{2}",
point.Location.X,
point.Location.Y,
point.Location.Z);
}
doc.Views.Redraw();
return Result.Success;
}
public static Result SelectObjectsInObjectGroups(RhinoDoc doc)
{
ObjRef obj_ref;
var rs = RhinoGet.GetOneObject(
"Select object", false, ObjectType.AnyObject, out obj_ref);
if (rs != Result.Success)
return rs;
var rhino_object = obj_ref.Object();
if (rhino_object == null)
return Result.Failure;
var rhino_object_groups = rhino_object.Attributes.GetGroupList().DefaultIfEmpty(-1);
var selectable_objects= from obj in doc.Objects.GetObjectList(ObjectType.AnyObject)
where obj.IsSelectable(true, false, false, false)
select obj;
foreach (var selectable_object in selectable_objects)
{
foreach (var group in selectable_object.Attributes.GetGroupList())
{
if (rhino_object_groups.Contains(group))
{
selectable_object.Select(true);
continue;
}
}
}
doc.Views.Redraw();
return Result.Success;
}
public static void DecomposeObj(RhinoDoc doc, Layer layer, RhinoObject obj, Brep brep, ref int progressCurrentIndex, ref int progressShowedPercent, int progressMax, bool beforeFixAllIssues, int objsInLayerCount = -1)
{
//if (objsInLayerCount == -1)
//{
// objsInLayerCount = layer._GetObjsCount(doc, false, ObjectType.Brep);
//}
var newLayerIndex = GetNewLayer(doc, layer, obj, beforeFixAllIssues);
int index = 0;
int nameLength = 1;
if (brep.Faces.Count >= 10)
{
nameLength = 2;
}
if (brep.Faces.Count >= 100)
{
nameLength = 3;
}
if (brep.Faces.Count >= 1000)
{
nameLength = 4;
}
if (brep.Faces.Count >= 10000)
{
nameLength = 5;
}
foreach (BrepFace face in brep.Faces_ThreadSafe())
{
index++;
// Duplicate brep
var face_copy = face.DuplicateFace(true);
var id = doc.Objects.AddBrep(face_copy, new ObjectAttributes()
{
LayerIndex = newLayerIndex,
Visible = true,
Name = index.ToString("D" + nameLength),
});
// Add to group
if (id != Guid.Empty && obj.GroupCount > 0)
{
foreach (var groupId in obj.GetGroupList())
{
doc.Groups.AddToGroup(groupId, id);
}
}
// Show progress
progressCurrentIndex++;
var progressCurrentPercent = 100 - ((progressMax - progressCurrentIndex) * 100 / progressMax);
if (progressCurrentPercent - progressShowedPercent >= 1)
{
progressShowedPercent = progressCurrentPercent;
log.rawText(g.SolidNavigator, ".");
}
}
obj._Delete();
}
/// <summary>
/// Write rhino object to ArcGIS feature layer
/// </summary>
/// <param name="mapLayer"></param>
/// <param name="ro"></param>
public static async void ThrowItOverTheFence(BasicFeatureLayer mapLayer, RhinoObject ro, RhinoDoc rhinoDoc)
{
Mesh mesh = null;
var createOperation = new EditOperation();
var projection = mapLayer.GetSpatialReference();
var origin = getOrigin(rhinoDoc);
switch (ro.Geometry.ObjectType)
{
case ObjectType.Point:
{
Point pt = ro.Geometry as Point;
MapPoint mp = ptToGis(pt.Location, origin);
createOperation.Create(mapLayer, mp);
await createOperation.ExecuteAsync();
break;
}
case ObjectType.Surface:
{
Surface srf = ro.Geometry as Surface;
if (!srf.IsPlanar())
{
Console.Out.WriteLine($"Unable to send non-planar surfaces: Guid: ${ro.Id}");
break;
}
goto case ObjectType.Brep;
}
case ObjectType.Curve:
{
Curve c = ro.Geometry as Curve;
var ptList = getPointsFromCurves(new List <Curve>()
{
c
});
var gisPts = ptList.Select(p => ptToGis(p, origin)).ToList();
var polyline = PolylineBuilder.CreatePolyline(gisPts, projection);
createOperation.Create(mapLayer, polyline);
await createOperation.ExecuteAsync();
break;
}
case ObjectType.Brep:
{
Brep brep = ro.Geometry as Brep;
if (brep.IsSolid)
{
mesh = Mesh.CreateFromBrep(brep, MeshingParameters.Default)[0];
goto case ObjectType.Mesh;
}
else
{
var crvs = new List <Curve>();
foreach (BrepEdge ed in brep.Edges)
{
crvs.Add(ed.EdgeCurve);
}
var pts = getPointsFromCurves(crvs);
var gisPts = pts.Select(p => ptToGis(p, origin)).ToList();
var polygon = new PolygonBuilder(gisPts).ToGeometry();
createOperation.Create(mapLayer, polygon);
await createOperation.ExecuteAsync();
break;
}
}
case ObjectType.Extrusion:
{
mesh = (ro.Geometry as Extrusion).GetMesh(MeshType.Default);
goto case ObjectType.Mesh;
}
case ObjectType.Mesh:
{
mesh = mesh ?? ro.Geometry as Mesh;
break;
}
default:
{
Console.Out.WriteLine($"Unable to send geometry type: ${ro.Geometry.ObjectType}");
break;
}
}
}
public static void Zoom(RhinoDoc doc, IEnumerable<RhinoObject> objects, double fitFactor = 3, bool resetCameraPosition = false)
{
Zoom(doc, objects.Select(o => o.Geometry), fitFactor, resetCameraPosition);
}
internal Group(int index, RhinoDoc doc)
{
m_id = UnsafeNativeMethods.CRhinoGroupTable_IdFromIndex(doc.RuntimeSerialNumber, index);
m_doc = doc;
m__parent = m_doc;
}
internal GroupTable(RhinoDoc doc) : base(doc)
{
}
/// <summary>
/// Draws the perforation.
/// </summary>
/// <param name="boundaryCurve">The boundary curve.</param>
/// <returns></returns>
public override double drawPerforation(Curve boundaryCurve)
{
List <PointMap> pointMapList = new List <PointMap>();
Random random = new Random();
PointMap pointMapTool1 = new PointMap();
int tool0count = 0;
int tool1count = 0;
int tool2count = 0;
double marginX;
pointMapList.Add(pointMapTool1);
// Find the boundary
BoundingBox boundingBox = boundaryCurve.GetBoundingBox(Plane.WorldXY);
Point3d min = boundingBox.Min;
Point3d max = boundingBox.Max;
double spanX = max.X - min.X;
double spanY = max.Y - min.Y;
double gap = xSpacing - punchingToolList[2].X;
// Maximum punching qty
int punchQtyX = ((int)((spanX - punchingToolList[2].X) / XSpacing)) + 1;
// PunchQty need to add 1 if the last bit can fit the small rectangle
if (spanX - (punchingToolList[2].X * punchQtyX) > (punchingToolList[0].X + gap))
{
punchQtyX = punchQtyX + 1;
}
// Find the location of the first punch
if (spanX >= ((punchQtyX - 1) * XSpacing + punchingToolList[2].X))
{
marginX = (spanX - ((punchQtyX - 2) * XSpacing) - (punchingToolList[2].X) - gap) / 2;
}
else if (spanX >= ((punchQtyX - 1) * XSpacing + punchingToolList[1].X))
{
marginX = (spanX - ((punchQtyX - 2) * XSpacing) - (punchingToolList[1].X) - gap) / 2;
}
else
{
marginX = (spanX - ((punchQtyX - 2) * XSpacing) - (punchingToolList[0].X) - gap) / 2;
}
int punchQtyY = ((int)((spanY - punchingToolList[0].Y) / YSpacing)) + 1;
double marginY = (spanY - ((punchQtyY - 1) * YSpacing)) / 2;
Point3d point;
RhinoDoc doc = RhinoDoc.ActiveDoc;
double firstX = min.X + marginX;
double firstY = min.Y + marginY;
// Record the current layer
int currentLayer = doc.Layers.CurrentLayerIndex;
// Create Perforation Layer
//if (punchingToolList[0].ClusterTool.Enable == true)
{
doc.Layers.SetCurrentLayerIndex(currentLayer, true);
}
//else
//{
// if (!MetrixUtilities.IsLayerFound("TemporaryPerfLayer"))
// {
// RhinoUtilities.SetActiveLayer(Properties.Settings.Default.ToolHitLayerName, System.Drawing.Color.Black);
// }
// else
// {
// RhinoUtilities.SetActiveLayer("TemporaryToolHit", System.Drawing.Color.Black);
// }
//}
// Random Engine
RandomTiler randomTileEngine = new RandomTiler();
int totalQty = (punchQtyX + 1) * punchQtyY;
int toolHitQty = (int)(totalQty * randomness);
int blankQty = totalQty - toolHitQty;
List <int> tileCounts = new List <int>();
tileCounts.Add(toolHitQty);
tileCounts.Add(blankQty);
int[,] tileMap = randomTileEngine.GetTileMap(tileCounts, punchQtyX + 1, punchQtyY);
Point3d pointMedL;
Point3d pointMedR;
Point3d pointShortL;
Point3d pointShortR;
Point3d pointLeft, pointRight, pointTop, pointBottom;
double toolOffset = XSpacing / 6;
double rowOffset = XSpacing / 3;
for (int y = 0; y < punchQtyY; y++)
{
if (y % 3 == 0) // Long tool row
{
// first X
firstX = min.X + marginX;
}
else if (y % 3 == 1) // Med tool row
{
firstX = min.X + marginX - rowOffset;
}
else // short tool rows
{
firstX = min.X + marginX - (2 * rowOffset);
}
bool isBorderPunch = false;
for (int x = 0; x < punchQtyX + 1; x++)
{
point = new Point3d(firstX + x * XSpacing, firstY + y * YSpacing, 0);
pointMedL = new Point3d(firstX + x * XSpacing - toolOffset, firstY + y * YSpacing, 0);
pointMedR = new Point3d(firstX + x * XSpacing + toolOffset, firstY + y * YSpacing, 0);
pointShortL = new Point3d(firstX + x * XSpacing - 2 * toolOffset, firstY + y * YSpacing, 0);
pointShortR = new Point3d(firstX + x * XSpacing + 2 * toolOffset, firstY + y * YSpacing, 0);
pointLeft = new Point3d(firstX + (x - 1) * XSpacing, firstY + y * YSpacing, 0);
pointRight = new Point3d(firstX + (x + 1) * XSpacing, firstY + y * YSpacing, 0);
pointTop = new Point3d(firstX + x * XSpacing, firstY + (y + 1) * YSpacing, 0);
pointBottom = new Point3d(firstX + (x + 1) * XSpacing, firstY + (y - 1) * YSpacing, 0);
// Test if the current punch is close to border
isBorderPunch = false;
if (punchingToolList[0].isInside(boundaryCurve, pointLeft) == false)
{
isBorderPunch = true;
}
if (punchingToolList[0].isInside(boundaryCurve, pointRight) == false)
{
isBorderPunch = true;
}
if (punchingToolList[0].isInside(boundaryCurve, pointTop) == false)
{
isBorderPunch = true;
}
if (punchingToolList[0].isInside(boundaryCurve, pointBottom) == false)
{
isBorderPunch = true;
}
if (isBorderPunch == true || tileMap[x, y] == 1)
{
if (punchingToolList[2].isInside(boundaryCurve, point) == true)
{
pointMapTool1.AddPoint(new PunchingPoint(point));
punchingToolList[2].drawTool(point);
tool2count++;
}
else if (punchingToolList[1].isInside(boundaryCurve, pointMedL) == true)
{
pointMapTool1.AddPoint(new PunchingPoint(pointMedL));
punchingToolList[1].drawTool(pointMedL);
tool1count++;
}
else if (punchingToolList[1].isInside(boundaryCurve, pointMedR) == true)
{
pointMapTool1.AddPoint(new PunchingPoint(pointMedR));
punchingToolList[1].drawTool(pointMedR);
tool1count++;
}
else if (punchingToolList[0].isInside(boundaryCurve, pointShortL) == true)
{
pointMapTool1.AddPoint(new PunchingPoint(pointShortL));
punchingToolList[0].drawTool(pointShortL);
tool0count++;
}
else if (punchingToolList[0].isInside(boundaryCurve, pointShortR) == true)
{
pointMapTool1.AddPoint(new PunchingPoint(pointShortR));
punchingToolList[0].drawTool(pointShortR);
tool0count++;
}
}
}
}
// Display the open area calculation
AreaMassProperties area = AreaMassProperties.Compute(boundaryCurve);
RhinoApp.WriteLine("Total area: {0} mm^2", area.Area.ToString("#.##"));
double tool0Area = punchingToolList[0].getArea() * tool0count;
double tool1Area = punchingToolList[1].getArea() * tool1count;
double tool2Area = punchingToolList[2].getArea() * tool2count;
RhinoApp.WriteLine("Tool 1 area: {0} mm^2", tool0Area.ToString("#.##"));
RhinoApp.WriteLine("Tool 2 area: {0} mm^2", tool1Area.ToString("#.##"));
RhinoApp.WriteLine("Tool 3 area: {0} mm^2", tool2Area.ToString("#.##"));
openArea = (tool0Area + tool1Area + tool2Area) * 100 / area.Area;
RhinoApp.WriteLine("Open area: {0}%", openArea.ToString("#."));
// Draw the cluster for each tool
for (int i = 0; i < punchingToolList.Count; i++)
{
// Only draw cluster tool if it is enable
if (punchingToolList[i].ClusterTool.Enable == true)
{
// Draw the cluster tool
drawCluster(pointMapList[i], punchingToolList[i]);
}
}
doc.Views.Redraw();
doc.Layers.SetCurrentLayerIndex(currentLayer, true);
return(openArea);
}
/// <summary>
/// Draws the perforation.
/// </summary>
/// <returns></returns>
public override double drawPerforation(Curve boundaryCurve)
{
List <PointMap> pointMapList = new List <PointMap>();
Random random = new Random();
PointMap pointMapTool0 = new PointMap();
PointMap pointMapTool1 = new PointMap();
pointMapList.Add(pointMapTool0);
pointMapList.Add(pointMapTool1);
double marginX;
// Find the boundary
BoundingBox boundingBox = boundaryCurve.GetBoundingBox(Plane.WorldXY);
Point3d min = boundingBox.Min;
Point3d max = boundingBox.Max;
double spanX = max.X - min.X;
double spanY = max.Y - min.Y;
int punchQtyX = ((int)((spanX - punchingToolList[0].X) / XSpacing)) + 1;
double secondRowOffset = pitch * Math.Cos(Math.PI * 60 / 180);
if (spanX >= ((punchQtyX - 1) * XSpacing + secondRowOffset + punchingToolList[0].X))
{
marginX = (spanX - ((punchQtyX - 1) * XSpacing) - secondRowOffset) / 2;
}
else
{
marginX = (spanX - ((punchQtyX - 1) * XSpacing)) / 2;
}
int punchQtyY = ((int)((spanY - punchingToolList[0].Y) / YSpacing)) + 1;
double marginY = (spanY - ((punchQtyY - 1) * YSpacing)) / 2;
Point3d point;
RhinoDoc doc = RhinoDoc.ActiveDoc;
double firstX = min.X + marginX;
double firstY = min.Y + marginY;
// Record the current layer
int currentLayer = doc.Layers.CurrentLayerIndex;
// Create Perforation Layer
// if (punchingToolList[0].ClusterTool.Enable == true)
{
doc.Layers.SetCurrentLayerIndex(currentLayer, true);
}
//else
//{
// if (!MetrixUtilities.IsLayerFound("TemporaryPerfLayer"))
// {
// RhinoUtilities.SetActiveLayer(Properties.Settings.Default.ToolHitLayerName, System.Drawing.Color.Black);
// }
// else
// {
// RhinoUtilities.SetActiveLayer("TemporaryToolHit", System.Drawing.Color.Black);
// }
//}
int rightSide = 0;
bool hasSlot = false;
int slotPercentage = 0;
int slotQty;
for (int y = 0; y < punchQtyY; y++)
{
if (y % 3 == 1)
{
hasSlot = true;
slotPercentage = random.Next(10, 105);
if (slotPercentage > 100)
{
slotPercentage = 100;
}
rightSide++;
if (rightSide > 2)
{
rightSide = 0;
}
}
else
{
hasSlot = false;
}
if (y % 2 == 0) // even rows
{
// Slot propagate from the left
if (hasSlot == true && rightSide < 2)
{
slotQty = (int)(slotPercentage * punchQtyX / 100);
int x;
for (x = 1; x < slotQty; x += 3)
{
point = new Point3d(firstX + x * XSpacing, firstY + y * YSpacing, 0);
if (punchingToolList[1].isInside(boundaryCurve, point) == true)
{
pointMapList[1].AddPoint(new PunchingPoint(point));
punchingToolList[1].drawTool(point);
}
}
if (slotQty == punchQtyX && slotQty % 3 != 0)
{
x = punchQtyX - (punchQtyX % 3) + 1;
}
for (x = x - 1; x < punchQtyX; x++)
{
point = new Point3d(firstX + x * XSpacing, firstY + y * YSpacing, 0);
if (punchingToolList[0].isInside(boundaryCurve, point) == true)
{
pointMapList[0].AddPoint(new PunchingPoint(point));
punchingToolList[0].drawTool(point);
}
}
}
else if (hasSlot == true && rightSide == 2)
{
slotQty = (int)(slotPercentage * punchQtyX / 100);
int x;
int holeQty = punchQtyX - slotQty;
holeQty = (int)(holeQty / 3) * 3;
for (x = 0; x < holeQty; x++)
{
point = new Point3d(firstX + x * XSpacing, firstY + y * YSpacing, 0);
if (punchingToolList[0].isInside(boundaryCurve, point) == true)
{
pointMapList[0].AddPoint(new PunchingPoint(point));
punchingToolList[0].drawTool(point);
}
}
for (x = x + 1; x < punchQtyX; x += 3)
{
point = new Point3d(firstX + x * XSpacing, firstY + y * YSpacing, 0);
if (punchingToolList[1].isInside(boundaryCurve, point) == true)
{
pointMapList[1].AddPoint(new PunchingPoint(point));
punchingToolList[1].drawTool(point);
}
}
if (punchQtyX % 3 != 0)
{
x = punchQtyX - (punchQtyX % 3);
}
for (; x < punchQtyX; x++)
{
point = new Point3d(firstX + x * XSpacing, firstY + y * YSpacing, 0);
if (punchingToolList[0].isInside(boundaryCurve, point) == true)
{
pointMapList[0].AddPoint(new PunchingPoint(point));
punchingToolList[0].drawTool(point);
}
}
}
else
{
for (int x = 0; x < punchQtyX; x++)
{
point = new Point3d(firstX + x * XSpacing, firstY + y * YSpacing, 0);
if (punchingToolList[0].isInside(boundaryCurve, point) == true)
{
pointMapList[0].AddPoint(new PunchingPoint(point));
punchingToolList[0].drawTool(point);
}
}
}
}
else // odd rows
{
// Slot propagate from the left
if (hasSlot == true && rightSide < 2)
{
slotQty = (int)(slotPercentage * punchQtyX / 100);
int x;
for (x = 1; x < slotQty; x += 3)
{
point = new Point3d(firstX + secondRowOffset + (x * XSpacing), firstY + y * YSpacing, 0);
if (punchingToolList[1].isInside(boundaryCurve, point) == true)
{
pointMapList[1].AddPoint(new PunchingPoint(point));
punchingToolList[1].drawTool(point);
}
}
if (slotQty == punchQtyX && slotQty % 3 != 0)
{
x = punchQtyX - (punchQtyX % 3) + 1;
}
for (x = x - 1; x < punchQtyX; x++)
{
point = new Point3d(firstX + secondRowOffset + (x * XSpacing), firstY + y * YSpacing, 0);
if (punchingToolList[0].isInside(boundaryCurve, point) == true)
{
pointMapList[0].AddPoint(new PunchingPoint(point));
punchingToolList[0].drawTool(point);
}
}
}
else if (hasSlot == true && rightSide == 2)
{
slotQty = (int)(slotPercentage * punchQtyX / 100);
int x;
int holeQty = punchQtyX - slotQty;
holeQty = (int)(holeQty / 3) * 3;
for (x = 0; x < holeQty; x++)
{
point = new Point3d(firstX + secondRowOffset + (x * XSpacing), firstY + y * YSpacing, 0);
if (punchingToolList[0].isInside(boundaryCurve, point) == true)
{
pointMapList[0].AddPoint(new PunchingPoint(point));
punchingToolList[0].drawTool(point);
}
}
for (x = x + 1; x < punchQtyX; x += 3)
{
point = new Point3d(firstX + secondRowOffset + (x * XSpacing), firstY + y * YSpacing, 0);
if (punchingToolList[1].isInside(boundaryCurve, point) == true)
{
pointMapList[1].AddPoint(new PunchingPoint(point));
punchingToolList[1].drawTool(point);
}
}
if (punchQtyX % 3 != 0)
{
x = punchQtyX - (punchQtyX % 3);
}
for (; x < punchQtyX; x++)
{
point = new Point3d(firstX + secondRowOffset + (x * XSpacing), firstY + y * YSpacing, 0);
if (punchingToolList[0].isInside(boundaryCurve, point) == true)
{
pointMapList[0].AddPoint(new PunchingPoint(point));
punchingToolList[0].drawTool(point);
}
}
}
else
{
for (int x = 0; x < punchQtyX; x++)
{
point = new Point3d(firstX + secondRowOffset + (x * XSpacing), firstY + y * YSpacing, 0);
if (punchingToolList[0].isInside(boundaryCurve, point) == true)
{
pointMapList[0].AddPoint(new PunchingPoint(point));
punchingToolList[0].drawTool(point);
}
}
}
}
}
// Display the open area calculation
AreaMassProperties area = AreaMassProperties.Compute(boundaryCurve);
RhinoApp.WriteLine("Total area: {0} mm^2", area.Area.ToString("#.##"));
double tool1Area = punchingToolList[0].getArea() * pointMapList[0].Count;
RhinoApp.WriteLine("Tool 1 area: {0} mm^2", tool1Area.ToString("#.##"));
double tool2Area = punchingToolList[1].getArea() * pointMapList[1].Count;
RhinoApp.WriteLine("Tool 2 area: {0} mm^2", tool2Area.ToString("#.##"));
openArea = (tool1Area + tool2Area) * 100 / area.Area;
RhinoApp.WriteLine("Open area: {0}%", openArea.ToString("#."));
// Draw the cluster for each tool
for (int i = 0; i < punchingToolList.Count; i++)
{
// Only draw cluster tool if it is enable
if (punchingToolList[i].ClusterTool.Enable == true)
{
// Draw the cluster tool
drawCluster(pointMapList[i], punchingToolList[i]);
}
}
doc.Views.Redraw();
doc.Layers.SetCurrentLayerIndex(currentLayer, true);
return(openArea);
}
internal static void AuditUnits(RhinoDoc doc)
{
if (Command.InScriptRunnerCommand())
{
return;
}
if (Revit.ActiveUIDocument?.Document is DB.Document revitDoc)
{
var units = revitDoc.GetUnits();
var lengthFormatoptions = units.GetFormatOptions(DB.UnitType.UT_Length);
var RevitModelUnitSystem = lengthFormatoptions.DisplayUnits.ToUnitSystem();
var GrasshopperModelUnitSystem = GH.Guest.ModelUnitSystem != UnitSystem.Unset ? GH.Guest.ModelUnitSystem : doc.ModelUnitSystem;
if (doc.ModelUnitSystem != RevitModelUnitSystem || doc.ModelUnitSystem != GrasshopperModelUnitSystem)
{
var hasUnits = doc.ModelUnitSystem != UnitSystem.Unset && doc.ModelUnitSystem != UnitSystem.None;
var expandedContent = doc.IsOpening ?
$"The Rhino model you are opening is in {doc.ModelUnitSystem}{Environment.NewLine}Revit document '{revitDoc.Title}' length units are {RevitModelUnitSystem}" :
string.Empty;
using
(
var taskDialog = new TaskDialog("Units")
{
MainIcon = External.UI.TaskDialogIcons.IconInformation,
TitleAutoPrefix = true,
AllowCancellation = hasUnits,
MainInstruction = hasUnits ? (doc.IsOpening ? "Model units mismatch." : "Model units mismatch warning.") : "Rhino model has no units.",
MainContent = doc.IsOpening ? "What units do you want to use?" : $"Revit document '{revitDoc.Title}' length units are {RevitModelUnitSystem}." + (hasUnits ? $"{Environment.NewLine}Rhino is working in {doc.ModelUnitSystem}." : string.Empty),
ExpandedContent = expandedContent,
FooterText = "Current version: " + Addin.DisplayVersion
}
)
{
if (!doc.IsOpening && hasUnits)
{
#if REVIT_2020
taskDialog.EnableDoNotShowAgain("RhinoInside.Revit.DocumentUnitsMismatch", true, "Do not show again");
#else
// Without the ability of checking DoNotShowAgain this may be too anoying.
return;
#endif
}
else
{
taskDialog.AddCommandLink(Autodesk.Revit.UI.TaskDialogCommandLinkId.CommandLink2, $"Use {RevitModelUnitSystem} like Revit", $"Scale Rhino model by {UnitScale(doc.ModelUnitSystem, RevitModelUnitSystem)}");
taskDialog.DefaultButton = Autodesk.Revit.UI.TaskDialogResult.CommandLink2;
}
if (hasUnits)
{
if (doc.IsOpening)
{
taskDialog.AddCommandLink(Autodesk.Revit.UI.TaskDialogCommandLinkId.CommandLink1, $"Continue in {doc.ModelUnitSystem}", $"Rhino and Grasshopper will work in {doc.ModelUnitSystem}");
taskDialog.DefaultButton = Autodesk.Revit.UI.TaskDialogResult.CommandLink1;
}
else
{
taskDialog.CommonButtons = Autodesk.Revit.UI.TaskDialogCommonButtons.Ok;
taskDialog.DefaultButton = Autodesk.Revit.UI.TaskDialogResult.Ok;
}
}
if (GH.Guest.ModelUnitSystem != UnitSystem.Unset)
{
taskDialog.ExpandedContent += $"{Environment.NewLine}Documents opened in Grasshopper were working in {GH.Guest.ModelUnitSystem}";
if (GrasshopperModelUnitSystem != doc.ModelUnitSystem && GrasshopperModelUnitSystem != RevitModelUnitSystem)
{
taskDialog.AddCommandLink(Autodesk.Revit.UI.TaskDialogCommandLinkId.CommandLink3, $"Adjust Rhino model to {GH.Guest.ModelUnitSystem} like Grasshopper", $"Scale Rhino model by {UnitScale(doc.ModelUnitSystem, GH.Guest.ModelUnitSystem)}");
taskDialog.DefaultButton = Autodesk.Revit.UI.TaskDialogResult.CommandLink3;
}
}
switch (taskDialog.Show())
{
case Autodesk.Revit.UI.TaskDialogResult.CommandLink2:
doc.ModelAngleToleranceRadians = Revit.AngleTolerance;
doc.ModelDistanceDisplayPrecision = Clamp((int)-Log10(lengthFormatoptions.Accuracy), 0, 7);
doc.ModelAbsoluteTolerance = Revit.VertexTolerance * UnitScale(UnitSystem.Feet, RevitModelUnitSystem);
doc.AdjustModelUnitSystem(RevitModelUnitSystem, true);
AdjustViewConstructionPlanes(doc);
break;
case Autodesk.Revit.UI.TaskDialogResult.CommandLink3:
doc.ModelAngleToleranceRadians = Revit.AngleTolerance;
doc.ModelDistanceDisplayPrecision = Clamp(Grasshopper.CentralSettings.FormatDecimalDigits, 0, 7);
doc.ModelAbsoluteTolerance = Revit.VertexTolerance * UnitScale(UnitSystem.Feet, GH.Guest.ModelUnitSystem);
doc.AdjustModelUnitSystem(GH.Guest.ModelUnitSystem, true);
AdjustViewConstructionPlanes(doc);
break;
default:
AuditTolerances(doc);
break;
}
}
}
}
}
public static object[] GetPanels(Guid panelId, uint documentRuntimeSerialNumber) => GetPanels(panelId, RhinoDoc.FromRuntimeSerialNumber(documentRuntimeSerialNumber));
protected override Result RunCommand(RhinoDoc doc, RunMode mode)
{
//This command takes a Text annotation object which has an Object Name function associated with it (fx object name)
//it then finds the object associated and creates a copy of it in the document with a new tag for the copy which
//indexes the copy name as Object A > Object B > Object C.
//Ask for a text object that's being used as a name tag
var go = new GetObject()
{
GeometryFilter = ObjectType.Annotation
};
go.GeometryFilter = ObjectType.Annotation;
go.SetCommandPrompt("Select Text with Object Name Function Applied");
go.EnablePreSelect(false, true);
go.GetMultiple(1, 0);
if (go.Result() != GetResult.Object)
{
return(Result.Cancel);
}
foreach (var ro in go.Objects().Select(ob => ob.Object()).ToList())
{
//Deselect our input object and filter out anything that isnt a text annotation
doc.Objects.Select(ro.Id, false);
if (ro.Geometry.ObjectType != ObjectType.Annotation)
{
continue;
}
if (!(ro.Geometry is TextEntity te))
{
continue;
}
//See if the annotation contains the ingredients of a function
var fx = te.RichText;
if (!fx.Contains("%<") && !fx.Contains(">%"))
{
continue;
}
//Find the original doc object guid that tag function is linked to
var object_id = ExtractGuidFromString(fx);
var isguid = Guid.TryParse(object_id, out Guid obj_guid);
if (!isguid)
{
continue;
}
//Create a duplicate of the linked text object
var copy_obj = doc.Objects.Find(obj_guid);
if (copy_obj == null)
{
continue;
}
//Duplicate the original objects geometry and attributes
var duplicate = copy_obj.DuplicateGeometry();
var attributes = copy_obj.Attributes.Duplicate();
attributes.Name = $"{copy_obj.Name} {GetNextIndexName(obj_guid, ref doc)}";
//Tag the copy with a reference to the original so that we can figure out the next letter index easier
attributes.SetUserString(".Dup", obj_guid.ToString());
//Create a duplicate of the object in the doc
var copied_obj_guid = doc.Objects.Add(duplicate, attributes);
//Create a new tag for the duplicate with updated functions
if (!(ro.DuplicateGeometry() is TextEntity dup_text))
{
continue;
}
dup_text.RichText = ReplaceGuid(dup_text.RichText, copied_obj_guid);
var tag_guid = doc.Objects.Add(dup_text);
//Select the new objects to make moving them easier
Guid[] selection = { tag_guid, copied_obj_guid };
doc.Objects.Select(selection);
doc.Views.Redraw();
}
return(Result.Success);
}
/// <since>5.0</since>
public virtual Commands.Result RunScript(RhinoDoc doc, Commands.RunMode mode)
{
RhinoApp.WriteLine(Localization.LocalizeString("Scripting not supported for this option", 33));
Dialogs.ShowMessage(Localization.LocalizeString("Scripting not supported for this option", 34), Localization.LocalizeString("Unsupported Option", 35));
return(Commands.Result.Success);
}
public static T [] GetPanels <T> (uint documentRuntimeSerialNumber) where T : class => GetPanels <T> (RhinoDoc.FromRuntimeSerialNumber(documentRuntimeSerialNumber));
/// <summary>
/// Accesses the environment table.
/// </summary>
/// <param name="doc">A Rhino document.</param>
/// <returns>The environments list.</returns>
public static ContentList EnvironmentList(RhinoDoc doc)
{
return(new ContentList(RenderContentKind.Environment, doc));
}
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(RhinoDoc doc, RunMode mode)
{
return(Result.Success);
}
/// <summary>
/// Accesses the texture table.
/// </summary>
/// <param name="doc">A Rhino document.</param>
/// <returns>The textures list.</returns>
public static ContentList TextureList(RhinoDoc doc)
{
return(new ContentList(RenderContentKind.Texture, doc));
}
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;
}
/// <summary>
/// Accesses the material table.
/// </summary>
/// <param name="doc">A Rhino document.</param>
/// <returns>The materials list.</returns>
public static ContentList MaterialList(RhinoDoc doc)
{
return(new ContentList(RenderContentKind.Material, doc));
}
/// <summary>
/// Draws the perforation.
/// </summary>
/// <returns></returns>
public override double drawPerforation(Curve boundaryCurve)
{
PointMap pointMap = new PointMap();
// Find the boundary
BoundingBox boundingBox = boundaryCurve.GetBoundingBox(Plane.WorldXY);
Point3d min = boundingBox.Min;
Point3d max = boundingBox.Max;
double spanX = max.X - min.X;
double spanY = max.Y - min.Y;
int punchQtyX = ((int)((spanX - punchingToolList[0].X) / XSpacing)) + 1;
double marginX = (spanX - ((punchQtyX - 1) * XSpacing)) / 2;
int punchQtyY = ((int)((spanY - punchingToolList[0].Y) / YSpacing)) + 1;
double marginY = (spanY - ((punchQtyY - 1) * YSpacing)) / 2;
Point3d point;
RhinoDoc doc = RhinoDoc.ActiveDoc;
double firstX = min.X + marginX;
double firstY = min.Y + marginY;
Point3d origin = new Point3d(firstX, firstY, 0);
// Record the current layer
int currentLayer = doc.Layers.CurrentLayerIndex;
// Create Perforation Layer
// if (punchingToolList[0].ClusterTool.Enable == true)
{
doc.Layers.SetCurrentLayerIndex(currentLayer, true);
}
//else
//{
// if (!MetrixUtilities.IsLayerFound("TemporaryPerfLayer"))
// {
// RhinoUtilities.SetActiveLayer(Properties.Settings.Default.ToolHitLayerName, System.Drawing.Color.Black);
// }
// else
// {
// RhinoUtilities.SetActiveLayer("TemporaryToolHit", System.Drawing.Color.Black);
// }
//}
// Random Engine
RandomTiler randomTileEngine = new RandomTiler();
int totalQty = punchQtyX * punchQtyY;
int toolHitQty = (int)(totalQty * randomness);
int blankQty = totalQty - toolHitQty;
List <int> tileCounts = new List <int>();
tileCounts.Add(toolHitQty);
tileCounts.Add(blankQty);
int[,] tileMap = randomTileEngine.GetTileMap(tileCounts, punchQtyX, punchQtyY);
// Add first point
random = new Random();
for (int y = 0; y < punchQtyY; y++)
{
for (int x = 0; x < punchQtyX; x++)
{
point = new Point3d(firstX + x * XSpacing, firstY + y * YSpacing, 0);
if (punchingToolList[0].isInside(boundaryCurve, point) == true)
{
if (tileMap[x, y] == 1)
{
pointMap.AddPoint(new PunchingPoint(point));
punchingToolList[0].drawTool(point);
}
}
}
}
// Display the open area calculation
AreaMassProperties area = AreaMassProperties.Compute(boundaryCurve);
RhinoApp.WriteLine("Total area: {0} mm^2", area.Area.ToString("#.##"));
double toolArea = punchingToolList[0].getArea() * pointMap.Count;
RhinoApp.WriteLine("Tool area: {0} mm^2", toolArea.ToString("#.##"));
openArea = toolArea * 100 / area.Area;
RhinoApp.WriteLine("Open area: {0}%", openArea.ToString("#."));
// Draw the cluster for each tool
for (int i = 0; i < punchingToolList.Count; i++)
{
// Only draw cluster tool if it is enable
if (punchingToolList[i].ClusterTool.Enable == true)
{
// Draw the cluster tool
drawCluster(pointMap, punchingToolList[i]);
}
}
doc.Views.Redraw();
doc.Layers.SetCurrentLayerIndex(currentLayer, true);
return(openArea);
}
public static bool DoExport(string fileName, glTFExportOptions options, bool binary, RhinoDoc doc, IEnumerable <Rhino.DocObjects.RhinoObject> rhinoObjects, Rhino.Render.LinearWorkflow workflow)
{
RhinoDocGltfConverter converter = new RhinoDocGltfConverter(options, binary, doc, rhinoObjects, workflow);
glTFLoader.Schema.Gltf gltf = converter.ConvertToGltf();
if (binary)
{
byte[] bytes = converter.GetBinaryBuffer();
glTFLoader.Interface.SaveBinaryModel(gltf, bytes.Length == 0 ? null : bytes, fileName);
}
else
{
glTFLoader.Interface.SaveModel(gltf, fileName);
}
RhinoApp.WriteLine("Successfully exported selected geometry to glTF(Binary).");
return(true);
}
protected override Result RunCommand(RhinoDoc doc, RunMode mode)
{
RhinoApp.WriteLine("{0} plug-in loaded.", SampleCsWinFormsPlugIn.Instance.Name);
return(Result.Success);
}
protected override Result RunCommand(RhinoDoc doc, RunMode mode)
{
GetObject go = new GetObject();
go.SetCommandPrompt("Select curve to split");
go.GeometryFilter = ObjectType.Curve;
go.GeometryAttributeFilter = GeometryAttributeFilter.OpenCurve;
go.SubObjectSelect = false;
go.Get();
if (go.CommandResult() != Result.Success)
{
return(go.CommandResult());
}
ObjRef object_ref = go.Object(0);
RhinoObject rh_object = object_ref.Object();
Curve curve = object_ref.Curve();
if (null == rh_object || null == curve)
{
return(Result.Failure);
}
GetPoint gp = new GetPoint();
gp.SetCommandPrompt("Point on curve to split at");
gp.Constrain(curve, false);
gp.Get();
if (gp.CommandResult() != Result.Success)
{
return(gp.CommandResult());
}
Point3d point = gp.Point();
double t = Rhino.RhinoMath.UnsetValue;
if (!curve.ClosestPoint(point, out t))
{
return(Result.Failure);
}
List <double> curve_t = new List <double>(3);
curve_t.Add(curve.Domain.Min);
curve_t.Add(curve.Domain.Max);
curve_t.Add(t);
curve_t.Sort();
List <double> culled_t = curve_t.Distinct().ToList();
if (culled_t.Count < 3)
{
return(Result.Nothing);
}
ObjectAttributes attributes = rh_object.Attributes.Duplicate();
attributes.ObjectId = Guid.Empty;
for (int i = 0; i < culled_t.Count - 1; i++)
{
Interval domain = new Interval(culled_t[i], culled_t[i + 1]);
if (curve.Domain.IncludesInterval(domain))
{
Curve trim = curve.Trim(domain);
if (null != trim)
{
doc.Objects.Add(trim, attributes);
}
}
}
doc.Objects.Delete(object_ref, false);
doc.Views.Redraw();
return(Result.Success);
}
private int runCount; //Legacy field.
public override void InvokeRunScript(IGH_Component owner, object rhinoDocument, int iteration, List <object> inputs, IGH_DataAccess DA)
{
//Prepare for a new run...
//1. Reset lists
this.__out.Clear();
this.__err.Clear();
this.Component = owner;
this.Iteration = iteration;
this.GrasshopperDocument = owner.OnPingDocument();
this.RhinoDocument = rhinoDocument as Rhino.RhinoDoc;
this.owner = this.Component;
this.runCount = this.Iteration;
this.doc = this.RhinoDocument;
//2. Assign input parameters
List <Plane> Pl = null;
if (inputs[0] != null)
{
Pl = GH_DirtyCaster.CastToList <Plane>(inputs[0]);
}
List <int> id = null;
if (inputs[1] != null)
{
id = GH_DirtyCaster.CastToList <int>(inputs[1]);
}
List <Polyline> body = null;
if (inputs[2] != null)
{
body = GH_DirtyCaster.CastToList <Polyline>(inputs[2]);
}
//3. Declare output parameters
object A = null;
//4. Invoke RunScript
RunScript(Pl, id, body, ref A);
try
{
//5. Assign output parameters to component...
if (A != null)
{
if (GH_Format.TreatAsCollection(A))
{
IEnumerable __enum_A = (IEnumerable)(A);
DA.SetDataList(1, __enum_A);
}
else
{
if (A is Grasshopper.Kernel.Data.IGH_DataTree)
{
//merge tree
DA.SetDataTree(1, (Grasshopper.Kernel.Data.IGH_DataTree)(A));
}
else
{
//assign direct
DA.SetData(1, A);
}
}
}
else
{
DA.SetData(1, null);
}
}
catch (Exception ex)
{
this.__err.Add(string.Format("Script exception: {0}", ex.Message));
}
finally
{
//Add errors and messages...
if (owner.Params.Output.Count > 0)
{
if (owner.Params.Output[0] is Grasshopper.Kernel.Parameters.Param_String)
{
List <string> __errors_plus_messages = new List <string>();
if (this.__err != null)
{
__errors_plus_messages.AddRange(this.__err);
}
if (this.__out != null)
{
__errors_plus_messages.AddRange(this.__out);
}
if (__errors_plus_messages.Count > 0)
{
DA.SetDataList(0, __errors_plus_messages);
}
}
}
}
}
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 bool ReadFile(string filename, int index, RhinoDoc doc, FileReadOptions options)
{
string line;
// Read the file and display it line by line.
StreamReader file = new StreamReader(filename);
var obj = new ASCObject();
var points = new List <Point3d>();
var y = 0;
while ((line = file.ReadLine()) != null)
{
string[] components = Regex.Split(line, @"\s+");
if (components.Length == 2)
{
var val = components[1];
switch (components[0])
{
case "ncols": obj.ncols = int.Parse(val); break;
case "nrows": obj.nrows = int.Parse(val); break;
case "xllcorner": obj.xllcorner = int.Parse(val); break;
case "yllcorner": obj.yllcorner = int.Parse(val); break;
case "cellsize": obj.cellsize = float.Parse(val); break;
case "NODATA_value": obj.NODATA_value = float.Parse(val); break;
}
}
else
{
var x = 0;
foreach (var item in components)
{
float _x = obj.xllcorner + obj.cellsize * x;
float _y = obj.yllcorner - obj.cellsize * y + obj.cellsize * obj.nrows;
float _z = float.Parse(item);
points.Add(new Point3d(_x, _y, _z));
x += 1;
}
y++;
}
}
var importAsPointCloud = true;
var importAsMesh = true;
if (!Settings.TryGetBool(ASCImportOptionPageLayout.KEY_POINTCLOUD, out importAsPointCloud))
{
importAsPointCloud = false;
}
if (!Settings.TryGetBool(ASCImportOptionPageLayout.KEY_MESH, out importAsMesh))
{
importAsPointCloud = true;
}
if (importAsPointCloud)
{
var pc = new PointCloud(points);
doc.Objects.AddPointCloud(pc);
}
if (importAsMesh)
{
int faceCount = 0;
Mesh mesh = new Mesh();
mesh.Vertices.AddVertices(points);
for (int i = 0; i < obj.nrows * (obj.ncols - 1); i++)
{
if (faceCount < (obj.nrows - 1))
{
var A = i;
var B = i + 1;
var C = (i + obj.nrows) + 1;
var D = (i + obj.nrows);
var face = new MeshFace(A, B, C, D);
mesh.Faces.AddFace(face);
faceCount += 1;
}
else
{
faceCount = 0;
}
}
mesh.FaceNormals.ComputeFaceNormals();
mesh.Compact();
doc.Objects.AddMesh(mesh);
}
doc.Views.Redraw();
file.Close();
return(true);
}
protected override Result RunCommand(RhinoDoc doc, RunMode mode)
{
m_tolerance = doc.ModelAbsoluteTolerance;
// only use a custom geometry filter if no simpler filter does the job
// only curves
var gc = new GetObject();
gc.SetCommandPrompt("select curve");
gc.GeometryFilter = ObjectType.Curve;
gc.DisablePreSelect();
gc.SubObjectSelect = false;
gc.Get();
if (gc.CommandResult() != Result.Success)
{
return(gc.CommandResult());
}
if (null == gc.Object(0).Curve())
{
return(Result.Failure);
}
Rhino.RhinoApp.WriteLine("curve was selected");
// only closed curves
var gcc = new GetObject();
gcc.SetCommandPrompt("select closed curve");
gcc.GeometryFilter = ObjectType.Curve;
gcc.GeometryAttributeFilter = GeometryAttributeFilter.ClosedCurve;
gcc.DisablePreSelect();
gcc.SubObjectSelect = false;
gcc.Get();
if (gcc.CommandResult() != Result.Success)
{
return(gcc.CommandResult());
}
if (null == gcc.Object(0).Curve())
{
return(Result.Failure);
}
Rhino.RhinoApp.WriteLine("closed curve was selected");
// only circles with a radius of 10
var gcc10 = new GetObject();
gcc10.SetCommandPrompt("select circle with radius of 10");
gc.GeometryFilter = ObjectType.Curve;
gcc10.SetCustomGeometryFilter(CircleWithRadiusOf10GeometryFilter); // custom geometry filter
gcc10.DisablePreSelect();
gcc10.SubObjectSelect = false;
gcc10.Get();
if (gcc10.CommandResult() != Result.Success)
{
return(gcc10.CommandResult());
}
if (null == gcc10.Object(0).Curve())
{
return(Result.Failure);
}
RhinoApp.WriteLine("circle with radius of 10 was selected");
return(Result.Success);
}
protected override Result RunCommand(RhinoDoc doc, RunMode mode)
{
// TODO: complete command.
return(Result.Success);
}
protected override Result RunCommand(RhinoDoc doc, RunMode mode)
{
// Locals
Plane plane;
Point3d base_point = Point3d.Unset;
Point3d ref_point = Point3d.Unset;
GetResult res = GetResult.Nothing;
Result rc = Result.Nothing;
// Select objects to rotate
TransformObjectList list = new TransformObjectList();
rc = SelectObjects("Select objects to rotate", list);
if (rc != Result.Success)
{
return(rc);
}
GetPoint gp = new GetPoint();
gp.SetCommandPrompt("Center of rotation");
gp.Get();
if (gp.CommandResult() != Result.Success)
{
return(gp.CommandResult());
}
RhinoView view = gp.View();
if (null == view)
{
return(Result.Failure);
}
base_point = gp.Point();
plane = view.ActiveViewport.ConstructionPlane();
plane.Origin = base_point;
// Angle or first reference point
GetReferencePoint gr = new GetReferencePoint(base_point);
gr.SetCommandPrompt("Angle or first reference point");
res = gr.Get();
if (res == GetResult.Point)
{
view = gr.View();
rc = (null != view) ? Result.Success : Result.Failure;
if (rc == Result.Success)
{
plane = view.ActiveViewport.ConstructionPlane();
plane.Origin = base_point;
ref_point = plane.ClosestPoint(gr.Point());
if (base_point.DistanceTo(ref_point) <= RhinoMath.ZeroTolerance)
{
rc = Result.Nothing;
}
}
if (rc != Result.Success)
{
return(rc);
}
}
else if (res == GetResult.Number)
{
Transform xform = Transform.Rotation(Rhino.RhinoMath.ToRadians(gr.Number()), plane.Normal, base_point);
rc = (xform.IsValid) ? Result.Success : Result.Failure;
if (rc == Result.Success)
{
TransformObjects(list, xform, false, false);
doc.Views.Redraw();
}
return(rc);
}
else
{
return(Result.Cancel);
}
// Second reference point
GetRotationTransform gx = new GetRotationTransform(plane, base_point, ref_point);
gx.SetCommandPrompt("Second reference point");
gx.AddTransformObjects(list);
res = gx.GetXform();
if (res == GetResult.Point)
{
view = gx.View();
rc = (null != view) ? Result.Success : Result.Failure;
if (rc == Result.Success)
{
Transform xform = gx.CalculateTransform(view.ActiveViewport, gx.Point());
rc = (xform.IsValid) ? Result.Success : Result.Failure;
if (rc == Result.Success)
{
TransformObjects(list, xform, false, false);
doc.Views.Redraw();
}
}
}
else if (res == GetResult.Number)
{
Transform xform = Transform.Rotation(Rhino.RhinoMath.ToRadians(gx.Number()), plane.Normal, base_point);
rc = (xform.IsValid) ? Result.Success : Result.Failure;
if (rc == Result.Success)
{
TransformObjects(list, xform, false, false);
doc.Views.Redraw();
}
}
else
{
rc = Result.Cancel;
}
return(rc);
}
public static void FloorOrientPosition(Point3d startPos, ref List <double> zPositions, RhinoDoc rhinoDocument)
{
RhinoObject[] byLayer = rhinoDocument.Objects.FindByLayer("#VR User Defined Floors");
if (byLayer == null || byLayer.Length < 1)
{
return;
}
List <Brep> brepList1 = new List <Brep>();
for (int index = 0; index < byLayer.Length; ++index)
{
ObjRef objRef = new ObjRef(byLayer[index]);
if (objRef != null)
{
Brep brep = objRef.Brep();
if (brep != null)
{
brepList1.Add(brep);
}
}
}
List <Brep> brepList2 = brepList1;
List <Point3d> point3dList1 = new List <Point3d>();
point3dList1.Add(startPos);
List <Point3d> point3dList2 = point3dList1;
Vector3d vector3d = new Vector3d(0.0, 0.0, -1.0);
double absoluteTolerance = rhinoDocument.ModelAbsoluteTolerance;
Point3d[] breps = Intersection.ProjectPointsToBreps((IEnumerable <Brep>)brepList2, (IEnumerable <Point3d>)point3dList2, vector3d, absoluteTolerance);
if (breps != null && breps.Length > 0)
{
foreach (Point3d point3d in breps)
{
// ISSUE: explicit reference operation
double z = ((Point3d)@point3d).Z;
zPositions.Add(z + VR_PANEL.EyeHeight);
}
}
else
{
// ISSUE: explicit reference operation
zPositions.Add(((Point3d)@startPos).Z);
}
}
protected override Result Render(RhinoDoc doc, RunMode mode, bool fastPreview)
{
RhinoApp.WriteLine("_Render command support not yet implemented");
return(Result.Nothing);
}
