protected override Result RunCommand(RhinoDoc doc, RunMode mode)
{
Rhino.DocObjects.ObjectType filter = Rhino.DocObjects.ObjectType.Mesh;
Rhino.DocObjects.ObjRef objref = null;
Rhino.Commands.Result rc = Rhino.Input.RhinoGet.GetOneObject("Select mesh to contour", false, filter, out objref);
if (rc != Rhino.Commands.Result.Success || objref == null)
{
return(rc);
}
Rhino.Geometry.Mesh mesh = objref.Geometry() as Rhino.Geometry.Mesh;
if (null == mesh)
{
return(Rhino.Commands.Result.Failure);
}
Rhino.Geometry.BoundingBox bbox = mesh.GetBoundingBox(false);
Rhino.Geometry.Point3d start_pt = bbox.Corner(true, true, true);
Rhino.Geometry.Point3d end_pt = bbox.Corner(false, true, true);
double interval = start_pt.DistanceTo(end_pt) / 10;
Rhino.Geometry.Curve[] curves = Rhino.Geometry.Mesh.CreateContourCurves(mesh, start_pt, end_pt, interval);
if (null != curves && curves.Length > 0)
{
for (int i = 0; i < curves.Length; i++)
{
doc.Objects.AddCurve(curves[i]);
}
doc.Views.Redraw();
}
return(Result.Success);
}
//Convert a Rhino mesh to a Media 3d Model
public static GeometryModel3D ToHelixModel(this Rhino.Geometry.Mesh input)
{
MeshGeometry3D mesh = new MeshGeometry3D();
input.Faces.ConvertQuadsToTriangles();
foreach (Rhino.Geometry.Point3d pt in input.Vertices)
{
mesh.Positions.Add(pt.ToHelixPoint());
}
foreach (Rhino.Geometry.Vector3d vc in input.Normals)
{
mesh.Normals.Add(vc.ToHelixVector());
}
foreach (Rhino.Geometry.MeshFace face in input.Faces)
{
mesh.TriangleIndices.Add(face.A);
mesh.TriangleIndices.Add(face.B);
mesh.TriangleIndices.Add(face.C);
}
GeometryModel3D model = new GeometryModel3D();
model.Geometry = mesh;
model.Material = new DiffuseMaterial(new SolidColorBrush(Colors.LightGray));
model.BackMaterial = new DiffuseMaterial(new SolidColorBrush(Colors.LightGray));
return(model);
}
void CommitInstance
(
Document doc, IGH_DataAccess DA, int Iteration,
Rhino.Geometry.Mesh mesh
)
{
var element = PreviousElement(doc, Iteration);
try
{
if (mesh == null)
{
throw new NullReferenceException($"Parameter '{Params.Input[0].Name}' not set to an instance of a Mesh.");
}
if (!mesh.IsValidWithLog(out var log))
{
foreach (var line in log.Split(new[] { "\r\n", "\r", "\n" }, StringSplitOptions.RemoveEmptyEntries))
{
AddRuntimeMessage(GH_RuntimeMessageLevel.Warning, line);
}
throw new Exception($"Parameter '{Params.Input[0].Name}' not set to a valid Mesh.");
}
var scaleFactor = 1.0 / Revit.ModelUnits;
if (scaleFactor != 1.0)
{
mesh.Scale(scaleFactor);
}
var shape = new List <GeometryObject>();
foreach (var geometry in mesh.ToHost().SelectMany(x => x.ToDirectShapeGeometry()))
{
// DirectShape only accepts those types and no nulls
switch (geometry)
{
case Point p: shape.Add(p); break;
case Curve c: shape.Add(c); break;
case Solid s: shape.Add(s); break;
case Mesh m: shape.Add(m); break;
}
}
var ds = element as DirectShape ?? CopyParametersFrom(DirectShape.CreateElement(doc, new ElementId(BuiltInCategory.OST_GenericModel)), element);
ds.SetShape(shape);
element = ds;
ReplaceElement(doc, DA, Iteration, element);
}
catch (Exception e)
{
AddRuntimeMessage(GH_RuntimeMessageLevel.Error, e.Message);
ReplaceElement(doc, DA, Iteration, null);
}
}
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);
}
public GltfMeshHolder Convert()
{
GltfMeshHolder meshHolder = new GltfMeshHolder(converter, doc);
foreach (var primitive in mesh.Primitives)
{
Rhino.Geometry.Mesh rhinoMesh = GetMesh(primitive);
if (rhinoMesh == null)
{
continue;
}
rhinoMesh.Weld(0.01);
rhinoMesh.Compact();
if (!rhinoMesh.IsValidWithLog(out string log))
{
Rhino.RhinoApp.WriteLine(log);
}
meshHolder.AddPrimitive(rhinoMesh, primitive.Material, mesh.Name);
}
return(meshHolder);
}
void ReconstructDirectShapeByMesh
(
DB.Document doc,
ref DB.DirectShape element,
Rhino.Geometry.Mesh mesh
)
{
if (!ThrowIfNotValid(nameof(mesh), mesh))
{
return;
}
if (element is DB.DirectShape ds)
{
}
else
{
ds = DB.DirectShape.CreateElement(doc, new DB.ElementId(DB.BuiltInCategory.OST_GenericModel));
}
using (var ctx = GeometryEncoder.Context.Push(ds))
{
ctx.RuntimeMessage = (severity, message, invalidGeometry) =>
AddGeometryConversionError((GH_RuntimeMessageLevel)severity, message, invalidGeometry);
ds.SetShape(mesh.ToShape().OfType <DB.GeometryObject>().ToList());
}
ReplaceElement(ref element, ds);
}
protected static IndexBuffer ToWireframeBuffer(Rhino.Geometry.Mesh mesh, out int linesCount)
{
linesCount = (mesh.Faces.Count * 3) + mesh.Faces.QuadCount;
if (linesCount > 0)
{
var ib = new IndexBuffer(linesCount * IndexLine.GetSizeInShortInts());
ib.Map(linesCount * IndexLine.GetSizeInShortInts());
using (var istream = ib.GetIndexStreamLine())
{
foreach (var face in mesh.Faces)
{
istream.AddLine(new IndexLine(face.A, face.B));
istream.AddLine(new IndexLine(face.B, face.C));
istream.AddLine(new IndexLine(face.C, face.D));
if (face.IsQuad)
{
istream.AddLine(new IndexLine(face.D, face.A));
}
}
}
ib.Unmap();
return(ib);
}
return(null);
}
public void AddInstance(Rhino.Geometry.Transform transform)
{
foreach (GltfMeshMaterialPair pair in meshMaterialPairs)
{
Rhino.Geometry.Mesh rhinoMesh = pair.RhinoMesh.DuplicateMesh();
rhinoMesh.Transform(GltfUtils.YupToZup * transform);
rhinoMesh.TextureCoordinates.ReverseTextureCoordinates(1);
Guid objectId = doc.Objects.AddMesh(rhinoMesh);
Rhino.DocObjects.RhinoObject rhinoObject = doc.Objects.Find(objectId);
Rhino.Render.RenderMaterial material = converter.GetMaterial(pair.MaterialIndex);
if (rhinoObject != null && material != null)
{
rhinoObject.RenderMaterial = material;
rhinoObject.Attributes.MaterialSource = Rhino.DocObjects.ObjectMaterialSource.MaterialFromObject;
rhinoObject.Attributes.Name = pair.Name;
rhinoObject.CommitChanges();
}
}
}
void ReconstructDirectShapeByMesh
(
Document doc,
ref Autodesk.Revit.DB.Element element,
Rhino.Geometry.Mesh mesh
)
{
var scaleFactor = 1.0 / Revit.ModelUnits;
ThrowIfNotValid(nameof(mesh), mesh);
if (element is DirectShape ds)
{
}
else
{
ds = DirectShape.CreateElement(doc, new ElementId(BuiltInCategory.OST_GenericModel));
}
var shape = mesh.
ToHostMultiple(scaleFactor).
SelectMany(x => x.ToDirectShapeGeometry());
ds.SetShape(shape.ToList());
ReplaceElement(ref element, ds);
}
public static Rhino.Geometry.Mesh ToRhino(this DMesh3 dMesh3)
{
Rhino.Geometry.Mesh rhMs = new Rhino.Geometry.Mesh();
List <Rhino.Geometry.MeshFace> rhFaces = new List <Rhino.Geometry.MeshFace>();
List <Rhino.Geometry.Point3f> rhVertices = new List <Rhino.Geometry.Point3f>();
DMesh3 copy;
if (!dMesh3.IsCompact)
{
copy = new DMesh3(dMesh3, true);
}
else
{
copy = dMesh3;
}
foreach (var tri in copy.Triangles())
{
rhMs.Faces.AddFace(new Rhino.Geometry.MeshFace(tri.a, tri.b, tri.c));
}
foreach (var vert in copy.Vertices())
{
rhMs.Vertices.Add((float)vert.x, (float)vert.y, (float)vert.z);
}
foreach (int ind in copy.VertexIndices())
{
Vector3f col = copy.GetVertexColor(ind);
rhMs.VertexColors.Add((int)(col.x * 255), (int)(col.y * 255), (int)(col.z * 255));
}
return(rhMs);
}
public static Rhino.Commands.Result AddMesh(Rhino.RhinoDoc doc)
{
Rhino.Geometry.Mesh mesh = new Rhino.Geometry.Mesh();
mesh.Vertices.Add(0.0, 0.0, 1.0); //0
mesh.Vertices.Add(1.0, 0.0, 1.0); //1
mesh.Vertices.Add(2.0, 0.0, 1.0); //2
mesh.Vertices.Add(3.0, 0.0, 0.0); //3
mesh.Vertices.Add(0.0, 1.0, 1.0); //4
mesh.Vertices.Add(1.0, 1.0, 2.0); //5
mesh.Vertices.Add(2.0, 1.0, 1.0); //6
mesh.Vertices.Add(3.0, 1.0, 0.0); //7
mesh.Vertices.Add(0.0, 2.0, 1.0); //8
mesh.Vertices.Add(1.0, 2.0, 1.0); //9
mesh.Vertices.Add(2.0, 2.0, 1.0); //10
mesh.Vertices.Add(3.0, 2.0, 1.0); //11
mesh.Faces.AddFace(0, 1, 5, 4);
mesh.Faces.AddFace(1, 2, 6, 5);
mesh.Faces.AddFace(2, 3, 7, 6);
mesh.Faces.AddFace(4, 5, 9, 8);
mesh.Faces.AddFace(5, 6, 10, 9);
mesh.Faces.AddFace(6, 7, 11, 10);
mesh.Normals.ComputeNormals();
mesh.Compact();
if (doc.Objects.AddMesh(mesh) != Guid.Empty)
{
doc.Views.Redraw();
return Rhino.Commands.Result.Success;
}
return Rhino.Commands.Result.Failure;
}
public static Rhino.Geometry.Mesh MeshBox(double x, double y, double z)
{
Rhino.Geometry.Mesh mesh = new Rhino.Geometry.Mesh();
mesh.Vertices.Add(0, 0, 0);
mesh.Vertices.Add(x, 0, 0);
mesh.Vertices.Add(x, y, 0);
mesh.Vertices.Add(0, y, 0);
mesh.Vertices.Add(0, 0, z);
mesh.Vertices.Add(x, 0, z);
mesh.Vertices.Add(x, y, z);
mesh.Vertices.Add(0, y, z);
mesh.Faces.AddFace(3, 2, 1, 0);
mesh.Faces.AddFace(4, 5, 6, 7);
mesh.Faces.AddFace(0, 1, 5, 4);
mesh.Faces.AddFace(1, 2, 6, 5);
mesh.Faces.AddFace(2, 3, 7, 6);
mesh.Faces.AddFace(3, 0, 4, 7);
mesh.Normals.ComputeNormals();
mesh.Compact();
if (mesh.IsValid)
{
return(mesh);
}
return(null);
}
public static Rhino.Commands.Result AddMesh(Rhino.RhinoDoc doc)
{
Rhino.Geometry.Mesh mesh = new Rhino.Geometry.Mesh();
mesh.Vertices.Add(0.0, 0.0, 1.0); //0
mesh.Vertices.Add(1.0, 0.0, 1.0); //1
mesh.Vertices.Add(2.0, 0.0, 1.0); //2
mesh.Vertices.Add(3.0, 0.0, 0.0); //3
mesh.Vertices.Add(0.0, 1.0, 1.0); //4
mesh.Vertices.Add(1.0, 1.0, 2.0); //5
mesh.Vertices.Add(2.0, 1.0, 1.0); //6
mesh.Vertices.Add(3.0, 1.0, 0.0); //7
mesh.Vertices.Add(0.0, 2.0, 1.0); //8
mesh.Vertices.Add(1.0, 2.0, 1.0); //9
mesh.Vertices.Add(2.0, 2.0, 1.0); //10
mesh.Vertices.Add(3.0, 2.0, 1.0); //11
mesh.Faces.AddFace(0, 1, 5, 4);
mesh.Faces.AddFace(1, 2, 6, 5);
mesh.Faces.AddFace(2, 3, 7, 6);
mesh.Faces.AddFace(4, 5, 9, 8);
mesh.Faces.AddFace(5, 6, 10, 9);
mesh.Faces.AddFace(6, 7, 11, 10);
mesh.Normals.ComputeNormals();
mesh.Compact();
if (doc.Objects.AddMesh(mesh) != Guid.Empty)
{
doc.Views.Redraw();
return(Rhino.Commands.Result.Success);
}
return(Rhino.Commands.Result.Failure);
}
public static DMesh3 ToDMesh3(this Rhino.Geometry.Mesh ms)
{
int numV = ms.Vertices.Count;
int numF = ms.Faces.Count;
int numC = ms.VertexColors.Count;
List <Vector3f> Vertices = new List <Vector3f>(numV);
List <Vector3i> Triangles = new List <Vector3i>(numF);
for (int i = 0; i < numV; i++)
{
Vertices.Add(ms.Vertices[i].ToVec3f());
}
for (int i = 0; i < numF; i++)
{
Triangles.Add(ms.Faces[i].ToVec3i());
}
DMesh3 dMs = DMesh3Builder.Build <Vector3f, Vector3i, Vector3f>(Vertices, Triangles);
if (numV == numC)
{
dMs.EnableVertexColors(new Vector3f(0.5, 0.5, 0.5));
for (int i = 0; i < numV; i++)
{
dMs.SetVertexColor(i, new Vector3f((float)ms.VertexColors[i].R / 255, (float)ms.VertexColors[i].G / 255, (float)ms.VertexColors[i].B / 255));
}
}
return(dMs);
}
public void AddPrimitive(Rhino.Geometry.Mesh rhinoMesh, int?materialIndex, string name)
{
meshMaterialPairs.Add(new GltfMeshMaterialPair()
{
RhinoMesh = rhinoMesh,
MaterialIndex = materialIndex,
Name = name,
});
}
public Guid DrawObjectWithSpecificLayer(Rhino.Geometry.Mesh mesh, NamedLayer layername)
{
Rhino.RhinoDoc.ActiveDoc.Layers.SetCurrentLayerIndex(layerIndexes[(int)layername], false);
var result = Rhino.RhinoDoc.ActiveDoc.Objects.AddMesh(mesh);
Rhino.RhinoDoc.ActiveDoc.Layers.SetCurrentLayerIndex(0, false);
return(result);
}
public void DoSomething()
{
var sphere = new Rhino.Geometry.Sphere(Rhino.Geometry.Point3d.Origin, 10);
mesh = Rhino.Geometry.Mesh.CreateFromSphere(sphere, 10, 10);
mesh.Faces.ConvertQuadsToTriangles();
mesh.Flip(true, true, true);
FMessage.Log(ELogVerbosity.Warning, "Created a mesh with " + mesh.Vertices.Count.ToString() + " vertices and " + mesh.Vertices.Count.ToString() + " Faces.");
}
public static Scene <Model> BuildScene(List <Rhino.Geometry.Mesh> meshes)
{
var merged_mesh = new Rhino.Geometry.Mesh();
foreach (var m in meshes)
{
merged_mesh.Append(m);
}
return(BuildScene(merged_mesh));
}
public BakeGeometry GetBKGT(Rhino.Geometry.Mesh m)
{
return(new BakeGeometry((d, a, o) =>
{
Rhino.DocObjects.ObjectAttributes a2 = a.Duplicate();
a2.LayerIndex = 1;
Guid id = d.Objects.AddMesh(m, a2);
o.Add(id);
}));
}
// This function will be called from a component in Grasshopper
void FromGrasshopper(object sender, Rhino.Runtime.NamedParametersEventArgs args)
{
Rhino.Geometry.GeometryBase[] values;
if (args.TryGetGeometry("mesh", out values))
{
mesh = values[0] as Rhino.Geometry.Mesh;
mesh.Faces.ConvertQuadsToTriangles();
mesh.Flip(true, true, true);
}
}
public static Rhino.Geometry.Mesh UnionMesh(List <Rhino.Geometry.Mesh> meshes)
{
Rhino.Geometry.Mesh outMesh = new Rhino.Geometry.Mesh();
foreach (Rhino.Geometry.Mesh m in meshes)
{
outMesh.Append(m);
}
return(outMesh);
}
private bool HandleTriangleFanMode(Rhino.Geometry.Mesh rhinoMesh)
{
for (int i = 1; i < rhinoMesh.Vertices.Count - 1; i++)
{
Rhino.Geometry.MeshFace face = new Rhino.Geometry.MeshFace(0, i, i + 1);
rhinoMesh.Faces.AddFace(face);
}
return(true);
}
private bool HandleTriangleStripMode(Rhino.Geometry.Mesh rhinoMesh)
{
for (int i = 0; i < rhinoMesh.Vertices.Count - 2; i++)
{
Rhino.Geometry.MeshFace face = new Rhino.Geometry.MeshFace(i, i + 1, i + 2);
rhinoMesh.Faces.AddFace(face);
}
return(true);
}
void DrawData(Grasshopper.Kernel.Data.IGH_Structure volatileData, IGH_DocumentObject docObject)
{
if (!volatileData.IsEmpty)
{
foreach (var value in volatileData.AllData(true))
{
// First check for IGH_PreviewData to discard no graphic elements like strings, doubles, vectors...
if (value is IGH_PreviewData)
{
switch (value.ScriptVariable())
{
case Rhino.Geometry.Point3d point: primitives.Add(new ParamPrimitive(docObject, new Rhino.Geometry.Point(point))); break;
case Rhino.Geometry.Line line: primitives.Add(new ParamPrimitive(docObject, new Rhino.Geometry.LineCurve(line))); break;
case Rhino.Geometry.Rectangle3d rect: primitives.Add(new ParamPrimitive(docObject, rect.ToNurbsCurve())); break;
case Rhino.Geometry.Arc arc: primitives.Add(new ParamPrimitive(docObject, new Rhino.Geometry.ArcCurve(arc))); break;
case Rhino.Geometry.Circle circle: primitives.Add(new ParamPrimitive(docObject, new Rhino.Geometry.ArcCurve(circle))); break;
case Rhino.Geometry.Ellipse ellipse: primitives.Add(new ParamPrimitive(docObject, ellipse.ToNurbsCurve())); break;
case Rhino.Geometry.Curve curve: primitives.Add(new ParamPrimitive(docObject, curve)); break;
case Rhino.Geometry.Mesh mesh: primitives.Add(new ParamPrimitive(docObject, mesh)); break;
case Rhino.Geometry.Box box:
{
var boxMeshes = Rhino.Geometry.Mesh.CreateFromBox(box, 1, 1, 1);
if (boxMeshes != null)
{
primitives.Add(new ParamPrimitive(docObject, boxMeshes));
}
}
break;
case Rhino.Geometry.Brep brep:
{
var brepMeshes = Rhino.Geometry.Mesh.CreateFromBrep(brep, activeDefinition.PreviewCurrentMeshParameters());
if (brepMeshes != null)
{
var previewMesh = new Rhino.Geometry.Mesh();
previewMesh.Append(brepMeshes);
primitives.Add(new ParamPrimitive(docObject, previewMesh));
}
}
break;
}
}
}
}
}
public UpdateGeometry GetUPGR(Rhino.Geometry.Mesh m)
{
return(new UpdateGeometry((x, y, z) =>
{
m.Vertices.Clear();
for (int i = 0; i < pS.Value.__N; i++)
{
m.Vertices.Add(pS.Value.particles[i, 0] + x, pS.Value.particles[i, 1] + y, pS.Value.particles[i, 2] + z);
}
}));
}
public Rhino.Geometry.Mesh Mesh(int index)
{
IntPtr pMesh = UnsafeNativeMethods.Rdk_CustomMeshes_Mesh(ConstPointer(), index);
if (pMesh != IntPtr.Zero)
{
Rhino.Geometry.Mesh mesh = new Rhino.Geometry.Mesh(pMesh, null);
mesh.DoNotDestructOnDispose();
return(mesh);
}
return(null);
}
public static Rhino.Commands.Result UnrollSurface2(Rhino.RhinoDoc doc)
{
const ObjectType filter = Rhino.DocObjects.ObjectType.Brep | Rhino.DocObjects.ObjectType.Surface;
Rhino.DocObjects.ObjRef objref;
Result rc = Rhino.Input.RhinoGet.GetOneObject("Select surface or brep to unroll", false, filter, out objref);
if (rc != Rhino.Commands.Result.Success)
{
return(rc);
}
Rhino.Geometry.Unroller unroll = null;
Rhino.Geometry.Brep brep = objref.Brep();
Rhino.Geometry.Mesh mesh = null;
if (brep != null)
{
unroll = new Rhino.Geometry.Unroller(brep);
mesh = brep.Faces[0].GetMesh(Rhino.Geometry.MeshType.Render);
}
else
{
Rhino.Geometry.Surface srf = objref.Surface();
if (srf != null)
{
unroll = new Rhino.Geometry.Unroller(srf);
}
}
if (unroll == null || mesh == null)
{
return(Rhino.Commands.Result.Cancel);
}
unroll.AddFollowingGeometry(mesh.Vertices.ToPoint3dArray());
unroll.ExplodeOutput = false;
Rhino.Geometry.Curve[] curves;
Rhino.Geometry.Point3d[] points;
Rhino.Geometry.TextDot[] dots;
unroll.PerformUnroll(out curves, out points, out dots);
// change the mesh vertices to the flattened form and add it to the document
if (points.Length == mesh.Vertices.Count)
{
for (int i = 0; i < points.Length; i++)
{
mesh.Vertices.SetVertex(i, points[i]);
}
mesh.Normals.ComputeNormals();
}
doc.Objects.AddMesh(mesh, objref.Object().Attributes);
doc.Views.Redraw();
return(Rhino.Commands.Result.Success);
}
protected override void SolveInstance(IGH_DataAccess DA)
{
Rhino.Geometry.Mesh mesh = null;
if (!DA.GetData("Mesh", ref mesh))
{
return;
}
DA.DisableGapLogic();
int Iteration = DA.Iteration;
Revit.EnqueueAction((doc) => CommitInstance(doc, DA, Iteration, (Rhino.Geometry.Mesh)mesh?.DuplicateShallow()));
}
protected override void SolveInstance(Grasshopper.Kernel.IGH_DataAccess DA)
{
if (!DA.GetData(1, ref v))
{
return;
}
if (!FriedChiken.isInitialized)
{
Rhino.Geometry.Mesh m = null;
if (!DA.GetData(0, ref m))
{
return;
}
newNodes.Clear();
newNodes.AddRange(m.Vertices.ToPoint3dArray());
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);
}
public static Rhino.Geometry.Mesh ToRhinoMesh(this Mesh source)
{
// empty rhino mesh
var rMesh = new Rhino.Geometry.Mesh();
// add vertices
foreach (var vertex in source.Vertices)
{
rMesh.Vertices.Add(vertex.Position.X, vertex.Position.Y, vertex.Position.Z);
}
// add faces
foreach (var face in source.Faces)
{
switch (face.Vertices.Length)
{
case 3:
rMesh.Faces.AddFace(face.Vertices[0].Index, face.Vertices[1].Index, face.Vertices[2].Index);
break;
case 4:
rMesh.Faces.AddFace(face.Vertices[0].Index, face.Vertices[1].Index, face.Vertices[2].Index, face.Vertices[3].Index);
break;
default:
// triangulate about face center (fan)
var center = Vec3d.Average(face.Vertices.Select(v => v.Position).ToList()).ToPoint3d();
rMesh.Vertices.Add(center);
var faceIndices = new int[face.Vertices.Length];
for (int i = 0; i < face.Vertices.Length; i++)
{
faceIndices[i] =
rMesh.Faces
.AddFace(
face.Vertices[i].Index,
face.Vertices[(i + 1) % face.Vertices.Length].Index,
rMesh.Vertices.Count - 1);
}
rMesh.Ngons.AddNgon(Rhino.Geometry.MeshNgon.Create(face.Vertices.Select(v => v.Index).ToList(), faceIndices));
break;
}
}
// clean up
rMesh.Normals.ComputeNormals();
return(rMesh);
}
void CommitInstance
(
Document doc, IGH_DataAccess DA, int Iteration,
Rhino.Geometry.Mesh mesh
)
{
var element = PreviousElement(doc, Iteration);
try
{
if (mesh == null || !mesh.IsValid)
{
throw new Exception(string.Format("Parameter '{0}' must be valid Mesh.", Params.Input[0].Name));
}
var scaleFactor = 1.0 / Revit.ModelUnits;
if (scaleFactor != 1.0)
{
mesh.Scale(scaleFactor);
}
var shape = new List <GeometryObject>();
foreach (var geometry in mesh.ToHost().SelectMany(x => x.ToDirectShapeGeometry()))
{
// DirectShape only accepts those types and no nulls
switch (geometry)
{
case Point p: shape.Add(p); break;
case Curve c: shape.Add(c); break;
case Solid s: shape.Add(s); break;
case Mesh m: shape.Add(m); break;
}
}
var ds = element as DirectShape ?? CopyParametersFrom(DirectShape.CreateElement(doc, new ElementId(BuiltInCategory.OST_GenericModel)), element);
ds.SetShape(shape);
element = ds;
ReplaceElement(doc, DA, Iteration, element);
}
catch (Exception e)
{
AddRuntimeMessage(GH_RuntimeMessageLevel.Error, e.Message);
ReplaceElement(doc, DA, Iteration, null);
}
}
public static Rhino.Geometry.Mesh MeshBox(double x, double y, double z)
{
Rhino.Geometry.Mesh mesh = new Rhino.Geometry.Mesh();
mesh.Vertices.Add(0, 0, 0);
mesh.Vertices.Add(x, 0, 0);
mesh.Vertices.Add(x, y, 0);
mesh.Vertices.Add(0, y, 0);
mesh.Vertices.Add(0, 0, z);
mesh.Vertices.Add(x, 0, z);
mesh.Vertices.Add(x, y, z);
mesh.Vertices.Add(0, y, z);
mesh.Faces.AddFace(3, 2, 1, 0);
mesh.Faces.AddFace(4, 5, 6, 7);
mesh.Faces.AddFace(0, 1, 5, 4);
mesh.Faces.AddFace(1, 2, 6, 5);
mesh.Faces.AddFace(2, 3, 7, 6);
mesh.Faces.AddFace(3, 0, 4, 7);
mesh.Normals.ComputeNormals();
mesh.Compact();
if (mesh.IsValid)
return mesh;
return null;
}
static int OnReturnBoolGeneralCallback(int serial_number, int iVirtualFunction, IntPtr pObj, IntPtr pMat, IntPtr pMesh)
{
try
{
RenderPipeline pipe = RenderPipeline.FromSerialNumber(serial_number);
if (pipe != null)
{
switch ((VirtualFunctions)iVirtualFunction)
{
case VirtualFunctions.StartRendering:
return pipe.StartRendering() ? 1 : 0;
case VirtualFunctions.StopRendering:
pipe.StopRendering();
return 1;
case VirtualFunctions.NeedToProcessGeometryTable:
return pipe.NeedToProcessGeometryTable() ? 1 : 0;
case VirtualFunctions.NeedToProcessLightTable:
return pipe.NeedToProcessLightTable() ? 1 : 0;
case VirtualFunctions.RenderSceneWithNoMeshes:
return pipe.RenderSceneWithNoMeshes() ? 1 : 0;
case VirtualFunctions.RenderPreCreateWindow:
return pipe.RenderPreCreateWindow() ? 1:0;
case VirtualFunctions.RenderEnterModalLoop:
return pipe.RenderEnterModalLoop() ? 1 : 0;
case VirtualFunctions.RenderExitModalLoop:
return pipe.RenderExitModalLoop() ? 1 : 0;
case VirtualFunctions.RenderContinueModal:
return pipe.RenderContinueModal() ? 1 : 0;
case VirtualFunctions.IgnoreRhinoObject:
{
if (pObj != IntPtr.Zero)
{
Rhino.DocObjects.RhinoObject obj = Rhino.DocObjects.RhinoObject.CreateRhinoObjectHelper(pObj);
if (obj != null)
return pipe.IgnoreRhinoObject(obj) ? 1 : 0;
}
}
return 0;
case VirtualFunctions.AddLightToScene:
{
if (pObj != IntPtr.Zero)
{
Rhino.DocObjects.LightObject obj = Rhino.DocObjects.RhinoObject.CreateRhinoObjectHelper(pObj) as Rhino.DocObjects.LightObject;
if (obj != null)
return pipe.AddLightToScene(obj) ? 1 : 0;
}
}
return 0;
case VirtualFunctions.AddRenderMeshToScene:
{
if (pObj != IntPtr.Zero && pMat != IntPtr.Zero && pMesh != IntPtr.Zero)
{
Rhino.DocObjects.RhinoObject obj = Rhino.DocObjects.RhinoObject.CreateRhinoObjectHelper(pObj);
Rhino.DocObjects.Material mat = Rhino.DocObjects.Material.NewTemporaryMaterial(pMat);
//Steve....you need to look at this
Rhino.Geometry.Mesh mesh = new Rhino.Geometry.Mesh(pMesh, obj);
return pipe.AddRenderMeshToScene(obj, mat, mesh) ? 1:0;
}
}
return 0;
}
}
}
catch (Exception ex)
{
Rhino.Runtime.HostUtils.ExceptionReport(ex);
}
Debug.Assert(false);
return 0;
}
void Initialize()
{
IntPtr pSceneServer = m_pSceneServer;
if (pSceneServer != IntPtr.Zero)
{
//Pull in the list of objects
m_scene_objects = new List<SceneObject>();
UnsafeNativeMethods.Rdk_SceneServer_ResetObjectEnum(pSceneServer);
IntPtr pObject = UnsafeNativeMethods.Rdk_SceneServer_NextObject(pSceneServer);
while (pObject != IntPtr.Zero)
{
Rhino.Geometry.Mesh mesh = new Rhino.Geometry.Mesh();
IntPtr pMaterial = UnsafeNativeMethods.Rdk_SceneServer_ObjectDetails(pObject, mesh.NonConstPointer());
if (pMaterial != IntPtr.Zero)
{
SceneObject o = new SceneObject(mesh, RenderContent.FromPointer(pMaterial) as RenderMaterial);
m_scene_objects.Add(o);
}
pObject = UnsafeNativeMethods.Rdk_SceneServer_NextObject(pSceneServer);
}
//Now get the lights
m_scene_lights = new List<Rhino.Geometry.Light>();
UnsafeNativeMethods.Rdk_SceneServer_ResetLightEnum(pSceneServer);
IntPtr pLight = UnsafeNativeMethods.Rdk_SceneServer_NextLight(pSceneServer);
while (pLight != IntPtr.Zero)
{
Rhino.Geometry.Light light = new Rhino.Geometry.Light();
UnsafeNativeMethods.Rdk_SceneServer_LightDetails(pLight, light.NonConstPointer());
m_scene_lights.Add(light);
pLight = UnsafeNativeMethods.Rdk_SceneServer_NextLight(pSceneServer);
}
//And then fill in the blanks
IntPtr pEnvironment = UnsafeNativeMethods.Rdk_SceneServer_Environment(pSceneServer);
if (pEnvironment != IntPtr.Zero)
{
m_environment = RenderContent.FromPointer(pEnvironment) as RenderEnvironment;
}
else
{
m_environment = null;
}
m_content_instance_id = UnsafeNativeMethods.Rdk_SceneServer_InstanceId(pSceneServer);
m_sig = UnsafeNativeMethods.Rdk_SceneServer_Signature(pSceneServer);
//Just the view left...
m_viewport = new Rhino.DocObjects.ViewportInfo();
UnsafeNativeMethods.Rdk_SceneServer_View(pSceneServer, m_viewport.NonConstPointer());
}
m_pSceneServer = IntPtr.Zero;
}
public static void OptToRhino(OptFile opt, string rhinoPath, bool scale)
{
if (opt == null)
{
throw new ArgumentNullException("opt");
}
string rhinoDirectory = Path.GetDirectoryName(rhinoPath);
string rhinoName = Path.GetFileNameWithoutExtension(rhinoPath);
var distances = opt.Meshes
.SelectMany(t => t.Lods)
.Select(t => t.Distance)
.Distinct()
.OrderByDescending(t => t)
.ToArray();
for (int distance = 0; distance < distances.Length; distance++)
{
using (var file = new Rhino.FileIO.File3dm())
{
file.Settings.ModelUnitSystem = Rhino.UnitSystem.Meters;
int objectsIndex = 0;
List<string> textureNames = new List<string>();
foreach (var mesh in opt.Meshes)
{
var lod = mesh.Lods.FirstOrDefault(t => t.Distance <= distances[distance]);
if (lod == null)
{
continue;
}
foreach (var textureName in lod.FaceGroups
.Where(t => t.Textures.Count > 0)
.Select(t => t.Textures[0]))
{
if (!textureNames.Contains(textureName))
{
textureNames.Add(textureName);
}
}
string meshName = string.Format(CultureInfo.InvariantCulture, "{0}.{1:D3}", mesh.Descriptor.MeshType, objectsIndex);
using (var layer = new Rhino.DocObjects.Layer())
{
layer.Name = meshName;
file.Layers.Add(layer);
}
foreach (var faceGroup in lod.FaceGroups)
{
using (var rhinoMesh = new Rhino.Geometry.Mesh())
using (var rhinoAttributes = new Rhino.DocObjects.ObjectAttributes())
{
rhinoAttributes.Name = meshName;
rhinoAttributes.LayerIndex = objectsIndex;
if (faceGroup.Textures.Count > 0)
{
rhinoAttributes.MaterialIndex = textureNames.IndexOf(faceGroup.Textures[0]);
}
Action<Vector> addVertex;
if (scale)
{
addVertex = vertex => rhinoMesh.Vertices.Add(vertex.X * OptFile.ScaleFactor, vertex.Y * OptFile.ScaleFactor, vertex.Z * OptFile.ScaleFactor);
}
else
{
addVertex = vertex => rhinoMesh.Vertices.Add(vertex.X, vertex.Y, vertex.Z);
}
Action<TextureCoordinates> addTexCoords = texCoords => rhinoMesh.TextureCoordinates.Add(texCoords.U, -texCoords.V);
Action<Vector> addNormal = normal => rhinoMesh.Normals.Add(normal.X, normal.Y, normal.Z);
int facesIndex = 0;
foreach (var face in faceGroup.Faces)
{
var verticesIndex = face.VerticesIndex;
var texCoordsIndex = face.TextureCoordinatesIndex;
var normalsIndex = face.VertexNormalsIndex;
addVertex(mesh.Vertices[verticesIndex.A]);
addTexCoords(mesh.TextureCoordinates[texCoordsIndex.A]);
addNormal(mesh.VertexNormals[normalsIndex.A]);
facesIndex++;
addVertex(mesh.Vertices[verticesIndex.B]);
addTexCoords(mesh.TextureCoordinates[texCoordsIndex.B]);
addNormal(mesh.VertexNormals[normalsIndex.B]);
facesIndex++;
addVertex(mesh.Vertices[verticesIndex.C]);
addTexCoords(mesh.TextureCoordinates[texCoordsIndex.C]);
addNormal(mesh.VertexNormals[normalsIndex.C]);
facesIndex++;
if (verticesIndex.D >= 0)
{
addVertex(mesh.Vertices[verticesIndex.D]);
addTexCoords(mesh.TextureCoordinates[texCoordsIndex.D]);
addNormal(mesh.VertexNormals[normalsIndex.D]);
facesIndex++;
}
if (verticesIndex.D < 0)
{
rhinoMesh.Faces.AddFace(facesIndex - 1, facesIndex - 2, facesIndex - 3);
}
else
{
rhinoMesh.Faces.AddFace(facesIndex - 1, facesIndex - 2, facesIndex - 3, facesIndex - 4);
}
}
rhinoMesh.Compact();
file.Objects.AddMesh(rhinoMesh, rhinoAttributes);
}
}
objectsIndex++;
}
foreach (var textureName in textureNames)
{
Texture texture;
opt.Textures.TryGetValue(textureName, out texture);
using (var material = new Rhino.DocObjects.Material())
{
material.Name = textureName;
if (texture == null)
{
material.DiffuseColor = System.Drawing.Color.White;
}
else
{
texture.Save(Path.Combine(rhinoDirectory, textureName + ".png"));
material.SetBitmapTexture(textureName + ".png");
if (texture.HasAlpha)
{
texture.SaveAlphaMap(Path.Combine(rhinoDirectory, textureName + "_alpha.png"));
material.SetTransparencyTexture(textureName + "_alpha.png");
}
}
file.Materials.Add(material);
}
}
file.Write(Path.Combine(rhinoDirectory, string.Format(CultureInfo.InvariantCulture, "{0}_{1}.3dm", rhinoName, distance)), 4);
}
}
}
private void Build_Mesh_Sections()
{
int ct = -1;
m_templateX = new Rhino.Geometry.Mesh[2];
m_templateX[0] = new Rhino.Geometry.Mesh();
m_templateX[1] = new Rhino.Geometry.Mesh();
m_templateY = new Rhino.Geometry.Mesh[2];
m_templateY[0] = new Rhino.Geometry.Mesh();
m_templateY[1] = new Rhino.Geometry.Mesh();
m_templateZ = new Rhino.Geometry.Mesh[2];
m_templateZ[0] = new Rhino.Geometry.Mesh();
m_templateZ[1] = new Rhino.Geometry.Mesh();
double rt2 = Math.Sqrt(2);
for (int i = 0; i < 2; i++)
{
ct = -1;
for (int y = 0; y < PFrame[i].Length; y++)
{
for (int z = 0; z < PFrame[i][y].Length; z++)
{
ct++;
Rhino.Geometry.Point3d pt = new Rhino.Geometry.Point3d(PFrame[0][0][0].Pt.x, PFrame[i][y][z].Pt.y, PFrame[i][y][z].Pt.z);
m_templateX[i].Vertices.Add((Rhino.Geometry.Point3d)(pt + new Rhino.Geometry.Point3d(0, dy, dz)));
m_templateX[i].Vertices.Add((Rhino.Geometry.Point3d)(pt + new Rhino.Geometry.Point3d(0, dy, -dz)));
m_templateX[i].Vertices.Add((Rhino.Geometry.Point3d)(pt + new Rhino.Geometry.Point3d(0, -dy, -dz)));
m_templateX[i].Vertices.Add((Rhino.Geometry.Point3d)(pt + new Rhino.Geometry.Point3d(0, -dy, dz)));
int ct4 = ct * 4;
m_templateX[i].Faces.AddFace(ct4, ct4 + 1, ct4 + 2, ct4 + 3);
}
}
ct = -1;
for (int x = 0; x < PFrame.Length; x++)
{
for (int z = 0; z < PFrame[x][i].Length; z++)
{
ct++;
Rhino.Geometry.Point3d pt = new Rhino.Geometry.Point3d(PFrame[x][i][z].Pt.x, PFrame[0][0][0].Pt.y, PFrame[x][i][z].Pt.z);
m_templateY[i].Vertices.Add((Rhino.Geometry.Point3d)(pt + new Rhino.Geometry.Point3d(2 * dx / rt2, 0, 0)));
m_templateY[i].Vertices.Add((Rhino.Geometry.Point3d)(pt + new Rhino.Geometry.Point3d(0, 0, -dz)));
m_templateY[i].Vertices.Add((Rhino.Geometry.Point3d)(pt + new Rhino.Geometry.Point3d(2 * -dx / rt2, 0, 0)));
m_templateY[i].Vertices.Add((Rhino.Geometry.Point3d)(pt + new Rhino.Geometry.Point3d(0, 0, dz)));
int ct4 = ct * 4;
m_templateY[i].Faces.AddFace(ct4, ct4 + 1, ct4 + 2, ct4 + 3);
}
}
ct = -1;
for (int x = 0; x < PFrame.Length; x++)
{
for (int y = 0; y < PFrame[x].Length; y++)
{
ct++;
Rhino.Geometry.Point3d pt = new Rhino.Geometry.Point3d(PFrame[x][y][i].Pt.x, PFrame[x][y][i].Pt.y, PFrame[0][0][0].Pt.z);
m_templateZ[i].Vertices.Add((Rhino.Geometry.Point3d)(pt - new Rhino.Geometry.Point3d(2 * dx / rt2, 0, 0)));
m_templateZ[i].Vertices.Add((Rhino.Geometry.Point3d)(pt - new Rhino.Geometry.Point3d(0, -dy, 0)));
m_templateZ[i].Vertices.Add((Rhino.Geometry.Point3d)(pt - new Rhino.Geometry.Point3d(-2 * dx / rt2, 0, 0)));
m_templateZ[i].Vertices.Add((Rhino.Geometry.Point3d)(pt - new Rhino.Geometry.Point3d(0, dy, 0)));
int ct4 = ct * 4;
m_templateZ[i].Faces.AddFace(ct4, ct4 + 1, ct4 + 2, ct4 + 3);
}
}
m_templateX[i].Normals.ComputeNormals();
m_templateX[i].FaceNormals.ComputeFaceNormals();
m_templateY[i].Normals.ComputeNormals();
m_templateY[i].FaceNormals.ComputeFaceNormals();
m_templateZ[i].Normals.ComputeNormals();
m_templateZ[i].FaceNormals.ComputeFaceNormals();
}
}
public Rhino.Geometry.Mesh Mesh(int index)
{
IntPtr pMesh = UnsafeNativeMethods.Rdk_CustomMeshes_Mesh(ConstPointer(), index);
if (pMesh != IntPtr.Zero)
{
Rhino.Geometry.Mesh mesh = new Rhino.Geometry.Mesh(pMesh, null);
mesh.DoNotDestructOnDispose();
return mesh;
}
return null;
}
static int OnReturnBoolGeneralCallback(int serial_number, int iVirtualFunction, IntPtr pObj, IntPtr pMat, IntPtr pMesh, IntPtr pView, int rectLeft, int rectTop, int rectRight, int rectBottom)
{
try
{
RenderPipeline pipe = RenderPipeline.FromSerialNumber(serial_number);
if (pipe != null)
{
switch ((VirtualFunctions)iVirtualFunction)
{
case VirtualFunctions.StartRendering:
return pipe.OnRenderBegin() ? 1 : 0;
case VirtualFunctions.StartRenderingInWindow:
{
Rhino.Display.RhinoView view = Rhino.Display.RhinoView.FromIntPtr(pView);
System.Drawing.Rectangle rect = System.Drawing.Rectangle.FromLTRB(rectLeft, rectTop, rectRight, rectBottom);
return pipe.OnRenderWindowBegin(view, rect) ? 1 : 0;
}
case VirtualFunctions.StopRendering:
pipe.OnRenderEnd(new RenderEndEventArgs());
return 1;
case VirtualFunctions.NeedToProcessGeometryTable:
return pipe.NeedToProcessGeometryTable() ? 1 : 0;
case VirtualFunctions.NeedToProcessLightTable:
return pipe.NeedToProcessLightTable() ? 1 : 0;
case VirtualFunctions.RenderSceneWithNoMeshes:
return pipe.RenderSceneWithNoMeshes() ? 1 : 0;
case VirtualFunctions.RenderPreCreateWindow:
return pipe.RenderPreCreateWindow() ? 1:0;
case VirtualFunctions.RenderEnterModalLoop:
return pipe.RenderEnterModalLoop() ? 1 : 0;
case VirtualFunctions.RenderExitModalLoop:
return pipe.RenderExitModalLoop() ? 1 : 0;
case VirtualFunctions.RenderContinueModal:
return pipe.ContinueModal() ? 1 : 0;
case VirtualFunctions.IgnoreRhinoObject:
{
if (pObj != IntPtr.Zero)
{
Rhino.DocObjects.RhinoObject obj = Rhino.DocObjects.RhinoObject.CreateRhinoObjectHelper(pObj);
if (obj != null)
return pipe.IgnoreRhinoObject(obj) ? 1 : 0;
}
}
return 0;
case VirtualFunctions.AddLightToScene:
{
if (pObj != IntPtr.Zero)
{
Rhino.DocObjects.LightObject obj = Rhino.DocObjects.RhinoObject.CreateRhinoObjectHelper(pObj) as Rhino.DocObjects.LightObject;
if (obj != null)
return pipe.AddLightToScene(obj) ? 1 : 0;
}
}
return 0;
case VirtualFunctions.AddRenderMeshToScene:
{
if (pObj != IntPtr.Zero && pMat != IntPtr.Zero && pMesh != IntPtr.Zero)
{
Rhino.DocObjects.RhinoObject obj = Rhino.DocObjects.RhinoObject.CreateRhinoObjectHelper(pObj);
Rhino.DocObjects.Material mat = Rhino.DocObjects.Material.NewTemporaryMaterial(pMat);
//Steve....you need to look at this
Rhino.Geometry.Mesh mesh = new Rhino.Geometry.Mesh(pMesh, obj);
return pipe.AddRenderMeshToScene(obj, mat, mesh) ? 1:0;
}
}
return 0;
}
}
}
catch (Exception ex)
{
Rhino.Runtime.HostUtils.ExceptionReport(ex);
}
Debug.Assert(false);
return 0;
}
/// <summary>
/// reads a file and populates the map receiver instance.
/// </summary>
/// <returns></returns>
public static bool Read_pachm(out Mapping.PachMapReceiver[] Map)
{
System.Windows.Forms.OpenFileDialog of = new System.Windows.Forms.OpenFileDialog();
of.DefaultExt = ".pachm";
of.AddExtension = true;
of.Filter = "Pachyderm Mapping Data File (*.pachm)|*.pachm|" + "All Files|";
if (of.ShowDialog() != System.Windows.Forms.DialogResult.OK)
{
Map = null;
return false;
}
System.IO.BinaryReader sr = new System.IO.BinaryReader(System.IO.File.Open(of.FileName, System.IO.FileMode.Open));
//1. Write calculation type. (string)
string CalcType = sr.ReadString();
if (CalcType != "Type;Map_Data" && CalcType != "Type;Map_Data_NoDir") throw new Exception("Map Data File Expected");
bool Directional = (CalcType == "Type;Map_Data");
//2. Write the number of samples in each histogram. (int)
int SampleCT = (int)sr.ReadUInt32();
//3. Write the sample rate. (int)
int SampleRate = (int)sr.ReadUInt32();
//4. Write the number of Receivers (int)
int Rec_CT = (int)sr.ReadUInt32();
//4.5 Write the version number
double version = 1.1;
double rev = 0;
//5. Announce that the following data pertains to the form of the analysis mesh. (string)
int s_ct=1;
Rhino.Geometry.Mesh Map_Mesh = new Rhino.Geometry.Mesh();
Map = new Mapping.PachMapReceiver[1];
//Map[0] = new Pach_Map_Receiver();
//double[] Rho_C = null;
double[] delay;
do
{
switch (sr.ReadString())
{
case "Version":
//Pach1.7 = Versioning functionality added.
string v = sr.ReadString();
version = double.Parse(v.Substring(0, 3));
rev = int.Parse(v.Split(new char[1] { '.' })[3]);
break;
case "Mesh Information":
//6. Announce Mesh Vertices (string)
//Write the number of vertices & faces (int) (int)
if (sr.ReadString() != "Mesh Vertices") throw new Exception("Mesh Vertices Expected");
int VC = (int)sr.ReadUInt32();
int FC = (int)sr.ReadUInt32();
for (int i = 0; i < VC; i++)
{
//Write Vertex: (double) (double) (double)
Map_Mesh.Vertices.Add(new Rhino.Geometry.Point3d(sr.ReadSingle(), sr.ReadSingle(), sr.ReadSingle()));
}
//7. Announce Mesh Faces (string)
if (sr.ReadString() != "Mesh Faces") throw new Exception("Mesh Faces Expected");
for (int i = 0; i < FC; i++)
{
// Write mesh vertex indices: (int) (int) (int) (int)
Map_Mesh.Faces.AddFace((int)sr.ReadUInt32(), (int)sr.ReadUInt32(), (int)sr.ReadUInt32(), (int)sr.ReadUInt32());
}
break;
case "Sources":
//7.5: Announce the number of sources.
s_ct = sr.ReadInt32();
delay = new double[s_ct];
Map = new Mapping.PachMapReceiver[s_ct];
//7.5a Announce the type of source.
for (int s = 0; s < s_ct; s++)
{
Map[s] = new Mapping.PachMapReceiver();
Map[s].CutOffTime = (double)SampleCT / (double)SampleRate;
Map[s].SampleCT = SampleCT;
Map[s].SampleRate = SampleRate;
Map[s].Map_Mesh = Map_Mesh;
Map[s].Rec_List = new Mapping.PachMapReceiver.Map_Receiver[Rec_CT];
Map[s].SrcType = sr.ReadString();
//4.4 Source delay (ms)
if (version > 2.0 || (version == 2.0 && rev >= 1))
{
delay[s] = sr.ReadDouble();
}
}
break;
case "SourceswLoc":
//7.5: Announce the number of sources.
s_ct = sr.ReadInt32();
delay = new double[s_ct];
Map = new Mapping.PachMapReceiver[s_ct];
//7.5a Announce the type of source.
for (int s = 0; s < s_ct; s++)
{
Map[s] = new Mapping.PachMapReceiver();
Map[s].CutOffTime = (double)SampleCT / (double)SampleRate * 1000;
Map[s].SampleCT = SampleCT;
Map[s].SampleRate = SampleRate;
Map[s].Map_Mesh = Map_Mesh;
Map[s].Rec_List = new Mapping.PachMapReceiver.Map_Receiver[Rec_CT];
Map[s].Src = new Rhino.Geometry.Point3d(sr.ReadDouble(), sr.ReadDouble(), sr.ReadDouble());
Map[s].SrcType = sr.ReadString();
//4.4 Source delay (ms)
if (version > 2.0 || (version == 2.0 && rev >= 1))
{
delay[s] = sr.ReadDouble();
}
}
break;
case "Receiver Hit Data":
if (Map[0] == null)
{
Map = new Mapping.PachMapReceiver[1];
Map[0] = new Mapping.PachMapReceiver();
Map[0].CutOffTime = (double)SampleCT / (double)SampleRate;
Map[0].SampleRate = SampleRate;
Map[0].SampleCT = SampleCT;
Map[0].Map_Mesh = Map_Mesh;
Map[0].Rec_List = new Mapping.PachMapReceiver.Map_Receiver[Rec_CT];
Map[0].SrcType = "Geodesic";
}
//8. Announce that the following data pertains to the receiver histograms (string)
//8a. Announce whether or not data is linked to vertices rather than faces (bool)
bool vert_Receiver = sr.ReadBoolean();
for (int s = 0; s < s_ct; s++)
{
Map[s].Rec_Vertex = vert_Receiver;
for (int i = 0; i < Map[s].Rec_List.Length; i++)
{
//for version 1.7 and up, write direct sound arrival time.
//Write Receiver Index (int)
int j = (int)sr.ReadUInt32();
//Write Direct Sound Arrival Time.
double Direct_Time;
if (version >= 1.7) Direct_Time = sr.ReadDouble(); else Direct_Time = (Utilities.PachTools.RPttoHPt(Map[s].Src) - Map[s].Rec_List[i].H_Origin).Length() / 343f;
//Write Impedance of Air
double Rho_C = version >= 2.0 ? sr.ReadDouble() : 400;
if (vert_Receiver)
{
Map[s].Rec_List[i] = new Mapping.PachMapReceiver.Map_Receiver(Map_Mesh.Vertices[i], new Rhino.Geometry.Point3f((float)Map[s].Src.X, (float)Map[s].Src.Y, (float)Map[s].Src.Z), Direct_Time, Rho_C, i, SampleRate, SampleCT, Directional);
}
else
{
Rhino.Geometry.Point3d RecLoc = Map_Mesh.Faces.GetFaceCenter(i);
Map[s].Rec_List[i] = new Mapping.PachMapReceiver.Map_Receiver(new Rhino.Geometry.Point3f((float)RecLoc.X, (float)RecLoc.Y, (float)RecLoc.Z), new Rhino.Geometry.Point3f((float)Map[s].Src.X, (float)Map[s].Src.Y, (float)Map[s].Src.Z), Direct_Time, Rho_C, i, SampleRate, SampleCT, Directional);
}
for (int Octave = 0; Octave < 8; Octave++)
{
//Write Octave (int)
int Oct_out = (int)sr.ReadUInt32();
if (Oct_out != Octave) throw new Exception(string.Format("Octave {0} Expected", Octave));
double[] Hist = Map[s].Rec_List[i].GetEnergyHistogram(Octave);
if (Directional)
{
if (version < 1.7)
{
for (int e = 0; e < SampleCT; e++)
Map[s].Rec_List[i].Combine_Sample(e, sr.ReadDouble(), new Hare.Geometry.Vector(sr.ReadSingle(), sr.ReadSingle(), sr.ReadSingle()), new Hare.Geometry.Vector(sr.ReadSingle(), sr.ReadSingle(), sr.ReadSingle()), Octave);
}
else
{
for (int e = 0; e < SampleCT; e++)
Map[s].Rec_List[i].Combine_Sample(e, sr.ReadDouble(), new Hare.Geometry.Vector(sr.ReadSingle(), sr.ReadSingle(), sr.ReadSingle()), new Hare.Geometry.Vector(sr.ReadSingle(), sr.ReadSingle(), sr.ReadSingle()), Octave);
}
}
else
{
if (version < 1.7)
{
for (int e = 0; e < SampleCT; e++)
Map[s].Rec_List[i].Combine_Sample(e, sr.ReadDouble(), new Hare.Geometry.Vector(0, 0, 0), new Hare.Geometry.Vector(0, 0, 0), Octave);
}
else
{
for (int e = 0; e < SampleCT; e++)
Map[s].Rec_List[i].Combine_Sample(e, sr.ReadDouble(), new Hare.Geometry.Vector(0, 0, 0), new Hare.Geometry.Vector(0,0,0), Octave);
}
}
}
if (sr.ReadString() != "End_Receiver_Hits") throw new Exception("End of Receiver Hits Expected");
}
}
break;
case "End_of_File":
sr.Close();
return true;
}
} while (true);
throw new Exception("Unsuccessful Read");
}
