| public ToMesh ( bool freeze = false ) : System.Windows.Media.Media3D.MeshGeometry3D | ||
| freeze | bool |
/// freeze the mesh if set to |
| return | System.Windows.Media.Media3D.MeshGeometry3D | |
public MainViewModel()
{
var gm = new MeshBuilder();
gm.AddBox(new Point3D(0, 0, 0.5), 1, 1, 1);
gm.AddCylinder(new Point3D(5, 0, 0), new Point3D(5, 0, 5), 1, 36);
this.Model = new GeometryModel3D(gm.ToMesh(true), Materials.Blue);
this.Model.Freeze();
}
private static object buildTri()
{
var mb = new MeshBuilder(true, false);
var p0 = new Point3D(0, 0, 0);
var p1 = new Point3D(1, 0, 0);
var p2 = new Point3D(1, 1, 0);
mb.AddTriangle(p0, p1, p2);
mb.Normals.ToList().ForEach(x => System.Diagnostics.Trace.WriteLine(x.ToString()));
return mb.ToMesh();
}
//private ht.TranslateManipulator translateModificator;
/// <summary>
/// The tessellate.
/// </summary>
/// <returns>The mesh.</returns>
protected override MeshGeometry3D Tessellate()
{
var builder = new ht.MeshBuilder(true, true);
// Position and Rotation must not be concidered because they are handled by the visual 3d
if (this.Sensor == null)
{
builder.AddPyramid(new Point3D(), 1, 1);
return(builder.ToMesh());
}
var _zeroPosition = new Point3D();// this.Transform.Value.GetTranslation() - this.Position;
var _length = new Spherical3D(this.Sensor.MaxRange, 0, 0);
var _dirSp = this.Orientation.Axis.ToSpherical();
_dirSp.Radius = 0;
var _p0AzOffset = new Spherical3D(0, 0, this.Sensor.AzimuthRange / 2.0);
var _p0ElOffset = new Spherical3D(0, this.Sensor.ElevationRange / 2.0, 0);
var _pts = new List <Point3D>();
_pts.Add(_zeroPosition + this.Orientation.Axis + (_length + _p0ElOffset - _p0AzOffset + _dirSp).ToDirection());
_pts.Add(_zeroPosition + this.Orientation.Axis + (_length + _p0ElOffset + _p0AzOffset + _dirSp).ToDirection());
_pts.Add(_zeroPosition + this.Orientation.Axis + (_length - _p0ElOffset + _p0AzOffset + _dirSp).ToDirection());
_pts.Add(_zeroPosition + this.Orientation.Axis + (_length - _p0ElOffset - _p0AzOffset + _dirSp).ToDirection());
_pts.Sort((Point3D a, Point3D b) =>
{
if (Math.Abs(a.X - b.X) < DBL_EqualOffset)
{
if (Math.Abs(a.Y - b.Y) < DBL_EqualOffset)
{
return(a.Z.CompareTo(b.Z));
}
return(a.Y.CompareTo(b.Y));
}
return(a.X.CompareTo(b.X));
});
// outside
builder.AddTriangle(_pts[0], _zeroPosition, _pts[1]);
builder.AddTriangle(_pts[3], _zeroPosition, _pts[2]);
builder.AddTriangle(_pts[2], _zeroPosition, _pts[0]);
builder.AddTriangle(_pts[1], _zeroPosition, _pts[3]);
this.Material = this.outsideMat;
this.BackMaterial = this.insideMat;
return(builder.ToMesh());
}
private static ModelVisual3D Planar(IFeature basePath)
{
TongJi.Geometry.Polyline curve = new TongJi.Geometry.Polyline(basePath.GeoData);
if (curve.AlgebraicArea < 0)
{
curve = curve.ReversePoints();
}
var points = curve.Points.ToList();
if (points.Last() == points.First())
{
points.RemoveAt(points.Count - 1);
}
var triangles = DelaunayOfPolygon(points);
MeshBuilder mb = new MeshBuilder();
foreach (var tri in triangles)
{
var a = new Point3D(tri.A.x, tri.A.y, 0);
var b = new Point3D(tri.B.x, tri.B.y, 0);
var c = new Point3D(tri.C.x, tri.C.y, 0);
mb.AddTriangle(a, b, c);
}
ModelVisual3D visual = new ModelVisual3D();
visual.Content = new GeometryModel3D(mb.ToMesh(), MaterialHelper.CreateMaterial(Colors.Blue));
return(visual);
}
// Add all cubes to a ModelVisual3D, reuse geometry but create new visual for each cube - this is slow
/* GeometryModel3D AddGeometrySeparate(IEnumerable<Point3D> centers, double L)
{
var mv = new ModelVisual3D();
var cubit = new CubeVisual3D { SideLength = L * 0.95, Fill = Brushes.Gold };
var cuboidGeometry = cubit.Model.Geometry as MeshGeometry3D;
var r = new Random();
foreach (var center in centers)
{
var tg = new Transform3DGroup();
tg.Children.Add(new RotateTransform3D(new AxisAngleRotation3D(new Vector3D(1, 0, 0), (r.NextDouble() - 0.5) * 10)));
tg.Children.Add(new RotateTransform3D(new AxisAngleRotation3D(new Vector3D(0, 1, 0), (r.NextDouble() - 0.5) * 10)));
tg.Children.Add(new TranslateTransform3D(center.ToVector3D()));
var c = new ModelVisual3D
{
Content =
new GeometryModel3D
{
Geometry = cuboidGeometry,
Material = cubit.Material,
Transform = tg
}
};
mv.Children.Add(c);
}
return mv;
}*/
// All cubes in one GeometryModel - much faster
GeometryModel3D AddGeometry(IEnumerable<Point3D> centers, double L)
{
var w = new Stopwatch();
w.Start();
/* var geometry = new MeshGeometry3D();
foreach (var center in centers)
{
MeshGeometryHelper.AddBox(geometry,center, L, L, L);
}
*/
var builder = new MeshBuilder();
foreach (var center in centers)
{
builder.AddBox(center, L, L, L);
}
var geometry = builder.ToMesh();
geometry.Freeze();
Trace.WriteLine(Level + ": " + w.ElapsedMilliseconds + " ms");
var mv = new GeometryModel3D
{
Geometry = geometry,
Material = MaterialHelper.CreateMaterial(Brushes.Gold)
};
TriangleCount = geometry.TriangleIndices.Count / 3;
return mv;
}
private void Initializer(Point3D location)
{
var geometryModel = new GeometryModel3D();
var meshBuilder = new MeshBuilder();
meshBuilder.AddBox(new Point3D(location.X, location.Y, location.Z + 3.5), 1.5, 1.5, 0.25);
meshBuilder.AddBox(new Point3D(location.X, location.Y + 1, location.Z + 3.5), 0.25, 1.25, 0.25);
meshBuilder.AddBox(new Point3D(location.X, location.Y - 1, location.Z + 3.5), 0.25, 1.25, 0.25);
meshBuilder.AddBox(new Point3D(location.X + 1, location.Y , location.Z + 3.5), 1.25, 0.25, 0.25);
meshBuilder.AddBox(new Point3D(location.X - 1, location.Y, location.Z + 3.5), 1.25, 0.25, 0.25);
meshBuilder.AddBox(new Point3D(location.X, location.Y + 1.5, location.Z + 3), 0.25, 0.25, 0.75);
meshBuilder.AddBox(new Point3D(location.X, location.Y - 1.5, location.Z + 3), 0.25, 0.25, 0.75);
meshBuilder.AddBox(new Point3D(location.X + 1.5, location.Y, location.Z + 3), 0.25, 0.25, 0.75);
meshBuilder.AddBox(new Point3D(location.X - 1.5, location.Y, location.Z + 3), 0.25, 0.25, 0.75);
meshBuilder.AddBox(new Point3D(location.X, location.Y, location.Z + 4), 0.5, 0.5, 1);
geometryModel.Geometry = meshBuilder.ToMesh();
geometryModel.Material = Materials.Gold;
Visual3DModel = geometryModel;
}
/// <summary>
/// Initializes a new instance of the <see cref="MainViewModel"/> class.
/// </summary>
public MainViewModel()
{
// Create a model group
var modelGroup = new Model3DGroup();
// Create a mesh builder and add a box to it
var meshBuilder = new MeshBuilder(false, false);
meshBuilder.AddBox(new Point3D(0, 0, 1), 1, 2, 0.5);
meshBuilder.AddBox(new Rect3D(0, 0, 1.2, 0.5, 1, 0.4));
// Create a mesh from the builder (and freeze it)
var mesh = meshBuilder.ToMesh(true);
// Create some materials
var greenMaterial = MaterialHelper.CreateMaterial(Colors.Green);
var redMaterial = MaterialHelper.CreateMaterial(Colors.Red);
var blueMaterial = MaterialHelper.CreateMaterial(Colors.Blue);
var insideMaterial = MaterialHelper.CreateMaterial(Colors.Yellow);
// Add 3 models to the group (using the same mesh, that's why we had to freeze it)
modelGroup.Children.Add(new GeometryModel3D { Geometry = mesh, Material = greenMaterial, BackMaterial = insideMaterial });
modelGroup.Children.Add(new GeometryModel3D { Geometry = mesh, Transform = new TranslateTransform3D(-2, 0, 0), Material = redMaterial, BackMaterial = insideMaterial });
modelGroup.Children.Add(new GeometryModel3D { Geometry = mesh, Transform = new TranslateTransform3D(2, 0, 0), Material = blueMaterial, BackMaterial = insideMaterial });
//// Set the property, which will be bound to the Content property of the ModelVisual3D (see MainWindow.xaml)
//AxisAngleRotation3D rotateAxis = new AxisAngleRotation3D(new Vector3D(0, 1, 0), 180/*or 360*/);
//Rotation3DAnimation rotateAnimation = new Rotation3DAnimation(rotateAxis, TimeSpan.FromSeconds(2));
//var rotateTransform = new RotateTransform3D();
//rotateTransform.BeginAnimation(RotateTransform3D.RotationProperty, rotateAnimation);
//modelGroup.Transform = rotateTransform;
this.Model = modelGroup;
}
/// <summary>
/// Initializes a new instance of the <see cref="MainViewModel"/> class.
/// </summary>
public MainViewModel()
{
// Create a model group
var modelGroup = new Model3DGroup();
// Create a mesh builder and add a box to it
var meshBuilder = new MeshBuilder(false, false);
meshBuilder.AddBox(new Point3D(0, 0, 1), 1, 2, 0.5);
meshBuilder.AddBox(new Rect3D(0, 0, 1.2, 0.5, 1, 0.4));
// Create a mesh from the builder (and freeze it)
var mesh = meshBuilder.ToMesh(true);
// Create some materials
var greenMaterial = MaterialHelper.CreateMaterial(Colors.Green);
var redMaterial = MaterialHelper.CreateMaterial(Colors.Red);
var blueMaterial = MaterialHelper.CreateMaterial(Colors.Blue);
var insideMaterial = MaterialHelper.CreateMaterial(Colors.Yellow);
// Add 3 models to the group (using the same mesh, that's why we had to freeze it)
modelGroup.Children.Add(new GeometryModel3D { Geometry = mesh, Material = greenMaterial, BackMaterial = insideMaterial });
modelGroup.Children.Add(new GeometryModel3D { Geometry = mesh, Transform = new TranslateTransform3D(-2, 0, 0), Material = redMaterial, BackMaterial = insideMaterial });
modelGroup.Children.Add(new GeometryModel3D { Geometry = mesh, Transform = new TranslateTransform3D(2, 0, 0), Material = blueMaterial, BackMaterial = insideMaterial });
// Set the property, which will be bound to the Content property of the ModelVisual3D (see MainWindow.xaml)
this.Model = modelGroup;
}
private void CreateModel()
{
const double dt = 0.1;
const int nSteps = 100;
var mb = new MeshBuilder(true, true);
for (double y0 = -5; y0 <= 5; y0 += 0.25)
{
var p0 = new Point(-3, y0);
Point[] pts = Solve(Velocity, p0, dt, nSteps);
var vel = new double[pts.Length];
var diam = new double[pts.Length];
int i = 0;
var pts3d = new Point3D[pts.Length];
double vmax = 0;
foreach (Point pt in pts)
{
pts3d[i] = new Point3D(pt.X, pt.Y, 0);
double v = Velocity(pt.X, pt.Y).Length;
if (v > vmax) vmax = v;
vel[i++] = v;
}
for (int j = 0; j < vel.Length; j++)
vel[j] /= vmax;
for (int j = 0; j < vel.Length; j++)
diam[j] = 0.075;
mb.AddTube(pts3d, vel, diam, 12, false);
}
this.StreamLinesModel = new GeometryModel3D();
this.StreamLinesModel.Geometry = mb.ToMesh();
this.StreamLinesModel.Material = Materials.Hue;
this.StreamLinesModel.BackMaterial = Materials.Hue;
}
//// Using a DependencyProperty as the backing store for Direction. This enables animation, styling, binding, etc...
//public static readonly DependencyProperty DirectionProperty =
// DependencyProperty.Register("Direction", typeof(Vector3D), typeof(SensorVisual3D), new PropertyMetadata(new Vector3D(1, 0, 0), GeometryChanged));
//public string Name
//{
// get { return (string)GetValue(NameProperty); }
// set { SetValue(NameProperty, value); }
//}
//// Using a DependencyProperty as the backing store for Name. This enables animation, styling, binding, etc...
//public static readonly DependencyProperty NameProperty =
// DependencyProperty.Register("Name", typeof(Size3D), typeof(SensorVisual3D), new PropertyMetadata(new Size3D(), GeometryChanged));
//public Size3D Size
//{
// get { return (Size3D)GetValue(SizeProperty); }
// set { SetValue(SizeProperty, value); }
//}
//// Using a DependencyProperty as the backing store for Size. This enables animation, styling, binding, etc...
//public static readonly DependencyProperty SizeProperty =
// DependencyProperty.Register("Size", typeof(Size3D), typeof(SensorVisual3D), new PropertyMetadata(new Size3D(0, 0, 0), GeometryChanged));
/// <summary>
/// The tessellate.
/// </summary>
/// <returns>The mesh.</returns>
protected override MeshGeometry3D Tessellate()
{
var builder = new ht.MeshBuilder(true, true);
builder.AddArrow(this.Position, this.Position + this.Orientation.Axis, 1);
return(builder.ToMesh());
}
private Model3D CreateModel()
{
var plotModel = new Model3DGroup();
var mb = new MeshBuilder();
Point3D centre = new Point3D(1, 0.5, 0);
double radius = 0.4;
AddCircleInZCross(mb,centre, radius, 121);
var a = mb.ToMesh();
plotModel.Children.Add(new GeometryModel3D(mb.ToMesh(), MaterialHelper.CreateMaterial(TopBrush.Clone())));
return plotModel;
}
public static MeshGeometry3D GetSimpleMesh(Tool tool, Point3D position, Vector3D direction)
{
var t = tool as SimpleTool;
var builder = new HelixToolkit.Wpf.MeshBuilder();
var p = position + direction * t.Length;
builder.AddCylinder(position, p, t.Diameter / 2.0);
return(builder.ToMesh());
}
void AddTube(List<Point3D> path, Color color)
{
var mb = new MeshBuilder();
mb.AddTube(path, 0.1, 3, false);
var geom = new GeometryModel3D { Geometry = mb.ToMesh(true), Material = MaterialHelper.CreateMaterial(color) }; // create a model
var model = new ModelVisual3D();
model.Content = geom;
_Helix.Children.Add(model);
}
public DemoElement3D()
{
var gm = new GeometryModel3D();
var mb = new MeshBuilder();
mb.AddSphere(new Point3D(0, 0, 0), 2, 100, 50);
gm.Geometry = mb.ToMesh();
gm.Material = Materials.Blue;
Visual3DModel = gm;
}
public LineSegment(Point3D startPoint, Point3D endPoint)
{
StartPoint = startPoint;
EndPoint = endPoint;
var meshBuilder = new MeshBuilder(false, false);
meshBuilder.AddCylinder(startPoint, endPoint, 0.2, 10);
Model = meshBuilder.ToMesh();
}
public void AddGroup(List<int> selectedVertex)
{
MeshBuilder mesh = new MeshBuilder(false, false);
foreach (int index in selectedVertex)
mesh.AddSphere(this.Points[index], pointRaduis);
var mesh1 = mesh.ToMesh(true);
var redMaterial = MaterialHelper.CreateMaterial(Colors.Red);
var insideMaterial = MaterialHelper.CreateMaterial(Colors.Yellow);
// Add 3 models to the group (using the same mesh, that's why we had to freeze it)
mg.Children.Add(new GeometryModel3D { Geometry = mesh1, Material = redMaterial, BackMaterial = insideMaterial });
}
public static MeshGeometry3D GetPointedMesh(Tool tool, Point3D position, Vector3D direction)
{
var t = tool as PointedTool;
var builder = new HelixToolkit.Wpf.MeshBuilder();
var p1 = position + direction * t.StraightLength;
var p2 = position + direction * (t.StraightLength + t.ConeHeight);
builder.AddCylinder(position, p1, t.Diameter / 2.0);
builder.AddCone(p1, p2, t.Diameter / 2.0, false, 20);
return(builder.ToMesh());
}
public static MeshGeometry3D GetTwoSectioMesh(Tool tool, Point3D position, Vector3D direction)
{
var t = tool as TwoSectionTool;
var builder = new HelixToolkit.Wpf.MeshBuilder();
var p1 = position + direction * t.Length1;
var p2 = position + direction * (t.Length1 + t.Length2);
builder.AddCylinder(position, p1, t.Diameter1 / 2.0);
builder.AddCylinder(p1, p2, t.Diameter2 / 2.0);
return(builder.ToMesh());
}
public MainWindow()
{
InitializeComponent();
var material = MaterialHelper.CreateMaterial(Colors.Aqua);
var builder = new MeshBuilder();
builder.AddTriangle(new Point3D(0, 0, 0), new Point3D(0, 10, 100), new Point3D(100, 0, 0));
var mesh = builder.ToMesh();
var geo = new GeometryModel3D { Geometry = mesh, Material = material , Transform = null};
var model = new ModelVisual3D { Content = geo, Transform = null };
_visual.Children.Add(model);
}
//private ht.TranslateManipulator translateModificator;
/// <summary>
/// The tessellate.
/// </summary>
/// <returns>The mesh.</returns>
protected override MeshGeometry3D Tessellate()
{
var builder = new ht.MeshBuilder(true, true);
var _bo = (IpObject)this;
if (_bo != null)
{
builder.AddSphere(_bo.Position, _bo.Size.X);
}
this.Material = outsideMat;
this.BackMaterial = insideMat;
return(builder.ToMesh());
}
public Cube(Point3D center, double radius, Action action) {
Center = center;
Radius = radius;
Action = action;
Notified = false;
SolidColorBrush = new SolidColorBrush();
SolidColorBrush.Opacity = _Constants.BaseOpacity;
SolidColorBrush.Color = _Constants.DefaultCubeColour;
Material = new DiffuseMaterial(SolidColorBrush);
MeshBuilder meshBuilder = new MeshBuilder();
meshBuilder.AddBox(center, radius, radius, radius);
ModelVisual3D = Engine._3DUtil.WrapMeshAndMaterialIntoModelVisual3D(meshBuilder.ToMesh(), Material);
}
private ModelVisual3D CreateDice()
{
var diceMesh = new MeshBuilder();
diceMesh.AddBox(new Point3D(0, 0, 0), 1, 1, 1);
for (int i = 0; i < 2; i++)
for (int j = 0; j < 2; j++)
for (int k = 0; k < 2; k++)
{
var points = new List<Point3D>();
diceMesh.ChamferCorner(new Point3D(i - 0.5, j - 0.5, k - 0.5), 0.1, 1e-6, points);
//foreach (var p in points)
// b.ChamferCorner(p, 0.03);
}
return new ModelVisual3D { Content = new GeometryModel3D { Geometry = diceMesh.ToMesh(), Material = Materials.White } };
}
public static System.Windows.Media.Media3D.MeshGeometry3D get3DText(string text)
{
var builder = new HelixToolkit.Wpf.MeshBuilder(false, false);
//Debug.WriteLine("<<<get3DText:" + text + ">>>");
builder.ExtrudeText(
text,
"Arial",
FontStyles.Normal,
FontWeights.Bold,
29,
new Vector3D(-1, 0, 0), //text direction
new Point3D(0, 0, 0),
new Point3D(0, 0, 0.001));
return(builder.ToMesh(true));
}
public override GeometryModel3D Generate()
{
var mesh = new MeshBuilder();
AddBranch(mesh, new Point3D(0,0,0), UpVector, 0);
var mv = new GeometryModel3D
{
Geometry = mesh.ToMesh(),
Material = mat,
BackMaterial = mat
};
TriangleCount = mesh.TriangleIndices.Count / 3;
return mv;
}
public MainWindow()
{
InitializeComponent();
var container = new ContainerUIElement3D();
var element = new ModelUIElement3D();
var geometry = new GeometryModel3D();
var meshBuilder = new MeshBuilder();
meshBuilder.AddSphere(new Point3D(0, 0, 0), 2, 100, 50);
geometry.Geometry = meshBuilder.ToMesh();
geometry.Material = Materials.Green;
element.Model = geometry;
element.Transform = new TranslateTransform3D(5, 0, 0);
element.MouseDown += this.ContainerElementMouseDown;
container.Children.Add(element);
view1.Children.Add(container);
}
public static MeshGeometry3D GetCountersinkMesh(Tool tool, Point3D position, Vector3D direction)
{
const double hSvasatore = 10.0;
var t = tool as CountersinkTool;
var builder = new HelixToolkit.Wpf.MeshBuilder();
var p1 = position + direction * (t.Length1 - hSvasatore);
var p12 = position + direction * t.Length1;
var p2 = position + direction * (t.Length1 + t.Length2);
var p3 = position + direction * (t.Length1 + t.Length2 + t.Length3);
builder.AddCylinder(position, p1, t.Diameter1 / 2.0);
builder.AddCylinder(p1, p12, t.Diameter2 / 2.0);
builder.AddCone(p12, direction, t.Diameter2 / 2.0, t.Diameter1 / 2.0, t.Length2, false, false, 20);
builder.AddCylinder(p2, p3, t.Diameter1 / 2.0);
return(builder.ToMesh());
}
public MainWindow()
{
this.InitializeComponent();
var builder = new MeshBuilder(false, false);
builder.ExtrudeText(
"Helix Toolkit",
"Arial",
FontStyles.Normal,
FontWeights.Bold,
20,
new Vector3D(1, 0, 0),
new Point3D(0, 0, 0),
new Point3D(0, 0, 1));
this.textGeometry = builder.ToMesh(true);
this.DataContext = this;
}
GeometryModel3D AddGeometry(IEnumerable<Point3D> centers, double l)
{
var builder = new MeshBuilder();
foreach (var center in centers)
{
builder.AddPyramid(center, l, l, true);
}
var mv = new GeometryModel3D
{
Geometry = builder.ToMesh(true),
Material = MaterialHelper.CreateMaterial(Brushes.Gold)
};
TriangleCount = builder.TriangleIndices.Count / 3;
return mv;
}
public TubeSegment(Point3D startPoint, Point3D endPoint, double d1, double d2)
{
var meshBuilder = new MeshBuilder(false, false);
var h1 = 0.1*d1;
var h2 = 0.1*d2;
var deltaStart = GeometryHelper.GetDeltaPoint(startPoint, endPoint, h1);
var deltaEnd = GeometryHelper.GetDeltaPoint(endPoint, startPoint, h2);
var points = new List<Point3D>() { deltaStart, deltaEnd };
//var points = new List<Point3D>() { startPoint, endPoint };
var dd1 = d1*0.9;
var dd2 = d2*0.9;
var diameters = new[] { dd1, dd2 };
//var diameters = new[] { d1, d2 };
meshBuilder.AddTube(points, new double[] { 0, 0 }, diameters, 10, false);
Model = meshBuilder.ToMesh();
}
public Model3D ToModel3D()
{
var m = new Model3DGroup();
TriangleIndexToPanelIndex = new List<int>();
// Add the triangles
var tm = new MeshBuilder(false, false);
int panelIndex = 0;
foreach (var p in Panels)
{
p.TriangleIndex = tm.Positions.Count;
tm.AddTriangleFan(p.Points);
for (int i = 0; i < p.Points.Length - 2; i++) TriangleIndexToPanelIndex.Add(panelIndex);
panelIndex++;
}
var panelsGeometry = tm.ToMesh();
m.Children.Add(new GeometryModel3D(panelsGeometry, Materials.Red) { BackMaterial = Materials.Blue });
// Add the nodes
var gm = new MeshBuilder();
foreach (var p in panelsGeometry.Positions)
{
gm.AddSphere(p, 0.05);
}
m.Children.Add(new GeometryModel3D(gm.ToMesh(), Materials.Gold));
// Add the edges
var em = new MeshBuilder();
foreach (var p in Panels)
{
for (int i = 0; i < p.Points.Length; i += 1)
{
em.AddCylinder(p.Points[i], p.Points[(i + 1) % p.Points.Length], 0.05, 10);
}
}
m.Children.Add(new GeometryModel3D(em.ToMesh(), Materials.Gray));
return m;
}
public PartMesh(string filename)
{
var meshBuilder = new MeshBuilder(false, false);
var min = new Point3D(double.PositiveInfinity, double.PositiveInfinity, double.PositiveInfinity);
var max = new Point3D(double.NegativeInfinity, double.NegativeInfinity, double.NegativeInfinity);
using (var stream = modelAssembly.GetManifestResourceStream("Hexenstein.Models." + filename))
using (var reader = new BinaryReader(stream))
{
var header = reader.ReadBytes(80);
var num = reader.ReadUInt32();
for (int i = 0; i < num; i++)
{
var normal = ReadPoint(reader);
var v1 = ReadPoint(reader);
var v2 = ReadPoint(reader);
var v3 = ReadPoint(reader);
var extra = reader.ReadInt16();
meshBuilder.AddTriangle(v1, v2, v3);
min = new Point3D(
Math.Min(Math.Min(Math.Min(min.X, v1.X), v2.X), v3.X),
Math.Min(Math.Min(Math.Min(min.Y, v1.Y), v2.Y), v3.Y),
Math.Min(Math.Min(Math.Min(min.Z, v1.Z), v2.Z), v3.Z));
max = new Point3D(
Math.Max(Math.Max(Math.Max(max.X, v1.X), v2.X), v3.X),
Math.Max(Math.Max(Math.Max(max.Y, v1.Y), v2.Y), v3.Y),
Math.Max(Math.Max(Math.Max(max.Z, v1.Z), v2.Z), v3.Z));
}
}
Centre = ((max - min) / 2 + min);
Mesh = meshBuilder.ToMesh(true);
}
private Model3D CreateModel()
{
var plotModel = new Model3DGroup();
var axesMeshBuilder = new MeshBuilder();
_realRect3D = GetSampleImageBox();
axesMeshBuilder.AddBoundingBox(_realRect3D, 0.01);
plotModel.Children.Add(new GeometryModel3D(axesMeshBuilder.ToMesh(), Materials.Yellow));
switch (CurrentDirection)
{
case FrameDirection.Top:
CreateTopSelectionSlice(plotModel, SectionBrush);
CreateTopMaxSlice(plotModel);
CreateTopPartSlice(plotModel, SectionPosition);
break;
case FrameDirection.Front:
CreateFrontSelectionSlice(plotModel, SectionBrush);
CreateFrontMaxSlice(plotModel);
CreateFrontPartSlice(plotModel, SectionPosition);
break;
case FrameDirection.Left:
CreateLeftSelectionSlice(plotModel, SectionBrush);
CreateLeftMaxSlice(plotModel);
CreateLeftPartSlice(plotModel, SectionPosition);
break;
default:
throw new InvalidOperationException("Can not process the direction.");
}
return plotModel;
}
public static MeshGeometry3D GetDiskMesh(Tool tool, Point3D position, Vector3D direction)
{
var t = tool as DiskTool;
var builder = new HelixToolkit.Wpf.MeshBuilder();
var d = Math.Abs(t.BodyThickness - t.CuttingThickness) / 2.0;
var r1 = t.Diameter / 2.0 - t.CuttingRadialThickness;
var profile = new Point[]
{
new Point(t.BodyThickness, 10.0),
new Point(t.BodyThickness, r1),
new Point(t.BodyThickness + d, r1),
new Point(t.BodyThickness + d, t.Diameter / 2.0),
new Point(-d, t.Diameter / 2.0),
new Point(-d, r1),
new Point(0.0, r1),
new Point(0.0, 10.0)
};
builder.AddRevolvedGeometry(profile, null, position, direction, 100);
return(builder.ToMesh());
}
public Sphere(Point3D center, double radius, IEnumerable<CutingPlane> cutingPlanes)
{
Center = center;
Radius = radius;
CutingPlanes = new List<CutingPlane>();
if (cutingPlanes != null)
{
CutingPlanes.AddRange(cutingPlanes);
}
var meshBuilder = new MeshBuilder(false, false);
meshBuilder.AddSphere(center, radius, 25, 15);
var m = meshBuilder.ToMesh();
foreach (var plane3D in CutingPlanes)
{
Point3D p = plane3D.Point;
Vector3D n = -1*plane3D.Vector;
m = MeshGeometryHelper.Cut(m, p, n);
}
Model = m;
}
/// <summary>
/// Do the tesselation and return the <see cref="MeshGeometry3D"/> .
/// </summary>
/// <returns>
/// A triangular mesh geometry.
/// </returns>
protected override MeshGeometry3D Tessellate()
{
if (this.Path == null)
{
return null;
}
var builder = new MeshBuilder(false, this.TextureCoordinates != null);
builder.AddTube(
this.Path,
this.TextureCoordinates,
this.Diameters,
this.Section,
this.IsPathClosed,
this.IsSectionClosed);
return builder.ToMesh();
}
private void UpdateModel()
{
// http://en.wikipedia.org/wiki/Lorenz_attractor
Func<double[], double[]> lorenzAttractor = x =>
{
var dx = new double[3];
dx[0] = sigma * (x[1] - x[0]);
dx[1] = x[0] * (rho - x[2]) - x[1];
dx[2] = x[0] * x[1] - beta * x[2];
return dx;
};
// solve the ODE
var x0 = new[] { 0, 1, 1.05 };
IEnumerable<double[]> solution = EulerSolver(lorenzAttractor, x0, 25);
// todo: should have a better ODE solver (R-K(4,5)? http://www.mathworks.com/help/techdoc/ref/ode45.html)
List<Point3D> path = solution.Select(x => new Point3D(x[0], x[1], x[2])).ToList();
// create the WPF3D model
var m = new Model3DGroup();
var gm = new MeshBuilder();
gm.AddTube(path, 0.8, 10, false);
if (directionArrows)
{
// sphere at the initial point
gm.AddSphere(path[0], 1);
// arrow heads every 100 point
for (int i = 100; i + 1 < path.Count; i += 100)
{
gm.AddArrow(path[i], path[i + 1], 0.8);
}
// arrow head at the end
Point3D p0 = path[path.Count - 2];
Point3D p1 = path[path.Count - 1];
var d = new Vector3D(p1.X - p0.X, p1.Y - p0.Y, p1.Z - p0.Z);
d.Normalize();
Point3D p2 = p1 + d * 2;
gm.AddArrow(p1, p2, 0.8);
}
m.Children.Add(new GeometryModel3D(gm.ToMesh(), Materials.Gold));
Model = m;
}
/// <summary>
/// Do the tessellation and return the <see cref="MeshGeometry3D" />.
/// </summary>
/// <returns>
/// A triangular mesh geometry.
/// </returns>
protected override MeshGeometry3D Tessellate()
{
var builder = new MeshBuilder(false, true);
builder.AddEllipsoid(this.Center, this.RadiusX, this.RadiusY, this.RadiusZ, this.ThetaDiv, this.PhiDiv);
return builder.ToMesh();
}
/// <summary>
/// Do the tessellation and return the <see cref="MeshGeometry3D"/>.
/// </summary>
/// <returns>A triangular mesh geometry.</returns>
protected override MeshGeometry3D Tessellate()
{
var builder = new MeshBuilder(false, true);
builder.AddCone(
this.Origin,
this.Normal,
this.BaseRadius,
this.TopRadius,
this.Height,
this.BaseCap,
this.TopCap,
this.ThetaDiv);
return builder.ToMesh();
}
private static Geometry3D GetDefaultGeometry()
{
// The default geometry is a box
var mb = new MeshBuilder(false,false);
mb.AddBox(new Point3D(0, 0, 0.5), 0.8, 0.8, 1);
return mb.ToMesh();
}
/// <summary>
/// Create the text for the north arrow.
///
/// It is suggested to use an image instead
/// of text for performance purposes. I will
/// look into this later.
/// </summary>
/// <returns>3D Text.</returns>
private Model3D NorthArrow(int numBins)
{
Model3DGroup group = new Model3DGroup();
// Get the length of the cylinder, if it is 0, then display something.
double arrowLength = CylinderRadius * SCALE_ARROW;
if (arrowLength <= 0)
{
arrowLength = SCALE_ARROW;
}
#region Arrow
//Create the shape of the object
//This will be an arrow
//Length will be the scale value
//The position will be above the plot
double xAxisLoc = 0;
double yAxisLoc = 0;
double zAxisLoc = 0;
if (YAxis)
{
yAxisLoc = -numBins * TRANSLATION_SCALE;
}
else
{
xAxisLoc = numBins * TRANSLATION_SCALE;
}
var mb = new MeshBuilder(false, false);
if (YAxis)
{
mb.AddArrow(new Point3D(xAxisLoc, yAxisLoc, zAxisLoc), new Point3D(arrowLength, yAxisLoc, zAxisLoc), LABEL_ARROW_HEAD_SIZE, 3, 100);
}
else
{
mb.AddArrow(new Point3D(xAxisLoc, yAxisLoc, zAxisLoc), new Point3D(xAxisLoc, arrowLength, zAxisLoc), LABEL_ARROW_HEAD_SIZE, 3, 100);
}
Geometry3D geometry = mb.ToMesh();
//Set the color
Material material = MaterialHelper.CreateMaterial(SELECTED_BIN_COLOR);
material.Freeze();
var model = new GeometryModel3D(geometry, material);
model.BackMaterial = material;
#endregion
#region Text
double xAxisLocLabel = 0;
double yAxisLocLabel = 0;
double zAxisLocLabel = LABEL_ARROW_HEAD_SIZE; // Make the text just in front of the North arrow
if (YAxis)
{
xAxisLocLabel = arrowLength / 2; // Make the text in the middle of the North arrow
yAxisLocLabel = -numBins * TRANSLATION_SCALE; // Go to the bottom of the column
}
else
{
xAxisLocLabel = numBins * TRANSLATION_SCALE;
yAxisLocLabel = arrowLength / 2;
}
TextVisual3D txt = new TextVisual3D();
txt.Position = new Point3D(xAxisLocLabel, yAxisLocLabel, zAxisLocLabel);
txt.Height = 0.5;
txt.Text = string.Format("North {0}", (arrowLength / SCALE_ARROW).ToString("0.0")); // Need to get the arrowLenght back to m/s
txt.TextDirection = new Vector3D(1, 0, 0); // Set text to run in line with X axis
txt.UpDirection = new Vector3D(0, 1, 0); // Set text to Point Up on Y axis
txt.Foreground = new SolidColorBrush(Colors.Black);
txt.Background = new SolidColorBrush(Colors.WhiteSmoke);
txt.Padding = new Thickness(2);
#endregion
group.Children.Add(model);
group.Children.Add(txt.Content);
return group;
}
