public Point3D ToWorld(Point3D point)
{
var mat = Visual3DHelper.GetTransform(this);
var t = new MatrixTransform3D(mat);
return(t.Transform(point));
}
public Vector3D ToWorld(Vector3D vector)
{
var mat = Visual3DHelper.GetTransform(this);
var t = new MatrixTransform3D(mat);
return(t.Transform(vector));
}
private bool UpdateTransform()
{
bool result;
if (this.Viewport == null)
{
result = false;
}
else
{
Matrix3D?transform = Visual3DHelper.GetViewportTransform(this);
if (!transform.HasValue)
{
result = false;
}
else if (_visualToScreen == transform.Value)
{
result = false;
}
else
{
_visualToScreen = transform.Value;
result = true;
}
}
return(result);
}
/// <summary>
/// Invoked when an unhandled <see cref="E:System.Windows.Input.Mouse.MouseDown" /> attached event reaches an element in
/// its route that is derived from this class. Implement this method to add class handling for this event.
/// </summary>
/// <param name="e">
/// The <see cref="T:System.Windows.Input.MouseButtonEventArgs" /> that contains the event data. This event data reports
/// details about the mouse button that was pressed and the handled state.
/// </param>
protected override void OnMouseDown(MouseButtonEventArgs e)
{
base.OnMouseDown(e);
ParentViewport = Visual3DHelper.GetViewport3D(this);
Camera = ParentViewport.Camera as ProjectionCamera;
ProjectionCamera projectionCamera = Camera;
if (projectionCamera != null)
{
HitPlaneNormal = projectionCamera.LookDirection;
}
CaptureMouse();
Vector3D direction = ToWorld(Normal);
Vector3D up = Vector3D.CrossProduct(Camera.LookDirection, direction);
Point3D hitPlaneOrigin = ToWorld(Center);
HitPlaneNormal = Vector3D.CrossProduct(up, direction);
Point p = e.GetPosition(ParentViewport);
Point3D?np = GetHitPlanePoint(p, hitPlaneOrigin, Normal);
if (np == null)
{
return;
}
Point3D lp = ToLocal(np.Value);
_lastPoint = lp;
CaptureMouse();
}
private bool UpdateTransforms()
{
Matrix3D?transform = Visual3DHelper.GetViewportTransform(this);
bool result;
if (!transform.HasValue)
{
result = false;
}
else
{
Matrix3D newTransform = transform.Value;
if (double.IsNaN(newTransform.M11))
{
result = false;
}
else if (!newTransform.HasInverse)
{
result = false;
}
else if (newTransform == _visualToScreen)
{
result = false;
}
else
{
_visualToScreen = (_screenToVisual = newTransform);
_screenToVisual.Invert();
result = true;
}
}
return(result);
}
/// <summary>
/// Transforms from local to world coordinates.
/// </summary>
/// <param name="point">
/// The point (local coordinates).
/// </param>
/// <returns>
/// Transformed point (world coordinates).
/// </returns>
protected Point3D ToWorld(Point3D point)
{
Matrix3D mat = Visual3DHelper.GetTransform(this);
var t = new MatrixTransform3D(mat);
return(t.Transform(point));
}
private void view1_MouseDown(object sender, System.Windows.Input.MouseButtonEventArgs e)
{
var p = e.GetPosition(view1);
var v = Viewport3DHelper.FindNearestVisual(view1.Viewport, p);
// Left-clicking with control creates a bounding box around the object
if (v != null && Keyboard.IsKeyDown(Key.LeftCtrl))
{
var rect = Visual3DHelper.FindBounds(v, Transform3D.Identity);
view1.Children.Add(new BoundingBoxVisual3D()
{
BoundingBox = rect
});
return;
}
// Left-clicking adds a blue sphere at the nearest hit point
var pt = Viewport3DHelper.FindNearestPoint(view1.Viewport, p);
if (pt.HasValue)
{
view1.Children.Add(new SphereVisual3D()
{
Center = pt.Value, Radius = 0.03
});
}
}
/// <summary>
/// Re-attaches the instance to the viewport resulting in a refresh.
/// </summary>
public void RefreshChildren()
{
var viewPort = Visual3DHelper.GetViewport3D(this);
var index = viewPort.Children.IndexOf(this);
viewPort.Children.Remove(this);
viewPort.Children.Insert(index, this);
}
public Point3D ToLocal(Point3D worldPoint)
{
var mat = Visual3DHelper.GetTransform(this);
mat.Invert();
var t = new MatrixTransform3D(mat);
return(t.Transform(worldPoint));
}
/// <summary>
/// Applies the cutting planes.
/// </summary>
/// <param name="forceUpdate">
/// if set to <c>true</c> [force update].
/// </param>
private void ApplyCuttingPlanes(bool forceUpdate = false)
{
lock (this)
{
this.TempCutGeometries = new Dictionary <Model3D, Geometry3D>();
this.TempOriginalGeometries = new Dictionary <Model3D, Geometry3D>();
this.forceUpdate = forceUpdate;
Visual3DHelper.Traverse <GeometryModel3D>(this.Children, this.ApplyCuttingPlanesToModel);
this.CutGeometries = this.TempCutGeometries;
this.OriginalGeometries = this.TempOriginalGeometries;
}
}
public static ModelVisual3D AddContours(Visual3D model1, int d1, int d2, int d3, double diameter = 0.5)
{
var ContourModel = new ModelVisual3D();
Plane3D ContourPlane = null;
Action <GeometryModel3D, Transform3D> AddContours = (model, transform) =>
{
var p = ContourPlane.Position;
var n = ContourPlane.Normal;
var segments = MeshGeometryHelper
.GetContourSegments(model.Geometry as MeshGeometry3D, p, n).ToList();
var contours = MeshGeometryHelper.CombineSegments(segments, 1e-6).ToList();
foreach (var contour in contours)
{
if (contour.Count == 0)
{
continue;
}
ContourModel.Children.Add(new TubeVisual3D {
Diameter = diameter,
Path = new Point3DCollection(contour),
Fill = Brushes.White, ThetaDiv = 4
});
}
};
var bounds = Visual3DHelper.FindBounds(model1, Transform3D.Identity);
for (int i = 1; i < d3; i++)
{
ContourPlane = new Plane3D(
new Point3D(0, 0, bounds.Location.Z + bounds.Size.Z * i / d3),
new Vector3D(0, 0, 1));
Visual3DHelper.Traverse <GeometryModel3D>(model1, AddContours);
}
for (int i = 1; i < d2; i++)
{
ContourPlane = new Plane3D(
new Point3D(0, bounds.Location.Y + bounds.Size.Y * i / d2, 0),
new Vector3D(0, 1, 0));
Visual3DHelper.Traverse <GeometryModel3D>(model1, AddContours);
}
for (int i = 1; i < d1; i++)
{
ContourPlane = new Plane3D(
new Point3D(bounds.Location.X + bounds.Size.X * i / d1, 0, 0),
new Vector3D(1, 0, 0));
Visual3DHelper.Traverse <GeometryModel3D>(model1, AddContours);
}
return(ContourModel);
}
private void Update()
{
if (base.Visibility == Visibility.Visible)
{
if (this.AttachedVisual != null)
{
Matrix3D?transform = Visual3DHelper.GetViewportTransform(this.AttachedVisual);
if (transform.HasValue)
{
Point3D screenPt = transform.Value.Transform(this.Point);
base.Margin = new Thickness(screenPt.X + 1.0, screenPt.Y - 1.0 - base.ActualHeight, 0.0, 0.0);
}
}
}
}
private void ZoomExtent()
{
var viewport = viewPort3d.Viewport;
var bounds = Visual3DHelper.FindBounds(viewport.Children);
var diagonal = new Vector3D(bounds.SizeX, bounds.SizeY, bounds.SizeZ);
if (bounds.IsEmpty || diagonal.LengthSquared < double.Epsilon)
{
return;
}
var infbounds = Inflate(bounds, 0.9f);
CameraHelper.ZoomExtents(this.viewPort3d.Camera, viewport, infbounds);
}
public void SetPresetCameraPosition(string presetName)
{
///PerspectiveCamera.UpDirection*3
var wBounds = Visual3DHelper.FindBounds(Properties.Model, null);
switch (presetName)
{// Need to add proper calc to reposition over model's center
case "Top": PerspectiveCameraSetup(0, -0.1, wBounds.SizeZ + 5, 0, -0.1, -(wBounds.SizeZ + 5)); break;
//Both should scale better with the model to enclose everything in the scene
case "Front": PerspectiveCameraSetup(0, -(wBounds.SizeY + 5), 0, 0, wBounds.SizeY + 5, 0); break;
case "Side": PerspectiveCameraSetup(wBounds.SizeX + 15, 0, 0, -(wBounds.SizeX + 15), 0, 0); break;
}
}
public void Load_TestObj_ValidNumberOfVertices()
{
var model = ModelImporter.Load(@"Models\obj\test.obj");
int countVertices = 0;
Visual3DHelper.TraverseModel <GeometryModel3D>(
model,
(geometryModel, transform) =>
{
var mesh = (MeshGeometry3D)geometryModel.Geometry;
countVertices += mesh.Positions.Count;
});
Assert.AreEqual(8, countVertices);
}
/// <summary>
/// The composition target_ rendering.
/// </summary>
/// <param name="sender">
/// The sender.
/// </param>
/// <param name="e">
/// The event arguments.
/// </param>
protected override void OnCompositionTargetRendering(object sender, RenderingEventArgs e)
{
if (this.isRendering)
{
if (!Visual3DHelper.IsAttachedToViewport3D(this))
{
return;
}
if (this.UpdateTransforms())
{
this.UpdateClipping();
this.UpdateGeometry();
}
}
}
private void View7Loaded(object sender, RoutedEventArgs e)
{
if (view7.CameraController != null)
{
if (_firstTime7)
{
_firstTime7 = false;
// add a box that shows the bounds
Rect3D bounds = Visual3DHelper.FindBounds(view7.Children);
view7.Children.Add(new BoundingBoxVisual3D {
BoundingBox = bounds
});
// add a coordinate system that shows the origin
view7.Children.Add(new CoordinateSystemVisual3D());
}
}
}
protected override void OnCompositionTargetRendering(object sender, RenderingEventArgs eventArgs)
{
if (_isRendering)
{
if (_viewport == null)
{
_viewport = Visual3DHelper.GetViewport3D(this);
if (_viewport == null)
{
return;
}
}
if (this.UpdateTransforms())
{
this.UpdateMode3D();
this.AdjustTextDirection();
}
}
}
/// <summary>
/// Handles the CompositionTarget.Rendering event.
/// </summary>
/// <param name="sender">The sender.</param>
/// <param name="eventArgs">The <see cref="System.Windows.Media.RenderingEventArgs"/> instance containing the event data.</param>
protected void OnCompositionTargetRendering(object sender, RenderingEventArgs eventArgs)
{
if (this._IsRendering)
{
if (!Visual3DHelper.IsAttachedToViewport3D(this))
{
return;
}
if (lastRenderTime == eventArgs.RenderingTime)
{
return;
}
lastRenderTime = eventArgs.RenderingTime;
this.UpdateModel();
}
}
private void AddContours(Visual3D model1, int o, int m, int n)
{
var bounds = Visual3DHelper.FindBounds(model1, Transform3D.Identity);
for (int i = 1; i < n; i++)
{
this.ContourPlane = new Plane3D(new Point3D(0, 0, bounds.Location.Z + bounds.Size.Z * i / n), new Vector3D(0, 0, 1));
Visual3DHelper.Traverse <GeometryModel3D>(model1, this.AddContours);
}
for (int i = 1; i < m; i++)
{
this.ContourPlane = new Plane3D(new Point3D(0, bounds.Location.Y + bounds.Size.Y * i / m, 0), new Vector3D(0, 1, 0));
Visual3DHelper.Traverse <GeometryModel3D>(model1, this.AddContours);
}
for (int i = 1; i < o; i++)
{
this.ContourPlane = new Plane3D(new Point3D(bounds.Location.X + bounds.Size.X * i / o, 0, 0), new Vector3D(1, 0, 0));
Visual3DHelper.Traverse <GeometryModel3D>(model1, this.AddContours);
}
}
private void Update()
{
if (this.Visibility != System.Windows.Visibility.Visible)
{
return;
}
if (AttachedVisual == null)
{
return;
}
var transform = Visual3DHelper.GetViewportTransform(AttachedVisual);
if (!transform.HasValue)
{
return;
}
var m = transform.Value;
var screenPt = m.Transform(Point);
this.Margin = new Thickness(screenPt.X + 1, screenPt.Y - 1 - this.ActualHeight, 0, 0);
}
private Visual3D CreateVisualFromModel(object item)
{
if (this.ItemTemplate != null)
{
return(this.ItemTemplate.CreateItem(item));
}
else if (ItemTemplateSelector != null)
{
var viewPort = Visual3DHelper.GetViewport3D(this);
var dataTemplate = ItemTemplateSelector.SelectTemplate(item, viewPort);
if (dataTemplate != null)
{
return(dataTemplate.CreateItem(item));
}
else
{
return(item as Visual3D);
}
}
else
{
return(item as Visual3D);
}
}
