// Compute angle P1, P2, P3 public static double ComputeAngle(Point3D p1, Point3D p2, Point3D p3) { Vector3D ab = new Vector3D(p2.X - p1.X, p2.Y - p1.Y, p2.Z - p1.Z); Vector3D bc = new Vector3D(p3.X - p2.X, p3.Y - p2.Y, p3.Z - p2.Z); return(Vector3D.AngleBetween(ab, bc)); }
public void Look(Point currentPosition) { Vector3D currentPosition3D = ProjectToTrackball(EventSource.ActualWidth, EventSource.ActualHeight, currentPosition); //currentPosition3D = new Vector3D(_previousPosition3D.X, _previousPosition3D.Y, currentPosition3D.Z); Vector3D axis = Vector3D.CrossProduct(_previousPosition3D, currentPosition3D); double angle = Vector3D.AngleBetween(_previousPosition3D, currentPosition3D); //axis.X = 0; //axis.Z = 0; //axis.Y = 0; if (axis.Length == 0) { _previousPosition3D = currentPosition3D; return; } Quaternion delta = new Quaternion(axis, -angle); // Get the current orientantion from the RotateTransform3D AxisAngleRotation3D r = _rotation; Quaternion q = new Quaternion(_rotation.Axis, _rotation.Angle); // Compose the delta with the previous orientation q *= delta; // Write the new orientation back to the Rotation3D _rotation.Axis = q.Axis; //_rotation.Axis = new Vector3D(q.Axis.X, _rotation.Axis.Y, _rotation.Axis.Z); _rotation.Angle = q.Angle; _previousPosition3D = currentPosition3D; }
internal void Track(Point currentPosition) { var currentPosition3D = ProjectToTrackball(ActualWidth, ActualHeight, currentPosition); var angle = Vector3D.AngleBetween(_previousPosition3D, currentPosition3D); var axis = Vector3D.CrossProduct(_previousPosition3D, currentPosition3D); // quaterion will throw if this happens - sometimes we can get 3D positions that // are very similar, so we avoid the throw by doing this check and just ignoring // the event if (axis.Length == 0) { return; } var delta = new Quaternion(axis, -angle); var q = new Quaternion(_rotation.Axis, _rotation.Angle); q *= delta; // Write the new orientation back to the Rotation3D _rotation.Axis = q.Axis; _rotation.Angle = q.Angle; _previousPosition3D = currentPosition3D; }
public Transform3D Track(Point currentPosition, double width, double height) { Vector3D currentPosition3D = ProjectToTrackball(width, height, currentPosition); Vector3D axis = Vector3D.CrossProduct(_previousPosition3D, currentPosition3D); if (axis.Length < 100 * double.Epsilon) { return(_transform); } double angle = Vector3D.AngleBetween(_previousPosition3D, currentPosition3D); Quaternion delta = new Quaternion(axis, -angle); _orientation = new Quaternion(_rotation.Axis, _rotation.Angle); // Compose the delta with the previous orientation _orientation *= delta; // Write the new orientation back to the Rotation3D _rotation.Axis = _orientation.Axis; _rotation.Angle = _orientation.Angle; _previousPosition3D = currentPosition3D; _previousPosition2D = currentPosition; return(_transform); }
void GenerateLocalAxes() { var globalX = new Vector3D(1.0, 0.0, 0.0); // Get the beams orientation vector this.LongitudinalAxis = new Vector3D(this.EndNode.X - this.StartNode.X, this.EndNode.Y - this.StartNode.Y, this.EndNode.Z - this.StartNode.Z); // Compute the transformation required to match the X axis double angle = Vector3D.AngleBetween(this.LongitudinalAxis, globalX); var rotation = Quaternion.Identity; if (angle % 180 != 0) { rotation = new Quaternion(Vector3D.CrossProduct(globalX, this.LongitudinalAxis), angle); } else { rotation = new Quaternion(new Vector3D(0.0, 1.0, 0.0), angle); } rotation.Normalize(); var transformation = Matrix3D.Identity; transformation.Rotate(rotation); // Apply the transformation this.LongitudinalAxis = transformation.Transform(globalX); this.MajorAxis = transformation.Transform(new Vector3D(0.0, 0.0, 1.0)); this.MinorAxis = transformation.Transform(new Vector3D(0.0, 1.0, 0.0)); }
private void canvas_MouseMove(object sender, MouseEventArgs e) { if (mouseDown /*&& physics == null*/) { if (!mouseCaptured) { root.CaptureMouse(); mouseCaptured = true; } Vector3D position = Trackball.ProjectToTrackball(Width, Height, e.GetPosition(root)); Vector3D axis = Vector3D.CrossProduct(anchorPosition, position); double angle = Vector3D.AngleBetween(anchorPosition, position); if (axis != new Vector3D()) { axis.Y *= -1; Quaternion delta = new Quaternion(axis, angle); camera.Rotation *= delta; camera.UpDirection = camera.GetRotationMatrix().Transform(new Vector3D(0, 1, 0)); } anchorPosition = position; needsRefresh = true; } }
internal static Device CalculateClosestMatch(List <Device> devices, Point3D[] vectors) { Device currDev = null; Double currDist = -1; if (vectors == null) { return(null); } // pointing ray goes from vectors[0] to vectors[1] Ray3D pointer = new Ray3D(vectors[0], vectors[1]); Double tempDist; foreach (Device dev in devices) { foreach (Ball ball in dev.Form) { // check if Ball is in front of pointing ray if (Vector3D.AngleBetween(pointer.direction, ball.Center - pointer.origin) < 90) { // check distance tempDist = Point3D.Subtract(pointer.nearestPoint(ball.Center), ball.Center).Length; if (currDist == -1 || tempDist < currDist) { currDev = dev; currDist = tempDist; } } } } return(currDev); }
/// <summary> /// The Methode does the collision detection /// First the pointing vector of the underarm is calculated. /// This vector will be "extended" to a straight line. Following it will be calculated if this line hits a sphere of a device. /// Hit devices will be saved in a list. /// </summary> /// <param name="devices">Devices which are available in the system</param> /// <param name="vectors">The position vectors of the ellbows and wrists</param> /// <returns>Devicelist with hit devices</returns> internal static List <Device> Calculate(List <Device> devices, Point3D[] vectors) { List <Device> found = new List <Device>(); if (vectors == null) { return(found); } // pointing ray goes from vectors[0] to vectors[1] Ray3D pointer = new Ray3D(vectors[0], vectors[1]); foreach (Device dev in devices) { foreach (Ball ball in dev.Form) { // check if Ball is in front of pointing ray if (Vector3D.AngleBetween(pointer.direction, ball.Center - pointer.origin) < 90) { // check distance if (Point3D.Subtract(pointer.nearestPoint(ball.Center), ball.Center).Length <= ball.Radius) { found.Add(dev); continue; // skip other balls of this dev } } } } return(found); }
private void Normalize(object sender, RoutedEventArgs e) { firstVecFromUser = goThroughText(FirstVec3X.Text, FirstVec3Y.Text, FirstVec3Z.Text); secondVecFromUser = goThroughText(SecondVec3X.Text, SecondVec3Y.Text, SecondVec3Z.Text); Vector3D.AngleBetween(firstVecFromUser, secondVecFromUser); }
/// <summary> /// Calculates the angle between the specified points around the specified axis. /// </summary> /// <param name="center">The center of the angle.</param> /// <param name="start">The start of the angle.</param> /// <param name="end">The end of the angle.</param> /// <param name="axis">The axis around which the angle is calculated.</param> /// <returns>The angle, in degrees.</returns> public static double Angle(this CameraSpacePoint center, CameraSpacePoint start, CameraSpacePoint end, Axis axis) { switch (axis) { case Axis.X: start.X = 0f; center.X = 0f; end.X = 0f; break; case Axis.Y: start.Y = 0f; center.Y = 0f; end.Y = 0f; break; case Axis.Z: start.Z = 0f; center.Z = 0f; end.Z = 0f; break; } Vector3D first = start.ToVector3() - center.ToVector3(); Vector3D second = end.ToVector3() - center.ToVector3(); return(Vector3D.AngleBetween(first, second)); }
public void ProductTest() { // // TODO: Add test logic here // // Calculates the angle between two Vector3Ds using the static AngleBetween method. // Returns a Double. Vector3D vector1 = new Vector3D(20, 30, 40); Vector3D vector2 = new Vector3D(45, 70, 80); Double angleBetween; angleBetween = Vector3D.AngleBetween(vector1, vector2); // angleBetween is approximately equal to 4.15129 Console.WriteLine(angleBetween); double produect = Vector3D.DotProduct(vector1, vector2); Console.WriteLine(produect); double anglecos = Vector3D.DotProduct(vector1, vector2) / vector1.Length / vector2.Length; Console.WriteLine(anglecos); double angle = Math.Acos(Vector3D.DotProduct(vector1, vector2) / vector1.Length / vector2.Length); Console.WriteLine(angle); Console.WriteLine(angle / Math.PI * 180); }
/// <summary> /// Calculates the angle and updates the arc according to the specifed vectors. /// </summary> /// <param name="start">The vector of the starting point.</param> /// <param name="middle">The vector of the middle point.</param> /// <param name="end">The vector of the end point.</param> /// <param name="desiredRadius">The desired arc radius.</param> public void Update(Vector3D start, Vector3D middle, Vector3D end, double desiredRadius = 0) { _vector1 = middle - start; _vector2 = middle - end; if (desiredRadius == 0) { desiredRadius = Math.Min(_vector1.Length, _vector2.Length); } _vector1.Normalize(); _vector2.Normalize(); _angle = Vector3D.AngleBetween(_vector1, _vector2); start = middle - desiredRadius * _vector1; end = middle - desiredRadius * _vector2; line1.Point = middle.ToPoint(); line2.Point = start.ToPoint(); angleFigure.StartPoint = end.ToPoint(); arc.IsLargeArc = _angle > 180.0; arc.Point = end.ToPoint(); arc.Size = new Size(desiredRadius, desiredRadius); }
public static Vector3D[] FindVectorsAtRightAnglesTo(Vector3D v) { var vectors = new List <Vector3D>(); var n = (int)v.Length; for (int x = -n; x <= n; x++) { for (int y = -n; y <= n; y++) { for (int z = -n; z <= n; z++) { if (!(x == 0 && y == 0 && z == 0)) { var vr = new Vector3D(x, y, z); if (Math.Abs(vr.LengthSquared - v.LengthSquared) < 1e-9 && Math.Abs(Math.Abs(Vector3D.AngleBetween(vr, v)) - 90) < 1e-9) { vectors.Add(vr); } } } } } return(vectors.Distinct().ToArray()); }
protected double getAngle(JointObject j1, JointObject j2, JointObject j3) { Vector3D v1 = new Vector3D(j2.x - j1.x, j2.y - j1.y, j2.z - j1.z); Vector3D v2 = new Vector3D(j2.x - j3.x, j2.y - j3.y, j2.z - j3.z); return(Vector3D.AngleBetween(v1, v2)); }
/// <summary> /// The rotate trackball. /// </summary> /// <param name="p1"> /// The previous mouse position. /// </param> /// <param name="p2"> /// The current mouse position. /// </param> /// <param name="rotateAround"> /// The point to rotate around. /// </param> private void RotateTrackball(Point p1, Point p2, Point3D rotateAround) { // http://viewport3d.com/trackball.htm // http://www.codeplex.com/3DTools/Thread/View.aspx?ThreadId=22310 var v1 = ProjectToTrackball(p1, this.Viewport.ActualWidth, this.Viewport.ActualHeight); var v2 = ProjectToTrackball(p2, this.Viewport.ActualWidth, this.Viewport.ActualHeight); // transform the trackball coordinates to view space var viewZ = this.Camera.LookDirection; var viewX = Vector3D.CrossProduct(this.Camera.UpDirection, viewZ); var viewY = Vector3D.CrossProduct(viewX, viewZ); viewX.Normalize(); viewY.Normalize(); viewZ.Normalize(); var u1 = (viewZ * v1.Z) + (viewX * v1.X) + (viewY * v1.Y); var u2 = (viewZ * v2.Z) + (viewX * v2.X) + (viewY * v2.Y); // Could also use the Camera ViewMatrix // var vm = Viewport3DHelper.GetViewMatrix(this.ActualCamera); // vm.Invert(); // var ct = new MatrixTransform3D(vm); // var u1 = ct.Transform(v1); // var u2 = ct.Transform(v2); // Find the rotation axis and angle var axis = Vector3D.CrossProduct(u1, u2); if (axis.LengthSquared < 1e-8) { return; } double angle = Vector3D.AngleBetween(u1, u2); // Create the transform var delta = new Quaternion(axis, -angle * this.RotationSensitivity * 5); var rotate = new RotateTransform3D(new QuaternionRotation3D(delta)); // Find vectors relative to the rotate-around point var relativeTarget = rotateAround - this.Camera.Target; var relativePosition = rotateAround - this.Camera.Position; // Rotate the relative vectors var newRelativeTarget = rotate.Transform(relativeTarget); var newRelativePosition = rotate.Transform(relativePosition); var newUpDirection = rotate.Transform(this.Camera.UpDirection); // Find new camera position var newTarget = rotateAround - newRelativeTarget; var newPosition = rotateAround - newRelativePosition; this.Camera.LookDirection = newTarget - newPosition; if (this.CameraMode == CameraMode.Inspect) { this.Camera.Position = newPosition; } this.Camera.UpDirection = newUpDirection; }
public static double GetRotationXZ(this Matrix3D matrix, double rotationZ) { // back off z rotation Matrix3D matrix2 = new Matrix3D(); matrix2.Append(matrix); matrix2 = matrix2.RotateXYZ(new Vector3D(0.0, 0.0, rotationZ * -1.0)); Vector3D localX = matrix2.Transform(new Vector3D(1, 0, 0)); Vector3D localY = matrix2.Transform(new Vector3D(0, 1, 0)); // rotation about the X axis localY.X = 0.0; double angle = Vector3D.AngleBetween(localY, new Vector3D(0, 1, 0)); double rotationX = localX.Z > 0 ? angle * -1.0 : angle; if (Abs(rotationX - 180.0) > 0.01 && Abs(localY.Z) < 0.0001) { rotationX = 0.0; } if (Abs(localY.Y + 1.0) < 0.01) { rotationX = 0.0; } return(rotationX); }
private MeshGeometry3D ShowSteepAngles(double angle, Vector3D reference, bool inverted) { //to store the outgoing mesh var mesh = new MeshBuilder(true); MeshGeometry3D scannedMesh = bolus.Mesh(); //calculate for each triangle for (int triangle = 0; triangle < scannedMesh.TriangleIndices.Count; triangle += 3) { //get the triangle's normal int i0 = scannedMesh.TriangleIndices[triangle]; int i1 = scannedMesh.TriangleIndices[triangle + 1]; int i2 = scannedMesh.TriangleIndices[triangle + 2]; Point3D p0 = scannedMesh.Positions[i0]; Point3D p1 = scannedMesh.Positions[i1]; Point3D p2 = scannedMesh.Positions[i2]; var normal = CalculateSurfaceNormal(p0, p1, p2); //calculate normal's angle from the ground //using the z-axis as to determine how the angle if from the ground var degrees = Vector3D.AngleBetween(normal, reference); //if angle less than steepangle, add the triangle to the overhang mesh if (degrees < angle) { mesh.AddTriangle(p0, p1, p2); } } return(mesh.ToMesh()); }
/// <summary> /// Calculates the angle between the specified points. /// </summary> /// <param name="center">The center of the angle.</param> /// <param name="start">The start of the angle.</param> /// <param name="end">The end of the angle.</param> /// <returns>The angle, in degrees.</returns> public static double AngleBetween(this DepthSpacePoint center, DepthSpacePoint start, DepthSpacePoint end) { Vector3D first = start.ToVector3() - center.ToVector3(); Vector3D second = end.ToVector3() - center.ToVector3(); return(Vector3D.AngleBetween(first, second)); }
public bool IsVisible(double cameraZ) { var camFaceCenterVector = new Vector3D(-_center.X, -_center.Y, -cameraZ - _center.Z); var angle = Vector3D.AngleBetween(camFaceCenterVector, _faceFront); return(angle < 90.0); }
private void Track(Point currentPosition) { Vector3D currentPosition3D = ProjectToTrackball( ActualWidth, ActualHeight, currentPosition); Vector3D axis = Vector3D.CrossProduct(_previousPosition3D, currentPosition3D); double angle = Vector3D.AngleBetween(_previousPosition3D, currentPosition3D); // quaterion will throw if this happens - sometimes we can get 3D positions that // are very similar, so we avoid the throw by doing this check and just ignoring // the event if (axis.Length == 0) { return; } Quaternion delta = new Quaternion(axis, -angle); // Get the current orientantion from the RotateTransform3D AxisAngleRotation3D r = _rotation; Quaternion q = new Quaternion(_rotation.Axis, _rotation.Angle); // Compose the delta with the previous orientation q *= delta; // Write the new orientation back to the Rotation3D _rotation.Axis = q.Axis; _rotation.Angle = q.Angle; _previousPosition3D = currentPosition3D; }
static void Main(string[] args) { Vector3D u = new Vector3D(0, 3, 4); Vector3D v = new Vector3D(0, 4, -3); Point3D a = new Point3D(10, 12, 15); Point3D b = a + u; // Point + Vector = Point Vector3D w = b - a; // Point - Point = Vector Vector3D t = u + v; // Vector + Vector = Vector double angle = Vector3D.AngleBetween(u, v); Vector3D cross = Vector3D.CrossProduct(u, v); double dot = Vector3D.DotProduct(u, v); Vector3D normal = cross; normal.Normalize(); Vector3D scaled = normal * 10; Console.WriteLine("u:\t" + u.ToString()); Console.WriteLine("v:\t" + v.ToString()); Console.WriteLine("w:\t" + w.ToString()); Console.WriteLine("a:\t" + a.ToString()); Console.WriteLine("b:\t" + b.ToString()); Console.WriteLine("angle:\t" + angle.ToString()); Console.WriteLine("cross:\t" + cross.ToString()); Console.WriteLine("dot:\t" + dot.ToString()); Console.WriteLine("normal:\t" + normal.ToString()); Console.WriteLine("scaled:\t" + scaled.ToString()); Console.ReadLine(); }
/// <summary> /// Calculates the angle between the specified points. /// </summary> /// <param name="center">The center of the angle.</param> /// <param name="start">The start of the angle.</param> /// <param name="end">The end of the angle.</param> /// <returns>The angle, in degrees.</returns> public static double Angle(this CameraSpacePoint center, CameraSpacePoint start, CameraSpacePoint end) { Vector3D first = new Vector3D(start.X, start.Y, start.Z) - new Vector3D(center.X, center.Y, center.Z); Vector3D second = new Vector3D(end.X, end.Y, end.Z) - new Vector3D(center.X, center.Y, center.Z); return(Vector3D.AngleBetween(first, second)); }
// Make a cylinder using vectors perpendicular to the axis. private void MakeCylinder(Model3DGroup model_group, ref MeshGeometry3D cylinder_mesh, Material cylinder_material, double cx1, double cy1, double cz1, double cx2, double cy2, double cz2, double uv1, double uv2, double uv3, double uv4, double radius1, double radius2, int num_theta) { // Get the axis. Vector3D axis = new Vector3D(cx2 - cx1, cy2 - cy1, cz2 - cz1); // Just pick a vector to start from. Vector3D vector1 = new Vector3D(1, 0, 0); if (Vector3D.AngleBetween(axis, vector1) < 0.1) // See if they're parallel. { // Pick a different vector1. vector1 = new Vector3D(0, 0, 1); } // Find perpendicular vectors. Vector3D vector2 = Vector3D.CrossProduct(axis, vector1); vector1 = Vector3D.CrossProduct(axis, vector2); vector1.Normalize(); vector2.Normalize(); // Make the cylinder. MakeCylinder(model_group, ref cylinder_mesh, cylinder_material, cx1, cy1, cz1, cx2, cy2, cz2, uv1, uv2, uv3, uv4, radius1, radius2, num_theta, vector1, vector2); }
private void Track(Point currentPosition) { Vector3D currentPosition3D = ProjectToTrackball(EventSource.ActualWidth, EventSource.ActualHeight, currentPosition); IoC.Get <IOutput>().Append("New trackball position: " + currentPosition3D); // Because our sphere is centered at the origin, we may interpret our points as vectors. Doing so it is trivial // to find the axis and angle of rotation using the cross product dot product respectively. Vector3D axis = Vector3D.Cross(_initialPosition3D, currentPosition3D); float angle = Vector3D.AngleBetween(_initialPosition3D, currentPosition3D); // We negate the angle because we are rotating the camera (if we were rotating the scene, we wouldn't do this). Quaternion delta = new Quaternion(axis, -angle); // Get the initial orientation. Quaternion q = _persistentOrientation; // Compose the delta with the previous orientation q *= delta; // Store the new orientation. _rotation.Axis = q.Axis; _rotation.Angle = q.Angle; _currentOrientation = q; //_previousPosition3D = currentPosition3D; }
Point3D panelCenter = new Point3D(0, 0, 0); //控制板操作状态的中心点 /// <summary> /// 获取屏幕点与地平面Y=0的交点 /// </summary> /// <param name="p">viewport3D上的屏幕点</param> private void getCrossPoint3D(Point p) { Matrix3D matrix2, matrixc; Vector3D v1, v2; Vector3D raxis; double rangle; //v1 = new Vector3D(0, 0, -1); PerspectiveCamera camera = mainViewport3D.Camera as PerspectiveCamera; matrixc = (camera.Transform as MatrixTransform3D).Matrix; Point3D pline = camera.Position; pline = matrixc.Transform(pline); Vector3D vline = camera.LookDirection; vline = matrixc.Transform(vline); double angx = Math.Atan((p.X - mainViewport3D.ActualWidth / 2) / (mainViewport3D.ActualWidth / 2) * Math.Tan(camera.FieldOfView / 2 / 180 * Math.PI)); double angy = Math.Atan((-p.Y + mainViewport3D.ActualHeight / 2) / (mainViewport3D.ActualWidth / 2) * Math.Tan(camera.FieldOfView / 2 / 180 * Math.PI)); v1 = new Vector3D(0, 0, -1); v2 = new Vector3D(Math.Tan(angx), Math.Tan(angy), -1); raxis = Vector3D.CrossProduct(v1, v2); raxis.Normalize(); raxis = matrixc.Transform(raxis); raxis.Normalize(); rangle = Vector3D.AngleBetween(v1, v2); if (rangle != 0) { matrix2 = new Matrix3D(); matrix2.Rotate(new Quaternion(raxis, rangle)); vline = matrix2.Transform(vline); vline.Normalize(); } _pcenter = Model3DHelper.calFlatXLine(new Vector3D(0, 1, 0), new Point3D(10000, 0, 10000), vline, pline); }
private void Track(Point currentPosition) { try { Vector3D currentPosition3D = ProjectToTrackball( EventSource.ActualWidth, EventSource.ActualHeight, currentPosition); Vector3D axis = Vector3D.CrossProduct(_previousPosition3D, currentPosition3D); double angle = Vector3D.AngleBetween(_previousPosition3D, currentPosition3D); Quaternion delta = new Quaternion(axis, -angle); AxisAngleRotation3D r = _rotation; Quaternion q = new Quaternion(_rotation.Axis, _rotation.Angle); q *= delta; _rotation.Axis = q.Axis; _rotation.Angle = q.Angle; _previousPosition3D = currentPosition3D; } catch (Exception ex) { Trace.WriteLine("Exception while tracking movement: " + ex); } }
public void getTiltsbyAA_divided(Vector3D axis, int strandNum, ref Dictionary <string, AminoAcid> _aaDict) { if (this.StrandNum % 2 == 0) {// calculate tilt for (int resCtr = 0; resCtr < this.Residues.Count; resCtr++) { if (resCtr > 0 && resCtr < this.Residues.Count - 1 && _aaDict.ContainsKey(this.Residues[resCtr].ThreeLetCode)) { _aaDict[this.Residues[resCtr].ThreeLetCode].Tilt_even.Add(Vector3D.AngleBetween(this.Residues[resCtr - 1].BackboneCoords["CA"] - this.Residues[resCtr + 1].BackboneCoords["CA"], axis)); this.AvgTilt_even += (Vector3D.AngleBetween(this.Residues[resCtr - 1].BackboneCoords["CA"] - this.Residues[resCtr + 1].BackboneCoords["CA"], axis) / (this.Residues.Count - 2)); } } } else // if odd { for (int resCtr = 0; resCtr < this.Residues.Count; resCtr++) { if (resCtr > 0 && resCtr < this.Residues.Count - 1 && _aaDict.ContainsKey(this.Residues[resCtr].ThreeLetCode)) { _aaDict[this.Residues[resCtr].ThreeLetCode].Tilt_odd.Add(Vector3D.AngleBetween(this.Residues[resCtr - 1].BackboneCoords["CA"] - this.Residues[resCtr + 1].BackboneCoords["CA"], axis)); this.AvgTilt_odd += (Vector3D.AngleBetween(this.Residues[resCtr - 1].BackboneCoords["CA"] - this.Residues[resCtr + 1].BackboneCoords["CA"], axis) / (this.Residues.Count - 2)); } } } }
/// <summary> /// /// </summary> private void Look(Point currentPosition) { Vector3D currentPosition3D = ProjectToTrackball( EventSource.ActualWidth, EventSource.ActualHeight, currentPosition); if (_previousPosition3D.Equals(currentPosition3D)) { return; } Vector3D axis = Vector3D.CrossProduct(_previousPosition3D, currentPosition3D); double angle = _rotationFactor * Vector3D.AngleBetween(_previousPosition3D, currentPosition3D); Quaternion delta = new Quaternion(axis, -angle); // Get the current orientation from the RotateTransform3D AxisAngleRotation3D r = _rotation; Quaternion q = new Quaternion(_rotation.Axis, _rotation.Angle); // Compose the delta with the previous orientation q *= delta; // Write the new orientation back to the Rotation3D _rotation.Axis = q.Axis; _rotation.Angle = q.Angle; _previousPosition3D = currentPosition3D; }
public static double AngleBetweenThreePoints(SolidEdgeGeometry.Vertex Start, SolidEdgeGeometry.Vertex Center, SolidEdgeGeometry.Vertex End)//, Vector3D up) { //Vertexs.GetPointData Array p1 = Array.CreateInstance(typeof(double), 0); Array p2 = Array.CreateInstance(typeof(double), 0); Array p3 = Array.CreateInstance(typeof(double), 0); double[] pointStart; double[] pointCenter; double[] pointEnd; Start.GetPointData(ref p1); Center.GetPointData(ref p2); End.GetPointData(ref p3); pointStart = (double[])p1; pointCenter = (double[])p2; pointEnd = (double[])p3; double x1 = 0 - pointCenter[0]; double y1 = 0 - pointCenter[1]; double z1 = 0 - pointCenter[2]; Vector3D vt1 = new Vector3D(pointStart[0] + x1, pointStart[1] + y1, pointStart[2] + z1); Vector3D vt3 = new Vector3D(pointEnd[0] + x1, pointEnd[1] + y1, pointEnd[2] + z1); return(Math.Round(Vector3D.AngleBetween(vt1, vt3))); }
private void Sphere_MouseMove(object sender, MouseEventArgs e) { if (_isMouseLeftButtonDown) { Visual3DHitTestHelper visual3DHitTestHelper = new Visual3DHitTestHelper(); visual3DHitTestHelper.HitTest(Viewport3D, _mousePosition, out Visual3D hitVisual3D, out Point3D HitPoint3D); Point mousePotion = e.GetPosition(null); visual3DHitTestHelper.HitTest(Viewport3D, mousePotion, out Visual3D hitVisual3D1, out Point3D HitPoint3D1); Vector3D vector1 = new Vector3D(HitPoint3D.X, HitPoint3D.Y, HitPoint3D.Z); Vector3D vector2 = new Vector3D(HitPoint3D1.X, HitPoint3D1.Y, HitPoint3D1.Z); Vector3D rotateAxis = Vector3D.CrossProduct(vector1, vector2); double horizontalRotateAngle = -Vector3D.AngleBetween(vector1, vector2); Camera?.RotateAroundAxis(rotateAxis, horizontalRotateAngle); _mousePosition = e.GetPosition(null); _isCameraRotated = true; RoutedEventArgs args = new RoutedEventArgs(CameraStatusChangingEvent, this); RaiseEvent(args); } }
public IList<Vector3D> ComputeCurve( Vector3D start, Vector3D stop, double granularity) { if (granularity <= 0.0) { throw new ArgumentOutOfRangeException("granularity", "Granularity must be greater than zero."); } Vector3D normal = start.Cross(stop).Normalize(); double theta = start.AngleBetween(stop); int n = Math.Max((int)(theta / granularity) - 1, 0); List<Vector3D> positions = new List<Vector3D>(2 + n); positions.Add(start); for (int i = 1; i <= n; ++i) { double phi = (i * granularity); positions.Add(ScaleToGeocentricSurface(start.RotateAroundAxis(normal, phi))); } positions.Add(stop); return positions; }