/// <summary>
/// Zooms the camera in/out until it reaches the target
/// </summary>
void Zoom_()
{
switch (_zoomDirection)
{
// zoom in
case ZoomDirection.In:
TheCamera.orthographicSize -= _zoomSpeed * Time.deltaTime * SpeedAdjustment;
// stop when target reached
if (TheCamera.orthographicSize < _targetZoom)
{
_zoomDirection = ZoomDirection.None;
TheCamera.orthographicSize = _targetZoom;
}
break;
// zoom out
case ZoomDirection.Out:
TheCamera.orthographicSize += _zoomSpeed * Time.deltaTime * SpeedAdjustment;
// stop when target reached
if (TheCamera.orthographicSize > _targetZoom)
{
_zoomDirection = ZoomDirection.None;
TheCamera.orthographicSize = _targetZoom;
}
break;
}
}
/// <summary>
/// Start the movement
/// </summary>
/// <param name="targetPosition">Where to move to (where the camera should end up)</param>
public void StartMovement(Vector2 targetPosition, float targetZoom)
{
// get the differences in X and Y directions
var xDifference = Math.Abs(targetPosition.x - transform.localPosition.x);
var yDifference = Math.Abs(targetPosition.y - transform.localPosition.y);
var zDifference = Math.Abs(targetZoom - TheCamera.orthographicSize);
// calculate the speed to move at
var max = (Math.Max(Math.Max(xDifference, yDifference), zDifference));
_xSpeed = xDifference / max;
_ySpeed = yDifference / max;
_zoomSpeed = zDifference / max;
_targetPosition = targetPosition;
_targetZoom = targetZoom;
// get the original movement
if (_targetPosition.x != transform.localPosition.x)
{
_xMovement = _targetPosition.x > transform.localPosition.x ? MovementDirectionX.Right : MovementDirectionX.Left;
}
if (_targetPosition.y != transform.localPosition.y)
{
_yMovement = _targetPosition.y > transform.localPosition.y ? MovementDirectionY.Up : MovementDirectionY.Down;
}
if (_targetZoom != TheCamera.orthographicSize)
{
_zoomDirection = _targetZoom < TheCamera.orthographicSize ? ZoomDirection.In : ZoomDirection.Out;
}
// set values
_callbackCalled = false;
}
/// <summary>
/// Raises zoom gesture event to subscribers.
/// </summary>
/// <param name="direction">Zoom direction.</param>
private void OnZoom(ZoomDirection direction)
{
var func = Zoom;
if (func != null)
{
func(this, new ZoomEventArgs(direction));
}
}
private double GetNewValue(double value, double factor, ZoomDirection direction)
{
if (direction == ZoomDirection.In)
{
return(value / factor);
}
return(value * factor);
}
public override void ZoomMove(string VideoSource, ZoomDirection Direction, string Timeout)
{
ParametersValidation validation = new ParametersValidation();
validation.Add(ParameterType.String, "VideoSource", VideoSource);
validation.Add(ParameterType.OptionalString, "Timeout", Timeout);
validation.Add(ParameterType.String, "Direction", Direction.ToString());
ExecuteVoidCommand(validation, ProvisioningServiceTest.ZoomMoveTest);
}
private void OnSeriesEnd(ZoomDirection direction)
{
var ev = direction == ZoomDirection.In ? StEvent.SceneZoomedIn : StEvent.SceneZoomedOut;
UISharedRTClient.Instance.clienRt.SendStatsEvent(ev,
SessionInfo.Get().person.Id,
SessionInfo.Get().discussion.Id,
topicNavPanel.selectedTopic.Id,
DeviceType.Wpf);
}
//private Duration AnimationDuration
//{
// get { return new Duration(TimeSpan.FromMilliseconds(300)); }
//}
public void SwitchViews(ZoomDirection direction)
{
_switchOut.IsHitTestVisible = false;
_switchIn.IsHitTestVisible = false;
if (direction == ZoomDirection.In)
{
ZoomIn(_switchOut, _switchIn);
}
else
{
ZoomOut(_switchOut, _switchIn);
}
}
//private Duration AnimationDuration
//{
// get { return new Duration(TimeSpan.FromMilliseconds(400)); }
//}
public void SwitchViews(ZoomDirection direction)
{
centerX = _switchIn.RenderSize.Width / 2;
centerY = _switchIn.RenderSize.Height / 2;
if (direction == ZoomDirection.In)
{
ZoomIn();
}
else
{
ZoomOut();
}
}
public void InitialiseZoom(ZoomDirection t_direction, float t_zoomSpeed, float t_zoomAmount = 0.0f, float t_timeToZoom = 0.0f, CameraMovementState t_state = CameraMovementState.None)
{
SetZoomDirection(t_direction);
SetInitialZoom(GetPosition().z);
SetTrackingType(TrackingType.None);
SetCameraState(CameraMovementState.None);
SetTimeForZoom(t_timeToZoom);
SetZoomAmount(t_zoomAmount);
SetCurrentZoomSpeed(t_zoomSpeed);
if (t_state != CameraMovementState.None)
{
InitialiseMovement(t_state);
}
}
public override void StopZoom(ZoomDirection direction)
{
switch (direction)
{
case ZoomDirection.In:
ExecuteMethod("actZoom", "in", "stop");
break;
case ZoomDirection.Out:
ExecuteMethod("actZoom", "out", "stop");
break;
default:
throw new ArgumentOutOfRangeException(nameof(direction), direction, null);
}
}
private double CalculateModifiedZoom(double currentLinearZoom, ZoomDirection zoomDirection, double zoomAmount)
{
var zoomSign = zoomDirection == ZoomDirection.In ? 1 : -1;
var newLinearZoom = currentLinearZoom + zoomAmount * zoomSign;
if (newLinearZoom < MinZoom)
{
newLinearZoom = MinZoom;
}
if (newLinearZoom > MaxZoom)
{
newLinearZoom = MaxZoom;
}
return(newLinearZoom);
}
public void Zoom(ZoomDirection direction, Point zoomCenter)
{
// scale everything
double scale = ZoomScale;
switch (direction)
{
case ZoomDirection.In:
scale = 1.0 / scale;
break;
case ZoomDirection.Out:
break;
}
// center zoom operation on mouse
lastPointerPosition = zoomCenter;
var vp = _workspace.ActiveViewPort;
var oldHeight = vp.ViewHeight;
var oldWidth = Width * oldHeight / Height;
var newHeight = oldHeight * scale;
var newWidth = oldWidth * scale;
var heightDelta = newHeight - oldHeight;
var widthDelta = newWidth - oldWidth;
var relHoriz = zoomCenter.X / Width;
var relVert = (Height - zoomCenter.Y) / Height;
var botLeftDelta = new Vector(relHoriz * widthDelta, relVert * heightDelta, 0.0);
var newVp = vp.Update(
bottomLeft: (Point)(vp.BottomLeft - botLeftDelta),
viewHeight: vp.ViewHeight * scale);
_workspace.Update(activeViewPort: newVp);
updateSnapPointsTask.ContinueWith(_ =>
{
var snapPoint = GetActiveModelPoint(zoomCenter, updateSnapPointsCancellationTokenSource.Token);
CursorWorldLocationUpdated?.Invoke(this, snapPoint.WorldPoint);
if ((_workspace.InputService.AllowedInputTypes & InputType.Point) == InputType.Point)
{
DrawSnapPoint(snapPoint, GetNextDrawSnapPointId());
}
}).ConfigureAwait(false);
}
public void ChangeZoom(ZoomDirection zoomDirection)
{
if (!isNextZoomLevelWithinLimit(zoomDirection))
{
return;
}
if (zoomDirection == ZoomDirection.In)
{
CustomMap.Instance.Zoom += zoomResponsiveness;
}
else if (zoomDirection == ZoomDirection.Out)
{
CustomMap.Instance.Zoom -= zoomResponsiveness;
}
InteractibleMap.Instance.HideTablesAndObjects();
RemoveAllTiles();
StartCoroutine(LoadNewTiles());
}
public void Zoom(ZoomDirection direction, ZoomAmount amount)
{
int boxSize = 200;
if (amount == ZoomAmount.Short)
{
boxSize = 750;
}
else if (amount == ZoomAmount.Medium)
{
boxSize = 250;
}
else if (amount == ZoomAmount.Long)
{
boxSize = 50;
}
HttpPost(url, GetPTZJSONString("34323638666239302D396463362D3131", 500, 500, boxSize, boxSize, direction == ZoomDirection.In));
}
public void SubmitStep(ZoomDirection direction)
{
_timer.Stop();
_timer.Start();
if (SeriesNonEmpty() && direction != _currentDirection)
{
_numSteps = 0;
_end(_currentDirection);
}
else
{
_numSteps++;
}
if (direction != _currentDirection)
{
_currentDirection = direction;
}
}
public void SubmitStep(ZoomDirection direction)
{
_timer.Stop();
_timer.Start();
if (SeriesNonEmpty() && direction != _currentDirection)
{
_numSteps = 0;
_end(_currentDirection);
}
else
{
_numSteps++;
}
if (direction != _currentDirection)
{
_currentDirection = direction;
}
}
private ZoomDirection AdjustScale(ZoomDirection direction, ScaleTransform scale, bool mouseOver, Storyboard timer)
{
if (direction == ZoomDirection.In)
{
if (scale.ScaleX < 1.3)
{
scale.ScaleX += 0.05;
scale.ScaleY += 0.05;
}
else if (mouseOver == false)
{
direction = ZoomDirection.Out;
}
}
else if (scale.ScaleX > 1.0)
{
scale.ScaleX -= 0.05;
scale.ScaleY -= 0.05;
}
timer.Begin();
return(direction);
}
public void Zoom(ZoomDirection dir, bool animate = false)
{
if (animate)
{
var factor = (dir == ZoomDirection.In) ? _zoomInFactor : _zoomOutFactor;
ValueAnimation zoomAnimation = new ValueAnimation();
zoomAnimation.InterpolationMethod = InterpMethod.Linear;
zoomAnimation.SetKeyFrame(0.0f, App.Camera.Zoom);
zoomAnimation.SetKeyFrame(0.3f, App.Camera.Zoom * factor);
ObjectAnimation cameraAnimation = new ObjectAnimation();
cameraAnimation.AddAttributeAnimation("Zoom", zoomAnimation, WrapMode.Once, 1f);
App.Camera.ObjectAnimation = cameraAnimation;
}
else
{
var factor = (dir == ZoomDirection.In) ? _zoomInFactorSmall : _zoomOutFactorSmall;
App.Camera.Zoom *= factor;
}
}
private bool isNextZoomLevelWithinLimit(ZoomDirection zoom)
{
int levelAfterZoom = 0;
switch (zoom)
{
case ZoomDirection.Out:
levelAfterZoom = CustomMap.Instance.Zoom - zoomResponsiveness;
break;
case ZoomDirection.In:
levelAfterZoom = CustomMap.Instance.Zoom + zoomResponsiveness;
break;
}
if (levelAfterZoom > maxZoomLevel || levelAfterZoom < minZoomLevel)
{
return(false);
}
else
{
return(true);
}
}
public void Zoom(ZoomDirection direction)
{
Logger.LogInfo(nameof(SurfaceHolderCallback), nameof(Zoom), "called.");
Logger.LogInfo(nameof(SurfaceHolderCallback), nameof(Zoom), " direction is: " + direction.ToString());
if (_Camera != null)
{
if (SupportsZoom())
{
Logger.LogInfo(nameof(SurfaceHolderCallback), nameof(Zoom), "zoom is supported.");
switch (direction)
{
case ZoomDirection.In:
if (_Parameters.Zoom < _Parameters.MaxZoom)
{
_Parameters.Zoom++;
_Camera.SetParameters(_Parameters);
}
break;
case ZoomDirection.Out:
if (_Parameters.Zoom != 0)
{
_Parameters.Zoom--;
_Camera.SetParameters(_Parameters);
}
break;
default:
return;
}
Logger.LogInfo(nameof(SurfaceHolderCallback), nameof(Zoom), "Zoom set to: " + _Parameters.Zoom.ToString());
}
}
}
public abstract void ZoomMove(string VideoSource, ZoomDirection Direction, [System.Xml.Serialization.XmlElementAttribute(DataType = "duration")] string Timeout);
protected bool IsZoomLimitReached(ZoomDirection zoomDirection)
{
return((zoomDirection == ZoomDirection.In && ZoomValue >= MaxZoom) ||
(zoomDirection == ZoomDirection.Out && ZoomValue <= MinZoom));
}
protected void Zoom(ZoomDirection direction, double amount, Point center)
{
ZoomCommand?.Execute(direction, amount, center);
}
private void ZoomTo(ZoomDirection direction, double amount, Point center, TransitionSpeed transitionSpeed)
{
var newLinearZoom = CalculateModifiedZoom(ViewportZoom, direction, amount);
ZoomWithCenterTo(newLinearZoom, center, transitionSpeed);
}
private void OnMouseZoom(ZoomDirection direction, double amount, Point center) => ZoomTo(direction, amount, center, TransitionSpeed.Fast);
/// <inheritdoc cref="IMapFactory{TDrawingContext}.Zoom(LvcPoint, ZoomDirection)"/>
public void Zoom(LvcPoint pivot, ZoomDirection direction)
{
// not implemented yet.
}
/// <summary>
/// Initializes a new instance of the <see cref="ZoomOnPointerView"/> command.
/// </summary>
/// <param name="pivot">The pivot.</param>
/// <param name="direction">The direction.</param>
public ZoomOnPointerView(LvcPoint pivot, ZoomDirection direction)
{
Pivot = pivot;
Direction = direction;
}
public EffectsBuilder Zoom(ZoomDirection direction)
{
return Add(EffectsList.Zoom, direction.ToString().ToLower());
}
private void OnSeriesEnd(ZoomDirection direction)
{
var ev = direction == ZoomDirection.In ? StEvent.SceneZoomedIn : StEvent.SceneZoomedOut;
UISharedRTClient.Instance.clienRt.SendStatsEvent(ev,
SessionInfo.Get().person.Id,
SessionInfo.Get().discussion.Id,
topicNavPanel.selectedTopic.Id,
DeviceType.Wpf);
}
public void SetZoomDirection(ZoomDirection t_zoomDirection)
{
m_zoomDirection = t_zoomDirection;
}
public EffectsBuilder Zoom(ZoomDirection direction)
{
return(Add(EffectsList.Zoom, direction.ToString().ToLower()));
}
public ZoomedEventArgs(Geometries.Point screenPosition, ZoomDirection direction)
{
ScreenPosition = screenPosition;
Direction = direction;
}
private ZoomDirection AdjustScale(ZoomDirection direction, ScaleTransform scale, bool mouseOver, Storyboard timer)
{
if (direction == ZoomDirection.In)
{
if (scale.ScaleX < 1.3)
{
scale.ScaleX += 0.05;
scale.ScaleY += 0.05;
}
else if (mouseOver == false)
{
direction = ZoomDirection.Out;
}
}
else if (scale.ScaleX > 1.0)
{
scale.ScaleX -= 0.05;
scale.ScaleY -= 0.05;
}
timer.Begin();
return direction;
}
private void Timer_Completed(object sender, EventArgs e)
{
Direction = AdjustScale(Direction, ScaleTransform, IsMouseOver, Timer);
}
public void Zoom(ZoomDirection direction, ZoomAmount amount)
{
PTZProfile profile = GetProfile();
if (profile == null)
{
return;
}
if (typeof(PTZSpecV1) == profile.spec.GetType())
{
PTZSpecV1 spec = (PTZSpecV1)profile.spec;
string url = null;
int waitTime = 0;
if (direction == ZoomDirection.In)
{
if (amount == ZoomAmount.Short && !string.IsNullOrWhiteSpace(spec.zoomInShort))
{
waitTime = spec.ZoomRunTimeShortMs;
url = spec.zoomInShort;
}
else if (amount == ZoomAmount.Medium && !string.IsNullOrWhiteSpace(spec.zoomInMedium))
{
waitTime = spec.ZoomRunTimeMediumMs;
url = spec.zoomInMedium;
}
else if (amount == ZoomAmount.Long && !string.IsNullOrWhiteSpace(spec.zoomInLong))
{
waitTime = spec.ZoomRunTimeLongMs;
url = spec.zoomInLong;
}
}
else if (direction == ZoomDirection.Out)
{
if (amount == ZoomAmount.Short && !string.IsNullOrWhiteSpace(spec.zoomOutShort))
{
waitTime = spec.ZoomRunTimeShortMs;
url = spec.zoomOutShort;
}
else if (amount == ZoomAmount.Medium && !string.IsNullOrWhiteSpace(spec.zoomOutMedium))
{
waitTime = spec.ZoomRunTimeMediumMs;
url = spec.zoomOutMedium;
}
else if (amount == ZoomAmount.Long && !string.IsNullOrWhiteSpace(spec.zoomOutLong))
{
waitTime = spec.ZoomRunTimeLongMs;
url = spec.zoomOutLong;
}
}
if (string.IsNullOrWhiteSpace(url))
{
return;
}
SimpleProxy.GetData(urlBase + url, camSpec.ptz_username, camSpec.ptz_password);
if (spec.SendStopCommandAfterZoom && !string.IsNullOrWhiteSpace(spec.stopZoom))
{
Thread.Sleep(waitTime);
SimpleProxy.GetData(urlBase + spec.stopZoom, camSpec.ptz_username, camSpec.ptz_password);
}
}
}
