protected override Result RunCommand(RhinoDoc doc, RunMode mode)
{
Rhino.Geometry.Point3d[] corners;
Result rc = Rhino.Input.RhinoGet.GetRectangle(out corners);
if (rc != Result.Success)
{
return(rc);
}
Rhino.Geometry.Plane plane = new Rhino.Geometry.Plane(corners[0], corners[1], corners[2]);
Rhino.Geometry.Interval x_interval = new Rhino.Geometry.Interval(0, corners[0].DistanceTo(corners[1]));
Rhino.Geometry.Interval y_interval = new Rhino.Geometry.Interval(0, corners[1].DistanceTo(corners[2]));
Rhino.Geometry.Mesh mesh = Rhino.Geometry.Mesh.CreateFromPlane(plane, x_interval, y_interval, 10, 10);
//mesh.FaceNormals.ComputeFaceNormals();
//mesh.Normals.ComputeNormals();
SampleCsDrawMeshConduit conduit = new SampleCsDrawMeshConduit();
conduit.Mesh = mesh;
conduit.Enabled = true;
doc.Views.Redraw();
string out_str = null;
rc = Rhino.Input.RhinoGet.GetString("Press <Enter> to continue", true, ref out_str);
conduit.Enabled = false;
doc.Views.Redraw();
return(Result.Success);
}
static public bool CreateSections(Rhino.RhinoDoc doc, Rhino.Geometry.GeometryBase geo, Rhino.Geometry.Surface surfaceB, Rhino.Geometry.Curve curve, double interval, ref List <PlanePoint> points)
{
Rhino.Geometry.Interval domain = curve.Domain; // fixed issue
for (double t = domain.T0; t < domain.T1; t += interval)
{
Rhino.Geometry.Point3d pt = curve.PointAt(t);
Rhino.Geometry.Vector3d tangent = curve.TangentAt(t);
Rhino.Geometry.Vector3d curvature = curve.CurvatureAt(t);
Rhino.Geometry.Plane plane = new Rhino.Geometry.Plane();
curve.FrameAt(t, out plane);
doc.Objects.AddPoint(pt);
curvature = curvature * 10.0;
Rhino.Geometry.Line line = new Rhino.Geometry.Line(pt, curvature);
doc.Objects.AddLine(line);
RhinoApp.WriteLine("Curve at {0}", t);
Rhino.Geometry.Vector3d normal = new Rhino.Geometry.Vector3d();
bool ret = false;
if (geo is Rhino.Geometry.Brep)
{
Rhino.Geometry.Brep brepA = (Rhino.Geometry.Brep)geo;
ret = GetNormalVector(brepA, pt, ref normal);
RhinoApp.WriteLine(" Added Brep point at ({0}, {0}, {0})", pt.X, pt.Y, pt.Z);
}
else if (geo is Rhino.Geometry.Surface)
{
Rhino.Geometry.Surface surfaceA = (Rhino.Geometry.Surface)geo;
ret = GetNormalVector(surfaceA, pt, ref normal);
RhinoApp.WriteLine(" Added surface point at ({0}, {0}, {0})", pt.X, pt.Y, pt.Z);
}
if (ret)
{
Rhino.Geometry.Vector3d ucoord = CrossProduct(tangent, normal);
Rhino.Geometry.Plane plane2 = new Rhino.Geometry.Plane(pt, ucoord, tangent); // normal);
double[] parameters = plane2.GetPlaneEquation();
PlanePoint PlanePoint = new PlanePoint();
PlanePoint.pt = pt;
PlanePoint.A = parameters[0];
PlanePoint.B = parameters[1];
PlanePoint.C = parameters[2];
PlanePoint.D = parameters[3];
PlanePoint.curvature = curvature;
points.Add(PlanePoint);
Rhino.Geometry.Interval Interval1 = new Rhino.Geometry.Interval(-0.1, -0.1);
Rhino.Geometry.Interval Interval2 = new Rhino.Geometry.Interval(0.1, 0.1);
Rhino.Geometry.PlaneSurface PlaneSurface = new Rhino.Geometry.PlaneSurface(plane2, Interval1, Interval2);
doc.Objects.AddSurface(PlaneSurface);
}
}
return(true);
}
/// <summary>
/// Create Rhino open ArcCurve from Edge(Arc).
/// </summary>
public static Rhino.Geometry.ArcCurve ToRhinoArcCurve(Geometry.Edge obj)
{
if (obj.Points.Count == 3)
{
Rhino.Geometry.Arc arc = new Rhino.Geometry.Arc(obj.Points[0].ToRhino(), obj.Points[1].ToRhino(), obj.Points[2].ToRhino());
return(new Rhino.Geometry.ArcCurve(arc));
}
else
{
Rhino.Geometry.Interval interval = new Rhino.Geometry.Interval(obj.StartAngle, obj.EndAngle);
Rhino.Geometry.Plane plane = new Rhino.Geometry.Plane(obj.Points[0].ToRhino(), obj.XAxis.ToRhino(), obj.Normal.Cross(obj.XAxis).Normalize().ToRhino());
Rhino.Geometry.Circle circle = new Rhino.Geometry.Circle(plane, obj.Radius);
Rhino.Geometry.Arc arc = new Rhino.Geometry.Arc(circle, interval);
return(new Rhino.Geometry.ArcCurve(arc));
}
}
public static Rhino.Geometry.Brep ToRhino(Wall wall)
{
// i know the coordinates are not right, but it's work in progress and i'm past caring.
var vector = new Rhino.Geometry.Vector3d(wall.BaseLine.EndPoint.X, wall.BaseLine.EndPoint.Y, wall.BaseLine.EndPoint.Z);
var origin = new Rhino.Geometry.Point3d(wall.BaseLine.StartPoint.X, wall.BaseLine.StartPoint.Y, wall.BaseLine.StartPoint.Z);
var plane = new Rhino.Geometry.Plane(origin, vector);
Rhino.Geometry.Interval xInterval = new Rhino.Geometry.Interval(-wall.Length / 2, wall.Length / 2);
Rhino.Geometry.Interval yInterval = new Rhino.Geometry.Interval(-wall.Thickness / 2, wall.Thickness / 2);
Rhino.Geometry.Interval zInterval = new Rhino.Geometry.Interval(0, wall.Height);
Rhino.Geometry.Box box = new Rhino.Geometry.Box(plane, xInterval, yInterval, zInterval);
var brep = box.ToBrep();
brep.Rotate(Math.PI / 2, vector, origin);
return(brep);
}
protected override Result RunCommand(RhinoDoc doc, RunMode mode)
{
Rhino.DocObjects.ObjRef obj_ref;
Result rc = Rhino.Input.RhinoGet.GetOneObject("Select curve", false, Rhino.DocObjects.ObjectType.Curve, out obj_ref);
if (rc != Result.Success)
{
return(rc);
}
Rhino.DocObjects.RhinoObject obj = obj_ref.Object();
if (null == obj)
{
return(Result.Failure);
}
obj_ref.Object().Select(false);
doc.Views.Redraw();
Rhino.Geometry.Curve crv = obj_ref.Curve();
if (null == crv)
{
return(Result.Failure);
}
Rhino.Input.Custom.GetPoint gp = new Rhino.Input.Custom.GetPoint();
gp.SetCommandPrompt("First point on curve");
gp.Constrain(crv, false);
gp.Get();
rc = gp.CommandResult();
if (rc != Result.Success)
{
return(rc);
}
double t0 = Rhino.RhinoMath.UnsetValue;
if (null == gp.PointOnCurve(out t0))
{
return(Result.Failure);
}
gp.SetCommandPrompt("Second point on curve");
gp.Get();
rc = gp.CommandResult();
if (rc != Result.Success)
{
return(rc);
}
double t1 = Rhino.RhinoMath.UnsetValue;
if (null == gp.PointOnCurve(out t1))
{
return(Result.Failure);
}
if (System.Math.Abs(t1 - t0) < Rhino.RhinoMath.ZeroTolerance)
{
return(Result.Failure);
}
if (crv.IsClosed || (!crv.IsClosed && t0 > t1))
{
double t = t0;
t0 = t1;
t1 = t;
}
Rhino.Geometry.Interval range = new Rhino.Geometry.Interval(t0, t1);
Rhino.Geometry.Curve subcrv = crv.Trim(range);
if (null != subcrv)
{
System.Guid id = doc.Objects.Add(subcrv);
obj = doc.Objects.Find(id);
if (null != obj)
{
obj.Select(true);
}
}
doc.Views.Redraw();
return(Result.Success);
}
protected override void SolveInstance(Grasshopper.Kernel.IGH_DataAccess DA)
{
if (!DA.GetData(3, ref v))
{
return;
}
if (!FriedChiken.isInitialized)
{
Rhino.Geometry.Surface s = null;
if (!DA.GetData(0, ref s))
{
return;
}
Rhino.Geometry.Interval uDomain = s.Domain(0);
Rhino.Geometry.Interval vDomain = s.Domain(1);
int[] nEdgeNodes = new int[_dim];
DA.GetData(1, ref nEdgeNodes[0]);
DA.GetData(2, ref nEdgeNodes[1]);
for (int i = 0; i < _dim; i++)
{
if (nEdgeNodes[i] < 2)
{
AddRuntimeMessage(Grasshopper.Kernel.GH_RuntimeMessageLevel.Error, "Integers must be greater than or equal to 2");
return;
}
}
newNodes.Clear();
for (int i = 0; i < nEdgeNodes[1]; i++)
{
for (int j = 0; j < nEdgeNodes[0]; j++)
{
newNodes.Add(s.PointAt(uDomain.T0 + (uDomain.T1 - uDomain.T0) / (nEdgeNodes[0] - 1) * j, vDomain.T0 + (vDomain.T1 - vDomain.T0) / (nEdgeNodes[1] - 1) * i));
}
}
int nNewNodes = newNodes.Count;
mikity.NumericalMethodHelper.particle[] particles = new mikity.NumericalMethodHelper.particle[nNewNodes];
for (int i = 0; i < nNewNodes; i++)
{
particles[i] = new mikity.NumericalMethodHelper.particle(newNodes[i][0], newNodes[i][1], newNodes[i][2]);
}
pS = new GH_particleSystem(particles);
node[] lNodes = new node[nNewNodes];
for (int i = 0; i < nNewNodes; i++)
{
lNodes[i] = new node(i);
lNodes[i].copyFrom(pS.Value.particles);
}
nF = new nodalForce(v.X, v.Y, v.Z);
for (int i = 0; i < nNewNodes; i++)
{
nF.addNode(lNodes[i]);
}
pS.Value.addObject(nF);
lGeometry = new Rhino.Geometry.Point3d[nNewNodes];
for (int i = 0; i < nNewNodes; i++)
{
lGeometry[i] = new Rhino.Geometry.Point3d(particles[i][0], particles[i][1], particles[i][2]);
}
}
else
{
nF.forceX = v.X;
nF.forceY = v.Y;
nF.forceZ = v.Z;
}
DA.SetData(0, pS);
}
private void ExtractGeometry(Grasshopper.Kernel.Types.IGH_Goo iGoo, ref List <Rhino.Geometry.GeometryBase> resGeom)
{
if (iGoo is Grasshopper.Kernel.Types.GH_GeometryGroup group)
{
foreach (var geomGoo in group.Objects)
{
ExtractGeometry(geomGoo, ref resGeom);
}
return;
}
Rhino.Geometry.GeometryBase geometryBase = null;
try
{
switch (iGoo.ScriptVariable())
{
case Rhino.Geometry.Point3d point:
geometryBase = new Rhino.Geometry.Point(point);
break;
case Rhino.Geometry.Line line:
geometryBase = new Rhino.Geometry.LineCurve(line);
break;
case Rhino.Geometry.Rectangle3d rect:
geometryBase = rect.ToNurbsCurve();
break;
case Rhino.Geometry.Arc arc:
geometryBase = new Rhino.Geometry.ArcCurve(arc);
break;
case Rhino.Geometry.Circle circle:
geometryBase = new Rhino.Geometry.ArcCurve(circle);
break;
case Rhino.Geometry.Ellipse ellipse:
geometryBase = ellipse.ToNurbsCurve();
break;
case Rhino.Geometry.Curve curve:
geometryBase = curve;
break;
case Rhino.Geometry.Box box:
geometryBase = Rhino.Geometry.Mesh.CreateFromBox(box, 1, 1, 1); break;
case Rhino.Geometry.Mesh mesh:
geometryBase = mesh; break;
case Rhino.Geometry.Brep brep:
{
if (!CompoundDrawable.IsRenderMode)
{
foreach (var crv in brep.GetWireframe(-1))
{
resGeom.Add(crv);
}
}
else
{
var previewMesh = new Rhino.Geometry.Mesh();
previewMesh.Append(Rhino.Geometry.Mesh.CreateFromBrep(brep, MeshParameters));
geometryBase = previewMesh;
}
break;
}
case Rhino.Geometry.Plane plane:
{
double len = 4.0;
var x = new Rhino.Geometry.Interval(-len, len);
var y = new Rhino.Geometry.Interval(-len, len);
geometryBase = Rhino.Geometry.Mesh.CreateFromPlane(plane, x, y, 5, 5);
break;
}
default:
{
System.Diagnostics.Debug.Fail("Not supported GH type", iGoo.GetType().ToString());
break;
}
}
}
catch (Exception e)
{
System.Diagnostics.Debug.Fail(e.Source, e.Message);
}
if (geometryBase != null)
{
resGeom.Add(geometryBase);
}
}
public Rhino.Commands.Result AddPoints(Rhino.RhinoDoc doc)
{
// Input interval
double _interval = 0.1;
double _noise = 1; // 1% noise
var input = new Rhino.Input.Custom.GetNumber();
input.SetCommandPrompt("Input interval(0.0 ~ 1.0)<0.1>");
Rhino.Input.GetResult res = input.Get();
if (res == Rhino.Input.GetResult.Number)
{
_interval = input.Number();
}
if (_interval == 0.0)
{
_interval = 0.1;
}
input.SetCommandPrompt("Noise factor(0.0 ~ 100.0)");
res = input.Get();
if (res == Rhino.Input.GetResult.Number)
{
_noise = input.Number();
}
// Select surface
var go = new Rhino.Input.Custom.GetObject();
go.SetCommandPrompt("Select surface");
go.GeometryFilter = Rhino.DocObjects.ObjectType.Surface;
res = go.GetMultiple(1, 1024);
if (res == Rhino.Input.GetResult.Nothing)
{
return(Rhino.Commands.Result.Failure);
}
Utility.SetOutputCount(10);
for (int i = 0; i < go.ObjectCount; i++)
{
Rhino.Geometry.Surface surfaceA = go.Object(i).Surface();
if (surfaceA == null)
{
return(Rhino.Commands.Result.Failure);
}
Rhino.Geometry.Interval domU = surfaceA.Domain(0);
Rhino.Geometry.Interval domV = surfaceA.Domain(1);
double u, v;
u = v = 0.0;
for (u = domU.Min; u <= domU.Max; u += _interval)
{
for (v = domV.Min; v <= domV.Max; v += _interval)
{
Rhino.Geometry.Point3d pt = surfaceA.PointAt(u, v);
Rhino.Geometry.Vector3d n = surfaceA.NormalAt(u, v);
Rhino.Geometry.Point3d pt2 = randomPoint(surfaceA, u, v, _interval, _noise);
doc.Objects.AddPoint(pt2);
}
}
}
return(Rhino.Commands.Result.Success);
}
protected override void SolveInstance(Grasshopper.Kernel.IGH_DataAccess DA)
{
if (!FriedChiken.isInitialized)
{
Rhino.Geometry.Surface s = null;
if (!DA.GetData(0, ref s))
{
return;
}
Rhino.Geometry.Interval uDomain = s.Domain(0);
Rhino.Geometry.Interval vDomain = s.Domain(1);
int[] nEdgeNodes = new int[_dim];
DA.GetData(1, ref nEdgeNodes[0]);
DA.GetData(2, ref nEdgeNodes[1]);
for (int i = 0; i < _dim; i++)
{
if (nEdgeNodes[i] < 2)
{
AddRuntimeMessage(Grasshopper.Kernel.GH_RuntimeMessageLevel.Error, "Integers must be greater than or equal to 2");
return;
}
}
Rhino.Geometry.Mesh m = new Rhino.Geometry.Mesh();
//メッシュノード構築
newNodes.Clear();
for (int i = 0; i < nEdgeNodes[1]; i++)
{
for (int j = 0; j < nEdgeNodes[0]; j++)
{
newNodes.Add(s.PointAt(uDomain.T0 + (uDomain.T1 - uDomain.T0) / (nEdgeNodes[0] - 1) * j, vDomain.T0 + (vDomain.T1 - vDomain.T0) / (nEdgeNodes[1] - 1) * i));
}
}
m.Vertices.AddVertices(newNodes);
int nNewNodes = newNodes.Count;
GH_material mat = null;
GH_gravity gvt = null;
if (!DA.GetData(3, ref mat))
{
return;
}
if (!DA.GetData(4, ref gvt))
{
return;
}
el = MathUtil.isoparametricElements(nEdgeNodes);
int nElements = el.Length;
//メッシュ構築
for (int i = 0; i < nElements; i++)
{
m.Faces.AddFace(el[i][0], el[i][1], el[i][3], el[i][2]);
}
mikity.NumericalMethodHelper.particle[] particles = new mikity.NumericalMethodHelper.particle[nNewNodes];
for (int i = 0; i < nNewNodes; i++)
{
particles[i] = new mikity.NumericalMethodHelper.particle(newNodes[i][0], newNodes[i][1], newNodes[i][2]);
}
eM = new generalSpring();
pS = new GH_particleSystem(particles);
for (int i = 0; i < nElements; i++)
{
if (_subdv == subdivide.quad)
{
eM.addElement(new mikity.NumericalMethodHelper.elements.isoparametricElement(el[i]));
}
if (_subdv == subdivide.triA)
{
eM.addElement(new mikity.NumericalMethodHelper.elements.simplexElement(new int[3] {
el[i][0], el[i][1], el[i][3]
}));
eM.addElement(new mikity.NumericalMethodHelper.elements.simplexElement(new int[3] {
el[i][0], el[i][3], el[i][2]
}));
}
if (_subdv == subdivide.triB)
{
int S = i % (nEdgeNodes[0] - 1);
int T = (i - S) / (nEdgeNodes[0] - 1);
if (T % 2 == 1)
{
S++;
}
if (S % 2 == 0)
{
eM.addElement(new mikity.NumericalMethodHelper.elements.simplexElement(new int[3] {
el[i][0], el[i][1], el[i][3]
}));
eM.addElement(new mikity.NumericalMethodHelper.elements.simplexElement(new int[3] {
el[i][0], el[i][3], el[i][2]
}));
}
else
{
eM.addElement(new mikity.NumericalMethodHelper.elements.simplexElement(new int[3] {
el[i][0], el[i][1], el[i][2]
}));
eM.addElement(new mikity.NumericalMethodHelper.elements.simplexElement(new int[3] {
el[i][2], el[i][1], el[i][3]
}));
}
}
if (_subdv == subdivide.triC)
{
int S = i % (nEdgeNodes[0] - 1);
if (S % 2 == 0)
{
eM.addElement(new mikity.NumericalMethodHelper.elements.simplexElement(new int[3] {
el[i][0], el[i][1], el[i][3]
}));
eM.addElement(new mikity.NumericalMethodHelper.elements.simplexElement(new int[3] {
el[i][0], el[i][3], el[i][2]
}));
}
else
{
eM.addElement(new mikity.NumericalMethodHelper.elements.simplexElement(new int[3] {
el[i][0], el[i][1], el[i][2]
}));
eM.addElement(new mikity.NumericalMethodHelper.elements.simplexElement(new int[3] {
el[i][2], el[i][1], el[i][3]
}));
}
}
}
if (_subdv == subdivide.quad)
{
nElements *= 1;
}
else
{
nElements *= 2;
}
lGeometry = new Rhino.Geometry.Mesh();
lGeometry2 = new Rhino.Geometry.Mesh();
lGeometry.Vertices.Clear();
lGeometry.Faces.Clear();
lGeometry2.Faces.Clear();
for (int i = 0; i < pS.Value.__N; i++)
{
lGeometry.Vertices.Add(particles[i][0], particles[i][1], particles[i][2]);
}
for (int i = 0; i < nElements; i++)
{
if (_subdv == subdivide.quad)
{
lGeometry.Faces.AddFace(eM.elemList[i].el[0], eM.elemList[i].el[1], eM.elemList[i].el[3], eM.elemList[i].el[2]);
}
else
{
lGeometry.Faces.AddFace(eM.elemList[i].el[0], eM.elemList[i].el[1], eM.elemList[i].el[2]);
}
}
for (int i = 0; i < nElements; i++)
{
if (_subdv == subdivide.quad)
{
lGeometry2.Faces.AddFace(eM.elemList[i].el[0], eM.elemList[i].el[1], eM.elemList[i].el[3], eM.elemList[i].el[2]);
}
else
{
lGeometry2.Faces.AddFace(eM.elemList[i].el[0], eM.elemList[i].el[1], eM.elemList[i].el[2]);
}
}
eM.setMaterial(mat.Value, gvt.Value);
pS.Value.addObject(eM);
this.DVPW = GetDVPW(lGeometry);
this.BKGT = GetBKGT(lGeometry);
pS.DVPW = GetDVPW(lGeometry2);
pS.UPGR = GetUPGR(lGeometry2);
pS.BKGT = GetBKGT(lGeometry2);
DA.SetData(0, pS);
DA.SetDataList(1, newNodes);
}
}
protected override void SolveInstance(Grasshopper.Kernel.IGH_DataAccess DA)
{
if (!FriedChiken.isInitialized)
{
Rhino.Geometry.Curve c = null;
if (!DA.GetData(0, ref c))
{
return;
}
Rhino.Geometry.Interval uDomain = c.Domain;
int[] nEdgeNodes = new int[_dim];
DA.GetData(1, ref nEdgeNodes[0]);
for (int i = 0; i < _dim; i++)
{
if (nEdgeNodes[i] < 2)
{
AddRuntimeMessage(Grasshopper.Kernel.GH_RuntimeMessageLevel.Error, "Integers must be greater than or equal to 2");
return;
}
}
lGeometry.Clear();
//メッシュノード構築
newNodes.Clear();
for (int j = 0; j < nEdgeNodes[0]; j++)
{
newNodes.Add(c.PointAt(uDomain.T0 + (uDomain.T1 - uDomain.T0) / (nEdgeNodes[0] - 1) * j));
}
int nNewNodes = newNodes.Count;
GH_material mat = null;
GH_gravity gvt = null;
if (!DA.GetData(2, ref mat))
{
return;
}
if (!DA.GetData(3, ref gvt))
{
return;
}
el = MathUtil.isoparametricElements(nEdgeNodes);
int nElements = el.Length;
mikity.NumericalMethodHelper.particle[] particles = new mikity.NumericalMethodHelper.particle[nNewNodes];
for (int i = 0; i < nNewNodes; i++)
{
particles[i] = new mikity.NumericalMethodHelper.particle(newNodes[i][0], newNodes[i][1], newNodes[i][2]);
}
eM = new generalSpring();
pS = new GH_particleSystem(particles);
for (int i = 0; i < el.Length; i++)
{
mikity.NumericalMethodHelper.elements.isoparametricElement e = new NumericalMethodHelper.elements.isoparametricElement(el[i]);
eM.addElement(e);
}
eM.setMaterial(mat.Value, gvt.Value);
for (int i = 0; i < pS.Value.__N; i++)
{
lGeometry.Add(particles[i][0], particles[i][1], particles[i][2]);
}
this.DVPW = GetDVPW(lGeometry);
pS.DVPW = GetDVPW(lGeometry2);
pS.UPGR = GetUPGR(lGeometry2);
pS.BKGT = GetBKGT(lGeometry2);
pS.Value.addObject(eM);
DA.SetData(0, pS);
DA.SetDataList(1, newNodes);
}
}
public static Aviary.Wind.Mathematics.Domain ToDomain(this Rhino.Geometry.Interval input)
{
return(new Aviary.Wind.Mathematics.Domain(input.T0, input.T1));
}
