public override void DrawViewportWires(IGH_PreviewArgs args)
{
args.Viewport.GetFrustumFarPlane(out Plane plane);
RhinoViewport viewport = args.Viewport;
for (int i = 0; i < _pt.Count; i++)
{
if (bar_No == 1)
{
var size = VisualizeModel.VisualizeModel.fontsize; Point3d point = _pt[i]; plane.Origin = point;
viewport.GetWorldToScreenScale(point, out double pixPerUnit); size /= pixPerUnit;
args.Display.Draw3dText(_bar[i], _c[i], plane, size, "", false, false, Rhino.DocObjects.TextHorizontalAlignment.Center, Rhino.DocObjects.TextVerticalAlignment.Bottom);
}
if (bar_name == 1)
{
var size = VisualizeModel.VisualizeModel.fontsize; Point3d point = _pt[i]; plane.Origin = point;
viewport.GetWorldToScreenScale(point, out double pixPerUnit); size /= pixPerUnit;
args.Display.Draw3dText(_name[i], _c[i], plane, size, "", false, false, Rhino.DocObjects.TextHorizontalAlignment.Center, Rhino.DocObjects.TextVerticalAlignment.Top);
}
if (bar_list == 1)
{
var size = VisualizeModel.VisualizeModel.fontsize; Point3d point = _pt[i]; plane.Origin = point;
viewport.GetWorldToScreenScale(point, out double pixPerUnit); size /= pixPerUnit;
args.Display.Draw3dText(_list[i], _c[i], plane, size, "", false, false, Rhino.DocObjects.TextHorizontalAlignment.Center, Rhino.DocObjects.TextVerticalAlignment.Top);
}
}
}
public override void DrawViewportWires(IGH_PreviewArgs argments)
{
argments.Viewport.GetFrustumFarPlane(out Plane pln);
RhinoViewport viewp = argments.Viewport;
for (int i = 0; i < _s.Count; i++)
{
var material = new DisplayMaterial(_c[i], 0.5);
argments.Display.DrawBrepShaded(_s[i], material);
}
for (int i = 0; i < _pt.Count; i++)
{
double size = fontsize;
Point3d point = _pt[i];
pln.Origin = point;
viewp.GetWorldToScreenScale(point, out double pixPerUnit); size /= pixPerUnit;
var tt = _text[i];
var H = TextHorizontalAlignment.Right; var V = TextVerticalAlignment.Top;
if (_c2[i] == Color.Black)
{
V = TextVerticalAlignment.Bottom;
}
if (_c2[i] == Color.Blue)
{
H = TextHorizontalAlignment.Left; V = TextVerticalAlignment.Bottom;
}
if (_c2[i] == Color.Purple)
{
H = TextHorizontalAlignment.Left;
}
argments.Display.Draw3dText(tt, _c2[i], pln, size, "", false, false, H, V);
}
}
public override Transform CalculateTransform(RhinoViewport viewport, Point3d point)
{
Transform xform = new Transform(0);
if (SetX)
{
xform[0, 3] = point.X;
}
else
{
xform[0, 0] = 1.0;
}
if (SetY)
{
xform[1, 3] = point.Y;
}
else
{
xform[1, 1] = 1.0;
}
if (SetZ)
{
xform[2, 3] = point.Z;
}
else
{
xform[2, 2] = 1.0;
}
xform[3, 3] = 1.0;
return(xform);
}
public static void StopWASD()
{
Overlay.ShowImage(null);
if (timer != null)
{
timer.Stop();
timer.Tick -= OnTick;
timer.Dispose();
timer = null;
}
UnhookWindowsHookEx(_kHook);
UnhookWindowsHookEx(_mHook);
if (!double.IsNaN(LastTargetDistance))
{
RhinoViewport vp = RhinoDoc.ActiveDoc.Views.ActiveView.ActiveViewport;
Point3d newTarget = vp.CameraLocation + vp.CameraDirection * LastTargetDistance;
vp.SetCameraTarget(newTarget, false);
}
LastTargetDistance = double.NaN;
Cursor.Position = CursorPositionBuffer;
ShowCursor(true);
F1 = F2 = F3 = F12 = Q = W = E = S = A = D = Shift = Esc = Enter = false;
}
public void writeSection2d(MeshVoxeliser mvox)
{
File3dm file = setupFile();
foreach (StructuralSpan sp in mvox.structuralSpans)
{
Point3d location = new Point3d();
foreach (StructuralBay sb in sp.structuralBays)
{
location.X = sb.baynum * 40000;
addBaySection2d(file, sb, location);
}
}
RhinoViewport viewport = new RhinoViewport();
viewport.SetProjection(DefinedViewportProjection.Top, "2d sections", false);
viewport.ZoomExtents();
file.AllViews.Add(new ViewInfo(viewport));
string section = mvox.parameters.sectionNum.ToString();
if (mvox.parameters.sectionNum < 10)
{
section = "0" + section;
}
file.Write(@"C:\Users\r.hudson\Documents\WORK\projects\passageProjects\sections\section" + section + "_2d.3dm", 5);
}
private void makeBayView(File3dm file, StructuralBay bay)
{
//File3dm file = setupFile();
RhinoViewport viewport = new RhinoViewport();
//shift to mid point of module
Point3d origin = new Point3d(bay.minPlane.Origin);
Plane plnA = new Plane(origin + bay.minPlane.YAxis * bay.parameters.yCell / 2, bay.minPlane.XAxis, Vector3d.ZAxis);
//shift to end of module
Plane plnB = new Plane(origin + bay.minPlane.YAxis * bay.parameters.yCell, bay.minPlane.XAxis, Vector3d.ZAxis);
plnA.Flip();
viewport.SetProjection(DefinedViewportProjection.Perspective, "bay_" + bay.baynum.ToString() + "section", false);
viewport.ChangeToParallelProjection(true);
//set camera and target
Vector3d shiftTarget = bay.maxPlane.Origin - bay.minPlane.Origin;
viewport.SetCameraTarget(bay.minPlane.Origin + shiftTarget / 2, false);
viewport.SetCameraLocation(viewport.CameraTarget + bay.minPlane.YAxis * -50000, false);
viewport.SetCameraDirection(viewport.CameraTarget - viewport.CameraTarget, false);
viewport.CameraUp = Vector3d.ZAxis;
//viewport.ZoomExtents();
viewport.PushViewProjection();
file.AllViews.Add(new ViewInfo(viewport));
//Clip plane A
file.Objects.AddClippingPlane(plnA, bay.parameters.width, bay.parameters.height, viewport.Id);
//Clip plane B
file.Objects.AddClippingPlane(plnB, bay.parameters.width, bay.parameters.height, viewport.Id);
}
public override Transform CalculateTransform(RhinoViewport viewport, Point3d point)
{
if (CalculatePlaneAngle(point))
{
return(Transform.Rotation(m_angle, m_plane.Normal, m_base_point));
}
return(Transform.Identity);
}
private RhinoViewport camera; //ビューポートのカメラの設定
////////////////
//constructors//
////////////////
public ChangeCoordinates(
int _size,
RhinoView _view
)
{
size = _size;
view = _view;
camera = new RhinoViewport(view.ActiveViewport);//ビューポートのカメラの設定を格納
}
private RhinoViewport SetViewParams(RhinoViewport viewport, Base speckleView)
{
// lens
var lens = speckleView["lens"] as double?;
if (lens != null)
{
viewport.Camera35mmLensLength = (double)lens;
}
return(viewport);
}
/// <summary>
/// Gets scale factor of a given viewport in pixels per unit
/// </summary>
/// <param name="viewport">viewport to calculate scale factor for</param>
/// <returns>scale factor in pixels per unit</returns>
public static double GetViewportScale(RhinoViewport viewport)
{
if (!viewport.IsPlanView)
{
return(0);
}
viewport.GetFrustumCenter(out var frustrumCenter);
viewport.GetWorldToScreenScale(frustrumCenter, out var pixelsPerUnit);
return(pixelsPerUnit);
}
public override void DrawViewportWires(IGH_PreviewArgs args)
{
args.Viewport.GetFrustumFarPlane(out Plane plane);
RhinoViewport viewport = args.Viewport;
for (int i = 0; i < _frame.Count; i++)
{
args.Display.DrawLine(_frame[i], Color.Black);
}
for (int i = 0; i < _wave.Count; i++)
{
args.Display.DrawLine(_wave[i], _c[i]);
}
}
private static bool IsNamedView(RhinoViewport vp, ViewportInfo info)
{
if (
Math.Abs(vp.Camera35mmLensLength - info.Camera35mmLensLength) < 1 &&
vp.CameraDirection == info.CameraDirection &&
vp.CameraLocation == info.CameraLocation &&
vp.CameraUp == info.CameraUp &&
vp.CameraTarget == info.TargetPoint
)
{
return(true);
}
return(false);
}
public string ViewToNative(View3D view)
{
Rhino.RhinoApp.InvokeOnUiThread((Action) delegate {
RhinoView _view = Doc.Views.ActiveView;
RhinoViewport viewport = _view.ActiveViewport;
viewport.SetProjection(DefinedViewportProjection.Perspective, null, false);
var origin = PointToNative(view.origin).Location;
var forward = new Vector3d(view.forwardDirection.x, view.forwardDirection.y, view.forwardDirection.z);
if (view.target != null)
{
viewport.SetCameraLocations(PointToNative(view.target).Location, origin); // this changes viewport.CameraUp. works for axon from revit if after, for perspective from revit if before
}
else
{
viewport.SetCameraLocation(origin, true);
viewport.SetCameraDirection(forward, true);
}
viewport.CameraUp = new Vector3d(view.upDirection.x, view.upDirection.y, view.upDirection.z);
viewport.Name = view.name;
/* TODO: debug this and see if it helps better match views from revit
* // set bounding box
* var box = BoxToNative(view.boundingBox);
* BoundingBox boundingBox = new BoundingBox(box.X.Min, box.Y.Min, box.Z.Min, box.X.Max, box.Y.Max, box.Z.Max);
* viewport.SetClippingPlanes(boundingBox);
*/
// set rhino view props if available
SetViewParams(viewport, view);
if (view.isOrthogonal)
{
viewport.ChangeToParallelProjection(true);
}
var commitInfo = GetCommitInfo();
var viewName = $"{commitInfo } - {view.name}";
Doc.NamedViews.Add(viewName, viewport.Id);
});
//ConversionErrors.Add(sdfasdfaf);
return("baked");
}
/// <summary>
/// Calculate the transform
/// </summary>
public bool CalculateTransform(RhinoViewport vp, Point3d pt, ref Transform xform)
{
var rc = false;
var mp = m_mesh.ClosestMeshPoint(pt, 0.0);
if (null != mp)
{
Plane meshPlane;
if (MeshFacePlane(mp, out meshPlane))
{
meshPlane.Origin = pt;
xform = Transform.PlaneToPlane(m_object_plane, meshPlane);
rc = xform.IsValid;
}
}
return(rc);
}
public override void DrawViewportWires(IGH_PreviewArgs args)
{
args.Viewport.GetFrustumFarPlane(out Plane plane);
RhinoViewport viewport = args.Viewport;
///重心の描画用関数*********************************************************************************
for (int i = 0; i < _p1.Count; i++)
{
Point3d point = _p1[i];
args.Display.DrawPoint(point, PointStyle.Square, 3, Color.Red);
}
///図心の描画用関数*********************************************************************************
for (int i = 0; i < _p2.Count; i++)
{
Point3d point = _p2[i];
args.Display.DrawPoint(point, PointStyle.Circle, 3, Color.Blue);
}
}
public override Transform CalculateTransform(RhinoViewport viewport, Point3d point)
{
var xform = Transform.Identity;
Point3d base_point;
if (TryGetBasePoint(out base_point))
{
var v = point - base_point;
if (!v.IsZero)
{
xform = Transform.Translation(v);
if (!xform.IsValid)
{
xform = Transform.Identity;
}
}
}
return(xform);
}
/// <summary>
/// Calculate the transformation
/// </summary>
public bool CalculateTransform(RhinoViewport vp, Point3d pt, ref Transform xform)
{
bool rc = false;
if (null != m_curve)
{
double t;
if (m_curve.ClosestPoint(pt, out t))
{
Plane frame;
if (m_curve.PerpendicularFrameAt(t, out frame))
{
xform = Transform.PlaneToPlane(m_plane, frame);
rc = xform.IsValid;
}
}
}
return(rc);
}
public override void DrawViewportWires(IGH_PreviewArgs args)
{
args.Viewport.GetFrustumFarPlane(out Plane plane);
RhinoViewport viewport = args.Viewport;
///軸外力の描画用関数*******************************************************************************
for (int i = 0; i < _arrow.Count; i++)
{
if (VisualizeModel.VisualizeModel.Value == 1)
{
var size = VisualizeModel.VisualizeModel.fontsize; Point3d point = _arrow[i].From; plane.Origin = point;
viewport.GetWorldToScreenScale(point, out double pixPerUnit); size /= pixPerUnit;
Text3d drawText = new Text3d(_text[i] + "kN", plane, size);
args.Display.Draw3dText(drawText, Color.MintCream); drawText.Dispose();
}
Line arrow = _arrow[i];
args.Display.DrawLine(arrow, Color.MintCream, 2);
args.Display.DrawArrowHead(arrow.To, arrow.Direction, Color.MintCream, 25, 0);
}
}
private void setClippingPlanes(Plane a, Plane b, File3dm file, string vpName, double w, double h)
{
RhinoViewport viewport = new RhinoViewport();
viewport.SetProjection(DefinedViewportProjection.Top, vpName, false);
viewport.SetCameraTarget(new Point3d(13817.498, 7162.495, -6025.053), true);
var vInfo = new ViewInfo(viewport);
file.AllViews.Add(vInfo);
//Clip plane A
file.Objects.AddClippingPlane(a, w, h, new List <Guid> {
viewport.Id
}, attClippingplanes);
//Clip plane B
file.Objects.AddClippingPlane(b, w, h, new List <Guid> {
viewport.Id
}, attClippingplanes);
}
public bool IsDisplayModeAvailable(RhinoViewport viewport)
{
if (viewport == null)
{
return(false);
}
try
{
var mode = viewport.DisplayMode;
var res = (mode != null);
if (mode != null)
{
mode.Dispose();
}
return(res);
}
catch (Exception ex)
{
log.temp("DisplayMode is unavailable: " + ex.Message);
return(false);
}
}
public void WritePart3d(PartController partController, Parameters parameters, string filePath)
{
foreach (NurbsCurve nurbsCurve in parameters.problemPanels)
{
AddCurve(nurbsCurve, "PROBLEM PANELS");
}
foreach (BayController bayController in partController.bayControllers)
{
foreach (CaveElement caveElement in bayController.caveElements)
{
if (caveElement.supportAssembly != null)
{
AddSupportAssembly(caveElement.supportAssembly, caveElement.orientation);
}
AddPanelFrames(caveElement.panelFrames, caveElement.orientation);
}
}
RhinoViewport viewport = new RhinoViewport();
viewport.SetProjection(DefinedViewportProjection.Perspective, "cavern view", false);
viewport.ZoomExtents();
file.AllViews.Add(new ViewInfo(viewport));
file.Write(filePath, 5);
}
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);
}
/// <summary>
/// Export an a perspective or orthographic sensor
/// </summary>
/// <param name="parent">The parent node in the output XML document</param>
/// <param name="obj">The RhinoViewport instance to be exported</param>
/// <returns>true if any content was exported</returns>
private bool ExportSensor(XmlElement parent, RhinoViewport view)
{
bool perspective = view.IsPerspectiveProjection;
bool orthographic = view.IsParallelProjection;
if (!perspective && !orthographic)
{
Log("Warning: camera type not supported -- ignoring.");
return(false);
}
double left, right, bottom, top, near, far;
view.GetFrustum(out left, out right, out bottom, out top, out near, out far);
XmlElement sensorElement = m_xmlDocument.CreateElement("sensor");
sensorElement.SetAttribute("type", perspective ? "perspective" : "orthographic");
Transform toWorld = view.GetTransform(CoordinateSystem.Camera, CoordinateSystem.World);
toWorld = toWorld * Transform.Mirror(new Plane(new Point3d(0, 0, 0), new Vector3d(0, 0, -1)));
toWorld = toWorld * Transform.Mirror(new Plane(new Point3d(0, 0, 0), new Vector3d(-1, 0, 0)));
XmlElement toWorldElement = MakeProperty("toWorld", toWorld);
if (perspective)
{
double focusDistance = view.CameraLocation.DistanceTo(view.CameraTarget);
double halfDiag, halfVert, halfHoriz;
view.GetCameraAngle(out halfDiag, out halfVert, out halfHoriz);
toWorld = toWorld * Transform.Mirror(new Plane(new Point3d(0, 0, 0), new Vector3d(0, 0, -1)));
sensorElement.AppendChild(MakeProperty("fovAxis", "diagonal"));
sensorElement.AppendChild(MakeProperty("fov", 2 * halfDiag * 180 / Math.PI));
sensorElement.AppendChild(MakeProperty("focusDistance", focusDistance));
}
else
{
XmlElement scaleNode = m_xmlDocument.CreateElement("scale");
double scale = (right - left) / 2;
scaleNode.SetAttribute("x", ToStringHelper(scale));
scaleNode.SetAttribute("y", ToStringHelper(scale));
toWorldElement.PrependChild(scaleNode);
}
// Some extra room for nativating using the interactive viewer
near /= 10; far *= 10;
sensorElement.AppendChild(toWorldElement);
sensorElement.AppendChild(MakeProperty("nearClip", near));
sensorElement.AppendChild(MakeProperty("farClip", far));
XmlElement filmElement = m_xmlDocument.CreateElement("film");
filmElement.SetAttribute("type", "hdrfilm");
filmElement.AppendChild(MakeProperty("width", m_settings.xres));
filmElement.AppendChild(MakeProperty("height", m_settings.yres));
sensorElement.AppendChild(filmElement);
XmlElement samplerElement = m_xmlDocument.CreateElement("sampler");
samplerElement.SetAttribute("type", "independent");
samplerElement.AppendChild(MakeProperty("sampleCount", m_settings.samplesPerPixel));
sensorElement.AppendChild(samplerElement);
parent.AppendChild(sensorElement);
return(true);
}
public void writeSection3d(MeshVoxeliser mvox, List <Curve> curvesToAdd)
{
File3dm file = setupFile();
foreach (Curve c in curvesToAdd)
{
file.Objects.AddCurve(c, attBuildingGrid);
}
file.Objects.AddText(mvox.sectionNum, attAnnotation);
foreach (StructuralSpan sp in mvox.structuralSpans)
{
foreach (Line xg in sp.xGrid)
{
file.Objects.AddLine(xg, attGrid);
}
foreach (Line yg in sp.yGrid)
{
file.Objects.AddLine(yg, attGrid);
}
foreach (Line bg in sp.baseGrid)
{
file.Objects.AddLine(bg, attBasegrid);
}
foreach (Text3d text in sp.txt)
{
file.Objects.AddText(text, attAnnotation);
}
foreach (StructuralBay sb in sp.structuralBays)
{
foreach (List <StructuralCell> sc in sb.voxels)
{
foreach (StructuralCell c in sc)
{
if (c.cellType != StructuralCell.CellType.InsideCell && c.cellType != StructuralCell.CellType.Undefined)
{
attCavepanels.ObjectColor = c.displayColor;
if (c.caveFace != null)
{
file.Objects.AddMesh(c.caveFace, attCavepanels);
}
foreach (Curve cl in c.centreLines)
{
file.Objects.AddCurve(cl, attCentrelines);
}
foreach (Curve d in c.diagonals)
{
file.Objects.AddCurve(d, attDiagonals);
}
if (c.GSAmesh != null)
{
file.Objects.AddMesh(c.GSAmesh, attGsamesh);
}
}
}
}
}
}
RhinoViewport viewport = new RhinoViewport();
viewport.SetProjection(DefinedViewportProjection.Perspective, "cavern view", false);
viewport.ZoomExtents();
file.AllViews.Add(new ViewInfo(viewport));
string cavepart = mvox.parameters.sectionNum.ToString();
if (mvox.parameters.sectionNum < 10)
{
cavepart = "0" + cavepart;
}
file.Write(@"C:\Users\r.hudson\Documents\WORK\projects\passageProjects\caveparts\cavepart" + cavepart + "_3d.3dm", 5);
}
public MouseSelectHandler(RhinoViewport vp, System.Drawing.Point pt, bool r)
{
_viewport = vp;
_point = pt;
_remove = r;
}
private static void OnTick(object sender, EventArgs args)
{
if (MouseOffset.IsEmpty && !Q && !W && !E && !A && !S && !D)
{
return;
}
RhinoViewport vp = RhinoDoc.ActiveDoc.Views.ActiveView.ActiveViewport;
Point3d loc = vp.CameraLocation;
Vector3d dir = new Vector3d(vp.CameraDirection);
Vector3d up = new Vector3d(vp.CameraUp);
dir.Unitize();
up.Unitize();
// Change direction if mouse moved
if (!MouseOffset.IsEmpty)
{
double angleH = MouseOffset.X / (double)MOUSE_SENSITIVITY * -360.0;
double angleV = MouseOffset.Y / (double)MOUSE_SENSITIVITY * -360.0;
MouseOffset = System.Drawing.Point.Empty;
dir.Rotate(Math.PI * angleH / 180.0, up);
dir.Rotate(Math.PI * angleV / 180.0, Vector3d.CrossProduct(vp.CameraDirection, up));
vp.SetCameraDirection(dir, false);
}
// Move camera if some key is pressed
if (Q)
{
loc -= Vector3d.ZAxis * speed;
}
if (W)
{
loc += dir * speed;
}
if (E)
{
loc += Vector3d.ZAxis * speed;
}
if (A)
{
loc -= Vector3d.CrossProduct(dir, up) * speed;
}
if (S)
{
loc -= dir * speed;
}
if (D)
{
loc += Vector3d.CrossProduct(dir, up) * speed;
}
vp.SetCameraLocation(loc, false);
if (!vp.IsVisible(vp.CameraTarget))
{
Point3d newTarget = vp.CameraLocation + vp.CameraDirection * 10000;
vp.SetCameraTarget(newTarget, false);
}
RhinoDoc.ActiveDoc.Views.ActiveView.Redraw();
}
