public string Export(string path, List <Rhino.Geometry.Brep> bs, Rhino.Geometry.MeshingParameters mp)
{
List <Rhino.Geometry.Mesh> meshes = new List <Rhino.Geometry.Mesh>();
bs.ForEach(p => meshes.AddRange(Rhino.Geometry.Mesh.CreateFromBrep(p, mp)));
return(Export(path, meshes));
}
private static void ExtractGeometry(Grasshopper.Kernel.Data.IGH_Structure volatileData,
ref List <Rhino.Geometry.GeometryBase> resGeom,
bool isRenderMode,
Rhino.Geometry.MeshingParameters meshParams)
{
foreach (var value in volatileData.AllData(true))
{
if (value is IGH_PreviewData)
{
ExtractGeometry(value, ref resGeom, isRenderMode, meshParams);
}
}
}
protected override Result RunCommand(RhinoDoc doc, RunMode mode)
{
Rhino.Geometry.MeshingParameters mp = doc.GetMeshingParameters(Rhino.Geometry.MeshingParameterStyle.Custom);
double relativeTolerance = mp.RelativeTolerance;
Rhino.Input.Custom.GetNumber gn = new Rhino.Input.Custom.GetNumber();
gn.SetCommandPrompt("Custom render mesh density");
gn.SetDefaultNumber(relativeTolerance);
gn.SetLowerLimit(0.0, false);
gn.SetUpperLimit(1.0, false);
gn.AcceptNothing(true);
gn.Get();
if (gn.CommandResult() != Result.Success)
{
return(gn.CommandResult());
}
double newTolerance = gn.Number();
if (newTolerance == relativeTolerance)
{
return(Result.Nothing);
}
Rhino.Geometry.MeshingParameters new_mp = new Rhino.Geometry.MeshingParameters();
new_mp = mp;
new_mp.RelativeTolerance = newTolerance;
doc.SetCustomMeshingParameters(new_mp);
// Toggling the meshing parameter style will destroy existing render meshes,
// which will be recreated when the scene is redrawn.
if (doc.MeshingParameterStyle == Rhino.Geometry.MeshingParameterStyle.Custom)
{
doc.MeshingParameterStyle = Rhino.Geometry.MeshingParameterStyle.Fast;
}
doc.MeshingParameterStyle = Rhino.Geometry.MeshingParameterStyle.Custom;
doc.Views.Redraw();
return(Result.Success);
}
internal static IntPtr ReadIntoProfileContext(System.Runtime.Serialization.SerializationInfo info, string sectionBase)
{
IntPtr pProfileContext = UnsafeNativeMethods.CRhCmnProfileContext_New();
var e = info.GetEnumerator();
while (e.MoveNext())
{
string entry = e.Name.Replace("::", "\\");
string section = sectionBase;
int split_index = entry.LastIndexOf("\\", System.StringComparison.Ordinal);
if (split_index > -1)
{
section = sectionBase + "\\" + entry.Substring(0, split_index);
entry = entry.Substring(split_index + 1);
}
Type t = e.ObjectType;
if( typeof(string) == t )
UnsafeNativeMethods.CRhinoProfileContext_SaveProfileString(pProfileContext, section, entry, e.Value as string);
else if( typeof(Guid) == t )
UnsafeNativeMethods.CRhinoProfileContext_SaveProfileUuid(pProfileContext, section, entry, (Guid)e.Value);
else if( typeof(System.Drawing.Color) == t )
{
System.Drawing.Color c = (System.Drawing.Color)e.Value;
int argb = c.ToArgb();
UnsafeNativeMethods.CRhinoProfileContext_SaveProfileColor(pProfileContext, section, entry, argb);
}
else if( typeof(int) == t )
UnsafeNativeMethods.CRhinoProfileContext_SaveProfileInt(pProfileContext, section, entry, (int)e.Value);
else if( typeof(double) == t )
UnsafeNativeMethods.CRhinoProfileContext_SaveProfileDouble(pProfileContext, section, entry, (double)e.Value);
else if( typeof(System.Drawing.Rectangle) == t )
{
System.Drawing.Rectangle r = (System.Drawing.Rectangle)e.Value;
UnsafeNativeMethods.CRhinoProfileContext_SaveProfileRect(pProfileContext, section, entry, r.Left, r.Top, r.Right, r.Bottom);
}
else if( typeof(System.Drawing.Point) == t )
{
System.Drawing.Point pt = (System.Drawing.Point)e.Value;
UnsafeNativeMethods.CRhinoProfileContext_SaveProfilePoint(pProfileContext, section, entry, pt.X, pt.Y);
}
else if( typeof(Rhino.Geometry.Point3d) == t )
{
Rhino.Geometry.Point3d pt = (Rhino.Geometry.Point3d)e.Value;
UnsafeNativeMethods.CRhinoProfileContext_SaveProfilePoint3d(pProfileContext, section, entry, pt);
}
else if( typeof(Rhino.Geometry.Transform) == t )
{
Rhino.Geometry.Transform xf = (Rhino.Geometry.Transform)e.Value;
UnsafeNativeMethods.CRhinoProfileContext_SaveProfileXform(pProfileContext, section, entry, ref xf);
}
else if( typeof(Rhino.Geometry.Vector3d) == t )
{
Rhino.Geometry.Vector3d v = (Rhino.Geometry.Vector3d)e.Value;
UnsafeNativeMethods.CRhinoProfileContext_SaveProfileVector3d(pProfileContext, section, entry, v);
}
else if( typeof(Rhino.Geometry.MeshingParameters) == t )
{
Rhino.Geometry.MeshingParameters mp = e.Value as Rhino.Geometry.MeshingParameters;
if (mp != null)
{
IntPtr pMp = mp.ConstPointer();
UnsafeNativeMethods.CRhinoProfileContext_SaveProfileMeshingParameters(pProfileContext, section, entry, pMp);
}
}
else if( typeof(byte[]) == t )
{
byte[] b = e.Value as byte[];
if (b != null)
{
UnsafeNativeMethods.CRhinoProfileContext_SaveProfileBuffer(pProfileContext, section, entry, b.Length, b);
}
}
else if (typeof(bool) == t)
UnsafeNativeMethods.CRhinoProfileContext_SaveProfileBool(pProfileContext, section, entry, (bool)e.Value);
else
{
//try
//{
string s = info.GetString(e.Name);
UnsafeNativeMethods.CRhinoProfileContext_SaveProfileString(pProfileContext, section, entry, s);
//}
//catch (Exception ex)
//{
// throw;
//}
}
}
return pProfileContext;
}
protected override Result RunCommand(RhinoDoc doc, RunMode mode)
{
Rhino.DocObjects.ObjRef obj_ref;
const string prompt = "Select surface or polysurface to mesh";
const Rhino.DocObjects.ObjectType object_type =
Rhino.DocObjects.ObjectType.Surface |
Rhino.DocObjects.ObjectType.Brep;
Result res = Rhino.Input.RhinoGet.GetOneObject(prompt, false, object_type, out obj_ref);
if (res != Result.Success)
{
return(res);
}
Rhino.DocObjects.RhinoObject obj = obj_ref.Object();
if (null == obj)
{
return(Result.Failure);
}
Rhino.Geometry.Mesh obj_mesh = new Rhino.Geometry.Mesh();
Rhino.Geometry.Mesh[] meshes = obj.GetMeshes(Rhino.Geometry.MeshType.Render);
if (meshes.Length > 0)
{
foreach (Rhino.Geometry.Mesh m in meshes)
{
obj_mesh.Append(m);
}
}
else
{
Rhino.Geometry.MeshingParameters mesh_params = obj.GetRenderMeshParameters();
if (obj.CreateMeshes(Rhino.Geometry.MeshType.Render, mesh_params, false) > 0)
{
meshes = obj.GetMeshes(Rhino.Geometry.MeshType.Render);
if (meshes.Length > 0)
{
foreach (Rhino.Geometry.Mesh m in meshes)
{
obj_mesh.Append(m);
}
}
}
}
if (obj_mesh.IsValid)
{
obj_mesh.Faces.ConvertQuadsToTriangles();
}
if (obj_mesh.IsValid)
{
doc.Objects.AddMesh(obj_mesh);
doc.Views.Redraw();
}
return(Result.Success);
}
public List <ObjectExportData> SanitizeRhinoObjects(IEnumerable <RhinoObject> rhinoObjects)
{
List <ObjectExportData> explodedObjects = new List <ObjectExportData>();
foreach (var rhinoObject in rhinoObjects)
{
if (rhinoObject.ObjectType == ObjectType.InstanceReference && rhinoObject is InstanceObject instanceObject)
{
List <RhinoObject> pieces = new List <RhinoObject>();
List <Rhino.Geometry.Transform> transforms = new List <Rhino.Geometry.Transform>();
ExplodeRecursive(instanceObject, Rhino.Geometry.Transform.Identity, pieces, transforms);
foreach (var item in pieces.Zip(transforms, (rObj, trans) => (rhinoObject: rObj, trans)))
{
explodedObjects.Add(new ObjectExportData()
{
Object = item.rhinoObject,
Transform = item.trans,
RenderMaterial = GetObjectMaterial(item.rhinoObject),
});
}
}
else
{
explodedObjects.Add(new ObjectExportData()
{
Object = rhinoObject,
RenderMaterial = GetObjectMaterial(rhinoObject),
});
}
}
//Remove Unmeshable
explodedObjects.RemoveAll(x => !x.Object.IsMeshable(Rhino.Geometry.MeshType.Any));
foreach (var item in explodedObjects)
{
//Mesh
if (item.Object.ObjectType == ObjectType.SubD && item.Object.Geometry is Rhino.Geometry.SubD subd)
{
if (options.SubDExportMode == SubDMode.ControlNet)
{
Rhino.Geometry.Mesh mesh = Rhino.Geometry.Mesh.CreateFromSubDControlNet(subd);
mesh.Transform(item.Transform);
item.Meshes = new Rhino.Geometry.Mesh[] { mesh };
}
else
{
int level = options.SubDLevel;
Rhino.Geometry.Mesh mesh = Rhino.Geometry.Mesh.CreateFromSubD(subd, level);
mesh.Transform(item.Transform);
item.Meshes = new Rhino.Geometry.Mesh[] { mesh };
}
}
else
{
Rhino.Geometry.MeshingParameters parameters = item.Object.GetRenderMeshParameters();
if (item.Object.MeshCount(Rhino.Geometry.MeshType.Render, parameters) == 0)
{
item.Object.CreateMeshes(Rhino.Geometry.MeshType.Render, parameters, false);
}
List <Rhino.Geometry.Mesh> meshes = new List <Rhino.Geometry.Mesh>(item.Object.GetMeshes(Rhino.Geometry.MeshType.Render));
foreach (Rhino.Geometry.Mesh mesh in meshes)
{
mesh.EnsurePrivateCopy();
mesh.Transform(item.Transform);
}
//Remove bad meshes
meshes.RemoveAll(x => x == null || !MeshIsValidForExport(x));
item.Meshes = meshes.ToArray();
}
}
//Remove meshless objects
explodedObjects.RemoveAll(x => x.Meshes.Length == 0);
return(explodedObjects);
}
public static Complex[][] Finite_Radiation_Impedance_Rect_Longhand(double x, double y, Rhino.Geometry.Brep S, double freq, double[] altitude, double[] azimuth, double C_Sound)
{
Complex[][] Zr = new Complex[altitude.Length][];
double lambda = C_Sound / freq;
double step = lambda / 30;
double A = Rhino.Geometry.AreaMassProperties.Compute(S).Area;
Rhino.Geometry.MeshingParameters MP = new Rhino.Geometry.MeshingParameters();
MP.MaximumEdgeLength = step;
Rhino.Geometry.Mesh M = Rhino.Geometry.Mesh.CreateFromBrep(S, MP)[0];
Complex integral_Mod = Complex.ImaginaryOne * Utilities.Numerics.PiX2 * freq * 1.2 / A;
List <double> Areas = new List <double>();
List <Rhino.Geometry.Point3d> pts = new List <Rhino.Geometry.Point3d>();
for (int f = 0; f < M.Faces.Count; f++)
{
if (M.Faces[f].IsQuad)
{
Hare.Geometry.Point[][] verts = new Hare.Geometry.Point[1][];
verts[0] = new Hare.Geometry.Point[] {
new Hare.Geometry.Point(M.Vertices[M.Faces[f].A].X, M.Vertices[M.Faces[f].A].Y, M.Vertices[M.Faces[f].A].Z),
new Hare.Geometry.Point(M.Vertices[M.Faces[f].B].X, M.Vertices[M.Faces[f].B].Y, M.Vertices[M.Faces[f].B].Z),
new Hare.Geometry.Point(M.Vertices[M.Faces[f].C].X, M.Vertices[M.Faces[f].C].Y, M.Vertices[M.Faces[f].C].Z),
new Hare.Geometry.Point(M.Vertices[M.Faces[f].D].X, M.Vertices[M.Faces[f].D].Y, M.Vertices[M.Faces[f].D].Z)
};
Areas.Add(new Hare.Geometry.Topology(verts).Polygon_Area(0));
}
else
{
Hare.Geometry.Point[][] verts = new Hare.Geometry.Point[1][];
verts[0] = new Hare.Geometry.Point[] {
new Hare.Geometry.Point(M.Vertices[M.Faces[f].A].X, M.Vertices[M.Faces[f].A].Y, M.Vertices[M.Faces[f].A].Z),
new Hare.Geometry.Point(M.Vertices[M.Faces[f].B].X, M.Vertices[M.Faces[f].B].Y, M.Vertices[M.Faces[f].B].Z),
new Hare.Geometry.Point(M.Vertices[M.Faces[f].C].X, M.Vertices[M.Faces[f].C].Y, M.Vertices[M.Faces[f].C].Z)
};
Areas.Add(new Hare.Geometry.Topology(verts).Polygon_Area(0));
}
pts.Add(M.Faces.GetFaceCenter(f));
}
Parallel.For(0, altitude.Length, j =>
{
double k = Utilities.Numerics.PiX2 / C_Sound;
double kt = k * Math.Sin(Math.Abs(altitude[j]) * Math.PI / 180);
Zr[j] = new Complex[azimuth.Length];
for (int phi = 0; phi < azimuth.Length; phi++) //Parallel.For(0, 16, phi =>
{
double cosphi = Math.Cos(azimuth[phi] * Math.PI / 180), sinphi = Math.Sin(azimuth[phi] * Math.PI / 180);
for (int i = 0; i < pts.Count; i++)
{
double xd = pts[i].X - x, yd = pts[i].Y - y;
double R = Math.Sqrt(xd * xd + yd * yd);
Complex GMM = Complex.Exp(-Complex.ImaginaryOne * k * freq * R) / (Utilities.Numerics.PiX2 * R);
Complex PiMPiM0 = Complex.Exp(Complex.ImaginaryOne * kt * freq * (cosphi * xd + sinphi * yd));
Zr[j][phi] += GMM * PiMPiM0 * Areas[i];
}
///By distributive property, all multipliers moved to outer loop.
Zr[j][phi] *= integral_Mod;
//Zr[j][35 - phi] = Zr[j][phi];
///this is now Zr for a given angle theta.
}
});
return(Zr);
}
private static void ExtractGeometry(Grasshopper.Kernel.Types.IGH_Goo iGoo,
ref List <Rhino.Geometry.GeometryBase> resGeom,
bool isRenderMode,
Rhino.Geometry.MeshingParameters meshParams)
{
if (iGoo is Grasshopper.Kernel.Types.GH_GeometryGroup group)
{
foreach (var geomGoo in group.Objects)
{
ExtractGeometry(geomGoo, ref resGeom, isRenderMode, meshParams);
}
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 (!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, meshParams));
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 static Complex[][] Finite_Radiation_Impedance_Rect_Longhand(double x, double y, Rhino.Geometry.Brep S, double freq, double[] altitude, double[] azimuth, double C_Sound)
{
Complex[][] Zr = new Complex[altitude.Length][];
double lambda = C_Sound / freq;
double step = lambda / 30;
double A = Rhino.Geometry.AreaMassProperties.Compute(S).Area;
Rhino.Geometry.MeshingParameters MP = new Rhino.Geometry.MeshingParameters();
MP.MaximumEdgeLength = step;
Rhino.Geometry.Mesh M = Rhino.Geometry.Mesh.CreateFromBrep(S, MP)[0];
Complex integral_Mod = Complex.ImaginaryOne * Utilities.Numerics.PiX2 * freq * 1.2 / A;
List<double> Areas = new List<double>();
List<Rhino.Geometry.Point3d> pts = new List<Rhino.Geometry.Point3d>();
for (int f = 0; f < M.Faces.Count; f++)
{
if (M.Faces[f].IsQuad)
{
Hare.Geometry.Point[][] verts = new Hare.Geometry.Point[1][];
verts[0] = new Hare.Geometry.Point[]{
new Hare.Geometry.Point(M.Vertices[M.Faces[f].A].X, M.Vertices[M.Faces[f].A].Y, M.Vertices[M.Faces[f].A].Z),
new Hare.Geometry.Point(M.Vertices[M.Faces[f].B].X, M.Vertices[M.Faces[f].B].Y, M.Vertices[M.Faces[f].B].Z),
new Hare.Geometry.Point(M.Vertices[M.Faces[f].C].X, M.Vertices[M.Faces[f].C].Y, M.Vertices[M.Faces[f].C].Z),
new Hare.Geometry.Point(M.Vertices[M.Faces[f].D].X, M.Vertices[M.Faces[f].D].Y, M.Vertices[M.Faces[f].D].Z)};
Areas.Add(new Hare.Geometry.Topology(verts).Polygon_Area(0));
}
else
{
Hare.Geometry.Point[][] verts = new Hare.Geometry.Point[1][];
verts[0] = new Hare.Geometry.Point[]{
new Hare.Geometry.Point(M.Vertices[M.Faces[f].A].X, M.Vertices[M.Faces[f].A].Y, M.Vertices[M.Faces[f].A].Z),
new Hare.Geometry.Point(M.Vertices[M.Faces[f].B].X, M.Vertices[M.Faces[f].B].Y, M.Vertices[M.Faces[f].B].Z),
new Hare.Geometry.Point(M.Vertices[M.Faces[f].C].X, M.Vertices[M.Faces[f].C].Y, M.Vertices[M.Faces[f].C].Z)};
Areas.Add(new Hare.Geometry.Topology(verts).Polygon_Area(0));
}
pts.Add(M.Faces.GetFaceCenter(f));
}
Parallel.For(0, altitude.Length, j =>
{
double k = Utilities.Numerics.PiX2 / C_Sound;
double kt = k * Math.Sin(Math.Abs(altitude[j]) * Math.PI / 180);
Zr[j] = new Complex[azimuth.Length];
for (int phi = 0; phi < azimuth.Length; phi++) //Parallel.For(0, 16, phi =>
{
double cosphi = Math.Cos(azimuth[phi] * Math.PI / 180), sinphi = Math.Sin(azimuth[phi] * Math.PI / 180);
for (int i = 0; i < pts.Count; i++)
{
double xd = pts[i].X - x, yd = pts[i].Y - y;
double R = Math.Sqrt(xd * xd + yd * yd);
Complex GMM = Complex.Exp(-Complex.ImaginaryOne * k * freq * R) / (Utilities.Numerics.PiX2 * R);
Complex PiMPiM0 = Complex.Exp(Complex.ImaginaryOne * kt * freq * (cosphi * xd + sinphi * yd));
Zr[j][phi] += GMM * PiMPiM0 * Areas[i];
}
///By distributive property, all multipliers moved to outer loop.
Zr[j][phi] *= integral_Mod;
//Zr[j][35 - phi] = Zr[j][phi];
///this is now Zr for a given angle theta.
}
});
return Zr;
}
