public bool IsHittedBy(HitTestPointData hitData) { foreach (var rect in _rectangles) { if (hitData.IsHit(rect, _transformation, out var z)) { return(true); } } return(false); }
public bool IsHittedBy(HitTestPointData hitData) { foreach (var outline in _outlines) { if (outline.IsHittedBy(hitData)) { return(true); } } return(false); }
public void MoveGrip(HitTestPointData newPosition) { foreach (var ele in GripList) ele.MoveGrip(newPosition); }
/// <summary> /// Gets the principal coordinate system that results of the camera facing a layer. The plane of the layer that best faced the camera is used for the calculations. /// The normal of that layer is returned as z-axis, the vector that best matches the up-vector of the camera is becoming the y-axis, /// and the x-axis results from the z-axis and the y-axis. /// </summary> /// <param name="camera">The camera.</param> /// <param name="activeLayer">The active layer of the graph document.</param> /// <param name="transformation">Matrix that contains the principal axes as described above. The axes coordinates are in the coordinates of the layer provided in the argument <paramref name="activeLayer"/>.</param> /// <exception cref="InvalidProgramException">There should always be a plane of a rectangle that can be hit!</exception> public static void GetCoordinateSystemBasedOnLayerPlaneFacingTheCamera(CameraBase camera, HostLayer activeLayer, out Matrix3x3 transformation) { PointD3D hitposition = new PointD3D(0.5, 0.5, 1); // this hit position is arbitrary, every other position should work similarly var activeLayerTransformation = activeLayer.TransformationFromRootToHere(); var hitData = new HitTestPointData(camera.GetHitRayMatrix(hitposition)); hitData = hitData.NewFromAdditionalTransformation(activeLayerTransformation); // now hitdata are in layer cos var targetToEye = hitData.WorldTransformation.Transform(camera.TargetToEyeVectorNormalized); // targetToEye in layer coordinates var upEye = hitData.WorldTransformation.Transform(camera.UpVectorPerpendicularToEyeVectorNormalized); // camera up vector in layer coordinates // get the face which has the best dot product between the eye vector of the camera and the plane's normal var layerRect = new RectangleD3D(PointD3D.Empty, activeLayer.Size); double maxval = double.MinValue; PlaneD3D maxPlane = PlaneD3D.Empty; foreach (var plane in layerRect.Planes) { double val = VectorD3D.DotProduct(plane.Normal, targetToEye); if (val > maxval) { maxval = val; maxPlane = plane; } } // bool isHit = hitData.IsPlaneHitByRay(maxPlane, out hitPointOnPlaneInActiveLayerCoordinates); // hitPointOnPlane is in layer coordinates too // if (!isHit) // throw new InvalidProgramException("There should always be a plane of a rectangle that can be hit!"); VectorD3D zaxis = maxPlane.Normal; VectorD3D yaxis = upEye; // Find y axis perpendicular to zaxis maxval = double.MinValue; foreach (var plane in layerRect.Planes) { double val = VectorD3D.DotProduct(plane.Normal, upEye); if (val > maxval && 0 == VectorD3D.DotProduct(plane.Normal, zaxis)) { maxval = val; yaxis = plane.Normal; } } var xaxis = VectorD3D.CrossProduct(yaxis, zaxis); // now we have all information about the spatial position and orientation of the text: // hitPointOnPlane is the position of the text // maxPlane.Normal is the face orientation of the text // maxUpVector is the up orientation of the text xaxis = xaxis.Normalized; yaxis = yaxis.Normalized; zaxis = zaxis.Normalized; transformation = new Matrix3x3( xaxis.X, yaxis.X, zaxis.X, xaxis.Y, yaxis.Y, zaxis.Y, xaxis.Z, yaxis.Z, zaxis.Z ); }
/// <summary> /// Handles the mouse move event. /// </summary> /// <param name="position">Mouse position.</param> /// <param name="e">MouseEventArgs as provided by the view.</param> /// <returns>The next mouse state handler that should handle mouse events.</returns> public override void OnMouseMove(PointD3D position, MouseEventArgs e) { base.OnMouseMove(position, e); if (null != ActiveGrip) { var graphCoord = new HitTestPointData(_grac.Doc.Camera.GetHitRayMatrix(position)); ActiveGrip.MoveGrip(graphCoord); _wereObjectsMoved = true; _grac.RenderOverlay(); } /* else if (e.LeftButton == MouseButtonState.Pressed) { var diffPos = position - _positionLastMouseDownInMouseCoordinates; var oldRect = _rectangleSelectionArea_GraphCoordinates; if (null != _rectangleSelectionArea_GraphCoordinates || Math.Abs(diffPos.X) >= System.Windows.SystemParameters.MinimumHorizontalDragDistance || Math.Abs(diffPos.Y) >= System.Windows.SystemParameters.MinimumHorizontalDragDistance) { if (null == _rectangleSelectionArea_GraphCoordinates) { _grac.CaptureMouse(); } var pt1 = _grac.ConvertMouseToRootLayerCoordinates(_positionLastMouseDownInMouseCoordinates); var rect = new RectangleD2D(pt1, PointD2D.Empty); rect.ExpandToInclude(_grac.ConvertMouseToRootLayerCoordinates(position)); _rectangleSelectionArea_GraphCoordinates = rect; } if (null != _rectangleSelectionArea_GraphCoordinates) _grac.RenderOverlay(); } */ }
/// <summary> /// Tests if a grip from the <see cref="DisplayedGrips"/> is hitted. /// </summary> /// <param name="pt">Mouse location.</param> /// <returns>The grip which was hitted, or null if no grip was hitted.</returns> public IGripManipulationHandle GripHitTest(HitTestPointData pt) { if (null == DisplayedGrips || DisplayedGrips.Length == 0) return null; for (int i = 0; i < DisplayedGrips.Length; i++) { if (DisplayedGrips[i].IsGripHit(pt)) return DisplayedGrips[i]; } return null; }
public bool IsHittedBy(HitTestPointData hitData) { foreach (var outline in _outlines) if (outline.IsHittedBy(hitData)) return true; return false; }
public bool GetHittedElement(HitTestPointData point, out IGripManipulationHandle gripHandle, out IHitTestObject hitObject) { for (int i = GripList.Count - 1; i >= 0; i--) { if (GripList[i].IsGripHit(point)) { gripHandle = GripList[i]; hitObject = HittedList[i]; return true; } } gripHandle = null; hitObject = null; return false; }
public bool IsGripHit(HitTestPointData point) { return(false); }
public bool IsHittedBy(HitTestPointData hitData) { double z; return hitData.IsHit(_rectangle, _transformation, out z); }
public void MoveGrip(HitTestPointData newPosition) { }
/// <summary> /// Activates this grip, providing the initial position of the mouse. /// </summary> /// <param name="initialPosition">Initial position of the mouse.</param> /// <param name="isActivatedUponCreation">If true the activation is called right after creation of this handle. If false, /// thie activation is due to a regular mouse click in this grip.</param> public void Activate(HitTestPointData initialPosition, bool isActivatedUponCreation) { }
/// <summary> /// Looks for a graph object at the position given by <paramref name="hitData"/> and returns true if one is found. /// </summary> /// <param name="hitData">The position of the mouse, expressed as transformation, that when applied, transformes the mouse coordinate to the point x=0, y=0, z=-Infinity....+Infinity.</param> /// <param name="plotItemsOnly">If true, only the plot items where hit tested.</param> /// <param name="foundObject">Found object if there is one found, else null</param> /// <param name="foundInLayerNumber">The layer the found object belongs to, otherwise 0</param> /// <returns>True if a object was found at the position given by <paramref name="hitData"/>, else false.</returns> public bool FindGraphObjectAtPixelPosition(HitTestPointData hitData, bool plotItemsOnly, out IHitTestObject foundObject, out int[] foundInLayerNumber) { foundObject = Doc.RootLayer.HitTest(hitData, plotItemsOnly); if (null != foundObject && null != foundObject.ParentLayer) { foundInLayerNumber = foundObject.ParentLayer.IndexOf().ToArray(); return true; } foundObject = null; foundInLayerNumber = null; return false; }
public bool IsHittedBy(HitTestPointData hitData) { throw new NotImplementedException(); }
public bool IsHittedBy(HitTestPointData hitData) { double z; foreach (var rect in _rectangles) { if (hitData.IsHit(rect, _transformation, out z)) return true; } return false; }
public bool IsGripHit(HitTestPointData point) { foreach (var ele in GripList) if (ele.IsGripHit(point)) return true; return false; }
public bool IsHittedBy(HitTestPointData hitData) { throw new NotImplementedException(); }
public override void OnMouseDown(PointD3D position, MouseButtonEventArgs e) { base.OnMouseDown(position, e); if (e.ChangedButton == MouseButton.Left) { var hitData = new HitTestPointData(_grac.Doc.Camera.GetHitRayMatrix(position)); // first, if we have a mousedown without shift key and the // position has changed with respect to the last mousedown // we have to deselect all objects var keyboardModifiers = System.Windows.Input.Keyboard.Modifiers; bool bControlKey = keyboardModifiers.HasFlag(ModifierKeys.Control); bool bShiftKey = keyboardModifiers.HasFlag(ModifierKeys.Shift); ActiveGrip = GripHitTest(hitData); if ((ActiveGrip is SuperGrip) && (bShiftKey || bControlKey)) { var superGrip = ActiveGrip as SuperGrip; IHitTestObject hitTestObj; IGripManipulationHandle gripHandle; if (superGrip.GetHittedElement(hitData, out gripHandle, out hitTestObj)) { _selectedObjects.Remove(hitTestObj); superGrip.Remove(gripHandle); return; } } else if (ActiveGrip != null) { ActiveGrip.Activate(hitData, false); return; } // search for a object first IHitTestObject clickedObject; int[] clickedLayerNumber = null; _grac.FindGraphObjectAtPixelPosition(hitData, false, out clickedObject, out clickedLayerNumber); if (!bShiftKey && !bControlKey) // if shift or control are pressed, we add the object to the selection list and start moving mode ClearSelections(); if (null != clickedObject) AddSelectedObject(hitData, clickedObject); } }
/// <summary> /// Copy constructor. /// </summary> /// <param name="from">Another HitTestData object to copy from.</param> public HitTestPointData(HitTestPointData from) { this._hitTransformation = from._hitTransformation; this._worldTransformation = from._worldTransformation; }
private void AddSelectedObject(HitTestPointData hitPoint, IHitTestObject clickedObject) { _selectedObjects.Add(clickedObject); DisplayedGripLevel = 1; DisplayedGrips = GetGripsFromSelectedObjects(); if (_selectedObjects.Count == 1) // single object selected { ActiveGrip = GripHitTest(hitPoint); if (ActiveGrip != null) ActiveGrip.Activate(hitPoint, true); } else // multiple objects selected { ActiveGrip = DisplayedGrips[0]; // this is our SuperGrip DisplayedGrips[0].Activate(hitPoint, true); } _grac.RenderOverlay(); }
/// <summary> /// Gets the hit point on that plane of the active layer rectangle, that is facing the camera. /// </summary> /// <param name="doc">The graph document containing the active layer.</param> /// <param name="activeLayer">The active layer of the graph document.</param> /// <param name="hitposition">Hit point in relative screen coordinates. The z-component is the aspect ratio of the screen (y/x).</param> /// <param name="hitPointOnPlaneInActiveLayerCoordinates">Output: The hit point on the plane of the active layer that faces the camera. The hit point is returned in active layer coordinates.</param> /// <param name="rotationsRadian">The rotation angles that can be used e.g. to orient text so that the text is most readable from the current camera setting. Rotation angle around x is the x-component of the returned vector, and so on.</param> /// <exception cref="InvalidProgramException">There should always be a plane of a rectangle that can be hit!</exception> public static void GetHitPointOnActiveLayerPlaneFacingTheCamera(GraphDocument doc, HostLayer activeLayer, PointD3D hitposition, out PointD3D hitPointOnPlaneInActiveLayerCoordinates, out VectorD3D rotationsRadian) { var activeLayerTransformation = activeLayer.TransformationFromRootToHere(); var camera = doc.Camera; var hitData = new HitTestPointData(camera.GetHitRayMatrix(hitposition)); hitData = hitData.NewFromAdditionalTransformation(activeLayerTransformation); // now hitdata are in layer cos var targetToEye = hitData.WorldTransformation.Transform(camera.TargetToEyeVectorNormalized); // targetToEye in layer coordinates var upEye = hitData.WorldTransformation.Transform(camera.UpVectorPerpendicularToEyeVectorNormalized); // camera up vector in layer coordinates // get the face which has the best dot product between the eye vector of the camera and the plane's normal var layerRect = new RectangleD3D(PointD3D.Empty, activeLayer.Size); double maxval = double.MinValue; PlaneD3D maxPlane = PlaneD3D.Empty; foreach (var plane in layerRect.Planes) { double val = VectorD3D.DotProduct(plane.Normal, targetToEye); if (val > maxval) { maxval = val; maxPlane = plane; } } bool isHit = hitData.IsPlaneHitByRay(maxPlane, out hitPointOnPlaneInActiveLayerCoordinates); // hitPointOnPlane is in layer coordinates too if (!isHit) throw new InvalidProgramException("There should always be a plane of a rectangle that can be hit!"); VectorD3D zaxis = maxPlane.Normal; VectorD3D yaxis = upEye; // Find y axis perpendicular to zaxis maxval = double.MinValue; foreach (var plane in layerRect.Planes) { double val = VectorD3D.DotProduct(plane.Normal, upEye); if (val > maxval && 0 == VectorD3D.DotProduct(plane.Normal, zaxis)) { maxval = val; yaxis = plane.Normal; } } var xaxis = VectorD3D.CrossProduct(yaxis, zaxis); // now we have all information about the spatial position and orientation of the text: // hitPointOnPlane is the position of the text // maxPlane.Normal is the face orientation of the text // maxUpVector is the up orientation of the text double cx, sx, cy, sy, cz, sz; sy = xaxis.Z; if (1 != Math.Abs(sy)) { cy = Math.Sqrt(1 - sy * sy); cz = xaxis.X / cy; sz = xaxis.Y / cy; sx = yaxis.Z / cy; cx = zaxis.Z / cy; } else // sy is +1, thus cy is zero { // we set x-rotation to zero, i.e. cx==1 and sx==0 cy = 0; cx = 1; sx = 0; cz = yaxis.Y; sz = -yaxis.X; } rotationsRadian = new VectorD3D(Math.Atan2(sx, cx), Math.Atan2(sy, cy), Math.Atan2(sz, cz)); }
/// <summary> /// Activates this grip, providing the initial position of the mouse. /// </summary> /// <param name="initialPosition">Initial position of the mouse.</param> /// <param name="isActivatedUponCreation">If true the activation is called right after creation of this handle. If false, /// thie activation is due to a regular mouse click in this grip.</param> public void Activate(HitTestPointData initialPosition, bool isActivatedUponCreation) { foreach (var ele in GripList) ele.Activate(initialPosition, isActivatedUponCreation); }
public bool IsHittedBy(HitTestPointData hitData) { return(hitData.IsHit(_rectangle, _transformation, out var z)); }
/// <summary> /// Copy constructor. /// </summary> /// <param name="from">Another HitTestData object to copy from.</param> public HitTestPointData(HitTestPointData from) { _hitTransformation = from._hitTransformation; _worldTransformation = from._worldTransformation; }
protected override IHitTestObject HitTestWithLocalCoordinates(HitTestPointData localCoord, bool plotItemsOnly) { IHitTestObject hit = null; if (!plotItemsOnly) { hit = _axisStyles.HitTest(localCoord, AxisScaleEditorMethod, AxisStyleEditorMethod, AxisLabelMajorStyleEditorMethod, AxisLabelMinorStyleEditorMethod); } if (null == hit) { hit = base.HitTestWithLocalCoordinates(localCoord, plotItemsOnly); } if (null != hit && hit.ParentLayer == null) hit.ParentLayer = this; return hit; }